Vicare Scheme: function index

Appendix P An entry for each function

Jump to:	! # $ & * + - . / < = > ? \ _ \| A B C D E F G H I K L M N O P Q R S T U V W X Y Z

	Index Entry	Section

!
	`!=`:	iklib numerics compar

#
	`#!(char-names (?name . ?char) ...)`:	iklib reader chars
	`#!eof`:	iklib reader misc
	`#!ikarus`:	iklib reader mode
	`#!vicare`:	iklib reader mode
	`#:symbol`:	iklib reader misc
	`#<?symbol`:	iklib reader extensions
	`#ci`:	iklib reader misc
	`#cs`:	iklib reader misc
	`#vc4b(cflonum ...)`:	iklib reader bv
	`#vc4l(cflonum ...)`:	iklib reader bv
	`#vc4n(cflonum ...)`:	iklib reader bv
	`#vc8b(cflonum ...)`:	iklib reader bv
	`#vc8l(cflonum ...)`:	iklib reader bv
	`#vc8n(cflonum ...)`:	iklib reader bv
	`#ve(encoding data)`:	iklib reader bv
	`#vf4b(flonum ...)`:	iklib reader bv
	`#vf4l(flonum ...)`:	iklib reader bv
	`#vf4n(flonum ...)`:	iklib reader bv
	`#vf8b(flonum ...)`:	iklib reader bv
	`#vf8l(flonum ...)`:	iklib reader bv
	`#vf8n(flonum ...)`:	iklib reader bv
	`#vs16b(word ...)`:	iklib reader bv
	`#vs16l(word ...)`:	iklib reader bv
	`#vs16n(word ...)`:	iklib reader bv
	`#vs32b(word ...)`:	iklib reader bv
	`#vs32l(word ...)`:	iklib reader bv
	`#vs32n(word ...)`:	iklib reader bv
	`#vs64b(word ...)`:	iklib reader bv
	`#vs64l(word ...)`:	iklib reader bv
	`#vs64n(word ...)`:	iklib reader bv
	`#vs8(byte ...)`:	iklib reader bv
	`#vu16b(word ...)`:	iklib reader bv
	`#vu16l(word ...)`:	iklib reader bv
	`#vu16n(word ...)`:	iklib reader bv
	`#vu32b(word ...)`:	iklib reader bv
	`#vu32l(word ...)`:	iklib reader bv
	`#vu32n(word ...)`:	iklib reader bv
	`#vu64b(word ...)`:	iklib reader bv
	`#vu64l(word ...)`:	iklib reader bv
	`#vu64n(word ...)`:	iklib reader bv
	`#\{?name}`:	iklib reader chars
	`#{pretty-name unique-name}`:	iklib reader misc
	`#{unique-name}`:	iklib reader misc

