From 03e9649064f19a4448b1abe40114af96542e46c6 Mon Sep 17 00:00:00 2001 From: Abdulaziz Ghuloum Date: Thu, 23 Nov 2006 19:42:39 -0500 Subject: [PATCH] imported compiler3 --- src/Makefile | 2 +- src/build-date.tmp | 2 +- src/compiler-6.1.ss | 2 +- src/compiler-6.2.ss | 3185 ++ src/ikarus.fasl | Bin 766162 -> 810086 bytes src/libassembler-compat-6.0.ss | 2 +- src/libcafe.fasl | Bin 14227 -> 14375 bytes src/libcollect-6.1.ss | 36 + src/libcollect.fasl | Bin 3426 -> 4634 bytes src/libcontrol.fasl | Bin 17155 -> 17535 bytes src/libcore-6.2.ss | 1628 + src/libcore.fasl | Bin 193705 -> 197895 bytes src/libcxr.fasl | Bin 2719 -> 21945 bytes src/libexpand-6.2.ss | 1099 + src/libexpand.fasl | Bin 209928 -> 222049 bytes src/libfasl-6.0.ss | 34 +- src/libhandlers.fasl | Bin 4941 -> 4843 bytes src/libhash-6.2.ss | 200 + src/libintelasm-6.0.ss | 13 + src/libinterpret.fasl | Bin 48841 -> 49149 bytes src/libio.fasl | Bin 83419 -> 84765 bytes src/librecord.fasl | Bin 30001 -> 30937 bytes src/libsyncase-6.2.ss | 534 + src/libtokenizer.fasl | Bin 75818 -> 76558 bytes src/libtoplevel.fasl | Bin 1061 -> 1061 bytes src/libwriter-6.2.ss | 373 + src/libwriter.fasl | Bin 60795 -> 61884 bytes src/makepp.ss | 34 + src/petite-ikarus.fasl | Bin 736 -> 736 bytes src/psyntax-7.1.pp | 10704 ++++++ src/psyntax-7.1.ss | 4424 +++ src/runtime/Makefile | 29 +- src/runtime/ikarus | Bin 72283 -> 83575 bytes src/runtime/ikarus-collect.c | 1132 +- src/runtime/ikarus-data.h | 13 + src/runtime/ikarus-enter.s | 26 +- src/runtime/ikarus-exec.c | 3 + src/runtime/ikarus-fasl.c | 57 +- src/runtime/ikarus-runtime.c | 200 +- src/runtime/ikarus-weak-pairs.c | 37 + src/runtime/ikarus.h | 72 +- src/xpsyntax.pp | 55957 ++++++++++++++++++++++++++++++ 42 files changed, 79264 insertions(+), 534 deletions(-) create mode 100644 src/compiler-6.2.ss create mode 100644 src/libcollect-6.1.ss create mode 100644 src/libcore-6.2.ss create mode 100644 src/libexpand-6.2.ss create mode 100644 src/libhash-6.2.ss create mode 100644 src/libsyncase-6.2.ss create mode 100644 src/libwriter-6.2.ss create mode 100644 src/makepp.ss create mode 100644 src/psyntax-7.1.pp create mode 100644 src/psyntax-7.1.ss create mode 100644 src/runtime/ikarus-weak-pairs.c create mode 100644 src/xpsyntax.pp diff --git a/src/Makefile b/src/Makefile index 46f9303..aa9bfa2 100644 --- a/src/Makefile +++ b/src/Makefile @@ -2,7 +2,7 @@ all: ikarus.fasl ikarus.fasl: - echo '(load "compiler-6.1.ss")' | petite + echo '(load "compiler-6.2.ss")' | petite clean: rm -f *.fasl diff --git a/src/build-date.tmp b/src/build-date.tmp index fe1b341..597f7df 100644 --- a/src/build-date.tmp +++ b/src/build-date.tmp @@ -1 +1 @@ -2006-07-28 +2006-08-02 diff --git a/src/compiler-6.1.ss b/src/compiler-6.1.ss index 76ea6c2..e3d5847 100644 --- a/src/compiler-6.1.ss +++ b/src/compiler-6.1.ss @@ -61,7 +61,7 @@ (define scheme-library-files '(["libhandlers-6.0.ss" "libhandlers.fasl"] ["libcontrol-6.1.ss" "libcontrol.fasl"] - ["libcollect-6.0.ss" "libcollect.fasl"] + ["libcollect-6.1.ss" "libcollect.fasl"] ["librecord-6.1.ss" "librecord.fasl"] ["libcxr-6.0.ss" "libcxr.fasl"] ["libcore-6.1.ss" "libcore.fasl"] diff --git a/src/compiler-6.2.ss b/src/compiler-6.2.ss new file mode 100644 index 0000000..30649cc --- /dev/null +++ b/src/compiler-6.2.ss @@ -0,0 +1,3185 @@ + + +;;; 6.2: * side-effects now modify the dirty-vector +;;; * added bwp-object? +;;; * added pointer-value +;;; * added tcbuckets +;;; 6.1: * added case-lambda, dropped lambda +;;; 6.0: * basic compiler + +(when (eq? "" "") + (load "chez-compat.ss") + (set! primitive-ref top-level-value) + (load "libexpand-6.2.ss") + ;(load "libinterpret-6.0.ss") + (load "record-case.ss") + ;(#%current-eval eval) + ) + +(define primitive-set! set-top-level-value!) + +(load "libassembler-compat-6.0.ss") ; defines make-code etc. +(load "libintelasm-6.0.ss") ; uses make-code, etc. +(load "libfasl-6.0.ss") ; uses code? etc. + + + +(load "tests-driver.ss") +(print-gensym #f) +(gensym-prefix "L_") + + +(define assembler-output (make-parameter #t)) + +(load "set-operations.ss") +;(load "tests-5.6-req.scm") +;(load "tests-5.3-req.scm") +;(load "tests-5.2-req.scm") +;(load "tests-5.1-req.scm") +;(load "tests-4.3-req.scm") +;(load "tests-4.2-req.scm") + +;(load "tests-4.1-req.scm") +;(load "tests-3.4-req.scm") + +;(load "tests-3.3-req.scm") +;(load "tests-3.2-req.scm") +;(load "tests-3.1-req.scm") +;(load "tests-2.9-req.scm") +;(load "tests-2.8-req.scm") +;(load "tests-2.6-req.scm") +;(load "tests-2.4-req.scm") +;(load "tests-2.3-req.scm") +;(load "tests-2.2-req.scm") +;(load "tests-2.1-req.scm") +;(load "tests-1.9-req.scm") +;(load "tests-1.8-req.scm") +;(load "tests-1.7-req.scm") +;(load "tests-1.6-req.scm") +;(load "tests-1.5-req.scm") +;(load "tests-1.4-req.scm") +;(load "tests-1.3-req.scm") +;(load "tests-1.2-req.scm") +;(load "tests-1.1-req.scm") + + +(define scheme-library-files + '(["libhandlers-6.0.ss" "libhandlers.fasl"] + ["libcontrol-6.1.ss" "libcontrol.fasl"] + ["libcollect-6.1.ss" "libcollect.fasl"] + ["librecord-6.1.ss" "librecord.fasl"] + ["libcxr-6.0.ss" "libcxr.fasl"] + ["libcore-6.2.ss" "libcore.fasl"] + ["libio-6.1.ss" "libio.fasl"] + ["libwriter-6.2.ss" "libwriter.fasl"] + ["libtokenizer-6.1.ss" "libtokenizer.fasl"] + ["libexpand-6.2.ss" "libexpand.fasl"] + ["libinterpret-6.1.ss" "libinterpret.fasl"] + ;["libintelasm-6.0.ss" "libintelasm.fasl"] + ["libcafe-6.1.ss" "libcafe.fasl"] +; ["libtrace-5.3.ss" "libtrace-5.3.s" "libtrace" ] + ["libposix-6.0.ss" "libposix.fasl"] + ["libhash-6.2.ss" "libhash.fasl"] + ["libtoplevel-6.0.ss" "libtoplevel.fasl"] + )) + +(define primitive? + (lambda (x) + (or (assq x open-coded-primitives) + (memq x public-primitives)))) + +(define open-coded-primitives +;;; these primitives, when found in operator position with the correct +;;; number of arguments, will be open-coded by the generator. If an +;;; incorrect number of args is detected, or if they appear in non-operator +;;; position, then they cannot be open-coded, and the pcb-primitives table +;;; is consulted for a reference of the pcb slot containing the primitive. +;;; If it's not found there, an error is signalled. +;;; +;;; prim-name args + '([$constant-ref 1 value] + [$constant-set! 2 effect] + [$pcb-ref 1 value] + [$pcb-set! 2 effect] + ;;; type predicates + [fixnum? 1 pred] + [immediate? 1 pred] + [boolean? 1 pred] + [char? 1 pred] + [pair? 1 pred] + [symbol? 1 pred] + [vector? 1 pred] + [string? 1 pred] + [procedure? 1 pred] + [null? 1 pred] + [eof-object? 1 pred] + [bwp-object? 1 pred] + [$unbound-object? 1 pred] + [$forward-ptr? 1 pred] + [not 1 pred] + [pointer-value 1 value] + [eq? 2 pred] + ;;; fixnum primitives + [$fxadd1 1 value] + [$fxsub1 1 value] + [$fx+ 2 value] + [$fx- 2 value] + [$fx* 2 value] + [$fxsll 2 value] + [$fxsra 2 value] + [$fxlogand 2 value] + [$fxlogor 2 value] + [$fxlogxor 2 value] + [$fxlognot 1 value] + [$fxquotient 2 value] + [$fxmodulo 2 value] + ;;; fixnum predicates + [$fxzero? 1 pred] + [$fx= 2 pred] + [$fx< 2 pred] + [$fx<= 2 pred] + [$fx> 2 pred] + [$fx>= 2 pred] + ;;; character predicates + [$char= 2 pred] + [$char< 2 pred] + [$char<= 2 pred] + [$char> 2 pred] + [$char>= 2 pred] + ;;; character conversion + [$fixnum->char 1 value] + [$char->fixnum 1 value] + ;;; lists/pairs + [cons 2 value] + [$car 1 value] + [$cdr 1 value] + [$set-car! 2 effect] + [$set-cdr! 2 effect] + ;;; vectors + [$make-vector 1 value] + [vector any value] + [$vector-length 1 value] + [$vector-ref 2 value] + [$vector-set! 3 effect] + ;;; strings + [$make-string 1 value] + [$string any value] + [$string-length 1 value] + [$string-ref 2 value] + [$string-set! 3 effect] + ;;; symbols + [$make-symbol 1 value] + [$symbol-value 1 value] + [$symbol-string 1 value] + [$symbol-unique-string 1 value] + [$set-symbol-value! 2 effect] + [$set-symbol-string! 2 effect] + [$set-symbol-unique-string! 2 effect] + [$symbol-plist 1 value] + [$set-symbol-plist! 2 effect] + [primitive-ref 1 value] + [primitive-set! 2 effect] + ;;; tcbuckets + [$make-tcbucket 4 value] + [$tcbucket-key 1 value] + [$tcbucket-val 1 value] + [$tcbucket-next 1 value] + [$set-tcbucket-val! 2 effect] + [$set-tcbucket-next! 2 effect] + [$set-tcbucket-tconc! 2 effect] + ;;; misc + [eof-object 0 value] + [void 0 value] + [$exit 1 effect] + [$fp-at-base 0 pred] + [$current-frame 0 value] + [$seal-frame-and-call 1 tail] + [$frame->continuation 1 value] + ;;; + ;;; records + ;;; + [$make-record 2 value] + [$record? 1 pred] + [$record-rtd 1 value] + [$record-ref 2 value] + [$record-set! 3 effect] + ;;; + ;;; asm + ;;; + ;[code? 1 pred] + ;[$code-instr-size 1 value] + ;[$code-reloc-size 1 value] + ;[$code-closure-size 1 value] + ;[$code->closure 1 value] + ;[$set-code-byte! 3 effect] + ;[$set-code-word! 3 effect] + ;[$set-code-object! 4 effect] + ;[$set-code-object+offset! 5 effect] + ;[$set-code-object+offset/rel! 5 effect] + ;;; + [$make-call-with-values-procedure 0 value] + [$make-values-procedure 0 value] + [$install-underflow-handler 0 effect] + )) + +(define (primitive-context x) + (cond + [(assq x open-coded-primitives) => caddr] + [else (error 'primitive-context "unknown prim ~s" x)])) + + +;;; primitives table section +(define primitives-table + '(;;; system locations used by the C/Scheme interface + [$apply-nonprocedure-error-handler library] + [$incorrect-args-error-handler library] + [$multiple-values-error library] + [$intern library] + [do-overflow library] + [do-vararg-overflow library] + [do-stack-overflow library] + ;;; type predicates + [fixnum? public] + [immediate? public] + [boolean? public] + [char? public] + [null? public] + [pair? public] + [symbol? public] + [vector? public] + [string? public] + [procedure? public] + [eof-object? public] + [not public] + [eq? public] + [equal? public] + ;;; fixnum primitives + [fxadd1 public] + [fxsub1 public] + [fx+ public] + [fx- public] + [fx* public] + [fxsll public] + [fxsra public] + [fxlogor public] + [fxlogand public] + [fxlogxor public] + [fxlognot public] + [fxquotient public] + [fxremainder public] + [fxmodulo public] + ;;; fixnum predicates + [fxzero? public] + [fx= public] + [fx< public] + [fx<= public] + [fx> public] + [fx>= public] + ;;; characters + [char=? public] + [char? public] + [char>=? public] + [integer->char public] + [char->integer public] + ;;; lists + [cons public] + [car public] + [cdr public] + [caar public] + [cadr public] + [cdar public] + [cddr public] + [caaar public] + [caadr public] + [cadar public] + [caddr public] + [cdaar public] + [cdadr public] + [cddar public] + [cdddr public] + [caaaar public] + [caaadr public] + [caadar public] + [caaddr public] + [cadaar public] + [cadadr public] + [caddar public] + [cadddr public] + [cdaaar public] + [cdaadr public] + [cdadar public] + [cdaddr public] + [cddaar public] + [cddadr public] + [cdddar public] + [cddddr public] + [set-car! public] + [set-cdr! public] + [list public] + [list* ADDME] + [list? public] + [list-ref public] + [length public] + [make-list public] + [reverse public] + [append public] + [list-ref public] + [memq public] + [assq public] + [map public] + [for-each public] + [andmap public] + [ormap public] + ;;; vectors + [make-vector public] + [vector public] + [vector-length public] + [vector-ref public] + [vector-set! public] + [list->vector public] + [vector->list public] + ;;; strings + [make-string public] + [string public] + [string-length public] + [string-ref public] + [string-set! public] + [list->string public] + [string->list public] + [string-append public] + [substring public] + [string=? public] + [fixnum->string public] + ;;; symbols + [gensym public] + [gensym? public] + [symbol->string public] + [gensym->unique-string public] + [gensym-prefix public] + [gensym-count public] + [print-gensym public] + [string->symbol public] + [top-level-value public] + [top-level-bound? public] + [set-top-level-value! public] + [primitive-set! public] + [getprop public] + [putprop public] + [remprop public] + [property-list public] + [oblist public] + [uuid public] + ;;; eof + [eof-object public] + [void public] + ;;; control/debugging + [print-error public] + [error public] + [current-error-handler public] + [exit public] + [apply public] + [make-parameter public] + ;;; output + [output-port? public] + [console-output-port public] + [current-output-port public] + [standard-output-port public] + [standard-error-port public] + [open-output-file public] + [open-output-string public] + [with-output-to-file public] + [call-with-output-file public] + [with-input-from-file public] + [call-with-input-file public] + [get-output-string public] + [close-output-port public] + [flush-output-port public] + [write-char public] + [output-port-name public] + [newline public] + ;;; input + [input-port? public] + [standard-input-port public] + [console-input-port public] + [current-input-port public] + [open-input-file public] + [close-input-port public] + [reset-input-port! public] + [read-char public] + [peek-char public] + [unread-char public] + [input-port-name public] + ;;; writing/printing + [write public] + [display public] + [printf public] + [fprintf public] + [format public] + [read-token public] + [read public] + ;;; evaluation + [primitive? public] + [expand public] + [syntax-error public] + [core-expand public] + [current-expand public] + + [$sc-put-cte public] + [sc-expand public] + [$make-environment public] + [environment? public] + [interaction-environment public] + [identifier? public] + [syntax->list public] + [syntax-object->datum public] + [datum->syntax-object public] + [generate-temporaries public] + [free-identifier=? public] + [bound-identifier=? public] + [literal-identifier=? public] + [syntax-error public] + [$syntax-dispatch public] + + + + [interpret public] + [eval public] + [current-eval public] + [load public] + [new-cafe public] + [collect public] + [call/cc public] + [call/cf library] + [dynamic-wind public] + [values public] + [call-with-values public] + [make-traced-procedure library] + [trace-symbol! library] + [untrace-symbol! library] + ;;; record + [$base-rtd library] + [record? public] + [record-rtd public] + [record-name public] + [record-printer public] + [record-length public] + [record-ref public] + [record-set! public] + ;;; record rtds + [make-record-type public] + [record-constructor public] + [record-predicate public] + [record-field-accessor public] + [record-field-mutator public] + ;;; hash tables + [make-hash-table public] + [hash-table? public] + [get-hash-table public] + [put-hash-table! public] + ;;; asm + [make-code public] + [code? public] + [make-code-executable! public] + [code-instr-size public] + [code-reloc-size public] + [code-closure-size public] + [set-code-byte! public] + [set-code-word! public] + [set-code-object! public] + [set-code-foreign-object! public] + [set-code-object+offset! public] + [set-code-object+offset/rel! public] + [set-code-object/reloc/relative! public] + [code->closure public] + [list*->code* library] + ;;; + ;;; POSIX + ;;; + [fork public] + [posix-fork public] + [system public] + [$debug public] + [$underflow-misaligned-error public] + )) + +(define (primitive? x) + (cond + [(assq x primitives-table) #t] + [(assq x open-coded-primitives) #t] + [else #f])) + +(define (open-codeable? x) + (cond + [(assq x open-coded-primitives) #t] + [(assq x primitives-table) #f] + [else (error 'open-codeable "invalid primitive ~s" x)])) + +(define (open-coded-primitive-args x) + (cond + [(assq x open-coded-primitives) => cadr] + [else (error 'open-coded-primitive-args "invalid ~s" x)])) + +;;; end of primitives table section + + +(define-record constant (value)) +(define-record code-loc (label)) +(define-record foreign-label (label)) +(define-record var (name)) +(define-record cp-var (idx)) +(define-record frame-var (idx)) +(define-record new-frame (base-idx size body)) +(define-record save-cp (loc)) +(define-record eval-cp (check body)) +(define-record return (value)) +(define-record call-cp + (call-convention rp-convention base-idx arg-count live-mask)) +(define-record primcall (op arg*)) +(define-record primref (name)) +(define-record conditional (test conseq altern)) +(define-record bind (lhs* rhs* body)) +(define-record seq (e0 e1)) +(define-record function (arg* proper body)) +(define-record clambda-case (arg* proper body)) +(define-record clambda (cases)) +(define-record clambda-code (label cases free)) + +(define-record closure (code free*)) +(define-record funcall (op rand*)) +(define-record appcall (op rand*)) +(define-record forcall (op rand*)) +(define-record code-rec (arg* proper free* body)) + +(define-record codes (list body)) +(define-record assign (lhs rhs)) + +(define unique-var + (let ([counter 0]) + (lambda (x) + (let ([g (gensym (format "~a:~a" x counter))]) + (set! counter (fxadd1 counter)) + (make-var g))))) + +(define (make-bind^ lhs* rhs* body) + (if (null? lhs*) + body + (make-bind lhs* rhs* body))) + +(define (recordize x) + (define (gen-fml* fml*) + (cond + [(pair? fml*) + (cons (unique-var (car fml*)) + (gen-fml* (cdr fml*)))] + [(symbol? fml*) + (unique-var fml*)] + [else '()])) + (define (properize fml*) + (cond + [(pair? fml*) + (cons (car fml*) (properize (cdr fml*)))] + [(null? fml*) '()] + [else (list fml*)])) + (define (extend-env fml* nfml* env) + (cons (cons fml* nfml*) env)) + (define (quoted-sym x) + (if (and (list? x) + (fx= (length x) 2) + (eq? 'quote (car x)) + (symbol? (cadr x))) + (cadr x) + (error 'quoted-sym "not a quoted symbol ~s" x))) + (define (quoted-string x) + (if (and (list? x) + (fx= (length x) 2) + (eq? 'quote (car x)) + (string? (cadr x))) + (cadr x) + (error 'quoted-string "not a quoted string ~s" x))) + (define (lookup^ x lhs* rhs*) + (cond + [(pair? lhs*) + (if (eq? x (car lhs*)) + (car rhs*) + (lookup^ x (cdr lhs*) (cdr rhs*)))] + [(eq? x lhs*) rhs*] + [else #f])) + (define (lookup x env) + (cond + [(pair? env) + (or (lookup^ x (caar env) (cdar env)) + (lookup x (cdr env)))] + [else #f])) + (define (E x env) + (cond + [(pair? x) + (case (car x) + [(quote) (make-constant (cadr x))] + [(if) + (make-conditional + (E (cadr x) env) + (E (caddr x) env) + (E (cadddr x) env))] + [(set!) + (let ([lhs (cadr x)] [rhs (caddr x)]) + (make-assign + (or (lookup lhs env) + (error 'recordize "invalid assignment ~s" x)) + (E rhs env)))] + [(begin) + (let f ([a (cadr x)] [d (cddr x)]) + (cond + [(null? d) (E a env)] + [else + (make-seq + (E a env) + (f (car d) (cdr d)))]))] + [(case-lambda) + (let ([cls* + (map + (lambda (cls) + (let ([fml* (car cls)] [body (cadr cls)]) + (let ([nfml* (gen-fml* fml*)]) + (let ([body (E body (extend-env fml* nfml* env))]) + (make-clambda-case + (properize nfml*) + (list? fml*) + body))))) + (cdr x))]) + (make-clambda cls*))] + [(foreign-call) + (let ([name (quoted-string (cadr x))] [arg* (cddr x)]) + (make-forcall name + (map (lambda (x) (E x env)) arg*)))] + [(|#primitive|) + (let ([var (cadr x)]) + (if (primitive? var) + (make-primref var) + (error 'recordize "invalid primitive ~s" var)))] + [(top-level-value) + (let ([var (quoted-sym (cadr x))]) + (if (primitive? var) + (make-primref var) + (error 'recordize "invalid top-level var ~s" var)))] + [(memv) + (make-funcall + (make-primref 'memq) + (map (lambda (x) (E x env)) (cdr x)))] + [($apply) + (let ([proc (cadr x)] [arg* (cddr x)]) + (make-appcall + (E proc env) + (map (lambda (x) (E x env)) arg*)))] + [(void) + (make-constant (void))] + [else + (make-funcall + (E (car x) env) + (map (lambda (x) (E x env)) (cdr x)))])] + [(symbol? x) + (or (lookup x env) + (error 'recordize "invalid reference in ~s" x))] + [else (error 'recordize "invalid expression ~s" x)])) + (E x '())) + + +(define (unparse x) + (define (E-args proper x) + (if proper + (map E x) + (let f ([a (car x)] [d (cdr x)]) + (cond + [(null? d) (E a)] + [else (cons (E a) (f (car d) (cdr d)))])))) + (define (E x) + (record-case x + [(constant c) `(quote ,c)] + [(code-loc x) `(code-loc ,x)] + [(var x) (string->symbol (format "v:~a" x))] + [(primref x) x] + [(conditional test conseq altern) + `(if ,(E test) ,(E conseq) ,(E altern))] + [(primcall op arg*) `(,op . ,(map E arg*))] + [(bind lhs* rhs* body) + `(let ,(map (lambda (lhs rhs) (list (E lhs) (E rhs))) lhs* rhs*) + ,(E body))] + [(seq e0 e1) `(begin ,(E e0) ,(E e1))] + [(function args proper body) + `(lambda ,(E-args proper args) ,(E body))] + [(clambda-case args proper body) + `(clambda-case ,(E-args proper args) ,(E body))] + [(clambda cls*) + `(case-lambda . ,(map E cls*))] + [(clambda-code label clauses free) + `(code ,label . ,(map E clauses))] + [(closure code free*) + `(closure ,(E code) ,(map E free*))] + [(code-rec arg* proper free* body) + `(code-rec [arg: ,(E-args proper arg*)] + [free: ,(map E free*)] + ,(E body))] + [(codes list body) + `(codes ,(map E list) + ,(E body))] + [(funcall rator rand*) `(funcall ,(E rator) . ,(map E rand*))] + [(appcall rator rand*) `(appcall ,(E rator) . ,(map E rand*))] + [(forcall rator rand*) `(foreign-call ,rator . ,(map E rand*))] + [(assign lhs rhs) `(set! ,(E lhs) ,(E rhs))] + [(return x) `(return ,(E x))] + [(new-frame base-idx size body) + `(new-frame [base: ,base-idx] + [size: ,size] + ,(E body))] + [(frame-var idx) + (string->symbol (format "fv.~a" idx))] + [(cp-var idx) + (string->symbol (format "cp.~a" idx))] + [(save-cp expr) + `(save-cp ,(E expr))] + [(eval-cp check body) + `(eval-cp ,check ,(E body))] + [(call-cp call-convention rp-convention base-idx arg-count live-mask) + `(call-cp [conv: ,call-convention] + [rpconv: ,rp-convention] + [base-idx: ,base-idx] + [arg-count: ,arg-count] + [live-mask: ,live-mask])] + [(foreign-label x) `(foreign-label ,x)] + [else (error 'unparse "invalid record ~s" x)])) + (E x)) + +(define (optimize-direct-calls x) + (define who 'optimize-direct-calls) + (define (make-conses ls) + (cond + [(null? ls) (make-constant '())] + [else + (make-primcall 'cons + (list (car ls) (make-conses (cdr ls))))])) + (define (properize lhs* rhs*) + (cond + [(null? lhs*) (error who "improper improper")] + [(null? (cdr lhs*)) + (list (make-conses rhs*))] + [else (cons (car rhs*) (properize (cdr lhs*) (cdr rhs*)))])) + (define (inline-case cls rand*) + (record-case cls + [(clambda-case fml* proper body) + (if proper + (and (fx= (length fml*) (length rand*)) + (make-bind fml* rand* body)) + (and (fx<= (length fml*) (length rand*)) + (make-bind fml* (properize fml* rand*) body)))])) + (define (try-inline cls* rand* default) + (cond + [(null? cls*) default] + [(inline-case (car cls*) rand*)] + [else (try-inline (cdr cls*) rand* default)])) + (define (inline rator rand*) + (record-case rator + [(clambda cls*) + (try-inline cls* rand* + (make-funcall rator rand*))] +; [(function fml* proper body) +; (cond +; [proper +; (if (fx= (length fml*) (length rand*)) +; (make-bind fml* rand* body) +; (begin +; (warning 'compile "possible application error in ~s" +; (unparse (make-funcall rator rand*))) +; (make-funcall rator rand*)))] +; [else +; (if (fx<= (length fml*) (length rand*)) +; (make-bind fml* (properize fml* rand*) body) +; (begin +; (warning 'compile "possible application error in ~s" +; (unparse (make-funcall rator rand*))) +; (make-funcall rator rand*)))])] + [else (make-funcall rator rand*)])) + (define (Expr x) + (record-case x + [(constant) x] + [(var) x] + [(primref) x] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Expr body))] + [(conditional test conseq altern) + (make-conditional + (Expr test) + (Expr conseq) + (Expr altern))] + [(seq e0 e1) + (make-seq (Expr e0) (Expr e1))] + [(function fml* proper body) + (make-function fml* proper (Expr body))] + [(clambda cls*) + (make-clambda + (map (lambda (x) + (record-case x + [(clambda-case fml* proper body) + (make-clambda-case fml* proper (Expr body))])) + cls*))] + [(primcall rator rand*) + (make-primcall rator (map Expr rand*))] + [(funcall rator rand*) + (inline (Expr rator) (map Expr rand*))] + [(appcall rator rand*) + (make-appcall (Expr rator) (map Expr rand*))] + [(forcall rator rand*) + (make-forcall rator (map Expr rand*))] + [(assign lhs rhs) + (make-assign lhs (Expr rhs))] + [else (error who "invalid expression ~s" (unparse x))])) + (Expr x)) + + + +(define (uncover-assigned x) + (define who 'uncover-assigned) + (define (Expr* x*) + (cond + [(null? x*) '()] + [else (union (Expr (car x*)) (Expr* (cdr x*)))])) + (define (Expr x) + (record-case x + [(constant) '()] + [(var) '()] + [(primref) '()] + [(bind lhs* rhs* body) + (union (Expr body) (Expr* rhs*))] + [(conditional test conseq altern) + (union (Expr test) (union (Expr conseq) (Expr altern)))] + [(seq e0 e1) (union (Expr e0) (Expr e1))] + [(clambda cls*) + (Expr* (map clambda-case-body cls*))] + [(function fml* proper body) (Expr body)] + [(primcall rator rand*) (Expr* rand*)] + [(funcall rator rand*) + (union (Expr rator) (Expr* rand*))] + [(appcall rator rand*) + (union (Expr rator) (Expr* rand*))] + [(forcall rator rand*) (Expr* rand*)] + [(assign lhs rhs) + (union (singleton lhs) (Expr rhs))] + [else (error who "invalid expression ~s" (unparse x))])) + (Expr x)) + +(define (rewrite-assignments assigned x) + (define who 'rewrite-assignments) + (define (fix lhs*) + (cond + [(null? lhs*) (values '() '() '())] + [else + (let ([x (car lhs*)]) + (let-values ([(lhs* a-lhs* a-rhs*) (fix (cdr lhs*))]) + (cond + [(memq x assigned) + (let ([t (make-var 'assignment-tmp)]) + (values (cons t lhs*) (cons x a-lhs*) (cons t a-rhs*)))] + [else + (values (cons x lhs*) a-lhs* a-rhs*)])))])) + (define (bind-assigned lhs* rhs* body) + (cond + [(null? lhs*) body] + [else + (make-bind lhs* + (map (lambda (rhs) (make-primcall 'vector (list rhs))) rhs*) + body)])) + (define (Expr x) + (record-case x + [(constant) x] + [(var) + (cond + [(memq x assigned) + (make-primcall '$vector-ref (list x (make-constant 0)))] + [else x])] + [(primref) x] + [(bind lhs* rhs* body) + (let-values ([(lhs* a-lhs* a-rhs*) (fix lhs*)]) + (make-bind lhs* (map Expr rhs*) + (bind-assigned a-lhs* a-rhs* (Expr body))))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Expr conseq) (Expr altern))] + [(seq e0 e1) (make-seq (Expr e0) (Expr e1))] + [(function fml* proper body) + (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)]) + (make-function fml* proper + (bind-assigned a-lhs* a-rhs* (Expr body))))] + [(clambda cls*) + (make-clambda + (map (lambda (cls) + (record-case cls + [(clambda-case fml* proper body) + (let-values ([(fml* a-lhs* a-rhs*) (fix fml*)]) + (make-clambda-case fml* proper + (bind-assigned a-lhs* a-rhs* (Expr body))))])) + cls*))] + [(primcall op rand*) + (make-primcall op (map Expr rand*))] + [(forcall op rand*) + (make-forcall op (map Expr rand*))] + [(funcall rator rand*) + (make-funcall (Expr rator) (map Expr rand*))] + [(appcall rator rand*) + (make-appcall (Expr rator) (map Expr rand*))] + [(assign lhs rhs) + (unless (memq lhs assigned) + (error 'rewrite-assignments "not assigned ~s in ~s" lhs x)) + (make-primcall '$vector-set! (list lhs (make-constant 0) (Expr rhs)))] + [else (error who "invalid expression ~s" (unparse x))])) + (Expr x)) + + +(define (remove-assignments x) + (let ([assigned (uncover-assigned x)]) + (rewrite-assignments assigned x))) + + +(define (convert-closures prog) + (define who 'convert-closures) + (define (Expr* x*) + (cond + [(null? x*) (values '() '())] + [else + (let-values ([(a a-free) (Expr (car x*))] + [(d d-free) (Expr* (cdr x*))]) + (values (cons a d) (union a-free d-free)))])) + (define (Expr ex) + (record-case ex + [(constant) (values ex '())] + [(var) (values ex (singleton ex))] + [(primref) (values ex '())] + [(bind lhs* rhs* body) + (let-values ([(rhs* rhs-free) (Expr* rhs*)] + [(body body-free) (Expr body)]) + (values (make-bind lhs* rhs* body) + (union rhs-free (difference body-free lhs*))))] + [(conditional test conseq altern) + (let-values ([(test test-free) (Expr test)] + [(conseq conseq-free) (Expr conseq)] + [(altern altern-free) (Expr altern)]) + (values (make-conditional test conseq altern) + (union test-free (union conseq-free altern-free))))] + [(seq e0 e1) + (let-values ([(e0 e0-free) (Expr e0)] + [(e1 e1-free) (Expr e1)]) + (values (make-seq e0 e1) (union e0-free e1-free)))] + [(function fml* proper body) + (let-values ([(body body-free) (Expr body)]) + (let ([free (difference body-free fml*)]) + (values (make-closure (make-code-rec fml* proper free body) free) + free)))] + [(clambda cls*) + (let-values ([(cls* free) + (let f ([cls* cls*]) + (cond + [(null? cls*) (values '() '())] + [else + (record-case (car cls*) + [(clambda-case fml* proper body) + (let-values ([(body body-free) (Expr body)] + [(cls* cls*-free) (f (cdr cls*))]) + (values + (cons (make-clambda-case fml* proper body) + cls*) + (union (difference body-free fml*) + cls*-free)))])]))]) + (values (make-closure (make-clambda-code (gensym) cls* free) free) + free))] + [(primcall op rand*) + (let-values ([(rand* rand*-free) (Expr* rand*)]) + (values (make-primcall op rand*) rand*-free))] + [(forcall op rand*) + (let-values ([(rand* rand*-free) (Expr* rand*)]) + (values (make-forcall op rand*) rand*-free))] + [(funcall rator rand*) + (let-values ([(rator rat-free) (Expr rator)] + [(rand* rand*-free) (Expr* rand*)]) + (values (make-funcall rator rand*) + (union rat-free rand*-free)))] + [(appcall rator rand*) + (let-values ([(rator rat-free) (Expr rator)] + [(rand* rand*-free) (Expr* rand*)]) + (values (make-appcall rator rand*) + (union rat-free rand*-free)))] + [else (error who "invalid expression ~s" (unparse ex))])) + (let-values ([(prog free) (Expr prog)]) + (unless (null? free) + (error 'convert-closures "free vars ~s encountered in ~a" + free (unparse prog))) + prog)) + + +(define (lift-codes x) + (define who 'lift-codes) + (define all-codes '()) + (define (do-code x) + (record-case x + [(clambda-code label cls* free) + (let ([cls* (map + (lambda (x) + (record-case x + [(clambda-case fml* proper body) + (make-clambda-case fml* proper (E body))])) + cls*)]) + (let ([g (make-code-loc label)]) + (set! all-codes + (cons (make-clambda-code label cls* free) all-codes)) + g))])) + (define (E x) + (record-case x + [(constant) x] + [(var) x] + [(primref) x] + [(bind lhs* rhs* body) + (make-bind lhs* (map E rhs*) (E body))] + [(conditional test conseq altern) + (make-conditional (E test) (E conseq) (E altern))] + [(seq e0 e1) (make-seq (E e0) (E e1))] + [(closure c free) (make-closure (do-code c) free)] + [(primcall op rand*) (make-primcall op (map E rand*))] + [(forcall op rand*) (make-forcall op (map E rand*))] + [(funcall rator rand*) (make-funcall (E rator) (map E rand*))] + [(appcall rator rand*) (make-appcall (E rator) (map E rand*))] + [else (error who "invalid expression ~s" (unparse x))])) + (let ([x (E x)]) + (make-codes all-codes x))) + + + + +(define (syntactically-valid? op rand*) + (define (valid-arg-count? op rand*) + (let ([n (open-coded-primitive-args op)] [m (length rand*)]) + (cond + [(eq? n 'any) #t] + [(eq? n 'no-code) + (error 'syntactically-valid + "should not primcall non codable prim ~s" op)] + [(fixnum? n) + (cond + [(fx= n m) #t] + [else + (error 'compile + "Possible incorrect number of args in ~s" + (cons op (map unparse rand*))) + #f])] + [else (error 'do-primcall "BUG: what ~s" n)]))) + (define (check op pred?) + (lambda (arg) + (record-case arg + [(constant c) + (cond + [(pred? c) #t] + [else + (error 'compile "Possible argument error to primitive ~s" op) + #f])] + [(primref) + (cond + [(pred? (lambda (x) x)) #t] + [else + (error 'compile "Possible argument error to primitive ~s" op) + #f])] + [else #t]))) + (define (nonnegative-fixnum? n) + (and (fixnum? n) (fx>= n 0))) + (define (byte? n) + (and (fixnum? n) (fx<= 0 n) (fx<= n 127))) + (define (valid-arg-types? op rand*) + (case op + [(fixnum? immediate? boolean? char? vector? string? procedure? + null? pair? not cons eq? vector symbol? error eof-object eof-object? + void $unbound-object? code? $forward-ptr? bwp-object? + pointer-value) + '#t] + [($fxadd1 $fxsub1 $fxzero? $fxlognot $fxlogor $fxlogand $fx+ $fx- $fx* + $fx= $fx< $fx<= $fx> $fx>= $fxquotient $fxmodulo $fxsll $fxsra $fxlogxor $exit) + (andmap (check op fixnum?) rand*)] + [($fixnum->char) + (andmap (check op byte?) rand*)] + [($char->fixnum $char= $char< $char<= $char> $char>= $string) + (andmap (check op char?) rand*)] + [($make-vector $make-string) + (andmap (check op nonnegative-fixnum?) rand*)] + [($car $cdr) + (andmap (check op pair?) rand*)] + [($vector-length) + (andmap (check op vector?) rand*)] + [($string-length) + (andmap (check op string?) rand*)] + [($set-car! $set-cdr!) + ((check op pair?) (car rand*))] + [($vector-ref $vector-set!) + (and ((check op vector?) (car rand*)) + ((check op nonnegative-fixnum?) (cadr rand*)))] + [($string-ref $string-set! + $string-ref-16+0 $string-ref-16+1 $string-ref-8+0 $string-ref-8+2) + (and ((check op string?) (car rand*)) + ((check op nonnegative-fixnum?) (cadr rand*)))] + [($symbol-string $symbol-unique-string) + (andmap (check op symbol?) rand*)] + [($constant-ref $set-constant! $intern $pcb-set! $pcb-ref $make-symbol + $symbol-value $set-symbol-value! $symbol-plist $set-symbol-plist! + $set-symbol-system-value! $set-symbol-system-value! + $set-symbol-unique-string! + $set-symbol-string! + $seal-frame-and-call $frame->continuation $code->closure + $code-instr-size $code-reloc-size $code-closure-size + $set-code-byte! $set-code-word! + $set-code-object! $set-code-object+offset! $set-code-object+offset/rel! + $make-record $record? $record-rtd $record-ref $record-set! + primitive-set! primitive-ref + $make-tcbucket $tcbucket-key $tcbucket-val $tcbucket-next + $set-tcbucket-val! $set-tcbucket-next! $set-tcbucket-tconc!) + #t] + [else (error 'valid-arg-types? "unhandled op ~s" op)])) + (and (valid-arg-count? op rand*) + (or (null? rand*) + (valid-arg-types? op rand*)))) + + +;;; the output of simplify-operands differs from the input in that the +;;; operands to primcalls are all simple (variables, primrefs, or constants). +;;; funcalls to open-codable primrefs whos arguments are "ok" are converted to +;;; primcalls. + +(define (introduce-primcalls x) + (define who 'introduce-primcalls) + (define (simple? x) + (or (constant? x) (var? x) (primref? x))) + (define (Expr x) + (record-case x + [(constant) x] + [(var) x] + [(primref) x] + [(closure) x] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Expr body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Expr conseq) (Expr altern))] + [(seq e0 e1) (make-seq (Expr e0) (Expr e1))] + [(primcall op arg*) + (case op + ;[(values) + ; (if (fx= (length arg*) 1) + ; (Expr (car arg*)) + ; (begin + ; (warning 'compile "possible incorrect number of values") + ; (make-funcall (make-primref 'values) (map Expr arg*))))] + [else + (make-primcall op (map Expr arg*))])] + [(forcall op arg*) + (make-forcall op (map Expr arg*))] + [(funcall rator rand*) + (cond + [(and (primref? rator) + (open-codeable? (primref-name rator)) + (syntactically-valid? (primref-name rator) rand*)) + (Expr (make-primcall (primref-name rator) rand*))] + [else + (make-funcall (Expr rator) (map Expr rand*))])] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (Tail x) + (record-case x + [(constant) (make-return x)] + [(var) (make-return x)] + [(primref) (make-return x)] + [(closure) (make-return x)] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Tail body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Tail conseq) (Tail altern))] + [(seq e0 e1) (make-seq (Expr e0) (Tail e1))] + [(primcall op arg*) + (case op + ;[(values) + ; (if (fx= (length arg*) 1) + ; (make-return (Expr (car arg*))) + ; (make-return* (map Expr arg*)))] + [else + (make-return (make-primcall op (map Expr arg*)))])] + [(forcall op arg*) + (make-return (make-forcall op (map Expr arg*)))] + [(funcall rator rand*) + (cond + [(and (primref? rator) + (open-codeable? (primref-name rator)) + (syntactically-valid? (primref-name rator) rand*)) + (Tail (make-primcall (primref-name rator) rand*))] + [else + (make-funcall (Expr rator) (map Expr rand*))])] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (CaseExpr x) + (record-case x + [(clambda-case fml* proper body) + (make-clambda-case fml* proper (Tail body))])) + (define (CodeExpr x) + (record-case x + [(clambda-code L cases free) + (make-clambda-code L (map CaseExpr cases) free)])) + (define (CodesExpr x) + (record-case x + [(codes list body) + (make-codes (map CodeExpr list) (Tail body))])) + (CodesExpr x)) + + +(define (simplify-operands x) + (define who 'simplify-operands) + (define (simple? x) + (or (constant? x) (var? x) (primref? x))) + (define (simplify arg lhs* rhs* k) + (if (simple? arg) + (k arg lhs* rhs*) + (let ([v (unique-var 'tmp)]) + (k v (cons v lhs*) (cons (Expr arg) rhs*))))) + (define (simplify* arg* lhs* rhs* k) + (cond + [(null? arg*) (k '() lhs* rhs*)] + [else + (simplify (car arg*) lhs* rhs* + (lambda (a lhs* rhs*) + (simplify* (cdr arg*) lhs* rhs* + (lambda (d lhs* rhs*) + (k (cons a d) lhs* rhs*)))))])) + (define (Expr x) + (record-case x + [(constant) x] + [(var) x] + [(primref) x] + [(closure) x] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Expr body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Expr conseq) (Expr altern))] + [(seq e0 e1) (make-seq (Expr e0) (Expr e1))] + [(primcall op arg*) + (simplify* arg* '() '() + (lambda (arg* lhs* rhs*) + (make-bind^ lhs* rhs* + (make-primcall op arg*))))] + [(forcall op arg*) + (make-forcall op (map Expr arg*))] + [(funcall rator rand*) + (make-funcall (Expr rator) (map Expr rand*))] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (Tail x) + (record-case x + [(return v) (make-return (Expr v))] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Tail body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Tail conseq) (Tail altern))] + [(seq e0 e1) (make-seq (Expr e0) (Tail e1))] + [(funcall rator rand*) + (make-funcall (Expr rator) (map Expr rand*))] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (CaseExpr x) + (record-case x + [(clambda-case fml* proper body) + (make-clambda-case fml* proper (Tail body))])) + (define (CodeExpr x) + (record-case x + [(clambda-code L clauses free) + (make-clambda-code L (map CaseExpr clauses) free)])) + (define (CodesExpr x) + (record-case x + [(codes list body) + (make-codes (map CodeExpr list) (Tail body))])) + (CodesExpr x)) + + +(define (insert-stack-overflow-checks x) + (define who 'insert-stack-overflow-checks) + (define (insert-check body) + (make-seq + (make-conditional + (make-primcall '$fp-overflow '()) + (make-funcall (make-primref 'do-stack-overflow) '()) + (make-primcall 'void '())) + body)) + (define (Expr x) + (record-case x + [(constant) #f] + [(var) #f] + [(primref) #f] + [(closure code free*) #f] + [(bind lhs* rhs* body) + (or (ormap Expr rhs*) (Expr body))] + [(conditional test conseq altern) + (or (Expr test) (Expr conseq) (Expr altern))] + [(seq e0 e1) (or (Expr e0) (Expr e1))] + [(primcall op arg*) (ormap Expr arg*)] + [(forcall op arg*) (ormap Expr arg*)] + [(funcall rator arg*) #t] + [(appcall rator arg*) #t] + [else (error who "invalid expression ~s" (unparse x))])) + (define (Tail x) + (record-case x + [(return v) (Expr v)] + [(bind lhs* rhs* body) + (or (ormap Expr rhs*) (Tail body))] + [(conditional test conseq altern) + (or (Expr test) (Tail conseq) (Tail altern))] + [(seq e0 e1) (or (Expr e0) (Tail e1))] + [(funcall rator arg*) (or (Expr rator) (ormap Expr arg*))] + [(appcall rator arg*) (or (Expr rator) (ormap Expr arg*))] + [else (error who "invalid tail expression ~s" (unparse x))])) + (define (CaseExpr x) + (record-case x + [(clambda-case fml* proper body) + (if (Tail body) + (make-clambda-case fml* proper (insert-check body)) + x)])) + (define (CodeExpr x) + (record-case x + [(clambda-code L cases free) + (make-clambda-code L (map CaseExpr cases) free)])) + (define (CodesExpr x) + (record-case x + [(codes list body) + (make-codes (map CodeExpr list) + (if (Tail body) + (insert-check body) + body))])) + (CodesExpr x)) + + +(define (insert-allocation-checks x) + (define who 'insert-allocation-checks) + (define (check-bytes n var body) + (make-seq + (make-conditional + (make-primcall '$ap-check-bytes + (list (make-constant n) var)) + (make-funcall (make-primref 'do-overflow) + (list + (make-primcall '$fx+ + (list (make-constant n) var)))) + (make-primcall 'void '())) + body)) + (define (check-words n var body) + (make-seq + (make-conditional + (make-primcall '$ap-check-words + (list (make-constant n) var)) + (make-funcall (make-primref 'do-overflow-words) + (list + (make-primcall '$fx+ + (list (make-constant n) var)))) + (make-primcall 'void '())) + body)) + (define (check-const n body) + (make-seq + (make-conditional + (make-primcall '$ap-check-const + (list (make-constant n))) + (make-funcall (make-primref 'do-overflow) + (list (make-constant n))) + (make-primcall 'void '())) + body)) + (define (Expr x) + (record-case x + [(constant) x] + [(var) x] + [(primref) x] + [(closure code free*) + (check-const (fx+ disp-closure-data (fx* (length free*) wordsize)) x)] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Expr body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Expr conseq) (Expr altern))] + [(seq e0 e1) (make-seq (Expr e0) (Expr e1))] + [(primcall op arg*) + (let ([x (make-primcall op (map Expr arg*))]) + (case op + [(cons) (check-const pair-size x)] + [($make-symbol) (check-const symbol-size x)] + [($make-tcbucket) (check-const tcbucket-size x)] + [($frame->continuation $code->closure) + (check-const (fx+ disp-closure-data (fx* (length arg*) wordsize)) x)] + [($make-string) + (record-case (car arg*) + [(constant i) + (check-const (fx+ i (fx+ disp-string-data 1)) x)] + [else + (check-bytes (fxadd1 disp-string-data) (car arg*) x)])] + [($string) + (check-const (fx+ (length arg*) (fx+ disp-string-data 1)) x)] + [($make-vector) + (record-case (car arg*) + [(constant i) + (check-const (fx+ (fx* i wordsize) disp-vector-data) x)] + [else + (check-words (fxadd1 disp-vector-data) (car arg*) x)])] + [($make-record) + (record-case (cadr arg*) + [(constant i) + (check-const (fx+ (fx* i wordsize) disp-record-data) x)] + [else + (check-words (fxadd1 disp-record-data) (cadr arg*) x)])] + [(vector) + (check-const (fx+ (fx* (length arg*) wordsize) disp-vector-data) x)] + [else x]))] + [(forcall op arg*) + (make-forcall op (map Expr arg*))] + [(funcall rator rand*) + (make-funcall (Expr rator) (map Expr rand*))] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (Tail x) + (record-case x + [(return v) (make-return (Expr v))] + [(bind lhs* rhs* body) + (make-bind lhs* (map Expr rhs*) (Tail body))] + [(conditional test conseq altern) + (make-conditional (Expr test) (Tail conseq) (Tail altern))] + [(seq e0 e1) (make-seq (Expr e0) (Tail e1))] + [(funcall rator rand*) + (make-funcall (Expr rator) (map Expr rand*))] + [(appcall op arg*) + (make-appcall (Expr op) (map Expr arg*))] + [else (error who "invalid expression ~s" (unparse x))])) + (define (CaseExpr x) + (record-case x + [(clambda-case fml* proper body) + (make-clambda-case fml* proper (Tail body))])) + (define (CodeExpr x) + (record-case x + [(clambda-code L cases free) + (make-clambda-code L (map CaseExpr cases) free)])) + (define (CodesExpr x) + (record-case x + [(codes list body) + (make-codes (map CodeExpr list) (Tail body))])) + (CodesExpr x)) + + +(define (remove-local-variables x) + (define who 'remove-local-variables) + (define (simple* x* r) + (map (lambda (x) + (cond + [(assq x r) => cdr] + [else + (when (var? x) (error who "unbound var ~s" x)) + x])) + x*)) + (define (env->mask r sz) + (let ([s (make-vector (fxsra (fx+ sz 7) 3) 0)]) + (for-each + (lambda (idx) + (let ([q (fxsra idx 3)] + [r (fxlogand idx 7)]) + (vector-set! s q + (fxlogor (vector-ref s q) (fxsll 1 r))))) + r) + s)) + (define (do-new-frame op rand* si r call-convention rp-convention orig-live) + (make-new-frame (fxadd1 si) (fx+ (length rand*) 2) + (let f ([r* rand*] [nsi (fx+ si 2)] [live orig-live]) + (cond + [(null? r*) + (make-seq + (make-seq + (make-save-cp (make-frame-var si)) + (case call-convention + [(normal apply) + (make-eval-cp #t (Expr op nsi r (cons si live)))] + [(foreign) + (make-eval-cp #f (make-foreign-label op))] + [else (error who "invalid convention ~s" convention)])) + (make-call-cp call-convention + rp-convention + (fxadd1 si) ; frame size + (length rand*) ; argc + (env->mask (cons si orig-live) ; cp and everything before it + (fxadd1 si))))] ; mask-size ~~ frame size + [else + (make-seq + (make-assign (make-frame-var nsi) + (Expr (car r*) nsi r live)) + (f (cdr r*) (fxadd1 nsi) (cons nsi live)))])))) + (define (nop) (make-primcall 'void '())) + (define (do-bind lhs* rhs* body si r live k) + (let f ([lhs* lhs*] [rhs* rhs*] [si si] [nr r] [live live]) + (cond + [(null? lhs*) (k body si nr live)] + [else + (let ([v (make-frame-var si)]) + (make-seq + (make-assign v (Expr (car rhs*) si r live)) + (f (cdr lhs*) (cdr rhs*) (fxadd1 si) + (cons (cons (car lhs*) v) nr) + (cons si live))))]))) + (define (Tail x si r live) + (record-case x + [(return v) (make-return (Expr v si r live))] + [(bind lhs* rhs* body) + (do-bind lhs* rhs* body si r live Tail)] + [(conditional test conseq altern) + (make-conditional + (Expr test si r live) + (Tail conseq si r live) + (Tail altern si r live))] + [(seq e0 e1) (make-seq (Effect e0 si r live) (Tail e1 si r live))] + [(primcall op arg*) + (case op +; [(values) (make-primcall op (simple* arg* r))] + [else (make-return (make-primcall op (simple* arg* r)))])] + [(funcall op rand*) + (do-new-frame op rand* si r 'normal 'tail live)] + [(appcall op rand*) + (do-new-frame op rand* si r 'apply 'tail live)] + [else (error who "invalid expression ~s" (unparse x))])) + (define (Effect x si r live) + (record-case x + [(constant) (nop)] + [(var) (nop)] + [(primref) (nop)] + [(closure code free*) (nop)] + [(bind lhs* rhs* body) + (do-bind lhs* rhs* body si r live Effect)] + [(conditional test conseq altern) + (make-conditional + (Expr test si r live) + (Effect conseq si r live) + (Effect altern si r live))] + [(seq e0 e1) (make-seq (Effect e0 si r live) (Effect e1 si r live))] + [(primcall op arg*) + (make-primcall op (simple* arg* r))] + [(forcall op rand*) + (do-new-frame op rand* si r 'foreign 'effect live)] + [(funcall op rand*) + (do-new-frame op rand* si r 'normal 'effect live)] + [(appcall op rand*) + (do-new-frame op rand* si r 'apply 'effect live)] + [else (error who "invalid effect expression ~s" (unparse x))])) + (define (Expr x si r live) + (record-case x + [(constant) x] + [(var) + (cond + [(assq x r) => cdr] + [else (error who "unbound var ~s" x)])] + [(primref) x] + [(closure code free*) + (make-closure code (simple* free* r))] + [(bind lhs* rhs* body) + (do-bind lhs* rhs* body si r live Expr)] + [(conditional test conseq altern) + (make-conditional + (Expr test si r live) + (Expr conseq si r live) + (Expr altern si r live))] + [(seq e0 e1) (make-seq (Effect e0 si r live) (Expr e1 si r live))] + [(primcall op arg*) + (make-primcall op (simple* arg* r))] + [(forcall op rand*) + (do-new-frame op rand* si r 'foreign 'value live)] + [(funcall op rand*) + (do-new-frame op rand* si r 'normal 'value live)] + [(appcall op rand*) + (do-new-frame op rand* si r 'apply 'value live)] + [else (error who "invalid expression ~s" (unparse x))])) + (define (bind-fml* fml* r) + (let f ([si 1] [fml* fml*]) + (cond + [(null? fml*) (values '() si r '())] + [else + (let-values ([(nfml* nsi r live) (f (fxadd1 si) (cdr fml*))]) + (let ([v (make-frame-var si)]) + (values (cons v nfml*) + nsi + (cons (cons (car fml*) v) r) + (cons si live))))]))) + (define (bind-free* free*) + (let f ([free* free*] [idx 0] [r '()]) + (cond + [(null? free*) r] + [else + (f (cdr free*) (fxadd1 idx) + (cons (cons (car free*) (make-cp-var idx)) r))]))) + (define CaseExpr + (lambda (r) + (lambda (x) + (record-case x + [(clambda-case fml* proper body) + (let-values ([(fml* si r live) (bind-fml* fml* r)]) + (make-clambda-case fml* proper (Tail body si r live)))])))) + (define (CodeExpr x) + (record-case x + [(clambda-code L cases free) + (let ([r (bind-free* free)]) + (make-clambda-code L (map (CaseExpr r) cases) free))])) + (define (CodesExpr x) + (record-case x + [(codes list body) + (make-codes (map CodeExpr list) + (Tail body 1 '() '()))])) + (CodesExpr x)) + + +(begin + (define fx-shift 2) + (define fx-mask #x03) + (define fx-tag 0) + (define bool-f #x2F) + (define bool-t #x3F) + (define bool-mask #xEF) + (define bool-tag bool-f) + (define bool-shift 4) + (define nil #x4F) + (define eof #x5F) ; double check + (define unbound #x6F) ; double check + (define void-object #x7F) ; double check + (define bwp-object #x8F) ; double check + (define char-shift 8) + (define char-tag #x0F) + (define char-mask #xFF) + (define pair-mask 7) + (define pair-tag 1) + (define disp-car 0) + (define disp-cdr 4) + (define pair-size 8) + (define pagesize 4096) + (define pageshift 12) + (define wordsize 4) + (define wordshift 2) + + (define symbol-mask 7) + (define symbol-tag 2) + (define disp-symbol-string 0) + (define disp-symbol-unique-string 4) + (define disp-symbol-value 8) + (define disp-symbol-plist 12) + (define disp-symbol-system-value 16) + (define disp-symbol-system-plist 20) + (define symbol-size 24) + (define vector-tag 5) + (define vector-mask 7) + (define disp-vector-length 0) + (define disp-vector-data 4) + (define string-mask 7) + (define string-tag 6) + (define disp-string-length 0) + (define disp-string-data 4) + (define closure-mask 7) + (define closure-tag 3) + (define disp-closure-data 4) + (define disp-closure-code 0) + (define continuation-size 16) + (define continuation-tag #x1F) + (define disp-continuation-top 4) + (define disp-continuation-size 8) + (define disp-continuation-next 12) + (define code-tag #x2F) + (define disp-code-instrsize 4) + (define disp-code-relocsize 8) + (define disp-code-closuresize 12) + (define disp-code-data 16) + (define disp-tcbucket-tconc 0) + (define disp-tcbucket-key 4) + (define disp-tcbucket-val 8) + (define disp-tcbucket-next 12) + (define tcbucket-size 16) + + (define record-ptag vector-tag) + (define record-pmask vector-mask) + (define disp-record-rtd 0) + (define disp-record-data 4) + (define disp-frame-size -17) + (define disp-frame-offset -13) + (define disp-multivalue-rp -9) + (define object-alignment 8) + (define align-shift 3) + (define pagesize 4096) + (define dirty-word -1)) + +(begin + (define (mem off val) + (cond + [(fixnum? off) (list 'disp (int off) val)] + [(register? off) (list 'disp off val)] + [else (error 'mem "invalid disp ~s" off)])) + (define (int x) (list 'int x)) + (define (obj x) (list 'obj x)) + (define (byte x) (list 'byte x)) + (define (byte-vector x) (list 'byte-vector x)) + (define (movzbl src targ) (list 'movzbl src targ)) + (define (sall src targ) (list 'sall src targ)) + (define (sarl src targ) (list 'sarl src targ)) + (define (shrl src targ) (list 'shrl src targ)) + (define (notl src) (list 'notl src)) + (define (pushl src) (list 'pushl src)) + (define (popl src) (list 'popl src)) + (define (orl src targ) (list 'orl src targ)) + (define (xorl src targ) (list 'xorl src targ)) + (define (andl src targ) (list 'andl src targ)) + (define (movl src targ) (list 'movl src targ)) + (define (movb src targ) (list 'movb src targ)) + (define (addl src targ) (list 'addl src targ)) + (define (imull src targ) (list 'imull src targ)) + (define (idivl src) (list 'idivl src)) + (define (subl src targ) (list 'subl src targ)) + (define (push src) (list 'push src)) + (define (pop targ) (list 'pop targ)) + (define (sete targ) (list 'sete targ)) + (define (call targ) (list 'call targ)) + (define (tail-indirect-cpr-call) + (jmp (mem (fx- disp-closure-code closure-tag) cpr))) + (define (indirect-cpr-call) + (call (mem (fx- disp-closure-code closure-tag) cpr))) + (define (negl targ) (list 'negl targ)) + (define (label x) (list 'label x)) + (define (label-address x) (list 'label-address x)) + (define (ret) '(ret)) + (define (cltd) '(cltd)) + (define (cmpl arg1 arg2) (list 'cmpl arg1 arg2)) + (define (je label) (list 'je label)) + (define (jne label) (list 'jne label)) + (define (jle label) (list 'jle label)) + (define (jge label) (list 'jge label)) + (define (jg label) (list 'jg label)) + (define (jl label) (list 'jl label)) + (define (jb label) (list 'jb label)) + (define (ja label) (list 'ja label)) + (define (jmp label) (list 'jmp label)) + (define edi '%edx) ; closure pointer + (define esi '%esi) ; pcb + (define ebp '%ebp) ; allocation pointer + (define esp '%esp) ; stack base pointer + (define al '%al) + (define ah '%ah) + (define bh '%bh) + (define cl '%cl) + (define eax '%eax) + (define ebx '%ebx) + (define ecx '%ecx) + (define edx '%edx) + (define apr '%ebp) + (define fpr '%esp) + (define cpr '%edi) + (define pcr '%esi) + (define register? symbol?) + (define (argc-convention n) + (fx- 0 (fxsll n fx-shift)))) + + +(define pcb-ref + (lambda (x) + (case x + [(allocation-pointer) (mem 0 pcr)] + [(allocation-redline) (mem 4 pcr)] + [(frame-pointer) (mem 8 pcr)] + [(frame-base) (mem 12 pcr)] + [(frame-redline) (mem 16 pcr)] + [(next-continuation) (mem 20 pcr)] + [(system-stack) (mem 24 pcr)] + [(dirty-vector) (mem 28 pcr)] + [else (error 'pcb-ref "invalid arg ~s" x)]))) + +(define (primref-loc op) + (unless (symbol? op) (error 'primref-loc "not a symbol ~s" op)) + (mem (fx- disp-symbol-system-value symbol-tag) + (obj op))) + +(define (generate-code x) + (define who 'generate-code) + (define (rp-label x) + (case x + [(value) (label-address SL_multiple_values_error_rp)] + [(effect) (label-address SL_multiple_values_ignore_rp)] + [else (error who "invalid rp-convention ~s" x)])) + (define (align n) + (fxsll (fxsra (fx+ n (fxsub1 object-alignment)) align-shift) align-shift)) + (define unique-label + (lambda () + (label (gensym)))) + (define (constant-val x) + (cond + [(fixnum? x) (obj x)] + [(boolean? x) (int (if x bool-t bool-f))] + [(null? x) (int nil)] + [(char? x) (int (fx+ (fxsll (char->integer x) char-shift) char-tag))] + [(eq? x (void)) (int void-object)] + [else (obj x)])) + (define (cond-branch op Lt Lf ac) + (define (opposite x) + (cadr (assq x '([je jne] [jl jge] [jle jg] [jg jle] [jge jl])))) + (unless (or Lt Lf) + (error 'cond-branch "no labels")) + (cond + [(not Lf) (cons (list op Lt) ac)] + [(not Lt) (cons (list (opposite op) Lf) ac)] + [else (list* (list op Lt) (jmp Lf) ac)])) + (define (indirect-type-pred pri-mask pri-tag sec-mask sec-tag rand* Lt Lf ac) + (cond + [(and Lt Lf) + (list* (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int pri-mask) ebx) + (cmpl (int pri-tag) ebx) + (jne Lf) + (movl (mem (fx- 0 pri-tag) eax) ebx) + (if sec-mask + (andl (int sec-mask) ebx) + '(nop)) + (cmpl (int sec-tag) ebx) + (jne Lf) + (jmp Lt) + ac)] + [Lf + (list* (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int pri-mask) ebx) + (cmpl (int pri-tag) ebx) + (jne Lf) + (movl (mem (fx- 0 pri-tag) eax) ebx) + (if sec-mask + (andl (int sec-mask) ebx) + '(nop)) + (cmpl (int sec-tag) ebx) + (jne Lf) + ac)] + [Lt + (let ([L_END (unique-label)]) + (list* (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int pri-mask) ebx) + (cmpl (int pri-tag) ebx) + (jne L_END) + (movl (mem (fx- 0 pri-tag) eax) ebx) + (if sec-mask + (andl (int sec-mask) ebx) + '(nop)) + (cmpl (int sec-tag) ebx) + (je Lt) + L_END + ac))] + [else ac])) + (define (type-pred mask tag rand* Lt Lf ac) + (cond + [mask + (list* + (movl (Simple (car rand*)) eax) + (andl (int mask) eax) + (cmpl (int tag) eax) + (cond-branch 'je Lt Lf ac))] + [else + (let ([v (Simple (car rand*))]) + (cond + [(memq (car v) '(mem register)) + (list* + (cmpl (int tag) (Simple (car rand*))) + (cond-branch 'je Lt Lf ac))] + [else + (list* + (movl (Simple (car rand*)) eax) + (cmpl (int tag) eax) + (cond-branch 'je Lt Lf ac))]))])) + (define (compare-and-branch op rand* Lt Lf ac) + (define (opposite x) + (cadr (assq x '([je je] [jl jg] [jle jge] [jg jl] [jge jle])))) + (cond + [(and (constant? (car rand*)) (constant? (cadr rand*))) + (list* + (movl (Simple (car rand*)) eax) + (cmpl (Simple (cadr rand*)) eax) + (cond-branch op Lt Lf ac))] + [(constant? (cadr rand*)) + (list* + (cmpl (Simple (cadr rand*)) (Simple (car rand*))) + (cond-branch op Lt Lf ac))] + [(constant? (car rand*)) + (list* + (cmpl (Simple (car rand*)) (Simple (cadr rand*))) + (cond-branch (opposite op) Lt Lf ac))] + [else + (list* + (movl (Simple (car rand*)) eax) + (cmpl (Simple (cadr rand*)) eax) + (cond-branch op Lt Lf ac))])) + (define (do-pred-prim op rand* Lt Lf ac) + (case op + [(fixnum?) (type-pred fx-mask fx-tag rand* Lt Lf ac)] + [(pair?) (type-pred pair-mask pair-tag rand* Lt Lf ac)] + [(char?) (type-pred char-mask char-tag rand* Lt Lf ac)] + [(string?) (type-pred string-mask string-tag rand* Lt Lf ac)] + [(symbol?) (type-pred symbol-mask symbol-tag rand* Lt Lf ac)] + [(procedure?) (type-pred closure-mask closure-tag rand* Lt Lf ac)] + [(boolean?) (type-pred bool-mask bool-tag rand* Lt Lf ac)] + [(null?) (type-pred #f nil rand* Lt Lf ac)] + [($unbound-object?) (type-pred #f unbound rand* Lt Lf ac)] + [($forward-ptr?) (type-pred #f -1 rand* Lt Lf ac)] + [(not) (type-pred #f bool-f rand* Lt Lf ac)] + [(eof-object?) (type-pred #f eof rand* Lt Lf ac)] + [(bwp-object?) (type-pred #f bwp-object rand* Lt Lf ac)] + [($fxzero?) (type-pred #f 0 rand* Lt Lf ac)] + [($fx= $char= eq?) (compare-and-branch 'je rand* Lt Lf ac)] + [($fx< $char<) (compare-and-branch 'jl rand* Lt Lf ac)] + [($fx<= $char<=) (compare-and-branch 'jle rand* Lt Lf ac)] + [($fx> $char>) (compare-and-branch 'jg rand* Lt Lf ac)] + [($fx>= $char>=) (compare-and-branch 'jge rand* Lt Lf ac)] + [(vector?) + (indirect-type-pred vector-mask vector-tag fx-mask fx-tag + rand* Lt Lf ac)] + [($record?) + (indirect-type-pred record-pmask record-ptag record-pmask record-ptag + rand* Lt Lf ac)] + [(code?) + (indirect-type-pred vector-mask vector-tag #f code-tag + rand* Lt Lf ac)] + [(immediate?) + (cond + [(and Lt Lf) + (list* (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int fx-mask) ebx) + (cmpl (int 0) ebx) + (je Lt) + (andl (int 7) eax) + (cmpl (int 7) eax) + (je Lt) + (jmp Lf) + ac)] + [Lt + (list* (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int fx-mask) ebx) + (cmpl (int 0) ebx) + (je Lt) + (andl (int 7) eax) + (cmpl (int 7) eax) + (je Lt) + ac)] + [Lf + (let ([Ljoin (unique-label)]) + (list* + (movl (Simple (car rand*)) eax) + (movl eax ebx) + (andl (int fx-mask) ebx) + (cmpl (int 0) ebx) + (je Ljoin) + (andl (int 7) eax) + (cmpl (int 7) eax) + (jne Lf) + Ljoin + ac))] + [else ac])] + [($ap-check-words) + (record-case (car rand*) + [(constant i) + (list* (movl (pcb-ref 'allocation-redline) eax) + (subl (Simple (cadr rand*)) eax) + (subl (int i) eax) + (cmpl eax apr) + (cond-branch 'jge Lt Lf ac))] + [else (error who "ap-check-words")])] + [($ap-check-bytes) + (record-case (car rand*) + [(constant i) + (list* (movl (Simple (cadr rand*)) eax) + (negl eax) + (addl (pcb-ref 'allocation-redline) eax) + (subl (int i) eax) + (cmpl eax apr) + (cond-branch 'jge Lt Lf ac))] + [else (error who "ap-check-bytes")])] + [($ap-check-const) + (record-case (car rand*) + [(constant i) + (if (fx< i pagesize) + (list* + (cmpl (pcb-ref 'allocation-redline) apr) + (cond-branch 'jge Lt Lf ac)) + (list* + (movl (pcb-ref 'allocation-redline) eax) + (subl (int i) eax) + (cmpl eax apr) + (cond-branch 'jge Lt Lf ac)))] + [else (error who "ap-check-const")])] + [($fp-at-base) + (list* + (movl (pcb-ref 'frame-base) eax) + (subl (int wordsize) eax) + (cmpl eax fpr) + (cond-branch 'je Lt Lf ac))] + [($fp-overflow) + (list* (cmpl (pcb-ref 'frame-redline) fpr) + (cond-branch 'jle Lt Lf ac))] + [($vector-ref) + (do-value-prim op rand* + (do-simple-test eax Lt Lf ac))] + [(cons void $fxadd1 $fxsub1) + ;;; always true + (do-effect-prim op rand* + (cond + [(not Lt) ac] + [else (cons (jmp Lt) ac)]))] + [else + (error 'pred-prim "HERE unhandled ~s" op)])) + (define (do-pred->value-prim op rand* ac) + (case op + [else + (let ([Lf (unique-label)] [Lj (unique-label)]) + (do-pred-prim op rand* #f Lf + (list* (movl (constant-val #t) eax) + (jmp Lj) + Lf + (movl (constant-val #f) eax) + Lj + ac)))])) + (define (indirect-ref arg* off ac) + (list* + (movl (Simple (car arg*)) eax) + (movl (mem off eax) eax) + ac)) + (define (do-value-prim op arg* ac) + (case op + [(eof-object) (cons (movl (int eof) eax) ac)] + [(void) (cons (movl (int void-object) eax) ac)] + [($fxadd1) + (list* (movl (Simple (car arg*)) eax) + (addl (constant-val 1) eax) + ac)] + [($fxsub1) + (list* (movl (Simple (car arg*)) eax) + (addl (constant-val -1) eax) + ac)] + [($fx+) + (list* (movl (Simple (car arg*)) eax) + (addl (Simple (cadr arg*)) eax) + ac)] + [($fx-) + (list* (movl (Simple (car arg*)) eax) + (subl (Simple (cadr arg*)) eax) + ac)] + [($fx*) + (cond + [(constant? (car arg*)) + (record-case (car arg*) + [(constant c) + (unless (fixnum? c) + (error who "invalid arg ~s to fx*" c)) + (list* (movl (Simple (cadr arg*)) eax) + (imull (int c) eax) + ac)])] + [(constant? (cadr arg*)) + (record-case (cadr arg*) + [(constant c) + (unless (fixnum? c) + (error who "invalid arg ~s to fx*" c)) + (list* (movl (Simple (car arg*)) eax) + (imull (int c) eax) + ac)])] + [else + (list* (movl (Simple (car arg*)) eax) + (sarl (int fx-shift) eax) + (imull (Simple (cadr arg*)) eax) + ac)])] + [($fxquotient) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ecx) + (cltd) + (idivl ecx) + (sall (int fx-shift) eax) + ac)] + [($fxmodulo) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl eax ecx) + (xorl ebx ecx) + (sarl (int (fxsub1 (fx* wordsize 8))) ecx) + (andl ebx ecx) + (cltd) + (idivl ebx) + (movl edx eax) + (addl ecx eax) + ac)] + [($fxlogor) + (list* (movl (Simple (car arg*)) eax) + (orl (Simple (cadr arg*)) eax) + ac)] + [($fxlogand) + (list* (movl (Simple (car arg*)) eax) + (andl (Simple (cadr arg*)) eax) + ac)] + [($fxlogxor) + (list* (movl (Simple (car arg*)) eax) + (xorl (Simple (cadr arg*)) eax) + ac)] + [($fxsra) + (record-case (cadr arg*) + [(constant i) + (unless (fixnum? i) (error who "invalid arg to fxsra")) + (list* (movl (Simple (car arg*)) eax) + (sarl (int (fx+ i fx-shift)) eax) + (sall (int fx-shift) eax) + ac)] + [else + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ecx) + (sarl (int fx-shift) ecx) + (sarl (int fx-shift) eax) + (sarl cl eax) + (sall (int fx-shift) eax) + ac)])] + [($fxsll) + (record-case (cadr arg*) + [(constant i) + (unless (fixnum? i) (error who "invalid arg to fxsll")) + (list* (movl (Simple (car arg*)) eax) + (sall (int i) eax) + ac)] + [else + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ecx) + (sarl (int fx-shift) ecx) + (sall cl eax) + ac)])] + [($fixnum->char) + (list* (movl (Simple (car arg*)) eax) + (sall (int (fx- char-shift fx-shift)) eax) + (orl (int char-tag) eax) + ac)] + [($char->fixnum) + (list* (movl (Simple (car arg*)) eax) + (sarl (int (fx- char-shift fx-shift)) eax) + ac)] + [($fxlognot) + (list* (movl (Simple (car arg*)) eax) + (orl (int fx-mask) eax) + (notl eax) + ac)] + [($car) (indirect-ref arg* (fx- disp-car pair-tag) ac)] + [($cdr) (indirect-ref arg* (fx- disp-cdr pair-tag) ac)] + [($vector-length) + (indirect-ref arg* (fx- disp-vector-length vector-tag) ac)] + [($string-length) + (indirect-ref arg* (fx- disp-string-length string-tag) ac)] + [($symbol-string) + (indirect-ref arg* (fx- disp-symbol-string symbol-tag) ac)] + [($symbol-unique-string) + (indirect-ref arg* (fx- disp-symbol-unique-string symbol-tag) ac)] + [($symbol-value) + (indirect-ref arg* (fx- disp-symbol-value symbol-tag) ac)] + [(primitive-ref) + (indirect-ref arg* (fx- disp-symbol-system-value symbol-tag) ac)] + [($tcbucket-key) + (indirect-ref arg* (fx- disp-tcbucket-key vector-tag) ac)] + [($tcbucket-val) + (indirect-ref arg* (fx- disp-tcbucket-val vector-tag) ac)] + [($tcbucket-next) + (indirect-ref arg* (fx- disp-tcbucket-next vector-tag) ac)] + [(pointer-value) + (list* + (movl (Simple (car arg*)) eax) + (sarl (int fx-shift) eax) + (sall (int fx-shift) eax) + ac)] + [($symbol-plist) + (indirect-ref arg* (fx- disp-symbol-plist symbol-tag) ac)] + [($record-rtd) + (indirect-ref arg* (fx- disp-record-rtd record-ptag) ac)] + [($constant-ref) + (list* (movl (Simple (car arg*)) eax) ac)] + [($vector-ref) + (list* (movl (Simple (car arg*)) ebx) + (addl (Simple (cadr arg*)) ebx) + (movl (mem (fx- disp-vector-data vector-tag) ebx) eax) + ac)] + [($record-ref) + (list* (movl (Simple (car arg*)) ebx) + (addl (Simple (cadr arg*)) ebx) + (movl (mem (fx- disp-record-data record-ptag) ebx) eax) + ac)] + [($string-ref) + (list* (movl (Simple (cadr arg*)) ebx) + (sarl (int fx-shift) ebx) + (addl (Simple (car arg*)) ebx) + (movl (int char-tag) eax) + (movb (mem (fx- disp-string-data string-tag) ebx) ah) + ac)] + [($make-string) + (list* (movl (Simple (car arg*)) ebx) + (movl ebx (mem disp-string-length apr)) + (movl apr eax) + (addl (int string-tag) eax) + (sarl (int fx-shift) ebx) + (addl ebx apr) + (movb (int 0) (mem disp-string-data apr)) + (addl (int (fx+ disp-string-data object-alignment)) apr) + (sarl (int align-shift) apr) + (sall (int align-shift) apr) + ac)] + [($make-vector) + (list* (movl (Simple (car arg*)) ebx) + (movl ebx (mem disp-vector-length apr)) + (movl apr eax) + (addl (int vector-tag) eax) + (addl ebx apr) + (addl (int (fx+ disp-vector-data (fxsub1 object-alignment))) apr) + (sarl (int align-shift) apr) + (sall (int align-shift) apr) + ac)] + [($make-record) + (list* (movl (Simple (car arg*)) eax) + (movl eax (mem disp-record-rtd apr)) + (movl apr eax) + (addl (int record-ptag) eax) + (addl (Simple (cadr arg*)) apr) + (addl (int (fx+ disp-record-data (fxsub1 object-alignment))) apr) + (sarl (int align-shift) apr) + (sall (int align-shift) apr) + ac)] + [(cons) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl eax (mem disp-car apr)) + (movl apr eax) + (movl ebx (mem disp-cdr apr)) + (addl (int pair-tag) eax) + (addl (int (align pair-size)) apr) + ac)] + [($make-symbol) + (list* (movl (Simple (car arg*)) eax) + (movl eax (mem disp-symbol-string apr)) + (movl (int 0) (mem disp-symbol-unique-string apr)) + (movl (int unbound) (mem disp-symbol-value apr)) + (movl (int nil) (mem disp-symbol-plist apr)) + (movl (int unbound) (mem disp-symbol-system-value apr)) + (movl (int nil) (mem disp-symbol-system-plist apr)) + (movl apr eax) + (addl (int symbol-tag) eax) + (addl (int (align symbol-size)) apr) + ac)] + [($make-tcbucket) + (list* (movl (Simple (car arg*)) eax) + (movl eax (mem disp-tcbucket-tconc apr)) + (movl (Simple (cadr arg*)) eax) + (movl eax (mem disp-tcbucket-key apr)) + (movl (Simple (caddr arg*)) eax) + (movl eax (mem disp-tcbucket-val apr)) + (movl (Simple (cadddr arg*)) eax) + (movl eax (mem disp-tcbucket-next apr)) + (movl apr eax) + (addl (int vector-tag) eax) + (addl (int (align tcbucket-size)) apr) + ac)] + [(vector) + (let f ([arg* arg*] [idx disp-vector-data]) + (cond + [(null? arg*) + (list* (movl apr eax) + (addl (int vector-tag) eax) + (movl (int (fx- idx disp-vector-data)) + (mem disp-vector-length apr)) + (addl (int (align idx)) apr) + ac)] + [else + (list* (movl (Simple (car arg*)) eax) + (movl eax (mem idx apr)) + (f (cdr arg*) (fx+ idx wordsize)))]))] + [($string) + (let f ([arg* arg*] [idx disp-string-data]) + (cond + [(null? arg*) + (list* (movb (int 0) (mem idx apr)) + (movl apr eax) + (addl (int string-tag) eax) + (movl (int (fx* (fx- idx disp-string-data) wordsize)) + (mem disp-string-length apr)) + (addl (int (align (fxadd1 idx))) apr) + ac)] + [else + (record-case (car arg*) + [(constant c) + (unless (char? c) (error who "invalid arg to string ~s" x)) + (list* (movb (int (char->integer c)) (mem idx apr)) + (f (cdr arg*) (fxadd1 idx)))] + [else + (list* (movl (Simple (car arg*)) ebx) + (movb bh (mem idx apr)) + (f (cdr arg*) (fxadd1 idx)))])]))] + [($current-frame) + (list* (movl (pcb-ref 'next-continuation) eax) + ac)] + [($seal-frame-and-call) + (list* (movl (Simple (car arg*)) cpr) ; proc + (movl (pcb-ref 'frame-base) eax) + ; eax=baseofstack + (movl (mem (fx- 0 wordsize) eax) ebx) ; underflow handler + (movl ebx (mem (fx- 0 wordsize) fpr)) ; set + ; create a new cont record + (movl (int continuation-tag) (mem 0 apr)) + (movl fpr (mem disp-continuation-top apr)) + ; compute the size of the captured frame + (movl eax ebx) + (subl fpr ebx) + (subl (int wordsize) ebx) + ; and store it + (movl ebx (mem disp-continuation-size apr)) + ; load next cont + (movl (pcb-ref 'next-continuation) ebx) + ; and store it + (movl ebx (mem disp-continuation-next apr)) + ; adjust ap + (movl apr eax) + (addl (int vector-tag) eax) + (addl (int continuation-size) apr) + ; store new cont in current-cont + (movl eax (pcb-ref 'next-continuation)) + ; adjust fp + (movl fpr (pcb-ref 'frame-base)) + (subl (int wordsize) fpr) + ; tail-call f + (movl eax (mem (fx- 0 wordsize) fpr)) + (movl (int (argc-convention 1)) eax) + (tail-indirect-cpr-call) + ac)] + [($code-instr-size) + (indirect-ref arg* (fx- disp-code-instrsize vector-tag) + (cons (sall (int fx-shift) eax) ac))] + [($code-reloc-size) + (indirect-ref arg* (fx- disp-code-relocsize vector-tag) ac)] + [($code-closure-size) + (indirect-ref arg* (fx- disp-code-closuresize vector-tag) ac)] + [($set-car! $set-cdr! $vector-set! $string-set! $exit + $set-symbol-value! $set-symbol-plist! + $set-code-byte! $set-code-word! primitive-set! + $set-code-object! $set-code-object+offset! $set-code-object+offset/rel! + $record-set!) + (do-effect-prim op arg* + (cons (movl (int void-object) eax) ac))] + [(fixnum? immediate? $fxzero? boolean? char? pair? vector? string? symbol? + procedure? null? not eof-object? $fx= $fx< $fx<= $fx> $fx>= eq? + $char= $char< $char<= $char> $char>= $unbound-object? code? + $record? bwp-object?) + (do-pred->value-prim op arg* ac)] + [($code->closure) + (list* + (movl (Simple (car arg*)) eax) + (addl (int (fx- disp-code-data vector-tag)) eax) + (movl eax (mem 0 apr)) + (movl apr eax) + (addl (int closure-tag) eax) + (addl (int (align disp-closure-data)) apr) + ac)] + [($frame->continuation) + (NonTail + (make-closure (make-code-loc SL_continuation_code) arg*) + ac)] + [($make-call-with-values-procedure) + (NonTail + (make-closure (make-code-loc SL_call_with_values) arg*) + ac)] + [($make-values-procedure) + (NonTail + (make-closure (make-code-loc SL_values) arg*) + ac)] + [else + (error 'value-prim "unhandled ~s" op)])) + (define (indirect-assignment arg* offset ac) + (list* + (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem offset eax)) + ;;; record side effect + (addl (int offset) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)) + (define (do-effect-prim op arg* ac) + (case op + [($vector-set!) + (list* (movl (Simple (car arg*)) ebx) + (addl (Simple (cadr arg*)) ebx) + (addl (int (fx- disp-vector-data vector-tag)) ebx) + (movl (Simple (caddr arg*)) eax) + (movl eax (mem 0 ebx)) + ;;; record side effect + (shrl (int pageshift) ebx) + (sall (int wordshift) ebx) + (addl (pcb-ref 'dirty-vector) ebx) + (movl (int dirty-word) (mem 0 ebx)) + ac)] + [($string-set!) + (list* (movl (Simple (cadr arg*)) eax) + (sarl (int fx-shift) eax) + (addl (Simple (car arg*)) eax) + (movl (Simple (caddr arg*)) ebx) + (movb bh (mem (fx- disp-string-data string-tag) eax)) + ac)] + [($set-car!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-car pair-tag) eax)) + ;;; record side effect + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($set-cdr!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-cdr pair-tag) eax)) + ;;; record side effect + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($set-tcbucket-key!) + (indirect-assignment arg* (fx- disp-tcbucket-key vector-tag) ac)] + [($set-tcbucket-val!) + (indirect-assignment arg* (fx- disp-tcbucket-val vector-tag) ac)] + [($set-tcbucket-next!) + (indirect-assignment arg* (fx- disp-tcbucket-next vector-tag) ac)] + [($set-tcbucket-tconc!) + (indirect-assignment arg* (fx- disp-tcbucket-tconc vector-tag) ac)] + + [($set-symbol-value!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-symbol-value symbol-tag) eax)) + ;;; record side effect + (addl (int (fx- disp-symbol-value symbol-tag)) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [(primitive-set!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-symbol-system-value symbol-tag) eax)) + ;;; record side effect + (addl (int (fx- disp-symbol-system-value symbol-tag)) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($set-symbol-plist!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-symbol-plist symbol-tag) eax)) + ;;; record side effect + (addl (int (fx- disp-symbol-plist symbol-tag)) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($set-symbol-unique-string!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-symbol-unique-string symbol-tag) eax)) + ;;; record side effect + (addl (int (fx- disp-symbol-unique-string symbol-tag)) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($set-symbol-string!) + (list* (movl (Simple (car arg*)) eax) + (movl (Simple (cadr arg*)) ebx) + (movl ebx (mem (fx- disp-symbol-string symbol-tag) eax)) + ;;; record side effect + (addl (int (fx- disp-symbol-string symbol-tag)) eax) + (shrl (int pageshift) eax) + (sall (int wordshift) eax) + (addl (pcb-ref 'dirty-vector) eax) + (movl (int dirty-word) (mem 0 eax)) + ac)] + [($record-set!) + (list* (movl (Simple (car arg*)) ebx) + (addl (Simple (cadr arg*)) ebx) + (movl (Simple (caddr arg*)) eax) + (addl (int (fx- disp-record-data record-ptag)) ebx) + (movl eax (mem 0 ebx)) + ;;; record side effect + (shrl (int pageshift) ebx) + (sall (int wordshift) ebx) + (addl (pcb-ref 'dirty-vector) ebx) + (movl (int dirty-word) (mem 0 ebx)) + ac)] + [(cons void $fxadd1 $fxsub1) + (let f ([arg* arg*]) + (cond + [(null? arg*) ac] + [else + (Effect (car arg*) (f (cdr arg*)))]))] + [else + (error 'do-effect-prim "unhandled op ~s" op)])) + (define (do-simple-test x Lt Lf ac) + (unless (or Lt Lf) + (error 'Pred "no labels")) + (cond + [(not Lt) + (list* (cmpl (int bool-f) x) (je Lf) ac)] + [(not Lf) + (list* (cmpl (int bool-f) x) (jne Lt) ac)] + [else + (list* (cmpl (int bool-f) x) (je Lf) (jmp Lt) ac)])) + (define (Simple x) + (record-case x + [(cp-var i) + (mem (fx+ (fx* i wordsize) (fx- disp-closure-data closure-tag)) cpr)] + [(frame-var i) (mem (fx* i (fx- 0 wordsize)) fpr)] + [(constant c) (constant-val c)] + [(code-loc label) (label-address label)] + [(primref op) (primref-loc op)] + [else (error 'Simple "what ~s" x)])) + (define (frame-adjustment offset) + (fx* (fxsub1 offset) (fx- 0 wordsize))) + (define (NonTail x ac) + (record-case x + [(constant c) + (cons (movl (constant-val c) eax) ac)] + [(frame-var) + (cons (movl (Simple x) eax) ac)] + [(cp-var) + (cons (movl (Simple x) eax) ac)] + [(foreign-label L) + (cons (movl (list 'foreign-label L) eax) ac)] + [(primref c) + (cons (movl (primref-loc c) eax) ac)] + [(closure label arg*) + (let f ([arg* arg*] [off disp-closure-data]) + (cond + [(null? arg*) + (list* (movl (Simple label) (mem 0 apr)) + (movl apr eax) + (addl (int (align off)) apr) + (addl (int closure-tag) eax) + ac)] + [else + (list* (movl (Simple (car arg*)) eax) + (movl eax (mem off apr)) + (f (cdr arg*) (fx+ off wordsize)))]))] + [(conditional test conseq altern) + (let ([Lj (unique-label)] [Lf (unique-label)]) + (Pred test #f Lf + (NonTail conseq + (list* (jmp Lj) Lf (NonTail altern (cons Lj ac))))))] + [(seq e0 e1) + (Effect e0 (NonTail e1 ac))] + [(primcall op rand*) + (do-value-prim op rand* ac)] + [(new-frame base-idx size body) + (NonTail body ac)] + [(call-cp call-convention rp-convention offset size mask) + (let ([L_CALL (unique-label)]) + (case call-convention + [(normal) + (list* (addl (int (frame-adjustment offset)) fpr) + (movl (int (argc-convention size)) eax) + (jmp L_CALL) + ; NEW FRAME + `(byte-vector ,mask) + `(int ,(fx* offset wordsize)) + `(current-frame-offset) + (rp-label rp-convention) + `(byte 0) ; padding for indirect calls only + `(byte 0) ; direct calls are ok + L_CALL + (indirect-cpr-call) + (movl (mem 0 fpr) cpr) + (subl (int (frame-adjustment offset)) fpr) + ac)] + [(apply) are-we-ever-here? + (list* (addl (int (frame-adjustment offset)) fpr) + (movl (int (argc-convention size)) eax) + (jmp L_CALL) + ; NEW FRAME + (byte-vector mask) + `(int ,(fx* offset wordsize)) + `(current-frame-offset) + (rp-label rp-convention) + L_CALL + (call (label SL_apply)) + (movl (mem 0 fpr) cpr) + (subl (int (frame-adjustment offset)) fpr) + ac)] + [(foreign) + (list* (addl (int (frame-adjustment offset)) fpr) + (movl (int (argc-convention size)) eax) + (movl '(foreign-label "ik_foreign_call") ebx) + (jmp L_CALL) + ; NEW FRAME + (byte-vector mask) + `(int ,(fx* offset wordsize)) + `(current-frame-offset) + (rp-label rp-convention) ; should be 0, since C has 1 rv + '(byte 0) + '(byte 0) + '(byte 0) + L_CALL + (call ebx) + (movl (mem 0 fpr) cpr) + (subl (int (frame-adjustment offset)) fpr) + ac)] + [else (error who "invalid convention ~s for call-cp" convention)]))] + [else (error 'NonTail "invalid expression ~s" x)])) + (define (Pred x Lt Lf ac) + (record-case x + [(frame-var i) + (do-simple-test (idx->frame-loc i) Lt Lf ac)] + [(cp-var i) + (do-simple-test (Simple x) Lt Lf ac)] + [(constant c) + (if c + (if Lt (cons (jmp Lt) ac) ac) + (if Lf (cons (jmp Lf) ac) ac))] + [(primcall op rand*) + (do-pred-prim op rand* Lt Lf ac)] + [(conditional test conseq altern) + (cond + [(not Lt) + (let ([Lj^ (unique-label)] [Lf^ (unique-label)]) + (Pred test #f Lf^ + (Pred conseq Lj^ Lf + (cons Lf^ + (Pred altern #f Lf + (cons Lj^ ac))))))] + [(not Lf) + (let ([Lj^ (unique-label)] [Lf^ (unique-label)]) + (Pred test #f Lf^ + (Pred conseq Lt Lj^ + (cons Lf^ + (Pred altern Lt #f + (cons Lj^ ac))))))] + [else + (let ([Lf^ (unique-label)]) + (Pred test #f Lf^ + (Pred conseq Lt Lf + (cons Lf^ + (Pred altern Lt Lf ac)))))])] + [(seq e0 e1) + (Effect e0 (Pred e1 Lt Lf ac))] + [(new-frame) + (NonTail x (do-simple-test eax Lt Lf ac))] + [else (error 'Pred "invalid expression ~s" x)])) + (define (idx->frame-loc i) + (mem (fx* i (fx- 0 wordsize)) fpr)) + (define (Effect x ac) + (record-case x + [(constant) ac] + [(primcall op rand*) + (do-effect-prim op rand* ac)] + [(conditional test conseq altern) + (let ([Lf (unique-label)] [Ljoin (unique-label)]) + (Pred test #f Lf + (Effect conseq + (list* (jmp Ljoin) Lf (Effect altern (cons Ljoin ac))))))] + [(seq e0 e1) + (Effect e0 (Effect e1 ac))] + [(assign loc val) + (record-case loc + [(frame-var i) + (NonTail val + (cons (movl eax (idx->frame-loc i)) ac))] + [else (error who "invalid assign loc ~s" loc)])] + [(eval-cp check body) + (NonTail body + (cond + [check + (list* + (movl eax cpr) + (andl (int closure-mask) eax) + (cmpl (int closure-tag) eax) + (jne (label SL_nonprocedure)) + ac)] + [else + (list* + (movl eax cpr) + ac)]))] + [(save-cp loc) + (record-case loc + [(frame-var i) + (cons (movl cpr (idx->frame-loc i)) ac)] + [else (error who "invalid cpr loc ~s" x)])] + [(new-frame) (NonTail x ac)] + [(frame-var) ac] + [else (error 'Effect "invalid expression ~s" x)])) + (define (Tail x ac) + (record-case x + [(return x) + (NonTail x (cons (ret) ac))] + [(conditional test conseq altern) + (let ([L (unique-label)]) + (Pred test #f L + (Tail conseq + (cons L (Tail altern ac)))))] + [(seq e0 e1) + (Effect e0 (Tail e1 ac))] + [(new-frame idx size body) + (Tail body ac)] + [(call-cp call-convention rp-convention idx argc mask) + (unless (eq? rp-convention 'tail) + (error who "nontail rp (~s) in tail context" rp-convention)) + (let f ([i 0]) + (cond + [(fx= i argc) + (case call-convention + [(normal) + (list* + (movl (int (argc-convention argc)) eax) + (tail-indirect-cpr-call) + ac)] + [(apply) + (list* + (movl (int (argc-convention argc)) eax) + (jmp (label SL_apply)) + ac)] + [else (error who "invalid conv ~s in tail call-cpr" convention)])] + [else + (list* (movl (mem (fx* (fx+ idx (fxadd1 i)) + (fx- 0 wordsize)) fpr) + eax) + (movl eax (mem (fx* (fx+ i 1) (fx- 0 wordsize)) fpr)) + (f (fxadd1 i)))]))] + [else (error 'Tail "invalid expression ~s" x)])) + (define (handle-vararg fml-count ac) + (define CONTINUE_LABEL (unique-label)) + (define DONE_LABEL (unique-label)) + (define CONS_LABEL (unique-label)) + (define LOOP_HEAD (unique-label)) + (define L_CALL (unique-label)) + (list* (cmpl (int (argc-convention (fxsub1 fml-count))) eax) + (jg (label SL_invalid_args)) + (jl CONS_LABEL) + (movl (int nil) ebx) + (jmp DONE_LABEL) + CONS_LABEL + (movl (pcb-ref 'allocation-redline) ebx) + (addl eax ebx) + (addl eax ebx) + (cmpl ebx apr) + (jle LOOP_HEAD) + ; overflow + (addl eax esp) ; advance esp to cover args + (pushl cpr) ; push current cp + (pushl eax) ; push argc + (negl eax) ; make argc positive + (addl (int (fx* 4 wordsize)) eax) ; add 4 words to adjust frame size + (pushl eax) ; push frame size + (addl eax eax) ; double the number of args + (movl eax (mem (fx* -2 wordsize) fpr)) ; pass it as first arg + (movl (int (argc-convention 1)) eax) ; setup argc + (movl (primref-loc 'do-vararg-overflow) cpr) ; load handler + (jmp L_CALL) ; go to overflow handler + ; NEW FRAME + (int 0) ; if the framesize=0, then the framesize is dynamic + '(current-frame-offset) + (int 0) ; multiarg rp + (byte 0) + (byte 0) + L_CALL + (indirect-cpr-call) + (popl eax) ; pop framesize and drop it + (popl eax) ; reload argc + (popl cpr) ; reload cp + (subl eax fpr) ; readjust fp + LOOP_HEAD + (movl (int nil) ebx) + CONTINUE_LABEL + (movl ebx (mem disp-cdr apr)) + (movl (mem fpr eax) ebx) + (movl ebx (mem disp-car apr)) + (movl apr ebx) + (addl (int pair-tag) ebx) + (addl (int pair-size) apr) + (addl (int (fxsll 1 fx-shift)) eax) + (cmpl (int (fx- 0 (fxsll fml-count fx-shift))) eax) + (jle CONTINUE_LABEL) + DONE_LABEL + (movl ebx (mem (fx- 0 (fxsll fml-count fx-shift)) fpr)) + ac)) + (define (Entry check? x ac) + (record-case x + [(clambda-case fml* proper body) + (let ([ac (Tail body ac)]) + (cond + [(and proper check?) + (list* (cmpl (int (argc-convention (length fml*))) eax) + (jne (label SL_invalid_args)) + ac)] + [proper ac] + [else + (handle-vararg (length fml*) ac)]))])) + (define make-dispatcher + (lambda (j? L L* x x* ac) + (cond + [(null? L*) (if j? (cons (jmp (label L)) ac) ac)] + [else + (record-case x + [(clambda-case fml* proper _) + (cond + [proper + (list* (cmpl (int (argc-convention (length fml*))) eax) + (je (label L)) + (make-dispatcher #t + (car L*) (cdr L*) (car x*) (cdr x*) ac))] + [else + (list* (cmpl (int (argc-convention (fxsub1 (length fml*)))) eax) + (jle (label L)) + (make-dispatcher #t + (car L*) (cdr L*) (car x*) (cdr x*) ac))])])]))) + (define (handle-cases x x*) + (let ([L* (map (lambda (_) (gensym)) x*)] + [L (gensym)]) + (make-dispatcher #f L L* x x* + (let f ([x x] [x* x*] [L L] [L* L*]) + (cond + [(null? x*) + (cons (label L) (Entry 'check x '()))] + [else + (cons (label L) + (Entry #f x + (f (car x*) (cdr x*) (car L*) (cdr L*))))]))))) + (define (CodeExpr x) + (record-case x + [(clambda-code L cases free) + (list* + (fx+ disp-closure-data (fx* wordsize (length free))) + (label L) + (handle-cases (car cases) (cdr cases)))])) + (record-case x + [(codes list body) + (cons (cons 0 (Tail body '())) + (map CodeExpr list))])) + + +(define SL_nonprocedure (gensym "SL_nonprocedure")) +(define SL_invalid_args (gensym "SL_invalid_args")) +(define SL_foreign_call (gensym "SL_foreign_call")) +(define SL_continuation_code (gensym "SL_continuation_code")) +(define SL_multiple_values_error_rp (gensym "SL_multiple_values_error_rp")) +(define SL_multiple_values_ignore_rp (gensym "SL_multiple_ignore_error_rp")) +(define SL_underflow_multiple_values (gensym "SL_underflow_multiple_values")) +(define SL_underflow_handler (gensym "SL_underflow_handler")) +(define SL_scheme_exit (gensym "SL_scheme_exit")) +(define SL_apply (gensym "SL_apply")) +(define SL_values (gensym "SL_values")) +(define SL_call_with_values (gensym "SL_call_with_values")) + +(list*->code* + (list + (let ([L_cwv_done (gensym)] + [L_cwv_loop (gensym)] + [L_cwv_multi_rp (gensym)] + [L_cwv_call (gensym)] + ) + (list disp-closure-data + (label SL_call_with_values) + (cmpl (int (argc-convention 2)) eax) + (jne (label SL_invalid_args)) + (movl (mem (fx- 0 wordsize) fpr) ebx) ; producer + (movl ebx cpr) + (andl (int closure-mask) ebx) + (cmpl (int closure-tag) ebx) + (jne (label SL_nonprocedure)) + (movl (int (argc-convention 0)) eax) + (subl (int (fx* wordsize 2)) fpr) + (jmp (label L_cwv_call)) + ; MV NEW FRAME + (byte-vector '#(#b110)) + (int (fx* wordsize 3)) + '(current-frame-offset) + (label-address L_cwv_multi_rp) + (byte 0) + (byte 0) + (label L_cwv_call) + (indirect-cpr-call) + ;;; one value returned + (addl (int (fx* wordsize 2)) fpr) + (movl (mem (fx* -2 wordsize) fpr) ebx) ; consumer + (movl ebx cpr) + (movl eax (mem (fx- 0 wordsize) fpr)) + (movl (int (argc-convention 1)) eax) + (andl (int closure-mask) ebx) + (cmpl (int closure-tag) ebx) + (jne (label SL_nonprocedure)) + (tail-indirect-cpr-call) + ;;; multiple values returned + (label L_cwv_multi_rp) + ; because values does not pop the return point + ; we have to adjust fp one more word here + (addl (int (fx* wordsize 3)) fpr) + (movl (mem (fx* -2 wordsize) fpr) cpr) ; consumer + (cmpl (int (argc-convention 0)) eax) + (je (label L_cwv_done)) + (movl (int (fx* -4 wordsize)) ebx) + (addl fpr ebx) ; ebx points to first value + (movl ebx ecx) + (addl eax ecx) ; ecx points to the last value + (label L_cwv_loop) + (movl (mem 0 ebx) edx) + (movl edx (mem (fx* 3 wordsize) ebx)) + (subl (int wordsize) ebx) + (cmpl ecx ebx) + (jge (label L_cwv_loop)) + (label L_cwv_done) + (movl cpr ebx) + (andl (int closure-mask) ebx) + (cmpl (int closure-tag) ebx) + (jne (label SL_nonprocedure)) + (tail-indirect-cpr-call))) + + (let ([L_values_one_value (gensym)] + [L_values_many_values (gensym)]) + (list disp-closure-data + (label SL_values) + (cmpl (int (argc-convention 1)) eax) + (je (label L_values_one_value)) + (label L_values_many_values) + (movl (mem 0 fpr) ebx) ; return point + (jmp (mem disp-multivalue-rp ebx)) ; go + (label L_values_one_value) + (movl (mem (fx- 0 wordsize) fpr) eax) + (ret))) + + (let ([L_apply_done (gensym)] + [L_apply_loop (gensym)]) + (list 0 + (label SL_apply) + (movl (mem fpr eax) ebx) + (cmpl (int nil) ebx) + (je (label L_apply_done)) + (label L_apply_loop) + (movl (mem (fx- disp-car pair-tag) ebx) ecx) + (movl (mem (fx- disp-cdr pair-tag) ebx) ebx) + (movl ecx (mem fpr eax)) + (subl (int wordsize) eax) + (cmpl (int nil) ebx) + (jne (label L_apply_loop)) + (label L_apply_done) + (addl (int wordsize) eax) + (tail-indirect-cpr-call))) + + (list 0 + (label SL_nonprocedure) + (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg + (movl (primref-loc '$apply-nonprocedure-error-handler) cpr) + (movl (int (argc-convention 1)) eax) + (tail-indirect-cpr-call)) + + (list 0 + (label SL_multiple_values_error_rp) + (movl (primref-loc '$multiple-values-error) cpr) + (tail-indirect-cpr-call)) + + (list 0 + (label SL_multiple_values_ignore_rp) + (ret)) + + (list 0 + (label SL_invalid_args) + ;;; + (movl cpr (mem (fx- 0 wordsize) fpr)) ; first arg + (negl eax) + (movl eax (mem (fx- 0 (fx* 2 wordsize)) fpr)) + (movl (primref-loc '$incorrect-args-error-handler) cpr) + (movl (int (argc-convention 2)) eax) + (tail-indirect-cpr-call)) + + (let ([Lset (gensym)] [Lloop (gensym)]) + (list 0 + (label SL_foreign_call) + (movl fpr (pcb-ref 'frame-pointer)) + (movl apr (pcb-ref 'allocation-pointer)) + (movl fpr ebx) + (movl (pcb-ref 'system-stack) esp) + (pushl pcr) + (cmpl (int 0) eax) + (je (label Lset)) + (label Lloop) + (movl (mem ebx eax) ecx) + (pushl ecx) + (addl (int 4) eax) + (cmpl (int 0) eax) + (jne (label Lloop)) + (label Lset) + ; FOREIGN NEW FRAME + (call cpr) + (movl (pcb-ref 'frame-pointer) fpr) + (movl (pcb-ref 'allocation-pointer) apr) + (ret))) + + (let ([L_cont_zero_args (gensym)] + [L_cont_mult_args (gensym)] + [L_cont_one_arg (gensym)] + [L_cont_mult_move_args (gensym)] + [L_cont_mult_copy_loop (gensym)]) + (list + (fx+ disp-closure-data wordsize) + (label SL_continuation_code) + (movl (mem (fx- disp-closure-data closure-tag) cpr) ebx) ; captured-k + (movl ebx (pcb-ref 'next-continuation)) ; set + (movl (pcb-ref 'frame-base) ebx) + (cmpl (int (argc-convention 1)) eax) + (jg (label L_cont_zero_args)) + (jl (label L_cont_mult_args)) + (label L_cont_one_arg) + (movl (mem (fx- 0 wordsize) fpr) eax) + (movl ebx fpr) + (subl (int wordsize) fpr) + (ret) + (label L_cont_zero_args) + (subl (int wordsize) ebx) + (movl ebx fpr) + (movl (mem 0 ebx) ebx) ; return point + (jmp (mem disp-multivalue-rp ebx)) ; go + (label L_cont_mult_args) + (subl (int wordsize) ebx) + (cmpl ebx fpr) + (jne (label L_cont_mult_move_args)) + (movl (mem 0 ebx) ebx) + (jmp (mem disp-multivalue-rp ebx)) + (label L_cont_mult_move_args) + ; move args from fpr to ebx + (movl (int 0) ecx) + (label L_cont_mult_copy_loop) + (subl (int wordsize) ecx) + (movl (mem fpr ecx) edx) + (movl edx (mem ebx ecx)) + (cmpl ecx eax) + (jne (label L_cont_mult_copy_loop)) + (movl ebx fpr) + (movl (mem 0 ebx) ebx) + (jmp (mem disp-multivalue-rp ebx)) + )) + )) + + + +(define (compile-program original-program) + (let* (;;; + [p (expand original-program)] + [p (recordize p)] + ;[f (pretty-print (unparse p))] + [p (optimize-direct-calls p)] + [p (remove-assignments p)] + [p (convert-closures p)] + [p (lift-codes p)] + ;[p (lift-complex-constants p)] + [p (introduce-primcalls p)] + [p (simplify-operands p)] + ;[f (pretty-print (unparse p))] + [p (insert-stack-overflow-checks p)] + [p (insert-allocation-checks p)] + [p (remove-local-variables p)] + ;[f (pretty-print (unparse p))] + [ls* (generate-code p)] + [f (when (assembler-output) + (for-each + (lambda (ls) + (for-each (lambda (x) (printf " ~s\n" x)) ls)) + ls*))] + [code* (list*->code* ls*)]) + (fasl-write (car code*) (compile-port)))) + + +(define compile-expr + (lambda (expr output-file) + (let ([op (open-output-file output-file 'replace)]) + (parameterize ([compile-port op]) + (compile-program expr)) + (close-output-port op)))) + +(define compile-file + (lambda (input-file output-file) + (let ([ip (open-input-file input-file)] + [op (open-output-file output-file 'replace)]) + (parameterize ([compile-port op]) + (let f () + (let ([x (read ip)]) + (unless (eof-object? x) + (compile-program x) + (f))))) + (close-input-port ip) + (close-output-port op)))) + + +(parameterize ([assembler-output #f]) + (for-each + (lambda (x) + (printf "compiling ~a ...\n" x) + (compile-file (car x) (cadr x))) + scheme-library-files)) + +(system "rm -f ikarus.fasl") + +(for-each + (lambda (x) + (system (format "cat ~a >> ikarus.fasl" (cadr x)))) + scheme-library-files) + + + +(define replace-safe-prims-with-unsafe + (lambda (x) + (define prims + '([fx+ $fx+] [fx- $fx-] [fx* $fx*] [fxadd1 $fxadd1] [fxsub1 $fxsub1] + [fxlogand $fxlogand] [fxlogor $fxlogor] [fxlognot $fxlognot] + [fx= $fx=] [fx< $fx<] [fx<= $fx<=] [fx> $fx>] [fx>= $fx>=] + [fxzero? $fxzero?] + [fixnum->char $fixnum->char] [char->fixnum $char->fixnum] + [char= $char=] + [char< $char<] [char> $char>] [char<= $char<=] [char>= $char>=] + [car $car] [cdr $cdr] [set-car! $set-car!] [set-cdr! $set-cdr!] + [vector-length $vector-length] [vector-ref $vector-ref] + [vector-set! $vector-set!] [make-vector $make-vector] + [string-length $string-length] [string-ref $string-ref] + [string-set! $string-set!] [make-string $make-string] + )) + (define (E x) + (cond + [(pair? x) (cons (E (car x)) (E (cdr x)))] + [(symbol? x) + (cond + [(assq x prims) => cadr] + [else x])] + [else x])) + (E x))) + +(parameterize ([input-filter + (lambda (x) + `(begin (write (eval ',x)) (newline) (exit 0)))]) + (test-all)) + +(define (get-date) + (system "date +\"%F\" > build-date.tmp") + (let ([ip (open-input-file "build-date.tmp")]) + (list->string + (let f () + (let ([x (read-char ip)]) + (if (char=? x #\newline) + '() + (cons x (f)))))))) + +(compile-expr + `(begin + (display ,(format "Petite Ikarus Scheme (Build ~a)\n" (get-date))) + (display "Copyright (c) 2006 Abdulaziz Ghuloum\n\n") + (new-cafe)) + "petite-ikarus.fasl") diff --git a/src/ikarus.fasl b/src/ikarus.fasl index 61bc83d081a12e5950f4538b3afeb573375b0eff..047aad26b436012c2fd961ef930d27d6a6d55128 100644 GIT binary patch literal 810086 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 u0Gj_nC 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

<>b&OE@0(vTP*6U^E$z& zDnRcXHeX$Vt~x<_J#D;?9bj;AIR6%hP#QiCX9e_^4WYsY5sFg$CV08^D@aanfXj!} zC|dEt;|tslG*}Lns#u|t|3oY{gYN-)%y1X{D`Tf4)diff(lJFCKIv$U0_oWcaAy0UWndfN1Wq?Q4vM|^49h@A(?$a}Dblm0 z?H^U37>1X(31wfN4gR`D0F}Wu1gp|fu$}+`i%eEI^U%CG&tyrwRUGW<3dCiy;%=J? zV8NkhzV?r__TFAP!r1vcGJ#p@#O|40%O>E1w9Ec+Q1iwCes_;%nOeIswSMABM3gDl zvC``ba&t&TTWN*F-2yvW*#t{oD&7%0u1gQ0w|MW7qJ^J8ZU;#9qMRQ%s)T~ser%R2 zKfWkdYzJGqt{_QJ%=aOFcmSf^3@vze4Lbpf5IO-r#PGi`z+93Ib~m}-AQ`-`1LB+3 zRWvJ(i?A^z7g`0$md^sz5>md~a57wP2PDHa0#uT-45#N#2J|)r&*9aE({qCX={Z{3 zq%F0YxgOSxQOG zWlT;-dMZN=N2%QtFuW%sCS3AE>(%t!MnJzp@Xv)QM`=qZUfj7pl5mnS=I%{^R)^<4 zU^qQD15nJRGCi!yue66fImo#SOe4S0!|J*09=7TX%6VJCb1i_rfZ+9`yB%^jcC4hC z)EG{s5?pTaV{wP)!cp%OfxVxl4r{|IP_;oL;SDF?>`ise2M zP^9u(AV{TpEPm>^fp;+S8-4G=jukc~b-Bw=WA)GFF7L|c^Y1srj4>GYxD2aTq{cxnY3#^bRe69U}B){?~i|!Go1gXP!+Q=bAIe)|2hT6@TU+>tvXe zil52w?qP3c3*I;kSvguRBqGr_Y%hG33tTknwz*s+b#n^(YHkpWO_IAhrXf_Z*c^9t zgo+r?Z&B~{G!n4i@hKkz6jMG5NEL(f`J>kf7ERl2z%75C=~ofc`k=Vp4d^?>5h~Z4 zD`lD9T+h|uVM$cjo9nqAH58>RY$z{-7RMp@hVp0l)se%KfDSjD`>Em7P#yxr4DbzQ zJ)lTsZkn?C^+-_1nTi#N3`O|+X(%s6U2cPC?XNJpD5}fNC9`@1x;Y2L8?^80Xi3$x6Pccm<>?iZnIUV-4N`#EVv_5H#KKobn- zjxn67`#?akx<3u0AE>y^fPRYLX>LF)HlaHJJ!m-h5yOe*&441!S%3l+R|BXP!P6X# zSfqJ8pz{ppUS>Ga+=FD1=97Q|75800TM#_WFC&J(^caRuBl;b~xqmjCXkHH}(wqh; zP;qYtbTNXbITA7ar8JL4^jyQaL535}Kcjz*G#>*LsJL$f`T>Hcc^6`l=52uPHJn>w zIMG}HDAIfnpg_f)1L%ANPqPBCNb_hwXBp1D2=`Dp(d+;eY5oFGpyIv>Xd{BBc?V*V zW-Fkt8_s>maH2UEP^5V|pg_f)0q8sgPxE-hBF({oPB)zEf&(1od>T-s`C~wViu)>{ z?;v=ZpGGXwyamuY!?{I=6r(i{lr6vMe^(R!ntzX23! zZUGdixVr&;3&GR;IAW3J5z| z7hu9pG@N?|P?YmAK#}HVK!J+;9H6fuc$&8&7HM7&=yt=oIfj#*?*$ZTz70^I;)Vk{ z9l_Haj98@kJf1$zaPGH&qMW}36lrb*6sWj60If&xG?yb5X?_S0@xr-A!{L7}nTFp; z(*X)p-0J|n5y8`ZHDZzGVStGDH2+dC8TO1#hQS`>+|K|7D()UY4^9n%3 zdzxGli@Nh(q{$WbK*e1IMXo^bG|xpW(mV|i@t)?1hLfC_;qo+L3;hWLfy&7>7r%Y% zS=hcW&5ANRO$W?Fuqrl!+7opz_gBH=~j-F9b} zMRrpZiuT1FYZ0*a_E?` zjI`l*%oX|YS+6&5C}Fr34A*BfT%XTyd>!bnf-&}2$ny2ZuxnWs!}TQ$*MQ-=Y=-Od z8QwevoTjh_=?Vem>@_DqgzN;s|r$JN;!R~K*`I2#-@-Zfoq9Cv4OTwTI( z1vswC=D4bW`Dsaa$(Gr9~WD^nq*5lw3(55X zX`ID)$>tl7ppf^#rC@pvH&*CMc`s>aN@M>>278~cB@)c{5>WkY35Y3_;PB<(T*XB~ zT|ok-Gzm6mO28B)5;Wi@@_<>9Edeow5)9#_SyJKohu(cjJ5!nj8#5(fiV_KC<0d3v zR%A;+OrZoPtpxK+URxpoQa^h0%k?F1jH0daPw*~pE9yU0;V(x?#+~dDWU{5ps=i^atdxj0%k?F1jH0d zuy+j}ojD3Wxl7fWx!WAFZ+i$9v@+rZSX=skC^uQz|$3UCBIq$luF2 zQYA`032gfz`6Z{Pf?F4~q&;79mXnu!xtF{Jl0y$DFf>mAody#WSl=rJ*pB+4z@#&} zRiGs6mwE*j^HiJE&QCZNF}6yaP6*wg;&A+f!WDTcjw&dlb-hw?P5)Hf!G!@`J+EC* z0GbZPKWIw*Xq%~@X-XBLX@%FcvaF_Sd!^}Eh}nOK}A}9AO+36r5iz8WO%!ibycrq9ooN4-EdxcSbU=lUSw;sYt+&P#eN;c9hQ z2U5s|wS5qh?!|!=a_~F)AS7Lz11aQcPW$O9^;gQ6?$sLk^h(GIaOj7tF_yEvx=MwF zlf>ac`Mz+qhDkjTw~ZY7A>||Q_A=%TFzKFyBLB6nmYhA10~^g#PlHD=`llruNQhwF z(ajr=esK4Z5AHl<;041UuE~LX-uS4We%-DqnQGYhD2_7LV3d(pMe>}weM<{fNXX~L z|A?B4r}a?Hwf#^t4*mLBDC1`IP}+6>8>H>1@1e9C`XOz8bG3LK>Xgk1OsPzL;F5z( zmuzM;isvQ12uM={TREAntH92rZ7>#Q1=8SV%8gSY*)tHt6wN>kSc_-pzh6x76ZkNx zH8C~va^sMFw=HA<=SH$cB1R;{jGEtk$T|q}0B6;81(7tt;^$dPRG)+g!G}4J&4-vm z)o(s*J?KwqOxZ-$nbcHItxKL+Nrzx*UdxgmN)m-T8Os*w@cAYDl)XJQt9{DMjt`VD z-7lHBVnGR?{hFDRcvy+9P)T}~nXwx6(;P0mHdBzIS_IdCv#0&AG3biZ39{bwQCf`M z1PN>3gIVuttkmPhPA(rc)#FUFF>@N{FIuSM{YTVRG66OqAOTmjB5Di|j!A|B%@y+M zLHMaV2aDX-A#x>J9|w*nMC9BS{Af=EpLTcS=NW`5mVem&S@wBLZftT5}0QCg~QFd%jk?UoErWr1&K}?xOW<1+FT&&_Qya`22Jn@a< zhc}_Bj{xMGz|47L7A%}TsqYP3{4tqGfXbi5X}TbodO=fo$ypK-H9L;^bH0cgDQN1@n;qv2iDLMqIm-E(A0O z!81PBaAJHaATh?SSW)MeUy2Ad`unjFGTgmy^4#;? zY2Jh0NGkU(#isavg36jLQtu}))7)eDQ9V$WKMIJqtJsYF`w27^C9Rf+cWhuf7Pb2- ze)N`tD6-*xhd4r^;rh+dq3J1QnWm@bYVdHZpP{AcxsisG%xoyUUB#9bo0L*AfvB)a zxjk44emSa)Zvp&FY~;Yt%l-wySHvF}P8`|*i35|n&l4A@EVh)Y&W(U>L-16tG@PhR z0z@j+?CmB_<_-s#gT|TDn`Y*hR zp9UnHSndEM!P$b6jVZ30{qe!pf=tkr`g6_gdPAaYYhkAKx3#cXV`~w`&{_zUYb{Dy zrnTs~8ay29a%e4ju1Bp!DGOW6H&9)^hu~Yw?P=xlZ}u(&wBB&;dc&#GT@5I?9pgG{UM(D zTRbyeLiP_Kwfcua)LvJt@qX0cy-U7u*Pi8FHsk0rKBvU5r@0+VKTB62rNemSpYGGo zH7`}O5b$F9b68?@%7P@}5FVXh1d(u>NVx+{d9=?S>qT{{&uW%gp=$B)qJq9U9*qQr z$ct|&c4lXw_r&$MxSYf4P{ajP=;Yghd3=|-n{!aoOyq$PboIl55xID3km~S{QR>k$ z@R(Gdc~Hgb<-Tn=rTj7=)%L@HtNjF^ZvFOKNrsi!@%wG&yYUmKxL*Sj6?OmLGf2;^ zFi4U$1G*EzbKrSpdQK^40}=!LoI&cGt^YX@iWwcO6@BERnxJXIGMRN zzrOxzZ+>1x>t_1uSK+5_Fq(N6BHsMu%9x)X?l8|VKYoXKcdZ7@z1bPeyyw{+{)&wq zb-xo73O}w`aOM|U2+srZUv8AS+2cElKG@J<9H{9E5_G9mr;WGQ$FEIcSrrj{>0h(% zWRou9QYdk`(;JYgU~VGko-Js74;rNUe=ne)AXKsXxGxz__3<-+qIqcs)UA2>Ajz<~|OPycbdFk$F+dU|s|T^CD;*TKt6w-n>+%?caMZuLSf4 z!?}TmlX-a#Pe=2z15lt+dmkV_a*ET6<7;okU7f2uaWZ`c9jlW!uae9Gp1M}k_8qi6 z2W?LuT^m-Pm%#R*w&&R%5e>G7P&wP9lx1v>o-1Q}^jwc@k5cx*_UO4D*&fMR#`cIx zk8F=p2HPVj*d9Tbp~X)_@V4i?wEcVAGaAsPhI7LWC);y0plExZLoX4i)IJKR8q+&4 zK%9=^CrMHxqYsl@1GEgPyuNxs|BN63+&c{?CKm!C6aV>+tLhsUTtBz=Y}}kom7-xw zo`VY~yM+m{T-_SDsT&cYf42YDI5ssud3f^+ho*CCbuTnOIk5Q!n_`P=ksaBS9eJNa z&>?GlKipqo(4<4w+A46DGaeYfm7T-lN|#1hW!E^uaH(LL2U8;H2q(_dbT`rrd^A7P zz%tSmM7A?!JKqA*K4;p-BZ-95nL3;De}Qp)`I|46SFz~ajfj29pkyjyv8KEO5SzbG zIl*wMDLhDrHKiJp{HQLh9@k)r4~wt-!WS34R@;+trAPJeX(ZK3kN7_ZNE}6#4cyni zfr!nz?!08Z;q~n20eu(2OZ0KW=~+%g`e(VWkP72J_34^$=L;r}n^6E=251_BXeKp? zNgjhaN=+$ zAaNimw-ivMazUE1?h@cA3g-Yq+p}SG8}D{knXS9Q|AOh~m|NaapIq~4ze$i~DuORRPG_oKtA(EqXrkfV35Jt?M*)iZbz)jM zQu!939+V$)b^q(f@9}*X!RzG;k z?PEeGmg>iovb$YuNbO5l7y!%@rSta!y%CI5E|P5&Aj($FDI`CxN=-VyLRn;hj)br$ zAovXE!m?p3;NJo|!f@^vh7*&22NW}41E5Id18K^ARA6S!ey_mqhb-44c>Ug$O6CiA z0-&o5=iXpA>GwK7QNN=BMJkV?>8S#DU%;t;`>%kjSinW)`3PkD1%lW2-c(Yr?_Gc% zGMuyTnN&&NTW~+>+W;t1u`eO)qe8QLLwO!peMdslH<(VzD-etIcL1Q14d?y{|2{U7 zCjmu${{v8@(we5+NBvFpE$i)~p=zo(H@2}`$dtW+N6B>Hi<V9Op7+J zXhhHvH{q^8a-{GF%d$onZK~#)ci^FEr496xbp?6bZRw|DnckZ3!ggDf-X6TVt)YQ` zvAGj3Hn;IXyw;rlAMVfKoKRsW;8XzJ{LrXP_~!;7gNM?CW_BmcrdUOv1Vp@W?&pS6 zlY9hFEW&RAid2?cO8NFY!08SIPo>FlqB0W@srZgS`|bSqgyWg;lB>p^Qq?*e&}9go zVvoFcQYkV<+rgM;xO-!?8L_DOzX1A~;oMz@lgyt4gunFDq$Vo(7`Brm=Qvo6R`W05ElAa_oe(Q8i{gUc;-|U-KYsUj z(RW|B6G4}};JdH);6|(xUj)P!BYKX-8adwzNLAu6L~0k}N3+8I`(wUB>kDL815?HM z95)L;KO{uy+;sdb3J|OIG=q{F#G(|T>g%~4Rehyo%@q|5T+f8C+{Nmv{t0QN_5Cmp zR~~IR_g9R$qn_=6fJ&=A4_A&1&=%fJ~SxaOR{T5^;XPU8~=`YyDy1J>SZWcLw zDW-M!pk@DwASpk`}of$SJ=%I>^*2M*<88y)=D%fiH%vTQdkXCYDA4YMDpJDhY z?x=CeU@ZZpugdT_x6p9vbNFgYOnDZdS_E-$m4;KwR|8TLl_}z$8f}eVIB#CX-06+i zS759DqPf`OyP$S2nv(xk@?Q~qx6w;}2PpE|0f>0d>rumr*Moo}udf1{jCr8a{oAsA znx-2@)$TyTLB`H;_tts@F-UGkEHZBbw8C(%-f(2@&H;2ppfVg#RDpIsQh5={iT5h} z5s+|F;YmPJft{NBC4RK?YXqS!`1vmcFBvO@o>L)z9T4%J=ADKU%})Rl%_9(T%kUGZ zxEla9BKYSL#HJgRj7N;m`Ii~+*26V;^`Pmh`0_&~kaH}#V^+5Yh@uhi2~!RUD|3H6 zO!HC%Z|>_;L+#D|<$$g+oJ$NRMcxQVijb5$5m2P^D_C~ku6`|k>h{34Z9o=}0uUxE z`(Sgs^>onkd%fc+>w}YF3cug>Y5hRxt1FuH)Tc=$Ew|ID84gqM_+{&MAPb9W(bhF% zx#CQ}8IA@UxA?6&y`bg&dOxnf*S^Y~t>27KMhCm9Z=)@zanKdy*5{)6bz$ua_5Dow zkHi)4W8Ioz{qrRSy?uP+EM$fR9LlCsBp{1Fl`l2?A75_XyffC9YJEd*4ceo>LLu&iWc-jeJ2i^i-dgk5 zRM_3VZ-=M8yXftNs%~vRv>b#wtMlf>ns=eF2PpxOXmTzzq@6V^;#Yk%^_kWrmXq#~UP3jskRg zNSQO7RG=61X2T_`07VY1fcQym&*3J+iNi$(NfsX3txo>6%$9Iyw^DYY_lY#00VL-@ zDfwN!m@Q$WsHFZZaBT>l`$zIqx_1G3*l@{P3@2I60Cb7r+z7)-mj8x$;wKJI0OBTc z&*5i=Q_6<{sfU%f_OE~@^Fe)~C;h7S2EhKS)n7%7`z<`7y8(TNII39gRUWB-EfNIv zTmmS%8)pNGR60SP9I8*oPaRv*BglzL00-R-8ngZEZgg5Vm5xBmyBfuw!40LZ zhV5;j+?@J>XHeeL$lKl_&)@;JK3&1wYkNm()Kkx({MS^ACtCNg;uq4>kP!4JC(SzP z^EkRy4LCHb;sfoEsVIjt&UWJm=*oRo4CpvMs;g}cviN_m|@lIdzdw_3^z_*G!nfhLg~90r~6!D{NJ&O8B|o zD9;-KU5?=8In{7_HoUDOE>EF{(maPG58nz=%DaGzG`UfWZ?kxs%M2$S>4b0|#OqPU z2@!`LIU!2fHz$O90`xwyoDdNTP6(lLPKZ*LaYFQ54IYj)DmWo}u18LYQZlzhMNY_i zMDIuNPRJ_6gj1d6r^5ItG2z^`hEu`J0i;TV|2a1azmdu@Y0BzTfUBd&xe*a&%ip~d zlJ+a?j>~S23=_VZuPAo_1PofyRBtyEw7y@{JdB7|uncsC4j`^O@jj^gCGBozJBo=e zEOkL5(K8E(mh(f9J(;WJ`aUjeieJ~h(^{^o8D}={VasK8(e})kl0yeUN;w|TKZcaA zH=HWu^LRL>d>W88S&HUkhEvK%0jcUzUw@ni_7;~t3P%GAn6JDu0z~v~+|s~;P`Ng( zlx5nqo~yybQS8vB_1s9q9ZC*m1{O-m1frrg{S1Epis0MyFA$3y_}RSOhI98BP8`+& zif#I1fFc#n43SDTg{qr|{1}Gpr^~Qkwi~dWow8TdhxiGQf=S4N6&N~t^k>U%O9%~8 zOB5SfmbyaQ;Y^_xT1BN7@1=JPETt8^oiY-4Cux{|l%%s+D!R%^T7KHJczluZU8A_d zWu92f)}9NwhkbaFkkZ`pltqaWN*AxojfjwnP9c50!Z+u0?rr(LgF6<`$p}@fh{-_1 z$v*rURg!q&Tv(t{<^C_=VypilARYEHV|pW(pZ#eM6$`JOGo!wi@8kQI=)aFxWcC$6 zYDsci?f`T@Q&JGeZfN9=k+ zV)-h>PBlnpeMRA(Me<_|=bi!-g}c`v<=K}2J%r$Ce%5djZaJVR+%efX*NN_{J!^@ejFG@Np; z0Z^pLclrYrH-^tJpp0_Kafn5l{1)hGhKt_<70vK1P$qZ$7HFVS?pvTL@;aSwO^lnjbM7{^ydL@f&IK<(fdnT@0uW!P6XvSfn`$5b>Vo z35LV}TyhkCBh9~JKpd#JUjTXv!PEQ!Vv**3fQa`rzic?syd6-a$&Y9UDy|;TLIh9q za>OFd1Q79_=DCIw%~JtIn*4@npyHlIr+$b%mplO|()Ivc0Z^p*dO(4S8v^Jx2%hGP1wG*(01@wLK5jVC{3)PF zlkQNU;_d*n9>LRGj#!lQMnJ@Sn)3}On(qS?X>!v=pyEaY;*x}?c>-dQ=8=Gi_cZsy z8VVX`9A=RS(xNR#K_M4EE}1uD(~dN+cn z`6k4ooTmXI-phHS;Uwn}K#}GiFb!17eP2{^o`#ecA*3`Bi*j;;Pc+dFbn|`D6?`0l zSKLNRuN=OVKY@iJ7R{?QZ}!Ko{EnzYC`$)px`LQ_o=i_oUN-tquY(l#6OKHK8F7Xd^22U z*bLX1zcHiiTa}bi8L4UajLmQz!qN*ay9G5}bjC1-$xw7V;eVIq7=|{PN{^MuVHZ!oJwd-pyx`op?fZ-3&}cc=SF+1+!aWd3SD-g zA#9S+Lc{1IQrdRHcXRu0E0gwRS)b-K!oEN_qp`C@0Ir7b$et755w{?`IB*o0pTjz? zE0oa=lVE421Un+Xv3L*?Yz4pV+5EQW@jHApl6RIaVr(~lyTA_xv?JpXYD}{O!>RTy zk$sJ4zY**o$!7mZ9{a0kjXG$#bOm)EG4|MvPxjcG&rSKeGd^XPfRC4AGk9*x;tBi~ zNXfzCBlyo*s?GSH_cm3|9fx)y)57-g(jTqNxqhly&DuXvo1$l4k0Y|@%oua+oW_~S z@6q{+JzGrOXjrwSh|n^JEgdnBD{vd~`$fY{gPk{=*P&a-f}p=b7N;ldU3kQ@(v$j; zH#me5Eb?BqNb8kf3Cv`gw+6@)Lvp*(Q5P{yU$(gLP%v#J>yi&}c(wMFDMs1}79-mj zi;;5xdBx}sgPzRBDwbl>g&*~b6gPPSKgwbnkGjqLL15L7Sv+f~-%^d5lqo_pxyx?Fjw|-}#8ee0m=s=953++8?@-_PpFO5%)GQ=aL%y=vgv~$7d54kIz>A zvl6J%AA!g|kIxnXmXx%>zK9kf;J+?5{H`Shm`&F!tj&D_5O^EHJ=uMyZ z;MN@Cm|@Aq_z_Dg>S))A7tWn&IA!JtKoqBn$+hJrP$}Z@V_3zV2s&Cm*@#%=a1S8j z{ju|3G@Lkm8c^iW0w_|sDoyE+8|S3|Y>2Vn%z%mzwzOy;V~H6lHPCeIq5vmXn|O&TSH}VN5n(F{Xnp|U#R2HW=fA;u{ z^kDIPYdsAq<{@~l99u`OoEsNkKmlkTZ(H=L+& zd`v3d%;=L73ExBT_vp~*xSdpBjq12pFp9{%f_&$}6XyUtW(*hXB_a)3?G!+IGa~P+ z6cypy7PXT}1XAW4kCgltA(T$eU5uDk1qmf%07d2%fT}~vR~k;59SSHi|8G33+3kGh zej7>cQ^0x7k0W+bptl212XT^P3u1bML2__cZIt8dfQa`g?=+m`_yi!y!Cp1K2O*j_ z;8r7oe=b36xq7ozkTdk zEQws*3f@HE6@6gVB=(i%x=4CzVO-a}r}h#}S}?9wIZ#x)~x}O23sw3G;`@?*}@PeP{Y;-8dv;SI(*!N5_~SvaY>&tb^8~p>J#eIX40i zhb)cG3G>I*fKx4kSLe)>uUBUTAmY6`#~M!R90rK$_>sf2@FOFYUjb4HXp&+!QjJ0& zyQo6muAl=rz^7Dw9N=pdWOd7rd$vN)UnBUu`+lmm&%18|BHriSTEi*tJ_RV|T{ECS z#g!SIsG;;|bRw@edvwyz0qFi3)=0M=4Qp6@FY&NO%zHGf5%c{vtdSgFhkjcSe5JV) zF*5ZQHVkVt54a5X!{8{s-i=0?)8y84K1XQ33~OXL$_#6y$l2gbykCnQiC9#`OuDxm zY*EuJ<=^A5hW>{}H2yf-Sxxii9$bt?p4e<{!TRXIQO*DSs3u)HI=C2{YpX#$g(r1z zF}CnKw+9zv)k+U8#&)F}UP>nm|2Hhga$HpW1&p{7LN_U41DEF^k0p2|a-p)llAe9a zSOjb^P_1DO-5PS?#d(N+f6ADvOmWfl;94xQw( z0l_Ba_m3Z3h&{M}JoNAf7h?ClTm0ZcZ2kbqAE6xAp$;y@rmvUxVz2UHFvfjdi0yuO zOph`;r{r^R9kyZKweH|LY@E7J52xM_8?EVN99)M*CSae8_N!>CN-n`taJr4+)reKj pUDU8}&isaY9Le0UsD8m1P1E*cdug|08rgt@%djwn|GzK8{$KKlkYNA- literal 83419 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 y3hh+;67ELaa%b)QIrC~~VT3;#@e-lyw diff --git a/src/librecord.fasl b/src/librecord.fasl index 5439b5df58cdaa84546764847d6f992ac90499e2..f307aefef452e56f013e4e8c3be11b34df39c10c 100644 GIT binary patch literal 30937 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 literal 30001 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 Core Scheme +;;; +;;; ::= (quote datum) +;;; | +;;; | (if ) +;;; | (set! ) +;;; | (begin ...) +;;; | (letrec ([ ] ...) ...) +;;; | (lambda ...) +;;; | ( ...) +;;; | (#primitive| ) +;;; | ( ...) +;;; ::= () +;;; | +;;; | ( . ) +;;; ::= void | memv | top-level-value | set-top-level-value! +;;; | primitive-set! | foreign-call | $apply + +(let ([*stx* (make-record-type "*stx*" '(e marks ribcage))] + [*rib* (make-record-type "*rib*" '(sym* marks* lab*))] + [*top* (make-record-type "*top*" '())]) + + (define stx? (record-predicate *stx*)) + (define make-stx (record-constructor *stx*)) + (define stx-e (record-field-accessor *stx* 'e)) + (define stx-marks (record-field-accessor *stx* 'marks)) + (define stx-ribcage (record-field-accessor *stx* 'ribcage)) + (define make-rib (record-constructor *rib*)) + (define rib-sym* (record-field-accessor *rib* 'sym*)) + (define rib-marks* (record-field-accessor *rib* 'marks*)) + (define rib-lab* (record-field-accessor *rib* 'lab*)) + (define *top-ribcage* ((record-constructor *top*))) + (define (top? x) (eq? x *top-ribcage*)) + (define *syncase-macro* (gensym "*syncase-macro*")) + + (define (build-data x) `(quote ,x)) + (define (build-global-ref x) `(top-level-value ',x)) + (define (build-lexical-ref x) x) + (define (build-app a d) `(,a . ,d)) + (define (build-lambda fml* body) + (cond + [(and (pair? body) (eq? (car body) 'begin)) + `(lambda ,fml* . ,(cdr body))] + [else + `(lambda ,fml* ,body)])) + (define (build-begin body*) `(begin . ,body*)) + + + (define (build-void) `(void)) + (define (build-if e0 e1 e2) `(if ,e0 ,e1 ,e2)) + (define (build-foreign-call e e*) `(foreign-call ,e ,e*)) + + + + (define (id? x) + (and (stx? x) + (symbol? (stx-e x)))) + + (define (stx->datum x) ;;;; use strip + (cond + [(stx? x) (stx-e x)] + [else x])) + + (define (stx-pair? x) + (and (stx? x) + (pair? (stx-e x)))) + + (define (strip x) + (cond + [(stx? x) (stx-e x)] + [else x])) + + (define label? string?) + + (define (eqmarks? m1* m2*) + (cond + [(null? m1*) (null? m2*)] + [(memq (car m1*) m2*) (eqmarks? (cdr m1*) (remq (car m1*) m2*))] + [else #f])) + + (define (rib-lookup sym m* sym* m** lab*) + (and (pair? sym*) + (if (and (eq? sym (car sym*)) + (eqmarks? m* (car m**))) + (car lab*) + (rib-lookup sym m* (cdr sym*) (cdr m**) (cdr lab*))))) + + (define (ribcage-lookup sym m* rc) + (cond + [(pair? rc) + (let ([r (car rc)]) + (cond + [(eq? r 'shift) + (ribcage-lookup sym (cdr m*) (cdr rc))] + [else + (or (rib-lookup sym m* (rib-sym* r) (rib-marks* r) (rib-lab* r)) + (ribcage-lookup sym m* (cdr rc)))]))] + [(top? rc) #f] + [else (error "BUG1")])) + + (define (resolve x) + (unless (id? x) (error "BUG2")) + (let ([sym (stx-e x)] + [m* (stx-marks x)] + [rc (stx-ribcage x)]) + (or (ribcage-lookup sym m* rc) ; bound -> label + (getprop sym *syncase-macro*) ; top-level-macros -> pair + sym ; global -> symbol + ))) + + (define (remove-last ls) + (let ([d (cdr ls)]) + (cond + [(null? d) '()] + [else (cons (car ls) (remove-last d))]))) + + (define (unshift rc) + (cond + [(pair? rc) + (if (eq? (car rc) 'shift) + (cdr rc) + (cons (car rc) (unshift (cdr rc))))] + [else (error "BUG3: missing shift")])) + + (define (push-wrap m r x) + (cond + [(stx? x) + (let ([xm (stx-marks x)]) + (cond + [(and (pair? xm) (eq? (car xm) #f)) + (make-stx (stx-e x) + (append (remove-last m) (cdr xm)) + (unshift (append r (stx-ribcage x))))] + [else + (make-stx (stx-e x) + (append m xm) + (append r (stx-ribcage x)))]))] + [else (make-stx x m r)])) + + (define (push-subst sym* marks* lab* x) + (cond + [(stx? x) + (make-stx (stx-e x) + (stx-marks x) + (cons (make-rib sym* marks* lab*) (stx-ribcage x)))] + [else + (make-stx x + '() + (cons (make-rib sym* marks* lab*) '()))])) + + (define (push-antimark x) + (cond + [(stx? x) + (make-stx (stx-e x) + (cons #f (stx-marks x)) + (stx-ribcage x))] + [else (make-stx x (cons #f '()) '())])) + + (define (push-mark m x) + (cond + [(stx? x) + (let ([m* (stx-marks x)]) + (cond + [(and (pair? m*) (eq? (car m*) #f)) + (make-stx (stx-e x) (cdr m*) (stx-ribcage x))] + [else + (make-stx (stx-e x) (cons m m*) (cons 'shift (stx-ribcage x)))]))] + [else + (make-stx x (list m) '(shift))])) + + (define (push-rib rib x) + (cond + [(stx? x) + (make-stx (stx-e x) (stx-marks x) (cons rib (stx-ribcage x)))] + [else (make-stx x '() (list rib))])) + + (define (expose-stx x) + (let ([e (stx-e x)]) + (cond + [(pair? e) + (let ([m (stx-marks x)] + [r (stx-ribcage x)]) + (cons + (push-wrap m r (car e)) + (push-wrap m r (cdr e))))] + [(vector? e) + (let ([m (stx-marks x)] + [r (stx-ribcage x)]) + (list->vector + (map (lambda (x) (push-wrap m r x)) + (vector->list e))))] + [(null? e) e] + [else x]))) + + (define (expose x) + (cond + [(stx? x) (expose-stx x)] + [else x])) + + (define (expose-ls ox) + (let loop ([x (expose ox)]) + (cond + [(pair? x) (cons (car x) (loop (expose (cdr x))))] + [(null? x) '()] + [else (error 'expose-ls "BUG: not a list: ~s" x)]))) + + (define (expose* x) + (cond + [(id? x) x] + [(stx? x) (expose* (expose x))] + [(pair? x) (cons (expose* (car x)) (expose* (cdr x)))] + [(vector? x) + (list->vector (map expose* (vector->list x)))] + [else x])) + + (define (lookup lab r) + (define (lookup1 lab lab* g*) + (cond + [(null? lab*) #f] + [(eq? lab (car lab*)) (car g*)] + [else (lookup1 lab (cdr lab*) (cdr g*))])) + (cond + [(null? r) #f] + [(eq? (car r) 'lexical-barrier) + (let ([v (lookup lab (cdr r))]) + (cond + [(not (symbol? v)) v] + [else #f]))] + [else + (or (lookup1 lab (caar r) (cdar r)) + (lookup lab (cdr r)))])) + + (define (genmark) (gensym "M")) + (define (newsym x) + (gensym)) + ;(gensym (symbol->string x))) + + (define (apply-macro proc x r) + (expand-ctx (push-mark (genmark) (proc (push-antimark x))) r)) + + (define (identifier-macro? x r) + (and (id? x) + (let ([a (resolve x)]) + (or (and (label? a) + (let ([a (lookup a r)]) + (and (procedure? a) a))) + (and (pair? a) + (eq? (car a) '*user-macro*) + (cdr a)))))) + + (define (macro-call? x r) + (if (id? x) + (identifier-macro? x r) + (let ([x (expose x)]) + (and (pair? x) + (identifier-macro? (car x) r))))) + + (define (core? x) + (and (pair? x) (eq? (car x) '*core-macro*))) + + (define (apply-core-form a d ctx r) + (unless (core? a) (syntax-error ctx)) + ((cdr a) a d ctx r)) + + (define (E* d r ctx) + (let ([d (expose-ls d)]) + (map (lambda (x) (E x r)) d))) + + (define (extend-core name proc) + (putprop name *syncase-macro* (cons '*core-macro* proc))) + + (define (extend-user-macro name proc) + (putprop name *syncase-macro* (cons '*user-macro* proc))) + + (define (E ctx r) + (let ([x (expose ctx)]) + (cond + [(macro-call? x r) => + (lambda (proc) + (apply-macro proc ctx r))] + [(pair? x) + (let ([a (car x)] [d (cdr x)]) + (cond + [(id? a) + (let ([a (resolve a)]) + (cond + [(label? a) + (cond + [(lookup a r) => + (lambda (g) + (cond + [(symbol? g) + (build-app (build-lexical-ref g) + (E* d r ctx))] + [(and (pair? g) (eq? (car g) 'pat)) + (syntax-error ctx)] + [else (error 'expand "BUG4")]))] + [else (syntax-error ctx)])] + [(core? a) + (apply-core-form a d ctx r)] + [(symbol? a) + (build-app (build-global-ref a) + (E* d r ctx))] + [else (syntax-error ctx)]))] + [else + (build-app + (E a r) + (E* d r ctx))]))] + [(id? x) + (let ([a (resolve x)]) + (cond + [(label? a) + (cond + [(lookup a r) => + (lambda (g) + (cond + [(symbol? g) (build-lexical-ref g)] + [(and (pair? g) (eq? (car g) 'pat)) + (syntax-error ctx)] + [else (error 'expand "BUG5")]))] + [else (syntax-error ctx)])] + [(core? a) (syntax-error ctx)] + [(symbol? a) + (build-global-ref a)] + [else (syntax-error ctx)]))] + [else (build-data (strip x))]))) + + (define (core-expand x) + (E (make-stx x '() *top-ribcage*) '())) + + (define (process-fml* bind* ctx) + (define (assert-no-dups s m* s* m**) + (unless (null? s*) + (when (and (eq? s (car s*)) + (eqmarks? m* (car m**))) + (syntax-error ctx)) + (assert-no-dups s m* (cdr s*) (cdr m*)))) + (let loop ([bind* (expose bind*)]) + (cond + [(null? bind*) (values '() '() '() '() '())] + [(pair? bind*) + (let ([b (car bind*)]) + (unless (id? b) (syntax-error ctx)) + (let-values ([(fml* s* m** g* lab*) + (loop (expose (cdr bind*)))]) + (let ([s (stx-e b)] [m* (stx-marks b)]) + (assert-no-dups s m* s* m**) + (let ([lab (string #\i)] [g (newsym s)]) + (values (cons g fml*) + (cons s s*) + (cons m* m**) + (cons g g*) + (cons lab lab*))))))] + [else (syntax-error ctx)]))) + + (define (top-level-macro? x r sym) + (let ([x (expose x)]) + (and (pair? x) + (id? (car x)) + (let ([loc (resolve (car x))]) + (and (or (and (pair? loc) + (eq? (car loc) '*core-macro*)) + (symbol? loc)) + (eq? (stx->datum (car x)) sym)))))) + + (define (define? x r) + (top-level-macro? x r 'define)) + + (define (begin? x r) + (top-level-macro? x r 'begin)) + + (define (begin-e* x ctx) + (let ([x (expose x)]) + (let loop ([x (expose (cdr x))]) + (cond + [(null? x) '()] + [(pair? x) (cons (car x) (loop (expose (cdr x))))] + [else (syntax-error ctx)])))) + + (define (expand-body* body* ctx r) + (let ([rib (make-rib '() '() '())]) + (let loop ([body* (expose (push-rib rib body*))] + [r r] + [lab* '()] [sym* '()] [marks* '()] [vrhs* '()]) + (cond + [(null? body*) (syntax-error ctx)] + [(pair? body*) + (let ([a (car body*)] [d (cdr body*)]) + (cond + [(macro-call? a r) => + (lambda (proc) + (loop (cons (push-mark (genmark) (proc (push-antimark a))) d) + r lab* sym* marks* vrhs*))] + [(define? a r) + (let-values ([(lhs rhs) (extract-define a ctx)]) + (loop (expose d) + r + (cons (string #\p) lab*) + (cons (stx-e lhs) sym*) + (cons (stx-marks lhs) marks*) + (cons rhs vrhs*)))] + [(begin? a r) + (loop (expose (append (begin-e* a ctx) d)) + r lab* sym* marks* vrhs*)] + [else + ;;; done + (cond + [(null? sym*) + (let ([body* (E* body* r ctx)]) + (build-begin body*))] + [else + (let ([g* (map newsym sym*)]) + (let* ([r (cons (cons lab* g*) r)] + [rhs* + (E* (push-subst sym* marks* lab* vrhs*) + r ctx)] + [body* + (E* (push-subst sym* marks* lab* body*) + r ctx)]) + (build-letrec g* rhs* (build-begin body*))))])]))] + [else (syntax-error ctx)])))) + + (define (extract-bindings bind* ctx) + (let ([bind* (expose bind*)]) + (cond + [(null? bind*) (values '() '())] + [(not (pair? bind*)) (syntax-error ctx)] + [else + (let ([a (car bind*)] [d (cdr bind*)]) + (let ([a (expose-ls a)]) + (cond + [(fx= (length a) 2) + (let-values ([(lhs* rhs*) + (extract-bindings d ctx)]) + (values (cons (car a) lhs*) + (cons (cadr a) rhs*)))] + [else (syntax-error ctx)])))]))) + + (define (core-stx x) + (make-stx x '() *top-ribcage*)) + + (extend-core 'quote + (lambda (a d ctx r) + (let ([d (expose-ls d)]) + (cond + [(and (list? d) (fx= (length d) 1)) + (build-data (strip (car d)))] + [else (syntax-error ctx)])))) + + (extend-core 'lambda + (lambda (a d ctx r) + (let ([d (expose d)]) + (cond + [(pair? d) + (let ([fml* (car d)] [body* (cdr d)]) + (let-values ([(fml* s* m** g* lab*) + (process-fml* fml* ctx)]) + (let ([body* (push-subst s* m** lab* body*)]) + (let ([r (cons (cons lab* g*) r)]) + (build-lambda fml* + (expand-body* body* ctx r))))))] + [else (syntax-error ctx)])))) + + (extend-core 'if + (lambda (a d ctx r) + (let ([d (expose d)]) + (unless (pair? d) (syntax-error ctx)) + (let ([test (car d)] [d (expose (cdr d))]) + (unless (pair? d) (syntax-error ctx)) + (let ([conseq (car d)] [d (expose (cdr d))]) + (let ([altern + (cond + [(null? d) (build-void)] + [(pair? d) + (let ([altern (car d)] [d (expose (cdr d))]) + (cond + [(null? d) (E altern r)] + [else (syntax-error ctx)]))] + [else (syntax-error ctx)])]) + (build-if (E test r) (E conseq r) altern))))))) + + (extend-core 'begin + (lambda (a d ctx r) + (let ([d (expose-ls d)]) + (when (null? d) (syntax-error ctx)) + (build-begin (E* d r ctx))))) + + + (extend-core 'define + (lambda (a d ctx r) (syntax-error ctx))) + + (extend-core 'foreign-call + (lambda (a d ctx r) + (let ([d (expose-ls d)]) + (unless (fx>= (length d) 1) (syntax-error ctx)) + (build-foreign-call + (E (car d) r) + (E* (cdr d) r ctx))))) + + (extend-core 'let + (lambda (a d ctx r) + (let ([d (expose d)]) + (unless (pair? d) (syntax-error ctx)) + (let ([bind* (car d)] [body* (cdr d)]) + (let-values ([(lhs* rhs*) + (extract-bindings bind* ctx)]) + (let ([lambda^ (core-stx 'lambda)]) + (E `((,lambda^ ,lhs* . ,body*) . ,rhs*) r))))))) + + (extend-core 'let* + (lambda (a d ctx r) + (let ([d (expose d)]) + (unless (pair? d) (syntax-error ctx)) + (let ([bind* (car d)] [body* (cdr d)]) + (let-values ([(lhs* rhs*) + (extract-bindings bind* ctx)]) + (let ([lambda^ (core-stx 'lambda)]) + (E (let f ([lhs* lhs*] [rhs* rhs*]) + (cond + [(null? lhs*) + `((,lambda^ () . ,body*))] + [else + `((,lambda^ (,(car lhs*)) + ,(f (cdr lhs*) (cdr rhs*))) + ,(car rhs*))])) + r))))))) + + (set! expand core-expand) +) diff --git a/src/libtokenizer.fasl b/src/libtokenizer.fasl index 352e050cfb20288a624feace8ae32ab21b4cee21..3ef1482a926b5f87916cce64fd9dbca5cb3488f5 100644 GIT binary patch literal 76558 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%0DQxbjas~t-bl0 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 diff --git a/src/libtoplevel.fasl b/src/libtoplevel.fasl index 6d6ebdd74794e8c8b1353131d8cb1ca96e361786..d25a6083915ff88b3ee647f464e12812887e754f 100644 GIT binary patch delta 463 zcmZ3=v6N$iY&`=Ibk?Z+>1GA9jyFGGZ~no|-wNV2ANjKbM85yjs1XdtAq$pUj;K*GsDDxVmcsJCyL*?L1wuC{q3Ui z0Z9MY@dN0l|LK1j7$!R~D)NCefSm~u%4bXjdLPVYn0$k=3><7gt$(^5_&~aW%pb@h z2a*DczX6E@=@+;H11SFnC=YVQ3y?W5SL^^;aF~I?%L7Pr1F;P#h+M3I1juQ=lg~1F RGBQjSXHEopa&k5EDgcq_mYe_p delta 463 zcmYk2ze~eF6vr=##h}n?DYk+Ig$xcZZsjgQhX^W&qjQDgW;YQmbT}MBgjRz17j)3Q zkj;XXI_N464vtL;p@j?qQ{(q6wLN(E9`DD8?|V(PsW$R8-KRsdszp|UX@r#~aI6(;%!iH}ECRU_Ps+HWLKcw>-)U_}gS;eH7Mi@>mH!S#6l#usC9=gW^lV4(&I2U&`27rKFSzvoDp0U-PBD&j0`b diff --git a/src/libwriter-6.2.ss b/src/libwriter-6.2.ss new file mode 100644 index 0000000..2f114f8 --- /dev/null +++ b/src/libwriter-6.2.ss @@ -0,0 +1,373 @@ + +;;; 6.2: * added a printer for bwp-objects + +;;; WRITER provides display and write. + +(let () + (define char-table ; first nonprintable chars + '#("nul" "soh" "stx" "etx" "eot" "enq" "ack" "bel" "bs" "tab" "newline" + "vt" "ff" "return" "so" "si" "dle" "dc1" "dc2" "dc3" "dc4" "nak" + "syn" "etb" "can" "em" "sub" "esc" "fs" "gs" "rs" "us" "space")) + (define write-character + (lambda (x p m) + (if m + (let ([i ($char->fixnum x)]) + (write-char #\# p) + (cond + [(fx< i (vector-length char-table)) + (write-char #\\ p) + (write-char* (vector-ref char-table i) p)] + [(fx< i 127) + (write-char #\\ p) + (write-char x p)] + [(fx= i 127) + (write-char #\\ p) + (write-char* "del" p)] + [else + (write-char #\+ p) + (write-fixnum i p)])) + (write-char x p)))) + (define write-list + (lambda (x p m) + (cond + [(pair? x) + (write-char #\space p) + (writer (car x) p m) + (write-list (cdr x) p m)] + [(not (null? x)) + (write-char #\space p) + (write-char #\. p) + (write-char #\space p) + (writer x p m)]))) + (define write-vector + (lambda (x p m) + (write-char #\# p) + (write-char #\( p) + (let ([n (vector-length x)]) + (when (fx> n 0) + (writer (vector-ref x 0) p m) + (letrec ([f + (lambda (i) + (unless (fx= i n) + (write-char #\space p) + (writer (vector-ref x i) p m) + (f (fxadd1 i))))]) + (f 1)))) + (write-char #\) p))) + (define write-record + (lambda (x p m) + (write-char #\# p) + (write-char #\[ p) + (writer (record-name x) p m) + (let ([n (record-length x)]) + (letrec ([f + (lambda (i) + (unless (fx= i n) + (write-char #\space p) + (writer (record-ref x i) p m) + (f (fxadd1 i))))]) + (f 0))) + (write-char #\] p))) + (define initial? + (lambda (c) + (or (letter? c) (special-initial? c)))) + (define letter? + (lambda (c) + (or (and ($char<= #\a c) ($char<= c #\z)) + (and ($char<= #\A c) ($char<= c #\Z))))) + (define digit? + (lambda (c) + (and ($char<= #\0 c) ($char<= c #\9)))) + (define special-initial? + (lambda (x) + (memq x '(#\! #\$ #\% #\& #\* #\/ #\: #\< #\= #\> #\? #\^ #\_ #\~)))) + (define subsequent? + (lambda (x) + (or (initial? x) + (digit? x) + (special-subsequent? x)))) + (define special-subsequent? + (lambda (x) + (memq x '(#\+ #\- #\. #\@)))) + (define subsequent*? + (lambda (str i n) + (or ($fx= i n) + (and (subsequent? ($string-ref str i)) + (subsequent*? str ($fxadd1 i) n))))) + (define valid-symbol-string? + (lambda (str) + (or (let ([n ($string-length str)]) + (and ($fx>= n 1) + (initial? ($string-ref str 0)) + (subsequent*? str 1 n))) + (string=? str "+") + (string=? str "-") + (string=? str "...")))) + (define write-symbol-esc-loop + (lambda (x i n p) + (unless ($fx= i n) + (let ([c ($string-ref x i)]) + (when (memq c '(#\\ #\|)) + (write-char #\\ p)) + (write-char c p)) + (write-symbol-esc-loop x ($fxadd1 i) n p)))) + (define write-symbol-esc + (lambda (x p) + (write-char #\| p) + (write-symbol-esc-loop x 0 ($string-length x) p) + (write-char #\| p))) + (define write-symbol + (lambda (x p m) + (let ([str (symbol->string x)]) + (if m + (if (valid-symbol-string? str) + (write-char* str p) + (write-symbol-esc str p)) + (write-char* str p))))) + (define write-gensym + (lambda (x p m) + (cond + [(and m (print-gensym)) + (let ([str (symbol->string x)]) + (write-char #\# p) + (write-char #\{ p) + (if (valid-symbol-string? str) + (write-char* str p) + (write-symbol-esc str p)) + (write-char #\space p) + (write-symbol-esc (gensym->unique-string x) p) + (write-char #\} p))] + [else (write-symbol x p m)]))) + (define write-string-escape + (lambda (x p) + (define loop + (lambda (x i n p) + (unless (fx= i n) + (let ([c (string-ref x i)]) + (cond + [(or ($char= #\" c) ($char= #\\ c)) + (write-char #\\ p) + (write-char c p)] + [($char= #\tab c) + (write-char #\\ p) + (write-char #\t p)] + [else + (write-char c p)])) + (loop x (fxadd1 i) n p)))) + (write-char #\" p) + (loop x 0 (string-length x) p) + (write-char #\" p))) + (define write-string + (lambda (x p m) + (if m + (write-string-escape x p) + (write-char* x p)))) + (define write-fixnum + (lambda (x p) + (define loop + (lambda (x p) + (unless (fxzero? x) + (loop (fxquotient x 10) p) + (write-char + ($fixnum->char + ($fx+ (fxremainder x 10) + ($char->fixnum #\0))) + p)))) + (cond + [(fxzero? x) (write-char #\0 p)] + [(fx< x 0) + (write-char #\- p) + (if (fx= x -536870912) + (write-char* "536870912" p) + (loop (fx- 0 x) p))] + [else (loop x p)]))) + (define write-char* + (lambda (x p) + (define loop + (lambda (x i n p) + (unless (fx= i n) + (write-char (string-ref x i) p) + (loop x (fxadd1 i) n p)))) + (loop x 0 (string-length x) p))) + (define macro + (lambda (x) + (define macro-forms + '([quote . "'"] + [quasiquote . "`"] + [unquote . ","] + [unquote-splicing . ",@"] + [syntax . "#'"] + [|#primitive| . "#%"])) + (and (pair? x) + (let ([d ($cdr x)]) + (and (pair? d) + (null? ($cdr d)))) + (assq ($car x) macro-forms)))) + (define writer + (lambda (x p m) + (cond + [(macro x) => + (lambda (y) + (write-char* (cdr y) p) + (writer (cadr x) p m))] + [(pair? x) + (write-char #\( p) + (writer (car x) p m) + (write-list (cdr x) p m) + (write-char #\) p)] + [(symbol? x) + (if (gensym? x) + (write-gensym x p m) + (write-symbol x p m))] + [(fixnum? x) + (write-fixnum x p)] + [(string? x) + (write-string x p m)] + [(boolean? x) + (write-char* (if x "#t" "#f") p)] + [(char? x) + (write-character x p m)] + [(procedure? x) + (write-char* "#" p)] + [(output-port? x) + (write-char* "# p)] + [(input-port? x) + (write-char* "# p)] + [(vector? x) + (write-vector x p m)] + [(null? x) + (write-char #\( p) + (write-char #\) p)] + [(eq? x (void)) + (write-char* "#" p)] + [(eof-object? x) + (write-char* "#!eof" p)] + [(bwp-object? x) + (write-char* "#!bwp" p)] + [(record? x) + (let ([printer (record-printer x)]) + (if (procedure? printer) + (printer x p) + (write-record x p m)))] + ;[(code? x) + ; (write-char* "#" p)] + [(hash-table? x) + (write-char* "#" p)] + [($unbound-object? x) + (write-char* "#" p)] + [($forward-ptr? x) + (write-char* "#" p)] + [else + (write-char* "#" p)]))) + + (define (write x p) + (writer x p #t) + (flush-output-port p)) + (define (display x p) + (writer x p #f) + (flush-output-port p)) + ;;; + (define formatter + (lambda (who p fmt args) + (let f ([i 0] [args args]) + (unless (fx= i (string-length fmt)) + (let ([c (string-ref fmt i)]) + (cond + [($char= c #\~) + (let ([i (fxadd1 i)]) + (when (fx= i (string-length fmt)) + (error who "invalid ~~ at end of format string ~s" fmt)) + (let ([c (string-ref fmt i)]) + (cond + [($char= c #\~) + (write-char #\~ p) + (f (fxadd1 i) args)] + [($char= c #\a) + (when (null? args) + (error who "insufficient arguments")) + (display (car args) p) + (f (fxadd1 i) (cdr args))] + [($char= c #\s) + (when (null? args) + (error who "insufficient arguments")) + (write (car args) p) + (f (fxadd1 i) (cdr args))] + [else + (error who "invalid sequence ~~~a" c)])))] + [else + (write-char c p) + (f (fxadd1 i) args)])))))) + + (define fprintf + (lambda (port fmt . args) + (unless (output-port? port) + (error 'fprintf "~s is not an output port" port)) + (unless (string? fmt) + (error 'fprintf "~s is not a string" fmt)) + (formatter 'fprintf port fmt args))) + + (define printf + (lambda (fmt . args) + (unless (string? fmt) + (error 'printf "~s is not a string" fmt)) + (formatter 'printf (current-output-port) fmt args))) + + (define format + (lambda (fmt . args) + (unless (string? fmt) + (error 'format "~s is not a string" fmt)) + (let ([p (open-output-string)]) + (formatter 'format p fmt args) + (get-output-string p)))) + + (define print-error + (lambda (who fmt . args) + (unless (string? fmt) + (error 'print-error "~s is not a string" fmt)) + (let ([p (standard-error-port)]) + (if who + (fprintf p "Error in ~a: " who) + (fprintf p "Error: ")) + (formatter 'print-error p fmt args) + (write-char #\. p) + (newline p)))) + + + ;;; + (primitive-set! 'format format) + (primitive-set! 'printf printf) + (primitive-set! 'fprintf fprintf) + (primitive-set! 'write + (case-lambda + [(x) (write x (current-output-port))] + [(x p) + (unless (output-port? p) + (error 'write "~s is not an output port" p)) + (write x p)])) + (primitive-set! 'display + (case-lambda + [(x) (display x (current-output-port))] + [(x p) + (unless (output-port? p) + (error 'display "~s is not an output port" p)) + (display x p)])) + (primitive-set! 'print-error print-error) + (primitive-set! 'current-error-handler + (make-parameter + (lambda args + (apply print-error args) + (display "exiting\n" (console-output-port)) + (flush-output-port (console-output-port)) + (exit -100)) + (lambda (x) + (if (procedure? x) + x + (error 'current-error-handler "~s is not a procedure" x))))) + (primitive-set! 'error + (lambda args + (apply (current-error-handler) args)))) + diff --git a/src/libwriter.fasl b/src/libwriter.fasl index 7d727f76925da903be856b21dda0c565c67957c7..05fb9ce74575633b251f7df6672afcab2c719bb6 100644 GIT binary patch literal 61884 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 Y1R~wa@~ literal 60795 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 E9!WoU2mXXL;F%;dm4H34iJ}NZET}Z?6 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 Q33o`*gdJ6H%{Ns3KftN8I{*Lx diff --git a/src/makepp.ss b/src/makepp.ss new file mode 100644 index 0000000..69ac05b --- /dev/null +++ b/src/makepp.ss @@ -0,0 +1,34 @@ +(define primitive-set! set-top-level-value!) +(define chez-expand sc-expand) +(define-syntax |#primitive| + (lambda (x) + (syntax-case x () + [(_ n) #'n]))) + +(printf "loading psyntax.pp ...\n") +(load "psyntax-7.1.pp") + +(current-expand + (lambda (x . args) + (apply chez-expand (sc-expand x) args))) + +(printf "loading psyntax.ss ...\n") +(load "psyntax-7.1.ss") +(current-expand + (lambda (x . args) + (apply chez-expand (sc-expand x) args))) + +(printf "making xpsyntax.pp ...\n") + +(with-output-to-file "xpsyntax.pp" + (lambda () + (load "psyntax-7.1.ss" + (lambda (x) + (parameterize ([print-gensym #f] + [print-graph #f] + [expand-mode 'bootstrap] + [print-vector-length #f]) + (pretty-print (sc-expand x)) + (newline))))) + 'replace) + diff --git a/src/petite-ikarus.fasl b/src/petite-ikarus.fasl index c5eb91c858c7e0b314992d1fdec824da0a40549e..35ae3aced5eaca083e373d7a3dd75e7efe688ad1 100644 GIT binary patch delta 302 zcmaFB`hazUY&`=Ibk?Z+>1GA9jyFGGZ~no|-wNV2ANjKbM85yw=|Du23J86F<})Oo!50ekZgX8u+N1_rg}BY$=PX@-{!3=zys z96;6?5LY%gk%8fV_}}gt6^7-sSMVWS2CVv NG1oP+m|Ve>0RSlod$Rxl diff --git a/src/psyntax-7.1.pp b/src/psyntax-7.1.pp new file mode 100644 index 0000000..8020c5b --- /dev/null +++ b/src/psyntax-7.1.pp @@ -0,0 +1,10704 @@ +;;; psyntax.pp +;;; automatically generated from psyntax.ss +;;; Tue Aug 1 21:30:16 EDT 2006 +;;; see copyright notice in psyntax.ss + +(let () +(define + fx+) +(define - fx-) +(define * fx*) +(define quotient fxquotient) +(define modulo fxmodulo) +(define number? fixnum?) +(define = fx=) +(define > fx>) +(define >= fx>=) +(define < fx<) +(define <= fx<=) + +((lambda () + (letrec ((noexpand62 '"noexpand") + (make-syntax-object63 (lambda (expression2523 wrap2522) + (vector + 'syntax-object + expression2523 + wrap2522))) + (syntax-object?64 (lambda (x2521) + (if (vector? x2521) + (if (= (vector-length x2521) '3) + (eq? (vector-ref x2521 '0) + 'syntax-object) + '#f) + '#f))) + (syntax-object-expression65 (lambda (x2520) + (vector-ref x2520 '1))) + (syntax-object-wrap66 (lambda (x2519) + (vector-ref x2519 '2))) + (set-syntax-object-expression!67 (lambda (x2518 update2517) + (vector-set! + x2518 + '1 + update2517))) + (set-syntax-object-wrap!68 (lambda (x2516 update2515) + (vector-set! + x2516 + '2 + update2515))) + (annotation?132 (lambda (x2514) '#f)) + (top-level-eval-hook133 (lambda (x2513) + (eval (list noexpand62 x2513)))) + (local-eval-hook134 (lambda (x2512) + (eval (list noexpand62 x2512)))) + (define-top-level-value-hook135 (lambda (sym2511 val2510) + (top-level-eval-hook133 + (list + 'define + sym2511 + (list 'quote val2510))))) + (error-hook136 (lambda (who2509 why2508 what2507) + (error who2509 '"~a ~s" why2508 what2507))) + (put-cte-hook141 (lambda (symbol2506 val2505) + ($sc-put-cte symbol2506 val2505 '*top*))) + (get-global-definition-hook142 (lambda (symbol2504) + (getprop + symbol2504 + '*sc-expander*))) + (put-global-definition-hook143 (lambda (symbol2503 x2502) + (if (not x2502) + (remprop + symbol2503 + '*sc-expander*) + (putprop + symbol2503 + '*sc-expander* + x2502)))) + (read-only-binding?144 (lambda (symbol2501) '#f)) + (get-import-binding145 (lambda (symbol2500 token2499) + (getprop symbol2500 token2499))) + (put-import-binding146 (lambda (symbol2498 token2497 x2496) + (if (not x2496) + (remprop symbol2498 token2497) + (putprop + symbol2498 + token2497 + x2496)))) + (generate-id147 ((lambda (digits2482) + ((lambda (base2484 session-key2483) + (letrec ((make-digit2485 (lambda (x2495) + (string-ref + digits2482 + x2495))) + (fmt2486 (lambda (n2489) + ((letrec ((fmt2490 (lambda (n2492 + a2491) + (if (< n2492 + base2484) + (list->string + (cons + (make-digit2485 + n2492) + a2491)) + ((lambda (r2494 + rest2493) + (fmt2490 + rest2493 + (cons + (make-digit2485 + r2494) + a2491))) + (modulo + n2492 + base2484) + (quotient + n2492 + base2484)))))) + fmt2490) + n2489 + '())))) + ((lambda (n2487) + (lambda (name2488) + (begin + (set! n2487 (+ n2487 '1)) + (string->symbol + (string-append + session-key2483 + (fmt2486 n2487)))))) + '-1))) + (string-length digits2482) + '"_")) + '"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/:<=>?~_^.+-")) + (built-lambda?221 (lambda (x2481) + (if (pair? x2481) + (eq? (car x2481) 'lambda) + '#f))) + (build-sequence239 (lambda (ae2478 exps2477) + ((letrec ((loop2479 (lambda (exps2480) + (if (null? + (cdr exps2480)) + (car exps2480) + (if (equal? + (car exps2480) + '(void)) + (loop2479 + (cdr exps2480)) + (cons + 'begin + exps2480)))))) + loop2479) + exps2477))) + (build-letrec240 (lambda (ae2476 vars2475 val-exps2474 + body-exp2473) + (if (null? vars2475) + body-exp2473 + (list + 'letrec + (map list vars2475 val-exps2474) + body-exp2473)))) + (build-body241 (lambda (ae2472 vars2471 val-exps2470 + body-exp2469) + (build-letrec240 + ae2472 + vars2471 + val-exps2470 + body-exp2469))) + (build-top-module242 (lambda (ae2457 types2456 vars2455 + val-exps2454 body-exp2453) + (call-with-values + (lambda () + ((letrec ((f2461 (lambda (types2463 + vars2462) + (if (null? + types2463) + (values + '() + '() + '()) + ((lambda (var2464) + (call-with-values + (lambda () + (f2461 + (cdr types2463) + (cdr vars2462))) + (lambda (vars2467 + defns2466 + sets2465) + (if (eq? (car types2463) + 'global) + ((lambda (x2468) + (values + (cons + x2468 + vars2467) + (cons + (list + 'define + var2464 + (chi-void513)) + defns2466) + (cons + (list + 'set! + var2464 + x2468) + sets2465))) + (gensym)) + (values + (cons + var2464 + vars2467) + defns2466 + sets2465))))) + (car vars2462)))))) + f2461) + types2456 + vars2455)) + (lambda (vars2460 defns2459 sets2458) + (if (null? defns2459) + (build-letrec240 + ae2457 + vars2460 + val-exps2454 + body-exp2453) + (build-sequence239 + '#f + (append + defns2459 + (list + (build-letrec240 + ae2457 + vars2460 + val-exps2454 + (build-sequence239 + '#f + (append + sets2458 + (list + body-exp2453)))))))))))) + (sanitize-binding275 (lambda (b2449) + (if (procedure? b2449) + (cons 'macro b2449) + (if (binding?289 b2449) + (if ((lambda (t2450) + (if (memv + t2450 + '(core + macro + macro! + deferred)) + (procedure? + (binding-value286 + b2449)) + (if (memv + t2450 + '($module)) + (interface?447 + (binding-value286 + b2449)) + (if (memv + t2450 + '(lexical)) + '#f + (if (memv + t2450 + '(global + meta-variable)) + (symbol? + (binding-value286 + b2449)) + (if (memv + t2450 + '(syntax)) + ((lambda (x2451) + (if (pair? + x2451) + (if '#f + ((lambda (n2452) + (if (integer? + n2452) + (if (exact? + n2452) + (>= n2452 + '0) + '#f) + '#f)) + (cdr x2451)) + '#f) + '#f)) + (binding-value286 + b2449)) + (if (memv + t2450 + '(begin + define + define-syntax + set! + $module-key + $import + eval-when + meta)) + (null? + (binding-value286 + b2449)) + (if (memv + t2450 + '(local-syntax)) + (boolean? + (binding-value286 + b2449)) + (if (memv + t2450 + '(displaced-lexical)) + (eq? (binding-value286 + b2449) + '#f) + '#t))))))))) + (binding-type285 b2449)) + b2449 + '#f) + '#f)))) + (binding-type285 car) + (binding-value286 cdr) + (set-binding-type!287 set-car!) + (set-binding-value!288 set-cdr!) + (binding?289 (lambda (x2448) + (if (pair? x2448) (symbol? (car x2448)) '#f))) + (extend-env299 (lambda (label2447 binding2446 r2445) + (cons (cons label2447 binding2446) r2445))) + (extend-env*300 (lambda (labels2444 bindings2443 r2442) + (if (null? labels2444) + r2442 + (extend-env*300 + (cdr labels2444) + (cdr bindings2443) + (extend-env299 + (car labels2444) + (car bindings2443) + r2442))))) + (extend-var-env*301 (lambda (labels2441 vars2440 r2439) + (if (null? labels2441) + r2439 + (extend-var-env*301 + (cdr labels2441) + (cdr vars2440) + (extend-env299 + (car labels2441) + (cons 'lexical (car vars2440)) + r2439))))) + (displaced-lexical?302 (lambda (id2436 r2435) + ((lambda (n2437) + (if n2437 + ((lambda (b2438) + (eq? (binding-type285 b2438) + 'displaced-lexical)) + (lookup305 n2437 r2435)) + '#f)) + (id-var-name429 id2436 '(()))))) + (displaced-lexical-error303 (lambda (id2434) + (syntax-error + id2434 + (if (id-var-name429 + id2434 + '(())) + '"identifier out of context" + '"identifier not visible")))) + (lookup*304 (lambda (x2431 r2430) + ((lambda (t2432) + (if t2432 + (cdr t2432) + (if (symbol? x2431) + ((lambda (t2433) + (if t2433 + t2433 + (cons 'global x2431))) + (get-global-definition-hook142 + x2431)) + '(displaced-lexical . #f)))) + (assq x2431 r2430)))) + (lookup305 (lambda (x2425 r2424) + (letrec ((whack-binding!2426 (lambda (b2429 + *b2428) + (begin + (set-binding-type!287 + b2429 + (binding-type285 + *b2428)) + (set-binding-value!288 + b2429 + (binding-value286 + *b2428)))))) + ((lambda (b2427) + (begin + (if (eq? (binding-type285 b2427) 'deferred) + (whack-binding!2426 + b2427 + (make-transformer-binding306 + ((binding-value286 b2427)))) + (void)) + b2427)) + (lookup*304 x2425 r2424))))) + (make-transformer-binding306 (lambda (b2422) + ((lambda (t2423) + (if t2423 + t2423 + (syntax-error + b2422 + '"invalid transformer"))) + (sanitize-binding275 b2422)))) + (defer-or-eval-transformer307 (lambda (eval2421 x2420) + (if (built-lambda?221 x2420) + (cons + 'deferred + (lambda () + (eval2421 x2420))) + (make-transformer-binding306 + (eval2421 x2420))))) + (global-extend308 (lambda (type2419 sym2418 val2417) + (put-cte-hook141 + sym2418 + (cons type2419 val2417)))) + (nonsymbol-id?309 (lambda (x2415) + (if (syntax-object?64 x2415) + (symbol? + ((lambda (e2416) + (if (annotation?132 e2416) + (annotation-expression e2416) + e2416)) + (syntax-object-expression65 + x2415))) + '#f))) + (id?310 (lambda (x2413) + (if (symbol? x2413) + '#t + (if (syntax-object?64 x2413) + (symbol? + ((lambda (e2414) + (if (annotation?132 e2414) + (annotation-expression e2414) + e2414)) + (syntax-object-expression65 x2413))) + (if (annotation?132 x2413) + (symbol? (annotation-expression x2413)) + '#f))))) + (id-marks316 (lambda (id2412) + (if (syntax-object?64 id2412) + (wrap-marks320 + (syntax-object-wrap66 id2412)) + (wrap-marks320 '((top)))))) + (id-subst317 (lambda (id2411) + (if (syntax-object?64 id2411) + (wrap-subst321 + (syntax-object-wrap66 id2411)) + (wrap-marks320 '((top)))))) + (id-sym-name&marks318 (lambda (x2408 w2407) + (if (syntax-object?64 x2408) + (values + ((lambda (e2409) + (if (annotation?132 e2409) + (annotation-expression + e2409) + e2409)) + (syntax-object-expression65 + x2408)) + (join-marks418 + (wrap-marks320 w2407) + (wrap-marks320 + (syntax-object-wrap66 + x2408)))) + (values + ((lambda (e2410) + (if (annotation?132 e2410) + (annotation-expression + e2410) + e2410)) + x2408) + (wrap-marks320 w2407))))) + (make-wrap319 cons) + (wrap-marks320 car) + (wrap-subst321 cdr) + (make-indirect-label350 (lambda (label2406) + (vector 'indirect-label label2406))) + (indirect-label?351 (lambda (x2405) + (if (vector? x2405) + (if (= (vector-length x2405) '2) + (eq? (vector-ref x2405 '0) + 'indirect-label) + '#f) + '#f))) + (indirect-label-label352 (lambda (x2404) + (vector-ref x2404 '1))) + (set-indirect-label-label!353 (lambda (x2403 update2402) + (vector-set! + x2403 + '1 + update2402))) + (gen-indirect-label354 (lambda () + (make-indirect-label350 + (gen-label357)))) + (get-indirect-label355 (lambda (x2401) + (indirect-label-label352 x2401))) + (set-indirect-label!356 (lambda (x2400 v2399) + (set-indirect-label-label!353 + x2400 + v2399))) + (gen-label357 (lambda () (string '#\i))) + (label?358 (lambda (x2396) + ((lambda (t2397) + (if t2397 + t2397 + ((lambda (t2398) + (if t2398 + t2398 + (indirect-label?351 x2396))) + (symbol? x2396)))) + (string? x2396)))) + (gen-labels359 (lambda (ls2395) + (if (null? ls2395) + '() + (cons + (gen-label357) + (gen-labels359 (cdr ls2395)))))) + (make-ribcage360 (lambda (symnames2394 marks2393 labels2392) + (vector + 'ribcage + symnames2394 + marks2393 + labels2392))) + (ribcage?361 (lambda (x2391) + (if (vector? x2391) + (if (= (vector-length x2391) '4) + (eq? (vector-ref x2391 '0) 'ribcage) + '#f) + '#f))) + (ribcage-symnames362 (lambda (x2390) (vector-ref x2390 '1))) + (ribcage-marks363 (lambda (x2389) (vector-ref x2389 '2))) + (ribcage-labels364 (lambda (x2388) (vector-ref x2388 '3))) + (set-ribcage-symnames!365 (lambda (x2387 update2386) + (vector-set! x2387 '1 update2386))) + (set-ribcage-marks!366 (lambda (x2385 update2384) + (vector-set! x2385 '2 update2384))) + (set-ribcage-labels!367 (lambda (x2383 update2382) + (vector-set! x2383 '3 update2382))) + (make-top-ribcage368 (lambda (key2381 mutable?2380) + (vector + 'top-ribcage + key2381 + mutable?2380))) + (top-ribcage?369 (lambda (x2379) + (if (vector? x2379) + (if (= (vector-length x2379) '3) + (eq? (vector-ref x2379 '0) + 'top-ribcage) + '#f) + '#f))) + (top-ribcage-key370 (lambda (x2378) (vector-ref x2378 '1))) + (top-ribcage-mutable?371 (lambda (x2377) + (vector-ref x2377 '2))) + (set-top-ribcage-key!372 (lambda (x2376 update2375) + (vector-set! x2376 '1 update2375))) + (set-top-ribcage-mutable?!373 (lambda (x2374 update2373) + (vector-set! + x2374 + '2 + update2373))) + (make-import-interface374 (lambda (interface2372 + new-marks2371) + (vector + 'import-interface + interface2372 + new-marks2371))) + (import-interface?375 (lambda (x2370) + (if (vector? x2370) + (if (= (vector-length x2370) '3) + (eq? (vector-ref x2370 '0) + 'import-interface) + '#f) + '#f))) + (import-interface-interface376 (lambda (x2369) + (vector-ref x2369 '1))) + (import-interface-new-marks377 (lambda (x2368) + (vector-ref x2368 '2))) + (set-import-interface-interface!378 (lambda (x2367 + update2366) + (vector-set! + x2367 + '1 + update2366))) + (set-import-interface-new-marks!379 (lambda (x2365 + update2364) + (vector-set! + x2365 + '2 + update2364))) + (make-env380 (lambda (top-ribcage2363 wrap2362) + (vector 'env top-ribcage2363 wrap2362))) + (env?381 (lambda (x2361) + (if (vector? x2361) + (if (= (vector-length x2361) '3) + (eq? (vector-ref x2361 '0) 'env) + '#f) + '#f))) + (env-top-ribcage382 (lambda (x2360) (vector-ref x2360 '1))) + (env-wrap383 (lambda (x2359) (vector-ref x2359 '2))) + (set-env-top-ribcage!384 (lambda (x2358 update2357) + (vector-set! x2358 '1 update2357))) + (set-env-wrap!385 (lambda (x2356 update2355) + (vector-set! x2356 '2 update2355))) + (anti-mark395 (lambda (w2354) + (make-wrap319 + (cons '#f (wrap-marks320 w2354)) + (cons 'shift (wrap-subst321 w2354))))) + (barrier-marker400 '#f) + (extend-ribcage!405 (lambda (ribcage2352 id2351 label2350) + (begin + (set-ribcage-symnames!365 + ribcage2352 + (cons + ((lambda (e2353) + (if (annotation?132 e2353) + (annotation-expression + e2353) + e2353)) + (syntax-object-expression65 + id2351)) + (ribcage-symnames362 ribcage2352))) + (set-ribcage-marks!366 + ribcage2352 + (cons + (wrap-marks320 + (syntax-object-wrap66 id2351)) + (ribcage-marks363 ribcage2352))) + (set-ribcage-labels!367 + ribcage2352 + (cons + label2350 + (ribcage-labels364 + ribcage2352)))))) + (import-extend-ribcage!406 (lambda (ribcage2348 + new-marks2347 id2346 + label2345) + (begin + (set-ribcage-symnames!365 + ribcage2348 + (cons + ((lambda (e2349) + (if (annotation?132 + e2349) + (annotation-expression + e2349) + e2349)) + (syntax-object-expression65 + id2346)) + (ribcage-symnames362 + ribcage2348))) + (set-ribcage-marks!366 + ribcage2348 + (cons + (join-marks418 + new-marks2347 + (wrap-marks320 + (syntax-object-wrap66 + id2346))) + (ribcage-marks363 + ribcage2348))) + (set-ribcage-labels!367 + ribcage2348 + (cons + label2345 + (ribcage-labels364 + ribcage2348)))))) + (extend-ribcage-barrier!407 (lambda (ribcage2344 + killer-id2343) + (extend-ribcage-barrier-help!408 + ribcage2344 + (syntax-object-wrap66 + killer-id2343)))) + (extend-ribcage-barrier-help!408 (lambda (ribcage2342 + wrap2341) + (begin + (set-ribcage-symnames!365 + ribcage2342 + (cons + barrier-marker400 + (ribcage-symnames362 + ribcage2342))) + (set-ribcage-marks!366 + ribcage2342 + (cons + (wrap-marks320 + wrap2341) + (ribcage-marks363 + ribcage2342)))))) + (extend-ribcage-subst!409 (lambda (ribcage2340 + import-iface2339) + (set-ribcage-symnames!365 + ribcage2340 + (cons + import-iface2339 + (ribcage-symnames362 + ribcage2340))))) + (lookup-import-binding-name410 (lambda (sym2334 marks2333 + token2332 + new-marks2331) + ((lambda (new2335) + (if new2335 + ((letrec ((f2336 (lambda (new2337) + (if (pair? + new2337) + ((lambda (t2338) + (if t2338 + t2338 + (f2336 + (cdr new2337)))) + (f2336 + (car new2337))) + (if (symbol? + new2337) + (if (same-marks?420 + marks2333 + (join-marks418 + new-marks2331 + (wrap-marks320 + '((top))))) + new2337 + '#f) + (if (same-marks?420 + marks2333 + (join-marks418 + new-marks2331 + (wrap-marks320 + (syntax-object-wrap66 + new2337)))) + new2337 + '#f)))))) + f2336) + new2335) + '#f)) + (get-import-binding145 + sym2334 + token2332)))) + (store-import-binding411 (lambda (id2316 token2315 + new-marks2314) + (letrec ((cons-id2317 (lambda (id2330 + x2329) + (if (not x2329) + id2330 + (cons + id2330 + x2329)))) + (weed2318 (lambda (marks2328 + x2327) + (if (pair? + x2327) + (if (same-marks?420 + (id-marks316 + (car x2327)) + marks2328) + (weed2318 + marks2328 + (cdr x2327)) + (cons-id2317 + (car x2327) + (weed2318 + marks2328 + (cdr x2327)))) + (if x2327 + (if (not (same-marks?420 + (id-marks316 + x2327) + marks2328)) + x2327 + '#f) + '#f))))) + ((lambda (id2319) + ((lambda (sym2320) + (if (not (eq? id2319 + sym2320)) + ((lambda (marks2321) + ((lambda (x2322) + (put-import-binding146 + sym2320 + token2315 + (cons-id2317 + (if (same-marks?420 + marks2321 + (wrap-marks320 + '((top)))) + (resolved-id-var-name415 + id2319) + id2319) + x2322))) + (weed2318 + marks2321 + (get-import-binding145 + sym2320 + token2315)))) + (id-marks316 id2319)) + (void))) + ((lambda (x2323) + ((lambda (e2324) + (if (annotation?132 + e2324) + (annotation-expression + e2324) + e2324)) + (if (syntax-object?64 + x2323) + (syntax-object-expression65 + x2323) + x2323))) + id2319))) + (if (null? new-marks2314) + id2316 + (make-syntax-object63 + ((lambda (x2325) + ((lambda (e2326) + (if (annotation?132 + e2326) + (annotation-expression + e2326) + e2326)) + (if (syntax-object?64 + x2325) + (syntax-object-expression65 + x2325) + x2325))) + id2316) + (make-wrap319 + (join-marks418 + new-marks2314 + (id-marks316 id2316)) + (id-subst317 + id2316)))))))) + (make-binding-wrap412 (lambda (ids2304 labels2303 w2302) + (if (null? ids2304) + w2302 + (make-wrap319 + (wrap-marks320 w2302) + (cons + ((lambda (labelvec2305) + ((lambda (n2306) + ((lambda (symnamevec2308 + marksvec2307) + (begin + ((letrec ((f2309 (lambda (ids2311 + i2310) + (if (not (null? + ids2311)) + (call-with-values + (lambda () + (id-sym-name&marks318 + (car ids2311) + w2302)) + (lambda (symname2313 + marks2312) + (begin + (vector-set! + symnamevec2308 + i2310 + symname2313) + (vector-set! + marksvec2307 + i2310 + marks2312) + (f2309 + (cdr ids2311) + (+ i2310 + '1))))) + (void))))) + f2309) + ids2304 + '0) + (make-ribcage360 + symnamevec2308 + marksvec2307 + labelvec2305))) + (make-vector n2306) + (make-vector n2306))) + (vector-length + labelvec2305))) + (list->vector labels2303)) + (wrap-subst321 w2302)))))) + (make-resolved-id413 (lambda (fromsym2301 marks2300 + tosym2299) + (make-syntax-object63 + fromsym2301 + (make-wrap319 + marks2300 + (list + (make-ribcage360 + (vector fromsym2301) + (vector marks2300) + (vector tosym2299))))))) + (id->resolved-id414 (lambda (id2294) + (call-with-values + (lambda () + (id-var-name&marks427 id2294 '(()))) + (lambda (tosym2296 marks2295) + (begin + (if (not tosym2296) + (syntax-error + id2294 + '"identifier not visible for export") + (void)) + (make-resolved-id413 + ((lambda (x2297) + ((lambda (e2298) + (if (annotation?132 e2298) + (annotation-expression + e2298) + e2298)) + (if (syntax-object?64 x2297) + (syntax-object-expression65 + x2297) + x2297))) + id2294) + marks2295 + tosym2296)))))) + (resolved-id-var-name415 (lambda (id2293) + (vector-ref + (ribcage-labels364 + (car (wrap-subst321 + (syntax-object-wrap66 + id2293)))) + '0))) + (smart-append416 (lambda (m12292 m22291) + (if (null? m22291) + m12292 + (append m12292 m22291)))) + (join-wraps417 (lambda (w12288 w22287) + ((lambda (m12290 s12289) + (if (null? m12290) + (if (null? s12289) + w22287 + (make-wrap319 + (wrap-marks320 w22287) + (join-subst419 + s12289 + (wrap-subst321 w22287)))) + (make-wrap319 + (join-marks418 + m12290 + (wrap-marks320 w22287)) + (join-subst419 + s12289 + (wrap-subst321 w22287))))) + (wrap-marks320 w12288) + (wrap-subst321 w12288)))) + (join-marks418 (lambda (m12286 m22285) + (smart-append416 m12286 m22285))) + (join-subst419 (lambda (s12284 s22283) + (smart-append416 s12284 s22283))) + (same-marks?420 (lambda (x2281 y2280) + ((lambda (t2282) + (if t2282 + t2282 + (if (not (null? x2281)) + (if (not (null? y2280)) + (if (eq? (car x2281) + (car y2280)) + (same-marks?420 + (cdr x2281) + (cdr y2280)) + '#f) + '#f) + '#f))) + (eq? x2281 y2280)))) + (diff-marks421 (lambda (m12274 m22273) + ((lambda (n12276 n22275) + ((letrec ((f2277 (lambda (n12279 m12278) + (if (> n12279 n22275) + (cons + (car m12278) + (f2277 + (- n12279 '1) + (cdr m12278))) + (if (equal? + m12278 + m22273) + '() + (error 'sc-expand + '"internal error in diff-marks: ~s is not a tail of ~s" + m12278 + m22273)))))) + f2277) + n12276 + m12274)) + (length m12274) + (length m22273)))) + (leave-implicit?422 (lambda (token2272) + (eq? token2272 '*top*))) + (new-binding423 (lambda (sym2269 marks2268 token2267) + ((lambda (loc2270) + ((lambda (id2271) + (begin + (store-import-binding411 + id2271 + token2267 + '()) + (values loc2270 id2271))) + (make-resolved-id413 + sym2269 + marks2268 + loc2270))) + (if (if (leave-implicit?422 token2267) + (same-marks?420 + marks2268 + (wrap-marks320 '((top)))) + '#f) + sym2269 + (generate-id147 sym2269))))) + (top-id-bound-var-name424 (lambda (sym2263 marks2262 + top-ribcage2261) + ((lambda (token2264) + ((lambda (t2265) + (if t2265 + ((lambda (id2266) + (if (symbol? id2266) + (if (read-only-binding?144 + id2266) + (new-binding423 + sym2263 + marks2262 + token2264) + (values + id2266 + (make-resolved-id413 + sym2263 + marks2262 + id2266))) + (values + (resolved-id-var-name415 + id2266) + id2266))) + t2265) + (new-binding423 + sym2263 + marks2262 + token2264))) + (lookup-import-binding-name410 + sym2263 + marks2262 + token2264 + '()))) + (top-ribcage-key370 + top-ribcage2261)))) + (top-id-free-var-name425 (lambda (sym2255 marks2254 + top-ribcage2253) + ((lambda (token2256) + ((lambda (t2257) + (if t2257 + ((lambda (id2258) + (if (symbol? id2258) + id2258 + (resolved-id-var-name415 + id2258))) + t2257) + (if (if (top-ribcage-mutable?371 + top-ribcage2253) + (same-marks?420 + marks2254 + (wrap-marks320 + '((top)))) + '#f) + (call-with-values + (lambda () + (new-binding423 + sym2255 + (wrap-marks320 + '((top))) + token2256)) + (lambda (sym2260 + id2259) + sym2260)) + '#f))) + (lookup-import-binding-name410 + sym2255 + marks2254 + token2256 + '()))) + (top-ribcage-key370 + top-ribcage2253)))) + (id-var-name-loc&marks426 (lambda (id2204 w2203) + (letrec ((search2205 (lambda (sym2248 + subst2247 + marks2246) + (if (null? + subst2247) + (values + '#f + marks2246) + ((lambda (fst2249) + (if (eq? fst2249 + 'shift) + (search2205 + sym2248 + (cdr subst2247) + (cdr marks2246)) + (if (ribcage?361 + fst2249) + ((lambda (symnames2250) + (if (vector? + symnames2250) + (search-vector-rib2207 + sym2248 + subst2247 + marks2246 + symnames2250 + fst2249) + (search-list-rib2206 + sym2248 + subst2247 + marks2246 + symnames2250 + fst2249))) + (ribcage-symnames362 + fst2249)) + (if (top-ribcage?369 + fst2249) + ((lambda (t2251) + (if t2251 + ((lambda (var-name2252) + (values + var-name2252 + marks2246)) + t2251) + (search2205 + sym2248 + (cdr subst2247) + marks2246))) + (top-id-free-var-name425 + sym2248 + marks2246 + fst2249)) + (error 'sc-expand + '"internal error in id-var-name-loc&marks: improper subst ~s" + subst2247))))) + (car subst2247))))) + (search-list-rib2206 (lambda (sym2226 + subst2225 + marks2224 + symnames2223 + ribcage2222) + ((letrec ((f2227 (lambda (symnames2229 + i2228) + (if (null? + symnames2229) + (search2205 + sym2226 + (cdr subst2225) + marks2224) + ((lambda (x2230) + (if (if (eq? x2230 + sym2226) + (same-marks?420 + marks2224 + (list-ref + (ribcage-marks363 + ribcage2222) + i2228)) + '#f) + (values + (list-ref + (ribcage-labels364 + ribcage2222) + i2228) + marks2224) + (if (import-interface?375 + x2230) + ((lambda (iface2232 + new-marks2231) + ((lambda (t2233) + (if t2233 + ((lambda (token2234) + ((lambda (t2235) + (if t2235 + ((lambda (id2236) + (values + (if (symbol? + id2236) + id2236 + (resolved-id-var-name415 + id2236)) + marks2224)) + t2235) + (f2227 + (cdr symnames2229) + i2228))) + (lookup-import-binding-name410 + sym2226 + marks2224 + token2234 + new-marks2231))) + t2233) + ((lambda (ie2237) + ((lambda (n2238) + ((lambda () + ((letrec ((g2239 (lambda (j2240) + (if (= j2240 + n2238) + (f2227 + (cdr symnames2229) + i2228) + ((lambda (id2241) + ((lambda (id.sym2243 + id.marks2242) + (if (help-bound-id=?432 + id.sym2243 + id.marks2242 + sym2226 + marks2224) + (values + (lookup-import-label501 + id2241) + marks2224) + (g2239 + (+ j2240 + '1)))) + ((lambda (x2244) + ((lambda (e2245) + (if (annotation?132 + e2245) + (annotation-expression + e2245) + e2245)) + (if (syntax-object?64 + x2244) + (syntax-object-expression65 + x2244) + x2244))) + id2241) + (join-marks418 + new-marks2231 + (id-marks316 + id2241)))) + (vector-ref + ie2237 + j2240)))))) + g2239) + '0)))) + (vector-length + ie2237))) + (interface-exports449 + iface2232)))) + (interface-token450 + iface2232))) + (import-interface-interface376 + x2230) + (import-interface-new-marks377 + x2230)) + (if (if (eq? x2230 + barrier-marker400) + (same-marks?420 + marks2224 + (list-ref + (ribcage-marks363 + ribcage2222) + i2228)) + '#f) + (values + '#f + marks2224) + (f2227 + (cdr symnames2229) + (+ i2228 + '1)))))) + (car symnames2229)))))) + f2227) + symnames2223 + '0))) + (search-vector-rib2207 (lambda (sym2218 + subst2217 + marks2216 + symnames2215 + ribcage2214) + ((lambda (n2219) + ((letrec ((f2220 (lambda (i2221) + (if (= i2221 + n2219) + (search2205 + sym2218 + (cdr subst2217) + marks2216) + (if (if (eq? (vector-ref + symnames2215 + i2221) + sym2218) + (same-marks?420 + marks2216 + (vector-ref + (ribcage-marks363 + ribcage2214) + i2221)) + '#f) + (values + (vector-ref + (ribcage-labels364 + ribcage2214) + i2221) + marks2216) + (f2220 + (+ i2221 + '1))))))) + f2220) + '0)) + (vector-length + symnames2215))))) + (if (symbol? id2204) + (search2205 + id2204 + (wrap-subst321 w2203) + (wrap-marks320 w2203)) + (if (syntax-object?64 id2204) + ((lambda (sym2209 w12208) + (call-with-values + (lambda () + (search2205 + sym2209 + (wrap-subst321 + w2203) + (join-marks418 + (wrap-marks320 + w2203) + (wrap-marks320 + w12208)))) + (lambda (name2211 + marks2210) + (if name2211 + (values + name2211 + marks2210) + (search2205 + sym2209 + (wrap-subst321 + w12208) + marks2210))))) + ((lambda (e2212) + (if (annotation?132 + e2212) + (annotation-expression + e2212) + e2212)) + (syntax-object-expression65 + id2204)) + (syntax-object-wrap66 + id2204)) + (if (annotation?132 + id2204) + (search2205 + ((lambda (e2213) + (if (annotation?132 + e2213) + (annotation-expression + e2213) + e2213)) + id2204) + (wrap-subst321 + w2203) + (wrap-marks320 + w2203)) + (error-hook136 + 'id-var-name + '"invalid id" + id2204))))))) + (id-var-name&marks427 (lambda (id2200 w2199) + (call-with-values + (lambda () + (id-var-name-loc&marks426 + id2200 + w2199)) + (lambda (label2202 marks2201) + (values + (if (indirect-label?351 + label2202) + (get-indirect-label355 + label2202) + label2202) + marks2201))))) + (id-var-name-loc428 (lambda (id2196 w2195) + (call-with-values + (lambda () + (id-var-name-loc&marks426 + id2196 + w2195)) + (lambda (label2198 marks2197) + label2198)))) + (id-var-name429 (lambda (id2192 w2191) + (call-with-values + (lambda () + (id-var-name-loc&marks426 id2192 w2191)) + (lambda (label2194 marks2193) + (if (indirect-label?351 label2194) + (get-indirect-label355 label2194) + label2194))))) + (free-id=?430 (lambda (i2186 j2185) + (if (eq? ((lambda (x2189) + ((lambda (e2190) + (if (annotation?132 e2190) + (annotation-expression + e2190) + e2190)) + (if (syntax-object?64 x2189) + (syntax-object-expression65 + x2189) + x2189))) + i2186) + ((lambda (x2187) + ((lambda (e2188) + (if (annotation?132 e2188) + (annotation-expression + e2188) + e2188)) + (if (syntax-object?64 x2187) + (syntax-object-expression65 + x2187) + x2187))) + j2185)) + (eq? (id-var-name429 i2186 '(())) + (id-var-name429 j2185 '(()))) + '#f))) + (literal-id=?431 (lambda (id2175 literal2174) + (if (eq? ((lambda (x2178) + ((lambda (e2179) + (if (annotation?132 e2179) + (annotation-expression + e2179) + e2179)) + (if (syntax-object?64 x2178) + (syntax-object-expression65 + x2178) + x2178))) + id2175) + ((lambda (x2176) + ((lambda (e2177) + (if (annotation?132 e2177) + (annotation-expression + e2177) + e2177)) + (if (syntax-object?64 x2176) + (syntax-object-expression65 + x2176) + x2176))) + literal2174)) + ((lambda (n-id2181 n-literal2180) + ((lambda (t2182) + (if t2182 + t2182 + (if ((lambda (t2183) + (if t2183 + t2183 + (symbol? + n-id2181))) + (not n-id2181)) + ((lambda (t2184) + (if t2184 + t2184 + (symbol? + n-literal2180))) + (not n-literal2180)) + '#f))) + (eq? n-id2181 n-literal2180))) + (id-var-name429 id2175 '(())) + (id-var-name429 literal2174 '(()))) + '#f))) + (help-bound-id=?432 (lambda (i.sym2173 i.marks2172 j.sym2171 + j.marks2170) + (if (eq? i.sym2173 j.sym2171) + (same-marks?420 + i.marks2172 + j.marks2170) + '#f))) + (bound-id=?433 (lambda (i2165 j2164) + (help-bound-id=?432 + ((lambda (x2168) + ((lambda (e2169) + (if (annotation?132 e2169) + (annotation-expression e2169) + e2169)) + (if (syntax-object?64 x2168) + (syntax-object-expression65 x2168) + x2168))) + i2165) + (id-marks316 i2165) + ((lambda (x2166) + ((lambda (e2167) + (if (annotation?132 e2167) + (annotation-expression e2167) + e2167)) + (if (syntax-object?64 x2166) + (syntax-object-expression65 x2166) + x2166))) + j2164) + (id-marks316 j2164)))) + (valid-bound-ids?434 (lambda (ids2160) + (if ((letrec ((all-ids?2161 (lambda (ids2162) + ((lambda (t2163) + (if t2163 + t2163 + (if (id?310 + (car ids2162)) + (all-ids?2161 + (cdr ids2162)) + '#f))) + (null? + ids2162))))) + all-ids?2161) + ids2160) + (distinct-bound-ids?435 ids2160) + '#f))) + (distinct-bound-ids?435 (lambda (ids2156) + ((letrec ((distinct?2157 (lambda (ids2158) + ((lambda (t2159) + (if t2159 + t2159 + (if (not (bound-id-member?437 + (car ids2158) + (cdr ids2158))) + (distinct?2157 + (cdr ids2158)) + '#f))) + (null? + ids2158))))) + distinct?2157) + ids2156))) + (invalid-ids-error436 (lambda (ids2152 exp2151 class2150) + ((letrec ((find2153 (lambda (ids2155 + gooduns2154) + (if (null? + ids2155) + (syntax-error + exp2151) + (if (id?310 + (car ids2155)) + (if (bound-id-member?437 + (car ids2155) + gooduns2154) + (syntax-error + (car ids2155) + '"duplicate " + class2150) + (find2153 + (cdr ids2155) + (cons + (car ids2155) + gooduns2154))) + (syntax-error + (car ids2155) + '"invalid " + class2150)))))) + find2153) + ids2152 + '()))) + (bound-id-member?437 (lambda (x2148 list2147) + (if (not (null? list2147)) + ((lambda (t2149) + (if t2149 + t2149 + (bound-id-member?437 + x2148 + (cdr list2147)))) + (bound-id=?433 + x2148 + (car list2147))) + '#f))) + (wrap438 (lambda (x2146 w2145) + (if (if (null? (wrap-marks320 w2145)) + (null? (wrap-subst321 w2145)) + '#f) + x2146 + (if (syntax-object?64 x2146) + (make-syntax-object63 + (syntax-object-expression65 x2146) + (join-wraps417 + w2145 + (syntax-object-wrap66 x2146))) + (if (null? x2146) + x2146 + (make-syntax-object63 x2146 w2145)))))) + (source-wrap439 (lambda (x2144 w2143 ae2142) + (wrap438 + (if (annotation?132 ae2142) + (begin + (if (not (eq? (annotation-expression + ae2142) + x2144)) + (error 'sc-expand + '"internal error in source-wrap: ae/x mismatch") + (void)) + ae2142) + x2144) + w2143))) + (chi-when-list440 (lambda (when-list2140 w2139) + (map (lambda (x2141) + (if (literal-id=?431 + x2141 + '#(syntax-object compile ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(when-list w) #((top) (top)) #("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + 'compile + (if (literal-id=?431 + x2141 + '#(syntax-object load ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(when-list w) #((top) (top)) #("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + 'load + (if (literal-id=?431 + x2141 + '#(syntax-object visit ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(when-list w) #((top) (top)) #("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + 'visit + (if (literal-id=?431 + x2141 + '#(syntax-object revisit ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(when-list w) #((top) (top)) #("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + 'revisit + (if (literal-id=?431 + x2141 + '#(syntax-object eval ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(when-list w) #((top) (top)) #("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + 'eval + (syntax-error + (wrap438 + x2141 + w2139) + '"invalid eval-when situation"))))))) + when-list2140))) + (syntax-type441 (lambda (e2124 r2123 w2122 ae2121 rib2120) + (if (symbol? e2124) + ((lambda (n2125) + ((lambda (b2126) + ((lambda (type2127) + ((lambda () + ((lambda (t2128) + (if (memv + t2128 + '(macro macro!)) + (syntax-type441 + (chi-macro497 + (binding-value286 + b2126) + e2124 r2123 w2122 + ae2121 rib2120) + r2123 '(()) '#f + rib2120) + (values type2127 + (binding-value286 + b2126) + e2124 w2122 + ae2121))) + type2127)))) + (binding-type285 b2126))) + (lookup305 n2125 r2123))) + (id-var-name429 e2124 w2122)) + (if (pair? e2124) + ((lambda (first2129) + (if (id?310 first2129) + ((lambda (n2130) + ((lambda (b2131) + ((lambda (type2132) + ((lambda () + ((lambda (t2133) + (if (memv + t2133 + '(lexical)) + (values + 'lexical-call + (binding-value286 + b2131) + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(macro + macro!)) + (syntax-type441 + (chi-macro497 + (binding-value286 + b2131) + e2124 + r2123 + w2122 + ae2121 + rib2120) + r2123 + '(()) + '#f + rib2120) + (if (memv + t2133 + '(core)) + (values + type2132 + (binding-value286 + b2131) + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(begin)) + (values + 'begin-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(alias)) + (values + 'alias-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(define)) + (values + 'define-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(define-syntax)) + (values + 'define-syntax-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(set!)) + (chi-set!496 + e2124 + r2123 + w2122 + ae2121 + rib2120) + (if (memv + t2133 + '($module-key)) + (values + '$module-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '($import)) + (values + '$import-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(eval-when)) + (values + 'eval-when-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(meta)) + (values + 'meta-form + '#f + e2124 + w2122 + ae2121) + (if (memv + t2133 + '(local-syntax)) + (values + 'local-syntax-form + (binding-value286 + b2131) + e2124 + w2122 + ae2121) + (values + 'call + '#f + e2124 + w2122 + ae2121))))))))))))))) + type2132)))) + (binding-type285 + b2131))) + (lookup305 n2130 r2123))) + (id-var-name429 + first2129 + w2122)) + (values 'call '#f e2124 w2122 + ae2121))) + (car e2124)) + (if (syntax-object?64 e2124) + (syntax-type441 + (syntax-object-expression65 + e2124) + r2123 + (join-wraps417 + w2122 + (syntax-object-wrap66 e2124)) + '#f rib2120) + (if (annotation?132 e2124) + (syntax-type441 + (annotation-expression + e2124) + r2123 w2122 e2124 rib2120) + (if ((lambda (x2134) + ((lambda (t2135) + (if t2135 + t2135 + ((lambda (t2136) + (if t2136 + t2136 + ((lambda (t2137) + (if t2137 + t2137 + ((lambda (t2138) + (if t2138 + t2138 + (null? + x2134))) + (char? + x2134)))) + (string? + x2134)))) + (number? + x2134)))) + (boolean? x2134))) + e2124) + (values 'constant '#f + e2124 w2122 ae2121) + (values 'other '#f e2124 + w2122 ae2121)))))))) + (chi-top*442 (lambda (e2115 r2114 w2113 ctem2112 rtem2111 + meta?2110 top-ribcage2109) + ((lambda (meta-residuals2116) + (letrec ((meta-residualize!2117 (lambda (x2119) + (set! meta-residuals2116 + (cons + x2119 + meta-residuals2116))))) + ((lambda (e2118) + (build-sequence239 + '#f + (reverse + (cons e2118 meta-residuals2116)))) + (chi-top444 e2115 r2114 w2113 ctem2112 + rtem2111 meta?2110 top-ribcage2109 + meta-residualize!2117 '#f)))) + '()))) + (chi-top-sequence443 (lambda (body2105 r2104 w2103 ae2102 + ctem2101 rtem2100 meta?2099 + ribcage2098 + meta-residualize!2097) + (build-sequence239 + ae2102 + ((letrec ((dobody2106 (lambda (body2107) + (if (null? + body2107) + '() + ((lambda (first2108) + (cons + first2108 + (dobody2106 + (cdr body2107)))) + (chi-top444 + (car body2107) + r2104 + w2103 + ctem2101 + rtem2100 + meta?2099 + ribcage2098 + meta-residualize!2097 + '#f)))))) + dobody2106) + body2105)))) + (chi-top444 (lambda (e2042 r2041 w2040 ctem2039 rtem2038 + meta?2037 top-ribcage2036 + meta-residualize!2035 meta-seen?2034) + (call-with-values + (lambda () + (syntax-type441 e2042 r2041 w2040 '#f + top-ribcage2036)) + (lambda (type2047 value2046 e2045 w2044 ae2043) + ((lambda (t2048) + (if (memv t2048 '(begin-form)) + ((lambda (forms2049) + (if (null? forms2049) + (chi-void513) + (chi-top-sequence443 forms2049 + r2041 w2044 ae2043 ctem2039 + rtem2038 meta?2037 + top-ribcage2036 + meta-residualize!2035))) + (parse-begin510 + e2045 + w2044 + ae2043 + '#t)) + (if (memv t2048 '(local-syntax-form)) + (call-with-values + (lambda () + (chi-local-syntax512 value2046 + e2045 r2041 r2041 w2044 + ae2043)) + (lambda (forms2054 r2053 mr2052 + w2051 ae2050) + (chi-top-sequence443 forms2054 + r2053 w2051 ae2050 ctem2039 + rtem2038 meta?2037 + top-ribcage2036 + meta-residualize!2035))) + (if (memv t2048 '(eval-when-form)) + (call-with-values + (lambda () + (parse-eval-when508 + e2045 + w2044 + ae2043)) + (lambda (when-list2056 + forms2055) + ((lambda (ctem2058 + rtem2057) + (if (if (null? + ctem2058) + (null? + rtem2057) + '#f) + (chi-void513) + (chi-top-sequence443 + forms2055 r2041 + w2044 ae2043 + ctem2058 rtem2057 + meta?2037 + top-ribcage2036 + meta-residualize!2035))) + (update-mode-set485 + when-list2056 + ctem2039) + (update-mode-set485 + when-list2056 + rtem2038)))) + (if (memv t2048 '(meta-form)) + (chi-top444 + (parse-meta507 + e2045 + w2044 + ae2043) + r2041 w2044 ctem2039 + rtem2038 '#t + top-ribcage2036 + meta-residualize!2035 + '#t) + (if (memv + t2048 + '(define-syntax-form)) + (call-with-values + (lambda () + (parse-define-syntax506 + e2045 + w2044 + ae2043)) + (lambda (id2061 + rhs2060 + w2059) + ((lambda (id2062) + (begin + (if (displaced-lexical?302 + id2062 + r2041) + (displaced-lexical-error303 + id2062) + (void)) + (if (not (top-ribcage-mutable?371 + top-ribcage2036)) + (syntax-error + (source-wrap439 + e2045 + w2059 + ae2043) + '"invalid definition in read-only environment") + (void)) + ((lambda (sym2063) + (call-with-values + (lambda () + (top-id-bound-var-name424 + sym2063 + (wrap-marks320 + (syntax-object-wrap66 + id2062)) + top-ribcage2036)) + (lambda (valsym2065 + bound-id2064) + (begin + (if (not (eq? (id-var-name429 + id2062 + '(())) + valsym2065)) + (syntax-error + (source-wrap439 + e2045 + w2059 + ae2043) + '"definition not permitted") + (void)) + (if (read-only-binding?144 + valsym2065) + (syntax-error + (source-wrap439 + e2045 + w2059 + ae2043) + '"invalid definition of read-only identifier") + (void)) + (ct-eval/residualize2488 + ctem2039 + (lambda () + (list + '$sc-put-cte + (list + 'quote + bound-id2064) + (chi493 + rhs2060 + r2041 + r2041 + w2059 + '#t) + (list + 'quote + (top-ribcage-key370 + top-ribcage2036))))))))) + ((lambda (x2066) + ((lambda (e2067) + (if (annotation?132 + e2067) + (annotation-expression + e2067) + e2067)) + (if (syntax-object?64 + x2066) + (syntax-object-expression65 + x2066) + x2066))) + id2062)))) + (wrap438 + id2061 + w2059)))) + (if (memv + t2048 + '(define-form)) + (call-with-values + (lambda () + (parse-define505 + e2045 + w2044 + ae2043)) + (lambda (id2070 + rhs2069 + w2068) + ((lambda (id2071) + (begin + (if (displaced-lexical?302 + id2071 + r2041) + (displaced-lexical-error303 + id2071) + (void)) + (if (not (top-ribcage-mutable?371 + top-ribcage2036)) + (syntax-error + (source-wrap439 + e2045 + w2068 + ae2043) + '"invalid definition in read-only environment") + (void)) + ((lambda (sym2072) + (call-with-values + (lambda () + (top-id-bound-var-name424 + sym2072 + (wrap-marks320 + (syntax-object-wrap66 + id2071)) + top-ribcage2036)) + (lambda (valsym2074 + bound-id2073) + (begin + (if (not (eq? (id-var-name429 + id2071 + '(())) + valsym2074)) + (syntax-error + (source-wrap439 + e2045 + w2068 + ae2043) + '"definition not permitted") + (void)) + (if (read-only-binding?144 + valsym2074) + (syntax-error + (source-wrap439 + e2045 + w2068 + ae2043) + '"invalid definition of read-only identifier") + (void)) + (if meta?2037 + (ct-eval/residualize2488 + ctem2039 + (lambda () + (build-sequence239 + '#f + (list + (list + '$sc-put-cte + (list + 'quote + bound-id2073) + (list + 'quote + (cons + 'meta-variable + valsym2074)) + (list + 'quote + (top-ribcage-key370 + top-ribcage2036))) + (list + 'define + valsym2074 + (chi493 + rhs2069 + r2041 + r2041 + w2068 + '#t)))))) + ((lambda (x2075) + (build-sequence239 + '#f + (list + x2075 + (rt-eval/residualize487 + rtem2038 + (lambda () + (list + 'define + valsym2074 + (chi493 + rhs2069 + r2041 + r2041 + w2068 + '#f))))))) + (ct-eval/residualize2488 + ctem2039 + (lambda () + (list + '$sc-put-cte + (list + 'quote + bound-id2073) + (list + 'quote + (cons + 'global + valsym2074)) + (list + 'quote + (top-ribcage-key370 + top-ribcage2036))))))))))) + ((lambda (x2076) + ((lambda (e2077) + (if (annotation?132 + e2077) + (annotation-expression + e2077) + e2077)) + (if (syntax-object?64 + x2076) + (syntax-object-expression65 + x2076) + x2076))) + id2071)))) + (wrap438 + id2070 + w2068)))) + (if (memv + t2048 + '($module-form)) + ((lambda (ribcage2078) + (call-with-values + (lambda () + (parse-module503 + e2045 + w2044 + ae2043 + (make-wrap319 + (wrap-marks320 + w2044) + (cons + ribcage2078 + (wrap-subst321 + w2044))))) + (lambda (orig2082 + id2081 + exports2080 + forms2079) + (begin + (if (displaced-lexical?302 + id2081 + r2041) + (displaced-lexical-error303 + (wrap438 + id2081 + w2044)) + (void)) + (if (not (top-ribcage-mutable?371 + top-ribcage2036)) + (syntax-error + orig2082 + '"invalid definition in read-only environment") + (void)) + (chi-top-module477 + orig2082 + r2041 + r2041 + top-ribcage2036 + ribcage2078 + ctem2039 + rtem2038 + meta?2037 + id2081 + exports2080 + forms2079 + meta-residualize!2035))))) + (make-ribcage360 + '() + '() + '())) + (if (memv + t2048 + '($import-form)) + (call-with-values + (lambda () + (parse-import504 + e2045 + w2044 + ae2043)) + (lambda (orig2085 + only?2084 + mid2083) + (begin + (if (not (top-ribcage-mutable?371 + top-ribcage2036)) + (syntax-error + orig2085 + '"invalid definition in read-only environment") + (void)) + (ct-eval/residualize2488 + ctem2039 + (lambda () + ((lambda (binding2086) + ((lambda (t2087) + (if (memv + t2087 + '($module)) + (do-top-import484 + only?2084 + top-ribcage2036 + mid2083 + (interface-token450 + (binding-value286 + binding2086))) + (if (memv + t2087 + '(displaced-lexical)) + (displaced-lexical-error303 + mid2083) + (syntax-error + mid2083 + '"unknown module")))) + (binding-type285 + binding2086))) + (lookup305 + (id-var-name429 + mid2083 + '(())) + '()))))))) + (if (memv + t2048 + '(alias-form)) + (call-with-values + (lambda () + (parse-alias509 + e2045 + w2044 + ae2043)) + (lambda (new-id2089 + old-id2088) + ((lambda (new-id2090) + (begin + (if (displaced-lexical?302 + new-id2090 + r2041) + (displaced-lexical-error303 + new-id2090) + (void)) + (if (not (top-ribcage-mutable?371 + top-ribcage2036)) + (syntax-error + (source-wrap439 + e2045 + w2044 + ae2043) + '"invalid definition in read-only environment") + (void)) + ((lambda (sym2091) + (call-with-values + (lambda () + (top-id-bound-var-name424 + sym2091 + (wrap-marks320 + (syntax-object-wrap66 + new-id2090)) + top-ribcage2036)) + (lambda (valsym2093 + bound-id2092) + (begin + (if (not (eq? (id-var-name429 + new-id2090 + '(())) + valsym2093)) + (syntax-error + (source-wrap439 + e2045 + w2044 + ae2043) + '"definition not permitted") + (void)) + (if (read-only-binding?144 + valsym2093) + (syntax-error + (source-wrap439 + e2045 + w2044 + ae2043) + '"invalid definition of read-only identifier") + (void)) + (ct-eval/residualize2488 + ctem2039 + (lambda () + (list + '$sc-put-cte + (list + 'quote + (make-resolved-id413 + sym2091 + (wrap-marks320 + (syntax-object-wrap66 + new-id2090)) + (id-var-name429 + old-id2088 + w2044))) + (list + 'quote + '(do-alias + . + #f)) + (list + 'quote + (top-ribcage-key370 + top-ribcage2036))))))))) + ((lambda (x2094) + ((lambda (e2095) + (if (annotation?132 + e2095) + (annotation-expression + e2095) + e2095)) + (if (syntax-object?64 + x2094) + (syntax-object-expression65 + x2094) + x2094))) + new-id2090)))) + (wrap438 + new-id2089 + w2044)))) + (begin + (if meta-seen?2034 + (syntax-error + (source-wrap439 + e2045 + w2044 + ae2043) + '"invalid meta definition") + (void)) + (if meta?2037 + ((lambda (x2096) + (begin + (top-level-eval-hook133 + x2096) + (ct-eval/residualize3489 + ctem2039 + void + (lambda () + x2096)))) + (chi-expr494 + type2047 + value2046 + e2045 + r2041 + r2041 + w2044 + ae2043 + '#t)) + (rt-eval/residualize487 + rtem2038 + (lambda () + (chi-expr494 + type2047 + value2046 + e2045 + r2041 + r2041 + w2044 + ae2043 + '#f))))))))))))))) + type2047))))) + (flatten-exports445 (lambda (exports2030) + ((letrec ((loop2031 (lambda (exports2033 + ls2032) + (if (null? + exports2033) + ls2032 + (loop2031 + (cdr exports2033) + (if (pair? + (car exports2033)) + (loop2031 + (car exports2033) + ls2032) + (cons + (car exports2033) + ls2032))))))) + loop2031) + exports2030 + '()))) + (make-interface446 (lambda (marks2029 exports2028 token2027) + (vector + 'interface + marks2029 + exports2028 + token2027))) + (interface?447 (lambda (x2026) + (if (vector? x2026) + (if (= (vector-length x2026) '4) + (eq? (vector-ref x2026 '0) 'interface) + '#f) + '#f))) + (interface-marks448 (lambda (x2025) (vector-ref x2025 '1))) + (interface-exports449 (lambda (x2024) + (vector-ref x2024 '2))) + (interface-token450 (lambda (x2023) (vector-ref x2023 '3))) + (set-interface-marks!451 (lambda (x2022 update2021) + (vector-set! x2022 '1 update2021))) + (set-interface-exports!452 (lambda (x2020 update2019) + (vector-set! + x2020 + '2 + update2019))) + (set-interface-token!453 (lambda (x2018 update2017) + (vector-set! x2018 '3 update2017))) + (make-unresolved-interface454 (lambda (mid2015 exports2014) + (make-interface446 + (wrap-marks320 + (syntax-object-wrap66 + mid2015)) + (list->vector + (map (lambda (x2016) + (if (pair? x2016) + (car x2016) + x2016)) + exports2014)) + '#f))) + (make-resolved-interface455 (lambda (mid2012 exports2011 + token2010) + (make-interface446 + (wrap-marks320 + (syntax-object-wrap66 + mid2012)) + (list->vector + (map (lambda (x2013) + (id->resolved-id414 + (if (pair? x2013) + (car x2013) + x2013))) + exports2011)) + token2010))) + (make-module-binding456 (lambda (type2009 id2008 label2007 + imps2006 val2005 exported2004) + (vector 'module-binding type2009 + id2008 label2007 imps2006 val2005 + exported2004))) + (module-binding?457 (lambda (x2003) + (if (vector? x2003) + (if (= (vector-length x2003) '7) + (eq? (vector-ref x2003 '0) + 'module-binding) + '#f) + '#f))) + (module-binding-type458 (lambda (x2002) + (vector-ref x2002 '1))) + (module-binding-id459 (lambda (x2001) + (vector-ref x2001 '2))) + (module-binding-label460 (lambda (x2000) + (vector-ref x2000 '3))) + (module-binding-imps461 (lambda (x1999) + (vector-ref x1999 '4))) + (module-binding-val462 (lambda (x1998) + (vector-ref x1998 '5))) + (module-binding-exported463 (lambda (x1997) + (vector-ref x1997 '6))) + (set-module-binding-type!464 (lambda (x1996 update1995) + (vector-set! + x1996 + '1 + update1995))) + (set-module-binding-id!465 (lambda (x1994 update1993) + (vector-set! + x1994 + '2 + update1993))) + (set-module-binding-label!466 (lambda (x1992 update1991) + (vector-set! + x1992 + '3 + update1991))) + (set-module-binding-imps!467 (lambda (x1990 update1989) + (vector-set! + x1990 + '4 + update1989))) + (set-module-binding-val!468 (lambda (x1988 update1987) + (vector-set! + x1988 + '5 + update1987))) + (set-module-binding-exported!469 (lambda (x1986 update1985) + (vector-set! + x1986 + '6 + update1985))) + (create-module-binding470 (lambda (type1984 id1983 label1982 + imps1981 val1980) + (make-module-binding456 type1984 + id1983 label1982 imps1981 val1980 + '#f))) + (make-frob471 (lambda (e1979 meta?1978) + (vector 'frob e1979 meta?1978))) + (frob?472 (lambda (x1977) + (if (vector? x1977) + (if (= (vector-length x1977) '3) + (eq? (vector-ref x1977 '0) 'frob) + '#f) + '#f))) + (frob-e473 (lambda (x1976) (vector-ref x1976 '1))) + (frob-meta?474 (lambda (x1975) (vector-ref x1975 '2))) + (set-frob-e!475 (lambda (x1974 update1973) + (vector-set! x1974 '1 update1973))) + (set-frob-meta?!476 (lambda (x1972 update1971) + (vector-set! x1972 '2 update1971))) + (chi-top-module477 (lambda (orig1912 r1911 mr1910 + top-ribcage1909 ribcage1908 + ctem1907 rtem1906 meta?1905 id1904 + exports1903 forms1902 + meta-residualize!1901) + ((lambda (fexports1913) + (call-with-values + (lambda () + (chi-external481 ribcage1908 + orig1912 + (map (lambda (d1970) + (make-frob471 + d1970 + meta?1905)) + forms1902) + r1911 mr1910 ctem1907 exports1903 + fexports1913 + meta-residualize!1901)) + (lambda (r1917 mr1916 bindings1915 + inits1914) + ((letrec ((process-exports1918 (lambda (fexports1920 + ctdefs1919) + (if (null? + fexports1920) + ((letrec ((process-locals1921 (lambda (bs1926 + r1925 + dts1924 + dvs1923 + des1922) + (if (null? + bs1926) + ((lambda (des1928 + inits1927) + (build-sequence239 + '#f + (append + (ctdefs1919) + (list + (ct-eval/residualize2488 + ctem1907 + (lambda () + ((lambda (sym1929) + ((lambda (token1930) + ((lambda (b1931) + ((lambda () + (call-with-values + (lambda () + (top-id-bound-var-name424 + sym1929 + (wrap-marks320 + (syntax-object-wrap66 + id1904)) + top-ribcage1909)) + (lambda (valsym1933 + bound-id1932) + (begin + (if (not (eq? (id-var-name429 + id1904 + '(())) + valsym1933)) + (syntax-error + orig1912 + '"definition not permitted") + (void)) + (if (read-only-binding?144 + valsym1933) + (syntax-error + orig1912 + '"invalid definition of read-only identifier") + (void)) + (list + '$sc-put-cte + (list + 'quote + bound-id1932) + b1931 + (list + 'quote + (top-ribcage-key370 + top-ribcage1909))))))))) + (list + 'quote + (cons + '$module + (make-resolved-interface455 + id1904 + exports1903 + token1930))))) + (generate-id147 + sym1929))) + ((lambda (x1934) + ((lambda (e1935) + (if (annotation?132 + e1935) + (annotation-expression + e1935) + e1935)) + (if (syntax-object?64 + x1934) + (syntax-object-expression65 + x1934) + x1934))) + id1904)))) + (rt-eval/residualize487 + rtem1906 + (lambda () + (build-top-module242 + '#f + dts1924 + dvs1923 + des1928 + (if (null? + inits1927) + (chi-void513) + (build-sequence239 + '#f + (append + inits1927 + (list + (chi-void513)))))))))))) + (chi-frobs490 + des1922 + r1925 + mr1916 + '#f) + (chi-frobs490 + inits1914 + r1925 + mr1916 + '#f)) + ((lambda (b1937 + bs1936) + ((lambda (t1938) + ((lambda (t1939) + (if (memv + t1939 + '(define-form)) + ((lambda (label1940) + (if (module-binding-exported463 + b1937) + ((lambda (var1941) + (process-locals1921 + bs1936 + r1925 + (cons + 'global + dts1924) + (cons + label1940 + dvs1923) + (cons + (module-binding-val462 + b1937) + des1922))) + (module-binding-id459 + b1937)) + ((lambda (var1942) + (process-locals1921 + bs1936 + (extend-env299 + label1940 + (cons + 'lexical + var1942) + r1925) + (cons + 'local + dts1924) + (cons + var1942 + dvs1923) + (cons + (module-binding-val462 + b1937) + des1922))) + (gen-var518 + (module-binding-id459 + b1937))))) + (get-indirect-label355 + (module-binding-label460 + b1937))) + (if (memv + t1939 + '(ctdefine-form + define-syntax-form + $module-form + alias-form)) + (process-locals1921 + bs1936 + r1925 + dts1924 + dvs1923 + des1922) + (error 'sc-expand-internal + '"unexpected module binding type ~s" + t1938)))) + (module-binding-type458 + b1937))) + (module-binding-type458 + b1937))) + (car bs1926) + (cdr bs1926)))))) + process-locals1921) + bindings1915 + r1917 + '() + '() + '()) + ((lambda (id1944 + fexports1943) + ((letrec ((loop1945 (lambda (bs1946) + (if (null? + bs1946) + (process-exports1918 + fexports1943 + ctdefs1919) + ((lambda (b1948 + bs1947) + (if (free-id=?430 + (module-binding-id459 + b1948) + id1944) + (if (module-binding-exported463 + b1948) + (process-exports1918 + fexports1943 + ctdefs1919) + ((lambda (t1949) + ((lambda (label1950) + ((lambda (imps1951) + ((lambda (fexports1952) + ((lambda () + (begin + (set-module-binding-exported!469 + b1948 + '#t) + ((lambda (t1953) + (if (memv + t1953 + '(define-form)) + ((lambda (sym1954) + (begin + (set-indirect-label!356 + label1950 + sym1954) + (process-exports1918 + fexports1952 + ctdefs1919))) + (generate-id147 + ((lambda (x1955) + ((lambda (e1956) + (if (annotation?132 + e1956) + (annotation-expression + e1956) + e1956)) + (if (syntax-object?64 + x1955) + (syntax-object-expression65 + x1955) + x1955))) + id1944))) + (if (memv + t1953 + '(ctdefine-form)) + ((lambda (b1957) + (process-exports1918 + fexports1952 + (lambda () + ((lambda (sym1958) + (begin + (set-indirect-label!356 + label1950 + sym1958) + (cons + (ct-eval/residualize3489 + ctem1907 + (lambda () + (put-cte-hook141 + sym1958 + b1957)) + (lambda () + (list + '$sc-put-cte + (list + 'quote + sym1958) + (list + 'quote + b1957) + (list + 'quote + '#f)))) + (ctdefs1919)))) + (binding-value286 + b1957))))) + (module-binding-val462 + b1948)) + (if (memv + t1953 + '(define-syntax-form)) + ((lambda (sym1959) + (process-exports1918 + fexports1952 + (lambda () + ((lambda (local-label1960) + (begin + (set-indirect-label!356 + label1950 + sym1959) + (cons + (ct-eval/residualize3489 + ctem1907 + (lambda () + (put-cte-hook141 + sym1959 + (car (module-binding-val462 + b1948)))) + (lambda () + (list + '$sc-put-cte + (list + 'quote + sym1959) + (cdr (module-binding-val462 + b1948)) + (list + 'quote + '#f)))) + (ctdefs1919)))) + (get-indirect-label355 + label1950))))) + (generate-id147 + ((lambda (x1961) + ((lambda (e1962) + (if (annotation?132 + e1962) + (annotation-expression + e1962) + e1962)) + (if (syntax-object?64 + x1961) + (syntax-object-expression65 + x1961) + x1961))) + id1944))) + (if (memv + t1953 + '($module-form)) + ((lambda (sym1964 + exports1963) + (process-exports1918 + (append + (flatten-exports445 + exports1963) + fexports1952) + (lambda () + (begin + (set-indirect-label!356 + label1950 + sym1964) + ((lambda (rest1965) + ((lambda (x1966) + (cons + (ct-eval/residualize3489 + ctem1907 + (lambda () + (put-cte-hook141 + sym1964 + x1966)) + (lambda () + (list + '$sc-put-cte + (list + 'quote + sym1964) + (list + 'quote + x1966) + (list + 'quote + '#f)))) + rest1965)) + (cons + '$module + (make-resolved-interface455 + id1944 + exports1963 + sym1964)))) + (ctdefs1919)))))) + (generate-id147 + ((lambda (x1967) + ((lambda (e1968) + (if (annotation?132 + e1968) + (annotation-expression + e1968) + e1968)) + (if (syntax-object?64 + x1967) + (syntax-object-expression65 + x1967) + x1967))) + id1944)) + (module-binding-val462 + b1948)) + (if (memv + t1953 + '(alias-form)) + (process-exports1918 + fexports1952 + (lambda () + ((lambda (rest1969) + (begin + (if (indirect-label?351 + label1950) + (if (not (symbol? + (get-indirect-label355 + label1950))) + (syntax-error + (module-binding-id459 + b1948) + '"unexported target of alias") + (void)) + (void)) + rest1969)) + (ctdefs1919)))) + (error 'sc-expand-internal + '"unexpected module binding type ~s" + t1949))))))) + t1949))))) + (append + imps1951 + fexports1943))) + (module-binding-imps461 + b1948))) + (module-binding-label460 + b1948))) + (module-binding-type458 + b1948))) + (loop1945 + bs1947))) + (car bs1946) + (cdr bs1946)))))) + loop1945) + bindings1915)) + (car fexports1920) + (cdr fexports1920)))))) + process-exports1918) + fexports1913 + (lambda () '()))))) + (flatten-exports445 exports1903)))) + (id-set-diff478 (lambda (exports1900 defs1899) + (if (null? exports1900) + '() + (if (bound-id-member?437 + (car exports1900) + defs1899) + (id-set-diff478 + (cdr exports1900) + defs1899) + (cons + (car exports1900) + (id-set-diff478 + (cdr exports1900) + defs1899)))))) + (check-module-exports479 (lambda (source-exp1874 + fexports1873 ids1872) + (letrec ((defined?1875 (lambda (e1882 + ids1881) + (ormap + (lambda (x1883) + (if (import-interface?375 + x1883) + ((lambda (x.iface1885 + x.new-marks1884) + ((lambda (t1886) + (if t1886 + ((lambda (token1887) + (lookup-import-binding-name410 + ((lambda (x1888) + ((lambda (e1889) + (if (annotation?132 + e1889) + (annotation-expression + e1889) + e1889)) + (if (syntax-object?64 + x1888) + (syntax-object-expression65 + x1888) + x1888))) + e1882) + (id-marks316 + e1882) + token1887 + x.new-marks1884)) + t1886) + ((lambda (v1890) + ((letrec ((lp1891 (lambda (i1892) + (if (>= i1892 + '0) + ((lambda (t1893) + (if t1893 + t1893 + (lp1891 + (- i1892 + '1)))) + ((lambda (id1894) + (help-bound-id=?432 + ((lambda (x1897) + ((lambda (e1898) + (if (annotation?132 + e1898) + (annotation-expression + e1898) + e1898)) + (if (syntax-object?64 + x1897) + (syntax-object-expression65 + x1897) + x1897))) + id1894) + (join-marks418 + x.new-marks1884 + (id-marks316 + id1894)) + ((lambda (x1895) + ((lambda (e1896) + (if (annotation?132 + e1896) + (annotation-expression + e1896) + e1896)) + (if (syntax-object?64 + x1895) + (syntax-object-expression65 + x1895) + x1895))) + e1882) + (id-marks316 + e1882))) + (vector-ref + v1890 + i1892))) + '#f)))) + lp1891) + (- (vector-length + v1890) + '1))) + (interface-exports449 + x.iface1885)))) + (interface-token450 + x.iface1885))) + (import-interface-interface376 + x1883) + (import-interface-new-marks377 + x1883)) + (bound-id=?433 + e1882 + x1883))) + ids1881)))) + ((letrec ((loop1876 (lambda (fexports1878 + missing1877) + (if (null? + fexports1878) + (if (not (null? + missing1877)) + (syntax-error + (car missing1877) + (if (= (length + missing1877) + '1) + '"missing definition for export" + '"missing definition for multiple exports, including")) + (void)) + ((lambda (e1880 + fexports1879) + (if (defined?1875 + e1880 + ids1872) + (loop1876 + fexports1879 + missing1877) + (loop1876 + fexports1879 + (cons + e1880 + missing1877)))) + (car fexports1878) + (cdr fexports1878)))))) + loop1876) + fexports1873 + '())))) + (check-defined-ids480 (lambda (source-exp1821 ls1820) + (letrec ((vfold1822 (lambda (v1867 + p1866 + cls1865) + ((lambda (len1868) + ((letrec ((lp1869 (lambda (i1871 + cls1870) + (if (= i1871 + len1868) + cls1870 + (lp1869 + (+ i1871 + '1) + (p1866 + (vector-ref + v1867 + i1871) + cls1870)))))) + lp1869) + '0 + cls1865)) + (vector-length + v1867)))) + (conflicts1823 (lambda (x1852 + y1851 + cls1850) + (if (import-interface?375 + x1852) + ((lambda (x.iface1854 + x.new-marks1853) + (if (import-interface?375 + y1851) + ((lambda (y.iface1856 + y.new-marks1855) + ((lambda (xe1858 + ye1857) + (if (> (vector-length + xe1858) + (vector-length + ye1857)) + (vfold1822 + ye1857 + (lambda (id1860 + cls1859) + (id-iface-conflicts1824 + id1860 + y.new-marks1855 + x.iface1854 + x.new-marks1853 + cls1859)) + cls1850) + (vfold1822 + xe1858 + (lambda (id1862 + cls1861) + (id-iface-conflicts1824 + id1862 + x.new-marks1853 + y.iface1856 + y.new-marks1855 + cls1861)) + cls1850))) + (interface-exports449 + x.iface1854) + (interface-exports449 + y.iface1856))) + (import-interface-interface376 + y1851) + (import-interface-new-marks377 + y1851)) + (id-iface-conflicts1824 + y1851 + '() + x.iface1854 + x.new-marks1853 + cls1850))) + (import-interface-interface376 + x1852) + (import-interface-new-marks377 + x1852)) + (if (import-interface?375 + y1851) + ((lambda (y.iface1864 + y.new-marks1863) + (id-iface-conflicts1824 + x1852 + '() + y.iface1864 + y.new-marks1863 + cls1850)) + (import-interface-interface376 + y1851) + (import-interface-new-marks377 + y1851)) + (if (bound-id=?433 + x1852 + y1851) + (cons + x1852 + cls1850) + cls1850))))) + (id-iface-conflicts1824 (lambda (id1837 + id.new-marks1836 + iface1835 + iface.new-marks1834 + cls1833) + ((lambda (id.sym1839 + id.marks1838) + ((lambda (t1840) + (if t1840 + ((lambda (token1841) + (if (lookup-import-binding-name410 + id.sym1839 + id.marks1838 + token1841 + iface.new-marks1834) + (cons + id1837 + cls1833) + cls1833)) + t1840) + (vfold1822 + (interface-exports449 + iface1835) + (lambda (*id1843 + cls1842) + ((lambda (*id.sym1845 + *id.marks1844) + (if (help-bound-id=?432 + *id.sym1845 + *id.marks1844 + id.sym1839 + id.marks1838) + (cons + *id1843 + cls1842) + cls1842)) + ((lambda (x1846) + ((lambda (e1847) + (if (annotation?132 + e1847) + (annotation-expression + e1847) + e1847)) + (if (syntax-object?64 + x1846) + (syntax-object-expression65 + x1846) + x1846))) + *id1843) + (join-marks418 + iface.new-marks1834 + (id-marks316 + *id1843)))) + cls1833))) + (interface-token450 + iface1835))) + ((lambda (x1848) + ((lambda (e1849) + (if (annotation?132 + e1849) + (annotation-expression + e1849) + e1849)) + (if (syntax-object?64 + x1848) + (syntax-object-expression65 + x1848) + x1848))) + id1837) + (join-marks418 + id.new-marks1836 + (id-marks316 + id1837)))))) + (if (not (null? ls1820)) + ((letrec ((lp1825 (lambda (x1828 + ls1827 + cls1826) + (if (null? + ls1827) + (if (not (null? + cls1826)) + ((lambda (cls1829) + (syntax-error + source-exp1821 + '"duplicate definition for " + (symbol->string + (car cls1829)) + '" in")) + (syntax-object->datum + cls1826)) + (void)) + ((letrec ((lp21830 (lambda (ls21832 + cls1831) + (if (null? + ls21832) + (lp1825 + (car ls1827) + (cdr ls1827) + cls1831) + (lp21830 + (cdr ls21832) + (conflicts1823 + x1828 + (car ls21832) + cls1831)))))) + lp21830) + ls1827 + cls1826))))) + lp1825) + (car ls1820) + (cdr ls1820) + '()) + (void))))) + (chi-external481 (lambda (ribcage1713 source-exp1712 + body1711 r1710 mr1709 ctem1708 + exports1707 fexports1706 + meta-residualize!1705) + (letrec ((return1714 (lambda (r1819 mr1818 + bindings1817 + ids1816 + inits1815) + (begin + (check-defined-ids480 + source-exp1712 + ids1816) + (check-module-exports479 + source-exp1712 + fexports1706 + ids1816) + (values + r1819 + mr1818 + bindings1817 + inits1815)))) + (get-implicit-exports1715 (lambda (id1812) + ((letrec ((f1813 (lambda (exports1814) + (if (null? + exports1814) + '() + (if (if (pair? + (car exports1814)) + (bound-id=?433 + id1812 + (caar + exports1814)) + '#f) + (flatten-exports445 + (cdar + exports1814)) + (f1813 + (cdr exports1814))))))) + f1813) + exports1707))) + (update-imp-exports1716 (lambda (bindings1807 + exports1806) + ((lambda (exports1808) + (map (lambda (b1809) + ((lambda (id1810) + (if (not (bound-id-member?437 + id1810 + exports1808)) + b1809 + (create-module-binding470 + (module-binding-type458 + b1809) + id1810 + (module-binding-label460 + b1809) + (append + (get-implicit-exports1715 + id1810) + (module-binding-imps461 + b1809)) + (module-binding-val462 + b1809)))) + (module-binding-id459 + b1809))) + bindings1807)) + (map (lambda (x1811) + (if (pair? + x1811) + (car x1811) + x1811)) + exports1806))))) + ((letrec ((parse1717 (lambda (body1724 + r1723 mr1722 + ids1721 + bindings1720 + inits1719 + meta-seen?1718) + (if (null? + body1724) + (return1714 + r1723 mr1722 + bindings1720 + ids1721 + inits1719) + ((lambda (fr1725) + ((lambda (e1726) + ((lambda (meta?1727) + ((lambda () + (call-with-values + (lambda () + (syntax-type441 + e1726 + r1723 + '(()) + '#f + ribcage1713)) + (lambda (type1732 + value1731 + e1730 + w1729 + ae1728) + ((lambda (t1733) + (if (memv + t1733 + '(define-form)) + (call-with-values + (lambda () + (parse-define505 + e1730 + w1729 + ae1728)) + (lambda (id1736 + rhs1735 + w1734) + ((lambda (id1737) + ((lambda (label1738) + ((lambda (sym1739) + ((lambda (imps1740) + ((lambda () + (begin + (extend-ribcage!405 + ribcage1713 + id1737 + label1738) + (if meta?1727 + ((lambda (sym1741) + ((lambda (b1742) + ((lambda () + ((lambda (mr1743) + ((lambda (exp1744) + (begin + (define-top-level-value-hook135 + sym1741 + (top-level-eval-hook133 + exp1744)) + (meta-residualize!1705 + (ct-eval/residualize3489 + ctem1708 + void + (lambda () + (list + 'define + sym1741 + exp1744)))) + (parse1717 + (cdr body1724) + r1723 + mr1743 + (cons + id1737 + ids1721) + (cons + (create-module-binding470 + 'ctdefine-form + id1737 + label1738 + imps1740 + b1742) + bindings1720) + inits1719 + '#f))) + (chi493 + rhs1735 + mr1743 + mr1743 + w1734 + '#t))) + (extend-env299 + (get-indirect-label355 + label1738) + b1742 + mr1722))))) + (cons + 'meta-variable + sym1741))) + (generate-id147 + ((lambda (x1745) + ((lambda (e1746) + (if (annotation?132 + e1746) + (annotation-expression + e1746) + e1746)) + (if (syntax-object?64 + x1745) + (syntax-object-expression65 + x1745) + x1745))) + id1737))) + (parse1717 + (cdr body1724) + r1723 + mr1722 + (cons + id1737 + ids1721) + (cons + (create-module-binding470 + type1732 + id1737 + label1738 + imps1740 + (make-frob471 + (wrap438 + rhs1735 + w1734) + meta?1727)) + bindings1720) + inits1719 + '#f)))))) + (get-implicit-exports1715 + id1737))) + (generate-id147 + ((lambda (x1747) + ((lambda (e1748) + (if (annotation?132 + e1748) + (annotation-expression + e1748) + e1748)) + (if (syntax-object?64 + x1747) + (syntax-object-expression65 + x1747) + x1747))) + id1737)))) + (gen-indirect-label354))) + (wrap438 + id1736 + w1734)))) + (if (memv + t1733 + '(define-syntax-form)) + (call-with-values + (lambda () + (parse-define-syntax506 + e1730 + w1729 + ae1728)) + (lambda (id1751 + rhs1750 + w1749) + ((lambda (id1752) + ((lambda (label1753) + ((lambda (imps1754) + ((lambda (exp1755) + ((lambda () + (begin + (extend-ribcage!405 + ribcage1713 + id1752 + label1753) + ((lambda (l1757 + b1756) + (parse1717 + (cdr body1724) + (extend-env299 + l1757 + b1756 + r1723) + (extend-env299 + l1757 + b1756 + mr1722) + (cons + id1752 + ids1721) + (cons + (create-module-binding470 + type1732 + id1752 + label1753 + imps1754 + (cons + b1756 + exp1755)) + bindings1720) + inits1719 + '#f)) + (get-indirect-label355 + label1753) + (defer-or-eval-transformer307 + top-level-eval-hook133 + exp1755)))))) + (chi493 + rhs1750 + mr1722 + mr1722 + w1749 + '#t))) + (get-implicit-exports1715 + id1752))) + (gen-indirect-label354))) + (wrap438 + id1751 + w1749)))) + (if (memv + t1733 + '($module-form)) + ((lambda (*ribcage1758) + ((lambda (*w1759) + ((lambda () + (call-with-values + (lambda () + (parse-module503 + e1730 + w1729 + ae1728 + *w1759)) + (lambda (orig1763 + id1762 + *exports1761 + forms1760) + (call-with-values + (lambda () + (chi-external481 + *ribcage1758 + orig1763 + (map (lambda (d1775) + (make-frob471 + d1775 + meta?1727)) + forms1760) + r1723 + mr1722 + ctem1708 + *exports1761 + (flatten-exports445 + *exports1761) + meta-residualize!1705)) + (lambda (r1767 + mr1766 + *bindings1765 + *inits1764) + ((lambda (iface1772 + bindings1771 + inits1770 + label1769 + imps1768) + (begin + (extend-ribcage!405 + ribcage1713 + id1762 + label1769) + ((lambda (l1774 + b1773) + (parse1717 + (cdr body1724) + (extend-env299 + l1774 + b1773 + r1767) + (extend-env299 + l1774 + b1773 + mr1766) + (cons + id1762 + ids1721) + (cons + (create-module-binding470 + type1732 + id1762 + label1769 + imps1768 + *exports1761) + bindings1771) + inits1770 + '#f)) + (get-indirect-label355 + label1769) + (cons + '$module + iface1772)))) + (make-unresolved-interface454 + id1762 + *exports1761) + (append + *bindings1765 + bindings1720) + (append + inits1719 + *inits1764) + (gen-indirect-label354) + (get-implicit-exports1715 + id1762))))))))) + (make-wrap319 + (wrap-marks320 + w1729) + (cons + *ribcage1758 + (wrap-subst321 + w1729))))) + (make-ribcage360 + '() + '() + '())) + (if (memv + t1733 + '($import-form)) + (call-with-values + (lambda () + (parse-import504 + e1730 + w1729 + ae1728)) + (lambda (orig1778 + only?1777 + mid1776) + ((lambda (mlabel1779) + ((lambda (binding1780) + ((lambda (t1781) + (if (memv + t1781 + '($module)) + ((lambda (iface1782) + ((lambda (import-iface1783) + ((lambda () + (begin + (if only?1777 + (extend-ribcage-barrier!407 + ribcage1713 + mid1776) + (void)) + (do-import!502 + import-iface1783 + ribcage1713) + (parse1717 + (cdr body1724) + r1723 + mr1722 + (cons + import-iface1783 + ids1721) + (update-imp-exports1716 + bindings1720 + (vector->list + (interface-exports449 + iface1782))) + inits1719 + '#f))))) + (make-import-interface374 + iface1782 + (import-mark-delta500 + mid1776 + iface1782)))) + (binding-value286 + binding1780)) + (if (memv + t1781 + '(displaced-lexical)) + (displaced-lexical-error303 + mid1776) + (syntax-error + mid1776 + '"unknown module")))) + (binding-type285 + binding1780))) + (lookup305 + mlabel1779 + r1723))) + (id-var-name429 + mid1776 + '(()))))) + (if (memv + t1733 + '(alias-form)) + (call-with-values + (lambda () + (parse-alias509 + e1730 + w1729 + ae1728)) + (lambda (new-id1785 + old-id1784) + ((lambda (new-id1786) + ((lambda (label1787) + ((lambda (imps1788) + ((lambda () + (begin + (extend-ribcage!405 + ribcage1713 + new-id1786 + label1787) + (parse1717 + (cdr body1724) + r1723 + mr1722 + (cons + new-id1786 + ids1721) + (cons + (create-module-binding470 + type1732 + new-id1786 + label1787 + imps1788 + '#f) + bindings1720) + inits1719 + '#f))))) + (get-implicit-exports1715 + new-id1786))) + (id-var-name-loc428 + old-id1784 + w1729))) + (wrap438 + new-id1785 + w1729)))) + (if (memv + t1733 + '(begin-form)) + (parse1717 + ((letrec ((f1789 (lambda (forms1790) + (if (null? + forms1790) + (cdr body1724) + (cons + (make-frob471 + (wrap438 + (car forms1790) + w1729) + meta?1727) + (f1789 + (cdr forms1790))))))) + f1789) + (parse-begin510 + e1730 + w1729 + ae1728 + '#t)) + r1723 + mr1722 + ids1721 + bindings1720 + inits1719 + '#f) + (if (memv + t1733 + '(eval-when-form)) + (call-with-values + (lambda () + (parse-eval-when508 + e1730 + w1729 + ae1728)) + (lambda (when-list1792 + forms1791) + (parse1717 + (if (memq + 'eval + when-list1792) + ((letrec ((f1793 (lambda (forms1794) + (if (null? + forms1794) + (cdr body1724) + (cons + (make-frob471 + (wrap438 + (car forms1794) + w1729) + meta?1727) + (f1793 + (cdr forms1794))))))) + f1793) + forms1791) + (cdr body1724)) + r1723 + mr1722 + ids1721 + bindings1720 + inits1719 + '#f))) + (if (memv + t1733 + '(meta-form)) + (parse1717 + (cons + (make-frob471 + (wrap438 + (parse-meta507 + e1730 + w1729 + ae1728) + w1729) + '#t) + (cdr body1724)) + r1723 + mr1722 + ids1721 + bindings1720 + inits1719 + '#t) + (if (memv + t1733 + '(local-syntax-form)) + (call-with-values + (lambda () + (chi-local-syntax512 + value1731 + e1730 + r1723 + mr1722 + w1729 + ae1728)) + (lambda (forms1799 + r1798 + mr1797 + w1796 + ae1795) + (parse1717 + ((letrec ((f1800 (lambda (forms1801) + (if (null? + forms1801) + (cdr body1724) + (cons + (make-frob471 + (wrap438 + (car forms1801) + w1796) + meta?1727) + (f1800 + (cdr forms1801))))))) + f1800) + forms1799) + r1798 + mr1797 + ids1721 + bindings1720 + inits1719 + '#f))) + (begin + (if meta-seen?1718 + (syntax-error + (source-wrap439 + e1730 + w1729 + ae1728) + '"invalid meta definition") + (void)) + ((letrec ((f1802 (lambda (body1803) + (if ((lambda (t1804) + (if t1804 + t1804 + (not (frob-meta?474 + (car body1803))))) + (null? + body1803)) + (return1714 + r1723 + mr1722 + bindings1720 + ids1721 + (append + inits1719 + body1803)) + (begin + ((lambda (x1805) + (begin + (top-level-eval-hook133 + x1805) + (meta-residualize!1705 + (ct-eval/residualize3489 + ctem1708 + void + (lambda () + x1805))))) + (chi-meta-frob491 + (car body1803) + mr1722)) + (f1802 + (cdr body1803))))))) + f1802) + (cons + (make-frob471 + (source-wrap439 + e1730 + w1729 + ae1728) + meta?1727) + (cdr body1724)))))))))))))) + type1732)))))) + (frob-meta?474 + fr1725))) + (frob-e473 + fr1725))) + (car body1724)))))) + parse1717) body1711 r1710 mr1709 '() + '() '() '#f)))) + (vmap482 (lambda (fn1701 v1700) + ((letrec ((do1702 (lambda (i1704 ls1703) + (if (< i1704 '0) + ls1703 + (do1702 + (- i1704 '1) + (cons + (fn1701 + (vector-ref + v1700 + i1704)) + ls1703)))))) + do1702) + (- (vector-length v1700) '1) + '()))) + (vfor-each483 (lambda (fn1696 v1695) + ((lambda (len1697) + ((letrec ((do1698 (lambda (i1699) + (if (not (= i1699 + len1697)) + (begin + (fn1696 + (vector-ref + v1695 + i1699)) + (do1698 + (+ i1699 '1))) + (void))))) + do1698) + '0)) + (vector-length v1695)))) + (do-top-import484 (lambda (import-only?1694 top-ribcage1693 + mid1692 token1691) + (list + '$sc-put-cte + (list 'quote mid1692) + (list 'quote (cons 'do-import token1691)) + (list + 'quote + (top-ribcage-key370 + top-ribcage1693))))) + (update-mode-set485 ((lambda (table1682) + (lambda (when-list1684 mode-set1683) + (letrec ((remq1685 (lambda (x1690 + ls1689) + (if (null? + ls1689) + '() + (if (eq? (car ls1689) + x1690) + (remq1685 + x1690 + (cdr ls1689)) + (cons + (car ls1689) + (remq1685 + x1690 + (cdr ls1689)))))))) + (remq1685 + '- + (apply + append + (map (lambda (m1686) + ((lambda (row1687) + (map (lambda (s1688) + (cdr (assq + s1688 + row1687))) + when-list1684)) + (cdr (assq + m1686 + table1682)))) + mode-set1683)))))) + '((l (load . l) (compile . c) (visit . v) + (revisit . r) (eval . -)) + (c (load . -) (compile . -) + (visit . -) (revisit . -) + (eval . c)) + (v (load . v) (compile . c) + (visit . v) (revisit . -) + (eval . -)) + (r (load . r) (compile . c) + (visit . -) (revisit . r) + (eval . -)) + (e (load . -) (compile . -) + (visit . -) (revisit . -) + (eval . e))))) + (initial-mode-set486 (lambda (when-list1678 + compiling-a-file1677) + (apply + append + (map (lambda (s1679) + (if compiling-a-file1677 + ((lambda (t1680) + (if (memv + t1680 + '(compile)) + '(c) + (if (memv + t1680 + '(load)) + '(l) + (if (memv + t1680 + '(visit)) + '(v) + (if (memv + t1680 + '(revisit)) + '(r) + '()))))) + s1679) + ((lambda (t1681) + (if (memv t1681 '(eval)) + '(e) + '())) + s1679))) + when-list1678)))) + (rt-eval/residualize487 (lambda (rtem1672 thunk1671) + (if (memq 'e rtem1672) + (thunk1671) + ((lambda (thunk1673) + (if (memq 'v rtem1672) + (if ((lambda (t1674) + (if t1674 + t1674 + (memq + 'r + rtem1672))) + (memq 'l rtem1672)) + (thunk1673) + (thunk1673)) + (if ((lambda (t1675) + (if t1675 + t1675 + (memq + 'r + rtem1672))) + (memq 'l rtem1672)) + (thunk1673) + (chi-void513)))) + (if (memq 'c rtem1672) + ((lambda (x1676) + (begin + (top-level-eval-hook133 + x1676) + (lambda () x1676))) + (thunk1671)) + thunk1671))))) + (ct-eval/residualize2488 (lambda (ctem1668 thunk1667) + ((lambda (t1669) + (ct-eval/residualize3489 + ctem1668 + (lambda () + (begin + (if (not t1669) + (set! t1669 + (thunk1667)) + (void)) + (top-level-eval-hook133 + t1669))) + (lambda () + ((lambda (t1670) + (if t1670 + t1670 + (thunk1667))) + t1669)))) + '#f))) + (ct-eval/residualize3489 (lambda (ctem1664 eval-thunk1663 + residualize-thunk1662) + (if (memq 'e ctem1664) + (begin + (eval-thunk1663) + (chi-void513)) + (begin + (if (memq 'c ctem1664) + (eval-thunk1663) + (void)) + (if (memq 'r ctem1664) + (if ((lambda (t1665) + (if t1665 + t1665 + (memq + 'v + ctem1664))) + (memq 'l ctem1664)) + (residualize-thunk1662) + (residualize-thunk1662)) + (if ((lambda (t1666) + (if t1666 + t1666 + (memq + 'v + ctem1664))) + (memq 'l ctem1664)) + (residualize-thunk1662) + (chi-void513))))))) + (chi-frobs490 (lambda (frob*1660 r1659 mr1658 m?1657) + (map (lambda (x1661) + (chi493 (frob-e473 x1661) r1659 mr1658 + '(()) m?1657)) + frob*1660))) + (chi-meta-frob491 (lambda (x1656 mr1655) + (chi493 (frob-e473 x1656) mr1655 mr1655 + '(()) '#t))) + (chi-sequence492 (lambda (body1651 r1650 mr1649 w1648 ae1647 + m?1646) + (build-sequence239 + ae1647 + ((letrec ((dobody1652 (lambda (body1653) + (if (null? + body1653) + '() + ((lambda (first1654) + (cons + first1654 + (dobody1652 + (cdr body1653)))) + (chi493 + (car body1653) + r1650 + mr1649 + w1648 + m?1646)))))) + dobody1652) + body1651)))) + (chi493 (lambda (e1640 r1639 mr1638 w1637 m?1636) + (call-with-values + (lambda () + (syntax-type441 e1640 r1639 w1637 '#f '#f)) + (lambda (type1645 value1644 e1643 w1642 ae1641) + (chi-expr494 type1645 value1644 e1643 r1639 + mr1638 w1642 ae1641 m?1636))))) + (chi-expr494 (lambda (type1620 value1619 e1618 r1617 mr1616 + w1615 ae1614 m?1613) + ((lambda (t1621) + (if (memv t1621 '(lexical)) + value1619 + (if (memv t1621 '(core)) + (value1619 e1618 r1617 mr1616 w1615 + ae1614 m?1613) + (if (memv t1621 '(lexical-call)) + (chi-application495 value1619 + e1618 r1617 mr1616 w1615 ae1614 + m?1613) + (if (memv t1621 '(constant)) + (list + 'quote + (strip517 + (source-wrap439 + e1618 + w1615 + ae1614) + '(()))) + (if (memv t1621 '(global)) + value1619 + (if (memv + t1621 + '(meta-variable)) + (if m?1613 + value1619 + (displaced-lexical-error303 + (source-wrap439 + e1618 + w1615 + ae1614))) + (if (memv + t1621 + '(call)) + (chi-application495 + (chi493 + (car e1618) + r1617 mr1616 + w1615 m?1613) + e1618 r1617 + mr1616 w1615 + ae1614 m?1613) + (if (memv + t1621 + '(begin-form)) + (chi-sequence492 + (parse-begin510 + e1618 + w1615 + ae1614 + '#f) + r1617 + mr1616 + w1615 + ae1614 + m?1613) + (if (memv + t1621 + '(local-syntax-form)) + (call-with-values + (lambda () + (chi-local-syntax512 + value1619 + e1618 + r1617 + mr1616 + w1615 + ae1614)) + (lambda (forms1626 + r1625 + mr1624 + w1623 + ae1622) + (chi-sequence492 + forms1626 + r1625 + mr1624 + w1623 + ae1622 + m?1613))) + (if (memv + t1621 + '(eval-when-form)) + (call-with-values + (lambda () + (parse-eval-when508 + e1618 + w1615 + ae1614)) + (lambda (when-list1628 + forms1627) + (if (memq + 'eval + when-list1628) + (chi-sequence492 + forms1627 + r1617 + mr1616 + w1615 + ae1614 + m?1613) + (chi-void513)))) + (if (memv + t1621 + '(meta-form)) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614) + '"invalid context for meta definition") + (if (memv + t1621 + '(define-form)) + (begin + (parse-define505 + e1618 + w1615 + ae1614) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614) + '"invalid context for definition")) + (if (memv + t1621 + '(define-syntax-form)) + (begin + (parse-define-syntax506 + e1618 + w1615 + ae1614) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614) + '"invalid context for definition")) + (if (memv + t1621 + '($module-form)) + (call-with-values + (lambda () + (parse-module503 + e1618 + w1615 + ae1614 + w1615)) + (lambda (orig1632 + id1631 + exports1630 + forms1629) + (syntax-error + orig1632 + '"invalid context for definition"))) + (if (memv + t1621 + '($import-form)) + (call-with-values + (lambda () + (parse-import504 + e1618 + w1615 + ae1614)) + (lambda (orig1635 + only?1634 + mid1633) + (syntax-error + orig1635 + '"invalid context for definition"))) + (if (memv + t1621 + '(alias-form)) + (begin + (parse-alias509 + e1618 + w1615 + ae1614) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614) + '"invalid context for definition")) + (if (memv + t1621 + '(syntax)) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614) + '"reference to pattern variable outside syntax form") + (if (memv + t1621 + '(displaced-lexical)) + (displaced-lexical-error303 + (source-wrap439 + e1618 + w1615 + ae1614)) + (syntax-error + (source-wrap439 + e1618 + w1615 + ae1614))))))))))))))))))))) + type1620))) + (chi-application495 (lambda (x1605 e1604 r1603 mr1602 w1601 + ae1600 m?1599) + ((lambda (tmp1606) + ((lambda (tmp1607) + (if tmp1607 + (apply + (lambda (e01609 e11608) + (cons + x1605 + (map (lambda (e1611) + (chi493 e1611 + r1603 mr1602 + w1601 m?1599)) + e11608))) + tmp1607) + ((lambda (_1612) + (syntax-error + (source-wrap439 + e1604 + w1601 + ae1600))) + tmp1606))) + ($syntax-dispatch + tmp1606 + '(any . each-any)))) + e1604))) + (chi-set!496 (lambda (e1573 r1572 w1571 ae1570 rib1569) + ((lambda (tmp1574) + ((lambda (tmp1575) + (if (if tmp1575 + (apply + (lambda (_1578 id1577 val1576) + (id?310 id1577)) + tmp1575) + '#f) + (apply + (lambda (_1581 id1580 val1579) + ((lambda (n1582) + ((lambda (b1583) + ((lambda (t1584) + (if (memv + t1584 + '(macro!)) + ((lambda (id1586 + val1585) + (syntax-type441 + (chi-macro497 + (binding-value286 + b1583) + (list + '#(syntax-object set! ((top) #(ribcage () () ()) #(ribcage #(id val) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(t) #(("m" top)) #("i")) #(ribcage () () ()) #(ribcage #(b) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(n) #((top)) #("i")) #(ribcage #(_ id val) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(e r w ae rib) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + id1586 + val1585) + r1572 '(()) + '#f rib1569) + r1572 '(()) '#f + rib1569)) + (wrap438 + id1580 + w1571) + (wrap438 + val1579 + w1571)) + (values 'core + (lambda (e1592 + r1591 + mr1590 + w1589 + ae1588 + m?1587) + ((lambda (val1594 + n1593) + ((lambda (b1595) + ((lambda (t1596) + (if (memv + t1596 + '(lexical)) + (list + 'set! + (binding-value286 + b1595) + val1594) + (if (memv + t1596 + '(global)) + ((lambda (sym1597) + (begin + (if (read-only-binding?144 + n1593) + (syntax-error + (source-wrap439 + e1592 + w1589 + ae1588) + '"invalid assignment to read-only variable") + (void)) + (list + 'set! + sym1597 + val1594))) + (binding-value286 + b1595)) + (if (memv + t1596 + '(meta-variable)) + (if m?1587 + (list + 'set! + (binding-value286 + b1595) + val1594) + (displaced-lexical-error303 + (wrap438 + id1580 + w1589))) + (if (memv + t1596 + '(displaced-lexical)) + (displaced-lexical-error303 + (wrap438 + id1580 + w1589)) + (syntax-error + (source-wrap439 + e1592 + w1589 + ae1588))))))) + (binding-type285 + b1595))) + (lookup305 + n1593 + r1591))) + (chi493 val1579 + r1591 mr1590 + w1589 m?1587) + (id-var-name429 + id1580 + w1589))) + e1573 w1571 + ae1570))) + (binding-type285 b1583))) + (lookup305 n1582 r1572))) + (id-var-name429 id1580 w1571))) + tmp1575) + ((lambda (_1598) + (syntax-error + (source-wrap439 + e1573 + w1571 + ae1570))) + tmp1574))) + ($syntax-dispatch tmp1574 '(any any any)))) + e1573))) + (chi-macro497 (lambda (p1556 e1555 r1554 w1553 ae1552 + rib1551) + (letrec ((rebuild-macro-output1557 (lambda (x1561 + m1560) + (if (pair? + x1561) + (cons + (rebuild-macro-output1557 + (car x1561) + m1560) + (rebuild-macro-output1557 + (cdr x1561) + m1560)) + (if (syntax-object?64 + x1561) + ((lambda (w1562) + ((lambda (ms1564 + s1563) + (make-syntax-object63 + (syntax-object-expression65 + x1561) + (if (if (pair? + ms1564) + (eq? (car ms1564) + '#f) + '#f) + (make-wrap319 + (cdr ms1564) + (cdr s1563)) + (make-wrap319 + (cons + m1560 + ms1564) + (if rib1551 + (cons + rib1551 + (cons + 'shift + s1563)) + (cons + 'shift + s1563)))))) + (wrap-marks320 + w1562) + (wrap-subst321 + w1562))) + (syntax-object-wrap66 + x1561)) + (if (vector? + x1561) + ((lambda (n1565) + ((lambda (v1566) + ((lambda () + ((letrec ((do1567 (lambda (i1568) + (if (= i1568 + n1565) + v1566 + (begin + (vector-set! + v1566 + i1568 + (rebuild-macro-output1557 + (vector-ref + x1561 + i1568) + m1560)) + (do1567 + (+ i1568 + '1))))))) + do1567) + '0)))) + (make-vector + n1565))) + (vector-length + x1561)) + (if (symbol? + x1561) + (syntax-error + (source-wrap439 + e1555 + w1553 + ae1552) + '"encountered raw symbol " + (symbol->string + x1561) + '" in output of macro") + x1561))))))) + (rebuild-macro-output1557 + ((lambda (out1558) + (if (procedure? out1558) + (out1558 + (lambda (id1559) + (begin + (if (not (identifier? id1559)) + (syntax-error + id1559 + '"environment argument is not an identifier") + (void)) + (lookup305 + (id-var-name429 + id1559 + '(())) + r1554)))) + out1558)) + (p1556 + (source-wrap439 + e1555 + (anti-mark395 w1553) + ae1552))) + (string '#\m))))) + (chi-body498 (lambda (body1539 outer-form1538 r1537 mr1536 + w1535 m?1534) + ((lambda (ribcage1540) + ((lambda (w1541) + ((lambda (body1542) + ((lambda () + (call-with-values + (lambda () + (chi-internal499 ribcage1540 + outer-form1538 body1542 r1537 + mr1536 m?1534)) + (lambda (r1549 mr1548 exprs1547 + ids1546 vars1545 vals1544 + inits1543) + (begin + (if (null? exprs1547) + (syntax-error + outer-form1538 + '"no expressions in body") + (void)) + (build-body241 + '#f + (reverse vars1545) + (chi-frobs490 + (reverse vals1544) + r1549 + mr1548 + m?1534) + (build-sequence239 + '#f + (chi-frobs490 + (append + inits1543 + exprs1547) + r1549 + mr1548 + m?1534))))))))) + (map (lambda (x1550) + (make-frob471 + (wrap438 x1550 w1541) + '#f)) + body1539))) + (make-wrap319 + (wrap-marks320 w1535) + (cons + ribcage1540 + (wrap-subst321 w1535))))) + (make-ribcage360 '() '() '())))) + (chi-internal499 (lambda (ribcage1443 source-exp1442 + body1441 r1440 mr1439 m?1438) + (letrec ((return1444 (lambda (r1533 mr1532 + exprs1531 + ids1530 + vars1529 + vals1528 + inits1527) + (begin + (check-defined-ids480 + source-exp1442 + ids1530) + (values r1533 + mr1532 exprs1531 + ids1530 vars1529 + vals1528 + inits1527))))) + ((letrec ((parse1445 (lambda (body1453 + r1452 mr1451 + ids1450 + vars1449 + vals1448 + inits1447 + meta-seen?1446) + (if (null? + body1453) + (return1444 + r1452 mr1451 + body1453 + ids1450 + vars1449 + vals1448 + inits1447) + ((lambda (fr1454) + ((lambda (e1455) + ((lambda (meta?1456) + ((lambda () + (call-with-values + (lambda () + (syntax-type441 + e1455 + r1452 + '(()) + '#f + ribcage1443)) + (lambda (type1461 + value1460 + e1459 + w1458 + ae1457) + ((lambda (t1462) + (if (memv + t1462 + '(define-form)) + (call-with-values + (lambda () + (parse-define505 + e1459 + w1458 + ae1457)) + (lambda (id1465 + rhs1464 + w1463) + ((lambda (id1467 + label1466) + (if meta?1456 + ((lambda (sym1468) + (begin + (extend-ribcage!405 + ribcage1443 + id1467 + label1466) + ((lambda (mr1469) + (begin + (define-top-level-value-hook135 + sym1468 + (top-level-eval-hook133 + (chi493 + rhs1464 + mr1469 + mr1469 + w1463 + '#t))) + (parse1445 + (cdr body1453) + r1452 + mr1469 + (cons + id1467 + ids1450) + vars1449 + vals1448 + inits1447 + '#f))) + (extend-env299 + label1466 + (cons + 'meta-variable + sym1468) + mr1451)))) + (generate-id147 + ((lambda (x1470) + ((lambda (e1471) + (if (annotation?132 + e1471) + (annotation-expression + e1471) + e1471)) + (if (syntax-object?64 + x1470) + (syntax-object-expression65 + x1470) + x1470))) + id1467))) + ((lambda (var1472) + (begin + (extend-ribcage!405 + ribcage1443 + id1467 + label1466) + (parse1445 + (cdr body1453) + (extend-env299 + label1466 + (cons + 'lexical + var1472) + r1452) + mr1451 + (cons + id1467 + ids1450) + (cons + var1472 + vars1449) + (cons + (make-frob471 + (wrap438 + rhs1464 + w1463) + meta?1456) + vals1448) + inits1447 + '#f))) + (gen-var518 + id1467)))) + (wrap438 + id1465 + w1463) + (gen-label357)))) + (if (memv + t1462 + '(define-syntax-form)) + (call-with-values + (lambda () + (parse-define-syntax506 + e1459 + w1458 + ae1457)) + (lambda (id1475 + rhs1474 + w1473) + ((lambda (id1478 + label1477 + exp1476) + (begin + (extend-ribcage!405 + ribcage1443 + id1478 + label1477) + ((lambda (b1479) + (parse1445 + (cdr body1453) + (extend-env299 + label1477 + b1479 + r1452) + (extend-env299 + label1477 + b1479 + mr1451) + (cons + id1478 + ids1450) + vars1449 + vals1448 + inits1447 + '#f)) + (defer-or-eval-transformer307 + local-eval-hook134 + exp1476)))) + (wrap438 + id1475 + w1473) + (gen-label357) + (chi493 + rhs1474 + mr1451 + mr1451 + w1473 + '#t)))) + (if (memv + t1462 + '($module-form)) + ((lambda (*ribcage1480) + ((lambda (*w1481) + ((lambda () + (call-with-values + (lambda () + (parse-module503 + e1459 + w1458 + ae1457 + *w1481)) + (lambda (orig1485 + id1484 + exports1483 + forms1482) + (call-with-values + (lambda () + (chi-internal499 + *ribcage1480 + orig1485 + (map (lambda (d1499) + (make-frob471 + d1499 + meta?1456)) + forms1482) + r1452 + mr1451 + m?1438)) + (lambda (r1492 + mr1491 + *body1490 + *ids1489 + *vars1488 + *vals1487 + *inits1486) + (begin + (check-module-exports479 + source-exp1442 + (flatten-exports445 + exports1483) + *ids1489) + ((lambda (iface1497 + vars1496 + vals1495 + inits1494 + label1493) + (begin + (extend-ribcage!405 + ribcage1443 + id1484 + label1493) + ((lambda (b1498) + (parse1445 + (cdr body1453) + (extend-env299 + label1493 + b1498 + r1492) + (extend-env299 + label1493 + b1498 + mr1491) + (cons + id1484 + ids1450) + vars1496 + vals1495 + inits1494 + '#f)) + (cons + '$module + iface1497)))) + (make-resolved-interface455 + id1484 + exports1483 + '#f) + (append + *vars1488 + vars1449) + (append + *vals1487 + vals1448) + (append + inits1447 + *inits1486 + *body1490) + (gen-label357)))))))))) + (make-wrap319 + (wrap-marks320 + w1458) + (cons + *ribcage1480 + (wrap-subst321 + w1458))))) + (make-ribcage360 + '() + '() + '())) + (if (memv + t1462 + '($import-form)) + (call-with-values + (lambda () + (parse-import504 + e1459 + w1458 + ae1457)) + (lambda (orig1502 + only?1501 + mid1500) + ((lambda (mlabel1503) + ((lambda (binding1504) + ((lambda (t1505) + (if (memv + t1505 + '($module)) + ((lambda (iface1506) + ((lambda (import-iface1507) + ((lambda () + (begin + (if only?1501 + (extend-ribcage-barrier!407 + ribcage1443 + mid1500) + (void)) + (do-import!502 + import-iface1507 + ribcage1443) + (parse1445 + (cdr body1453) + r1452 + mr1451 + (cons + import-iface1507 + ids1450) + vars1449 + vals1448 + inits1447 + '#f))))) + (make-import-interface374 + iface1506 + (import-mark-delta500 + mid1500 + iface1506)))) + (binding-value286 + binding1504)) + (if (memv + t1505 + '(displaced-lexical)) + (displaced-lexical-error303 + mid1500) + (syntax-error + mid1500 + '"unknown module")))) + (binding-type285 + binding1504))) + (lookup305 + mlabel1503 + r1452))) + (id-var-name429 + mid1500 + '(()))))) + (if (memv + t1462 + '(alias-form)) + (call-with-values + (lambda () + (parse-alias509 + e1459 + w1458 + ae1457)) + (lambda (new-id1509 + old-id1508) + ((lambda (new-id1510) + (begin + (extend-ribcage!405 + ribcage1443 + new-id1510 + (id-var-name-loc428 + old-id1508 + w1458)) + (parse1445 + (cdr body1453) + r1452 + mr1451 + (cons + new-id1510 + ids1450) + vars1449 + vals1448 + inits1447 + '#f))) + (wrap438 + new-id1509 + w1458)))) + (if (memv + t1462 + '(begin-form)) + (parse1445 + ((letrec ((f1511 (lambda (forms1512) + (if (null? + forms1512) + (cdr body1453) + (cons + (make-frob471 + (wrap438 + (car forms1512) + w1458) + meta?1456) + (f1511 + (cdr forms1512))))))) + f1511) + (parse-begin510 + e1459 + w1458 + ae1457 + '#t)) + r1452 + mr1451 + ids1450 + vars1449 + vals1448 + inits1447 + '#f) + (if (memv + t1462 + '(eval-when-form)) + (call-with-values + (lambda () + (parse-eval-when508 + e1459 + w1458 + ae1457)) + (lambda (when-list1514 + forms1513) + (parse1445 + (if (memq + 'eval + when-list1514) + ((letrec ((f1515 (lambda (forms1516) + (if (null? + forms1516) + (cdr body1453) + (cons + (make-frob471 + (wrap438 + (car forms1516) + w1458) + meta?1456) + (f1515 + (cdr forms1516))))))) + f1515) + forms1513) + (cdr body1453)) + r1452 + mr1451 + ids1450 + vars1449 + vals1448 + inits1447 + '#f))) + (if (memv + t1462 + '(meta-form)) + (parse1445 + (cons + (make-frob471 + (wrap438 + (parse-meta507 + e1459 + w1458 + ae1457) + w1458) + '#t) + (cdr body1453)) + r1452 + mr1451 + ids1450 + vars1449 + vals1448 + inits1447 + '#t) + (if (memv + t1462 + '(local-syntax-form)) + (call-with-values + (lambda () + (chi-local-syntax512 + value1460 + e1459 + r1452 + mr1451 + w1458 + ae1457)) + (lambda (forms1521 + r1520 + mr1519 + w1518 + ae1517) + (parse1445 + ((letrec ((f1522 (lambda (forms1523) + (if (null? + forms1523) + (cdr body1453) + (cons + (make-frob471 + (wrap438 + (car forms1523) + w1518) + meta?1456) + (f1522 + (cdr forms1523))))))) + f1522) + forms1521) + r1520 + mr1519 + ids1450 + vars1449 + vals1448 + inits1447 + '#f))) + (begin + (if meta-seen?1446 + (syntax-error + (source-wrap439 + e1459 + w1458 + ae1457) + '"invalid meta definition") + (void)) + ((letrec ((f1524 (lambda (body1525) + (if ((lambda (t1526) + (if t1526 + t1526 + (not (frob-meta?474 + (car body1525))))) + (null? + body1525)) + (return1444 + r1452 + mr1451 + body1525 + ids1450 + vars1449 + vals1448 + inits1447) + (begin + (top-level-eval-hook133 + (chi-meta-frob491 + (car body1525) + mr1451)) + (f1524 + (cdr body1525))))))) + f1524) + (cons + (make-frob471 + (source-wrap439 + e1459 + w1458 + ae1457) + meta?1456) + (cdr body1453)))))))))))))) + type1461)))))) + (frob-meta?474 + fr1454))) + (frob-e473 + fr1454))) + (car body1453)))))) + parse1445) body1441 r1440 mr1439 '() + '() '() '() '#f)))) + (import-mark-delta500 (lambda (mid1437 iface1436) + (diff-marks421 + (id-marks316 mid1437) + (interface-marks448 iface1436)))) + (lookup-import-label501 (lambda (id1434) + ((lambda (label1435) + (begin + (if (not label1435) + (syntax-error + id1434 + '"exported identifier not visible") + (void)) + label1435)) + (id-var-name-loc428 + id1434 + '(()))))) + (do-import!502 (lambda (import-iface1430 ribcage1429) + ((lambda (ie1431) + (if (<= (vector-length ie1431) '20) + ((lambda (new-marks1432) + (vfor-each483 + (lambda (id1433) + (import-extend-ribcage!406 + ribcage1429 + new-marks1432 + id1433 + (lookup-import-label501 + id1433))) + ie1431)) + (import-interface-new-marks377 + import-iface1430)) + (extend-ribcage-subst!409 + ribcage1429 + import-iface1430))) + (interface-exports449 + (import-interface-interface376 + import-iface1430))))) + (parse-module503 (lambda (e1405 w1404 ae1403 *w1402) + (letrec ((listify1406 (lambda (exports1423) + (if (null? + exports1423) + '() + (cons + ((lambda (tmp1424) + ((lambda (tmp1425) + (if tmp1425 + (apply + (lambda (ex1426) + (listify1406 + ex1426)) + tmp1425) + ((lambda (x1428) + (if (id?310 + x1428) + (wrap438 + x1428 + *w1402) + (syntax-error + (source-wrap439 + e1405 + w1404 + ae1403) + '"invalid exports list in"))) + tmp1424))) + ($syntax-dispatch + tmp1424 + 'each-any))) + (car exports1423)) + (listify1406 + (cdr exports1423))))))) + ((lambda (tmp1407) + ((lambda (tmp1408) + (if (if tmp1408 + (apply + (lambda (_1413 orig1412 + mid1411 ex1410 + form1409) + (id?310 mid1411)) + tmp1408) + '#f) + (apply + (lambda (_1418 orig1417 + mid1416 ex1415 + form1414) + (values + orig1417 + (wrap438 mid1416 w1404) + (listify1406 ex1415) + (map (lambda (x1420) + (wrap438 + x1420 + *w1402)) + form1414))) + tmp1408) + ((lambda (_1422) + (syntax-error + (source-wrap439 + e1405 + w1404 + ae1403))) + tmp1407))) + ($syntax-dispatch + tmp1407 + '(any any any each-any . + each-any)))) + e1405)))) + (parse-import504 (lambda (e1385 w1384 ae1383) + ((lambda (tmp1386) + ((lambda (tmp1387) + (if (if tmp1387 + (apply + (lambda (_1390 orig1389 + mid1388) + (id?310 mid1388)) + tmp1387) + '#f) + (apply + (lambda (_1393 orig1392 mid1391) + (values + orig1392 + '#t + (wrap438 mid1391 w1384))) + tmp1387) + ((lambda (tmp1394) + (if (if tmp1394 + (apply + (lambda (_1397 + orig1396 + mid1395) + (id?310 mid1395)) + tmp1394) + '#f) + (apply + (lambda (_1400 orig1399 + mid1398) + (values + orig1399 + '#f + (wrap438 + mid1398 + w1384))) + tmp1394) + ((lambda (_1401) + (syntax-error + (source-wrap439 + e1385 + w1384 + ae1383))) + tmp1386))) + ($syntax-dispatch + tmp1386 + '(any any #(atom #f) any))))) + ($syntax-dispatch + tmp1386 + '(any any #(atom #t) any)))) + e1385))) + (parse-define505 (lambda (e1356 w1355 ae1354) + ((lambda (tmp1357) + ((lambda (tmp1358) + (if (if tmp1358 + (apply + (lambda (_1361 name1360 + val1359) + (id?310 name1360)) + tmp1358) + '#f) + (apply + (lambda (_1364 name1363 val1362) + (values + name1363 + val1362 + w1355)) + tmp1358) + ((lambda (tmp1365) + (if (if tmp1365 + (apply + (lambda (_1370 + name1369 + args1368 + e11367 + e21366) + (if (id?310 + name1369) + (valid-bound-ids?434 + (lambda-var-list519 + args1368)) + '#f)) + tmp1365) + '#f) + (apply + (lambda (_1375 name1374 + args1373 e11372 + e21371) + (values + (wrap438 + name1374 + w1355) + (cons + '#(syntax-object lambda ((top) #(ribcage #(_ name args e1 e2) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(e w ae) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (wrap438 + (cons + args1373 + (cons + e11372 + e21371)) + w1355)) + '(()))) + tmp1365) + ((lambda (tmp1377) + (if (if tmp1377 + (apply + (lambda (_1379 + name1378) + (id?310 + name1378)) + tmp1377) + '#f) + (apply + (lambda (_1381 + name1380) + (values + (wrap438 + name1380 + w1355) + '#(syntax-object (void) ((top) #(ribcage #(_ name) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(e w ae) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + '(()))) + tmp1377) + ((lambda (_1382) + (syntax-error + (source-wrap439 + e1356 + w1355 + ae1354))) + tmp1357))) + ($syntax-dispatch + tmp1357 + '(any any))))) + ($syntax-dispatch + tmp1357 + '(any (any . any) + any + . + each-any))))) + ($syntax-dispatch + tmp1357 + '(any any any)))) + e1356))) + (parse-define-syntax506 (lambda (e1332 w1331 ae1330) + ((lambda (tmp1333) + ((lambda (tmp1334) + (if (if tmp1334 + (apply + (lambda (_1339 + name1338 + id1337 + e11336 + e21335) + (if (id?310 + name1338) + (id?310 id1337) + '#f)) + tmp1334) + '#f) + (apply + (lambda (_1344 name1343 + id1342 e11341 + e21340) + (values + (wrap438 + name1343 + w1331) + (cons + '#(syntax-object lambda ((top) #(ribcage #(_ name id e1 e2) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(e w ae) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + (wrap438 + (list id1342) + w1331) + (wrap438 + (cons + e11341 + e21340) + w1331))) + '(()))) + tmp1334) + ((lambda (tmp1346) + (if (if tmp1346 + (apply + (lambda (_1349 + name1348 + val1347) + (id?310 + name1348)) + tmp1346) + '#f) + (apply + (lambda (_1352 + name1351 + val1350) + (values + name1351 + val1350 + w1331)) + tmp1346) + ((lambda (_1353) + (syntax-error + (source-wrap439 + e1332 + w1331 + ae1330))) + tmp1333))) + ($syntax-dispatch + tmp1333 + '(any any any))))) + ($syntax-dispatch + tmp1333 + '(any (any any) + any + . + each-any)))) + e1332))) + (parse-meta507 (lambda (e1324 w1323 ae1322) + ((lambda (tmp1325) + ((lambda (tmp1326) + (if tmp1326 + (apply + (lambda (_1328 form1327) form1327) + tmp1326) + ((lambda (_1329) + (syntax-error + (source-wrap439 + e1324 + w1323 + ae1322))) + tmp1325))) + ($syntax-dispatch tmp1325 '(any . any)))) + e1324))) + (parse-eval-when508 (lambda (e1312 w1311 ae1310) + ((lambda (tmp1313) + ((lambda (tmp1314) + (if tmp1314 + (apply + (lambda (_1318 x1317 e11316 + e21315) + (values + (chi-when-list440 + x1317 + w1311) + (cons e11316 e21315))) + tmp1314) + ((lambda (_1321) + (syntax-error + (source-wrap439 + e1312 + w1311 + ae1310))) + tmp1313))) + ($syntax-dispatch + tmp1313 + '(any each-any any . each-any)))) + e1312))) + (parse-alias509 (lambda (e1300 w1299 ae1298) + ((lambda (tmp1301) + ((lambda (tmp1302) + (if (if tmp1302 + (apply + (lambda (_1305 new-id1304 + old-id1303) + (if (id?310 new-id1304) + (id?310 old-id1303) + '#f)) + tmp1302) + '#f) + (apply + (lambda (_1308 new-id1307 + old-id1306) + (values new-id1307 old-id1306)) + tmp1302) + ((lambda (_1309) + (syntax-error + (source-wrap439 + e1300 + w1299 + ae1298))) + tmp1301))) + ($syntax-dispatch + tmp1301 + '(any any any)))) + e1300))) + (parse-begin510 (lambda (e1287 w1286 ae1285 empty-okay?1284) + ((lambda (tmp1288) + ((lambda (tmp1289) + (if (if tmp1289 + (apply + (lambda (_1290) + empty-okay?1284) + tmp1289) + '#f) + (apply + (lambda (_1291) '()) + tmp1289) + ((lambda (tmp1292) + (if tmp1292 + (apply + (lambda (_1295 e11294 + e21293) + (cons e11294 e21293)) + tmp1292) + ((lambda (_1297) + (syntax-error + (source-wrap439 + e1287 + w1286 + ae1285))) + tmp1288))) + ($syntax-dispatch + tmp1288 + '(any any . each-any))))) + ($syntax-dispatch tmp1288 '(any)))) + e1287))) + (chi-lambda-clause511 (lambda (e1261 c1260 r1259 mr1258 + w1257 m?1256) + ((lambda (tmp1262) + ((lambda (tmp1263) + (if tmp1263 + (apply + (lambda (id1266 e11265 + e21264) + ((lambda (ids1267) + (if (not (valid-bound-ids?434 + ids1267)) + (syntax-error + e1261 + '"invalid parameter list in") + ((lambda (labels1269 + new-vars1268) + (values + new-vars1268 + (chi-body498 + (cons + e11265 + e21264) + e1261 + (extend-var-env*301 + labels1269 + new-vars1268 + r1259) + mr1258 + (make-binding-wrap412 + ids1267 + labels1269 + w1257) + m?1256))) + (gen-labels359 + ids1267) + (map gen-var518 + ids1267)))) + id1266)) + tmp1263) + ((lambda (tmp1272) + (if tmp1272 + (apply + (lambda (ids1275 + e11274 + e21273) + ((lambda (old-ids1276) + (if (not (valid-bound-ids?434 + old-ids1276)) + (syntax-error + e1261 + '"invalid parameter list in") + ((lambda (labels1278 + new-vars1277) + (values + ((letrec ((f1280 (lambda (ls11282 + ls21281) + (if (null? + ls11282) + ls21281 + (f1280 + (cdr ls11282) + (cons + (car ls11282) + ls21281)))))) + f1280) + (cdr new-vars1277) + (car new-vars1277)) + (chi-body498 + (cons + e11274 + e21273) + e1261 + (extend-var-env*301 + labels1278 + new-vars1277 + r1259) + mr1258 + (make-binding-wrap412 + old-ids1276 + labels1278 + w1257) + m?1256))) + (gen-labels359 + old-ids1276) + (map gen-var518 + old-ids1276)))) + (lambda-var-list519 + ids1275))) + tmp1272) + ((lambda (_1283) + (syntax-error + e1261)) + tmp1262))) + ($syntax-dispatch + tmp1262 + '(any any . each-any))))) + ($syntax-dispatch + tmp1262 + '(each-any any . each-any)))) + c1260))) + (chi-local-syntax512 (lambda (rec?1237 e1236 r1235 mr1234 + w1233 ae1232) + ((lambda (tmp1238) + ((lambda (tmp1239) + (if tmp1239 + (apply + (lambda (_1244 id1243 + val1242 e11241 + e21240) + ((lambda (ids1245) + (if (not (valid-bound-ids?434 + ids1245)) + (invalid-ids-error436 + (map (lambda (x1246) + (wrap438 + x1246 + w1233)) + ids1245) + (source-wrap439 + e1236 + w1233 + ae1232) + '"keyword") + ((lambda (labels1247) + ((lambda (new-w1248) + ((lambda (b*1249) + (values + (cons + e11241 + e21240) + (extend-env*300 + labels1247 + b*1249 + r1235) + (extend-env*300 + labels1247 + b*1249 + mr1234) + new-w1248 + ae1232)) + ((lambda (w1251) + (map (lambda (x1253) + (defer-or-eval-transformer307 + local-eval-hook134 + (chi493 + x1253 + mr1234 + mr1234 + w1251 + '#t))) + val1242)) + (if rec?1237 + new-w1248 + w1233)))) + (make-binding-wrap412 + ids1245 + labels1247 + w1233))) + (gen-labels359 + ids1245)))) + id1243)) + tmp1239) + ((lambda (_1255) + (syntax-error + (source-wrap439 + e1236 + w1233 + ae1232))) + tmp1238))) + ($syntax-dispatch + tmp1238 + '(any #(each (any any)) + any + . + each-any)))) + e1236))) + (chi-void513 (lambda () (list 'void))) + (ellipsis?514 (lambda (x1231) + (if (nonsymbol-id?309 x1231) + (literal-id=?431 + x1231 + '#(syntax-object ... ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + '#f))) + (strip-annotation515 (lambda (x1230) + (if (pair? x1230) + (cons + (strip-annotation515 (car x1230)) + (strip-annotation515 (cdr x1230))) + (if (annotation?132 x1230) + (annotation-stripped x1230) + x1230)))) + (strip*516 (lambda (x1223 w1222 fn1221) + (if (memq 'top (wrap-marks320 w1222)) + (fn1221 x1223) + ((letrec ((f1224 (lambda (x1225) + (if (syntax-object?64 + x1225) + (strip*516 + (syntax-object-expression65 + x1225) + (syntax-object-wrap66 + x1225) + fn1221) + (if (pair? x1225) + ((lambda (a1227 + d1226) + (if (if (eq? a1227 + (car x1225)) + (eq? d1226 + (cdr x1225)) + '#f) + x1225 + (cons + a1227 + d1226))) + (f1224 + (car x1225)) + (f1224 + (cdr x1225))) + (if (vector? x1225) + ((lambda (old1228) + ((lambda (new1229) + (if (andmap + eq? + old1228 + new1229) + x1225 + (list->vector + new1229))) + (map f1224 + old1228))) + (vector->list + x1225)) + x1225)))))) + f1224) + x1223)))) + (strip517 (lambda (x1218 w1217) + (strip*516 + x1218 + w1217 + (lambda (x1219) + (if ((lambda (t1220) + (if t1220 + t1220 + (if (pair? x1219) + (annotation?132 (car x1219)) + '#f))) + (annotation?132 x1219)) + (strip-annotation515 x1219) + x1219))))) + (gen-var518 (lambda (id1215) + ((lambda (id1216) + (if (annotation?132 id1216) + (gensym) + (gensym))) + (if (syntax-object?64 id1215) + (syntax-object-expression65 id1215) + id1215)))) + (lambda-var-list519 (lambda (vars1210) + ((letrec ((lvl1211 (lambda (vars1214 + ls1213 w1212) + (if (pair? vars1214) + (lvl1211 + (cdr vars1214) + (cons + (wrap438 + (car vars1214) + w1212) + ls1213) + w1212) + (if (id?310 + vars1214) + (cons + (wrap438 + vars1214 + w1212) + ls1213) + (if (null? + vars1214) + ls1213 + (if (syntax-object?64 + vars1214) + (lvl1211 + (syntax-object-expression65 + vars1214) + ls1213 + (join-wraps417 + w1212 + (syntax-object-wrap66 + vars1214))) + (if (annotation?132 + vars1214) + (lvl1211 + (annotation-expression + vars1214) + ls1213 + w1212) + (cons + vars1214 + ls1213))))))))) + lvl1211) + vars1210 + '() + '(()))))) + (begin + (set! $sc-put-cte + (lambda (id1191 b1190 top-token1189) + (letrec ((sc-put-module1192 (lambda (exports1208 token1207 + new-marks1206) + (vfor-each483 + (lambda (id1209) + (store-import-binding411 + id1209 + token1207 + new-marks1206)) + exports1208))) + (put-cte1193 (lambda (id1204 binding1203 token1202) + ((lambda (sym1205) + (begin + (store-import-binding411 + id1204 + token1202 + '()) + (put-global-definition-hook143 + sym1205 + (if (if (eq? (binding-type285 + binding1203) + 'global) + (eq? (binding-value286 + binding1203) + sym1205) + '#f) + '#f + binding1203)))) + (if (symbol? id1204) + id1204 + (id-var-name429 id1204 '(()))))))) + ((lambda (binding1194) + ((lambda (t1195) + (if (memv t1195 '($module)) + (begin + ((lambda (iface1196) + (sc-put-module1192 + (interface-exports449 iface1196) + (interface-token450 iface1196) + '())) + (binding-value286 binding1194)) + (put-cte1193 id1191 binding1194 top-token1189)) + (if (memv t1195 '(do-alias)) + (store-import-binding411 + id1191 + top-token1189 + '()) + (if (memv t1195 '(do-import)) + ((lambda (token1197) + ((lambda (b1198) + ((lambda (t1199) + (if (memv t1199 '($module)) + ((lambda (iface1200) + ((lambda (exports1201) + ((lambda () + (begin + (if (not (eq? (interface-token450 + iface1200) + token1197)) + (syntax-error + id1191 + '"import mismatch for module") + (void)) + (sc-put-module1192 + (interface-exports449 + iface1200) + top-token1189 + (import-mark-delta500 + id1191 + iface1200)))))) + (interface-exports449 + iface1200))) + (binding-value286 b1198)) + (syntax-error + id1191 + '"unknown module"))) + (binding-type285 b1198))) + (lookup305 + (id-var-name429 id1191 '(())) + '()))) + (binding-value286 b1190)) + (put-cte1193 + id1191 + binding1194 + top-token1189))))) + (binding-type285 binding1194))) + (make-transformer-binding306 b1190))))) + (global-extend308 'local-syntax 'letrec-syntax '#t) + (global-extend308 'local-syntax 'let-syntax '#f) + (global-extend308 + 'core + 'fluid-let-syntax + (lambda (e1163 r1162 mr1161 w1160 ae1159 m?1158) + ((lambda (tmp1164) + ((lambda (tmp1165) + (if (if tmp1165 + (apply + (lambda (_1170 var1169 val1168 e11167 e21166) + (valid-bound-ids?434 var1169)) + tmp1165) + '#f) + (apply + (lambda (_1176 var1175 val1174 e11173 e21172) + ((lambda (names1177) + (begin + (for-each + (lambda (id1184 n1183) + ((lambda (t1185) + (if (memv t1185 '(displaced-lexical)) + (displaced-lexical-error303 + (wrap438 id1184 w1160)) + (void))) + (binding-type285 + (lookup305 n1183 r1162)))) + var1175 + names1177) + ((lambda (b*1178) + (chi-body498 (cons e11173 e21172) + (source-wrap439 e1163 w1160 ae1159) + (extend-env*300 names1177 b*1178 r1162) + (extend-env*300 names1177 b*1178 mr1161) + w1160 m?1158)) + (map (lambda (x1181) + (defer-or-eval-transformer307 + local-eval-hook134 + (chi493 x1181 mr1161 mr1161 w1160 + '#t))) + val1174)))) + (map (lambda (x1187) + (id-var-name429 x1187 w1160)) + var1175))) + tmp1165) + ((lambda (_1188) + (syntax-error (source-wrap439 e1163 w1160 ae1159))) + tmp1164))) + ($syntax-dispatch + tmp1164 + '(any #(each (any any)) any . each-any)))) + e1163))) + (global-extend308 + 'core + 'quote + (lambda (e1152 r1151 mr1150 w1149 ae1148 m?1147) + ((lambda (tmp1153) + ((lambda (tmp1154) + (if tmp1154 + (apply + (lambda (_1156 e1155) + (list 'quote (strip517 e1155 w1149))) + tmp1154) + ((lambda (_1157) + (syntax-error (source-wrap439 e1152 w1149 ae1148))) + tmp1153))) + ($syntax-dispatch tmp1153 '(any any)))) + e1152))) + (global-extend308 + 'core + 'syntax + ((lambda () + (letrec ((gen-syntax1031 (lambda (src1092 e1091 r1090 + maps1089 ellipsis?1088 + vec?1087) + (if (id?310 e1091) + ((lambda (label1093) + ((lambda (b1094) + (if (eq? (binding-type285 + b1094) + 'syntax) + (call-with-values + (lambda () + ((lambda (var.lev1097) + (gen-ref1032 + src1092 + (car var.lev1097) + (cdr var.lev1097) + maps1089)) + (binding-value286 + b1094))) + (lambda (var1096 + maps1095) + (values + (list + 'ref + var1096) + maps1095))) + (if (ellipsis?1088 + e1091) + (syntax-error + src1092 + '"misplaced ellipsis in syntax form") + (values + (list + 'quote + e1091) + maps1089)))) + (lookup305 + label1093 + r1090))) + (id-var-name429 e1091 '(()))) + ((lambda (tmp1098) + ((lambda (tmp1099) + (if (if tmp1099 + (apply + (lambda (dots1101 + e1100) + (ellipsis?1088 + dots1101)) + tmp1099) + '#f) + (apply + (lambda (dots1103 + e1102) + (if vec?1087 + (syntax-error + src1092 + '"misplaced ellipsis in syntax template") + (gen-syntax1031 + src1092 + e1102 r1090 + maps1089 + (lambda (x1104) + '#f) + '#f))) + tmp1099) + ((lambda (tmp1105) + (if (if tmp1105 + (apply + (lambda (x1108 + dots1107 + y1106) + (ellipsis?1088 + dots1107)) + tmp1105) + '#f) + (apply + (lambda (x1111 + dots1110 + y1109) + ((letrec ((f1112 (lambda (y1114 + k1113) + ((lambda (tmp1115) + ((lambda (tmp1116) + (if (if tmp1116 + (apply + (lambda (dots1118 + y1117) + (ellipsis?1088 + dots1118)) + tmp1116) + '#f) + (apply + (lambda (dots1120 + y1119) + (f1112 + y1119 + (lambda (maps1121) + (call-with-values + (lambda () + (k1113 + (cons + '() + maps1121))) + (lambda (x1123 + maps1122) + (if (null? + (car maps1122)) + (syntax-error + src1092 + '"extra ellipsis in syntax form") + (values + (gen-mappend1034 + x1123 + (car maps1122)) + (cdr maps1122)))))))) + tmp1116) + ((lambda (_1124) + (call-with-values + (lambda () + (gen-syntax1031 + src1092 + y1114 + r1090 + maps1089 + ellipsis?1088 + vec?1087)) + (lambda (y1126 + maps1125) + (call-with-values + (lambda () + (k1113 + maps1125)) + (lambda (x1128 + maps1127) + (values + (gen-append1033 + x1128 + y1126) + maps1127)))))) + tmp1115))) + ($syntax-dispatch + tmp1115 + '(any . + any)))) + y1114)))) + f1112) + y1109 + (lambda (maps1129) + (call-with-values + (lambda () + (gen-syntax1031 + src1092 + x1111 + r1090 + (cons + '() + maps1129) + ellipsis?1088 + '#f)) + (lambda (x1131 + maps1130) + (if (null? + (car maps1130)) + (syntax-error + src1092 + '"extra ellipsis in syntax form") + (values + (gen-map1035 + x1131 + (car maps1130)) + (cdr maps1130)))))))) + tmp1105) + ((lambda (tmp1132) + (if tmp1132 + (apply + (lambda (x1134 + y1133) + (call-with-values + (lambda () + (gen-syntax1031 + src1092 + x1134 + r1090 + maps1089 + ellipsis?1088 + '#f)) + (lambda (xnew1136 + maps1135) + (call-with-values + (lambda () + (gen-syntax1031 + src1092 + y1133 + r1090 + maps1135 + ellipsis?1088 + vec?1087)) + (lambda (ynew1138 + maps1137) + (values + (gen-cons1036 + e1091 + x1134 + y1133 + xnew1136 + ynew1138) + maps1137)))))) + tmp1132) + ((lambda (tmp1139) + (if tmp1139 + (apply + (lambda (x11141 + x21140) + ((lambda (ls1142) + (call-with-values + (lambda () + (gen-syntax1031 + src1092 + ls1142 + r1090 + maps1089 + ellipsis?1088 + '#t)) + (lambda (lsnew1144 + maps1143) + (values + (gen-vector1037 + e1091 + ls1142 + lsnew1144) + maps1143)))) + (cons + x11141 + x21140))) + tmp1139) + ((lambda (_1146) + (values + (list + 'quote + e1091) + maps1089)) + tmp1098))) + ($syntax-dispatch + tmp1098 + '#(vector + (any . + each-any)))))) + ($syntax-dispatch + tmp1098 + '(any . + any))))) + ($syntax-dispatch + tmp1098 + '(any any + . + any))))) + ($syntax-dispatch + tmp1098 + '(any any)))) + e1091)))) + (gen-ref1032 (lambda (src1082 var1081 level1080 + maps1079) + (if (= level1080 '0) + (values var1081 maps1079) + (if (null? maps1079) + (syntax-error + src1082 + '"missing ellipsis in syntax form") + (call-with-values + (lambda () + (gen-ref1032 + src1082 + var1081 + (- level1080 '1) + (cdr maps1079))) + (lambda (outer-var1084 + outer-maps1083) + ((lambda (b1085) + (if b1085 + (values + (cdr b1085) + maps1079) + ((lambda (inner-var1086) + (values + inner-var1086 + (cons + (cons + (cons + outer-var1084 + inner-var1086) + (car maps1079)) + outer-maps1083))) + (gen-var518 + 'tmp)))) + (assq + outer-var1084 + (car maps1079))))))))) + (gen-append1033 (lambda (x1078 y1077) + (if (equal? y1077 ''()) + x1078 + (list 'append x1078 y1077)))) + (gen-mappend1034 (lambda (e1076 map-env1075) + (list + 'apply + '(primitive append) + (gen-map1035 + e1076 + map-env1075)))) + (gen-map1035 (lambda (e1068 map-env1067) + ((lambda (formals1070 actuals1069) + (if (eq? (car e1068) 'ref) + (car actuals1069) + (if (andmap + (lambda (x1071) + (if (eq? (car x1071) + 'ref) + (memq + (cadr x1071) + formals1070) + '#f)) + (cdr e1068)) + (cons + 'map + (cons + (list + 'primitive + (car e1068)) + (map ((lambda (r1072) + (lambda (x1073) + (cdr (assq + (cadr + x1073) + r1072)))) + (map cons + formals1070 + actuals1069)) + (cdr e1068)))) + (cons + 'map + (cons + (list + 'lambda + formals1070 + e1068) + actuals1069))))) + (map cdr map-env1067) + (map (lambda (x1074) + (list 'ref (car x1074))) + map-env1067)))) + (gen-cons1036 (lambda (e1063 x1062 y1061 xnew1060 + ynew1059) + ((lambda (t1064) + (if (memv t1064 '(quote)) + (if (eq? (car xnew1060) 'quote) + ((lambda (xnew1066 + ynew1065) + (if (if (eq? xnew1066 + x1062) + (eq? ynew1065 + y1061) + '#f) + (list 'quote e1063) + (list + 'quote + (cons + xnew1066 + ynew1065)))) + (cadr xnew1060) + (cadr ynew1059)) + (if (eq? (cadr ynew1059) + '()) + (list 'list xnew1060) + (list + 'cons + xnew1060 + ynew1059))) + (if (memv t1064 '(list)) + (cons + 'list + (cons + xnew1060 + (cdr ynew1059))) + (list + 'cons + xnew1060 + ynew1059)))) + (car ynew1059)))) + (gen-vector1037 (lambda (e1058 ls1057 lsnew1056) + (if (eq? (car lsnew1056) 'quote) + (if (eq? (cadr lsnew1056) + ls1057) + (list 'quote e1058) + (list + 'quote + (list->vector + (cadr lsnew1056)))) + (if (eq? (car lsnew1056) 'list) + (cons + 'vector + (cdr lsnew1056)) + (list + 'list->vector + lsnew1056))))) + (regen1038 (lambda (x1053) + ((lambda (t1054) + (if (memv t1054 '(ref)) + (cadr x1053) + (if (memv t1054 '(primitive)) + (cadr x1053) + (if (memv t1054 '(quote)) + (list 'quote (cadr x1053)) + (if (memv t1054 '(lambda)) + (list + 'lambda + (cadr x1053) + (regen1038 + (caddr x1053))) + (if (memv + t1054 + '(map)) + ((lambda (ls1055) + (cons + (if (= (length + ls1055) + '2) + 'map + 'map) + ls1055)) + (map regen1038 + (cdr x1053))) + (cons + (car x1053) + (map regen1038 + (cdr x1053))))))))) + (car x1053))))) + (lambda (e1044 r1043 mr1042 w1041 ae1040 m?1039) + ((lambda (e1045) + ((lambda (tmp1046) + ((lambda (tmp1047) + (if tmp1047 + (apply + (lambda (_1049 x1048) + (call-with-values + (lambda () + (gen-syntax1031 e1045 x1048 r1043 '() + ellipsis?514 '#f)) + (lambda (e1051 maps1050) + (regen1038 e1051)))) + tmp1047) + ((lambda (_1052) (syntax-error e1045)) + tmp1046))) + ($syntax-dispatch tmp1046 '(any any)))) + e1045)) + (source-wrap439 e1044 w1041 ae1040))))))) + (global-extend308 + 'core + 'lambda + (lambda (e1024 r1023 mr1022 w1021 ae1020 m?1019) + ((lambda (tmp1025) + ((lambda (tmp1026) + (if tmp1026 + (apply + (lambda (_1028 c1027) + (call-with-values + (lambda () + (chi-lambda-clause511 + (source-wrap439 e1024 w1021 ae1020) c1027 + r1023 mr1022 w1021 m?1019)) + (lambda (vars1030 body1029) + (list 'lambda vars1030 body1029)))) + tmp1026) + (syntax-error tmp1025))) + ($syntax-dispatch tmp1025 '(any . any)))) + e1024))) + (global-extend308 + 'core + 'letrec + (lambda (e1000 r999 mr998 w997 ae996 m?995) + ((lambda (tmp1001) + ((lambda (tmp1002) + (if tmp1002 + (apply + (lambda (_1007 id1006 val1005 e11004 e21003) + ((lambda (ids1008) + (if (not (valid-bound-ids?434 ids1008)) + (invalid-ids-error436 + (map (lambda (x1009) + (wrap438 x1009 w997)) + ids1008) + (source-wrap439 e1000 w997 ae996) + '"bound variable") + ((lambda (labels1011 new-vars1010) + ((lambda (w1013 r1012) + (build-letrec240 + ae996 + new-vars1010 + (map (lambda (x1016) + (chi493 x1016 r1012 mr998 + w1013 m?995)) + val1005) + (chi-body498 (cons e11004 e21003) + (source-wrap439 + e1000 + w1013 + ae996) + r1012 mr998 w1013 m?995))) + (make-binding-wrap412 + ids1008 + labels1011 + w997) + (extend-var-env*301 + labels1011 + new-vars1010 + r999))) + (gen-labels359 ids1008) + (map gen-var518 ids1008)))) + id1006)) + tmp1002) + ((lambda (_1018) + (syntax-error (source-wrap439 e1000 w997 ae996))) + tmp1001))) + ($syntax-dispatch + tmp1001 + '(any #(each (any any)) any . each-any)))) + e1000))) + (global-extend308 + 'core + 'if + (lambda (e983 r982 mr981 w980 ae979 m?978) + ((lambda (tmp984) + ((lambda (tmp985) + (if tmp985 + (apply + (lambda (_988 test987 then986) + (list + 'if + (chi493 test987 r982 mr981 w980 m?978) + (chi493 then986 r982 mr981 w980 m?978) + (chi-void513))) + tmp985) + ((lambda (tmp989) + (if tmp989 + (apply + (lambda (_993 test992 then991 else990) + (list + 'if + (chi493 test992 r982 mr981 w980 m?978) + (chi493 then991 r982 mr981 w980 m?978) + (chi493 else990 r982 mr981 w980 m?978))) + tmp989) + ((lambda (_994) + (syntax-error + (source-wrap439 e983 w980 ae979))) + tmp984))) + ($syntax-dispatch tmp984 '(any any any any))))) + ($syntax-dispatch tmp984 '(any any any)))) + e983))) + (global-extend308 'set! 'set! '()) + (global-extend308 'alias 'alias '()) + (global-extend308 'begin 'begin '()) + (global-extend308 '$module-key '$module '()) + (global-extend308 '$import '$import '()) + (global-extend308 'define 'define '()) + (global-extend308 'define-syntax 'define-syntax '()) + (global-extend308 'eval-when 'eval-when '()) + (global-extend308 'meta 'meta '()) + (global-extend308 + 'core + 'syntax-case + ((lambda () + (letrec ((convert-pattern850 (lambda (pattern927 keys926) + (letrec ((cvt*928 (lambda (p*973 + n972 + ids971) + (if (null? + p*973) + (values + '() + ids971) + (call-with-values + (lambda () + (cvt*928 + (cdr p*973) + n972 + ids971)) + (lambda (y975 + ids974) + (call-with-values + (lambda () + (cvt929 + (car p*973) + n972 + ids974)) + (lambda (x977 + ids976) + (values + (cons + x977 + y975) + ids976)))))))) + (cvt929 (lambda (p932 + n931 + ids930) + (if (id?310 + p932) + (if (bound-id-member?437 + p932 + keys926) + (values + (vector + 'free-id + p932) + ids930) + (values + 'any + (cons + (cons + p932 + n931) + ids930))) + ((lambda (tmp933) + ((lambda (tmp934) + (if (if tmp934 + (apply + (lambda (x936 + dots935) + (ellipsis?514 + dots935)) + tmp934) + '#f) + (apply + (lambda (x938 + dots937) + (call-with-values + (lambda () + (cvt929 + x938 + (+ n931 + '1) + ids930)) + (lambda (p940 + ids939) + (values + (if (eq? p940 + 'any) + 'each-any + (vector + 'each + p940)) + ids939)))) + tmp934) + ((lambda (tmp941) + (if (if tmp941 + (apply + (lambda (x945 + dots944 + y943 + z942) + (ellipsis?514 + dots944)) + tmp941) + '#f) + (apply + (lambda (x949 + dots948 + y947 + z946) + (call-with-values + (lambda () + (cvt929 + z946 + n931 + ids930)) + (lambda (z951 + ids950) + (call-with-values + (lambda () + (cvt*928 + y947 + n931 + ids950)) + (lambda (y953 + ids952) + (call-with-values + (lambda () + (cvt929 + x949 + (+ n931 + '1) + ids952)) + (lambda (x955 + ids954) + (values + (vector + 'each+ + x955 + (reverse + y953) + z951) + ids954)))))))) + tmp941) + ((lambda (tmp957) + (if tmp957 + (apply + (lambda (x959 + y958) + (call-with-values + (lambda () + (cvt929 + y958 + n931 + ids930)) + (lambda (y961 + ids960) + (call-with-values + (lambda () + (cvt929 + x959 + n931 + ids960)) + (lambda (x963 + ids962) + (values + (cons + x963 + y961) + ids962)))))) + tmp957) + ((lambda (tmp964) + (if tmp964 + (apply + (lambda () + (values + '() + ids930)) + tmp964) + ((lambda (tmp965) + (if tmp965 + (apply + (lambda (x966) + (call-with-values + (lambda () + (cvt929 + x966 + n931 + ids930)) + (lambda (p968 + ids967) + (values + (vector + 'vector + p968) + ids967)))) + tmp965) + ((lambda (x970) + (values + (vector + 'atom + (strip517 + p932 + '(()))) + ids930)) + tmp933))) + ($syntax-dispatch + tmp933 + '#(vector + each-any))))) + ($syntax-dispatch + tmp933 + '())))) + ($syntax-dispatch + tmp933 + '(any . + any))))) + ($syntax-dispatch + tmp933 + '(any any + . + #(each+ + any + () + any)))))) + ($syntax-dispatch + tmp933 + '(any any)))) + p932))))) + (cvt929 pattern927 '0 '())))) + (build-dispatch-call851 (lambda (pvars919 exp918 y917 + r916 mr915 m?914) + ((lambda (ids921 levels920) + ((lambda (labels923 + new-vars922) + (list + 'apply + (list + 'lambda + new-vars922 + (chi493 exp918 + (extend-env*300 + labels923 + (map (lambda (var925 + level924) + (cons + 'syntax + (cons + var925 + level924))) + new-vars922 + (map cdr + pvars919)) + r916) + mr915 + (make-binding-wrap412 + ids921 + labels923 + '(())) + m?914)) + y917)) + (gen-labels359 ids921) + (map gen-var518 + ids921))) + (map car pvars919) + (map cdr pvars919)))) + (gen-clause852 (lambda (x897 keys896 clauses895 r894 + mr893 m?892 pat891 fender890 + exp889) + (call-with-values + (lambda () + (convert-pattern850 + pat891 + keys896)) + (lambda (p899 pvars898) + (if (not (distinct-bound-ids?435 + (map car pvars898))) + (invalid-ids-error436 + (map car pvars898) + pat891 + '"pattern variable") + (if (not (andmap + (lambda (x900) + (not (ellipsis?514 + (car x900)))) + pvars898)) + (syntax-error + pat891 + '"misplaced ellipsis in syntax-case pattern") + ((lambda (y901) + (list + (list + 'lambda + (list y901) + (list + 'if + ((lambda (tmp911) + ((lambda (tmp912) + (if tmp912 + (apply + (lambda () + y901) + tmp912) + ((lambda (_913) + (list + 'if + y901 + (build-dispatch-call851 + pvars898 + fender890 + y901 + r894 + mr893 + m?892) + (list + 'quote + '#f))) + tmp911))) + ($syntax-dispatch + tmp911 + '#(atom + #t)))) + fender890) + (build-dispatch-call851 + pvars898 + exp889 y901 + r894 mr893 + m?892) + (gen-syntax-case853 + x897 keys896 + clauses895 + r894 mr893 + m?892))) + (if (eq? p899 'any) + (list + 'list + x897) + (list + '$syntax-dispatch + x897 + (list + 'quote + p899))))) + (gen-var518 + 'tmp)))))))) + (gen-syntax-case853 (lambda (x877 keys876 clauses875 + r874 mr873 m?872) + (if (null? clauses875) + (list 'syntax-error x877) + ((lambda (tmp878) + ((lambda (tmp879) + (if tmp879 + (apply + (lambda (pat881 + exp880) + (if (if (id?310 + pat881) + (if (not (bound-id-member?437 + pat881 + keys876)) + (not (ellipsis?514 + pat881)) + '#f) + '#f) + ((lambda (label883 + var882) + (list + (list + 'lambda + (list + var882) + (chi493 + exp880 + (extend-env299 + label883 + (cons + 'syntax + (cons + var882 + '0)) + r874) + mr873 + (make-binding-wrap412 + (list + pat881) + (list + label883) + '(())) + m?872)) + x877)) + (gen-label357) + (gen-var518 + pat881)) + (gen-clause852 + x877 + keys876 + (cdr clauses875) + r874 + mr873 + m?872 + pat881 + '#t + exp880))) + tmp879) + ((lambda (tmp884) + (if tmp884 + (apply + (lambda (pat887 + fender886 + exp885) + (gen-clause852 + x877 + keys876 + (cdr clauses875) + r874 + mr873 + m?872 + pat887 + fender886 + exp885)) + tmp884) + ((lambda (_888) + (syntax-error + (car clauses875) + '"invalid syntax-case clause")) + tmp878))) + ($syntax-dispatch + tmp878 + '(any any + any))))) + ($syntax-dispatch + tmp878 + '(any any)))) + (car clauses875)))))) + (lambda (e859 r858 mr857 w856 ae855 m?854) + ((lambda (e860) + ((lambda (tmp861) + ((lambda (tmp862) + (if tmp862 + (apply + (lambda (_866 val865 key864 m863) + (if (andmap + (lambda (x868) + (if (id?310 x868) + (not (ellipsis?514 x868)) + '#f)) + key864) + ((lambda (x869) + (list + (list + 'lambda + (list x869) + (gen-syntax-case853 x869 key864 + m863 r858 mr857 m?854)) + (chi493 val865 r858 mr857 '(()) + m?854))) + (gen-var518 'tmp)) + (syntax-error + e860 + '"invalid literals list in"))) + tmp862) + (syntax-error tmp861))) + ($syntax-dispatch + tmp861 + '(any any each-any . each-any)))) + e860)) + (source-wrap439 e859 w856 ae855))))))) + (put-cte-hook141 + 'module + (lambda (x819) + (letrec ((proper-export?820 (lambda (e843) + ((lambda (tmp844) + ((lambda (tmp845) + (if tmp845 + (apply + (lambda (id847 e846) + (if (identifier? + id847) + (andmap + proper-export?820 + e846) + '#f)) + tmp845) + ((lambda (id849) + (identifier? id849)) + tmp844))) + ($syntax-dispatch + tmp844 + '(any . each-any)))) + e843)))) + ((lambda (tmp821) + ((lambda (orig822) + ((lambda (tmp823) + ((lambda (tmp824) + (if tmp824 + (apply + (lambda (_827 e826 d825) + (if (andmap proper-export?820 e826) + (list + '#(syntax-object begin ((top) #(ribcage #(_ e d) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object $module ((top) #(ribcage #(_ e d) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig822 + (cons + '#(syntax-object anon ((top) #(ribcage #(_ e d) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons e826 d825)))) + (cons + '#(syntax-object $import ((top) #(ribcage #(_ e d) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig822 + '#(syntax-object (#f anon) ((top) #(ribcage #(_ e d) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))))) + (syntax-error + x819 + '"invalid exports list in"))) + tmp824) + ((lambda (tmp831) + (if (if tmp831 + (apply + (lambda (_835 m834 e833 d832) + (identifier? m834)) + tmp831) + '#f) + (apply + (lambda (_839 m838 e837 d836) + (if (andmap proper-export?820 e837) + (cons + '#(syntax-object $module ((top) #(ribcage #(_ m e d) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage #(orig) #((top)) #("i")) #(ribcage (proper-export?) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig822 + (cons + m838 + (cons e837 d836)))) + (syntax-error + x819 + '"invalid exports list in"))) + tmp831) + (syntax-error tmp823))) + ($syntax-dispatch + tmp823 + '(any any each-any . each-any))))) + ($syntax-dispatch + tmp823 + '(any each-any . each-any)))) + x819)) + tmp821)) + x819)))) + ((lambda () + (letrec (($module-exports622 (lambda (m811 r810) + ((lambda (b812) + ((lambda (t813) + (if (memv t813 '($module)) + ((lambda (interface814) + ((lambda (new-marks815) + ((lambda () + (vmap482 + (lambda (x816) + ((lambda (id817) + (make-syntax-object63 + (syntax-object->datum + id817) + ((lambda (marks818) + (make-wrap319 + marks818 + (if (eq? (car marks818) + '#f) + (cons + 'shift + (wrap-subst321 + '((top)))) + (wrap-subst321 + '((top)))))) + (join-marks418 + new-marks815 + (wrap-marks320 + (syntax-object-wrap66 + id817)))))) + (if (pair? + x816) + (car x816) + x816))) + (interface-exports449 + interface814))))) + (import-mark-delta500 + m811 + interface814))) + (binding-value286 + b812)) + (if (memv + t813 + '(displaced-lexical)) + (displaced-lexical-error303 + m811) + (syntax-error + m811 + '"unknown module")))) + (binding-type285 b812))) + (r810 m811)))) + ($import-help623 (lambda (orig627 import-only?626) + (lambda (r628) + (letrec ((difference629 (lambda (ls1809 + ls2808) + (if (null? + ls1809) + ls1809 + (if (bound-id-member?437 + (car ls1809) + ls2808) + (difference629 + (cdr ls1809) + ls2808) + (cons + (car ls1809) + (difference629 + (cdr ls1809) + ls2808)))))) + (prefix-add630 (lambda (prefix-id805) + ((lambda (prefix806) + (lambda (id807) + (datum->syntax-object + id807 + (string->symbol + (string-append + prefix806 + (symbol->string + (syntax-object->datum + id807))))))) + (symbol->string + (syntax-object->datum + prefix-id805))))) + (prefix-drop631 (lambda (prefix-id799) + ((lambda (prefix800) + (lambda (id801) + ((lambda (s802) + ((lambda (np804 + ns803) + (begin + (if (not (if (>= ns803 + np804) + (string=? + (substring + s802 + '0 + np804) + prefix800) + '#f)) + (syntax-error + id801 + (string-append + '"missing expected prefix " + prefix800)) + (void)) + (datum->syntax-object + id801 + (string->symbol + (substring + s802 + np804 + ns803))))) + (string-length + prefix800) + (string-length + s802))) + (symbol->string + (syntax-object->datum + id801))))) + (symbol->string + (syntax-object->datum + prefix-id799))))) + (gen-mid632 (lambda (mid798) + (datum->syntax-object + mid798 + (gensym)))) + (modspec633 (lambda (m649 + exports?648) + ((lambda (tmp650) + ((lambda (tmp651) + (if tmp651 + (apply + (lambda (orig653 + import-only?652) + ((lambda (tmp654) + ((lambda (tmp655) + (if (if tmp655 + (apply + (lambda (m657 + id656) + (andmap + identifier? + id656)) + tmp655) + '#f) + (apply + (lambda (m660 + id659) + (call-with-values + (lambda () + (modspec633 + m660 + '#f)) + (lambda (mid663 + d662 + exports661) + ((lambda (tmp664) + ((lambda (tmp665) + (if tmp665 + (apply + (lambda (d667 + tmid666) + (values + mid663 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object $module ((top) #(ribcage #(d tmid) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + tmid666 + id659 + d667) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid666)) + (if exports?648 + id659 + '#f))) + tmp665) + (syntax-error + tmp664))) + ($syntax-dispatch + tmp664 + '(any any)))) + (list + d662 + (gen-mid632 + mid663)))))) + tmp655) + ((lambda (tmp670) + (if (if tmp670 + (apply + (lambda (m672 + id671) + (andmap + identifier? + id671)) + tmp670) + '#f) + (apply + (lambda (m675 + id674) + (call-with-values + (lambda () + (modspec633 + m675 + '#t)) + (lambda (mid678 + d677 + exports676) + ((lambda (tmp679) + ((lambda (tmp681) + (if tmp681 + (apply + (lambda (d684 + tmid683 + id682) + (values + mid678 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object $module ((top) #(ribcage #(d tmid id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + tmid683 + id682 + d684) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid683)) + (if exports?648 + id682 + '#f))) + tmp681) + (syntax-error + tmp679))) + ($syntax-dispatch + tmp679 + '(any any + each-any)))) + (list + d677 + (gen-mid632 + mid678) + (difference629 + exports676 + id674)))))) + tmp670) + ((lambda (tmp687) + (if (if tmp687 + (apply + (lambda (m689 + prefix-id688) + (identifier? + prefix-id688)) + tmp687) + '#f) + (apply + (lambda (m691 + prefix-id690) + (call-with-values + (lambda () + (modspec633 + m691 + '#t)) + (lambda (mid694 + d693 + exports692) + ((lambda (tmp695) + ((lambda (tmp696) + (if tmp696 + (apply + (lambda (d701 + tmid700 + old-id699 + tmp698 + id697) + (values + mid694 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid700 + (cons + (map list + id697 + tmp698) + (cons + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid700 + (cons + (map list + tmp698 + old-id699) + (cons + d701 + (map (lambda (tmp708 + tmp707) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp707 + tmp708)) + old-id699 + tmp698)))))) + (cons + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid700) + (map (lambda (tmp710 + tmp709) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp709 + tmp710)) + tmp698 + id697))))))) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid700)) + (if exports?648 + id697 + '#f))) + tmp696) + (syntax-error + tmp695))) + ($syntax-dispatch + tmp695 + '(any any + each-any + each-any + each-any)))) + (list + d693 + (gen-mid632 + mid694) + exports692 + (generate-temporaries + exports692) + (map (prefix-add630 + prefix-id690) + exports692)))))) + tmp687) + ((lambda (tmp711) + (if (if tmp711 + (apply + (lambda (m713 + prefix-id712) + (identifier? + prefix-id712)) + tmp711) + '#f) + (apply + (lambda (m715 + prefix-id714) + (call-with-values + (lambda () + (modspec633 + m715 + '#t)) + (lambda (mid718 + d717 + exports716) + ((lambda (tmp719) + ((lambda (tmp720) + (if tmp720 + (apply + (lambda (d725 + tmid724 + old-id723 + tmp722 + id721) + (values + mid718 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid724 + (cons + (map list + id721 + tmp722) + (cons + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid724 + (cons + (map list + tmp722 + old-id723) + (cons + d725 + (map (lambda (tmp732 + tmp731) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp731 + tmp732)) + old-id723 + tmp722)))))) + (cons + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid724) + (map (lambda (tmp734 + tmp733) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp733 + tmp734)) + tmp722 + id721))))))) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid old-id tmp id) #((top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m prefix-id) #((top) (top)) #("i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid724)) + (if exports?648 + id721 + '#f))) + tmp720) + (syntax-error + tmp719))) + ($syntax-dispatch + tmp719 + '(any any + each-any + each-any + each-any)))) + (list + d717 + (gen-mid632 + mid718) + exports716 + (generate-temporaries + exports716) + (map (prefix-drop631 + prefix-id714) + exports716)))))) + tmp711) + ((lambda (tmp735) + (if (if tmp735 + (apply + (lambda (m738 + new-id737 + old-id736) + (if (andmap + identifier? + new-id737) + (andmap + identifier? + old-id736) + '#f)) + tmp735) + '#f) + (apply + (lambda (m743 + new-id742 + old-id741) + (call-with-values + (lambda () + (modspec633 + m743 + '#t)) + (lambda (mid746 + d745 + exports744) + ((lambda (tmp747) + ((lambda (tmp750) + (if tmp750 + (apply + (lambda (d754 + tmid753 + tmp752 + other-id751) + (values + mid746 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid753 + (cons + (append + (map list + new-id742 + tmp752) + other-id751) + (cons + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid753 + (cons + (append + other-id751 + (map list + tmp752 + old-id741)) + (cons + d754 + (map (lambda (tmp764 + tmp763) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp763 + tmp764)) + old-id741 + tmp752)))))) + (cons + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid753) + (map (lambda (tmp766 + tmp765) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp765 + tmp766)) + tmp752 + new-id742))))))) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid tmp other-id) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid753)) + (if exports?648 + (append + new-id742 + other-id751) + '#f))) + tmp750) + (syntax-error + tmp747))) + ($syntax-dispatch + tmp747 + '(any any + each-any + each-any)))) + (list + d745 + (gen-mid632 + mid746) + (generate-temporaries + old-id741) + (difference629 + exports744 + old-id741)))))) + tmp735) + ((lambda (tmp767) + (if (if tmp767 + (apply + (lambda (m770 + new-id769 + old-id768) + (if (andmap + identifier? + new-id769) + (andmap + identifier? + old-id768) + '#f)) + tmp767) + '#f) + (apply + (lambda (m775 + new-id774 + old-id773) + (call-with-values + (lambda () + (modspec633 + m775 + '#t)) + (lambda (mid778 + d777 + exports776) + ((lambda (tmp779) + ((lambda (tmp780) + (if tmp780 + (apply + (lambda (d783 + tmid782 + other-id781) + (values + mid778 + (list + '#(syntax-object begin ((top) #(ribcage #(d tmid other-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object $module ((top) #(ribcage #(d tmid other-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + orig653 + (cons + tmid782 + (cons + (append + (map list + new-id774 + old-id773) + other-id781) + (cons + d783 + (map (lambda (tmp790 + tmp789) + (list + '#(syntax-object alias ((top) #(ribcage #(d tmid other-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp789 + tmp790)) + old-id773 + new-id774)))))) + (list + '#(syntax-object $import ((top) #(ribcage #(d tmid other-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(mid d exports) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(m new-id old-id) #((top) (top) (top)) #("i" "i" "i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + tmid782)) + (if exports?648 + (append + new-id774 + other-id781) + '#f))) + tmp780) + (syntax-error + tmp779))) + ($syntax-dispatch + tmp779 + '(any any + each-any)))) + (list + d777 + (gen-mid632 + mid778) + exports776))))) + tmp767) + ((lambda (tmp791) + (if (if tmp791 + (apply + (lambda (mid792) + (identifier? + mid792)) + tmp791) + '#f) + (apply + (lambda (mid793) + (values + mid793 + (list + '#(syntax-object $import ((top) #(ribcage #(mid) #((top)) #("i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + mid793) + (if exports?648 + ($module-exports622 + mid793 + r628) + '#f))) + tmp791) + ((lambda (tmp794) + (if (if tmp794 + (apply + (lambda (mid795) + (identifier? + mid795)) + tmp794) + '#f) + (apply + (lambda (mid796) + (values + mid796 + (list + '#(syntax-object $import ((top) #(ribcage #(mid) #((top)) #("i")) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + orig653 + import-only?652 + mid796) + (if exports?648 + ($module-exports622 + mid796 + r628) + '#f))) + tmp794) + ((lambda (_797) + (syntax-error + m649 + '"invalid module specifier")) + tmp654))) + ($syntax-dispatch + tmp654 + '(any))))) + (list + tmp654)))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object alias ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + . + #(each + (any any))))))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object rename ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + . + #(each + (any any))))))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object drop-prefix ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + any))))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object add-prefix ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + any))))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object except ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + . + each-any))))) + ($syntax-dispatch + tmp654 + '(#(free-id + #(syntax-object only ((top) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(m exports?) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any + . + each-any)))) + m649)) + tmp651) + (syntax-error + tmp650))) + ($syntax-dispatch + tmp650 + '(any any)))) + (list + orig627 + import-only?626)))) + (modspec*634 (lambda (m644) + (call-with-values + (lambda () + (modspec633 + m644 + '#f)) + (lambda (mid647 + d646 + exports645) + d646))))) + ((lambda (tmp635) + ((lambda (tmp636) + (if tmp636 + (apply + (lambda (_638 m637) + ((lambda (tmp639) + ((lambda (tmp641) + (if tmp641 + (apply + (lambda (d642) + (cons + '#(syntax-object begin ((top) #(ribcage #(d) #((top)) #("i")) #(ribcage #(_ m) #((top) (top)) #("i" "i")) #(ribcage (modspec* modspec gen-mid prefix-drop prefix-add difference) ((top) (top) (top) (top) (top) (top)) ("i" "i" "i" "i" "i" "i")) #(ribcage #(r) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(orig import-only?) #((top) (top)) #("i" "i")) #(ribcage ($import-help $module-exports) ((top) (top)) ("i" "i")) #(ribcage (lambda-var-list gen-var strip strip* strip-annotation ellipsis? chi-void chi-local-syntax chi-lambda-clause parse-begin parse-alias parse-eval-when parse-meta parse-define-syntax parse-define parse-import parse-module do-import! lookup-import-label import-mark-delta chi-internal chi-body chi-macro chi-set! chi-application chi-expr chi chi-sequence chi-meta-frob chi-frobs ct-eval/residualize3 ct-eval/residualize2 rt-eval/residualize initial-mode-set update-mode-set do-top-import vfor-each vmap chi-external check-defined-ids check-module-exports id-set-diff chi-top-module set-frob-meta?! set-frob-e! frob-meta? frob-e frob? make-frob create-module-binding set-module-binding-exported! set-module-binding-val! set-module-binding-imps! set-module-binding-label! set-module-binding-id! set-module-binding-type! module-binding-exported module-binding-val module-binding-imps module-binding-label module-binding-id module-binding-type module-binding? make-module-binding make-resolved-interface make-unresolved-interface set-interface-token! set-interface-exports! set-interface-marks! interface-token interface-exports interface-marks interface? make-interface flatten-exports chi-top chi-top-sequence chi-top* syntax-type chi-when-list source-wrap wrap bound-id-member? invalid-ids-error distinct-bound-ids? valid-bound-ids? bound-id=? help-bound-id=? literal-id=? free-id=? id-var-name id-var-name-loc id-var-name&marks id-var-name-loc&marks top-id-free-var-name top-id-bound-var-name anon diff-marks same-marks? join-subst join-marks join-wraps smart-append resolved-id-var-name id->resolved-id make-resolved-id make-binding-wrap store-import-binding lookup-import-binding-name extend-ribcage-subst! extend-ribcage-barrier-help! extend-ribcage-barrier! import-extend-ribcage! extend-ribcage! make-empty-ribcage barrier-marker new-mark anti-mark the-anti-mark set-env-wrap! set-env-top-ribcage! env-wrap env-top-ribcage env? make-env set-import-interface-new-marks! set-import-interface-interface! import-interface-new-marks import-interface-interface import-interface? make-import-interface set-top-ribcage-mutable?! set-top-ribcage-key! top-ribcage-mutable? top-ribcage-key top-ribcage? make-top-ribcage set-ribcage-labels! set-ribcage-marks! set-ribcage-symnames! ribcage-labels ribcage-marks ribcage-symnames ribcage? make-ribcage gen-labels label? gen-label set-indirect-label! get-indirect-label indirect-label? gen-indirect-label anon only-top-marked? top-marked? top-wrap empty-wrap wrap-subst wrap-marks make-wrap id-sym-name&marks id-subst id-marks id-sym-name id? nonsymbol-id? global-extend defer-or-eval-transformer make-transformer-binding lookup lookup* displaced-lexical-error displaced-lexical? extend-var-env* extend-env* extend-env null-env binding? set-binding-value! set-binding-type! binding-value binding-type make-binding sanitize-binding arg-check no-source unannotate self-evaluating? lexical-var? build-lexical-var build-top-module build-body build-letrec build-sequence build-data build-primref built-lambda? build-lambda build-revisit-only build-visit-only build-cte-install build-global-definition build-global-assignment build-global-reference build-lexical-assignment build-lexical-reference build-conditional build-application generate-id put-import-binding get-import-binding read-only-binding? put-global-definition-hook get-global-definition-hook put-cte-hook gensym-hook error-hook define-top-level-value-hook local-eval-hook top-level-eval-hook annotation? fx>= fx<= fx> fx< fx= fx- fx+ set-syntax-object-wrap! set-syntax-object-expression! syntax-object-wrap syntax-object-expression syntax-object? make-syntax-object noexpand let-values define-structure unless when) ((top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) ("m" top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (top) (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" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + d642)) + tmp641) + (syntax-error + tmp639))) + ($syntax-dispatch + tmp639 + 'each-any))) + (map modspec*634 + m637))) + tmp636) + (syntax-error tmp635))) + ($syntax-dispatch + tmp635 + '(any . each-any)))) + orig627)))))) + (begin + (put-cte-hook141 + 'import + (lambda (orig625) ($import-help623 orig625 '#f))) + (put-cte-hook141 + 'import-only + (lambda (orig624) ($import-help623 orig624 '#t))))))) + (set! sc-expand + ((lambda (ctem619 rtem618) + (lambda (x620) + ((lambda (env621) + (if (if (pair? x620) (equal? (car x620) noexpand62) '#f) + (cadr x620) + (chi-top*442 x620 '() (env-wrap383 env621) ctem619 + rtem618 '#f (env-top-ribcage382 env621)))) + (interaction-environment)))) + '(e) + '(e))) + (set! $make-environment + (lambda (token616 mutable?615) + ((lambda (top-ribcage617) + (make-env380 + top-ribcage617 + (make-wrap319 + (wrap-marks320 '((top))) + (cons top-ribcage617 (wrap-subst321 '((top))))))) + (make-top-ribcage368 token616 mutable?615)))) + (set! environment? (lambda (x614) (env?381 x614))) + (set! interaction-environment + ((lambda (e613) (lambda () e613)) + ($make-environment '*top* '#t))) + (set! identifier? (lambda (x612) (nonsymbol-id?309 x612))) + (set! datum->syntax-object + (lambda (id610 datum609) + (begin + ((lambda (x611) + (if (not (nonsymbol-id?309 x611)) + (error-hook136 + 'datum->syntax-object + '"invalid argument" + x611) + (void))) + id610) + (make-syntax-object63 + datum609 + (syntax-object-wrap66 id610))))) + (set! syntax->list + (lambda (orig-ls600) + ((letrec ((f601 (lambda (ls602) + ((lambda (tmp603) + ((lambda (tmp604) + (if tmp604 + (apply (lambda () '()) tmp604) + ((lambda (tmp605) + (if tmp605 + (apply + (lambda (x607 r606) + (cons x607 (f601 r606))) + tmp605) + ((lambda (_608) + (error 'syntax->list + '"invalid argument ~s" + orig-ls600)) + tmp603))) + ($syntax-dispatch + tmp603 + '(any . any))))) + ($syntax-dispatch tmp603 '()))) + ls602)))) + f601) + orig-ls600))) + (set! syntax->vector + (lambda (v594) + ((lambda (tmp595) + ((lambda (tmp596) + (if tmp596 + (apply + (lambda (x597) (apply vector (syntax->list x597))) + tmp596) + ((lambda (_599) + (error 'syntax->vector + '"invalid argument ~s" + v594)) + tmp595))) + ($syntax-dispatch tmp595 '#(vector each-any)))) + v594))) + (set! syntax-object->datum + (lambda (x593) (strip517 x593 '(())))) + (set! generate-temporaries + (lambda (ls590) + (begin + ((lambda (x592) + (if (not (list? x592)) + (error-hook136 + 'generate-temporaries + '"invalid argument" + x592) + (void))) + ls590) + (map (lambda (x591) (wrap438 (gensym) '((top)))) ls590)))) + (set! free-identifier=? + (lambda (x587 y586) + (begin + ((lambda (x589) + (if (not (nonsymbol-id?309 x589)) + (error-hook136 + 'free-identifier=? + '"invalid argument" + x589) + (void))) + x587) + ((lambda (x588) + (if (not (nonsymbol-id?309 x588)) + (error-hook136 + 'free-identifier=? + '"invalid argument" + x588) + (void))) + y586) + (free-id=?430 x587 y586)))) + (set! bound-identifier=? + (lambda (x583 y582) + (begin + ((lambda (x585) + (if (not (nonsymbol-id?309 x585)) + (error-hook136 + 'bound-identifier=? + '"invalid argument" + x585) + (void))) + x583) + ((lambda (x584) + (if (not (nonsymbol-id?309 x584)) + (error-hook136 + 'bound-identifier=? + '"invalid argument" + x584) + (void))) + y582) + (bound-id=?433 x583 y582)))) + (set! literal-identifier=? + (lambda (x579 y578) + (begin + ((lambda (x581) + (if (not (nonsymbol-id?309 x581)) + (error-hook136 + 'literal-identifier=? + '"invalid argument" + x581) + (void))) + x579) + ((lambda (x580) + (if (not (nonsymbol-id?309 x580)) + (error-hook136 + 'literal-identifier=? + '"invalid argument" + x580) + (void))) + y578) + (literal-id=?431 x579 y578)))) + (set! syntax-error + (lambda (object573 . messages574) + (begin + (for-each + (lambda (x576) + ((lambda (x577) + (if (not (string? x577)) + (error-hook136 + 'syntax-error + '"invalid argument" + x577) + (void))) + x576)) + messages574) + ((lambda (message575) + (error-hook136 '#f message575 (strip517 object573 '(())))) + (if (null? messages574) + '"invalid syntax" + (apply string-append messages574)))))) + ((lambda () + (letrec ((match-each520 (lambda (e570 p569 w568) + (if (annotation?132 e570) + (match-each520 + (annotation-expression e570) + p569 + w568) + (if (pair? e570) + ((lambda (first571) + (if first571 + ((lambda (rest572) + (if rest572 + (cons + first571 + rest572) + '#f)) + (match-each520 + (cdr e570) + p569 + w568)) + '#f)) + (match526 + (car e570) + p569 + w568 + '())) + (if (null? e570) + '() + (if (syntax-object?64 e570) + (match-each520 + (syntax-object-expression65 + e570) + p569 + (join-wraps417 + w568 + (syntax-object-wrap66 + e570))) + '#f)))))) + (match-each+521 (lambda (e560 x-pat559 y-pat558 z-pat557 + w556 r555) + ((letrec ((f561 (lambda (e563 w562) + (if (pair? e563) + (call-with-values + (lambda () + (f561 + (cdr e563) + w562)) + (lambda (xr*566 + y-pat565 + r564) + (if r564 + (if (null? + y-pat565) + ((lambda (xr567) + (if xr567 + (values + (cons + xr567 + xr*566) + y-pat565 + r564) + (values + '#f + '#f + '#f))) + (match526 + (car e563) + x-pat559 + w562 + '())) + (values + '() + (cdr y-pat565) + (match526 + (car e563) + (car y-pat565) + w562 + r564))) + (values + '#f + '#f + '#f)))) + (if (annotation?132 + e563) + (f561 + (annotation-expression + e563) + w562) + (if (syntax-object?64 + e563) + (f561 + (syntax-object-expression65 + e563) + (join-wraps417 + w562 + (syntax-object-wrap66 + e563))) + (values + '() + y-pat558 + (match526 + e563 + z-pat557 + w562 + r555)))))))) + f561) + e560 + w556))) + (match-each-any522 (lambda (e553 w552) + (if (annotation?132 e553) + (match-each-any522 + (annotation-expression e553) + w552) + (if (pair? e553) + ((lambda (l554) + (if l554 + (cons + (wrap438 + (car e553) + w552) + l554) + '#f)) + (match-each-any522 + (cdr e553) + w552)) + (if (null? e553) + '() + (if (syntax-object?64 + e553) + (match-each-any522 + (syntax-object-expression65 + e553) + (join-wraps417 + w552 + (syntax-object-wrap66 + e553))) + '#f)))))) + (match-empty523 (lambda (p550 r549) + (if (null? p550) + r549 + (if (eq? p550 'any) + (cons '() r549) + (if (pair? p550) + (match-empty523 + (car p550) + (match-empty523 + (cdr p550) + r549)) + (if (eq? p550 'each-any) + (cons '() r549) + ((lambda (t551) + (if (memv + t551 + '(each)) + (match-empty523 + (vector-ref + p550 + '1) + r549) + (if (memv + t551 + '(each+)) + (match-empty523 + (vector-ref + p550 + '1) + (match-empty523 + (reverse + (vector-ref + p550 + '2)) + (match-empty523 + (vector-ref + p550 + '3) + r549))) + (if (memv + t551 + '(free-id + atom)) + r549 + (if (memv + t551 + '(vector)) + (match-empty523 + (vector-ref + p550 + '1) + r549) + (void)))))) + (vector-ref + p550 + '0)))))))) + (combine524 (lambda (r*548 r547) + (if (null? (car r*548)) + r547 + (cons + (map car r*548) + (combine524 + (map cdr r*548) + r547))))) + (match*525 (lambda (e540 p539 w538 r537) + (if (null? p539) + (if (null? e540) r537 '#f) + (if (pair? p539) + (if (pair? e540) + (match526 + (car e540) + (car p539) + w538 + (match526 + (cdr e540) + (cdr p539) + w538 + r537)) + '#f) + (if (eq? p539 'each-any) + ((lambda (l541) + (if l541 + (cons l541 r537) + '#f)) + (match-each-any522 + e540 + w538)) + ((lambda (t542) + (if (memv t542 '(each)) + (if (null? e540) + (match-empty523 + (vector-ref + p539 + '1) + r537) + ((lambda (r*543) + (if r*543 + (combine524 + r*543 + r537) + '#f)) + (match-each520 + e540 + (vector-ref + p539 + '1) + w538))) + (if (memv + t542 + '(free-id)) + (if (id?310 e540) + (if (literal-id=?431 + (wrap438 + e540 + w538) + (vector-ref + p539 + '1)) + r537 + '#f) + '#f) + (if (memv + t542 + '(each+)) + (call-with-values + (lambda () + (match-each+521 + e540 + (vector-ref + p539 + '1) + (vector-ref + p539 + '2) + (vector-ref + p539 + '3) + w538 + r537)) + (lambda (xr*546 + y-pat545 + r544) + (if r544 + (if (null? + y-pat545) + (if (null? + xr*546) + (match-empty523 + (vector-ref + p539 + '1) + r544) + (combine524 + xr*546 + r544)) + '#f) + '#f))) + (if (memv + t542 + '(atom)) + (if (equal? + (vector-ref + p539 + '1) + (strip517 + e540 + w538)) + r537 + '#f) + (if (memv + t542 + '(vector)) + (if (vector? + e540) + (match526 + (vector->list + e540) + (vector-ref + p539 + '1) + w538 + r537) + '#f) + (void))))))) + (vector-ref p539 '0))))))) + (match526 (lambda (e534 p533 w532 r531) + (if (not r531) + '#f + (if (eq? p533 'any) + (cons (wrap438 e534 w532) r531) + (if (syntax-object?64 e534) + (match*525 + ((lambda (e535) + (if (annotation?132 e535) + (annotation-expression + e535) + e535)) + (syntax-object-expression65 + e534)) + p533 + (join-wraps417 + w532 + (syntax-object-wrap66 e534)) + r531) + (match*525 + ((lambda (e536) + (if (annotation?132 e536) + (annotation-expression + e536) + e536)) + e534) + p533 + w532 + r531))))))) + (set! $syntax-dispatch + (lambda (e528 p527) + (if (eq? p527 'any) + (list e528) + (if (syntax-object?64 e528) + (match*525 + ((lambda (e529) + (if (annotation?132 e529) + (annotation-expression e529) + e529)) + (syntax-object-expression65 e528)) + p527 + (syntax-object-wrap66 e528) + '()) + (match*525 + ((lambda (e530) + (if (annotation?132 e530) + (annotation-expression e530) + e530)) + e528) + p527 + '(()) + '())))))))))))) + +) + +($sc-put-cte + '#(syntax-object with-syntax ((top) #(ribcage #(with-syntax) #((top)) #(with-syntax)))) + (lambda (x2524) + ((lambda (tmp2525) + ((lambda (tmp2526) + (if tmp2526 + (apply + (lambda (_2529 e12528 e22527) + (cons + '#(syntax-object begin ((top) #(ribcage #(_ e1 e2) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons e12528 e22527))) + tmp2526) + ((lambda (tmp2531) + (if tmp2531 + (apply + (lambda (_2536 out2535 in2534 e12533 e22532) + (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")) #(top-ribcage *top* #t))) + in2534 + '() + (list + out2535 + (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")) #(top-ribcage *top* #t))) + (cons e12533 e22532))))) + tmp2531) + ((lambda (tmp2538) + (if tmp2538 + (apply + (lambda (_2543 out2542 in2541 e12540 e22539) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + in2541) + '() + (list + out2542 + (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")) #(top-ribcage *top* #t))) + (cons e12540 e22539))))) + tmp2538) + (syntax-error tmp2525))) + ($syntax-dispatch + tmp2525 + '(any #(each (any any)) any . each-any))))) + ($syntax-dispatch + tmp2525 + '(any ((any any)) any . each-any))))) + ($syntax-dispatch tmp2525 '(any () any . each-any)))) + x2524)) + '*top*) +($sc-put-cte + '#(syntax-object with-implicit ((top) #(ribcage #(with-implicit) #((top)) #(with-implicit)))) + (lambda (x2547) + ((lambda (tmp2548) + ((lambda (tmp2549) + (if (if tmp2549 + (apply + (lambda (dummy2554 tid2553 id2552 e12551 e22550) + (andmap identifier? (cons tid2553 id2552))) + tmp2549) + '#f) + (apply + (lambda (dummy2560 tid2559 id2558 e12557 e22556) + (list + '#(syntax-object begin ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object unless ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object identifier? ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + tid2559)) + (cons + '#(syntax-object syntax-error ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (cons + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + tid2559) + '#(syntax-object ("non-identifier with-implicit template") ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t)))))) + (cons + '#(syntax-object with-syntax ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (cons + (map (lambda (tmp2561) + (list + tmp2561 + (list + '#(syntax-object datum->syntax-object ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + tid2559) + (list + '#(syntax-object quote ((top) #(ribcage #(dummy tid id e1 e2) #(("m" top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + tmp2561)))) + id2558) + (cons e12557 e22556))))) + tmp2549) + (syntax-error tmp2548))) + ($syntax-dispatch + tmp2548 + '(any (any . each-any) any . each-any)))) + x2547)) + '*top*) +($sc-put-cte + '#(syntax-object datum ((top) #(ribcage #(datum) #((top)) #(datum)))) + (lambda (x2563) + ((lambda (tmp2564) + ((lambda (tmp2565) + (if tmp2565 + (apply + (lambda (dummy2567 x2566) + (list + '#(syntax-object syntax-object->datum ((top) #(ribcage #(dummy x) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy x) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + x2566))) + tmp2565) + (syntax-error tmp2564))) + ($syntax-dispatch tmp2564 '(any any)))) + x2563)) + '*top*) +($sc-put-cte + '#(syntax-object syntax-rules ((top) #(ribcage #(syntax-rules) #((top)) #(syntax-rules)))) + (lambda (x2568) + (letrec ((clause2569 (lambda (y2585) + ((lambda (tmp2586) + ((lambda (tmp2587) + (if tmp2587 + (apply + (lambda (keyword2590 pattern2589 + template2588) + (list + (cons + '#(syntax-object dummy ((top) #(ribcage #(keyword pattern template) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(y) #((top)) #("i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + pattern2589) + (list + '#(syntax-object syntax ((top) #(ribcage #(keyword pattern template) #((top) (top) (top)) #("i" "i" "i")) #(ribcage () () ()) #(ribcage #(y) #((top)) #("i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + template2588))) + tmp2587) + ((lambda (tmp2591) + (if tmp2591 + (apply + (lambda (keyword2595 + pattern2594 + fender2593 + template2592) + (list + (cons + '#(syntax-object dummy ((top) #(ribcage #(keyword pattern fender template) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(y) #((top)) #("i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + pattern2594) + fender2593 + (list + '#(syntax-object syntax ((top) #(ribcage #(keyword pattern fender template) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(y) #((top)) #("i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + template2592))) + tmp2591) + ((lambda (_2596) + (syntax-error x2568)) + tmp2586))) + ($syntax-dispatch + tmp2586 + '((any . any) any any))))) + ($syntax-dispatch + tmp2586 + '((any . any) any)))) + y2585)))) + ((lambda (tmp2570) + ((lambda (tmp2571) + (if (if tmp2571 + (apply + (lambda (_2574 k2573 cl2572) + (andmap identifier? k2573)) + tmp2571) + '#f) + (apply + (lambda (_2578 k2577 cl2576) + ((lambda (tmp2579) + ((lambda (tmp2581) + (if tmp2581 + (apply + (lambda (cl2582) + (list + '#(syntax-object lambda ((top) #(ribcage #(cl) #((top)) #("i")) #(ribcage #(_ k cl) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (x) ((top) #(ribcage #(cl) #((top)) #("i")) #(ribcage #(_ k cl) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object syntax-case ((top) #(ribcage #(cl) #((top)) #("i")) #(ribcage #(_ k cl) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object x ((top) #(ribcage #(cl) #((top)) #("i")) #(ribcage #(_ k cl) #((top) (top) (top)) #("i" "i" "i")) #(ribcage (clause) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons k2577 cl2582))))) + tmp2581) + (syntax-error tmp2579))) + ($syntax-dispatch tmp2579 'each-any))) + (map clause2569 cl2576))) + tmp2571) + (syntax-error tmp2570))) + ($syntax-dispatch tmp2570 '(any each-any . each-any)))) + x2568))) + '*top*) +($sc-put-cte + '#(syntax-object or ((top) #(ribcage #(or) #((top)) #(or)))) + (lambda (x2597) + ((lambda (tmp2598) + ((lambda (tmp2599) + (if tmp2599 + (apply + (lambda (_2600) + '#(syntax-object #f ((top) #(ribcage #(_) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + tmp2599) + ((lambda (tmp2601) + (if tmp2601 + (apply (lambda (_2603 e2602) e2602) tmp2601) + ((lambda (tmp2604) + (if tmp2604 + (apply + (lambda (_2608 e12607 e22606 e32605) + (list + '#(syntax-object let ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (list + (list + '#(syntax-object t ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + e12607)) + (list + '#(syntax-object if ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object t ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object t ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons + '#(syntax-object or ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons e22606 e32605))))) + tmp2604) + (syntax-error tmp2598))) + ($syntax-dispatch + tmp2598 + '(any any any . each-any))))) + ($syntax-dispatch tmp2598 '(any any))))) + ($syntax-dispatch tmp2598 '(any)))) + x2597)) + '*top*) +($sc-put-cte + '#(syntax-object and ((top) #(ribcage #(and) #((top)) #(and)))) + (lambda (x2610) + ((lambda (tmp2611) + ((lambda (tmp2612) + (if tmp2612 + (apply + (lambda (_2616 e12615 e22614 e32613) + (cons + '#(syntax-object if ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons + e12615 + (cons + (cons + '#(syntax-object and ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + (cons e22614 e32613)) + '#(syntax-object (#f) ((top) #(ribcage #(_ e1 e2 e3) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))))))) + tmp2612) + ((lambda (tmp2618) + (if tmp2618 + (apply (lambda (_2620 e2619) e2619) tmp2618) + ((lambda (tmp2621) + (if tmp2621 + (apply + (lambda (_2622) + '#(syntax-object #t ((top) #(ribcage #(_) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + tmp2621) + (syntax-error tmp2611))) + ($syntax-dispatch tmp2611 '(any))))) + ($syntax-dispatch tmp2611 '(any any))))) + ($syntax-dispatch tmp2611 '(any any any . each-any)))) + x2610)) + '*top*) +($sc-put-cte + '#(syntax-object let ((top) #(ribcage #(let) #((top)) #(let)))) + (lambda (x2623) + ((lambda (tmp2624) + ((lambda (tmp2625) + (if (if tmp2625 + (apply + (lambda (_2630 x2629 v2628 e12627 e22626) + (andmap identifier? x2629)) + tmp2625) + '#f) + (apply + (lambda (_2636 x2635 v2634 e12633 e22632) + (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")) #(top-ribcage *top* #t))) + (cons x2635 (cons e12633 e22632))) + v2634)) + tmp2625) + ((lambda (tmp2640) + (if (if tmp2640 + (apply + (lambda (_2646 f2645 x2644 v2643 e12642 e22641) + (andmap identifier? (cons f2645 x2644))) + tmp2640) + '#f) + (apply + (lambda (_2653 f2652 x2651 v2650 e12649 e22648) + (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")) #(top-ribcage *top* #t))) + (list + (list + f2652 + (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")) #(top-ribcage *top* #t))) + (cons x2651 (cons e12649 e22648))))) + f2652) + v2650)) + tmp2640) + (syntax-error tmp2624))) + ($syntax-dispatch + tmp2624 + '(any any #(each (any any)) any . each-any))))) + ($syntax-dispatch + tmp2624 + '(any #(each (any any)) any . each-any)))) + x2623)) + '*top*) +($sc-put-cte + '#(syntax-object let* ((top) #(ribcage #(let*) #((top)) #(let*)))) + (lambda (x2657) + ((lambda (tmp2658) + ((lambda (tmp2659) + (if (if tmp2659 + (apply + (lambda (let*2664 x2663 v2662 e12661 e22660) + (andmap identifier? x2663)) + tmp2659) + '#f) + (apply + (lambda (let*2670 x2669 v2668 e12667 e22666) + ((letrec ((f2671 (lambda (bindings2672) + (if (null? bindings2672) + (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")) #(top-ribcage *top* #t))) + (cons '() (cons e12667 e22666))) + ((lambda (tmp2674) + ((lambda (tmp2675) + (if tmp2675 + (apply + (lambda (body2677 + binding2676) + (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")) #(top-ribcage *top* #t))) + (list binding2676) + body2677)) + tmp2675) + (syntax-error tmp2674))) + ($syntax-dispatch + tmp2674 + '(any any)))) + (list + (f2671 (cdr bindings2672)) + (car bindings2672))))))) + f2671) + (map list x2669 v2668))) + tmp2659) + (syntax-error tmp2658))) + ($syntax-dispatch + tmp2658 + '(any #(each (any any)) any . each-any)))) + x2657)) + '*top*) +($sc-put-cte + '#(syntax-object cond ((top) #(ribcage #(cond) #((top)) #(cond)))) + (lambda (x2680) + ((lambda (tmp2681) + ((lambda (tmp2682) + (if tmp2682 + (apply + (lambda (_2685 m12684 m22683) + ((letrec ((f2686 (lambda (clause2688 clauses2687) + (if (null? clauses2687) + ((lambda (tmp2689) + ((lambda (tmp2690) + (if tmp2690 + (apply + (lambda (e12692 + e22691) + (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")) #(top-ribcage *top* #t))) + (cons + e12692 + e22691))) + tmp2690) + ((lambda (tmp2694) + (if tmp2694 + (apply + (lambda (e02695) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e02695)) + '#(syntax-object ((if t 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")) #(top-ribcage *top* #t)))))) + tmp2694) + ((lambda (tmp2696) + (if tmp2696 + (apply + (lambda (e02698 + e12697) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e02698)) + (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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + (cons + e12697 + '#(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")) #(top-ribcage *top* #t))))))) + tmp2696) + ((lambda (tmp2699) + (if tmp2699 + (apply + (lambda (e02702 + e12701 + e22700) + (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")) #(top-ribcage *top* #t))) + e02702 + (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")) #(top-ribcage *top* #t))) + (cons + e12701 + e22700)))) + tmp2699) + ((lambda (_2704) + (syntax-error + x2680)) + tmp2689))) + ($syntax-dispatch + tmp2689 + '(any any + . + each-any))))) + ($syntax-dispatch + tmp2689 + '(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")) #(top-ribcage *top* #t)))) + any))))) + ($syntax-dispatch + tmp2689 + '(any))))) + ($syntax-dispatch + tmp2689 + '(#(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")) #(top-ribcage *top* #t)))) + any + . + each-any)))) + clause2688) + ((lambda (tmp2705) + ((lambda (rest2706) + ((lambda (tmp2707) + ((lambda (tmp2708) + (if tmp2708 + (apply + (lambda (e02709) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e02709)) + (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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + rest2706))) + tmp2708) + ((lambda (tmp2710) + (if tmp2710 + (apply + (lambda (e02712 + e12711) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e02712)) + (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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + (cons + e12711 + '#(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")) #(top-ribcage *top* #t)))) + rest2706))) + tmp2710) + ((lambda (tmp2713) + (if tmp2713 + (apply + (lambda (e02716 + e12715 + e22714) + (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")) #(top-ribcage *top* #t))) + e02716 + (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")) #(top-ribcage *top* #t))) + (cons + e12715 + e22714)) + rest2706)) + tmp2713) + ((lambda (_2718) + (syntax-error + x2680)) + tmp2707))) + ($syntax-dispatch + tmp2707 + '(any any + . + each-any))))) + ($syntax-dispatch + tmp2707 + '(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")) #(top-ribcage *top* #t)))) + any))))) + ($syntax-dispatch + tmp2707 + '(any)))) + clause2688)) + tmp2705)) + (f2686 + (car clauses2687) + (cdr clauses2687))))))) + f2686) + m12684 + m22683)) + tmp2682) + (syntax-error tmp2681))) + ($syntax-dispatch tmp2681 '(any any . each-any)))) + x2680)) + '*top*) +($sc-put-cte + '#(syntax-object do ((top) #(ribcage #(do) #((top)) #(do)))) + (lambda (orig-x2720) + ((lambda (tmp2721) + ((lambda (tmp2722) + (if tmp2722 + (apply + (lambda (_2729 var2728 init2727 step2726 e02725 e12724 + c2723) + ((lambda (tmp2730) + ((lambda (tmp2740) + (if tmp2740 + (apply + (lambda (step2741) + ((lambda (tmp2742) + ((lambda (tmp2744) + (if tmp2744 + (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")) #(top-ribcage *top* #t))) + '#(syntax-object do ((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")) #(top-ribcage *top* #t))) + (map list var2728 init2727) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e02725) + (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")) #(top-ribcage *top* #t))) + (append + c2723 + (list + (cons + '#(syntax-object do ((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")) #(top-ribcage *top* #t))) + step2741))))))) + tmp2744) + ((lambda (tmp2749) + (if tmp2749 + (apply + (lambda (e12751 e22750) + (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")) #(top-ribcage *top* #t))) + '#(syntax-object do ((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")) #(top-ribcage *top* #t))) + (map list + var2728 + init2727) + (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")) #(top-ribcage *top* #t))) + e02725 + (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")) #(top-ribcage *top* #t))) + (cons + e12751 + e22750)) + (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")) #(top-ribcage *top* #t))) + (append + c2723 + (list + (cons + '#(syntax-object do ((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")) #(top-ribcage *top* #t))) + step2741))))))) + tmp2749) + (syntax-error tmp2742))) + ($syntax-dispatch + tmp2742 + '(any . each-any))))) + ($syntax-dispatch tmp2742 '()))) + e12724)) + tmp2740) + (syntax-error tmp2730))) + ($syntax-dispatch tmp2730 'each-any))) + (map (lambda (v2734 s2733) + ((lambda (tmp2735) + ((lambda (tmp2736) + (if tmp2736 + (apply (lambda () v2734) tmp2736) + ((lambda (tmp2737) + (if tmp2737 + (apply + (lambda (e2738) e2738) + tmp2737) + ((lambda (_2739) + (syntax-error orig-x2720)) + tmp2735))) + ($syntax-dispatch tmp2735 '(any))))) + ($syntax-dispatch tmp2735 '()))) + s2733)) + var2728 + step2726))) + tmp2722) + (syntax-error tmp2721))) + ($syntax-dispatch + tmp2721 + '(any #(each (any any . any)) + (any . each-any) + . + each-any)))) + orig-x2720)) + '*top*) +($sc-put-cte + '#(syntax-object quasiquote ((top) #(ribcage #(quasiquote) #((top)) #(quasiquote)))) + (letrec ((isquote?2766 (lambda (x2895) + (if (identifier? x2895) + (free-identifier=? + x2895 + '#(syntax-object quote ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + '#f))) + (islist?2765 (lambda (x2894) + (if (identifier? x2894) + (free-identifier=? + x2894 + '#(syntax-object list ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + '#f))) + (iscons?2764 (lambda (x2893) + (if (identifier? x2893) + (free-identifier=? + x2893 + '#(syntax-object cons ((top) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + '#f))) + (quote-nil?2763 (lambda (x2888) + ((lambda (tmp2889) + ((lambda (tmp2890) + (if tmp2890 + (apply + (lambda (quote?2891) + (isquote?2766 quote?2891)) + tmp2890) + ((lambda (_2892) '#f) tmp2889))) + ($syntax-dispatch tmp2889 '(any ())))) + x2888))) + (quasilist*2762 (lambda (x2885 y2884) + ((letrec ((f2886 (lambda (x2887) + (if (null? x2887) + y2884 + (quasicons2761 + (car x2887) + (f2886 + (cdr x2887))))))) + f2886) + x2885))) + (quasicons2761 (lambda (x2860 y2859) + ((lambda (tmp2861) + ((lambda (tmp2862) + (if tmp2862 + (apply + (lambda (x2864 y2863) + ((lambda (tmp2865) + ((lambda (tmp2866) + (if (if tmp2866 + (apply + (lambda (quote?2868 + dy2867) + (isquote?2766 + quote?2868)) + tmp2866) + '#f) + (apply + (lambda (quote?2870 + dy2869) + ((lambda (tmp2871) + ((lambda (tmp2872) + (if (if tmp2872 + (apply + (lambda (quote?2874 + dx2873) + (isquote?2766 + quote?2874)) + tmp2872) + '#f) + (apply + (lambda (quote?2876 + dx2875) + (list + '#(syntax-object quote ((top) #(ribcage #(quote? dx) #((top) (top)) #("i" "i")) #(ribcage #(quote? dy) #((top) (top)) #("i" "i")) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + dx2875 + dy2869))) + tmp2872) + ((lambda (_2877) + (if (null? + dy2869) + (list + '#(syntax-object list ((top) #(ribcage #(_) #((top)) #("i")) #(ribcage #(quote? dy) #((top) (top)) #("i" "i")) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + x2864) + (list + '#(syntax-object cons ((top) #(ribcage #(_) #((top)) #("i")) #(ribcage #(quote? dy) #((top) (top)) #("i" "i")) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + x2864 + y2863))) + tmp2871))) + ($syntax-dispatch + tmp2871 + '(any any)))) + x2864)) + tmp2866) + ((lambda (tmp2878) + (if (if tmp2878 + (apply + (lambda (listp2880 + stuff2879) + (islist?2765 + listp2880)) + tmp2878) + '#f) + (apply + (lambda (listp2882 + stuff2881) + (cons + '#(syntax-object list ((top) #(ribcage #(listp stuff) #((top) (top)) #("i" "i")) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (cons + x2864 + stuff2881))) + tmp2878) + ((lambda (else2883) + (list + '#(syntax-object cons ((top) #(ribcage #(else) #((top)) #("i")) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + x2864 + y2863)) + tmp2865))) + ($syntax-dispatch + tmp2865 + '(any . any))))) + ($syntax-dispatch + tmp2865 + '(any any)))) + y2863)) + tmp2862) + (syntax-error tmp2861))) + ($syntax-dispatch tmp2861 '(any any)))) + (list x2860 y2859)))) + (quasiappend2760 (lambda (x2851 y2850) + ((lambda (ls2852) + (if (null? ls2852) + '#(syntax-object (quote ()) ((top) #(ribcage () () ()) #(ribcage #(ls) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (if (null? (cdr ls2852)) + (car ls2852) + ((lambda (tmp2853) + ((lambda (tmp2854) + (if tmp2854 + (apply + (lambda (p2855) + (cons + '#(syntax-object append ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(ls) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x y) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + p2855)) + tmp2854) + (syntax-error tmp2853))) + ($syntax-dispatch + tmp2853 + 'each-any))) + ls2852)))) + ((letrec ((f2857 (lambda (x2858) + (if (null? x2858) + (if (quote-nil?2763 + y2850) + '() + (list y2850)) + (if (quote-nil?2763 + (car x2858)) + (f2857 + (cdr x2858)) + (cons + (car x2858) + (f2857 + (cdr x2858)))))))) + f2857) + x2851)))) + (quasivector2759 (lambda (x2813) + ((lambda (tmp2814) + ((lambda (pat-x2815) + ((lambda (tmp2816) + ((lambda (tmp2817) + (if (if tmp2817 + (apply + (lambda (quote?2819 + x2818) + (isquote?2766 + quote?2819)) + tmp2817) + '#f) + (apply + (lambda (quote?2821 x2820) + (list + '#(syntax-object quote ((top) #(ribcage #(quote? x) #((top) (top)) #("i" "i")) #(ribcage #(pat-x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (list->vector x2820))) + tmp2817) + ((lambda (_2823) + ((letrec ((f2824 (lambda (x2826 + k2825) + ((lambda (tmp2827) + ((lambda (tmp2828) + (if (if tmp2828 + (apply + (lambda (quote?2830 + x2829) + (isquote?2766 + quote?2830)) + tmp2828) + '#f) + (apply + (lambda (quote?2832 + x2831) + (k2825 + (map (lambda (tmp2833) + (list + '#(syntax-object quote ((top) #(ribcage #(quote? x) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x k) #((top) (top)) #("i" "i")) #(ribcage #(f) #((top)) #("i")) #(ribcage #(_) #((top)) #("i")) #(ribcage #(pat-x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + tmp2833)) + x2831))) + tmp2828) + ((lambda (tmp2834) + (if (if tmp2834 + (apply + (lambda (listp2836 + x2835) + (islist?2765 + listp2836)) + tmp2834) + '#f) + (apply + (lambda (listp2838 + x2837) + (k2825 + x2837)) + tmp2834) + ((lambda (tmp2840) + (if (if tmp2840 + (apply + (lambda (cons?2843 + x2842 + y2841) + (iscons?2764 + cons?2843)) + tmp2840) + '#f) + (apply + (lambda (cons?2846 + x2845 + y2844) + (f2824 + y2844 + (lambda (ls2847) + (k2825 + (cons + x2845 + ls2847))))) + tmp2840) + ((lambda (else2848) + (list + '#(syntax-object list->vector ((top) #(ribcage #(else) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x k) #((top) (top)) #("i" "i")) #(ribcage #(f) #((top)) #("i")) #(ribcage #(_) #((top)) #("i")) #(ribcage #(pat-x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + pat-x2815)) + tmp2827))) + ($syntax-dispatch + tmp2827 + '(any any + any))))) + ($syntax-dispatch + tmp2827 + '(any . + each-any))))) + ($syntax-dispatch + tmp2827 + '(any each-any)))) + x2826)))) + f2824) + x2813 + (lambda (ls2849) + (cons + '#(syntax-object vector ((top) #(ribcage () () ()) #(ribcage #(ls) #((top)) #("i")) #(ribcage #(_) #((top)) #("i")) #(ribcage #(pat-x) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(x) #((top)) #("i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + ls2849)))) + tmp2816))) + ($syntax-dispatch + tmp2816 + '(any each-any)))) + pat-x2815)) + tmp2814)) + x2813))) + (vquasi2758 (lambda (p2797 lev2796) + ((lambda (tmp2798) + ((lambda (tmp2799) + (if tmp2799 + (apply + (lambda (p2801 q2800) + ((lambda (tmp2802) + ((lambda (tmp2803) + (if tmp2803 + (apply + (lambda (p2804) + (if (fx= lev2796 '0) + (quasilist*2762 + p2804 + (vquasi2758 + q2800 + lev2796)) + (quasicons2761 + (quasicons2761 + '#(syntax-object (quote unquote) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + p2804 + (- lev2796 + '1))) + (vquasi2758 + q2800 + lev2796)))) + tmp2803) + ((lambda (tmp2807) + (if tmp2807 + (apply + (lambda (p2808) + (if (fx= lev2796 + '0) + (quasiappend2760 + p2808 + (vquasi2758 + q2800 + lev2796)) + (quasicons2761 + (quasicons2761 + '#(syntax-object (quote unquote-splicing) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + p2808 + (- lev2796 + '1))) + (vquasi2758 + q2800 + lev2796)))) + tmp2807) + ((lambda (p2811) + (quasicons2761 + (quasi2757 + p2811 + lev2796) + (vquasi2758 + q2800 + lev2796))) + tmp2802))) + ($syntax-dispatch + tmp2802 + '(#(free-id + #(syntax-object unquote-splicing ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + . + each-any))))) + ($syntax-dispatch + tmp2802 + '(#(free-id + #(syntax-object unquote ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + . + each-any)))) + p2801)) + tmp2799) + ((lambda (tmp2812) + (if tmp2812 + (apply + (lambda () + '#(syntax-object (quote ()) ((top) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + tmp2812) + (syntax-error tmp2798))) + ($syntax-dispatch tmp2798 '())))) + ($syntax-dispatch tmp2798 '(any . any)))) + p2797))) + (quasi2757 (lambda (p2773 lev2772) + ((lambda (tmp2774) + ((lambda (tmp2775) + (if tmp2775 + (apply + (lambda (p2776) + (if (fx= lev2772 '0) + p2776 + (quasicons2761 + '#(syntax-object (quote unquote) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + (list p2776) + (- lev2772 '1))))) + tmp2775) + ((lambda (tmp2777) + (if tmp2777 + (apply + (lambda (p2779 q2778) + (if (fx= lev2772 '0) + (quasilist*2762 + p2779 + (quasi2757 + q2778 + lev2772)) + (quasicons2761 + (quasicons2761 + '#(syntax-object (quote unquote) ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + p2779 + (- lev2772 '1))) + (quasi2757 + q2778 + lev2772)))) + tmp2777) + ((lambda (tmp2782) + (if tmp2782 + (apply + (lambda (p2784 q2783) + (if (fx= lev2772 '0) + (quasiappend2760 + p2784 + (quasi2757 + q2783 + lev2772)) + (quasicons2761 + (quasicons2761 + '#(syntax-object (quote unquote-splicing) ((top) #(ribcage #(p q) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + p2784 + (- lev2772 + '1))) + (quasi2757 + q2783 + lev2772)))) + tmp2782) + ((lambda (tmp2787) + (if tmp2787 + (apply + (lambda (p2788) + (quasicons2761 + '#(syntax-object (quote quasiquote) ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + (quasi2757 + (list p2788) + (+ lev2772 + '1)))) + tmp2787) + ((lambda (tmp2789) + (if tmp2789 + (apply + (lambda (p2791 + q2790) + (quasicons2761 + (quasi2757 + p2791 + lev2772) + (quasi2757 + q2790 + lev2772))) + tmp2789) + ((lambda (tmp2792) + (if tmp2792 + (apply + (lambda (x2793) + (quasivector2759 + (vquasi2758 + x2793 + lev2772))) + tmp2792) + ((lambda (p2795) + (list + '#(syntax-object quote ((top) #(ribcage #(p) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t))) + p2795)) + tmp2774))) + ($syntax-dispatch + tmp2774 + '#(vector + each-any))))) + ($syntax-dispatch + tmp2774 + '(any . any))))) + ($syntax-dispatch + tmp2774 + '(#(free-id + #(syntax-object quasiquote ((top) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any))))) + ($syntax-dispatch + tmp2774 + '((#(free-id + #(syntax-object unquote-splicing ((top) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + . + each-any) + . + any))))) + ($syntax-dispatch + tmp2774 + '((#(free-id + #(syntax-object unquote ((top) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + . + each-any) + . + any))))) + ($syntax-dispatch + tmp2774 + '(#(free-id + #(syntax-object unquote ((top) #(ribcage () () ()) #(ribcage #(p lev) #((top) (top)) #("i" "i")) #(ribcage #(isquote? islist? iscons? quote-nil? quasilist* quasicons quasiappend quasivector vquasi quasi) #((top) (top) (top) (top) (top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i" "i" "i" "i" "i")) #(top-ribcage *top* #t)))) + any)))) + p2773)))) + (lambda (x2767) + ((lambda (tmp2768) + ((lambda (tmp2769) + (if tmp2769 + (apply (lambda (_2771 e2770) (quasi2757 e2770 '0)) tmp2769) + (syntax-error tmp2768))) + ($syntax-dispatch tmp2768 '(any any)))) + x2767))) + '*top*) +($sc-put-cte + '#(syntax-object unquote ((top) #(ribcage #(unquote) #((top)) #(unquote)))) + (lambda (x2896) (syntax-error x2896 '"misplaced")) + '*top*) +($sc-put-cte + '#(syntax-object unquote-splicing ((top) #(ribcage #(unquote-splicing) #((top)) #(unquote-splicing)))) + (lambda (x2897) (syntax-error x2897 '"misplaced")) + '*top*) +($sc-put-cte + '#(syntax-object quasisyntax ((top) #(ribcage #(quasisyntax) #((top)) #(quasisyntax)))) + (lambda (x2898) + (letrec ((qs2899 (lambda (q2950 n2949 b*2948 k2947) + ((lambda (tmp2951) + ((lambda (tmp2952) + (if tmp2952 + (apply + (lambda (d2953) + (qs2899 + d2953 + (+ n2949 '1) + b*2948 + (lambda (b*2955 dnew2954) + (k2947 + b*2955 + (if (eq? dnew2954 d2953) + q2950 + ((lambda (tmp2956) + ((lambda (d2957) + (cons + '#(syntax-object quasisyntax ((top) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* dnew) #((top) (top)) #("i" "i")) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + d2957)) + tmp2956)) + dnew2954)))))) + tmp2952) + ((lambda (tmp2958) + (if (if tmp2958 + (apply + (lambda (d2959) + (not (fx= n2949 '0))) + tmp2958) + '#f) + (apply + (lambda (d2960) + (qs2899 + d2960 + (- n2949 '1) + b*2948 + (lambda (b*2962 dnew2961) + (k2947 + b*2962 + (if (eq? dnew2961 d2960) + q2950 + ((lambda (tmp2963) + ((lambda (d2964) + (cons + '#(syntax-object unsyntax ((top) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* dnew) #((top) (top)) #("i" "i")) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + d2964)) + tmp2963)) + dnew2961)))))) + tmp2958) + ((lambda (tmp2965) + (if (if tmp2965 + (apply + (lambda (d2966) + (not (fx= n2949 '0))) + tmp2965) + '#f) + (apply + (lambda (d2967) + (qs2899 + d2967 + (- n2949 '1) + b*2948 + (lambda (b*2969 + dnew2968) + (k2947 + b*2969 + (if (eq? dnew2968 + d2967) + q2950 + ((lambda (tmp2970) + ((lambda (d2971) + (cons + '#(syntax-object unsyntax-splicing ((top) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* dnew) #((top) (top)) #("i" "i")) #(ribcage #(d) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + d2971)) + tmp2970)) + dnew2968)))))) + tmp2965) + ((lambda (tmp2972) + (if (if tmp2972 + (apply + (lambda (q2973) + (fx= n2949 '0)) + tmp2972) + '#f) + (apply + (lambda (q2974) + ((lambda (tmp2975) + ((lambda (tmp2976) + (if tmp2976 + (apply + (lambda (t2977) + (k2947 + (cons + (list + t2977 + q2974) + b*2948) + t2977)) + tmp2976) + (syntax-error + tmp2975))) + ($syntax-dispatch + tmp2975 + '(any)))) + (generate-temporaries + (list + q2974)))) + tmp2972) + ((lambda (tmp2978) + (if (if tmp2978 + (apply + (lambda (q2980 + d2979) + (fx= n2949 + '0)) + tmp2978) + '#f) + (apply + (lambda (q2982 + d2981) + (qs2899 + d2981 + n2949 + b*2948 + (lambda (b*2984 + dnew2983) + ((lambda (tmp2985) + ((lambda (tmp2987) + (if tmp2987 + (apply + (lambda (t2988) + (k2947 + (append + (map list + t2988 + q2982) + b*2984) + ((lambda (tmp2989) + ((lambda (d2990) + (append + t2988 + d2990)) + tmp2989)) + dnew2983))) + tmp2987) + (syntax-error + tmp2985))) + ($syntax-dispatch + tmp2985 + 'each-any))) + (generate-temporaries + q2982))))) + tmp2978) + ((lambda (tmp2994) + (if (if tmp2994 + (apply + (lambda (q2996 + d2995) + (fx= n2949 + '0)) + tmp2994) + '#f) + (apply + (lambda (q2998 + d2997) + (qs2899 + d2997 + n2949 + b*2948 + (lambda (b*3000 + dnew2999) + ((lambda (tmp3001) + ((lambda (tmp3003) + (if tmp3003 + (apply + (lambda (t3004) + (k2947 + (append + (map (lambda (tmp3014 + tmp3013) + (list + (cons + tmp3013 + '(#(syntax-object ... ((top) #(ribcage #(t) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* dnew) #((top) (top)) #("i" "i")) #(ribcage #(q d) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))))) + tmp3014)) + q2998 + t3004) + b*3000) + ((lambda (tmp3005) + ((lambda (tmp3007) + (if tmp3007 + (apply + (lambda (m3008) + ((lambda (tmp3009) + ((lambda (d3010) + (append + (apply + append + m3008) + d3010)) + tmp3009)) + dnew2999)) + tmp3007) + (syntax-error + tmp3005))) + ($syntax-dispatch + tmp3005 + '#(each + each-any)))) + (map (lambda (tmp3006) + (cons + tmp3006 + '(#(syntax-object ... ((top) #(ribcage #(t) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* dnew) #((top) (top)) #("i" "i")) #(ribcage #(q d) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))))) + t3004)))) + tmp3003) + (syntax-error + tmp3001))) + ($syntax-dispatch + tmp3001 + 'each-any))) + (generate-temporaries + q2998))))) + tmp2994) + ((lambda (tmp3015) + (if tmp3015 + (apply + (lambda (a3017 + d3016) + (qs2899 + a3017 + n2949 + b*2948 + (lambda (b*3019 + anew3018) + (qs2899 + d3016 + n2949 + b*3019 + (lambda (b*3021 + dnew3020) + (k2947 + b*3021 + (if (if (eq? anew3018 + a3017) + (eq? dnew3020 + d3016) + '#f) + q2950 + ((lambda (tmp3022) + ((lambda (tmp3023) + (if tmp3023 + (apply + (lambda (a3025 + d3024) + (cons + a3025 + d3024)) + tmp3023) + (syntax-error + tmp3022))) + ($syntax-dispatch + tmp3022 + '(any any)))) + (list + anew3018 + dnew3020))))))))) + tmp3015) + ((lambda (tmp3026) + (if tmp3026 + (apply + (lambda (x3027) + (vqs2900 + x3027 + n2949 + b*2948 + (lambda (b*3029 + xnew*3028) + (k2947 + b*3029 + (if ((letrec ((same?3030 (lambda (x*3032 + xnew*3031) + (if (null? + x*3032) + (null? + xnew*3031) + (if (not (null? + xnew*3031)) + (if (eq? (car x*3032) + (car xnew*3031)) + (same?3030 + (cdr x*3032) + (cdr xnew*3031)) + '#f) + '#f))))) + same?3030) + x3027 + xnew*3028) + q2950 + ((lambda (tmp3034) + ((lambda (tmp3035) + (if tmp3035 + (apply + (lambda (x3036) + (list->vector + x3036)) + tmp3035) + (syntax-error + tmp3034))) + ($syntax-dispatch + tmp3034 + 'each-any))) + xnew*3028)))))) + tmp3026) + ((lambda (_3039) + (k2947 + b*2948 + q2950)) + tmp2951))) + ($syntax-dispatch + tmp2951 + '#(vector + each-any))))) + ($syntax-dispatch + tmp2951 + '(any . + any))))) + ($syntax-dispatch + tmp2951 + '((#(free-id + #(syntax-object unsyntax-splicing ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + each-any) + . + any))))) + ($syntax-dispatch + tmp2951 + '((#(free-id + #(syntax-object unsyntax ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + each-any) + . + any))))) + ($syntax-dispatch + tmp2951 + '(#(free-id + #(syntax-object unsyntax ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + any))))) + ($syntax-dispatch + tmp2951 + '(#(free-id + #(syntax-object unsyntax-splicing ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + any))))) + ($syntax-dispatch + tmp2951 + '(#(free-id + #(syntax-object unsyntax ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + any))))) + ($syntax-dispatch + tmp2951 + '(#(free-id + #(syntax-object quasisyntax ((top) #(ribcage () () ()) #(ribcage #(q n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + any)))) + q2950))) + (vqs2900 (lambda (x*2915 n2914 b*2913 k2912) + (if (null? x*2915) + (k2912 b*2913 '()) + (vqs2900 + (cdr x*2915) + n2914 + b*2913 + (lambda (b*2917 xnew*2916) + ((lambda (tmp2918) + ((lambda (tmp2919) + (if (if tmp2919 + (apply + (lambda (q2920) + (fx= n2914 '0)) + tmp2919) + '#f) + (apply + (lambda (q2921) + ((lambda (tmp2922) + ((lambda (tmp2924) + (if tmp2924 + (apply + (lambda (t2925) + (k2912 + (append + (map list + t2925 + q2921) + b*2917) + (append + t2925 + xnew*2916))) + tmp2924) + (syntax-error + tmp2922))) + ($syntax-dispatch + tmp2922 + 'each-any))) + (generate-temporaries + q2921))) + tmp2919) + ((lambda (tmp2929) + (if (if tmp2929 + (apply + (lambda (q2930) + (fx= n2914 '0)) + tmp2929) + '#f) + (apply + (lambda (q2931) + ((lambda (tmp2932) + ((lambda (tmp2934) + (if tmp2934 + (apply + (lambda (t2935) + (k2912 + (append + (map (lambda (tmp2943 + tmp2942) + (list + (cons + tmp2942 + '(#(syntax-object ... ((top) #(ribcage #(t) #((top)) #("i")) #(ribcage #(q) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* xnew*) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x* n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))))) + tmp2943)) + q2931 + t2935) + b*2917) + ((lambda (tmp2936) + ((lambda (tmp2938) + (if tmp2938 + (apply + (lambda (m2939) + (append + (apply + append + m2939) + xnew*2916)) + tmp2938) + (syntax-error + tmp2936))) + ($syntax-dispatch + tmp2936 + '#(each + each-any)))) + (map (lambda (tmp2937) + (cons + tmp2937 + '(#(syntax-object ... ((top) #(ribcage #(t) #((top)) #("i")) #(ribcage #(q) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(b* xnew*) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x* n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))))) + t2935)))) + tmp2934) + (syntax-error + tmp2932))) + ($syntax-dispatch + tmp2932 + 'each-any))) + (generate-temporaries + q2931))) + tmp2929) + ((lambda (_2944) + (qs2899 + (car x*2915) + n2914 + b*2917 + (lambda (b*2946 + xnew2945) + (k2912 + b*2946 + (cons + xnew2945 + xnew*2916))))) + tmp2918))) + ($syntax-dispatch + tmp2918 + '(#(free-id + #(syntax-object unsyntax-splicing ((top) #(ribcage () () ()) #(ribcage #(b* xnew*) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x* n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + each-any))))) + ($syntax-dispatch + tmp2918 + '(#(free-id + #(syntax-object unsyntax ((top) #(ribcage () () ()) #(ribcage #(b* xnew*) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x* n b* k) #((top) (top) (top) (top)) #("i" "i" "i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t)))) + . + each-any)))) + (car x*2915)))))))) + ((lambda (tmp2901) + ((lambda (tmp2902) + (if tmp2902 + (apply + (lambda (_2904 x2903) + (qs2899 + x2903 + '0 + '() + (lambda (b*2906 xnew2905) + (if (eq? xnew2905 x2903) + (list + '#(syntax-object syntax ((top) #(ribcage () () ()) #(ribcage #(b* xnew) #((top) (top)) #("i" "i")) #(ribcage #(_ x) #((top) (top)) #("i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + x2903) + ((lambda (tmp2907) + ((lambda (tmp2908) + (if tmp2908 + (apply + (lambda (b2910 x2909) + (list + '#(syntax-object with-syntax ((top) #(ribcage #(b x) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(b* xnew) #((top) (top)) #("i" "i")) #(ribcage #(_ x) #((top) (top)) #("i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + b2910 + (list + '#(syntax-object syntax ((top) #(ribcage #(b x) #((top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(b* xnew) #((top) (top)) #("i" "i")) #(ribcage #(_ x) #((top) (top)) #("i" "i")) #(ribcage (vqs qs) ((top) (top)) ("i" "i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + x2909))) + tmp2908) + (syntax-error tmp2907))) + ($syntax-dispatch + tmp2907 + '(each-any any)))) + (list b*2906 xnew2905)))))) + tmp2902) + (syntax-error tmp2901))) + ($syntax-dispatch tmp2901 '(any any)))) + x2898))) + '*top*) +($sc-put-cte + '#(syntax-object unsyntax ((top) #(ribcage #(unsyntax) #((top)) #(unsyntax)))) + (lambda (x3040) (syntax-error x3040 '"misplaced")) + '*top*) +($sc-put-cte + '#(syntax-object unsyntax-splicing ((top) #(ribcage #(unsyntax-splicing) #((top)) #(unsyntax-splicing)))) + (lambda (x3041) (syntax-error x3041 '"misplaced")) + '*top*) +($sc-put-cte + '#(syntax-object include ((top) #(ribcage #(include) #((top)) #(include)))) + (lambda (x3042) + (letrec ((read-file3043 (lambda (fn3054 k3053) + ((lambda (p3055) + ((letrec ((f3056 (lambda () + ((lambda (x3057) + (if (eof-object? + x3057) + (begin + (close-input-port + p3055) + '()) + (cons + (datum->syntax-object + k3053 + x3057) + (f3056)))) + (read p3055))))) + f3056))) + (open-input-file fn3054))))) + ((lambda (tmp3044) + ((lambda (tmp3045) + (if tmp3045 + (apply + (lambda (k3047 filename3046) + ((lambda (fn3048) + ((lambda (tmp3049) + ((lambda (tmp3050) + (if tmp3050 + (apply + (lambda (exp3051) + (cons + '#(syntax-object begin ((top) #(ribcage #(exp) #((top)) #("i")) #(ribcage () () ()) #(ribcage #(fn) #((top)) #("i")) #(ribcage #(k filename) #((top) (top)) #("i" "i")) #(ribcage (read-file) ((top)) ("i")) #(ribcage #(x) #((top)) #("i")) #(top-ribcage *top* #t))) + exp3051)) + tmp3050) + (syntax-error tmp3049))) + ($syntax-dispatch tmp3049 'each-any))) + (read-file3043 fn3048 k3047))) + (syntax-object->datum filename3046))) + tmp3045) + (syntax-error tmp3044))) + ($syntax-dispatch tmp3044 '(any any)))) + x3042))) + '*top*) +($sc-put-cte + '#(syntax-object case ((top) #(ribcage #(case) #((top)) #(case)))) + (lambda (x3058) + ((lambda (tmp3059) + ((lambda (tmp3060) + (if tmp3060 + (apply + (lambda (_3064 e3063 m13062 m23061) + ((lambda (tmp3065) + ((lambda (body3092) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + e3063)) + body3092)) + tmp3065)) + ((letrec ((f3066 (lambda (clause3068 clauses3067) + (if (null? clauses3067) + ((lambda (tmp3069) + ((lambda (tmp3070) + (if tmp3070 + (apply + (lambda (e13072 + e23071) + (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")) #(top-ribcage *top* #t))) + (cons + e13072 + e23071))) + tmp3070) + ((lambda (tmp3074) + (if tmp3074 + (apply + (lambda (k3077 + e13076 + e23075) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + k3077)) + (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")) #(top-ribcage *top* #t))) + (cons + e13076 + e23075)))) + tmp3074) + ((lambda (_3080) + (syntax-error + x3058)) + tmp3069))) + ($syntax-dispatch + tmp3069 + '(each-any + any + . + each-any))))) + ($syntax-dispatch + tmp3069 + '(#(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")) #(top-ribcage *top* #t)))) + any + . + each-any)))) + clause3068) + ((lambda (tmp3081) + ((lambda (rest3082) + ((lambda (tmp3083) + ((lambda (tmp3084) + (if tmp3084 + (apply + (lambda (k3087 + e13086 + e23085) + (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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + '#(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")) #(top-ribcage *top* #t))) + (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")) #(top-ribcage *top* #t))) + k3087)) + (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")) #(top-ribcage *top* #t))) + (cons + e13086 + e23085)) + rest3082)) + tmp3084) + ((lambda (_3090) + (syntax-error + x3058)) + tmp3083))) + ($syntax-dispatch + tmp3083 + '(each-any + any + . + each-any)))) + clause3068)) + tmp3081)) + (f3066 + (car clauses3067) + (cdr clauses3067))))))) + f3066) + m13062 + m23061))) + tmp3060) + (syntax-error tmp3059))) + ($syntax-dispatch tmp3059 '(any any any . each-any)))) + x3058)) + '*top*) +($sc-put-cte + '#(syntax-object identifier-syntax ((top) #(ribcage #(identifier-syntax) #((top)) #(identifier-syntax)))) + (lambda (x3093) + ((lambda (tmp3094) + ((lambda (tmp3095) + (if tmp3095 + (apply + (lambda (dummy3097 e3096) + (list + '#(syntax-object lambda ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (x) ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax-case ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object x ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '() + (list + '#(syntax-object id ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (identifier? (syntax id)) ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + e3096)) + (list + '(#(syntax-object _ ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + #(syntax-object x ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + #(syntax-object ... ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t)))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (cons + e3096 + '(#(syntax-object x ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + #(syntax-object ... ((top) #(ribcage #(dummy e) #(("m" top) (top)) #("i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t)))))))))) + tmp3095) + ((lambda (tmp3098) + (if (if tmp3098 + (apply + (lambda (dummy3104 id3103 exp13102 var3101 + val3100 exp23099) + (if (identifier? id3103) + (identifier? var3101) + '#f)) + tmp3098) + '#f) + (apply + (lambda (dummy3110 id3109 exp13108 var3107 val3106 + exp23105) + (list + '#(syntax-object cons ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (quote macro!) ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object lambda ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (x) ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax-case ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object x ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + '#(syntax-object (set!) ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + (list + '#(syntax-object set! ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + var3107 + val3106) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + exp23105)) + (list + (cons + id3109 + '(#(syntax-object x ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + #(syntax-object ... ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (cons + exp13108 + '(#(syntax-object x ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + #(syntax-object ... ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))))))) + (list + id3109 + (list + '#(syntax-object identifier? ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + id3109)) + (list + '#(syntax-object syntax ((top) #(ribcage #(dummy id exp1 var val exp2) #(("m" top) (top) (top) (top) (top) (top)) #("i" "i" "i" "i" "i" "i")) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t))) + exp13108)))))) + tmp3098) + (syntax-error tmp3094))) + ($syntax-dispatch + tmp3094 + '(any (any any) + ((#(free-id + #(syntax-object set! ((top) #(ribcage () () ()) #(ribcage #(x) #(("m" top)) #("i")) #(top-ribcage *top* #t)))) + any + any) + any)))))) + ($syntax-dispatch tmp3094 '(any any)))) + x3093)) + '*top*) + +;(primitive-set! '$syntax-dispatch $syntax-dispatch) +;(primitive-set! '$sc-put-cte $sc-put-cte) +;(current-expand +; (let ([sc-expand sc-expand]) +; (lambda (x) +; (#%core-expand (sc-expand x))))) + diff --git a/src/psyntax-7.1.ss b/src/psyntax-7.1.ss new file mode 100644 index 0000000..94b4550 --- /dev/null +++ b/src/psyntax-7.1.ss @@ -0,0 +1,4424 @@ +;;; Portable implementation of syntax-case +;;; Extracted from Chez Scheme Version 7.1 (Aug 01, 2006) +;;; Authors: R. Kent Dybvig, Oscar Waddell, Bob Hieb, Carl Bruggeman + +;;; Copyright (c) 1992-2002 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 +;;; is granted subject to the restriction that all copies made of this +;;; software must include this copyright notice in full. This software +;;; is provided AS IS, with NO WARRANTY, EITHER EXPRESS OR IMPLIED, +;;; INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY +;;; OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT SHALL THE +;;; AUTHORS BE LIABLE FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY +;;; NATURE WHATSOEVER. + +;;; Before attempting to port this code to a new implementation of +;;; Scheme, please read the notes below carefully. + +;;; This file defines the syntax-case expander, sc-expand, and a set +;;; of associated syntactic forms and procedures. Of these, the +;;; following are documented in The Scheme Programming Language, +;;; Third Edition (R. Kent Dybvig, MIT Press, 2003), which can be +;;; found online at http://www.scheme.com/tspl3/. Most are also documented +;;; in the R4RS and draft R5RS. +;;; +;;; bound-identifier=? +;;; datum->syntax-object +;;; define-syntax +;;; fluid-let-syntax +;;; free-identifier=? +;;; generate-temporaries +;;; identifier? +;;; identifier-syntax +;;; let-syntax +;;; letrec-syntax +;;; syntax +;;; syntax-case +;;; syntax-object->datum +;;; syntax-rules +;;; with-syntax +;;; +;;; All standard Scheme syntactic forms are supported by the expander +;;; or syntactic abstractions defined in this file. Only the R4RS +;;; delay is omitted, since its expansion is implementation-dependent. + +;;; Also defined are three forms that support modules: module, import, +;;; and import-only. These are documented in the Chez Scheme User's +;;; Guide (R. Kent Dybvig, Cadence Research Systems, 1998), which can +;;; also be found online at http://www.scheme.com/csug/. They are +;;; described briefly here as well. + +;;; All are definitions and may appear where and only where other +;;; definitions may appear. modules may be named: +;;; +;;; (module id (ex ...) defn ... init ...) +;;; +;;; or anonymous: +;;; +;;; (module (ex ...) defn ... init ...) +;;; +;;; The latter form is semantically equivalent to: +;;; +;;; (module T (ex ...) defn ... init ...) +;;; (import T) +;;; +;;; where T is a fresh identifier. +;;; +;;; In either form, each of the exports in (ex ...) is either an +;;; identifier or of the form (id ex ...). In the former case, the +;;; single identifier ex is exported. In the latter, the identifier +;;; id is exported and the exports ex ... are "implicitly" exported. +;;; This listing of implicit exports is useful only when id is a +;;; keyword bound to a transformer that expands into references to +;;; the listed implicit exports. In the present implementation, +;;; listing of implicit exports is necessary only for top-level +;;; modules and allows the implementation to avoid placing all +;;; identifiers into the top-level environment where subsequent passes +;;; of the compiler will be unable to deal effectively with them. +;;; +;;; Named modules may be referenced in import statements, which +;;; always take one of the forms: +;;; +;;; (import id) +;;; (import-only id) +;;; +;;; id must name a module. Each exported identifier becomes visible +;;; within the scope of the import form. In the case of import-only, +;;; all other identifiers become invisible in the scope of the +;;; import-only form, except for those established by definitions +;;; that appear textually after the import-only form. + +;;; import and import-only also support a variety of identifier +;;; selection and renaming forms: only, except, add-prefix, +;;; drop-prefix, rename, and alias. +;;; +;;; (import (only m x y)) +;;; +;;; imports x and y (and nothing else) from m. +;;; +;;; (import (except m x y)) +;;; +;;; imports all of m's imports except for x and y. +;;; +;;; (import (add-prefix (only m x y) m:)) +;;; +;;; imports x and y as m:x and m:y. +;;; +;;; (import (drop-prefix m foo:)) +;;; +;;; imports all of m's imports, dropping the common foo: prefix +;;; (which must appear on all of m's exports). +;;; +;;; (import (rename (except m a b) (m-c c) (m-d d))) +;;; +;;; imports all of m's imports except for x and y, renaming c +;;; m-c and d m-d. +;;; +;;; (import (alias (except m a b) (m-c c) (m-d d))) +;;; +;;; imports all of m's imports except for x and y, with additional +;;; aliases m-c for c and m-d for d. +;;; +;;; multiple imports may be specified with one import form: +;;; +;;; (import (except m1 x) (only m2 x)) +;;; +;;; imports all of m1's exports except for x plus x from m2. + +;;; Another form, meta, may be used as a prefix for any definition and +;;; causes any resulting variable bindings to be created at expansion +;;; time. Meta variables (variables defined using meta) are available +;;; only at expansion time. Meta definitions are often used to create +;;; data and helpers that can be shared by multiple macros, for example: + +;;; (module (alpha beta) +;;; (meta define key-error +;;; (lambda (key) +;;; (syntax-error key "invalid key"))) +;;; (meta define parse-keys +;;; (lambda (keys) +;;; (let f ((keys keys) (c #'white) (s 10)) +;;; (syntax-case keys (color size) +;;; (() (list c s)) +;;; (((color c) . keys) (f #'keys #'c s)) +;;; (((size s) . keys) (f #'keys c #'s)) +;;; ((k . keys) (key-error #'k)))))) +;;; (define-syntax alpha +;;; (lambda (x) +;;; (syntax-case x () +;;; ((_ (k ...) ) +;;; (with-syntax (((c s) (parse-keys (syntax (k ...))))) +;;; ---))))) +;;; (define-syntax beta +;;; (lambda (x) +;;; (syntax-case x () +;;; ((_ (k ...) ) +;;; (with-syntax (((c s) (parse-keys (syntax (k ...))))) +;;; ---)))))) + +;;; As with define-syntax rhs expressions, meta expressions can evaluate +;;; references only to identifiers whose values are (already) available +;;; in the compile-time environment, e.g., macros and meta variables. +;;; They can, however, like define-syntax rhs expressions, build syntax +;;; objects containing occurrences of any identifiers in their scope. + +;;; meta definitions propagate through macro expansion, so one can write, +;;; for example: +;;; +;;; (module (a) +;;; (meta define-structure (foo x)) +;;; (define-syntax a +;;; (let ((q (make-foo (syntax 'q)))) +;;; (lambda (x) +;;; (foo-x q))))) +;;; a -> q +;;; +;;; where define-record is a macro that expands into a set of defines. +;;; +;;; It is also sometimes convenient to write +;;; +;;; (meta begin defn ...) +;;; +;;; or +;;; +;;; (meta module {exports} defn ...) +;;; +;;; to create groups of meta bindings. + +;;; Another form, alias, is used to create aliases from one identifier +;;; to another. This is used primarily to support the extended import +;;; syntaxes (add-prefix, drop-prefix, rename, and alias). + +;;; (let ((x 3)) (alias y x) y) -> 3 + +;;; The remaining exports are listed below. sc-expand, eval-when, and +;;; syntax-error are described in the Chez Scheme User's Guide. +;;; +;;; (sc-expand datum) +;;; if datum represents a valid expression, sc-expand returns an +;;; expanded version of datum in a core language that includes no +;;; syntactic abstractions. The core language includes begin, +;;; define, if, lambda, letrec, quote, and set!. +;;; (eval-when situations expr ...) +;;; conditionally evaluates expr ... at compile-time or run-time +;;; depending upon situations +;;; (syntax-error object message) +;;; used to report errors found during expansion +;;; ($syntax-dispatch e p) +;;; used by expanded code to handle syntax-case matching +;;; ($sc-put-cte symbol val top-token) +;;; used to establish top-level compile-time (expand-time) bindings. + +;;; The following nonstandard procedures must be provided by the +;;; implementation for this code to run. +;;; +;;; (void) +;;; returns the implementation's cannonical "unspecified value". The +;;; following usually works: +;;; +;;; (define void (lambda () (if #f #f))). +;;; +;;; (andmap proc list1 list2 ...) +;;; returns true if proc returns true when applied to each element of list1 +;;; along with the corresponding elements of list2 .... The following +;;; definition works but does no error checking: +;;; +;;; (define andmap +;;; (lambda (f first . rest) +;;; (or (null? first) +;;; (if (null? rest) +;;; (let andmap ((first first)) +;;; (let ((x (car first)) (first (cdr first))) +;;; (if (null? first) +;;; (f x) +;;; (and (f x) (andmap first))))) +;;; (let andmap ((first first) (rest rest)) +;;; (let ((x (car first)) +;;; (xr (map car rest)) +;;; (first (cdr first)) +;;; (rest (map cdr rest))) +;;; (if (null? first) +;;; (apply f (cons x xr)) +;;; (and (apply f (cons x xr)) (andmap first rest))))))))) +;;; +;;; (ormap proc list1) +;;; returns the first non-false return result of proc applied to +;;; the elements of list1 or false if none. The following definition +;;; works but does no error checking: +;;; +;;; (define ormap +;;; (lambda (proc list1) +;;; (and (not (null? list1)) +;;; (or (proc (car list1)) (ormap proc (cdr list1)))))) +;;; +;;; The following nonstandard procedures must also be provided by the +;;; implementation for this code to run using the standard portable +;;; hooks and output constructors. They are not used by expanded code, +;;; and so need be present only at expansion time. +;;; +;;; (eval x) +;;; where x is always in the form ("noexpand" expr). +;;; returns the value of expr. the "noexpand" flag is used to tell the +;;; 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, results 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 +;;; signal an error with a message something like +;;; +;;; "error in : " +;;; +;;; (gensym) +;;; returns a unique symbol each time it's called. In Chez Scheme, gensym +;;; returns a symbol with a "globally" unique name so that gensyms that +;;; end up in the object code of separately compiled files cannot conflict. +;;; This is necessary only if you intend to support compiled files. +;;; +;;; (gensym? x) +;;; returns #t if x is a gensym, otherwise false. +;;; +;;; (putprop symbol key value) +;;; (getprop symbol key) +;;; (remprop symbol key) +;;; key is always a symbol; value may be any object. putprop should +;;; associate the given value with the given symbol and key in some way +;;; that it can be retrieved later with getprop. getprop should return +;;; #f if no value is associated with the given symbol and key. remprop +;;; should remove the association between the given symbol and key. + +;;; When porting to a new Scheme implementation, you should define the +;;; procedures listed above, load the expanded version of psyntax.ss +;;; (psyntax.pp, which should be available whereever you found +;;; psyntax.ss), and register sc-expand as the current expander (how +;;; you do this depends upon your implementation of Scheme). You may +;;; change the hooks and constructors defined toward the beginning of +;;; 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