(*banner* "; _\n; |_ _ _ |_ _ | . _ _\n; | (-||||_(_)|__|_)|_)\n;-------------------|----------------------------------------------------------\n\n"

*builtins* [0 0 0 0 0 0 0 0 0 0 0 0 #fn("6000r2|}<;" [])

#fn("6000r2|}=;" [])

#fn("6000r2|}>;" [])

#fn("5000r1|?;" [])

#fn("5000r1|@;" [])

#fn("5000r1|A;" [])

#fn("5000r1|B;" [])

#fn("5000r1|C;" [])

#fn("5000r1|D;" [])

#fn("5000r1|E;" [])

#fn("5000r1|F;" [])

#fn("5000r1|G;" [])

#fn("5000r1|H;" [])

#fn("5000r1|I;" [])

#fn("5000r1|J;" [])

#fn("6000r2|}K;" [])

#fn("8000s0c0|v2;" [#.list])

#fn("5000r1|M;" [])

#fn("5000r1|N;" [])

#fn("6000r2|}O;" [])

#fn("6000r2|}P;" [])

#fn("8000s0c0|v2;" [#.apply])

#fn("8000s0c0|v2;" [#.+])

#fn("8000s0c0|v2;" [#.-])

#fn("8000s0c0|v2;" [#.*])

#fn("8000s0c0|v2;" [#./])

#fn("8000s0c0|v2;" [#.div0])

#fn("6000r2|}W;" [])

#fn("6000r2|}X;" [])

#fn("6000r2|}Y;" [])

#fn("8000s0c0|v2;" [#.vector])

#fn("6000r2|}[;" [])

#fn("7000r3|}g2\\;" [])]

*interactive* #f *syntax-environment*

#table(throw #fn("9000r2c0c1c2c3L2|}L4L2;" [raise list quote

thrown-value]) assert #fn(";000r1c0|]c1c2c3|L2L2L2L4;" [if

raise quote assert-failed]) case #fn("@000s1]\x8c6g6c0O2c130c2g7|L2L1c3c4c5g6g7q2}32KL3;" [#fn("8000r2}c0\x8250c0;}\x8540^;}C6=0c1|e2}31L3;}?6=0c3|e2}31L3;}N\x85>0c3|e2}M31L3;e4c5}326=0c6|c7}L2L3;c8|c7}L2L3;" [else

eq? quote-value eqv? every #.symbol? memq quote memv] vals->cond)

#fn(gensym) let cond #fn(map) #fn("7000r1~M\x7f|M32|NK;" [])]) unwind-protect #fn("A000r2c030c030c1g7c2_}L3L2L1c3c4|c2g6L1c5g7L1c6g6L2L3L3L3g7L1L3L3;" [#fn(gensym)

let lambda prog1 trycatch begin raise]) with-bindings #fn("F000s1c0c1|32c0e2|32c0c3|32c4c5L1c0c6g8g633L1c7c0c8g6g73331c9c:c7}31Kc:c7c0c;g6g83331KL3L144;" [#fn(map)

#.car cadr #fn("5000r1c040;" [#fn(gensym)])

#fn(nconc) let #.list #fn(copy-list) #fn("7000r2c0|}L3;" [set!])

unwind-protect begin #fn("7000r2c0|}L3;" [set!])]) time #fn(">000r1c030c1g5c2L1L2L1c3|c4c5c6c2L1g5L3c7L4L3L3;" [#fn(gensym)

let time.now prog1 princ "Elapsed time: " - " seconds\n"]) dotimes #fn("A000s1|M|\x84c0`c1g7aL3c2c3L1g6L1L1c4}3133L4;" [for

- #fn(nconc) lambda #fn(copy-list)]) define-macro #fn(">000s1c0c1|ML2c2c3L1|NL1c4}3133L3;" [set-syntax!

quote #fn(nconc) lambda #fn(copy-list)]) unless #fn("<000s1c0|^c1}KL4;" [if

begin]) with-output-to #fn("<000s1c0c1L1c2|L2L1L1c3}3143;" [#fn(nconc)

with-bindings

*output-stream*

#fn(copy-list)]) cond #fn(":000s0]\x8c5g5c0g5q1O2g5M|41;" [#fn(">000r1|?640^;|Mg5Mc0<17802g5M]<6C0g5N\x8560g5M;c1g5NK;g5N\x85@0c2g5M~M|N31L3;g5\x84c3\x82\x980e4e5g531316c0e6e5g53131c7g6g5ML2L1c8g6c1e9e5g53131K~M|N31L4L3;c:30c7g6g5ML2L1c8g6e5g531g6L2~M|N31L4L3;c8g5Mc1g5NK~M|N31L4;" [else

begin or => 1arg-lambda? caddr caadr let if cddr #fn(gensym)] cond-clauses->if)]) with-input-from #fn("<000s1c0c1L1c2|L2L1L1c3}3143;" [#fn(nconc)

with-bindings *input-stream* #fn(copy-list)]) quasiquote #fn("6000r1e0|41;" [bq-process]) letrec #fn("=000s1c0c1L1c2c3|32L1c2c4|32c5}3134c2c6|32K;" [#fn(nconc)

lambda #fn(map) #.car #fn("7000r1c0c1|31K;" [set! #fn(copy-list)])

#fn(copy-list) #fn("5000r1e040;" [void])]) receive #fn("?000s2c0c1_}L3c2c1L1|L1c3g23133L3;" [call-with-values

lambda #fn(nconc) #fn(copy-list)]) let* #fn("@000s1|?6E0c0c1L1_L1c2}3133L1;c0c1L1e3|31L1L1c2|NF6H0c0c4L1|NL1c2}3133L1530}3133e5|31L2;" [#fn(nconc)

lambda #fn(copy-list) caar let* cadar]) when #fn(";000s1c0|c1}K^L4;" [if

begin]) catch #fn("@000r2c030c1}c2g6L1c3c4c5g6L2c6c7g6L2c8c9L2L3c6c:g6L2|L3L4c;g6L2c<g6L2L4L3L3;" [#fn(gensym)

trycatch lambda if and pair? eq? car quote thrown-value cadr caddr raise]) let #fn(">000s1^|C6B0|m62}Mm02}Nm1530]2c0c1L1c2c3|32L1c4}3133c2c5|32g66C0c6g6g7L2L1g6L3540g7g8K;" [#fn(nconc)

lambda #fn(map) #fn("5000r1|F650|M;|;" [])

#fn(copy-list) #fn("5000r1|F650|\x84;e040;" [void]) letrec]))

1+ #fn("6000r1|aw;" [] 1+) 1-

#fn("6000r1|ax;" [] 1-) 1arg-lambda? #fn("7000r1|F16T02|Mc0<16J02|NF16B02|\x84F16:02e1|\x84a42;" [lambda