$
	`$abs-bignum`:	syslib numerics abs
	`$abs-fixnum`:	syslib numerics abs
	`$abs-flonum`:	syslib numerics abs
	`$abs-ratnum`:	syslib numerics abs
	`$acos-bignum`:	syslib numerics acos
	`$acos-cflonum`:	syslib numerics acos
	`$acos-compnum`:	syslib numerics acos
	`$acos-fixnum`:	syslib numerics acos
	`$acos-flonum`:	syslib numerics acos
	`$acos-ratnum`:	syslib numerics acos
	`$acosh-bignum`:	syslib numerics acosh
	`$acosh-cflonum`:	syslib numerics acosh
	`$acosh-compnum`:	syslib numerics acosh
	`$acosh-fixnum`:	syslib numerics acosh
	`$acosh-flonum`:	syslib numerics acosh
	`$acosh-ratnum`:	syslib numerics acosh
	`$add-bignum-bignum`:	syslib numerics add
	`$add-bignum-cflonum`:	syslib numerics add
	`$add-bignum-compnum`:	syslib numerics add
	`$add-bignum-fixnum`:	syslib numerics add
	`$add-bignum-flonum`:	syslib numerics add
	`$add-bignum-number`:	syslib numerics add
	`$add-bignum-ratnum`:	syslib numerics add
	`$add-cflonum-bignum`:	syslib numerics add
	`$add-cflonum-cflonum`:	syslib numerics add
	`$add-cflonum-compnum`:	syslib numerics add
	`$add-cflonum-fixnum`:	syslib numerics add
	`$add-cflonum-flonum`:	syslib numerics add
	`$add-cflonum-number`:	syslib numerics add
	`$add-cflonum-ratnum`:	syslib numerics add
	`$add-compnum-bignum`:	syslib numerics add
	`$add-compnum-cflonum`:	syslib numerics add
	`$add-compnum-compnum`:	syslib numerics add
	`$add-compnum-fixnum`:	syslib numerics add
	`$add-compnum-flonum`:	syslib numerics add
	`$add-compnum-number`:	syslib numerics add
	`$add-compnum-ratnum`:	syslib numerics add
	`$add-fixnum-bignum`:	syslib numerics add
	`$add-fixnum-cflonum`:	syslib numerics add
	`$add-fixnum-compnum`:	syslib numerics add
	`$add-fixnum-fixnum`:	syslib numerics add
	`$add-fixnum-flonum`:	syslib numerics add
	`$add-fixnum-number`:	syslib numerics add
	`$add-fixnum-ratnum`:	syslib numerics add
	`$add-flonum-bignum`:	syslib numerics add
	`$add-flonum-cflonum`:	syslib numerics add
	`$add-flonum-compnum`:	syslib numerics add
	`$add-flonum-fixnum`:	syslib numerics add
	`$add-flonum-flonum`:	syslib numerics add
	`$add-flonum-number`:	syslib numerics add
	`$add-flonum-ratnum`:	syslib numerics add
	`$add-number-bignum`:	syslib numerics add
	`$add-number-cflonum`:	syslib numerics add
	`$add-number-compnum`:	syslib numerics add
	`$add-number-fixnum`:	syslib numerics add
	`$add-number-flonum`:	syslib numerics add
	`$add-number-number`:	syslib numerics add
	`$add-number-ratnum`:	syslib numerics add
	`$add-ratnum-bignum`:	syslib numerics add
	`$add-ratnum-cflonum`:	syslib numerics add
	`$add-ratnum-compnum`:	syslib numerics add
	`$add-ratnum-fixnum`:	syslib numerics add
	`$add-ratnum-flonum`:	syslib numerics add
	`$add-ratnum-number`:	syslib numerics add
	`$add-ratnum-ratnum`:	syslib numerics add
	`$add1-bignum`:	syslib numerics add1
	`$add1-fixnum`:	syslib numerics add1
	`$add1-integer`:	syslib numerics add1
	`$angle-bignum`:	syslib numerics angle
	`$angle-cflonum`:	syslib numerics angle
	`$angle-compnum`:	syslib numerics angle
	`$angle-fixnum`:	syslib numerics angle
	`$angle-flonum`:	syslib numerics angle
	`$angle-ratnum`:	syslib numerics angle
	`$annotated-procedure-annotation`:	syslib closures
	`$ascii->string`:	syslib strings
	`$ascii-encoded-bytevector?`:	syslib bytevectors encodings
	`$ascii-encoded-string?`:	syslib strings
	`$asin-bignum`:	syslib numerics asin
	`$asin-cflonum`:	syslib numerics asin
	`$asin-compnum`:	syslib numerics asin
	`$asin-fixnum`:	syslib numerics asin
	`$asin-flonum`:	syslib numerics asin
	`$asin-ratnum`:	syslib numerics asin
	`$asinh-bignum`:	syslib numerics asinh
	`$asinh-cflonum`:	syslib numerics asinh
	`$asinh-compnum`:	syslib numerics asinh
	`$asinh-fixnum`:	syslib numerics asinh
	`$asinh-flonum`:	syslib numerics asinh
	`$asinh-ratnum`:	syslib numerics asinh
	`$atan-bignum`:	syslib numerics atan
	`$atan-cflonum`:	syslib numerics atan
	`$atan-compnum`:	syslib numerics atan
	`$atan-fixnum`:	syslib numerics atan
	`$atan-flonum`:	syslib numerics atan
	`$atan-ratnum`:	syslib numerics atan
	`$atan2-real-real`:	syslib numerics atan
	`$atanh-bignum`:	syslib numerics atanh
	`$atanh-cflonum`:	syslib numerics atanh
	`$atanh-compnum`:	syslib numerics atanh
	`$atanh-fixnum`:	syslib numerics atanh
	`$atanh-flonum`:	syslib numerics atanh
	`$atanh-ratnum`:	syslib numerics atanh
	`$base64->bytevector`:	syslib bytevectors encodings
	`$bignum->flonum`:	syslib bignums
	`$bignum-byte-ref`:	syslib bignums
	`$bignum-even?`:	syslib bignums
	`$bignum-hash`:	syslib hashtables
	`$bignum-negative?`:	syslib bignums
	`$bignum-non-negative?`:	syslib bignums
	`$bignum-non-positive?`:	syslib bignums
	`$bignum-odd?`:	syslib bignums
	`$bignum-positive?`:	syslib bignums
	`$bignum-size`:	syslib bignums
	`$bitwise-and-bignum-bignum`:	syslib numerics bitand
	`$bitwise-and-bignum-fixnum`:	syslib numerics bitand
	`$bitwise-and-bignum-number`:	syslib numerics bitand
	`$bitwise-and-fixnum-bignum`:	syslib numerics bitand
	`$bitwise-and-fixnum-fixnum`:	syslib numerics bitand
	`$bitwise-and-fixnum-number`:	syslib numerics bitand
	`$bitwise-ior-bignum-bignum`:	syslib numerics bitior
	`$bitwise-ior-bignum-fixnum`:	syslib numerics bitior
	`$bitwise-ior-bignum-number`:	syslib numerics bitior
	`$bitwise-ior-fixnum-bignum`:	syslib numerics bitior
	`$bitwise-ior-fixnum-fixnum`:	syslib numerics bitior
	`$bitwise-ior-fixnum-number`:	syslib numerics bitior
	`$bitwise-not-bignum`:	syslib numerics bitnot
	`$bitwise-not-fixnum`:	syslib numerics bitnot
	`$bitwise-xor-bignum-bignum`:	syslib numerics bitxor
	`$bitwise-xor-bignum-fixnum`:	syslib numerics bitxor
	`$bitwise-xor-bignum-number`:	syslib numerics bitxor
	`$bitwise-xor-fixnum-bignum`:	syslib numerics bitxor
	`$bitwise-xor-fixnum-fixnum`:	syslib numerics bitxor
	`$bitwise-xor-fixnum-number`:	syslib numerics bitxor
	`$boolean!=`:	syslib booleans
	`$boolean-max`:	syslib booleans
	`$boolean-min`:	syslib booleans
	`$boolean<`:	syslib booleans
	`$boolean<=`:	syslib booleans
	`$boolean=`:	syslib booleans
	`$boolean>`:	syslib booleans
	`$boolean>=`:	syslib booleans
	`$bytevector!=`:	syslib bytevectors comparison
	`$bytevector->base64`:	syslib bytevectors encodings
	`$bytevector->string-base64`:	syslib strings
	`$bytevector-concatenate`:	syslib bytevectors concatenating
	`$bytevector-copy`:	syslib bytevectors copying
	`$bytevector-copy!`:	syslib bytevectors copying
	`$bytevector-copy!/count`:	syslib bytevectors copying
	`$bytevector-empty?`:	syslib bytevectors predicates
	`$bytevector-hash`:	syslib hashtables
	`$bytevector-hash`:	syslib hashtables
	`$bytevector-ieee-double-big-ref`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-big-set!`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-little-ref`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-little-set!`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-native-ref`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-native-set!`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-nonnative-ref`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-nonnative-set!`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-ref`:	syslib bytevectors accessors double
	`$bytevector-ieee-double-set!`:	syslib bytevectors accessors double
	`$bytevector-ieee-single-big-ref`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-big-set!`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-little-ref`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-little-set!`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-native-ref`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-native-set!`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-nonnative-ref`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-nonnative-set!`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-ref`:	syslib bytevectors accessors single
	`$bytevector-ieee-single-set!`:	syslib bytevectors accessors single
	`$bytevector-length`:	syslib bytevectors inspection
	`$bytevector-reverse-and-concatenate`:	syslib bytevectors concatenating
	`$bytevector-s16-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16b-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16b-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16l-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16l-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16n-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-s16n-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-s32-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32b-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32b-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32l-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32l-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32n-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-s32n-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-s64-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64b-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64b-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64l-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64l-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64n-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-s64n-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-s8-max`:	syslib bytevectors comparison
	`$bytevector-s8-min`:	syslib bytevectors comparison
	`$bytevector-s8-ref`:	syslib bytevectors accessors 8-bit
	`$bytevector-s8-set!`:	syslib bytevectors accessors 8-bit
	`$bytevector-s8<`:	syslib bytevectors comparison
	`$bytevector-s8<=`:	syslib bytevectors comparison
	`$bytevector-s8>`:	syslib bytevectors comparison
	`$bytevector-s8>=`:	syslib bytevectors comparison
	`$bytevector-self-copy-backwards!/count`:	syslib bytevectors copying
	`$bytevector-self-copy-forwards!/count`:	syslib bytevectors copying
	`$bytevector-set!`:	syslib bytevectors accessors 8-bit
	`$bytevector-total-length`:	syslib bytevectors concatenating
	`$bytevector-u16-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16b-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16b-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16l-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16l-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16n-ref`:	syslib bytevectors accessors 16-bit
	`$bytevector-u16n-set!`:	syslib bytevectors accessors 16-bit
	`$bytevector-u32-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32b-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32b-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32l-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32l-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32n-ref`:	syslib bytevectors accessors 32-bit
	`$bytevector-u32n-set!`:	syslib bytevectors accessors 32-bit
	`$bytevector-u64-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64b-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64b-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64l-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64l-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64n-ref`:	syslib bytevectors accessors 64-bit
	`$bytevector-u64n-set!`:	syslib bytevectors accessors 64-bit
	`$bytevector-u8-max`:	syslib bytevectors comparison
	`$bytevector-u8-min`:	syslib bytevectors comparison
	`$bytevector-u8-ref`:	syslib bytevectors accessors 8-bit
	`$bytevector-u8-set!`:	syslib bytevectors accessors 8-bit
	`$bytevector-u8<`:	syslib bytevectors comparison
	`$bytevector-u8<=`:	syslib bytevectors comparison
	`$bytevector-u8>`:	syslib bytevectors comparison
	`$bytevector-u8>=`:	syslib bytevectors comparison
	`$bytevector=`:	syslib bytevectors comparison
	`$car`:	syslib pairs
	`$cbrt-bignum`:	syslib numerics cbrt
	`$cbrt-cflonum`:	syslib numerics cbrt
	`$cbrt-compnum`:	syslib numerics cbrt
	`$cbrt-fixnum`:	syslib numerics cbrt
	`$cbrt-flonum`:	syslib numerics cbrt
	`$cbrt-ratnum`:	syslib numerics cbrt
	`$cdr`:	syslib pairs
	`$ceiling-bignum`:	syslib numerics ceiling
	`$ceiling-fixnum`:	syslib numerics ceiling
	`$ceiling-flonum`:	syslib numerics ceiling
	`$ceiling-ratnum`:	syslib numerics ceiling
	`$cflonum-hash`:	syslib hashtables
	`$cflonum-imag`:	syslib cflonums
	`$cflonum-real`:	syslib cflonums
	`$char!=`:	syslib chars
	`$char->fixnum`:	syslib fixnums
	`$char->fixnum`:	syslib chars
	`$char-ci-hash`:	syslib hashtables
	`$char-hash`:	syslib hashtables
	`$char<`:	syslib chars
	`$char<=`:	syslib chars
	`$char=`:	syslib chars
	`$char>`:	syslib chars
	`$char>=`:	syslib chars
	`$chmax`:	syslib chars
	`$chmin`:	syslib chars
	`$closure-code`:	syslib closures
	`$code->closure`:	syslib codes unsafe
	`$code-annotation`:	syslib codes unsafe
	`$code-freevars`:	syslib codes unsafe
	`$code-ref`:	syslib codes unsafe
	`$code-reloc-vector`:	syslib codes unsafe
	`$code-set!`:	syslib codes unsafe
	`$code-size`:	syslib codes unsafe
	`$complex-conjugate-cflonum`:	syslib numerics conjugate
	`$complex-conjugate-compnum`:	syslib numerics conjugate
	`$compnum->cflonum`:	syslib compnums
	`$compnum-hash`:	syslib hashtables
	`$compnum-imag`:	syslib compnums
	`$compnum-real`:	syslib compnums
	`$cos-bignum`:	syslib numerics cos
	`$cos-cflonum`:	syslib numerics cos
	`$cos-compnum`:	syslib numerics cos
	`$cos-fixnum`:	syslib numerics cos
	`$cos-flonum`:	syslib numerics cos
	`$cos-ratnum`:	syslib numerics cos
	`$cosh-bignum`:	syslib numerics cosh
	`$cosh-cflonum`:	syslib numerics cosh
	`$cosh-compnum`:	syslib numerics cosh
	`$cosh-fixnum`:	syslib numerics cosh
	`$cosh-flonum`:	syslib numerics cosh
	`$cosh-ratnum`:	syslib numerics cosh
	`$cpref`:	syslib closures
	`$cube-bignum`:	syslib numerics cube
	`$cube-cflonum`:	syslib numerics cube
	`$cube-compnum`:	syslib numerics cube
	`$cube-fixnum`:	syslib numerics cube
	`$cube-ratnum`:	syslib numerics cube
	`$data->transcoder`:	syslib transcoders
	`$denominator-bignum`:	syslib numerics denominator
	`$denominator-fixnum`:	syslib numerics denominator
	`$denominator-flonum`:	syslib numerics denominator
	`$denominator-ratnum`:	syslib numerics denominator
	`$div-bignum-bignum`:	syslib numerics div
	`$div-bignum-cflonum`:	syslib numerics div
	`$div-bignum-compnum`:	syslib numerics div
	`$div-bignum-fixnum`:	syslib numerics div
	`$div-bignum-flonum`:	syslib numerics div
	`$div-bignum-number`:	syslib numerics div
	`$div-bignum-ratnum`:	syslib numerics div
	`$div-cflonum-bignum`:	syslib numerics div
	`$div-cflonum-cflonum`:	syslib numerics div
	`$div-cflonum-compnum`:	syslib numerics div
	`$div-cflonum-fixnum`:	syslib numerics div
	`$div-cflonum-flonum`:	syslib numerics div
	`$div-cflonum-number`:	syslib numerics div
	`$div-cflonum-ratnum`:	syslib numerics div
	`$div-compnum-bignum`:	syslib numerics div
	`$div-compnum-cflonum`:	syslib numerics div
	`$div-compnum-compnum`:	syslib numerics div
	`$div-compnum-fixnum`:	syslib numerics div
	`$div-compnum-flonum`:	syslib numerics div
	`$div-compnum-number`:	syslib numerics div
	`$div-compnum-ratnum`:	syslib numerics div
	`$div-fixnum-bignum`:	syslib numerics div
	`$div-fixnum-cflonum`:	syslib numerics div
	`$div-fixnum-compnum`:	syslib numerics div
	`$div-fixnum-fixnum`:	syslib numerics div
	`$div-fixnum-flonum`:	syslib numerics div
	`$div-fixnum-number`:	syslib numerics div
	`$div-fixnum-ratnum`:	syslib numerics div
	`$div-flonum-bignum`:	syslib numerics div
	`$div-flonum-cflonum`:	syslib numerics div
	`$div-flonum-compnum`:	syslib numerics div
	`$div-flonum-fixnum`:	syslib numerics div
	`$div-flonum-flonum`:	syslib numerics div
	`$div-flonum-number`:	syslib numerics div
	`$div-flonum-ratnum`:	syslib numerics div
	`$div-number-bignum`:	syslib numerics div
	`$div-number-cflonum`:	syslib numerics div
	`$div-number-compnum`:	syslib numerics div
	`$div-number-fixnum`:	syslib numerics div
	`$div-number-flonum`:	syslib numerics div
	`$div-number-number`:	syslib numerics div
	`$div-number-ratnum`:	syslib numerics div
	`$div-ratnum-bignum`:	syslib numerics div
	`$div-ratnum-cflonum`:	syslib numerics div
	`$div-ratnum-compnum`:	syslib numerics div
	`$div-ratnum-fixnum`:	syslib numerics div
	`$div-ratnum-flonum`:	syslib numerics div
	`$div-ratnum-number`:	syslib numerics div
	`$div-ratnum-ratnum`:	syslib numerics div
	`$enum-set-hash`:	syslib hashtables
	`$exact-bignum`:	syslib numerics exact
	`$exact-cflonum`:	syslib numerics exact
	`$exact-compnum`:	syslib numerics exact
	`$exact-fixnum`:	syslib numerics exact
	`$exact-flonum`:	syslib numerics exact
	`$exact-integer-hash`:	syslib hashtables
	`$exact-integer-sqrt-bignum`:	syslib numerics sqrt
	`$exact-integer-sqrt-fixnum`:	syslib numerics sqrt
	`$exact-ratnum`:	syslib numerics exact
	`$exp-bignum`:	syslib numerics exp
	`$exp-cflonum`:	syslib numerics exp
	`$exp-compnum`:	syslib numerics exp
	`$exp-fixnum`:	syslib numerics exp
	`$exp-flonum`:	syslib numerics exp
	`$exp-ratnum`:	syslib numerics exp
	`$expt-bignum-bignum`:	syslib numerics expt bignums
	`$expt-bignum-cflonum`:	syslib numerics expt bignums
	`$expt-bignum-compnum`:	syslib numerics expt bignums
	`$expt-bignum-fixnum`:	syslib numerics expt bignums
	`$expt-bignum-flonum`:	syslib numerics expt bignums
	`$expt-bignum-negative-fixnum`:	syslib numerics expt nega
	`$expt-bignum-positive-fixnum`:	syslib numerics expt posi
	`$expt-bignum-ratnum`:	syslib numerics expt bignums
	`$expt-cflonum-bignum`:	syslib numerics expt cflonums
	`$expt-cflonum-cflonum`:	syslib numerics expt cflonums
	`$expt-cflonum-compnum`:	syslib numerics expt cflonums
	`$expt-cflonum-fixnum`:	syslib numerics expt cflonums
	`$expt-cflonum-flonum`:	syslib numerics expt cflonums
	`$expt-cflonum-negative-fixnum`:	syslib numerics expt nega
	`$expt-cflonum-positive-fixnum`:	syslib numerics expt posi
	`$expt-cflonum-ratnum`:	syslib numerics expt cflonums
	`$expt-cflonum-zero-fixnum`:	syslib numerics expt zero
	`$expt-compnum-bignum`:	syslib numerics expt compnums
	`$expt-compnum-cflonum`:	syslib numerics expt compnums
	`$expt-compnum-compnum`:	syslib numerics expt compnums
	`$expt-compnum-fixnum`:	syslib numerics expt compnums
	`$expt-compnum-flonum`:	syslib numerics expt compnums
	`$expt-compnum-negative-fixnum`:	syslib numerics expt nega
	`$expt-compnum-positive-fixnum`:	syslib numerics expt posi
	`$expt-compnum-ratnum`:	syslib numerics expt compnums
	`$expt-compnum-zero-fixnum`:	syslib numerics expt zero
	`$expt-fixnum-bignum`:	syslib numerics expt fixnums
	`$expt-fixnum-cflonum`:	syslib numerics expt fixnums
	`$expt-fixnum-compnum`:	syslib numerics expt fixnums
	`$expt-fixnum-fixnum`:	syslib numerics expt fixnums
	`$expt-fixnum-flonum`:	syslib numerics expt fixnums
	`$expt-fixnum-negative-fixnum`:	syslib numerics expt nega
	`$expt-fixnum-positive-fixnum`:	syslib numerics expt posi
	`$expt-fixnum-ratnum`:	syslib numerics expt fixnums
	`$expt-fixnum-zero-fixnum`:	syslib numerics expt zero
	`$expt-flonum-bignum`:	syslib numerics expt flonums
	`$expt-flonum-cflonum`:	syslib numerics expt flonums
	`$expt-flonum-compnum`:	syslib numerics expt flonums
	`$expt-flonum-fixnum`:	syslib numerics expt flonums
	`$expt-flonum-flonum`:	syslib numerics expt flonums
	`$expt-flonum-negative-fixnum`:	syslib numerics expt nega
	`$expt-flonum-positive-fixnum`:	syslib numerics expt posi
	`$expt-flonum-ratnum`:	syslib numerics expt flonums
	`$expt-flonum-zero-fixnum`:	syslib numerics expt zero
	`$expt-number-bignum`:	syslib numerics expt any
	`$expt-number-cflonum`:	syslib numerics expt any
	`$expt-number-compnum`:	syslib numerics expt any
	`$expt-number-fixnum`:	syslib numerics expt any
	`$expt-number-flonum`:	syslib numerics expt any
	`$expt-number-negative-fixnum`:	syslib numerics expt nega
	`$expt-number-positive-fixnum`:	syslib numerics expt posi
	`$expt-number-ratnum`:	syslib numerics expt any
	`$expt-number-zero-fixnum`:	syslib numerics expt zero
	`$expt-ratnum-bignum`:	syslib numerics expt ratnums
	`$expt-ratnum-cflonum`:	syslib numerics expt ratnums
	`$expt-ratnum-compnum`:	syslib numerics expt ratnums
	`$expt-ratnum-fixnum`:	syslib numerics expt ratnums
	`$expt-ratnum-flonum`:	syslib numerics expt ratnums
	`$expt-ratnum-negative-fixnum`:	syslib numerics expt nega
	`$expt-ratnum-positive-fixnum`:	syslib numerics expt posi
	`$expt-ratnum-ratnum`:	syslib numerics expt ratnums
	`$fill-vector-from-list!`:	syslib vectors conversion
	`$fixnum->char`:	syslib fixnums
	`$fixnum->char`:	syslib chars
	`$fixnum->flonum`:	syslib fixnums
	`$fixnum->flonum`:	syslib flonums conversion
	`$fixnum->string`:	syslib fixnums
	`$fixnum->string`:	syslib strings
	`$fixnum-hash`:	syslib hashtables
	`$fl!=`:	syslib flonums comparison
	`$fl*`:	syslib flonums arithmetic
	`$fl+`:	syslib flonums arithmetic
	`$fl-`:	syslib flonums arithmetic
	`$fl-`:	syslib flonums arithmetic
	`$fl/`:	syslib flonums arithmetic
	`$fl<`:	syslib flonums comparison
	`$fl<=`:	syslib flonums comparison
	`$fl=`:	syslib flonums comparison
	`$fl>`:	syslib flonums comparison
	`$fl>=`:	syslib flonums comparison
	`$flabs`:	syslib flonums parts
	`$flacos`:	syslib flonums trigon
	`$flacosh`:	syslib flonums hyperbol
	`$flasin`:	syslib flonums trigon
	`$flasinh`:	syslib flonums hyperbol
	`$flatan`:	syslib flonums trigon
	`$flatan`:	syslib flonums trigon
	`$flatan2`:	syslib flonums trigon
	`$flatanh`:	syslib flonums hyperbol
	`$flcbrt`:	syslib flonums log
	`$flceiling`:	syslib flonums rounding
	`$flcos`:	syslib flonums trigon
	`$flcosh`:	syslib flonums hyperbol
	`$flcube`:	syslib flonums power
	`$fldenominator`:	syslib flonums parts
	`$fldiv`:	syslib flonums arithmetic
	`$fldiv-and-mod`:	syslib flonums arithmetic
	`$fldiv0`:	syslib flonums arithmetic
	`$fldiv0-and-mod0`:	syslib flonums arithmetic
	`$fleven?`:	syslib flonums predicates
	`$flexact`:	syslib flonums conversion
	`$flexp`:	syslib flonums log
	`$flexpm1`:	syslib flonums log
	`$flexpt`:	syslib flonums power
	`$flfloor`:	syslib flonums rounding
	`$flhypot`:	syslib flonums log
	`$flinfinite?`:	syslib flonums predicates
	`$fllog`:	syslib flonums log
	`$fllog`:	syslib flonums log
	`$fllog1p`:	syslib flonums log
	`$fllog2`:	syslib flonums log
	`$flmax`:	syslib flonums comparison
	`$flmin`:	syslib flonums comparison
	`$flmod`:	syslib flonums arithmetic
	`$flmod0`:	syslib flonums arithmetic
	`$flnan?`:	syslib flonums predicates
	`$flnegative?`:	syslib flonums predicates
	`$flnonnegative?`:	syslib flonums predicates
	`$flnonpositive?`:	syslib flonums predicates
	`$flnumerator`:	syslib flonums parts
	`$flodd?`:	syslib flonums predicates
	`$flonum->maybe-exact`:	syslib flonums conversion
	`$flonum-hash`:	syslib hashtables
	`$flonum-integer?`:	syslib flonums predicates
	`$flonum-rational?`:	syslib flonums predicates
	`$flonum-sbe`:	syslib flonums inspect
	`$flonum-set!`:	syslib flonums inspect
	`$flonum-u8-ref`:	syslib flonums inspect
	`$floor-bignum`:	syslib numerics floor
	`$floor-fixnum`:	syslib numerics floor
	`$floor-flonum`:	syslib numerics floor
	`$floor-ratnum`:	syslib numerics floor
	`$flpositive?`:	syslib flonums predicates
	`$flround`:	syslib flonums rounding
	`$flsin`:	syslib flonums trigon
	`$flsinh`:	syslib flonums hyperbol
	`$flsqrt`:	syslib flonums power
	`$flsquare`:	syslib flonums power
	`$fltan`:	syslib flonums trigon
	`$fltanh`:	syslib flonums hyperbol
	`$fltruncate`:	syslib flonums rounding
	`$flzero?`:	syslib flonums predicates
	`$flzero?/negative`:	syslib flonums predicates
	`$flzero?/positive`:	syslib flonums predicates
	`$fx*`:	syslib fixnums
	`$fx+`:	syslib fixnums
	`$fx-`:	syslib fixnums
	`$fx-`:	syslib fixnums
	`$fx<`:	syslib fixnums
	`$fx<=`:	syslib fixnums
	`$fx=`:	syslib fixnums
	`$fx=!`:	syslib fixnums
	`$fx>`:	syslib fixnums
	`$fx>=`:	syslib fixnums
	`$fxabs`:	syslib fixnums
	`$fxadd1`:	syslib fixnums
	`$fxand`:	syslib fixnums
	`$fxbit-field`:	syslib fixnums
	`$fxcopy-bit`:	syslib fixnums
	`$fxcopy-bit-field`:	syslib fixnums
	`$fxdiv`:	syslib fixnums
	`$fxdiv-and-mod`:	syslib fixnums
	`$fxdiv0`:	syslib fixnums
	`$fxdiv0-and-mod0`:	syslib fixnums
	`$fxeven?`:	syslib fixnums
	`$fxif`:	syslib fixnums
	`$fxinthash`:	syslib fixnums
	`$fxior`:	syslib fixnums
	`$fxmax`:	syslib fixnums
	`$fxmin`:	syslib fixnums
	`$fxmod`:	syslib fixnums
	`$fxmod0`:	syslib fixnums
	`$fxmodulo`:	syslib fixnums
	`$fxnegative?`:	syslib fixnums
	`$fxnonnegative?`:	syslib fixnums
	`$fxnonpositive?`:	syslib fixnums
	`$fxnot`:	syslib fixnums
	`$fxodd?`:	syslib fixnums
	`$fxpositive?`:	syslib fixnums
	`$fxquotient`:	syslib fixnums
	`$fxrotate-bit-field`:	syslib fixnums
	`$fxsign`:	syslib fixnums
	`$fxsll`:	syslib fixnums
	`$fxsra`:	syslib fixnums
	`$fxsub1`:	syslib fixnums
	`$fxxor`:	syslib fixnums
	`$fxzero?`:	syslib fixnums
	`$gcd-bignum-bignum`:	syslib numerics gcd
	`$gcd-bignum-fixnum`:	syslib numerics gcd
	`$gcd-bignum-flonum`:	syslib numerics gcd
	`$gcd-bignum-number`:	syslib numerics gcd
	`$gcd-fixnum-bignum`:	syslib numerics gcd
	`$gcd-fixnum-fixnum`:	syslib numerics gcd
	`$gcd-fixnum-flonum`:	syslib numerics gcd
	`$gcd-fixnum-number`:	syslib numerics gcd
	`$gcd-flonum-bignum`:	syslib numerics gcd
	`$gcd-flonum-fixnum`:	syslib numerics gcd
	`$gcd-flonum-flonum`:	syslib numerics gcd
	`$gcd-flonum-number`:	syslib numerics gcd
	`$gcd-number`:	syslib numerics gcd
	`$gcd-number-bignum`:	syslib numerics gcd
	`$gcd-number-fixnum`:	syslib numerics gcd
	`$gcd-number-flonum`:	syslib numerics gcd
	`$gcd-number-number`:	syslib numerics gcd
	`$getprop`:	syslib symbols plists
	`$hashtable-type-descriptor`:	syslib hashtables
	`$hashtable-type-descriptor-set!`:	syslib hashtables
	`$inexact-bignum`:	syslib numerics inexact
	`$inexact-cflonum`:	syslib numerics inexact
	`$inexact-compnum`:	syslib numerics inexact
	`$inexact-fixnum`:	syslib numerics inexact
	`$inexact-flonum`:	syslib numerics inexact
	`$inexact-ratnum`:	syslib numerics inexact
	`$init-symbol-function!`:	syslib symbols value
	`$interned-strings`:	syslib strings
	`$inv-bignum`:	syslib numerics inv
	`$inv-cflonum`:	syslib numerics inv
	`$inv-compnum`:	syslib numerics inv
	`$inv-fixnum`:	syslib numerics inv
	`$inv-flonum`:	syslib numerics inv
	`$inv-number`:	syslib numerics inv
	`$inv-ratnum`:	syslib numerics inv
	`$ipair-hash`:	syslib hashtables
	`$keyword->string`:	syslib keywords
	`$keyword->symbol`:	syslib keywords
	`$keyword-hash`:	syslib keywords
	`$keyword=?`:	syslib keywords
	`$latin1->string`:	syslib strings
	`$latin1-encoded-bytevector?`:	syslib bytevectors encodings
	`$latin1-encoded-string?`:	syslib strings
	`$lcm-bignum-bignum`:	syslib numerics lcm
	`$lcm-bignum-fixnum`:	syslib numerics lcm
	`$lcm-bignum-flonum`:	syslib numerics lcm
	`$lcm-bignum-number`:	syslib numerics lcm
	`$lcm-fixnum-bignum`:	syslib numerics lcm
	`$lcm-fixnum-fixnum`:	syslib numerics lcm
	`$lcm-fixnum-flonum`:	syslib numerics lcm
	`$lcm-fixnum-number`:	syslib numerics lcm
	`$lcm-flonum-bignum`:	syslib numerics lcm
	`$lcm-flonum-fixnum`:	syslib numerics lcm
	`$lcm-flonum-flonum`:	syslib numerics lcm
	`$lcm-flonum-number`:	syslib numerics lcm
	`$lcm-number`:	syslib numerics lcm
	`$lcm-number-bignum`:	syslib numerics lcm
	`$lcm-number-fixnum`:	syslib numerics lcm
	`$lcm-number-flonum`:	syslib numerics lcm
	`$lcm-number-number`:	syslib numerics lcm
	`$length`:	syslib lists
	`$list-hash`:	syslib hashtables
	`$list-hash`:	syslib hashtables
	`$log-bignum`:	syslib numerics log
	`$log-cflonum`:	syslib numerics log
	`$log-compnum`:	syslib numerics log
	`$log-fixnum`:	syslib numerics log
	`$log-flonum`:	syslib numerics log
	`$log-ratnum`:	syslib numerics log
	`$log-symbol-table-status`:	syslib symbols table
	`$magnitude-bignum`:	syslib numerics magnitude
	`$magnitude-cflonum`:	syslib numerics magnitude
	`$magnitude-compnum`:	syslib numerics magnitude
	`$magnitude-fixnum`:	syslib numerics magnitude
	`$magnitude-flonum`:	syslib numerics magnitude
	`$magnitude-ratnum`:	syslib numerics magnitude
	`$make-annotated-procedure`:	syslib closures
	`$make-bytevector`:	syslib bytevectors constructors
	`$make-cflonum`:	syslib cflonums
	`$make-clean-struct`:	syslib structs unsafe
	`$make-clean-vector`:	syslib vectors makers
	`$make-compnum`:	syslib compnums
	`$make-flonum`:	syslib flonums constr
	`$make-port`:	syslib ports
	`$make-ratnum`:	syslib ratnums
	`$make-rectangular`:	syslib compnums
	`$make-string`:	syslib strings
	`$make-struct`:	syslib structs unsafe
	`$make-symbol`:	syslib symbols constructors
	`$make-tcbucket`:	syslib tcbuckets
	`$make-vector`:	syslib vectors makers
	`$max-bignum-bignum`:	syslib numerics max
	`$max-bignum-fixnum`:	syslib numerics max
	`$max-bignum-flonum`:	syslib numerics max
	`$max-bignum-number`:	syslib numerics max
	`$max-bignum-ratnum`:	syslib numerics max
	`$max-fixnum-bignum`:	syslib numerics max
	`$max-fixnum-fixnum`:	syslib numerics max
	`$max-fixnum-flonum`:	syslib numerics max
	`$max-fixnum-number`:	syslib numerics max
	`$max-fixnum-ratnum`:	syslib numerics max
	`$max-flonum-bignum`:	syslib numerics max
	`$max-flonum-fixnum`:	syslib numerics max
	`$max-flonum-flonum`:	syslib numerics max
	`$max-flonum-number`:	syslib numerics max
	`$max-flonum-ratnum`:	syslib numerics max
	`$max-number-bignum`:	syslib numerics max
	`$max-number-fixnum`:	syslib numerics max
	`$max-number-flonum`:	syslib numerics max
	`$max-number-ratnum`:	syslib numerics max
	`$max-ratnum-bignum`:	syslib numerics max
	`$max-ratnum-fixnum`:	syslib numerics max
	`$max-ratnum-flonum`:	syslib numerics max
	`$max-ratnum-number`:	syslib numerics max
	`$max-ratnum-ratnum`:	syslib numerics max
	`$min-bignum-bignum`:	syslib numerics min
	`$min-bignum-fixnum`:	syslib numerics min
	`$min-bignum-flonum`:	syslib numerics min
	`$min-bignum-number`:	syslib numerics min
	`$min-bignum-ratnum`:	syslib numerics min
	`$min-fixnum-bignum`:	syslib numerics min
	`$min-fixnum-fixnum`:	syslib numerics min
	`$min-fixnum-flonum`:	syslib numerics min
	`$min-fixnum-number`:	syslib numerics min
	`$min-fixnum-ratnum`:	syslib numerics min
	`$min-flonum-bignum`:	syslib numerics min
	`$min-flonum-fixnum`:	syslib numerics min
	`$min-flonum-flonum`:	syslib numerics min
	`$min-flonum-number`:	syslib numerics min
	`$min-flonum-ratnum`:	syslib numerics min
	`$min-number-bignum`:	syslib numerics min
	`$min-number-fixnum`:	syslib numerics min
	`$min-number-flonum`:	syslib numerics min
	`$min-number-ratnum`:	syslib numerics min
	`$min-ratnum-bignum`:	syslib numerics min
	`$min-ratnum-fixnum`:	syslib numerics min
	`$min-ratnum-flonum`:	syslib numerics min
	`$min-ratnum-number`:	syslib numerics min
	`$min-ratnum-ratnum`:	syslib numerics min
	`$modulo-bignum-bignum`:	syslib numerics modulo
	`$modulo-bignum-fixnum`:	syslib numerics modulo
	`$modulo-bignum-flonum`:	syslib numerics modulo
	`$modulo-bignum-number`:	syslib numerics modulo
	`$modulo-fixnum-bignum`:	syslib numerics modulo
	`$modulo-fixnum-fixnum`:	syslib numerics modulo
	`$modulo-fixnum-flonum`:	syslib numerics modulo
	`$modulo-fixnum-number`:	syslib numerics modulo
	`$modulo-flonum-bignum`:	syslib numerics modulo
	`$modulo-flonum-fixnum`:	syslib numerics modulo
	`$modulo-flonum-flonum`:	syslib numerics modulo
	`$modulo-flonum-number`:	syslib numerics modulo
	`$modulo-number-bignum`:	syslib numerics modulo
	`$modulo-number-fixnum`:	syslib numerics modulo
	`$modulo-number-flonum`:	syslib numerics modulo
	`$mul-bignum-bignum`:	syslib numerics mul
	`$mul-bignum-cflonum`:	syslib numerics mul
	`$mul-bignum-compnum`:	syslib numerics mul
	`$mul-bignum-fixnum`:	syslib numerics mul
	`$mul-bignum-flonum`:	syslib numerics mul
	`$mul-bignum-number`:	syslib numerics mul
	`$mul-bignum-ratnum`:	syslib numerics mul
	`$mul-cflonum-bignum`:	syslib numerics mul
	`$mul-cflonum-cflonum`:	syslib numerics mul
	`$mul-cflonum-compnum`:	syslib numerics mul
	`$mul-cflonum-fixnum`:	syslib numerics mul
	`$mul-cflonum-flonum`:	syslib numerics mul
	`$mul-cflonum-number`:	syslib numerics mul
	`$mul-cflonum-ratnum`:	syslib numerics mul
	`$mul-compnum-bignum`:	syslib numerics mul
	`$mul-compnum-cflonum`:	syslib numerics mul
	`$mul-compnum-compnum`:	syslib numerics mul
	`$mul-compnum-fixnum`:	syslib numerics mul
	`$mul-compnum-flonum`:	syslib numerics mul
	`$mul-compnum-number`:	syslib numerics mul
	`$mul-compnum-ratnum`:	syslib numerics mul
	`$mul-fixnum-bignum`:	syslib numerics mul
	`$mul-fixnum-cflonum`:	syslib numerics mul
	`$mul-fixnum-compnum`:	syslib numerics mul
	`$mul-fixnum-fixnum`:	syslib numerics mul
	`$mul-fixnum-flonum`:	syslib numerics mul
	`$mul-fixnum-number`:	syslib numerics mul
	`$mul-fixnum-ratnum`:	syslib numerics mul
	`$mul-flonum-bignum`:	syslib numerics mul
	`$mul-flonum-cflonum`:	syslib numerics mul
	`$mul-flonum-compnum`:	syslib numerics mul
	`$mul-flonum-fixnum`:	syslib numerics mul
	`$mul-flonum-flonum`:	syslib numerics mul
	`$mul-flonum-number`:	syslib numerics mul
	`$mul-flonum-ratnum`:	syslib numerics mul
	`$mul-number-bignum`:	syslib numerics mul
	`$mul-number-cflonum`:	syslib numerics mul
	`$mul-number-compnum`:	syslib numerics mul
	`$mul-number-fixnum`:	syslib numerics mul
	`$mul-number-flonum`:	syslib numerics mul
	`$mul-number-number`:	syslib numerics mul
	`$mul-number-ratnum`:	syslib numerics mul
	`$mul-ratnum-bignum`:	syslib numerics mul
	`$mul-ratnum-cflonum`:	syslib numerics mul
	`$mul-ratnum-compnum`:	syslib numerics mul
	`$mul-ratnum-fixnum`:	syslib numerics mul
	`$mul-ratnum-flonum`:	syslib numerics mul
	`$mul-ratnum-number`:	syslib numerics mul
	`$mul-ratnum-ratnum`:	syslib numerics mul
	`$neg-bignum`:	syslib numerics neg
	`$neg-cflonum`:	syslib numerics neg
	`$neg-compnum`:	syslib numerics neg
	`$neg-fixnum`:	syslib numerics neg
	`$neg-flonum`:	syslib numerics neg
	`$neg-number`:	syslib numerics neg
	`$neg-ratnum`:	syslib numerics neg
	`$numerator-bignum`:	syslib numerics numerator
	`$numerator-fixnum`:	syslib numerics numerator
	`$numerator-flonum`:	syslib numerics numerator
	`$numerator-ratnum`:	syslib numerics numerator
	`$octets->string`:	syslib strings
	`$octets-encoded-bytevector?`:	syslib bytevectors encodings
	`$octets-encoded-string?`:	syslib strings
	`$pair-hash`:	syslib hashtables
	`$percent-encoded-bytevector?`:	syslib bytevectors encodings
	`$percent-encoded-string?`:	syslib strings
	`$pointer!=?`:	syslib pointers
	`$pointer-hash`:	syslib hashtables
	`$pointer-max`:	syslib pointers
	`$pointer-min`:	syslib pointers
	`$pointer<`:	syslib pointers
	`$pointer<=`:	syslib pointers
	`$pointer=`:	syslib pointers
	`$pointer>`:	syslib pointers
	`$pointer>=`:	syslib pointers
	`$port-attrs`:	syslib ports
	`$port-buffer`:	syslib ports
	`$port-close`:	syslib ports
	`$port-cookie`:	syslib ports
	`$port-get-position`:	syslib ports
	`$port-id`:	syslib ports
	`$port-index`:	syslib ports
	`$port-read!`:	syslib ports
	`$port-set-position!`:	syslib ports
	`$port-size`:	syslib ports
	`$port-tag`:	syslib ports
	`$port-transcoder`:	syslib ports
	`$port-write!`:	syslib ports
	`$promise-hash`:	syslib hashtables
	`$property-list`:	syslib symbols plists
	`$putprop`:	syslib symbols plists
	`$quotient+remainder-bignum-bignum`:	syslib numerics quorem
	`$quotient+remainder-bignum-fixnum`:	syslib numerics quorem
	`$quotient+remainder-bignum-flonum`:	syslib numerics quorem
	`$quotient+remainder-bignum-number`:	syslib numerics quorem
	`$quotient+remainder-fixnum-bignum`:	syslib numerics quorem
	`$quotient+remainder-fixnum-fixnum`:	syslib numerics quorem
	`$quotient+remainder-fixnum-flonum`:	syslib numerics quorem
	`$quotient+remainder-fixnum-number`:	syslib numerics quorem
	`$quotient+remainder-flonum-bignum`:	syslib numerics quorem
	`$quotient+remainder-flonum-fixnum`:	syslib numerics quorem
	`$quotient+remainder-flonum-flonum`:	syslib numerics quorem
	`$quotient+remainder-flonum-number`:	syslib numerics quorem
	`$quotient+remainder-number-bignum`:	syslib numerics quorem
	`$quotient+remainder-number-fixnum`:	syslib numerics quorem
	`$quotient+remainder-number-flonum`:	syslib numerics quorem
	`$quotient-bignum-bignum`:	syslib numerics quotient
	`$quotient-bignum-fixnum`:	syslib numerics quotient
	`$quotient-bignum-flonum`:	syslib numerics quotient
	`$quotient-bignum-number`:	syslib numerics quotient
	`$quotient-fixnum-bignum`:	syslib numerics quotient
	`$quotient-fixnum-fixnum`:	syslib numerics quotient
	`$quotient-fixnum-flonum`:	syslib numerics quotient
	`$quotient-fixnum-number`:	syslib numerics quotient
	`$quotient-flonum-bignum`:	syslib numerics quotient
	`$quotient-flonum-fixnum`:	syslib numerics quotient
	`$quotient-flonum-flonum`:	syslib numerics quotient
	`$quotient-flonum-number`:	syslib numerics quotient
	`$quotient-number-bignum`:	syslib numerics quotient
	`$quotient-number-fixnum`:	syslib numerics quotient
	`$quotient-number-flonum`:	syslib numerics quotient
	`$ratnum->flonum`:	syslib ratnums
	`$ratnum-den`:	syslib ratnums
	`$ratnum-hash`:	syslib hashtables
	`$ratnum-negative?`:	syslib ratnums
	`$ratnum-non-negative?`:	syslib ratnums
	`$ratnum-non-positive?`:	syslib ratnums
	`$ratnum-num`:	syslib ratnums
	`$ratnum-positive?`:	syslib ratnums
	`$record-and-rtd?`:	syslib records
	`$record-comparison-procedure`:	syslib records
	`$record-constructor`:	syslib records
	`$record-destructor`:	syslib records
	`$record-equality-predicate`:	syslib records
	`$record-hash`:	syslib hashtables
	`$record-hash-function`:	syslib records
	`$record-method-retriever`:	syslib records
	`$record-printer`:	syslib records
	`$record-ref`:	syslib records
	`$record-rtd`:	syslib records
	`$record-type-comparison-procedure`:	syslib records
	`$record-type-comparison-procedure-set!`:	syslib records
	`$record-type-destructor`:	syslib records
	`$record-type-destructor-set!`:	syslib records
	`$record-type-equality-predicate`:	syslib records
	`$record-type-equality-predicate-set!`:	syslib records
	`$record-type-hash-function`:	syslib records
	`$record-type-hash-function-set!`:	syslib records
	`$record-type-method-retriever`:	syslib records
	`$record-type-method-retriever-set!`:	syslib records
	`$record-type-printer`:	syslib records
	`$record-type-printer-set!`:	syslib records
	`$record=`:	syslib records
	`$remainder-bignum-bignum`:	syslib numerics remainder
	`$remainder-bignum-fixnum`:	syslib numerics remainder
	`$remainder-bignum-flonum`:	syslib numerics remainder
	`$remainder-bignum-number`:	syslib numerics remainder
	`$remainder-fixnum-bignum`:	syslib numerics remainder
	`$remainder-fixnum-fixnum`:	syslib numerics remainder
	`$remainder-fixnum-flonum`:	syslib numerics remainder
	`$remainder-fixnum-number`:	syslib numerics remainder
	`$remainder-flonum-bignum`:	syslib numerics remainder
	`$remainder-flonum-fixnum`:	syslib numerics remainder
	`$remainder-flonum-flonum`:	syslib numerics remainder
	`$remainder-flonum-number`:	syslib numerics remainder
	`$remainder-number-bignum`:	syslib numerics remainder
	`$remainder-number-fixnum`:	syslib numerics remainder
	`$remainder-number-flonum`:	syslib numerics remainder
	`$remprop`:	syslib symbols plists
	`$round-bignum`:	syslib numerics round
	`$round-fixnum`:	syslib numerics round
	`$round-flonum`:	syslib numerics round
	`$round-ratnum`:	syslib numerics round
	`$set-car!`:	syslib pairs
	`$set-cdr!`:	syslib pairs
	`$set-code-annotation`:	syslib codes unsafe
	`$set-port-attrs!`:	syslib ports
	`$set-port-index!`:	syslib ports
	`$set-port-size!`:	syslib ports
	`$set-std-destructor!`:	syslib structs unsafe
	`$set-std-fields!`:	syslib structs unsafe
	`$set-std-length!`:	syslib structs unsafe
	`$set-std-name!`:	syslib structs unsafe
	`$set-std-printer!`:	syslib structs unsafe
	`$set-std-std!`:	syslib structs unsafe
	`$set-std-symbol!`:	syslib structs unsafe
	`$set-symbol-plist!`:	syslib symbols plists
	`$set-symbol-proc!`:	syslib symbols value
	`$set-symbol-string!`:	syslib symbols accessors
	`$set-symbol-unique-string!`:	syslib symbols accessors
	`$set-symbol-value!`:	syslib symbols value
	`$set-symbol-value/proc!`:	syslib symbols value
	`$set-tcbucket-key!`:	syslib tcbuckets
	`$set-tcbucket-next!`:	syslib tcbuckets
	`$set-tcbucket-tconc!`:	syslib tcbuckets
	`$set-tcbucket-val!`:	syslib tcbuckets
	`$sign-bignum`:	syslib numerics sign
	`$sign-fixnum`:	syslib numerics sign
	`$sign-flonum`:	syslib numerics sign
	`$sign-ratnum`:	syslib numerics sign
	`$sin-bignum`:	syslib numerics sin
	`$sin-cflonum`:	syslib numerics sin
	`$sin-compnum`:	syslib numerics sin
	`$sin-fixnum`:	syslib numerics sin
	`$sin-flonum`:	syslib numerics sin
	`$sin-ratnum`:	syslib numerics sin
	`$sinh-bignum`:	syslib numerics sinh
	`$sinh-cflonum`:	syslib numerics sinh
	`$sinh-compnum`:	syslib numerics sinh
	`$sinh-fixnum`:	syslib numerics sinh
	`$sinh-flonum`:	syslib numerics sinh
	`$sinh-ratnum`:	syslib numerics sinh
	`$sqrt-bignum`:	syslib numerics sqrt
	`$sqrt-cflonum`:	syslib numerics sqrt
	`$sqrt-compnum`:	syslib numerics sqrt
	`$sqrt-fixnum`:	syslib numerics sqrt
	`$sqrt-flonum`:	syslib numerics sqrt
	`$sqrt-ratnum`:	syslib numerics sqrt
	`$square-bignum`:	syslib numerics square
	`$square-cflonum`:	syslib numerics square
	`$square-compnum`:	syslib numerics square
	`$square-fixnum`:	syslib numerics square
	`$square-ratnum`:	syslib numerics square
	`$std-destructor`:	syslib structs unsafe
	`$std-fields`:	syslib structs unsafe
	`$std-length`:	syslib structs unsafe
	`$std-name`:	syslib structs unsafe
	`$std-printer`:	syslib structs unsafe
	`$std-std`:	syslib structs unsafe
	`$std-symbol`:	syslib structs unsafe
	`$string`:	syslib strings
	`$string!=?`:	syslib strings
	`$string->ascii`:	syslib strings
	`$string->latin1`:	syslib strings
	`$string->octets`:	syslib strings
	`$string->symbol`:	syslib symbols conversion
	`$string-base64->bytevector`:	syslib strings
	`$string-ci-hash`:	syslib hashtables
	`$string-ci-hash`:	syslib hashtables
	`$string-concatenate`:	syslib strings
	`$string-copy`:	syslib strings
	`$string-copy!`:	syslib strings
	`$string-copy!/count`:	syslib strings
	`$string-empty?`:	syslib strings
	`$string-fill!`:	syslib strings
	`$string-hash`:	syslib hashtables
	`$string-hash`:	syslib hashtables
	`$string-length`:	syslib strings
	`$string-max`:	syslib strings
	`$string-min`:	syslib strings
	`$string-ref`:	syslib strings
	`$string-reverse-and-concatenate`:	syslib strings
	`$string-self-copy-backwards!/count`:	syslib strings
	`$string-self-copy-forwards!/count`:	syslib strings
	`$string-set!`:	syslib strings
	`$string-total-length`:	syslib strings
	`$string<`:	syslib strings
	`$string<=`:	syslib strings
	`$string=`:	syslib strings
	`$string>`:	syslib strings
	`$string>=`:	syslib strings
	`$struct`:	syslib structs unsafe
	`$struct-hash`:	syslib hashtables
	`$struct-ref`:	syslib structs unsafe
	`$struct-set!`:	syslib structs unsafe
	`$struct-std`:	syslib structs unsafe
	`$struct/rtd?`:	syslib structs unsafe
	`$struct?`:	syslib structs unsafe
	`$sub-bignum-bignum`:	syslib numerics sub
	`$sub-bignum-cflonum`:	syslib numerics sub
	`$sub-bignum-compnum`:	syslib numerics sub
	`$sub-bignum-fixnum`:	syslib numerics sub
	`$sub-bignum-flonum`:	syslib numerics sub
	`$sub-bignum-number`:	syslib numerics sub
	`$sub-bignum-ratnum`:	syslib numerics sub
	`$sub-cflonum-bignum`:	syslib numerics sub
	`$sub-cflonum-cflonum`:	syslib numerics sub
	`$sub-cflonum-compnum`:	syslib numerics sub
	`$sub-cflonum-fixnum`:	syslib numerics sub
	`$sub-cflonum-flonum`:	syslib numerics sub
	`$sub-cflonum-number`:	syslib numerics sub
	`$sub-cflonum-ratnum`:	syslib numerics sub
	`$sub-compnum-bignum`:	syslib numerics sub
	`$sub-compnum-cflonum`:	syslib numerics sub
	`$sub-compnum-compnum`:	syslib numerics sub
	`$sub-compnum-fixnum`:	syslib numerics sub
	`$sub-compnum-flonum`:	syslib numerics sub
	`$sub-compnum-number`:	syslib numerics sub
	`$sub-compnum-ratnum`:	syslib numerics sub
	`$sub-fixnum-bignum`:	syslib numerics sub
	`$sub-fixnum-cflonum`:	syslib numerics sub
	`$sub-fixnum-compnum`:	syslib numerics sub
	`$sub-fixnum-fixnum`:	syslib numerics sub
	`$sub-fixnum-flonum`:	syslib numerics sub
	`$sub-fixnum-number`:	syslib numerics sub
	`$sub-fixnum-ratnum`:	syslib numerics sub
	`$sub-flonum-bignum`:	syslib numerics sub
	`$sub-flonum-cflonum`:	syslib numerics sub
	`$sub-flonum-compnum`:	syslib numerics sub
	`$sub-flonum-fixnum`:	syslib numerics sub
	`$sub-flonum-flonum`:	syslib numerics sub
	`$sub-flonum-number`:	syslib numerics sub
	`$sub-flonum-ratnum`:	syslib numerics sub
	`$sub-number-bignum`:	syslib numerics sub
	`$sub-number-cflonum`:	syslib numerics sub
	`$sub-number-compnum`:	syslib numerics sub
	`$sub-number-fixnum`:	syslib numerics sub
	`$sub-number-flonum`:	syslib numerics sub
	`$sub-number-number`:	syslib numerics sub
	`$sub-number-ratnum`:	syslib numerics sub
	`$sub-ratnum-bignum`:	syslib numerics sub
	`$sub-ratnum-cflonum`:	syslib numerics sub
	`$sub-ratnum-compnum`:	syslib numerics sub
	`$sub-ratnum-fixnum`:	syslib numerics sub
	`$sub-ratnum-flonum`:	syslib numerics sub
	`$sub-ratnum-number`:	syslib numerics sub
	`$sub-ratnum-ratnum`:	syslib numerics sub
	`$sub1-bignum`:	syslib numerics sub1
	`$sub1-fixnum`:	syslib numerics sub1
	`$sub1-integer`:	syslib numerics sub1
	`$subbytevector-s8`:	syslib bytevectors constructors
	`$subbytevector-s8/count`:	syslib bytevectors constructors
	`$subbytevector-u8`:	syslib bytevectors constructors
	`$subbytevector-u8/count`:	syslib bytevectors constructors
	`$substring`:	syslib strings
	`$subvector`:	syslib vectors makers
	`$symbol!=`:	syslib symbols comparison
	`$symbol->keyword`:	syslib keywords
	`$symbol->string`:	syslib symbols conversion
	`$symbol-hash`:	syslib hashtables
	`$symbol-max`:	syslib symbols comparison
	`$symbol-min`:	syslib symbols comparison
	`$symbol-plist`:	syslib symbols plists
	`$symbol-proc`:	syslib symbols value
	`$symbol-string`:	syslib symbols accessors
	`$symbol-table-size`:	syslib symbols table
	`$symbol-unique-string`:	syslib symbols accessors
	`$symbol-value`:	syslib symbols value
	`$symbol<`:	syslib symbols comparison
	`$symbol<=`:	syslib symbols comparison
	`$symbol=`:	syslib symbols comparison
	`$symbol>`:	syslib symbols comparison
	`$symbol>=`:	syslib symbols comparison
	`$tan-bignum`:	syslib numerics tan
	`$tan-cflonum`:	syslib numerics tan
	`$tan-compnum`:	syslib numerics tan
	`$tan-fixnum`:	syslib numerics tan
	`$tan-flonum`:	syslib numerics tan
	`$tan-ratnum`:	syslib numerics tan
	`$tanh-bignum`:	syslib numerics tanh
	`$tanh-cflonum`:	syslib numerics tanh
	`$tanh-compnum`:	syslib numerics tanh
	`$tanh-fixnum`:	syslib numerics tanh
	`$tanh-flonum`:	syslib numerics tanh
	`$tanh-ratnum`:	syslib numerics tanh
	`$tcbucket-key`:	syslib tcbuckets
	`$tcbucket-next`:	syslib tcbuckets
	`$tcbucket-tconc`:	syslib tcbuckets
	`$tcbucket-val`:	syslib tcbuckets
	`$transcoder!=`:	syslib transcoders
	`$transcoder->data`:	syslib transcoders
	`$transcoder-hash`:	syslib hashtables
	`$transcoder-max`:	syslib transcoders
	`$transcoder-min`:	syslib transcoders
	`$transcoder<`:	syslib transcoders
	`$transcoder<=`:	syslib transcoders
	`$transcoder=`:	syslib transcoders
	`$transcoder>`:	syslib transcoders
	`$transcoder>=`:	syslib transcoders
	`$truncate-bignum`:	syslib numerics truncate
	`$truncate-fixnum`:	syslib numerics truncate
	`$truncate-flonum`:	syslib numerics truncate
	`$truncate-ratnum`:	syslib numerics truncate
	`$unbound-object?`:	syslib symbols value
	`$uri-decode`:	syslib bytevectors encodings
	`$uri-encode`:	syslib bytevectors encodings
	`$uri-encoded-bytevector?`:	syslib bytevectors encodings
	`$uri-encoded-string?`:	syslib strings
	`$uri-normalise-encoding`:	syslib bytevectors encodings
	`$vector-copy-source-count!`:	syslib vectors copying
	`$vector-copy-source-range!`:	syslib vectors copying
	`$vector-empty?`:	syslib vectors inspect
	`$vector-for-all1`:	syslib vectors mapping
	`$vector-for-each1`:	syslib vectors mapping
	`$vector-for-exists1`:	syslib vectors mapping
	`$vector-hash`:	syslib hashtables
	`$vector-hash`:	syslib hashtables
	`$vector-length`:	syslib vectors inspect
	`$vector-map1`:	syslib vectors mapping
	`$vector-ref`:	syslib vectors access
	`$vector-self-copy-backwards!`:	syslib vectors copying
	`$vector-self-copy-forwards!`:	syslib vectors copying
	`$vector-set!`:	syslib vectors access
	`$vector-set-void!`:	syslib vectors access
	`$vectors-of-same-length?`:	syslib vectors inspect

