/* Generated automatically from libchar.scm.  DO NOT EDIT */
#define LIBGAUCHE_BODY 
#include <gauche.h>
#include <gauche/code.h>

#line 37 "libchar.scm"
#include <gauche/vminsn.h>
#include <gauche/char_attr.h>
#include <gauche/priv/charP.h>
#include <ctype.h>

static ScmObj libcharcharP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharcharP__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharcharP, SCM_MAKE_INT(SCM_VM_CHARP), NULL);

static ScmObj libcharchar_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_3dP, NULL, NULL);

static ScmObj libcharchar_LTP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_LTP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_LTP, NULL, NULL);

static ScmObj libcharchar_GTP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_GTP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_GTP, NULL, NULL);

static ScmObj libcharchar_LT_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_LT_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_LT_3dP, NULL, NULL);

static ScmObj libcharchar_GT_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_GT_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_GT_3dP, NULL, NULL);

static ScmObj libcharchar_ci_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_ci_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_ci_3dP, NULL, NULL);

static ScmObj libcharchar_ci_LTP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_ci_LTP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_ci_LTP, NULL, NULL);

static ScmObj libcharchar_ci_GTP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_ci_GTP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_ci_GTP, NULL, NULL);

static ScmObj libcharchar_ci_LT_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_ci_LT_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_ci_LT_3dP, NULL, NULL);

static ScmObj libcharchar_ci_GT_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_ci_GT_3dP__STUB, 2, 1,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_ci_GT_3dP, NULL, NULL);

static ScmObj libcharchar_alphabeticP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_alphabeticP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_alphabeticP, NULL, NULL);

static ScmObj libcharchar_numericP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_numericP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_numericP, NULL, NULL);

static ScmObj libcharchar_whitespaceP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_whitespaceP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_whitespaceP, NULL, NULL);

static ScmObj libcharchar_upper_caseP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_upper_caseP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_upper_caseP, NULL, NULL);

static ScmObj libcharchar_lower_caseP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_lower_caseP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_lower_caseP, NULL, NULL);

static ScmObj libcharchar_TOinteger(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_TOinteger__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_TOinteger, NULL, NULL);

static ScmObj libcharinteger_TOchar(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharinteger_TOchar__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharinteger_TOchar, NULL, NULL);

static ScmObj libcharchar_upcase(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_upcase__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_upcase, NULL, NULL);

static ScmObj libcharchar_downcase(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_downcase__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_downcase, NULL, NULL);

static ScmObj libchardigit_TOinteger(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchardigit_TOinteger__STUB, 1, 3,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchardigit_TOinteger, NULL, NULL);

static ScmObj libcharinteger_TOdigit(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharinteger_TOdigit__STUB, 1, 4,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharinteger_TOdigit, NULL, NULL);

static ScmObj libcharucs_TOchar(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharucs_TOchar__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharucs_TOchar, NULL, NULL);

static ScmObj libcharchar_TOucs(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_TOucs__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_TOucs, NULL, NULL);

static ScmObj libchargauche_character_encoding(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchargauche_character_encoding__STUB, 0, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchargauche_character_encoding, NULL, NULL);

static ScmObj libcharsupported_character_encodings(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharsupported_character_encodings__STUB, 0, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharsupported_character_encodings, NULL, NULL);

static ScmObj libcharsupported_character_encodingP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharsupported_character_encodingP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharsupported_character_encodingP, NULL, NULL);

static ScmObj libcharchar_title_caseP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_title_caseP__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_title_caseP, NULL, NULL);

static ScmObj libcharchar_titlecase(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_titlecase__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_titlecase, NULL, NULL);

static ScmObj libcharchar_foldcase(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_foldcase__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_foldcase, NULL, NULL);

static ScmObj libcharchar_general_category(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_general_category__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_general_category, NULL, NULL);

static void char_set_add(ScmCharSet* cs,ScmObj chars);
static ScmObj libcharchar_setP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_setP__STUB, 1, 0,1, SCM_FALSE,0, libcharchar_setP, NULL, NULL);

static ScmObj libcharchar_set(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set__STUB, 0, 1,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set, NULL, NULL);

static ScmObj libcharchar_set_copy(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_copy__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_copy, NULL, NULL);

static ScmObj libcharchar_set_freeze(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_freeze__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_freeze, NULL, NULL);

static ScmObj libcharchar_set_freezeX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_freezeX__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_freezeX, NULL, NULL);

static ScmObj libcharread_char_set(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharread_char_set__STUB, 1, 1,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharread_char_set, NULL, NULL);

static ScmObj libcharchar_set_containsP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_containsP__STUB, 2, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_containsP, NULL, NULL);

static ScmObj libcharchar_set_complementX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_complementX__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_complementX, NULL, NULL);

static ScmObj libcharchar_set_immutableP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libcharchar_set_immutableP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libcharchar_set_immutableP, NULL, NULL);

static ScmObj libchar_25char_set_equalP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_equalP__STUB, 2, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_equalP, NULL, NULL);

static ScmObj libchar_25char_set_LT_3dP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_LT_3dP__STUB, 2, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_LT_3dP, NULL, NULL);

static ScmObj libchar_25char_set_add_charsX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_add_charsX__STUB, 2, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_add_charsX, NULL, NULL);

static ScmObj libchar_25char_set_add_rangeX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libchar_25char_set_add_rangeX__STUB, 3, 0,SCM_FALSE,libchar_25char_set_add_rangeX, NULL, NULL);

static ScmObj libchar_25char_set_addX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_addX__STUB, 2, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_addX, NULL, NULL);

static ScmObj libchar_25char_set_ranges(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_ranges__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_ranges, NULL, NULL);

static ScmObj libchar_25char_set_predefined(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_predefined__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_predefined, NULL, NULL);

static ScmObj libchar_25char_set_case_foldX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_case_foldX__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_case_foldX, NULL, NULL);

static ScmObj libchar_25char_set_dump(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libchar_25char_set_dump__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libchar_25char_set_dump, NULL, NULL);

