(*builtins* #(#fn("r07080z2:" #(aref) 6) NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL #fn("A180<:" 5)
#fn("A180=:" 5) NIL NIL NIL NIL #fn("A180B:" 5) NIL NIL NIL NIL NIL #fn("A180H:" 5)
NIL NIL NIL #fn("r07080z2:" #(<) 6) NIL #fn("A28081N:" 6) NIL #fn("A28081P:" 6)
#fn("A28081Q:" 6) #fn("A180R:" 5) #fn("A180S:" 5)
#fn("A180T:" 5) NIL #fn("A180V:" 5) NIL #fn("A180X:" 5)
#fn("A180Y:" 5) #fn("A180Z:" 5) #fn("A180[:" 5)
#fn("A180\\:" 5) #fn("A180]:" 5) NIL #fn("A28081_:" 6) NIL NIL NIL #fn("A28081c:" 6)
#fn("A28081d:" 6) #fn("r080:" 4) #fn("r07080z2:" #(apply) 6)
#fn("r07080z2:" #(+) 6) #fn("r07080z2:" #(-) 6)
#fn("r07080z2:" #(*) 6) #fn("r07080z2:" #(/) 6)
#fn("r07080z2:" #(div0) 6) #fn("r07080z2:" #(=) 6)
#fn("A28081m:" 6) NIL #fn("r07080z2:" #(vec) 6)
#fn("r07080z2:" #(aset!) 6) NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
NIL NIL)
*properties* #table(*formals-list* #table(append (lists)  process? ((v))  process-exit-code ((p))  io-eof? ((io))  path-exists? ((path))  cadddr ((lst))  sort ((lst
less-than? (:key identity)))  fixnum? ((v))  exit (((msg NIL) (code 0)))  __finish ((status))  caaar ((lst))  io-peek ((io
type (endian +endianness+))
(io type (n NIL) (endian +endianness+)))  cc-compile ((cc code (decl-fn NIL) (define-fn NIL)))  s32 (((n
0)))  u8 (((n 0)))  any ((pred lst))  nthcdr ((lst n))  s8 (((n 0)))  os-getenv ((name))  tag-of ((v))  io-close ((io))  io-line! ((io
new-line-number))  num? ((v))  rune-downcase ((r))  unquote-splicing ((expr))  assert ((expr))  vec->list ((vc))  1+ ((n))  throw ((tag
value))  positive? ((n))  atan ((x) (y x))  remprop ((symbol key))  io-copy-until ((io-dest
io-src r))  process-input ((p))  cdddar ((lst))  set-cdr! ((cell
new-second))  stacktrace (NIL)  eq? ((a b))  io->str ((io))  bound? ((sym))  list->vec ((lst))  def ((form
body₀ . rest)
(id expr))  call-with-values ((producer receiver))  odd? ((n))  list? ((v))  str-rep ((term k))  process-alive? ((p))  time ((expr))  size-of ((v))  sym ((term . rest))  tanh ((r))  for ((start
limit fn))  begin (body)  const? ((term))  str-trim ((s (lead-pred rune-whitespace?) (trail-pred
lead-pred)))  io-pos! ((io
new-position))  return (((value (void))))  tan ((r))  table (rest)  __rcscript (NIL)  process-error ((p))  doc-group ((group-name
doc))  cdaaar ((lst))  bounds-error ((seq index . msg))  even? ((n))  zero? ((n))  proper-list? ((v))  io-filename! ((io
new-name))  random ((max (state NIL)))  reverse! ((lst))  eval ((x))  cdaadr ((lst))  u32 (((n 0)))  cons ((first
second))  filter ((pred lst))  do ((vars test-spec . commands))  path-make-dir ((path (mode
*io-default-dir-mode*)))  io-buffer-mode! ((io))  let ((binds . body) (id binds . body))  assq ((key
lst))  process-core-dumped? ((p))  make-random-state (((state NIL)))  del! ((table key))  when ((cond . body))  vec? ((v))  min ((v . rest))  cddaar ((lst))  help (((topic
NIL)
(:print-header help-print-header) . rest))  io? ((term))  rune-titlecase ((r))  unquote-nsplicing ((expr))  num->str ((n
(:base 10)))  mod ((a n))  if ((cond then . else))  str-pad ((s n (:align :left) (:fill #\space)))  p32 (((n
0)))  case ((expr . clauses))  io-read-lines ((io))  cc-add-file ((cc path))  io-line ((io))  zip-with ((fn . lst))  trycatch ((try
catch))  macrocall? ((e))  cc-set-options ((cc str))  iterate ((fn zero n))  builtin ((sym))  table-values ((ta))  macroexpand ((e))  caadr ((lst))  type-of ((v))  top-level-value ((sym))  defstruct ((name
docs… options… (slot-1 DEFAULT) slot-2 slot-3)
(name (:type vec) (:named T) (:constructor T) (:conc-name T) (:predicate T) . slots))  caadar ((lst))  foldl1 ((fn
seq))  buffer (NIL (v (:start NIL) (:end NIL)))  find-program ((name))  random-state? ((state))  assoc-list (kvs)  process-close ((p))  builtin? ((v))  with-input (((var
expr) . body))  str-map ((fn s))  macroexpand-1 ((e))  remove-duplicates ((lst))  fn-vals ((fn))  str (terms)  with-exception-bindings (body)  negative? ((n))  void (rest)  io-read-line ((io))  assert-fail ((expr . what))  and (rest)  1- ((n))  io-buffer-mode ((io))  equal? ((a
b))  unquote ((expr))  cddar ((lst))  or (rest)  rune-lower-case? ((r))  make-process ((path args
(:in NIL) (:out NIL) (:err NIL) (:dir NIL)))  = ((n . rest))  fn? ((v))  caaadr ((lst))  make-system-image ((filename))  subseq ((seq
start (end NIL)))  set! ((id expr . rest))  vm-stats (((io *io-out*)))  ptr (((n 0)))  caddar ((lst))  print-stack-trace ((st))  cosh ((x))  values (v)  < ((v . rest))  copy-tree ((lst))  f32 (((n
0.0)))  sin ((r))  io-copy ((io-dest io-src (n NIL)))  > ((v . rest))  str-rune ((s n))  foldl ((fn
zero . seqs))  with-output-to ((io . body))  abs ((n))  str? ((v))  cons? ((v))  io-read ((io
type (endian +endianness+))
(io type (n NIL) (endian +endianness+)))  str-split ((str (sep " \n\t\v\f") (:trim NIL)))  truncate ((x))  make-cc (((fn-err
NIL)))  aset! ((sequence subscripts… new-value))  - ((n . rest))  io-truncate ((io nbytes))  makunbound ((sym))  quasiquote ((expr))  io-column! ((io
new-column-number))  copy-list ((lst (n NIL)))  logand (ints)  time-now (NIL)  sinh ((r))  top-level-exception-handler ((e))  identity ((v))  untrace ((sym))  count ((pred
lst))  io-pos ((io))  map-int ((fn count))  table->assoc-list ((ta))  length< ((seq n))  cc-define ((cc
name (str NIL)))  unless ((cond . body))  str->time ((str))  get-syntax ((sym))  ptr? ((v))  expt ((x
p))  io-read-all ((io))  gc (NIL)  io-write ((io v (endian +endianness+)))  table-invert ((ta))  lz-unpack ((data
:to destination)
(data :size decompressed-bytes))  rune-whitespace? ((r))  div ((a n))  princ (args)  last-cdr ((lst))  trace ((sym))  io-filename ((io))  fn-name ((fn))  let* ((binds . body))  rune->codepoint ((r))  gensym? ((v))  defdoc ((term . doc))  cdddr ((lst))  copy-table ((ta))  set-car! ((cell
new-first))  receive ((formals expr . body))  partition ((pred lst))  dotimes ((var . body))  has? ((table
key))  vec (rest)  while ((cond . body))  rune (((n 65533)))  cadar ((lst))  type-error ((expected-type
got-value . msg))  file ((path (mode *io-default-file-mode*) . flags))  nth ((lst n))  cdr ((lst))  / ((n . rest))  process-output ((p))  newline (((io
*io-out*)))  separate-doc-from-body ((body (doc NIL)))  cdadar ((lst))  cc-undefine ((cc name))  sqrt ((x))  foldr ((fn
zero . seqs))  reverse ((lst))  lz-pack ((data (level 0)))  *prompt* (NIL)  member ((item lst))  rune-numeric? ((r))  bignum? ((v))  fixnum (((n
0)))  f64 (((n 0.0)))  cc? ((v))  memq ((item lst))  str->num ((s (:base NIL)))  exp ((p))  caaaar ((lst))  io-column ((io))  traced? ((fn))  cond (clauses)  s64 (((n
0)))  io-flush ((io))  assoc ((key lst))  + (rest)  path-delete ((path))  cadadr ((lst))  foldr1 ((fn
seq))  compare ((a b))  length ((seq))  error (msg)  print-exception ((e))  set-top-level-value! ((sym
expr))  load ((path/io (eval eval)))  cc-add-sysinclude-path ((cc path))  getpid (NIL)  keyword? ((v))  aref ((sequence
subscript0 . rest))  sym? ((v))  defmacro ((form . body))  cc-add-include-path ((cc path))  u64 (((n
0)))  int-valued? ((x))  assv ((key lst))  bignum (((n 0)))  princ-to-str (args)  copy-vec ((vec))  print-to-str (args)  process-state ((p))  eqv? ((a
b))  process-exit-msg ((p))  list (rest)  __init_globals (NIL)  eof? ((v))  revappend ((lst tail))  quote ((expr))  nreconc ((lst
tail))  defc*r ((name))  rune-alphabetic? ((r))  read-all-of ((fn io))  cddddr ((lst))  prog1 ((expr . rest))  logior (ints)  cadr ((lst))  cdadr ((lst))  nan? ((v))  caar ((lst))  path-rename ((old
new))  div0 ((a n))  set-syntax! ((sym fn))  mod0 ((a n))  last-pair ((lst))  cc-add-library-path ((cc
path))  path-cwd (((to NIL)))  rune-title-case? ((r))  arr? ((v))  cadaar ((lst))  unwind-protect ((expr
finally))  cos ((r))  io-skip ((io offset (:end NIL)))  rune-upper-case? ((r))  with-bindings ((binds . body))  every ((pred
lst))  atom? ((v))  p64 (((n 0)))  fn ((name code maxstack . rest))  str-utf8? ((s))  apply ((f
arg . rest))  cc-relocate ((cc))  process-post ((p note signal))  cddr ((lst))  not ((v))  print (args)  letrec ((binds . body))  with-output (((var) . body)
((var io) . body))  cdar ((lst))  cdaar ((lst))  iota ((count (start 0) (step 1)))  caaddr ((lst))  environment (NIL)  fn-code ((fn))  getprop ((symbol
key (def NIL)))  * (rest)  putprop ((symbol key val))  repl (NIL)  io-read-until ((io r))  get ((table
key (failed-result)))  table? ((v))  u16 (((n 0)))  logxor (ints)  zip (lst)  str-width ((s))  acos ((x))  time->str ((sec))  to-proper ((lst))  caddr ((lst))  table-keys ((ta))  rune-upcase ((r))  set-doc! ((symbol
doc-seq . formals-list))  catch ((tag expr))  __start ((argv interactive))  floor ((x))  add-exit-hook ((fn))  str-join ((strlist
sep))  >= ((v . rest))  lognot ((int))  void? ((v))  length= ((seq n))  int? ((v))  nanoseconds-monotonic (NIL)  io-discard-buffer ((io))  with-input-from ((io . body))  car ((lst))  <= ((v . rest))  arr ((type . rest))  ceiling ((x))  length> ((seq
n))  arg-error (msg)  asin ((x))  put! ((table key value))  log ((x (base (exp 1))))  cdaddr ((lst))  ash ((int
nbits))  str-sub ((s start (end NIL)))  arr-alloc ((type length . rest))  vec-alloc ((length . rest))  cddadr ((lst))  memv ((item
lst))  max ((v . rest))  closure? ((v))  read-all ((io))  help-print-header ((term sigs (:kind NIL)
(:lpad "")))  sleep ((sec))  s16 (((n
0)))  rune? ((v))  os-setenv ((name value))  __script ((path)))  *doc* #table(append "Return the concatenation of the arguments.\n\nLists are copied, except the last one, which becomes the `cdr` of the\nfinal dotted pair.  It's returned as is if it was the only argument.\nNo lists are changed in-place."  (doc
group error) "Errors and exception handling."  process? "Return `T` if the argument is a process, `NIL` otherwise."  process-exit-code "Return the process' exit status code or `NIL` if the process might still be running.\n\nOn Plan 9 this function will always return `0` to indicate normal termination, or `1`\nin any other case - see `process-exit-msg`."  io-eof? "Return `T` if `io` is currently in the \"end of file\" state, `NIL`\notherwise."  path-exists? "Return `T` if `path` exists on the filesystem, `NIL` otherwise."  cadddr "Shorthand for `(car (cdr (cdr (cdr lst))))`."  (doc
group string) "Strings and runes."  sort "Return a copy of the list sorted by comparing elements with the\ntwo-argument function `less-than?`.\n\nAn optional keyworded argument `:key` is used to provide a function to\nretrieve terms (the _key_) from the list items in order to perform\ncomparison.  By default the terms compared are the list elements\nthemselves."  fixnum? "Return `T` if `v` is of a fixnum type, `NIL` otherwise."  exit "Terminate the process with the specified message and code. Does not return.\n\nThe message is expected to be a non-empty string in case of an error.\nThe code is expected to be a positive integer in case of an error."  __finish "A function called right before exit by the VM.\n\nThe exit `status` is either `NIL` or a string referring to the error\ncondition."  caaar "Shorthand for `(car (car (car lst)))`."  io-peek "Return a value of the specified type by peeking at data of the IO\nobject.\n\nCompared to `io-read`, this function does not consume the data -\nmultiple repeated calls with the same arguments will return the\nsame result.\n\nThe `type` must specify a fixed-width number, pointer, or rune.\n\nNumerical values may be peeked at in a specific endianness order\nby setting `endian` to either `:little-endian` or `:big-endian`.\nHost CPU endianness is used if not specified.\n\nIf the parameter `n` is provided, peek `n` values of the type,\nreturning an array of the values or a string when `type` is `utf8`."  cc-compile "Compile the C code, passing all declarations and macro definitions to the optional\ncallbacks.\n\nThe code can be either a string or an IO object.\n\nReturns `T` on success, `NIL` otherwise."  s32 "Construct a 32-bit signed number."  u8 "Construct a 8-bit unsigned number."  any "Return `T` if the predicate is true for _any_ element of the list,\n`NIL` otherwise."  nthcdr "Return the reminder of the list after at most `n` elements, or `NIL`\nif the list is shorter."  s8 "Construct a 8-bit signed number."  os-getenv "Return the value of the environment variable `name` or `NIL` if it's\nnot set."  tag-of "Return the internal VM tag of the value."  io-close "Close the IO object.\n\nNo further operations on the IO object are possible, those will throw\nan exception if attempted.  The only exception is `(io-filename io)`,\nwhich might be useful in some cases for debugging purposes."  io-line! "Change the current line number of the IO object."  num? "Return `T` if `v` is of a numerical type, `NIL` otherwise.\n\nNumerical types include floating point, fixnum, bignum, etc.\nNote: ironically, a NaN value is considered a number by this function\nsince it's only testing the _type_ of the value."  rune-downcase "Return the lowercase version of the rune.\n\nThe rune is returned unchanged if it has no case."  unquote-splicing "Evaluate the expression, which is a part of a quasi-quoted expression\nitself, and \"splice\" it at the location."  +os-name+ "The name of the operating system this StreetLISP VM executable was\nbuilt for.\n\nIt's set to a lowercase string and its value is considered \"best\neffort\" - it might not always be accurate.\n\nPossible values: `\"unknown\"`, `\"plan9\"`, `\"linux\"`, `\"openbsd\"`,\n`\"netbsd\"`, `\"dragonflybsd\"`, `\"freebsd\"`, `\"haiku\"`, `\"macosx\"`,\n`\"macos\"`, `\"dos\"`."  assert "Throw an exception if `expr` evaluates to `NIL`.  Return `T` in any\nother case."  vec->list "Return the vector converted to a list."  1+ "Equivalent to `(+ n 1)` - increment by one."  throw "Raise an exception consisting of a tag and a value.\n\nThis exception can be handled directly with `catch`,\nsee `(help catch)`."  positive? "Return `T` if `n` is greater than zero. Shorthand for `(> n 0)`."  atan "Return the arc tangent of `y/x` in radians."  *builtins* "VM instructions as closures."  remprop "Remove a property associated with the symbol.\n\nReturns `T` if the property was removed, `NIL` if there was no\nsuch association defined for the symbol."  io-copy-until "Copy bytes from the source IO object to the destination until\nencountering the delimiting rune `r` and return the number of bytes\ncopied.  The copied bytes include the delimiter."  (doc
group list) "Working with lists."  process-input "Return the standard input stream of the process, or `NIL` if none has been connected."  (doc
group compare) "Comparison operators."  cdddar "Shorthand for `(cdr (cdr (cdr (car lst))))`."  set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list).  Return the modified cons\ncell (list)."  stacktrace "Return the current stack trace."  eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise."  *random-state* "The random state of the current process.\n\nThe state isn't set (is `NIL`) until a call is made to any function\nthat uses it."  io->str "Return the data of the in-memory `io` buffer as a string."  bound? "Return `T` if `sym` has a value associated with it, `NIL` otherwise."  list->vec "Return the list converted to a vector."  def "Assign the function (first form) or the result of the expression\n(second form) to the identifier.\n\nDocumentation for the definition may also be supplied after `form` in\nthe same manner as with `defdoc` macro (see `(help defdoc)`).\n\nFunction definitions themselves may contain other definitions internal\nto the function.\n\nIf the name of the definition starts and ends with a plus sign (`+a-symbol+`),\nthe binding becomes constant. Trying to modify it will raise an error unless\nthe new value is equivalent and is of the same type. Note, non-leaf types such\ntables, strings, arrays, and vectors assigned to the name can still be modified\nthemselves - the value is not constant itself, only the binding."  call-with-values "Call `producer` and pass the values produced as arguments to\n`receiver`."  odd? "Return `T` if `n` is an odd integer, `NIL` otherwise."  list? "Return `T` if the value is either `NIL` or a cons cell, `NIL`\notherwise."  str-rep "Return the concatenation of the `term` formatted as a string, repeated\n`k` times."  process-alive? "Return `T` if the process is still alive, or `NIL` otherwise."  time "Display the elapsed time of evaluating `expr` to `*io-out*`, return\nthe result of the evaluated expression."  size-of "Return the size of the value in bytes, if applicable.\n\nWorks only with C integer types, arrays, strings, and in-memory\nbuffers."  sym "Return a symbol with the name being the concatenation of terms\nformatted as strings.\n\nThis is equivalent to `(sym (str …))`."  tanh "Return the hyperbolic tangent of `x`."  for "Call the function `f` with a single argument in a loop until the argument\nreaches `limit` or greater.\n\nThe argument is incremented by `1` after each call, with the initial value\nset to `start`."  begin "Evaluate the expressions in order and return the result of the last\nexpression."  const? "Return `T` if the term refers to a constant, `NIL` otherwise.\n\nConstants cannot be modified with `set!`.  Trying to do so will result\nin an exception."  str-trim "Return the portion of the string with all leading runes satisfying\n`lead-pred` (and trailing runes satisfying `trail-pred`) removed.\n\nWithout predicates explicitly specified, `str-trim` will remove\nwhitespace from both sides of the string.\n\nPass `NIL` as the predicate to disable trimming on either side."  io-pos! "Change the current absolute position within the IO object in bytes,\nreturn the resulting position."  return "Return from the function with the specified value as the result."  *stderr* "Standard error output IO stream."  tan "Return the tangent of `r`, where `r` is given in radians."  table "Construct a table from keys from the arguments.\n\nEvery two arguments are expected to be a key and a value associated\nwith that key."  __rcscript "Execute, if exists, the user's \"run commands\" file.\n\nThe file path is predefined and depends on the OS:\n\n * `$home/lib/slrc` on Plan 9\n * `$HOME/.slrc` on other operating systems\n\nIt is automatically loaded by StreetLISP when running in interactive\nmode.  The user may wish to use this file to change the look of the\nprompt, load additional functionality they want to use without having\nto do the process manually each time, and so on."  process-error "Return the standard error stream of the process, or `NIL` if none has been connected."  doc-group "Define documentation for a group."  cdaaar "Shorthand for `(cdr (car (car (car lst))))`."  bounds-error "Raise a bounds error exception."  even? "Return `T` if `n` is an even integer, `NIL` otherwise."  *properties* "All properties of symbols recorded with `putprop` are in this table."  zero? "Return `T` if `n` is zero. Shorthand for `(= n 0)`."  proper-list? "Return `T` is the value is a proper list.  That is, a non-circular\nlist with the last element being `NIL`, as opposed to a dotted list."  io-filename! "Change the filename of the IO object, return the new filename.\n\nChanging the filename does not cause any side effects.  The filename\nis purely informative and does not necessarily reflect the actual\npath."  random "Return a random number in the range `[0, max]` (inclusive).\n\nThe result is either an integer or a floating point number, depending\non the type of the `max` argument, which has to be a positive number.\n\nOptional `state` can be specified, otherwise the random state of the\ncurrent process (`*random-state*`) is used. State will be modified\nin-place."  *directory-separator* "OS-specific path separator.\n\nIt is preferred over hardcoded `\"/\"`, for portability."  reverse! "Return the list with its elements in reverse order.\n\nThe original list may be modified by this function since it's a\ndestructive operation."  eval "Evaluate expression."  cdaadr "Shorthand for `(cdr (car (car (cdr lst))))`."  u32 "Construct a 32-bit unsigned number."  cons "Return a cons cell containing two arguments."  filter "Return a copy of the list with only the elements of the original\nthat satisfy the predicate."  do "Run `commands` sequentially in a loop until the test condition\nevaluates to `NIL`.\n\nEach variable in `vars` consists of the variable's name, its\ninitial value and (optionally) a single \"step\" expression:\n\n    (var-name init-value step-expr)\n\nLoop test condition and (optionally) the result expression are\ncontained within `test-spec`:\n\n    (test-cond result-exprs)\n\nLoop runs as long as `test-cond` evaluates to `NIL`. If `test-cond`\nis satisfied (result is not `NIL`), loop is terminated and either\nthe result of `result-exprs` is returned or, if `result-exprs` isn't\nsupplied, `#<void>` is used instead.\n\nAfter each loop run, every variable containing a step expression\ngets updated to the result of that expression, which may reference\nthe variable by its name."  make-random-state "Return a new random state.\n\nIf `state` is `NIL`, a copy of the random state of the current process\n(`*random-state*`) is returned. If `state` is `T`, the returned random\nstate is a new one that has been randomly initialized. If an already\nexisting random state is passed, the returned value is a copy of that\nstate."  path-make-dir "Create the directory (directories) if they do not already exist.\n\nEach directory is created, unless it already exists, with the mode\nbits `*io-default-dir-mode*` if not specified."  io-buffer-mode! "Changed the output buffering behavior of the writable IO, return the\napplied value.\n\nSee `io-buffer-mode` for supported modes."  let "Bind variables and execute a series of expression that use\nthese bindings, return the result of the last expression.\n\nIf a binding in the first form consists of a variable name alone,\nits value is set to `#<void>`.\n\nThe second form `(let id ((… ) …) …)`, which is called\n\"named let\", allows referencing the resulting lambda within\nthe expressions following the bindings to aid with recursive\ncalls."  process-core-dumped? "Return `T` if a core image was dumped by the process, or `NIL` otherwise."  assq "Return a pair of a matching key and the associated value, or `NIL` if\nnone matched.  Keys are compared using `eq?`."  del! "Remove any existing mapping for `key` and return the table."  when "Shorthand for `(if cond body NIL)`.\n\nA non-empty body is required."  vec? "Return `T` if `v` is a vector, `NIL` otherwise."  min "Return the smallest among the arguments."  cddaar "Shorthand for `(cdr (cdr (car (car lst))))`."  io? "Return `T` if `term` is of `io` type, `NIL` otherwise."  help "Display documentation for a specific term or group of terms, if\navailable.\n\nAn optional symbol `group` is used to query for documentation on a\ngroup instead of a single term.  All available documentation groups\ncan be displayed with `(help groups)`.\n\nAsterisk can be added to the beginning and/or end of the term in order\nto list the matching terms defined in the current environment.  This\ncan be useful to recall a function's name.\n\nRune `↳` followed by an object appearing in the documentation describes\nthe returned value. Rune `‼` follows by what is being written to the\noutput or by an error raised."  (doc
group array) "Arrays and vectors."  rune-titlecase "Return the title case version of the rune.\n\nFor most runes the result is the same as with `rune-upcase`."  unquote-nsplicing "Evaluate the expression, which is a part of a quasi-quoted expression\nitself, and \"splice\" it at the location.\n\nUnlike `unquote-splicing`, this macro may operate destructively\non the list produced."  num->str "Return the number formatted as a string.\n\nFloating point numbers can only be formatted in base 10.  Bignums are\nsupported with bases 2, 4, 8, 10, 16 and 32.  The rest of the\nnumerical types are valid for any base from 2 to 36.\n\nNote: unlike other LISP dialects, StreetLISP's base-32 encoding is\ndone according to RFC 4648."  mod "Return the remainder of the Euclidean division `a/n`."  if "Return the result of `then` if `cond` evaluated as \"true\", `else`\notherwise.\n\nThe `else` is not optional unlike in many other LISP implementations.\nPrimary purpose is to spot errors involving wrong parenthesis\nplacement.  Another reason is to force a certain code style."  str-pad "Return the string padded until the given length.\n\nBy default the string is padded with spaces on the right."  p32 "Construct a 32-bit abstract pointer value."  case "Evaluate an expression, select one of the clauses by matching\nthe result with `eqv?`, and return the result of the clause.\n\nThe special `else` clause matching expression, if specified, is\nused as a fallback if none of the clauses matched the result.\nIf no `else` was specified and no matches occurred, `NIL` is\nreturned."  io-read-lines "Return a list of lines read from the IO object until it ran out of\ndata.\n\nThe file is split into lines by `#\\linefeed`.  Each string will have\nthe character, except the last line if EOF has been reached\nbeforehand."  cc-add-file "Add a file to the C compiler object and return `T` on success, `NIL` otherwise.\n\nThe file can be a C file, a library, an object file or a linker scripts."  io-line "Return the current line number of the IO object.\n\nLine number is purely informative and is only being automatically\nupdated with the files opened for reading.  If the cursor position is\nchanged via `io-skip` or `io-pos!`, the behavior is undefined."  zip-with "Return a list where each nth element is the result of the supplied\nfunction applied to the corresponding elements from the parameter lists.\n\nThe resulting list is as long as the shortest of the arguments."  trycatch "Return the result of evaluation of the expression `try` or, if an\nexception has been thrown, the one-argument function `catch`."  (doc
group builtin) "Built-in operators."  macrocall? "Return the macro application function if `e` refers to a macro call,\n`NIL` otherwise."  cc-set-options "Append to the list of the C compiler options. Multiple options can be specified\nin the string, separated with spaces."  iterate "Return the list of length `n` containing results of applying function\n`fn` to `zero`, 0 through `n` times.\n\nThe result is of form\n\n    [zero (fn zero) (fn (fn zero)) (fn (fn (fn zero))) …]"  *syntax-environment* "Table containing macro definitions.\n\nThe keys are macro names, the values are their application functions."  builtin "Return the builtin associated with the symbol.\n\nThrows an exception if no such builtin exists."  table-values "Return the list of all values of the table."  macroexpand "Return a fully macro-expanded expression.\n\nExpansion will continue until no more macro calls are left."  caadr "Shorthand for `(car (car (cdr lst)))`."  type-of "Return the underlying type of the value."  top-level-value "Return the value bound to the symbol in the top level (global)\nenvironment."  defstruct "Declare a new structure type with the specified name and slots.\n\nThe default underlying type is a \"named\" vector (`:type vec`), where\nthe first element is the name of the structure's type, the rest are\nthe keyworded slot values.  A list with slot values alone can be used\ninstead by adding `:type list` option.  The list will not contain the\nname of the struct by default, which can be enabled with `:named T`\noption.\n\nAs an example, the following declaration generates the default\nconstructor for a structure of three slots, with one of them (`c`)\nhaving a non-`NIL` default value and marked as read-only:\n\n    (defstruct blah \"Return stuff.\" :doc-group stuff a b (c 1 :read-only T))\n    ; (make-blah (:a NIL) (:b NIL) (:c 1))\n    ; (blah-a s)\n    ; (blah-b s)\n    ; (blah-c s)\n    ; (blah-a! s new-a)\n    ; (blah-b! s new-b)\n\nSlot's options, if any, should be specified after its default value.\nSupported options are:\n\n    ; mark the slot as read-only\n    ; its value can be read, but trying to modify it will throw an error\n    … :read-only T\n\nThe constructor can be changed in several ways:\n\n    ; disable the constructor altogether\n    (defstruct blah :constructor NIL a b c)\n    ; only change its name\n    (defstruct blah :constructor blargh a b c)\n    ; rename AND avoid using keywords\n    (defstruct blah :constructor (blah a b c) a b c)\n\nThe option `:conc-name` specifies the slot accessor/setter prefix,\nwhich defaults to `structname-`.  Prefix can be disabled entirely with\n`:conc-name NIL`.\n\nSlot setters are generated for writable slots by appending `!`\n(exclamation mark) to the accessor's name.\n\nDefault predicate can be disabled or its name, which defaults to\n`structname?`, changed:\n\n    ; use \"blargh?\" instead of \"blah?\"\n    (defstruct blah :predicate blargh? a b c)\n    ; without predicate\n    (defstruct blah :predicate NIL a b c)"  caadar "Shorthand for `(car (car (cdr (car lst))))`."  foldl1 "Same as `foldl` but using the first element of the sequence as the\ninitial accumulator."  buffer "Return an in-memory buffer of `io` type.\n\nIn the first form an empty buffer for both reading and writing is returned.\n\nA read-only buffer pointing at the underlying data of `v` is returned in\nthe second form. Optionally, the range of the data (measured in bytes)\navailable when accessing the buffer may be limited by using `:start` and/or\n`:end` keyworded arguments."  find-program "Returns the full path to an executable by its name, or `NIL` if not found."  random-state? "Return `T` if the argument is a random state object, `NIL` otherwise."  assoc-list "Construct an association list from the arguments.\n\nEvery two arguments are expected to be a key and a value associated\nwith that key."  process-close "Close any streams connected to the process."  builtin? "Return `T` if `v` is a built-in function implemented in C, `NIL`\notherwise."  with-input "Evaluate expressions in `body` with `var` bound to a readable buffer\ncontaining the result of the expression during the evaluation.\n\nOptionally, the range of the data (measured in bytes) available\nwhen accessing the buffer may be limited by using `:start` and/or\n`:end` keyworded arguments.\n\nThe result returned will be that of the last expression in the `body`."  str-map "Return the concatenation of the values produced by `fn` when applying\nto each rune of the string `s`.\n\nFunction `fn` may return a value of any type suitable for `io-write` -\na rune, string, array of C primitives.  If `fn` returns `NIL`, the\nrune is ignored."  macroexpand-1 "Return a macro-expanded expression.\n\nIf the expression is not a macro call, it is returned unchanged.\nOnly a single level of expansion is performed."  +endianness+ "Endianess of the CPU the VM is running on, a constant.\n\nSet to either `:big-endian` or `:little-endian`."  remove-duplicates "Return a copy of the list with duplicated elements removed.\n\nElements are tested for duplicates using `equal?`.  The order of the\nelements is preserved in the resulting list."  fn-vals "Return the vector of values used by the function."  str "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\n_returned_, rather than printed."  with-exception-bindings "Bind `*print-…` variables to their `*exception-print-…` counterparts\nevaluate the body."  negative? "Return `T` if `n` is a negative number. Shorthand for `(< n 0)`."  void "Return the constant `#<void>` while ignoring any arguments.\n\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."  io-read-line "Return a single line of input read from `io`.\n\nReading stops at either a `#\\linefeed` character or upon reaching EOF.\nThe linefeed character is included in the returned value unless EOF\nhas been reached beforehand.\n\nEOF (`#<eof>`) is returned if the IO object had no data."  assert-fail "Throw an \"assertion failed\" exception if evaluating `expr` itself does\nnot result in an exception thrown. Return `T` otherwise.\n\nTo test for a specific exception type, an optional `what` argument can\nbe used."  and "Return `NIL` and stop evaluating the arguments if one of them\nevaluated to `NIL`.  Return the last value otherwise."  1- "Equivalent to `(- n 1)` - decrement by one."  io-buffer-mode "Return the output buffering mode of the writable IO.\n\nPossible values include:\n\n* `NIL` - no buffering, data is written immediately\n* `:line` - data is written when `#\\newline` is encountered\n* `:block` - data is written when the buffer is full\n* `:memory` - the IO is an in-memory buffer itself"  that "The result of the last expression evaluated in the REPL."  (doc
group prop) "Dealing with properties of symbols."  equal? "Return `T` if both `a` and `b` are of the same value.  For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values."  unquote "Evaluate the expression, which is a part of a quasi-quoted expression\nitself, and insert it at the location."  (doc
group vm) "VM-related functions."  *interactive* "Variable indicating whether VM is running in \"interactive\" mode (`T`,\nREPL is active) or not (`NIL`, REPL is not active).\n\nInteractive mode can be forced by adding `-i` as the first command\nline argument."  or "Return the first evaluated argument that is not `NIL` and stop\nevaluating the rest of the arguments.  Return `NIL` otherwise."  rune-lower-case? "Return `T` if the rune is a lowercase one, `NIL` otherwise."  make-process "Run an external program with the specified arguments.\n\nThe program is specified by its full path to the executable (`\"/bin/ls\"`). See\n`find-program` for an easy way to locate programs by their name alone.\n\nFirst element in the list of arguments, by convention, is usually the program's name.\n\nBy default, standard input, output, and error streams are assigned to `/dev/null` by\nspecifying is as `NIL`. To inherit any of the streams from the main (StreetLISP) process\nitself, it should be assigned to `T` instead. One can also set it to a string path instead,\nin which case for output and error streams the files will be created (or truncated)\nautomatically. Existing IO objects can be passed as well, if any specific file modes\n(like `:append`, see `(help file)`) are needed. A special variant, `:io` is used to create\na pipe - that is useful when dynamic communication with the running process is wanted.\nA construct `:err :out` will direct both standard output and error output to the same stream\nor IO object.\n\nA `:dir path` will make the program run in the specified directory. Note: any files specified\nwith `:in`, `:out` and `:err` will be created in the current working directory of the main\nprocess, not the one specified with `:dir`.\n\nBy default, the environment of the main process is copied. It can be replaced with\n`:env new-env` instead, where the new environment is an association list of key and value\npairs. To start the process with a completely clean environment, `:env NIL` is used."  cddar "Shorthand for `(cdr (cdr (car lst)))`."  = "Numerical equality test.  Return `T` if all numbers are equal,\n`NIL` otherwise."  fn? "Return `T` if `v` is a function, `NIL` otherwise."  (doc
group type) "Dealing with types."  caaadr "Shorthand for `(car (car (car (cdr lst))))`."  make-system-image "Build and store a \"system image\" of the runtime environment to a file."  subseq "Return a bounded part of a sequence.\n\nThe returned value is always a copy of the subsequence of the\noriginal.  It is an error if either `start` or `end` (if specified)\nare out of bounds."  set! "Evaluate the expression, assign the result to the identifier and\nreturn the value.\n\nThe identifier must already be bound in the same environment,\notherwise this results in a compilation error.\n\nMultiple identifiers and expressions may be specified in pairs.  The\nreturned value will be the result of the last expression."  vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap, and stack size, etc."  ptr "Construct an abstract pointer value.  The bit width is either 32-bit\nor 64-bit, depending on the platform the code is executing on.\n\nNote: certain arithmetic operations on pointers, such as division and\nmultiplication, will throw an error.  This is done on purpose since\ndoing that on pointers rarely makes sense."  caddar "Shorthand for `(car (cdr (cdr (car lst))))`."  print-stack-trace "Print the stacktrace."  *stdin* "Standard input IO stream."  cosh "Return the hyperbolic cosine of `x`."  values "Return the supplied values as multiple-return values."  < "Return `T` if the arguments are in strictly increasing order (next\none is greater than the previous one).  With a single argument\nthe result is always `T`."  (doc
group time) "Measuring, manipulating and displaying time."  copy-tree "Return a recursive copy of the list.\n\nUnlike `copy-list`, this function copies sub-elements of the list\nrecursively."  f32 "Construct a 32-bit floating point number."  sin "Return the sine of `r`, where `r` is given in radians."  io-copy "Copy bytes from the source IO object to the destination and return\nthe number of bytes copied.  If `n` is provided, copy up to that many\nbytes."  > "Return `T` if the arguments are in strictly decreasing order (previous\none is greater than the next one)."  str-rune "Return the nth rune of the string.\n\nThrows an exception if the index `n` is out of bounds."  foldl "Reduce the sequences to a single value by repeatedly applying the\nfunction left-associatively.\n\nThe function should be of the form `(fn e₀ e₁ … eₙ acc)`. For each\niteration each `eᵢ` will be set to successive values of the `i`-th\nsequence. The value `acc` will initially be set to `zero` and\nsubsequently to the previous value of the function application.\n\nThe iteration will terminate once the shortest sequence is exhausted.\n\nFor example, for two sequences `(e₀ e₁ … eₙ)` and `(d₀ d₁ … dₙ)`, the\nresult will be:\n\n    (fn eₙ dₙ (…(fn e₁ d₁ (fn e₀ d₀ zero))…))\n\nNote that `foldl` is tail call recursive."  +os-version+ "The \"version\" of the operating system StreetLISP VM is running on.\n\nThe availability of the constant and its value depends on the\noperating system and is only provided for the user to see.  No logic\nshould depend on it."  abs "Return absolute value of the argument."  with-output-to "Evaluate expressions in `body` with `*io-out*` set to `io` during the\nevaluation."  *linefeed* "OS-specific _linefeed_ value.\n\nIt is preferred over hardcoded `\"\\n\"`, for portability."  str? "Return `T` if the argument is a string, `NIL` otherwise."  cons? "Return `T` if `v` is a cons cell, `NIL` otherwise."  io-read "Return a value of the specified type by reading it from the IO\nobject.\n\nThe `type` must specify a fixed-width number, pointer, or rune.\n\nNumerical values may be read in a specific endianness order by setting\n`endian` to either `:little-endian` or `:big-endian`.  Host CPU\nendianness is used if not specified.\n\nIf the parameter `n` is provided, read `n` values of the type,\nreturning an array of the values or a string when `type` is `utf8`."  str-split "Return a list of substrings of `str` by splitting at any character in\nthe string `sep`. The splitting characters are removed.\n\nBy default the string is split on space, line feed (newline),\nhorizontal and vertical tab, and form feed.\n\nTrim removes empty strings from the list."  truncate "Return the integer value of `x` rounded toward zero.\n\nIf `x` is already an integer (or infinite, or NaN), result is `x`."  make-cc "Return a new C compiler object.\n\nThe optional argument `fn-err` is used to print any error messages and warnings\nduring compilation of C code by the returned object."  aset! "Modify the sequence element specified by the subscripts and return the\nnew value.  The sequence can be an array, vector, a list.\nMulti-dimensional sequences are supported."  - "Return the result of subtraction.  With only one argument a\nnegation is performed."  io-truncate "Truncate the underlying IO object to the specified number of bytes."  makunbound "Make the symbol unbound."  quasiquote "Same as `'expr` but allows evaluating (\"unquoting\") parts of\nthe expression."  io-column! "Change the current column number of the IO object."  copy-list "Return a copy of the list.\n\nThe number of elements to be copied can be limited with the optional\nargument `n`."  logand "Return the result of bitwise AND operation on integers."  time-now "Return the number of nanoseconds since Epoch (1970-01-01 00:00:00).\n\nThis measures the system-wide real (wall-clock) time."  sinh "Return the hyperbolic sine of `x`."  *argv* "The list of command line arguments.\n\nIf StreetLISP was started in interactive mode without a file specified\nfor execution, `*argv*` will be a list containing just one value - the\nname of the `sl` executable.\n\nOtherwise, the file specified for execution and the rest of the remaining\narguments will form the `*argv*` list.\n\nStreetLISP's own options, such as `-i` and `-H ...` will be stripped\nout in any case."  top-level-exception-handler "Print the exception `e` and the stack trace to `*stderr*`.\n\nThis is the top level exception handler that is used by `load` and\n`repl` functions to handle exceptions that weren't handled at the\nlower level."  identity "Return `v`."  untrace "Disable tracing for the function bound to the symbol."  count "Return the number of elements in the list that satisfy the predicate."  io-pos "Return the current absolute position within the IO object in bytes."  +most-positive-fixnum+ "A constant integer closest to positive infinity that can be\nrepresented by fixnum type on this particular platform."  map-int "Return a list of elements generated by repeated calls to `fn`.\n\nThe lambda `fn` will be called with a single argument which is an\nincreasing number in the range `[0, count)` (exclusive).  The\nresulting list contains the values returned by `fn`."  table->assoc-list "Return the table converted to an association list (pairs of each\nkey and value)."  length< "Shorthand for a bounded length test `(< (length seq) n)`."  cc-define "Define a macro. Same as `#define …`."  unless "Shorthand for `(if cond NIL body)`.\n\nA non-empty body is required."  (doc
group cc) "C compiler."  str->time "Return the number of nanoseconds since Epoch from a time and date\nformatted as a string.\n\nBecause the supported format is limited, the returned value will have\nprecision in seconds at most."  get-syntax "Return a macro application function based on its name, or `NIL` if\nit's not defined."  (doc
group table) "Tables of keys with associated values."  ptr? "Return `T` if the argument is an abstract pointer, `NIL` otherwise."  expt "Return the value of `x` raised to the power of `p`."  io-read-all "Return a string containing all the data read from the IO object\nuntil it ran out of data.\n\nAn empty string (`\"\"`) is returned if the IO object had no data."  gc "Force a garbage collection run.\n\nOne does not need to execute this function manually since garbage\ncollection will happen automatically, based on the amount of data\nallocated."  io-write "Write the value to the IO object, return the number of bytes written.\n\nThe value may be a string, a fixed-width number or pointer, a rune,\nor an array.\n\nNumerical values may be written in a specific endianness order by\nsetting `endian` to either `:little-endian` or `:big-endian`.  Host\nCPU endianness is used if not specified.\n\nWhen writing a rune or an array of runes, they will be converted and\nwritten as a UTF-8 string."  table-invert "Return a new table with the keys and values from the original table\nbut entries _inverted_ - values to keys and keys to values.\n\nNote that if the original table had several keys mapped to the same\nvalue, only one such mapping will be stored in the new table."  lz-unpack "Return decompressed data previously compressed using Lempel-Ziv.\n\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."  rune-whitespace? "Return `T` if the rune is whitespace, `NIL` otherwise."  div "Return the quotient of the Euclidean division `a/n`."  princ "Print the arguments to `*io-out*` with `*print-readably*` set to `NIL`."  (doc
group struct) "Declaring and manipulating structures."  last-cdr "Return the second element of the last cell in the list.\n\nIt will always evaluate to `NIL` with any proper list."  trace "Enable tracing for the function bound to the symbol.\n\nWhen tracing is enabled for the function, before evaluating the call\nthe name and arguments will be printed to `*io-out*`."  io-filename "Return the filename of the IO object."  fn-name "Return the name of the function as a symbol."  let* "Same as the first form of `let` but each of the binding\nexpressions may reference any of the variables bound previously.\n\nIf a binding consists of a variable name alone, its value is\nset to `#<void>`."  rune->codepoint "Return a rune's Unicode code point as a fixnum."  gensym? "Return `T` if the argument is a gensym, `NIL` otherwise."  (doc
group syntax) "StreetLISP syntax and macros."  defdoc "Define documentation for a top level term.\n\nUseful in cases where the documentation for a term has to be set\nindependent of the definition of said term, or an additional form\nwith the same name has to be documented.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined.\n\nFirst `doc` argument is supposed to be a string with the description\nof the term.  The following arguments are expected to be optional tag\npairings that provide grouping for multiple symbols (`:doc-group`),\n\"see also\" references (`:doc-see`) and code examples (`:doc-example`).\n\nCustom formatting lambda (`:doc-fmt`) may be used to process the\ndocumentation string when it's printed with `(help ...)`. It's used\nby `defstruct` to provide full constructor description in the output."  cdddr "Shorthand for `(cdr (cdr (cdr lst)))`."  copy-table "Return a new copy of the table with the keys and values preserved.\n\nNo copies of the keys nor values are created - original ones are\nreused."  set-car! "Modify a cons cell (a list) in-place by putting `new-first` as its\nfirst element (head of the list).  Return the modified cons\ncell (list)."  receive "Capture multiple-return values into the given identifiers and\nevaluate the body."  partition "Return two lists where the first contains the elements of the original\nlist which satisfy the predicate and the second containing the rest of\nthe elements.\n\nBoth lists will have the elements appear in the same order as in the\noriginal list."  dotimes "Execute expressions in a loop the specified number of times.\n\nThe argument `var` defines the loop variable name, the iteration\ncount and (optionally) the resulting expression to evaluate and\nreturn the value of:\n\n    (var-name count (result-expr #<void>))\n\nIf `result-expr` is not specified, `#<void>` is used instead.\n\nThe variable is incremented by `1` after each iteration, with its\ninitial value set to `0`, and may be referenced in expressions of\nthe `body`."  has? "Return `T` if the table has a value associated with the key, `NIL` otherwise."  vec "Construct a vector containing the specified arguments."  while "Evaluate the body expressions until `cond` evaluates to `NIL`."  rune "Construct a rune from a Unicode code point.  Without code point\nspecified, an \"invalid\" rune (`#xFFFD`) is returned."  *exit-hooks* "Internal variable, a list containing functions to call right before VM\nprocess exits."  cadar "Shorthand for `(car (cdr (car lst)))`."  type-error "Raise a type error exception."  file "Open a file for input and/or output.\n\nFiles are created, when a flag `:created` is used, with the mode\nbits `*io-default-file-mode*` if not specified.\n\nAn `io` object is returned.  Without any flags specified the file\nmust already exist and is opened in read-only mode.\n\nSupported flags:\n\n    :append\n    :create\n    :exclusive\n    :read\n    :remove-when-closed ; only on Plan 9\n    :truncate\n    :write"  nth "Return nth element of the list, or `NIL` if the list is shorter."  cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available."  / "Return the division of the arguments.  With only one argument the\nresult of `1/x` is returned.  The result is always a floating point."  process-output "Return the standard output stream of the process, or `NIL` if none has been connected."  newline "Write a single OS-specific linefeed to the output.\n\nOn most systems it's a single character - `#\\linefeed` (`\\n`)."  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  cdadar "Shorthand for `(cdr (car (cdr (car lst))))`."  cc-undefine "Undefine a macro. Same as `#undef …`."  sqrt "Return the square root of `x`."  foldr "Reduce the sequences to a single value by repeatedly applying the\nfunction right-associatively.\n\nThe function should be of the form `(fn e₀ e₁ … eₙ acc)`. For each\niteration each `eᵢ` will be set to successive values of the `i`-th\nsequence. The value `acc` will initially be set to `zero` and\nsubsequently to the previous value of the function application.\n\nThe iteration will terminate once the shortest sequence is exhausted.\n\nFor example, for two sequences `(e₀ e₁ … eₙ)` and `(d₀ d₁ … dₙ)`, the\nresult will be:\n\n    (fn e₀ d₀ (fn e₁ d₁ (…(fn eₙ dₙ zero)…)))\n\nNote that `foldr` is NOT tail call recursive."  reverse "Return the list with its elements in reverse order.\n\nThe original list is copied to construct the reversed version."  lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`.  With `level` set to\n`0` a simple LZSS using hashing will be performed.  Levels between\n`1` and `9` offer a trade-off between time/space and ratio.  Level\n`10` is optimal but very slow."  *prompt* "Function called by REPL to tell the user it's expecting input.\n\nThe default `*prompt*` function prints `#;> `, which by itself is a\ncommented-out expression, allowing the user to copy-paste the entire\nline (with the prompt) to reevaluate."  member "Return the tail of a list beginning with the item, or `NIL` otherwise.\nList elements are compared to the `item` using `equal?`."  rune-numeric? "Return `T` if the rune is numeric, `NIL` otherwise."  bignum? "Return `T` if the argument is a bignum, `NIL` otherwise."  memq "Return the tail of a list beginning with the item, or `NIL` otherwise.\nList elements are compared to the `item` using `eq?`."  cc? "Return `T` if the value is a C compiler object, `NIL` otherwise."  f64 "Construct a 64-bit floating point number."  fixnum "Construct a fixnum."  str->num "Return the number using the radix `base` in the string `s`.\n\nReturns `NIL` if the number could not be parsed. Any number of leading\nand/or trailing whitespace runes is allowed and those will be ignored."  exp "Return the exponential - value of `e` (natural logarithms base) raised\nto the power of `p`."  (doc
group debug) "Debugging utilities."  +most-negative-fixnum+ "A constant integer closest to negative infinity that can be\nrepresented by fixnum type on this particular platform."  caaaar "Shorthand for `(car (car (car (car lst))))`."  io-column "Return the current column number of the IO object.\n\nColumn number is purely informative and is only being automatically\nupdated with the files opened for reading.  If the cursor position is\nchanged via `io-skip` or `io-pos!`, the behavior is undefined."  traced? "Return `T` if the tracing is enabled for the function, `NIL`\notherwise."  cond "Select one of the clauses by evaluating the condition, evaluate the\naccompanied expressions for the matching clause and return the result.\n\nDifferent clause form variants are available. The most common is\n`(test then…)`, which gives the result of `then…` if `test` did not\nevaluate to `NIL`. Second form, `(test)`, which gives the result\nof `test` unless it's `NIL`. Third form, `(test => fn)`, calls `fn`\nwith a single argument which is the non-`NIL` result of evaluating\n`test`.\n\nThe special `else` clause condition, if specified, is used as a fallback\nif none of the other conditions were satisfied. If none were satisfied\n_and_ `else` was not provided, `NIL` is returned."  (doc
group io) "Files and input/output functionality."  s64 "Construct a 64-bit signed number."  io-flush "Flush the contents of the output buffer to the underlying IO."  assoc "Return a pair of a matching key and the associated value, or `NIL` if\nnone matched.  Keys are compared using `equal?`."  + "Return sum of the arguments or `0` when none specified."  path-delete "Delete the name from the filesystem.\n\nThrows an IO error if the path does not exist or it failed to be\nremoved."  cadadr "Shorthand for `(car (cdr (car (cdr lst))))`."  foldr1 "Same as `foldr` but using the first element of the sequence as the\ninitial accumulator."  compare "Return -1 if `x` is less than `y`, 0 if equal, and `1` if `y` is\ngreater than `x`."  length "Return the length of the sequence.\n\nString's length is measured in UTF-8 code points.  For tables the number\nof key-value pairs is returned.\n\nNote: for circular lists the result is `NIL`.  A type error exception is\nthrown on improper lists, which are not considered valid sequences."  *io-err* "Current (default) error output IO stream.\n\nFunctions may use `*io-err*` for error output, which then can be\nredirected to a different IO using `with-bindings`."  print-exception "Print the exception in a human-readable form.\n\nExceptions are lists containing various information about the error.\nThey may optionally, as the first element, contain the error location\nof the form `(io row column)`."  error "Raise an error."  set-top-level-value! "Evaluate the expression and assign the result to the symbol in the top\nlevel (global) environment.\n\nThe use of this function is discouraged.  For the usual assignment of\nvalues to names it is recommended instead to use `(def …)` and/or\n`(set!  …)`."  load "Read and evaluate expression from the file or IO object.\n\nIf the argument is an IO object it is _not_ closed after the load\nfinishes."  cc-add-sysinclude-path "Append a directory to the the list of the system-specific include\nsearch paths."  getpid "Return the process ID of the StreetLISP VM within the operating system\nit's running on."  *io-default-file-mode* "Default mode bits when creating new files.\n\nIt is set to `#o644` at startup."  keyword? "Return `T` if the argument is a keyword, `NIL` otherwise."  aref "Return the sequence element specified by the subscripts.  The sequence\ncan be an array, vector, a list.  Multi-dimensional sequences are\nsupported."  sym? "Return `T` if `v` is a symbol, `NIL` otherwise."  defmacro "Define a new macro."  cc-add-include-path "Append a directory to the list of the include search paths."  u64 "Construct a 64-bit unsigned number."  int-valued? "Return `T` if `x` is a number and is equal (as in `=`) to an\ninteger value of `x`."  Instructions "VM instructions mapped to their encoded byte representation."  assv "Return a pair of a matching key and the associated value, or `NIL` if\nnone matched.  Keys are compared using `eqv?`."  bignum "Construct a bignum.  As opposed to a fixnum, its value is not limited."  princ-to-str "Same as `(princ …)` but the result is returned as a string instead."  copy-vec "Return a copy of the vector with the same elements.\n\nNo copies of the values themselves are created, the original values\nare reused."  print-to-str "Same as `(print …)` but the result is returned as a string instead."  process-state "Return the current state of the process.\n\nThe result is either `:running`, `:exited`, `:stopped` or `:signaled`."  eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise.  Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures."  +f64-epsilon+ "A smallest positive floating point number such that\n`(+ 1.0 +f64-epsilon+)` is not equal to `1.0`."  list "Return a list constructed of the arguments."  process-exit-msg "Return the process' exit status code or `NIL` if the process might still be running.\n\nOn any OS other than Plan 9 this function will always the exit status code converted to\na string - see `process-exit-code`."  eof? "Return `T` if the argument is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by IO functions to signal end of file,\nwhere applicable."  __init_globals "Initialize globals that need to be set at load time."  +pi+ "Mathematical constant π."  revappend "Return list with its elements in reverse order, with `tail` appended\nto its end.\n\nThe original list is copied to construct the reversed version."  quote "Leave the expression unevaluated."  nreconc "Return list with its elements in reverse order, with `tail` appended\nto its end.\n\nThe original list may be modified by this function."  defc*r "Define a shorthand for list access using `car` and `cdr`."  rune-alphabetic? "Return `T` if the rune is alphabetic, `NIL` otherwise."  (doc
group misc) "Miscellaneous."  read-all-of "Return the list containing the values returned by call `(fn io)` repeated\nuntil the IO object runs out of data."  cddddr "Shorthand for `(cdr (cdr (cdr (cdr lst))))`."  prog1 "Evaluate the expressions in order, return the result of the first\nexpression."  logior "Return the result of bitwise OR (inclusive OR) operation on integers."  cadr "Shorthand for `(car (cdr lst))`, that is, _first element of the\nsecond element_."  cdadr "Shorthand for `(cdr (car (cdr lst)))`."  (doc
group doc) "Writing and reading documentation."  nan? "Return `T` if `v` is a floating point representation of NaN, either\nnegative or positive, `NIL` otherwise."  caar "Shorthand for `(car (car lst))`."  path-rename "Rename a file or a directory.\n\nThrows an IO error if the path does not exist or it failed to be\nrename. On most operating systems (not Plan 9), files can be moved\nbetween directories."  div0 "Return the quotient of the truncated division `a/n`."  set-syntax! "Associate a macro name with its application function."  mod0 "Return the remainder of the truncated division `a/n`."  last-pair "Return the last cell (pair) of the list."  cc-add-library-path "Add a directory to the end of the list of the library search paths."  path-cwd "Return the full path to the current directory of the process, or\nchange it to the path specified with `to` argument."  (doc
group compress) "Compression."  *print-width* "Current maximal visible width (in terminal cells) of strings printed or `NIL`\nif strings are to be printed in full.\n\nTruncation does not occur in the middle of a code point or a grapheme cluster.\n\nNote: if a string contains an invalid rune or a control character for which\nits width is undefined, the string is printed in full if the rune in question\nwould fit otherwise."  rune-title-case? "Return `T` if the rune is a title case one, `NIL` otherwise.\n\nFor most runes the result is the same as with `rune-upper-case?`."  arr? "Return `T` if the argument is either a vector or an array, `NIL`\notherwise."  cadaar "Shorthand for `(car (cdr (car (car lst))))`."  unwind-protect "Evaluate `expr` first, then `finally`, regardless of whether\nevaluating the former resulted in any exception thrown or not.\n\nIf an exception has been thrown, it will be raised _after_ evaluating\n`finally`, else the result of `expr` is returned."  cos "Return the cosine of `r`, where `r` is given in radians."  io-skip "Update the current absolute position within the IO object by the\nrelative offset in bytes, return the resulting absolute position.\n\nTo specify the position relative to the end of the file, use the\noptional `:end T` argument with a negative offset."  *io-default-dir-mode* "Default mode bits when creating new directories.\n\nIt is set to `#o755` at startup."  rune-upper-case? "Return `T` if the rune is an uppercase one, `NIL` otherwise."  *io-in* "Current (default) input IO stream.\n\nFunctions may use `*io-in*` for input, which then can be redirected\nfrom a different IO using either `with-input-from` or (a more general)\n`with-bindings`."  with-bindings "Evaluate expressions with the values of the specified variables\noverridden for the duration of the evaluation."  every "Return `T` if the predicate is true for _every_ element of the list,\n`NIL` otherwise."  atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise.  This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible."  p64 "Construct a 64-bit abstract pointer value."  fn "A function constructor."  str-utf8? "Return `T` if `s` is a valid UTF-8 string, `NIL` otherwise."  apply "Return the result of applying a function `f` to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function."  cc-relocate "Perform all relocations, return `T` on success, `NIL` otherwise.\n\nAfter relocation has been performed, the resulting code can be executed."  process-post "Send a signal to the process.\n\nBoth a `note` and a `signal` must be specified for the sake of portability.\nOn Plan 9 the note (a string) is sent to the process. On any other operating system the\nprocess instead receives the signal, which is one of the following: `'ABRT`, `'ALRM`,\n`'CONT`, `'HUP`, `'INT`, `'KILL`, `'QUIT`, `'STOP`, `'TERM`, `'USR1`, `'USR2`."  cddr "Shorthand for `(cdr (cdr lst))`."  not "Return `T` if `v` is `NIL`, `T` otherwise."  print "Print the arguments to `*io-out*` with `*print-readably*` set to `T`.\n\nMultiple arguments are separated with a single `#\\space`."  letrec "Same as the first form of `let` but each of the binding\nexpressions may reference any of the variables bound, before\nor after.\n\nIf a binding consists of a variable name alone, its value is\nset to `#<void>`."  with-output "Evaluate expressions in `body` with `var` bound to `io` during the\nevaluation.\n\nIf expression `io` was not specified (first form), `var` will point\nto a new in-memory buffer and the resulting contents will be returned\nas a string.\n\nWith the second form the result of the last expression in the `body`\nwill be returned instead."  cdar "Shorthand for `(cdr (car lst))`."  cdaar "Shorthand for `(cdr (car (car lst)))`."  iota "Return a list of generated indices.\n\nThe sequence of numbers generated will contain the elements:\n\n    (start start+step … start+(count-1)*step)"  caaddr "Shorthand for `(car (car (cdr (cdr lst))))`."  environment "Return the list of all bound top level symbols."  fn-code "Return the code of the function.\n\nIf the argument is a built-in function implemented in C, the\nfunction itself is returned instead."  (doc
group random) "Random numbers generation."  T "A boolean \"true\"."  * "Return product of the arguments or `1` when none specified."  putprop "Associate a property with the symbol, return the value."  *io-out* "Current (default) output IO stream.\n\nFunctions may use `*io-out*` for output, which then can be redirected\nto a different IO using either `with-output-to` or (a more general)\n`with-bindings`."  repl "Run interactive prompt in a loop, reading and evaluating the\nexpressions entered by the user and printing the results.\n\nThis function is executed automatically if StreetLISP is started in\ninteractive mode."  io-read-until "Return a string by reading from the IO object until encountering the\ndelimiting rune `r`.  The returned string includes the delimiter."  getprop "Return a property value associated with the symbol or `def` if\nmissing.\n\nIf the default value is not supplied and the property is missing,\nexception `key-error` will be thrown."  get "Return the value associated with the `key` in the table.\n\nIf the key isn't in the table then either return the optional\n`failed-result` argument or (if called without the argument) throw a\n`key-error` exception."  table? "Return `T` if the argument is a table, `NIL` otherwise."  u16 "Construct a 16-bit unsigned number."  logxor "Return the result of bitwise XOR (exclusive OR) operation on integers."  zip "Return a list where each nth element is a list of the corresponding\nelements from the parameter lists.\n\nThe resulting list is as long as the shortest of the arguments."  str-width "Return the number of columns needed to represent a string or a rune.\n\nIf a non-printable control rune is encountered, the result is `NIL`,\nelse it is a non-negative integer. Rune `#\\null` is considered of width zero."  acos "Return the arc cosine of `x` in radians."  time->str "Return the number of nanoseconds since Epoch formatted as time and date.\n\nThis is the opposite of `str->time`."  to-proper "Return a proper list that is a copy of the original list."  caddr "Shorthand for `(car (cdr (cdr lst)))`."  table-keys "Return the list of all keys of the table."  rune-upcase "Return the higher case version of the rune.\n\nThe rune is returned unchanged if it has no case."  set-doc! "Set the documentation for the symbol."  catch "Evaluate `expr` and catch any exception thrown while evaluating by a\ncall to `throw` with the specified `tag`.\n\nIf no exception was thrown, return the result of the expression.  In\ncase an exception thrown has a different tag, raise it further, to be\ncaught on a higher level of exception handling logic."  __start "The system boot image entry.\n\nThis is the first function executed by the VM after initialization."  NIL "An empty list.  Can be used as the opposite of T in boolean\nexpressions."  floor "Return the largest integer that is less than or equal to `x`.\n\nInfinity and NaN `floor` to themselves."  add-exit-hook "Puts a one-argument function on top of the list of exit hooks.\n\nOn shutdown each exit hook is called with the exit status as a single\nargument, which is `NIL` on success or a string describing the error\notherwise.\n\nThe hook added last will be called first."  str-join "Return concatenated elements of `strlist`, separated between each\nother with `sep`, as a single string.\n\nThe separator can be of any type suitable for `io-write` - a rune,\nstring, array of C primitives."  (doc
group sys) "OS-specific functions."  >= "Return `T` if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)."  +f32-epsilon+ "A smallest positive floating point number such that\n`(+ 1.0f +f32-epsilon+)` is not equal to `1.0f`."  lognot "Return the result of bitwise NOT (complement) operation on an integer."  length= "Perform a bounded length test and return `T` if the length is `n`,\n`NIL` otherwise.\n\nUse this instead of `(= (length seq) n)`, since it avoids unnecessary\nwork and always terminates.\n\nThe value of `seq` can be of any sequence type."  void? "Return `T` if `v` is `#<void>`, `NIL` otherwise."  int? "Return `T` if the argument is an integer, `NIL` otherwise."  nanoseconds-monotonic "Return the number of nanoseconds passed since the first call to this\nfunction.\n\nThe first call will always return 0."  io-discard-buffer "Discard the contents of the output buffer of the writable IO."  with-input-from "Evaluate expressions in `body` with `*io-in*` set to `io` during the\nevaluation."  *stdout* "Standard output IO stream."  car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available."  arr "Construct a packed array containing the specified arguments.\n\nThe arguments will be coerced to a single `type` which must be\na fixed-width number or pointer type, or rune."  ceiling "Return the smallest integer that is greater than or equal to `x`.\n\nInfinity and NaN `ceiling` to themselves."  length> "Perform a bounded length test and return `T` if the length is greater\nthan `n`, `NIL` otherwise.\n\nUse this instead of `(> (length seq) n)`, since it avoids unnecessary\nwork and always terminates.\n\nThe value of `seq` can be of any sequence type."  <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)."  arg-error "Raise an argument error exception."  put! "Store the value associated with the key and return the table.\n\nAny existing value associated with the key will be replaced."  (doc
group number) "Operations on numbers, mathematical constants."  log "Return the logarithm of `x` in `base`.\n\nDefault base is `e`, returning natural logarithm of the first\nargument."  asin "Return the arc sine of `x` in radians."  cdaddr "Shorthand for `(cdr (car (cdr (cdr lst))))`."  ash "Return the integer shifted by the specified number of bits to the\nright (negative `nbits`) or left (positive `nbits`)."  str-sub "Return the portion of the string within the specified bounds.\n\nThe `start` and `end` index by rune. Specifying any index out of bounds\nof the string will result in an exception thrown.\n\nIf `end` isn't specified the portion is assumed to begin at `start`\nuntil the end of the original string."  vec-alloc "Construct a vector of the specified `length` by repeating\nthe elements in `rest`."  arr-alloc "Construct a packed array of the specified `length` by repeating\nthe elements in `rest`.\n\nThe arguments will be coerced to a single `type` which must be\na fixed-width number or pointer type, or rune."  cddadr "Shorthand for `(cdr (cdr (car (cdr lst))))`."  memv "Return the tail of a list beginning with the item, or `NIL` otherwise.\nList elements are compared to the `item` using `eqv?`."  max "Return the largest among the arguments."  closure? "Return `T` if the argument is a function that is implemented in LISP\n(as opposed to a C builtin), `NIL` otherwise."  (doc
group process) "External processes."  read-all "Return a list of terms read from the IO object until it ran out of\ndata."  help-print-header "Format and print signatures of the term for `(help term)` output."  arg-counts "VM instructions mapped to their expected arguments count."  sleep "Halt the StreetLISP VM for the specified duration of time in seconds.b"  s16 "Construct a 16-bit signed number."  rune? "Return `T` if the value is a rune, `NIL` otherwise."  os-setenv "Add or replace the value of the environment variable `name` to\n`value`.\n\nIf `value` is `NIL`, the variable is deleted from the environment if\nit exists."  __script "Execute a single file at `path`.\n\nAn unhandled exception will result in it being printed to `*io-err*`\nand the process exiting with a non-zero (non-empty in case OS is Plan\n9) status signaling an error to its parent.")  *doc-extra* #table(append ((:doc-example . "(append '(1) '(2 3) '(4))\n; ↳ (1 2 3 4)")
(:doc-example . "(append '(1))\n; ↳ (1)") (:doc-group . list) (:doc-see . nconc) (:doc-see . revappend))  process? ((:doc-group . process)
(:doc-see . make-process))  process-exit-code ((:doc-group . process) (:doc-see . process-exit-msg))  io-eof? ((:doc-group . io))  path-exists? ((:doc-group . io)
(:doc-see . file) (:doc-see . path-delete))  cadddr ((:doc-group . list))  sort ((:doc-example . "; simple sort (note: symbols > numbers)\n(sort '(1a 1 0 2b e 3) <)\n; ↳ (0 1 3 1a 2b e)")
(:doc-example . "; sort in lexicographical order (as strings)\n(sort '(1a 1 0 2b e 3) < :key str)\n; ↳ (0 1 1a 2b 3 e)")
(:doc-example . "; sort by type (note how the numbers stayed in the same order)\n(sort '(3 \"a\" 1 a #\\a 2)\n      (λ (a b) (< (type-of a) (type-of b))))\n; ↳ (3 1 2 #\\a \"a\" a)")
(:doc-group . list)
(:doc-see . partition))  fixnum? ((:doc-group . type)
(:doc-group . number) (:doc-see . fixnum) (:doc-group . builtin))  exit ((:doc-example . "(exit) ; exit with code 0 (message '' on Plan 9)")
(:doc-example . "(exit \"error\") ; exit with code 1 (message \"error\" on Plan 9)")
(:doc-group . sys))  __finish ((:doc-group . vm)
(:doc-see . __start))  caaar ((:doc-group . list))  io-peek ((:doc-example . "(io-peek f 'utf8 5)\n; ↳ \"hello\"")
(:doc-example . "(io-peek f 'u32)\n; ↳ 57")
(:doc-example . "(io-peek f 'u32 3)\n; ↳ #arr(u32 0 1 2)")
(:doc-example . "(io-peek f 'rune 6)\n; ↳ #arr(rune #\\λ #\\a #\\m #\\b #\\d #\\a)")
(:doc-group . io) (:doc-see . io-read))  cc-compile ((:doc-group . cc))  s32 ((:doc-group . number)
(:doc-see . u32))  u8 ((:doc-group . number) (:doc-see . s8))  any ((:doc-example . "(any even? '(1 3 5 7)) ; any even number?\n; ↳ NIL")
(:doc-example . "(any (λ (s) (length> s 1)) ; any string longer than one rune?\n  '(\"ab\" \"cd\" \"e\"))\n; ↳ T")
(:doc-group . list) (:doc-see . every))  nthcdr ((:doc-example . "(def l '(a b c))\n(nthcdr l 1)\n; ↳ (b c)\n(nthcdr l 2)\n; ↳ (c)\n(nthcdr l 10)\n; ↳ NIL")
(:doc-group . list) (:doc-see . nth))  s8 ((:doc-group . number) (:doc-see . u8))  os-getenv ((:doc-group . sys)
(:doc-see . os-setenv))  tag-of ((:doc-example . "(tag-of 1)\n; ↳ fixnum") (:doc-example . "(tag-of NIL)\n; ↳ special")
(:doc-example . "(tag-of \"hello\")\n; ↳ cvalue")
(:doc-example . "(tag-of (s32 1))\n; ↳ unboxed")
(:doc-group . vm) (:doc-see . type-of))  io-close ((:doc-example . "(def f (file \"/dev/random\"))\n(io-read f 'u8)\n; ↳ #u8(123)\n(io-close f)\n(io-read f 'u8)\n; ‼ I/O error: closed file")
(:doc-group . io) (:doc-see . file))  io-line! ((:doc-group . io) (:doc-see . io-line) (:doc-see . io-column!))  num? ((:doc-group . type)
(:doc-group . number) (:doc-see . nan?) (:doc-group . builtin))  rune-downcase ((:doc-example . "(rune-downcase #\\ä)\n; ↳ #\\ä")
(:doc-example . "(rune-downcase #\\DŽ)\n; ↳ #\\dž")
(:doc-group . string)
(:doc-see . rune-lower-case?)
(:doc-see . rune-upcase)
(:doc-see . rune-titlecase))  unquote-splicing ((:doc-example . "(def x '(1 2 3))\n`(0 1 ,.(map 1+ x))\n; ↳ (0 1 2 3 4)")
(:doc-group . syntax) (:doc-see . unquote) (:doc-see . unquote-nsplicing))  +os-name+ ((:doc-group . sys)
(:doc-see . +os-version+))  assert ((:doc-example . "(def s \"abc\")\n(assert (= (length s) 3))\n; ↳ T\n(assert (eq? (str-rune s 0) #\\x))\n; ‼ assertion failed: ...")
(:doc-group . debug) (:doc-see . assert-fail))  vec->list ((:doc-example . "(vec->list #(1 2 a))\n; ↳ (1 2 a)")
(:doc-group . list) (:doc-see . list->vec))  1+ ((:doc-group . number) (:doc-see . 1-))  throw ((:doc-example . "(throw 'blah \"oops\")\n; ‼ *** unhandled exception: (thrown-value blah \"oops\")")
(:doc-example . "(trycatch (throw 'blah \"oops\") identity)\n; ↳ (thrown-value blah \"oops\")")
(:doc-group . error) (:doc-see . catch))  positive? ((:doc-group . number) (:doc-group . compare))  atan ((:doc-group . number))  *builtins* ((:doc-group . builtin))  remprop ((:doc-example . "(def x '(1 2 3))\n(putprop x 'words \"one two three\")\n; ↳ \"one two three\"\n(remprop x 'unknown) ; no such association\n; ↳ NIL\n(getprop x 'words NIL)\n; ↳ \"one two three\"\n(remprop x 'words)\n; ↳ T\n(getprop x 'words NIL)\n; ↳ NIL")
(:doc-group . prop) (:doc-see . getprop) (:doc-see . putprop))  io-copy-until ((:doc-group . io)
(:doc-see . io-copy))  process-input ((:doc-group . process)
(:doc-see . process-error) (:doc-see . process-output))  cdddar ((:doc-group . list))  set-cdr! ((:doc-example . "(def q '(1 2 3 4 5))\n(set-cdr! q '(6 7))\n; ↳ (1 6 7)\nq\n; ↳ (1 6 7)")
(:doc-group . list) (:doc-group . builtin))  stacktrace ((:doc-group . debug) (:doc-see . print-stack-trace))  eq? ((:doc-example . "(eq? 0.0 0)\n; ↳ NIL")
(:doc-example . "(eq? 0 0)\n; ↳ T") (:doc-example . "(def a \"1\")\n(def b \"1\")\n(eq? a b)\n; ↳ NIL")
(:doc-example . "(def a '(1))\n(def b '(1))\n(eq? a b)\n; ↳ NIL") (:doc-group . compare) (:doc-group . builtin))  *random-state* ((:doc-group . random)
(:doc-see . make-random-state) (:doc-see . random-state?))  io->str ((:doc-group . io))  bound? ((:doc-example . "(bound? 'bound?)\n; ↳ T")
(:doc-example . "(bound? 'doesnotcompute)\n; ↳ NIL") (:doc-group . builtin))  list->vec ((:doc-example . "(list->vec '(1 2 a))\n; ↳ #(1 2 a)")
(:doc-group . list) (:doc-see . vec->list))  def ((:doc-example . "; a function with documentation (first form)\n(def (f x)\n  «Return the square of doubled `x`.»\n  :doc-example\n  «(f 3)\n   ; ↳ 36»\n  :doc-group cool-funcs ; documentation group for (help groups)\n  :doc-see g ; reference another function in the documentation\n  (def (g y) ; an internal function\n    (+ y y))\n  (* (g x) (g x)))\n(f 2)\n; ↳ 16")
(:doc-example . "; a variable (second form)\n(def x (length \"hello\"))\nx\n; ↳ 5")
(:doc-group . syntax) (:doc-see . defdoc) (:doc-see . set!)
(:doc-see . let))  call-with-values ((:doc-example . "(call-with-values (λ () (values 1 2 3))\n                  (λ (a b c) b))\n; ↳ 2")
(:doc-example . "(call-with-values (λ () (list 1 2 3))\n                  (λ (lst) (cadr lst)))\n; ↳ 2")
(:doc-group . syntax) (:doc-see . receive) (:doc-see . values))  odd? ((:doc-group . number) (:doc-see . even?))  list? ((:doc-group . list)
(:doc-group . type) (:doc-see . list) (:doc-see . proper-list?))  str-rep ((:doc-example . "(str-rep \"oi\" 3)\n; ↳ \"oioioi\"")
(:doc-example . "(str-rep #\\ы 5)\n; ↳ \"ыыыыы\"")
(:doc-example . "(str-rep 'a 3)\n; ↳ \"aaa\"")
(:doc-example . "(str-rep 1 5)\n; ↳ \"11111\"")
(:doc-group . string))  process-alive? ((:doc-group . process)
(:doc-see . process-state) (:doc-see . process-core-dumped?))  time ((:doc-example . "(time (begin (sleep 0.1) 12345))\n; ‼ Elapsed time: 0.10013356 seconds\n; ↳ 12345")
(:doc-group . debug))  size-of ((:doc-example . "(size-of \"hello\")\n; ↳ 5")
(:doc-example . "(size-of (arr 'u32 1 2 3))\n; ↳ 12")
(:doc-example . "(def b (buffer))\n(io-write b \"hello\")\n(size-of b)\n; ↳ 5") (:doc-group . misc)
(:doc-see . type-of))  sym ((:doc-example . "(sym \"a\" 'b 1)\n; ↳ ab1")
(:doc-group . misc) (:doc-see . sym?))  tanh ((:doc-group . number))  for ((:doc-example . "(for 0 2 (λ (i) (print i)))\n; ‼ 01")
(:doc-group . syntax) (:doc-see . dotimes) (:doc-see . while))  begin ((:doc-example . "(if 1\n    (begin (print 1)\n           (newline)\n           'ignored\n           'done)\n    (print 0)\n    (newline)\n    'else)\n; ‼ 1\n; ↳ done")
(:doc-group . syntax) (:doc-see . prog1))  const? ((:doc-example . "(const? 12345) ; a number\n; ↳ T")
(:doc-example . "(const? 'const?) ; a function\n; ↳ NIL")
(:doc-example . "(const? 'pi) ; a mathematical constant\n; ↳ T") (:doc-group . type))  str-trim ((:doc-example . "(str-trim \" \\nhello\\t\\v\")\n; ↳ \"hello\"")
(:doc-example . "(str-trim \" \\nhello\\t\\v\"\n          (λ (r) (str-find \" \\v\" r)))\n; ↳ \"\\nhello\\t\"")
(:doc-example . "(str-trim \"123abc!456def\"\n          rune-numeric?\n          rune-alphabetic?)\n; ↳ \"abc!456\"")
(:doc-group . string) (:doc-see . str-sub) (:doc-see . str-map))  io-pos! ((:doc-example . "(def f (buffer))\n(io-write f \"hello, world!\")\n(io-pos! f 64)\n; ↳ 13\n(io-pos! f 7)\n; ↳ 7\n(read f)\n; ↳ world!")
(:doc-group . io) (:doc-see . io-pos)
(:doc-see . io-skip))  return ((:doc-example . "(def (f x) (when (not x)\n             (return 0))\n           (princ \"hi\")\n           (newline)\n           1)\n(f 'a)\n; ‼ hi\n; ↳ 1\n(f NIL)\n; ↳ 0")
(:doc-group . syntax))  *stderr* ((:doc-group . io) (:doc-see . *stdout*) (:doc-see . *stdin*))  tan ((:doc-group . number))  table ((:doc-example . "(table)\n; ↳ #table()")
(:doc-example . "(table 'a 1 'b 2)\n; ↳ #table(a 1 b 2)") (:doc-group . table) (:doc-see . get)
(:doc-see . put!))  __rcscript ((:doc-group . vm) (:doc-see . *prompt*) (:doc-see . *interactive*))  process-error ((:doc-group . process)
(:doc-see . process-input) (:doc-see . process-output))  doc-group ((:doc-group . doc))  cdaaar ((:doc-group . list))  bounds-error ((:doc-example . "(bounds-error '(1) 1 \"oops\")\n; ‼ out of bounds: oops: index 1 for (1)")
(:doc-example . "(trycatch (bounds-error NIL 0 \"oops\") identity)\n; ↳ (bounds-error NIL 0 \"oops\")")
(:doc-group . error))  even? ((:doc-group . number) (:doc-see . odd?))  *properties* ((:doc-group . prop))  zero? ((:doc-group . number)
(:doc-group . compare))  proper-list? ((:doc-example . "(proper-list? NIL) ; empty list\n; ↳ T")
(:doc-example . "(proper-list? '(1)) ; a list with one element\n; ↳ T")
(:doc-example . "(proper-list? '(1 . 2)) ; a pair, cdr of the cell is 2\n; ↳ NIL")
(:doc-example . "(proper-list? '#0=(1 . #0#)) ; on a circular list\n; ↳ NIL")
(:doc-group . list) (:doc-group . type) (:doc-see . list?))  io-filename! ((:doc-example . "(def f (buffer))\n(io-filename b)\n; ↳ \"\"\n(io-filename! b \"new name\") ; change the filename\n; ↳ \"new name\"\n(io-filename b)\n; ↳ \"new name\"")
(:doc-group . io) (:doc-see . io-filename))  random ((:doc-example . "(random 1)\n; ↳ 1") (:doc-example . "(random 10000000000000000000000000000000000)\n; ↳ 5312781302474765749507273681609477")
(:doc-example . "(random 1.0)\n; ↳ 0.69517") (:doc-group . random) (:doc-see . make-random-state))  *directory-separator* ((:doc-group . sys)
(:doc-see . *linefeed*))  reverse! ((:doc-example . "(def a '(1 2 3))\n(reverse! a)\n; ↳ (3 2 1)\na\n; ↳ (1) ; original list modified")
(:doc-group . list) (:doc-see . reverse))  eval ((:doc-example . "(eval '(begin (set! x 1 y 2) (+ x y)))\n; ↳ 3\nx\n; ↳ 1\ny\n; ↳ 2")
(:doc-group . vm)
(:doc-see . load))  cdaadr ((:doc-group . list))  u32 ((:doc-group . number)
(:doc-see . s32))  cons ((:doc-example . "(cons 1 2)\n; ↳ (1 . 2)")
(:doc-example . "(cons 1 '(2))\n; ↳ (1 2)")
(:doc-example . "(cons 1 (cons 2 (cons 3 NIL)))\n; ↳ (1 2 3)") (:doc-group . list)
(:doc-see . cons?) (:doc-see . list) (:doc-group . builtin))  filter ((:doc-example . "(filter odd? '(0 1 2 3 4))\n; ↳ (1 3)")
(:doc-group . list) (:doc-see . partition))  do ((:doc-example . "(do ((x 0 (+ x 1))) ; x=0 at first, x=x+1 after each step\n  ((> (sin x) 0.95) ; loop until sin(x) > 0.95\n   (newline)        ; print a linefeed when loop terminates\n   x)               ; return final value of x\n  (princ x))        ; print x on each step\n; ‼ 01234567\n; ↳ 8")
(:doc-group . syntax) (:doc-see . for) (:doc-see . while))  make-random-state ((:doc-group . random)
(:doc-see . *random-state*) (:doc-see . random-state?) (:doc-see . random))  path-make-dir ((:doc-group . io)
(:doc-see . *io-default-dir-mode*))  io-buffer-mode! ((:doc-group . io) (:doc-see . io-buffer-mode))  let ((:doc-example . "(let ((a 123) (b 456) c)   ; first form\n  (cons (+ a b) (void? c)))\n; ↳ (579 . T)")
(:doc-example . "(let loop ((a (iota 3 1))) ; second form\n  (when a\n    (princ (car a))\n    (loop (cdr a))))\n; ‼ 123\n; ↳ NIL")
(:doc-group . syntax) (:doc-see . let*) (:doc-see . letrec))  process-core-dumped? ((:doc-group . process)
(:doc-see . process-alive?))  assq ((:doc-group . list)
(:doc-see . assoc) (:doc-see . assv))  del! ((:doc-example . "(def t #table(a 1 b 2))\n(del! t 'c)\n; ↳ #table(b 2  a 1)\n(del! t 'b)\n; ↳ #table(a 1)\nt\n; ↳ #table(a 1)")
(:doc-group . table) (:doc-see . has?) (:doc-see . get)
(:doc-see . put!))  when ((:doc-example . "(when (eq? cmd 'exit)\n(princ \"exiting!\")\n(newline)\n(exit))")
(:doc-group . syntax) (:doc-see . unless)
(:doc-see . if))  vec? ((:doc-group . type)
(:doc-group . builtin))  min ((:doc-example . "(min 3 1 9 4)\n; ↳ 1") (:doc-example . "(min 'c 'h 'z 'a)\n; ↳ a")
(:doc-example . "(min \"t\" \"g\" \"a\")\n; ↳ \"a\"")
(:doc-group . compare) (:doc-see . max))  cddaar ((:doc-group . list))  io? ((:doc-group . io)
(:doc-group . type))  help ((:doc-example . "(help str?)       ; show documentation for str?\n(help groups)     ; show documentation groups\n(help type group) ; list items for dealing with types\n(help group type) ; same as above\n(help str->*)     ; find functions converting from strings\n(help *->str)     ; find functions converting to strings\n(help *num*)      ; find anything related to numbers")
(:doc-group . doc))  rune-titlecase ((:doc-example . "(rune-titlecase #\\й)\n; ↳ #\\Й")
(:doc-example . "(rune-titlecase #\\dž)\n; ↳ #\\Dž")
(:doc-group . string) (:doc-see . rune-title-case?)
(:doc-see . rune-downcase) (:doc-see . rune-upcase))  unquote-nsplicing ((:doc-example . "(def x '(1 2 3))\n`(0 1 ,.(map 1+ x))\n; ↳ (0 1 2 3 4)")
(:doc-group . syntax) (:doc-see . unquote) (:doc-see . unquote-splicing))  num->str ((:doc-example . "(num->str 65535 :base 16)\n; ↳ \"FFFF")
(:doc-example . "(num->str (s8 -7))\n; ↳ \"-7\"")
(:doc-group . string))  mod ((:doc-example . "(mod  10 3)\n; ↳ 1")
(:doc-example . "(mod -10 3)\n; ↳ 2") (:doc-example . "(mod -10 -3)\n; ↳ 2") (:doc-example . "(mod  10 -3)\n; ↳ 1")
(:doc-group . number) (:doc-see . div) (:doc-see . mod0))  if ((:doc-example . "(def x '(1))\n(if x (begin (print \"yep!\") (newline) 'yes) 0)\n; ‼ yep!\n; ↳ yes\n(if (str? x) 1 (print \"nope!\") (newline) 'no)\n; ‼ nope!\n; ↳ no")
(:doc-group . syntax) (:doc-see . when)
(:doc-see . unless))  str-pad ((:doc-example . "(str-pad \"abc\" 7)\n↳ \"abc    \"")
(:doc-example . "(str-pad \"abc\" 7 :align :center :fill #\\.)\n↳ \"..abc..\"") (:doc-group . string))  p32 ((:doc-group . number)
(:doc-see . p64) (:doc-see . ptr))  case ((:doc-example . "(case 'c ; match present\n  (a 0)\n  ((b c d) 1))\n; ↳ b")
(:doc-example . "(case (+ 1 2) ; no matches, with else\n  (a 0)\n  (b 1)\n  (else (print 'yay)\n        (newline))\n; ‼ yay")
(:doc-example . "(case \"c\" ; no matches, without else\n  (\"a\" 0)\n  (\"b\" 1))\n; ↳ NIL")
(:doc-group . syntax) (:doc-see . cond))  io-read-lines ((:doc-example . "; read current process' segments on Plan 9\n(def seg (file (str \"/proc/\" (getpid) \"/segment\")))\n(io-read-lines seg)\n; ↳ (\"Stack     1feff0000 1ffff0000    1\\n\"\n     \"Text   R     10000    70000    1\\n\"\n     \"Data         70000    d0000    1\\n\"\n     \"Bss          d0000   1a0000    1\\n\"\n     \"Bss       1fcff0000 1feff0000    1\\n\"\n     \"Bss       1faff0000 1fcff0000    1\\n\")")
(:doc-group . io) (:doc-see . io-read-line) (:doc-see . io-read-all))  cc-add-file ((:doc-group . cc)
(:doc-see . cc-compile))  io-line ((:doc-group . io)
(:doc-see . io-column) (:doc-see . io-line!))  zip-with ((:doc-example . "(zip-with + '(1 2 3))\n; ↳ (1 2 3)")
(:doc-example . "(zip-with + '(1 2 3 4) '(5 6 7) '(8 9 10 11))\n; ↳ (14 17 20)")
(:doc-group . list) (:doc-see . zip))  trycatch ((:doc-example . "(trycatch (+ 1 2) (λ (e) e))\n; ↳ 3")
(:doc-example . "(trycatch (+ 1 NIL) (λ (e) e))\n; ↳ (type-error num NIL)") (:doc-group . syntax)
(:doc-see . catch) (:doc-see . unwind-protect))  macrocall? ((:doc-example . "(macrocall? '(car NIL))\n; ↳ NIL")
(:doc-example . "(macrocall? '(let ((x 1)) 2))\n; ↳ #fn(...)")
(:doc-group . syntax) (:doc-see . macroexpand-1)
(:doc-see . macroexpand))  cc-set-options ((:doc-group . cc))  iterate ((:doc-example . "(iterate 1+ 5 3)\n; ↳ (5 6 7)")
(:doc-example . "(iterate (λ (x) (* x x)) 2 5)\n; ↳ (2 4 16 256 65536)")
(:doc-example . "(iterate (λ (s) (str-sub s 1)) \"hello\" 5)\n; ↳ (\"hello\" \"ello\" \"llo\" \"lo\" \"o\")")
(:doc-group . list))  *syntax-environment* ((:doc-group . syntax) (:doc-see . get-syntax) (:doc-see . set-syntax!))  builtin ((:doc-example . "(builtin 'map)\n; ↳ #fn(map)")
(:doc-example . "(builtin 'print)\n; ‼ arguments error: builtin \"print\" not found") (:doc-group . vm))  table-values ((:doc-example . "def t #table(a 1 b 2 c 1))\n(table-values t)\n; ↳ (1 2 1)")
(:doc-group . table) (:doc-see . table-keys))  macroexpand ((:doc-example . "(let ((a 3) (b 4) (c 5))\n  (macroexpand `(let* {[x ,a] [y ,b]} (+ x y ,c))))\n; ↳ ((λ (x)\n       ((λ (y)\n          (+ x y 5))\n        4))\n     3)")
(:doc-group . syntax) (:doc-see . macroexpand-1))  caadr ((:doc-group . list))  type-of ((:doc-example . "(type-of 1)\n; ↳ fixnum")
(:doc-example . "(type-of NIL)\n; ↳ null") (:doc-example . "(type-of T)\n; ↳ bool")
(:doc-example . "(type-of \"hello\")\n; ↳ str") (:doc-example . "(type-of (arr 'u32 0 1 2))\n; ↳ (arr u32)")
(:doc-group . type) (:doc-see . size-of))  top-level-value ((:doc-example . "(def abc 1)\n(let {[abc 2]}\n  (cons abc (top-level-value 'abc)))\n; ↳ (2 . 1)\nabc\n; ↳ 1")
(:doc-group . misc) (:doc-see . set-top-level-value!))  defstruct ((:doc-group . struct))  caadar ((:doc-group . list))  foldl1 ((:doc-example . "(foldl1 * (iota 6 1))\n; ↳ 720")
(:doc-group . list) (:doc-see . foldl) (:doc-see . foldr1))  buffer ((:doc-example . "(def b (buffer))\n(io-write b #vu8(#x68 #x65 #x6c #x6c #x6f))\n; ↳ 5\n(io->str b)\n; ↳ \"hello\"")
(:doc-example . "(def b (buffer (arr 'f32 1.0 2.0 3.0 -4.0)))\n(io-pos! b 8)\n(io-read b 'p32 2)\n; ↳ #arr(p32 #x40400000 #xC0800000)")
(:doc-group . io) (:doc-see . io->str))  find-program ((:doc-example . "(find-program \"ls\")\n; ↳ \"/usr/bin/ls\"")
(:doc-group . io) (:doc-see . make-process))  random-state? ((:doc-example . "(random-state? 1)\n; ↳ NIL")
(:doc-example . "(random-state? (make-random-state))\n; ↳ T")
(:doc-example . "(random-state? *random-state*)\n; ↳ T")
(:doc-group . random) (:doc-see . *random-state*)
(:doc-see . make-random-state))  assoc-list ((:doc-example . "(assoc-list 'a 0 'b 1)\n; ↳ ((a . 0) (b . 1))")
(:doc-group . list) (:doc-see . assoc))  process-close ((:doc-group . process) (:doc-see . process-post))  builtin? ((:doc-example . "(builtin? map)\n; ↳ T")
(:doc-example . "(builtin? macroexpand)\n; ↳ NIL") (:doc-group . type) (:doc-see . builtin) (:doc-see . fn?)
(:doc-see . closure?) (:doc-group . builtin))  with-input ((:doc-example . "(with-input (s «x\"blah\"x» :start 1 :end 7)\n  (read s))\n; ↳ \"blah\"")
(:doc-group . io) (:doc-see . with-output-to)
(:doc-see . buffer))  str-map ((:doc-example . "(str-map rune-upcase\n         \"hello, world!\")\n; ↳ \"HELLO, WORLD!\"")
(:doc-example . "(str-map (λ (r) (str r r))\n         \"hello\")\n; ↳ \"hheelllloo\"")
(:doc-example . "(str-map (λ (r) (and (not (rune-whitespace? r)) r))\n         \"! this is great !\")\n; ↳ \"!thisisgreat!\"")
(:doc-group . string))  macroexpand-1 ((:doc-example . "(let ((a 3) (b 4) (c 5))\n  (macroexpand-1 `(let* {[x ,a] [y ,b]} (+ x y ,c))))\n; ↳ ((λ (x) ; note how the inner let* expression isn't expanded\n       (let* ((y 4)) (+ x y 5)))\n     3)")
(:doc-group . syntax) (:doc-see . macroexpand))  +endianness+ ((:doc-group . sys))  remove-duplicates ((:doc-example . "(remove-duplicates '(a 0 b c1 a b 3 c 5))\n; ↳ (a 0 b c1 3 c 5)")
(:doc-group . list))  fn-vals ((:doc-group . misc))  str ((:doc-example . "(str \"a\" 'b 1 #(0))\n; ↳ \"ab1#(0)\"")
(:doc-group . string))  with-exception-bindings ((:doc-group . error)
(:doc-see . *exception-print-level*) (:doc-see . *exception-print-length*))  negative? ((:doc-group . number)
(:doc-group . compare))  void ((:doc-group . misc) (:doc-see . void?))  io-read-line ((:doc-example . "; read one line from the kernel messages file\n(io-read-line (file \"/dev/kmesg\"))\n; ↳ \"127 holes free\\n\"")
(:doc-example . "; /dev/null has no data - EOF is returned\n(eof? (io-read-line (file \"/dev/null\")))\n; ↳ T")
(:doc-group . io)
(:doc-see . eof?)
(:doc-see . io-read-lines))  assert-fail ((:doc-example . "(def s \"abc\")\n(assert-fail (= (length s) 3))\n; ‼ assertion failed: ...\n(assert-fail (= s 1) type-error)\n; ↳ T")
(:doc-group . debug) (:doc-see . assert))  and ((:doc-example . "(and)\n; ↳ T") (:doc-example . "(and 1 2 (print 'yes) 3)\n; ‼ yes\n; ↳ 3")
(:doc-example . "(and 1 NIL (print 'yes) 3)\n; ↳ NIL")
(:doc-group . syntax)
(:doc-see . or)
(:doc-see . not))  1- ((:doc-group . number)
(:doc-see . 1+))  io-buffer-mode ((:doc-group . io) (:doc-see . io-buffer-mode!))  that ((:doc-example . "(map rune-upcase \"hello, world!\")\n; ↳ \"HELLO, WORLD!\"\n(str-sub that 0 5)\n; ↳ \"HELLO\"\n(map rune-downcase that)\n; ↳ \"hello\"")
(:doc-group . vm) (:doc-see . repl))  equal? ((:doc-example . "(equal? 0.0 0)\n; ↳ NIL")
(:doc-example . "(equal? 0 0)\n; ↳ T")
(:doc-example . "(def a \"1\")\n(def b \"1\")\n(equal? a b)\n; ↳ T")
(:doc-example . "(def a '(1))\n(def b '(1))\n(equal? a b)\n; ↳ T")
(:doc-group . compare) (:doc-group . builtin))  unquote ((:doc-example . "`(0 1 ,(+ 2 3))\n; ↳ (0 1 5)")
(:doc-group . syntax) (:doc-see . quasiquote))  cddar ((:doc-group . list))  *interactive* ((:doc-group . vm)
(:doc-see . *prompt*))  or ((:doc-example . "(or)\n; ↳ NIL") (:doc-example . "(or 1 2 (print 'first) (print 'second) 3)\n; ↳ 1")
(:doc-example . "(or NIL NIL (print 'first) (print 'second) 3)\n; ‼ first")
(:doc-group . syntax) (:doc-see . and)
(:doc-see . not))  rune-lower-case? ((:doc-example . "(rune-lower-case? #\\dž)\n; ↳ T")
(:doc-example . "(rune-lower-case? #\\Dž)\n; ↳ NIL") (:doc-group . string) (:doc-see . rune-downcase)
(:doc-see . rune-upper-case?) (:doc-see . rune-title-case?))  make-process ((:doc-example . "; run ls on /home and make its output available for reading\n; redirect any error output to be visible alongside the REPL\n(def p (make-process \"/bin/ls\" '(\"ls\" \"/home\") :out :io :err T))\n; ↳ #<process>\n(def s (io-read-all (process-output p))) ; read the output as a string")
(:doc-group . process)
(:doc-see . find-program)
(:doc-see . process-close)
(:doc-see . process-output)
(:doc-see . process?))  = ((:doc-group . number)
(:doc-group . compare) (:doc-group . builtin))  fn? ((:doc-example . "(fn? (void))\n; ↳ NIL") (:doc-example . "(fn? map)\n; ↳ T")
(:doc-example . "(fn? macroexpand)\n; ↳ T") (:doc-group . type) (:doc-see . fn) (:doc-see . builtin?)
(:doc-see . closure?) (:doc-group . builtin))  caaadr ((:doc-group . list))  make-system-image ((:doc-group . vm))  subseq ((:doc-example . "(subseq \"hello\" 1 2)\n; ↳ \"e\"")
(:doc-example . "(subseq '(1 2 3) 0 2)\n; ↳ (1 2)")
(:doc-example . "(subseq #(a b c) 2)\n; ↳ #(c)") (:doc-group . list) (:doc-see . str-sub) (:doc-see . copy-list)
(:doc-see . nthcdr))  set! ((:doc-example . "(def a NIL)\n(def b NIL)\n(def c NIL)\n(set! a 1 b 2 c (+ a b))\n; ↳ 3\na\n; ↳ 1\nb\n; ↳ 2\nc\n; ↳ 3")
(:doc-group . syntax) (:doc-see . set-top-level-value!) (:doc-see . let))  vm-stats ((:doc-group . vm))  ptr ((:doc-group . number)
(:doc-see . p32) (:doc-see . p64) (:doc-see . ptr?))  caddar ((:doc-group . list))  print-stack-trace ((:doc-group . error)
(:doc-see . stacktrace))  *stdin* ((:doc-group . io) (:doc-see . *stdout*) (:doc-see . *stderr*))  cosh ((:doc-group . number))  values ((:doc-group . syntax)
(:doc-see . call-with-values) (:doc-see . receive))  < ((:doc-group . compare) (:doc-group . builtin))  copy-tree ((:doc-example . "(def a '(1 (2 3)))\n(def b (copy-tree a))\n(equal? a b)\n; ↳ T\n(eq? a b)\n; ↳ NIL\n(equal? (cadr a) (cadr b))\n; ↳ T\n(eq? (cadr a) (cadr b))\n; ↳ NIL")
(:doc-group . list) (:doc-see . copy-list))  f32 ((:doc-group . number) (:doc-see . f64))  sin ((:doc-group . number))  io-copy ((:doc-group . io)
(:doc-see . io-copy-until))  > ((:doc-group . compare))  str-rune ((:doc-example . "(str-rune \"йцукен\" 3)\n; ↳ #\\к")
(:doc-group . string) (:doc-see . str-sub))  foldl ((:doc-example . "(foldl cons NIL (iota 5))\n; ↳ (4 3 2 1 0)")
(:doc-example . "(foldl + 0 (iota 5))\n; ↳ 10") (:doc-example . "(foldl (λ (x y a) (+ (* x y) a)) 0 (iota 5) (iota 5))\n; ↳ 30")
(:doc-example . "(foldl (λ (x y a) (cons x (cons y a))) NIL (iota 5) (vec 'a 'b 'c))\n; ↳ (2 c 1 b 0 a)")
(:doc-group . list) (:doc-see . foldr) (:doc-see . foldl1))  +os-version+ ((:doc-example . "; on Alpine Linux\n+os-version+\n; ↳ \"6.14.5-0-edge\" ; kernel version")
(:doc-example . "; on 9front\n+os-version+\n; ↳ NIL ; 9front does not define one")
(:doc-group . sys) (:doc-see . +os-name+))  abs ((:doc-group . number))  with-output-to ((:doc-example . "; write a string \"hello, world!\" and a newline to a file\n(with-output-to (file \"/tmp/1.txt\" :create :truncate :write)\n  (print \"hello, world!\")\n  (newline))")
(:doc-group . io) (:doc-see . with-input-from) (:doc-see . with-output))  *linefeed* ((:doc-group . sys)
(:doc-see . newline)
(:doc-see . *directory-separator*))  str? ((:doc-group . type)
(:doc-see . str) (:doc-see . str-utf8?))  cons? ((:doc-example . "(cons? 0)\n; ↳ NIL") (:doc-example . "(cons? NIL)\n; ↳ NIL")
(:doc-example . "(cons? '(1))\n; ↳ T") (:doc-group . type) (:doc-see . cons) (:doc-see . list?)
(:doc-group . builtin))  io-read ((:doc-example . "(io-read f 'utf8 5)\n; ↳ \"hello\"")
(:doc-example . "(io-read f 'u32)\n; ↳ 57")
(:doc-example . "(io-read f 'u32 3)\n; ↳ #arr(u32 0 1 2)")
(:doc-example . "(io-read f 'rune 6)\n; ↳ #arr(rune #\\λ #\\a #\\m #\\b #\\d #\\a)")
(:doc-group . io) (:doc-see . io-write) (:doc-see . io-read-until))  str-split ((:doc-example . "(str-split \"hello world\")\n; ↳ (\"hello\" \"world\")")
(:doc-example . "(str-split \"multiple   spaces \")\n; ↳ (\"multiple\" \"\" \"\" \"spaces\" \"\")")
(:doc-example . "(str-split \"multiple   spaces \" :trim T)\n; ↳ (\"multiple\" \"spaces\")")
(:doc-example . "(str-split \"too many vowels\" \"aeiou\")\n; ↳ (\"t\" \"\" \" m\" \"ny v\" \"w\" \"ls\")")
(:doc-group . string))  truncate ((:doc-example . "(truncate -123.45)\n; ↳ -123")
(:doc-example . "(truncate  299.9)\n; ↳ 299") (:doc-group . number))  make-cc ((:doc-group . cc))  aset! ((:doc-example . "(def a '((1 #(2 (3)) 4)))\n(aset! a 1 'x)\n; ‼ index 1 out of bounds\n(aset! a 0 0 'x)\n; ↳ x\na\n; ↳ ((x #(2 (3)) 4))\n(aset! a 0 1 9)\n; ↳ 9\na\n; ↳ ((x #(9 (3)) 4))")
(:doc-group . array) (:doc-see . aref) (:doc-group . builtin))  - ((:doc-example . "(- 1.5)\n; ↳ -1.5")
(:doc-example . "(- 3 2)\n; ↳ 1")
(:doc-group . number) (:doc-group . builtin))  io-truncate ((:doc-group . io))  makunbound ((:doc-example . "(def x 1)\n(bound? 'x)\n; ↳ T\nx\n; ↳ 1\n(makunbound 'x)\n(bound? 'x)\n; ↳ NIL\nx\n; ‼ eval: variable x has no value")
(:doc-group . misc) (:doc-see . bound?))  quasiquote ((:doc-example . "`(0 1 (+ 2 3))\n; ↳ (0 1 (+ 2 3))")
(:doc-group . syntax) (:doc-see . quote) (:doc-see . unquote))  io-column! ((:doc-group . io)
(:doc-see . io-column) (:doc-see . io-line!))  copy-list ((:doc-example . "(def a '(1 2 3 4))\n(def b (copy-list a))\nb\n; ↳ (1 2 3 4)\n(eq? a b)\n; ↳ NIL\n(equal? a b)\n; ↳ T\n(copy-list a 3)\n; ↳ (1 2 3)\n(copy-list a 10)\n; ↳ (1 2 3 4)")
(:doc-group . list) (:doc-see . copy-tree)
(:doc-see . nthcdr) (:doc-see . subseq))  logand ((:doc-example . "(logand)\n; ↳ 0")
(:doc-example . "(logand 2)\n; ↳ 2") (:doc-example . "(logand 2 3)\n; ↳ 2") (:doc-example . "(logand 2 3 4)\n; ↳ 0")
(:doc-group . number))  time-now ((:doc-example . "(time-now)\n; ↳ 1746494461277334928")
(:doc-group . time) (:doc-see . nanoseconds-monotonic))  sinh ((:doc-group . number))  *argv* ((:doc-example . "; $ sl -i -H 12345\n*argv*\n; ↳ (\"sl\")")
(:doc-example . "; $ sl script.sl -i abc\n*argv*\n; ↳ (\"script.sl\" \"-i\" \"abc\")") (:doc-group . vm)
(:doc-see . *interactive*))  top-level-exception-handler ((:doc-group . error))  identity ((:doc-group . misc))  untrace ((:doc-example . "(trace 'map)\n(map odd? (list (+ 1 2) (+ 3 4)))\n; ‼ (map #fn(\"n170051S:\" #(even?) odd? 6) (3 7))\n; ↳ (T T)\n(untrace 'map)\n(map odd? (list (+ 1 2) (+ 3 4)))\n; ↳ (T T)")
(:doc-group . debug) (:doc-see . trace) (:doc-see . traced?))  count ((:doc-example . "(count (λ (s) (length> s 1))\n       '(\"ab\" \"c\" \"d\" \"ef\"))\n; ↳ 2")
(:doc-group . list))  io-pos ((:doc-example . "(def f (buffer))\n(io-write f \"hello, world!\")\n(io-pos f)\n; ↳ 13")
(:doc-group . io) (:doc-see . io-pos!))  +most-positive-fixnum+ ((:doc-group . number) (:doc-see . +most-negative-fixnum+))  map-int ((:doc-example . "(map-int even? 5)\n; ↳ (T NIL T NIL T)")
(:doc-example . "(map-int (λ (i) (str i i i)) 4)\n; ↳ (\"000\" \"111\" \"222\" \"333\")") (:doc-group . list)
(:doc-see . iota))  table->assoc-list ((:doc-example . "(def t #table(a 1 b 2 c 1))\n(table->assoc-list t)\n; ↳ ((a . 1) (b . 2) (c . 1))")
(:doc-group . table) (:doc-see . table-keys) (:doc-see . table-values))  length< ((:doc-group . list)
(:doc-see . length=) (:doc-see . length>))  cc-define ((:doc-group . cc) (:doc-see . cc-undefine))  unless ((:doc-example . "(unless (cons? x)\n(princ \"oops!\")\n(newline)\n(type-error 'cons x))")
(:doc-group . syntax) (:doc-see . when) (:doc-see . if))  str->time ((:doc-example . "(str->time \"Tue May  6 03:21:01 CES 2025\")\n; ↳ 1746494461")
(:doc-group . time) (:doc-see . time->str)
(:doc-see . time-now))  get-syntax ((:doc-group . syntax)
(:doc-see . set-syntax!))  ptr? ((:doc-group . type) (:doc-group . number) (:doc-see . ptr))  expt ((:doc-example . "(expt 3 3) ; cube of 3\n; ↳ 27")
(:doc-example . "(expt 27 (/ 1 3)) ; cube root of 27\n; ↳ 3") (:doc-group . number))  io-read-all ((:doc-example . "; read current user on Plan 9\n(io-read-all (file \"/dev/user\"))\n; ↳ \"glenda\"")
(:doc-group . io) (:doc-see . read-all) (:doc-see . io-read-lines))  gc ((:doc-group . vm) (:doc-see . vm-stats))  io-write ((:doc-example . "(io-write *stdout* \"hello\")\n; ‼ hello\n; ↳ 5")
(:doc-example . "(io-write *stdout* (u32 #x44434241) :little-endian)\n; ‼ ABCD\n; ↳ 4")
(:doc-example . "(io-write *stdout* #\\λ)\n; ‼ λ\n; ↳ 2")
(:doc-example . "(io-write *stdout* (arr 'rune #\\λ #\\= #\\l #\\a #\\m #\\b #\\d #\\a))\n; ‼ λ=lambda\n; ↳ 9")
(:doc-group . io) (:doc-see . io-read))  table-invert ((:doc-example . "(def t #table(a 1 b 2 c 1))\n(table-invert t)\n; ↳ #table(1 a  2 b)")
(:doc-group . table) (:doc-see . table-values))  lz-unpack ((:doc-group . compress))  rune-whitespace? ((:doc-example . "(rune-whitespace? #\\newline)\n; ↳ T")
(:doc-example . "(rune-whitespace? #\\_)\n; ↳ NIL") (:doc-group . string) (:doc-see . rune-alphabetic?)
(:doc-see . rune-numeric?))  div ((:doc-example . "(div 10 3)\n; ↳ 3") (:doc-example . "(div -10 3)\n; ↳ -4")
(:doc-example . "(div -10 -3)\n; ↳ 4")
(:doc-example . "(div 10 -3)\n; ↳ -3")
(:doc-group . number) (:doc-see . mod)
(:doc-see . div0))  princ ((:doc-example . "(princ 1 2 \"abc\")\n; ‼ 12abc")
(:doc-group . io) (:doc-see . print))  last-cdr ((:doc-example . "(last-cdr '(1 2 3))\n; ↳ NIL")
(:doc-example . "(last-cdr '(1 2 . 3))\n; ↳ 3")
(:doc-group . list) (:doc-see . last-pair))  trace ((:doc-example . "(trace 'map)\n(map odd? (list (+ 1 2) (+ 3 4)))\n; ‼ (map #fn(\"n170051S:\" #(even?) odd? 6) (3 7))\n; ↳ (T T)")
(:doc-group . debug) (:doc-see . untrace) (:doc-see . traced?))  io-filename ((:doc-example . "(def f (file \"/dev/random\"))\n(io-filename f)\n; ↳ \"/dev/random\"\n(io-close f)\n(io-filename f) ; preserved even after it's closed\n; ↳ \"/dev/random\"")
(:doc-example . "(io-filename *io-out*)\n; ↳ \"*stdout*\"")
(:doc-group . io)
(:doc-see . io-filename!))  fn-name ((:doc-group . misc))  let* ((:doc-example . "(let* ((a 1)\n       (b (+ a 1))\n       (c (+ b 1))\n       d)\n  (cons c (void? d)))\n; ↳ (3 . T)")
(:doc-group . syntax) (:doc-see . let) (:doc-see . letrec))  rune->codepoint ((:doc-example . "(rune->codepoint #\\й)\n; ↳ 1081")
(:doc-group . string))  gensym? ((:doc-group . type)
(:doc-see . sym?) (:doc-see . sym))  defdoc ((:doc-example . "(defdoc (func arg (arg2 0))\n  «Return something about the `arg` and `arg2`.  This is a short\n   description.\n\n   This is the longer description, following the short one.»\n  :doc-example\n  «(func 0)\n   ; ↳ T»\n  :doc-example\n  «(func 1 3)\n   ; ↳ NIL»\n  :doc-group stuff\n  :doc-see func2\n  :doc-fmt (λ (doc) doc)\n(defdoc (func arg (:another-variant NIL)))")
(:doc-group . doc))  cdddr ((:doc-group . list))  copy-table ((:doc-example . "(def t #table(a (1 2 3)))\n(def q (copy-table t))\n(eq? t q)\n; ↳ NIL\n(eq? (get t 'a) (get q 'a))\n; ↳ T")
(:doc-group . table) (:doc-see . table->assoc-list))  set-car! ((:doc-example . "(def q '(1 2 3 4 5))\n(set-car! q 0)\n; ↳ (0 6 7)\nq\n; ↳ (0 6 7)")
(:doc-group . list) (:doc-group . builtin))  receive ((:doc-example . "(receive (a b c) (values 1 2 3) b)\n; ↳ 2")
(:doc-example . "(receive (odd even) (partition odd? '(0 1 2 3 4 5))\n  (map cons odd even))\n; ↳ ((1 . 0) (3 . 2) (5 . 4))")
(:doc-example . "(receive (lst) '(1 2 3) (cadr lst))\n; ↳ 2") (:doc-group . syntax) (:doc-see . values)
(:doc-see . call-with-values))  partition ((:doc-example . "; split the list into numbers and non-numbers\n(def q '(1a 1 0 2b e 3))\n(receive (nums other) (partition num? q)\n  (print nums other)\n  (newline))\n; ↳ (1 0 3) (1a 2b e)")
(:doc-group . list) (:doc-see . filter) (:doc-see . receive))  dotimes ((:doc-example . "(dotimes (x 3 \"heh\")\n  (print x)\n  (newline))\n; ‼ 0\n; ‼ 1\n; ‼ 2\n; ↳ \"heh\"")
(:doc-group . syntax) (:doc-see . for) (:doc-see . while))  has? ((:doc-example . "(def t #table(a 1 b 2))\n(has? t 'c)\n; ↳ NIL\n(has? t 'a)\n; ↳ T")
(:doc-group . table) (:doc-see . get)
(:doc-see . put!) (:doc-see . del!))  vec ((:doc-example . "(vec) ; empty vector\n; ↳ #()")
(:doc-example . "(vec 1 2.5 \"a\" 'b)\n; ↳ #(1 2.5 \"a\" b)") (:doc-group . array) (:doc-see . vec-alloc)
(:doc-see . arr) (:doc-group . builtin))  while ((:doc-example . "(def x 3)\n(while (> x 0)\n  (princ #\\x)\n  (set! x (1- x)))\n; ‼ xxx")
(:doc-group . syntax) (:doc-see . for))  rune ((:doc-group . string)
(:doc-see . rune?))  *exit-hooks* ((:doc-group . vm) (:doc-see . add-exit-hook))  cadar ((:doc-group . list))  type-error ((:doc-example . "(type-error 'num \"hello\")\n; ‼ type error: expected num, got str: \"hello\"")
(:doc-example . "(type-error 'num \"hello\" \"more\" \"text\")\n; ‼ type error: more: text: expected num, got str: \"hello\"")
(:doc-example . "(trycatch (type-error 'num \"hello\" \"extra\") identity)\n; ↳ (type-error num \"hello\" \"extra\")")
(:doc-group . error))  file ((:doc-group . io) (:doc-see . *io-default-file-mode*))  nth ((:doc-example . "(def l '(a b c))\n(nth l 0)\n; ↳ a\n(nth l 2)\n; ↳ c\n(nth l 10)\n; ↳ NIL")
(:doc-group . list) (:doc-see . nthcdr))  cdr ((:doc-example . "(cdr NIL)\n; ↳ NIL") (:doc-example . "(cdr '(1 2 3))\n; ↳ (2 3)")
(:doc-example . "(cdr '(1 . 2))\n; ↳ 2")
(:doc-group . list)
(:doc-group . builtin))  / ((:doc-example . "(/ 2)\n; ↳ 0.5")
(:doc-example . "(/ 7 2 2)\n; ↳ 1.75") (:doc-example . "(/ 10 0)\n; ↳ +inf.0")
(:doc-example . "(/ 6.9 1.9)\n; ↳ 3.6315…") (:doc-group . number) (:doc-see . div0) (:doc-see . div)
(:doc-group . builtin))  process-output ((:doc-group . process) (:doc-see . process-input) (:doc-see . process-error))  newline ((:doc-group . io)
(:doc-see . *linefeed*))  separate-doc-from-body ((:doc-group . doc))  cdadar ((:doc-group . list))  cc-undefine ((:doc-group . cc)
(:doc-see . cc-define))  sqrt ((:doc-example . "(sqrt 9.0)\n; ↳ 3.0") (:doc-group . number))  foldr ((:doc-example . "(foldr cons NIL (iota 5))\n; ↳ (0 1 2 3 4)")
(:doc-example . "(foldr + 0 (iota 5))\n; ↳ 10") (:doc-example . "(foldr (λ (x y a) (+ (* x y) a)) 0 (iota 5) (iota 5))\n; ↳ 30")
(:doc-example . "(foldr (λ (x y a) (cons x (cons y a))) NIL (iota 5) (vec 'a 'b 'c))\n; ↳ (0 a 1 b 2 c)")
(:doc-group . list) (:doc-see . foldl) (:doc-see . foldr1))  reverse ((:doc-example . "(def a '(1 2 3))\n(reverse a)\n; ↳ (3 2 1)\na\n; ↳ (1 2 3) ; original list preserved")
(:doc-group . list) (:doc-see . reverse!))  lz-pack ((:doc-group . compress))  *prompt* ((:doc-group . vm)
(:doc-see . *interactive*))  member ((:doc-example . "(member 1 '(3 2 1 0))\n; ↳ (1 0)")
(:doc-example . "(member 1 '(2 3))\n; ↳ NIL") (:doc-group . list)
(:doc-see . memq) (:doc-see . memv))  rune-numeric? ((:doc-example . "(rune-numeric? #\\9)\n; ↳ T")
(:doc-example . "(rune-numeric? #\\й)\n; ↳ NIL") (:doc-group . string) (:doc-see . rune-alphabetic?)
(:doc-see . rune-whitespace?))  bignum? ((:doc-group . type) (:doc-group . number) (:doc-see . bignum))  fixnum ((:doc-group . number)
(:doc-see . fixnum?))  f64 ((:doc-group . number) (:doc-see . f32))  cc? ((:doc-group . cc))  memq ((:doc-group . list)
(:doc-see . member) (:doc-see . memv))  str->num ((:doc-example . "(str->num \"1.2\")\n; ↳ 1.2")
(:doc-example . "(str->num \"#x123\")\n; ↳ 291")
(:doc-example . "(str->num \"ffff\" :base 16)\n; ↳ 65535")
(:doc-example . "(str->num \"777\" :base 8)\n; ↳ 511")
(:doc-group . string) (:doc-see . num->str))  exp ((:doc-example . "(exp 1)\n; ↳ 2.71828… ; e")
(:doc-group . number))  +most-negative-fixnum+ ((:doc-group . number) (:doc-see . +most-positive-fixnum+))  caaaar ((:doc-group . list))  io-column ((:doc-group . io)
(:doc-see . io-line) (:doc-see . io-column!))  traced? ((:doc-example . "(traced? map)\n; ↳ NIL\n(trace 'map)\n(traced? map)\n; ↳ T\n(untrace 'map)\n(traced? map)\n; ↳ NIL")
(:doc-group . debug) (:doc-see . trace)
(:doc-see . untrace))  cond ((:doc-example . "(def x 8)\n(cond ((sym? x) \"symbol\")\n      ((str? x) \"string\")\n      ((+ x 1) => sqrt))\n; ↳ 3.0")
(:doc-example . "(def x \"hello\")\n(cond ((sym? x) 0)\n      ((length x)))\n; ↳ 5")
(:doc-example . "(def x 0)\n(case ((positive? x) 10)\n      ((negative? x) -10)\n      (else 'oops))\n; ↳ oops")
(:doc-group . syntax)
(:doc-see . case))  s64 ((:doc-group . number)
(:doc-see . u64))  io-flush ((:doc-group . io) (:doc-see . io-discard-buffer) (:doc-see . io-buffer-mode))  assoc ((:doc-example . "(def L (assoc-list 'a 0 'b 1))\n(assoc 'b L)\n; ↳ (b . 1)\n(assoc 'c L)\n; ↳ NIL")
(:doc-group . list) (:doc-see . assoc-list) (:doc-see . assq) (:doc-see . assv))  + ((:doc-group . number)
(:doc-group . builtin))  path-delete ((:doc-group . io)
(:doc-see . path-exists?) (:doc-see . path-rename))  cadadr ((:doc-group . list))  foldr1 ((:doc-example . "(foldr1 + (iota 10))\n; ↳ 45")
(:doc-group . list) (:doc-see . foldr) (:doc-see . foldl1))  compare ((:doc-example . "(compare 'a 'b)\n; ↳ -1")
(:doc-example . "(compare 1 1)\n; ↳ 0")
(:doc-example . "(compare \"b\" \"a\")\n; ↳ 1")
(:doc-group . compare) (:doc-group . builtin))  length ((:doc-example . "(length \"абвгд\")\n; ↳ 5")
(:doc-example . "(length #(abc 123))\n; ↳ 2") (:doc-example . "(length #table(0 a  1 b  2 c))\n; ↳ 3")
(:doc-example . "(length (arr 'u32 1 2 3 4))\n; ↳ 4")
(:doc-example . "(length '(1 2 3 4 5))\n; ↳ 5") (:doc-example . "(length '(1 2 3 4 . 5)) ; improper list\n; ‼ type error: expected cons, got fixnum: 5")
(:doc-example . "(length '#0=(1 . #0#)) ; circular list\n; ↳ NIL") (:doc-group . array) (:doc-group . list)
(:doc-group . table) (:doc-see . proper-list?))  *io-err* ((:doc-group . io) (:doc-see . *io-out*)
(:doc-see . *io-in*)
(:doc-see . with-bindings))  print-exception ((:doc-example . "(def e (list (list *stdin* 3 10) 'type-error 'str 123))\n(print-exception e)\n; ‼ *stdin*:3:10: type error: expected str, got fixnum: 123")
(:doc-group . error) (:doc-see . *exception-print-level*)
(:doc-see . *exception-print-length*))  error ((:doc-example . "(error \"oops: \" 123)\n; ‼ error: oops: 123")
(:doc-example . "(trycatch (error 0 \"oops\" 'extra) identity)\n; ↳ (error \"oops\" 0 extra)")
(:doc-group . error))  set-top-level-value! ((:doc-example . "(let {[abc 2]}\n  (set-top-level-value! 'abc 123)\n  abc)\n; ↳ 2\nabc\n; ↳ 123")
(:doc-group . misc) (:doc-see . top-level-value) (:doc-see . set!))  load ((:doc-example . "(load \"stuff.sl\")")
(:doc-group . vm) (:doc-see . eval))  cc-add-sysinclude-path ((:doc-group . cc))  getpid ((:doc-group . sys))  *io-default-file-mode* ((:doc-group . io)
(:doc-see . *io-default-dir-mode*) (:doc-see . file))  keyword? ((:doc-group . type))  aref ((:doc-example . "(def a '((1 #(2 (3)) 4)))\n(aref a 0)\n; ↳ (1 (2 (3)) 4)\n(aref a 1)\n; ‼ index 1 out of bounds\n(aref a 0 0)\n; ↳ 1\n(aref a 0 1 0)\n; ↳ 2\n(aref a 0 2)\n; ↳ 4")
(:doc-group . array) (:doc-see . aset!) (:doc-group . builtin))  sym? ((:doc-group . type) (:doc-see . sym)
(:doc-see . gensym?) (:doc-group . builtin))  defmacro ((:doc-example . "(defmacro (inc! v)\n  «Increments and returns the value.»\n  :doc-group my-cool-macros\n  :doc-see my-other-cool-macro\n  (if (num? v)\n      (1+ v)\n      `(set! ,v (1+ ,v))))\n(inc! 1)\n; ↳ 2\n(set! x 1)\n(inc! x)\n; ↳ 2\nx\n; ↳ 2")
(:doc-group . syntax) (:doc-see . macroexpand))  cc-add-include-path ((:doc-group . cc))  u64 ((:doc-group . number)
(:doc-see . s64))  int-valued? ((:doc-example . "(int-valued? -123.0)\n; ↳ T")
(:doc-example . "(int-valued? -123.1)\n; ↳ NIL") (:doc-group . number)
(:doc-see . int?))  Instructions ((:doc-group . builtin))  assv ((:doc-group . list)
(:doc-see . assoc) (:doc-see . assq))  bignum ((:doc-group . number) (:doc-see . bignum?))  princ-to-str ((:doc-example . "(princ-to-str 1 2 3)\n↳ \"123\"")
(:doc-group . io) (:doc-see . print-to-str))  copy-vec ((:doc-example . "(def v #vec(1 2 \"three\"))\n(def q (copy-vec v))\n(eq? v q)\n; ↳ NIL\n(equal? v q)\n; ↳ T\n(map eq? v q)\n; ↳ #(T T T)")
(:doc-group . array))  print-to-str ((:doc-example . "(print-to-str 1 2 3)\n↳ \"1 2 3\"")
(:doc-group . io) (:doc-see . princ-to-str))  process-state ((:doc-group . process) (:doc-see . process-alive?)
(:doc-see . process-exit-code)
(:doc-see . process-exit-msg))  eqv? ((:doc-example . "(eqv? 0.0 0)\n; ↳ NIL")
(:doc-example . "(eqv? 0 0)\n; ↳ T") (:doc-example . "(def a \"1\")\n(def b \"1\")\n(eqv? a b)\n; ↳ T")
(:doc-example . "(def a '(1))\n(def b '(1))\n(eqv? a b)\n; ↳ NIL") (:doc-group . compare) (:doc-group . builtin))  +f64-epsilon+ ((:doc-group . number)
(:doc-see . +f32-epsilon))  list ((:doc-example . "(list) ; empty list\n; ↳ NIL")
(:doc-example . "(list 1 2.5 \"a\" 'b)\n; ↳ (1 2.5 \"a\" b)")
(:doc-see . list?) (:doc-see . cons) (:doc-group . builtin))  process-exit-msg ((:doc-group . process)
(:doc-see . process-exit-code))  eof? ((:doc-group . io) (:doc-group . type))  __init_globals ((:doc-group . vm))  +pi+ ((:doc-group . number))  revappend ((:doc-example . "(def a '(4 5 6))\n(revappend a '(3 2 1))\n; ↳ (6 5 4 3 2 1)\na\n; ↳ (4 5 6) ; original list preserved")
(:doc-group . list) (:doc-see . nreconc))  quote ((:doc-example . "'(0 1 (+ 2 3))\n; ↳ (0 1 (+ 2 3))")
(:doc-group . syntax) (:doc-see . quasiquote)
(:doc-see . unquote))  nreconc ((:doc-example . "(def a '(4 5 6))\n(nreconc a '(3 2 1))\n; ↳ (6 5 4 3 2 1)")
(:doc-group . list)
(:doc-see . revappend))  defc*r ((:doc-example . "(defc*r caaaaaaaaddr)\n(caaaaaaaaddr '(0 1 (((((((2 3 4)))))))))\n; ↳ 2")
(:doc-group . list))  rune-alphabetic? ((:doc-example . "(rune-alphabetic? #\\9)\n; ↳ NIL")
(:doc-example . "(rune-alphabetic? #\\й)\n; ↳ T") (:doc-group . string)
(:doc-see . rune-numeric?) (:doc-see . rune-whitespace?))  read-all-of ((:doc-group . io)
(:doc-see . read-all) (:doc-see . io-read-lines))  cddddr ((:doc-group . list))  prog1 ((:doc-example . "(prog1 (+ 1 2 3)\n       (print \"hi\")\n       (newline))\n; ↳ 6")
(:doc-group . syntax) (:doc-see . begin))  logior ((:doc-example . "(logior)\n; ↳ 0") (:doc-example . "(logior 2)\n; ↳ 2")
(:doc-example . "(logior 2 3)\n; ↳ 3")
(:doc-example . "(logior 2 3 4)\n; ↳ 7")
(:doc-group . number))  cadr ((:doc-example . "(cadr '(1 2 3))\n; ↳ 2")
(:doc-example . "(cadr '(1))\n; ↳ NIL") (:doc-example . "(cadr NIL)\n; ↳ NIL") (:doc-group . list)
(:doc-group . builtin))  cdadr ((:doc-group . list))  nan? ((:doc-group . number) (:doc-group . builtin))  caar ((:doc-group . list))  path-rename ((:doc-group . io)
(:doc-see . path-delete) (:doc-see . path-exists?))  div0 ((:doc-example . "(div0 10 3)\n; ↳ 3")
(:doc-example . "(div0 -10 3)\n; ↳ -3")
(:doc-example . "(div0 -10 -3)\n; ↳ 3")
(:doc-example . "(div0 10 -3)\n; ↳ -3")
(:doc-group . number) (:doc-see . mod0)
(:doc-see . div) (:doc-group . builtin))  set-syntax! ((:doc-group . syntax)
(:doc-see . defmacro) (:doc-see . get-syntax))  mod0 ((:doc-example . "(mod0 10 3)\n; ↳ 1") (:doc-example . "(mod0 -10 3)\n; ↳ -1")
(:doc-example . "(mod0 -10 -3)\n; ↳ -1") (:doc-example . "(mod0 10 -3)\n; ↳  1") (:doc-group . number)
(:doc-see . div0) (:doc-see . mod))  last-pair ((:doc-example . "(last-pair '(1 2 3))\n; ↳ (3)")
(:doc-example . "(last-pair '(1 2 . 3))\n; ↳ (2 . 3)")
(:doc-group . list) (:doc-see . last-cdr))  cc-add-library-path ((:doc-group . cc))  path-cwd ((:doc-group . io)
(:doc-see . path-exists?))  *print-width* ((:doc-example . "(with-bindings ((*print-width* 3)) (princ \"abcde\"))\n; ‼ abc...")
(:doc-example . "(with-bindings ((*print-width* 3)) (princ \"ab𲎿\"))\n; ‼ ab...")
(:doc-group . io) (:doc-see . princ))  rune-title-case? ((:doc-example . "(rune-title-case? #\\DŽ)\n; ↳ NIL")
(:doc-example . "(rune-title-case? #\\Dž)\n; ↳ T") (:doc-group . string) (:doc-see . rune-titlecase)
(:doc-see . rune-lower-case?) (:doc-see . rune-upper-case?))  arr? ((:doc-group . type) (:doc-see . vec?)
(:doc-see . arr) (:doc-see . vec))  cadaar ((:doc-group . list))  unwind-protect ((:doc-example . "(unwind-protect (begin (print \"a\")     (newline)\n                       (print (/ 1 0)) (newline) ; an error here\n                       (print \"b\")     (newline)\n                (begin (print \"c\")     (newline))))\n; ↳ \"a\"\n; ↳ \"c\"\n; ‼ /: division by zero")
(:doc-group . error)
(:doc-see . catch))  cos ((:doc-group . number))  io-skip ((:doc-example . "(def f (buffer))\n(io-write f \"hello, world!\")\n(io-skip f -6 :end T)\n; ↳ 7\n(read f)\n; ↳ world!")
(:doc-group . io) (:doc-see . io-pos!))  *io-default-dir-mode* ((:doc-group . io) (:doc-see . *io-default-file-mode*)
(:doc-see . path-make-dir))  rune-upper-case? ((:doc-example . "(rune-upper-case? #\\DŽ)\n; ↳ T")
(:doc-example . "(rune-upper-case? #\\Dž)\n; ↳ NIL") (:doc-group . string) (:doc-see . rune-upcase)
(:doc-see . rune-lower-case?) (:doc-see . rune-title-case?))  *io-in* ((:doc-group . io) (:doc-see . *io-out*)
(:doc-see . *io-err*) (:doc-see . with-input-from))  with-bindings ((:doc-example . "(def (s) (str *print-base* #\\. *print-radix* #\\. 123))\n(s)\n; ↳ \"10.NIL.123\"\n(with-bindings ((*print-base* 16)\n                (*print-radix* T))\n  (s))\n; ↳ \"#x10.T.#x7B\"\n(s)\n; ↳ \"10.NIL.123\"")
(:doc-group . syntax) (:doc-see . def)
(:doc-see . let) (:doc-see . set!))  every ((:doc-example . "(every odd? '(1 3 5 7)) ; every number odd?\n; ↳ T")
(:doc-example . "(every (λ (s) (length> s 1)) ; every string longer than one rune?\n  '(\"ab\" \"cd\" \"e\"))\n; ↳ NIL")
(:doc-group . list) (:doc-see . any))  atom? ((:doc-example . "(atom? \"a\")\n; ↳ T") (:doc-example . "(atom? NIL)\n; ↳ T")
(:doc-example . "(atom? '(1))\n; ↳ NIL")
(:doc-group . type)
(:doc-group . builtin))  p64 ((:doc-group . number)
(:doc-see . p32) (:doc-see . ptr))  fn ((:doc-group . misc))  str-utf8? ((:doc-example . "(str-utf8? \"привет\")\n; ↳ T")
(:doc-example . "(str-utf8? \"при\\xffвет\")\n; ↳ NIL")
(:doc-group . string) (:doc-see . str?))  apply ((:doc-example . "(apply + 1 2 '(3 4 5))\n; ↳ 15")
(:doc-example . "(apply vec '(1 2 3))\n; ↳ #(3 4 5)")
(:doc-example . "(apply arr 'u8 '(3 4 5))\n; ↳ #vu8(3 4 5)") (:doc-group . builtin))  cc-relocate ((:doc-group . cc)
(:doc-see . cc-compile))  process-post ((:doc-group . process) (:doc-see . process-close))  cddr ((:doc-group . list))  not ((:doc-group . syntax)
(:doc-see . and) (:doc-see . or) (:doc-group . builtin))  print ((:doc-example . "(print 1 2 \"abc\")\n; ‼ 1 2 \"abc\"")
(:doc-group . io) (:doc-see . princ))  letrec ((:doc-example . "(letrec ((a (λ () 1))\n         (b (λ () (+ (c) 1)))\n         (c (λ () (+ (a) 1)))\n         d)\n  (list (a) (b) (c) (void? d)))\n; ↳ (1 3 2 T)")
(:doc-group . syntax) (:doc-see . let) (:doc-see . let*))  with-output ((:doc-example . "(with-output (s) (write \"hello\" s))\n; ↳ \"\\\"hello\\\"\"")
(:doc-example . "(def b (buffer))\n(with-output (s b) (io-write s \"hello\"))\n; ↳ 5\n(length b)\n; ↳ 5")
(:doc-group . io) (:doc-see . with-output-to))  cdar ((:doc-group . list))  cdaar ((:doc-group . list))  iota ((:doc-example . "(iota 4)\n; ↳ (0 1 2 3)")
(:doc-example . "(iota 4 6)\n; ↳ (6 7 8 9)") (:doc-example . "(iota 4 6 -0.5)\n; ↳ (6 5.5 5.0 4.5)")
(:doc-group . list) (:doc-see . map-int))  caaddr ((:doc-group . list))  environment ((:doc-group . vm)
(:doc-see . print-stack-trace))  fn-code ((:doc-group . misc))  putprop ((:doc-example . "(def x '(1 2 3))\n(putprop x 'words \"one two three\")\n; ↳ \"one two three\"\n(getprop x 'words)\n; ↳ \"one two three\"")
(:doc-group . prop) (:doc-see . getprop) (:doc-see . remprop))  T ((:doc-example . "(not T)\n; ↳ NIL")
(:doc-example . "(if T 'yes 'no)\n; ↳ yes")
(:doc-group . misc) (:doc-see))  * ((:doc-group . number)
(:doc-group . builtin))  *io-out* ((:doc-group . io) (:doc-see . *io-err*) (:doc-see . *io-in*)
(:doc-see . with-output-to))  repl ((:doc-group . vm)
(:doc-see . that) (:doc-see . *interactive*) (:doc-see . *prompt*))  io-read-until ((:doc-group . io)
(:doc-see . io-read))  getprop ((:doc-example . "(def x '(1 2 3))\n(putprop x 'words \"one two three\")\n; ↳ \"one two three\"\n(getprop x 'words)\n; ↳ \"one two three\"\n(getprop x 'huh)\n; ‼ key not found: huh\n(getprop x 'huh \"fallback\")\n; ↳ \"fallback\"")
(:doc-group . prop) (:doc-see . putprop) (:doc-see . remprop))  get ((:doc-example . "(def t #table(a 1 b 2))\n(get t 'a)\n; ↳ 1\n(get t 'b NIL)\n; ↳ 2\n(get t 'c)\n; ‼ key not found: a\n(get t 'c 123)\n; ↳ 123")
(:doc-group . table) (:doc-see . has?)
(:doc-see . put!) (:doc-see . del!))  table? ((:doc-group . type)
(:doc-group . table) (:doc-see . table))  u16 ((:doc-group . number) (:doc-see . s16))  logxor ((:doc-example . "(logxor)\n; ↳ 0")
(:doc-example . "(logxor 2)\n; ↳ 2") (:doc-example . "(logxor 2 3)\n; ↳ 1") (:doc-example . "(logxor 2 3 4)\n; ↳ 5")
(:doc-group . number))  zip ((:doc-example . "(zip '(1 2 3))\n; ↳ ((1) (2) (3))")
(:doc-example . "(zip '(1 2 3 4) '(5 6 7) '(8 9 10 11))\n; ↳ ((1 5 8) (2 6 9) (3 7 10))")
(:doc-group . list) (:doc-see . zip-with))  str-width ((:doc-example . "(str-width #\\й)\n; ↳ 1")
(:doc-example . "(str-width \"⌛!\")\n; ↳ 3")
(:doc-example . "(str-width \"nope\\n\")\n; ↳ NIL")
(:doc-group . string))  acos ((:doc-group . number))  time->str ((:doc-example . "(time->str (time-now))\n; ↳ \"Tue May  6 03:21:01 CES 2025\"")
(:doc-group . time) (:doc-see . str->time) (:doc-see . time-now))  to-proper ((:doc-example . "(to-proper '(1 2))\n; ↳ (1 2)")
(:doc-example . "(to-proper '(1 . 2))\n; ↳ (1 2)")
(:doc-group . list)
(:doc-see . proper-list?))  caddr ((:doc-group . list))  table-keys ((:doc-example . "(def t #table(a 1 b 2 c 1))\n(table-keys t)\n; ↳ (a b c)")
(:doc-group . table) (:doc-see . table-values))  rune-upcase ((:doc-example . "(rune-upcase #\\ä)\n; ↳ #\\ä")
(:doc-example . "(rune-upcase #\\dž)\n; ↳ #\\DŽ")
(:doc-group . string) (:doc-see . rune-upper-case?)
(:doc-see . rune-downcase) (:doc-see . rune-titlecase))  set-doc! ((:doc-group . doc))  catch ((:doc-example . "(catch 'some (/ 1 1))\n; ↳ 1")
(:doc-example . "(catch 'some (throw 'some \"oops\"))\n; ↳ \"oops\"")
(:doc-example . "(catch 'some (throw 'other \"oops\"))\n; ‼ *** unhandled exception: (thrown-value other 0)")
(:doc-group . error) (:doc-see . trycatch) (:doc-see . unwind-protect))  __start ((:doc-group . vm)
(:doc-see . __finish))  NIL ((:doc-example . "(not NIL)\n; ↳ T")
(:doc-example . "(if NIL 'yes 'no)\n; ↳ no") (:doc-example . "(car NIL)\n; ↳ NIL") (:doc-example . "(cdr NIL)\n; ↳ NIL")
(:doc-group . list) (:doc-see . T))  floor ((:doc-example . "(floor 1.2)\n; ↳ 1.0") (:doc-example . "(floor -1.2)\n; ↳ -2.0")
(:doc-example . "(floor -5)\n; ↳ -5.0")
(:doc-group . number)
(:doc-see . ceiling))  add-exit-hook ((:doc-group . vm)
(:doc-see . *exit-hooks*))  str-join ((:doc-example . "(str-join '(\"\" \"n\" \"9\" \"heh\")\n          *directory-separator*)\n; ↳ \"/n/9/heh\"")
(:doc-example . "(str-join '(\"a\" \"b\" \"c\") #\\.)\n; ↳ \"a.b.c\"")
(:doc-group . string) (:doc-see . str-split))  >= ((:doc-group . compare))  void? ((:doc-group . type)
(:doc-group . misc) (:doc-see . void))  +f32-epsilon+ ((:doc-group . number) (:doc-see . +f64-epsilon))  length= ((:doc-group . list)
(:doc-see . length<) (:doc-see . length>))  lognot ((:doc-example . "(lognot 0)\n; ↳ -1") (:doc-example . "(lognot #s8(63))\n; ↳ #s8(-64)")
(:doc-example . "(lognot #u16(32767))\n; ↳ #u16(32768)") (:doc-group . number))  int? ((:doc-group . type)
(:doc-group . number) (:doc-see . int-valued?))  nanoseconds-monotonic ((:doc-example . "(nanoseconds-monotonic)\n; ↳ #u64(0)\n(nanoseconds-monotonic)\n; ↳ #u64(47840)")
(:doc-group . time) (:doc-see . time-now))  io-discard-buffer ((:doc-group . io)
(:doc-see . io-flush) (:doc-see . io-buffer-mode))  with-input-from ((:doc-example . "; read a single expression from a file and print it\n(with-input-from (file \"/tmp/1.txt\" :read)\n  (print (read *io-in*))\n  (newline))")
(:doc-group . io) (:doc-see . with-output-to))  *stdout* ((:doc-group . io)
(:doc-see . *stderr*) (:doc-see . *stdin*))  car ((:doc-example . "(car NIL)\n; ↳ NIL") (:doc-example . "(car '(1 2 3))\n; ↳ 1")
(:doc-example . "(car '(1 . 2))\n; ↳ 1") (:doc-group . list) (:doc-group . builtin))  arr ((:doc-example . "(arr 's8 0 1 2)\n; ↳ #arr(s8 0 1 2)")
(:doc-example . "(arr 'rune 0 1 2)\n; ↳ #arr(rune #\\nul #\\soh #\\stx)") (:doc-group . array) (:doc-see . arr-alloc)
(:doc-see . vec))  ceiling ((:doc-example . "(ceiling 1.2)\n; ↳ 2.0") (:doc-example . "(ceiling -1.2)\n; ↳ -1.0")
(:doc-example . "(ceiling -5)\n; ↳ -5.0")
(:doc-group . number) (:doc-see . floor))  length> ((:doc-group . list)
(:doc-see . length<) (:doc-see . length=))  <= ((:doc-group . compare))  arg-error ((:doc-example . "(arg-error \"stuff\" \"?\")\n; ‼ arguments error: stuff?")
(:doc-example . "(trycatch (arg-error \"stuff: \" \"blah\") identity)\n; ↳ (arg-error \"stuff: \" \"blah\")")
(:doc-group . error))  put! ((:doc-example . "(def t #table(a 1 b 2))\n(put! t 'c 3)\n; ↳ #table(c 3  b 2  a 1)\n(put! t 'a \"hello\")\n; ↳ #table(c 3  b 2  a \"hello\")")
(:doc-group . table) (:doc-see . get) (:doc-see . has?) (:doc-see . del!))  asin ((:doc-group . number))  log ((:doc-example . "(log 100 10)\n; ↳ 2.0")
(:doc-example . "(log 256 2)\n; ↳ 8.0") (:doc-example . "(log (exp 4))\n; ↳ 4.0") (:doc-group . number))  cdaddr ((:doc-group . list))  ash ((:doc-example . "(ash -3 3)\n; ↳ -24")
(:doc-example . "(ash 1 3)\n; ↳ 8") (:doc-group . number))  str-sub ((:doc-example . "(str-sub \"hello\" 2)\n; ↳ \"llo\"")
(:doc-example . "(str-sub \"hello\" 3 3)\n; ↳ \"\"")
(:doc-example . "(str-sub \"hello\" 2 4)\n; ↳ \"ll\"")
(:doc-group . string) (:doc-see . str-rune))  vec-alloc ((:doc-example . "(vec-alloc 5 2.5)\n; ↳ #(2.5 2.5 2.5 2.5 2.5)")
(:doc-example . "(vec-alloc 10 1 2.5 \"a\" 'b)\n; ↳ #(1 2.5 \"a\" b 1 2.5 \"a\" b 1 2.5)") (:doc-group . array)
(:doc-see . vec) (:doc-see . arr-alloc))  arr-alloc ((:doc-example . "(arr-alloc 'u16 5 -1)\n; ↳ #arr(u16 65535 65535 65535 65535 65535)")
(:doc-example . "(arr-alloc 's8 10 0 1 2)\n; ↳ #arr(s8 0 1 2 0 1 2 0 1 2 0)")
(:doc-group . array) (:doc-see . arr) (:doc-see . vec-alloc))  cddadr ((:doc-group . list))  memv ((:doc-group . list)
(:doc-see . member) (:doc-see . memq))  max ((:doc-example . "(max 3 1 9 4)\n; ↳ 9") (:doc-example . "(max 'c 'h 'z 'a)\n; ↳ z")
(:doc-example . "(max \"t\" \"g\" \"a\")\n; ↳ \"t\"")
(:doc-group . compare)
(:doc-see . min))  closure? ((:doc-example . "(closure? closure?)\n; ↳ T")
(:doc-example . "(closure? length)\n; ↳ NIL") (:doc-group . type) (:doc-see . fn?))  read-all ((:doc-example . "; read current process' status file on Plan 9\n(def status (file (str \"/proc/\" (getpid) \"/status\")))\n(read-all status)\n; ↳ (sl glenda Pread 40 0 4940 0 0 0 1856 10 10)")
(:doc-group . io) (:doc-see . io-read-all))  help-print-header ((:doc-group . doc))  arg-counts ((:doc-group . builtin))  sleep ((:doc-example . "(sleep 0.1) ; sleep for 100ms")
(:doc-group . time))  s16 ((:doc-group . number) (:doc-see . u16))  rune? ((:doc-group . type) (:doc-group . string)
(:doc-see . rune))  os-setenv ((:doc-group . sys) (:doc-see . os-getenv))  __script ((:doc-group . vm)
(:doc-see . __rcscript))))
*syntax-environment* #table(bcode:ctable #fn("A12080Ke3:" #(aref) 7)  defdoc #fn("r180B86;360480<;J5048086;360480=707181225251<863I0232487e22489e22488e2e4:232487e22489e2e3:" #(separate-doc-from-body
append (NIL) set-doc! quote) 13)  make-label #fn("A120e1:" #(gensym) 5)  while #fn("r1208081PP:" #($while) 7)  trycatch #fn("A2208081e3:" #($trycatch) 7)  def #fn("r220808182PPP:" #($def) 8)  prog1 #fn("r1208081PP:" #($prog1) 7)  bcode:nconst #fn("A12080F2e3:" #(aref) 7)  bcode:spmax #fn("A12080F5e3:" #(aref) 7)  with-input-from #fn("r12021e12280e2e1e18163:" #(#fn(nconc)
with-bindings *io-in*) 8)  defmacro #fn("r170815186<86=873A07180<8780=53@40D9422232480<e22526e180=e18853e3DIe3:" #(separate-doc-from-body
set-doc! begin set-syntax! quote #fn(nconc) λ) 14)  unless #fn("r181370D9@8070215142280D92381Pe4:" #(arg-error
"unless without a body" if begin) 9)  with-exception-bindings #fn("r02021e12223e22425e2e2e18063:" #(#fn(nconc)
with-bindings *print-level* *exception-print-level* *print-length* *exception-print-length*) 9)  time #fn("A1202122e1e2e123802425262722e121e328e3292:e5e3e3:" #(let
#:t0_auto42# time-now prog1 princ "Elapsed time: " / - 1000000000 "s" *linefeed*) 14)  cond #fn("r0DIDIb5b68520_486218685>2_486<8061:" #(#fn("A180B;3O0480<20Q;3D0480TB;3;047180TK62:" #(λ
length=) 1arg-lambda? 7) #fn("A180H350D9:80<85<20Q;J90485<DAQ3C085=J6085<:2185=P:85=JB02285<90<80=51e3:85T23C\x99091<748551513e07574855151268685<e2e12786217874855151P90<80=51e4e3:262985<e2e1272974855129e290<80=51e4e3:2785<2185=P90<80=51e4:" #(else
begin or => caddr caadr let if cddr #:b_auto22#) cond-clauses->if 14)) 8)  do #fn("r281<207180522072805220238052242526882728e187e12729e181=52e1822725e18:52e155e3e2e12725e18952e3:" #(#fn(map)
car cadr #fn("A1708051B3O07180513?0722370805162:748061:80<:" #(cddr cdddr compile-error "invalid step-expr: "
caddr) 8) letrec #:loop_auto29# λ
#fn(nconc) if begin) 20)  mark-label #fn("A220802122e281e4:" #(emit quote label) 8)  with-bindings #fn("r12071805220728052202380522425e12076888653e12027868753282429e181522429e1202:86885352e3e164:" #(#fn(map)
car cadr #fn("A12060:" #(#fn(gensym)) 5) #fn(nconc) let list #fn("A2208081e3:" #(set!) 7)
unwind-protect begin #fn("A2208081e3:" #(set!) 7)) 19)  let #fn("r1D980R3E080?6481<?0481=?1@40D9481B370D9@8070215142223e124258052e1815390<80512491<8052883B0762792<885152@40D94863C0288687e2e186e3@408789P:" #(arg-error
"missing body" #fn(nconc) λ #fn(map) #fn("A180B36080<:80:" 5) compile-error "duplicate identifier: "
letrec) #(#0=(#fn("A180<80=863M070219085>28652;J:0491<8661:D9:" #(any #fn("A190<915190<8051Q;350491:" 7)) #(#1=(#fn("A180B36080<:80:" 5))
#0#) 9)) #2=(#fn("A190<805185R3@0208551J70D9@:071228552480R;J;047380F252370D9@:071248052480R350DI:80T:" #(#fn(keyword?)
compile-error "invalid identifier: " length= "invalid binding: ") #(#1#) 8))
#1#) 12)  %defstruct% #fn("O10005000*///r6W1000J7021?14W2000;J70DA?24W3000;J70DA?34W4000;J70DA?44W5000;J70DA?54DIDI2280>1??423?@4248651252686528@8651258?86528121C70DA@F08127C70D9@:0782981528E3B082;J904782:51@;082;35048;;370480e185DAQ;3;042;802<52;J504858G;3M048F3708G@B08>3;0782=51@40D98E3;02>80e2@80802?e283DAQ83;3^0483H;3O0483DAQ;3;042;2@8052;J504838CP;J5048384DAQ;3;042;802A52;J50484DI2B8E81808B8F>5?M42C2De18H3|02E8H2Fe28E3E02G2H2Fe22I8Ie2e3@W02J2K2L2FEe32I80e2e32M2N2Fe27O8A51e3e3e3@40D9e18K3C02E8K<8M8K=51e3@40D9e18E3V02P2I80e22I2Qe28J3808K<@808M8C51e4@40D9e17R2S8B8L8E8H8I8F>68A527R2T8D8B8L8E8H8I8F>78A52DIe167:" #(#(:type
:named :constructor :conc-name :predicate) vec #fn("A180H380D9:@40D942071728051f22324858090>38652486:" #((:read-only)
assoc-list cddr #fn(for-each) #fn("A17080<9052350D9:71222391<249225805661:" #(member error #fn(str)
"invalid option in slot "
" of struct " ": ") 12)) slot-opts 9)
#fn("A120218062:" #(#fn(map) #fn("A180B;360480<85;J5048085;360480=;J704D9e186RS;J9042086513=071228652@40D942324865287B38087<@40D9e2:" #(#fn(keyword?)
error "invalid slot name: " #fn(sym) #\:) 10)) tokw 7)
#fn(length) #fn(map) #fn("A180B36080<:80:" 5) list arg-error "invalid struct type: " "structs of type `vec` are always :named T"
#fn(sym) #\? "predicate not possible unless the struct is :named T" struct … "make-" "-" #fn("A12080903W02191e12223e2e12292e2e17425D9935354@Z0943K02126e12122e19452e19353@<02126e19352e3:" #(λ
#fn(nconc) quote %struct% foldr #fn("A2202180528081PP:" #(#fn(sym) ":") 7) list) make-constructor 14)
#fn(nconc) begin def s equal? type-of quote and eq? aref = length 1+ putprop constructor map-int
#fn("A170908052913=021918552@4085923=0F280i2KM@4080228623e2933K0249323e2252694e223e3e3@40D9272395360K@30E87Me3e4:" #(nth
#fn(sym) def s unless type-error quote aref) 14) #fn("A170908052709180522192;J50422862353933=0F280i2KM@408074258552350D9:26872728e3943K0299427e22:2;95e227e3e3@40D92<2796360K@30E88M28e4e4:" #(nth
#fn(sym) "" #\! assv :read-only def s v unless type-error quote aset!) 15)) 33)  and #fn("r02021e18062:" #(#fn(nconc)
$and) 7)  for #fn("A320212280e22381e2e224252223e38222e226222722Ke3e3e4e3e2:" #(#3=#fn("r0DI:" void 4)
let #:i_auto14#
#:n_auto14# while
< set! +) 15)  bcode:cenv #fn("A12080F3e3:" #(aref) 7)  bcode:code #fn("A12080Ee3:" #(aref) 7)  > #fn("r12021e172815180e163:" #(#fn(nconc)
< reverse) 8)  when #fn("r181370D9@80702151422802381PD9e4:" #(arg-error "when without a body" if
begin) 8)  quasiquote #fn("A17080E62:" #(bq-process) 7)  unquote #fn("A18042047142047242380P:" #(:doc-see
unquote-splicing unquote-nsplicing unquote) 6)  assert-fail #fn("r1DI20?6421222380D9e32425e1813F0268625e22781<e2e3@40DAe3e3e2:" #(#fn("A1708051;3Q047080<51;3E042172805151;360480<8538080=@408086;3G0486B;3?0486<R;360486<:" #(list?
#fn(io?) caar) type 7) assert trycatch begin λ e eq? quote) 14)  begin #fn("r02080P:" #($begin) 6)  help #fn("O00001000.///r2W0000;J70D9?04W1000J7071?148737080@40228823C8082<@40888889C8082<@40888:;3>0424258:5289P8:3=0268:89e3@4089778<28D953778<29D95389R;3A0489Z;J9047:89512;7<51DIDIDIDIDIDIDIDIbAbCbDbE2=7<2>5248A2?_42@89>1?B48C2A_48D2B_48E2C_42D?F42E8;>1?G42F?H4892GCM02H2I8E>18H2J7K28528F5252@\xb318=;J5048>3[1778<2LD9537M2N8I527M2O8I527M2P8I527M2Q8I5281;3?04818<8>2R8:5448=3M07S8A<7T2U8=8J53515147V50@40D948M3T07V5047S2W5147V5042H2X8D8A>28M52@40D948K3W07V5047S2Y5147V5042H2Z8C>18K5247V50@40D948L3S07V5047S2[5147V5042H2\\8L5247V50@40D948:3c07V5047S2]5147V5042H2^8C>18H2J7K28528G525247V50@40D94DI^1^1^1^1^1@~08?J>08B50370D9@m07S2_8:3=02`8:2a52@402b895348:JF089R3@08?J;07S2c51@40D947V5042=7<8@5242d7<5147e60:" #(#(:print-header)
help-print-header help group #fn(sym) ":doc-" doc getprop *doc* *formals-list* get-syntax #fn(io-buffer-mode)
*io-out* #fn(io-buffer-mode!) :block #fn("A1707122523;073248062:80:" #(member +os-name+ ("dos" "macos"
"unknown") str-map #fn("A1808520c35021:8522c35023:8524c35025:8526c35027:8528c35029:852:c3502;:852<c3502=:852>c3502?:80:" #(#\↳
"->" #\… "..." #\‼ "!!" #\λ "lambda" #\₀ #\0 #\₁ #\1 #\ₙ #\n #\ᵢ #\i) 7)) deunicode 7)
#fn("A0209051E21842252Q85;3:042384K52;J5048474258651512186225287Q88;3<042386E8753;J50486258951268985888:>427788;295052788;7:7;5152528<3A02<2=7>8<7?5262:D9:" #(#fn(str)
#fn(str-find) "*" #fn(str-sub) 1- #fn(length) #fn("A12080512185905286;390422855186;3T0491;J804E86l2;3C0492;J<04878693Ml2:" #(#fn(str)
#fn(str-find) #fn(length)) 10) #fn(nconc) filter #fn(environment) table-keys *syntax-environment*
#fn(for-each) #fn("A170805147160:" #(princ newline) 6) sort <) environment-find-matching 18)
#fn("A37071D9I04D9I14228788>223818280>32489>1q89504:" #(*print-syntax-sugar* *print-pretty* #fn("A090I0491I1:" #(*print-syntax-sugar*
*print-pretty*) 4) #fn("A0903A020219192>29062:725047391514749261:" #(#fn(for-each)
#fn("A1705047190514729180P61:" #(newline
princ print) 7) newline princ print) 7) #fn("A190504208061:" #(#fn(raise)) 6)) print-sig 9)
#fn("A2202181>12280235262:" #(#fn(for-each) #fn("A17090805247160:" #(princ newline) 7)
#fn(str-split) "\n") princ-indent 9)
#fn("A12080E2180225263:" #(#fn(str-sub) #fn(str-find) "\n") first-line 10)
#fn("A180B;3D0480<20Q;390480T21Q:" #(doc group) doc-group? 6)
#fn("A180H;3C047090718022D95362:" #(member getprop *doc-extra*) doc-extra-term? 10)
#fn("A270212281>1D980537362:" #(sort #fn(table-fold)
#fn("A39080513808082P:82:" 6) <) table-keys-filter-sort 9) groups
#fn(for-each) #fn("A17021722374805151F:25265490<778028D953515347960:" #(princ "  " str-pad #fn(str)
caddr :align :left
getprop *doc* newline) 12)
#fn(get) *properties* *doc-extra* filter #fn("A180<20Q:" #(:doc-fmt) 6)
#fn("A180<20Q:" #(:doc-see) 6) #fn("A180<20Q:" #(:doc-group) 6)
#fn("A180<20Q:" #(:doc-example) 6) :kind princ foldl #fn("A280=8161:" 6) newline "Examples:" #fn("A17050490<91<80=512162:" #(newline
"    ") 7) "See also:" #fn("A190<80=7080=21D9532263:" #(getprop *formals-list* "    ") 10) "Groups:"
#fn("A170504712280=2363:" #(newline princ "    (help group " ")") 8) "Members:" #fn("A190<80708021D9532263:" #(getprop
*formals-list* "    ") 10) "no help for " #fn(str) " " "" " (undefined)" #fn(io-flush) void) 33)  or #fn("r02021e18062:" #(#fn(nconc)
$or) 7)  doc-group #fn("A22021222324e22325e22380e2e481e3e2:" #(begin set-doc! list quote doc
group) 11)  with-output-to #fn("r12021e12280e2e1e18163:" #(#fn(nconc)
with-bindings *io-out*) 8)  unquote-nsplicing #fn("A12080P:" #(unquote-nsplicing) 6)  catch #fn("A220812122e123242522e2262722e22829e2e3262:22e280e3e42;22e22<22e2e4e3e3:" #(trycatch
λ #:e_auto36# if and cons? eq? car quote thrown-value cadr caddr raise) 15)  unquote-splicing #fn("A12080P:" #(unquote-splicing) 6)  let* #fn("r181B370D9@80702151480<80=2223e190<8651e1e187B3E02224e187e18153e1@40815391<8651e2:" #(arg-error
"missing body" #fn(nconc) λ let*) #(#1# #2#) 13)  return #fn("w00001000W0000J907050?042180e2:" #(void
$return) 6)  if #fn("r282370D9@8070215142280812382Pe4:" #(arg-error "if without an else branch"
$if begin) 9)  letrec #fn("r181B370D9@80702151490<8051863B0722391<865152@40D9^14242425e12691<8052e126279192>280528154e12678805262:" #(arg-error
"missing body" compile-error "duplicate identifier: " #fn(nconc) λ #fn(map)
#fn("A12090<805191<8051e3:" #(set!) 8) void) #(#0#
#1#
#2#) 11)  bcode:sp #fn("A12080F4e3:" #(aref) 7)  with-output #fn("r180<80T873G02021e18687e2e1e18163:218622e1e2e1232024e1812586e2e1532686e2e3e3:" #(#fn(nconc)
let buffer unwind-protect begin io->str io-close) 14)  defstruct #fn("r07080=5185<85=80<DI218887>2?94863H0728873862489Pe15252@40D942526e188e18763:" #(separate-doc-from-body
#fn("A120802152853>02280E8553@4080853=022808552@40232475262790915351285229862:7;882<528764:" #(#fn(str-find)
"\n\n" #fn(str-sub) "" #fn(str-split) print-to-str #fn(list*) defstruct "\n" #fn(str) "\n\n    "
str-join "\n    ") fmt 14) set-doc! append :doc-fmt #fn(nconc) %defstruct%) 15)  assert #fn("A12080DA21222380e2e2e2e4:" #(if
raise quote assert-failed) 11)  case #fn("r1DIDIb6b78620_4872186>1_42250238880e2e12425e126278788>2815252e3:" #(#fn("A170805135080:2180e2:" #(self-evaluating?
$quote) quote-value 6) #fn("A28120C5020:81J50D9:81R3@0218090<8151e3:81H3@0228090<8151e3:81=JA0228090<81<51e3:737481523?025802681e2e3:27802681e2e3:" #(else
eq? eqv? every sym? memq quote memv) vals->cond 8)
#fn(gensym) let #fn(nconc) cond #fn(map) #fn("A190<9180<5280=P:" 7)) 14)  quote #fn("A12080e2:" #($quote) 6)  with-input #fn("r12080<2122e180=52e2e1232124e181522580<e2e3e3:" #(let
#fn(nconc) buffer unwind-protect begin io-close) 10)  set! #fn("r2208081e382J5087:2187DIb:8:228:>1_48:<^18251PP:" #($set!
$begin #fn("A1803[080=370D9@8070215142280<80Te390<73805151P:D9:" #(arg-error "set!: odd number of arguments"
$set! cddr) 8)) 9)  defc*r #fn("A1208051218551F2n72238586>22475865153268024e22027872853292:87e6:" #(#fn(str)
#fn(length) foldl #fn("A22021909180n52C7022@402381e1P:" #(#\a #fn(str-rune) car cdr) 9) lst iota
def "Shorthand for `" "`." :doc-group list) 13)  dotimes #fn("r180<80KG20805188F3l23:080F2G@40DI7188F352370D9@:07223805242425E872627e186e1e18153e489e3:" #(#fn(length)
<= compile-error "invalid var expression: " begin for #fn(nconc) λ) 16)  receive #fn("r22021D981e32221e180e18253e3:" #(call-with-values
λ #fn(nconc)) 10)  throw #fn("A220212223e28081e4e2:" #(raise list quote thrown-value) 9)  unwind-protect #fn("A2202122D981e3e2e12324802225e121e12625e2e4e321e1e3e3:" #(let
#:thk_auto37# λ prog1 trycatch #:e_auto37# raise) 14))
1+ #fn("A180KM:" 6) 1-
#fn("A180Kn:" 6) <= #fn("r1DIb6862086>1_486<^1808162:" #(#fn("A281S;JS0481<80L2;J60480V350D9:90<81<81=62:" 7)) 7)
> #fn("r1DIb6862086>1_486<^1808162:" #(#fn("A281S;JJ0481<80L2;3>0490<81<81=62:" 7)) 7)
>= #fn("r1DIb6862086>1_486<^1808162:" #(#fn("A281S;JS048081<L2;J60480V350D9:90<81<81=62:" 7)) 7)
Instructions #table(call.l #u8(75)  trycatch #u8(65)  loadg.l #u8(68)  aref2 #u8(23)  box #u8(50)  argc #u8(17)  setg #u8(25)  cadr #u8(36)  load0 #u8(21)  nan? #u8(38)  fixnum? #u8(41)  div0 #u8(59)  keyargs #u8(31)  call #u8(5)  loada.l #u8(69)  num? #u8(40)  sub2 #u8(62)  add2 #u8(29)  loadc.l #u8(70)  loadc #u8(9)  builtin? #u8(43)  set-car! #u8(47)  vargc.l #u8(80)  vec #u8(63)  ret #u8(10)  loadi8 #u8(22)  tapply #u8(74)  shift #u8(46)  atom? #u8(24)  cdr #u8(13)  brne.l #u8(77)  / #u8(58)  equal? #u8(52)  apply #u8(54)  dup #u8(11)  jmp.l #u8(48)  bounda #u8(39)  = #u8(60)  not #u8(35)  set-cdr! #u8(30)  fn? #u8(44)  eq? #u8(33)  * #u8(57)  load1 #u8(27)  bound? #u8(42)  box.l #u8(1)  < #u8(28)  brnn.l #u8(78)  jmp #u8(16)  loadv #u8(2)  loade8 #u8(20)  + #u8(55)  brne #u8(19)  argc.l #u8(79)  compare #u8(61)  brn #u8(3)  neg #u8(37)  loadv.l #u8(67)  vargc #u8(66)  setg.l #u8(72)  cons? #u8(18)  aref #u8(0)  sym? #u8(34)  aset! #u8(64)  car #u8(12)  cons #u8(32)  tcall.l #u8(76)  - #u8(56)  brn.l #u8(49)  optargs #u8(71)  closure #u8(14)  vec? #u8(45)  pop #u8(4)  eqv? #u8(51)  list #u8(53)  seta #u8(15)  seta.l #u8(73)  brnn #u8(26)  loadg #u8(7)  loada #u8(8)  tcall #u8(6))
S #fn("r1708021D953863908681z2:72238062:" #(getprop constructor error "no default constructor for struct: ") 8)
__finish #fn("A120Z3?0212280>17062:D9:" #(*exit-hooks* #fn(for-each)
#fn("A1809061:" 6)) 7)
__init_globals #fn("A0F8I04FpI1422I34D9I4475I6477I8479I:47;2<d3702=@402>I?47@7;2A523702B@402CID:" #(*exception-print-level*
*exception-print-length* "\n" *linefeed* *exit-hooks* *stdout* *io-out* *stdin* *io-in* *stderr*
*io-err* +os-name+ "macos" #fn("A0702161:" #(princ "\e[0m\e[1m#;> \e[0m") 6)
#fn("A0702161:" #(princ "#;> ") 6) *prompt* member ("dos" "windows") "\\" "/"
*directory-separator*) 7)
__rcscript #fn("A0708421c370D9@U08422c37023@H08424c3>07526514D9@4027^184;3904288451708622c37029@402:^185;3=042;857<865387;3D042=8751;39047>8761:" #(+os-name+
"unknown" "plan9" "home" "macos" princ "\e]0;StreetLISP v0.999\a" "HOME" #fn(os-getenv) "lib/slrc"
".slrc" #fn(str) *directory-separator* #fn(path-exists?) load) 11)
__script #fn("A12080>121q:" #(#fn("A0709061:" #(load) 6)
#fn("A1708051421727374I2475I34268687>22780>12888>1q88504^1^261:" #(top-level-exception-handler
#fn(exit) *print-level* *print-length* *exception-print-level* *exception-print-length*
#fn("A090I0491I1:" #(*print-level* *print-length*) 4)
#fn("A0209061:" #(#fn(str)) 6) #fn("A190504208061:" #(#fn(raise)) 6)) 10)) 4)
__start #fn("A27050480I1481I2480=B3B080=I147380T51@60DAI24723>0745047550@40D942660:" #(__init_globals
*argv* *interactive* __script __rcscript repl #fn(exit)) 6)
abs #fn("A180EL236080U:80:" 6) add-exit-hook
#fn("A18070PI047160:" #(*exit-hooks* void) 6) any #fn("A281B;3H048081<51;J<04708081=62:" #(any) 7)
append #fn("r0DIDIb5b6852085>1_486218685>2_4D9D9P86<878052487=:" #(#fn("A281J5080:81<D9P8086N490<8681=62:" copy- 8)
#fn("A281=370D9@<08081<N4DI:490<91<8081<5281=62:" append- 8)) 10)
arg-counts #table(bound? 1  sym? 1  car 1  cons 2  cadr 1  nan? 1  fixnum? 1  atom? 1  cdr 1  div0 2  vec? 1  equal? 2  eqv? 2  compare 2  not 1  set-cdr! 2  num? 1  fn? 1  set-car! 2  eq? 2  cons? 1  builtin? 1)
arg-error #fn("r0202180P61:" #(#fn(raise) arg-error) 7) argc-error
#fn("A27080218181Kl237022@402364:" #(compile-error " expects " " argument." " arguments.") 10)
args_auto41# #:args_auto41# args_auto53# #:args_auto53# arr?
#fn("A180];JG0420805185B;390485<21Q:" #(#fn(type-of) arr) 7) assoc #fn("A270815180d36081<:813<0718081=62:D9:" #(caar
assoc) 7)
assoc-list #fn("r080=85B3B080<85<P7085=f2P:D9:" #(assoc-list) 8) assv
#fn("A270815180c36081<:813<0718081=62:D9:" #(caar assv) 7) b_auto22# #:b_auto22#
b_auto34# #:b_auto34# bcode:indexfor
#fn("A280KG80F2G208681523;021868162:228681875348780F287KMp4:" #(#fn(has?)
#fn(get)
#fn(put!)) 11)
bcode:stack #fn("A280F4G81M80F5G86L23<080F586p@40D9480F486p:" 8) bounds-error
#fn("r22021228081825461:" #(#fn(raise) #fn(list*) bounds-error) 10) box-vars #fn("A2DIb686208086>2_486<^18161:" #(#fn("A180B3W080<T3D07090217280<5153@40D9491<80=61:D9:" #(emit
box caddr) 9)) 6)
bq-bracket #fn("A280H3?07071808152e2:80<22CW081El23907080=P:7073247180=81Kn52e3e2:80<25CX081El23:02680Te2:7070277180T81Kn52e3e2:80<28CT081El236080T:7070297180T81Kn52e3e2:7071808152e2:" #(list
bq-process unquote cons 'unquote unquote-splicing copy-list 'unquote-splicing unquote-nsplicing
'unquote-nsplicing) 11)
bq-bracket1 #fn("A280B3X080<20CP081El236080T:71227380=81Kn52e3:73808162:" #(unquote
cons 'unquote
bq-process) 10)
bq-process #fn("A2DI20?6480R3902180e2:80]3V072738051815287<74C907587=P:767587e3:80H35080:80<27CD074287280T81KM52e3:80<29C[081El23A07:80F25236080T:7;2<7280=81Kn52e3:7=868052Jy07>80512?2@81>1805287J807488P:88=JB07;88<72878152e3:2A7B88P72878152e162:DIb7872C8187>2_487<^180D962:" #(#fn("A180B;3\\0480<20Q;JQ0480<21Q;JF0480<22Q;3;047380F252;J8048022Q:" #(unquote-splicing
unquote-nsplicing unquote length>) splice-form? 7) $quote bq-process vec->list list vec apply
quasiquote 'quasiquote unquote length= cons 'unquote any last-cdr #fn(map)
#fn("A170809062:" #(bq-bracket1) 7) #fn(nconc) list* #fn("A280J<020718151P:80B3z080<22C]020738190El238080=@E07425e27680=90Kn52e252P:91<80=7780<905281P62:20717680905281P51P:" #(nconc
reverse! unquote nreconc list 'unquote bq-process bq-bracket) 12)) 12)
builtin->instruction #fn("A1209080D963:" #(#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!  #.vec vec  #.set-cdr! set-cdr!  #.< <  #.cons cons  #.apply apply  #.eqv? eqv?  #.vec? vec?  #.list list  #.car car  #.bound? bound?  #.nan? nan?  #.fn? fn?  #.sym? sym?  #.compare compare  #.aref aref  #.fixnum? fixnum?  #.atom? atom?  #.= =  #.num? num?  #.* *)) 8)
caaaar #fn("A180<<<<:" 5) caaadr
#fn("A180T<<:" 5) caaar #fn("A180<<<:" 5) caadar
#fn("A180<T<:" 5) caaddr #fn("A180=T<:" 5) caadr
#fn("A180T<:" 5) caar #fn("A180<<:" 5) cadaar
#fn("A180<<T:" 5) cadadr #fn("A180TT:" 5) cadar
#fn("A180<T:" 5) caddar #fn("A180<=T:" 5) cadddr
#fn("A180==T:" 5) caddr #6=#fn("A180=T:" 5) call-with-values
#fn("A2805086B3B09086<C:08186=z2:818661:" #() #(#5=(*values*)) 7) capture-var! #fn("A2DIb6862086>1_480F3G86<8187E5388;JI0421875180F3228781e152p4:" #(#fn("A381J50D9:8081<C5082:90<8081=82KM63:" index-of 9)
#fn(length) #fn(nconc)) 13)
cdaaar #fn("A180<<<=:" 5) cdaadr
#fn("A180T<=:" 5) cdaar #fn("A180<<=:" 5) cdadar
#fn("A180<T=:" 5) cdaddr #fn("A180=T=:" 5) cdadr
#fn("A180T=:" 5) cdar #fn("A180<=:" 5) cddaar
#fn("A180<<==:" 5) cddadr #fn("A180T==:" 5) cddar
#fn("A180<==:" 5) cdddar #fn("A180<===:" 5) cddddr
#fn("A180====:" 5) cdddr #fn("A180===:" 5) cddr
#fn("A180==:" 5) closure? #fn("A180\\;370480[S:" 5) compile
#fn("A170D97180725262:" #(compile-f lower-def *interactive*) 9) compile-and #fn("A57080818283DA218467:" #(compile-short-circuit
brn) 12)
compile-app #fn("A483<88R3V070888152JK088Z3E0218851[3;0218851@408889[;39047289517383=24523q0758081D9895447680K52477808183=5376808;U52478808237029@402:8;63:89B3P089<2;CH07<83513?07=8081828364:8:3Z077808183=5376808;U5247>80818283898:8;67:758081D9895447680K52477808183=5389R;3<047?8981E538<2@Q;3A0489Z;39042189517A8=51;39042B8=518>;3A048>EG2C7D2E52l28?;37048>KG8@S;J9048@8;l2370D9@>07F2G8@2H8;54476808;U5247680F/5247880823702I@402J8;63:" #(in-env?
#fn(top-level-value) builtin->instruction length> 255 compile-in bcode:stack compile-arglist emit
tcall.l call.l λ inlineable? compile-let compile-builtin-call lookup-sym global closure? #fn(fn-code)
#fn(get) Instructions argc compile-error "arity error: expected " ", got " tcall call) 18)
compile-arglist #fn("A320218081>282524228261:" #(#fn(for-each)
#fn("A1709091D9805447190K62:" #(compile-in
bcode:stack) 9) #fn(length)) 7)
compile-aset! #fn("A3208251F2n87Kl23B0718081D92282P64:K87L23l0718081D9237482E8753P5447580817482875253768088U52477802262:7822F362:" #(#fn(length)
compile-app aset! aref subseq compile-arglist bcode:stack emit argc-error) 14)
compile-begin #fn("A483H3?070808182DI64:83=H3@07080818283<64:708081D983<5447180225247380818283=64:" #(compile-in
emit pop compile-begin) 9)
compile-builtin-call #fn("A7DI20868580>3?;4217285D9538<3I07383=8<52J=074858<52@40D94858=25CP086El23=0768027F963:7680858663:8=28C708;60:8=29C708;60:8=2:C`086El23;076802;62:86F2l23;076802<62:7680858663:8=2=Cp086El23:07485K62:86Kl23;076802>62:86F2l23;076802?62:7680858663:8=2@CN086El23;076802A62:7680858663:8=2BCM086El23:07485K62:7680858663:8=2CCP086El23=076802D2E63:7680858663:8=2FCY086F2L23;07485F262:7680823702G@402F8663:8=2HCd086F2l23;076802I62:F286L23@076808586F3n63:7485F262:76808562:" #(#fn("A090El23:07091K62:7192919063:" #(argc-error
emit) num-compare 8) #fn(get) arg-counts length= argc-error list emit loade8 < = + load0 add2 -
neg sub2 * load1 / vec loadv #() apply tapply aref aref2) 12)
compile-error #fn("r0702180Pz2:" #(error "compile: ") 7) compile-f
#fn("A270218081>22262:" #(call-with-values #fn("A070909162:" #(compile-f-) 7)
#fn("A280:" 4)) 7)
compile-f- #fn("A2DIDIDIb6b8862086>1_421?74882288>1_4735081T748:518;3<088<8:51@408:75815176778<522879767:8>52527481518@J702;@408@8<H360E@802<8<518B2<8>51n76878>522<8D5186<8=518F3=07=2>8F52@40D948>3~08DJL07?892@8C8;3808BU@408B54@\\07A89282B7C8D535247?892D8C8E8;3808BU@408B55@40D942E8BL23I07?898;3702F@402G8B53@X08;3?07?892H8B53@F08>J?07?892I8B53@40D948>3C07J89808>8=8C55@40D948=8?3?07K8=2L8?53@408=8?3=07K8=8?52@408=7M808H7N7O81518I52537P898J<5247Q892<8I51F4M5247R898JDA7O81515447?892S5247T2U7V89EG517W89518A89F5G2<8G51nDA5589F3G62:" #(#fn("A180<80=863K0702185>18652;J:0490<8661:D9:" #(any
#fn("A19080Q;350490:" 6)) any-duplicates 9) #fn("A180B;3:042080<61:" #(#fn(keyword?)) keyword-arg? 6)
#fn("A180B;3?0480<90<80=51P:" novar 7) make-code-emitter last-cdr lambda:vars filter cons? #fn(map)
caddr cddr λ #fn(length) compile-error "duplicate argument: " emit optargs bcode:indexfor vec car
keyargs 255 vargc.l argc.l vargc argc emit-optional-arg-inits append (NIL NIL NIL NIL) extend-env
complex-bindings lambda:body box-vars bcode:stack compile-in ret values #fn(fn) encode-byte-code
const-to-idx-vec) 33)
compile-if #fn("A420502050205083T718351728351B3;0738351@40D98;DAC?0748081828<64:8;J?0748081828=64:748081D98;895547580268953475802788534748081828<544823=075802852@<07580298:53475802789534748081828=5447580278:63:" #(#fn(gensym)
caddr cdddr cadddr compile-in emit brn label ret jmp) 16)
compile-in #fn("w40005000W4000J70D9?44DI20?9483R3?071808183DA64:83H3\xa5083EC;072802362:83KC;072802462:83J=0728025F963:83DAC=0728025FA63:7683513=0728025FI63:8983513=07280278363:7280288363:83<29C>07:808183=63:83<RS;JE0483<Z;J<047;83<81523?07<8081828364:83<2=Q;J90483<2>Q3\x97083T7?83512@83=518<F2l2370D9@:07A2B8<5248:R370D9@>07C2D8:2E2F5448:8;C;07A2G51@40D947H80818:8;83<2=Q65:83<8:2ICV07J83T513@07K80818283T64:72802883T63:8:2LC?07M8081828364:8:2NC@07O80818283=64:8:2PC=07Q80818363:8:2RCG07S2T8183>22U8081>262:8:2VCB07W80818283=8465:8:2XC@07Y80818283=64:8:2ZCG07[808183T2N7\\8351P64:8:2]CU07K8081DA83=B38083T@40DI54472802^62:8:2_C`07K8081D92RD983Te35447K8081D97?835154472802`62:7<8081828364:" #(#fn("A180Y;3=0470F\xaf80F\xb063:" #(>=) fits-i8 8)
compile-sym emit load0 load1 loade8 void? loadi8 loadv aset! compile-aset! in-env? compile-app
$set! $set!- caddr #fn(length) compile-error "set!: arity error: expected 2, got " type-error sym
"set!" "name" "set!: useless assignment to itself" compile-set! $quote self-evaluating?
compile-in $if compile-if $begin compile-begin $prog1 compile-prog1 λ call-with-values #fn("A070909162:" #(compile-f-) 7)
#fn("A270902180534813P022239091>28152470902425815163:D9:" #(emit loadv #fn(for-each)
#fn("A170909180D964:" #(compile-sym) 9)
closure #fn(length)) 9) $and
compile-and $or compile-or $while compile-while cddr $return ret $trycatch trycatch) 15)
compile-let #fn("A483<83=80F4G88T7080818953718;727388518;528:5374808=524258=81<5281=P76808>8273885154477808<U524E8<L23B082J=07880298<63:D9:" #(compile-arglist
vars-to-env complex-bindings caddr box-vars #fn(nconc) compile-in bcode:stack emit shift) 17)
compile-or #fn("A47080818283D921D967:" #(compile-short-circuit brnn) 12) compile-prog1
#fn("A3708081D982T544718251B3]07280K524738081D97182515447480255247280F/62:D9:" #(compile-in
cddr bcode:stack compile-begin emit pop) 10)
compile-set! #fn("w40005000W4000J70D9?44708281E538921Cc0843C082ZJ=072238252@40D94748081D9835447580268263:89=T89<El28;3<07789=51@:0788082528:3n075808;37029@402:8<5347;80K524748081D9835447;80F/52475802<62:748081D9835448;370D9@>07=2>2?825251475802@8<63:" #(lookup-sym
global compile-error "undefined variable: " compile-in emit setg vinfo:index capture-var! loada
loadc bcode:stack set-car! error #fn(str) "internal error: misallocated var " seta) 13)
compile-short-circuit #fn("A783H3A070808182848665:83=H3B07080818283<8665:86;J7042150708081D983<865547280K52486370D9@:07380245247380858;5347280F/52486370D9@:07380255247680818283=84858657486350D9:7380278;63:" #(compile-in
#fn(gensym) bcode:stack emit dup pop compile-short-circuit label) 13)
compile-sym #fn("A4DI20?84718281E538922C~02382513j088248251513]07526822753;J=047528822953JA07:802;24825163:7:802<8263:89<El23Z07:802=7>89=51534833B089=T3;07:802?62:D9:7:802@7A808252534833B089=T3;07:802?62:D9:" #(#fn("A1208051;JD04718051;J904228051S:" #(#fn(io?)
void? #fn(eof?)) printable? 6) lookup-sym global #fn(const?)
#fn(top-level-value) <= *a *z +a +z emit loadv loadg loada vinfo:index car loadc capture-var!) 12)
compile-thunk #fn("A170D921D972807352e362:" #(compile-f λ lower-def *interactive*) 11)
compile-while #fn("A420502050718081D9DI5447280K52473802488534718081D982544738025895347380265247280F/524718081D983544738027885347380248963:" #(#fn(gensym)
compile-in bcode:stack emit label brn pop jmp) 11)
complex-bindings #fn("A220502050718081D9D98687564722386>174875162:" #(#fn(table)
complex-bindings-
filter #fn("A120908062:" #(#fn(has?)) 7)
table-keys) 13)
complex-bindings- #fn("A6DIb:8:208:>1_481J50D9:80R3P0833H0218081523=0228480DA63:D9:80H;J904738051350D9:80<24Q;J90480<25Q3z02180T81523V0228580TDA534833@0228480TDA53@40D9@40D947677805181D983848566:80<28CZ0767980518:<817:805152D982S;J50483848566:7680<817;8051838485562<2=81838485>480=52P:" #(#fn("A280J50D9:2080<81523=090<80=8162:80<90<80=8152P:" #(#fn(memq)) diff 8)
#fn(memq) #fn(put!) quoted? $set! $set!- complex-bindings- caddr λ lambda:body lambda:vars
inlineable? #fn(map) #fn("A1708090D991929366:" #(complex-bindings-) 11)) 12)
const-to-idx-vec #fn("A12080F2G51212285>180KG52485:" #(#fn(vec-alloc)
#fn(for-each)
#fn("A2908180p:" 7)) 9)
copy-list #fn("w10002000W1000J70D9?14DIb6862086>1_4D9D9P86<87808153487=:" #(#fn("A382;3@0482El2;3604DI:481370D9@50DI:481<D9P8087N490<8781=82;390470825163:" #(1-) copy- 10)) 10)
copy-table #fn("A12050212285>1D98053485:" #(#fn(table)
#fn(table-fold)
#fn("A32090808163:" #(#fn(put!)) 8)) 9)
copy-tree #fn("A180H35080:7080<517080=51P:" #(copy-tree) 7) count
#fn("A2DIb686208680>2_486<81E62:" #(#fn("A2803N090<80=9180<5139081KM@408162:81:" count- 8)) 8)
div #fn("A28081k80EL2;3E0481EL2;3404K;J504F/;J404EM:" 7) e_auto36# #:e_auto36#
e_auto37# #:e_auto37# e_auto48# #:e_auto48# e_auto49# #:e_auto49# emit
#fn("r2DI20?7480EG82Jp08121CB088<22C:08823_@V08124CF08788<513<080E88=p@;080E8188Pp@\xed0258126523B0778082<52e1?2@40D9428812952893D02:82<L23:089T?1@40D9^1428812;52893D02:82<L23:089T?1@40D9^1488<812<Q;3e04892=CC080E82<2>88=PPp@L0892?CC080E82<2@88=PPp@40D9;JB0480E7A8182P8852p^1480:" #(#fn("A120802162:" #(#fn(memq)
(load0 load1)) load? 7) 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)) brn not brnn eq? brne nreconc) 12)
emit-optional-arg-inits #fn("A582B3\xb402050718022845347382513=071802452@40D9471802589534768077817883E8453D953D979825154471802:8453471802;52471802<895347=808182=8384KM65:D9:" #(#fn(gensym)
emit bounda cddar dup brnn compile-in extend-env subseq cadar seta pop label
emit-optional-arg-inits) 13)
encode-byte-code #fn("A17080517185512286517387F387F2ki2M2452255025502650D9D9EDI8>87L23\xc814868>G?<48<27CP02889868>KMG298;515348>F2M?>@\x9712:8;2;7<883k08<8C2=C702>@X08C2?C702@@L08C2AC702B@@08C2CC702D@408<^1@408<525248>KM?>48>87L2;3804868>G?=42E8<2F523`0288:298;518=5342:8;883707G@407HE515248>KM?>@\xf708<2ICJ02:8;2J8=512K5348>KM?>@\xd808=X3\xd008<2E8?2L523J02:8;2J8=512K5348>KM?>@\xa602E8?2M523\x8802:8;2J8=512K5348>KM?>42:8;2J868>G512K5348>KM?>48<2NCM02:8;2J868>G512K5348>KM?>@40D9@E02:8;2O8=515248>KM?>^1@40D9@\x93.42P2Q8;8889>38:5242R8;512S8;514:" #(reverse!
list->vec #fn(length) >= 65536 #fn(table) #fn(buffer) label #fn(put!)
#fn(size-of) #fn(io-write) #fn(get) Instructions jmp jmp.l brne brne.l brnn brnn.l brn brn.l #fn(memq)
(jmp brne brnn brn) s32 s16 bounda #fn(s32) :little-endian (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(u8)
#fn(for-each) #fn("A220908052421909137072@40732492815280n512563:" #(#fn(io-pos!)
#fn(io-write) s32 s16 #fn(get)
:little-endian) 10)
#fn(io->str) #fn(io-close)) 21)
error #fn("r0202180P61:" #(#fn(raise) error) 7) eval
#fn("A1707180515160:" #(compile-thunk macroexpand) 7) even? #fn("A12080K52El2:" #(#fn(logand)) 7)
every #fn("A281S;JH048081<51;3<04708081=62:" #(every) 7) expand-def
#fn("A180T708051B3;0708051@I085R37021@>072237480515285R3<0258586<e3:2585<2627e185=e18685<54e3:" #(cddr
#3# compile-error "invalid syntax " print-to-str $set!- #fn(nconc) λ) 13)
extend-env #fn("A3708182E5380P:" #(vars-to-env) 8) filter
#fn("A2DI2080>1?648681D9e162:" #(#fn("A281DI80B3W049080<513A08180<D9PN=?1@40D9480=?0@\a/4=:" filter- 8)) 8)
find #fn("O200050007000W2000J7071?24W3000J7072?34W4000J60E?44W5000J70D9?54W6000J70D9?6473248380>28125822684278528866::" #(#(:key
:test :start :end :from-end) identity equal? find-if #fn("A190918062:" 7) :key :start :end
:from-end) 15)
find-if #fn("O200040006000W2000J7071?24W3000J60E?34W4000J70D9?44W5000J70D9?54DIb:8:2280828:>3_483El23A084J<085J70D9@Q07381838453?14853=0748151?1@40D948:<8161:" #(#(:key
:start :end :from-end) identity #fn("A180S;J>04909180<515136080<:92<80=61:" find-if- 7) subseq
reverse!) 9)
fn-disasm #fn("O100030004000W1000J70D9?14W2000J70DA?24W3000J70D9?34DIDIDIDIb:b;21?8422?948:23_48;24_480[3E0752681275347860:@40D9483JL079802:812;822<E5747860:@40D942=80512>8051DIDI2?8283>2?>42@81838:828;>5??4E2A8<51b@DI8@<8AL23\x1a242B2C8<8@>2D97D53E8@<L23907850@40D942EE83DI8D8EL23G048D752F51^148DKM?D@\x14/^2514DI48@8@<KM_48B2G8C2H523[08?8B8@<F45348>8=888<8@<52G5148@8@<F4M_@\x8322G8C2I523V08?8B8@<K5348>8=8<8@<GG5148@8@<KM_@T28C2JC~08?8B8@<K534758<8@<G8EF9c370D9@N08EFAc370DA@A08EFIc370DI@40D9^15148@8@<KM_@\x0112G8C2K523a08?8B8@<K534758<8@<G8B2LC70F3@30EM5148@8@<KM_@\xc718C2MCW08?8B8@<K534752N8<8@<G515148@8@<KM_@\x9b12G8C2O523X08?8B8@<F453475888<8@<525148@8@<F4M_@j12G8C2P523\xad08?8B8@<F88B2QC70F4@30EM53475888<8@<522R5248@8@<F4M_475888<8@<525148@8@<F4M_48B2QCU0752R51475888<8@<522R5248@8@<F4M_@40D9@\xe408C2Sc3Z08?8B8@<F453475888<8@<522R5248@8@<F4M_@\xb402G8C2T523c08?8B8@<F2534752U8:<8@<898<8@<52M515248@8@<F2M_@x02G8C2V523c08?8B8@<F4534752U8:<8@<888<8@<52M515248@8@<F4M_@<08?8B8@<E53^1^1@@-:" #(#(:ip
:readable :level) #fn("A220218081EMGE52218081KMGF852218081F2MGF@52218081F3MGFH52g461:" #(#fn(s32)
#fn(ash)) ref-s32-LE 12) #fn("A220218081EMGE52218081KMGF852M61:" #(#fn(s16)
#fn(ash)) ref-s16-LE 10)
#fn("A170718022F@53F52324252666:" #(str-pad num->str :base :align :right :fill #\0) hex5 11)
#table(call.l call  box.l box  loadg.l loadg  aref2 "aref 2"  tcall.l tcall  brn.l brn  load0 "loadi8 0"  brnn.l brnn  brne.l brne  loada.l loada  jmp.l jmp  argc.l argc  loadv.l loadv  seta.l seta  sub2 "sub 2"  add2 "add 2"  loadc.l loadc  setg.l setg  vargc.l vargc  load1 "loadi8 1")
princ " > " " // PC" newline fn-disasm :ip :readable :level #fn(fn-code)
#fn(fn-vals) #fn("A180\\3R080[JL070504718022D923902491KM67:758061:" #(newline fn-disasm :ip
:readable :level print) print-val 13)
#fn("A370903Z091El23R07190728151523C0908182ML237023@402492<81Kn5125933@02694<808053@40802765:" #(princ
>= 1- " >" "  " ":  " #fn(get) " ") print-inst 12)
#fn(size-of) #fn(table-fold) #fn("A382;JD04819091<Gl2;350480:" 7) Instructions #3# "\t" #fn(memq)
(loadv.l loadg.l setg.l) (loadv loadg setg) loade8 (loada seta loadc call tcall list + - * / < =
vec argc vargc apply tapply closure box shift
aref) aref loadi8 #fn(s8)
(loada.l seta.l loadc.l argc.l vargc.l call.l tcall.l box.l) (optargs keyargs) keyargs " " bounda
(jmp brne brnn brn) "@" (jmp.l brne.l brnn.l brn.l)) 23)
foldl #fn("r22082512172875151DIb9892388878980>4_489<E818263:" #(#fn(length)
#fn(vec-alloc) 1+ #fn("A3DIb78720908087>3_4712280>18252J5081:909181p487<E8252492<7380519390f22425825263:" #(#fn("A281;3z0481<908086];J9047086513:08691G@I02186513=022869152@5086<p492<73805181=62:" #(arr?
#fn(str?) #fn(str-rune) 1+) copy-args 10) every #fn("A170805135080:90218051L2:" #(list? #fn(length)) 7)
1+ #fn(map) #fn("A170805136080=:80:" #(list?) 6)) foldl- 11)) 11)
foldl1 #fn("A281];J9047081513D0718081EG7281K5263:2381513G071802481E527281K5263:718081<81=63:" #(arr?
foldl subseq #fn(str?) #fn(str-rune)) 10)
foldr #fn("r22082512172875151DIb9892388878980>4_489<E818263:" #(#fn(length)
#fn(vec-alloc) 1+ #fn("A3DIb78720908087>3_4712280>18252J5081:909192<738051812425825253p487<E825249390z2:" #(#fn("A281;3z0481<908086];J9047086513:08691G@I02186513=022869152@5086<p492<73805181=62:" #(arr?
#fn(str?) #fn(str-rune) 1+) copy-args 10) every #fn("A170805135080:90218051L2:" #(list? #fn(length)) 7)
1+ #fn(map) #fn("A170805136080=:80:" #(list?) 6)) foldr- 13)) 11)
foldr1 #fn("A281];J9047081513D0718081EG7281K5263:2381513G071802481E527281K5263:718081<81=63:" #(arr?
foldr subseq #fn(str?) #fn(str-rune)) 10)
for #fn("A3208081DI8889L23C04828851488KM?8@\x18/^261:" #(#3#) 10) get-defined-vars
#fn("A1DIb5852085>1_47185<805161:" #(#fn("A180H350D9:80<20Cj080=B3c080TR;380480Te1;JP0480TB;3G04718051R;3;04718051e1:80<22CA0732490<80=52z2:D9:" #($def
caadr $begin nconc #fn(map)) 8) remove-duplicates) 8)
get-reader-macro #fn("w10002000W1000J7070?147180513=0228051?0@40D947324818053258651;3>042686D9D953=:" #(*read-table*
rune? #fn(str) foldl #fn("A281;3=04208180D963:" #(#fn(get)) 8)
#fn(table?) #fn(get)) 9)
get-syntax #fn("A1207180D963:" #(#fn(get) *syntax-environment*) 8) getprop
#fn("w20003000W2000;J70D9?24207181D953873K088;3=042088808253;J50482:883F0228880523;020888062:232481e261:" #(#fn(get)
*properties* #fn(has?) #fn(raise) key-error) 10)
help-print-header #fn("O200020004000W2000J70D9?24W3000J7021?34DIDIb8b988228880>2_48923_4813G0242589808388>48152@`07683514823A0767780512852@@0798051488<805147:5047:60:" #(#(:kind
:lpad) "" #fn("A19070_4712280RJ;0238051@[080R3E080Z3?02324915151@B075805137026@40272863:" #(void
princ " ;; [" #fn(type-of) #fn(top-level-value) get-syntax "macro" "any" "]") print-type 9)
#fn("A120502185>1228085>22386>1q86504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A07071DAI04D9I14228485>2239091>22486>1q86504^1^24259161:" #(*print-readably*
*print-pretty* #fn("A090I0491I1:" #(*print-readably* *print-pretty*) 4)
#fn("A020909162:" #(#fn(write)) 7) #fn("A190504208061:" #(#fn(raise)) 6)
#fn(io->str)) 9) #fn("A190504208061:" #(#fn(raise)) 6)) term->str 8)
#fn(for-each) #fn("A190<9180P51205071D9I142287>123909180>32488>1q88504^1^1759251475855148587d370D9@:075268752493<915147760:" #(#fn(buffer)
*print-syntax-sugar* #fn("A090I0:" #(*print-syntax-sugar*) 4)
#fn("A090<9192P61:" 7) #fn("A190504208061:" #(#fn(raise)) 6) princ " | " newline) 10) princ caddr
" ;; [doc group]" print newline) 9)
i_auto14# #:i_auto14# i_auto26# #:i_auto26# identity
#fn("A180:" 4) in-env? #fn("A281B;3J04208081<52;J<04718081=62:" #(#fn(assq) in-env?) 7)
inlineable? #fn("A180<85B;3u0485<20Q;3j047185T51;3^04727385T52;3P047485T2552S;3A047685T2780=5162:" #(λ
proper-list? every sym? length> 255 length= #fn(length)) 9)
io-read-all #fn("A120502185>1228580>22386>1q86504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A0209091524219061:" #(#fn(io-copy)
#fn(io->str)) 7) #fn("A190504208061:" #(#fn(raise)) 6)) 8)
io-read-line #fn("A120802162:" #(#fn(io-read-until) #\newline) 7) io-read-lines
#fn("A170718062:" #(read-all-of io-read-line) 7) iota #fn("w10003000W1000J60E?14W2000J60K?2470218182>28062:" #(map-int
#fn("A1908091i2M:" 7)) 7)
iterate #fn("A3E82L2;3F0481708080815182Kn53P:" #(iterate) 10) lambda-vars
#fn("A1DIDIb5b68520_4862186>1_486<8080D9D9544222385>174805162:" #(#fn("A12080513F0212280512386K52^161:80:" #(#fn(keyword?)
#fn(sym) #fn(str) #fn(str-sub)) keyword->sym 9) #fn("A480S;JB0480R;3:04208051S350DA:80B3i080<R3b02080<51JX082;J504833=07122812363:90<80=81828364:80B3\xb7080<B3\xb00748051R3]07580<F252;JH047580<F352;3:04768051R370D9@?0712780<288154420748051513A090<80=8182DA64:833=07122812963:90<80=81DA8364:80B3@0712:80<288164:8081C;071228162:712:80288164:" #(#fn(keyword?)
compile-error "invalid argument list " ": optional arguments must come after required" caar
length= caddar "invalid optional argument " " in list " ": keyword arguments must come last."
"invalid formal argument ") check-formals 9) #fn(map)
#fn("A180B3;090<80<61:80:" 6)
to-proper) 11)
lambda:body #fn("A1708061:" #(caddr) 6) lambda:vars
#fn("A17080T61:" #(lambda-vars) 6) last-cdr #fn("A180H35080:708051=:" #(last-pair) 6)
last-pair #fn("A180=H35080:7080=61:" #(last-pair) 6) length<
#fn("A2708081Kn52S:" #(length>) 8) length= #fn("A281EL2350D9:80B3>07080=81Kn62:21805181l2:" #(length=
#fn(length)) 8)
length> #fn("A281EL2350DA:80B3>07080=81Kn62:81218051L2:" #(length> #fn(length)) 8)
list->vec #fn("A17080z2:" #(vec) 6) list?
#fn("A180S;J60480B:" 5) load #fn("w10002000W1000J7070?142180518637080@:02280235224878186>3258687>2q:" #(eval
#fn(io?) #fn(file) :read #fn("A0DIb4842090849192>4_484<^1DIDIDI63:" #(#fn("A3209051JJ091<21905180729281515163:7293370D9@8023905192815162:" #(#fn(io-eof?)
#fn(read) void #fn(io-close)) 10)) 8) #fn("A190370D9@802091514212280e261:" #(#fn(io-close)
#fn(raise)
load-error) 7)) 8)
lookup-sym #fn("A381J5020:81<21808752883808288P:728081=82KM63:" #(global #fn(assq)
lookup-sym) 11)
loop_auto29# #:loop_auto29# loop_auto41# #:loop_auto41# lower-def
#fn("w10002000W1000J70D9?14DI20?6480H;J90471805135080:80<22CQ0813A0237475805151e2:7475805161:80<26CN02726e180Te1868051e178805164:29748062:" #(#fn("A1708051B3Q0718051B3>022708051P@80738051@40DI748551758551863D0268687e327788652P:87:" #(cddr
cdddr $begin caddr get-defined-vars lower-def λ #fn(map) void) λ-body 11) quoted? $def #3#
lower-def expand-def λ #fn(nconc) last-cdr #fn(map)) 11)
macrocall? #fn("A180B;3:047080<61:" #(get-syntax) 6) macroexpand
#fn("A1DIDIDIDIDIDIDIDIDIb5b6b7b8b9b:b;b<b=8520_4862186>1_48722e1_4882385868=87>4_489248=89>2_48:258:>1_48;268:8988>3_48<278=8:8988>4_48=288=8;8<>3_48=<80D962:" #(#fn("A280Z;J;0420808152S:" #(#fn(assq)) top? 7)
#fn("A180H35080:8020d35080:80<B3U071805122CJ07390<7480515190<80=5162:80<90<80=51P:" #(((begin))
caar begin
append cdar) splice-begin 8)
*expanded* #fn("A280H35080:90<2081523<091<8051@408090<21815287;390472865123247588528152b987JA024269289>28662:DIb:8:278:928993>4_48:<^186518:DI8;B3b0493<788;51C>08;798;51_@@08;92<8;<89<52_48;=?;@\xfc/48::" #($begin
$def get-defined-vars #fn(nconc) #fn(map) list #fn("A190<8091<62:" 7)
#fn("A180H35080:80<B3J020718051C?080<90<80=51P:91<80<92<52922223747585515292<52_493<85P90<80=51P:" #($def
caar #fn(nconc) #fn(map) list get-defined-vars) 11) caar cdar) expand-body 14)
#fn("A280H35080:80<B3X080<=B3P070805190<7180518152728051PP@5080<91<80=8152P:" #(caar cadar cddar) expand-lambda-list 8)
#fn("A180H37080e1:80<B3B070805190<80=51P:80<90<80=51P:" #(caar) l-vars 7)
#fn("A280T70805171805190<80T51222374895281522225e191<868:52e192<888:5276875164:" #(last-cdr cddr
#fn(nconc)
#fn(map) list
λ copy-list) expand-lambda 15)
#fn("A280=S;J70480TH3u0708051J5080:80T717080515187<87=883=072868852@40D94238690<89<8152e3:748051758051717080515188<88=91<86512627788;528152893?07287898653@40D942623e18792<868<52Pe193<8:8<5263:" #(cddr
separate-doc-from-body set-doc! $def cdadr caadr #fn(nconc)
#fn(map) list) expand-define 17) #fn("A280H35080:80<2086815221908180>3728051893A090<8980=f28162:87;J?0486RS;J60486Z3708860:8623C5080:8624C<091<808162:8625C<092<808162:8860:" #(#fn(assq)
#fn("A0DIb48420909184>3_484<^19261:" #(#fn("A180H35080:80<H38080<@<090<80<915292<80=51P:" 7)) 6)
macrocall? $quote λ $def) expand-in 11)) 16)
macroexpand-1 #fn("A180H35080:708051853:08580=z2:80:" #(macrocall?) 7)
make-code-emitter #fn("A0D92050ED9EEo6:" #(#fn(table)) 10) make-system-image
#fn("A1DI20?542180222324547585762750785252792:7;872:7<875253f27=7>7?7@DAI=4DAI>4DAI?4D9I@42A898:8;8<>42B8886>22C8=>1q8=504:" #(#fn("A1202122808552;J\x940480Z;3\x8c04238051S;3\x8004248051[S;JE042580512524805151dS;3\\0422808652S;3N047627802853S;3>042924805151S:" #((*syntax-environment*
*properties* *builtins*) (ptr) #fn(memq) #fn(const?)
#fn(top-level-value) #fn(str) <= *a *z #fn(io?)) save? 10)
#fn(file) :write :create :truncate filter sort #fn(environment) < nconc #fn(map) list
top-level-value *print-pretty* *print-readably* *print-circle* that #fn("A090I0491I1492I2493I3:" #(*print-pretty*
*print-readably* *print-circle* that) 4) #fn("A0209091524219161:" #(#fn(write)
#fn(io-close)) 7)
#fn("A190504208061:" #(#fn(raise)) 6)) 15)
map-int #fn("A2E81L2;3u0480E51D9P8620K81DI898:L23S048987808;51D9PN487=?7^1489KM?9@\b/^251486:" #(#4=#fn("r0DI:" void 4)) 13)
max #fn("r1813=07021808163:80:" #(foldl #fn("A28081L235081:80:" 6)) 8) member
#fn("A281<80d35081:813<0708081=62:D9:" #(member) 7) memv #fn("A281<80c35081:813<0708081=62:D9:" #(memv) 7)
min #fn("r1813=07021808163:80:" #(foldl #fn("A28081L235080:81:" 6)) 8) mod
#fn("A2807080815281i2n:" #(div) 8) mod0 #fn("A2808081k81i2n:" 7) n_auto14# #:n_auto14#
n_auto26# #:n_auto26# negative?
#fn("A180EL2:" 6) newline #fn("w00001000W0000J7070?04218072524DI:" #(*io-out* #fn(io-write)
*linefeed*) 7)
nreconc #fn("A270818062:" #(reverse!-) 7) nth
#fn("A270808152<:" #(nthcdr) 7) nthcdr #fn("A27081E5235080:7180=81Kn62:" #(<= nthcdr) 8)
num->str #fn("O100010002000W1000J70F:?1480X370D9@:0712280524238151370D9@:071248052475F281FT53370D9@:0762781524238051;J90481F:l2370D9@:0762881524298051S;JN0481F:l2;JC047:2;817<81515251370D9@:0762=815247>7?7@7A7B81I>481I?4D9I@4D9IA4D9IB42C868788898:>52D80>12E8;>1q8;504:" #(#(:base)
type-error num #fn(int?) base <= arg-error "invalid/unsupported base: "
"invalid/unsupported base with floating point: " #fn(bignum?) zero? #fn(logand) 1- "invalid/unsupported base with bignum: "
*print-base* *print-ptr-base* *print-radix* *print-ptr-radix* *print-readably* #fn("A090I0491I1492I2493I3494I4:" #(*print-base*
*print-ptr-base* *print-radix* *print-ptr-radix* *print-readably*) 4)
#fn("A020502184>1229084>22385>1q85504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A0209091524219161:" #(#fn(write)
#fn(io->str)) 7)
#fn("A190504208061:" #(#fn(raise)) 6)) 8)
#fn("A190504208061:" #(#fn(raise)) 6)) 12)
odd? #fn("A1708051S:" #(even?) 6) partition
#fn("A2DI80\\370D9@:07021805242280>1?648681D9D9PD9D9P63:" #(type-error fn #fn("A38182PDI80B3a049080<513A08180<D9PN=?1@>08280<D9PN=?2480=?0@\xfd/47087<=87==62:" #(values) partition- 8)) 10)
positive? #fn("A1E80L2:" 6) princ
#fn("r070D9I042185>12280>12386>1q86504:" #(*print-readably* #fn("A090I0:" #(*print-readably*) 4)
#fn("A020719062:" #(#fn(for-each) write) 7)
#fn("A190504208061:" #(#fn(raise)) 6)) 8)
princ-to-str #fn("r020502185>1228580>22386>1q86504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A07090I042184>12291>12385>1q85504^1^14249061:" #(*io-out*
#fn("A090I0:" #(*io-out*) 4) #fn("A07090z2:" #(princ) 6)
#fn("A190504208061:" #(#fn(raise)) 6) #fn(io->str)) 8)
#fn("A190504208061:" #(#fn(raise)) 6)) 8)
print #fn("r0803b080<80=70DAI042187>1228586>22388>1q88504^1^1^2@40D94DI:" #(*print-readably*
#fn("A090I0:" #(*print-readably*) 4)
#fn("A0209051421229162:" #(#fn(write)
#fn(for-each) #fn("A17021514228061:" #(princ " " #fn(write)) 6)) 7)
#fn("A190504208061:" #(#fn(raise)) 6)) 10)
print-exception #fn("A1DI20?54718051;3Q047180<51;3E042273805151;360480<8638080=@408087;3G0487B;3?0487<R;360487<88;360487=863O0742586<512686T267786512856@40D948829Ce0742:5142;2<7=8951524742>89<2?2@89T51285548589T51@\x111882AC\\0742B5142;2C7=8951524742D89T2E5348589<51@\xe01882FCV0742G89<2H5347I89<513;0742J51@40D9@\xb51882KCB0742L5147489f2@\x9e1882MC@07N89<514DI:@\x891882OCB0742P5147489f2@r1882QCB0742R5147489f2@[1882SC\xbf0742T51489<89T7789518<8=2UC=0748:2V52@Z08=2WC=0748:2X52@H08=2YC;0742Z51@80748:51^14742?7[8;513702\\@408;52^347]89513F07428514857]8951f2@40D9@\xc70882^CC0742_5148589<51@\xaf0882`CR0742a89<513702b@402c5148589<51@\x880882dCB0742e5147489f2@q0882fCB0742g5148589f2@Z0882hQ;J804882iQ3;07489f2@?0742j51485875147k60:" #(#fn("A1707172I0473I14248586>22580>12687>1q87504:" #(*print-level*
*print-length* *exception-print-level* *exception-print-length*
#fn("A090I0491I1:" #(*print-level* *print-length*) 4)
#fn("A0709061:" #(print) 6) #fn("A190504208061:" #(#fn(raise)) 6)) print-value 9) list? #fn(io?)
caar princ #fn(io-filename) ":" caddr ": " type-error "type error: " #fn(for-each)
#fn("A170802162:" #(princ ": ") 7) cddr "expected " ", got " #fn(type-of) bounds-error "out of bounds: "
#fn("A170802162:" #(princ ": ") 7) "index " " for " unbound-error "eval: variable " " has no value"
get-syntax " (defined as a macro)" error "error: " load-error print-exception parse-error "parsing error: "
arg-error "arguments error: " arity-error "arity error: expected " :min " or more" :max " or less"
:extra " no extra" zero? "none" cdddr key-error "key not found: " const-error #fn(keyword?)
"keywords are read-only: " "tried to modify a constant: " io-error "I/O error: " assert-failed "assertion failed: "
divide-error memory-error "*** unhandled exception: " newline) 16)
print-stack-trace #fn("A1DIDIb5b6852085>1_4862185>1_4727374I2475I34268788>2278680>22889>1q89504:" #(#fn("A320805182P218051218151C?022232487e361:25805126E278851DI8:8;L23`048:78888<G513C090<888<G818753@40D9^148:KM?:@\xfb/^261:" #(#fn(fn-name)
#fn(fn-code) #fn(raise) thrown-value ffound #fn(fn-vals)
#3# #fn(length) closure?) find-in-f 14) #fn("A220908081>321q863E0722374758651522662:80[390278061:28:" #(#fn("A020219091>292524D9:" #(#fn(for-each)
#fn("A190<8091D963:" 8)) 7) #fn("A180B3I080<20CA080T21C90728061:238061:" #(thrown-value ffound
caddr #fn(raise)) 6)
str-join #fn(map) str reverse! "/" #fn(fn-name) "λ") fname 10) *print-level* *print-length*
*exception-print-level* *exception-print-length* #fn("A090I0491I1:" #(*print-level*
*print-length*) 4)
#fn("A07071222324505252Eb52526908485>377915162:" #(filter closure? #fn(map)
#fn("A180Z;3904208061:" #(#fn(top-level-value)) 6)
#fn(environment)
#fn(for-each)
#fn("A1702190<80KG915252422F2238051DI8687L23Q04867024514758088G51^1486KM?6@\n/^251470267752492<El23C07880KG2980EG53@40D949292<KM_:" #(princ
"(" #3# #fn(length) " " print ")" *linefeed* fn-disasm :ip) 11) reverse!) 10)
#fn("A190504208061:" #(#fn(raise)) 6)) 11)
print-to-str #fn("r020502185>1228580>22386>1q86504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A07090I042184>12291>12385>1q85504^1^14249061:" #(*io-out*
#fn("A090I0:" #(*io-out*) 4) #fn("A07090z2:" #(print) 6)
#fn("A190504208061:" #(#fn(raise)) 6) #fn(io->str)) 8)
#fn("A190504208061:" #(#fn(raise)) 6)) 8)
proper-list? #fn("A1DIb5852085>1_480S;JD0480B;3<0485<808062:" #(#fn("A280=81=87B38087=@408786B3J088B3D08688QJ<090<868862:86S;J60486B;360488S:" proper? 10)) 8)
putprop #fn("A3207181D95387370D9@G022502371818853488?7^142387808253482:" #(#fn(get)
*properties*
#fn(table)
#fn(put!)) 10)
quoted? #fn("A180<20Q:" #($quote) 6) read-all
#fn("A170718062:" #(read-all-of read) 7) read-all-of #fn("A2DIb68620868081>3_486<^1D980815162:" #(#fn("A2208151390718061:90<8180P91925162:" #(#fn(eof?)
reverse!) 8)) 8)
remove-duplicates #fn("A12050DIb686218586>2_486<^180D962:" #(#fn(table)
#fn("A280H390708161:219080<523=091<80=8162:229080<DA53491<80=80<81P62:" #(reverse!
#fn(has?) #fn(put!)) 8)) 8)
remprop #fn("A2207181D95386;3O0422868052;3B0423868052;3504DA:" #(#fn(get) *properties*
#fn(has?)
#fn(del!)) 8)
repl #fn("A0DIDIb4b5DII047150422735148424_485258485>2_485<5047660:" #(that *prompt* #fn(io-flush)
*io-out* #fn("A02021q227351S;3q047484517585513N07584513@076504277851@40D9@B0798551485I:47;504DI:" #(#fn("A0207122DA63:" #(#fn(read)
*io-in* :whitespace) 8) #fn("A12071514228061:" #(#fn(io-discard-buffer) *io-in* #fn(raise)) 6)
#fn(io-eof?) *io-in* eval void? *prompt* #fn(io-flush) *io-out* print that newline) prompt 8)
#fn("A02090>121q38091<60:D9:" #(#fn("A090<60:" 5)
#fn("A17080514DA:" #(top-level-exception-handler) 6)) reploop 5) newline) 8)
revappend #fn("A270818062:" #(reverse-) 7) reverse
#fn("A170D98062:" #(reverse-) 7) reverse! #fn("A170D98062:" #(reverse!-) 7) reverse!-
#fn("A2DI81B3F0481=818081?04N4?1@\x18/480:" 7) reverse- #fn("A2813@07081<80P81=62:80:" #(reverse-) 7)
rune? #fn("A120805121Q:" #(#fn(type-of) rune) 6) self-evaluating?
#fn("A1208051S;3`0480H;370480RS;JO04218051;3D0480R;3<0480228051Q:" #(#fn(gensym?)
#fn(const?)
#fn(top-level-value)) 7)
separate-doc-from-body #fn("w10002000W1000J70D9?14DIDI20?6421?7480<80=2288513H081JC0893>073898881P62:813P08688513G07389=888789<51P81P62:74815180P:" #(#fn("A17021802263:" #(<=
:doc-a :doc-z) doc? 8) #fn("A180B3H080<20C@080TB390718061:80:" #(λ compile) maybe-lambda 6)
#fn(str?) separate-doc-from-body reverse) 13)
set-doc! #fn("r2DIDIDIb7b8872087>1_48821_42288>1?942381518:37081@5081<8:370D9@;0248981=522487<82528;3Y075802688<8;515348<3?07580278<53@40D9@40D948=B3Q0758028797:7;8028D9538=525153@40D94DI:" #(#fn("A180H38080:@40D9480<85B3I07085F2523>07185EF253@408590<80=51P:" #(length>
subseq) formals-clean 9) #fn("A120Z3=021Z370D9@5080:42280235285<85=87;3?047425268752f287;3?04252788>18752718689P2362:" #(str-trim
str-join #fn(str-split) "\n" min #fn(map) #fn("A1E208051L2;3D042080512071805151n:" #(#fn(length)
str-trim) 8)
#fn("A17090218051523;022809062:80:" #(<= #fn(length)
#fn(str-sub)) 8)) trim-indent 12)
#fn("A180B3A02080=51370D9@5080:48090<80=51N:" #(#fn(str?)) extra-clean 7)
#fn(str?) #fn(map) putprop *doc* *doc-extra* *formals-list* remove-duplicates append getprop) 20)
set-reader-macro! #fn("w20003000W2000J7070?247180513=0228051?0@40D94237425828053D981;38048081P534DI:" #(*read-table*
rune? #fn(str) #fn(put!) foldl #fn("A22081802150532281808653486:" #(#fn(get)
#fn(table)
#fn(put!)) 9)) 9)
set-syntax! #fn("A22071808163:" #(#fn(put!) *syntax-environment*) 8) sort
#fn("O200010003000W2000J7071?2480=J5080:80<722381828780>424818287>362:" #(#(:key)
identity
call-with-values
#fn("A07021909192>393=62:" #(partition
#fn("A19091805191925162:" 8)) 7) #fn("A22071809022915492e171819022915463:" #(#fn(nconc) sort :key) 12)) 8)
str-join #fn("A280J5020:21502286>123868081>32487>1q87504:" #("" #fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A0209091<52421229092>291=524239061:" #(#fn(io-write)
#fn(for-each) #fn("A120909152420908062:" #(#fn(io-write)) 7)
#fn(io->str)) 7) #fn("A190504208061:" #(#fn(raise)) 6)) 8)
str-map #fn("A220502186>122818086>32387>1q87504:" #(#fn(buffer)
#fn("A0209061:" #(#fn(io-close)) 6)
#fn("A0209051EDI8584L23_04912190855251863=022928652@40D9^14738551?5@\xfc/^24249261:" #(#fn(length)
#fn(str-rune) #fn(io-write) 1+ #fn(io->str)) 10) #fn("A190504208061:" #(#fn(raise)) 6)) 8)
str-pad #fn("O200020004000W2000J7021?24W3000J7022?342380518188n238351k7489E5235080:828:21CA025807683895262:8:27CA025768389528062:8:28CS089F2k898;n2576838;528076838<5263:792:8262:" #(#(:align
:fill) :left #\space #fn(str-width) <= #fn(str) str-rep :right :center arg-error "invalid alignment: ") 15)
str-rep #fn("A27081E5235021:7281513C02380748081Kn5262:742380805281F2k62:" #(<= "" odd?
#fn(str)
str-rep) 10)
str-trim #fn("w10003000W1000J7070?14W2000J7081?24DIDIb7b88721818087>3_48822828088>3_42380512480813=087<E8952@30E823<088<8951@408963:" #(rune-whitespace?
#fn("A28081L23O09020918052513@092<7180518162:80:" #(#fn(str-rune) 1+) trim-start 8)
#fn("A1E80L23Q090209171805152513>092<71805161:80:" #(#fn(str-rune) 1-) trim-end 9)
#fn(length) #fn(str-sub)) 12)
subseq #fn("w20003000W2000J70D9?24DIDIb770818252370D9@>071228123825448724828187>3_425808281>3?8480B3<087<808162:80]390887661:2780513=02880818263:7980513D02:8051T882;89>161:D9:" #(<=
arg-error "start <= end: " " <= " #fn("A281El23g090;38049091n7080865287863H0718786523=072809052@40D94:80B3A092<80=73815162:72809162:" #(copy-list
length< bounds-error 1-) subseq-l 10) #fn("A120905191;J504858586L23=071908652@;0808692n51229286DI898:L23N0489878;92n908;Gp^1489KM?9@\r/^251487:" #(#fn(length)
bounds-error #4#) subseq-av 15) vec-alloc #fn(str?)
#fn(str-sub) arr? #fn(type-of) #fn("A1209080E63:" #(#fn(arr-alloc)) 8)) 11)
t0_auto42# #:t0_auto42# t0_auto54# #:t0_auto54# table->assoc-list
#fn("A12021D98063:" #(#fn(table-fold) #fn("A38081P82P:" 6)) 8) table-invert #fn("A12050212285>1D98053485:" #(#fn(table)
#fn(table-fold) #fn("A32090818063:" #(#fn(put!)) 8)) 9)
table-keys #fn("A12021D98063:" #(#fn(table-fold)
#fn("A38082P:" 6)) 8)
table-values #fn("A12021D98063:" #(#fn(table-fold)
#fn("A38182P:" 6)) 8)
that NIL thk_auto37# #:thk_auto37# thk_auto49# #:thk_auto49# to-proper
#fn("A180J5080:80H37080e1:80<7080=51P:" #(to-proper) 7)
top-level-exception-handler #fn("A17071I042285>12380>12486>1q86504:" #(*io-out*
*stderr* #fn("A090I0:" #(*io-out*) 4)
#fn("A0709051471225061:" #(print-exception
print-stack-trace #fn(stacktrace)) 6) #fn("A190504208061:" #(#fn(raise)) 6)) 8)
trace #fn("A1208051718551Je0228073242526272880e225e3e229e12:2885e225e3e55152@40D9^14DI:" #(#fn(top-level-value)
traced? #fn(set-top-level-value!) eval λ #:args_auto41# write cons quote newline apply) 15)
traced? #fn("A120718051;3@04228051228551d:" #(#fn("r0202180P514725042380z2:" #(#fn(write)
x newline #.apply) 7) closure? #fn(fn-code)) 8)
type-error #fn("r22021228081825461:" #(#fn(raise)
#fn(list*) type-error) 10)
untrace #fn("A12080517172513D02380247251F3G52@40D9^14DI:" #(#fn(top-level-value)
traced? fn #fn(set-top-level-value!)
#fn(fn-vals)) 9)
values #fn("r080B3<080=J6080<:9080P:" #() #(#5#) 6) vars-to-env
#fn("A320218182>280722380515163:" #(#fn(map)
#fn("A2708021809052SS8191M63:" #(vinfo #fn(memq)) 9)
iota #fn(length)) 10)
vec->list #fn("A17080z2:" #(list) 6) vinfo
#fn("A3808182e3:" 7) vinfo:heap? #.cadr vinfo:index
#6# vinfo:sym #.car void
#3# void? #fn("A180DIQ:" 6) zero?
#fn("A180El2:" 6) zip #fn("r0707180z3:" #(map list) 7) zip-with
#fn("r1708081z3:" #(map) 7))