shithub: sl

Info  •  Files  •  Log  •  Branches

keep the boot image in plain text (uncompressed)

Use an additional lzpack executable to compress the boot image
when building.
This helps with not storing binaries in git.

--- a/.gitignore

+++ b/.gitignore

@@ -1,7 +1,7 @@

 *.[05678qvtoa]

+[05678qvtoa].*

 *.out

 *.bak

-sl.boot

 instructions.lsp

 builtins.lsp

 docs_ops.lsp

--- /dev/null

+++ b/boot/sl.boot

@@ -1,0 +1,437 @@

+(*builtins* #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL #fn("n10<:" #())

+	      #fn("n10=:" #()) NIL NIL NIL NIL #fn("n10B:" #()) NIL NIL NIL NIL NIL #fn("n10H:" #())

+	      NIL NIL NIL #fn("z0700}2:" #(<)) NIL #fn("n201N:" #()) NIL #fn("n201P:" #())

+	      #fn("n201Q:" #()) #fn("n10R:" #()) #fn("n10S:" #())

+	      #fn("n10T:" #()) NIL #fn("n10V:" #()) NIL #fn("n10X:" #())

+	      #fn("n10Y:" #()) #fn("n10Z:" #()) #fn("n10[:" #())

+	      #fn("n10\\:" #()) #fn("n10]:" #()) NIL #fn("n201_:" #()) NIL NIL NIL #fn("n201c:" #())

+	      #fn("n201d:" #()) #fn("z00:" #()) #fn("z0700}2:" #(apply))

+	      #fn("z0700}2:" #(+)) #fn("z0700}2:" #(-))

+	      #fn("z0700}2:" #(*)) #fn("z0700}2:" #(/))

+	      #fn("z0700}2:" #(div0)) #fn("z0700}2:" #(=))

+	      #fn("n201m:" #()) NIL #fn("z0700}2:" #(vector))

+	      #fn("z0700}2:" #(aset!)) NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL #fn("n3012082>1|:" #(#fn("n1A061:" #())))

+	      NIL NIL NIL NIL NIL NIL NIL NIL #fn("z0700}2:" #(aref)) NIL NIL NIL)

+	    *properties* #table(*funvars* #table(*prompt* (NIL)  lz-unpack ((data :to destination)

+									    (data :size

+										  decompressed-bytes))  void? ((x))  >= ((a . rest))  rand-uint64 (NIL)  help ((term))  length= ((lst

+  n))  = ((a . rest))  car ((lst))  <= ((a . rest))  rand-uint32 (NIL)  /= ((a . rest))  void (rest)  lz-pack ((data

+  (level 0)))  rand (NIL)  nan? ((x))  rand-float (NIL)  cons? ((value))  vm-stats (NIL)  * ((number…))  rand-double (NIL)  cdr ((lst))  + ((number…))  > ((a . rest)))  *doc* #table(>= "Return T if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)."  void? "Return T if x is #<void>, NIL otherwise."  length= "Bounded length test.\nUse this instead of (= (length lst) n), since it avoids unnecessary\nwork and always terminates."  car "Return the first element of a list or NIL if not available."  *builtins* "VM instructions as closures."  <= "Return T if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)."  void "Return the constant #<void> while ignoring any arguments.\n#<void> is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though T or NIL could\nbe returned instead, in case of #<void> alone, REPL will not print\nit."  rand "Return a random non-negative fixnum on its maximum range."  nan? "Return T if the argument is NaN, regardless of the sign."  Instructions "VM instructions mapped to their encoded byte representation."  rand-double "Return a random double on [0.0, 1.0] interval."  > "Return T if the arguments are in strictly decreasing order (previous\none is greater than the next one)."  cdr "Return the tail of a list or NIL if not available."  + "Return sum of the numbers or 0 with no arguments."  lz-unpack "Return decompressed data previously compressed using lz-pack.\nEither destination for the decompressed data or the expected size of\nthe decompressed data must be specified.  In the latter case a new\narray is allocated."  rand-uint64 "Return a random integer on [0, 2⁶⁴-1] interval."  help "Display documentation for the specified term, if available."  = "Return T if the arguments are equal."  rand-uint32 "Return a random integer on [0, 2³²-1] interval."  /= "Return T if not all arguments are equal. Shorthand for (not (= …))."  lz-pack "Return data compressed using Lempel-Ziv.\nThe data must be an array, returned value will have the same type.\nThe optional level is between 0 and 10.  With level 0 a simple LZSS\nusing hashing will be performed.  Levels between 1 and 9 offer a\ntrade-off between time/space and ratio.  Level 10 is optimal but very\nslow."  rand-float "Return a random float on [0.0, 1.0] interval."  arg-counts "VM instructions mapped to their expected arguments count."  *prompt* "Function called by REPL to signal the user input is required.\nDefault function prints \"#;> \"."  cons? "Return T if the value is a cons cell."  vm-stats "Print various VM-related information, such as the number of GC calls\nso far, heap and stack size, etc."  * "Return product of the numbers or 1 with no arguments."  *properties* "All properties of symbols recorded with putprop are recorded in this table."))

+	    *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("\x8710002000W1000J60q?140B86;35040<;J404087R;3904208751;J5048786;35040=863H021222387e212389e2e4e2:21222387e21e3e2:" #(#fn(top-level-value)

+  void symbol-set-doc quote))  with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc)

+										 with-bindings

+										 *input-stream* #fn(copy-list)))  unless #fn("z1200q211Pe4:" #(if

+  begin))  defmacro #fn("z170151863D0710<860=5341=?1@30q42223240<e22526e10=e12715153e3e2:" #(value-get-doc

+  symbol-set-doc void set-syntax! quote #fn(nconc) λ #fn(copy-list)))  time #fn("n1202122e1e2e123024252622e121e32728e5e3e3:" #(let

+  #:g354 time-now prog1 princ "Elapsed time: " - " seconds" *linefeed*))  cond #fn("z0Ib520852185>1_51485<061:" #(#0=#fn("z0I:" #() void)

+  #fn("n10H340q:0<85<20Q;J80485<DQ3C085=J6085<:2185=P:85=J@02285<A<0=51e3:85T23C\x94074758551513c07675855151278685<e2e12886217975855151PA<0=51e4e3:272:85<e2e1282:7585512:e2A<0=51e4e3:2885<2185=PA<0=51e4:" #(else

+  begin or => 1arg-lambda? caddr caadr let if cddr #:g22) cond-clauses->if)))  do #fn("z21<2071052207205220230522425268827872829e12:1=51522829e12:82512825e18:52e153e4e3e2e12825e18952e3:" #(#fn(map)

+  car cadr #fn("n170051B38071061:0<:" #(cddr caddr)) letrec #:g324 λ if #fn(nconc) begin #fn(copy-list)))  mark-label #fn("n22002122e21e4:" #(emit

+  quote label))  with-bindings #fn("z12071052207205220230522425e12076888653e12720288687535129242:e12715152242:e127202;8688535152e3e164:" #(#fn(map)

+  car cadr #fn("n12060:" #(#fn(gensym))) #fn(nconc) let list #fn(copy-list)

+  #fn("n22001e3:" #(set!)) unwind-protect begin #fn("n22001e3:" #(set!))))  let #fn("z1q0R3B00?641<?041=?1@30q42021e12223052e124151532225052863C0268687e2e186e3@408788P:" #(#fn(nconc)

+  λ #fn(map) #fn("n10B3500<:0:" #()) #fn(copy-list)

+  #fn("n10B3500T:7060:" #(void)) letrec))  bcode:code #fn("n1200Ee3:" #(aref))  make-label #fn("n120e1:" #(gensym))  bcode:cenv #fn("n1200r3e3:" #(aref))  > #fn("z12021e12273151510e163:" #(#fn(nconc)

+  < #fn(copy-list) reverse!))  when #fn("z1200211Pqe4:" #(if begin))  quasiquote #fn("n1700E62:" #(bq-process))  help #fn("n17002152853W072855147350424250>170026q535247350@B0722728051524735047960:" #(getprop

+  *doc* princ newline #fn(for-each) #fn("n17050471A0P61:" #(newline print)) *funvars* "no help for "

+  #fn(string) void))  bcode:ctable #fn("n1200Ke3:" #(aref))  with-output-to #fn("z12021e1220e2e1e12315163:" #(#fn(nconc)

+  with-bindings *output-stream* #fn(copy-list)))  catch #fn("n22012122e123242522e2262722e22829e2e3262:22e20e3e42;22e22<22e2e4e3e3:" #(trycatch

+  λ #:g349 if and cons? eq? car quote thrown-value cadr caddr raise))  let* #fn("z10H3E02021e1qe12215153e1:2021e173051e1e1220=B3H02024e10=e12215153e1@301515375051e2:" #(#fn(nconc)