length=] 1arg-lambda?)

<= #fn("6000r2|}X17602|}W;" [] <=) >

#fn("6000r2}|X;" [] >) >= #fn("6000r2}|X17602|}W;" [] >=)

Instructions #table(jmp.l 8 loadg.l 54 loadt 45 brn.l 88 lvargc 75 box 92 boolean? 18 eq? 12 + 34 loada 55 brn 87 box.l 93 aset! 44 brt.l 10 seta.l 62 null? 17 ret 11 vector 42 loadv 51 cadr 84 builtin? 23 setg.l 60 apply 33 keyargs 91 trycatch 68 dup 1 aref 43 list 28 set-car! 31 seta 61 removed-setc.l 64 cons 27 brne 82 closure 65 dummy_nil 97 neg 73 loadc0 78 pop 2 pair? 22 brbound 90 loada1 77 / 37 loadc1 79 vargc 67 sub2 72 brf.l 9 function? 26 load1 49 call.l 80 symbol? 19 = 39 loada0 76 call 3 set-cdr! 32 compare 41 dummy_t 95 load0 48 atom? 15 tcall 4 equal? 14 car 29 loadc.l 58 eqv? 13 loada.l 56 for 69 loadf 46 tcall.l 81 removed-setc 63 dummy_f 96 brt 7 jmp 5 < 40 brf 6 tapply 70 loadnil 47 argc 66 not 16 add2 71 largc 74 cdr 30 brnn 85 brne.l 83 loadc 57 - 35 shift 94 * 36 nop 0 div0 38 loadv.l 52 optargs 89 vector? 24 brnn.l 86 loadg 53 fixnum? 25 number? 20 setg 59 bound? 21 loadi8 50)

__init_globals #fn("6000r0e0c1<17B02e0c2<17802e0c3<6>0c4k52c6k75;0c8k52c9k72e:k;2e<k=2e>k?;" [*os-name*

win32 win64 windows "\\" *directory-separator* "\r\n" *linefeed* "/" "\n"

*stdout* *output-stream* *stdin* *input-stream* *stderr* *error-stream*] __init_globals)

__script #fn("6000r1c0|q1c1t;" [#fn("6000r0e0~41;" [load])

#fn("6000r1e0|312c1a41;" [top-level-exception-handler

#fn(exit)])] __script)

__start #fn("7000r1e0302|NF6D0|Nk12^k22e3|\x84315E0|k12]k22e4e5312e6302c7`41;" [__init_globals

*argv* *interactive* __script princ *banner* repl #fn(exit)] __start)

abs #fn("6000r1|`X650|y;|;" [] abs) any

#fn("7000r2}F16D02|}M3117:02e0|}N42;" [any] any) arg-counts #table(#.equal? 2 #.atom? 1 #.set-cdr! 2 #.symbol? 1 #.car 1 #.eq? 2 #.aref 2 #.boolean? 1 #.not 1 #.null? 1 #.eqv? 2 #.number? 1 #.pair? 1 #.builtin? 1 #.aset! 3 #.div0 2 #.= 2 #.bound? 1 #.compare 2 #.vector? 1 #.cdr 1 #.set-car! 2 #.< 2 #.fixnum? 1 #.cons 2)

argc-error #fn(";000r2e0c1|c2}}aW670c3540c445;" [error "compile error: "

" expects " " argument."

" arguments."] argc-error)

array? #fn("7000r1|H17F02c0|31g5F16902g5Mc1<;" [#fn(typeof) array] array?)

assoc #fn("7000r2}?640^;e0}31|>650}M;e1|}N42;" [caar assoc] assoc)

assv #fn("7000r2}?640^;e0}31|=650}M;e1|}N42;" [caar assv] assv)

bcode:cenv #fn("6000r1|b3[;" [] bcode:cenv) bcode:code

#fn("6000r1|`[;" [] bcode:code) bcode:ctable #fn("6000r1|a[;" [] bcode:ctable)

bcode:indexfor #fn(";000r2e0|31e1|31c2g6}326:0c3g6}42;c4g6}g7332g7|b2g7aw\\2;" [bcode:ctable

bcode:nconst #fn(has?) #fn(get) #fn(put!)] bcode:indexfor)

bcode:nconst #fn("6000r1|b2[;" [] bcode:nconst) bcode:sp

#fn("6000r1|b4[;" [] bcode:sp) bcode:stack #fn("8000r2|b4|b4[}w\\;" [] bcode:stack)

box-vars #fn("9000r2]\x8c6g6c0|g6q2O2g6M\x8e1}41;" [#fn("9000r1|F6Q0|M\x846B0e0~c1e2|M3133530]2\x7fM|N41;];" [emit

box caddr])] box-vars)

bq-bracket #fn("7000r1|?6<0c0e1|31L2;|Mc2\x8290c0|\x84L2;|Mc3\x8290c4|\x84L2;|Mc5\x8250|\x84;c0e1|31L2;" [#.list

bq-process unquote unquote-splicing copy-list unquote-nsplicing] bq-bracket)

bq-process #fn("A000r1]]c0m52c1m62e2|316Z0|H6S0e3e4|3131g7Mc5\x8290c6g7NK;c7c6g7L3;|;|?680c8|L2;|Mc9\x82=0e3e3|\x843141;|Mc:\x8250|\x84;e;g5|327o0e<|31c=g6|32g7\x8580c5g8K;g8N\x85@0c>g8Me3g731L3;c?c@g8Ke3g731L142;|_]g7F16:02g7Mc:<@6H02eAg7M31g8Km82g7Nm75\x0a/2g7F6@0eBg8g7\x84L1325N0g7\x85;0eCg8315@0eBg8e3g731L132g9N\x8560g9M;eDg9b23216J02eDg9Mb23216<02cEeFg931<6@0c>eGg931g9\x84L3;cHg9K;" [#fn("6000r1|F16B02|Mc0<17802|Mc1<17702|c2<;" [unquote-splicing

unquote-nsplicing unquote] splice-form?)

#fn("6000r1|F16802|Mc0<650|\x84;e1|41;" [unquote bq-process] bq-bracket1)

self-evaluating? bq-process vector->list list #.vector #.apply quote

quasiquote unquote any lastcdr #fn(map) #.cons #fn(nconc) list* bq-bracket

nreconc reverse! length= #.list caar cadar nconc] bq-process)

builtin->instruction #fn("8000r1c0~|^43;" [#fn(get)] [#table(#.equal? equal? #.* * #.car car #.apply apply #.aref aref #.- - #.boolean? boolean? #.builtin? builtin? #.null? null? #.eqv? eqv? #.function? function? #.bound? bound? #.cdr cdr #.list list #.set-car! set-car! #.cons cons #.atom? atom? #.set-cdr! set-cdr! #.symbol? symbol? #.eq? eq? #.vector vector #.not not #.pair? pair? #.number? number? #.div0 div0 #.aset! aset! #.+ + #.= = #.compare compare #.vector? vector? #./ / #.< < #.fixnum? fixnum?)])