&
	`&assertion`:	stdlib exceptions conditions types
	`&condition`:	stdlib exceptions conditions objects
	`&error`:	stdlib exceptions conditions types
	`&i/o`:	stdlib io conditions
	`&i/o-decoding`:	stdlib io port transcoders
	`&i/o-encoding`:	stdlib io port transcoders
	`&i/o-file-already-exists`:	stdlib io conditions
	`&i/o-file-does-not-exist`:	stdlib io conditions
	`&i/o-file-is-read-only`:	stdlib io conditions
	`&i/o-file-protection`:	stdlib io conditions
	`&i/o-filename`:	stdlib io conditions
	`&i/o-invalid-position`:	stdlib io conditions
	`&i/o-port`:	stdlib io conditions
	`&i/o-read`:	stdlib io conditions
	`&i/o-write`:	stdlib io conditions
	`&implementation-restriction`:	stdlib exceptions conditions types
	`&irritants`:	stdlib exceptions conditions types
	`&lexical`:	stdlib exceptions conditions types
	`&message`:	stdlib exceptions conditions types
	`&no-infinities`:	stdlib arithmetic flonums
	`&no-nans`:	stdlib arithmetic flonums
	`&non-continuable`:	stdlib exceptions conditions types
	`&serious`:	stdlib exceptions conditions types
	`&syntax`:	stdlib exceptions conditions types
	`&undefined`:	stdlib exceptions conditions types
	`&violation`:	stdlib exceptions conditions types
	`&warning`:	stdlib exceptions conditions types
	`&who`:	scheme entry other kinds
	`&who`:	stdlib exceptions conditions types

*
	`*`:	baselib math ops arithmetic

+
	`+`:	baselib math ops arithmetic
	`++`:	iklib syntaxes increments
	`++`:	iklib syntaxes increments
	`+greek-pi`:	iklib numerics constants
	`+greek-pi*2`:	iklib numerics constants
	`+greek-pi*2/3`:	iklib numerics constants
	`+greek-pi*3/4`:	iklib numerics constants
	`+greek-pi/2`:	iklib numerics constants
	`+greek-pi/3`:	iklib numerics constants
	`+greek-pi/4`:	iklib numerics constants
	`+greek-pi/6`:	iklib numerics constants

-
	`-`:	baselib math ops arithmetic
	`-`:	baselib math ops arithmetic
	`--`:	iklib syntaxes increments
	`--`:	iklib syntaxes increments
	`-greek-pi`:	iklib numerics constants
	`-greek-pi*2`:	iklib numerics constants
	`-greek-pi*2/3`:	iklib numerics constants
	`-greek-pi*3/4`:	iklib numerics constants
	`-greek-pi/2`:	iklib numerics constants
	`-greek-pi/3`:	iklib numerics constants
	`-greek-pi/4`:	iklib numerics constants
	`-greek-pi/6`:	iklib numerics constants

.
	`...`:	baselib lists
	`...`:	baselib transformers
	`...`:	stdlib syntax-case parsing

/
	`/`:	baselib math ops arithmetic
	`/`:	baselib math ops arithmetic

<
	`<`:	baselib math ops value pred
	`<=`:	baselib math ops value pred
	`<>`:	iklib syntaxes misc
	`<>`:	iklib compensations api

=
	`=`:	baselib math ops value pred
	`=>`:	baselib expressions derived cond
	`=>`:	baselib expressions derived cond
	`=>`:	stdlib exceptions exceptions
	`=>`:	iklib syntaxes control

>
	`>`:	baselib math ops value pred
	`>=`:	baselib math ops value pred

?
	`?boolean`:	scheme syntax primitive
	`?bytevector`:	scheme syntax primitive
	`?character`:	scheme syntax primitive
	`?number`:	scheme syntax primitive
	`?operator`:	scheme syntax primitive
	`?string`:	scheme syntax primitive
	`?variable`:	scheme syntax primitive

\
	`\{?name}`:	iklib reader chars

_
	`_`:	baselib transformers
	`_`:	stdlib syntax-case parsing
	`__file__`:	iklib syntaxes misc
	`__line__`:	iklib syntaxes misc
	`__synner__`:	iklib syntaxes misc
	`__who__`:	iklib syntaxes misc

\|
	`\|symbol\|`:	iklib reader misc

A
	`abs`:	baselib math ops arithmetic
	`acos`:	baselib math ops trascend
	`acosh`:	iklib numerics math
	`add1`:	iklib numerics math
	`alist->hashtable!`:	iklib hashtables iterators
	`alist-type-spec.key-ots`:	expander specs alist
	`alist-type-spec.val-ots`:	expander specs alist
	`alist-type-spec?`:	expander specs alist
	`all-identifiers?`:	expander utils pairs
	`always-false`:	iklib misc
	`always-true`:	iklib misc
	`ancestor-of-type-spec.ancestor-ots*`:	expander specs ancestor
	`ancestor-of-type-spec.item-ots`:	expander specs ancestor
	`ancestor-of-type-spec?`:	expander specs ancestor
	`and`:	baselib expressions derived cond
	`andmap`:	iklib lists misc
	`andmap`:	iklib lists misc
	`angle`:	baselib math ops complex
	`append`:	baselib lists
	`append`:	baselib lists
	`apply`:	baselib control
	`apropos`:	iklib misc
	`argv->bytevectors`:	iklib cstrings
	`argv->strings`:	iklib cstrings
	`argv-length`:	iklib cstrings
	`array-ref-c-double`:	iklib arrays peek
	`array-ref-c-double-complex`:	iklib arrays peek
	`array-ref-c-float`:	iklib arrays peek
	`array-ref-c-off_t`:	iklib arrays peek
	`array-ref-c-pointer`:	iklib arrays peek
	`array-ref-c-ptrdiff_t`:	iklib arrays peek
	`array-ref-c-signed-char`:	iklib arrays peek
	`array-ref-c-signed-char`:	iklib arrays peek
	`array-ref-c-signed-int`:	iklib arrays peek
	`array-ref-c-signed-long`:	iklib arrays peek
	`array-ref-c-signed-long-long`:	iklib arrays peek
	`array-ref-c-signed-short`:	iklib arrays peek
	`array-ref-c-sint16`:	iklib arrays peek
	`array-ref-c-sint32`:	iklib arrays peek
	`array-ref-c-sint64`:	iklib arrays peek
	`array-ref-c-sint8`:	iklib arrays peek
	`array-ref-c-size_t`:	iklib arrays peek
	`array-ref-c-ssize_t`:	iklib arrays peek
	`array-ref-c-uint16`:	iklib arrays peek
	`array-ref-c-uint32`:	iklib arrays peek
	`array-ref-c-uint64`:	iklib arrays peek
	`array-ref-c-uint8`:	iklib arrays peek
	`array-ref-c-unsigned-int`:	iklib arrays peek
	`array-ref-c-unsigned-long`:	iklib arrays peek
	`array-ref-c-unsigned-long-long`:	iklib arrays peek
	`array-ref-c-unsigned-short`:	iklib arrays peek
	`array-set-c-double!`:	iklib arrays poke
	`array-set-c-double-complex!`:	iklib arrays poke
	`array-set-c-float!`:	iklib arrays poke
	`array-set-c-off_t!`:	iklib arrays poke
	`array-set-c-pointer!`:	iklib arrays poke
	`array-set-c-ptrdiff_t!`:	iklib arrays poke
	`array-set-c-signed-char!`:	iklib arrays poke
	`array-set-c-signed-int!`:	iklib arrays poke
	`array-set-c-signed-long!`:	iklib arrays poke
	`array-set-c-signed-long-long!`:	iklib arrays poke
	`array-set-c-signed-short!`:	iklib arrays poke
	`array-set-c-sint16!`:	iklib arrays poke
	`array-set-c-sint32!`:	iklib arrays poke
	`array-set-c-sint64!`:	iklib arrays poke
	`array-set-c-sint8!`:	iklib arrays poke
	`array-set-c-size_t!`:	iklib arrays poke
	`array-set-c-ssize_t!`:	iklib arrays poke
	`array-set-c-uint16!`:	iklib arrays poke
	`array-set-c-uint32!`:	iklib arrays poke
	`array-set-c-uint64!`:	iklib arrays poke
	`array-set-c-uint8!`:	iklib arrays poke
	`array-set-c-unsigned-char!`:	iklib arrays poke
	`array-set-c-unsigned-int!`:	iklib arrays poke
	`array-set-c-unsigned-long!`:	iklib arrays poke
	`array-set-c-unsigned-long-long!`:	iklib arrays poke
	`array-set-c-unsigned-short!`:	iklib arrays poke
	`ascii->string`:	iklib strings conversion
	`ascii-code-point?`:	iklib chars unicode ascii
	`ascii-decode`:	iklib chars unicode ascii
	`ascii-encode`:	iklib chars unicode ascii
	`ascii-encoded-bytevector?`:	iklib bytevectors conversion
	`ascii-encoded-string?`:	iklib strings conversion
	`ascii-octet?`:	iklib chars unicode ascii
	`asin`:	baselib math ops trascend
	`asinh`:	iklib numerics math
	`assemble-sources`:	compiler assember
	`assembly-of`:	iklib syntaxes assembly-of
	`assert`:	baselib errors
	`assertion-violation`:	baselib errors
	`assertion-violation?`:	stdlib exceptions conditions types
	`assoc`:	stdlib list
	`assp`:	stdlib list
	`assq`:	stdlib list
	`assv`:	stdlib list
	`atan`:	baselib math ops trascend
	`atan`:	baselib math ops trascend
	`atanh`:	iklib numerics math
	`automatic-collect`:	iklib gc
	`automatic-collect`:	iklib gc
	`automatic-garbage-collection`:	iklib gc
	`automatic-garbage-collection`:	iklib gc

B
	`base-rtd`:	syslib structs unsafe
	`base64->bytevector`:	iklib bytevectors conversion
	`begin`:	baselib expressions sequencing
	`begin`:	baselib expressions sequencing
	`begin-for-syntax`:	iklib syntaxes misc
	`begin0`:	iklib syntaxes control
	`bignum->bytevector`:	iklib debug
	`bignum-even?`:	iklib numerics bignums
	`bignum-hash`:	iklib hashtables hashfun
	`bignum-negative?`:	iklib numerics bignums
	`bignum-non-negative?`:	iklib numerics bignums
	`bignum-non-positive?`:	iklib numerics bignums
	`bignum-odd?`:	iklib numerics bignums
	`bignum-positive?`:	iklib numerics bignums
	`bignum?`:	iklib numerics preds
	`binary-input-only-port?`:	iklib io binary
	`binary-input-port?`:	iklib io binary
	`binary-input/output-port?`:	iklib io binary
	`binary-output-only-port?`:	iklib io binary
	`binary-output-port?`:	iklib io binary
	`binary-port?`:	stdlib io port io ports
	`bitwise-and`:	stdlib arithmetic exact bitwise
	`bitwise-arithmetic-shift`:	stdlib arithmetic exact bitwise
	`bitwise-arithmetic-shift-left`:	stdlib arithmetic exact bitwise
	`bitwise-arithmetic-shift-right`:	stdlib arithmetic exact bitwise
	`bitwise-bit-count`:	stdlib arithmetic exact bitwise
	`bitwise-bit-field`:	stdlib arithmetic exact bitwise
	`bitwise-bit-set?`:	stdlib arithmetic exact bitwise
	`bitwise-copy-bit`:	stdlib arithmetic exact bitwise
	`bitwise-copy-bit-field`:	stdlib arithmetic exact bitwise
	`bitwise-first-bit-set`:	stdlib arithmetic exact bitwise
	`bitwise-if`:	stdlib arithmetic exact bitwise
	`bitwise-ior`:	stdlib arithmetic exact bitwise
	`bitwise-length`:	stdlib arithmetic exact bitwise
	`bitwise-not`:	stdlib arithmetic exact bitwise
	`bitwise-reverse-bit-field`:	stdlib arithmetic exact bitwise
	`bitwise-rotate-bit-field`:	stdlib arithmetic exact bitwise
	`bitwise-xor`:	stdlib arithmetic exact bitwise
	`boolean!=?`:	iklib booleans
	`boolean-hash`:	iklib hashtables hashfun
	`boolean-max`:	iklib booleans
	`boolean-min`:	iklib booleans
	`boolean<=?`:	iklib booleans
	`boolean<?`:	iklib booleans
	`boolean=?`:	baselib booleans
	`boolean>=?`:	iklib booleans
	`boolean>?`:	iklib booleans
	`boolean?`:	baselib booleans
	`bound-identifier=?`:	stdlib syntax-case identifier
	`brace`:	iklib syntaxes misc
	`break`:	iklib syntaxes loops while
	`break`:	iklib syntaxes loops until
	`break`:	iklib syntaxes loops for
	`break`:	iklib syntaxes loops do
	`break`:	iklib syntaxes loops fluids
	`buffer-mode`:	stdlib io port buffer modes
	`buffer-mode?`:	stdlib io port buffer modes
	`bwp-object`:	iklib lists weak
	`bwp-object?`:	iklib lists weak
	`byte-fixnum?`:	iklib fixnums predicates
	`bytevector!=?`:	iklib bytevectors comparison
	`bytevector->base64`:	iklib bytevectors conversion
	`bytevector->bignum`:	iklib debug
	`bytevector->c4b-list`:	iklib bytevectors conversion
	`bytevector->c4l-list`:	iklib bytevectors conversion
	`bytevector->c4n-list`:	iklib bytevectors conversion
	`bytevector->c8b-list`:	iklib bytevectors conversion
	`bytevector->c8l-list`:	iklib bytevectors conversion
	`bytevector->c8n-list`:	iklib bytevectors conversion
	`bytevector->cstring`:	iklib cstrings
	`bytevector->cstring*`:	iklib cstrings
	`bytevector->f4b-list`:	iklib bytevectors conversion
	`bytevector->f4l-list`:	iklib bytevectors conversion
	`bytevector->f4n-list`:	iklib bytevectors conversion
	`bytevector->f8b-list`:	iklib bytevectors conversion
	`bytevector->f8l-list`:	iklib bytevectors conversion
	`bytevector->f8n-list`:	iklib bytevectors conversion
	`bytevector->flonum`:	iklib debug
	`bytevector->guarded-cstring`:	iklib cstrings
	`bytevector->guarded-cstring*`:	iklib cstrings
	`bytevector->guarded-memory`:	iklib memory ops
	`bytevector->hex`:	iklib bytevectors conversion
	`bytevector->memory`:	iklib memory ops
	`bytevector->s16b-list`:	iklib bytevectors conversion
	`bytevector->s16l-list`:	iklib bytevectors conversion
	`bytevector->s16n-list`:	iklib bytevectors conversion
	`bytevector->s32b-list`:	iklib bytevectors conversion
	`bytevector->s32l-list`:	iklib bytevectors conversion
	`bytevector->s32n-list`:	iklib bytevectors conversion
	`bytevector->s64b-list`:	iklib bytevectors conversion
	`bytevector->s64l-list`:	iklib bytevectors conversion
	`bytevector->s64n-list`:	iklib bytevectors conversion
	`bytevector->s8-list`:	iklib bytevectors conversion
	`bytevector->sint-list`:	stdlib bytevector integers
	`bytevector->string`:	stdlib io port transcoders
	`bytevector->string-base64`:	iklib strings conversion
	`bytevector->string-hex`:	iklib strings conversion
	`bytevector->u16b-list`:	iklib bytevectors conversion
	`bytevector->u16l-list`:	iklib bytevectors conversion
	`bytevector->u16n-list`:	iklib bytevectors conversion
	`bytevector->u32b-list`:	iklib bytevectors conversion
	`bytevector->u32l-list`:	iklib bytevectors conversion
	`bytevector->u32n-list`:	iklib bytevectors conversion
	`bytevector->u64b-list`:	iklib bytevectors conversion
	`bytevector->u64l-list`:	iklib bytevectors conversion
	`bytevector->u64n-list`:	iklib bytevectors conversion
	`bytevector->u8-list`:	stdlib bytevector bytes and octets
	`bytevector->uint-list`:	stdlib bytevector integers
	`bytevector-append`:	iklib bytevectors generic
	`bytevector-concatenate`:	iklib bytevectors generic
	`bytevector-copy`:	stdlib bytevector general
	`bytevector-copy!`:	stdlib bytevector general
	`bytevector-empty?`:	iklib bytevectors generic
	`bytevector-fill!`:	stdlib bytevector general
	`bytevector-hash`:	iklib hashtables hashfun
	`bytevector-hash`:	iklib hashtables hashfun
	`bytevector-ieee-double-native-ref`:	stdlib bytevector flonum
	`bytevector-ieee-double-native-set!`:	stdlib bytevector flonum
	`bytevector-ieee-double-ref`:	stdlib bytevector flonum
	`bytevector-ieee-double-set!`:	stdlib bytevector flonum
	`bytevector-ieee-single-native-ref`:	stdlib bytevector flonum
	`bytevector-ieee-single-native-set!`:	stdlib bytevector flonum
	`bytevector-ieee-single-ref`:	stdlib bytevector flonum
	`bytevector-ieee-single-set!`:	stdlib bytevector flonum
	`bytevector-index-for-double-flonum?`:	iklib bytevectors valpred
	`bytevector-index-for-single-flonum?`:	iklib bytevectors valpred
	`bytevector-index-for-word16?`:	iklib bytevectors valpred
	`bytevector-index-for-word32?`:	iklib bytevectors valpred
	`bytevector-index-for-word64?`:	iklib bytevectors valpred
	`bytevector-index-for-word8?`:	iklib bytevectors valpred
	`bytevector-index-for-word?`:	iklib bytevectors valpred
	`bytevector-index?`:	iklib bytevectors valpred
	`bytevector-length`:	stdlib bytevector general
	`bytevector-length?`:	iklib bytevectors valpred
	`bytevector-port-buffer-size`:	iklib io buffer
	`bytevector-port-buffer-size`:	iklib io buffer
	`bytevector-reverse-and-concatenate`:	iklib bytevectors generic
	`bytevector-s16-native-ref`:	stdlib bytevector integers 16
	`bytevector-s16-native-set!`:	stdlib bytevector integers 16
	`bytevector-s16-ref`:	stdlib bytevector integers 16
	`bytevector-s16-set!`:	stdlib bytevector integers 16
	`bytevector-s32-native-ref`:	stdlib bytevector integers 32
	`bytevector-s32-native-set!`:	stdlib bytevector integers 32
	`bytevector-s32-ref`:	stdlib bytevector integers 32
	`bytevector-s32-set!`:	stdlib bytevector integers 32
	`bytevector-s64-native-ref`:	stdlib bytevector integers 64
	`bytevector-s64-native-set!`:	stdlib bytevector integers 64
	`bytevector-s64-ref`:	stdlib bytevector integers 64
	`bytevector-s64-set!`:	stdlib bytevector integers 64
	`bytevector-s8-max`:	iklib bytevectors comparison
	`bytevector-s8-min`:	iklib bytevectors comparison
	`bytevector-s8-ref`:	stdlib bytevector bytes and octets
	`bytevector-s8-set!`:	stdlib bytevector bytes and octets
	`bytevector-s8<=?`:	iklib bytevectors comparison
	`bytevector-s8<?`:	iklib bytevectors comparison
	`bytevector-s8>=?`:	iklib bytevectors comparison
	`bytevector-s8>?`:	iklib bytevectors comparison
	`bytevector-sint-ref`:	stdlib bytevector integers
	`bytevector-sint-set!`:	stdlib bytevector integers
	`bytevector-start-index-and-count-for-word16?`:	iklib bytevectors valpred
	`bytevector-start-index-and-count-for-word32?`:	iklib bytevectors valpred
	`bytevector-start-index-and-count-for-word64?`:	iklib bytevectors valpred
	`bytevector-start-index-and-count-for-word8?`:	iklib bytevectors valpred
	`bytevector-start-index-and-count-for-word?`:	iklib bytevectors valpred
	`bytevector-u16-native-ref`:	stdlib bytevector integers 16
	`bytevector-u16-native-set!`:	stdlib bytevector integers 16
	`bytevector-u16-ref`:	stdlib bytevector integers 16
	`bytevector-u16-set!`:	stdlib bytevector integers 16
	`bytevector-u32-native-ref`:	stdlib bytevector integers 32
	`bytevector-u32-native-set!`:	stdlib bytevector integers 32
	`bytevector-u32-ref`:	stdlib bytevector integers 32
	`bytevector-u32-set!`:	stdlib bytevector integers 32
	`bytevector-u64-native-ref`:	stdlib bytevector integers 64
	`bytevector-u64-native-set!`:	stdlib bytevector integers 64
	`bytevector-u64-ref`:	stdlib bytevector integers 64
	`bytevector-u64-set!`:	stdlib bytevector integers 64
	`bytevector-u8-max`:	iklib bytevectors comparison
	`bytevector-u8-min`:	iklib bytevectors comparison
	`bytevector-u8-ref`:	stdlib bytevector bytes and octets
	`bytevector-u8-set!`:	stdlib bytevector bytes and octets
	`bytevector-u8<=?`:	iklib bytevectors comparison
	`bytevector-u8<?`:	iklib bytevectors comparison
	`bytevector-u8>=?`:	iklib bytevectors comparison
	`bytevector-u8>?`:	iklib bytevectors comparison
	`bytevector-uint-ref`:	stdlib bytevector integers
	`bytevector-uint-set!`:	stdlib bytevector integers
	`bytevector-word-count?`:	iklib bytevectors valpred
	`bytevector-word-size?`:	iklib bytevectors valpred
	`bytevector=?`:	stdlib bytevector general
	`bytevector?`:	stdlib bytevector general
	`bytevectors->argv`:	iklib cstrings
	`bytevectors->guarded-argv`:	iklib cstrings