+  λ #fn(copy-list) caar let* cadar))  letrec #fn("z1202021e12273052e122240522515154e1227605262:" #(#fn(nconc)

+  λ #fn(map) car #fn("n12021e12205162:" #(#fn(nconc) set! #fn(copy-list)))

+  #fn(copy-list) void))  /= #fn("z1202122e10e12315153e2:" #(not #fn(nconc) = #fn(copy-list)))  bcode:sp #fn("n1200r4e3:" #(aref))  bcode:stack #fn("n2200r421220e21e3e4:" #(aset!

+  + bcode:sp))  assert #fn("n1200D2122230e2e2e2e4:" #(if raise quote assert-failed))  case #fn("z1Ib6208621_514225023870e2e12425e126278687>215252e3:" #(#0#

+  #fn("n2120C5020:1J40q:1R3=021072151e3:1H3=023072151e3:1=J>0230721<51e3:74751523=0260271e2e3:280271e2e3:" #(else

+  eq? quote-value eqv? every symbol? memq quote memv) vals->cond)

+  #fn(gensym) let #fn(nconc) cond #fn(map) #fn("n1A<F0<520=P:" #())))  receive #fn("z22021q1e32221e10e123825153e3:" #(call-with-values

+  λ #fn(nconc) #fn(copy-list)))  unwind-protect #fn("n2202122q1e3e2e1232402225e12621e12725e2e3e3e321e1e3e3:" #(let

+  #:g350 λ prog1 trycatch #:g351 begin raise))  dotimes #fn("z10<0T20E2187Ke32223e186e1e12415153e4:" #(for

+  - #fn(nconc) λ #fn(copy-list)))  throw #fn("n220212223e201e4e2:" #(raise list quote thrown-value)))

+	    1+ #fn("n10KM:" #() 1+) 1-

+	    #fn("n10K~:" #() 1-) 1arg-lambda? #fn("n10B;3E04700<51;3:04710TK62:" #(is-lambda?

+										   length=) 1arg-lambda?)

+	    <= #fn("z1Ib6862086>1_486<^10162:" #(#fn("n21S;JL041<0L2;J5040V340q:A<1<1=62:" #())) <=)

+	    > #fn("z1Ib6862086>1_486<^10162:" #(#fn("n21S;JE041<0L2;3;04A<1<1=62:" #())) >) >=

+	    #fn("z1Ib6862086>1_486<^10162:" #(#fn("n21S;JL0401<L2;J5040V340q:A<1<1=62:" #())) >=)

+	    Instructions #table(call.l #byte(0x51)  trycatch #byte(0x4b)  loadg.l #byte(0x44)  aref2 #byte(0x17)  box #byte(0x32)  cadr #byte(0x24)  argc #byte(0x3e)  setg #byte(0x47)  load0 #byte(0x15)  nan? #byte(0x26)  vector? #byte(0x2d)  fixnum? #byte(0x29)  loadc0 #byte(0x11)  loada0 #byte(0x0)  div0 #byte(0x3b)  keyargs #byte(0x1f)  call #byte(0x5)  loada.l #byte(0x45)  sub2 #byte(0x4e)  add2 #byte(0x1d)  loadc.l #byte(0x46)  loadc #byte(0x9)  builtin? #byte(0x2b)  set-car! #byte(0x2f)  vargc.l #byte(0x50)  ret #byte(0xa)  loadi8 #byte(0x42)  tapply #byte(0x4d)  loadvoid #byte(0x19)  loada1 #byte(0x1)  shift #byte(0x2e)  atom? #byte(0x18)  cdr #byte(0xd)  brne.l #byte(0x53)  / #byte(0x3a)  equal? #byte(0x34)  apply #byte(0x36)  dup #byte(0xb)  loadt #byte(0x14)  jmp.l #byte(0x30)  = #byte(0x3c)  not #byte(0x23)  set-cdr! #byte(0x1e)  eq? #byte(0x21)  * #byte(0x39)  load1 #byte(0x1b)  bound? #byte(0x2a)  function? #byte(0x2c)  box.l #byte(0x56)  < #byte(0x1c)  brnn.l #byte(0x54)  jmp #byte(0x10)  loadv #byte(0x2)  for #byte(0x4c)  dummy_eof #byte(0x58)  + #byte(0x37)  brne #byte(0x13)  argc.l #byte(0x4f)  compare #byte(0x3d)  brn #byte(0x3)  neg #byte(0x25)  number? #byte(0x28)  loadv.l #byte(0x43)  vargc #byte(0x4a)  brbound #byte(0x27)  vector #byte(0x3f)  loadc1 #byte(0x16)  setg.l #byte(0x48)  cons? #byte(0x12)  aref #byte(0x55)  symbol? #byte(0x22)  aset! #byte(0x40)  car #byte(0xc)  cons #byte(0x20)  tcall.l #byte(0x52)  - #byte(0x38)  brn.l #byte(0x31)  optargs #byte(0x57)  closure #byte(0xe)  pop #byte(0x4)  eqv? #byte(0x33)  list #byte(0x35)  seta #byte(0xf)  seta.l #byte(0x49)  brnn #byte(0x1a)  loadnil #byte(0x41)  loadg #byte(0x7)  loada #byte(0x8)  tcall #byte(0x6))

+	    __init_globals #fn("n07021d37022@402384w4^147025d;350426;J50427w8429w:47;w<47=w>47?w@:" #(*os-name*

+  "macos" #fn("n0702161:" #(princ "\e[0m\e[1m#;> \e[0m"))

+  #fn("n0702161:" #(princ "#;> ")) *prompt* "dos" "\\" "/" *directory-separator* "\n" *linefeed*

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

+	    __rcscript #fn("n0708421c360q@T08422c37023@G08424c3=07526514q@4027^184;3904288451708622c37029@402:^185;3=042;857<8653873B02=87513907>8761:q:" #(*os-name*

+  "unknown" "plan9" "home" "macos" princ "\e]0;StreetLISP v0.999\a" "HOME" #fn(os-getenv) "lib/slrc"

+  ".slrc" #fn(string) *directory-separator* #fn(path-exists?) load) __rcscript)

+	    __script #fn("n1200>121{:" #(#fn("n070A61:" #(load))

+					 #fn("n170051421K61:" #(top-level-exception-handler

+								#fn(exit)))) __script)

+	    __start #fn("n1705040=B3D00=w14qw24730T51@C00w14Dw24745047550426E61:" #(__init_globals

+										    *argv*

+										    *interactive*

+										    __script

+										    __rcscript repl

+										    #fn(exit)) __start)

+	    abs #fn("n10EL23500U:0:" #() abs) any

+	    #fn("n21B;3D0401<51;J:047001=62:" #(any) any) arg-counts #table(bound? 1  function? 1  symbol? 1  car 1  cons 2  cadr 1  nan? 1  for 3  fixnum? 1  vector? 1  cdr 1  atom? 1  div0 2  equal? 2  eqv? 2  compare 2  not 1  number? 1  set-cdr! 2  eq? 2  builtin? 1  cons? 1  set-car! 2)

+	    argc-error #fn("n2702102211Kl237023@402465:" #(error "compile error: " " expects " " argument."

+							   " arguments.") argc-error)

+	    array? #fn("n10];JF042005185B;390485<21Q:" #(#fn(typeof) array) array?) assoc

+	    #fn("n2701510d3501<:13:07101=62:q:" #(caar assoc) assoc) assv #fn("n2701510c3501<:13:07101=62:q:" #(caar

+  assv) assv)

+	    bcode:indexfor #fn("n20KG0r2G20861523:02186162:2286187534870r287KMp4:" #(#fn(has?)

+										     #fn(get)

+										     #fn(put!)) bcode:indexfor)

+	    box-vars #fn("n2Ib68620086>2_486<^1161:" #(#fn("n10B3Q00<T3B070A21720<5153@30q4F<0=61:q:" #(emit

+  box caddr))) box-vars)

+	    bq-bracket #fn("n20H3=070710152e2:0<22CS01El2380700=P:707324710=1K~52e3e2:0<25CT01El2390260Te2:707027710T1K~52e3e2:0<28CP01El23500T:707029710T1K~52e3e2:70710152e2:" #(list

+  bq-process unquote cons 'unquote unquote-splicing copy-list 'unquote-splicing unquote-nsplicing

+  'unquote-nsplicing) bq-bracket)

+	    bq-bracket1 #fn("n20B3S00<20CL01El23500T:7122730=1K~52e3:730162:" #(unquote cons 'unquote

+										bq-process) bq-bracket1)

+	    bq-process #fn("n20R380200e2:0]3T0717205115286<73C907486=P:757486e3:0H3400:0<26CB07327710T1KM52e3:0<28CV01El23?0790r2523500T:7:2;710=1K~52e3:7<7=052Jt07>0512?2@1>105286J807387P:87=JA07:87<7186152e3:2A7B87P7186152e162:Ib6862C186>2_486<^10q62:" #(quote

