diff --git a/demo/define-syntax-def.scm b/demo/define-syntax-def.scm new file mode 100644 index 00000000..a6e93530 --- /dev/null +++ b/demo/define-syntax-def.scm @@ -0,0 +1,3 @@ +(define-library (demo define-syntax-def) + (export answer) + (begin (define answer 42))) diff --git a/demo/define-syntax-last.scm b/demo/define-syntax-last.scm new file mode 100644 index 00000000..5f9cff52 --- /dev/null +++ b/demo/define-syntax-last.scm @@ -0,0 +1,5 @@ +(define-library (demo define-syntax-last) + (import (demo define-syntax-next)) + (begin + (display (ans)) + (newline))) diff --git a/demo/define-syntax-next.scm b/demo/define-syntax-next.scm new file mode 100644 index 00000000..0c51ca73 --- /dev/null +++ b/demo/define-syntax-next.scm @@ -0,0 +1,6 @@ +(define-library (demo define-syntax-next) + (import (demo define-syntax-def)) + (export ans) + (begin + (define (ans) (+ 1 answer)) + (newline))) diff --git a/demo/demo_psyntax.scm b/demo/demo_psyntax.scm new file mode 100644 index 00000000..51a843ee --- /dev/null +++ b/demo/demo_psyntax.scm @@ -0,0 +1,5 @@ +(define-library (demo demo_psyntax) + (import (scheme base)) + (begin + (display (max 10 11)))) + diff --git a/demo/x.scm b/demo/x.scm new file mode 100644 index 00000000..b328a8b7 --- /dev/null +++ b/demo/x.scm @@ -0,0 +1,58 @@ +(module scheme.base (let-values) + (define-syntax let-values + (lambda (x) + (syntax-case x () + ((_ ((binds exp)) b0 b1 ...) + (syntax (call-with-values (lambda () exp) + (lambda binds b0 b1 ...)))) + ((_ (clause ...) b0 b1 ...) + (let lp ((clauses (syntax (clause ...))) + (ids '()) + (tmps '())) + (if (null? clauses) + (with-syntax (((id ...) ids) + ((tmp ...) tmps)) + (syntax (let ((id tmp) ...) + b0 b1 ...))) + (syntax-case (car clauses) () + (((var ...) exp) + (with-syntax (((new-tmp ...) (generate-temporaries + (syntax (var ...)))) + ((id ...) ids) + ((tmp ...) tmps)) + (with-syntax ((inner (lp (cdr clauses) + (syntax (var ... id ...)) + (syntax (new-tmp ... tmp ...))))) + (syntax (call-with-values (lambda () exp) + (lambda (new-tmp ...) inner)))))) + ((vars exp) + (with-syntax ((((new-var . new-tmp) ...) + (let lp ((vars (syntax vars))) + (syntax-case vars () + ((id . rest) + (acons (syntax id) + (car + (generate-temporaries (syntax (id)))) + (lp (syntax rest)))) + (id (acons (syntax id) + (car + (generate-temporaries (syntax (id)))) + '()))))) + ((id ...) ids) + ((tmp ...) tmps)) + (with-syntax ((inner (lp (cdr clauses) + (syntax (new-var ... id ...)) + (syntax (new-tmp ... tmp ...)))) + (args (let lp ((tmps (syntax (new-tmp ...)))) + (syntax-case tmps () + ((id) (syntax id)) + ((id . rest) (cons (syntax id) + (lp (syntax rest)))))))) + (syntax (call-with-values (lambda () exp) + (lambda args inner)))))))))))))) + +(module demo () + (import scheme.base) + (let-values (((a b) (values 1 2))) + (display b) + (newline))) diff --git a/goldfish/liii/base.scm b/goldfish/liii/base.scm index d0144848..faede0cb 100644 --- a/goldfish/liii/base.scm +++ b/goldfish/liii/base.scm @@ -40,7 +40,9 @@ ; R7RS 6.7: String string-copy ; R7RS 6.8 Vector - vector->string string->vector vector-copy vector-copy! vector-fill! vector-append + vector->string string->vector vector-copy vector-copy! vector-fill! + ; workaround for binding s7 primitives + (rename vector-append vector-append) ; R7RS 6.9 Bytevectors bytevector? make-bytevector bytevector bytevector-length bytevector-u8-ref bytevector-u8-set! bytevector-copy bytevector-append diff --git a/goldfish/scheme/base.scm b/goldfish/scheme/base.scm index bf9bdd20..d7aeb8ce 100644 --- a/goldfish/scheme/base.scm +++ b/goldfish/scheme/base.scm @@ -15,6 +15,7 @@ ; (define-library (scheme base) + (import (scheme internal)) (export let-values ; R7RS 5: Program Structure @@ -26,7 +27,7 @@ ; R7RS 6.4: list pair? cons car cdr set-car! set-cdr! caar cadr cdar cddr null? list? make-list list length append reverse list-tail - list-ref list-set! memq memv member assq assv assoc list-copy + list-ref list-set! memq memv member assq assv assoc (rename copy list-copy) ; R7RS 6.5: Symbol symbol? symbol=? string->symbol symbol->string ; R7RS 6.6: Characters @@ -51,40 +52,120 @@ ; 0-clause BSD ; Bill Schottstaedt ; from S7 source repo: r7rs.scm - (define-macro (let-values vars . body) - (if (and (pair? vars) - (pair? (car vars)) - (null? (cdar vars))) - `((lambda ,(caar vars) - ,@body) - ,(cadar vars)) - `(with-let - (apply sublet (curlet) - (list - ,@(map - (lambda (v) - `((lambda ,(car v) - (values ,@(map (lambda (name) - (values (symbol->keyword name) name)) - (let args->proper-list ((args (car v))) - (cond ((symbol? args) - (list args)) - ((not (pair? args)) - args) - ((pair? (car args)) - (cons (caar args) - (args->proper-list (cdr args)))) - (else - (cons (car args) - (args->proper-list (cdr args))))))))) - ,(cadr v))) - vars))) - ,@body))) + (define-syntax let-values + (lambda (x) + (syntax-case x () + ((_ ((binds exp)) b0 b1 ...) + (syntax (call-with-values (lambda () exp) + (lambda binds b0 b1 ...)))) + ((_ (clause ...) b0 b1 ...) + (let lp ((clauses (syntax (clause ...))) + (ids '()) + (tmps '())) + (if (null? clauses) + (with-syntax (((id ...) ids) + ((tmp ...) tmps)) + (syntax (let ((id tmp) ...) + b0 b1 ...))) + (syntax-case (car clauses) () + (((var ...) exp) + (with-syntax (((new-tmp ...) (generate-temporaries + (syntax (var ...)))) + ((id ...) ids) + ((tmp ...) tmps)) + (with-syntax ((inner (lp (cdr clauses) + (syntax (var ... id ...)) + (syntax (new-tmp ... tmp ...))))) + (syntax (call-with-values (lambda () exp) + (lambda (new-tmp ...) inner)))))) + ((vars exp) + (with-syntax ((((new-var . new-tmp) ...) + (let lp ((vars (syntax vars))) + (syntax-case vars () + ((id . rest) + (acons (syntax id) + (car + (generate-temporaries (syntax (id)))) + (lp (syntax rest)))) + (id (acons (syntax id) + (car + (generate-temporaries (syntax (id)))) + '()))))) + ((id ...) ids) + ((tmp ...) tmps)) + (with-syntax ((inner (lp (cdr clauses) + (syntax (new-var ... id ...)) + (syntax (new-tmp ... tmp ...)))) + (args (let lp ((tmps (syntax (new-tmp ...)))) + (syntax-case tmps () + ((id) (syntax id)) + ((id . rest) (cons (syntax id) + (lp (syntax rest)))))))) + (syntax (call-with-values (lambda () exp) + (lambda args inner))))))))))))) ; 0-clause BSD by Bill Schottstaedt from S7 source repo: s7test.scm (define-macro (define-values vars expression) `(if (not (null? ',vars)) (varlet (curlet) ((lambda ,vars (curlet)) ,expression)))) + ; (define-syntax define-values + ; (lambda (orig-form) + ; (syntax-case orig-form () + ; ((_ () expr) + ; ;; XXX Work around the lack of hygienic top-level identifiers + ; (with-syntax (((dummy) (generate-temporaries '(dummy)))) + ; #`(define dummy + ; (call-with-values (lambda () expr) + ; (lambda () #f))))) + ; ((_ (var) expr) + ; (identifier? #'var) + ; #`(define var + ; (call-with-values (lambda () expr) + ; (lambda (v) v)))) + ; ((_ (var0 ... varn) expr) + ; (and-map identifier? #'(var0 ... varn)) + ; ;; XXX Work around the lack of hygienic toplevel identifiers + ; (with-syntax (((dummy) (generate-temporaries '(dummy)))) + ; #`(begin + ; ;; Avoid mutating the user-visible variables + ; (define dummy + ; (call-with-values (lambda () expr) + ; (lambda (var0 ... varn) + ; (list var0 ... varn)))) + ; (define var0 + ; (let ((v (car dummy))) + ; (set! dummy (cdr dummy)) + ; v)) + ; ... + ; (define varn + ; (let ((v (car dummy))) + ; (set! dummy #f) ; blackhole dummy + ; v))))) + ; ((_ var expr) + ; (identifier? #'var) + ; #'(define var + ; (call-with-values (lambda () expr) + ; list))) + ; ((_ (var0 ... . varn) expr) + ; (and-map identifier? #'(var0 ... varn)) + ; ;; XXX Work around the lack of hygienic toplevel identifiers + ; (with-syntax (((dummy) (generate-temporaries '(dummy)))) + ; #`(begin + ; ;; Avoid mutating the user-visible variables + ; (define dummy + ; (call-with-values (lambda () expr) + ; (lambda (var0 ... . varn) + ; (list var0 ... varn)))) + ; (define var0 + ; (let ((v (car dummy))) + ; (set! dummy (cdr dummy)) + ; v)) + ; ... + ; (define varn + ; (let ((v (car dummy))) + ; (set! dummy #f) ; blackhole dummy + ; v)))))))) + ; 0-clause BSD by Bill Schottstaedt from S7 source repo: r7rs.scm (define-macro (define-record-type type make ? . fields) @@ -549,10 +630,10 @@ wrong-type-arg (close-input-port p) (close-output-port p))) - (define (eof-object) #) + (define (eof-object) (call-with-input-string "" read)) ; 0 clause BSD, from S7 repo r7rs.scm - (define list-copy copy) + ; (define list-copy copy) (define (string-copy str . start_end) (cond ((null? start_end) diff --git a/goldfish/scheme/boot.scm b/goldfish/scheme/boot.scm index 14f4a671..f28e7937 100644 --- a/goldfish/scheme/boot.scm +++ b/goldfish/scheme/boot.scm @@ -1,107 +1,210 @@ -(define (file-exists? path) - (if (string? path) - (if (not (g_access path 0)) ; F_OK - #f - (if (g_access path 1) ; R_OK - #t - (error 'permission-error (string-append "No permission: " path)))) - (error 'type-error "(file-exists? path): path should be string"))) - -(define (delete-file path) - (if (not (string? path)) - (error 'type-error "(delete-file path): path should be string") - (if (not (file-exists? path)) - (error 'read-error (string-append path " does not exist")) - (g_delete-file path)))) - -; 0-clause BSD -; Adapted from S7 Scheme's r7rs.scm -(define-macro (define-library libname . body) ; |(lib name)| -> environment - `(define ,(symbol (object->string libname)) - (with-let (sublet (unlet) - (cons 'import import) - (cons '*export* ()) - (cons 'export (define-macro (,(gensym) . names) - `(set! *export* (append ',names *export*))))) - ,@body - (apply inlet - (map (lambda (entry) - (if (or (member (car entry) '(*export* export import)) - (and (pair? *export*) - (not (member (car entry) *export*)))) - (values) - entry)) - (curlet)))))) - -(unless (defined? 'r7rs-import-library-filename) - (define (r7rs-import-library-filename libs) - (when (pair? libs) - (let ((lib-filename (let loop ((lib (if (memq (caar libs) '(only except prefix rename)) - (cadar libs) - (car libs))) - (name "")) - (set! name (string-append name (symbol->string (car lib)))) - (if (null? (cdr lib)) - (string-append name ".scm") - (begin - (set! name (string-append name "/")) - (loop (cdr lib) name)))))) - (when (not (defined? (symbol (object->string (car libs))))) - ;(display "Loading ") (display lib-filename) (newline) - (load lib-filename)) - (r7rs-import-library-filename (cdr libs))))) - ) - -(define-macro (import . libs) - `(begin - (r7rs-import-library-filename ',libs) - (varlet (curlet) - ,@(map (lambda (lib) - (case (car lib) - ((only) - `((lambda (e names) - (apply inlet - (map (lambda (name) - (cons name (e name))) - names))) - (symbol->value (symbol (object->string (cadr ',lib)))) - (cddr ',lib))) - ((except) - `((lambda (e names) - (apply inlet - (map (lambda (entry) - (if (member (car entry) names) - (values) - entry)) - e))) - (symbol->value (symbol (object->string (cadr ',lib)))) - (cddr ',lib))) - ((prefix) - `((lambda (e prefx) - (apply inlet - (map (lambda (entry) - (cons (string->symbol - (string-append (symbol->string prefx) - (symbol->string (car entry)))) - (cdr entry))) - e))) - (symbol->value (symbol (object->string (cadr ',lib)))) - (caddr ',lib))) - ((rename) - `((lambda (e names) - (apply inlet - (map (lambda (entry) - (let ((info (assoc (car entry) names))) - (if info - (cons (cadr info) (cdr entry)) - entry))) - e))) - (symbol->value (symbol (object->string (cadr ',lib)))) - (cddr ',lib))) - (else - `(let ((sym (symbol (object->string ',lib)))) - (if (not (defined? sym)) - (format () "~A not loaded~%" sym) - (symbol->value sym)))))) - libs)))) +(define (void) (if #f #f)) +(define (andmap f first . rest) + (if (null? rest) + (let andmap ((first first)) + (if (null? first) + #t + (let ((x (car first)) + (rest (cdr first))) + (if (null? rest) + (f x) + (and (f x) (andmap rest)))))) + (let andmap ((first first) (rest rest)) + (if (null? first) + #t + (let ((x (car first)) + (xr (map car rest)) + (next-first (cdr first)) + (next-rest (map cdr rest))) + (if (null? next-first) + (apply f (cons x xr)) + (and (apply f (cons x xr)) + (andmap next-first next-rest)))))))) + +(define (ormap f list1) + (and (not (null? list1)) + (or (f (car list1)) + (ormap f (cdr list1))))) + +(define *symbol-properties* (make-hash-table)) + +(define (putprop symbol key value) + (let ((props (hash-table-ref *symbol-properties* symbol))) + (if props + (hash-table-set! props key value) + (let ((new-props (make-hash-table))) + (hash-table-set! new-props key value) + (hash-table-set! *symbol-properties* symbol new-props))) + value)) + +(define (getprop symbol key) + (let ((props (hash-table-ref *symbol-properties* symbol))) + (if props + (hash-table-ref props key) + #f))) + +(define (remprop symbol key) + (let ((props (hash-table-ref *symbol-properties* symbol))) + (if props + (hash-table-set! props key #f)) + #f)) + +(define s7-gensym gensym) +(define (gensym x) + (cond + ((symbol? x) (s7-gensym (symbol->string x))) + (else (s7-gensym x)))) + +;; API provided by psyntax +(define $sc-put-cte #f) +(define sc-expand #f) +(define $make-environment #f) +(define environment? #f) +(define interaction-environment #f) +(define identifier? #f) +(define unwrap-syntax #f) +(define syntax->list #f) +(define syntax-object->datum #f) +(define datum->syntax-object #f) +(define generate-temporaries #f) +(define free-identifier=? #f) +(define bound-identifier=? #f) +(define literal-identifier=? #f) +(define syntax-error #f) +(define $syntax-dispatch #f) + +(define syntax->vector #f) + +(set! (*s7* 'symbol-quote?) #t) + +(define s7-append append) +(set! append + (lambda args + (cond + ;; 0 或 1 个参数 + ((or (null? args) (null? (cdr args))) + (apply s7-append args)) + + ((not (proper-list? (car (last-pair args)))) + (let ((prefix (apply s7-append (drop-right args 1)))) + (if (null? prefix) + (car (last-pair args)) + (let copy ((lst prefix)) + (if (null? (cdr lst)) + (cons (car lst) (car (last-pair args))) + (cons (car lst) (copy (cdr lst)))))))) + + (else (apply s7-append args))))) + +(unless (defined? 'drop-right) + (define (drop-right lst n) + (let loop ((lst lst) (result '())) + (if (or (null? lst) (null? (cdr lst))) + (reverse result) + (loop (cdr lst) (cons (car lst) result)))))) + +(unless (defined? 'last-pair) + (define (last-pair lst) + (if (null? (cdr lst)) + lst + (last-pair (cdr lst))))) + +(define %primitive-read read) +(define %primitive-eval eval) +(define %primitive-eval-string eval-string) +(define %primitive-load load) + +(define read g_goldfish-read) +(define eval g_goldfish-eval) +(define eval-string g_goldfish-eval-string) +(define load g_goldfish-load) + +(%primitive-load "scheme/psyntax.pp") + +(define syntax->datum syntax-object->datum) +(define datum->syntax datum->syntax-object) + + + + +(set! *#readers* + (append + (list + ;; #` (quasisyntax) + (cons #\` (lambda (str) + (list 'quasisyntax (read)))) + ;; #, (unsyntax) + (cons #\, (lambda (str) + ;; 检查后面是否跟着 @，即 #,@ (unsyntax-splicing) + (let ((next-char (peek-char))) + (if (eq? next-char #\@) + (begin + (read-char) ;; 消耗掉 @ + (list 'unsyntax-splicing (read))) + (list 'unsyntax (read))))))) + ;; #' (syntax) + ;; NOTE: 不能简单这样写，见下方注释 + ; (cons #\' (lambda (str) + ; (list 'syntax (read))))) + *#readers*)) + +;; --------------------------------------------------------- +;; 注意：在 s7 的 *#readers* hook 中，不能简单地对原子符号使用 (read)。 +;; 因为此时 (read) 为了确定一个 symbol 的结束，会预读下一个字符。 +;; 如果 #'foo 紧跟括号，如 (#'foo)，内部的 (read) 会消耗掉那个 ')'， +;; 导致外层解析器因丢失闭合括号而报错。 +;; 如果不是预期如此，这应当是 s7 的 bug +;; --------------------------------------------------------- + +(define (goldfish-read-syntax-object port) + (define (delimiter? c) + (or (eof-object? c) + (char-whitespace? c) + ;; 核心界定符：这些字符标志着一个原子符号的终结 + ;; 我们必须在读到这些字符之前停止，且绝不能从 port 中消耗它们 + (case c ((#\( #\) #\[ #\] #\{ #\} #\" #\;) #t) (else #f)))) + + ;; 1. 处理前置空格（确保跳过 #' 后的空白） + (let skip-ws () + (let ((c (peek-char port))) + (if (and (not (eof-object? c)) (char-whitespace? c)) + (begin (read-char port) (skip-ws))))) + + (let ((next (peek-char port))) + (cond + ((eof-object? next) next) + + ;; 2. 处理复合结构如 #'(foo) + ;; 此时直接调用 read 是安全的，因为 read 遇到配对的 ')' 停止， + ;; 指针位置刚好符合预期。 + ((eq? next #\() (read port)) + + ;; 3. 处理原子符号如 #'foo + ;; 必须通过 peek-char 手动收集字符。一旦遇到界定符（如 ')'）， + ;; 立即停止收集并返回。这样指针就精准地停在界定符之前， + ;; 从而避免了原生 (read) 误吞界定符导致的语法解析崩溃。 + (else + (let collect ((chars '())) + (let ((c (peek-char port))) + (if (delimiter? c) + (if (null? chars) + #f + (string->symbol (list->string (reverse chars)))) + (collect (cons (read-char port) chars))))))))) + +;; 注册宏 +(set! *#readers* + (cons + (cons #\' (lambda (str) + (list 'syntax (goldfish-read-syntax-object (current-input-port))))) + *#readers*)) + +(set-expander! + (lambda (expr) + (sc-expand expr #f '(E) '(E)))) + +(load "scheme/s7-shim.scm") +(load "scheme/r7rs-small.scm") + +; (load "demo/demo_psyntax.scm") diff --git a/goldfish/scheme/complex.scm b/goldfish/scheme/complex.scm index c8277b63..404f4dea 100644 --- a/goldfish/scheme/complex.scm +++ b/goldfish/scheme/complex.scm @@ -24,7 +24,7 @@ imag-part magnitude angle) - (import (scheme base))) + (import (scheme internal))) ;; Note: These functions are implemented in the underlying S7 scheme engine -;; and are made available through the library export mechanism. \ No newline at end of file +;; and are made available through the library export mechanism. diff --git a/goldfish/scheme/inexact.scm b/goldfish/scheme/inexact.scm index ef8a6450..c3c76aad 100644 --- a/goldfish/scheme/inexact.scm +++ b/goldfish/scheme/inexact.scm @@ -18,6 +18,7 @@ ; useful with inexact values (define-library (scheme inexact) (export acos asin atan cos exp finite? infinite? log nan? sin sqrt s7-sqrt tan) + (import (scheme internal)) (begin (define s7-sqrt sqrt) diff --git a/goldfish/scheme/internal.scm b/goldfish/scheme/internal.scm new file mode 100644 index 00000000..232e1874 --- /dev/null +++ b/goldfish/scheme/internal.scm @@ -0,0 +1,54 @@ +(define-library (scheme internal) + (export (rename acos acos) + (rename angle angle) + (rename append append) + (rename asin asin) + (rename assoc assoc) + (rename assq assq) + (rename assv assv) + (rename atan atan) + (rename caar caar) + (rename cadr cadr) + (rename car car) + (rename cdar cdar) + (rename cddr cddr) + (rename cdr cdr) + (rename cons cons) + (rename cos cos) + (rename denominator denominator) + (rename digit-value digit-value) + (rename exp exp) + (rename gcd gcd) + (rename imag-part imag-part) + (rename infinite? infinite?) + (rename length length) + (rename list list) + (rename list-ref list-ref) + (rename list-set! list-set!) + (rename list-tail list-tail) + (rename list? list?) + (rename log log) + (rename magnitude magnitude) + (rename make-list make-list) + (rename make-polar make-polar) + (rename make-rectangular make-rectangular) + (rename member member) + (rename memq memq) + (rename memv memv) + (rename nan? nan?) + (rename null? null?) + (rename number->string number->string) + (rename numerator numerator) + (rename open-binary-input-file open-binary-input-file) + (rename open-binary-output-file open-binary-output-file) + (rename pair? pair?) + (rename real-part real-part) + (rename reverse reverse) + (rename set-car! set-car!) + (rename set-cdr! set-cdr!) + (rename sin sin) + (rename string->number string->number) + (rename string->symbol string->symbol) + (rename symbol->string symbol->string) + (rename symbol? symbol?) + (rename tan tan))) diff --git a/goldfish/scheme/psyntax.pp b/goldfish/scheme/psyntax.pp new file mode 100644 index 00000000..ea84cd28 --- /dev/null +++ b/goldfish/scheme/psyntax.pp @@ -0,0 +1,60718 @@ +;;; psyntax.pp +;;; automatically generated from psyntax.ss +;;; Fri 27 Feb 2026 03:34:51 PM CST CST +;;; see copyright notice in psyntax.ss + +((lambda () + (letrec* ((lexical-noexpand-87 '"noexpand") + (lexical-make-syntax-object-89 + (lambda (lexical-expression-553 lexical-wrap-554) + (vector 'syntax-object lexical-expression-553 lexical-wrap-554))) + (lexical-syntax-object?-90 + (lambda (lexical-x-555) + (if (vector? lexical-x-555) + (if (= (vector-length lexical-x-555) '3) + (eq? (vector-ref lexical-x-555 '0) 'syntax-object) + '#f) + '#f))) + (lexical-syntax-object-expression-91 + (lambda (lexical-x-556) (vector-ref lexical-x-556 '1))) + (lexical-syntax-object-wrap-92 + (lambda (lexical-x-557) (vector-ref lexical-x-557 '2))) + (lexical-set-syntax-object-expression!-93 + (lambda (lexical-x-558 lexical-update-559) + (vector-set! lexical-x-558 '1 lexical-update-559))) + (lexical-set-syntax-object-wrap!-94 + (lambda (lexical-x-560 lexical-update-561) + (vector-set! lexical-x-560 '2 lexical-update-561))) + (lexical-annotation?-158 (lambda (lexical-x-562) '#f)) + (lexical-top-level-eval-hook-159 + (lambda (lexical-x-563) + (eval (list lexical-noexpand-87 lexical-x-563)))) + (lexical-local-eval-hook-160 + (lambda (lexical-x-564) + (eval (list lexical-noexpand-87 lexical-x-564)))) + (lexical-define-top-level-value-hook-161 + (lambda (lexical-sym-565 lexical-val-566) + (lexical-top-level-eval-hook-159 + (list 'define lexical-sym-565 (list 'quote lexical-val-566))))) + (lexical-error-hook-162 + (lambda (lexical-who-567 lexical-why-568 lexical-what-569) + (error lexical-who-567 + '"~a ~s" + lexical-why-568 + lexical-what-569))) + (lexical-put-cte-hook-163 + (lambda (lexical-symbol-570 lexical-val-571) + ($sc-put-cte lexical-symbol-570 lexical-val-571 '*top*))) + (lexical-get-global-definition-hook-164 + (lambda (lexical-symbol-572) + (getprop lexical-symbol-572 '*sc-expander*))) + (lexical-put-global-definition-hook-165 + (lambda (lexical-symbol-573 lexical-x-574) + (if (not lexical-x-574) + (remprop lexical-symbol-573 '*sc-expander*) + (putprop lexical-symbol-573 '*sc-expander* lexical-x-574)))) + (lexical-read-only-binding?-166 (lambda (lexical-symbol-575) '#f)) + (lexical-get-import-binding-167 + (lambda (lexical-symbol-576 lexical-token-577) + (getprop lexical-symbol-576 lexical-token-577))) + (lexical-update-import-binding!-168 + (lambda (lexical-symbol-578 lexical-token-579 lexical-p-580) + ((lambda (lexical-x-581) + (if (not lexical-x-581) + (remprop lexical-symbol-578 lexical-token-579) + (putprop + lexical-symbol-578 + lexical-token-579 + lexical-x-581))) + (lexical-p-580 + (lexical-get-import-binding-167 + lexical-symbol-578 + lexical-token-579))))) + (lexical-generate-id-169 + ((lambda (lexical-digits-582) + ((lambda (lexical-base-583 lexical-session-key-584) + (letrec* ((lexical-make-digit-585 + (lambda (lexical-x-587) + (string-ref lexical-digits-582 lexical-x-587))) + (lexical-fmt-586 + (lambda (lexical-n-588) + ((letrec ((lexical-fmt-589 + (lambda (lexical-n-590 + lexical-a-591) + (if (< lexical-n-590 + lexical-base-583) + (list->string + (cons (lexical-make-digit-585 + lexical-n-590) + lexical-a-591)) + ((lambda (lexical-r-592 + lexical-rest-593) + (lexical-fmt-589 + lexical-rest-593 + (cons (lexical-make-digit-585 + lexical-r-592) + lexical-a-591))) + (modulo + lexical-n-590 + lexical-base-583) + (quotient + lexical-n-590 + lexical-base-583)))))) + lexical-fmt-589) + lexical-n-588 + '())))) + ((lambda (lexical-n-594) + (lambda (lexical-name-595) + (begin + (set! lexical-n-594 (+ lexical-n-594 '1)) + (string->symbol + (string-append + lexical-session-key-584 + (lexical-fmt-586 lexical-n-594)))))) + '-1))) + (string-length lexical-digits-582) + '"_")) + '"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&*/<=>?~_^.+-")) + (lexical-built-lambda?-243 + (lambda (lexical-x-596) + (if (pair? lexical-x-596) + (eq? (car lexical-x-596) 'lambda) + '#f))) + (lexical-build-sequence-261 + (lambda (lexical-ae-597 lexical-exps-598) + ((letrec ((lexical-loop-599 + (lambda (lexical-exps-600) + (if (null? (cdr lexical-exps-600)) + (car lexical-exps-600) + (if (equal? (car lexical-exps-600) '(void)) + (lexical-loop-599 (cdr lexical-exps-600)) + (cons 'begin lexical-exps-600)))))) + lexical-loop-599) + lexical-exps-598))) + (lexical-build-letrec-262 + (lambda (lexical-ae-601 + lexical-vars-602 + lexical-val-exps-603 + lexical-body-exp-604) + (if (null? lexical-vars-602) + lexical-body-exp-604 + (list 'letrec + (map list lexical-vars-602 lexical-val-exps-603) + lexical-body-exp-604)))) + (lexical-build-letrec*-263 + (lambda (lexical-ae-605 + lexical-vars-606 + lexical-val-exps-607 + lexical-body-exp-608) + (if (null? lexical-vars-606) + lexical-body-exp-608 + (list 'letrec* + (map list lexical-vars-606 lexical-val-exps-607) + lexical-body-exp-608)))) + (lexical-build-body-264 + (lambda (lexical-ae-609 + lexical-vars-610 + lexical-val-exps-611 + lexical-body-exp-612) + (lexical-build-letrec*-263 + lexical-ae-609 + lexical-vars-610 + lexical-val-exps-611 + lexical-body-exp-612))) + (lexical-build-top-module-265 + (lambda (lexical-ae-613 + lexical-types-614 + lexical-vars-615 + lexical-val-exps-616 + lexical-body-exp-617) + (call-with-values + (lambda () + ((letrec ((lexical-f-618 + (lambda (lexical-types-619 lexical-vars-620) + (if (null? lexical-types-619) + (values '() '() '()) + ((lambda (lexical-var-621) + (call-with-values + (lambda () + (lexical-f-618 + (cdr lexical-types-619) + (cdr lexical-vars-620))) + (lambda (lexical-vars-622 + lexical-defns-623 + lexical-sets-624) + (if (eq? (car lexical-types-619) + 'global) + ((lambda (lexical-x-625) + (values + (cons lexical-x-625 + lexical-vars-622) + (cons (list 'define + lexical-var-621 + (lexical-chi-void-546)) + lexical-defns-623) + (cons (list 'set! + lexical-var-621 + lexical-x-625) + lexical-sets-624))) + (gensym lexical-var-621)) + (values + (cons lexical-var-621 + lexical-vars-622) + lexical-defns-623 + lexical-sets-624))))) + (car lexical-vars-620)))))) + lexical-f-618) + lexical-types-614 + lexical-vars-615)) + (lambda (lexical-vars-626 lexical-defns-627 lexical-sets-628) + (if (null? lexical-defns-627) + (lexical-build-letrec-262 + lexical-ae-613 + lexical-vars-626 + lexical-val-exps-616 + lexical-body-exp-617) + (lexical-build-sequence-261 + '#f + (append + lexical-defns-627 + (list (lexical-build-letrec-262 + lexical-ae-613 + lexical-vars-626 + lexical-val-exps-616 + (lexical-build-sequence-261 + '#f + (append + lexical-sets-628 + (list lexical-body-exp-617)))))))))))) + (lexical-sanitize-binding-298 + (lambda (lexical-b-629) + (if (procedure? lexical-b-629) + (cons 'macro lexical-b-629) + (if (lexical-binding?-312 lexical-b-629) + (if ((lambda (lexical-t-630) + (if (memv lexical-t-630 + '(core macro macro! deferred)) + (procedure? + (lexical-binding-value-309 lexical-b-629)) + (if (memv lexical-t-630 '($module)) + (lexical-interface?-479 + (lexical-binding-value-309 + lexical-b-629)) + (if (memv lexical-t-630 '(lexical)) + '#f + (if (memv lexical-t-630 + '(global meta-variable)) + (symbol? + (lexical-binding-value-309 + lexical-b-629)) + (if (memv lexical-t-630 + '(syntax)) + ((lambda (lexical-x-631) + (if (pair? lexical-x-631) + (if '#f + ((lambda (lexical-n-632) + (if (integer? + lexical-n-632) + (if (exact? + lexical-n-632) + (>= lexical-n-632 + '0) + '#f) + '#f)) + (cdr lexical-x-631)) + '#f) + '#f)) + (lexical-binding-value-309 + lexical-b-629)) + (if (memv lexical-t-630 + '(begin + define + define-syntax + set! + $module-key + $import + eval-when + meta)) + (null? (lexical-binding-value-309 + lexical-b-629)) + (if (memv lexical-t-630 + '(local-syntax)) + (boolean? + (lexical-binding-value-309 + lexical-b-629)) + (if (memv lexical-t-630 + '(displaced-lexical)) + (eq? (lexical-binding-value-309 + lexical-b-629) + '#f) + '#t))))))))) + (lexical-binding-type-308 lexical-b-629)) + lexical-b-629 + '#f) + '#f)))) + (lexical-binding-type-308 car) + (lexical-binding-value-309 cdr) + (lexical-set-binding-type!-310 set-car!) + (lexical-set-binding-value!-311 set-cdr!) + (lexical-binding?-312 + (lambda (lexical-x-633) + (if (pair? lexical-x-633) (symbol? (car lexical-x-633)) '#f))) + (lexical-extend-env-322 + (lambda (lexical-label-634 lexical-binding-635 lexical-r-636) + (cons (cons lexical-label-634 lexical-binding-635) + lexical-r-636))) + (lexical-extend-env*-323 + (lambda (lexical-labels-637 lexical-bindings-638 lexical-r-639) + (if (null? lexical-labels-637) + lexical-r-639 + (lexical-extend-env*-323 + (cdr lexical-labels-637) + (cdr lexical-bindings-638) + (lexical-extend-env-322 + (car lexical-labels-637) + (car lexical-bindings-638) + lexical-r-639))))) + (lexical-extend-var-env*-324 + (lambda (lexical-labels-640 lexical-vars-641 lexical-r-642) + (if (null? lexical-labels-640) + lexical-r-642 + (lexical-extend-var-env*-324 + (cdr lexical-labels-640) + (cdr lexical-vars-641) + (lexical-extend-env-322 + (car lexical-labels-640) + (cons 'lexical (car lexical-vars-641)) + lexical-r-642))))) + (lexical-displaced-lexical?-325 + (lambda (lexical-id-643 lexical-r-644) + ((lambda (lexical-n-645) + (if lexical-n-645 + ((lambda (lexical-b-646) + (eq? (lexical-binding-type-308 lexical-b-646) + 'displaced-lexical)) + (lexical-lookup-328 lexical-n-645 lexical-r-644)) + '#f)) + (lexical-id-var-name-461 lexical-id-643 '(()))))) + (lexical-displaced-lexical-error-326 + (lambda (lexical-id-647) + (syntax-error + lexical-id-647 + (if (lexical-id-var-name-461 lexical-id-647 '(())) + '"identifier out of context" + '"identifier not visible")))) + (lexical-lookup*-327 + (lambda (lexical-x-648 lexical-r-649) + ((lambda (lexical-t-650) + (if lexical-t-650 + (cdr lexical-t-650) + (if (symbol? lexical-x-648) + ((lambda (lexical-t-651) + (if lexical-t-651 + lexical-t-651 + (cons 'global lexical-x-648))) + (lexical-get-global-definition-hook-164 + lexical-x-648)) + '(displaced-lexical . #f)))) + (assq lexical-x-648 lexical-r-649)))) + (lexical-lookup-328 + (lambda (lexical-x-652 lexical-r-653) + (letrec* ((lexical-whack-binding!-654 + (lambda (lexical-b-655 lexical-*b-656) + (begin + (lexical-set-binding-type!-310 + lexical-b-655 + (lexical-binding-type-308 lexical-*b-656)) + (lexical-set-binding-value!-311 + lexical-b-655 + (lexical-binding-value-309 lexical-*b-656)))))) + ((lambda (lexical-b-657) + (begin + (if (eq? (lexical-binding-type-308 lexical-b-657) + 'deferred) + (lexical-whack-binding!-654 + lexical-b-657 + (lexical-make-transformer-binding-329 + ((lexical-binding-value-309 lexical-b-657)))) + (void)) + lexical-b-657)) + (lexical-lookup*-327 lexical-x-652 lexical-r-653))))) + (lexical-make-transformer-binding-329 + (lambda (lexical-b-658) + ((lambda (lexical-t-659) + (if lexical-t-659 + lexical-t-659 + (syntax-error lexical-b-658 '"invalid transformer"))) + (lexical-sanitize-binding-298 lexical-b-658)))) + (lexical-defer-or-eval-transformer-330 + (lambda (lexical-eval-660 lexical-x-661) + (if (lexical-built-lambda?-243 lexical-x-661) + (cons 'deferred + (lambda () (lexical-eval-660 lexical-x-661))) + (lexical-make-transformer-binding-329 + (lexical-eval-660 lexical-x-661))))) + (lexical-global-extend-331 + (lambda (lexical-type-662 lexical-sym-663 lexical-val-664) + (lexical-put-cte-hook-163 + lexical-sym-663 + (cons lexical-type-662 lexical-val-664)))) + (lexical-nonsymbol-id?-332 + (lambda (lexical-x-665) + (if (lexical-syntax-object?-90 lexical-x-665) + (symbol? + ((lambda (lexical-e-666) + (if (lexical-annotation?-158 lexical-e-666) + (annotation-expression lexical-e-666) + lexical-e-666)) + (lexical-syntax-object-expression-91 lexical-x-665))) + '#f))) + (lexical-id?-333 + (lambda (lexical-x-667) + (if (symbol? lexical-x-667) + '#t + (if (lexical-syntax-object?-90 lexical-x-667) + (symbol? + ((lambda (lexical-e-668) + (if (lexical-annotation?-158 lexical-e-668) + (annotation-expression lexical-e-668) + lexical-e-668)) + (lexical-syntax-object-expression-91 lexical-x-667))) + (if (lexical-annotation?-158 lexical-x-667) + (symbol? (annotation-expression lexical-x-667)) + '#f))))) + (lexical-id-marks-339 + (lambda (lexical-id-669) + (if (lexical-syntax-object?-90 lexical-id-669) + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-id-669)) + (lexical-wrap-marks-343 '((top)))))) + (lexical-id-subst-340 + (lambda (lexical-id-670) + (if (lexical-syntax-object?-90 lexical-id-670) + (lexical-wrap-subst-344 + (lexical-syntax-object-wrap-92 lexical-id-670)) + (lexical-wrap-marks-343 '((top)))))) + (lexical-id-sym-name&marks-341 + (lambda (lexical-x-671 lexical-w-672) + (if (lexical-syntax-object?-90 lexical-x-671) + (values + ((lambda (lexical-e-673) + (if (lexical-annotation?-158 lexical-e-673) + (annotation-expression lexical-e-673) + lexical-e-673)) + (lexical-syntax-object-expression-91 lexical-x-671)) + (lexical-join-marks-450 + (lexical-wrap-marks-343 lexical-w-672) + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-x-671)))) + (values + ((lambda (lexical-e-674) + (if (lexical-annotation?-158 lexical-e-674) + (annotation-expression lexical-e-674) + lexical-e-674)) + lexical-x-671) + (lexical-wrap-marks-343 lexical-w-672))))) + (lexical-make-wrap-342 cons) + (lexical-wrap-marks-343 car) + (lexical-wrap-subst-344 cdr) + (lexical-make-indirect-label-382 + (lambda (lexical-label-675) + (vector 'indirect-label lexical-label-675))) + (lexical-indirect-label?-383 + (lambda (lexical-x-676) + (if (vector? lexical-x-676) + (if (= (vector-length lexical-x-676) '2) + (eq? (vector-ref lexical-x-676 '0) 'indirect-label) + '#f) + '#f))) + (lexical-indirect-label-label-384 + (lambda (lexical-x-677) (vector-ref lexical-x-677 '1))) + (lexical-set-indirect-label-label!-385 + (lambda (lexical-x-678 lexical-update-679) + (vector-set! lexical-x-678 '1 lexical-update-679))) + (lexical-gen-indirect-label-386 + (lambda () + (lexical-make-indirect-label-382 (lexical-gen-label-389)))) + (lexical-get-indirect-label-387 + (lambda (lexical-x-680) + (lexical-indirect-label-label-384 lexical-x-680))) + (lexical-set-indirect-label!-388 + (lambda (lexical-x-681 lexical-v-682) + (lexical-set-indirect-label-label!-385 + lexical-x-681 + lexical-v-682))) + (lexical-gen-label-389 (lambda () (string '#\i))) + (lexical-label?-390 + (lambda (lexical-x-683) + ((lambda (lexical-t-684) + (if lexical-t-684 + lexical-t-684 + ((lambda (lexical-t-685) + (if lexical-t-685 + lexical-t-685 + (lexical-indirect-label?-383 lexical-x-683))) + (symbol? lexical-x-683)))) + (string? lexical-x-683)))) + (lexical-gen-labels-391 + (lambda (lexical-ls-686) + (if (null? lexical-ls-686) + '() + (cons (lexical-gen-label-389) + (lexical-gen-labels-391 (cdr lexical-ls-686)))))) + (lexical-make-ribcage-392 + (lambda (lexical-symnames-687 + lexical-marks-688 + lexical-labels-689) + (vector + 'ribcage + lexical-symnames-687 + lexical-marks-688 + lexical-labels-689))) + (lexical-ribcage?-393 + (lambda (lexical-x-690) + (if (vector? lexical-x-690) + (if (= (vector-length lexical-x-690) '4) + (eq? (vector-ref lexical-x-690 '0) 'ribcage) + '#f) + '#f))) + (lexical-ribcage-symnames-394 + (lambda (lexical-x-691) (vector-ref lexical-x-691 '1))) + (lexical-ribcage-marks-395 + (lambda (lexical-x-692) (vector-ref lexical-x-692 '2))) + (lexical-ribcage-labels-396 + (lambda (lexical-x-693) (vector-ref lexical-x-693 '3))) + (lexical-set-ribcage-symnames!-397 + (lambda (lexical-x-694 lexical-update-695) + (vector-set! lexical-x-694 '1 lexical-update-695))) + (lexical-set-ribcage-marks!-398 + (lambda (lexical-x-696 lexical-update-697) + (vector-set! lexical-x-696 '2 lexical-update-697))) + (lexical-set-ribcage-labels!-399 + (lambda (lexical-x-698 lexical-update-699) + (vector-set! lexical-x-698 '3 lexical-update-699))) + (lexical-make-top-ribcage-400 + (lambda (lexical-key-700 lexical-mutable?-701) + (vector 'top-ribcage lexical-key-700 lexical-mutable?-701))) + (lexical-top-ribcage?-401 + (lambda (lexical-x-702) + (if (vector? lexical-x-702) + (if (= (vector-length lexical-x-702) '3) + (eq? (vector-ref lexical-x-702 '0) 'top-ribcage) + '#f) + '#f))) + (lexical-top-ribcage-key-402 + (lambda (lexical-x-703) (vector-ref lexical-x-703 '1))) + (lexical-top-ribcage-mutable?-403 + (lambda (lexical-x-704) (vector-ref lexical-x-704 '2))) + (lexical-set-top-ribcage-key!-404 + (lambda (lexical-x-705 lexical-update-706) + (vector-set! lexical-x-705 '1 lexical-update-706))) + (lexical-set-top-ribcage-mutable?!-405 + (lambda (lexical-x-707 lexical-update-708) + (vector-set! lexical-x-707 '2 lexical-update-708))) + (lexical-make-import-interface-406 + (lambda (lexical-interface-709 lexical-new-marks-710) + (vector + 'import-interface + lexical-interface-709 + lexical-new-marks-710))) + (lexical-import-interface?-407 + (lambda (lexical-x-711) + (if (vector? lexical-x-711) + (if (= (vector-length lexical-x-711) '3) + (eq? (vector-ref lexical-x-711 '0) 'import-interface) + '#f) + '#f))) + (lexical-import-interface-interface-408 + (lambda (lexical-x-712) (vector-ref lexical-x-712 '1))) + (lexical-import-interface-new-marks-409 + (lambda (lexical-x-713) (vector-ref lexical-x-713 '2))) + (lexical-set-import-interface-interface!-410 + (lambda (lexical-x-714 lexical-update-715) + (vector-set! lexical-x-714 '1 lexical-update-715))) + (lexical-set-import-interface-new-marks!-411 + (lambda (lexical-x-716 lexical-update-717) + (vector-set! lexical-x-716 '2 lexical-update-717))) + (lexical-make-env-412 + (lambda (lexical-top-ribcage-718 lexical-wrap-719) + (vector 'env lexical-top-ribcage-718 lexical-wrap-719))) + (lexical-env?-413 + (lambda (lexical-x-720) + (if (vector? lexical-x-720) + (if (= (vector-length lexical-x-720) '3) + (eq? (vector-ref lexical-x-720 '0) 'env) + '#f) + '#f))) + (lexical-env-top-ribcage-414 + (lambda (lexical-x-721) (vector-ref lexical-x-721 '1))) + (lexical-env-wrap-415 + (lambda (lexical-x-722) (vector-ref lexical-x-722 '2))) + (lexical-set-env-top-ribcage!-416 + (lambda (lexical-x-723 lexical-update-724) + (vector-set! lexical-x-723 '1 lexical-update-724))) + (lexical-set-env-wrap!-417 + (lambda (lexical-x-725 lexical-update-726) + (vector-set! lexical-x-725 '2 lexical-update-726))) + (lexical-anti-mark-427 + (lambda (lexical-w-727) + (lexical-make-wrap-342 + (cons '#f (lexical-wrap-marks-343 lexical-w-727)) + (cons 'shift (lexical-wrap-subst-344 lexical-w-727))))) + (lexical-barrier-marker-432 '#f) + (lexical-extend-ribcage!-437 + (lambda (lexical-ribcage-728 lexical-id-729 lexical-label-730) + (begin + (lexical-set-ribcage-symnames!-397 + lexical-ribcage-728 + (cons ((lambda (lexical-e-731) + (if (lexical-annotation?-158 lexical-e-731) + (annotation-expression lexical-e-731) + lexical-e-731)) + (lexical-syntax-object-expression-91 lexical-id-729)) + (lexical-ribcage-symnames-394 lexical-ribcage-728))) + (lexical-set-ribcage-marks!-398 + lexical-ribcage-728 + (cons (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-id-729)) + (lexical-ribcage-marks-395 lexical-ribcage-728))) + (lexical-set-ribcage-labels!-399 + lexical-ribcage-728 + (cons lexical-label-730 + (lexical-ribcage-labels-396 lexical-ribcage-728)))))) + (lexical-import-extend-ribcage!-438 + (lambda (lexical-ribcage-732 + lexical-new-marks-733 + lexical-id-734 + lexical-label-735) + (begin + (lexical-set-ribcage-symnames!-397 + lexical-ribcage-732 + (cons ((lambda (lexical-e-736) + (if (lexical-annotation?-158 lexical-e-736) + (annotation-expression lexical-e-736) + lexical-e-736)) + (lexical-syntax-object-expression-91 lexical-id-734)) + (lexical-ribcage-symnames-394 lexical-ribcage-732))) + (lexical-set-ribcage-marks!-398 + lexical-ribcage-732 + (cons (lexical-join-marks-450 + lexical-new-marks-733 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-id-734))) + (lexical-ribcage-marks-395 lexical-ribcage-732))) + (lexical-set-ribcage-labels!-399 + lexical-ribcage-732 + (cons lexical-label-735 + (lexical-ribcage-labels-396 lexical-ribcage-732)))))) + (lexical-extend-ribcage-barrier!-439 + (lambda (lexical-ribcage-737 lexical-killer-id-738) + (lexical-extend-ribcage-barrier-help!-440 + lexical-ribcage-737 + (lexical-syntax-object-wrap-92 lexical-killer-id-738)))) + (lexical-extend-ribcage-barrier-help!-440 + (lambda (lexical-ribcage-739 lexical-wrap-740) + (begin + (lexical-set-ribcage-symnames!-397 + lexical-ribcage-739 + (cons lexical-barrier-marker-432 + (lexical-ribcage-symnames-394 lexical-ribcage-739))) + (lexical-set-ribcage-marks!-398 + lexical-ribcage-739 + (cons (lexical-wrap-marks-343 lexical-wrap-740) + (lexical-ribcage-marks-395 lexical-ribcage-739)))))) + (lexical-extend-ribcage-subst!-441 + (lambda (lexical-ribcage-741 lexical-import-iface-742) + (lexical-set-ribcage-symnames!-397 + lexical-ribcage-741 + (cons lexical-import-iface-742 + (lexical-ribcage-symnames-394 lexical-ribcage-741))))) + (lexical-lookup-import-binding-name-442 + (lambda (lexical-sym-743 + lexical-marks-744 + lexical-token-745 + lexical-new-marks-746) + ((lambda (lexical-new-747) + (if lexical-new-747 + ((letrec ((lexical-f-748 + (lambda (lexical-new-749) + (if (pair? lexical-new-749) + ((lambda (lexical-t-750) + (if lexical-t-750 + lexical-t-750 + (lexical-f-748 + (cdr lexical-new-749)))) + (lexical-f-748 (car lexical-new-749))) + (if (symbol? lexical-new-749) + (if (lexical-same-marks?-452 + lexical-marks-744 + (lexical-join-marks-450 + lexical-new-marks-746 + (lexical-wrap-marks-343 + '((top))))) + lexical-new-749 + '#f) + (if (lexical-same-marks?-452 + lexical-marks-744 + (lexical-join-marks-450 + lexical-new-marks-746 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-new-749)))) + lexical-new-749 + '#f)))))) + lexical-f-748) + lexical-new-747) + '#f)) + (lexical-get-import-binding-167 + lexical-sym-743 + lexical-token-745)))) + (lexical-store-import-binding-443 + (lambda (lexical-id-751 lexical-token-752 lexical-new-marks-753) + (letrec* ((lexical-cons-id-754 + (lambda (lexical-id-756 lexical-x-757) + (if (not lexical-x-757) + lexical-id-756 + (cons lexical-id-756 lexical-x-757)))) + (lexical-weed-755 + (lambda (lexical-marks-758 lexical-x-759) + (if (pair? lexical-x-759) + (if (lexical-same-marks?-452 + (lexical-id-marks-339 + (car lexical-x-759)) + lexical-marks-758) + (lexical-weed-755 + lexical-marks-758 + (cdr lexical-x-759)) + (lexical-cons-id-754 + (car lexical-x-759) + (lexical-weed-755 + lexical-marks-758 + (cdr lexical-x-759)))) + (if lexical-x-759 + (if (not (lexical-same-marks?-452 + (lexical-id-marks-339 + lexical-x-759) + lexical-marks-758)) + lexical-x-759 + '#f) + '#f))))) + ((lambda (lexical-id-760) + ((lambda (lexical-sym-761) + (if (not (eq? lexical-id-760 lexical-sym-761)) + ((lambda (lexical-marks-762) + (lexical-update-import-binding!-168 + lexical-sym-761 + lexical-token-752 + (lambda (lexical-old-binding-763) + ((lambda (lexical-x-764) + (lexical-cons-id-754 + (if (lexical-same-marks?-452 + lexical-marks-762 + (lexical-wrap-marks-343 '((top)))) + (lexical-resolved-id-var-name-447 + lexical-id-760) + lexical-id-760) + lexical-x-764)) + (lexical-weed-755 + lexical-marks-762 + lexical-old-binding-763))))) + (lexical-id-marks-339 lexical-id-760)) + (void))) + ((lambda (lexical-x-765) + ((lambda (lexical-e-766) + (if (lexical-annotation?-158 lexical-e-766) + (annotation-expression lexical-e-766) + lexical-e-766)) + (if (lexical-syntax-object?-90 lexical-x-765) + (lexical-syntax-object-expression-91 + lexical-x-765) + lexical-x-765))) + lexical-id-760))) + (if (null? lexical-new-marks-753) + lexical-id-751 + (lexical-make-syntax-object-89 + ((lambda (lexical-x-767) + ((lambda (lexical-e-768) + (if (lexical-annotation?-158 lexical-e-768) + (annotation-expression lexical-e-768) + lexical-e-768)) + (if (lexical-syntax-object?-90 lexical-x-767) + (lexical-syntax-object-expression-91 + lexical-x-767) + lexical-x-767))) + lexical-id-751) + (lexical-make-wrap-342 + (lexical-join-marks-450 + lexical-new-marks-753 + (lexical-id-marks-339 lexical-id-751)) + (lexical-id-subst-340 lexical-id-751)))))))) + (lexical-make-binding-wrap-444 + (lambda (lexical-ids-769 lexical-labels-770 lexical-w-771) + (if (null? lexical-ids-769) + lexical-w-771 + (lexical-make-wrap-342 + (lexical-wrap-marks-343 lexical-w-771) + (cons ((lambda (lexical-labelvec-772) + ((lambda (lexical-n-773) + ((lambda (lexical-symnamevec-774 + lexical-marksvec-775) + (begin + ((letrec ((lexical-f-776 + (lambda (lexical-ids-777 + lexical-i-778) + (if (not (null? lexical-ids-777)) + (call-with-values + (lambda () + (lexical-id-sym-name&marks-341 + (car lexical-ids-777) + lexical-w-771)) + (lambda (lexical-symname-779 + lexical-marks-780) + (begin + (vector-set! + lexical-symnamevec-774 + lexical-i-778 + lexical-symname-779) + (vector-set! + lexical-marksvec-775 + lexical-i-778 + lexical-marks-780) + (lexical-f-776 + (cdr lexical-ids-777) + (+ lexical-i-778 + '1))))) + (void))))) + lexical-f-776) + lexical-ids-769 + '0) + (lexical-make-ribcage-392 + lexical-symnamevec-774 + lexical-marksvec-775 + lexical-labelvec-772))) + (make-vector lexical-n-773) + (make-vector lexical-n-773))) + (vector-length lexical-labelvec-772))) + (list->vector lexical-labels-770)) + (lexical-wrap-subst-344 lexical-w-771)))))) + (lexical-make-resolved-id-445 + (lambda (lexical-fromsym-781 lexical-marks-782 lexical-tosym-783) + (lexical-make-syntax-object-89 + lexical-fromsym-781 + (lexical-make-wrap-342 + lexical-marks-782 + (list (lexical-make-ribcage-392 + (vector lexical-fromsym-781) + (vector lexical-marks-782) + (vector lexical-tosym-783))))))) + (lexical-id->resolved-id-446 + (lambda (lexical-id-784) + (call-with-values + (lambda () + (lexical-id-var-name&marks-459 lexical-id-784 '(()))) + (lambda (lexical-tosym-785 lexical-marks-786) + (begin + (if (not lexical-tosym-785) + (syntax-error + lexical-id-784 + '"identifier not visible for export") + (void)) + (lexical-make-resolved-id-445 + ((lambda (lexical-x-787) + ((lambda (lexical-e-788) + (if (lexical-annotation?-158 lexical-e-788) + (annotation-expression lexical-e-788) + lexical-e-788)) + (if (lexical-syntax-object?-90 lexical-x-787) + (lexical-syntax-object-expression-91 + lexical-x-787) + lexical-x-787))) + lexical-id-784) + lexical-marks-786 + lexical-tosym-785)))))) + (lexical-resolved-id-var-name-447 + (lambda (lexical-id-789) + (vector-ref + (lexical-ribcage-labels-396 + (car (lexical-wrap-subst-344 + (lexical-syntax-object-wrap-92 lexical-id-789)))) + '0))) + (lexical-smart-append-448 + (lambda (lexical-m1-790 lexical-m2-791) + (if (null? lexical-m2-791) + lexical-m1-790 + (append lexical-m1-790 lexical-m2-791)))) + (lexical-join-wraps-449 + (lambda (lexical-w1-792 lexical-w2-793) + ((lambda (lexical-m1-794 lexical-s1-795) + (if (null? lexical-m1-794) + (if (null? lexical-s1-795) + lexical-w2-793 + (lexical-make-wrap-342 + (lexical-wrap-marks-343 lexical-w2-793) + (lexical-join-subst-451 + lexical-s1-795 + (lexical-wrap-subst-344 lexical-w2-793)))) + (lexical-make-wrap-342 + (lexical-join-marks-450 + lexical-m1-794 + (lexical-wrap-marks-343 lexical-w2-793)) + (lexical-join-subst-451 + lexical-s1-795 + (lexical-wrap-subst-344 lexical-w2-793))))) + (lexical-wrap-marks-343 lexical-w1-792) + (lexical-wrap-subst-344 lexical-w1-792)))) + (lexical-join-marks-450 + (lambda (lexical-m1-796 lexical-m2-797) + (lexical-smart-append-448 lexical-m1-796 lexical-m2-797))) + (lexical-join-subst-451 + (lambda (lexical-s1-798 lexical-s2-799) + (lexical-smart-append-448 lexical-s1-798 lexical-s2-799))) + (lexical-same-marks?-452 + (lambda (lexical-x-800 lexical-y-801) + ((lambda (lexical-t-802) + (if lexical-t-802 + lexical-t-802 + (if (not (null? lexical-x-800)) + (if (not (null? lexical-y-801)) + (if (eq? (car lexical-x-800) + (car lexical-y-801)) + (lexical-same-marks?-452 + (cdr lexical-x-800) + (cdr lexical-y-801)) + '#f) + '#f) + '#f))) + (eq? lexical-x-800 lexical-y-801)))) + (lexical-diff-marks-453 + (lambda (lexical-m1-803 lexical-m2-804) + ((lambda (lexical-n1-805 lexical-n2-806) + ((letrec ((lexical-f-807 + (lambda (lexical-n1-808 lexical-m1-809) + (if (> lexical-n1-808 lexical-n2-806) + (cons (car lexical-m1-809) + (lexical-f-807 + (- lexical-n1-808 '1) + (cdr lexical-m1-809))) + (if (equal? lexical-m1-809 lexical-m2-804) + '() + (error 'sc-expand + '"internal error in diff-marks: ~s is not a tail of ~s" + lexical-m1-809 + lexical-m2-804)))))) + lexical-f-807) + lexical-n1-805 + lexical-m1-803)) + (length lexical-m1-803) + (length lexical-m2-804)))) + (lexical-leave-implicit?-454 + (lambda (lexical-token-810) (eq? lexical-token-810 '*top*))) + (lexical-new-binding-455 + (lambda (lexical-sym-811 lexical-marks-812 lexical-token-813) + ((lambda (lexical-loc-814) + ((lambda (lexical-id-815) + (begin + (lexical-store-import-binding-443 + lexical-id-815 + lexical-token-813 + '()) + (values lexical-loc-814 lexical-id-815))) + (lexical-make-resolved-id-445 + lexical-sym-811 + lexical-marks-812 + lexical-loc-814))) + (if (if (lexical-leave-implicit?-454 lexical-token-813) + (lexical-same-marks?-452 + lexical-marks-812 + (lexical-wrap-marks-343 '((top)))) + '#f) + lexical-sym-811 + (lexical-generate-id-169 lexical-sym-811))))) + (lexical-top-id-bound-var-name-456 + (lambda (lexical-sym-816 + lexical-marks-817 + lexical-top-ribcage-818) + ((lambda (lexical-token-819) + ((lambda (lexical-t-820) + (if lexical-t-820 + ((lambda (lexical-id-821) + (if (symbol? lexical-id-821) + (if (lexical-read-only-binding?-166 + lexical-id-821) + (lexical-new-binding-455 + lexical-sym-816 + lexical-marks-817 + lexical-token-819) + (values + lexical-id-821 + (lexical-make-resolved-id-445 + lexical-sym-816 + lexical-marks-817 + lexical-id-821))) + (values + (lexical-resolved-id-var-name-447 + lexical-id-821) + lexical-id-821))) + lexical-t-820) + (lexical-new-binding-455 + lexical-sym-816 + lexical-marks-817 + lexical-token-819))) + (lexical-lookup-import-binding-name-442 + lexical-sym-816 + lexical-marks-817 + lexical-token-819 + '()))) + (lexical-top-ribcage-key-402 lexical-top-ribcage-818)))) + (lexical-top-id-free-var-name-457 + (lambda (lexical-sym-822 + lexical-marks-823 + lexical-top-ribcage-824) + ((lambda (lexical-token-825) + ((lambda (lexical-t-826) + (if lexical-t-826 + ((lambda (lexical-id-827) + (if (symbol? lexical-id-827) + lexical-id-827 + (lexical-resolved-id-var-name-447 + lexical-id-827))) + lexical-t-826) + (if (if (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-824) + (lexical-same-marks?-452 + lexical-marks-823 + (lexical-wrap-marks-343 '((top)))) + '#f) + (call-with-values + (lambda () + (lexical-new-binding-455 + lexical-sym-822 + (lexical-wrap-marks-343 '((top))) + lexical-token-825)) + (lambda (lexical-sym-828 lexical-id-829) + lexical-sym-828)) + '#f))) + (lexical-lookup-import-binding-name-442 + lexical-sym-822 + lexical-marks-823 + lexical-token-825 + '()))) + (lexical-top-ribcage-key-402 lexical-top-ribcage-824)))) + (lexical-id-var-name-loc&marks-458 + (lambda (lexical-id-830 lexical-w-831) + (letrec* ((lexical-search-832 + (lambda (lexical-sym-835 + lexical-subst-836 + lexical-marks-837) + (if (null? lexical-subst-836) + (values '#f lexical-marks-837) + ((lambda (lexical-fst-838) + (if (eq? lexical-fst-838 'shift) + (lexical-search-832 + lexical-sym-835 + (cdr lexical-subst-836) + (cdr lexical-marks-837)) + (if (lexical-ribcage?-393 + lexical-fst-838) + ((lambda (lexical-symnames-839) + (if (vector? + lexical-symnames-839) + (lexical-search-vector-rib-834 + lexical-sym-835 + lexical-subst-836 + lexical-marks-837 + lexical-symnames-839 + lexical-fst-838) + (lexical-search-list-rib-833 + lexical-sym-835 + lexical-subst-836 + lexical-marks-837 + lexical-symnames-839 + lexical-fst-838))) + (lexical-ribcage-symnames-394 + lexical-fst-838)) + (if (lexical-top-ribcage?-401 + lexical-fst-838) + ((lambda (lexical-t-840) + (if lexical-t-840 + ((lambda (lexical-var-name-841) + (values + lexical-var-name-841 + lexical-marks-837)) + lexical-t-840) + (lexical-search-832 + lexical-sym-835 + (cdr lexical-subst-836) + lexical-marks-837))) + (lexical-top-id-free-var-name-457 + lexical-sym-835 + lexical-marks-837 + lexical-fst-838)) + (error 'sc-expand + '"internal error in id-var-name-loc&marks: improper subst ~s" + lexical-subst-836))))) + (car lexical-subst-836))))) + (lexical-search-list-rib-833 + (lambda (lexical-sym-842 + lexical-subst-843 + lexical-marks-844 + lexical-symnames-845 + lexical-ribcage-846) + ((letrec ((lexical-f-847 + (lambda (lexical-symnames-848 + lexical-i-849) + (if (null? lexical-symnames-848) + (lexical-search-832 + lexical-sym-842 + (cdr lexical-subst-843) + lexical-marks-844) + ((lambda (lexical-x-850) + (if (if (eq? lexical-x-850 + lexical-sym-842) + (lexical-same-marks?-452 + lexical-marks-844 + (list-ref + (lexical-ribcage-marks-395 + lexical-ribcage-846) + lexical-i-849)) + '#f) + (values + (list-ref + (lexical-ribcage-labels-396 + lexical-ribcage-846) + lexical-i-849) + lexical-marks-844) + (if (lexical-import-interface?-407 + lexical-x-850) + ((lambda (lexical-iface-851 + lexical-new-marks-852) + ((lambda (lexical-t-853) + (if lexical-t-853 + ((lambda (lexical-token-854) + ((lambda (lexical-t-855) + (if lexical-t-855 + ((lambda (lexical-id-856) + (values + (if (symbol? + lexical-id-856) + lexical-id-856 + (lexical-resolved-id-var-name-447 + lexical-id-856)) + lexical-marks-844)) + lexical-t-855) + (lexical-f-847 + (cdr lexical-symnames-848) + lexical-i-849))) + (lexical-lookup-import-binding-name-442 + lexical-sym-842 + lexical-marks-844 + lexical-token-854 + lexical-new-marks-852))) + lexical-t-853) + ((lambda (lexical-ie-857) + ((lambda (lexical-n-858) + ((lambda () + ((letrec ((lexical-g-859 + (lambda (lexical-j-860) + (if (= lexical-j-860 + lexical-n-858) + (lexical-f-847 + (cdr lexical-symnames-848) + lexical-i-849) + ((lambda (lexical-id-861) + ((lambda (lexical-id.sym-862 + lexical-id.marks-863) + (if (lexical-help-bound-id=?-464 + lexical-id.sym-862 + lexical-id.marks-863 + lexical-sym-842 + lexical-marks-844) + (values + (lexical-lookup-import-label-534 + lexical-id-861) + lexical-marks-844) + (lexical-g-859 + (+ lexical-j-860 + '1)))) + ((lambda (lexical-x-864) + ((lambda (lexical-e-865) + (if (lexical-annotation?-158 + lexical-e-865) + (annotation-expression + lexical-e-865) + lexical-e-865)) + (if (lexical-syntax-object?-90 + lexical-x-864) + (lexical-syntax-object-expression-91 + lexical-x-864) + lexical-x-864))) + lexical-id-861) + (lexical-join-marks-450 + lexical-new-marks-852 + (lexical-id-marks-339 + lexical-id-861)))) + (vector-ref + lexical-ie-857 + lexical-j-860)))))) + lexical-g-859) + '0)))) + (vector-length + lexical-ie-857))) + (lexical-interface-exports-481 + lexical-iface-851)))) + (lexical-interface-token-482 + lexical-iface-851))) + (lexical-import-interface-interface-408 + lexical-x-850) + (lexical-import-interface-new-marks-409 + lexical-x-850)) + (if (if (eq? lexical-x-850 + lexical-barrier-marker-432) + (lexical-same-marks?-452 + lexical-marks-844 + (list-ref + (lexical-ribcage-marks-395 + lexical-ribcage-846) + lexical-i-849)) + '#f) + (values + '#f + lexical-marks-844) + (lexical-f-847 + (cdr lexical-symnames-848) + (+ lexical-i-849 + '1)))))) + (car lexical-symnames-848)))))) + lexical-f-847) + lexical-symnames-845 + '0))) + (lexical-search-vector-rib-834 + (lambda (lexical-sym-866 + lexical-subst-867 + lexical-marks-868 + lexical-symnames-869 + lexical-ribcage-870) + ((lambda (lexical-n-871) + ((letrec ((lexical-f-872 + (lambda (lexical-i-873) + (if (= lexical-i-873 + lexical-n-871) + (lexical-search-832 + lexical-sym-866 + (cdr lexical-subst-867) + lexical-marks-868) + (if (if (eq? (vector-ref + lexical-symnames-869 + lexical-i-873) + lexical-sym-866) + (lexical-same-marks?-452 + lexical-marks-868 + (vector-ref + (lexical-ribcage-marks-395 + lexical-ribcage-870) + lexical-i-873)) + '#f) + (values + (vector-ref + (lexical-ribcage-labels-396 + lexical-ribcage-870) + lexical-i-873) + lexical-marks-868) + (lexical-f-872 + (+ lexical-i-873 '1))))))) + lexical-f-872) + '0)) + (vector-length lexical-symnames-869))))) + (if (symbol? lexical-id-830) + (lexical-search-832 + lexical-id-830 + (lexical-wrap-subst-344 lexical-w-831) + (lexical-wrap-marks-343 lexical-w-831)) + (if (lexical-syntax-object?-90 lexical-id-830) + ((lambda (lexical-sym-874 lexical-w1-875) + (call-with-values + (lambda () + (lexical-search-832 + lexical-sym-874 + (lexical-wrap-subst-344 lexical-w-831) + (lexical-join-marks-450 + (lexical-wrap-marks-343 lexical-w-831) + (lexical-wrap-marks-343 lexical-w1-875)))) + (lambda (lexical-name-876 lexical-marks-877) + (if lexical-name-876 + (values lexical-name-876 lexical-marks-877) + (lexical-search-832 + lexical-sym-874 + (lexical-wrap-subst-344 lexical-w1-875) + lexical-marks-877))))) + ((lambda (lexical-e-878) + (if (lexical-annotation?-158 lexical-e-878) + (annotation-expression lexical-e-878) + lexical-e-878)) + (lexical-syntax-object-expression-91 + lexical-id-830)) + (lexical-syntax-object-wrap-92 lexical-id-830)) + (if (lexical-annotation?-158 lexical-id-830) + (lexical-search-832 + ((lambda (lexical-e-879) + (if (lexical-annotation?-158 lexical-e-879) + (annotation-expression lexical-e-879) + lexical-e-879)) + lexical-id-830) + (lexical-wrap-subst-344 lexical-w-831) + (lexical-wrap-marks-343 lexical-w-831)) + (lexical-error-hook-162 + 'id-var-name + '"invalid id" + lexical-id-830))))))) + (lexical-id-var-name&marks-459 + (lambda (lexical-id-880 lexical-w-881) + (call-with-values + (lambda () + (lexical-id-var-name-loc&marks-458 + lexical-id-880 + lexical-w-881)) + (lambda (lexical-label-882 lexical-marks-883) + (values + (if (lexical-indirect-label?-383 lexical-label-882) + (lexical-get-indirect-label-387 lexical-label-882) + lexical-label-882) + lexical-marks-883))))) + (lexical-id-var-name-loc-460 + (lambda (lexical-id-884 lexical-w-885) + (call-with-values + (lambda () + (lexical-id-var-name-loc&marks-458 + lexical-id-884 + lexical-w-885)) + (lambda (lexical-label-886 lexical-marks-887) + lexical-label-886)))) + (lexical-id-var-name-461 + (lambda (lexical-id-888 lexical-w-889) + (call-with-values + (lambda () + (lexical-id-var-name-loc&marks-458 + lexical-id-888 + lexical-w-889)) + (lambda (lexical-label-890 lexical-marks-891) + (if (lexical-indirect-label?-383 lexical-label-890) + (lexical-get-indirect-label-387 lexical-label-890) + lexical-label-890))))) + (lexical-free-id=?-462 + (lambda (lexical-i-892 lexical-j-893) + (if (eq? ((lambda (lexical-x-894) + ((lambda (lexical-e-895) + (if (lexical-annotation?-158 lexical-e-895) + (annotation-expression lexical-e-895) + lexical-e-895)) + (if (lexical-syntax-object?-90 lexical-x-894) + (lexical-syntax-object-expression-91 + lexical-x-894) + lexical-x-894))) + lexical-i-892) + ((lambda (lexical-x-896) + ((lambda (lexical-e-897) + (if (lexical-annotation?-158 lexical-e-897) + (annotation-expression lexical-e-897) + lexical-e-897)) + (if (lexical-syntax-object?-90 lexical-x-896) + (lexical-syntax-object-expression-91 + lexical-x-896) + lexical-x-896))) + lexical-j-893)) + (eq? (lexical-id-var-name-461 lexical-i-892 '(())) + (lexical-id-var-name-461 lexical-j-893 '(()))) + '#f))) + (lexical-literal-id=?-463 + (lambda (lexical-id-898 lexical-literal-899) + (if (eq? ((lambda (lexical-x-900) + ((lambda (lexical-e-901) + (if (lexical-annotation?-158 lexical-e-901) + (annotation-expression lexical-e-901) + lexical-e-901)) + (if (lexical-syntax-object?-90 lexical-x-900) + (lexical-syntax-object-expression-91 + lexical-x-900) + lexical-x-900))) + lexical-id-898) + ((lambda (lexical-x-902) + ((lambda (lexical-e-903) + (if (lexical-annotation?-158 lexical-e-903) + (annotation-expression lexical-e-903) + lexical-e-903)) + (if (lexical-syntax-object?-90 lexical-x-902) + (lexical-syntax-object-expression-91 + lexical-x-902) + lexical-x-902))) + lexical-literal-899)) + ((lambda (lexical-n-id-904 lexical-n-literal-905) + ((lambda (lexical-t-906) + (if lexical-t-906 + lexical-t-906 + (if ((lambda (lexical-t-907) + (if lexical-t-907 + lexical-t-907 + (symbol? lexical-n-id-904))) + (not lexical-n-id-904)) + ((lambda (lexical-t-908) + (if lexical-t-908 + lexical-t-908 + (symbol? lexical-n-literal-905))) + (not lexical-n-literal-905)) + '#f))) + (eq? lexical-n-id-904 lexical-n-literal-905))) + (lexical-id-var-name-461 lexical-id-898 '(())) + (lexical-id-var-name-461 lexical-literal-899 '(()))) + '#f))) + (lexical-help-bound-id=?-464 + (lambda (lexical-i.sym-909 + lexical-i.marks-910 + lexical-j.sym-911 + lexical-j.marks-912) + (if (eq? lexical-i.sym-909 lexical-j.sym-911) + (lexical-same-marks?-452 + lexical-i.marks-910 + lexical-j.marks-912) + '#f))) + (lexical-bound-id=?-465 + (lambda (lexical-i-913 lexical-j-914) + (lexical-help-bound-id=?-464 + ((lambda (lexical-x-915) + ((lambda (lexical-e-916) + (if (lexical-annotation?-158 lexical-e-916) + (annotation-expression lexical-e-916) + lexical-e-916)) + (if (lexical-syntax-object?-90 lexical-x-915) + (lexical-syntax-object-expression-91 lexical-x-915) + lexical-x-915))) + lexical-i-913) + (lexical-id-marks-339 lexical-i-913) + ((lambda (lexical-x-917) + ((lambda (lexical-e-918) + (if (lexical-annotation?-158 lexical-e-918) + (annotation-expression lexical-e-918) + lexical-e-918)) + (if (lexical-syntax-object?-90 lexical-x-917) + (lexical-syntax-object-expression-91 lexical-x-917) + lexical-x-917))) + lexical-j-914) + (lexical-id-marks-339 lexical-j-914)))) + (lexical-valid-bound-ids?-466 + (lambda (lexical-ids-919) + (if ((letrec ((lexical-all-ids?-920 + (lambda (lexical-ids-921) + ((lambda (lexical-t-922) + (if lexical-t-922 + lexical-t-922 + (if (lexical-id?-333 + (car lexical-ids-921)) + (lexical-all-ids?-920 + (cdr lexical-ids-921)) + '#f))) + (null? lexical-ids-921))))) + lexical-all-ids?-920) + lexical-ids-919) + (lexical-distinct-bound-ids?-467 lexical-ids-919) + '#f))) + (lexical-distinct-bound-ids?-467 + (lambda (lexical-ids-923) + ((letrec ((lexical-distinct?-924 + (lambda (lexical-ids-925) + ((lambda (lexical-t-926) + (if lexical-t-926 + lexical-t-926 + (if (not (lexical-bound-id-member?-469 + (car lexical-ids-925) + (cdr lexical-ids-925))) + (lexical-distinct?-924 + (cdr lexical-ids-925)) + '#f))) + (null? lexical-ids-925))))) + lexical-distinct?-924) + lexical-ids-923))) + (lexical-invalid-ids-error-468 + (lambda (lexical-ids-927 lexical-exp-928 lexical-class-929) + ((letrec ((lexical-find-930 + (lambda (lexical-ids-931 lexical-gooduns-932) + (if (null? lexical-ids-931) + (syntax-error lexical-exp-928) + (if (lexical-id?-333 (car lexical-ids-931)) + (if (lexical-bound-id-member?-469 + (car lexical-ids-931) + lexical-gooduns-932) + (syntax-error + (car lexical-ids-931) + '"duplicate " + lexical-class-929) + (lexical-find-930 + (cdr lexical-ids-931) + (cons (car lexical-ids-931) + lexical-gooduns-932))) + (syntax-error + (car lexical-ids-931) + '"invalid " + lexical-class-929)))))) + lexical-find-930) + lexical-ids-927 + '()))) + (lexical-bound-id-member?-469 + (lambda (lexical-x-933 lexical-list-934) + (if (not (null? lexical-list-934)) + ((lambda (lexical-t-935) + (if lexical-t-935 + lexical-t-935 + (lexical-bound-id-member?-469 + lexical-x-933 + (cdr lexical-list-934)))) + (lexical-bound-id=?-465 + lexical-x-933 + (car lexical-list-934))) + '#f))) + (lexical-wrap-470 + (lambda (lexical-x-936 lexical-w-937) + (if (if (null? (lexical-wrap-marks-343 lexical-w-937)) + (null? (lexical-wrap-subst-344 lexical-w-937)) + '#f) + lexical-x-936 + (if (lexical-syntax-object?-90 lexical-x-936) + (lexical-make-syntax-object-89 + (lexical-syntax-object-expression-91 lexical-x-936) + (lexical-join-wraps-449 + lexical-w-937 + (lexical-syntax-object-wrap-92 lexical-x-936))) + (if (null? lexical-x-936) + lexical-x-936 + (lexical-make-syntax-object-89 + lexical-x-936 + lexical-w-937)))))) + (lexical-source-wrap-471 + (lambda (lexical-x-938 lexical-w-939 lexical-ae-940) + (lexical-wrap-470 + (if (lexical-annotation?-158 lexical-ae-940) + (begin + (if (not (eq? (annotation-expression lexical-ae-940) + lexical-x-938)) + (error 'sc-expand + '"internal error in source-wrap: ae/x mismatch") + (void)) + lexical-ae-940) + lexical-x-938) + lexical-w-939))) + (lexical-chi-when-list-472 + (lambda (lexical-when-list-941 lexical-w-942) + (map (lambda (lexical-x-943) + (if (lexical-literal-id=?-463 + lexical-x-943 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + 'compile + (if (lexical-literal-id=?-463 + lexical-x-943 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + 'load + (if (lexical-literal-id=?-463 + lexical-x-943 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + 'visit + (if (lexical-literal-id=?-463 + lexical-x-943 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + 'revisit + (if (lexical-literal-id=?-463 + lexical-x-943 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + 'eval + (syntax-error + (lexical-wrap-470 + lexical-x-943 + lexical-w-942) + '"invalid eval-when situation"))))))) + lexical-when-list-941))) + (lexical-syntax-type-473 + (lambda (lexical-e-944 + lexical-r-945 + lexical-w-946 + lexical-ae-947 + lexical-rib-948) + (if (symbol? lexical-e-944) + ((lambda (lexical-n-949) + ((lambda (lexical-b-950) + ((lambda (lexical-type-951) + ((lambda () + ((lambda (lexical-t-952) + (if (memv lexical-t-952 '(macro macro!)) + (lexical-syntax-type-473 + (lexical-chi-macro-529 + (lexical-binding-value-309 + lexical-b-950) + lexical-e-944 + lexical-r-945 + lexical-w-946 + lexical-ae-947 + lexical-rib-948) + lexical-r-945 + '(()) + '#f + lexical-rib-948) + (values + lexical-type-951 + (lexical-binding-value-309 + lexical-b-950) + lexical-e-944 + lexical-w-946 + lexical-ae-947))) + lexical-type-951)))) + (lexical-binding-type-308 lexical-b-950))) + (lexical-lookup-328 lexical-n-949 lexical-r-945))) + (lexical-id-var-name-461 lexical-e-944 lexical-w-946)) + (if (pair? lexical-e-944) + ((lambda (lexical-first-953) + (if (lexical-id?-333 lexical-first-953) + ((lambda (lexical-n-954) + ((lambda (lexical-b-955) + ((lambda (lexical-type-956) + ((lambda () + ((lambda (lexical-t-957) + (if (memv lexical-t-957 + '(lexical)) + (values + 'lexical-call + (lexical-binding-value-309 + lexical-b-955) + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(macro macro!)) + (lexical-syntax-type-473 + (lexical-chi-macro-529 + (lexical-binding-value-309 + lexical-b-955) + lexical-e-944 + lexical-r-945 + lexical-w-946 + lexical-ae-947 + lexical-rib-948) + lexical-r-945 + '(()) + '#f + lexical-rib-948) + (if (memv lexical-t-957 + '(core)) + (values + lexical-type-956 + (lexical-binding-value-309 + lexical-b-955) + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(begin)) + (values + 'begin-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(alias)) + (values + 'alias-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(define)) + (values + 'define-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(define-syntax)) + (values + 'define-syntax-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(set!)) + (lexical-chi-set!-528 + lexical-e-944 + lexical-r-945 + lexical-w-946 + lexical-ae-947 + lexical-rib-948) + (if (memv lexical-t-957 + '($module-key)) + (values + '$module-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '($import)) + (values + '$import-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(eval-when)) + (values + 'eval-when-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(meta)) + (values + 'meta-form + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (if (memv lexical-t-957 + '(local-syntax)) + (values + 'local-syntax-form + (lexical-binding-value-309 + lexical-b-955) + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (values + 'call + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947))))))))))))))) + lexical-type-956)))) + (lexical-binding-type-308 lexical-b-955))) + (lexical-lookup-328 + lexical-n-954 + lexical-r-945))) + (lexical-id-var-name-461 + lexical-first-953 + lexical-w-946)) + (values + 'call + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947))) + (car lexical-e-944)) + (if (lexical-syntax-object?-90 lexical-e-944) + (lexical-syntax-type-473 + (lexical-syntax-object-expression-91 + lexical-e-944) + lexical-r-945 + (lexical-join-wraps-449 + lexical-w-946 + (lexical-syntax-object-wrap-92 lexical-e-944)) + '#f + lexical-rib-948) + (if (lexical-annotation?-158 lexical-e-944) + (lexical-syntax-type-473 + (annotation-expression lexical-e-944) + lexical-r-945 + lexical-w-946 + lexical-e-944 + lexical-rib-948) + (if ((lambda (lexical-x-958) + ((lambda (lexical-t-959) + (if lexical-t-959 + lexical-t-959 + ((lambda (lexical-t-960) + (if lexical-t-960 + lexical-t-960 + ((lambda (lexical-t-961) + (if lexical-t-961 + lexical-t-961 + ((lambda (lexical-t-962) + (if lexical-t-962 + lexical-t-962 + (null? lexical-x-958))) + (char? lexical-x-958)))) + (string? lexical-x-958)))) + (number? lexical-x-958)))) + (boolean? lexical-x-958))) + lexical-e-944) + (values + 'constant + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947) + (values + 'other + '#f + lexical-e-944 + lexical-w-946 + lexical-ae-947)))))))) + (lexical-chi-top*-474 + (lambda (lexical-e-963 + lexical-r-964 + lexical-w-965 + lexical-ctem-966 + lexical-rtem-967 + lexical-meta?-968 + lexical-top-ribcage-969) + ((lambda (lexical-meta-residuals-970) + (letrec* ((lexical-meta-residualize!-971 + (lambda (lexical-x-972) + (set! lexical-meta-residuals-970 + (cons lexical-x-972 + lexical-meta-residuals-970))))) + ((lambda (lexical-e-973) + (lexical-build-sequence-261 + '#f + (reverse + (cons lexical-e-973 lexical-meta-residuals-970)))) + (lexical-chi-top-476 + lexical-e-963 + lexical-r-964 + lexical-w-965 + lexical-ctem-966 + lexical-rtem-967 + lexical-meta?-968 + lexical-top-ribcage-969 + lexical-meta-residualize!-971 + '#f)))) + '()))) + (lexical-chi-top-sequence-475 + (lambda (lexical-body-974 + lexical-r-975 + lexical-w-976 + lexical-ae-977 + lexical-ctem-978 + lexical-rtem-979 + lexical-meta?-980 + lexical-ribcage-981 + lexical-meta-residualize!-982) + (lexical-build-sequence-261 + lexical-ae-977 + ((letrec ((lexical-dobody-983 + (lambda (lexical-body-984) + (if (null? lexical-body-984) + '() + ((lambda (lexical-first-985) + (cons lexical-first-985 + (lexical-dobody-983 + (cdr lexical-body-984)))) + (lexical-chi-top-476 + (car lexical-body-984) + lexical-r-975 + lexical-w-976 + lexical-ctem-978 + lexical-rtem-979 + lexical-meta?-980 + lexical-ribcage-981 + lexical-meta-residualize!-982 + '#f)))))) + lexical-dobody-983) + lexical-body-974)))) + (lexical-chi-top-476 + (lambda (lexical-e-986 + lexical-r-987 + lexical-w-988 + lexical-ctem-989 + lexical-rtem-990 + lexical-meta?-991 + lexical-top-ribcage-992 + lexical-meta-residualize!-993 + lexical-meta-seen?-994) + (call-with-values + (lambda () + (lexical-syntax-type-473 + lexical-e-986 + lexical-r-987 + lexical-w-988 + '#f + lexical-top-ribcage-992)) + (lambda (lexical-type-995 + lexical-value-996 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + ((lambda (lexical-t-1000) + (if (memv lexical-t-1000 '(begin-form)) + ((lambda (lexical-forms-1001) + (if (null? lexical-forms-1001) + (lexical-chi-void-546) + (lexical-chi-top-sequence-475 + lexical-forms-1001 + lexical-r-987 + lexical-w-998 + lexical-ae-999 + lexical-ctem-989 + lexical-rtem-990 + lexical-meta?-991 + lexical-top-ribcage-992 + lexical-meta-residualize!-993))) + (lexical-parse-begin-543 + lexical-e-997 + lexical-w-998 + lexical-ae-999 + '#t)) + (if (memv lexical-t-1000 '(local-syntax-form)) + (call-with-values + (lambda () + (lexical-chi-local-syntax-545 + lexical-value-996 + lexical-e-997 + lexical-r-987 + lexical-r-987 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-forms-1002 + lexical-r-1003 + lexical-mr-1004 + lexical-w-1005 + lexical-ae-1006) + (lexical-chi-top-sequence-475 + lexical-forms-1002 + lexical-r-1003 + lexical-w-1005 + lexical-ae-1006 + lexical-ctem-989 + lexical-rtem-990 + lexical-meta?-991 + lexical-top-ribcage-992 + lexical-meta-residualize!-993))) + (if (memv lexical-t-1000 '(eval-when-form)) + (call-with-values + (lambda () + (lexical-parse-eval-when-541 + lexical-e-997 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-when-list-1007 + lexical-forms-1008) + ((lambda (lexical-ctem-1009 + lexical-rtem-1010) + (if (if (null? lexical-ctem-1009) + (null? lexical-rtem-1010) + '#f) + (lexical-chi-void-546) + (lexical-chi-top-sequence-475 + lexical-forms-1008 + lexical-r-987 + lexical-w-998 + lexical-ae-999 + lexical-ctem-1009 + lexical-rtem-1010 + lexical-meta?-991 + lexical-top-ribcage-992 + lexical-meta-residualize!-993))) + (lexical-update-mode-set-517 + lexical-when-list-1007 + lexical-ctem-989) + (lexical-update-mode-set-517 + lexical-when-list-1007 + lexical-rtem-990)))) + (if (memv lexical-t-1000 '(meta-form)) + (lexical-chi-top-476 + (lexical-parse-meta-540 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + lexical-r-987 + lexical-w-998 + lexical-ctem-989 + lexical-rtem-990 + '#t + lexical-top-ribcage-992 + lexical-meta-residualize!-993 + '#t) + (if (memv lexical-t-1000 + '(define-syntax-form)) + (call-with-values + (lambda () + (lexical-parse-define-syntax-539 + lexical-e-997 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-id-1011 + lexical-rhs-1012 + lexical-w-1013) + ((lambda (lexical-id-1014) + (begin + (if (lexical-displaced-lexical?-325 + lexical-id-1014 + lexical-r-987) + (lexical-displaced-lexical-error-326 + lexical-id-1014) + (void)) + (if (not (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-992)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1013 + lexical-ae-999) + '"invalid definition in read-only environment") + (void)) + ((lambda (lexical-sym-1015) + (call-with-values + (lambda () + (lexical-top-id-bound-var-name-456 + lexical-sym-1015 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-id-1014)) + lexical-top-ribcage-992)) + (lambda (lexical-valsym-1016 + lexical-bound-id-1017) + (begin + (if (not (eq? (lexical-id-var-name-461 + lexical-id-1014 + '(())) + lexical-valsym-1016)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1013 + lexical-ae-999) + '"definition not permitted") + (void)) + (if (lexical-read-only-binding?-166 + lexical-valsym-1016) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1013 + lexical-ae-999) + '"invalid definition of read-only identifier") + (void)) + (lexical-ct-eval/residualize2-520 + lexical-ctem-989 + (lambda () + (list '$sc-put-cte + (list 'quote + lexical-bound-id-1017) + (lexical-chi-525 + lexical-rhs-1012 + lexical-r-987 + lexical-r-987 + lexical-w-1013 + '#t) + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-992))))))))) + ((lambda (lexical-x-1018) + ((lambda (lexical-e-1019) + (if (lexical-annotation?-158 + lexical-e-1019) + (annotation-expression + lexical-e-1019) + lexical-e-1019)) + (if (lexical-syntax-object?-90 + lexical-x-1018) + (lexical-syntax-object-expression-91 + lexical-x-1018) + lexical-x-1018))) + lexical-id-1014)))) + (lexical-wrap-470 + lexical-id-1011 + lexical-w-1013)))) + (if (memv lexical-t-1000 + '(define-form)) + (call-with-values + (lambda () + (lexical-parse-define-538 + lexical-e-997 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-id-1020 + lexical-rhs-1021 + lexical-w-1022) + ((lambda (lexical-id-1023) + (begin + (if (lexical-displaced-lexical?-325 + lexical-id-1023 + lexical-r-987) + (lexical-displaced-lexical-error-326 + lexical-id-1023) + (void)) + (if (not (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-992)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1022 + lexical-ae-999) + '"invalid definition in read-only environment") + (void)) + ((lambda (lexical-sym-1024) + (call-with-values + (lambda () + (lexical-top-id-bound-var-name-456 + lexical-sym-1024 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-id-1023)) + lexical-top-ribcage-992)) + (lambda (lexical-valsym-1025 + lexical-bound-id-1026) + (begin + (if (not (eq? (lexical-id-var-name-461 + lexical-id-1023 + '(())) + lexical-valsym-1025)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1022 + lexical-ae-999) + '"definition not permitted") + (void)) + (if (lexical-read-only-binding?-166 + lexical-valsym-1025) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-1022 + lexical-ae-999) + '"invalid definition of read-only identifier") + (void)) + (if lexical-meta?-991 + (lexical-ct-eval/residualize2-520 + lexical-ctem-989 + (lambda () + (lexical-build-sequence-261 + '#f + (list (list '$sc-put-cte + (list 'quote + lexical-bound-id-1026) + (list 'quote + (cons 'meta-variable + lexical-valsym-1025)) + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-992))) + (list 'define + lexical-valsym-1025 + (lexical-chi-525 + lexical-rhs-1021 + lexical-r-987 + lexical-r-987 + lexical-w-1022 + '#t)))))) + ((lambda (lexical-x-1027) + (lexical-build-sequence-261 + '#f + (list lexical-x-1027 + (lexical-rt-eval/residualize-519 + lexical-rtem-990 + (lambda () + (list 'define + lexical-valsym-1025 + (lexical-chi-525 + lexical-rhs-1021 + lexical-r-987 + lexical-r-987 + lexical-w-1022 + '#f))))))) + (lexical-ct-eval/residualize2-520 + lexical-ctem-989 + (lambda () + (list '$sc-put-cte + (list 'quote + lexical-bound-id-1026) + (list 'quote + (cons 'global + lexical-valsym-1025)) + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-992))))))))))) + ((lambda (lexical-x-1028) + ((lambda (lexical-e-1029) + (if (lexical-annotation?-158 + lexical-e-1029) + (annotation-expression + lexical-e-1029) + lexical-e-1029)) + (if (lexical-syntax-object?-90 + lexical-x-1028) + (lexical-syntax-object-expression-91 + lexical-x-1028) + lexical-x-1028))) + lexical-id-1023)))) + (lexical-wrap-470 + lexical-id-1020 + lexical-w-1022)))) + (if (memv lexical-t-1000 + '($module-form)) + ((lambda (lexical-ribcage-1030) + (call-with-values + (lambda () + (lexical-parse-module-536 + lexical-e-997 + lexical-w-998 + lexical-ae-999 + (lexical-make-wrap-342 + (lexical-wrap-marks-343 + lexical-w-998) + (cons lexical-ribcage-1030 + (lexical-wrap-subst-344 + lexical-w-998))))) + (lambda (lexical-orig-1031 + lexical-id-1032 + lexical-exports-1033 + lexical-forms-1034) + (begin + (if (lexical-displaced-lexical?-325 + lexical-id-1032 + lexical-r-987) + (lexical-displaced-lexical-error-326 + (lexical-wrap-470 + lexical-id-1032 + lexical-w-998)) + (void)) + (if (not (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-992)) + (syntax-error + lexical-orig-1031 + '"invalid definition in read-only environment") + (void)) + (lexical-chi-top-module-509 + lexical-orig-1031 + lexical-r-987 + lexical-r-987 + lexical-top-ribcage-992 + lexical-ribcage-1030 + lexical-ctem-989 + lexical-rtem-990 + lexical-meta?-991 + lexical-id-1032 + lexical-exports-1033 + lexical-forms-1034 + lexical-meta-residualize!-993))))) + (lexical-make-ribcage-392 + '() + '() + '())) + (if (memv lexical-t-1000 + '($import-form)) + (call-with-values + (lambda () + (lexical-parse-import-537 + lexical-e-997 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-orig-1035 + lexical-only?-1036 + lexical-mid-1037) + (begin + (if (not (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-992)) + (syntax-error + lexical-orig-1035 + '"invalid definition in read-only environment") + (void)) + (lexical-ct-eval/residualize2-520 + lexical-ctem-989 + (lambda () + ((lambda (lexical-binding-1038) + ((lambda (lexical-t-1039) + (if (memv lexical-t-1039 + '($module)) + (lexical-do-top-import-516 + lexical-only?-1036 + lexical-top-ribcage-992 + lexical-mid-1037 + (lexical-interface-token-482 + (lexical-binding-value-309 + lexical-binding-1038))) + (if (memv lexical-t-1039 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + lexical-mid-1037) + (syntax-error + lexical-mid-1037 + '"unknown module")))) + (lexical-binding-type-308 + lexical-binding-1038))) + (lexical-lookup-328 + (lexical-id-var-name-461 + lexical-mid-1037 + '(())) + '()))))))) + (if (memv lexical-t-1000 + '(alias-form)) + (call-with-values + (lambda () + (lexical-parse-alias-542 + lexical-e-997 + lexical-w-998 + lexical-ae-999)) + (lambda (lexical-new-id-1040 + lexical-old-id-1041) + ((lambda (lexical-new-id-1042) + (begin + (if (lexical-displaced-lexical?-325 + lexical-new-id-1042 + lexical-r-987) + (lexical-displaced-lexical-error-326 + lexical-new-id-1042) + (void)) + (if (not (lexical-top-ribcage-mutable?-403 + lexical-top-ribcage-992)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + '"invalid definition in read-only environment") + (void)) + ((lambda (lexical-sym-1043) + (call-with-values + (lambda () + (lexical-top-id-bound-var-name-456 + lexical-sym-1043 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-new-id-1042)) + lexical-top-ribcage-992)) + (lambda (lexical-valsym-1044 + lexical-bound-id-1045) + (begin + (if (not (eq? (lexical-id-var-name-461 + lexical-new-id-1042 + '(())) + lexical-valsym-1044)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + '"definition not permitted") + (void)) + (if (lexical-read-only-binding?-166 + lexical-valsym-1044) + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + '"invalid definition of read-only identifier") + (void)) + (lexical-ct-eval/residualize2-520 + lexical-ctem-989 + (lambda () + (list '$sc-put-cte + (list 'quote + (lexical-make-resolved-id-445 + lexical-sym-1043 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-new-id-1042)) + (lexical-id-var-name-461 + lexical-old-id-1041 + lexical-w-998))) + (list 'quote + '(do-alias + . + #f)) + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-992))))))))) + ((lambda (lexical-x-1046) + ((lambda (lexical-e-1047) + (if (lexical-annotation?-158 + lexical-e-1047) + (annotation-expression + lexical-e-1047) + lexical-e-1047)) + (if (lexical-syntax-object?-90 + lexical-x-1046) + (lexical-syntax-object-expression-91 + lexical-x-1046) + lexical-x-1046))) + lexical-new-id-1042)))) + (lexical-wrap-470 + lexical-new-id-1040 + lexical-w-998)))) + (begin + (if lexical-meta-seen?-994 + (syntax-error + (lexical-source-wrap-471 + lexical-e-997 + lexical-w-998 + lexical-ae-999) + '"invalid meta definition") + (void)) + (if lexical-meta?-991 + ((lambda (lexical-x-1048) + (begin + (lexical-top-level-eval-hook-159 + lexical-x-1048) + (lexical-ct-eval/residualize3-521 + lexical-ctem-989 + void + (lambda () + lexical-x-1048)))) + (lexical-chi-expr-526 + lexical-type-995 + lexical-value-996 + lexical-e-997 + lexical-r-987 + lexical-r-987 + lexical-w-998 + lexical-ae-999 + '#t)) + (lexical-rt-eval/residualize-519 + lexical-rtem-990 + (lambda () + (lexical-chi-expr-526 + lexical-type-995 + lexical-value-996 + lexical-e-997 + lexical-r-987 + lexical-r-987 + lexical-w-998 + lexical-ae-999 + '#f))))))))))))))) + lexical-type-995))))) + (lexical-flatten-exports-477 + (lambda (lexical-exports-1049) + ((letrec ((lexical-loop-1050 + (lambda (lexical-exports-1051 lexical-ls-1052) + (if (null? lexical-exports-1051) + lexical-ls-1052 + (lexical-loop-1050 + (cdr lexical-exports-1051) + (if (pair? (car lexical-exports-1051)) + (lexical-loop-1050 + (car lexical-exports-1051) + lexical-ls-1052) + (cons (car lexical-exports-1051) + lexical-ls-1052))))))) + lexical-loop-1050) + lexical-exports-1049 + '()))) + (lexical-make-interface-478 + (lambda (lexical-marks-1053 + lexical-exports-1054 + lexical-token-1055) + (vector + 'interface + lexical-marks-1053 + lexical-exports-1054 + lexical-token-1055))) + (lexical-interface?-479 + (lambda (lexical-x-1056) + (if (vector? lexical-x-1056) + (if (= (vector-length lexical-x-1056) '4) + (eq? (vector-ref lexical-x-1056 '0) 'interface) + '#f) + '#f))) + (lexical-interface-marks-480 + (lambda (lexical-x-1057) (vector-ref lexical-x-1057 '1))) + (lexical-interface-exports-481 + (lambda (lexical-x-1058) (vector-ref lexical-x-1058 '2))) + (lexical-interface-token-482 + (lambda (lexical-x-1059) (vector-ref lexical-x-1059 '3))) + (lexical-set-interface-marks!-483 + (lambda (lexical-x-1060 lexical-update-1061) + (vector-set! lexical-x-1060 '1 lexical-update-1061))) + (lexical-set-interface-exports!-484 + (lambda (lexical-x-1062 lexical-update-1063) + (vector-set! lexical-x-1062 '2 lexical-update-1063))) + (lexical-set-interface-token!-485 + (lambda (lexical-x-1064 lexical-update-1065) + (vector-set! lexical-x-1064 '3 lexical-update-1065))) + (lexical-make-unresolved-interface-486 + (lambda (lexical-mid-1066 lexical-exports-1067) + (lexical-make-interface-478 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-mid-1066)) + (list->vector + (map (lambda (lexical-x-1068) + (if (pair? lexical-x-1068) + (car lexical-x-1068) + lexical-x-1068)) + lexical-exports-1067)) + '#f))) + (lexical-make-resolved-interface-487 + (lambda (lexical-mid-1069 + lexical-exports-1070 + lexical-token-1071) + (lexical-make-interface-478 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 lexical-mid-1069)) + (list->vector + (map (lambda (lexical-x-1072) + (lexical-id->resolved-id-446 + (if (pair? lexical-x-1072) + (car lexical-x-1072) + lexical-x-1072))) + lexical-exports-1070)) + lexical-token-1071))) + (lexical-make-module-binding-488 + (lambda (lexical-type-1073 + lexical-id-1074 + lexical-label-1075 + lexical-imps-1076 + lexical-val-1077 + lexical-exported-1078) + (vector + 'module-binding + lexical-type-1073 + lexical-id-1074 + lexical-label-1075 + lexical-imps-1076 + lexical-val-1077 + lexical-exported-1078))) + (lexical-module-binding?-489 + (lambda (lexical-x-1079) + (if (vector? lexical-x-1079) + (if (= (vector-length lexical-x-1079) '7) + (eq? (vector-ref lexical-x-1079 '0) 'module-binding) + '#f) + '#f))) + (lexical-module-binding-type-490 + (lambda (lexical-x-1080) (vector-ref lexical-x-1080 '1))) + (lexical-module-binding-id-491 + (lambda (lexical-x-1081) (vector-ref lexical-x-1081 '2))) + (lexical-module-binding-label-492 + (lambda (lexical-x-1082) (vector-ref lexical-x-1082 '3))) + (lexical-module-binding-imps-493 + (lambda (lexical-x-1083) (vector-ref lexical-x-1083 '4))) + (lexical-module-binding-val-494 + (lambda (lexical-x-1084) (vector-ref lexical-x-1084 '5))) + (lexical-module-binding-exported-495 + (lambda (lexical-x-1085) (vector-ref lexical-x-1085 '6))) + (lexical-set-module-binding-type!-496 + (lambda (lexical-x-1086 lexical-update-1087) + (vector-set! lexical-x-1086 '1 lexical-update-1087))) + (lexical-set-module-binding-id!-497 + (lambda (lexical-x-1088 lexical-update-1089) + (vector-set! lexical-x-1088 '2 lexical-update-1089))) + (lexical-set-module-binding-label!-498 + (lambda (lexical-x-1090 lexical-update-1091) + (vector-set! lexical-x-1090 '3 lexical-update-1091))) + (lexical-set-module-binding-imps!-499 + (lambda (lexical-x-1092 lexical-update-1093) + (vector-set! lexical-x-1092 '4 lexical-update-1093))) + (lexical-set-module-binding-val!-500 + (lambda (lexical-x-1094 lexical-update-1095) + (vector-set! lexical-x-1094 '5 lexical-update-1095))) + (lexical-set-module-binding-exported!-501 + (lambda (lexical-x-1096 lexical-update-1097) + (vector-set! lexical-x-1096 '6 lexical-update-1097))) + (lexical-create-module-binding-502 + (lambda (lexical-type-1098 + lexical-id-1099 + lexical-label-1100 + lexical-imps-1101 + lexical-val-1102) + (lexical-make-module-binding-488 + lexical-type-1098 + lexical-id-1099 + lexical-label-1100 + lexical-imps-1101 + lexical-val-1102 + '#f))) + (lexical-make-frob-503 + (lambda (lexical-e-1103 lexical-meta?-1104) + (vector 'frob lexical-e-1103 lexical-meta?-1104))) + (lexical-frob?-504 + (lambda (lexical-x-1105) + (if (vector? lexical-x-1105) + (if (= (vector-length lexical-x-1105) '3) + (eq? (vector-ref lexical-x-1105 '0) 'frob) + '#f) + '#f))) + (lexical-frob-e-505 + (lambda (lexical-x-1106) (vector-ref lexical-x-1106 '1))) + (lexical-frob-meta?-506 + (lambda (lexical-x-1107) (vector-ref lexical-x-1107 '2))) + (lexical-set-frob-e!-507 + (lambda (lexical-x-1108 lexical-update-1109) + (vector-set! lexical-x-1108 '1 lexical-update-1109))) + (lexical-set-frob-meta?!-508 + (lambda (lexical-x-1110 lexical-update-1111) + (vector-set! lexical-x-1110 '2 lexical-update-1111))) + (lexical-chi-top-module-509 + (lambda (lexical-orig-1112 + lexical-r-1113 + lexical-mr-1114 + lexical-top-ribcage-1115 + lexical-ribcage-1116 + lexical-ctem-1117 + lexical-rtem-1118 + lexical-meta?-1119 + lexical-id-1120 + lexical-exports-1121 + lexical-forms-1122 + lexical-meta-residualize!-1123) + ((lambda (lexical-fexports-1124) + (call-with-values + (lambda () + (lexical-chi-external-513 + lexical-ribcage-1116 + lexical-orig-1112 + (map (lambda (lexical-d-1125) + (lexical-make-frob-503 + lexical-d-1125 + lexical-meta?-1119)) + lexical-forms-1122) + lexical-r-1113 + lexical-mr-1114 + lexical-ctem-1117 + lexical-exports-1121 + lexical-fexports-1124 + lexical-meta-residualize!-1123)) + (lambda (lexical-r-1126 + lexical-mr-1127 + lexical-bindings-1128 + lexical-inits-1129) + ((letrec ((lexical-process-exports-1130 + (lambda (lexical-fexports-1131 + lexical-ctdefs-1132) + (if (null? lexical-fexports-1131) + ((letrec ((lexical-process-locals-1133 + (lambda (lexical-bs-1134 + lexical-r-1135 + lexical-dts-1136 + lexical-dvs-1137 + lexical-des-1138) + (if (null? lexical-bs-1134) + ((lambda (lexical-des-1139 + lexical-inits-1140) + (lexical-build-sequence-261 + '#f + (append + (lexical-ctdefs-1132) + (list (lexical-ct-eval/residualize2-520 + lexical-ctem-1117 + (lambda () + ((lambda (lexical-sym-1141) + ((lambda (lexical-token-1142) + ((lambda (lexical-b-1143) + ((lambda () + (call-with-values + (lambda () + (lexical-top-id-bound-var-name-456 + lexical-sym-1141 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-id-1120)) + lexical-top-ribcage-1115)) + (lambda (lexical-valsym-1144 + lexical-bound-id-1145) + (begin + (if (not (eq? (lexical-id-var-name-461 + lexical-id-1120 + '(())) + lexical-valsym-1144)) + (syntax-error + lexical-orig-1112 + '"definition not permitted") + (void)) + (if (lexical-read-only-binding?-166 + lexical-valsym-1144) + (syntax-error + lexical-orig-1112 + '"invalid definition of read-only identifier") + (void)) + (list '$sc-put-cte + (list 'quote + lexical-bound-id-1145) + lexical-b-1143 + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-1115))))))))) + (list 'quote + (cons '$module + (lexical-make-resolved-interface-487 + lexical-id-1120 + lexical-exports-1121 + lexical-token-1142))))) + (lexical-generate-id-169 + lexical-sym-1141))) + ((lambda (lexical-x-1146) + ((lambda (lexical-e-1147) + (if (lexical-annotation?-158 + lexical-e-1147) + (annotation-expression + lexical-e-1147) + lexical-e-1147)) + (if (lexical-syntax-object?-90 + lexical-x-1146) + (lexical-syntax-object-expression-91 + lexical-x-1146) + lexical-x-1146))) + lexical-id-1120)))) + (lexical-rt-eval/residualize-519 + lexical-rtem-1118 + (lambda () + (lexical-build-top-module-265 + '#f + lexical-dts-1136 + lexical-dvs-1137 + lexical-des-1139 + (if (null? lexical-inits-1140) + (lexical-chi-void-546) + (lexical-build-sequence-261 + '#f + (append + lexical-inits-1140 + (list (lexical-chi-void-546)))))))))))) + (lexical-chi-frobs-522 + lexical-des-1138 + lexical-r-1135 + lexical-mr-1127 + '#f) + (lexical-chi-frobs-522 + lexical-inits-1129 + lexical-r-1135 + lexical-mr-1127 + '#f)) + ((lambda (lexical-b-1148 + lexical-bs-1149) + ((lambda (lexical-t-1150) + ((lambda (lexical-t-1151) + (if (memv lexical-t-1151 + '(define-form)) + ((lambda (lexical-label-1152) + (if (lexical-module-binding-exported-495 + lexical-b-1148) + ((lambda (lexical-var-1153) + (lexical-process-locals-1133 + lexical-bs-1149 + lexical-r-1135 + (cons 'global + lexical-dts-1136) + (cons lexical-label-1152 + lexical-dvs-1137) + (cons (lexical-module-binding-val-494 + lexical-b-1148) + lexical-des-1138))) + (lexical-module-binding-id-491 + lexical-b-1148)) + ((lambda (lexical-var-1154) + (lexical-process-locals-1133 + lexical-bs-1149 + (lexical-extend-env-322 + lexical-label-1152 + (cons 'lexical + lexical-var-1154) + lexical-r-1135) + (cons 'local + lexical-dts-1136) + (cons lexical-var-1154 + lexical-dvs-1137) + (cons (lexical-module-binding-val-494 + lexical-b-1148) + lexical-des-1138))) + (lexical-gen-var-551 + (lexical-module-binding-id-491 + lexical-b-1148))))) + (lexical-get-indirect-label-387 + (lexical-module-binding-label-492 + lexical-b-1148))) + (if (memv lexical-t-1151 + '(ctdefine-form + define-syntax-form + $module-form + alias-form)) + (lexical-process-locals-1133 + lexical-bs-1149 + lexical-r-1135 + lexical-dts-1136 + lexical-dvs-1137 + lexical-des-1138) + (error 'sc-expand-internal + '"unexpected module binding type ~s" + lexical-t-1150)))) + (lexical-module-binding-type-490 + lexical-b-1148))) + (lexical-module-binding-type-490 + lexical-b-1148))) + (car lexical-bs-1134) + (cdr lexical-bs-1134)))))) + lexical-process-locals-1133) + lexical-bindings-1128 + lexical-r-1126 + '() + '() + '()) + ((lambda (lexical-id-1155 + lexical-fexports-1156) + ((letrec ((lexical-loop-1157 + (lambda (lexical-bs-1158) + (if (null? lexical-bs-1158) + (lexical-process-exports-1130 + lexical-fexports-1156 + lexical-ctdefs-1132) + ((lambda (lexical-b-1159 + lexical-bs-1160) + (if (lexical-free-id=?-462 + (lexical-module-binding-id-491 + lexical-b-1159) + lexical-id-1155) + (if (lexical-module-binding-exported-495 + lexical-b-1159) + (lexical-process-exports-1130 + lexical-fexports-1156 + lexical-ctdefs-1132) + ((lambda (lexical-t-1161) + ((lambda (lexical-label-1162) + ((lambda (lexical-imps-1163) + ((lambda (lexical-fexports-1164) + ((lambda () + (begin + (lexical-set-module-binding-exported!-501 + lexical-b-1159 + '#t) + ((lambda (lexical-t-1165) + (if (memv lexical-t-1165 + '(define-form)) + ((lambda (lexical-sym-1166) + (begin + (lexical-set-indirect-label!-388 + lexical-label-1162 + lexical-sym-1166) + (lexical-process-exports-1130 + lexical-fexports-1164 + lexical-ctdefs-1132))) + (lexical-generate-id-169 + ((lambda (lexical-x-1167) + ((lambda (lexical-e-1168) + (if (lexical-annotation?-158 + lexical-e-1168) + (annotation-expression + lexical-e-1168) + lexical-e-1168)) + (if (lexical-syntax-object?-90 + lexical-x-1167) + (lexical-syntax-object-expression-91 + lexical-x-1167) + lexical-x-1167))) + lexical-id-1155))) + (if (memv lexical-t-1165 + '(ctdefine-form)) + ((lambda (lexical-b-1169) + (lexical-process-exports-1130 + lexical-fexports-1164 + (lambda () + ((lambda (lexical-sym-1170) + (begin + (lexical-set-indirect-label!-388 + lexical-label-1162 + lexical-sym-1170) + (cons (lexical-ct-eval/residualize3-521 + lexical-ctem-1117 + (lambda () + (lexical-put-cte-hook-163 + lexical-sym-1170 + lexical-b-1169)) + (lambda () + (list '$sc-put-cte + (list 'quote + lexical-sym-1170) + (list 'quote + lexical-b-1169) + (list 'quote + '#f)))) + (lexical-ctdefs-1132)))) + (lexical-binding-value-309 + lexical-b-1169))))) + (lexical-module-binding-val-494 + lexical-b-1159)) + (if (memv lexical-t-1165 + '(define-syntax-form)) + ((lambda (lexical-sym-1171) + (lexical-process-exports-1130 + lexical-fexports-1164 + (lambda () + ((lambda (lexical-local-label-1172) + (begin + (lexical-set-indirect-label!-388 + lexical-label-1162 + lexical-sym-1171) + (cons (lexical-ct-eval/residualize3-521 + lexical-ctem-1117 + (lambda () + (lexical-put-cte-hook-163 + lexical-sym-1171 + (car (lexical-module-binding-val-494 + lexical-b-1159)))) + (lambda () + (list '$sc-put-cte + (list 'quote + lexical-sym-1171) + (cdr (lexical-module-binding-val-494 + lexical-b-1159)) + (list 'quote + '#f)))) + (lexical-ctdefs-1132)))) + (lexical-get-indirect-label-387 + lexical-label-1162))))) + (lexical-generate-id-169 + ((lambda (lexical-x-1173) + ((lambda (lexical-e-1174) + (if (lexical-annotation?-158 + lexical-e-1174) + (annotation-expression + lexical-e-1174) + lexical-e-1174)) + (if (lexical-syntax-object?-90 + lexical-x-1173) + (lexical-syntax-object-expression-91 + lexical-x-1173) + lexical-x-1173))) + lexical-id-1155))) + (if (memv lexical-t-1165 + '($module-form)) + ((lambda (lexical-sym-1175 + lexical-exports-1176) + (lexical-process-exports-1130 + (append + (lexical-flatten-exports-477 + lexical-exports-1176) + lexical-fexports-1164) + (lambda () + (begin + (lexical-set-indirect-label!-388 + lexical-label-1162 + lexical-sym-1175) + ((lambda (lexical-rest-1177) + ((lambda (lexical-x-1178) + (cons (lexical-ct-eval/residualize3-521 + lexical-ctem-1117 + (lambda () + (lexical-put-cte-hook-163 + lexical-sym-1175 + lexical-x-1178)) + (lambda () + (list '$sc-put-cte + (list 'quote + lexical-sym-1175) + (list 'quote + lexical-x-1178) + (list 'quote + '#f)))) + lexical-rest-1177)) + (cons '$module + (lexical-make-resolved-interface-487 + lexical-id-1155 + lexical-exports-1176 + lexical-sym-1175)))) + (lexical-ctdefs-1132)))))) + (lexical-generate-id-169 + ((lambda (lexical-x-1179) + ((lambda (lexical-e-1180) + (if (lexical-annotation?-158 + lexical-e-1180) + (annotation-expression + lexical-e-1180) + lexical-e-1180)) + (if (lexical-syntax-object?-90 + lexical-x-1179) + (lexical-syntax-object-expression-91 + lexical-x-1179) + lexical-x-1179))) + lexical-id-1155)) + (lexical-module-binding-val-494 + lexical-b-1159)) + (if (memv lexical-t-1165 + '(alias-form)) + (lexical-process-exports-1130 + lexical-fexports-1164 + (lambda () + ((lambda (lexical-rest-1181) + (begin + (if (lexical-indirect-label?-383 + lexical-label-1162) + (if (not (symbol? + (lexical-get-indirect-label-387 + lexical-label-1162))) + (syntax-error + (lexical-module-binding-id-491 + lexical-b-1159) + '"unexported target of alias") + (void)) + (void)) + lexical-rest-1181)) + (lexical-ctdefs-1132)))) + (error 'sc-expand-internal + '"unexpected module binding type ~s" + lexical-t-1161))))))) + lexical-t-1161))))) + (append + lexical-imps-1163 + lexical-fexports-1156))) + (lexical-module-binding-imps-493 + lexical-b-1159))) + (lexical-module-binding-label-492 + lexical-b-1159))) + (lexical-module-binding-type-490 + lexical-b-1159))) + (lexical-loop-1157 + lexical-bs-1160))) + (car lexical-bs-1158) + (cdr lexical-bs-1158)))))) + lexical-loop-1157) + lexical-bindings-1128)) + (car lexical-fexports-1131) + (cdr lexical-fexports-1131)))))) + lexical-process-exports-1130) + lexical-fexports-1124 + (lambda () '()))))) + (lexical-flatten-exports-477 lexical-exports-1121)))) + (lexical-id-set-diff-510 + (lambda (lexical-exports-1182 lexical-defs-1183) + (if (null? lexical-exports-1182) + '() + (if (lexical-bound-id-member?-469 + (car lexical-exports-1182) + lexical-defs-1183) + (lexical-id-set-diff-510 + (cdr lexical-exports-1182) + lexical-defs-1183) + (cons (car lexical-exports-1182) + (lexical-id-set-diff-510 + (cdr lexical-exports-1182) + lexical-defs-1183)))))) + (lexical-check-module-exports-511 + (lambda (lexical-source-exp-1184 + lexical-fexports-1185 + lexical-ids-1186) + (letrec* ((lexical-defined?-1187 + (lambda (lexical-e-1188 lexical-ids-1189) + (ormap (lambda (lexical-x-1190) + (if (lexical-import-interface?-407 + lexical-x-1190) + ((lambda (lexical-x.iface-1191 + lexical-x.new-marks-1192) + ((lambda (lexical-t-1193) + (if lexical-t-1193 + ((lambda (lexical-token-1194) + (lexical-lookup-import-binding-name-442 + ((lambda (lexical-x-1195) + ((lambda (lexical-e-1196) + (if (lexical-annotation?-158 + lexical-e-1196) + (annotation-expression + lexical-e-1196) + lexical-e-1196)) + (if (lexical-syntax-object?-90 + lexical-x-1195) + (lexical-syntax-object-expression-91 + lexical-x-1195) + lexical-x-1195))) + lexical-e-1188) + (lexical-id-marks-339 + lexical-e-1188) + lexical-token-1194 + lexical-x.new-marks-1192)) + lexical-t-1193) + ((lambda (lexical-v-1197) + ((letrec ((lexical-lp-1198 + (lambda (lexical-i-1199) + (if (>= lexical-i-1199 + '0) + ((lambda (lexical-t-1200) + (if lexical-t-1200 + lexical-t-1200 + (lexical-lp-1198 + (- lexical-i-1199 + '1)))) + ((lambda (lexical-id-1201) + (lexical-help-bound-id=?-464 + ((lambda (lexical-x-1202) + ((lambda (lexical-e-1203) + (if (lexical-annotation?-158 + lexical-e-1203) + (annotation-expression + lexical-e-1203) + lexical-e-1203)) + (if (lexical-syntax-object?-90 + lexical-x-1202) + (lexical-syntax-object-expression-91 + lexical-x-1202) + lexical-x-1202))) + lexical-id-1201) + (lexical-join-marks-450 + lexical-x.new-marks-1192 + (lexical-id-marks-339 + lexical-id-1201)) + ((lambda (lexical-x-1204) + ((lambda (lexical-e-1205) + (if (lexical-annotation?-158 + lexical-e-1205) + (annotation-expression + lexical-e-1205) + lexical-e-1205)) + (if (lexical-syntax-object?-90 + lexical-x-1204) + (lexical-syntax-object-expression-91 + lexical-x-1204) + lexical-x-1204))) + lexical-e-1188) + (lexical-id-marks-339 + lexical-e-1188))) + (vector-ref + lexical-v-1197 + lexical-i-1199))) + '#f)))) + lexical-lp-1198) + (- (vector-length + lexical-v-1197) + '1))) + (lexical-interface-exports-481 + lexical-x.iface-1191)))) + (lexical-interface-token-482 + lexical-x.iface-1191))) + (lexical-import-interface-interface-408 + lexical-x-1190) + (lexical-import-interface-new-marks-409 + lexical-x-1190)) + (lexical-bound-id=?-465 + lexical-e-1188 + lexical-x-1190))) + lexical-ids-1189)))) + ((letrec ((lexical-loop-1206 + (lambda (lexical-fexports-1207 + lexical-missing-1208) + (if (null? lexical-fexports-1207) + (if (not (null? lexical-missing-1208)) + (syntax-error + (car lexical-missing-1208) + (if (= (length lexical-missing-1208) + '1) + '"missing definition for export" + '"missing definition for multiple exports, including")) + (void)) + ((lambda (lexical-e-1209 + lexical-fexports-1210) + (if (lexical-defined?-1187 + lexical-e-1209 + lexical-ids-1186) + (lexical-loop-1206 + lexical-fexports-1210 + lexical-missing-1208) + (lexical-loop-1206 + lexical-fexports-1210 + (cons lexical-e-1209 + lexical-missing-1208)))) + (car lexical-fexports-1207) + (cdr lexical-fexports-1207)))))) + lexical-loop-1206) + lexical-fexports-1185 + '())))) + (lexical-check-defined-ids-512 + (lambda (lexical-source-exp-1211 lexical-ls-1212) + (letrec* ((lexical-vfold-1213 + (lambda (lexical-v-1216 + lexical-p-1217 + lexical-cls-1218) + ((lambda (lexical-len-1219) + ((letrec ((lexical-lp-1220 + (lambda (lexical-i-1221 + lexical-cls-1222) + (if (= lexical-i-1221 + lexical-len-1219) + lexical-cls-1222 + (lexical-lp-1220 + (+ lexical-i-1221 '1) + (lexical-p-1217 + (vector-ref + lexical-v-1216 + lexical-i-1221) + lexical-cls-1222)))))) + lexical-lp-1220) + '0 + lexical-cls-1218)) + (vector-length lexical-v-1216)))) + (lexical-conflicts-1214 + (lambda (lexical-x-1223 + lexical-y-1224 + lexical-cls-1225) + (if (lexical-import-interface?-407 lexical-x-1223) + ((lambda (lexical-x.iface-1226 + lexical-x.new-marks-1227) + (if (lexical-import-interface?-407 + lexical-y-1224) + ((lambda (lexical-y.iface-1228 + lexical-y.new-marks-1229) + ((lambda (lexical-xe-1230 + lexical-ye-1231) + (if (> (vector-length + lexical-xe-1230) + (vector-length + lexical-ye-1231)) + (lexical-vfold-1213 + lexical-ye-1231 + (lambda (lexical-id-1232 + lexical-cls-1233) + (lexical-id-iface-conflicts-1215 + lexical-id-1232 + lexical-y.new-marks-1229 + lexical-x.iface-1226 + lexical-x.new-marks-1227 + lexical-cls-1233)) + lexical-cls-1225) + (lexical-vfold-1213 + lexical-xe-1230 + (lambda (lexical-id-1234 + lexical-cls-1235) + (lexical-id-iface-conflicts-1215 + lexical-id-1234 + lexical-x.new-marks-1227 + lexical-y.iface-1228 + lexical-y.new-marks-1229 + lexical-cls-1235)) + lexical-cls-1225))) + (lexical-interface-exports-481 + lexical-x.iface-1226) + (lexical-interface-exports-481 + lexical-y.iface-1228))) + (lexical-import-interface-interface-408 + lexical-y-1224) + (lexical-import-interface-new-marks-409 + lexical-y-1224)) + (lexical-id-iface-conflicts-1215 + lexical-y-1224 + '() + lexical-x.iface-1226 + lexical-x.new-marks-1227 + lexical-cls-1225))) + (lexical-import-interface-interface-408 + lexical-x-1223) + (lexical-import-interface-new-marks-409 + lexical-x-1223)) + (if (lexical-import-interface?-407 + lexical-y-1224) + ((lambda (lexical-y.iface-1236 + lexical-y.new-marks-1237) + (lexical-id-iface-conflicts-1215 + lexical-x-1223 + '() + lexical-y.iface-1236 + lexical-y.new-marks-1237 + lexical-cls-1225)) + (lexical-import-interface-interface-408 + lexical-y-1224) + (lexical-import-interface-new-marks-409 + lexical-y-1224)) + (if (lexical-bound-id=?-465 + lexical-x-1223 + lexical-y-1224) + (cons lexical-x-1223 lexical-cls-1225) + lexical-cls-1225))))) + (lexical-id-iface-conflicts-1215 + (lambda (lexical-id-1238 + lexical-id.new-marks-1239 + lexical-iface-1240 + lexical-iface.new-marks-1241 + lexical-cls-1242) + ((lambda (lexical-id.sym-1243 + lexical-id.marks-1244) + ((lambda (lexical-t-1245) + (if lexical-t-1245 + ((lambda (lexical-token-1246) + (if (lexical-lookup-import-binding-name-442 + lexical-id.sym-1243 + lexical-id.marks-1244 + lexical-token-1246 + lexical-iface.new-marks-1241) + (cons lexical-id-1238 + lexical-cls-1242) + lexical-cls-1242)) + lexical-t-1245) + (lexical-vfold-1213 + (lexical-interface-exports-481 + lexical-iface-1240) + (lambda (lexical-*id-1247 + lexical-cls-1248) + ((lambda (lexical-*id.sym-1249 + lexical-*id.marks-1250) + (if (lexical-help-bound-id=?-464 + lexical-*id.sym-1249 + lexical-*id.marks-1250 + lexical-id.sym-1243 + lexical-id.marks-1244) + (cons lexical-*id-1247 + lexical-cls-1248) + lexical-cls-1248)) + ((lambda (lexical-x-1251) + ((lambda (lexical-e-1252) + (if (lexical-annotation?-158 + lexical-e-1252) + (annotation-expression + lexical-e-1252) + lexical-e-1252)) + (if (lexical-syntax-object?-90 + lexical-x-1251) + (lexical-syntax-object-expression-91 + lexical-x-1251) + lexical-x-1251))) + lexical-*id-1247) + (lexical-join-marks-450 + lexical-iface.new-marks-1241 + (lexical-id-marks-339 + lexical-*id-1247)))) + lexical-cls-1242))) + (lexical-interface-token-482 + lexical-iface-1240))) + ((lambda (lexical-x-1253) + ((lambda (lexical-e-1254) + (if (lexical-annotation?-158 + lexical-e-1254) + (annotation-expression lexical-e-1254) + lexical-e-1254)) + (if (lexical-syntax-object?-90 + lexical-x-1253) + (lexical-syntax-object-expression-91 + lexical-x-1253) + lexical-x-1253))) + lexical-id-1238) + (lexical-join-marks-450 + lexical-id.new-marks-1239 + (lexical-id-marks-339 lexical-id-1238)))))) + (if (not (null? lexical-ls-1212)) + ((letrec ((lexical-lp-1255 + (lambda (lexical-x-1256 + lexical-ls-1257 + lexical-cls-1258) + (if (null? lexical-ls-1257) + (if (not (null? lexical-cls-1258)) + ((lambda (lexical-cls-1259) + (syntax-error + lexical-source-exp-1211 + '"duplicate definition for " + (symbol->string + (car lexical-cls-1259)) + '" in")) + (syntax-object->datum + lexical-cls-1258)) + (void)) + ((letrec ((lexical-lp2-1260 + (lambda (lexical-ls2-1261 + lexical-cls-1262) + (if (null? lexical-ls2-1261) + (lexical-lp-1255 + (car lexical-ls-1257) + (cdr lexical-ls-1257) + lexical-cls-1262) + (lexical-lp2-1260 + (cdr lexical-ls2-1261) + (lexical-conflicts-1214 + lexical-x-1256 + (car lexical-ls2-1261) + lexical-cls-1262)))))) + lexical-lp2-1260) + lexical-ls-1257 + lexical-cls-1258))))) + lexical-lp-1255) + (car lexical-ls-1212) + (cdr lexical-ls-1212) + '()) + (void))))) + (lexical-chi-external-513 + (lambda (lexical-ribcage-1263 + lexical-source-exp-1264 + lexical-body-1265 + lexical-r-1266 + lexical-mr-1267 + lexical-ctem-1268 + lexical-exports-1269 + lexical-fexports-1270 + lexical-meta-residualize!-1271) + (letrec* ((lexical-return-1272 + (lambda (lexical-r-1275 + lexical-mr-1276 + lexical-bindings-1277 + lexical-ids-1278 + lexical-inits-1279) + (begin + (lexical-check-defined-ids-512 + lexical-source-exp-1264 + lexical-ids-1278) + (lexical-check-module-exports-511 + lexical-source-exp-1264 + lexical-fexports-1270 + lexical-ids-1278) + (values + lexical-r-1275 + lexical-mr-1276 + lexical-bindings-1277 + lexical-inits-1279)))) + (lexical-get-implicit-exports-1273 + (lambda (lexical-id-1280) + ((letrec ((lexical-f-1281 + (lambda (lexical-exports-1282) + (if (null? lexical-exports-1282) + '() + (if (if (pair? (car lexical-exports-1282)) + (lexical-bound-id=?-465 + lexical-id-1280 + (caar lexical-exports-1282)) + '#f) + (lexical-flatten-exports-477 + (cdar lexical-exports-1282)) + (lexical-f-1281 + (cdr lexical-exports-1282))))))) + lexical-f-1281) + lexical-exports-1269))) + (lexical-update-imp-exports-1274 + (lambda (lexical-bindings-1283 lexical-exports-1284) + ((lambda (lexical-exports-1285) + (map (lambda (lexical-b-1286) + ((lambda (lexical-id-1287) + (if (not (lexical-bound-id-member?-469 + lexical-id-1287 + lexical-exports-1285)) + lexical-b-1286 + (lexical-create-module-binding-502 + (lexical-module-binding-type-490 + lexical-b-1286) + lexical-id-1287 + (lexical-module-binding-label-492 + lexical-b-1286) + (append + (lexical-get-implicit-exports-1273 + lexical-id-1287) + (lexical-module-binding-imps-493 + lexical-b-1286)) + (lexical-module-binding-val-494 + lexical-b-1286)))) + (lexical-module-binding-id-491 + lexical-b-1286))) + lexical-bindings-1283)) + (map (lambda (lexical-x-1288) + (if (pair? lexical-x-1288) + (car lexical-x-1288) + lexical-x-1288)) + lexical-exports-1284))))) + ((letrec ((lexical-parse-1289 + (lambda (lexical-body-1290 + lexical-r-1291 + lexical-mr-1292 + lexical-ids-1293 + lexical-bindings-1294 + lexical-inits-1295 + lexical-meta-seen?-1296) + (if (null? lexical-body-1290) + (lexical-return-1272 + lexical-r-1291 + lexical-mr-1292 + lexical-bindings-1294 + lexical-ids-1293 + lexical-inits-1295) + ((lambda (lexical-fr-1297) + ((lambda (lexical-e-1298) + ((lambda (lexical-meta?-1299) + ((lambda () + (call-with-values + (lambda () + (lexical-syntax-type-473 + lexical-e-1298 + lexical-r-1291 + '(()) + '#f + lexical-ribcage-1263)) + (lambda (lexical-type-1300 + lexical-value-1301 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304) + ((lambda (lexical-t-1305) + (if (memv lexical-t-1305 + '(define-form)) + (call-with-values + (lambda () + (lexical-parse-define-538 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-id-1306 + lexical-rhs-1307 + lexical-w-1308) + ((lambda (lexical-id-1309) + ((lambda (lexical-label-1310) + ((lambda (lexical-imps-1311) + ((lambda () + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1263 + lexical-id-1309 + lexical-label-1310) + (if lexical-meta?-1299 + ((lambda (lexical-sym-1312) + ((lambda (lexical-b-1313) + ((lambda () + ((lambda (lexical-mr-1314) + ((lambda (lexical-exp-1315) + (begin + (lexical-define-top-level-value-hook-161 + lexical-sym-1312 + (lexical-top-level-eval-hook-159 + lexical-exp-1315)) + (lexical-meta-residualize!-1271 + (lexical-ct-eval/residualize3-521 + lexical-ctem-1268 + void + (lambda () + (list 'define + lexical-sym-1312 + lexical-exp-1315)))) + (lexical-parse-1289 + (cdr lexical-body-1290) + lexical-r-1291 + lexical-mr-1314 + (cons lexical-id-1309 + lexical-ids-1293) + (cons (lexical-create-module-binding-502 + 'ctdefine-form + lexical-id-1309 + lexical-label-1310 + lexical-imps-1311 + lexical-b-1313) + lexical-bindings-1294) + lexical-inits-1295 + '#f))) + (lexical-chi-525 + lexical-rhs-1307 + lexical-mr-1314 + lexical-mr-1314 + lexical-w-1308 + '#t))) + (lexical-extend-env-322 + (lexical-get-indirect-label-387 + lexical-label-1310) + lexical-b-1313 + lexical-mr-1292))))) + (cons 'meta-variable + lexical-sym-1312))) + (lexical-generate-id-169 + ((lambda (lexical-x-1316) + ((lambda (lexical-e-1317) + (if (lexical-annotation?-158 + lexical-e-1317) + (annotation-expression + lexical-e-1317) + lexical-e-1317)) + (if (lexical-syntax-object?-90 + lexical-x-1316) + (lexical-syntax-object-expression-91 + lexical-x-1316) + lexical-x-1316))) + lexical-id-1309))) + (lexical-parse-1289 + (cdr lexical-body-1290) + lexical-r-1291 + lexical-mr-1292 + (cons lexical-id-1309 + lexical-ids-1293) + (cons (lexical-create-module-binding-502 + lexical-type-1300 + lexical-id-1309 + lexical-label-1310 + lexical-imps-1311 + (lexical-make-frob-503 + (lexical-wrap-470 + lexical-rhs-1307 + lexical-w-1308) + lexical-meta?-1299)) + lexical-bindings-1294) + lexical-inits-1295 + '#f)))))) + (lexical-get-implicit-exports-1273 + lexical-id-1309))) + (lexical-gen-indirect-label-386))) + (lexical-wrap-470 + lexical-id-1306 + lexical-w-1308)))) + (if (memv lexical-t-1305 + '(define-syntax-form)) + (call-with-values + (lambda () + (lexical-parse-define-syntax-539 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-id-1318 + lexical-rhs-1319 + lexical-w-1320) + ((lambda (lexical-id-1321) + ((lambda (lexical-label-1322) + ((lambda (lexical-imps-1323) + ((lambda (lexical-exp-1324) + ((lambda () + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1263 + lexical-id-1321 + lexical-label-1322) + ((lambda (lexical-l-1325 + lexical-b-1326) + (lexical-parse-1289 + (cdr lexical-body-1290) + (lexical-extend-env-322 + lexical-l-1325 + lexical-b-1326 + lexical-r-1291) + (lexical-extend-env-322 + lexical-l-1325 + lexical-b-1326 + lexical-mr-1292) + (cons lexical-id-1321 + lexical-ids-1293) + (cons (lexical-create-module-binding-502 + lexical-type-1300 + lexical-id-1321 + lexical-label-1322 + lexical-imps-1323 + (cons lexical-b-1326 + lexical-exp-1324)) + lexical-bindings-1294) + lexical-inits-1295 + '#f)) + (lexical-get-indirect-label-387 + lexical-label-1322) + (lexical-defer-or-eval-transformer-330 + lexical-top-level-eval-hook-159 + lexical-exp-1324)))))) + (lexical-chi-525 + lexical-rhs-1319 + lexical-mr-1292 + lexical-mr-1292 + lexical-w-1320 + '#t))) + (lexical-get-implicit-exports-1273 + lexical-id-1321))) + (lexical-gen-indirect-label-386))) + (lexical-wrap-470 + lexical-id-1318 + lexical-w-1320)))) + (if (memv lexical-t-1305 + '($module-form)) + ((lambda (lexical-*ribcage-1327) + ((lambda (lexical-*w-1328) + ((lambda () + (call-with-values + (lambda () + (lexical-parse-module-536 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304 + lexical-*w-1328)) + (lambda (lexical-orig-1329 + lexical-id-1330 + lexical-*exports-1331 + lexical-forms-1332) + (call-with-values + (lambda () + (lexical-chi-external-513 + lexical-*ribcage-1327 + lexical-orig-1329 + (map (lambda (lexical-d-1333) + (lexical-make-frob-503 + lexical-d-1333 + lexical-meta?-1299)) + lexical-forms-1332) + lexical-r-1291 + lexical-mr-1292 + lexical-ctem-1268 + lexical-*exports-1331 + (lexical-flatten-exports-477 + lexical-*exports-1331) + lexical-meta-residualize!-1271)) + (lambda (lexical-r-1334 + lexical-mr-1335 + lexical-*bindings-1336 + lexical-*inits-1337) + ((lambda (lexical-iface-1338 + lexical-bindings-1339 + lexical-inits-1340 + lexical-label-1341 + lexical-imps-1342) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1263 + lexical-id-1330 + lexical-label-1341) + ((lambda (lexical-l-1343 + lexical-b-1344) + (lexical-parse-1289 + (cdr lexical-body-1290) + (lexical-extend-env-322 + lexical-l-1343 + lexical-b-1344 + lexical-r-1334) + (lexical-extend-env-322 + lexical-l-1343 + lexical-b-1344 + lexical-mr-1335) + (cons lexical-id-1330 + lexical-ids-1293) + (cons (lexical-create-module-binding-502 + lexical-type-1300 + lexical-id-1330 + lexical-label-1341 + lexical-imps-1342 + lexical-*exports-1331) + lexical-bindings-1339) + lexical-inits-1340 + '#f)) + (lexical-get-indirect-label-387 + lexical-label-1341) + (cons '$module + lexical-iface-1338)))) + (lexical-make-unresolved-interface-486 + lexical-id-1330 + lexical-*exports-1331) + (append + lexical-*bindings-1336 + lexical-bindings-1294) + (append + lexical-inits-1295 + lexical-*inits-1337) + (lexical-gen-indirect-label-386) + (lexical-get-implicit-exports-1273 + lexical-id-1330))))))))) + (lexical-make-wrap-342 + (lexical-wrap-marks-343 + lexical-w-1303) + (cons lexical-*ribcage-1327 + (lexical-wrap-subst-344 + lexical-w-1303))))) + (lexical-make-ribcage-392 + '() + '() + '())) + (if (memv lexical-t-1305 + '($import-form)) + (call-with-values + (lambda () + (lexical-parse-import-537 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-orig-1345 + lexical-only?-1346 + lexical-mid-1347) + ((lambda (lexical-mlabel-1348) + ((lambda (lexical-binding-1349) + ((lambda (lexical-t-1350) + (if (memv lexical-t-1350 + '($module)) + ((lambda (lexical-iface-1351) + ((lambda (lexical-import-iface-1352) + ((lambda () + (begin + (if lexical-only?-1346 + (lexical-extend-ribcage-barrier!-439 + lexical-ribcage-1263 + lexical-mid-1347) + (void)) + (lexical-do-import!-535 + lexical-import-iface-1352 + lexical-ribcage-1263) + (lexical-parse-1289 + (cdr lexical-body-1290) + lexical-r-1291 + lexical-mr-1292 + (cons lexical-import-iface-1352 + lexical-ids-1293) + (lexical-update-imp-exports-1274 + lexical-bindings-1294 + (vector->list + (lexical-interface-exports-481 + lexical-iface-1351))) + lexical-inits-1295 + '#f))))) + (lexical-make-import-interface-406 + lexical-iface-1351 + (lexical-import-mark-delta-533 + lexical-mid-1347 + lexical-iface-1351)))) + (lexical-binding-value-309 + lexical-binding-1349)) + (if (memv lexical-t-1350 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + lexical-mid-1347) + (syntax-error + lexical-mid-1347 + '"unknown module")))) + (lexical-binding-type-308 + lexical-binding-1349))) + (lexical-lookup-328 + lexical-mlabel-1348 + lexical-r-1291))) + (lexical-id-var-name-461 + lexical-mid-1347 + '(()))))) + (if (memv lexical-t-1305 + '(alias-form)) + (call-with-values + (lambda () + (lexical-parse-alias-542 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-new-id-1353 + lexical-old-id-1354) + ((lambda (lexical-new-id-1355) + ((lambda (lexical-label-1356) + ((lambda (lexical-imps-1357) + ((lambda () + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1263 + lexical-new-id-1355 + lexical-label-1356) + (lexical-parse-1289 + (cdr lexical-body-1290) + lexical-r-1291 + lexical-mr-1292 + (cons lexical-new-id-1355 + lexical-ids-1293) + (cons (lexical-create-module-binding-502 + lexical-type-1300 + lexical-new-id-1355 + lexical-label-1356 + lexical-imps-1357 + '#f) + lexical-bindings-1294) + lexical-inits-1295 + '#f))))) + (lexical-get-implicit-exports-1273 + lexical-new-id-1355))) + (lexical-id-var-name-loc-460 + lexical-old-id-1354 + lexical-w-1303))) + (lexical-wrap-470 + lexical-new-id-1353 + lexical-w-1303)))) + (if (memv lexical-t-1305 + '(begin-form)) + (lexical-parse-1289 + ((letrec ((lexical-f-1358 + (lambda (lexical-forms-1359) + (if (null? lexical-forms-1359) + (cdr lexical-body-1290) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1359) + lexical-w-1303) + lexical-meta?-1299) + (lexical-f-1358 + (cdr lexical-forms-1359))))))) + lexical-f-1358) + (lexical-parse-begin-543 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304 + '#t)) + lexical-r-1291 + lexical-mr-1292 + lexical-ids-1293 + lexical-bindings-1294 + lexical-inits-1295 + '#f) + (if (memv lexical-t-1305 + '(eval-when-form)) + (call-with-values + (lambda () + (lexical-parse-eval-when-541 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-when-list-1360 + lexical-forms-1361) + (lexical-parse-1289 + (if (memq 'eval + lexical-when-list-1360) + ((letrec ((lexical-f-1362 + (lambda (lexical-forms-1363) + (if (null? lexical-forms-1363) + (cdr lexical-body-1290) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1363) + lexical-w-1303) + lexical-meta?-1299) + (lexical-f-1362 + (cdr lexical-forms-1363))))))) + lexical-f-1362) + lexical-forms-1361) + (cdr lexical-body-1290)) + lexical-r-1291 + lexical-mr-1292 + lexical-ids-1293 + lexical-bindings-1294 + lexical-inits-1295 + '#f))) + (if (memv lexical-t-1305 + '(meta-form)) + (lexical-parse-1289 + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (lexical-parse-meta-540 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304) + lexical-w-1303) + '#t) + (cdr lexical-body-1290)) + lexical-r-1291 + lexical-mr-1292 + lexical-ids-1293 + lexical-bindings-1294 + lexical-inits-1295 + '#t) + (if (memv lexical-t-1305 + '(local-syntax-form)) + (call-with-values + (lambda () + (lexical-chi-local-syntax-545 + lexical-value-1301 + lexical-e-1302 + lexical-r-1291 + lexical-mr-1292 + lexical-w-1303 + lexical-ae-1304)) + (lambda (lexical-forms-1364 + lexical-r-1365 + lexical-mr-1366 + lexical-w-1367 + lexical-ae-1368) + (lexical-parse-1289 + ((letrec ((lexical-f-1369 + (lambda (lexical-forms-1370) + (if (null? lexical-forms-1370) + (cdr lexical-body-1290) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1370) + lexical-w-1367) + lexical-meta?-1299) + (lexical-f-1369 + (cdr lexical-forms-1370))))))) + lexical-f-1369) + lexical-forms-1364) + lexical-r-1365 + lexical-mr-1366 + lexical-ids-1293 + lexical-bindings-1294 + lexical-inits-1295 + '#f))) + (begin + (if lexical-meta-seen?-1296 + (syntax-error + (lexical-source-wrap-471 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304) + '"invalid meta definition") + (void)) + ((letrec ((lexical-f-1371 + (lambda (lexical-body-1372) + (if ((lambda (lexical-t-1373) + (if lexical-t-1373 + lexical-t-1373 + (not (lexical-frob-meta?-506 + (car lexical-body-1372))))) + (null? lexical-body-1372)) + (lexical-return-1272 + lexical-r-1291 + lexical-mr-1292 + lexical-bindings-1294 + lexical-ids-1293 + (append + lexical-inits-1295 + lexical-body-1372)) + (begin + ((lambda (lexical-x-1374) + (begin + (lexical-top-level-eval-hook-159 + lexical-x-1374) + (lexical-meta-residualize!-1271 + (lexical-ct-eval/residualize3-521 + lexical-ctem-1268 + void + (lambda () + lexical-x-1374))))) + (lexical-chi-meta-frob-523 + (car lexical-body-1372) + lexical-mr-1292)) + (lexical-f-1371 + (cdr lexical-body-1372))))))) + lexical-f-1371) + (cons (lexical-make-frob-503 + (lexical-source-wrap-471 + lexical-e-1302 + lexical-w-1303 + lexical-ae-1304) + lexical-meta?-1299) + (cdr lexical-body-1290)))))))))))))) + lexical-type-1300)))))) + (lexical-frob-meta?-506 + lexical-fr-1297))) + (lexical-frob-e-505 lexical-fr-1297))) + (car lexical-body-1290)))))) + lexical-parse-1289) + lexical-body-1265 + lexical-r-1266 + lexical-mr-1267 + '() + '() + '() + '#f)))) + (lexical-vmap-514 + (lambda (lexical-fn-1375 lexical-v-1376) + ((letrec ((lexical-do-1377 + (lambda (lexical-i-1378 lexical-ls-1379) + (if (< lexical-i-1378 '0) + lexical-ls-1379 + (lexical-do-1377 + (- lexical-i-1378 '1) + (cons (lexical-fn-1375 + (vector-ref + lexical-v-1376 + lexical-i-1378)) + lexical-ls-1379)))))) + lexical-do-1377) + (- (vector-length lexical-v-1376) '1) + '()))) + (lexical-vfor-each-515 + (lambda (lexical-fn-1380 lexical-v-1381) + ((lambda (lexical-len-1382) + ((letrec ((lexical-do-1383 + (lambda (lexical-i-1384) + (if (not (= lexical-i-1384 lexical-len-1382)) + (begin + (lexical-fn-1380 + (vector-ref + lexical-v-1381 + lexical-i-1384)) + (lexical-do-1383 (+ lexical-i-1384 '1))) + (void))))) + lexical-do-1383) + '0)) + (vector-length lexical-v-1381)))) + (lexical-do-top-import-516 + (lambda (lexical-import-only?-1385 + lexical-top-ribcage-1386 + lexical-mid-1387 + lexical-token-1388) + (list '$sc-put-cte + (list 'quote lexical-mid-1387) + (list 'quote (cons 'do-import lexical-token-1388)) + (list 'quote + (lexical-top-ribcage-key-402 + lexical-top-ribcage-1386))))) + (lexical-update-mode-set-517 + ((lambda (lexical-table-1389) + (lambda (lexical-when-list-1390 lexical-mode-set-1391) + (letrec* ((lexical-remq-1392 + (lambda (lexical-x-1393 lexical-ls-1394) + (if (null? lexical-ls-1394) + '() + (if (eq? (car lexical-ls-1394) + lexical-x-1393) + (lexical-remq-1392 + lexical-x-1393 + (cdr lexical-ls-1394)) + (cons (car lexical-ls-1394) + (lexical-remq-1392 + lexical-x-1393 + (cdr lexical-ls-1394)))))))) + (lexical-remq-1392 + '- + (apply append + (map (lambda (lexical-m-1395) + ((lambda (lexical-row-1396) + (map (lambda (lexical-s-1397) + (cdr (assq lexical-s-1397 + lexical-row-1396))) + lexical-when-list-1390)) + (cdr (assq lexical-m-1395 + lexical-table-1389)))) + lexical-mode-set-1391)))))) + '((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))))) + (lexical-initial-mode-set-518 + (lambda (lexical-when-list-1398 lexical-compiling-a-file-1399) + (apply append + (map (lambda (lexical-s-1400) + (if lexical-compiling-a-file-1399 + ((lambda (lexical-t-1401) + (if (memv lexical-t-1401 '(compile)) + '(C) + (if (memv lexical-t-1401 '(load)) + '(L) + (if (memv lexical-t-1401 '(visit)) + '(V) + (if (memv lexical-t-1401 + '(revisit)) + '(R) + '()))))) + lexical-s-1400) + ((lambda (lexical-t-1402) + (if (memv lexical-t-1402 '(eval)) + '(E) + '())) + lexical-s-1400))) + lexical-when-list-1398)))) + (lexical-rt-eval/residualize-519 + (lambda (lexical-rtem-1403 lexical-thunk-1404) + (if (memq 'E lexical-rtem-1403) + (lexical-thunk-1404) + ((lambda (lexical-thunk-1405) + (if (memq 'V lexical-rtem-1403) + (if ((lambda (lexical-t-1406) + (if lexical-t-1406 + lexical-t-1406 + (memq 'R lexical-rtem-1403))) + (memq 'L lexical-rtem-1403)) + (lexical-thunk-1405) + (lexical-thunk-1405)) + (if ((lambda (lexical-t-1407) + (if lexical-t-1407 + lexical-t-1407 + (memq 'R lexical-rtem-1403))) + (memq 'L lexical-rtem-1403)) + (lexical-thunk-1405) + (lexical-chi-void-546)))) + (if (memq 'C lexical-rtem-1403) + ((lambda (lexical-x-1408) + (begin + (lexical-top-level-eval-hook-159 lexical-x-1408) + (lambda () lexical-x-1408))) + (lexical-thunk-1404)) + lexical-thunk-1404))))) + (lexical-ct-eval/residualize2-520 + (lambda (lexical-ctem-1409 lexical-thunk-1410) + ((lambda (lexical-t-1411) + (lexical-ct-eval/residualize3-521 + lexical-ctem-1409 + (lambda () + (begin + (if (not lexical-t-1411) + (set! lexical-t-1411 (lexical-thunk-1410)) + (void)) + (lexical-top-level-eval-hook-159 lexical-t-1411))) + (lambda () + ((lambda (lexical-t-1412) + (if lexical-t-1412 + lexical-t-1412 + (lexical-thunk-1410))) + lexical-t-1411)))) + '#f))) + (lexical-ct-eval/residualize3-521 + (lambda (lexical-ctem-1413 + lexical-eval-thunk-1414 + lexical-residualize-thunk-1415) + (if (memq 'E lexical-ctem-1413) + (begin (lexical-eval-thunk-1414) (lexical-chi-void-546)) + (begin + (if (memq 'C lexical-ctem-1413) + (lexical-eval-thunk-1414) + (void)) + (if (memq 'R lexical-ctem-1413) + (if ((lambda (lexical-t-1416) + (if lexical-t-1416 + lexical-t-1416 + (memq 'V lexical-ctem-1413))) + (memq 'L lexical-ctem-1413)) + (lexical-residualize-thunk-1415) + (lexical-residualize-thunk-1415)) + (if ((lambda (lexical-t-1417) + (if lexical-t-1417 + lexical-t-1417 + (memq 'V lexical-ctem-1413))) + (memq 'L lexical-ctem-1413)) + (lexical-residualize-thunk-1415) + (lexical-chi-void-546))))))) + (lexical-chi-frobs-522 + (lambda (lexical-frob*-1418 + lexical-r-1419 + lexical-mr-1420 + lexical-m?-1421) + (map (lambda (lexical-x-1422) + (lexical-chi-525 + (lexical-frob-e-505 lexical-x-1422) + lexical-r-1419 + lexical-mr-1420 + '(()) + lexical-m?-1421)) + lexical-frob*-1418))) + (lexical-chi-meta-frob-523 + (lambda (lexical-x-1423 lexical-mr-1424) + (lexical-chi-525 + (lexical-frob-e-505 lexical-x-1423) + lexical-mr-1424 + lexical-mr-1424 + '(()) + '#t))) + (lexical-chi-sequence-524 + (lambda (lexical-body-1425 + lexical-r-1426 + lexical-mr-1427 + lexical-w-1428 + lexical-ae-1429 + lexical-m?-1430) + (lexical-build-sequence-261 + lexical-ae-1429 + ((letrec ((lexical-dobody-1431 + (lambda (lexical-body-1432) + (if (null? lexical-body-1432) + '() + ((lambda (lexical-first-1433) + (cons lexical-first-1433 + (lexical-dobody-1431 + (cdr lexical-body-1432)))) + (lexical-chi-525 + (car lexical-body-1432) + lexical-r-1426 + lexical-mr-1427 + lexical-w-1428 + lexical-m?-1430)))))) + lexical-dobody-1431) + lexical-body-1425)))) + (lexical-chi-525 + (lambda (lexical-e-1434 + lexical-r-1435 + lexical-mr-1436 + lexical-w-1437 + lexical-m?-1438) + (call-with-values + (lambda () + (lexical-syntax-type-473 + lexical-e-1434 + lexical-r-1435 + lexical-w-1437 + '#f + '#f)) + (lambda (lexical-type-1439 + lexical-value-1440 + lexical-e-1441 + lexical-w-1442 + lexical-ae-1443) + (lexical-chi-expr-526 + lexical-type-1439 + lexical-value-1440 + lexical-e-1441 + lexical-r-1435 + lexical-mr-1436 + lexical-w-1442 + lexical-ae-1443 + lexical-m?-1438))))) + (lexical-chi-expr-526 + (lambda (lexical-type-1444 + lexical-value-1445 + lexical-e-1446 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + ((lambda (lexical-t-1452) + (if (memv lexical-t-1452 '(lexical)) + lexical-value-1445 + (if (memv lexical-t-1452 '(core)) + (lexical-value-1445 + lexical-e-1446 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + (if (memv lexical-t-1452 '(lexical-call)) + (lexical-chi-application-527 + lexical-value-1445 + lexical-e-1446 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + (if (memv lexical-t-1452 '(constant)) + (list 'quote + (lexical-strip-550 + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '(()))) + (if (memv lexical-t-1452 '(global)) + lexical-value-1445 + (if (memv lexical-t-1452 + '(meta-variable)) + (if lexical-m?-1451 + lexical-value-1445 + (lexical-displaced-lexical-error-326 + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450))) + (if (memv lexical-t-1452 '(call)) + (lexical-chi-application-527 + (lexical-chi-525 + (car lexical-e-1446) + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-m?-1451) + lexical-e-1446 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + (if (memv lexical-t-1452 + '(begin-form)) + (lexical-chi-sequence-524 + (lexical-parse-begin-543 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450 + '#f) + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + (if (memv lexical-t-1452 + '(local-syntax-form)) + (call-with-values + (lambda () + (lexical-chi-local-syntax-545 + lexical-value-1445 + lexical-e-1446 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450)) + (lambda (lexical-forms-1453 + lexical-r-1454 + lexical-mr-1455 + lexical-w-1456 + lexical-ae-1457) + (lexical-chi-sequence-524 + lexical-forms-1453 + lexical-r-1454 + lexical-mr-1455 + lexical-w-1456 + lexical-ae-1457 + lexical-m?-1451))) + (if (memv lexical-t-1452 + '(eval-when-form)) + (call-with-values + (lambda () + (lexical-parse-eval-when-541 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450)) + (lambda (lexical-when-list-1458 + lexical-forms-1459) + (if (memq 'eval + lexical-when-list-1458) + (lexical-chi-sequence-524 + lexical-forms-1459 + lexical-r-1447 + lexical-mr-1448 + lexical-w-1449 + lexical-ae-1450 + lexical-m?-1451) + (lexical-chi-void-546)))) + (if (memv lexical-t-1452 + '(meta-form)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '"invalid context for meta definition") + (if (memv lexical-t-1452 + '(define-form)) + (begin + (lexical-parse-define-538 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '"invalid context for definition")) + (if (memv lexical-t-1452 + '(define-syntax-form)) + (begin + (lexical-parse-define-syntax-539 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '"invalid context for definition")) + (if (memv lexical-t-1452 + '($module-form)) + (call-with-values + (lambda () + (lexical-parse-module-536 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450 + lexical-w-1449)) + (lambda (lexical-orig-1460 + lexical-id-1461 + lexical-exports-1462 + lexical-forms-1463) + (syntax-error + lexical-orig-1460 + '"invalid context for definition"))) + (if (memv lexical-t-1452 + '($import-form)) + (call-with-values + (lambda () + (lexical-parse-import-537 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450)) + (lambda (lexical-orig-1464 + lexical-only?-1465 + lexical-mid-1466) + (syntax-error + lexical-orig-1464 + '"invalid context for definition"))) + (if (memv lexical-t-1452 + '(alias-form)) + (begin + (lexical-parse-alias-542 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '"invalid context for definition")) + (if (memv lexical-t-1452 + '(syntax)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450) + '"reference to pattern variable outside syntax form") + (if (memv lexical-t-1452 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1446 + lexical-w-1449 + lexical-ae-1450))))))))))))))))))))) + lexical-type-1444))) + (lexical-chi-application-527 + (lambda (lexical-x-1467 + lexical-e-1468 + lexical-r-1469 + lexical-mr-1470 + lexical-w-1471 + lexical-ae-1472 + lexical-m?-1473) + ((lambda (lexical-tmp-1474) + ((lambda (lexical-tmp-1475) + (if lexical-tmp-1475 + (apply (lambda (lexical-e0-1476 lexical-e1-1477) + (cons lexical-x-1467 + (map (lambda (lexical-e-1478) + (lexical-chi-525 + lexical-e-1478 + lexical-r-1469 + lexical-mr-1470 + lexical-w-1471 + lexical-m?-1473)) + lexical-e1-1477))) + lexical-tmp-1475) + ((lambda (lexical-_-1480) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1468 + lexical-w-1471 + lexical-ae-1472))) + lexical-tmp-1474))) + ($syntax-dispatch lexical-tmp-1474 '(any . each-any)))) + lexical-e-1468))) + (lexical-chi-set!-528 + (lambda (lexical-e-1481 + lexical-r-1482 + lexical-w-1483 + lexical-ae-1484 + lexical-rib-1485) + ((lambda (lexical-tmp-1486) + ((lambda (lexical-tmp-1487) + (if (if lexical-tmp-1487 + (apply (lambda (lexical-_-1488 + lexical-id-1489 + lexical-val-1490) + (lexical-id?-333 lexical-id-1489)) + lexical-tmp-1487) + '#f) + (apply (lambda (lexical-_-1491 + lexical-id-1492 + lexical-val-1493) + ((lambda (lexical-n-1494) + ((lambda (lexical-b-1495) + ((lambda (lexical-t-1496) + (if (memv lexical-t-1496 '(macro!)) + ((lambda (lexical-id-1497 + lexical-val-1498) + (lexical-syntax-type-473 + (lexical-chi-macro-529 + (lexical-binding-value-309 + lexical-b-1495) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-id-1497 + lexical-val-1498) + lexical-r-1482 + '(()) + '#f + lexical-rib-1485) + lexical-r-1482 + '(()) + '#f + lexical-rib-1485)) + (lexical-wrap-470 + lexical-id-1492 + lexical-w-1483) + (lexical-wrap-470 + lexical-val-1493 + lexical-w-1483)) + (values + 'core + (lambda (lexical-e-1499 + lexical-r-1500 + lexical-mr-1501 + lexical-w-1502 + lexical-ae-1503 + lexical-m?-1504) + ((lambda (lexical-val-1505 + lexical-n-1506) + ((lambda (lexical-b-1507) + ((lambda (lexical-t-1508) + (if (memv lexical-t-1508 + '(lexical)) + (list 'set! + (lexical-binding-value-309 + lexical-b-1507) + lexical-val-1505) + (if (memv lexical-t-1508 + '(global)) + ((lambda (lexical-sym-1509) + (begin + (if (lexical-read-only-binding?-166 + lexical-n-1506) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1499 + lexical-w-1502 + lexical-ae-1503) + '"invalid assignment to read-only variable") + (void)) + (list 'set! + lexical-sym-1509 + lexical-val-1505))) + (lexical-binding-value-309 + lexical-b-1507)) + (if (memv lexical-t-1508 + '(meta-variable)) + (if lexical-m?-1504 + (list 'set! + (lexical-binding-value-309 + lexical-b-1507) + lexical-val-1505) + (lexical-displaced-lexical-error-326 + (lexical-wrap-470 + lexical-id-1492 + lexical-w-1502))) + (if (memv lexical-t-1508 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + (lexical-wrap-470 + lexical-id-1492 + lexical-w-1502)) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1499 + lexical-w-1502 + lexical-ae-1503))))))) + (lexical-binding-type-308 + lexical-b-1507))) + (lexical-lookup-328 + lexical-n-1506 + lexical-r-1500))) + (lexical-chi-525 + lexical-val-1493 + lexical-r-1500 + lexical-mr-1501 + lexical-w-1502 + lexical-m?-1504) + (lexical-id-var-name-461 + lexical-id-1492 + lexical-w-1502))) + lexical-e-1481 + lexical-w-1483 + lexical-ae-1484))) + (lexical-binding-type-308 + lexical-b-1495))) + (lexical-lookup-328 + lexical-n-1494 + lexical-r-1482))) + (lexical-id-var-name-461 + lexical-id-1492 + lexical-w-1483))) + lexical-tmp-1487) + ((lambda (lexical-_-1510) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1481 + lexical-w-1483 + lexical-ae-1484))) + lexical-tmp-1486))) + ($syntax-dispatch lexical-tmp-1486 '(any any any)))) + lexical-e-1481))) + (lexical-chi-macro-529 + (lambda (lexical-p-1511 + lexical-e-1512 + lexical-r-1513 + lexical-w-1514 + lexical-ae-1515 + lexical-rib-1516) + (letrec* ((lexical-rebuild-macro-output-1517 + (lambda (lexical-x-1518 lexical-m-1519) + (if (pair? lexical-x-1518) + (cons (lexical-rebuild-macro-output-1517 + (car lexical-x-1518) + lexical-m-1519) + (lexical-rebuild-macro-output-1517 + (cdr lexical-x-1518) + lexical-m-1519)) + (if (lexical-syntax-object?-90 lexical-x-1518) + ((lambda (lexical-w-1520) + ((lambda (lexical-ms-1521 + lexical-s-1522) + (lexical-make-syntax-object-89 + (lexical-syntax-object-expression-91 + lexical-x-1518) + (if (if (pair? lexical-ms-1521) + (eq? (car lexical-ms-1521) + '#f) + '#f) + (lexical-make-wrap-342 + (cdr lexical-ms-1521) + (cdr lexical-s-1522)) + (lexical-make-wrap-342 + (cons lexical-m-1519 + lexical-ms-1521) + (if lexical-rib-1516 + (cons lexical-rib-1516 + (cons 'shift + lexical-s-1522)) + (cons 'shift + lexical-s-1522)))))) + (lexical-wrap-marks-343 + lexical-w-1520) + (lexical-wrap-subst-344 + lexical-w-1520))) + (lexical-syntax-object-wrap-92 + lexical-x-1518)) + (if (vector? lexical-x-1518) + ((lambda (lexical-n-1523) + ((lambda (lexical-v-1524) + ((lambda () + ((letrec ((lexical-do-1525 + (lambda (lexical-i-1526) + (if (= lexical-i-1526 + lexical-n-1523) + lexical-v-1524 + (begin + (vector-set! + lexical-v-1524 + lexical-i-1526 + (lexical-rebuild-macro-output-1517 + (vector-ref + lexical-x-1518 + lexical-i-1526) + lexical-m-1519)) + (lexical-do-1525 + (+ lexical-i-1526 + '1))))))) + lexical-do-1525) + '0)))) + (make-vector lexical-n-1523))) + (vector-length lexical-x-1518)) + (if (symbol? lexical-x-1518) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1512 + lexical-w-1514 + lexical-ae-1515) + '"encountered raw symbol " + (symbol->string lexical-x-1518) + '" in output of macro") + lexical-x-1518))))))) + (lexical-rebuild-macro-output-1517 + (lexical-call-or-value-530 + (lexical-p-1511 + (lexical-source-wrap-471 + lexical-e-1512 + (lexical-anti-mark-427 lexical-w-1514) + lexical-ae-1515)) + (lambda (lexical-id-1527) + (begin + (if (not (identifier? lexical-id-1527)) + (syntax-error + lexical-id-1527 + '"environment argument is not an identifier") + (void)) + (lexical-lookup-328 + (lexical-id-var-name-461 lexical-id-1527 '(())) + lexical-r-1513)))) + (string '#\m))))) + (lexical-call-or-value-530 + (lambda (lexical-p/v-1528 lexical-arg-1529) + (if (procedure? lexical-p/v-1528) + (lexical-p/v-1528 lexical-arg-1529) + lexical-p/v-1528))) + (lexical-chi-body-531 + (lambda (lexical-body-1530 + lexical-outer-form-1531 + lexical-r-1532 + lexical-mr-1533 + lexical-w-1534 + lexical-m?-1535) + ((lambda (lexical-ribcage-1536) + ((lambda (lexical-w-1537) + ((lambda (lexical-body-1538) + ((lambda () + (call-with-values + (lambda () + (lexical-chi-internal-532 + lexical-ribcage-1536 + lexical-outer-form-1531 + lexical-body-1538 + lexical-r-1532 + lexical-mr-1533 + lexical-m?-1535)) + (lambda (lexical-r-1539 + lexical-mr-1540 + lexical-exprs-1541 + lexical-ids-1542 + lexical-vars-1543 + lexical-vals-1544 + lexical-inits-1545) + (begin + (if (null? lexical-exprs-1541) + (syntax-error + lexical-outer-form-1531 + '"no expressions in body") + (void)) + (lexical-build-body-264 + '#f + (reverse lexical-vars-1543) + (lexical-chi-frobs-522 + (reverse lexical-vals-1544) + lexical-r-1539 + lexical-mr-1540 + lexical-m?-1535) + (lexical-build-sequence-261 + '#f + (lexical-chi-frobs-522 + (append + lexical-inits-1545 + lexical-exprs-1541) + lexical-r-1539 + lexical-mr-1540 + lexical-m?-1535))))))))) + (map (lambda (lexical-x-1546) + (lexical-make-frob-503 + (lexical-wrap-470 lexical-x-1546 lexical-w-1537) + '#f)) + lexical-body-1530))) + (lexical-make-wrap-342 + (lexical-wrap-marks-343 lexical-w-1534) + (cons lexical-ribcage-1536 + (lexical-wrap-subst-344 lexical-w-1534))))) + (lexical-make-ribcage-392 '() '() '())))) + (lexical-chi-internal-532 + (lambda (lexical-ribcage-1547 + lexical-source-exp-1548 + lexical-body-1549 + lexical-r-1550 + lexical-mr-1551 + lexical-m?-1552) + (letrec* ((lexical-return-1553 + (lambda (lexical-r-1554 + lexical-mr-1555 + lexical-exprs-1556 + lexical-ids-1557 + lexical-vars-1558 + lexical-vals-1559 + lexical-inits-1560) + (begin + (lexical-check-defined-ids-512 + lexical-source-exp-1548 + lexical-ids-1557) + (values + lexical-r-1554 + lexical-mr-1555 + lexical-exprs-1556 + lexical-ids-1557 + lexical-vars-1558 + lexical-vals-1559 + lexical-inits-1560))))) + ((letrec ((lexical-parse-1561 + (lambda (lexical-body-1562 + lexical-r-1563 + lexical-mr-1564 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + lexical-meta-seen?-1569) + (if (null? lexical-body-1562) + (lexical-return-1553 + lexical-r-1563 + lexical-mr-1564 + lexical-body-1562 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568) + ((lambda (lexical-fr-1570) + ((lambda (lexical-e-1571) + ((lambda (lexical-meta?-1572) + ((lambda () + (call-with-values + (lambda () + (lexical-syntax-type-473 + lexical-e-1571 + lexical-r-1563 + '(()) + '#f + lexical-ribcage-1547)) + (lambda (lexical-type-1573 + lexical-value-1574 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577) + ((lambda (lexical-t-1578) + (if (memv lexical-t-1578 + '(define-form)) + (call-with-values + (lambda () + (lexical-parse-define-538 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-id-1579 + lexical-rhs-1580 + lexical-w-1581) + ((lambda (lexical-id-1582 + lexical-label-1583) + (if lexical-meta?-1572 + ((lambda (lexical-sym-1584) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1547 + lexical-id-1582 + lexical-label-1583) + ((lambda (lexical-mr-1585) + (begin + (lexical-define-top-level-value-hook-161 + lexical-sym-1584 + (lexical-top-level-eval-hook-159 + (lexical-chi-525 + lexical-rhs-1580 + lexical-mr-1585 + lexical-mr-1585 + lexical-w-1581 + '#t))) + (lexical-parse-1561 + (cdr lexical-body-1562) + lexical-r-1563 + lexical-mr-1585 + (cons lexical-id-1582 + lexical-ids-1565) + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f))) + (lexical-extend-env-322 + lexical-label-1583 + (cons 'meta-variable + lexical-sym-1584) + lexical-mr-1564)))) + (lexical-generate-id-169 + ((lambda (lexical-x-1586) + ((lambda (lexical-e-1587) + (if (lexical-annotation?-158 + lexical-e-1587) + (annotation-expression + lexical-e-1587) + lexical-e-1587)) + (if (lexical-syntax-object?-90 + lexical-x-1586) + (lexical-syntax-object-expression-91 + lexical-x-1586) + lexical-x-1586))) + lexical-id-1582))) + ((lambda (lexical-var-1588) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1547 + lexical-id-1582 + lexical-label-1583) + (lexical-parse-1561 + (cdr lexical-body-1562) + (lexical-extend-env-322 + lexical-label-1583 + (cons 'lexical + lexical-var-1588) + lexical-r-1563) + lexical-mr-1564 + (cons lexical-id-1582 + lexical-ids-1565) + (cons lexical-var-1588 + lexical-vars-1566) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + lexical-rhs-1580 + lexical-w-1581) + lexical-meta?-1572) + lexical-vals-1567) + lexical-inits-1568 + '#f))) + (lexical-gen-var-551 + lexical-id-1582)))) + (lexical-wrap-470 + lexical-id-1579 + lexical-w-1581) + (lexical-gen-label-389)))) + (if (memv lexical-t-1578 + '(define-syntax-form)) + (call-with-values + (lambda () + (lexical-parse-define-syntax-539 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-id-1589 + lexical-rhs-1590 + lexical-w-1591) + ((lambda (lexical-id-1592 + lexical-label-1593 + lexical-exp-1594) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1547 + lexical-id-1592 + lexical-label-1593) + ((lambda (lexical-b-1595) + (lexical-parse-1561 + (cdr lexical-body-1562) + (lexical-extend-env-322 + lexical-label-1593 + lexical-b-1595 + lexical-r-1563) + (lexical-extend-env-322 + lexical-label-1593 + lexical-b-1595 + lexical-mr-1564) + (cons lexical-id-1592 + lexical-ids-1565) + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f)) + (lexical-defer-or-eval-transformer-330 + lexical-local-eval-hook-160 + lexical-exp-1594)))) + (lexical-wrap-470 + lexical-id-1589 + lexical-w-1591) + (lexical-gen-label-389) + (lexical-chi-525 + lexical-rhs-1590 + lexical-mr-1564 + lexical-mr-1564 + lexical-w-1591 + '#t)))) + (if (memv lexical-t-1578 + '($module-form)) + ((lambda (lexical-*ribcage-1596) + ((lambda (lexical-*w-1597) + ((lambda () + (call-with-values + (lambda () + (lexical-parse-module-536 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577 + lexical-*w-1597)) + (lambda (lexical-orig-1598 + lexical-id-1599 + lexical-exports-1600 + lexical-forms-1601) + (call-with-values + (lambda () + (lexical-chi-internal-532 + lexical-*ribcage-1596 + lexical-orig-1598 + (map (lambda (lexical-d-1602) + (lexical-make-frob-503 + lexical-d-1602 + lexical-meta?-1572)) + lexical-forms-1601) + lexical-r-1563 + lexical-mr-1564 + lexical-m?-1552)) + (lambda (lexical-r-1603 + lexical-mr-1604 + lexical-*body-1605 + lexical-*ids-1606 + lexical-*vars-1607 + lexical-*vals-1608 + lexical-*inits-1609) + (begin + (lexical-check-module-exports-511 + lexical-source-exp-1548 + (lexical-flatten-exports-477 + lexical-exports-1600) + lexical-*ids-1606) + ((lambda (lexical-iface-1610 + lexical-vars-1611 + lexical-vals-1612 + lexical-inits-1613 + lexical-label-1614) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1547 + lexical-id-1599 + lexical-label-1614) + ((lambda (lexical-b-1615) + (lexical-parse-1561 + (cdr lexical-body-1562) + (lexical-extend-env-322 + lexical-label-1614 + lexical-b-1615 + lexical-r-1603) + (lexical-extend-env-322 + lexical-label-1614 + lexical-b-1615 + lexical-mr-1604) + (cons lexical-id-1599 + lexical-ids-1565) + lexical-vars-1611 + lexical-vals-1612 + lexical-inits-1613 + '#f)) + (cons '$module + lexical-iface-1610)))) + (lexical-make-resolved-interface-487 + lexical-id-1599 + lexical-exports-1600 + '#f) + (append + lexical-*vars-1607 + lexical-vars-1566) + (append + lexical-*vals-1608 + lexical-vals-1567) + (append + lexical-inits-1568 + lexical-*inits-1609 + lexical-*body-1605) + (lexical-gen-label-389)))))))))) + (lexical-make-wrap-342 + (lexical-wrap-marks-343 + lexical-w-1576) + (cons lexical-*ribcage-1596 + (lexical-wrap-subst-344 + lexical-w-1576))))) + (lexical-make-ribcage-392 + '() + '() + '())) + (if (memv lexical-t-1578 + '($import-form)) + (call-with-values + (lambda () + (lexical-parse-import-537 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-orig-1616 + lexical-only?-1617 + lexical-mid-1618) + ((lambda (lexical-mlabel-1619) + ((lambda (lexical-binding-1620) + ((lambda (lexical-t-1621) + (if (memv lexical-t-1621 + '($module)) + ((lambda (lexical-iface-1622) + ((lambda (lexical-import-iface-1623) + ((lambda () + (begin + (if lexical-only?-1617 + (lexical-extend-ribcage-barrier!-439 + lexical-ribcage-1547 + lexical-mid-1618) + (void)) + (lexical-do-import!-535 + lexical-import-iface-1623 + lexical-ribcage-1547) + (lexical-parse-1561 + (cdr lexical-body-1562) + lexical-r-1563 + lexical-mr-1564 + (cons lexical-import-iface-1623 + lexical-ids-1565) + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f))))) + (lexical-make-import-interface-406 + lexical-iface-1622 + (lexical-import-mark-delta-533 + lexical-mid-1618 + lexical-iface-1622)))) + (lexical-binding-value-309 + lexical-binding-1620)) + (if (memv lexical-t-1621 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + lexical-mid-1618) + (syntax-error + lexical-mid-1618 + '"unknown module")))) + (lexical-binding-type-308 + lexical-binding-1620))) + (lexical-lookup-328 + lexical-mlabel-1619 + lexical-r-1563))) + (lexical-id-var-name-461 + lexical-mid-1618 + '(()))))) + (if (memv lexical-t-1578 + '(alias-form)) + (call-with-values + (lambda () + (lexical-parse-alias-542 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-new-id-1624 + lexical-old-id-1625) + ((lambda (lexical-new-id-1626) + (begin + (lexical-extend-ribcage!-437 + lexical-ribcage-1547 + lexical-new-id-1626 + (lexical-id-var-name-loc-460 + lexical-old-id-1625 + lexical-w-1576)) + (lexical-parse-1561 + (cdr lexical-body-1562) + lexical-r-1563 + lexical-mr-1564 + (cons lexical-new-id-1626 + lexical-ids-1565) + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f))) + (lexical-wrap-470 + lexical-new-id-1624 + lexical-w-1576)))) + (if (memv lexical-t-1578 + '(begin-form)) + (lexical-parse-1561 + ((letrec ((lexical-f-1627 + (lambda (lexical-forms-1628) + (if (null? lexical-forms-1628) + (cdr lexical-body-1562) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1628) + lexical-w-1576) + lexical-meta?-1572) + (lexical-f-1627 + (cdr lexical-forms-1628))))))) + lexical-f-1627) + (lexical-parse-begin-543 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577 + '#t)) + lexical-r-1563 + lexical-mr-1564 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f) + (if (memv lexical-t-1578 + '(eval-when-form)) + (call-with-values + (lambda () + (lexical-parse-eval-when-541 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-when-list-1629 + lexical-forms-1630) + (lexical-parse-1561 + (if (memq 'eval + lexical-when-list-1629) + ((letrec ((lexical-f-1631 + (lambda (lexical-forms-1632) + (if (null? lexical-forms-1632) + (cdr lexical-body-1562) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1632) + lexical-w-1576) + lexical-meta?-1572) + (lexical-f-1631 + (cdr lexical-forms-1632))))))) + lexical-f-1631) + lexical-forms-1630) + (cdr lexical-body-1562)) + lexical-r-1563 + lexical-mr-1564 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f))) + (if (memv lexical-t-1578 + '(meta-form)) + (lexical-parse-1561 + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (lexical-parse-meta-540 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577) + lexical-w-1576) + '#t) + (cdr lexical-body-1562)) + lexical-r-1563 + lexical-mr-1564 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#t) + (if (memv lexical-t-1578 + '(local-syntax-form)) + (call-with-values + (lambda () + (lexical-chi-local-syntax-545 + lexical-value-1574 + lexical-e-1575 + lexical-r-1563 + lexical-mr-1564 + lexical-w-1576 + lexical-ae-1577)) + (lambda (lexical-forms-1633 + lexical-r-1634 + lexical-mr-1635 + lexical-w-1636 + lexical-ae-1637) + (lexical-parse-1561 + ((letrec ((lexical-f-1638 + (lambda (lexical-forms-1639) + (if (null? lexical-forms-1639) + (cdr lexical-body-1562) + (cons (lexical-make-frob-503 + (lexical-wrap-470 + (car lexical-forms-1639) + lexical-w-1636) + lexical-meta?-1572) + (lexical-f-1638 + (cdr lexical-forms-1639))))))) + lexical-f-1638) + lexical-forms-1633) + lexical-r-1634 + lexical-mr-1635 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568 + '#f))) + (begin + (if lexical-meta-seen?-1569 + (syntax-error + (lexical-source-wrap-471 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577) + '"invalid meta definition") + (void)) + ((letrec ((lexical-f-1640 + (lambda (lexical-body-1641) + (if ((lambda (lexical-t-1642) + (if lexical-t-1642 + lexical-t-1642 + (not (lexical-frob-meta?-506 + (car lexical-body-1641))))) + (null? lexical-body-1641)) + (lexical-return-1553 + lexical-r-1563 + lexical-mr-1564 + lexical-body-1641 + lexical-ids-1565 + lexical-vars-1566 + lexical-vals-1567 + lexical-inits-1568) + (begin + (lexical-top-level-eval-hook-159 + (lexical-chi-meta-frob-523 + (car lexical-body-1641) + lexical-mr-1564)) + (lexical-f-1640 + (cdr lexical-body-1641))))))) + lexical-f-1640) + (cons (lexical-make-frob-503 + (lexical-source-wrap-471 + lexical-e-1575 + lexical-w-1576 + lexical-ae-1577) + lexical-meta?-1572) + (cdr lexical-body-1562)))))))))))))) + lexical-type-1573)))))) + (lexical-frob-meta?-506 + lexical-fr-1570))) + (lexical-frob-e-505 lexical-fr-1570))) + (car lexical-body-1562)))))) + lexical-parse-1561) + lexical-body-1549 + lexical-r-1550 + lexical-mr-1551 + '() + '() + '() + '() + '#f)))) + (lexical-import-mark-delta-533 + (lambda (lexical-mid-1643 lexical-iface-1644) + (lexical-diff-marks-453 + (lexical-id-marks-339 lexical-mid-1643) + (lexical-interface-marks-480 lexical-iface-1644)))) + (lexical-lookup-import-label-534 + (lambda (lexical-id-1645) + ((lambda (lexical-label-1646) + (begin + (if (not lexical-label-1646) + (syntax-error + lexical-id-1645 + '"exported identifier not visible") + (void)) + lexical-label-1646)) + (lexical-id-var-name-loc-460 lexical-id-1645 '(()))))) + (lexical-do-import!-535 + (lambda (lexical-import-iface-1647 lexical-ribcage-1648) + ((lambda (lexical-ie-1649) + (if (<= (vector-length lexical-ie-1649) '20) + ((lambda (lexical-new-marks-1650) + (lexical-vfor-each-515 + (lambda (lexical-id-1651) + (lexical-import-extend-ribcage!-438 + lexical-ribcage-1648 + lexical-new-marks-1650 + lexical-id-1651 + (lexical-lookup-import-label-534 lexical-id-1651))) + lexical-ie-1649)) + (lexical-import-interface-new-marks-409 + lexical-import-iface-1647)) + (lexical-extend-ribcage-subst!-441 + lexical-ribcage-1648 + lexical-import-iface-1647))) + (lexical-interface-exports-481 + (lexical-import-interface-interface-408 + lexical-import-iface-1647))))) + (lexical-parse-module-536 + (lambda (lexical-e-1652 + lexical-w-1653 + lexical-ae-1654 + lexical-*w-1655) + (letrec* ((lexical-listify-1656 + (lambda (lexical-exports-1657) + (if (null? lexical-exports-1657) + '() + (cons ((lambda (lexical-tmp-1658) + ((lambda (lexical-tmp-1659) + (if lexical-tmp-1659 + (apply (lambda (lexical-ex-1660) + (lexical-listify-1656 + lexical-ex-1660)) + lexical-tmp-1659) + ((lambda (lexical-x-1662) + (if (lexical-id?-333 + lexical-x-1662) + (lexical-wrap-470 + lexical-x-1662 + lexical-*w-1655) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1652 + lexical-w-1653 + lexical-ae-1654) + '"invalid exports list in"))) + lexical-tmp-1658))) + ($syntax-dispatch + lexical-tmp-1658 + 'each-any))) + (car lexical-exports-1657)) + (lexical-listify-1656 + (cdr lexical-exports-1657))))))) + ((lambda (lexical-tmp-1663) + ((lambda (lexical-tmp-1664) + (if (if lexical-tmp-1664 + (apply (lambda (lexical-_-1665 + lexical-orig-1666 + lexical-mid-1667 + lexical-ex-1668 + lexical-form-1669) + (lexical-id?-333 lexical-mid-1667)) + lexical-tmp-1664) + '#f) + (apply (lambda (lexical-_-1670 + lexical-orig-1671 + lexical-mid-1672 + lexical-ex-1673 + lexical-form-1674) + (values + lexical-orig-1671 + (lexical-wrap-470 + lexical-mid-1672 + lexical-w-1653) + (lexical-listify-1656 lexical-ex-1673) + (map (lambda (lexical-x-1676) + (lexical-wrap-470 + lexical-x-1676 + lexical-*w-1655)) + lexical-form-1674))) + lexical-tmp-1664) + ((lambda (lexical-_-1678) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1652 + lexical-w-1653 + lexical-ae-1654))) + lexical-tmp-1663))) + ($syntax-dispatch + lexical-tmp-1663 + '(any any any each-any . each-any)))) + lexical-e-1652)))) + (lexical-parse-import-537 + (lambda (lexical-e-1679 lexical-w-1680 lexical-ae-1681) + ((lambda (lexical-tmp-1682) + ((lambda (lexical-tmp-1683) + (if (if lexical-tmp-1683 + (apply (lambda (lexical-_-1684 + lexical-orig-1685 + lexical-mid-1686) + (lexical-id?-333 lexical-mid-1686)) + lexical-tmp-1683) + '#f) + (apply (lambda (lexical-_-1687 + lexical-orig-1688 + lexical-mid-1689) + (values + lexical-orig-1688 + '#t + (lexical-wrap-470 + lexical-mid-1689 + lexical-w-1680))) + lexical-tmp-1683) + ((lambda (lexical-tmp-1690) + (if (if lexical-tmp-1690 + (apply (lambda (lexical-_-1691 + lexical-orig-1692 + lexical-mid-1693) + (lexical-id?-333 + lexical-mid-1693)) + lexical-tmp-1690) + '#f) + (apply (lambda (lexical-_-1694 + lexical-orig-1695 + lexical-mid-1696) + (values + lexical-orig-1695 + '#f + (lexical-wrap-470 + lexical-mid-1696 + lexical-w-1680))) + lexical-tmp-1690) + ((lambda (lexical-_-1697) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1679 + lexical-w-1680 + lexical-ae-1681))) + lexical-tmp-1682))) + ($syntax-dispatch + lexical-tmp-1682 + '(any any #(atom #f) any))))) + ($syntax-dispatch + lexical-tmp-1682 + '(any any #(atom #t) any)))) + lexical-e-1679))) + (lexical-parse-define-538 + (lambda (lexical-e-1698 lexical-w-1699 lexical-ae-1700) + ((lambda (lexical-tmp-1701) + ((lambda (lexical-tmp-1702) + (if (if lexical-tmp-1702 + (apply (lambda (lexical-_-1703 + lexical-name-1704 + lexical-val-1705) + (lexical-id?-333 lexical-name-1704)) + lexical-tmp-1702) + '#f) + (apply (lambda (lexical-_-1706 + lexical-name-1707 + lexical-val-1708) + (values + lexical-name-1707 + lexical-val-1708 + lexical-w-1699)) + lexical-tmp-1702) + ((lambda (lexical-tmp-1709) + (if (if lexical-tmp-1709 + (apply (lambda (lexical-_-1710 + lexical-name-1711 + lexical-args-1712 + lexical-e1-1713 + lexical-e2-1714) + (if (lexical-id?-333 + lexical-name-1711) + (lexical-valid-bound-ids?-466 + (lexical-lambda-var-list-552 + lexical-args-1712)) + '#f)) + lexical-tmp-1709) + '#f) + (apply (lambda (lexical-_-1715 + lexical-name-1716 + lexical-args-1717 + lexical-e1-1718 + lexical-e2-1719) + (values + (lexical-wrap-470 + lexical-name-1716 + lexical-w-1699) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t))) + (lexical-wrap-470 + (cons lexical-args-1717 + (cons lexical-e1-1718 + lexical-e2-1719)) + lexical-w-1699)) + '(()))) + lexical-tmp-1709) + ((lambda (lexical-tmp-1721) + (if (if lexical-tmp-1721 + (apply (lambda (lexical-_-1722 + lexical-name-1723) + (lexical-id?-333 + lexical-name-1723)) + lexical-tmp-1721) + '#f) + (apply (lambda (lexical-_-1724 + lexical-name-1725) + (values + (lexical-wrap-470 + lexical-name-1725 + lexical-w-1699) + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t))) + '(()))) + lexical-tmp-1721) + ((lambda (lexical-_-1726) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1698 + lexical-w-1699 + lexical-ae-1700))) + lexical-tmp-1701))) + ($syntax-dispatch + lexical-tmp-1701 + '(any any))))) + ($syntax-dispatch + lexical-tmp-1701 + '(any (any . any) any . each-any))))) + ($syntax-dispatch lexical-tmp-1701 '(any any any)))) + lexical-e-1698))) + (lexical-parse-define-syntax-539 + (lambda (lexical-e-1727 lexical-w-1728 lexical-ae-1729) + ((lambda (lexical-tmp-1730) + ((lambda (lexical-tmp-1731) + (if (if lexical-tmp-1731 + (apply (lambda (lexical-_-1732 + lexical-name-1733 + lexical-id-1734 + lexical-e1-1735 + lexical-e2-1736) + (if (lexical-id?-333 lexical-name-1733) + (lexical-id?-333 lexical-id-1734) + '#f)) + lexical-tmp-1731) + '#f) + (apply (lambda (lexical-_-1737 + lexical-name-1738 + lexical-id-1739 + lexical-e1-1740 + lexical-e2-1741) + (values + (lexical-wrap-470 + lexical-name-1738 + lexical-w-1728) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t))) + (cons (lexical-wrap-470 + (list lexical-id-1739) + lexical-w-1728) + (lexical-wrap-470 + (cons lexical-e1-1740 + lexical-e2-1741) + lexical-w-1728))) + '(()))) + lexical-tmp-1731) + ((lambda (lexical-tmp-1743) + (if (if lexical-tmp-1743 + (apply (lambda (lexical-_-1744 + lexical-name-1745 + lexical-val-1746) + (lexical-id?-333 + lexical-name-1745)) + lexical-tmp-1743) + '#f) + (apply (lambda (lexical-_-1747 + lexical-name-1748 + lexical-val-1749) + (values + lexical-name-1748 + lexical-val-1749 + lexical-w-1728)) + lexical-tmp-1743) + ((lambda (lexical-_-1750) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1727 + lexical-w-1728 + lexical-ae-1729))) + lexical-tmp-1730))) + ($syntax-dispatch lexical-tmp-1730 '(any any any))))) + ($syntax-dispatch + lexical-tmp-1730 + '(any (any any) any . each-any)))) + lexical-e-1727))) + (lexical-parse-meta-540 + (lambda (lexical-e-1751 lexical-w-1752 lexical-ae-1753) + ((lambda (lexical-tmp-1754) + ((lambda (lexical-tmp-1755) + (if lexical-tmp-1755 + (apply (lambda (lexical-_-1756 lexical-form-1757) + lexical-form-1757) + lexical-tmp-1755) + ((lambda (lexical-_-1758) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1751 + lexical-w-1752 + lexical-ae-1753))) + lexical-tmp-1754))) + ($syntax-dispatch lexical-tmp-1754 '(any . any)))) + lexical-e-1751))) + (lexical-parse-eval-when-541 + (lambda (lexical-e-1759 lexical-w-1760 lexical-ae-1761) + ((lambda (lexical-tmp-1762) + ((lambda (lexical-tmp-1763) + (if lexical-tmp-1763 + (apply (lambda (lexical-_-1764 + lexical-x-1765 + lexical-e1-1766 + lexical-e2-1767) + (values + (lexical-chi-when-list-472 + lexical-x-1765 + lexical-w-1760) + (cons lexical-e1-1766 lexical-e2-1767))) + lexical-tmp-1763) + ((lambda (lexical-_-1770) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1759 + lexical-w-1760 + lexical-ae-1761))) + lexical-tmp-1762))) + ($syntax-dispatch + lexical-tmp-1762 + '(any each-any any . each-any)))) + lexical-e-1759))) + (lexical-parse-alias-542 + (lambda (lexical-e-1771 lexical-w-1772 lexical-ae-1773) + ((lambda (lexical-tmp-1774) + ((lambda (lexical-tmp-1775) + (if (if lexical-tmp-1775 + (apply (lambda (lexical-_-1776 + lexical-new-id-1777 + lexical-old-id-1778) + (if (lexical-id?-333 + lexical-new-id-1777) + (lexical-id?-333 + lexical-old-id-1778) + '#f)) + lexical-tmp-1775) + '#f) + (apply (lambda (lexical-_-1779 + lexical-new-id-1780 + lexical-old-id-1781) + (values + lexical-new-id-1780 + lexical-old-id-1781)) + lexical-tmp-1775) + ((lambda (lexical-_-1782) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1771 + lexical-w-1772 + lexical-ae-1773))) + lexical-tmp-1774))) + ($syntax-dispatch lexical-tmp-1774 '(any any any)))) + lexical-e-1771))) + (lexical-parse-begin-543 + (lambda (lexical-e-1783 + lexical-w-1784 + lexical-ae-1785 + lexical-empty-okay?-1786) + ((lambda (lexical-tmp-1787) + ((lambda (lexical-tmp-1788) + (if (if lexical-tmp-1788 + (apply (lambda (lexical-_-1789) + lexical-empty-okay?-1786) + lexical-tmp-1788) + '#f) + (apply (lambda (lexical-_-1790) '()) + lexical-tmp-1788) + ((lambda (lexical-tmp-1791) + (if lexical-tmp-1791 + (apply (lambda (lexical-_-1792 + lexical-e1-1793 + lexical-e2-1794) + (cons lexical-e1-1793 + lexical-e2-1794)) + lexical-tmp-1791) + ((lambda (lexical-_-1796) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1783 + lexical-w-1784 + lexical-ae-1785))) + lexical-tmp-1787))) + ($syntax-dispatch + lexical-tmp-1787 + '(any any . each-any))))) + ($syntax-dispatch lexical-tmp-1787 '(any)))) + lexical-e-1783))) + (lexical-chi-lambda-clause-544 + (lambda (lexical-e-1797 + lexical-c-1798 + lexical-r-1799 + lexical-mr-1800 + lexical-w-1801 + lexical-m?-1802) + ((lambda (lexical-tmp-1803) + ((lambda (lexical-tmp-1804) + (if lexical-tmp-1804 + (apply (lambda (lexical-id-1805 + lexical-e1-1806 + lexical-e2-1807) + ((lambda (lexical-ids-1808) + (if (not (lexical-valid-bound-ids?-466 + lexical-ids-1808)) + (syntax-error + lexical-e-1797 + '"invalid parameter list in") + ((lambda (lexical-labels-1809 + lexical-new-vars-1810) + (values + lexical-new-vars-1810 + (lexical-chi-body-531 + (cons lexical-e1-1806 + lexical-e2-1807) + lexical-e-1797 + (lexical-extend-var-env*-324 + lexical-labels-1809 + lexical-new-vars-1810 + lexical-r-1799) + lexical-mr-1800 + (lexical-make-binding-wrap-444 + lexical-ids-1808 + lexical-labels-1809 + lexical-w-1801) + lexical-m?-1802))) + (lexical-gen-labels-391 + lexical-ids-1808) + (map lexical-gen-var-551 + lexical-ids-1808)))) + lexical-id-1805)) + lexical-tmp-1804) + ((lambda (lexical-tmp-1813) + (if lexical-tmp-1813 + (apply (lambda (lexical-ids-1814 + lexical-e1-1815 + lexical-e2-1816) + ((lambda (lexical-old-ids-1817) + (if (not (lexical-valid-bound-ids?-466 + lexical-old-ids-1817)) + (syntax-error + lexical-e-1797 + '"invalid parameter list in") + ((lambda (lexical-labels-1818 + lexical-new-vars-1819) + (values + ((letrec ((lexical-f-1820 + (lambda (lexical-ls1-1821 + lexical-ls2-1822) + (if (null? lexical-ls1-1821) + lexical-ls2-1822 + (lexical-f-1820 + (cdr lexical-ls1-1821) + (cons (car lexical-ls1-1821) + lexical-ls2-1822)))))) + lexical-f-1820) + (cdr lexical-new-vars-1819) + (car lexical-new-vars-1819)) + (lexical-chi-body-531 + (cons lexical-e1-1815 + lexical-e2-1816) + lexical-e-1797 + (lexical-extend-var-env*-324 + lexical-labels-1818 + lexical-new-vars-1819 + lexical-r-1799) + lexical-mr-1800 + (lexical-make-binding-wrap-444 + lexical-old-ids-1817 + lexical-labels-1818 + lexical-w-1801) + lexical-m?-1802))) + (lexical-gen-labels-391 + lexical-old-ids-1817) + (map lexical-gen-var-551 + lexical-old-ids-1817)))) + (lexical-lambda-var-list-552 + lexical-ids-1814))) + lexical-tmp-1813) + ((lambda (lexical-_-1824) + (syntax-error lexical-e-1797)) + lexical-tmp-1803))) + ($syntax-dispatch + lexical-tmp-1803 + '(any any . each-any))))) + ($syntax-dispatch + lexical-tmp-1803 + '(each-any any . each-any)))) + lexical-c-1798))) + (lexical-chi-local-syntax-545 + (lambda (lexical-rec?-1825 + lexical-e-1826 + lexical-r-1827 + lexical-mr-1828 + lexical-w-1829 + lexical-ae-1830) + ((lambda (lexical-tmp-1831) + ((lambda (lexical-tmp-1832) + (if lexical-tmp-1832 + (apply (lambda (lexical-_-1833 + lexical-id-1834 + lexical-val-1835 + lexical-e1-1836 + lexical-e2-1837) + ((lambda (lexical-ids-1838) + (if (not (lexical-valid-bound-ids?-466 + lexical-ids-1838)) + (lexical-invalid-ids-error-468 + (map (lambda (lexical-x-1839) + (lexical-wrap-470 + lexical-x-1839 + lexical-w-1829)) + lexical-ids-1838) + (lexical-source-wrap-471 + lexical-e-1826 + lexical-w-1829 + lexical-ae-1830) + '"keyword") + ((lambda (lexical-labels-1840) + ((lambda (lexical-new-w-1841) + ((lambda (lexical-b*-1842) + (values + (cons lexical-e1-1836 + lexical-e2-1837) + (lexical-extend-env*-323 + lexical-labels-1840 + lexical-b*-1842 + lexical-r-1827) + (lexical-extend-env*-323 + lexical-labels-1840 + lexical-b*-1842 + lexical-mr-1828) + lexical-new-w-1841 + lexical-ae-1830)) + ((lambda (lexical-w-1844) + (map (lambda (lexical-x-1845) + (lexical-defer-or-eval-transformer-330 + lexical-local-eval-hook-160 + (lexical-chi-525 + lexical-x-1845 + lexical-mr-1828 + lexical-mr-1828 + lexical-w-1844 + '#t))) + lexical-val-1835)) + (if lexical-rec?-1825 + lexical-new-w-1841 + lexical-w-1829)))) + (lexical-make-binding-wrap-444 + lexical-ids-1838 + lexical-labels-1840 + lexical-w-1829))) + (lexical-gen-labels-391 + lexical-ids-1838)))) + lexical-id-1834)) + lexical-tmp-1832) + ((lambda (lexical-_-1848) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1826 + lexical-w-1829 + lexical-ae-1830))) + lexical-tmp-1831))) + ($syntax-dispatch + lexical-tmp-1831 + '(any #(each (any any)) any . each-any)))) + lexical-e-1826))) + (lexical-chi-void-546 (lambda () (cons 'void '()))) + (lexical-ellipsis?-547 + (lambda (lexical-x-1849) + (if (lexical-nonsymbol-id?-332 lexical-x-1849) + (lexical-literal-id=?-463 + lexical-x-1849 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage *top* #t)))) + '#f))) + (lexical-strip-annotation-548 + (lambda (lexical-x-1850) + (if (pair? lexical-x-1850) + (cons (lexical-strip-annotation-548 (car lexical-x-1850)) + (lexical-strip-annotation-548 (cdr lexical-x-1850))) + (if (lexical-annotation?-158 lexical-x-1850) + (annotation-stripped lexical-x-1850) + lexical-x-1850)))) + (lexical-strip*-549 + (lambda (lexical-x-1851 lexical-w-1852 lexical-fn-1853) + (if (memq 'top (lexical-wrap-marks-343 lexical-w-1852)) + (lexical-fn-1853 lexical-x-1851) + ((letrec ((lexical-f-1854 + (lambda (lexical-x-1855) + (if (lexical-syntax-object?-90 lexical-x-1855) + (lexical-strip*-549 + (lexical-syntax-object-expression-91 + lexical-x-1855) + (lexical-syntax-object-wrap-92 + lexical-x-1855) + lexical-fn-1853) + (if (pair? lexical-x-1855) + ((lambda (lexical-a-1856 + lexical-d-1857) + (if (if (eq? lexical-a-1856 + (car lexical-x-1855)) + (eq? lexical-d-1857 + (cdr lexical-x-1855)) + '#f) + lexical-x-1855 + (cons lexical-a-1856 + lexical-d-1857))) + (lexical-f-1854 (car lexical-x-1855)) + (lexical-f-1854 (cdr lexical-x-1855))) + (if (vector? lexical-x-1855) + ((lambda (lexical-old-1858) + ((lambda (lexical-new-1859) + (if (andmap + eq? + lexical-old-1858 + lexical-new-1859) + lexical-x-1855 + (list->vector + lexical-new-1859))) + (map lexical-f-1854 + lexical-old-1858))) + (vector->list lexical-x-1855)) + lexical-x-1855)))))) + lexical-f-1854) + lexical-x-1851)))) + (lexical-strip-550 + (lambda (lexical-x-1860 lexical-w-1861) + (lexical-strip*-549 + lexical-x-1860 + lexical-w-1861 + (lambda (lexical-x-1862) + (if ((lambda (lexical-t-1863) + (if lexical-t-1863 + lexical-t-1863 + (if (pair? lexical-x-1862) + (lexical-annotation?-158 + (car lexical-x-1862)) + '#f))) + (lexical-annotation?-158 lexical-x-1862)) + (lexical-strip-annotation-548 lexical-x-1862) + lexical-x-1862))))) + (lexical-gen-var-551 + (lambda (lexical-id-1864) + ((lambda (lexical-id-1865) + (if (lexical-annotation?-158 lexical-id-1865) + (gensym (annotation-expression lexical-id-1865)) + (gensym lexical-id-1865))) + (if (lexical-syntax-object?-90 lexical-id-1864) + (lexical-syntax-object-expression-91 lexical-id-1864) + lexical-id-1864)))) + (lexical-lambda-var-list-552 + (lambda (lexical-vars-1866) + ((letrec ((lexical-lvl-1867 + (lambda (lexical-vars-1868 + lexical-ls-1869 + lexical-w-1870) + (if (pair? lexical-vars-1868) + (lexical-lvl-1867 + (cdr lexical-vars-1868) + (cons (lexical-wrap-470 + (car lexical-vars-1868) + lexical-w-1870) + lexical-ls-1869) + lexical-w-1870) + (if (lexical-id?-333 lexical-vars-1868) + (cons (lexical-wrap-470 + lexical-vars-1868 + lexical-w-1870) + lexical-ls-1869) + (if (null? lexical-vars-1868) + lexical-ls-1869 + (if (lexical-syntax-object?-90 + lexical-vars-1868) + (lexical-lvl-1867 + (lexical-syntax-object-expression-91 + lexical-vars-1868) + lexical-ls-1869 + (lexical-join-wraps-449 + lexical-w-1870 + (lexical-syntax-object-wrap-92 + lexical-vars-1868))) + (if (lexical-annotation?-158 + lexical-vars-1868) + (lexical-lvl-1867 + (annotation-expression + lexical-vars-1868) + lexical-ls-1869 + lexical-w-1870) + (cons lexical-vars-1868 + lexical-ls-1869))))))))) + lexical-lvl-1867) + lexical-vars-1866 + '() + '(()))))) + (begin + (set! $sc-put-cte + (lambda (lexical-id-1871 lexical-b-1872 lexical-top-token-1873) + (letrec* ((lexical-sc-put-module-1874 + (lambda (lexical-exports-1876 + lexical-token-1877 + lexical-new-marks-1878) + (lexical-vfor-each-515 + (lambda (lexical-id-1879) + (lexical-store-import-binding-443 + lexical-id-1879 + lexical-token-1877 + lexical-new-marks-1878)) + lexical-exports-1876))) + (lexical-put-cte-1875 + (lambda (lexical-id-1880 + lexical-binding-1881 + lexical-token-1882) + ((lambda (lexical-sym-1883) + (begin + (lexical-store-import-binding-443 + lexical-id-1880 + lexical-token-1882 + '()) + (lexical-put-global-definition-hook-165 + lexical-sym-1883 + (if (if (eq? (lexical-binding-type-308 + lexical-binding-1881) + 'global) + (eq? (lexical-binding-value-309 + lexical-binding-1881) + lexical-sym-1883) + '#f) + '#f + lexical-binding-1881)))) + (if (symbol? lexical-id-1880) + lexical-id-1880 + (lexical-id-var-name-461 + lexical-id-1880 + '(()))))))) + ((lambda (lexical-binding-1884) + ((lambda (lexical-t-1885) + (if (memv lexical-t-1885 '($module)) + (begin + ((lambda (lexical-iface-1886) + (lexical-sc-put-module-1874 + (lexical-interface-exports-481 + lexical-iface-1886) + (lexical-interface-token-482 + lexical-iface-1886) + '())) + (lexical-binding-value-309 lexical-binding-1884)) + (lexical-put-cte-1875 + lexical-id-1871 + lexical-binding-1884 + lexical-top-token-1873)) + (if (memv lexical-t-1885 '(do-alias)) + (lexical-store-import-binding-443 + lexical-id-1871 + lexical-top-token-1873 + '()) + (if (memv lexical-t-1885 '(do-import)) + ((lambda (lexical-token-1887) + ((lambda (lexical-b-1888) + ((lambda (lexical-t-1889) + (if (memv lexical-t-1889 + '($module)) + ((lambda (lexical-iface-1890) + ((lambda (lexical-exports-1891) + ((lambda () + (begin + (if (not (eq? (lexical-interface-token-482 + lexical-iface-1890) + lexical-token-1887)) + (syntax-error + lexical-id-1871 + '"import mismatch for module") + (void)) + (lexical-sc-put-module-1874 + (lexical-interface-exports-481 + lexical-iface-1890) + lexical-top-token-1873 + (lexical-import-mark-delta-533 + lexical-id-1871 + lexical-iface-1890)))))) + (lexical-interface-exports-481 + lexical-iface-1890))) + (lexical-binding-value-309 + lexical-b-1888)) + (syntax-error + lexical-id-1871 + '"unknown module"))) + (lexical-binding-type-308 + lexical-b-1888))) + (lexical-lookup-328 + (lexical-id-var-name-461 + lexical-id-1871 + '(())) + '()))) + (lexical-binding-value-309 lexical-b-1872)) + (lexical-put-cte-1875 + lexical-id-1871 + lexical-binding-1884 + lexical-top-token-1873))))) + (lexical-binding-type-308 lexical-binding-1884))) + (lexical-make-transformer-binding-329 lexical-b-1872))))) + (lexical-global-extend-331 'local-syntax 'letrec-syntax '#t) + (lexical-global-extend-331 'local-syntax 'let-syntax '#f) + (lexical-global-extend-331 + 'core + 'fluid-let-syntax + (lambda (lexical-e-1892 + lexical-r-1893 + lexical-mr-1894 + lexical-w-1895 + lexical-ae-1896 + lexical-m?-1897) + ((lambda (lexical-tmp-1898) + ((lambda (lexical-tmp-1899) + (if (if lexical-tmp-1899 + (apply (lambda (lexical-_-1900 + lexical-var-1901 + lexical-val-1902 + lexical-e1-1903 + lexical-e2-1904) + (lexical-valid-bound-ids?-466 + lexical-var-1901)) + lexical-tmp-1899) + '#f) + (apply (lambda (lexical-_-1906 + lexical-var-1907 + lexical-val-1908 + lexical-e1-1909 + lexical-e2-1910) + ((lambda (lexical-names-1911) + (begin + (for-each + (lambda (lexical-id-1912 lexical-n-1913) + ((lambda (lexical-t-1914) + (if (memv lexical-t-1914 + '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + (lexical-wrap-470 + lexical-id-1912 + lexical-w-1895)) + (void))) + (lexical-binding-type-308 + (lexical-lookup-328 + lexical-n-1913 + lexical-r-1893)))) + lexical-var-1907 + lexical-names-1911) + ((lambda (lexical-b*-1916) + (lexical-chi-body-531 + (cons lexical-e1-1909 lexical-e2-1910) + (lexical-source-wrap-471 + lexical-e-1892 + lexical-w-1895 + lexical-ae-1896) + (lexical-extend-env*-323 + lexical-names-1911 + lexical-b*-1916 + lexical-r-1893) + (lexical-extend-env*-323 + lexical-names-1911 + lexical-b*-1916 + lexical-mr-1894) + lexical-w-1895 + lexical-m?-1897)) + (map (lambda (lexical-x-1918) + (lexical-defer-or-eval-transformer-330 + lexical-local-eval-hook-160 + (lexical-chi-525 + lexical-x-1918 + lexical-mr-1894 + lexical-mr-1894 + lexical-w-1895 + '#t))) + lexical-val-1908)))) + (map (lambda (lexical-x-1920) + (lexical-id-var-name-461 + lexical-x-1920 + lexical-w-1895)) + lexical-var-1907))) + lexical-tmp-1899) + ((lambda (lexical-_-1922) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1892 + lexical-w-1895 + lexical-ae-1896))) + lexical-tmp-1898))) + ($syntax-dispatch + lexical-tmp-1898 + '(any #(each (any any)) any . each-any)))) + lexical-e-1892))) + (lexical-global-extend-331 + 'core + 'quote + (lambda (lexical-e-1923 + lexical-r-1924 + lexical-mr-1925 + lexical-w-1926 + lexical-ae-1927 + lexical-m?-1928) + ((lambda (lexical-tmp-1929) + ((lambda (lexical-tmp-1930) + (if lexical-tmp-1930 + (apply (lambda (lexical-_-1931 lexical-e-1932) + (list 'quote + (lexical-strip-550 + lexical-e-1932 + lexical-w-1926))) + lexical-tmp-1930) + ((lambda (lexical-_-1933) + (syntax-error + (lexical-source-wrap-471 + lexical-e-1923 + lexical-w-1926 + lexical-ae-1927))) + lexical-tmp-1929))) + ($syntax-dispatch lexical-tmp-1929 '(any any)))) + lexical-e-1923))) + (lexical-global-extend-331 + 'core + 'syntax + ((lambda () + (letrec* ((lexical-gen-syntax-1934 + (lambda (lexical-src-1942 + lexical-e-1943 + lexical-r-1944 + lexical-maps-1945 + lexical-ellipsis?-1946 + lexical-vec?-1947) + (if (lexical-id?-333 lexical-e-1943) + ((lambda (lexical-label-1948) + ((lambda (lexical-b-1949) + (if (eq? (lexical-binding-type-308 + lexical-b-1949) + 'syntax) + (call-with-values + (lambda () + ((lambda (lexical-var.lev-1950) + (lexical-gen-ref-1935 + lexical-src-1942 + (car lexical-var.lev-1950) + (cdr lexical-var.lev-1950) + lexical-maps-1945)) + (lexical-binding-value-309 + lexical-b-1949))) + (lambda (lexical-var-1951 + lexical-maps-1952) + (values + (list 'ref lexical-var-1951) + lexical-maps-1952))) + (if (lexical-ellipsis?-1946 + lexical-e-1943) + (syntax-error + lexical-src-1942 + '"misplaced ellipsis in syntax form") + (values + (list 'quote lexical-e-1943) + lexical-maps-1945)))) + (lexical-lookup-328 + lexical-label-1948 + lexical-r-1944))) + (lexical-id-var-name-461 lexical-e-1943 '(()))) + ((lambda (lexical-tmp-1953) + ((lambda (lexical-tmp-1954) + (if (if lexical-tmp-1954 + (apply (lambda (lexical-dots-1955 + lexical-e-1956) + (lexical-ellipsis?-1946 + lexical-dots-1955)) + lexical-tmp-1954) + '#f) + (apply (lambda (lexical-dots-1957 + lexical-e-1958) + (if lexical-vec?-1947 + (syntax-error + lexical-src-1942 + '"misplaced ellipsis in syntax template") + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-e-1958 + lexical-r-1944 + lexical-maps-1945 + (lambda (lexical-x-1959) + '#f) + '#f))) + lexical-tmp-1954) + ((lambda (lexical-tmp-1960) + (if (if lexical-tmp-1960 + (apply (lambda (lexical-x-1961 + lexical-dots-1962 + lexical-y-1963) + (lexical-ellipsis?-1946 + lexical-dots-1962)) + lexical-tmp-1960) + '#f) + (apply (lambda (lexical-x-1964 + lexical-dots-1965 + lexical-y-1966) + ((letrec ((lexical-f-1967 + (lambda (lexical-y-1968 + lexical-k-1969) + ((lambda (lexical-tmp-1970) + ((lambda (lexical-tmp-1971) + (if (if lexical-tmp-1971 + (apply (lambda (lexical-dots-1972 + lexical-y-1973) + (lexical-ellipsis?-1946 + lexical-dots-1972)) + lexical-tmp-1971) + '#f) + (apply (lambda (lexical-dots-1974 + lexical-y-1975) + (lexical-f-1967 + lexical-y-1975 + (lambda (lexical-maps-1976) + (call-with-values + (lambda () + (lexical-k-1969 + (cons '() + lexical-maps-1976))) + (lambda (lexical-x-1977 + lexical-maps-1978) + (if (null? (car lexical-maps-1978)) + (syntax-error + lexical-src-1942 + '"extra ellipsis in syntax form") + (values + (lexical-gen-mappend-1937 + lexical-x-1977 + (car lexical-maps-1978)) + (cdr lexical-maps-1978)))))))) + lexical-tmp-1971) + ((lambda (lexical-_-1979) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-y-1968 + lexical-r-1944 + lexical-maps-1945 + lexical-ellipsis?-1946 + lexical-vec?-1947)) + (lambda (lexical-y-1980 + lexical-maps-1981) + (call-with-values + (lambda () + (lexical-k-1969 + lexical-maps-1981)) + (lambda (lexical-x-1982 + lexical-maps-1983) + (values + (lexical-gen-append-1936 + lexical-x-1982 + lexical-y-1980) + lexical-maps-1983)))))) + lexical-tmp-1970))) + ($syntax-dispatch + lexical-tmp-1970 + '(any . + any)))) + lexical-y-1968)))) + lexical-f-1967) + lexical-y-1966 + (lambda (lexical-maps-1984) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-x-1964 + lexical-r-1944 + (cons '() + lexical-maps-1984) + lexical-ellipsis?-1946 + '#f)) + (lambda (lexical-x-1985 + lexical-maps-1986) + (if (null? (car lexical-maps-1986)) + (syntax-error + lexical-src-1942 + '"extra ellipsis in syntax form") + (values + (lexical-gen-map-1938 + lexical-x-1985 + (car lexical-maps-1986)) + (cdr lexical-maps-1986)))))))) + lexical-tmp-1960) + ((lambda (lexical-tmp-1987) + (if lexical-tmp-1987 + (apply (lambda (lexical-x-1988 + lexical-y-1989) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-x-1988 + lexical-r-1944 + lexical-maps-1945 + lexical-ellipsis?-1946 + '#f)) + (lambda (lexical-xnew-1990 + lexical-maps-1991) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-y-1989 + lexical-r-1944 + lexical-maps-1991 + lexical-ellipsis?-1946 + lexical-vec?-1947)) + (lambda (lexical-ynew-1992 + lexical-maps-1993) + (values + (lexical-gen-cons-1939 + lexical-e-1943 + lexical-x-1988 + lexical-y-1989 + lexical-xnew-1990 + lexical-ynew-1992) + lexical-maps-1993)))))) + lexical-tmp-1987) + ((lambda (lexical-tmp-1994) + (if lexical-tmp-1994 + (apply (lambda (lexical-x1-1995 + lexical-x2-1996) + ((lambda (lexical-ls-1997) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-src-1942 + lexical-ls-1997 + lexical-r-1944 + lexical-maps-1945 + lexical-ellipsis?-1946 + '#t)) + (lambda (lexical-lsnew-1998 + lexical-maps-1999) + (values + (lexical-gen-vector-1940 + lexical-e-1943 + lexical-ls-1997 + lexical-lsnew-1998) + lexical-maps-1999)))) + (cons lexical-x1-1995 + lexical-x2-1996))) + lexical-tmp-1994) + ((lambda (lexical-_-2001) + (values + (list 'quote + lexical-e-1943) + lexical-maps-1945)) + lexical-tmp-1953))) + ($syntax-dispatch + lexical-tmp-1953 + '#(vector + (any . each-any)))))) + ($syntax-dispatch + lexical-tmp-1953 + '(any . any))))) + ($syntax-dispatch + lexical-tmp-1953 + '(any any . any))))) + ($syntax-dispatch lexical-tmp-1953 '(any any)))) + lexical-e-1943)))) + (lexical-gen-ref-1935 + (lambda (lexical-src-2002 + lexical-var-2003 + lexical-level-2004 + lexical-maps-2005) + (if (= lexical-level-2004 '0) + (values lexical-var-2003 lexical-maps-2005) + (if (null? lexical-maps-2005) + (syntax-error + lexical-src-2002 + '"missing ellipsis in syntax form") + (call-with-values + (lambda () + (lexical-gen-ref-1935 + lexical-src-2002 + lexical-var-2003 + (- lexical-level-2004 '1) + (cdr lexical-maps-2005))) + (lambda (lexical-outer-var-2006 + lexical-outer-maps-2007) + ((lambda (lexical-b-2008) + (if lexical-b-2008 + (values + (cdr lexical-b-2008) + lexical-maps-2005) + ((lambda (lexical-inner-var-2009) + (values + lexical-inner-var-2009 + (cons (cons (cons lexical-outer-var-2006 + lexical-inner-var-2009) + (car lexical-maps-2005)) + lexical-outer-maps-2007))) + (lexical-gen-var-551 'tmp)))) + (assq lexical-outer-var-2006 + (car lexical-maps-2005))))))))) + (lexical-gen-append-1936 + (lambda (lexical-x-2010 lexical-y-2011) + (if (equal? lexical-y-2011 ''()) + lexical-x-2010 + (list 'append lexical-x-2010 lexical-y-2011)))) + (lexical-gen-mappend-1937 + (lambda (lexical-e-2012 lexical-map-env-2013) + (list 'apply + '(primitive append) + (lexical-gen-map-1938 + lexical-e-2012 + lexical-map-env-2013)))) + (lexical-gen-map-1938 + (lambda (lexical-e-2014 lexical-map-env-2015) + ((lambda (lexical-formals-2016 lexical-actuals-2017) + (if (eq? (car lexical-e-2014) 'ref) + (car lexical-actuals-2017) + (if (andmap + (lambda (lexical-x-2018) + (if (eq? (car lexical-x-2018) 'ref) + (memq (cadr lexical-x-2018) + lexical-formals-2016) + '#f)) + (cdr lexical-e-2014)) + (cons 'map + (cons (list 'primitive + (car lexical-e-2014)) + (map ((lambda (lexical-r-2019) + (lambda (lexical-x-2020) + (cdr (assq (cadr lexical-x-2020) + lexical-r-2019)))) + (map cons + lexical-formals-2016 + lexical-actuals-2017)) + (cdr lexical-e-2014)))) + (cons 'map + (cons (list 'lambda + lexical-formals-2016 + lexical-e-2014) + lexical-actuals-2017))))) + (map cdr lexical-map-env-2015) + (map (lambda (lexical-x-2021) + (list 'ref (car lexical-x-2021))) + lexical-map-env-2015)))) + (lexical-gen-cons-1939 + (lambda (lexical-e-2022 + lexical-x-2023 + lexical-y-2024 + lexical-xnew-2025 + lexical-ynew-2026) + ((lambda (lexical-t-2027) + (if (memv lexical-t-2027 '(quote)) + (if (eq? (car lexical-xnew-2025) 'quote) + ((lambda (lexical-xnew-2028 + lexical-ynew-2029) + (if (if (eq? lexical-xnew-2028 + lexical-x-2023) + (eq? lexical-ynew-2029 + lexical-y-2024) + '#f) + (list 'quote lexical-e-2022) + (list 'quote + (cons lexical-xnew-2028 + lexical-ynew-2029)))) + (cadr lexical-xnew-2025) + (cadr lexical-ynew-2026)) + (if (eq? (cadr lexical-ynew-2026) '()) + (list 'list lexical-xnew-2025) + (list 'cons + lexical-xnew-2025 + lexical-ynew-2026))) + (if (memv lexical-t-2027 '(list)) + (cons 'list + (cons lexical-xnew-2025 + (cdr lexical-ynew-2026))) + (list 'cons + lexical-xnew-2025 + lexical-ynew-2026)))) + (car lexical-ynew-2026)))) + (lexical-gen-vector-1940 + (lambda (lexical-e-2030 + lexical-ls-2031 + lexical-lsnew-2032) + (if (eq? (car lexical-lsnew-2032) 'quote) + (if (eq? (cadr lexical-lsnew-2032) lexical-ls-2031) + (list 'quote lexical-e-2030) + (list 'quote + (list->vector (cadr lexical-lsnew-2032)))) + (if (eq? (car lexical-lsnew-2032) 'list) + (cons 'vector (cdr lexical-lsnew-2032)) + (list 'list->vector lexical-lsnew-2032))))) + (lexical-regen-1941 + (lambda (lexical-x-2033) + ((lambda (lexical-t-2034) + (if (memv lexical-t-2034 '(ref)) + (cadr lexical-x-2033) + (if (memv lexical-t-2034 '(primitive)) + (cadr lexical-x-2033) + (if (memv lexical-t-2034 '(quote)) + (list 'quote (cadr lexical-x-2033)) + (if (memv lexical-t-2034 '(lambda)) + (list 'lambda + (cadr lexical-x-2033) + (lexical-regen-1941 + (caddr lexical-x-2033))) + (if (memv lexical-t-2034 '(map)) + ((lambda (lexical-ls-2035) + (cons (if (= (length + lexical-ls-2035) + '2) + 'map + 'map) + lexical-ls-2035)) + (map lexical-regen-1941 + (cdr lexical-x-2033))) + (cons (car lexical-x-2033) + (map lexical-regen-1941 + (cdr lexical-x-2033))))))))) + (car lexical-x-2033))))) + (lambda (lexical-e-2036 + lexical-r-2037 + lexical-mr-2038 + lexical-w-2039 + lexical-ae-2040 + lexical-m?-2041) + ((lambda (lexical-e-2042) + ((lambda (lexical-tmp-2043) + ((lambda (lexical-tmp-2044) + (if lexical-tmp-2044 + (apply (lambda (lexical-_-2045 lexical-x-2046) + (call-with-values + (lambda () + (lexical-gen-syntax-1934 + lexical-e-2042 + lexical-x-2046 + lexical-r-2037 + '() + lexical-ellipsis?-547 + '#f)) + (lambda (lexical-e-2047 + lexical-maps-2048) + (lexical-regen-1941 lexical-e-2047)))) + lexical-tmp-2044) + ((lambda (lexical-_-2049) + (syntax-error lexical-e-2042)) + lexical-tmp-2043))) + ($syntax-dispatch lexical-tmp-2043 '(any any)))) + lexical-e-2042)) + (lexical-source-wrap-471 + lexical-e-2036 + lexical-w-2039 + lexical-ae-2040))))))) + (lexical-global-extend-331 + 'core + 'lambda + (lambda (lexical-e-2050 + lexical-r-2051 + lexical-mr-2052 + lexical-w-2053 + lexical-ae-2054 + lexical-m?-2055) + ((lambda (lexical-tmp-2056) + ((lambda (lexical-tmp-2057) + (if lexical-tmp-2057 + (apply (lambda (lexical-_-2058 lexical-c-2059) + (call-with-values + (lambda () + (lexical-chi-lambda-clause-544 + (lexical-source-wrap-471 + lexical-e-2050 + lexical-w-2053 + lexical-ae-2054) + lexical-c-2059 + lexical-r-2051 + lexical-mr-2052 + lexical-w-2053 + lexical-m?-2055)) + (lambda (lexical-vars-2060 lexical-body-2061) + (list 'lambda + lexical-vars-2060 + lexical-body-2061)))) + lexical-tmp-2057) + (syntax-error lexical-tmp-2056))) + ($syntax-dispatch lexical-tmp-2056 '(any . any)))) + lexical-e-2050))) + ((lambda (lexical-letrec-transformer-2062) + (begin + (lexical-global-extend-331 + 'core + 'letrec + (lexical-letrec-transformer-2062 lexical-build-letrec-262)) + (lexical-global-extend-331 + 'core + 'letrec* + (lexical-letrec-transformer-2062 lexical-build-letrec*-263)))) + (lambda (lexical-build-2063) + (lambda (lexical-e-2064 + lexical-r-2065 + lexical-mr-2066 + lexical-w-2067 + lexical-ae-2068 + lexical-m?-2069) + ((lambda (lexical-tmp-2070) + ((lambda (lexical-tmp-2071) + (if lexical-tmp-2071 + (apply (lambda (lexical-_-2072 + lexical-id-2073 + lexical-val-2074 + lexical-e1-2075 + lexical-e2-2076) + ((lambda (lexical-ids-2077) + (if (not (lexical-valid-bound-ids?-466 + lexical-ids-2077)) + (lexical-invalid-ids-error-468 + (map (lambda (lexical-x-2078) + (lexical-wrap-470 + lexical-x-2078 + lexical-w-2067)) + lexical-ids-2077) + (lexical-source-wrap-471 + lexical-e-2064 + lexical-w-2067 + lexical-ae-2068) + '"bound variable") + ((lambda (lexical-labels-2079 + lexical-new-vars-2080) + ((lambda (lexical-w-2081 + lexical-r-2082) + (lexical-build-2063 + lexical-ae-2068 + lexical-new-vars-2080 + (map (lambda (lexical-x-2083) + (lexical-chi-525 + lexical-x-2083 + lexical-r-2082 + lexical-mr-2066 + lexical-w-2081 + lexical-m?-2069)) + lexical-val-2074) + (lexical-chi-body-531 + (cons lexical-e1-2075 + lexical-e2-2076) + (lexical-source-wrap-471 + lexical-e-2064 + lexical-w-2081 + lexical-ae-2068) + lexical-r-2082 + lexical-mr-2066 + lexical-w-2081 + lexical-m?-2069))) + (lexical-make-binding-wrap-444 + lexical-ids-2077 + lexical-labels-2079 + lexical-w-2067) + (lexical-extend-var-env*-324 + lexical-labels-2079 + lexical-new-vars-2080 + lexical-r-2065))) + (lexical-gen-labels-391 + lexical-ids-2077) + (map lexical-gen-var-551 + lexical-ids-2077)))) + lexical-id-2073)) + lexical-tmp-2071) + ((lambda (lexical-_-2087) + (syntax-error + (lexical-source-wrap-471 + lexical-e-2064 + lexical-w-2067 + lexical-ae-2068))) + lexical-tmp-2070))) + ($syntax-dispatch + lexical-tmp-2070 + '(any #(each (any any)) any . each-any)))) + lexical-e-2064)))) + (lexical-global-extend-331 + 'core + 'if + (lambda (lexical-e-2088 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-ae-2092 + lexical-m?-2093) + ((lambda (lexical-tmp-2094) + ((lambda (lexical-tmp-2095) + (if lexical-tmp-2095 + (apply (lambda (lexical-_-2096 + lexical-test-2097 + lexical-then-2098) + (list 'if + (lexical-chi-525 + lexical-test-2097 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-m?-2093) + (lexical-chi-525 + lexical-then-2098 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-m?-2093) + (lexical-chi-void-546))) + lexical-tmp-2095) + ((lambda (lexical-tmp-2099) + (if lexical-tmp-2099 + (apply (lambda (lexical-_-2100 + lexical-test-2101 + lexical-then-2102 + lexical-else-2103) + (list 'if + (lexical-chi-525 + lexical-test-2101 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-m?-2093) + (lexical-chi-525 + lexical-then-2102 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-m?-2093) + (lexical-chi-525 + lexical-else-2103 + lexical-r-2089 + lexical-mr-2090 + lexical-w-2091 + lexical-m?-2093))) + lexical-tmp-2099) + ((lambda (lexical-_-2104) + (syntax-error + (lexical-source-wrap-471 + lexical-e-2088 + lexical-w-2091 + lexical-ae-2092))) + lexical-tmp-2094))) + ($syntax-dispatch lexical-tmp-2094 '(any any any any))))) + ($syntax-dispatch lexical-tmp-2094 '(any any any)))) + lexical-e-2088))) + (lexical-global-extend-331 'set! 'set! '()) + (lexical-global-extend-331 'alias 'alias '()) + (lexical-global-extend-331 'begin 'begin '()) + (lexical-global-extend-331 '$module-key '$module '()) + (lexical-global-extend-331 '$import '$import '()) + (lexical-global-extend-331 'define 'define '()) + (lexical-global-extend-331 'define-syntax 'define-syntax '()) + (lexical-global-extend-331 'eval-when 'eval-when '()) + (lexical-global-extend-331 'meta 'meta '()) + (lexical-global-extend-331 + 'core + 'syntax-case + ((lambda () + (letrec* ((lexical-convert-pattern-2105 + (lambda (lexical-pattern-2109 lexical-keys-2110) + (letrec* ((lexical-cvt*-2111 + (lambda (lexical-p*-2113 + lexical-n-2114 + lexical-ids-2115) + (if (null? lexical-p*-2113) + (values '() lexical-ids-2115) + (call-with-values + (lambda () + (lexical-cvt*-2111 + (cdr lexical-p*-2113) + lexical-n-2114 + lexical-ids-2115)) + (lambda (lexical-y-2116 + lexical-ids-2117) + (call-with-values + (lambda () + (lexical-cvt-2112 + (car lexical-p*-2113) + lexical-n-2114 + lexical-ids-2117)) + (lambda (lexical-x-2118 + lexical-ids-2119) + (values + (cons lexical-x-2118 + lexical-y-2116) + lexical-ids-2119)))))))) + (lexical-cvt-2112 + (lambda (lexical-p-2120 + lexical-n-2121 + lexical-ids-2122) + (if (lexical-id?-333 lexical-p-2120) + (if (lexical-bound-id-member?-469 + lexical-p-2120 + lexical-keys-2110) + (values + (vector 'free-id lexical-p-2120) + lexical-ids-2122) + (values + 'any + (cons (cons lexical-p-2120 + lexical-n-2121) + lexical-ids-2122))) + ((lambda (lexical-tmp-2123) + ((lambda (lexical-tmp-2124) + (if (if lexical-tmp-2124 + (apply (lambda (lexical-x-2125 + lexical-dots-2126) + (lexical-ellipsis?-547 + lexical-dots-2126)) + lexical-tmp-2124) + '#f) + (apply (lambda (lexical-x-2127 + lexical-dots-2128) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-x-2127 + (+ lexical-n-2121 + '1) + lexical-ids-2122)) + (lambda (lexical-p-2129 + lexical-ids-2130) + (values + (if (eq? lexical-p-2129 + 'any) + 'each-any + (vector + 'each + lexical-p-2129)) + lexical-ids-2130)))) + lexical-tmp-2124) + ((lambda (lexical-tmp-2131) + (if (if lexical-tmp-2131 + (apply (lambda (lexical-x-2132 + lexical-dots-2133 + lexical-y-2134 + lexical-z-2135) + (lexical-ellipsis?-547 + lexical-dots-2133)) + lexical-tmp-2131) + '#f) + (apply (lambda (lexical-x-2136 + lexical-dots-2137 + lexical-y-2138 + lexical-z-2139) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-z-2139 + lexical-n-2121 + lexical-ids-2122)) + (lambda (lexical-z-2140 + lexical-ids-2141) + (call-with-values + (lambda () + (lexical-cvt*-2111 + lexical-y-2138 + lexical-n-2121 + lexical-ids-2141)) + (lambda (lexical-y-2143 + lexical-ids-2144) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-x-2136 + (+ lexical-n-2121 + '1) + lexical-ids-2144)) + (lambda (lexical-x-2145 + lexical-ids-2146) + (values + (vector + 'each+ + lexical-x-2145 + (reverse + lexical-y-2143) + lexical-z-2140) + lexical-ids-2146)))))))) + lexical-tmp-2131) + ((lambda (lexical-tmp-2147) + (if lexical-tmp-2147 + (apply (lambda (lexical-x-2148 + lexical-y-2149) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-y-2149 + lexical-n-2121 + lexical-ids-2122)) + (lambda (lexical-y-2150 + lexical-ids-2151) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-x-2148 + lexical-n-2121 + lexical-ids-2151)) + (lambda (lexical-x-2152 + lexical-ids-2153) + (values + (cons lexical-x-2152 + lexical-y-2150) + lexical-ids-2153)))))) + lexical-tmp-2147) + ((lambda (lexical-tmp-2154) + (if lexical-tmp-2154 + (apply (lambda () + (values + '() + lexical-ids-2122)) + lexical-tmp-2154) + ((lambda (lexical-tmp-2155) + (if lexical-tmp-2155 + (apply (lambda (lexical-x-2156) + (call-with-values + (lambda () + (lexical-cvt-2112 + lexical-x-2156 + lexical-n-2121 + lexical-ids-2122)) + (lambda (lexical-p-2158 + lexical-ids-2159) + (values + (vector + 'vector + lexical-p-2158) + lexical-ids-2159)))) + lexical-tmp-2155) + ((lambda (lexical-x-2160) + (values + (vector + 'atom + (lexical-strip-550 + lexical-p-2120 + '(()))) + lexical-ids-2122)) + lexical-tmp-2123))) + ($syntax-dispatch + lexical-tmp-2123 + '#(vector + each-any))))) + ($syntax-dispatch + lexical-tmp-2123 + '())))) + ($syntax-dispatch + lexical-tmp-2123 + '(any . any))))) + ($syntax-dispatch + lexical-tmp-2123 + '(any any + . + #(each+ any () any)))))) + ($syntax-dispatch + lexical-tmp-2123 + '(any any)))) + lexical-p-2120))))) + (lexical-cvt-2112 lexical-pattern-2109 '0 '())))) + (lexical-build-dispatch-call-2106 + (lambda (lexical-pvars-2161 + lexical-exp-2162 + lexical-y-2163 + lexical-r-2164 + lexical-mr-2165 + lexical-m?-2166) + ((lambda (lexical-ids-2167 lexical-levels-2168) + ((lambda (lexical-labels-2169 lexical-new-vars-2170) + (cons 'apply + (list (list 'lambda + lexical-new-vars-2170 + (lexical-chi-525 + lexical-exp-2162 + (lexical-extend-env*-323 + lexical-labels-2169 + (map (lambda (lexical-var-2171 + lexical-level-2172) + (cons 'syntax + (cons lexical-var-2171 + lexical-level-2172))) + lexical-new-vars-2170 + (map cdr + lexical-pvars-2161)) + lexical-r-2164) + lexical-mr-2165 + (lexical-make-binding-wrap-444 + lexical-ids-2167 + lexical-labels-2169 + '(())) + lexical-m?-2166)) + lexical-y-2163))) + (lexical-gen-labels-391 lexical-ids-2167) + (map lexical-gen-var-551 lexical-ids-2167))) + (map car lexical-pvars-2161) + (map cdr lexical-pvars-2161)))) + (lexical-gen-clause-2107 + (lambda (lexical-x-2173 + lexical-keys-2174 + lexical-clauses-2175 + lexical-r-2176 + lexical-mr-2177 + lexical-m?-2178 + lexical-pat-2179 + lexical-fender-2180 + lexical-exp-2181) + (call-with-values + (lambda () + (lexical-convert-pattern-2105 + lexical-pat-2179 + lexical-keys-2174)) + (lambda (lexical-p-2182 lexical-pvars-2183) + (if (not (lexical-distinct-bound-ids?-467 + (map car lexical-pvars-2183))) + (lexical-invalid-ids-error-468 + (map car lexical-pvars-2183) + lexical-pat-2179 + '"pattern variable") + (if (not (andmap + (lambda (lexical-x-2184) + (not (lexical-ellipsis?-547 + (car lexical-x-2184)))) + lexical-pvars-2183)) + (syntax-error + lexical-pat-2179 + '"misplaced ellipsis in syntax-case pattern") + ((lambda (lexical-y-2185) + (cons (list 'lambda + (list lexical-y-2185) + (list 'if + ((lambda (lexical-tmp-2195) + ((lambda (lexical-tmp-2196) + (if lexical-tmp-2196 + (apply (lambda () + lexical-y-2185) + lexical-tmp-2196) + ((lambda (lexical-_-2197) + (list 'if + lexical-y-2185 + (lexical-build-dispatch-call-2106 + lexical-pvars-2183 + lexical-fender-2180 + lexical-y-2185 + lexical-r-2176 + lexical-mr-2177 + lexical-m?-2178) + (list 'quote + '#f))) + lexical-tmp-2195))) + ($syntax-dispatch + lexical-tmp-2195 + '#(atom #t)))) + lexical-fender-2180) + (lexical-build-dispatch-call-2106 + lexical-pvars-2183 + lexical-exp-2181 + lexical-y-2185 + lexical-r-2176 + lexical-mr-2177 + lexical-m?-2178) + (lexical-gen-syntax-case-2108 + lexical-x-2173 + lexical-keys-2174 + lexical-clauses-2175 + lexical-r-2176 + lexical-mr-2177 + lexical-m?-2178))) + (list (if (eq? lexical-p-2182 'any) + (cons 'list + (list lexical-x-2173)) + (cons '$syntax-dispatch + (list lexical-x-2173 + (list 'quote + lexical-p-2182))))))) + (lexical-gen-var-551 'tmp)))))))) + (lexical-gen-syntax-case-2108 + (lambda (lexical-x-2198 + lexical-keys-2199 + lexical-clauses-2200 + lexical-r-2201 + lexical-mr-2202 + lexical-m?-2203) + (if (null? lexical-clauses-2200) + (cons 'syntax-error (list lexical-x-2198)) + ((lambda (lexical-tmp-2204) + ((lambda (lexical-tmp-2205) + (if lexical-tmp-2205 + (apply (lambda (lexical-pat-2206 + lexical-exp-2207) + (if (if (lexical-id?-333 + lexical-pat-2206) + (if (not (lexical-bound-id-member?-469 + lexical-pat-2206 + lexical-keys-2199)) + (not (lexical-ellipsis?-547 + lexical-pat-2206)) + '#f) + '#f) + ((lambda (lexical-label-2208 + lexical-var-2209) + (cons (list 'lambda + (list lexical-var-2209) + (lexical-chi-525 + lexical-exp-2207 + (lexical-extend-env-322 + lexical-label-2208 + (cons 'syntax + (cons lexical-var-2209 + '0)) + lexical-r-2201) + lexical-mr-2202 + (lexical-make-binding-wrap-444 + (list lexical-pat-2206) + (list lexical-label-2208) + '(())) + lexical-m?-2203)) + (list lexical-x-2198))) + (lexical-gen-label-389) + (lexical-gen-var-551 + lexical-pat-2206)) + (lexical-gen-clause-2107 + lexical-x-2198 + lexical-keys-2199 + (cdr lexical-clauses-2200) + lexical-r-2201 + lexical-mr-2202 + lexical-m?-2203 + lexical-pat-2206 + '#t + lexical-exp-2207))) + lexical-tmp-2205) + ((lambda (lexical-tmp-2210) + (if lexical-tmp-2210 + (apply (lambda (lexical-pat-2211 + lexical-fender-2212 + lexical-exp-2213) + (lexical-gen-clause-2107 + lexical-x-2198 + lexical-keys-2199 + (cdr lexical-clauses-2200) + lexical-r-2201 + lexical-mr-2202 + lexical-m?-2203 + lexical-pat-2211 + lexical-fender-2212 + lexical-exp-2213)) + lexical-tmp-2210) + ((lambda (lexical-_-2214) + (syntax-error + (car lexical-clauses-2200) + '"invalid syntax-case clause")) + lexical-tmp-2204))) + ($syntax-dispatch + lexical-tmp-2204 + '(any any any))))) + ($syntax-dispatch lexical-tmp-2204 '(any any)))) + (car lexical-clauses-2200)))))) + (lambda (lexical-e-2215 + lexical-r-2216 + lexical-mr-2217 + lexical-w-2218 + lexical-ae-2219 + lexical-m?-2220) + ((lambda (lexical-e-2221) + ((lambda (lexical-tmp-2222) + ((lambda (lexical-tmp-2223) + (if lexical-tmp-2223 + (apply (lambda (lexical-_-2224 + lexical-val-2225 + lexical-key-2226 + lexical-m-2227) + (if (andmap + (lambda (lexical-x-2228) + (if (lexical-id?-333 + lexical-x-2228) + (not (lexical-ellipsis?-547 + lexical-x-2228)) + '#f)) + lexical-key-2226) + ((lambda (lexical-x-2230) + (cons (list 'lambda + (list lexical-x-2230) + (lexical-gen-syntax-case-2108 + lexical-x-2230 + lexical-key-2226 + lexical-m-2227 + lexical-r-2216 + lexical-mr-2217 + lexical-m?-2220)) + (list (lexical-chi-525 + lexical-val-2225 + lexical-r-2216 + lexical-mr-2217 + '(()) + lexical-m?-2220)))) + (lexical-gen-var-551 'tmp)) + (syntax-error + lexical-e-2221 + '"invalid literals list in"))) + lexical-tmp-2223) + (syntax-error lexical-tmp-2222))) + ($syntax-dispatch + lexical-tmp-2222 + '(any any each-any . each-any)))) + lexical-e-2221)) + (lexical-source-wrap-471 + lexical-e-2215 + lexical-w-2218 + lexical-ae-2219))))))) + (lexical-put-cte-hook-163 + 'module + (lambda (lexical-x-2233) + (letrec* ((lexical-proper-export?-2234 + (lambda (lexical-e-2235) + ((lambda (lexical-tmp-2236) + ((lambda (lexical-tmp-2237) + (if lexical-tmp-2237 + (apply (lambda (lexical-id-2238 + lexical-e-2239) + (if (identifier? lexical-id-2238) + (andmap + lexical-proper-export?-2234 + lexical-e-2239) + '#f)) + lexical-tmp-2237) + ((lambda (lexical-id-2241) + (identifier? lexical-id-2241)) + lexical-tmp-2236))) + ($syntax-dispatch + lexical-tmp-2236 + '(any . each-any)))) + lexical-e-2235)))) + ((lambda (lexical-tmp-2242) + ((lambda (lexical-orig-2243) + ((lambda (lexical-tmp-2244) + ((lambda (lexical-tmp-2245) + (if lexical-tmp-2245 + (apply (lambda (lexical-_-2246 + lexical-e-2247 + lexical-d-2248) + (if (andmap + lexical-proper-export?-2234 + lexical-e-2247) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2243 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-e-2247 + lexical-d-2248)))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2243 + '#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))))) + (syntax-error + lexical-x-2233 + '"invalid exports list in"))) + lexical-tmp-2245) + ((lambda (lexical-tmp-2252) + (if (if lexical-tmp-2252 + (apply (lambda (lexical-_-2253 + lexical-m-2254 + lexical-e-2255 + lexical-d-2256) + (identifier? lexical-m-2254)) + lexical-tmp-2252) + '#f) + (apply (lambda (lexical-_-2257 + lexical-m-2258 + lexical-e-2259 + lexical-d-2260) + (if (andmap + lexical-proper-export?-2234 + lexical-e-2259) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2243 + (cons lexical-m-2258 + (cons lexical-e-2259 + lexical-d-2260)))) + (syntax-error + lexical-x-2233 + '"invalid exports list in"))) + lexical-tmp-2252) + (syntax-error lexical-tmp-2244))) + ($syntax-dispatch + lexical-tmp-2244 + '(any any each-any . each-any))))) + ($syntax-dispatch + lexical-tmp-2244 + '(any each-any . each-any)))) + lexical-x-2233)) + lexical-tmp-2242)) + lexical-x-2233)))) + ((lambda () + (letrec* ((lexical-$module-exports-2264 + (lambda (lexical-m-2266 lexical-r-2267) + ((lambda (lexical-b-2268) + ((lambda (lexical-t-2269) + (if (memv lexical-t-2269 '($module)) + ((lambda (lexical-interface-2270) + ((lambda (lexical-new-marks-2271) + ((lambda () + (lexical-vmap-514 + (lambda (lexical-x-2272) + ((lambda (lexical-id-2273) + (lexical-make-syntax-object-89 + (syntax-object->datum + lexical-id-2273) + ((lambda (lexical-marks-2274) + (lexical-make-wrap-342 + lexical-marks-2274 + (if (eq? (car lexical-marks-2274) + '#f) + (cons 'shift + (lexical-wrap-subst-344 + '((top)))) + (lexical-wrap-subst-344 + '((top)))))) + (lexical-join-marks-450 + lexical-new-marks-2271 + (lexical-wrap-marks-343 + (lexical-syntax-object-wrap-92 + lexical-id-2273)))))) + (if (pair? lexical-x-2272) + (car lexical-x-2272) + lexical-x-2272))) + (lexical-interface-exports-481 + lexical-interface-2270))))) + (lexical-import-mark-delta-533 + lexical-m-2266 + lexical-interface-2270))) + (lexical-binding-value-309 lexical-b-2268)) + (if (memv lexical-t-2269 '(displaced-lexical)) + (lexical-displaced-lexical-error-326 + lexical-m-2266) + (syntax-error + lexical-m-2266 + '"unknown module")))) + (lexical-binding-type-308 lexical-b-2268))) + (lexical-r-2267 lexical-m-2266)))) + (lexical-$import-help-2265 + (lambda (lexical-orig-2275 lexical-import-only?-2276) + (lambda (lexical-r-2277) + (letrec* ((lexical-difference-2278 + (lambda (lexical-ls1-2284 lexical-ls2-2285) + (if (null? lexical-ls1-2284) + lexical-ls1-2284 + (if (lexical-bound-id-member?-469 + (car lexical-ls1-2284) + lexical-ls2-2285) + (lexical-difference-2278 + (cdr lexical-ls1-2284) + lexical-ls2-2285) + (cons (car lexical-ls1-2284) + (lexical-difference-2278 + (cdr lexical-ls1-2284) + lexical-ls2-2285)))))) + (lexical-prefix-add-2279 + (lambda (lexical-prefix-id-2286) + ((lambda (lexical-prefix-2287) + (lambda (lexical-id-2288) + (datum->syntax-object + lexical-id-2288 + (string->symbol + (string-append + lexical-prefix-2287 + (symbol->string + (syntax-object->datum + lexical-id-2288))))))) + (symbol->string + (syntax-object->datum + lexical-prefix-id-2286))))) + (lexical-prefix-drop-2280 + (lambda (lexical-prefix-id-2289) + ((lambda (lexical-prefix-2290) + (lambda (lexical-id-2291) + ((lambda (lexical-s-2292) + ((lambda (lexical-np-2293 + lexical-ns-2294) + (begin + (if (not (if (>= lexical-ns-2294 + lexical-np-2293) + (string=? + (substring + lexical-s-2292 + '0 + lexical-np-2293) + lexical-prefix-2290) + '#f)) + (syntax-error + lexical-id-2291 + (string-append + '"missing expected prefix " + lexical-prefix-2290)) + (void)) + (datum->syntax-object + lexical-id-2291 + (string->symbol + (substring + lexical-s-2292 + lexical-np-2293 + lexical-ns-2294))))) + (string-length + lexical-prefix-2290) + (string-length lexical-s-2292))) + (symbol->string + (syntax-object->datum + lexical-id-2291))))) + (symbol->string + (syntax-object->datum + lexical-prefix-id-2289))))) + (lexical-gen-mid-2281 + (lambda (lexical-mid-2295) + (datum->syntax-object + lexical-mid-2295 + (lexical-generate-id-169 + ((lambda (lexical-x-2296) + ((lambda (lexical-e-2297) + (if (lexical-annotation?-158 + lexical-e-2297) + (annotation-expression + lexical-e-2297) + lexical-e-2297)) + (if (lexical-syntax-object?-90 + lexical-x-2296) + (lexical-syntax-object-expression-91 + lexical-x-2296) + lexical-x-2296))) + lexical-mid-2295))))) + (lexical-modspec-2282 + (lambda (lexical-m-2298 + lexical-exports?-2299) + ((lambda (lexical-tmp-2300) + ((lambda (lexical-tmp-2301) + (if lexical-tmp-2301 + (apply (lambda (lexical-orig-2302 + lexical-import-only?-2303) + ((lambda (lexical-tmp-2304) + ((lambda (lexical-tmp-2305) + (if (if lexical-tmp-2305 + (apply (lambda (lexical-m-2306 + lexical-id-2307) + (andmap + identifier? + lexical-id-2307)) + lexical-tmp-2305) + '#f) + (apply (lambda (lexical-m-2309 + lexical-id-2310) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2309 + '#f)) + (lambda (lexical-mid-2311 + lexical-d-2312 + lexical-exports-2313) + ((lambda (lexical-tmp-2314) + ((lambda (lexical-tmp-2315) + (if lexical-tmp-2315 + (apply (lambda (lexical-d-2316 + lexical-tmid-2317) + (values + lexical-mid-2311 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-tmid-2317 + lexical-id-2310 + lexical-d-2316) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2317)) + (if lexical-exports?-2299 + lexical-id-2310 + '#f))) + lexical-tmp-2315) + (syntax-error + lexical-tmp-2314))) + ($syntax-dispatch + lexical-tmp-2314 + '(any any)))) + (list lexical-d-2312 + (lexical-gen-mid-2281 + lexical-mid-2311)))))) + lexical-tmp-2305) + ((lambda (lexical-tmp-2320) + (if (if lexical-tmp-2320 + (apply (lambda (lexical-m-2321 + lexical-id-2322) + (andmap + identifier? + lexical-id-2322)) + lexical-tmp-2320) + '#f) + (apply (lambda (lexical-m-2324 + lexical-id-2325) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2324 + '#t)) + (lambda (lexical-mid-2326 + lexical-d-2327 + lexical-exports-2328) + ((lambda (lexical-tmp-2329) + ((lambda (lexical-tmp-2330) + (if lexical-tmp-2330 + (apply (lambda (lexical-d-2331 + lexical-tmid-2332 + lexical-id-2333) + (values + lexical-mid-2326 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-tmid-2332 + lexical-id-2333 + lexical-d-2331) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2332)) + (if lexical-exports?-2299 + lexical-id-2333 + '#f))) + lexical-tmp-2330) + (syntax-error + lexical-tmp-2329))) + ($syntax-dispatch + lexical-tmp-2329 + '(any any + each-any)))) + (list lexical-d-2327 + (lexical-gen-mid-2281 + lexical-mid-2326) + (lexical-difference-2278 + lexical-exports-2328 + lexical-id-2325)))))) + lexical-tmp-2320) + ((lambda (lexical-tmp-2337) + (if (if lexical-tmp-2337 + (apply (lambda (lexical-m-2338 + lexical-prefix-id-2339) + (identifier? + lexical-prefix-id-2339)) + lexical-tmp-2337) + '#f) + (apply (lambda (lexical-m-2340 + lexical-prefix-id-2341) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2340 + '#t)) + (lambda (lexical-mid-2342 + lexical-d-2343 + lexical-exports-2344) + ((lambda (lexical-tmp-2345) + ((lambda (lexical-tmp-2346) + (if lexical-tmp-2346 + (apply (lambda (lexical-d-2347 + lexical-tmid-2348 + lexical-old-id-2349 + lexical-tmp-2350 + lexical-id-2351) + (values + lexical-mid-2342 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2348 + (cons (map list + lexical-id-2351 + lexical-tmp-2350) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2348 + (cons (map list + lexical-tmp-2350 + lexical-old-id-2349) + (cons lexical-d-2347 + (map (lambda (lexical-tmp-2357 + lexical-tmp-2356) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2356 + lexical-tmp-2357)) + lexical-old-id-2349 + lexical-tmp-2350)))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2348) + (map (lambda (lexical-tmp-2359 + lexical-tmp-2358) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2358 + lexical-tmp-2359)) + lexical-tmp-2350 + lexical-id-2351))))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2348)) + (if lexical-exports?-2299 + lexical-id-2351 + '#f))) + lexical-tmp-2346) + (syntax-error + lexical-tmp-2345))) + ($syntax-dispatch + lexical-tmp-2345 + '(any any + each-any + each-any + each-any)))) + (list lexical-d-2343 + (lexical-gen-mid-2281 + lexical-mid-2342) + lexical-exports-2344 + (generate-temporaries + lexical-exports-2344) + (map (lexical-prefix-add-2279 + lexical-prefix-id-2341) + lexical-exports-2344)))))) + lexical-tmp-2337) + ((lambda (lexical-tmp-2361) + (if (if lexical-tmp-2361 + (apply (lambda (lexical-m-2362 + lexical-prefix-id-2363) + (identifier? + lexical-prefix-id-2363)) + lexical-tmp-2361) + '#f) + (apply (lambda (lexical-m-2364 + lexical-prefix-id-2365) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2364 + '#t)) + (lambda (lexical-mid-2366 + lexical-d-2367 + lexical-exports-2368) + ((lambda (lexical-tmp-2369) + ((lambda (lexical-tmp-2370) + (if lexical-tmp-2370 + (apply (lambda (lexical-d-2371 + lexical-tmid-2372 + lexical-old-id-2373 + lexical-tmp-2374 + lexical-id-2375) + (values + lexical-mid-2366 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2372 + (cons (map list + lexical-id-2375 + lexical-tmp-2374) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2372 + (cons (map list + lexical-tmp-2374 + lexical-old-id-2373) + (cons lexical-d-2371 + (map (lambda (lexical-tmp-2381 + lexical-tmp-2380) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2380 + lexical-tmp-2381)) + lexical-old-id-2373 + lexical-tmp-2374)))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2372) + (map (lambda (lexical-tmp-2383 + lexical-tmp-2382) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2382 + lexical-tmp-2383)) + lexical-tmp-2374 + lexical-id-2375))))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2372)) + (if lexical-exports?-2299 + lexical-id-2375 + '#f))) + lexical-tmp-2370) + (syntax-error + lexical-tmp-2369))) + ($syntax-dispatch + lexical-tmp-2369 + '(any any + each-any + each-any + each-any)))) + (list lexical-d-2367 + (lexical-gen-mid-2281 + lexical-mid-2366) + lexical-exports-2368 + (generate-temporaries + lexical-exports-2368) + (map (lexical-prefix-drop-2280 + lexical-prefix-id-2365) + lexical-exports-2368)))))) + lexical-tmp-2361) + ((lambda (lexical-tmp-2385) + (if (if lexical-tmp-2385 + (apply (lambda (lexical-m-2386 + lexical-new-id-2387 + lexical-old-id-2388) + (if (andmap + identifier? + lexical-new-id-2387) + (andmap + identifier? + lexical-old-id-2388) + '#f)) + lexical-tmp-2385) + '#f) + (apply (lambda (lexical-m-2391 + lexical-new-id-2392 + lexical-old-id-2393) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2391 + '#t)) + (lambda (lexical-mid-2394 + lexical-d-2395 + lexical-exports-2396) + ((lambda (lexical-tmp-2397) + ((lambda (lexical-tmp-2398) + (if lexical-tmp-2398 + (apply (lambda (lexical-d-2399 + lexical-tmid-2400 + lexical-tmp-2401 + lexical-other-id-2402) + (values + lexical-mid-2394 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2400 + (cons (append + (map list + lexical-new-id-2392 + lexical-tmp-2401) + lexical-other-id-2402) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2400 + (cons (append + lexical-other-id-2402 + (map list + lexical-tmp-2401 + lexical-old-id-2393)) + (cons lexical-d-2399 + (map (lambda (lexical-tmp-2410 + lexical-tmp-2409) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2409 + lexical-tmp-2410)) + lexical-old-id-2393 + lexical-tmp-2401)))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2400) + (map (lambda (lexical-tmp-2412 + lexical-tmp-2411) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2411 + lexical-tmp-2412)) + lexical-tmp-2401 + lexical-new-id-2392))))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2400)) + (if lexical-exports?-2299 + (append + lexical-new-id-2392 + lexical-other-id-2402) + '#f))) + lexical-tmp-2398) + (syntax-error + lexical-tmp-2397))) + ($syntax-dispatch + lexical-tmp-2397 + '(any any + each-any + each-any)))) + (list lexical-d-2395 + (lexical-gen-mid-2281 + lexical-mid-2394) + (generate-temporaries + lexical-old-id-2393) + (lexical-difference-2278 + lexical-exports-2396 + lexical-old-id-2393)))))) + lexical-tmp-2385) + ((lambda (lexical-tmp-2417) + (if (if lexical-tmp-2417 + (apply (lambda (lexical-m-2418 + lexical-new-id-2419 + lexical-old-id-2420) + (if (andmap + identifier? + lexical-new-id-2419) + (andmap + identifier? + lexical-old-id-2420) + '#f)) + lexical-tmp-2417) + '#f) + (apply (lambda (lexical-m-2423 + lexical-new-id-2424 + lexical-old-id-2425) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2423 + '#t)) + (lambda (lexical-mid-2426 + lexical-d-2427 + lexical-exports-2428) + ((lambda (lexical-tmp-2429) + ((lambda (lexical-tmp-2430) + (if lexical-tmp-2430 + (apply (lambda (lexical-d-2431 + lexical-tmid-2432 + lexical-other-id-2433) + (values + lexical-mid-2426 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-orig-2302 + (cons lexical-tmid-2432 + (cons (append + (map list + lexical-new-id-2424 + lexical-old-id-2425) + lexical-other-id-2433) + (cons lexical-d-2431 + (map (lambda (lexical-tmp-2438 + lexical-tmp-2437) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2437 + lexical-tmp-2438)) + lexical-old-id-2425 + lexical-new-id-2424)))))) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-tmid-2432)) + (if lexical-exports?-2299 + (append + lexical-new-id-2424 + lexical-other-id-2433) + '#f))) + lexical-tmp-2430) + (syntax-error + lexical-tmp-2429))) + ($syntax-dispatch + lexical-tmp-2429 + '(any any + each-any)))) + (list lexical-d-2427 + (lexical-gen-mid-2281 + lexical-mid-2426) + lexical-exports-2428))))) + lexical-tmp-2417) + ((lambda (lexical-tmp-2441) + (if (if lexical-tmp-2441 + (apply (lambda (lexical-mid-2442) + (identifier? + lexical-mid-2442)) + lexical-tmp-2441) + '#f) + (apply (lambda (lexical-mid-2443) + (values + lexical-mid-2443 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-mid-2443) + (if lexical-exports?-2299 + (lexical-$module-exports-2264 + lexical-mid-2443 + lexical-r-2277) + '#f))) + lexical-tmp-2441) + ((lambda (lexical-tmp-2444) + (if (if lexical-tmp-2444 + (apply (lambda (lexical-mid-2445) + (identifier? + lexical-mid-2445)) + lexical-tmp-2444) + '#f) + (apply (lambda (lexical-mid-2446) + (values + lexical-mid-2446 + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-orig-2302 + lexical-import-only?-2303 + lexical-mid-2446) + (if lexical-exports?-2299 + (lexical-$module-exports-2264 + lexical-mid-2446 + lexical-r-2277) + '#f))) + lexical-tmp-2444) + ((lambda (lexical-_-2447) + (syntax-error + lexical-m-2298 + '"invalid module specifier")) + lexical-tmp-2304))) + ($syntax-dispatch + lexical-tmp-2304 + '(any))))) + (list lexical-tmp-2304)))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + . + #(each (any any))))))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + . + #(each (any any))))))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + any))))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + any))))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2304 + '(#(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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + any + . + each-any)))) + lexical-m-2298)) + lexical-tmp-2301) + (syntax-error lexical-tmp-2300))) + ($syntax-dispatch + lexical-tmp-2300 + '(any any)))) + (list lexical-orig-2275 + lexical-import-only?-2276)))) + (lexical-modspec*-2283 + (lambda (lexical-m-2448) + (call-with-values + (lambda () + (lexical-modspec-2282 + lexical-m-2448 + '#f)) + (lambda (lexical-mid-2449 + lexical-d-2450 + lexical-exports-2451) + lexical-d-2450))))) + ((lambda (lexical-tmp-2452) + ((lambda (lexical-tmp-2453) + (if lexical-tmp-2453 + (apply (lambda (lexical-_-2454 + lexical-m-2455) + ((lambda (lexical-tmp-2456) + ((lambda (lexical-tmp-2457) + (if lexical-tmp-2457 + (apply (lambda (lexical-d-2458) + (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 + call-or-value + 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? + tmp-wrap + 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-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 + update-import-binding! + get-import-binding + read-only-binding? + put-global-definition-hook + get-global-definition-hook + put-cte-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) + (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) + (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" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-d-2458)) + lexical-tmp-2457) + (syntax-error + lexical-tmp-2456))) + ($syntax-dispatch + lexical-tmp-2456 + 'each-any))) + (map lexical-modspec*-2283 + lexical-m-2455))) + lexical-tmp-2453) + (syntax-error lexical-tmp-2452))) + ($syntax-dispatch + lexical-tmp-2452 + '(any . each-any)))) + lexical-orig-2275)))))) + (begin + (lexical-put-cte-hook-163 + '%primitive-import + (lambda (lexical-orig-2461) + (lexical-$import-help-2265 lexical-orig-2461 '#f))) + (lexical-put-cte-hook-163 + 'import-only + (lambda (lexical-orig-2462) + (lexical-$import-help-2265 lexical-orig-2462 '#t))))))) + (set! sc-expand + (lambda (lexical-x-2463 + lexical-env-2464 + lexical-ctem-2465 + lexical-rtem-2466) + ((lambda (lexical-env-2467 lexical-ctem-2468 lexical-rtem-2469) + (if (if (pair? lexical-x-2463) + (equal? (car lexical-x-2463) lexical-noexpand-87) + '#f) + (cadr lexical-x-2463) + (lexical-chi-top*-474 + lexical-x-2463 + '() + (lexical-env-wrap-415 lexical-env-2467) + lexical-ctem-2468 + lexical-rtem-2469 + '#f + (lexical-env-top-ribcage-414 lexical-env-2467)))) + ((lambda (lexical-t-2470) + (if lexical-t-2470 lexical-t-2470 (interaction-environment))) + lexical-env-2464) + ((lambda (lexical-t-2471) + (if lexical-t-2471 lexical-t-2471 '(E))) + lexical-ctem-2465) + ((lambda (lexical-t-2472) + (if lexical-t-2472 lexical-t-2472 '(E))) + lexical-rtem-2466)))) + (set! $make-environment + (lambda (lexical-token-2473 lexical-mutable?-2474) + ((lambda (lexical-top-ribcage-2475) + (lexical-make-env-412 + lexical-top-ribcage-2475 + (lexical-make-wrap-342 + (lexical-wrap-marks-343 '((top))) + (cons lexical-top-ribcage-2475 + (lexical-wrap-subst-344 '((top))))))) + (lexical-make-top-ribcage-400 + lexical-token-2473 + lexical-mutable?-2474)))) + (set! environment? + (lambda (lexical-x-2476) (lexical-env?-413 lexical-x-2476))) + (set! interaction-environment + ((lambda (lexical-e-2477) (lambda () lexical-e-2477)) + ($make-environment '*top* '#t))) + (set! identifier? + (lambda (lexical-x-2478) + (lexical-nonsymbol-id?-332 lexical-x-2478))) + (set! datum->syntax-object + (lambda (lexical-id-2479 lexical-datum-2480) + (begin + ((lambda (lexical-x-2481) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2481)) + (lexical-error-hook-162 + 'datum->syntax-object + '"invalid argument" + lexical-x-2481) + (void))) + lexical-id-2479) + (lexical-make-syntax-object-89 + lexical-datum-2480 + (lexical-syntax-object-wrap-92 lexical-id-2479))))) + (set! unwrap-syntax + (lambda (lexical-stx-2482) + ((lambda (lexical-tmp-2483) + ((lambda (lexical-tmp-2484) + (if lexical-tmp-2484 + (apply (lambda (lexical-first-2485 lexical-rest-2486) + (cons lexical-first-2485 lexical-rest-2486)) + lexical-tmp-2484) + ((lambda (lexical-tmp-2487) + (if lexical-tmp-2487 + (apply (lambda (lexical-x-2488) + (apply vector lexical-x-2488)) + lexical-tmp-2487) + ((lambda (lexical-_-2490) lexical-stx-2482) + lexical-tmp-2483))) + ($syntax-dispatch + lexical-tmp-2483 + '#(vector each-any))))) + ($syntax-dispatch lexical-tmp-2483 '(any . any)))) + lexical-stx-2482))) + (set! syntax-object->datum + (lambda (lexical-x-2491) (lexical-strip-550 lexical-x-2491 '(())))) + (set! generate-temporaries + ((lambda (lexical-n-2492) + (lambda (lexical-ls-2493) + (begin + ((lambda (lexical-x-2494) + (if (not (list? lexical-x-2494)) + (lexical-error-hook-162 + 'generate-temporaries + '"invalid argument" + lexical-x-2494) + (void))) + lexical-ls-2493) + (map (lambda (lexical-x-2495) + (begin + (set! lexical-n-2492 (+ lexical-n-2492 '1)) + (lexical-wrap-470 + (string->symbol + (string-append + '"t" + (number->string lexical-n-2492))) + '((tmp))))) + lexical-ls-2493)))) + '0)) + (set! free-identifier=? + (lambda (lexical-x-2496 lexical-y-2497) + (begin + ((lambda (lexical-x-2498) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2498)) + (lexical-error-hook-162 + 'free-identifier=? + '"invalid argument" + lexical-x-2498) + (void))) + lexical-x-2496) + ((lambda (lexical-x-2499) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2499)) + (lexical-error-hook-162 + 'free-identifier=? + '"invalid argument" + lexical-x-2499) + (void))) + lexical-y-2497) + (lexical-free-id=?-462 lexical-x-2496 lexical-y-2497)))) + (set! bound-identifier=? + (lambda (lexical-x-2500 lexical-y-2501) + (begin + ((lambda (lexical-x-2502) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2502)) + (lexical-error-hook-162 + 'bound-identifier=? + '"invalid argument" + lexical-x-2502) + (void))) + lexical-x-2500) + ((lambda (lexical-x-2503) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2503)) + (lexical-error-hook-162 + 'bound-identifier=? + '"invalid argument" + lexical-x-2503) + (void))) + lexical-y-2501) + (lexical-bound-id=?-465 lexical-x-2500 lexical-y-2501)))) + (set! literal-identifier=? + (lambda (lexical-x-2504 lexical-y-2505) + (begin + ((lambda (lexical-x-2506) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2506)) + (lexical-error-hook-162 + 'literal-identifier=? + '"invalid argument" + lexical-x-2506) + (void))) + lexical-x-2504) + ((lambda (lexical-x-2507) + (if (not (lexical-nonsymbol-id?-332 lexical-x-2507)) + (lexical-error-hook-162 + 'literal-identifier=? + '"invalid argument" + lexical-x-2507) + (void))) + lexical-y-2505) + (lexical-literal-id=?-463 lexical-x-2504 lexical-y-2505)))) + (set! syntax-error + (lambda (lexical-object-2509 . lexical-messages-2508) + (begin + (for-each + (lambda (lexical-x-2510) + ((lambda (lexical-x-2511) + (if (not (string? lexical-x-2511)) + (lexical-error-hook-162 + 'syntax-error + '"invalid argument" + lexical-x-2511) + (void))) + lexical-x-2510)) + lexical-messages-2508) + ((lambda (lexical-message-2512) + (lexical-error-hook-162 + '#f + lexical-message-2512 + (lexical-strip-550 lexical-object-2509 '(())))) + (if (null? lexical-messages-2508) + '"invalid syntax" + (apply string-append lexical-messages-2508)))))) + ((lambda () + (letrec* ((lexical-match-each-2513 + (lambda (lexical-e-2520 lexical-p-2521 lexical-w-2522) + (if (lexical-annotation?-158 lexical-e-2520) + (lexical-match-each-2513 + (annotation-expression lexical-e-2520) + lexical-p-2521 + lexical-w-2522) + (if (pair? lexical-e-2520) + ((lambda (lexical-first-2523) + (if lexical-first-2523 + ((lambda (lexical-rest-2524) + (if lexical-rest-2524 + (cons lexical-first-2523 + lexical-rest-2524) + '#f)) + (lexical-match-each-2513 + (cdr lexical-e-2520) + lexical-p-2521 + lexical-w-2522)) + '#f)) + (lexical-match-2519 + (car lexical-e-2520) + lexical-p-2521 + lexical-w-2522 + '())) + (if (null? lexical-e-2520) + '() + (if (lexical-syntax-object?-90 + lexical-e-2520) + (lexical-match-each-2513 + (lexical-syntax-object-expression-91 + lexical-e-2520) + lexical-p-2521 + (lexical-join-wraps-449 + lexical-w-2522 + (lexical-syntax-object-wrap-92 + lexical-e-2520))) + '#f)))))) + (lexical-match-each+-2514 + (lambda (lexical-e-2525 + lexical-x-pat-2526 + lexical-y-pat-2527 + lexical-z-pat-2528 + lexical-w-2529 + lexical-r-2530) + ((letrec ((lexical-f-2531 + (lambda (lexical-e-2532 lexical-w-2533) + (if (pair? lexical-e-2532) + (call-with-values + (lambda () + (lexical-f-2531 + (cdr lexical-e-2532) + lexical-w-2533)) + (lambda (lexical-xr*-2534 + lexical-y-pat-2535 + lexical-r-2536) + (if lexical-r-2536 + (if (null? lexical-y-pat-2535) + ((lambda (lexical-xr-2537) + (if lexical-xr-2537 + (values + (cons lexical-xr-2537 + lexical-xr*-2534) + lexical-y-pat-2535 + lexical-r-2536) + (values '#f '#f '#f))) + (lexical-match-2519 + (car lexical-e-2532) + lexical-x-pat-2526 + lexical-w-2533 + '())) + (values + '() + (cdr lexical-y-pat-2535) + (lexical-match-2519 + (car lexical-e-2532) + (car lexical-y-pat-2535) + lexical-w-2533 + lexical-r-2536))) + (values '#f '#f '#f)))) + (if (lexical-annotation?-158 + lexical-e-2532) + (lexical-f-2531 + (annotation-expression + lexical-e-2532) + lexical-w-2533) + (if (lexical-syntax-object?-90 + lexical-e-2532) + (lexical-f-2531 + (lexical-syntax-object-expression-91 + lexical-e-2532) + (lexical-join-wraps-449 + lexical-w-2533 + (lexical-syntax-object-wrap-92 + lexical-e-2532))) + (values + '() + lexical-y-pat-2527 + (lexical-match-2519 + lexical-e-2532 + lexical-z-pat-2528 + lexical-w-2533 + lexical-r-2530)))))))) + lexical-f-2531) + lexical-e-2525 + lexical-w-2529))) + (lexical-match-each-any-2515 + (lambda (lexical-e-2538 lexical-w-2539) + (if (lexical-annotation?-158 lexical-e-2538) + (lexical-match-each-any-2515 + (annotation-expression lexical-e-2538) + lexical-w-2539) + (if (pair? lexical-e-2538) + ((lambda (lexical-l-2540) + (if lexical-l-2540 + (cons (lexical-wrap-470 + (car lexical-e-2538) + lexical-w-2539) + lexical-l-2540) + '#f)) + (lexical-match-each-any-2515 + (cdr lexical-e-2538) + lexical-w-2539)) + (if (null? lexical-e-2538) + '() + (if (lexical-syntax-object?-90 + lexical-e-2538) + (lexical-match-each-any-2515 + (lexical-syntax-object-expression-91 + lexical-e-2538) + (lexical-join-wraps-449 + lexical-w-2539 + (lexical-syntax-object-wrap-92 + lexical-e-2538))) + '#f)))))) + (lexical-match-empty-2516 + (lambda (lexical-p-2541 lexical-r-2542) + (if (null? lexical-p-2541) + lexical-r-2542 + (if (eq? lexical-p-2541 'any) + (cons '() lexical-r-2542) + (if (pair? lexical-p-2541) + (lexical-match-empty-2516 + (car lexical-p-2541) + (lexical-match-empty-2516 + (cdr lexical-p-2541) + lexical-r-2542)) + (if (eq? lexical-p-2541 'each-any) + (cons '() lexical-r-2542) + ((lambda (lexical-t-2543) + (if (memv lexical-t-2543 '(each)) + (lexical-match-empty-2516 + (vector-ref lexical-p-2541 '1) + lexical-r-2542) + (if (memv lexical-t-2543 + '(each+)) + (lexical-match-empty-2516 + (vector-ref + lexical-p-2541 + '1) + (lexical-match-empty-2516 + (reverse + (vector-ref + lexical-p-2541 + '2)) + (lexical-match-empty-2516 + (vector-ref + lexical-p-2541 + '3) + lexical-r-2542))) + (if (memv lexical-t-2543 + '(free-id atom)) + lexical-r-2542 + (if (memv lexical-t-2543 + '(vector)) + (lexical-match-empty-2516 + (vector-ref + lexical-p-2541 + '1) + lexical-r-2542) + (void)))))) + (vector-ref lexical-p-2541 '0)))))))) + (lexical-combine-2517 + (lambda (lexical-r*-2544 lexical-r-2545) + (if (null? (car lexical-r*-2544)) + lexical-r-2545 + (cons (map car lexical-r*-2544) + (lexical-combine-2517 + (map cdr lexical-r*-2544) + lexical-r-2545))))) + (lexical-match*-2518 + (lambda (lexical-e-2546 + lexical-p-2547 + lexical-w-2548 + lexical-r-2549) + (if (null? lexical-p-2547) + (if (null? lexical-e-2546) lexical-r-2549 '#f) + (if (pair? lexical-p-2547) + (if (pair? lexical-e-2546) + (lexical-match-2519 + (car lexical-e-2546) + (car lexical-p-2547) + lexical-w-2548 + (lexical-match-2519 + (cdr lexical-e-2546) + (cdr lexical-p-2547) + lexical-w-2548 + lexical-r-2549)) + '#f) + (if (eq? lexical-p-2547 'each-any) + ((lambda (lexical-l-2550) + (if lexical-l-2550 + (cons lexical-l-2550 lexical-r-2549) + '#f)) + (lexical-match-each-any-2515 + lexical-e-2546 + lexical-w-2548)) + ((lambda (lexical-t-2551) + (if (memv lexical-t-2551 '(each)) + (if (null? lexical-e-2546) + (lexical-match-empty-2516 + (vector-ref lexical-p-2547 '1) + lexical-r-2549) + ((lambda (lexical-r*-2552) + (if lexical-r*-2552 + (lexical-combine-2517 + lexical-r*-2552 + lexical-r-2549) + '#f)) + (lexical-match-each-2513 + lexical-e-2546 + (vector-ref lexical-p-2547 '1) + lexical-w-2548))) + (if (memv lexical-t-2551 '(free-id)) + (if (lexical-id?-333 + lexical-e-2546) + (if (lexical-literal-id=?-463 + (lexical-wrap-470 + lexical-e-2546 + lexical-w-2548) + (vector-ref + lexical-p-2547 + '1)) + lexical-r-2549 + '#f) + '#f) + (if (memv lexical-t-2551 + '(each+)) + (call-with-values + (lambda () + (lexical-match-each+-2514 + lexical-e-2546 + (vector-ref + lexical-p-2547 + '1) + (vector-ref + lexical-p-2547 + '2) + (vector-ref + lexical-p-2547 + '3) + lexical-w-2548 + lexical-r-2549)) + (lambda (lexical-xr*-2553 + lexical-y-pat-2554 + lexical-r-2555) + (if lexical-r-2555 + (if (null? lexical-y-pat-2554) + (if (null? lexical-xr*-2553) + (lexical-match-empty-2516 + (vector-ref + lexical-p-2547 + '1) + lexical-r-2555) + (lexical-combine-2517 + lexical-xr*-2553 + lexical-r-2555)) + '#f) + '#f))) + (if (memv lexical-t-2551 + '(atom)) + (if (equal? + (vector-ref + lexical-p-2547 + '1) + (lexical-strip-550 + lexical-e-2546 + lexical-w-2548)) + lexical-r-2549 + '#f) + (if (memv lexical-t-2551 + '(vector)) + (if (vector? + lexical-e-2546) + (lexical-match-2519 + (vector->list + lexical-e-2546) + (vector-ref + lexical-p-2547 + '1) + lexical-w-2548 + lexical-r-2549) + '#f) + (void))))))) + (vector-ref lexical-p-2547 '0))))))) + (lexical-match-2519 + (lambda (lexical-e-2556 + lexical-p-2557 + lexical-w-2558 + lexical-r-2559) + (if (not lexical-r-2559) + '#f + (if (eq? lexical-p-2557 'any) + (cons (lexical-wrap-470 + lexical-e-2556 + lexical-w-2558) + lexical-r-2559) + (if (lexical-syntax-object?-90 lexical-e-2556) + (lexical-match*-2518 + ((lambda (lexical-e-2560) + (if (lexical-annotation?-158 + lexical-e-2560) + (annotation-expression + lexical-e-2560) + lexical-e-2560)) + (lexical-syntax-object-expression-91 + lexical-e-2556)) + lexical-p-2557 + (lexical-join-wraps-449 + lexical-w-2558 + (lexical-syntax-object-wrap-92 + lexical-e-2556)) + lexical-r-2559) + (lexical-match*-2518 + ((lambda (lexical-e-2561) + (if (lexical-annotation?-158 + lexical-e-2561) + (annotation-expression + lexical-e-2561) + lexical-e-2561)) + lexical-e-2556) + lexical-p-2557 + lexical-w-2558 + lexical-r-2559))))))) + (set! $syntax-dispatch + (lambda (lexical-e-2562 lexical-p-2563) + (if (eq? lexical-p-2563 'any) + (list lexical-e-2562) + (if (lexical-syntax-object?-90 lexical-e-2562) + (lexical-match*-2518 + ((lambda (lexical-e-2564) + (if (lexical-annotation?-158 lexical-e-2564) + (annotation-expression lexical-e-2564) + lexical-e-2564)) + (lexical-syntax-object-expression-91 + lexical-e-2562)) + lexical-p-2563 + (lexical-syntax-object-wrap-92 lexical-e-2562) + '()) + (lexical-match*-2518 + ((lambda (lexical-e-2565) + (if (lexical-annotation?-158 lexical-e-2565) + (annotation-expression lexical-e-2565) + lexical-e-2565)) + lexical-e-2562) + lexical-p-2563 + '(()) + '())))))))))))) + +($sc-put-cte + '#(syntax-object + with-syntax + ((top) #(ribcage #(with-syntax) #((top)) #(with-syntax)))) + (lambda (lexical-x-2566) + ((lambda (lexical-tmp-2567) + ((lambda (lexical-tmp-2568) + (if lexical-tmp-2568 + (apply (lambda (lexical-_-2569 lexical-e1-2570 lexical-e2-2571) + (cons '#(syntax-object + begin + ((top) + #(ribcage + #(_ e1 e2) + #((top) (top) (top)) + #("i" "i" "i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(top-ribcage *top* #t))) + (cons lexical-e1-2570 lexical-e2-2571))) + lexical-tmp-2568) + ((lambda (lexical-tmp-2573) + (if lexical-tmp-2573 + (apply (lambda (lexical-_-2574 + lexical-out-2575 + lexical-in-2576 + lexical-e1-2577 + lexical-e2-2578) + (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))) + lexical-in-2576 + '() + (list lexical-out-2575 + (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 lexical-e1-2577 + lexical-e2-2578))))) + lexical-tmp-2573) + ((lambda (lexical-tmp-2580) + (if lexical-tmp-2580 + (apply (lambda (lexical-_-2581 + lexical-out-2582 + lexical-in-2583 + lexical-e1-2584 + lexical-e2-2585) + (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))) + lexical-in-2583) + '() + (list lexical-out-2582 + (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 lexical-e1-2584 + lexical-e2-2585))))) + lexical-tmp-2580) + (syntax-error lexical-tmp-2567))) + ($syntax-dispatch + lexical-tmp-2567 + '(any #(each (any any)) any . each-any))))) + ($syntax-dispatch + lexical-tmp-2567 + '(any ((any any)) any . each-any))))) + ($syntax-dispatch lexical-tmp-2567 '(any () any . each-any)))) + lexical-x-2566)) + '*top*) + +($sc-put-cte + '#(syntax-object + with-implicit + ((top) #(ribcage #(with-implicit) #((top)) #(with-implicit)))) + (lambda (lexical-x-2589) + ((lambda (lexical-tmp-2590) + ((lambda (lexical-tmp-2591) + (if (if lexical-tmp-2591 + (apply (lambda (lexical-dummy-2592 + lexical-tid-2593 + lexical-id-2594 + lexical-e1-2595 + lexical-e2-2596) + (andmap + identifier? + (cons lexical-tid-2593 lexical-id-2594))) + lexical-tmp-2591) + '#f) + (apply (lambda (lexical-dummy-2598 + lexical-tid-2599 + lexical-id-2600 + lexical-e1-2601 + lexical-e2-2602) + (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))) + lexical-tid-2599)) + (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))) + lexical-tid-2599) + '#(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 (lexical-tmp-2603) + (list lexical-tmp-2603 + (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))) + lexical-tid-2599) + (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))) + lexical-tmp-2603)))) + lexical-id-2600) + (cons lexical-e1-2601 lexical-e2-2602))))) + lexical-tmp-2591) + (syntax-error lexical-tmp-2590))) + ($syntax-dispatch + lexical-tmp-2590 + '(any (any . each-any) any . each-any)))) + lexical-x-2589)) + '*top*) + +($sc-put-cte + '#(syntax-object datum ((top) #(ribcage #(datum) #((top)) #(datum)))) + (lambda (lexical-x-2605) + ((lambda (lexical-tmp-2606) + ((lambda (lexical-tmp-2607) + (if lexical-tmp-2607 + (apply (lambda (lexical-dummy-2608 lexical-x-2609) + (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))) + lexical-x-2609))) + lexical-tmp-2607) + (syntax-error lexical-tmp-2606))) + ($syntax-dispatch lexical-tmp-2606 '(any any)))) + lexical-x-2605)) + '*top*) + +($sc-put-cte + '#(syntax-object + syntax-rules + ((top) #(ribcage #(syntax-rules) #((top)) #(syntax-rules)))) + (lambda (lexical-x-2610) + (letrec* ((lexical-clause-2611 + (lambda (lexical-y-2612) + ((lambda (lexical-tmp-2613) + ((lambda (lexical-tmp-2614) + (if lexical-tmp-2614 + (apply (lambda (lexical-keyword-2615 + lexical-pattern-2616 + lexical-template-2617) + (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))) + lexical-pattern-2616) + (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))) + lexical-template-2617))) + lexical-tmp-2614) + ((lambda (lexical-tmp-2618) + (if lexical-tmp-2618 + (apply (lambda (lexical-keyword-2619 + lexical-pattern-2620 + lexical-fender-2621 + lexical-template-2622) + (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))) + lexical-pattern-2620) + lexical-fender-2621 + (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))) + lexical-template-2622))) + lexical-tmp-2618) + ((lambda (lexical-_-2623) + (syntax-error lexical-x-2610)) + lexical-tmp-2613))) + ($syntax-dispatch + lexical-tmp-2613 + '((any . any) any any))))) + ($syntax-dispatch lexical-tmp-2613 '((any . any) any)))) + lexical-y-2612)))) + ((lambda (lexical-tmp-2624) + ((lambda (lexical-tmp-2625) + (if (if lexical-tmp-2625 + (apply (lambda (lexical-_-2626 + lexical-k-2627 + lexical-cl-2628) + (andmap identifier? lexical-k-2627)) + lexical-tmp-2625) + '#f) + (apply (lambda (lexical-_-2630 lexical-k-2631 lexical-cl-2632) + ((lambda (lexical-tmp-2633) + ((lambda (lexical-tmp-2634) + (if lexical-tmp-2634 + (apply (lambda (lexical-cl-2635) + (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 lexical-k-2631 + lexical-cl-2635))))) + lexical-tmp-2634) + (syntax-error lexical-tmp-2633))) + ($syntax-dispatch lexical-tmp-2633 'each-any))) + (map lexical-clause-2611 lexical-cl-2632))) + lexical-tmp-2625) + (syntax-error lexical-tmp-2624))) + ($syntax-dispatch lexical-tmp-2624 '(any each-any . each-any)))) + lexical-x-2610))) + '*top*) + +($sc-put-cte + '#(syntax-object or ((top) #(ribcage #(or) #((top)) #(or)))) + (lambda (lexical-x-2639) + ((lambda (lexical-tmp-2640) + ((lambda (lexical-tmp-2641) + (if lexical-tmp-2641 + (apply (lambda (lexical-_-2642) + '#(syntax-object + #f + ((top) + #(ribcage #(_) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(top-ribcage *top* #t)))) + lexical-tmp-2641) + ((lambda (lexical-tmp-2643) + (if lexical-tmp-2643 + (apply (lambda (lexical-_-2644 lexical-e-2645) + lexical-e-2645) + lexical-tmp-2643) + ((lambda (lexical-tmp-2646) + (if lexical-tmp-2646 + (apply (lambda (lexical-_-2647 + lexical-e1-2648 + lexical-e2-2649 + lexical-e3-2650) + (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))) + lexical-e1-2648)) + (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 lexical-e2-2649 + lexical-e3-2650))))) + lexical-tmp-2646) + (syntax-error lexical-tmp-2640))) + ($syntax-dispatch + lexical-tmp-2640 + '(any any any . each-any))))) + ($syntax-dispatch lexical-tmp-2640 '(any any))))) + ($syntax-dispatch lexical-tmp-2640 '(any)))) + lexical-x-2639)) + '*top*) + +($sc-put-cte + '#(syntax-object and ((top) #(ribcage #(and) #((top)) #(and)))) + (lambda (lexical-x-2652) + ((lambda (lexical-tmp-2653) + ((lambda (lexical-tmp-2654) + (if lexical-tmp-2654 + (apply (lambda (lexical-_-2655 + lexical-e1-2656 + lexical-e2-2657 + lexical-e3-2658) + (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 lexical-e1-2656 + (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 lexical-e2-2657 + lexical-e3-2658)) + '#(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))))))) + lexical-tmp-2654) + ((lambda (lexical-tmp-2660) + (if lexical-tmp-2660 + (apply (lambda (lexical-_-2661 lexical-e-2662) + lexical-e-2662) + lexical-tmp-2660) + ((lambda (lexical-tmp-2663) + (if lexical-tmp-2663 + (apply (lambda (lexical-_-2664) + '#(syntax-object + #t + ((top) + #(ribcage #(_) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(top-ribcage *top* #t)))) + lexical-tmp-2663) + (syntax-error lexical-tmp-2653))) + ($syntax-dispatch lexical-tmp-2653 '(any))))) + ($syntax-dispatch lexical-tmp-2653 '(any any))))) + ($syntax-dispatch lexical-tmp-2653 '(any any any . each-any)))) + lexical-x-2652)) + '*top*) + +($sc-put-cte + '#(syntax-object let ((top) #(ribcage #(let) #((top)) #(let)))) + (lambda (lexical-x-2665) + ((lambda (lexical-tmp-2666) + ((lambda (lexical-tmp-2667) + (if (if lexical-tmp-2667 + (apply (lambda (lexical-_-2668 + lexical-x-2669 + lexical-v-2670 + lexical-e1-2671 + lexical-e2-2672) + (andmap identifier? lexical-x-2669)) + lexical-tmp-2667) + '#f) + (apply (lambda (lexical-_-2674 + lexical-x-2675 + lexical-v-2676 + lexical-e1-2677 + lexical-e2-2678) + (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 lexical-x-2675 + (cons lexical-e1-2677 lexical-e2-2678))) + lexical-v-2676)) + lexical-tmp-2667) + ((lambda (lexical-tmp-2682) + (if (if lexical-tmp-2682 + (apply (lambda (lexical-_-2683 + lexical-f-2684 + lexical-x-2685 + lexical-v-2686 + lexical-e1-2687 + lexical-e2-2688) + (andmap + identifier? + (cons lexical-f-2684 lexical-x-2685))) + lexical-tmp-2682) + '#f) + (apply (lambda (lexical-_-2690 + lexical-f-2691 + lexical-x-2692 + lexical-v-2693 + lexical-e1-2694 + lexical-e2-2695) + (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 lexical-f-2691 + (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 lexical-x-2692 + (cons lexical-e1-2694 + lexical-e2-2695))))) + lexical-f-2691) + lexical-v-2693)) + lexical-tmp-2682) + (syntax-error lexical-tmp-2666))) + ($syntax-dispatch + lexical-tmp-2666 + '(any any #(each (any any)) any . each-any))))) + ($syntax-dispatch + lexical-tmp-2666 + '(any #(each (any any)) any . each-any)))) + lexical-x-2665)) + '*top*) + +($sc-put-cte + '#(syntax-object let* ((top) #(ribcage #(let*) #((top)) #(let*)))) + (lambda (lexical-x-2699) + ((lambda (lexical-tmp-2700) + ((lambda (lexical-tmp-2701) + (if (if lexical-tmp-2701 + (apply (lambda (lexical-let*-2702 + lexical-x-2703 + lexical-v-2704 + lexical-e1-2705 + lexical-e2-2706) + (andmap identifier? lexical-x-2703)) + lexical-tmp-2701) + '#f) + (apply (lambda (lexical-let*-2708 + lexical-x-2709 + lexical-v-2710 + lexical-e1-2711 + lexical-e2-2712) + ((letrec ((lexical-f-2713 + (lambda (lexical-bindings-2714) + (if (null? lexical-bindings-2714) + (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 lexical-e1-2711 + lexical-e2-2712))) + ((lambda (lexical-tmp-2716) + ((lambda (lexical-tmp-2717) + (if lexical-tmp-2717 + (apply (lambda (lexical-body-2718 + lexical-binding-2719) + (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 lexical-binding-2719) + lexical-body-2718)) + lexical-tmp-2717) + (syntax-error + lexical-tmp-2716))) + ($syntax-dispatch + lexical-tmp-2716 + '(any any)))) + (list (lexical-f-2713 + (cdr lexical-bindings-2714)) + (car lexical-bindings-2714))))))) + lexical-f-2713) + (map list lexical-x-2709 lexical-v-2710))) + lexical-tmp-2701) + (syntax-error lexical-tmp-2700))) + ($syntax-dispatch + lexical-tmp-2700 + '(any #(each (any any)) any . each-any)))) + lexical-x-2699)) + '*top*) + +($sc-put-cte + '#(syntax-object cond ((top) #(ribcage #(cond) #((top)) #(cond)))) + (lambda (lexical-x-2723) + ((lambda (lexical-tmp-2724) + ((lambda (lexical-tmp-2725) + (if lexical-tmp-2725 + (apply (lambda (lexical-_-2726 lexical-m1-2727 lexical-m2-2728) + ((letrec ((lexical-f-2729 + (lambda (lexical-clause-2730 + lexical-clauses-2731) + (if (null? lexical-clauses-2731) + ((lambda (lexical-tmp-2732) + ((lambda (lexical-tmp-2733) + (if lexical-tmp-2733 + (apply (lambda (lexical-e1-2734 + lexical-e2-2735) + (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 lexical-e1-2734 + lexical-e2-2735))) + lexical-tmp-2733) + ((lambda (lexical-tmp-2737) + (if lexical-tmp-2737 + (apply (lambda (lexical-e0-2738) + (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))) + lexical-e0-2738)) + '#(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)))))) + lexical-tmp-2737) + ((lambda (lexical-tmp-2739) + (if lexical-tmp-2739 + (apply (lambda (lexical-e0-2740 + lexical-e1-2741) + (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))) + lexical-e0-2740)) + (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 lexical-e1-2741 + '#(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))))))) + lexical-tmp-2739) + ((lambda (lexical-tmp-2742) + (if lexical-tmp-2742 + (apply (lambda (lexical-e0-2743 + lexical-e1-2744 + lexical-e2-2745) + (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))) + lexical-e0-2743 + (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 lexical-e1-2744 + lexical-e2-2745)))) + lexical-tmp-2742) + ((lambda (lexical-_-2747) + (syntax-error + lexical-x-2723)) + lexical-tmp-2732))) + ($syntax-dispatch + lexical-tmp-2732 + '(any any + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2732 + '(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 + lexical-tmp-2732 + '(any))))) + ($syntax-dispatch + lexical-tmp-2732 + '(#(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)))) + lexical-clause-2730) + ((lambda (lexical-tmp-2748) + ((lambda (lexical-rest-2749) + ((lambda (lexical-tmp-2750) + ((lambda (lexical-tmp-2751) + (if lexical-tmp-2751 + (apply (lambda (lexical-e0-2752) + (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))) + lexical-e0-2752)) + (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))) + lexical-rest-2749))) + lexical-tmp-2751) + ((lambda (lexical-tmp-2753) + (if lexical-tmp-2753 + (apply (lambda (lexical-e0-2754 + lexical-e1-2755) + (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))) + lexical-e0-2754)) + (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 lexical-e1-2755 + '#(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)))) + lexical-rest-2749))) + lexical-tmp-2753) + ((lambda (lexical-tmp-2756) + (if lexical-tmp-2756 + (apply (lambda (lexical-e0-2757 + lexical-e1-2758 + lexical-e2-2759) + (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))) + lexical-e0-2757 + (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 lexical-e1-2758 + lexical-e2-2759)) + lexical-rest-2749)) + lexical-tmp-2756) + ((lambda (lexical-_-2761) + (syntax-error + lexical-x-2723)) + lexical-tmp-2750))) + ($syntax-dispatch + lexical-tmp-2750 + '(any any + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2750 + '(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 + lexical-tmp-2750 + '(any)))) + lexical-clause-2730)) + lexical-tmp-2748)) + (lexical-f-2729 + (car lexical-clauses-2731) + (cdr lexical-clauses-2731))))))) + lexical-f-2729) + lexical-m1-2727 + lexical-m2-2728)) + lexical-tmp-2725) + (syntax-error lexical-tmp-2724))) + ($syntax-dispatch lexical-tmp-2724 '(any any . each-any)))) + lexical-x-2723)) + '*top*) + +($sc-put-cte + '#(syntax-object do ((top) #(ribcage #(do) #((top)) #(do)))) + (lambda (lexical-orig-x-2764) + ((lambda (lexical-tmp-2765) + ((lambda (lexical-tmp-2766) + (if lexical-tmp-2766 + (apply (lambda (lexical-_-2767 + lexical-var-2768 + lexical-init-2769 + lexical-step-2770 + lexical-e0-2771 + lexical-e1-2772 + lexical-c-2773) + ((lambda (lexical-tmp-2774) + ((lambda (lexical-tmp-2775) + (if lexical-tmp-2775 + (apply (lambda (lexical-step-2776) + ((lambda (lexical-tmp-2777) + ((lambda (lexical-tmp-2778) + (if lexical-tmp-2778 + (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 + lexical-var-2768 + lexical-init-2769) + (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))) + lexical-e0-2771) + (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 + lexical-c-2773 + (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))) + lexical-step-2776))))))) + lexical-tmp-2778) + ((lambda (lexical-tmp-2783) + (if lexical-tmp-2783 + (apply (lambda (lexical-e1-2784 + lexical-e2-2785) + (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 + lexical-var-2768 + lexical-init-2769) + (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))) + lexical-e0-2771 + (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 lexical-e1-2784 + lexical-e2-2785)) + (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 + lexical-c-2773 + (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))) + lexical-step-2776))))))) + lexical-tmp-2783) + (syntax-error + lexical-tmp-2777))) + ($syntax-dispatch + lexical-tmp-2777 + '(any . each-any))))) + ($syntax-dispatch + lexical-tmp-2777 + '()))) + lexical-e1-2772)) + lexical-tmp-2775) + (syntax-error lexical-tmp-2774))) + ($syntax-dispatch lexical-tmp-2774 'each-any))) + (map (lambda (lexical-v-2792 lexical-s-2793) + ((lambda (lexical-tmp-2794) + ((lambda (lexical-tmp-2795) + (if lexical-tmp-2795 + (apply (lambda () lexical-v-2792) + lexical-tmp-2795) + ((lambda (lexical-tmp-2796) + (if lexical-tmp-2796 + (apply (lambda (lexical-e-2797) + lexical-e-2797) + lexical-tmp-2796) + ((lambda (lexical-_-2798) + (syntax-error + lexical-orig-x-2764)) + lexical-tmp-2794))) + ($syntax-dispatch + lexical-tmp-2794 + '(any))))) + ($syntax-dispatch lexical-tmp-2794 '()))) + lexical-s-2793)) + lexical-var-2768 + lexical-step-2770))) + lexical-tmp-2766) + (syntax-error lexical-tmp-2765))) + ($syntax-dispatch + lexical-tmp-2765 + '(any #(each (any any . any)) (any . each-any) . each-any)))) + lexical-orig-x-2764)) + '*top*) + +($sc-put-cte + '#(syntax-object + quasiquote + ((top) #(ribcage #(quasiquote) #((top)) #(quasiquote)))) + ((lambda () + (letrec* ((lexical-quasi-2801 + (lambda (lexical-p-2808 lexical-lev-2809) + ((lambda (lexical-tmp-2810) + ((lambda (lexical-tmp-2811) + (if lexical-tmp-2811 + (apply (lambda (lexical-p-2812) + (if (= lexical-lev-2809 '0) + (list '#(syntax-object + "value" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage *top* #t))) + lexical-p-2812) + (lexical-quasicons-2803 + '#(syntax-object + ("quote" unquote) + ((top) + #(ribcage #(p) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t))) + (lexical-quasi-2801 + (list lexical-p-2812) + (- lexical-lev-2809 '1))))) + lexical-tmp-2811) + ((lambda (lexical-tmp-2813) + (if lexical-tmp-2813 + (apply (lambda (lexical-p-2814) + (lexical-quasicons-2803 + '#(syntax-object + ("quote" quasiquote) + ((top) + #(ribcage #(p) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t))) + (lexical-quasi-2801 + (list lexical-p-2814) + (+ lexical-lev-2809 '1)))) + lexical-tmp-2813) + ((lambda (lexical-tmp-2815) + (if lexical-tmp-2815 + (apply (lambda (lexical-p-2816 + lexical-q-2817) + ((lambda (lexical-tmp-2818) + ((lambda (lexical-tmp-2819) + (if lexical-tmp-2819 + (apply (lambda (lexical-p-2820) + (if (= lexical-lev-2809 + '0) + (lexical-quasilist*-2805 + (map (lambda (lexical-tmp-2821) + (list '#(syntax-object + "value" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + #(p q) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2821)) + lexical-p-2820) + (lexical-quasi-2801 + lexical-q-2817 + lexical-lev-2809)) + (lexical-quasicons-2803 + (lexical-quasicons-2803 + '#(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 + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (lexical-quasi-2801 + lexical-p-2820 + (- lexical-lev-2809 + '1))) + (lexical-quasi-2801 + lexical-q-2817 + lexical-lev-2809)))) + lexical-tmp-2819) + ((lambda (lexical-tmp-2823) + (if lexical-tmp-2823 + (apply (lambda (lexical-p-2824) + (if (= lexical-lev-2809 + '0) + (lexical-quasiappend-2804 + (map (lambda (lexical-tmp-2825) + (list '#(syntax-object + "value" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + #(p q) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2825)) + lexical-p-2824) + (lexical-quasi-2801 + lexical-q-2817 + lexical-lev-2809)) + (lexical-quasicons-2803 + (lexical-quasicons-2803 + '#(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 + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (lexical-quasi-2801 + lexical-p-2824 + (- lexical-lev-2809 + '1))) + (lexical-quasi-2801 + lexical-q-2817 + lexical-lev-2809)))) + lexical-tmp-2823) + ((lambda (lexical-_-2827) + (lexical-quasicons-2803 + (lexical-quasi-2801 + lexical-p-2816 + lexical-lev-2809) + (lexical-quasi-2801 + lexical-q-2817 + lexical-lev-2809))) + lexical-tmp-2818))) + ($syntax-dispatch + lexical-tmp-2818 + '(#(free-id + #(syntax-object + unquote-splicing + ((top) + #(ribcage + #(p q) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2818 + '(#(free-id + #(syntax-object + unquote + ((top) + #(ribcage + #(p q) + #((top) (top)) + #("i" "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t)))) + . + each-any)))) + lexical-p-2816)) + lexical-tmp-2815) + ((lambda (lexical-tmp-2828) + (if lexical-tmp-2828 + (apply (lambda (lexical-x-2829) + (lexical-quasivector-2806 + (lexical-vquasi-2802 + lexical-x-2829 + lexical-lev-2809))) + lexical-tmp-2828) + ((lambda (lexical-p-2831) + (list '#(syntax-object + "quote" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-p-2831)) + lexical-tmp-2810))) + ($syntax-dispatch + lexical-tmp-2810 + '#(vector each-any))))) + ($syntax-dispatch + lexical-tmp-2810 + '(any . any))))) + ($syntax-dispatch + lexical-tmp-2810 + '(#(free-id + #(syntax-object + quasiquote + ((top) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t)))) + any))))) + ($syntax-dispatch + lexical-tmp-2810 + '(#(free-id + #(syntax-object + unquote + ((top) + #(ribcage () () ()) + #(ribcage #(p lev) #((top) (top)) #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) (top) (top) (top) (top) (top) (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t)))) + any)))) + lexical-p-2808))) + (lexical-vquasi-2802 + (lambda (lexical-p-2832 lexical-lev-2833) + ((lambda (lexical-tmp-2834) + ((lambda (lexical-tmp-2835) + (if lexical-tmp-2835 + (apply (lambda (lexical-p-2836 lexical-q-2837) + ((lambda (lexical-tmp-2838) + ((lambda (lexical-tmp-2839) + (if lexical-tmp-2839 + (apply (lambda (lexical-p-2840) + (if (= lexical-lev-2833 + '0) + (lexical-quasilist*-2805 + (map (lambda (lexical-tmp-2841) + (list '#(syntax-object + "value" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + #(p q) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2841)) + lexical-p-2840) + (lexical-vquasi-2802 + lexical-q-2837 + lexical-lev-2833)) + (lexical-quasicons-2803 + (lexical-quasicons-2803 + '#(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 + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (lexical-quasi-2801 + lexical-p-2840 + (- lexical-lev-2833 + '1))) + (lexical-vquasi-2802 + lexical-q-2837 + lexical-lev-2833)))) + lexical-tmp-2839) + ((lambda (lexical-tmp-2843) + (if lexical-tmp-2843 + (apply (lambda (lexical-p-2844) + (if (= lexical-lev-2833 + '0) + (lexical-quasiappend-2804 + (map (lambda (lexical-tmp-2845) + (list '#(syntax-object + "value" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + #(p q) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(p lev) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2845)) + lexical-p-2844) + (lexical-vquasi-2802 + lexical-q-2837 + lexical-lev-2833)) + (lexical-quasicons-2803 + (lexical-quasicons-2803 + '#(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 + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (lexical-quasi-2801 + lexical-p-2844 + (- lexical-lev-2833 + '1))) + (lexical-vquasi-2802 + lexical-q-2837 + lexical-lev-2833)))) + lexical-tmp-2843) + ((lambda (lexical-_-2847) + (lexical-quasicons-2803 + (lexical-quasi-2801 + lexical-p-2836 + lexical-lev-2833) + (lexical-vquasi-2802 + lexical-q-2837 + lexical-lev-2833))) + lexical-tmp-2838))) + ($syntax-dispatch + lexical-tmp-2838 + '(#(free-id + #(syntax-object + unquote-splicing + ((top) + #(ribcage + #(p q) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage *top* #t)))) + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2838 + '(#(free-id + #(syntax-object + unquote + ((top) + #(ribcage + #(p q) + #((top) (top)) + #("i" "i")) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t)))) + . + each-any)))) + lexical-p-2836)) + lexical-tmp-2835) + ((lambda (lexical-tmp-2848) + (if lexical-tmp-2848 + (apply (lambda () + '#(syntax-object + ("quote" ()) + ((top) + #(ribcage () () ()) + #(ribcage + #(p lev) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t)))) + lexical-tmp-2848) + (syntax-error lexical-tmp-2834))) + ($syntax-dispatch lexical-tmp-2834 '())))) + ($syntax-dispatch lexical-tmp-2834 '(any . any)))) + lexical-p-2832))) + (lexical-quasicons-2803 + (lambda (lexical-x-2849 lexical-y-2850) + ((lambda (lexical-tmp-2851) + ((lambda (lexical-tmp-2852) + (if lexical-tmp-2852 + (apply (lambda (lexical-x-2853 lexical-y-2854) + ((lambda (lexical-tmp-2855) + ((lambda (lexical-tmp-2856) + (if lexical-tmp-2856 + (apply (lambda (lexical-dy-2857) + ((lambda (lexical-tmp-2858) + ((lambda (lexical-tmp-2859) + (if lexical-tmp-2859 + (apply (lambda (lexical-dx-2860) + (list '#(syntax-object + "quote" + ((top) + #(ribcage + #(dx) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-dx-2860 + lexical-dy-2857))) + lexical-tmp-2859) + ((lambda (lexical-_-2861) + (if (null? lexical-dy-2857) + (list '#(syntax-object + "list" + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-x-2853) + (list '#(syntax-object + "list*" + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + #(dy) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-x-2853 + lexical-y-2854))) + lexical-tmp-2858))) + ($syntax-dispatch + lexical-tmp-2858 + '(#(atom "quote") + any)))) + lexical-x-2853)) + lexical-tmp-2856) + ((lambda (lexical-tmp-2862) + (if lexical-tmp-2862 + (apply (lambda (lexical-stuff-2863) + (cons '#(syntax-object + "list" + ((top) + #(ribcage + #(stuff) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-x-2853 + lexical-stuff-2863))) + lexical-tmp-2862) + ((lambda (lexical-tmp-2864) + (if lexical-tmp-2864 + (apply (lambda (lexical-stuff-2865) + (cons '#(syntax-object + "list*" + ((top) + #(ribcage + #(stuff) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (cons lexical-x-2853 + lexical-stuff-2865))) + lexical-tmp-2864) + ((lambda (lexical-_-2866) + (list '#(syntax-object + "list*" + ((top) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-x-2853 + lexical-y-2854)) + lexical-tmp-2855))) + ($syntax-dispatch + lexical-tmp-2855 + '(#(atom "list*") . any))))) + ($syntax-dispatch + lexical-tmp-2855 + '(#(atom "list") . any))))) + ($syntax-dispatch + lexical-tmp-2855 + '(#(atom "quote") any)))) + lexical-y-2854)) + lexical-tmp-2852) + (syntax-error lexical-tmp-2851))) + ($syntax-dispatch lexical-tmp-2851 '(any any)))) + (list lexical-x-2849 lexical-y-2850)))) + (lexical-quasiappend-2804 + (lambda (lexical-x-2867 lexical-y-2868) + ((lambda (lexical-tmp-2869) + ((lambda (lexical-tmp-2870) + (if lexical-tmp-2870 + (apply (lambda () + (if (null? lexical-x-2867) + '#(syntax-object + ("quote" ()) + ((top) + #(ribcage () () ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t))) + (if (null? (cdr lexical-x-2867)) + (car lexical-x-2867) + ((lambda (lexical-tmp-2871) + ((lambda (lexical-tmp-2872) + (if lexical-tmp-2872 + (apply (lambda (lexical-p-2873) + (cons '#(syntax-object + "append" + ((top) + #(ribcage + #(p) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-p-2873)) + lexical-tmp-2872) + (syntax-error + lexical-tmp-2871))) + ($syntax-dispatch + lexical-tmp-2871 + 'each-any))) + lexical-x-2867)))) + lexical-tmp-2870) + ((lambda (lexical-_-2875) + (if (null? lexical-x-2867) + lexical-y-2868 + ((lambda (lexical-tmp-2876) + ((lambda (lexical-tmp-2877) + (if lexical-tmp-2877 + (apply (lambda (lexical-p-2878 + lexical-y-2879) + (cons '#(syntax-object + "append" + ((top) + #(ribcage + #(p y) + #((top) (top)) + #("i" "i")) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x y) + #((top) (top)) + #("i" "i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + (append + lexical-p-2878 + (list lexical-y-2879)))) + lexical-tmp-2877) + (syntax-error lexical-tmp-2876))) + ($syntax-dispatch + lexical-tmp-2876 + '(each-any any)))) + (list lexical-x-2867 lexical-y-2868)))) + lexical-tmp-2869))) + ($syntax-dispatch lexical-tmp-2869 '(#(atom "quote") ())))) + lexical-y-2868))) + (lexical-quasilist*-2805 + (lambda (lexical-x-2881 lexical-y-2882) + ((letrec ((lexical-f-2883 + (lambda (lexical-x-2884) + (if (null? lexical-x-2884) + lexical-y-2882 + (lexical-quasicons-2803 + (car lexical-x-2884) + (lexical-f-2883 (cdr lexical-x-2884))))))) + lexical-f-2883) + lexical-x-2881))) + (lexical-quasivector-2806 + (lambda (lexical-x-2885) + ((lambda (lexical-tmp-2886) + ((lambda (lexical-tmp-2887) + (if lexical-tmp-2887 + (apply (lambda (lexical-x-2888) + (list '#(syntax-object + "quote" + ((top) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t))) + (list->vector lexical-x-2888))) + lexical-tmp-2887) + ((lambda (lexical-_-2890) + ((letrec ((lexical-f-2891 + (lambda (lexical-y-2892 + lexical-k-2893) + ((lambda (lexical-tmp-2894) + ((lambda (lexical-tmp-2895) + (if lexical-tmp-2895 + (apply (lambda (lexical-y-2896) + (lexical-k-2893 + (map (lambda (lexical-tmp-2897) + (list '#(syntax-object + "quote" + ((top) + #(ribcage + #(y) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(y k) + #((top) + (top)) + #("i" + "i")) + #(ribcage + #(f) + #((top)) + #("i")) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-tmp-2897)) + lexical-y-2896))) + lexical-tmp-2895) + ((lambda (lexical-tmp-2898) + (if lexical-tmp-2898 + (apply (lambda (lexical-y-2899) + (lexical-k-2893 + lexical-y-2899)) + lexical-tmp-2898) + ((lambda (lexical-tmp-2901) + (if lexical-tmp-2901 + (apply (lambda (lexical-y-2902 + lexical-z-2903) + (lexical-f-2891 + lexical-z-2903 + (lambda (lexical-ls-2904) + (lexical-k-2893 + (append + lexical-y-2902 + lexical-ls-2904))))) + lexical-tmp-2901) + ((lambda (lexical-else-2906) + ((lambda (lexical-tmp-2907) + ((lambda (lexical-t1-2908) + (list '#(syntax-object + "list->vector" + ((top) + #(ribcage + #(t1) + #(("m" + tmp)) + #("i")) + #(ribcage + #(else) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(y k) + #((top) + (top)) + #("i" + "i")) + #(ribcage + #(f) + #((top)) + #("i")) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t1-2908)) + lexical-tmp-2907)) + lexical-x-2885)) + lexical-tmp-2894))) + ($syntax-dispatch + lexical-tmp-2894 + '(#(atom "list*") + . + #(each+ any + (any) + ())))))) + ($syntax-dispatch + lexical-tmp-2894 + '(#(atom "list") + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2894 + '(#(atom "quote") each-any)))) + lexical-y-2892)))) + lexical-f-2891) + lexical-x-2885 + (lambda (lexical-ls-2909) + ((lambda (lexical-tmp-2910) + ((lambda (lexical-tmp-2911) + (if lexical-tmp-2911 + (apply (lambda (lexical-t2-2912) + (cons '#(syntax-object + "vector" + ((top) + #(ribcage + #(t2) + #(("m" tmp)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(ls) + #((top)) + #("i")) + #(ribcage + #(_) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t2-2912)) + lexical-tmp-2911) + (syntax-error lexical-tmp-2910))) + ($syntax-dispatch + lexical-tmp-2910 + 'each-any))) + lexical-ls-2909)))) + lexical-tmp-2886))) + ($syntax-dispatch + lexical-tmp-2886 + '(#(atom "quote") each-any)))) + lexical-x-2885))) + (lexical-emit-2807 + (lambda (lexical-x-2914) + ((lambda (lexical-tmp-2915) + ((lambda (lexical-tmp-2916) + (if lexical-tmp-2916 + (apply (lambda (lexical-x-2917) + (list '#(syntax-object + quote + ((top) + #(ribcage #(x) #((top)) #("i")) + #(ribcage () () ()) + #(ribcage #(x) #((top)) #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" "i" "i" "i" "i" "i" "i")) + #(top-ribcage *top* #t))) + lexical-x-2917)) + lexical-tmp-2916) + ((lambda (lexical-tmp-2918) + (if lexical-tmp-2918 + (apply (lambda (lexical-x-2919) + ((lambda (lexical-tmp-2920) + ((lambda (lexical-tmp-2921) + (if lexical-tmp-2921 + (apply (lambda (lexical-t3-2922) + (cons '#(syntax-object + list + ((top) + #(ribcage + #(t3) + #(("m" + tmp)) + #("i")) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t3-2922)) + lexical-tmp-2921) + (syntax-error + lexical-tmp-2920))) + ($syntax-dispatch + lexical-tmp-2920 + 'each-any))) + (map lexical-emit-2807 + lexical-x-2919))) + lexical-tmp-2918) + ((lambda (lexical-tmp-2925) + (if lexical-tmp-2925 + (apply (lambda (lexical-x-2926 + lexical-y-2927) + ((letrec ((lexical-f-2928 + (lambda (lexical-x*-2929) + (if (null? lexical-x*-2929) + (lexical-emit-2807 + lexical-y-2927) + ((lambda (lexical-tmp-2930) + ((lambda (lexical-tmp-2931) + (if lexical-tmp-2931 + (apply (lambda (lexical-t5-2932 + lexical-t4-2933) + (list '#(syntax-object + cons + ((top) + #(ribcage + #(t5 t4) + #(("m" + tmp) + ("m" + tmp)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x*) + #((top)) + #("i")) + #(ribcage + #(f) + #((top)) + #("i")) + #(ribcage + #(x y) + #((top) + (top)) + #("i" + "i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t5-2932 + lexical-t4-2933)) + lexical-tmp-2931) + (syntax-error + lexical-tmp-2930))) + ($syntax-dispatch + lexical-tmp-2930 + '(any any)))) + (list (lexical-emit-2807 + (car lexical-x*-2929)) + (lexical-f-2928 + (cdr lexical-x*-2929)))))))) + lexical-f-2928) + lexical-x-2926)) + lexical-tmp-2925) + ((lambda (lexical-tmp-2935) + (if lexical-tmp-2935 + (apply (lambda (lexical-x-2936) + ((lambda (lexical-tmp-2937) + ((lambda (lexical-tmp-2938) + (if lexical-tmp-2938 + (apply (lambda (lexical-t6-2939) + (cons '#(syntax-object + append + ((top) + #(ribcage + #(t6) + #(("m" + tmp)) + #("i")) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t6-2939)) + lexical-tmp-2938) + (syntax-error + lexical-tmp-2937))) + ($syntax-dispatch + lexical-tmp-2937 + 'each-any))) + (map lexical-emit-2807 + lexical-x-2936))) + lexical-tmp-2935) + ((lambda (lexical-tmp-2942) + (if lexical-tmp-2942 + (apply (lambda (lexical-x-2943) + ((lambda (lexical-tmp-2944) + ((lambda (lexical-tmp-2945) + (if lexical-tmp-2945 + (apply (lambda (lexical-t7-2946) + (cons '#(syntax-object + vector + ((top) + #(ribcage + #(t7) + #(("m" + tmp)) + #("i")) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t7-2946)) + lexical-tmp-2945) + (syntax-error + lexical-tmp-2944))) + ($syntax-dispatch + lexical-tmp-2944 + 'each-any))) + (map lexical-emit-2807 + lexical-x-2943))) + lexical-tmp-2942) + ((lambda (lexical-tmp-2949) + (if lexical-tmp-2949 + (apply (lambda (lexical-x-2950) + ((lambda (lexical-tmp-2951) + ((lambda (lexical-t8-2952) + (list '#(syntax-object + list->vector + ((top) + #(ribcage + #(t8) + #(("m" + tmp)) + #("i")) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + () + () + ()) + #(ribcage + #(x) + #((top)) + #("i")) + #(ribcage + (emit quasivector + quasilist* + quasiappend + quasicons + vquasi + quasi) + ((top) + (top) + (top) + (top) + (top) + (top) + (top)) + ("i" + "i" + "i" + "i" + "i" + "i" + "i")) + #(top-ribcage + *top* + #t))) + lexical-t8-2952)) + lexical-tmp-2951)) + (lexical-emit-2807 + lexical-x-2950))) + lexical-tmp-2949) + ((lambda (lexical-tmp-2953) + (if lexical-tmp-2953 + (apply (lambda (lexical-x-2954) + lexical-x-2954) + lexical-tmp-2953) + (syntax-error + lexical-tmp-2915))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "value") + any))))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "list->vector") + any))))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "vector") + . + each-any))))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "append") . each-any))))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "list*") . #(each+ any (any) ())))))) + ($syntax-dispatch + lexical-tmp-2915 + '(#(atom "list") . each-any))))) + ($syntax-dispatch lexical-tmp-2915 '(#(atom "quote") any)))) + lexical-x-2914)))) + (lambda (lexical-x-2955) + ((lambda (lexical-tmp-2956) + ((lambda (lexical-tmp-2957) + (if lexical-tmp-2957 + (apply (lambda (lexical-_-2958 lexical-e-2959) + (lexical-emit-2807 + (lexical-quasi-2801 lexical-e-2959 '0))) + lexical-tmp-2957) + (syntax-error lexical-tmp-2956))) + ($syntax-dispatch lexical-tmp-2956 '(any any)))) + lexical-x-2955))))) + '*top*) + +($sc-put-cte + '#(syntax-object unquote ((top) #(ribcage #(unquote) #((top)) #(unquote)))) + (lambda (lexical-x-2963) (syntax-error lexical-x-2963 '"misplaced")) + '*top*) + +($sc-put-cte + '#(syntax-object + unquote-splicing + ((top) #(ribcage #(unquote-splicing) #((top)) #(unquote-splicing)))) + (lambda (lexical-x-2964) (syntax-error lexical-x-2964 '"misplaced")) + '*top*) + +($sc-put-cte + '#(syntax-object + quasisyntax + ((top) #(ribcage #(quasisyntax) #((top)) #(quasisyntax)))) + (lambda (lexical-x-2965) + (letrec* ((lexical-qs-2966 + (lambda (lexical-q-2968 + lexical-n-2969 + lexical-b*-2970 + lexical-k-2971) + ((lambda (lexical-tmp-2972) + ((lambda (lexical-tmp-2973) + (if lexical-tmp-2973 + (apply (lambda (lexical-d-2974) + (lexical-qs-2966 + lexical-d-2974 + (+ lexical-n-2969 '1) + lexical-b*-2970 + (lambda (lexical-b*-2975 lexical-dnew-2976) + (lexical-k-2971 + lexical-b*-2975 + (if (eq? lexical-dnew-2976 + lexical-d-2974) + lexical-q-2968 + ((lambda (lexical-tmp-2977) + ((lambda (lexical-d-2978) + (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))) + lexical-d-2978)) + lexical-tmp-2977)) + lexical-dnew-2976)))))) + lexical-tmp-2973) + ((lambda (lexical-tmp-2979) + (if (if lexical-tmp-2979 + (apply (lambda (lexical-d-2980) + (not (= lexical-n-2969 '0))) + lexical-tmp-2979) + '#f) + (apply (lambda (lexical-d-2981) + (lexical-qs-2966 + lexical-d-2981 + (- lexical-n-2969 '1) + lexical-b*-2970 + (lambda (lexical-b*-2982 + lexical-dnew-2983) + (lexical-k-2971 + lexical-b*-2982 + (if (eq? lexical-dnew-2983 + lexical-d-2981) + lexical-q-2968 + ((lambda (lexical-tmp-2984) + ((lambda (lexical-d-2985) + (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))) + lexical-d-2985)) + lexical-tmp-2984)) + lexical-dnew-2983)))))) + lexical-tmp-2979) + ((lambda (lexical-tmp-2986) + (if (if lexical-tmp-2986 + (apply (lambda (lexical-d-2987) + (not (= lexical-n-2969 '0))) + lexical-tmp-2986) + '#f) + (apply (lambda (lexical-d-2988) + (lexical-qs-2966 + lexical-d-2988 + (- lexical-n-2969 '1) + lexical-b*-2970 + (lambda (lexical-b*-2989 + lexical-dnew-2990) + (lexical-k-2971 + lexical-b*-2989 + (if (eq? lexical-dnew-2990 + lexical-d-2988) + lexical-q-2968 + ((lambda (lexical-tmp-2991) + ((lambda (lexical-d-2992) + (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))) + lexical-d-2992)) + lexical-tmp-2991)) + lexical-dnew-2990)))))) + lexical-tmp-2986) + ((lambda (lexical-tmp-2993) + (if (if lexical-tmp-2993 + (apply (lambda (lexical-q-2994) + (= lexical-n-2969 + '0)) + lexical-tmp-2993) + '#f) + (apply (lambda (lexical-q-2995) + ((lambda (lexical-tmp-2996) + ((lambda (lexical-tmp-2997) + (if lexical-tmp-2997 + (apply (lambda (lexical-t-2998) + (lexical-k-2971 + (cons (list lexical-t-2998 + lexical-q-2995) + lexical-b*-2970) + lexical-t-2998)) + lexical-tmp-2997) + (syntax-error + lexical-tmp-2996))) + ($syntax-dispatch + lexical-tmp-2996 + '(any)))) + (generate-temporaries + (list lexical-q-2995)))) + lexical-tmp-2993) + ((lambda (lexical-tmp-2999) + (if (if lexical-tmp-2999 + (apply (lambda (lexical-q-3000 + lexical-d-3001) + (= lexical-n-2969 + '0)) + lexical-tmp-2999) + '#f) + (apply (lambda (lexical-q-3002 + lexical-d-3003) + (lexical-qs-2966 + lexical-d-3003 + lexical-n-2969 + lexical-b*-2970 + (lambda (lexical-b*-3004 + lexical-dnew-3005) + ((lambda (lexical-tmp-3006) + ((lambda (lexical-tmp-3007) + (if lexical-tmp-3007 + (apply (lambda (lexical-t-3008) + (lexical-k-2971 + (append + (map list + lexical-t-3008 + lexical-q-3002) + lexical-b*-3004) + ((lambda (lexical-tmp-3011) + ((lambda (lexical-d-3012) + (append + lexical-t-3008 + lexical-d-3012)) + lexical-tmp-3011)) + lexical-dnew-3005))) + lexical-tmp-3007) + (syntax-error + lexical-tmp-3006))) + ($syntax-dispatch + lexical-tmp-3006 + 'each-any))) + (generate-temporaries + lexical-q-3002))))) + lexical-tmp-2999) + ((lambda (lexical-tmp-3015) + (if (if lexical-tmp-3015 + (apply (lambda (lexical-q-3016 + lexical-d-3017) + (= lexical-n-2969 + '0)) + lexical-tmp-3015) + '#f) + (apply (lambda (lexical-q-3018 + lexical-d-3019) + (lexical-qs-2966 + lexical-d-3019 + lexical-n-2969 + lexical-b*-2970 + (lambda (lexical-b*-3020 + lexical-dnew-3021) + ((lambda (lexical-tmp-3022) + ((lambda (lexical-tmp-3023) + (if lexical-tmp-3023 + (apply (lambda (lexical-t-3024) + (lexical-k-2971 + (append + (map (lambda (lexical-tmp-3026 + lexical-tmp-3025) + (list (cons lexical-tmp-3025 + '(#(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))))) + lexical-tmp-3026)) + lexical-q-3018 + lexical-t-3024) + lexical-b*-3020) + ((lambda (lexical-tmp-3027) + ((lambda (lexical-tmp-3028) + (if lexical-tmp-3028 + (apply (lambda (lexical-m-3029) + ((lambda (lexical-tmp-3030) + ((lambda (lexical-d-3031) + (append + (apply append + lexical-m-3029) + lexical-d-3031)) + lexical-tmp-3030)) + lexical-dnew-3021)) + lexical-tmp-3028) + (syntax-error + lexical-tmp-3027))) + ($syntax-dispatch + lexical-tmp-3027 + '#(each each-any)))) + (map (lambda (lexical-tmp-3034) + (cons lexical-tmp-3034 + '(#(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)))))) + lexical-t-3024)))) + lexical-tmp-3023) + (syntax-error + lexical-tmp-3022))) + ($syntax-dispatch + lexical-tmp-3022 + 'each-any))) + (generate-temporaries + lexical-q-3018))))) + lexical-tmp-3015) + ((lambda (lexical-tmp-3036) + (if lexical-tmp-3036 + (apply (lambda (lexical-a-3037 + lexical-d-3038) + (lexical-qs-2966 + lexical-a-3037 + lexical-n-2969 + lexical-b*-2970 + (lambda (lexical-b*-3039 + lexical-anew-3040) + (lexical-qs-2966 + lexical-d-3038 + lexical-n-2969 + lexical-b*-3039 + (lambda (lexical-b*-3041 + lexical-dnew-3042) + (lexical-k-2971 + lexical-b*-3041 + (if (if (eq? lexical-anew-3040 + lexical-a-3037) + (eq? lexical-dnew-3042 + lexical-d-3038) + '#f) + lexical-q-2968 + ((lambda (lexical-tmp-3043) + ((lambda (lexical-tmp-3044) + (if lexical-tmp-3044 + (apply (lambda (lexical-a-3045 + lexical-d-3046) + (cons lexical-a-3045 + lexical-d-3046)) + lexical-tmp-3044) + (syntax-error + lexical-tmp-3043))) + ($syntax-dispatch + lexical-tmp-3043 + '(any any)))) + (list lexical-anew-3040 + lexical-dnew-3042))))))))) + lexical-tmp-3036) + ((lambda (lexical-tmp-3047) + (if lexical-tmp-3047 + (apply (lambda (lexical-x-3048) + (lexical-vqs-2967 + lexical-x-3048 + lexical-n-2969 + lexical-b*-2970 + (lambda (lexical-b*-3050 + lexical-xnew*-3051) + (lexical-k-2971 + lexical-b*-3050 + (if ((letrec ((lexical-same?-3052 + (lambda (lexical-x*-3053 + lexical-xnew*-3054) + (if (null? lexical-x*-3053) + (null? lexical-xnew*-3054) + (if (not (null? lexical-xnew*-3054)) + (if (eq? (car lexical-x*-3053) + (car lexical-xnew*-3054)) + (lexical-same?-3052 + (cdr lexical-x*-3053) + (cdr lexical-xnew*-3054)) + '#f) + '#f))))) + lexical-same?-3052) + lexical-x-3048 + lexical-xnew*-3051) + lexical-q-2968 + ((lambda (lexical-tmp-3056) + ((lambda (lexical-tmp-3057) + (if lexical-tmp-3057 + (apply (lambda (lexical-x-3058) + (list->vector + lexical-x-3058)) + lexical-tmp-3057) + (syntax-error + lexical-tmp-3056))) + ($syntax-dispatch + lexical-tmp-3056 + 'each-any))) + lexical-xnew*-3051)))))) + lexical-tmp-3047) + ((lambda (lexical-_-3060) + (lexical-k-2971 + lexical-b*-2970 + lexical-q-2968)) + lexical-tmp-2972))) + ($syntax-dispatch + lexical-tmp-2972 + '#(vector + each-any))))) + ($syntax-dispatch + lexical-tmp-2972 + '(any . any))))) + ($syntax-dispatch + lexical-tmp-2972 + '((#(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 + lexical-tmp-2972 + '((#(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 + lexical-tmp-2972 + '(#(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 + lexical-tmp-2972 + '(#(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 + lexical-tmp-2972 + '(#(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 + lexical-tmp-2972 + '(#(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)))) + lexical-q-2968))) + (lexical-vqs-2967 + (lambda (lexical-x*-3061 + lexical-n-3062 + lexical-b*-3063 + lexical-k-3064) + (if (null? lexical-x*-3061) + (lexical-k-3064 lexical-b*-3063 '()) + (lexical-vqs-2967 + (cdr lexical-x*-3061) + lexical-n-3062 + lexical-b*-3063 + (lambda (lexical-b*-3065 lexical-xnew*-3066) + ((lambda (lexical-tmp-3067) + ((lambda (lexical-tmp-3068) + (if (if lexical-tmp-3068 + (apply (lambda (lexical-q-3069) + (= lexical-n-3062 '0)) + lexical-tmp-3068) + '#f) + (apply (lambda (lexical-q-3070) + ((lambda (lexical-tmp-3071) + ((lambda (lexical-tmp-3072) + (if lexical-tmp-3072 + (apply (lambda (lexical-t-3073) + (lexical-k-3064 + (append + (map list + lexical-t-3073 + lexical-q-3070) + lexical-b*-3065) + (append + lexical-t-3073 + lexical-xnew*-3066))) + lexical-tmp-3072) + (syntax-error + lexical-tmp-3071))) + ($syntax-dispatch + lexical-tmp-3071 + 'each-any))) + (generate-temporaries + lexical-q-3070))) + lexical-tmp-3068) + ((lambda (lexical-tmp-3078) + (if (if lexical-tmp-3078 + (apply (lambda (lexical-q-3079) + (= lexical-n-3062 '0)) + lexical-tmp-3078) + '#f) + (apply (lambda (lexical-q-3080) + ((lambda (lexical-tmp-3081) + ((lambda (lexical-tmp-3082) + (if lexical-tmp-3082 + (apply (lambda (lexical-t-3083) + (lexical-k-3064 + (append + (map (lambda (lexical-tmp-3085 + lexical-tmp-3084) + (list (cons lexical-tmp-3084 + '(#(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))))) + lexical-tmp-3085)) + lexical-q-3080 + lexical-t-3083) + lexical-b*-3065) + ((lambda (lexical-tmp-3086) + ((lambda (lexical-tmp-3087) + (if lexical-tmp-3087 + (apply (lambda (lexical-m-3088) + (append + (apply append + lexical-m-3088) + lexical-xnew*-3066)) + lexical-tmp-3087) + (syntax-error + lexical-tmp-3086))) + ($syntax-dispatch + lexical-tmp-3086 + '#(each each-any)))) + (map (lambda (lexical-tmp-3091) + (cons lexical-tmp-3091 + '(#(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)))))) + lexical-t-3083)))) + lexical-tmp-3082) + (syntax-error + lexical-tmp-3081))) + ($syntax-dispatch + lexical-tmp-3081 + 'each-any))) + (generate-temporaries + lexical-q-3080))) + lexical-tmp-3078) + ((lambda (lexical-_-3093) + (lexical-qs-2966 + (car lexical-x*-3061) + lexical-n-3062 + lexical-b*-3065 + (lambda (lexical-b*-3094 + lexical-xnew-3095) + (lexical-k-3064 + lexical-b*-3094 + (cons lexical-xnew-3095 + lexical-xnew*-3066))))) + lexical-tmp-3067))) + ($syntax-dispatch + lexical-tmp-3067 + '(#(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 + lexical-tmp-3067 + '(#(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 lexical-x*-3061)))))))) + ((lambda (lexical-tmp-3096) + ((lambda (lexical-tmp-3097) + (if lexical-tmp-3097 + (apply (lambda (lexical-_-3098 lexical-x-3099) + (lexical-qs-2966 + lexical-x-3099 + '0 + '() + (lambda (lexical-b*-3100 lexical-xnew-3101) + (if (eq? lexical-xnew-3101 lexical-x-3099) + (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))) + lexical-x-3099) + ((lambda (lexical-tmp-3102) + ((lambda (lexical-tmp-3103) + (if lexical-tmp-3103 + (apply (lambda (lexical-b-3104 + lexical-x-3105) + (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))) + lexical-b-3104 + (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))) + lexical-x-3105))) + lexical-tmp-3103) + (syntax-error lexical-tmp-3102))) + ($syntax-dispatch + lexical-tmp-3102 + '(each-any any)))) + (list lexical-b*-3100 lexical-xnew-3101)))))) + lexical-tmp-3097) + (syntax-error lexical-tmp-3096))) + ($syntax-dispatch lexical-tmp-3096 '(any any)))) + lexical-x-2965))) + '*top*) + +($sc-put-cte + '#(syntax-object unsyntax ((top) #(ribcage #(unsyntax) #((top)) #(unsyntax)))) + (lambda (lexical-x-3108) (syntax-error lexical-x-3108 '"misplaced")) + '*top*) + +($sc-put-cte + '#(syntax-object + unsyntax-splicing + ((top) #(ribcage #(unsyntax-splicing) #((top)) #(unsyntax-splicing)))) + (lambda (lexical-x-3109) (syntax-error lexical-x-3109 '"misplaced")) + '*top*) + +($sc-put-cte + '#(syntax-object include ((top) #(ribcage #(include) #((top)) #(include)))) + (lambda (lexical-x-3110) + (letrec* ((lexical-read-file-3111 + (lambda (lexical-fn-3112 lexical-k-3113) + ((lambda (lexical-p-3114) + ((letrec ((lexical-f-3115 + (lambda () + ((lambda (lexical-x-3116) + (if (eof-object? lexical-x-3116) + (begin + (close-input-port lexical-p-3114) + '()) + (cons (datum->syntax-object + lexical-k-3113 + lexical-x-3116) + (lexical-f-3115)))) + (read lexical-p-3114))))) + lexical-f-3115))) + (open-input-file lexical-fn-3112))))) + ((lambda (lexical-tmp-3117) + ((lambda (lexical-tmp-3118) + (if lexical-tmp-3118 + (apply (lambda (lexical-k-3119 lexical-filename-3120) + ((lambda (lexical-fn-3121) + ((lambda (lexical-tmp-3122) + ((lambda (lexical-tmp-3123) + (if lexical-tmp-3123 + (apply (lambda (lexical-exp-3124) + (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))) + lexical-exp-3124)) + lexical-tmp-3123) + (syntax-error lexical-tmp-3122))) + ($syntax-dispatch lexical-tmp-3122 'each-any))) + (lexical-read-file-3111 + lexical-fn-3121 + lexical-k-3119))) + (syntax-object->datum lexical-filename-3120))) + lexical-tmp-3118) + (syntax-error lexical-tmp-3117))) + ($syntax-dispatch lexical-tmp-3117 '(any any)))) + lexical-x-3110))) + '*top*) + +($sc-put-cte + '#(syntax-object case ((top) #(ribcage #(case) #((top)) #(case)))) + (lambda (lexical-x-3127) + ((lambda (lexical-tmp-3128) + ((lambda (lexical-tmp-3129) + (if lexical-tmp-3129 + (apply (lambda (lexical-_-3130 + lexical-e-3131 + lexical-m1-3132 + lexical-m2-3133) + ((lambda (lexical-tmp-3134) + ((lambda (lexical-body-3135) + (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))) + lexical-e-3131)) + lexical-body-3135)) + lexical-tmp-3134)) + ((letrec ((lexical-f-3136 + (lambda (lexical-clause-3137 + lexical-clauses-3138) + (if (null? lexical-clauses-3138) + ((lambda (lexical-tmp-3139) + ((lambda (lexical-tmp-3140) + (if lexical-tmp-3140 + (apply (lambda (lexical-e1-3141 + lexical-e2-3142) + (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 lexical-e1-3141 + lexical-e2-3142))) + lexical-tmp-3140) + ((lambda (lexical-tmp-3144) + (if lexical-tmp-3144 + (apply (lambda (lexical-k-3145 + lexical-e1-3146 + lexical-e2-3147) + (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))) + lexical-k-3145)) + (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 lexical-e1-3146 + lexical-e2-3147)))) + lexical-tmp-3144) + ((lambda (lexical-_-3150) + (syntax-error + lexical-x-3127)) + lexical-tmp-3139))) + ($syntax-dispatch + lexical-tmp-3139 + '(each-any any . each-any))))) + ($syntax-dispatch + lexical-tmp-3139 + '(#(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)))) + lexical-clause-3137) + ((lambda (lexical-tmp-3151) + ((lambda (lexical-rest-3152) + ((lambda (lexical-tmp-3153) + ((lambda (lexical-tmp-3154) + (if lexical-tmp-3154 + (apply (lambda (lexical-k-3155 + lexical-e1-3156 + lexical-e2-3157) + (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))) + lexical-k-3155)) + (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 lexical-e1-3156 + lexical-e2-3157)) + lexical-rest-3152)) + lexical-tmp-3154) + ((lambda (lexical-_-3160) + (syntax-error + lexical-x-3127)) + lexical-tmp-3153))) + ($syntax-dispatch + lexical-tmp-3153 + '(each-any any . each-any)))) + lexical-clause-3137)) + lexical-tmp-3151)) + (lexical-f-3136 + (car lexical-clauses-3138) + (cdr lexical-clauses-3138))))))) + lexical-f-3136) + lexical-m1-3132 + lexical-m2-3133))) + lexical-tmp-3129) + (syntax-error lexical-tmp-3128))) + ($syntax-dispatch lexical-tmp-3128 '(any any any . each-any)))) + lexical-x-3127)) + '*top*) + +($sc-put-cte + '#(syntax-object + identifier-syntax + ((top) #(ribcage #(identifier-syntax) #((top)) #(identifier-syntax)))) + (lambda (lexical-x-3163) + ((lambda (lexical-tmp-3164) + ((lambda (lexical-tmp-3165) + (if lexical-tmp-3165 + (apply (lambda (lexical-dummy-3166 lexical-e-3167) + (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))) + lexical-e-3167)) + (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 lexical-e-3167 + '(#(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)))))))))) + lexical-tmp-3165) + ((lambda (lexical-tmp-3168) + (if (if lexical-tmp-3168 + (apply (lambda (lexical-dummy-3169 + lexical-id-3170 + lexical-exp1-3171 + lexical-var-3172 + lexical-val-3173 + lexical-exp2-3174) + (if (identifier? lexical-id-3170) + (identifier? lexical-var-3172) + '#f)) + lexical-tmp-3168) + '#f) + (apply (lambda (lexical-dummy-3175 + lexical-id-3176 + lexical-exp1-3177 + lexical-var-3178 + lexical-val-3179 + lexical-exp2-3180) + (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 + '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))) + lexical-var-3178 + lexical-val-3179) + (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))) + lexical-exp2-3180)) + (list (cons lexical-id-3176 + '(#(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 lexical-exp1-3177 + '(#(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 lexical-id-3176 + (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))) + lexical-id-3176)) + (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))) + lexical-exp1-3177)))))) + lexical-tmp-3168) + (syntax-error lexical-tmp-3164))) + ($syntax-dispatch + lexical-tmp-3164 + '(any (any any) + ((#(free-id + #(syntax-object + set! + ((top) + #(ribcage () () ()) + #(ribcage #(x) #(("m" top)) #("i")) + #(top-ribcage *top* #t)))) + any + any) + any)))))) + ($syntax-dispatch lexical-tmp-3164 '(any any)))) + lexical-x-3163)) + '*top*) + diff --git a/goldfish/scheme/psyntax.ss b/goldfish/scheme/psyntax.ss new file mode 100644 index 00000000..785a7749 --- /dev/null +++ b/goldfish/scheme/psyntax.ss @@ -0,0 +1,4296 @@ +;;; Portable implementation of syntax-case +;;; Extracted from Chez Scheme Version 7.3 (Feb 26, 2007) +;;; 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