/* 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>


#line 39 "libvec.scm"
#include <gauche/priv/mmapP.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 libvecmake_view_uvector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_view_uvector__STUB, 3, 3,SCM_FALSE,libvecmake_view_uvector, 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 d1612[171];
} scm__sc SCM_UNUSED = {
  {   /* ScmString d1612 */
      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("*", 1, 1),
      SCM_STRING_CONST_INITIALIZER("->", 2, 2),
      SCM_STRING_CONST_INITIALIZER("<top>", 5, 5),
      SCM_STRING_CONST_INITIALIZER("vector\077", 7, 7),
      SCM_STRING_CONST_INITIALIZER("obj", 3, 3),
      SCM_STRING_CONST_INITIALIZER("<boolean>", 9, 9),
      SCM_STRING_CONST_INITIALIZER("vector-length", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vec", 3, 3),
      SCM_STRING_CONST_INITIALIZER("<vector>", 8, 8),
      SCM_STRING_CONST_INITIALIZER("<fixnum>", 8, 8),
      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("<integer>", 9, 9),
      SCM_STRING_CONST_INITIALIZER("vector-set!", 11, 11),
      SCM_STRING_CONST_INITIALIZER("<void>", 6, 6),
      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("<list>", 6, 6),
      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>", 13, 13),
      SCM_STRING_CONST_INITIALIZER("<int>", 5, 5),
      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>", 10, 10),
      SCM_STRING_CONST_INITIALIZER("s8vector-ref", 12, 12),
      SCM_STRING_CONST_INITIALIZER("u8vector-set!", 13, 13),
      SCM_STRING_CONST_INITIALIZER("<u8vector>", 10, 10),
      SCM_STRING_CONST_INITIALIZER("u8vector-ref", 12, 12),
      SCM_STRING_CONST_INITIALIZER("s16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<s16vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("s16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<u16vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("u16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("s32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<s32vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("s32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<u32vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("u32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("s64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<s64vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("s64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("u64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<u64vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("u64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f16vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<f16vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("f16vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<f32vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("f32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("f64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<f64vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("f64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c32vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<c32vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("c32vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c64vector-set!", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<c64vector>", 11, 11),
      SCM_STRING_CONST_INITIALIZER("c64vector-ref", 13, 13),
      SCM_STRING_CONST_INITIALIZER("c128vector-set!", 15, 15),
      SCM_STRING_CONST_INITIALIZER("<c128vector>", 12, 12),
      SCM_STRING_CONST_INITIALIZER("c128vector-ref", 14, 14),
      SCM_STRING_CONST_INITIALIZER("uvector-set!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("<uvector>", 9, 9),
      SCM_STRING_CONST_INITIALIZER("uvector-ref", 11, 11),
      SCM_STRING_CONST_INITIALIZER("uvector-length", 14, 14),
      SCM_STRING_CONST_INITIALIZER("<ulong>", 7, 7),
      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("make-view-uvector", 17, 17),
      SCM_STRING_CONST_INITIALIZER("mem", 3, 3),
      SCM_STRING_CONST_INITIALIZER("klass", 5, 5),
      SCM_STRING_CONST_INITIALIZER("length", 6, 6),
      SCM_STRING_CONST_INITIALIZER("offset", 6, 6),
      SCM_STRING_CONST_INITIALIZER("immutable\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("<class>", 7, 7),
      SCM_STRING_CONST_INITIALIZER("<integer>\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("bitvector\077", 10, 10),
      SCM_STRING_CONST_INITIALIZER("bitvector-length", 16, 16),
      SCM_STRING_CONST_INITIALIZER("<bitvector>", 11, 11),
      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("<string>", 8, 8),
      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 d1622[2];
  ScmWord d1621[110];
  ScmPair d1614[726] SCM_ALIGN_PAIR;
  ScmObj d1613[770];
} scm__rc SCM_UNUSED = {
  {   /* ScmCompiledCode d1622 */
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* vector->string */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1621[0])), 55,
            22, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[149]),
            SCM_FALSE, SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* string->vector */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1621[55])), 55,
            22, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1614[162]),
            SCM_FALSE, SCM_FALSE),
  },
  {   /* ScmWord d1621 */
    /* vector->string */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 6),
    0x00000002    /*   3 (CONSTI 0) */,
    0x00000013    /*   4 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 7),
    0x0000006a    /*   6 (LREF0-CAR) */,
    0x0000000d    /*   7 (PUSH) */,
    0x0000003d    /*   8 (LREF0) */,
    0x00000022    /*   9 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 14),
    0x00000003    /*  11 (CONSTN) */,
    0x00000013    /*  12 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.d1621[0]) + 22),
    -0x00000ffe   /*  19 (CONSTI -1) */,
    0x00000013    /*  20 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 23),
    0x0000006a    /*  22 (LREF0-CAR) */,
    0x0000000d    /*  23 (PUSH) */,
    0x0000003d    /*  24 (LREF0) */,
    0x00000022    /*  25 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 30),
    0x00000003    /*  27 (CONSTN) */,
    0x00000013    /*  28 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.d1621[0]) + 37),
    0x00000013    /*  35 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 45),
    0x0000200e    /*  37 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]) + 45),
    0x00000006    /*  39 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1612[45])) /* "too many arguments for" */,
    0x00000006    /*  41 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1614[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.3eb8efa0> */,
    0x0000300e    /*  45 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.3eb95000> */,
    0x00001063    /*  52 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#list->string.3eb950c0> */,
    0x00000014    /*  54 (RET) */,
    /* string->vector */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 6),
    0x00000002    /*   3 (CONSTI 0) */,
    0x00000013    /*   4 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 7),
    0x0000006a    /*   6 (LREF0-CAR) */,
    0x0000000d    /*   7 (PUSH) */,
    0x0000003d    /*   8 (LREF0) */,
    0x00000022    /*   9 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 14),
    0x00000003    /*  11 (CONSTN) */,
    0x00000013    /*  12 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.d1621[55]) + 22),
    -0x00000ffe   /*  19 (CONSTI -1) */,
    0x00000013    /*  20 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 23),
    0x0000006a    /*  22 (LREF0-CAR) */,
    0x0000000d    /*  23 (PUSH) */,
    0x0000003d    /*  24 (LREF0) */,
    0x00000022    /*  25 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 30),
    0x00000003    /*  27 (CONSTN) */,
    0x00000013    /*  28 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.d1621[55]) + 37),
    0x00000013    /*  35 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 45),
    0x0000200e    /*  37 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]) + 45),
    0x00000006    /*  39 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1612[45])) /* "too many arguments for" */,
    0x00000006    /*  41 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1614[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.3e1d54c0> */,
    0x0000300e    /*  45 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1621[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.3e1d6e20> */,
    0x00001063    /*  52 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* #<identifier #f#list->vector.3e1d6e60> */,
    0x00000014    /*  54 (RET) */,
  },
  {   /* ScmPair d1614 */
       { SCM_NIL, SCM_NIL },
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[1])},
       { SCM_MAKE_INT(49U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[3])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[4])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[6])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[7])},
       { SCM_OBJ(&scm__rc.d1614[8]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[5]), SCM_OBJ(&scm__rc.d1614[9])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(52U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[12])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[13])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[15])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[16])},
       { SCM_OBJ(&scm__rc.d1614[17]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[14]), SCM_OBJ(&scm__rc.d1614[18])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(55U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[21])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[22])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[24])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[25])},
       { SCM_OBJ(&scm__rc.d1614[26]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[23]), SCM_OBJ(&scm__rc.d1614[27])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[29])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[31])},
       { SCM_MAKE_INT(58U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[33])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[34])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[36])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[37])},
       { SCM_OBJ(&scm__rc.d1614[38]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[35]), SCM_OBJ(&scm__rc.d1614[39])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[11])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[41])},
       { SCM_MAKE_INT(69U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[43])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[44])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[46])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[47])},
       { SCM_OBJ(&scm__rc.d1614[48]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[45]), SCM_OBJ(&scm__rc.d1614[49])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[51])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[53])},
       { SCM_MAKE_INT(79U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[55])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[56])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[58])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[59])},
       { SCM_OBJ(&scm__rc.d1614[60]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[57]), SCM_OBJ(&scm__rc.d1614[61])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[53])},
       { SCM_MAKE_INT(83U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[64])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[65])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[67])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[68])},
       { SCM_OBJ(&scm__rc.d1614[69]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[66]), SCM_OBJ(&scm__rc.d1614[70])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[72])},
       { SCM_MAKE_INT(87U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[74])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[75])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[77])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[78])},
       { SCM_OBJ(&scm__rc.d1614[79]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[76]), SCM_OBJ(&scm__rc.d1614[80])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[82])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[83])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[84])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[85])},
       { SCM_MAKE_INT(91U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[87])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[88])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[90])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[91])},
       { SCM_OBJ(&scm__rc.d1614[92]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[89]), SCM_OBJ(&scm__rc.d1614[93])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[95])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[96])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[97])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[98])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[99])},
       { SCM_MAKE_INT(95U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[101])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[102])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[104])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[105])},
       { SCM_OBJ(&scm__rc.d1614[106]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[103]), SCM_OBJ(&scm__rc.d1614[107])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[109])},
       { SCM_MAKE_INT(126U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[111])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[112])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[114])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[115])},
       { SCM_OBJ(&scm__rc.d1614[116]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[113]), SCM_OBJ(&scm__rc.d1614[117])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(142U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[120])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[121])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[123])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[124])},
       { SCM_OBJ(&scm__rc.d1614[125]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[122]), SCM_OBJ(&scm__rc.d1614[126])},
       { SCM_MAKE_INT(0), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[128])},
       { SCM_MAKE_INT(-1), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[130])},
       { SCM_OBJ(&scm__rc.d1614[131]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[129]), SCM_OBJ(&scm__rc.d1614[132])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[133])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[134])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[136])},
       { SCM_OBJ(&scm__rc.d1614[137]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[138])},
       { SCM_OBJ(&scm__rc.d1614[139]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[135]), SCM_OBJ(&scm__rc.d1614[140])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[141])},
       { SCM_MAKE_INT(150U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[143])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[144])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[146]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[145]), SCM_OBJ(&scm__rc.d1614[147])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[134])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[151])},
       { SCM_OBJ(&scm__rc.d1614[152]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[153])},
       { SCM_OBJ(&scm__rc.d1614[154]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[150]), SCM_OBJ(&scm__rc.d1614[155])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[156])},
       { SCM_MAKE_INT(152U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[158])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[159])},
       { SCM_OBJ(&scm__rc.d1614[160]), SCM_OBJ(&scm__rc.d1614[147])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(161U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[164])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[165])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[167])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[168])},
       { SCM_OBJ(&scm__rc.d1614[169]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[166]), SCM_OBJ(&scm__rc.d1614[170])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(163U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[173])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[174])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[176])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[177])},
       { SCM_OBJ(&scm__rc.d1614[178]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[175]), SCM_OBJ(&scm__rc.d1614[179])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[181])},
       { SCM_MAKE_INT(167U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[183])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[184])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[186])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[187])},
       { SCM_OBJ(&scm__rc.d1614[188]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[185]), SCM_OBJ(&scm__rc.d1614[189])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[191])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[192])},
       { SCM_MAKE_INT(170U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[194])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[195])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[197])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[198])},
       { SCM_OBJ(&scm__rc.d1614[199]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[196]), SCM_OBJ(&scm__rc.d1614[200])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[202])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[203])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[204])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[205])},
       { SCM_MAKE_INT(196U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[207])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[208])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[210])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[211])},
       { SCM_OBJ(&scm__rc.d1614[212]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[209]), SCM_OBJ(&scm__rc.d1614[213])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[215])},
       { SCM_MAKE_INT(198U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[217])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[218])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[220])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[221])},
       { SCM_OBJ(&scm__rc.d1614[222]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[219]), SCM_OBJ(&scm__rc.d1614[223])},
       { SCM_MAKE_INT(203U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[225])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[226])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[228])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[229])},
       { SCM_OBJ(&scm__rc.d1614[230]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[227]), SCM_OBJ(&scm__rc.d1614[231])},
       { SCM_MAKE_INT(205U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[233])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[234])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[236])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[237])},
       { SCM_OBJ(&scm__rc.d1614[238]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[235]), SCM_OBJ(&scm__rc.d1614[239])},
       { SCM_MAKE_INT(210U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[241])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[242])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[244])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[245])},
       { SCM_OBJ(&scm__rc.d1614[246]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[243]), SCM_OBJ(&scm__rc.d1614[247])},
       { SCM_MAKE_INT(212U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[249])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[250])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[252])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[253])},
       { SCM_OBJ(&scm__rc.d1614[254]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[251]), SCM_OBJ(&scm__rc.d1614[255])},
       { SCM_MAKE_INT(217U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[257])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[258])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[260])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[261])},
       { SCM_OBJ(&scm__rc.d1614[262]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[259]), SCM_OBJ(&scm__rc.d1614[263])},
       { SCM_MAKE_INT(219U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[265])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[266])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[268])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[269])},
       { SCM_OBJ(&scm__rc.d1614[270]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[267]), SCM_OBJ(&scm__rc.d1614[271])},
       { SCM_MAKE_INT(224U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[273])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[274])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[276])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[277])},
       { SCM_OBJ(&scm__rc.d1614[278]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[275]), SCM_OBJ(&scm__rc.d1614[279])},
       { SCM_MAKE_INT(226U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[281])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[282])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[284])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[285])},
       { SCM_OBJ(&scm__rc.d1614[286]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[283]), SCM_OBJ(&scm__rc.d1614[287])},
       { SCM_MAKE_INT(231U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[289])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[290])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[292])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[293])},
       { SCM_OBJ(&scm__rc.d1614[294]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[291]), SCM_OBJ(&scm__rc.d1614[295])},
       { SCM_MAKE_INT(233U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[297])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[298])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[300])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[301])},
       { SCM_OBJ(&scm__rc.d1614[302]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[299]), SCM_OBJ(&scm__rc.d1614[303])},
       { SCM_MAKE_INT(238U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[305])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[308])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[309])},
       { SCM_OBJ(&scm__rc.d1614[310]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[307]), SCM_OBJ(&scm__rc.d1614[311])},
       { SCM_MAKE_INT(240U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[313])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[314])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[316])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[317])},
       { SCM_OBJ(&scm__rc.d1614[318]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[315]), SCM_OBJ(&scm__rc.d1614[319])},
       { SCM_MAKE_INT(245U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[321])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[322])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[324])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[325])},
       { SCM_OBJ(&scm__rc.d1614[326]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[323]), SCM_OBJ(&scm__rc.d1614[327])},
       { SCM_MAKE_INT(247U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[329])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[330])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[332])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[333])},
       { SCM_OBJ(&scm__rc.d1614[334]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[331]), SCM_OBJ(&scm__rc.d1614[335])},
       { SCM_MAKE_INT(252U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[337])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[338])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[340])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[341])},
       { SCM_OBJ(&scm__rc.d1614[342]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[339]), SCM_OBJ(&scm__rc.d1614[343])},
       { SCM_MAKE_INT(254U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[345])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[346])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[348])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[349])},
       { SCM_OBJ(&scm__rc.d1614[350]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[347]), SCM_OBJ(&scm__rc.d1614[351])},
       { SCM_MAKE_INT(259U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[353])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[354])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[356])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[357])},
       { SCM_OBJ(&scm__rc.d1614[358]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[355]), SCM_OBJ(&scm__rc.d1614[359])},
       { SCM_MAKE_INT(261U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[361])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[362])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[364])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[365])},
       { SCM_OBJ(&scm__rc.d1614[366]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[363]), SCM_OBJ(&scm__rc.d1614[367])},
       { SCM_MAKE_INT(266U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[369])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[370])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[372])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[373])},
       { SCM_OBJ(&scm__rc.d1614[374]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[371]), SCM_OBJ(&scm__rc.d1614[375])},
       { SCM_MAKE_INT(268U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[377])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[378])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[380])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[381])},
       { SCM_OBJ(&scm__rc.d1614[382]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[379]), SCM_OBJ(&scm__rc.d1614[383])},
       { SCM_MAKE_INT(273U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[385])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[386])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[388])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[389])},
       { SCM_OBJ(&scm__rc.d1614[390]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[387]), SCM_OBJ(&scm__rc.d1614[391])},
       { SCM_MAKE_INT(275U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[393])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[394])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[396])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[397])},
       { SCM_OBJ(&scm__rc.d1614[398]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[395]), SCM_OBJ(&scm__rc.d1614[399])},
       { SCM_MAKE_INT(280U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[401])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[402])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[404])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[405])},
       { SCM_OBJ(&scm__rc.d1614[406]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[403]), SCM_OBJ(&scm__rc.d1614[407])},
       { SCM_MAKE_INT(282U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[409])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[410])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[412])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[413])},
       { SCM_OBJ(&scm__rc.d1614[414]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[411]), SCM_OBJ(&scm__rc.d1614[415])},
       { SCM_MAKE_INT(287U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[417])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[418])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[420])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[421])},
       { SCM_OBJ(&scm__rc.d1614[422]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[419]), SCM_OBJ(&scm__rc.d1614[423])},
       { SCM_MAKE_INT(289U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[425])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[426])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[428])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[429])},
       { SCM_OBJ(&scm__rc.d1614[430]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[427]), SCM_OBJ(&scm__rc.d1614[431])},
       { SCM_MAKE_INT(294U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[433])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[434])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[436])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[437])},
       { SCM_OBJ(&scm__rc.d1614[438]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[435]), SCM_OBJ(&scm__rc.d1614[439])},
       { SCM_MAKE_INT(298U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[441])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[442])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[444])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[445])},
       { SCM_OBJ(&scm__rc.d1614[446]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[443]), SCM_OBJ(&scm__rc.d1614[447])},
       { SCM_MAKE_INT(303U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[449])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[450])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[452])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[453])},
       { SCM_OBJ(&scm__rc.d1614[454]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[451]), SCM_OBJ(&scm__rc.d1614[455])},
       { SCM_MAKE_INT(305U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[457])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[458])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[460])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[461])},
       { SCM_OBJ(&scm__rc.d1614[462]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[459]), SCM_OBJ(&scm__rc.d1614[463])},
       { SCM_MAKE_INT(307U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[465])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[466])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[468])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[469])},
       { SCM_OBJ(&scm__rc.d1614[470]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[467]), SCM_OBJ(&scm__rc.d1614[471])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(310U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[474])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[475])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[477])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[478])},
       { SCM_OBJ(&scm__rc.d1614[479]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[476]), SCM_OBJ(&scm__rc.d1614[480])},
       { SCM_MAKE_INT(311U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[482])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[483])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[485])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[486])},
       { SCM_OBJ(&scm__rc.d1614[487]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[484]), SCM_OBJ(&scm__rc.d1614[488])},
       { SCM_MAKE_INT(312U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[490])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[491])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[493])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[494])},
       { SCM_OBJ(&scm__rc.d1614[495]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[492]), SCM_OBJ(&scm__rc.d1614[496])},
       { SCM_MAKE_INT(313U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[498])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[499])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[501])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[502])},
       { SCM_OBJ(&scm__rc.d1614[503]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[500]), SCM_OBJ(&scm__rc.d1614[504])},
       { SCM_MAKE_INT(314U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[506])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[507])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[509])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[510])},
       { SCM_OBJ(&scm__rc.d1614[511]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[508]), SCM_OBJ(&scm__rc.d1614[512])},
       { SCM_MAKE_INT(315U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[514])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[515])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[517])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[518])},
       { SCM_OBJ(&scm__rc.d1614[519]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[516]), SCM_OBJ(&scm__rc.d1614[520])},
       { SCM_MAKE_INT(316U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[522])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[523])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[525])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[526])},
       { SCM_OBJ(&scm__rc.d1614[527]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[524]), SCM_OBJ(&scm__rc.d1614[528])},
       { SCM_MAKE_INT(317U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[530])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[531])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[533])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[534])},
       { SCM_OBJ(&scm__rc.d1614[535]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[532]), SCM_OBJ(&scm__rc.d1614[536])},
       { SCM_MAKE_INT(318U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[538])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[539])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[541])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[542])},
       { SCM_OBJ(&scm__rc.d1614[543]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[540]), SCM_OBJ(&scm__rc.d1614[544])},
       { SCM_MAKE_INT(319U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[546])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[547])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[549])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[550])},
       { SCM_OBJ(&scm__rc.d1614[551]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[548]), SCM_OBJ(&scm__rc.d1614[552])},
       { SCM_MAKE_INT(320U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[554])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[555])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[557])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[558])},
       { SCM_OBJ(&scm__rc.d1614[559]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[556]), SCM_OBJ(&scm__rc.d1614[560])},
       { SCM_MAKE_INT(321U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[562])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[563])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[565])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[566])},
       { SCM_OBJ(&scm__rc.d1614[567]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[564]), SCM_OBJ(&scm__rc.d1614[568])},
       { SCM_MAKE_INT(322U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[570])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[571])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[573])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[574])},
       { SCM_OBJ(&scm__rc.d1614[575]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[572]), SCM_OBJ(&scm__rc.d1614[576])},
       { SCM_MAKE_INT(323U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[578])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[579])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[581])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[582])},
       { SCM_OBJ(&scm__rc.d1614[583]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[580]), SCM_OBJ(&scm__rc.d1614[584])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[586])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[587])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[588])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[589])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[590])},
       { SCM_MAKE_INT(325U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[592])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[593])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[595])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[596])},
       { SCM_OBJ(&scm__rc.d1614[597]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[594]), SCM_OBJ(&scm__rc.d1614[598])},
       { SCM_MAKE_INT(341U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[600])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[601])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[603])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[604])},
       { SCM_OBJ(&scm__rc.d1614[605]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[602]), SCM_OBJ(&scm__rc.d1614[606])},
       { SCM_MAKE_INT(342U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[608])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[609])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[611])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[612])},
       { SCM_OBJ(&scm__rc.d1614[613]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[610]), SCM_OBJ(&scm__rc.d1614[614])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[616])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[617])},
       { SCM_MAKE_INT(345U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[619])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[620])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[622])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[623])},
       { SCM_OBJ(&scm__rc.d1614[624]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[621]), SCM_OBJ(&scm__rc.d1614[625])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[627])},
       { SCM_MAKE_INT(347U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[629])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[630])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[632])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[633])},
       { SCM_OBJ(&scm__rc.d1614[634]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[631]), SCM_OBJ(&scm__rc.d1614[635])},
       { SCM_MAKE_INT(348U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[637])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[638])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[640])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[641])},
       { SCM_OBJ(&scm__rc.d1614[642]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[639]), SCM_OBJ(&scm__rc.d1614[643])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(350U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[646])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[647])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[649])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[650])},
       { SCM_OBJ(&scm__rc.d1614[651]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[648]), SCM_OBJ(&scm__rc.d1614[652])},
       { SCM_MAKE_INT(352U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[654])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[655])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[657])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[658])},
       { SCM_OBJ(&scm__rc.d1614[659]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[656]), SCM_OBJ(&scm__rc.d1614[660])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(355U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[663])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[664])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[666])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[667])},
       { SCM_OBJ(&scm__rc.d1614[668]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[665]), SCM_OBJ(&scm__rc.d1614[669])},
       { SCM_MAKE_INT(356U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[671])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[672])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[674])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[675])},
       { SCM_OBJ(&scm__rc.d1614[676]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[673]), SCM_OBJ(&scm__rc.d1614[677])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[679])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[680])},
       { SCM_MAKE_INT(358U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[682])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[683])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[685])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[686])},
       { SCM_OBJ(&scm__rc.d1614[687]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[684]), SCM_OBJ(&scm__rc.d1614[688])},
       { SCM_MAKE_INT(366U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[690])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[691])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[693])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[694])},
       { SCM_OBJ(&scm__rc.d1614[695]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[692]), SCM_OBJ(&scm__rc.d1614[696])},
       { SCM_MAKE_INT(377U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[698])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[699])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[701])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[702])},
       { SCM_OBJ(&scm__rc.d1614[703]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[700]), SCM_OBJ(&scm__rc.d1614[704])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[53])},
       { SCM_MAKE_INT(386U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[707])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[708])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[710])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[711])},
       { SCM_OBJ(&scm__rc.d1614[712]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[709]), SCM_OBJ(&scm__rc.d1614[713])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[715])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[716])},
       { SCM_MAKE_INT(391U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1612[4]), SCM_OBJ(&scm__rc.d1614[718])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[719])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[721])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1614[722])},
       { SCM_OBJ(&scm__rc.d1614[723]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1614[720]), SCM_OBJ(&scm__rc.d1614[724])},
  },
  {   /* ScmObj d1613 */
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(7, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(8, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
  },
};

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];
  if (!(args_scm)) Scm_Error("scheme object required, but got %S", args_scm);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 50 "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];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 61 "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];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  obj = (obj_scm);
  {

#line 70 "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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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];
  if (!(fill_scm)) Scm_Error("scheme object required, but got %S", fill_scm);
  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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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;
  }
  if (!(fill_scm)) Scm_Error("scheme object required, but got %S", fill_scm);
  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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt required, but got %S", send_scm);
  send = SCM_INT_VALUE(send_scm);
  {

#line 97 "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 109 "libvec.scm"
if (!((sstart)<=(send))){{
Scm_Error("send (%ld) must be greater than or equal to sstart (%ld)",send,sstart);}}
#line 112 "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];
  if (!(vecs_scm)) Scm_Error("scheme object required, but got %S", vecs_scm);
  vecs = (vecs_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1616;ScmObj cise__1615;
#line 127 "libvec.scm"
{long len=0;
SCM_FOR_EACH(cise__1615,vecs) {{ScmObj v=SCM_CAR(cise__1615);
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 134 "libvec.scm"
SCM_FOR_EACH(cise__1616,vecs) {{ScmObj v=SCM_CAR(cise__1616);
{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("ScmSmallInt 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 164 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  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("ScmSmallInt required, but got %S", index_scm);
  index = SCM_INT_VALUE(index_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 197 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 201 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 204 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 208 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 211 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 215 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 218 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 222 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 225 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 229 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 232 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 236 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 239 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 243 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 246 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 250 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 253 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 257 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 260 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 264 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 267 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 271 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 274 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 278 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 281 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 285 "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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;

#line 288 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 292 "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("<uvector> required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_Error("scheme object required, but got %S", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_Error("scheme object required, but got %S", clamp_scm);
  clamp = (clamp_scm);
  {

#line 296 "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("<uvector> required, but got %S", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_Error("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 301 "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("<uvector> 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_MakeIntegerU(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("<uvector> 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];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_S16VECTORP(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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_S32VECTORP(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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
{SCM_RESULT=(SCM_S64VECTORP(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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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];
  if (!(x_scm)) Scm_Error("scheme object required, but got %S", x_scm);
  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 libvecmake_view_uvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj mem_scm;
  ScmObj mem;
  ScmObj klass_scm;
  ScmClass* klass;
  ScmObj length_scm;
  ScmObj length;
  ScmObj offset_scm;
  ScmSmallInt offset;
  ScmObj immutableP_scm;
  int immutableP;
  ScmObj SCM_SUBRARGS[7];
  SCM_ENTER_SUBR("make-view-uvector");
  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);
  }
  mem_scm = SCM_SUBRARGS[0];
  if (!(mem_scm)) Scm_Error("scheme object required, but got %S", mem_scm);
  mem = (mem_scm);
  klass_scm = SCM_SUBRARGS[1];
  if (!SCM_CLASSP(klass_scm)) Scm_Error("<class> required, but got %S", klass_scm);
  klass = SCM_CLASS(klass_scm);
  length_scm = SCM_SUBRARGS[2];
  if (!SCM_MAYBE_P(SCM_INTEGERP, length_scm)) Scm_Error("exact integer or #f required, but got %S", length_scm);
  length = SCM_MAYBE(, length_scm);
  if (SCM_ARGCNT > 3+1) {
    offset_scm = SCM_SUBRARGS[3];
  } else {
    offset_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(offset_scm)) Scm_Error("ScmSmallInt required, but got %S", offset_scm);
  offset = SCM_INT_VALUE(offset_scm);
  if (SCM_ARGCNT > 4+1) {
    immutableP_scm = SCM_SUBRARGS[4];
  } else {
    immutableP_scm = SCM_FALSE;
  }
  if (!SCM_BOOLP(immutableP_scm)) Scm_Error("boolean required, but got %S", immutableP_scm);
  immutableP = SCM_BOOL_VALUE(immutableP_scm);
  {
{
ScmObj SCM_RESULT;

#line 328 "libvec.scm"
if (!(SCM_MEMORY_REGION_P(mem))){{
SCM_TYPE_ERROR(mem,"<memory-region>");}}

#line 330 "libvec.scm"
{ScmSmallInt len=0;
if (SCM_FALSEP(length)){len=(-1);}else if(
SCM_INTP(length)){len=(SCM_INT_VALUE(length));} else {
Scm_Error("length is out of range: %S",length);}
{SCM_RESULT=(Scm_MakeViewUVector(SCM_MEMORY_REGION(mem),klass,len,offset,immutableP));goto SCM_STUB_RETURN;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RETURN(SCM_OBJ_SAFE(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];
  if (!(obj_scm)) Scm_Error("scheme object required, but got %S", obj_scm);
  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("ScmSmallInt 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;
  }
  if (!(init_scm)) Scm_Error("scheme object required, but got %S", init_scm);
  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];
  if (!(bits_scm)) Scm_Error("scheme object required, but got %S", bits_scm);
  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];
  if (!(bits_scm)) Scm_Error("scheme object required, but got %S", bits_scm);
  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 351 "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 353 "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];
  if (!(bit_scm)) Scm_Error("scheme object required, but got %S", bit_scm);
  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];
  if (!(bit_scm)) Scm_Error("scheme object required, but got %S", bit_scm);
  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("ScmSmallInt required, but got %S", i_scm);
  i = SCM_INT_VALUE(i_scm);
  b_scm = SCM_SUBRARGS[2];
  if (!(b_scm)) Scm_Error("scheme object required, but got %S", b_scm);
  b = (b_scm);
  {

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

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

#line 362 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 369 "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 373 "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("ScmSmallInt 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;
  }
  if (!(fallback_scm)) Scm_Error("scheme object required, but got %S", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 380 "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 384 "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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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("ScmSmallInt 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 452 "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 460 "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 468 "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 476 "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 484 "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 492 "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 500 "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 508 "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 516 "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 524 "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 532 "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 540 "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 548 "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 556 "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.d1613[0] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[0])),TRUE); /* vector */
  scm__rc.d1613[1] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[1]))); /* :rest */
  scm__rc.d1613[2] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[2])),TRUE); /* args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[1]), scm__rc.d1613[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[2]), scm__rc.d1613[1]);
  scm__rc.d1613[3] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[3])),TRUE); /* source-info */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[5]), scm__rc.d1613[3]);
  scm__rc.d1613[4] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[5])),TRUE); /* bind-info */
  scm__rc.d1613[5] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[6])),TRUE); /* scheme */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[6]), scm__rc.d1613[0]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[7]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[8]), scm__rc.d1613[4]);
  scm__rc.d1613[6] = Scm_MakeExtendedPair(scm__rc.d1613[0], SCM_OBJ(&scm__rc.d1614[2]), SCM_OBJ(&scm__rc.d1614[10]));
  scm__rc.d1613[7] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[7])),TRUE); /* * */
  scm__rc.d1613[8] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[8])),TRUE); /* -> */
  scm__rc.d1613[9] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[9])),TRUE); /* <top> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[10]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[10]))[4] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[10]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[10]))[6] = scm__rc.d1613[9];
  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.d1613[6];
  libvecvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[10]);
  scm__rc.d1613[17] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[10])),TRUE); /* vector? */
  scm__rc.d1613[18] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[11])),TRUE); /* obj */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[11]), scm__rc.d1613[18]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[14]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[15]), scm__rc.d1613[17]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[16]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[17]), scm__rc.d1613[4]);
  scm__rc.d1613[19] = Scm_MakeExtendedPair(scm__rc.d1613[17], SCM_OBJ(&scm__rc.d1614[11]), SCM_OBJ(&scm__rc.d1614[19]));
  scm__rc.d1613[20] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[12])),TRUE); /* <boolean> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[21]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[21]))[4] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[21]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[21]))[6] = scm__rc.d1613[20];
  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.d1613[19];
  libvecvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[21]);
  scm__rc.d1613[28] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[13])),TRUE); /* vector-length */
  scm__rc.d1613[29] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[14])),TRUE); /* vec */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[20]), scm__rc.d1613[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[23]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[24]), scm__rc.d1613[28]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[25]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[26]), scm__rc.d1613[4]);
  scm__rc.d1613[30] = Scm_MakeExtendedPair(scm__rc.d1613[28], SCM_OBJ(&scm__rc.d1614[20]), SCM_OBJ(&scm__rc.d1614[28]));
  scm__rc.d1613[31] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[15])),TRUE); /* <vector> */
  scm__rc.d1613[32] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[16])),TRUE); /* <fixnum> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[33]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[33]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[33]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[33]))[6] = scm__rc.d1613[32];
  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.d1613[30];
  libvecvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[33]);
  scm__rc.d1613[40] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[17])),TRUE); /* vector-ref */
  scm__rc.d1613[41] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[18])),TRUE); /* k */
  scm__rc.d1613[42] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1612[19]))); /* :optional */
  scm__rc.d1613[43] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[20])),TRUE); /* fallback */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[29]), scm__rc.d1613[43]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[30]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[31]), scm__rc.d1613[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[32]), scm__rc.d1613[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[35]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[36]), scm__rc.d1613[40]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[37]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[38]), scm__rc.d1613[4]);
  scm__rc.d1613[44] = Scm_MakeExtendedPair(scm__rc.d1613[40], SCM_OBJ(&scm__rc.d1614[32]), SCM_OBJ(&scm__rc.d1614[40]));
  scm__rc.d1613[45] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[21])),TRUE); /* <integer> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[5] = scm__rc.d1613[45];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[46]))[8] = scm__rc.d1613[9];
  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.d1613[44];
  libvecvector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[46]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecvector_ref__STUB), SCM_PROCEDURE(&libvecvector_setX__STUB), TRUE);
  scm__rc.d1613[55] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[22])),TRUE); /* vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[41]), scm__rc.d1613[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[42]), scm__rc.d1613[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[45]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[46]), scm__rc.d1613[55]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[47]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[48]), scm__rc.d1613[4]);
  scm__rc.d1613[56] = Scm_MakeExtendedPair(scm__rc.d1613[55], SCM_OBJ(&scm__rc.d1614[42]), SCM_OBJ(&scm__rc.d1614[50]));
  scm__rc.d1613[57] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[23])),TRUE); /* <void> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[5] = scm__rc.d1613[45];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[58]))[8] = scm__rc.d1613[57];
  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.d1613[56];
  libvecvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[58]);
  scm__rc.d1613[67] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[24])),TRUE); /* vector->list */
  scm__rc.d1613[68] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[25])),TRUE); /* start */
  scm__rc.d1613[69] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[26])),TRUE); /* end */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[51]), scm__rc.d1613[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[52]), scm__rc.d1613[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[53]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[54]), scm__rc.d1613[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[57]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[58]), scm__rc.d1613[67]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[59]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[60]), scm__rc.d1613[4]);
  scm__rc.d1613[70] = Scm_MakeExtendedPair(scm__rc.d1613[67], SCM_OBJ(&scm__rc.d1614[54]), SCM_OBJ(&scm__rc.d1614[62]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[71]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[71]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[71]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[71]))[6] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[71]))[7] = scm__rc.d1613[9];
  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.d1613[70];
  libvecvector_TOlist__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[71]);
  scm__rc.d1613[79] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[27])),TRUE); /* list->vector */
  scm__rc.d1613[80] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[28])),TRUE); /* list */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[63]), scm__rc.d1613[80]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[66]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[67]), scm__rc.d1613[79]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[68]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[69]), scm__rc.d1613[4]);
  scm__rc.d1613[81] = Scm_MakeExtendedPair(scm__rc.d1613[79], SCM_OBJ(&scm__rc.d1614[63]), SCM_OBJ(&scm__rc.d1614[71]));
  scm__rc.d1613[82] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[29])),TRUE); /* <list> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[83]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[83]))[4] = scm__rc.d1613[82];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[83]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[83]))[6] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[83]))[7] = scm__rc.d1613[9];
  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.d1613[81];
  libveclist_TOvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[83]);
  scm__rc.d1613[91] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[30])),TRUE); /* vector-fill! */
  scm__rc.d1613[92] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[31])),TRUE); /* fill */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[72]), scm__rc.d1613[92]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[73]), scm__rc.d1613[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[76]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[77]), scm__rc.d1613[91]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[78]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[79]), scm__rc.d1613[4]);
  scm__rc.d1613[93] = Scm_MakeExtendedPair(scm__rc.d1613[91], SCM_OBJ(&scm__rc.d1614[73]), SCM_OBJ(&scm__rc.d1614[81]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[5] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[94]))[8] = scm__rc.d1613[57];
  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.d1613[93];
  libvecvector_fillX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[94]);
  scm__rc.d1613[103] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[32])),TRUE); /* vector-copy */
  scm__rc.d1613[104] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[33])),TRUE); /* v */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[82]), scm__rc.d1613[92]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[83]), scm__rc.d1613[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[84]), scm__rc.d1613[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[85]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[86]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[89]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[90]), scm__rc.d1613[103]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[91]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[92]), scm__rc.d1613[4]);
  scm__rc.d1613[105] = Scm_MakeExtendedPair(scm__rc.d1613[103], SCM_OBJ(&scm__rc.d1614[86]), SCM_OBJ(&scm__rc.d1614[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.d1613[105];
  libvecvector_copy__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[71]);
  scm__rc.d1613[106] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[34])),TRUE); /* vector-copy! */
  scm__rc.d1613[107] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[35])),TRUE); /* t */
  scm__rc.d1613[108] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[36])),TRUE); /* tstart */
  scm__rc.d1613[109] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[37])),TRUE); /* s */
  scm__rc.d1613[110] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[38])),TRUE); /* sstart */
  scm__rc.d1613[111] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[39])),TRUE); /* send */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[95]), scm__rc.d1613[111]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[96]), scm__rc.d1613[110]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[97]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[98]), scm__rc.d1613[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[99]), scm__rc.d1613[108]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[100]), scm__rc.d1613[107]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[103]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[104]), scm__rc.d1613[106]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[105]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[106]), scm__rc.d1613[4]);
  scm__rc.d1613[112] = Scm_MakeExtendedPair(scm__rc.d1613[106], SCM_OBJ(&scm__rc.d1614[100]), SCM_OBJ(&scm__rc.d1614[108]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[3] = scm__rc.d1613[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[6] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[113]))[9] = scm__rc.d1613[57];
  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.d1613[112];
  libvecvector_copyX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[113]);
  scm__rc.d1613[123] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[40])),TRUE); /* vector-append */
  scm__rc.d1613[124] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[41])),TRUE); /* vecs */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[109]), scm__rc.d1613[124]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[110]), scm__rc.d1613[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[113]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[114]), scm__rc.d1613[123]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[115]), scm__rc.d1613[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[116]), scm__rc.d1613[4]);
  scm__rc.d1613[125] = Scm_MakeExtendedPair(scm__rc.d1613[123], SCM_OBJ(&scm__rc.d1614[110]), SCM_OBJ(&scm__rc.d1614[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.d1613[125];
  libvecvector_append__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[10]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[126] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[42])),TRUE); /* vector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[119]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[122]), scm__rc.d1613[3]);
  scm__rc.d1613[127] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[43])),TRUE); /* gauche */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[123]), scm__rc.d1613[126]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[124]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[125]), scm__rc.d1613[4]);
  scm__rc.d1613[128] = Scm_MakeExtendedPair(scm__rc.d1613[126], SCM_OBJ(&scm__rc.d1614[119]), SCM_OBJ(&scm__rc.d1614[127]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[129]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[129]))[4] = scm__rc.d1613[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[129]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[129]))[6] = scm__rc.d1613[20];
  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.d1613[128];
  libvecvector_immutableP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[129]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[136] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[44])),TRUE); /* vector->string */
  scm__rc.d1613[137] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[46])),TRUE); /* lambda */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[129]), scm__rc.d1613[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[131]), scm__rc.d1613[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[134]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[135]), scm__rc.d1613[104]);
  scm__rc.d1613[138] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[47])),TRUE); /* list->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[136]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[137]), scm__rc.d1613[67]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[139]), scm__rc.d1613[138]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[142]), scm__rc.d1613[137]);
  scm__rc.d1613[140] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[48])),TRUE); /* error */
  scm__rc.d1613[141] = SCM_OBJ(Scm_FindModule(SCM_SYMBOL(scm__rc.d1613[127]), SCM_FIND_MODULE_CREATE|SCM_FIND_MODULE_PLACEHOLDING)); /* module gauche */
  scm__rc.d1613[139] = Scm_MakeIdentifier(scm__rc.d1613[140], SCM_MODULE(scm__rc.d1613[141]), SCM_NIL); /* gauche#error */
  scm__rc.d1613[142] = Scm_MakeIdentifier(scm__rc.d1613[67], SCM_MODULE(scm__rc.d1613[141]), SCM_NIL); /* gauche#vector->list */
  scm__rc.d1613[143] = Scm_MakeIdentifier(scm__rc.d1613[138], SCM_MODULE(scm__rc.d1613[141]), SCM_NIL); /* gauche#list->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[145]), scm__rc.d1613[3]);
  scm__rc.d1613[144] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[49])),TRUE); /* unused-args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[146]), scm__rc.d1613[144]);
  scm__rc.d1613[145] = Scm_MakeExtendedPair(scm__rc.d1613[136], SCM_OBJ(&scm__rc.d1614[135]), SCM_OBJ(&scm__rc.d1614[148]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[149]), scm__rc.d1613[145]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1622[0]))->name = scm__rc.d1613[136];/* vector->string */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]))[44] = SCM_WORD(scm__rc.d1613[139]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]))[51] = SCM_WORD(scm__rc.d1613[142]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[0]))[53] = SCM_WORD(scm__rc.d1613[143]);
  ScmObj G1623 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1622[0]), NULL);

  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())) /* scheme */, SCM_SYMBOL(scm__rc.d1613[136]) /* vector->string */, G1623,0);

  scm__rc.d1613[146] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[50])),TRUE); /* string->vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[150]), scm__rc.d1613[109]);
  scm__rc.d1613[147] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[51])),TRUE); /* string->list */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[151]), scm__rc.d1613[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[152]), scm__rc.d1613[147]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[154]), scm__rc.d1613[79]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[157]), scm__rc.d1613[137]);
  scm__rc.d1613[148] = Scm_MakeIdentifier(scm__rc.d1613[147], SCM_MODULE(scm__rc.d1613[141]), SCM_NIL); /* gauche#string->list */
  scm__rc.d1613[149] = Scm_MakeIdentifier(scm__rc.d1613[79], SCM_MODULE(scm__rc.d1613[141]), SCM_NIL); /* gauche#list->vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[160]), scm__rc.d1613[3]);
  scm__rc.d1613[150] = Scm_MakeExtendedPair(scm__rc.d1613[146], SCM_OBJ(&scm__rc.d1614[150]), SCM_OBJ(&scm__rc.d1614[161]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[162]), scm__rc.d1613[150]);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1622[1]))->name = scm__rc.d1613[146];/* string->vector */
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]))[44] = SCM_WORD(scm__rc.d1613[139]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]))[51] = SCM_WORD(scm__rc.d1613[148]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1621[55]))[53] = SCM_WORD(scm__rc.d1613[149]);
  ScmObj G1628 = Scm_MakeClosure(SCM_OBJ(&scm__rc.d1622[1]), NULL);

  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_SchemeModule())) /* scheme */, SCM_SYMBOL(scm__rc.d1613[146]) /* string->vector */, G1628,0);

   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[151] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[52])),TRUE); /* make-weak-vector */
  scm__rc.d1613[152] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[53])),TRUE); /* size */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[163]), scm__rc.d1613[152]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[166]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[167]), scm__rc.d1613[151]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[168]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[169]), scm__rc.d1613[4]);
  scm__rc.d1613[153] = Scm_MakeExtendedPair(scm__rc.d1613[151], SCM_OBJ(&scm__rc.d1614[163]), SCM_OBJ(&scm__rc.d1614[171]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[154]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[154]))[4] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[154]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[154]))[6] = scm__rc.d1613[9];
  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.d1613[153];
  libvecmake_weak_vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[154]);
  scm__rc.d1613[161] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[54])),TRUE); /* weak-vector-length */
  scm__rc.d1613[162] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[55])),TRUE); /* wv */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[172]), scm__rc.d1613[162]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[175]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[176]), scm__rc.d1613[161]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[177]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[178]), scm__rc.d1613[4]);
  scm__rc.d1613[163] = Scm_MakeExtendedPair(scm__rc.d1613[161], SCM_OBJ(&scm__rc.d1614[172]), SCM_OBJ(&scm__rc.d1614[180]));
  scm__rc.d1613[164] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[56])),TRUE); /* <weak-vector> */
  scm__rc.d1613[165] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[57])),TRUE); /* <int> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[166]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[166]))[4] = scm__rc.d1613[164];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[166]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[166]))[6] = scm__rc.d1613[165];
  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.d1613[163];
  libvecweak_vector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[166]);
  scm__rc.d1613[173] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[58])),TRUE); /* weak-vector-ref */
  scm__rc.d1613[174] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[59])),TRUE); /* index */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[181]), scm__rc.d1613[174]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[182]), scm__rc.d1613[162]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[185]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[186]), scm__rc.d1613[173]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[187]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[188]), scm__rc.d1613[4]);
  scm__rc.d1613[175] = Scm_MakeExtendedPair(scm__rc.d1613[173], SCM_OBJ(&scm__rc.d1614[182]), SCM_OBJ(&scm__rc.d1614[190]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[4] = scm__rc.d1613[164];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[176]))[8] = scm__rc.d1613[9];
  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.d1613[175];
  libvecweak_vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[176]);
  scm__rc.d1613[185] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[60])),TRUE); /* weak-vector-set! */
  scm__rc.d1613[186] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[61])),TRUE); /* val */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[191]), scm__rc.d1613[186]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[192]), scm__rc.d1613[174]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[193]), scm__rc.d1613[162]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[196]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[197]), scm__rc.d1613[185]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[198]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[199]), scm__rc.d1613[4]);
  scm__rc.d1613[187] = Scm_MakeExtendedPair(scm__rc.d1613[185], SCM_OBJ(&scm__rc.d1614[193]), SCM_OBJ(&scm__rc.d1614[201]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[4] = scm__rc.d1613[164];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[188]))[8] = scm__rc.d1613[9];
  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.d1613[187];
  libvecweak_vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[188]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1613[197] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[62])),TRUE); /* SCM_UVECTOR_S8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[197]), Scm_MakeInteger(SCM_UVECTOR_S8), SCM_BINDING_CONST);

  scm__rc.d1613[198] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[63])),TRUE); /* SCM_UVECTOR_U8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[198]), Scm_MakeInteger(SCM_UVECTOR_U8), SCM_BINDING_CONST);

  scm__rc.d1613[199] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[64])),TRUE); /* SCM_UVECTOR_S16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[199]), Scm_MakeInteger(SCM_UVECTOR_S16), SCM_BINDING_CONST);

  scm__rc.d1613[200] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[65])),TRUE); /* SCM_UVECTOR_U16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[200]), Scm_MakeInteger(SCM_UVECTOR_U16), SCM_BINDING_CONST);

  scm__rc.d1613[201] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[66])),TRUE); /* SCM_UVECTOR_S32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[201]), Scm_MakeInteger(SCM_UVECTOR_S32), SCM_BINDING_CONST);

  scm__rc.d1613[202] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[67])),TRUE); /* SCM_UVECTOR_U32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[202]), Scm_MakeInteger(SCM_UVECTOR_U32), SCM_BINDING_CONST);

  scm__rc.d1613[203] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[68])),TRUE); /* SCM_UVECTOR_S64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[203]), Scm_MakeInteger(SCM_UVECTOR_S64), SCM_BINDING_CONST);

  scm__rc.d1613[204] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[69])),TRUE); /* SCM_UVECTOR_U64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[204]), Scm_MakeInteger(SCM_UVECTOR_U64), SCM_BINDING_CONST);

  scm__rc.d1613[205] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[70])),TRUE); /* SCM_UVECTOR_F16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[205]), Scm_MakeInteger(SCM_UVECTOR_F16), SCM_BINDING_CONST);

  scm__rc.d1613[206] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[71])),TRUE); /* SCM_UVECTOR_F32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[206]), Scm_MakeInteger(SCM_UVECTOR_F32), SCM_BINDING_CONST);

  scm__rc.d1613[207] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[72])),TRUE); /* SCM_UVECTOR_F64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1613[207]), Scm_MakeInteger(SCM_UVECTOR_F64), SCM_BINDING_CONST);

  scm__rc.d1613[208] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[73])),TRUE); /* s8vector-set! */
  scm__rc.d1613[209] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[74])),TRUE); /* i */
  scm__rc.d1613[210] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[75])),TRUE); /* clamp */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[202]), scm__rc.d1613[210]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[203]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[204]), scm__rc.d1613[186]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[205]), scm__rc.d1613[209]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[206]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[209]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[210]), scm__rc.d1613[208]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[211]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[212]), scm__rc.d1613[4]);
  scm__rc.d1613[211] = Scm_MakeExtendedPair(scm__rc.d1613[208], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[214]));
  scm__rc.d1613[212] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[76])),TRUE); /* <s8vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[4] = scm__rc.d1613[212];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[213]))[9] = scm__rc.d1613[9];
  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.d1613[211];
  libvecs8vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[213]);
  scm__rc.d1613[223] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[77])),TRUE); /* s8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[215]), scm__rc.d1613[209]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[216]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[219]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[220]), scm__rc.d1613[223]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[221]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[222]), scm__rc.d1613[4]);
  scm__rc.d1613[224] = Scm_MakeExtendedPair(scm__rc.d1613[223], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[224]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[4] = scm__rc.d1613[212];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[225]))[8] = scm__rc.d1613[9];
  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.d1613[224];
  libvecs8vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[225]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs8vector_ref__STUB), SCM_PROCEDURE(&libvecs8vector_setX__STUB), TRUE);
  scm__rc.d1613[234] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[78])),TRUE); /* u8vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[227]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[228]), scm__rc.d1613[234]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[229]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[230]), scm__rc.d1613[4]);
  scm__rc.d1613[235] = Scm_MakeExtendedPair(scm__rc.d1613[234], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[232]));
  scm__rc.d1613[236] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[79])),TRUE); /* <u8vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[4] = scm__rc.d1613[236];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[237]))[9] = scm__rc.d1613[9];
  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.d1613[235];
  libvecu8vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[237]);
  scm__rc.d1613[247] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[80])),TRUE); /* u8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[235]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[236]), scm__rc.d1613[247]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[237]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[238]), scm__rc.d1613[4]);
  scm__rc.d1613[248] = Scm_MakeExtendedPair(scm__rc.d1613[247], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[240]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[4] = scm__rc.d1613[236];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[249]))[8] = scm__rc.d1613[9];
  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.d1613[248];
  libvecu8vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[249]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu8vector_ref__STUB), SCM_PROCEDURE(&libvecu8vector_setX__STUB), TRUE);
  scm__rc.d1613[258] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[81])),TRUE); /* s16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[243]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[244]), scm__rc.d1613[258]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[245]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[246]), scm__rc.d1613[4]);
  scm__rc.d1613[259] = Scm_MakeExtendedPair(scm__rc.d1613[258], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[248]));
  scm__rc.d1613[260] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[82])),TRUE); /* <s16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[4] = scm__rc.d1613[260];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[261]))[9] = scm__rc.d1613[9];
  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.d1613[259];
  libvecs16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[261]);
  scm__rc.d1613[271] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[83])),TRUE); /* s16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[251]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[252]), scm__rc.d1613[271]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[253]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[254]), scm__rc.d1613[4]);
  scm__rc.d1613[272] = Scm_MakeExtendedPair(scm__rc.d1613[271], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[256]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[4] = scm__rc.d1613[260];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[273]))[8] = scm__rc.d1613[9];
  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.d1613[272];
  libvecs16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[273]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs16vector_ref__STUB), SCM_PROCEDURE(&libvecs16vector_setX__STUB), TRUE);
  scm__rc.d1613[282] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[84])),TRUE); /* u16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[259]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[260]), scm__rc.d1613[282]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[261]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[262]), scm__rc.d1613[4]);
  scm__rc.d1613[283] = Scm_MakeExtendedPair(scm__rc.d1613[282], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[264]));
  scm__rc.d1613[284] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[85])),TRUE); /* <u16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[4] = scm__rc.d1613[284];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[285]))[9] = scm__rc.d1613[9];
  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.d1613[283];
  libvecu16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[285]);
  scm__rc.d1613[295] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[86])),TRUE); /* u16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[267]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[268]), scm__rc.d1613[295]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[269]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[270]), scm__rc.d1613[4]);
  scm__rc.d1613[296] = Scm_MakeExtendedPair(scm__rc.d1613[295], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[272]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[4] = scm__rc.d1613[284];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[297]))[8] = scm__rc.d1613[9];
  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.d1613[296];
  libvecu16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[297]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu16vector_ref__STUB), SCM_PROCEDURE(&libvecu16vector_setX__STUB), TRUE);
  scm__rc.d1613[306] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[87])),TRUE); /* s32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[275]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[276]), scm__rc.d1613[306]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[277]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[278]), scm__rc.d1613[4]);
  scm__rc.d1613[307] = Scm_MakeExtendedPair(scm__rc.d1613[306], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[280]));
  scm__rc.d1613[308] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[88])),TRUE); /* <s32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[4] = scm__rc.d1613[308];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[309]))[9] = scm__rc.d1613[9];
  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.d1613[307];
  libvecs32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[309]);
  scm__rc.d1613[319] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[89])),TRUE); /* s32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[283]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[284]), scm__rc.d1613[319]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[285]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[286]), scm__rc.d1613[4]);
  scm__rc.d1613[320] = Scm_MakeExtendedPair(scm__rc.d1613[319], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[288]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[4] = scm__rc.d1613[308];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[321]))[8] = scm__rc.d1613[9];
  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.d1613[320];
  libvecs32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[321]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs32vector_ref__STUB), SCM_PROCEDURE(&libvecs32vector_setX__STUB), TRUE);
  scm__rc.d1613[330] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[90])),TRUE); /* u32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[291]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[292]), scm__rc.d1613[330]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[293]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[294]), scm__rc.d1613[4]);
  scm__rc.d1613[331] = Scm_MakeExtendedPair(scm__rc.d1613[330], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[296]));
  scm__rc.d1613[332] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[91])),TRUE); /* <u32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[4] = scm__rc.d1613[332];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[333]))[9] = scm__rc.d1613[9];
  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.d1613[331];
  libvecu32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[333]);
  scm__rc.d1613[343] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[92])),TRUE); /* u32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[299]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[300]), scm__rc.d1613[343]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[301]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[302]), scm__rc.d1613[4]);
  scm__rc.d1613[344] = Scm_MakeExtendedPair(scm__rc.d1613[343], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[304]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[4] = scm__rc.d1613[332];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[345]))[8] = scm__rc.d1613[9];
  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.d1613[344];
  libvecu32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[345]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu32vector_ref__STUB), SCM_PROCEDURE(&libvecu32vector_setX__STUB), TRUE);
  scm__rc.d1613[354] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[93])),TRUE); /* s64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[307]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[308]), scm__rc.d1613[354]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[309]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[310]), scm__rc.d1613[4]);
  scm__rc.d1613[355] = Scm_MakeExtendedPair(scm__rc.d1613[354], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[312]));
  scm__rc.d1613[356] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[94])),TRUE); /* <s64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[4] = scm__rc.d1613[356];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[357]))[9] = scm__rc.d1613[9];
  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.d1613[355];
  libvecs64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[357]);
  scm__rc.d1613[367] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[95])),TRUE); /* s64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[315]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[316]), scm__rc.d1613[367]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[317]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[318]), scm__rc.d1613[4]);
  scm__rc.d1613[368] = Scm_MakeExtendedPair(scm__rc.d1613[367], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[320]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[4] = scm__rc.d1613[356];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[369]))[8] = scm__rc.d1613[9];
  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.d1613[368];
  libvecs64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[369]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs64vector_ref__STUB), SCM_PROCEDURE(&libvecs64vector_setX__STUB), TRUE);
  scm__rc.d1613[378] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[96])),TRUE); /* u64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[323]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[324]), scm__rc.d1613[378]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[325]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[326]), scm__rc.d1613[4]);
  scm__rc.d1613[379] = Scm_MakeExtendedPair(scm__rc.d1613[378], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[328]));
  scm__rc.d1613[380] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[97])),TRUE); /* <u64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[4] = scm__rc.d1613[380];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[381]))[9] = scm__rc.d1613[9];
  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.d1613[379];
  libvecu64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[381]);
  scm__rc.d1613[391] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[98])),TRUE); /* u64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[331]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[332]), scm__rc.d1613[391]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[333]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[334]), scm__rc.d1613[4]);
  scm__rc.d1613[392] = Scm_MakeExtendedPair(scm__rc.d1613[391], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[336]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[4] = scm__rc.d1613[380];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[393]))[8] = scm__rc.d1613[9];
  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.d1613[392];
  libvecu64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[393]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu64vector_ref__STUB), SCM_PROCEDURE(&libvecu64vector_setX__STUB), TRUE);
  scm__rc.d1613[402] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[99])),TRUE); /* f16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[339]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[340]), scm__rc.d1613[402]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[341]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[342]), scm__rc.d1613[4]);
  scm__rc.d1613[403] = Scm_MakeExtendedPair(scm__rc.d1613[402], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[344]));
  scm__rc.d1613[404] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[100])),TRUE); /* <f16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[4] = scm__rc.d1613[404];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[405]))[9] = scm__rc.d1613[9];
  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.d1613[403];
  libvecf16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[405]);
  scm__rc.d1613[415] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[101])),TRUE); /* f16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[347]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[348]), scm__rc.d1613[415]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[349]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[350]), scm__rc.d1613[4]);
  scm__rc.d1613[416] = Scm_MakeExtendedPair(scm__rc.d1613[415], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[352]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[4] = scm__rc.d1613[404];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[417]))[8] = scm__rc.d1613[9];
  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.d1613[416];
  libvecf16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[417]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf16vector_ref__STUB), SCM_PROCEDURE(&libvecf16vector_setX__STUB), TRUE);
  scm__rc.d1613[426] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[102])),TRUE); /* f32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[355]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[356]), scm__rc.d1613[426]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[357]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[358]), scm__rc.d1613[4]);
  scm__rc.d1613[427] = Scm_MakeExtendedPair(scm__rc.d1613[426], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[360]));
  scm__rc.d1613[428] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[103])),TRUE); /* <f32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[4] = scm__rc.d1613[428];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[429]))[9] = scm__rc.d1613[9];
  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.d1613[427];
  libvecf32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[429]);
  scm__rc.d1613[439] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[104])),TRUE); /* f32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[363]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[364]), scm__rc.d1613[439]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[365]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[366]), scm__rc.d1613[4]);
  scm__rc.d1613[440] = Scm_MakeExtendedPair(scm__rc.d1613[439], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[368]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[4] = scm__rc.d1613[428];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[441]))[8] = scm__rc.d1613[9];
  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.d1613[440];
  libvecf32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[441]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf32vector_ref__STUB), SCM_PROCEDURE(&libvecf32vector_setX__STUB), TRUE);
  scm__rc.d1613[450] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[105])),TRUE); /* f64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[371]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[372]), scm__rc.d1613[450]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[373]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[374]), scm__rc.d1613[4]);
  scm__rc.d1613[451] = Scm_MakeExtendedPair(scm__rc.d1613[450], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[376]));
  scm__rc.d1613[452] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[106])),TRUE); /* <f64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[4] = scm__rc.d1613[452];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[453]))[9] = scm__rc.d1613[9];
  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.d1613[451];
  libvecf64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[453]);
  scm__rc.d1613[463] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[107])),TRUE); /* f64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[379]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[380]), scm__rc.d1613[463]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[381]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[382]), scm__rc.d1613[4]);
  scm__rc.d1613[464] = Scm_MakeExtendedPair(scm__rc.d1613[463], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[384]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[4] = scm__rc.d1613[452];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[465]))[8] = scm__rc.d1613[9];
  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.d1613[464];
  libvecf64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[465]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf64vector_ref__STUB), SCM_PROCEDURE(&libvecf64vector_setX__STUB), TRUE);
  scm__rc.d1613[474] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[108])),TRUE); /* c32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[387]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[388]), scm__rc.d1613[474]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[389]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[390]), scm__rc.d1613[4]);
  scm__rc.d1613[475] = Scm_MakeExtendedPair(scm__rc.d1613[474], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[392]));
  scm__rc.d1613[476] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[109])),TRUE); /* <c32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[4] = scm__rc.d1613[476];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[477]))[9] = scm__rc.d1613[9];
  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.d1613[475];
  libvecc32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[477]);
  scm__rc.d1613[487] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[110])),TRUE); /* c32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[395]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[396]), scm__rc.d1613[487]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[397]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[398]), scm__rc.d1613[4]);
  scm__rc.d1613[488] = Scm_MakeExtendedPair(scm__rc.d1613[487], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[400]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[4] = scm__rc.d1613[476];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[489]))[8] = scm__rc.d1613[9];
  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.d1613[488];
  libvecc32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[489]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc32vector_ref__STUB), SCM_PROCEDURE(&libvecc32vector_setX__STUB), TRUE);
  scm__rc.d1613[498] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[111])),TRUE); /* c64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[403]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[404]), scm__rc.d1613[498]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[405]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[406]), scm__rc.d1613[4]);
  scm__rc.d1613[499] = Scm_MakeExtendedPair(scm__rc.d1613[498], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[408]));
  scm__rc.d1613[500] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[112])),TRUE); /* <c64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[4] = scm__rc.d1613[500];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[501]))[9] = scm__rc.d1613[9];
  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.d1613[499];
  libvecc64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[501]);
  scm__rc.d1613[511] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[113])),TRUE); /* c64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[411]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[412]), scm__rc.d1613[511]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[413]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[414]), scm__rc.d1613[4]);
  scm__rc.d1613[512] = Scm_MakeExtendedPair(scm__rc.d1613[511], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[416]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[4] = scm__rc.d1613[500];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[513]))[8] = scm__rc.d1613[9];
  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.d1613[512];
  libvecc64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[513]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc64vector_ref__STUB), SCM_PROCEDURE(&libvecc64vector_setX__STUB), TRUE);
  scm__rc.d1613[522] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[114])),TRUE); /* c128vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[419]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[420]), scm__rc.d1613[522]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[421]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[422]), scm__rc.d1613[4]);
  scm__rc.d1613[523] = Scm_MakeExtendedPair(scm__rc.d1613[522], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[424]));
  scm__rc.d1613[524] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[115])),TRUE); /* <c128vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[4] = scm__rc.d1613[524];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[525]))[9] = scm__rc.d1613[9];
  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.d1613[523];
  libvecc128vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[525]);
  scm__rc.d1613[535] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[116])),TRUE); /* c128vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[427]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[428]), scm__rc.d1613[535]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[429]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[430]), scm__rc.d1613[4]);
  scm__rc.d1613[536] = Scm_MakeExtendedPair(scm__rc.d1613[535], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[432]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[4] = scm__rc.d1613[524];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[537]))[8] = scm__rc.d1613[9];
  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.d1613[536];
  libvecc128vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[537]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc128vector_ref__STUB), SCM_PROCEDURE(&libvecc128vector_setX__STUB), TRUE);
  scm__rc.d1613[546] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[117])),TRUE); /* uvector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[435]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[436]), scm__rc.d1613[546]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[437]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[438]), scm__rc.d1613[4]);
  scm__rc.d1613[547] = Scm_MakeExtendedPair(scm__rc.d1613[546], SCM_OBJ(&scm__rc.d1614[206]), SCM_OBJ(&scm__rc.d1614[440]));
  scm__rc.d1613[548] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[118])),TRUE); /* <uvector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[4] = scm__rc.d1613[548];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[549]))[9] = scm__rc.d1613[57];
  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.d1613[547];
  libvecuvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[549]);
  scm__rc.d1613[559] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[119])),TRUE); /* uvector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[443]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[444]), scm__rc.d1613[559]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[445]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[446]), scm__rc.d1613[4]);
  scm__rc.d1613[560] = Scm_MakeExtendedPair(scm__rc.d1613[559], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[448]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[4] = scm__rc.d1613[548];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[561]))[8] = scm__rc.d1613[9];
  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.d1613[560];
  libvecuvector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[561]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecuvector_ref__STUB), SCM_PROCEDURE(&libvecuvector_setX__STUB), TRUE);
  scm__rc.d1613[570] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[120])),TRUE); /* uvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[451]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[452]), scm__rc.d1613[570]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[453]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[454]), scm__rc.d1613[4]);
  scm__rc.d1613[571] = Scm_MakeExtendedPair(scm__rc.d1613[570], SCM_OBJ(&scm__rc.d1614[119]), SCM_OBJ(&scm__rc.d1614[456]));
  scm__rc.d1613[572] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[121])),TRUE); /* <ulong> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[573]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[573]))[4] = scm__rc.d1613[548];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[573]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[573]))[6] = scm__rc.d1613[572];
  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.d1613[571];
  libvecuvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[573]);
  scm__rc.d1613[580] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[122])),TRUE); /* uvector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[459]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[460]), scm__rc.d1613[580]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[461]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[462]), scm__rc.d1613[4]);
  scm__rc.d1613[581] = Scm_MakeExtendedPair(scm__rc.d1613[580], SCM_OBJ(&scm__rc.d1614[119]), SCM_OBJ(&scm__rc.d1614[464]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[582]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[582]))[4] = scm__rc.d1613[548];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[582]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[582]))[6] = scm__rc.d1613[20];
  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.d1613[581];
  libvecuvector_immutableP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[582]);
  scm__rc.d1613[589] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[123])),TRUE); /* uvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[467]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[468]), scm__rc.d1613[589]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[469]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[470]), scm__rc.d1613[4]);
  scm__rc.d1613[590] = Scm_MakeExtendedPair(scm__rc.d1613[589], SCM_OBJ(&scm__rc.d1614[11]), SCM_OBJ(&scm__rc.d1614[472]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[591]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[591]))[4] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[591]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[591]))[6] = scm__rc.d1613[20];
  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.d1613[590];
  libvecuvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[598] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[124])),TRUE); /* u8vector? */
  scm__rc.d1613[599] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[125])),TRUE); /* x */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[473]), scm__rc.d1613[599]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[476]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[477]), scm__rc.d1613[598]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[478]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[479]), scm__rc.d1613[4]);
  scm__rc.d1613[600] = Scm_MakeExtendedPair(scm__rc.d1613[598], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[600];
  libvecu8vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[601] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[126])),TRUE); /* s8vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[484]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[485]), scm__rc.d1613[601]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[486]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[487]), scm__rc.d1613[4]);
  scm__rc.d1613[602] = Scm_MakeExtendedPair(scm__rc.d1613[601], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[602];
  libvecs8vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[603] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[127])),TRUE); /* u16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[492]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[493]), scm__rc.d1613[603]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[494]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[495]), scm__rc.d1613[4]);
  scm__rc.d1613[604] = Scm_MakeExtendedPair(scm__rc.d1613[603], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[604];
  libvecu16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[605] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[128])),TRUE); /* s16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[500]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[501]), scm__rc.d1613[605]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[502]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[503]), scm__rc.d1613[4]);
  scm__rc.d1613[606] = Scm_MakeExtendedPair(scm__rc.d1613[605], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[606];
  libvecs16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[607] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[129])),TRUE); /* u32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[508]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[509]), scm__rc.d1613[607]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[510]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[511]), scm__rc.d1613[4]);
  scm__rc.d1613[608] = Scm_MakeExtendedPair(scm__rc.d1613[607], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[608];
  libvecu32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[609] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[130])),TRUE); /* s32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[516]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[517]), scm__rc.d1613[609]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[518]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[519]), scm__rc.d1613[4]);
  scm__rc.d1613[610] = Scm_MakeExtendedPair(scm__rc.d1613[609], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[610];
  libvecs32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[611] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[131])),TRUE); /* u64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[524]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[525]), scm__rc.d1613[611]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[526]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[527]), scm__rc.d1613[4]);
  scm__rc.d1613[612] = Scm_MakeExtendedPair(scm__rc.d1613[611], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[612];
  libvecu64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[613] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[132])),TRUE); /* s64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[532]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[533]), scm__rc.d1613[613]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[534]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[535]), scm__rc.d1613[4]);
  scm__rc.d1613[614] = Scm_MakeExtendedPair(scm__rc.d1613[613], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[614];
  libvecs64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[615] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[133])),TRUE); /* f16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[540]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[541]), scm__rc.d1613[615]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[542]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[543]), scm__rc.d1613[4]);
  scm__rc.d1613[616] = Scm_MakeExtendedPair(scm__rc.d1613[615], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[616];
  libvecf16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[617] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[134])),TRUE); /* f32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[548]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[549]), scm__rc.d1613[617]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[550]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[551]), scm__rc.d1613[4]);
  scm__rc.d1613[618] = Scm_MakeExtendedPair(scm__rc.d1613[617], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[618];
  libvecf32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[619] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[135])),TRUE); /* f64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[556]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[557]), scm__rc.d1613[619]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[558]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[559]), scm__rc.d1613[4]);
  scm__rc.d1613[620] = Scm_MakeExtendedPair(scm__rc.d1613[619], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[620];
  libvecf64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[621] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[136])),TRUE); /* c32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[564]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[565]), scm__rc.d1613[621]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[566]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[567]), scm__rc.d1613[4]);
  scm__rc.d1613[622] = Scm_MakeExtendedPair(scm__rc.d1613[621], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[622];
  libvecc32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[623] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[137])),TRUE); /* c64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[572]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[573]), scm__rc.d1613[623]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[574]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[575]), scm__rc.d1613[4]);
  scm__rc.d1613[624] = Scm_MakeExtendedPair(scm__rc.d1613[623], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[624];
  libvecc64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[625] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[138])),TRUE); /* c128vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[580]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[581]), scm__rc.d1613[625]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[582]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[583]), scm__rc.d1613[4]);
  scm__rc.d1613[626] = Scm_MakeExtendedPair(scm__rc.d1613[625], SCM_OBJ(&scm__rc.d1614[473]), SCM_OBJ(&scm__rc.d1614[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.d1613[626];
  libvecc128vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[627] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[139])),TRUE); /* make-view-uvector */
  scm__rc.d1613[628] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[140])),TRUE); /* mem */
  scm__rc.d1613[629] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[141])),TRUE); /* klass */
  scm__rc.d1613[630] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[142])),TRUE); /* length */
  scm__rc.d1613[631] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[143])),TRUE); /* offset */
  scm__rc.d1613[632] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[144])),TRUE); /* immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[586]), scm__rc.d1613[632]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[587]), scm__rc.d1613[631]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[588]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[589]), scm__rc.d1613[630]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[590]), scm__rc.d1613[629]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[591]), scm__rc.d1613[628]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[594]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[595]), scm__rc.d1613[627]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[596]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[597]), scm__rc.d1613[4]);
  scm__rc.d1613[633] = Scm_MakeExtendedPair(scm__rc.d1613[627], SCM_OBJ(&scm__rc.d1614[591]), SCM_OBJ(&scm__rc.d1614[599]));
  scm__rc.d1613[634] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[145])),TRUE); /* <class> */
  scm__rc.d1613[635] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[146])),TRUE); /* <integer>? */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[4] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[5] = scm__rc.d1613[634];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[6] = scm__rc.d1613[635];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[636]))[9] = scm__rc.d1613[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-view-uvector")), SCM_OBJ(&libvecmake_view_uvector__STUB), 0);
  libvecmake_view_uvector__STUB.common.info = scm__rc.d1613[633];
  libvecmake_view_uvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[636]);
  scm__rc.d1613[646] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[147])),TRUE); /* bitvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[602]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[603]), scm__rc.d1613[646]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[604]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[605]), scm__rc.d1613[4]);
  scm__rc.d1613[647] = Scm_MakeExtendedPair(scm__rc.d1613[646], SCM_OBJ(&scm__rc.d1614[11]), SCM_OBJ(&scm__rc.d1614[607]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector?")), SCM_OBJ(&libvecbitvectorP__STUB), 0);
  libvecbitvectorP__STUB.common.info = scm__rc.d1613[647];
  libvecbitvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[648] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[148])),TRUE); /* bitvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[610]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[611]), scm__rc.d1613[648]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[612]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[613]), scm__rc.d1613[4]);
  scm__rc.d1613[649] = Scm_MakeExtendedPair(scm__rc.d1613[648], SCM_OBJ(&scm__rc.d1614[119]), SCM_OBJ(&scm__rc.d1614[615]));
  scm__rc.d1613[650] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[149])),TRUE); /* <bitvector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[651]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[651]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[651]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[651]))[6] = scm__rc.d1613[165];
  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.d1613[649];
  libvecbitvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[651]);
  scm__rc.d1613[658] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[150])),TRUE); /* make-bitvector */
  scm__rc.d1613[659] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[151])),TRUE); /* len */
  scm__rc.d1613[660] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[152])),TRUE); /* init */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[616]), scm__rc.d1613[660]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[617]), scm__rc.d1613[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[618]), scm__rc.d1613[659]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[621]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[622]), scm__rc.d1613[658]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[623]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[624]), scm__rc.d1613[4]);
  scm__rc.d1613[661] = Scm_MakeExtendedPair(scm__rc.d1613[658], SCM_OBJ(&scm__rc.d1614[618]), SCM_OBJ(&scm__rc.d1614[626]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[662]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[662]))[4] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[662]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[662]))[6] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[662]))[7] = scm__rc.d1613[9];
  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.d1613[661];
  libvecmake_bitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[662]);
  scm__rc.d1613[670] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[153])),TRUE); /* bitvector */
  scm__rc.d1613[671] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[154])),TRUE); /* bits */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[627]), scm__rc.d1613[671]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[628]), scm__rc.d1613[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[631]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[632]), scm__rc.d1613[670]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[633]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[634]), scm__rc.d1613[4]);
  scm__rc.d1613[672] = Scm_MakeExtendedPair(scm__rc.d1613[670], SCM_OBJ(&scm__rc.d1614[628]), SCM_OBJ(&scm__rc.d1614[636]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[673]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[673]))[4] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[673]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[673]))[6] = scm__rc.d1613[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector")), SCM_OBJ(&libvecbitvector__STUB), 0);
  libvecbitvector__STUB.common.info = scm__rc.d1613[672];
  libvecbitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[673]);
  scm__rc.d1613[680] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[155])),TRUE); /* list->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[639]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[640]), scm__rc.d1613[680]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[641]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[642]), scm__rc.d1613[4]);
  scm__rc.d1613[681] = Scm_MakeExtendedPair(scm__rc.d1613[680], SCM_OBJ(&scm__rc.d1614[627]), SCM_OBJ(&scm__rc.d1614[644]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[682]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[682]))[4] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[682]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[682]))[6] = scm__rc.d1613[9];
  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.d1613[681];
  libveclist_TObitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[682]);
  scm__rc.d1613[689] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[156])),TRUE); /* string->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[645]), scm__rc.d1613[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[648]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[649]), scm__rc.d1613[689]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[650]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[651]), scm__rc.d1613[4]);
  scm__rc.d1613[690] = Scm_MakeExtendedPair(scm__rc.d1613[689], SCM_OBJ(&scm__rc.d1614[645]), SCM_OBJ(&scm__rc.d1614[653]));
  scm__rc.d1613[691] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[157])),TRUE); /* <string> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[692]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[692]))[4] = scm__rc.d1613[691];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[692]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[692]))[6] = scm__rc.d1613[9];
  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.d1613[690];
  libvecstring_TObitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[692]);
  scm__rc.d1613[699] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[158])),TRUE); /* bitvector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[656]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[657]), scm__rc.d1613[699]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[658]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[659]), scm__rc.d1613[4]);
  scm__rc.d1613[700] = Scm_MakeExtendedPair(scm__rc.d1613[699], SCM_OBJ(&scm__rc.d1614[119]), SCM_OBJ(&scm__rc.d1614[661]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[701]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[701]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[701]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[701]))[6] = scm__rc.d1613[9];
  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.d1613[700];
  libvecbitvector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[701]);
  scm__rc.d1613[708] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[159])),TRUE); /* bit->integer */
  scm__rc.d1613[709] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[160])),TRUE); /* bit */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[662]), scm__rc.d1613[709]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[665]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[666]), scm__rc.d1613[708]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[667]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[668]), scm__rc.d1613[4]);
  scm__rc.d1613[710] = Scm_MakeExtendedPair(scm__rc.d1613[708], SCM_OBJ(&scm__rc.d1614[662]), SCM_OBJ(&scm__rc.d1614[670]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[711]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[711]))[4] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[711]))[5] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[711]))[6] = scm__rc.d1613[165];
  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.d1613[710];
  libvecbit_TOinteger__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[711]);
  scm__rc.d1613[718] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[161])),TRUE); /* bit->boolean */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[673]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[674]), scm__rc.d1613[718]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[675]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[676]), scm__rc.d1613[4]);
  scm__rc.d1613[719] = Scm_MakeExtendedPair(scm__rc.d1613[718], SCM_OBJ(&scm__rc.d1614[662]), SCM_OBJ(&scm__rc.d1614[678]));
  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.d1613[719];
  libvecbit_TOboolean__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[591]);
  scm__rc.d1613[720] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[162])),TRUE); /* bitvector-set! */
  scm__rc.d1613[721] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[163])),TRUE); /* b */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[679]), scm__rc.d1613[721]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[680]), scm__rc.d1613[209]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[681]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[684]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[685]), scm__rc.d1613[720]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[686]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[687]), scm__rc.d1613[4]);
  scm__rc.d1613[722] = Scm_MakeExtendedPair(scm__rc.d1613[720], SCM_OBJ(&scm__rc.d1614[681]), SCM_OBJ(&scm__rc.d1614[689]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[6] = scm__rc.d1613[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[723]))[8] = scm__rc.d1613[57];
  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.d1613[722];
  libvecbitvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[723]);
  scm__rc.d1613[732] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[164])),TRUE); /* bitvector-ref/int */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[692]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[693]), scm__rc.d1613[732]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[694]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[695]), scm__rc.d1613[4]);
  scm__rc.d1613[733] = Scm_MakeExtendedPair(scm__rc.d1613[732], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[697]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[6] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[7] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[734]))[8] = scm__rc.d1613[9];
  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.d1613[733];
  libvecbitvector_ref_2fint__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[734]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fint__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1613[743] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[165])),TRUE); /* bitvector-ref/bool */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[700]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[701]), scm__rc.d1613[743]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[702]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[703]), scm__rc.d1613[4]);
  scm__rc.d1613[744] = Scm_MakeExtendedPair(scm__rc.d1613[743], SCM_OBJ(&scm__rc.d1614[216]), SCM_OBJ(&scm__rc.d1614[705]));
  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.d1613[744];
  libvecbitvector_ref_2fbool__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[734]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fbool__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1613[745] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[166])),TRUE); /* bitvector-copy */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[706]), scm__rc.d1613[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[709]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[710]), scm__rc.d1613[745]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[711]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[712]), scm__rc.d1613[4]);
  scm__rc.d1613[746] = Scm_MakeExtendedPair(scm__rc.d1613[745], SCM_OBJ(&scm__rc.d1614[706]), SCM_OBJ(&scm__rc.d1614[714]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[747]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[747]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[747]))[5] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[747]))[6] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[747]))[7] = scm__rc.d1613[9];
  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.d1613[746];
  libvecbitvector_copy__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[747]);
  scm__rc.d1613[755] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[167])),TRUE); /* bitvector-copy! */
  scm__rc.d1613[756] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[168])),TRUE); /* dest */
  scm__rc.d1613[757] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[169])),TRUE); /* dstart */
  scm__rc.d1613[758] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1612[170])),TRUE); /* src */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[715]), scm__rc.d1613[758]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[716]), scm__rc.d1613[757]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[717]), scm__rc.d1613[756]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[720]), scm__rc.d1613[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[721]), scm__rc.d1613[755]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[722]), scm__rc.d1613[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1614[723]), scm__rc.d1613[4]);
  scm__rc.d1613[759] = Scm_MakeExtendedPair(scm__rc.d1613[755], SCM_OBJ(&scm__rc.d1614[717]), SCM_OBJ(&scm__rc.d1614[725]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[3] = scm__rc.d1613[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[4] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[5] = scm__rc.d1613[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[6] = scm__rc.d1613[650];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[7] = scm__rc.d1613[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[8] = scm__rc.d1613[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1613[760]))[9] = scm__rc.d1613[9];
  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.d1613[759];
  libvecbitvector_copyX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1613[760]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  Scm_VMExecuteToplevels(toplevels);
}