+  bq-process vector->list list vector apply quasiquote 'quasiquote unquote length= cons 'unquote

+  any splice-form? lastcdr #fn(map) #fn("n1700A62:" #(bq-bracket1))

+  #fn(nconc) list* #fn("n20J;02071151P:0B3o00<22CX020731AEl23700=@C07425e2760=AK~52e252P:F<0=770<A521P62:2071760A521P51P:" #(nconc

+  reverse! unquote nreconc list 'unquote bq-process bq-bracket))) bq-process)

+	    builtin->instruction #fn("n120A0q63:" #(#fn(get)) #(#table(#.cadr cadr  #.aset! aset!  #.+ +  #.- -  #.equal? equal?  #.eq? eq?  #.builtin? builtin?  #.not not  #.cons? cons?  #.cdr cdr  #./ /  #.div0 div0  #.set-car! set-car!  #.vector vector  #.set-cdr! set-cdr!  #.< <  #.aref aref  #.for for  #.cons cons  #.apply apply  #.eqv? eqv?  #.vector? vector?  #.list list  #.car car  #.bound? bound?  #.nan? nan?  #.function? function?  #.symbol? symbol?  #.compare compare  #.fixnum? fixnum?  #.atom? atom?  #.= =  #.number? number?  #.* *)))

+	    caaaar #fn("n10<<<<:" #() caaaar) caaadr

+	    #fn("n10T<<:" #() caaadr) caaar #fn("n10<<<:" #() caaar) caadar

+	    #fn("n10<T<:" #() caadar) caaddr #fn("n10=T<:" #() caaddr) caadr

+	    #fn("n10T<:" #() caadr) caar #fn("n10<<:" #() caar) cadaar

+	    #fn("n10<<T:" #() cadaar) cadadr #fn("n10TT:" #() cadadr) cadar

+	    #fn("n10<T:" #() cadar) caddar #fn("n10<=T:" #() caddar) cadddr

+	    #fn("n10==T:" #() cadddr) caddr #4=#fn("n10=T:" #() caddr) call-with-values

+	    #fn("n205086B3@0A86<C90186=}2:18661:" #() #(#3=(*values*))) capture-var! #fn("n20r3G70186E5387;JG042186510r322861e152p4:" #(index-of

+  #fn(length) #fn(nconc)) capture-var!)

+	    cdaaar #fn("n10<<<=:" #() cdaaar) cdaadr

+	    #fn("n10T<=:" #() cdaadr) cdaar #fn("n10<<=:" #() cdaar) cdadar

+	    #fn("n10<T=:" #() cdadar) cdaddr #fn("n10=T=:" #() cdaddr) cdadr

+	    #fn("n10T=:" #() cdadr) cdar #fn("n10<=:" #() cdar) cddaar

+	    #fn("n10<<==:" #() cddaar) cddadr #fn("n10T==:" #() cddadr) cddar

+	    #fn("n10<==:" #() cddar) cdddar #fn("n10<===:" #() cdddar) cddddr

+	    #fn("n10====:" #() cddddr) cdddr #fn("n10===:" #() cdddr) cddr

+	    #fn("n10==:" #() cddr) char? #fn("n12005121Q:" #(#fn(typeof) rune) char?) closure?

+	    #fn("n10\\;36040[S:" #() closure?) compile #fn("n170q7105162:" #(compile-f lower-define) compile)

+	    compile-and #fn("n570018283D218467:" #(compile-short-circuit brn) compile-and)

+	    compile-app #fn("n483<88R3U07088152JK088Z3E0218851[3;0218851@40887283=23523q07401q895440r40r4GKMp4750183=530r40r4G8:UMp47608237027@40288:63:89[;3904798951892:Cf07089152J\\0212:517:d3P07;83r2523E07401q83T5447602:62:89B3P07<89<513F07=83513=07>01828364:8:360q@F07401q895440r40r4GKMp4750183=530r40r4G8;UMp48:360q@=00r40r4Gr/Mp48:3C07?018283898:8;67:760823702@@402A8;63:" #(in-env?

+  #fn(top-level-value) length> 255 compile-in compile-arglist emit tcall.l call.l

+  builtin->instruction cadr length= is-lambda? inlineable? compile-let compile-builtin-call tcall

+  call) compile-app)

+	    compile-arglist #fn("n3202101>282524228261:" #(#fn(for-each)

+							   #fn("n170AFq0544Ar4Ar4GKMp:" #(compile-in))

+							   #fn(length)) compile-arglist)

+	    compile-aset! #fn("n3208251r2~87Kl23?07101q2282P64:K87L23h07101q2374828752P544750176828752530r40r4G88UMp47702262:7822r362:" #(#fn(length)

+  compile-app aset! aref list-head compile-arglist list-tail emit argc-error) compile-aset!)

+	    compile-begin #fn("n483H3?0700182715064:83=H3>070018283<64:7001q83<5447202352474018283=64:" #(compile-in

+  void emit pop compile-begin) compile-begin)

+	    compile-builtin-call #fn("n7I202186850>3?;514227385q538<3I07483=8<52J=075858<52@30q4858=26CL086El23:07702862:770858663:8=29C708;60:8=2:C708;60:8=2;C]086El23:07702<62:86r2l23:07702=62:770858663:8=2>Cm086El23:07585K62:86Kl23:07702?62:86r2l23:07702@62:770858663:8=2ACL086El23:07702B62:770858663:8=2CCL086El23:07585K62:770858663:8=2DCN086El23<07702E2F63:770858663:8=2GCX086r2L23;07585r262:770823702H@402G8663:8=2ICb086r2l23:07702J62:r286L23?07708586r3~63:7585r262:7708562:" #(#0#

+  #fn("n0AEl239070FK62:7192FA63:" #(argc-error emit) num-compare)

+  #fn(get) arg-counts length= argc-error list emit loadnil < = + load0 add2 - neg sub2 * load1 /

+  vector loadv #() apply tapply aref aref2) compile-builtin-call)

+	    compile-f #fn("n2702101>22262:" #(call-with-values #fn("n070AF62:" #(compile-f-))

+					      #fn("n20:" #())) compile-f)

+	    compile-f- #fn("n270501T711T517215173741T52711518;J7025@408;87H360E@802687518=268:51~73778:528:3\xa208?JL07886298>883808=U@408=54@r07:867;2<7=2<7>8?527?268?5151535152478862@8>268?51883808=U@408=5547A8608:898>55@30q42B8=L23I07886883702C@402D8=53@W0883?078862E8=53@E08:J?078862F8=53@30q47G0897H7I1518952537J868@<52486r4268951r4Mp47K868@D7I15154478862L5247M2N7O86EG517P86518<5386r3G62:" #(make-code-emitter

+  lastcdr lambda:vars filter cons? λ #fn(length) keyword-arg? emit optargs bcode:indexfor

+  make-perfect-hash-table #fn(map) cons car iota keyargs emit-optional-arg-inits 255 vargc.l argc.l

+  vargc argc extend-env complex-bindings lambda:body box-vars compile-in ret values #fn(function)

+  encode-byte-code const-to-idx-vec) compile-f-)

+	    compile-if #fn("n420502050205083T718351728351B3;0738351@30q8;DC=07401828<64:8;J=07401828=64:7401q8;89554750268953475027885347401828<544823<07502852@;0750298:53475027895347401828=544750278:63:" #(#fn(gensym)

+  caddr cdddr cadddr compile-in emit brn label ret jmp) compile-if)

+	    compile-in #fn("\x8740005000W4000J60q?4483R3<0700183D64:83H3\x97083EC:07102262:83KC:07102362:83DC:07102462:83J:07102562:7683513:07102762:7883513<0710298363:7102:8363:83<2;C<07<0183=63:83<RS;JD0483<Z;J;047=83<1523=07>01828364:83<892?CS07@83T513>07A018283T64:7102:83T63:892BC=07C01828364:892DC>07E018283=64:892FC;07G018363:892HCD07I2J183>22K01>262:892LC@07M018283=8465:892NC>07O018283=64:892PCE07Q0183T2D7R8351P64:892SCE07A01D83T5447102T62:892UC\x93083T7R83517V8;518:R360q@807W2X5148<3`08;=?;47Y8:8<8;<B;3G047Z8;<<51;3:047[8;<5153@30q47\\018:8;<64:892]Cp07A01q2Hq83Te35447^7_835151360q@807W2`5147A01q7_83515447102]62:7>01828364:" #(compile-sym

+  emit load0 load1 loadt loadnil void? loadvoid fits-i8 loadi8 loadv aset! compile-aset! in-env?

+  compile-app quote self-evaluating? compile-in if compile-if begin compile-begin prog1

