/* Generated automatically from libvec.scm.  DO NOT EDIT */
#define LIBGAUCHE_BODY 
#include <gauche.h>
#include <gauche/code.h>
#include "gauche/priv/configP.h"
#include "gauche/vminsn.h"
#include "gauche/priv/vectorP.h"
#include "gauche/priv/bytesP.h"
#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);

/* debug info */
static unsigned char uvector__00001[] = {
 0u, 3u, 133u, 134u, 8u, 0u, 8u, 6u, 2u, 14u, 144u, 15u, 1u, 36u,
129u, 1u, 192u, 48u, 33u, 34u, 5u, 16u, 52u, 15u, 0u, 146u, 72u, 225u,
65u, 129u, 48u, 67u, 35u, 132u, 134u, 4u, 194u, 88u, 142u, 16u, 24u,
19u, 10u, 50u, 56u, 56u, 96u, 72u, 4u, 142u, 12u, 24u, 18u, 7u, 35u,
129u, 134u, 4u, 193u, 188u, 142u, 4u, 24u, 18u, 4u, 35u, 128u, 134u,
4u, 192u, 112u, 142u, 0u, 24u, 18u, 2u, 33u, 136u, 48u, 49u, 168u,
76u, 7u, 9u, 32u,};
/* debug info of vector->string */
static unsigned char uvector__00002[] = {
 0u, 3u, 186u, 134u, 8u, 32u, 57u, 40u, 128u, 0u, 128u, 96u, 32u,
233u, 0u, 240u, 18u, 72u, 16u, 28u, 3u, 2u, 18u, 32u, 81u, 3u, 64u,
240u, 9u, 36u, 146u, 59u, 152u, 96u, 99u, 80u, 152u, 28u, 18u, 59u,
136u, 96u, 103u, 16u, 76u, 20u, 24u, 68u, 23u, 2u, 18u, 73u, 29u,
188u, 48u, 65u, 129u, 132u, 55u, 112u, 8u, 52u, 144u, 251u, 5u, 4u,
197u, 168u, 146u, 59u, 112u, 96u, 76u, 123u, 200u, 236u, 193u, 129u,
49u, 177u, 35u, 178u, 6u, 4u, 197u, 32u, 142u, 188u, 24u, 19u, 23u,
82u, 58u, 232u, 96u, 72u, 16u, 142u, 182u, 24u, 19u, 23u, 82u, 58u,
200u, 96u, 103u, 16u, 76u, 20u, 24u, 68u, 23u, 1u, 18u, 73u, 29u, 92u,
48u, 65u, 129u, 132u, 55u, 112u, 8u, 52u, 144u, 251u, 5u, 4u, 205u,
168u, 146u, 58u, 176u, 96u, 76u, 251u, 200u, 233u, 193u, 129u, 51u,
177u, 35u, 166u, 6u, 4u, 205u, 32u, 142u, 140u, 24u, 19u, 55u, 82u,
58u, 40u, 96u, 72u, 8u, 142u, 134u, 24u, 19u, 55u, 82u, 58u, 8u, 96u,
131u, 131u, 12u, 14u, 96u, 248u, 28u, 145u, 208u, 3u, 2u, 64u, 228u,
115u, 224u, 192u, 144u, 121u, 28u, 232u, 48u, 38u, 133u, 68u, 17u,
205u, 195u, 2u, 64u, 228u, 115u, 80u, 192u, 202u, 33u, 8u, 30u, 15u,
48u, 56u, 77u, 10u, 136u, 36u, 115u, 48u, 192u, 154u, 25u, 52u, 71u,
49u, 12u, 9u, 7u, 145u, 204u, 3u, 2u, 64u, 228u, 114u, 224u, 192u,
154u, 25u, 52u, 71u, 44u, 12u, 12u, 240u, 136u, 97u, 12u, 98u, 7u,
132u, 132u, 5u, 192u, 8u, 129u, 4u, 39u, 3u, 146u, 68u, 41u, 3u, 193u,
228u, 66u, 161u, 51u, 117u, 34u, 21u, 9u, 139u, 169u, 9u, 128u, 225u,
36u, 142u, 76u, 24u, 19u, 67u, 182u, 200u, 228u, 65u, 129u, 174u, 22u,
36u, 114u, 16u, 192u, 144u, 177u, 28u, 128u, 48u, 50u, 1u, 2u, 6u,
80u, 215u, 11u, 144u, 154u, 31u, 138u, 26u, 33u, 114u, 72u, 133u,
131u, 40u, 107u, 133u, 200u, 97u, 82u, 26u, 161u, 114u, 73u, 13u,
225u, 52u, 70u, 120u, 38u, 135u, 109u, 144u, 200u, 169u, 162u, 0u,
68u, 142u, 62u, 24u, 19u, 68u, 244u, 136u, 227u, 65u, 129u, 52u, 78u,
32u, 142u, 50u, 24u, 18u, 23u, 35u, 139u, 134u, 4u, 209u, 49u, 34u,
56u, 160u, 96u, 77u, 15u, 197u, 35u, 137u, 134u, 4u, 129u, 200u, 226u,
33u, 129u, 52u, 74u, 124u, 142u, 32u, 24u, 18u, 23u, 35u, 135u, 134u,
6u, 64u, 32u, 32u, 202u, 26u, 225u, 131u, 192u, 3u, 68u, 48u, 73u,
16u, 184u, 101u, 13u, 112u, 193u, 12u, 42u, 67u, 84u, 48u, 73u, 33u,
52u, 73u, 100u, 145u, 195u, 131u, 2u, 104u, 204u, 41u, 28u, 36u, 48u,
38u, 140u, 141u, 145u, 194u, 3u, 2u, 67u, 36u, 112u, 96u, 192u, 154u,
49u, 138u, 71u, 1u, 12u, 9u, 163u, 16u, 68u, 112u, 0u, 192u, 144u,
201u, 12u, 65u, 129u, 52u, 60u, 108u, 144u,};
/* debug info of %toplevel */
static unsigned char uvector__00003[] = {
 0u, 3u, 134u, 6u, 8u, 106u, 27u, 16u, 228u, 15u, 9u, 8u, 11u, 128u,
17u, 2u, 8u, 78u, 7u, 36u, 136u, 82u, 7u, 131u, 200u, 133u, 68u, 23u,
1u, 18u, 33u, 81u, 5u, 192u, 132u, 136u, 32u, 57u, 40u, 128u, 0u,
128u, 96u, 32u, 233u, 0u, 240u, 18u, 72u, 16u, 28u, 3u, 2u, 18u, 32u,
81u, 3u, 64u, 240u, 9u, 36u, 146u, 71u, 9u, 12u, 12u, 97u, 48u, 61u,
76u, 38u, 72u, 224u, 225u, 129u, 48u, 28u, 35u, 129u, 6u, 4u, 192u,
112u, 142u, 0u, 24u, 19u, 1u, 194u, 64u,};
/* debug info of string->vector */
static unsigned char uvector__00004[] = {
 0u, 3u, 194u, 40u, 24u, 18u, 7u, 35u, 194u, 34u, 24u, 32u, 0u, 33u,
216u, 116u, 67u, 208u, 252u, 58u, 72u, 128u, 120u, 0u, 116u, 128u,
120u, 9u, 36u, 8u, 130u, 29u, 136u, 73u, 17u, 20u, 15u, 0u, 136u,
142u, 31u, 135u, 73u, 36u, 120u, 68u, 3u, 2u, 97u, 112u, 71u, 132u,
52u, 48u, 38u, 15u, 36u, 120u, 67u, 3u, 2u, 67u, 164u, 120u, 66u,
195u, 2u, 67u, 228u, 120u, 66u, 67u, 2u, 96u, 242u, 71u, 132u, 32u,
48u, 38u, 33u, 100u, 120u, 65u, 131u, 2u, 98u, 88u, 71u, 132u, 20u,
48u, 36u, 58u, 71u, 132u, 16u, 48u, 36u, 62u, 71u, 132u, 8u, 48u, 38u,
37u, 132u, 120u, 64u, 67u, 2u, 64u, 36u, 120u, 64u, 3u, 2u, 64u, 228u,
119u, 208u, 192u, 152u, 114u, 17u, 223u, 3u, 2u, 68u, 36u, 119u, 176u,
192u, 144u, 233u, 29u, 228u, 48u, 38u, 28u, 132u, 119u, 128u, 192u,
152u, 41u, 17u, 221u, 131u, 2u, 67u, 164u, 119u, 64u, 192u, 152u, 41u,
17u, 220u, 195u, 3u, 32u, 16u, 56u, 137u, 34u, 82u, 72u, 76u, 20u,
160u, 114u, 71u, 113u, 12u, 9u, 161u, 67u, 4u, 119u, 0u, 192u, 145u,
41u, 29u, 184u, 48u, 38u, 133u, 12u, 17u, 218u, 131u, 3u, 60u, 76u,
31u, 96u, 40u, 16u, 146u, 59u, 72u, 96u, 77u, 12u, 26u, 35u, 180u, 6u,
4u, 129u, 8u, 236u, 225u, 129u, 32u, 34u, 59u, 24u, 96u, 77u, 12u, 5u,
35u, 176u, 134u, 8u, 158u, 37u, 224u, 4u, 142u, 186u, 24u, 34u, 136u,
126u, 29u, 136u, 73u, 29u, 112u, 48u, 36u, 66u, 71u, 91u, 12u, 9u,
14u, 145u, 214u, 131u, 2u, 67u, 228u, 117u, 128u, 192u, 154u, 29u,
36u, 71u, 85u, 12u, 17u, 76u, 63u, 2u, 18u, 58u, 160u, 96u, 72u, 16u,
142u, 166u, 24u, 18u, 31u, 35u, 168u, 134u, 4u, 209u, 8u, 178u, 58u,
112u, 96u, 138u, 97u, 248u, 8u, 145u, 211u, 67u, 2u, 64u, 68u, 116u,
192u, 192u, 144u, 249u, 29u, 40u, 48u, 38u, 137u, 8u, 17u, 210u, 3u,
4u, 28u, 24u, 97u, 243u, 21u, 64u, 228u, 142u, 142u, 24u, 18u, 31u,
35u, 162u, 134u, 4u, 138u, 136u, 232u, 33u, 129u, 52u, 78u, 84u, 142u,
124u, 24u, 18u, 31u, 35u, 158u, 6u, 6u, 81u, 8u, 64u, 241u, 81u, 129u,
194u, 104u, 156u, 169u, 35u, 157u, 6u, 4u, 209u, 92u, 114u, 57u, 192u,
96u, 72u, 168u, 142u, 110u, 24u, 18u, 31u, 35u, 154u, 134u, 4u, 209u,
92u, 114u, 57u, 152u, 96u, 103u, 132u, 67u, 8u, 99u, 16u, 252u, 36u,
32u, 33u, 21u, 195u, 228u, 136u, 16u, 69u, 144u, 249u, 36u, 66u, 144u,
252u, 84u, 68u, 90u, 4u, 58u, 19u, 68u, 132u, 8u, 136u, 66u, 104u,
132u, 89u, 17u, 40u, 77u, 14u, 146u, 36u, 60u, 4u, 208u, 225u, 64u,
154u, 24u, 10u, 68u, 93u, 3u, 132u, 208u, 161u, 128u, 152u, 41u, 18u,
73u, 35u, 150u, 134u, 4u, 209u, 128u, 130u, 57u, 72u, 96u, 107u, 139u,
201u, 28u, 160u, 48u, 36u, 94u, 71u, 39u, 12u, 12u, 128u, 64u, 129u,
148u, 53u, 198u, 4u, 38u, 140u, 128u, 134u, 136u, 192u, 146u, 34u,
240u, 202u, 26u, 227u, 2u, 24u, 84u, 134u, 168u, 192u, 146u, 67u,
120u, 77u, 28u, 128u, 9u, 163u, 1u, 4u, 50u, 42u, 104u, 200u, 241u,
35u, 147u, 6u, 4u, 209u, 233u, 66u, 57u, 8u, 96u, 77u, 30u, 74u, 35u,
144u, 6u, 4u, 140u, 8u, 227u, 193u, 129u, 52u, 119u, 80u, 142u, 52u,
24u, 19u, 70u, 64u, 72u, 227u, 33u, 129u, 33u, 242u, 56u, 184u, 96u,
77u, 25u, 1u, 35u, 138u, 134u, 4u, 209u, 216u, 18u, 56u, 160u, 96u,
72u, 192u, 142u, 38u, 24u, 25u, 0u, 128u, 131u, 40u, 107u, 140u, 72u,
77u, 24u, 151u, 13u, 17u, 137u, 36u, 70u, 1u, 148u, 53u, 198u, 36u,
48u, 169u, 13u, 81u, 137u, 36u, 132u, 209u, 209u, 178u, 71u, 18u, 12u,
9u, 164u, 153u, 100u, 112u, 208u, 192u, 154u, 73u, 2u, 71u, 12u, 12u,
9u, 25u, 17u, 194u, 131u, 2u, 105u, 32u, 89u, 28u, 24u, 48u, 38u,
140u, 75u, 145u, 193u, 67u, 2u, 67u, 228u, 112u, 48u, 192u, 154u, 49u,
46u, 71u, 1u, 12u, 9u, 164u, 115u, 4u, 112u, 0u, 192u, 145u, 145u,
12u, 65u, 129u, 52u, 97u, 32u, 144u,};
/* debug info of %toplevel */
static unsigned char uvector__00005[] = {
 0u, 3u, 134u, 6u, 8u, 106u, 27u, 17u, 156u, 63u, 9u, 8u, 8u, 69u,
112u, 249u, 34u, 4u, 17u, 100u, 62u, 73u, 16u, 164u, 63u, 21u, 17u,
22u, 129u, 14u, 136u, 166u, 31u, 128u, 137u, 17u, 8u, 138u, 97u, 248u,
16u, 145u, 18u, 136u, 162u, 31u, 135u, 98u, 18u, 72u, 120u, 17u, 60u,
75u, 192u, 8u, 103u, 137u, 131u, 236u, 5u, 2u, 18u, 68u, 93u, 3u,
136u, 146u, 37u, 34u, 0u, 2u, 29u, 135u, 68u, 61u, 15u, 195u, 164u,
136u, 7u, 128u, 7u, 72u, 7u, 128u, 146u, 64u, 136u, 33u, 216u, 132u,
145u, 17u, 64u, 240u, 8u, 136u, 225u, 248u, 116u, 146u, 73u, 35u,
132u, 134u, 6u, 48u, 152u, 30u, 166u, 21u, 4u, 112u, 112u, 192u, 152u,
14u, 17u, 192u, 131u, 2u, 96u, 56u, 71u, 0u, 12u, 9u, 128u, 225u, 32u,};
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 libvecmake_s8vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_s8vector__STUB, 1, 2,SCM_FALSE,libvecmake_s8vector, NULL, NULL);

static ScmObj libvecmake_u8vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_u8vector__STUB, 1, 2,SCM_FALSE,libvecmake_u8vector, NULL, NULL);

static ScmObj libvecmake_s16vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_s16vector__STUB, 1, 2,SCM_FALSE,libvecmake_s16vector, NULL, NULL);

static ScmObj libvecmake_u16vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_u16vector__STUB, 1, 2,SCM_FALSE,libvecmake_u16vector, NULL, NULL);

static ScmObj libvecmake_s32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_s32vector__STUB, 1, 2,SCM_FALSE,libvecmake_s32vector, NULL, NULL);

static ScmObj libvecmake_u32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_u32vector__STUB, 1, 2,SCM_FALSE,libvecmake_u32vector, NULL, NULL);

static ScmObj libvecmake_s64vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_s64vector__STUB, 1, 2,SCM_FALSE,libvecmake_s64vector, NULL, NULL);

static ScmObj libvecmake_u64vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_u64vector__STUB, 1, 2,SCM_FALSE,libvecmake_u64vector, NULL, NULL);

static ScmObj libvecmake_f16vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_f16vector__STUB, 1, 2,SCM_FALSE,libvecmake_f16vector, NULL, NULL);

static ScmObj libvecmake_f32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_f32vector__STUB, 1, 2,SCM_FALSE,libvecmake_f32vector, NULL, NULL);

static ScmObj libvecmake_f64vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_f64vector__STUB, 1, 2,SCM_FALSE,libvecmake_f64vector, NULL, NULL);

static ScmObj libvecmake_c32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_c32vector__STUB, 1, 2,SCM_FALSE,libvecmake_c32vector, NULL, NULL);

static ScmObj libvecmake_c64vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_c64vector__STUB, 1, 2,SCM_FALSE,libvecmake_c64vector, NULL, NULL);

static ScmObj libvecmake_c128vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecmake_c128vector__STUB, 1, 2,SCM_FALSE,libvecmake_c128vector, 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 string_TObytevector(ScmClass* klass,ScmString* s,ScmSmallInt start,ScmSmallInt end,int immutable);
static ScmObj libvecstring_TOs8vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecstring_TOs8vector__STUB, 1, 4,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecstring_TOs8vector, NULL, NULL);

static ScmObj libvecstring_TOu8vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecstring_TOu8vector__STUB, 1, 4,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecstring_TOu8vector, NULL, NULL);

static ScmObj string_TObytevectorX(ScmUVector* v,ScmSmallInt tstart,ScmString* s,ScmSmallInt start,ScmSmallInt end);
static ScmObj libvecstring_TOs8vectorX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecstring_TOs8vectorX__STUB, 3, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecstring_TOs8vectorX, NULL, NULL);

static ScmObj libvecstring_TOu8vectorX(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecstring_TOu8vectorX__STUB, 3, 3,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecstring_TOu8vectorX, NULL, NULL);

static ScmObj bytevector_TOstring(ScmUVector* v,ScmSmallInt start,ScmSmallInt end,ScmObj term);
static ScmObj libvecs8vector_TOstring(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs8vector_TOstring__STUB, 1, 4,SCM_FALSE,libvecs8vector_TOstring, NULL, NULL);

static ScmObj libvecu8vector_TOstring(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu8vector_TOstring__STUB, 1, 4,SCM_FALSE,libvecu8vector_TOstring, NULL, NULL);

static ScmObj string_TOwordvector(ScmClass* klass,ScmString* s,ScmSmallInt start,ScmSmallInt end,ScmObj endian);
static ScmObj libvecstring_TOs32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecstring_TOs32vector__STUB, 1, 4,SCM_FALSE,libvecstring_TOs32vector, NULL, NULL);

static ScmObj libvecstring_TOu32vector(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecstring_TOu32vector__STUB, 1, 4,SCM_FALSE,libvecstring_TOu32vector, NULL, NULL);

static ScmObj string_TOwordvectorX(ScmUVector* v,ScmSmallInt tstart,ScmString* s,ScmSmallInt start,ScmSmallInt end,ScmObj endian);
static ScmObj libvecstring_TOs32vectorX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecstring_TOs32vectorX__STUB, 3, 4,SCM_FALSE,libvecstring_TOs32vectorX, NULL, NULL);

static ScmObj libvecstring_TOu32vectorX(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecstring_TOu32vectorX__STUB, 3, 4,SCM_FALSE,libvecstring_TOu32vectorX, NULL, NULL);

static ScmObj wordvector_TOstring(ScmUVector* v,ScmSmallInt start,ScmSmallInt end,ScmObj term,ScmObj endian);
static ScmObj libvecs32vector_TOstring(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecs32vector_TOstring__STUB, 1, 5,SCM_FALSE,libvecs32vector_TOstring, NULL, NULL);

static ScmObj libvecu32vector_TOstring(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecu32vector_TOstring__STUB, 1, 5,SCM_FALSE,libvecu32vector_TOstring, 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 libvecbitvector_any_valueP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvector_any_valueP__STUB, 2, 3,SCM_FALSE,libvecbitvector_any_valueP, NULL, NULL);

static ScmObj libvecbitvector_every_valueP(ScmObj*, int, void*);
static SCM_DEFINE_SUBR(libvecbitvector_every_valueP__STUB, 2, 3,SCM_FALSE,libvecbitvector_every_valueP, 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);

static ScmObj libvecbitvector_word_bits(ScmObj*, int, void*);
static SCM_DEFINE_SUBRX(libvecbitvector_word_bits__STUB, 0, 0,0, SCM_FALSE,SCM_SUBR_IMMEDIATE_ARG, libvecbitvector_word_bits, NULL, NULL);

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

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





















