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

#line 37 "libvec.scm"
#include <gauche/vminsn.h>


#line 38 "libvec.scm"
#include <gauche/priv/vectorP.h>


static ScmObj libvecvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector__STUB, 0, 1,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector, SCM_MAKE_INT(SCM_VM_VEC), NULL);


static ScmObj libvecvectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvectorP__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvectorP, SCM_MAKE_INT(SCM_VM_VECTORP), NULL);


static ScmObj libvecvector_length(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_length__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector_length, SCM_MAKE_INT(SCM_VM_VEC_LEN), NULL);


static ScmObj libvecvector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_ref__STUB, 2, 2,1, SCM_FALSE,0, libvecvector_ref, NULL, NULL);


static ScmObj libvecvector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecvector_setX__STUB, 3, 0,SCM_FALSE,libvecvector_setX, NULL, NULL);


static ScmObj libvecvector_TOlist(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_TOlist__STUB, 1, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector_TOlist, NULL, NULL);


static ScmObj libveclist_TOvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libveclist_TOvector__STUB, 1, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libveclist_TOvector, NULL, NULL);


static ScmObj libvecvector_fillX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecvector_fillX__STUB, 2, 3,SCM_FALSE,libvecvector_fillX, NULL, NULL);


static ScmObj libvecvector_copy(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecvector_copy__STUB, 1, 4,SCM_FALSE,libvecvector_copy, NULL, NULL);


static ScmObj libvecvector_copyX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_copyX__STUB, 3, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector_copyX, NULL, NULL);


static ScmObj libvecvector_append(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_append__STUB, 0, 1,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector_append, NULL, NULL);


static ScmObj libvecvector_immutableP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecvector_immutableP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecvector_immutableP, NULL, NULL);


static ScmObj libvecmake_weak_vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecmake_weak_vector__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecmake_weak_vector, NULL, NULL);


static ScmObj libvecweak_vector_length(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecweak_vector_length__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecweak_vector_length, NULL, NULL);


static ScmObj libvecweak_vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecweak_vector_ref__STUB, 2, 2,SCM_FALSE,libvecweak_vector_ref, NULL, NULL);


static ScmObj libvecweak_vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecweak_vector_setX__STUB, 3, 0,SCM_FALSE,libvecweak_vector_setX, NULL, NULL);


static ScmObj libvecs8vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs8vector_setX__STUB, 3, 2,SCM_FALSE,libvecs8vector_setX, NULL, NULL);


static ScmObj libvecs8vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecs8vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecs8vector_ref, NULL, NULL);


static ScmObj libvecu8vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu8vector_setX__STUB, 3, 2,SCM_FALSE,libvecu8vector_setX, NULL, NULL);


static ScmObj libvecu8vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecu8vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecu8vector_ref, NULL, NULL);


static ScmObj libvecs16vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs16vector_setX__STUB, 3, 2,SCM_FALSE,libvecs16vector_setX, NULL, NULL);


static ScmObj libvecs16vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecs16vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecs16vector_ref, NULL, NULL);


static ScmObj libvecu16vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu16vector_setX__STUB, 3, 2,SCM_FALSE,libvecu16vector_setX, NULL, NULL);


static ScmObj libvecu16vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecu16vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecu16vector_ref, NULL, NULL);


static ScmObj libvecs32vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs32vector_setX__STUB, 3, 2,SCM_FALSE,libvecs32vector_setX, NULL, NULL);


static ScmObj libvecs32vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecs32vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecs32vector_ref, NULL, NULL);


static ScmObj libvecu32vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu32vector_setX__STUB, 3, 2,SCM_FALSE,libvecu32vector_setX, NULL, NULL);


static ScmObj libvecu32vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecu32vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecu32vector_ref, NULL, NULL);


static ScmObj libvecs64vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs64vector_setX__STUB, 3, 2,SCM_FALSE,libvecs64vector_setX, NULL, NULL);


static ScmObj libvecs64vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecs64vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecs64vector_ref, NULL, NULL);


static ScmObj libvecu64vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu64vector_setX__STUB, 3, 2,SCM_FALSE,libvecu64vector_setX, NULL, NULL);


static ScmObj libvecu64vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecu64vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecu64vector_ref, NULL, NULL);


static ScmObj libvecf16vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf16vector_setX__STUB, 3, 2,SCM_FALSE,libvecf16vector_setX, NULL, NULL);


static ScmObj libvecf16vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecf16vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecf16vector_ref, NULL, NULL);


static ScmObj libvecf32vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf32vector_setX__STUB, 3, 2,SCM_FALSE,libvecf32vector_setX, NULL, NULL);


static ScmObj libvecf32vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecf32vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecf32vector_ref, NULL, NULL);


static ScmObj libvecf64vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf64vector_setX__STUB, 3, 2,SCM_FALSE,libvecf64vector_setX, NULL, NULL);


static ScmObj libvecf64vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecf64vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecf64vector_ref, NULL, NULL);


static ScmObj libvecc32vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc32vector_setX__STUB, 3, 2,SCM_FALSE,libvecc32vector_setX, NULL, NULL);


static ScmObj libvecc32vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecc32vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecc32vector_ref, NULL, NULL);


static ScmObj libvecc64vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc64vector_setX__STUB, 3, 2,SCM_FALSE,libvecc64vector_setX, NULL, NULL);


static ScmObj libvecc64vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecc64vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecc64vector_ref, NULL, NULL);


static ScmObj libvecc128vector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc128vector_setX__STUB, 3, 2,SCM_FALSE,libvecc128vector_setX, NULL, NULL);


static ScmObj libvecc128vector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecc128vector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecc128vector_ref, NULL, NULL);


static ScmObj libvecuvector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecuvector_setX__STUB, 3, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecuvector_setX, NULL, NULL);


static ScmObj libvecuvector_ref(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecuvector_ref__STUB, 2, 2,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecuvector_ref, NULL, NULL);


static ScmObj libvecuvector_length(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecuvector_length__STUB, 1, 0,1, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecuvector_length, NULL, NULL);


static ScmObj libvecuvector_immutableP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecuvector_immutableP__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecuvector_immutableP, NULL, NULL);


static ScmObj libvecuvectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecuvectorP__STUB, 1, 0,1, SCM_FALSE,0, libvecuvectorP, NULL, NULL);


static ScmObj libvecu8vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu8vectorP__STUB, 1, 0,SCM_FALSE,libvecu8vectorP, NULL, NULL);


static ScmObj libvecs8vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs8vectorP__STUB, 1, 0,SCM_FALSE,libvecs8vectorP, NULL, NULL);


static ScmObj libvecu16vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu16vectorP__STUB, 1, 0,SCM_FALSE,libvecu16vectorP, NULL, NULL);


static ScmObj libvecs16vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs16vectorP__STUB, 1, 0,SCM_FALSE,libvecs16vectorP, NULL, NULL);


static ScmObj libvecu32vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu32vectorP__STUB, 1, 0,SCM_FALSE,libvecu32vectorP, NULL, NULL);


static ScmObj libvecs32vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs32vectorP__STUB, 1, 0,SCM_FALSE,libvecs32vectorP, NULL, NULL);


static ScmObj libvecu64vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu64vectorP__STUB, 1, 0,SCM_FALSE,libvecu64vectorP, NULL, NULL);


static ScmObj libvecs64vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs64vectorP__STUB, 1, 0,SCM_FALSE,libvecs64vectorP, NULL, NULL);


static ScmObj libvecf16vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf16vectorP__STUB, 1, 0,SCM_FALSE,libvecf16vectorP, NULL, NULL);


static ScmObj libvecf32vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf32vectorP__STUB, 1, 0,SCM_FALSE,libvecf32vectorP, NULL, NULL);


static ScmObj libvecf64vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecf64vectorP__STUB, 1, 0,SCM_FALSE,libvecf64vectorP, NULL, NULL);


static ScmObj libvecc32vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc32vectorP__STUB, 1, 0,SCM_FALSE,libvecc32vectorP, NULL, NULL);


static ScmObj libvecc64vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc64vectorP__STUB, 1, 0,SCM_FALSE,libvecc64vectorP, NULL, NULL);


static ScmObj libvecc128vectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecc128vectorP__STUB, 1, 0,SCM_FALSE,libvecc128vectorP, NULL, NULL);


static ScmObj libvecbitvectorP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvectorP__STUB, 1, 0,SCM_FALSE,libvecbitvectorP, NULL, NULL);


static ScmObj libvecbitvector_length(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector_length__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector_length, NULL, NULL);


static ScmObj libvecmake_bitvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_bitvector__STUB, 1, 2,SCM_FALSE,libvecmake_bitvector, NULL, NULL);


static ScmObj libvecbitvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector__STUB, 0, 1,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector, NULL, NULL);


static ScmObj libveclist_TObitvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libveclist_TObitvector__STUB, 1, 0,SCM_FALSE,libveclist_TObitvector, NULL, NULL);


static ScmObj libvecstring_TObitvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecstring_TObitvector__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecstring_TObitvector, NULL, NULL);


static ScmObj libvecbitvector_TOstring(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector_TOstring__STUB, 1, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector_TOstring, NULL, NULL);


static ScmObj libvecbit_TOinteger(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbit_TOinteger__STUB, 1, 0,SCM_FALSE,libvecbit_TOinteger, NULL, NULL);


static ScmObj libvecbit_TOboolean(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbit_TOboolean__STUB, 1, 0,SCM_FALSE,libvecbit_TOboolean, NULL, NULL);


static ScmObj libvecbitvector_setX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvector_setX__STUB, 3, 0,SCM_FALSE,libvecbitvector_setX, NULL, NULL);


static ScmObj libvecbitvector_ref_2fint(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvector_ref_2fint__STUB, 2, 2,SCM_FALSE,libvecbitvector_ref_2fint, NULL, NULL);


static ScmObj libvecbitvector_ref_2fbool(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvector_ref_2fbool__STUB, 2, 2,SCM_FALSE,libvecbitvector_ref_2fbool, NULL, NULL);


static ScmObj libvecbitvector_copy(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector_copy__STUB, 1, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector_copy, NULL, NULL);