+  compile-prog1 λ call-with-values #fn("n070AF62:" #(compile-f-))

+  #fn("n270A21053413K02223AF>2152470A242515163:q:" #(emit loadv #fn(for-each)

+						     #fn("n170AF0q64:" #(compile-sym)) closure #fn(length)))

+  and compile-and or compile-or while compile-while cddr return ret set! value-get-doc error "set!: name must be a symbol"

+  symbol-set-doc is-lambda? lambda:vars compile-set! trycatch 1arg-lambda? caddr "trycatch: second form must be a 1-argument lambda") compile-in)

+	    compile-let #fn("n483<83=0r4G88T70018953718;727388518;528:537408=524258=1<521=P7608>827388515440r40r4G8<UMp4E8<L23A082J<0770288<63:q:" #(compile-arglist

+  vars-to-env complex-bindings caddr box-vars #fn(nconc) compile-in emit shift) compile-let)

+	    compile-or #fn("n470018283q21q67:" #(compile-short-circuit brnn) compile-or)

+	    compile-prog1 #fn("n37001q82T544718251B3_00r40r4GKMp47201q718251544730245240r40r4Gr/Mp:q:" #(compile-in

+  cddr compile-begin emit pop) compile-prog1)

+	    compile-set! #fn("n470821E538821CF07201q83544730248263:88<El288=T893<07588=51@9076082528:3o07308937027@40288;5340r40r4GKMp47201q835440r40r4Gr/Mp47302962:7201q8354489JA07:2;2<825251@30q47302=8;63:" #(lookup-sym

+  global compile-in emit setg vinfo:index capture-var! loada loadc set-car! error #fn(string)

+  "internal error: misallocated var " seta) compile-set!)

+	    compile-short-circuit #fn("n783H3?0700182848665:83=H3@070018283<8665:86;J70421507001q83<865540r40r4GKMp486360q@9072023524720858;5340r40r4Gr/Mp486360q@907202452475018283=84858657486340q:720268;63:" #(compile-in

+  #fn(gensym) emit dup pop compile-short-circuit label) compile-short-circuit)

+	    compile-sym #fn("n470821E538821C`02282513M073248251513@07502624825163:750278263:88<El23W0750287988=51534833A088=T3:07502:62:q:7502;7<08252534833A088=T3:07502:62:q:" #(lookup-sym

+  global #fn(constant?) printable? #fn(top-level-value) emit loadv loadg loada vinfo:index car

+  loadc capture-var!) compile-sym)

+	    compile-thunk #fn("n170q21q72051e362:" #(compile-f λ lower-define) compile-thunk)

+	    compile-while #fn("n4205020507101q72505440r40r4GKMp473024885347101q825447302589534730265240r40r4Gr/Mp47101q835447302788534730248963:" #(#fn(gensym)

+  compile-in void emit label brn pop jmp) compile-while)

+	    complex-bindings #fn("n2205020507101qq8687564722386>174875162:" #(#fn(table)

+									      complex-bindings-

+									      filter #fn("n120A062:" #(#fn(has?)))

+									      table-keys) complex-bindings)

+	    complex-bindings- #fn("n61J40q:0R3K0833D02001523;021840D63:q:0H;J80472051340q:0<23Co0200T1523Q021850TD534833>021840TD53@30q@30q474750511q83848566:760<513U074770517817905152q82S;J50483848566:740<17:051838485562;2<1838485>40=52P:" #(#fn(memq)

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

+  inlineable? #fn(map) #fn("n1700AqF929366:" #(complex-bindings-))) complex-bindings-)

+	    const-to-idx-vec #fn("n1200r2G51212285>10KG52485:" #(#fn(vector-alloc)

+								 #fn(for-each)

+								 #fn("n2A10p:" #())) const-to-idx-vec)

+	    copy-tree #fn("n10H3400:700<51700=51P:" #(copy-tree) copy-tree) count

+	    #fn("n2Ib620862186>1_51486<01E63:" #(#0#

+						 #fn("n31J5082:A<01=01<5139082KM@408263:" #() count-)) count)

+	    delete-duplicates #fn("n1700rD523O02150Ib686228586>2_486<^10q62:0H3400:0<0=73858652390748661:85748651P:" #(length>

+  #fn(table) #fn("n20H38070161:21A0<523:0F<0=162:22A0<D534F<0=0<1P62:" #(reverse! #fn(has?)

+									 #fn(put!))) member

+  delete-duplicates) delete-duplicates)

+	    diff #fn("n20J40q:200<1523:0710=162:0<710=152P:" #(#fn(memq) diff) diff) disassemble

+	    #fn("\x871000.///W1000J60q?14z282JG07001E534715047260:@30q482<2305124051II252687>1?:5142527187>2?;514E288851b<I8<<8=L23\x8a24292:888<>2q7;53E8<<L23907150@30q4E87K~2<|48<8<<KM_48>2=8?2>523[08;8>8<<r45348:897?888<<52G5148<8<<r4M_@\x1912=8?2@523V08;8>8<<K5348:89888<<GG5148<8<<KM_@\xea12=8?2A523e08;8>8<<K5347B2C888<<G8>2DC70r3@30EM515148<8<<KM_@\xac12=8?2E523\\08;8>8<<r45347B2C7?888<<52515148<8<<r4M_@w12=8?2F523\xb808;8>8<<r88>2GC70r4@30EM5347B2C7?888<<52512H5248<8<<r4M_47B2C7?888<<52515148<8<<r4M_48>2GCY07B2H5147B2C7?888<<52512H5248<8<<r4M_@30q@\xe608?2Ic3^08;8>8<<r45347B2C7?888<<52512H5248<8<<r4M_@\xb202=8?2J523b08;8>8<<r25347B2K7L8<<7M888<<52M515248<8<<r2M_@w02=8?2N523b08;8>8<<r45347B2K7L8<<7?888<<52M515248<8<<r4M_@<08;8>8<<E53^1^1@\xd0-:" #(disassemble

+  newline void #fn(function:code) #fn(function:vals)

+  #1=#fn("z0I:" #() void) #fn("n10\\3F00[JA070504710qAKM63:72061:" #(newline disassemble print) print-val)

+  #fn("n370A3U0FEl23N071A72151523A0A182ML237023@4024751K~512602765:" #(princ >= 1- " >" "  " hex5

+								       ":  " " ") print-inst)

+  #fn(length) #fn(table-foldl) #fn("n382;J@041AF<Gl2;34040:" #()) Instructions #fn("n1702161:" #(princ

+  "\t")) #fn(memq) (loadv.l loadg.l setg.l) ref-int32-LE (loadv loadg setg)

+  (loada seta loadc call tcall list + - * / < = vector argc vargc loadi8 apply tapply closure box

+   shift aref) princ #fn(number->string) aref (loada.l seta.l loadc.l argc.l vargc.l call.l tcall.l

+						       box.l) (optargs keyargs) keyargs " " brbound

+  (jmp brne brnn brn) "@" hex5 ref-int16-LE (jmp.l brne.l brnn.l brn.l)) disassemble)

+	    div #fn("n201k0EL2;3D041EL2;3404K;J504r/;J404EM:" #() div) emit

+	    #fn("z2I2021?75140EG82Jk0122CB088<23C:08824_@R0125CE08788<513;00E88=p@900E188Pp@D126127523A078082<52e1?2@30q42912:52893D02;82<L23:089T?1@30q^142912<52893D02;82<L23:089T?1@30q^1412=C\\0822>d3=02??14q?2@F0822@d3=02A?14q?2@30q@30q412BC\\0822>d3=02C?14q?2@F0822@d3=02D?14q?2@30q@30q488<12EQ;3b04892FCB00E82<2G88=PPp@J0892HCB00E82<2I88=PPp@30q;J@040E7J182P8852p^140:" #(#0#

+  #fn("n17002162:" #(member (load0 load1 loadt loadf loadnil loadvoid)) load?) car cdr cadr pop #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 brn not brnn eq? brne nreconc) emit)

+	    emit-optional-arg-inits #fn("n582B3\x91020507102284534710238953474075176838452q53q7782515447102884534710295247102:895347;0182=8384KM65:q:" #(#fn(gensym)

+  emit brbound brnn compile-in extend-env list-head cadar seta pop label emit-optional-arg-inits) emit-optional-arg-inits)

+	    encode-byte-code #fn("n17005171855172238651r3238651r2ki2M2452238651E255025502650qqI8988L23\xbc148689G?=48=27CP0288:8689KMG298<5153489r2M?9@\x8b12:8<2;7<873k08=8C2=C702>@X08C2?C702@@L08C2AC702B@@08C2CC702D@408=^1@408=5252489KM?948988L2;38048689G?>42E8=2F523`0288;298<518>5342:8<873707G@407HE5152489KM?9@\xeb08=2ICH02:8<2J8>5152489KM?9@\xce08>X3\xc708=2E8?2K523H02:8<2J8>5152489KM?9@\x9f02E8?2L523\x8102:8<2J8>5152489KM?942:8<2J8689G5152489KM?948=2MCK02:8<2J8689G5152489KM?9@30q@E02:8<2N8>5152489KM?9^1@30q@\x9f.42O2P8<878:>38;5242Q8<61:" #(reverse!

