diff --git a/doc/guile-api.alist b/doc/guile-api.alist
new file mode 100644
index 000000000..179b610fa
--- /dev/null
+++ b/doc/guile-api.alist
@@ -0,0 +1,2950 @@
+;; Generated Fri Feb 15 13:14:33 PST 2002 by guile-scripts/scan-api -- do not edit!
+;; guile: /home/ttn/build/.gnu/guile-core-1.4/pre-inst-guile .
+;; sofile: libguile/.libs/libguile.so.9.0.0
+
+(
+(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")
+(%autoloader-developer-mode "")
+(%deliver-signals "#<primitive-procedure")
+(%gc-thunk "#<primitive-procedure")
+(%guile-build-info "")
+(%library-dir "#<primitive-procedure")
+(%load-announce "#<procedure")
+(%load-extensions "")
+(%load-hook "#<procedure")
+(%load-path "")
+(%load-verbosely "")
+(%make-void-port "#<primitive-procedure")
+(%package-data-dir "#<primitive-procedure")
+(%print-module "#<procedure")
+(%read-delimited! "#<primitive-procedure")
+(%read-line "#<primitive-procedure")
+(%search-load-path "#<primitive-procedure")
+(%site-dir "#<primitive-procedure")
+(* "#<primitive-procedure")
+(*features* "")
+(*null-device* "")
+(*random-state* "")
+(*top-level-lookup-closure* "#<compiled-closure")
+(*unspecified* "")
+(*values-rtd* "")
+(+ "#<primitive-procedure")
+(- "#<primitive-procedure")
+(-1+ "#<procedure")
+(->bool "#<procedure")
+(/ "#<primitive-procedure")
+(0-cond "")
+(0-ify "")
+(1+ "#<procedure")
+(1- "#<procedure")
+(1-ify "")
+(< "#<primitive-procedure")
+(<= "#<primitive-procedure")
+(<class> "")
+(<entity> "")
+(<operator-class> "")
+(= "#<primitive-procedure")
+(> "#<primitive-procedure")
+(>= "#<primitive-procedure")
+(@apply "")
+(@bind "")
+(@call-with-current-continuation "")
+(@fop "")
+(AF_INET "")
+(AF_UNIX "")
+(AF_UNSPEC "")
+(E2BIG "")
+(EACCES "")
+(EADDRINUSE "")
+(EADDRNOTAVAIL "")
+(EADV "")
+(EAFNOSUPPORT "")
+(EAGAIN "")
+(EALREADY "")
+(EBADE "")
+(EBADF "")
+(EBADFD "")
+(EBADMSG "")
+(EBADR "")
+(EBADRQC "")
+(EBADSLT "")
+(EBFONT "")
+(EBUSY "")
+(ECHILD "")
+(ECHRNG "")
+(ECOMM "")
+(ECONNABORTED "")
+(ECONNREFUSED "")
+(ECONNRESET "")
+(EDEADLK "")
+(EDEADLOCK "")
+(EDESTADDRREQ "")
+(EDOM "")
+(EDOTDOT "")
+(EDQUOT "")
+(EEXIST "")
+(EFAULT "")
+(EFBIG "")
+(EHOSTDOWN "")
+(EHOSTUNREACH "")
+(EIDRM "")
+(EILSEQ "")
+(EINPROGRESS "")
+(EINTR "")
+(EINVAL "")
+(EIO "")
+(EISCONN "")
+(EISDIR "")
+(EISNAM "")
+(EL2HLT "")
+(EL2NSYNC "")
+(EL3HLT "")
+(EL3RST "")
+(ELIBACC "")
+(ELIBBAD "")
+(ELIBEXEC "")
+(ELIBMAX "")
+(ELIBSCN "")
+(ELNRNG "")
+(ELOOP "")
+(EMFILE "")
+(EMLINK "")
+(EMSGSIZE "")
+(EMULTIHOP "")
+(ENAMETOOLONG "")
+(ENAVAIL "")
+(ENETDOWN "")
+(ENETRESET "")
+(ENETUNREACH "")
+(ENFILE "")
+(ENOANO "")
+(ENOBUFS "")
+(ENOCSI "")
+(ENODATA "")
+(ENODEV "")
+(ENOENT "")
+(ENOEXEC "")
+(ENOLCK "")
+(ENOLINK "")
+(ENOMEM "")
+(ENOMSG "")
+(ENONET "")
+(ENOPKG "")
+(ENOPROTOOPT "")
+(ENOSPC "")
+(ENOSR "")
+(ENOSTR "")
+(ENOSYS "")
+(ENOTBLK "")
+(ENOTCONN "")
+(ENOTDIR "")
+(ENOTEMPTY "")
+(ENOTNAM "")
+(ENOTSOCK "")
+(ENOTTY "")
+(ENOTUNIQ "")
+(ENXIO "")
+(EOPNOTSUPP "")
+(EOVERFLOW "")
+(EPERM "")
+(EPFNOSUPPORT "")
+(EPIPE "")
+(EPROTO "")
+(EPROTONOSUPPORT "")
+(EPROTOTYPE "")
+(ERANGE "")
+(EREMCHG "")
+(EREMOTE "")
+(EREMOTEIO "")
+(ERESTART "")
+(EROFS "")
+(ESHUTDOWN "")
+(ESOCKTNOSUPPORT "")
+(ESPIPE "")
+(ESRCH "")
+(ESRMNT "")
+(ESTALE "")
+(ESTRPIPE "")
+(ETIME "")
+(ETIMEDOUT "")
+(ETOOMANYREFS "")
+(ETXTBSY "")
+(EUCLEAN "")
+(EUNATCH "")
+(EUSERS "")
+(EWOULDBLOCK "")
+(EXDEV "")
+(EXFULL "")
+(FD_CLOEXEC "")
+(F_DUPFD "")
+(F_GETFD "")
+(F_GETFL "")
+(F_GETOWN "")
+(F_OK "")
+(F_SETFD "")
+(F_SETFL "")
+(F_SETOWN "")
+(INADDR_ANY "")
+(INADDR_BROADCAST "")
+(INADDR_LOOPBACK "")
+(INADDR_NONE "")
+(LC_ALL "")
+(LC_COLLATE "")
+(LC_CTYPE "")
+(LC_MESSAGES "")
+(LC_MONETARY "")
+(LC_NUMERIC "")
+(LC_TIME "")
+(MSG_DONTROUTE "")
+(MSG_OOB "")
+(MSG_PEEK "")
+(NSIG "")
+(OPEN_BOTH "")
+(OPEN_READ "")
+(OPEN_WRITE "")
+(O_APPEND "")
+(O_CREAT "")
+(O_EXCL "")
+(O_NDELAY "")
+(O_NOCTTY "")
+(O_NONBLOCK "")
+(O_RDONLY "")
+(O_RDWR "")
+(O_SYNC "")
+(O_TRUNC "")
+(O_WRONLY "")
+(PF_INET "")
+(PF_UNIX "")
+(PF_UNSPEC "")
+(PIPE_BUF "")
+(R_OK "")
+(SA_NOCLDSTOP "")
+(SA_RESTART "")
+(SEEK_CUR "")
+(SEEK_END "")
+(SEEK_SET "")
+(SIGABRT "")
+(SIGALRM "")
+(SIGBUS "")
+(SIGCHLD "")
+(SIGCLD "")
+(SIGCONT "")
+(SIGFPE "")
+(SIGHUP "")
+(SIGILL "")
+(SIGINT "")
+(SIGIO "")
+(SIGIOT "")
+(SIGKILL "")
+(SIGPIPE "")
+(SIGPOLL "")
+(SIGPROF "")
+(SIGPWR "")
+(SIGQUIT "")
+(SIGSEGV "")
+(SIGSTKFLT "")
+(SIGSTOP "")
+(SIGTERM "")
+(SIGTRAP "")
+(SIGTSTP "")
+(SIGTTIN "")
+(SIGTTOU "")
+(SIGUNUSED "")
+(SIGURG "")
+(SIGUSR1 "")
+(SIGUSR2 "")
+(SIGVTALRM "")
+(SIGWINCH "")
+(SIGXCPU "")
+(SIGXFSZ "")
+(SIG_DFL "")
+(SIG_IGN "")
+(SOCK_DGRAM "")
+(SOCK_RAW "")
+(SOCK_STREAM "")
+(SOL_IP "")
+(SOL_SOCKET "")
+(SO_BROADCAST "")
+(SO_DEBUG "")
+(SO_DONTROUTE "")
+(SO_ERROR "")
+(SO_KEEPALIVE "")
+(SO_LINGER "")
+(SO_NO_CHECK "")
+(SO_OOBINLINE "")
+(SO_PRIORITY "")
+(SO_RCVBUF "")
+(SO_REUSEADDR "")
+(SO_SNDBUF "")
+(SO_TYPE "")
+(WAIT_ANY "")
+(WAIT_MYPGRP "")
+(WNOHANG "")
+(WUNTRACED "")
+(W_OK "")
+(X_OK "")
+(_IOFBF "")
+(_IOLBF "")
+(_IONBF "")
+(abort-hook "")
+(abs "#<primitive-procedure")
+(accept "#<primitive-procedure")
+(access? "#<primitive-procedure")
+(acons "#<primitive-procedure")
+(acos "#<procedure")
+(acosh "#<procedure")
+(add-hook! "#<primitive-procedure")
+(after-backtrace-hook "")
+(after-error-hook "")
+(after-gc-hook "")
+(after-read-hook "")
+(alarm "#<primitive-procedure")
+(and "")
+(and-map "#<procedure")
+(and=> "#<procedure")
+(angle "#<primitive-procedure")
+(app "")
+(append "#<primitive-procedure")
+(append! "#<primitive-procedure")
+(apply "#<procedure")
+(apply-frame-handler "#<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")
+(autoloads-done "")
+(autoloads-in-progress "")
+(backtrace "#<primitive-procedure")
+(bad-throw "#<procedure")
+(basename "#<primitive-procedure")
+(basic-load "#<procedure")
+(batch-mode? "#<procedure")
+(beautify-user-module! "#<procedure")
+(before-backtrace-hook "")
+(before-error-hook "")
+(before-read-hook "")
+(before-signal-stack "")
+(begin "")
+(bignum-radix "")
+(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")
+(builtin-bindings "#<primitive-procedure")
+(builtin-variable "#<primitive-procedure")
+(builtin-weak-bindings "#<primitive-procedure")
+(c-clear-registered-modules "#<primitive-procedure")
+(c-registered-modules "#<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")
+(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")
+(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")
+(close "#<primitive-procedure")
+(close-all-ports-except "#<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")
+(collect "")
+(command-line "#<procedure")
+(complex? "#<primitive-procedure")
+(cond "")
+(connect "#<primitive-procedure")
+(cons "#<primitive-procedure")
+(cons* "#<primitive-procedure")
+(cons-source "#<primitive-procedure")
+(convert-c-registered-modules "#<procedure")
+(copy-file "#<primitive-procedure")
+(copy-random-state "#<primitive-procedure")
+(copy-tree "#<primitive-procedure")
+(cos "#<procedure")
+(cosh "#<procedure")
+(ctermid "#<primitive-procedure")
+(current-error-port "#<primitive-procedure")
+(current-input-port "#<primitive-procedure")
+(current-load-port "#<primitive-procedure")
+(current-module "#<procedure")
+(current-output-port "#<primitive-procedure")
+(current-time "#<primitive-procedure")
+(debug-disable "#<procedure")
+(debug-enable "#<procedure")
+(debug-object? "#<primitive-procedure")
+(debug-options "#<procedure")
+(debug-options-interface "#<primitive-procedure")
+(debug-set! "")
+(default-lazy-handler "#<procedure")
+(define "")
+(define-macro "")
+(define-module "")
+(define-private "")
+(define-public "")
+(define-syntax-macro "")
+(defined? "#<primitive-procedure")
+(defmacro "")
+(defmacro-public "")
+(defmacro-transformer "#<procedure")
+(defmacro:syntax-transformer "#<procedure")
+(defmacro:transformer "#<procedure")
+(defmacro? "#<procedure")
+(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")
+(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")
+(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")
+(duplicate-port "#<procedure")
+(dynamic-args-call "#<primitive-procedure")
+(dynamic-call "#<primitive-procedure")
+(dynamic-func "#<primitive-procedure")
+(dynamic-link "#<primitive-procedure")
+(dynamic-maybe-call "#<procedure")
+(dynamic-maybe-link "#<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")
+(enter-frame-handler "#<procedure")
+(entity? "#<primitive-procedure")
+(environ "#<primitive-procedure")
+(environment-module "#<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")
+(eval-disable "#<procedure")
+(eval-enable "#<procedure")
+(eval-in-module "#<procedure")
+(eval-options "#<procedure")
+(eval-options-interface "#<primitive-procedure")
+(eval-set! "")
+(eval-string "#<primitive-procedure")
+(eval2 "#<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")
+(exit-frame-handler "#<procedure")
+(exit-hook "")
+(exp "#<procedure")
+(export "")
+(export-syntax "")
+(expt "#<procedure")
+(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-position "#<procedure")
+(file-set-position "#<procedure")
+(fileno "#<primitive-procedure")
+(find-and-link-dynamic-module "#<procedure")
+(flags "#<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")
+(fseek "#<primitive-procedure")
+(fsync "#<primitive-procedure")
+(ftell "#<primitive-procedure")
+(gc "#<primitive-procedure")
+(gc-run-time "#<procedure")
+(gc-stats "#<primitive-procedure")
+(gc-thunk "")
+(gcd "#<primitive-procedure")
+(gensym "#<primitive-procedure")
+(gentemp "#<procedure")
+(get-internal-real-time "#<primitive-procedure")
+(get-internal-run-time "#<primitive-procedure")
+(get-option "#<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")
+(getnet "#<primitive-procedure")
+(getnetbyaddr "#<procedure")
+(getnetbyname "#<procedure")
+(getnetent "#<procedure")
+(getpeername "#<primitive-procedure")
+(getpgrp "#<primitive-procedure")
+(getpid "#<primitive-procedure")
+(getppid "#<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")
+(handle-system-error "#<procedure")
+(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")
+(id "#<procedure")
+(if "")
+(imag-part "#<primitive-procedure")
+(in-vicinity "#<procedure")
+(inet-aton "#<primitive-procedure")
+(inet-lnaof "#<primitive-procedure")
+(inet-makeaddr "#<primitive-procedure")
+(inet-netof "#<primitive-procedure")
+(inet-ntoa "#<primitive-procedure")
+(inexact->exact "#<primitive-procedure")
+(inexact? "#<primitive-procedure")
+(inherit-print-state "#<procedure")
+(init-dynamic-module "#<procedure")
+(input-port? "#<primitive-procedure")
+(integer->char "#<primitive-procedure")
+(integer-expt "#<primitive-procedure")
+(integer-length "#<primitive-procedure")
+(integer? "#<primitive-procedure")
+(intern-symbol "#<primitive-procedure")
+(internal-time-units-per-second "")
+(iota "#<procedure")
+(ipow-by-squaring "#<procedure")
+(isatty? "#<primitive-procedure")
+(join-thread "#<primitive-procedure")
+(keyword->symbol "#<procedure")
+(keyword-dash-symbol "#<primitive-procedure")
+(keyword? "#<primitive-procedure")
+(kill "#<primitive-procedure")
+(kw-arg-ref "#<procedure")
+(lambda "")
+(last-pair "#<primitive-procedure")
+(last-stack-frame "#<primitive-procedure")
+(lazy-catch "#<primitive-procedure")
+(lazy-handler-dispatch "#<procedure")
+(lcm "#<primitive-procedure")
+(length "#<primitive-procedure")
+(let "")
+(let* "")
+(letrec "")
+(link "#<primitive-procedure")
+(link-dynamic-module "#<procedure")
+(list "#<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")
+(load-emacs-interface "#<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")
+(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-fluid "#<primitive-procedure")
+(make-guardian "#<primitive-procedure")
+(make-hash-table "#<procedure")
+(make-hook "#<primitive-procedure")
+(make-hook-with-name "#<primitive-procedure")
+(make-keyword-from-dash-symbol "#<primitive-procedure")
+(make-list "#<procedure")
+(make-module "#<procedure")
+(make-modules-in "#<procedure")
+(make-mutex "#<primitive-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-shared-substring "#<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-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")
+(min "#<primitive-procedure")
+(minor-version "#<primitive-procedure")
+(mkdir "#<primitive-procedure")
+(mknod "#<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-eval-closure "#<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-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")
+(module-type "")
+(module-unobserve "#<procedure")
+(module-use! "#<procedure")
+(module-uses "#<procedure")
+(module-variable "#<procedure")
+(module-weak-observers "#<procedure")
+(module? "#<procedure")
+(modulo "#<primitive-procedure")
+(most-negative-fixnum "")
+(most-positive-fixnum "")
+(move->fdes "#<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")
+(nil "")
+(nil-car "#<primitive-procedure")
+(nil-cdr "#<primitive-procedure")
+(nil-cond "")
+(nil-cons "#<primitive-procedure")
+(nil-eq "#<primitive-procedure")
+(nil-ify "")
+(nil-while "")
+(noop "#<primitive-procedure")
+(not "#<primitive-procedure")
+(ntohl "#<primitive-procedure")
+(ntohs "#<primitive-procedure")
+(null "#<primitive-procedure")
+(null? "#<primitive-procedure")
+(number->string "#<primitive-procedure")
+(number? "#<primitive-procedure")
+(obarray-gensym "#<procedure")
+(obarray-symbol-append "#<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-io-file "#<procedure")
+(open-output-file "#<procedure")
+(opendir "#<primitive-procedure")
+(operator? "#<primitive-procedure")
+(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-line "#<primitive-procedure")
+(port-mode "#<primitive-procedure")
+(port-revealed "#<primitive-procedure")
+(port-with-print-state "#<primitive-procedure")
+(positive? "#<primitive-procedure")
+(primitive-exit "#<primitive-procedure")
+(primitive-fork "#<primitive-procedure")
+(primitive-load "#<primitive-procedure")
+(primitive-load-path "#<primitive-procedure")
+(primitive-macro? "#<procedure")
+(primitive-move->fdes "#<primitive-procedure")
+(print-disable "#<procedure")
+(print-enable "#<procedure")
+(print-options "#<procedure")
+(print-options-interface "#<primitive-procedure")
+(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")
+(putenv "#<primitive-procedure")
+(quasiquote "")
+(quit "#<procedure")
+(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")
+(read "#<primitive-procedure")
+(read-and-eval! "#<primitive-procedure")
+(read-char "#<primitive-procedure")
+(read-delimited "#<procedure")
+(read-delimited! "#<procedure")
+(read-disable "#<procedure")
+(read-enable "#<procedure")
+(read-hash-extend "#<primitive-procedure")
+(read-hash-procedures "")
+(read-line "#<procedure")
+(read-line! "#<procedure")
+(read-only-string? "#<primitive-procedure")
+(read-options "#<procedure")
+(read-options-interface "#<primitive-procedure")
+(read-set! "")
+(read:array "#<procedure")
+(read:uniform-vector "#<procedure")
+(readdir "#<primitive-procedure")
+(readline-disable "#<procedure")
+(readline-enable "#<procedure")
+(readline-options "#<procedure")
+(readline-set! "")
+(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")
+(record-type-vtable "")
+(record-type? "#<procedure")
+(record? "#<procedure")
+(recv! "#<primitive-procedure")
+(recvfrom! "#<primitive-procedure")
+(redirect-port "#<primitive-procedure")
+(regexp-exec "#<primitive-procedure")
+(regexp/basic "")
+(regexp/extended "")
+(regexp/icase "")
+(regexp/newline "")
+(regexp/notbol "")
+(regexp/noteol "")
+(regexp? "#<primitive-procedure")
+(register-modules "#<procedure")
+(registered-modules "")
+(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")
+(return-it "#<primitive-procedure")
+(reverse "#<primitive-procedure")
+(reverse! "#<primitive-procedure")
+(rewinddir "#<primitive-procedure")
+(rmdir "#<primitive-procedure")
+(root-module-closure "#<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")
+(scm-line-incrementors "")
+(scm-module-closure "#<procedure")
+(scm-repl-print-unspecified "")
+(scm-repl-prompt "")
+(scm-repl-silent "")
+(scm-repl-verbose "")
+(scm-style-repl "#<procedure")
+(scm:eval-transformer "")
+(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")
+(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 "#<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")
+(setlocale "#<primitive-procedure")
+(setnet "#<primitive-procedure")
+(setnetent "#<procedure")
+(setpgid "#<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")
+(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")
+(sloppy-member "#<primitive-procedure")
+(sloppy-memq "#<primitive-procedure")
+(sloppy-memv "#<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")
+(source-whash "")
+(split-c-module-name "#<procedure")
+(sqrt "#<procedure")
+(stable-sort "#<primitive-procedure")
+(stable-sort! "#<primitive-procedure")
+(stack-id "#<primitive-procedure")
+(stack-length "#<primitive-procedure")
+(stack-ref "#<primitive-procedure")
+(stack-saved? "")
+(stack? "#<primitive-procedure")
+(standard-eval-closure "#<primitive-procedure")
+(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->obarray-symbol "#<primitive-procedure")
+(string->symbol "#<primitive-procedure")
+(string-append "#<primitive-procedure")
+(string-capitalize "#<primitive-procedure")
+(string-capitalize! "#<primitive-procedure")
+(string-character-length "#<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-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")
+(substring-move-left! "#<primitive-procedure")
+(substring-move-right! "#<primitive-procedure")
+(symbol "#<procedure")
+(symbol->keyword "#<procedure")
+(symbol->string "#<primitive-procedure")
+(symbol-append "#<procedure")
+(symbol-binding "#<primitive-procedure")
+(symbol-bound? "#<primitive-procedure")
+(symbol-fref "#<primitive-procedure")
+(symbol-fset! "#<primitive-procedure")
+(symbol-hash "#<primitive-procedure")
+(symbol-interned? "#<primitive-procedure")
+(symbol-pref "#<primitive-procedure")
+(symbol-property "#<procedure")
+(symbol-property-remove! "#<procedure")
+(symbol-pset! "#<primitive-procedure")
+(symbol-set! "#<primitive-procedure")
+(symbol? "#<primitive-procedure")
+(symlink "#<primitive-procedure")
+(sync "#<primitive-procedure")
+(system "#<primitive-procedure")
+(system-async "#<primitive-procedure")
+(system-async-mark "#<primitive-procedure")
+(t "")
+(t-ify "")
+(tag "#<primitive-procedure")
+(tan "#<procedure")
+(tanh "#<procedure")
+(tcgetpgrp "#<primitive-procedure")
+(tcsetpgrp "#<primitive-procedure")
+(the-environment "")
+(the-eof-object "")
+(the-last-stack "")
+(the-module "")
+(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")
+(trap-set! "")
+(traps "#<procedure")
+(truncate "#<primitive-procedure")
+(truncate-file "#<primitive-procedure")
+(try-arbiter "#<primitive-procedure")
+(try-load-module "#<procedure")
+(try-module-autoload "#<procedure")
+(try-module-dynamic-link "#<procedure")
+(try-module-linked "#<procedure")
+(try-using-libtool-name "#<procedure")
+(try-using-sharlib-name "#<procedure")
+(ttyname "#<primitive-procedure")
+(tzset "#<primitive-procedure")
+(umask "#<primitive-procedure")
+(uname "#<primitive-procedure")
+(undefine "")
+(unhash-name "#<primitive-procedure")
+(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")
+(unintern-symbol "#<primitive-procedure")
+(unlock-mutex "#<primitive-procedure")
+(unmask-signals "#<primitive-procedure")
+(unmemoize "#<primitive-procedure")
+(unread-char "#<primitive-procedure")
+(unread-string "#<primitive-procedure")
+(unspecified? "#<procedure")
+(use-emacs-interface "")
+(use-modules "")
+(use-syntax "")
+(using-readline? "#<procedure-with-setter>")
+(usleep "#<primitive-procedure")
+(utag_asubr "")
+(utag_bvect "")
+(utag_byvect "")
+(utag_closure "")
+(utag_cvect "")
+(utag_cxr "")
+(utag_dvect "")
+(utag_flag_base "")
+(utag_fvect "")
+(utag_immediate_char "")
+(utag_immediate_integer "")
+(utag_ivect "")
+(utag_lsubr "")
+(utag_lsubr_2 "")
+(utag_pair "")
+(utag_port_base "")
+(utag_rpsubr "")
+(utag_smob_base "")
+(utag_string "")
+(utag_struct_base "")
+(utag_subr_0 "")
+(utag_subr_1 "")
+(utag_subr_1o "")
+(utag_subr_2 "")
+(utag_subr_2o "")
+(utag_subr_3 "")
+(utag_substring "")
+(utag_svect "")
+(utag_symbol "")
+(utag_uvect "")
+(utag_vector "")
+(utag_wvect "")
+(utime "#<primitive-procedure")
+(utsname:machine "#<procedure")
+(utsname:nodename "#<procedure")
+(utsname:release "#<procedure")
+(utsname:sysname "#<procedure")
+(utsname:version "#<procedure")
+(values "#<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")
+(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")
+(while "")
+(with-error-to-file "#<procedure")
+(with-error-to-port "#<procedure")
+(with-error-to-string "#<procedure")
+(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")
+(write-line "#<primitive-procedure")
+(xformer-table "")
+(yield "#<primitive-procedure")
+(zero? "#<primitive-procedure")
+) ;; end of scheme
+(C     
+(collisionp B)
+(coop_abort T)
+(coop_condition_variable_destroy T)
+(coop_condition_variable_init T)
+(coop_condition_variable_signal T)
+(coop_condition_variable_timed_wait_mutex T)
+(coop_condition_variable_wait_mutex T)
+(coop_create T)
+(coop_getspecific T)
+(coop_global_allq B)
+(coop_global_curr B)
+(coop_global_runq B)
+(coop_global_sleepq B)
+(coop_init T)
+(coop_join T)
+(coop_key_create T)
+(coop_key_delete T)
+(coop_mutex_destroy T)
+(coop_mutex_init T)
+(coop_mutex_lock T)
+(coop_mutex_trylock T)
+(coop_mutex_unlock T)
+(coop_new_condition_variable_init T)
+(coop_new_mutex_init T)
+(coop_next_runnable_thread T)
+(coop_qget T)
+(coop_qput T)
+(coop_setspecific T)
+(coop_sleephelp T)
+(coop_start T)
+(coop_timeout_qinsert T)
+(coop_tmp_queue B)
+(coop_wait_for_runnable_thread T)
+(coop_wait_for_runnable_thread_now T)
+(coop_yield T)
+(gdb_binding T)
+(gdb_eval T)
+(gdb_language D)
+(gdb_maybe_valid_type_p T)
+(gdb_options D)
+(gdb_output B)
+(gdb_output_length B)
+(gdb_print T)
+(gdb_read T)
+(gdb_result B)
+(gexceptfds B)
+(gh_append T)
+(gh_append2 T)
+(gh_append3 T)
+(gh_append4 T)
+(gh_apply T)
+(gh_bool2scm T)
+(gh_boolean_p T)
+(gh_caaar T)
+(gh_caadr T)
+(gh_caar T)
+(gh_cadar T)
+(gh_caddr T)
+(gh_cadr T)
+(gh_call0 T)
+(gh_call1 T)
+(gh_call2 T)
+(gh_call3 T)
+(gh_car T)
+(gh_catch T)
+(gh_cdaar T)
+(gh_cdadr T)
+(gh_cdar T)
+(gh_cddar T)
+(gh_cdddr T)
+(gh_cddr T)
+(gh_cdr T)
+(gh_char2scm T)
+(gh_char_p T)
+(gh_chars2byvect T)
+(gh_cons T)
+(gh_define T)
+(gh_display T)
+(gh_double2scm T)
+(gh_doubles2dvect T)
+(gh_doubles2scm T)
+(gh_enter T)
+(gh_eq_p T)
+(gh_equal_p T)
+(gh_eqv_p T)
+(gh_eval_file T)
+(gh_eval_file_with_catch T)
+(gh_eval_file_with_standard_handler T)
+(gh_eval_str T)
+(gh_eval_str_with_catch T)
+(gh_eval_str_with_stack_saving_handler T)
+(gh_eval_str_with_standard_handler T)
+(gh_exact_p T)
+(gh_floats2fvect T)
+(gh_get_substr T)
+(gh_inexact_p T)
+(gh_int2scm T)
+(gh_int2scmb T)
+(gh_ints2scm T)
+(gh_length T)
+(gh_list_p T)
+(gh_long2scm T)
+(gh_longs2ivect T)
+(gh_lookup T)
+(gh_make_vector T)
+(gh_module_lookup T)
+(gh_new_procedure T)
+(gh_new_procedure0_0 T)
+(gh_new_procedure0_1 T)
+(gh_new_procedure0_2 T)
+(gh_new_procedure1_0 T)
+(gh_new_procedure1_1 T)
+(gh_new_procedure1_2 T)
+(gh_new_procedure2_0 T)
+(gh_new_procedure2_1 T)
+(gh_new_procedure2_2 T)
+(gh_new_procedure3_0 T)
+(gh_new_procedure4_0 T)
+(gh_new_procedure5_0 T)
+(gh_newline T)
+(gh_null_p T)
+(gh_number_p T)
+(gh_pair_p T)
+(gh_procedure_p T)
+(gh_repl T)
+(gh_scm2bool T)
+(gh_scm2char T)
+(gh_scm2chars T)
+(gh_scm2double T)
+(gh_scm2doubles T)
+(gh_scm2floats T)
+(gh_scm2int T)
+(gh_scm2long T)
+(gh_scm2longs T)
+(gh_scm2newstr T)
+(gh_scm2shorts T)
+(gh_scm2ulong T)
+(gh_set_car_x T)
+(gh_set_cdr_x T)
+(gh_set_substr T)
+(gh_shorts2svect T)
+(gh_standard_handler T)
+(gh_str02scm T)
+(gh_str2scm T)
+(gh_string_equal_p T)
+(gh_string_p T)
+(gh_symbol2newstr T)
+(gh_symbol2scm T)
+(gh_symbol_p T)
+(gh_ulong2scm T)
+(gh_ulongs2uvect T)
+(gh_uniform_vector_length T)
+(gh_uniform_vector_ref T)
+(gh_vector_length T)
+(gh_vector_p T)
+(gh_vector_ref T)
+(gh_vector_set_x T)
+(gh_write T)
+(gnfds B)
+(greadfds B)
+(gwritefds B)
+(lt_dladderror T)
+(lt_dladdsearchdir T)
+(lt_dlcaller_get_data T)
+(lt_dlcaller_register T)
+(lt_dlcaller_set_data T)
+(lt_dlclose T)
+(lt_dlerror T)
+(lt_dlexit T)
+(lt_dlforeach T)
+(lt_dlfree D)
+(lt_dlgetinfo T)
+(lt_dlgetsearchpath T)
+(lt_dlhandle_next T)
+(lt_dlinit T)
+(lt_dlisresident T)
+(lt_dlloader_add T)
+(lt_dlloader_data T)
+(lt_dlloader_find T)
+(lt_dlloader_name T)
+(lt_dlloader_next T)
+(lt_dlloader_remove T)
+(lt_dlmakeresident T)
+(lt_dlmalloc D)
+(lt_dlmutex_register T)
+(lt_dlopen T)
+(lt_dlopenext T)
+(lt_dlpreload T)
+(lt_dlpreload_default T)
+(lt_dlseterror T)
+(lt_dlsetsearchpath T)
+(lt_dlsym T)
+(rexceptfds B)
+(rreadfds B)
+(rwritefds B)
+(scm_2ulong2big T)
+(scm_I_am_dead B)
+(scm_abs T)
+(scm_accept T)
+(scm_access T)
+(scm_acons T)
+(scm_acosh T)
+(scm_add_feature T)
+(scm_add_hook_x T)
+(scm_add_to_port_table T)
+(scm_addbig T)
+(scm_adjbig T)
+(scm_after_gc_c_hook B)
+(scm_after_gc_hook B)
+(scm_after_sweep_c_hook B)
+(scm_aind T)
+(scm_alarm T)
+(scm_alloc_struct T)
+(scm_angle T)
+(scm_append T)
+(scm_append_x T)
+(scm_apply T)
+(scm_apply_generic T)
+(scm_apply_with_dynamic_root T)
+(scm_array_contents T)
+(scm_array_copy_x T)
+(scm_array_dimensions T)
+(scm_array_equal_p T)
+(scm_array_fill_int T)
+(scm_array_fill_x T)
+(scm_array_for_each T)
+(scm_array_identity T)
+(scm_array_in_bounds_p T)
+(scm_array_index_map_x T)
+(scm_array_map_x T)
+(scm_array_p T)
+(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_assoc_ref T)
+(scm_assoc_remove_x T)
+(scm_assoc_set_x T)
+(scm_assq T)
+(scm_assq_ref T)
+(scm_assq_remove_x T)
+(scm_assq_set_x T)
+(scm_assv T)
+(scm_assv_ref T)
+(scm_assv_remove_x T)
+(scm_assv_set_x T)
+(scm_async T)
+(scm_async_click T)
+(scm_async_mark T)
+(scm_asyncs_pending_p D)
+(scm_atanh T)
+(scm_backtrace T)
+(scm_badargsp T)
+(scm_basename T)
+(scm_before_gc_c_hook B)
+(scm_before_mark_c_hook B)
+(scm_before_sweep_c_hook B)
+(scm_big2dbl T)
+(scm_big2inum T)
+(scm_big_and T)
+(scm_big_ior T)
+(scm_big_test T)
+(scm_big_xor T)
+(scm_bigcomp T)
+(scm_bigequal T)
+(scm_bigprint T)
+(scm_bind T)
+(scm_bit_count T)
+(scm_bit_count_star T)
+(scm_bit_extract T)
+(scm_bit_invert_x T)
+(scm_bit_position T)
+(scm_bit_set_star_x T)
+(scm_block_gc D)
+(scm_body_thunk T)
+(scm_boolean_p T)
+(scm_boot_guile T)
+(scm_boot_guile_1_live D)
+(scm_builtin_bindings T)
+(scm_builtin_variable T)
+(scm_builtin_weak_bindings T)
+(scm_c_default_rstate T)
+(scm_c_exp1 T)
+(scm_c_hook_add T)
+(scm_c_hook_init T)
+(scm_c_hook_remove T)
+(scm_c_hook_run T)
+(scm_c_make_keyword T)
+(scm_c_make_rstate T)
+(scm_c_normal01 T)
+(scm_c_random T)
+(scm_c_random_bignum T)
+(scm_c_run_hook T)
+(scm_c_uniform01 T)
+(scm_call_catching_errors T)
+(scm_call_continuation T)
+(scm_call_generic_0 T)
+(scm_call_generic_1 T)
+(scm_call_generic_2 T)
+(scm_call_generic_3 T)
+(scm_call_with_dynamic_root T)
+(scm_call_with_input_string T)
+(scm_call_with_new_thread T)
+(scm_call_with_output_string T)
+(scm_can_use_top_level_lookup_closure_var B)
+(scm_casei_streq T)
+(scm_catch T)
+(scm_cellp T)
+(scm_cells_allocated D)
+(scm_ceval T)
+(scm_ceval_ptr B)
+(scm_change_object_class B)
+(scm_char_alphabetic_p T)
+(scm_char_ci_eq_p T)
+(scm_char_ci_geq_p T)
+(scm_char_ci_gr_p T)
+(scm_char_ci_leq_p T)
+(scm_char_ci_less_p T)
+(scm_char_downcase T)
+(scm_char_eq_p T)
+(scm_char_geq_p T)
+(scm_char_gr_p T)
+(scm_char_is_both_p T)
+(scm_char_leq_p T)
+(scm_char_less_p T)
+(scm_char_lower_case_p T)
+(scm_char_numeric_p T)
+(scm_char_p T)
+(scm_char_ready_p T)
+(scm_char_to_integer T)
+(scm_char_upcase T)
+(scm_char_upper_case_p T)
+(scm_char_whitespace_p T)
+(scm_charnames D)
+(scm_charnums R)
+(scm_chdir T)
+(scm_check_apply_p B)
+(scm_check_entry_p B)
+(scm_check_exit_p B)
+(scm_chmod T)
+(scm_chown T)
+(scm_class_boolean B)
+(scm_class_char B)
+(scm_class_complex B)
+(scm_class_integer B)
+(scm_class_null B)
+(scm_class_of T)
+(scm_class_pair B)
+(scm_class_primitive_generic B)
+(scm_class_procedure B)
+(scm_class_procedure_with_setter B)
+(scm_class_real B)
+(scm_class_string B)
+(scm_class_symbol B)
+(scm_class_unknown B)
+(scm_class_vector B)
+(scm_clear_registered_modules T)
+(scm_close T)
+(scm_close_all_ports_except T)
+(scm_close_input_port T)
+(scm_close_output_port T)
+(scm_close_port T)
+(scm_closedir T)
+(scm_closure T)
+(scm_closure_p T)
+(scm_compile_shell_switches T)
+(scm_complex_equalp T)
+(scm_connect T)
+(scm_cons T)
+(scm_cons2 T)
+(scm_cons_source T)
+(scm_cons_star T)
+(scm_copy_big_dec T)
+(scm_copy_file T)
+(scm_copy_fluids T)
+(scm_copy_random_state T)
+(scm_copy_smaller T)
+(scm_copy_tree T)
+(scm_copybig T)
+(scm_count_argv T)
+(scm_create_hook T)
+(scm_critical_section_mutex B)
+(scm_ctermid T)
+(scm_current_error_port T)
+(scm_current_input_port T)
+(scm_current_load_port T)
+(scm_current_output_port T)
+(scm_current_time T)
+(scm_cvref T)
+(scm_dapply T)
+(scm_dbl2big T)
+(scm_dblprec B)
+(scm_debug_eframe_size B)
+(scm_debug_mode B)
+(scm_debug_object_p T)
+(scm_debug_options T)
+(scm_debug_opts D)
+(scm_default_init_heap_size_1 D)
+(scm_default_init_heap_size_2 D)
+(scm_default_max_segment_size D)
+(scm_default_min_yield_1 D)
+(scm_default_min_yield_2 D)
+(scm_definedp T)
+(scm_delete T)
+(scm_delete1_x T)
+(scm_delete_file T)
+(scm_delete_x T)
+(scm_delq T)
+(scm_delq1_x T)
+(scm_delq_x T)
+(scm_delv T)
+(scm_delv1_x T)
+(scm_delv_x T)
+(scm_deval T)
+(scm_deval_args T)
+(scm_difference T)
+(scm_dimensions_to_uniform_array T)
+(scm_directory_stream_p T)
+(scm_dirname T)
+(scm_display T)
+(scm_display_application T)
+(scm_display_backtrace T)
+(scm_display_error T)
+(scm_display_error_message T)
+(scm_divbigdig T)
+(scm_divide T)
+(scm_done_malloc T)
+(scm_dot_string B)
+(scm_doubly_weak_hash_table_p T)
+(scm_dowinds T)
+(scm_downcase T)
+(scm_drain_input T)
+(scm_dup_to_fdes T)
+(scm_dynamic_args_call T)
+(scm_dynamic_call T)
+(scm_dynamic_func T)
+(scm_dynamic_link T)
+(scm_dynamic_object_p T)
+(scm_dynamic_root T)
+(scm_dynamic_unlink T)
+(scm_dynamic_wind T)
+(scm_enclose_array T)
+(scm_end_input T)
+(scm_ensure_user_module T)
+(scm_entity_p T)
+(scm_env_top_level T)
+(scm_environ T)
+(scm_eof_object_p T)
+(scm_eq_p T)
+(scm_equal_p T)
+(scm_eqv_p T)
+(scm_error T)
+(scm_error_revive_threads T)
+(scm_error_scm T)
+(scm_eval T)
+(scm_eval2 T)
+(scm_eval_0str T)
+(scm_eval_3 T)
+(scm_eval_args T)
+(scm_eval_body T)
+(scm_eval_car T)
+(scm_eval_options_interface T)
+(scm_eval_opts D)
+(scm_eval_stack B)
+(scm_eval_string T)
+(scm_eval_x T)
+(scm_evaluator_trap_table D)
+(scm_evaluator_traps T)
+(scm_even_p T)
+(scm_evict_ports T)
+(scm_exact_p T)
+(scm_exact_to_inexact T)
+(scm_execl T)
+(scm_execle T)
+(scm_execlp T)
+(scm_exit_status T)
+(scm_expmem D)
+(scm_f_apply B)
+(scm_f_gsubr_apply B)
+(scm_fcntl T)
+(scm_fdes_to_port T)
+(scm_fdes_to_ports T)
+(scm_fdopen T)
+(scm_fileno T)
+(scm_fill_input T)
+(scm_find_executable T)
+(scm_finish_srcprop T)
+(scm_fluid_p T)
+(scm_fluid_ref T)
+(scm_fluid_set_x T)
+(scm_flush T)
+(scm_flush_all_ports T)
+(scm_flush_ws T)
+(scm_for_each T)
+(scm_force T)
+(scm_force_output T)
+(scm_fork T)
+(scm_frame_arguments T)
+(scm_frame_evaluating_args_p T)
+(scm_frame_next T)
+(scm_frame_number T)
+(scm_frame_overflow_p T)
+(scm_frame_p T)
+(scm_frame_previous T)
+(scm_frame_procedure T)
+(scm_frame_procedure_p T)
+(scm_frame_real_p T)
+(scm_frame_source T)
+(scm_free0 T)
+(scm_free_print_state T)
+(scm_free_subr_entry T)
+(scm_freelist D)
+(scm_freelist2 D)
+(scm_fseek T)
+(scm_fsync T)
+(scm_ftell T)
+(scm_gc T)
+(scm_gc_async B)
+(scm_gc_cells_collected B)
+(scm_gc_end T)
+(scm_gc_for_newcell T)
+(scm_gc_heap_lock D)
+(scm_gc_malloc_collected B)
+(scm_gc_mark T)
+(scm_gc_ports_collected B)
+(scm_gc_rt B)
+(scm_gc_start T)
+(scm_gc_stats T)
+(scm_gc_sweep T)
+(scm_gc_time_taken D)
+(scm_gc_yield B)
+(scm_gcd T)
+(scm_gensym T)
+(scm_geq_p T)
+(scm_get_internal_real_time T)
+(scm_get_internal_run_time T)
+(scm_get_meta_args T)
+(scm_get_one_zombie T)
+(scm_get_print_state T)
+(scm_getc T)
+(scm_getcwd T)
+(scm_getegid T)
+(scm_getenv T)
+(scm_geteuid T)
+(scm_getgid T)
+(scm_getgrgid T)
+(scm_getgroups T)
+(scm_gethost T)
+(scm_getnet T)
+(scm_getpeername T)
+(scm_getpgrp T)
+(scm_getpid T)
+(scm_getppid T)
+(scm_getproto T)
+(scm_getpwuid T)
+(scm_getserv T)
+(scm_getsockname T)
+(scm_getsockopt T)
+(scm_gettimeofday T)
+(scm_getuid T)
+(scm_gmtime T)
+(scm_gr_p T)
+(scm_grow_tok_buf T)
+(scm_gsubr_apply T)
+(scm_guard T)
+(scm_handle_by_message T)
+(scm_handle_by_message_noexit T)
+(scm_handle_by_proc T)
+(scm_handle_by_proc_catching_all T)
+(scm_handle_by_throw T)
+(scm_hash T)
+(scm_hash_create_handle_x T)
+(scm_hash_fn_create_handle_x T)
+(scm_hash_fn_get_handle T)
+(scm_hash_fn_ref T)
+(scm_hash_fn_remove_x T)
+(scm_hash_fn_set_x T)
+(scm_hash_fold T)
+(scm_hash_get_handle T)
+(scm_hash_ref T)
+(scm_hash_remove_x T)
+(scm_hash_set_x T)
+(scm_hasher T)
+(scm_hashq T)
+(scm_hashq_create_handle_x T)
+(scm_hashq_get_handle T)
+(scm_hashq_ref T)
+(scm_hashq_remove_x T)
+(scm_hashq_set_x T)
+(scm_hashv T)
+(scm_hashv_create_handle_x T)
+(scm_hashv_get_handle T)
+(scm_hashv_ref T)
+(scm_hashv_remove_x T)
+(scm_hashv_set_x T)
+(scm_hashx_create_handle_x T)
+(scm_hashx_get_handle T)
+(scm_hashx_ref T)
+(scm_hashx_remove_x T)
+(scm_hashx_set_x T)
+(scm_heap_org B)
+(scm_heap_table D)
+(scm_hook_empty_p T)
+(scm_hook_p T)
+(scm_hook_to_list T)
+(scm_htonl T)
+(scm_htons T)
+(scm_i_copy_rstate T)
+(scm_i_dummy B)
+(scm_i_init_rstate T)
+(scm_i_make_class_object T)
+(scm_i_procedure_arity T)
+(scm_i_uniform32 T)
+(scm_ice_9_already_loaded D)
+(scm_igc T)
+(scm_ihash T)
+(scm_ihashq T)
+(scm_ihashv T)
+(scm_iint2str T)
+(scm_ilength T)
+(scm_ilookup T)
+(scm_imag_part T)
+(scm_inet_aton T)
+(scm_inet_makeaddr T)
+(scm_inet_netof T)
+(scm_inet_ntoa T)
+(scm_inexact_p T)
+(scm_inexact_to_exact T)
+(scm_init_alist T)
+(scm_init_arbiters T)
+(scm_init_async T)
+(scm_init_backtrace T)
+(scm_init_boolean T)
+(scm_init_chars T)
+(scm_init_continuations T)
+(scm_init_debug T)
+(scm_init_dynamic_linking T)
+(scm_init_dynwind T)
+(scm_init_eq T)
+(scm_init_error T)
+(scm_init_eval T)
+(scm_init_evalext T)
+(scm_init_feature T)
+(scm_init_filesys T)
+(scm_init_fluids T)
+(scm_init_fports T)
+(scm_init_gc T)
+(scm_init_gdbint T)
+(scm_init_gsubr T)
+(scm_init_guardian T)
+(scm_init_hash T)
+(scm_init_hashtab T)
+(scm_init_hooks T)
+(scm_init_ioext T)
+(scm_init_iselect T)
+(scm_init_keywords T)
+(scm_init_lang T)
+(scm_init_list T)
+(scm_init_load T)
+(scm_init_load_path T)
+(scm_init_macros T)
+(scm_init_mallocs T)
+(scm_init_modules T)
+(scm_init_net_db T)
+(scm_init_numbers T)
+(scm_init_objects T)
+(scm_init_objprop T)
+(scm_init_options T)
+(scm_init_opts T)
+(scm_init_pairs T)
+(scm_init_ports T)
+(scm_init_posix T)
+(scm_init_print T)
+(scm_init_procprop T)
+(scm_init_procs T)
+(scm_init_ramap T)
+(scm_init_random T)
+(scm_init_read T)
+(scm_init_regex_posix T)
+(scm_init_root T)
+(scm_init_scmsigs T)
+(scm_init_script T)
+(scm_init_simpos T)
+(scm_init_socket T)
+(scm_init_sort T)
+(scm_init_srcprop T)
+(scm_init_stackchk T)
+(scm_init_stacks T)
+(scm_init_stime T)
+(scm_init_storage T)
+(scm_init_strings T)
+(scm_init_strop T)
+(scm_init_strorder T)
+(scm_init_strports T)
+(scm_init_struct T)
+(scm_init_subr_table T)
+(scm_init_symbols T)
+(scm_init_tag T)
+(scm_init_threads T)
+(scm_init_throw T)
+(scm_init_unif T)
+(scm_init_variable T)
+(scm_init_vectors T)
+(scm_init_version T)
+(scm_init_vports T)
+(scm_init_weaks T)
+(scm_initialized_p D)
+(scm_input_port_p T)
+(scm_integer_expt T)
+(scm_integer_length T)
+(scm_integer_p T)
+(scm_integer_to_char T)
+(scm_intern T)
+(scm_intern0 T)
+(scm_intern_obarray T)
+(scm_intern_obarray_soft T)
+(scm_intern_symbol T)
+(scm_internal_catch T)
+(scm_internal_cwdr T)
+(scm_internal_dynamic_wind T)
+(scm_internal_hash_fold T)
+(scm_internal_lazy_catch T)
+(scm_internal_parse_path T)
+(scm_internal_select T)
+(scm_internal_stack_catch T)
+(scm_internal_with_fluids T)
+(scm_intprint T)
+(scm_ints_disabled D)
+(scm_iprin1 T)
+(scm_iprlist T)
+(scm_ipruk T)
+(scm_isatty_p T)
+(scm_istr2bve T)
+(scm_istr2flo T)
+(scm_istr2int T)
+(scm_istring2number T)
+(scm_isymnames D)
+(scm_ithrow T)
+(scm_join_thread T)
+(scm_keyword_dash_symbol T)
+(scm_keyword_p T)
+(scm_kill T)
+(scm_last_pair T)
+(scm_last_stack_frame T)
+(scm_lazy_catch T)
+(scm_lcm T)
+(scm_length T)
+(scm_leq_p T)
+(scm_less_p T)
+(scm_lfwrite T)
+(scm_link T)
+(scm_lisp_nil B)
+(scm_lisp_t B)
+(scm_list T)
+(scm_list_cdr_set_x T)
+(scm_list_copy T)
+(scm_list_head T)
+(scm_list_p T)
+(scm_list_ref T)
+(scm_list_set_x T)
+(scm_list_tail T)
+(scm_list_to_uniform_array T)
+(scm_listen T)
+(scm_listify T)
+(scm_listofnullstr B)
+(scm_lnaof T)
+(scm_load_scheme_module T)
+(scm_load_startup_files T)
+(scm_local_eval T)
+(scm_localtime T)
+(scm_lock_mutex T)
+(scm_logand T)
+(scm_logbit_p T)
+(scm_logcount T)
+(scm_logior T)
+(scm_lognot T)
+(scm_logtest T)
+(scm_logxor T)
+(scm_long2big T)
+(scm_long2num T)
+(scm_long_long2big T)
+(scm_long_long2num T)
+(scm_lookupcar T)
+(scm_lreadparen T)
+(scm_lreadr T)
+(scm_lreadrecparen T)
+(scm_lstat T)
+(scm_m_0_cond T)
+(scm_m_0_ify T)
+(scm_m_1_ify T)
+(scm_m_and T)
+(scm_m_apply T)
+(scm_m_atbind T)
+(scm_m_atfop T)
+(scm_m_begin T)
+(scm_m_case T)
+(scm_m_cond T)
+(scm_m_cont T)
+(scm_m_define T)
+(scm_m_delay T)
+(scm_m_do T)
+(scm_m_expand_body T)
+(scm_m_generalized_set_x T)
+(scm_m_if T)
+(scm_m_lambda T)
+(scm_m_let T)
+(scm_m_letrec T)
+(scm_m_letstar T)
+(scm_m_nil_cond T)
+(scm_m_nil_ify T)
+(scm_m_or T)
+(scm_m_quasiquote T)
+(scm_m_quote T)
+(scm_m_set_x T)
+(scm_m_t_ify T)
+(scm_m_undefine T)
+(scm_m_while T)
+(scm_macro_name T)
+(scm_macro_p T)
+(scm_macro_transformer T)
+(scm_macro_type T)
+(scm_macroexp T)
+(scm_magnitude T)
+(scm_major_version T)
+(scm_makacro T)
+(scm_makcclo T)
+(scm_make_arbiter T)
+(scm_make_class_object T)
+(scm_make_complex T)
+(scm_make_condition_variable T)
+(scm_make_cont T)
+(scm_make_debugobj T)
+(scm_make_doubly_weak_hash_table T)
+(scm_make_extended_class B)
+(scm_make_fluid T)
+(scm_make_fptob T)
+(scm_make_gsubr T)
+(scm_make_gsubr_with_generic T)
+(scm_make_guardian T)
+(scm_make_hook T)
+(scm_make_hook_with_name T)
+(scm_make_initial_fluids T)
+(scm_make_keyword_from_dash_symbol T)
+(scm_make_memoized T)
+(scm_make_module T)
+(scm_make_mutex T)
+(scm_make_polar T)
+(scm_make_port_classes B)
+(scm_make_port_type T)
+(scm_make_print_state T)
+(scm_make_procedure_with_setter T)
+(scm_make_ra T)
+(scm_make_real T)
+(scm_make_rectangular T)
+(scm_make_regexp T)
+(scm_make_root T)
+(scm_make_sfptob T)
+(scm_make_shared_array T)
+(scm_make_shared_substring T)
+(scm_make_smob T)
+(scm_make_smob_type T)
+(scm_make_smob_type_mfpe T)
+(scm_make_soft_port T)
+(scm_make_srcprops T)
+(scm_make_stack T)
+(scm_make_stptob T)
+(scm_make_string T)
+(scm_make_struct T)
+(scm_make_struct_layout T)
+(scm_make_subclass_object T)
+(scm_make_subr T)
+(scm_make_subr_opt T)
+(scm_make_subr_with_generic T)
+(scm_make_synt T)
+(scm_make_undefined_variable T)
+(scm_make_uve T)
+(scm_make_variable T)
+(scm_make_vector T)
+(scm_make_vtable_vtable T)
+(scm_make_weak_key_hash_table T)
+(scm_make_weak_value_hash_table T)
+(scm_make_weak_vector T)
+(scm_makfrom0str T)
+(scm_makfrom0str_opt T)
+(scm_makfromstr T)
+(scm_makfromstrs T)
+(scm_makmacro T)
+(scm_makmmacro T)
+(scm_makprom T)
+(scm_makstr T)
+(scm_malloc_obj T)
+(scm_mallocated D)
+(scm_map T)
+(scm_mark0 T)
+(scm_mark_locations T)
+(scm_mark_subr_table T)
+(scm_markcdr T)
+(scm_markstream T)
+(scm_mask_ints D)
+(scm_mask_signals T)
+(scm_masktab B)
+(scm_master_freelist D)
+(scm_master_freelist2 D)
+(scm_max T)
+(scm_max_segment_size B)
+(scm_mcache_compute_cmethod T)
+(scm_mcache_lookup_cmethod T)
+(scm_member T)
+(scm_memoize_method B)
+(scm_memoized_environment T)
+(scm_memoized_p T)
+(scm_memory_error T)
+(scm_memq T)
+(scm_memv T)
+(scm_merge T)
+(scm_merge_x T)
+(scm_metaclass_operator B)
+(scm_metaclass_standard B)
+(scm_min T)
+(scm_minor_version T)
+(scm_misc_error T)
+(scm_mkbig T)
+(scm_mkdir T)
+(scm_mknod T)
+(scm_mkstrport T)
+(scm_mktime T)
+(scm_mode_bits T)
+(scm_module_lookup_closure T)
+(scm_modulo T)
+(scm_mtrigger B)
+(scm_mulbig T)
+(scm_must_free T)
+(scm_must_malloc T)
+(scm_must_realloc T)
+(scm_n_charnames D)
+(scm_n_heap_segs D)
+(scm_nconc2last T)
+(scm_negative_p T)
+(scm_newline T)
+(scm_nice T)
+(scm_nil_car T)
+(scm_nil_cdr T)
+(scm_nil_cons T)
+(scm_nil_eq T)
+(scm_no_applicable_method B)
+(scm_noop T)
+(scm_normbig T)
+(scm_not T)
+(scm_ntohl T)
+(scm_ntohs T)
+(scm_null T)
+(scm_null_p T)
+(scm_num2dbl T)
+(scm_num2long T)
+(scm_num2long_long T)
+(scm_num2ulong T)
+(scm_num_eq_p T)
+(scm_num_overflow T)
+(scm_number_p T)
+(scm_number_to_string T)
+(scm_numptob B)
+(scm_numsmob B)
+(scm_object_address T)
+(scm_object_properties T)
+(scm_object_property T)
+(scm_odd_p T)
+(scm_open T)
+(scm_open_fdes T)
+(scm_open_file T)
+(scm_opendir T)
+(scm_operator_p T)
+(scm_options T)
+(scm_out_of_range T)
+(scm_out_of_range_pos T)
+(scm_output_port_p T)
+(scm_pair_p T)
+(scm_parse_path T)
+(scm_pause T)
+(scm_peek_char T)
+(scm_permanent_object T)
+(scm_pipe T)
+(scm_port_class D)
+(scm_port_closed_p T)
+(scm_port_column T)
+(scm_port_filename T)
+(scm_port_line T)
+(scm_port_mode T)
+(scm_port_non_buffer T)
+(scm_port_print T)
+(scm_port_revealed T)
+(scm_port_table B)
+(scm_port_table_room D)
+(scm_port_table_size D)
+(scm_port_with_print_state T)
+(scm_ports_prehistory T)
+(scm_positive_p T)
+(scm_post_boot_init_modules T)
+(scm_primitive_exit T)
+(scm_primitive_load T)
+(scm_primitive_load_path T)
+(scm_primitive_move_to_fdes T)
+(scm_prin1 T)
+(scm_print_carefully_p B)
+(scm_print_complex T)
+(scm_print_options T)
+(scm_print_opts D)
+(scm_print_port_mode T)
+(scm_print_real T)
+(scm_print_state_vtable B)
+(scm_print_struct T)
+(scm_printer_apply T)
+(scm_procedure T)
+(scm_procedure_documentation T)
+(scm_procedure_environment T)
+(scm_procedure_name T)
+(scm_procedure_p T)
+(scm_procedure_properties T)
+(scm_procedure_property T)
+(scm_procedure_source T)
+(scm_procedure_with_setter_p T)
+(scm_product T)
+(scm_program_arguments T)
+(scm_promise_p T)
+(scm_protect_object T)
+(scm_pseudolong T)
+(scm_ptobs B)
+(scm_putc T)
+(scm_putenv T)
+(scm_puts T)
+(scm_quotient T)
+(scm_ra2contig T)
+(scm_ra_difference T)
+(scm_ra_divide T)
+(scm_ra_eqp T)
+(scm_ra_greqp T)
+(scm_ra_grp T)
+(scm_ra_leqp T)
+(scm_ra_lessp T)
+(scm_ra_matchp T)
+(scm_ra_product T)
+(scm_ra_set_contp T)
+(scm_ra_sum T)
+(scm_raequal T)
+(scm_raise T)
+(scm_ramapc T)
+(scm_random T)
+(scm_random_exp T)
+(scm_random_hollow_sphere_x T)
+(scm_random_normal T)
+(scm_random_normal_vector_x T)
+(scm_random_solid_sphere_x T)
+(scm_random_uniform T)
+(scm_raprin1 T)
+(scm_read T)
+(scm_read_0str T)
+(scm_read_and_eval_x T)
+(scm_read_char T)
+(scm_read_delimited_x T)
+(scm_read_hash_extend T)
+(scm_read_line T)
+(scm_read_only_string_p T)
+(scm_read_options T)
+(scm_read_opts D)
+(scm_read_token T)
+(scm_readdir T)
+(scm_readlink T)
+(scm_real_equalp T)
+(scm_real_p T)
+(scm_real_part T)
+(scm_recv T)
+(scm_recvfrom T)
+(scm_redirect_port T)
+(scm_regexp_exec T)
+(scm_regexp_p T)
+(scm_register_module_xxx T)
+(scm_registered_modules T)
+(scm_release_arbiter T)
+(scm_remainder T)
+(scm_remember T)
+(scm_remove_from_port_table T)
+(scm_remove_hook_x T)
+(scm_rename T)
+(scm_report_stack_overflow T)
+(scm_reset_hook_x T)
+(scm_resolve_module T)
+(scm_restore_signals T)
+(scm_restricted_vector_sort_x T)
+(scm_return_first T)
+(scm_return_first_int T)
+(scm_revealed_count T)
+(scm_reverse T)
+(scm_reverse_lookup T)
+(scm_reverse_x T)
+(scm_rewinddir T)
+(scm_rmdir T)
+(scm_round T)
+(scm_run_asyncs T)
+(scm_run_hook T)
+(scm_s_bindings R)
+(scm_s_body R)
+(scm_s_clauses R)
+(scm_s_expression R)
+(scm_s_formals R)
+(scm_s_set_x R)
+(scm_s_test R)
+(scm_s_variable R)
+(scm_search_path T)
+(scm_seed_to_random_state T)
+(scm_seek T)
+(scm_select T)
+(scm_select_module T)
+(scm_selected_module T)
+(scm_send T)
+(scm_sendto T)
+(scm_set_car_x T)
+(scm_set_cdr_x T)
+(scm_set_current_error_port T)
+(scm_set_current_input_port T)
+(scm_set_current_output_port T)
+(scm_set_object_procedure_x T)
+(scm_set_object_properties_x T)
+(scm_set_object_property_x T)
+(scm_set_port_close T)
+(scm_set_port_column_x T)
+(scm_set_port_end_input T)
+(scm_set_port_equalp T)
+(scm_set_port_filename_x T)
+(scm_set_port_flush T)
+(scm_set_port_free T)
+(scm_set_port_input_waiting T)
+(scm_set_port_line_x T)
+(scm_set_port_mark T)
+(scm_set_port_print T)
+(scm_set_port_revealed_x T)
+(scm_set_port_seek T)
+(scm_set_port_truncate T)
+(scm_set_procedure_properties_x T)
+(scm_set_procedure_property_x T)
+(scm_set_program_arguments T)
+(scm_set_smob_equalp T)
+(scm_set_smob_free T)
+(scm_set_smob_mark T)
+(scm_set_smob_mfpe T)
+(scm_set_smob_print T)
+(scm_set_source_properties_x T)
+(scm_set_source_property_x T)
+(scm_set_struct_vtable_name_x T)
+(scm_setegid T)
+(scm_seteuid T)
+(scm_setgid T)
+(scm_setgrent T)
+(scm_sethost T)
+(scm_setlocale T)
+(scm_setnet T)
+(scm_setpgid T)
+(scm_setproto T)
+(scm_setpwent T)
+(scm_setserv T)
+(scm_setsid T)
+(scm_setsockopt T)
+(scm_setter T)
+(scm_setuid T)
+(scm_setvbuf T)
+(scm_shap2ra T)
+(scm_shared_array_increments T)
+(scm_shared_array_offset T)
+(scm_shared_array_root T)
+(scm_shell T)
+(scm_shell_usage T)
+(scm_shutdown T)
+(scm_sigaction T)
+(scm_signal_condition_variable T)
+(scm_simple_format T)
+(scm_single_thread_p T)
+(scm_sleep T)
+(scm_sloppy_assoc T)
+(scm_sloppy_assq T)
+(scm_sloppy_assv T)
+(scm_sloppy_member T)
+(scm_sloppy_memq T)
+(scm_sloppy_memv T)
+(scm_smob_class D)
+(scm_smob_free T)
+(scm_smob_prehistory T)
+(scm_smob_print T)
+(scm_smobs B)
+(scm_socket T)
+(scm_socketpair T)
+(scm_sort T)
+(scm_sort_list T)
+(scm_sort_list_x T)
+(scm_sort_x T)
+(scm_sorted_p T)
+(scm_source_properties T)
+(scm_source_property T)
+(scm_spawn_thread T)
+(scm_srcprops_to_plist T)
+(scm_stable_sort T)
+(scm_stable_sort_x T)
+(scm_stack_checking_enabled_p B)
+(scm_stack_id T)
+(scm_stack_length T)
+(scm_stack_p T)
+(scm_stack_ref T)
+(scm_stack_report T)
+(scm_stack_size T)
+(scm_stack_type B)
+(scm_standard_eval_closure T)
+(scm_start_stack T)
+(scm_stat T)
+(scm_status_exit_val T)
+(scm_status_stop_sig T)
+(scm_status_term_sig T)
+(scm_strerror T)
+(scm_strftime T)
+(scm_strhash T)
+(scm_string T)
+(scm_string_append T)
+(scm_string_capitalize T)
+(scm_string_capitalize_x T)
+(scm_string_ci_equal_p T)
+(scm_string_ci_geq_p T)
+(scm_string_ci_gr_p T)
+(scm_string_ci_leq_p T)
+(scm_string_ci_less_p T)
+(scm_string_ci_to_symbol T)
+(scm_string_copy T)
+(scm_string_downcase T)
+(scm_string_downcase_x T)
+(scm_string_equal_p T)
+(scm_string_fill_x T)
+(scm_string_geq_p T)
+(scm_string_gr_p T)
+(scm_string_index T)
+(scm_string_length T)
+(scm_string_leq_p T)
+(scm_string_less_p T)
+(scm_string_null_p T)
+(scm_string_p T)
+(scm_string_ref T)
+(scm_string_rindex T)
+(scm_string_set_x T)
+(scm_string_to_list T)
+(scm_string_to_number T)
+(scm_string_to_obarray_symbol T)
+(scm_string_to_symbol T)
+(scm_string_upcase T)
+(scm_string_upcase_x T)
+(scm_strport_to_string T)
+(scm_strprint_obj T)
+(scm_strptime T)
+(scm_struct_create_handle T)
+(scm_struct_free_0 T)
+(scm_struct_free_entity T)
+(scm_struct_free_light T)
+(scm_struct_free_standard T)
+(scm_struct_ihashq T)
+(scm_struct_init T)
+(scm_struct_p T)
+(scm_struct_ref T)
+(scm_struct_set_x T)
+(scm_struct_table B)
+(scm_struct_vtable T)
+(scm_struct_vtable_name T)
+(scm_struct_vtable_p T)
+(scm_struct_vtable_tag T)
+(scm_subr_p T)
+(scm_subr_table B)
+(scm_subr_table_room D)
+(scm_subr_table_size D)
+(scm_substring T)
+(scm_substring_fill_x T)
+(scm_substring_move_x T)
+(scm_sum T)
+(scm_swap_fluids T)
+(scm_swap_fluids_reverse T)
+(scm_switch_counter D)
+(scm_sym2ovcell T)
+(scm_sym2ovcell_soft T)
+(scm_sym2vcell T)
+(scm_sym_and B)
+(scm_sym_apply B)
+(scm_sym_apply_frame B)
+(scm_sym_arity B)
+(scm_sym_arrow B)
+(scm_sym_atapply B)
+(scm_sym_atcall_cc B)
+(scm_sym_begin B)
+(scm_sym_breakpoint B)
+(scm_sym_case B)
+(scm_sym_column B)
+(scm_sym_cond B)
+(scm_sym_copy B)
+(scm_sym_define B)
+(scm_sym_delay B)
+(scm_sym_do B)
+(scm_sym_dot B)
+(scm_sym_else B)
+(scm_sym_enter_frame B)
+(scm_sym_exit_frame B)
+(scm_sym_filename B)
+(scm_sym_if B)
+(scm_sym_lambda B)
+(scm_sym_let B)
+(scm_sym_letrec B)
+(scm_sym_letstar B)
+(scm_sym_line B)
+(scm_sym_name B)
+(scm_sym_or B)
+(scm_sym_quasiquote B)
+(scm_sym_quote B)
+(scm_sym_set_x B)
+(scm_sym_system_procedure B)
+(scm_sym_trace B)
+(scm_sym_unquote B)
+(scm_sym_uq_splicing B)
+(scm_symbol_binding T)
+(scm_symbol_bound_p T)
+(scm_symbol_fref T)
+(scm_symbol_fset_x T)
+(scm_symbol_hash T)
+(scm_symbol_interned_p T)
+(scm_symbol_p T)
+(scm_symbol_pref T)
+(scm_symbol_pset_x T)
+(scm_symbol_set_x T)
+(scm_symbol_to_string T)
+(scm_symbol_value0 T)
+(scm_symhash_dim D)
+(scm_symlink T)
+(scm_sync T)
+(scm_sys_atan2 T)
+(scm_sys_expt T)
+(scm_sys_library_dir T)
+(scm_sys_make_void_port T)
+(scm_sys_package_data_dir T)
+(scm_sys_protects B)
+(scm_sys_search_load_path T)
+(scm_sys_site_dir T)
+(scm_syserror T)
+(scm_syserror_msg T)
+(scm_sysintern T)
+(scm_sysintern0 T)
+(scm_sysintern0_no_module_lookup T)
+(scm_sysmissing T)
+(scm_system T)
+(scm_system_async T)
+(scm_system_async_mark T)
+(scm_system_module_env_p T)
+(scm_tables_prehistory T)
+(scm_tag T)
+(scm_take0str T)
+(scm_take_str T)
+(scm_tc16_array B)
+(scm_tc16_condvar B)
+(scm_tc16_debugobj B)
+(scm_tc16_dir B)
+(scm_tc16_dynamic_obj B)
+(scm_tc16_fluid B)
+(scm_tc16_hook B)
+(scm_tc16_keyword B)
+(scm_tc16_macro B)
+(scm_tc16_malloc B)
+(scm_tc16_memoized B)
+(scm_tc16_mutex B)
+(scm_tc16_port_with_ps B)
+(scm_tc16_promise B)
+(scm_tc16_regex B)
+(scm_tc16_root B)
+(scm_tc16_rstate B)
+(scm_tc16_srcprops B)
+(scm_tc16_thread B)
+(scm_tc16_variable B)
+(scm_tc16_void_port D)
+(scm_tcgetpgrp T)
+(scm_tcsetpgrp T)
+(scm_the_last_stack_fluid B)
+(scm_the_rng B)
+(scm_the_root_module T)
+(scm_thread_count D)
+(scm_thread_sleep T)
+(scm_thread_usleep T)
+(scm_threads_init T)
+(scm_threads_mark_stacks T)
+(scm_throw T)
+(scm_thunk_p T)
+(scm_times T)
+(scm_tmpnam T)
+(scm_top_level_env T)
+(scm_transpose_array T)
+(scm_truncate T)
+(scm_truncate_file T)
+(scm_try_arbiter T)
+(scm_ttyname T)
+(scm_tzset T)
+(scm_ulong2big T)
+(scm_ulong2num T)
+(scm_umask T)
+(scm_uname T)
+(scm_ungetc T)
+(scm_ungets T)
+(scm_unhash_name T)
+(scm_uniform_array_read_x T)
+(scm_uniform_array_write T)
+(scm_uniform_element_size T)
+(scm_uniform_vector_length T)
+(scm_uniform_vector_ref T)
+(scm_unintern_symbol T)
+(scm_unlock_mutex T)
+(scm_unmask_signals T)
+(scm_unmemocar T)
+(scm_unmemocopy T)
+(scm_unmemoize T)
+(scm_unprotect_object T)
+(scm_unread_char T)
+(scm_unread_string T)
+(scm_upcase T)
+(scm_usage_name D)
+(scm_usleep T)
+(scm_utime T)
+(scm_valid_oport_value_p T)
+(scm_var_random_state B)
+(scm_variable_bound_p T)
+(scm_variable_p T)
+(scm_variable_ref T)
+(scm_variable_set_x T)
+(scm_vector T)
+(scm_vector_equal_p T)
+(scm_vector_fill_x T)
+(scm_vector_length T)
+(scm_vector_move_left_x T)
+(scm_vector_move_right_x T)
+(scm_vector_p T)
+(scm_vector_ref T)
+(scm_vector_set_length_x T)
+(scm_vector_set_x T)
+(scm_vector_to_list T)
+(scm_version T)
+(scm_void_port T)
+(scm_wait_condition_variable T)
+(scm_waitpid T)
+(scm_weak_key_hash_table_p T)
+(scm_weak_value_hash_table_p T)
+(scm_weak_vector T)
+(scm_weak_vector_p T)
+(scm_weak_vectors B)
+(scm_weaks_prehistory T)
+(scm_with_fluids T)
+(scm_with_traps T)
+(scm_write T)
+(scm_write_char T)
+(scm_write_line T)
+(scm_wrong_num_args T)
+(scm_wrong_type_arg T)
+(scm_wrong_type_arg_msg T)
+(scm_wta T)
+(scm_yield T)
+(scm_your_base D)
+(scm_zero_p T)
+(terminating B)
+) ;; end of C
+)