#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 {
  ScmString d1612[142];
} scm__sc SCM_UNUSED = {
  {   /* ScmString d1612 */
      SCM_STRING_CONST_INITIALIZER("char\077", 5, 5),
      SCM_STRING_CONST_INITIALIZER("obj", 3, 3),
      SCM_STRING_CONST_INITIALIZER("source-info", 11, 11),
      SCM_STRING_CONST_INITIALIZER("libchar.scm", 11, 11),
      SCM_STRING_CONST_INITIALIZER("bind-info", 9, 9),
      SCM_STRING_CONST_INITIALIZER("scheme", 6, 6),
      SCM_STRING_CONST_INITIALIZER("<top>", 5, 5),
      SCM_STRING_CONST_INITIALIZER("->", 2, 2),
      SCM_STRING_CONST_INITIALIZER("<boolean>", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char=\077", 6, 6),
      SCM_STRING_CONST_INITIALIZER("c1", 2, 2),
      SCM_STRING_CONST_INITIALIZER("c2", 2, 2),
      SCM_STRING_CONST_INITIALIZER("rest", 4, 4),
      SCM_STRING_CONST_INITIALIZER("chars", 5, 5),
      SCM_STRING_CONST_INITIALIZER("<char>", 6, 6),
      SCM_STRING_CONST_INITIALIZER("*", 1, 1),
      SCM_STRING_CONST_INITIALIZER("char<\077", 6, 6),
      SCM_STRING_CONST_INITIALIZER("char>\077", 6, 6),
      SCM_STRING_CONST_INITIALIZER("char<=\077", 7, 7),
      SCM_STRING_CONST_INITIALIZER("char>=\077", 7, 7),
      SCM_STRING_CONST_INITIALIZER("char-ci=\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci<\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci>\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci<=\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("char-ci>=\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("char-alphabetic\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("c", 1, 1),
      SCM_STRING_CONST_INITIALIZER("char-numeric\077", 13, 13),
      SCM_STRING_CONST_INITIALIZER("char-whitespace\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-upper-case\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-lower-case\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char->integer", 13, 13),
      SCM_STRING_CONST_INITIALIZER("<long>", 6, 6),
      SCM_STRING_CONST_INITIALIZER("integer->char", 13, 13),
      SCM_STRING_CONST_INITIALIZER("<int>", 5, 5),
      SCM_STRING_CONST_INITIALIZER("char-upcase", 11, 11),
      SCM_STRING_CONST_INITIALIZER("char-downcase", 13, 13),
      SCM_STRING_CONST_INITIALIZER("digit->integer", 14, 14),
      SCM_STRING_CONST_INITIALIZER("ch", 2, 2),
      SCM_STRING_CONST_INITIALIZER("optional", 8, 8),
      SCM_STRING_CONST_INITIALIZER("radix", 5, 5),
      SCM_STRING_CONST_INITIALIZER("extended-range\077", 15, 15),
      SCM_STRING_CONST_INITIALIZER("gauche", 6, 6),
      SCM_STRING_CONST_INITIALIZER("integer->digit", 14, 14),
      SCM_STRING_CONST_INITIALIZER("n", 1, 1),
      SCM_STRING_CONST_INITIALIZER("basechar1", 9, 9),
      SCM_STRING_CONST_INITIALIZER("basechar2", 9, 9),
      SCM_STRING_CONST_INITIALIZER("<fixnum>", 8, 8),
      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\077", 29, 29),
      SCM_STRING_CONST_INITIALIZER("encoding", 8, 8),
      SCM_STRING_CONST_INITIALIZER("<const-cstring>", 15, 15),
      SCM_STRING_CONST_INITIALIZER("char-title-case\077", 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\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-set", 8, 8),
      SCM_STRING_CONST_INITIALIZER("<char-set>", 10, 10),
      SCM_STRING_CONST_INITIALIZER("char-set-copy", 13, 13),
      SCM_STRING_CONST_INITIALIZER("cs", 2, 2),
      SCM_STRING_CONST_INITIALIZER("char-set-freeze", 15, 15),
      SCM_STRING_CONST_INITIALIZER("char-set-freeze!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-set-size", 13, 13),
      SCM_STRING_CONST_INITIALIZER("range", 5, 5),
      SCM_STRING_CONST_INITIALIZER("unused-args", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%char-set-ranges", 16, 16),
      SCM_STRING_CONST_INITIALIZER("for-each", 8, 8),
      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("port", 4, 4),
      SCM_STRING_CONST_INITIALIZER("<input-port>", 12, 12),
      SCM_STRING_CONST_INITIALIZER("char-set-contains\077", 18, 18),
      SCM_STRING_CONST_INITIALIZER("char-set-complement!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("char-set-complement", 19, 19),
      SCM_STRING_CONST_INITIALIZER("char-set-immutable\077", 19, 19),
      SCM_STRING_CONST_INITIALIZER("char-set-hash", 13, 13),
      SCM_STRING_CONST_INITIALIZER("too many arguments for", 22, 22),
      SCM_STRING_CONST_INITIALIZER("lambda", 6, 6),
      SCM_STRING_CONST_INITIALIZER("bound", 5, 5),
      SCM_STRING_CONST_INITIALIZER("fold", 4, 4),
      SCM_STRING_CONST_INITIALIZER("^", 1, 1),
      SCM_STRING_CONST_INITIALIZER("val", 3, 3),
      SCM_STRING_CONST_INITIALIZER("modulo", 6, 6),
      SCM_STRING_CONST_INITIALIZER("hash", 4, 4),
      SCM_STRING_CONST_INITIALIZER("+", 1, 1),
      SCM_STRING_CONST_INITIALIZER("car", 3, 3),
      SCM_STRING_CONST_INITIALIZER("cdr", 3, 3),
      SCM_STRING_CONST_INITIALIZER("with-module", 11, 11),
      SCM_STRING_CONST_INITIALIZER("gauche.internal", 15, 15),
      SCM_STRING_CONST_INITIALIZER("%char-set-equal\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("x", 1, 1),
      SCM_STRING_CONST_INITIALIZER("y", 1, 1),
      SCM_STRING_CONST_INITIALIZER("%char-set<=\077", 12, 12),
      SCM_STRING_CONST_INITIALIZER("%char-set-add-chars!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("<list>", 6, 6),
      SCM_STRING_CONST_INITIALIZER("%char-set-add-range!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("from", 4, 4),
      SCM_STRING_CONST_INITIALIZER("to", 2, 2),
      SCM_STRING_CONST_INITIALIZER("%char-set-add!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("dst", 3, 3),
      SCM_STRING_CONST_INITIALIZER("src", 3, 3),
      SCM_STRING_CONST_INITIALIZER("%char-set-predefined", 20, 20),
      SCM_STRING_CONST_INITIALIZER("num", 3, 3),
      SCM_STRING_CONST_INITIALIZER("%char-set-case-fold!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("%char-set-dump", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<void>", 6, 6),
  },
};
static struct scm__rcRec {
  ScmCompiledCode d1621[5];
  ScmWord d1620[90];
  ScmPair d1614[476] SCM_ALIGN_PAIR;
  ScmObj d1613[403];
} scm__rc SCM_UNUSED = {
  {   /* ScmCompiledCode d1621 */
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* #f */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1620[0])), 10,
            2, 1, 0, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[308]),
            SCM_OBJ(&scm__rc.d1621[1]), SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* char-set-size */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1620[10])), 16,
            20, 1, 0, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[313]),
            SCM_FALSE, SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* char-set-complement */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1620[26])), 8,
            10, 1, 0, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[345]),
            SCM_FALSE, SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* #f */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1620[34])), 14,
            11, 2, 0, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[391]),
            SCM_OBJ(&scm__rc.d1621[4]), SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* char-set-hash */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1620[48])), 42,
            16, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[396]),
            SCM_FALSE, SCM_FALSE),
  },
  {   /* ScmWord d1620 */
    /* (char-set-size #f) */
    0x000010ea    /*   0 (LREF-UNBOX 1 0) */,
    0x0000000d    /*   1 (PUSH) */,
    0x00000076    /*   2 (LREF0-CDR) */,
    0x0000000d    /*   3 (PUSH) */,
    0x0000006a    /*   4 (LREF0-CAR) */,
    0x000000b3    /*   5 (NUMSUB2) */,
    0x000010bc    /*   6 (NUMADDI 1) */,
    0x000000b2    /*   7 (NUMADD2) */,
    0x0000103a    /*   8 (LSET 1 0) */,
    0x00000014    /*   9 (RET) */,
    /* char-set-size */
    0x00000007    /*   0 (CONSTI-PUSH 0) */,
    0x00001017    /*   1 (LOCAL-ENV 1) */,
    0x000010e7    /*   2 (BOX 1) */,
    0x0000200e    /*   3 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[10]) + 14),
    0x00000016    /*   5 (CLOSURE) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1621[0])) /* #<compiled-code (char-set-size #f)@0x7f3011d49ba0> */,
    0x0000100f    /*   7 (PUSH-PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[10]) + 12),
    0x0000004c    /*   9 (LREF10-PUSH) */,
    0x0000105f    /*  10 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier gauche.internal#%char-set-ranges.144ae700> */,
    0x00002062    /*  12 (PUSH-GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#for-each.144aed00> */,
    0x000000ea    /*  14 (LREF-UNBOX 0 0) */,
    0x00000014    /*  15 (RET) */,
    /* char-set-complement */
    0x0000100e    /*   0 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[26]) + 5),
    0x00000048    /*   2 (LREF0-PUSH) */,
    0x0000105f    /*   3 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#char-set-copy.11da0700> */,
    0x00001063    /*   5 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#char-set-complement!.11da0740> */,
    0x00000014    /*   7 (RET) */,
    /* (char-set-hash #f) */
    0x0000100e    /*   0 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[34]) + 9),
    0x0000006b    /*   2 (LREF1-CAR) */,
    0x000000b6    /*   3 (LREF-VAL0-NUMADD2 0 0) */,
    0x0000000d    /*   4 (PUSH) */,
    0x00000077    /*   5 (LREF1-CDR) */,
    0x000000b2    /*   6 (NUMADD2) */,
    0x00001062    /*   7 (PUSH-GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#hash.11f651c0> */,
    0x0000000d    /*   9 (PUSH) */,
    0x0000004d    /*  10 (LREF11-PUSH) */,
    0x00002060    /*  11 (GREF-TAIL-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#modulo.11f65320> */,
    0x00000014    /*  13 (RET) */,
    /* char-set-hash */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 7),
    0x00000001    /*   3 (CONST) */,
    SCM_WORD(SCM_UNDEFINED) /* 536870911 */,
    0x00000013    /*   5 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 8),
    0x0000006a    /*   7 (LREF0-CAR) */,
    0x0000000d    /*   8 (PUSH) */,
    0x0000003d    /*   9 (LREF0) */,
    0x00000022    /*  10 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 15),
    0x00000003    /*  12 (CONSTN) */,
    0x00000013    /*  13 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 16),
    0x00000076    /*  15 (LREF0-CDR) */,
    0x00002018    /*  16 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  17 (LREF0) */,
    0x00000022    /*  18 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 22),
    0x00000013    /*  20 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 30),
    0x0000200e    /*  22 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 30),
    0x00000006    /*  24 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1612[112])) /* "too many arguments for" */,
    0x00000006    /*  26 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1614[385])) /* (lambda (cs :optional (bound 536870911)) (fold (^ (range val) (modulo (hash (+ val (car range) (cdr range))) bound)) 0 ((with-module gauche.internal %char-set-ranges) cs))) */,
    0x0000205f    /*  28 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#error.11f5a480> */,
    0x00000016    /*  30 (CLOSURE) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1621[3])) /* #<compiled-code (char-set-hash #f)@0x7f3011c690c0> */,
    0x0000000d    /*  32 (PUSH) */,
    0x00000007    /*  33 (CONSTI-PUSH 0) */,
    0x0000100e    /*  34 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]) + 39),
    0x0000004d    /*  36 (LREF11-PUSH) */,
    0x0000105f    /*  37 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier gauche.internal#%char-set-ranges.11f65060> */,
    0x00003063    /*  39 (PUSH-GREF-TAIL-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#fold.11f654e0> */,
    0x00000014    /*  41 (RET) */,
  },
  {   /* ScmPair d1614 */
       { SCM_NIL, SCM_NIL },
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(48U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[2])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[3])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[5])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[6])},
       { SCM_OBJ(&scm__rc.d1614[7]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[4]), SCM_OBJ(&scm__rc.d1614[8])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[10])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[11])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[12])},
       { SCM_MAKE_INT(65U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[14])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[15])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[17])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[18])},
       { SCM_OBJ(&scm__rc.d1614[19]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[16]), SCM_OBJ(&scm__rc.d1614[20])},
       { SCM_MAKE_INT(67U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[22])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[23])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[25])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[26])},
       { SCM_OBJ(&scm__rc.d1614[27]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[24]), SCM_OBJ(&scm__rc.d1614[28])},
       { SCM_MAKE_INT(69U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[31])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[33])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[34])},
       { SCM_OBJ(&scm__rc.d1614[35]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[32]), SCM_OBJ(&scm__rc.d1614[36])},
       { SCM_MAKE_INT(71U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[38])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[39])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[41])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[42])},
       { SCM_OBJ(&scm__rc.d1614[43]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[40]), SCM_OBJ(&scm__rc.d1614[44])},
       { SCM_MAKE_INT(73U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[46])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[47])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[49])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[50])},
       { SCM_OBJ(&scm__rc.d1614[51]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[48]), SCM_OBJ(&scm__rc.d1614[52])},
       { SCM_MAKE_INT(94U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[54])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[55])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[57])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[58])},
       { SCM_OBJ(&scm__rc.d1614[59]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[56]), SCM_OBJ(&scm__rc.d1614[60])},
       { SCM_MAKE_INT(96U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[62])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[63])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[65])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[66])},
       { SCM_OBJ(&scm__rc.d1614[67]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[64]), SCM_OBJ(&scm__rc.d1614[68])},
       { SCM_MAKE_INT(98U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[70])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[71])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[73])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[74])},
       { SCM_OBJ(&scm__rc.d1614[75]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[72]), SCM_OBJ(&scm__rc.d1614[76])},
       { SCM_MAKE_INT(100U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[78])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[79])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[81])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[82])},
       { SCM_OBJ(&scm__rc.d1614[83]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[80]), SCM_OBJ(&scm__rc.d1614[84])},
       { SCM_MAKE_INT(102U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[86])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[87])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[89])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[90])},
       { SCM_OBJ(&scm__rc.d1614[91]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[88]), SCM_OBJ(&scm__rc.d1614[92])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(105U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[95])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[96])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[98])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[99])},
       { SCM_OBJ(&scm__rc.d1614[100]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[97]), SCM_OBJ(&scm__rc.d1614[101])},
       { SCM_MAKE_INT(106U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[103])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[104])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[106])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[107])},
       { SCM_OBJ(&scm__rc.d1614[108]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[105]), SCM_OBJ(&scm__rc.d1614[109])},
       { SCM_MAKE_INT(107U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[111])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[112])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[114])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[115])},
       { SCM_OBJ(&scm__rc.d1614[116]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[113]), SCM_OBJ(&scm__rc.d1614[117])},
       { SCM_MAKE_INT(110U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[119])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[120])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[122])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[123])},
       { SCM_OBJ(&scm__rc.d1614[124]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[121]), SCM_OBJ(&scm__rc.d1614[125])},
       { SCM_MAKE_INT(111U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[127])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[128])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[130])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[131])},
       { SCM_OBJ(&scm__rc.d1614[132]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[129]), SCM_OBJ(&scm__rc.d1614[133])},
       { SCM_MAKE_INT(113U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[135])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[136])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[138])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[139])},
       { SCM_OBJ(&scm__rc.d1614[140]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[137]), SCM_OBJ(&scm__rc.d1614[141])},
       { SCM_MAKE_INT(115U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[143])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[144])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[146])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[147])},
       { SCM_OBJ(&scm__rc.d1614[148]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[145]), SCM_OBJ(&scm__rc.d1614[149])},
       { SCM_MAKE_INT(118U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[151])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[152])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[154])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[155])},
       { SCM_OBJ(&scm__rc.d1614[156]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[153]), SCM_OBJ(&scm__rc.d1614[157])},
       { SCM_MAKE_INT(119U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[159])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[160])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[162])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[163])},
       { SCM_OBJ(&scm__rc.d1614[164]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[161]), SCM_OBJ(&scm__rc.d1614[165])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[167])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[168])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[169])},
       { SCM_MAKE_INT(122U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[171])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[172])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[174])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[175])},
       { SCM_OBJ(&scm__rc.d1614[176]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[173]), SCM_OBJ(&scm__rc.d1614[177])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[179])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[180])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[181])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[182])},
       { SCM_MAKE_INT(133U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[184])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[185])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[187])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[188])},
       { SCM_OBJ(&scm__rc.d1614[189]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[186]), SCM_OBJ(&scm__rc.d1614[190])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(142U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[193])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[194])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[196])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[197])},
       { SCM_OBJ(&scm__rc.d1614[198]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[195]), SCM_OBJ(&scm__rc.d1614[199])},
       { SCM_MAKE_INT(146U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[201])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[202])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[204])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[205])},
       { SCM_OBJ(&scm__rc.d1614[206]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[203]), SCM_OBJ(&scm__rc.d1614[207])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[209])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[210])},
       { SCM_OBJ(&scm__rc.d1614[211]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[213])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[214])},
       { SCM_OBJ(&scm__rc.d1614[215]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(155U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[218])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[219])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[221])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[222])},
       { SCM_OBJ(&scm__rc.d1614[223]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[220]), SCM_OBJ(&scm__rc.d1614[224])},
       { SCM_MAKE_INT(158U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[226])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[227])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[229])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[230])},
       { SCM_OBJ(&scm__rc.d1614[231]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[228]), SCM_OBJ(&scm__rc.d1614[232])},
       { SCM_MAKE_INT(160U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[234])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[235])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[237])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[238])},
       { SCM_OBJ(&scm__rc.d1614[239]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[236]), SCM_OBJ(&scm__rc.d1614[240])},
       { SCM_MAKE_INT(161U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[242])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[243])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[245])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[246])},
       { SCM_OBJ(&scm__rc.d1614[247]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[244]), SCM_OBJ(&scm__rc.d1614[248])},
       { SCM_MAKE_INT(163U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[250])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[251])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[253])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[254])},
       { SCM_OBJ(&scm__rc.d1614[255]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[252]), SCM_OBJ(&scm__rc.d1614[256])},
       { SCM_MAKE_INT(214U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[258])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[259])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[261])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[262])},
       { SCM_OBJ(&scm__rc.d1614[263]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[260]), SCM_OBJ(&scm__rc.d1614[264])},
       { SCM_MAKE_INT(216U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[266])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[267])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[269])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[270])},
       { SCM_OBJ(&scm__rc.d1614[271]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[268]), SCM_OBJ(&scm__rc.d1614[272])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(221U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[275])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[276])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[278])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[279])},
       { SCM_OBJ(&scm__rc.d1614[280]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[277]), SCM_OBJ(&scm__rc.d1614[281])},
       { SCM_MAKE_INT(223U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[283])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[284])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[286])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[287])},
       { SCM_OBJ(&scm__rc.d1614[288]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[285]), SCM_OBJ(&scm__rc.d1614[289])},
       { SCM_MAKE_INT(224U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[291])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[292])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[294])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[295])},
       { SCM_OBJ(&scm__rc.d1614[296]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[293]), SCM_OBJ(&scm__rc.d1614[297])},
       { SCM_FALSE, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[299])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(228U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[302])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[303])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[305]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[304]), SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(226U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[309])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[310])},
       { SCM_OBJ(&scm__rc.d1614[311]), SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(232U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[315])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[316])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[318])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[319])},
       { SCM_OBJ(&scm__rc.d1614[320]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[317]), SCM_OBJ(&scm__rc.d1614[321])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[323])},
       { SCM_MAKE_INT(235U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[325])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[326])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[328])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[329])},
       { SCM_OBJ(&scm__rc.d1614[330]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[327]), SCM_OBJ(&scm__rc.d1614[331])},
       { SCM_MAKE_INT(238U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[333])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[334])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[336])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[337])},
       { SCM_OBJ(&scm__rc.d1614[338]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[335]), SCM_OBJ(&scm__rc.d1614[339])},
       { SCM_MAKE_INT(240U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[341])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[342])},
       { SCM_OBJ(&scm__rc.d1614[343]), SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(242U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[346])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[347])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[349])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[350])},
       { SCM_OBJ(&scm__rc.d1614[351]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[348]), SCM_OBJ(&scm__rc.d1614[352])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[354])},
       { SCM_OBJ(&scm__rc.d1614[355]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[356])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[357])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[359])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[301])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[301])},
       { SCM_OBJ(&scm__rc.d1614[362]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[361]), SCM_OBJ(&scm__rc.d1614[363])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[364])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[365])},
       { SCM_OBJ(&scm__rc.d1614[366]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[367])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[368]), SCM_OBJ(&scm__rc.d1614[369])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[370])},
       { SCM_OBJ(&scm__rc.d1614[371]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[360]), SCM_OBJ(&scm__rc.d1614[372])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[373])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[375])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[376])},
       { SCM_OBJ(&scm__rc.d1614[377]), SCM_OBJ(&scm__rc.d1614[274])},
       { SCM_OBJ(&scm__rc.d1614[378]), SCM_NIL},
       { SCM_MAKE_INT(0), SCM_OBJ(&scm__rc.d1614[379])},
       { SCM_OBJ(&scm__rc.d1614[374]), SCM_OBJ(&scm__rc.d1614[380])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[381])},
       { SCM_OBJ(&scm__rc.d1614[382]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[358]), SCM_OBJ(&scm__rc.d1614[383])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[384])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[299])},
       { SCM_MAKE_INT(246U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[387])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[388])},
       { SCM_OBJ(&scm__rc.d1614[389]), SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(245U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[392])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[393])},
       { SCM_OBJ(&scm__rc.d1614[394]), SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[397])},
       { SCM_MAKE_INT(251U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[399])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[400])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[402])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[403])},
       { SCM_OBJ(&scm__rc.d1614[404]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[401]), SCM_OBJ(&scm__rc.d1614[405])},
       { SCM_MAKE_INT(254U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[407])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[408])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[410])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[411])},
       { SCM_OBJ(&scm__rc.d1614[412]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[409]), SCM_OBJ(&scm__rc.d1614[413])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[10])},
       { SCM_MAKE_INT(257U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[416])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[417])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[419])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[420])},
       { SCM_OBJ(&scm__rc.d1614[421]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[418]), SCM_OBJ(&scm__rc.d1614[422])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[424])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[425])},
       { SCM_MAKE_INT(260U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[427])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[428])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[430])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[431])},
       { SCM_OBJ(&scm__rc.d1614[432]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[429]), SCM_OBJ(&scm__rc.d1614[433])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[435])},
       { SCM_MAKE_INT(274U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[437])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[438])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[440])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[441])},
       { SCM_OBJ(&scm__rc.d1614[442]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[439]), SCM_OBJ(&scm__rc.d1614[443])},
       { SCM_MAKE_INT(275U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[445])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[446])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[376])},
       { SCM_OBJ(&scm__rc.d1614[448]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[447]), SCM_OBJ(&scm__rc.d1614[449])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(276U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[452])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[453])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[455])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[456])},
       { SCM_OBJ(&scm__rc.d1614[457]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[454]), SCM_OBJ(&scm__rc.d1614[458])},
       { SCM_MAKE_INT(278U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[460])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[461])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[463])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[464])},
       { SCM_OBJ(&scm__rc.d1614[465]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[462]), SCM_OBJ(&scm__rc.d1614[466])},
       { SCM_MAKE_INT(280U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[3]), SCM_OBJ(&scm__rc.d1614[468])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[469])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[471])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[472])},
       { SCM_OBJ(&scm__rc.d1614[473]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[470]), SCM_OBJ(&scm__rc.d1614[474])},
  },
  {   /* ScmObj d1613 */
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(4, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
  },
};