C
	`c-callback?`:	ffi call back
	`c4b-list->bytevector`:	iklib bytevectors conversion
	`c4l-list->bytevector`:	iklib bytevectors conversion
	`c4n-list->bytevector`:	iklib bytevectors conversion
	`c8b-list->bytevector`:	iklib bytevectors conversion
	`c8l-list->bytevector`:	iklib bytevectors conversion
	`c8n-list->bytevector`:	iklib bytevectors conversion
	`caar`:	baselib lists
	`cadr`:	baselib lists
	`cafe-input-port`:	iklib cafe
	`call-with-bytevector-output-port`:	stdlib io port output ports
	`call-with-bytevector-output-port`:	stdlib io port output ports
	`call-with-current-continuation`:	baselib control
	`call-with-input-file`:	stdlib io simple
	`call-with-input-file`:	iklib io codecs
	`call-with-output-file`:	stdlib io simple
	`call-with-output-file`:	iklib io codecs
	`call-with-port`:	stdlib io port io ports
	`call-with-string-output-port`:	stdlib io port output ports
	`call-with-values`:	baselib control
	`call/cc`:	baselib control
	`calloc`:	iklib memory alloc
	`car`:	baselib lists
	`case`:	baselib expressions derived cond
	`case-define`:	iklib syntaxes defines
	`case-define*`:	iklib syntaxes defines
	`case-identifiers`:	iklib syntaxes control
	`case-lambda`:	stdlib control
	`case-lambda*`:	iklib syntaxes lambdas star
	`case-lambda-signature.clause-signature*`:	expander specs signatures case-lambda
	`case-lambda-signature?`:	expander specs signatures case-lambda
	`catch`:	iklib syntaxes try
	`cbrt`:	iklib numerics math
	`cdddar`:	baselib lists
	`cddddr`:	baselib lists
	`cdr`:	baselib lists
	`ceiling`:	baselib math ops part
	`cflonum-hash`:	iklib hashtables hashfun
	`cflonum?`:	iklib numerics preds
	`char!=?`:	iklib chars comparison
	`char->fixnum`:	iklib fixnums conversion
	`char->integer`:	baselib characters
	`char-alphabetic?`:	stdlib unicode characters
	`char-ci!=?`:	iklib chars comparison
	`char-ci-hash`:	iklib hashtables hashfun
	`char-ci<=?`:	stdlib unicode characters
	`char-ci<?`:	stdlib unicode characters
	`char-ci=?`:	stdlib unicode characters
	`char-ci>=?`:	stdlib unicode characters
	`char-ci>?`:	stdlib unicode characters
	`char-downcase`:	stdlib unicode characters
	`char-foldcase`:	stdlib unicode characters
	`char-general-category`:	stdlib unicode characters
	`char-hash`:	iklib hashtables hashfun
	`char-in-ascii-range?`:	iklib chars predicates
	`char-lower-case?`:	stdlib unicode characters
	`char-numeric?`:	stdlib unicode characters
	`char-title-case?`:	stdlib unicode characters
	`char-titlecase`:	stdlib unicode characters
	`char-upcase`:	stdlib unicode characters
	`char-upper-case?`:	stdlib unicode characters
	`char-whitespace?`:	stdlib unicode characters
	`char<=?`:	baselib characters
	`char<?`:	baselib characters
	`char=?`:	baselib characters
	`char>=?`:	baselib characters
	`char>?`:	baselib characters
	`char?`:	baselib characters
	`check-for-illegal-letrec`:	compiler letrec api
	`chmax`:	iklib chars comparison
	`chmin`:	iklib chars comparison
	`circular-list?`:	iklib lists misc
	`close-input-port`:	stdlib io simple
	`close-output-port`:	stdlib io simple
	`close-port`:	stdlib io port io ports
	`close-shared-object`:	ffi shared
	`closed-port?`:	iklib io misc
	`closure-type-spec.signature`:	expander specs closure
	`closure-type-spec?`:	expander specs closure
	`code->thunk`:	syslib codes safe
	`code-freevars`:	syslib codes safe
	`code-ref`:	syslib codes safe
	`code-reloc-vector`:	syslib codes safe
	`code-reloc-vector->sexp`:	syslib codes safe
	`code-set!`:	syslib codes safe
	`code-size`:	syslib codes safe
	`code?`:	syslib codes safe
	`collect`:	iklib gc
	`collect`:	iklib gc
	`collected-struct-type`:	ffi foreign wrapper syntax
	`collection-avoidance-list`:	iklib gc
	`collector-struct-type`:	ffi foreign wrapper syntax
	`command-line`:	stdlib programlib
	`command-line-arguments`:	iklib cmdline
	`compar-bignum`:	syslib compar numerics
	`compar-boolean`:	syslib compar misc
	`compar-char`:	syslib compar textual
	`compar-exact-integer`:	syslib compar numerics
	`compar-exact-real`:	syslib compar numerics
	`compar-false`:	syslib compar misc
	`compar-fixnum`:	syslib compar numerics
	`compar-flonum`:	syslib compar numerics
	`compar-pointer`:	syslib compar misc
	`compar-ratnum`:	syslib compar numerics
	`compar-real`:	syslib compar numerics
	`compar-string`:	syslib compar textual
	`compar-string-ci`:	syslib compar textual
	`compar-symbol`:	syslib compar textual
	`compar-transcoder`:	syslib compar misc
	`compar-true`:	syslib compar misc
	`comparison-procedure`:	iklib records defs
	`compensate`:	iklib compensations api
	`compile-core-expr->code`:	compiler full
	`compile-time-library-locator`:	libutils file-system locators compile
	`compiled-libraries-build-directory`:	libutils compiling special build
	`compiler-options`:	iklib eval
	`complement-type-spec.item-ots`:	expander specs complement
	`complement-type-spec?`:	expander specs complement
	`complex-conjugate`:	iklib numerics math
	`complex?`:	baselib math ops type pred
	`compnum-hash`:	iklib hashtables hashfun
	`compnum?`:	iklib numerics preds
	`compound-condition-type-spec.component-ots*`:	expander specs condobj
	`compound-condition-type-spec?`:	expander specs condobj
	`compound-condition?`:	iklib conditions misc
	`concurrently`:	iklib coroutines syntaxes
	`cond`:	baselib expressions derived cond
	`condition`:	stdlib exceptions conditions objects
	`condition-accessor`:	stdlib exceptions conditions objects
	`condition-accessor`:	iklib conditions core
	`condition-accessor`:	iklib conditions core
	`condition-and-rtd?`:	iklib conditions misc
	`condition-errno`:	iklib conditions errno
	`condition-failed-expression`:	iklib conditions failexpr
	`condition-irritants`:	stdlib exceptions conditions types
	`condition-message`:	stdlib exceptions conditions types
	`condition-one-based-return-value-index`:	iklib conditions exprindex
	`condition-predicate`:	stdlib exceptions conditions objects
	`condition-shared-object-closing-so-handle`:	ffi shared
	`condition-shared-object-lookup-foreign-symbol`:	ffi shared
	`condition-shared-object-lookup-so-handle`:	ffi shared
	`condition-shared-object-opening-name`:	ffi shared
	`condition-who`:	stdlib exceptions conditions types
	`condition?`:	stdlib exceptions conditions objects
	`conforming-library-name-and-library-reference?`:	libutils refs conform
	`conforming-sub-version-and-sub-version-reference?`:	libutils refs conform
	`conforming-version-and-version-reference?`:	libutils refs conform
	`cons`:	baselib lists
	`cons*`:	stdlib list
	`cons*`:	stdlib list
	`console-error-port`:	iklib io binary
	`console-error-port`:	iklib io binary
	`console-input-port`:	iklib io binary
	`console-input-port`:	iklib io binary
	`console-output-port`:	iklib io binary
	`console-output-port`:	iklib io binary
	`constructor-signature`:	iklib records defs
	`continue`:	iklib syntaxes loops while
	`continue`:	iklib syntaxes loops until
	`continue`:	iklib syntaxes loops for
	`continue`:	iklib syntaxes loops do
	`continue`:	iklib syntaxes loops fluids
	`core-type-spec.parent-and-child?`:	expander specs core
	`core-type-spec.type-descriptor-id`:	expander specs core
	`core-type-spec?`:	expander specs core
	`coroutine`:	iklib coroutines basic
	`coroutine-uid`:	iklib coroutines uid
	`coroutine-uid?`:	iklib coroutines uid
	`cos`:	baselib math ops trascend
	`cosh`:	iklib numerics math
	`cp0-effort-limit`:	compiler optimisation
	`cp0-size-limit`:	compiler optimisation
	`cpu-architecture`:	iklib env-inquiry
	`cstring->bytevector`:	iklib cstrings
	`cstring->bytevector`:	iklib cstrings
	`cstring->string`:	iklib cstrings
	`cstring->string`:	iklib cstrings
	`cstring16->bytevector`:	iklib cstrings
	`cstring16be->string`:	iklib cstrings
	`cstring16le->string`:	iklib cstrings
	`cstring16n->string`:	iklib cstrings
	`cube`:	iklib numerics math
	`current-binary-library-loader`:	libutils loading
	`current-error-port`:	stdlib io port output ports
	`current-error-port`:	stdlib io simple
	`current-error-port`:	iklib io textual
	`current-include-file-loader`:	includes
	`current-include-file-locator`:	includes
	`current-include-loader`:	includes
	`current-inferior-lexenv`:	expander lexenv internal
	`current-input-port`:	stdlib io port input ports
	`current-input-port`:	stdlib io simple
	`current-input-port`:	iklib io textual
	`current-letrec-pass`:	compiler letrec api
	`current-library-binary-search-path-scanner`:	libutils file-system binary
	`current-library-loader`:	libutils loading
	`current-library-locator`:	libutils locating
	`current-library-source-search-path-scanner`:	libutils file-system source
	`current-output-port`:	stdlib io port output ports
	`current-output-port`:	stdlib io simple
	`current-output-port`:	iklib io textual
	`current-source-library-loader`:	libutils loading
	`current-time`:	iklib time epoch
	`custom-printer`:	iklib records defs

D
	`date-string`:	iklib time date
	`datum->syntax`:	stdlib syntax-case conversion
	`debug-print`:	iklib printing debug
	`debug-print*`:	iklib printing debug
	`debug-print-enabled?`:	iklib printing debug
	`default-binary-library-loader`:	libutils loading
	`default-include-file-loader`:	includes
	`default-include-file-locator`:	includes
	`default-include-loader`:	includes
	`default-library-binary-search-path-scanner`:	libutils file-system binary
	`default-library-loader`:	libutils loading
	`default-library-source-search-path-scanner`:	libutils file-system source
	`default-source-library-loader`:	libutils loading
	`define`:	baselib definitions variables
	`define`:	baselib definitions variables
	`define`:	baselib definitions variables
	`define`:	baselib definitions variables
	`define*`:	iklib syntaxes defines
	`define*`:	iklib syntaxes defines
	`define*`:	iklib syntaxes defines
	`define*`:	iklib syntaxes defines
	`define-alias`:	iklib syntaxes defstxs
	`define-auxiliary-syntaxes`:	iklib syntaxes defstxs
	`define-condition-type`:	stdlib exceptions conditions objects
	`define-constant`:	iklib syntaxes defstxs
	`define-constant-values`:	iklib syntaxes defines
	`define-enumeration`:	stdlib enum
	`define-fluid-syntax`:	iklib expander fluids
	`define-foreign-pointer-wrapper`:	ffi foreign wrapper syntax
	`define-inline`:	iklib syntaxes defines
	`define-inline`:	iklib syntaxes integrable
	`define-inline-constant`:	iklib syntaxes defines
	`define-integrable`:	iklib syntaxes defines
	`define-integrable`:	iklib syntaxes integrable
	`define-macro`:	stdlib syntax-case lisp
	`define-record-type`:	stdlib records syntactic layer
	`define-record-type`:	iklib records defs
	`define-struct`:	syslib structs safe define
	`define-struct`:	syslib structs safe define
	`define-struct`:	syslib structs safe define
	`define-struct`:	syslib structs safe define
	`define-syntax`:	baselib definitions syntax
	`define-syntax`:	iklib syntaxes defstxs
	`define-syntax`:	iklib syntaxes defstxs
	`define-syntax`:	iklib syntaxes defstxs
	`define-syntax-parameter`:	iklib expander parameters
	`define-syntax-rule`:	iklib syntaxes defstxs
	`define-type-descriptors`:	iklib records defs
	`define-values`:	iklib syntaxes defines
	`delay`:	stdlib rfive compat
	`delete-duplicate-identifiers`:	expander utils id
	`delete-duplicate-identifiers`:	expander utils id
	`delete-file`:	stdlib files
	`denominator`:	baselib math ops part
	`deprefix`:	iklib expander export specs
	`deprefix`:	iklib expander import specs
	`destructor-protocol`:	iklib records defs
	`desuffix`:	iklib expander export specs
	`desuffix`:	iklib expander import specs
	`directory+library-stem->library-binary-pathname`:	libutils file-system pathnames
	`directory+library-stem->library-source-pathname`:	libutils file-system pathnames
	`directory-exists?`:	iklib io pathnames
	`display`:	stdlib io simple
	`display`:	stdlib io simple
	`div`:	baselib math ops arithmetic
	`div-and-mod`:	baselib math ops arithmetic
	`div0`:	baselib math ops arithmetic
	`div0-and-mod0`:	baselib math ops arithmetic
	`dlclose`:	ffi dl
	`dlerror`:	ffi dl
	`dlopen`:	ffi dl
	`dlopen`:	ffi dl
	`dlopen`:	ffi dl
	`dlsym`:	ffi dl
	`do`:	stdlib control
	`do`:	iklib syntaxes loops do
	`do`:	iklib syntaxes loops do
	`do*`:	iklib syntaxes loops do*
	`dolist`:	iklib syntaxes loops dolist
	`dolist`:	iklib syntaxes loops dolist
	`dotimes`:	iklib syntaxes loops dotimes
	`dotimes`:	iklib syntaxes loops dotimes
	`dump-coroutines`:	iklib coroutines debug
	`duplicate-identifiers?`:	expander utils id
	`duplicate-identifiers?`:	expander utils id
	`dynamic-wind`:	baselib control

E
	`else`:	baselib expressions derived cond
	`else`:	baselib expressions derived cond
	`else`:	stdlib exceptions exceptions
	`else`:	iklib syntaxes control
	`else`:	iklib syntaxes try
	`empty-bytevector?`:	iklib bytevectors predicates
	`empty-string?`:	iklib strings predicates
	`empty-vector?`:	iklib vectors predicates
	`endianness`:	stdlib bytevector general
	`endianness`:	iklib syntaxes misc
	`engine-handler`:	iklib engines
	`enum-set->list`:	stdlib enum
	`enum-set-complement`:	stdlib enum
	`enum-set-constructor`:	stdlib enum
	`enum-set-difference`:	stdlib enum
	`enum-set-hash`:	iklib hashtables hashfun
	`enum-set-indexer`:	stdlib enum
	`enum-set-intersection`:	stdlib enum
	`enum-set-member?`:	stdlib enum
	`enum-set-projection`:	stdlib enum
	`enum-set-subset?`:	stdlib enum
	`enum-set-union`:	stdlib enum
	`enum-set-universe`:	stdlib enum
	`enum-set=?`:	stdlib enum
	`enum-set?`:	iklib enumerations
	`enumeration-type-spec.member?`:	expander specs enum
	`enumeration-type-spec.symbol*`:	expander specs enum
	`enumeration-type-spec?`:	expander specs enum
	`environ`:	iklib misc
	`environment`:	stdlib eval
	`environment-binding`:	iklib environment
	`environment-labels`:	iklib environment
	`environment-libraries`:	iklib environment
	`environment-symbols`:	iklib environment
	`environment?`:	iklib environment
	`eof-object`:	stdlib io port eof object
	`eof-object`:	stdlib io simple
	`eof-object-hash`:	iklib hashtables hashfun
	`eof-object?`:	stdlib io port eof object
	`eof-object?`:	stdlib io simple
	`eol-style`:	stdlib io port transcoders
	`epoch-time-addition`:	iklib time epoch
	`epoch-time-subtraction`:	iklib time epoch
	`epoch-time?`:	iklib time epoch
	`eq?`:	baselib predicates
	`equal-hash`:	stdlib hashtable hash functions
	`equal?`:	baselib predicates
	`equality-predicate`:	iklib records defs
	`eqv?`:	baselib predicates
	`errno`:	iklib errno
	`errno`:	iklib errno
	`errno-condition?`:	iklib conditions errno
	`error`:	baselib errors
	`error-handling-mode`:	stdlib io port transcoders
	`error?`:	stdlib exceptions conditions types
	`eval`:	stdlib eval
	`eval`:	iklib eval
	`eval`:	iklib eval
	`even?`:	baselib math ops value pred
	`exact`:	baselib math ops exactness
	`exact->inexact`:	stdlib rfive compat
	`exact-compnum?`:	iklib numerics preds
	`exact-integer-hash`:	iklib hashtables hashfun
	`exact-integer-sqrt`:	baselib math ops exponentiation
	`exact-integer?`:	iklib numerics preds
	`exact?`:	baselib math ops type pred
	`exists`:	stdlib list
	`exit`:	stdlib programlib
	`exit`:	stdlib programlib
	`exit-hooks`:	iklib misc
	`exp`:	baselib math ops trascend
	`expand-form-to-core-language`:	expander utils expanding
	`expand-library`:	libutils expanding
	`expand-library`:	libutils expanding
	`expand-library`:	libutils expanding
	`expand-library->sexp`:	libutils expanding
	`expand-time-expr`:	iklib syntaxes misc
	`expand-time-value-object`:	iklib expander etv
	`expand-time-value?`:	iklib expander etv
	`expand-top-level-program`:	progutils expanding
	`expand-top-level-program->sexp`:	progutils expanding
	`expander-options`:	iklib eval
	`expansion-of`:	iklib syntaxes expansion-of
	`expansion-of*`:	iklib syntaxes expansion-of
	`expect-single-argument-and-return-false`:	iklib misc
	`expect-single-argument-and-return-it`:	iklib misc
	`expect-single-argument-and-return-true`:	iklib misc
	`export`:	iklib expander extended export
	`expression-return-value-violation`:	iklib conditions exprret
	`expression-return-value-violation?`:	iklib conditions exprret
	`expt`:	baselib math ops exponentiation

F
	`f4b-list->bytevector`:	iklib bytevectors conversion
	`f4l-list->bytevector`:	iklib bytevectors conversion
	`f4n-list->bytevector`:	iklib bytevectors conversion
	`f8b-list->bytevector`:	iklib bytevectors conversion
	`f8l-list->bytevector`:	iklib bytevectors conversion
	`f8n-list->bytevector`:	iklib bytevectors conversion
	`factorial`:	iklib numerics math
	`failed-expression-condition?`:	iklib conditions failexpr
	`false-or-c-callback?`:	ffi call back
	`false-or-pointer?`:	iklib pointers pred
	`false?`:	iklib booleans
	`faraway-time`:	iklib time epoch
	`fasl-read`:	fasl api
	`fasl-write`:	fasl api
	`fasl-write`:	fasl api
	`fields`:	stdlib records syntactic layer
	`fields`:	iklib records defs
	`fields`:	ffi foreign wrapper syntax
	`file-absolute-pathname?`:	iklib io pathnames
	`file-bytevector-absolute-pathname?`:	iklib io pathnames
	`file-bytevector-colon-search-path?`:	iklib io pathnames
	`file-bytevector-pathname?`:	iklib io pathnames
	`file-bytevector-relative-pathname?`:	iklib io pathnames
	`file-colon-search-path?`:	iklib io pathnames
	`file-exists?`:	stdlib files
	`file-options`:	stdlib io port file options
	`file-options`:	iklib io misc
	`file-pathname?`:	iklib io pathnames
	`file-relative-pathname?`:	iklib io pathnames
	`file-string-absolute-pathname?`:	iklib io pathnames
	`file-string-colon-search-path?`:	iklib io pathnames
	`file-string-pathname?`:	iklib io pathnames
	`file-string-relative-pathname?`:	iklib io pathnames
	`filename->string-func`:	iklib io pathnames
	`filter`:	stdlib list
	`finally`:	iklib syntaxes try
	`find`:	stdlib list
	`find-library-by-descriptor`:	libutils interning
	`find-library-by-name`:	libutils interning
	`find-library-by-reference`:	libutils interning
	`find-library-in-collection-by-descriptor`:	libutils interning
	`find-library-in-collection-by-name`:	libutils interning
	`find-library-in-collection-by-predicate`:	libutils interning
	`find-library-in-collection-by-reference`:	libutils interning
	`finish-coroutines`:	iklib coroutines basic
	`finish-coroutines`:	iklib coroutines basic
	`finite?`:	baselib math ops value pred
	`fixnum->char`:	iklib fixnums conversion
	`fixnum->flonum`:	stdlib arithmetic flonums
	`fixnum->string`:	iklib fixnums conversion
	`fixnum->string`:	iklib fixnums conversion
	`fixnum-hash`:	iklib hashtables hashfun
	`fixnum-in-character-range?`:	iklib chars predicates
	`fixnum-width`:	stdlib arithmetic fixnums
	`fixnum?`:	stdlib arithmetic fixnums
	`fl!=?`:	iklib flonums
	`fl*`:	stdlib arithmetic flonums
	`fl+`:	stdlib arithmetic flonums
	`fl-`:	stdlib arithmetic flonums
	`fl-`:	stdlib arithmetic flonums
	`fl/`:	stdlib arithmetic flonums
	`fl/`:	stdlib arithmetic flonums
	`fl<=?`:	stdlib arithmetic flonums
	`fl<?`:	stdlib arithmetic flonums
	`fl=?`:	stdlib arithmetic flonums
	`fl>=?`:	stdlib arithmetic flonums
	`fl>?`:	stdlib arithmetic flonums
	`flabs`:	stdlib arithmetic flonums
	`flacos`:	stdlib arithmetic flonums
	`flacosh`:	iklib flonums
	`flasin`:	stdlib arithmetic flonums
	`flasinh`:	iklib flonums
	`flatan`:	stdlib arithmetic flonums
	`flatan`:	stdlib arithmetic flonums
	`flatanh`:	iklib flonums
	`flcbrt`:	iklib flonums
	`flceiling`:	stdlib arithmetic flonums
	`flcos`:	stdlib arithmetic flonums
	`flcosh`:	iklib flonums
	`flcube`:	iklib flonums
	`fldenominator`:	stdlib arithmetic flonums
	`fldiv`:	stdlib arithmetic flonums
	`fldiv-and-mod`:	stdlib arithmetic flonums
	`fldiv0`:	stdlib arithmetic flonums
	`fldiv0-and-mod0`:	stdlib arithmetic flonums
	`fleven?`:	stdlib arithmetic flonums
	`flexp`:	stdlib arithmetic flonums
	`flexpm1`:	iklib flonums
	`flexpt`:	stdlib arithmetic flonums
	`flfinite?`:	stdlib arithmetic flonums
	`flfloor`:	stdlib arithmetic flonums
	`flhypot`:	iklib flonums
	`flinfinite?`:	stdlib arithmetic flonums
	`flinteger?`:	stdlib arithmetic flonums
	`fllog`:	stdlib arithmetic flonums
	`fllog`:	stdlib arithmetic flonums
	`fllog1p`:	iklib flonums
	`flmax`:	stdlib arithmetic flonums
	`flmin`:	stdlib arithmetic flonums
	`flmod`:	stdlib arithmetic flonums
	`flmod0`:	stdlib arithmetic flonums
	`flnan?`:	stdlib arithmetic flonums
	`flnegative?`:	stdlib arithmetic flonums
	`flnonnegative?`:	iklib flonums
	`flnonpositive?`:	iklib flonums
	`flnumerator`:	stdlib arithmetic flonums
	`flodd?`:	stdlib arithmetic flonums
	`flonum->bytevector`:	iklib debug
	`flonum->string`:	iklib flonums
	`flonum-bytes`:	iklib flonums
	`flonum-hash`:	iklib hashtables hashfun
	`flonum-hash`:	iklib hashtables hashfun
	`flonum-parts`:	iklib flonums
	`flonum?`:	stdlib arithmetic flonums
	`floor`:	baselib math ops part
	`flpositive?`:	stdlib arithmetic flonums
	`flround`:	stdlib arithmetic flonums
	`flsin`:	stdlib arithmetic flonums
	`flsinh`:	iklib flonums
	`flsqrt`:	stdlib arithmetic flonums
	`flsquare`:	iklib flonums
	`fltan`:	stdlib arithmetic flonums
	`fltanh`:	iklib flonums
	`fltruncate`:	stdlib arithmetic flonums
	`fluid-let-syntax`:	iklib expander fluids
	`flush-output-port`:	stdlib io port output ports
	`flzero?`:	stdlib arithmetic flonums
	`flzero?/negative`:	iklib flonums
	`flzero?/positive`:	iklib flonums
	`fold-left`:	stdlib list
	`fold-right`:	stdlib list
	`for`:	iklib syntaxes loops for
	`for-all`:	stdlib list
	`for-each`:	baselib lists
	`for-each-in-order`:	iklib lists misc
	`force`:	stdlib rfive compat
	`foreign-call`:	foreign
	`foreign-destructor`:	ffi foreign wrapper syntax
	`forget-to-avoid-collecting`:	iklib gc
	`format`:	iklib printing formatting
	`fprintf`:	iklib printing formatting
	`free`:	iklib memory alloc
	`free-c-callback`:	ffi call back
	`free-identifier=?`:	stdlib syntax-case identifier
	`further-optimisation-of`:	iklib syntaxes optim-of
	`further-optimisation-of*`:	iklib syntaxes optim-of
	`fx!=`:	iklib fixnums comparison
	`fx!=?`:	iklib fixnums comparison
	`fx*`:	stdlib arithmetic fixnums
	`fx*/carry`:	stdlib arithmetic fixnums
	`fx+`:	stdlib arithmetic fixnums
	`fx+/carry`:	stdlib arithmetic fixnums
	`fx-`:	stdlib arithmetic fixnums
	`fx-`:	stdlib arithmetic fixnums
	`fx-/carry`:	stdlib arithmetic fixnums
	`fx<`:	iklib fixnums comparison
	`fx<=`:	iklib fixnums comparison
	`fx<=?`:	stdlib arithmetic fixnums
	`fx<?`:	stdlib arithmetic fixnums
	`fx=`:	iklib fixnums comparison
	`fx=?`:	stdlib arithmetic fixnums
	`fx>`:	iklib fixnums comparison
	`fx>=`:	iklib fixnums comparison
	`fx>=?`:	stdlib arithmetic fixnums
	`fx>?`:	stdlib arithmetic fixnums
	`fxabs`:	iklib fixnums arithmetics
	`fxadd1`:	iklib fixnums arithmetics
	`fxand`:	stdlib arithmetic fixnums
	`fxarithmetic-shift`:	stdlib arithmetic fixnums
	`fxarithmetic-shift-left`:	stdlib arithmetic fixnums
	`fxarithmetic-shift-right`:	stdlib arithmetic fixnums
	`fxbit-count`:	stdlib arithmetic fixnums
	`fxbit-field`:	stdlib arithmetic fixnums
	`fxbit-set?`:	stdlib arithmetic fixnums
	`fxcopy-bit`:	stdlib arithmetic fixnums
	`fxcopy-bit-field`:	stdlib arithmetic fixnums
	`fxdiv`:	stdlib arithmetic fixnums
	`fxdiv-and-mod`:	stdlib arithmetic fixnums
	`fxdiv0`:	stdlib arithmetic fixnums
	`fxdiv0-and-mod0`:	stdlib arithmetic fixnums
	`fxeven?`:	stdlib arithmetic fixnums
	`fxfirst-bit-set`:	stdlib arithmetic fixnums
	`fxif`:	stdlib arithmetic fixnums
	`fxior`:	stdlib arithmetic fixnums
	`fxlength`:	stdlib arithmetic fixnums
	`fxmax`:	stdlib arithmetic fixnums
	`fxmin`:	stdlib arithmetic fixnums
	`fxmod`:	stdlib arithmetic fixnums
	`fxmod0`:	stdlib arithmetic fixnums
	`fxmodulo`:	iklib fixnums arithmetics
	`fxnegative?`:	stdlib arithmetic fixnums
	`fxnonnegative?`:	iklib fixnums predicates
	`fxnonpositive?`:	iklib fixnums predicates
	`fxnot`:	stdlib arithmetic fixnums
	`fxodd?`:	stdlib arithmetic fixnums
	`fxpositive?`:	stdlib arithmetic fixnums
	`fxquotient`:	iklib fixnums arithmetics
	`fxremainder`:	iklib fixnums arithmetics
	`fxreverse-bit-field`:	stdlib arithmetic fixnums
	`fxrotate-bit-field`:	stdlib arithmetic fixnums
	`fxsign`:	iklib fixnums arithmetics
	`fxsub1`:	iklib fixnums arithmetics
	`fxxor`:	stdlib arithmetic fixnums
	`fxzero?`:	stdlib arithmetic fixnums
	`fx_mask`:	objects fixnums
	`fx_shift`:	objects fixnums
	`fx_tag`:	objects fixnums