caaaar #fn("5000r1|MMMM;" [] caaaar) caaadr

#fn("5000r1|\x84MM;" [] caaadr) caaar #fn("5000r1|MMM;" [] caaar)

caadar #fn("5000r1|M\x84M;" [] caadar) caaddr

#fn("5000r1|N\x84M;" [] caaddr) caadr #fn("5000r1|\x84M;" [] caadr)

caar #fn("5000r1|MM;" [] caar) cadaar

#fn("5000r1|MM\x84;" [] cadaar) cadadr #fn("5000r1|\x84\x84;" [] cadadr)

cadar #fn("5000r1|M\x84;" [] cadar) caddar

#fn("5000r1|MN\x84;" [] caddar) cadddr #fn("5000r1|NN\x84;" [] cadddr)

caddr #3=#fn("5000r1|N\x84;" [] caddr) cadr

#2=#fn("5000r1|\x84;" [] cadr) call-with-values #fn("7000r2|30g6F16802~g6M<690}g6Nv2;}g641;" [] [#1=(*values*)])

capture-var! #fn("<000r2e0|31e1}g6`33g717G02c2g631|b3c3g6}L132\\2;" [bcode:cenv

index-of #fn(length) #fn(append!)] capture-var!)

cdaaar #fn("5000r1|MMMN;" [] cdaaar) cdaadr

#fn("5000r1|\x84MN;" [] cdaadr) cdaar #fn("5000r1|MMN;" [] cdaar)

cdadar #fn("5000r1|M\x84N;" [] cdadar) cdaddr

#fn("5000r1|N\x84N;" [] cdaddr) cdadr #fn("5000r1|\x84N;" [] cdadr)

cdar #fn("5000r1|MN;" [] cdar) cddaar

#fn("5000r1|MMNN;" [] cddaar) cddadr #fn("5000r1|\x84NN;" [] cddadr)

cddar #fn("5000r1|MNN;" [] cddar) cdddar

#fn("5000r1|MNNN;" [] cdddar) cddddr #fn("5000r1|NNNN;" [] cddddr)

cdddr #fn("5000r1|NNN;" [] cdddr) cddr

#fn("5000r1|NN;" [] cddr) char? #fn("6000r1c0|31c1<;" [#fn(typeof)

wchar] char?)

closure? #fn("6000r1|J16602|G@;" [] closure?) compile

#fn("8000r1e0_e1|3142;" [compile-f lower-define] compile) compile-and

#fn(";000r4e0|}g2g3]c146;" [compile-short-circuit brf] compile-and)

compile-app #fn("E000r4g3Mg8C16Z02e0g8}32@16M02g8E16E02c1g83116:02c2g831G6;0c2g831540g8e3g3Nc4326i0e5|}^g9342e6|a322e7|}g3N33e6|g:y322e8|g2670c9540c:g:43;g9G16902e;g931g9c<<16V02e0g9}32@16I02c2c<31e<>16;02e=g3b2326E0e5|}^g3\x84342e8|c<42;g9F16D02g9Mc><16902e?g3316=0e@|}g2g344;g:7E0e5|}^g9342e6|a32530]2e7|}g3N33e6|g;y322g:7<0e6|b/32530]2g:6C0eA|}g2g3g9g:g;47;e8|g2670cB540cCg;43;" [in-env?

#fn(constant?) #fn(top-level-value) length> 255 compile-in bcode:stack

compile-arglist emit tcall.l call.l builtin->instruction cadr length= lambda

inlineable? compile-let compile-builtin-call tcall call] compile-app)

compile-arglist #fn("8000r3c0c1|}q2g2322c2g241;" [#fn(for-each)

#fn("9000r1e0~\x7f^|342e1~a42;" [compile-in

bcode:stack]) #fn(length)] compile-arglist)

compile-begin #fn("9000r4g3?6?0e0|}g2e13044;g3N?6>0e0|}g2g3M44;e0|}^g3M342e2|c3322e4|}g2g3N44;" [compile-in

void emit pop compile-begin] compile-begin)

compile-builtin-call #fn("<000r7c0e1g4^33g;16=02e2g3Ng;32@6=0e3g5g;32530]2g5g<c4\x82K0g6`W6:0e5|c642;e5|g5g643;g<c7\x82[0g6`W6:0e5|c842;g6b2W6:0e5|c942;e5|g5g643;g<c:\x82j0g6`W6:0e3g5a42;g6aW6:0e5|c;42;g6b2W6:0e5|c<42;e5|g5g643;g<c=\x82K0g6`W6:0e5|c>42;e5|g5g643;g<c?\x82K0g6`W6:0e3g5a42;e5|g5g643;g<c@\x82M0g6`W6<0e5|cAcB43;e5|g5g643;g<cC\x82W0g6b2X6;0e3g5b242;e5|g2670cD540cCg643;e5|g542;" [#fn(get)

arg-counts length= argc-error list emit loadnil + load0 add2 - neg sub2 *

load1 / vector loadv [] apply tapply] compile-builtin-call)

compile-f #fn("8000r2e0c1|}q2c242;" [call-with-values #fn("7000r0e0~\x7f42;" [compile-f-])

#fn("5000r2|;" [])] compile-f)

compile-f- #fn("O000r2e030}\x84e1}\x8431e2}31e3c4}\x8432e1}31g;\x8570c5540g;g7?660`580c6g731g=c6g:31xe3e7g:32g:\x87\xa20g?\x85L0e8g6c9g>g8\x8570g=550g=y345r0e:g6e;c<c=c<c>g?32e?c6g?31313331322e8g6c@g>c6g?31g8\x8570g=550g=y352eAg6|g:g9g>35530]2eBg=cC326I0e8g6g8\x8570cD540cEg=335W0g8\x87?0e8g6cFg=335E0g:\x85?0e8g6cGg=33530^2eH|g9eIeJ}31g93233eKg6g@M322g6b4c6g931b4w\\2eLg6g@]eJ}31342e8g6cM322eNcOePeQg63131eRg631g<33eSg63142;" [make-code-emitter

lastcdr lambda:vars filter #.pair? lambda #fn(length) keyword-arg? emit

optargs bcode:indexfor make-perfect-hash-table

#fn(map) #.cons #.car iota keyargs emit-optional-arg-inits > 255 largc lvargc

vargc argc extend-env complex-bindings lambda:body box-vars compile-in ret

values #fn(function) encode-byte-code bcode:code const-to-idx-vec bcode:cenv] compile-f-)