+  list->vector >= #fn(length) 65536 #fn(table) #fn(buffer) label #fn(put!)

+  #fn(sizeof) #fn(io-write) #fn(get) Instructions jmp jmp.l brne brne.l brnn brnn.l brn brn.l #fn(memq)

+  (jmp brne brnn brn) int32 int16 brbound #fn(int32)

+  (loadv.l loadg.l setg.l loada.l seta.l argc.l vargc.l call.l tcall.l loadc.l box.l) (optargs

+										       keyargs)

+  keyargs #fn(uint8) #fn(for-each) #fn("n220A052421AF37072@407324921520~5162:" #(#fn(io-seek)

+										 #fn(io-write)

+										 int32 int16 #fn(get)))

+  #fn(iostream->string)) encode-byte-code)

+	    error #fn("z020210P61:" #(#fn(raise) error) error) eval

+	    #fn("n170710515160:" #(compile-thunk macroexpand) eval) even? #fn("n1200K52El2:" #(#fn(logand)) even?)

+	    every #fn("n21H;JD0401<51;3:047001=62:" #(every) every) expand-define

+	    #fn("n10T70051B3:070051@H085R37021@=07223740515285R3@021258586<e3e2:212585<2627e185=e128865185<54e3e2:" #(cddr

+  #1# error "compile error: invalid syntax " print-to-string set! #fn(nconc) λ #fn(copy-list)) expand-define)

+	    extend-env #fn("n370182E530P:" #(vars-to-env) extend-env) filter

+	    #fn("n2I20210>1?65148601qe163:" #(#0# #fn("n382I1B3Q04A1<513?0821<qPN=?2@30q41=?1@\x0e/4=:" #() filter-)) filter)

+	    fits-i8 #fn("n10Y;3<0470r\xaf0r\xb063:" #(>=) fits-i8) foldl

+	    #fn("n382J401:700082<15282=63:" #(foldl) foldl) foldr #fn("n382J401:082<700182=5362:" #(foldr) foldr)

+	    get-defined-vars #fn("n170A<05161:" #(delete-duplicates) #(#2=(#fn("n10H340q:0<20Cj00=B3d00TR;37040Te1;JS040TB;3E0471051R;3:0471051e1;J404q:0<22C?07324A<0=52}2:q:" #(def

+  caadr begin nconc #fn(map)) #(#2#)))))

+	    getprop #fn("\x8720003000W2000J60q?2420711q5387;3<04208708253;J50482:" #(#fn(get)

+										     *properties*) getprop)

+	    hex5 #fn("n170210r@52r52263:" #(string-lpad #fn(number->string) #\0) hex5) identity

+	    #fn("n10:" #() identity) in-env? #fn("n21B;3F042001<52;J:047101=62:" #(#fn(assq)

+										   in-env?) in-env?)

+	    index-of #fn("n31J40q:01<C5082:7001=82KM63:" #(index-of) index-of) inlineable?

+	    #fn("n10<85B;3u047085<51;3i047185T51;3]04727385T52;3O047485T2552S;3@047685T270=5162:" #(is-lambda?

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

+	    io-readall #fn("n1205021850524228561:" #(#fn(buffer)

+						     #fn(io-copy)

+						     #fn(iostream->string)) io-readall)

+	    io-readline #fn("n12002162:" #(#fn(io-readuntil) #\newline) io-readline) io-readlines

+	    #fn("n17071062:" #(read-all-of io-readline) io-readlines) iota #fn("n17071062:" #(map-int

+  identity) iota)

+	    is-lambda? #fn("n1020Q;J704020Q:" #(λ) is-lambda?) keyword->symbol

+	    #fn("n1200513K021220512386K24865153^161:0:" #(#fn(keyword?)

+							  #fn(symbol)

+							  #fn(string)

+							  #fn(string-sub)

+							  #fn(string-length)) keyword->symbol)

+	    keyword-arg? #fn("n10B;3904200<61:" #(#fn(keyword?)) keyword-arg?) lambda-vars

+	    #fn("n1Ib520852185>1_51485<00qq54422237405162:" #(#0#

+							      #fn("n40S;J5040R340D:0B3Z00<R3T082;J504833<0702112263:A<0=1828364:0B3\x8d00<B3\x870730<r2523?074051R360q@=070250<2615442774051513=0A<0=182D64:833<0702112863:A<0=1D8364:0B3>070290<26164:01C:07021162:7029026164:" #(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("n10B390700<61:0:" #(keyword->symbol))

+							      to-proper) lambda-vars)

+	    lambda:body #fn("n170061:" #(caddr) lambda:body) lambda:vars

+	    #fn("n1700T61:" #(lambda-vars) lambda:vars) last-pair #fn("n10=H3400:700=61:" #(last-pair) last-pair)

+	    lastcdr #fn("n10H3400:70051=:" #(last-pair) lastcdr) length=

+	    #fn("n21EL2340q:1El23500H:0H3701El2:700=1K~62:" #(length=) length=) length> #fn("n21EL23400:1El23;00B;34040:0H3701EL2:700=1K~62:" #(length>) length>)

+	    list->vector #fn("n1700}2:" #(vector) list->vector) list-head

+	    #fn("n2701E52340q:0<710=1K~52P:" #(<= list-head) list-head) list-ref #fn("n2700152<:" #(list-tail) list-ref)

+	    list-tail #fn("n2701E523400:710=1K~62:" #(<= list-tail) list-tail) list?

+	    #fn("n10S;J@040B;3904700=61:" #(list?) list?) load #fn("n120021522285>123850>2{:" #(#fn(file)

+  :read #fn("n0Ib48420A84>2_484<^1III63:" #(#fn("n320A51JG0F<21A510721514735063:24A514737215161:" #(#fn(io-eof?)

+  #fn(read) load-process void #fn(io-close))))) #fn("n120A5142122F0e361:" #(#fn(io-close)

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

+	    load-process #fn("n170061:" #(eval) load-process) lookup-sym

+	    #fn("n31J5020:1<2108752883808288P:7201=82KM63:" #(global #fn(assq) lookup-sym) lookup-sym)

+	    lower-define #fn("n1I2021?55140H;J804720513400:0<23C<0747505161:760<513K02728e10Te185051e17905164:2:74062:" #(#1#

+  #fn("n170051B3N071051B3=02270051P@7073051@607450758551768551863D0278687e328748652P:87:" #(cddr

+  cdddr begin caddr void get-defined-vars lower-define λ #fn(map)) λ-body) quoted? def lower-define

+  expand-define is-lambda? #fn(nconc) λ lastcdr #fn(map)) lower-define)

+	    macrocall? #fn("n10<R;3904700<61:" #(symbol-syntax) macrocall?) macroexpand

+	    #fn("n1IIIIIIIIIIIb5b6b7b8b9b:b;b<b=b>b?208521_51420862286>1_514208723e1_51420882485868?87>4_5142089258?89>2_514208:268:>1_514208;278:8988>3_514208<288?8:8988>4_514208=29888?>2_514208>2:_514208?2;8?8>8;8<8=>5_5148?<0q62:" #(#0#

+  #fn("n20Z;J904200152S:" #(#fn(assq)) top?) #fn("n10H3400:020d3400:0<B3P07105122CF023A<7405151A<0=5162:0<A<0=51P:" #(((begin))

+  caar begin #fn(append) cdar) splice-begin) *expanded* #fn("n20H3400:A<201523:0F<051@300A<21152873;0728651@30q2324758852152b987JA024269289>28662:Ib:8:278:928993>4_48:<^186518:I8;B3c0493<788;51QJC08;92<8;<89<52_@;08;798;51_48;=?;@\xfb/48::" #(begin

+  def get-defined-vars #fn(nconc) #fn(map) list #fn("n1A<0F<62:" #())

+  #fn("n10H3400:0<B3F02071051C<00<A<0=51P:F<0<92<52922223747585515292<52_493<85PA<0=51P:" #(def

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

+  #fn("n20H3400:0<B3M00<=B3F070051A<71051152e2@400<F<0=152P:" #(caar cadar) expand-lambda-list)

+  #fn("n10H3600e1:0<B3?070051A<0=51P:0<A<0=51P:" #(caar) l-vars)

+  #fn("n20T7005171051A<0T5122237489521522225e1F<868:52e192<888:528764:" #(lastcdr cddr #fn(nconc)

+									  #fn(map) list λ) expand-lambda)