static ScmObj libcharcharP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  obj_scm = SCM_SUBRARGS[0];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_CHARP(obj));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 66 "libchar.scm"
while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)==(c2));goto SCM_STUB_RETURN;}break;}else if((c1)==(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_LTP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char<?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 68 "libchar.scm"
while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)<(c2));goto SCM_STUB_RETURN;}break;}else if((c1)<(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_GTP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char>?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 70 "libchar.scm"
while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)>(c2));goto SCM_STUB_RETURN;}break;}else if((c1)>(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_LT_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char<=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 72 "libchar.scm"
while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)<=(c2));goto SCM_STUB_RETURN;}break;}else if((c1)<=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_GT_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char>=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 74 "libchar.scm"
while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)>=(c2));goto SCM_STUB_RETURN;}break;}else if((c1)>=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_ci_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char-ci=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 95 "libchar.scm"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)==(c2));goto SCM_STUB_RETURN;}break;}else if((c1)==(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_ci_LTP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char-ci<?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 97 "libchar.scm"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)<(c2));goto SCM_STUB_RETURN;}break;}else if((c1)<(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_ci_GTP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char-ci>?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 99 "libchar.scm"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)>(c2));goto SCM_STUB_RETURN;}break;}else if((c1)>(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_ci_LT_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char-ci<=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 101 "libchar.scm"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)<=(c2));goto SCM_STUB_RETURN;}break;}else if((c1)<=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_ci_GT_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("char-ci>=?");
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c1_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_SUBRARGS[1];
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 103 "libchar.scm"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){{SCM_RESULT=((c1)>=(c2));goto SCM_STUB_RETURN;}break;}else if((c1)>=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {{SCM_RESULT=(FALSE);goto SCM_STUB_RETURN;}break;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_alphabeticP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-alphabetic?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharAlphabeticP(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_numericP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-numeric?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharNumericP(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_whitespaceP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-whitespace?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
int SCM_RESULT;

#line 108 "libchar.scm"
{SCM_RESULT=(((SCM_CHAR_ASCII_P(c))&&(isspace(c)))||(
SCM_CHAR_EXTRA_WHITESPACE(c)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_upper_caseP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-upper-case?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharUppercaseP(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_lower_caseP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-lower-case?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharLowercaseP(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_TOinteger(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char->integer");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[0];
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
long SCM_RESULT;

#line 114 "libchar.scm"
{SCM_RESULT=(((signed long )(c)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}


static ScmObj libcharinteger_TOchar(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  int c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("integer->char");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[0];
  if (!SCM_INTEGERP(c_scm)) Scm_Error("int required, but got %S", c_scm);
  c = Scm_GetInteger(c_scm);
  {
{
ScmChar SCM_RESULT;

#line 116 "libchar.scm"
{SCM_RESULT=(((ScmChar )(c)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_upcase(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-upcase");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharUpcase(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_downcase(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-downcase");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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_CharDowncase(c));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}


static ScmObj libchardigit_TOinteger(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj ch_scm;
  ScmChar ch;
  ScmObj radix_scm;
  ScmSmallInt radix;
  ScmObj extended_rangeP_scm;
  int extended_rangeP;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("digit->integer");
  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);
  for (int SCM_i=0; SCM_i<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  ch_scm = SCM_SUBRARGS[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_SUBRARGS[1];
  } else {
    radix_scm = SCM_MAKE_INT(10U);
  }
  if (!SCM_INTP(radix_scm)) Scm_Error("ScmSmallInt required, but got %S", radix_scm);
  radix = SCM_INT_VALUE(radix_scm);
  if (SCM_ARGCNT > 2+1) {
    extended_rangeP_scm = SCM_SUBRARGS[2];
  } else {
    extended_rangeP_scm = SCM_FALSE;
  }
  if (!SCM_BOOLP(extended_rangeP_scm)) Scm_Error("boolean required, but got %S", extended_rangeP_scm);
  extended_rangeP = SCM_BOOL_VALUE(extended_rangeP_scm);
  {
{
ScmObj SCM_RESULT;

#line 124 "libchar.scm"
{int r;
if (((radix)<(SCM_RADIX_MIN))||((radix)>(SCM_RADIX_MAX))){{
Scm_Error("radix must be an integer between %d and %d, but got %d",SCM_RADIX_MIN,SCM_RADIX_MAX,radix);}}
#line 128 "libchar.scm"
if ((extended_rangeP)&&((radix)>(10))){{
Scm_Error("for extended range, radix can't exceed 10",radix);}}
r=(Scm_DigitToInt(ch,radix,extended_rangeP));
{SCM_RESULT=((((r)>=(0))?(SCM_MAKE_INT(r)):(SCM_FALSE)));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharinteger_TOdigit(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj n_scm;
  ScmSmallInt n;
  ScmObj radix_scm;
  ScmSmallInt radix;
  ScmObj basechar1_scm;
  ScmChar basechar1;
  ScmObj basechar2_scm;
  ScmChar basechar2;
  ScmObj SCM_SUBRARGS[7];
  SCM_ENTER_SUBR("integer->digit");
  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);
  for (int SCM_i=0; SCM_i<7; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  n_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(n_scm)) Scm_Error("ScmSmallInt required, but got %S", n_scm);
  n = SCM_INT_VALUE(n_scm);
  if (SCM_ARGCNT > 1+1) {
    radix_scm = SCM_SUBRARGS[1];
  } else {
    radix_scm = SCM_MAKE_INT(10U);
  }
  if (!SCM_INTP(radix_scm)) Scm_Error("ScmSmallInt required, but got %S", radix_scm);
  radix = SCM_INT_VALUE(radix_scm);
  if (SCM_ARGCNT > 2+1) {
    basechar1_scm = SCM_SUBRARGS[2];
  } else {
    basechar1_scm = SCM_MAKE_CHAR(48);
  }
  if (!SCM_CHARP(basechar1_scm)) Scm_Error("character required, but got %S", basechar1_scm);
  basechar1 = SCM_CHAR_VALUE(basechar1_scm);
  if (SCM_ARGCNT > 3+1) {
    basechar2_scm = SCM_SUBRARGS[3];
  } else {
    basechar2_scm = SCM_MAKE_CHAR(97);
  }
  if (!SCM_CHARP(basechar2_scm)) Scm_Error("character required, but got %S", basechar2_scm);
  basechar2 = SCM_CHAR_VALUE(basechar2_scm);
  {
{
ScmObj SCM_RESULT;

#line 135 "libchar.scm"
{ScmChar r;
if (((radix)<(SCM_RADIX_MIN))||((radix)>(SCM_RADIX_MAX))){{
Scm_Error("radix must be an integer between %d and %d, but got %d",SCM_RADIX_MIN,SCM_RADIX_MAX,radix);}}
#line 139 "libchar.scm"
r=(Scm_IntToDigit(n,radix,basechar1,basechar2));
{SCM_RESULT=((((r)==(SCM_CHAR_INVALID))?(SCM_FALSE):(SCM_MAKE_CHAR(r))));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharucs_TOchar(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj n_scm;
  int n;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("ucs->char");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  n_scm = SCM_SUBRARGS[0];
  if (!SCM_INTEGERP(n_scm)) Scm_Error("int required, but got %S", n_scm);
  n = Scm_GetInteger(n_scm);
  {
{
ScmObj SCM_RESULT;

#line 143 "libchar.scm"
{ScmChar ch=Scm_UcsToChar(n);
{SCM_RESULT=((((ch)==(SCM_CHAR_INVALID))?(SCM_FALSE):(SCM_MAKE_CHAR(ch))));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_TOucs(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char->ucs");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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 147 "libchar.scm"
{int ucs=Scm_CharToUcs(c);
{SCM_RESULT=((((ucs)<(0))?(SCM_FALSE):(Scm_MakeInteger(ucs))));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


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


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

#line 153 "libchar.scm"
{SCM_RESULT=(Scm_CStringArrayToList(Scm_SupportedCharacterEncodings(),-1,0));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharsupported_character_encodingP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj encoding_scm;
  const char* encoding;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("supported-character-encoding?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  encoding_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(encoding_scm)) Scm_Error("const char* required, but got %S", encoding_scm);
  encoding = SCM_STRING_CONST_CSTRING(encoding_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(Scm_SupportedCharacterEncodingP(encoding));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_title_caseP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-title-case?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_titlecase(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-titlecase");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_foldcase(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-foldcase");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_general_category(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj c_scm;
  ScmChar c;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-general-category");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  c_scm = SCM_SUBRARGS[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 164 "libchar.scm"
switch (Scm_CharGeneralCategory(c)) {
case SCM_CHAR_CATEGORY_Lu : {{SCM_RESULT=(scm__rc.d1613[188]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Ll : {{SCM_RESULT=(scm__rc.d1613[189]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Lt : {{SCM_RESULT=(scm__rc.d1613[190]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Lm : {{SCM_RESULT=(scm__rc.d1613[191]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Lo : {{SCM_RESULT=(scm__rc.d1613[192]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Mn : {{SCM_RESULT=(scm__rc.d1613[193]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Mc : {{SCM_RESULT=(scm__rc.d1613[194]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Me : {{SCM_RESULT=(scm__rc.d1613[195]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Nd : {{SCM_RESULT=(scm__rc.d1613[196]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Nl : {{SCM_RESULT=(scm__rc.d1613[197]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_No : {{SCM_RESULT=(scm__rc.d1613[198]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Pc : {{SCM_RESULT=(scm__rc.d1613[199]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Pd : {{SCM_RESULT=(scm__rc.d1613[200]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Ps : {{SCM_RESULT=(scm__rc.d1613[201]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Pe : {{SCM_RESULT=(scm__rc.d1613[202]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Pi : {{SCM_RESULT=(scm__rc.d1613[203]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Pf : {{SCM_RESULT=(scm__rc.d1613[204]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Po : {{SCM_RESULT=(scm__rc.d1613[205]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Sm : {{SCM_RESULT=(scm__rc.d1613[206]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Sc : {{SCM_RESULT=(scm__rc.d1613[207]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Sk : {{SCM_RESULT=(scm__rc.d1613[208]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_So : {{SCM_RESULT=(scm__rc.d1613[209]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Zs : {{SCM_RESULT=(scm__rc.d1613[210]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Zl : {{SCM_RESULT=(scm__rc.d1613[211]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Zp : {{SCM_RESULT=(scm__rc.d1613[212]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Cc : {{SCM_RESULT=(scm__rc.d1613[213]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Cf : {{SCM_RESULT=(scm__rc.d1613[214]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Cs : {{SCM_RESULT=(scm__rc.d1613[215]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Co : {{SCM_RESULT=(scm__rc.d1613[216]);goto SCM_STUB_RETURN;}break;}
case SCM_CHAR_CATEGORY_Cn : {{SCM_RESULT=(scm__rc.d1613[217]);goto SCM_STUB_RETURN;}break;}default: {
Scm_Panic("Scm_CharGeneralCategory returns unknown value for character %d",c);
#line 197 "libchar.scm"
{SCM_RESULT=(SCM_UNDEFINED);goto SCM_STUB_RETURN;}break;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static void char_set_add(ScmCharSet* cs,ScmObj chars){ScmObj cise__1619;{
#line 209 "libchar.scm"
SCM_FOR_EACH(cise__1619,chars) {{ScmObj ch=SCM_CAR(cise__1619);
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 libcharchar_setP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  obj_scm = SCM_SUBRARGS[0];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_CHARSETP(obj));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("char-set");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  chars_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!(chars_scm)) Scm_Error("scheme object required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
ScmCharSet* SCM_RESULT;

#line 217 "libchar.scm"
{ScmCharSet* cs=SCM_CHARSET(Scm_MakeEmptyCharSet());
char_set_add(cs,chars);
{SCM_RESULT=(cs);goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_copy(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set-copy");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetCopy(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_freeze(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set-freeze");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetFreeze(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_freezeX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set-freeze!");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetFreezeX(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharread_char_set(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj port_scm;
  ScmPort* port;
  ScmObj error_scm = SCM_TRUE;
  int error;
  ScmObj posix_bracket_scm = SCM_TRUE;
  int posix_bracket;
  ScmObj SCM_SUBRARGS[1];
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("read-char-set");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  port_scm = SCM_SUBRARGS[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.d1613[264])) {
      error_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1613[265])) {
      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 233 "libchar.scm"
{SCM_RESULT=(Scm_CharSetRead(port,NULL,error,posix_bracket));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_containsP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj ch_scm;
  ScmChar ch;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("char-set-contains?");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  ch_scm = SCM_SUBRARGS[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));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_complementX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set-complement!");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetComplement(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libcharchar_set_immutableP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("char-set-immutable?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
int SCM_RESULT;

#line 243 "libchar.scm"
{SCM_RESULT=(SCM_CHAR_SET_IMMUTABLE_P(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_equalP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmCharSet* x;
  ScmObj y_scm;
  ScmCharSet* y;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("%char-set-equal?");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(x_scm)) Scm_Error("<char-set> required, but got %S", x_scm);
  x = SCM_CHAR_SET(x_scm);
  y_scm = SCM_SUBRARGS[1];
  if (!SCM_CHAR_SET_P(y_scm)) Scm_Error("<char-set> required, but got %S", y_scm);
  y = SCM_CHAR_SET(y_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(Scm_CharSetEq(x,y));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_LT_3dP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmCharSet* x;
  ScmObj y_scm;
  ScmCharSet* y;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("%char-set<=?");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(x_scm)) Scm_Error("<char-set> required, but got %S", x_scm);
  x = SCM_CHAR_SET(x_scm);
  y_scm = SCM_SUBRARGS[1];
  if (!SCM_CHAR_SET_P(y_scm)) Scm_Error("<char-set> required, but got %S", y_scm);
  y = SCM_CHAR_SET(y_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(Scm_CharSetLE(x,y));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_add_charsX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj chars_scm;
  ScmObj chars;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("%char-set-add-chars!");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  chars_scm = SCM_SUBRARGS[1];
  if (!SCM_LISTP(chars_scm)) Scm_Error("list required, but got %S", chars_scm);
  chars = (chars_scm);
  {
{
ScmCharSet* SCM_RESULT;

#line 258 "libchar.scm"
char_set_add(cs,chars);

#line 258 "libchar.scm"
{SCM_RESULT=(cs);goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_add_rangeX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj from_scm;
  ScmObj from;
  ScmObj to_scm;
  ScmObj to;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("%char-set-add-range!");
  for (int SCM_i=0; SCM_i<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  from_scm = SCM_SUBRARGS[1];
  if (!(from_scm)) Scm_Error("scheme object required, but got %S", from_scm);
  from = (from_scm);
  to_scm = SCM_SUBRARGS[2];
  if (!(to_scm)) Scm_Error("scheme object required, but got %S", to_scm);
  to = (to_scm);
  {
{
ScmObj SCM_RESULT;

#line 261 "libchar.scm"
{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))));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_addX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj dst_scm;
  ScmCharSet* dst;
  ScmObj src_scm;
  ScmCharSet* src;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("%char-set-add!");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  dst_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(dst_scm)) Scm_Error("<char-set> required, but got %S", dst_scm);
  dst = SCM_CHAR_SET(dst_scm);
  src_scm = SCM_SUBRARGS[1];
  if (!SCM_CHAR_SET_P(src_scm)) Scm_Error("<char-set> required, but got %S", src_scm);
  src = SCM_CHAR_SET(src_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetAdd(dst,src));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_ranges(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("%char-set-ranges");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetRanges(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_predefined(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj num_scm;
  ScmSmallInt num;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("%char-set-predefined");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  num_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(num_scm)) Scm_Error("ScmSmallInt required, but got %S", num_scm);
  num = SCM_INT_VALUE(num_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_GetStandardCharSet(num));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_case_foldX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("%char-set-case-fold!");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_CharSetCaseFold(cs));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}


static ScmObj libchar_25char_set_dump(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj cs_scm;
  ScmCharSet* cs;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("%char-set-dump");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  cs_scm = SCM_SUBRARGS[0];
  if (!SCM_CHAR_SET_P(cs_scm)) Scm_Error("<char-set> required, but got %S", cs_scm);
  cs = SCM_CHAR_SET(cs_scm);
  {

#line 281 "libchar.scm"
Scm_CharSetDump(cs,SCM_CUROUT);
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

static ScmCompiledCode *toplevels[] = {
 NULL /*termination*/
};
void Scm_Init_libchar() {
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())));
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())));
  scm__rc.d1613[0] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[0])),TRUE); /* char? */
  scm__rc.d1613[1] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[1])),TRUE); /* obj */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[1]), scm__rc.d1613[1]);
  scm__rc.d1613[2] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[2])),TRUE); /* source-info */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[4]), scm__rc.d1613[2]);
  scm__rc.d1613[3] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[4])),TRUE); /* bind-info */
  scm__rc.d1613[4] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[5])),TRUE); /* scheme */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[5]), scm__rc.d1613[0]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[6]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[7]), scm__rc.d1613[3]);
  scm__rc.d1613[5] = Scm_MakeExtendedPair(scm__rc.d1613[0], SCM_OBJ(&scm__rc.d1614[1]), SCM_OBJ(&scm__rc.d1614[9]));
  scm__rc.d1613[6] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[6])),TRUE); /* <top> */
  scm__rc.d1613[7] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[7])),TRUE); /* -> */
  scm__rc.d1613[8] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[8])),TRUE); /* <boolean> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[9]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[9]))[4] = scm__rc.d1613[6];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[9]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[9]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char?")), SCM_OBJ(&libcharcharP__STUB), SCM_BINDING_INLINABLE);
  libcharcharP__STUB.common.info = scm__rc.d1613[5];
  libcharcharP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[9]);
  scm__rc.d1613[16] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[9])),TRUE); /* char=? */
  scm__rc.d1613[17] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[10])),TRUE); /* c1 */
  scm__rc.d1613[18] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[11])),TRUE); /* c2 */
  scm__rc.d1613[19] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[12]))); /* :rest */
  scm__rc.d1613[20] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[13])),TRUE); /* chars */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[10]), scm__rc.d1613[20]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[11]), scm__rc.d1613[19]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[12]), scm__rc.d1613[18]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[13]), scm__rc.d1613[17]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[16]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[17]), scm__rc.d1613[16]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[18]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[19]), scm__rc.d1613[3]);
  scm__rc.d1613[21] = Scm_MakeExtendedPair(scm__rc.d1613[16], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[21]));
  scm__rc.d1613[22] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[14])),TRUE); /* <char> */
  scm__rc.d1613[23] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[15])),TRUE); /* * */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[5] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[6] = scm__rc.d1613[23];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[24]))[8] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char=?")), SCM_OBJ(&libcharchar_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_3dP__STUB.common.info = scm__rc.d1613[21];
  libcharchar_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[33] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[16])),TRUE); /* char<? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[24]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[25]), scm__rc.d1613[33]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[26]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[27]), scm__rc.d1613[3]);
  scm__rc.d1613[34] = Scm_MakeExtendedPair(scm__rc.d1613[33], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[29]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char<?")), SCM_OBJ(&libcharchar_LTP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_LTP__STUB.common.info = scm__rc.d1613[34];
  libcharchar_LTP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[35] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[17])),TRUE); /* char>? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[32]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[33]), scm__rc.d1613[35]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[34]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[35]), scm__rc.d1613[3]);
  scm__rc.d1613[36] = Scm_MakeExtendedPair(scm__rc.d1613[35], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[37]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char>?")), SCM_OBJ(&libcharchar_GTP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_GTP__STUB.common.info = scm__rc.d1613[36];
  libcharchar_GTP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[37] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[18])),TRUE); /* char<=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[40]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[41]), scm__rc.d1613[37]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[42]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[43]), scm__rc.d1613[3]);
  scm__rc.d1613[38] = Scm_MakeExtendedPair(scm__rc.d1613[37], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[45]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char<=?")), SCM_OBJ(&libcharchar_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_LT_3dP__STUB.common.info = scm__rc.d1613[38];
  libcharchar_LT_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[39] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[19])),TRUE); /* char>=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[48]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[49]), scm__rc.d1613[39]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[50]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[51]), scm__rc.d1613[3]);
  scm__rc.d1613[40] = Scm_MakeExtendedPair(scm__rc.d1613[39], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[53]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char>=?")), SCM_OBJ(&libcharchar_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_GT_3dP__STUB.common.info = scm__rc.d1613[40];
  libcharchar_GT_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[41] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[20])),TRUE); /* char-ci=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[56]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[57]), scm__rc.d1613[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[58]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[59]), scm__rc.d1613[3]);
  scm__rc.d1613[42] = Scm_MakeExtendedPair(scm__rc.d1613[41], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[61]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-ci=?")), SCM_OBJ(&libcharchar_ci_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_ci_3dP__STUB.common.info = scm__rc.d1613[42];
  libcharchar_ci_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[43] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[21])),TRUE); /* char-ci<? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[64]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[65]), scm__rc.d1613[43]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[66]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[67]), scm__rc.d1613[3]);
  scm__rc.d1613[44] = Scm_MakeExtendedPair(scm__rc.d1613[43], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[69]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-ci<?")), SCM_OBJ(&libcharchar_ci_LTP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_ci_LTP__STUB.common.info = scm__rc.d1613[44];
  libcharchar_ci_LTP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[45] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[22])),TRUE); /* char-ci>? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[72]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[73]), scm__rc.d1613[45]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[74]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[75]), scm__rc.d1613[3]);
  scm__rc.d1613[46] = Scm_MakeExtendedPair(scm__rc.d1613[45], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[77]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-ci>?")), SCM_OBJ(&libcharchar_ci_GTP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_ci_GTP__STUB.common.info = scm__rc.d1613[46];
  libcharchar_ci_GTP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[47] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[23])),TRUE); /* char-ci<=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[80]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[81]), scm__rc.d1613[47]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[82]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[83]), scm__rc.d1613[3]);
  scm__rc.d1613[48] = Scm_MakeExtendedPair(scm__rc.d1613[47], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[85]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-ci<=?")), SCM_OBJ(&libcharchar_ci_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_ci_LT_3dP__STUB.common.info = scm__rc.d1613[48];
  libcharchar_ci_LT_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[49] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[24])),TRUE); /* char-ci>=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[88]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[89]), scm__rc.d1613[49]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[90]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[91]), scm__rc.d1613[3]);
  scm__rc.d1613[50] = Scm_MakeExtendedPair(scm__rc.d1613[49], SCM_OBJ(&scm__rc.d1614[13]), SCM_OBJ(&scm__rc.d1614[93]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-ci>=?")), SCM_OBJ(&libcharchar_ci_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_ci_GT_3dP__STUB.common.info = scm__rc.d1613[50];
  libcharchar_ci_GT_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[24]);
  scm__rc.d1613[51] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[25])),TRUE); /* char-alphabetic? */
  scm__rc.d1613[52] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[26])),TRUE); /* c */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[94]), scm__rc.d1613[52]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[97]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[98]), scm__rc.d1613[51]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[99]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[100]), scm__rc.d1613[3]);
  scm__rc.d1613[53] = Scm_MakeExtendedPair(scm__rc.d1613[51], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[102]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[54]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[54]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[54]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[54]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-alphabetic?")), SCM_OBJ(&libcharchar_alphabeticP__STUB), 0);
  libcharchar_alphabeticP__STUB.common.info = scm__rc.d1613[53];
  libcharchar_alphabeticP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[54]);
  scm__rc.d1613[61] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[27])),TRUE); /* char-numeric? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[105]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[106]), scm__rc.d1613[61]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[107]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[108]), scm__rc.d1613[3]);
  scm__rc.d1613[62] = Scm_MakeExtendedPair(scm__rc.d1613[61], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[110]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-numeric?")), SCM_OBJ(&libcharchar_numericP__STUB), 0);
  libcharchar_numericP__STUB.common.info = scm__rc.d1613[62];
  libcharchar_numericP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[54]);
  scm__rc.d1613[63] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[28])),TRUE); /* char-whitespace? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[113]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[114]), scm__rc.d1613[63]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[115]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[116]), scm__rc.d1613[3]);
  scm__rc.d1613[64] = Scm_MakeExtendedPair(scm__rc.d1613[63], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[118]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-whitespace?")), SCM_OBJ(&libcharchar_whitespaceP__STUB), 0);
  libcharchar_whitespaceP__STUB.common.info = scm__rc.d1613[64];
  libcharchar_whitespaceP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[54]);
  scm__rc.d1613[65] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[29])),TRUE); /* char-upper-case? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[121]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[122]), scm__rc.d1613[65]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[123]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[124]), scm__rc.d1613[3]);
  scm__rc.d1613[66] = Scm_MakeExtendedPair(scm__rc.d1613[65], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[126]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-upper-case?")), SCM_OBJ(&libcharchar_upper_caseP__STUB), 0);
  libcharchar_upper_caseP__STUB.common.info = scm__rc.d1613[66];
  libcharchar_upper_caseP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[54]);
  scm__rc.d1613[67] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[30])),TRUE); /* char-lower-case? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[129]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[130]), scm__rc.d1613[67]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[131]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[132]), scm__rc.d1613[3]);
  scm__rc.d1613[68] = Scm_MakeExtendedPair(scm__rc.d1613[67], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[134]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-lower-case?")), SCM_OBJ(&libcharchar_lower_caseP__STUB), 0);
  libcharchar_lower_caseP__STUB.common.info = scm__rc.d1613[68];
  libcharchar_lower_caseP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[54]);
  scm__rc.d1613[69] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[31])),TRUE); /* char->integer */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[137]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[138]), scm__rc.d1613[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[139]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[140]), scm__rc.d1613[3]);
  scm__rc.d1613[70] = Scm_MakeExtendedPair(scm__rc.d1613[69], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[142]));
  scm__rc.d1613[71] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[32])),TRUE); /* <long> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[72]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[72]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[72]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[72]))[6] = scm__rc.d1613[71];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char->integer")), SCM_OBJ(&libcharchar_TOinteger__STUB), SCM_BINDING_INLINABLE);
  libcharchar_TOinteger__STUB.common.info = scm__rc.d1613[70];
  libcharchar_TOinteger__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[72]);
  scm__rc.d1613[79] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[33])),TRUE); /* integer->char */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[145]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[146]), scm__rc.d1613[79]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[147]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[148]), scm__rc.d1613[3]);
  scm__rc.d1613[80] = Scm_MakeExtendedPair(scm__rc.d1613[79], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[150]));
  scm__rc.d1613[81] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[34])),TRUE); /* <int> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[82]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[82]))[4] = scm__rc.d1613[81];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[82]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[82]))[6] = scm__rc.d1613[22];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("integer->char")), SCM_OBJ(&libcharinteger_TOchar__STUB), SCM_BINDING_INLINABLE);
  libcharinteger_TOchar__STUB.common.info = scm__rc.d1613[80];
  libcharinteger_TOchar__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[82]);
  scm__rc.d1613[89] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[35])),TRUE); /* char-upcase */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[153]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[154]), scm__rc.d1613[89]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[155]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[156]), scm__rc.d1613[3]);
  scm__rc.d1613[90] = Scm_MakeExtendedPair(scm__rc.d1613[89], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[158]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[91]))[3] = scm__rc.d1613[4];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[91]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[91]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[91]))[6] = scm__rc.d1613[22];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-upcase")), SCM_OBJ(&libcharchar_upcase__STUB), 0);
  libcharchar_upcase__STUB.common.info = scm__rc.d1613[90];
  libcharchar_upcase__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[91]);
  scm__rc.d1613[98] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[36])),TRUE); /* char-downcase */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[161]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[162]), scm__rc.d1613[98]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[163]), scm__rc.d1613[4]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[164]), scm__rc.d1613[3]);
  scm__rc.d1613[99] = Scm_MakeExtendedPair(scm__rc.d1613[98], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[166]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("char-downcase")), SCM_OBJ(&libcharchar_downcase__STUB), 0);
  libcharchar_downcase__STUB.common.info = scm__rc.d1613[99];
  libcharchar_downcase__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[91]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[100] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[37])),TRUE); /* digit->integer */
  scm__rc.d1613[101] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[38])),TRUE); /* ch */
  scm__rc.d1613[102] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[39]))); /* :optional */
  scm__rc.d1613[103] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[40])),TRUE); /* radix */
  scm__rc.d1613[104] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[41])),TRUE); /* extended-range? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[167]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[168]), scm__rc.d1613[103]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[169]), scm__rc.d1613[102]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[170]), scm__rc.d1613[101]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[173]), scm__rc.d1613[2]);
  scm__rc.d1613[105] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[42])),TRUE); /* gauche */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[174]), scm__rc.d1613[100]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[175]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[176]), scm__rc.d1613[3]);
  scm__rc.d1613[106] = Scm_MakeExtendedPair(scm__rc.d1613[100], SCM_OBJ(&scm__rc.d1614[170]), SCM_OBJ(&scm__rc.d1614[178]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[107]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[107]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[107]))[5] = scm__rc.d1613[23];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[107]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[107]))[7] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("digit->integer")), SCM_OBJ(&libchardigit_TOinteger__STUB), SCM_BINDING_INLINABLE);
  libchardigit_TOinteger__STUB.common.info = scm__rc.d1613[106];
  libchardigit_TOinteger__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[107]);
  scm__rc.d1613[115] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[43])),TRUE); /* integer->digit */
  scm__rc.d1613[116] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[44])),TRUE); /* n */
  scm__rc.d1613[117] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[45])),TRUE); /* basechar1 */
  scm__rc.d1613[118] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[46])),TRUE); /* basechar2 */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[179]), scm__rc.d1613[118]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[180]), scm__rc.d1613[117]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[181]), scm__rc.d1613[103]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[182]), scm__rc.d1613[102]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[183]), scm__rc.d1613[116]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[186]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[187]), scm__rc.d1613[115]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[188]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[189]), scm__rc.d1613[3]);
  scm__rc.d1613[119] = Scm_MakeExtendedPair(scm__rc.d1613[115], SCM_OBJ(&scm__rc.d1614[183]), SCM_OBJ(&scm__rc.d1614[191]));
  scm__rc.d1613[120] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[47])),TRUE); /* <fixnum> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[121]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[121]))[4] = scm__rc.d1613[120];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[121]))[5] = scm__rc.d1613[23];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[121]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[121]))[7] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("integer->digit")), SCM_OBJ(&libcharinteger_TOdigit__STUB), SCM_BINDING_INLINABLE);
  libcharinteger_TOdigit__STUB.common.info = scm__rc.d1613[119];
  libcharinteger_TOdigit__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[121]);
  scm__rc.d1613[129] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[48])),TRUE); /* ucs->char */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[192]), scm__rc.d1613[116]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[195]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[196]), scm__rc.d1613[129]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[197]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[198]), scm__rc.d1613[3]);
  scm__rc.d1613[130] = Scm_MakeExtendedPair(scm__rc.d1613[129], SCM_OBJ(&scm__rc.d1614[192]), SCM_OBJ(&scm__rc.d1614[200]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[131]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[131]))[4] = scm__rc.d1613[81];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[131]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[131]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("ucs->char")), SCM_OBJ(&libcharucs_TOchar__STUB), 0);
  libcharucs_TOchar__STUB.common.info = scm__rc.d1613[130];
  libcharucs_TOchar__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[131]);
  scm__rc.d1613[138] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[49])),TRUE); /* char->ucs */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[203]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[204]), scm__rc.d1613[138]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[205]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[206]), scm__rc.d1613[3]);
  scm__rc.d1613[139] = Scm_MakeExtendedPair(scm__rc.d1613[138], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[208]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[140]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[140]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[140]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[140]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char->ucs")), SCM_OBJ(&libcharchar_TOucs__STUB), 0);
  libcharchar_TOucs__STUB.common.info = scm__rc.d1613[139];
  libcharchar_TOucs__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[140]);
  scm__rc.d1613[147] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[50])),TRUE); /* gauche-character-encoding */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[209]), scm__rc.d1613[147]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[210]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[211]), scm__rc.d1613[3]);
  scm__rc.d1613[148] = Scm_MakeExtendedPair(scm__rc.d1613[147], SCM_NIL, SCM_OBJ(&scm__rc.d1614[212]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[149]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[149]))[4] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[149]))[5] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("gauche-character-encoding")), SCM_OBJ(&libchargauche_character_encoding__STUB), 0);
  libchargauche_character_encoding__STUB.common.info = scm__rc.d1613[148];
  libchargauche_character_encoding__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[149]);
  scm__rc.d1613[155] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[51])),TRUE); /* supported-character-encodings */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[213]), scm__rc.d1613[155]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[214]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[215]), scm__rc.d1613[3]);
  scm__rc.d1613[156] = Scm_MakeExtendedPair(scm__rc.d1613[155], SCM_NIL, SCM_OBJ(&scm__rc.d1614[216]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("supported-character-encodings")), SCM_OBJ(&libcharsupported_character_encodings__STUB), 0);
  libcharsupported_character_encodings__STUB.common.info = scm__rc.d1613[156];
  libcharsupported_character_encodings__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[149]);
  scm__rc.d1613[157] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[52])),TRUE); /* supported-character-encoding? */
  scm__rc.d1613[158] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[53])),TRUE); /* encoding */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[217]), scm__rc.d1613[158]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[220]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[221]), scm__rc.d1613[157]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[222]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[223]), scm__rc.d1613[3]);
  scm__rc.d1613[159] = Scm_MakeExtendedPair(scm__rc.d1613[157], SCM_OBJ(&scm__rc.d1614[217]), SCM_OBJ(&scm__rc.d1614[225]));
  scm__rc.d1613[160] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[54])),TRUE); /* <const-cstring> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[161]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[161]))[4] = scm__rc.d1613[160];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[161]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[161]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("supported-character-encoding?")), SCM_OBJ(&libcharsupported_character_encodingP__STUB), 0);
  libcharsupported_character_encodingP__STUB.common.info = scm__rc.d1613[159];
  libcharsupported_character_encodingP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[161]);
  scm__rc.d1613[168] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[55])),TRUE); /* char-title-case? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[228]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[229]), scm__rc.d1613[168]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[230]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[231]), scm__rc.d1613[3]);
  scm__rc.d1613[169] = Scm_MakeExtendedPair(scm__rc.d1613[168], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[233]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[170]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[170]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[170]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[170]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-title-case?")), SCM_OBJ(&libcharchar_title_caseP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_title_caseP__STUB.common.info = scm__rc.d1613[169];
  libcharchar_title_caseP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[170]);
  scm__rc.d1613[177] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[56])),TRUE); /* char-titlecase */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[236]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[237]), scm__rc.d1613[177]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[238]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[239]), scm__rc.d1613[3]);
  scm__rc.d1613[178] = Scm_MakeExtendedPair(scm__rc.d1613[177], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[241]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[179]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[179]))[4] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[179]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[179]))[6] = scm__rc.d1613[22];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-titlecase")), SCM_OBJ(&libcharchar_titlecase__STUB), 0);
  libcharchar_titlecase__STUB.common.info = scm__rc.d1613[178];
  libcharchar_titlecase__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[179]);
  scm__rc.d1613[186] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[57])),TRUE); /* char-foldcase */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[244]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[245]), scm__rc.d1613[186]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[246]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[247]), scm__rc.d1613[3]);
  scm__rc.d1613[187] = Scm_MakeExtendedPair(scm__rc.d1613[186], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[249]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-foldcase")), SCM_OBJ(&libcharchar_foldcase__STUB), 0);
  libcharchar_foldcase__STUB.common.info = scm__rc.d1613[187];
  libcharchar_foldcase__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[179]);
  scm__rc.d1613[188] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[59])),TRUE); /* Lu */
  scm__rc.d1613[189] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[60])),TRUE); /* Ll */
  scm__rc.d1613[190] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[61])),TRUE); /* Lt */
  scm__rc.d1613[191] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[62])),TRUE); /* Lm */
  scm__rc.d1613[192] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[63])),TRUE); /* Lo */
  scm__rc.d1613[193] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[64])),TRUE); /* Mn */
  scm__rc.d1613[194] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[65])),TRUE); /* Mc */
  scm__rc.d1613[195] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[66])),TRUE); /* Me */
  scm__rc.d1613[196] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[67])),TRUE); /* Nd */
  scm__rc.d1613[197] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[68])),TRUE); /* Nl */
  scm__rc.d1613[198] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[69])),TRUE); /* No */
  scm__rc.d1613[199] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[70])),TRUE); /* Pc */
  scm__rc.d1613[200] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[71])),TRUE); /* Pd */
  scm__rc.d1613[201] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[72])),TRUE); /* Ps */
  scm__rc.d1613[202] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[73])),TRUE); /* Pe */
  scm__rc.d1613[203] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[74])),TRUE); /* Pi */
  scm__rc.d1613[204] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[75])),TRUE); /* Pf */
  scm__rc.d1613[205] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[76])),TRUE); /* Po */
  scm__rc.d1613[206] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[77])),TRUE); /* Sm */
  scm__rc.d1613[207] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[78])),TRUE); /* Sc */
  scm__rc.d1613[208] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[79])),TRUE); /* Sk */
  scm__rc.d1613[209] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[80])),TRUE); /* So */
  scm__rc.d1613[210] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[81])),TRUE); /* Zs */
  scm__rc.d1613[211] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[82])),TRUE); /* Zl */
  scm__rc.d1613[212] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[83])),TRUE); /* Zp */
  scm__rc.d1613[213] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[84])),TRUE); /* Cc */
  scm__rc.d1613[214] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[85])),TRUE); /* Cf */
  scm__rc.d1613[215] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[86])),TRUE); /* Cs */
  scm__rc.d1613[216] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[87])),TRUE); /* Co */
  scm__rc.d1613[217] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[88])),TRUE); /* Cn */
  scm__rc.d1613[218] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[58])),TRUE); /* char-general-category */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[252]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[253]), scm__rc.d1613[218]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[254]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[255]), scm__rc.d1613[3]);
  scm__rc.d1613[219] = Scm_MakeExtendedPair(scm__rc.d1613[218], SCM_OBJ(&scm__rc.d1614[94]), SCM_OBJ(&scm__rc.d1614[257]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-general-category")), SCM_OBJ(&libcharchar_general_category__STUB), SCM_BINDING_INLINABLE);
  libcharchar_general_category__STUB.common.info = scm__rc.d1613[219];
  libcharchar_general_category__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[140]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[220] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[89])),TRUE); /* *char-code-max* */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[220]), Scm_MakeInteger(SCM_CHAR_MAX), SCM_BINDING_CONST);

  scm__rc.d1613[221] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[90])),TRUE); /* char-set? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[260]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[261]), scm__rc.d1613[221]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[262]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[263]), scm__rc.d1613[3]);
  scm__rc.d1613[222] = Scm_MakeExtendedPair(scm__rc.d1613[221], SCM_OBJ(&scm__rc.d1614[1]), SCM_OBJ(&scm__rc.d1614[265]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[223]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[223]))[4] = scm__rc.d1613[6];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[223]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[223]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set?")), SCM_OBJ(&libcharchar_setP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_setP__STUB.common.info = scm__rc.d1613[222];
  libcharchar_setP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[223]);
  scm__rc.d1613[230] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[91])),TRUE); /* char-set */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[268]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[269]), scm__rc.d1613[230]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[270]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[271]), scm__rc.d1613[3]);
  scm__rc.d1613[231] = Scm_MakeExtendedPair(scm__rc.d1613[230], SCM_OBJ(&scm__rc.d1614[11]), SCM_OBJ(&scm__rc.d1614[273]));
  scm__rc.d1613[232] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[92])),TRUE); /* <char-set> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[233]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[233]))[4] = scm__rc.d1613[23];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[233]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[233]))[6] = scm__rc.d1613[232];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set")), SCM_OBJ(&libcharchar_set__STUB), 0);
  libcharchar_set__STUB.common.info = scm__rc.d1613[231];
  libcharchar_set__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[233]);
  scm__rc.d1613[240] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[93])),TRUE); /* char-set-copy */
  scm__rc.d1613[241] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[94])),TRUE); /* cs */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[274]), scm__rc.d1613[241]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[277]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[278]), scm__rc.d1613[240]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[279]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[280]), scm__rc.d1613[3]);
  scm__rc.d1613[242] = Scm_MakeExtendedPair(scm__rc.d1613[240], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[282]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[243]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[243]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[243]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[243]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-copy")), SCM_OBJ(&libcharchar_set_copy__STUB), 0);
  libcharchar_set_copy__STUB.common.info = scm__rc.d1613[242];
  libcharchar_set_copy__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[243]);
  scm__rc.d1613[250] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[95])),TRUE); /* char-set-freeze */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[285]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[286]), scm__rc.d1613[250]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[287]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[288]), scm__rc.d1613[3]);
  scm__rc.d1613[251] = Scm_MakeExtendedPair(scm__rc.d1613[250], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[290]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-freeze")), SCM_OBJ(&libcharchar_set_freeze__STUB), 0);
  libcharchar_set_freeze__STUB.common.info = scm__rc.d1613[251];
  libcharchar_set_freeze__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[243]);
  scm__rc.d1613[252] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[96])),TRUE); /* char-set-freeze! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[293]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[294]), scm__rc.d1613[252]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[295]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[296]), scm__rc.d1613[3]);
  scm__rc.d1613[253] = Scm_MakeExtendedPair(scm__rc.d1613[252], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[298]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-freeze!")), SCM_OBJ(&libcharchar_set_freezeX__STUB), 0);
  libcharchar_set_freezeX__STUB.common.info = scm__rc.d1613[253];
  libcharchar_set_freezeX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[243]);
  scm__rc.d1613[254] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[97])),TRUE); /* char-set-size */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[300]), scm__rc.d1613[254]);
  scm__rc.d1613[255] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[98])),TRUE); /* range */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[301]), scm__rc.d1613[255]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[304]), scm__rc.d1613[2]);
  scm__rc.d1613[256] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[99])),TRUE); /* unused-args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[305]), scm__rc.d1613[256]);
  scm__rc.d1613[257] = Scm_MakeExtendedPair(SCM_OBJ(&scm__rc.d1614[300]), SCM_OBJ(&scm__rc.d1614[301]), SCM_OBJ(&scm__rc.d1614[307]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[308]), scm__rc.d1613[257]);
  scm__rc.d1613[259] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[100])),TRUE); /* %char-set-ranges */
  scm__rc.d1613[258] = Scm_MakeIdentifier(scm__rc.d1613[259], SCM_MODULE(Scm_GaucheInternalModule()), SCM_NIL); /* gauche.internal#%char-set-ranges */
  scm__rc.d1613[261] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[101])),TRUE); /* for-each */
  scm__rc.d1613[262] = SCM_OBJ(Scm_FindModule(SCM_SYMBOL(scm__rc.d1613[105]), SCM_FIND_MODULE_CREATE|SCM_FIND_MODULE_PLACEHOLDING)); /* module gauche */
  scm__rc.d1613[260] = Scm_MakeIdentifier(scm__rc.d1613[261], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#for-each */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[311]), scm__rc.d1613[2]);
  scm__rc.d1613[263] = Scm_MakeExtendedPair(scm__rc.d1613[254], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[312]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[313]), scm__rc.d1613[263]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1621[1]))->name = scm__rc.d1613[254];/* char-set-size */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[10]))[11] = SCM_WORD(scm__rc.d1613[258]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[10]))[13] = SCM_WORD(scm__rc.d1613[260]);
  ScmObj G1622 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1621[1]), NULL);

  Scm_MakeBinding(SCM_MODULE(Scm_CurrentModule()) /*  */, SCM_SYMBOL(scm__rc.d1613[254]) /* char-set-size */, G1622,0);

  scm__rc.d1613[264] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[102]))); /* :error */
  scm__rc.d1613[265] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[103]))); /* :posix-bracket */
  scm__rc.d1613[266] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[104])),TRUE); /* read-char-set */
  scm__rc.d1613[267] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[105])),TRUE); /* port */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[314]), scm__rc.d1613[267]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[317]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[318]), scm__rc.d1613[266]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[319]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[320]), scm__rc.d1613[3]);
  scm__rc.d1613[268] = Scm_MakeExtendedPair(scm__rc.d1613[266], SCM_OBJ(&scm__rc.d1614[314]), SCM_OBJ(&scm__rc.d1614[322]));
  scm__rc.d1613[269] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[106])),TRUE); /* <input-port> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[270]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[270]))[4] = scm__rc.d1613[269];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[270]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[270]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("read-char-set")), SCM_OBJ(&libcharread_char_set__STUB), 0);
  libcharread_char_set__STUB.common.info = scm__rc.d1613[268];
  libcharread_char_set__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[270]);
  scm__rc.d1613[277] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[107])),TRUE); /* char-set-contains? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[323]), scm__rc.d1613[101]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[324]), scm__rc.d1613[241]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[327]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[328]), scm__rc.d1613[277]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[329]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[330]), scm__rc.d1613[3]);
  scm__rc.d1613[278] = Scm_MakeExtendedPair(scm__rc.d1613[277], SCM_OBJ(&scm__rc.d1614[324]), SCM_OBJ(&scm__rc.d1614[332]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[279]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[279]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[279]))[5] = scm__rc.d1613[22];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[279]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[279]))[7] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-contains?")), SCM_OBJ(&libcharchar_set_containsP__STUB), SCM_BINDING_INLINABLE);
  libcharchar_set_containsP__STUB.common.info = scm__rc.d1613[278];
  libcharchar_set_containsP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[279]);
  scm__rc.d1613[287] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[108])),TRUE); /* char-set-complement! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[335]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[336]), scm__rc.d1613[287]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[337]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[338]), scm__rc.d1613[3]);
  scm__rc.d1613[288] = Scm_MakeExtendedPair(scm__rc.d1613[287], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[340]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-complement!")), SCM_OBJ(&libcharchar_set_complementX__STUB), 0);
  libcharchar_set_complementX__STUB.common.info = scm__rc.d1613[288];
  libcharchar_set_complementX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[243]);
  scm__rc.d1613[289] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[109])),TRUE); /* char-set-complement */
  scm__rc.d1613[290] = Scm_MakeIdentifier(scm__rc.d1613[240], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#char-set-copy */
  scm__rc.d1613[291] = Scm_MakeIdentifier(scm__rc.d1613[287], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#char-set-complement! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[343]), scm__rc.d1613[2]);
  scm__rc.d1613[292] = Scm_MakeExtendedPair(scm__rc.d1613[289], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[344]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[345]), scm__rc.d1613[292]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1621[2]))->name = scm__rc.d1613[289];/* char-set-complement */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[26]))[4] = SCM_WORD(scm__rc.d1613[290]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[26]))[6] = SCM_WORD(scm__rc.d1613[291]);
  ScmObj G1623 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1621[2]), NULL);

  Scm_MakeBinding(SCM_MODULE(Scm_CurrentModule()) /*  */, SCM_SYMBOL(scm__rc.d1613[289]) /* char-set-complement */, G1623,0);

  scm__rc.d1613[293] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[110])),TRUE); /* char-set-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[348]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[349]), scm__rc.d1613[293]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[350]), scm__rc.d1613[105]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[351]), scm__rc.d1613[3]);
  scm__rc.d1613[294] = Scm_MakeExtendedPair(scm__rc.d1613[293], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[353]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[295]))[3] = scm__rc.d1613[105];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[295]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[295]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[295]))[6] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("char-set-immutable?")), SCM_OBJ(&libcharchar_set_immutableP__STUB), 0);
  libcharchar_set_immutableP__STUB.common.info = scm__rc.d1613[294];
  libcharchar_set_immutableP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[295]);
  scm__rc.d1613[302] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[111])),TRUE); /* char-set-hash */
  scm__rc.d1613[303] = Scm_MakeIntegerU(536870911U);
  scm__rc.d1613[304] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[113])),TRUE); /* lambda */
  scm__rc.d1613[305] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[114])),TRUE); /* bound */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[354]), scm__rc.d1613[303]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[355]), scm__rc.d1613[305]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[357]), scm__rc.d1613[102]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[358]), scm__rc.d1613[241]);
  scm__rc.d1613[306] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[115])),TRUE); /* fold */
  scm__rc.d1613[307] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[116])),TRUE); /* ^ */
  scm__rc.d1613[308] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[117])),TRUE); /* val */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[359]), scm__rc.d1613[308]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[360]), scm__rc.d1613[255]);
  scm__rc.d1613[309] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[118])),TRUE); /* modulo */
  scm__rc.d1613[310] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[119])),TRUE); /* hash */
  scm__rc.d1613[311] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[120])),TRUE); /* + */
  scm__rc.d1613[312] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[121])),TRUE); /* car */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[361]), scm__rc.d1613[312]);
  scm__rc.d1613[313] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[122])),TRUE); /* cdr */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[362]), scm__rc.d1613[313]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[365]), scm__rc.d1613[308]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[366]), scm__rc.d1613[311]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[368]), scm__rc.d1613[310]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[369]), scm__rc.d1613[305]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[371]), scm__rc.d1613[309]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[374]), scm__rc.d1613[307]);
  scm__rc.d1613[314] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[123])),TRUE); /* with-module */
  scm__rc.d1613[315] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[124])),TRUE); /* gauche.internal */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[375]), scm__rc.d1613[259]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[376]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[377]), scm__rc.d1613[314]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[382]), scm__rc.d1613[306]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[385]), scm__rc.d1613[304]);
  scm__rc.d1613[317] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[102])),TRUE); /* error */
  scm__rc.d1613[316] = Scm_MakeIdentifier(scm__rc.d1613[317], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#error */
  scm__rc.d1613[318] = Scm_MakeIdentifier(scm__rc.d1613[310], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#hash */
  scm__rc.d1613[319] = Scm_MakeIdentifier(scm__rc.d1613[309], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#modulo */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[386]), scm__rc.d1613[302]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[389]), scm__rc.d1613[2]);
  scm__rc.d1613[320] = Scm_MakeExtendedPair(SCM_OBJ(&scm__rc.d1614[386]), SCM_OBJ(&scm__rc.d1614[360]), SCM_OBJ(&scm__rc.d1614[390]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[391]), scm__rc.d1613[320]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[34]))[8] = SCM_WORD(scm__rc.d1613[318]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[34]))[12] = SCM_WORD(scm__rc.d1613[319]);
  scm__rc.d1613[321] = Scm_MakeIdentifier(scm__rc.d1613[306], SCM_MODULE(scm__rc.d1613[262]), SCM_NIL); /* gauche#fold */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[394]), scm__rc.d1613[2]);
  scm__rc.d1613[322] = Scm_MakeExtendedPair(scm__rc.d1613[302], SCM_OBJ(&scm__rc.d1614[358]), SCM_OBJ(&scm__rc.d1614[395]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[396]), scm__rc.d1613[322]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1621[4]))->name = scm__rc.d1613[302];/* char-set-hash */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]))[4] = SCM_WORD(scm__rc.d1613[303]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]))[29] = SCM_WORD(scm__rc.d1613[316]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]))[38] = SCM_WORD(scm__rc.d1613[258]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1620[48]))[40] = SCM_WORD(scm__rc.d1613[321]);
  ScmObj G1627 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1621[4]), NULL);

  Scm_MakeBinding(SCM_MODULE(Scm_CurrentModule()) /*  */, SCM_SYMBOL(scm__rc.d1613[302]) /* char-set-hash */, G1627,0);

   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())));
  scm__rc.d1613[323] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[125])),TRUE); /* %char-set-equal? */
  scm__rc.d1613[324] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[126])),TRUE); /* x */
  scm__rc.d1613[325] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[127])),TRUE); /* y */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[397]), scm__rc.d1613[325]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[398]), scm__rc.d1613[324]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[401]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[402]), scm__rc.d1613[323]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[403]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[404]), scm__rc.d1613[3]);
  scm__rc.d1613[326] = Scm_MakeExtendedPair(scm__rc.d1613[323], SCM_OBJ(&scm__rc.d1614[398]), SCM_OBJ(&scm__rc.d1614[406]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[327]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[327]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[327]))[5] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[327]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[327]))[7] = scm__rc.d1613[8];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-equal?")), SCM_OBJ(&libchar_25char_set_equalP__STUB), 0);
  libchar_25char_set_equalP__STUB.common.info = scm__rc.d1613[326];
  libchar_25char_set_equalP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[327]);
  scm__rc.d1613[335] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[128])),TRUE); /* %char-set<=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[409]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[410]), scm__rc.d1613[335]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[411]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[412]), scm__rc.d1613[3]);
  scm__rc.d1613[336] = Scm_MakeExtendedPair(scm__rc.d1613[335], SCM_OBJ(&scm__rc.d1614[398]), SCM_OBJ(&scm__rc.d1614[414]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set<=?")), SCM_OBJ(&libchar_25char_set_LT_3dP__STUB), 0);
  libchar_25char_set_LT_3dP__STUB.common.info = scm__rc.d1613[336];
  libchar_25char_set_LT_3dP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[327]);
  scm__rc.d1613[337] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[129])),TRUE); /* %char-set-add-chars! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[415]), scm__rc.d1613[241]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[418]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[419]), scm__rc.d1613[337]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[420]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[421]), scm__rc.d1613[3]);
  scm__rc.d1613[338] = Scm_MakeExtendedPair(scm__rc.d1613[337], SCM_OBJ(&scm__rc.d1614[415]), SCM_OBJ(&scm__rc.d1614[423]));
  scm__rc.d1613[339] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[130])),TRUE); /* <list> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[340]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[340]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[340]))[5] = scm__rc.d1613[339];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[340]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[340]))[7] = scm__rc.d1613[232];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-add-chars!")), SCM_OBJ(&libchar_25char_set_add_charsX__STUB), 0);
  libchar_25char_set_add_charsX__STUB.common.info = scm__rc.d1613[338];
  libchar_25char_set_add_charsX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[340]);
  scm__rc.d1613[348] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[131])),TRUE); /* %char-set-add-range! */
  scm__rc.d1613[349] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[132])),TRUE); /* from */
  scm__rc.d1613[350] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[133])),TRUE); /* to */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[424]), scm__rc.d1613[350]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[425]), scm__rc.d1613[349]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[426]), scm__rc.d1613[241]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[429]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[430]), scm__rc.d1613[348]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[431]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[432]), scm__rc.d1613[3]);
  scm__rc.d1613[351] = Scm_MakeExtendedPair(scm__rc.d1613[348], SCM_OBJ(&scm__rc.d1614[426]), SCM_OBJ(&scm__rc.d1614[434]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[5] = scm__rc.d1613[6];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[6] = scm__rc.d1613[6];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[352]))[8] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-add-range!")), SCM_OBJ(&libchar_25char_set_add_rangeX__STUB), 0);
  libchar_25char_set_add_rangeX__STUB.common.info = scm__rc.d1613[351];
  libchar_25char_set_add_rangeX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[352]);
  scm__rc.d1613[361] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[134])),TRUE); /* %char-set-add! */
  scm__rc.d1613[362] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[135])),TRUE); /* dst */
  scm__rc.d1613[363] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[136])),TRUE); /* src */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[435]), scm__rc.d1613[363]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[436]), scm__rc.d1613[362]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[439]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[440]), scm__rc.d1613[361]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[441]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[442]), scm__rc.d1613[3]);
  scm__rc.d1613[364] = Scm_MakeExtendedPair(scm__rc.d1613[361], SCM_OBJ(&scm__rc.d1614[436]), SCM_OBJ(&scm__rc.d1614[444]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[365]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[365]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[365]))[5] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[365]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[365]))[7] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-add!")), SCM_OBJ(&libchar_25char_set_addX__STUB), 0);
  libchar_25char_set_addX__STUB.common.info = scm__rc.d1613[364];
  libchar_25char_set_addX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[365]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[447]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[448]), scm__rc.d1613[3]);
  scm__rc.d1613[373] = Scm_MakeExtendedPair(scm__rc.d1613[259], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[450]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[374]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[374]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[374]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[374]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-ranges")), SCM_OBJ(&libchar_25char_set_ranges__STUB), 0);
  libchar_25char_set_ranges__STUB.common.info = scm__rc.d1613[373];
  libchar_25char_set_ranges__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[374]);
  scm__rc.d1613[381] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[137])),TRUE); /* %char-set-predefined */
  scm__rc.d1613[382] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[138])),TRUE); /* num */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[451]), scm__rc.d1613[382]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[454]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[455]), scm__rc.d1613[381]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[456]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[457]), scm__rc.d1613[3]);
  scm__rc.d1613[383] = Scm_MakeExtendedPair(scm__rc.d1613[381], SCM_OBJ(&scm__rc.d1614[451]), SCM_OBJ(&scm__rc.d1614[459]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[384]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[384]))[4] = scm__rc.d1613[120];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[384]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[384]))[6] = scm__rc.d1613[6];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-predefined")), SCM_OBJ(&libchar_25char_set_predefined__STUB), 0);
  libchar_25char_set_predefined__STUB.common.info = scm__rc.d1613[383];
  libchar_25char_set_predefined__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[384]);
  scm__rc.d1613[391] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[139])),TRUE); /* %char-set-case-fold! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[462]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[463]), scm__rc.d1613[391]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[464]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[465]), scm__rc.d1613[3]);
  scm__rc.d1613[392] = Scm_MakeExtendedPair(scm__rc.d1613[391], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[467]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-case-fold!")), SCM_OBJ(&libchar_25char_set_case_foldX__STUB), 0);
  libchar_25char_set_case_foldX__STUB.common.info = scm__rc.d1613[392];
  libchar_25char_set_case_foldX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[374]);
  scm__rc.d1613[393] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[140])),TRUE); /* %char-set-dump */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[470]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[471]), scm__rc.d1613[393]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[472]), scm__rc.d1613[315]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[473]), scm__rc.d1613[3]);
  scm__rc.d1613[394] = Scm_MakeExtendedPair(scm__rc.d1613[393], SCM_OBJ(&scm__rc.d1614[274]), SCM_OBJ(&scm__rc.d1614[475]));
  scm__rc.d1613[395] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[141])),TRUE); /* <void> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[396]))[3] = scm__rc.d1613[315];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[396]))[4] = scm__rc.d1613[232];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[396]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[396]))[6] = scm__rc.d1613[395];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheInternalModule())), SCM_SYMBOL(SCM_INTERN("%char-set-dump")), SCM_OBJ(&libchar_25char_set_dump__STUB), 0);
  libchar_25char_set_dump__STUB.common.info = scm__rc.d1613[394];
  libchar_25char_set_dump__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[396]);
  Scm_VMExecuteToplevels(toplevels);
}