compile-for #fn("9000r5e0g4316n0e1|}^g2342e2|a322e1|}^g3342e2|a322e1|}^g4342e3|c4322e2|b.42;e5c641;" [1arg-lambda?

compile-in bcode:stack emit for error "for: third form must be a 1-argument lambda"] compile-for)

compile-if #fn("@000r4e0|31e0|31g3\x84e1g331e2g331F6;0e3g331560e430g:]\x82=0e5|}g2g;44;g:^\x82=0e5|}g2g<44;e5|}^g:342e6|c7g8332e5|}g2g;342g26<0e6|c8325;0e6|c9g9332e:|g8322e5|}g2g<342e:|g942;" [make-label

caddr cdddr cadddr void compile-in emit brf ret jmp mark-label] compile-if)

compile-in #fn("<000r4g3C6<0e0|}g3]44;g3?6\xaf0g3`\x82:0e1|c242;g3a\x82:0e1|c342;g3]\x82:0e1|c442;g3^\x82:0e1|c542;g3_\x82:0e1|c642;e7g3316<0e1|c8g343;c9g3316C0e:|}g2c;c<31L144;e1|c=g343;g3MC@17D02g3ME17;02e>g3M}326=0e?|}g2g344;g3Mg8c@\x82S0eAg3\x84316>0e:|}g2g3\x8444;e1|c=g3\x8443;g8cB\x82=0eC|}g2g344;g8cD\x82>0eE|}g2g3N44;g8cF\x82;0eG|}g343;g8cH\x82D0eIcJ}g3q2cK|}q242;g8cL\x82>0eM|}g2g3N44;g8cN\x82>0eO|}g2g3N44;g8cP\x82E0eQ|}g3\x84cDeRg331K44;g8cS\x82H0eT|}g3\x84eUg331eVg33145;g8cW\x82E0e:|}]g3\x84342e1|cX42;g8cY\x82B0eZ|}g3\x84eUg33144;g8c[\x82p0e:|}^cH_g3\x84L3342e\\eUg33131660^580e]c^312e:|}^eUg331342e1|c[42;e?|}g2g344;" [compile-sym

emit load0 load1 loadt loadf loadnil fits-i8 loadi8 #fn(eof-object?)

compile-in #fn(top-level-value) eof-object loadv in-env? compile-app quote

self-evaluating? if compile-if begin compile-begin prog1 compile-prog1 lambda

call-with-values #fn("7000r0e0~\x7f42;" [compile-f-])

#fn("9000r2e0~c1|332}\x87K0c2c3~\x7fq2}322e0~c4c5}3143;];" [emit loadv #fn(for-each)

#fn("9000r1e0~\x7f|^44;" [compile-sym])

closure #fn(length)])

and compile-and or compile-or while compile-while cddr for compile-for caddr

cadddr return ret set! compile-set! trycatch 1arg-lambda? error "trycatch: second form must be a 1-argument lambda"] compile-in)

compile-let #fn("A000r4g3Mg3Ne0|31g8\x84e1|}g933e2g;e3e4g831g;32g:33e5|g=322c6g=}M32}NKe7|g>g2e4g831342e8|g<y322e9g<`3216602g2@6<0e:|c;g<43;];" [bcode:sp

compile-arglist vars-to-env complex-bindings caddr box-vars #fn(append!)

compile-in bcode:stack > emit shift] compile-let)

compile-or #fn(";000r4e0|}g2g3^c146;" [compile-short-circuit brt] compile-or)

compile-prog1 #fn(":000r3e0|}^g2\x84342e1g231F6W0e2|a322e3|}^e1g231342e4|c5322e2|b/42;];" [compile-in

cddr bcode:stack compile-begin emit pop] compile-prog1)

compile-set! #fn("?000r4e0g2}`33g8c1\x82F0e2|}^g3342e3|c4g243;g8M`We5g8N31g96<0e6g8N31590e7|g232g:6g0e3|g9670c8540c9g;332e:|a322e2|}^g3342e:|b/322e3|c;42;e2|}^g3342g97A0e<c=c>g23231530]2e3|c?g;43;" [lookup-sym

global compile-in emit setg vinfo:heap? vinfo:index capture-var! loada loadc

bcode:stack set-car! error #fn(string) "internal error: misallocated var "

seta] compile-set!)

compile-short-circuit #fn("<000r6g3?6=0e0|}g2g444;g3N?6>0e0|}g2g3M44;e1|31e0|}^g3M342e2|a322e3|c4322e3|g5g:332e2|b/322e3|c5322e6|}g2g3Ng4g5362e7|g:42;" [compile-in

make-label bcode:stack emit dup pop compile-short-circuit mark-label] compile-short-circuit)

compile-sym #fn(";000r4e0g2}`33g8c1\x82b0c2g23116=02e3c4g231316@0e5|c6c4g23143;e5|c7g243;g8M`W6\\0e5|c8e9g8N31332g316:02e:g8N316:0e5|c;42;];e5|c<e=|g232332g316:02e:g8N316:0e5|c;42;];" [lookup-sym

global #fn(constant?) printable? #fn(top-level-value) emit loadv loadg loada

vinfo:index vinfo:heap? car loadc capture-var!] compile-sym)

compile-thunk #fn(":000r1e0_c1_e2|31L342;" [compile-f lambda

lower-define] compile-thunk)

compile-while #fn(";000r4e0|31e0|31e1|}^e230342e3|a322e4|g8322e1|}^g2342e5|c6g9332e5|c7322e3|b/322e1|}^g3342e5|c8g8332e4|g942;" [make-label

compile-in void bcode:stack mark-label emit brf pop jmp] compile-while)

complex-bindings #fn("=000r2c030c030e1|}^^g6g7362e2c3g6q1e4g73142;" [#fn(table)

complex-bindings- filter #fn("7000r1c0~|42;" [#fn(has?)]) table.keys] complex-bindings)

complex-bindings- #fn("=000r6}\x8540^;|C6M0g316902c0|}326;0c1g4|]43;];|?17802e2|31640^;|Mc3\x82o0c0|\x84}326Q0c1g5|\x84]332g36>0c1g4|\x84]33530]530]2e4e5|31}^g3g4g546;|Mc6\x82U0e4e7|31e8}e9|3132^g2@17502g3g4g546;e4|M}e:|31g3g4g536c;c<}g3g4g5q4|N32K;" [#fn(memq)

#fn(put!) quoted? set! complex-bindings- caddr lambda lambda:body diff

lambda:vars inlineable? #fn(map) #fn(";000r1e0|~^\x7fi2i346;" [complex-bindings-])] complex-bindings-)

const-to-idx-vec #fn("9000r1c0e1|3131e2c3g5q1e4|31322g5;" [#fn(vector.alloc)

bcode:nconst table.foreach #fn("7000r2~}|\\;" []) bcode:ctable] const-to-idx-vec)

