/* Generated by genstub.  Do not edit. */
#define LIBGAUCHE_BODY 
#include <gauche.h>

#line 35 "extlib.stub"
#include <fcntl.h>
#include <gauche/arch.h>
#include <gauche/class.h>
#include <gauche/vminsn.h>
#include <gauche/regexp.h>
#include <gauche/bignum.h>
#include <gauche/char_attr.h>

#if defined(__CYGWIN__) || defined(GAUCHE_WINDOWS)
#define SCM_CGEN_CONST /*empty*/
#else
#define SCM_CGEN_CONST const
#endif
static SCM_CGEN_CONST struct scm__scRec {
#if SCM_DEBUG_HELPER
  ScmString d1015[5];
#endif /*SCM_DEBUG_HELPER*/
  ScmString d1003[399];
} scm__sc = {
#if SCM_DEBUG_HELPER
  {   /* ScmString d1015 */
      SCM_STRING_CONST_INITIALIZER("%bignum-dump", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%char-set-dump", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%string-pointer-dump", 20, 20),
      SCM_STRING_CONST_INITIALIZER("%regexp-dump", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%regmatch-dump", 14, 14),
  },
#endif /*SCM_DEBUG_HELPER*/
  {   /* ScmString d1003 */
      SCM_STRING_CONST_INITIALIZER("macroexpand", 11, 11),
      SCM_STRING_CONST_INITIALIZER("macroexpand-1", 13, 13),
      SCM_STRING_CONST_INITIALIZER("eqv?", 4, 4),
      SCM_STRING_CONST_INITIALIZER("eq?", 3, 3),
      SCM_STRING_CONST_INITIALIZER("equal?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("compare", 7, 7),
      SCM_STRING_CONST_INITIALIZER("ash", 3, 3),
      SCM_STRING_CONST_INITIALIZER("lognot", 6, 6),
      SCM_STRING_CONST_INITIALIZER("logand", 6, 6),
      SCM_STRING_CONST_INITIALIZER("logior", 6, 6),
      SCM_STRING_CONST_INITIALIZER("logxor", 6, 6),
      SCM_STRING_CONST_INITIALIZER("logcount", 8, 8),
      SCM_STRING_CONST_INITIALIZER("integer-length", 14, 14),
      SCM_STRING_CONST_INITIALIZER("fixnum?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("bignum?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("flonum?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("finite?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("infinite?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("nan?", 4, 4),
      SCM_STRING_CONST_INITIALIZER("fixnum-width", 12, 12),
      SCM_STRING_CONST_INITIALIZER("least-fixnum", 12, 12),
      SCM_STRING_CONST_INITIALIZER("greatest-fixnum", 15, 15),
      SCM_STRING_CONST_INITIALIZER("inexact-/", 9, 9),
      SCM_STRING_CONST_INITIALIZER("+.", 2, 2),
      SCM_STRING_CONST_INITIALIZER("*.", 2, 2),
      SCM_STRING_CONST_INITIALIZER("-.", 2, 2),
      SCM_STRING_CONST_INITIALIZER("/.", 2, 2),
      SCM_STRING_CONST_INITIALIZER("clamp", 5, 5),
      SCM_STRING_CONST_INITIALIZER("floor->exact", 12, 12),
      SCM_STRING_CONST_INITIALIZER("ceiling->exact", 14, 14),
      SCM_STRING_CONST_INITIALIZER("truncate->exact", 15, 15),
      SCM_STRING_CONST_INITIALIZER("round->exact", 12, 12),
      SCM_STRING_CONST_INITIALIZER("decode-float", 12, 12),
      SCM_STRING_CONST_INITIALIZER("native-endian", 13, 13),
      SCM_STRING_CONST_INITIALIZER("min&max", 7, 7),
      SCM_STRING_CONST_INITIALIZER("quotient&remainder", 18, 18),
      SCM_STRING_CONST_INITIALIZER("boolean", 7, 7),
      SCM_STRING_CONST_INITIALIZER("proper-list?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("dotted-list?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("circular-list?", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-list", 9, 9),
      SCM_STRING_CONST_INITIALIZER("acons", 5, 5),
      SCM_STRING_CONST_INITIALIZER("last-pair", 9, 9),
      SCM_STRING_CONST_INITIALIZER("list-copy", 9, 9),
      SCM_STRING_CONST_INITIALIZER("list*", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%delete", 7, 7),
      SCM_STRING_CONST_INITIALIZER("%delete!", 8, 8),
      SCM_STRING_CONST_INITIALIZER("%delete-duplicates", 18, 18),
      SCM_STRING_CONST_INITIALIZER("%delete-duplicates!", 19, 19),
      SCM_STRING_CONST_INITIALIZER("%alist-delete", 13, 13),
      SCM_STRING_CONST_INITIALIZER("%alist-delete!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("append!", 7, 7),
      SCM_STRING_CONST_INITIALIZER("reverse!", 8, 8),
      SCM_STRING_CONST_INITIALIZER("%sort", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%sort!", 6, 6),
      SCM_STRING_CONST_INITIALIZER("monotonic-merge", 15, 15),
      SCM_STRING_CONST_INITIALIZER("gensym", 6, 6),
      SCM_STRING_CONST_INITIALIZER("symbol-interned?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string->uninterned-symbol", 25, 25),
      SCM_STRING_CONST_INITIALIZER("symbol-sans-prefix", 18, 18),
      SCM_STRING_CONST_INITIALIZER("keyword?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("make-keyword", 12, 12),
      SCM_STRING_CONST_INITIALIZER("get-keyword", 11, 11),
      SCM_STRING_CONST_INITIALIZER("delete-keyword", 14, 14),
      SCM_STRING_CONST_INITIALIZER("delete-keyword!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("keyword->string", 15, 15),
      SCM_STRING_CONST_INITIALIZER("identifier?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("identifier->symbol", 18, 18),
      SCM_STRING_CONST_INITIALIZER("digit->integer", 14, 14),
      SCM_STRING_CONST_INITIALIZER("integer->digit", 14, 14),
      SCM_STRING_CONST_INITIALIZER("ucs->char", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char->ucs", 9, 9),
      SCM_STRING_CONST_INITIALIZER("gauche-character-encoding", 25, 25),
      SCM_STRING_CONST_INITIALIZER("supported-character-encodings", 29, 29),
      SCM_STRING_CONST_INITIALIZER("supported-character-encoding?", 29, 29),
      SCM_STRING_CONST_INITIALIZER("char-title-case?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-titlecase", 14, 14),
      SCM_STRING_CONST_INITIALIZER("char-foldcase", 13, 13),
      SCM_STRING_CONST_INITIALIZER("char-general-category", 21, 21),
      SCM_STRING_CONST_INITIALIZER("Lu", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Ll", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Lt", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Lm", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Lo", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Mn", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Mc", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Me", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Nd", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Nl", 2, 2),
      SCM_STRING_CONST_INITIALIZER("No", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Pc", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Pd", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Ps", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Pe", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Pi", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Pf", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Po", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Sm", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Sc", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Sk", 2, 2),
      SCM_STRING_CONST_INITIALIZER("So", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Zs", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Zl", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Zp", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Cc", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Cf", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Cs", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Co", 2, 2),
      SCM_STRING_CONST_INITIALIZER("Cn", 2, 2),
      SCM_STRING_CONST_INITIALIZER("*char-code-max*", 15, 15),
      SCM_STRING_CONST_INITIALIZER("char-set?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("%char-set-equal?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("%char-set<=?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("char-set", 8, 8),
      SCM_STRING_CONST_INITIALIZER("char-set-copy", 13, 13),
      SCM_STRING_CONST_INITIALIZER("error", 5, 5),
      SCM_STRING_CONST_INITIALIZER("posix-bracket", 13, 13),
      SCM_STRING_CONST_INITIALIZER("read-char-set", 13, 13),
      SCM_STRING_CONST_INITIALIZER("%char-set-add-chars!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("%char-set-add-range!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("char-set-contains?", 18, 18),
      SCM_STRING_CONST_INITIALIZER("%char-set-add!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%char-set-complement!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("%char-set-ranges", 16, 16),
      SCM_STRING_CONST_INITIALIZER("%char-set-predefined", 20, 20),
      SCM_STRING_CONST_INITIALIZER("string-incomplete?", 18, 18),
      SCM_STRING_CONST_INITIALIZER("string-immutable?", 17, 17),
      SCM_STRING_CONST_INITIALIZER("string-incomplete->complete!", 28, 28),
      SCM_STRING_CONST_INITIALIZER("string-complete->incomplete", 27, 27),
      SCM_STRING_CONST_INITIALIZER("string-incomplete->complete", 27, 27),
      SCM_STRING_CONST_INITIALIZER("omit", 4, 4),
      SCM_STRING_CONST_INITIALIZER("string-size", 11, 11),
      SCM_STRING_CONST_INITIALIZER("make-byte-string", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string-byte-ref", 15, 15),
      SCM_STRING_CONST_INITIALIZER("byte-substring", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%string-replace-body!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("%maybe-substring", 16, 16),
      SCM_STRING_CONST_INITIALIZER(" ", 1, 1),
      SCM_STRING_CONST_INITIALIZER("infix", 5, 5),
      SCM_STRING_CONST_INITIALIZER("string-join", 11, 11),
      SCM_STRING_CONST_INITIALIZER("prefix", 6, 6),
      SCM_STRING_CONST_INITIALIZER("suffix", 6, 6),
      SCM_STRING_CONST_INITIALIZER("strict-infix", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%hash-string", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%string-split-by-char", 21, 21),
      SCM_STRING_CONST_INITIALIZER("index", 5, 5),
      SCM_STRING_CONST_INITIALIZER("string-scan", 11, 11),
      SCM_STRING_CONST_INITIALIZER("both", 4, 4),
      SCM_STRING_CONST_INITIALIZER("after*", 6, 6),
      SCM_STRING_CONST_INITIALIZER("before*", 7, 7),
      SCM_STRING_CONST_INITIALIZER("after", 5, 5),
      SCM_STRING_CONST_INITIALIZER("before", 6, 6),
      SCM_STRING_CONST_INITIALIZER("make-string-pointer", 19, 19),
      SCM_STRING_CONST_INITIALIZER("string-pointer?", 15, 15),
      SCM_STRING_CONST_INITIALIZER("string-pointer-ref", 18, 18),
      SCM_STRING_CONST_INITIALIZER("string-pointer-next!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("string-pointer-prev!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("string-pointer-set!", 19, 19),
      SCM_STRING_CONST_INITIALIZER("string-pointer-substring", 24, 24),
      SCM_STRING_CONST_INITIALIZER("string-pointer-index", 20, 20),
      SCM_STRING_CONST_INITIALIZER("string-pointer-copy", 19, 19),
      SCM_STRING_CONST_INITIALIZER("string-pointer-byte-index", 25, 25),
      SCM_STRING_CONST_INITIALIZER("regexp?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("regmatch?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("case-fold", 9, 9),
      SCM_STRING_CONST_INITIALIZER("string->regexp", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%regexp-pattern", 15, 15),
      SCM_STRING_CONST_INITIALIZER("(setter %regexp-pattern)", 24, 24),
      SCM_STRING_CONST_INITIALIZER("regexp-ast", 10, 10),
      SCM_STRING_CONST_INITIALIZER("regexp-case-fold?", 17, 17),
      SCM_STRING_CONST_INITIALIZER("regexp-parse", 12, 12),
      SCM_STRING_CONST_INITIALIZER("regexp-compile", 14, 14),
      SCM_STRING_CONST_INITIALIZER("regexp-optimize", 15, 15),
      SCM_STRING_CONST_INITIALIZER("rxmatch", 7, 7),
      SCM_STRING_CONST_INITIALIZER("rxmatch-substring", 17, 17),
      SCM_STRING_CONST_INITIALIZER("rxmatch-start", 13, 13),
      SCM_STRING_CONST_INITIALIZER("rxmatch-end", 11, 11),
      SCM_STRING_CONST_INITIALIZER("rxmatch-before", 14, 14),
      SCM_STRING_CONST_INITIALIZER("rxmatch-after", 13, 13),
      SCM_STRING_CONST_INITIALIZER("rxmatch-num-matches", 19, 19),
      SCM_STRING_CONST_INITIALIZER("vector-copy", 11, 11),
      SCM_STRING_CONST_INITIALIZER("make-weak-vector", 16, 16),
      SCM_STRING_CONST_INITIALIZER("weak-vector-length", 18, 18),
      SCM_STRING_CONST_INITIALIZER("weak-vector-ref", 15, 15),
      SCM_STRING_CONST_INITIALIZER("weak-vector-set!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("%uvector-ref", 12, 12),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S8", 14, 14),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U8", 14, 14),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("uvector-length", 14, 14),
      SCM_STRING_CONST_INITIALIZER("uvector-immutable?", 18, 18),
      SCM_STRING_CONST_INITIALIZER("setter", 6, 6),
      SCM_STRING_CONST_INITIALIZER("(setter setter)", 15, 15),
      SCM_STRING_CONST_INITIALIZER("has-setter?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("identity", 8, 8),
      SCM_STRING_CONST_INITIALIZER("promise?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("eager", 5, 5),
      SCM_STRING_CONST_INITIALIZER("promise-kind", 12, 12),
      SCM_STRING_CONST_INITIALIZER("(setter promise-kind)", 21, 21),
      SCM_STRING_CONST_INITIALIZER("eof-object", 10, 10),
      SCM_STRING_CONST_INITIALIZER("if-does-not-exist", 17, 17),
      SCM_STRING_CONST_INITIALIZER("buffering", 9, 9),
      SCM_STRING_CONST_INITIALIZER("character", 9, 9),
      SCM_STRING_CONST_INITIALIZER("element-type", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%open-input-file", 16, 16),
      SCM_STRING_CONST_INITIALIZER("supersede", 9, 9),
      SCM_STRING_CONST_INITIALIZER("if-exists", 9, 9),
      SCM_STRING_CONST_INITIALIZER("create", 6, 6),
      SCM_STRING_CONST_INITIALIZER("mode", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%open-output-file", 17, 17),
      SCM_STRING_CONST_INITIALIZER("overwrite", 9, 9),
      SCM_STRING_CONST_INITIALIZER("append", 6, 6),
      SCM_STRING_CONST_INITIALIZER("private?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("open-input-string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("open-output-string", 18, 18),
      SCM_STRING_CONST_INITIALIZER("get-output-string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("get-output-byte-string", 22, 22),
      SCM_STRING_CONST_INITIALIZER("get-remaining-input-string", 26, 26),
      SCM_STRING_CONST_INITIALIZER("open-coding-aware-port", 22, 22),
      SCM_STRING_CONST_INITIALIZER("open-input-buffered-port", 24, 24),
      SCM_STRING_CONST_INITIALIZER("open-output-buffered-port", 25, 25),
      SCM_STRING_CONST_INITIALIZER("flush", 5, 5),
      SCM_STRING_CONST_INITIALIZER("flush-all-ports", 15, 15),
      SCM_STRING_CONST_INITIALIZER("port-closed?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("port-case-fold-set!", 19, 19),
      SCM_STRING_CONST_INITIALIZER("current-error-port", 18, 18),
      SCM_STRING_CONST_INITIALIZER("standard-input-port", 19, 19),
      SCM_STRING_CONST_INITIALIZER("standard-output-port", 20, 20),
      SCM_STRING_CONST_INITIALIZER("standard-error-port", 19, 19),
      SCM_STRING_CONST_INITIALIZER("port-name", 9, 9),
      SCM_STRING_CONST_INITIALIZER("port-current-line", 17, 17),
      SCM_STRING_CONST_INITIALIZER("port-file-number", 16, 16),
      SCM_STRING_CONST_INITIALIZER("port-fd-dup!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("SEEK_SET", 8, 8),
      SCM_STRING_CONST_INITIALIZER("SEEK_CUR", 8, 8),
      SCM_STRING_CONST_INITIALIZER("SEEK_END", 8, 8),
      SCM_STRING_CONST_INITIALIZER("port-seek", 9, 9),
      SCM_STRING_CONST_INITIALIZER("port-type", 9, 9),
      SCM_STRING_CONST_INITIALIZER("file", 4, 4),
      SCM_STRING_CONST_INITIALIZER("proc", 4, 4),
      SCM_STRING_CONST_INITIALIZER("string", 6, 6),
      SCM_STRING_CONST_INITIALIZER("port-buffering", 14, 14),
      SCM_STRING_CONST_INITIALIZER("(setter port-buffering)", 23, 23),
      SCM_STRING_CONST_INITIALIZER("owner?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("name", 4, 4),
      SCM_STRING_CONST_INITIALIZER("open-input-fd-port", 18, 18),
      SCM_STRING_CONST_INITIALIZER("open-output-fd-port", 19, 19),
      SCM_STRING_CONST_INITIALIZER("with-port-locking", 17, 17),
      SCM_STRING_CONST_INITIALIZER("port->byte-string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("byte-ready?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("read-byte", 9, 9),
      SCM_STRING_CONST_INITIALIZER("peek-byte", 9, 9),
      SCM_STRING_CONST_INITIALIZER("read-line", 9, 9),
      SCM_STRING_CONST_INITIALIZER("read-block", 10, 10),
      SCM_STRING_CONST_INITIALIZER("read-list", 9, 9),
      SCM_STRING_CONST_INITIALIZER("define-reader-ctor", 18, 18),
      SCM_STRING_CONST_INITIALIZER("%get-reader-ctor", 16, 16),
      SCM_STRING_CONST_INITIALIZER("define-reader-directive", 23, 23),
      SCM_STRING_CONST_INITIALIZER("read-reference?", 15, 15),
      SCM_STRING_CONST_INITIALIZER("read-reference-has-value?", 25, 25),
      SCM_STRING_CONST_INITIALIZER("read-reference-value", 20, 20),
      SCM_STRING_CONST_INITIALIZER("write-byte", 10, 10),
      SCM_STRING_CONST_INITIALIZER("write-limited", 13, 13),
      SCM_STRING_CONST_INITIALIZER("write*", 6, 6),
      SCM_STRING_CONST_INITIALIZER("%add-load-path", 14, 14),
      SCM_STRING_CONST_INITIALIZER("paths", 5, 5),
      SCM_STRING_CONST_INITIALIZER("environment", 11, 11),
      SCM_STRING_CONST_INITIALIZER("main-script", 11, 11),
      SCM_STRING_CONST_INITIALIZER("load-from-port", 14, 14),
      SCM_STRING_CONST_INITIALIZER("init-function", 13, 13),
      SCM_STRING_CONST_INITIALIZER("export-symbols", 14, 14),
      SCM_STRING_CONST_INITIALIZER("dynamic-load", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%require", 8, 8),
      SCM_STRING_CONST_INITIALIZER("provide", 7, 7),
      SCM_STRING_CONST_INITIALIZER("provided?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("%autoload", 9, 9),
      SCM_STRING_CONST_INITIALIZER("undefined", 9, 9),
      SCM_STRING_CONST_INITIALIZER("undefined?", 10, 10),
      SCM_STRING_CONST_INITIALIZER("warn", 4, 4),
      SCM_STRING_CONST_INITIALIZER("eq-hash", 7, 7),
      SCM_STRING_CONST_INITIALIZER("eqv-hash", 8, 8),
      SCM_STRING_CONST_INITIALIZER("hash", 4, 4),
      SCM_STRING_CONST_INITIALIZER("hash-table?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("make-hash-table", 15, 15),
      SCM_STRING_CONST_INITIALIZER("string=?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("hash-table-type", 15, 15),
      SCM_STRING_CONST_INITIALIZER("hash-table-num-entries", 22, 22),
      SCM_STRING_CONST_INITIALIZER("hash-table-clear!", 17, 17),
      SCM_STRING_CONST_INITIALIZER("hash-table-get", 14, 14),
      SCM_STRING_CONST_INITIALIZER("hash-table-put!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("hash-table-delete!", 18, 18),
      SCM_STRING_CONST_INITIALIZER("hash-table-exists?", 18, 18),
      SCM_STRING_CONST_INITIALIZER("hash-table-update!", 18, 18),
      SCM_STRING_CONST_INITIALIZER("hash-table-push!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("hash-table-pop!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("%hash-table-iter", 16, 16),
      SCM_STRING_CONST_INITIALIZER("hash-table-iterator", 19, 19),
      SCM_STRING_CONST_INITIALIZER("hash-table-copy", 15, 15),
      SCM_STRING_CONST_INITIALIZER("hash-table-keys", 15, 15),
      SCM_STRING_CONST_INITIALIZER("hash-table-values", 17, 17),
      SCM_STRING_CONST_INITIALIZER("hash-table-stat", 15, 15),
      SCM_STRING_CONST_INITIALIZER("%make-tree-map", 14, 14),
      SCM_STRING_CONST_INITIALIZER("tree-map-copy", 13, 13),
      SCM_STRING_CONST_INITIALIZER("tree-map?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("tree-map-get", 12, 12),
      SCM_STRING_CONST_INITIALIZER("tree-map-put!", 13, 13),
      SCM_STRING_CONST_INITIALIZER("tree-map-delete!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("tree-map-update!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("tree-map-push!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("tree-map-pop!", 13, 13),
      SCM_STRING_CONST_INITIALIZER("tree-map-exists?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("tree-map-num-entries", 20, 20),
      SCM_STRING_CONST_INITIALIZER("%tree-map-bound", 15, 15),
      SCM_STRING_CONST_INITIALIZER("%tree-map-iter", 14, 14),
      SCM_STRING_CONST_INITIALIZER("tree-map-iterator", 17, 17),
      SCM_STRING_CONST_INITIALIZER("%tree-map-check-consistency", 27, 27),
      SCM_STRING_CONST_INITIALIZER("%tree-map-dump", 14, 14),
      SCM_STRING_CONST_INITIALIZER("tree-map-clear!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("tree-map-floor", 14, 14),
      SCM_STRING_CONST_INITIALIZER("tree-map-floor-key", 18, 18),
      SCM_STRING_CONST_INITIALIZER("tree-map-floor-value", 20, 20),
      SCM_STRING_CONST_INITIALIZER("tree-map-ceiling", 16, 16),
      SCM_STRING_CONST_INITIALIZER("tree-map-ceiling-key", 20, 20),
      SCM_STRING_CONST_INITIALIZER("tree-map-ceiling-value", 22, 22),
      SCM_STRING_CONST_INITIALIZER("tree-map-predecessor", 20, 20),
      SCM_STRING_CONST_INITIALIZER("tree-map-predecessor-key", 24, 24),
      SCM_STRING_CONST_INITIALIZER("tree-map-predecessor-value", 26, 26),
      SCM_STRING_CONST_INITIALIZER("tree-map-successor", 18, 18),
      SCM_STRING_CONST_INITIALIZER("tree-map-successor-key", 22, 22),
      SCM_STRING_CONST_INITIALIZER("tree-map-successor-value", 24, 24),
      SCM_STRING_CONST_INITIALIZER("module?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("module-name", 11, 11),
      SCM_STRING_CONST_INITIALIZER("module-parents", 14, 14),
      SCM_STRING_CONST_INITIALIZER("module-precedence-list", 22, 22),
      SCM_STRING_CONST_INITIALIZER("module-imports", 14, 14),
      SCM_STRING_CONST_INITIALIZER("module-exports", 14, 14),
      SCM_STRING_CONST_INITIALIZER("module-table", 12, 12),
      SCM_STRING_CONST_INITIALIZER("find-module", 11, 11),
      SCM_STRING_CONST_INITIALIZER("all-modules", 11, 11),
      SCM_STRING_CONST_INITIALIZER("make-module", 11, 11),
      SCM_STRING_CONST_INITIALIZER("module-name->path", 17, 17),
      SCM_STRING_CONST_INITIALIZER("path->module-name", 17, 17),
      SCM_STRING_CONST_INITIALIZER("%export-all", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%extend-module", 14, 14),
      SCM_STRING_CONST_INITIALIZER("global-variable-bound?", 22, 22),
      SCM_STRING_CONST_INITIALIZER("global-variable-ref", 19, 19),
      SCM_STRING_CONST_INITIALIZER("%format", 7, 7),
      SCM_STRING_CONST_INITIALIZER("%exit", 5, 5),
      SCM_STRING_CONST_INITIALIZER("vm-dump", 7, 7),
      SCM_STRING_CONST_INITIALIZER("vm-get-stack-trace", 18, 18),
      SCM_STRING_CONST_INITIALIZER("vm-get-stack-trace-lite", 23, 23),
      SCM_STRING_CONST_INITIALIZER("port", 4, 4),
      SCM_STRING_CONST_INITIALIZER("maxdepth", 8, 8),
      SCM_STRING_CONST_INITIALIZER("skip", 4, 4),
      SCM_STRING_CONST_INITIALIZER("offset", 6, 6),
      SCM_STRING_CONST_INITIALIZER("%vm-show-stack-trace", 20, 20),
      SCM_STRING_CONST_INITIALIZER("vm-set-default-exception-handler", 32, 32),
      SCM_STRING_CONST_INITIALIZER("current-load-history", 20, 20),
      SCM_STRING_CONST_INITIALIZER("current-load-next", 17, 17),
      SCM_STRING_CONST_INITIALIZER("current-load-port", 17, 17),
      SCM_STRING_CONST_INITIALIZER("%vm-make-parameter-slot", 23, 23),
      SCM_STRING_CONST_INITIALIZER("%vm-parameter-ref", 17, 17),
      SCM_STRING_CONST_INITIALIZER("%vm-parameter-set!", 18, 18),
      SCM_STRING_CONST_INITIALIZER("gauche-version", 14, 14),
      SCM_STRING_CONST_INITIALIZER("gauche-architecture", 19, 19),
      SCM_STRING_CONST_INITIALIZER("gauche-library-directory", 24, 24),
      SCM_STRING_CONST_INITIALIZER("gauche-architecture-directory", 29, 29),
      SCM_STRING_CONST_INITIALIZER("gauche-site-library-directory", 29, 29),
      SCM_STRING_CONST_INITIALIZER("gauche-site-architecture-directory", 34, 34),
      SCM_STRING_CONST_INITIALIZER("gauche-dso-suffix", 17, 17),
      SCM_STRING_CONST_INITIALIZER("%gauche-runtime-directory", 25, 25),
      SCM_STRING_CONST_INITIALIZER("current-thread", 14, 14),
      SCM_STRING_CONST_INITIALIZER("unwrap-syntax", 13, 13),
      SCM_STRING_CONST_INITIALIZER("foreign-pointer-attributes", 26, 26),
      SCM_STRING_CONST_INITIALIZER("foreign-pointer-attribute-get", 29, 29),
      SCM_STRING_CONST_INITIALIZER("foreign-pointer-attribute-set", 29, 29),
      SCM_STRING_CONST_INITIALIZER("gc", 2, 2),
      SCM_STRING_CONST_INITIALIZER("gc-stat", 7, 7),
      SCM_STRING_CONST_INITIALIZER("total-heap-size", 15, 15),
      SCM_STRING_CONST_INITIALIZER("free-bytes", 10, 10),
      SCM_STRING_CONST_INITIALIZER("bytes-since-gc", 14, 14),
      SCM_STRING_CONST_INITIALIZER("total-bytes", 11, 11),
      SCM_STRING_CONST_INITIALIZER("profiler-start", 14, 14),
      SCM_STRING_CONST_INITIALIZER("profiler-stop", 13, 13),
      SCM_STRING_CONST_INITIALIZER("profiler-reset", 14, 14),
      SCM_STRING_CONST_INITIALIZER("subr?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("closure?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("toplevel-closure?", 17, 17),
      SCM_STRING_CONST_INITIALIZER("closure-code", 12, 12),
      SCM_STRING_CONST_INITIALIZER("method-code", 11, 11),
      SCM_STRING_CONST_INITIALIZER("procedure-info", 14, 14),
  },
};
static struct scm__rcRec {
  ScmObj d1004[95];
} scm__rc = {
  {   /* ScmObj d1004 */
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
  },
};
static ScmObj extlib_macroexpand(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj form_scm;
  ScmObj form;
  SCM_ENTER_SUBR("macroexpand");
  form_scm = SCM_ARGREF(0);
  form = (form_scm);
  {
{
ScmObj SCM_RESULT;

#line 48 "extlib.stub"
SCM_RESULT=(Scm_VMMacroExpand(form,SCM_NIL,FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_macroexpand__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[0]),extlib_macroexpand, NULL, NULL);

static ScmObj extlib_macroexpand_1(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj form_scm;
  ScmObj form;
  SCM_ENTER_SUBR("macroexpand-1");
  form_scm = SCM_ARGREF(0);
  form = (form_scm);
  {
{
ScmObj SCM_RESULT;

#line 50 "extlib.stub"
SCM_RESULT=(Scm_VMMacroExpand(form,SCM_NIL,TRUE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_macroexpand_1__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[1]),extlib_macroexpand_1, NULL, NULL);

static int getcmpmode(ScmObj opt){{
#line 58 "extlib.stub"
if (
(SCM_UNBOUNDP(opt))||(SCM_EQ(opt,scm__rc.d1004[2]))){return (SCM_CMP_EQUAL);}else if(
SCM_EQ(opt,scm__rc.d1004[1])){return (SCM_CMP_EQ);}else if(
SCM_EQ(opt,scm__rc.d1004[0])){return (SCM_CMP_EQV);} else {
Scm_Error("unrecognized compare mode: %S",opt);return (0);}}}
static ScmObj extlib_compare(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj y_scm;
  ScmObj y;
  SCM_ENTER_SUBR("compare");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  y_scm = SCM_ARGREF(1);
  y = (y_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_Compare(x,y));
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_compare__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[5]),extlib_compare, NULL, NULL);

static ScmObj extlib_ash(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  ScmObj cnt_scm;
  int cnt;
  SCM_ENTER_SUBR("ash");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  cnt_scm = SCM_ARGREF(1);
  if (!SCM_INTP(cnt_scm)) Scm_Error("small integer required, but got %S", cnt_scm);
  cnt = SCM_INT_VALUE(cnt_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Ash(num,cnt));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_ash__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[6]),0, extlib_ash, NULL, NULL);

static ScmObj extlib_lognot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("lognot");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_LogNot(x));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_lognot__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[7]),0, extlib_lognot, NULL, NULL);

static ScmObj extlib_logand(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj* arg2;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("logand");
  arg2 = &SCM_ARGREF(0);
  optcnt = SCM_ARGCNT-1-0;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1007;
#line 87 "extlib.stub"
if ((optcnt)==(0)){SCM_RESULT=(SCM_MAKE_INT(-1));}else if((optcnt)==(1)){if (!(SCM_INTEGERP((arg2)[0]))){{Scm_Error("Exact integer required, but got %S",(arg2)[0]);}}SCM_RESULT=((arg2)[0]);} else {{ScmObj r=Scm_LogAnd((arg2)[0],(arg2)[1]);SCM_FOR_EACH(cise__1007,args) {{ScmObj v=SCM_CAR(cise__1007);r=(Scm_LogAnd(r,v));}}SCM_RESULT=(r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_logand__STUB, 0, 3,1, SCM_OBJ(&scm__sc.d1003[8]),0, extlib_logand, NULL, NULL);

static ScmObj extlib_logior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj* arg2;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("logior");
  arg2 = &SCM_ARGREF(0);
  optcnt = SCM_ARGCNT-1-0;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1008;
#line 89 "extlib.stub"
if ((optcnt)==(0)){SCM_RESULT=(SCM_MAKE_INT(0));}else if((optcnt)==(1)){if (!(SCM_INTEGERP((arg2)[0]))){{Scm_Error("Exact integer required, but got %S",(arg2)[0]);}}SCM_RESULT=((arg2)[0]);} else {{ScmObj r=Scm_LogIor((arg2)[0],(arg2)[1]);SCM_FOR_EACH(cise__1008,args) {{ScmObj v=SCM_CAR(cise__1008);r=(Scm_LogIor(r,v));}}SCM_RESULT=(r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_logior__STUB, 0, 3,1, SCM_OBJ(&scm__sc.d1003[9]),0, extlib_logior, NULL, NULL);

static ScmObj extlib_logxor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj* arg2;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("logxor");
  arg2 = &SCM_ARGREF(0);
  optcnt = SCM_ARGCNT-1-0;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1009;
#line 91 "extlib.stub"
if ((optcnt)==(0)){SCM_RESULT=(SCM_MAKE_INT(0));}else if((optcnt)==(1)){if (!(SCM_INTEGERP((arg2)[0]))){{Scm_Error("Exact integer required, but got %S",(arg2)[0]);}}SCM_RESULT=((arg2)[0]);} else {{ScmObj r=Scm_LogXor((arg2)[0],(arg2)[1]);SCM_FOR_EACH(cise__1009,args) {{ScmObj v=SCM_CAR(cise__1009);r=(Scm_LogXor(r,v));}}SCM_RESULT=(r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_logxor__STUB, 0, 3,1, SCM_OBJ(&scm__sc.d1003[10]),0, extlib_logxor, NULL, NULL);

static ScmObj extlib_logcount(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  ScmObj n;
  SCM_ENTER_SUBR("logcount");
  n_scm = SCM_ARGREF(0);
  n = (n_scm);
  {
{
int SCM_RESULT;

#line 94 "extlib.stub"
if (SCM_EQ(n,SCM_MAKE_INT(0))){SCM_RESULT=(0);}else if(
SCM_INTP(n)){
{ScmBits z=((ScmBits )(((long )(SCM_INT_VALUE(n)))));
if ((SCM_INT_VALUE(n))>(0)){
SCM_RESULT=(Scm_BitsCount1(&(z),0,SCM_WORD_BITS));} else {
SCM_RESULT=(Scm_BitsCount0(&(z),0,SCM_WORD_BITS));}}}else if(
SCM_BIGNUMP(n)){SCM_RESULT=(Scm_BignumLogCount(SCM_BIGNUM(n)));} else {
SCM_TYPE_ERROR(n,"exact integer");SCM_RESULT=(0);}
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_logcount__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[11]),0, extlib_logcount, NULL, NULL);

static ScmObj extlib_integer_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  ScmObj n;
  SCM_ENTER_SUBR("integer-length");
  n_scm = SCM_ARGREF(0);
  n = (n_scm);
  {
{
int SCM_RESULT;

#line 104 "extlib.stub"
if (SCM_INTP(n)){
{ScmBits z=((ScmBits )(((long )(SCM_INT_VALUE(n)))));
if ((SCM_INT_VALUE(n))>=(0)){
SCM_RESULT=((Scm_BitsHighest1(&(z),0,SCM_WORD_BITS))+(1));} else {
SCM_RESULT=((Scm_BitsHighest0(&(z),0,SCM_WORD_BITS))+(1));}}}else if(
SCM_BIGNUMP(n)){
#line 111 "extlib.stub"
if ((SCM_BIGNUM_SIGN(n))<(0)){{
n=(Scm_Add(n,SCM_MAKE_INT(1)));}}
#line 114 "extlib.stub"
if (SCM_BIGNUMP(n)){
{ScmBits* z=((ScmBits* )((SCM_BIGNUM(n))->values));int k=
SCM_BIGNUM_SIZE(n);
SCM_RESULT=((Scm_BitsHighest1(z,0,(k)*(SCM_WORD_BITS)))+(1));}} else {
#line 119 "extlib.stub"
SCM_RESULT=((SCM_SMALL_INT_SIZE)+(1));}} else {
SCM_TYPE_ERROR(n,"exact integer");SCM_RESULT=(0);}
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_integer_length__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[12]),0, extlib_integer_length, NULL, NULL);

static ScmObj extlib_fixnumP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("fixnum?");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_INTP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_fixnumP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[13]),SCM_SUBR_IMMEDIATE_ARG, extlib_fixnumP, NULL, NULL);

static ScmObj extlib_bignumP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("bignum?");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_BIGNUMP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_bignumP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[14]),SCM_SUBR_IMMEDIATE_ARG, extlib_bignumP, NULL, NULL);

static ScmObj extlib_flonumP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("flonum?");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_FLONUMP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_flonumP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[15]),SCM_SUBR_IMMEDIATE_ARG, extlib_flonumP, NULL, NULL);

static ScmObj extlib_finiteP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("finite?");
  x_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(x_scm)) Scm_Error("number required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_FiniteP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_finiteP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[16]),SCM_SUBR_IMMEDIATE_ARG, extlib_finiteP, NULL, NULL);

static ScmObj extlib_infiniteP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("infinite?");
  x_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(x_scm)) Scm_Error("number required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_InfiniteP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_infiniteP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[17]),SCM_SUBR_IMMEDIATE_ARG, extlib_infiniteP, NULL, NULL);

static ScmObj extlib_nanP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("nan?");
  x_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(x_scm)) Scm_Error("number required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_NanP(x));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_nanP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[18]),SCM_SUBR_IMMEDIATE_ARG, extlib_nanP, NULL, NULL);

static ScmObj extlib_fixnum_width(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("fixnum-width");
  {
{
int SCM_RESULT;

#line 132 "extlib.stub"
SCM_RESULT=(SCM_SMALL_INT_SIZE);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_fixnum_width__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[19]),SCM_SUBR_IMMEDIATE_ARG, extlib_fixnum_width, NULL, NULL);

static ScmObj extlib_least_fixnum(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("least-fixnum");
  {
{
long SCM_RESULT;

#line 133 "extlib.stub"
SCM_RESULT=(SCM_SMALL_INT_MIN);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_least_fixnum__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[20]),SCM_SUBR_IMMEDIATE_ARG, extlib_least_fixnum, NULL, NULL);

static ScmObj extlib_greatest_fixnum(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("greatest-fixnum");
  {
{
long SCM_RESULT;

#line 134 "extlib.stub"
SCM_RESULT=(SCM_SMALL_INT_MAX);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_greatest_fixnum__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[21]),SCM_SUBR_IMMEDIATE_ARG, extlib_greatest_fixnum, NULL, NULL);

static ScmObj extlib_inexact__2f(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("inexact-/");
  arg1_scm = SCM_ARGREF(0);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1010;
#line 146 "extlib.stub"
if (SCM_NULLP(args)){SCM_RESULT=(Scm_ReciprocalInexact(arg1));} else {
SCM_FOR_EACH(cise__1010,args) {{ScmObj x=SCM_CAR(cise__1010);arg1=(Scm_DivInexact(arg1,x));}}
SCM_RESULT=(arg1);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_inexact__2f__STUB, 1, 1,SCM_OBJ(&scm__sc.d1003[22]),extlib_inexact__2f, NULL, NULL);

static ScmObj extlib__2b_2e(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("+.");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1011;
#line 154 "extlib.stub"
{ScmObj a=scm__rc.d1004[3];
SCM_FOR_EACH(cise__1011,args) {{ScmObj x=SCM_CAR(cise__1011);a=(Scm_Add(a,Scm_Inexact(x)));}}
SCM_RESULT=(a);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__2b_2e__STUB, 0, 1,1, SCM_OBJ(&scm__sc.d1003[23]),SCM_SUBR_IMMEDIATE_ARG, extlib__2b_2e, NULL, NULL);

static ScmObj extlib__2a_2e(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("*.");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1012;
#line 158 "extlib.stub"
{ScmObj a=scm__rc.d1004[4];
SCM_FOR_EACH(cise__1012,args) {{ScmObj x=SCM_CAR(cise__1012);a=(Scm_Mul(a,Scm_Inexact(x)));}}
SCM_RESULT=(a);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__2a_2e__STUB, 0, 1,1, SCM_OBJ(&scm__sc.d1003[24]),SCM_SUBR_IMMEDIATE_ARG, extlib__2a_2e, NULL, NULL);

static ScmObj extlib___2e(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("-.");
  arg1_scm = SCM_ARGREF(0);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1013;
#line 162 "extlib.stub"
if (
SCM_NULLP(args)){SCM_RESULT=(Scm_Negate(Scm_Inexact(arg1)));} else {
SCM_FOR_EACH(cise__1013,args) {{ScmObj x=SCM_CAR(cise__1013);arg1=(Scm_Sub(arg1,Scm_Inexact(x)));}}
SCM_RESULT=(arg1);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib___2e__STUB, 1, 1,1, SCM_OBJ(&scm__sc.d1003[25]),0, extlib___2e, NULL, NULL);

static ScmObj extlib__2f_2e(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("/.");
  arg1_scm = SCM_ARGREF(0);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1014;
#line 167 "extlib.stub"
if (
SCM_NULLP(args)){SCM_RESULT=(Scm_Reciprocal(Scm_Inexact(arg1)));} else {
SCM_FOR_EACH(cise__1014,args) {{ScmObj x=SCM_CAR(cise__1014);arg1=(Scm_Div(arg1,Scm_Inexact(x)));}}
SCM_RESULT=(arg1);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__2f_2e__STUB, 1, 1,1, SCM_OBJ(&scm__sc.d1003[26]),0, extlib__2f_2e, NULL, NULL);

static ScmObj extlib_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj min_scm;
  ScmObj min;
  ScmObj max_scm;
  ScmObj max;
  SCM_ENTER_SUBR("clamp");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  if (SCM_ARGCNT > 1+1) {
    min_scm = SCM_ARGREF(1);
  } else {
    min_scm = SCM_FALSE;
  }
  min = (min_scm);
  if (SCM_ARGCNT > 2+1) {
    max_scm = SCM_ARGREF(2);
  } else {
    max_scm = SCM_FALSE;
  }
  max = (max_scm);
  {
{
ScmObj SCM_RESULT;

#line 173 "extlib.stub"
{ScmObj r=x;int maybe_exact=SCM_EXACTP(x);
if (!(SCM_REALP(x))){{SCM_TYPE_ERROR(x,"real number");}}
if (SCM_EXACTP(min)){if ((Scm_NumCmp(x,min))<(0)){{r=(min);}}}else if(
SCM_FLONUMP(min)){
maybe_exact=(FALSE);
if ((Scm_NumCmp(x,min))<(0)){{r=(min);}}}else if(
!(SCM_FALSEP(min))){SCM_TYPE_ERROR(min,"real number or #f");}
if (SCM_EXACTP(max)){if ((Scm_NumCmp(x,max))>(0)){{r=(max);}}}else if(
SCM_FLONUMP(max)){
maybe_exact=(FALSE);
if ((Scm_NumCmp(x,max))>(0)){{r=(max);}}}else if(
!(SCM_FALSEP(max))){SCM_TYPE_ERROR(max,"real number or #f");}
if ((!(maybe_exact))&&(SCM_EXACTP(r))){
return (Scm_Inexact(r));} else {
return (r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_clamp__STUB, 1, 3,1, SCM_OBJ(&scm__sc.d1003[27]),SCM_SUBR_IMMEDIATE_ARG, extlib_clamp, NULL, NULL);

static ScmObj extlib_floor_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  SCM_ENTER_SUBR("floor->exact");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  {
{
ScmObj SCM_RESULT;

#line 190 "extlib.stub"
SCM_RESULT=(Scm_RoundToExact(num,SCM_ROUND_FLOOR));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_floor_TOexact__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[28]),SCM_SUBR_IMMEDIATE_ARG, extlib_floor_TOexact, NULL, NULL);

static ScmObj extlib_ceiling_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  SCM_ENTER_SUBR("ceiling->exact");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  {
{
ScmObj SCM_RESULT;

#line 192 "extlib.stub"
SCM_RESULT=(Scm_RoundToExact(num,SCM_ROUND_CEIL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_ceiling_TOexact__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[29]),SCM_SUBR_IMMEDIATE_ARG, extlib_ceiling_TOexact, NULL, NULL);

static ScmObj extlib_truncate_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  SCM_ENTER_SUBR("truncate->exact");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  {
{
ScmObj SCM_RESULT;

#line 194 "extlib.stub"
SCM_RESULT=(Scm_RoundToExact(num,SCM_ROUND_TRUNC));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_truncate_TOexact__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[30]),SCM_SUBR_IMMEDIATE_ARG, extlib_truncate_TOexact, NULL, NULL);

static ScmObj extlib_round_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  SCM_ENTER_SUBR("round->exact");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  {
{
ScmObj SCM_RESULT;

#line 196 "extlib.stub"
SCM_RESULT=(Scm_RoundToExact(num,SCM_ROUND_ROUND));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_round_TOexact__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[31]),SCM_SUBR_IMMEDIATE_ARG, extlib_round_TOexact, NULL, NULL);

static ScmObj extlib_decode_float(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  ScmObj num;
  SCM_ENTER_SUBR("decode-float");
  num_scm = SCM_ARGREF(0);
  num = (num_scm);
  {
{
ScmObj SCM_RESULT;

#line 199 "extlib.stub"
if (SCM_FLONUMP(num)){
{int exp;int sign;ScmObj f=
Scm_DecodeFlonum(SCM_FLONUM_VALUE(num),&(exp),&(sign));ScmObj v=
Scm_MakeVector(3,SCM_FALSE);
SCM_VECTOR_ELEMENT(v,0)=(f),
SCM_VECTOR_ELEMENT(v,1)=(Scm_MakeInteger(exp)),
SCM_VECTOR_ELEMENT(v,2)=(Scm_MakeInteger(sign));
SCM_RESULT=(v);}}else if(
SCM_INTP(num)){
{ScmObj v=Scm_MakeVector(3,SCM_FALSE);
SCM_VECTOR_ELEMENT(v,0)=(Scm_Abs(num)),
SCM_VECTOR_ELEMENT(v,1)=(Scm_MakeInteger(0)),
SCM_VECTOR_ELEMENT(v,2)=(Scm_MakeInteger(Scm_Sign(num)));
SCM_RESULT=(v);}} else {
SCM_TYPE_ERROR(num,"real number");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_decode_float__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[32]),extlib_decode_float, NULL, NULL);

static ScmObj extlib_native_endian(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("native-endian");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_NativeEndian());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_native_endian__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[33]),SCM_SUBR_IMMEDIATE_ARG, extlib_native_endian, NULL, NULL);

#if SCM_DEBUG_HELPER
static ScmObj extlib__25bignum_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("%bignum-dump");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {

#line 221 "extlib.stub"
if (SCM_BIGNUMP(obj)){{
Scm_DumpBignum(SCM_BIGNUM(obj),SCM_CUROUT);}}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib__25bignum_dump__STUB, 1, 0,SCM_OBJ(&scm__sc.d1015[0]),extlib__25bignum_dump, NULL, NULL);

#endif /* SCM_DEBUG_HELPER */
static ScmObj extlib_min_26max(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("min&max");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 225 "extlib.stub"
Scm_MinMax(arg0,args,&(SCM_RESULT0),&(SCM_RESULT1));
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_min_26max__STUB, 1, 1,SCM_OBJ(&scm__sc.d1003[34]),extlib_min_26max, NULL, NULL);

static ScmObj extlib_quotient_26remainder(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n1_scm;
  ScmObj n1;
  ScmObj n2_scm;
  ScmObj n2;
  SCM_ENTER_SUBR("quotient&remainder");
  n1_scm = SCM_ARGREF(0);
  n1 = (n1_scm);
  n2_scm = SCM_ARGREF(1);
  n2 = (n2_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 228 "extlib.stub"
SCM_RESULT0=(Scm_Quotient(n1,n2,&(SCM_RESULT1)));
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_quotient_26remainder__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[35]),extlib_quotient_26remainder, NULL, NULL);

static ScmObj extlib_boolean(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("boolean");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 236 "extlib.stub"
SCM_RESULT=(!(SCM_FALSEP(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_boolean__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[36]),0, extlib_boolean, NULL, NULL);

static ScmObj extlib_proper_listP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("proper-list?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_PROPER_LIST_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_proper_listP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[37]),0, extlib_proper_listP, NULL, NULL);

static ScmObj extlib_dotted_listP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("dotted-list?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_DOTTED_LIST_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_dotted_listP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[38]),0, extlib_dotted_listP, NULL, NULL);

static ScmObj extlib_circular_listP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("circular-list?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_CIRCULAR_LIST_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_circular_listP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[39]),0, extlib_circular_listP, NULL, NULL);

static ScmObj extlib_make_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj len_scm;
  int len;
  ScmObj fill_scm;
  ScmObj fill;
  SCM_ENTER_SUBR("make-list");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  len_scm = SCM_ARGREF(0);
  if (!SCM_INTP(len_scm)) Scm_Error("small integer required, but got %S", len_scm);
  len = SCM_INT_VALUE(len_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_ARGREF(1);
  } else {
    fill_scm = SCM_FALSE;
  }
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeList(len,fill));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_make_list__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[40]),extlib_make_list, NULL, NULL);

static ScmObj extlib_acons(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj caa_scm;
  ScmObj caa;
  ScmObj cda_scm;
  ScmObj cda;
  ScmObj cd_scm;
  ScmObj cd;
  SCM_ENTER_SUBR("acons");
  caa_scm = SCM_ARGREF(0);
  caa = (caa_scm);
  cda_scm = SCM_ARGREF(1);
  cda = (cda_scm);
  cd_scm = SCM_ARGREF(2);
  cd = (cd_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Acons(caa,cda,cd));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_acons__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[41]),extlib_acons, NULL, NULL);

static ScmObj extlib_last_pair(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("last-pair");
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_LastPair(list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_last_pair__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[42]),0, extlib_last_pair, NULL, NULL);

static ScmObj extlib_list_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("list-copy");
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CopyList(list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_list_copy__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[43]),extlib_list_copy, NULL, NULL);

static ScmObj extlib_list_2a(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("list*");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cp;
#line 252 "extlib.stub"
{ScmObj head=SCM_NIL;ScmObj tail=SCM_NIL;
if (SCM_PAIRP(args)){{
SCM_FOR_EACH(cp,args){
if (!(SCM_PAIRP(SCM_CDR(cp)))){{
if (SCM_NULLP(head)){
head=(SCM_CAR(cp));} else {
SCM_SET_CDR(tail,SCM_CAR(cp));}
break;}}
SCM_APPEND1(head,tail,SCM_CAR(cp));}}}
SCM_RESULT=(head);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_list_2a__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[44]),SCM_SUBR_IMMEDIATE_ARG, extlib_list_2a, SCM_MAKE_INT(SCM_VM_LIST_STAR), NULL);

static ScmObj extlib__25delete(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%delete");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 2+1) {
    cmpmode_scm = SCM_ARGREF(2);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 264 "extlib.stub"
SCM_RESULT=(Scm_Delete(obj,list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25delete__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[45]),extlib__25delete, NULL, NULL);

static ScmObj extlib__25deleteX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%delete!");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 2+1) {
    cmpmode_scm = SCM_ARGREF(2);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 266 "extlib.stub"
SCM_RESULT=(Scm_DeleteX(obj,list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25deleteX__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[46]),extlib__25deleteX, NULL, NULL);

static ScmObj extlib__25delete_duplicates(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%delete-duplicates");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  list_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 1+1) {
    cmpmode_scm = SCM_ARGREF(1);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 268 "extlib.stub"
SCM_RESULT=(Scm_DeleteDuplicates(list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25delete_duplicates__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[47]),extlib__25delete_duplicates, NULL, NULL);

static ScmObj extlib__25delete_duplicatesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%delete-duplicates!");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  list_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 1+1) {
    cmpmode_scm = SCM_ARGREF(1);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 270 "extlib.stub"
SCM_RESULT=(Scm_DeleteDuplicatesX(list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25delete_duplicatesX__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[48]),extlib__25delete_duplicatesX, NULL, NULL);

static ScmObj extlib__25alist_delete(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj elt_scm;
  ScmObj elt;
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%alist-delete");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  elt_scm = SCM_ARGREF(0);
  elt = (elt_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 2+1) {
    cmpmode_scm = SCM_ARGREF(2);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 272 "extlib.stub"
SCM_RESULT=(Scm_AssocDelete(elt,list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25alist_delete__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[49]),extlib__25alist_delete, NULL, NULL);

static ScmObj extlib__25alist_deleteX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj elt_scm;
  ScmObj elt;
  ScmObj list_scm;
  ScmObj list;
  ScmObj cmpmode_scm;
  ScmObj cmpmode;
  SCM_ENTER_SUBR("%alist-delete!");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  elt_scm = SCM_ARGREF(0);
  elt = (elt_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 2+1) {
    cmpmode_scm = SCM_ARGREF(2);
  } else {
    cmpmode_scm = SCM_UNBOUND;
  }
  cmpmode = (cmpmode_scm);
  {
{
ScmObj SCM_RESULT;

#line 274 "extlib.stub"
SCM_RESULT=(Scm_AssocDeleteX(elt,list,getcmpmode(cmpmode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25alist_deleteX__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[50]),extlib__25alist_deleteX, NULL, NULL);

static ScmObj extlib_appendX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("append!");
  list_scm = SCM_ARGREF(SCM_ARGCNT-1);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cp;
#line 277 "extlib.stub"
{ScmObj h=SCM_NIL;ScmObj t=SCM_NIL;
SCM_FOR_EACH(cp,list){
#line 280 "extlib.stub"
if ((!(SCM_PAIRP(SCM_CAR(cp))))&&(
SCM_NULLP(SCM_CDR(cp)))){{
if (SCM_NULLP(h)){
h=(SCM_CAR(cp));} else {
SCM_SET_CDR(t,SCM_CAR(cp));}
break;}}
SCM_APPEND(h,t,SCM_CAR(cp));}
SCM_RESULT=(h);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_appendX__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[51]),SCM_SUBR_IMMEDIATE_ARG, extlib_appendX, NULL, NULL);

static ScmObj extlib_reverseX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj tail_scm;
  ScmObj tail;
  SCM_ENTER_SUBR("reverse!");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  if (SCM_ARGCNT > 1+1) {
    tail_scm = SCM_ARGREF(1);
  } else {
    tail_scm = SCM_NIL;
  }
  tail = (tail_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Reverse2X(list,tail));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_reverseX__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[52]),extlib_reverseX, NULL, NULL);

static ScmObj extlib__25sort(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj seq_scm;
  ScmObj seq;
  SCM_ENTER_SUBR("%sort");
  seq_scm = SCM_ARGREF(0);
  seq = (seq_scm);
  {
{
ScmObj SCM_RESULT;

#line 294 "extlib.stub"
if (SCM_VECTORP(seq)){
{ScmObj r=Scm_VectorCopy(SCM_VECTOR(seq),0,-1,SCM_UNDEFINED);
Scm_SortArray(SCM_VECTOR_ELEMENTS(r),SCM_VECTOR_SIZE(r),SCM_FALSE);
SCM_RESULT=(r);}}else if(
(Scm_Length(seq))>=(0)){SCM_RESULT=(Scm_SortList(seq,SCM_FALSE));} else {
SCM_TYPE_ERROR(seq,"proper list or vector");
SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25sort__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[53]),extlib__25sort, NULL, NULL);

static ScmObj extlib__25sortX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj seq_scm;
  ScmObj seq;
  SCM_ENTER_SUBR("%sort!");
  seq_scm = SCM_ARGREF(0);
  seq = (seq_scm);
  {
{
ScmObj SCM_RESULT;

#line 303 "extlib.stub"
if (SCM_VECTORP(seq)){
Scm_SortArray(SCM_VECTOR_ELEMENTS(seq),SCM_VECTOR_SIZE(seq),SCM_FALSE);
SCM_RESULT=(seq);}else if(
(Scm_Length(seq))>=(0)){SCM_RESULT=(Scm_SortListX(seq,SCM_FALSE));} else {
SCM_TYPE_ERROR(seq,"proper list or vector");
SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25sortX__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[54]),extlib__25sortX, NULL, NULL);

static ScmObj extlib_monotonic_merge(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sequences_scm;
  ScmObj sequences;
  SCM_ENTER_SUBR("monotonic-merge");
  sequences_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(sequences_scm)) Scm_Error("list required, but got %S", sequences_scm);
  sequences = (sequences_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MonotonicMerge1(sequences));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_monotonic_merge__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[55]),SCM_SUBR_IMMEDIATE_ARG, extlib_monotonic_merge, NULL, NULL);

static ScmObj extlib_gensym(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj prefix_scm;
  ScmString* prefix;
  SCM_ENTER_SUBR("gensym");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    prefix_scm = SCM_ARGREF(0);
  } else {
    prefix_scm = SCM_FALSE;
  }
  if (!SCM_MAYBE_P(SCM_STRINGP, prefix_scm)) Scm_Error("string or #f required, but got %S", prefix_scm);
  prefix = SCM_MAYBE(SCM_STRING, prefix_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Gensym(prefix));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gensym__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[56]),SCM_SUBR_IMMEDIATE_ARG, extlib_gensym, NULL, NULL);

static ScmObj extlib_symbol_internedP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s_scm;
  ScmSymbol* s;
  SCM_ENTER_SUBR("symbol-interned?");
  s_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(s_scm)) Scm_Error("symbol required, but got %S", s_scm);
  s = SCM_SYMBOL(s_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_SYMBOL_INTERNED(s));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_symbol_internedP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[57]),SCM_SUBR_IMMEDIATE_ARG, extlib_symbol_internedP, NULL, NULL);

static ScmObj extlib_string_TOuninterned_symbol(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmString* name;
  SCM_ENTER_SUBR("string->uninterned-symbol");
  name_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(name_scm)) Scm_Error("string required, but got %S", name_scm);
  name = SCM_STRING(name_scm);
  {
{
ScmObj SCM_RESULT;

#line 319 "extlib.stub"
SCM_RESULT=(Scm_MakeSymbol(name,FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_TOuninterned_symbol__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[58]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_TOuninterned_symbol, NULL, NULL);

static ScmObj extlib_symbol_sans_prefix(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s_scm;
  ScmSymbol* s;
  ScmObj p_scm;
  ScmSymbol* p;
  SCM_ENTER_SUBR("symbol-sans-prefix");
  s_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(s_scm)) Scm_Error("symbol required, but got %S", s_scm);
  s = SCM_SYMBOL(s_scm);
  p_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(p_scm)) Scm_Error("symbol required, but got %S", p_scm);
  p = SCM_SYMBOL(p_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_SymbolSansPrefix(s,p));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_symbol_sans_prefix__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[59]),SCM_SUBR_IMMEDIATE_ARG, extlib_symbol_sans_prefix, NULL, NULL);

static ScmObj extlib_keywordP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("keyword?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_KEYWORDP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_keywordP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[60]),SCM_SUBR_IMMEDIATE_ARG, extlib_keywordP, NULL, NULL);

static ScmObj extlib_make_keyword(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmObj name;
  SCM_ENTER_SUBR("make-keyword");
  name_scm = SCM_ARGREF(0);
  name = (name_scm);
  {
{
ScmObj SCM_RESULT;

#line 325 "extlib.stub"
{ScmString* sname=NULL;
if (SCM_STRINGP(name)){sname=(SCM_STRING(name));}else if(
SCM_SYMBOLP(name)){sname=(SCM_SYMBOL_NAME(name));} else {
SCM_TYPE_ERROR(name,"string or symbol");}
SCM_RESULT=(Scm_MakeKeyword(sname));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_make_keyword__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[61]),extlib_make_keyword, NULL, NULL);

static ScmObj extlib_get_keyword(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj key_scm;
  ScmObj key;
  ScmObj list_scm;
  ScmObj list;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("get-keyword");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  key_scm = SCM_ARGREF(0);
  key = (key_scm);
  list_scm = SCM_ARGREF(1);
  list = (list_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_GetKeyword(key,list,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_get_keyword__STUB, 2, 2,1, SCM_OBJ(&scm__sc.d1003[62]),0, extlib_get_keyword, NULL, NULL);

static ScmObj extlib_delete_keyword(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj key_scm;
  ScmObj key;
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("delete-keyword");
  key_scm = SCM_ARGREF(0);
  key = (key_scm);
  list_scm = SCM_ARGREF(1);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_DeleteKeyword(key,list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_delete_keyword__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[63]),extlib_delete_keyword, NULL, NULL);

static ScmObj extlib_delete_keywordX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj key_scm;
  ScmObj key;
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("delete-keyword!");
  key_scm = SCM_ARGREF(0);
  key = (key_scm);
  list_scm = SCM_ARGREF(1);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_DeleteKeywordX(key,list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_delete_keywordX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[64]),extlib_delete_keywordX, NULL, NULL);

static ScmObj extlib_keyword_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj key_scm;
  ScmKeyword* key;
  SCM_ENTER_SUBR("keyword->string");
  key_scm = SCM_ARGREF(0);
  if (!SCM_KEYWORDP(key_scm)) Scm_Error("keyword required, but got %S", key_scm);
  key = SCM_KEYWORD(key_scm);
  {
{
ScmObj SCM_RESULT;

#line 338 "extlib.stub"
SCM_RESULT=(SCM_OBJ(SCM_KEYWORD_NAME(key)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_keyword_TOstring__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[65]),SCM_SUBR_IMMEDIATE_ARG, extlib_keyword_TOstring, NULL, NULL);

static ScmObj extlib_identifierP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("identifier?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_IDENTIFIERP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_identifierP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[66]),0, extlib_identifierP, SCM_MAKE_INT(SCM_VM_IDENTIFIERP), NULL);

static ScmObj extlib_identifier_TOsymbol(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmIdentifier* obj;
  SCM_ENTER_SUBR("identifier->symbol");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_IDENTIFIERP(obj_scm)) Scm_Error("identifier required, but got %S", obj_scm);
  obj = SCM_IDENTIFIER(obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 345 "extlib.stub"
SCM_RESULT=(SCM_OBJ((SCM_IDENTIFIER(obj))->name));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_identifier_TOsymbol__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[67]),SCM_SUBR_IMMEDIATE_ARG, extlib_identifier_TOsymbol, NULL, NULL);

static ScmObj extlib_digit_TOinteger(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ch_scm;
  ScmChar ch;
  ScmObj radix_scm;
  int radix;
  SCM_ENTER_SUBR("digit->integer");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  ch_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(ch_scm)) Scm_Error("character required, but got %S", ch_scm);
  ch = SCM_CHAR_VALUE(ch_scm);
  if (SCM_ARGCNT > 1+1) {
    radix_scm = SCM_ARGREF(1);
  } else {
    radix_scm = SCM_MAKE_INT(10U);
  }
  if (!SCM_INTP(radix_scm)) Scm_Error("small integer required, but got %S", radix_scm);
  radix = SCM_INT_VALUE(radix_scm);
  {
{
ScmObj SCM_RESULT;

#line 353 "extlib.stub"
{int r;
if (((radix)<(2))||((radix)>(36))){{
Scm_Error("radix must be between 2 and 36, but got %d",radix);}}
r=(Scm_DigitToInt(ch,radix));
SCM_RESULT=((((r)>=(0))?(SCM_MAKE_INT(r)):(SCM_FALSE)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_digit_TOinteger__STUB, 1, 2,1, SCM_OBJ(&scm__sc.d1003[68]),SCM_SUBR_IMMEDIATE_ARG, extlib_digit_TOinteger, NULL, NULL);

static ScmObj extlib_integer_TOdigit(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  int n;
  ScmObj radix_scm;
  int radix;
  SCM_ENTER_SUBR("integer->digit");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  n_scm = SCM_ARGREF(0);
  if (!SCM_INTP(n_scm)) Scm_Error("small integer required, but got %S", n_scm);
  n = SCM_INT_VALUE(n_scm);
  if (SCM_ARGCNT > 1+1) {
    radix_scm = SCM_ARGREF(1);
  } else {
    radix_scm = SCM_MAKE_INT(10U);
  }
  if (!SCM_INTP(radix_scm)) Scm_Error("small integer required, but got %S", radix_scm);
  radix = SCM_INT_VALUE(radix_scm);
  {
{
ScmObj SCM_RESULT;

#line 361 "extlib.stub"
{ScmChar r;
if (((radix)<(2))||((radix)>(36))){{
Scm_Error("radix must be between 2 and 36, but got %d",radix);}}
r=(Scm_IntToDigit(n,radix));
SCM_RESULT=((((r)==(SCM_CHAR_INVALID))?(SCM_FALSE):(SCM_MAKE_CHAR(r))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_integer_TOdigit__STUB, 1, 2,1, SCM_OBJ(&scm__sc.d1003[69]),SCM_SUBR_IMMEDIATE_ARG, extlib_integer_TOdigit, NULL, NULL);

static ScmObj extlib_ucs_TOchar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  int n;
  SCM_ENTER_SUBR("ucs->char");
  n_scm = SCM_ARGREF(0);
  if (!SCM_INTEGERP(n_scm)) Scm_Error("C integer required, but got %S", n_scm);
  n = Scm_GetInteger(n_scm);
  {
{
ScmObj SCM_RESULT;

#line 368 "extlib.stub"
{ScmChar ch=Scm_UcsToChar(n);
SCM_RESULT=((((ch)==(SCM_CHAR_INVALID))?(SCM_FALSE):(SCM_MAKE_CHAR(ch))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_ucs_TOchar__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[70]),SCM_SUBR_IMMEDIATE_ARG, extlib_ucs_TOchar, NULL, NULL);

static ScmObj extlib_char_TOucs(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("char->ucs");
  c_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
ScmObj SCM_RESULT;

#line 372 "extlib.stub"
{int ucs=Scm_CharToUcs(c);
SCM_RESULT=((((ucs)<(0))?(SCM_FALSE):(Scm_MakeInteger(ucs))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_TOucs__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[71]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_TOucs, NULL, NULL);

static ScmObj extlib_gauche_character_encoding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-character-encoding");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CharEncodingName());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_character_encoding__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[72]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_character_encoding, NULL, NULL);

static ScmObj extlib_supported_character_encodings(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("supported-character-encodings");
  {
{
ScmObj SCM_RESULT;

#line 378 "extlib.stub"
SCM_RESULT=(Scm_CStringArrayToList(Scm_SupportedCharacterEncodings(),-1,0));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_supported_character_encodings__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[73]),SCM_SUBR_IMMEDIATE_ARG, extlib_supported_character_encodings, NULL, NULL);

static ScmObj extlib_supported_character_encodingP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj encoding_scm;
  const char * encoding;
  SCM_ENTER_SUBR("supported-character-encoding?");
  encoding_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(encoding_scm)) Scm_Error("const C string required, but got %S", encoding_scm);
  encoding = SCM_STRING_CONST_CSTRING(encoding_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_SupportedCharacterEncodingP(encoding));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_supported_character_encodingP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[74]),SCM_SUBR_IMMEDIATE_ARG, extlib_supported_character_encodingP, NULL, NULL);

static ScmObj extlib_char_title_caseP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("char-title-case?");
  c_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_CharTitlecaseP(c));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_title_caseP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[75]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_title_caseP, NULL, NULL);

static ScmObj extlib_char_titlecase(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("char-titlecase");
  c_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
ScmChar SCM_RESULT;
SCM_RESULT=(Scm_CharTitlecase(c));
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_titlecase__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[76]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_titlecase, NULL, NULL);

static ScmObj extlib_char_foldcase(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("char-foldcase");
  c_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
ScmChar SCM_RESULT;
SCM_RESULT=(Scm_CharFoldcase(c));
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_foldcase__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[77]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_foldcase, NULL, NULL);

static ScmObj extlib_char_general_category(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("char-general-category");
  c_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
ScmObj SCM_RESULT;

#line 389 "extlib.stub"
switch (Scm_CharGeneralCategory(c)) {
case SCM_CHAR_CATEGORY_Lu : {SCM_RESULT=(scm__rc.d1004[5]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 391 "extlib.stub"
case SCM_CHAR_CATEGORY_Ll : {SCM_RESULT=(scm__rc.d1004[6]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 392 "extlib.stub"
case SCM_CHAR_CATEGORY_Lt : {SCM_RESULT=(scm__rc.d1004[7]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 393 "extlib.stub"
case SCM_CHAR_CATEGORY_Lm : {SCM_RESULT=(scm__rc.d1004[8]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 394 "extlib.stub"
case SCM_CHAR_CATEGORY_Lo : {SCM_RESULT=(scm__rc.d1004[9]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 395 "extlib.stub"
case SCM_CHAR_CATEGORY_Mn : {SCM_RESULT=(scm__rc.d1004[10]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 396 "extlib.stub"
case SCM_CHAR_CATEGORY_Mc : {SCM_RESULT=(scm__rc.d1004[11]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 397 "extlib.stub"
case SCM_CHAR_CATEGORY_Me : {SCM_RESULT=(scm__rc.d1004[12]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 398 "extlib.stub"
case SCM_CHAR_CATEGORY_Nd : {SCM_RESULT=(scm__rc.d1004[13]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 399 "extlib.stub"
case SCM_CHAR_CATEGORY_Nl : {SCM_RESULT=(scm__rc.d1004[14]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 400 "extlib.stub"
case SCM_CHAR_CATEGORY_No : {SCM_RESULT=(scm__rc.d1004[15]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 401 "extlib.stub"
case SCM_CHAR_CATEGORY_Pc : {SCM_RESULT=(scm__rc.d1004[16]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 402 "extlib.stub"
case SCM_CHAR_CATEGORY_Pd : {SCM_RESULT=(scm__rc.d1004[17]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 403 "extlib.stub"
case SCM_CHAR_CATEGORY_Ps : {SCM_RESULT=(scm__rc.d1004[18]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 404 "extlib.stub"
case SCM_CHAR_CATEGORY_Pe : {SCM_RESULT=(scm__rc.d1004[19]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 405 "extlib.stub"
case SCM_CHAR_CATEGORY_Pi : {SCM_RESULT=(scm__rc.d1004[20]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 406 "extlib.stub"
case SCM_CHAR_CATEGORY_Pf : {SCM_RESULT=(scm__rc.d1004[21]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 407 "extlib.stub"
case SCM_CHAR_CATEGORY_Po : {SCM_RESULT=(scm__rc.d1004[22]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 408 "extlib.stub"
case SCM_CHAR_CATEGORY_Sm : {SCM_RESULT=(scm__rc.d1004[23]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 409 "extlib.stub"
case SCM_CHAR_CATEGORY_Sc : {SCM_RESULT=(scm__rc.d1004[24]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 410 "extlib.stub"
case SCM_CHAR_CATEGORY_Sk : {SCM_RESULT=(scm__rc.d1004[25]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 411 "extlib.stub"
case SCM_CHAR_CATEGORY_So : {SCM_RESULT=(scm__rc.d1004[26]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 412 "extlib.stub"
case SCM_CHAR_CATEGORY_Zs : {SCM_RESULT=(scm__rc.d1004[27]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 413 "extlib.stub"
case SCM_CHAR_CATEGORY_Zl : {SCM_RESULT=(scm__rc.d1004[28]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 414 "extlib.stub"
case SCM_CHAR_CATEGORY_Zp : {SCM_RESULT=(scm__rc.d1004[29]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 415 "extlib.stub"
case SCM_CHAR_CATEGORY_Cc : {SCM_RESULT=(scm__rc.d1004[30]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 416 "extlib.stub"
case SCM_CHAR_CATEGORY_Cf : {SCM_RESULT=(scm__rc.d1004[31]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 417 "extlib.stub"
case SCM_CHAR_CATEGORY_Cs : {SCM_RESULT=(scm__rc.d1004[32]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 418 "extlib.stub"
case SCM_CHAR_CATEGORY_Co : {SCM_RESULT=(scm__rc.d1004[33]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 419 "extlib.stub"
case SCM_CHAR_CATEGORY_Cn : {SCM_RESULT=(scm__rc.d1004[34]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_general_category__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[78]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_general_category, NULL, NULL);

static ScmObj extlib_char_setP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("char-set?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_CHARSETP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_setP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[110]),0, extlib_char_setP, NULL, NULL);

static void char_set_add(ScmCharSet* cs,ScmObj chars){ScmObj cise__1016;{
#line 430 "extlib.stub"
SCM_FOR_EACH(cise__1016,chars) {{ScmObj ch=SCM_CAR(cise__1016);
if (!(SCM_CHARP(ch))){{Scm_Error("character required, but got %S",ch);}}
Scm_CharSetAddRange(cs,SCM_CHAR_VALUE(ch),SCM_CHAR_VALUE(ch));}}}}
static ScmObj extlib__25char_set_equalP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmCharSet* x;
  ScmObj y_scm;
  ScmCharSet* y;
  SCM_ENTER_SUBR("%char-set-equal?");
  x_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(x_scm)) Scm_Error("char-set required, but got %S", x_scm);
  x = SCM_CHARSET(x_scm);
  y_scm = SCM_ARGREF(1);
  if (!SCM_CHARSETP(y_scm)) Scm_Error("char-set required, but got %S", y_scm);
  y = SCM_CHARSET(y_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_CharSetEq(x,y));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_equalP__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[111]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_equalP, NULL, NULL);

static ScmObj extlib__25char_set_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmCharSet* x;
  ScmObj y_scm;
  ScmCharSet* y;
  SCM_ENTER_SUBR("%char-set<=?");
  x_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(x_scm)) Scm_Error("char-set required, but got %S", x_scm);
  x = SCM_CHARSET(x_scm);
  y_scm = SCM_ARGREF(1);
  if (!SCM_CHARSETP(y_scm)) Scm_Error("char-set required, but got %S", y_scm);
  y = SCM_CHARSET(y_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_CharSetLE(x,y));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_LT_3dP__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[112]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_LT_3dP, NULL, NULL);

static ScmObj extlib_char_set(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-set");
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
ScmCharSet* SCM_RESULT;

#line 441 "extlib.stub"
{ScmCharSet* cs=SCM_CHARSET(Scm_MakeEmptyCharSet());
char_set_add(cs,chars);
SCM_RESULT=(cs);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_set__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[113]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_set, NULL, NULL);

static ScmObj extlib_char_set_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  SCM_ENTER_SUBR("char-set-copy");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CharSetCopy(cs));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_set_copy__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[114]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_set_copy, NULL, NULL);

static ScmObj extlib_read_char_set(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj error_scm = SCM_TRUE;
  int error;
  ScmObj posix_bracket_scm = SCM_TRUE;
  int posix_bracket;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("read-char-set");
  port_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[36])) {
      error_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[37])) {
      posix_bracket_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if (!SCM_BOOLP(error_scm)) Scm_Error("boolean required, but got %S", error_scm);
  error = SCM_BOOL_VALUE(error_scm);
  if (!SCM_BOOLP(posix_bracket_scm)) Scm_Error("boolean required, but got %S", posix_bracket_scm);
  posix_bracket = SCM_BOOL_VALUE(posix_bracket_scm);
  {
{
ScmObj SCM_RESULT;

#line 449 "extlib.stub"
SCM_RESULT=(Scm_CharSetRead(port,NULL,error,posix_bracket));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_read_char_set__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[117]),SCM_SUBR_IMMEDIATE_ARG, extlib_read_char_set, NULL, NULL);

static ScmObj extlib__25char_set_add_charsX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("%char-set-add-chars!");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  chars_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(chars_scm)) Scm_Error("list required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
ScmCharSet* SCM_RESULT;

#line 452 "extlib.stub"
char_set_add(cs,chars);

#line 452 "extlib.stub"
SCM_RESULT=(cs);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_add_charsX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[118]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_add_charsX, NULL, NULL);

static ScmObj extlib__25char_set_add_rangeX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj from_scm;
  ScmObj from;
  ScmObj to_scm;
  ScmObj to;
  SCM_ENTER_SUBR("%char-set-add-range!");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  from_scm = SCM_ARGREF(1);
  from = (from_scm);
  to_scm = SCM_ARGREF(2);
  to = (to_scm);
  {
{
ScmObj SCM_RESULT;

#line 455 "extlib.stub"
{long f=-1;long t=-1;
if (SCM_INTP(from)){f=(SCM_INT_VALUE(from));}else if(
SCM_CHARP(from)){f=(SCM_CHAR_VALUE(from));}
if ((f)<(0)){{SCM_TYPE_ERROR(from,"character or positive exact integer");}}
if ((f)>(SCM_CHAR_MAX)){{
Scm_Error("'from' argument out of range: %S",from);}}
if (SCM_INTP(to)){t=(SCM_INT_VALUE(to));}else if(
SCM_CHARP(to)){t=(SCM_CHAR_VALUE(to));}
if ((t)<(0)){{SCM_TYPE_ERROR(to,"character or positive exact integer");}}
if ((t)>(SCM_CHAR_MAX)){{
Scm_Error("'to' argument out of range: %S",to);}}
SCM_RESULT=(Scm_CharSetAddRange(cs,((ScmChar )(f)),((ScmChar )(t))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25char_set_add_rangeX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[119]),extlib__25char_set_add_rangeX, NULL, NULL);

static ScmObj extlib_char_set_containsP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj ch_scm;
  ScmChar ch;
  SCM_ENTER_SUBR("char-set-contains?");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  ch_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(ch_scm)) Scm_Error("character required, but got %S", ch_scm);
  ch = SCM_CHAR_VALUE(ch_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_CharSetContains(cs,ch));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_char_set_containsP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[120]),SCM_SUBR_IMMEDIATE_ARG, extlib_char_set_containsP, NULL, NULL);

static ScmObj extlib__25char_set_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj dst_scm;
  ScmCharSet* dst;
  ScmObj src_scm;
  ScmCharSet* src;
  SCM_ENTER_SUBR("%char-set-add!");
  dst_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(dst_scm)) Scm_Error("char-set required, but got %S", dst_scm);
  dst = SCM_CHARSET(dst_scm);
  src_scm = SCM_ARGREF(1);
  if (!SCM_CHARSETP(src_scm)) Scm_Error("char-set required, but got %S", src_scm);
  src = SCM_CHARSET(src_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CharSetAdd(dst,src));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_addX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[121]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_addX, NULL, NULL);

static ScmObj extlib__25char_set_complementX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  SCM_ENTER_SUBR("%char-set-complement!");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CharSetComplement(cs));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_complementX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[122]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_complementX, NULL, NULL);

static ScmObj extlib__25char_set_ranges(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  SCM_ENTER_SUBR("%char-set-ranges");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CharSetRanges(cs));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_ranges__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[123]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_ranges, NULL, NULL);

static ScmObj extlib__25char_set_predefined(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj num_scm;
  int num;
  SCM_ENTER_SUBR("%char-set-predefined");
  num_scm = SCM_ARGREF(0);
  if (!SCM_INTP(num_scm)) Scm_Error("small integer required, but got %S", num_scm);
  num = SCM_INT_VALUE(num_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_GetStandardCharSet(num));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_predefined__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[124]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_predefined, NULL, NULL);

#if SCM_DEBUG_HELPER
static ScmObj extlib__25char_set_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  SCM_ENTER_SUBR("%char-set-dump");
  cs_scm = SCM_ARGREF(0);
  if (!SCM_CHARSETP(cs_scm)) Scm_Error("char-set required, but got %S", cs_scm);
  cs = SCM_CHARSET(cs_scm);
  {

#line 479 "extlib.stub"
Scm_CharSetDump(cs,SCM_CUROUT);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25char_set_dump__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1015[1]),SCM_SUBR_IMMEDIATE_ARG, extlib__25char_set_dump, NULL, NULL);

#endif /* SCM_DEBUG_HELPER */
static ScmObj extlib_string_incompleteP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("string-incomplete?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 487 "extlib.stub"
SCM_RESULT=((SCM_STRINGP(obj))&&(SCM_STRING_INCOMPLETE_P(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_incompleteP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[125]),extlib_string_incompleteP, NULL, NULL);

static ScmObj extlib_string_immutableP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("string-immutable?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 489 "extlib.stub"
SCM_RESULT=((SCM_STRINGP(obj))&&(SCM_STRING_IMMUTABLE_P(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_immutableP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[126]),extlib_string_immutableP, NULL, NULL);

static ScmObj extlib_string_incomplete_TOcompleteX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  SCM_ENTER_SUBR("string-incomplete->complete!");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  {
{
ScmObj SCM_RESULT;

#line 496 "extlib.stub"
{ScmObj s=Scm_StringIncompleteToComplete(str,SCM_ILLEGAL_CHAR_REJECT,
SCM_CHAR(0));
if (!(SCM_FALSEP(s))){{(str)->body=(SCM_STRING_BODY(s));}}
SCM_RESULT=(s);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_incomplete_TOcompleteX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[127]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_incomplete_TOcompleteX, NULL, NULL);

static ScmObj extlib_string_complete_TOincomplete(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  SCM_ENTER_SUBR("string-complete->incomplete");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringCompleteToIncomplete(str));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_complete_TOincomplete__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[128]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_complete_TOincomplete, NULL, NULL);

static ScmObj extlib_string_incomplete_TOcomplete(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj handling_scm;
  ScmObj handling;
  SCM_ENTER_SUBR("string-incomplete->complete");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (SCM_ARGCNT > 1+1) {
    handling_scm = SCM_ARGREF(1);
  } else {
    handling_scm = SCM_FALSE;
  }
  handling = (handling_scm);
  {
{
ScmObj SCM_RESULT;

#line 505 "extlib.stub"
{int h=0;ScmChar sub=SCM_CHAR(0);
if (SCM_EQ(handling,scm__rc.d1004[38])){h=(SCM_ILLEGAL_CHAR_OMIT);}else if(
SCM_FALSEP(handling)){h=(SCM_ILLEGAL_CHAR_REJECT);}else if(
SCM_CHARP(handling)){h=(SCM_ILLEGAL_CHAR_REPLACE),sub=(
SCM_CHAR_VALUE(handling));} else {
SCM_TYPE_ERROR(handling,":omit, #f, or a character");}
SCM_RESULT=(Scm_StringIncompleteToComplete(str,h,sub));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_incomplete_TOcomplete__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[129]),extlib_string_incomplete_TOcomplete, NULL, NULL);

static ScmObj extlib_string_size(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  SCM_ENTER_SUBR("string-size");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  {
{
int SCM_RESULT;

#line 514 "extlib.stub"
SCM_RESULT=(SCM_STRING_BODY_SIZE(SCM_STRING_BODY(str)));
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_size__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[131]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_size, NULL, NULL);

static ScmObj extlib_make_byte_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj size_scm;
  int size;
  ScmObj byte_scm;
  int byte;
  SCM_ENTER_SUBR("make-byte-string");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  size_scm = SCM_ARGREF(0);
  if (!SCM_INTP(size_scm)) Scm_Error("small integer required, but got %S", size_scm);
  size = SCM_INT_VALUE(size_scm);
  if (SCM_ARGCNT > 1+1) {
    byte_scm = SCM_ARGREF(1);
  } else {
    byte_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(byte_scm)) Scm_Error("small integer required, but got %S", byte_scm);
  byte = SCM_INT_VALUE(byte_scm);
  {
{
ScmObj SCM_RESULT;

#line 517 "extlib.stub"
{char* s;
if ((size)<(0)){{Scm_Error("size out of bound: %d",size);}}
s=(SCM_NEW_ATOMIC2(char*,size));
memset(s,byte,size);
SCM_RESULT=(Scm_MakeString(s,size,size,SCM_STRING_INCOMPLETE));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_make_byte_string__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[132]),SCM_SUBR_IMMEDIATE_ARG, extlib_make_byte_string, NULL, NULL);

static ScmObj extlib_string_byte_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj k_scm;
  int k;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("string-byte-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  k_scm = SCM_ARGREF(1);
  if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
  k = SCM_INT_VALUE(k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 524 "extlib.stub"
{int r=Scm_StringByteRef(str,k,SCM_UNBOUNDP(fallback));
SCM_RESULT=((((r)<(0))?(fallback):(SCM_MAKE_INT(r))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_byte_ref__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[133]),extlib_string_byte_ref, NULL, NULL);

static ScmObj extlib_byte_substring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj start_scm;
  int start;
  ScmObj end_scm;
  int end;
  SCM_ENTER_SUBR("byte-substring");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  start_scm = SCM_ARGREF(1);
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  end_scm = SCM_ARGREF(2);
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;

#line 528 "extlib.stub"
SCM_RESULT=(Scm_Substring(str,start,end,TRUE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_byte_substring__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[134]),SCM_SUBR_IMMEDIATE_ARG, extlib_byte_substring, NULL, NULL);

static ScmObj extlib__25string_replace_bodyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj target_scm;
  ScmString* target;
  ScmObj source_scm;
  ScmString* source;
  SCM_ENTER_SUBR("%string-replace-body!");
  target_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(target_scm)) Scm_Error("string required, but got %S", target_scm);
  target = SCM_STRING(target_scm);
  source_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(source_scm)) Scm_Error("string required, but got %S", source_scm);
  source = SCM_STRING(source_scm);
  {
{
ScmObj SCM_RESULT;

#line 531 "extlib.stub"
SCM_RESULT=(Scm_StringReplaceBody(target,SCM_STRING_BODY(source)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25string_replace_bodyX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[135]),SCM_SUBR_IMMEDIATE_ARG, extlib__25string_replace_bodyX, NULL, NULL);

static ScmObj extlib__25maybe_substring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj start_scm;
  ScmObj start;
  ScmObj end_scm;
  ScmObj end;
  SCM_ENTER_SUBR("%maybe-substring");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_ARGREF(1);
  } else {
    start_scm = SCM_UNBOUND;
  }
  start = (start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_ARGREF(2);
  } else {
    end_scm = SCM_UNBOUND;
  }
  end = (end_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MaybeSubstring(str,start,end));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25maybe_substring__STUB, 1, 3,SCM_OBJ(&scm__sc.d1003[136]),extlib__25maybe_substring, NULL, NULL);

static ScmObj extlib_string_join(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj strs_scm;
  ScmObj strs;
  ScmObj delim_scm;
  ScmString* delim;
  ScmObj grammar_scm;
  ScmObj grammar;
  SCM_ENTER_SUBR("string-join");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  strs_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(strs_scm)) Scm_Error("list required, but got %S", strs_scm);
  strs = (strs_scm);
  if (SCM_ARGCNT > 1+1) {
    delim_scm = SCM_ARGREF(1);
  } else {
    delim_scm = SCM_OBJ(&scm__sc.d1003[137]);
  }
  if (!SCM_STRINGP(delim_scm)) Scm_Error("string required, but got %S", delim_scm);
  delim = SCM_STRING(delim_scm);
  if (SCM_ARGCNT > 2+1) {
    grammar_scm = SCM_ARGREF(2);
  } else {
    grammar_scm = scm__rc.d1004[39];
  }
  grammar = (grammar_scm);
  {
{
ScmObj SCM_RESULT;

#line 538 "extlib.stub"
{int gm=0;
if (
SCM_EQ(grammar,scm__rc.d1004[39])){gm=(SCM_STRING_JOIN_INFIX);}else if(
SCM_EQ(grammar,scm__rc.d1004[42])){gm=(SCM_STRING_JOIN_STRICT_INFIX);}else if(
SCM_EQ(grammar,scm__rc.d1004[41])){gm=(SCM_STRING_JOIN_SUFFIX);}else if(
SCM_EQ(grammar,scm__rc.d1004[40])){gm=(SCM_STRING_JOIN_PREFIX);} else {
SCM_TYPE_ERROR(grammar,"one of the symbols infix, strict-infix, suffix, or prefix");}
#line 546 "extlib.stub"
SCM_RESULT=(Scm_StringJoin(strs,delim,gm));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_join__STUB, 1, 3,SCM_OBJ(&scm__sc.d1003[139]),extlib_string_join, NULL, NULL);

static ScmObj extlib__25hash_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj bound_scm;
  ScmObj bound;
  SCM_ENTER_SUBR("%hash-string");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  bound_scm = SCM_ARGREF(1);
  bound = (bound_scm);
  {
{
u_long SCM_RESULT;

#line 549 "extlib.stub"
{u_long modulo=0;
if (SCM_UNDEFINEDP(bound)){modulo=(SCM_SMALL_INT_MAX);}else if(
SCM_INTP(bound)){modulo=(SCM_INT_VALUE(bound));}else if(
SCM_BIGNUMP(bound)){
modulo=(
Scm_BignumToUI(SCM_BIGNUM(bound),SCM_CLAMP_BOTH,NULL));}
if ((modulo)==(0)){{Scm_Error("argument out of domain: %S",bound);}}
SCM_RESULT=(Scm_HashString(str,modulo));}
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25hash_string__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[143]),extlib__25hash_string, NULL, NULL);

static ScmObj extlib__25string_split_by_char(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj ch_scm;
  ScmChar ch;
  SCM_ENTER_SUBR("%string-split-by-char");
  s_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
  s = SCM_STRING(s_scm);
  ch_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(ch_scm)) Scm_Error("character required, but got %S", ch_scm);
  ch = SCM_CHAR_VALUE(ch_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringSplitByChar(s,ch));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25string_split_by_char__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[144]),SCM_SUBR_IMMEDIATE_ARG, extlib__25string_split_by_char, NULL, NULL);

static ScmObj extlib_string_scan(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmObj s2;
  ScmObj mode_scm;
  ScmObj mode;
  SCM_ENTER_SUBR("string-scan");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  s2 = (s2_scm);
  if (SCM_ARGCNT > 2+1) {
    mode_scm = SCM_ARGREF(2);
  } else {
    mode_scm = scm__rc.d1004[43];
  }
  mode = (mode_scm);
  {
{
ScmObj SCM_RESULT;

#line 564 "extlib.stub"
{int rmode=0;
if (
SCM_EQ(mode,scm__rc.d1004[43])){rmode=(SCM_STRING_SCAN_INDEX);}else if(
SCM_EQ(mode,scm__rc.d1004[48])){rmode=(SCM_STRING_SCAN_BEFORE);}else if(
SCM_EQ(mode,scm__rc.d1004[47])){rmode=(SCM_STRING_SCAN_AFTER);}else if(
SCM_EQ(mode,scm__rc.d1004[46])){rmode=(SCM_STRING_SCAN_BEFORE2);}else if(
SCM_EQ(mode,scm__rc.d1004[45])){rmode=(SCM_STRING_SCAN_AFTER2);}else if(
SCM_EQ(mode,scm__rc.d1004[44])){rmode=(SCM_STRING_SCAN_BOTH);} else {
Scm_Error("bad value in mode argumet: %S, must be one of 'index, 'before, 'after, 'before*, 'after* or 'both.",mode);}
#line 574 "extlib.stub"
if (
SCM_STRINGP(s2)){SCM_RESULT=(Scm_StringScan(s1,SCM_STRING(s2),rmode));}else if(
SCM_CHARP(s2)){
SCM_RESULT=(Scm_StringScanChar(s1,SCM_CHAR_VALUE(s2),rmode));} else {
Scm_Error("bad type of argument for s2: %S, must be either string or character",s2);
#line 580 "extlib.stub"
SCM_RESULT=(SCM_UNDEFINED);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_scan__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[146]),extlib_string_scan, NULL, NULL);

static ScmObj extlib_make_string_pointer(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj index_scm;
  int index;
  ScmObj start_scm;
  int start;
  ScmObj end_scm;
  int end;
  SCM_ENTER_SUBR("make-string-pointer");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (SCM_ARGCNT > 1+1) {
    index_scm = SCM_ARGREF(1);
  } else {
    index_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(index_scm)) Scm_Error("small integer required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  if (SCM_ARGCNT > 2+1) {
    start_scm = SCM_ARGREF(2);
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 3+1) {
    end_scm = SCM_ARGREF(3);
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeStringPointer(str,index,start,end));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_make_string_pointer__STUB, 1, 4,0, SCM_OBJ(&scm__sc.d1003[152]),SCM_SUBR_IMMEDIATE_ARG, extlib_make_string_pointer, NULL, NULL);

static ScmObj extlib_string_pointerP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("string-pointer?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_STRING_POINTERP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_string_pointerP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[153]),extlib_string_pointerP, NULL, NULL);

static ScmObj extlib_string_pointer_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-ref");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringPointerRef(sp));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_ref__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[154]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_ref, NULL, NULL);

static ScmObj extlib_string_pointer_nextX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-next!");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringPointerNext(sp));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_nextX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[155]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_nextX, NULL, NULL);

static ScmObj extlib_string_pointer_prevX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-prev!");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringPointerPrev(sp));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_prevX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[156]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_prevX, NULL, NULL);

static ScmObj extlib_string_pointer_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  ScmObj index_scm;
  int index;
  SCM_ENTER_SUBR("string-pointer-set!");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  index_scm = SCM_ARGREF(1);
  if (!SCM_INTP(index_scm)) Scm_Error("small integer required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringPointerSet(sp,index));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_setX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[157]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_setX, NULL, NULL);

static ScmObj extlib_string_pointer_substring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  ScmObj after_scm = SCM_FALSE;
  ScmObj after;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("string-pointer-substring");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[49])) {
      after_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  after = (after_scm);
  {
{
ScmObj SCM_RESULT;

#line 602 "extlib.stub"
SCM_RESULT=(Scm_StringPointerSubstring(sp,!(SCM_FALSEP(after))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_substring__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[158]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_substring, NULL, NULL);

static ScmObj extlib_string_pointer_index(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-index");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
int SCM_RESULT;

#line 604 "extlib.stub"
SCM_RESULT=((sp)->index);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_index__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[159]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_index, NULL, NULL);

static ScmObj extlib_string_pointer_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-copy");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringPointerCopy(sp));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_copy__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[160]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_copy, NULL, NULL);

static ScmObj extlib_string_pointer_byte_index(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("string-pointer-byte-index");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
{
int SCM_RESULT;

#line 608 "extlib.stub"
SCM_RESULT=(((int )(((sp)->current)-((sp)->start))));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_pointer_byte_index__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[161]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_pointer_byte_index, NULL, NULL);

#if SCM_DEBUG_HELPER
static ScmObj extlib__25string_pointer_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj sp_scm;
  ScmStringPointer* sp;
  SCM_ENTER_SUBR("%string-pointer-dump");
  sp_scm = SCM_ARGREF(0);
  if (!SCM_STRING_POINTERP(sp_scm)) Scm_Error("string pointer required, but got %S", sp_scm);
  sp = SCM_STRING_POINTER(sp_scm);
  {
Scm_StringPointerDump(sp);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25string_pointer_dump__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1015[2]),SCM_SUBR_IMMEDIATE_ARG, extlib__25string_pointer_dump, NULL, NULL);

#endif /* SCM_DEBUG_HELPER */
static ScmObj extlib_regexpP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("regexp?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_REGEXPP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_regexpP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[162]),0, extlib_regexpP, NULL, NULL);

static ScmObj extlib_regmatchP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("regmatch?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_REGMATCHP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_regmatchP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[163]),extlib_regmatchP, NULL, NULL);

static ScmObj extlib_string_TOregexp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj case_fold_scm = SCM_FALSE;
  ScmObj case_fold;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("string->regexp");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[50])) {
      case_fold_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  case_fold = (case_fold_scm);
  {
{
ScmObj SCM_RESULT;

#line 620 "extlib.stub"
{int flags=((SCM_BOOL_VALUE(case_fold))?(SCM_REGEXP_CASE_FOLD):(0));
SCM_RESULT=(Scm_RegComp(str,flags));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_string_TOregexp__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[165]),SCM_SUBR_IMMEDIATE_ARG, extlib_string_TOregexp, NULL, NULL);

static ScmObj extlib__25regexp_pattern_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj regexp_scm;
  ScmRegexp* regexp;
  ScmObj pat_scm;
  ScmString* pat;
  SCM_ENTER_SUBR("(setter %regexp-pattern)");
  regexp_scm = SCM_ARGREF(0);
  if (!SCM_REGEXPP(regexp_scm)) Scm_Error("regexp required, but got %S", regexp_scm);
  regexp = SCM_REGEXP(regexp_scm);
  pat_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(pat_scm)) Scm_Error("string required, but got %S", pat_scm);
  pat = SCM_STRING(pat_scm);
  {

#line 624 "extlib.stub"
(regexp)->pattern=(SCM_OBJ(pat));
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib__25regexp_pattern_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[167]),extlib__25regexp_pattern_SETTER, NULL, NULL);

static ScmObj extlib__25regexp_pattern(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj regexp_scm;
  ScmRegexp* regexp;
  SCM_ENTER_SUBR("%regexp-pattern");
  regexp_scm = SCM_ARGREF(0);
  if (!SCM_REGEXPP(regexp_scm)) Scm_Error("regexp required, but got %S", regexp_scm);
  regexp = SCM_REGEXP(regexp_scm);
  {
{
ScmObj SCM_RESULT;

#line 625 "extlib.stub"
SCM_RESULT=((regexp)->pattern);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25regexp_pattern__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[166]),SCM_SUBR_IMMEDIATE_ARG, extlib__25regexp_pattern, NULL, NULL);

static ScmObj extlib_regexp_ast(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj regexp_scm;
  ScmRegexp* regexp;
  SCM_ENTER_SUBR("regexp-ast");
  regexp_scm = SCM_ARGREF(0);
  if (!SCM_REGEXPP(regexp_scm)) Scm_Error("regexp required, but got %S", regexp_scm);
  regexp = SCM_REGEXP(regexp_scm);
  {
{
ScmObj SCM_RESULT;

#line 626 "extlib.stub"
SCM_RESULT=((regexp)->ast);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_regexp_ast__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[168]),SCM_SUBR_IMMEDIATE_ARG, extlib_regexp_ast, NULL, NULL);

static ScmObj extlib_regexp_case_foldP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj regexp_scm;
  ScmRegexp* regexp;
  SCM_ENTER_SUBR("regexp-case-fold?");
  regexp_scm = SCM_ARGREF(0);
  if (!SCM_REGEXPP(regexp_scm)) Scm_Error("regexp required, but got %S", regexp_scm);
  regexp = SCM_REGEXP(regexp_scm);
  {
{
int SCM_RESULT;

#line 628 "extlib.stub"
SCM_RESULT=(((regexp)->flags)&(SCM_REGEXP_CASE_FOLD));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_regexp_case_foldP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[169]),SCM_SUBR_IMMEDIATE_ARG, extlib_regexp_case_foldP, NULL, NULL);

static ScmObj extlib_regexp_parse(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj case_fold_scm = SCM_FALSE;
  ScmObj case_fold;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("regexp-parse");
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[50])) {
      case_fold_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  case_fold = (case_fold_scm);
  {
{
ScmObj SCM_RESULT;

#line 631 "extlib.stub"
{int flags=((SCM_BOOL_VALUE(case_fold))?(SCM_REGEXP_CASE_FOLD):(0));
SCM_RESULT=(Scm_RegComp(str,(flags)|(SCM_REGEXP_PARSE_ONLY)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_regexp_parse__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[170]),SCM_SUBR_IMMEDIATE_ARG, extlib_regexp_parse, NULL, NULL);

static ScmObj extlib_regexp_compile(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ast_scm;
  ScmObj ast;
  SCM_ENTER_SUBR("regexp-compile");
  ast_scm = SCM_ARGREF(0);
  ast = (ast_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_RegCompFromAST(ast));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_regexp_compile__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[171]),extlib_regexp_compile, NULL, NULL);

static ScmObj extlib_regexp_optimize(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ast_scm;
  ScmObj ast;
  SCM_ENTER_SUBR("regexp-optimize");
  ast_scm = SCM_ARGREF(0);
  ast = (ast_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_RegOptimizeAST(ast));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_regexp_optimize__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[172]),extlib_regexp_optimize, NULL, NULL);

static ScmObj extlib_rxmatch(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj regexp_scm;
  ScmObj regexp;
  ScmObj str_scm;
  ScmString* str;
  SCM_ENTER_SUBR("rxmatch");
  regexp_scm = SCM_ARGREF(0);
  regexp = (regexp_scm);
  str_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  {
{
ScmObj SCM_RESULT;

#line 637 "extlib.stub"
{ScmRegexp* rx=NULL;
if (SCM_STRINGP(regexp)){rx=(SCM_REGEXP(Scm_RegComp(
SCM_STRING(regexp),0)));}else if(
SCM_REGEXPP(regexp)){rx=(SCM_REGEXP(regexp));} else {
SCM_TYPE_ERROR(regexp,"regexp");}
SCM_RESULT=(Scm_RegExec(rx,str));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[173]),extlib_rxmatch, NULL, NULL);

static ScmObj extlib_rxmatch_substring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("rxmatch-substring");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  if (SCM_ARGCNT > 1+1) {
    obj_scm = SCM_ARGREF(1);
  } else {
    obj_scm = SCM_MAKE_INT(0);
  }
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 655 "extlib.stub"
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(Scm_RegMatchSubstr(SCM_REGMATCH(match),obj));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_substring__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[174]),extlib_rxmatch_substring, NULL, NULL);

static ScmObj extlib_rxmatch_start(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("rxmatch-start");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  if (SCM_ARGCNT > 1+1) {
    obj_scm = SCM_ARGREF(1);
  } else {
    obj_scm = SCM_MAKE_INT(0);
  }
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 657 "extlib.stub"
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(Scm_RegMatchStart(SCM_REGMATCH(match),obj));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_start__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[175]),extlib_rxmatch_start, NULL, NULL);

static ScmObj extlib_rxmatch_end(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("rxmatch-end");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  if (SCM_ARGCNT > 1+1) {
    obj_scm = SCM_ARGREF(1);
  } else {
    obj_scm = SCM_MAKE_INT(0);
  }
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 659 "extlib.stub"
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(Scm_RegMatchEnd(SCM_REGMATCH(match),obj));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_end__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[176]),extlib_rxmatch_end, NULL, NULL);

static ScmObj extlib_rxmatch_before(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("rxmatch-before");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  if (SCM_ARGCNT > 1+1) {
    obj_scm = SCM_ARGREF(1);
  } else {
    obj_scm = SCM_MAKE_INT(0);
  }
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 661 "extlib.stub"
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(Scm_RegMatchBefore(SCM_REGMATCH(match),obj));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_before__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[177]),extlib_rxmatch_before, NULL, NULL);

static ScmObj extlib_rxmatch_after(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("rxmatch-after");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  if (SCM_ARGCNT > 1+1) {
    obj_scm = SCM_ARGREF(1);
  } else {
    obj_scm = SCM_MAKE_INT(0);
  }
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 663 "extlib.stub"
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(Scm_RegMatchAfter(SCM_REGMATCH(match),obj));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_after__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[178]),extlib_rxmatch_after, NULL, NULL);

static ScmObj extlib_rxmatch_num_matches(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj match_scm;
  ScmObj match;
  SCM_ENTER_SUBR("rxmatch-num-matches");
  match_scm = SCM_ARGREF(0);
  match = (match_scm);
  {
{
ScmObj SCM_RESULT;

#line 665 "extlib.stub"
if (SCM_FALSEP(match)){
SCM_RESULT=(SCM_MAKE_INT(0));} else {
if (SCM_FALSEP(match)){SCM_RESULT=(SCM_FALSE);}else if(SCM_REGMATCHP(match)){SCM_RESULT=(SCM_MAKE_INT((SCM_REGMATCH(match))->numMatches));} else {SCM_TYPE_ERROR(match,"regmatch object or #f");SCM_RESULT=(SCM_UNDEFINED);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_rxmatch_num_matches__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[179]),extlib_rxmatch_num_matches, NULL, NULL);

#if SCM_DEBUG_HELPER
static ScmObj extlib__25regexp_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj rx_scm;
  ScmRegexp* rx;
  SCM_ENTER_SUBR("%regexp-dump");
  rx_scm = SCM_ARGREF(0);
  if (!SCM_REGEXPP(rx_scm)) Scm_Error("regexp required, but got %S", rx_scm);
  rx = SCM_REGEXP(rx_scm);
  {
Scm_RegDump(rx);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25regexp_dump__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1015[3]),SCM_SUBR_IMMEDIATE_ARG, extlib__25regexp_dump, NULL, NULL);

#endif /* SCM_DEBUG_HELPER */
#if SCM_DEBUG_HELPER
static ScmObj extlib__25regmatch_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj rm_scm;
  ScmRegMatch* rm;
  SCM_ENTER_SUBR("%regmatch-dump");
  rm_scm = SCM_ARGREF(0);
  if (!SCM_REGMATCHP(rm_scm)) Scm_Error("regmatch required, but got %S", rm_scm);
  rm = SCM_REGMATCH(rm_scm);
  {
Scm_RegMatchDump(rm);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25regmatch_dump__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1015[4]),SCM_SUBR_IMMEDIATE_ARG, extlib__25regmatch_dump, NULL, NULL);

#endif /* SCM_DEBUG_HELPER */
static ScmObj extlib_vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmVector* v;
  ScmObj start_scm;
  int start;
  ScmObj end_scm;
  int end;
  ScmObj fill_scm;
  ScmObj fill;
  SCM_ENTER_SUBR("vector-copy");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  v_scm = SCM_ARGREF(0);
  if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
  v = SCM_VECTOR(v_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_ARGREF(1);
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_ARGREF(2);
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    fill_scm = SCM_ARGREF(3);
  } else {
    fill_scm = SCM_UNBOUND;
  }
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VectorCopy(v,start,end,fill));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_vector_copy__STUB, 1, 4,SCM_OBJ(&scm__sc.d1003[180]),extlib_vector_copy, NULL, NULL);

static ScmObj extlib_make_weak_vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj size_scm;
  int size;
  SCM_ENTER_SUBR("make-weak-vector");
  size_scm = SCM_ARGREF(0);
  if (!SCM_INTP(size_scm)) Scm_Error("small integer required, but got %S", size_scm);
  size = SCM_INT_VALUE(size_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeWeakVector(size));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_make_weak_vector__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[181]),SCM_SUBR_IMMEDIATE_ARG, extlib_make_weak_vector, NULL, NULL);

static ScmObj extlib_weak_vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj wv_scm;
  ScmWeakVector* wv;
  SCM_ENTER_SUBR("weak-vector-length");
  wv_scm = SCM_ARGREF(0);
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_Error("weak vector required, but got %S", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  {
{
int SCM_RESULT;

#line 687 "extlib.stub"
SCM_RESULT=((wv)->size);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_weak_vector_length__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[182]),SCM_SUBR_IMMEDIATE_ARG, extlib_weak_vector_length, NULL, NULL);

static ScmObj extlib_weak_vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj wv_scm;
  ScmWeakVector* wv;
  ScmObj index_scm;
  int index;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("weak-vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  wv_scm = SCM_ARGREF(0);
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_Error("weak vector required, but got %S", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  index_scm = SCM_ARGREF(1);
  if (!SCM_INTP(index_scm)) Scm_Error("small integer required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_WeakVectorRef(wv,index,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_weak_vector_ref__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[183]),extlib_weak_vector_ref, NULL, NULL);

static ScmObj extlib_weak_vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj wv_scm;
  ScmWeakVector* wv;
  ScmObj index_scm;
  int index;
  ScmObj val_scm;
  ScmObj val;
  SCM_ENTER_SUBR("weak-vector-set!");
  wv_scm = SCM_ARGREF(0);
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_Error("weak vector required, but got %S", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  index_scm = SCM_ARGREF(1);
  if (!SCM_INTP(index_scm)) Scm_Error("small integer required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  val_scm = SCM_ARGREF(2);
  val = (val_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_WeakVectorSet(wv,index,val));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_weak_vector_setX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[184]),extlib_weak_vector_setX, NULL, NULL);

static ScmObj extlib__25uvector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj t_scm;
  int t;
  ScmObj k_scm;
  ScmObj k;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("%uvector-ref");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  v_scm = SCM_ARGREF(0);
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  t_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(t_scm)) Scm_Error("C integer required, but got %S", t_scm);
  t = Scm_GetInteger(t_scm);
  k_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(k_scm)) Scm_Error("exact integer required, but got %S", k_scm);
  k = (k_scm);
  if (SCM_ARGCNT > 3+1) {
    fallback_scm = SCM_ARGREF(3);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 702 "extlib.stub"
if (!((Scm_UVectorType(SCM_CLASS_OF(v)))==(t))){{
Scm_TypeError("vec",Scm_UVectorTypeName(t),SCM_OBJ(v));}}

#line 704 "extlib.stub"
if (((SCM_BIGNUMP(k))||(
(SCM_INT_VALUE(k))<(0)))||(
(SCM_INT_VALUE(k))>=(SCM_UVECTOR_SIZE(v)))){
if (SCM_UNBOUNDP(fallback)){{
Scm_Error("%s-ref index out of range: %S",Scm_UVectorTypeName(t),k);}}
SCM_RESULT=(fallback);} else {
SCM_RESULT=(Scm_VMUVectorRef(v,t,SCM_INT_VALUE(k),fallback));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25uvector_ref__STUB, 3, 2,1, SCM_OBJ(&scm__sc.d1003[185]),0, extlib__25uvector_ref, NULL, NULL);

static ScmObj extlib_uvector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmUVector* v;
  SCM_ENTER_SUBR("uvector-length");
  v_scm = SCM_ARGREF(0);
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_UVECTOR_SIZE(v));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_uvector_length__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[197]),SCM_SUBR_IMMEDIATE_ARG, extlib_uvector_length, NULL, NULL);

static ScmObj extlib_uvector_immutableP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmUVector* v;
  SCM_ENTER_SUBR("uvector-immutable?");
  v_scm = SCM_ARGREF(0);
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_UVECTOR_IMMUTABLE_P(v));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_uvector_immutableP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[198]),SCM_SUBR_IMMEDIATE_ARG, extlib_uvector_immutableP, NULL, NULL);

static ScmObj extlib_setter_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmProcedure* proc;
  ScmObj setter_scm;
  ScmProcedure* setter;
  SCM_ENTER_SUBR("(setter setter)");
  proc_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(proc_scm)) Scm_Error("procedure required, but got %S", proc_scm);
  proc = SCM_PROCEDURE(proc_scm);
  setter_scm = SCM_ARGREF(1);
  if (!SCM_PROCEDUREP(setter_scm)) Scm_Error("procedure required, but got %S", setter_scm);
  setter = SCM_PROCEDURE(setter_scm);
  {

#line 734 "extlib.stub"
Scm_SetterSet(proc,setter,FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_setter_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[200]),extlib_setter_SETTER, NULL, NULL);

static ScmObj extlib_setter(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("setter");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Setter(proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_setter__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[199]),extlib_setter, SCM_MAKE_INT(SCM_VM_SETTER), NULL);

static ScmObj extlib_has_setterP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("has-setter?");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_HasSetter(proc));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_has_setterP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[201]),extlib_has_setterP, NULL, NULL);

static ScmObj extlib_identity(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj val_scm;
  ScmObj val;
  SCM_ENTER_SUBR("identity");
  val_scm = SCM_ARGREF(0);
  val = (val_scm);
  {
{
ScmObj SCM_RESULT;

#line 739 "extlib.stub"
SCM_RESULT=(val);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_identity__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[202]),0, extlib_identity, NULL, NULL);

static ScmObj extlib_promiseP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("promise?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 742 "extlib.stub"
SCM_RESULT=(SCM_XTYPEP(obj,SCM_CLASS_PROMISE));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_promiseP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[203]),0, extlib_promiseP, NULL, NULL);

static ScmObj extlib_eager(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("eager");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 745 "extlib.stub"
SCM_RESULT=(Scm_MakePromise(TRUE,obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_eager__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[204]),extlib_eager, NULL, NULL);

static ScmObj extlib_promise_kind_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmPromise* p;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("(setter promise-kind)");
  p_scm = SCM_ARGREF(0);
  if (!SCM_PROMISEP(p_scm)) Scm_Error("promise required, but got %S", p_scm);
  p = SCM_PROMISE(p_scm);
  obj_scm = SCM_ARGREF(1);
  obj = (obj_scm);
  {

#line 748 "extlib.stub"
(p)->kind=(obj);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_promise_kind_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[206]),extlib_promise_kind_SETTER, NULL, NULL);

static ScmObj extlib_promise_kind(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmPromise* p;
  SCM_ENTER_SUBR("promise-kind");
  p_scm = SCM_ARGREF(0);
  if (!SCM_PROMISEP(p_scm)) Scm_Error("promise required, but got %S", p_scm);
  p = SCM_PROMISE(p_scm);
  {
{
ScmObj SCM_RESULT;

#line 749 "extlib.stub"
SCM_RESULT=((p)->kind);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_promise_kind__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[205]),SCM_SUBR_IMMEDIATE_ARG, extlib_promise_kind, NULL, NULL);

static ScmObj extlib_eof_object(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("eof-object");
  {
{
ScmObj SCM_RESULT;

#line 755 "extlib.stub"
SCM_RESULT=(SCM_EOF);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_eof_object__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[207]),SCM_SUBR_IMMEDIATE_ARG, extlib_eof_object, NULL, NULL);

#if defined(GAUCHE_WINDOWS)
#define DIRECTORY_GETS_IN_WAY(x) ((x)==EACCES)
#endif /* defined(GAUCHE_WINDOWS) */
#if !(defined(GAUCHE_WINDOWS))
#define DIRECTORY_GETS_IN_WAY(x) FALSE
#endif /* !(defined(GAUCHE_WINDOWS)) */
static ScmObj extlib__25open_input_file(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj path_scm;
  ScmString* path;
  ScmObj if_does_not_exist_scm = scm__rc.d1004[36];
  ScmObj if_does_not_exist;
  ScmObj buffering_scm = SCM_FALSE;
  ScmObj buffering;
  ScmObj element_type_scm = scm__rc.d1004[64];
  ScmObj element_type;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("%open-input-file");
  path_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(path_scm)) Scm_Error("string required, but got %S", path_scm);
  path = SCM_STRING(path_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[62])) {
      if_does_not_exist_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[63])) {
      buffering_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[65])) {
      element_type_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if_does_not_exist = (if_does_not_exist_scm);
  buffering = (buffering_scm);
  element_type = (element_type_scm);
  {
{
ScmObj SCM_RESULT;

#line 786 "extlib.stub"
{int ignerr=FALSE;
if (SCM_FALSEP(if_does_not_exist)){ignerr=(TRUE);}else if(
!(SCM_EQ(if_does_not_exist,scm__rc.d1004[36]))){
Scm_TypeError(":if-does-not-exist",":error or #f",if_does_not_exist);}
#line 791 "extlib.stub"
{int bufmode=Scm_BufferingMode(buffering,SCM_PORT_INPUT,SCM_PORT_BUFFER_FULL);ScmObj o=
#line 793 "extlib.stub"
Scm_OpenFilePort(Scm_GetStringConst(path),O_RDONLY,bufmode,0);
if ((SCM_FALSEP(o))&&(!((ignerr)&&(((((errno)==(ENOENT))||((errno)==(ENODEV)))||((errno)==(ENXIO)))||((errno)==(ENOTDIR)))))){{
Scm_SysError("couldn't open input file: %S",path);}}
SCM_RESULT=(o);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25open_input_file__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[212]),SCM_SUBR_IMMEDIATE_ARG, extlib__25open_input_file, NULL, NULL);

static ScmObj extlib__25open_output_file(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj path_scm;
  ScmString* path;
  ScmObj if_exists_scm = scm__rc.d1004[66];
  ScmObj if_exists;
  ScmObj if_does_not_exist_scm = scm__rc.d1004[68];
  ScmObj if_does_not_exist;
  ScmObj mode_scm = SCM_MAKE_INT(438U);
  int mode;
  ScmObj buffering_scm = SCM_FALSE;
  ScmObj buffering;
  ScmObj element_type_scm = scm__rc.d1004[64];
  ScmObj element_type;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("%open-output-file");
  path_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(path_scm)) Scm_Error("string required, but got %S", path_scm);
  path = SCM_STRING(path_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[67])) {
      if_exists_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[62])) {
      if_does_not_exist_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[69])) {
      mode_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[63])) {
      buffering_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[65])) {
      element_type_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if_exists = (if_exists_scm);
  if_does_not_exist = (if_does_not_exist_scm);
  if (!SCM_INTP(mode_scm)) Scm_Error("small integer required, but got %S", mode_scm);
  mode = SCM_INT_VALUE(mode_scm);
  buffering = (buffering_scm);
  element_type = (element_type_scm);
  {
{
ScmObj SCM_RESULT;

#line 804 "extlib.stub"
{int ignerr_noexist=FALSE;int ignerr_exist=FALSE;int flags=O_WRONLY;
#line 808 "extlib.stub"
if (
SCM_EQ(if_exists,scm__rc.d1004[71])){(flags)|=(O_APPEND);}else if(
SCM_EQ(if_exists,scm__rc.d1004[36])){
(flags)|=(O_EXCL);
if (SCM_EQ(if_does_not_exist,scm__rc.d1004[36])){{
Scm_Error("bad flag combination: :if-exists and :if-does-not-exist can't be :error the same time.");}}}else if(
SCM_EQ(if_exists,scm__rc.d1004[66])){(flags)|=(O_TRUNC);}else if(
SCM_EQ(if_exists,scm__rc.d1004[70])){}else if(
SCM_FALSEP(if_exists)){(flags)|=(O_EXCL);ignerr_exist=(TRUE);} else {
#line 818 "extlib.stub"
Scm_TypeError(":if-exists",":supersede, :overwrite, :append, :error or #f",if_exists);}
#line 820 "extlib.stub"
if (
SCM_EQ(if_does_not_exist,scm__rc.d1004[68])){(flags)|=(O_CREAT);}else if(
SCM_FALSEP(if_does_not_exist)){ignerr_noexist=(TRUE);}else if(
SCM_EQ(if_does_not_exist,scm__rc.d1004[36])){} else {
Scm_TypeError(":if-does-not-exist",":error, :create or #f",if_does_not_exist);}
#line 826 "extlib.stub"
{int bufmode=
Scm_BufferingMode(buffering,SCM_PORT_OUTPUT,SCM_PORT_BUFFER_FULL);ScmObj o=
Scm_OpenFilePort(Scm_GetStringConst(path),flags,bufmode,mode);
if (((SCM_FALSEP(o))&&(
!((ignerr_noexist)&&(((((errno)==(ENOENT))||((errno)==(ENODEV)))||((errno)==(ENXIO)))||((errno)==(ENOTDIR))))))&&(
!((ignerr_exist)&&((((errno)==(EEXIST))||((errno)==(ENOTDIR)))||(DIRECTORY_GETS_IN_WAY(errno)))))){{
Scm_Error("couldn't open output file: %S",path);}}
SCM_RESULT=(o);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25open_output_file__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[217]),SCM_SUBR_IMMEDIATE_ARG, extlib__25open_output_file, NULL, NULL);

static ScmObj extlib_open_input_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj string_scm;
  ScmString* string;
  ScmObj privateP_scm = SCM_FALSE;
  int privateP;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("open-input-string");
  string_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(string_scm)) Scm_Error("string required, but got %S", string_scm);
  string = SCM_STRING(string_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[72])) {
      privateP_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if (!SCM_BOOLP(privateP_scm)) Scm_Error("boolean required, but got %S", privateP_scm);
  privateP = SCM_BOOL_VALUE(privateP_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeInputStringPort(string,privateP));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_input_string__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[221]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_input_string, NULL, NULL);

static ScmObj extlib_open_output_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj privateP_scm = SCM_FALSE;
  int privateP;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("open-output-string");
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[72])) {
      privateP_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if (!SCM_BOOLP(privateP_scm)) Scm_Error("boolean required, but got %S", privateP_scm);
  privateP = SCM_BOOL_VALUE(privateP_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeOutputStringPort(privateP));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_output_string__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[222]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_output_string, NULL, NULL);

static ScmObj extlib_get_output_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj oport_scm;
  ScmPort* oport;
  SCM_ENTER_SUBR("get-output-string");
  oport_scm = SCM_ARGREF(0);
  if (!SCM_OPORTP(oport_scm)) Scm_Error("output port required, but got %S", oport_scm);
  oport = SCM_PORT(oport_scm);
  {
{
ScmObj SCM_RESULT;

#line 843 "extlib.stub"
SCM_RESULT=(Scm_GetOutputString(oport,0));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_get_output_string__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[223]),SCM_SUBR_IMMEDIATE_ARG, extlib_get_output_string, NULL, NULL);

static ScmObj extlib_get_output_byte_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj oport_scm;
  ScmPort* oport;
  SCM_ENTER_SUBR("get-output-byte-string");
  oport_scm = SCM_ARGREF(0);
  if (!SCM_OPORTP(oport_scm)) Scm_Error("output port required, but got %S", oport_scm);
  oport = SCM_PORT(oport_scm);
  {
{
ScmObj SCM_RESULT;

#line 846 "extlib.stub"
SCM_RESULT=(Scm_GetOutputString(oport,SCM_STRING_INCOMPLETE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_get_output_byte_string__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[224]),SCM_SUBR_IMMEDIATE_ARG, extlib_get_output_byte_string, NULL, NULL);

static ScmObj extlib_get_remaining_input_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj iport_scm;
  ScmPort* iport;
  SCM_ENTER_SUBR("get-remaining-input-string");
  iport_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(iport_scm)) Scm_Error("input port required, but got %S", iport_scm);
  iport = SCM_PORT(iport_scm);
  {
{
ScmObj SCM_RESULT;

#line 849 "extlib.stub"
SCM_RESULT=(Scm_GetRemainingInputString(iport,0));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_get_remaining_input_string__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[225]),SCM_SUBR_IMMEDIATE_ARG, extlib_get_remaining_input_string, NULL, NULL);

static ScmObj extlib_open_coding_aware_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj iport_scm;
  ScmPort* iport;
  SCM_ENTER_SUBR("open-coding-aware-port");
  iport_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(iport_scm)) Scm_Error("input port required, but got %S", iport_scm);
  iport = SCM_PORT(iport_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeCodingAwarePort(iport));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_coding_aware_port__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[226]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_coding_aware_port, NULL, NULL);

static void bufport_closer(ScmPort* p){{
#line 857 "extlib.stub"
if ((SCM_PORT_DIR(p))==(SCM_PORT_OUTPUT)){{
{ScmObj scmflusher=SCM_OBJ(((p)->src).buf.data);int siz=
((int )((((p)->src).buf.current)-(
((p)->src).buf.buffer)));
if ((siz)>(0)){{
Scm_ApplyRec1(scmflusher,
Scm_MakeString(((p)->src).buf.buffer,siz,siz,
(SCM_STRING_INCOMPLETE)|(SCM_STRING_COPYING)));}}
#line 866 "extlib.stub"
Scm_ApplyRec1(scmflusher,SCM_FALSE);}}}}}
static int bufport_filler(ScmPort* p,int cnt){{
#line 869 "extlib.stub"
{ScmObj scmfiller=SCM_OBJ(((p)->src).buf.data);ScmObj r=
Scm_ApplyRec1(scmfiller,Scm_MakeInteger(cnt));
if ((SCM_EOFP(r))||(SCM_FALSEP(r))){return (0);}else if(
!(SCM_STRINGP(r))){
Scm_Error("buffered port callback procedure returned non-string: %S",r);}
{const ScmStringBody* b=SCM_STRING_BODY(r);int siz=
SCM_STRING_BODY_SIZE(b);
if ((siz)>(cnt)){{siz=(cnt);}}
memcpy(((p)->src).buf.end,SCM_STRING_BODY_START(b),siz);
return (SCM_STRING_BODY_SIZE(b));}}}}
static ScmObj extlib_open_input_buffered_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj filler_scm;
  ScmProcedure* filler;
  ScmObj buffer_size_scm;
  int buffer_size;
  SCM_ENTER_SUBR("open-input-buffered-port");
  filler_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(filler_scm)) Scm_Error("procedure required, but got %S", filler_scm);
  filler = SCM_PROCEDURE(filler_scm);
  buffer_size_scm = SCM_ARGREF(1);
  if (!SCM_INTP(buffer_size_scm)) Scm_Error("small integer required, but got %S", buffer_size_scm);
  buffer_size = SCM_INT_VALUE(buffer_size_scm);
  {
{
ScmObj SCM_RESULT;

#line 882 "extlib.stub"
{ScmPortBuffer bufrec;
(bufrec).size=(buffer_size),
(bufrec).buffer=(NULL),
(bufrec).mode=(SCM_PORT_BUFFER_FULL),
(bufrec).filler=(bufport_filler),
(bufrec).flusher=(NULL),
(bufrec).closer=(bufport_closer),
(bufrec).ready=(NULL),
(bufrec).filenum=(NULL),
(bufrec).data=(((void* )(filler)));
SCM_RESULT=(Scm_MakeBufferedPort(SCM_CLASS_PORT,SCM_FALSE,SCM_PORT_INPUT,TRUE,&(bufrec)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_input_buffered_port__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[227]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_input_buffered_port, NULL, NULL);

static int bufport_flusher(ScmPort* p,int cnt,int forcep){{
#line 895 "extlib.stub"
{ScmObj scmflusher=SCM_OBJ(((p)->src).buf.data);ScmObj s=
Scm_MakeString(((p)->src).buf.buffer,cnt,cnt,
(SCM_STRING_INCOMPLETE)|(SCM_STRING_COPYING));
Scm_ApplyRec1(scmflusher,s);
return (cnt);}}}
static ScmObj extlib_open_output_buffered_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj flusher_scm;
  ScmProcedure* flusher;
  ScmObj buffer_size_scm;
  int buffer_size;
  SCM_ENTER_SUBR("open-output-buffered-port");
  flusher_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(flusher_scm)) Scm_Error("procedure required, but got %S", flusher_scm);
  flusher = SCM_PROCEDURE(flusher_scm);
  buffer_size_scm = SCM_ARGREF(1);
  if (!SCM_INTP(buffer_size_scm)) Scm_Error("small integer required, but got %S", buffer_size_scm);
  buffer_size = SCM_INT_VALUE(buffer_size_scm);
  {
{
ScmObj SCM_RESULT;

#line 903 "extlib.stub"
{ScmPortBuffer bufrec;
(bufrec).size=(buffer_size),
(bufrec).buffer=(NULL),
(bufrec).mode=(SCM_PORT_BUFFER_FULL),
(bufrec).filler=(NULL),
(bufrec).flusher=(bufport_flusher),
(bufrec).closer=(bufport_closer),
(bufrec).ready=(NULL),
(bufrec).filenum=(NULL),
(bufrec).data=(((void* )(flusher)));
SCM_RESULT=(Scm_MakeBufferedPort(SCM_CLASS_PORT,SCM_FALSE,SCM_PORT_OUTPUT,TRUE,
&(bufrec)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_output_buffered_port__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[228]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_output_buffered_port, NULL, NULL);

static ScmObj extlib_flush(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj oport_scm;
  ScmPort* oport;
  SCM_ENTER_SUBR("flush");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    oport_scm = SCM_ARGREF(0);
  } else {
    oport_scm = SCM_OBJ(SCM_CUROUT);
  }
  if (!SCM_OPORTP(oport_scm)) Scm_Error("output port required, but got %S", oport_scm);
  oport = SCM_PORT(oport_scm);
  {
Scm_Flush(oport);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_flush__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[229]),SCM_SUBR_IMMEDIATE_ARG, extlib_flush, NULL, NULL);

static ScmObj extlib_flush_all_ports(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("flush-all-ports");
  {

#line 919 "extlib.stub"
Scm_FlushAllPorts(FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_flush_all_ports__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[230]),SCM_SUBR_IMMEDIATE_ARG, extlib_flush_all_ports, NULL, NULL);

static ScmObj extlib_port_closedP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmPort* obj;
  SCM_ENTER_SUBR("port-closed?");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(obj_scm)) Scm_Error("port required, but got %S", obj_scm);
  obj = SCM_PORT(obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_PORT_CLOSED_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_closedP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[231]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_closedP, NULL, NULL);

static ScmObj extlib_port_case_fold_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj flag_scm;
  int flag;
  SCM_ENTER_SUBR("port-case-fold-set!");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  flag_scm = SCM_ARGREF(1);
  if (!SCM_BOOLP(flag_scm)) Scm_Error("boolean required, but got %S", flag_scm);
  flag = SCM_BOOL_VALUE(flag_scm);
  {

#line 924 "extlib.stub"
if (flag){
(SCM_PORT_FLAGS(port))|=(SCM_PORT_CASE_FOLD);} else {
(SCM_PORT_FLAGS(port))&=(~(SCM_PORT_CASE_FOLD));}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_port_case_fold_setX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[232]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_case_fold_setX, NULL, NULL);

static ScmObj extlib_current_error_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj newport_scm;
  ScmObj newport;
  SCM_ENTER_SUBR("current-error-port");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    newport_scm = SCM_ARGREF(0);
  } else {
    newport_scm = SCM_UNBOUND;
  }
  newport = (newport_scm);
  {
{
ScmObj SCM_RESULT;

#line 929 "extlib.stub"
if (
SCM_OPORTP(newport)){SCM_RESULT=(Scm_SetCurrentErrorPort(SCM_PORT(newport)));}else if(
!(SCM_UNBOUNDP(newport))){
Scm_TypeError("current-error-port","output port",newport);
SCM_RESULT=(SCM_UNDEFINED);} else {
SCM_RESULT=(SCM_OBJ(SCM_CURERR));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_current_error_port__STUB, 0, 2,SCM_OBJ(&scm__sc.d1003[233]),extlib_current_error_port, NULL, NULL);

static ScmObj extlib_standard_input_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmPort* p;
  SCM_ENTER_SUBR("standard-input-port");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    p_scm = SCM_ARGREF(0);
  } else {
    p_scm = SCM_FALSE;
  }
  if (!SCM_MAYBE_P(SCM_IPORTP, p_scm)) Scm_Error("input port or #f required, but got %S", p_scm);
  p = SCM_MAYBE(SCM_PORT, p_scm);
  {
{
ScmObj SCM_RESULT;

#line 937 "extlib.stub"
SCM_RESULT=(((p)?(Scm_SetStdin(p)):(Scm_Stdin())));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_standard_input_port__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[234]),SCM_SUBR_IMMEDIATE_ARG, extlib_standard_input_port, NULL, NULL);

static ScmObj extlib_standard_output_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmPort* p;
  SCM_ENTER_SUBR("standard-output-port");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    p_scm = SCM_ARGREF(0);
  } else {
    p_scm = SCM_FALSE;
  }
  if (!SCM_MAYBE_P(SCM_OPORTP, p_scm)) Scm_Error("output port or #f required, but got %S", p_scm);
  p = SCM_MAYBE(SCM_PORT, p_scm);
  {
{
ScmObj SCM_RESULT;

#line 939 "extlib.stub"
SCM_RESULT=(((p)?(Scm_SetStdout(p)):(Scm_Stdout())));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_standard_output_port__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[235]),SCM_SUBR_IMMEDIATE_ARG, extlib_standard_output_port, NULL, NULL);

static ScmObj extlib_standard_error_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmPort* p;
  SCM_ENTER_SUBR("standard-error-port");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    p_scm = SCM_ARGREF(0);
  } else {
    p_scm = SCM_FALSE;
  }
  if (!SCM_MAYBE_P(SCM_OPORTP, p_scm)) Scm_Error("output port or #f required, but got %S", p_scm);
  p = SCM_MAYBE(SCM_PORT, p_scm);
  {
{
ScmObj SCM_RESULT;

#line 941 "extlib.stub"
SCM_RESULT=(((p)?(Scm_SetStderr(p)):(Scm_Stderr())));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_standard_error_port__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[236]),SCM_SUBR_IMMEDIATE_ARG, extlib_standard_error_port, NULL, NULL);

static ScmObj extlib_port_name(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port-name");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_PortName(port));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_name__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[237]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_name, NULL, NULL);

static ScmObj extlib_port_current_line(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port-current-line");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_PortLine(port));
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_current_line__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[238]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_current_line, NULL, NULL);

static ScmObj extlib_port_file_number(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port-file-number");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 947 "extlib.stub"
{int i=Scm_PortFileNo(port);
SCM_RESULT=((((i)<(0))?(SCM_FALSE):(Scm_MakeInteger(i))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_file_number__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[239]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_file_number, NULL, NULL);

static ScmObj extlib_port_fd_dupX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj dst_scm;
  ScmPort* dst;
  ScmObj src_scm;
  ScmPort* src;
  SCM_ENTER_SUBR("port-fd-dup!");
  dst_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(dst_scm)) Scm_Error("port required, but got %S", dst_scm);
  dst = SCM_PORT(dst_scm);
  src_scm = SCM_ARGREF(1);
  if (!SCM_PORTP(src_scm)) Scm_Error("port required, but got %S", src_scm);
  src = SCM_PORT(src_scm);
  {
Scm_PortFdDup(dst,src);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_port_fd_dupX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[240]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_fd_dupX, NULL, NULL);

static ScmObj extlib_port_seek(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj offset_scm;
  ScmObj offset;
  ScmObj whence_scm;
  int whence;
  SCM_ENTER_SUBR("port-seek");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  offset_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(offset_scm)) Scm_Error("exact integer required, but got %S", offset_scm);
  offset = (offset_scm);
  if (SCM_ARGCNT > 2+1) {
    whence_scm = SCM_ARGREF(2);
  } else {
    whence_scm = SCM_MAKE_INT(SEEK_SET);
  }
  if (!SCM_INTP(whence_scm)) Scm_Error("small integer required, but got %S", whence_scm);
  whence = SCM_INT_VALUE(whence_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_PortSeek(port,offset,whence));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_seek__STUB, 2, 2,0, SCM_OBJ(&scm__sc.d1003[244]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_seek, NULL, NULL);

static ScmObj extlib_port_type(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port-type");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 962 "extlib.stub"
switch (SCM_PORT_TYPE(port)) {
case SCM_PORT_FILE : {SCM_RESULT=(scm__rc.d1004[76]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 964 "extlib.stub"
case SCM_PORT_PROC : {SCM_RESULT=(scm__rc.d1004[77]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 965 "extlib.stub"
case SCM_PORT_OSTR : case SCM_PORT_ISTR : {SCM_RESULT=(scm__rc.d1004[78]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}default: {
#line 966 "extlib.stub"
SCM_RESULT=(SCM_FALSE);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_type__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[245]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_type, NULL, NULL);

static ScmObj extlib_port_buffering_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj mode_scm;
  ScmObj mode;
  SCM_ENTER_SUBR("(setter port-buffering)");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  mode_scm = SCM_ARGREF(1);
  mode = (mode_scm);
  {

#line 970 "extlib.stub"
if (!((SCM_PORT_TYPE(port))==(SCM_PORT_FILE))){{
Scm_Error("can't set buffering mode to non-buffered port: %S",port);}}

#line 972 "extlib.stub"
((port)->src).buf.mode=(
Scm_BufferingMode(mode,(port)->direction,-1));
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_port_buffering_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[250]),extlib_port_buffering_SETTER, NULL, NULL);

static ScmObj extlib_port_buffering(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port-buffering");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_GetBufferingMode(port));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_buffering__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[249]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_buffering, NULL, NULL);

static ScmObj extlib_open_input_fd_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fd_scm;
  int fd;
  ScmObj buffering_scm = SCM_FALSE;
  ScmObj buffering;
  ScmObj ownerP_scm = SCM_FALSE;
  int ownerP;
  ScmObj name_scm = SCM_FALSE;
  ScmObj name;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("open-input-fd-port");
  fd_scm = SCM_ARGREF(0);
  if (!SCM_INTP(fd_scm)) Scm_Error("small integer required, but got %S", fd_scm);
  fd = SCM_INT_VALUE(fd_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[63])) {
      buffering_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[79])) {
      ownerP_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[80])) {
      name_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  buffering = (buffering_scm);
  if (!SCM_BOOLP(ownerP_scm)) Scm_Error("boolean required, but got %S", ownerP_scm);
  ownerP = SCM_BOOL_VALUE(ownerP_scm);
  name = (name_scm);
  {
{
ScmObj SCM_RESULT;

#line 981 "extlib.stub"
{int bufmode=Scm_BufferingMode(buffering,SCM_PORT_INPUT,SCM_PORT_BUFFER_FULL);
#line 983 "extlib.stub"
if ((fd)<(0)){{Scm_Error("bad file descriptor: %d",fd);}}
SCM_RESULT=(Scm_MakePortWithFd(name,SCM_PORT_INPUT,fd,bufmode,ownerP));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_input_fd_port__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[253]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_input_fd_port, NULL, NULL);

static ScmObj extlib_open_output_fd_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fd_scm;
  int fd;
  ScmObj buffering_scm = SCM_FALSE;
  ScmObj buffering;
  ScmObj ownerP_scm = SCM_FALSE;
  int ownerP;
  ScmObj name_scm = SCM_FALSE;
  ScmObj name;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("open-output-fd-port");
  fd_scm = SCM_ARGREF(0);
  if (!SCM_INTP(fd_scm)) Scm_Error("small integer required, but got %S", fd_scm);
  fd = SCM_INT_VALUE(fd_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[63])) {
      buffering_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[79])) {
      ownerP_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[80])) {
      name_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  buffering = (buffering_scm);
  if (!SCM_BOOLP(ownerP_scm)) Scm_Error("boolean required, but got %S", ownerP_scm);
  ownerP = SCM_BOOL_VALUE(ownerP_scm);
  name = (name_scm);
  {
{
ScmObj SCM_RESULT;

#line 990 "extlib.stub"
{int bufmode=Scm_BufferingMode(buffering,SCM_PORT_OUTPUT,SCM_PORT_BUFFER_FULL);
#line 992 "extlib.stub"
if ((fd)<(0)){{Scm_Error("bad file descriptor: %d",fd);}}
SCM_RESULT=(Scm_MakePortWithFd(name,SCM_PORT_OUTPUT,fd,bufmode,ownerP));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_open_output_fd_port__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[254]),SCM_SUBR_IMMEDIATE_ARG, extlib_open_output_fd_port, NULL, NULL);

static ScmObj extlib_with_port_locking(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("with-port-locking");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  proc_scm = SCM_ARGREF(1);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMWithPortLocking(port,proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_with_port_locking__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[255]),extlib_with_port_locking, NULL, NULL);

static ScmObj extlib_port_TObyte_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("port->byte-string");
  port_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 999 "extlib.stub"
{ScmDString ds;char buf[1024];
Scm_DStringInit(&(ds));
for (;;){{int nbytes=Scm_Getz(buf,1024,port);
if ((nbytes)<=(0)){{break;}}
Scm_DStringPutz(&(ds),buf,nbytes);}}
SCM_RESULT=(Scm_DStringGet(&(ds),SCM_STRING_INCOMPLETE));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_port_TObyte_string__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[256]),SCM_SUBR_IMMEDIATE_ARG, extlib_port_TObyte_string, NULL, NULL);

static ScmObj extlib_byte_readyP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("byte-ready?");
  port_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_ByteReady(port));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_byte_readyP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[257]),SCM_SUBR_IMMEDIATE_ARG, extlib_byte_readyP, NULL, NULL);

static ScmObj extlib_read_byte(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("read-byte");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    port_scm = SCM_ARGREF(0);
  } else {
    port_scm = SCM_OBJ(SCM_CURIN);
  }
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 1013 "extlib.stub"
{int b;
SCM_GETB(b,port);
SCM_RESULT=((((b)<(0))?(SCM_EOF):(SCM_MAKE_INT(b))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_read_byte__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[258]),SCM_SUBR_IMMEDIATE_ARG, extlib_read_byte, NULL, NULL);

static ScmObj extlib_peek_byte(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("peek-byte");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    port_scm = SCM_ARGREF(0);
  } else {
    port_scm = SCM_OBJ(SCM_CURIN);
  }
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 1018 "extlib.stub"
{int b=Scm_Peekb(port);
SCM_RESULT=((((b)<(0))?(SCM_EOF):(SCM_MAKE_INT(b))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_peek_byte__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[259]),SCM_SUBR_IMMEDIATE_ARG, extlib_peek_byte, NULL, NULL);

static ScmObj extlib_read_line(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj allowbytestr_scm;
  ScmObj allowbytestr;
  SCM_ENTER_SUBR("read-line");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    port_scm = SCM_ARGREF(0);
  } else {
    port_scm = SCM_OBJ(SCM_CURIN);
  }
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  if (SCM_ARGCNT > 1+1) {
    allowbytestr_scm = SCM_ARGREF(1);
  } else {
    allowbytestr_scm = SCM_FALSE;
  }
  allowbytestr = (allowbytestr_scm);
  {
{
ScmObj SCM_RESULT;

#line 1023 "extlib.stub"
{ScmObj r=Scm_ReadLine(port);
if (((SCM_FALSEP(allowbytestr))&&(
SCM_STRINGP(r)))&&(
SCM_STRING_INCOMPLETE_P(r))){{
Scm_ReadError(port,"read-line: encountered illegal byte sequence: %S",r);}}
SCM_RESULT=(r);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_read_line__STUB, 0, 3,SCM_OBJ(&scm__sc.d1003[260]),extlib_read_line, NULL, NULL);

static ScmObj extlib_read_block(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj bytes_scm;
  int bytes;
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("read-block");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  bytes_scm = SCM_ARGREF(0);
  if (!SCM_INTP(bytes_scm)) Scm_Error("small integer required, but got %S", bytes_scm);
  bytes = SCM_INT_VALUE(bytes_scm);
  if (SCM_ARGCNT > 1+1) {
    port_scm = SCM_ARGREF(1);
  } else {
    port_scm = SCM_OBJ(SCM_CURIN);
  }
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
ScmObj SCM_RESULT;

#line 1032 "extlib.stub"
if ((bytes)<(0)){{
Scm_Error("bytes must be non-negative integer: %d",bytes);}}

#line 1034 "extlib.stub"
if ((bytes)==(0)){
SCM_RESULT=(Scm_MakeString("",0,0,0));} else {
{char* buf=SCM_NEW_ATOMIC2(char*,(bytes)+(1));int nread=
Scm_Getz(buf,bytes,port);
if ((nread)<=(0)){SCM_RESULT=(SCM_EOF);} else {
#line 1040 "extlib.stub"
SCM_ASSERT((nread)<=(bytes));
(buf)[nread]=('\x00');
SCM_RESULT=(Scm_MakeString(buf,nread,nread,SCM_STRING_INCOMPLETE));}}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_read_block__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[261]),SCM_SUBR_IMMEDIATE_ARG, extlib_read_block, NULL, NULL);

static ScmObj extlib_read_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj closer_scm;
  ScmChar closer;
  ScmObj port_scm;
  ScmObj port;
  SCM_ENTER_SUBR("read-list");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  closer_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(closer_scm)) Scm_Error("character required, but got %S", closer_scm);
  closer = SCM_CHAR_VALUE(closer_scm);
  if (SCM_ARGCNT > 1+1) {
    port_scm = SCM_ARGREF(1);
  } else {
    port_scm = SCM_OBJ(SCM_CURIN);
  }
  port = (port_scm);
  {
{
ScmObj SCM_RESULT;

#line 1047 "extlib.stub"
SCM_RESULT=(Scm_ReadList(port,closer));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_read_list__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[262]),extlib_read_list, NULL, NULL);

static ScmObj extlib_define_reader_ctor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj symbol_scm;
  ScmObj symbol;
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj finisher_scm;
  ScmObj finisher;
  SCM_ENTER_SUBR("define-reader-ctor");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  symbol_scm = SCM_ARGREF(0);
  symbol = (symbol_scm);
  proc_scm = SCM_ARGREF(1);
  proc = (proc_scm);
  if (SCM_ARGCNT > 2+1) {
    finisher_scm = SCM_ARGREF(2);
  } else {
    finisher_scm = SCM_FALSE;
  }
  finisher = (finisher_scm);
  {
{
ScmObj SCM_RESULT;

#line 1050 "extlib.stub"
SCM_RESULT=(Scm_DefineReaderCtor(symbol,proc,finisher,SCM_FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_define_reader_ctor__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[263]),extlib_define_reader_ctor, NULL, NULL);

static ScmObj extlib__25get_reader_ctor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj symbol_scm;
  ScmObj symbol;
  SCM_ENTER_SUBR("%get-reader-ctor");
  symbol_scm = SCM_ARGREF(0);
  symbol = (symbol_scm);
  {
{
ScmObj SCM_RESULT;

#line 1053 "extlib.stub"
SCM_RESULT=(Scm_GetReaderCtor(symbol,SCM_FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25get_reader_ctor__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[264]),extlib__25get_reader_ctor, NULL, NULL);

static ScmObj extlib_define_reader_directive(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj symbol_scm;
  ScmObj symbol;
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("define-reader-directive");
  symbol_scm = SCM_ARGREF(0);
  symbol = (symbol_scm);
  proc_scm = SCM_ARGREF(1);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_DefineReaderDirective(symbol,proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_define_reader_directive__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[265]),extlib_define_reader_directive, NULL, NULL);

static ScmObj extlib_read_referenceP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("read-reference?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_READ_REFERENCE_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_read_referenceP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[266]),extlib_read_referenceP, NULL, NULL);

static ScmObj extlib_read_reference_has_valueP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ref_scm;
  ScmReadReference* ref;
  SCM_ENTER_SUBR("read-reference-has-value?");
  ref_scm = SCM_ARGREF(0);
  if (!SCM_READ_REFERENCE_P(ref_scm)) Scm_Error("read reference required, but got %S", ref_scm);
  ref = SCM_READ_REFERENCE(ref_scm);
  {
{
int SCM_RESULT;

#line 1067 "extlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP((ref)->value)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_read_reference_has_valueP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[267]),SCM_SUBR_IMMEDIATE_ARG, extlib_read_reference_has_valueP, NULL, NULL);

static ScmObj extlib_read_reference_value(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ref_scm;
  ScmReadReference* ref;
  SCM_ENTER_SUBR("read-reference-value");
  ref_scm = SCM_ARGREF(0);
  if (!SCM_READ_REFERENCE_P(ref_scm)) Scm_Error("read reference required, but got %S", ref_scm);
  ref = SCM_READ_REFERENCE(ref_scm);
  {
{
ScmObj SCM_RESULT;

#line 1070 "extlib.stub"
if (SCM_UNBOUNDP((ref)->value)){{
Scm_Error("read reference hasn't been resolved");}}

#line 1072 "extlib.stub"
SCM_RESULT=((ref)->value);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_read_reference_value__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[268]),SCM_SUBR_IMMEDIATE_ARG, extlib_read_reference_value, NULL, NULL);

static ScmObj extlib_write_byte(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj byte_scm;
  int byte;
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("write-byte");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  byte_scm = SCM_ARGREF(0);
  if (!SCM_INTP(byte_scm)) Scm_Error("small integer required, but got %S", byte_scm);
  byte = SCM_INT_VALUE(byte_scm);
  if (SCM_ARGCNT > 1+1) {
    port_scm = SCM_ARGREF(1);
  } else {
    port_scm = SCM_OBJ(SCM_CUROUT);
  }
  if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
{
int SCM_RESULT;

#line 1081 "extlib.stub"
if (((byte)<(0))||((byte)>(255))){{
Scm_Error("argument out of range: %d",byte);}}

#line 1083 "extlib.stub"
SCM_PUTB(byte,port);

#line 1084 "extlib.stub"
SCM_RESULT=(1);
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_write_byte__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[269]),SCM_SUBR_IMMEDIATE_ARG, extlib_write_byte, NULL, NULL);

static ScmObj extlib_write_limited(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj limit_scm;
  int limit;
  ScmObj port_scm;
  ScmObj port;
  SCM_ENTER_SUBR("write-limited");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  limit_scm = SCM_ARGREF(1);
  if (!SCM_INTP(limit_scm)) Scm_Error("small integer required, but got %S", limit_scm);
  limit = SCM_INT_VALUE(limit_scm);
  if (SCM_ARGCNT > 2+1) {
    port_scm = SCM_ARGREF(2);
  } else {
    port_scm = SCM_OBJ(SCM_CUROUT);
  }
  port = (port_scm);
  {
{
int SCM_RESULT;

#line 1088 "extlib.stub"
SCM_RESULT=(Scm_WriteLimited(obj,port,SCM_WRITE_WRITE,limit));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_write_limited__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[270]),extlib_write_limited, NULL, NULL);

static ScmObj extlib_write_2a(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj port_scm;
  ScmObj port;
  SCM_ENTER_SUBR("write*");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  if (SCM_ARGCNT > 1+1) {
    port_scm = SCM_ARGREF(1);
  } else {
    port_scm = SCM_OBJ(SCM_CUROUT);
  }
  port = (port_scm);
  {
{
int SCM_RESULT;

#line 1091 "extlib.stub"
SCM_RESULT=(Scm_WriteCircular(obj,port,SCM_WRITE_WRITE,0));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_write_2a__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[271]),extlib_write_2a, NULL, NULL);

static ScmObj extlib__25add_load_path(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj path_scm;
  const char * path;
  ScmObj afterp_scm;
  ScmObj afterp;
  SCM_ENTER_SUBR("%add-load-path");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  path_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(path_scm)) Scm_Error("const C string required, but got %S", path_scm);
  path = SCM_STRING_CONST_CSTRING(path_scm);
  if (SCM_ARGCNT > 1+1) {
    afterp_scm = SCM_ARGREF(1);
  } else {
    afterp_scm = SCM_FALSE;
  }
  afterp = (afterp_scm);
  {
{
ScmObj SCM_RESULT;

#line 1098 "extlib.stub"
SCM_RESULT=(Scm_AddLoadPath(path,!(SCM_FALSEP(afterp))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25add_load_path__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[272]),extlib__25add_load_path, NULL, NULL);

static ScmObj extlib_load_from_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj paths_scm = SCM_FALSE;
  ScmObj paths;
  ScmObj environment_scm = SCM_FALSE;
  ScmObj environment;
  ScmObj main_script_scm = SCM_FALSE;
  ScmObj main_script;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("load-from-port");
  port_scm = SCM_ARGREF(0);
  if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[81])) {
      paths_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[82])) {
      environment_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[83])) {
      main_script_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  paths = (paths_scm);
  environment = (environment_scm);
  main_script = (main_script_scm);
  {
{
ScmObj SCM_RESULT;

#line 1102 "extlib.stub"
{int flags=((SCM_FALSEP(main_script))?(0):(SCM_LOAD_MAIN_SCRIPT));
SCM_RESULT=(Scm_VMLoadFromPort(port,paths,environment,flags));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_load_from_port__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[276]),SCM_SUBR_IMMEDIATE_ARG, extlib_load_from_port, NULL, NULL);

static ScmObj extlib_dynamic_load(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj file_scm;
  ScmString* file;
  ScmObj init_function_scm = SCM_FALSE;
  ScmObj init_function;
  ScmObj export_symbols_scm = SCM_FALSE;
  ScmObj export_symbols;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("dynamic-load");
  file_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(file_scm)) Scm_Error("string required, but got %S", file_scm);
  file = SCM_STRING(file_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[84])) {
      init_function_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[85])) {
      export_symbols_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  init_function = (init_function_scm);
  export_symbols = (export_symbols_scm);
  {
{
ScmObj SCM_RESULT;

#line 1108 "extlib.stub"
SCM_RESULT=(Scm_DynLoad(file,init_function,0));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_dynamic_load__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[279]),SCM_SUBR_IMMEDIATE_ARG, extlib_dynamic_load, NULL, NULL);

static ScmObj extlib__25require(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj feature_scm;
  ScmObj feature;
  SCM_ENTER_SUBR("%require");
  feature_scm = SCM_ARGREF(0);
  feature = (feature_scm);
  {
{
int SCM_RESULT;

#line 1111 "extlib.stub"
SCM_RESULT=(!(Scm_Require(feature,SCM_LOAD_PROPAGATE_ERROR,NULL)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25require__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[280]),extlib__25require, NULL, NULL);

static ScmObj extlib_provide(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj feature_scm;
  ScmObj feature;
  SCM_ENTER_SUBR("provide");
  feature_scm = SCM_ARGREF(0);
  feature = (feature_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Provide(feature));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_provide__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[281]),extlib_provide, NULL, NULL);

static ScmObj extlib_providedP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj feature_scm;
  ScmObj feature;
  SCM_ENTER_SUBR("provided?");
  feature_scm = SCM_ARGREF(0);
  feature = (feature_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_ProvidedP(feature));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_providedP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[282]),extlib_providedP, NULL, NULL);

static ScmObj extlib__25autoload(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj file_or_module_scm;
  ScmObj file_or_module;
  ScmObj entries_scm;
  ScmObj entries;
  SCM_ENTER_SUBR("%autoload");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  file_or_module_scm = SCM_ARGREF(1);
  file_or_module = (file_or_module_scm);
  entries_scm = SCM_ARGREF(2);
  entries = (entries_scm);
  {
Scm_DefineAutoload(mod,file_or_module,entries);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib__25autoload__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[283]),extlib__25autoload, NULL, NULL);

static ScmObj extlib_undefined(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("undefined");
  {
{
ScmObj SCM_RESULT;

#line 1118 "extlib.stub"
SCM_RESULT=(SCM_UNDEFINED);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_undefined__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[284]),SCM_SUBR_IMMEDIATE_ARG, extlib_undefined, SCM_MAKE_INT(SCM_VM_CONSTU), NULL);

static ScmObj extlib_undefinedP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("undefined?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_UNDEFINEDP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_undefinedP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[285]),0, extlib_undefinedP, NULL, NULL);

static ScmObj extlib_warn(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fmt_scm;
  ScmString* fmt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("warn");
  fmt_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(fmt_scm)) Scm_Error("string required, but got %S", fmt_scm);
  fmt = SCM_STRING(fmt_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
Scm_FWarn(fmt,args);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_warn__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[286]),SCM_SUBR_IMMEDIATE_ARG, extlib_warn, NULL, NULL);

static ScmObj extlib_eq_hash(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("eq-hash");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
u_long SCM_RESULT;
SCM_RESULT=(Scm_EqHash(obj));
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_eq_hash__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[287]),SCM_SUBR_IMMEDIATE_ARG, extlib_eq_hash, NULL, NULL);

static ScmObj extlib_eqv_hash(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("eqv-hash");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
u_long SCM_RESULT;
SCM_RESULT=(Scm_EqvHash(obj));
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_eqv_hash__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[288]),SCM_SUBR_IMMEDIATE_ARG, extlib_eqv_hash, NULL, NULL);

static ScmObj extlib_hash(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("hash");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
u_long SCM_RESULT;
SCM_RESULT=(Scm_Hash(obj));
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[289]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash, NULL, NULL);

static ScmObj extlib_hash_tableP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("hash-table?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_HASH_TABLE_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_tableP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[290]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_tableP, NULL, NULL);

static ScmObj extlib_make_hash_table(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj type_scm;
  ScmObj type;
  SCM_ENTER_SUBR("make-hash-table");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    type_scm = SCM_ARGREF(0);
  } else {
    type_scm = scm__rc.d1004[1];
  }
  type = (type_scm);
  {
{
ScmObj SCM_RESULT;

#line 1212 "extlib.stub"
{int ctype=0;
if (SCM_EQ(type,scm__rc.d1004[1])){ctype=(SCM_HASH_EQ);}else if(SCM_EQ(type,scm__rc.d1004[0])){ctype=(SCM_HASH_EQV);}else if(SCM_EQ(type,scm__rc.d1004[2])){ctype=(SCM_HASH_EQUAL);}else if(SCM_EQ(type,scm__rc.d1004[86])){ctype=(SCM_HASH_STRING);} else {Scm_Error("unsupported hash type: %S",type);}
SCM_RESULT=(Scm_MakeHashTableSimple(ctype,0));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_make_hash_table__STUB, 0, 2,SCM_OBJ(&scm__sc.d1003[291]),extlib_make_hash_table, NULL, NULL);

static ScmObj extlib_hash_table_type(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-type");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;

#line 1217 "extlib.stub"
switch ((hash)->type) {case SCM_HASH_EQ : {SCM_RESULT=(scm__rc.d1004[1]);
#line 542 "../lib/gauche/cgen/cise.scm"
break;}case SCM_HASH_EQV : {SCM_RESULT=(scm__rc.d1004[0]);break;}case SCM_HASH_EQUAL : {SCM_RESULT=(scm__rc.d1004[2]);break;}case SCM_HASH_STRING : {SCM_RESULT=(scm__rc.d1004[86]);break;}default: {SCM_RESULT=(SCM_FALSE);break;}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_type__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[293]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_type, NULL, NULL);

static ScmObj extlib_hash_table_num_entries(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-num-entries");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
int SCM_RESULT;

#line 1220 "extlib.stub"
SCM_RESULT=(Scm_HashCoreNumEntries(SCM_HASH_TABLE_CORE(hash)));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_num_entries__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[294]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_num_entries, NULL, NULL);

static ScmObj extlib_hash_table_clearX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-clear!");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {

#line 1223 "extlib.stub"
Scm_HashCoreClear(SCM_HASH_TABLE_CORE(hash));
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_clearX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[295]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_clearX, NULL, NULL);

static ScmObj extlib_hash_table_get(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("hash-table-get");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1226 "extlib.stub"
{ScmObj v=Scm_HashTableRef(hash,key,fallback);if (SCM_UNBOUNDP(v)){{Scm_Error("%S doesn't have an entry for key %S",hash,key);}}SCM_RESULT=(v);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_get__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[296]),extlib_hash_table_get, NULL, NULL);

static ScmObj extlib_hash_table_putX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("hash-table-put!");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {

#line 1229 "extlib.stub"
Scm_HashTableSet(hash,key,value,0);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_putX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[297]),extlib_hash_table_putX, NULL, NULL);

static ScmObj extlib_hash_table_deleteX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  SCM_ENTER_SUBR("hash-table-delete!");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  {
{
int SCM_RESULT;

#line 1234 "extlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP(Scm_HashTableDelete(hash,key))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_deleteX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[298]),extlib_hash_table_deleteX, NULL, NULL);

static ScmObj extlib_hash_table_existsP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  SCM_ENTER_SUBR("hash-table-exists?");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  {
{
int SCM_RESULT;

#line 1237 "extlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP(Scm_HashTableRef(hash,key,SCM_UNBOUND))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_existsP__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[299]),extlib_hash_table_existsP, NULL, NULL);

static ScmObj hash_table_update_cc(ScmObj result,void** data){{
#line 1240 "extlib.stub"
{ScmDictEntry* e=((ScmDictEntry* )((data)[0]));
((void )(SCM_DICT_SET_VALUE(e,result)));
return (result);}}}
static ScmObj extlib_hash_table_updateX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("hash-table-update!");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  proc_scm = SCM_ARGREF(2);
  proc = (proc_scm);
  if (SCM_ARGCNT > 3+1) {
    fallback_scm = SCM_ARGREF(3);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1246 "extlib.stub"
{ScmDictEntry* e;void* data[1];if (SCM_UNBOUNDP(fallback)){e=(Scm_HashCoreSearch(SCM_HASH_TABLE_CORE(hash),((intptr_t )(key)),SCM_DICT_GET));if ((e)==(NULL)){{Scm_Error("%S doesn't have an entry for key %S",hash,key);}}} else {e=(Scm_HashCoreSearch(SCM_HASH_TABLE_CORE(hash),((intptr_t )(key)),SCM_DICT_CREATE));if (!((e)->value)){{((void )(SCM_DICT_SET_VALUE(e,fallback)));}}}(data)[0]=(((void* )(e)));Scm_VMPushCC(hash_table_update_cc,data,1);SCM_RESULT=(Scm_VMApply1(proc,SCM_DICT_VALUE(e)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_updateX__STUB, 3, 2,SCM_OBJ(&scm__sc.d1003[300]),extlib_hash_table_updateX, NULL, NULL);

static ScmObj extlib_hash_table_pushX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("hash-table-push!");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {

#line 1250 "extlib.stub"
{ScmDictEntry* e=Scm_HashCoreSearch(SCM_HASH_TABLE_CORE(hash),((intptr_t )(key)),SCM_DICT_CREATE);ScmObj prev=(((e)->value)?(SCM_DICT_VALUE(e)):(SCM_NIL));((void )(SCM_DICT_SET_VALUE(e,Scm_Cons(value,prev))));}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_pushX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[301]),extlib_hash_table_pushX, NULL, NULL);

static ScmObj extlib_hash_table_popX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("hash-table-pop!");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1253 "extlib.stub"
{ScmDictEntry* e=Scm_HashCoreSearch(SCM_HASH_TABLE_CORE(hash),((intptr_t )(key)),SCM_DICT_GET);if (!(e)){if (SCM_UNBOUNDP(fallback)){{Scm_Error("%S doesn't have an entry for key %S",hash,key);}}SCM_RESULT=(fallback);}else if(!(SCM_PAIRP(SCM_DICT_VALUE(e)))){if (SCM_UNBOUNDP(fallback)){{Scm_Error("%S's value for key %S is not a pair: %S",hash,key,SCM_DICT_VALUE(e));}}SCM_RESULT=(fallback);} else {SCM_RESULT=(SCM_CAR(SCM_DICT_VALUE(e)));((void )(SCM_DICT_SET_VALUE(e,SCM_CDR(SCM_DICT_VALUE(e)))));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_hash_table_popX__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[302]),extlib_hash_table_popX, NULL, NULL);

static ScmObj hash_table_iter(ScmObj* args,int nargs,void* data){{
#line 1256 "extlib.stub"
{ScmHashIter* iter=((ScmHashIter* )(data));ScmDictEntry* e=
Scm_HashIterNext(iter);ScmObj eofval=
(args)[0];
if ((e)==(NULL)){
return (Scm_Values2(eofval,eofval));} else {
return (Scm_Values2(SCM_DICT_KEY(e),SCM_DICT_VALUE(e)));}}}}
static ScmObj extlib__25hash_table_iter(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("%hash-table-iter");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;

#line 1264 "extlib.stub"
{ScmHashIter* iter=SCM_NEW(ScmHashIter);
Scm_HashIterInit(iter,SCM_HASH_TABLE_CORE(hash));
SCM_RESULT=(Scm_MakeSubr(hash_table_iter,iter,1,0,SCM_OBJ(&scm__sc.d1003[304])));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25hash_table_iter__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[303]),SCM_SUBR_IMMEDIATE_ARG, extlib__25hash_table_iter, NULL, NULL);

static ScmObj extlib_hash_table_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-copy");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_HashTableCopy(hash));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_copy__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[305]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_copy, NULL, NULL);

static ScmObj extlib_hash_table_keys(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-keys");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_HashTableKeys(hash));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_keys__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[306]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_keys, NULL, NULL);

static ScmObj extlib_hash_table_values(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-values");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_HashTableValues(hash));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_values__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[307]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_values, NULL, NULL);

static ScmObj extlib_hash_table_stat(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj hash_scm;
  ScmHashTable* hash;
  SCM_ENTER_SUBR("hash-table-stat");
  hash_scm = SCM_ARGREF(0);
  if (!SCM_HASH_TABLE_P(hash_scm)) Scm_Error("hash table required, but got %S", hash_scm);
  hash = SCM_HASH_TABLE(hash_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_HashTableStat(hash));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_hash_table_stat__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[308]),SCM_SUBR_IMMEDIATE_ARG, extlib_hash_table_stat, NULL, NULL);

static int tree_map_cmp(ScmTreeCore* core,intptr_t x,intptr_t y){{
#line 1352 "extlib.stub"
{ScmObj cmp_proc=SCM_OBJ((core)->data);ScmObj r=
Scm_ApplyRec2(cmp_proc,SCM_OBJ(x),SCM_OBJ(y));
return (SCM_INT_VALUE(r));}}}
static ScmObj extlib__25make_tree_map(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cmp_proc_scm;
  ScmObj cmp_proc;
  SCM_ENTER_SUBR("%make-tree-map");
  cmp_proc_scm = SCM_ARGREF(0);
  cmp_proc = (cmp_proc_scm);
  {
{
ScmObj SCM_RESULT;

#line 1357 "extlib.stub"
SCM_RESULT=(Scm_MakeTreeMap(tree_map_cmp,cmp_proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25make_tree_map__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[309]),extlib__25make_tree_map, NULL, NULL);

static ScmObj extlib_tree_map_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("tree-map-copy");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_TreeMapCopy(tm));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_tree_map_copy__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[310]),SCM_SUBR_IMMEDIATE_ARG, extlib_tree_map_copy, NULL, NULL);

static ScmObj extlib_tree_mapP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("tree-map?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_TREE_MAP_P(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_mapP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[311]),extlib_tree_mapP, NULL, NULL);

static ScmObj extlib_tree_map_get(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("tree-map-get");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1364 "extlib.stub"
{ScmObj v=Scm_TreeMapRef(tm,key,fallback);if (SCM_UNBOUNDP(v)){{Scm_Error("%S doesn't have an entry for key %S",tm,key);}}SCM_RESULT=(v);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_get__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[312]),extlib_tree_map_get, NULL, NULL);

static ScmObj extlib_tree_map_putX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj val_scm;
  ScmObj val;
  SCM_ENTER_SUBR("tree-map-put!");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  val_scm = SCM_ARGREF(2);
  val = (val_scm);
  {

#line 1367 "extlib.stub"
Scm_TreeMapSet(tm,key,val,0);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_putX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[313]),extlib_tree_map_putX, NULL, NULL);

static ScmObj extlib_tree_map_deleteX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  SCM_ENTER_SUBR("tree-map-delete!");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  {
{
int SCM_RESULT;

#line 1370 "extlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP(Scm_TreeMapDelete(tm,key))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_deleteX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[314]),extlib_tree_map_deleteX, NULL, NULL);

static ScmObj tree_map_update_cc(ScmObj result,void** data){{
#line 1373 "extlib.stub"
{ScmDictEntry* e=((ScmDictEntry* )((data)[0]));
((void )(SCM_DICT_SET_VALUE(e,result)));
return (result);}}}
static ScmObj extlib_tree_map_updateX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("tree-map-update!");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  proc_scm = SCM_ARGREF(2);
  proc = (proc_scm);
  if (SCM_ARGCNT > 3+1) {
    fallback_scm = SCM_ARGREF(3);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1378 "extlib.stub"
{ScmDictEntry* e;void* data[1];if (SCM_UNBOUNDP(fallback)){e=(Scm_TreeCoreSearch(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),SCM_DICT_GET));if ((e)==(NULL)){{Scm_Error("%S doesn't have an entry for key %S",tm,key);}}} else {e=(Scm_TreeCoreSearch(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),SCM_DICT_CREATE));if (!((e)->value)){{((void )(SCM_DICT_SET_VALUE(e,fallback)));}}}(data)[0]=(((void* )(e)));Scm_VMPushCC(tree_map_update_cc,data,1);SCM_RESULT=(Scm_VMApply1(proc,SCM_DICT_VALUE(e)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_updateX__STUB, 3, 2,SCM_OBJ(&scm__sc.d1003[315]),extlib_tree_map_updateX, NULL, NULL);

static ScmObj extlib_tree_map_pushX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("tree-map-push!");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {

#line 1381 "extlib.stub"
{ScmDictEntry* e=Scm_TreeCoreSearch(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),SCM_DICT_CREATE);ScmObj prev=(((e)->value)?(SCM_DICT_VALUE(e)):(SCM_NIL));((void )(SCM_DICT_SET_VALUE(e,Scm_Cons(value,prev))));}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_pushX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[316]),extlib_tree_map_pushX, NULL, NULL);

static ScmObj extlib_tree_map_popX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("tree-map-pop!");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 1384 "extlib.stub"
{ScmDictEntry* e=Scm_TreeCoreSearch(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),SCM_DICT_GET);if (!(e)){if (SCM_UNBOUNDP(fallback)){{Scm_Error("%S doesn't have an entry for key %S",tm,key);}}SCM_RESULT=(fallback);}else if(!(SCM_PAIRP(SCM_DICT_VALUE(e)))){if (SCM_UNBOUNDP(fallback)){{Scm_Error("%S's value for key %S is not a pair: %S",tm,key,SCM_DICT_VALUE(e));}}SCM_RESULT=(fallback);} else {SCM_RESULT=(SCM_CAR(SCM_DICT_VALUE(e)));((void )(SCM_DICT_SET_VALUE(e,SCM_CDR(SCM_DICT_VALUE(e)))));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_popX__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[317]),extlib_tree_map_popX, NULL, NULL);

static ScmObj extlib_tree_map_existsP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  SCM_ENTER_SUBR("tree-map-exists?");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  {
{
int SCM_RESULT;

#line 1387 "extlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP(Scm_TreeMapRef(tm,key,SCM_UNBOUND))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_existsP__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[318]),extlib_tree_map_existsP, NULL, NULL);

static ScmObj extlib_tree_map_num_entries(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("tree-map-num-entries");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {
{
int SCM_RESULT;

#line 1390 "extlib.stub"
SCM_RESULT=(Scm_TreeCoreNumEntries(SCM_TREE_MAP_CORE(tm)));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_tree_map_num_entries__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[319]),SCM_SUBR_IMMEDIATE_ARG, extlib_tree_map_num_entries, NULL, NULL);

static ScmObj extlib__25tree_map_bound(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj min_scm;
  int min;
  ScmObj pop_scm;
  int pop;
  SCM_ENTER_SUBR("%tree-map-bound");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  min_scm = SCM_ARGREF(1);
  if (!SCM_BOOLP(min_scm)) Scm_Error("boolean required, but got %S", min_scm);
  min = SCM_BOOL_VALUE(min_scm);
  pop_scm = SCM_ARGREF(2);
  if (!SCM_BOOLP(pop_scm)) Scm_Error("boolean required, but got %S", pop_scm);
  pop = SCM_BOOL_VALUE(pop_scm);
  {
{
ScmObj SCM_RESULT;

#line 1393 "extlib.stub"
{ScmTreeCoreBoundOp op=((min)?(SCM_TREE_CORE_MIN):(SCM_TREE_CORE_MAX));ScmDictEntry* e=
#line 1395 "extlib.stub"
((pop)?(
Scm_TreeCorePopBound(SCM_TREE_MAP_CORE(tm),op)):(
Scm_TreeCoreGetBound(SCM_TREE_MAP_CORE(tm),op)));
if (e){
SCM_RESULT=(Scm_Cons(SCM_DICT_KEY(e),SCM_DICT_VALUE(e)));} else {
SCM_RESULT=(SCM_FALSE);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25tree_map_bound__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[320]),SCM_SUBR_IMMEDIATE_ARG, extlib__25tree_map_bound, NULL, NULL);

static ScmObj tree_map_iter(ScmObj* args,int nargs,void* data){{
#line 1403 "extlib.stub"
{ScmTreeIter* iter=((ScmTreeIter* )(data));ScmDictEntry* e=
((SCM_FALSEP((args)[1]))?(
Scm_TreeIterNext(iter)):(
Scm_TreeIterPrev(iter)));
if (!(e)){
return (Scm_Values2((args)[0],(args)[0]));} else {
return (Scm_Values2(SCM_DICT_KEY(e),SCM_DICT_VALUE(e)));}}}}
static ScmObj extlib__25tree_map_iter(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("%tree-map-iter");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {
{
ScmObj SCM_RESULT;

#line 1412 "extlib.stub"
{ScmTreeIter* iter=SCM_NEW(ScmTreeIter);
Scm_TreeIterInit(iter,SCM_TREE_MAP_CORE(tm),NULL);
SCM_RESULT=(Scm_MakeSubr(tree_map_iter,iter,2,0,SCM_OBJ(&scm__sc.d1003[322])));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25tree_map_iter__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[321]),SCM_SUBR_IMMEDIATE_ARG, extlib__25tree_map_iter, NULL, NULL);

static ScmObj extlib__25tree_map_check_consistency(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("%tree-map-check-consistency");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {
{
ScmObj SCM_RESULT;

#line 1417 "extlib.stub"
Scm_TreeCoreCheckConsistency(SCM_TREE_MAP_CORE(tm));

#line 1418 "extlib.stub"
SCM_RESULT=(SCM_TRUE);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25tree_map_check_consistency__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[323]),SCM_SUBR_IMMEDIATE_ARG, extlib__25tree_map_check_consistency, NULL, NULL);

static ScmObj extlib__25tree_map_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("%tree-map-dump");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {

#line 1421 "extlib.stub"
Scm_TreeMapDump(tm,SCM_CUROUT);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25tree_map_dump__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[324]),SCM_SUBR_IMMEDIATE_ARG, extlib__25tree_map_dump, NULL, NULL);

static ScmObj extlib_tree_map_clearX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  SCM_ENTER_SUBR("tree-map-clear!");
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  {

#line 1424 "extlib.stub"
Scm_TreeCoreClear(SCM_TREE_MAP_CORE(tm));
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_tree_map_clearX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[325]),SCM_SUBR_IMMEDIATE_ARG, extlib_tree_map_clearX, NULL, NULL);

static ScmObj extlib_tree_map_floor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-floor");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  if (SCM_ARGCNT > 3+1) {
    val_fb_scm = SCM_ARGREF(3);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 1450 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(eq)),SCM_RESULT1=(SCM_DICT_VALUE(eq));}else if((lo)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(lo)),SCM_RESULT1=(SCM_DICT_VALUE(lo));} else {SCM_RESULT0=(key_fb),SCM_RESULT1=(val_fb);}}
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_floor__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[326]),extlib_tree_map_floor, NULL, NULL);

static ScmObj extlib_tree_map_floor_key(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  SCM_ENTER_SUBR("tree-map-floor-key");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1452 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(eq));}else if((lo)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(lo));} else {SCM_RESULT=(key_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_floor_key__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[327]),extlib_tree_map_floor_key, NULL, NULL);

static ScmObj extlib_tree_map_floor_value(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-floor-value");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    val_fb_scm = SCM_ARGREF(2);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1454 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(eq));}else if((lo)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(lo));} else {SCM_RESULT=(val_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_floor_value__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[328]),extlib_tree_map_floor_value, NULL, NULL);

static ScmObj extlib_tree_map_ceiling(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-ceiling");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  if (SCM_ARGCNT > 3+1) {
    val_fb_scm = SCM_ARGREF(3);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 1458 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(eq)),SCM_RESULT1=(SCM_DICT_VALUE(eq));}else if((hi)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(hi)),SCM_RESULT1=(SCM_DICT_VALUE(hi));} else {SCM_RESULT0=(key_fb),SCM_RESULT1=(val_fb);}}
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_ceiling__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[329]),extlib_tree_map_ceiling, NULL, NULL);

static ScmObj extlib_tree_map_ceiling_key(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  SCM_ENTER_SUBR("tree-map-ceiling-key");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1460 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(eq));}else if((hi)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(hi));} else {SCM_RESULT=(key_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_ceiling_key__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[330]),extlib_tree_map_ceiling_key, NULL, NULL);

static ScmObj extlib_tree_map_ceiling_value(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-ceiling-value");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    val_fb_scm = SCM_ARGREF(2);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1462 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((eq)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(eq));}else if((hi)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(hi));} else {SCM_RESULT=(val_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_ceiling_value__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[331]),extlib_tree_map_ceiling_value, NULL, NULL);

static ScmObj extlib_tree_map_predecessor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-predecessor");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  if (SCM_ARGCNT > 3+1) {
    val_fb_scm = SCM_ARGREF(3);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 1466 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((lo)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(lo)),SCM_RESULT1=(SCM_DICT_VALUE(lo));} else {SCM_RESULT0=(key_fb),SCM_RESULT1=(val_fb);}}
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_predecessor__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[332]),extlib_tree_map_predecessor, NULL, NULL);

static ScmObj extlib_tree_map_predecessor_key(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  SCM_ENTER_SUBR("tree-map-predecessor-key");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1469 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((lo)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(lo));} else {SCM_RESULT=(key_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_predecessor_key__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[333]),extlib_tree_map_predecessor_key, NULL, NULL);

static ScmObj extlib_tree_map_predecessor_value(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-predecessor-value");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    val_fb_scm = SCM_ARGREF(2);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1472 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((lo)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(lo));} else {SCM_RESULT=(val_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_predecessor_value__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[334]),extlib_tree_map_predecessor_value, NULL, NULL);

static ScmObj extlib_tree_map_successor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-successor");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  if (SCM_ARGCNT > 3+1) {
    val_fb_scm = SCM_ARGREF(3);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 1476 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((hi)!=(NULL)){SCM_RESULT0=(SCM_DICT_KEY(hi)),SCM_RESULT1=(SCM_DICT_VALUE(hi));} else {SCM_RESULT0=(key_fb),SCM_RESULT1=(val_fb);}}
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_successor__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[335]),extlib_tree_map_successor, NULL, NULL);

static ScmObj extlib_tree_map_successor_key(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj key_fb_scm;
  ScmObj key_fb;
  SCM_ENTER_SUBR("tree-map-successor-key");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    key_fb_scm = SCM_ARGREF(2);
  } else {
    key_fb_scm = SCM_FALSE;
  }
  key_fb = (key_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1479 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((hi)!=(NULL)){SCM_RESULT=(SCM_DICT_KEY(hi));} else {SCM_RESULT=(key_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_successor_key__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[336]),extlib_tree_map_successor_key, NULL, NULL);

static ScmObj extlib_tree_map_successor_value(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj tm_scm;
  ScmTreeMap* tm;
  ScmObj key_scm;
  ScmObj key;
  ScmObj val_fb_scm;
  ScmObj val_fb;
  SCM_ENTER_SUBR("tree-map-successor-value");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  tm_scm = SCM_ARGREF(0);
  if (!SCM_TREE_MAP_P(tm_scm)) Scm_Error("tree map required, but got %S", tm_scm);
  tm = SCM_TREE_MAP(tm_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    val_fb_scm = SCM_ARGREF(2);
  } else {
    val_fb_scm = SCM_FALSE;
  }
  val_fb = (val_fb_scm);
  {
{
ScmObj SCM_RESULT;

#line 1482 "extlib.stub"
{ScmDictEntry* lo=NULL;ScmDictEntry* hi=NULL;ScmDictEntry* eq=Scm_TreeCoreClosestEntries(SCM_TREE_MAP_CORE(tm),((intptr_t )(key)),&(lo),&(hi));if ((hi)!=(NULL)){SCM_RESULT=(SCM_DICT_VALUE(hi));} else {SCM_RESULT=(val_fb);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_tree_map_successor_value__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[337]),extlib_tree_map_successor_value, NULL, NULL);

static ScmObj extlib_moduleP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("module?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_MODULEP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_moduleP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[338]),0, extlib_moduleP, NULL, NULL);

static ScmObj extlib_module_name(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-name");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1491 "extlib.stub"
SCM_RESULT=(SCM_OBJ((SCM_MODULE(mod))->name));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_name__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[339]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_name, NULL, NULL);

static ScmObj extlib_module_parents(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-parents");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1493 "extlib.stub"
SCM_RESULT=((mod)->parents);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_parents__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[340]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_parents, NULL, NULL);

static ScmObj extlib_module_precedence_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-precedence-list");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1494 "extlib.stub"
SCM_RESULT=((mod)->mpl);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_precedence_list__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[341]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_precedence_list, NULL, NULL);

static ScmObj extlib_module_imports(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-imports");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1495 "extlib.stub"
SCM_RESULT=((mod)->imported);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_imports__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[342]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_imports, NULL, NULL);

static ScmObj extlib_module_exports(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-exports");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1496 "extlib.stub"
SCM_RESULT=((mod)->exported);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_exports__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[343]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_exports, NULL, NULL);

static ScmObj extlib_module_table(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("module-table");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {
{
ScmObj SCM_RESULT;

#line 1497 "extlib.stub"
SCM_RESULT=(SCM_OBJ((mod)->table));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_module_table__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[344]),SCM_SUBR_IMMEDIATE_ARG, extlib_module_table, NULL, NULL);

static ScmObj extlib_find_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmSymbol* name;
  SCM_ENTER_SUBR("find-module");
  name_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  {
{
ScmModule* SCM_RESULT;

#line 1500 "extlib.stub"
SCM_RESULT=(Scm_FindModule(name,SCM_FIND_MODULE_QUIET));
SCM_RETURN(SCM_MAKE_MAYBE(SCM_OBJ_SAFE, SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_find_module__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[345]),SCM_SUBR_IMMEDIATE_ARG, extlib_find_module, NULL, NULL);

static ScmObj extlib_all_modules(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("all-modules");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_AllModules());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_all_modules__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[346]),SCM_SUBR_IMMEDIATE_ARG, extlib_all_modules, NULL, NULL);

static ScmObj extlib_make_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj if_exists_scm = scm__rc.d1004[36];
  ScmObj if_exists;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("make-module");
  name_scm = SCM_ARGREF(0);
  if (!SCM_MAYBE_P(SCM_SYMBOLP, name_scm)) Scm_Error("symbol or #f required, but got %S", name_scm);
  name = SCM_MAYBE(SCM_SYMBOL, name_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[67])) {
      if_exists_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if_exists = (if_exists_scm);
  {
{
ScmObj SCM_RESULT;

#line 1505 "extlib.stub"
{int error_if_exists=TRUE;
if (SCM_EQ(if_exists,scm__rc.d1004[36])){error_if_exists=(TRUE);}else if(
SCM_FALSEP(if_exists)){error_if_exists=(FALSE);} else {
Scm_TypeError(":if-exists",":error or #f",if_exists);}
SCM_RESULT=(Scm_MakeModule(name,error_if_exists));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_make_module__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[347]),SCM_SUBR_IMMEDIATE_ARG, extlib_make_module, NULL, NULL);

static ScmObj extlib_module_name_TOpath(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmObj name;
  SCM_ENTER_SUBR("module-name->path");
  name_scm = SCM_ARGREF(0);
  name = (name_scm);
  {
{
ScmObj SCM_RESULT;

#line 1512 "extlib.stub"
{ScmSymbol* s=NULL;
if (SCM_SYMBOLP(name)){s=(SCM_SYMBOL(name));}else if(
SCM_IDENTIFIERP(name)){s=((SCM_IDENTIFIER(name))->name);} else {
SCM_TYPE_ERROR(name,"symbol or identifier");}
SCM_RESULT=(Scm_ModuleNameToPath(s));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_module_name_TOpath__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[348]),extlib_module_name_TOpath, NULL, NULL);

static ScmObj extlib_path_TOmodule_name(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj path_scm;
  ScmString* path;
  SCM_ENTER_SUBR("path->module-name");
  path_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(path_scm)) Scm_Error("string required, but got %S", path_scm);
  path = SCM_STRING(path_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_PathToModuleName(path));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_path_TOmodule_name__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[349]),SCM_SUBR_IMMEDIATE_ARG, extlib_path_TOmodule_name, NULL, NULL);

static ScmObj extlib__25export_all(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj module_scm;
  ScmModule* module;
  SCM_ENTER_SUBR("%export-all");
  module_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(module_scm)) Scm_Error("module required, but got %S", module_scm);
  module = SCM_MODULE(module_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ExportAll(module));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25export_all__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[350]),SCM_SUBR_IMMEDIATE_ARG, extlib__25export_all, NULL, NULL);

static ScmObj extlib__25extend_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj module_scm;
  ScmModule* module;
  ScmObj supers_scm;
  ScmObj supers;
  SCM_ENTER_SUBR("%extend-module");
  module_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(module_scm)) Scm_Error("module required, but got %S", module_scm);
  module = SCM_MODULE(module_scm);
  supers_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(supers_scm)) Scm_Error("list required, but got %S", supers_scm);
  supers = (supers_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ExtendModule(module,supers));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25extend_module__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[351]),SCM_SUBR_IMMEDIATE_ARG, extlib__25extend_module, NULL, NULL);

static ScmModule* get_module_from_mod_or_name(ScmObj id){{
#line 1525 "extlib.stub"
if (SCM_MODULEP(id)){return (SCM_MODULE(id));}else if(
SCM_SYMBOLP(id)){return (Scm_FindModule(SCM_SYMBOL(id),0));}else if(
SCM_FALSEP(id)){return (SCM_CURRENT_MODULE());} else {
Scm_Error("module or symbol required, but got: %S",id);
return (NULL);}}}
static ScmObj extlib_global_variable_boundP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_or_name_scm;
  ScmObj mod_or_name;
  ScmObj name_scm;
  ScmSymbol* name;
  SCM_ENTER_SUBR("global-variable-bound?");
  mod_or_name_scm = SCM_ARGREF(0);
  mod_or_name = (mod_or_name_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  {
{
int SCM_RESULT;

#line 1532 "extlib.stub"
SCM_RESULT=(
!(SCM_UNBOUNDP(
Scm_GlobalVariableRef(get_module_from_mod_or_name(mod_or_name),name,0))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_global_variable_boundP__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[352]),extlib_global_variable_boundP, NULL, NULL);

static ScmObj extlib_global_variable_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_or_name_scm;
  ScmObj mod_or_name;
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj stay_in_module_scm;
  int stay_in_module;
  SCM_ENTER_SUBR("global-variable-ref");
  if (SCM_ARGCNT >= 5
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 4 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  mod_or_name_scm = SCM_ARGREF(0);
  mod_or_name = (mod_or_name_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  if (SCM_ARGCNT > 3+1) {
    stay_in_module_scm = SCM_ARGREF(3);
  } else {
    stay_in_module_scm = SCM_FALSE;
  }
  if (!SCM_BOOLP(stay_in_module_scm)) Scm_Error("boolean required, but got %S", stay_in_module_scm);
  stay_in_module = SCM_BOOL_VALUE(stay_in_module_scm);
  {
{
ScmObj SCM_RESULT;

#line 1541 "extlib.stub"
{ScmModule* module=get_module_from_mod_or_name(mod_or_name);int flags=
((stay_in_module)?(SCM_BINDING_STAY_IN_MODULE):(0));ScmObj r=
Scm_GlobalVariableRef(module,name,flags);ScmObj r2=
((SCM_UNBOUNDP(r))?(fallback):(r));
if (SCM_UNBOUNDP(r2)){{
Scm_Error("global variable %S is not bound in module %S",name,module);}}
#line 1548 "extlib.stub"
SCM_RESULT=(r2);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_global_variable_ref__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[353]),extlib_global_variable_ref, NULL, NULL);

static ScmObj extlib__25format(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj fmt_scm;
  ScmString* fmt;
  ScmObj args_scm;
  ScmObj args;
  ScmObj shared_scm;
  int shared;
  SCM_ENTER_SUBR("%format");
  port_scm = SCM_ARGREF(0);
  if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  fmt_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(fmt_scm)) Scm_Error("string required, but got %S", fmt_scm);
  fmt = SCM_STRING(fmt_scm);
  args_scm = SCM_ARGREF(2);
  args = (args_scm);
  shared_scm = SCM_ARGREF(3);
  if (!SCM_BOOLP(shared_scm)) Scm_Error("boolean required, but got %S", shared_scm);
  shared = SCM_BOOL_VALUE(shared_scm);
  {
Scm_Format(port,fmt,args,shared);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib__25format__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[354]),extlib__25format, NULL, NULL);

static ScmObj extlib__25exit(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj code_scm;
  int code;
  SCM_ENTER_SUBR("%exit");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    code_scm = SCM_ARGREF(0);
  } else {
    code_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(code_scm)) Scm_Error("small integer required, but got %S", code_scm);
  code = SCM_INT_VALUE(code_scm);
  {
Scm_Exit(code);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib__25exit__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[355]),SCM_SUBR_IMMEDIATE_ARG, extlib__25exit, NULL, NULL);

static void Scm_VMClass_PRINT(ScmObj obj, ScmPort *port, ScmWriteContext *ctx)
{

#line 1572 "extlib.stub"
{ScmVM* vm=SCM_VM(obj);const char * state;
#line 1574 "extlib.stub"
switch ((vm)->state) {
case SCM_VM_NEW : {state=("new");
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 1576 "extlib.stub"
case SCM_VM_RUNNABLE : {state=("runnable");
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 1577 "extlib.stub"
case SCM_VM_STOPPED : {state=("stopped");
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 1578 "extlib.stub"
case SCM_VM_TERMINATED : {state=("terminated");
#line 542 "../lib/gauche/cgen/cise.scm"
break;}default: {
#line 1579 "extlib.stub"
state=("(unknown state");
#line 542 "../lib/gauche/cgen/cise.scm"
break;}}
#line 1580 "extlib.stub"
Scm_Printf(port,"#<thread %S %s %p>",(vm)->name,state,vm);}
}

SCM_DEFINE_BUILTIN_CLASS(Scm_VMClass, Scm_VMClass_PRINT, NULL, NULL, NULL, SCM_CLASS_DEFAULT_CPL);

static ScmObj Scm_VMClass_name_GET(ScmObj OBJARG)
{
  ScmVM* obj = SCM_VM(OBJARG);
  return SCM_OBJ_SAFE(obj->name);
}

static void Scm_VMClass_name_SET(ScmObj OBJARG, ScmObj value)
{
  ScmVM* obj = SCM_VM(OBJARG);
  obj->name = (value);
}

static ScmObj Scm_VMClass_specific_GET(ScmObj OBJARG)
{
  ScmVM* obj = SCM_VM(OBJARG);
  return SCM_OBJ_SAFE(obj->specific);
}

static void Scm_VMClass_specific_SET(ScmObj OBJARG, ScmObj value)
{
  ScmVM* obj = SCM_VM(OBJARG);
  obj->specific = (value);
}

static ScmClassStaticSlotSpec Scm_VMClass__SLOTS[] = {
  SCM_CLASS_SLOT_SPEC("name", Scm_VMClass_name_GET, Scm_VMClass_name_SET),
  SCM_CLASS_SLOT_SPEC("specific", Scm_VMClass_specific_GET, Scm_VMClass_specific_SET),
  SCM_CLASS_SLOT_SPEC_END()
};

static ScmObj extlib_vm_dump(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vm_scm;
  ScmVM* vm;
  SCM_ENTER_SUBR("vm-dump");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    vm_scm = SCM_ARGREF(0);
  } else {
    vm_scm = SCM_OBJ(Scm_VM());
  }
  if (!SCM_VMP(vm_scm)) Scm_Error("thread required, but got %S", vm_scm);
  vm = SCM_VM(vm_scm);
  {

#line 1585 "extlib.stub"
Scm_VMDump(vm);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_vm_dump__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[356]),SCM_SUBR_IMMEDIATE_ARG, extlib_vm_dump, NULL, NULL);

static ScmObj extlib_vm_get_stack_trace(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vm_scm;
  ScmVM* vm;
  SCM_ENTER_SUBR("vm-get-stack-trace");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    vm_scm = SCM_ARGREF(0);
  } else {
    vm_scm = SCM_OBJ(Scm_VM());
  }
  if (!SCM_VMP(vm_scm)) Scm_Error("thread required, but got %S", vm_scm);
  vm = SCM_VM(vm_scm);
  {
{
ScmObj SCM_RESULT;

#line 1589 "extlib.stub"
SCM_RESULT=(Scm_VMGetStack(vm));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_vm_get_stack_trace__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[357]),SCM_SUBR_IMMEDIATE_ARG, extlib_vm_get_stack_trace, NULL, NULL);

static ScmObj extlib_vm_get_stack_trace_lite(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vm_scm;
  ScmVM* vm;
  SCM_ENTER_SUBR("vm-get-stack-trace-lite");
  if (SCM_ARGCNT >= 2
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 1 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  if (SCM_ARGCNT > 0+1) {
    vm_scm = SCM_ARGREF(0);
  } else {
    vm_scm = SCM_OBJ(Scm_VM());
  }
  if (!SCM_VMP(vm_scm)) Scm_Error("thread required, but got %S", vm_scm);
  vm = SCM_VM(vm_scm);
  {
{
ScmObj SCM_RESULT;

#line 1593 "extlib.stub"
SCM_RESULT=(Scm_VMGetStackLite(vm));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_vm_get_stack_trace_lite__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[358]),SCM_SUBR_IMMEDIATE_ARG, extlib_vm_get_stack_trace_lite, NULL, NULL);

static ScmObj extlib__25vm_show_stack_trace(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj trace_scm;
  ScmObj trace;
  ScmObj port_scm = SCM_OBJ(SCM_CUROUT);
  ScmPort* port;
  ScmObj maxdepth_scm = SCM_MAKE_INT(0);
  int maxdepth;
  ScmObj skip_scm = SCM_MAKE_INT(0);
  int skip;
  ScmObj offset_scm = SCM_MAKE_INT(0);
  int offset;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("%vm-show-stack-trace");
  trace_scm = SCM_ARGREF(0);
  trace = (trace_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[87])) {
      port_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[88])) {
      maxdepth_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[89])) {
      skip_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1004[90])) {
      offset_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  if (!SCM_INTEGERP(maxdepth_scm)) Scm_Error("C integer required, but got %S", maxdepth_scm);
  maxdepth = Scm_GetInteger(maxdepth_scm);
  if (!SCM_INTEGERP(skip_scm)) Scm_Error("C integer required, but got %S", skip_scm);
  skip = Scm_GetInteger(skip_scm);
  if (!SCM_INTEGERP(offset_scm)) Scm_Error("C integer required, but got %S", offset_scm);
  offset = Scm_GetInteger(offset_scm);
  {

#line 1601 "extlib.stub"
Scm_ShowStackTrace(port,trace,maxdepth,skip,offset,SCM_STACK_TRACE_FORMAT_ORIGINAL);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib__25vm_show_stack_trace__STUB, 1, 1,SCM_OBJ(&scm__sc.d1003[363]),extlib__25vm_show_stack_trace, NULL, NULL);

static ScmObj extlib_vm_set_default_exception_handler(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vm_scm;
  ScmVM* vm;
  ScmObj handler_scm;
  ScmObj handler;
  SCM_ENTER_SUBR("vm-set-default-exception-handler");
  vm_scm = SCM_ARGREF(0);
  if (!SCM_VMP(vm_scm)) Scm_Error("thread required, but got %S", vm_scm);
  vm = SCM_VM(vm_scm);
  handler_scm = SCM_ARGREF(1);
  handler = (handler_scm);
  {

#line 1605 "extlib.stub"
if (!((SCM_FALSEP(handler))||(SCM_PROCEDUREP(handler)))){{
SCM_TYPE_ERROR(handler,"a procedure or #f");}}

#line 1607 "extlib.stub"
(vm)->defaultEscapeHandler=(handler);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(extlib_vm_set_default_exception_handler__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[364]),extlib_vm_set_default_exception_handler, NULL, NULL);

static ScmObj extlib_current_load_history(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("current-load-history");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CurrentLoadHistory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_current_load_history__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[365]),SCM_SUBR_IMMEDIATE_ARG, extlib_current_load_history, NULL, NULL);

static ScmObj extlib_current_load_next(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("current-load-next");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CurrentLoadNext());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_current_load_next__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[366]),SCM_SUBR_IMMEDIATE_ARG, extlib_current_load_next, NULL, NULL);

static ScmObj extlib_current_load_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("current-load-port");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CurrentLoadPort());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_current_load_port__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[367]),SCM_SUBR_IMMEDIATE_ARG, extlib_current_load_port, NULL, NULL);

static ScmObj extlib__25vm_make_parameter_slot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("%vm-make-parameter-slot");
  {
int SCM_RESULT0;
int SCM_RESULT1;
{

#line 1615 "extlib.stub"
{ScmParameterLoc loc;
Scm_MakeParameterSlot(Scm_VM(),&(loc));
SCM_RESULT0=((loc).index),SCM_RESULT1=(
(loc).id);}
}
SCM_RETURN(Scm_Values2(Scm_MakeInteger(SCM_RESULT0),Scm_MakeInteger(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBRX(extlib__25vm_make_parameter_slot__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[368]),SCM_SUBR_IMMEDIATE_ARG, extlib__25vm_make_parameter_slot, NULL, NULL);

static ScmObj extlib__25vm_parameter_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj index_scm;
  int index;
  ScmObj id_scm;
  int id;
  SCM_ENTER_SUBR("%vm-parameter-ref");
  index_scm = SCM_ARGREF(0);
  if (!SCM_INTEGERP(index_scm)) Scm_Error("C integer required, but got %S", index_scm);
  index = Scm_GetInteger(index_scm);
  id_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(id_scm)) Scm_Error("C integer required, but got %S", id_scm);
  id = Scm_GetInteger(id_scm);
  {
{
ScmObj SCM_RESULT;

#line 1621 "extlib.stub"
{ScmParameterLoc loc;
(loc).index=(index),
(loc).id=(id);
SCM_RESULT=(Scm_ParameterRef(Scm_VM(),&(loc)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25vm_parameter_ref__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[369]),SCM_SUBR_IMMEDIATE_ARG, extlib__25vm_parameter_ref, NULL, NULL);

static ScmObj extlib__25vm_parameter_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj index_scm;
  int index;
  ScmObj id_scm;
  int id;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("%vm-parameter-set!");
  index_scm = SCM_ARGREF(0);
  if (!SCM_INTEGERP(index_scm)) Scm_Error("C integer required, but got %S", index_scm);
  index = Scm_GetInteger(index_scm);
  id_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(id_scm)) Scm_Error("C integer required, but got %S", id_scm);
  id = Scm_GetInteger(id_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {
{
ScmObj SCM_RESULT;

#line 1627 "extlib.stub"
{ScmParameterLoc loc;
(loc).index=(index),
(loc).id=(id);
SCM_RESULT=(Scm_ParameterSet(Scm_VM(),&(loc),value));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib__25vm_parameter_setX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[370]),extlib__25vm_parameter_setX, NULL, NULL);

static ScmObj extlib_gauche_version(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-version");
  {
{
const char * SCM_RESULT;

#line 1637 "extlib.stub"
SCM_RESULT=(GAUCHE_VERSION);
SCM_RETURN(SCM_MAKE_STR_COPYING(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_version__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[371]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_version, NULL, NULL);

static ScmObj extlib_gauche_architecture(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-architecture");
  {
{
const char * SCM_RESULT;

#line 1638 "extlib.stub"
SCM_RESULT=(GAUCHE_ARCH);
SCM_RETURN(SCM_MAKE_STR_COPYING(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_architecture__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[372]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_architecture, NULL, NULL);

static ScmObj extlib_gauche_library_directory(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-library-directory");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_LibraryDirectory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_library_directory__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[373]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_library_directory, NULL, NULL);

static ScmObj extlib_gauche_architecture_directory(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-architecture-directory");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ArchitectureDirectory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_architecture_directory__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[374]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_architecture_directory, NULL, NULL);

static ScmObj extlib_gauche_site_library_directory(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-site-library-directory");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_SiteLibraryDirectory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_site_library_directory__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[375]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_site_library_directory, NULL, NULL);

static ScmObj extlib_gauche_site_architecture_directory(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-site-architecture-directory");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_SiteArchitectureDirectory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_site_architecture_directory__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[376]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_site_architecture_directory, NULL, NULL);

static ScmObj extlib_gauche_dso_suffix(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gauche-dso-suffix");
  {
{
const char * SCM_RESULT;

#line 1643 "extlib.stub"
SCM_RESULT=(SHLIB_SO_SUFFIX);
SCM_RETURN(SCM_MAKE_STR_COPYING(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gauche_dso_suffix__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[377]),SCM_SUBR_IMMEDIATE_ARG, extlib_gauche_dso_suffix, NULL, NULL);

static ScmObj extlib__25gauche_runtime_directory(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("%gauche-runtime-directory");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm__RuntimeDirectory());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib__25gauche_runtime_directory__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[378]),SCM_SUBR_IMMEDIATE_ARG, extlib__25gauche_runtime_directory, NULL, NULL);

static ScmObj extlib_current_thread(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("current-thread");
  {
{
ScmObj SCM_RESULT;

#line 1651 "extlib.stub"
SCM_RESULT=(SCM_OBJ(Scm_VM()));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_current_thread__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[379]),SCM_SUBR_IMMEDIATE_ARG, extlib_current_thread, NULL, NULL);

static ScmObj extlib_unwrap_syntax(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj form_scm;
  ScmObj form;
  SCM_ENTER_SUBR("unwrap-syntax");
  form_scm = SCM_ARGREF(0);
  form = (form_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_UnwrapSyntax(form));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_unwrap_syntax__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[380]),extlib_unwrap_syntax, NULL, NULL);

static ScmObj extlib_foreign_pointer_attributes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fp_scm;
  ScmForeignPointer* fp;
  SCM_ENTER_SUBR("foreign-pointer-attributes");
  fp_scm = SCM_ARGREF(0);
  if (!SCM_FOREIGN_POINTER_P(fp_scm)) Scm_Error("foreign pointer required, but got %S", fp_scm);
  fp = SCM_FOREIGN_POINTER(fp_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ForeignPointerAttr(fp));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_foreign_pointer_attributes__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[381]),SCM_SUBR_IMMEDIATE_ARG, extlib_foreign_pointer_attributes, NULL, NULL);

static ScmObj extlib_foreign_pointer_attribute_get(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fp_scm;
  ScmForeignPointer* fp;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("foreign-pointer-attribute-get");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  fp_scm = SCM_ARGREF(0);
  if (!SCM_FOREIGN_POINTER_P(fp_scm)) Scm_Error("foreign pointer required, but got %S", fp_scm);
  fp = SCM_FOREIGN_POINTER(fp_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ForeignPointerAttrGet(fp,key,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_foreign_pointer_attribute_get__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[382]),extlib_foreign_pointer_attribute_get, NULL, NULL);

static ScmObj extlib_foreign_pointer_attribute_set(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj fp_scm;
  ScmForeignPointer* fp;
  ScmObj key_scm;
  ScmObj key;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("foreign-pointer-attribute-set");
  fp_scm = SCM_ARGREF(0);
  if (!SCM_FOREIGN_POINTER_P(fp_scm)) Scm_Error("foreign pointer required, but got %S", fp_scm);
  fp = SCM_FOREIGN_POINTER(fp_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ForeignPointerAttrSet(fp,key,value));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_foreign_pointer_attribute_set__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[383]),extlib_foreign_pointer_attribute_set, NULL, NULL);

static ScmObj extlib_gc(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gc");
  {
GC_gcollect();
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_gc__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[384]),SCM_SUBR_IMMEDIATE_ARG, extlib_gc, NULL, NULL);

static ScmObj extlib_gc_stat(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gc-stat");
  {
{
ScmObj SCM_RESULT;

#line 1674 "extlib.stub"
SCM_RESULT=(
SCM_LIST4(
SCM_LIST2(scm__rc.d1004[91],
Scm_MakeIntegerFromUI(((u_long )(GC_get_heap_size())))),
SCM_LIST2(scm__rc.d1004[92],
Scm_MakeIntegerFromUI(((u_long )(GC_get_free_bytes())))),
SCM_LIST2(scm__rc.d1004[93],
Scm_MakeIntegerFromUI(((u_long )(GC_get_bytes_since_gc())))),
SCM_LIST2(scm__rc.d1004[94],
Scm_MakeIntegerFromUI(((u_long )(GC_get_total_bytes()))))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_gc_stat__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[385]),SCM_SUBR_IMMEDIATE_ARG, extlib_gc_stat, NULL, NULL);

static ScmObj extlib_profiler_start(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("profiler-start");
  {
Scm_ProfilerStart();
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_profiler_start__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[390]),SCM_SUBR_IMMEDIATE_ARG, extlib_profiler_start, NULL, NULL);

static ScmObj extlib_profiler_stop(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("profiler-stop");
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_ProfilerStop());
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_profiler_stop__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[391]),SCM_SUBR_IMMEDIATE_ARG, extlib_profiler_stop, NULL, NULL);

static ScmObj extlib_profiler_reset(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("profiler-reset");
  {
Scm_ProfilerReset();
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(extlib_profiler_reset__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[392]),SCM_SUBR_IMMEDIATE_ARG, extlib_profiler_reset, NULL, NULL);

static ScmObj extlib_subrP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("subr?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_SUBRP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_subrP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[393]),extlib_subrP, NULL, NULL);

static ScmObj extlib_closureP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("closure?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_CLOSUREP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_closureP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[394]),extlib_closureP, NULL, NULL);

static ScmObj extlib_toplevel_closureP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("toplevel-closure?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 1694 "extlib.stub"
SCM_RESULT=((SCM_CLOSUREP(obj))&&(((SCM_CLOSURE(obj))->env)==(NULL)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(extlib_toplevel_closureP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[395]),extlib_toplevel_closureP, NULL, NULL);

static ScmObj extlib_closure_code(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj clo_scm;
  ScmClosure* clo;
  SCM_ENTER_SUBR("closure-code");
  clo_scm = SCM_ARGREF(0);
  if (!SCM_CLOSUREP(clo_scm)) Scm_Error("closure required, but got %S", clo_scm);
  clo = SCM_CLOSURE(clo_scm);
  {
{
ScmObj SCM_RESULT;

#line 1696 "extlib.stub"
SCM_RESULT=((clo)->code);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_closure_code__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[396]),SCM_SUBR_IMMEDIATE_ARG, extlib_closure_code, NULL, NULL);

static ScmObj extlib_method_code(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj m_scm;
  ScmMethod* m;
  SCM_ENTER_SUBR("method-code");
  m_scm = SCM_ARGREF(0);
  if (!SCM_METHODP(m_scm)) Scm_Error("method required, but got %S", m_scm);
  m = SCM_METHOD(m_scm);
  {
{
ScmObj SCM_RESULT;

#line 1698 "extlib.stub"
if ((m)->func){
#line 1700 "extlib.stub"
SCM_RESULT=(SCM_FALSE);} else {
SCM_RESULT=(SCM_OBJ((m)->data));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_method_code__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[397]),SCM_SUBR_IMMEDIATE_ARG, extlib_method_code, NULL, NULL);

static ScmObj extlib_procedure_info(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmProcedure* proc;
  SCM_ENTER_SUBR("procedure-info");
  proc_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(proc_scm)) Scm_Error("procedure required, but got %S", proc_scm);
  proc = SCM_PROCEDURE(proc_scm);
  {
{
ScmObj SCM_RESULT;

#line 1704 "extlib.stub"
SCM_RESULT=(SCM_PROCEDURE_INFO(proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(extlib_procedure_info__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[398]),SCM_SUBR_IMMEDIATE_ARG, extlib_procedure_info, NULL, NULL);

void Scm_Init_extlib(ScmModule *mod){

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("macroexpand")), SCM_OBJ(&extlib_macroexpand__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("macroexpand-1")), SCM_OBJ(&extlib_macroexpand_1__STUB), 0);
  scm__rc.d1004[0] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[2]))); /* eqv? */
  scm__rc.d1004[1] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[3]))); /* eq? */
  scm__rc.d1004[2] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[4]))); /* equal? */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compare")), SCM_OBJ(&extlib_compare__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("ash")), SCM_OBJ(&extlib_ash__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("lognot")), SCM_OBJ(&extlib_lognot__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("logand")), SCM_OBJ(&extlib_logand__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("logior")), SCM_OBJ(&extlib_logior__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("logxor")), SCM_OBJ(&extlib_logxor__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("logcount")), SCM_OBJ(&extlib_logcount__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("integer-length")), SCM_OBJ(&extlib_integer_length__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("fixnum?")), SCM_OBJ(&extlib_fixnumP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("bignum?")), SCM_OBJ(&extlib_bignumP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("flonum?")), SCM_OBJ(&extlib_flonumP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("finite?")), SCM_OBJ(&extlib_finiteP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("infinite?")), SCM_OBJ(&extlib_infiniteP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("nan?")), SCM_OBJ(&extlib_nanP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("fixnum-width")), SCM_OBJ(&extlib_fixnum_width__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("least-fixnum")), SCM_OBJ(&extlib_least_fixnum__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("greatest-fixnum")), SCM_OBJ(&extlib_greatest_fixnum__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("inexact-/")), SCM_OBJ(&extlib_inexact__2f__STUB), 0);
  scm__rc.d1004[3] = 
Scm_MakeFlonum(0.0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("+.")), SCM_OBJ(&extlib__2b_2e__STUB), SCM_BINDING_INLINABLE);
  scm__rc.d1004[4] = 
Scm_MakeFlonum(1.0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("*.")), SCM_OBJ(&extlib__2a_2e__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("-.")), SCM_OBJ(&extlib___2e__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("/.")), SCM_OBJ(&extlib__2f_2e__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("clamp")), SCM_OBJ(&extlib_clamp__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("floor->exact")), SCM_OBJ(&extlib_floor_TOexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("ceiling->exact")), SCM_OBJ(&extlib_ceiling_TOexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("truncate->exact")), SCM_OBJ(&extlib_truncate_TOexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("round->exact")), SCM_OBJ(&extlib_round_TOexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("decode-float")), SCM_OBJ(&extlib_decode_float__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("native-endian")), SCM_OBJ(&extlib_native_endian__STUB), 0);
#if SCM_DEBUG_HELPER
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%bignum-dump")), SCM_OBJ(&extlib__25bignum_dump__STUB), 0);
#endif /* SCM_DEBUG_HELPER */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("min&max")), SCM_OBJ(&extlib_min_26max__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("quotient&remainder")), SCM_OBJ(&extlib_quotient_26remainder__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("boolean")), SCM_OBJ(&extlib_boolean__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("proper-list?")), SCM_OBJ(&extlib_proper_listP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("dotted-list?")), SCM_OBJ(&extlib_dotted_listP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("circular-list?")), SCM_OBJ(&extlib_circular_listP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-list")), SCM_OBJ(&extlib_make_list__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("acons")), SCM_OBJ(&extlib_acons__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("last-pair")), SCM_OBJ(&extlib_last_pair__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list-copy")), SCM_OBJ(&extlib_list_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list*")), SCM_OBJ(&extlib_list_2a__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%delete")), SCM_OBJ(&extlib__25delete__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%delete!")), SCM_OBJ(&extlib__25deleteX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%delete-duplicates")), SCM_OBJ(&extlib__25delete_duplicates__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%delete-duplicates!")), SCM_OBJ(&extlib__25delete_duplicatesX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%alist-delete")), SCM_OBJ(&extlib__25alist_delete__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%alist-delete!")), SCM_OBJ(&extlib__25alist_deleteX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("append!")), SCM_OBJ(&extlib_appendX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("reverse!")), SCM_OBJ(&extlib_reverseX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%sort")), SCM_OBJ(&extlib__25sort__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%sort!")), SCM_OBJ(&extlib__25sortX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("monotonic-merge")), SCM_OBJ(&extlib_monotonic_merge__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gensym")), SCM_OBJ(&extlib_gensym__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("symbol-interned?")), SCM_OBJ(&extlib_symbol_internedP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string->uninterned-symbol")), SCM_OBJ(&extlib_string_TOuninterned_symbol__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("symbol-sans-prefix")), SCM_OBJ(&extlib_symbol_sans_prefix__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("keyword?")), SCM_OBJ(&extlib_keywordP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-keyword")), SCM_OBJ(&extlib_make_keyword__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("get-keyword")), SCM_OBJ(&extlib_get_keyword__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("delete-keyword")), SCM_OBJ(&extlib_delete_keyword__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("delete-keyword!")), SCM_OBJ(&extlib_delete_keywordX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("keyword->string")), SCM_OBJ(&extlib_keyword_TOstring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identifier?")), SCM_OBJ(&extlib_identifierP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identifier->symbol")), SCM_OBJ(&extlib_identifier_TOsymbol__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("digit->integer")), SCM_OBJ(&extlib_digit_TOinteger__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("integer->digit")), SCM_OBJ(&extlib_integer_TOdigit__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("ucs->char")), SCM_OBJ(&extlib_ucs_TOchar__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char->ucs")), SCM_OBJ(&extlib_char_TOucs__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-character-encoding")), SCM_OBJ(&extlib_gauche_character_encoding__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("supported-character-encodings")), SCM_OBJ(&extlib_supported_character_encodings__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("supported-character-encoding?")), SCM_OBJ(&extlib_supported_character_encodingP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-title-case?")), SCM_OBJ(&extlib_char_title_caseP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-titlecase")), SCM_OBJ(&extlib_char_titlecase__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-foldcase")), SCM_OBJ(&extlib_char_foldcase__STUB), 0);
  scm__rc.d1004[5] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[79]))); /* Lu */
  scm__rc.d1004[6] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[80]))); /* Ll */
  scm__rc.d1004[7] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[81]))); /* Lt */
  scm__rc.d1004[8] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[82]))); /* Lm */
  scm__rc.d1004[9] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[83]))); /* Lo */
  scm__rc.d1004[10] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[84]))); /* Mn */
  scm__rc.d1004[11] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[85]))); /* Mc */
  scm__rc.d1004[12] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[86]))); /* Me */
  scm__rc.d1004[13] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[87]))); /* Nd */
  scm__rc.d1004[14] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[88]))); /* Nl */
  scm__rc.d1004[15] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[89]))); /* No */
  scm__rc.d1004[16] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[90]))); /* Pc */
  scm__rc.d1004[17] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[91]))); /* Pd */
  scm__rc.d1004[18] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[92]))); /* Ps */
  scm__rc.d1004[19] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[93]))); /* Pe */
  scm__rc.d1004[20] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[94]))); /* Pi */
  scm__rc.d1004[21] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[95]))); /* Pf */
  scm__rc.d1004[22] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[96]))); /* Po */
  scm__rc.d1004[23] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[97]))); /* Sm */
  scm__rc.d1004[24] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[98]))); /* Sc */
  scm__rc.d1004[25] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[99]))); /* Sk */
  scm__rc.d1004[26] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[100]))); /* So */
  scm__rc.d1004[27] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[101]))); /* Zs */
  scm__rc.d1004[28] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[102]))); /* Zl */
  scm__rc.d1004[29] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[103]))); /* Zp */
  scm__rc.d1004[30] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[104]))); /* Cc */
  scm__rc.d1004[31] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[105]))); /* Cf */
  scm__rc.d1004[32] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[106]))); /* Cs */
  scm__rc.d1004[33] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[107]))); /* Co */
  scm__rc.d1004[34] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[108]))); /* Cn */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-general-category")), SCM_OBJ(&extlib_char_general_category__STUB), SCM_BINDING_INLINABLE);
  scm__rc.d1004[35] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[109]))); /* *char-code-max* */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[35]), Scm_MakeInteger(SCM_CHAR_MAX), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-set?")), SCM_OBJ(&extlib_char_setP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-equal?")), SCM_OBJ(&extlib__25char_set_equalP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set<=?")), SCM_OBJ(&extlib__25char_set_LT_3dP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-set")), SCM_OBJ(&extlib_char_set__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-set-copy")), SCM_OBJ(&extlib_char_set_copy__STUB), 0);
  scm__rc.d1004[36] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[115]))); /* error */
  scm__rc.d1004[37] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[116]))); /* posix-bracket */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-char-set")), SCM_OBJ(&extlib_read_char_set__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-add-chars!")), SCM_OBJ(&extlib__25char_set_add_charsX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-add-range!")), SCM_OBJ(&extlib__25char_set_add_rangeX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-set-contains?")), SCM_OBJ(&extlib_char_set_containsP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-add!")), SCM_OBJ(&extlib__25char_set_addX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-complement!")), SCM_OBJ(&extlib__25char_set_complementX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-ranges")), SCM_OBJ(&extlib__25char_set_ranges__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-predefined")), SCM_OBJ(&extlib__25char_set_predefined__STUB), 0);
#if SCM_DEBUG_HELPER
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%char-set-dump")), SCM_OBJ(&extlib__25char_set_dump__STUB), 0);
#endif /* SCM_DEBUG_HELPER */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-incomplete?")), SCM_OBJ(&extlib_string_incompleteP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-immutable?")), SCM_OBJ(&extlib_string_immutableP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-incomplete->complete!")), SCM_OBJ(&extlib_string_incomplete_TOcompleteX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-complete->incomplete")), SCM_OBJ(&extlib_string_complete_TOincomplete__STUB), 0);
  scm__rc.d1004[38] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[130]))); /* omit */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-incomplete->complete")), SCM_OBJ(&extlib_string_incomplete_TOcomplete__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-size")), SCM_OBJ(&extlib_string_size__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-byte-string")), SCM_OBJ(&extlib_make_byte_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-byte-ref")), SCM_OBJ(&extlib_string_byte_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("byte-substring")), SCM_OBJ(&extlib_byte_substring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%string-replace-body!")), SCM_OBJ(&extlib__25string_replace_bodyX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%maybe-substring")), SCM_OBJ(&extlib__25maybe_substring__STUB), 0);
  scm__rc.d1004[39] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[138]))); /* infix */
  scm__rc.d1004[40] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[140]))); /* prefix */
  scm__rc.d1004[41] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[141]))); /* suffix */
  scm__rc.d1004[42] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[142]))); /* strict-infix */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-join")), SCM_OBJ(&extlib_string_join__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%hash-string")), SCM_OBJ(&extlib__25hash_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%string-split-by-char")), SCM_OBJ(&extlib__25string_split_by_char__STUB), 0);
  scm__rc.d1004[43] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[145]))); /* index */
  scm__rc.d1004[44] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[147]))); /* both */
  scm__rc.d1004[45] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[148]))); /* after* */
  scm__rc.d1004[46] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[149]))); /* before* */
  scm__rc.d1004[47] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[150]))); /* after */
  scm__rc.d1004[48] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[151]))); /* before */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-scan")), SCM_OBJ(&extlib_string_scan__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-string-pointer")), SCM_OBJ(&extlib_make_string_pointer__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer?")), SCM_OBJ(&extlib_string_pointerP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-ref")), SCM_OBJ(&extlib_string_pointer_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-next!")), SCM_OBJ(&extlib_string_pointer_nextX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-prev!")), SCM_OBJ(&extlib_string_pointer_prevX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-set!")), SCM_OBJ(&extlib_string_pointer_setX__STUB), 0);
  scm__rc.d1004[49] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[150]))); /* after */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-substring")), SCM_OBJ(&extlib_string_pointer_substring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-index")), SCM_OBJ(&extlib_string_pointer_index__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-copy")), SCM_OBJ(&extlib_string_pointer_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-pointer-byte-index")), SCM_OBJ(&extlib_string_pointer_byte_index__STUB), 0);
#if SCM_DEBUG_HELPER
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%string-pointer-dump")), SCM_OBJ(&extlib__25string_pointer_dump__STUB), 0);
#endif /* SCM_DEBUG_HELPER */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp?")), SCM_OBJ(&extlib_regexpP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regmatch?")), SCM_OBJ(&extlib_regmatchP__STUB), 0);
  scm__rc.d1004[50] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[164]))); /* case-fold */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string->regexp")), SCM_OBJ(&extlib_string_TOregexp__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%regexp-pattern")), SCM_OBJ(&extlib__25regexp_pattern__STUB), 0);
  Scm_SetterSet(SCM_PROCEDURE(&extlib__25regexp_pattern__STUB), SCM_PROCEDURE(&extlib__25regexp_pattern_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp-ast")), SCM_OBJ(&extlib_regexp_ast__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp-case-fold?")), SCM_OBJ(&extlib_regexp_case_foldP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp-parse")), SCM_OBJ(&extlib_regexp_parse__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp-compile")), SCM_OBJ(&extlib_regexp_compile__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("regexp-optimize")), SCM_OBJ(&extlib_regexp_optimize__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch")), SCM_OBJ(&extlib_rxmatch__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-substring")), SCM_OBJ(&extlib_rxmatch_substring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-start")), SCM_OBJ(&extlib_rxmatch_start__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-end")), SCM_OBJ(&extlib_rxmatch_end__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-before")), SCM_OBJ(&extlib_rxmatch_before__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-after")), SCM_OBJ(&extlib_rxmatch_after__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rxmatch-num-matches")), SCM_OBJ(&extlib_rxmatch_num_matches__STUB), 0);
#if SCM_DEBUG_HELPER
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%regexp-dump")), SCM_OBJ(&extlib__25regexp_dump__STUB), 0);
#endif /* SCM_DEBUG_HELPER */
#if SCM_DEBUG_HELPER
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%regmatch-dump")), SCM_OBJ(&extlib__25regmatch_dump__STUB), 0);
#endif /* SCM_DEBUG_HELPER */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector-copy")), SCM_OBJ(&extlib_vector_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-weak-vector")), SCM_OBJ(&extlib_make_weak_vector__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("weak-vector-length")), SCM_OBJ(&extlib_weak_vector_length__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("weak-vector-ref")), SCM_OBJ(&extlib_weak_vector_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("weak-vector-set!")), SCM_OBJ(&extlib_weak_vector_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%uvector-ref")), SCM_OBJ(&extlib__25uvector_ref__STUB), SCM_BINDING_INLINABLE);
  scm__rc.d1004[51] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[186]))); /* SCM_UVECTOR_S8 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[51]), Scm_MakeInteger(SCM_UVECTOR_S8), SCM_BINDING_CONST);

  scm__rc.d1004[52] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[187]))); /* SCM_UVECTOR_U8 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[52]), Scm_MakeInteger(SCM_UVECTOR_U8), SCM_BINDING_CONST);

  scm__rc.d1004[53] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[188]))); /* SCM_UVECTOR_S16 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[53]), Scm_MakeInteger(SCM_UVECTOR_S16), SCM_BINDING_CONST);

  scm__rc.d1004[54] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[189]))); /* SCM_UVECTOR_U16 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[54]), Scm_MakeInteger(SCM_UVECTOR_U16), SCM_BINDING_CONST);

  scm__rc.d1004[55] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[190]))); /* SCM_UVECTOR_S32 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[55]), Scm_MakeInteger(SCM_UVECTOR_S32), SCM_BINDING_CONST);

  scm__rc.d1004[56] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[191]))); /* SCM_UVECTOR_U32 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[56]), Scm_MakeInteger(SCM_UVECTOR_U32), SCM_BINDING_CONST);

  scm__rc.d1004[57] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[192]))); /* SCM_UVECTOR_S64 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[57]), Scm_MakeInteger(SCM_UVECTOR_S64), SCM_BINDING_CONST);

  scm__rc.d1004[58] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[193]))); /* SCM_UVECTOR_U64 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[58]), Scm_MakeInteger(SCM_UVECTOR_U64), SCM_BINDING_CONST);

  scm__rc.d1004[59] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[194]))); /* SCM_UVECTOR_F16 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[59]), Scm_MakeInteger(SCM_UVECTOR_F16), SCM_BINDING_CONST);

  scm__rc.d1004[60] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[195]))); /* SCM_UVECTOR_F32 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[60]), Scm_MakeInteger(SCM_UVECTOR_F32), SCM_BINDING_CONST);

  scm__rc.d1004[61] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[196]))); /* SCM_UVECTOR_F64 */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[61]), Scm_MakeInteger(SCM_UVECTOR_F64), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("uvector-length")), SCM_OBJ(&extlib_uvector_length__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("uvector-immutable?")), SCM_OBJ(&extlib_uvector_immutableP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("setter")), SCM_OBJ(&extlib_setter__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&extlib_setter__STUB), SCM_PROCEDURE(&extlib_setter_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("has-setter?")), SCM_OBJ(&extlib_has_setterP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identity")), SCM_OBJ(&extlib_identity__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("promise?")), SCM_OBJ(&extlib_promiseP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eager")), SCM_OBJ(&extlib_eager__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("promise-kind")), SCM_OBJ(&extlib_promise_kind__STUB), 0);
  Scm_SetterSet(SCM_PROCEDURE(&extlib_promise_kind__STUB), SCM_PROCEDURE(&extlib_promise_kind_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eof-object")), SCM_OBJ(&extlib_eof_object__STUB), 0);
  scm__rc.d1004[62] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[208]))); /* if-does-not-exist */
  scm__rc.d1004[63] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[209]))); /* buffering */
  scm__rc.d1004[64] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[210]))); /* character */
  scm__rc.d1004[65] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[211]))); /* element-type */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%open-input-file")), SCM_OBJ(&extlib__25open_input_file__STUB), 0);
  scm__rc.d1004[66] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[213]))); /* supersede */
  scm__rc.d1004[67] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[214]))); /* if-exists */
  scm__rc.d1004[68] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[215]))); /* create */
  scm__rc.d1004[69] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[216]))); /* mode */
  scm__rc.d1004[70] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[218]))); /* overwrite */
  scm__rc.d1004[71] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[219]))); /* append */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%open-output-file")), SCM_OBJ(&extlib__25open_output_file__STUB), 0);
  scm__rc.d1004[72] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[220]))); /* private? */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-input-string")), SCM_OBJ(&extlib_open_input_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-output-string")), SCM_OBJ(&extlib_open_output_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("get-output-string")), SCM_OBJ(&extlib_get_output_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("get-output-byte-string")), SCM_OBJ(&extlib_get_output_byte_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("get-remaining-input-string")), SCM_OBJ(&extlib_get_remaining_input_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-coding-aware-port")), SCM_OBJ(&extlib_open_coding_aware_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-input-buffered-port")), SCM_OBJ(&extlib_open_input_buffered_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-output-buffered-port")), SCM_OBJ(&extlib_open_output_buffered_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("flush")), SCM_OBJ(&extlib_flush__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("flush-all-ports")), SCM_OBJ(&extlib_flush_all_ports__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-closed?")), SCM_OBJ(&extlib_port_closedP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-case-fold-set!")), SCM_OBJ(&extlib_port_case_fold_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-error-port")), SCM_OBJ(&extlib_current_error_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("standard-input-port")), SCM_OBJ(&extlib_standard_input_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("standard-output-port")), SCM_OBJ(&extlib_standard_output_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("standard-error-port")), SCM_OBJ(&extlib_standard_error_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-name")), SCM_OBJ(&extlib_port_name__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-current-line")), SCM_OBJ(&extlib_port_current_line__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-file-number")), SCM_OBJ(&extlib_port_file_number__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-fd-dup!")), SCM_OBJ(&extlib_port_fd_dupX__STUB), 0);
  scm__rc.d1004[73] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[241]))); /* SEEK_SET */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[73]), Scm_MakeInteger(SEEK_SET), SCM_BINDING_CONST);

  scm__rc.d1004[74] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[242]))); /* SEEK_CUR */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[74]), Scm_MakeInteger(SEEK_CUR), SCM_BINDING_CONST);

  scm__rc.d1004[75] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[243]))); /* SEEK_END */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[75]), Scm_MakeInteger(SEEK_END), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-seek")), SCM_OBJ(&extlib_port_seek__STUB), 0);
  scm__rc.d1004[76] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[246]))); /* file */
  scm__rc.d1004[77] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[247]))); /* proc */
  scm__rc.d1004[78] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[248]))); /* string */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-type")), SCM_OBJ(&extlib_port_type__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port-buffering")), SCM_OBJ(&extlib_port_buffering__STUB), 0);
  Scm_SetterSet(SCM_PROCEDURE(&extlib_port_buffering__STUB), SCM_PROCEDURE(&extlib_port_buffering_SETTER__STUB), TRUE);
  scm__rc.d1004[79] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[251]))); /* owner? */
  scm__rc.d1004[80] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[252]))); /* name */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-input-fd-port")), SCM_OBJ(&extlib_open_input_fd_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("open-output-fd-port")), SCM_OBJ(&extlib_open_output_fd_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("with-port-locking")), SCM_OBJ(&extlib_with_port_locking__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port->byte-string")), SCM_OBJ(&extlib_port_TObyte_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("byte-ready?")), SCM_OBJ(&extlib_byte_readyP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-byte")), SCM_OBJ(&extlib_read_byte__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("peek-byte")), SCM_OBJ(&extlib_peek_byte__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-line")), SCM_OBJ(&extlib_read_line__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-block")), SCM_OBJ(&extlib_read_block__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-list")), SCM_OBJ(&extlib_read_list__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("define-reader-ctor")), SCM_OBJ(&extlib_define_reader_ctor__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%get-reader-ctor")), SCM_OBJ(&extlib__25get_reader_ctor__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("define-reader-directive")), SCM_OBJ(&extlib_define_reader_directive__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-reference?")), SCM_OBJ(&extlib_read_referenceP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-reference-has-value?")), SCM_OBJ(&extlib_read_reference_has_valueP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-reference-value")), SCM_OBJ(&extlib_read_reference_value__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("write-byte")), SCM_OBJ(&extlib_write_byte__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("write-limited")), SCM_OBJ(&extlib_write_limited__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("write*")), SCM_OBJ(&extlib_write_2a__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%add-load-path")), SCM_OBJ(&extlib__25add_load_path__STUB), 0);
  scm__rc.d1004[81] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[273]))); /* paths */
  scm__rc.d1004[82] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[274]))); /* environment */
  scm__rc.d1004[83] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[275]))); /* main-script */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("load-from-port")), SCM_OBJ(&extlib_load_from_port__STUB), 0);
  scm__rc.d1004[84] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[277]))); /* init-function */
  scm__rc.d1004[85] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[278]))); /* export-symbols */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("dynamic-load")), SCM_OBJ(&extlib_dynamic_load__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%require")), SCM_OBJ(&extlib__25require__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("provide")), SCM_OBJ(&extlib_provide__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("provided?")), SCM_OBJ(&extlib_providedP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%autoload")), SCM_OBJ(&extlib__25autoload__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("undefined")), SCM_OBJ(&extlib_undefined__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("undefined?")), SCM_OBJ(&extlib_undefinedP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("warn")), SCM_OBJ(&extlib_warn__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eq-hash")), SCM_OBJ(&extlib_eq_hash__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eqv-hash")), SCM_OBJ(&extlib_eqv_hash__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash")), SCM_OBJ(&extlib_hash__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table?")), SCM_OBJ(&extlib_hash_tableP__STUB), 0);
  scm__rc.d1004[86] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[292]))); /* string=? */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-hash-table")), SCM_OBJ(&extlib_make_hash_table__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-type")), SCM_OBJ(&extlib_hash_table_type__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-num-entries")), SCM_OBJ(&extlib_hash_table_num_entries__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-clear!")), SCM_OBJ(&extlib_hash_table_clearX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-get")), SCM_OBJ(&extlib_hash_table_get__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-put!")), SCM_OBJ(&extlib_hash_table_putX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-delete!")), SCM_OBJ(&extlib_hash_table_deleteX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-exists?")), SCM_OBJ(&extlib_hash_table_existsP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-update!")), SCM_OBJ(&extlib_hash_table_updateX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-push!")), SCM_OBJ(&extlib_hash_table_pushX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-pop!")), SCM_OBJ(&extlib_hash_table_popX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%hash-table-iter")), SCM_OBJ(&extlib__25hash_table_iter__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-copy")), SCM_OBJ(&extlib_hash_table_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-keys")), SCM_OBJ(&extlib_hash_table_keys__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-values")), SCM_OBJ(&extlib_hash_table_values__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("hash-table-stat")), SCM_OBJ(&extlib_hash_table_stat__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%make-tree-map")), SCM_OBJ(&extlib__25make_tree_map__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-copy")), SCM_OBJ(&extlib_tree_map_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map?")), SCM_OBJ(&extlib_tree_mapP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-get")), SCM_OBJ(&extlib_tree_map_get__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-put!")), SCM_OBJ(&extlib_tree_map_putX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-delete!")), SCM_OBJ(&extlib_tree_map_deleteX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-update!")), SCM_OBJ(&extlib_tree_map_updateX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-push!")), SCM_OBJ(&extlib_tree_map_pushX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-pop!")), SCM_OBJ(&extlib_tree_map_popX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-exists?")), SCM_OBJ(&extlib_tree_map_existsP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-num-entries")), SCM_OBJ(&extlib_tree_map_num_entries__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tree-map-bound")), SCM_OBJ(&extlib__25tree_map_bound__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tree-map-iter")), SCM_OBJ(&extlib__25tree_map_iter__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tree-map-check-consistency")), SCM_OBJ(&extlib__25tree_map_check_consistency__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tree-map-dump")), SCM_OBJ(&extlib__25tree_map_dump__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-clear!")), SCM_OBJ(&extlib_tree_map_clearX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-floor")), SCM_OBJ(&extlib_tree_map_floor__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-floor-key")), SCM_OBJ(&extlib_tree_map_floor_key__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-floor-value")), SCM_OBJ(&extlib_tree_map_floor_value__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-ceiling")), SCM_OBJ(&extlib_tree_map_ceiling__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-ceiling-key")), SCM_OBJ(&extlib_tree_map_ceiling_key__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-ceiling-value")), SCM_OBJ(&extlib_tree_map_ceiling_value__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-predecessor")), SCM_OBJ(&extlib_tree_map_predecessor__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-predecessor-key")), SCM_OBJ(&extlib_tree_map_predecessor_key__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-predecessor-value")), SCM_OBJ(&extlib_tree_map_predecessor_value__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-successor")), SCM_OBJ(&extlib_tree_map_successor__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-successor-key")), SCM_OBJ(&extlib_tree_map_successor_key__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("tree-map-successor-value")), SCM_OBJ(&extlib_tree_map_successor_value__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module?")), SCM_OBJ(&extlib_moduleP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-name")), SCM_OBJ(&extlib_module_name__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-parents")), SCM_OBJ(&extlib_module_parents__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-precedence-list")), SCM_OBJ(&extlib_module_precedence_list__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-imports")), SCM_OBJ(&extlib_module_imports__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-exports")), SCM_OBJ(&extlib_module_exports__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-table")), SCM_OBJ(&extlib_module_table__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("find-module")), SCM_OBJ(&extlib_find_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("all-modules")), SCM_OBJ(&extlib_all_modules__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-module")), SCM_OBJ(&extlib_make_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("module-name->path")), SCM_OBJ(&extlib_module_name_TOpath__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("path->module-name")), SCM_OBJ(&extlib_path_TOmodule_name__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%export-all")), SCM_OBJ(&extlib__25export_all__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%extend-module")), SCM_OBJ(&extlib__25extend_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("global-variable-bound?")), SCM_OBJ(&extlib_global_variable_boundP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("global-variable-ref")), SCM_OBJ(&extlib_global_variable_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%format")), SCM_OBJ(&extlib__25format__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%exit")), SCM_OBJ(&extlib__25exit__STUB), 0);
  Scm_InitBuiltinClass(&Scm_VMClass, "<thread>", Scm_VMClass__SLOTS, TRUE, SCM_MODULE(mod));
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-dump")), SCM_OBJ(&extlib_vm_dump__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-get-stack-trace")), SCM_OBJ(&extlib_vm_get_stack_trace__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-get-stack-trace-lite")), SCM_OBJ(&extlib_vm_get_stack_trace_lite__STUB), 0);
  scm__rc.d1004[87] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[359]))); /* port */
  scm__rc.d1004[88] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[360]))); /* maxdepth */
  scm__rc.d1004[89] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[361]))); /* skip */
  scm__rc.d1004[90] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[362]))); /* offset */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%vm-show-stack-trace")), SCM_OBJ(&extlib__25vm_show_stack_trace__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-set-default-exception-handler")), SCM_OBJ(&extlib_vm_set_default_exception_handler__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-load-history")), SCM_OBJ(&extlib_current_load_history__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-load-next")), SCM_OBJ(&extlib_current_load_next__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-load-port")), SCM_OBJ(&extlib_current_load_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%vm-make-parameter-slot")), SCM_OBJ(&extlib__25vm_make_parameter_slot__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%vm-parameter-ref")), SCM_OBJ(&extlib__25vm_parameter_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%vm-parameter-set!")), SCM_OBJ(&extlib__25vm_parameter_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-version")), SCM_OBJ(&extlib_gauche_version__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-architecture")), SCM_OBJ(&extlib_gauche_architecture__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-library-directory")), SCM_OBJ(&extlib_gauche_library_directory__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-architecture-directory")), SCM_OBJ(&extlib_gauche_architecture_directory__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-site-library-directory")), SCM_OBJ(&extlib_gauche_site_library_directory__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-site-architecture-directory")), SCM_OBJ(&extlib_gauche_site_architecture_directory__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gauche-dso-suffix")), SCM_OBJ(&extlib_gauche_dso_suffix__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%gauche-runtime-directory")), SCM_OBJ(&extlib__25gauche_runtime_directory__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-thread")), SCM_OBJ(&extlib_current_thread__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("unwrap-syntax")), SCM_OBJ(&extlib_unwrap_syntax__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("foreign-pointer-attributes")), SCM_OBJ(&extlib_foreign_pointer_attributes__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("foreign-pointer-attribute-get")), SCM_OBJ(&extlib_foreign_pointer_attribute_get__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("foreign-pointer-attribute-set")), SCM_OBJ(&extlib_foreign_pointer_attribute_set__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gc")), SCM_OBJ(&extlib_gc__STUB), 0);
  scm__rc.d1004[91] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[386]))); /* total-heap-size */
  scm__rc.d1004[92] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[387]))); /* free-bytes */
  scm__rc.d1004[93] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[388]))); /* bytes-since-gc */
  scm__rc.d1004[94] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[389]))); /* total-bytes */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gc-stat")), SCM_OBJ(&extlib_gc_stat__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("profiler-start")), SCM_OBJ(&extlib_profiler_start__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("profiler-stop")), SCM_OBJ(&extlib_profiler_stop__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("profiler-reset")), SCM_OBJ(&extlib_profiler_reset__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("subr?")), SCM_OBJ(&extlib_subrP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("closure?")), SCM_OBJ(&extlib_closureP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("toplevel-closure?")), SCM_OBJ(&extlib_toplevel_closureP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("closure-code")), SCM_OBJ(&extlib_closure_code__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("method-code")), SCM_OBJ(&extlib_method_code__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("procedure-info")), SCM_OBJ(&extlib_procedure_info__STUB), 0);
}