+  #fn("n20=S;J6040TH3o070051J400:0T717005151873B00=?0472868752@30q42386A<74051152e3:750517605170051718851F<86512728798:52152893E088=?847287898653@30q42723e18792<868;52Pe193<888;5263:" #(cddr

+  value-get-doc symbol-set-doc def caddr cdadr caadr #fn(nconc)

+  #fn(map) list) expand-define) #fn("n20T20A<71051222324F1>2865215252P:" #(begin cddr #fn(nconc)

+									   #fn(map)

+									   #fn("n10<70A<0TF525150Fe3:" #(compile-thunk))) expand-let-syntax)

+  #fn("n20:" #() local-expansion-env) #fn("n20H3400:0<208615221A10>3873P087=B3I0A<87T0=f2F<72875115262:73051893>0A<890=f2162:87;J?0486RS;J60486Z3708860:8624C400:8625C:092<0162:8625C:092<0162:8626C:093<0162:8627C:094<0162:8860:" #(#fn(assq)

+  #fn("n0Ib48420AF84>3_484<^19261:" #(#fn("n10H3400:0<H3700<@90A<0<F5292<0=51P:" #()))) caddr

+  macrocall? quote λ def let-syntax) expand-in)) macroexpand)

+	    macroexpand-1 #fn("n10H3400:7005185390850=}2:0:" #(macrocall?) macroexpand-1)

+	    make-code-emitter #fn("n0q2050EqEo5:" #(#fn(table)) make-code-emitter)

+	    make-perfect-hash-table #fn("n1Ib5208521_514Ib6862285860>3_486<^12305161:" #(#1#

+  #fn("n270712205151162:" #(mod0 abs #fn(hash)) $hash-keyword)

+  #fn("n120r20i2q52Ib68621A085F86>5_486<^19261:" #(#fn(vector-alloc)

+						   #fn("n10B3p070051r2A<85F52i29286G3;093<FKM61:928685p49286KM71051p494<0=61:92:" #(caar

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

+	    make-system-image #fn("n120021222354247576Dw54Dw64278788>2288685>22989>1{89504:" #(#fn(file)

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

+				       *print-width* *print-readably* *print-level* *print-length*

+				       *os-name* *interactive* *prompt* *os-version* procedure?

+				       top-level-bound?) *print-pretty* *print-readably* #fn("n0Aw04Fw1:" #(*print-pretty*

+  *print-readably*)) #fn("n07021A>17223505152742576842577845253f22885F52429F7:52^1^142;F61:" #(filter

+  #fn("n10Z;3u0420051S;3j0421051[S;JC0422051222105151dS;3I04230A52S;3=04242105151S:" #(#fn(constant?)

+										       #fn(top-level-value)

+										       #fn(string)

+										       #fn(memq)

+										       #fn(iostream?)))

+  simple-sort #fn(environment) nconc #fn(map) list top-level-value #fn(write)

+  #fn(io-write) *linefeed* #fn(io-close))) #fn("n1A50420061:" #(#fn(raise)))) make-system-image)

+	    map! #fn("n21I1B3B04101<51_41=?1@\x1d/4:" #() map!) map-int

+	    #fn("n2701E52340q:0E51qPqb78786_4K7115122870>2|486:" #(<= 1- #fn("n1A<F051qPN4AA<=_:" #())) map-int)

+	    max #fn("z11J400:70210163:" #(foldl #fn("n201L23401:0:" #())) max) member

+	    #fn("n21<0d3401:13:07001=62:q:" #(member) member) memv #fn("n21<0c3401:13:07001=62:q:" #(memv) memv)

+	    min #fn("z11J400:70210163:" #(foldl #fn("n201L23400:1:" #())) min) mod

+	    #fn("n207001521i2~:" #(div) mod) mod0 #fn("n2001k1i2~:" #() mod0) negative?

+	    #fn("n10EL2:" #() negative?) nestlist #fn("n37082E52340q:1710015182K~53P:" #(<=

+  nestlist) nestlist)

+	    newline #fn("\x8700001000W0000J7070?04210725247360:" #(*output-stream* #fn(io-write)

+								   *linefeed* void) newline)

+	    nreconc #fn("n2701062:" #(reverse!-) nreconc) odd?

+	    #fn("n170051S:" #(even?) odd?) partition #fn("n2I2021?65148601qe1qe164:" #(#0#

+										       #fn("n48283PI1B3Z0401<513?0821<qPN=?2@<0831<qPN=?341=?1@\x05/47088<=88==62:" #(values) partition-)) partition)

+	    positive? #fn("n1E0L2:" #() positive?) princ

+	    #fn("z070qw042185>1220>12386>1{86504:" #(*print-readably* #fn("n0Aw0:" #(*print-readably*))

+						     #fn("n02071A62:" #(#fn(for-each) write))

+						     #fn("n1A50420061:" #(#fn(raise)))) princ)

+	    print #fn("z02071062:" #(#fn(for-each) write) print) print-exception

+	    #fn("n10B3e00<20C^0710r3523T072230T2425760515127554787605151@\x0e00B3Z00<29CS0710r3523I0722:760512;534780T51@\xe100B3P00<2<CI0710r2523?0722=0T2>53@\xbe00B3I00<2?CB0722@514720=f2@\xa200B3N00<2ACG07B76051514722C0T52@\x8107D0513m0710r2523c0780<51472275140T2E8551;J60485R37072@40788551^1@>0722F514780514727G61:" #(type-error

+  length= princ "type error: expected " ", got " #fn(typeof) caddr ": " print 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("n1IIb5b620852185>1_51420862285>1_51473740r3523F075076370r5@40r452@300517778292:2;505252Eb92<2=868889>38762:" #(#0#

+  #fn("n32005182P2105121151C?022232487e361:25051E76278851512888A187>4|:" #(#fn(function:name)

+									   #fn(function:code)

+									   #fn(raise) thrown-value

+									   ffound #fn(function:vals)

+									   1- #fn(length)

+									   #fn("n170A0G513>0F<A0G929363:q:" #(closure?))) find-in-f)

+  #fn("n220A01>321{863E0722374758651522662:27:" #(#fn("n02021AF>292524q:" #(#fn(for-each)

+									    #fn("n1A<0Fq63:" #())))

+						  #fn("n10B3F00<20C?00T21C8072061:23061:" #(thrown-value

+  ffound caddr #fn(raise))) string-join #fn(map) string reverse! "/" "λ") fn-name) reverse! length>

+  list-tail *interactive* filter closure? #fn(map) #fn("n10Z;380420061:" #(#fn(top-level-value)))

+  #fn(environment) #fn(for-each) #fn("n17021A<0KGF52524222374051==52470257652492<El23?0770KG0EG52@30q49292<KM_:" #(princ

+  "(" #fn(for-each) #fn("n1702151472061:" #(princ " " print)) vector->list ")" *linefeed*

+  disassemble))) print-stack-trace)

+	    print-to-string #fn("n1205021085524228561:" #(#fn(buffer)

+							  #fn(write)

+							  #fn(iostream->string)) print-to-string)

+	    printable? #fn("n120051;JB0471051;J80422051S:" #(#fn(iostream?) void? #fn(eof-object?)) printable?)

+	    putprop #fn("n320711q5387360q@F02250237118853488?7^14238708253482:" #(#fn(get)

+										  *properties* #fn(table)

+										  #fn(put!)) putprop)

+	    quote-value #fn("n1700513400:210e2:" #(self-evaluating? quote) quote-value) quoted?

+	    #fn("n10<20Q:" #(quote) quoted?) random #fn("n1200513<0712250062:23500i2:" #(#fn(integer?)

+  mod #fn(rand) #fn(rand-double)) random)

+	    read-all #fn("n17071062:" #(read-all-of read) read-all) read-all-of

+	    #fn("n2Ib686201860>3_486<^1q015162:" #(#fn("n220A5138071061:F<10P92A5162:" #(#fn(io-eof?)

+  reverse!))) read-all-of)

+	    ref-int16-LE #fn("n2202101EMGE522101KMGr852M61:" #(#fn(int16)

+							       #fn(ash)) ref-int16-LE)

+	    ref-int32-LE #fn("n2202101EMGE522101KMGr8522101r2MGr@522101r3MGrH52g461:" #(#fn(int32)

+											#fn(ash)) ref-int32-LE)

+	    remprop #fn("n220711q5386;3F042286052;3:042386062:" #(#fn(get) *properties* #fn(has?)

+								  #fn(del!)) remprop)

+	    repl #fn("n0IIb4b5208421_5142085228485>2_51485<5047360:" #(#0#

+								       #fn("n07050421725142324{257651S;3Z04778451788551360q@=079855147:5047;85w<61:" #(*prompt*

+  #fn(io-flush) *output-stream* #fn("n02060:" #(#fn(read)))

+  #fn("n1207151422061:" #(#fn(io-discardbuffer) *input-stream* #fn(raise)))