count #fn("9000r2]\x8c6g6c0g6q1O2g6M|}`43;" [#fn("9000r3}\x8550g2;~M|}N|}M31690g2aw540g243;" [] count-)] count)

delete-duplicates #fn(":000r1e0|bD326O0c130]\x8c6g6c2g5g6q2O2g6M\x8e1|_42;|?640|;|M|Ne3g5g632690e4g641;g5e4g631K;" [length>

#fn(table) #fn("8000r2|?680e0}41;c1~|M326:0\x7fM|N}42;c2~|M]332\x7fM|N|M}K42;" [reverse!

#fn(has?) #fn(put!)]) member delete-duplicates] delete-duplicates)

diff #fn("8000r2|\x8540_;c0|M}326:0e1|N}42;|Me1|N}32K;" [#fn(memq)

diff] diff)

div #fn("7000r2|}V|`X16C02}`X16402a17502b/17402`w;" [] div) emit

#fn("P000s2g2\x85b0}c0<16C02|`[F16:02|`[Mc1<6;0|`[c2O5:0|`}|`[K\\5\xb91c3}c4326A0e5|g2M32L1m2530]2c6}c732g716<02e8g2Mc9326:0g7\x84m1530]\x8e12c6}c:32g716<02e8g2Mc9326:0g7\x84m1530]\x8e12}c;\x82\\0g2c<>6=0c=m12_m25F0g2c>>6=0c?m12_m2530^530]2}c@\x82\\0g2c<>6=0cAm12_m25F0g2c>>6=0cBm12_m2530^530]2|`[F690|`[M530_|`[}cC<16\x9f02g7cD<16902g8\x84cE<6E0|`g2McFeGg831KK\\5x0g7cD\x82B0|`g2McHg8NKK\\5a0g7cI\x82B0|`g2McJg8NKK\\5J0g7cE\x82B0|`g2McKg8NKK\\530^17a02}cH<16802g7cE<6B0|`g2McFg8NKK\\5?0|`eL}g2Kg832\\\x8e22|;" [car

cdr cadr #fn(memq) (loadv loadg setg) bcode:indexfor #fn(assq)

((loadv loadv.l) (loadg loadg.l) (setg setg.l) (loada loada.l) (seta seta.l)

(box box.l)) > 255 ((loadc loadc.l)) loada (0) loada0 (1)

loada1 loadc loadc0 loadc1 brf not null? brn cddr brt eq? brne brnn nreconc] emit)

emit-optional-arg-inits #fn("<000r5g2F6\x900e0|31e1|c2g4332e1|c3g9332e4|e5}e6g3g432_33^e7g231342e1|c8g4332e1|c9322e:|g9322e;|}g2Ng3g4aw45;];" [make-label

emit brbound brt compile-in extend-env list-head cadar seta pop mark-label

emit-optional-arg-inits] emit-optional-arg-inits)

encode-byte-code #fn("S000r1e0|31e1g531e2c3g631b3c3g631b2VT2wc432c3g631`c530c530c630^^c7g<c8322]g9g8X6\xd912g6g9[m=2g=c9\x82P0c:g:g6g9aw[c;g<31332g9b2wm95\xa81c7g<e<c=e>g76\x830g=gDc?\x8270c@5p0gDcA\x8270cB5d0gDcC\x8270cD5X0gDcE\x8270cF5L0gDcG\x8270cH5@0gDcI\x8270cJ540g=\x8e1540g=3231322g9awm92g9g8X6:0g6g9[530^m>2cKg=cL326`0c:g;c;g<31g>332c7g<g7670eM540eN`31322g9awm95\xeb0g=cO\x82H0c7g<eMg>31322g9awm95\xce0g>D6\xc70g=cKg?cP326H0c7g<eMg>31322g9awm95\x9f0cKg?cQ326\x810c7g<eMg>31322g9awm92c7g<eMg6g9[31322g9awm92g=cR\x82K0c7g<eMg6g9[31322g9awm9530]5E0c7g<eSg>31322g9awm9\x8e1530^5\x83.2eTcUg<g7g:q3g;322cVg<41;" [reverse!

list->vector >= #fn(length) 65536 #fn(table)

#fn(buffer) #fn(io.write) #int32(0) label #fn(put!)

#fn(sizeof) byte #fn(get) Instructions jmp jmp.l brt brt.l brf brf.l brne

brne.l brnn brnn.l brn brn.l #fn(memq) (jmp brf brt brne brnn brn) int32

int16 brbound (loadv.l loadg.l setg.l loada.l seta.l loadc.l largc lvargc

call.l tcall.l box.l) (optargs keyargs) keyargs uint8

table.foreach #fn(";000r2c0~|322c1~\x7f670e2540e3c4i2}32|x3142;" [#fn(io.seek)

#fn(io.write)

int32 int16

#fn(get)])

#fn(io.tostring!)] encode-byte-code)

error #fn("9000s0c0c1|K41;" [#fn(raise) error] error) eval

#fn("7000r1e0e1|313140;" [compile-thunk expand] eval) even? #fn("7000r1c0|a32`W;" [#fn(logand)] even?)

every #fn("7000r2}?17D02|}M3116:02e0|}N42;" [every] every) expand

#fn("F000r1]]]]]]]]]]]\x8c5\x8c6\x8c7\x8c8\x8c9\x8c:\x8c;\x8c<\x8c=\x8c>\x8c?g5c0O2g6c1g6q1O2g7c2L1O2g8c3g5g6g?g7q4O2g9c4g?g9q2O2g:c5g:q1O2g;c6g:g9g8q3O2g<c7g?g:g9g8q4O2g=c8g8g?q2O2g>c9O2g?c:g?g>g;g<g=q5O2g?M|_42;" [#fn("7000r2|E17902c0|}32@;" [#fn(assq)] top?)

#fn("8000r1|?640|;|c0>640|;|MF16;02e1|31c2<6F0c3~Me4|3131~M|N3142;|M~M|N31K;" [((begin))

caar begin #fn(append) cdar] splice-begin) *expanded* #fn("A000r2|?640|;~Mc0}326:0\x7fM|31530|~Mc1}32g76;0e2g631530_c3c4c5g832}32\x8c9g77A0c4c6i2g9q2g642;]\x8c:g:c7g:i2g9i3q4O2g:M\x8e1g631g:]g;F6c02i3Me8g;31<7C0g;i2Mg;Mg9M32O5;0g;e9g;31O2g;Nm;5\xfb/2g:;" [begin

define get-defined-vars #fn(nconc) #fn(map) #.list #fn("7000r1~M|\x7fM42;" [])

#fn(";000r1|?640|;|MF16;02c0e1|31<6<0|M~M|N31K;\x7fM|Mi2M32i2c2c3c4e5g53132i2M32O2i3Mg5K~M|N31K;" [define