G
	`gcd`:	baselib math ops arithmetic
	`generate-debug-calls`:	debug int intro
	`generate-descriptive-labels`:	compiler options
	`generate-temporaries`:	stdlib syntax-case temporaries
	`gensym`:	iklib gensym
	`gensym`:	iklib gensym
	`gensym`:	iklib gensym
	`gensym->unique-string`:	iklib gensym
	`gensym-count`:	iklib printing pretty
	`gensym-count`:	iklib printing pretty
	`gensym-prefix`:	iklib printing pretty
	`gensym-prefix`:	iklib printing pretty
	`gensym?`:	iklib gensym
	`get-annotated-datum`:	iklib reader annotations
	`get-bytevector-all`:	stdlib io port binary input
	`get-bytevector-n`:	stdlib io port binary input
	`get-bytevector-n`:	iklib io non-blocking binary
	`get-bytevector-n!`:	stdlib io port binary input
	`get-bytevector-n!`:	iklib io non-blocking binary
	`get-bytevector-some`:	stdlib io port binary input
	`get-bytevector-some`:	iklib io non-blocking binary
	`get-char`:	stdlib io port textual input
	`get-char`:	iklib io non-blocking textual
	`get-char-and-track-textual-position`:	iklib io textual
	`get-datum`:	stdlib io port textual input
	`get-line`:	stdlib io port textual input
	`get-output-string`:	iklib io textual
	`get-string-all`:	stdlib io port textual input
	`get-string-all`:	iklib io non-blocking textual
	`get-string-n`:	stdlib io port textual input
	`get-string-n`:	iklib io non-blocking textual
	`get-string-n!`:	stdlib io port textual input
	`get-string-n!`:	iklib io non-blocking textual
	`get-string-some`:	iklib io non-blocking textual
	`get-string-some`:	iklib io textual
	`get-u8`:	stdlib io port binary input
	`get-u8`:	iklib io non-blocking binary
	`getenv`:	iklib misc
	`getprop`:	iklib symbols plists
	`greatest-fixnum`:	stdlib arithmetic fixnums
	`greatest-negative-bignum`:	iklib numerics bignums
	`greek-pi`:	iklib numerics constants
	`greek-pi*2`:	iklib numerics constants
	`greek-pi*2/3`:	iklib numerics constants
	`greek-pi*3/4`:	iklib numerics constants
	`greek-pi/2`:	iklib numerics constants
	`greek-pi/3`:	iklib numerics constants
	`greek-pi/4`:	iklib numerics constants
	`greek-pi/6`:	iklib numerics constants
	`guard`:	stdlib exceptions exceptions
	`guarded-calloc`:	iklib memory alloc
	`guarded-malloc`:	iklib memory alloc
	`guarded-realloc`:	iklib memory alloc
	`guarded-start`:	debug int intro
	`guarded-strdup`:	iklib cstrings
	`guarded-strndup`:	iklib cstrings

H
	`hash-function`:	iklib records defs
	`hashtable->alist`:	iklib hashtables iterators
	`hashtable->alist`:	iklib hashtables iterators
	`hashtable-clear!`:	stdlib hashtable procedures
	`hashtable-clear!`:	stdlib hashtable procedures
	`hashtable-contains?`:	stdlib hashtable procedures
	`hashtable-copy`:	stdlib hashtable procedures
	`hashtable-copy`:	stdlib hashtable procedures
	`hashtable-delete!`:	stdlib hashtable procedures
	`hashtable-entries`:	stdlib hashtable procedures
	`hashtable-eq?`:	iklib hashtables pred
	`hashtable-equiv?`:	iklib hashtables pred
	`hashtable-equivalence-function`:	stdlib hashtable inspection
	`hashtable-eqv?`:	iklib hashtables pred
	`hashtable-exists-entry`:	iklib hashtables iterators
	`hashtable-exists-key`:	iklib hashtables iterators
	`hashtable-find-entry`:	iklib hashtables iterators
	`hashtable-find-key`:	iklib hashtables iterators
	`hashtable-fold-entries`:	iklib hashtables iterators
	`hashtable-fold-keys`:	iklib hashtables iterators
	`hashtable-for-all-entries`:	iklib hashtables iterators
	`hashtable-for-all-keys`:	iklib hashtables iterators
	`hashtable-for-each-entry`:	iklib hashtables iterators
	`hashtable-for-each-key`:	iklib hashtables iterators
	`hashtable-hash-function`:	stdlib hashtable inspection
	`hashtable-keys`:	stdlib hashtable procedures
	`hashtable-map-entries`:	iklib hashtables iterators
	`hashtable-map-keys`:	iklib hashtables iterators
	`hashtable-mutable?`:	stdlib hashtable inspection
	`hashtable-ref`:	stdlib hashtable procedures
	`hashtable-ref`:	stdlib hashtable procedures
	`hashtable-set!`:	stdlib hashtable procedures
	`hashtable-size`:	stdlib hashtable procedures
	`hashtable-type-spec.key-ots`:	expander specs hashtable
	`hashtable-type-spec.val-ots`:	expander specs hashtable
	`hashtable-type-spec?`:	expander specs hashtable
	`hashtable-update!`:	stdlib hashtable procedures
	`hashtable?`:	stdlib hashtable procedures
	`hex->bytevector`:	iklib bytevectors conversion
	`host-info`:	iklib env-inquiry