+  #fn(io-eof?) *input-stream* load-process void? print newline void that) prompt)

+								       #fn("n020A>121{370F<60:q:" #(#fn("n0A<60:" #())

+  #fn("n1700514D:" #(top-level-exception-handler))) reploop) newline) repl)

+	    revappend #fn("n2701062:" #(reverse-) revappend) reverse

+	    #fn("n170q062:" #(reverse-) reverse) reverse! #fn("n170q062:" #(reverse!-) reverse!)

+	    reverse!- #fn("n2I1B3B041=101?04N4?1@\x1d/40:" #() reverse!-) reverse-

+	    #fn("n21J400:701<0P1=62:" #(reverse-) reverse-) self-evaluating? #fn("n120051S;3Z040H;36040RS;JK0421051;3A040R;3:04022051Q:" #(#fn(gensym?)

+  #fn(constant?) #fn(top-level-value)) self-evaluating?)

+	    set-syntax! #fn("n220710163:" #(#fn(put!)

+					    *syntax-environment*) set-syntax!)

+	    simple-sort #fn("n10S;J6040=S3400:0<7021850>22285>162:" #(call-with-values #fn("n07021A>1F=62:" #(partition

+  #fn("n10AL2:" #()))) #fn("n22071051Ae17115163:" #(#fn(nconc) simple-sort))) simple-sort)

+	    splice-form? #fn("n10B;3X040<20Q;JN040<21Q;JD040<22Q;3:04730r252;J704022Q:" #(unquote-splicing

+  unquote-nsplicing unquote length>) splice-form?)

+	    string-join #fn("n20J5020:215022860<5242324861>20=524258661:" #("" #fn(buffer)

+									    #fn(io-write)

+									    #fn(for-each)

+									    #fn("n120AF52420A062:" #(#fn(io-write)))

+									    #fn(iostream->string)) string-join)

+	    string-lpad #fn("n3207182122051~52062:" #(#fn(string) string-rep #fn(string-length)) string-lpad)

+	    string-map #fn("n2205021151EI8887L23O0422860231885251524748851?8@\f/^14258661:" #(#fn(buffer)

+  #fn(string-length) #fn(io-putc) #fn(string-char) 1+ #fn(iostream->string)) string-map)

+	    string-rep #fn("n21r4L23b0701E5235021:1Kl238022061:1r2l2390220062:2200063:731513@02207401K~5262:742200521r2j262:" #(<=

+  "" #fn(string) odd? string-rep) string-rep)

+	    string-rpad #fn("n32007182122051~5262:" #(#fn(string) string-rep #fn(string-length)) string-rpad)

+	    string-tail #fn("n2200162:" #(#fn(string-sub)) string-tail) string-trim

+	    #fn("n3IIb7b820872187>1_51420882288>1_5142305124087<01E895488<082895363:" #(#0#

+											#fn("n48283L23P02012108252523A0A<017282518364:82:" #(#fn(string-find)

+  #fn(string-char) 1+) trim-start) #fn("n3E82L23R020121072825152523?0A<0172825163:82:" #(#fn(string-find)

+  #fn(string-char) 1-) trim-end) #fn(string-length)

+											#fn(string-sub)) string-trim)

+	    symbol-set-doc #fn("z213=070021153@30q482B3J0700222374022q53825253@30q47560:" #(putprop

+  *doc* *funvars* #fn(append) getprop void) symbol-set-doc)

+	    symbol-syntax #fn("n120710q63:" #(#fn(get)

+					      *syntax-environment*) symbol-syntax)

+	    table-clone #fn("n12050212285>1q053485:" #(#fn(table)

+						       #fn(table-foldl)

+						       #fn("n320A0163:" #(#fn(put!)))) table-clone)

+	    table-invert #fn("n12050212285>1q053485:" #(#fn(table)

+							#fn(table-foldl)

+							#fn("n320A1063:" #(#fn(put!)))) table-invert)

+	    table-keys #fn("n12021q063:" #(#fn(table-foldl)

+					   #fn("n3082P:" #())) table-keys)

+	    table-pairs #fn("n12021q063:" #(#fn(table-foldl)

+					    #fn("n301P82P:" #())) table-pairs)

+	    table-values #fn("n12021q063:" #(#fn(table-foldl)

+					     #fn("n3182P:" #())) table-values)

+	    to-proper #fn("n10J400:0H3600e1:0<700=51P:" #(to-proper) to-proper)

+	    top-level-exception-handler #fn("n17071w042285>1230>12486>1{86504:" #(*output-stream*

+										  *stderr* #fn("n0Aw0:" #(*output-stream*))

+										  #fn("n070A51471225061:" #(print-exception

+  print-stack-trace #fn(stacktrace))) #fn("n1A50420061:" #(#fn(raise)))) top-level-exception-handler)

+	    trace #fn("n120051718551Jg0220732425262728290e225e3e22:e12;2985e225e3e4e35152@30q^147<60:" #(#fn(top-level-value)

+  traced? #fn(set-top-level-value!) eval λ #:g352 begin write cons quote newline apply void) trace)

+	    traced? #fn("n170051;3?042105121A<51d:" #(closure? #fn(function:code)) #((#fn("z020210P51472504230}2:" #(#fn(write)

+  x newline #.apply)))))

+	    untrace #fn("n1200517185513C0220238551r3G52@30q^147460:" #(#fn(top-level-value) traced?

+								       #fn(set-top-level-value!)

+								       #fn(function:vals) void) untrace)

+	    value-get-doc #fn("n10<0=208551;3=0486B;350485:" #(#fn(string?)) value-get-doc) values

+	    #fn("z00B3:00=J500<:A0P:" #() #(#3#)) vars-to-env #fn("n32021182>2072230515163:" #(#fn(map)

+  #fn("n2700210A52SS1FM63:" #(vinfo #fn(memq))) iota #fn(length)) vars-to-env)

+	    vector->list #fn("n120051qb6K852186085>3|486<:" #(#fn(length)

+							      #fn("n1AF920~GA<P_:" #())) vector->list)

+	    vector-map #fn("n220151218651E86K~228701>3|487:" #(#fn(length)

+							       #fn(vector-alloc)

+							       #fn("n1A0F920G51p:" #())) vector-map)

+	    vinfo #fn("n30182e3:" #() vinfo) vinfo:heap? #.cadr vinfo:index

+	    #4# vinfo:sym #.car void

+	    #1# void? #fn("n10IQ:" #() void?) zero?

+	    #fn("n10El2:" #() zero?))

binary files a/boot/sl.boot.builtin /dev/null differ

--- a/meson.build

+++ b/meson.build

@@ -147,17 +147,40 @@

 math = cc.find_library('m', required: false)

+brieflz = static_library(

+	'brieflz',

+	sources: [

+		'3rd/brieflz/brieflz.c',

+		'3rd/brieflz/depacks.c',

+	],

+	include_directories: inc,

+	pic: false,

+	prelink: false,

+)

+

+lzpack = executable(

+	'lzpack',

+	sources: [

+		'tools/lzpack.c',

+	],

+	include_directories: inc,

+	link_with: [

+		brieflz,

+	],

+	native: true,

+)

+

 boot = custom_target(

 	'boot',

 	capture: true,

 	input: [

-		'boot/sl.boot.builtin',

+		'boot/sl.boot',

 	],

 	output: [

 		'sl.boot.h',

 	],

 	command: [

-		'tools/boot2h.sh', '@INPUT@',

+		'tools/boot2h.sh', lzpack, '@INPUT@',

 	],

 )

@@ -187,17 +210,6 @@

 	command: [

 		'tools/ops2h.sh', '@INPUT@',

 	],

-)

-