caar #fn(nconc) #fn(map) #.list get-defined-vars]) caar cdar] expand-body)

#fn("9000r2|?640|;|MF16702|MNF6F0e0|31~Me1|31}32L2540|M\x7fM|N}32K;" [caar

cadar] expand-lambda-list) #fn("7000r1|?660|L1;|MF6?0e0|31~M|N31K;|M~M|N31K;" [caar] l-vars)

#fn("?000r2|\x84e0|31e1|31~M|\x8431c2c3c4g932}32c2c5L1\x7fMg6g:32L1i2Mg8g:32g744;" [lastcdr

cddr #fn(nconc) #fn(map) #.list lambda] expand-lambda)

#fn("?000r2|NA17602|\x84?6M0e0|31\x8540|;c1|\x84~Me2|31}32L3;e3|31e4|31e0|31\x7fMe3|3131c5c6c7g932}32c5c1L1g7i2Mg6g:32KL1i3Mg8g:3243;" [cddr

define caddr cdadr caadr #fn(nconc) #fn(map) #.list] expand-define)

#fn("=000r2|\x84c0~Me1|31c2c3c4\x7f}q2g632}3232K;" [begin cddr #fn(nconc)

#fn(map)

#fn("9000r1|Me0~M|\x84\x7f323130\x7fL3;" [compile-thunk])] expand-let-syntax)

#fn("5000r2|;" [] local-expansion-env) #fn("<000r2|?640|;|Mc0g6}32c1~}|q3g716702g7NF6I0~Mg7\x84|NQ2\x7fMe2g731}3242;g717?02g6C@17602g6E670g840;e3|31g96>0~Mg9|NQ2}42;g6c4\x8240|;g6c5\x82:0i2M|}42;g6c6\x82:0i3M|}42;g6c7\x82:0i4M|}42;g840;" [#fn(assq)

#fn(":000r0]\x8c4g4c0~\x7fg4q3O2g4M\x8e1i241;" [#fn("8000r1|?640|;|M?670|M590~M|M\x7f32i2M|N31K;" [])])

caddr macrocall? quote lambda define let-syntax] expand-in)] expand)

expand-define #fn("?000r1|\x84e0|31F6:0e0|315L0|\x84C6;0e130L15=0e2c3e4|3132g5C6<0c5g5g6ML3;c5g5Mc6c7L1g5NL1c8g631g5M34L3;" [cddr

void error "compile error: invalid syntax " print-to-string set! #fn(nconc)

lambda #fn(copy-list)] expand-define)

extend-env #fn("8000r3e0}g2`33|K;" [vars-to-env] extend-env) filter

#fn("9000r2]c0|q1m62g6|}_L143;" [#fn("8000r3g2]}F6Q02~}M316?0g2}M_KPNm2530]2}Nm15\x0e/2N;" [] filter-)] filter)

fits-i8 #fn("7000r1|I16F02e0|b\xb03216:02e1|b\xaf42;" [>= <=] fits-i8)

foldl #fn("9000r3g2\x8540};e0||g2M}32g2N43;" [foldl] foldl)

get-defined-vars #fn("7000r1e0~M|3141;" [delete-duplicates] [#0=(#fn("8000r1|?640_;|Mc0<16602|NF6d0|\x84C16702|\x84L117S02|\x84F16E02e1|31C16:02e1|31L117402_;|Mc2\x82?0c3c4~M|N32v2;_;" [define

caadr begin #fn(nconc) #fn(map)] [#0#]))])

identity #fn("5000r1|;" [] identity) in-env?

#fn("7000r2}F16F02c0|}M3217:02e1|}N42;" [#fn(assq) in-env?] in-env?)

index-of #fn("9000r3}\x8540^;|}M\x8250g2;e0|}Ng2aw43;" [index-of] index-of)

inlineable? #fn("9000r1|Mg5F16t02g5Mc0<16i02e1g5\x843116]02e2c3g5\x843216O02e4g5\x84c532@16@02e6g5\x84c7|N3142;" [lambda

list? every #.symbol? length> 255 length= #fn(length)] inlineable?)

io.readall #fn("8000r1c030c1g5|322c2g531g6c3>16802c4|31670c540;g6;" [#fn(buffer)

#fn(io.copy) #fn(io.tostring!) "" #fn(io.eof?)

#fn(eof-object)] io.readall)

io.readline #fn("7000r1c0|c142;" [#fn(io.readuntil)

#\linefeed] io.readline)

io.readlines #fn("7000r1e0e1|42;" [read-all-of io.readline] io.readlines)

iota #fn("7000r1e0e1|42;" [map-int identity] iota) keyword->symbol

#fn("=000r1c0|316Q0c1c2|31c3g6`c4g6c5g6313233\x8e141;|;" [#fn(keyword?)

#fn(symbol)

#fn(string)

#fn(string.sub)

#fn(string.dec)

#fn(length)] keyword->symbol)

keyword-arg? #fn("6000r1|F16902c0|M41;" [#fn(keyword?)] keyword-arg?)

lambda-vars #fn(":000r1]\x8c5g5c0g5q1O2g5M||^^342c1c2e3|3142;" [#fn(":000r4|A17502|C640];|F16602|MC6T0g217502g36<0e0c1}c243;~M|N}g2g344;|F16602|MF6\x890e3|Mb23216902e4|31C660^5=0e0c5|Mc6}342c7e4|31316=0~M|N}g2]44;g36<0e0c1}c843;~M|N}]g344;|F6>0e0c9|Mc6}44;|}\x82:0e0c1}42;e0c9|c6}44;" [error

"compile error: invalid argument list "

". optional arguments must come after required." length= caar "compile error: invalid optional argument "

" in list " #fn(keyword?) ". keyword arguments must come last."

"compile error: invalid formal argument "] check-formals)

#fn(map) #fn("6000r1|F690e0|M41;|;" [keyword->symbol]) to-proper] lambda-vars)

lambda:body #fn("6000r1e0|41;" [caddr] lambda:body) lambda:vars

#fn("6000r1e0|\x8441;" [lambda-vars] lambda:vars) last-pair #fn("6000r1|N?640|;e0|N41;" [last-pair] last-pair)

lastcdr #fn("6000r1|?640|;e0|31N;" [last-pair] lastcdr) length=

#fn("8000r2}`X640^;}`W650|?;|?660}`W;e0|N}ax42;" [length=] length=)

length> #fn("8000r2}`X640|;}`W6;0|F16402|;|?660}`X;e0|N}ax42;" [length>] length>)

list->vector #fn("6000r1c0|v2;" [#.vector] list->vector) list-head

#fn("9000r2e0}`32640_;|Me1|N}ax32K;" [<= list-head] list-head)

list-ref #fn("7000r2e0|}32M;" [list-tail] list-ref) list-tail

