-;; Generated Fri Feb 15 13:35:09 PST 2002 by guile-scripts/scan-api -- do not edit!
-;; guile: /home/ttn/build/.gnu/guile-core/pre-inst-guile .
-;; sofile: libguile/.libs/libguile.so.10.0.0
-
+;; Generated Thu Feb 28 23:33:42 PST 2002 by guile-scripts/scan-api -- do not edit!
(
+(meta (GUILE_LOAD_PATH . "")
+ (LTDL_LOAD_PATH . "")
+ (guile . "pre-inst-guile")
+ (sofile . "libguile/.libs/libguile.so.15.0.0")
+ (pwd . "/home/ttn/tmp/.tmp"))
(scheme
-($abs "#<primitive-procedure")
-($acos "#<primitive-procedure")
-($acosh "#<primitive-procedure")
-($asin "#<primitive-procedure")
-($asinh "#<primitive-procedure")
-($atan "#<primitive-procedure")
-($atan2 "#<primitive-procedure")
-($atanh "#<primitive-procedure")
-($cos "#<primitive-procedure")
-($cosh "#<primitive-procedure")
-($exp "#<primitive-procedure")
-($expt "#<primitive-procedure")
-($log "#<primitive-procedure")
-($sin "#<primitive-procedure")
-($sinh "#<primitive-procedure")
-($sqrt "#<primitive-procedure")
-($tan "#<primitive-procedure")
-($tanh "#<primitive-procedure")
+($abs "#<primitive-procedure $abs>")
+($acos "#<primitive-procedure $acos>")
+($acosh "#<primitive-procedure $acosh>")
+($asin "#<primitive-procedure $asin>")
+($asinh "#<primitive-procedure $asinh>")
+($atan "#<primitive-procedure $atan>")
+($atan2 "#<primitive-procedure $atan2>")
+($atanh "#<primitive-procedure $atanh>")
+($cos "#<primitive-procedure $cos>")
+($cosh "#<primitive-procedure $cosh>")
+($exp "#<primitive-procedure $exp>")
+($expt "#<primitive-procedure $expt>")
+($log "#<primitive-procedure $log>")
+($sin "#<primitive-procedure $sin>")
+($sinh "#<primitive-procedure $sinh>")
+($sqrt "#<primitive-procedure $sqrt>")
+($tan "#<primitive-procedure $tan>")
+($tanh "#<primitive-procedure $tanh>")
(%cond-expand-features "")
(%cond-expand-table "")
-(%deliver-signals "#<primitive-procedure")
-(%get-pre-modules-obarray "#<primitive-procedure")
+(%deliver-signals "#<primitive-procedure %deliver-signals>")
+(%get-pre-modules-obarray "#<primitive-procedure %get-pre-modules-obarray>")
(%guile-build-info "")
-(%init-goops-builtins "#<primitive-procedure")
-(%init-rdelim-builtins "#<primitive-procedure")
-(%init-rw-builtins "#<primitive-procedure")
-(%library-dir "#<primitive-procedure")
-(%load-announce "#<procedure")
+(%init-goops-builtins "#<primitive-procedure %init-goops-builtins>")
+(%init-rdelim-builtins "#<primitive-procedure %init-rdelim-builtins>")
+(%init-rw-builtins "#<primitive-procedure %init-rw-builtins>")
+(%library-dir "#<primitive-procedure %library-dir>")
+(%load-announce "#<procedure %load-announce (file)>")
(%load-extensions "")
-(%load-hook "#<procedure")
+(%load-hook "#<procedure %load-announce (file)>")
(%load-path "")
(%load-verbosely "")
-(%make-void-port "#<primitive-procedure")
+(%make-void-port "#<primitive-procedure %make-void-port>")
(%module-public-interface "")
(%module-public-interface "")
(%nil "")
-(%package-data-dir "#<primitive-procedure")
-(%print-module "#<procedure")
-(%print-values "#<primitive-procedure")
-(%search-load-path "#<primitive-procedure")
-(%site-dir "#<primitive-procedure")
-(* "#<primitive-procedure")
+(%package-data-dir "#<primitive-procedure %package-data-dir>")
+(%print-module "#<procedure %print-module (mod port)>")
+(%print-values "#<primitive-procedure %print-values>")
+(%search-load-path "#<primitive-procedure %search-load-path>")
+(%site-dir "#<primitive-procedure %site-dir>")
+(* "#<primitive-procedure *>")
(*features* "")
(*null-device* "")
(*random-state* "")
(*unspecified* "")
-(+ "#<primitive-procedure")
-(- "#<primitive-procedure")
-(->bool "#<procedure")
-(/ "#<primitive-procedure")
-(1+ "#<procedure")
-(1- "#<procedure")
-(< "#<primitive-procedure")
-(<= "#<primitive-procedure")
+(+ "#<primitive-procedure +>")
+(- "#<primitive-procedure ->")
+(->bool "#<procedure ->bool (x)>")
+(/ "#<primitive-procedure />")
+(1+ "#<procedure 1+ (n)>")
+(1- "#<procedure 1- (n)>")
+(< "#<primitive-procedure <>")
+(<= "#<primitive-procedure <=>")
(<class> "")
(<entity> "")
(<operator-class> "")
-(= "#<primitive-procedure")
-(> "#<primitive-procedure")
-(>= "#<primitive-procedure")
+(= "#<primitive-procedure =>")
+(> "#<primitive-procedure >>")
+(>= "#<primitive-procedure >=>")
(@apply "")
(@bind "")
(@call-with-current-continuation "")
(_IOLBF "")
(_IONBF "")
(abort-hook "")
-(abs "#<primitive-procedure")
-(accept "#<primitive-procedure")
-(access? "#<primitive-procedure")
-(acons "#<primitive-procedure")
-(acos "#<procedure")
-(acosh "#<procedure")
-(add-hook! "#<primitive-procedure")
+(abs "#<primitive-procedure abs>")
+(accept "#<primitive-procedure accept>")
+(access? "#<primitive-procedure access?>")
+(acons "#<primitive-procedure acons>")
+(acos "#<procedure acos (z)>")
+(acosh "#<procedure acosh (z)>")
+(add-hook! "#<primitive-procedure add-hook!>")
(after-backtrace-hook "")
(after-error-hook "")
(after-eval-hook "")
(after-gc-hook "")
(after-print-hook "")
(after-read-hook "")
-(alarm "#<primitive-procedure")
+(alarm "#<primitive-procedure alarm>")
(and "")
-(and-map "#<procedure")
-(and=> "#<procedure")
-(angle "#<primitive-procedure")
+(and-map "#<procedure and-map (f lst)>")
+(and=> "#<procedure and=> (value procedure)>")
+(angle "#<primitive-procedure angle>")
(app "")
-(append "#<primitive-procedure")
-(append! "#<primitive-procedure")
-(apply "#<procedure")
-(apply-to-args "#<procedure")
-(apply:nconc2last "#<primitive-procedure")
-(array->list "#<primitive-procedure")
-(array-contents "#<primitive-procedure")
-(array-copy! "#<primitive-procedure")
-(array-copy-in-order! "#<primitive-procedure")
-(array-dimensions "#<primitive-procedure")
-(array-equal? "#<primitive-procedure")
-(array-fill! "#<primitive-procedure")
-(array-for-each "#<primitive-procedure")
-(array-in-bounds? "#<primitive-procedure")
-(array-index-map! "#<primitive-procedure")
-(array-map! "#<primitive-procedure")
-(array-map-in-order! "#<primitive-procedure")
-(array-prototype "#<primitive-procedure")
-(array-rank "#<primitive-procedure")
-(array-ref "#<primitive-procedure")
-(array-set! "#<primitive-procedure")
-(array-shape "#<procedure")
-(array? "#<primitive-procedure")
-(ash "#<primitive-procedure")
-(asin "#<procedure")
-(asinh "#<procedure")
-(assert-defmacro?! "#<procedure")
-(assert-load-verbosity "#<procedure")
-(assert-repl-print-unspecified "#<procedure")
-(assert-repl-silence "#<procedure")
-(assert-repl-verbosity "#<procedure")
-(assoc "#<primitive-procedure")
-(assoc-ref "#<primitive-procedure")
-(assoc-remove! "#<primitive-procedure")
-(assoc-set! "#<primitive-procedure")
-(assq "#<primitive-procedure")
-(assq-ref "#<primitive-procedure")
-(assq-remove! "#<primitive-procedure")
-(assq-set! "#<primitive-procedure")
-(assv "#<primitive-procedure")
-(assv-ref "#<primitive-procedure")
-(assv-remove! "#<primitive-procedure")
-(assv-set! "#<primitive-procedure")
-(async "#<primitive-procedure")
-(async-mark "#<primitive-procedure")
-(atan "#<procedure")
-(atanh "#<procedure")
-(autoload-done! "#<procedure")
-(autoload-done-or-in-progress? "#<procedure")
-(autoload-in-progress! "#<procedure")
+(append "#<primitive-procedure append>")
+(append! "#<primitive-procedure append!>")
+(apply "#<procedure apply (fun . args)>")
+(apply-to-args "#<procedure apply-to-args (args fn)>")
+(apply:nconc2last "#<primitive-procedure apply:nconc2last>")
+(array->list "#<primitive-procedure array->list>")
+(array-contents "#<primitive-procedure array-contents>")
+(array-copy! "#<primitive-procedure array-copy!>")
+(array-copy-in-order! "#<primitive-procedure array-copy-in-order!>")
+(array-dimensions "#<primitive-procedure array-dimensions>")
+(array-equal? "#<primitive-procedure array-equal?>")
+(array-fill! "#<primitive-procedure array-fill!>")
+(array-for-each "#<primitive-procedure array-for-each>")
+(array-in-bounds? "#<primitive-procedure array-in-bounds?>")
+(array-index-map! "#<primitive-procedure array-index-map!>")
+(array-map! "#<primitive-procedure array-map!>")
+(array-map-in-order! "#<primitive-procedure array-map-in-order!>")
+(array-prototype "#<primitive-procedure array-prototype>")
+(array-rank "#<primitive-procedure array-rank>")
+(array-ref "#<primitive-procedure array-ref>")
+(array-set! "#<primitive-procedure array-set!>")
+(array-shape "#<procedure array-shape (a)>")
+(array? "#<primitive-procedure array?>")
+(ash "#<primitive-procedure ash>")
+(asin "#<procedure asin (z)>")
+(asinh "#<procedure asinh (z)>")
+(assert-defmacro?! "#<procedure assert-defmacro?! (m)>")
+(assert-load-verbosity "#<procedure assert-load-verbosity (v)>")
+(assert-repl-print-unspecified "#<procedure assert-repl-print-unspecified (v)>")
+(assert-repl-silence "#<procedure assert-repl-silence (v)>")
+(assert-repl-verbosity "#<procedure assert-repl-verbosity (v)>")
+(assoc "#<primitive-procedure assoc>")
+(assoc-ref "#<primitive-procedure assoc-ref>")
+(assoc-remove! "#<primitive-procedure assoc-remove!>")
+(assoc-set! "#<primitive-procedure assoc-set!>")
+(assq "#<primitive-procedure assq>")
+(assq-ref "#<primitive-procedure assq-ref>")
+(assq-remove! "#<primitive-procedure assq-remove!>")
+(assq-set! "#<primitive-procedure assq-set!>")
+(assv "#<primitive-procedure assv>")
+(assv-ref "#<primitive-procedure assv-ref>")
+(assv-remove! "#<primitive-procedure assv-remove!>")
+(assv-set! "#<primitive-procedure assv-set!>")
+(async "#<primitive-procedure async>")
+(async-mark "#<primitive-procedure async-mark>")
+(atan "#<procedure atan (z . y)>")
+(atanh "#<procedure atanh (z)>")
+(autoload-done! "#<procedure autoload-done! (p m)>")
+(autoload-done-or-in-progress? "#<procedure autoload-done-or-in-progress? (p m)>")
+(autoload-in-progress! "#<procedure autoload-in-progress! (p m)>")
(autoloads-done "")
(autoloads-in-progress "")
-(backtrace "#<primitive-procedure")
-(bad-throw "#<procedure")
-(basename "#<primitive-procedure")
-(basic-load "#<procedure")
-(batch-mode? "#<procedure")
-(beautify-user-module! "#<procedure")
+(backtrace "#<primitive-procedure backtrace>")
+(bad-throw "#<procedure bad-throw (key . args)>")
+(basename "#<primitive-procedure basename>")
+(basic-load "#<procedure load (name)>")
+(batch-mode? "#<procedure batch-mode? ()>")
+(beautify-user-module! "#<procedure beautify-user-module! (module)>")
(before-backtrace-hook "")
(before-error-hook "")
(before-eval-hook "")
(before-signal-stack "")
(begin "")
(begin-deprecated "")
-(bind "#<primitive-procedure")
-(bit-count "#<primitive-procedure")
-(bit-count* "#<primitive-procedure")
-(bit-extract "#<primitive-procedure")
-(bit-invert! "#<primitive-procedure")
-(bit-position "#<primitive-procedure")
-(bit-set*! "#<primitive-procedure")
-(boolean? "#<primitive-procedure")
-(caaaar "#<primitive-procedure")
-(caaadr "#<primitive-procedure")
-(caaar "#<primitive-procedure")
-(caadar "#<primitive-procedure")
-(caaddr "#<primitive-procedure")
-(caadr "#<primitive-procedure")
-(caar "#<primitive-procedure")
-(cadaar "#<primitive-procedure")
-(cadadr "#<primitive-procedure")
-(cadar "#<primitive-procedure")
-(caddar "#<primitive-procedure")
-(cadddr "#<primitive-procedure")
-(caddr "#<primitive-procedure")
-(cadr "#<primitive-procedure")
-(call-with-current-continuation "#<procedure")
-(call-with-dynamic-root "#<primitive-procedure")
-(call-with-input-file "#<procedure")
-(call-with-input-string "#<primitive-procedure")
-(call-with-new-thread "#<primitive-procedure")
-(call-with-output-file "#<procedure")
-(call-with-output-string "#<primitive-procedure")
-(call-with-values "#<procedure")
-(car "#<primitive-procedure")
+(bind "#<primitive-procedure bind>")
+(bit-count "#<primitive-procedure bit-count>")
+(bit-count* "#<primitive-procedure bit-count*>")
+(bit-extract "#<primitive-procedure bit-extract>")
+(bit-invert! "#<primitive-procedure bit-invert!>")
+(bit-position "#<primitive-procedure bit-position>")
+(bit-set*! "#<primitive-procedure bit-set*!>")
+(boolean? "#<primitive-procedure boolean?>")
+(caaaar "#<primitive-procedure caaaar>")
+(caaadr "#<primitive-procedure caaadr>")
+(caaar "#<primitive-procedure caaar>")
+(caadar "#<primitive-procedure caadar>")
+(caaddr "#<primitive-procedure caaddr>")
+(caadr "#<primitive-procedure caadr>")
+(caar "#<primitive-procedure caar>")
+(cadaar "#<primitive-procedure cadaar>")
+(cadadr "#<primitive-procedure cadadr>")
+(cadar "#<primitive-procedure cadar>")
+(caddar "#<primitive-procedure caddar>")
+(cadddr "#<primitive-procedure cadddr>")
+(caddr "#<primitive-procedure caddr>")
+(cadr "#<primitive-procedure cadr>")
+(call-with-current-continuation "#<procedure call-with-current-continuation (proc)>")
+(call-with-dynamic-root "#<primitive-procedure call-with-dynamic-root>")
+(call-with-input-file "#<procedure call-with-input-file (str proc)>")
+(call-with-input-string "#<primitive-procedure call-with-input-string>")
+(call-with-new-thread "#<primitive-procedure call-with-new-thread>")
+(call-with-output-file "#<procedure call-with-output-file (str proc)>")
+(call-with-output-string "#<primitive-procedure call-with-output-string>")
+(call-with-values "#<procedure call-with-values (producer consumer)>")
+(car "#<primitive-procedure car>")
(case "")
-(catch "#<primitive-procedure")
-(cdaaar "#<primitive-procedure")
-(cdaadr "#<primitive-procedure")
-(cdaar "#<primitive-procedure")
-(cdadar "#<primitive-procedure")
-(cdaddr "#<primitive-procedure")
-(cdadr "#<primitive-procedure")
-(cdar "#<primitive-procedure")
-(cddaar "#<primitive-procedure")
-(cddadr "#<primitive-procedure")
-(cddar "#<primitive-procedure")
-(cdddar "#<primitive-procedure")
-(cddddr "#<primitive-procedure")
-(cdddr "#<primitive-procedure")
-(cddr "#<primitive-procedure")
-(cdr "#<primitive-procedure")
-(ceiling "#<primitive-procedure")
-(char->integer "#<primitive-procedure")
-(char-alphabetic? "#<primitive-procedure")
-(char-ci<=? "#<primitive-procedure")
-(char-ci<? "#<primitive-procedure")
-(char-ci=? "#<primitive-procedure")
-(char-ci>=? "#<primitive-procedure")
-(char-ci>? "#<primitive-procedure")
+(catch "#<primitive-procedure catch>")
+(cdaaar "#<primitive-procedure cdaaar>")
+(cdaadr "#<primitive-procedure cdaadr>")
+(cdaar "#<primitive-procedure cdaar>")
+(cdadar "#<primitive-procedure cdadar>")
+(cdaddr "#<primitive-procedure cdaddr>")
+(cdadr "#<primitive-procedure cdadr>")
+(cdar "#<primitive-procedure cdar>")
+(cddaar "#<primitive-procedure cddaar>")
+(cddadr "#<primitive-procedure cddadr>")
+(cddar "#<primitive-procedure cddar>")
+(cdddar "#<primitive-procedure cdddar>")
+(cddddr "#<primitive-procedure cddddr>")
+(cdddr "#<primitive-procedure cdddr>")
+(cddr "#<primitive-procedure cddr>")
+(cdr "#<primitive-procedure cdr>")
+(ceiling "#<primitive-procedure ceiling>")
+(char->integer "#<primitive-procedure char->integer>")
+(char-alphabetic? "#<primitive-procedure char-alphabetic?>")
+(char-ci<=? "#<primitive-procedure char-ci<=?>")
+(char-ci<? "#<primitive-procedure char-ci<?>")
+(char-ci=? "#<primitive-procedure char-ci=?>")
+(char-ci>=? "#<primitive-procedure char-ci>=?>")
+(char-ci>? "#<primitive-procedure char-ci>?>")
(char-code-limit "")
-(char-downcase "#<primitive-procedure")
-(char-is-both? "#<primitive-procedure")
-(char-lower-case? "#<primitive-procedure")
-(char-numeric? "#<primitive-procedure")
-(char-ready? "#<primitive-procedure")
-(char-upcase "#<primitive-procedure")
-(char-upper-case? "#<primitive-procedure")
-(char-whitespace? "#<primitive-procedure")
-(char<=? "#<primitive-procedure")
-(char<? "#<primitive-procedure")
-(char=? "#<primitive-procedure")
-(char>=? "#<primitive-procedure")
-(char>? "#<primitive-procedure")
-(char? "#<primitive-procedure")
-(chdir "#<primitive-procedure")
-(chmod "#<primitive-procedure")
-(chown "#<primitive-procedure")
-(chroot "#<primitive-procedure")
-(class-of "#<primitive-procedure")
-(close "#<primitive-procedure")
-(close-fdes "#<primitive-procedure")
-(close-input-port "#<primitive-procedure")
-(close-io-port "#<primitive-procedure")
-(close-output-port "#<primitive-procedure")
-(close-port "#<primitive-procedure")
-(closedir "#<primitive-procedure")
-(closure? "#<primitive-procedure")
+(char-downcase "#<primitive-procedure char-downcase>")
+(char-is-both? "#<primitive-procedure char-is-both?>")
+(char-lower-case? "#<primitive-procedure char-lower-case?>")
+(char-numeric? "#<primitive-procedure char-numeric?>")
+(char-ready? "#<primitive-procedure char-ready?>")
+(char-upcase "#<primitive-procedure char-upcase>")
+(char-upper-case? "#<primitive-procedure char-upper-case?>")
+(char-whitespace? "#<primitive-procedure char-whitespace?>")
+(char<=? "#<primitive-procedure char<=?>")
+(char<? "#<primitive-procedure char<?>")
+(char=? "#<primitive-procedure char=?>")
+(char>=? "#<primitive-procedure char>=?>")
+(char>? "#<primitive-procedure char>?>")
+(char? "#<primitive-procedure char?>")
+(chdir "#<primitive-procedure chdir>")
+(chmod "#<primitive-procedure chmod>")
+(chown "#<primitive-procedure chown>")
+(chroot "#<primitive-procedure chroot>")
+(class-of "#<primitive-procedure class-of>")
+(close "#<primitive-procedure close>")
+(close-fdes "#<primitive-procedure close-fdes>")
+(close-input-port "#<primitive-procedure close-input-port>")
+(close-io-port "#<primitive-procedure close-port>")
+(close-output-port "#<primitive-procedure close-output-port>")
+(close-port "#<primitive-procedure close-port>")
+(closedir "#<primitive-procedure closedir>")
+(closure? "#<primitive-procedure closure?>")
(collect "")
-(command-line "#<procedure")
-(compile-define-module-args "#<procedure")
-(compile-interface-spec "#<procedure")
-(complex? "#<primitive-procedure")
+(command-line "#<procedure command-line ()>")
+(compile-define-module-args "#<procedure compile-define-module-args (args)>")
+(compile-interface-spec "#<procedure compile-interface-spec (spec)>")
+(complex? "#<primitive-procedure complex?>")
(cond "")
(cond-expand "")
-(cond-expand-provide "#<procedure")
-(connect "#<primitive-procedure")
-(cons "#<primitive-procedure")
-(cons* "#<primitive-procedure")
-(cons-source "#<primitive-procedure")
-(copy-file "#<primitive-procedure")
-(copy-random-state "#<primitive-procedure")
-(copy-tree "#<primitive-procedure")
-(cos "#<procedure")
-(cosh "#<procedure")
-(crypt "#<primitive-procedure")
-(ctermid "#<primitive-procedure")
-(current-error-port "#<primitive-procedure")
-(current-input-port "#<primitive-procedure")
-(current-load-port "#<primitive-procedure")
-(current-module "#<primitive-procedure")
-(current-output-port "#<primitive-procedure")
-(current-time "#<primitive-procedure")
-(cuserid "#<primitive-procedure")
-(debug-disable "#<procedure")
-(debug-enable "#<procedure")
-(debug-object? "#<primitive-procedure")
-(debug-options "#<procedure")
-(debug-options-interface "#<primitive-procedure")
+(cond-expand-provide "#<procedure cond-expand-provide (module features)>")
+(connect "#<primitive-procedure connect>")
+(cons "#<primitive-procedure cons>")
+(cons* "#<primitive-procedure cons*>")
+(cons-source "#<primitive-procedure cons-source>")
+(copy-file "#<primitive-procedure copy-file>")
+(copy-random-state "#<primitive-procedure copy-random-state>")
+(copy-tree "#<primitive-procedure copy-tree>")
+(cos "#<procedure cos (z)>")
+(cosh "#<procedure cosh (z)>")
+(crypt "#<primitive-procedure crypt>")
+(ctermid "#<primitive-procedure ctermid>")
+(current-error-port "#<primitive-procedure current-error-port>")
+(current-input-port "#<primitive-procedure current-input-port>")
+(current-load-port "#<primitive-procedure current-load-port>")
+(current-module "#<primitive-procedure current-module>")
+(current-output-port "#<primitive-procedure current-output-port>")
+(current-time "#<primitive-procedure current-time>")
+(cuserid "#<primitive-procedure cuserid>")
+(debug-disable "#<procedure debug-disable flags>")
+(debug-enable "#<procedure debug-enable flags>")
+(debug-object? "#<primitive-procedure debug-object?>")
+(debug-options "#<procedure debug-options args>")
+(debug-options-interface "#<primitive-procedure debug-options-interface>")
(debug-set! "")
-(default-lazy-handler "#<procedure")
+(default-lazy-handler "#<procedure default-lazy-handler (key . args)>")
(define "")
(define-macro "")
(define-module "")
(define-private "")
(define-public "")
(define-syntax-macro "")
-(defined? "#<primitive-procedure")
+(defined? "#<primitive-procedure defined?>")
(defmacro "")
(defmacro-public "")
-(defmacro-transformer "#<procedure")
-(defmacro:syntax-transformer "#<procedure")
-(defmacro:transformer "#<procedure")
-(defmacro? "#<procedure")
+(defmacro-transformer "#<procedure defmacro-transformer (m)>")
+(defmacro:syntax-transformer "#<procedure defmacro:syntax-transformer (f)>")
+(defmacro:transformer "#<procedure defmacro:transformer (f)>")
+(defmacro? "#<procedure defmacro? (m)>")
(delay "")
-(delete "#<primitive-procedure")
-(delete! "#<primitive-procedure")
-(delete-file "#<primitive-procedure")
-(delete1! "#<primitive-procedure")
-(delq "#<primitive-procedure")
-(delq! "#<primitive-procedure")
-(delq1! "#<primitive-procedure")
-(delv "#<primitive-procedure")
-(delv! "#<primitive-procedure")
-(delv1! "#<primitive-procedure")
-(destroy-guardian! "#<primitive-procedure")
-(dimensions->uniform-array "#<primitive-procedure")
-(directory-stream? "#<primitive-procedure")
-(dirname "#<primitive-procedure")
-(display "#<primitive-procedure")
-(display-application "#<primitive-procedure")
-(display-backtrace "#<primitive-procedure")
-(display-error "#<primitive-procedure")
-(display-usage-report "#<procedure")
+(delete "#<primitive-procedure delete>")
+(delete! "#<primitive-procedure delete!>")
+(delete-file "#<primitive-procedure delete-file>")
+(delete1! "#<primitive-procedure delete1!>")
+(delq "#<primitive-procedure delq>")
+(delq! "#<primitive-procedure delq!>")
+(delq1! "#<primitive-procedure delq1!>")
+(delv "#<primitive-procedure delv>")
+(delv! "#<primitive-procedure delv!>")
+(delv1! "#<primitive-procedure delv1!>")
+(destroy-guardian! "#<primitive-procedure destroy-guardian!>")
+(dimensions->uniform-array "#<primitive-procedure dimensions->uniform-array>")
+(directory-stream? "#<primitive-procedure directory-stream?>")
+(dirname "#<primitive-procedure dirname>")
+(display "#<primitive-procedure display>")
+(display-application "#<primitive-procedure display-application>")
+(display-backtrace "#<primitive-procedure display-backtrace>")
+(display-error "#<primitive-procedure display-error>")
+(display-usage-report "#<procedure display-usage-report (kw-desc)>")
(do "")
-(doubly-weak-hash-table? "#<primitive-procedure")
-(drain-input "#<primitive-procedure")
-(dup "#<procedure")
-(dup->fdes "#<primitive-procedure")
-(dup->inport "#<procedure")
-(dup->outport "#<procedure")
-(dup->port "#<procedure")
-(dup2 "#<primitive-procedure")
-(duplicate-port "#<procedure")
-(dynamic-args-call "#<primitive-procedure")
-(dynamic-call "#<primitive-procedure")
-(dynamic-func "#<primitive-procedure")
-(dynamic-link "#<primitive-procedure")
-(dynamic-object? "#<primitive-procedure")
-(dynamic-root "#<primitive-procedure")
-(dynamic-unlink "#<primitive-procedure")
-(dynamic-wind "#<primitive-procedure")
-(enclose-array "#<primitive-procedure")
-(endgrent "#<procedure")
-(endhostent "#<procedure")
-(endnetent "#<procedure")
-(endprotoent "#<procedure")
-(endpwent "#<procedure")
-(endservent "#<procedure")
-(entity? "#<primitive-procedure")
-(env-module "#<primitive-procedure")
-(environ "#<primitive-procedure")
-(environment-bound? "#<primitive-procedure")
-(environment-cell "#<primitive-procedure")
-(environment-define "#<primitive-procedure")
-(environment-fold "#<primitive-procedure")
-(environment-module "#<procedure")
-(environment-observe "#<primitive-procedure")
-(environment-observe-weak "#<primitive-procedure")
-(environment-ref "#<primitive-procedure")
-(environment-set! "#<primitive-procedure")
-(environment-undefine "#<primitive-procedure")
-(environment-unobserve "#<primitive-procedure")
-(environment? "#<primitive-procedure")
-(eof-object? "#<primitive-procedure")
-(eq? "#<primitive-procedure")
-(equal? "#<primitive-procedure")
-(eqv? "#<primitive-procedure")
-(error "#<procedure")
-(error-catching-loop "#<procedure")
-(error-catching-repl "#<procedure")
-(eval "#<primitive-procedure")
+(doubly-weak-hash-table? "#<primitive-procedure doubly-weak-hash-table?>")
+(drain-input "#<primitive-procedure drain-input>")
+(dup "#<procedure dup (port/fd . maybe-fd)>")
+(dup->fdes "#<primitive-procedure dup->fdes>")
+(dup->inport "#<procedure dup->inport (port/fd . maybe-fd)>")
+(dup->outport "#<procedure dup->outport (port/fd . maybe-fd)>")
+(dup->port "#<procedure dup->port (port/fd mode . maybe-fd)>")
+(dup2 "#<primitive-procedure dup2>")
+(duplicate-port "#<procedure duplicate-port (port modes)>")
+(dynamic-args-call "#<primitive-procedure dynamic-args-call>")
+(dynamic-call "#<primitive-procedure dynamic-call>")
+(dynamic-func "#<primitive-procedure dynamic-func>")
+(dynamic-link "#<primitive-procedure dynamic-link>")
+(dynamic-object? "#<primitive-procedure dynamic-object?>")
+(dynamic-root "#<primitive-procedure dynamic-root>")
+(dynamic-unlink "#<primitive-procedure dynamic-unlink>")
+(dynamic-wind "#<primitive-procedure dynamic-wind>")
+(enclose-array "#<primitive-procedure enclose-array>")
+(endgrent "#<procedure endgrent ()>")
+(endhostent "#<procedure endhostent ()>")
+(endnetent "#<procedure endnetent ()>")
+(endprotoent "#<procedure endprotoent ()>")
+(endpwent "#<procedure endpwent ()>")
+(endservent "#<procedure endservent ()>")
+(entity? "#<primitive-procedure entity?>")
+(env-module "#<primitive-procedure env-module>")
+(environ "#<primitive-procedure environ>")
+(environment-bound? "#<primitive-procedure environment-bound?>")
+(environment-cell "#<primitive-procedure environment-cell>")
+(environment-define "#<primitive-procedure environment-define>")
+(environment-fold "#<primitive-procedure environment-fold>")
+(environment-module "#<procedure environment-module (env)>")
+(environment-observe "#<primitive-procedure environment-observe>")
+(environment-observe-weak "#<primitive-procedure environment-observe-weak>")
+(environment-ref "#<primitive-procedure environment-ref>")
+(environment-set! "#<primitive-procedure environment-set!>")
+(environment-undefine "#<primitive-procedure environment-undefine>")
+(environment-unobserve "#<primitive-procedure environment-unobserve>")
+(environment? "#<primitive-procedure environment?>")
+(eof-object? "#<primitive-procedure eof-object?>")
+(eq? "#<primitive-procedure eq?>")
+(equal? "#<primitive-procedure equal?>")
+(eqv? "#<primitive-procedure eqv?>")
+(error "#<procedure error args>")
+(error-catching-loop "#<procedure error-catching-loop (thunk)>")
+(error-catching-repl "#<procedure error-catching-repl (r e p)>")
+(eval "#<primitive-procedure eval>")
(eval-case "")
-(eval-disable "#<procedure")
-(eval-enable "#<procedure")
-(eval-environment-imported "#<primitive-procedure")
-(eval-environment-local "#<primitive-procedure")
-(eval-environment-set-imported! "#<primitive-procedure")
-(eval-environment-set-local! "#<primitive-procedure")
-(eval-environment? "#<primitive-procedure")
-(eval-options "#<procedure")
-(eval-options-interface "#<primitive-procedure")
+(eval-disable "#<procedure eval-disable flags>")
+(eval-enable "#<procedure eval-enable flags>")
+(eval-environment-imported "#<primitive-procedure eval-environment-imported>")
+(eval-environment-local "#<primitive-procedure eval-environment-local>")
+(eval-environment-set-imported! "#<primitive-procedure eval-environment-set-imported!>")
+(eval-environment-set-local! "#<primitive-procedure eval-environment-set-local!>")
+(eval-environment? "#<primitive-procedure eval-environment?>")
+(eval-options "#<procedure eval-options args>")
+(eval-options-interface "#<primitive-procedure eval-options-interface>")
(eval-set! "")
-(eval-string "#<primitive-procedure")
-(evaluator-traps-interface "#<primitive-procedure")
-(even? "#<primitive-procedure")
-(exact->inexact "#<primitive-procedure")
-(exact? "#<primitive-procedure")
-(execl "#<primitive-procedure")
-(execle "#<primitive-procedure")
-(execlp "#<primitive-procedure")
-(exit "#<procedure")
+(eval-string "#<primitive-procedure eval-string>")
+(evaluator-traps-interface "#<primitive-procedure evaluator-traps-interface>")
+(even? "#<primitive-procedure even?>")
+(exact->inexact "#<primitive-procedure exact->inexact>")
+(exact? "#<primitive-procedure exact?>")
+(execl "#<primitive-procedure execl>")
+(execle "#<primitive-procedure execle>")
+(execlp "#<primitive-procedure execlp>")
+(exit "#<procedure quit args>")
(exit-hook "")
-(exp "#<procedure")
+(exp "#<procedure exp (z)>")
(export "")
-(export-environment-private "#<primitive-procedure")
-(export-environment-set-private! "#<primitive-procedure")
-(export-environment-set-signature! "#<primitive-procedure")
-(export-environment-signature "#<primitive-procedure")
-(export-environment? "#<primitive-procedure")
+(export-environment-private "#<primitive-procedure export-environment-private>")
+(export-environment-set-private! "#<primitive-procedure export-environment-set-private!>")
+(export-environment-set-signature! "#<primitive-procedure export-environment-set-signature!>")
+(export-environment-signature "#<primitive-procedure export-environment-signature>")
+(export-environment? "#<primitive-procedure export-environment?>")
(export-syntax "")
-(expt "#<procedure")
+(expt "#<procedure expt (z1 z2)>")
(false-if-exception "")
-(fcntl "#<primitive-procedure")
-(fdes->inport "#<procedure")
-(fdes->outport "#<procedure")
-(fdes->ports "#<primitive-procedure")
-(fdopen "#<primitive-procedure")
-(feature? "#<procedure")
-(file-exists? "#<procedure")
-(file-is-directory? "#<procedure")
-(file-port? "#<primitive-procedure")
-(file-position "#<procedure")
-(file-set-position "#<procedure")
-(fileno "#<primitive-procedure")
-(flock "#<primitive-procedure")
-(floor "#<primitive-procedure")
-(fluid-ref "#<primitive-procedure")
-(fluid-set! "#<primitive-procedure")
-(fluid? "#<primitive-procedure")
-(flush-all-ports "#<primitive-procedure")
-(for-each "#<primitive-procedure")
-(for-next-option "#<procedure")
-(force "#<primitive-procedure")
-(force-output "#<primitive-procedure")
-(format "#<primitive-procedure")
-(frame-arguments "#<primitive-procedure")
-(frame-evaluating-args? "#<primitive-procedure")
-(frame-next "#<primitive-procedure")
-(frame-number "#<primitive-procedure")
-(frame-overflow? "#<primitive-procedure")
-(frame-previous "#<primitive-procedure")
-(frame-procedure "#<primitive-procedure")
-(frame-procedure? "#<primitive-procedure")
-(frame-real? "#<primitive-procedure")
-(frame-source "#<primitive-procedure")
-(frame? "#<primitive-procedure")
-(fsync "#<primitive-procedure")
-(ftell "#<primitive-procedure")
-(gc "#<primitive-procedure")
-(gc-run-time "#<procedure")
-(gc-stats "#<primitive-procedure")
-(gcd "#<primitive-procedure")
-(gensym "#<primitive-procedure")
-(get-internal-real-time "#<primitive-procedure")
-(get-internal-run-time "#<primitive-procedure")
-(get-option "#<procedure")
-(get-output-string "#<primitive-procedure")
-(get-print-state "#<primitive-procedure")
-(getcwd "#<primitive-procedure")
-(getegid "#<primitive-procedure")
-(getenv "#<primitive-procedure")
-(geteuid "#<primitive-procedure")
-(getgid "#<primitive-procedure")
-(getgr "#<primitive-procedure")
-(getgrent "#<procedure")
-(getgrgid "#<procedure")
-(getgrnam "#<procedure")
-(getgroups "#<primitive-procedure")
-(gethost "#<primitive-procedure")
-(gethostbyaddr "#<procedure")
-(gethostbyname "#<procedure")
-(gethostent "#<procedure")
-(gethostname "#<primitive-procedure")
-(getitimer "#<primitive-procedure")
-(getlogin "#<primitive-procedure")
-(getnet "#<primitive-procedure")
-(getnetbyaddr "#<procedure")
-(getnetbyname "#<procedure")
-(getnetent "#<procedure")
-(getpass "#<primitive-procedure")
-(getpeername "#<primitive-procedure")
-(getpgrp "#<primitive-procedure")
-(getpid "#<primitive-procedure")
-(getppid "#<primitive-procedure")
-(getpriority "#<primitive-procedure")
-(getproto "#<primitive-procedure")
-(getprotobyname "#<procedure")
-(getprotobynumber "#<procedure")
-(getprotoent "#<procedure")
-(getpw "#<primitive-procedure")
-(getpwent "#<procedure")
-(getpwnam "#<procedure")
-(getpwuid "#<procedure")
-(getserv "#<primitive-procedure")
-(getservbyname "#<procedure")
-(getservbyport "#<procedure")
-(getservent "#<procedure")
-(getsockname "#<primitive-procedure")
-(getsockopt "#<primitive-procedure")
-(gettimeofday "#<primitive-procedure")
-(getuid "#<primitive-procedure")
-(gmtime "#<primitive-procedure")
-(group:gid "#<procedure")
-(group:mem "#<procedure")
-(group:name "#<procedure")
-(group:passwd "#<procedure")
-(guardian-destroyed? "#<primitive-procedure")
-(guardian-greedy? "#<primitive-procedure")
-(handle-system-error "#<procedure")
+(fcntl "#<primitive-procedure fcntl>")
+(fdes->inport "#<procedure fdes->inport (fdes)>")
+(fdes->outport "#<procedure fdes->outport (fdes)>")
+(fdes->ports "#<primitive-procedure fdes->ports>")
+(fdopen "#<primitive-procedure fdopen>")
+(feature? "#<procedure provided? (feature)>")
+(file-exists? "#<procedure file-exists? (str)>")
+(file-is-directory? "#<procedure file-is-directory? (str)>")
+(file-port? "#<primitive-procedure file-port?>")
+(file-position "#<procedure file-position args>")
+(file-set-position "#<procedure file-set-position args>")
+(fileno "#<primitive-procedure fileno>")
+(flock "#<primitive-procedure flock>")
+(floor "#<primitive-procedure floor>")
+(fluid-ref "#<primitive-procedure fluid-ref>")
+(fluid-set! "#<primitive-procedure fluid-set!>")
+(fluid? "#<primitive-procedure fluid?>")
+(flush-all-ports "#<primitive-procedure flush-all-ports>")
+(for-each "#<primitive-procedure for-each>")
+(for-next-option "#<procedure for-next-option (proc argv kw-opts kw-args)>")
+(force "#<primitive-procedure force>")
+(force-output "#<primitive-procedure force-output>")
+(format "#<primitive-procedure simple-format>")
+(frame-arguments "#<primitive-procedure frame-arguments>")
+(frame-evaluating-args? "#<primitive-procedure frame-evaluating-args?>")
+(frame-next "#<primitive-procedure frame-next>")
+(frame-number "#<primitive-procedure frame-number>")
+(frame-overflow? "#<primitive-procedure frame-overflow?>")
+(frame-previous "#<primitive-procedure frame-previous>")
+(frame-procedure "#<primitive-procedure frame-procedure>")
+(frame-procedure? "#<primitive-procedure frame-procedure?>")
+(frame-real? "#<primitive-procedure frame-real?>")
+(frame-source "#<primitive-procedure frame-source>")
+(frame? "#<primitive-procedure frame?>")
+(fsync "#<primitive-procedure fsync>")
+(ftell "#<primitive-procedure ftell>")
+(gc "#<primitive-procedure gc>")
+(gc-run-time "#<procedure gc-run-time ()>")
+(gc-stats "#<primitive-procedure gc-stats>")
+(gcd "#<primitive-procedure gcd>")
+(gensym "#<primitive-procedure gensym>")
+(get-internal-real-time "#<primitive-procedure get-internal-real-time>")
+(get-internal-run-time "#<primitive-procedure get-internal-run-time>")
+(get-option "#<procedure get-option (argv kw-opts kw-args return)>")
+(get-output-string "#<primitive-procedure get-output-string>")
+(get-print-state "#<primitive-procedure get-print-state>")
+(getcwd "#<primitive-procedure getcwd>")
+(getegid "#<primitive-procedure getegid>")
+(getenv "#<primitive-procedure getenv>")
+(geteuid "#<primitive-procedure geteuid>")
+(getgid "#<primitive-procedure getgid>")
+(getgr "#<primitive-procedure getgr>")
+(getgrent "#<procedure getgrent ()>")
+(getgrgid "#<procedure getgrgid (id)>")
+(getgrnam "#<procedure getgrnam (name)>")
+(getgroups "#<primitive-procedure getgroups>")
+(gethost "#<primitive-procedure gethost>")
+(gethostbyaddr "#<procedure gethostbyaddr (addr)>")
+(gethostbyname "#<procedure gethostbyname (name)>")
+(gethostent "#<procedure gethostent ()>")
+(gethostname "#<primitive-procedure gethostname>")
+(getitimer "#<primitive-procedure getitimer>")
+(getlogin "#<primitive-procedure getlogin>")
+(getnet "#<primitive-procedure getnet>")
+(getnetbyaddr "#<procedure getnetbyaddr (addr)>")
+(getnetbyname "#<procedure getnetbyname (name)>")
+(getnetent "#<procedure getnetent ()>")
+(getpass "#<primitive-procedure getpass>")
+(getpeername "#<primitive-procedure getpeername>")
+(getpgrp "#<primitive-procedure getpgrp>")
+(getpid "#<primitive-procedure getpid>")
+(getppid "#<primitive-procedure getppid>")
+(getpriority "#<primitive-procedure getpriority>")
+(getproto "#<primitive-procedure getproto>")
+(getprotobyname "#<procedure getprotobyname (name)>")
+(getprotobynumber "#<procedure getprotobynumber (addr)>")
+(getprotoent "#<procedure getprotoent ()>")
+(getpw "#<primitive-procedure getpw>")
+(getpwent "#<procedure getpwent ()>")
+(getpwnam "#<procedure getpwnam (name)>")
+(getpwuid "#<procedure getpwuid (uid)>")
+(getserv "#<primitive-procedure getserv>")
+(getservbyname "#<procedure getservbyname (name proto)>")
+(getservbyport "#<procedure getservbyport (port proto)>")
+(getservent "#<procedure getservent ()>")
+(getsockname "#<primitive-procedure getsockname>")
+(getsockopt "#<primitive-procedure getsockopt>")
+(gettimeofday "#<primitive-procedure gettimeofday>")
+(getuid "#<primitive-procedure getuid>")
+(gmtime "#<primitive-procedure gmtime>")
+(group:gid "#<procedure group:gid (obj)>")
+(group:mem "#<procedure group:mem (obj)>")
+(group:name "#<procedure group:name (obj)>")
+(group:passwd "#<procedure group:passwd (obj)>")
+(guardian-destroyed? "#<primitive-procedure guardian-destroyed?>")
+(guardian-greedy? "#<primitive-procedure guardian-greedy?>")
+(handle-system-error "#<procedure handle-system-error (key . args)>")
(has-shown-backtrace-hint? "")
(has-shown-debugger-hint? "")
-(has-suffix? "#<procedure")
-(hash "#<primitive-procedure")
-(hash-create-handle! "#<primitive-procedure")
-(hash-fold "#<primitive-procedure")
-(hash-get-handle "#<primitive-procedure")
-(hash-ref "#<primitive-procedure")
-(hash-remove! "#<primitive-procedure")
-(hash-set! "#<primitive-procedure")
-(hashq "#<primitive-procedure")
-(hashq-create-handle! "#<primitive-procedure")
-(hashq-get-handle "#<primitive-procedure")
-(hashq-ref "#<primitive-procedure")
-(hashq-remove! "#<primitive-procedure")
-(hashq-set! "#<primitive-procedure")
-(hashv "#<primitive-procedure")
-(hashv-create-handle! "#<primitive-procedure")
-(hashv-get-handle "#<primitive-procedure")
-(hashv-ref "#<primitive-procedure")
-(hashv-remove! "#<primitive-procedure")
-(hashv-set! "#<primitive-procedure")
-(hashx-create-handle! "#<primitive-procedure")
-(hashx-get-handle "#<primitive-procedure")
-(hashx-ref "#<primitive-procedure")
-(hashx-set! "#<primitive-procedure")
-(hook->list "#<primitive-procedure")
-(hook-empty? "#<primitive-procedure")
-(hook? "#<primitive-procedure")
-(hostent:addr-list "#<procedure")
-(hostent:addrtype "#<procedure")
-(hostent:aliases "#<procedure")
-(hostent:length "#<procedure")
-(hostent:name "#<procedure")
-(htonl "#<primitive-procedure")
-(htons "#<primitive-procedure")
-(identity "#<procedure")
+(has-suffix? "#<procedure has-suffix? (str suffix)>")
+(hash "#<primitive-procedure hash>")
+(hash-create-handle! "#<primitive-procedure hash-create-handle!>")
+(hash-fold "#<primitive-procedure hash-fold>")
+(hash-get-handle "#<primitive-procedure hash-get-handle>")
+(hash-ref "#<primitive-procedure hash-ref>")
+(hash-remove! "#<primitive-procedure hash-remove!>")
+(hash-set! "#<primitive-procedure hash-set!>")
+(hashq "#<primitive-procedure hashq>")
+(hashq-create-handle! "#<primitive-procedure hashq-create-handle!>")
+(hashq-get-handle "#<primitive-procedure hashq-get-handle>")
+(hashq-ref "#<primitive-procedure hashq-ref>")
+(hashq-remove! "#<primitive-procedure hashq-remove!>")
+(hashq-set! "#<primitive-procedure hashq-set!>")
+(hashv "#<primitive-procedure hashv>")
+(hashv-create-handle! "#<primitive-procedure hashv-create-handle!>")
+(hashv-get-handle "#<primitive-procedure hashv-get-handle>")
+(hashv-ref "#<primitive-procedure hashv-ref>")
+(hashv-remove! "#<primitive-procedure hashv-remove!>")
+(hashv-set! "#<primitive-procedure hashv-set!>")
+(hashx-create-handle! "#<primitive-procedure hashx-create-handle!>")
+(hashx-get-handle "#<primitive-procedure hashx-get-handle>")
+(hashx-ref "#<primitive-procedure hashx-ref>")
+(hashx-set! "#<primitive-procedure hashx-set!>")
+(hook->list "#<primitive-procedure hook->list>")
+(hook-empty? "#<primitive-procedure hook-empty?>")
+(hook? "#<primitive-procedure hook?>")
+(hostent:addr-list "#<procedure hostent:addr-list (obj)>")
+(hostent:addrtype "#<procedure hostent:addrtype (obj)>")
+(hostent:aliases "#<procedure hostent:aliases (obj)>")
+(hostent:length "#<procedure hostent:length (obj)>")
+(hostent:name "#<procedure hostent:name (obj)>")
+(htonl "#<primitive-procedure htonl>")
+(htons "#<primitive-procedure htons>")
+(identity "#<procedure identity (x)>")
(if "")
-(imag-part "#<primitive-procedure")
-(import-environment-imports "#<primitive-procedure")
-(import-environment-set-imports! "#<primitive-procedure")
-(import-environment? "#<primitive-procedure")
-(in-vicinity "#<procedure")
-(include-deprecated-features "#<primitive-procedure")
-(inet-aton "#<primitive-procedure")
-(inet-lnaof "#<primitive-procedure")
-(inet-makeaddr "#<primitive-procedure")
-(inet-netof "#<primitive-procedure")
-(inet-ntoa "#<primitive-procedure")
-(inet-ntop "#<primitive-procedure")
-(inet-pton "#<primitive-procedure")
-(inexact->exact "#<primitive-procedure")
-(inexact? "#<primitive-procedure")
-(inherit-print-state "#<procedure")
-(input-port? "#<primitive-procedure")
-(integer->char "#<primitive-procedure")
-(integer-expt "#<primitive-procedure")
-(integer-length "#<primitive-procedure")
-(integer? "#<primitive-procedure")
-(interaction-environment "#<primitive-procedure")
+(imag-part "#<primitive-procedure imag-part>")
+(import-environment-imports "#<primitive-procedure import-environment-imports>")
+(import-environment-set-imports! "#<primitive-procedure import-environment-set-imports!>")
+(import-environment? "#<primitive-procedure import-environment?>")
+(in-vicinity "#<procedure in-vicinity (vicinity file)>")
+(include-deprecated-features "#<primitive-procedure include-deprecated-features>")
+(inet-aton "#<primitive-procedure inet-aton>")
+(inet-lnaof "#<primitive-procedure inet-lnaof>")
+(inet-makeaddr "#<primitive-procedure inet-makeaddr>")
+(inet-netof "#<primitive-procedure inet-netof>")
+(inet-ntoa "#<primitive-procedure inet-ntoa>")
+(inet-ntop "#<primitive-procedure inet-ntop>")
+(inet-pton "#<primitive-procedure inet-pton>")
+(inexact->exact "#<primitive-procedure inexact->exact>")
+(inexact? "#<primitive-procedure inexact?>")
+(inherit-print-state "#<procedure inherit-print-state (old-port new-port)>")
+(input-port? "#<primitive-procedure input-port?>")
+(integer->char "#<primitive-procedure integer->char>")
+(integer-expt "#<primitive-procedure integer-expt>")
+(integer-length "#<primitive-procedure integer-length>")
+(integer? "#<primitive-procedure integer?>")
+(interaction-environment "#<primitive-procedure interaction-environment>")
(internal-time-units-per-second "")
-(iota "#<procedure")
-(ipow-by-squaring "#<procedure")
-(isatty? "#<primitive-procedure")
-(issue-deprecation-warning "#<primitive-procedure")
-(join-thread "#<primitive-procedure")
-(keyword->symbol "#<procedure")
-(keyword-dash-symbol "#<primitive-procedure")
-(keyword-like-symbol->keyword "#<procedure")
-(keyword? "#<primitive-procedure")
-(kill "#<primitive-procedure")
-(kw-arg-ref "#<procedure")
+(iota "#<procedure iota (n)>")
+(ipow-by-squaring "#<procedure ipow-by-squaring (x k acc proc)>")
+(isatty? "#<primitive-procedure isatty?>")
+(issue-deprecation-warning "#<primitive-procedure issue-deprecation-warning>")
+(join-thread "#<primitive-procedure join-thread>")
+(keyword->symbol "#<procedure keyword->symbol (kw)>")
+(keyword-dash-symbol "#<primitive-procedure keyword-dash-symbol>")
+(keyword-like-symbol->keyword "#<procedure keyword-like-symbol->keyword (sym)>")
+(keyword? "#<primitive-procedure keyword?>")
+(kill "#<primitive-procedure kill>")
+(kw-arg-ref "#<procedure kw-arg-ref (args kw)>")
(lambda "")
-(last-pair "#<primitive-procedure")
-(last-stack-frame "#<primitive-procedure")
-(lazy-catch "#<primitive-procedure")
-(lazy-handler-dispatch "#<procedure")
-(lcm "#<primitive-procedure")
-(leaf-environment? "#<primitive-procedure")
-(length "#<primitive-procedure")
+(last-pair "#<primitive-procedure last-pair>")
+(last-stack-frame "#<primitive-procedure last-stack-frame>")
+(lazy-catch "#<primitive-procedure lazy-catch>")
+(lazy-handler-dispatch "#<procedure lazy-handler-dispatch (key . args)>")
+(lcm "#<primitive-procedure lcm>")
+(leaf-environment? "#<primitive-procedure leaf-environment?>")
+(length "#<primitive-procedure length>")
(let "")
(let* "")
(letrec "")
-(link "#<primitive-procedure")
-(list "#<primitive-procedure")
-(list->array "#<procedure")
-(list->string "#<primitive-procedure")
-(list->symbol "#<procedure")
-(list->uniform-array "#<primitive-procedure")
-(list->uniform-vector "#<procedure")
-(list->vector "#<primitive-procedure")
-(list->weak-vector "#<primitive-procedure")
-(list-cdr-ref "#<primitive-procedure")
-(list-cdr-set! "#<primitive-procedure")
-(list-copy "#<primitive-procedure")
-(list-head "#<primitive-procedure")
-(list-index "#<procedure")
-(list-ref "#<primitive-procedure")
-(list-set! "#<primitive-procedure")
-(list-tail "#<primitive-procedure")
-(list? "#<primitive-procedure")
-(listen "#<primitive-procedure")
-(load "#<procedure")
+(link "#<primitive-procedure link>")
+(list "#<primitive-procedure list>")
+(list->array "#<procedure list->array (ndim lst)>")
+(list->string "#<primitive-procedure list->string>")
+(list->symbol "#<procedure list->symbol args>")
+(list->uniform-array "#<primitive-procedure list->uniform-array>")
+(list->uniform-vector "#<procedure list->uniform-vector (prot lst)>")
+(list->vector "#<primitive-procedure list->vector>")
+(list->weak-vector "#<primitive-procedure list->weak-vector>")
+(list-cdr-ref "#<primitive-procedure list-cdr-ref>")
+(list-cdr-set! "#<primitive-procedure list-cdr-set!>")
+(list-copy "#<primitive-procedure list-copy>")
+(list-head "#<primitive-procedure list-head>")
+(list-index "#<procedure list-index (l k)>")
+(list-ref "#<primitive-procedure list-ref>")
+(list-set! "#<primitive-procedure list-set!>")
+(list-tail "#<primitive-procedure list-tail>")
+(list? "#<primitive-procedure list?>")
+(listen "#<primitive-procedure listen>")
+(load "#<procedure load-module (filename)>")
(load-compiled "")
-(load-emacs-interface "#<procedure")
-(load-extension "#<primitive-procedure")
-(load-from-path "#<procedure")
-(load-module "#<procedure")
-(load-user-init "#<procedure")
-(local-define "#<procedure")
-(local-eval "#<primitive-procedure")
-(local-ref "#<procedure")
-(local-remove "#<procedure")
-(local-set! "#<procedure")
-(localtime "#<primitive-procedure")
-(lock-mutex "#<primitive-procedure")
-(log "#<procedure")
-(log10 "#<procedure")
-(logand "#<primitive-procedure")
-(logbit? "#<primitive-procedure")
-(logcount "#<primitive-procedure")
-(logior "#<primitive-procedure")
-(lognot "#<primitive-procedure")
-(logtest "#<primitive-procedure")
-(logxor "#<primitive-procedure")
-(lstat "#<primitive-procedure")
-(macro-name "#<primitive-procedure")
+(load-emacs-interface "#<procedure load-emacs-interface ()>")
+(load-extension "#<primitive-procedure load-extension>")
+(load-from-path "#<procedure load-from-path (name)>")
+(load-module "#<procedure load-module (filename)>")
+(load-user-init "#<procedure load-user-init ()>")
+(local-define "#<procedure local-define (names val)>")
+(local-eval "#<primitive-procedure local-eval>")
+(local-ref "#<procedure local-ref (names)>")
+(local-remove "#<procedure local-remove (names)>")
+(local-set! "#<procedure local-set! (names val)>")
+(localtime "#<primitive-procedure localtime>")
+(lock-mutex "#<primitive-procedure lock-mutex>")
+(log "#<procedure log (z)>")
+(log10 "#<procedure log10 (arg)>")
+(logand "#<primitive-procedure logand>")
+(logbit? "#<primitive-procedure logbit?>")
+(logcount "#<primitive-procedure logcount>")
+(logior "#<primitive-procedure logior>")
+(lognot "#<primitive-procedure lognot>")
+(logtest "#<primitive-procedure logtest>")
+(logxor "#<primitive-procedure logxor>")
+(lstat "#<primitive-procedure lstat>")
+(macro-name "#<primitive-procedure macro-name>")
(macro-table "")
-(macro-transformer "#<primitive-procedure")
-(macro-type "#<primitive-procedure")
-(macro? "#<primitive-procedure")
-(macroexpand "#<procedure")
-(macroexpand-1 "#<procedure")
-(magnitude "#<primitive-procedure")
-(major-version "#<primitive-procedure")
-(make-arbiter "#<primitive-procedure")
-(make-array "#<procedure")
-(make-autoload-interface "#<procedure")
-(make-class-object "#<primitive-procedure")
-(make-condition-variable "#<primitive-procedure")
-(make-doubly-weak-hash-table "#<primitive-procedure")
-(make-eval-environment "#<primitive-procedure")
-(make-export-environment "#<primitive-procedure")
-(make-fluid "#<primitive-procedure")
-(make-guardian "#<primitive-procedure")
-(make-hash-table "#<procedure")
-(make-hook "#<primitive-procedure")
-(make-import-environment "#<primitive-procedure")
-(make-keyword-from-dash-symbol "#<primitive-procedure")
-(make-leaf-environment "#<primitive-procedure")
-(make-list "#<procedure")
-(make-module "#<procedure")
-(make-modules-in "#<procedure")
-(make-mutex "#<primitive-procedure")
-(make-object-property "#<procedure")
-(make-polar "#<primitive-procedure")
-(make-procedure-with-setter "#<primitive-procedure")
-(make-record-type "#<procedure")
-(make-rectangular "#<primitive-procedure")
-(make-regexp "#<primitive-procedure")
-(make-root-module "#<procedure")
-(make-scm-module "#<procedure")
-(make-shared-array "#<primitive-procedure")
-(make-soft-port "#<primitive-procedure")
-(make-stack "#<primitive-procedure")
-(make-string "#<primitive-procedure")
-(make-struct "#<primitive-procedure")
-(make-struct-layout "#<primitive-procedure")
-(make-subclass-object "#<primitive-procedure")
-(make-symbol "#<primitive-procedure")
-(make-undefined-variable "#<primitive-procedure")
-(make-uniform-array "#<procedure")
-(make-uniform-vector "#<primitive-procedure")
-(make-variable "#<primitive-procedure")
-(make-vector "#<primitive-procedure")
-(make-vtable-vtable "#<primitive-procedure")
-(make-weak-key-hash-table "#<primitive-procedure")
-(make-weak-value-hash-table "#<primitive-procedure")
-(make-weak-vector "#<primitive-procedure")
-(map "#<primitive-procedure")
-(map-in-order "#<primitive-procedure")
-(mask-signals "#<primitive-procedure")
-(max "#<primitive-procedure")
-(member "#<primitive-procedure")
-(memoized-environment "#<primitive-procedure")
-(memoized? "#<primitive-procedure")
-(memq "#<primitive-procedure")
-(memv "#<primitive-procedure")
-(merge "#<primitive-procedure")
-(merge! "#<primitive-procedure")
-(micro-version "#<primitive-procedure")
-(min "#<primitive-procedure")
-(minor-version "#<primitive-procedure")
-(mkdir "#<primitive-procedure")
-(mknod "#<primitive-procedure")
-(mkstemp! "#<primitive-procedure")
-(mktime "#<primitive-procedure")
-(module-add! "#<procedure")
-(module-binder "#<procedure")
-(module-bound? "#<procedure")
-(module-clear! "#<procedure")
-(module-constructor "#<procedure")
-(module-define! "#<procedure")
-(module-defined? "#<procedure")
-(module-ensure-local-variable! "#<procedure")
-(module-eval-closure "#<procedure")
-(module-export! "#<procedure")
-(module-for-each "#<procedure")
-(module-kind "#<procedure")
-(module-local-variable "#<procedure")
-(module-locally-bound? "#<procedure")
-(module-make-local-var! "#<procedure")
-(module-map "#<procedure")
-(module-modified "#<procedure")
-(module-name "#<procedure")
-(module-obarray "#<procedure")
-(module-obarray-get-handle "#<procedure")
-(module-obarray-ref "#<procedure")
-(module-obarray-remove! "#<procedure")
-(module-obarray-set! "#<procedure")
-(module-observe "#<procedure")
-(module-observe-weak "#<procedure")
-(module-observer-id "#<procedure")
-(module-observers "#<procedure")
-(module-public-interface "#<procedure")
-(module-re-export! "#<procedure")
-(module-ref "#<procedure")
-(module-remove! "#<procedure")
-(module-search "#<procedure")
-(module-set! "#<procedure")
-(module-symbol-binding "#<procedure")
-(module-symbol-interned? "#<procedure")
-(module-symbol-local-binding "#<procedure")
-(module-symbol-locally-interned? "#<procedure")
-(module-transformer "#<procedure")
+(macro-transformer "#<primitive-procedure macro-transformer>")
+(macro-type "#<primitive-procedure macro-type>")
+(macro? "#<primitive-procedure macro?>")
+(macroexpand "#<procedure macroexpand (e)>")
+(macroexpand-1 "#<procedure macroexpand-1 (e)>")
+(magnitude "#<primitive-procedure magnitude>")
+(major-version "#<primitive-procedure major-version>")
+(make-arbiter "#<primitive-procedure make-arbiter>")
+(make-array "#<procedure make-array (fill . args)>")
+(make-autoload-interface "#<procedure make-autoload-interface (module name bindings)>")
+(make-class-object "#<primitive-procedure make-class-object>")
+(make-condition-variable "#<primitive-procedure make-condition-variable>")
+(make-doubly-weak-hash-table "#<primitive-procedure make-doubly-weak-hash-table>")
+(make-eval-environment "#<primitive-procedure make-eval-environment>")
+(make-export-environment "#<primitive-procedure make-export-environment>")
+(make-fluid "#<primitive-procedure make-fluid>")
+(make-guardian "#<primitive-procedure make-guardian>")
+(make-hash-table "#<procedure make-hash-table (k)>")
+(make-hook "#<primitive-procedure make-hook>")
+(make-import-environment "#<primitive-procedure make-import-environment>")
+(make-keyword-from-dash-symbol "#<primitive-procedure make-keyword-from-dash-symbol>")
+(make-leaf-environment "#<primitive-procedure make-leaf-environment>")
+(make-list "#<procedure make-list (n . init)>")
+(make-module "#<procedure make-module args>")
+(make-modules-in "#<procedure make-modules-in (module name)>")
+(make-mutex "#<primitive-procedure make-mutex>")
+(make-object-property "#<procedure make-object-property ()>")
+(make-polar "#<primitive-procedure make-polar>")
+(make-procedure-with-setter "#<primitive-procedure make-procedure-with-setter>")
+(make-record-type "#<procedure make-record-type (type-name fields . opt)>")
+(make-rectangular "#<primitive-procedure make-rectangular>")
+(make-regexp "#<primitive-procedure make-regexp>")
+(make-root-module "#<procedure make-root-module ()>")
+(make-scm-module "#<procedure make-scm-module ()>")
+(make-shared-array "#<primitive-procedure make-shared-array>")
+(make-soft-port "#<primitive-procedure make-soft-port>")
+(make-stack "#<primitive-procedure make-stack>")
+(make-string "#<primitive-procedure make-string>")
+(make-struct "#<primitive-procedure make-struct>")
+(make-struct-layout "#<primitive-procedure make-struct-layout>")
+(make-subclass-object "#<primitive-procedure make-subclass-object>")
+(make-symbol "#<primitive-procedure make-symbol>")
+(make-undefined-variable "#<primitive-procedure make-undefined-variable>")
+(make-uniform-array "#<procedure make-uniform-array (prot . args)>")
+(make-uniform-vector "#<primitive-procedure dimensions->uniform-array>")
+(make-variable "#<primitive-procedure make-variable>")
+(make-vector "#<primitive-procedure make-vector>")
+(make-vtable-vtable "#<primitive-procedure make-vtable-vtable>")
+(make-weak-key-hash-table "#<primitive-procedure make-weak-key-hash-table>")
+(make-weak-value-hash-table "#<primitive-procedure make-weak-value-hash-table>")
+(make-weak-vector "#<primitive-procedure make-weak-vector>")
+(map "#<primitive-procedure map>")
+(map-in-order "#<primitive-procedure map-in-order>")
+(mask-signals "#<primitive-procedure mask-signals>")
+(max "#<primitive-procedure max>")
+(member "#<primitive-procedure member>")
+(memoized-environment "#<primitive-procedure memoized-environment>")
+(memoized? "#<primitive-procedure memoized?>")
+(memq "#<primitive-procedure memq>")
+(memv "#<primitive-procedure memv>")
+(merge "#<primitive-procedure merge>")
+(merge! "#<primitive-procedure merge!>")
+(micro-version "#<primitive-procedure micro-version>")
+(min "#<primitive-procedure min>")
+(minor-version "#<primitive-procedure minor-version>")
+(mkdir "#<primitive-procedure mkdir>")
+(mknod "#<primitive-procedure mknod>")
+(mkstemp! "#<primitive-procedure mkstemp!>")
+(mktime "#<primitive-procedure mktime>")
+(module-add! "#<procedure module-add! (m v var)>")
+(module-binder "#<procedure module-binder (obj)>")
+(module-bound? "#<procedure module-bound? (m v)>")
+(module-clear! "#<procedure module-clear! (m)>")
+(module-constructor "#<procedure module-constructor (obarray uses binder eval-closure transformer name kind observers weak-observers observer-id)>")
+(module-define! "#<procedure module-define! (module name value)>")
+(module-defined? "#<procedure module-defined? (module name)>")
+(module-ensure-local-variable! "#<procedure module-ensure-local-variable! (module symbol)>")
+(module-eval-closure "#<procedure module-eval-closure (obj)>")
+(module-export! "#<procedure module-export! (m names)>")
+(module-for-each "#<procedure module-for-each (proc module)>")
+(module-kind "#<procedure module-kind (obj)>")
+(module-local-variable "#<procedure module-local-variable (m v)>")
+(module-locally-bound? "#<procedure module-locally-bound? (m v)>")
+(module-make-local-var! "#<procedure module-make-local-var! (m v)>")
+(module-map "#<procedure module-map (proc module)>")
+(module-modified "#<procedure module-modified (m)>")
+(module-name "#<procedure module-name (obj)>")
+(module-obarray "#<procedure module-obarray (obj)>")
+(module-obarray-get-handle "#<procedure module-obarray-get-handle (ob key)>")
+(module-obarray-ref "#<procedure module-obarray-ref (ob key)>")
+(module-obarray-remove! "#<procedure module-obarray-remove! (ob key)>")
+(module-obarray-set! "#<procedure module-obarray-set! (ob key val)>")
+(module-observe "#<procedure module-observe (module proc)>")
+(module-observe-weak "#<procedure module-observe-weak (module proc)>")
+(module-observer-id "#<procedure module-observer-id (obj)>")
+(module-observers "#<procedure module-observers (obj)>")
+(module-public-interface "#<procedure module-public-interface (m)>")
+(module-re-export! "#<procedure module-re-export! (m names)>")
+(module-ref "#<procedure module-ref (module name . rest)>")
+(module-remove! "#<procedure module-remove! (m v)>")
+(module-search "#<procedure module-search (fn m v)>")
+(module-set! "#<procedure module-set! (module name value)>")
+(module-symbol-binding "#<procedure module-symbol-binding (m v . opt-val)>")
+(module-symbol-interned? "#<procedure module-symbol-interned? (m v)>")
+(module-symbol-local-binding "#<procedure module-symbol-local-binding (m v . opt-val)>")
+(module-symbol-locally-interned? "#<procedure module-symbol-locally-interned? (m v)>")
+(module-transformer "#<procedure module-transformer (obj)>")
(module-type "")
-(module-unobserve "#<procedure")
-(module-use! "#<procedure")
-(module-uses "#<procedure")
-(module-variable "#<procedure")
-(module-weak-observers "#<procedure")
-(module? "#<procedure")
-(modulo "#<primitive-procedure")
+(module-unobserve "#<procedure module-unobserve (token)>")
+(module-use! "#<procedure module-use! (module interface)>")
+(module-uses "#<procedure module-uses (obj)>")
+(module-variable "#<procedure module-variable (m v)>")
+(module-weak-observers "#<procedure module-weak-observers (obj)>")
+(module? "#<procedure module? (obj)>")
+(modulo "#<primitive-procedure modulo>")
(most-negative-fixnum "")
(most-positive-fixnum "")
-(move->fdes "#<procedure")
-(named-module-use! "#<procedure")
-(negative? "#<primitive-procedure")
-(nested-define! "#<procedure")
-(nested-ref "#<procedure")
-(nested-remove! "#<procedure")
-(nested-set! "#<procedure")
-(netent:addrtype "#<procedure")
-(netent:aliases "#<procedure")
-(netent:name "#<procedure")
-(netent:net "#<procedure")
-(newline "#<primitive-procedure")
-(nice "#<primitive-procedure")
+(move->fdes "#<procedure move->fdes (fd/port fd)>")
+(named-module-use! "#<procedure named-module-use! (user usee)>")
+(negative? "#<primitive-procedure negative?>")
+(nested-define! "#<procedure nested-define! (root names val)>")
+(nested-ref "#<procedure nested-ref (root names)>")
+(nested-remove! "#<procedure nested-remove! (root names)>")
+(nested-set! "#<procedure nested-set! (root names val)>")
+(netent:addrtype "#<procedure netent:addrtype (obj)>")
+(netent:aliases "#<procedure netent:aliases (obj)>")
+(netent:name "#<procedure netent:name (obj)>")
+(netent:net "#<procedure netent:net (obj)>")
+(newline "#<primitive-procedure newline>")
+(nice "#<primitive-procedure nice>")
(nil-cond "")
-(noop "#<primitive-procedure")
-(not "#<primitive-procedure")
-(ntohl "#<primitive-procedure")
-(ntohs "#<primitive-procedure")
-(null? "#<primitive-procedure")
-(number->string "#<primitive-procedure")
-(number? "#<primitive-procedure")
-(object->string "#<primitive-procedure")
-(object-address "#<primitive-procedure")
-(object-properties "#<primitive-procedure")
-(object-property "#<primitive-procedure")
-(odd? "#<primitive-procedure")
-(open "#<primitive-procedure")
-(open-fdes "#<primitive-procedure")
-(open-file "#<primitive-procedure")
-(open-input-file "#<procedure")
-(open-input-string "#<primitive-procedure")
-(open-io-file "#<procedure")
-(open-output-file "#<procedure")
-(open-output-string "#<primitive-procedure")
-(opendir "#<primitive-procedure")
-(operator? "#<primitive-procedure")
+(noop "#<primitive-procedure noop>")
+(not "#<primitive-procedure not>")
+(ntohl "#<primitive-procedure ntohl>")
+(ntohs "#<primitive-procedure ntohs>")
+(null? "#<primitive-procedure null?>")
+(number->string "#<primitive-procedure number->string>")
+(number? "#<primitive-procedure number?>")
+(object->string "#<primitive-procedure object->string>")
+(object-address "#<primitive-procedure object-address>")
+(object-properties "#<primitive-procedure object-properties>")
+(object-property "#<primitive-procedure object-property>")
+(odd? "#<primitive-procedure odd?>")
+(open "#<primitive-procedure open>")
+(open-fdes "#<primitive-procedure open-fdes>")
+(open-file "#<primitive-procedure open-file>")
+(open-input-file "#<procedure open-input-file (str)>")
+(open-input-string "#<primitive-procedure open-input-string>")
+(open-io-file "#<procedure open-io-file (str)>")
+(open-output-file "#<procedure open-output-file (str)>")
+(open-output-string "#<primitive-procedure open-output-string>")
+(opendir "#<primitive-procedure opendir>")
+(operator? "#<primitive-procedure operator?>")
(or "")
-(or-map "#<procedure")
-(output-port? "#<primitive-procedure")
-(pair? "#<primitive-procedure")
-(parse-path "#<primitive-procedure")
-(passwd:dir "#<procedure")
-(passwd:gecos "#<procedure")
-(passwd:gid "#<procedure")
-(passwd:name "#<procedure")
-(passwd:passwd "#<procedure")
-(passwd:shell "#<procedure")
-(passwd:uid "#<procedure")
-(pause "#<primitive-procedure")
-(peek "#<procedure")
-(peek-char "#<primitive-procedure")
-(pipe "#<primitive-procedure")
-(pk "#<procedure")
-(port->fdes "#<procedure")
-(port-closed? "#<primitive-procedure")
-(port-column "#<primitive-procedure")
-(port-filename "#<primitive-procedure")
-(port-for-each "#<primitive-procedure")
-(port-line "#<primitive-procedure")
-(port-mode "#<primitive-procedure")
-(port-revealed "#<primitive-procedure")
-(port-with-print-state "#<primitive-procedure")
-(port? "#<primitive-procedure")
-(positive? "#<primitive-procedure")
-(primitive-eval "#<primitive-procedure")
-(primitive-exit "#<primitive-procedure")
-(primitive-fork "#<primitive-procedure")
-(primitive-load "#<primitive-procedure")
-(primitive-load-path "#<primitive-procedure")
-(primitive-macro? "#<procedure")
-(primitive-make-property "#<primitive-procedure")
-(primitive-move->fdes "#<primitive-procedure")
-(primitive-property-del! "#<primitive-procedure")
-(primitive-property-ref "#<primitive-procedure")
-(primitive-property-set! "#<primitive-procedure")
-(print-disable "#<procedure")
-(print-enable "#<procedure")
-(print-options "#<procedure")
-(print-options-interface "#<primitive-procedure")
+(or-map "#<procedure or-map (f lst)>")
+(output-port? "#<primitive-procedure output-port?>")
+(pair? "#<primitive-procedure pair?>")
+(parse-path "#<primitive-procedure parse-path>")
+(passwd:dir "#<procedure passwd:dir (obj)>")
+(passwd:gecos "#<procedure passwd:gecos (obj)>")
+(passwd:gid "#<procedure passwd:gid (obj)>")
+(passwd:name "#<procedure passwd:name (obj)>")
+(passwd:passwd "#<procedure passwd:passwd (obj)>")
+(passwd:shell "#<procedure passwd:shell (obj)>")
+(passwd:uid "#<procedure passwd:uid (obj)>")
+(pause "#<primitive-procedure pause>")
+(peek "#<procedure peek stuff>")
+(peek-char "#<primitive-procedure peek-char>")
+(pipe "#<primitive-procedure pipe>")
+(pk "#<procedure peek stuff>")
+(port->fdes "#<procedure port->fdes (port)>")
+(port-closed? "#<primitive-procedure port-closed?>")
+(port-column "#<primitive-procedure port-column>")
+(port-filename "#<primitive-procedure port-filename>")
+(port-for-each "#<primitive-procedure port-for-each>")
+(port-line "#<primitive-procedure port-line>")
+(port-mode "#<primitive-procedure port-mode>")
+(port-revealed "#<primitive-procedure port-revealed>")
+(port-with-print-state "#<primitive-procedure port-with-print-state>")
+(port? "#<primitive-procedure port?>")
+(positive? "#<primitive-procedure positive?>")
+(primitive-eval "#<primitive-procedure primitive-eval>")
+(primitive-exit "#<primitive-procedure primitive-exit>")
+(primitive-fork "#<primitive-procedure primitive-fork>")
+(primitive-load "#<primitive-procedure primitive-load>")
+(primitive-load-path "#<primitive-procedure primitive-load-path>")
+(primitive-macro? "#<procedure primitive-macro? (m)>")
+(primitive-make-property "#<primitive-procedure primitive-make-property>")
+(primitive-move->fdes "#<primitive-procedure primitive-move->fdes>")
+(primitive-property-del! "#<primitive-procedure primitive-property-del!>")
+(primitive-property-ref "#<primitive-procedure primitive-property-ref>")
+(primitive-property-set! "#<primitive-procedure primitive-property-set!>")
+(print-disable "#<procedure print-disable flags>")
+(print-enable "#<procedure print-enable flags>")
+(print-options "#<procedure print-options args>")
+(print-options-interface "#<primitive-procedure print-options-interface>")
(print-set! "")
-(procedure "#<primitive-procedure")
-(procedure->macro "#<primitive-procedure")
-(procedure->memoizing-macro "#<primitive-procedure")
-(procedure->syntax "#<primitive-procedure")
-(procedure-documentation "#<primitive-procedure")
-(procedure-environment "#<primitive-procedure")
-(procedure-name "#<primitive-procedure")
-(procedure-properties "#<primitive-procedure")
-(procedure-property "#<primitive-procedure")
-(procedure-source "#<primitive-procedure")
-(procedure-with-setter? "#<primitive-procedure")
-(procedure? "#<primitive-procedure")
-(process-define-module "#<procedure")
-(process-use-modules "#<procedure")
-(program-arguments "#<primitive-procedure")
-(promise? "#<primitive-procedure")
-(protoent:aliases "#<procedure")
-(protoent:name "#<procedure")
-(protoent:proto "#<procedure")
-(provide "#<procedure")
-(provided? "#<procedure")
-(purify-module! "#<procedure")
-(putenv "#<primitive-procedure")
+(procedure "#<primitive-procedure procedure>")
+(procedure->macro "#<primitive-procedure procedure->macro>")
+(procedure->memoizing-macro "#<primitive-procedure procedure->memoizing-macro>")
+(procedure->syntax "#<primitive-procedure procedure->syntax>")
+(procedure-documentation "#<primitive-procedure procedure-documentation>")
+(procedure-environment "#<primitive-procedure procedure-environment>")
+(procedure-name "#<primitive-procedure procedure-name>")
+(procedure-properties "#<primitive-procedure procedure-properties>")
+(procedure-property "#<primitive-procedure procedure-property>")
+(procedure-source "#<primitive-procedure procedure-source>")
+(procedure-with-setter? "#<primitive-procedure procedure-with-setter?>")
+(procedure? "#<primitive-procedure procedure?>")
+(process-define-module "#<procedure process-define-module (args)>")
+(process-use-modules "#<procedure process-use-modules (module-interface-args)>")
+(program-arguments "#<primitive-procedure program-arguments>")
+(promise? "#<primitive-procedure promise?>")
+(protoent:aliases "#<procedure protoent:aliases (obj)>")
+(protoent:name "#<procedure protoent:name (obj)>")
+(protoent:proto "#<procedure protoent:proto (obj)>")
+(provide "#<procedure provide (sym)>")
+(provided? "#<procedure provided? (feature)>")
+(purify-module! "#<procedure purify-module! (module)>")
+(putenv "#<primitive-procedure putenv>")
(quasiquote "")
-(quit "#<procedure")
+(quit "#<procedure quit args>")
(quote "")
-(quotient "#<primitive-procedure")
-(raise "#<primitive-procedure")
-(random "#<primitive-procedure")
-(random:exp "#<primitive-procedure")
-(random:hollow-sphere! "#<primitive-procedure")
-(random:normal "#<primitive-procedure")
-(random:normal-vector! "#<primitive-procedure")
-(random:solid-sphere! "#<primitive-procedure")
-(random:uniform "#<primitive-procedure")
-(rational? "#<primitive-procedure")
+(quotient "#<primitive-procedure quotient>")
+(raise "#<primitive-procedure raise>")
+(random "#<primitive-procedure random>")
+(random:exp "#<primitive-procedure random:exp>")
+(random:hollow-sphere! "#<primitive-procedure random:hollow-sphere!>")
+(random:normal "#<primitive-procedure random:normal>")
+(random:normal-vector! "#<primitive-procedure random:normal-vector!>")
+(random:solid-sphere! "#<primitive-procedure random:solid-sphere!>")
+(random:uniform "#<primitive-procedure random:uniform>")
+(rational? "#<primitive-procedure rational?>")
(re-export "")
(re-export-syntax "")
-(read "#<primitive-procedure")
-(read-char "#<primitive-procedure")
-(read-disable "#<procedure")
-(read-enable "#<procedure")
+(read "#<primitive-procedure read>")
+(read-char "#<primitive-procedure read-char>")
+(read-disable "#<procedure read-disable flags>")
+(read-enable "#<procedure read-enable flags>")
(read-eval? "")
-(read-hash-extend "#<primitive-procedure")
+(read-hash-extend "#<primitive-procedure read-hash-extend>")
(read-hash-procedures "")
-(read-options "#<procedure")
-(read-options-interface "#<primitive-procedure")
+(read-options "#<procedure read-options args>")
+(read-options-interface "#<primitive-procedure read-options-interface>")
(read-set! "")
-(read:array "#<procedure")
-(read:uniform-vector "#<procedure")
-(readdir "#<primitive-procedure")
-(readlink "#<primitive-procedure")
-(real-part "#<primitive-procedure")
-(real? "#<primitive-procedure")
-(record-accessor "#<procedure")
-(record-constructor "#<procedure")
-(record-modifier "#<procedure")
-(record-predicate "#<procedure")
-(record-type-descriptor "#<procedure")
-(record-type-fields "#<procedure")
-(record-type-name "#<procedure")
+(read:array "#<procedure read:array (digit port)>")
+(read:uniform-vector "#<procedure read:uniform-vector (proto port)>")
+(readdir "#<primitive-procedure readdir>")
+(readlink "#<primitive-procedure readlink>")
+(real-part "#<primitive-procedure real-part>")
+(real? "#<primitive-procedure real?>")
+(record-accessor "#<procedure record-accessor (rtd field-name)>")
+(record-constructor "#<procedure record-constructor (rtd . opt)>")
+(record-modifier "#<procedure record-modifier (rtd field-name)>")
+(record-predicate "#<procedure record-predicate (rtd)>")
+(record-type-descriptor "#<procedure record-type-descriptor (obj)>")
+(record-type-fields "#<procedure record-type-fields (obj)>")
+(record-type-name "#<procedure record-type-name (obj)>")
(record-type-vtable "")
-(record-type? "#<procedure")
-(record? "#<procedure")
-(recv! "#<primitive-procedure")
-(recvfrom! "#<primitive-procedure")
-(redirect-port "#<primitive-procedure")
-(regexp-exec "#<primitive-procedure")
+(record-type? "#<procedure record-type? (obj)>")
+(record? "#<procedure record? (obj)>")
+(recv! "#<primitive-procedure recv!>")
+(recvfrom! "#<primitive-procedure recvfrom!>")
+(redirect-port "#<primitive-procedure redirect-port>")
+(regexp-exec "#<primitive-procedure regexp-exec>")
(regexp/basic "")
(regexp/extended "")
(regexp/icase "")
(regexp/newline "")
(regexp/notbol "")
(regexp/noteol "")
-(regexp? "#<primitive-procedure")
-(release-arbiter "#<primitive-procedure")
-(release-port-handle "#<procedure")
-(remainder "#<primitive-procedure")
-(remove-hook! "#<primitive-procedure")
-(rename-file "#<primitive-procedure")
-(repl "#<procedure")
-(repl-reader "#<procedure")
-(reset-hook! "#<primitive-procedure")
-(resolve-interface "#<procedure")
-(resolve-module "#<procedure")
-(restore-signals "#<primitive-procedure")
-(restricted-vector-sort! "#<primitive-procedure")
-(reverse "#<primitive-procedure")
-(reverse! "#<primitive-procedure")
-(rewinddir "#<primitive-procedure")
-(rmdir "#<primitive-procedure")
-(round "#<primitive-procedure")
-(run-asyncs "#<primitive-procedure")
-(run-hook "#<primitive-procedure")
-(save-module-excursion "#<procedure")
-(save-stack "#<procedure")
-(scheme-file-suffix "#<procedure")
-(scm-error "#<primitive-procedure")
+(regexp? "#<primitive-procedure regexp?>")
+(release-arbiter "#<primitive-procedure release-arbiter>")
+(release-port-handle "#<procedure release-port-handle (port)>")
+(remainder "#<primitive-procedure remainder>")
+(remove-hook! "#<primitive-procedure remove-hook!>")
+(rename-file "#<primitive-procedure rename-file>")
+(repl "#<procedure repl (read evaler print)>")
+(repl-reader "#<procedure repl-reader (prompt)>")
+(reset-hook! "#<primitive-procedure reset-hook!>")
+(resolve-interface "#<procedure resolve-interface (name . args)>")
+(resolve-module "#<procedure resolve-module (name . maybe-autoload)>")
+(restore-signals "#<primitive-procedure restore-signals>")
+(restricted-vector-sort! "#<primitive-procedure restricted-vector-sort!>")
+(reverse "#<primitive-procedure reverse>")
+(reverse! "#<primitive-procedure reverse!>")
+(rewinddir "#<primitive-procedure rewinddir>")
+(rmdir "#<primitive-procedure rmdir>")
+(round "#<primitive-procedure round>")
+(run-asyncs "#<primitive-procedure run-asyncs>")
+(run-hook "#<primitive-procedure run-hook>")
+(save-module-excursion "#<procedure save-module-excursion (thunk)>")
+(save-stack "#<procedure save-stack narrowing>")
+(scheme-file-suffix "#<procedure scheme-file-suffix ()>")
+(scm-error "#<primitive-procedure scm-error>")
(scm-repl-print-unspecified "")
(scm-repl-prompt "")
(scm-repl-silent "")
(scm-repl-verbose "")
-(scm-style-repl "#<procedure")
-(search-path "#<primitive-procedure")
-(seed->random-state "#<primitive-procedure")
-(seek "#<primitive-procedure")
-(select "#<primitive-procedure")
-(send "#<primitive-procedure")
-(sendto "#<primitive-procedure")
-(servent:aliases "#<procedure")
-(servent:name "#<procedure")
-(servent:port "#<procedure")
-(servent:proto "#<procedure")
+(scm-style-repl "#<procedure scm-style-repl ()>")
+(search-path "#<primitive-procedure search-path>")
+(seed->random-state "#<primitive-procedure seed->random-state>")
+(seek "#<primitive-procedure seek>")
+(select "#<primitive-procedure select>")
+(send "#<primitive-procedure send>")
+(sendto "#<primitive-procedure sendto>")
+(servent:aliases "#<procedure servent:aliases (obj)>")
+(servent:name "#<procedure servent:name (obj)>")
+(servent:port "#<procedure servent:port (obj)>")
+(servent:proto "#<procedure servent:proto (obj)>")
(set! "")
-(set-autoloaded! "#<procedure")
-(set-batch-mode?! "#<procedure")
-(set-car! "#<primitive-procedure")
-(set-cdr! "#<primitive-procedure")
-(set-current-error-port "#<primitive-procedure")
-(set-current-input-port "#<primitive-procedure")
-(set-current-module "#<primitive-procedure")
-(set-current-output-port "#<primitive-procedure")
-(set-defmacro-transformer! "#<procedure")
-(set-module-binder! "#<procedure")
-(set-module-eval-closure! "#<procedure")
-(set-module-kind! "#<procedure")
-(set-module-name! "#<procedure")
-(set-module-obarray! "#<procedure")
-(set-module-observer-id! "#<procedure")
-(set-module-observers! "#<procedure")
-(set-module-public-interface! "#<procedure")
-(set-module-transformer! "#<procedure")
-(set-module-uses! "#<procedure")
-(set-object-procedure! "#<primitive-procedure")
-(set-object-properties! "#<primitive-procedure")
-(set-object-property! "#<primitive-procedure")
-(set-port-column! "#<primitive-procedure")
-(set-port-filename! "#<primitive-procedure")
-(set-port-line! "#<primitive-procedure")
-(set-port-revealed! "#<primitive-procedure")
-(set-procedure-properties! "#<primitive-procedure")
-(set-procedure-property! "#<primitive-procedure")
-(set-repl-prompt! "#<procedure")
-(set-source-properties! "#<primitive-procedure")
-(set-source-property! "#<primitive-procedure")
-(set-struct-vtable-name! "#<primitive-procedure")
-(set-symbol-property! "#<procedure")
-(set-system-module! "#<procedure")
-(set-tm:gmtoff "#<procedure")
-(set-tm:hour "#<procedure")
-(set-tm:isdst "#<procedure")
-(set-tm:mday "#<procedure")
-(set-tm:min "#<procedure")
-(set-tm:mon "#<procedure")
-(set-tm:sec "#<procedure")
-(set-tm:wday "#<procedure")
-(set-tm:yday "#<procedure")
-(set-tm:year "#<procedure")
-(set-tm:zone "#<procedure")
-(setegid "#<primitive-procedure")
-(setenv "#<procedure")
-(seteuid "#<primitive-procedure")
-(setgid "#<primitive-procedure")
-(setgr "#<primitive-procedure")
-(setgrent "#<procedure")
-(sethost "#<primitive-procedure")
-(sethostent "#<procedure")
-(sethostname "#<primitive-procedure")
-(setitimer "#<primitive-procedure")
-(setlocale "#<primitive-procedure")
-(setnet "#<primitive-procedure")
-(setnetent "#<procedure")
-(setpgid "#<primitive-procedure")
-(setpriority "#<primitive-procedure")
-(setproto "#<primitive-procedure")
-(setprotoent "#<procedure")
-(setpw "#<primitive-procedure")
-(setpwent "#<procedure")
-(setserv "#<primitive-procedure")
-(setservent "#<procedure")
-(setsid "#<primitive-procedure")
-(setsockopt "#<primitive-procedure")
-(setter "#<primitive-procedure")
-(setuid "#<primitive-procedure")
-(setvbuf "#<primitive-procedure")
-(shared-array-increments "#<primitive-procedure")
-(shared-array-offset "#<primitive-procedure")
-(shared-array-root "#<primitive-procedure")
-(shutdown "#<primitive-procedure")
-(sigaction "#<primitive-procedure")
-(signal-condition-variable "#<primitive-procedure")
+(set-autoloaded! "#<procedure set-autoloaded! (p m done?)>")
+(set-batch-mode?! "#<procedure set-batch-mode?! (arg)>")
+(set-car! "#<primitive-procedure set-car!>")
+(set-cdr! "#<primitive-procedure set-cdr!>")
+(set-current-error-port "#<primitive-procedure set-current-error-port>")
+(set-current-input-port "#<primitive-procedure set-current-input-port>")
+(set-current-module "#<primitive-procedure set-current-module>")
+(set-current-output-port "#<primitive-procedure set-current-output-port>")
+(set-defmacro-transformer! "#<procedure set-defmacro-transformer! (m t)>")
+(set-module-binder! "#<procedure set-module-binder! (obj val)>")
+(set-module-eval-closure! "#<procedure set-module-eval-closure! (module closure)>")
+(set-module-kind! "#<procedure set-module-kind! (obj val)>")
+(set-module-name! "#<procedure set-module-name! (obj val)>")
+(set-module-obarray! "#<procedure set-module-obarray! (obj val)>")
+(set-module-observer-id! "#<procedure set-module-observer-id! (obj val)>")
+(set-module-observers! "#<procedure set-module-observers! (obj val)>")
+(set-module-public-interface! "#<procedure set-module-public-interface! (m i)>")
+(set-module-transformer! "#<procedure set-module-transformer! (obj val)>")
+(set-module-uses! "#<procedure set-module-uses! (obj val)>")
+(set-object-procedure! "#<primitive-procedure set-object-procedure!>")
+(set-object-properties! "#<primitive-procedure set-object-properties!>")
+(set-object-property! "#<primitive-procedure set-object-property!>")
+(set-port-column! "#<primitive-procedure set-port-column!>")
+(set-port-filename! "#<primitive-procedure set-port-filename!>")
+(set-port-line! "#<primitive-procedure set-port-line!>")
+(set-port-revealed! "#<primitive-procedure set-port-revealed!>")
+(set-procedure-properties! "#<primitive-procedure set-procedure-properties!>")
+(set-procedure-property! "#<primitive-procedure set-procedure-property!>")
+(set-repl-prompt! "#<procedure set-repl-prompt! (v)>")
+(set-source-properties! "#<primitive-procedure set-source-properties!>")
+(set-source-property! "#<primitive-procedure set-source-property!>")
+(set-struct-vtable-name! "#<primitive-procedure set-struct-vtable-name!>")
+(set-symbol-property! "#<procedure set-symbol-property! (sym prop val)>")
+(set-system-module! "#<procedure set-system-module! (m s)>")
+(set-tm:gmtoff "#<procedure set-tm:gmtoff (obj val)>")
+(set-tm:hour "#<procedure set-tm:hour (obj val)>")
+(set-tm:isdst "#<procedure set-tm:isdst (obj val)>")
+(set-tm:mday "#<procedure set-tm:mday (obj val)>")
+(set-tm:min "#<procedure set-tm:min (obj val)>")
+(set-tm:mon "#<procedure set-tm:mon (obj val)>")
+(set-tm:sec "#<procedure set-tm:sec (obj val)>")
+(set-tm:wday "#<procedure set-tm:wday (obj val)>")
+(set-tm:yday "#<procedure set-tm:yday (obj val)>")
+(set-tm:year "#<procedure set-tm:year (obj val)>")
+(set-tm:zone "#<procedure set-tm:zone (obj val)>")
+(setegid "#<primitive-procedure setegid>")
+(setenv "#<procedure setenv (name value)>")
+(seteuid "#<primitive-procedure seteuid>")
+(setgid "#<primitive-procedure setgid>")
+(setgr "#<primitive-procedure setgr>")
+(setgrent "#<procedure setgrent ()>")
+(sethost "#<primitive-procedure sethost>")
+(sethostent "#<procedure sethostent stayopen>")
+(sethostname "#<primitive-procedure sethostname>")
+(setitimer "#<primitive-procedure setitimer>")
+(setlocale "#<primitive-procedure setlocale>")
+(setnet "#<primitive-procedure setnet>")
+(setnetent "#<procedure setnetent stayopen>")
+(setpgid "#<primitive-procedure setpgid>")
+(setpriority "#<primitive-procedure setpriority>")
+(setproto "#<primitive-procedure setproto>")
+(setprotoent "#<procedure setprotoent stayopen>")
+(setpw "#<primitive-procedure setpw>")
+(setpwent "#<procedure setpwent ()>")
+(setserv "#<primitive-procedure setserv>")
+(setservent "#<procedure setservent stayopen>")
+(setsid "#<primitive-procedure setsid>")
+(setsockopt "#<primitive-procedure setsockopt>")
+(setter "#<primitive-procedure setter>")
+(setuid "#<primitive-procedure setuid>")
+(setvbuf "#<primitive-procedure setvbuf>")
+(shared-array-increments "#<primitive-procedure shared-array-increments>")
+(shared-array-offset "#<primitive-procedure shared-array-offset>")
+(shared-array-root "#<primitive-procedure shared-array-root>")
+(shutdown "#<primitive-procedure shutdown>")
+(sigaction "#<primitive-procedure sigaction>")
+(signal-condition-variable "#<primitive-procedure signal-condition-variable>")
(signal-handlers "")
-(simple-format "#<primitive-procedure")
-(sin "#<procedure")
-(single-active-thread? "#<primitive-procedure")
-(sinh "#<procedure")
-(sleep "#<primitive-procedure")
-(sloppy-assoc "#<primitive-procedure")
-(sloppy-assq "#<primitive-procedure")
-(sloppy-assv "#<primitive-procedure")
-(sockaddr:addr "#<procedure")
-(sockaddr:fam "#<procedure")
-(sockaddr:path "#<procedure")
-(sockaddr:port "#<procedure")
-(socket "#<primitive-procedure")
-(socketpair "#<primitive-procedure")
-(sort "#<primitive-procedure")
-(sort! "#<primitive-procedure")
-(sort-list "#<primitive-procedure")
-(sort-list! "#<primitive-procedure")
-(sorted? "#<primitive-procedure")
-(source-properties "#<primitive-procedure")
-(source-property "#<primitive-procedure")
+(simple-format "#<primitive-procedure simple-format>")
+(sin "#<procedure sin (z)>")
+(single-active-thread? "#<primitive-procedure single-active-thread?>")
+(sinh "#<procedure sinh (z)>")
+(sleep "#<primitive-procedure sleep>")
+(sloppy-assoc "#<primitive-procedure sloppy-assoc>")
+(sloppy-assq "#<primitive-procedure sloppy-assq>")
+(sloppy-assv "#<primitive-procedure sloppy-assv>")
+(sockaddr:addr "#<procedure sockaddr:addr (obj)>")
+(sockaddr:fam "#<procedure sockaddr:fam (obj)>")
+(sockaddr:path "#<procedure sockaddr:path (obj)>")
+(sockaddr:port "#<procedure sockaddr:port (obj)>")
+(socket "#<primitive-procedure socket>")
+(socketpair "#<primitive-procedure socketpair>")
+(sort "#<primitive-procedure sort>")
+(sort! "#<primitive-procedure sort!>")
+(sort-list "#<primitive-procedure sort-list>")
+(sort-list! "#<primitive-procedure sort-list!>")
+(sorted? "#<primitive-procedure sorted?>")
+(source-properties "#<primitive-procedure source-properties>")
+(source-property "#<primitive-procedure source-property>")
(source-whash "")
-(sqrt "#<procedure")
-(stable-sort "#<primitive-procedure")
-(stable-sort! "#<primitive-procedure")
-(stack-id "#<primitive-procedure")
-(stack-length "#<primitive-procedure")
-(stack-ref "#<primitive-procedure")
+(sqrt "#<procedure sqrt (z)>")
+(stable-sort "#<primitive-procedure stable-sort>")
+(stable-sort! "#<primitive-procedure stable-sort!>")
+(stack-id "#<primitive-procedure stack-id>")
+(stack-length "#<primitive-procedure stack-length>")
+(stack-ref "#<primitive-procedure stack-ref>")
(stack-saved? "")
-(stack? "#<primitive-procedure")
-(standard-eval-closure "#<primitive-procedure")
-(standard-interface-eval-closure "#<primitive-procedure")
+(stack? "#<primitive-procedure stack?>")
+(standard-eval-closure "#<primitive-procedure standard-eval-closure>")
+(standard-interface-eval-closure "#<primitive-procedure standard-interface-eval-closure>")
(start-stack "")
-(stat "#<primitive-procedure")
-(stat:atime "#<procedure")
-(stat:blksize "#<procedure")
-(stat:blocks "#<procedure")
-(stat:ctime "#<procedure")
-(stat:dev "#<procedure")
-(stat:gid "#<procedure")
-(stat:ino "#<procedure")
-(stat:mode "#<procedure")
-(stat:mtime "#<procedure")
-(stat:nlink "#<procedure")
-(stat:perms "#<procedure")
-(stat:rdev "#<procedure")
-(stat:size "#<procedure")
-(stat:type "#<procedure")
-(stat:uid "#<procedure")
-(status:exit-val "#<primitive-procedure")
-(status:stop-sig "#<primitive-procedure")
-(status:term-sig "#<primitive-procedure")
-(strerror "#<primitive-procedure")
-(strftime "#<primitive-procedure")
-(string "#<primitive-procedure")
-(string->list "#<primitive-procedure")
-(string->number "#<primitive-procedure")
-(string->symbol "#<primitive-procedure")
-(string-append "#<primitive-procedure")
-(string-capitalize "#<primitive-procedure")
-(string-capitalize! "#<primitive-procedure")
-(string-ci->symbol "#<primitive-procedure")
-(string-ci<=? "#<primitive-procedure")
-(string-ci<? "#<primitive-procedure")
-(string-ci=? "#<primitive-procedure")
-(string-ci>=? "#<primitive-procedure")
-(string-ci>? "#<primitive-procedure")
-(string-copy "#<primitive-procedure")
-(string-downcase "#<primitive-procedure")
-(string-downcase! "#<primitive-procedure")
-(string-fill! "#<primitive-procedure")
-(string-index "#<primitive-procedure")
-(string-length "#<primitive-procedure")
-(string-null? "#<primitive-procedure")
-(string-ref "#<primitive-procedure")
-(string-rindex "#<primitive-procedure")
-(string-set! "#<primitive-procedure")
-(string-split "#<primitive-procedure")
-(string-upcase "#<primitive-procedure")
-(string-upcase! "#<primitive-procedure")
-(string<=? "#<primitive-procedure")
-(string<? "#<primitive-procedure")
-(string=? "#<primitive-procedure")
-(string>=? "#<primitive-procedure")
-(string>? "#<primitive-procedure")
-(string? "#<primitive-procedure")
-(strptime "#<primitive-procedure")
-(struct-layout "#<procedure")
-(struct-ref "#<primitive-procedure")
-(struct-set! "#<primitive-procedure")
-(struct-vtable "#<primitive-procedure")
-(struct-vtable-name "#<primitive-procedure")
-(struct-vtable-tag "#<primitive-procedure")
-(struct-vtable? "#<primitive-procedure")
-(struct? "#<primitive-procedure")
-(substring "#<primitive-procedure")
-(substring-fill! "#<primitive-procedure")
-(substring-move! "#<primitive-procedure")
-(symbol "#<procedure")
-(symbol->keyword "#<procedure")
-(symbol->string "#<primitive-procedure")
-(symbol-append "#<procedure")
-(symbol-fref "#<primitive-procedure")
-(symbol-fset! "#<primitive-procedure")
-(symbol-hash "#<primitive-procedure")
-(symbol-interned? "#<primitive-procedure")
-(symbol-pref "#<primitive-procedure")
-(symbol-prefix-proc "#<procedure")
-(symbol-property "#<procedure")
-(symbol-property-remove! "#<procedure")
-(symbol-pset! "#<primitive-procedure")
-(symbol? "#<primitive-procedure")
-(symlink "#<primitive-procedure")
-(sync "#<primitive-procedure")
-(system "#<primitive-procedure")
-(system-async "#<primitive-procedure")
-(system-async-mark "#<primitive-procedure")
-(system-error-errno "#<procedure")
-(tan "#<procedure")
-(tanh "#<procedure")
-(tcgetpgrp "#<primitive-procedure")
-(tcsetpgrp "#<primitive-procedure")
+(stat "#<primitive-procedure stat>")
+(stat:atime "#<procedure stat:atime (f)>")
+(stat:blksize "#<procedure stat:blksize (f)>")
+(stat:blocks "#<procedure stat:blocks (f)>")
+(stat:ctime "#<procedure stat:ctime (f)>")
+(stat:dev "#<procedure stat:dev (f)>")
+(stat:gid "#<procedure stat:gid (f)>")
+(stat:ino "#<procedure stat:ino (f)>")
+(stat:mode "#<procedure stat:mode (f)>")
+(stat:mtime "#<procedure stat:mtime (f)>")
+(stat:nlink "#<procedure stat:nlink (f)>")
+(stat:perms "#<procedure stat:perms (f)>")
+(stat:rdev "#<procedure stat:rdev (f)>")
+(stat:size "#<procedure stat:size (f)>")
+(stat:type "#<procedure stat:type (f)>")
+(stat:uid "#<procedure stat:uid (f)>")
+(status:exit-val "#<primitive-procedure status:exit-val>")
+(status:stop-sig "#<primitive-procedure status:stop-sig>")
+(status:term-sig "#<primitive-procedure status:term-sig>")
+(strerror "#<primitive-procedure strerror>")
+(strftime "#<primitive-procedure strftime>")
+(string "#<primitive-procedure string>")
+(string->list "#<primitive-procedure string->list>")
+(string->number "#<primitive-procedure string->number>")
+(string->symbol "#<primitive-procedure string->symbol>")
+(string-append "#<primitive-procedure string-append>")
+(string-capitalize "#<primitive-procedure string-capitalize>")
+(string-capitalize! "#<primitive-procedure string-capitalize!>")
+(string-ci->symbol "#<primitive-procedure string-ci->symbol>")
+(string-ci<=? "#<primitive-procedure string-ci<=?>")
+(string-ci<? "#<primitive-procedure string-ci<?>")
+(string-ci=? "#<primitive-procedure string-ci=?>")
+(string-ci>=? "#<primitive-procedure string-ci>=?>")
+(string-ci>? "#<primitive-procedure string-ci>?>")
+(string-copy "#<primitive-procedure string-copy>")
+(string-downcase "#<primitive-procedure string-downcase>")
+(string-downcase! "#<primitive-procedure string-downcase!>")
+(string-fill! "#<primitive-procedure string-fill!>")
+(string-index "#<primitive-procedure string-index>")
+(string-length "#<primitive-procedure string-length>")
+(string-null? "#<primitive-procedure string-null?>")
+(string-ref "#<primitive-procedure string-ref>")
+(string-rindex "#<primitive-procedure string-rindex>")
+(string-set! "#<primitive-procedure string-set!>")
+(string-split "#<primitive-procedure string-split>")
+(string-upcase "#<primitive-procedure string-upcase>")
+(string-upcase! "#<primitive-procedure string-upcase!>")
+(string<=? "#<primitive-procedure string<=?>")
+(string<? "#<primitive-procedure string<?>")
+(string=? "#<primitive-procedure string=?>")
+(string>=? "#<primitive-procedure string>=?>")
+(string>? "#<primitive-procedure string>?>")
+(string? "#<primitive-procedure string?>")
+(strptime "#<primitive-procedure strptime>")
+(struct-layout "#<procedure struct-layout (s)>")
+(struct-ref "#<primitive-procedure struct-ref>")
+(struct-set! "#<primitive-procedure struct-set!>")
+(struct-vtable "#<primitive-procedure struct-vtable>")
+(struct-vtable-name "#<primitive-procedure struct-vtable-name>")
+(struct-vtable-tag "#<primitive-procedure struct-vtable-tag>")
+(struct-vtable? "#<primitive-procedure struct-vtable?>")
+(struct? "#<primitive-procedure struct?>")
+(substring "#<primitive-procedure substring>")
+(substring-fill! "#<primitive-procedure substring-fill!>")
+(substring-move! "#<primitive-procedure substring-move!>")
+(symbol "#<procedure symbol args>")
+(symbol->keyword "#<procedure symbol->keyword (symbol)>")
+(symbol->string "#<primitive-procedure symbol->string>")
+(symbol-append "#<procedure symbol-append args>")
+(symbol-fref "#<primitive-procedure symbol-fref>")
+(symbol-fset! "#<primitive-procedure symbol-fset!>")
+(symbol-hash "#<primitive-procedure symbol-hash>")
+(symbol-interned? "#<primitive-procedure symbol-interned?>")
+(symbol-pref "#<primitive-procedure symbol-pref>")
+(symbol-prefix-proc "#<procedure symbol-prefix-proc (prefix)>")
+(symbol-property "#<procedure symbol-property (sym prop)>")
+(symbol-property-remove! "#<procedure symbol-property-remove! (sym prop)>")
+(symbol-pset! "#<primitive-procedure symbol-pset!>")
+(symbol? "#<primitive-procedure symbol?>")
+(symlink "#<primitive-procedure symlink>")
+(sync "#<primitive-procedure sync>")
+(system "#<primitive-procedure system>")
+(system-async "#<primitive-procedure system-async>")
+(system-async-mark "#<primitive-procedure system-async-mark>")
+(system-error-errno "#<procedure system-error-errno (args)>")
+(tan "#<procedure tan (z)>")
+(tanh "#<procedure tanh (z)>")
+(tcgetpgrp "#<primitive-procedure tcgetpgrp>")
+(tcsetpgrp "#<primitive-procedure tcsetpgrp>")
(the-environment "")
(the-eof-object "")
(the-last-stack "")
(the-root-environment "")
(the-root-module "")
(the-scm-module "")
-(throw "#<primitive-procedure")
-(thunk? "#<primitive-procedure")
-(times "#<primitive-procedure")
-(tm:gmtoff "#<procedure")
-(tm:hour "#<procedure")
-(tm:isdst "#<procedure")
-(tm:mday "#<procedure")
-(tm:min "#<procedure")
-(tm:mon "#<procedure")
-(tm:sec "#<procedure")
-(tm:wday "#<procedure")
-(tm:yday "#<procedure")
-(tm:year "#<procedure")
-(tm:zone "#<procedure")
-(tmpnam "#<primitive-procedure")
-(tms:clock "#<procedure")
-(tms:cstime "#<procedure")
-(tms:cutime "#<procedure")
-(tms:stime "#<procedure")
-(tms:utime "#<procedure")
-(top-repl "#<procedure")
-(transform-usage-lambda "#<procedure")
-(transpose-array "#<primitive-procedure")
-(trap-disable "#<procedure")
-(trap-enable "#<procedure")
+(throw "#<primitive-procedure throw>")
+(thunk? "#<primitive-procedure thunk?>")
+(times "#<primitive-procedure times>")
+(tm:gmtoff "#<procedure tm:gmtoff (obj)>")
+(tm:hour "#<procedure tm:hour (obj)>")
+(tm:isdst "#<procedure tm:isdst (obj)>")
+(tm:mday "#<procedure tm:mday (obj)>")
+(tm:min "#<procedure tm:min (obj)>")
+(tm:mon "#<procedure tm:mon (obj)>")
+(tm:sec "#<procedure tm:sec (obj)>")
+(tm:wday "#<procedure tm:wday (obj)>")
+(tm:yday "#<procedure tm:yday (obj)>")
+(tm:year "#<procedure tm:year (obj)>")
+(tm:zone "#<procedure tm:zone (obj)>")
+(tmpnam "#<primitive-procedure tmpnam>")
+(tms:clock "#<procedure tms:clock (obj)>")
+(tms:cstime "#<procedure tms:cstime (obj)>")
+(tms:cutime "#<procedure tms:cutime (obj)>")
+(tms:stime "#<procedure tms:stime (obj)>")
+(tms:utime "#<procedure tms:utime (obj)>")
+(top-repl "#<procedure top-repl ()>")
+(transform-usage-lambda "#<procedure transform-usage-lambda (cases)>")
+(transpose-array "#<primitive-procedure transpose-array>")
+(trap-disable "#<procedure trap-disable flags>")
+(trap-enable "#<procedure trap-enable flags>")
(trap-set! "")
-(traps "#<procedure")
-(truncate "#<primitive-procedure")
-(truncate-file "#<primitive-procedure")
-(try-arbiter "#<primitive-procedure")
-(try-load-module "#<procedure")
-(try-module-autoload "#<procedure")
-(ttyname "#<primitive-procedure")
-(turn-on-debugging "#<procedure")
-(tzset "#<primitive-procedure")
-(umask "#<primitive-procedure")
-(uname "#<primitive-procedure")
+(traps "#<procedure traps args>")
+(truncate "#<primitive-procedure truncate>")
+(truncate-file "#<primitive-procedure truncate-file>")
+(try-arbiter "#<primitive-procedure try-arbiter>")
+(try-load-module "#<procedure try-load-module (name)>")
+(try-module-autoload "#<procedure try-module-autoload (module-name)>")
+(ttyname "#<primitive-procedure ttyname>")
+(turn-on-debugging "#<procedure turn-on-debugging ()>")
+(tzset "#<primitive-procedure tzset>")
+(umask "#<primitive-procedure umask>")
+(uname "#<primitive-procedure uname>")
(undefine "")
-(uniform-array-read! "#<primitive-procedure")
-(uniform-array-set1! "#<primitive-procedure")
-(uniform-array-write "#<primitive-procedure")
-(uniform-vector-fill! "#<primitive-procedure")
-(uniform-vector-length "#<primitive-procedure")
-(uniform-vector-read! "#<primitive-procedure")
-(uniform-vector-ref "#<primitive-procedure")
-(uniform-vector-set! "#<procedure")
-(uniform-vector-write "#<primitive-procedure")
-(uniform-vector? "#<primitive-procedure")
-(unlock-mutex "#<primitive-procedure")
-(unmask-signals "#<primitive-procedure")
-(unmemoize "#<primitive-procedure")
-(unread-char "#<primitive-procedure")
-(unread-string "#<primitive-procedure")
-(unspecified? "#<procedure")
+(uniform-array-read! "#<primitive-procedure uniform-array-read!>")
+(uniform-array-set1! "#<primitive-procedure uniform-array-set1!>")
+(uniform-array-write "#<primitive-procedure uniform-array-write>")
+(uniform-vector-fill! "#<primitive-procedure array-fill!>")
+(uniform-vector-length "#<primitive-procedure uniform-vector-length>")
+(uniform-vector-read! "#<primitive-procedure uniform-array-read!>")
+(uniform-vector-ref "#<primitive-procedure uniform-vector-ref>")
+(uniform-vector-set! "#<procedure uniform-vector-set! (u i o)>")
+(uniform-vector-write "#<primitive-procedure uniform-array-write>")
+(uniform-vector? "#<primitive-procedure array?>")
+(unlock-mutex "#<primitive-procedure unlock-mutex>")
+(unmask-signals "#<primitive-procedure unmask-signals>")
+(unmemoize "#<primitive-procedure unmemoize>")
+(unread-char "#<primitive-procedure unread-char>")
+(unread-string "#<primitive-procedure unread-string>")
+(unspecified? "#<procedure unspecified? (v)>")
(use-emacs-interface "")
(use-modules "")
-(use-srfis "#<procedure")
+(use-srfis "#<procedure use-srfis (srfis)>")
(use-syntax "")
(using-readline? "#<procedure-with-setter>")
-(usleep "#<primitive-procedure")
-(utime "#<primitive-procedure")
-(utsname:machine "#<procedure")
-(utsname:nodename "#<procedure")
-(utsname:release "#<procedure")
-(utsname:sysname "#<procedure")
-(utsname:version "#<procedure")
-(valid-object-procedure? "#<primitive-procedure")
-(values "#<primitive-procedure")
-(variable-bound? "#<primitive-procedure")
-(variable-ref "#<primitive-procedure")
-(variable-set! "#<primitive-procedure")
-(variable? "#<primitive-procedure")
-(vector "#<primitive-procedure")
-(vector->list "#<primitive-procedure")
-(vector-fill! "#<primitive-procedure")
-(vector-length "#<primitive-procedure")
-(vector-move-left! "#<primitive-procedure")
-(vector-move-right! "#<primitive-procedure")
-(vector-ref "#<primitive-procedure")
-(vector-set! "#<primitive-procedure")
-(vector? "#<primitive-procedure")
-(version "#<primitive-procedure")
+(usleep "#<primitive-procedure usleep>")
+(utime "#<primitive-procedure utime>")
+(utsname:machine "#<procedure utsname:machine (obj)>")
+(utsname:nodename "#<procedure utsname:nodename (obj)>")
+(utsname:release "#<procedure utsname:release (obj)>")
+(utsname:sysname "#<procedure utsname:sysname (obj)>")
+(utsname:version "#<procedure utsname:version (obj)>")
+(valid-object-procedure? "#<primitive-procedure valid-object-procedure?>")
+(values "#<primitive-procedure values>")
+(variable-bound? "#<primitive-procedure variable-bound?>")
+(variable-ref "#<primitive-procedure variable-ref>")
+(variable-set! "#<primitive-procedure variable-set!>")
+(variable? "#<primitive-procedure variable?>")
+(vector "#<primitive-procedure vector>")
+(vector->list "#<primitive-procedure vector->list>")
+(vector-fill! "#<primitive-procedure vector-fill!>")
+(vector-length "#<primitive-procedure vector-length>")
+(vector-move-left! "#<primitive-procedure vector-move-left!>")
+(vector-move-right! "#<primitive-procedure vector-move-right!>")
+(vector-ref "#<primitive-procedure vector-ref>")
+(vector-set! "#<primitive-procedure vector-set!>")
+(vector? "#<primitive-procedure vector?>")
+(version "#<primitive-procedure version>")
(vtable-index-layout "")
(vtable-index-printer "")
(vtable-index-vtable "")
(vtable-offset-user "")
-(wait-condition-variable "#<primitive-procedure")
-(waitpid "#<primitive-procedure")
-(warn "#<procedure")
-(weak-key-hash-table? "#<primitive-procedure")
-(weak-value-hash-table? "#<primitive-procedure")
-(weak-vector "#<primitive-procedure")
-(weak-vector? "#<primitive-procedure")
+(wait-condition-variable "#<primitive-procedure wait-condition-variable>")
+(waitpid "#<primitive-procedure waitpid>")
+(warn "#<procedure warn stuff>")
+(weak-key-hash-table? "#<primitive-procedure weak-key-hash-table?>")
+(weak-value-hash-table? "#<primitive-procedure weak-value-hash-table?>")
+(weak-vector "#<primitive-procedure weak-vector>")
+(weak-vector? "#<primitive-procedure weak-vector?>")
(while "")
-(with-error-to-file "#<procedure")
-(with-error-to-port "#<procedure")
-(with-error-to-string "#<procedure")
+(with-error-to-file "#<procedure with-error-to-file (file thunk)>")
+(with-error-to-port "#<procedure with-error-to-port (port thunk)>")
+(with-error-to-string "#<procedure with-error-to-string (thunk)>")
(with-fluids "")
-(with-fluids* "#<primitive-procedure")
-(with-input-from-file "#<procedure")
-(with-input-from-port "#<procedure")
-(with-input-from-string "#<procedure")
-(with-output-to-file "#<procedure")
-(with-output-to-port "#<procedure")
-(with-output-to-string "#<procedure")
-(with-traps "#<primitive-procedure")
-(write "#<primitive-procedure")
-(write-char "#<primitive-procedure")
+(with-fluids* "#<primitive-procedure with-fluids*>")
+(with-input-from-file "#<procedure with-input-from-file (file thunk)>")
+(with-input-from-port "#<procedure with-input-from-port (port thunk)>")
+(with-input-from-string "#<procedure with-input-from-string (string thunk)>")
+(with-output-to-file "#<procedure with-output-to-file (file thunk)>")
+(with-output-to-port "#<procedure with-output-to-port (port thunk)>")
+(with-output-to-string "#<procedure with-output-to-string (thunk)>")
+(with-traps "#<primitive-procedure with-traps>")
+(write "#<primitive-procedure write>")
+(write-char "#<primitive-procedure write-char>")
(xformer-table "")
-(yield "#<primitive-procedure")
-(zero? "#<primitive-procedure")
+(yield "#<primitive-procedure yield>")
+(zero? "#<primitive-procedure zero?>")
) ;; end of scheme
-(C
+(C
(collisionp B)
(coop_abort T)
(coop_condition_variable_destroy T)
(gnfds B)
(greadfds B)
(gwritefds B)
-(issued_msgs B)
(rexceptfds B)
(rreadfds B)
(rwritefds B)
(scm_array_prototype T)
(scm_array_rank T)
(scm_array_set_x T)
+(scm_array_to_list T)
(scm_ash T)
(scm_asinh T)
(scm_assoc T)
(scm_c_ints2ivect T)
(scm_c_ints2scm T)
(scm_c_issue_deprecation_warning T)
+(scm_c_issue_deprecation_warning_fmt T)
(scm_c_load_extension T)
(scm_c_longs2ivect T)
(scm_c_longs2scm T)
(scm_gc_cells_swept D)
(scm_gc_cells_swept_acc D)
(scm_gc_for_newcell T)
+(scm_gc_free T)
(scm_gc_heap_lock D)
+(scm_gc_malloc T)
(scm_gc_malloc_collected B)
(scm_gc_mark T)
(scm_gc_mark_dependencies T)
(scm_gc_mark_time_taken D)
(scm_gc_ports_collected B)
(scm_gc_protect_object T)
+(scm_gc_realloc T)
+(scm_gc_register_collectable_memory T)
(scm_gc_register_root T)
(scm_gc_register_roots T)
(scm_gc_running_p D)
(scm_gc_stats T)
+(scm_gc_strdup T)
+(scm_gc_strndup T)
(scm_gc_sweep T)
(scm_gc_sweep_time_taken D)
(scm_gc_time_taken D)
(scm_gc_times D)
(scm_gc_unprotect_object T)
+(scm_gc_unregister_collectable_memory T)
(scm_gc_unregister_root T)
(scm_gc_unregister_roots T)
(scm_gc_yield B)
(scm_makmacro T)
(scm_makmmacro T)
(scm_makprom T)
+(scm_malloc T)
(scm_malloc_obj T)
(scm_mallocated D)
(scm_map T)
(scm_real_equalp T)
(scm_real_p T)
(scm_real_part T)
+(scm_realloc T)
(scm_recv T)
(scm_recvfrom T)
(scm_redirect_port T)
(scm_status_term_sig T)
(scm_str2string T)
(scm_str2symbol T)
+(scm_strdup T)
(scm_strerror T)
(scm_strftime T)
(scm_string T)
(scm_string_to_symbol T)
(scm_string_upcase T)
(scm_string_upcase_x T)
+(scm_strndup T)
(scm_strport_to_string T)
(scm_strptime T)
(scm_struct_create_handle T)
(scm_system_environment B)
(scm_system_error_key B)
(scm_system_module_env_p T)
-(scm_t_arrayo_list T)
(scm_tables_prehistory T)
(scm_take0str T)
(scm_take_from_input_buffers T)
(scm_zero_p T)
(terminating B)
) ;; end of C
-)
+) ;; eof
HCoop / bpt / guile.git / commitdiff