I
	`i/o-decoding-error?`:	stdlib io port transcoders
	`i/o-eagain-error?`:	iklib conditions eagain
	`i/o-encoding-error-char`:	stdlib io port transcoders
	`i/o-encoding-error?`:	stdlib io port transcoders
	`i/o-error-filename`:	stdlib io conditions
	`i/o-error-port`:	stdlib io conditions
	`i/o-error-position`:	stdlib io conditions
	`i/o-error?`:	stdlib io conditions
	`i/o-file-already-exists-error?`:	stdlib io conditions
	`i/o-file-does-not-exist-error?`:	stdlib io conditions
	`i/o-file-is-read-only-error?`:	stdlib io conditions
	`i/o-file-protection-error?`:	stdlib io conditions
	`i/o-filename-error?`:	stdlib io conditions
	`i/o-invalid-position-error?`:	stdlib io conditions
	`i/o-port-error?`:	stdlib io conditions
	`i/o-read-error?`:	stdlib io conditions
	`i/o-write-error?`:	stdlib io conditions
	`i/o-wrong-fasl-header-error-error?`:	iklib conditions wfs
	`icar`:	iklib ipairs
	`icdr`:	iklib ipairs
	`identifier->string`:	expander utils id
	`identifier-append`:	expander utils id
	`identifier-bound?`:	expander utils id
	`identifier-format`:	expander utils id
	`identifier-memq`:	expander utils id
	`identifier-memq`:	expander utils id
	`identifier-prefix`:	expander utils id
	`identifier-record-constructor`:	expander utils records
	`identifier-record-field-accessor`:	expander utils records
	`identifier-record-field-mutator`:	expander utils records
	`identifier-record-predicate`:	expander utils records
	`identifier-struct-constructor`:	expander utils structs
	`identifier-struct-field-accessor`:	expander utils structs
	`identifier-struct-field-mutator`:	expander utils structs
	`identifier-struct-predicate`:	expander utils structs
	`identifier-suffix`:	expander utils id
	`identifier-syntax`:	baselib transformers
	`identifier-syntax`:	baselib transformers
	`identifier=symbol?`:	expander utils compar
	`identifier?`:	stdlib syntax-case identifier
	`identifiers->list`:	expander utils pairs
	`identifiers->list`:	expander utils pairs
	`if`:	baselib expressions conditionals
	`if`:	baselib expressions conditionals
	`IKA_BIGNUM_ALLOC`:	objects bignums
	`ika_bytevector_alloc`:	objects bytevectors
	`ika_bytevector_from_cstring`:	objects bytevectors
	`ika_bytevector_from_cstring_len`:	objects bytevectors
	`ika_bytevector_from_memory_block`:	objects bytevectors
	`ika_bytevector_from_utf16z`:	objects bytevectors
	`ika_cflonum_from_doubles`:	objects cflonums
	`ika_compnum_alloc_and_init`:	objects compnums
	`ika_compnum_alloc_no_init`:	objects compnums
	`ika_flonum_from_double`:	objects flonums
	`ika_integer_from_int`:	objects integers
	`ika_integer_from_llong`:	objects integers
	`ika_integer_from_long`:	objects integers
	`ika_integer_from_off_t`:	objects integers
	`ika_integer_from_ptrdiff_t`:	objects integers
	`ika_integer_from_sint16`:	objects integers
	`ika_integer_from_sint32`:	objects integers
	`ika_integer_from_sint64`:	objects integers
	`ika_integer_from_sint8`:	objects integers
	`ika_integer_from_size_t`:	objects integers
	`ika_integer_from_ssize_t`:	objects integers
	`ika_integer_from_sword`:	objects integers
	`ika_integer_from_sword`:	objects integers
	`ika_integer_from_uint`:	objects integers
	`ika_integer_from_uint16`:	objects integers
	`ika_integer_from_uint32`:	objects integers
	`ika_integer_from_uint64`:	objects integers
	`ika_integer_from_uint8`:	objects integers
	`ika_integer_from_ullong`:	objects integers
	`ika_integer_from_ulong`:	objects integers
	`ika_integer_from_uword`:	objects integers
	`ika_integer_from_uword`:	objects integers
	`ika_list_from_argv`:	objects pairs
	`ika_list_from_argv_and_argc`:	objects pairs
	`IKA_PAIR_ALLOC`:	objects pairs
	`ika_pair_alloc`:	objects pairs
	`ika_pointer_alloc`:	objects pointers
	`ika_ratnum_alloc_and_init`:	objects ratnums
	`ika_ratnum_alloc_no_init`:	objects ratnums
	`ika_string_alloc`:	objects strings
	`ika_string_from_cstring`:	objects strings
	`ika_struct_alloc_and_init`:	objects structs
	`ika_struct_alloc_no_init`:	objects structs
	`ika_vector_alloc_and_init`:	objects vectors
	`ika_vector_alloc_no_init`:	objects vectors
	`ikpair?`:	iklib ipairs
	`ikrt_bytevector_copy`:	objects bytevectors
	`ikrt_general_copy`:	objects misc func
	`ikrt_is_pointer`:	objects pointers
	`ikrt_vector_clean`:	objects vectors
	`ikrt_vector_copy`:	objects vectors
	`iku_cflonum_alloc_and_init`:	objects cflonums
	`iku_flonum_alloc`:	objects flonums
	`IKU_PAIR_ALLOC`:	objects pairs
	`iku_pair_alloc`:	objects pairs
	`iku_pointer_alloc`:	objects pointers
	`iku_string_alloc`:	objects strings
	`iku_string_from_cstring`:	objects strings
	`iku_string_to_symbol`:	objects strings
	`iku_symbol_from_string`:	objects symbols ops
	`iku_vector_alloc_and_init`:	objects vectors
	`iku_vector_alloc_no_init`:	objects vectors
	`IK_ALIGN`:	objects memory alloc
	`IK_ALIGN_TO_NEXT_PAGE`:	objects memory pages
	`IK_ALIGN_TO_PREV_PAGE`:	objects memory pages
	`IK_ASS`:	objects memory alloc
	`IK_BIGNUM_ALLOC_SIZE`:	objects bignums
	`IK_BIGNUM_DATA_LIMBP`:	objects bignums
	`IK_BIGNUM_DATA_VOIDP`:	objects bignums
	`IK_BIGNUM_FIRST`:	objects bignums
	`IK_BIGNUM_FIRST_LIMB`:	objects bignums
	`IK_BIGNUM_LAST_LIMB`:	objects bignums
	`IK_BOOLEAN_FROM_INT`:	objects booleans
	`IK_BOOLEAN_TO_INT`:	objects booleans
	`IK_BWP`:	objects refs
	`IK_BWP_OBJECT`:	objects refs
	`IK_BYTEVECTOR_DATA`:	objects bytevectors
	`IK_BYTEVECTOR_DATA_CHARP`:	objects bytevectors
	`IK_BYTEVECTOR_DATA_UINT8P`:	objects bytevectors
	`IK_BYTEVECTOR_DATA_VOIDP`:	objects bytevectors
	`IK_BYTEVECTOR_LENGTH`:	objects bytevectors
	`IK_BYTEVECTOR_LENGTH_FX`:	objects bytevectors
	`IK_CAAR`:	objects pairs
	`IK_CAAR_PTR`:	objects pairs
	`IK_CADR`:	objects pairs
	`IK_CADR_PTR`:	objects pairs
	`IK_CAR`:	objects pairs
	`IK_CAR_PTR`:	objects pairs
	`IK_CDAR`:	objects pairs
	`IK_CDAR_PTR`:	objects pairs
	`IK_CDDR`:	objects pairs
	`IK_CDDR_PTR`:	objects pairs
	`IK_CDR`:	objects pairs
	`IK_CDR_PTR`:	objects pairs
	`IK_CFLONUM_IMAG`:	objects cflonums
	`IK_CFLONUM_IMAG_PTR`:	objects cflonums
	`IK_CFLONUM_IMP`:	objects cflonums
	`IK_CFLONUM_IMP_PTR`:	objects cflonums
	`IK_CFLONUM_REAL`:	objects cflonums
	`IK_CFLONUM_REAL_PTR`:	objects cflonums
	`IK_CFLONUM_REP`:	objects cflonums
	`IK_CFLONUM_REP_PTR`:	objects cflonums
	`IK_CHAR32`:	objects strings
	`IK_CHAR32_FROM_INTEGER`:	objects chars
	`IK_CHAR32_TO_INTEGER`:	objects chars
	`IK_CHARP_FROM_BYTEVECTOR_OR_FALSE`:	objects misc charp
	`IK_CHARP_FROM_BYTEVECTOR_OR_POINTER`:	objects misc charp
	`IK_CHARP_FROM_BYTEVECTOR_OR_POINTER_OR_FALSE`:	objects misc charp
	`IK_CHARP_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK`:	objects misc charp
	`IK_CHARP_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_CHARP_FROM_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_CHARP_FROM_POINTER_OR_FALSE`:	objects misc charp
	`IK_CHARP_FROM_POINTER_OR_MBLOCK`:	objects misc charp
	`IK_CHARP_FROM_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_CHAR_FROM_INTEGER`:	objects chars
	`IK_CHAR_TO_INTEGER`:	objects chars
	`IK_CLOSURE_CODE_OBJECT`:	objects closures
	`IK_CLOSURE_ENTRY_POINT`:	objects closures
	`IK_CLOSURE_FREE_VAR`:	objects closures
	`IK_CLOSURE_NUMBER_OF_FREE_VARS`:	objects closures
	`IK_CODE_ENTRY_POINT`:	objects codes ops
	`IK_COMPNUM_IMAG`:	objects compnums
	`IK_COMPNUM_IMAG_PTR`:	objects compnums
	`IK_COMPNUM_IMP`:	objects compnums
	`IK_COMPNUM_IMP_PTR`:	objects compnums
	`IK_COMPNUM_REAL`:	objects compnums
	`IK_COMPNUM_REAL_PTR`:	objects compnums
	`IK_COMPNUM_REP`:	objects compnums
	`IK_COMPNUM_REP_PTR`:	objects compnums
	`IK_COMPNUM_TAG`:	objects compnums
	`IK_COMPOSE_BIGNUM_FIRST_WORD`:	objects bignums
	`ik_enter_c_function`:	objects callbacks
	`IK_EOF`:	objects refs
	`IK_EOF_OBJECT`:	objects refs
	`IK_FALSE`:	objects refs
	`IK_FALSE_OBJECT`:	objects refs
	`IK_FIELD`:	objects structs
	`IK_FIELD_PTR`:	objects structs
	`IK_FIX`:	objects fixnums
	`IK_FLONUM_DATA`:	objects flonums
	`IK_FLONUM_TAG`:	objects flonums
	`IK_FLONUM_VOIDP`:	objects flonums
	`IK_FORWARD_PTR`:	objects refs
	`IK_GENERALISED_C_BUFFER`:	objects misc cbuffers
	`ik_generalised_c_buffer_len`:	objects misc cbuffers
	`IK_GENERALISED_C_BUFFER_OR_FALSE`:	objects misc cbuffers
	`IK_GENERALISED_C_STICKY_BUFFER`:	objects misc cbuffers
	`IK_GENERALISED_C_STICKY_BUFFER_OR_FALSE`:	objects misc cbuffers
	`IK_GENERALISED_C_STRING`:	objects misc cbuffers
	`IK_GENERALISED_C_STRING_OR_FALSE`:	objects misc cbuffers
	`ik_integer_to_int`:	objects integers
	`ik_integer_to_llong`:	objects integers
	`ik_integer_to_long`:	objects integers
	`ik_integer_to_off_t`:	objects integers
	`ik_integer_to_ptrdiff_t`:	objects integers
	`ik_integer_to_sint16`:	objects integers
	`ik_integer_to_sint32`:	objects integers
	`ik_integer_to_sint64`:	objects integers
	`ik_integer_to_sint8`:	objects integers
	`ik_integer_to_size_t`:	objects integers
	`ik_integer_to_ssize_t`:	objects integers
	`ik_integer_to_uint`:	objects integers
	`ik_integer_to_uint16`:	objects integers
	`ik_integer_to_uint32`:	objects integers
	`ik_integer_to_uint64`:	objects integers
	`ik_integer_to_uint8`:	objects integers
	`ik_integer_to_ullong`:	objects integers
	`ik_integer_to_ulong`:	objects integers
	`IK_IS_ANY_CONTINUATION`:	objects continuations intro
	`ik_is_bignum`:	objects integers
	`IK_IS_BOOLEAN`:	objects booleans
	`IK_IS_BYTEVECTOR`:	objects bytevectors
	`IK_IS_CFLONUM`:	objects cflonums
	`ik_is_cflonum`:	objects cflonums
	`IK_IS_CHAR`:	objects chars
	`IK_IS_CLOSURE`:	objects closures
	`IK_IS_CODE`:	objects codes ops
	`IK_IS_COMPNUM`:	objects compnums
	`ik_is_compnum`:	objects compnums
	`IK_IS_CONTINUATION`:	objects continuations intro
	`IK_IS_FIXNUM`:	objects fixnums
	`IK_IS_FLONUM`:	objects flonums
	`ik_is_flonum`:	objects flonums
	`IK_IS_INTEGER`:	objects integers
	`IK_IS_PAIR`:	objects pairs
	`IK_IS_POINTER`:	objects pointers
	`ik_is_pointer`:	objects pointers
	`IK_IS_RATNUM`:	objects ratnums
	`ik_is_ratnum`:	objects ratnums
	`IK_IS_STRING`:	objects strings
	`IK_IS_STRUCT`:	objects structs
	`ik_is_struct`:	objects structs
	`ik_is_symbol`:	objects symbols ops
	`IK_IS_SYSTEM_CONTINUATION`:	objects continuations intro
	`IK_IS_VECTOR`:	objects vectors
	`ik_is_vector`:	objects vectors
	`IK_ITEM`:	objects vectors
	`IK_ITEM_PTR`:	objects vectors
	`ik_leave_c_function`:	objects callbacks
	`IK_LIMB`:	objects bignums
	`ik_list_length`:	objects pairs
	`ik_list_to_argv`:	objects pairs
	`ik_list_to_argv_and_argc`:	objects pairs
	`IK_MBLOCK_DATA_CHARP`:	objects misc mblock
	`IK_MBLOCK_DATA_VOIDP`:	objects misc mblock
	`IK_MBLOCK_POINTER`:	objects misc mblock
	`IK_MBLOCK_SIZE`:	objects misc mblock
	`IK_MBLOCK_SIZE_T`:	objects misc mblock
	`IK_MINIMUM_PAGES_NUMBER_FOR_SIZE`:	objects memory pages
	`IK_MMAP_ALLOCATION_SIZE`:	objects memory pages
	`IK_MMAP_ALLOCATION_SIZE_FOR_PAGES`:	objects memory pages
	`IK_NEGATIVE_BIGNUM_FIRST_WORD`:	objects bignums
	`IK_NULL`:	objects refs
	`IK_NULL_OBJECT`:	objects refs
	`IK_PAGE_INDEX`:	objects memory pages
	`IK_PAGE_INDEX_RANGE`:	objects memory pages
	`IK_PAGE_POINTER_FROM_INDEX`:	objects memory pages
	`IK_POINTER_DATA`:	objects pointers
	`IK_POINTER_DATA_CHARP`:	objects pointers
	`IK_POINTER_DATA_LLONG`:	objects pointers
	`IK_POINTER_DATA_LONG`:	objects pointers
	`IK_POINTER_DATA_UINT8P`:	objects pointers
	`IK_POINTER_DATA_ULLONG`:	objects pointers
	`IK_POINTER_DATA_ULONG`:	objects pointers
	`IK_POINTER_DATA_VOIDP`:	objects pointers
	`IK_POINTER_FROM_BYTEVECTOR_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_BYTEVECTOR_OR_FALSE`:	objects misc charp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER`:	objects misc voidp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER`:	objects misc charp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_FALSE`:	objects misc charp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK`:	objects misc voidp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK`:	objects misc charp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_POINTER_FROM_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_POINTER_FROM_POINTER_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_POINTER_OR_FALSE`:	objects misc charp
	`IK_POINTER_FROM_POINTER_OR_MBLOCK`:	objects misc voidp
	`IK_POINTER_FROM_POINTER_OR_MBLOCK`:	objects misc charp
	`IK_POINTER_FROM_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_POINTER_FROM_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc charp
	`IK_POINTER_IS_NULL`:	objects pointers
	`IK_POINTER_SET`:	objects pointers
	`IK_POINTER_SET_NULL`:	objects pointers
	`IK_POINTER_TAG`:	objects pointers
	`IK_POSITIVE_BIGNUM_FIRST_WORD`:	objects bignums
	`IK_PTR`:	objects refs
	`IK_RATNUM_DEN`:	objects ratnums
	`IK_RATNUM_DEN_PTR`:	objects ratnums
	`IK_RATNUM_NUM`:	objects ratnums
	`IK_RATNUM_NUM_PTR`:	objects ratnums
	`IK_RATNUM_TAG`:	objects ratnums
	`IK_REF`:	objects refs
	`ik_safe_alloc`:	objects memory alloc
	`IK_SEGMENT_INDEX`:	objects memory segments
	`IK_SIGNAL_DIRT`:	objects memory alloc
	`ik_signal_dirt_in_page_of_pointer`:	objects memory alloc
	`IK_STD_DESTRUCTOR`:	objects structs
	`IK_STD_FIELDS`:	objects structs
	`IK_STD_LENGTH`:	objects structs
	`IK_STD_NAME`:	objects structs
	`IK_STD_PRINTER`:	objects structs
	`IK_STD_STD`:	objects structs
	`IK_STD_SYMBOL`:	objects structs
	`IK_STRING_DATA_IKCHARP`:	objects strings
	`IK_STRING_DATA_VOIDP`:	objects strings
	`IK_STRING_LENGTH`:	objects strings
	`IK_STRING_LENGTH_FX`:	objects strings
	`IK_STRUCT_FIELDS_VOIDP`:	objects structs
	`IK_STRUCT_RTD`:	objects structs
	`IK_STRUCT_RTD_PTR`:	objects structs
	`IK_STRUCT_STD`:	objects structs
	`IK_STRUCT_STD_PTR`:	objects structs
	`IK_TAGOF`:	objects refs
	`ik_the_pcb`:	objects memory alloc
	`IK_TRUE`:	objects refs
	`IK_TRUE_OBJECT`:	objects refs
	`IK_UNBOUND`:	objects refs
	`IK_UNBOUND_OBJECT`:	objects refs
	`IK_UNFIX`:	objects fixnums
	`IK_UNICODE_FROM_ASCII`:	objects chars
	`ik_unsafe_alloc`:	objects memory alloc
	`IK_VECTOR_LENGTH`:	objects vectors
	`IK_VECTOR_LENGTH_FX`:	objects vectors
	`IK_VOID`:	objects refs
	`IK_VOIDP_FROM_BYTEVECTOR_OR_FALSE`:	objects misc voidp
	`IK_VOIDP_FROM_BYTEVECTOR_OR_POINTER`:	objects misc voidp
	`IK_VOIDP_FROM_BYTEVECTOR_OR_POINTER_OR_FALSE`:	objects misc voidp
	`IK_VOIDP_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK`:	objects misc voidp
	`IK_VOIDP_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_VOIDP_FROM_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_VOIDP_FROM_POINTER_OR_FALSE`:	objects misc voidp
	`IK_VOIDP_FROM_POINTER_OR_MBLOCK`:	objects misc voidp
	`IK_VOIDP_FROM_POINTER_OR_MBLOCK_OR_FALSE`:	objects misc voidp
	`IK_VOID_OBJECT`:	objects refs
	`imag-part`:	baselib math ops complex
	`immediate?`:	iklib misc
	`implementation-name`:	iklib env-inquiry
	`implementation-restriction-violation?`:	stdlib exceptions conditions types
	`implementation-version`:	iklib env-inquiry
	`implements`:	iklib records defs
	`import`:	iklib expander local import
	`include`:	includes
	`include`:	includes
	`inexact`:	baselib math ops exactness
	`inexact->exact`:	stdlib rfive compat
	`inexact-compnum?`:	iklib numerics preds
	`inexact?`:	baselib math ops type pred
	`infinite?`:	baselib math ops value pred
	`infix`:	iklib syntaxes infix
	`initialise-compiler`:	compiler options
	`initialise-expander`:	expander options
	`input-file-buffer-size`:	iklib io buffer
	`input-file-buffer-size`:	iklib io buffer
	`input-only-port?`:	iklib io misc
	`input-only-port?`:	iklib io misc
	`input-port?`:	stdlib io port input ports
	`input-port?`:	stdlib io simple
	`input/output-file-buffer-size`:	iklib io buffer
	`input/output-file-buffer-size`:	iklib io buffer
	`input/output-port?`:	iklib io misc
	`input/output-socket-buffer-size`:	iklib io buffer
	`input/output-socket-buffer-size`:	iklib io buffer
	`integer->char`:	baselib characters
	`integer->machine-word`:	iklib debug
	`integer->pointer`:	iklib pointers conv
	`integer-valued?`:	baselib math ops type pred
	`integer?`:	baselib math ops type pred
	`interaction-environment`:	iklib environment
	`interaction-environment`:	iklib environment
	`interaction-lexical-environment?`:	iklib environment
	`interface-type-spec?`:	expander specs interface
	`internal-body`:	iklib syntaxes body
	`interned-libraries`:	libutils interning
	`interned-libraries`:	libutils interning
	`interrupt-handler`:	iklib engines
	`intersection-of-type-specs`:	expander specs intersection
	`intersection-type-spec.item-ots*`:	expander specs intersection
	`intersection-type-spec?`:	expander specs intersection
	`invoke-library`:	libutils libraries ops
	`ipair`:	iklib ipairs
	`ipair-hash`:	iklib hashtables hashfun
	`irritants-condition?`:	stdlib exceptions conditions types

K
	`keyword->string`:	iklib keywords
	`keyword->symbol`:	iklib keywords
	`keyword-hash`:	iklib keywords
	`keyword=?`:	iklib keywords
	`keyword?`:	iklib keywords

L
	`label->syntactic-binding-descriptor`:	expander lexenv inspection
	`label->syntactic-binding-descriptor/no-indirection`:	expander lexenv inspection
	`label-type-spec?`:	expander specs label
	`lambda`:	baselib expressions procedures
	`lambda*`:	iklib syntaxes lambdas star
	`lambda-signature.argvals`:	expander specs signatures lambda
	`lambda-signature.retvals`:	expander specs signatures lambda
	`lambda-signature?`:	expander specs signatures lambda
	`last-pair`:	iklib lists misc
	`late-binding-error?`:	iklib conditions late-bind base
	`latin-1-C0-control?`:	iklib chars unicode latin1
	`latin-1-C1-control?`:	iklib chars unicode latin1
	`latin-1-code-point?`:	iklib chars unicode latin1
	`latin-1-codec`:	stdlib io port transcoders
	`latin-1-control?`:	iklib chars unicode latin1
	`latin-1-decode`:	iklib chars unicode latin1
	`latin-1-encode`:	iklib chars unicode latin1
	`latin-1-graphic?`:	iklib chars unicode latin1
	`latin1->string`:	iklib strings conversion
	`latin1-encoded-bytevector?`:	iklib bytevectors conversion
	`latin1-encoded-string?`:	iklib strings conversion
	`lcm`:	baselib math ops arithmetic
	`least-fixnum`:	stdlib arithmetic fixnums
	`least-positive-bignum`:	iklib numerics bignums
	`length`:	baselib lists
	`let`:	baselib expressions binding
	`let`:	baselib iteration
	`let*`:	baselib expressions binding
	`let*-constants`:	iklib syntaxes bindings
	`let*-syntax`:	iklib syntaxes bindings
	`let*-values`:	baselib expressions binding
	`let-constants`:	iklib syntaxes bindings
	`let-syntax`:	baselib syntax binding
	`let-values`:	baselib expressions binding
	`letrec`:	baselib expressions binding
	`letrec*`:	baselib expressions binding
	`letrec*-constants`:	iklib syntaxes bindings
	`letrec-constants`:	iklib syntaxes bindings
	`letrec-syntax`:	baselib syntax binding
	`lexical-violation?`:	stdlib exceptions conditions types
	`library`:	scheme library form
	`library-binary-search-path`:	libutils file-system paths
	`library-descriptor`:	libutils libraries typedef
	`library-descriptor-name`:	libutils libraries typedef
	`library-descriptor-uid`:	libutils libraries typedef
	`library-descriptor?`:	libutils libraries typedef
	`library-dynamic-load-and-intern`:	libutils dynamic
	`library-dynamic-retrieve`:	libutils dynamic
	`library-export-subst`:	libutils libraries typedef
	`library-extensions`:	libutils file-system extensions
	`library-foreign-library*`:	libutils libraries typedef
	`library-global-env`:	libutils libraries global-env
	`library-guard-code`:	libutils libraries typedef
	`library-guard-lib*`:	libutils libraries typedef
	`library-imp-lib*`:	libutils libraries typedef
	`library-inv-lib*`:	libutils libraries typedef
	`library-invoke-code`:	libutils libraries typedef
	`library-invoke-state`:	libutils libraries typedef
	`library-loaded-from-binary-file?`:	libutils libraries typedef
	`library-loaded-from-source-file?`:	libutils libraries typedef
	`library-name`:	libutils libraries typedef
	`library-name->filename-stem`:	libutils file-system pathnames
	`library-name->identifiers`:	libutils names split
	`library-name->library-binary-pathname-in-build-directory`:	libutils file-system pathnames
	`library-name->version`:	libutils names split
	`library-name-decompose`:	libutils names split
	`library-name-identifiers=?`:	libutils names compar
	`library-name<=?`:	libutils names compar
	`library-name<?`:	libutils names compar
	`library-name=?`:	libutils names compar
	`library-name?`:	libutils names pred
	`library-option*`:	libutils libraries typedef
	`library-reference->filename-stem`:	libutils file-system pathnames
	`library-reference->identifiers`:	libutils refs split
	`library-reference->library-binary-pathname-in-build-directory`:	libutils file-system pathnames
	`library-reference->version`:	libutils refs split
	`library-reference-decompose`:	libutils refs split
	`library-reference-identifiers=?`:	libutils refs compar
	`library-reference?`:	libutils refs pred
	`library-source-file-name`:	libutils libraries typedef
	`library-source-pathname->library-binary-tail-pathname`:	libutils file-system pathnames
	`library-source-pathname->library-stem-pathname`:	libutils file-system pathnames
	`library-source-search-path`:	libutils file-system paths
	`library-sub-version-reference?`:	libutils refs pred
	`library-sub-version?`:	libutils refs pred
	`library-typed-locs`:	libutils libraries typedef
	`library-uid`:	libutils libraries typedef
	`library-version-number?`:	libutils names pred
	`library-version-numbers?`:	libutils names pred
	`library-version-reference?`:	libutils refs pred
	`library-version<=?`:	libutils names compar
	`library-version<?`:	libutils names compar
	`library-version=?`:	libutils names compar
	`library-vis-lib*`:	libutils libraries typedef
	`library-visible?`:	libutils libraries typedef
	`library-visit-code`:	libutils libraries typedef
	`library-visit-state`:	libutils libraries typedef
	`library?`:	libutils libraries typedef
	`lisp-transformer`:	stdlib syntax-case lisp
	`list`:	baselib lists
	`list->string`:	baselib strings
	`list->vector`:	baselib vectors
	`list-hash`:	iklib hashtables hashfun
	`list-hash`:	iklib hashtables hashfun
	`list-of-booleans?`:	iklib booleans
	`list-of-bytevector-pathnames?`:	iklib io pathnames
	`list-of-bytevectors?`:	iklib bytevectors predicates
	`list-of-chars?`:	iklib chars predicates
	`list-of-conditions?`:	iklib conditions preds
	`list-of-epoch-times?`:	iklib time epoch
	`list-of-fixnums?`:	iklib fixnums predicates
	`list-of-flonums?`:	iklib flonums
	`list-of-nestrings?`:	iklib strings predicates
	`list-of-pathnames?`:	iklib io pathnames
	`list-of-pointers?`:	iklib pointers pred
	`list-of-simple-conditions?`:	iklib conditions preds
	`list-of-single-item?`:	iklib lists misc
	`list-of-string-pathnames?`:	iklib io pathnames
	`list-of-strings?`:	iklib strings predicates
	`list-of-symbols?`:	iklib symbols predicates
	`list-of-times?`:	iklib time time
	`list-of-transcoders?`:	iklib io codecs
	`list-of-type-spec.item-ots`:	expander specs list-of
	`list-of-type-spec?`:	expander specs list-of
	`list-of-vectors-of-same-length?`:	iklib vectors predicates
	`list-of-vectors?`:	iklib vectors predicates
	`list-ref`:	baselib lists
	`list-sort`:	stdlib sorting
	`list-tail`:	baselib lists
	`list-type-spec.item-ots*`:	expander specs list
	`list-type-spec.length`:	expander specs list
	`list-type-spec?`:	expander specs list
	`list?`:	baselib lists
	`load`:	iklib load
	`load`:	iklib load
	`log`:	baselib math ops trascend
	`log`:	baselib math ops trascend
	`lookahead-char`:	stdlib io port textual input
	`lookahead-char`:	iklib io non-blocking textual
	`lookahead-two-u8`:	iklib io binary
	`lookahead-u8`:	stdlib io port binary input
	`lookahead-u8`:	iklib io non-blocking binary
	`lookup-shared-object`:	ffi shared

M
	`machine-name`:	iklib env-inquiry
	`machine-word->integer`:	iklib debug
	`magnitude`:	baselib math ops complex
	`make-alist-type-spec`:	expander specs alist
	`make-ancestor-of-type-spec`:	expander specs ancestor
	`make-assertion-violation`:	stdlib exceptions conditions types
	`make-binary-file-descriptor-input-port`:	iklib io binary
	`make-binary-file-descriptor-input-port*`:	iklib io binary
	`make-binary-file-descriptor-input/output-port`:	iklib io binary
	`make-binary-file-descriptor-input/output-port*`:	iklib io binary
	`make-binary-file-descriptor-output-port`:	iklib io binary
	`make-binary-file-descriptor-output-port*`:	iklib io binary
	`make-binary-socket-input-port`:	iklib io binary
	`make-binary-socket-input-port*`:	iklib io binary
	`make-binary-socket-input/output-port`:	iklib io binary
	`make-binary-socket-input/output-port*`:	iklib io binary
	`make-binary-socket-output-port`:	iklib io binary
	`make-binary-socket-output-port*`:	iklib io binary
	`make-bytevector`:	stdlib bytevector general
	`make-bytevector`:	stdlib bytevector general
	`make-c-callback-maker`:	ffi call back
	`make-c-callout-maker`:	ffi call out
	`make-c-callout-maker/with-errno`:	ffi call out
	`make-case-lambda-signature`:	expander specs signatures case-lambda
	`make-closure-type-spec`:	expander specs closure
	`make-code`:	syslib codes safe
	`make-comparison-procedure`:	syslib compar
	`make-complement-type-spec`:	expander specs complement
	`make-compound-condition-type-spec`:	expander specs condobj
	`make-custom-binary-input-port`:	stdlib io port input ports
	`make-custom-binary-input/output-port`:	stdlib io port input output ports
	`make-custom-binary-output-port`:	stdlib io port output ports
	`make-custom-textual-input-port`:	stdlib io port input ports
	`make-custom-textual-input/output-port`:	stdlib io port input output ports
	`make-custom-textual-output-port`:	stdlib io port output ports
	`make-enumeration`:	stdlib enum
	`make-enumeration-type-spec`:	expander specs enum
	`make-epoch-time`:	iklib time epoch
	`make-eq-hashtable`:	stdlib hashtable constructors
	`make-eq-hashtable`:	stdlib hashtable constructors
	`make-eqv-hashtable`:	stdlib hashtable constructors
	`make-eqv-hashtable`:	stdlib hashtable constructors
	`make-errno-condition`:	iklib conditions errno
	`make-error`:	stdlib exceptions conditions types
	`make-expand-time-value`:	iklib expander etv
	`make-expression-return-value-violation`:	iklib conditions exprret
	`make-failed-expression-condition`:	iklib conditions failexpr
	`make-file-options`:	iklib io misc
	`make-guardian`:	iklib guardians api
	`make-hashtable`:	stdlib hashtable constructors
	`make-hashtable`:	stdlib hashtable constructors
	`make-hashtable-type-spec`:	expander specs hashtable
	`make-i/o-decoding-error`:	stdlib io port transcoders
	`make-i/o-eagain`:	iklib conditions eagain
	`make-i/o-encoding-error`:	stdlib io port transcoders
	`make-i/o-error`:	stdlib io conditions
	`make-i/o-file-already-exists-error`:	stdlib io conditions
	`make-i/o-file-does-not-exist-error`:	stdlib io conditions
	`make-i/o-file-is-read-only-error`:	stdlib io conditions
	`make-i/o-file-protection-error`:	stdlib io conditions
	`make-i/o-filename-error`:	stdlib io conditions
	`make-i/o-invalid-position-error`:	stdlib io conditions
	`make-i/o-port-error`:	stdlib io conditions
	`make-i/o-read-error`:	stdlib io conditions
	`make-i/o-write-error`:	stdlib io conditions
	`make-i/o-wrong-fasl-header-error-error`:	iklib conditions wfs
	`make-implementation-restriction-violation`:	stdlib exceptions conditions types
	`make-irritants-condition`:	stdlib exceptions conditions types
	`make-lambda-signature`:	expander specs signatures lambda
	`make-late-binding-error`:	iklib conditions late-bind base
	`make-lexical-violation`:	stdlib exceptions conditions types
	`make-list`:	iklib lists misc
	`make-list`:	iklib lists misc
	`make-list-of-type-spec`:	expander specs list-of
	`make-list-type-spec`:	expander specs list
	`make-memory-block`:	iklib memory blocks
	`make-memory-block/guarded`:	iklib memory blocks
	`make-message-condition`:	stdlib exceptions conditions types
	`make-method-late-binding-error`:	iklib conditions late-bind method
	`make-no-infinities-violation`:	stdlib arithmetic flonums
	`make-no-nans-violation`:	stdlib arithmetic flonums
	`make-non-continuable-violation`:	stdlib exceptions conditions types
	`make-non-reinstatable-violation`:	iklib conditions non-reinst
	`make-one-based-return-value-index-condition`:	iklib conditions exprindex
	`make-out-of-memory-error`:	iklib memory condition
	`make-overloaded-function-late-binding-error`:	iklib conditions late-bind overload
	`make-pair-of-type-spec`:	expander specs pair-of
	`make-pair-type-spec`:	expander specs pair
	`make-parameter`:	iklib parameters
	`make-parameter`:	iklib parameters
	`make-parameter`:	compiler recordize specials
	`make-parameter`:	compiler recordize specials
	`make-polar`:	baselib math ops complex
	`make-procedure-argument-violation`:	iklib conditions procarg
	`make-procedure-arguments-consistency-violation`:	iklib conditions proccon
	`make-procedure-postcondition-violation`:	iklib conditions procpost
	`make-procedure-precondition-violation`:	iklib conditions procpre
	`make-procedure-signature-argument-violation`:	iklib conditions sigarg
	`make-procedure-signature-return-value-violation`:	iklib conditions rvarg
	`make-queue-procs`:	iklib lists queue
	`make-queue-procs`:	iklib lists queue
	`make-readline-input-port`:	iklib readline
	`make-readline-input-port`:	iklib readline
	`make-record-constructor-descriptor`:	stdlib records procedural layer
	`make-record-type-descriptor`:	stdlib records procedural layer
	`make-rectangular`:	baselib math ops complex
	`make-serious-condition`:	stdlib exceptions conditions types
	`make-shared-object-closing-error`:	ffi shared
	`make-shared-object-error`:	ffi shared
	`make-shared-object-lookup-error`:	ffi shared
	`make-shared-object-opening-error`:	ffi shared
	`make-source-position-condition`:	iklib conditions spos
	`make-string`:	baselib strings
	`make-string`:	baselib strings
	`make-string-decoding-error`:	iklib conditions string generic
	`make-string-encoding-error`:	iklib conditions string generic
	`make-struct-type`:	syslib structs safe define
	`make-struct-type`:	syslib structs safe define
	`make-synonym-transformer`:	iklib expander synonym
	`make-syntax-clause-spec`:	expander clauses objects
	`make-syntax-clause-spec`:	expander clauses objects
	`make-syntax-violation`:	stdlib exceptions conditions types
	`make-textual-file-descriptor-input-port`:	iklib io textual
	`make-textual-file-descriptor-input-port*`:	iklib io textual
	`make-textual-file-descriptor-input/output-port`:	iklib io textual
	`make-textual-file-descriptor-input/output-port*`:	iklib io textual
	`make-textual-file-descriptor-output-port`:	iklib io textual
	`make-textual-file-descriptor-output-port*`:	iklib io textual
	`make-textual-socket-input/output-port`:	iklib io textual
	`make-textual-socket-input/output-port*`:	iklib io textual
	`make-time`:	iklib time time
	`make-time`:	iklib time time
	`make-transcoder`:	stdlib io port transcoders
	`make-transcoder`:	stdlib io port transcoders
	`make-transcoder`:	stdlib io port transcoders
	`make-type-signature`:	expander specs signatures type
	`make-type-specification`:	expander specs retrieving
	`make-undefined-violation`:	stdlib exceptions conditions types
	`make-utf16-string-decoding-error`:	iklib conditions string utf16
	`make-utf16-string-decoding-invalid-first-word`:	iklib conditions string utf16
	`make-utf16-string-decoding-invalid-second-word`:	iklib conditions string utf16
	`make-utf16-string-decoding-missing-second-word`:	iklib conditions string utf16
	`make-utf16-string-decoding-standalone-octet`:	iklib conditions string utf16
	`make-utf16-string-encoding-error`:	iklib conditions string utf16
	`make-utf32-string-decoding-error`:	iklib conditions string utf32
	`make-utf32-string-decoding-invalid-word`:	iklib conditions string utf32
	`make-utf32-string-decoding-orphan-octets`:	iklib conditions string utf32
	`make-utf32-string-encoding-error`:	iklib conditions string utf32
	`make-utf8-string-decoding-error`:	iklib conditions string utf8
	`make-utf8-string-decoding-incomplete-2-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-incomplete-3-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-incomplete-4-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-invalid-2-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-invalid-3-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-invalid-4-tuple`:	iklib conditions string utf8
	`make-utf8-string-decoding-invalid-octet`:	iklib conditions string utf8
	`make-utf8-string-encoding-error`:	iklib conditions string utf8
	`make-variable-transformer`:	stdlib syntax-case transformers
	`make-variable-transformer`:	iklib expander transformers
	`make-vector`:	baselib vectors
	`make-vector`:	baselib vectors
	`make-vector-of-type-spec`:	expander specs vector-of
	`make-vector-type-spec`:	expander specs vector
	`make-violation`:	stdlib exceptions conditions types
	`make-warning`:	stdlib exceptions conditions types
	`make-who-condition`:	stdlib exceptions conditions types
	`malloc`:	iklib memory alloc
	`map`:	baselib lists
	`max`:	baselib math ops comparison
	`maybe-callback?`:	ffi call back
	`member`:	stdlib list
	`memcmp`:	iklib memory ops
	`memcpy`:	iklib memory ops
	`memmove`:	iklib memory ops
	`memory->bytevector`:	iklib memory ops
	`memory-block!=?`:	iklib memory blocks
	`memory-block-pointer`:	iklib memory blocks
	`memory-block-reset`:	iklib memory blocks
	`memory-block-size`:	iklib memory blocks
	`memory-block=?`:	iklib memory blocks
	`memory-block?`:	iklib memory blocks
	`memory-block?/non-null`:	iklib memory blocks
	`memory-block?/not-null`:	iklib memory blocks
	`memory-copy`:	iklib memory ops
	`memp`:	stdlib list
	`memq`:	stdlib list
	`memset`:	iklib memory ops
	`memv`:	stdlib list
	`message-condition?`:	stdlib exceptions conditions types
	`method`:	iklib records defs
	`method-late-binding-error?`:	iklib conditions late-bind method
	`min`:	baselib math ops comparison
	`mixins`:	iklib records defs
	`mod`:	baselib math ops arithmetic
	`mod0`:	baselib math ops arithmetic
	`module`:	iklib modules api
	`module`:	iklib modules api
	`modulo`:	stdlib rfive compat
	`monitor`:	iklib coroutines syntaxes
	`mutable-hashtable?`:	iklib hashtables pred

N
	`named-case-lambda`:	iklib syntaxes lambdas named
	`named-case-lambda*`:	iklib syntaxes lambdas star
	`named-lambda`:	iklib syntaxes lambdas named
	`named-lambda*`:	iklib syntaxes lambdas star
	`nan?`:	baselib math ops value pred
	`native-endianness`:	stdlib bytevector general
	`native-eol-style`:	stdlib io port transcoders
	`native-transcoder`:	stdlib io port transcoders
	`native-transcoder`:	iklib io codecs
	`nebytevector?`:	iklib bytevectors predicates
	`negative-bignum?`:	iklib numerics bignums
	`negative-byte-fixnum?`:	iklib fixnums predicates
	`negative-exact-integer?`:	iklib numerics preds
	`negative-fixnum?`:	iklib fixnums predicates
	`negative-flonum?`:	iklib flonums
	`negative-ratnum?`:	iklib numerics ratnums
	`negative-zero-flonum?`:	iklib flonums
	`negative?`:	baselib math ops value pred
	`neq?`:	iklib misc
	`nestring?`:	iklib strings predicates
	`nevector?`:	iklib vectors predicates
	`new-cafe`:	iklib cafe
	`new-cafe`:	iklib cafe
	`new-interaction-environment`:	iklib environment
	`new-interaction-environment`:	iklib environment
	`newline`:	stdlib io simple
	`newline`:	stdlib io simple
	`no-infinities-violation?`:	stdlib arithmetic flonums
	`no-nans-violation?`:	stdlib arithmetic flonums
	`non-continuable-violation?`:	stdlib exceptions conditions types
	`non-empty-vector?`:	iklib vectors predicates
	`non-interaction-lexical-environment?`:	iklib environment
	`non-negative-bignum?`:	iklib numerics bignums
	`non-negative-exact-integer?`:	iklib numerics preds
	`non-negative-fixnum?`:	iklib fixnums predicates
	`non-negative-flonum?`:	iklib flonums
	`non-negative-ratnum?`:	iklib numerics ratnums
	`non-negative?`:	iklib numerics preds
	`non-positive-bignum?`:	iklib numerics bignums
	`non-positive-exact-integer?`:	iklib numerics preds
	`non-positive-fixnum?`:	iklib fixnums predicates
	`non-positive-flonum?`:	iklib flonums
	`non-positive-ratnum?`:	iklib numerics ratnums
	`non-positive?`:	iklib numerics preds
	`non-reinstatable-violation`:	iklib conditions non-reinst
	`non-reinstatable-violation?`:	iklib conditions non-reinst
	`non-zero-cflonum?`:	iklib numerics preds
	`non-zero-compnum?`:	iklib numerics preds
	`non-zero-fixnum?`:	iklib fixnums predicates
	`non-zero-inexact-compnum?`:	iklib numerics preds
	`nongenerative`:	stdlib records syntactic layer
	`nongenerative`:	stdlib records syntactic layer
	`nongenerative`:	syslib structs safe define
	`normalise-percent-encoding`:	iklib bytevectors conversion
	`normalise-uri-encoding`:	iklib bytevectors conversion
	`not`:	baselib booleans
	`null-environment`:	stdlib rfive compat
	`null-memory-block`:	iklib memory blocks
	`null-pointer`:	iklib pointers cons
	`null?`:	baselib lists
	`number->string`:	baselib math string
	`number->string`:	baselib math string
	`number->string`:	baselib math string
	`number?`:	baselib math ops type pred
	`numerator`:	baselib math ops part

O
	`object-hash`:	iklib hashtables hashfun
	`object-type-spec.ancestor-ots*`:	expander specs object
	`object-type-spec.applicable-hash-function`:	expander specs object
	`object-type-spec.applicable-method-stx`:	expander specs object
	`object-type-spec.common-ancestor`:	expander specs object
	`object-type-spec.comparison-procedure`:	expander specs object
	`object-type-spec.compatible-super-and-sub?`:	expander specs object
	`object-type-spec.constructor-stx`:	expander specs object
	`object-type-spec.destructor-stx`:	expander specs object
	`object-type-spec.equality-predicate`:	expander specs object
	`object-type-spec.implemented-interfaces`:	expander specs object
	`object-type-spec.list-sub-type?`:	expander specs object
	`object-type-spec.matching-super-and-sub?`:	expander specs object
	`object-type-spec.name`:	expander specs object
	`object-type-spec.parent-ots`:	expander specs object
	`object-type-spec.procedure?`:	expander specs object
	`object-type-spec.type-annotation`:	expander specs object
	`object-type-spec.type-predicate-stx`:	expander specs object
	`object-type-spec.uids-list`:	expander specs object
	`object-type-spec.vector-sub-type?`:	expander specs object
	`object-type-spec=?`:	expander specs object
	`object-type-spec?`:	expander specs object
	`octet-fixnum?`:	iklib fixnums predicates
	`octets->string`:	iklib strings conversion
	`octets-encoded-bytevector?`:	iklib bytevectors conversion
	`octets-encoded-string?`:	iklib strings conversion
	`odd?`:	baselib math ops value pred
	`one-based-return-value-index-condition?`:	iklib conditions exprindex
	`opaque`:	stdlib records syntactic layer
	`opaque`:	stdlib records syntactic layer
	`open-binary-input-port?`:	iklib io binary
	`open-binary-input/output-port?`:	iklib io binary
	`open-binary-output-port?`:	iklib io binary
	`open-binary-port?`:	iklib io binary
	`open-bytevector-input-port`:	stdlib io port input ports
	`open-bytevector-input-port`:	stdlib io port input ports
	`open-bytevector-output-port`:	stdlib io port output ports
	`open-bytevector-output-port`:	stdlib io port output ports
	`open-file-input-port`:	stdlib io port input ports
	`open-file-input-port`:	stdlib io port input ports
	`open-file-input-port`:	stdlib io port input ports
	`open-file-input-port`:	stdlib io port input ports
	`open-file-input/output-port`:	stdlib io port input output ports
	`open-file-input/output-port`:	stdlib io port input output ports
	`open-file-input/output-port`:	stdlib io port input output ports
	`open-file-input/output-port`:	stdlib io port input output ports
	`open-file-output-port`:	stdlib io port output ports
	`open-file-output-port`:	stdlib io port output ports
	`open-file-output-port`:	stdlib io port output ports
	`open-file-output-port`:	stdlib io port output ports
	`open-input-file`:	stdlib io simple
	`open-input-file`:	iklib io codecs
	`open-input-port?`:	iklib io misc
	`open-input/output-port?`:	iklib io misc
	`open-output-file`:	stdlib io simple
	`open-output-file`:	iklib io codecs
	`open-output-port?`:	iklib io misc
	`open-port?`:	iklib io misc
	`open-shared-object`:	ffi shared
	`open-shared-object`:	ffi shared
	`open-string-input-port`:	stdlib io port input ports
	`open-string-input-port`:	iklib io textual
	`open-string-input-port`:	iklib io textual
	`open-string-input-port/id`:	iklib io textual
	`open-string-input-port/id`:	iklib io textual
	`open-string-output-port`:	stdlib io port output ports
	`open-string-output-port`:	iklib io textual
	`open-string-output-port`:	iklib io textual
	`open-textual-input-port?`:	iklib io textual
	`open-textual-input/output-port?`:	iklib io textual
	`open-textual-output-port?`:	iklib io textual
	`open-textual-port?`:	iklib io textual
	`optimisation-of`:	iklib syntaxes optim-of
	`optimisation-of*`:	iklib syntaxes optim-of
	`optimize-level`:	compiler optimisation
	`or`:	baselib expressions derived cond
	`ormap`:	iklib lists misc
	`os-name`:	iklib env-inquiry
	`os-version`:	iklib env-inquiry
	`out-of-memory-error?`:	iklib memory condition
	`output-file-buffer-size`:	iklib io buffer
	`output-file-buffer-size`:	iklib io buffer
	`output-port-buffer-mode`:	stdlib io port output ports
	`output-port?`:	stdlib io port output ports
	`output-port?`:	stdlib io simple
	`overloaded-function-late-binding-error?`:	iklib conditions late-bind overload

P
	`pair-hash`:	iklib hashtables hashfun
	`pair-of-type-spec.item-ots`:	expander specs pair-of
	`pair-of-type-spec?`:	expander specs pair-of
	`pair-type-spec.car-ots`:	expander specs pair
	`pair-type-spec.cdr-ots`:	expander specs pair
	`pair-type-spec?`:	expander specs pair
	`pair?`:	baselib lists
	`parameterise`:	iklib parameters
	`parameterize`:	iklib parameters
	`parametrise`:	iklib parameters
	`parent`:	stdlib records syntactic layer
	`parent-rtd`:	stdlib records syntactic layer
	`parse-logic-predicate-syntax`:	expander utils special
	`parse-logic-predicate-syntax`:	expander utils special
	`partition`:	stdlib list
	`pass-assign-frame-sizes`:	compiler cogen frame
	`pass-code-generation`:	compiler cogen
	`pass-color-by-chaitin`:	compiler cogen color
	`pass-core-type-inference`:	compiler type inference
	`pass-flatten-codes`:	compiler cogen flatten
	`pass-impose-calling-convention/evaluation-order`:	compiler cogen order
	`pass-insert-engine-checks`:	compiler engine
	`pass-insert-global-assignments`:	compiler global assign
	`pass-insert-stack-overflow-check`:	compiler stack
	`pass-introduce-closure-makers`:	compiler closure makers
	`pass-introduce-primitive-operation-calls`:	compiler primopcalls
	`pass-introduce-unsafe-primrefs`:	compiler unsafe primrefs
	`pass-introduce-vars`:	compiler vars
	`pass-optimize-combinator-calls/lift-clambdas`:	compiler lifting api
	`pass-optimize-direct-calls`:	compiler dircalls
	`pass-optimize-for-direct-jumps`:	compiler direct jumps
	`pass-optimize-letrec`:	compiler letrec api
	`pass-recordize`:	compiler recordize
	`pass-rewrite-freevar-references`:	compiler freevar refs
	`pass-rewrite-references-and-assignments`:	compiler refassig
	`pass-sanitize-bindings`:	compiler sanitise bindings
	`pass-source-optimize`:	compiler optimisation
	`pass-specify-representation`:	compiler cogen primop
	`pathname->string-func`:	iklib io pathnames
	`peek-char`:	stdlib io simple
	`peek-char`:	stdlib io simple
	`peek-char`:	iklib io non-blocking textual
	`peek-char`:	iklib io non-blocking textual
	`percent-decode`:	iklib bytevectors conversion
	`percent-encode`:	iklib bytevectors conversion
	`percent-encoded-bytevector?`:	iklib bytevectors conversion
	`percent-encoded-string?`:	iklib strings conversion
	`percent-encoding->string`:	iklib strings conversion
	`perform-core-type-inference?`:	compiler type inference
	`perform-unsafe-primrefs-introduction?`:	compiler unsafe primrefs
	`pointer!=?`:	iklib pointers compar
	`pointer->integer`:	iklib pointers conv
	`pointer-add`:	iklib pointers misc
	`pointer-and-offset?`:	iklib pointers pred
	`pointer-clone`:	iklib pointers cons
	`pointer-diff`:	iklib pointers misc
	`pointer-hash`:	iklib hashtables hashfun
	`pointer-max`:	iklib pointers compar
	`pointer-min`:	iklib pointers compar
	`pointer-non-null?`:	iklib pointers pred
	`pointer-null?`:	iklib pointers pred
	`pointer-ref-c-double`:	iklib pointers peek
	`pointer-ref-c-double-complex`:	iklib pointers peek
	`pointer-ref-c-float`:	iklib pointers peek
	`pointer-ref-c-off_t`:	iklib pointers peek
	`pointer-ref-c-pointer`:	iklib pointers peek
	`pointer-ref-c-ptrdiff_t`:	iklib pointers peek
	`pointer-ref-c-signed-char`:	iklib pointers peek
	`pointer-ref-c-signed-char`:	iklib pointers peek
	`pointer-ref-c-signed-int`:	iklib pointers peek
	`pointer-ref-c-signed-long`:	iklib pointers peek
	`pointer-ref-c-signed-long-long`:	iklib pointers peek
	`pointer-ref-c-signed-short`:	iklib pointers peek
	`pointer-ref-c-sint16`:	iklib pointers peek
	`pointer-ref-c-sint32`:	iklib pointers peek
	`pointer-ref-c-sint64`:	iklib pointers peek
	`pointer-ref-c-sint8`:	iklib pointers peek
	`pointer-ref-c-size_t`:	iklib pointers peek
	`pointer-ref-c-ssize_t`:	iklib pointers peek
	`pointer-ref-c-uint16`:	iklib pointers peek
	`pointer-ref-c-uint32`:	iklib pointers peek
	`pointer-ref-c-uint64`:	iklib pointers peek
	`pointer-ref-c-uint8`:	iklib pointers peek
	`pointer-ref-c-unsigned-int`:	iklib pointers peek
	`pointer-ref-c-unsigned-long`:	iklib pointers peek
	`pointer-ref-c-unsigned-long-long`:	iklib pointers peek
	`pointer-ref-c-unsigned-short`:	iklib pointers peek
	`pointer-set-c-double!`:	iklib pointers poke
	`pointer-set-c-double-complex!`:	iklib pointers poke
	`pointer-set-c-float!`:	iklib pointers poke
	`pointer-set-c-off_t!`:	iklib pointers poke
	`pointer-set-c-pointer!`:	iklib pointers poke
	`pointer-set-c-ptrdiff_t!`:	iklib pointers poke
	`pointer-set-c-signed-char!`:	iklib pointers poke
	`pointer-set-c-signed-int!`:	iklib pointers poke
	`pointer-set-c-signed-long!`:	iklib pointers poke
	`pointer-set-c-signed-long-long!`:	iklib pointers poke
	`pointer-set-c-signed-short!`:	iklib pointers poke
	`pointer-set-c-sint16!`:	iklib pointers poke
	`pointer-set-c-sint32!`:	iklib pointers poke
	`pointer-set-c-sint64!`:	iklib pointers poke
	`pointer-set-c-sint8!`:	iklib pointers poke
	`pointer-set-c-size_t!`:	iklib pointers poke
	`pointer-set-c-ssize_t!`:	iklib pointers poke
	`pointer-set-c-uint16!`:	iklib pointers poke
	`pointer-set-c-uint32!`:	iklib pointers poke
	`pointer-set-c-uint64!`:	iklib pointers poke
	`pointer-set-c-uint8!`:	iklib pointers poke
	`pointer-set-c-unsigned-char!`:	iklib pointers poke
	`pointer-set-c-unsigned-int!`:	iklib pointers poke
	`pointer-set-c-unsigned-long!`:	iklib pointers poke
	`pointer-set-c-unsigned-long-long!`:	iklib pointers poke
	`pointer-set-c-unsigned-short!`:	iklib pointers poke
	`pointer-value`:	iklib hashtables hashfun
	`pointer<=?`:	iklib pointers compar
	`pointer<?`:	iklib pointers compar
	`pointer=?`:	iklib pointers compar
	`pointer>=?`:	iklib pointers compar
	`pointer>?`:	iklib pointers compar
	`pointer?`:	iklib pointers pred
	`port-closed?`:	iklib io misc
	`port-dump-status`:	iklib io misc
	`port-eof?`:	stdlib io port input ports
	`port-fd`:	iklib io misc
	`port-getprop`:	iklib io plists
	`port-has-port-position?`:	stdlib io port io ports
	`port-has-set-port-position!?`:	stdlib io port io ports
	`port-hash`:	iklib io misc
	`port-id`:	iklib io misc
	`port-in-non-blocking-mode?`:	iklib io non-blocking mode
	`port-mode`:	iklib reader mode
	`port-position`:	stdlib io port io ports
	`port-property-list`:	iklib io plists
	`port-putprop`:	iklib io plists
	`port-remprop`:	iklib io plists
	`port-set-non-blocking-mode!`:	iklib io non-blocking mode
	`port-textual-position`:	iklib io textual
	`port-transcoder`:	stdlib io port io ports
	`port-uid`:	iklib io misc
	`port-unset-non-blocking-mode!`:	iklib io non-blocking mode
	`port?`:	stdlib io port io ports
	`port?`:	syslib ports
	`positive-bignum?`:	iklib numerics bignums
	`positive-byte-fixnum?`:	iklib fixnums predicates
	`positive-exact-integer?`:	iklib numerics preds
	`positive-fixnum?`:	iklib fixnums predicates
	`positive-flonum?`:	iklib flonums
	`positive-octet-fixnum?`:	iklib fixnums predicates
	`positive-ratnum?`:	iklib numerics ratnums
	`positive-zero-flonum?`:	iklib flonums
	`positive?`:	baselib math ops value pred
	`post-decr!`:	iklib syntaxes increments
	`post-decr!`:	iklib syntaxes increments
	`post-gc-hooks`:	iklib guardians api
	`post-incr!`:	iklib syntaxes increments
	`post-incr!`:	iklib syntaxes increments
	`pre-decr!`:	iklib syntaxes increments
	`pre-decr!`:	iklib syntaxes increments
	`pre-incr!`:	iklib syntaxes increments
	`pre-incr!`:	iklib syntaxes increments
	`prefix`:	iklib expander export specs
	`pretty-format`:	iklib printing pretty
	`pretty-print`:	iklib printing pretty
	`pretty-print`:	iklib printing pretty
	`pretty-print*`:	iklib printing pretty
	`pretty-width`:	iklib printing pretty
	`pretty-width`:	iklib printing pretty
	`print-condition`:	iklib conditions misc
	`print-condition`:	iklib conditions misc
	`print-gensym`:	iklib printing pretty
	`print-gensym`:	iklib printing pretty
	`print-gensym`:	iklib printing pretty
	`print-gensym`:	iklib printing pretty
	`print-graph`:	iklib shared
	`print-graph`:	iklib shared
	`print-graph`:	iklib shared
	`print-unicode`:	iklib printing pretty
	`print-unicode`:	iklib printing pretty
	`print-unicode`:	iklib printing pretty
	`printer-integer-radix`:	iklib printing pretty
	`printf`:	iklib printing formatting
	`Procedure`:	iklib timing
	`Procedure`:	iklib timing
	`procedure-annotation`:	syslib codes safe
	`procedure-argument-violation`:	iklib conditions procarg
	`procedure-argument-violation?`:	iklib conditions procarg
	`procedure-arguments-consistency-violation`:	iklib conditions proccon
	`procedure-arguments-consistency-violation/failed-expression`:	iklib conditions proccon
	`procedure-arguments-consistency-violation?`:	iklib conditions proccon
	`procedure-postcondition-violation?`:	iklib conditions procpost
	`procedure-precondition-violation?`:	iklib conditions procpre
	`procedure-signature-argument-violation`:	iklib conditions sigarg
	`procedure-signature-argument-violation.failed-expression`:	iklib conditions sigarg
	`procedure-signature-argument-violation.offending-value`:	iklib conditions sigarg
	`procedure-signature-argument-violation.one-based-argument-index`:	iklib conditions sigarg
	`procedure-signature-argument-violation?`:	iklib conditions sigarg
	`procedure-signature-return-value-violation`:	iklib conditions rvarg
	`procedure-signature-return-value-violation.failed-expression`:	iklib conditions rvarg
	`procedure-signature-return-value-violation.offending-value`:	iklib conditions rvarg
	`procedure-signature-return-value-violation.one-based-return-value-index`:	iklib conditions rvarg
	`procedure-signature-return-value-violation?`:	iklib conditions rvarg
	`procedure?`:	baselib predicates
	`procname`:	scheme entry procedure
	`procname`:	scheme entry procedure
	`program-source-pathname->program-binary-pathname`:	progutils pathanmes
	`promise-hash`:	iklib hashtables hashfun
	`promise?`:	iklib promises
	`property-list`:	iklib symbols plists
	`protocol`:	stdlib records syntactic layer
	`purge-collection-avoidance-list`:	iklib gc
	`push-compensation`:	iklib compensations api
	`push-compensation-thunk`:	iklib compensations api
	`put-bytevector`:	stdlib io port binary output
	`put-bytevector`:	stdlib io port binary output
	`put-bytevector`:	stdlib io port binary output
	`put-char`:	stdlib io port textual output
	`put-datum`:	stdlib io port textual output
	`put-string`:	stdlib io port textual output
	`put-string`:	stdlib io port textual output
	`put-string`:	stdlib io port textual output
	`put-u8`:	stdlib io port binary output
	`putprop`:	iklib symbols plists

Q
	`quasiquote`:	baselib quasiquotation
	`quasisyntax`:	stdlib syntax-case derived
	`quote`:	baselib expressions quotation
	`quotient`:	stdlib rfive compat
	`quotient`:	iklib numerics math
	`quotient+remainder`:	iklib numerics math

R
	`raise`:	stdlib exceptions exceptions
	`raise-continuable`:	stdlib exceptions exceptions
	`raise-non-continuable-standard-condition`:	iklib conditions raising
	`raise-non-continuable-standard-condition`:	iklib conditions raising
	`random`:	iklib misc
	`rational-valued?`:	baselib math ops type pred
	`rational?`:	baselib math ops type pred
	`rationalize`:	baselib math ops part
	`ratnum-hash`:	iklib hashtables hashfun
	`ratnum-negative?`:	iklib numerics ratnums
	`ratnum-non-negative?`:	iklib numerics ratnums
	`ratnum-non-positive?`:	iklib numerics ratnums
	`ratnum-positive?`:	iklib numerics ratnums
	`ratnum?`:	iklib numerics preds
	`rcd-parent-rcd`:	iklib records rcd
	`rcd-rtd`:	iklib records rcd
	`read`:	stdlib io simple
	`read`:	stdlib io simple
	`read-char`:	stdlib io simple
	`read-char`:	stdlib io simple
	`read-char`:	iklib io non-blocking textual
	`read-char`:	iklib io non-blocking textual
	`read-line`:	iklib io textual
	`read-line`:	iklib io textual
	`reader-annotation-expression`:	iklib reader annotations
	`reader-annotation-source`:	iklib reader annotations
	`reader-annotation-stripped`:	iklib reader annotations
	`reader-annotation-textual-position`:	iklib reader annotations
	`reader-annotation?`:	iklib reader annotations
	`reader-import`:	iklib reader extensions
	`readline`:	iklib readline
	`readline`:	iklib readline
	`readline-enabled?`:	iklib readline
	`real->flonum`:	stdlib arithmetic flonums
	`real-part`:	baselib math ops complex
	`real-valued?`:	baselib math ops type pred
	`real?`:	baselib math ops type pred
	`realloc`:	iklib memory alloc
	`receive`:	iklib syntaxes bindings
	`receive-and-return`:	iklib syntaxes bindings
	`record!=?`:	iklib records misc
	`record-accessor`:	stdlib records procedural layer
	`record-accessor`:	iklib records fields
	`record-accessor`:	iklib records fields
	`record-and-rtd?`:	iklib records predicates
	`record-comparison-procedure`:	iklib records comparison
	`record-constructor`:	stdlib records procedural layer
	`record-constructor-descriptor`:	stdlib records syntactic layer
	`record-constructor-descriptor?`:	iklib records rcd
	`record-destructor`:	iklib records final
	`record-equality-predicate`:	iklib records equality
	`record-field-mutable?`:	stdlib records inspection
	`record-guardian-log`:	iklib records final
	`record-guardian-logger`:	iklib records final
	`record-hash`:	iklib hashtables hashfun
	`record-hash-function`:	iklib records hash
	`record-mutator`:	stdlib records procedural layer
	`record-mutator`:	iklib records fields
	`record-mutator`:	iklib records fields
	`record-object?`:	iklib records misc
	`record-predicate`:	stdlib records procedural layer
	`record-printer`:	iklib records printer
	`record-ref`:	iklib records fields
	`record-reset!`:	iklib records misc
	`record-rtd`:	stdlib records inspection
	`record-type-all-field-names`:	iklib records misc
	`record-type-and-record?`:	iklib records predicates
	`record-type-comparison-procedure`:	iklib records comparison
	`record-type-comparison-procedure-set!`:	iklib records comparison
	`record-type-descriptor`:	stdlib records syntactic layer
	`record-type-descriptor?`:	stdlib records procedural layer
	`record-type-destructor`:	iklib records final
	`record-type-destructor-set!`:	iklib records final
	`record-type-equality-predicate`:	iklib records equality
	`record-type-equality-predicate-set!`:	iklib records equality
	`record-type-field-names`:	stdlib records inspection
	`record-type-generative?`:	stdlib records inspection
	`record-type-hash-function`:	iklib records hash
	`record-type-hash-function-set!`:	iklib records hash
	`record-type-name`:	stdlib records inspection
	`record-type-opaque?`:	stdlib records inspection
	`record-type-parent`:	stdlib records inspection
	`record-type-printer`:	iklib records printer
	`record-type-printer-set!`:	iklib records printer
	`record-type-sealed?`:	stdlib records inspection
	`record-type-spec.parent-and-child?`:	expander specs record
	`record-type-spec.rcd-id`:	expander specs record
	`record-type-spec.rtd-id`:	expander specs record
	`record-type-spec?`:	expander specs record
	`record-type-uid`:	stdlib records inspection
	`record-type-uids-list`:	iklib records misc
	`record=?`:	iklib records misc
	`record?`:	stdlib records inspection
	`register-to-avoid-collecting`:	iklib gc
	`remainder`:	stdlib rfive compat
	`remainder`:	iklib numerics math
	`remove`:	stdlib list
	`remp`:	stdlib list
	`remprop`:	iklib symbols plists
	`remq`:	stdlib list
	`remv`:	stdlib list
	`replace-to-avoid-collecting`:	iklib gc
	`reset`:	iklib syntaxes delimcc
	`reset-coroutines!`:	iklib coroutines debug
	`reset-input-port!`:	iklib io misc
	`reset-output-port!`:	iklib io misc
	`reset-symbol-proc!`:	iklib symbols value
	`resume-coroutine`:	iklib coroutines suspend
	`retrieve-expand-time-value`:	iklib expander etv
	`retrieve-to-avoid-collecting`:	iklib gc
	`return`:	iklib syntaxes returnable
	`returnable`:	iklib syntaxes returnable
	`reverse`:	baselib lists
	`round`:	baselib math ops part
	`run-compensations`:	iklib compensations api
	`run-time-library-locator`:	libutils file-system locators run

S
	`s16b-list->bytevector`:	iklib bytevectors conversion
	`s16l-list->bytevector`:	iklib bytevectors conversion
	`s16n-list->bytevector`:	iklib bytevectors conversion
	`s32b-list->bytevector`:	iklib bytevectors conversion
	`s32l-list->bytevector`:	iklib bytevectors conversion
	`s32n-list->bytevector`:	iklib bytevectors conversion
	`s64b-list->bytevector`:	iklib bytevectors conversion
	`s64l-list->bytevector`:	iklib bytevectors conversion
	`s64n-list->bytevector`:	iklib bytevectors conversion
	`s8-list->bytevector`:	iklib bytevectors conversion
	`scheme-heap-nursery-size`:	iklib runtime
	`scheme-heap-nursery-size`:	iklib runtime
	`scheme-report-environment`:	stdlib rfive compat
	`scheme-stack-size`:	iklib runtime
	`scheme-stack-size`:	iklib runtime
	`sealed`:	stdlib records syntactic layer
	`sealed`:	stdlib records syntactic layer
	`search-file-in-environment-path`:	iklib io pathnames
	`search-file-in-list-path`:	iklib io pathnames
	`sentinel`:	iklib sentinel
	`sentinel-hash`:	iklib hashtables hashfun
	`sentinel?`:	iklib sentinel
	`serious-condition?`:	stdlib exceptions conditions types
	`set!`:	baselib expressions assignments
	`set!`:	baselib transformers
	`set-car!`:	stdlib mutable pairs
	`set-cdr!`:	stdlib mutable pairs
	`set-code-annotation!`:	syslib codes safe
	`set-code-reloc-vector!`:	syslib codes safe
	`set-cons!`:	iklib syntaxes misc
	`set-pointer-null!`:	iklib pointers misc
	`set-port-buffer-mode!`:	iklib io misc
	`set-port-mode!`:	iklib reader mode
	`set-port-position!`:	stdlib io port io ports
	`set-struct-type-destructor!`:	syslib structs safe final
	`set-struct-type-printer!`:	syslib structs safe printer
	`set-symbol-value!`:	iklib symbols value
	`set-top-level-value!`:	iklib symbols value
	`shared-object-closing-error?`:	ffi shared
	`shared-object-error?`:	ffi shared
	`shared-object-lookup-error?`:	ffi shared
	`shared-object-opening-error?`:	ffi shared
	`shift`:	iklib syntaxes delimcc
	`sign`:	iklib numerics math
	`simple-condition?`:	iklib conditions preds
	`simple-conditions`:	stdlib exceptions conditions objects
	`sin`:	baselib math ops trascend
	`sinh`:	iklib numerics math
	`sint-list->bytevector`:	stdlib bytevector integers
	`sll`:	iklib numerics bitwise
	`sorted-vector-binary-search`:	iklib vectors misc
	`source-library-locator`:	libutils file-system locators source
	`source-optimizer-passes-count`:	compiler optimisation
	`source-position-byte`:	iklib conditions spos
	`source-position-character`:	iklib conditions spos
	`source-position-column`:	iklib conditions spos
	`source-position-condition?`:	iklib conditions spos
	`source-position-line`:	iklib conditions spos
	`source-position-port-id`:	iklib conditions spos
	`splice-first-expand`:	iklib syntaxes splice1st
	`split-pathname`:	iklib io pathnames
	`split-pathname-bytevector`:	iklib io pathnames
	`split-pathname-root-and-tail`:	iklib io pathnames
	`split-pathname-string`:	iklib io pathnames
	`split-search-path`:	iklib io pathnames
	`split-search-path-bytevector`:	iklib io pathnames
	`split-search-path-string`:	iklib io pathnames
	`sqrt`:	baselib math ops exponentiation
	`square`:	iklib numerics math
	`sra`:	iklib numerics bitwise
	`stale-when`:	iklib syntaxes stale
	`standard-error-port`:	stdlib io port output ports
	`standard-input-port`:	stdlib io port input ports
	`standard-output-port`:	stdlib io port output ports
	`stats-bytes-major`:	iklib timing
	`stats-bytes-minor`:	iklib timing
	`stats-collection-id`:	iklib timing
	`stats-gc-real-secs`:	iklib timing
	`stats-gc-real-usecs`:	iklib timing
	`stats-gc-sys-secs`:	iklib timing
	`stats-gc-sys-usecs`:	iklib timing
	`stats-gc-user-secs`:	iklib timing
	`stats-gc-user-usecs`:	iklib timing
	`stats-real-secs`:	iklib timing
	`stats-real-usecs`:	iklib timing
	`stats-sys-secs`:	iklib timing
	`stats-sys-usecs`:	iklib timing
	`stats-user-secs`:	iklib timing
	`stats-user-usecs`:	iklib timing
	`stats?`:	iklib timing
	`strcmp`:	iklib cstrings
	`strdup`:	iklib cstrings
	`strerror`:	iklib misc
	`strict-r6rs-enabled?`:	iklib expander language
	`strict-r6rs-enabled?`:	iklib expander language
	`string`:	baselib strings
	`string!=?`:	iklib strings comparison
	`string->ascii`:	iklib strings conversion
	`string->bytevector`:	stdlib io port transcoders
	`string->cstring`:	iklib cstrings
	`string->cstring*`:	iklib cstrings
	`string->filename-func`:	iklib io pathnames
	`string->flonum`:	iklib flonums
	`string->guarded-cstring`:	iklib cstrings
	`string->guarded-cstring*`:	iklib cstrings
	`string->identifier`:	expander utils id
	`string->keyword`:	iklib keywords
	`string->latin1`:	iklib strings conversion
	`string->list`:	baselib strings
	`string->number`:	baselib math string
	`string->number`:	baselib math string
	`string->octets`:	iklib strings conversion
	`string->pathname-func`:	iklib io pathnames
	`string->percent-encoding`:	iklib strings conversion
	`string->symbol`:	baselib symbols
	`string->uri-encoding`:	iklib strings conversion
	`string->utf16`:	stdlib bytevector strings
	`string->utf16`:	stdlib bytevector strings
	`string->utf16-length`:	iklib strings conversion
	`string->utf16be`:	iklib strings conversion
	`string->utf16le`:	iklib strings conversion
	`string->utf16n`:	iklib strings conversion
	`string->utf32`:	stdlib bytevector strings
	`string->utf32`:	stdlib bytevector strings
	`string->utf32-length`:	iklib strings conversion
	`string->utf8`:	stdlib bytevector strings
	`string->utf8-length`:	iklib strings conversion
	`string-append`:	baselib strings
	`string-base64->bytevector`:	iklib strings conversion
	`string-ci-hash`:	stdlib hashtable hash functions
	`string-ci-hash`:	stdlib hashtable hash functions
	`string-ci<=?`:	stdlib unicode strings
	`string-ci<?`:	stdlib unicode strings
	`string-ci=?`:	stdlib unicode strings
	`string-ci>=?`:	stdlib unicode strings
	`string-ci>?`:	stdlib unicode strings
	`string-concatenate`:	iklib strings constructors
	`string-copy`:	baselib strings
	`string-copy!`:	iklib strings constructors
	`string-decoding-error?`:	iklib conditions string generic
	`string-downcase`:	stdlib unicode strings
	`string-empty?`:	iklib strings predicates
	`string-encoding-error?`:	iklib conditions string generic
	`string-fill!`:	stdlib mutable strings
	`string-foldcase`:	stdlib unicode strings
	`string-for-each`:	baselib strings
	`string-hash`:	stdlib hashtable hash functions
	`string-hash`:	stdlib hashtable hash functions
	`string-hex->bytevector`:	iklib strings conversion
	`string-length`:	baselib strings
	`string-max`:	iklib strings comparison
	`string-min`:	iklib strings comparison
	`string-normalize-nfc`:	stdlib unicode strings
	`string-normalize-nfd`:	stdlib unicode strings
	`string-normalize-nfkc`:	stdlib unicode strings
	`string-normalize-nfkd`:	stdlib unicode strings
	`string-or-symbol->string`:	iklib strings conversion
	`string-or-symbol->symbol`:	iklib strings conversion
	`string-port-buffer-size`:	iklib io buffer
	`string-port-buffer-size`:	iklib io buffer
	`string-ref`:	baselib strings
	`string-reverse-and-concatenate`:	iklib strings constructors
	`string-set!`:	stdlib mutable strings
	`string-titlecase`:	stdlib unicode strings
	`string-upcase`:	stdlib unicode strings
	`string<=?`:	baselib strings
	`string<?`:	baselib strings
	`string=?`:	baselib strings
	`string>=?`:	baselib strings
	`string>?`:	baselib strings
	`string?`:	baselib strings
	`strings->argv`:	iklib cstrings
	`strings->guarded-argv`:	iklib cstrings
	`strip-angular-parentheses`:	iklib records defs
	`strlen`:	iklib cstrings
	`strncmp`:	iklib cstrings
	`strndup`:	iklib cstrings
	`struct!=?`:	syslib structs safe data
	`struct-and-std-ref`:	syslib structs safe data
	`struct-and-std-set!`:	syslib structs safe data
	`struct-and-std?`:	syslib structs safe data
	`struct-destructor`:	syslib structs safe data
	`struct-field-names`:	syslib structs safe data
	`struct-guardian-log`:	syslib structs safe final
	`struct-guardian-logger`:	syslib structs safe final
	`struct-hash`:	iklib hashtables hashfun
	`struct-length`:	syslib structs safe data
	`struct-name`:	syslib structs safe data
	`struct-printer`:	syslib structs safe data
	`struct-ref`:	syslib structs safe data
	`struct-reset!`:	syslib structs safe data
	`struct-set!`:	syslib structs safe data
	`struct-std`:	syslib structs safe data
	`struct-type-constructor`:	syslib structs safe using
	`struct-type-descriptor`:	syslib structs safe using
	`struct-type-descriptor?`:	syslib structs safe using
	`struct-type-destructor`:	syslib structs safe final
	`struct-type-field-accessor`:	syslib structs safe using
	`struct-type-field-method`:	syslib structs safe using
	`struct-type-field-mutator`:	syslib structs safe using
	`struct-type-field-names`:	syslib structs safe inspect
	`struct-type-name`:	syslib structs safe inspect
	`struct-type-predicate`:	syslib structs safe using
	`struct-type-printer`:	syslib structs safe printer
	`struct-type-spec.std`:	expander specs struct
	`struct-type-spec?`:	expander specs struct
	`struct-type-symbol`:	syslib structs safe inspect
	`struct=?`:	syslib structs safe data
	`struct?`:	syslib structs safe data
	`struct?`:	syslib structs safe data
	`stx-annotated-expr* on <stx>`:	expander lexenv stx
	`stx-expr on <stx>`:	expander lexenv stx
	`stx-mark* on <stx>`:	expander lexenv stx
	`stx-rib* on <stx>`:	expander lexenv stx
	`stx?`:	expander lexenv stx
	`sub1`:	iklib numerics math
	`subbytevector-s8`:	iklib bytevectors sub
	`subbytevector-s8`:	iklib bytevectors sub
	`subbytevector-s8/count`:	iklib bytevectors sub
	`subbytevector-u8`:	iklib bytevectors sub
	`subbytevector-u8`:	iklib bytevectors sub
	`subbytevector-u8/count`:	iklib bytevectors sub
	`substring`:	baselib strings
	`subvector`:	iklib vectors copying
	`suffix`:	iklib expander export specs
	`suffix`:	iklib expander import specs
	`super-protocol`:	iklib records defs
	`suspend-coroutine`:	iklib coroutines suspend
	`suspended-coroutine?`:	iklib coroutines suspend
	`symbol!=?`:	iklib symbols comparison
	`symbol->keyword`:	iklib keywords
	`symbol->string`:	baselib symbols
	`symbol-bound?`:	iklib symbols value
	`symbol-hash`:	stdlib hashtable hash functions
	`symbol-max`:	iklib symbols comparison
	`symbol-min`:	iklib symbols comparison
	`symbol-value`:	iklib symbols value
	`symbol<=?`:	iklib symbols comparison
	`symbol<?`:	iklib symbols comparison
	`symbol=?`:	baselib symbols
	`symbol>=?`:	iklib symbols comparison
	`symbol>?`:	iklib symbols comparison
	`symbol?`:	baselib symbols
	`synonym-transformer-identifier`:	iklib expander synonym
	`synonym-transformer?`:	iklib expander synonym
	`syntactic-binding-getprop`:	iklib syntaxes properties
	`syntactic-binding-property-list`:	iklib syntaxes properties
	`syntactic-binding-putprop`:	iklib syntaxes properties
	`syntactic-binding-remprop`:	iklib syntaxes properties
	`syntactic-identifier->label`:	expander lexenv inspection
	`syntax`:	stdlib syntax-case parsing
	`syntax->datum`:	stdlib syntax-case conversion
	`syntax->list`:	expander utils pairs
	`syntax->list`:	expander utils pairs
	`syntax->vector`:	expander utils vectors
	`syntax->vector`:	expander utils vectors
	`syntax-car`:	expander utils pairs
	`syntax-car`:	expander utils pairs
	`syntax-case`:	stdlib syntax-case parsing
	`syntax-cdr`:	expander utils pairs
	`syntax-cdr`:	expander utils pairs
	`syntax-clause-spec-custom-data`:	expander clauses objects
	`syntax-clause-spec-keyword`:	expander clauses objects
	`syntax-clause-spec-max-number-of-arguments`:	expander clauses objects
	`syntax-clause-spec-max-number-of-occurrences`:	expander clauses objects
	`syntax-clause-spec-min-number-of-arguments`:	expander clauses objects
	`syntax-clause-spec-min-number-of-occurrences`:	expander clauses objects
	`syntax-clause-spec-mutually-exclusive`:	expander clauses objects
	`syntax-clause-spec-mutually-inclusive`:	expander clauses objects
	`syntax-clause-spec?`:	expander clauses objects
	`syntax-clauses-collapse`:	expander clauses utils
	`syntax-clauses-filter`:	expander clauses utils
	`syntax-clauses-fold-specs`:	expander clauses objects
	`syntax-clauses-fold-specs`:	expander clauses objects
	`syntax-clauses-partition`:	expander clauses utils
	`syntax-clauses-remove`:	expander clauses utils
	`syntax-clauses-single-spec`:	expander clauses objects
	`syntax-clauses-single-spec`:	expander clauses objects
	`syntax-clauses-unwrap`:	expander clauses utils
	`syntax-clauses-unwrap`:	expander clauses utils
	`syntax-clauses-validate-specs`:	expander clauses objects
	`syntax-clauses-verify-at-least-once`:	expander clauses constr
	`syntax-clauses-verify-at-least-once`:	expander clauses constr
	`syntax-clauses-verify-at-most-once`:	expander clauses constr
	`syntax-clauses-verify-at-most-once`:	expander clauses constr
	`syntax-clauses-verify-exactly-once`:	expander clauses constr
	`syntax-clauses-verify-exactly-once`:	expander clauses constr
	`syntax-clauses-verify-mutually-exclusive`:	expander clauses constr
	`syntax-clauses-verify-mutually-exclusive`:	expander clauses constr
	`syntax-clauses-verify-mutually-inclusive`:	expander clauses constr
	`syntax-clauses-verify-mutually-inclusive`:	expander clauses constr
	`syntax-object?`:	expander lexenv stx
	`syntax-parameter-value`:	iklib expander parameters
	`syntax-parametrise`:	iklib expander parameters
	`syntax-replace-id`:	expander utils unwrap
	`syntax-rules`:	baselib transformers
	`syntax-unwrap`:	expander utils unwrap
	`syntax-violation`:	stdlib syntax-case violations
	`syntax-violation`:	stdlib syntax-case violations
	`syntax-violation-form`:	stdlib exceptions conditions types
	`syntax-violation-subform`:	stdlib exceptions conditions types
	`syntax-violation?`:	stdlib exceptions conditions types
	`syntax=?`:	expander utils compar
	`system-id`:	expander system-identifiers
	`system-id-gensym`:	expander system-identifiers
	`system-label`:	expander system-labels
	`system-label-gensym`:	expander system-labels
	`system-value`:	compiler sysval
	`system-value-gensym`:	compiler sysval

T
	`tan`:	baselib math ops trascend
	`tanh`:	iklib numerics math
	`tcbucket?`:	iklib hashtables tcbuckets
	`template`:	scheme entry
	`textual-input-only-port?`:	iklib io textual
	`textual-input-port?`:	iklib io textual
	`textual-input/output-port?`:	iklib io textual
	`textual-output-only-port?`:	iklib io textual
	`textual-output-port?`:	iklib io textual
	`textual-port?`:	stdlib io port io ports
	`the-proc`:	scheme entry procedure
	`this`:	iklib syntaxes misc
	`time`:	iklib timing
	`time!=?`:	iklib time time
	`time-addition`:	iklib time time
	`time-and-gather`:	iklib timing
	`time-difference`:	iklib time time
	`time-flonum`:	iklib time time
	`time-gmt-offset`:	iklib time epoch
	`time-max`:	iklib time time
	`time-min`:	iklib time time
	`time-nanoseconds`:	iklib time time
	`time-ratnum`:	iklib time time
	`time-seconds`:	iklib time time
	`time<=?`:	iklib time time
	`time<?`:	iklib time time
	`time=?`:	iklib time time
	`time>=?`:	iklib time time
	`time>?`:	iklib time time
	`time?`:	iklib time time
	`top-level-bound?`:	iklib symbols value
	`top-level-value`:	iklib symbols value
	`transcoded-port`:	stdlib io port io ports
	`transcoder!=?`:	iklib io codecs
	`transcoder-codec`:	stdlib io port transcoders
	`transcoder-eol-style`:	stdlib io port transcoders
	`transcoder-error-handling-mode`:	stdlib io port transcoders
	`transcoder-hash`:	iklib io codecs
	`transcoder-max`:	iklib io codecs
	`transcoder-min`:	iklib io codecs
	`transcoder<=?`:	iklib io codecs
	`transcoder<?`:	iklib io codecs
	`transcoder=?`:	iklib io codecs
	`transcoder>=?`:	iklib io codecs
	`transcoder>?`:	iklib io codecs
	`transcoder?`:	iklib io codecs
	`true?`:	iklib booleans
	`truncate`:	baselib math ops part
	`try`:	iklib syntaxes try
	`try`:	iklib syntaxes try
	`try`:	iklib syntaxes try
	`type-predicate`:	iklib records defs
	`type-signature.object-type-specs`:	expander specs signatures type
	`type-signature?`:	expander specs signatures type
	`typed-language-enabled?`:	iklib expander language
	`typed-language-enabled?`:	iklib expander language

U
	`u16b-list->bytevector`:	iklib bytevectors conversion
	`u16l-list->bytevector`:	iklib bytevectors conversion
	`u16n-list->bytevector`:	iklib bytevectors conversion
	`u32b-list->bytevector`:	iklib bytevectors conversion
	`u32l-list->bytevector`:	iklib bytevectors conversion
	`u32n-list->bytevector`:	iklib bytevectors conversion
	`u64b-list->bytevector`:	iklib bytevectors conversion
	`u64l-list->bytevector`:	iklib bytevectors conversion
	`u64n-list->bytevector`:	iklib bytevectors conversion
	`u8-list->bytevector`:	stdlib bytevector bytes and octets
	`uint-list->bytevector`:	stdlib bytevector integers
	`uname`:	iklib env-inquiry
	`unbound-object`:	iklib symbols value
	`unbound-object?`:	iklib symbols value
	`undefined-violation?`:	stdlib exceptions conditions types
	`unicode-code-point-representable-as-latin-1-code-point?`:	iklib chars unicode latin1
	`unicode-printable-char?`:	iklib chars predicates
	`unintern-library`:	libutils interning
	`unintern-library`:	libutils interning
	`union-of-type-specs`:	expander specs union
	`union-type-spec.item-ots*`:	expander specs union
	`union-type-spec?`:	expander specs union
	`unless`:	stdlib control
	`unparse-recordized-code`:	compiler unparse
	`unparse-recordized-code/pretty`:	compiler unparse
	`unparse-recordized-code/sexp`:	compiler unparse
	`unquote`:	scheme entry other kinds
	`unquote`:	baselib quasiquotation
	`unquote-splicing`:	baselib quasiquotation
	`unsafe-record-accessor`:	iklib records fields
	`unsafe-record-accessor`:	iklib records fields
	`unsafe-record-mutator`:	iklib records fields
	`unsafe-record-mutator`:	iklib records fields
	`unsyntax`:	stdlib syntax-case derived
	`unsyntax-splicing`:	stdlib syntax-case derived
	`until`:	iklib syntaxes loops until
	`until`:	iklib syntaxes loops do
	`unwind-protect`:	iklib unwind-protect syntaxes
	`unwinding-call/cc`:	iklib unwind-protect call/cc
	`uri-decode`:	iklib bytevectors conversion
	`uri-encode`:	iklib bytevectors conversion
	`uri-encoded-bytevector?`:	iklib bytevectors conversion
	`uri-encoded-string?`:	iklib strings conversion
	`uri-encoding->string`:	iklib strings conversion
	`utf-16-codec`:	stdlib io port transcoders
	`utf-16-decode-single-word`:	iklib chars unicode utf16
	`utf-16-decode-surrogate-pair`:	iklib chars unicode utf16
	`utf-16-encode-first-of-two-words`:	iklib chars unicode utf16
	`utf-16-encode-second-of-two-words`:	iklib chars unicode utf16
	`utf-16-encode-single-word`:	iklib chars unicode utf16
	`utf-16-first-of-two-words?`:	iklib chars unicode utf16
	`utf-16-second-of-two-words?`:	iklib chars unicode utf16
	`utf-16-single-word-code-point?`:	iklib chars unicode utf16
	`utf-16-single-word?`:	iklib chars unicode utf16
	`utf-16-two-words-code-point?`:	iklib chars unicode utf16
	`utf-16be-codec`:	iklib io codecs
	`utf-16le-codec`:	iklib io codecs
	`utf-16n-codec`:	iklib io codecs
	`utf-32-code-point?`:	iklib chars unicode utf32
	`utf-32-decode`:	iklib chars unicode utf32
	`utf-32-encode`:	iklib chars unicode utf32
	`utf-32-word?`:	iklib chars unicode utf32
	`utf-8-codec`:	stdlib io port transcoders
	`utf-8-decode-four-octets`:	iklib chars unicode utf8
	`utf-8-decode-single-octet`:	iklib chars unicode utf8
	`utf-8-decode-three-octets`:	iklib chars unicode utf8
	`utf-8-decode-two-octets`:	iklib chars unicode utf8
	`utf-8-encode-first-of-four-octets`:	iklib chars unicode utf8
	`utf-8-encode-first-of-three-octets`:	iklib chars unicode utf8
	`utf-8-encode-first-of-two-octets`:	iklib chars unicode utf8
	`utf-8-encode-fourth-of-four-octets`:	iklib chars unicode utf8
	`utf-8-encode-second-of-four-octets`:	iklib chars unicode utf8
	`utf-8-encode-second-of-three-octets`:	iklib chars unicode utf8
	`utf-8-encode-second-of-two-octets`:	iklib chars unicode utf8
	`utf-8-encode-single-octet`:	iklib chars unicode utf8
	`utf-8-encode-third-of-four-octets`:	iklib chars unicode utf8
	`utf-8-encode-third-of-three-octets`:	iklib chars unicode utf8
	`utf-8-first-of-four-octets?`:	iklib chars unicode utf8
	`utf-8-first-of-three-octets?`:	iklib chars unicode utf8
	`utf-8-first-of-two-octets?`:	iklib chars unicode utf8
	`utf-8-four-octets-code-point?`:	iklib chars unicode utf8
	`utf-8-invalid-octet?`:	iklib chars unicode utf8
	`utf-8-second-and-third-of-three-octets?`:	iklib chars unicode utf8
	`utf-8-second-of-two-octets?`:	iklib chars unicode utf8
	`utf-8-second-third-and-fourth-of-four-octets?`:	iklib chars unicode utf8
	`utf-8-single-octet-code-point?`:	iklib chars unicode utf8
	`utf-8-single-octet?`:	iklib chars unicode utf8
	`utf-8-three-octets-code-point?`:	iklib chars unicode utf8
	`utf-8-two-octets-code-point?`:	iklib chars unicode utf8
	`utf-8-valid-code-point-from-1-octet?`:	iklib chars unicode utf8
	`utf-8-valid-code-point-from-2-octets?`:	iklib chars unicode utf8
	`utf-8-valid-code-point-from-3-octets?`:	iklib chars unicode utf8
	`utf-8-valid-code-point-from-4-octets?`:	iklib chars unicode utf8
	`utf-bom-codec`:	iklib io codecs
	`utf16->string`:	stdlib bytevector strings
	`utf16->string`:	stdlib bytevector strings
	`utf16->string`:	stdlib bytevector strings
	`utf16->string-length`:	iklib bytevectors conversion
	`utf16->string-length`:	iklib bytevectors conversion
	`utf16->string-length`:	iklib bytevectors conversion
	`utf16-string-decoding-error?`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-first-word.bytevector`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-first-word.index`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-first-word.word`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-first-word?`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-second-word.bytevector`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-second-word.first-word`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-second-word.index`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-second-word.second-word`:	iklib conditions string utf16
	`utf16-string-decoding-invalid-second-word?`:	iklib conditions string utf16
	`utf16-string-decoding-missing-second-word.bytevector`:	iklib conditions string utf16
	`utf16-string-decoding-missing-second-word.index`:	iklib conditions string utf16
	`utf16-string-decoding-missing-second-word.word`:	iklib conditions string utf16
	`utf16-string-decoding-missing-second-word?`:	iklib conditions string utf16
	`utf16-string-decoding-standalone-octet.bytevector`:	iklib conditions string utf16
	`utf16-string-decoding-standalone-octet.index`:	iklib conditions string utf16
	`utf16-string-decoding-standalone-octet.octet`:	iklib conditions string utf16
	`utf16-string-decoding-standalone-octet?`:	iklib conditions string utf16
	`utf16-string-encoding-error?`:	iklib conditions string utf16
	`utf16be->string`:	iklib strings conversion
	`utf16be->string`:	iklib strings conversion
	`utf16le->string`:	iklib strings conversion
	`utf16le->string`:	iklib strings conversion
	`utf16n->string`:	iklib strings conversion
	`utf16n->string`:	iklib strings conversion
	`utf32->string`:	stdlib bytevector strings
	`utf32->string`:	stdlib bytevector strings
	`utf32->string`:	stdlib bytevector strings
	`utf32->string-length`:	iklib bytevectors conversion
	`utf32->string-length`:	iklib bytevectors conversion
	`utf32->string-length`:	iklib bytevectors conversion
	`utf32-string-decoding-error?`:	iklib conditions string utf32
	`utf32-string-decoding-invalid-word.bytevector`:	iklib conditions string utf32
	`utf32-string-decoding-invalid-word.index`:	iklib conditions string utf32
	`utf32-string-decoding-invalid-word.word`:	iklib conditions string utf32
	`utf32-string-decoding-invalid-word?`:	iklib conditions string utf32
	`utf32-string-decoding-orphan-octets.bytevector`:	iklib conditions string utf32
	`utf32-string-decoding-orphan-octets.index`:	iklib conditions string utf32
	`utf32-string-decoding-orphan-octets.octets`:	iklib conditions string utf32
	`utf32-string-decoding-orphan-octets?`:	iklib conditions string utf32
	`utf32-string-encoding-error?`:	iklib conditions string utf32
	`utf8->string`:	stdlib bytevector strings
	`utf8->string`:	stdlib bytevector strings
	`utf8->string-length`:	iklib bytevectors conversion
	`utf8->string-length`:	iklib bytevectors conversion
	`utf8-string-decoding-error?`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-2-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-2-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-2-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-2-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-3-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-3-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-3-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-3-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-4-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-4-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-4-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-incomplete-4-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-2-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-2-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-2-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-2-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-3-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-3-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-3-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-3-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-4-tuple.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-4-tuple.index`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-4-tuple.octets`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-4-tuple?`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-octet.bytevector`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-octet.index`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-octet.octets`:	iklib conditions string utf8
	`utf8-string-decoding-invalid-octet?`:	iklib conditions string utf8
	`utf8-string-encoding-error?`:	iklib conditions string utf8
	`utsname!=?`:	iklib env-inquiry
	`utsname-machine`:	iklib env-inquiry
	`utsname-nodename`:	iklib env-inquiry
	`utsname-release`:	iklib env-inquiry
	`utsname-sysname`:	iklib env-inquiry
	`utsname-version`:	iklib env-inquiry
	`utsname=?`:	iklib env-inquiry
	`utsname?`:	iklib env-inquiry
	`uuid`:	iklib strings misc

V
	`values`:	baselib control
	`values->list`:	iklib syntaxes misc
	`variable-transformer-procedure`:	iklib expander transformers
	`variable-transformer?`:	iklib expander transformers
	`vector`:	baselib vectors
	`vector!=?`:	iklib vectors comparison
	`vector->list`:	baselib vectors
	`vector-append`:	iklib vectors constructors
	`vector-copy`:	iklib vectors copying
	`vector-copy!`:	iklib vectors copying
	`vector-empty?`:	iklib vectors predicates
	`vector-exists`:	iklib vectors iteration
	`vector-fill!`:	baselib vectors
	`vector-find`:	iklib vectors iteration
	`vector-fold-left`:	iklib vectors iteration
	`vector-fold-right`:	iklib vectors iteration
	`vector-for-all`:	iklib vectors iteration
	`vector-for-each`:	baselib vectors
	`vector-hash`:	iklib hashtables hashfun
	`vector-hash`:	iklib hashtables hashfun
	`vector-length`:	baselib vectors
	`vector-map`:	baselib vectors
	`vector-of-type-spec.item-ots`:	expander specs vector-of
	`vector-of-type-spec?`:	expander specs vector-of
	`vector-ref`:	scheme entry procedure
	`vector-ref`:	baselib vectors
	`vector-reset!`:	iklib vectors misc
	`vector-reset!`:	iklib vectors misc
	`vector-resize`:	iklib vectors constructors
	`vector-resize`:	iklib vectors constructors
	`vector-set!`:	baselib vectors
	`vector-sort`:	stdlib sorting
	`vector-sort!`:	stdlib sorting
	`vector-type-spec.item-ots*`:	expander specs vector
	`vector-type-spec.length`:	expander specs vector
	`vector-type-spec?`:	expander specs vector
	`vector=?`:	iklib vectors comparison
	`vector?`:	baselib vectors
	`vectors-of-same-length?`:	iklib vectors predicates
	`verbose-timer`:	iklib timing
	`vicare-argv0`:	iklib progname
	`vicare-argv0-string`:	iklib progname
	`vicare-built-with-arguments-validation-enabled`:	iklib config
	`vicare-built-with-descriptive-labels-generation`:	iklib config
	`vicare-built-with-ffi-enabled`:	iklib config
	`vicare-built-with-glibc-enabled`:	iklib config
	`vicare-built-with-iconv-enabled`:	iklib config
	`vicare-built-with-linux-enabled`:	iklib config
	`vicare-built-with-posix-enabled`:	iklib config
	`vicare-built-with-srfi-enabled`:	iklib config
	`violation?`:	stdlib exceptions conditions types
	`virtual-method`:	iklib records defs
	`visit-code-of`:	iklib syntaxes expansion-of
	`visit-library`:	libutils libraries ops
	`void`:	iklib misc
	`void-hash`:	iklib hashtables hashfun
	`void-object?`:	iklib misc

W
	`waiter-prompt-string`:	iklib cafe
	`warning`:	iklib misc
	`warning?`:	stdlib exceptions conditions types
	`weak-cons`:	iklib lists weak
	`weak-pair?`:	iklib lists weak
	`when`:	stdlib control
	`while`:	iklib syntaxes loops while
	`while`:	iklib syntaxes loops do
	`who-condition?`:	stdlib exceptions conditions types
	`with`:	iklib compensations api
	`with-blocked-exceptions`:	iklib syntaxes blocking
	`with-blocked-exceptions`:	iklib syntaxes blocking
	`with-compensation-handler`:	iklib compensations api
	`with-compensations`:	iklib compensations api
	`with-compensations/on-error`:	iklib compensations api
	`with-current-dynamic-environment`:	iklib syntaxes dynenv
	`with-exception-handler`:	stdlib exceptions exceptions
	`with-implicits`:	expander utils id
	`with-input-from-file`:	stdlib io simple
	`with-input-from-file`:	iklib io codecs
	`with-input-from-string`:	iklib io textual
	`with-local-storage`:	iklib memory alloc
	`with-output-to-file`:	stdlib io simple
	`with-output-to-file`:	iklib io codecs
	`with-output-to-string`:	iklib io textual
	`with-syntax`:	stdlib syntax-case derived
	`with-unwind-handler`:	iklib unwind-protect syntaxes
	`with-unwind-protection`:	iklib unwind-protect syntaxes
	`would-block-hash`:	iklib hashtables hashfun
	`would-block-object`:	iklib io non-blocking object
	`would-block-object?`:	iklib io non-blocking object
	`write`:	stdlib io simple
	`write`:	stdlib io simple
	`write-char`:	stdlib io simple
	`write-char`:	stdlib io simple

X
	`xor`:	iklib syntaxes control

Y
	`yield`:	iklib coroutines basic

Z
	`zero-byte-fixnum?`:	iklib fixnums predicates
	`zero-cflonum?`:	iklib numerics preds
	`zero-compnum?`:	iklib numerics preds
	`zero-exact-integer?`:	iklib numerics preds
	`zero-fixnum?`:	iklib fixnums predicates
	`zero-flonum?`:	iklib flonums
	`zero-octet-fixnum?`:	iklib fixnums predicates
	`zero?`:	baselib math ops value pred

Jump to:	! # $ & * + - . / < = > ? \ _ \| A B C D E F G H I K L M N O P Q R S T U V W X Y Z