#fn("8000r2e0}`32640|;e1|N}ax42;" [<= list-tail] list-tail) list? #fn("6000r1|A17@02|F16902e0|N41;" [list?] list?)

load #fn("9000r1c0|c132c2g5q1c3g5|q2t;" [#fn(file) :read #fn("9000r0]\x8c4g4c0~g4q2O2g4M\x8e1]]]43;" [#fn("9000r3c0~317B0\x7fMc1~31|e2}3143;c3~312e2}41;" [#fn(io.eof?)

#fn(read) load-process #fn(io.close)])])

#fn("8000r1c0~312c1c2\x7f|L341;" [#fn(io.close)

#fn(raise) load-error])] load)

load-process #fn("6000r1e0|41;" [eval] load-process) lookup-sym

#fn(";000r3}\x8550c0;}Mc1|g732g8680g2g8K;e2|}Ng2aw43;" [global #fn(assq)

lookup-sym] lookup-sym)

lower-define #fn(";000r1]c0m52|?17802e1|31640|;|Mc2\x82<0e3e4|3141;|Mc5\x82K0c6c5L1|\x84L1g5|31L1e7|3144;c8e3|42;" [#fn("=000r1e0|31F6N0e1|31F6=0c2e0|31K570e3|31560e430e5g531e6g531g6\x8550g7;c7g6g7L3c8c9g632K;" [cddr

cdddr begin caddr void get-defined-vars lower-define lambda #fn(map)

#fn("5000r1e040;" [void])] lambda-body) quoted? define lower-define

expand-define lambda #fn(nconc) lastcdr #fn(map)] lower-define)

macrocall? #fn("6000r1|MC16902e0|M41;" [symbol-syntax] macrocall?)

make-code-emitter #fn("9000r0_c030`_`Z5;" [#fn(table)] make-code-emitter)

make-label #fn("5000r1c040;" [#fn(gensym)] make-label)

make-perfect-hash-table #fn(";000r1]\x8c5g5c0O2]\x8c6g6c1g5g6|q3O2g6M\x8e1c2|3141;" [#fn("8000r2e0e1c2|3131}42;" [mod0

abs #fn(hash)] $hash-keyword) #fn("=000r1c0b2|T2^32]\x8c6g6c1~|g5\x7fg6q5O2g6M\x8e1i241;" [#fn(vector.alloc)

#fn(":000r1|F6p0e0|31b2~Mg5\x7f32T2i2g6[6;0i3M\x7faw41;i2g6g5\\2i2g6awe1|31\\2i4M|N41;i2;" [caar

cdar])]) #fn(length)] make-perfect-hash-table)

make-system-image #fn("<000r1c0|c1c2c334c4e5e6]k52]k62c7g7g8q2c8g6g5q2c9g9q1tg9302;" [#fn(file)

:write :create :truncate (*linefeed* *directory-separator* *argv* that

*print-pretty* *print-width*

*print-readably* *print-level*

*print-length* *os-name*) *print-pretty*

*print-readably* #fn("5000r0~k02\x7fk1;" [*print-pretty* *print-readably*])

#fn("=000r0e0c1~q1e2c3303132c4c5c6c7g4c6c8g43233Q2\x7f322c9\x7fe:32\x8e12c;\x7f41;" [filter

#fn("8000r1|E16u02c0|31@16j02c1|31G@17C02c2|31c2c1|3131>@16I02c3|~32@16=02c4c1|3131@;" [#fn(constant?)

#fn(top-level-value) #fn(string) #fn(memq)

#fn(iostream?)]) simple-sort #fn(environment)

#fn(write) #fn(nconc) #fn(map) #.list #fn(top-level-value)

#fn(io.write) *linefeed* #fn(io.close)])

#fn("6000r1~302c0|41;" [#fn(raise)])] make-system-image)

map-int #fn(";000r2e0}`32640_;|`31_K_\x8c7g7g6O2a}axc1g7|q2u2g6;" [<=

#fn("7000r1~M\x7f|31_KP2~~MNO;" [])] map-int)

mark-label #fn("8000r2e0|c1}43;" [emit label] mark-label) max

#fn(";000s1}\x8540|;e0c1|}43;" [foldl #fn("6000r2|}X640};|;" [])] max)

member #fn("7000r2}?640^;}M|>640};e0|}N42;" [member] member) memv

#fn("7000r2}?640^;}M|=640};e0|}N42;" [memv] memv) min #fn(";000s1}\x8540|;e0c1|}43;" [foldl

#fn("6000r2|}X640|;};" [])] min)

mod #fn("8000r2|e0|}32}T2x;" [div] mod) mod0

#fn("7000r2||}V}T2x;" [] mod0) negative? #fn("6000r1|`X;" [] negative?)

newline #fn("8000\x8900001000\x8a0000770e0m02c1|e2322];" [*output-stream*

#fn(io.write)

*linefeed*] newline)

nreconc #fn("7000r2e0}|42;" [reverse!-] nreconc) odd?

#fn("6000r1e0|31@;" [even?] odd?) positive? #fn("7000r1e0|`42;" [>] positive?)

princ #fn(";000s0e0^k02c1g5q1c2|q1c3g6q1tg6302;" [*print-readably* #fn("5000r0~k0;" [*print-readably*])

#fn("7000r0c0c1~42;" [#fn(for-each)

#fn(write)]) #fn("6000r1~302c0|41;" [#fn(raise)])] princ)

print #fn("9000s0c0c1|42;" [#fn(for-each)

#fn(write)] print)

print-exception #fn("=000r1|F16D02|Mc0<16:02e1|b4326P0e2c3|\x84c4e5|31c6352e7e8|31315!0|F16D02|Mc9<16:02e1|b4326N0e2|\x84c:e8|31c;342e7e5|31315\xea0|F16@02|Mc<<16602|NF6?0e2c=|\x84c>335\xc60|F16802|Mc?<6B0e2c@312e2|NQ25\xa70|F16802|McA<6G0eBe5|31312e2cC|\x84325\x830eD|3116:02e1|b2326c0e7|M312e2cE312|\x84cFg53117602g5C670e2540e7g531\x8e15>0e2cG312e7|312e2eH41;" [type-error

length= princ "type error: " ": expected " caddr ", got " print cadddr

bounds-error ": index " " out of bounds for " unbound-error "eval: variable "

" has no value" error "error: " load-error print-exception "in file " list?

": " #fn(string?) "*** Unhandled exception: " *linefeed*] print-exception)

print-stack-trace #fn("?000r1]]\x8c5\x8c6g5c0g5q1O2g6c1g5q1O2e2e3|e4670b5540b43231e5e6c7c8c9303232`\x8c9c:c;g9g6g8q3g742;" [#fn("=000r3c0|31g2Kc1|31c1}31\x82?0c2c3c4g7L341;c5|31`e6c7g83131c8g8~}g7q4u;" [#fn(function:name)