static ScmObj SCM_debug_info_const_vector();
#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 d1944[245];
} scm__sc SCM_UNUSED = {
  {   /* ScmString d1944 */
      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("%expression-name-mark-key", 25, 25),
      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("assume-type", 11, 11),
      SCM_STRING_CONST_INITIALIZER("assume", 6, 6),
      SCM_STRING_CONST_INITIALIZER("exact-integer\077", 14, 14),
      SCM_STRING_CONST_INITIALIZER("with-output-to-string", 21, 21),
      SCM_STRING_CONST_INITIALIZER("^", 1, 1),
      SCM_STRING_CONST_INITIALIZER("do", 2, 2),
      SCM_STRING_CONST_INITIALIZER("i", 1, 1),
      SCM_STRING_CONST_INITIALIZER("+", 1, 1),
      SCM_STRING_CONST_INITIALIZER(">=", 2, 2),
      SCM_STRING_CONST_INITIALIZER("write-char", 10, 10),
      SCM_STRING_CONST_INITIALIZER("error", 5, 5),
      SCM_STRING_CONST_INITIALIZER("of-type\077", 8, 8),
      SCM_STRING_CONST_INITIALIZER("type-error", 10, 10),
      SCM_STRING_CONST_INITIALIZER("Invalid assumption: ~s", 22, 22),
      SCM_STRING_CONST_INITIALIZER("format-internal", 15, 15),
      SCM_STRING_CONST_INITIALIZER("gauche.format", 13, 13),
      SCM_STRING_CONST_INITIALIZER("%toplevel", 9, 9),
      SCM_STRING_CONST_INITIALIZER("string->vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("string-cursor-start", 19, 19),
      SCM_STRING_CONST_INITIALIZER("string-cursor-end", 17, 17),
      SCM_STRING_CONST_INITIALIZER("<string>", 8, 8),
      SCM_STRING_CONST_INITIALIZER("let*", 4, 4),
      SCM_STRING_CONST_INITIALIZER("ss", 2, 2),
      SCM_STRING_CONST_INITIALIZER("string-index->cursor", 20, 20),
      SCM_STRING_CONST_INITIALIZER("ee", 2, 2),
      SCM_STRING_CONST_INITIALIZER("size", 4, 4),
      SCM_STRING_CONST_INITIALIZER("string-cursor-diff", 18, 18),
      SCM_STRING_CONST_INITIALIZER("when", 4, 4),
      SCM_STRING_CONST_INITIALIZER("<", 1, 1),
      SCM_STRING_CONST_INITIALIZER("End point precedes start point", 30, 30),
      SCM_STRING_CONST_INITIALIZER("rlet1", 5, 5),
      SCM_STRING_CONST_INITIALIZER("make-vector", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string-cursor-next", 18, 18),
      SCM_STRING_CONST_INITIALIZER("string-cursor>=\077", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string-ref", 10, 10),
      SCM_STRING_CONST_INITIALIZER("make-weak-vector", 16, 16),
      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("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("SCM_UVECTOR_GENERIC", 19, 19),
      SCM_STRING_CONST_INITIALIZER("make-s8vector", 13, 13),
      SCM_STRING_CONST_INITIALIZER("length", 6, 6),
      SCM_STRING_CONST_INITIALIZER("make-u8vector", 13, 13),
      SCM_STRING_CONST_INITIALIZER("make-s16vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-u16vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-s32vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-u32vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-s64vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-u64vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-f16vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-f32vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-f64vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-c32vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-c64vector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("make-c128vector", 15, 15),
      SCM_STRING_CONST_INITIALIZER("s8vector-set!", 13, 13),
      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("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("string->s8vector", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string->u8vector", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string->s8vector!", 17, 17),
      SCM_STRING_CONST_INITIALIZER("string->u8vector!", 17, 17),
      SCM_STRING_CONST_INITIALIZER("s8vector->string", 16, 16),
      SCM_STRING_CONST_INITIALIZER("terminator", 10, 10),
      SCM_STRING_CONST_INITIALIZER("u8vector->string", 16, 16),
      SCM_STRING_CONST_INITIALIZER("string->s32vector", 17, 17),
      SCM_STRING_CONST_INITIALIZER("endian", 6, 6),
      SCM_STRING_CONST_INITIALIZER("string->u32vector", 17, 17),
      SCM_STRING_CONST_INITIALIZER("string->s32vector!", 18, 18),
      SCM_STRING_CONST_INITIALIZER("string->u32vector!", 18, 18),
      SCM_STRING_CONST_INITIALIZER("s32vector->string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("u32vector->string", 17, 17),
      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("bitvector-any-value\077", 20, 20),
      SCM_STRING_CONST_INITIALIZER("bit", 3, 3),
      SCM_STRING_CONST_INITIALIZER("bitvector-every-value\077", 22, 22),
      SCM_STRING_CONST_INITIALIZER("make-bitvector", 14, 14),
      SCM_STRING_CONST_INITIALIZER("len", 3, 3),
      SCM_STRING_CONST_INITIALIZER("init", 4, 4),
      SCM_STRING_CONST_INITIALIZER("bitvector", 9, 9),
      SCM_STRING_CONST_INITIALIZER("bits", 4, 4),
      SCM_STRING_CONST_INITIALIZER("list->bitvector", 15, 15),
      SCM_STRING_CONST_INITIALIZER("string->bitvector", 17, 17),
      SCM_STRING_CONST_INITIALIZER("bitvector->string", 17, 17),
      SCM_STRING_CONST_INITIALIZER("bit->integer", 12, 12),
      SCM_STRING_CONST_INITIALIZER("<int>", 5, 5),
      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),
      SCM_STRING_CONST_INITIALIZER("bitvector-word-bits", 19, 19),
      SCM_STRING_CONST_INITIALIZER("bitvector->uvector/shared", 25, 25),
      SCM_STRING_CONST_INITIALIZER("bv", 2, 2),
      SCM_STRING_CONST_INITIALIZER("uvector->bitvector/shared", 25, 25),
      SCM_STRING_CONST_INITIALIZER("uv", 2, 2),
      SCM_STRING_CONST_INITIALIZER("format", 6, 6),
      SCM_STRING_CONST_INITIALIZER("G1950", 5, 5),
      SCM_STRING_CONST_INITIALIZER("G1952", 5, 5),
      SCM_STRING_CONST_INITIALIZER("G1951", 5, 5),
      SCM_STRING_CONST_INITIALIZER("rest1949", 8, 8),
      SCM_STRING_CONST_INITIALIZER("define-in-module", 16, 16),
      SCM_STRING_CONST_INITIALIZER("G1957", 5, 5),
      SCM_STRING_CONST_INITIALIZER("G1959", 5, 5),
      SCM_STRING_CONST_INITIALIZER("G1958", 5, 5),
      SCM_STRING_CONST_INITIALIZER("rest1956", 8, 8),
  },
};
static struct scm__rcRec {
  ScmUVector d1955[5];
  ScmCompiledCode d1954[5];
  ScmWord d1953[314];
  ScmPair d1946[1112] SCM_ALIGN_PAIR;
  ScmObj d1945[1054];
} scm__rc SCM_UNUSED = {
  {   /* ScmUVector d1955 */
      SCM_UVECTOR_INITIALIZER(Scm_U8VectorClass, 85, uvector__00001, 0, NULL),
      SCM_UVECTOR_INITIALIZER(Scm_U8VectorClass, 461, uvector__00002, 0, NULL),
      SCM_UVECTOR_INITIALIZER(Scm_U8VectorClass, 90, uvector__00003, 0, NULL),
      SCM_UVECTOR_INITIALIZER(Scm_U8VectorClass, 660, uvector__00004, 0, NULL),
      SCM_UVECTOR_INITIALIZER(Scm_U8VectorClass, 131, uvector__00005, 0, NULL),
  },
  {   /* ScmCompiledCode d1954 */
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* #f */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1953[0])), 15,
            15, 0, 0, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1946[189]),
            SCM_OBJ(&scm__rc.d1954[1]), SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* vector->string */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1953[15])), 120,
            29, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1946[194]),
            SCM_OBJ(&scm__rc.d1954[2]), SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* %toplevel */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1953[135])), 15,
            10, 0, 0, SCM_FALSE, SCM_NIL, SCM_FALSE,
            SCM_FALSE, SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* string->vector */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1953[150])), 149,
            52, 1, 1, SCM_FALSE, SCM_NIL, SCM_OBJ(&scm__rc.d1946[274]),
            SCM_OBJ(&scm__rc.d1954[4]), SCM_FALSE),
        SCM_COMPILED_CODE_CONST_INITIALIZER(  /* %toplevel */
            (ScmWord*)(SCM_OBJ(&scm__rc.d1953[299])), 15,
            10, 0, 0, SCM_FALSE, SCM_NIL, SCM_FALSE,
            SCM_FALSE, SCM_FALSE),
  },
  {   /* ScmWord d1953 */
    /* (vector->string #f) */
    0x0000004d    /*   0 (LREF11-PUSH) */,
    0x00001017    /*   1 (LOCAL-ENV 1) */,
    0x00000042    /*   2 (LREF11) */,
    0x0000002c    /*   3 (LREF-VAL0-BNGE 0 0) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[0]) + 6),
    0x00000014    /*   5 (RET) */,
    0x00403047    /*   6 (LREF-PUSH 3 1) */,
    0x0000003d    /*   7 (LREF0) */,
    0x000000a8    /*   8 (VEC-REF) */,
    0x000010dd    /*   9 (WRITE-CHAR 1) */,
    0x000010c7    /*  10 (LREF0-NUMADDI-PUSH 1) */,
    0x0000101b    /*  11 (LOCAL-ENV-JUMP 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[0]) + 2),
    0x00000014    /*  13 (RET) */,
    0x00000014    /*  14 (RET) */,
    /* vector->string */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 6),
    0x00000002    /*   3 (CONSTI 0) */,
    0x00000013    /*   4 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 7),
    0x0000006a    /*   6 (LREF0-CAR) */,
    0x0000000d    /*   7 (PUSH) */,
    0x0000003d    /*   8 (LREF0) */,
    0x00000022    /*   9 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 14),
    0x00000003    /*  11 (CONSTN) */,
    0x00000013    /*  12 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 15),
    0x00000076    /*  14 (LREF0-CDR) */,
    0x00002018    /*  15 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  16 (LREF0) */,
    0x00000022    /*  17 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 23),
    0x00000042    /*  19 (LREF11) */,
    0x000000a7    /*  20 (VEC-LEN) */,
    0x00000013    /*  21 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 24),
    0x0000006a    /*  23 (LREF0-CAR) */,
    0x0000000d    /*  24 (PUSH) */,
    0x0000003d    /*  25 (LREF0) */,
    0x00000022    /*  26 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 31),
    0x00000003    /*  28 (CONSTN) */,
    0x00000013    /*  29 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 32),
    0x00000076    /*  31 (LREF0-CDR) */,
    0x00002018    /*  32 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  33 (LREF0) */,
    0x00000022    /*  34 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 38),
    0x00000013    /*  36 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 46),
    0x0000200e    /*  38 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 46),
    0x00000006    /*  40 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1944[46])) /* "too many arguments for" */,
    0x00000006    /*  42 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[176])) /* (lambda (v :optional (start 0) (end (vector-length v))) (assume-type v <vector>) (assume (exact-integer? start)) (assume (exact-integer? end)) (with-output-to-string (^ () (do ((i start (+ i 1))) ((>= i end)) (write-char (vector-ref v i)))))) */,
    0x0000205f    /*  44 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* error */,
    0x0000200e    /*  46 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 53),
    0x00000050    /*  48 (LREF21-PUSH) */,
    0x0000005e    /*  49 (GREF-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* <vector> */,
    0x0000205f    /*  51 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* of-type? */,
    0x0000001e    /*  53 (BF) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 58),
    0x00000045    /*  55 (LREF21) */,
    0x00000013    /*  56 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 67),
    0x0000300e    /*  58 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 67),
    0x00000006    /*  60 (CONST-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* v */,
    0x0000005e    /*  62 (GREF-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* <vector> */,
    0x00000050    /*  64 (LREF21-PUSH) */,
    0x0000305f    /*  65 (GREF-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* type-error */,
    0x0000100e    /*  67 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 72),
    0x0000004d    /*  69 (LREF11-PUSH) */,
    0x0000105f    /*  70 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* exact-integer? */,
    0x0000001e    /*  72 (BF) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 76),
    0x00000013    /*  74 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 91),
    0x0000100e    /*  76 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 91),
    0x0000200e    /*  78 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 89),
    0x00000006    /*  80 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[179])) /* (#f 0 #<box #f>) */,
    0x00000006    /*  82 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1944[61])) /* "Invalid assumption: ~s" */,
    0x00000001    /*  84 (CONST) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[141])) /* (exact-integer? start) */,
    0x00002088    /*  86 (LIST 2) */,
    0x00002062    /*  87 (PUSH-GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* format-internal */,
    0x00001062    /*  89 (PUSH-GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* error */,
    0x0000100e    /*  91 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 96),
    0x00000049    /*  93 (LREF1-PUSH) */,
    0x0000105f    /*  94 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* exact-integer? */,
    0x0000001e    /*  96 (BF) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 100),
    0x00000013    /*  98 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 115),
    0x0000100e    /* 100 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 115),
    0x0000200e    /* 102 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]) + 113),
    0x00000006    /* 104 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[182])) /* (#f 0 #<box #f>) */,
    0x00000006    /* 106 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1944[61])) /* "Invalid assumption: ~s" */,
    0x00000001    /* 108 (CONST) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[144])) /* (exact-integer? end) */,
    0x00002088    /* 110 (LIST 2) */,
    0x00002062    /* 111 (PUSH-GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* format-internal */,
    0x00001062    /* 113 (PUSH-GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* error */,
    0x00000016    /* 115 (CLOSURE) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1954[0])) /* #<compiled-code (vector->string #f)@0x7f1600173300> */,
    0x00001063    /* 117 (PUSH-GREF-TAIL-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* with-output-to-string */,
    0x00000014    /* 119 (RET) */,
    /* %toplevel */
    0x0000000e    /*   0 (PRE-CALL 0) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[135]) + 4),
    0x0000005f    /*   2 (GREF-CALL 0) */,
    SCM_WORD(SCM_UNDEFINED) /* %expression-name-mark-key */,
    0x0000000d    /*   4 (PUSH) */,
    0x00000001    /*   5 (CONST) */,
    SCM_WORD(SCM_UNDEFINED) /* vector->string */,
    0x000000ee    /*   7 (EXTEND-DENV) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[135]) + 12),
    0x00000016    /*   9 (CLOSURE) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1954[1])) /* #<compiled-code vector->string@0x7f1600173360> */,
    0x00000014    /*  11 (RET) */,
    0x00000015    /*  12 (DEFINE 0) */,
    SCM_WORD(SCM_UNDEFINED) /* vector->string */,
    0x00000014    /*  14 (RET) */,
    /* string->vector */
    0x0000003d    /*   0 (LREF0) */,
    0x00000022    /*   1 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 10),
    0x0000100e    /*   3 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 11),
    0x00000049    /*   5 (LREF1-PUSH) */,
    0x0000105f    /*   6 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* string-cursor-start */,
    0x00000013    /*   8 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 11),
    0x0000006a    /*  10 (LREF0-CAR) */,
    0x0000000d    /*  11 (PUSH) */,
    0x0000003d    /*  12 (LREF0) */,
    0x00000022    /*  13 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 18),
    0x00000003    /*  15 (CONSTN) */,
    0x00000013    /*  16 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 19),
    0x00000076    /*  18 (LREF0-CDR) */,
    0x00002018    /*  19 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  20 (LREF0) */,
    0x00000022    /*  21 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 30),
    0x0000100e    /*  23 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 31),
    0x0000004d    /*  25 (LREF11-PUSH) */,
    0x0000105f    /*  26 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* string-cursor-end */,
    0x00000013    /*  28 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 31),
    0x0000006a    /*  30 (LREF0-CAR) */,
    0x0000000d    /*  31 (PUSH) */,
    0x0000003d    /*  32 (LREF0) */,
    0x00000022    /*  33 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 38),
    0x00000003    /*  35 (CONSTN) */,
    0x00000013    /*  36 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 39),
    0x00000076    /*  38 (LREF0-CDR) */,
    0x00002018    /*  39 (PUSH-LOCAL-ENV 2) */,
    0x0000003d    /*  40 (LREF0) */,
    0x00000022    /*  41 (BNNULL) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 45),
    0x00000013    /*  43 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 53),
    0x0000200e    /*  45 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 53),
    0x00000006    /*  47 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1944[46])) /* "too many arguments for" */,
    0x00000006    /*  49 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1946[269])) /* (lambda (s :optional (start (string-cursor-start s)) (end (string-cursor-end s))) (assume-type s <string>) (let* ((ss (string-index->cursor s start)) (ee (string-index->cursor s end)) (size (string-cursor-diff s ss ee))) (when (< size 0) (error "End point precedes start point" (list start end))) (rlet1 v (make-vector size) (do ((ss ss (string-cursor-next s ss)) (i 0 (+ i 1))) ((string-cursor>=? ss ee)) (vector-set! v i (string-ref s ss)))))) */,
    0x0000205f    /*  51 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* error */,
    0x0000200e    /*  53 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 60),
    0x00000050    /*  55 (LREF21-PUSH) */,
    0x0000005e    /*  56 (GREF-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* <string> */,
    0x0000205f    /*  58 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* of-type? */,
    0x0000001e    /*  60 (BF) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 65),
    0x00000045    /*  62 (LREF21) */,
    0x00000013    /*  63 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 74),
    0x0000300e    /*  65 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 74),
    0x00000006    /*  67 (CONST-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* s */,
    0x0000005e    /*  69 (GREF-PUSH) */,
    SCM_WORD(SCM_UNDEFINED) /* <string> */,
    0x00000050    /*  71 (LREF21-PUSH) */,
    0x0000305f    /*  72 (GREF-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* type-error */,
    0x0000200e    /*  74 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 80),
    0x00000050    /*  76 (LREF21-PUSH) */,
    0x0000004d    /*  77 (LREF11-PUSH) */,
    0x0000205f    /*  78 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* string-index->cursor */,
    0x00001018    /*  80 (PUSH-LOCAL-ENV 1) */,
    0x0000200e    /*  81 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 87),
    0x00403047    /*  83 (LREF-PUSH 3 1) */,
    0x0000004d    /*  84 (LREF11-PUSH) */,
    0x0000205f    /*  85 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* string-index->cursor */,
    0x00001018    /*  87 (PUSH-LOCAL-ENV 1) */,
    0x0000300e    /*  88 (PRE-CALL 3) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 95),
    0x00404047    /*  90 (LREF-PUSH 4 1) */,
    0x0000004c    /*  91 (LREF10-PUSH) */,
    0x00000048    /*  92 (LREF0-PUSH) */,
    0x0000305f    /*  93 (GREF-CALL 3) */,
    SCM_WORD(SCM_UNDEFINED) /* string-cursor-diff */,
    0x00001018    /*  95 (PUSH-LOCAL-ENV 1) */,
    0x00000002    /*  96 (CONSTI 0) */,
    0x00000029    /*  97 (LREF-VAL0-BNLT 0 0) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 110),
    0x0000200e    /*  99 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 110),
    0x00000006    /* 101 (CONST-PUSH) */,
    SCM_WORD(SCM_OBJ(&scm__sc.d1944[77])) /* "End point precedes start point" */,
    0x00404047    /* 103 (LREF-PUSH 4 1) */,
    0x0040303c    /* 104 (LREF 3 1) */,
    0x00002088    /* 105 (LIST 2) */,
    0x00002062    /* 106 (PUSH-GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* error */,
    0x00000013    /* 108 (JUMP) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 110),
    0x0000100e    /* 110 (PRE-CALL 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 115),
    0x00000048    /* 112 (LREF0-PUSH) */,
    0x0000105f    /* 113 (GREF-CALL 1) */,
    SCM_WORD(SCM_UNDEFINED) /* make-vector */,
    0x00001018    /* 115 (PUSH-LOCAL-ENV 1) */,
    0x0000200e    /* 116 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 148),
    0x00000051    /* 118 (LREF30-PUSH) */,
    0x00000007    /* 119 (CONSTI-PUSH 0) */,
    0x00002017    /* 120 (LOCAL-ENV 2) */,
    0x0000200e    /* 121 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 127),
    0x00000049    /* 123 (LREF1-PUSH) */,
    0x00000051    /* 124 (LREF30-PUSH) */,
    0x0000205f    /* 125 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* string-cursor>=? */,
    0x00000031    /* 127 (RT) */,
    0x0000004c    /* 128 (LREF10-PUSH) */,
    0x00000048    /* 129 (LREF0-PUSH) */,
    0x0000200e    /* 130 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 136),
    0x00407047    /* 132 (LREF-PUSH 7 1) */,
    0x00000049    /* 133 (LREF1-PUSH) */,
    0x0000205f    /* 134 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* string-ref */,
    0x000000a9    /* 136 (VEC-SET) */,
    0x0000200e    /* 137 (PRE-CALL 2) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 143),
    0x00407047    /* 139 (LREF-PUSH 7 1) */,
    0x00000049    /* 140 (LREF1-PUSH) */,
    0x0000205f    /* 141 (GREF-CALL 2) */,
    SCM_WORD(SCM_UNDEFINED) /* string-cursor-next */,
    0x0000000d    /* 143 (PUSH) */,
    0x000010c7    /* 144 (LREF0-NUMADDI-PUSH 1) */,
    0x0000101b    /* 145 (LOCAL-ENV-JUMP 1) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]) + 121),
    0x00000014    /* 147 (RET) */,
    0x00000053    /* 148 (LREF0-RET) */,
    /* %toplevel */
    0x0000000e    /*   0 (PRE-CALL 0) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[299]) + 4),
    0x0000005f    /*   2 (GREF-CALL 0) */,
    SCM_WORD(SCM_UNDEFINED) /* %expression-name-mark-key */,
    0x0000000d    /*   4 (PUSH) */,
    0x00000001    /*   5 (CONST) */,
    SCM_WORD(SCM_UNDEFINED) /* string->vector */,
    0x000000ee    /*   7 (EXTEND-DENV) */,
    SCM_WORD((ScmWord*)SCM_OBJ(&scm__rc.d1953[299]) + 12),
    0x00000016    /*   9 (CLOSURE) */,
    SCM_WORD(SCM_OBJ(&scm__rc.d1954[3])) /* #<compiled-code string->vector@0x7f15ffeda720> */,
    0x00000014    /*  11 (RET) */,
    0x00000015    /*  12 (DEFINE 0) */,
    SCM_WORD(SCM_UNDEFINED) /* string->vector */,
    0x00000014    /*  14 (RET) */,
  },
  {   /* ScmPair d1946 */
       { SCM_NIL, SCM_NIL },
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1])},
       { SCM_MAKE_INT(51U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[3])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[4])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[6])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[7])},
       { SCM_OBJ(&scm__rc.d1946[8]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[5]), SCM_OBJ(&scm__rc.d1946[9])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(54U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[12])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[13])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[15])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[16])},
       { SCM_OBJ(&scm__rc.d1946[17]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[14]), SCM_OBJ(&scm__rc.d1946[18])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(57U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[21])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[22])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[24])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[25])},
       { SCM_OBJ(&scm__rc.d1946[26]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[23]), SCM_OBJ(&scm__rc.d1946[27])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[29])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[31])},
       { SCM_MAKE_INT(60U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[33])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[34])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[36])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[37])},
       { SCM_OBJ(&scm__rc.d1946[38]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[35]), SCM_OBJ(&scm__rc.d1946[39])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[11])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[41])},
       { SCM_MAKE_INT(71U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[43])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[44])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[46])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[47])},
       { SCM_OBJ(&scm__rc.d1946[48]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[45]), SCM_OBJ(&scm__rc.d1946[49])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[51])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[52])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_MAKE_INT(81U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[55])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[56])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[58])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[59])},
       { SCM_OBJ(&scm__rc.d1946[60]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[57]), SCM_OBJ(&scm__rc.d1946[61])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_MAKE_INT(85U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[64])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[65])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[67])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[68])},
       { SCM_OBJ(&scm__rc.d1946[69]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[66]), SCM_OBJ(&scm__rc.d1946[70])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[72])},
       { SCM_MAKE_INT(89U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[74])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[75])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[77])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[78])},
       { SCM_OBJ(&scm__rc.d1946[79]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[76]), SCM_OBJ(&scm__rc.d1946[80])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[82])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[83])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[84])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[85])},
       { SCM_MAKE_INT(93U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[87])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[88])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[90])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[91])},
       { SCM_OBJ(&scm__rc.d1946[92]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[89]), SCM_OBJ(&scm__rc.d1946[93])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[95])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[96])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[97])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[98])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[99])},
       { SCM_MAKE_INT(97U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[101])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[102])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[104])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[105])},
       { SCM_OBJ(&scm__rc.d1946[106]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[103]), SCM_OBJ(&scm__rc.d1946[107])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[109])},
       { SCM_MAKE_INT(128U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[111])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[112])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[114])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[115])},
       { SCM_OBJ(&scm__rc.d1946[116]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[113]), SCM_OBJ(&scm__rc.d1946[117])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(144U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[120])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[121])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[123])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[124])},
       { SCM_OBJ(&scm__rc.d1946[125]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[122]), SCM_OBJ(&scm__rc.d1946[126])},
       { SCM_MAKE_INT(0), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[128])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[119])},
       { SCM_OBJ(&scm__rc.d1946[130]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[131])},
       { SCM_OBJ(&scm__rc.d1946[132]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[129]), SCM_OBJ(&scm__rc.d1946[133])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[134])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[135])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[137])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[138])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[140])},
       { SCM_OBJ(&scm__rc.d1946[141]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[142])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[51])},
       { SCM_OBJ(&scm__rc.d1946[144]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[145])},
       { SCM_MAKE_INT(1U), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[147])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[148])},
       { SCM_OBJ(&scm__rc.d1946[149]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[150])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[151])},
       { SCM_OBJ(&scm__rc.d1946[152]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[51])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[154])},
       { SCM_OBJ(&scm__rc.d1946[155]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[157])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[158])},
       { SCM_OBJ(&scm__rc.d1946[159]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[160])},
       { SCM_OBJ(&scm__rc.d1946[161]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[156]), SCM_OBJ(&scm__rc.d1946[162])},
       { SCM_OBJ(&scm__rc.d1946[153]), SCM_OBJ(&scm__rc.d1946[163])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[164])},
       { SCM_OBJ(&scm__rc.d1946[165]), SCM_NIL},
       { SCM_NIL, SCM_OBJ(&scm__rc.d1946[166])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[167])},
       { SCM_OBJ(&scm__rc.d1946[168]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[169])},
       { SCM_OBJ(&scm__rc.d1946[170]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[146]), SCM_OBJ(&scm__rc.d1946[171])},
       { SCM_OBJ(&scm__rc.d1946[143]), SCM_OBJ(&scm__rc.d1946[172])},
       { SCM_OBJ(&scm__rc.d1946[139]), SCM_OBJ(&scm__rc.d1946[173])},
       { SCM_OBJ(&scm__rc.d1946[136]), SCM_OBJ(&scm__rc.d1946[174])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[175])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(0), SCM_OBJ(&scm__rc.d1946[177])},
       { SCM_FALSE, SCM_OBJ(&scm__rc.d1946[178])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(0), SCM_OBJ(&scm__rc.d1946[180])},
       { SCM_FALSE, SCM_OBJ(&scm__rc.d1946[181])},
       { SCM_FALSE, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[183])},
       { SCM_MAKE_INT(155U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[185])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[186])},
       { SCM_OBJ(&scm__rc.d1946[187]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(149U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[190])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[191])},
       { SCM_OBJ(&scm__rc.d1946[192]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[195])},
       { SCM_OBJ(&scm__rc.d1946[196]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[197])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[195])},
       { SCM_OBJ(&scm__rc.d1946[199]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[200])},
       { SCM_OBJ(&scm__rc.d1946[201]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[198]), SCM_OBJ(&scm__rc.d1946[202])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[203])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[204])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[206])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[207])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[140])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[209])},
       { SCM_OBJ(&scm__rc.d1946[210]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[211])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[51])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[213])},
       { SCM_OBJ(&scm__rc.d1946[214]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[215])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[217])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[218])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[219])},
       { SCM_OBJ(&scm__rc.d1946[220]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[221])},
       { SCM_OBJ(&scm__rc.d1946[222]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[216]), SCM_OBJ(&scm__rc.d1946[223])},
       { SCM_OBJ(&scm__rc.d1946[212]), SCM_OBJ(&scm__rc.d1946[224])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[128])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[226])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[52])},
       { SCM_OBJ(&scm__rc.d1946[228]), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[77]), SCM_OBJ(&scm__rc.d1946[229])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[230])},
       { SCM_OBJ(&scm__rc.d1946[231]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[227]), SCM_OBJ(&scm__rc.d1946[232])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[233])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[235])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[237])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[238])},
       { SCM_OBJ(&scm__rc.d1946[239]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[240])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[241])},
       { SCM_MAKE_INT(0), SCM_OBJ(&scm__rc.d1946[150])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[243])},
       { SCM_OBJ(&scm__rc.d1946[244]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[242]), SCM_OBJ(&scm__rc.d1946[245])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[218])},
       { SCM_OBJ(&scm__rc.d1946[247]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[238])},
       { SCM_OBJ(&scm__rc.d1946[249]), SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[250])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[251])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[252])},
       { SCM_OBJ(&scm__rc.d1946[253]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[248]), SCM_OBJ(&scm__rc.d1946[254])},
       { SCM_OBJ(&scm__rc.d1946[246]), SCM_OBJ(&scm__rc.d1946[255])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[256])},
       { SCM_OBJ(&scm__rc.d1946[257]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[236]), SCM_OBJ(&scm__rc.d1946[258])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[259])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[260])},
       { SCM_OBJ(&scm__rc.d1946[261]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[234]), SCM_OBJ(&scm__rc.d1946[262])},
       { SCM_OBJ(&scm__rc.d1946[225]), SCM_OBJ(&scm__rc.d1946[263])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[264])},
       { SCM_OBJ(&scm__rc.d1946[265]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[208]), SCM_OBJ(&scm__rc.d1946[266])},
       { SCM_OBJ(&scm__rc.d1946[205]), SCM_OBJ(&scm__rc.d1946[267])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[268])},
       { SCM_MAKE_INT(159U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[270])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[271])},
       { SCM_OBJ(&scm__rc.d1946[272]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(180U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[275])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[276])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[278])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[279])},
       { SCM_OBJ(&scm__rc.d1946[280]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[277]), SCM_OBJ(&scm__rc.d1946[281])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(182U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[284])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[285])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[287])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[288])},
       { SCM_OBJ(&scm__rc.d1946[289]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[286]), SCM_OBJ(&scm__rc.d1946[290])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[292])},
       { SCM_MAKE_INT(186U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[294])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[295])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[297])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[298])},
       { SCM_OBJ(&scm__rc.d1946[299]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[296]), SCM_OBJ(&scm__rc.d1946[300])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[302])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[303])},
       { SCM_MAKE_INT(189U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[305])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[306])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[308])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[309])},
       { SCM_OBJ(&scm__rc.d1946[310]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[307]), SCM_OBJ(&scm__rc.d1946[311])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[82])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[313])},
       { SCM_MAKE_INT(216U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[315])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[316])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[318])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[319])},
       { SCM_OBJ(&scm__rc.d1946[320]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[317]), SCM_OBJ(&scm__rc.d1946[321])},
       { SCM_MAKE_INT(220U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[323])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[324])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[326])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[327])},
       { SCM_OBJ(&scm__rc.d1946[328]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[325]), SCM_OBJ(&scm__rc.d1946[329])},
       { SCM_MAKE_INT(224U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[331])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[332])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[334])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[335])},
       { SCM_OBJ(&scm__rc.d1946[336]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[333]), SCM_OBJ(&scm__rc.d1946[337])},
       { SCM_MAKE_INT(228U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[339])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[340])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[342])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[343])},
       { SCM_OBJ(&scm__rc.d1946[344]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[341]), SCM_OBJ(&scm__rc.d1946[345])},
       { SCM_MAKE_INT(232U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[347])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[348])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[350])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[351])},
       { SCM_OBJ(&scm__rc.d1946[352]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[349]), SCM_OBJ(&scm__rc.d1946[353])},
       { SCM_MAKE_INT(236U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[355])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[356])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[358])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[359])},
       { SCM_OBJ(&scm__rc.d1946[360]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[357]), SCM_OBJ(&scm__rc.d1946[361])},
       { SCM_MAKE_INT(240U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[363])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[364])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[366])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[367])},
       { SCM_OBJ(&scm__rc.d1946[368]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[365]), SCM_OBJ(&scm__rc.d1946[369])},
       { SCM_MAKE_INT(244U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[371])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[372])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[374])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[375])},
       { SCM_OBJ(&scm__rc.d1946[376]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[373]), SCM_OBJ(&scm__rc.d1946[377])},
       { SCM_MAKE_INT(248U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[379])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[380])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[382])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[383])},
       { SCM_OBJ(&scm__rc.d1946[384]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[381]), SCM_OBJ(&scm__rc.d1946[385])},
       { SCM_MAKE_INT(252U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[387])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[388])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[390])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[391])},
       { SCM_OBJ(&scm__rc.d1946[392]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[389]), SCM_OBJ(&scm__rc.d1946[393])},
       { SCM_MAKE_INT(256U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[395])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[396])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[398])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[399])},
       { SCM_OBJ(&scm__rc.d1946[400]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[397]), SCM_OBJ(&scm__rc.d1946[401])},
       { SCM_MAKE_INT(260U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[403])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[404])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[406])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[407])},
       { SCM_OBJ(&scm__rc.d1946[408]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[405]), SCM_OBJ(&scm__rc.d1946[409])},
       { SCM_MAKE_INT(264U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[411])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[412])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[414])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[415])},
       { SCM_OBJ(&scm__rc.d1946[416]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[413]), SCM_OBJ(&scm__rc.d1946[417])},
       { SCM_MAKE_INT(268U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[419])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[420])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[422])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[423])},
       { SCM_OBJ(&scm__rc.d1946[424]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[421]), SCM_OBJ(&scm__rc.d1946[425])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[427])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[428])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[429])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[430])},
       { SCM_MAKE_INT(272U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[432])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[433])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[435])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[436])},
       { SCM_OBJ(&scm__rc.d1946[437]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[434]), SCM_OBJ(&scm__rc.d1946[438])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[30])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[440])},
       { SCM_MAKE_INT(274U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[442])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[443])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[445])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[446])},
       { SCM_OBJ(&scm__rc.d1946[447]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[444]), SCM_OBJ(&scm__rc.d1946[448])},
       { SCM_MAKE_INT(279U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[450])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[451])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[453])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[454])},
       { SCM_OBJ(&scm__rc.d1946[455]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[452]), SCM_OBJ(&scm__rc.d1946[456])},
       { SCM_MAKE_INT(281U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[458])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[459])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[461])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[462])},
       { SCM_OBJ(&scm__rc.d1946[463]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[460]), SCM_OBJ(&scm__rc.d1946[464])},
       { SCM_MAKE_INT(286U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[466])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[467])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[469])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[470])},
       { SCM_OBJ(&scm__rc.d1946[471]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[468]), SCM_OBJ(&scm__rc.d1946[472])},
       { SCM_MAKE_INT(288U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[474])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[475])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[477])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[478])},
       { SCM_OBJ(&scm__rc.d1946[479]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[476]), SCM_OBJ(&scm__rc.d1946[480])},
       { SCM_MAKE_INT(293U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[482])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[483])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[485])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[486])},
       { SCM_OBJ(&scm__rc.d1946[487]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[484]), SCM_OBJ(&scm__rc.d1946[488])},
       { SCM_MAKE_INT(295U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[490])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[491])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[493])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[494])},
       { SCM_OBJ(&scm__rc.d1946[495]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[492]), SCM_OBJ(&scm__rc.d1946[496])},
       { SCM_MAKE_INT(300U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[498])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[499])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[501])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[502])},
       { SCM_OBJ(&scm__rc.d1946[503]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[500]), SCM_OBJ(&scm__rc.d1946[504])},
       { SCM_MAKE_INT(302U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[506])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[507])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[509])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[510])},
       { SCM_OBJ(&scm__rc.d1946[511]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[508]), SCM_OBJ(&scm__rc.d1946[512])},
       { SCM_MAKE_INT(307U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[514])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[515])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[517])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[518])},
       { SCM_OBJ(&scm__rc.d1946[519]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[516]), SCM_OBJ(&scm__rc.d1946[520])},
       { SCM_MAKE_INT(309U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[522])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[523])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[525])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[526])},
       { SCM_OBJ(&scm__rc.d1946[527]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[524]), SCM_OBJ(&scm__rc.d1946[528])},
       { SCM_MAKE_INT(314U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[530])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[531])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[533])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[534])},
       { SCM_OBJ(&scm__rc.d1946[535]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[532]), SCM_OBJ(&scm__rc.d1946[536])},
       { SCM_MAKE_INT(316U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[538])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[539])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[541])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[542])},
       { SCM_OBJ(&scm__rc.d1946[543]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[540]), SCM_OBJ(&scm__rc.d1946[544])},
       { SCM_MAKE_INT(321U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[546])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[547])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[549])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[550])},
       { SCM_OBJ(&scm__rc.d1946[551]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[548]), SCM_OBJ(&scm__rc.d1946[552])},
       { SCM_MAKE_INT(323U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[554])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[555])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[557])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[558])},
       { SCM_OBJ(&scm__rc.d1946[559]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[556]), SCM_OBJ(&scm__rc.d1946[560])},
       { SCM_MAKE_INT(328U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[562])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[563])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[565])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[566])},
       { SCM_OBJ(&scm__rc.d1946[567]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[564]), SCM_OBJ(&scm__rc.d1946[568])},
       { SCM_MAKE_INT(330U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[570])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[571])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[573])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[574])},
       { SCM_OBJ(&scm__rc.d1946[575]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[572]), SCM_OBJ(&scm__rc.d1946[576])},
       { SCM_MAKE_INT(335U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[578])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[579])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[581])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[582])},
       { SCM_OBJ(&scm__rc.d1946[583]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[580]), SCM_OBJ(&scm__rc.d1946[584])},
       { SCM_MAKE_INT(337U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[586])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[587])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[589])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[590])},
       { SCM_OBJ(&scm__rc.d1946[591]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[588]), SCM_OBJ(&scm__rc.d1946[592])},
       { SCM_MAKE_INT(342U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[594])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[595])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[597])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[598])},
       { SCM_OBJ(&scm__rc.d1946[599]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[596]), SCM_OBJ(&scm__rc.d1946[600])},
       { SCM_MAKE_INT(344U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[602])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[603])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[605])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[606])},
       { SCM_OBJ(&scm__rc.d1946[607]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[604]), SCM_OBJ(&scm__rc.d1946[608])},
       { SCM_MAKE_INT(349U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[610])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[611])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[613])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[614])},
       { SCM_OBJ(&scm__rc.d1946[615]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[612]), SCM_OBJ(&scm__rc.d1946[616])},
       { SCM_MAKE_INT(351U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[618])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[619])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[621])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[622])},
       { SCM_OBJ(&scm__rc.d1946[623]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[620]), SCM_OBJ(&scm__rc.d1946[624])},
       { SCM_MAKE_INT(356U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[626])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[627])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[629])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[630])},
       { SCM_OBJ(&scm__rc.d1946[631]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[628]), SCM_OBJ(&scm__rc.d1946[632])},
       { SCM_MAKE_INT(358U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[634])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[635])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[637])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[638])},
       { SCM_OBJ(&scm__rc.d1946[639]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[636]), SCM_OBJ(&scm__rc.d1946[640])},
       { SCM_MAKE_INT(363U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[642])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[643])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[645])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[646])},
       { SCM_OBJ(&scm__rc.d1946[647]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[644]), SCM_OBJ(&scm__rc.d1946[648])},
       { SCM_MAKE_INT(365U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[650])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[651])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[653])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[654])},
       { SCM_OBJ(&scm__rc.d1946[655]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[652]), SCM_OBJ(&scm__rc.d1946[656])},
       { SCM_MAKE_INT(370U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[658])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[659])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[661])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[662])},
       { SCM_OBJ(&scm__rc.d1946[663]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[660]), SCM_OBJ(&scm__rc.d1946[664])},
       { SCM_MAKE_INT(374U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[666])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[667])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[669])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[670])},
       { SCM_OBJ(&scm__rc.d1946[671]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[668]), SCM_OBJ(&scm__rc.d1946[672])},
       { SCM_MAKE_INT(379U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[674])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[675])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[677])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[678])},
       { SCM_OBJ(&scm__rc.d1946[679]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[676]), SCM_OBJ(&scm__rc.d1946[680])},
       { SCM_MAKE_INT(381U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[682])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[683])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[685])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[686])},
       { SCM_OBJ(&scm__rc.d1946[687]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[684]), SCM_OBJ(&scm__rc.d1946[688])},
       { SCM_MAKE_INT(383U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[690])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[691])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[693])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[694])},
       { SCM_OBJ(&scm__rc.d1946[695]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[692]), SCM_OBJ(&scm__rc.d1946[696])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(386U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[699])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[700])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[702])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[703])},
       { SCM_OBJ(&scm__rc.d1946[704]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[701]), SCM_OBJ(&scm__rc.d1946[705])},
       { SCM_MAKE_INT(387U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[707])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[708])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[710])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[711])},
       { SCM_OBJ(&scm__rc.d1946[712]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[709]), SCM_OBJ(&scm__rc.d1946[713])},
       { SCM_MAKE_INT(388U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[715])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[716])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[718])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[719])},
       { SCM_OBJ(&scm__rc.d1946[720]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[717]), SCM_OBJ(&scm__rc.d1946[721])},
       { SCM_MAKE_INT(389U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[723])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[724])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[726])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[727])},
       { SCM_OBJ(&scm__rc.d1946[728]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[725]), SCM_OBJ(&scm__rc.d1946[729])},
       { SCM_MAKE_INT(390U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[731])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[732])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[734])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[735])},
       { SCM_OBJ(&scm__rc.d1946[736]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[733]), SCM_OBJ(&scm__rc.d1946[737])},
       { SCM_MAKE_INT(391U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[739])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[740])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[742])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[743])},
       { SCM_OBJ(&scm__rc.d1946[744]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[741]), SCM_OBJ(&scm__rc.d1946[745])},
       { SCM_MAKE_INT(392U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[747])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[748])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[750])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[751])},
       { SCM_OBJ(&scm__rc.d1946[752]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[749]), SCM_OBJ(&scm__rc.d1946[753])},
       { SCM_MAKE_INT(393U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[755])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[756])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[758])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[759])},
       { SCM_OBJ(&scm__rc.d1946[760]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[757]), SCM_OBJ(&scm__rc.d1946[761])},
       { SCM_MAKE_INT(394U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[763])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[764])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[766])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[767])},
       { SCM_OBJ(&scm__rc.d1946[768]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[765]), SCM_OBJ(&scm__rc.d1946[769])},
       { SCM_MAKE_INT(395U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[771])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[772])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[774])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[775])},
       { SCM_OBJ(&scm__rc.d1946[776]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[773]), SCM_OBJ(&scm__rc.d1946[777])},
       { SCM_MAKE_INT(396U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[779])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[780])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[782])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[783])},
       { SCM_OBJ(&scm__rc.d1946[784]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[781]), SCM_OBJ(&scm__rc.d1946[785])},
       { SCM_MAKE_INT(397U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[787])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[788])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[790])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[791])},
       { SCM_OBJ(&scm__rc.d1946[792]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[789]), SCM_OBJ(&scm__rc.d1946[793])},
       { SCM_MAKE_INT(398U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[795])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[796])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[798])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[799])},
       { SCM_OBJ(&scm__rc.d1946[800]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[797]), SCM_OBJ(&scm__rc.d1946[801])},
       { SCM_MAKE_INT(399U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[803])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[804])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[806])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[807])},
       { SCM_OBJ(&scm__rc.d1946[808]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[805]), SCM_OBJ(&scm__rc.d1946[809])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[811])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[812])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[813])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[814])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[815])},
       { SCM_MAKE_INT(401U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[817])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[818])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[820])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[821])},
       { SCM_OBJ(&scm__rc.d1946[822]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[819]), SCM_OBJ(&scm__rc.d1946[823])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[811])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[825])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[826])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[827])},
       { SCM_MAKE_INT(454U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[829])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[830])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[832])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[833])},
       { SCM_OBJ(&scm__rc.d1946[834]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[831]), SCM_OBJ(&scm__rc.d1946[835])},
       { SCM_MAKE_INT(459U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[837])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[838])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[840])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[841])},
       { SCM_OBJ(&scm__rc.d1946[842]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[839]), SCM_OBJ(&scm__rc.d1946[843])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[845])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[846])},
       { SCM_MAKE_INT(480U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[848])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[849])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[851])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[852])},
       { SCM_OBJ(&scm__rc.d1946[853]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[850]), SCM_OBJ(&scm__rc.d1946[854])},
       { SCM_MAKE_INT(487U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[856])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[857])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[859])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[860])},
       { SCM_OBJ(&scm__rc.d1946[861]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[858]), SCM_OBJ(&scm__rc.d1946[862])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[864])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[865])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[866])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[867])},
       { SCM_MAKE_INT(532U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[869])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[870])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[872])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[873])},
       { SCM_OBJ(&scm__rc.d1946[874]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[871]), SCM_OBJ(&scm__rc.d1946[875])},
       { SCM_MAKE_INT(538U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[877])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[878])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[880])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[881])},
       { SCM_OBJ(&scm__rc.d1946[882]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[879]), SCM_OBJ(&scm__rc.d1946[883])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[885])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[886])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[887])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[888])},
       { SCM_MAKE_INT(567U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[890])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[891])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[893])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[894])},
       { SCM_OBJ(&scm__rc.d1946[895]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[892]), SCM_OBJ(&scm__rc.d1946[896])},
       { SCM_MAKE_INT(573U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[898])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[899])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[901])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[902])},
       { SCM_OBJ(&scm__rc.d1946[903]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[900]), SCM_OBJ(&scm__rc.d1946[904])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[889])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[906])},
       { SCM_MAKE_INT(607U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[908])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[909])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[911])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[912])},
       { SCM_OBJ(&scm__rc.d1946[913]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[910]), SCM_OBJ(&scm__rc.d1946[914])},
       { SCM_MAKE_INT(615U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[916])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[917])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[919])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[920])},
       { SCM_OBJ(&scm__rc.d1946[921]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[918]), SCM_OBJ(&scm__rc.d1946[922])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[885])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[924])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[925])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[926])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[927])},
       { SCM_MAKE_INT(651U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[929])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[930])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[932])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[933])},
       { SCM_OBJ(&scm__rc.d1946[934]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[931]), SCM_OBJ(&scm__rc.d1946[935])},
       { SCM_MAKE_INT(658U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[937])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[938])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[940])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[941])},
       { SCM_OBJ(&scm__rc.d1946[942]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[939]), SCM_OBJ(&scm__rc.d1946[943])},
       { SCM_MAKE_INT(670U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[945])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[946])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[948])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[949])},
       { SCM_OBJ(&scm__rc.d1946[950]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[947]), SCM_OBJ(&scm__rc.d1946[951])},
       { SCM_MAKE_INT(671U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[953])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[954])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[956])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[957])},
       { SCM_OBJ(&scm__rc.d1946[958]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[955]), SCM_OBJ(&scm__rc.d1946[959])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[961])},
       { SCM_MAKE_INT(674U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[963])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[964])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[966])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[967])},
       { SCM_OBJ(&scm__rc.d1946[968]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[965]), SCM_OBJ(&scm__rc.d1946[969])},
       { SCM_MAKE_INT(684U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[971])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[972])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[974])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[975])},
       { SCM_OBJ(&scm__rc.d1946[976]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[973]), SCM_OBJ(&scm__rc.d1946[977])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[979])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[980])},
       { SCM_MAKE_INT(694U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[982])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[983])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[985])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[986])},
       { SCM_OBJ(&scm__rc.d1946[987]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[984]), SCM_OBJ(&scm__rc.d1946[988])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[990])},
       { SCM_MAKE_INT(696U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[992])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[993])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[995])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[996])},
       { SCM_OBJ(&scm__rc.d1946[997]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[994]), SCM_OBJ(&scm__rc.d1946[998])},
       { SCM_MAKE_INT(697U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1000])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1001])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1003])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1004])},
       { SCM_OBJ(&scm__rc.d1946[1005]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1002]), SCM_OBJ(&scm__rc.d1946[1006])},
       { SCM_MAKE_INT(699U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1008])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1009])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1011])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1012])},
       { SCM_OBJ(&scm__rc.d1946[1013]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1010]), SCM_OBJ(&scm__rc.d1946[1014])},
       { SCM_MAKE_INT(701U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1016])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1017])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1019])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1020])},
       { SCM_OBJ(&scm__rc.d1946[1021]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1018]), SCM_OBJ(&scm__rc.d1946[1022])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_MAKE_INT(704U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1025])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1026])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1028])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1029])},
       { SCM_OBJ(&scm__rc.d1946[1030]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1027]), SCM_OBJ(&scm__rc.d1946[1031])},
       { SCM_MAKE_INT(705U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1033])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1034])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1036])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1037])},
       { SCM_OBJ(&scm__rc.d1946[1038]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1035]), SCM_OBJ(&scm__rc.d1946[1039])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1041])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1042])},
       { SCM_MAKE_INT(707U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1044])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1045])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1047])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1048])},
       { SCM_OBJ(&scm__rc.d1946[1049]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1046]), SCM_OBJ(&scm__rc.d1946[1050])},
       { SCM_MAKE_INT(715U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1052])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1053])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1055])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1056])},
       { SCM_OBJ(&scm__rc.d1946[1057]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1054]), SCM_OBJ(&scm__rc.d1946[1058])},
       { SCM_MAKE_INT(726U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1060])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1061])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1063])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1064])},
       { SCM_OBJ(&scm__rc.d1946[1065]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1062]), SCM_OBJ(&scm__rc.d1946[1066])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_MAKE_INT(735U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1069])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1070])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1072])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1073])},
       { SCM_OBJ(&scm__rc.d1946[1074]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1071]), SCM_OBJ(&scm__rc.d1946[1075])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1077])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1078])},
       { SCM_MAKE_INT(740U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1080])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1081])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1083])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1084])},
       { SCM_OBJ(&scm__rc.d1946[1085]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1082]), SCM_OBJ(&scm__rc.d1946[1086])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1088])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1089])},
       { SCM_OBJ(&scm__rc.d1946[1090]), SCM_NIL},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1092])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1093])},
       { SCM_MAKE_INT(750U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1095])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1096])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1098])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1099])},
       { SCM_OBJ(&scm__rc.d1946[1100]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1097]), SCM_OBJ(&scm__rc.d1946[1101])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[53])},
       { SCM_MAKE_INT(755U), SCM_NIL},
       { SCM_OBJ(&scm__sc.d1944[4]), SCM_OBJ(&scm__rc.d1946[1104])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1105])},
       { SCM_UNDEFINED, SCM_NIL},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1107])},
       { SCM_UNDEFINED, SCM_OBJ(&scm__rc.d1946[1108])},
       { SCM_OBJ(&scm__rc.d1946[1109]), SCM_NIL},
       { SCM_OBJ(&scm__rc.d1946[1106]), SCM_OBJ(&scm__rc.d1946[1110])},
  },
  {   /* ScmObj d1945 */
    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_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_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_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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_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_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(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(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(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_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_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(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(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(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(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_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(5, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_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,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(4, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(6, FALSE),
    SCM_MAKE_INT(1U),
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_UNDEFINED,
    SCM_OBJ(SCM_CLASS_STATIC_TAG(Scm_VectorClass)) /* <vector> */,
    SCM_VECTOR_SIZE_SLOT_INITIALIZER(52, FALSE),
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_FALSE,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
  },
};

static ScmObj libvecvector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj args_scm;
  ScmObj args;
  ScmObj SCM_SUBRARGS[1];
  SCM_ENTER_SUBR("vector");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  args_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!SCM_LISTP(args_scm)) Scm_TypeError("args", "list", args_scm);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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_TypeError("obj", "scheme object", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_VECTORP(obj);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("vec", "<vector>", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  {
{
ScmSmallInt SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_VECTOR_SIZE(vec);
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_TypeError("vec", "<vector>", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_SUBRARGS[1];
  if (!SCM_INTEGERP(k_scm)) Scm_TypeError("k", "exact integer", k_scm);
  k = (k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_SUBRARGS[2];
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  if (!(fallback_scm)) Scm_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 63 "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;
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;} else {
SCM_RESULT = 
#line 69 "libvec.scm"
SCM_VECTOR_ELEMENT(vec,SCM_INT_VALUE(k));
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("vec", "<vector>", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_SUBRARGS[1];
  if (!SCM_INTEGERP(k_scm)) Scm_TypeError("k", "exact integer", k_scm);
  k = (k_scm);
  obj_scm = SCM_SUBRARGS[2];
  if (!(obj_scm)) Scm_TypeError("obj", "scheme object", obj_scm);
  obj = (obj_scm);
  {

#line 72 "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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_TypeError("vec", "<vector>", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_VectorToList(vec,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  list_scm = SCM_SUBRARGS[0];
  if (!SCM_LISTP(list_scm)) Scm_TypeError("list", "list", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_ListToVector(list,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vec_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(vec_scm)) Scm_TypeError("vec", "<vector>", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  fill_scm = SCM_SUBRARGS[1];
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", 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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(v_scm)) Scm_TypeError("v", "<vector>", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", 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_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_VectorCopy(v,start,end,fill);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[5];
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  t_scm = SCM_SUBRARGS[0];
  if (!SCM_VECTORP(t_scm)) Scm_TypeError("t", "<vector>", t_scm);
  t = SCM_VECTOR(t_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_TypeError("tstart", "ScmSmallInt", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_VECTORP(s_scm)) Scm_TypeError("s", "<vector>", 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_TypeError("sstart", "ScmSmallInt", 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_TypeError("send", "ScmSmallInt", send_scm);
  send = SCM_INT_VALUE(send_scm);
  {

#line 99 "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 111 "libvec.scm"
if (!((sstart)<=(send))){{
Scm_Error("send (%ld) must be greater than or equal to sstart (%ld)",send,sstart);}}
#line 114 "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[1];
  SCM_ENTER_SUBR("vector-append");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  vecs_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!SCM_LISTP(vecs_scm)) Scm_TypeError("vecs", "list", vecs_scm);
  vecs = (vecs_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
ScmObj cise__1948;ScmObj cise__1947;
#line 129 "libvec.scm"
{long len=0;
SCM_FOR_EACH(cise__1947,vecs) {{ScmObj v=SCM_CAR(cise__1947);
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 136 "libvec.scm"
SCM_FOR_EACH(cise__1948,vecs) {{ScmObj v=SCM_CAR(cise__1948);
{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;
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("v", "<vector>", v_scm);
  v = SCM_VECTOR(v_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_VECTOR_IMMUTABLE_P(v);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("size", "ScmSmallInt", size_scm);
  size = SCM_INT_VALUE(size_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_MakeWeakVector(size);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("wv", "<weak-vector>", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  {
{
ScmSmallInt SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 183 "libvec.scm"
SCM_RESULT = 
#line 183 "libvec.scm"
(wv)->size;
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  wv_scm = SCM_SUBRARGS[0];
  if (!SCM_WEAK_VECTOR_P(wv_scm)) Scm_TypeError("wv", "<weak-vector>", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  index_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(index_scm)) Scm_TypeError("index", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_WeakVectorRef(wv,index,fallback);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("wv", "<weak-vector>", wv_scm);
  wv = SCM_WEAK_VECTOR(wv_scm);
  index_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(index_scm)) Scm_TypeError("index", "ScmSmallInt", index_scm);
  index = SCM_INT_VALUE(index_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_WeakVectorSet(wv,index,val);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_s8vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-s8vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 217 "libvec.scm"
{int8_t filler=Scm_GetInteger8Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 218 "libvec.scm"
Scm_MakeS8Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_u8vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-u8vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 221 "libvec.scm"
{uint8_t filler=Scm_GetIntegerU8Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 222 "libvec.scm"
Scm_MakeU8Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_s16vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-s16vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 225 "libvec.scm"
{int16_t filler=Scm_GetInteger16Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 226 "libvec.scm"
Scm_MakeS16Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_u16vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-u16vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 229 "libvec.scm"
{uint16_t filler=Scm_GetIntegerU16Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 230 "libvec.scm"
Scm_MakeU16Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_s32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-s32vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 233 "libvec.scm"
{int32_t filler=Scm_GetInteger32Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 234 "libvec.scm"
Scm_MakeS32Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_u32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-u32vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 237 "libvec.scm"
{uint32_t filler=Scm_GetIntegerU32Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 238 "libvec.scm"
Scm_MakeU32Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_s64vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-s64vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 241 "libvec.scm"
{int64_t filler=Scm_GetInteger64Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 242 "libvec.scm"
Scm_MakeS64Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_u64vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-u64vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 245 "libvec.scm"
{uint64_t filler=Scm_GetIntegerU64Clamp(fill,SCM_CLAMP_ERROR,NULL);
SCM_RESULT = 
#line 246 "libvec.scm"
Scm_MakeU64Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_f16vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-f16vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 249 "libvec.scm"
{ScmHalfFloat filler=Scm_DoubleToHalf(Scm_GetDouble(fill));
SCM_RESULT = 
#line 250 "libvec.scm"
Scm_MakeF16Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_f32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-f32vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 253 "libvec.scm"
{float filler=((float )(Scm_GetDouble(fill)));
SCM_RESULT = 
#line 254 "libvec.scm"
Scm_MakeF32Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_f64vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-f64vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 257 "libvec.scm"
{double filler=Scm_GetDouble(fill);
SCM_RESULT = 
#line 258 "libvec.scm"
Scm_MakeF64Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_c32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-c32vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 261 "libvec.scm"
{ScmHalfComplex filler=Scm_GetHalfComplex(fill);
SCM_RESULT = 
#line 262 "libvec.scm"
Scm_MakeC32Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_c64vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-c64vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 265 "libvec.scm"
{ScmFloatComplex filler=Scm_GetFloatComplex(fill);
SCM_RESULT = 
#line 266 "libvec.scm"
Scm_MakeC64Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecmake_c128vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj length_scm;
  ScmSmallInt length;
  ScmObj fill_scm;
  ScmObj fill;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("make-c128vector");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  length_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(length_scm)) Scm_TypeError("length", "ScmSmallInt", length_scm);
  length = SCM_INT_VALUE(length_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_SUBRARGS[1];
  } else {
    fill_scm = SCM_MAKE_INT(0);
  }
  if (!(fill_scm)) Scm_TypeError("fill", "scheme object", fill_scm);
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 269 "libvec.scm"
{ScmDoubleComplex filler=Scm_GetDoubleComplex(fill);
SCM_RESULT = 
#line 270 "libvec.scm"
Scm_MakeC128Vector(length,filler);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_TypeError("v", "<s8vector>", v_scm);
  v = SCM_S8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_TypeError("v", "<s8vector>", v_scm);
  v = SCM_S8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_TypeError("v", "<u8vector>", v_scm);
  v = SCM_U8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_TypeError("v", "<u8vector>", v_scm);
  v = SCM_U8VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S16VECTORP(v_scm)) Scm_TypeError("v", "<s16vector>", v_scm);
  v = SCM_S16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S16VECTORP(v_scm)) Scm_TypeError("v", "<s16vector>", v_scm);
  v = SCM_S16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U16VECTORP(v_scm)) Scm_TypeError("v", "<u16vector>", v_scm);
  v = SCM_U16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U16VECTORP(v_scm)) Scm_TypeError("v", "<u16vector>", v_scm);
  v = SCM_U16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_TypeError("v", "<s32vector>", v_scm);
  v = SCM_S32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_TypeError("v", "<s32vector>", v_scm);
  v = SCM_S32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_TypeError("v", "<u32vector>", v_scm);
  v = SCM_U32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_TypeError("v", "<u32vector>", v_scm);
  v = SCM_U32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S64VECTORP(v_scm)) Scm_TypeError("v", "<s64vector>", v_scm);
  v = SCM_S64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S64VECTORP(v_scm)) Scm_TypeError("v", "<s64vector>", v_scm);
  v = SCM_S64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U64VECTORP(v_scm)) Scm_TypeError("v", "<u64vector>", v_scm);
  v = SCM_U64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U64VECTORP(v_scm)) Scm_TypeError("v", "<u64vector>", v_scm);
  v = SCM_U64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F16VECTORP(v_scm)) Scm_TypeError("v", "<f16vector>", v_scm);
  v = SCM_F16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F16VECTORP(v_scm)) Scm_TypeError("v", "<f16vector>", v_scm);
  v = SCM_F16VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F32VECTORP(v_scm)) Scm_TypeError("v", "<f32vector>", v_scm);
  v = SCM_F32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F32VECTORP(v_scm)) Scm_TypeError("v", "<f32vector>", v_scm);
  v = SCM_F32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F64VECTORP(v_scm)) Scm_TypeError("v", "<f64vector>", v_scm);
  v = SCM_F64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_F64VECTORP(v_scm)) Scm_TypeError("v", "<f64vector>", v_scm);
  v = SCM_F64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C32VECTORP(v_scm)) Scm_TypeError("v", "<c32vector>", v_scm);
  v = SCM_C32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C32VECTORP(v_scm)) Scm_TypeError("v", "<c32vector>", v_scm);
  v = SCM_C32VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C64VECTORP(v_scm)) Scm_TypeError("v", "<c64vector>", v_scm);
  v = SCM_C64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C64VECTORP(v_scm)) Scm_TypeError("v", "<c64vector>", v_scm);
  v = SCM_C64VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C128VECTORP(v_scm)) Scm_TypeError("v", "<c128vector>", v_scm);
  v = SCM_C128VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_C128VECTORP(v_scm)) Scm_TypeError("v", "<c128vector>", v_scm);
  v = SCM_C128VECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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[4];
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_TypeError("v", "<uvector>", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  val_scm = SCM_SUBRARGS[2];
  if (!(val_scm)) Scm_TypeError("val", "scheme object", val_scm);
  val = (val_scm);
  if (SCM_ARGCNT > 3+1) {
    clamp_scm = SCM_SUBRARGS[3];
  } else {
    clamp_scm = SCM_UNBOUND;
  }
  if (!(clamp_scm)) Scm_TypeError("clamp", "scheme object", clamp_scm);
  clamp = (clamp_scm);
  {

#line 372 "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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(v_scm)) Scm_TypeError("v", "<uvector>", v_scm);
  v = SCM_UVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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_TypeError("v", "<uvector>", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
u_long SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_UVECTOR_SIZE(v);
SCM_RESULT_s = Scm_MakeIntegerU(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = Scm_MakeIntegerU(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("v", "<uvector>", v_scm);
  v = SCM_UVECTOR(v_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_UVECTOR_IMMUTABLE_P(v);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("obj", "scheme object", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_UVECTORP(obj);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_U8VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_S8VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_U16VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_S16VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_U32VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_S32VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_U64VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_S64VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_F16VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_F32VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_F64VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_C32VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_C64VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("x", "scheme object", x_scm);
  x = (x_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_C128VECTORP(x);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[5];
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  mem_scm = SCM_SUBRARGS[0];
  if (!(mem_scm)) Scm_TypeError("mem", "scheme object", mem_scm);
  mem = (mem_scm);
  klass_scm = SCM_SUBRARGS[1];
  if (!SCM_CLASSP(klass_scm)) Scm_TypeError("klass", "<class>", klass_scm);
  klass = SCM_CLASS(klass_scm);
  length_scm = SCM_SUBRARGS[2];
  if (!SCM_MAYBE_P(SCM_INTEGERP, length_scm)) Scm_TypeError("length", "exact integer or #f", 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_TypeError("offset", "ScmSmallInt", 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_TypeError("immutable\077", "boolean", immutableP_scm);
  immutableP = SCM_BOOL_VALUE(immutableP_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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

#line 406 "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 = 
#line 410 "libvec.scm"
Scm_MakeViewUVector(SCM_MEMORY_REGION(mem),klass,len,offset,immutableP);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj string_TObytevector(ScmClass* klass,ScmString* s,ScmSmallInt start,ScmSmallInt end,int immutable){{
#line 444 "libvec.scm"
{const ScmStringBody* G1962=SCM_STRING_BODY(s);ScmSize G1963=SCM_STRING_BODY_SIZE(G1962);ScmSize G1964=SCM_STRING_BODY_LENGTH(G1962);const char* G1965=SCM_STRING_BODY_START(G1962);SCM_CHECK_START_END(start,end,((int )(G1964)));;const char* sp=(((start)==(0))?(G1965):(Scm_StringBodyPosition(G1962,start)));const char* ep=(((end)==(G1964))?((G1965)+(G1963)):(Scm_StringBodyPosition(G1962,end)));
{char* buf=NULL;
if (immutable){
buf=(((char* )(sp)));} else {
{
buf=(SCM_NEW_ATOMIC2(char* ,(ep)-(sp)));
memcpy(buf,sp,(ep)-(sp));}}
return (Scm_MakeUVectorFull(klass,((ScmSmallInt )((ep)-(sp))),buf,immutable,NULL));}}}}

static ScmObj libvecstring_TOs8vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj immutableP_scm;
  int immutableP;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("string->s8vector");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  s_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    immutableP_scm = SCM_SUBRARGS[3];
  } else {
    immutableP_scm = SCM_FALSE;
  }
  if (!SCM_BOOLP(immutableP_scm)) Scm_TypeError("immutable\077", "boolean", immutableP_scm);
  immutableP = SCM_BOOL_VALUE(immutableP_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 457 "libvec.scm"
SCM_RESULT = 
#line 457 "libvec.scm"
string_TObytevector(SCM_CLASS_S8VECTOR,s,start,end,immutableP);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecstring_TOu8vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj immutableP_scm;
  int immutableP;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("string->u8vector");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  s_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    immutableP_scm = SCM_SUBRARGS[3];
  } else {
    immutableP_scm = SCM_FALSE;
  }
  if (!SCM_BOOLP(immutableP_scm)) Scm_TypeError("immutable\077", "boolean", immutableP_scm);
  immutableP = SCM_BOOL_VALUE(immutableP_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 462 "libvec.scm"
SCM_RESULT = 
#line 462 "libvec.scm"
string_TObytevector(SCM_CLASS_U8VECTOR,s,start,end,immutableP);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj string_TObytevectorX(ScmUVector* v,ScmSmallInt tstart,ScmString* s,ScmSmallInt start,ScmSmallInt end){{
#line 470 "libvec.scm"
{ScmSmallInt tlen=SCM_UVECTOR_SIZE(v);
if (((tstart)>=(0))&&((tstart)<(tlen))){{
SCM_UVECTOR_CHECK_MUTABLE(v);
{const ScmStringBody* G1966=SCM_STRING_BODY(s);ScmSize G1967=SCM_STRING_BODY_SIZE(G1966);ScmSize G1968=SCM_STRING_BODY_LENGTH(G1966);const char* G1969=SCM_STRING_BODY_START(G1966);SCM_CHECK_START_END(start,end,((int )(G1968)));;const char* sp=(((start)==(0))?(G1969):(Scm_StringBodyPosition(G1966,start)));const char* ep=(((end)==(G1968))?((G1969)+(G1967)):(Scm_StringBodyPosition(G1966,end)));
{char* buf=(((char* )(SCM_UVECTOR_ELEMENTS(v))))+(tstart);
if (((tlen)-(tstart))>((ep)-(sp))){
memcpy(buf,sp,(ep)-(sp));} else {
memcpy(buf,sp,(tlen)-(tstart));}}}}}
return (SCM_OBJ(v));}}}

static ScmObj libvecstring_TOs8vectorX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj tstart_scm;
  ScmSmallInt tstart;
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("string->s8vector!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_TypeError("v", "<s8vector>", v_scm);
  v = SCM_S8VECTOR(v_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_TypeError("tstart", "ScmSmallInt", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 3+1) {
    start_scm = SCM_SUBRARGS[3];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 485 "libvec.scm"
SCM_RESULT = 
#line 485 "libvec.scm"
string_TObytevectorX(SCM_UVECTOR(v),tstart,s,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecstring_TOu8vectorX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj tstart_scm;
  ScmSmallInt tstart;
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("string->u8vector!");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_TypeError("v", "<u8vector>", v_scm);
  v = SCM_U8VECTOR(v_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_TypeError("tstart", "ScmSmallInt", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 3+1) {
    start_scm = SCM_SUBRARGS[3];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 492 "libvec.scm"
SCM_RESULT = 
#line 492 "libvec.scm"
string_TObytevectorX(SCM_UVECTOR(v),tstart,s,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj bytevector_TOstring(ScmUVector* v,ScmSmallInt start,ScmSmallInt end,ScmObj term){{
#line 499 "libvec.scm"
{ScmSmallInt len=SCM_UVECTOR_SIZE(v);
#line 514 "libvec.scm"
SCM_CHECK_START_END(start,end,len);
{int flags=((((SCM_UVECTOR_IMMUTABLE_P(v))&&(
((v)->owner)==(NULL)))&&(
!(((len)>=(256))&&(
((end)-(start))<=((len)/(5))))))?(0):(SCM_STRING_COPYING));
#line 521 "libvec.scm"
if (SCM_INTP(term)){{
{u_char terminator=(255)&(SCM_INT_VALUE(term));ScmSmallInt i;
#line 524 "libvec.scm"
for (i=(start); (i)<(end); (i)++){
if ((terminator)==(
(((u_char* )(SCM_UVECTOR_ELEMENTS(v))))[i])){{
end=(i);
break;}}}}}}
return (Scm_MakeString((((char* )(SCM_UVECTOR_ELEMENTS(v))))+(start),
(end)-(start),-1,flags));}}}}

static ScmObj libvecs8vector_TOstring(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj terminator_scm;
  ScmObj terminator;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("s8vector->string");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S8VECTORP(v_scm)) Scm_TypeError("v", "<s8vector>", v_scm);
  v = SCM_S8VECTOR(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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    terminator_scm = SCM_SUBRARGS[3];
  } else {
    terminator_scm = SCM_FALSE;
  }
  if (!(terminator_scm)) Scm_TypeError("terminator", "scheme object", terminator_scm);
  terminator = (terminator_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 536 "libvec.scm"
SCM_RESULT = 
#line 536 "libvec.scm"
bytevector_TOstring(SCM_UVECTOR(v),start,end,terminator);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecu8vector_TOstring(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj terminator_scm;
  ScmObj terminator;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("u8vector->string");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U8VECTORP(v_scm)) Scm_TypeError("v", "<u8vector>", v_scm);
  v = SCM_U8VECTOR(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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    terminator_scm = SCM_SUBRARGS[3];
  } else {
    terminator_scm = SCM_FALSE;
  }
  if (!(terminator_scm)) Scm_TypeError("terminator", "scheme object", terminator_scm);
  terminator = (terminator_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 542 "libvec.scm"
SCM_RESULT = 
#line 542 "libvec.scm"
bytevector_TOstring(SCM_UVECTOR(v),start,end,terminator);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj string_TOwordvector(ScmClass* klass,ScmString* s,ScmSmallInt start,ScmSmallInt end,ScmObj endian){{
#line 548 "libvec.scm"
if (!(SCM_SYMBOLP(endian))){{
endian=(Scm_DefaultEndian());}}
{const ScmStringBody* G1970=SCM_STRING_BODY(s);ScmSize G1971=SCM_STRING_BODY_SIZE(G1970);ScmSize G1972=SCM_STRING_BODY_LENGTH(G1970);const char* G1973=SCM_STRING_BODY_START(G1970);SCM_CHECK_START_END(start,end,((int )(G1972)));;const char* sp=(((start)==(0))?(G1973):(Scm_StringBodyPosition(G1970,start)));const char* ep=(((end)==(G1972))?((G1973)+(G1971)):(Scm_StringBodyPosition(G1970,end)));
{ScmObj v=Scm_MakeUVector(klass,(end)-(start),NULL);uint32_t* eltp=
((uint32_t* )(SCM_UVECTOR_ELEMENTS(v)));ScmSmallInt i=0;int do_swap=
#line 554 "libvec.scm"
SWAP_REQUIRED(endian);
for (; (sp)<(ep); (i)++){
{ScmChar ch;
SCM_CHAR_GET(sp,ch);
if (do_swap){
{swap_u32_t v;
(v).val=(((uint32_t )(ch)));
SWAP_4(v);
(eltp)[i]=((v).val);}} else {
(eltp)[i]=(((uint32_t )(ch)));}
(sp)+=(SCM_CHAR_NBYTES(ch));}}
return (v);}}}}

static ScmObj libvecstring_TOs32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("string->s32vector");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  s_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    endian_scm = SCM_SUBRARGS[3];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 571 "libvec.scm"
SCM_RESULT = 
#line 571 "libvec.scm"
string_TOwordvector(SCM_CLASS_S32VECTOR,s,start,end,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecstring_TOu32vector(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("string->u32vector");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  s_scm = SCM_SUBRARGS[0];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    endian_scm = SCM_SUBRARGS[3];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 577 "libvec.scm"
SCM_RESULT = 
#line 577 "libvec.scm"
string_TOwordvector(SCM_CLASS_U32VECTOR,s,start,end,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj string_TOwordvectorX(ScmUVector* v,ScmSmallInt tstart,ScmString* s,ScmSmallInt start,ScmSmallInt end,ScmObj endian){{
#line 586 "libvec.scm"
if (!(SCM_SYMBOLP(endian))){{
endian=(Scm_DefaultEndian());}}
{ScmSmallInt tlen=SCM_UVECTOR_SIZE(v);
if (((tstart)>=(0))&&((tstart)<(tlen))){{
SCM_UVECTOR_CHECK_MUTABLE(v);
{const ScmStringBody* G1974=SCM_STRING_BODY(s);ScmSize G1975=SCM_STRING_BODY_SIZE(G1974);ScmSize G1976=SCM_STRING_BODY_LENGTH(G1974);const char* G1977=SCM_STRING_BODY_START(G1974);SCM_CHECK_START_END(start,end,((int )(G1976)));;const char* sp=(((start)==(0))?(G1977):(Scm_StringBodyPosition(G1974,start)));const char* ep=(((end)==(G1976))?((G1977)+(G1975)):(Scm_StringBodyPosition(G1974,end)));
{uint32_t* buf=((uint32_t* )(SCM_UVECTOR_ELEMENTS(v)));ScmSmallInt i=tstart;int do_swap=
#line 594 "libvec.scm"
SWAP_REQUIRED(endian);
for (; ((sp)<(ep))&&((i)<(tlen)); (i)++){
{ScmChar ch;
SCM_CHAR_GET(sp,ch);
if (do_swap){
{swap_u32_t v;
(v).val=(((uint32_t )(ch)));
SWAP_4(v);
(buf)[i]=((v).val);}} else {
(buf)[i]=(((uint32_t )(ch)));}
(sp)+=(SCM_CHAR_NBYTES(ch));}}}}}}
return (SCM_OBJ(v));}}}

static ScmObj libvecstring_TOs32vectorX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj tstart_scm;
  ScmSmallInt tstart;
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[6];
  SCM_ENTER_SUBR("string->s32vector!");
  if (SCM_ARGCNT >= 7
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 6 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);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_TypeError("v", "<s32vector>", v_scm);
  v = SCM_S32VECTOR(v_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_TypeError("tstart", "ScmSmallInt", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 3+1) {
    start_scm = SCM_SUBRARGS[3];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 5+1) {
    endian_scm = SCM_SUBRARGS[5];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 613 "libvec.scm"
SCM_RESULT = 
#line 613 "libvec.scm"
string_TOwordvectorX(SCM_UVECTOR(v),tstart,s,start,end,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecstring_TOu32vectorX(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj tstart_scm;
  ScmSmallInt tstart;
  ScmObj s_scm;
  ScmString* s;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[6];
  SCM_ENTER_SUBR("string->u32vector!");
  if (SCM_ARGCNT >= 7
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 6 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);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_TypeError("v", "<u32vector>", v_scm);
  v = SCM_U32VECTOR(v_scm);
  tstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(tstart_scm)) Scm_TypeError("tstart", "ScmSmallInt", tstart_scm);
  tstart = SCM_INT_VALUE(tstart_scm);
  s_scm = SCM_SUBRARGS[2];
  if (!SCM_STRINGP(s_scm)) Scm_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  if (SCM_ARGCNT > 3+1) {
    start_scm = SCM_SUBRARGS[3];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 5+1) {
    endian_scm = SCM_SUBRARGS[5];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 621 "libvec.scm"
SCM_RESULT = 
#line 621 "libvec.scm"
string_TOwordvectorX(SCM_UVECTOR(v),tstart,s,start,end,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

static ScmObj wordvector_TOstring(ScmUVector* v,ScmSmallInt start,ScmSmallInt end,ScmObj term,ScmObj endian){{
#line 629 "libvec.scm"
if (!(SCM_SYMBOLP(endian))){{
endian=(Scm_DefaultEndian());}}
{ScmSmallInt len=SCM_UVECTOR_SIZE(v);ScmObj s=
Scm_MakeOutputStringPort(FALSE);int do_swap=
SWAP_REQUIRED(endian);
SCM_CHECK_START_END(start,end,len);
{int32_t* eltp=((int32_t* )(SCM_UVECTOR_ELEMENTS(v)));
while((start)<(end)){
{ScmChar ch;uint32_t val=
(eltp)[(start)++];
if (do_swap){
{swap_u32_t v;
(v).val=(val);
SWAP_4(v);
ch=(((ScmChar )((v).val)));}} else {
ch=(((ScmChar )(val)));}
if ((SCM_INTP(term))&&(
(SCM_INT_VALUE(term))==(ch))){{
break;}}
Scm_PutcUnsafe(ch,SCM_PORT(s));}}}
return (Scm_GetOutputStringUnsafe(SCM_PORT(s),0));}}}

static ScmObj libvecs32vector_TOstring(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj terminator_scm;
  ScmObj terminator;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("s32vector->string");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_S32VECTORP(v_scm)) Scm_TypeError("v", "<s32vector>", v_scm);
  v = SCM_S32VECTOR(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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    terminator_scm = SCM_SUBRARGS[3];
  } else {
    terminator_scm = SCM_FALSE;
  }
  if (!(terminator_scm)) Scm_TypeError("terminator", "scheme object", terminator_scm);
  terminator = (terminator_scm);
  if (SCM_ARGCNT > 4+1) {
    endian_scm = SCM_SUBRARGS[4];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 656 "libvec.scm"
SCM_RESULT = 
#line 656 "libvec.scm"
wordvector_TOstring(SCM_UVECTOR(v),start,end,terminator,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecu32vector_TOstring(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmUVector* v;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj terminator_scm;
  ScmObj terminator;
  ScmObj endian_scm;
  ScmObj endian;
  ScmObj SCM_SUBRARGS[5];
  SCM_ENTER_SUBR("u32vector->string");
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_U32VECTORP(v_scm)) Scm_TypeError("v", "<u32vector>", v_scm);
  v = SCM_U32VECTOR(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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  if (SCM_ARGCNT > 3+1) {
    terminator_scm = SCM_SUBRARGS[3];
  } else {
    terminator_scm = SCM_FALSE;
  }
  if (!(terminator_scm)) Scm_TypeError("terminator", "scheme object", terminator_scm);
  terminator = (terminator_scm);
  if (SCM_ARGCNT > 4+1) {
    endian_scm = SCM_SUBRARGS[4];
  } else {
    endian_scm = SCM_UNBOUND;
  }
  if (!(endian_scm)) Scm_TypeError("endian", "scheme object", endian_scm);
  endian = (endian_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 663 "libvec.scm"
SCM_RESULT = 
#line 663 "libvec.scm"
wordvector_TOstring(SCM_UVECTOR(v),start,end,terminator,endian);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("obj", "scheme object", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_BITVECTORP(obj);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  {
{
ScmSmallInt SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = SCM_BITVECTOR_SIZE(v);
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecbitvector_any_valueP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj bit_scm;
  ScmObj bit;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("bitvector-any-value?");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  bit_scm = SCM_SUBRARGS[1];
  if (!(bit_scm)) Scm_TypeError("bit", "scheme object", bit_scm);
  bit = (bit_scm);
  if (SCM_ARGCNT > 2+1) {
    start_scm = SCM_SUBRARGS[2];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 678 "libvec.scm"
{int b=Scm_Bit2Int(bit);
SCM_CHECK_START_END(start,end,SCM_BITVECTOR_SIZE(v));
if (b){
SCM_RESULT = 
#line 681 "libvec.scm"
Scm_BitsAny(SCM_BITVECTOR_BITS(v),start,end);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;} else {
SCM_RESULT = 
#line 682 "libvec.scm"
!(Scm_BitsEvery(SCM_BITVECTOR_BITS(v),start,end));
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecbitvector_every_valueP(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj v_scm;
  ScmBitvector* v;
  ScmObj bit_scm;
  ScmObj bit;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[4];
  SCM_ENTER_SUBR("bitvector-every-value?");
  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<4; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  bit_scm = SCM_SUBRARGS[1];
  if (!(bit_scm)) Scm_TypeError("bit", "scheme object", bit_scm);
  bit = (bit_scm);
  if (SCM_ARGCNT > 2+1) {
    start_scm = SCM_SUBRARGS[2];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 688 "libvec.scm"
{int b=Scm_Bit2Int(bit);
SCM_CHECK_START_END(start,end,SCM_BITVECTOR_SIZE(v));
if (b){
SCM_RESULT = 
#line 691 "libvec.scm"
Scm_BitsEvery(SCM_BITVECTOR_BITS(v),start,end);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;} else {
SCM_RESULT = 
#line 692 "libvec.scm"
!(Scm_BitsAny(SCM_BITVECTOR_BITS(v),start,end));
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[2];
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  len_scm = SCM_SUBRARGS[0];
  if (!SCM_INTP(len_scm)) Scm_TypeError("len", "ScmSmallInt", 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_TypeError("init", "scheme object", init_scm);
  init = (init_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_MakeBitvector(len,init);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[1];
  SCM_ENTER_SUBR("bitvector");
  for (int SCM_i=0; SCM_i<1; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bits_scm = SCM_SUBRARGS[SCM_ARGCNT-1];
  if (!SCM_LISTP(bits_scm)) Scm_TypeError("bits", "list", bits_scm);
  bits = (bits_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_ListToBitvector(bits);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("bits", "scheme object", bits_scm);
  bits = (bits_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_ListToBitvector(bits);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("s", "<string>", s_scm);
  s = SCM_STRING(s_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

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


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_TypeError("bit", "scheme object", bit_scm);
  bit = (bit_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_Bit2Int(bit);
SCM_RESULT_s = Scm_MakeInteger(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = Scm_MakeInteger(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("bit", "scheme object", bit_scm);
  bit = (bit_scm);
  {
{
int SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_Bit2Int(bit);
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_BOOL(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", i_scm);
  i = SCM_INT_VALUE(i_scm);
  b_scm = SCM_SUBRARGS[2];
  if (!(b_scm)) Scm_TypeError("b", "scheme object", b_scm);
  b = (b_scm);
  {

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

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

#line 711 "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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 718 "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;
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}}}

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_TypeError("v", "<bitvector>", v_scm);
  v = SCM_BITVECTOR(v_scm);
  i_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(i_scm)) Scm_TypeError("i", "ScmSmallInt", 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_TypeError("fallback", "scheme object", fallback_scm);
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 729 "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;
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}}}

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


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[3];
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  v_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(v_scm)) Scm_TypeError("v", "<bitvector>", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_BitvectorCopy(v,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


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[5];
  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<5; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  dest_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(dest_scm)) Scm_TypeError("dest", "<bitvector>", dest_scm);
  dest = SCM_BITVECTOR(dest_scm);
  dstart_scm = SCM_SUBRARGS[1];
  if (!SCM_INTP(dstart_scm)) Scm_TypeError("dstart", "ScmSmallInt", dstart_scm);
  dstart = SCM_INT_VALUE(dstart_scm);
  src_scm = SCM_SUBRARGS[2];
  if (!SCM_BITVECTORP(src_scm)) Scm_TypeError("src", "<bitvector>", 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_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;
SCM_RESULT = Scm_BitvectorCopyX(dest,dstart,src,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecbitvector_word_bits(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  SCM_ENTER_SUBR("bitvector-word-bits");
  {
{
ScmSmallInt SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 748 "libvec.scm"
SCM_RESULT = 
#line 748 "libvec.scm"
(CHAR_BIT)*(sizeof(ScmBits));
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_MAKE_INT(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecbitvector_TOuvector_2fshared(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj bv_scm;
  ScmBitvector* bv;
  ScmObj klass_scm;
  ScmClass* klass;
  ScmObj SCM_SUBRARGS[2];
  SCM_ENTER_SUBR("bitvector->uvector/shared");
  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<2; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  bv_scm = SCM_SUBRARGS[0];
  if (!SCM_BITVECTORP(bv_scm)) Scm_TypeError("bv", "<bitvector>", bv_scm);
  bv = SCM_BITVECTOR(bv_scm);
  if (SCM_ARGCNT > 1+1) {
    klass_scm = SCM_SUBRARGS[1];
  } else {
    klass_scm = SCM_FALSE;
  }
  if (!SCM_MAYBE_P(SCM_CLASSP, klass_scm)) Scm_TypeError("klass", "<class> or #f", klass_scm);
  klass = SCM_MAYBE(SCM_CLASS, klass_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 752 "libvec.scm"
{ScmClass* k=((klass)?(klass):(SCM_CLASS_U8VECTOR));
SCM_RESULT = 
#line 753 "libvec.scm"
Scm_BitvectorToUVectorShared(bv,k);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;}
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}


static ScmObj libvecuvector_TObitvector_2fshared(ScmObj *SCM_FP SCM_UNUSED, int SCM_ARGCNT SCM_UNUSED, void *data_ SCM_UNUSED)
{
  ScmObj uv_scm;
  ScmUVector* uv;
  ScmObj start_scm;
  ScmSmallInt start;
  ScmObj end_scm;
  ScmSmallInt end;
  ScmObj SCM_SUBRARGS[3];
  SCM_ENTER_SUBR("uvector->bitvector/shared");
  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<3; SCM_i++) {
    SCM_SUBRARGS[SCM_i] = SCM_ARGREF(SCM_i);
  }
  uv_scm = SCM_SUBRARGS[0];
  if (!SCM_UVECTORP(uv_scm)) Scm_TypeError("uv", "<uvector>", uv_scm);
  uv = SCM_UVECTOR(uv_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_SUBRARGS[1];
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_TypeError("start", "ScmSmallInt", 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_TypeError("end", "ScmSmallInt", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj SCM_RESULT_s;

#line 758 "libvec.scm"
SCM_RESULT = 
#line 758 "libvec.scm"
Scm_UVectorToBitvectorShared(uv,start,end);
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
goto SCM_STUB_RETURN;
SCM_STUB_RETURN:
SCM_RESULT_s = SCM_OBJ_SAFE(SCM_RESULT);
goto SCM_STUB_RETURN_BOXED;
SCM_STUB_RETURN_BOXED:
SCM_RETURN(SCM_RESULT_s);
}
  }
}

#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 814 "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 822 "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 830 "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 838 "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 846 "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 854 "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 862 "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 870 "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 878 "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 886 "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 894 "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 902 "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 910 "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 918 "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[] = {
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[2])),
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[4])),
 NULL /*termination*/
};
ScmObj SCM_debug_info_const_vector()
{
  static _Bool initialized = FALSE;
  if (!initialized) {
    int i = 0;
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[145];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[146];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[68];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[148];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[69];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[149];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[40];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[104];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[143];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1044];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = SCM_OBJ(&scm__sc.d1944[61]);
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[142];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[161];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[164];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[157];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[31];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[155];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = SCM_OBJ(&scm__sc.d1944[46]);
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[42];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[28];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[140];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[141];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1045];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1046];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1047];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1048];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1049];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[5];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[138];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[180];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[189];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[109];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[190];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[182];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[55];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[191];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[188];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[183];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = SCM_OBJ(&scm__sc.d1944[77]);
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[186];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[184];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[181];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[178];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[175];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[177];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[179];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[187];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1050];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1051];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1052];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[1053];
    SCM_VECTOR_ELEMENT(SCM_OBJ(&scm__rc.d1945[990]), i++) = scm__rc.d1945[173];
    initialized = TRUE;
  }
  return SCM_OBJ(&scm__rc.d1945[990]);
}
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.d1945[0] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[0])),TRUE); /* vector */
  scm__rc.d1945[1] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1944[1]))); /* :rest */
  scm__rc.d1945[2] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[2])),TRUE); /* args */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1]), scm__rc.d1945[2]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[2]), scm__rc.d1945[1]);
  scm__rc.d1945[3] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[3])),TRUE); /* source-info */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[5]), scm__rc.d1945[3]);
  scm__rc.d1945[4] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[5])),TRUE); /* bind-info */
  scm__rc.d1945[5] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[6])),TRUE); /* scheme */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[6]), scm__rc.d1945[0]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[7]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[8]), scm__rc.d1945[4]);
  scm__rc.d1945[6] = Scm_MakeExtendedPair(scm__rc.d1945[0], SCM_OBJ(&scm__rc.d1946[2]), SCM_OBJ(&scm__rc.d1946[10]));
  scm__rc.d1945[7] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[7])),TRUE); /* * */
  scm__rc.d1945[8] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[8])),TRUE); /* -> */
  scm__rc.d1945[9] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[9])),TRUE); /* <top> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[10]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[10]))[4] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[10]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[10]))[6] = scm__rc.d1945[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.d1945[6];
  libvecvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[10]);
  scm__rc.d1945[17] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[10])),TRUE); /* vector? */
  scm__rc.d1945[18] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[11])),TRUE); /* obj */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[11]), scm__rc.d1945[18]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[14]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[15]), scm__rc.d1945[17]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[16]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[17]), scm__rc.d1945[4]);
  scm__rc.d1945[19] = Scm_MakeExtendedPair(scm__rc.d1945[17], SCM_OBJ(&scm__rc.d1946[11]), SCM_OBJ(&scm__rc.d1946[19]));
  scm__rc.d1945[20] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[12])),TRUE); /* <boolean> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[21]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[21]))[4] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[21]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[21]))[6] = scm__rc.d1945[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.d1945[19];
  libvecvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[21]);
  scm__rc.d1945[28] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[13])),TRUE); /* vector-length */
  scm__rc.d1945[29] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[14])),TRUE); /* vec */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[20]), scm__rc.d1945[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[23]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[24]), scm__rc.d1945[28]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[25]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[26]), scm__rc.d1945[4]);
  scm__rc.d1945[30] = Scm_MakeExtendedPair(scm__rc.d1945[28], SCM_OBJ(&scm__rc.d1946[20]), SCM_OBJ(&scm__rc.d1946[28]));
  scm__rc.d1945[31] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[15])),TRUE); /* <vector> */
  scm__rc.d1945[32] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[16])),TRUE); /* <fixnum> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[33]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[33]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[33]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[33]))[6] = scm__rc.d1945[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.d1945[30];
  libvecvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[33]);
  scm__rc.d1945[40] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[17])),TRUE); /* vector-ref */
  scm__rc.d1945[41] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[18])),TRUE); /* k */
  scm__rc.d1945[42] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1944[19]))); /* :optional */
  scm__rc.d1945[43] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[20])),TRUE); /* fallback */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[29]), scm__rc.d1945[43]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[30]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[31]), scm__rc.d1945[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[32]), scm__rc.d1945[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[35]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[36]), scm__rc.d1945[40]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[37]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[38]), scm__rc.d1945[4]);
  scm__rc.d1945[44] = Scm_MakeExtendedPair(scm__rc.d1945[40], SCM_OBJ(&scm__rc.d1946[32]), SCM_OBJ(&scm__rc.d1946[40]));
  scm__rc.d1945[45] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[21])),TRUE); /* <integer> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[5] = scm__rc.d1945[45];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[46]))[8] = scm__rc.d1945[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.d1945[44];
  libvecvector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[46]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecvector_ref__STUB), SCM_PROCEDURE(&libvecvector_setX__STUB), TRUE);
  scm__rc.d1945[55] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[22])),TRUE); /* vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[41]), scm__rc.d1945[41]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[42]), scm__rc.d1945[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[45]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[46]), scm__rc.d1945[55]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[47]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[48]), scm__rc.d1945[4]);
  scm__rc.d1945[56] = Scm_MakeExtendedPair(scm__rc.d1945[55], SCM_OBJ(&scm__rc.d1946[42]), SCM_OBJ(&scm__rc.d1946[50]));
  scm__rc.d1945[57] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[23])),TRUE); /* <void> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[5] = scm__rc.d1945[45];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[58]))[8] = scm__rc.d1945[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.d1945[56];
  libvecvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[58]);
  scm__rc.d1945[67] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[24])),TRUE); /* vector->list */
  scm__rc.d1945[68] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[25])),TRUE); /* start */
  scm__rc.d1945[69] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[26])),TRUE); /* end */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[51]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[52]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[53]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[54]), scm__rc.d1945[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[57]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[58]), scm__rc.d1945[67]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[59]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[60]), scm__rc.d1945[4]);
  scm__rc.d1945[70] = Scm_MakeExtendedPair(scm__rc.d1945[67], SCM_OBJ(&scm__rc.d1946[54]), SCM_OBJ(&scm__rc.d1946[62]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[71]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[71]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[71]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[71]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[71]))[7] = scm__rc.d1945[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.d1945[70];
  libvecvector_TOlist__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[71]);
  scm__rc.d1945[79] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[27])),TRUE); /* list->vector */
  scm__rc.d1945[80] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[28])),TRUE); /* list */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[63]), scm__rc.d1945[80]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[66]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[67]), scm__rc.d1945[79]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[68]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[69]), scm__rc.d1945[4]);
  scm__rc.d1945[81] = Scm_MakeExtendedPair(scm__rc.d1945[79], SCM_OBJ(&scm__rc.d1946[63]), SCM_OBJ(&scm__rc.d1946[71]));
  scm__rc.d1945[82] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[29])),TRUE); /* <list> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[83]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[83]))[4] = scm__rc.d1945[82];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[83]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[83]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[83]))[7] = scm__rc.d1945[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.d1945[81];
  libveclist_TOvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[83]);
  scm__rc.d1945[91] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[30])),TRUE); /* vector-fill! */
  scm__rc.d1945[92] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[31])),TRUE); /* fill */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[72]), scm__rc.d1945[92]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[73]), scm__rc.d1945[29]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[76]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[77]), scm__rc.d1945[91]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[78]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[79]), scm__rc.d1945[4]);
  scm__rc.d1945[93] = Scm_MakeExtendedPair(scm__rc.d1945[91], SCM_OBJ(&scm__rc.d1946[73]), SCM_OBJ(&scm__rc.d1946[81]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[5] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[94]))[8] = scm__rc.d1945[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.d1945[93];
  libvecvector_fillX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[94]);
  scm__rc.d1945[103] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[32])),TRUE); /* vector-copy */
  scm__rc.d1945[104] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[33])),TRUE); /* v */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[82]), scm__rc.d1945[92]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[83]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[84]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[85]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[86]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[89]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[90]), scm__rc.d1945[103]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[91]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[92]), scm__rc.d1945[4]);
  scm__rc.d1945[105] = Scm_MakeExtendedPair(scm__rc.d1945[103], SCM_OBJ(&scm__rc.d1946[86]), SCM_OBJ(&scm__rc.d1946[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.d1945[105];
  libvecvector_copy__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[71]);
  scm__rc.d1945[106] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[34])),TRUE); /* vector-copy! */
  scm__rc.d1945[107] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[35])),TRUE); /* t */
  scm__rc.d1945[108] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[36])),TRUE); /* tstart */
  scm__rc.d1945[109] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[37])),TRUE); /* s */
  scm__rc.d1945[110] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[38])),TRUE); /* sstart */
  scm__rc.d1945[111] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[39])),TRUE); /* send */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[95]), scm__rc.d1945[111]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[96]), scm__rc.d1945[110]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[97]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[98]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[99]), scm__rc.d1945[108]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[100]), scm__rc.d1945[107]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[103]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[104]), scm__rc.d1945[106]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[105]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[106]), scm__rc.d1945[4]);
  scm__rc.d1945[112] = Scm_MakeExtendedPair(scm__rc.d1945[106], SCM_OBJ(&scm__rc.d1946[100]), SCM_OBJ(&scm__rc.d1946[108]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[3] = scm__rc.d1945[5];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[6] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[113]))[9] = scm__rc.d1945[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.d1945[112];
  libvecvector_copyX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[113]);
  scm__rc.d1945[123] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[40])),TRUE); /* vector-append */
  scm__rc.d1945[124] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[41])),TRUE); /* vecs */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[109]), scm__rc.d1945[124]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[110]), scm__rc.d1945[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[113]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[114]), scm__rc.d1945[123]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[115]), scm__rc.d1945[5]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[116]), scm__rc.d1945[4]);
  scm__rc.d1945[125] = Scm_MakeExtendedPair(scm__rc.d1945[123], SCM_OBJ(&scm__rc.d1946[110]), SCM_OBJ(&scm__rc.d1946[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.d1945[125];
  libvecvector_append__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[10]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1945[126] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[42])),TRUE); /* vector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[119]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[122]), scm__rc.d1945[3]);
  scm__rc.d1945[127] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[43])),TRUE); /* gauche */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[123]), scm__rc.d1945[126]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[124]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[125]), scm__rc.d1945[4]);
  scm__rc.d1945[128] = Scm_MakeExtendedPair(scm__rc.d1945[126], SCM_OBJ(&scm__rc.d1946[119]), SCM_OBJ(&scm__rc.d1946[127]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[129]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[129]))[4] = scm__rc.d1945[31];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[129]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[129]))[6] = scm__rc.d1945[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.d1945[128];
  libvecvector_immutableP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[129]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1945[137] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[44])),TRUE); /* %expression-name-mark-key */
  scm__rc.d1945[136] = Scm_MakeIdentifier(scm__rc.d1945[137], SCM_MODULE(Scm_GaucheInternalModule()), SCM_NIL); /* gauche.internal#%expression-name-mark-key */
  scm__rc.d1945[138] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[45])),TRUE); /* vector->string */
  scm__rc.d1945[139] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[47])),TRUE); /* lambda */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[129]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[130]), scm__rc.d1945[28]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[132]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[135]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[136]), scm__rc.d1945[104]);
  scm__rc.d1945[140] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[48])),TRUE); /* assume-type */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[137]), scm__rc.d1945[31]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[138]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[139]), scm__rc.d1945[140]);
  scm__rc.d1945[141] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[49])),TRUE); /* assume */
  scm__rc.d1945[142] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[50])),TRUE); /* exact-integer? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[140]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[141]), scm__rc.d1945[142]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[143]), scm__rc.d1945[141]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[144]), scm__rc.d1945[142]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[146]), scm__rc.d1945[141]);
  scm__rc.d1945[143] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[51])),TRUE); /* with-output-to-string */
  scm__rc.d1945[144] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[52])),TRUE); /* ^ */
  scm__rc.d1945[145] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[53])),TRUE); /* do */
  scm__rc.d1945[146] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[54])),TRUE); /* i */
  scm__rc.d1945[147] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[55])),TRUE); /* + */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[148]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[149]), scm__rc.d1945[147]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[151]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[152]), scm__rc.d1945[146]);
  scm__rc.d1945[148] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[56])),TRUE); /* >= */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[154]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[155]), scm__rc.d1945[148]);
  scm__rc.d1945[149] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[57])),TRUE); /* write-char */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[157]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[158]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[159]), scm__rc.d1945[40]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[161]), scm__rc.d1945[149]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[165]), scm__rc.d1945[145]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[168]), scm__rc.d1945[144]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[170]), scm__rc.d1945[143]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[176]), scm__rc.d1945[139]);
  scm__rc.d1945[151] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[58])),TRUE); /* error */
  scm__rc.d1945[150] = Scm_MakeIdentifier(scm__rc.d1945[151], SCM_MODULE(Scm_GaucheModule()), SCM_NIL); /* gauche#error */
  scm__rc.d1945[153] = SCM_OBJ(Scm_FindModule(SCM_SYMBOL(scm__rc.d1945[127]), SCM_FIND_MODULE_CREATE|SCM_FIND_MODULE_PLACEHOLDING)); /* module gauche */
  scm__rc.d1945[152] = Scm_MakeIdentifier(scm__rc.d1945[31], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#<vector> */
  scm__rc.d1945[155] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[59])),TRUE); /* of-type? */
  scm__rc.d1945[154] = Scm_MakeIdentifier(scm__rc.d1945[155], SCM_MODULE(Scm_GaucheModule()), SCM_NIL); /* gauche#of-type? */
  scm__rc.d1945[157] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[60])),TRUE); /* type-error */
  scm__rc.d1945[156] = Scm_MakeIdentifier(scm__rc.d1945[157], SCM_MODULE(Scm_GaucheModule()), SCM_NIL); /* gauche#type-error */
  scm__rc.d1945[158] = Scm_MakeIdentifier(scm__rc.d1945[142], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#exact-integer? */
  scm__rc.d1945[159] = SCM_OBJ(Scm_MakeBox(SCM_FALSE));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[177]), scm__rc.d1945[159]);
  scm__rc.d1945[161] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[62])),TRUE); /* format-internal */
  scm__rc.d1945[163] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[63])),TRUE); /* gauche.format */
  scm__rc.d1945[162] = SCM_OBJ(Scm_FindModule(SCM_SYMBOL(scm__rc.d1945[163]), SCM_FIND_MODULE_CREATE|SCM_FIND_MODULE_PLACEHOLDING)); /* module gauche.format */
  scm__rc.d1945[160] = Scm_MakeIdentifier(scm__rc.d1945[161], SCM_MODULE(scm__rc.d1945[162]), SCM_NIL); /* gauche.format#format-internal */
  scm__rc.d1945[164] = SCM_OBJ(Scm_MakeBox(SCM_FALSE));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[180]), scm__rc.d1945[164]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[184]), scm__rc.d1945[138]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[187]), scm__rc.d1945[3]);
  scm__rc.d1945[165] = Scm_MakeExtendedPair(SCM_OBJ(&scm__rc.d1946[184]), SCM_NIL, SCM_OBJ(&scm__rc.d1946[188]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[189]), scm__rc.d1945[165]);
  scm__rc.d1945[166] = Scm_MakePackedDebugInfo(SCM_U8VECTOR(SCM_OBJ(&scm__rc.d1955[0])),SCM_debug_info_const_vector);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[0]))->debugInfo = scm__rc.d1945[166];
  scm__rc.d1945[167] = Scm_MakeIdentifier(scm__rc.d1945[143], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#with-output-to-string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[192]), scm__rc.d1945[3]);
  scm__rc.d1945[168] = Scm_MakeExtendedPair(scm__rc.d1945[138], SCM_OBJ(&scm__rc.d1946[136]), SCM_OBJ(&scm__rc.d1946[193]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[194]), scm__rc.d1945[168]);
  scm__rc.d1945[169] = Scm_MakePackedDebugInfo(SCM_U8VECTOR(SCM_OBJ(&scm__rc.d1955[1])),SCM_debug_info_const_vector);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[1]))->name = scm__rc.d1945[138];/* vector->string */
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[1]))->debugInfo = scm__rc.d1945[169];
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[45] = SCM_WORD(scm__rc.d1945[150]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[50] = SCM_WORD(scm__rc.d1945[152]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[52] = SCM_WORD(scm__rc.d1945[154]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[61] = SCM_WORD(scm__rc.d1945[104]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[63] = SCM_WORD(scm__rc.d1945[152]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[66] = SCM_WORD(scm__rc.d1945[156]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[71] = SCM_WORD(scm__rc.d1945[158]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[88] = SCM_WORD(scm__rc.d1945[160]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[90] = SCM_WORD(scm__rc.d1945[150]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[95] = SCM_WORD(scm__rc.d1945[158]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[112] = SCM_WORD(scm__rc.d1945[160]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[114] = SCM_WORD(scm__rc.d1945[150]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[15]))[118] = SCM_WORD(scm__rc.d1945[167]);
  scm__rc.d1945[170] = Scm_MakeIdentifier(scm__rc.d1945[138], SCM_MODULE(Scm_SchemeModule()), SCM_NIL); /* scheme#vector->string */
  scm__rc.d1945[171] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[64])),TRUE); /* %toplevel */
  scm__rc.d1945[172] = Scm_MakePackedDebugInfo(SCM_U8VECTOR(SCM_OBJ(&scm__rc.d1955[2])),SCM_debug_info_const_vector);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[2]))->name = scm__rc.d1945[171];/* %toplevel */
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[2]))->debugInfo = scm__rc.d1945[172];
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[135]))[3] = SCM_WORD(scm__rc.d1945[136]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[135]))[6] = SCM_WORD(scm__rc.d1945[138]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[135]))[13] = SCM_WORD(scm__rc.d1945[170]);
  scm__rc.d1945[173] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[65])),TRUE); /* string->vector */
  scm__rc.d1945[175] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[66])),TRUE); /* string-cursor-start */
  scm__rc.d1945[174] = Scm_MakeIdentifier(scm__rc.d1945[175], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-cursor-start */
  scm__rc.d1945[177] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[67])),TRUE); /* string-cursor-end */
  scm__rc.d1945[176] = Scm_MakeIdentifier(scm__rc.d1945[177], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-cursor-end */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[195]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[196]), scm__rc.d1945[175]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[198]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[199]), scm__rc.d1945[177]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[201]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[204]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[205]), scm__rc.d1945[109]);
  scm__rc.d1945[178] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[68])),TRUE); /* <string> */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[206]), scm__rc.d1945[178]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[207]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[208]), scm__rc.d1945[140]);
  scm__rc.d1945[179] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[69])),TRUE); /* let* */
  scm__rc.d1945[180] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[70])),TRUE); /* ss */
  scm__rc.d1945[181] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[71])),TRUE); /* string-index->cursor */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[209]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[210]), scm__rc.d1945[181]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[212]), scm__rc.d1945[180]);
  scm__rc.d1945[182] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[72])),TRUE); /* ee */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[213]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[214]), scm__rc.d1945[181]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[216]), scm__rc.d1945[182]);
  scm__rc.d1945[183] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[73])),TRUE); /* size */
  scm__rc.d1945[184] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[74])),TRUE); /* string-cursor-diff */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[217]), scm__rc.d1945[182]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[218]), scm__rc.d1945[180]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[219]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[220]), scm__rc.d1945[184]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[222]), scm__rc.d1945[183]);
  scm__rc.d1945[185] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[75])),TRUE); /* when */
  scm__rc.d1945[186] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[76])),TRUE); /* < */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[226]), scm__rc.d1945[183]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[227]), scm__rc.d1945[186]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[228]), scm__rc.d1945[80]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[231]), scm__rc.d1945[151]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[234]), scm__rc.d1945[185]);
  scm__rc.d1945[187] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[78])),TRUE); /* rlet1 */
  scm__rc.d1945[188] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[79])),TRUE); /* make-vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[235]), scm__rc.d1945[183]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[236]), scm__rc.d1945[188]);
  scm__rc.d1945[189] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[80])),TRUE); /* string-cursor-next */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[237]), scm__rc.d1945[180]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[238]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[239]), scm__rc.d1945[189]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[241]), scm__rc.d1945[180]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[242]), scm__rc.d1945[180]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[244]), scm__rc.d1945[146]);
  scm__rc.d1945[190] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[81])),TRUE); /* string-cursor>=? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[247]), scm__rc.d1945[190]);
  scm__rc.d1945[191] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[82])),TRUE); /* string-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[249]), scm__rc.d1945[191]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[251]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[252]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[253]), scm__rc.d1945[55]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[257]), scm__rc.d1945[145]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[260]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[261]), scm__rc.d1945[187]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[265]), scm__rc.d1945[179]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[269]), scm__rc.d1945[139]);
  scm__rc.d1945[192] = Scm_MakeIdentifier(scm__rc.d1945[178], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#<string> */
  scm__rc.d1945[193] = Scm_MakeIdentifier(scm__rc.d1945[181], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-index->cursor */
  scm__rc.d1945[194] = Scm_MakeIdentifier(scm__rc.d1945[184], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-cursor-diff */
  scm__rc.d1945[195] = Scm_MakeIdentifier(scm__rc.d1945[151], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#error */
  scm__rc.d1945[196] = Scm_MakeIdentifier(scm__rc.d1945[188], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#make-vector */
  scm__rc.d1945[197] = Scm_MakeIdentifier(scm__rc.d1945[190], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-cursor>=? */
  scm__rc.d1945[198] = Scm_MakeIdentifier(scm__rc.d1945[191], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-ref */
  scm__rc.d1945[199] = Scm_MakeIdentifier(scm__rc.d1945[189], SCM_MODULE(scm__rc.d1945[153]), SCM_NIL); /* gauche#string-cursor-next */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[272]), scm__rc.d1945[3]);
  scm__rc.d1945[200] = Scm_MakeExtendedPair(scm__rc.d1945[173], SCM_OBJ(&scm__rc.d1946[205]), SCM_OBJ(&scm__rc.d1946[273]));
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[274]), scm__rc.d1945[200]);
  scm__rc.d1945[201] = Scm_MakePackedDebugInfo(SCM_U8VECTOR(SCM_OBJ(&scm__rc.d1955[3])),SCM_debug_info_const_vector);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[3]))->name = scm__rc.d1945[173];/* string->vector */
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[3]))->debugInfo = scm__rc.d1945[201];
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[7] = SCM_WORD(scm__rc.d1945[174]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[27] = SCM_WORD(scm__rc.d1945[176]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[52] = SCM_WORD(scm__rc.d1945[150]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[57] = SCM_WORD(scm__rc.d1945[192]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[59] = SCM_WORD(scm__rc.d1945[154]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[68] = SCM_WORD(scm__rc.d1945[109]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[70] = SCM_WORD(scm__rc.d1945[192]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[73] = SCM_WORD(scm__rc.d1945[156]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[79] = SCM_WORD(scm__rc.d1945[193]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[86] = SCM_WORD(scm__rc.d1945[193]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[94] = SCM_WORD(scm__rc.d1945[194]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[107] = SCM_WORD(scm__rc.d1945[195]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[114] = SCM_WORD(scm__rc.d1945[196]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[126] = SCM_WORD(scm__rc.d1945[197]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[135] = SCM_WORD(scm__rc.d1945[198]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[150]))[142] = SCM_WORD(scm__rc.d1945[199]);
  scm__rc.d1945[202] = Scm_MakeIdentifier(scm__rc.d1945[173], SCM_MODULE(Scm_SchemeModule()), SCM_NIL); /* scheme#string->vector */
  scm__rc.d1945[203] = Scm_MakePackedDebugInfo(SCM_U8VECTOR(SCM_OBJ(&scm__rc.d1955[4])),SCM_debug_info_const_vector);
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[4]))->name = scm__rc.d1945[171];/* %toplevel */
  SCM_COMPILED_CODE(SCM_OBJ(&scm__rc.d1954[4]))->debugInfo = scm__rc.d1945[203];
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[299]))[3] = SCM_WORD(scm__rc.d1945[136]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[299]))[6] = SCM_WORD(scm__rc.d1945[173]);
  ((ScmWord*)SCM_OBJ(&scm__rc.d1953[299]))[13] = SCM_WORD(scm__rc.d1945[202]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1945[204] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[83])),TRUE); /* make-weak-vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[277]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[278]), scm__rc.d1945[204]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[279]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[280]), scm__rc.d1945[4]);
  scm__rc.d1945[205] = Scm_MakeExtendedPair(scm__rc.d1945[204], SCM_OBJ(&scm__rc.d1946[235]), SCM_OBJ(&scm__rc.d1946[282]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[206]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[206]))[4] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[206]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[206]))[6] = scm__rc.d1945[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.d1945[205];
  libvecmake_weak_vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[206]);
  scm__rc.d1945[213] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[84])),TRUE); /* weak-vector-length */
  scm__rc.d1945[214] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[85])),TRUE); /* wv */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[283]), scm__rc.d1945[214]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[286]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[287]), scm__rc.d1945[213]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[288]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[289]), scm__rc.d1945[4]);
  scm__rc.d1945[215] = Scm_MakeExtendedPair(scm__rc.d1945[213], SCM_OBJ(&scm__rc.d1946[283]), SCM_OBJ(&scm__rc.d1946[291]));
  scm__rc.d1945[216] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[86])),TRUE); /* <weak-vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[217]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[217]))[4] = scm__rc.d1945[216];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[217]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[217]))[6] = scm__rc.d1945[32];
  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.d1945[215];
  libvecweak_vector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[217]);
  scm__rc.d1945[224] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[87])),TRUE); /* weak-vector-ref */
  scm__rc.d1945[225] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[88])),TRUE); /* index */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[292]), scm__rc.d1945[225]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[293]), scm__rc.d1945[214]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[296]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[297]), scm__rc.d1945[224]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[298]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[299]), scm__rc.d1945[4]);
  scm__rc.d1945[226] = Scm_MakeExtendedPair(scm__rc.d1945[224], SCM_OBJ(&scm__rc.d1946[293]), SCM_OBJ(&scm__rc.d1946[301]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[4] = scm__rc.d1945[216];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[227]))[8] = scm__rc.d1945[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.d1945[226];
  libvecweak_vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[227]);
  scm__rc.d1945[236] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[89])),TRUE); /* weak-vector-set! */
  scm__rc.d1945[237] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[90])),TRUE); /* val */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[302]), scm__rc.d1945[237]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[303]), scm__rc.d1945[225]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[304]), scm__rc.d1945[214]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[307]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[308]), scm__rc.d1945[236]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[309]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[310]), scm__rc.d1945[4]);
  scm__rc.d1945[238] = Scm_MakeExtendedPair(scm__rc.d1945[236], SCM_OBJ(&scm__rc.d1946[304]), SCM_OBJ(&scm__rc.d1946[312]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[4] = scm__rc.d1945[216];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[239]))[8] = scm__rc.d1945[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.d1945[238];
  libvecweak_vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[239]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  scm__rc.d1945[248] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[91])),TRUE); /* SCM_UVECTOR_S8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[248]), Scm_MakeInteger(SCM_UVECTOR_S8), SCM_BINDING_CONST);

  scm__rc.d1945[249] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[92])),TRUE); /* SCM_UVECTOR_U8 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[249]), Scm_MakeInteger(SCM_UVECTOR_U8), SCM_BINDING_CONST);

  scm__rc.d1945[250] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[93])),TRUE); /* SCM_UVECTOR_S16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[250]), Scm_MakeInteger(SCM_UVECTOR_S16), SCM_BINDING_CONST);

  scm__rc.d1945[251] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[94])),TRUE); /* SCM_UVECTOR_U16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[251]), Scm_MakeInteger(SCM_UVECTOR_U16), SCM_BINDING_CONST);

  scm__rc.d1945[252] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[95])),TRUE); /* SCM_UVECTOR_S32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[252]), Scm_MakeInteger(SCM_UVECTOR_S32), SCM_BINDING_CONST);

  scm__rc.d1945[253] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[96])),TRUE); /* SCM_UVECTOR_U32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[253]), Scm_MakeInteger(SCM_UVECTOR_U32), SCM_BINDING_CONST);

  scm__rc.d1945[254] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[97])),TRUE); /* SCM_UVECTOR_S64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[254]), Scm_MakeInteger(SCM_UVECTOR_S64), SCM_BINDING_CONST);

  scm__rc.d1945[255] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[98])),TRUE); /* SCM_UVECTOR_U64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[255]), Scm_MakeInteger(SCM_UVECTOR_U64), SCM_BINDING_CONST);

  scm__rc.d1945[256] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[99])),TRUE); /* SCM_UVECTOR_F16 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[256]), Scm_MakeInteger(SCM_UVECTOR_F16), SCM_BINDING_CONST);

  scm__rc.d1945[257] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[100])),TRUE); /* SCM_UVECTOR_F32 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[257]), Scm_MakeInteger(SCM_UVECTOR_F32), SCM_BINDING_CONST);

  scm__rc.d1945[258] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[101])),TRUE); /* SCM_UVECTOR_F64 */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[258]), Scm_MakeInteger(SCM_UVECTOR_F64), SCM_BINDING_CONST);

  scm__rc.d1945[259] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[102])),TRUE); /* SCM_UVECTOR_GENERIC */
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(scm__rc.d1945[259]), Scm_MakeInteger(SCM_UVECTOR_GENERIC), SCM_BINDING_CONST);

  scm__rc.d1945[260] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[103])),TRUE); /* make-s8vector */
  scm__rc.d1945[261] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[104])),TRUE); /* length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[313]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[314]), scm__rc.d1945[261]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[317]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[318]), scm__rc.d1945[260]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[319]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[320]), scm__rc.d1945[4]);
  scm__rc.d1945[262] = Scm_MakeExtendedPair(scm__rc.d1945[260], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[322]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[263]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[263]))[4] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[263]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[263]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[263]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-s8vector")), SCM_OBJ(&libvecmake_s8vector__STUB), 0);
  libvecmake_s8vector__STUB.common.info = scm__rc.d1945[262];
  libvecmake_s8vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[271] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[105])),TRUE); /* make-u8vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[325]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[326]), scm__rc.d1945[271]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[327]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[328]), scm__rc.d1945[4]);
  scm__rc.d1945[272] = Scm_MakeExtendedPair(scm__rc.d1945[271], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[330]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-u8vector")), SCM_OBJ(&libvecmake_u8vector__STUB), 0);
  libvecmake_u8vector__STUB.common.info = scm__rc.d1945[272];
  libvecmake_u8vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[273] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[106])),TRUE); /* make-s16vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[333]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[334]), scm__rc.d1945[273]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[335]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[336]), scm__rc.d1945[4]);
  scm__rc.d1945[274] = Scm_MakeExtendedPair(scm__rc.d1945[273], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[338]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-s16vector")), SCM_OBJ(&libvecmake_s16vector__STUB), 0);
  libvecmake_s16vector__STUB.common.info = scm__rc.d1945[274];
  libvecmake_s16vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[275] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[107])),TRUE); /* make-u16vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[341]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[342]), scm__rc.d1945[275]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[343]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[344]), scm__rc.d1945[4]);
  scm__rc.d1945[276] = Scm_MakeExtendedPair(scm__rc.d1945[275], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[346]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-u16vector")), SCM_OBJ(&libvecmake_u16vector__STUB), 0);
  libvecmake_u16vector__STUB.common.info = scm__rc.d1945[276];
  libvecmake_u16vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[277] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[108])),TRUE); /* make-s32vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[349]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[350]), scm__rc.d1945[277]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[351]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[352]), scm__rc.d1945[4]);
  scm__rc.d1945[278] = Scm_MakeExtendedPair(scm__rc.d1945[277], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[354]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-s32vector")), SCM_OBJ(&libvecmake_s32vector__STUB), 0);
  libvecmake_s32vector__STUB.common.info = scm__rc.d1945[278];
  libvecmake_s32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[279] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[109])),TRUE); /* make-u32vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[357]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[358]), scm__rc.d1945[279]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[359]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[360]), scm__rc.d1945[4]);
  scm__rc.d1945[280] = Scm_MakeExtendedPair(scm__rc.d1945[279], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[362]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-u32vector")), SCM_OBJ(&libvecmake_u32vector__STUB), 0);
  libvecmake_u32vector__STUB.common.info = scm__rc.d1945[280];
  libvecmake_u32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[281] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[110])),TRUE); /* make-s64vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[365]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[366]), scm__rc.d1945[281]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[367]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[368]), scm__rc.d1945[4]);
  scm__rc.d1945[282] = Scm_MakeExtendedPair(scm__rc.d1945[281], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[370]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-s64vector")), SCM_OBJ(&libvecmake_s64vector__STUB), 0);
  libvecmake_s64vector__STUB.common.info = scm__rc.d1945[282];
  libvecmake_s64vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[283] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[111])),TRUE); /* make-u64vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[373]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[374]), scm__rc.d1945[283]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[375]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[376]), scm__rc.d1945[4]);
  scm__rc.d1945[284] = Scm_MakeExtendedPair(scm__rc.d1945[283], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[378]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-u64vector")), SCM_OBJ(&libvecmake_u64vector__STUB), 0);
  libvecmake_u64vector__STUB.common.info = scm__rc.d1945[284];
  libvecmake_u64vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[285] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[112])),TRUE); /* make-f16vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[381]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[382]), scm__rc.d1945[285]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[383]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[384]), scm__rc.d1945[4]);
  scm__rc.d1945[286] = Scm_MakeExtendedPair(scm__rc.d1945[285], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[386]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-f16vector")), SCM_OBJ(&libvecmake_f16vector__STUB), 0);
  libvecmake_f16vector__STUB.common.info = scm__rc.d1945[286];
  libvecmake_f16vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[287] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[113])),TRUE); /* make-f32vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[389]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[390]), scm__rc.d1945[287]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[391]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[392]), scm__rc.d1945[4]);
  scm__rc.d1945[288] = Scm_MakeExtendedPair(scm__rc.d1945[287], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[394]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-f32vector")), SCM_OBJ(&libvecmake_f32vector__STUB), 0);
  libvecmake_f32vector__STUB.common.info = scm__rc.d1945[288];
  libvecmake_f32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[289] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[114])),TRUE); /* make-f64vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[397]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[398]), scm__rc.d1945[289]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[399]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[400]), scm__rc.d1945[4]);
  scm__rc.d1945[290] = Scm_MakeExtendedPair(scm__rc.d1945[289], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[402]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-f64vector")), SCM_OBJ(&libvecmake_f64vector__STUB), 0);
  libvecmake_f64vector__STUB.common.info = scm__rc.d1945[290];
  libvecmake_f64vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[291] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[115])),TRUE); /* make-c32vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[405]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[406]), scm__rc.d1945[291]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[407]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[408]), scm__rc.d1945[4]);
  scm__rc.d1945[292] = Scm_MakeExtendedPair(scm__rc.d1945[291], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[410]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-c32vector")), SCM_OBJ(&libvecmake_c32vector__STUB), 0);
  libvecmake_c32vector__STUB.common.info = scm__rc.d1945[292];
  libvecmake_c32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[293] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[116])),TRUE); /* make-c64vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[413]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[414]), scm__rc.d1945[293]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[415]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[416]), scm__rc.d1945[4]);
  scm__rc.d1945[294] = Scm_MakeExtendedPair(scm__rc.d1945[293], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[418]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-c64vector")), SCM_OBJ(&libvecmake_c64vector__STUB), 0);
  libvecmake_c64vector__STUB.common.info = scm__rc.d1945[294];
  libvecmake_c64vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[295] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[117])),TRUE); /* make-c128vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[421]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[422]), scm__rc.d1945[295]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[423]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[424]), scm__rc.d1945[4]);
  scm__rc.d1945[296] = Scm_MakeExtendedPair(scm__rc.d1945[295], SCM_OBJ(&scm__rc.d1946[314]), SCM_OBJ(&scm__rc.d1946[426]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("make-c128vector")), SCM_OBJ(&libvecmake_c128vector__STUB), 0);
  libvecmake_c128vector__STUB.common.info = scm__rc.d1945[296];
  libvecmake_c128vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[297] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[118])),TRUE); /* s8vector-set! */
  scm__rc.d1945[298] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[119])),TRUE); /* clamp */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[427]), scm__rc.d1945[298]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[428]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[429]), scm__rc.d1945[237]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[430]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[431]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[434]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[435]), scm__rc.d1945[297]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[436]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[437]), scm__rc.d1945[4]);
  scm__rc.d1945[299] = Scm_MakeExtendedPair(scm__rc.d1945[297], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[439]));
  scm__rc.d1945[300] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[120])),TRUE); /* <s8vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[4] = scm__rc.d1945[300];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[301]))[9] = scm__rc.d1945[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.d1945[299];
  libvecs8vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[301]);
  scm__rc.d1945[311] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[121])),TRUE); /* s8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[440]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[441]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[444]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[445]), scm__rc.d1945[311]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[446]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[447]), scm__rc.d1945[4]);
  scm__rc.d1945[312] = Scm_MakeExtendedPair(scm__rc.d1945[311], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[449]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[4] = scm__rc.d1945[300];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[313]))[8] = scm__rc.d1945[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.d1945[312];
  libvecs8vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[313]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs8vector_ref__STUB), SCM_PROCEDURE(&libvecs8vector_setX__STUB), TRUE);
  scm__rc.d1945[322] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[122])),TRUE); /* u8vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[452]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[453]), scm__rc.d1945[322]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[454]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[455]), scm__rc.d1945[4]);
  scm__rc.d1945[323] = Scm_MakeExtendedPair(scm__rc.d1945[322], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[457]));
  scm__rc.d1945[324] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[123])),TRUE); /* <u8vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[4] = scm__rc.d1945[324];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[325]))[9] = scm__rc.d1945[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.d1945[323];
  libvecu8vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[325]);
  scm__rc.d1945[335] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[124])),TRUE); /* u8vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[460]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[461]), scm__rc.d1945[335]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[462]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[463]), scm__rc.d1945[4]);
  scm__rc.d1945[336] = Scm_MakeExtendedPair(scm__rc.d1945[335], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[465]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[4] = scm__rc.d1945[324];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[337]))[8] = scm__rc.d1945[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.d1945[336];
  libvecu8vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[337]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu8vector_ref__STUB), SCM_PROCEDURE(&libvecu8vector_setX__STUB), TRUE);
  scm__rc.d1945[346] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[125])),TRUE); /* s16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[468]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[469]), scm__rc.d1945[346]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[470]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[471]), scm__rc.d1945[4]);
  scm__rc.d1945[347] = Scm_MakeExtendedPair(scm__rc.d1945[346], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[473]));
  scm__rc.d1945[348] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[126])),TRUE); /* <s16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[4] = scm__rc.d1945[348];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[349]))[9] = scm__rc.d1945[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.d1945[347];
  libvecs16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[349]);
  scm__rc.d1945[359] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[127])),TRUE); /* s16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[476]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[477]), scm__rc.d1945[359]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[478]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[479]), scm__rc.d1945[4]);
  scm__rc.d1945[360] = Scm_MakeExtendedPair(scm__rc.d1945[359], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[481]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[4] = scm__rc.d1945[348];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[361]))[8] = scm__rc.d1945[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.d1945[360];
  libvecs16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[361]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs16vector_ref__STUB), SCM_PROCEDURE(&libvecs16vector_setX__STUB), TRUE);
  scm__rc.d1945[370] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[128])),TRUE); /* u16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[484]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[485]), scm__rc.d1945[370]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[486]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[487]), scm__rc.d1945[4]);
  scm__rc.d1945[371] = Scm_MakeExtendedPair(scm__rc.d1945[370], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[489]));
  scm__rc.d1945[372] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[129])),TRUE); /* <u16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[4] = scm__rc.d1945[372];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[373]))[9] = scm__rc.d1945[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.d1945[371];
  libvecu16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[373]);
  scm__rc.d1945[383] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[130])),TRUE); /* u16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[492]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[493]), scm__rc.d1945[383]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[494]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[495]), scm__rc.d1945[4]);
  scm__rc.d1945[384] = Scm_MakeExtendedPair(scm__rc.d1945[383], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[497]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[4] = scm__rc.d1945[372];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[385]))[8] = scm__rc.d1945[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.d1945[384];
  libvecu16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[385]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu16vector_ref__STUB), SCM_PROCEDURE(&libvecu16vector_setX__STUB), TRUE);
  scm__rc.d1945[394] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[131])),TRUE); /* s32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[500]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[501]), scm__rc.d1945[394]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[502]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[503]), scm__rc.d1945[4]);
  scm__rc.d1945[395] = Scm_MakeExtendedPair(scm__rc.d1945[394], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[505]));
  scm__rc.d1945[396] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[132])),TRUE); /* <s32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[4] = scm__rc.d1945[396];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[397]))[9] = scm__rc.d1945[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.d1945[395];
  libvecs32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[397]);
  scm__rc.d1945[407] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[133])),TRUE); /* s32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[508]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[509]), scm__rc.d1945[407]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[510]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[511]), scm__rc.d1945[4]);
  scm__rc.d1945[408] = Scm_MakeExtendedPair(scm__rc.d1945[407], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[513]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[4] = scm__rc.d1945[396];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[409]))[8] = scm__rc.d1945[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.d1945[408];
  libvecs32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[409]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs32vector_ref__STUB), SCM_PROCEDURE(&libvecs32vector_setX__STUB), TRUE);
  scm__rc.d1945[418] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[134])),TRUE); /* u32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[516]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[517]), scm__rc.d1945[418]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[518]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[519]), scm__rc.d1945[4]);
  scm__rc.d1945[419] = Scm_MakeExtendedPair(scm__rc.d1945[418], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[521]));
  scm__rc.d1945[420] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[135])),TRUE); /* <u32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[4] = scm__rc.d1945[420];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[421]))[9] = scm__rc.d1945[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.d1945[419];
  libvecu32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[421]);
  scm__rc.d1945[431] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[136])),TRUE); /* u32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[524]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[525]), scm__rc.d1945[431]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[526]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[527]), scm__rc.d1945[4]);
  scm__rc.d1945[432] = Scm_MakeExtendedPair(scm__rc.d1945[431], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[529]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[4] = scm__rc.d1945[420];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[433]))[8] = scm__rc.d1945[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.d1945[432];
  libvecu32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[433]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu32vector_ref__STUB), SCM_PROCEDURE(&libvecu32vector_setX__STUB), TRUE);
  scm__rc.d1945[442] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[137])),TRUE); /* s64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[532]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[533]), scm__rc.d1945[442]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[534]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[535]), scm__rc.d1945[4]);
  scm__rc.d1945[443] = Scm_MakeExtendedPair(scm__rc.d1945[442], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[537]));
  scm__rc.d1945[444] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[138])),TRUE); /* <s64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[4] = scm__rc.d1945[444];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[445]))[9] = scm__rc.d1945[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.d1945[443];
  libvecs64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[445]);
  scm__rc.d1945[455] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[139])),TRUE); /* s64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[540]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[541]), scm__rc.d1945[455]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[542]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[543]), scm__rc.d1945[4]);
  scm__rc.d1945[456] = Scm_MakeExtendedPair(scm__rc.d1945[455], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[545]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[4] = scm__rc.d1945[444];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[457]))[8] = scm__rc.d1945[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.d1945[456];
  libvecs64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[457]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecs64vector_ref__STUB), SCM_PROCEDURE(&libvecs64vector_setX__STUB), TRUE);
  scm__rc.d1945[466] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[140])),TRUE); /* u64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[548]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[549]), scm__rc.d1945[466]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[550]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[551]), scm__rc.d1945[4]);
  scm__rc.d1945[467] = Scm_MakeExtendedPair(scm__rc.d1945[466], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[553]));
  scm__rc.d1945[468] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[141])),TRUE); /* <u64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[4] = scm__rc.d1945[468];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[469]))[9] = scm__rc.d1945[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.d1945[467];
  libvecu64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[469]);
  scm__rc.d1945[479] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[142])),TRUE); /* u64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[556]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[557]), scm__rc.d1945[479]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[558]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[559]), scm__rc.d1945[4]);
  scm__rc.d1945[480] = Scm_MakeExtendedPair(scm__rc.d1945[479], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[561]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[4] = scm__rc.d1945[468];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[481]))[8] = scm__rc.d1945[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.d1945[480];
  libvecu64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[481]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecu64vector_ref__STUB), SCM_PROCEDURE(&libvecu64vector_setX__STUB), TRUE);
  scm__rc.d1945[490] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[143])),TRUE); /* f16vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[564]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[565]), scm__rc.d1945[490]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[566]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[567]), scm__rc.d1945[4]);
  scm__rc.d1945[491] = Scm_MakeExtendedPair(scm__rc.d1945[490], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[569]));
  scm__rc.d1945[492] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[144])),TRUE); /* <f16vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[4] = scm__rc.d1945[492];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[493]))[9] = scm__rc.d1945[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.d1945[491];
  libvecf16vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[493]);
  scm__rc.d1945[503] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[145])),TRUE); /* f16vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[572]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[573]), scm__rc.d1945[503]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[574]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[575]), scm__rc.d1945[4]);
  scm__rc.d1945[504] = Scm_MakeExtendedPair(scm__rc.d1945[503], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[577]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[4] = scm__rc.d1945[492];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[505]))[8] = scm__rc.d1945[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.d1945[504];
  libvecf16vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[505]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf16vector_ref__STUB), SCM_PROCEDURE(&libvecf16vector_setX__STUB), TRUE);
  scm__rc.d1945[514] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[146])),TRUE); /* f32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[580]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[581]), scm__rc.d1945[514]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[582]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[583]), scm__rc.d1945[4]);
  scm__rc.d1945[515] = Scm_MakeExtendedPair(scm__rc.d1945[514], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[585]));
  scm__rc.d1945[516] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[147])),TRUE); /* <f32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[4] = scm__rc.d1945[516];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[517]))[9] = scm__rc.d1945[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.d1945[515];
  libvecf32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[517]);
  scm__rc.d1945[527] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[148])),TRUE); /* f32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[588]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[589]), scm__rc.d1945[527]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[590]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[591]), scm__rc.d1945[4]);
  scm__rc.d1945[528] = Scm_MakeExtendedPair(scm__rc.d1945[527], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[593]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[4] = scm__rc.d1945[516];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[529]))[8] = scm__rc.d1945[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.d1945[528];
  libvecf32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[529]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf32vector_ref__STUB), SCM_PROCEDURE(&libvecf32vector_setX__STUB), TRUE);
  scm__rc.d1945[538] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[149])),TRUE); /* f64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[596]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[597]), scm__rc.d1945[538]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[598]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[599]), scm__rc.d1945[4]);
  scm__rc.d1945[539] = Scm_MakeExtendedPair(scm__rc.d1945[538], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[601]));
  scm__rc.d1945[540] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[150])),TRUE); /* <f64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[4] = scm__rc.d1945[540];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[541]))[9] = scm__rc.d1945[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.d1945[539];
  libvecf64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[541]);
  scm__rc.d1945[551] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[151])),TRUE); /* f64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[604]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[605]), scm__rc.d1945[551]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[606]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[607]), scm__rc.d1945[4]);
  scm__rc.d1945[552] = Scm_MakeExtendedPair(scm__rc.d1945[551], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[609]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[4] = scm__rc.d1945[540];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[553]))[8] = scm__rc.d1945[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.d1945[552];
  libvecf64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[553]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecf64vector_ref__STUB), SCM_PROCEDURE(&libvecf64vector_setX__STUB), TRUE);
  scm__rc.d1945[562] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[152])),TRUE); /* c32vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[612]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[613]), scm__rc.d1945[562]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[614]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[615]), scm__rc.d1945[4]);
  scm__rc.d1945[563] = Scm_MakeExtendedPair(scm__rc.d1945[562], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[617]));
  scm__rc.d1945[564] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[153])),TRUE); /* <c32vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[4] = scm__rc.d1945[564];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[565]))[9] = scm__rc.d1945[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.d1945[563];
  libvecc32vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[565]);
  scm__rc.d1945[575] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[154])),TRUE); /* c32vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[620]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[621]), scm__rc.d1945[575]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[622]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[623]), scm__rc.d1945[4]);
  scm__rc.d1945[576] = Scm_MakeExtendedPair(scm__rc.d1945[575], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[625]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[4] = scm__rc.d1945[564];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[577]))[8] = scm__rc.d1945[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.d1945[576];
  libvecc32vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[577]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc32vector_ref__STUB), SCM_PROCEDURE(&libvecc32vector_setX__STUB), TRUE);
  scm__rc.d1945[586] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[155])),TRUE); /* c64vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[628]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[629]), scm__rc.d1945[586]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[630]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[631]), scm__rc.d1945[4]);
  scm__rc.d1945[587] = Scm_MakeExtendedPair(scm__rc.d1945[586], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[633]));
  scm__rc.d1945[588] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[156])),TRUE); /* <c64vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[4] = scm__rc.d1945[588];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[589]))[9] = scm__rc.d1945[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.d1945[587];
  libvecc64vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[589]);
  scm__rc.d1945[599] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[157])),TRUE); /* c64vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[636]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[637]), scm__rc.d1945[599]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[638]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[639]), scm__rc.d1945[4]);
  scm__rc.d1945[600] = Scm_MakeExtendedPair(scm__rc.d1945[599], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[641]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[4] = scm__rc.d1945[588];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[601]))[8] = scm__rc.d1945[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.d1945[600];
  libvecc64vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[601]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc64vector_ref__STUB), SCM_PROCEDURE(&libvecc64vector_setX__STUB), TRUE);
  scm__rc.d1945[610] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[158])),TRUE); /* c128vector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[644]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[645]), scm__rc.d1945[610]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[646]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[647]), scm__rc.d1945[4]);
  scm__rc.d1945[611] = Scm_MakeExtendedPair(scm__rc.d1945[610], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[649]));
  scm__rc.d1945[612] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[159])),TRUE); /* <c128vector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[4] = scm__rc.d1945[612];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[613]))[9] = scm__rc.d1945[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.d1945[611];
  libvecc128vector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[613]);
  scm__rc.d1945[623] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[160])),TRUE); /* c128vector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[652]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[653]), scm__rc.d1945[623]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[654]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[655]), scm__rc.d1945[4]);
  scm__rc.d1945[624] = Scm_MakeExtendedPair(scm__rc.d1945[623], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[657]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[4] = scm__rc.d1945[612];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[625]))[8] = scm__rc.d1945[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.d1945[624];
  libvecc128vector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[625]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecc128vector_ref__STUB), SCM_PROCEDURE(&libvecc128vector_setX__STUB), TRUE);
  scm__rc.d1945[634] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[161])),TRUE); /* uvector-set! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[660]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[661]), scm__rc.d1945[634]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[662]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[663]), scm__rc.d1945[4]);
  scm__rc.d1945[635] = Scm_MakeExtendedPair(scm__rc.d1945[634], SCM_OBJ(&scm__rc.d1946[431]), SCM_OBJ(&scm__rc.d1946[665]));
  scm__rc.d1945[636] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[162])),TRUE); /* <uvector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[4] = scm__rc.d1945[636];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[637]))[9] = scm__rc.d1945[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.d1945[635];
  libvecuvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[637]);
  scm__rc.d1945[647] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[163])),TRUE); /* uvector-ref */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[668]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[669]), scm__rc.d1945[647]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[670]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[671]), scm__rc.d1945[4]);
  scm__rc.d1945[648] = Scm_MakeExtendedPair(scm__rc.d1945[647], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[673]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[4] = scm__rc.d1945[636];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[649]))[8] = scm__rc.d1945[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.d1945[648];
  libvecuvector_ref__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[649]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecuvector_ref__STUB), SCM_PROCEDURE(&libvecuvector_setX__STUB), TRUE);
  scm__rc.d1945[658] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[164])),TRUE); /* uvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[676]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[677]), scm__rc.d1945[658]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[678]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[679]), scm__rc.d1945[4]);
  scm__rc.d1945[659] = Scm_MakeExtendedPair(scm__rc.d1945[658], SCM_OBJ(&scm__rc.d1946[119]), SCM_OBJ(&scm__rc.d1946[681]));
  scm__rc.d1945[660] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[165])),TRUE); /* <ulong> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[661]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[661]))[4] = scm__rc.d1945[636];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[661]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[661]))[6] = scm__rc.d1945[660];
  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.d1945[659];
  libvecuvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[661]);
  scm__rc.d1945[668] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[166])),TRUE); /* uvector-immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[684]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[685]), scm__rc.d1945[668]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[686]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[687]), scm__rc.d1945[4]);
  scm__rc.d1945[669] = Scm_MakeExtendedPair(scm__rc.d1945[668], SCM_OBJ(&scm__rc.d1946[119]), SCM_OBJ(&scm__rc.d1946[689]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[670]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[670]))[4] = scm__rc.d1945[636];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[670]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[670]))[6] = scm__rc.d1945[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.d1945[669];
  libvecuvector_immutableP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[670]);
  scm__rc.d1945[677] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[167])),TRUE); /* uvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[692]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[693]), scm__rc.d1945[677]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[694]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[695]), scm__rc.d1945[4]);
  scm__rc.d1945[678] = Scm_MakeExtendedPair(scm__rc.d1945[677], SCM_OBJ(&scm__rc.d1946[11]), SCM_OBJ(&scm__rc.d1946[697]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[679]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[679]))[4] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[679]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[679]))[6] = scm__rc.d1945[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.d1945[678];
  libvecuvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[686] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[168])),TRUE); /* u8vector? */
  scm__rc.d1945[687] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[169])),TRUE); /* x */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[698]), scm__rc.d1945[687]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[701]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[702]), scm__rc.d1945[686]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[703]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[704]), scm__rc.d1945[4]);
  scm__rc.d1945[688] = Scm_MakeExtendedPair(scm__rc.d1945[686], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[706]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u8vector?")), SCM_OBJ(&libvecu8vectorP__STUB), 0);
  libvecu8vectorP__STUB.common.info = scm__rc.d1945[688];
  libvecu8vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[689] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[170])),TRUE); /* s8vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[709]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[710]), scm__rc.d1945[689]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[711]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[712]), scm__rc.d1945[4]);
  scm__rc.d1945[690] = Scm_MakeExtendedPair(scm__rc.d1945[689], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[714]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s8vector?")), SCM_OBJ(&libvecs8vectorP__STUB), 0);
  libvecs8vectorP__STUB.common.info = scm__rc.d1945[690];
  libvecs8vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[691] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[171])),TRUE); /* u16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[717]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[718]), scm__rc.d1945[691]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[719]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[720]), scm__rc.d1945[4]);
  scm__rc.d1945[692] = Scm_MakeExtendedPair(scm__rc.d1945[691], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[722]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u16vector?")), SCM_OBJ(&libvecu16vectorP__STUB), 0);
  libvecu16vectorP__STUB.common.info = scm__rc.d1945[692];
  libvecu16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[693] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[172])),TRUE); /* s16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[725]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[726]), scm__rc.d1945[693]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[727]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[728]), scm__rc.d1945[4]);
  scm__rc.d1945[694] = Scm_MakeExtendedPair(scm__rc.d1945[693], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[730]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s16vector?")), SCM_OBJ(&libvecs16vectorP__STUB), 0);
  libvecs16vectorP__STUB.common.info = scm__rc.d1945[694];
  libvecs16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[695] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[173])),TRUE); /* u32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[733]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[734]), scm__rc.d1945[695]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[735]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[736]), scm__rc.d1945[4]);
  scm__rc.d1945[696] = Scm_MakeExtendedPair(scm__rc.d1945[695], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[738]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u32vector?")), SCM_OBJ(&libvecu32vectorP__STUB), 0);
  libvecu32vectorP__STUB.common.info = scm__rc.d1945[696];
  libvecu32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[697] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[174])),TRUE); /* s32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[741]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[742]), scm__rc.d1945[697]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[743]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[744]), scm__rc.d1945[4]);
  scm__rc.d1945[698] = Scm_MakeExtendedPair(scm__rc.d1945[697], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[746]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s32vector?")), SCM_OBJ(&libvecs32vectorP__STUB), 0);
  libvecs32vectorP__STUB.common.info = scm__rc.d1945[698];
  libvecs32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[699] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[175])),TRUE); /* u64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[749]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[750]), scm__rc.d1945[699]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[751]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[752]), scm__rc.d1945[4]);
  scm__rc.d1945[700] = Scm_MakeExtendedPair(scm__rc.d1945[699], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[754]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u64vector?")), SCM_OBJ(&libvecu64vectorP__STUB), 0);
  libvecu64vectorP__STUB.common.info = scm__rc.d1945[700];
  libvecu64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[701] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[176])),TRUE); /* s64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[757]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[758]), scm__rc.d1945[701]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[759]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[760]), scm__rc.d1945[4]);
  scm__rc.d1945[702] = Scm_MakeExtendedPair(scm__rc.d1945[701], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[762]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s64vector?")), SCM_OBJ(&libvecs64vectorP__STUB), 0);
  libvecs64vectorP__STUB.common.info = scm__rc.d1945[702];
  libvecs64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[703] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[177])),TRUE); /* f16vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[765]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[766]), scm__rc.d1945[703]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[767]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[768]), scm__rc.d1945[4]);
  scm__rc.d1945[704] = Scm_MakeExtendedPair(scm__rc.d1945[703], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[770]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f16vector?")), SCM_OBJ(&libvecf16vectorP__STUB), 0);
  libvecf16vectorP__STUB.common.info = scm__rc.d1945[704];
  libvecf16vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[705] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[178])),TRUE); /* f32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[773]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[774]), scm__rc.d1945[705]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[775]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[776]), scm__rc.d1945[4]);
  scm__rc.d1945[706] = Scm_MakeExtendedPair(scm__rc.d1945[705], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[778]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f32vector?")), SCM_OBJ(&libvecf32vectorP__STUB), 0);
  libvecf32vectorP__STUB.common.info = scm__rc.d1945[706];
  libvecf32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[707] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[179])),TRUE); /* f64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[781]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[782]), scm__rc.d1945[707]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[783]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[784]), scm__rc.d1945[4]);
  scm__rc.d1945[708] = Scm_MakeExtendedPair(scm__rc.d1945[707], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[786]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("f64vector?")), SCM_OBJ(&libvecf64vectorP__STUB), 0);
  libvecf64vectorP__STUB.common.info = scm__rc.d1945[708];
  libvecf64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[709] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[180])),TRUE); /* c32vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[789]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[790]), scm__rc.d1945[709]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[791]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[792]), scm__rc.d1945[4]);
  scm__rc.d1945[710] = Scm_MakeExtendedPair(scm__rc.d1945[709], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[794]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c32vector?")), SCM_OBJ(&libvecc32vectorP__STUB), 0);
  libvecc32vectorP__STUB.common.info = scm__rc.d1945[710];
  libvecc32vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[711] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[181])),TRUE); /* c64vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[797]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[798]), scm__rc.d1945[711]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[799]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[800]), scm__rc.d1945[4]);
  scm__rc.d1945[712] = Scm_MakeExtendedPair(scm__rc.d1945[711], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[802]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c64vector?")), SCM_OBJ(&libvecc64vectorP__STUB), 0);
  libvecc64vectorP__STUB.common.info = scm__rc.d1945[712];
  libvecc64vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[713] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[182])),TRUE); /* c128vector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[805]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[806]), scm__rc.d1945[713]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[807]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[808]), scm__rc.d1945[4]);
  scm__rc.d1945[714] = Scm_MakeExtendedPair(scm__rc.d1945[713], SCM_OBJ(&scm__rc.d1946[698]), SCM_OBJ(&scm__rc.d1946[810]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("c128vector?")), SCM_OBJ(&libvecc128vectorP__STUB), 0);
  libvecc128vectorP__STUB.common.info = scm__rc.d1945[714];
  libvecc128vectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[715] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[183])),TRUE); /* make-view-uvector */
  scm__rc.d1945[716] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[184])),TRUE); /* mem */
  scm__rc.d1945[717] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[185])),TRUE); /* klass */
  scm__rc.d1945[718] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[186])),TRUE); /* offset */
  scm__rc.d1945[719] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[187])),TRUE); /* immutable? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[811]), scm__rc.d1945[719]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[812]), scm__rc.d1945[718]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[813]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[814]), scm__rc.d1945[261]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[815]), scm__rc.d1945[717]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[816]), scm__rc.d1945[716]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[819]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[820]), scm__rc.d1945[715]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[821]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[822]), scm__rc.d1945[4]);
  scm__rc.d1945[720] = Scm_MakeExtendedPair(scm__rc.d1945[715], SCM_OBJ(&scm__rc.d1946[816]), SCM_OBJ(&scm__rc.d1946[824]));
  scm__rc.d1945[721] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[188])),TRUE); /* <class> */
  scm__rc.d1945[722] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[189])),TRUE); /* <integer>? */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[4] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[5] = scm__rc.d1945[721];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[6] = scm__rc.d1945[722];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[723]))[9] = scm__rc.d1945[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.d1945[720];
  libvecmake_view_uvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[723]);
  scm__rc.d1945[733] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[190])),TRUE); /* string->s8vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[825]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[826]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[827]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[828]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[831]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[832]), scm__rc.d1945[733]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[833]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[834]), scm__rc.d1945[4]);
  scm__rc.d1945[734] = Scm_MakeExtendedPair(scm__rc.d1945[733], SCM_OBJ(&scm__rc.d1946[828]), SCM_OBJ(&scm__rc.d1946[836]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[735]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[735]))[4] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[735]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[735]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[735]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->s8vector")), SCM_OBJ(&libvecstring_TOs8vector__STUB), 0);
  libvecstring_TOs8vector__STUB.common.info = scm__rc.d1945[734];
  libvecstring_TOs8vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[735]);
  scm__rc.d1945[743] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[191])),TRUE); /* string->u8vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[839]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[840]), scm__rc.d1945[743]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[841]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[842]), scm__rc.d1945[4]);
  scm__rc.d1945[744] = Scm_MakeExtendedPair(scm__rc.d1945[743], SCM_OBJ(&scm__rc.d1946[828]), SCM_OBJ(&scm__rc.d1946[844]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->u8vector")), SCM_OBJ(&libvecstring_TOu8vector__STUB), 0);
  libvecstring_TOu8vector__STUB.common.info = scm__rc.d1945[744];
  libvecstring_TOu8vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[735]);
  scm__rc.d1945[745] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[192])),TRUE); /* string->s8vector! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[845]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[846]), scm__rc.d1945[108]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[847]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[850]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[851]), scm__rc.d1945[745]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[852]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[853]), scm__rc.d1945[4]);
  scm__rc.d1945[746] = Scm_MakeExtendedPair(scm__rc.d1945[745], SCM_OBJ(&scm__rc.d1946[847]), SCM_OBJ(&scm__rc.d1946[855]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[4] = scm__rc.d1945[300];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[6] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[747]))[9] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->s8vector!")), SCM_OBJ(&libvecstring_TOs8vectorX__STUB), 0);
  libvecstring_TOs8vectorX__STUB.common.info = scm__rc.d1945[746];
  libvecstring_TOs8vectorX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[747]);
  scm__rc.d1945[757] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[193])),TRUE); /* string->u8vector! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[858]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[859]), scm__rc.d1945[757]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[860]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[861]), scm__rc.d1945[4]);
  scm__rc.d1945[758] = Scm_MakeExtendedPair(scm__rc.d1945[757], SCM_OBJ(&scm__rc.d1946[847]), SCM_OBJ(&scm__rc.d1946[863]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[4] = scm__rc.d1945[324];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[6] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[759]))[9] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->u8vector!")), SCM_OBJ(&libvecstring_TOu8vectorX__STUB), 0);
  libvecstring_TOu8vectorX__STUB.common.info = scm__rc.d1945[758];
  libvecstring_TOu8vectorX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[759]);
  scm__rc.d1945[769] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[194])),TRUE); /* s8vector->string */
  scm__rc.d1945[770] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[195])),TRUE); /* terminator */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[864]), scm__rc.d1945[770]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[865]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[866]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[867]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[868]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[871]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[872]), scm__rc.d1945[769]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[873]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[874]), scm__rc.d1945[4]);
  scm__rc.d1945[771] = Scm_MakeExtendedPair(scm__rc.d1945[769], SCM_OBJ(&scm__rc.d1946[868]), SCM_OBJ(&scm__rc.d1946[876]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[772]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[772]))[4] = scm__rc.d1945[300];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[772]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[772]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[772]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s8vector->string")), SCM_OBJ(&libvecs8vector_TOstring__STUB), 0);
  libvecs8vector_TOstring__STUB.common.info = scm__rc.d1945[771];
  libvecs8vector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[772]);
  scm__rc.d1945[780] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[196])),TRUE); /* u8vector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[879]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[880]), scm__rc.d1945[780]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[881]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[882]), scm__rc.d1945[4]);
  scm__rc.d1945[781] = Scm_MakeExtendedPair(scm__rc.d1945[780], SCM_OBJ(&scm__rc.d1946[868]), SCM_OBJ(&scm__rc.d1946[884]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[782]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[782]))[4] = scm__rc.d1945[324];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[782]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[782]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[782]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u8vector->string")), SCM_OBJ(&libvecu8vector_TOstring__STUB), 0);
  libvecu8vector_TOstring__STUB.common.info = scm__rc.d1945[781];
  libvecu8vector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[782]);
  scm__rc.d1945[790] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[197])),TRUE); /* string->s32vector */
  scm__rc.d1945[791] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[198])),TRUE); /* endian */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[885]), scm__rc.d1945[791]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[886]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[887]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[888]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[889]), scm__rc.d1945[109]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[892]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[893]), scm__rc.d1945[790]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[894]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[895]), scm__rc.d1945[4]);
  scm__rc.d1945[792] = Scm_MakeExtendedPair(scm__rc.d1945[790], SCM_OBJ(&scm__rc.d1946[889]), SCM_OBJ(&scm__rc.d1946[897]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->s32vector")), SCM_OBJ(&libvecstring_TOs32vector__STUB), 0);
  libvecstring_TOs32vector__STUB.common.info = scm__rc.d1945[792];
  libvecstring_TOs32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[735]);
  scm__rc.d1945[793] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[199])),TRUE); /* string->u32vector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[900]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[901]), scm__rc.d1945[793]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[902]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[903]), scm__rc.d1945[4]);
  scm__rc.d1945[794] = Scm_MakeExtendedPair(scm__rc.d1945[793], SCM_OBJ(&scm__rc.d1946[889]), SCM_OBJ(&scm__rc.d1946[905]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->u32vector")), SCM_OBJ(&libvecstring_TOu32vector__STUB), 0);
  libvecstring_TOu32vector__STUB.common.info = scm__rc.d1945[794];
  libvecstring_TOu32vector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[735]);
  scm__rc.d1945[795] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[200])),TRUE); /* string->s32vector! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[906]), scm__rc.d1945[108]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[907]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[910]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[911]), scm__rc.d1945[795]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[912]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[913]), scm__rc.d1945[4]);
  scm__rc.d1945[796] = Scm_MakeExtendedPair(scm__rc.d1945[795], SCM_OBJ(&scm__rc.d1946[907]), SCM_OBJ(&scm__rc.d1946[915]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[4] = scm__rc.d1945[396];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[6] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[797]))[9] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->s32vector!")), SCM_OBJ(&libvecstring_TOs32vectorX__STUB), 0);
  libvecstring_TOs32vectorX__STUB.common.info = scm__rc.d1945[796];
  libvecstring_TOs32vectorX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[797]);
  scm__rc.d1945[807] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[201])),TRUE); /* string->u32vector! */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[918]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[919]), scm__rc.d1945[807]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[920]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[921]), scm__rc.d1945[4]);
  scm__rc.d1945[808] = Scm_MakeExtendedPair(scm__rc.d1945[807], SCM_OBJ(&scm__rc.d1946[907]), SCM_OBJ(&scm__rc.d1946[923]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[4] = scm__rc.d1945[420];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[6] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[809]))[9] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("string->u32vector!")), SCM_OBJ(&libvecstring_TOu32vectorX__STUB), 0);
  libvecstring_TOu32vectorX__STUB.common.info = scm__rc.d1945[808];
  libvecstring_TOu32vectorX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[809]);
  scm__rc.d1945[819] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[202])),TRUE); /* s32vector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[924]), scm__rc.d1945[770]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[925]), scm__rc.d1945[69]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[926]), scm__rc.d1945[68]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[927]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[928]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[931]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[932]), scm__rc.d1945[819]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[933]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[934]), scm__rc.d1945[4]);
  scm__rc.d1945[820] = Scm_MakeExtendedPair(scm__rc.d1945[819], SCM_OBJ(&scm__rc.d1946[928]), SCM_OBJ(&scm__rc.d1946[936]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[821]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[821]))[4] = scm__rc.d1945[396];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[821]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[821]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[821]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("s32vector->string")), SCM_OBJ(&libvecs32vector_TOstring__STUB), 0);
  libvecs32vector_TOstring__STUB.common.info = scm__rc.d1945[820];
  libvecs32vector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[821]);
  scm__rc.d1945[829] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[203])),TRUE); /* u32vector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[939]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[940]), scm__rc.d1945[829]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[941]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[942]), scm__rc.d1945[4]);
  scm__rc.d1945[830] = Scm_MakeExtendedPair(scm__rc.d1945[829], SCM_OBJ(&scm__rc.d1946[928]), SCM_OBJ(&scm__rc.d1946[944]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[831]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[831]))[4] = scm__rc.d1945[420];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[831]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[831]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[831]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("u32vector->string")), SCM_OBJ(&libvecu32vector_TOstring__STUB), 0);
  libvecu32vector_TOstring__STUB.common.info = scm__rc.d1945[830];
  libvecu32vector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[831]);
  scm__rc.d1945[839] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[204])),TRUE); /* bitvector? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[947]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[948]), scm__rc.d1945[839]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[949]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[950]), scm__rc.d1945[4]);
  scm__rc.d1945[840] = Scm_MakeExtendedPair(scm__rc.d1945[839], SCM_OBJ(&scm__rc.d1946[11]), SCM_OBJ(&scm__rc.d1946[952]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector?")), SCM_OBJ(&libvecbitvectorP__STUB), 0);
  libvecbitvectorP__STUB.common.info = scm__rc.d1945[840];
  libvecbitvectorP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[841] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[205])),TRUE); /* bitvector-length */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[955]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[956]), scm__rc.d1945[841]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[957]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[958]), scm__rc.d1945[4]);
  scm__rc.d1945[842] = Scm_MakeExtendedPair(scm__rc.d1945[841], SCM_OBJ(&scm__rc.d1946[119]), SCM_OBJ(&scm__rc.d1946[960]));
  scm__rc.d1945[843] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[206])),TRUE); /* <bitvector> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[844]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[844]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[844]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[844]))[6] = scm__rc.d1945[32];
  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.d1945[842];
  libvecbitvector_length__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[844]);
  scm__rc.d1945[851] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[207])),TRUE); /* bitvector-any-value? */
  scm__rc.d1945[852] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[208])),TRUE); /* bit */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[961]), scm__rc.d1945[852]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[962]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[965]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[966]), scm__rc.d1945[851]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[967]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[968]), scm__rc.d1945[4]);
  scm__rc.d1945[853] = Scm_MakeExtendedPair(scm__rc.d1945[851], SCM_OBJ(&scm__rc.d1946[962]), SCM_OBJ(&scm__rc.d1946[970]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[5] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[854]))[8] = scm__rc.d1945[20];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-any-value?")), SCM_OBJ(&libvecbitvector_any_valueP__STUB), 0);
  libvecbitvector_any_valueP__STUB.common.info = scm__rc.d1945[853];
  libvecbitvector_any_valueP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[854]);
  scm__rc.d1945[863] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[209])),TRUE); /* bitvector-every-value? */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[973]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[974]), scm__rc.d1945[863]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[975]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[976]), scm__rc.d1945[4]);
  scm__rc.d1945[864] = Scm_MakeExtendedPair(scm__rc.d1945[863], SCM_OBJ(&scm__rc.d1946[962]), SCM_OBJ(&scm__rc.d1946[978]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-every-value?")), SCM_OBJ(&libvecbitvector_every_valueP__STUB), 0);
  libvecbitvector_every_valueP__STUB.common.info = scm__rc.d1945[864];
  libvecbitvector_every_valueP__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[854]);
  scm__rc.d1945[865] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[210])),TRUE); /* make-bitvector */
  scm__rc.d1945[866] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[211])),TRUE); /* len */
  scm__rc.d1945[867] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[212])),TRUE); /* init */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[979]), scm__rc.d1945[867]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[980]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[981]), scm__rc.d1945[866]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[984]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[985]), scm__rc.d1945[865]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[986]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[987]), scm__rc.d1945[4]);
  scm__rc.d1945[868] = Scm_MakeExtendedPair(scm__rc.d1945[865], SCM_OBJ(&scm__rc.d1946[981]), SCM_OBJ(&scm__rc.d1946[989]));
  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.d1945[868];
  libvecmake_bitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[263]);
  scm__rc.d1945[869] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[213])),TRUE); /* bitvector */
  scm__rc.d1945[870] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[214])),TRUE); /* bits */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[990]), scm__rc.d1945[870]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[991]), scm__rc.d1945[1]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[994]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[995]), scm__rc.d1945[869]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[996]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[997]), scm__rc.d1945[4]);
  scm__rc.d1945[871] = Scm_MakeExtendedPair(scm__rc.d1945[869], SCM_OBJ(&scm__rc.d1946[991]), SCM_OBJ(&scm__rc.d1946[999]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[872]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[872]))[4] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[872]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[872]))[6] = scm__rc.d1945[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.d1945[871];
  libvecbitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[872]);
  scm__rc.d1945[879] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[215])),TRUE); /* list->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1002]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1003]), scm__rc.d1945[879]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1004]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1005]), scm__rc.d1945[4]);
  scm__rc.d1945[880] = Scm_MakeExtendedPair(scm__rc.d1945[879], SCM_OBJ(&scm__rc.d1946[990]), SCM_OBJ(&scm__rc.d1946[1007]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[881]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[881]))[4] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[881]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[881]))[6] = scm__rc.d1945[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.d1945[880];
  libveclist_TObitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[881]);
  scm__rc.d1945[888] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[216])),TRUE); /* string->bitvector */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1010]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1011]), scm__rc.d1945[888]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1012]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1013]), scm__rc.d1945[4]);
  scm__rc.d1945[889] = Scm_MakeExtendedPair(scm__rc.d1945[888], SCM_OBJ(&scm__rc.d1946[195]), SCM_OBJ(&scm__rc.d1946[1015]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[890]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[890]))[4] = scm__rc.d1945[178];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[890]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[890]))[6] = scm__rc.d1945[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.d1945[889];
  libvecstring_TObitvector__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[890]);
  scm__rc.d1945[897] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[217])),TRUE); /* bitvector->string */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1018]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1019]), scm__rc.d1945[897]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1020]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1021]), scm__rc.d1945[4]);
  scm__rc.d1945[898] = Scm_MakeExtendedPair(scm__rc.d1945[897], SCM_OBJ(&scm__rc.d1946[119]), SCM_OBJ(&scm__rc.d1946[1023]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[899]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[899]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[899]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[899]))[6] = scm__rc.d1945[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.d1945[898];
  libvecbitvector_TOstring__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[899]);
  scm__rc.d1945[906] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[218])),TRUE); /* bit->integer */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1024]), scm__rc.d1945[852]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1027]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1028]), scm__rc.d1945[906]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1029]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1030]), scm__rc.d1945[4]);
  scm__rc.d1945[907] = Scm_MakeExtendedPair(scm__rc.d1945[906], SCM_OBJ(&scm__rc.d1946[1024]), SCM_OBJ(&scm__rc.d1946[1032]));
  scm__rc.d1945[908] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[219])),TRUE); /* <int> */
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[909]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[909]))[4] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[909]))[5] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[909]))[6] = scm__rc.d1945[908];
  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.d1945[907];
  libvecbit_TOinteger__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[909]);
  scm__rc.d1945[916] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[220])),TRUE); /* bit->boolean */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1035]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1036]), scm__rc.d1945[916]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1037]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1038]), scm__rc.d1945[4]);
  scm__rc.d1945[917] = Scm_MakeExtendedPair(scm__rc.d1945[916], SCM_OBJ(&scm__rc.d1946[1024]), SCM_OBJ(&scm__rc.d1946[1040]));
  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.d1945[917];
  libvecbit_TOboolean__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[679]);
  scm__rc.d1945[918] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[221])),TRUE); /* bitvector-set! */
  scm__rc.d1945[919] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[222])),TRUE); /* b */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1041]), scm__rc.d1945[919]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1042]), scm__rc.d1945[146]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1043]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1046]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1047]), scm__rc.d1945[918]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1048]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1049]), scm__rc.d1945[4]);
  scm__rc.d1945[920] = Scm_MakeExtendedPair(scm__rc.d1945[918], SCM_OBJ(&scm__rc.d1946[1043]), SCM_OBJ(&scm__rc.d1946[1051]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[6] = scm__rc.d1945[9];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[921]))[8] = scm__rc.d1945[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.d1945[920];
  libvecbitvector_setX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[921]);
  scm__rc.d1945[930] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[223])),TRUE); /* bitvector-ref/int */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1054]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1055]), scm__rc.d1945[930]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1056]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1057]), scm__rc.d1945[4]);
  scm__rc.d1945[931] = Scm_MakeExtendedPair(scm__rc.d1945[930], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[1059]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[6] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[7] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[932]))[8] = scm__rc.d1945[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.d1945[931];
  libvecbitvector_ref_2fint__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[932]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fint__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1945[941] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[224])),TRUE); /* bitvector-ref/bool */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1062]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1063]), scm__rc.d1945[941]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1064]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1065]), scm__rc.d1945[4]);
  scm__rc.d1945[942] = Scm_MakeExtendedPair(scm__rc.d1945[941], SCM_OBJ(&scm__rc.d1946[441]), SCM_OBJ(&scm__rc.d1946[1067]));
  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.d1945[942];
  libvecbitvector_ref_2fbool__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[932]);
  Scm_SetterSet(SCM_PROCEDURE(&libvecbitvector_ref_2fbool__STUB), SCM_PROCEDURE(&libvecbitvector_setX__STUB), TRUE);
  scm__rc.d1945[943] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[225])),TRUE); /* bitvector-copy */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1068]), scm__rc.d1945[104]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1071]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1072]), scm__rc.d1945[943]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1073]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1074]), scm__rc.d1945[4]);
  scm__rc.d1945[944] = Scm_MakeExtendedPair(scm__rc.d1945[943], SCM_OBJ(&scm__rc.d1946[1068]), SCM_OBJ(&scm__rc.d1946[1076]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[945]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[945]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[945]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[945]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[945]))[7] = scm__rc.d1945[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.d1945[944];
  libvecbitvector_copy__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[945]);
  scm__rc.d1945[953] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[226])),TRUE); /* bitvector-copy! */
  scm__rc.d1945[954] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[227])),TRUE); /* dest */
  scm__rc.d1945[955] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[228])),TRUE); /* dstart */
  scm__rc.d1945[956] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[229])),TRUE); /* src */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1077]), scm__rc.d1945[956]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1078]), scm__rc.d1945[955]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1079]), scm__rc.d1945[954]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1082]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1083]), scm__rc.d1945[953]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1084]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1085]), scm__rc.d1945[4]);
  scm__rc.d1945[957] = Scm_MakeExtendedPair(scm__rc.d1945[953], SCM_OBJ(&scm__rc.d1946[1079]), SCM_OBJ(&scm__rc.d1946[1087]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[4] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[5] = scm__rc.d1945[32];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[6] = scm__rc.d1945[843];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[7] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[8] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[958]))[9] = scm__rc.d1945[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.d1945[957];
  libvecbitvector_copyX__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[958]);
  scm__rc.d1945[968] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[230])),TRUE); /* bitvector-word-bits */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1088]), scm__rc.d1945[968]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1089]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1090]), scm__rc.d1945[4]);
  scm__rc.d1945[969] = Scm_MakeExtendedPair(scm__rc.d1945[968], SCM_NIL, SCM_OBJ(&scm__rc.d1946[1091]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[970]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[970]))[4] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[970]))[5] = scm__rc.d1945[32];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector-word-bits")), SCM_OBJ(&libvecbitvector_word_bits__STUB), 0);
  libvecbitvector_word_bits__STUB.common.info = scm__rc.d1945[969];
  libvecbitvector_word_bits__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[970]);
  scm__rc.d1945[976] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[231])),TRUE); /* bitvector->uvector/shared */
  scm__rc.d1945[977] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[232])),TRUE); /* bv */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1092]), scm__rc.d1945[717]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1093]), scm__rc.d1945[42]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1094]), scm__rc.d1945[977]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1097]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1098]), scm__rc.d1945[976]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1099]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1100]), scm__rc.d1945[4]);
  scm__rc.d1945[978] = Scm_MakeExtendedPair(scm__rc.d1945[976], SCM_OBJ(&scm__rc.d1946[1094]), SCM_OBJ(&scm__rc.d1946[1102]));
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("bitvector->uvector/shared")), SCM_OBJ(&libvecbitvector_TOuvector_2fshared__STUB), 0);
  libvecbitvector_TOuvector_2fshared__STUB.common.info = scm__rc.d1945[978];
  libvecbitvector_TOuvector_2fshared__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[945]);
  scm__rc.d1945[979] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[233])),TRUE); /* uvector->bitvector/shared */
  scm__rc.d1945[980] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[234])),TRUE); /* uv */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1103]), scm__rc.d1945[980]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1106]), scm__rc.d1945[3]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1107]), scm__rc.d1945[979]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1108]), scm__rc.d1945[127]);
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1946[1109]), scm__rc.d1945[4]);
  scm__rc.d1945[981] = Scm_MakeExtendedPair(scm__rc.d1945[979], SCM_OBJ(&scm__rc.d1946[1103]), SCM_OBJ(&scm__rc.d1946[1111]));
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[982]))[3] = scm__rc.d1945[127];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[982]))[4] = scm__rc.d1945[636];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[982]))[5] = scm__rc.d1945[7];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[982]))[6] = scm__rc.d1945[8];
  ((ScmObj*)SCM_OBJ(&scm__rc.d1945[982]))[7] = scm__rc.d1945[9];
  Scm_MakeBinding(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())), SCM_SYMBOL(SCM_INTERN("uvector->bitvector/shared")), SCM_OBJ(&libvecuvector_TObitvector_2fshared__STUB), 0);
  libvecuvector_TObitvector_2fshared__STUB.common.info = scm__rc.d1945[981];
  libvecuvector_TObitvector_2fshared__STUB.common.typeHint = SCM_OBJ(&scm__rc.d1945[982]);
   Scm_SelectModule(SCM_MODULE(SCM_OBJ(Scm_GaucheModule())));
  Scm_VMExecuteToplevels(toplevels);
  scm__rc.d1945[1044] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[235])),TRUE); /* format */
  scm__rc.d1945[1045] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[236])),FALSE); /* G1950 */
  scm__rc.d1945[1046] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[237])),FALSE); /* G1952 */
  scm__rc.d1945[1047] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[238])),FALSE); /* G1951 */
  scm__rc.d1945[1048] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[239])),FALSE); /* rest1949 */
  scm__rc.d1945[1049] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[240])),TRUE); /* define-in-module */
  scm__rc.d1945[1050] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[241])),FALSE); /* G1957 */
  scm__rc.d1945[1051] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[242])),FALSE); /* G1959 */
  scm__rc.d1945[1052] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[243])),FALSE); /* G1958 */
  scm__rc.d1945[1053] = Scm_MakeSymbol(SCM_STRING(SCM_OBJ(&scm__sc.d1944[244])),FALSE); /* rest1956 */
}
