Import guile-1.8 as multiple upstream tarball component

[lilypond.git] / guile18 / doc / guile-api.alist

diff --git a/guile18/doc/guile-api.alist b/guile18/doc/guile-api.alist
new file mode 100644 (file)
index 0000000..5f73cae
--- /dev/null
+++ b/guile18/doc/guile-api.alist
@@ -0,0 +1,3219 @@
+;;; generated 2002-05-12 05:25:39 UTC by scan-api -- do not edit!
+
+(
+(meta
+  (GUILE_LOAD_PATH . "")
+  (LTDL_LIBRARY_PATH . "")
+  (guile . "pre-inst-guile")
+  (libguileinterface . "15:0:0")
+  (sofile . "libguile/.libs/libguile.so.15.0.0")
+  (groups C+scheme embedded-libltdl libguile-internal gdb coop gh g-fdes r-fdes scm k POSIX math guile-C-API Scheme C)
+) ;; end of meta
+(interface
+($abs (groups math Scheme) (scan-data "#<primitive-procedure $abs>"))
+($acos (groups math Scheme) (scan-data "#<primitive-procedure $acos>"))
+($acosh (groups math Scheme) (scan-data "#<primitive-procedure $acosh>"))
+($asin (groups math Scheme) (scan-data "#<primitive-procedure $asin>"))
+($asinh (groups math Scheme) (scan-data "#<primitive-procedure $asinh>"))
+($atan (groups math Scheme) (scan-data "#<primitive-procedure $atan>"))
+($atan2 (groups math Scheme) (scan-data "#<primitive-procedure $atan2>"))
+($atanh (groups math Scheme) (scan-data "#<primitive-procedure $atanh>"))
+($cos (groups math Scheme) (scan-data "#<primitive-procedure $cos>"))
+($cosh (groups math Scheme) (scan-data "#<primitive-procedure $cosh>"))
+($exp (groups math Scheme) (scan-data "#<primitive-procedure $exp>"))
+($expt (groups math Scheme) (scan-data "#<primitive-procedure $expt>"))
+($log (groups math Scheme) (scan-data "#<primitive-procedure $log>"))
+($sin (groups math Scheme) (scan-data "#<primitive-procedure $sin>"))
+($sinh (groups math Scheme) (scan-data "#<primitive-procedure $sinh>"))
+($sqrt (groups math Scheme) (scan-data "#<primitive-procedure $sqrt>"))
+($tan (groups math Scheme) (scan-data "#<primitive-procedure $tan>"))
+($tanh (groups math Scheme) (scan-data "#<primitive-procedure $tanh>"))
+(%cond-expand-features (groups Scheme) (scan-data ""))
+(%cond-expand-table (groups Scheme) (scan-data ""))
+(%deliver-signals (groups Scheme) (scan-data "#<primitive-procedure %deliver-signals>"))
+(%get-pre-modules-obarray (groups Scheme) (scan-data "#<primitive-procedure %get-pre-modules-obarray>"))
+(%guile-build-info (groups Scheme) (scan-data ""))
+(%init-goops-builtins (groups Scheme) (scan-data "#<primitive-procedure %init-goops-builtins>"))
+(%init-rdelim-builtins (groups Scheme) (scan-data "#<primitive-procedure %init-rdelim-builtins>"))
+(%init-rw-builtins (groups Scheme) (scan-data "#<primitive-procedure %init-rw-builtins>"))
+(%library-dir (groups Scheme) (scan-data "#<primitive-procedure %library-dir>"))
+(%load-announce (groups Scheme) (scan-data "#<procedure %load-announce (file)>"))
+(%load-extensions (groups Scheme) (scan-data ""))
+(%load-hook (groups Scheme) (scan-data "#<procedure %load-announce (file)>"))
+(%load-path (groups Scheme) (scan-data ""))
+(%load-verbosely (groups Scheme) (scan-data ""))
+(%make-void-port (groups Scheme) (scan-data "#<primitive-procedure %make-void-port>"))
+(%module-public-interface (groups Scheme) (scan-data ""))
+(%nil (groups Scheme) (scan-data ""))
+(%package-data-dir (groups Scheme) (scan-data "#<primitive-procedure %package-data-dir>"))
+(%print-module (groups Scheme) (scan-data "#<procedure %print-module (mod port)>"))
+(%print-values (groups Scheme) (scan-data "#<primitive-procedure %print-values>"))
+(%search-load-path (groups Scheme) (scan-data "#<primitive-procedure %search-load-path>"))
+(%site-dir (groups Scheme) (scan-data "#<primitive-procedure %site-dir>"))
+(* (groups Scheme) (scan-data "#<primitive-procedure *>"))
+(*features* (groups Scheme) (scan-data ""))
+(*null-device* (groups Scheme) (scan-data ""))
+(*random-state* (groups Scheme) (scan-data ""))
+(*unspecified* (groups Scheme) (scan-data ""))
+(+ (groups Scheme) (scan-data "#<primitive-procedure +>"))
+(- (groups Scheme) (scan-data "#<primitive-procedure ->"))
+(->bool (groups Scheme) (scan-data "#<procedure ->bool (x)>"))
+(/ (groups Scheme) (scan-data "#<primitive-procedure />"))
+(1+ (groups Scheme) (scan-data "#<procedure 1+ (n)>"))
+(1- (groups Scheme) (scan-data "#<procedure 1- (n)>"))
+(< (groups Scheme) (scan-data "#<primitive-procedure <>"))
+(<= (groups Scheme) (scan-data "#<primitive-procedure <=>"))
+(<class> (groups Scheme) (scan-data ""))
+(<entity> (groups Scheme) (scan-data ""))
+(<operator-class> (groups Scheme) (scan-data ""))
+(= (groups Scheme) (scan-data "#<primitive-procedure =>"))
+(> (groups Scheme) (scan-data "#<primitive-procedure >>"))
+(>= (groups Scheme) (scan-data "#<primitive-procedure >=>"))
+(@apply (groups Scheme) (scan-data ""))
+(@bind (groups Scheme) (scan-data ""))
+(@call-with-current-continuation (groups Scheme) (scan-data ""))
+(@call-with-values (groups Scheme) (scan-data ""))
+(@fop (groups Scheme) (scan-data ""))
+(AF_INET (groups k Scheme) (scan-data ""))
+(AF_INET6 (groups k Scheme) (scan-data ""))
+(AF_UNIX (groups k Scheme) (scan-data ""))
+(AF_UNSPEC (groups k Scheme) (scan-data ""))
+(E2BIG (groups k Scheme) (scan-data ""))
+(EACCES (groups k Scheme) (scan-data ""))
+(EADDRINUSE (groups k Scheme) (scan-data ""))
+(EADDRNOTAVAIL (groups k Scheme) (scan-data ""))
+(EADV (groups k Scheme) (scan-data ""))
+(EAFNOSUPPORT (groups k Scheme) (scan-data ""))
+(EAGAIN (groups k Scheme) (scan-data ""))
+(EALREADY (groups k Scheme) (scan-data ""))
+(EBADE (groups k Scheme) (scan-data ""))
+(EBADF (groups k Scheme) (scan-data ""))
+(EBADFD (groups k Scheme) (scan-data ""))
+(EBADMSG (groups k Scheme) (scan-data ""))
+(EBADR (groups k Scheme) (scan-data ""))
+(EBADRQC (groups k Scheme) (scan-data ""))
+(EBADSLT (groups k Scheme) (scan-data ""))
+(EBFONT (groups k Scheme) (scan-data ""))
+(EBUSY (groups k Scheme) (scan-data ""))
+(ECHILD (groups k Scheme) (scan-data ""))
+(ECHRNG (groups k Scheme) (scan-data ""))
+(ECOMM (groups k Scheme) (scan-data ""))
+(ECONNABORTED (groups k Scheme) (scan-data ""))
+(ECONNREFUSED (groups k Scheme) (scan-data ""))
+(ECONNRESET (groups k Scheme) (scan-data ""))
+(EDEADLK (groups k Scheme) (scan-data ""))
+(EDEADLOCK (groups k Scheme) (scan-data ""))
+(EDESTADDRREQ (groups k Scheme) (scan-data ""))
+(EDOM (groups k Scheme) (scan-data ""))
+(EDOTDOT (groups k Scheme) (scan-data ""))
+(EDQUOT (groups k Scheme) (scan-data ""))
+(EEXIST (groups k Scheme) (scan-data ""))
+(EFAULT (groups k Scheme) (scan-data ""))
+(EFBIG (groups k Scheme) (scan-data ""))
+(EHOSTDOWN (groups k Scheme) (scan-data ""))
+(EHOSTUNREACH (groups k Scheme) (scan-data ""))
+(EIDRM (groups k Scheme) (scan-data ""))
+(EILSEQ (groups k Scheme) (scan-data ""))
+(EINPROGRESS (groups k Scheme) (scan-data ""))
+(EINTR (groups k Scheme) (scan-data ""))
+(EINVAL (groups k Scheme) (scan-data ""))
+(EIO (groups k Scheme) (scan-data ""))
+(EISCONN (groups k Scheme) (scan-data ""))
+(EISDIR (groups k Scheme) (scan-data ""))
+(EISNAM (groups k Scheme) (scan-data ""))
+(EL2HLT (groups k Scheme) (scan-data ""))
+(EL2NSYNC (groups k Scheme) (scan-data ""))
+(EL3HLT (groups k Scheme) (scan-data ""))
+(EL3RST (groups k Scheme) (scan-data ""))
+(ELIBACC (groups k Scheme) (scan-data ""))
+(ELIBBAD (groups k Scheme) (scan-data ""))
+(ELIBEXEC (groups k Scheme) (scan-data ""))
+(ELIBMAX (groups k Scheme) (scan-data ""))
+(ELIBSCN (groups k Scheme) (scan-data ""))
+(ELNRNG (groups k Scheme) (scan-data ""))
+(ELOOP (groups k Scheme) (scan-data ""))
+(EMFILE (groups k Scheme) (scan-data ""))
+(EMLINK (groups k Scheme) (scan-data ""))
+(EMSGSIZE (groups k Scheme) (scan-data ""))
+(EMULTIHOP (groups k Scheme) (scan-data ""))
+(ENAMETOOLONG (groups k Scheme) (scan-data ""))
+(ENAVAIL (groups k Scheme) (scan-data ""))
+(ENETDOWN (groups k Scheme) (scan-data ""))
+(ENETRESET (groups k Scheme) (scan-data ""))
+(ENETUNREACH (groups k Scheme) (scan-data ""))
+(ENFILE (groups k Scheme) (scan-data ""))
+(ENOANO (groups k Scheme) (scan-data ""))
+(ENOBUFS (groups k Scheme) (scan-data ""))
+(ENOCSI (groups k Scheme) (scan-data ""))
+(ENODATA (groups k Scheme) (scan-data ""))
+(ENODEV (groups k Scheme) (scan-data ""))
+(ENOENT (groups k Scheme) (scan-data ""))
+(ENOEXEC (groups k Scheme) (scan-data ""))
+(ENOLCK (groups k Scheme) (scan-data ""))
+(ENOLINK (groups k Scheme) (scan-data ""))
+(ENOMEM (groups k Scheme) (scan-data ""))
+(ENOMSG (groups k Scheme) (scan-data ""))
+(ENONET (groups k Scheme) (scan-data ""))
+(ENOPKG (groups k Scheme) (scan-data ""))
+(ENOPROTOOPT (groups k Scheme) (scan-data ""))
+(ENOSPC (groups k Scheme) (scan-data ""))
+(ENOSR (groups k Scheme) (scan-data ""))
+(ENOSTR (groups k Scheme) (scan-data ""))
+(ENOSYS (groups k Scheme) (scan-data ""))
+(ENOTBLK (groups k Scheme) (scan-data ""))
+(ENOTCONN (groups k Scheme) (scan-data ""))
+(ENOTDIR (groups k Scheme) (scan-data ""))
+(ENOTEMPTY (groups k Scheme) (scan-data ""))
+(ENOTNAM (groups k Scheme) (scan-data ""))
+(ENOTSOCK (groups k Scheme) (scan-data ""))
+(ENOTTY (groups k Scheme) (scan-data ""))
+(ENOTUNIQ (groups k Scheme) (scan-data ""))
+(ENXIO (groups k Scheme) (scan-data ""))
+(EOPNOTSUPP (groups k Scheme) (scan-data ""))
+(EOVERFLOW (groups k Scheme) (scan-data ""))
+(EPERM (groups k Scheme) (scan-data ""))
+(EPFNOSUPPORT (groups k Scheme) (scan-data ""))
+(EPIPE (groups k Scheme) (scan-data ""))
+(EPROTO (groups k Scheme) (scan-data ""))
+(EPROTONOSUPPORT (groups k Scheme) (scan-data ""))
+(EPROTOTYPE (groups k Scheme) (scan-data ""))
+(ERANGE (groups k Scheme) (scan-data ""))
+(EREMCHG (groups k Scheme) (scan-data ""))
+(EREMOTE (groups k Scheme) (scan-data ""))
+(EREMOTEIO (groups k Scheme) (scan-data ""))
+(ERESTART (groups k Scheme) (scan-data ""))
+(EROFS (groups k Scheme) (scan-data ""))
+(ESHUTDOWN (groups k Scheme) (scan-data ""))
+(ESOCKTNOSUPPORT (groups k Scheme) (scan-data ""))
+(ESPIPE (groups k Scheme) (scan-data ""))
+(ESRCH (groups k Scheme) (scan-data ""))
+(ESRMNT (groups k Scheme) (scan-data ""))
+(ESTALE (groups k Scheme) (scan-data ""))
+(ESTRPIPE (groups k Scheme) (scan-data ""))
+(ETIME (groups k Scheme) (scan-data ""))
+(ETIMEDOUT (groups k Scheme) (scan-data ""))
+(ETOOMANYREFS (groups k Scheme) (scan-data ""))
+(ETXTBSY (groups k Scheme) (scan-data ""))
+(EUCLEAN (groups k Scheme) (scan-data ""))
+(EUNATCH (groups k Scheme) (scan-data ""))
+(EUSERS (groups k Scheme) (scan-data ""))
+(EWOULDBLOCK (groups k Scheme) (scan-data ""))
+(EXDEV (groups k Scheme) (scan-data ""))
+(EXFULL (groups k Scheme) (scan-data ""))
+(FD_CLOEXEC (groups POSIX k Scheme) (scan-data ""))
+(F_DUPFD (groups POSIX k Scheme) (scan-data ""))
+(F_GETFD (groups POSIX k Scheme) (scan-data ""))
+(F_GETFL (groups POSIX k Scheme) (scan-data ""))
+(F_GETOWN (groups POSIX k Scheme) (scan-data ""))
+(F_OK (groups POSIX k Scheme) (scan-data ""))
+(F_SETFD (groups POSIX k Scheme) (scan-data ""))
+(F_SETFL (groups POSIX k Scheme) (scan-data ""))
+(F_SETOWN (groups POSIX k Scheme) (scan-data ""))
+(INADDR_ANY (groups k Scheme) (scan-data ""))
+(INADDR_BROADCAST (groups k Scheme) (scan-data ""))
+(INADDR_LOOPBACK (groups k Scheme) (scan-data ""))
+(INADDR_NONE (groups k Scheme) (scan-data ""))
+(ITIMER_PROF (groups k Scheme) (scan-data ""))
+(ITIMER_REAL (groups k Scheme) (scan-data ""))
+(ITIMER_VIRTUAL (groups k Scheme) (scan-data ""))
+(LC_ALL (groups POSIX k Scheme) (scan-data ""))
+(LC_COLLATE (groups POSIX k Scheme) (scan-data ""))
+(LC_CTYPE (groups POSIX k Scheme) (scan-data ""))
+(LC_MESSAGES (groups POSIX k Scheme) (scan-data ""))
+(LC_MONETARY (groups POSIX k Scheme) (scan-data ""))
+(LC_NUMERIC (groups POSIX k Scheme) (scan-data ""))
+(LC_TIME (groups POSIX k Scheme) (scan-data ""))
+(LOCK_EX (groups POSIX k Scheme) (scan-data ""))
+(LOCK_NB (groups POSIX k Scheme) (scan-data ""))
+(LOCK_SH (groups POSIX k Scheme) (scan-data ""))
+(LOCK_UN (groups POSIX k Scheme) (scan-data ""))
+(MSG_DONTROUTE (groups k Scheme) (scan-data ""))
+(MSG_OOB (groups k Scheme) (scan-data ""))
+(MSG_PEEK (groups k Scheme) (scan-data ""))
+(NSIG (groups k Scheme) (scan-data ""))
+(OPEN_BOTH (groups k Scheme) (scan-data ""))
+(OPEN_READ (groups k Scheme) (scan-data ""))
+(OPEN_WRITE (groups k Scheme) (scan-data ""))
+(O_APPEND (groups POSIX k Scheme) (scan-data ""))
+(O_CREAT (groups POSIX k Scheme) (scan-data ""))
+(O_EXCL (groups k Scheme) (scan-data ""))
+(O_NDELAY (groups k Scheme) (scan-data ""))
+(O_NOCTTY (groups k Scheme) (scan-data ""))
+(O_NONBLOCK (groups k Scheme) (scan-data ""))
+(O_RDONLY (groups POSIX k Scheme) (scan-data ""))
+(O_RDWR (groups POSIX k Scheme) (scan-data ""))
+(O_SYNC (groups k Scheme) (scan-data ""))
+(O_TRUNC (groups k Scheme) (scan-data ""))
+(O_WRONLY (groups POSIX k Scheme) (scan-data ""))
+(PF_INET (groups k Scheme) (scan-data ""))
+(PF_INET6 (groups k Scheme) (scan-data ""))
+(PF_UNIX (groups k Scheme) (scan-data ""))
+(PF_UNSPEC (groups k Scheme) (scan-data ""))
+(PIPE_BUF (groups k Scheme) (scan-data ""))
+(PRIO_PGRP (groups k Scheme) (scan-data ""))
+(PRIO_PROCESS (groups k Scheme) (scan-data ""))
+(PRIO_USER (groups k Scheme) (scan-data ""))
+(R_OK (groups POSIX k Scheme) (scan-data ""))
+(SA_NOCLDSTOP (groups k Scheme) (scan-data ""))
+(SA_RESTART (groups k Scheme) (scan-data ""))
+(SEEK_CUR (groups k Scheme) (scan-data ""))
+(SEEK_END (groups k Scheme) (scan-data ""))
+(SEEK_SET (groups k Scheme) (scan-data ""))
+(SIGABRT (groups k Scheme) (scan-data ""))
+(SIGALRM (groups k Scheme) (scan-data ""))
+(SIGBUS (groups k Scheme) (scan-data ""))
+(SIGCHLD (groups k Scheme) (scan-data ""))
+(SIGCLD (groups k Scheme) (scan-data ""))
+(SIGCONT (groups k Scheme) (scan-data ""))
+(SIGFPE (groups k Scheme) (scan-data ""))
+(SIGHUP (groups POSIX k Scheme) (scan-data ""))
+(SIGILL (groups k Scheme) (scan-data ""))
+(SIGINT (groups POSIX k Scheme) (scan-data ""))
+(SIGIO (groups k Scheme) (scan-data ""))
+(SIGIOT (groups k Scheme) (scan-data ""))
+(SIGKILL (groups k Scheme) (scan-data ""))
+(SIGPIPE (groups k Scheme) (scan-data ""))
+(SIGPOLL (groups k Scheme) (scan-data ""))
+(SIGPROF (groups k Scheme) (scan-data ""))
+(SIGPWR (groups k Scheme) (scan-data ""))
+(SIGQUIT (groups k Scheme) (scan-data ""))
+(SIGSEGV (groups k Scheme) (scan-data ""))
+(SIGSTKFLT (groups k Scheme) (scan-data ""))
+(SIGSTOP (groups k Scheme) (scan-data ""))
+(SIGTERM (groups k Scheme) (scan-data ""))
+(SIGTRAP (groups k Scheme) (scan-data ""))
+(SIGTSTP (groups k Scheme) (scan-data ""))
+(SIGTTIN (groups k Scheme) (scan-data ""))
+(SIGTTOU (groups k Scheme) (scan-data ""))
+(SIGUNUSED (groups k Scheme) (scan-data ""))
+(SIGURG (groups k Scheme) (scan-data ""))
+(SIGUSR1 (groups k Scheme) (scan-data ""))
+(SIGUSR2 (groups k Scheme) (scan-data ""))
+(SIGVTALRM (groups k Scheme) (scan-data ""))
+(SIGWINCH (groups k Scheme) (scan-data ""))
+(SIGXCPU (groups k Scheme) (scan-data ""))
+(SIGXFSZ (groups k Scheme) (scan-data ""))
+(SIG_DFL (groups k Scheme) (scan-data ""))
+(SIG_IGN (groups k Scheme) (scan-data ""))
+(SOCK_DGRAM (groups k Scheme) (scan-data ""))
+(SOCK_RAW (groups k Scheme) (scan-data ""))
+(SOCK_STREAM (groups k Scheme) (scan-data ""))
+(SOL_IP (groups k Scheme) (scan-data ""))
+(SOL_SOCKET (groups k Scheme) (scan-data ""))
+(SO_BROADCAST (groups k Scheme) (scan-data ""))
+(SO_DEBUG (groups k Scheme) (scan-data ""))
+(SO_DONTROUTE (groups k Scheme) (scan-data ""))
+(SO_ERROR (groups k Scheme) (scan-data ""))
+(SO_KEEPALIVE (groups k Scheme) (scan-data ""))
+(SO_LINGER (groups k Scheme) (scan-data ""))
+(SO_NO_CHECK (groups k Scheme) (scan-data ""))
+(SO_OOBINLINE (groups k Scheme) (scan-data ""))
+(SO_PRIORITY (groups k Scheme) (scan-data ""))
+(SO_RCVBUF (groups k Scheme) (scan-data ""))
+(SO_REUSEADDR (groups k Scheme) (scan-data ""))
+(SO_SNDBUF (groups k Scheme) (scan-data ""))
+(SO_TYPE (groups k Scheme) (scan-data ""))
+(WAIT_ANY (groups k Scheme) (scan-data ""))
+(WAIT_MYPGRP (groups k Scheme) (scan-data ""))
+(WNOHANG (groups POSIX k Scheme) (scan-data ""))
+(WUNTRACED (groups POSIX k Scheme) (scan-data ""))
+(W_OK (groups POSIX k Scheme) (scan-data ""))
+(X_OK (groups POSIX k Scheme) (scan-data ""))
+(_IOFBF (groups POSIX k Scheme) (scan-data ""))
+(_IOLBF (groups POSIX k Scheme) (scan-data ""))
+(_IONBF (groups POSIX k Scheme) (scan-data ""))
+(_fini (groups C) (scan-data T))
+(_init (groups C) (scan-data T))
+(abort-hook (groups Scheme) (scan-data ""))
+(abs (groups Scheme) (scan-data "#<primitive-procedure abs>"))
+(accept (groups Scheme) (scan-data "#<primitive-procedure accept>"))
+(access? (groups POSIX Scheme) (scan-data "#<primitive-procedure access?>"))
+(acons (groups Scheme) (scan-data "#<primitive-procedure acons>"))
+(acos (groups Scheme) (scan-data "#<procedure acos (z)>"))
+(acosh (groups Scheme) (scan-data "#<procedure acosh (z)>"))
+(add-hook! (groups Scheme) (scan-data "#<primitive-procedure add-hook!>"))
+(after-backtrace-hook (groups Scheme) (scan-data ""))
+(after-error-hook (groups Scheme) (scan-data ""))
+(after-eval-hook (groups Scheme) (scan-data ""))
+(after-gc-hook (groups Scheme) (scan-data ""))
+(after-print-hook (groups Scheme) (scan-data ""))
+(after-read-hook (groups Scheme) (scan-data ""))
+(alarm (groups POSIX Scheme) (scan-data "#<primitive-procedure alarm>"))
+(and (groups Scheme) (scan-data ""))
+(and-map (groups Scheme) (scan-data "#<procedure and-map (f lst)>"))
+(and=> (groups Scheme) (scan-data "#<procedure and=> (value procedure)>"))
+(angle (groups Scheme) (scan-data "#<primitive-procedure angle>"))
+(app (groups Scheme) (scan-data ""))
+(append (groups Scheme) (scan-data "#<primitive-procedure append>"))
+(append! (groups Scheme) (scan-data "#<primitive-procedure append!>"))
+(apply (groups Scheme) (scan-data "#<procedure apply (fun . args)>"))
+(apply-to-args (groups Scheme) (scan-data "#<procedure apply-to-args (args fn)>"))
+(apply:nconc2last (groups Scheme) (scan-data "#<primitive-procedure apply:nconc2last>"))
+(array->list (groups Scheme) (scan-data "#<primitive-procedure array->list>"))
+(array-contents (groups Scheme) (scan-data "#<primitive-procedure array-contents>"))
+(array-copy! (groups Scheme) (scan-data "#<primitive-procedure array-copy!>"))
+(array-copy-in-order! (groups Scheme) (scan-data "#<primitive-procedure array-copy-in-order!>"))
+(array-dimensions (groups Scheme) (scan-data "#<primitive-procedure array-dimensions>"))
+(array-equal? (groups Scheme) (scan-data "#<primitive-procedure array-equal?>"))
+(array-fill! (groups Scheme) (scan-data "#<primitive-procedure array-fill!>"))
+(array-for-each (groups Scheme) (scan-data "#<primitive-procedure array-for-each>"))
+(array-in-bounds? (groups Scheme) (scan-data "#<primitive-procedure array-in-bounds?>"))
+(array-index-map! (groups Scheme) (scan-data "#<primitive-procedure array-index-map!>"))
+(array-map! (groups Scheme) (scan-data "#<primitive-procedure array-map!>"))
+(array-map-in-order! (groups Scheme) (scan-data "#<primitive-procedure array-map-in-order!>"))
+(array-prototype (groups Scheme) (scan-data "#<primitive-procedure array-prototype>"))
+(array-rank (groups Scheme) (scan-data "#<primitive-procedure array-rank>"))
+(array-ref (groups Scheme) (scan-data "#<primitive-procedure array-ref>"))
+(array-set! (groups Scheme) (scan-data "#<primitive-procedure array-set!>"))
+(array-shape (groups Scheme) (scan-data "#<procedure array-shape (a)>"))
+(array? (groups Scheme) (scan-data "#<primitive-procedure array?>"))
+(ash (groups Scheme) (scan-data "#<primitive-procedure ash>"))
+(asin (groups Scheme) (scan-data "#<procedure asin (z)>"))
+(asinh (groups Scheme) (scan-data "#<procedure asinh (z)>"))
+(assert-defmacro?! (groups Scheme) (scan-data "#<procedure assert-defmacro?! (m)>"))
+(assert-load-verbosity (groups Scheme) (scan-data "#<procedure assert-load-verbosity (v)>"))
+(assert-repl-print-unspecified (groups Scheme) (scan-data "#<procedure assert-repl-print-unspecified (v)>"))
+(assert-repl-silence (groups Scheme) (scan-data "#<procedure assert-repl-silence (v)>"))
+(assert-repl-verbosity (groups Scheme) (scan-data "#<procedure assert-repl-verbosity (v)>"))
+(assoc (groups Scheme) (scan-data "#<primitive-procedure assoc>"))
+(assoc-ref (groups Scheme) (scan-data "#<primitive-procedure assoc-ref>"))
+(assoc-remove! (groups Scheme) (scan-data "#<primitive-procedure assoc-remove!>"))
+(assoc-set! (groups Scheme) (scan-data "#<primitive-procedure assoc-set!>"))
+(assq (groups Scheme) (scan-data "#<primitive-procedure assq>"))
+(assq-ref (groups Scheme) (scan-data "#<primitive-procedure assq-ref>"))
+(assq-remove! (groups Scheme) (scan-data "#<primitive-procedure assq-remove!>"))
+(assq-set! (groups Scheme) (scan-data "#<primitive-procedure assq-set!>"))
+(assv (groups Scheme) (scan-data "#<primitive-procedure assv>"))
+(assv-ref (groups Scheme) (scan-data "#<primitive-procedure assv-ref>"))
+(assv-remove! (groups Scheme) (scan-data "#<primitive-procedure assv-remove!>"))
+(assv-set! (groups Scheme) (scan-data "#<primitive-procedure assv-set!>"))
+(async (groups Scheme) (scan-data "#<primitive-procedure async>"))
+(async-mark (groups Scheme) (scan-data "#<primitive-procedure async-mark>"))
+(atan (groups Scheme) (scan-data "#<procedure atan (z . y)>"))
+(atanh (groups Scheme) (scan-data "#<procedure atanh (z)>"))
+(autoload-done! (groups Scheme) (scan-data "#<procedure autoload-done! (p m)>"))
+(autoload-done-or-in-progress? (groups Scheme) (scan-data "#<procedure autoload-done-or-in-progress? (p m)>"))
+(autoload-in-progress! (groups Scheme) (scan-data "#<procedure autoload-in-progress! (p m)>"))
+(autoloads-done (groups Scheme) (scan-data ""))
+(autoloads-in-progress (groups Scheme) (scan-data ""))
+(backtrace (groups Scheme) (scan-data "#<primitive-procedure backtrace>"))
+(bad-throw (groups Scheme) (scan-data "#<procedure bad-throw (key . args)>"))
+(basename (groups POSIX Scheme) (scan-data "#<primitive-procedure basename>"))
+(basic-load (groups Scheme) (scan-data "#<procedure load (name)>"))
+(batch-mode? (groups Scheme) (scan-data "#<procedure batch-mode? ()>"))
+(beautify-user-module! (groups Scheme) (scan-data "#<procedure beautify-user-module! (module)>"))
+(before-backtrace-hook (groups Scheme) (scan-data ""))
+(before-error-hook (groups Scheme) (scan-data ""))
+(before-eval-hook (groups Scheme) (scan-data ""))
+(before-print-hook (groups Scheme) (scan-data ""))
+(before-read-hook (groups Scheme) (scan-data ""))
+(before-signal-stack (groups Scheme) (scan-data ""))
+(begin (groups Scheme) (scan-data ""))
+(begin-deprecated (groups Scheme) (scan-data ""))
+(bind (groups Scheme) (scan-data "#<primitive-procedure bind>"))
+(bit-count (groups Scheme) (scan-data "#<primitive-procedure bit-count>"))
+(bit-count* (groups Scheme) (scan-data "#<primitive-procedure bit-count*>"))
+(bit-extract (groups Scheme) (scan-data "#<primitive-procedure bit-extract>"))
+(bit-invert! (groups Scheme) (scan-data "#<primitive-procedure bit-invert!>"))
+(bit-position (groups Scheme) (scan-data "#<primitive-procedure bit-position>"))
+(bit-set*! (groups Scheme) (scan-data "#<primitive-procedure bit-set*!>"))
+(boolean? (groups Scheme) (scan-data "#<primitive-procedure boolean?>"))
+(caaaar (groups Scheme) (scan-data "#<primitive-procedure caaaar>"))
+(caaadr (groups Scheme) (scan-data "#<primitive-procedure caaadr>"))
+(caaar (groups Scheme) (scan-data "#<primitive-procedure caaar>"))
+(caadar (groups Scheme) (scan-data "#<primitive-procedure caadar>"))
+(caaddr (groups Scheme) (scan-data "#<primitive-procedure caaddr>"))
+(caadr (groups Scheme) (scan-data "#<primitive-procedure caadr>"))
+(caar (groups Scheme) (scan-data "#<primitive-procedure caar>"))
+(cadaar (groups Scheme) (scan-data "#<primitive-procedure cadaar>"))
+(cadadr (groups Scheme) (scan-data "#<primitive-procedure cadadr>"))
+(cadar (groups Scheme) (scan-data "#<primitive-procedure cadar>"))
+(caddar (groups Scheme) (scan-data "#<primitive-procedure caddar>"))
+(cadddr (groups Scheme) (scan-data "#<primitive-procedure cadddr>"))
+(caddr (groups Scheme) (scan-data "#<primitive-procedure caddr>"))
+(cadr (groups Scheme) (scan-data "#<primitive-procedure cadr>"))
+(call-with-current-continuation (groups Scheme) (scan-data "#<procedure call-with-current-continuation (proc)>"))
+(call-with-dynamic-root (groups Scheme) (scan-data "#<primitive-procedure call-with-dynamic-root>"))
+(call-with-input-file (groups Scheme) (scan-data "#<procedure call-with-input-file (str proc)>"))
+(call-with-input-string (groups Scheme) (scan-data "#<primitive-procedure call-with-input-string>"))
+(call-with-new-thread (groups Scheme) (scan-data "#<primitive-procedure call-with-new-thread>"))
+(call-with-output-file (groups Scheme) (scan-data "#<procedure call-with-output-file (str proc)>"))
+(call-with-output-string (groups Scheme) (scan-data "#<primitive-procedure call-with-output-string>"))
+(call-with-values (groups Scheme) (scan-data "#<procedure call-with-values (producer consumer)>"))
+(car (groups Scheme) (scan-data "#<primitive-procedure car>"))
+(case (groups Scheme) (scan-data ""))
+(catch (groups Scheme) (scan-data "#<primitive-procedure catch>"))
+(cdaaar (groups Scheme) (scan-data "#<primitive-procedure cdaaar>"))
+(cdaadr (groups Scheme) (scan-data "#<primitive-procedure cdaadr>"))
+(cdaar (groups Scheme) (scan-data "#<primitive-procedure cdaar>"))
+(cdadar (groups Scheme) (scan-data "#<primitive-procedure cdadar>"))
+(cdaddr (groups Scheme) (scan-data "#<primitive-procedure cdaddr>"))
+(cdadr (groups Scheme) (scan-data "#<primitive-procedure cdadr>"))
+(cdar (groups Scheme) (scan-data "#<primitive-procedure cdar>"))
+(cddaar (groups Scheme) (scan-data "#<primitive-procedure cddaar>"))
+(cddadr (groups Scheme) (scan-data "#<primitive-procedure cddadr>"))
+(cddar (groups Scheme) (scan-data "#<primitive-procedure cddar>"))
+(cdddar (groups Scheme) (scan-data "#<primitive-procedure cdddar>"))
+(cddddr (groups Scheme) (scan-data "#<primitive-procedure cddddr>"))
+(cdddr (groups Scheme) (scan-data "#<primitive-procedure cdddr>"))
+(cddr (groups Scheme) (scan-data "#<primitive-procedure cddr>"))
+(cdr (groups Scheme) (scan-data "#<primitive-procedure cdr>"))
+(ceiling (groups Scheme) (scan-data "#<primitive-procedure ceiling>"))
+(char->integer (groups Scheme) (scan-data "#<primitive-procedure char->integer>"))
+(char-alphabetic? (groups Scheme) (scan-data "#<primitive-procedure char-alphabetic?>"))
+(char-ci<=? (groups Scheme) (scan-data "#<primitive-procedure char-ci<=?>"))
+(char-ci<? (groups Scheme) (scan-data "#<primitive-procedure char-ci<?>"))
+(char-ci=? (groups Scheme) (scan-data "#<primitive-procedure char-ci=?>"))
+(char-ci>=? (groups Scheme) (scan-data "#<primitive-procedure char-ci>=?>"))
+(char-ci>? (groups Scheme) (scan-data "#<primitive-procedure char-ci>?>"))
+(char-code-limit (groups Scheme) (scan-data ""))
+(char-downcase (groups Scheme) (scan-data "#<primitive-procedure char-downcase>"))
+(char-is-both? (groups Scheme) (scan-data "#<primitive-procedure char-is-both?>"))
+(char-lower-case? (groups Scheme) (scan-data "#<primitive-procedure char-lower-case?>"))
+(char-numeric? (groups Scheme) (scan-data "#<primitive-procedure char-numeric?>"))
+(char-ready? (groups Scheme) (scan-data "#<primitive-procedure char-ready?>"))
+(char-upcase (groups Scheme) (scan-data "#<primitive-procedure char-upcase>"))
+(char-upper-case? (groups Scheme) (scan-data "#<primitive-procedure char-upper-case?>"))
+(char-whitespace? (groups Scheme) (scan-data "#<primitive-procedure char-whitespace?>"))
+(char<=? (groups Scheme) (scan-data "#<primitive-procedure char<=?>"))
+(char<? (groups Scheme) (scan-data "#<primitive-procedure char<?>"))
+(char=? (groups Scheme) (scan-data "#<primitive-procedure char=?>"))
+(char>=? (groups Scheme) (scan-data "#<primitive-procedure char>=?>"))
+(char>? (groups Scheme) (scan-data "#<primitive-procedure char>?>"))
+(char? (groups Scheme) (scan-data "#<primitive-procedure char?>"))
+(chdir (groups POSIX Scheme) (scan-data "#<primitive-procedure chdir>"))
+(chmod (groups POSIX Scheme) (scan-data "#<primitive-procedure chmod>"))
+(chown (groups POSIX Scheme) (scan-data "#<primitive-procedure chown>"))
+(chroot (groups POSIX Scheme) (scan-data "#<primitive-procedure chroot>"))
+(class-of (groups Scheme) (scan-data "#<primitive-procedure class-of>"))
+(close (groups POSIX Scheme) (scan-data "#<primitive-procedure close>"))
+(close-fdes (groups POSIX Scheme) (scan-data "#<primitive-procedure close-fdes>"))
+(close-input-port (groups Scheme) (scan-data "#<primitive-procedure close-input-port>"))
+(close-io-port (groups Scheme) (scan-data "#<primitive-procedure close-port>"))
+(close-output-port (groups Scheme) (scan-data "#<primitive-procedure close-output-port>"))
+(close-port (groups Scheme) (scan-data "#<primitive-procedure close-port>"))
+(closedir (groups POSIX Scheme) (scan-data "#<primitive-procedure closedir>"))
+(closure? (groups Scheme) (scan-data "#<primitive-procedure closure?>"))
+(collect (groups Scheme) (scan-data ""))
+(command-line (groups POSIX Scheme) (scan-data "#<procedure command-line ()>"))
+(compile-define-module-args (groups Scheme) (scan-data "#<procedure compile-define-module-args (args)>"))
+(compile-interface-spec (groups Scheme) (scan-data "#<procedure compile-interface-spec (spec)>"))
+(complex? (groups Scheme) (scan-data "#<primitive-procedure complex?>"))
+(cond (groups Scheme) (scan-data ""))
+(cond-expand (groups Scheme) (scan-data ""))
+(cond-expand-provide (groups Scheme) (scan-data "#<procedure cond-expand-provide (module features)>"))
+(connect (groups Scheme) (scan-data "#<primitive-procedure connect>"))
+(cons (groups Scheme) (scan-data "#<primitive-procedure cons>"))
+(cons* (groups Scheme) (scan-data "#<primitive-procedure cons*>"))
+(cons-source (groups Scheme) (scan-data "#<primitive-procedure cons-source>"))
+(coop_abort (groups guile-C-API coop C) (scan-data T))
+(coop_condition_variable_destroy (groups guile-C-API coop C) (scan-data T))
+(coop_condition_variable_init (groups guile-C-API coop C) (scan-data T))
+(coop_condition_variable_signal (groups guile-C-API coop C) (scan-data T))
+(coop_condition_variable_timed_wait_mutex (groups guile-C-API coop C) (scan-data T))
+(coop_condition_variable_wait_mutex (groups guile-C-API coop C) (scan-data T))
+(coop_create (groups guile-C-API coop C) (scan-data T))
+(coop_getspecific (groups guile-C-API coop C) (scan-data T))
+(coop_global_allq (groups guile-C-API coop C) (scan-data B))
+(coop_global_curr (groups guile-C-API coop C) (scan-data B))
+(coop_global_runq (groups guile-C-API coop C) (scan-data B))
+(coop_global_sleepq (groups guile-C-API coop C) (scan-data B))
+(coop_init (groups guile-C-API coop C) (scan-data T))
+(coop_join (groups guile-C-API coop C) (scan-data T))
+(coop_key_create (groups guile-C-API coop C) (scan-data T))
+(coop_key_delete (groups guile-C-API coop C) (scan-data T))
+(coop_mutex_destroy (groups guile-C-API coop C) (scan-data T))
+(coop_mutex_init (groups guile-C-API coop C) (scan-data T))
+(coop_mutex_lock (groups guile-C-API coop C) (scan-data T))
+(coop_mutex_trylock (groups guile-C-API coop C) (scan-data T))
+(coop_mutex_unlock (groups guile-C-API coop C) (scan-data T))
+(coop_new_condition_variable_init (groups guile-C-API coop C) (scan-data T))
+(coop_new_mutex_init (groups guile-C-API coop C) (scan-data T))
+(coop_next_runnable_thread (groups guile-C-API coop C) (scan-data T))
+(coop_qget (groups guile-C-API coop C) (scan-data T))
+(coop_qput (groups guile-C-API coop C) (scan-data T))
+(coop_setspecific (groups guile-C-API coop C) (scan-data T))
+(coop_sleephelp (groups guile-C-API coop C) (scan-data T))
+(coop_start (groups guile-C-API coop C) (scan-data T))
+(coop_timeout_qinsert (groups guile-C-API coop C) (scan-data T))
+(coop_tmp_queue (groups guile-C-API coop C) (scan-data B))
+(coop_wait_for_runnable_thread (groups guile-C-API coop C) (scan-data T))
+(coop_wait_for_runnable_thread_now (groups guile-C-API coop C) (scan-data T))
+(coop_yield (groups guile-C-API coop C) (scan-data T))
+(copy-file (groups POSIX Scheme) (scan-data "#<primitive-procedure copy-file>"))
+(copy-random-state (groups Scheme) (scan-data "#<primitive-procedure copy-random-state>"))
+(copy-tree (groups Scheme) (scan-data "#<primitive-procedure copy-tree>"))
+(cos (groups Scheme) (scan-data "#<procedure cos (z)>"))
+(cosh (groups Scheme) (scan-data "#<procedure cosh (z)>"))
+(crypt (groups POSIX Scheme) (scan-data "#<primitive-procedure crypt>"))
+(ctermid (groups POSIX Scheme) (scan-data "#<primitive-procedure ctermid>"))
+(current-error-port (groups Scheme) (scan-data "#<primitive-procedure current-error-port>"))
+(current-input-port (groups Scheme) (scan-data "#<primitive-procedure current-input-port>"))
+(current-load-port (groups Scheme) (scan-data "#<primitive-procedure current-load-port>"))
+(current-module (groups Scheme) (scan-data "#<primitive-procedure current-module>"))
+(current-output-port (groups Scheme) (scan-data "#<primitive-procedure current-output-port>"))
+(current-time (groups POSIX Scheme) (scan-data "#<primitive-procedure current-time>"))
+(cuserid (groups POSIX Scheme) (scan-data "#<primitive-procedure cuserid>"))
+(debug-disable (groups Scheme) (scan-data "#<procedure debug-disable flags>"))
+(debug-enable (groups Scheme) (scan-data "#<procedure debug-enable flags>"))
+(debug-object? (groups Scheme) (scan-data "#<primitive-procedure debug-object?>"))
+(debug-options (groups Scheme) (scan-data "#<procedure debug-options args>"))
+(debug-options-interface (groups Scheme) (scan-data "#<primitive-procedure debug-options-interface>"))
+(debug-set! (groups Scheme) (scan-data ""))
+(default-lazy-handler (groups Scheme) (scan-data "#<procedure default-lazy-handler (key . args)>"))
+(define (groups Scheme) (scan-data ""))
+(define-macro (groups Scheme) (scan-data ""))
+(define-module (groups Scheme) (scan-data ""))
+(define-option-interface (groups Scheme) (scan-data ""))
+(define-private (groups Scheme) (scan-data ""))
+(define-public (groups Scheme) (scan-data ""))
+(define-syntax-macro (groups Scheme) (scan-data ""))
+(defined? (groups Scheme) (scan-data "#<primitive-procedure defined?>"))
+(defmacro (groups Scheme) (scan-data ""))
+(defmacro-public (groups Scheme) (scan-data ""))
+(defmacro-transformer (groups Scheme) (scan-data "#<procedure defmacro-transformer (m)>"))
+(defmacro:syntax-transformer (groups Scheme) (scan-data "#<procedure defmacro:syntax-transformer (f)>"))
+(defmacro:transformer (groups Scheme) (scan-data "#<procedure defmacro:transformer (f)>"))
+(defmacro? (groups Scheme) (scan-data "#<procedure defmacro? (m)>"))
+(delay (groups Scheme) (scan-data ""))
+(delete (groups Scheme) (scan-data "#<primitive-procedure delete>"))
+(delete! (groups Scheme) (scan-data "#<primitive-procedure delete!>"))
+(delete-file (groups POSIX Scheme) (scan-data "#<primitive-procedure delete-file>"))
+(delete1! (groups Scheme) (scan-data "#<primitive-procedure delete1!>"))
+(delq (groups Scheme) (scan-data "#<primitive-procedure delq>"))
+(delq! (groups Scheme) (scan-data "#<primitive-procedure delq!>"))
+(delq1! (groups Scheme) (scan-data "#<primitive-procedure delq1!>"))
+(delv (groups Scheme) (scan-data "#<primitive-procedure delv>"))
+(delv! (groups Scheme) (scan-data "#<primitive-procedure delv!>"))
+(delv1! (groups Scheme) (scan-data "#<primitive-procedure delv1!>"))
+(destroy-guardian! (groups Scheme) (scan-data "#<primitive-procedure destroy-guardian!>"))
+(dimensions->uniform-array (groups Scheme) (scan-data "#<primitive-procedure dimensions->uniform-array>"))
+(directory-stream? (groups POSIX Scheme) (scan-data "#<primitive-procedure directory-stream?>"))
+(dirname (groups POSIX Scheme) (scan-data "#<primitive-procedure dirname>"))
+(display (groups Scheme) (scan-data "#<primitive-procedure display>"))
+(display-application (groups Scheme) (scan-data "#<primitive-procedure display-application>"))
+(display-backtrace (groups Scheme) (scan-data "#<primitive-procedure display-backtrace>"))
+(display-error (groups Scheme) (scan-data "#<primitive-procedure display-error>"))
+(display-usage-report (groups Scheme) (scan-data "#<procedure display-usage-report (kw-desc)>"))
+(do (groups Scheme) (scan-data ""))
+(doubly-weak-hash-table? (groups Scheme) (scan-data "#<primitive-procedure doubly-weak-hash-table?>"))
+(drain-input (groups Scheme) (scan-data "#<primitive-procedure drain-input>"))
+(dup (groups POSIX Scheme) (scan-data "#<procedure dup (port/fd . maybe-fd)>"))
+(dup->fdes (groups POSIX Scheme) (scan-data "#<primitive-procedure dup->fdes>"))
+(dup->inport (groups POSIX Scheme) (scan-data "#<procedure dup->inport (port/fd . maybe-fd)>"))
+(dup->outport (groups POSIX Scheme) (scan-data "#<procedure dup->outport (port/fd . maybe-fd)>"))
+(dup->port (groups POSIX Scheme) (scan-data "#<procedure dup->port (port/fd mode . maybe-fd)>"))
+(dup2 (groups POSIX Scheme) (scan-data "#<primitive-procedure dup2>"))
+(duplicate-port (groups POSIX Scheme) (scan-data "#<procedure duplicate-port (port modes)>"))
+(dynamic-args-call (groups Scheme) (scan-data "#<primitive-procedure dynamic-args-call>"))
+(dynamic-call (groups Scheme) (scan-data "#<primitive-procedure dynamic-call>"))
+(dynamic-func (groups Scheme) (scan-data "#<primitive-procedure dynamic-func>"))
+(dynamic-link (groups Scheme) (scan-data "#<primitive-procedure dynamic-link>"))
+(dynamic-object? (groups Scheme) (scan-data "#<primitive-procedure dynamic-object?>"))
+(dynamic-root (groups Scheme) (scan-data "#<primitive-procedure dynamic-root>"))
+(dynamic-unlink (groups Scheme) (scan-data "#<primitive-procedure dynamic-unlink>"))
+(dynamic-wind (groups Scheme) (scan-data "#<primitive-procedure dynamic-wind>"))
+(enclose-array (groups Scheme) (scan-data "#<primitive-procedure enclose-array>"))
+(endgrent (groups POSIX Scheme) (scan-data "#<procedure endgrent ()>"))
+(endhostent (groups Scheme) (scan-data "#<procedure endhostent ()>"))
+(endnetent (groups Scheme) (scan-data "#<procedure endnetent ()>"))
+(endprotoent (groups Scheme) (scan-data "#<procedure endprotoent ()>"))
+(endpwent (groups POSIX Scheme) (scan-data "#<procedure endpwent ()>"))
+(endservent (groups Scheme) (scan-data "#<procedure endservent ()>"))
+(entity? (groups Scheme) (scan-data "#<primitive-procedure entity?>"))
+(env-module (groups Scheme) (scan-data "#<primitive-procedure env-module>"))
+(environ (groups POSIX Scheme) (scan-data "#<primitive-procedure environ>"))
+(environment-bound? (groups Scheme) (scan-data "#<primitive-procedure environment-bound?>"))
+(environment-cell (groups Scheme) (scan-data "#<primitive-procedure environment-cell>"))
+(environment-define (groups Scheme) (scan-data "#<primitive-procedure environment-define>"))
+(environment-fold (groups Scheme) (scan-data "#<primitive-procedure environment-fold>"))
+(environment-module (groups Scheme) (scan-data "#<procedure environment-module (env)>"))
+(environment-observe (groups Scheme) (scan-data "#<primitive-procedure environment-observe>"))
+(environment-observe-weak (groups Scheme) (scan-data "#<primitive-procedure environment-observe-weak>"))
+(environment-ref (groups Scheme) (scan-data "#<primitive-procedure environment-ref>"))
+(environment-set! (groups Scheme) (scan-data "#<primitive-procedure environment-set!>"))
+(environment-undefine (groups Scheme) (scan-data "#<primitive-procedure environment-undefine>"))
+(environment-unobserve (groups Scheme) (scan-data "#<primitive-procedure environment-unobserve>"))
+(environment? (groups Scheme) (scan-data "#<primitive-procedure environment?>"))
+(eof-object? (groups Scheme) (scan-data "#<primitive-procedure eof-object?>"))
+(eq? (groups Scheme) (scan-data "#<primitive-procedure eq?>"))
+(equal? (groups Scheme) (scan-data "#<primitive-procedure equal?>"))
+(eqv? (groups Scheme) (scan-data "#<primitive-procedure eqv?>"))
+(error (groups Scheme) (scan-data "#<procedure error args>"))
+(error-catching-loop (groups Scheme) (scan-data "#<procedure error-catching-loop (thunk)>"))
+(error-catching-repl (groups Scheme) (scan-data "#<procedure error-catching-repl (r e p)>"))
+(eval (groups Scheme) (scan-data "#<primitive-procedure eval>"))
+(eval-case (groups Scheme) (scan-data ""))
+(eval-disable (groups Scheme) (scan-data "#<procedure eval-disable flags>"))
+(eval-enable (groups Scheme) (scan-data "#<procedure eval-enable flags>"))
+(eval-environment-imported (groups Scheme) (scan-data "#<primitive-procedure eval-environment-imported>"))
+(eval-environment-local (groups Scheme) (scan-data "#<primitive-procedure eval-environment-local>"))
+(eval-environment-set-imported! (groups Scheme) (scan-data "#<primitive-procedure eval-environment-set-imported!>"))
+(eval-environment-set-local! (groups Scheme) (scan-data "#<primitive-procedure eval-environment-set-local!>"))
+(eval-environment? (groups Scheme) (scan-data "#<primitive-procedure eval-environment?>"))
+(eval-options (groups Scheme) (scan-data "#<procedure eval-options args>"))
+(eval-options-interface (groups Scheme) (scan-data "#<primitive-procedure eval-options-interface>"))
+(eval-set! (groups Scheme) (scan-data ""))
+(eval-string (groups Scheme) (scan-data "#<primitive-procedure eval-string>"))
+(evaluator-traps-interface (groups Scheme) (scan-data "#<primitive-procedure evaluator-traps-interface>"))
+(even? (groups Scheme) (scan-data "#<primitive-procedure even?>"))
+(exact->inexact (groups Scheme) (scan-data "#<primitive-procedure exact->inexact>"))
+(exact? (groups Scheme) (scan-data "#<primitive-procedure exact?>"))
+(execl (groups POSIX Scheme) (scan-data "#<primitive-procedure execl>"))
+(execle (groups POSIX Scheme) (scan-data "#<primitive-procedure execle>"))
+(execlp (groups POSIX Scheme) (scan-data "#<primitive-procedure execlp>"))
+(exit (groups Scheme) (scan-data "#<procedure quit args>"))
+(exit-hook (groups Scheme) (scan-data ""))
+(exp (groups Scheme) (scan-data "#<procedure exp (z)>"))
+(export (groups Scheme) (scan-data ""))
+(export-environment-private (groups Scheme) (scan-data "#<primitive-procedure export-environment-private>"))
+(export-environment-set-private! (groups Scheme) (scan-data "#<primitive-procedure export-environment-set-private!>"))
+(export-environment-set-signature! (groups Scheme) (scan-data "#<primitive-procedure export-environment-set-signature!>"))
+(export-environment-signature (groups Scheme) (scan-data "#<primitive-procedure export-environment-signature>"))
+(export-environment? (groups Scheme) (scan-data "#<primitive-procedure export-environment?>"))
+(export-syntax (groups Scheme) (scan-data ""))
+(expt (groups Scheme) (scan-data "#<procedure expt (z1 z2)>"))
+(false-if-exception (groups Scheme) (scan-data ""))
+(fcntl (groups POSIX Scheme) (scan-data "#<primitive-procedure fcntl>"))
+(fdes->inport (groups POSIX Scheme) (scan-data "#<procedure fdes->inport (fdes)>"))
+(fdes->outport (groups POSIX Scheme) (scan-data "#<procedure fdes->outport (fdes)>"))
+(fdes->ports (groups POSIX Scheme) (scan-data "#<primitive-procedure fdes->ports>"))
+(fdopen (groups POSIX Scheme) (scan-data "#<primitive-procedure fdopen>"))
+(feature? (groups Scheme) (scan-data "#<procedure provided? (feature)>"))
+(file-exists? (groups Scheme) (scan-data "#<procedure file-exists? (str)>"))
+(file-is-directory? (groups Scheme) (scan-data "#<procedure file-is-directory? (str)>"))
+(file-port? (groups Scheme) (scan-data "#<primitive-procedure file-port?>"))
+(file-position (groups Scheme) (scan-data "#<procedure file-position args>"))
+(file-set-position (groups Scheme) (scan-data "#<procedure file-set-position args>"))
+(fileno (groups POSIX Scheme) (scan-data "#<primitive-procedure fileno>"))
+(flock (groups POSIX Scheme) (scan-data "#<primitive-procedure flock>"))
+(floor (groups Scheme) (scan-data "#<primitive-procedure floor>"))
+(fluid-ref (groups Scheme) (scan-data "#<primitive-procedure fluid-ref>"))
+(fluid-set! (groups Scheme) (scan-data "#<primitive-procedure fluid-set!>"))
+(fluid? (groups Scheme) (scan-data "#<primitive-procedure fluid?>"))
+(flush-all-ports (groups Scheme) (scan-data "#<primitive-procedure flush-all-ports>"))
+(for-each (groups Scheme) (scan-data "#<primitive-procedure for-each>"))
+(for-next-option (groups Scheme) (scan-data "#<procedure for-next-option (proc argv kw-opts kw-args)>"))
+(force (groups Scheme) (scan-data "#<primitive-procedure force>"))
+(force-output (groups Scheme) (scan-data "#<primitive-procedure force-output>"))
+(format (groups Scheme) (scan-data "#<primitive-procedure simple-format>"))
+(frame-arguments (groups Scheme) (scan-data "#<primitive-procedure frame-arguments>"))
+(frame-evaluating-args? (groups Scheme) (scan-data "#<primitive-procedure frame-evaluating-args?>"))
+(frame-next (groups Scheme) (scan-data "#<primitive-procedure frame-next>"))
+(frame-number (groups Scheme) (scan-data "#<primitive-procedure frame-number>"))
+(frame-overflow? (groups Scheme) (scan-data "#<primitive-procedure frame-overflow?>"))
+(frame-previous (groups Scheme) (scan-data "#<primitive-procedure frame-previous>"))
+(frame-procedure (groups Scheme) (scan-data "#<primitive-procedure frame-procedure>"))
+(frame-procedure? (groups Scheme) (scan-data "#<primitive-procedure frame-procedure?>"))
+(frame-real? (groups Scheme) (scan-data "#<primitive-procedure frame-real?>"))
+(frame-source (groups Scheme) (scan-data "#<primitive-procedure frame-source>"))
+(frame? (groups Scheme) (scan-data "#<primitive-procedure frame?>"))
+(fsync (groups POSIX Scheme) (scan-data "#<primitive-procedure fsync>"))
+(ftell (groups Scheme) (scan-data "#<primitive-procedure ftell>"))
+(gc (groups Scheme) (scan-data "#<primitive-procedure gc>"))
+(gc-run-time (groups Scheme) (scan-data "#<procedure gc-run-time ()>"))
+(gc-stats (groups Scheme) (scan-data "#<primitive-procedure gc-stats>"))
+(gcd (groups Scheme) (scan-data "#<primitive-procedure gcd>"))
+(gdb_binding (groups guile-C-API gdb C) (scan-data T))
+(gdb_eval (groups guile-C-API gdb C) (scan-data T))
+(gdb_language (groups guile-C-API gdb C) (scan-data D))
+(gdb_maybe_valid_type_p (groups guile-C-API gdb C) (scan-data T))
+(gdb_options (groups guile-C-API gdb C) (scan-data D))
+(gdb_output (groups guile-C-API gdb C) (scan-data B))
+(gdb_output_length (groups guile-C-API gdb C) (scan-data B))
+(gdb_print (groups guile-C-API gdb C) (scan-data T))
+(gdb_read (groups guile-C-API gdb C) (scan-data T))
+(gdb_result (groups guile-C-API gdb C) (scan-data B))
+(gensym (groups Scheme) (scan-data "#<primitive-procedure gensym>"))
+(get-internal-real-time (groups POSIX Scheme) (scan-data "#<primitive-procedure get-internal-real-time>"))
+(get-internal-run-time (groups POSIX Scheme) (scan-data "#<primitive-procedure get-internal-run-time>"))
+(get-option (groups Scheme) (scan-data "#<procedure get-option (argv kw-opts kw-args return)>"))
+(get-output-string (groups Scheme) (scan-data "#<primitive-procedure get-output-string>"))
+(get-print-state (groups Scheme) (scan-data "#<primitive-procedure get-print-state>"))
+(getcwd (groups POSIX Scheme) (scan-data "#<primitive-procedure getcwd>"))
+(getegid (groups POSIX Scheme) (scan-data "#<primitive-procedure getegid>"))
+(getenv (groups POSIX Scheme) (scan-data "#<primitive-procedure getenv>"))
+(geteuid (groups POSIX Scheme) (scan-data "#<primitive-procedure geteuid>"))
+(getgid (groups POSIX Scheme) (scan-data "#<primitive-procedure getgid>"))
+(getgr (groups POSIX Scheme) (scan-data "#<primitive-procedure getgr>"))
+(getgrent (groups POSIX Scheme) (scan-data "#<procedure getgrent ()>"))
+(getgrgid (groups POSIX Scheme) (scan-data "#<procedure getgrgid (id)>"))
+(getgrnam (groups POSIX Scheme) (scan-data "#<procedure getgrnam (name)>"))
+(getgroups (groups POSIX Scheme) (scan-data "#<primitive-procedure getgroups>"))
+(gethost (groups Scheme) (scan-data "#<primitive-procedure gethost>"))
+(gethostbyaddr (groups Scheme) (scan-data "#<procedure gethostbyaddr (addr)>"))
+(gethostbyname (groups Scheme) (scan-data "#<procedure gethostbyname (name)>"))
+(gethostent (groups Scheme) (scan-data "#<procedure gethostent ()>"))
+(gethostname (groups POSIX Scheme) (scan-data "#<primitive-procedure gethostname>"))
+(getitimer (groups POSIX Scheme) (scan-data "#<primitive-procedure getitimer>"))
+(getlogin (groups POSIX Scheme) (scan-data "#<primitive-procedure getlogin>"))
+(getnet (groups Scheme) (scan-data "#<primitive-procedure getnet>"))
+(getnetbyaddr (groups Scheme) (scan-data "#<procedure getnetbyaddr (addr)>"))
+(getnetbyname (groups Scheme) (scan-data "#<procedure getnetbyname (name)>"))
+(getnetent (groups Scheme) (scan-data "#<procedure getnetent ()>"))
+(getpass (groups POSIX Scheme) (scan-data "#<primitive-procedure getpass>"))
+(getpeername (groups Scheme) (scan-data "#<primitive-procedure getpeername>"))
+(getpgrp (groups POSIX Scheme) (scan-data "#<primitive-procedure getpgrp>"))
+(getpid (groups POSIX Scheme) (scan-data "#<primitive-procedure getpid>"))
+(getppid (groups POSIX Scheme) (scan-data "#<primitive-procedure getppid>"))
+(getpriority (groups POSIX Scheme) (scan-data "#<primitive-procedure getpriority>"))
+(getproto (groups Scheme) (scan-data "#<primitive-procedure getproto>"))
+(getprotobyname (groups Scheme) (scan-data "#<procedure getprotobyname (name)>"))
+(getprotobynumber (groups Scheme) (scan-data "#<procedure getprotobynumber (addr)>"))
+(getprotoent (groups Scheme) (scan-data "#<procedure getprotoent ()>"))
+(getpw (groups POSIX Scheme) (scan-data "#<primitive-procedure getpw>"))
+(getpwent (groups POSIX Scheme) (scan-data "#<procedure getpwent ()>"))
+(getpwnam (groups POSIX Scheme) (scan-data "#<procedure getpwnam (name)>"))
+(getpwuid (groups POSIX Scheme) (scan-data "#<procedure getpwuid (uid)>"))
+(getserv (groups Scheme) (scan-data "#<primitive-procedure getserv>"))
+(getservbyname (groups Scheme) (scan-data "#<procedure getservbyname (name proto)>"))
+(getservbyport (groups Scheme) (scan-data "#<procedure getservbyport (port proto)>"))
+(getservent (groups Scheme) (scan-data "#<procedure getservent ()>"))
+(getsockname (groups Scheme) (scan-data "#<primitive-procedure getsockname>"))
+(getsockopt (groups Scheme) (scan-data "#<primitive-procedure getsockopt>"))
+(gettimeofday (groups POSIX Scheme) (scan-data "#<primitive-procedure gettimeofday>"))
+(getuid (groups POSIX Scheme) (scan-data "#<primitive-procedure getuid>"))
+(gh_append (groups guile-C-API gh C) (scan-data T))
+(gh_append2 (groups guile-C-API gh C) (scan-data T))
+(gh_append3 (groups guile-C-API gh C) (scan-data T))
+(gh_append4 (groups guile-C-API gh C) (scan-data T))
+(gh_apply (groups guile-C-API gh C) (scan-data T))
+(gh_bool2scm (groups guile-C-API gh C) (scan-data T))
+(gh_boolean_p (groups guile-C-API gh C) (scan-data T))
+(gh_caaar (groups guile-C-API gh C) (scan-data T))
+(gh_caadr (groups guile-C-API gh C) (scan-data T))
+(gh_caar (groups guile-C-API gh C) (scan-data T))
+(gh_cadar (groups guile-C-API gh C) (scan-data T))
+(gh_caddr (groups guile-C-API gh C) (scan-data T))
+(gh_cadr (groups guile-C-API gh C) (scan-data T))
+(gh_call0 (groups guile-C-API gh C) (scan-data T))
+(gh_call1 (groups guile-C-API gh C) (scan-data T))
+(gh_call2 (groups guile-C-API gh C) (scan-data T))
+(gh_call3 (groups guile-C-API gh C) (scan-data T))
+(gh_car (groups guile-C-API gh C) (scan-data T))
+(gh_catch (groups guile-C-API gh C) (scan-data T))
+(gh_cdaar (groups guile-C-API gh C) (scan-data T))
+(gh_cdadr (groups guile-C-API gh C) (scan-data T))
+(gh_cdar (groups guile-C-API gh C) (scan-data T))
+(gh_cddar (groups guile-C-API gh C) (scan-data T))
+(gh_cdddr (groups guile-C-API gh C) (scan-data T))
+(gh_cddr (groups guile-C-API gh C) (scan-data T))
+(gh_cdr (groups guile-C-API gh C) (scan-data T))
+(gh_char2scm (groups guile-C-API gh C) (scan-data T))
+(gh_char_p (groups guile-C-API gh C) (scan-data T))
+(gh_chars2byvect (groups guile-C-API gh C) (scan-data T))
+(gh_cons (groups guile-C-API gh C) (scan-data T))
+(gh_define (groups guile-C-API gh C) (scan-data T))
+(gh_display (groups guile-C-API gh C) (scan-data T))
+(gh_double2scm (groups guile-C-API gh C) (scan-data T))
+(gh_doubles2dvect (groups guile-C-API gh C) (scan-data T))
+(gh_doubles2scm (groups guile-C-API gh C) (scan-data T))
+(gh_enter (groups guile-C-API gh C) (scan-data T))
+(gh_eq_p (groups guile-C-API gh C) (scan-data T))
+(gh_equal_p (groups guile-C-API gh C) (scan-data T))
+(gh_eqv_p (groups guile-C-API gh C) (scan-data T))
+(gh_eval_file (groups guile-C-API gh C) (scan-data T))
+(gh_eval_file_with_catch (groups guile-C-API gh C) (scan-data T))
+(gh_eval_file_with_standard_handler (groups guile-C-API gh C) (scan-data T))
+(gh_eval_str (groups guile-C-API gh C) (scan-data T))
+(gh_eval_str_with_catch (groups guile-C-API gh C) (scan-data T))
+(gh_eval_str_with_stack_saving_handler (groups guile-C-API gh C) (scan-data T))
+(gh_eval_str_with_standard_handler (groups guile-C-API gh C) (scan-data T))
+(gh_exact_p (groups guile-C-API gh C) (scan-data T))
+(gh_floats2fvect (groups guile-C-API gh C) (scan-data T))
+(gh_get_substr (groups guile-C-API gh C) (scan-data T))
+(gh_inexact_p (groups guile-C-API gh C) (scan-data T))
+(gh_int2scm (groups guile-C-API gh C) (scan-data T))
+(gh_ints2scm (groups guile-C-API gh C) (scan-data T))
+(gh_length (groups guile-C-API gh C) (scan-data T))
+(gh_list_p (groups guile-C-API gh C) (scan-data T))
+(gh_long2scm (groups guile-C-API gh C) (scan-data T))
+(gh_longs2ivect (groups guile-C-API gh C) (scan-data T))
+(gh_lookup (groups guile-C-API gh C) (scan-data T))
+(gh_make_vector (groups guile-C-API gh C) (scan-data T))
+(gh_module_lookup (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure0_0 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure0_1 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure0_2 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure1_0 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure1_1 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure1_2 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure2_0 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure2_1 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure2_2 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure3_0 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure4_0 (groups guile-C-API gh C) (scan-data T))
+(gh_new_procedure5_0 (groups guile-C-API gh C) (scan-data T))
+(gh_newline (groups guile-C-API gh C) (scan-data T))
+(gh_null_p (groups guile-C-API gh C) (scan-data T))
+(gh_number_p (groups guile-C-API gh C) (scan-data T))
+(gh_pair_p (groups guile-C-API gh C) (scan-data T))
+(gh_procedure_p (groups guile-C-API gh C) (scan-data T))
+(gh_repl (groups guile-C-API gh C) (scan-data T))
+(gh_scm2bool (groups guile-C-API gh C) (scan-data T))
+(gh_scm2char (groups guile-C-API gh C) (scan-data T))
+(gh_scm2chars (groups guile-C-API gh C) (scan-data T))
+(gh_scm2double (groups guile-C-API gh C) (scan-data T))
+(gh_scm2doubles (groups guile-C-API gh C) (scan-data T))
+(gh_scm2floats (groups guile-C-API gh C) (scan-data T))
+(gh_scm2int (groups guile-C-API gh C) (scan-data T))
+(gh_scm2long (groups guile-C-API gh C) (scan-data T))
+(gh_scm2longs (groups guile-C-API gh C) (scan-data T))
+(gh_scm2newstr (groups guile-C-API gh C) (scan-data T))
+(gh_scm2shorts (groups guile-C-API gh C) (scan-data T))
+(gh_scm2ulong (groups guile-C-API gh C) (scan-data T))
+(gh_set_car_x (groups guile-C-API gh C) (scan-data T))
+(gh_set_cdr_x (groups guile-C-API gh C) (scan-data T))
+(gh_set_substr (groups guile-C-API gh C) (scan-data T))
+(gh_shorts2svect (groups guile-C-API gh C) (scan-data T))
+(gh_standard_handler (groups guile-C-API gh C) (scan-data T))
+(gh_str02scm (groups guile-C-API gh C) (scan-data T))
+(gh_str2scm (groups guile-C-API gh C) (scan-data T))
+(gh_string_equal_p (groups guile-C-API gh C) (scan-data T))
+(gh_string_p (groups guile-C-API gh C) (scan-data T))
+(gh_symbol2newstr (groups guile-C-API gh C) (scan-data T))
+(gh_symbol2scm (groups guile-C-API gh C) (scan-data T))
+(gh_symbol_p (groups guile-C-API gh C) (scan-data T))
+(gh_ulong2scm (groups guile-C-API gh C) (scan-data T))
+(gh_ulongs2uvect (groups guile-C-API gh C) (scan-data T))
+(gh_uniform_vector_length (groups guile-C-API gh C) (scan-data T))
+(gh_uniform_vector_ref (groups guile-C-API gh C) (scan-data T))
+(gh_vector_length (groups guile-C-API gh C) (scan-data T))
+(gh_vector_p (groups guile-C-API gh C) (scan-data T))
+(gh_vector_ref (groups guile-C-API gh C) (scan-data T))
+(gh_vector_set_x (groups guile-C-API gh C) (scan-data T))
+(gh_write (groups guile-C-API gh C) (scan-data T))
+(gmtime (groups POSIX Scheme) (scan-data "#<primitive-procedure gmtime>"))
+(group:gid (groups POSIX Scheme) (scan-data "#<procedure group:gid (obj)>"))
+(group:mem (groups POSIX Scheme) (scan-data "#<procedure group:mem (obj)>"))
+(group:name (groups POSIX Scheme) (scan-data "#<procedure group:name (obj)>"))
+(group:passwd (groups POSIX Scheme) (scan-data "#<procedure group:passwd (obj)>"))
+(guardian-destroyed? (groups Scheme) (scan-data "#<primitive-procedure guardian-destroyed?>"))
+(guardian-greedy? (groups Scheme) (scan-data "#<primitive-procedure guardian-greedy?>"))
+(handle-system-error (groups Scheme) (scan-data "#<procedure handle-system-error (key . args)>"))
+(has-shown-backtrace-hint? (groups Scheme) (scan-data ""))
+(has-shown-debugger-hint? (groups Scheme) (scan-data ""))
+(has-suffix? (groups Scheme) (scan-data "#<procedure has-suffix? (str suffix)>"))
+(hash (groups Scheme) (scan-data "#<primitive-procedure hash>"))
+(hash-create-handle! (groups Scheme) (scan-data "#<primitive-procedure hash-create-handle!>"))
+(hash-fold (groups Scheme) (scan-data "#<primitive-procedure hash-fold>"))
+(hash-get-handle (groups Scheme) (scan-data "#<primitive-procedure hash-get-handle>"))
+(hash-ref (groups Scheme) (scan-data "#<primitive-procedure hash-ref>"))
+(hash-remove! (groups Scheme) (scan-data "#<primitive-procedure hash-remove!>"))
+(hash-set! (groups Scheme) (scan-data "#<primitive-procedure hash-set!>"))
+(hashq (groups Scheme) (scan-data "#<primitive-procedure hashq>"))
+(hashq-create-handle! (groups Scheme) (scan-data "#<primitive-procedure hashq-create-handle!>"))
+(hashq-get-handle (groups Scheme) (scan-data "#<primitive-procedure hashq-get-handle>"))
+(hashq-ref (groups Scheme) (scan-data "#<primitive-procedure hashq-ref>"))
+(hashq-remove! (groups Scheme) (scan-data "#<primitive-procedure hashq-remove!>"))
+(hashq-set! (groups Scheme) (scan-data "#<primitive-procedure hashq-set!>"))
+(hashv (groups Scheme) (scan-data "#<primitive-procedure hashv>"))
+(hashv-create-handle! (groups Scheme) (scan-data "#<primitive-procedure hashv-create-handle!>"))
+(hashv-get-handle (groups Scheme) (scan-data "#<primitive-procedure hashv-get-handle>"))
+(hashv-ref (groups Scheme) (scan-data "#<primitive-procedure hashv-ref>"))
+(hashv-remove! (groups Scheme) (scan-data "#<primitive-procedure hashv-remove!>"))
+(hashv-set! (groups Scheme) (scan-data "#<primitive-procedure hashv-set!>"))
+(hashx-create-handle! (groups Scheme) (scan-data "#<primitive-procedure hashx-create-handle!>"))
+(hashx-get-handle (groups Scheme) (scan-data "#<primitive-procedure hashx-get-handle>"))
+(hashx-ref (groups Scheme) (scan-data "#<primitive-procedure hashx-ref>"))
+(hashx-set! (groups Scheme) (scan-data "#<primitive-procedure hashx-set!>"))
+(hook->list (groups Scheme) (scan-data "#<primitive-procedure hook->list>"))
+(hook-empty? (groups Scheme) (scan-data "#<primitive-procedure hook-empty?>"))
+(hook? (groups Scheme) (scan-data "#<primitive-procedure hook?>"))
+(hostent:addr-list (groups Scheme) (scan-data "#<procedure hostent:addr-list (obj)>"))
+(hostent:addrtype (groups Scheme) (scan-data "#<procedure hostent:addrtype (obj)>"))
+(hostent:aliases (groups Scheme) (scan-data "#<procedure hostent:aliases (obj)>"))
+(hostent:length (groups Scheme) (scan-data "#<procedure hostent:length (obj)>"))
+(hostent:name (groups Scheme) (scan-data "#<procedure hostent:name (obj)>"))
+(htonl (groups Scheme) (scan-data "#<primitive-procedure htonl>"))
+(htons (groups Scheme) (scan-data "#<primitive-procedure htons>"))
+(identity (groups Scheme) (scan-data "#<procedure identity (x)>"))
+(if (groups Scheme) (scan-data ""))
+(imag-part (groups Scheme) (scan-data "#<primitive-procedure imag-part>"))
+(import-environment-imports (groups Scheme) (scan-data "#<primitive-procedure import-environment-imports>"))
+(import-environment-set-imports! (groups Scheme) (scan-data "#<primitive-procedure import-environment-set-imports!>"))
+(import-environment? (groups Scheme) (scan-data "#<primitive-procedure import-environment?>"))
+(in-vicinity (groups Scheme) (scan-data "#<procedure in-vicinity (vicinity file)>"))
+(include-deprecated-features (groups Scheme) (scan-data "#<primitive-procedure include-deprecated-features>"))
+(inet-aton (groups Scheme) (scan-data "#<primitive-procedure inet-aton>"))
+(inet-lnaof (groups Scheme) (scan-data "#<primitive-procedure inet-lnaof>"))
+(inet-makeaddr (groups Scheme) (scan-data "#<primitive-procedure inet-makeaddr>"))
+(inet-netof (groups Scheme) (scan-data "#<primitive-procedure inet-netof>"))
+(inet-ntoa (groups Scheme) (scan-data "#<primitive-procedure inet-ntoa>"))
+(inet-ntop (groups Scheme) (scan-data "#<primitive-procedure inet-ntop>"))
+(inet-pton (groups Scheme) (scan-data "#<primitive-procedure inet-pton>"))
+(inexact->exact (groups Scheme) (scan-data "#<primitive-procedure inexact->exact>"))
+(inexact? (groups Scheme) (scan-data "#<primitive-procedure inexact?>"))
+(inf (groups Scheme) (scan-data "#<primitive-procedure inf>"))
+(inf? (groups Scheme) (scan-data "#<primitive-procedure inf?>"))
+(inherit-print-state (groups Scheme) (scan-data "#<procedure inherit-print-state (old-port new-port)>"))
+(input-port? (groups Scheme) (scan-data "#<primitive-procedure input-port?>"))
+(integer->char (groups Scheme) (scan-data "#<primitive-procedure integer->char>"))
+(integer-expt (groups Scheme) (scan-data "#<primitive-procedure integer-expt>"))
+(integer-length (groups Scheme) (scan-data "#<primitive-procedure integer-length>"))
+(integer? (groups Scheme) (scan-data "#<primitive-procedure integer?>"))
+(interaction-environment (groups Scheme) (scan-data "#<primitive-procedure interaction-environment>"))
+(internal-time-units-per-second (groups Scheme) (scan-data ""))
+(iota (groups Scheme) (scan-data "#<procedure iota (n)>"))
+(ipow-by-squaring (groups Scheme) (scan-data "#<procedure ipow-by-squaring (x k acc proc)>"))
+(isatty? (groups POSIX Scheme) (scan-data "#<primitive-procedure isatty?>"))
+(issue-deprecation-warning (groups Scheme) (scan-data "#<primitive-procedure issue-deprecation-warning>"))
+(join-thread (groups Scheme) (scan-data "#<primitive-procedure join-thread>"))
+(keyword->symbol (groups Scheme) (scan-data "#<procedure keyword->symbol (kw)>"))
+(keyword-dash-symbol (groups Scheme) (scan-data "#<primitive-procedure keyword-dash-symbol>"))
+(keyword-like-symbol->keyword (groups Scheme) (scan-data "#<procedure keyword-like-symbol->keyword (sym)>"))
+(keyword? (groups Scheme) (scan-data "#<primitive-procedure keyword?>"))
+(kill (groups POSIX Scheme) (scan-data "#<primitive-procedure kill>"))
+(kw-arg-ref (groups Scheme) (scan-data "#<procedure kw-arg-ref (args kw)>"))
+(lambda (groups Scheme) (scan-data ""))
+(last-pair (groups Scheme) (scan-data "#<primitive-procedure last-pair>"))
+(last-stack-frame (groups Scheme) (scan-data "#<primitive-procedure last-stack-frame>"))
+(lazy-catch (groups Scheme) (scan-data "#<primitive-procedure lazy-catch>"))
+(lazy-handler-dispatch (groups Scheme) (scan-data "#<procedure lazy-handler-dispatch (key . args)>"))
+(lcm (groups Scheme) (scan-data "#<primitive-procedure lcm>"))
+(leaf-environment? (groups Scheme) (scan-data "#<primitive-procedure leaf-environment?>"))
+(length (groups Scheme) (scan-data "#<primitive-procedure length>"))
+(let (groups Scheme) (scan-data ""))
+(let* (groups Scheme) (scan-data ""))
+(letrec (groups Scheme) (scan-data ""))
+(link (groups POSIX Scheme) (scan-data "#<primitive-procedure link>"))
+(list (groups Scheme) (scan-data "#<primitive-procedure list>"))
+(list->array (groups Scheme) (scan-data "#<procedure list->array (ndim lst)>"))
+(list->string (groups Scheme) (scan-data "#<primitive-procedure list->string>"))
+(list->symbol (groups Scheme) (scan-data "#<procedure list->symbol args>"))
+(list->uniform-array (groups Scheme) (scan-data "#<primitive-procedure list->uniform-array>"))
+(list->uniform-vector (groups Scheme) (scan-data "#<procedure list->uniform-vector (prot lst)>"))
+(list->vector (groups Scheme) (scan-data "#<primitive-procedure list->vector>"))
+(list->weak-vector (groups Scheme) (scan-data "#<primitive-procedure list->weak-vector>"))
+(list-cdr-ref (groups Scheme) (scan-data "#<primitive-procedure list-cdr-ref>"))
+(list-cdr-set! (groups Scheme) (scan-data "#<primitive-procedure list-cdr-set!>"))
+(list-copy (groups Scheme) (scan-data "#<primitive-procedure list-copy>"))
+(list-head (groups Scheme) (scan-data "#<primitive-procedure list-head>"))
+(list-index (groups Scheme) (scan-data "#<procedure list-index (l k)>"))
+(list-ref (groups Scheme) (scan-data "#<primitive-procedure list-ref>"))
+(list-set! (groups Scheme) (scan-data "#<primitive-procedure list-set!>"))
+(list-tail (groups Scheme) (scan-data "#<primitive-procedure list-tail>"))
+(list? (groups Scheme) (scan-data "#<primitive-procedure list?>"))
+(listen (groups Scheme) (scan-data "#<primitive-procedure listen>"))
+(load (groups Scheme) (scan-data "#<procedure load-module (filename)>"))
+(load-compiled (groups Scheme) (scan-data ""))
+(load-emacs-interface (groups Scheme) (scan-data "#<procedure load-emacs-interface ()>"))
+(load-extension (groups Scheme) (scan-data "#<primitive-procedure load-extension>"))
+(load-from-path (groups Scheme) (scan-data "#<procedure load-from-path (name)>"))
+(load-module (groups Scheme) (scan-data "#<procedure load-module (filename)>"))
+(load-user-init (groups Scheme) (scan-data "#<procedure load-user-init ()>"))
+(local-define (groups Scheme) (scan-data "#<procedure local-define (names val)>"))
+(local-eval (groups Scheme) (scan-data "#<primitive-procedure local-eval>"))
+(local-ref (groups Scheme) (scan-data "#<procedure local-ref (names)>"))
+(local-remove (groups Scheme) (scan-data "#<procedure local-remove (names)>"))
+(local-set! (groups Scheme) (scan-data "#<procedure local-set! (names val)>"))
+(localtime (groups POSIX Scheme) (scan-data "#<primitive-procedure localtime>"))
+(lock-mutex (groups Scheme) (scan-data "#<primitive-procedure lock-mutex>"))
+(log (groups Scheme) (scan-data "#<procedure log (z)>"))
+(log10 (groups Scheme) (scan-data "#<procedure log10 (arg)>"))
+(logand (groups Scheme) (scan-data "#<primitive-procedure logand>"))
+(logbit? (groups Scheme) (scan-data "#<primitive-procedure logbit?>"))
+(logcount (groups Scheme) (scan-data "#<primitive-procedure logcount>"))
+(logior (groups Scheme) (scan-data "#<primitive-procedure logior>"))
+(lognot (groups Scheme) (scan-data "#<primitive-procedure lognot>"))
+(logtest (groups Scheme) (scan-data "#<primitive-procedure logtest>"))
+(logxor (groups Scheme) (scan-data "#<primitive-procedure logxor>"))
+(lstat (groups POSIX Scheme) (scan-data "#<primitive-procedure lstat>"))
+(macro-name (groups Scheme) (scan-data "#<primitive-procedure macro-name>"))
+(macro-table (groups Scheme) (scan-data ""))
+(macro-transformer (groups Scheme) (scan-data "#<primitive-procedure macro-transformer>"))
+(macro-type (groups Scheme) (scan-data "#<primitive-procedure macro-type>"))
+(macro? (groups Scheme) (scan-data "#<primitive-procedure macro?>"))
+(macroexpand (groups Scheme) (scan-data "#<procedure macroexpand (e)>"))
+(macroexpand-1 (groups Scheme) (scan-data "#<procedure macroexpand-1 (e)>"))
+(magnitude (groups Scheme) (scan-data "#<primitive-procedure magnitude>"))
+(major-version (groups Scheme) (scan-data "#<primitive-procedure major-version>"))
+(make-arbiter (groups Scheme) (scan-data "#<primitive-procedure make-arbiter>"))
+(make-array (groups Scheme) (scan-data "#<procedure make-array (fill . args)>"))
+(make-autoload-interface (groups Scheme) (scan-data "#<procedure make-autoload-interface (module name bindings)>"))
+(make-class-object (groups Scheme) (scan-data "#<primitive-procedure make-class-object>"))
+(make-condition-variable (groups Scheme) (scan-data "#<primitive-procedure make-condition-variable>"))
+(make-doubly-weak-hash-table (groups Scheme) (scan-data "#<primitive-procedure make-doubly-weak-hash-table>"))
+(make-eval-environment (groups Scheme) (scan-data "#<primitive-procedure make-eval-environment>"))
+(make-export-environment (groups Scheme) (scan-data "#<primitive-procedure make-export-environment>"))
+(make-fluid (groups Scheme) (scan-data "#<primitive-procedure make-fluid>"))
+(make-guardian (groups Scheme) (scan-data "#<primitive-procedure make-guardian>"))
+(make-hash-table (groups Scheme) (scan-data "#<procedure make-hash-table (k)>"))
+(make-hook (groups Scheme) (scan-data "#<primitive-procedure make-hook>"))
+(make-import-environment (groups Scheme) (scan-data "#<primitive-procedure make-import-environment>"))
+(make-keyword-from-dash-symbol (groups Scheme) (scan-data "#<primitive-procedure make-keyword-from-dash-symbol>"))
+(make-leaf-environment (groups Scheme) (scan-data "#<primitive-procedure make-leaf-environment>"))
+(make-list (groups Scheme) (scan-data "#<procedure make-list (n . init)>"))
+(make-module (groups Scheme) (scan-data "#<procedure make-module args>"))
+(make-modules-in (groups Scheme) (scan-data "#<procedure make-modules-in (module name)>"))
+(make-mutex (groups Scheme) (scan-data "#<primitive-procedure make-mutex>"))
+(make-object-property (groups Scheme) (scan-data "#<procedure make-object-property ()>"))
+(make-polar (groups Scheme) (scan-data "#<primitive-procedure make-polar>"))
+(make-procedure-with-setter (groups Scheme) (scan-data "#<primitive-procedure make-procedure-with-setter>"))
+(make-record-type (groups Scheme) (scan-data "#<procedure make-record-type (type-name fields . opt)>"))
+(make-rectangular (groups Scheme) (scan-data "#<primitive-procedure make-rectangular>"))
+(make-regexp (groups Scheme) (scan-data "#<primitive-procedure make-regexp>"))
+(make-root-module (groups Scheme) (scan-data "#<procedure make-root-module ()>"))
+(make-scm-module (groups Scheme) (scan-data "#<procedure make-scm-module ()>"))
+(make-shared-array (groups Scheme) (scan-data "#<primitive-procedure make-shared-array>"))
+(make-soft-port (groups Scheme) (scan-data "#<primitive-procedure make-soft-port>"))
+(make-stack (groups Scheme) (scan-data "#<primitive-procedure make-stack>"))
+(make-string (groups Scheme) (scan-data "#<primitive-procedure make-string>"))
+(make-struct (groups Scheme) (scan-data "#<primitive-procedure make-struct>"))
+(make-struct-layout (groups Scheme) (scan-data "#<primitive-procedure make-struct-layout>"))
+(make-subclass-object (groups Scheme) (scan-data "#<primitive-procedure make-subclass-object>"))
+(make-symbol (groups Scheme) (scan-data "#<primitive-procedure make-symbol>"))
+(make-undefined-variable (groups Scheme) (scan-data "#<primitive-procedure make-undefined-variable>"))
+(make-uniform-array (groups Scheme) (scan-data "#<procedure make-uniform-array (prot . args)>"))
+(make-uniform-vector (groups Scheme) (scan-data "#<primitive-procedure dimensions->uniform-array>"))
+(make-variable (groups Scheme) (scan-data "#<primitive-procedure make-variable>"))
+(make-vector (groups Scheme) (scan-data "#<primitive-procedure make-vector>"))
+(make-vtable-vtable (groups Scheme) (scan-data "#<primitive-procedure make-vtable-vtable>"))
+(make-weak-key-hash-table (groups Scheme) (scan-data "#<primitive-procedure make-weak-key-hash-table>"))
+(make-weak-value-hash-table (groups Scheme) (scan-data "#<primitive-procedure make-weak-value-hash-table>"))
+(make-weak-vector (groups Scheme) (scan-data "#<primitive-procedure make-weak-vector>"))
+(map (groups Scheme) (scan-data "#<primitive-procedure map>"))
+(map-in-order (groups Scheme) (scan-data "#<primitive-procedure map-in-order>"))
+(mask-signals (groups Scheme) (scan-data "#<primitive-procedure mask-signals>"))
+(max (groups Scheme) (scan-data "#<primitive-procedure max>"))
+(member (groups Scheme) (scan-data "#<primitive-procedure member>"))
+(memoized-environment (groups Scheme) (scan-data "#<primitive-procedure memoized-environment>"))
+(memoized? (groups Scheme) (scan-data "#<primitive-procedure memoized?>"))
+(memq (groups Scheme) (scan-data "#<primitive-procedure memq>"))
+(memv (groups Scheme) (scan-data "#<primitive-procedure memv>"))
+(merge (groups Scheme) (scan-data "#<primitive-procedure merge>"))
+(merge! (groups Scheme) (scan-data "#<primitive-procedure merge!>"))
+(micro-version (groups Scheme) (scan-data "#<primitive-procedure micro-version>"))
+(min (groups Scheme) (scan-data "#<primitive-procedure min>"))
+(minor-version (groups Scheme) (scan-data "#<primitive-procedure minor-version>"))
+(mkdir (groups POSIX Scheme) (scan-data "#<primitive-procedure mkdir>"))
+(mknod (groups POSIX Scheme) (scan-data "#<primitive-procedure mknod>"))
+(mkstemp! (groups POSIX Scheme) (scan-data "#<primitive-procedure mkstemp!>"))
+(mktime (groups POSIX Scheme) (scan-data "#<primitive-procedure mktime>"))
+(module-add! (groups Scheme) (scan-data "#<procedure module-add! (m v var)>"))
+(module-binder (groups Scheme) (scan-data "#<procedure module-binder (obj)>"))
+(module-bound? (groups Scheme) (scan-data "#<procedure module-bound? (m v)>"))
+(module-clear! (groups Scheme) (scan-data "#<procedure module-clear! (m)>"))
+(module-constructor (groups Scheme) (scan-data "#<procedure module-constructor (obarray uses binder eval-closure transformer name kind observers weak-observers observer-id)>"))
+(module-define! (groups Scheme) (scan-data "#<procedure module-define! (module name value)>"))
+(module-defined? (groups Scheme) (scan-data "#<procedure module-defined? (module name)>"))
+(module-ensure-local-variable! (groups Scheme) (scan-data "#<procedure module-ensure-local-variable! (module symbol)>"))
+(module-eval-closure (groups Scheme) (scan-data "#<procedure module-eval-closure (obj)>"))
+(module-export! (groups Scheme) (scan-data "#<procedure module-export! (m names)>"))
+(module-for-each (groups Scheme) (scan-data "#<procedure module-for-each (proc module)>"))
+(module-kind (groups Scheme) (scan-data "#<procedure module-kind (obj)>"))
+(module-local-variable (groups Scheme) (scan-data "#<procedure module-local-variable (m v)>"))
+(module-locally-bound? (groups Scheme) (scan-data "#<procedure module-locally-bound? (m v)>"))
+(module-make-local-var! (groups Scheme) (scan-data "#<procedure module-make-local-var! (m v)>"))
+(module-map (groups Scheme) (scan-data "#<procedure module-map (proc module)>"))
+(module-modified (groups Scheme) (scan-data "#<procedure module-modified (m)>"))
+(module-name (groups Scheme) (scan-data "#<procedure module-name (obj)>"))
+(module-obarray (groups Scheme) (scan-data "#<procedure module-obarray (obj)>"))
+(module-obarray-get-handle (groups Scheme) (scan-data "#<procedure module-obarray-get-handle (ob key)>"))
+(module-obarray-ref (groups Scheme) (scan-data "#<procedure module-obarray-ref (ob key)>"))
+(module-obarray-remove! (groups Scheme) (scan-data "#<procedure module-obarray-remove! (ob key)>"))
+(module-obarray-set! (groups Scheme) (scan-data "#<procedure module-obarray-set! (ob key val)>"))
+(module-observe (groups Scheme) (scan-data "#<procedure module-observe (module proc)>"))
+(module-observe-weak (groups Scheme) (scan-data "#<procedure module-observe-weak (module proc)>"))
+(module-observer-id (groups Scheme) (scan-data "#<procedure module-observer-id (obj)>"))
+(module-observers (groups Scheme) (scan-data "#<procedure module-observers (obj)>"))
+(module-public-interface (groups Scheme) (scan-data "#<procedure module-public-interface (m)>"))
+(module-re-export! (groups Scheme) (scan-data "#<procedure module-re-export! (m names)>"))
+(module-ref (groups Scheme) (scan-data "#<procedure module-ref (module name . rest)>"))
+(module-remove! (groups Scheme) (scan-data "#<procedure module-remove! (m v)>"))
+(module-search (groups Scheme) (scan-data "#<procedure module-search (fn m v)>"))
+(module-set! (groups Scheme) (scan-data "#<procedure module-set! (module name value)>"))
+(module-symbol-binding (groups Scheme) (scan-data "#<procedure module-symbol-binding (m v . opt-val)>"))
+(module-symbol-interned? (groups Scheme) (scan-data "#<procedure module-symbol-interned? (m v)>"))
+(module-symbol-local-binding (groups Scheme) (scan-data "#<procedure module-symbol-local-binding (m v . opt-val)>"))
+(module-symbol-locally-interned? (groups Scheme) (scan-data "#<procedure module-symbol-locally-interned? (m v)>"))
+(module-transformer (groups Scheme) (scan-data "#<procedure module-transformer (obj)>"))
+(module-type (groups Scheme) (scan-data ""))
+(module-unobserve (groups Scheme) (scan-data "#<procedure module-unobserve (token)>"))
+(module-use! (groups Scheme) (scan-data "#<procedure module-use! (module interface)>"))
+(module-uses (groups Scheme) (scan-data "#<procedure module-uses (obj)>"))
+(module-variable (groups Scheme) (scan-data "#<procedure module-variable (m v)>"))
+(module-weak-observers (groups Scheme) (scan-data "#<procedure module-weak-observers (obj)>"))
+(module? (groups Scheme) (scan-data "#<procedure module? (obj)>"))
+(modulo (groups Scheme) (scan-data "#<primitive-procedure modulo>"))
+(most-negative-fixnum (groups Scheme) (scan-data ""))
+(most-positive-fixnum (groups Scheme) (scan-data ""))
+(move->fdes (groups POSIX Scheme) (scan-data "#<procedure move->fdes (fd/port fd)>"))
+(named-module-use! (groups Scheme) (scan-data "#<procedure named-module-use! (user usee)>"))
+(nan (groups Scheme) (scan-data "#<primitive-procedure nan>"))
+(nan? (groups Scheme) (scan-data "#<primitive-procedure nan?>"))
+(negative? (groups Scheme) (scan-data "#<primitive-procedure negative?>"))
+(nested-define! (groups Scheme) (scan-data "#<procedure nested-define! (root names val)>"))
+(nested-ref (groups Scheme) (scan-data "#<procedure nested-ref (root names)>"))
+(nested-remove! (groups Scheme) (scan-data "#<procedure nested-remove! (root names)>"))
+(nested-set! (groups Scheme) (scan-data "#<procedure nested-set! (root names val)>"))
+(netent:addrtype (groups Scheme) (scan-data "#<procedure netent:addrtype (obj)>"))
+(netent:aliases (groups Scheme) (scan-data "#<procedure netent:aliases (obj)>"))
+(netent:name (groups Scheme) (scan-data "#<procedure netent:name (obj)>"))
+(netent:net (groups Scheme) (scan-data "#<procedure netent:net (obj)>"))
+(newline (groups Scheme) (scan-data "#<primitive-procedure newline>"))
+(nice (groups POSIX Scheme) (scan-data "#<primitive-procedure nice>"))
+(nil-cond (groups Scheme) (scan-data ""))
+(noop (groups Scheme) (scan-data "#<primitive-procedure noop>"))
+(not (groups Scheme) (scan-data "#<primitive-procedure not>"))
+(ntohl (groups Scheme) (scan-data "#<primitive-procedure ntohl>"))
+(ntohs (groups Scheme) (scan-data "#<primitive-procedure ntohs>"))
+(null? (groups Scheme) (scan-data "#<primitive-procedure null?>"))
+(number->string (groups Scheme) (scan-data "#<primitive-procedure number->string>"))
+(number? (groups Scheme) (scan-data "#<primitive-procedure number?>"))
+(object->string (groups Scheme) (scan-data "#<primitive-procedure object->string>"))
+(object-address (groups Scheme) (scan-data "#<primitive-procedure object-address>"))
+(object-properties (groups Scheme) (scan-data "#<primitive-procedure object-properties>"))
+(object-property (groups Scheme) (scan-data "#<primitive-procedure object-property>"))
+(odd? (groups Scheme) (scan-data "#<primitive-procedure odd?>"))
+(open (groups POSIX Scheme) (scan-data "#<primitive-procedure open>"))
+(open-fdes (groups POSIX Scheme) (scan-data "#<primitive-procedure open-fdes>"))
+(open-file (groups Scheme) (scan-data "#<primitive-procedure open-file>"))
+(open-input-file (groups Scheme) (scan-data "#<procedure open-input-file (str)>"))
+(open-input-string (groups Scheme) (scan-data "#<primitive-procedure open-input-string>"))
+(open-io-file (groups Scheme) (scan-data "#<procedure open-io-file (str)>"))
+(open-output-file (groups Scheme) (scan-data "#<procedure open-output-file (str)>"))
+(open-output-string (groups Scheme) (scan-data "#<primitive-procedure open-output-string>"))
+(opendir (groups POSIX Scheme) (scan-data "#<primitive-procedure opendir>"))
+(operator? (groups Scheme) (scan-data "#<primitive-procedure operator?>"))
+(or (groups Scheme) (scan-data ""))
+(or-map (groups Scheme) (scan-data "#<procedure or-map (f lst)>"))
+(output-port? (groups Scheme) (scan-data "#<primitive-procedure output-port?>"))
+(pair? (groups Scheme) (scan-data "#<primitive-procedure pair?>"))
+(parse-path (groups Scheme) (scan-data "#<primitive-procedure parse-path>"))
+(passwd:dir (groups POSIX Scheme) (scan-data "#<procedure passwd:dir (obj)>"))
+(passwd:gecos (groups POSIX Scheme) (scan-data "#<procedure passwd:gecos (obj)>"))
+(passwd:gid (groups POSIX Scheme) (scan-data "#<procedure passwd:gid (obj)>"))
+(passwd:name (groups POSIX Scheme) (scan-data "#<procedure passwd:name (obj)>"))
+(passwd:passwd (groups POSIX Scheme) (scan-data "#<procedure passwd:passwd (obj)>"))
+(passwd:shell (groups POSIX Scheme) (scan-data "#<procedure passwd:shell (obj)>"))
+(passwd:uid (groups POSIX Scheme) (scan-data "#<procedure passwd:uid (obj)>"))
+(pause (groups POSIX Scheme) (scan-data "#<primitive-procedure pause>"))
+(peek (groups Scheme) (scan-data "#<procedure peek stuff>"))
+(peek-char (groups Scheme) (scan-data "#<primitive-procedure peek-char>"))
+(pipe (groups POSIX Scheme) (scan-data "#<primitive-procedure pipe>"))
+(pk (groups Scheme) (scan-data "#<procedure peek stuff>"))
+(port->fdes (groups POSIX Scheme) (scan-data "#<procedure port->fdes (port)>"))
+(port-closed? (groups Scheme) (scan-data "#<primitive-procedure port-closed?>"))
+(port-column (groups Scheme) (scan-data "#<primitive-procedure port-column>"))
+(port-filename (groups Scheme) (scan-data "#<primitive-procedure port-filename>"))
+(port-for-each (groups POSIX Scheme) (scan-data "#<primitive-procedure port-for-each>"))
+(port-line (groups Scheme) (scan-data "#<primitive-procedure port-line>"))
+(port-mode (groups POSIX Scheme) (scan-data "#<primitive-procedure port-mode>"))
+(port-revealed (groups POSIX Scheme) (scan-data "#<primitive-procedure port-revealed>"))
+(port-with-print-state (groups Scheme) (scan-data "#<primitive-procedure port-with-print-state>"))
+(port? (groups Scheme) (scan-data "#<primitive-procedure port?>"))
+(positive? (groups Scheme) (scan-data "#<primitive-procedure positive?>"))
+(primitive-eval (groups Scheme) (scan-data "#<primitive-procedure primitive-eval>"))
+(primitive-exit (groups POSIX Scheme) (scan-data "#<primitive-procedure primitive-exit>"))
+(primitive-fork (groups POSIX Scheme) (scan-data "#<primitive-procedure primitive-fork>"))
+(primitive-load (groups Scheme) (scan-data "#<primitive-procedure primitive-load>"))
+(primitive-load-path (groups Scheme) (scan-data "#<primitive-procedure primitive-load-path>"))
+(primitive-macro? (groups Scheme) (scan-data "#<procedure primitive-macro? (m)>"))
+(primitive-make-property (groups Scheme) (scan-data "#<primitive-procedure primitive-make-property>"))
+(primitive-move->fdes (groups POSIX Scheme) (scan-data "#<primitive-procedure primitive-move->fdes>"))
+(primitive-property-del! (groups Scheme) (scan-data "#<primitive-procedure primitive-property-del!>"))
+(primitive-property-ref (groups Scheme) (scan-data "#<primitive-procedure primitive-property-ref>"))
+(primitive-property-set! (groups Scheme) (scan-data "#<primitive-procedure primitive-property-set!>"))
+(print-disable (groups Scheme) (scan-data "#<procedure print-disable flags>"))
+(print-enable (groups Scheme) (scan-data "#<procedure print-enable flags>"))
+(print-options (groups Scheme) (scan-data "#<procedure print-options args>"))
+(print-options-interface (groups Scheme) (scan-data "#<primitive-procedure print-options-interface>"))
+(print-set! (groups Scheme) (scan-data ""))
+(procedure (groups Scheme) (scan-data "#<primitive-procedure procedure>"))
+(procedure->macro (groups Scheme) (scan-data "#<primitive-procedure procedure->macro>"))
+(procedure->memoizing-macro (groups Scheme) (scan-data "#<primitive-procedure procedure->memoizing-macro>"))
+(procedure->syntax (groups Scheme) (scan-data "#<primitive-procedure procedure->syntax>"))
+(procedure-documentation (groups Scheme) (scan-data "#<primitive-procedure procedure-documentation>"))
+(procedure-environment (groups Scheme) (scan-data "#<primitive-procedure procedure-environment>"))
+(procedure-name (groups Scheme) (scan-data "#<primitive-procedure procedure-name>"))
+(procedure-properties (groups Scheme) (scan-data "#<primitive-procedure procedure-properties>"))
+(procedure-property (groups Scheme) (scan-data "#<primitive-procedure procedure-property>"))
+(procedure-source (groups Scheme) (scan-data "#<primitive-procedure procedure-source>"))
+(procedure-with-setter? (groups Scheme) (scan-data "#<primitive-procedure procedure-with-setter?>"))
+(procedure? (groups Scheme) (scan-data "#<primitive-procedure procedure?>"))
+(process-define-module (groups Scheme) (scan-data "#<procedure process-define-module (args)>"))
+(process-use-modules (groups Scheme) (scan-data "#<procedure process-use-modules (module-interface-args)>"))
+(program-arguments (groups POSIX Scheme) (scan-data "#<primitive-procedure program-arguments>"))
+(promise? (groups Scheme) (scan-data "#<primitive-procedure promise?>"))
+(protoent:aliases (groups Scheme) (scan-data "#<procedure protoent:aliases (obj)>"))
+(protoent:name (groups Scheme) (scan-data "#<procedure protoent:name (obj)>"))
+(protoent:proto (groups Scheme) (scan-data "#<procedure protoent:proto (obj)>"))
+(provide (groups Scheme) (scan-data "#<procedure provide (sym)>"))
+(provided? (groups Scheme) (scan-data "#<procedure provided? (feature)>"))
+(purify-module! (groups Scheme) (scan-data "#<procedure purify-module! (module)>"))
+(putenv (groups POSIX Scheme) (scan-data "#<primitive-procedure putenv>"))
+(quasiquote (groups Scheme) (scan-data ""))
+(quit (groups Scheme) (scan-data "#<procedure quit args>"))
+(quote (groups Scheme) (scan-data ""))
+(quotient (groups Scheme) (scan-data "#<primitive-procedure quotient>"))
+(raise (groups POSIX Scheme) (scan-data "#<primitive-procedure raise>"))
+(random (groups Scheme) (scan-data "#<primitive-procedure random>"))
+(random:exp (groups Scheme) (scan-data "#<primitive-procedure random:exp>"))
+(random:hollow-sphere! (groups Scheme) (scan-data "#<primitive-procedure random:hollow-sphere!>"))
+(random:normal (groups Scheme) (scan-data "#<primitive-procedure random:normal>"))
+(random:normal-vector! (groups Scheme) (scan-data "#<primitive-procedure random:normal-vector!>"))
+(random:solid-sphere! (groups Scheme) (scan-data "#<primitive-procedure random:solid-sphere!>"))
+(random:uniform (groups Scheme) (scan-data "#<primitive-procedure random:uniform>"))
+(rational? (groups Scheme) (scan-data "#<primitive-procedure rational?>"))
+(re-export (groups Scheme) (scan-data ""))
+(re-export-syntax (groups Scheme) (scan-data ""))
+(read (groups Scheme) (scan-data "#<primitive-procedure read>"))
+(read-char (groups Scheme) (scan-data "#<primitive-procedure read-char>"))
+(read-disable (groups Scheme) (scan-data "#<procedure read-disable flags>"))
+(read-enable (groups Scheme) (scan-data "#<procedure read-enable flags>"))
+(read-eval? (groups Scheme) (scan-data ""))
+(read-hash-extend (groups Scheme) (scan-data "#<primitive-procedure read-hash-extend>"))
+(read-hash-procedures (groups Scheme) (scan-data ""))
+(read-options (groups Scheme) (scan-data "#<procedure read-options args>"))
+(read-options-interface (groups Scheme) (scan-data "#<primitive-procedure read-options-interface>"))
+(read-set! (groups Scheme) (scan-data ""))
+(read:array (groups Scheme) (scan-data "#<procedure read:array (digit port)>"))
+(read:uniform-vector (groups Scheme) (scan-data "#<procedure read:uniform-vector (proto port)>"))
+(readdir (groups POSIX Scheme) (scan-data "#<primitive-procedure readdir>"))
+(readlink (groups POSIX Scheme) (scan-data "#<primitive-procedure readlink>"))
+(real-part (groups Scheme) (scan-data "#<primitive-procedure real-part>"))
+(real? (groups Scheme) (scan-data "#<primitive-procedure real?>"))
+(record-accessor (groups Scheme) (scan-data "#<procedure record-accessor (rtd field-name)>"))
+(record-constructor (groups Scheme) (scan-data "#<procedure record-constructor (rtd . opt)>"))
+(record-modifier (groups Scheme) (scan-data "#<procedure record-modifier (rtd field-name)>"))
+(record-predicate (groups Scheme) (scan-data "#<procedure record-predicate (rtd)>"))
+(record-type-descriptor (groups Scheme) (scan-data "#<procedure record-type-descriptor (obj)>"))
+(record-type-fields (groups Scheme) (scan-data "#<procedure record-type-fields (obj)>"))
+(record-type-name (groups Scheme) (scan-data "#<procedure record-type-name (obj)>"))
+(record-type-vtable (groups Scheme) (scan-data ""))
+(record-type? (groups Scheme) (scan-data "#<procedure record-type? (obj)>"))
+(record? (groups Scheme) (scan-data "#<procedure record? (obj)>"))
+(recv! (groups Scheme) (scan-data "#<primitive-procedure recv!>"))
+(recvfrom! (groups Scheme) (scan-data "#<primitive-procedure recvfrom!>"))
+(redirect-port (groups POSIX Scheme) (scan-data "#<primitive-procedure redirect-port>"))
+(regexp-exec (groups Scheme) (scan-data "#<primitive-procedure regexp-exec>"))
+(regexp/basic (groups Scheme) (scan-data ""))
+(regexp/extended (groups Scheme) (scan-data ""))
+(regexp/icase (groups Scheme) (scan-data ""))
+(regexp/newline (groups Scheme) (scan-data ""))
+(regexp/notbol (groups Scheme) (scan-data ""))
+(regexp/noteol (groups Scheme) (scan-data ""))
+(regexp? (groups Scheme) (scan-data "#<primitive-procedure regexp?>"))
+(release-arbiter (groups Scheme) (scan-data "#<primitive-procedure release-arbiter>"))
+(release-port-handle (groups POSIX Scheme) (scan-data "#<procedure release-port-handle (port)>"))
+(remainder (groups Scheme) (scan-data "#<primitive-procedure remainder>"))
+(remove-hook! (groups Scheme) (scan-data "#<primitive-procedure remove-hook!>"))
+(rename-file (groups POSIX Scheme) (scan-data "#<primitive-procedure rename-file>"))
+(repl (groups Scheme) (scan-data "#<procedure repl (read evaler print)>"))
+(repl-reader (groups Scheme) (scan-data "#<procedure repl-reader (prompt)>"))
+(reset-hook! (groups Scheme) (scan-data "#<primitive-procedure reset-hook!>"))
+(resolve-interface (groups Scheme) (scan-data "#<procedure resolve-interface (name . args)>"))
+(resolve-module (groups Scheme) (scan-data "#<procedure resolve-module (name . maybe-autoload)>"))
+(restore-signals (groups POSIX Scheme) (scan-data "#<primitive-procedure restore-signals>"))
+(restricted-vector-sort! (groups Scheme) (scan-data "#<primitive-procedure restricted-vector-sort!>"))
+(reverse (groups Scheme) (scan-data "#<primitive-procedure reverse>"))
+(reverse! (groups Scheme) (scan-data "#<primitive-procedure reverse!>"))
+(rewinddir (groups POSIX Scheme) (scan-data "#<primitive-procedure rewinddir>"))
+(rmdir (groups POSIX Scheme) (scan-data "#<primitive-procedure rmdir>"))
+(round (groups Scheme) (scan-data "#<primitive-procedure round>"))
+(run-asyncs (groups Scheme) (scan-data "#<primitive-procedure run-asyncs>"))
+(run-hook (groups Scheme) (scan-data "#<primitive-procedure run-hook>"))
+(save-module-excursion (groups Scheme) (scan-data "#<procedure save-module-excursion (thunk)>"))
+(save-stack (groups Scheme) (scan-data "#<procedure save-stack narrowing>"))
+(scheme-file-suffix (groups Scheme) (scan-data "#<procedure scheme-file-suffix ()>"))
+(scm-error (groups Scheme) (scan-data "#<primitive-procedure scm-error>"))
+(scm-repl-print-unspecified (groups Scheme) (scan-data ""))
+(scm-repl-prompt (groups Scheme) (scan-data ""))
+(scm-repl-silent (groups Scheme) (scan-data ""))
+(scm-repl-verbose (groups Scheme) (scan-data ""))
+(scm-style-repl (groups Scheme) (scan-data "#<procedure scm-style-repl ()>"))
+(scm_I_am_dead (groups scm C) (scan-data B))
+(scm_abs (groups scm C) (scan-data T))
+(scm_accept (groups scm C) (scan-data T))
+(scm_access (groups scm C) (scan-data T))
+(scm_accessor_method_slot_definition (groups scm C) (scan-data T))
+(scm_acons (groups scm C) (scan-data T))
+(scm_acosh (groups scm C) (scan-data T))
+(scm_add_feature (groups scm C) (scan-data T))
+(scm_add_hook_x (groups scm C) (scan-data T))
+(scm_add_method (groups scm C) (scan-data T))
+(scm_add_slot (groups scm C) (scan-data T))
+(scm_add_to_port_table (groups scm C) (scan-data T))
+(scm_addbig (groups scm C) (scan-data T))
+(scm_after_gc_c_hook (groups scm C) (scan-data B))
+(scm_after_gc_hook (groups scm C) (scan-data B))
+(scm_after_sweep_c_hook (groups scm C) (scan-data B))
+(scm_aind (groups scm C) (scan-data T))
+(scm_alarm (groups scm C) (scan-data T))
+(scm_alloc_struct (groups scm C) (scan-data T))
+(scm_allocate_string (groups scm C) (scan-data T))
+(scm_angle (groups scm C) (scan-data T))
+(scm_append (groups scm C) (scan-data T))
+(scm_append_x (groups scm C) (scan-data T))
+(scm_apply (groups scm C) (scan-data T))
+(scm_apply_0 (groups scm C) (scan-data T))
+(scm_apply_1 (groups scm C) (scan-data T))
+(scm_apply_2 (groups scm C) (scan-data T))
+(scm_apply_3 (groups scm C) (scan-data T))
+(scm_apply_generic (groups scm C) (scan-data T))
+(scm_apply_with_dynamic_root (groups scm C) (scan-data T))
+(scm_arg_type_key (groups scm C) (scan-data B))
+(scm_args_number_key (groups scm C) (scan-data B))
+(scm_array_contents (groups scm C) (scan-data T))
+(scm_array_copy_x (groups scm C) (scan-data T))
+(scm_array_dimensions (groups scm C) (scan-data T))
+(scm_array_equal_p (groups scm C) (scan-data T))
+(scm_array_fill_int (groups scm C) (scan-data T))
+(scm_array_fill_x (groups scm C) (scan-data T))
+(scm_array_for_each (groups scm C) (scan-data T))
+(scm_array_identity (groups scm C) (scan-data T))
+(scm_array_in_bounds_p (groups scm C) (scan-data T))
+(scm_array_index_map_x (groups scm C) (scan-data T))
+(scm_array_map_x (groups scm C) (scan-data T))
+(scm_array_p (groups scm C) (scan-data T))
+(scm_array_prototype (groups scm C) (scan-data T))
+(scm_array_rank (groups scm C) (scan-data T))
+(scm_array_set_x (groups scm C) (scan-data T))
+(scm_array_to_list (groups scm C) (scan-data T))
+(scm_ash (groups scm C) (scan-data T))
+(scm_asinh (groups scm C) (scan-data T))
+(scm_assoc (groups scm C) (scan-data T))
+(scm_assoc_ref (groups scm C) (scan-data T))
+(scm_assoc_remove_x (groups scm C) (scan-data T))
+(scm_assoc_set_x (groups scm C) (scan-data T))
+(scm_assq (groups scm C) (scan-data T))
+(scm_assq_ref (groups scm C) (scan-data T))
+(scm_assq_remove_x (groups scm C) (scan-data T))
+(scm_assq_set_x (groups scm C) (scan-data T))
+(scm_assv (groups scm C) (scan-data T))
+(scm_assv_ref (groups scm C) (scan-data T))
+(scm_assv_remove_x (groups scm C) (scan-data T))
+(scm_assv_set_x (groups scm C) (scan-data T))
+(scm_async (groups scm C) (scan-data T))
+(scm_async_click (groups scm C) (scan-data T))
+(scm_async_mark (groups scm C) (scan-data T))
+(scm_asyncs_pending_p (groups scm C) (scan-data D))
+(scm_atanh (groups scm C) (scan-data T))
+(scm_backtrace (groups scm C) (scan-data T))
+(scm_badargsp (groups scm C) (scan-data T))
+(scm_basename (groups scm C) (scan-data T))
+(scm_basic_basic_make_class (groups scm C) (scan-data T))
+(scm_basic_make_class (groups scm C) (scan-data T))
+(scm_before_gc_c_hook (groups scm C) (scan-data B))
+(scm_before_mark_c_hook (groups scm C) (scan-data B))
+(scm_before_sweep_c_hook (groups scm C) (scan-data B))
+(scm_big_and (groups scm C) (scan-data T))
+(scm_big_ior (groups scm C) (scan-data T))
+(scm_big_test (groups scm C) (scan-data T))
+(scm_big_xor (groups scm C) (scan-data T))
+(scm_bigcomp (groups scm C) (scan-data T))
+(scm_bigequal (groups scm C) (scan-data T))
+(scm_bigprint (groups scm C) (scan-data T))
+(scm_bind (groups scm C) (scan-data T))
+(scm_bit_count (groups scm C) (scan-data T))
+(scm_bit_count_star (groups scm C) (scan-data T))
+(scm_bit_extract (groups scm C) (scan-data T))
+(scm_bit_invert_x (groups scm C) (scan-data T))
+(scm_bit_position (groups scm C) (scan-data T))
+(scm_bit_set_star_x (groups scm C) (scan-data T))
+(scm_block_gc (groups scm C) (scan-data D))
+(scm_body_thunk (groups scm C) (scan-data T))
+(scm_boolean_p (groups scm C) (scan-data T))
+(scm_boot_guile (groups scm C) (scan-data T))
+(scm_boot_guile_1_live (groups scm C) (scan-data D))
+(scm_c_call_with_current_module (groups scm C) (scan-data T))
+(scm_c_chars2byvect (groups scm C) (scan-data T))
+(scm_c_chars2scm (groups scm C) (scan-data T))
+(scm_c_default_rstate (groups scm C) (scan-data T))
+(scm_c_define (groups scm C) (scan-data T))
+(scm_c_define_gsubr (groups scm C) (scan-data T))
+(scm_c_define_gsubr_with_generic (groups scm C) (scan-data T))
+(scm_c_define_module (groups scm C) (scan-data T))
+(scm_c_define_subr (groups scm C) (scan-data T))
+(scm_c_define_subr_with_generic (groups scm C) (scan-data T))
+(scm_c_doubles2dvect (groups scm C) (scan-data T))
+(scm_c_doubles2scm (groups scm C) (scan-data T))
+(scm_c_environment_cell (groups scm C) (scan-data T))
+(scm_c_environment_fold (groups scm C) (scan-data T))
+(scm_c_environment_observe (groups scm C) (scan-data T))
+(scm_c_environment_ref (groups scm C) (scan-data T))
+(scm_c_eval_string (groups scm C) (scan-data T))
+(scm_c_exp1 (groups scm C) (scan-data T))
+(scm_c_export (groups scm C) (scan-data T))
+(scm_c_floats2fvect (groups scm C) (scan-data T))
+(scm_c_floats2scm (groups scm C) (scan-data T))
+(scm_c_get_internal_run_time (groups scm C) (scan-data T))
+(scm_c_hook_add (groups scm C) (scan-data T))
+(scm_c_hook_init (groups scm C) (scan-data T))
+(scm_c_hook_remove (groups scm C) (scan-data T))
+(scm_c_hook_run (groups scm C) (scan-data T))
+(scm_c_ints2ivect (groups scm C) (scan-data T))
+(scm_c_ints2scm (groups scm C) (scan-data T))
+(scm_c_issue_deprecation_warning (groups scm C) (scan-data T))
+(scm_c_issue_deprecation_warning_fmt (groups scm C) (scan-data T))
+(scm_c_load_extension (groups scm C) (scan-data T))
+(scm_c_longs2ivect (groups scm C) (scan-data T))
+(scm_c_longs2scm (groups scm C) (scan-data T))
+(scm_c_lookup (groups scm C) (scan-data T))
+(scm_c_make_gsubr (groups scm C) (scan-data T))
+(scm_c_make_gsubr_with_generic (groups scm C) (scan-data T))
+(scm_c_make_hash_table (groups scm C) (scan-data T))
+(scm_c_make_keyword (groups scm C) (scan-data T))
+(scm_c_make_rstate (groups scm C) (scan-data T))
+(scm_c_make_subr (groups scm C) (scan-data T))
+(scm_c_make_subr_with_generic (groups scm C) (scan-data T))
+(scm_c_make_vector (groups scm C) (scan-data T))
+(scm_c_memq (groups scm C) (scan-data T))
+(scm_c_module_define (groups scm C) (scan-data T))
+(scm_c_module_lookup (groups scm C) (scan-data T))
+(scm_c_normal01 (groups scm C) (scan-data T))
+(scm_c_primitive_load (groups scm C) (scan-data T))
+(scm_c_primitive_load_path (groups scm C) (scan-data T))
+(scm_c_random (groups scm C) (scan-data T))
+(scm_c_random_bignum (groups scm C) (scan-data T))
+(scm_c_read (groups scm C) (scan-data T))
+(scm_c_read_string (groups scm C) (scan-data T))
+(scm_c_register_extension (groups scm C) (scan-data T))
+(scm_c_resolve_module (groups scm C) (scan-data T))
+(scm_c_run_hook (groups scm C) (scan-data T))
+(scm_c_scm2chars (groups scm C) (scan-data T))
+(scm_c_scm2doubles (groups scm C) (scan-data T))
+(scm_c_scm2floats (groups scm C) (scan-data T))
+(scm_c_scm2ints (groups scm C) (scan-data T))
+(scm_c_scm2longs (groups scm C) (scan-data T))
+(scm_c_scm2shorts (groups scm C) (scan-data T))
+(scm_c_shorts2scm (groups scm C) (scan-data T))
+(scm_c_shorts2svect (groups scm C) (scan-data T))
+(scm_c_source_property_breakpoint_p (groups scm C) (scan-data T))
+(scm_c_string2str (groups scm C) (scan-data T))
+(scm_c_substring2str (groups scm C) (scan-data T))
+(scm_c_symbol2str (groups scm C) (scan-data T))
+(scm_c_uints2uvect (groups scm C) (scan-data T))
+(scm_c_ulongs2uvect (groups scm C) (scan-data T))
+(scm_c_uniform01 (groups scm C) (scan-data T))
+(scm_c_use_module (groups scm C) (scan-data T))
+(scm_c_with_fluid (groups scm C) (scan-data T))
+(scm_c_with_fluids (groups scm C) (scan-data T))
+(scm_c_write (groups scm C) (scan-data T))
+(scm_call_0 (groups scm C) (scan-data T))
+(scm_call_1 (groups scm C) (scan-data T))
+(scm_call_2 (groups scm C) (scan-data T))
+(scm_call_3 (groups scm C) (scan-data T))
+(scm_call_4 (groups scm C) (scan-data T))
+(scm_call_generic_0 (groups scm C) (scan-data T))
+(scm_call_generic_1 (groups scm C) (scan-data T))
+(scm_call_generic_2 (groups scm C) (scan-data T))
+(scm_call_generic_3 (groups scm C) (scan-data T))
+(scm_call_with_dynamic_root (groups scm C) (scan-data T))
+(scm_call_with_input_string (groups scm C) (scan-data T))
+(scm_call_with_new_thread (groups scm C) (scan-data T))
+(scm_call_with_output_string (groups scm C) (scan-data T))
+(scm_casei_streq (groups scm C) (scan-data T))
+(scm_catch (groups scm C) (scan-data T))
+(scm_cellp (groups scm C) (scan-data T))
+(scm_cells_allocated (groups scm C) (scan-data D))
+(scm_ceval (groups scm C) (scan-data T))
+(scm_ceval_ptr (groups scm C) (scan-data B))
+(scm_change_object_class (groups scm C) (scan-data T))
+(scm_char_alphabetic_p (groups scm C) (scan-data T))
+(scm_char_ci_eq_p (groups scm C) (scan-data T))
+(scm_char_ci_geq_p (groups scm C) (scan-data T))
+(scm_char_ci_gr_p (groups scm C) (scan-data T))
+(scm_char_ci_leq_p (groups scm C) (scan-data T))
+(scm_char_ci_less_p (groups scm C) (scan-data T))
+(scm_char_downcase (groups scm C) (scan-data T))
+(scm_char_eq_p (groups scm C) (scan-data T))
+(scm_char_geq_p (groups scm C) (scan-data T))
+(scm_char_gr_p (groups scm C) (scan-data T))
+(scm_char_is_both_p (groups scm C) (scan-data T))
+(scm_char_leq_p (groups scm C) (scan-data T))
+(scm_char_less_p (groups scm C) (scan-data T))
+(scm_char_lower_case_p (groups scm C) (scan-data T))
+(scm_char_numeric_p (groups scm C) (scan-data T))
+(scm_char_p (groups scm C) (scan-data T))
+(scm_char_ready_p (groups scm C) (scan-data T))
+(scm_char_to_integer (groups scm C) (scan-data T))
+(scm_char_upcase (groups scm C) (scan-data T))
+(scm_char_upper_case_p (groups scm C) (scan-data T))
+(scm_char_whitespace_p (groups scm C) (scan-data T))
+(scm_charnames (groups scm C) (scan-data D))
+(scm_charnums (groups scm C) (scan-data R))
+(scm_chdir (groups scm C) (scan-data T))
+(scm_check_apply_p (groups scm C) (scan-data B))
+(scm_check_entry_p (groups scm C) (scan-data B))
+(scm_check_exit_p (groups scm C) (scan-data B))
+(scm_chmod (groups scm C) (scan-data T))
+(scm_chown (groups scm C) (scan-data T))
+(scm_chroot (groups scm C) (scan-data T))
+(scm_class_accessor (groups scm C) (scan-data B))
+(scm_class_boolean (groups scm C) (scan-data B))
+(scm_class_char (groups scm C) (scan-data B))
+(scm_class_class (groups scm C) (scan-data B))
+(scm_class_complex (groups scm C) (scan-data B))
+(scm_class_direct_methods (groups scm C) (scan-data T))
+(scm_class_direct_slots (groups scm C) (scan-data T))
+(scm_class_direct_subclasses (groups scm C) (scan-data T))
+(scm_class_direct_supers (groups scm C) (scan-data T))
+(scm_class_double (groups scm C) (scan-data B))
+(scm_class_entity (groups scm C) (scan-data B))
+(scm_class_entity_class (groups scm C) (scan-data B))
+(scm_class_entity_with_setter (groups scm C) (scan-data B))
+(scm_class_environment (groups scm C) (scan-data T))
+(scm_class_float (groups scm C) (scan-data B))
+(scm_class_foreign_class (groups scm C) (scan-data B))
+(scm_class_foreign_object (groups scm C) (scan-data B))
+(scm_class_foreign_slot (groups scm C) (scan-data B))
+(scm_class_generic (groups scm C) (scan-data B))
+(scm_class_generic_with_setter (groups scm C) (scan-data B))
+(scm_class_input_output_port (groups scm C) (scan-data B))
+(scm_class_input_port (groups scm C) (scan-data B))
+(scm_class_int (groups scm C) (scan-data B))
+(scm_class_integer (groups scm C) (scan-data B))
+(scm_class_keyword (groups scm C) (scan-data B))
+(scm_class_list (groups scm C) (scan-data B))
+(scm_class_method (groups scm C) (scan-data B))
+(scm_class_name (groups scm C) (scan-data T))
+(scm_class_null (groups scm C) (scan-data B))
+(scm_class_number (groups scm C) (scan-data B))
+(scm_class_object (groups scm C) (scan-data B))
+(scm_class_of (groups scm C) (scan-data T))
+(scm_class_opaque (groups scm C) (scan-data B))
+(scm_class_operator_class (groups scm C) (scan-data B))
+(scm_class_operator_with_setter_class (groups scm C) (scan-data B))
+(scm_class_output_port (groups scm C) (scan-data B))
+(scm_class_pair (groups scm C) (scan-data B))
+(scm_class_port (groups scm C) (scan-data B))
+(scm_class_precedence_list (groups scm C) (scan-data T))
+(scm_class_primitive_generic (groups scm C) (scan-data B))
+(scm_class_procedure (groups scm C) (scan-data B))
+(scm_class_procedure_class (groups scm C) (scan-data B))
+(scm_class_procedure_with_setter (groups scm C) (scan-data B))
+(scm_class_protected (groups scm C) (scan-data B))
+(scm_class_protected_opaque (groups scm C) (scan-data B))
+(scm_class_protected_read_only (groups scm C) (scan-data B))
+(scm_class_read_only (groups scm C) (scan-data B))
+(scm_class_real (groups scm C) (scan-data B))
+(scm_class_scm (groups scm C) (scan-data B))
+(scm_class_self (groups scm C) (scan-data B))
+(scm_class_simple_method (groups scm C) (scan-data B))
+(scm_class_slots (groups scm C) (scan-data T))
+(scm_class_string (groups scm C) (scan-data B))
+(scm_class_symbol (groups scm C) (scan-data B))
+(scm_class_top (groups scm C) (scan-data B))
+(scm_class_unknown (groups scm C) (scan-data B))
+(scm_class_vector (groups scm C) (scan-data B))
+(scm_close (groups scm C) (scan-data T))
+(scm_close_fdes (groups scm C) (scan-data T))
+(scm_close_input_port (groups scm C) (scan-data T))
+(scm_close_output_port (groups scm C) (scan-data T))
+(scm_close_port (groups scm C) (scan-data T))
+(scm_closedir (groups scm C) (scan-data T))
+(scm_closure (groups scm C) (scan-data T))
+(scm_closure_p (groups scm C) (scan-data T))
+(scm_compile_shell_switches (groups scm C) (scan-data T))
+(scm_complex_equalp (groups scm C) (scan-data T))
+(scm_components (groups scm C) (scan-data B))
+(scm_compute_applicable_methods (groups scm C) (scan-data T))
+(scm_connect (groups scm C) (scan-data T))
+(scm_cons (groups scm C) (scan-data T))
+(scm_cons2 (groups scm C) (scan-data T))
+(scm_cons_source (groups scm C) (scan-data T))
+(scm_cons_star (groups scm C) (scan-data T))
+(scm_copy_big_dec (groups scm C) (scan-data T))
+(scm_copy_file (groups scm C) (scan-data T))
+(scm_copy_fluids (groups scm C) (scan-data T))
+(scm_copy_random_state (groups scm C) (scan-data T))
+(scm_copy_smaller (groups scm C) (scan-data T))
+(scm_copy_tree (groups scm C) (scan-data T))
+(scm_count_argv (groups scm C) (scan-data T))
+(scm_critical_section_mutex (groups scm C) (scan-data B))
+(scm_crypt (groups scm C) (scan-data T))
+(scm_ctermid (groups scm C) (scan-data T))
+(scm_current_error_port (groups scm C) (scan-data T))
+(scm_current_input_port (groups scm C) (scan-data T))
+(scm_current_load_port (groups scm C) (scan-data T))
+(scm_current_module (groups scm C) (scan-data T))
+(scm_current_module_lookup_closure (groups scm C) (scan-data T))
+(scm_current_module_transformer (groups scm C) (scan-data T))
+(scm_current_output_port (groups scm C) (scan-data T))
+(scm_current_time (groups scm C) (scan-data T))
+(scm_cuserid (groups scm C) (scan-data T))
+(scm_cvref (groups scm C) (scan-data T))
+(scm_dapply (groups scm C) (scan-data T))
+(scm_dblprec (groups scm C) (scan-data B))
+(scm_debug_eframe_size (groups scm C) (scan-data B))
+(scm_debug_mode (groups scm C) (scan-data B))
+(scm_debug_object_p (groups scm C) (scan-data T))
+(scm_debug_options (groups scm C) (scan-data T))
+(scm_debug_opts (groups scm C) (scan-data D))
+(scm_default_init_heap_size_1 (groups scm C) (scan-data D))
+(scm_default_init_heap_size_2 (groups scm C) (scan-data D))
+(scm_default_max_segment_size (groups scm C) (scan-data D))
+(scm_default_min_yield_1 (groups scm C) (scan-data D))
+(scm_default_min_yield_2 (groups scm C) (scan-data D))
+(scm_define (groups scm C) (scan-data T))
+(scm_definedp (groups scm C) (scan-data T))
+(scm_delete (groups scm C) (scan-data T))
+(scm_delete1_x (groups scm C) (scan-data T))
+(scm_delete_file (groups scm C) (scan-data T))
+(scm_delete_x (groups scm C) (scan-data T))
+(scm_delq (groups scm C) (scan-data T))
+(scm_delq1_x (groups scm C) (scan-data T))
+(scm_delq_x (groups scm C) (scan-data T))
+(scm_delv (groups scm C) (scan-data T))
+(scm_delv1_x (groups scm C) (scan-data T))
+(scm_delv_x (groups scm C) (scan-data T))
+(scm_deprecated_newcell (groups scm C) (scan-data T))
+(scm_deprecated_newcell2 (groups scm C) (scan-data T))
+(scm_destroy_guardian_x (groups scm C) (scan-data T))
+(scm_deval (groups scm C) (scan-data T))
+(scm_difference (groups scm C) (scan-data T))
+(scm_dimensions_to_uniform_array (groups scm C) (scan-data T))
+(scm_directory_stream_p (groups scm C) (scan-data T))
+(scm_dirname (groups scm C) (scan-data T))
+(scm_display (groups scm C) (scan-data T))
+(scm_display_application (groups scm C) (scan-data T))
+(scm_display_backtrace (groups scm C) (scan-data T))
+(scm_display_error (groups scm C) (scan-data T))
+(scm_display_error_message (groups scm C) (scan-data T))
+(scm_divbigdig (groups scm C) (scan-data T))
+(scm_divide (groups scm C) (scan-data T))
+(scm_done_free (groups scm C) (scan-data T))
+(scm_done_malloc (groups scm C) (scan-data T))
+(scm_dot_string (groups scm C) (scan-data B))
+(scm_double2num (groups scm C) (scan-data T))
+(scm_doubly_weak_hash_table_p (groups scm C) (scan-data T))
+(scm_dowinds (groups scm C) (scan-data T))
+(scm_downcase (groups scm C) (scan-data T))
+(scm_drain_input (groups scm C) (scan-data T))
+(scm_dup2 (groups scm C) (scan-data T))
+(scm_dup_to_fdes (groups scm C) (scan-data T))
+(scm_dynamic_args_call (groups scm C) (scan-data T))
+(scm_dynamic_call (groups scm C) (scan-data T))
+(scm_dynamic_func (groups scm C) (scan-data T))
+(scm_dynamic_link (groups scm C) (scan-data T))
+(scm_dynamic_object_p (groups scm C) (scan-data T))
+(scm_dynamic_root (groups scm C) (scan-data T))
+(scm_dynamic_unlink (groups scm C) (scan-data T))
+(scm_dynamic_wind (groups scm C) (scan-data T))
+(scm_enable_primitive_generic_x (groups scm C) (scan-data T))
+(scm_enclose_array (groups scm C) (scan-data T))
+(scm_end_input (groups scm C) (scan-data T))
+(scm_ensure_accessor (groups scm C) (scan-data T))
+(scm_entity_p (groups scm C) (scan-data T))
+(scm_env_module (groups scm C) (scan-data T))
+(scm_env_top_level (groups scm C) (scan-data T))
+(scm_environ (groups scm C) (scan-data T))
+(scm_environment_bound_p (groups scm C) (scan-data T))
+(scm_environment_cell (groups scm C) (scan-data T))
+(scm_environment_define (groups scm C) (scan-data T))
+(scm_environment_fold (groups scm C) (scan-data T))
+(scm_environment_observe (groups scm C) (scan-data T))
+(scm_environment_observe_weak (groups scm C) (scan-data T))
+(scm_environment_p (groups scm C) (scan-data T))
+(scm_environment_ref (groups scm C) (scan-data T))
+(scm_environment_set_x (groups scm C) (scan-data T))
+(scm_environment_undefine (groups scm C) (scan-data T))
+(scm_environment_unobserve (groups scm C) (scan-data T))
+(scm_environments_prehistory (groups scm C) (scan-data T))
+(scm_eof_object_p (groups scm C) (scan-data T))
+(scm_eq_p (groups scm C) (scan-data T))
+(scm_equal_p (groups scm C) (scan-data T))
+(scm_eqv_p (groups scm C) (scan-data T))
+(scm_error (groups scm C) (scan-data T))
+(scm_error_environment_immutable_binding (groups scm C) (scan-data T))
+(scm_error_environment_immutable_location (groups scm C) (scan-data T))
+(scm_error_environment_unbound (groups scm C) (scan-data T))
+(scm_error_num_args_subr (groups scm C) (scan-data T))
+(scm_error_revive_threads (groups scm C) (scan-data T))
+(scm_error_scm (groups scm C) (scan-data T))
+(scm_eval (groups scm C) (scan-data T))
+(scm_eval_args (groups scm C) (scan-data T))
+(scm_eval_body (groups scm C) (scan-data T))
+(scm_eval_car (groups scm C) (scan-data T))
+(scm_eval_closure_lookup (groups scm C) (scan-data T))
+(scm_eval_environment_imported (groups scm C) (scan-data T))
+(scm_eval_environment_local (groups scm C) (scan-data T))
+(scm_eval_environment_p (groups scm C) (scan-data T))
+(scm_eval_environment_set_imported_x (groups scm C) (scan-data T))
+(scm_eval_environment_set_local_x (groups scm C) (scan-data T))
+(scm_eval_options_interface (groups scm C) (scan-data T))
+(scm_eval_opts (groups scm C) (scan-data D))
+(scm_eval_stack (groups scm C) (scan-data B))
+(scm_eval_string (groups scm C) (scan-data T))
+(scm_eval_x (groups scm C) (scan-data T))
+(scm_evaluator_trap_table (groups scm C) (scan-data D))
+(scm_evaluator_traps (groups scm C) (scan-data T))
+(scm_even_p (groups scm C) (scan-data T))
+(scm_evict_ports (groups scm C) (scan-data T))
+(scm_exact_p (groups scm C) (scan-data T))
+(scm_exact_to_inexact (groups scm C) (scan-data T))
+(scm_execl (groups scm C) (scan-data T))
+(scm_execle (groups scm C) (scan-data T))
+(scm_execlp (groups scm C) (scan-data T))
+(scm_exit_status (groups scm C) (scan-data T))
+(scm_expmem (groups scm C) (scan-data D))
+(scm_export_environment_p (groups scm C) (scan-data T))
+(scm_export_environment_private (groups scm C) (scan-data T))
+(scm_export_environment_set_private_x (groups scm C) (scan-data T))
+(scm_export_environment_set_signature_x (groups scm C) (scan-data T))
+(scm_export_environment_signature (groups scm C) (scan-data T))
+(scm_f_apply (groups scm C) (scan-data B))
+(scm_f_gsubr_apply (groups scm C) (scan-data B))
+(scm_fcntl (groups scm C) (scan-data T))
+(scm_fdes_to_port (groups scm C) (scan-data T))
+(scm_fdes_to_ports (groups scm C) (scan-data T))
+(scm_fdopen (groups scm C) (scan-data T))
+(scm_file_port_p (groups scm C) (scan-data T))
+(scm_fileno (groups scm C) (scan-data T))
+(scm_fill_input (groups scm C) (scan-data T))
+(scm_find_executable (groups scm C) (scan-data T))
+(scm_find_method (groups scm C) (scan-data T))
+(scm_finish_srcprop (groups scm C) (scan-data T))
+(scm_float2num (groups scm C) (scan-data T))
+(scm_flock (groups scm C) (scan-data T))
+(scm_fluid_p (groups scm C) (scan-data T))
+(scm_fluid_ref (groups scm C) (scan-data T))
+(scm_fluid_set_x (groups scm C) (scan-data T))
+(scm_flush (groups scm C) (scan-data T))
+(scm_flush_all_ports (groups scm C) (scan-data T))
+(scm_flush_ws (groups scm C) (scan-data T))
+(scm_for_each (groups scm C) (scan-data T))
+(scm_force (groups scm C) (scan-data T))
+(scm_force_output (groups scm C) (scan-data T))
+(scm_fork (groups scm C) (scan-data T))
+(scm_frame_arguments (groups scm C) (scan-data T))
+(scm_frame_evaluating_args_p (groups scm C) (scan-data T))
+(scm_frame_next (groups scm C) (scan-data T))
+(scm_frame_number (groups scm C) (scan-data T))
+(scm_frame_overflow_p (groups scm C) (scan-data T))
+(scm_frame_p (groups scm C) (scan-data T))
+(scm_frame_previous (groups scm C) (scan-data T))
+(scm_frame_procedure (groups scm C) (scan-data T))
+(scm_frame_procedure_p (groups scm C) (scan-data T))
+(scm_frame_real_p (groups scm C) (scan-data T))
+(scm_frame_source (groups scm C) (scan-data T))
+(scm_free0 (groups scm C) (scan-data T))
+(scm_free_print_state (groups scm C) (scan-data T))
+(scm_free_subr_entry (groups scm C) (scan-data T))
+(scm_freelist (groups scm C) (scan-data D))
+(scm_freelist2 (groups scm C) (scan-data D))
+(scm_fsync (groups scm C) (scan-data T))
+(scm_ftell (groups scm C) (scan-data T))
+(scm_gc (groups scm C) (scan-data T))
+(scm_gc_cells_collected (groups scm C) (scan-data B))
+(scm_gc_cells_marked_acc (groups scm C) (scan-data D))
+(scm_gc_cells_swept (groups scm C) (scan-data D))
+(scm_gc_cells_swept_acc (groups scm C) (scan-data D))
+(scm_gc_for_newcell (groups scm C) (scan-data T))
+(scm_gc_free (groups scm C) (scan-data T))
+(scm_gc_heap_lock (groups scm C) (scan-data D))
+(scm_gc_malloc (groups scm C) (scan-data T))
+(scm_gc_malloc_collected (groups scm C) (scan-data B))
+(scm_gc_mark (groups scm C) (scan-data T))
+(scm_gc_mark_dependencies (groups scm C) (scan-data T))
+(scm_gc_mark_time_taken (groups scm C) (scan-data D))
+(scm_gc_ports_collected (groups scm C) (scan-data B))
+(scm_gc_protect_object (groups scm C) (scan-data T))
+(scm_gc_realloc (groups scm C) (scan-data T))
+(scm_gc_register_collectable_memory (groups scm C) (scan-data T))
+(scm_gc_register_root (groups scm C) (scan-data T))
+(scm_gc_register_roots (groups scm C) (scan-data T))
+(scm_gc_running_p (groups scm C) (scan-data D))
+(scm_gc_stats (groups scm C) (scan-data T))
+(scm_gc_strdup (groups scm C) (scan-data T))
+(scm_gc_strndup (groups scm C) (scan-data T))
+(scm_gc_sweep (groups scm C) (scan-data T))
+(scm_gc_sweep_time_taken (groups scm C) (scan-data D))
+(scm_gc_time_taken (groups scm C) (scan-data D))
+(scm_gc_times (groups scm C) (scan-data D))
+(scm_gc_unprotect_object (groups scm C) (scan-data T))
+(scm_gc_unregister_collectable_memory (groups scm C) (scan-data T))
+(scm_gc_unregister_root (groups scm C) (scan-data T))
+(scm_gc_unregister_roots (groups scm C) (scan-data T))
+(scm_gc_yield (groups scm C) (scan-data B))
+(scm_gcd (groups scm C) (scan-data T))
+(scm_generic_capability_p (groups scm C) (scan-data T))
+(scm_generic_function_methods (groups scm C) (scan-data T))
+(scm_generic_function_name (groups scm C) (scan-data T))
+(scm_gensym (groups scm C) (scan-data T))
+(scm_geq_p (groups scm C) (scan-data T))
+(scm_get_internal_real_time (groups scm C) (scan-data T))
+(scm_get_internal_run_time (groups scm C) (scan-data T))
+(scm_get_keyword (groups scm C) (scan-data T))
+(scm_get_meta_args (groups scm C) (scan-data T))
+(scm_get_one_zombie (groups scm C) (scan-data T))
+(scm_get_output_string (groups scm C) (scan-data T))
+(scm_get_pre_modules_obarray (groups scm C) (scan-data T))
+(scm_get_print_state (groups scm C) (scan-data T))
+(scm_get_stack_base (groups scm C) (scan-data T))
+(scm_getc (groups scm C) (scan-data T))
+(scm_getcwd (groups scm C) (scan-data T))
+(scm_getegid (groups scm C) (scan-data T))
+(scm_getenv (groups scm C) (scan-data T))
+(scm_geteuid (groups scm C) (scan-data T))
+(scm_getgid (groups scm C) (scan-data T))
+(scm_getgrgid (groups scm C) (scan-data T))
+(scm_getgroups (groups scm C) (scan-data T))
+(scm_gethost (groups scm C) (scan-data T))
+(scm_gethostname (groups scm C) (scan-data T))
+(scm_getitimer (groups scm C) (scan-data T))
+(scm_getlogin (groups scm C) (scan-data T))
+(scm_getnet (groups scm C) (scan-data T))
+(scm_getpass (groups scm C) (scan-data T))
+(scm_getpeername (groups scm C) (scan-data T))
+(scm_getpgrp (groups scm C) (scan-data T))
+(scm_getpid (groups scm C) (scan-data T))
+(scm_getppid (groups scm C) (scan-data T))
+(scm_getpriority (groups scm C) (scan-data T))
+(scm_getproto (groups scm C) (scan-data T))
+(scm_getpwuid (groups scm C) (scan-data T))
+(scm_getserv (groups scm C) (scan-data T))
+(scm_getsockname (groups scm C) (scan-data T))
+(scm_getsockopt (groups scm C) (scan-data T))
+(scm_gettimeofday (groups scm C) (scan-data T))
+(scm_getuid (groups scm C) (scan-data T))
+(scm_gmtime (groups scm C) (scan-data T))
+(scm_gr_p (groups scm C) (scan-data T))
+(scm_grow_tok_buf (groups scm C) (scan-data T))
+(scm_gsubr_apply (groups scm C) (scan-data T))
+(scm_guard (groups scm C) (scan-data T))
+(scm_guardian_destroyed_p (groups scm C) (scan-data T))
+(scm_guardian_greedy_p (groups scm C) (scan-data T))
+(scm_handle_by_message (groups scm C) (scan-data T))
+(scm_handle_by_message_noexit (groups scm C) (scan-data T))
+(scm_handle_by_proc (groups scm C) (scan-data T))
+(scm_handle_by_proc_catching_all (groups scm C) (scan-data T))
+(scm_handle_by_throw (groups scm C) (scan-data T))
+(scm_hash (groups scm C) (scan-data T))
+(scm_hash_create_handle_x (groups scm C) (scan-data T))
+(scm_hash_fn_create_handle_x (groups scm C) (scan-data T))
+(scm_hash_fn_get_handle (groups scm C) (scan-data T))
+(scm_hash_fn_ref (groups scm C) (scan-data T))
+(scm_hash_fn_remove_x (groups scm C) (scan-data T))
+(scm_hash_fn_set_x (groups scm C) (scan-data T))
+(scm_hash_fold (groups scm C) (scan-data T))
+(scm_hash_get_handle (groups scm C) (scan-data T))
+(scm_hash_ref (groups scm C) (scan-data T))
+(scm_hash_remove_x (groups scm C) (scan-data T))
+(scm_hash_set_x (groups scm C) (scan-data T))
+(scm_hasher (groups scm C) (scan-data T))
+(scm_hashq (groups scm C) (scan-data T))
+(scm_hashq_create_handle_x (groups scm C) (scan-data T))
+(scm_hashq_get_handle (groups scm C) (scan-data T))
+(scm_hashq_ref (groups scm C) (scan-data T))
+(scm_hashq_remove_x (groups scm C) (scan-data T))
+(scm_hashq_set_x (groups scm C) (scan-data T))
+(scm_hashv (groups scm C) (scan-data T))
+(scm_hashv_create_handle_x (groups scm C) (scan-data T))
+(scm_hashv_get_handle (groups scm C) (scan-data T))
+(scm_hashv_ref (groups scm C) (scan-data T))
+(scm_hashv_remove_x (groups scm C) (scan-data T))
+(scm_hashv_set_x (groups scm C) (scan-data T))
+(scm_hashx_create_handle_x (groups scm C) (scan-data T))
+(scm_hashx_get_handle (groups scm C) (scan-data T))
+(scm_hashx_ref (groups scm C) (scan-data T))
+(scm_hashx_remove_x (groups scm C) (scan-data T))
+(scm_hashx_set_x (groups scm C) (scan-data T))
+(scm_heap_org (groups scm C) (scan-data B))
+(scm_heap_table (groups scm C) (scan-data D))
+(scm_hook_empty_p (groups scm C) (scan-data T))
+(scm_hook_p (groups scm C) (scan-data T))
+(scm_hook_to_list (groups scm C) (scan-data T))
+(scm_htonl (groups scm C) (scan-data T))
+(scm_htons (groups scm C) (scan-data T))
+(scm_i_adjbig (groups scm libguile-internal C) (scan-data T))
+(scm_i_big2dbl (groups scm libguile-internal C) (scan-data T))
+(scm_i_big2inum (groups scm libguile-internal C) (scan-data T))
+(scm_i_copy_rstate (groups scm libguile-internal C) (scan-data T))
+(scm_i_copybig (groups scm libguile-internal C) (scan-data T))
+(scm_i_dbl2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_display_error (groups scm libguile-internal C) (scan-data T))
+(scm_i_dummy (groups scm libguile-internal C) (scan-data B))
+(scm_i_eval (groups scm libguile-internal C) (scan-data T))
+(scm_i_eval_x (groups scm libguile-internal C) (scan-data T))
+(scm_i_get_keyword (groups scm libguile-internal C) (scan-data T))
+(scm_i_init_rstate (groups scm libguile-internal C) (scan-data T))
+(scm_i_int2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_long2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_long_long2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_make_class_object (groups scm libguile-internal C) (scan-data T))
+(scm_i_mem2number (groups scm libguile-internal C) (scan-data T))
+(scm_i_mkbig (groups scm libguile-internal C) (scan-data T))
+(scm_i_normbig (groups scm libguile-internal C) (scan-data T))
+(scm_i_procedure_arity (groups scm libguile-internal C) (scan-data T))
+(scm_i_ptrdiff2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_short2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_size2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_terminating (groups scm libguile-internal C) (scan-data B))
+(scm_i_uint2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_ulong2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_ulong_long2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_uniform32 (groups scm libguile-internal C) (scan-data T))
+(scm_i_ushort2big (groups scm libguile-internal C) (scan-data T))
+(scm_i_variable_print (groups scm libguile-internal C) (scan-data T))
+(scm_ice_9_already_loaded (groups scm C) (scan-data D))
+(scm_igc (groups scm C) (scan-data T))
+(scm_ihash (groups scm C) (scan-data T))
+(scm_ihashq (groups scm C) (scan-data T))
+(scm_ihashv (groups scm C) (scan-data T))
+(scm_iint2str (groups scm C) (scan-data T))
+(scm_ilength (groups scm C) (scan-data T))
+(scm_ilookup (groups scm C) (scan-data T))
+(scm_imag_part (groups scm C) (scan-data T))
+(scm_import_environment_imports (groups scm C) (scan-data T))
+(scm_import_environment_p (groups scm C) (scan-data T))
+(scm_import_environment_set_imports_x (groups scm C) (scan-data T))
+(scm_include_deprecated_features (groups scm C) (scan-data T))
+(scm_inet_aton (groups scm C) (scan-data T))
+(scm_inet_makeaddr (groups scm C) (scan-data T))
+(scm_inet_netof (groups scm C) (scan-data T))
+(scm_inet_ntoa (groups scm C) (scan-data T))
+(scm_inet_ntop (groups scm C) (scan-data T))
+(scm_inet_pton (groups scm C) (scan-data T))
+(scm_inexact_p (groups scm C) (scan-data T))
+(scm_inexact_to_exact (groups scm C) (scan-data T))
+(scm_inf (groups scm C) (scan-data T))
+(scm_inf_p (groups scm C) (scan-data T))
+(scm_init_alist (groups scm C) (scan-data T))
+(scm_init_arbiters (groups scm C) (scan-data T))
+(scm_init_async (groups scm C) (scan-data T))
+(scm_init_backtrace (groups scm C) (scan-data T))
+(scm_init_boolean (groups scm C) (scan-data T))
+(scm_init_chars (groups scm C) (scan-data T))
+(scm_init_continuations (groups scm C) (scan-data T))
+(scm_init_debug (groups scm C) (scan-data T))
+(scm_init_deprecation (groups scm C) (scan-data T))
+(scm_init_dynamic_linking (groups scm C) (scan-data T))
+(scm_init_dynwind (groups scm C) (scan-data T))
+(scm_init_environments (groups scm C) (scan-data T))
+(scm_init_eq (groups scm C) (scan-data T))
+(scm_init_error (groups scm C) (scan-data T))
+(scm_init_eval (groups scm C) (scan-data T))
+(scm_init_evalext (groups scm C) (scan-data T))
+(scm_init_extensions (groups scm C) (scan-data T))
+(scm_init_feature (groups scm C) (scan-data T))
+(scm_init_filesys (groups scm C) (scan-data T))
+(scm_init_fluids (groups scm C) (scan-data T))
+(scm_init_fports (groups scm C) (scan-data T))
+(scm_init_gc (groups scm C) (scan-data T))
+(scm_init_gdbint (groups scm C) (scan-data T))
+(scm_init_goops (groups scm C) (scan-data T))
+(scm_init_goops_builtins (groups scm C) (scan-data T))
+(scm_init_gsubr (groups scm C) (scan-data T))
+(scm_init_guardians (groups scm C) (scan-data T))
+(scm_init_guile (groups scm C) (scan-data T))
+(scm_init_hash (groups scm C) (scan-data T))
+(scm_init_hashtab (groups scm C) (scan-data T))
+(scm_init_hooks (groups scm C) (scan-data T))
+(scm_init_ioext (groups scm C) (scan-data T))
+(scm_init_iselect (groups scm C) (scan-data T))
+(scm_init_keywords (groups scm C) (scan-data T))
+(scm_init_lang (groups scm C) (scan-data T))
+(scm_init_list (groups scm C) (scan-data T))
+(scm_init_load (groups scm C) (scan-data T))
+(scm_init_load_path (groups scm C) (scan-data T))
+(scm_init_macros (groups scm C) (scan-data T))
+(scm_init_mallocs (groups scm C) (scan-data T))
+(scm_init_modules (groups scm C) (scan-data T))
+(scm_init_net_db (groups scm C) (scan-data T))
+(scm_init_numbers (groups scm C) (scan-data T))
+(scm_init_objects (groups scm C) (scan-data T))
+(scm_init_objprop (groups scm C) (scan-data T))
+(scm_init_options (groups scm C) (scan-data T))
+(scm_init_opts (groups scm C) (scan-data T))
+(scm_init_pairs (groups scm C) (scan-data T))
+(scm_init_ports (groups scm C) (scan-data T))
+(scm_init_posix (groups scm C) (scan-data T))
+(scm_init_print (groups scm C) (scan-data T))
+(scm_init_procprop (groups scm C) (scan-data T))
+(scm_init_procs (groups scm C) (scan-data T))
+(scm_init_properties (groups scm C) (scan-data T))
+(scm_init_ramap (groups scm C) (scan-data T))
+(scm_init_random (groups scm C) (scan-data T))
+(scm_init_rdelim (groups scm C) (scan-data T))
+(scm_init_rdelim_builtins (groups scm C) (scan-data T))
+(scm_init_read (groups scm C) (scan-data T))
+(scm_init_regex_posix (groups scm C) (scan-data T))
+(scm_init_root (groups scm C) (scan-data T))
+(scm_init_rw (groups scm C) (scan-data T))
+(scm_init_rw_builtins (groups scm C) (scan-data T))
+(scm_init_scmsigs (groups scm C) (scan-data T))
+(scm_init_script (groups scm C) (scan-data T))
+(scm_init_simpos (groups scm C) (scan-data T))
+(scm_init_socket (groups scm C) (scan-data T))
+(scm_init_sort (groups scm C) (scan-data T))
+(scm_init_srcprop (groups scm C) (scan-data T))
+(scm_init_stackchk (groups scm C) (scan-data T))
+(scm_init_stacks (groups scm C) (scan-data T))
+(scm_init_stime (groups scm C) (scan-data T))
+(scm_init_storage (groups scm C) (scan-data T))
+(scm_init_strings (groups scm C) (scan-data T))
+(scm_init_strop (groups scm C) (scan-data T))
+(scm_init_strorder (groups scm C) (scan-data T))
+(scm_init_strports (groups scm C) (scan-data T))
+(scm_init_struct (groups scm C) (scan-data T))
+(scm_init_subr_table (groups scm C) (scan-data T))
+(scm_init_symbols (groups scm C) (scan-data T))
+(scm_init_threads (groups scm C) (scan-data T))
+(scm_init_throw (groups scm C) (scan-data T))
+(scm_init_unif (groups scm C) (scan-data T))
+(scm_init_values (groups scm C) (scan-data T))
+(scm_init_variable (groups scm C) (scan-data T))
+(scm_init_vectors (groups scm C) (scan-data T))
+(scm_init_version (groups scm C) (scan-data T))
+(scm_init_vports (groups scm C) (scan-data T))
+(scm_init_weaks (groups scm C) (scan-data T))
+(scm_initialized_p (groups scm C) (scan-data D))
+(scm_input_port_p (groups scm C) (scan-data T))
+(scm_instance_p (groups scm C) (scan-data T))
+(scm_int2num (groups scm C) (scan-data T))
+(scm_integer_expt (groups scm C) (scan-data T))
+(scm_integer_length (groups scm C) (scan-data T))
+(scm_integer_p (groups scm C) (scan-data T))
+(scm_integer_to_char (groups scm C) (scan-data T))
+(scm_interaction_environment (groups scm C) (scan-data T))
+(scm_internal_catch (groups scm C) (scan-data T))
+(scm_internal_cwdr (groups scm C) (scan-data T))
+(scm_internal_dynamic_wind (groups scm C) (scan-data T))
+(scm_internal_hash_fold (groups scm C) (scan-data T))
+(scm_internal_lazy_catch (groups scm C) (scan-data T))
+(scm_internal_parse_path (groups scm C) (scan-data T))
+(scm_internal_select (groups scm C) (scan-data T))
+(scm_internal_stack_catch (groups scm C) (scan-data T))
+(scm_intprint (groups scm C) (scan-data T))
+(scm_ints_disabled (groups scm C) (scan-data D))
+(scm_iprin1 (groups scm C) (scan-data T))
+(scm_iprlist (groups scm C) (scan-data T))
+(scm_ipruk (groups scm C) (scan-data T))
+(scm_isatty_p (groups scm C) (scan-data T))
+(scm_issue_deprecation_warning (groups scm C) (scan-data T))
+(scm_istr2bve (groups scm C) (scan-data T))
+(scm_isymnames (groups scm C) (scan-data D))
+(scm_ithrow (groups scm C) (scan-data T))
+(scm_join_thread (groups scm C) (scan-data T))
+(scm_keyword_dash_symbol (groups scm C) (scan-data T))
+(scm_keyword_p (groups scm C) (scan-data T))
+(scm_kill (groups scm C) (scan-data T))
+(scm_last_pair (groups scm C) (scan-data T))
+(scm_last_stack_frame (groups scm C) (scan-data T))
+(scm_lazy_catch (groups scm C) (scan-data T))
+(scm_lcm (groups scm C) (scan-data T))
+(scm_leaf_environment_p (groups scm C) (scan-data T))
+(scm_length (groups scm C) (scan-data T))
+(scm_leq_p (groups scm C) (scan-data T))
+(scm_less_p (groups scm C) (scan-data T))
+(scm_lfwrite (groups scm C) (scan-data T))
+(scm_link (groups scm C) (scan-data T))
+(scm_list (groups scm C) (scan-data T))
+(scm_list_1 (groups scm C) (scan-data T))
+(scm_list_2 (groups scm C) (scan-data T))
+(scm_list_3 (groups scm C) (scan-data T))
+(scm_list_4 (groups scm C) (scan-data T))
+(scm_list_5 (groups scm C) (scan-data T))
+(scm_list_cdr_set_x (groups scm C) (scan-data T))
+(scm_list_copy (groups scm C) (scan-data T))
+(scm_list_head (groups scm C) (scan-data T))
+(scm_list_n (groups scm C) (scan-data T))
+(scm_list_p (groups scm C) (scan-data T))
+(scm_list_ref (groups scm C) (scan-data T))
+(scm_list_set_x (groups scm C) (scan-data T))
+(scm_list_tail (groups scm C) (scan-data T))
+(scm_list_to_uniform_array (groups scm C) (scan-data T))
+(scm_listen (groups scm C) (scan-data T))
+(scm_listofnullstr (groups scm C) (scan-data B))
+(scm_lnaof (groups scm C) (scan-data T))
+(scm_load_extension (groups scm C) (scan-data T))
+(scm_load_goops (groups scm C) (scan-data T))
+(scm_load_startup_files (groups scm C) (scan-data T))
+(scm_local_eval (groups scm C) (scan-data T))
+(scm_localtime (groups scm C) (scan-data T))
+(scm_lock_mutex (groups scm C) (scan-data T))
+(scm_logand (groups scm C) (scan-data T))
+(scm_logbit_p (groups scm C) (scan-data T))
+(scm_logcount (groups scm C) (scan-data T))
+(scm_logior (groups scm C) (scan-data T))
+(scm_lognot (groups scm C) (scan-data T))
+(scm_logtest (groups scm C) (scan-data T))
+(scm_logxor (groups scm C) (scan-data T))
+(scm_long2num (groups scm C) (scan-data T))
+(scm_long_long2num (groups scm C) (scan-data T))
+(scm_lookup (groups scm C) (scan-data T))
+(scm_lookup_closure_module (groups scm C) (scan-data T))
+(scm_lookupcar (groups scm C) (scan-data T))
+(scm_lreadparen (groups scm C) (scan-data T))
+(scm_lreadr (groups scm C) (scan-data T))
+(scm_lreadrecparen (groups scm C) (scan-data T))
+(scm_lstat (groups scm C) (scan-data T))
+(scm_m_and (groups scm C) (scan-data T))
+(scm_m_apply (groups scm C) (scan-data T))
+(scm_m_at_call_with_values (groups scm C) (scan-data T))
+(scm_m_atbind (groups scm C) (scan-data T))
+(scm_m_atdispatch (groups scm C) (scan-data T))
+(scm_m_atfop (groups scm C) (scan-data T))
+(scm_m_atslot_ref (groups scm C) (scan-data T))
+(scm_m_atslot_set_x (groups scm C) (scan-data T))
+(scm_m_begin (groups scm C) (scan-data T))
+(scm_m_case (groups scm C) (scan-data T))
+(scm_m_cond (groups scm C) (scan-data T))
+(scm_m_cont (groups scm C) (scan-data T))
+(scm_m_define (groups scm C) (scan-data T))
+(scm_m_delay (groups scm C) (scan-data T))
+(scm_m_do (groups scm C) (scan-data T))
+(scm_m_expand_body (groups scm C) (scan-data T))
+(scm_m_generalized_set_x (groups scm C) (scan-data T))
+(scm_m_if (groups scm C) (scan-data T))
+(scm_m_lambda (groups scm C) (scan-data T))
+(scm_m_let (groups scm C) (scan-data T))
+(scm_m_letrec (groups scm C) (scan-data T))
+(scm_m_letstar (groups scm C) (scan-data T))
+(scm_m_nil_cond (groups scm C) (scan-data T))
+(scm_m_or (groups scm C) (scan-data T))
+(scm_m_quasiquote (groups scm C) (scan-data T))
+(scm_m_quote (groups scm C) (scan-data T))
+(scm_m_set_x (groups scm C) (scan-data T))
+(scm_m_undefine (groups scm C) (scan-data T))
+(scm_macro_name (groups scm C) (scan-data T))
+(scm_macro_p (groups scm C) (scan-data T))
+(scm_macro_transformer (groups scm C) (scan-data T))
+(scm_macro_type (groups scm C) (scan-data T))
+(scm_macroexp (groups scm C) (scan-data T))
+(scm_magnitude (groups scm C) (scan-data T))
+(scm_major_version (groups scm C) (scan-data T))
+(scm_makacro (groups scm C) (scan-data T))
+(scm_makcclo (groups scm C) (scan-data T))
+(scm_make (groups scm C) (scan-data T))
+(scm_make_arbiter (groups scm C) (scan-data T))
+(scm_make_class (groups scm C) (scan-data T))
+(scm_make_class_object (groups scm C) (scan-data T))
+(scm_make_complex (groups scm C) (scan-data T))
+(scm_make_condition_variable (groups scm C) (scan-data T))
+(scm_make_continuation (groups scm C) (scan-data T))
+(scm_make_debugobj (groups scm C) (scan-data T))
+(scm_make_doubly_weak_hash_table (groups scm C) (scan-data T))
+(scm_make_environment (groups scm C) (scan-data T))
+(scm_make_eval_environment (groups scm C) (scan-data T))
+(scm_make_export_environment (groups scm C) (scan-data T))
+(scm_make_extended_class (groups scm C) (scan-data T))
+(scm_make_fluid (groups scm C) (scan-data T))
+(scm_make_foreign_object (groups scm C) (scan-data T))
+(scm_make_guardian (groups scm C) (scan-data T))
+(scm_make_hook (groups scm C) (scan-data T))
+(scm_make_import_environment (groups scm C) (scan-data T))
+(scm_make_initial_fluids (groups scm C) (scan-data T))
+(scm_make_keyword_from_dash_symbol (groups scm C) (scan-data T))
+(scm_make_leaf_environment (groups scm C) (scan-data T))
+(scm_make_memoized (groups scm C) (scan-data T))
+(scm_make_method_cache (groups scm C) (scan-data T))
+(scm_make_mutex (groups scm C) (scan-data T))
+(scm_make_polar (groups scm C) (scan-data T))
+(scm_make_port_classes (groups scm C) (scan-data T))
+(scm_make_port_type (groups scm C) (scan-data T))
+(scm_make_print_state (groups scm C) (scan-data T))
+(scm_make_procedure_with_setter (groups scm C) (scan-data T))
+(scm_make_ra (groups scm C) (scan-data T))
+(scm_make_real (groups scm C) (scan-data T))
+(scm_make_rectangular (groups scm C) (scan-data T))
+(scm_make_regexp (groups scm C) (scan-data T))
+(scm_make_root (groups scm C) (scan-data T))
+(scm_make_shared_array (groups scm C) (scan-data T))
+(scm_make_smob (groups scm C) (scan-data T))
+(scm_make_smob_type (groups scm C) (scan-data T))
+(scm_make_soft_port (groups scm C) (scan-data T))
+(scm_make_srcprops (groups scm C) (scan-data T))
+(scm_make_stack (groups scm C) (scan-data T))
+(scm_make_string (groups scm C) (scan-data T))
+(scm_make_struct (groups scm C) (scan-data T))
+(scm_make_struct_layout (groups scm C) (scan-data T))
+(scm_make_subclass_object (groups scm C) (scan-data T))
+(scm_make_symbol (groups scm C) (scan-data T))
+(scm_make_synt (groups scm C) (scan-data T))
+(scm_make_undefined_variable (groups scm C) (scan-data T))
+(scm_make_uve (groups scm C) (scan-data T))
+(scm_make_variable (groups scm C) (scan-data T))
+(scm_make_vector (groups scm C) (scan-data T))
+(scm_make_vtable_vtable (groups scm C) (scan-data T))
+(scm_make_weak_key_hash_table (groups scm C) (scan-data T))
+(scm_make_weak_value_hash_table (groups scm C) (scan-data T))
+(scm_make_weak_vector (groups scm C) (scan-data T))
+(scm_makfrom0str (groups scm C) (scan-data T))
+(scm_makfrom0str_opt (groups scm C) (scan-data T))
+(scm_makfromstrs (groups scm C) (scan-data T))
+(scm_makmacro (groups scm C) (scan-data T))
+(scm_makmmacro (groups scm C) (scan-data T))
+(scm_makprom (groups scm C) (scan-data T))
+(scm_malloc (groups scm C) (scan-data T))
+(scm_malloc_obj (groups scm C) (scan-data T))
+(scm_mallocated (groups scm C) (scan-data D))
+(scm_map (groups scm C) (scan-data T))
+(scm_mark0 (groups scm C) (scan-data T))
+(scm_mark_locations (groups scm C) (scan-data T))
+(scm_mark_subr_table (groups scm C) (scan-data T))
+(scm_markcdr (groups scm C) (scan-data T))
+(scm_markstream (groups scm C) (scan-data T))
+(scm_mask_ints (groups scm C) (scan-data D))
+(scm_mask_signals (groups scm C) (scan-data T))
+(scm_masktab (groups scm C) (scan-data B))
+(scm_master_freelist (groups scm C) (scan-data D))
+(scm_master_freelist2 (groups scm C) (scan-data D))
+(scm_max (groups scm C) (scan-data T))
+(scm_max_segment_size (groups scm C) (scan-data B))
+(scm_mcache_compute_cmethod (groups scm C) (scan-data T))
+(scm_mcache_lookup_cmethod (groups scm C) (scan-data T))
+(scm_mem2string (groups scm C) (scan-data T))
+(scm_mem2symbol (groups scm C) (scan-data T))
+(scm_mem2uninterned_symbol (groups scm C) (scan-data T))
+(scm_member (groups scm C) (scan-data T))
+(scm_memoize_method (groups scm C) (scan-data T))
+(scm_memoized_environment (groups scm C) (scan-data T))
+(scm_memoized_p (groups scm C) (scan-data T))
+(scm_memory_alloc_key (groups scm C) (scan-data B))
+(scm_memory_error (groups scm C) (scan-data T))
+(scm_memq (groups scm C) (scan-data T))
+(scm_memv (groups scm C) (scan-data T))
+(scm_merge (groups scm C) (scan-data T))
+(scm_merge_x (groups scm C) (scan-data T))
+(scm_metaclass_operator (groups scm C) (scan-data B))
+(scm_metaclass_standard (groups scm C) (scan-data B))
+(scm_method_generic_function (groups scm C) (scan-data T))
+(scm_method_procedure (groups scm C) (scan-data T))
+(scm_method_specializers (groups scm C) (scan-data T))
+(scm_micro_version (groups scm C) (scan-data T))
+(scm_min (groups scm C) (scan-data T))
+(scm_minor_version (groups scm C) (scan-data T))
+(scm_misc_error (groups scm C) (scan-data T))
+(scm_misc_error_key (groups scm C) (scan-data B))
+(scm_mkdir (groups scm C) (scan-data T))
+(scm_mknod (groups scm C) (scan-data T))
+(scm_mkstemp (groups scm C) (scan-data T))
+(scm_mkstrport (groups scm C) (scan-data T))
+(scm_mktime (groups scm C) (scan-data T))
+(scm_mode_bits (groups scm C) (scan-data T))
+(scm_module_define (groups scm C) (scan-data T))
+(scm_module_goops (groups scm C) (scan-data B))
+(scm_module_lookup (groups scm C) (scan-data T))
+(scm_module_lookup_closure (groups scm C) (scan-data T))
+(scm_module_reverse_lookup (groups scm C) (scan-data T))
+(scm_module_system_booted_p (groups scm C) (scan-data D))
+(scm_module_tag (groups scm C) (scan-data B))
+(scm_module_transformer (groups scm C) (scan-data T))
+(scm_modules_prehistory (groups scm C) (scan-data T))
+(scm_modulo (groups scm C) (scan-data T))
+(scm_mtrigger (groups scm C) (scan-data B))
+(scm_mulbig (groups scm C) (scan-data T))
+(scm_must_free (groups scm C) (scan-data T))
+(scm_must_malloc (groups scm C) (scan-data T))
+(scm_must_realloc (groups scm C) (scan-data T))
+(scm_must_strdup (groups scm C) (scan-data T))
+(scm_must_strndup (groups scm C) (scan-data T))
+(scm_n_charnames (groups scm C) (scan-data D))
+(scm_n_heap_segs (groups scm C) (scan-data D))
+(scm_nan (groups scm C) (scan-data T))
+(scm_nan_p (groups scm C) (scan-data T))
+(scm_nconc2last (groups scm C) (scan-data T))
+(scm_negative_p (groups scm C) (scan-data T))
+(scm_newline (groups scm C) (scan-data T))
+(scm_nice (groups scm C) (scan-data T))
+(scm_no_applicable_method (groups scm C) (scan-data B))
+(scm_noop (groups scm C) (scan-data T))
+(scm_not (groups scm C) (scan-data T))
+(scm_ntohl (groups scm C) (scan-data T))
+(scm_ntohs (groups scm C) (scan-data T))
+(scm_null_p (groups scm C) (scan-data T))
+(scm_num2dbl (groups scm C) (scan-data T))
+(scm_num2double (groups scm C) (scan-data T))
+(scm_num2float (groups scm C) (scan-data T))
+(scm_num2int (groups scm C) (scan-data T))
+(scm_num2long (groups scm C) (scan-data T))
+(scm_num2long_long (groups scm C) (scan-data T))
+(scm_num2ptrdiff (groups scm C) (scan-data T))
+(scm_num2short (groups scm C) (scan-data T))
+(scm_num2size (groups scm C) (scan-data T))
+(scm_num2uint (groups scm C) (scan-data T))
+(scm_num2ulong (groups scm C) (scan-data T))
+(scm_num2ulong_long (groups scm C) (scan-data T))
+(scm_num2ushort (groups scm C) (scan-data T))
+(scm_num_eq_p (groups scm C) (scan-data T))
+(scm_num_overflow (groups scm C) (scan-data T))
+(scm_num_overflow_key (groups scm C) (scan-data B))
+(scm_number_p (groups scm C) (scan-data T))
+(scm_number_to_string (groups scm C) (scan-data T))
+(scm_numptob (groups scm C) (scan-data B))
+(scm_numsmob (groups scm C) (scan-data B))
+(scm_object_address (groups scm C) (scan-data T))
+(scm_object_properties (groups scm C) (scan-data T))
+(scm_object_property (groups scm C) (scan-data T))
+(scm_object_to_string (groups scm C) (scan-data T))
+(scm_odd_p (groups scm C) (scan-data T))
+(scm_open (groups scm C) (scan-data T))
+(scm_open_fdes (groups scm C) (scan-data T))
+(scm_open_file (groups scm C) (scan-data T))
+(scm_open_input_string (groups scm C) (scan-data T))
+(scm_open_output_string (groups scm C) (scan-data T))
+(scm_opendir (groups scm C) (scan-data T))
+(scm_operator_p (groups scm C) (scan-data T))
+(scm_options (groups scm C) (scan-data T))
+(scm_out_of_range (groups scm C) (scan-data T))
+(scm_out_of_range_key (groups scm C) (scan-data B))
+(scm_out_of_range_pos (groups scm C) (scan-data T))
+(scm_output_port_p (groups scm C) (scan-data T))
+(scm_pair_p (groups scm C) (scan-data T))
+(scm_parse_path (groups scm C) (scan-data T))
+(scm_pause (groups scm C) (scan-data T))
+(scm_peek_char (groups scm C) (scan-data T))
+(scm_permanent_object (groups scm C) (scan-data T))
+(scm_pipe (groups scm C) (scan-data T))
+(scm_port_class (groups scm C) (scan-data D))
+(scm_port_closed_p (groups scm C) (scan-data T))
+(scm_port_column (groups scm C) (scan-data T))
+(scm_port_filename (groups scm C) (scan-data T))
+(scm_port_for_each (groups scm C) (scan-data T))
+(scm_port_line (groups scm C) (scan-data T))
+(scm_port_mode (groups scm C) (scan-data T))
+(scm_port_non_buffer (groups scm C) (scan-data T))
+(scm_port_p (groups scm C) (scan-data T))
+(scm_port_print (groups scm C) (scan-data T))
+(scm_port_revealed (groups scm C) (scan-data T))
+(scm_port_table (groups scm C) (scan-data B))
+(scm_port_table_room (groups scm C) (scan-data D))
+(scm_port_table_size (groups scm C) (scan-data D))
+(scm_port_with_print_state (groups scm C) (scan-data T))
+(scm_ports_prehistory (groups scm C) (scan-data T))
+(scm_positive_p (groups scm C) (scan-data T))
+(scm_pre_modules_obarray (groups scm C) (scan-data B))
+(scm_primitive_eval (groups scm C) (scan-data T))
+(scm_primitive_eval_x (groups scm C) (scan-data T))
+(scm_primitive_exit (groups scm C) (scan-data T))
+(scm_primitive_generic_generic (groups scm C) (scan-data T))
+(scm_primitive_load (groups scm C) (scan-data T))
+(scm_primitive_load_path (groups scm C) (scan-data T))
+(scm_primitive_make_property (groups scm C) (scan-data T))
+(scm_primitive_move_to_fdes (groups scm C) (scan-data T))
+(scm_primitive_property_del_x (groups scm C) (scan-data T))
+(scm_primitive_property_ref (groups scm C) (scan-data T))
+(scm_primitive_property_set_x (groups scm C) (scan-data T))
+(scm_prin1 (groups scm C) (scan-data T))
+(scm_print_carefully_p (groups scm C) (scan-data B))
+(scm_print_complex (groups scm C) (scan-data T))
+(scm_print_options (groups scm C) (scan-data T))
+(scm_print_opts (groups scm C) (scan-data D))
+(scm_print_port_mode (groups scm C) (scan-data T))
+(scm_print_real (groups scm C) (scan-data T))
+(scm_print_state_vtable (groups scm C) (scan-data D))
+(scm_print_struct (groups scm C) (scan-data T))
+(scm_print_symbol_name (groups scm C) (scan-data T))
+(scm_printer_apply (groups scm C) (scan-data T))
+(scm_procedure (groups scm C) (scan-data T))
+(scm_procedure_documentation (groups scm C) (scan-data T))
+(scm_procedure_environment (groups scm C) (scan-data T))
+(scm_procedure_name (groups scm C) (scan-data T))
+(scm_procedure_p (groups scm C) (scan-data T))
+(scm_procedure_properties (groups scm C) (scan-data T))
+(scm_procedure_property (groups scm C) (scan-data T))
+(scm_procedure_source (groups scm C) (scan-data T))
+(scm_procedure_with_setter_p (groups scm C) (scan-data T))
+(scm_product (groups scm C) (scan-data T))
+(scm_program_arguments (groups scm C) (scan-data T))
+(scm_promise_p (groups scm C) (scan-data T))
+(scm_pseudolong (groups scm C) (scan-data T))
+(scm_ptobs (groups scm C) (scan-data B))
+(scm_ptrdiff2num (groups scm C) (scan-data T))
+(scm_putc (groups scm C) (scan-data T))
+(scm_putenv (groups scm C) (scan-data T))
+(scm_puts (groups scm C) (scan-data T))
+(scm_quotient (groups scm C) (scan-data T))
+(scm_ra2contig (groups scm C) (scan-data T))
+(scm_ra_difference (groups scm C) (scan-data T))
+(scm_ra_divide (groups scm C) (scan-data T))
+(scm_ra_eqp (groups scm C) (scan-data T))
+(scm_ra_greqp (groups scm C) (scan-data T))
+(scm_ra_grp (groups scm C) (scan-data T))
+(scm_ra_leqp (groups scm C) (scan-data T))
+(scm_ra_lessp (groups scm C) (scan-data T))
+(scm_ra_matchp (groups scm C) (scan-data T))
+(scm_ra_product (groups scm C) (scan-data T))
+(scm_ra_set_contp (groups scm C) (scan-data T))
+(scm_ra_sum (groups scm C) (scan-data T))
+(scm_raequal (groups scm C) (scan-data T))
+(scm_raise (groups scm C) (scan-data T))
+(scm_ramapc (groups scm C) (scan-data T))
+(scm_random (groups scm C) (scan-data T))
+(scm_random_exp (groups scm C) (scan-data T))
+(scm_random_hollow_sphere_x (groups scm C) (scan-data T))
+(scm_random_normal (groups scm C) (scan-data T))
+(scm_random_normal_vector_x (groups scm C) (scan-data T))
+(scm_random_solid_sphere_x (groups scm C) (scan-data T))
+(scm_random_uniform (groups scm C) (scan-data T))
+(scm_raprin1 (groups scm C) (scan-data T))
+(scm_read (groups scm C) (scan-data T))
+(scm_read_char (groups scm C) (scan-data T))
+(scm_read_delimited_x (groups scm C) (scan-data T))
+(scm_read_hash_extend (groups scm C) (scan-data T))
+(scm_read_line (groups scm C) (scan-data T))
+(scm_read_options (groups scm C) (scan-data T))
+(scm_read_opts (groups scm C) (scan-data D))
+(scm_read_string_x_partial (groups scm C) (scan-data T))
+(scm_read_token (groups scm C) (scan-data T))
+(scm_readdir (groups scm C) (scan-data T))
+(scm_readlink (groups scm C) (scan-data T))
+(scm_real_equalp (groups scm C) (scan-data T))
+(scm_real_p (groups scm C) (scan-data T))
+(scm_real_part (groups scm C) (scan-data T))
+(scm_realloc (groups scm C) (scan-data T))
+(scm_recv (groups scm C) (scan-data T))
+(scm_recvfrom (groups scm C) (scan-data T))
+(scm_redirect_port (groups scm C) (scan-data T))
+(scm_regexp_exec (groups scm C) (scan-data T))
+(scm_regexp_p (groups scm C) (scan-data T))
+(scm_release_arbiter (groups scm C) (scan-data T))
+(scm_remainder (groups scm C) (scan-data T))
+(scm_remember_upto_here (groups scm C) (scan-data T))
+(scm_remember_upto_here_1 (groups scm C) (scan-data T))
+(scm_remember_upto_here_2 (groups scm C) (scan-data T))
+(scm_remove_from_port_table (groups scm C) (scan-data T))
+(scm_remove_hook_x (groups scm C) (scan-data T))
+(scm_rename (groups scm C) (scan-data T))
+(scm_report_stack_overflow (groups scm C) (scan-data T))
+(scm_reset_hook_x (groups scm C) (scan-data T))
+(scm_resolve_module (groups scm C) (scan-data T))
+(scm_restore_signals (groups scm C) (scan-data T))
+(scm_restricted_vector_sort_x (groups scm C) (scan-data T))
+(scm_return_first (groups scm C) (scan-data T))
+(scm_return_first_int (groups scm C) (scan-data T))
+(scm_revealed_count (groups scm C) (scan-data T))
+(scm_reverse (groups scm C) (scan-data T))
+(scm_reverse_lookup (groups scm C) (scan-data T))
+(scm_reverse_x (groups scm C) (scan-data T))
+(scm_rewinddir (groups scm C) (scan-data T))
+(scm_rmdir (groups scm C) (scan-data T))
+(scm_round (groups scm C) (scan-data T))
+(scm_run_asyncs (groups scm C) (scan-data T))
+(scm_run_hook (groups scm C) (scan-data T))
+(scm_s_bindings (groups scm C) (scan-data R))
+(scm_s_body (groups scm C) (scan-data R))
+(scm_s_clauses (groups scm C) (scan-data R))
+(scm_s_duplicate_bindings (groups scm C) (scan-data R))
+(scm_s_duplicate_formals (groups scm C) (scan-data R))
+(scm_s_expression (groups scm C) (scan-data R))
+(scm_s_formals (groups scm C) (scan-data R))
+(scm_s_set_x (groups scm C) (scan-data R))
+(scm_s_slot_set_x (groups scm C) (scan-data D))
+(scm_s_test (groups scm C) (scan-data R))
+(scm_s_variable (groups scm C) (scan-data R))
+(scm_search_path (groups scm C) (scan-data T))
+(scm_seed_to_random_state (groups scm C) (scan-data T))
+(scm_seek (groups scm C) (scan-data T))
+(scm_select (groups scm C) (scan-data T))
+(scm_send (groups scm C) (scan-data T))
+(scm_sendto (groups scm C) (scan-data T))
+(scm_set_car_x (groups scm C) (scan-data T))
+(scm_set_cdr_x (groups scm C) (scan-data T))
+(scm_set_current_error_port (groups scm C) (scan-data T))
+(scm_set_current_input_port (groups scm C) (scan-data T))
+(scm_set_current_module (groups scm C) (scan-data T))
+(scm_set_current_output_port (groups scm C) (scan-data T))
+(scm_set_object_procedure_x (groups scm C) (scan-data T))
+(scm_set_object_properties_x (groups scm C) (scan-data T))
+(scm_set_object_property_x (groups scm C) (scan-data T))
+(scm_set_port_close (groups scm C) (scan-data T))
+(scm_set_port_column_x (groups scm C) (scan-data T))
+(scm_set_port_end_input (groups scm C) (scan-data T))
+(scm_set_port_equalp (groups scm C) (scan-data T))
+(scm_set_port_filename_x (groups scm C) (scan-data T))
+(scm_set_port_flush (groups scm C) (scan-data T))
+(scm_set_port_free (groups scm C) (scan-data T))
+(scm_set_port_input_waiting (groups scm C) (scan-data T))
+(scm_set_port_line_x (groups scm C) (scan-data T))
+(scm_set_port_mark (groups scm C) (scan-data T))
+(scm_set_port_print (groups scm C) (scan-data T))
+(scm_set_port_revealed_x (groups scm C) (scan-data T))
+(scm_set_port_seek (groups scm C) (scan-data T))
+(scm_set_port_truncate (groups scm C) (scan-data T))
+(scm_set_procedure_properties_x (groups scm C) (scan-data T))
+(scm_set_procedure_property_x (groups scm C) (scan-data T))
+(scm_set_program_arguments (groups scm C) (scan-data T))
+(scm_set_smob_apply (groups scm C) (scan-data T))
+(scm_set_smob_equalp (groups scm C) (scan-data T))
+(scm_set_smob_free (groups scm C) (scan-data T))
+(scm_set_smob_mark (groups scm C) (scan-data T))
+(scm_set_smob_print (groups scm C) (scan-data T))
+(scm_set_source_properties_x (groups scm C) (scan-data T))
+(scm_set_source_property_x (groups scm C) (scan-data T))
+(scm_set_struct_vtable_name_x (groups scm C) (scan-data T))
+(scm_setegid (groups scm C) (scan-data T))
+(scm_seteuid (groups scm C) (scan-data T))
+(scm_setgid (groups scm C) (scan-data T))
+(scm_setgrent (groups scm C) (scan-data T))
+(scm_sethost (groups scm C) (scan-data T))
+(scm_sethostname (groups scm C) (scan-data T))
+(scm_setitimer (groups scm C) (scan-data T))
+(scm_setlocale (groups scm C) (scan-data T))
+(scm_setnet (groups scm C) (scan-data T))
+(scm_setpgid (groups scm C) (scan-data T))
+(scm_setpriority (groups scm C) (scan-data T))
+(scm_setproto (groups scm C) (scan-data T))
+(scm_setpwent (groups scm C) (scan-data T))
+(scm_setserv (groups scm C) (scan-data T))
+(scm_setsid (groups scm C) (scan-data T))
+(scm_setsockopt (groups scm C) (scan-data T))
+(scm_setter (groups scm C) (scan-data T))
+(scm_setuid (groups scm C) (scan-data T))
+(scm_setvbuf (groups scm C) (scan-data T))
+(scm_shap2ra (groups scm C) (scan-data T))
+(scm_shared_array_increments (groups scm C) (scan-data T))
+(scm_shared_array_offset (groups scm C) (scan-data T))
+(scm_shared_array_root (groups scm C) (scan-data T))
+(scm_shell (groups scm C) (scan-data T))
+(scm_shell_usage (groups scm C) (scan-data T))
+(scm_short2num (groups scm C) (scan-data T))
+(scm_shutdown (groups scm C) (scan-data T))
+(scm_sigaction (groups scm C) (scan-data T))
+(scm_signal_condition_variable (groups scm C) (scan-data T))
+(scm_simple_format (groups scm C) (scan-data T))
+(scm_single_thread_p (groups scm C) (scan-data T))
+(scm_size2num (groups scm C) (scan-data T))
+(scm_sleep (groups scm C) (scan-data T))
+(scm_sloppy_assoc (groups scm C) (scan-data T))
+(scm_sloppy_assq (groups scm C) (scan-data T))
+(scm_sloppy_assv (groups scm C) (scan-data T))
+(scm_slot_bound_p (groups scm C) (scan-data T))
+(scm_slot_bound_using_class_p (groups scm C) (scan-data T))
+(scm_slot_exists_p (groups scm C) (scan-data T))
+(scm_slot_exists_using_class_p (groups scm C) (scan-data T))
+(scm_slot_ref (groups scm C) (scan-data T))
+(scm_slot_ref_using_class (groups scm C) (scan-data T))
+(scm_slot_set_using_class_x (groups scm C) (scan-data T))
+(scm_slot_set_x (groups scm C) (scan-data T))
+(scm_smob_class (groups scm C) (scan-data D))
+(scm_smob_free (groups scm C) (scan-data T))
+(scm_smob_prehistory (groups scm C) (scan-data T))
+(scm_smob_print (groups scm C) (scan-data T))
+(scm_smobs (groups scm C) (scan-data B))
+(scm_socket (groups scm C) (scan-data T))
+(scm_socketpair (groups scm C) (scan-data T))
+(scm_sort (groups scm C) (scan-data T))
+(scm_sort_list (groups scm C) (scan-data T))
+(scm_sort_list_x (groups scm C) (scan-data T))
+(scm_sort_x (groups scm C) (scan-data T))
+(scm_sorted_p (groups scm C) (scan-data T))
+(scm_source_properties (groups scm C) (scan-data T))
+(scm_source_property (groups scm C) (scan-data T))
+(scm_spawn_thread (groups scm C) (scan-data T))
+(scm_srcprops_to_plist (groups scm C) (scan-data T))
+(scm_stable_sort (groups scm C) (scan-data T))
+(scm_stable_sort_x (groups scm C) (scan-data T))
+(scm_stack_checking_enabled_p (groups scm C) (scan-data B))
+(scm_stack_id (groups scm C) (scan-data T))
+(scm_stack_length (groups scm C) (scan-data T))
+(scm_stack_p (groups scm C) (scan-data T))
+(scm_stack_ref (groups scm C) (scan-data T))
+(scm_stack_report (groups scm C) (scan-data T))
+(scm_stack_size (groups scm C) (scan-data T))
+(scm_stack_type (groups scm C) (scan-data B))
+(scm_standard_eval_closure (groups scm C) (scan-data T))
+(scm_standard_interface_eval_closure (groups scm C) (scan-data T))
+(scm_start_stack (groups scm C) (scan-data T))
+(scm_stat (groups scm C) (scan-data T))
+(scm_status_exit_val (groups scm C) (scan-data T))
+(scm_status_stop_sig (groups scm C) (scan-data T))
+(scm_status_term_sig (groups scm C) (scan-data T))
+(scm_str2string (groups scm C) (scan-data T))
+(scm_str2symbol (groups scm C) (scan-data T))
+(scm_strdup (groups scm C) (scan-data T))
+(scm_strerror (groups scm C) (scan-data T))
+(scm_strftime (groups scm C) (scan-data T))
+(scm_string (groups scm C) (scan-data T))
+(scm_string_append (groups scm C) (scan-data T))
+(scm_string_capitalize (groups scm C) (scan-data T))
+(scm_string_capitalize_x (groups scm C) (scan-data T))
+(scm_string_ci_equal_p (groups scm C) (scan-data T))
+(scm_string_ci_geq_p (groups scm C) (scan-data T))
+(scm_string_ci_gr_p (groups scm C) (scan-data T))
+(scm_string_ci_leq_p (groups scm C) (scan-data T))
+(scm_string_ci_less_p (groups scm C) (scan-data T))
+(scm_string_ci_to_symbol (groups scm C) (scan-data T))
+(scm_string_copy (groups scm C) (scan-data T))
+(scm_string_downcase (groups scm C) (scan-data T))
+(scm_string_downcase_x (groups scm C) (scan-data T))
+(scm_string_equal_p (groups scm C) (scan-data T))
+(scm_string_fill_x (groups scm C) (scan-data T))
+(scm_string_geq_p (groups scm C) (scan-data T))
+(scm_string_gr_p (groups scm C) (scan-data T))
+(scm_string_hash (groups scm C) (scan-data T))
+(scm_string_index (groups scm C) (scan-data T))
+(scm_string_length (groups scm C) (scan-data T))
+(scm_string_leq_p (groups scm C) (scan-data T))
+(scm_string_less_p (groups scm C) (scan-data T))
+(scm_string_null_p (groups scm C) (scan-data T))
+(scm_string_p (groups scm C) (scan-data T))
+(scm_string_ref (groups scm C) (scan-data T))
+(scm_string_rindex (groups scm C) (scan-data T))
+(scm_string_set_x (groups scm C) (scan-data T))
+(scm_string_split (groups scm C) (scan-data T))
+(scm_string_to_list (groups scm C) (scan-data T))
+(scm_string_to_number (groups scm C) (scan-data T))
+(scm_string_to_symbol (groups scm C) (scan-data T))
+(scm_string_upcase (groups scm C) (scan-data T))
+(scm_string_upcase_x (groups scm C) (scan-data T))
+(scm_strndup (groups scm C) (scan-data T))
+(scm_strport_to_string (groups scm C) (scan-data T))
+(scm_strptime (groups scm C) (scan-data T))
+(scm_struct_create_handle (groups scm C) (scan-data T))
+(scm_struct_free_0 (groups scm C) (scan-data T))
+(scm_struct_free_entity (groups scm C) (scan-data T))
+(scm_struct_free_light (groups scm C) (scan-data T))
+(scm_struct_free_standard (groups scm C) (scan-data T))
+(scm_struct_ihashq (groups scm C) (scan-data T))
+(scm_struct_p (groups scm C) (scan-data T))
+(scm_struct_prehistory (groups scm C) (scan-data T))
+(scm_struct_ref (groups scm C) (scan-data T))
+(scm_struct_set_x (groups scm C) (scan-data T))
+(scm_struct_table (groups scm C) (scan-data B))
+(scm_struct_vtable (groups scm C) (scan-data T))
+(scm_struct_vtable_name (groups scm C) (scan-data T))
+(scm_struct_vtable_p (groups scm C) (scan-data T))
+(scm_struct_vtable_tag (groups scm C) (scan-data T))
+(scm_structs_to_free (groups scm C) (scan-data B))
+(scm_subr_p (groups scm C) (scan-data T))
+(scm_subr_table (groups scm C) (scan-data B))
+(scm_subr_table_room (groups scm C) (scan-data D))
+(scm_subr_table_size (groups scm C) (scan-data D))
+(scm_substring (groups scm C) (scan-data T))
+(scm_substring_fill_x (groups scm C) (scan-data T))
+(scm_substring_move_x (groups scm C) (scan-data T))
+(scm_sum (groups scm C) (scan-data T))
+(scm_swap_bindings (groups scm C) (scan-data T))
+(scm_swap_fluids (groups scm C) (scan-data T))
+(scm_swap_fluids_reverse (groups scm C) (scan-data T))
+(scm_switch_counter (groups scm C) (scan-data D))
+(scm_sym2var (groups scm C) (scan-data T))
+(scm_sym_and (groups scm C) (scan-data B))
+(scm_sym_apply (groups scm C) (scan-data B))
+(scm_sym_apply_frame (groups scm C) (scan-data B))
+(scm_sym_arity (groups scm C) (scan-data B))
+(scm_sym_arrow (groups scm C) (scan-data B))
+(scm_sym_at_call_with_values (groups scm C) (scan-data B))
+(scm_sym_atapply (groups scm C) (scan-data B))
+(scm_sym_atcall_cc (groups scm C) (scan-data B))
+(scm_sym_begin (groups scm C) (scan-data B))
+(scm_sym_breakpoint (groups scm C) (scan-data B))
+(scm_sym_case (groups scm C) (scan-data B))
+(scm_sym_column (groups scm C) (scan-data B))
+(scm_sym_cond (groups scm C) (scan-data B))
+(scm_sym_copy (groups scm C) (scan-data B))
+(scm_sym_define (groups scm C) (scan-data B))
+(scm_sym_delay (groups scm C) (scan-data B))
+(scm_sym_do (groups scm C) (scan-data B))
+(scm_sym_dot (groups scm C) (scan-data B))
+(scm_sym_else (groups scm C) (scan-data B))
+(scm_sym_enter_frame (groups scm C) (scan-data B))
+(scm_sym_exit_frame (groups scm C) (scan-data B))
+(scm_sym_filename (groups scm C) (scan-data B))
+(scm_sym_if (groups scm C) (scan-data B))
+(scm_sym_lambda (groups scm C) (scan-data B))
+(scm_sym_let (groups scm C) (scan-data B))
+(scm_sym_letrec (groups scm C) (scan-data B))
+(scm_sym_letstar (groups scm C) (scan-data B))
+(scm_sym_line (groups scm C) (scan-data B))
+(scm_sym_name (groups scm C) (scan-data B))
+(scm_sym_or (groups scm C) (scan-data B))
+(scm_sym_quasiquote (groups scm C) (scan-data B))
+(scm_sym_quote (groups scm C) (scan-data B))
+(scm_sym_set_x (groups scm C) (scan-data B))
+(scm_sym_system_procedure (groups scm C) (scan-data B))
+(scm_sym_trace (groups scm C) (scan-data B))
+(scm_sym_unquote (groups scm C) (scan-data B))
+(scm_sym_uq_splicing (groups scm C) (scan-data B))
+(scm_symbol_fref (groups scm C) (scan-data T))
+(scm_symbol_fset_x (groups scm C) (scan-data T))
+(scm_symbol_hash (groups scm C) (scan-data T))
+(scm_symbol_interned_p (groups scm C) (scan-data T))
+(scm_symbol_p (groups scm C) (scan-data T))
+(scm_symbol_pref (groups scm C) (scan-data T))
+(scm_symbol_pset_x (groups scm C) (scan-data T))
+(scm_symbol_to_string (groups scm C) (scan-data T))
+(scm_symbols_prehistory (groups scm C) (scan-data T))
+(scm_symlink (groups scm C) (scan-data T))
+(scm_sync (groups scm C) (scan-data T))
+(scm_sys_allocate_instance (groups scm C) (scan-data T))
+(scm_sys_atan2 (groups scm C) (scan-data T))
+(scm_sys_compute_applicable_methods (groups scm C) (scan-data T))
+(scm_sys_compute_slots (groups scm C) (scan-data T))
+(scm_sys_expt (groups scm C) (scan-data T))
+(scm_sys_fast_slot_ref (groups scm C) (scan-data T))
+(scm_sys_fast_slot_set_x (groups scm C) (scan-data T))
+(scm_sys_inherit_magic_x (groups scm C) (scan-data T))
+(scm_sys_initialize_object (groups scm C) (scan-data T))
+(scm_sys_invalidate_class (groups scm C) (scan-data T))
+(scm_sys_invalidate_method_cache_x (groups scm C) (scan-data T))
+(scm_sys_library_dir (groups scm C) (scan-data T))
+(scm_sys_make_void_port (groups scm C) (scan-data T))
+(scm_sys_method_more_specific_p (groups scm C) (scan-data T))
+(scm_sys_modify_class (groups scm C) (scan-data T))
+(scm_sys_modify_instance (groups scm C) (scan-data T))
+(scm_sys_package_data_dir (groups scm C) (scan-data T))
+(scm_sys_prep_layout_x (groups scm C) (scan-data T))
+(scm_sys_protects (groups scm C) (scan-data B))
+(scm_sys_search_load_path (groups scm C) (scan-data T))
+(scm_sys_set_object_setter_x (groups scm C) (scan-data T))
+(scm_sys_site_dir (groups scm C) (scan-data T))
+(scm_sys_tag_body (groups scm C) (scan-data T))
+(scm_syserror (groups scm C) (scan-data T))
+(scm_syserror_msg (groups scm C) (scan-data T))
+(scm_system (groups scm C) (scan-data T))
+(scm_system_async (groups scm C) (scan-data T))
+(scm_system_async_mark (groups scm C) (scan-data T))
+(scm_system_async_mark_from_signal_handler (groups scm C) (scan-data T))
+(scm_system_environment (groups scm C) (scan-data B))
+(scm_system_error_key (groups scm C) (scan-data B))
+(scm_system_module_env_p (groups scm C) (scan-data T))
+(scm_tables_prehistory (groups scm C) (scan-data T))
+(scm_take0str (groups scm C) (scan-data T))
+(scm_take_from_input_buffers (groups scm C) (scan-data T))
+(scm_take_str (groups scm C) (scan-data T))
+(scm_tc16_allocated (groups scm C) (scan-data B))
+(scm_tc16_array (groups scm C) (scan-data B))
+(scm_tc16_condvar (groups scm C) (scan-data B))
+(scm_tc16_continuation (groups scm C) (scan-data B))
+(scm_tc16_debugobj (groups scm C) (scan-data B))
+(scm_tc16_dir (groups scm C) (scan-data B))
+(scm_tc16_dynamic_obj (groups scm C) (scan-data B))
+(scm_tc16_environment (groups scm C) (scan-data B))
+(scm_tc16_eval_closure (groups scm C) (scan-data B))
+(scm_tc16_fluid (groups scm C) (scan-data B))
+(scm_tc16_fport (groups scm C) (scan-data B))
+(scm_tc16_hook (groups scm C) (scan-data B))
+(scm_tc16_keyword (groups scm C) (scan-data B))
+(scm_tc16_macro (groups scm C) (scan-data B))
+(scm_tc16_malloc (groups scm C) (scan-data B))
+(scm_tc16_memoized (groups scm C) (scan-data B))
+(scm_tc16_mutex (groups scm C) (scan-data B))
+(scm_tc16_observer (groups scm C) (scan-data B))
+(scm_tc16_port_with_ps (groups scm C) (scan-data B))
+(scm_tc16_promise (groups scm C) (scan-data B))
+(scm_tc16_regex (groups scm C) (scan-data B))
+(scm_tc16_root (groups scm C) (scan-data B))
+(scm_tc16_rstate (groups scm C) (scan-data B))
+(scm_tc16_srcprops (groups scm C) (scan-data B))
+(scm_tc16_strport (groups scm C) (scan-data B))
+(scm_tc16_thread (groups scm C) (scan-data B))
+(scm_tc16_void_port (groups scm C) (scan-data D))
+(scm_tcgetpgrp (groups scm C) (scan-data T))
+(scm_tcsetpgrp (groups scm C) (scan-data T))
+(scm_the_last_stack_fluid_var (groups scm C) (scan-data B))
+(scm_the_rng (groups scm C) (scan-data B))
+(scm_thread_count (groups scm C) (scan-data D))
+(scm_thread_sleep (groups scm C) (scan-data T))
+(scm_thread_usleep (groups scm C) (scan-data T))
+(scm_threads_init (groups scm C) (scan-data T))
+(scm_threads_mark_stacks (groups scm C) (scan-data T))
+(scm_throw (groups scm C) (scan-data T))
+(scm_thunk_p (groups scm C) (scan-data T))
+(scm_times (groups scm C) (scan-data T))
+(scm_tmpnam (groups scm C) (scan-data T))
+(scm_top_level_env (groups scm C) (scan-data T))
+(scm_transpose_array (groups scm C) (scan-data T))
+(scm_truncate (groups scm C) (scan-data T))
+(scm_truncate_file (groups scm C) (scan-data T))
+(scm_try_arbiter (groups scm C) (scan-data T))
+(scm_ttyname (groups scm C) (scan-data T))
+(scm_type_eval_environment (groups scm C) (scan-data D))
+(scm_type_export_environment (groups scm C) (scan-data D))
+(scm_type_import_environment (groups scm C) (scan-data D))
+(scm_type_leaf_environment (groups scm C) (scan-data D))
+(scm_tzset (groups scm C) (scan-data T))
+(scm_uint2num (groups scm C) (scan-data T))
+(scm_ulong2num (groups scm C) (scan-data T))
+(scm_ulong_long2num (groups scm C) (scan-data T))
+(scm_umask (groups scm C) (scan-data T))
+(scm_uname (groups scm C) (scan-data T))
+(scm_ungetc (groups scm C) (scan-data T))
+(scm_ungets (groups scm C) (scan-data T))
+(scm_uniform_array_read_x (groups scm C) (scan-data T))
+(scm_uniform_array_write (groups scm C) (scan-data T))
+(scm_uniform_element_size (groups scm C) (scan-data T))
+(scm_uniform_vector_length (groups scm C) (scan-data T))
+(scm_uniform_vector_ref (groups scm C) (scan-data T))
+(scm_unlock_mutex (groups scm C) (scan-data T))
+(scm_unmask_signals (groups scm C) (scan-data T))
+(scm_unmemocar (groups scm C) (scan-data T))
+(scm_unmemocopy (groups scm C) (scan-data T))
+(scm_unmemoize (groups scm C) (scan-data T))
+(scm_unread_char (groups scm C) (scan-data T))
+(scm_unread_string (groups scm C) (scan-data T))
+(scm_upcase (groups scm C) (scan-data T))
+(scm_usage_name (groups scm C) (scan-data D))
+(scm_ushort2num (groups scm C) (scan-data T))
+(scm_usleep (groups scm C) (scan-data T))
+(scm_utime (groups scm C) (scan-data T))
+(scm_valid_object_procedure_p (groups scm C) (scan-data T))
+(scm_valid_oport_value_p (groups scm C) (scan-data T))
+(scm_values (groups scm C) (scan-data T))
+(scm_values_vtable (groups scm C) (scan-data B))
+(scm_var_random_state (groups scm C) (scan-data B))
+(scm_variable_bound_p (groups scm C) (scan-data T))
+(scm_variable_p (groups scm C) (scan-data T))
+(scm_variable_ref (groups scm C) (scan-data T))
+(scm_variable_set_x (groups scm C) (scan-data T))
+(scm_vector (groups scm C) (scan-data T))
+(scm_vector_equal_p (groups scm C) (scan-data T))
+(scm_vector_fill_x (groups scm C) (scan-data T))
+(scm_vector_length (groups scm C) (scan-data T))
+(scm_vector_move_left_x (groups scm C) (scan-data T))
+(scm_vector_move_right_x (groups scm C) (scan-data T))
+(scm_vector_p (groups scm C) (scan-data T))
+(scm_vector_ref (groups scm C) (scan-data T))
+(scm_vector_set_x (groups scm C) (scan-data T))
+(scm_vector_to_list (groups scm C) (scan-data T))
+(scm_version (groups scm C) (scan-data T))
+(scm_void_port (groups scm C) (scan-data T))
+(scm_wait_condition_variable (groups scm C) (scan-data T))
+(scm_waitpid (groups scm C) (scan-data T))
+(scm_weak_key_hash_table_p (groups scm C) (scan-data T))
+(scm_weak_value_hash_table_p (groups scm C) (scan-data T))
+(scm_weak_vector (groups scm C) (scan-data T))
+(scm_weak_vector_p (groups scm C) (scan-data T))
+(scm_weak_vectors (groups scm C) (scan-data B))
+(scm_weaks_prehistory (groups scm C) (scan-data T))
+(scm_with_fluids (groups scm C) (scan-data T))
+(scm_with_traps (groups scm C) (scan-data T))
+(scm_wrap_component (groups scm C) (scan-data T))
+(scm_wrap_object (groups scm C) (scan-data T))
+(scm_write (groups scm C) (scan-data T))
+(scm_write_char (groups scm C) (scan-data T))
+(scm_write_line (groups scm C) (scan-data T))
+(scm_write_string_partial (groups scm C) (scan-data T))
+(scm_wrong_num_args (groups scm C) (scan-data T))
+(scm_wrong_type_arg (groups scm C) (scan-data T))
+(scm_wrong_type_arg_msg (groups scm C) (scan-data T))
+(scm_yield (groups scm C) (scan-data T))
+(scm_your_base (groups scm C) (scan-data D))
+(scm_zero_p (groups scm C) (scan-data T))
+(search-path (groups Scheme) (scan-data "#<primitive-procedure search-path>"))
+(seed->random-state (groups Scheme) (scan-data "#<primitive-procedure seed->random-state>"))
+(seek (groups Scheme) (scan-data "#<primitive-procedure seek>"))
+(select (groups POSIX Scheme) (scan-data "#<primitive-procedure select>"))
+(send (groups Scheme) (scan-data "#<primitive-procedure send>"))
+(sendto (groups Scheme) (scan-data "#<primitive-procedure sendto>"))
+(servent:aliases (groups Scheme) (scan-data "#<procedure servent:aliases (obj)>"))
+(servent:name (groups Scheme) (scan-data "#<procedure servent:name (obj)>"))
+(servent:port (groups Scheme) (scan-data "#<procedure servent:port (obj)>"))
+(servent:proto (groups Scheme) (scan-data "#<procedure servent:proto (obj)>"))
+(set! (groups Scheme) (scan-data ""))
+(set-autoloaded! (groups Scheme) (scan-data "#<procedure set-autoloaded! (p m done?)>"))
+(set-batch-mode?! (groups Scheme) (scan-data "#<procedure set-batch-mode?! (arg)>"))
+(set-car! (groups Scheme) (scan-data "#<primitive-procedure set-car!>"))
+(set-cdr! (groups Scheme) (scan-data "#<primitive-procedure set-cdr!>"))
+(set-current-error-port (groups Scheme) (scan-data "#<primitive-procedure set-current-error-port>"))
+(set-current-input-port (groups Scheme) (scan-data "#<primitive-procedure set-current-input-port>"))
+(set-current-module (groups Scheme) (scan-data "#<primitive-procedure set-current-module>"))
+(set-current-output-port (groups Scheme) (scan-data "#<primitive-procedure set-current-output-port>"))
+(set-defmacro-transformer! (groups Scheme) (scan-data "#<procedure set-defmacro-transformer! (m t)>"))
+(set-module-binder! (groups Scheme) (scan-data "#<procedure set-module-binder! (obj val)>"))
+(set-module-eval-closure! (groups Scheme) (scan-data "#<procedure set-module-eval-closure! (module closure)>"))
+(set-module-kind! (groups Scheme) (scan-data "#<procedure set-module-kind! (obj val)>"))
+(set-module-name! (groups Scheme) (scan-data "#<procedure set-module-name! (obj val)>"))
+(set-module-obarray! (groups Scheme) (scan-data "#<procedure set-module-obarray! (obj val)>"))
+(set-module-observer-id! (groups Scheme) (scan-data "#<procedure set-module-observer-id! (obj val)>"))
+(set-module-observers! (groups Scheme) (scan-data "#<procedure set-module-observers! (obj val)>"))
+(set-module-public-interface! (groups Scheme) (scan-data "#<procedure set-module-public-interface! (m i)>"))
+(set-module-transformer! (groups Scheme) (scan-data "#<procedure set-module-transformer! (obj val)>"))
+(set-module-uses! (groups Scheme) (scan-data "#<procedure set-module-uses! (obj val)>"))
+(set-object-procedure! (groups Scheme) (scan-data "#<primitive-procedure set-object-procedure!>"))
+(set-object-properties! (groups Scheme) (scan-data "#<primitive-procedure set-object-properties!>"))
+(set-object-property! (groups Scheme) (scan-data "#<primitive-procedure set-object-property!>"))
+(set-port-column! (groups Scheme) (scan-data "#<primitive-procedure set-port-column!>"))
+(set-port-filename! (groups Scheme) (scan-data "#<primitive-procedure set-port-filename!>"))
+(set-port-line! (groups Scheme) (scan-data "#<primitive-procedure set-port-line!>"))
+(set-port-revealed! (groups POSIX Scheme) (scan-data "#<primitive-procedure set-port-revealed!>"))
+(set-procedure-properties! (groups Scheme) (scan-data "#<primitive-procedure set-procedure-properties!>"))
+(set-procedure-property! (groups Scheme) (scan-data "#<primitive-procedure set-procedure-property!>"))
+(set-repl-prompt! (groups Scheme) (scan-data "#<procedure set-repl-prompt! (v)>"))
+(set-source-properties! (groups Scheme) (scan-data "#<primitive-procedure set-source-properties!>"))
+(set-source-property! (groups Scheme) (scan-data "#<primitive-procedure set-source-property!>"))
+(set-struct-vtable-name! (groups Scheme) (scan-data "#<primitive-procedure set-struct-vtable-name!>"))
+(set-symbol-property! (groups Scheme) (scan-data "#<procedure set-symbol-property! (sym prop val)>"))
+(set-system-module! (groups Scheme) (scan-data "#<procedure set-system-module! (m s)>"))
+(set-tm:gmtoff (groups POSIX Scheme) (scan-data "#<procedure set-tm:gmtoff (obj val)>"))
+(set-tm:hour (groups POSIX Scheme) (scan-data "#<procedure set-tm:hour (obj val)>"))
+(set-tm:isdst (groups POSIX Scheme) (scan-data "#<procedure set-tm:isdst (obj val)>"))
+(set-tm:mday (groups POSIX Scheme) (scan-data "#<procedure set-tm:mday (obj val)>"))
+(set-tm:min (groups POSIX Scheme) (scan-data "#<procedure set-tm:min (obj val)>"))
+(set-tm:mon (groups POSIX Scheme) (scan-data "#<procedure set-tm:mon (obj val)>"))
+(set-tm:sec (groups POSIX Scheme) (scan-data "#<procedure set-tm:sec (obj val)>"))
+(set-tm:wday (groups POSIX Scheme) (scan-data "#<procedure set-tm:wday (obj val)>"))
+(set-tm:yday (groups POSIX Scheme) (scan-data "#<procedure set-tm:yday (obj val)>"))
+(set-tm:year (groups POSIX Scheme) (scan-data "#<procedure set-tm:year (obj val)>"))
+(set-tm:zone (groups POSIX Scheme) (scan-data "#<procedure set-tm:zone (obj val)>"))
+(setegid (groups POSIX Scheme) (scan-data "#<primitive-procedure setegid>"))
+(setenv (groups POSIX Scheme) (scan-data "#<procedure setenv (name value)>"))
+(seteuid (groups POSIX Scheme) (scan-data "#<primitive-procedure seteuid>"))
+(setgid (groups POSIX Scheme) (scan-data "#<primitive-procedure setgid>"))
+(setgr (groups POSIX Scheme) (scan-data "#<primitive-procedure setgr>"))
+(setgrent (groups POSIX Scheme) (scan-data "#<procedure setgrent ()>"))
+(sethost (groups Scheme) (scan-data "#<primitive-procedure sethost>"))
+(sethostent (groups Scheme) (scan-data "#<procedure sethostent stayopen>"))
+(sethostname (groups POSIX Scheme) (scan-data "#<primitive-procedure sethostname>"))
+(setitimer (groups POSIX Scheme) (scan-data "#<primitive-procedure setitimer>"))
+(setlocale (groups POSIX Scheme) (scan-data "#<primitive-procedure setlocale>"))
+(setnet (groups Scheme) (scan-data "#<primitive-procedure setnet>"))
+(setnetent (groups Scheme) (scan-data "#<procedure setnetent stayopen>"))
+(setpgid (groups POSIX Scheme) (scan-data "#<primitive-procedure setpgid>"))
+(setpriority (groups POSIX Scheme) (scan-data "#<primitive-procedure setpriority>"))
+(setproto (groups Scheme) (scan-data "#<primitive-procedure setproto>"))
+(setprotoent (groups Scheme) (scan-data "#<procedure setprotoent stayopen>"))
+(setpw (groups POSIX Scheme) (scan-data "#<primitive-procedure setpw>"))
+(setpwent (groups POSIX Scheme) (scan-data "#<procedure setpwent ()>"))
+(setserv (groups Scheme) (scan-data "#<primitive-procedure setserv>"))
+(setservent (groups Scheme) (scan-data "#<procedure setservent stayopen>"))
+(setsid (groups POSIX Scheme) (scan-data "#<primitive-procedure setsid>"))
+(setsockopt (groups Scheme) (scan-data "#<primitive-procedure setsockopt>"))
+(setter (groups Scheme) (scan-data "#<primitive-procedure setter>"))
+(setuid (groups POSIX Scheme) (scan-data "#<primitive-procedure setuid>"))
+(setvbuf (groups POSIX Scheme) (scan-data "#<primitive-procedure setvbuf>"))
+(shared-array-increments (groups Scheme) (scan-data "#<primitive-procedure shared-array-increments>"))
+(shared-array-offset (groups Scheme) (scan-data "#<primitive-procedure shared-array-offset>"))
+(shared-array-root (groups Scheme) (scan-data "#<primitive-procedure shared-array-root>"))
+(shutdown (groups Scheme) (scan-data "#<primitive-procedure shutdown>"))
+(sigaction (groups POSIX Scheme) (scan-data "#<primitive-procedure sigaction>"))
+(signal-condition-variable (groups Scheme) (scan-data "#<primitive-procedure signal-condition-variable>"))
+(signal-handlers (groups Scheme) (scan-data ""))
+(simple-format (groups Scheme) (scan-data "#<primitive-procedure simple-format>"))
+(sin (groups Scheme) (scan-data "#<procedure sin (z)>"))
+(single-active-thread? (groups Scheme) (scan-data "#<primitive-procedure single-active-thread?>"))
+(sinh (groups Scheme) (scan-data "#<procedure sinh (z)>"))
+(sleep (groups POSIX Scheme) (scan-data "#<primitive-procedure sleep>"))
+(sloppy-assoc (groups Scheme) (scan-data "#<primitive-procedure sloppy-assoc>"))
+(sloppy-assq (groups Scheme) (scan-data "#<primitive-procedure sloppy-assq>"))
+(sloppy-assv (groups Scheme) (scan-data "#<primitive-procedure sloppy-assv>"))
+(sockaddr:addr (groups Scheme) (scan-data "#<procedure sockaddr:addr (obj)>"))
+(sockaddr:fam (groups Scheme) (scan-data "#<procedure sockaddr:fam (obj)>"))
+(sockaddr:path (groups Scheme) (scan-data "#<procedure sockaddr:path (obj)>"))
+(sockaddr:port (groups Scheme) (scan-data "#<procedure sockaddr:port (obj)>"))
+(socket (groups Scheme) (scan-data "#<primitive-procedure socket>"))
+(socketpair (groups Scheme) (scan-data "#<primitive-procedure socketpair>"))
+(sort (groups Scheme) (scan-data "#<primitive-procedure sort>"))
+(sort! (groups Scheme) (scan-data "#<primitive-procedure sort!>"))
+(sort-list (groups Scheme) (scan-data "#<primitive-procedure sort-list>"))
+(sort-list! (groups Scheme) (scan-data "#<primitive-procedure sort-list!>"))
+(sorted? (groups Scheme) (scan-data "#<primitive-procedure sorted?>"))
+(source-properties (groups Scheme) (scan-data "#<primitive-procedure source-properties>"))
+(source-property (groups Scheme) (scan-data "#<primitive-procedure source-property>"))
+(source-whash (groups Scheme) (scan-data ""))
+(sqrt (groups Scheme) (scan-data "#<procedure sqrt (z)>"))
+(stable-sort (groups Scheme) (scan-data "#<primitive-procedure stable-sort>"))
+(stable-sort! (groups Scheme) (scan-data "#<primitive-procedure stable-sort!>"))
+(stack-id (groups Scheme) (scan-data "#<primitive-procedure stack-id>"))
+(stack-length (groups Scheme) (scan-data "#<primitive-procedure stack-length>"))
+(stack-ref (groups Scheme) (scan-data "#<primitive-procedure stack-ref>"))
+(stack-saved? (groups Scheme) (scan-data ""))
+(stack? (groups Scheme) (scan-data "#<primitive-procedure stack?>"))
+(standard-eval-closure (groups Scheme) (scan-data "#<primitive-procedure standard-eval-closure>"))
+(standard-interface-eval-closure (groups Scheme) (scan-data "#<primitive-procedure standard-interface-eval-closure>"))
+(start-stack (groups Scheme) (scan-data ""))
+(stat (groups POSIX Scheme) (scan-data "#<primitive-procedure stat>"))
+(stat:atime (groups POSIX Scheme) (scan-data "#<procedure stat:atime (f)>"))
+(stat:blksize (groups POSIX Scheme) (scan-data "#<procedure stat:blksize (f)>"))
+(stat:blocks (groups POSIX Scheme) (scan-data "#<procedure stat:blocks (f)>"))
+(stat:ctime (groups POSIX Scheme) (scan-data "#<procedure stat:ctime (f)>"))
+(stat:dev (groups POSIX Scheme) (scan-data "#<procedure stat:dev (f)>"))
+(stat:gid (groups POSIX Scheme) (scan-data "#<procedure stat:gid (f)>"))
+(stat:ino (groups POSIX Scheme) (scan-data "#<procedure stat:ino (f)>"))
+(stat:mode (groups POSIX Scheme) (scan-data "#<procedure stat:mode (f)>"))
+(stat:mtime (groups POSIX Scheme) (scan-data "#<procedure stat:mtime (f)>"))
+(stat:nlink (groups POSIX Scheme) (scan-data "#<procedure stat:nlink (f)>"))
+(stat:perms (groups POSIX Scheme) (scan-data "#<procedure stat:perms (f)>"))
+(stat:rdev (groups POSIX Scheme) (scan-data "#<procedure stat:rdev (f)>"))
+(stat:size (groups POSIX Scheme) (scan-data "#<procedure stat:size (f)>"))
+(stat:type (groups POSIX Scheme) (scan-data "#<procedure stat:type (f)>"))
+(stat:uid (groups POSIX Scheme) (scan-data "#<procedure stat:uid (f)>"))
+(status:exit-val (groups POSIX Scheme) (scan-data "#<primitive-procedure status:exit-val>"))
+(status:stop-sig (groups POSIX Scheme) (scan-data "#<primitive-procedure status:stop-sig>"))
+(status:term-sig (groups POSIX Scheme) (scan-data "#<primitive-procedure status:term-sig>"))
+(strerror (groups Scheme) (scan-data "#<primitive-procedure strerror>"))
+(strftime (groups POSIX Scheme) (scan-data "#<primitive-procedure strftime>"))
+(string (groups Scheme) (scan-data "#<primitive-procedure string>"))
+(string->list (groups Scheme) (scan-data "#<primitive-procedure string->list>"))
+(string->number (groups Scheme) (scan-data "#<primitive-procedure string->number>"))
+(string->symbol (groups Scheme) (scan-data "#<primitive-procedure string->symbol>"))
+(string-append (groups Scheme) (scan-data "#<primitive-procedure string-append>"))
+(string-capitalize (groups Scheme) (scan-data "#<primitive-procedure string-capitalize>"))
+(string-capitalize! (groups Scheme) (scan-data "#<primitive-procedure string-capitalize!>"))
+(string-ci->symbol (groups Scheme) (scan-data "#<primitive-procedure string-ci->symbol>"))
+(string-ci<=? (groups Scheme) (scan-data "#<primitive-procedure string-ci<=?>"))
+(string-ci<? (groups Scheme) (scan-data "#<primitive-procedure string-ci<?>"))
+(string-ci=? (groups Scheme) (scan-data "#<primitive-procedure string-ci=?>"))
+(string-ci>=? (groups Scheme) (scan-data "#<primitive-procedure string-ci>=?>"))
+(string-ci>? (groups Scheme) (scan-data "#<primitive-procedure string-ci>?>"))
+(string-copy (groups Scheme) (scan-data "#<primitive-procedure string-copy>"))
+(string-downcase (groups Scheme) (scan-data "#<primitive-procedure string-downcase>"))
+(string-downcase! (groups Scheme) (scan-data "#<primitive-procedure string-downcase!>"))
+(string-fill! (groups Scheme) (scan-data "#<primitive-procedure string-fill!>"))
+(string-index (groups Scheme) (scan-data "#<primitive-procedure string-index>"))
+(string-length (groups Scheme) (scan-data "#<primitive-procedure string-length>"))
+(string-null? (groups Scheme) (scan-data "#<primitive-procedure string-null?>"))
+(string-ref (groups Scheme) (scan-data "#<primitive-procedure string-ref>"))
+(string-rindex (groups Scheme) (scan-data "#<primitive-procedure string-rindex>"))
+(string-set! (groups Scheme) (scan-data "#<primitive-procedure string-set!>"))
+(string-split (groups Scheme) (scan-data "#<primitive-procedure string-split>"))
+(string-upcase (groups Scheme) (scan-data "#<primitive-procedure string-upcase>"))
+(string-upcase! (groups Scheme) (scan-data "#<primitive-procedure string-upcase!>"))
+(string<=? (groups Scheme) (scan-data "#<primitive-procedure string<=?>"))
+(string<? (groups Scheme) (scan-data "#<primitive-procedure string<?>"))
+(string=? (groups Scheme) (scan-data "#<primitive-procedure string=?>"))
+(string>=? (groups Scheme) (scan-data "#<primitive-procedure string>=?>"))
+(string>? (groups Scheme) (scan-data "#<primitive-procedure string>?>"))
+(string? (groups Scheme) (scan-data "#<primitive-procedure string?>"))
+(strptime (groups POSIX Scheme) (scan-data "#<primitive-procedure strptime>"))
+(struct-layout (groups Scheme) (scan-data "#<procedure struct-layout (s)>"))
+(struct-ref (groups Scheme) (scan-data "#<primitive-procedure struct-ref>"))
+(struct-set! (groups Scheme) (scan-data "#<primitive-procedure struct-set!>"))
+(struct-vtable (groups Scheme) (scan-data "#<primitive-procedure struct-vtable>"))
+(struct-vtable-name (groups Scheme) (scan-data "#<primitive-procedure struct-vtable-name>"))
+(struct-vtable-tag (groups Scheme) (scan-data "#<primitive-procedure struct-vtable-tag>"))
+(struct-vtable? (groups Scheme) (scan-data "#<primitive-procedure struct-vtable?>"))
+(struct? (groups Scheme) (scan-data "#<primitive-procedure struct?>"))
+(substring (groups Scheme) (scan-data "#<primitive-procedure substring>"))
+(substring-fill! (groups Scheme) (scan-data "#<primitive-procedure substring-fill!>"))
+(substring-move! (groups Scheme) (scan-data "#<primitive-procedure substring-move!>"))
+(symbol (groups Scheme) (scan-data "#<procedure symbol args>"))
+(symbol->keyword (groups Scheme) (scan-data "#<procedure symbol->keyword (symbol)>"))
+(symbol->string (groups Scheme) (scan-data "#<primitive-procedure symbol->string>"))
+(symbol-append (groups Scheme) (scan-data "#<procedure symbol-append args>"))
+(symbol-fref (groups Scheme) (scan-data "#<primitive-procedure symbol-fref>"))
+(symbol-fset! (groups Scheme) (scan-data "#<primitive-procedure symbol-fset!>"))
+(symbol-hash (groups Scheme) (scan-data "#<primitive-procedure symbol-hash>"))
+(symbol-interned? (groups Scheme) (scan-data "#<primitive-procedure symbol-interned?>"))
+(symbol-pref (groups Scheme) (scan-data "#<primitive-procedure symbol-pref>"))
+(symbol-prefix-proc (groups Scheme) (scan-data "#<procedure symbol-prefix-proc (prefix)>"))
+(symbol-property (groups Scheme) (scan-data "#<procedure symbol-property (sym prop)>"))
+(symbol-property-remove! (groups Scheme) (scan-data "#<procedure symbol-property-remove! (sym prop)>"))
+(symbol-pset! (groups Scheme) (scan-data "#<primitive-procedure symbol-pset!>"))
+(symbol? (groups Scheme) (scan-data "#<primitive-procedure symbol?>"))
+(symlink (groups POSIX Scheme) (scan-data "#<primitive-procedure symlink>"))
+(sync (groups POSIX Scheme) (scan-data "#<primitive-procedure sync>"))
+(system (groups POSIX Scheme) (scan-data "#<primitive-procedure system>"))
+(system-async (groups Scheme) (scan-data "#<primitive-procedure system-async>"))
+(system-async-mark (groups Scheme) (scan-data "#<primitive-procedure system-async-mark>"))
+(system-error-errno (groups Scheme) (scan-data "#<procedure system-error-errno (args)>"))
+(tan (groups Scheme) (scan-data "#<procedure tan (z)>"))
+(tanh (groups Scheme) (scan-data "#<procedure tanh (z)>"))
+(tcgetpgrp (groups POSIX Scheme) (scan-data "#<primitive-procedure tcgetpgrp>"))
+(tcsetpgrp (groups POSIX Scheme) (scan-data "#<primitive-procedure tcsetpgrp>"))
+(the-environment (groups Scheme) (scan-data ""))
+(the-eof-object (groups Scheme) (scan-data ""))
+(the-last-stack (groups Scheme) (scan-data ""))
+(the-root-environment (groups Scheme) (scan-data ""))
+(the-root-module (groups Scheme) (scan-data ""))
+(the-scm-module (groups Scheme) (scan-data ""))
+(throw (groups Scheme) (scan-data "#<primitive-procedure throw>"))
+(thunk? (groups Scheme) (scan-data "#<primitive-procedure thunk?>"))
+(times (groups POSIX Scheme) (scan-data "#<primitive-procedure times>"))
+(tm:gmtoff (groups POSIX Scheme) (scan-data "#<procedure tm:gmtoff (obj)>"))
+(tm:hour (groups POSIX Scheme) (scan-data "#<procedure tm:hour (obj)>"))
+(tm:isdst (groups POSIX Scheme) (scan-data "#<procedure tm:isdst (obj)>"))
+(tm:mday (groups POSIX Scheme) (scan-data "#<procedure tm:mday (obj)>"))
+(tm:min (groups POSIX Scheme) (scan-data "#<procedure tm:min (obj)>"))
+(tm:mon (groups POSIX Scheme) (scan-data "#<procedure tm:mon (obj)>"))
+(tm:sec (groups POSIX Scheme) (scan-data "#<procedure tm:sec (obj)>"))
+(tm:wday (groups POSIX Scheme) (scan-data "#<procedure tm:wday (obj)>"))
+(tm:yday (groups POSIX Scheme) (scan-data "#<procedure tm:yday (obj)>"))
+(tm:year (groups POSIX Scheme) (scan-data "#<procedure tm:year (obj)>"))
+(tm:zone (groups POSIX Scheme) (scan-data "#<procedure tm:zone (obj)>"))
+(tmpnam (groups POSIX Scheme) (scan-data "#<primitive-procedure tmpnam>"))
+(tms:clock (groups POSIX Scheme) (scan-data "#<procedure tms:clock (obj)>"))
+(tms:cstime (groups POSIX Scheme) (scan-data "#<procedure tms:cstime (obj)>"))
+(tms:cutime (groups POSIX Scheme) (scan-data "#<procedure tms:cutime (obj)>"))
+(tms:stime (groups POSIX Scheme) (scan-data "#<procedure tms:stime (obj)>"))
+(tms:utime (groups POSIX Scheme) (scan-data "#<procedure tms:utime (obj)>"))
+(top-repl (groups Scheme) (scan-data "#<procedure top-repl ()>"))
+(transform-usage-lambda (groups Scheme) (scan-data "#<procedure transform-usage-lambda (cases)>"))
+(transpose-array (groups Scheme) (scan-data "#<primitive-procedure transpose-array>"))
+(trap-disable (groups Scheme) (scan-data "#<procedure trap-disable flags>"))
+(trap-enable (groups Scheme) (scan-data "#<procedure trap-enable flags>"))
+(trap-set! (groups Scheme) (scan-data ""))
+(traps (groups Scheme) (scan-data "#<procedure traps args>"))
+(truncate (groups Scheme) (scan-data "#<primitive-procedure truncate>"))
+(truncate-file (groups Scheme) (scan-data "#<primitive-procedure truncate-file>"))
+(try-arbiter (groups Scheme) (scan-data "#<primitive-procedure try-arbiter>"))
+(try-load-module (groups Scheme) (scan-data "#<procedure try-load-module (name)>"))
+(try-module-autoload (groups Scheme) (scan-data "#<procedure try-module-autoload (module-name)>"))
+(ttyname (groups POSIX Scheme) (scan-data "#<primitive-procedure ttyname>"))
+(turn-on-debugging (groups Scheme) (scan-data "#<procedure turn-on-debugging ()>"))
+(tzset (groups POSIX Scheme) (scan-data "#<primitive-procedure tzset>"))
+(umask (groups POSIX Scheme) (scan-data "#<primitive-procedure umask>"))
+(uname (groups POSIX Scheme) (scan-data "#<primitive-procedure uname>"))
+(undefine (groups Scheme) (scan-data ""))
+(uniform-array-read! (groups Scheme) (scan-data "#<primitive-procedure uniform-array-read!>"))
+(uniform-array-set1! (groups Scheme) (scan-data "#<primitive-procedure uniform-array-set1!>"))
+(uniform-array-write (groups Scheme) (scan-data "#<primitive-procedure uniform-array-write>"))
+(uniform-vector-fill! (groups Scheme) (scan-data "#<primitive-procedure array-fill!>"))
+(uniform-vector-length (groups Scheme) (scan-data "#<primitive-procedure uniform-vector-length>"))
+(uniform-vector-read! (groups Scheme) (scan-data "#<primitive-procedure uniform-array-read!>"))
+(uniform-vector-ref (groups Scheme) (scan-data "#<primitive-procedure uniform-vector-ref>"))
+(uniform-vector-set! (groups Scheme) (scan-data "#<procedure uniform-vector-set! (u i o)>"))
+(uniform-vector-write (groups Scheme) (scan-data "#<primitive-procedure uniform-array-write>"))
+(uniform-vector? (groups Scheme) (scan-data "#<primitive-procedure array?>"))
+(unlock-mutex (groups Scheme) (scan-data "#<primitive-procedure unlock-mutex>"))
+(unmask-signals (groups Scheme) (scan-data "#<primitive-procedure unmask-signals>"))
+(unmemoize (groups Scheme) (scan-data "#<primitive-procedure unmemoize>"))
+(unread-char (groups POSIX Scheme) (scan-data "#<primitive-procedure unread-char>"))
+(unread-string (groups POSIX Scheme) (scan-data "#<primitive-procedure unread-string>"))
+(unsetenv (groups Scheme) (scan-data "#<procedure unsetenv (name)>"))
+(unspecified? (groups Scheme) (scan-data "#<procedure unspecified? (v)>"))
+(use-emacs-interface (groups Scheme) (scan-data ""))
+(use-modules (groups Scheme) (scan-data ""))
+(use-srfis (groups Scheme) (scan-data "#<procedure use-srfis (srfis)>"))
+(use-syntax (groups Scheme) (scan-data ""))
+(using-readline? (groups Scheme) (scan-data "#<procedure-with-setter>"))
+(usleep (groups POSIX Scheme) (scan-data "#<primitive-procedure usleep>"))
+(utime (groups POSIX Scheme) (scan-data "#<primitive-procedure utime>"))
+(utsname:machine (groups POSIX Scheme) (scan-data "#<procedure utsname:machine (obj)>"))
+(utsname:nodename (groups POSIX Scheme) (scan-data "#<procedure utsname:nodename (obj)>"))
+(utsname:release (groups POSIX Scheme) (scan-data "#<procedure utsname:release (obj)>"))
+(utsname:sysname (groups POSIX Scheme) (scan-data "#<procedure utsname:sysname (obj)>"))
+(utsname:version (groups POSIX Scheme) (scan-data "#<procedure utsname:version (obj)>"))
+(valid-object-procedure? (groups Scheme) (scan-data "#<primitive-procedure valid-object-procedure?>"))
+(values (groups Scheme) (scan-data "#<primitive-procedure values>"))
+(variable-bound? (groups Scheme) (scan-data "#<primitive-procedure variable-bound?>"))
+(variable-ref (groups Scheme) (scan-data "#<primitive-procedure variable-ref>"))
+(variable-set! (groups Scheme) (scan-data "#<primitive-procedure variable-set!>"))
+(variable? (groups Scheme) (scan-data "#<primitive-procedure variable?>"))
+(vector (groups Scheme) (scan-data "#<primitive-procedure vector>"))
+(vector->list (groups Scheme) (scan-data "#<primitive-procedure vector->list>"))
+(vector-fill! (groups Scheme) (scan-data "#<primitive-procedure vector-fill!>"))
+(vector-length (groups Scheme) (scan-data "#<primitive-procedure vector-length>"))
+(vector-move-left! (groups Scheme) (scan-data "#<primitive-procedure vector-move-left!>"))
+(vector-move-right! (groups Scheme) (scan-data "#<primitive-procedure vector-move-right!>"))
+(vector-ref (groups Scheme) (scan-data "#<primitive-procedure vector-ref>"))
+(vector-set! (groups Scheme) (scan-data "#<primitive-procedure vector-set!>"))
+(vector? (groups Scheme) (scan-data "#<primitive-procedure vector?>"))
+(version (groups Scheme) (scan-data "#<primitive-procedure version>"))
+(vtable-index-layout (groups Scheme) (scan-data ""))
+(vtable-index-printer (groups Scheme) (scan-data ""))
+(vtable-index-vtable (groups Scheme) (scan-data ""))
+(vtable-offset-user (groups Scheme) (scan-data ""))
+(wait-condition-variable (groups Scheme) (scan-data "#<primitive-procedure wait-condition-variable>"))
+(waitpid (groups POSIX Scheme) (scan-data "#<primitive-procedure waitpid>"))
+(warn (groups Scheme) (scan-data "#<procedure warn stuff>"))
+(weak-key-hash-table? (groups Scheme) (scan-data "#<primitive-procedure weak-key-hash-table?>"))
+(weak-value-hash-table? (groups Scheme) (scan-data "#<primitive-procedure weak-value-hash-table?>"))
+(weak-vector (groups Scheme) (scan-data "#<primitive-procedure weak-vector>"))
+(weak-vector? (groups Scheme) (scan-data "#<primitive-procedure weak-vector?>"))
+(while (groups Scheme) (scan-data ""))
+(with-error-to-file (groups Scheme) (scan-data "#<procedure with-error-to-file (file thunk)>"))
+(with-error-to-port (groups Scheme) (scan-data "#<procedure with-error-to-port (port thunk)>"))
+(with-error-to-string (groups Scheme) (scan-data "#<procedure with-error-to-string (thunk)>"))
+(with-fluids (groups Scheme) (scan-data ""))
+(with-fluids* (groups Scheme) (scan-data "#<primitive-procedure with-fluids*>"))
+(with-input-from-file (groups Scheme) (scan-data "#<procedure with-input-from-file (file thunk)>"))
+(with-input-from-port (groups Scheme) (scan-data "#<procedure with-input-from-port (port thunk)>"))
+(with-input-from-string (groups Scheme) (scan-data "#<procedure with-input-from-string (string thunk)>"))
+(with-output-to-file (groups Scheme) (scan-data "#<procedure with-output-to-file (file thunk)>"))
+(with-output-to-port (groups Scheme) (scan-data "#<procedure with-output-to-port (port thunk)>"))
+(with-output-to-string (groups Scheme) (scan-data "#<procedure with-output-to-string (thunk)>"))
+(with-traps (groups Scheme) (scan-data "#<primitive-procedure with-traps>"))
+(write (groups Scheme) (scan-data "#<primitive-procedure write>"))
+(write-char (groups Scheme) (scan-data "#<primitive-procedure write-char>"))
+(xformer-table (groups Scheme) (scan-data ""))
+(yield (groups Scheme) (scan-data "#<primitive-procedure yield>"))
+(zero? (groups Scheme) (scan-data "#<primitive-procedure zero?>"))
+) ;; end of interface
+) ;; eof