#fn(function:code) #fn(raise) thrown-value ffound #fn(function:vals) 1- #fn(length)

#fn("8000r1e0~|[316>0\x7fM~|[i2i343;];" [closure?])] find-in-f)

#fn(";000r2c0~|}q3c1tg66I0c2e3c4c5e6g63132c73241;c8;" [#fn("8000r0c0c1~\x7fq2i2322^;" [#fn(for-each)

#fn("8000r1~M|\x7f_43;" [])]) #fn("6000r1|F16B02|Mc0<16802|\x84c1<680e2|41;c3|41;" [thrown-value

ffound caddr #fn(raise)]) #fn(symbol) string.join #fn(map)

#fn(string) reverse!

"/" lambda] fn-name)

reverse! list-tail *interactive* filter closure? #fn(map)

#fn("6000r1|E16802c0|41;" [#fn(top-level-value)])

#fn(environment) #fn(for-each) #fn("8000r1e0c1~Mc2332e3\x7fM|`[i232e4|31NK312e5302~~MawO;" [princ

"#" " " print vector->list newline])] print-stack-trace)

print-to-string #fn("8000r1c030c1|g5322c2g541;" [#fn(buffer)

#fn(write)

#fn(io.tostring!)] print-to-string)

printable? #fn("6000r1c0|3117802c1|31@;" [#fn(iostream?)

#fn(eof-object?)] printable?)

quote-value #fn("6000r1e0|31640|;c1|L2;" [self-evaluating? quote] quote-value)

quoted? #fn("6000r1|Mc0<;" [quote] quoted?) read-all

#fn("7000r1e0c1|42;" [read-all-of #fn(read)] read-all) read-all-of #fn(":000r2]\x8c6g6c0}g6|q3O2g6M\x8e1_|}3142;" [#fn("8000r2c0~31680e1|41;\x7fM}|Ki2~3142;" [#fn(io.eof?)

reverse!])] read-all-of)

repl #fn(":000r0]]\x8c4\x8c5g4c0O2g5c1g4g5q2O2g5M302e240;" [#fn("8000r0e0c1312c2e3312c4c5tc6e731@16F02e8g431e9g5312g5k:2];" [princ

"> " #fn(io.flush) *output-stream* #fn("5000r0c040;" [#fn(read)])

#fn("6000r1c0e1312c2|41;" [#fn(io.discardbuffer) *input-stream* #fn(raise)])

#fn(io.eof?) *input-stream* load-process print that] prompt)

#fn("6000r0c0~q1c1t6<0e2302\x7fM40;^;" [#fn("6000r0~M3016702e040;" [newline])

#fn("6000r1e0|312];" [top-level-exception-handler])

newline] reploop) newline] repl)

revappend #fn("7000r2e0}|42;" [reverse-] revappend) reverse

#fn("7000r1e0_|42;" [reverse-] reverse) reverse! #fn("7000r1e0_|42;" [reverse!-] reverse!)

reverse!- #fn("8000r2]}F6B02}N}|}m02P2m15\x1d/2|;" [] reverse!-)

reverse- #fn("7000r2}\x8540|;e0}M|K}N42;" [reverse-] reverse-)

self-evaluating? #fn("7000r1|?16602|C@17K02c0|3116A02|C16:02|c1|31<;" [#fn(constant?)

#fn(top-level-value)] self-evaluating?)

separate #fn(":000r2]c0m62g6|}_L1_L144;" [#fn("9000r4g2g3K]}F6Z02|}M316?0g2}M_KPNm25<0g3}M_KPNm32}Nm15\x05/2e0g8MNg8NN42;" [values] separate-)] separate)

set-syntax! #fn("8000r2c0e1|}43;" [#fn(put!)

*syntax-environment*] set-syntax!)

simple-sort #fn("9000r1|A17602|NA640|;|Me0c1g5|q2c2g5q142;" [call-with-values

#fn("7000r0e0c1~q1\x7fN42;" [separate #fn("6000r1|~X;" [])])

#fn("9000r2c0e1|31~L1e1}3143;" [#fn(nconc) simple-sort])] simple-sort)

string.join #fn("9000r2|\x8550c0;c130c2g6|M322c3c4g6}q2|N322c5g641;" [""

#fn(buffer) #fn(io.write) #fn(for-each)

#fn("7000r1c0~\x7f322c0~|42;" [#fn(io.write)])

#fn(io.tostring!)] string.join)

string.map #fn("=000r2c030c1}31`]g8g7X6P02c2g6|c3}g83231322c4}g832m85\x0c/\x8e12c5g641;" [#fn(buffer)

#fn(length) #fn(io.putc) #fn(string.char)

#fn(string.inc) #fn(io.tostring!)] string.map)

string.tail #fn(":000r2c0|c1|`}3342;" [#fn(string.sub)

#fn(string.inc)] string.tail)

symbol-syntax #fn("8000r1c0e1|^43;" [#fn(get)

*syntax-environment*] symbol-syntax)

table.foreach #fn("8000r2c0c1|q1_}43;" [#fn(table.foldl)

#fn("7000r3~|}322];" [])] table.foreach)

table.keys #fn("8000r1c0c1_|43;" [#fn(table.foldl)

#fn("6000r3|g2K;" [])] table.keys)

table.pairs #fn("8000r1c0c1_|43;" [#fn(table.foldl)

#fn("6000r3|}Kg2K;" [])] table.pairs)

to-proper #fn("7000r1|\x8540|;|?660|L1;|Me0|N31K;" [to-proper] to-proper)

top-level-exception-handler #fn("9000r1e0e1k02c2g5q1c3|q1c4g6q1tg6302;" [*output-stream*

*stderr* #fn("5000r0~k0;" [*output-stream*])

#fn("6000r0e0~312e1c23041;" [print-exception print-stack-trace #fn(stacktrace)])

#fn("6000r1~302c0|41;" [#fn(raise)])] top-level-exception-handler)

values #fn("8000s0|F16602|NA650|M;~|K;" [] [#1#]) vars-to-env

#fn(":000r3c0c1}g2q2|e2c3|313143;" [#fn(map)

#fn("9000r2e0|c1|~32@@}\x7fw43;" [vinfo

#fn(memq)]) iota #fn(length)] vars-to-env)

vector->list #fn("<000r1c0|31_\x8c6ag5c1g6|g5q3u2g6M;" [#fn(length)

#fn("8000r1~\x7fi2|x[~MKO;" [])] vector->list)

vinfo #fn("7000r3|}g2L3;" [] vinfo) vinfo:heap?

#2# vinfo:index #3# vinfo:sym #.car void

#fn("5000r0];" [] void) zero? #fn("6000r1|`W;" [] zero?))