static ScmObj libvecbitvector_copyX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector_copyX__STUB, 3, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector_copyX, 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 d1561[134];
} scm__sc SCM_UNUSED = {
  {   /* ScmString d1561 */
      SCM_STRING_CONST_INITIALIZER("vector", 6, 6),
      SCM_STRING_CONST_INITIALIZER("rest", 4, 4),
      SCM_STRING_CONST_INITIALIZER("args", 4, 4),
      SCM_STRING_CONST_INITIALIZER("source-info", 11, 11),
      SCM_STRING_CONST_INITIALIZER("libvec.scm", 10, 10),
      SCM_STRING_CONST_INITIALIZER("bind-info", 9, 9),
      SCM_STRING_CONST_INITIALIZER("scheme", 6, 6),
      SCM_STRING_CONST_INITIALIZER("vector\077", 7, 7),
      SCM_STRING_CONST_INITIALIZER("obj", 3, 3),
      SCM_STRING_CONST_INITIALIZER("vector-length", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vec", 3, 3),
      SCM_STRING_CONST_INITIALIZER("vector-ref", 10, 10),
      SCM_STRING_CONST_INITIALIZER("k", 1, 1),
      SCM_STRING_CONST_INITIALIZER("optional", 8, 8),
      SCM_STRING_CONST_INITIALIZER("fallback", 8, 8),
      SCM_STRING_CONST_INITIALIZER("vector-set!", 11, 11),
      SCM_STRING_CONST_INITIALIZER("vector->list", 12, 12),
      SCM_STRING_CONST_INITIALIZER("start", 5, 5),
      SCM_STRING_CONST_INITIALIZER("end", 3, 3),
      SCM_STRING_CONST_INITIALIZER("list->vector", 12, 12),
      SCM_STRING_CONST_INITIALIZER("list", 4, 4),
      SCM_STRING_CONST_INITIALIZER("vector-fill!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("fill", 4, 4),
      SCM_STRING_CONST_INITIALIZER("vector-copy", 11, 11),
      SCM_STRING_CONST_INITIALIZER("v", 1, 1),
      SCM_STRING_CONST_INITIALIZER("vector-copy!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("t", 1, 1),
      SCM_STRING_CONST_INITIALIZER("tstart", 6, 6),
      SCM_STRING_CONST_INITIALIZER("s", 1, 1),
      SCM_STRING_CONST_INITIALIZER("sstart", 6, 6),
      SCM_STRING_CONST_INITIALIZER("send", 4, 4),
      SCM_STRING_CONST_INITIALIZER("vector-append", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vecs", 4, 4),
      SCM_STRING_CONST_INITIALIZER("vector-immutable\077", 17, 17),
      SCM_STRING_CONST_INITIALIZER("gauche", 6, 6),
      SCM_STRING_CONST_INITIALIZER("vector->string", 14, 14),
      SCM_STRING_CONST_INITIALIZER("too many arguments for", 22, 22),
      SCM_STRING_CONST_INITIALIZER("lambda", 6, 6),
      SCM_STRING_CONST_INITIALIZER("list->string", 12, 12),
      SCM_STRING_CONST_INITIALIZER("error", 5, 5),
      SCM_STRING_CONST_INITIALIZER("unused-args", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string->vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("string->list", 12, 12),
      SCM_STRING_CONST_INITIALIZER("make-weak-vector", 16, 16),
      SCM_STRING_CONST_INITIALIZER("size", 4, 4),
      SCM_STRING_CONST_INITIALIZER("weak-vector-length", 18, 18),
      SCM_STRING_CONST_INITIALIZER("wv", 2, 2),
      SCM_STRING_CONST_INITIALIZER("weak-vector-ref", 15, 15),
      SCM_STRING_CONST_INITIALIZER("index", 5, 5),
      SCM_STRING_CONST_INITIALIZER("weak-vector-set!", 16, 16),
      SCM_STRING_CONST_INITIALIZER("val", 3, 3),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S8", 14, 14),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U8", 14, 14),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_S64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_U64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F16", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F32", 15, 15),
      SCM_STRING_CONST_INITIALIZER("SCM_UVECTOR_F64", 15, 15),
      SCM_STRING_CONST_INITIALIZER("s8vector-set!", 13, 13),
      SCM_STRING_CONST_INITIALIZER("i", 1, 1),
      SCM_STRING_CONST_INITIALIZER("clamp", 5, 5),
      SCM_STRING_CONST_INITIALIZER("s8vector-ref", 12, 12),
      SCM_STRING_CONST_INITIALIZER("u8vector-set!", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u8vector-ref", 12, 12),
      SCM_STRING_CONST_INITIALIZER("s16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("s16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("u16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("s32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("s32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("u32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("s64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("s64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("u64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("f16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("f32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("f64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("c32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("c64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c128vector-set!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("c128vector-ref", 14, 14),
      SCM_STRING_CONST_INITIALIZER("uvector-set!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("uvector-ref", 11, 11),
      SCM_STRING_CONST_INITIALIZER("uvector-length", 14, 14),
      SCM_STRING_CONST_INITIALIZER("uvector-immutable\077", 18, 18),
      SCM_STRING_CONST_INITIALIZER("uvector\077", 8, 8),
      SCM_STRING_CONST_INITIALIZER("u8vector\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("x", 1, 1),
      SCM_STRING_CONST_INITIALIZER("s8vector\077", 9, 9),
      SCM_STRING_CONST_INITIALIZER("u16vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("s16vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("u32vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("s32vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("u64vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("s64vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("f16vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("f32vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("f64vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("c32vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("c64vector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("c128vector\077", 11, 11),
      SCM_STRING_CONST_INITIALIZER("bitvector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("bitvector-length", 16, 16),
      SCM_STRING_CONST_INITIALIZER("make-bitvector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("len", 3, 3),
      SCM_STRING_CONST_INITIALIZER("init", 4, 4),
      SCM_STRING_CONST_INITIALIZER("bitvector", 9, 9),
      SCM_STRING_CONST_INITIALIZER("bits", 4, 4),
      SCM_STRING_CONST_INITIALIZER("list->bitvector", 15, 15),
      SCM_STRING_CONST_INITIALIZER("string->bitvector", 17, 17),
      SCM_STRING_CONST_INITIALIZER("bitvector->string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("bit->integer", 12, 12),
      SCM_STRING_CONST_INITIALIZER("bit", 3, 3),
      SCM_STRING_CONST_INITIALIZER("bit->boolean", 12, 12),
      SCM_STRING_CONST_INITIALIZER("bitvector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("b", 1, 1),
      SCM_STRING_CONST_INITIALIZER("bitvector-ref/int", 17, 17),
      SCM_STRING_CONST_INITIALIZER("bitvector-ref/bool", 18, 18),
      SCM_STRING_CONST_INITIALIZER("bitvector-copy", 14, 14),
      SCM_STRING_CONST_INITIALIZER("bitvector-copy!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("dest", 4, 4),
      SCM_STRING_CONST_INITIALIZER("dstart", 6, 6),
      SCM_STRING_CONST_INITIALIZER("src", 3, 3),
  },
};
static struct scm__rcRec {
  ScmCompiledCode d1571[2];
  ScmWord d1570[110];
  ScmPair d1563[712] SCM_ALIGN_PAIR;
  ScmObj d1562[217];
} scm__rc SCM_UNUSED = {
  {   /* ScmCompiledCode d1571 */
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* vector->string */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1570[0])), 55,
            22, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1563[149]),
            SCM_FALSE, SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* string->vector */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1570[55])), 55,
            22, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1563[162]),
            SCM_FALSE, SCM_FALSE),
  },
  {   /* ScmWord d1570 */
    /* vector->string */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 6),
    0x00000002    /*   3 (CONSTI 0) */,
    0x00000013    /*   4 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 7),
    0x0000006a    /*   6 (LREF0-CAR) */,
    0x0000000d    /*   7 (PUSH) */,
    0x0000003d    /*   8 (LREF0) */,
    0x00000022    /*   9 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 14),
    0x00000003    /*  11 (CONSTN) */,
    0x00000013    /*  12 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 15),
    0x00000076    /*  14 (LREF0-CDR) */,
    0x00002018    /*  15 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  16 (LREF0) */,
    0x00000022    /*  17 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 22),
    -0x00000ffe   /*  19 (CONSTI -1) */,
    0x00000013    /*  20 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 23),
    0x0000006a    /*  22 (LREF0-CAR) */,
    0x0000000d    /*  23 (PUSH) */,
    0x0000003d    /*  24 (LREF0) */,
    0x00000022    /*  25 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 30),
    0x00000003    /*  27 (CONSTN) */,
    0x00000013    /*  28 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 31),
    0x00000076    /*  30 (LREF0-CDR) */,
    0x00002018    /*  31 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  32 (LREF0) */,
    0x00000022    /*  33 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 37),
    0x00000013    /*  35 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 45),
    0x0000200e    /*  37 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 45),
    0x00000006    /*  39 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1561[36])) /* "too many arguments for" */,
    0x00000006    /*  41 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1563[142])) /* (lambda (v :optional (start 0) (end -1)) (list->string (vector->list v start end))) */,
    0x0000205f    /*  43 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#error.2083e940> */,
    0x0000300e    /*  45 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]) + 52),
    0x00000050    /*  47 (LREF21-PUSH) */,
    0x0000004d    /*  48 (LREF11-PUSH) */,
    0x00000049    /*  49 (LREF1-PUSH) */,
    0x0000305f    /*  50 (GREF-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#vector->list.2083e3a0> */,
    0x00001063    /*  52 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#list->string.2083e3e0> */,
    0x00000014    /*  54 (RET) */,
    /* string->vector */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 6),
    0x00000002    /*   3 (CONSTI 0) */,
    0x00000013    /*   4 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 7),
    0x0000006a    /*   6 (LREF0-CAR) */,
    0x0000000d    /*   7 (PUSH) */,
    0x0000003d    /*   8 (LREF0) */,
    0x00000022    /*   9 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 14),
    0x00000003    /*  11 (CONSTN) */,
    0x00000013    /*  12 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 15),
    0x00000076    /*  14 (LREF0-CDR) */,
    0x00002018    /*  15 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  16 (LREF0) */,
    0x00000022    /*  17 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 22),
    -0x00000ffe   /*  19 (CONSTI -1) */,
    0x00000013    /*  20 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 23),
    0x0000006a    /*  22 (LREF0-CAR) */,
    0x0000000d    /*  23 (PUSH) */,
    0x0000003d    /*  24 (LREF0) */,
    0x00000022    /*  25 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 30),
    0x00000003    /*  27 (CONSTN) */,
    0x00000013    /*  28 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 31),
    0x00000076    /*  30 (LREF0-CDR) */,
    0x00002018    /*  31 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  32 (LREF0) */,
    0x00000022    /*  33 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 37),
    0x00000013    /*  35 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 45),
    0x0000200e    /*  37 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 45),
    0x00000006    /*  39 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1561[36])) /* "too many arguments for" */,
    0x00000006    /*  41 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1563[157])) /* (lambda (s :optional (start 0) (end -1)) (list->vector (string->list s start end))) */,
    0x0000205f    /*  43 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#error.209820c0> */,
    0x0000300e    /*  45 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]) + 52),
    0x00000050    /*  47 (LREF21-PUSH) */,
    0x0000004d    /*  48 (LREF11-PUSH) */,
    0x00000049    /*  49 (LREF1-PUSH) */,
    0x0000305f    /*  50 (GREF-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#string->list.2098ab20> */,
    0x00001063    /*  52 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#list->vector.2098ab60> */,
    0x00000014    /*  54 (RET) */,
  },
  {   /* ScmPair d1563 */
       { SCM_NIL, SCM_NIL },
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[1])},
       { SCM_MAKE_INT(48U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[3])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[4])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[6])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[7])},
       { SCM_OBJ(&scm__rc.d1563[8]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[5]), SCM_OBJ(&scm__rc.d1563[9])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(51U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[12])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[13])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[15])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[16])},
       { SCM_OBJ(&scm__rc.d1563[17]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[14]), SCM_OBJ(&scm__rc.d1563[18])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(54U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[21])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[22])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[24])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[25])},
       { SCM_OBJ(&scm__rc.d1563[26]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[23]), SCM_OBJ(&scm__rc.d1563[27])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[29])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[31])},
       { SCM_MAKE_INT(57U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[33])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[34])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[36])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[37])},
       { SCM_OBJ(&scm__rc.d1563[38]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[35]), SCM_OBJ(&scm__rc.d1563[39])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[11])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[41])},
       { SCM_MAKE_INT(68U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[43])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[44])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[46])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[47])},
       { SCM_OBJ(&scm__rc.d1563[48]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[45]), SCM_OBJ(&scm__rc.d1563[49])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[51])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[53])},
       { SCM_MAKE_INT(78U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[55])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[56])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[58])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[59])},
       { SCM_OBJ(&scm__rc.d1563[60]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[57]), SCM_OBJ(&scm__rc.d1563[61])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[53])},
       { SCM_MAKE_INT(82U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[64])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[65])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[67])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[68])},
       { SCM_OBJ(&scm__rc.d1563[69]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[66]), SCM_OBJ(&scm__rc.d1563[70])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[72])},
       { SCM_MAKE_INT(86U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[74])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[75])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[77])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[78])},
       { SCM_OBJ(&scm__rc.d1563[79]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[76]), SCM_OBJ(&scm__rc.d1563[80])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[82])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[83])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[84])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[85])},
       { SCM_MAKE_INT(90U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[87])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[88])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[90])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[91])},
       { SCM_OBJ(&scm__rc.d1563[92]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[89]), SCM_OBJ(&scm__rc.d1563[93])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[95])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[96])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[97])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[98])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[99])},
       { SCM_MAKE_INT(94U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[101])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[102])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[104])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[105])},
       { SCM_OBJ(&scm__rc.d1563[106]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[103]), SCM_OBJ(&scm__rc.d1563[107])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[109])},
       { SCM_MAKE_INT(125U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[111])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[112])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[114])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[115])},
       { SCM_OBJ(&scm__rc.d1563[116]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[113]), SCM_OBJ(&scm__rc.d1563[117])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(141U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[120])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[121])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[123])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[124])},
       { SCM_OBJ(&scm__rc.d1563[125]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[122]), SCM_OBJ(&scm__rc.d1563[126])},
       { SCM_MAKE_INT(0), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[128])},
       { SCM_MAKE_INT(-1), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[130])},
       { SCM_OBJ(&scm__rc.d1563[131]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[129]), SCM_OBJ(&scm__rc.d1563[132])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[133])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[134])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[136])},
       { SCM_OBJ(&scm__rc.d1563[137]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[138])},
       { SCM_OBJ(&scm__rc.d1563[139]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[135]), SCM_OBJ(&scm__rc.d1563[140])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[141])},
       { SCM_MAKE_INT(149U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[143])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[144])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[146]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[145]), SCM_OBJ(&scm__rc.d1563[147])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[134])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[151])},
       { SCM_OBJ(&scm__rc.d1563[152]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[153])},
       { SCM_OBJ(&scm__rc.d1563[154]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[150]), SCM_OBJ(&scm__rc.d1563[155])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[156])},
       { SCM_MAKE_INT(151U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[158])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[159])},
       { SCM_OBJ(&scm__rc.d1563[160]), SCM_OBJ(&scm__rc.d1563[147])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(160U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[164])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[165])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[167])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[168])},
       { SCM_OBJ(&scm__rc.d1563[169]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[166]), SCM_OBJ(&scm__rc.d1563[170])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(162U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[173])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[174])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[176])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[177])},
       { SCM_OBJ(&scm__rc.d1563[178]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[175]), SCM_OBJ(&scm__rc.d1563[179])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[181])},
       { SCM_MAKE_INT(166U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[183])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[184])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[186])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[187])},
       { SCM_OBJ(&scm__rc.d1563[188]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[185]), SCM_OBJ(&scm__rc.d1563[189])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[191])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[192])},
       { SCM_MAKE_INT(169U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[194])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[195])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[197])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[198])},
       { SCM_OBJ(&scm__rc.d1563[199]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[196]), SCM_OBJ(&scm__rc.d1563[200])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[202])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[203])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[204])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[205])},
       { SCM_MAKE_INT(195U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[207])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[208])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[210])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[211])},
       { SCM_OBJ(&scm__rc.d1563[212]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[209]), SCM_OBJ(&scm__rc.d1563[213])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[215])},
       { SCM_MAKE_INT(197U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[217])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[218])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[220])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[221])},
       { SCM_OBJ(&scm__rc.d1563[222]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[219]), SCM_OBJ(&scm__rc.d1563[223])},
       { SCM_MAKE_INT(202U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[225])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[226])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[228])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[229])},
       { SCM_OBJ(&scm__rc.d1563[230]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[227]), SCM_OBJ(&scm__rc.d1563[231])},
       { SCM_MAKE_INT(204U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[233])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[234])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[236])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[237])},
       { SCM_OBJ(&scm__rc.d1563[238]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[235]), SCM_OBJ(&scm__rc.d1563[239])},
       { SCM_MAKE_INT(209U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[241])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[242])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[244])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[245])},
       { SCM_OBJ(&scm__rc.d1563[246]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[243]), SCM_OBJ(&scm__rc.d1563[247])},
       { SCM_MAKE_INT(211U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[249])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[250])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[252])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[253])},
       { SCM_OBJ(&scm__rc.d1563[254]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[251]), SCM_OBJ(&scm__rc.d1563[255])},
       { SCM_MAKE_INT(216U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[257])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[258])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[260])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[261])},
       { SCM_OBJ(&scm__rc.d1563[262]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[259]), SCM_OBJ(&scm__rc.d1563[263])},
       { SCM_MAKE_INT(218U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[265])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[266])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[268])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[269])},
       { SCM_OBJ(&scm__rc.d1563[270]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[267]), SCM_OBJ(&scm__rc.d1563[271])},
       { SCM_MAKE_INT(223U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[273])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[274])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[276])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[277])},
       { SCM_OBJ(&scm__rc.d1563[278]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[275]), SCM_OBJ(&scm__rc.d1563[279])},
       { SCM_MAKE_INT(225U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[281])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[282])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[284])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[285])},
       { SCM_OBJ(&scm__rc.d1563[286]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[283]), SCM_OBJ(&scm__rc.d1563[287])},
       { SCM_MAKE_INT(230U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[289])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[290])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[292])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[293])},
       { SCM_OBJ(&scm__rc.d1563[294]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[291]), SCM_OBJ(&scm__rc.d1563[295])},
       { SCM_MAKE_INT(232U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[297])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[298])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[300])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[301])},
       { SCM_OBJ(&scm__rc.d1563[302]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[299]), SCM_OBJ(&scm__rc.d1563[303])},
       { SCM_MAKE_INT(237U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[305])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[308])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[309])},
       { SCM_OBJ(&scm__rc.d1563[310]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[307]), SCM_OBJ(&scm__rc.d1563[311])},
       { SCM_MAKE_INT(239U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[313])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[314])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[316])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[317])},
       { SCM_OBJ(&scm__rc.d1563[318]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[315]), SCM_OBJ(&scm__rc.d1563[319])},
       { SCM_MAKE_INT(244U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[321])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[322])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[324])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[325])},
       { SCM_OBJ(&scm__rc.d1563[326]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[323]), SCM_OBJ(&scm__rc.d1563[327])},
       { SCM_MAKE_INT(246U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[329])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[330])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[332])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[333])},
       { SCM_OBJ(&scm__rc.d1563[334]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[331]), SCM_OBJ(&scm__rc.d1563[335])},
       { SCM_MAKE_INT(251U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[337])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[338])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[340])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[341])},
       { SCM_OBJ(&scm__rc.d1563[342]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[339]), SCM_OBJ(&scm__rc.d1563[343])},
       { SCM_MAKE_INT(253U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[345])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[346])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[348])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[349])},
       { SCM_OBJ(&scm__rc.d1563[350]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[347]), SCM_OBJ(&scm__rc.d1563[351])},
       { SCM_MAKE_INT(258U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[353])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[354])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[356])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[357])},
       { SCM_OBJ(&scm__rc.d1563[358]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[355]), SCM_OBJ(&scm__rc.d1563[359])},
       { SCM_MAKE_INT(260U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[361])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[362])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[364])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[365])},
       { SCM_OBJ(&scm__rc.d1563[366]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[363]), SCM_OBJ(&scm__rc.d1563[367])},
       { SCM_MAKE_INT(265U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[369])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[370])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[372])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[373])},
       { SCM_OBJ(&scm__rc.d1563[374]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[371]), SCM_OBJ(&scm__rc.d1563[375])},
       { SCM_MAKE_INT(267U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[377])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[378])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[380])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[381])},
       { SCM_OBJ(&scm__rc.d1563[382]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[379]), SCM_OBJ(&scm__rc.d1563[383])},
       { SCM_MAKE_INT(272U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[385])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[386])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[388])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[389])},
       { SCM_OBJ(&scm__rc.d1563[390]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[387]), SCM_OBJ(&scm__rc.d1563[391])},
       { SCM_MAKE_INT(274U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[393])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[394])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[396])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[397])},
       { SCM_OBJ(&scm__rc.d1563[398]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[395]), SCM_OBJ(&scm__rc.d1563[399])},
       { SCM_MAKE_INT(279U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[401])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[402])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[404])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[405])},
       { SCM_OBJ(&scm__rc.d1563[406]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[403]), SCM_OBJ(&scm__rc.d1563[407])},
       { SCM_MAKE_INT(281U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[409])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[410])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[412])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[413])},
       { SCM_OBJ(&scm__rc.d1563[414]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[411]), SCM_OBJ(&scm__rc.d1563[415])},
       { SCM_MAKE_INT(286U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[417])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[418])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[420])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[421])},
       { SCM_OBJ(&scm__rc.d1563[422]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[419]), SCM_OBJ(&scm__rc.d1563[423])},
       { SCM_MAKE_INT(288U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[425])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[426])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[428])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[429])},
       { SCM_OBJ(&scm__rc.d1563[430]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[427]), SCM_OBJ(&scm__rc.d1563[431])},
       { SCM_MAKE_INT(293U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[433])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[434])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[436])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[437])},
       { SCM_OBJ(&scm__rc.d1563[438]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[435]), SCM_OBJ(&scm__rc.d1563[439])},
       { SCM_MAKE_INT(297U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[441])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[442])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[444])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[445])},
       { SCM_OBJ(&scm__rc.d1563[446]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[443]), SCM_OBJ(&scm__rc.d1563[447])},
       { SCM_MAKE_INT(302U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[449])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[450])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[452])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[453])},
       { SCM_OBJ(&scm__rc.d1563[454]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[451]), SCM_OBJ(&scm__rc.d1563[455])},
       { SCM_MAKE_INT(304U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[457])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[458])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[460])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[461])},
       { SCM_OBJ(&scm__rc.d1563[462]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[459]), SCM_OBJ(&scm__rc.d1563[463])},
       { SCM_MAKE_INT(306U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[465])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[466])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[468])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[469])},
       { SCM_OBJ(&scm__rc.d1563[470]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[467]), SCM_OBJ(&scm__rc.d1563[471])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(309U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[474])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[475])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[477])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[478])},
       { SCM_OBJ(&scm__rc.d1563[479]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[476]), SCM_OBJ(&scm__rc.d1563[480])},
       { SCM_MAKE_INT(310U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[482])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[483])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[485])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[486])},
       { SCM_OBJ(&scm__rc.d1563[487]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[484]), SCM_OBJ(&scm__rc.d1563[488])},
       { SCM_MAKE_INT(311U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[490])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[491])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[493])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[494])},
       { SCM_OBJ(&scm__rc.d1563[495]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[492]), SCM_OBJ(&scm__rc.d1563[496])},
       { SCM_MAKE_INT(312U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[498])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[499])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[501])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[502])},
       { SCM_OBJ(&scm__rc.d1563[503]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[500]), SCM_OBJ(&scm__rc.d1563[504])},
       { SCM_MAKE_INT(313U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[506])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[507])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[509])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[510])},
       { SCM_OBJ(&scm__rc.d1563[511]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[508]), SCM_OBJ(&scm__rc.d1563[512])},
       { SCM_MAKE_INT(314U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[514])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[515])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[517])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[518])},
       { SCM_OBJ(&scm__rc.d1563[519]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[516]), SCM_OBJ(&scm__rc.d1563[520])},
       { SCM_MAKE_INT(315U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[522])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[523])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[525])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[526])},
       { SCM_OBJ(&scm__rc.d1563[527]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[524]), SCM_OBJ(&scm__rc.d1563[528])},
       { SCM_MAKE_INT(316U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[530])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[531])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[533])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[534])},
       { SCM_OBJ(&scm__rc.d1563[535]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[532]), SCM_OBJ(&scm__rc.d1563[536])},
       { SCM_MAKE_INT(317U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[538])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[539])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[541])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[542])},
       { SCM_OBJ(&scm__rc.d1563[543]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[540]), SCM_OBJ(&scm__rc.d1563[544])},
       { SCM_MAKE_INT(318U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[546])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[547])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[549])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[550])},
       { SCM_OBJ(&scm__rc.d1563[551]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[548]), SCM_OBJ(&scm__rc.d1563[552])},
       { SCM_MAKE_INT(319U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[554])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[555])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[557])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[558])},
       { SCM_OBJ(&scm__rc.d1563[559]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[556]), SCM_OBJ(&scm__rc.d1563[560])},
       { SCM_MAKE_INT(320U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[562])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[563])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[565])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[566])},
       { SCM_OBJ(&scm__rc.d1563[567]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[564]), SCM_OBJ(&scm__rc.d1563[568])},
       { SCM_MAKE_INT(321U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[570])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[571])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[573])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[574])},
       { SCM_OBJ(&scm__rc.d1563[575]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[572]), SCM_OBJ(&scm__rc.d1563[576])},
       { SCM_MAKE_INT(322U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[578])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[579])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[581])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[582])},
       { SCM_OBJ(&scm__rc.d1563[583]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[580]), SCM_OBJ(&scm__rc.d1563[584])},
       { SCM_MAKE_INT(328U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[586])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[587])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[589])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[590])},
       { SCM_OBJ(&scm__rc.d1563[591]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[588]), SCM_OBJ(&scm__rc.d1563[592])},
       { SCM_MAKE_INT(329U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[594])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[595])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[597])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[598])},
       { SCM_OBJ(&scm__rc.d1563[599]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[596]), SCM_OBJ(&scm__rc.d1563[600])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[602])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[603])},
       { SCM_MAKE_INT(332U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[605])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[606])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[608])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[609])},
       { SCM_OBJ(&scm__rc.d1563[610]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[607]), SCM_OBJ(&scm__rc.d1563[611])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[613])},
       { SCM_MAKE_INT(334U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[615])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[616])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[618])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[619])},
       { SCM_OBJ(&scm__rc.d1563[620]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[617]), SCM_OBJ(&scm__rc.d1563[621])},
       { SCM_MAKE_INT(335U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[623])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[624])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[626])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[627])},
       { SCM_OBJ(&scm__rc.d1563[628]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[625]), SCM_OBJ(&scm__rc.d1563[629])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(337U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[632])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[633])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[635])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[636])},
       { SCM_OBJ(&scm__rc.d1563[637]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[634]), SCM_OBJ(&scm__rc.d1563[638])},
       { SCM_MAKE_INT(339U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[640])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[641])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[643])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[644])},
       { SCM_OBJ(&scm__rc.d1563[645]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[642]), SCM_OBJ(&scm__rc.d1563[646])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(342U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[649])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[650])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[652])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[653])},
       { SCM_OBJ(&scm__rc.d1563[654]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[651]), SCM_OBJ(&scm__rc.d1563[655])},
       { SCM_MAKE_INT(343U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[657])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[658])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[660])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[661])},
       { SCM_OBJ(&scm__rc.d1563[662]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[659]), SCM_OBJ(&scm__rc.d1563[663])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[665])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[666])},
       { SCM_MAKE_INT(345U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[668])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[669])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[671])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[672])},
       { SCM_OBJ(&scm__rc.d1563[673]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[670]), SCM_OBJ(&scm__rc.d1563[674])},
       { SCM_MAKE_INT(353U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[676])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[677])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[679])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[680])},
       { SCM_OBJ(&scm__rc.d1563[681]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[678]), SCM_OBJ(&scm__rc.d1563[682])},
       { SCM_MAKE_INT(364U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[684])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[685])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[687])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[688])},
       { SCM_OBJ(&scm__rc.d1563[689]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[686]), SCM_OBJ(&scm__rc.d1563[690])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[53])},
       { SCM_MAKE_INT(373U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[693])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[694])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[696])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[697])},
       { SCM_OBJ(&scm__rc.d1563[698]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[695]), SCM_OBJ(&scm__rc.d1563[699])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[701])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[702])},
       { SCM_MAKE_INT(378U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1561[4]), SCM_OBJ(&scm__rc.d1563[704])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[705])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[707])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1563[708])},
       { SCM_OBJ(&scm__rc.d1563[709]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1563[706]), SCM_OBJ(&scm__rc.d1563[710])},
  },
  {   /* ScmObj d1562 */
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
  },
};
static ScmObj libvecvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj args_scm;
  ScmObj args;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("vector");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  args_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 49 "libvec.scm"
{SCM_RESULT=(Scm_ListToVector(args,0,-1));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecvectorP(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("vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  obj_scm = SCM_SUBRARGS[0];
  obj = (obj_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_VECTORP(obj));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecvector_length(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("vector-length");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  {
{
ScmSmallInt SCM_RESULT;
{SCM_RESULT=(SCM_VECTOR_SIZE(vec));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

static ScmObj libvecvector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj k_scm;
  ScmObj k;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_SUBRARGS[1];
  if (!SCM_INTEGERP(k_scm)) Scm_Error("exact integer required, but got %S", k_scm);
  k = (k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 60 "libvec.scm"
if (((SCM_BIGNUMP(k))||(
(SCM_INT_VALUE(k))<(0)))||(
(SCM_INT_VALUE(k))>=(SCM_VECTOR_SIZE(vec)))){
if (SCM_UNBOUNDP(fallback)){{
Scm_Error("vector-ref index out of range: %S",k);}}
{SCM_RESULT=(fallback);goto SCM_STUB_RETURN;}} else {
{SCM_RESULT=(SCM_VECTOR_ELEMENT(vec,SCM_INT_VALUE(k)));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecvector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj k_scm;
  ScmObj k;
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("vector-set!");
  for (int SCM_i=0; SCM_i<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_SUBRARGS[1];
  if (!SCM_INTEGERP(k_scm)) Scm_Error("exact integer required, but got %S", k_scm);
  k = (k_scm);
  obj_scm = SCM_SUBRARGS[2];
  obj = (obj_scm);
  {

#line 69 "libvec.scm"
{
SCM_VECTOR_CHECK_MUTABLE(vec);
if (((SCM_BIGNUMP(k))||(
(SCM_INT_VALUE(k))<(0)))||(
(SCM_INT_VALUE(k))>=(SCM_VECTOR_SIZE(vec)))){
Scm_Error("vector-set! index out of range: %S",k);} else {
SCM_VECTOR_ELEMENT(vec,SCM_INT_VALUE(k))=(obj);}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

static ScmObj libvecvector_TOlist(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("vector->list");
  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);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_SUBRARGS[2];
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_VectorToList(vec,start,end));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libveclist_TOvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("list->vector");
  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);
  }
  list_scm = SCM_SUBRARGS[0];
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_SUBRARGS[2];
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_ListToVector(list,start,end));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecvector_fillX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[6];
  SCM_ENTER_SUBR("vector-fill!");
  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<6; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  fill_scm = SCM_SUBRARGS[1];
  fill = (fill_scm);
  if (SCM_ARGCNT > 2+1) {
    start_scm = SCM_SUBRARGS[2];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 3+1) {
    end_scm = SCM_SUBRARGS[3];
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
Scm_VectorFill(vec,fill,start,end);
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

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

static ScmObj libvecvector_copyX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj t_scm;
  ScmVector* t;
  ScmObj tstart_scm;
  ScmSmallInt tstart;
  ScmObj s_scm;
  ScmVector* s;
  ScmObj sstart_scm;
  ScmSmallInt sstart;
  ScmObj send_scm;
  ScmSmallInt send;
  ScmObj SCM_SUBRARGS[7];
  SCM_ENTER_SUBR("vector-copy!");
  if (SCM_ARGCNT >= 6
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 5 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);
  }
  t_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(t_scm)) Scm_Error("vector required, but got %S", t_scm);
  t = SCM_VECTOR(t_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_Error("small integer required, but got %S", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_VECTORP(s_scm)) Scm_Error("vector required, but got %S", s_scm);
  s = SCM_VECTOR(s_scm);
  if (SCM_ARGCNT > 3+1) {
    sstart_scm = SCM_SUBRARGS[3];
  } else {
    sstart_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(sstart_scm)) Scm_Error("small integer required, but got %S", sstart_scm);
  sstart = SCM_INT_VALUE(sstart_scm);
  if (SCM_ARGCNT > 4+1) {
    send_scm = SCM_SUBRARGS[4];
  } else {
    send_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(send_scm)) Scm_Error("small integer required, but got %S", send_scm);
  send = SCM_INT_VALUE(send_scm);
  {

#line 96 "libvec.scm"
{long tsize=SCM_VECTOR_SIZE(t);
SCM_VECTOR_CHECK_MUTABLE(t);
if ((send)<(0)){{send=(SCM_VECTOR_SIZE(s));}}
if (!(((0)<=(tstart))&&((tstart)<=(tsize)))){{
Scm_Error("tstart out of range: %ld",tstart);}}
if (!(((0)<=(sstart))&&((sstart)<=(SCM_VECTOR_SIZE(s))))){{
Scm_Error("sstart out of range: %ld",sstart);}}
if (!(((0)<=(send))&&((send)<=(SCM_VECTOR_SIZE(s))))){{
Scm_Error("send out of range: %ld",send);}}
if (!(((tstart)+((send)-(sstart)))<=(tsize))){{
Scm_Error("source vector overruns the target vector: %20.0S [%ld,%ld]",s,sstart,send);}}
#line 108 "libvec.scm"
if (!((sstart)<=(send))){{
Scm_Error("send (%ld) must be greater than or equal to sstart (%ld)",send,sstart);}}
#line 111 "libvec.scm"
if ((tstart)<=(sstart)){
{ScmSmallInt i=sstart;ScmSmallInt j=tstart;
for (; ((i)<(send))&&((j)<(tsize)); (i)++,(j)++){
SCM_VECTOR_ELEMENT(t,j)=(SCM_VECTOR_ELEMENT(s,i));}}} else {
{ScmSmallInt i=send;ScmSmallInt j=
(tstart)+((send)-(sstart));
if ((j)>=(tsize)){{
i=((i)-((j)-(tsize)));
j=(tsize);}}
for ((i)--,(j)--; 
((i)>=(sstart))&&((j)>=(tstart)); 
(i)--,(j)--){
SCM_VECTOR_ELEMENT(t,j)=(SCM_VECTOR_ELEMENT(s,i));}}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

static ScmObj libvecvector_append(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj vecs_scm;
  ScmObj vecs;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("vector-append");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vecs_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  vecs = (vecs_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1565;ScmObj cise__1564;
#line 126 "libvec.scm"
{long len=0;
SCM_FOR_EACH(cise__1564,vecs) {{ScmObj v=SCM_CAR(cise__1564);
if (!(SCM_VECTORP(v))){{
Scm_Error("vector required, but got: %S",v);}}
len=((len)+(SCM_VECTOR_SIZE(v)));}}
{ScmObj dst=Scm_MakeVector(len,SCM_UNDEFINED);long j=0;
#line 133 "libvec.scm"
SCM_FOR_EACH(cise__1565,vecs) {{ScmObj v=SCM_CAR(cise__1565);
{long k=SCM_VECTOR_SIZE(v);
memcpy((SCM_VECTOR_ELEMENTS(dst))+(j),SCM_VECTOR_ELEMENTS(v),
(k)*(sizeof(ScmWord)));
j=((j)+(k));}}}
{SCM_RESULT=(dst);goto SCM_STUB_RETURN;}}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecvector_immutableP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmVector* v;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("vector-immutable?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
  v = SCM_VECTOR(v_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_VECTOR_IMMUTABLE_P(v));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecmake_weak_vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj size_scm;
  ScmSmallInt size;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("make-weak-vector");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  size_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(size_scm)) Scm_Error("small integer required, but got %S", size_scm);
  size = SCM_INT_VALUE(size_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_MakeWeakVector(size));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecweak_vector_length(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj wv_scm;
  ScmWeakVector* wv;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("weak-vector-length");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  wv_scm = SCM_SUBRARGS[0];
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_Error("weak vector required, but got %S", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  {
{
int SCM_RESULT;

#line 163 "libvec.scm"
{SCM_RESULT=((wv)->size);goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

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

static ScmObj libvecweak_vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj wv_scm;
  ScmWeakVector* wv;
  ScmObj index_scm;
  ScmSmallInt index;
  ScmObj val_scm;
  ScmObj val;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("weak-vector-set!");
  for (int SCM_i=0; SCM_i<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  wv_scm = SCM_SUBRARGS[0];
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_Error("weak vector required, but got %S", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  index_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(index_scm)) Scm_Error("small integer required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_WeakVectorSet(wv,index,val));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs8vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("s8vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_Error("s8vector required, but got %S", v_scm);
  v = SCM_S8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 196 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_S8,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs8vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("s8vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_Error("s8vector required, but got %S", v_scm);
  v = SCM_S8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 200 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_S8,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu8vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("u8vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_Error("u8vector required, but got %S", v_scm);
  v = SCM_U8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 203 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_U8,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu8vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("u8vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_Error("u8vector required, but got %S", v_scm);
  v = SCM_U8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 207 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_U8,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs16vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("s16vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S16VECTORP(v_scm)) Scm_Error("s16vector required, but got %S", v_scm);
  v = SCM_S16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 210 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_S16,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs16vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("s16vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S16VECTORP(v_scm)) Scm_Error("s16vector required, but got %S", v_scm);
  v = SCM_S16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 214 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_S16,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu16vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("u16vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U16VECTORP(v_scm)) Scm_Error("u16vector required, but got %S", v_scm);
  v = SCM_U16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 217 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_U16,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu16vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("u16vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U16VECTORP(v_scm)) Scm_Error("u16vector required, but got %S", v_scm);
  v = SCM_U16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 221 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_U16,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs32vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("s32vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_Error("s32vector required, but got %S", v_scm);
  v = SCM_S32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 224 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_S32,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs32vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("s32vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_Error("s32vector required, but got %S", v_scm);
  v = SCM_S32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 228 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_S32,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu32vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("u32vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_Error("u32vector required, but got %S", v_scm);
  v = SCM_U32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 231 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_U32,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu32vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("u32vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_Error("u32vector required, but got %S", v_scm);
  v = SCM_U32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 235 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_U32,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs64vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("s64vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S64VECTORP(v_scm)) Scm_Error("s64vector required, but got %S", v_scm);
  v = SCM_S64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 238 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_S64,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecs64vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("s64vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S64VECTORP(v_scm)) Scm_Error("s64vector required, but got %S", v_scm);
  v = SCM_S64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 242 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_S64,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu64vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("u64vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U64VECTORP(v_scm)) Scm_Error("u64vector required, but got %S", v_scm);
  v = SCM_U64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 245 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_U64,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecu64vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("u64vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U64VECTORP(v_scm)) Scm_Error("u64vector required, but got %S", v_scm);
  v = SCM_U64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 249 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_U64,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf16vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("f16vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F16VECTORP(v_scm)) Scm_Error("f16vector required, but got %S", v_scm);
  v = SCM_F16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 252 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_F16,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf16vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("f16vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F16VECTORP(v_scm)) Scm_Error("f16vector required, but got %S", v_scm);
  v = SCM_F16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 256 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_F16,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf32vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("f32vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F32VECTORP(v_scm)) Scm_Error("f32vector required, but got %S", v_scm);
  v = SCM_F32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 259 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_F32,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf32vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("f32vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F32VECTORP(v_scm)) Scm_Error("f32vector required, but got %S", v_scm);
  v = SCM_F32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 263 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_F32,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf64vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("f64vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F64VECTORP(v_scm)) Scm_Error("f64vector required, but got %S", v_scm);
  v = SCM_F64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 266 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_F64,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecf64vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("f64vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F64VECTORP(v_scm)) Scm_Error("f64vector required, but got %S", v_scm);
  v = SCM_F64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 270 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_F64,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc32vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("c32vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C32VECTORP(v_scm)) Scm_Error("c32vector required, but got %S", v_scm);
  v = SCM_C32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 273 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_C32,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc32vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("c32vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C32VECTORP(v_scm)) Scm_Error("c32vector required, but got %S", v_scm);
  v = SCM_C32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 277 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_C32,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc64vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("c64vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C64VECTORP(v_scm)) Scm_Error("c64vector required, but got %S", v_scm);
  v = SCM_C64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 280 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_C64,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc64vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("c64vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C64VECTORP(v_scm)) Scm_Error("c64vector required, but got %S", v_scm);
  v = SCM_C64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 284 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_C64,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc128vector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("c128vector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C128VECTORP(v_scm)) Scm_Error("c128vector required, but got %S", v_scm);
  v = SCM_C128VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 287 "libvec.scm"
{SCM_RESULT=(Scm_UVectorSet(v,SCM_UVECTOR_C128,i,val,Scm_ClampMode(clamp)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecc128vector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("c128vector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C128VECTORP(v_scm)) Scm_Error("c128vector required, but got %S", v_scm);
  v = SCM_C128VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 291 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,SCM_UVECTOR_C128,i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecuvector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj val_scm;
  ScmObj val;
  ScmObj clamp_scm;
  ScmObj clamp;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("uvector-set!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  clamp = (clamp_scm);
  {

#line 295 "libvec.scm"
Scm_UVectorSet(v,Scm_UVectorType(Scm_ClassOf(SCM_OBJ(v))),i,val,
Scm_ClampMode(clamp));
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

static ScmObj libvecuvector_ref(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("uvector-ref");
  if (SCM_ARGCNT >= 4
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 3 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 300 "libvec.scm"
{SCM_RESULT=(Scm_VMUVectorRef(v,Scm_UVectorType(Scm_ClassOf(SCM_OBJ(v))),i,fallback));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecuvector_length(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("uvector-length");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
u_long SCM_RESULT;
{SCM_RESULT=(SCM_UVECTOR_SIZE(v));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static ScmObj libvecuvector_immutableP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("uvector-immutable?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_Error("uniform vector required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_UVECTOR_IMMUTABLE_P(v));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecuvectorP(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("uvector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  obj_scm = SCM_SUBRARGS[0];
  obj = (obj_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_UVECTORP(obj));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecu8vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("u8vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U8VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecs8vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("s8vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_S8VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecu16vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("u16vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U16VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecs16vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("s16vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U16VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecu32vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("u32vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U32VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecs32vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("s32vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U32VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecu64vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("u64vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U64VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecs64vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("s64vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_U64VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecf16vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("f16vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_F16VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecf32vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("f32vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_F32VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecf64vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("f64vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_F64VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecc32vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("c32vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_C32VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecc64vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("c64vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_C64VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecc128vectorP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("c128vector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  x_scm = SCM_SUBRARGS[0];
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_C128VECTORP(x));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvectorP(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("bitvector?");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  obj_scm = SCM_SUBRARGS[0];
  obj = (obj_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_BITVECTORP(obj));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_length(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("bitvector-length");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_BITVECTOR_SIZE(v));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static ScmObj libvecmake_bitvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj len_scm;
  ScmSmallInt len;
  ScmObj init_scm;
  ScmObj init;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("make-bitvector");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  for (int SCM_i=0; SCM_i<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  len_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(len_scm)) Scm_Error("small integer required, but got %S", len_scm);
  len = SCM_INT_VALUE(len_scm);
  if (SCM_ARGCNT > 1+1) {
    init_scm = SCM_SUBRARGS[1];
  } else {
    init_scm = SCM_FALSE;
  }
  init = (init_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_MakeBitvector(len,init));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj bits_scm;
  ScmObj bits;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("bitvector");
  for (int SCM_i=0; SCM_i<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bits_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  bits = (bits_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_ListToBitvector(bits));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libveclist_TObitvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj bits_scm;
  ScmObj bits;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("list->bitvector");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bits_scm = SCM_SUBRARGS[0];
  bits = (bits_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_ListToBitvector(bits));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecstring_TObitvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("string->bitvector");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  s_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
  s = SCM_STRING(s_scm);
  {
{
ScmObj SCM_RESULT;

#line 338 "libvec.scm"
{SCM_RESULT=(Scm_StringToBitvector(s,TRUE));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_TOstring(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("bitvector->string");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  {
{
ScmObj SCM_RESULT;

#line 340 "libvec.scm"
{SCM_RESULT=(Scm_BitvectorToString(v,TRUE));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbit_TOinteger(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj bit_scm;
  ScmObj bit;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("bit->integer");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bit_scm = SCM_SUBRARGS[0];
  bit = (bit_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(Scm_Bit2Int(bit));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static ScmObj libvecbit_TOboolean(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj bit_scm;
  ScmObj bit;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("bit->boolean");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bit_scm = SCM_SUBRARGS[0];
  bit = (bit_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(Scm_Bit2Int(bit));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_setX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj b_scm;
  ScmObj b;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("bitvector-set!");
  for (int SCM_i=0; SCM_i<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  b_scm = SCM_SUBRARGS[2];
  b = (b_scm);
  {

#line 346 "libvec.scm"
if (((i)<(0))||((i)>=(SCM_BITVECTOR_SIZE(v)))){{
Scm_Error("bitvector index out of range: %ld",i);}}

#line 348 "libvec.scm"
SCM_BITVECTOR_CHECK_MUTABLE(v);

#line 349 "libvec.scm"
if (Scm_Bit2Int(b)){
SCM_BITS_SET(SCM_BITVECTOR_BITS(v),i);} else {
SCM_BITS_RESET(SCM_BITVECTOR_BITS(v),i);}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_UNDEFINED);
  }
}

static ScmObj libvecbitvector_ref_2fint(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("bitvector-ref/int");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 356 "libvec.scm"
if (((i)<(0))||((i)>=(SCM_BITVECTOR_SIZE(v)))){{
if (SCM_UNBOUNDP(fallback)){
Scm_Error("bitvector index out of range: %ld",i);} else {
{SCM_RESULT=(fallback);goto SCM_STUB_RETURN;}}}}

#line 360 "libvec.scm"
{SCM_RESULT=(((SCM_BITS_TEST(SCM_BITVECTOR_BITS(v),i))?(
SCM_MAKE_INT(1)):(
SCM_MAKE_INT(0))));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_ref_2fbool(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj i_scm;
  ScmSmallInt i;
  ScmObj fallback_scm;
  ScmObj fallback;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("bitvector-ref/bool");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 367 "libvec.scm"
if (((i)<(0))||((i)>=(SCM_BITVECTOR_SIZE(v)))){{
if (SCM_UNBOUNDP(fallback)){
Scm_Error("bitvector index out of range: %ld",i);} else {
{SCM_RESULT=(fallback);goto SCM_STUB_RETURN;}}}}

#line 371 "libvec.scm"
{SCM_RESULT=(((SCM_BITS_TEST(SCM_BITVECTOR_BITS(v),i))?(SCM_TRUE):(SCM_FALSE)));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_copy(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("bitvector-copy");
  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);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_Error("bitvector required, but got %S", v_scm);
  v = SCM_BITVECTOR(v_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_SUBRARGS[2];
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_BitvectorCopy(v,start,end));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static ScmObj libvecbitvector_copyX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj dest_scm;
  ScmBitvector* dest;
  ScmObj dstart_scm;
  ScmSmallInt dstart;
  ScmObj src_scm;
  ScmBitvector* src;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[7];
  SCM_ENTER_SUBR("bitvector-copy!");
  if (SCM_ARGCNT >= 6
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 5 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);
  }
  dest_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(dest_scm)) Scm_Error("bitvector required, but got %S", dest_scm);
  dest = SCM_BITVECTOR(dest_scm);
  dstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(dstart_scm)) Scm_Error("small integer required, but got %S", dstart_scm);
  dstart = SCM_INT_VALUE(dstart_scm);
  src_scm = SCM_SUBRARGS[2];
  if (!SCM_BITVECTORP(src_scm)) Scm_Error("bitvector required, but got %S", src_scm);
  src = SCM_BITVECTOR(src_scm);
  if (SCM_ARGCNT > 3+1) {
    start_scm = SCM_SUBRARGS[3];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 4+1) {
    end_scm = SCM_SUBRARGS[4];
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
{SCM_RESULT=(Scm_BitvectorCopyX(dest,dstart,src,start,end));goto SCM_STUB_RETURN;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

#define common_eqv(a,b) ((a)==(b))

#define common_lt(a,b) ((a)<(b))

#define hc_eqv(a,b) ((((a).r)==((b).r))&&(((a).i)==((b).i)))

#define hc_lt(a,b) ((((a).r)<((b).r))||((((a).r)==((b).r))&&(((a).i)<((b).i))))

#define fc_lt(a,b) (((crealf(a))<(crealf(b)))||(((crealf(a))==(crealf(b)))&&((cimagf(a))<(cimagf(b)))))

#define dc_lt(a,b) (((creal(a))<(creal(b)))||(((creal(a))==(creal(b)))&&((cimag(a))<(cimag(b)))))

 size_t Scm_BinarySearchS8(const int8_t* vec,size_t len,int8_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 439 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{int8_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchU8(const uint8_t* vec,size_t len,uint8_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 447 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{uint8_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchS16(const int16_t* vec,size_t len,int16_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 455 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{int16_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchU16(const uint16_t* vec,size_t len,uint16_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 463 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{uint16_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchS32(const int32_t* vec,size_t len,int32_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 471 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{int32_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchU32(const uint32_t* vec,size_t len,uint32_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 479 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{uint32_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchS64(const int64_t* vec,size_t len,int64_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 487 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{int64_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchU64(const uint64_t* vec,size_t len,uint64_t key,u_int skip,size_t* floor,size_t* ceil){{
#line 495 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{uint64_t v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchF16(const ScmHalfFloat* vec,size_t len,ScmHalfFloat key,u_int skip,size_t* floor,size_t* ceil){{
#line 503 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{ScmHalfFloat v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchF32(const float* vec,size_t len,float key,u_int skip,size_t* floor,size_t* ceil){{
#line 511 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{float v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchF64(const double* vec,size_t len,double key,u_int skip,size_t* floor,size_t* ceil){{
#line 519 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{double v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(common_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchC32(const ScmHalfComplex* vec,size_t len,ScmHalfComplex key,u_int skip,size_t* floor,size_t* ceil){{
#line 527 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{ScmHalfComplex v=(vec)[(k)*(esize)];if (hc_eqv(v,key)){return ((k)*(esize));}else if(hc_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchC64(const ScmFloatComplex* vec,size_t len,ScmFloatComplex key,u_int skip,size_t* floor,size_t* ceil){{
#line 535 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{ScmFloatComplex v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(fc_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
 size_t Scm_BinarySearchC128(const ScmDoubleComplex* vec,size_t len,ScmDoubleComplex key,u_int skip,size_t* floor,size_t* ceil){{
#line 543 "libvec.scm"
{u_int esize=(skip)+(1);size_t nume=(len)/(esize);size_t k=(nume)/(2);size_t hi=nume;size_t lo=0;while((lo)<(hi)){{ScmDoubleComplex v=(vec)[(k)*(esize)];if (common_eqv(v,key)){return ((k)*(esize));}else if(dc_lt(v,key)){lo=(k);k=((lo)+(((hi)-(lo))/(2)));if ((lo)==(k)){{break;}}} else {hi=(k);k=((lo)+(((hi)-(lo))/(2)));}}}if (floor){{if ((lo)==(hi)){*(floor)=(((size_t )(-1)));} else {*(floor)=((lo)*(esize));}}}if (ceil){{if ((hi)==(nume)){*(ceil)=(((size_t )(-1)));} else {*(ceil)=((hi)*(esize));}}}return (((size_t )(-1)));}}}
static ScmCompiledCode *toplevels[] = {
 NULL /*termination*/
};
void Scm_Init_libvec() {
   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.d1562[0] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[0])),TRUE); /* vector */
  scm__rc.d1562[1] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1561[1]))); /* :rest */
  scm__rc.d1562[2] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[2])),TRUE); /* args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[1]), scm__rc.d1562[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[2]), scm__rc.d1562[1]);
  scm__rc.d1562[3] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[3])),TRUE); /* source-info */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[5]), scm__rc.d1562[3]);
  scm__rc.d1562[4] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[5])),TRUE); /* bind-info */
  scm__rc.d1562[5] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[6])),TRUE); /* scheme */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[6]), scm__rc.d1562[0]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[7]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[8]), scm__rc.d1562[4]);
  scm__rc.d1562[6] = Scm_MakeExtendedPair(scm__rc.d1562[0], SCM_OBJ(&scm__rc.d1563[2]), SCM_OBJ(&scm__rc.d1563[10]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector")), SCM_OBJ(&libvecvector__STUB), SCM_BINDING_INLINABLE);
  libvecvector__STUB.common.info = scm__rc.d1562[6];
  scm__rc.d1562[7] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[7])),TRUE); /* vector? */
  scm__rc.d1562[8] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[8])),TRUE); /* obj */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[11]), scm__rc.d1562[8]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[14]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[15]), scm__rc.d1562[7]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[16]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[17]), scm__rc.d1562[4]);
  scm__rc.d1562[9] = Scm_MakeExtendedPair(scm__rc.d1562[7], SCM_OBJ(&scm__rc.d1563[11]), SCM_OBJ(&scm__rc.d1563[19]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector?")), SCM_OBJ(&libvecvectorP__STUB), SCM_BINDING_INLINABLE);
  libvecvectorP__STUB.common.info = scm__rc.d1562[9];
  scm__rc.d1562[10] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[9])),TRUE); /* vector-length */
  scm__rc.d1562[11] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[10])),TRUE); /* vec */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[20]), scm__rc.d1562[11]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[23]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[24]), scm__rc.d1562[10]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[25]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[26]), scm__rc.d1562[4]);
  scm__rc.d1562[12] = Scm_MakeExtendedPair(scm__rc.d1562[10], SCM_OBJ(&scm__rc.d1563[20]), SCM_OBJ(&scm__rc.d1563[28]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-length")), SCM_OBJ(&libvecvector_length__STUB), SCM_BINDING_INLINABLE);
  libvecvector_length__STUB.common.info = scm__rc.d1562[12];
  scm__rc.d1562[13] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[11])),TRUE); /* vector-ref */
  scm__rc.d1562[14] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[12])),TRUE); /* k */
  scm__rc.d1562[15] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1561[13]))); /* :optional */
  scm__rc.d1562[16] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[14])),TRUE); /* fallback */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[29]), scm__rc.d1562[16]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[30]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[31]), scm__rc.d1562[14]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[32]), scm__rc.d1562[11]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[35]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[36]), scm__rc.d1562[13]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[37]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[38]), scm__rc.d1562[4]);
  scm__rc.d1562[17] = Scm_MakeExtendedPair(scm__rc.d1562[13], SCM_OBJ(&scm__rc.d1563[32]), SCM_OBJ(&scm__rc.d1563[40]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-ref")), SCM_OBJ(&libvecvector_ref__STUB), SCM_BINDING_INLINABLE);
  libvecvector_ref__STUB.common.info = scm__rc.d1562[17];
  Scm_SetterSet(SCM_PROCEDURE(&libvecvector_ref__STUB), SCM_PROCEDURE(&libvecvector_setX__STUB), TRUE);
  scm__rc.d1562[18] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[15])),TRUE); /* vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[41]), scm__rc.d1562[14]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[42]), scm__rc.d1562[11]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[45]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[46]), scm__rc.d1562[18]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[47]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[48]), scm__rc.d1562[4]);
  scm__rc.d1562[19] = Scm_MakeExtendedPair(scm__rc.d1562[18], SCM_OBJ(&scm__rc.d1563[42]), SCM_OBJ(&scm__rc.d1563[50]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-set!")), SCM_OBJ(&libvecvector_setX__STUB), 0);
  libvecvector_setX__STUB.common.info = scm__rc.d1562[19];
  scm__rc.d1562[20] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[16])),TRUE); /* vector->list */
  scm__rc.d1562[21] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[17])),TRUE); /* start */
  scm__rc.d1562[22] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[18])),TRUE); /* end */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[51]), scm__rc.d1562[22]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[52]), scm__rc.d1562[21]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[53]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[54]), scm__rc.d1562[11]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[57]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[58]), scm__rc.d1562[20]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[59]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[60]), scm__rc.d1562[4]);
  scm__rc.d1562[23] = Scm_MakeExtendedPair(scm__rc.d1562[20], SCM_OBJ(&scm__rc.d1563[54]), SCM_OBJ(&scm__rc.d1563[62]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector->list")), SCM_OBJ(&libvecvector_TOlist__STUB), 0);
  libvecvector_TOlist__STUB.common.info = scm__rc.d1562[23];
  scm__rc.d1562[24] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[19])),TRUE); /* list->vector */
  scm__rc.d1562[25] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[20])),TRUE); /* list */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[63]), scm__rc.d1562[25]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[66]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[67]), scm__rc.d1562[24]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[68]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[69]), scm__rc.d1562[4]);
  scm__rc.d1562[26] = Scm_MakeExtendedPair(scm__rc.d1562[24], SCM_OBJ(&scm__rc.d1563[63]), SCM_OBJ(&scm__rc.d1563[71]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("list->vector")), SCM_OBJ(&libveclist_TOvector__STUB), 0);
  libveclist_TOvector__STUB.common.info = scm__rc.d1562[26];
  scm__rc.d1562[27] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[21])),TRUE); /* vector-fill! */
  scm__rc.d1562[28] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[22])),TRUE); /* fill */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[72]), scm__rc.d1562[28]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[73]), scm__rc.d1562[11]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[76]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[77]), scm__rc.d1562[27]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[78]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[79]), scm__rc.d1562[4]);
  scm__rc.d1562[29] = Scm_MakeExtendedPair(scm__rc.d1562[27], SCM_OBJ(&scm__rc.d1563[73]), SCM_OBJ(&scm__rc.d1563[81]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-fill!")), SCM_OBJ(&libvecvector_fillX__STUB), 0);
  libvecvector_fillX__STUB.common.info = scm__rc.d1562[29];
  scm__rc.d1562[30] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[23])),TRUE); /* vector-copy */
  scm__rc.d1562[31] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[24])),TRUE); /* v */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[82]), scm__rc.d1562[28]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[83]), scm__rc.d1562[22]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[84]), scm__rc.d1562[21]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[85]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[86]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[89]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[90]), scm__rc.d1562[30]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[91]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[92]), scm__rc.d1562[4]);
  scm__rc.d1562[32] = Scm_MakeExtendedPair(scm__rc.d1562[30], SCM_OBJ(&scm__rc.d1563[86]), SCM_OBJ(&scm__rc.d1563[94]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-copy")), SCM_OBJ(&libvecvector_copy__STUB), 0);
  libvecvector_copy__STUB.common.info = scm__rc.d1562[32];
  scm__rc.d1562[33] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[25])),TRUE); /* vector-copy! */
  scm__rc.d1562[34] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[26])),TRUE); /* t */
  scm__rc.d1562[35] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[27])),TRUE); /* tstart */
  scm__rc.d1562[36] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[28])),TRUE); /* s */
  scm__rc.d1562[37] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[29])),TRUE); /* sstart */
  scm__rc.d1562[38] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[30])),TRUE); /* send */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[95]), scm__rc.d1562[38]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[96]), scm__rc.d1562[37]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[97]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[98]), scm__rc.d1562[36]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[99]), scm__rc.d1562[35]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[100]), scm__rc.d1562[34]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[103]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[104]), scm__rc.d1562[33]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[105]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[106]), scm__rc.d1562[4]);
  scm__rc.d1562[39] = Scm_MakeExtendedPair(scm__rc.d1562[33], SCM_OBJ(&scm__rc.d1563[100]), SCM_OBJ(&scm__rc.d1563[108]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-copy!")), SCM_OBJ(&libvecvector_copyX__STUB), 0);
  libvecvector_copyX__STUB.common.info = scm__rc.d1562[39];
  scm__rc.d1562[40] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[31])),TRUE); /* vector-append */
  scm__rc.d1562[41] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[32])),TRUE); /* vecs */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[109]), scm__rc.d1562[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[110]), scm__rc.d1562[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[113]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[114]), scm__rc.d1562[40]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[115]), scm__rc.d1562[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[116]), scm__rc.d1562[4]);
  scm__rc.d1562[42] = Scm_MakeExtendedPair(scm__rc.d1562[40], SCM_OBJ(&scm__rc.d1563[110]), SCM_OBJ(&scm__rc.d1563[118]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())), SCM_SYMBOL(SCM_INTERN("vector-append")), SCM_OBJ(&libvecvector_append__STUB), 0);
  libvecvector_append__STUB.common.info = scm__rc.d1562[42];
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1562[43] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[33])),TRUE); /* vector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[119]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[122]), scm__rc.d1562[3]);
  scm__rc.d1562[44] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[34])),TRUE); /* gauche */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[123]), scm__rc.d1562[43]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[124]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[125]), scm__rc.d1562[4]);
  scm__rc.d1562[45] = Scm_MakeExtendedPair(scm__rc.d1562[43], SCM_OBJ(&scm__rc.d1563[119]), SCM_OBJ(&scm__rc.d1563[127]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("vector-immutable?")), SCM_OBJ(&libvecvector_immutableP__STUB), 0);
  libvecvector_immutableP__STUB.common.info = scm__rc.d1562[45];
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1562[46] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[35])),TRUE); /* vector->string */
  scm__rc.d1562[47] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[37])),TRUE); /* lambda */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[129]), scm__rc.d1562[21]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[131]), scm__rc.d1562[22]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[134]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[135]), scm__rc.d1562[31]);
  scm__rc.d1562[48] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[38])),TRUE); /* list->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[136]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[137]), scm__rc.d1562[20]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[139]), scm__rc.d1562[48]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[142]), scm__rc.d1562[47]);
  scm__rc.d1562[50] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[39])),TRUE); /* error */
  scm__rc.d1562[51] = SCM_OBJ(Scm_FindModule(SCM_SYMBOL(scm__rc.d1562[44]), SCM_FIND_MODULE_CREATE|SCM_FIND_MODULE_PLACEHOLDING)); /* module gauche */
  scm__rc.d1562[49] = Scm_MakeIdentifier(scm__rc.d1562[50], SCM_MODULE(scm__rc.d1562[51]), SCM_NIL); /* gauche#error */
  scm__rc.d1562[52] = Scm_MakeIdentifier(scm__rc.d1562[20], SCM_MODULE(scm__rc.d1562[51]), SCM_NIL); /* gauche#vector->list */
  scm__rc.d1562[53] = Scm_MakeIdentifier(scm__rc.d1562[48], SCM_MODULE(scm__rc.d1562[51]), SCM_NIL); /* gauche#list->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[145]), scm__rc.d1562[3]);
  scm__rc.d1562[54] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[40])),TRUE); /* unused-args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[146]), scm__rc.d1562[54]);
  scm__rc.d1562[55] = Scm_MakeExtendedPair(scm__rc.d1562[46], SCM_OBJ(&scm__rc.d1563[135]), SCM_OBJ(&scm__rc.d1563[148]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[149]), scm__rc.d1562[55]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1571[0]))->name = scm__rc.d1562[46];/* vector->string */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]))[44] = SCM_WORD(scm__rc.d1562[49]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]))[51] = SCM_WORD(scm__rc.d1562[52]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[0]))[53] = SCM_WORD(scm__rc.d1562[53]);
  ScmObj G1572 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1571[0]), NULL);

  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())) /* scheme */, SCM_SYMBOL(scm__rc.d1562[46]) /* vector->string */, G1572,0);

  scm__rc.d1562[56] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[41])),TRUE); /* string->vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[150]), scm__rc.d1562[36]);
  scm__rc.d1562[57] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[42])),TRUE); /* string->list */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[151]), scm__rc.d1562[36]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[152]), scm__rc.d1562[57]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[154]), scm__rc.d1562[24]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[157]), scm__rc.d1562[47]);
  scm__rc.d1562[58] = Scm_MakeIdentifier(scm__rc.d1562[57], SCM_MODULE(scm__rc.d1562[51]), SCM_NIL); /* gauche#string->list */
  scm__rc.d1562[59] = Scm_MakeIdentifier(scm__rc.d1562[24], SCM_MODULE(scm__rc.d1562[51]), SCM_NIL); /* gauche#list->vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[160]), scm__rc.d1562[3]);
  scm__rc.d1562[60] = Scm_MakeExtendedPair(scm__rc.d1562[56], SCM_OBJ(&scm__rc.d1563[150]), SCM_OBJ(&scm__rc.d1563[161]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[162]), scm__rc.d1562[60]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1571[1]))->name = scm__rc.d1562[56];/* string->vector */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]))[44] = SCM_WORD(scm__rc.d1562[49]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]))[51] = SCM_WORD(scm__rc.d1562[58]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1570[55]))[53] = SCM_WORD(scm__rc.d1562[59]);
  ScmObj G1577 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1571[1]), NULL);

  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())) /* scheme */, SCM_SYMBOL(scm__rc.d1562[56]) /* string->vector */, G1577,0);

   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1562[61] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[43])),TRUE); /* make-weak-vector */
  scm__rc.d1562[62] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[44])),TRUE); /* size */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[163]), scm__rc.d1562[62]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[166]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[167]), scm__rc.d1562[61]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[168]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[169]), scm__rc.d1562[4]);
  scm__rc.d1562[63] = Scm_MakeExtendedPair(scm__rc.d1562[61], SCM_OBJ(&scm__rc.d1563[163]), SCM_OBJ(&scm__rc.d1563[171]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-weak-vector")), SCM_OBJ(&libvecmake_weak_vector__STUB), 0);
  libvecmake_weak_vector__STUB.common.info = scm__rc.d1562[63];
  scm__rc.d1562[64] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[45])),TRUE); /* weak-vector-length */
  scm__rc.d1562[65] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[46])),TRUE); /* wv */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[172]), scm__rc.d1562[65]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[175]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[176]), scm__rc.d1562[64]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[177]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[178]), scm__rc.d1562[4]);
  scm__rc.d1562[66] = Scm_MakeExtendedPair(scm__rc.d1562[64], SCM_OBJ(&scm__rc.d1563[172]), SCM_OBJ(&scm__rc.d1563[180]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("weak-vector-length")), SCM_OBJ(&libvecweak_vector_length__STUB), 0);
  libvecweak_vector_length__STUB.common.info = scm__rc.d1562[66];
  scm__rc.d1562[67] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[47])),TRUE); /* weak-vector-ref */
  scm__rc.d1562[68] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[48])),TRUE); /* index */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[181]), scm__rc.d1562[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[182]), scm__rc.d1562[65]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[185]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[186]), scm__rc.d1562[67]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[187]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[188]), scm__rc.d1562[4]);
  scm__rc.d1562[69] = Scm_MakeExtendedPair(scm__rc.d1562[67], SCM_OBJ(&scm__rc.d1563[182]), SCM_OBJ(&scm__rc.d1563[190]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("weak-vector-ref")), SCM_OBJ(&libvecweak_vector_ref__STUB), 0);
  libvecweak_vector_ref__STUB.common.info = scm__rc.d1562[69];
  scm__rc.d1562[70] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[49])),TRUE); /* weak-vector-set! */
  scm__rc.d1562[71] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[50])),TRUE); /* val */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[191]), scm__rc.d1562[71]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[192]), scm__rc.d1562[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[193]), scm__rc.d1562[65]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[196]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[197]), scm__rc.d1562[70]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[198]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[199]), scm__rc.d1562[4]);
  scm__rc.d1562[72] = Scm_MakeExtendedPair(scm__rc.d1562[70], SCM_OBJ(&scm__rc.d1563[193]), SCM_OBJ(&scm__rc.d1563[201]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("weak-vector-set!")), SCM_OBJ(&libvecweak_vector_setX__STUB), 0);
  libvecweak_vector_setX__STUB.common.info = scm__rc.d1562[72];
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1562[73] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[51])),TRUE); /* SCM_UVECTOR_S8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[73]), Scm_MakeInteger(SCM_UVECTOR_S8), SCM_BINDING_CONST);

  scm__rc.d1562[74] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[52])),TRUE); /* SCM_UVECTOR_U8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[74]), Scm_MakeInteger(SCM_UVECTOR_U8), SCM_BINDING_CONST);

  scm__rc.d1562[75] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[53])),TRUE); /* SCM_UVECTOR_S16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[75]), Scm_MakeInteger(SCM_UVECTOR_S16), SCM_BINDING_CONST);

  scm__rc.d1562[76] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[54])),TRUE); /* SCM_UVECTOR_U16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[76]), Scm_MakeInteger(SCM_UVECTOR_U16), SCM_BINDING_CONST);

  scm__rc.d1562[77] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[55])),TRUE); /* SCM_UVECTOR_S32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[77]), Scm_MakeInteger(SCM_UVECTOR_S32), SCM_BINDING_CONST);

  scm__rc.d1562[78] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[56])),TRUE); /* SCM_UVECTOR_U32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[78]), Scm_MakeInteger(SCM_UVECTOR_U32), SCM_BINDING_CONST);

  scm__rc.d1562[79] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[57])),TRUE); /* SCM_UVECTOR_S64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[79]), Scm_MakeInteger(SCM_UVECTOR_S64), SCM_BINDING_CONST);

  scm__rc.d1562[80] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[58])),TRUE); /* SCM_UVECTOR_U64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[80]), Scm_MakeInteger(SCM_UVECTOR_U64), SCM_BINDING_CONST);

  scm__rc.d1562[81] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[59])),TRUE); /* SCM_UVECTOR_F16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[81]), Scm_MakeInteger(SCM_UVECTOR_F16), SCM_BINDING_CONST);

  scm__rc.d1562[82] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[60])),TRUE); /* SCM_UVECTOR_F32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[82]), Scm_MakeInteger(SCM_UVECTOR_F32), SCM_BINDING_CONST);

  scm__rc.d1562[83] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[61])),TRUE); /* SCM_UVECTOR_F64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1562[83]), Scm_MakeInteger(SCM_UVECTOR_F64), SCM_BINDING_CONST);

  scm__rc.d1562[84] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[62])),TRUE); /* s8vector-set! */
  scm__rc.d1562[85] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[63])),TRUE); /* i */
  scm__rc.d1562[86] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[64])),TRUE); /* clamp */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[202]), scm__rc.d1562[86]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[203]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[204]), scm__rc.d1562[71]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[205]), scm__rc.d1562[85]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[206]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[209]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[210]), scm__rc.d1562[84]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[211]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[212]), scm__rc.d1562[4]);
  scm__rc.d1562[87] = Scm_MakeExtendedPair(scm__rc.d1562[84], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[214]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s8vector-set!")), SCM_OBJ(&libvecs8vector_setX__STUB), 0);
  libvecs8vector_setX__STUB.common.info = scm__rc.d1562[87];
  scm__rc.d1562[88] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[65])),TRUE); /* s8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[215]), scm__rc.d1562[85]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[216]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[219]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[220]), scm__rc.d1562[88]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[221]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[222]), scm__rc.d1562[4]);
  scm__rc.d1562[89] = Scm_MakeExtendedPair(scm__rc.d1562[88], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[224]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s8vector-ref")), SCM_OBJ(&libvecs8vector_ref__STUB), 0);
  libvecs8vector_ref__STUB.common.info = scm__rc.d1562[89];
  Scm_SetterSet(SCM_PROCEDURE(&libvecs8vector_ref__STUB), SCM_PROCEDURE(&libvecs8vector_setX__STUB), TRUE);
  scm__rc.d1562[90] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[66])),TRUE); /* u8vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[227]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[228]), scm__rc.d1562[90]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[229]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[230]), scm__rc.d1562[4]);
  scm__rc.d1562[91] = Scm_MakeExtendedPair(scm__rc.d1562[90], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[232]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u8vector-set!")), SCM_OBJ(&libvecu8vector_setX__STUB), 0);
  libvecu8vector_setX__STUB.common.info = scm__rc.d1562[91];
  scm__rc.d1562[92] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[67])),TRUE); /* u8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[235]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[236]), scm__rc.d1562[92]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[237]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[238]), scm__rc.d1562[4]);
  scm__rc.d1562[93] = Scm_MakeExtendedPair(scm__rc.d1562[92], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[240]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u8vector-ref")), SCM_OBJ(&libvecu8vector_ref__STUB), 0);
  libvecu8vector_ref__STUB.common.info = scm__rc.d1562[93];
  Scm_SetterSet(SCM_PROCEDURE(&libvecu8vector_ref__STUB), SCM_PROCEDURE(&libvecu8vector_setX__STUB), TRUE);
  scm__rc.d1562[94] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[68])),TRUE); /* s16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[243]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[244]), scm__rc.d1562[94]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[245]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[246]), scm__rc.d1562[4]);
  scm__rc.d1562[95] = Scm_MakeExtendedPair(scm__rc.d1562[94], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[248]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s16vector-set!")), SCM_OBJ(&libvecs16vector_setX__STUB), 0);
  libvecs16vector_setX__STUB.common.info = scm__rc.d1562[95];
  scm__rc.d1562[96] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[69])),TRUE); /* s16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[251]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[252]), scm__rc.d1562[96]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[253]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[254]), scm__rc.d1562[4]);
  scm__rc.d1562[97] = Scm_MakeExtendedPair(scm__rc.d1562[96], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[256]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s16vector-ref")), SCM_OBJ(&libvecs16vector_ref__STUB), 0);
  libvecs16vector_ref__STUB.common.info = scm__rc.d1562[97];
  Scm_SetterSet(SCM_PROCEDURE(&libvecs16vector_ref__STUB), SCM_PROCEDURE(&libvecs16vector_setX__STUB), TRUE);
  scm__rc.d1562[98] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[70])),TRUE); /* u16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[259]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[260]), scm__rc.d1562[98]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[261]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[262]), scm__rc.d1562[4]);
  scm__rc.d1562[99] = Scm_MakeExtendedPair(scm__rc.d1562[98], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[264]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u16vector-set!")), SCM_OBJ(&libvecu16vector_setX__STUB), 0);
  libvecu16vector_setX__STUB.common.info = scm__rc.d1562[99];
  scm__rc.d1562[100] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[71])),TRUE); /* u16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[267]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[268]), scm__rc.d1562[100]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[269]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[270]), scm__rc.d1562[4]);
  scm__rc.d1562[101] = Scm_MakeExtendedPair(scm__rc.d1562[100], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[272]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u16vector-ref")), SCM_OBJ(&libvecu16vector_ref__STUB), 0);
  libvecu16vector_ref__STUB.common.info = scm__rc.d1562[101];
  Scm_SetterSet(SCM_PROCEDURE(&libvecu16vector_ref__STUB), SCM_PROCEDURE(&libvecu16vector_setX__STUB), TRUE);
  scm__rc.d1562[102] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[72])),TRUE); /* s32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[275]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[276]), scm__rc.d1562[102]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[277]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[278]), scm__rc.d1562[4]);
  scm__rc.d1562[103] = Scm_MakeExtendedPair(scm__rc.d1562[102], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[280]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s32vector-set!")), SCM_OBJ(&libvecs32vector_setX__STUB), 0);
  libvecs32vector_setX__STUB.common.info = scm__rc.d1562[103];
  scm__rc.d1562[104] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[73])),TRUE); /* s32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[283]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[284]), scm__rc.d1562[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[285]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[286]), scm__rc.d1562[4]);
  scm__rc.d1562[105] = Scm_MakeExtendedPair(scm__rc.d1562[104], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[288]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s32vector-ref")), SCM_OBJ(&libvecs32vector_ref__STUB), 0);
  libvecs32vector_ref__STUB.common.info = scm__rc.d1562[105];
  Scm_SetterSet(SCM_PROCEDURE(&libvecs32vector_ref__STUB), SCM_PROCEDURE(&libvecs32vector_setX__STUB), TRUE);
  scm__rc.d1562[106] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[74])),TRUE); /* u32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[291]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[292]), scm__rc.d1562[106]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[293]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[294]), scm__rc.d1562[4]);
  scm__rc.d1562[107] = Scm_MakeExtendedPair(scm__rc.d1562[106], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[296]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u32vector-set!")), SCM_OBJ(&libvecu32vector_setX__STUB), 0);
  libvecu32vector_setX__STUB.common.info = scm__rc.d1562[107];
  scm__rc.d1562[108] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[75])),TRUE); /* u32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[299]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[300]), scm__rc.d1562[108]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[301]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[302]), scm__rc.d1562[4]);
  scm__rc.d1562[109] = Scm_MakeExtendedPair(scm__rc.d1562[108], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[304]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u32vector-ref")), SCM_OBJ(&libvecu32vector_ref__STUB), 0);
  libvecu32vector_ref__STUB.common.info = scm__rc.d1562[109];
  Scm_SetterSet(SCM_PROCEDURE(&libvecu32vector_ref__STUB), SCM_PROCEDURE(&libvecu32vector_setX__STUB), TRUE);
  scm__rc.d1562[110] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[76])),TRUE); /* s64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[307]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[308]), scm__rc.d1562[110]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[309]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[310]), scm__rc.d1562[4]);
  scm__rc.d1562[111] = Scm_MakeExtendedPair(scm__rc.d1562[110], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[312]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s64vector-set!")), SCM_OBJ(&libvecs64vector_setX__STUB), 0);
  libvecs64vector_setX__STUB.common.info = scm__rc.d1562[111];
  scm__rc.d1562[112] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[77])),TRUE); /* s64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[315]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[316]), scm__rc.d1562[112]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[317]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[318]), scm__rc.d1562[4]);
  scm__rc.d1562[113] = Scm_MakeExtendedPair(scm__rc.d1562[112], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[320]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s64vector-ref")), SCM_OBJ(&libvecs64vector_ref__STUB), 0);
  libvecs64vector_ref__STUB.common.info = scm__rc.d1562[113];
  Scm_SetterSet(SCM_PROCEDURE(&libvecs64vector_ref__STUB), SCM_PROCEDURE(&libvecs64vector_setX__STUB), TRUE);
  scm__rc.d1562[114] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[78])),TRUE); /* u64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[323]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[324]), scm__rc.d1562[114]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[325]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[326]), scm__rc.d1562[4]);
  scm__rc.d1562[115] = Scm_MakeExtendedPair(scm__rc.d1562[114], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[328]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u64vector-set!")), SCM_OBJ(&libvecu64vector_setX__STUB), 0);
  libvecu64vector_setX__STUB.common.info = scm__rc.d1562[115];
  scm__rc.d1562[116] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[79])),TRUE); /* u64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[331]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[332]), scm__rc.d1562[116]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[333]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[334]), scm__rc.d1562[4]);
  scm__rc.d1562[117] = Scm_MakeExtendedPair(scm__rc.d1562[116], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[336]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u64vector-ref")), SCM_OBJ(&libvecu64vector_ref__STUB), 0);
  libvecu64vector_ref__STUB.common.info = scm__rc.d1562[117];
  Scm_SetterSet(SCM_PROCEDURE(&libvecu64vector_ref__STUB), SCM_PROCEDURE(&libvecu64vector_setX__STUB), TRUE);
  scm__rc.d1562[118] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[80])),TRUE); /* f16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[339]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[340]), scm__rc.d1562[118]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[341]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[342]), scm__rc.d1562[4]);
  scm__rc.d1562[119] = Scm_MakeExtendedPair(scm__rc.d1562[118], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[344]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f16vector-set!")), SCM_OBJ(&libvecf16vector_setX__STUB), 0);
  libvecf16vector_setX__STUB.common.info = scm__rc.d1562[119];
  scm__rc.d1562[120] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[81])),TRUE); /* f16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[347]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[348]), scm__rc.d1562[120]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[349]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[350]), scm__rc.d1562[4]);
  scm__rc.d1562[121] = Scm_MakeExtendedPair(scm__rc.d1562[120], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[352]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f16vector-ref")), SCM_OBJ(&libvecf16vector_ref__STUB), 0);
  libvecf16vector_ref__STUB.common.info = scm__rc.d1562[121];
  Scm_SetterSet(SCM_PROCEDURE(&libvecf16vector_ref__STUB), SCM_PROCEDURE(&libvecf16vector_setX__STUB), TRUE);
  scm__rc.d1562[122] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[82])),TRUE); /* f32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[355]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[356]), scm__rc.d1562[122]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[357]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[358]), scm__rc.d1562[4]);
  scm__rc.d1562[123] = Scm_MakeExtendedPair(scm__rc.d1562[122], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[360]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f32vector-set!")), SCM_OBJ(&libvecf32vector_setX__STUB), 0);
  libvecf32vector_setX__STUB.common.info = scm__rc.d1562[123];
  scm__rc.d1562[124] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[83])),TRUE); /* f32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[363]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[364]), scm__rc.d1562[124]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[365]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[366]), scm__rc.d1562[4]);
  scm__rc.d1562[125] = Scm_MakeExtendedPair(scm__rc.d1562[124], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[368]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f32vector-ref")), SCM_OBJ(&libvecf32vector_ref__STUB), 0);
  libvecf32vector_ref__STUB.common.info = scm__rc.d1562[125];
  Scm_SetterSet(SCM_PROCEDURE(&libvecf32vector_ref__STUB), SCM_PROCEDURE(&libvecf32vector_setX__STUB), TRUE);
  scm__rc.d1562[126] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[84])),TRUE); /* f64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[371]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[372]), scm__rc.d1562[126]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[373]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[374]), scm__rc.d1562[4]);
  scm__rc.d1562[127] = Scm_MakeExtendedPair(scm__rc.d1562[126], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[376]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f64vector-set!")), SCM_OBJ(&libvecf64vector_setX__STUB), 0);
  libvecf64vector_setX__STUB.common.info = scm__rc.d1562[127];
  scm__rc.d1562[128] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[85])),TRUE); /* f64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[379]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[380]), scm__rc.d1562[128]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[381]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[382]), scm__rc.d1562[4]);
  scm__rc.d1562[129] = Scm_MakeExtendedPair(scm__rc.d1562[128], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[384]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f64vector-ref")), SCM_OBJ(&libvecf64vector_ref__STUB), 0);
  libvecf64vector_ref__STUB.common.info = scm__rc.d1562[129];
  Scm_SetterSet(SCM_PROCEDURE(&libvecf64vector_ref__STUB), SCM_PROCEDURE(&libvecf64vector_setX__STUB), TRUE);
  scm__rc.d1562[130] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[86])),TRUE); /* c32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[387]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[388]), scm__rc.d1562[130]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[389]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[390]), scm__rc.d1562[4]);
  scm__rc.d1562[131] = Scm_MakeExtendedPair(scm__rc.d1562[130], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[392]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c32vector-set!")), SCM_OBJ(&libvecc32vector_setX__STUB), 0);
  libvecc32vector_setX__STUB.common.info = scm__rc.d1562[131];
  scm__rc.d1562[132] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[87])),TRUE); /* c32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[395]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[396]), scm__rc.d1562[132]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[397]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[398]), scm__rc.d1562[4]);
  scm__rc.d1562[133] = Scm_MakeExtendedPair(scm__rc.d1562[132], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[400]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c32vector-ref")), SCM_OBJ(&libvecc32vector_ref__STUB), 0);
  libvecc32vector_ref__STUB.common.info = scm__rc.d1562[133];
  Scm_SetterSet(SCM_PROCEDURE(&libvecc32vector_ref__STUB), SCM_PROCEDURE(&libvecc32vector_setX__STUB), TRUE);
  scm__rc.d1562[134] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[88])),TRUE); /* c64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[403]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[404]), scm__rc.d1562[134]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[405]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[406]), scm__rc.d1562[4]);
  scm__rc.d1562[135] = Scm_MakeExtendedPair(scm__rc.d1562[134], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[408]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c64vector-set!")), SCM_OBJ(&libvecc64vector_setX__STUB), 0);
  libvecc64vector_setX__STUB.common.info = scm__rc.d1562[135];
  scm__rc.d1562[136] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[89])),TRUE); /* c64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[411]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[412]), scm__rc.d1562[136]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[413]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[414]), scm__rc.d1562[4]);
  scm__rc.d1562[137] = Scm_MakeExtendedPair(scm__rc.d1562[136], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[416]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c64vector-ref")), SCM_OBJ(&libvecc64vector_ref__STUB), 0);
  libvecc64vector_ref__STUB.common.info = scm__rc.d1562[137];
  Scm_SetterSet(SCM_PROCEDURE(&libvecc64vector_ref__STUB), SCM_PROCEDURE(&libvecc64vector_setX__STUB), TRUE);
  scm__rc.d1562[138] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[90])),TRUE); /* c128vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[419]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[420]), scm__rc.d1562[138]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[421]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[422]), scm__rc.d1562[4]);
  scm__rc.d1562[139] = Scm_MakeExtendedPair(scm__rc.d1562[138], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[424]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c128vector-set!")), SCM_OBJ(&libvecc128vector_setX__STUB), 0);
  libvecc128vector_setX__STUB.common.info = scm__rc.d1562[139];
  scm__rc.d1562[140] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[91])),TRUE); /* c128vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[427]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[428]), scm__rc.d1562[140]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[429]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[430]), scm__rc.d1562[4]);
  scm__rc.d1562[141] = Scm_MakeExtendedPair(scm__rc.d1562[140], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[432]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c128vector-ref")), SCM_OBJ(&libvecc128vector_ref__STUB), 0);
  libvecc128vector_ref__STUB.common.info = scm__rc.d1562[141];
  Scm_SetterSet(SCM_PROCEDURE(&libvecc128vector_ref__STUB), SCM_PROCEDURE(&libvecc128vector_setX__STUB), TRUE);
  scm__rc.d1562[142] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[92])),TRUE); /* uvector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[435]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[436]), scm__rc.d1562[142]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[437]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[438]), scm__rc.d1562[4]);
  scm__rc.d1562[143] = Scm_MakeExtendedPair(scm__rc.d1562[142], SCM_OBJ(&scm__rc.d1563[206]), SCM_OBJ(&scm__rc.d1563[440]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector-set!")), SCM_OBJ(&libvecuvector_setX__STUB), 0);
  libvecuvector_setX__STUB.common.info = scm__rc.d1562[143];
  scm__rc.d1562[144] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[93])),TRUE); /* uvector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[443]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[444]), scm__rc.d1562[144]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[445]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[446]), scm__rc.d1562[4]);
  scm__rc.d1562[145] = Scm_MakeExtendedPair(scm__rc.d1562[144], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[448]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector-ref")), SCM_OBJ(&libvecuvector_ref__STUB), 0);
  libvecuvector_ref__STUB.common.info = scm__rc.d1562[145];
  Scm_SetterSet(SCM_PROCEDURE(&libvecuvector_ref__STUB), SCM_PROCEDURE(&libvecuvector_setX__STUB), TRUE);
  scm__rc.d1562[146] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[94])),TRUE); /* uvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[451]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[452]), scm__rc.d1562[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[453]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[454]), scm__rc.d1562[4]);
  scm__rc.d1562[147] = Scm_MakeExtendedPair(scm__rc.d1562[146], SCM_OBJ(&scm__rc.d1563[119]), SCM_OBJ(&scm__rc.d1563[456]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector-length")), SCM_OBJ(&libvecuvector_length__STUB), SCM_BINDING_INLINABLE);
  libvecuvector_length__STUB.common.info = scm__rc.d1562[147];
  scm__rc.d1562[148] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[95])),TRUE); /* uvector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[459]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[460]), scm__rc.d1562[148]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[461]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[462]), scm__rc.d1562[4]);
  scm__rc.d1562[149] = Scm_MakeExtendedPair(scm__rc.d1562[148], SCM_OBJ(&scm__rc.d1563[119]), SCM_OBJ(&scm__rc.d1563[464]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector-immutable?")), SCM_OBJ(&libvecuvector_immutableP__STUB), 0);
  libvecuvector_immutableP__STUB.common.info = scm__rc.d1562[149];
  scm__rc.d1562[150] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[96])),TRUE); /* uvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[467]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[468]), scm__rc.d1562[150]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[469]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[470]), scm__rc.d1562[4]);
  scm__rc.d1562[151] = Scm_MakeExtendedPair(scm__rc.d1562[150], SCM_OBJ(&scm__rc.d1563[11]), SCM_OBJ(&scm__rc.d1563[472]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector?")), SCM_OBJ(&libvecuvectorP__STUB), SCM_BINDING_INLINABLE);
  libvecuvectorP__STUB.common.info = scm__rc.d1562[151];
  scm__rc.d1562[152] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[97])),TRUE); /* u8vector? */
  scm__rc.d1562[153] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[98])),TRUE); /* x */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[473]), scm__rc.d1562[153]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[476]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[477]), scm__rc.d1562[152]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[478]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[479]), scm__rc.d1562[4]);
  scm__rc.d1562[154] = Scm_MakeExtendedPair(scm__rc.d1562[152], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[481]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u8vector?")), SCM_OBJ(&libvecu8vectorP__STUB), 0);
  libvecu8vectorP__STUB.common.info = scm__rc.d1562[154];
  scm__rc.d1562[155] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[99])),TRUE); /* s8vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[484]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[485]), scm__rc.d1562[155]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[486]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[487]), scm__rc.d1562[4]);
  scm__rc.d1562[156] = Scm_MakeExtendedPair(scm__rc.d1562[155], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[489]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s8vector?")), SCM_OBJ(&libvecs8vectorP__STUB), 0);
  libvecs8vectorP__STUB.common.info = scm__rc.d1562[156];
  scm__rc.d1562[157] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[100])),TRUE); /* u16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[492]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[493]), scm__rc.d1562[157]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[494]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[495]), scm__rc.d1562[4]);
  scm__rc.d1562[158] = Scm_MakeExtendedPair(scm__rc.d1562[157], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[497]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u16vector?")), SCM_OBJ(&libvecu16vectorP__STUB), 0);
  libvecu16vectorP__STUB.common.info = scm__rc.d1562[158];
  scm__rc.d1562[159] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[101])),TRUE); /* s16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[500]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[501]), scm__rc.d1562[159]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[502]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[503]), scm__rc.d1562[4]);
  scm__rc.d1562[160] = Scm_MakeExtendedPair(scm__rc.d1562[159], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[505]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s16vector?")), SCM_OBJ(&libvecs16vectorP__STUB), 0);
  libvecs16vectorP__STUB.common.info = scm__rc.d1562[160];
  scm__rc.d1562[161] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[102])),TRUE); /* u32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[508]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[509]), scm__rc.d1562[161]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[510]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[511]), scm__rc.d1562[4]);
  scm__rc.d1562[162] = Scm_MakeExtendedPair(scm__rc.d1562[161], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[513]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u32vector?")), SCM_OBJ(&libvecu32vectorP__STUB), 0);
  libvecu32vectorP__STUB.common.info = scm__rc.d1562[162];
  scm__rc.d1562[163] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[103])),TRUE); /* s32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[516]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[517]), scm__rc.d1562[163]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[518]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[519]), scm__rc.d1562[4]);
  scm__rc.d1562[164] = Scm_MakeExtendedPair(scm__rc.d1562[163], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[521]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s32vector?")), SCM_OBJ(&libvecs32vectorP__STUB), 0);
  libvecs32vectorP__STUB.common.info = scm__rc.d1562[164];
  scm__rc.d1562[165] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[104])),TRUE); /* u64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[524]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[525]), scm__rc.d1562[165]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[526]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[527]), scm__rc.d1562[4]);
  scm__rc.d1562[166] = Scm_MakeExtendedPair(scm__rc.d1562[165], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[529]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u64vector?")), SCM_OBJ(&libvecu64vectorP__STUB), 0);
  libvecu64vectorP__STUB.common.info = scm__rc.d1562[166];
  scm__rc.d1562[167] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[105])),TRUE); /* s64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[532]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[533]), scm__rc.d1562[167]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[534]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[535]), scm__rc.d1562[4]);
  scm__rc.d1562[168] = Scm_MakeExtendedPair(scm__rc.d1562[167], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[537]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s64vector?")), SCM_OBJ(&libvecs64vectorP__STUB), 0);
  libvecs64vectorP__STUB.common.info = scm__rc.d1562[168];
  scm__rc.d1562[169] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[106])),TRUE); /* f16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[540]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[541]), scm__rc.d1562[169]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[542]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[543]), scm__rc.d1562[4]);
  scm__rc.d1562[170] = Scm_MakeExtendedPair(scm__rc.d1562[169], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[545]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f16vector?")), SCM_OBJ(&libvecf16vectorP__STUB), 0);
  libvecf16vectorP__STUB.common.info = scm__rc.d1562[170];
  scm__rc.d1562[171] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[107])),TRUE); /* f32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[548]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[549]), scm__rc.d1562[171]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[550]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[551]), scm__rc.d1562[4]);
  scm__rc.d1562[172] = Scm_MakeExtendedPair(scm__rc.d1562[171], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[553]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f32vector?")), SCM_OBJ(&libvecf32vectorP__STUB), 0);
  libvecf32vectorP__STUB.common.info = scm__rc.d1562[172];
  scm__rc.d1562[173] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[108])),TRUE); /* f64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[556]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[557]), scm__rc.d1562[173]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[558]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[559]), scm__rc.d1562[4]);
  scm__rc.d1562[174] = Scm_MakeExtendedPair(scm__rc.d1562[173], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[561]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f64vector?")), SCM_OBJ(&libvecf64vectorP__STUB), 0);
  libvecf64vectorP__STUB.common.info = scm__rc.d1562[174];
  scm__rc.d1562[175] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[109])),TRUE); /* c32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[564]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[565]), scm__rc.d1562[175]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[566]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[567]), scm__rc.d1562[4]);
  scm__rc.d1562[176] = Scm_MakeExtendedPair(scm__rc.d1562[175], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[569]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c32vector?")), SCM_OBJ(&libvecc32vectorP__STUB), 0);
  libvecc32vectorP__STUB.common.info = scm__rc.d1562[176];
  scm__rc.d1562[177] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[110])),TRUE); /* c64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[572]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[573]), scm__rc.d1562[177]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[574]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[575]), scm__rc.d1562[4]);
  scm__rc.d1562[178] = Scm_MakeExtendedPair(scm__rc.d1562[177], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[577]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c64vector?")), SCM_OBJ(&libvecc64vectorP__STUB), 0);
  libvecc64vectorP__STUB.common.info = scm__rc.d1562[178];
  scm__rc.d1562[179] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[111])),TRUE); /* c128vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[580]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[581]), scm__rc.d1562[179]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[582]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[583]), scm__rc.d1562[4]);
  scm__rc.d1562[180] = Scm_MakeExtendedPair(scm__rc.d1562[179], SCM_OBJ(&scm__rc.d1563[473]), SCM_OBJ(&scm__rc.d1563[585]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c128vector?")), SCM_OBJ(&libvecc128vectorP__STUB), 0);
  libvecc128vectorP__STUB.common.info = scm__rc.d1562[180];
  scm__rc.d1562[181] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[112])),TRUE); /* bitvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[588]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[589]), scm__rc.d1562[181]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[590]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[591]), scm__rc.d1562[4]);
  scm__rc.d1562[182] = Scm_MakeExtendedPair(scm__rc.d1562[181], SCM_OBJ(&scm__rc.d1563[11]), SCM_OBJ(&scm__rc.d1563[593]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector?")), SCM_OBJ(&libvecbitvectorP__STUB), 0);
  libvecbitvectorP__STUB.common.info = scm__rc.d1562[182];
  scm__rc.d1562[183] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[113])),TRUE); /* bitvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[596]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[597]), scm__rc.d1562[183]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[598]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[599]), scm__rc.d1562[4]);
  scm__rc.d1562[184] = Scm_MakeExtendedPair(scm__rc.d1562[183], SCM_OBJ(&scm__rc.d1563[119]), SCM_OBJ(&scm__rc.d1563[601]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-length")), SCM_OBJ(&libvecbitvector_length__STUB), 0);
  libvecbitvector_length__STUB.common.info = scm__rc.d1562[184];
  scm__rc.d1562[185] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[114])),TRUE); /* make-bitvector */
  scm__rc.d1562[186] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[115])),TRUE); /* len */
  scm__rc.d1562[187] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[116])),TRUE); /* init */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[602]), scm__rc.d1562[187]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[603]), scm__rc.d1562[15]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[604]), scm__rc.d1562[186]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[607]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[608]), scm__rc.d1562[185]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[609]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[610]), scm__rc.d1562[4]);
  scm__rc.d1562[188] = Scm_MakeExtendedPair(scm__rc.d1562[185], SCM_OBJ(&scm__rc.d1563[604]), SCM_OBJ(&scm__rc.d1563[612]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-bitvector")), SCM_OBJ(&libvecmake_bitvector__STUB), 0);
  libvecmake_bitvector__STUB.common.info = scm__rc.d1562[188];
  scm__rc.d1562[189] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[117])),TRUE); /* bitvector */
  scm__rc.d1562[190] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[118])),TRUE); /* bits */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[613]), scm__rc.d1562[190]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[614]), scm__rc.d1562[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[617]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[618]), scm__rc.d1562[189]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[619]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[620]), scm__rc.d1562[4]);
  scm__rc.d1562[191] = Scm_MakeExtendedPair(scm__rc.d1562[189], SCM_OBJ(&scm__rc.d1563[614]), SCM_OBJ(&scm__rc.d1563[622]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector")), SCM_OBJ(&libvecbitvector__STUB), 0);
  libvecbitvector__STUB.common.info = scm__rc.d1562[191];
  scm__rc.d1562[192] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[119])),TRUE); /* list->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[625]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[626]), scm__rc.d1562[192]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[627]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[628]), scm__rc.d1562[4]);
  scm__rc.d1562[193] = Scm_MakeExtendedPair(scm__rc.d1562[192], SCM_OBJ(&scm__rc.d1563[613]), SCM_OBJ(&scm__rc.d1563[630]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("list->bitvector")), SCM_OBJ(&libveclist_TObitvector__STUB), 0);
  libveclist_TObitvector__STUB.common.info = scm__rc.d1562[193];
  scm__rc.d1562[194] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[120])),TRUE); /* string->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[631]), scm__rc.d1562[36]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[634]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[635]), scm__rc.d1562[194]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[636]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[637]), scm__rc.d1562[4]);
  scm__rc.d1562[195] = Scm_MakeExtendedPair(scm__rc.d1562[194], SCM_OBJ(&scm__rc.d1563[631]), SCM_OBJ(&scm__rc.d1563[639]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->bitvector")), SCM_OBJ(&libvecstring_TObitvector__STUB), 0);
  libvecstring_TObitvector__STUB.common.info = scm__rc.d1562[195];
  scm__rc.d1562[196] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[121])),TRUE); /* bitvector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[642]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[643]), scm__rc.d1562[196]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[644]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[645]), scm__rc.d1562[4]);
  scm__rc.d1562[197] = Scm_MakeExtendedPair(scm__rc.d1562[196], SCM_OBJ(&scm__rc.d1563[119]), SCM_OBJ(&scm__rc.d1563[647]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector->string")), SCM_OBJ(&libvecbitvector_TOstring__STUB), 0);
  libvecbitvector_TOstring__STUB.common.info = scm__rc.d1562[197];
  scm__rc.d1562[198] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[122])),TRUE); /* bit->integer */
  scm__rc.d1562[199] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[123])),TRUE); /* bit */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[648]), scm__rc.d1562[199]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[651]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[652]), scm__rc.d1562[198]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[653]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[654]), scm__rc.d1562[4]);
  scm__rc.d1562[200] = Scm_MakeExtendedPair(scm__rc.d1562[198], SCM_OBJ(&scm__rc.d1563[648]), SCM_OBJ(&scm__rc.d1563[656]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bit->integer")), SCM_OBJ(&libvecbit_TOinteger__STUB), 0);
  libvecbit_TOinteger__STUB.common.info = scm__rc.d1562[200];
  scm__rc.d1562[201] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[124])),TRUE); /* bit->boolean */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[659]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[660]), scm__rc.d1562[201]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[661]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[662]), scm__rc.d1562[4]);
  scm__rc.d1562[202] = Scm_MakeExtendedPair(scm__rc.d1562[201], SCM_OBJ(&scm__rc.d1563[648]), SCM_OBJ(&scm__rc.d1563[664]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bit->boolean")), SCM_OBJ(&libvecbit_TOboolean__STUB), 0);
  libvecbit_TOboolean__STUB.common.info = scm__rc.d1562[202];
  scm__rc.d1562[203] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[125])),TRUE); /* bitvector-set! */
  scm__rc.d1562[204] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[126])),TRUE); /* b */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[665]), scm__rc.d1562[204]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[666]), scm__rc.d1562[85]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[667]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[670]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[671]), scm__rc.d1562[203]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[672]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[673]), scm__rc.d1562[4]);
  scm__rc.d1562[205] = Scm_MakeExtendedPair(scm__rc.d1562[203], SCM_OBJ(&scm__rc.d1563[667]), SCM_OBJ(&scm__rc.d1563[675]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-set!")), SCM_OBJ(&libvecbitvector_setX__STUB), 0);
  libvecbitvector_setX__STUB.common.info = scm__rc.d1562[205];
  scm__rc.d1562[206] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[127])),TRUE); /* bitvector-ref/int */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[678]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[679]), scm__rc.d1562[206]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[680]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[681]), scm__rc.d1562[4]);
  scm__rc.d1562[207] = Scm_MakeExtendedPair(scm__rc.d1562[206], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[683]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-ref/int")), SCM_OBJ(&libvecbitvector_ref_2fint__STUB), 0);
  libvecbitvector_ref_2fint__STUB.common.info = scm__rc.d1562[207];
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fint__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1562[208] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[128])),TRUE); /* bitvector-ref/bool */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[686]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[687]), scm__rc.d1562[208]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[688]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[689]), scm__rc.d1562[4]);
  scm__rc.d1562[209] = Scm_MakeExtendedPair(scm__rc.d1562[208], SCM_OBJ(&scm__rc.d1563[216]), SCM_OBJ(&scm__rc.d1563[691]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-ref/bool")), SCM_OBJ(&libvecbitvector_ref_2fbool__STUB), 0);
  libvecbitvector_ref_2fbool__STUB.common.info = scm__rc.d1562[209];
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fbool__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1562[210] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[129])),TRUE); /* bitvector-copy */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[692]), scm__rc.d1562[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[695]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[696]), scm__rc.d1562[210]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[697]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[698]), scm__rc.d1562[4]);
  scm__rc.d1562[211] = Scm_MakeExtendedPair(scm__rc.d1562[210], SCM_OBJ(&scm__rc.d1563[692]), SCM_OBJ(&scm__rc.d1563[700]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-copy")), SCM_OBJ(&libvecbitvector_copy__STUB), 0);
  libvecbitvector_copy__STUB.common.info = scm__rc.d1562[211];
  scm__rc.d1562[212] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[130])),TRUE); /* bitvector-copy! */
  scm__rc.d1562[213] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[131])),TRUE); /* dest */
  scm__rc.d1562[214] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[132])),TRUE); /* dstart */
  scm__rc.d1562[215] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1561[133])),TRUE); /* src */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[701]), scm__rc.d1562[215]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[702]), scm__rc.d1562[214]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[703]), scm__rc.d1562[213]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[706]), scm__rc.d1562[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[707]), scm__rc.d1562[212]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[708]), scm__rc.d1562[44]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1563[709]), scm__rc.d1562[4]);
  scm__rc.d1562[216] = Scm_MakeExtendedPair(scm__rc.d1562[212], SCM_OBJ(&scm__rc.d1563[703]), SCM_OBJ(&scm__rc.d1563[711]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-copy!")), SCM_OBJ(&libvecbitvector_copyX__STUB), 0);
  libvecbitvector_copyX__STUB.common.info = scm__rc.d1562[216];
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  Scm_VMExecuteToplevels(toplevels);
}