-brieflz = static_library(

-	'brieflz',

-	sources: [

-		'3rd/brieflz/brieflz.c',

-		'3rd/brieflz/depacks.c',

-	],

-	include_directories: inc,

-	pic: false,

-	prelink: false,

 )

 mp = static_library(

--- a/mkfile

+++ b/mkfile

@@ -1,5 +1,7 @@

 </$objtype/mkfile

+cpuobjtype=`{sed -n 's/^O=//p' /$cputype/mkfile}

+

 BIN=/$objtype/bin

 TARG=sl

 CFLAGS=$CFLAGS -p -Isrc -I3rd -I3rd/brieflz -Isrc/plan9 \

@@ -56,6 +58,8 @@

 </sys/src/cmd/mkone

+CFILES=${OFILES:%.$O=%.c}

+

 src/plan9/builtin_fns.h:D:

 	awk -F '[()]' '\

 		/^sl_.*fn/     {attr=$1; next} \

@@ -62,7 +66,7 @@

 		/^_Noreturn/   {attr=$1; next} \

 		/^BUILTIN[_]?/ {printf "BUILTIN_FN(%s, %s)\n", $2, attr} \

 		{attr=""}' \

-	`{ls `{echo $OFILES | sed 's/\.'$O'/.c/g'} >[2]/dev/null} | sort >$target

+	`{ls $CFILES >[2]/dev/null} | sort >$target

 src/cvalues.$O: src/sl_arith_any.inc

 src/sl.$O: src/vm.inc

@@ -69,9 +73,23 @@

 src/equalhash.$O: src/htable.inc

 src/ptrhash.$O: src/htable.inc

-src/plan9/sl.boot.s:D: boot/sl.boot.builtin

-	aux/data2s boot <$prereq >$target

+OFILES_lzpack=\

+	3rd/brieflz/brieflz.$O\

+	3rd/brieflz/depacks.$O\

+	tools/lzpack.$O \

+CFILES_lzpack=${OFILES_lzpack:%.$O=%.c}

+

+tools/$cpuobjtype.lzpack: $CFILES_lzpack

+	objtype=$cputype

+	mk lzpack.$cputype

+

+lzpack.$cputype:V: $OFILES_lzpack

+	$LD $LDFLAGS -o tools/$O.lzpack $OFILES_lzpack

+

+src/plan9/sl.boot.s:D: boot/sl.boot tools/$cpuobjtype.lzpack

+	tools/$cpuobjtype.lzpack < boot/sl.boot | aux/data2s boot >$target

+

 %.$O: %.c

 	$CC $CFLAGS -o $target $stem.c

@@ -81,13 +99,11 @@

 %.$O: src/plan9/builtin_fns.h

 bootstrap:V: $O.out

-	if (test ! -e boot/sl.boot) touch boot/sl.boot

 	cd src && \

 	../$O.out ../tools/gen.lsp && \

 	cp ../boot/sl.boot ../boot/sl.boot.bak && \

 	../$O.out ../tools/mkboot0.lsp builtins.lsp instructions.lsp system.lsp compiler.lsp > ../boot/sl.boot.new && \

 	mv ../boot/sl.boot.new ../boot/sl.boot && \

-	cp ../boot/sl.boot ../boot/sl.boot.builtin && \

 	cd .. && \

 	mk && \

 	cd boot && \

@@ -96,4 +112,7 @@

 	mk

 clean:V:

-	rm -f */*/*.[$OS] */*.[$OS] [$OS].out *.acid $TARG $CLEANFILES

+	rm -f */*/*.[$OS] */*.[$OS] [$OS].out tools/[$OS].lzpack *.acid $TARG $CLEANFILES

+

+nuke:V:

+	mk clean

--- a/src/sl.c

+++ b/src/sl.c

@@ -411,13 +411,13 @@

 	if(t == TAG_FUNCTION){

 		function_t *fn = ptr(v);

 		function_t *nfn = alloc_words(sizeof(function_t)/sizeof(value_t));

-		nfn->bcode = fn->bcode;

 		nfn->vals = fn->vals;

+		nfn->bcode = fn->bcode;

 		nc = tagptr(nfn, TAG_FUNCTION);

 		forward(v, nc);

-		nfn->env = relocate(fn->env);

 		nfn->vals = relocate(nfn->vals);

 		nfn->bcode = relocate(nfn->bcode);

+		nfn->env = relocate(fn->env);

 		assert(!ismanaged(fn->name));

 		nfn->name = fn->name;

 		return nc;

--- a/src/sl.h

+++ b/src/sl.h

@@ -306,8 +306,8 @@

 }sl_aligned(8) cprim_t;

 typedef struct {

-	value_t bcode;

 	value_t vals;

+	value_t bcode;

 	value_t env;

 	value_t name;

 }sl_aligned(8) function_t;

--- a/src/system.lsp

+++ b/src/system.lsp

@@ -1068,13 +1068,11 @@

 (def (make-system-image fname)

   (let ((f (file fname :write :create :truncate))

-        (z (file (string fname ".builtin") :write :create :truncate))

-        (b (buffer))

         (excludes '(*linefeed* *directory-separator* *argv* that

                     *print-pretty* *print-width* *print-readably*

                     *print-level* *print-length* *os-name* *interactive*

                     *prompt* *os-version* procedure? top-level-bound?)))

-    (with-bindings ((*print-pretty* nil)

+    (with-bindings ((*print-pretty* t)

                     (*print-readably* t))

       (let* ((syms

               (filter (λ (s)

@@ -1087,20 +1085,9 @@

                              (not (iostream? (top-level-value s)))))

                       (simple-sort (environment))))

              (data (apply nconc (map list syms (map top-level-value syms)))))

-        (write data b)

         (write data f)

         (io-write f *linefeed*))

-      (let* ((size (sizeof b))

-             (packed (lz-pack (iostream->string b) 10))

-             (hdr (array 'byte 0

-                               (logand 0xff size)

-                               (ash size -8)

-                               (ash size -16)

-                               (ash size -24))))

-        (io-write z hdr)

-        (io-write z packed))

-      (io-close f)

-      (io-close z))))

+      (io-close f))))

 ; initialize globals that need to be set at load time

 (def (__init_globals)

--- a/src/vm.inc

+++ b/src/vm.inc

@@ -279,20 +279,19 @@

 	for(int i = 0; i < x; i++)

 		*pv++ = sp[-x+i];

 	sp -= x;

-	*sp++ = v;

+	*sp = v;

 #if !defined(BITS64)

 	if((x & 1) == 0)

 		pv++;

 #endif

 	function_t *f = (function_t*)pv;

-	value_t e = sp[-2];  // closure to copy

+	value_t e = sp[-1];  // closure to copy

+	sp[-1] = tagptr(f, TAG_FUNCTION);

 	assert(isfunction(e));

-	f->bcode = fn_bcode(e);

 	f->vals = fn_vals(e);

-	f->env = sp[-1];

+	f->bcode = fn_bcode(e);

+	f->env = sp[0];

 	f->name = fn_name(e);

-	sp--;

-	sp[-1] = tagptr(f, TAG_FUNCTION);

 	NEXT_OP;

 }

--- a/tools/boot2h.sh

+++ b/tools/boot2h.sh

@@ -1,3 +1,4 @@

 #!/bin/sh

 set -e

-od -t x1 -v -A n $* | sed -E 's/^[^ ]*[ ]+/ /g;s/[ ]+([^ ]+)/0x\1,/g'

+sed 's/^  */ /g' < "$2" | tr -d '

+' | "$1" | od -t x1 -v -A n | sed -E 's/^[^ ]*[ ]+/ /g;s/[ ]+([^ ]+)/0x\1,/g'

--- a/tools/bootstrap.sh

+++ b/tools/bootstrap.sh

@@ -5,10 +5,9 @@

 test -x $F || { echo no $F found; exit 1; }

 cd src && \

 $F ../tools/gen.lsp && \

-cp ../boot/sl.boot.builtin ../boot/sl.boot.builtin.bak && \

+cp ../boot/sl.boot ../boot/sl.boot.bak && \

 $F ../tools/mkboot0.lsp builtins.lsp instructions.lsp system.lsp compiler.lsp > ../boot/sl.boot && \

-cp ../boot/sl.boot ../boot/sl.boot.builtin && \

 ninja -C ../build && \

 cd ../boot && \

 $F ../tools/mkboot1.lsp && \

-ninja -C ../build || { cp sl.boot.builtin.bak sl.boot.builtin; exit 1; }

+ninja -C ../build || { cp sl.boot.bak sl.boot; exit 1; }

--- /dev/null

+++ b/tools/lzpack.c

@@ -1,0 +1,41 @@

+#include "platform.h"

+#include "brieflz.h"

+

+static uint8_t in[256*1024];

+

+int

+main(int argc, char **argv)

+{

+	unsigned long sz;

+	int n;

+

+	USED(argc); USED(argv);

+	for(sz = 0;; sz += n){

+		if((n = read(0, in+sz, sizeof(in)-sz)) < 0)

+			abort();

+		if(n == 0)

+			break;

+	}

+	if(sz == sizeof(in))

+		abort();

+	uint8_t *out = MEM_ALLOC(1+4+blz_max_packed_size(sz));

+	if(out == nil)

+		abort();

+	uint8_t *w = MEM_ALLOC(blz_workmem_size_level(sz, 10));

+	if(w == nil)

+		abort();

+	unsigned long osz = blz_pack_level(in, out+1+4, sz, w, 10);

+	if(osz == BLZ_ERROR)

+		abort();

+	out[0] = 0;

+	out[1] = sz >> 0;

+	out[2] = sz >> 8;

+	out[3] = sz >> 16;

+	out[4] = sz >> 24;

+	osz += 1+4;

+	if((unsigned long)write(1, out, osz) != osz)

+		abort();

+	MEM_FREE(w);

+	MEM_FREE(out);

+	exit(0);

+}

-- 

⑨