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

#line 35 "stdlib.stub"
#include <gauche/vminsn.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>

#ifndef M_PI
#define M_PI 3.1415926535897932384
#endif
#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 d1003[177];
} scm__sc = {
  {   /* ScmString d1003 */
      SCM_STRING_CONST_INITIALIZER("eqv?", 4, 4),
      SCM_STRING_CONST_INITIALIZER("eq?", 3, 3),
      SCM_STRING_CONST_INITIALIZER("equal?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("number?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("complex?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("real?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("rational?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("integer?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("exact?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("inexact?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("=", 1, 1),
      SCM_STRING_CONST_INITIALIZER("<", 1, 1),
      SCM_STRING_CONST_INITIALIZER("<=", 2, 2),
      SCM_STRING_CONST_INITIALIZER(">", 1, 1),
      SCM_STRING_CONST_INITIALIZER(">=", 2, 2),
      SCM_STRING_CONST_INITIALIZER("zero?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("positive?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("negative?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("odd?", 4, 4),
      SCM_STRING_CONST_INITIALIZER("even?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("max", 3, 3),
      SCM_STRING_CONST_INITIALIZER("min", 3, 3),
      SCM_STRING_CONST_INITIALIZER("*", 1, 1),
      SCM_STRING_CONST_INITIALIZER("+", 1, 1),
      SCM_STRING_CONST_INITIALIZER("-", 1, 1),
      SCM_STRING_CONST_INITIALIZER("/", 1, 1),
      SCM_STRING_CONST_INITIALIZER("abs", 3, 3),
      SCM_STRING_CONST_INITIALIZER("quotient", 8, 8),
      SCM_STRING_CONST_INITIALIZER("remainder", 9, 9),
      SCM_STRING_CONST_INITIALIZER("modulo", 6, 6),
      SCM_STRING_CONST_INITIALIZER("%gcd", 4, 4),
      SCM_STRING_CONST_INITIALIZER("numerator", 9, 9),
      SCM_STRING_CONST_INITIALIZER("denominator", 11, 11),
      SCM_STRING_CONST_INITIALIZER("floor", 5, 5),
      SCM_STRING_CONST_INITIALIZER("ceiling", 7, 7),
      SCM_STRING_CONST_INITIALIZER("truncate", 8, 8),
      SCM_STRING_CONST_INITIALIZER("round", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%exp", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%log", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%sin", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%cos", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%tan", 4, 4),
      SCM_STRING_CONST_INITIALIZER("%asin", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%acos", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%atan", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%sinh", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%cosh", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%tanh", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%sqrt", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%expt", 5, 5),
      SCM_STRING_CONST_INITIALIZER("make-rectangular", 16, 16),
      SCM_STRING_CONST_INITIALIZER("make-polar", 10, 10),
      SCM_STRING_CONST_INITIALIZER("real-part", 9, 9),
      SCM_STRING_CONST_INITIALIZER("imag-part", 9, 9),
      SCM_STRING_CONST_INITIALIZER("magnitude", 9, 9),
      SCM_STRING_CONST_INITIALIZER("angle", 5, 5),
      SCM_STRING_CONST_INITIALIZER("exact->inexact", 14, 14),
      SCM_STRING_CONST_INITIALIZER("inexact->exact", 14, 14),
      SCM_STRING_CONST_INITIALIZER("number->string", 14, 14),
      SCM_STRING_CONST_INITIALIZER("string->number", 14, 14),
      SCM_STRING_CONST_INITIALIZER("not", 3, 3),
      SCM_STRING_CONST_INITIALIZER("boolean?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("pair?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("cons", 4, 4),
      SCM_STRING_CONST_INITIALIZER("car", 3, 3),
      SCM_STRING_CONST_INITIALIZER("cdr", 3, 3),
      SCM_STRING_CONST_INITIALIZER("set-car!", 8, 8),
      SCM_STRING_CONST_INITIALIZER("set-cdr!", 8, 8),
      SCM_STRING_CONST_INITIALIZER("caar", 4, 4),
      SCM_STRING_CONST_INITIALIZER("(setter caar)", 13, 13),
      SCM_STRING_CONST_INITIALIZER("cadr", 4, 4),
      SCM_STRING_CONST_INITIALIZER("(setter cadr)", 13, 13),
      SCM_STRING_CONST_INITIALIZER("cdar", 4, 4),
      SCM_STRING_CONST_INITIALIZER("(setter cdar)", 13, 13),
      SCM_STRING_CONST_INITIALIZER("cddr", 4, 4),
      SCM_STRING_CONST_INITIALIZER("(setter cddr)", 13, 13),
      SCM_STRING_CONST_INITIALIZER("null?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("list?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("list", 4, 4),
      SCM_STRING_CONST_INITIALIZER("length", 6, 6),
      SCM_STRING_CONST_INITIALIZER("length+", 7, 7),
      SCM_STRING_CONST_INITIALIZER("append", 6, 6),
      SCM_STRING_CONST_INITIALIZER("reverse", 7, 7),
      SCM_STRING_CONST_INITIALIZER("list-tail", 9, 9),
      SCM_STRING_CONST_INITIALIZER("list-ref", 8, 8),
      SCM_STRING_CONST_INITIALIZER("memq", 4, 4),
      SCM_STRING_CONST_INITIALIZER("memv", 4, 4),
      SCM_STRING_CONST_INITIALIZER("member", 6, 6),
      SCM_STRING_CONST_INITIALIZER("assq", 4, 4),
      SCM_STRING_CONST_INITIALIZER("assv", 4, 4),
      SCM_STRING_CONST_INITIALIZER("assoc", 5, 5),
      SCM_STRING_CONST_INITIALIZER("symbol?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("symbol->string", 14, 14),
      SCM_STRING_CONST_INITIALIZER("string->symbol", 14, 14),
      SCM_STRING_CONST_INITIALIZER("char?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("char=?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("char<?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("char>?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("char<=?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("char>=?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("char-ci=?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci<?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci>?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("char-ci<=?", 10, 10),
      SCM_STRING_CONST_INITIALIZER("char-ci>=?", 10, 10),
      SCM_STRING_CONST_INITIALIZER("char-alphabetic?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-numeric?", 13, 13),
      SCM_STRING_CONST_INITIALIZER("char-whitespace?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-upper-case?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char-lower-case?", 16, 16),
      SCM_STRING_CONST_INITIALIZER("char->integer", 13, 13),
      SCM_STRING_CONST_INITIALIZER("integer->char", 13, 13),
      SCM_STRING_CONST_INITIALIZER("char-upcase", 11, 11),
      SCM_STRING_CONST_INITIALIZER("char-downcase", 13, 13),
      SCM_STRING_CONST_INITIALIZER("string?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("make-string", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string", 6, 6),
      SCM_STRING_CONST_INITIALIZER("string-length", 13, 13),
      SCM_STRING_CONST_INITIALIZER("string-ref", 10, 10),
      SCM_STRING_CONST_INITIALIZER("string=?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("string<?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("string>?", 8, 8),
      SCM_STRING_CONST_INITIALIZER("string<=?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("string>=?", 9, 9),
      SCM_STRING_CONST_INITIALIZER("string-ci=?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string-ci<?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string-ci>?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("string-ci<=?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("string-ci>=?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("substring", 9, 9),
      SCM_STRING_CONST_INITIALIZER("string-append", 13, 13),
      SCM_STRING_CONST_INITIALIZER("string->list", 12, 12),
      SCM_STRING_CONST_INITIALIZER("list->string", 12, 12),
      SCM_STRING_CONST_INITIALIZER("string-copy", 11, 11),
      SCM_STRING_CONST_INITIALIZER("vector?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("make-vector", 11, 11),
      SCM_STRING_CONST_INITIALIZER("vector", 6, 6),
      SCM_STRING_CONST_INITIALIZER("vector-length", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vector-ref", 10, 10),
      SCM_STRING_CONST_INITIALIZER("vector-set!", 11, 11),
      SCM_STRING_CONST_INITIALIZER("vector->list", 12, 12),
      SCM_STRING_CONST_INITIALIZER("list->vector", 12, 12),
      SCM_STRING_CONST_INITIALIZER("vector-fill!", 12, 12),
      SCM_STRING_CONST_INITIALIZER("procedure?", 10, 10),
      SCM_STRING_CONST_INITIALIZER("apply", 5, 5),
      SCM_STRING_CONST_INITIALIZER("map", 3, 3),
      SCM_STRING_CONST_INITIALIZER("for-each", 8, 8),
      SCM_STRING_CONST_INITIALIZER("force", 5, 5),
      SCM_STRING_CONST_INITIALIZER("call-with-current-continuation", 30, 30),
      SCM_STRING_CONST_INITIALIZER("values", 6, 6),
      SCM_STRING_CONST_INITIALIZER("dynamic-wind", 12, 12),
      SCM_STRING_CONST_INITIALIZER("eval", 4, 4),
      SCM_STRING_CONST_INITIALIZER("null-environment", 16, 16),
      SCM_STRING_CONST_INITIALIZER("scheme-report-environment", 25, 25),
      SCM_STRING_CONST_INITIALIZER("interaction-environment", 23, 23),
      SCM_STRING_CONST_INITIALIZER("input-port?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("output-port?", 12, 12),
      SCM_STRING_CONST_INITIALIZER("port?", 5, 5),
      SCM_STRING_CONST_INITIALIZER("current-input-port", 18, 18),
      SCM_STRING_CONST_INITIALIZER("current-output-port", 19, 19),
      SCM_STRING_CONST_INITIALIZER("close-input-port", 16, 16),
      SCM_STRING_CONST_INITIALIZER("close-output-port", 17, 17),
      SCM_STRING_CONST_INITIALIZER("read", 4, 4),
      SCM_STRING_CONST_INITIALIZER("read-char", 9, 9),
      SCM_STRING_CONST_INITIALIZER("peek-char", 9, 9),
      SCM_STRING_CONST_INITIALIZER("eof-object?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("char-ready?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("write", 5, 5),
      SCM_STRING_CONST_INITIALIZER("display", 7, 7),
      SCM_STRING_CONST_INITIALIZER("newline", 7, 7),
      SCM_STRING_CONST_INITIALIZER("write-char", 10, 10),
      SCM_STRING_CONST_INITIALIZER("paths", 5, 5),
      SCM_STRING_CONST_INITIALIZER("error-if-not-found", 18, 18),
      SCM_STRING_CONST_INITIALIZER("environment", 11, 11),
      SCM_STRING_CONST_INITIALIZER("ignore-coding", 13, 13),
      SCM_STRING_CONST_INITIALIZER("main-script", 11, 11),
      SCM_STRING_CONST_INITIALIZER("load", 4, 4),
  },
};
static struct scm__rcRec {
  ScmObj d1018[5];
} scm__rc = {
  {   /* ScmObj d1018 */
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
  },
};
static ScmObj stdlib_eqvP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj1_scm;
  ScmObj obj1;
  ScmObj obj2_scm;
  ScmObj obj2;
  SCM_ENTER_SUBR("eqv?");
  obj1_scm = SCM_ARGREF(0);
  obj1 = (obj1_scm);
  obj2_scm = SCM_ARGREF(1);
  obj2 = (obj2_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_EqvP(obj1,obj2));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_eqvP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[0]),SCM_SUBR_IMMEDIATE_ARG, stdlib_eqvP, SCM_MAKE_INT(SCM_VM_EQV), NULL);

static ScmObj stdlib_eqP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj1_scm;
  ScmObj obj1;
  ScmObj obj2_scm;
  ScmObj obj2;
  SCM_ENTER_SUBR("eq?");
  obj1_scm = SCM_ARGREF(0);
  obj1 = (obj1_scm);
  obj2_scm = SCM_ARGREF(1);
  obj2 = (obj2_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_EQ(obj1,obj2));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_eqP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[1]),SCM_SUBR_IMMEDIATE_ARG, stdlib_eqP, SCM_MAKE_INT(SCM_VM_EQ), NULL);

static ScmObj stdlib_equalP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj1_scm;
  ScmObj obj1;
  ScmObj obj2_scm;
  ScmObj obj2;
  SCM_ENTER_SUBR("equal?");
  obj1_scm = SCM_ARGREF(0);
  obj1 = (obj1_scm);
  obj2_scm = SCM_ARGREF(1);
  obj2 = (obj2_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_EqualP(obj1,obj2));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_equalP__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[2]),SCM_SUBR_IMMEDIATE_ARG, stdlib_equalP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_numberP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[3]),SCM_SUBR_IMMEDIATE_ARG, stdlib_numberP, SCM_MAKE_INT(SCM_VM_NUMBERP), NULL);

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

static SCM_DEFINE_SUBRX(stdlib_complexP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[4]),SCM_SUBR_IMMEDIATE_ARG, stdlib_complexP, SCM_MAKE_INT(SCM_VM_NUMBERP), NULL);

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

static SCM_DEFINE_SUBRX(stdlib_realP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[5]),SCM_SUBR_IMMEDIATE_ARG, stdlib_realP, SCM_MAKE_INT(SCM_VM_REALP), NULL);

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

#line 65 "stdlib.stub"
SCM_RESULT=((SCM_REALP(obj))&&(Scm_FiniteP(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_rationalP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[6]),SCM_SUBR_IMMEDIATE_ARG, stdlib_rationalP, NULL, NULL);

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

#line 67 "stdlib.stub"
SCM_RESULT=((SCM_NUMBERP(obj))&&(Scm_IntegerP(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_integerP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[7]),SCM_SUBR_IMMEDIATE_ARG, stdlib_integerP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_exactP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[8]),SCM_SUBR_IMMEDIATE_ARG, stdlib_exactP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_inexactP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[9]),SCM_SUBR_IMMEDIATE_ARG, stdlib_inexactP, NULL, NULL);

static ScmObj stdlib__3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj* oarg;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("=");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  oarg = &SCM_ARGREF(2);
  optcnt = SCM_ARGCNT-1-2;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
int SCM_RESULT;

#line 107 "stdlib.stub"
{SCM_RESULT=(FALSE);if (!(Scm_NumEq(arg0,arg1))){}else if((optcnt)==(0)){SCM_RESULT=(TRUE);}else if(!(Scm_NumEq(arg1,(oarg)[0]))){}else if((optcnt)==(1)){SCM_RESULT=(TRUE);}else if(!(Scm_NumEq((oarg)[0],(oarg)[1]))){}else if(((optcnt)==(2))&&(SCM_NULLP(args))){SCM_RESULT=(TRUE);} else {arg0=((oarg)[1]),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));for (;;){if (!(Scm_NumEq(arg0,arg1))){break;}else if(SCM_NULLP(args)){SCM_RESULT=(TRUE);break;} else {arg0=(arg1),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));}}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__3d__STUB, 2, 3,1, SCM_OBJ(&scm__sc.d1003[10]),SCM_SUBR_IMMEDIATE_ARG, stdlib__3d, NULL, NULL);

static ScmObj stdlib__LT(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj* oarg;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("<");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  oarg = &SCM_ARGREF(2);
  optcnt = SCM_ARGCNT-1-2;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
int SCM_RESULT;

#line 109 "stdlib.stub"
{SCM_RESULT=(FALSE);if (!(Scm_NumLT(arg0,arg1))){}else if((optcnt)==(0)){SCM_RESULT=(TRUE);}else if(!(Scm_NumLT(arg1,(oarg)[0]))){}else if((optcnt)==(1)){SCM_RESULT=(TRUE);}else if(!(Scm_NumLT((oarg)[0],(oarg)[1]))){}else if(((optcnt)==(2))&&(SCM_NULLP(args))){SCM_RESULT=(TRUE);} else {arg0=((oarg)[1]),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));for (;;){if (!(Scm_NumLT(arg0,arg1))){break;}else if(SCM_NULLP(args)){SCM_RESULT=(TRUE);break;} else {arg0=(arg1),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));}}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__LT__STUB, 2, 3,1, SCM_OBJ(&scm__sc.d1003[11]),SCM_SUBR_IMMEDIATE_ARG, stdlib__LT, NULL, NULL);

static ScmObj stdlib__LT_3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj* oarg;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("<=");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  oarg = &SCM_ARGREF(2);
  optcnt = SCM_ARGCNT-1-2;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
int SCM_RESULT;

#line 111 "stdlib.stub"
{SCM_RESULT=(FALSE);if (!(Scm_NumLE(arg0,arg1))){}else if((optcnt)==(0)){SCM_RESULT=(TRUE);}else if(!(Scm_NumLE(arg1,(oarg)[0]))){}else if((optcnt)==(1)){SCM_RESULT=(TRUE);}else if(!(Scm_NumLE((oarg)[0],(oarg)[1]))){}else if(((optcnt)==(2))&&(SCM_NULLP(args))){SCM_RESULT=(TRUE);} else {arg0=((oarg)[1]),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));for (;;){if (!(Scm_NumLE(arg0,arg1))){break;}else if(SCM_NULLP(args)){SCM_RESULT=(TRUE);break;} else {arg0=(arg1),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));}}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__LT_3d__STUB, 2, 3,1, SCM_OBJ(&scm__sc.d1003[12]),SCM_SUBR_IMMEDIATE_ARG, stdlib__LT_3d, NULL, NULL);

static ScmObj stdlib__GT(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj* oarg;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR(">");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  oarg = &SCM_ARGREF(2);
  optcnt = SCM_ARGCNT-1-2;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
int SCM_RESULT;

#line 113 "stdlib.stub"
{SCM_RESULT=(FALSE);if (!(Scm_NumGT(arg0,arg1))){}else if((optcnt)==(0)){SCM_RESULT=(TRUE);}else if(!(Scm_NumGT(arg1,(oarg)[0]))){}else if((optcnt)==(1)){SCM_RESULT=(TRUE);}else if(!(Scm_NumGT((oarg)[0],(oarg)[1]))){}else if(((optcnt)==(2))&&(SCM_NULLP(args))){SCM_RESULT=(TRUE);} else {arg0=((oarg)[1]),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));for (;;){if (!(Scm_NumGT(arg0,arg1))){break;}else if(SCM_NULLP(args)){SCM_RESULT=(TRUE);break;} else {arg0=(arg1),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));}}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__GT__STUB, 2, 3,1, SCM_OBJ(&scm__sc.d1003[13]),SCM_SUBR_IMMEDIATE_ARG, stdlib__GT, NULL, NULL);

static ScmObj stdlib__GT_3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj* oarg;
  int optcnt;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR(">=");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  oarg = &SCM_ARGREF(2);
  optcnt = SCM_ARGCNT-1-2;
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
int SCM_RESULT;

#line 115 "stdlib.stub"
{SCM_RESULT=(FALSE);if (!(Scm_NumGE(arg0,arg1))){}else if((optcnt)==(0)){SCM_RESULT=(TRUE);}else if(!(Scm_NumGE(arg1,(oarg)[0]))){}else if((optcnt)==(1)){SCM_RESULT=(TRUE);}else if(!(Scm_NumGE((oarg)[0],(oarg)[1]))){}else if(((optcnt)==(2))&&(SCM_NULLP(args))){SCM_RESULT=(TRUE);} else {arg0=((oarg)[1]),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));for (;;){if (!(Scm_NumGE(arg0,arg1))){break;}else if(SCM_NULLP(args)){SCM_RESULT=(TRUE);break;} else {arg0=(arg1),arg1=(SCM_CAR(args)),args=(SCM_CDR(args));}}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__GT_3d__STUB, 2, 3,1, SCM_OBJ(&scm__sc.d1003[14]),SCM_SUBR_IMMEDIATE_ARG, stdlib__GT_3d, NULL, NULL);

static ScmObj stdlib_zeroP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("zero?");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(obj_scm)) Scm_Error("number required, but got %S", obj_scm);
  obj = (obj_scm);
  {
{
int SCM_RESULT;

#line 118 "stdlib.stub"
SCM_RESULT=((SCM_REALP(obj))&&((Scm_Sign(obj))==(0)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

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

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

#line 121 "stdlib.stub"
SCM_RESULT=((Scm_Sign(obj))>(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

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

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

#line 123 "stdlib.stub"
SCM_RESULT=((Scm_Sign(obj))<(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

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

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

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

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

#line 126 "stdlib.stub"
SCM_RESULT=(!(Scm_OddP(obj)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_evenP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[19]),SCM_SUBR_IMMEDIATE_ARG, stdlib_evenP, NULL, NULL);

static ScmObj stdlib_max(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("max");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 129 "stdlib.stub"
Scm_MinMax(arg0,args,NULL,&(SCM_RESULT));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_max__STUB, 1, 1,1, SCM_OBJ(&scm__sc.d1003[20]),0, stdlib_max, NULL, NULL);

static ScmObj stdlib_min(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg0_scm;
  ScmObj arg0;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("min");
  arg0_scm = SCM_ARGREF(0);
  arg0 = (arg0_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 131 "stdlib.stub"
Scm_MinMax(arg0,args,&(SCM_RESULT),NULL);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_min__STUB, 1, 1,1, SCM_OBJ(&scm__sc.d1003[21]),0, stdlib_min, NULL, NULL);

static ScmObj stdlib__2a(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("*");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1006;
#line 134 "stdlib.stub"
if (!(SCM_PAIRP(args))){SCM_RESULT=(SCM_MAKE_INT(1));} else {
{ScmObj r=SCM_CAR(args);
SCM_FOR_EACH(cise__1006,SCM_CDR(args)) {{ScmObj v=SCM_CAR(cise__1006);r=(Scm_Mul(r,v));}}
SCM_RESULT=(r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__2a__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[22]),SCM_SUBR_IMMEDIATE_ARG, stdlib__2a, NULL, NULL);

static ScmObj stdlib__2b(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("+");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1007;
#line 140 "stdlib.stub"
if (!(SCM_PAIRP(args))){SCM_RESULT=(SCM_MAKE_INT(0));} else {
{ScmObj r=SCM_CAR(args);
SCM_FOR_EACH(cise__1007,SCM_CDR(args)) {{ScmObj v=SCM_CAR(cise__1007);r=(Scm_Add(r,v));}}
SCM_RESULT=(r);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj stdlib__(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("-");
  arg1_scm = SCM_ARGREF(0);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1008;
#line 146 "stdlib.stub"
if (SCM_NULLP(args)){
SCM_RESULT=(Scm_VMNegate(arg1));} else {
{SCM_FOR_EACH(cise__1008,args) {{ScmObj v=SCM_CAR(cise__1008);arg1=(Scm_Sub(arg1,v));}}
SCM_RESULT=(arg1);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj stdlib__2f(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("/");
  arg1_scm = SCM_ARGREF(0);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cise__1009;
#line 152 "stdlib.stub"
if (SCM_NULLP(args)){
SCM_RESULT=(Scm_VMReciprocal(arg1));} else {
{SCM_FOR_EACH(cise__1009,args) {{ScmObj v=SCM_CAR(cise__1009);arg1=(Scm_Div(arg1,v));}}
SCM_RESULT=(arg1);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__2f__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[25]),SCM_SUBR_IMMEDIATE_ARG, stdlib__2f, NULL, NULL);

static ScmObj stdlib_abs(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("abs");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMAbs(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_abs__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[26]),SCM_SUBR_IMMEDIATE_ARG, stdlib_abs, NULL, NULL);

static ScmObj stdlib_quotient(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n1_scm;
  ScmObj n1;
  ScmObj n2_scm;
  ScmObj n2;
  SCM_ENTER_SUBR("quotient");
  n1_scm = SCM_ARGREF(0);
  n1 = (n1_scm);
  n2_scm = SCM_ARGREF(1);
  n2 = (n2_scm);
  {
{
ScmObj SCM_RESULT;

#line 160 "stdlib.stub"
SCM_RESULT=(Scm_Quotient(n1,n2,NULL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_quotient__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[27]),SCM_SUBR_IMMEDIATE_ARG, stdlib_quotient, NULL, NULL);

static ScmObj stdlib_remainder(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n1_scm;
  ScmObj n1;
  ScmObj n2_scm;
  ScmObj n2;
  SCM_ENTER_SUBR("remainder");
  n1_scm = SCM_ARGREF(0);
  n1 = (n1_scm);
  n2_scm = SCM_ARGREF(1);
  n2 = (n2_scm);
  {
{
ScmObj SCM_RESULT;

#line 162 "stdlib.stub"
SCM_RESULT=(Scm_Modulo(n1,n2,TRUE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_remainder__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[28]),SCM_SUBR_IMMEDIATE_ARG, stdlib_remainder, NULL, NULL);

static ScmObj stdlib_modulo(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n1_scm;
  ScmObj n1;
  ScmObj n2_scm;
  ScmObj n2;
  SCM_ENTER_SUBR("modulo");
  n1_scm = SCM_ARGREF(0);
  n1 = (n1_scm);
  n2_scm = SCM_ARGREF(1);
  n2 = (n2_scm);
  {
{
ScmObj SCM_RESULT;

#line 164 "stdlib.stub"
SCM_RESULT=(Scm_Modulo(n1,n2,FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_modulo__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[29]),SCM_SUBR_IMMEDIATE_ARG, stdlib_modulo, NULL, NULL);

static ScmObj stdlib__25gcd(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n1_scm;
  ScmObj n1;
  ScmObj n2_scm;
  ScmObj n2;
  SCM_ENTER_SUBR("%gcd");
  n1_scm = SCM_ARGREF(0);
  n1 = (n1_scm);
  n2_scm = SCM_ARGREF(1);
  n2 = (n2_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Gcd(n1,n2));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25gcd__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[30]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25gcd, NULL, NULL);

static ScmObj stdlib_numerator(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  ScmObj n;
  SCM_ENTER_SUBR("numerator");
  n_scm = SCM_ARGREF(0);
  n = (n_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Numerator(n));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj stdlib_denominator(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj n_scm;
  ScmObj n;
  SCM_ENTER_SUBR("denominator");
  n_scm = SCM_ARGREF(0);
  n = (n_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Denominator(n));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_denominator__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[32]),SCM_SUBR_IMMEDIATE_ARG, stdlib_denominator, NULL, NULL);

static ScmObj stdlib_floor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmObj v;
  SCM_ENTER_SUBR("floor");
  v_scm = SCM_ARGREF(0);
  v = (v_scm);
  {
{
ScmObj SCM_RESULT;

#line 172 "stdlib.stub"
SCM_RESULT=(Scm_Round(v,SCM_ROUND_FLOOR));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_floor__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[33]),SCM_SUBR_IMMEDIATE_ARG, stdlib_floor, NULL, NULL);

static ScmObj stdlib_ceiling(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmObj v;
  SCM_ENTER_SUBR("ceiling");
  v_scm = SCM_ARGREF(0);
  v = (v_scm);
  {
{
ScmObj SCM_RESULT;

#line 174 "stdlib.stub"
SCM_RESULT=(Scm_Round(v,SCM_ROUND_CEIL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_ceiling__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[34]),SCM_SUBR_IMMEDIATE_ARG, stdlib_ceiling, NULL, NULL);

static ScmObj stdlib_truncate(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmObj v;
  SCM_ENTER_SUBR("truncate");
  v_scm = SCM_ARGREF(0);
  v = (v_scm);
  {
{
ScmObj SCM_RESULT;

#line 176 "stdlib.stub"
SCM_RESULT=(Scm_Round(v,SCM_ROUND_TRUNC));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_truncate__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[35]),SCM_SUBR_IMMEDIATE_ARG, stdlib_truncate, NULL, NULL);

static ScmObj stdlib_round(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj v_scm;
  ScmObj v;
  SCM_ENTER_SUBR("round");
  v_scm = SCM_ARGREF(0);
  v = (v_scm);
  {
{
ScmObj SCM_RESULT;

#line 178 "stdlib.stub"
SCM_RESULT=(Scm_Round(v,SCM_ROUND_ROUND));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_round__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[36]),SCM_SUBR_IMMEDIATE_ARG, stdlib_round, NULL, NULL);

static ScmObj stdlib__25exp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%exp");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(exp(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25exp__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[37]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25exp, NULL, NULL);

static ScmObj stdlib__25log(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("%log");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  {
{
ScmObj SCM_RESULT;

#line 188 "stdlib.stub"
if (!(SCM_REALP(x))){{SCM_TYPE_ERROR(x,"real number");}}

#line 189 "stdlib.stub"
if ((Scm_Sign(x))<(0)){
SCM_RESULT=(Scm_MakeComplex(log(-(Scm_GetDouble(x))),M_PI));} else {
#line 193 "stdlib.stub"
SCM_RESULT=(Scm_VMReturnFlonum(log(Scm_GetDouble(x))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25log__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[38]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25log, NULL, NULL);

static ScmObj stdlib__25sin(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%sin");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(sin(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25sin__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[39]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25sin, NULL, NULL);

static ScmObj stdlib__25cos(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%cos");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(cos(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25cos__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[40]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25cos, NULL, NULL);

static ScmObj stdlib__25tan(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%tan");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(tan(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25tan__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[41]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25tan, NULL, NULL);

static ScmObj stdlib__25asin(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%asin");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
ScmObj SCM_RESULT;

#line 200 "stdlib.stub"
if ((x)>(1.0)){
SCM_RESULT=(Scm_MakeComplex((M_PI)/(2.0),
-(log((x)+(sqrt(((x)*(x))-(1.0)))))));}else if(
(x)<(-1.0)){
SCM_RESULT=(Scm_MakeComplex((-(M_PI))/(2.0),
-(log((-(x))-(sqrt(((x)*(x))-(1.0)))))));} else {
SCM_RESULT=(Scm_VMReturnFlonum(asin(x)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25asin__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[42]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25asin, NULL, NULL);

static ScmObj stdlib__25acos(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%acos");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
ScmObj SCM_RESULT;

#line 209 "stdlib.stub"
if ((x)>(1.0)){
SCM_RESULT=(Scm_MakeComplex(0,log((x)+(sqrt(((x)*(x))-(1.0))))));}else if(
(x)<(-1.0)){
SCM_RESULT=(Scm_MakeComplex(0,log((x)+(sqrt(((x)*(x))-(1.0))))));} else {
SCM_RESULT=(Scm_VMReturnFlonum(acos(x)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25acos__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[43]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25acos, NULL, NULL);

static ScmObj stdlib__25atan(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj z_scm;
  double z;
  ScmObj x_scm;
  ScmObj x;
  SCM_ENTER_SUBR("%atan");
  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);
  z_scm = SCM_ARGREF(0);
  if (!SCM_REALP(z_scm)) Scm_Error("real number required, but got %S", z_scm);
  z = Scm_GetDouble(z_scm);
  if (SCM_ARGCNT > 1+1) {
    x_scm = SCM_ARGREF(1);
  } else {
    x_scm = SCM_UNBOUND;
  }
  x = (x_scm);
  {
{
double SCM_RESULT;

#line 216 "stdlib.stub"
if (SCM_UNBOUNDP(x)){SCM_RESULT=(atan(z));} else {
if (!(SCM_REALP(x))){{SCM_TYPE_ERROR(x,"real number");}}
SCM_RESULT=(atan2(z,Scm_GetDouble(x)));}
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25atan__STUB, 1, 2,1, SCM_OBJ(&scm__sc.d1003[44]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25atan, NULL, NULL);

static ScmObj stdlib__25sinh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%sinh");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(sinh(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25sinh__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[45]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25sinh, NULL, NULL);

static ScmObj stdlib__25cosh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%cosh");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(cosh(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25cosh__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[46]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25cosh, NULL, NULL);

static ScmObj stdlib__25tanh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%tanh");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(tanh(x));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25tanh__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[47]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25tanh, NULL, NULL);

static ScmObj stdlib__25sqrt(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  double x;
  SCM_ENTER_SUBR("%sqrt");
  x_scm = SCM_ARGREF(0);
  if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
  x = Scm_GetDouble(x_scm);
  {
{
ScmObj SCM_RESULT;

#line 226 "stdlib.stub"
if ((x)<(0)){
SCM_RESULT=(Scm_MakeComplex(0.0,sqrt(-(x))));} else {
SCM_RESULT=(Scm_VMReturnFlonum(sqrt(x)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25sqrt__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[48]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25sqrt, NULL, NULL);

static ScmObj stdlib__25expt(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj y_scm;
  ScmObj y;
  SCM_ENTER_SUBR("%expt");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  y_scm = SCM_ARGREF(1);
  y = (y_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Expt(x,y));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib__25expt__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[49]),SCM_SUBR_IMMEDIATE_ARG, stdlib__25expt, NULL, NULL);

static ScmObj stdlib_make_rectangular(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj a_scm;
  double a;
  ScmObj b_scm;
  double b;
  SCM_ENTER_SUBR("make-rectangular");
  a_scm = SCM_ARGREF(0);
  if (!SCM_REALP(a_scm)) Scm_Error("real number required, but got %S", a_scm);
  a = Scm_GetDouble(a_scm);
  b_scm = SCM_ARGREF(1);
  if (!SCM_REALP(b_scm)) Scm_Error("real number required, but got %S", b_scm);
  b = Scm_GetDouble(b_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeComplex(a,b));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_make_rectangular__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[50]),SCM_SUBR_IMMEDIATE_ARG, stdlib_make_rectangular, NULL, NULL);

static ScmObj stdlib_make_polar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj r_scm;
  double r;
  ScmObj t_scm;
  double t;
  SCM_ENTER_SUBR("make-polar");
  r_scm = SCM_ARGREF(0);
  if (!SCM_REALP(r_scm)) Scm_Error("real number required, but got %S", r_scm);
  r = Scm_GetDouble(r_scm);
  t_scm = SCM_ARGREF(1);
  if (!SCM_REALP(t_scm)) Scm_Error("real number required, but got %S", t_scm);
  t = Scm_GetDouble(t_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeComplexPolar(r,t));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_make_polar__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[51]),SCM_SUBR_IMMEDIATE_ARG, stdlib_make_polar, NULL, NULL);

static ScmObj stdlib_real_part(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj z_scm;
  ScmObj z;
  SCM_ENTER_SUBR("real-part");
  z_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(z_scm)) Scm_Error("number required, but got %S", z_scm);
  z = (z_scm);
  {
{
ScmObj SCM_RESULT;

#line 238 "stdlib.stub"
if (SCM_REALP(z)){
SCM_RESULT=(z);} else {
SCM_RESULT=(Scm_VMReturnFlonum(SCM_COMPNUM_REAL(z)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_real_part__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[52]),SCM_SUBR_IMMEDIATE_ARG, stdlib_real_part, NULL, NULL);

static ScmObj stdlib_imag_part(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj z_scm;
  ScmObj z;
  SCM_ENTER_SUBR("imag-part");
  z_scm = SCM_ARGREF(0);
  if (!SCM_NUMBERP(z_scm)) Scm_Error("number required, but got %S", z_scm);
  z = (z_scm);
  {
{
ScmObj SCM_RESULT;

#line 243 "stdlib.stub"
if (SCM_EXACTP(z)){SCM_RESULT=(SCM_MAKE_INT(0));}else if(
SCM_REALP(z)){SCM_RESULT=(Scm_VMReturnFlonum(0.0));} else {
SCM_RESULT=(Scm_VMReturnFlonum(SCM_COMPNUM_IMAG(z)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_imag_part__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[53]),SCM_SUBR_IMMEDIATE_ARG, stdlib_imag_part, NULL, NULL);

static ScmObj stdlib_magnitude(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj z_scm;
  ScmObj z;
  SCM_ENTER_SUBR("magnitude");
  z_scm = SCM_ARGREF(0);
  z = (z_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(Scm_Magnitude(z));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_magnitude__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[54]),SCM_SUBR_IMMEDIATE_ARG, stdlib_magnitude, NULL, NULL);

static ScmObj stdlib_angle(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj z_scm;
  ScmObj z;
  SCM_ENTER_SUBR("angle");
  z_scm = SCM_ARGREF(0);
  z = (z_scm);
  {
{
double SCM_RESULT;
SCM_RESULT=(Scm_Angle(z));
SCM_RETURN(Scm_VMReturnFlonum(SCM_RESULT));
}
  }
}

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

static ScmObj stdlib_exact_TOinexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("exact->inexact");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Inexact(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_exact_TOinexact__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[56]),SCM_SUBR_IMMEDIATE_ARG, stdlib_exact_TOinexact, NULL, NULL);

static ScmObj stdlib_inexact_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("inexact->exact");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Exact(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

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

#line 255 "stdlib.stub"
SCM_RESULT=(Scm_NumberToString(obj,radix,!(SCM_FALSEP(use_upperP))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_number_TOstring__STUB, 1, 3,1, SCM_OBJ(&scm__sc.d1003[58]),SCM_SUBR_IMMEDIATE_ARG, stdlib_number_TOstring, NULL, NULL);

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

#line 258 "stdlib.stub"
SCM_RESULT=(Scm_StringToNumber(obj,radix,FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_TOnumber__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[59]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_TOnumber, NULL, NULL);

static ScmObj stdlib_not(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("not");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_FALSEP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_not__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[60]),SCM_SUBR_IMMEDIATE_ARG, stdlib_not, SCM_MAKE_INT(SCM_VM_NOT), NULL);

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

static SCM_DEFINE_SUBRX(stdlib_booleanP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[61]),SCM_SUBR_IMMEDIATE_ARG, stdlib_booleanP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_pairP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[62]),SCM_SUBR_IMMEDIATE_ARG, stdlib_pairP, SCM_MAKE_INT(SCM_VM_PAIRP), NULL);

static ScmObj stdlib_cons(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj1_scm;
  ScmObj obj1;
  ScmObj obj2_scm;
  ScmObj obj2;
  SCM_ENTER_SUBR("cons");
  obj1_scm = SCM_ARGREF(0);
  obj1 = (obj1_scm);
  obj2_scm = SCM_ARGREF(1);
  obj2 = (obj2_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Cons(obj1,obj2));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_cons__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[63]),stdlib_cons, SCM_MAKE_INT(SCM_VM_CONS), NULL);

static ScmObj stdlib_car(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmPair* obj;
  SCM_ENTER_SUBR("car");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
  obj = SCM_PAIR(obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(SCM_CAR(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_car__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[64]),SCM_SUBR_IMMEDIATE_ARG, stdlib_car, SCM_MAKE_INT(SCM_VM_CAR), NULL);

static ScmObj stdlib_cdr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmPair* obj;
  SCM_ENTER_SUBR("cdr");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
  obj = SCM_PAIR(obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(SCM_CDR(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_cdr__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[65]),SCM_SUBR_IMMEDIATE_ARG, stdlib_cdr, SCM_MAKE_INT(SCM_VM_CDR), NULL);

static ScmObj stdlib_set_carX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmPair* obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("set-car!");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
  obj = SCM_PAIR(obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {
SCM_SET_CAR(obj,value);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_set_carX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[66]),stdlib_set_carX, NULL, NULL);

static ScmObj stdlib_set_cdrX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmPair* obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("set-cdr!");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
  obj = SCM_PAIR(obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {
SCM_SET_CDR(obj,value);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_set_cdrX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[67]),stdlib_set_cdrX, NULL, NULL);

#define CXR_SETTER(PRE, pre, tail) ScmObj cell = Scm_C##tail##r(obj); if (!SCM_PAIRP(cell)) Scm_Error("can't set c" #pre #tail "r of %S", obj); SCM_SET_C##PRE##R(cell, value);

static ScmObj stdlib_caar_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("(setter caar)");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {

#line 290 "stdlib.stub"
CXR_SETTER(A,a,a);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_caar_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[69]),stdlib_caar_SETTER, NULL, NULL);

static ScmObj stdlib_caar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("caar");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Caar(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_caar__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[68]),SCM_SUBR_IMMEDIATE_ARG, stdlib_caar, SCM_MAKE_INT(SCM_VM_CAAR), NULL);

static ScmObj stdlib_cadr_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("(setter cadr)");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {

#line 292 "stdlib.stub"
CXR_SETTER(A,a,d);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_cadr_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[71]),stdlib_cadr_SETTER, NULL, NULL);

static ScmObj stdlib_cadr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("cadr");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Cadr(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_cadr__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[70]),SCM_SUBR_IMMEDIATE_ARG, stdlib_cadr, SCM_MAKE_INT(SCM_VM_CADR), NULL);

static ScmObj stdlib_cdar_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("(setter cdar)");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {

#line 294 "stdlib.stub"
CXR_SETTER(D,d,a);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_cdar_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[73]),stdlib_cdar_SETTER, NULL, NULL);

static ScmObj stdlib_cdar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("cdar");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Cdar(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_cdar__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[72]),SCM_SUBR_IMMEDIATE_ARG, stdlib_cdar, SCM_MAKE_INT(SCM_VM_CDAR), NULL);

static ScmObj stdlib_cddr_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("(setter cddr)");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {

#line 296 "stdlib.stub"
CXR_SETTER(D,d,d);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_cddr_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[75]),stdlib_cddr_SETTER, NULL, NULL);

static ScmObj stdlib_cddr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("cddr");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Cddr(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_cddr__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[74]),SCM_SUBR_IMMEDIATE_ARG, stdlib_cddr, SCM_MAKE_INT(SCM_VM_CDDR), NULL);

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

static SCM_DEFINE_SUBRX(stdlib_nullP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[76]),SCM_SUBR_IMMEDIATE_ARG, stdlib_nullP, SCM_MAKE_INT(SCM_VM_NULLP), NULL);

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

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

static ScmObj stdlib_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("list");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 303 "stdlib.stub"
SCM_RESULT=(args);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_list__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[78]),SCM_SUBR_IMMEDIATE_ARG, stdlib_list, SCM_MAKE_INT(SCM_VM_LIST), NULL);

static ScmObj stdlib_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("length");
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  {
{
long SCM_RESULT;

#line 306 "stdlib.stub"
{long len=Scm_Length(list);
if ((len)<(0)){{Scm_Error("bad list: %S",list);}}
SCM_RESULT=(len);}
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_length__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[79]),0, stdlib_length, SCM_MAKE_INT(SCM_VM_LENGTH), NULL);

static ScmObj stdlib_length_2b(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("length+");
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;

#line 311 "stdlib.stub"
{int i=Scm_Length(list);
if ((i)<(0)){SCM_RESULT=(SCM_FALSE);} else {SCM_RESULT=(Scm_MakeInteger(i));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_length_2b__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[80]),0, stdlib_length_2b, NULL, NULL);

static ScmObj stdlib_append(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj lists_scm;
  ScmObj lists;
  SCM_ENTER_SUBR("append");
  lists_scm = SCM_ARGREF(SCM_ARGCNT-1);
  lists = (lists_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Append(lists));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_append__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[81]),SCM_SUBR_IMMEDIATE_ARG, stdlib_append, SCM_MAKE_INT(SCM_VM_APPEND), NULL);

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

static SCM_DEFINE_SUBR(stdlib_reverse__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[82]),stdlib_reverse, NULL, NULL);

static ScmObj stdlib_list_tail(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj k_scm;
  int k;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("list-tail");
  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);
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  k_scm = SCM_ARGREF(1);
  if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
  k = SCM_INT_VALUE(k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ListTail(list,k,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_list_tail__STUB, 2, 2,1, SCM_OBJ(&scm__sc.d1003[83]),0, stdlib_list_tail, NULL, NULL);

static ScmObj stdlib_list_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj k_scm;
  int k;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("list-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);
  list_scm = SCM_ARGREF(0);
  list = (list_scm);
  k_scm = SCM_ARGREF(1);
  if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
  k = SCM_INT_VALUE(k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ListRef(list,k,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_list_ref__STUB, 2, 2,1, SCM_OBJ(&scm__sc.d1003[84]),0, stdlib_list_ref, NULL, NULL);

static ScmObj stdlib_memq(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("memq");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Memq(obj,list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_memq__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[85]),0, stdlib_memq, SCM_MAKE_INT(SCM_VM_MEMQ), NULL);

static ScmObj stdlib_memv(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("memv");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Memv(obj,list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_memv__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[86]),0, stdlib_memv, SCM_MAKE_INT(SCM_VM_MEMV), NULL);

static ScmObj stdlib_member(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("member");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  list_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;

#line 325 "stdlib.stub"
SCM_RESULT=(Scm_Member(obj,list,SCM_CMP_EQUAL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_member__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[87]),stdlib_member, NULL, NULL);

static ScmObj stdlib_assq(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj alist_scm;
  ScmObj alist;
  SCM_ENTER_SUBR("assq");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  alist_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
  alist = (alist_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Assq(obj,alist));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_assq__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[88]),0, stdlib_assq, SCM_MAKE_INT(SCM_VM_ASSQ), NULL);

static ScmObj stdlib_assv(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj alist_scm;
  ScmObj alist;
  SCM_ENTER_SUBR("assv");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  alist_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
  alist = (alist_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Assv(obj,alist));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_assv__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[89]),0, stdlib_assv, SCM_MAKE_INT(SCM_VM_ASSV), NULL);

static ScmObj stdlib_assoc(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  ScmObj alist_scm;
  ScmObj alist;
  SCM_ENTER_SUBR("assoc");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  alist_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
  alist = (alist_scm);
  {
{
ScmObj SCM_RESULT;

#line 330 "stdlib.stub"
SCM_RESULT=(Scm_Assoc(obj,alist,SCM_CMP_EQUAL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_assoc__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[90]),stdlib_assoc, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_symbolP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[91]),SCM_SUBR_IMMEDIATE_ARG, stdlib_symbolP, SCM_MAKE_INT(SCM_VM_SYMBOLP), NULL);

static ScmObj stdlib_symbol_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmSymbol* obj;
  SCM_ENTER_SUBR("symbol->string");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(obj_scm)) Scm_Error("symbol required, but got %S", obj_scm);
  obj = SCM_SYMBOL(obj_scm);
  {
{
ScmObj SCM_RESULT;

#line 340 "stdlib.stub"
SCM_RESULT=(SCM_OBJ(SCM_SYMBOL_NAME(obj)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_symbol_TOstring__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[92]),SCM_SUBR_IMMEDIATE_ARG, stdlib_symbol_TOstring, NULL, NULL);

static ScmObj stdlib_string_TOsymbol(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmString* obj;
  SCM_ENTER_SUBR("string->symbol");
  obj_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(obj_scm)) Scm_Error("string required, but got %S", obj_scm);
  obj = SCM_STRING(obj_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Intern(obj));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_TOsymbol__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[93]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_TOsymbol, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_charP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[94]),SCM_SUBR_IMMEDIATE_ARG, stdlib_charP, SCM_MAKE_INT(SCM_VM_CHARP), NULL);

static ScmObj stdlib_char_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 364 "stdlib.stub"
while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)==(c2));break;}else if((c1)==(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[95]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_3dP, NULL, NULL);

static ScmObj stdlib_char_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char<?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 366 "stdlib.stub"
while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)<(c2));break;}else if((c1)<(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_LTP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[96]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_LTP, NULL, NULL);

static ScmObj stdlib_char_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char>?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 368 "stdlib.stub"
while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)>(c2));break;}else if((c1)>(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_GTP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[97]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_GTP, NULL, NULL);

static ScmObj stdlib_char_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char<=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 370 "stdlib.stub"
while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)<=(c2));break;}else if((c1)<=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_LT_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[98]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_LT_3dP, NULL, NULL);

static ScmObj stdlib_char_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char>=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 372 "stdlib.stub"
while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)>=(c2));break;}else if((c1)>=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(SCM_CHAR_VALUE(SCM_CAR(chars)));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_GT_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[99]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_GT_3dP, NULL, NULL);

static ScmObj stdlib_char_ci_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-ci=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 392 "stdlib.stub"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)==(c2));break;}else if((c1)==(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_ci_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[100]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_ci_3dP, NULL, NULL);

static ScmObj stdlib_char_ci_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-ci<?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 394 "stdlib.stub"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)<(c2));break;}else if((c1)<(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_ci_LTP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[101]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_ci_LTP, NULL, NULL);

static ScmObj stdlib_char_ci_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-ci>?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 396 "stdlib.stub"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)>(c2));break;}else if((c1)>(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_ci_GTP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[102]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_ci_GTP, NULL, NULL);

static ScmObj stdlib_char_ci_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-ci<=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 398 "stdlib.stub"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)<=(c2));break;}else if((c1)<=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_ci_LT_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[103]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_ci_LT_3dP, NULL, NULL);

static ScmObj stdlib_char_ci_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj c1_scm;
  ScmChar c1;
  ScmObj c2_scm;
  ScmChar c2;
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("char-ci>=?");
  c1_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
  c1 = SCM_CHAR_VALUE(c1_scm);
  c2_scm = SCM_ARGREF(1);
  if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
  c2 = SCM_CHAR_VALUE(c2_scm);
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
int SCM_RESULT;

#line 400 "stdlib.stub"
{c1=(Scm_CharFoldcase(c1));c2=(Scm_CharFoldcase(c2));while(1){if (!(SCM_PAIRP(chars))){SCM_RESULT=((c1)>=(c2));break;}else if((c1)>=(c2)){if (!(SCM_CHARP(SCM_CAR(chars)))){{Scm_TypeError("char","character",SCM_CAR(chars));}}c1=(c2);c2=(Scm_CharFoldcase(SCM_CHAR_VALUE(SCM_CAR(chars))));chars=(SCM_CDR(chars));} else {SCM_RESULT=(FALSE);break;}}}
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_ci_GT_3dP__STUB, 2, 1,1, SCM_OBJ(&scm__sc.d1003[104]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_ci_GT_3dP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_alphabeticP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[105]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_alphabeticP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_numericP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[106]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_numericP, NULL, NULL);

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

#line 405 "stdlib.stub"
SCM_RESULT=(((SCM_CHAR_ASCII_P(c))&&(isspace(c)))||(
SCM_CHAR_EXTRA_WHITESPACE(c)));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_whitespaceP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[107]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_whitespaceP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_upper_caseP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[108]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_upper_caseP, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_lower_caseP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[109]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_lower_caseP, NULL, NULL);

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

#line 411 "stdlib.stub"
SCM_RESULT=(((signed long )(c)));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_char_TOinteger__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[110]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_TOinteger, NULL, NULL);

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

#line 413 "stdlib.stub"
SCM_RESULT=(((ScmChar )(c)));
SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_integer_TOchar__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[111]),SCM_SUBR_IMMEDIATE_ARG, stdlib_integer_TOchar, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_upcase__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[112]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_upcase, NULL, NULL);

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

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

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

static SCM_DEFINE_SUBRX(stdlib_stringP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[114]),SCM_SUBR_IMMEDIATE_ARG, stdlib_stringP, SCM_MAKE_INT(SCM_VM_STRINGP), NULL);

static ScmObj stdlib_make_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj len_scm;
  int len;
  ScmObj c_scm;
  ScmChar c;
  SCM_ENTER_SUBR("make-string");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  len_scm = SCM_ARGREF(0);
  if (!SCM_INTP(len_scm)) Scm_Error("small integer required, but got %S", len_scm);
  len = SCM_INT_VALUE(len_scm);
  if (SCM_ARGCNT > 1+1) {
    c_scm = SCM_ARGREF(1);
  } else {
    c_scm = SCM_MAKE_CHAR(32);
  }
  if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
  c = SCM_CHAR_VALUE(c_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeFillString(len,c));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_make_string__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[115]),SCM_SUBR_IMMEDIATE_ARG, stdlib_make_string, NULL, NULL);

static ScmObj stdlib_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj chars_scm;
  ScmObj chars;
  SCM_ENTER_SUBR("string");
  chars_scm = SCM_ARGREF(SCM_ARGCNT-1);
  chars = (chars_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ListToString(chars));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[116]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string, NULL, NULL);

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

#line 431 "stdlib.stub"
SCM_RESULT=(SCM_STRING_BODY_LENGTH(SCM_STRING_BODY(str)));
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

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

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

#line 437 "stdlib.stub"
{ScmChar r=Scm_StringRef(str,k,SCM_UNBOUNDP(fallback));
SCM_RESULT=((((r)==(SCM_CHAR_INVALID))?(fallback):(SCM_MAKE_CHAR(r))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ref__STUB, 2, 2,1, SCM_OBJ(&scm__sc.d1003[118]),0, stdlib_string_ref, NULL, NULL);

static ScmObj stdlib_string_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_StringEqual(s1,s2));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[119]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_3dP, NULL, NULL);

static ScmObj stdlib_string_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string<?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 446 "stdlib.stub"
SCM_RESULT=((Scm_StringCmp(s1,s2))<(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

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

static ScmObj stdlib_string_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string>?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 448 "stdlib.stub"
SCM_RESULT=((Scm_StringCmp(s1,s2))>(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_GTP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[121]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_GTP, NULL, NULL);

static ScmObj stdlib_string_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string<=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 450 "stdlib.stub"
SCM_RESULT=((Scm_StringCmp(s1,s2))<=(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_LT_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[122]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_LT_3dP, NULL, NULL);

static ScmObj stdlib_string_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string>=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 452 "stdlib.stub"
SCM_RESULT=((Scm_StringCmp(s1,s2))>=(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_GT_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[123]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_GT_3dP, NULL, NULL);

static ScmObj stdlib_string_ci_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string-ci=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 455 "stdlib.stub"
SCM_RESULT=((Scm_StringCiCmp(s1,s2))==(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ci_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[124]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_ci_3dP, NULL, NULL);

static ScmObj stdlib_string_ci_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string-ci<?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 457 "stdlib.stub"
SCM_RESULT=((Scm_StringCiCmp(s1,s2))<(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ci_LTP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[125]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_ci_LTP, NULL, NULL);

static ScmObj stdlib_string_ci_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string-ci>?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 459 "stdlib.stub"
SCM_RESULT=((Scm_StringCiCmp(s1,s2))>(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ci_GTP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[126]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_ci_GTP, NULL, NULL);

static ScmObj stdlib_string_ci_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string-ci<=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 461 "stdlib.stub"
SCM_RESULT=((Scm_StringCiCmp(s1,s2))<=(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ci_LT_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[127]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_ci_LT_3dP, NULL, NULL);

static ScmObj stdlib_string_ci_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj s1_scm;
  ScmString* s1;
  ScmObj s2_scm;
  ScmString* s2;
  SCM_ENTER_SUBR("string-ci>=?");
  s1_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
  s1 = SCM_STRING(s1_scm);
  s2_scm = SCM_ARGREF(1);
  if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
  s2 = SCM_STRING(s2_scm);
  {
{
int SCM_RESULT;

#line 463 "stdlib.stub"
SCM_RESULT=((Scm_StringCiCmp(s1,s2))>=(0));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_ci_GT_3dP__STUB, 2, 0,1, SCM_OBJ(&scm__sc.d1003[128]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_ci_GT_3dP, NULL, NULL);

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

#line 466 "stdlib.stub"
SCM_RESULT=(Scm_Substring(str,start,end,FALSE));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_substring__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[129]),SCM_SUBR_IMMEDIATE_ARG, stdlib_substring, NULL, NULL);

static ScmObj stdlib_string_append(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("string-append");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_StringAppend(args));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_string_append__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[130]),SCM_SUBR_IMMEDIATE_ARG, stdlib_string_append, NULL, NULL);

static ScmObj stdlib_string_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj start_scm;
  ScmObj start;
  ScmObj end_scm;
  ScmObj end;
  SCM_ENTER_SUBR("string->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);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_ARGREF(1);
  } else {
    start_scm = SCM_UNBOUND;
  }
  start = (start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_ARGREF(2);
  } else {
    end_scm = SCM_UNBOUND;
  }
  end = (end_scm);
  {
{
ScmObj SCM_RESULT;

#line 471 "stdlib.stub"
SCM_RESULT=(Scm_StringToList(SCM_STRING(Scm_MaybeSubstring(str,start,end))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_string_TOlist__STUB, 1, 3,SCM_OBJ(&scm__sc.d1003[131]),stdlib_string_TOlist, NULL, NULL);

static ScmObj stdlib_list_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  SCM_ENTER_SUBR("list->string");
  list_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ListToString(list));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_list_TOstring__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[132]),SCM_SUBR_IMMEDIATE_ARG, stdlib_list_TOstring, NULL, NULL);

static ScmObj stdlib_string_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj str_scm;
  ScmString* str;
  ScmObj start_scm;
  ScmObj start;
  ScmObj end_scm;
  ScmObj end;
  SCM_ENTER_SUBR("string-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);
  str_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
  str = SCM_STRING(str_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_ARGREF(1);
  } else {
    start_scm = SCM_UNBOUND;
  }
  start = (start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_ARGREF(2);
  } else {
    end_scm = SCM_UNBOUND;
  }
  end = (end_scm);
  {
{
ScmObj SCM_RESULT;

#line 476 "stdlib.stub"
SCM_RESULT=(Scm_CopyString(SCM_STRING(Scm_MaybeSubstring(str,start,end))));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_string_copy__STUB, 1, 3,SCM_OBJ(&scm__sc.d1003[133]),stdlib_string_copy, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_vectorP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[134]),SCM_SUBR_IMMEDIATE_ARG, stdlib_vectorP, SCM_MAKE_INT(SCM_VM_VECTORP), NULL);

static ScmObj stdlib_make_vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj k_scm;
  int k;
  ScmObj fill_scm;
  ScmObj fill;
  SCM_ENTER_SUBR("make-vector");
  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);
  k_scm = SCM_ARGREF(0);
  if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
  k = SCM_INT_VALUE(k_scm);
  if (SCM_ARGCNT > 1+1) {
    fill_scm = SCM_ARGREF(1);
  } else {
    fill_scm = SCM_UNBOUND;
  }
  fill = (fill_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeVector(k,fill));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_make_vector__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[135]),stdlib_make_vector, NULL, NULL);

static ScmObj stdlib_vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("vector");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;

#line 488 "stdlib.stub"
SCM_RESULT=(Scm_ListToVector(args,0,-1));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_vector__STUB, 0, 1,0, SCM_OBJ(&scm__sc.d1003[136]),SCM_SUBR_IMMEDIATE_ARG, stdlib_vector, SCM_MAKE_INT(SCM_VM_VEC), NULL);

static ScmObj stdlib_vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vec_scm;
  ScmVector* vec;
  SCM_ENTER_SUBR("vector-length");
  vec_scm = SCM_ARGREF(0);
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_VECTOR_SIZE(vec));
SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_vector_length__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[137]),SCM_SUBR_IMMEDIATE_ARG, stdlib_vector_length, SCM_MAKE_INT(SCM_VM_VEC_LEN), NULL);

static ScmObj stdlib_vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj k_scm;
  ScmObj k;
  ScmObj fallback_scm;
  ScmObj fallback;
  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);
  vec_scm = SCM_ARGREF(0);
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(k_scm)) Scm_Error("exact integer required, but got %S", k_scm);
  k = (k_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 496 "stdlib.stub"
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);} else {
SCM_RESULT=(SCM_VECTOR_ELEMENT(vec,SCM_INT_VALUE(k)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_vector_ref__STUB, 2, 2,1, SCM_OBJ(&scm__sc.d1003[138]),0, stdlib_vector_ref, NULL, NULL);

static ScmObj stdlib_vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj vec_scm;
  ScmVector* vec;
  ScmObj k_scm;
  ScmObj k;
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("vector-set!");
  vec_scm = SCM_ARGREF(0);
  if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
  vec = SCM_VECTOR(vec_scm);
  k_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(k_scm)) Scm_Error("exact integer required, but got %S", k_scm);
  k = (k_scm);
  obj_scm = SCM_ARGREF(2);
  obj = (obj_scm);
  {

#line 505 "stdlib.stub"
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);}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_vector_setX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[139]),stdlib_vector_setX, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_vector_TOlist__STUB, 1, 3,0, SCM_OBJ(&scm__sc.d1003[140]),SCM_SUBR_IMMEDIATE_ARG, stdlib_vector_TOlist, NULL, NULL);

static ScmObj stdlib_list_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj list_scm;
  ScmObj list;
  ScmObj start_scm;
  int start;
  ScmObj end_scm;
  int end;
  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);
  list_scm = SCM_ARGREF(0);
  if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
  list = (list_scm);
  if (SCM_ARGCNT > 1+1) {
    start_scm = SCM_ARGREF(1);
  } else {
    start_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
  start = SCM_INT_VALUE(start_scm);
  if (SCM_ARGCNT > 2+1) {
    end_scm = SCM_ARGREF(2);
  } else {
    end_scm = SCM_MAKE_INT(-1);
  }
  if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
  end = SCM_INT_VALUE(end_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ListToVector(list,start,end));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_list_TOvector__STUB, 1, 3,0, SCM_OBJ(&scm__sc.d1003[141]),SCM_SUBR_IMMEDIATE_ARG, stdlib_list_TOvector, NULL, NULL);

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

static SCM_DEFINE_SUBR(stdlib_vector_fillX__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[142]),stdlib_vector_fillX, NULL, NULL);

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

static SCM_DEFINE_SUBRX(stdlib_procedureP__STUB, 1, 0,1, SCM_OBJ(&scm__sc.d1003[143]),SCM_SUBR_IMMEDIATE_ARG, stdlib_procedureP, NULL, NULL);

static ScmObj stdlib_apply(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj arg1_scm;
  ScmObj arg1;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("apply");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  arg1_scm = SCM_ARGREF(1);
  arg1 = (arg1_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
ScmObj cp;
#line 532 "stdlib.stub"
{ScmObj head;ScmObj tail;
if (SCM_NULLP(args)){SCM_RESULT=(Scm_VMApply(proc,arg1));} else {
head=(Scm_Cons(arg1,SCM_NIL)),tail=(head);
#line 536 "stdlib.stub"
SCM_FOR_EACH(cp,args){
if (SCM_NULLP(SCM_CDR(cp))){{
SCM_APPEND(head,tail,SCM_CAR(cp));
break;}}
if (!(SCM_PAIRP(SCM_CDR(cp)))){{
Scm_Error("improper list not allowed: %S",SCM_CDR(cp));}}
SCM_APPEND1(head,tail,SCM_CAR(cp));}
SCM_RESULT=(Scm_VMApply(proc,head));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_apply__STUB, 2, 1,SCM_OBJ(&scm__sc.d1003[144]),stdlib_apply, SCM_MAKE_INT(SCM_VM_TAIL_APPLY), NULL);

static ScmObj stdlib_map(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj args_scm;
  ScmObj args;
  ScmObj moreargs_scm;
  ScmObj moreargs;
  SCM_ENTER_SUBR("map");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  args_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(args_scm)) Scm_Error("list required, but got %S", args_scm);
  args = (args_scm);
  moreargs_scm = SCM_ARGREF(SCM_ARGCNT-1);
  moreargs = (moreargs_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Map(proc,args,moreargs));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_map__STUB, 2, 1,SCM_OBJ(&scm__sc.d1003[145]),stdlib_map, NULL, NULL);

static ScmObj stdlib_for_each(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj args_scm;
  ScmObj args;
  ScmObj moreargs_scm;
  ScmObj moreargs;
  SCM_ENTER_SUBR("for-each");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  args_scm = SCM_ARGREF(1);
  if (!SCM_LISTP(args_scm)) Scm_Error("list required, but got %S", args_scm);
  args = (args_scm);
  moreargs_scm = SCM_ARGREF(SCM_ARGCNT-1);
  moreargs = (moreargs_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ForEach(proc,args,moreargs));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_for_each__STUB, 2, 1,SCM_OBJ(&scm__sc.d1003[146]),stdlib_for_each, NULL, NULL);

static ScmObj stdlib_force(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  SCM_ENTER_SUBR("force");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Force(p));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_force__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[147]),stdlib_force, NULL, NULL);

static ScmObj stdlib_call_with_current_continuation(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("call-with-current-continuation");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMCallCC(proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_call_with_current_continuation__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[148]),stdlib_call_with_current_continuation, NULL, NULL);

static ScmObj stdlib_values(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("values");
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_Values(args));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_values__STUB, 0, 1,1, SCM_OBJ(&scm__sc.d1003[149]),SCM_SUBR_IMMEDIATE_ARG, stdlib_values, SCM_MAKE_INT(SCM_VM_VALUES), NULL);

static ScmObj stdlib_dynamic_wind(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj pre_scm;
  ScmObj pre;
  ScmObj body_scm;
  ScmObj body;
  ScmObj post_scm;
  ScmObj post;
  SCM_ENTER_SUBR("dynamic-wind");
  pre_scm = SCM_ARGREF(0);
  pre = (pre_scm);
  body_scm = SCM_ARGREF(1);
  body = (body_scm);
  post_scm = SCM_ARGREF(2);
  post = (post_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMDynamicWind(pre,body,post));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_dynamic_wind__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[150]),stdlib_dynamic_wind, NULL, NULL);

static ScmObj stdlib_eval(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj expr_scm;
  ScmObj expr;
  ScmObj env_scm;
  ScmObj env;
  SCM_ENTER_SUBR("eval");
  expr_scm = SCM_ARGREF(0);
  expr = (expr_scm);
  env_scm = SCM_ARGREF(1);
  env = (env_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMEval(expr,env));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_eval__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[151]),stdlib_eval, NULL, NULL);

static ScmObj stdlib_null_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj version_scm;
  int version;
  SCM_ENTER_SUBR("null-environment");
  version_scm = SCM_ARGREF(0);
  if (!SCM_INTP(version_scm)) Scm_Error("small integer required, but got %S", version_scm);
  version = SCM_INT_VALUE(version_scm);
  {
{
ScmObj SCM_RESULT;

#line 555 "stdlib.stub"
if ((version)!=(5)){{Scm_Error("unknown rNrs version: %d",version);}}

#line 556 "stdlib.stub"
SCM_RESULT=(SCM_OBJ(Scm_NullModule()));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_null_environment__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[152]),SCM_SUBR_IMMEDIATE_ARG, stdlib_null_environment, NULL, NULL);

static ScmObj stdlib_scheme_report_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj version_scm;
  int version;
  SCM_ENTER_SUBR("scheme-report-environment");
  version_scm = SCM_ARGREF(0);
  if (!SCM_INTP(version_scm)) Scm_Error("small integer required, but got %S", version_scm);
  version = SCM_INT_VALUE(version_scm);
  {
{
ScmObj SCM_RESULT;

#line 558 "stdlib.stub"
if ((version)!=(5)){{Scm_Error("unknown rNrs version: %d",version);}}

#line 559 "stdlib.stub"
SCM_RESULT=(SCM_OBJ(Scm_SchemeModule()));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_scheme_report_environment__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[153]),SCM_SUBR_IMMEDIATE_ARG, stdlib_scheme_report_environment, NULL, NULL);

static ScmObj stdlib_interaction_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("interaction-environment");
  {
{
ScmObj SCM_RESULT;

#line 560 "stdlib.stub"
SCM_RESULT=(SCM_OBJ(Scm_UserModule()));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_interaction_environment__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[154]),SCM_SUBR_IMMEDIATE_ARG, stdlib_interaction_environment, NULL, NULL);

static ScmObj stdlib_input_portP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("input-port?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_IPORTP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_input_portP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[155]),stdlib_input_portP, NULL, NULL);

static ScmObj stdlib_output_portP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("output-port?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_OPORTP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_output_portP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[156]),stdlib_output_portP, NULL, NULL);

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

static SCM_DEFINE_SUBR(stdlib_portP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[157]),stdlib_portP, NULL, NULL);

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

#line 574 "stdlib.stub"
if (SCM_IPORTP(newport)){
SCM_RESULT=(Scm_SetCurrentInputPort(SCM_PORT(newport)));}else if(
!(SCM_UNBOUNDP(newport))){
Scm_TypeError("current-input-port","input port",newport);
SCM_RESULT=(SCM_UNDEFINED);} else {
SCM_RESULT=(SCM_OBJ(SCM_CURIN));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_current_input_port__STUB, 0, 2,SCM_OBJ(&scm__sc.d1003[158]),stdlib_current_input_port, NULL, NULL);

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

#line 582 "stdlib.stub"
if (SCM_OPORTP(newport)){
SCM_RESULT=(Scm_SetCurrentOutputPort(SCM_PORT(newport)));}else if(
!(SCM_UNBOUNDP(newport))){
Scm_TypeError("current-output-port","output port",newport);
SCM_RESULT=(SCM_UNDEFINED);} else {
SCM_RESULT=(SCM_OBJ(SCM_CUROUT));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(stdlib_current_output_port__STUB, 0, 2,SCM_OBJ(&scm__sc.d1003[159]),stdlib_current_output_port, NULL, NULL);

static ScmObj stdlib_close_input_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("close-input-port");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
Scm_ClosePort(port);
SCM_RETURN(SCM_UNDEFINED);
  }
}

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

static ScmObj stdlib_close_output_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("close-output-port");
  port_scm = SCM_ARGREF(0);
  if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {
Scm_ClosePort(port);
SCM_RETURN(SCM_UNDEFINED);
  }
}

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

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

#line 597 "stdlib.stub"
SCM_RESULT=(Scm_Read(SCM_OBJ(port)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_read__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[162]),SCM_SUBR_IMMEDIATE_ARG, stdlib_read, NULL, NULL);

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

#line 601 "stdlib.stub"
{int ch;
SCM_GETC(ch,port);
SCM_RESULT=((((ch)==(EOF))?(SCM_EOF):(SCM_MAKE_CHAR(ch))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_read_char__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[163]),SCM_SUBR_IMMEDIATE_ARG, stdlib_read_char, SCM_MAKE_INT(SCM_VM_READ_CHAR), NULL);

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

#line 607 "stdlib.stub"
{ScmChar ch=Scm_Peekc(port);
SCM_RESULT=((((ch)==(SCM_CHAR_INVALID))?(SCM_EOF):(SCM_MAKE_CHAR(ch))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_peek_char__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[164]),SCM_SUBR_IMMEDIATE_ARG, stdlib_peek_char, SCM_MAKE_INT(SCM_VM_PEEK_CHAR), NULL);

static ScmObj stdlib_eof_objectP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj obj_scm;
  ScmObj obj;
  SCM_ENTER_SUBR("eof-object?");
  obj_scm = SCM_ARGREF(0);
  obj = (obj_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(SCM_EOFP(obj));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_eof_objectP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[165]),SCM_SUBR_IMMEDIATE_ARG, stdlib_eof_objectP, SCM_MAKE_INT(SCM_VM_EOFP), NULL);

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

static SCM_DEFINE_SUBRX(stdlib_char_readyP__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[166]),SCM_SUBR_IMMEDIATE_ARG, stdlib_char_readyP, NULL, NULL);

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

#line 621 "stdlib.stub"
Scm_Write(obj,SCM_OBJ(port),SCM_WRITE_WRITE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_write__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[167]),stdlib_write, NULL, NULL);

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

#line 625 "stdlib.stub"
Scm_Write(obj,SCM_OBJ(port),SCM_WRITE_DISPLAY);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(stdlib_display__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[168]),stdlib_display, NULL, NULL);

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

#line 628 "stdlib.stub"
SCM_PUTC('\n',port);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(stdlib_newline__STUB, 0, 2,0, SCM_OBJ(&scm__sc.d1003[169]),SCM_SUBR_IMMEDIATE_ARG, stdlib_newline, NULL, NULL);

static ScmObj stdlib_write_char(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj ch_scm;
  ScmChar ch;
  ScmObj port_scm;
  ScmPort* port;
  SCM_ENTER_SUBR("write-char");
  if (SCM_ARGCNT >= 3
      && !SCM_NULLP(SCM_ARGREF(SCM_ARGCNT-1)))
    Scm_Error("too many arguments: up to 2 is expected, %d given.", SCM_ARGCNT + Scm_Length(SCM_ARGREF(SCM_ARGCNT-1)) - 1);
  ch_scm = SCM_ARGREF(0);
  if (!SCM_CHARP(ch_scm)) Scm_Error("character required, but got %S", ch_scm);
  ch = SCM_CHAR_VALUE(ch_scm);
  if (SCM_ARGCNT > 1+1) {
    port_scm = SCM_ARGREF(1);
  } else {
    port_scm = SCM_OBJ(SCM_CUROUT);
  }
  if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
  port = SCM_PORT(port_scm);
  {

#line 632 "stdlib.stub"
SCM_PUTC(ch,port);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(stdlib_write_char__STUB, 1, 2,0, SCM_OBJ(&scm__sc.d1003[170]),SCM_SUBR_IMMEDIATE_ARG, stdlib_write_char, SCM_MAKE_INT(SCM_VM_WRITE_CHAR), NULL);

static ScmObj stdlib_load(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj file_scm;
  ScmString* file;
  ScmObj paths_scm = SCM_FALSE;
  ScmObj paths;
  ScmObj error_if_not_found_scm = SCM_TRUE;
  ScmObj error_if_not_found;
  ScmObj environment_scm = SCM_FALSE;
  ScmObj environment;
  ScmObj ignore_coding_scm = SCM_FALSE;
  ScmObj ignore_coding;
  ScmObj main_script_scm = SCM_FALSE;
  ScmObj main_script;
  ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  SCM_ENTER_SUBR("load");
  file_scm = SCM_ARGREF(0);
  if (!SCM_STRINGP(file_scm)) Scm_Error("string required, but got %S", file_scm);
  file = SCM_STRING(file_scm);
  if (Scm_Length(SCM_OPTARGS) % 2)
    Scm_Error("keyword list not even: %S", SCM_OPTARGS);
  while (!SCM_NULLP(SCM_OPTARGS)) {
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1018[0])) {
      paths_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1018[1])) {
      error_if_not_found_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1018[2])) {
      environment_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1018[3])) {
      ignore_coding_scm = SCM_CADR(SCM_OPTARGS);
    } else 
    if (SCM_EQ(SCM_CAR(SCM_OPTARGS), scm__rc.d1018[4])) {
      main_script_scm = SCM_CADR(SCM_OPTARGS);
    }
    else Scm_Warn("unknown keyword %S", SCM_CAR(SCM_OPTARGS));
    SCM_OPTARGS = SCM_CDDR(SCM_OPTARGS);
  }
  paths = (paths_scm);
  error_if_not_found = (error_if_not_found_scm);
  environment = (environment_scm);
  ignore_coding = (ignore_coding_scm);
  main_script = (main_script_scm);
  {
{
ScmObj SCM_RESULT;

#line 642 "stdlib.stub"
{int flags=
(((SCM_FALSEP(error_if_not_found))?(SCM_LOAD_QUIET_NOFILE):(0)))|(
(
((SCM_FALSEP(ignore_coding))?(0):(SCM_LOAD_IGNORE_CODING)))|(
((SCM_FALSEP(main_script))?(0):(SCM_LOAD_MAIN_SCRIPT))));
SCM_RESULT=(Scm_VMLoad(file,paths,environment,flags));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(stdlib_load__STUB, 1, 1,0, SCM_OBJ(&scm__sc.d1003[176]),SCM_SUBR_IMMEDIATE_ARG, stdlib_load, NULL, NULL);

void Scm_Init_stdlib(ScmModule *mod){

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eqv?")), SCM_OBJ(&stdlib_eqvP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eq?")), SCM_OBJ(&stdlib_eqP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("equal?")), SCM_OBJ(&stdlib_equalP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("number?")), SCM_OBJ(&stdlib_numberP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("complex?")), SCM_OBJ(&stdlib_complexP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("real?")), SCM_OBJ(&stdlib_realP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("rational?")), SCM_OBJ(&stdlib_rationalP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("integer?")), SCM_OBJ(&stdlib_integerP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("exact?")), SCM_OBJ(&stdlib_exactP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("inexact?")), SCM_OBJ(&stdlib_inexactP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("=")), SCM_OBJ(&stdlib__3d__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("<")), SCM_OBJ(&stdlib__LT__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("<=")), SCM_OBJ(&stdlib__LT_3d__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN(">")), SCM_OBJ(&stdlib__GT__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN(">=")), SCM_OBJ(&stdlib__GT_3d__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("zero?")), SCM_OBJ(&stdlib_zeroP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("positive?")), SCM_OBJ(&stdlib_positiveP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("negative?")), SCM_OBJ(&stdlib_negativeP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("odd?")), SCM_OBJ(&stdlib_oddP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("even?")), SCM_OBJ(&stdlib_evenP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("max")), SCM_OBJ(&stdlib_max__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("min")), SCM_OBJ(&stdlib_min__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("*")), SCM_OBJ(&stdlib__2a__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("+")), SCM_OBJ(&stdlib__2b__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("-")), SCM_OBJ(&stdlib____STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("/")), SCM_OBJ(&stdlib__2f__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("abs")), SCM_OBJ(&stdlib_abs__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("quotient")), SCM_OBJ(&stdlib_quotient__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("remainder")), SCM_OBJ(&stdlib_remainder__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("modulo")), SCM_OBJ(&stdlib_modulo__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%gcd")), SCM_OBJ(&stdlib__25gcd__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("numerator")), SCM_OBJ(&stdlib_numerator__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("denominator")), SCM_OBJ(&stdlib_denominator__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("floor")), SCM_OBJ(&stdlib_floor__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("ceiling")), SCM_OBJ(&stdlib_ceiling__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("truncate")), SCM_OBJ(&stdlib_truncate__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("round")), SCM_OBJ(&stdlib_round__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%exp")), SCM_OBJ(&stdlib__25exp__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%log")), SCM_OBJ(&stdlib__25log__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%sin")), SCM_OBJ(&stdlib__25sin__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%cos")), SCM_OBJ(&stdlib__25cos__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tan")), SCM_OBJ(&stdlib__25tan__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%asin")), SCM_OBJ(&stdlib__25asin__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%acos")), SCM_OBJ(&stdlib__25acos__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%atan")), SCM_OBJ(&stdlib__25atan__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%sinh")), SCM_OBJ(&stdlib__25sinh__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%cosh")), SCM_OBJ(&stdlib__25cosh__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%tanh")), SCM_OBJ(&stdlib__25tanh__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%sqrt")), SCM_OBJ(&stdlib__25sqrt__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%expt")), SCM_OBJ(&stdlib__25expt__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-rectangular")), SCM_OBJ(&stdlib_make_rectangular__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-polar")), SCM_OBJ(&stdlib_make_polar__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("real-part")), SCM_OBJ(&stdlib_real_part__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("imag-part")), SCM_OBJ(&stdlib_imag_part__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("magnitude")), SCM_OBJ(&stdlib_magnitude__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("angle")), SCM_OBJ(&stdlib_angle__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("exact->inexact")), SCM_OBJ(&stdlib_exact_TOinexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("inexact->exact")), SCM_OBJ(&stdlib_inexact_TOexact__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("number->string")), SCM_OBJ(&stdlib_number_TOstring__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string->number")), SCM_OBJ(&stdlib_string_TOnumber__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("not")), SCM_OBJ(&stdlib_not__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("boolean?")), SCM_OBJ(&stdlib_booleanP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("pair?")), SCM_OBJ(&stdlib_pairP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cons")), SCM_OBJ(&stdlib_cons__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("car")), SCM_OBJ(&stdlib_car__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_car__STUB), SCM_PROCEDURE(&stdlib_set_carX__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cdr")), SCM_OBJ(&stdlib_cdr__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_cdr__STUB), SCM_PROCEDURE(&stdlib_set_cdrX__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("set-car!")), SCM_OBJ(&stdlib_set_carX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("set-cdr!")), SCM_OBJ(&stdlib_set_cdrX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("caar")), SCM_OBJ(&stdlib_caar__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_caar__STUB), SCM_PROCEDURE(&stdlib_caar_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cadr")), SCM_OBJ(&stdlib_cadr__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_cadr__STUB), SCM_PROCEDURE(&stdlib_cadr_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cdar")), SCM_OBJ(&stdlib_cdar__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_cdar__STUB), SCM_PROCEDURE(&stdlib_cdar_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cddr")), SCM_OBJ(&stdlib_cddr__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_cddr__STUB), SCM_PROCEDURE(&stdlib_cddr_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("null?")), SCM_OBJ(&stdlib_nullP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list?")), SCM_OBJ(&stdlib_listP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list")), SCM_OBJ(&stdlib_list__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("length")), SCM_OBJ(&stdlib_length__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("length+")), SCM_OBJ(&stdlib_length_2b__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("append")), SCM_OBJ(&stdlib_append__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("reverse")), SCM_OBJ(&stdlib_reverse__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list-tail")), SCM_OBJ(&stdlib_list_tail__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list-ref")), SCM_OBJ(&stdlib_list_ref__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("memq")), SCM_OBJ(&stdlib_memq__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("memv")), SCM_OBJ(&stdlib_memv__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("member")), SCM_OBJ(&stdlib_member__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("assq")), SCM_OBJ(&stdlib_assq__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("assv")), SCM_OBJ(&stdlib_assv__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("assoc")), SCM_OBJ(&stdlib_assoc__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("symbol?")), SCM_OBJ(&stdlib_symbolP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("symbol->string")), SCM_OBJ(&stdlib_symbol_TOstring__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string->symbol")), SCM_OBJ(&stdlib_string_TOsymbol__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char?")), SCM_OBJ(&stdlib_charP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char=?")), SCM_OBJ(&stdlib_char_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char<?")), SCM_OBJ(&stdlib_char_LTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char>?")), SCM_OBJ(&stdlib_char_GTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char<=?")), SCM_OBJ(&stdlib_char_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char>=?")), SCM_OBJ(&stdlib_char_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ci=?")), SCM_OBJ(&stdlib_char_ci_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ci<?")), SCM_OBJ(&stdlib_char_ci_LTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ci>?")), SCM_OBJ(&stdlib_char_ci_GTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ci<=?")), SCM_OBJ(&stdlib_char_ci_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ci>=?")), SCM_OBJ(&stdlib_char_ci_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-alphabetic?")), SCM_OBJ(&stdlib_char_alphabeticP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-numeric?")), SCM_OBJ(&stdlib_char_numericP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-whitespace?")), SCM_OBJ(&stdlib_char_whitespaceP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-upper-case?")), SCM_OBJ(&stdlib_char_upper_caseP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-lower-case?")), SCM_OBJ(&stdlib_char_lower_caseP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char->integer")), SCM_OBJ(&stdlib_char_TOinteger__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("integer->char")), SCM_OBJ(&stdlib_integer_TOchar__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-upcase")), SCM_OBJ(&stdlib_char_upcase__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-downcase")), SCM_OBJ(&stdlib_char_downcase__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string?")), SCM_OBJ(&stdlib_stringP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-string")), SCM_OBJ(&stdlib_make_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string")), SCM_OBJ(&stdlib_string__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-length")), SCM_OBJ(&stdlib_string_length__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ref")), SCM_OBJ(&stdlib_string_ref__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string=?")), SCM_OBJ(&stdlib_string_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string<?")), SCM_OBJ(&stdlib_string_LTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string>?")), SCM_OBJ(&stdlib_string_GTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string<=?")), SCM_OBJ(&stdlib_string_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string>=?")), SCM_OBJ(&stdlib_string_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ci=?")), SCM_OBJ(&stdlib_string_ci_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ci<?")), SCM_OBJ(&stdlib_string_ci_LTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ci>?")), SCM_OBJ(&stdlib_string_ci_GTP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ci<=?")), SCM_OBJ(&stdlib_string_ci_LT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-ci>=?")), SCM_OBJ(&stdlib_string_ci_GT_3dP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("substring")), SCM_OBJ(&stdlib_substring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-append")), SCM_OBJ(&stdlib_string_append__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string->list")), SCM_OBJ(&stdlib_string_TOlist__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list->string")), SCM_OBJ(&stdlib_list_TOstring__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("string-copy")), SCM_OBJ(&stdlib_string_copy__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector?")), SCM_OBJ(&stdlib_vectorP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-vector")), SCM_OBJ(&stdlib_make_vector__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector")), SCM_OBJ(&stdlib_vector__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector-length")), SCM_OBJ(&stdlib_vector_length__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector-ref")), SCM_OBJ(&stdlib_vector_ref__STUB), SCM_BINDING_INLINABLE);
  Scm_SetterSet(SCM_PROCEDURE(&stdlib_vector_ref__STUB), SCM_PROCEDURE(&stdlib_vector_setX__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector-set!")), SCM_OBJ(&stdlib_vector_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector->list")), SCM_OBJ(&stdlib_vector_TOlist__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("list->vector")), SCM_OBJ(&stdlib_list_TOvector__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vector-fill!")), SCM_OBJ(&stdlib_vector_fillX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("procedure?")), SCM_OBJ(&stdlib_procedureP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("apply")), SCM_OBJ(&stdlib_apply__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("map")), SCM_OBJ(&stdlib_map__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("for-each")), SCM_OBJ(&stdlib_for_each__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("force")), SCM_OBJ(&stdlib_force__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("call-with-current-continuation")), SCM_OBJ(&stdlib_call_with_current_continuation__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("values")), SCM_OBJ(&stdlib_values__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("dynamic-wind")), SCM_OBJ(&stdlib_dynamic_wind__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eval")), SCM_OBJ(&stdlib_eval__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("null-environment")), SCM_OBJ(&stdlib_null_environment__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("scheme-report-environment")), SCM_OBJ(&stdlib_scheme_report_environment__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("interaction-environment")), SCM_OBJ(&stdlib_interaction_environment__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("input-port?")), SCM_OBJ(&stdlib_input_portP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("output-port?")), SCM_OBJ(&stdlib_output_portP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("port?")), SCM_OBJ(&stdlib_portP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-input-port")), SCM_OBJ(&stdlib_current_input_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("current-output-port")), SCM_OBJ(&stdlib_current_output_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("close-input-port")), SCM_OBJ(&stdlib_close_input_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("close-output-port")), SCM_OBJ(&stdlib_close_output_port__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read")), SCM_OBJ(&stdlib_read__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("read-char")), SCM_OBJ(&stdlib_read_char__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("peek-char")), SCM_OBJ(&stdlib_peek_char__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("eof-object?")), SCM_OBJ(&stdlib_eof_objectP__STUB), SCM_BINDING_INLINABLE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("char-ready?")), SCM_OBJ(&stdlib_char_readyP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("write")), SCM_OBJ(&stdlib_write__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("display")), SCM_OBJ(&stdlib_display__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("newline")), SCM_OBJ(&stdlib_newline__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("write-char")), SCM_OBJ(&stdlib_write_char__STUB), SCM_BINDING_INLINABLE);
  scm__rc.d1018[0] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[171]))); /* paths */
  scm__rc.d1018[1] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[172]))); /* error-if-not-found */
  scm__rc.d1018[2] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[173]))); /* environment */
  scm__rc.d1018[3] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[174]))); /* ignore-coding */
  scm__rc.d1018[4] = Scm_MakeKeyword(SCM_STRING(SCM_OBJ(&scm__sc.d1003[175]))); /* main-script */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("load")), SCM_OBJ(&stdlib_load__STUB), 0);
}
