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

#line 40 "intlib.stub"
#include <gauche/class.h>
#include <gauche/code.h>
#include <gauche/vminsn.h>
#include <gauche/macro.h>
#include <gauche/prof.h>
#include <gauche/builtin-syms.h>

#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[107];
} scm__sc = {
  {   /* ScmString d1003 */
      SCM_STRING_CONST_INITIALIZER("pair-attributes", 15, 15),
      SCM_STRING_CONST_INITIALIZER("pair-attribute-get", 18, 18),
      SCM_STRING_CONST_INITIALIZER("pair-attribute-set!", 19, 19),
      SCM_STRING_CONST_INITIALIZER("extended-pair?", 14, 14),
      SCM_STRING_CONST_INITIALIZER("extended-cons", 13, 13),
      SCM_STRING_CONST_INITIALIZER("extended-list", 13, 13),
      SCM_STRING_CONST_INITIALIZER("cond-features", 13, 13),
      SCM_STRING_CONST_INITIALIZER("make-syntactic-closure", 22, 22),
      SCM_STRING_CONST_INITIALIZER("make-identifier", 15, 15),
      SCM_STRING_CONST_INITIALIZER("identifier-module", 17, 17),
      SCM_STRING_CONST_INITIALIZER("identifier-name", 15, 15),
      SCM_STRING_CONST_INITIALIZER("identifier-env", 14, 14),
      SCM_STRING_CONST_INITIALIZER("find-binding", 12, 12),
      SCM_STRING_CONST_INITIALIZER("find-const-binding", 18, 18),
      SCM_STRING_CONST_INITIALIZER("quote", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%insert-binding", 15, 15),
      SCM_STRING_CONST_INITIALIZER("const", 5, 5),
      SCM_STRING_CONST_INITIALIZER("inlinable", 9, 9),
      SCM_STRING_CONST_INITIALIZER("%hide-binding", 13, 13),
      SCM_STRING_CONST_INITIALIZER("%alias-binding", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%make-wrapper-module", 20, 20),
      SCM_STRING_CONST_INITIALIZER("%export-symbols", 15, 15),
      SCM_STRING_CONST_INITIALIZER("%import-module", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%import-modules", 15, 15),
      SCM_STRING_CONST_INITIALIZER("gloc-bound?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("gloc-ref", 8, 8),
      SCM_STRING_CONST_INITIALIZER("gloc-set!", 9, 9),
      SCM_STRING_CONST_INITIALIZER("gloc-const?", 11, 11),
      SCM_STRING_CONST_INITIALIZER("gloc-inlinable?", 15, 15),
      SCM_STRING_CONST_INITIALIZER("global-call-type", 16, 16),
      SCM_STRING_CONST_INITIALIZER("inline", 6, 6),
      SCM_STRING_CONST_INITIALIZER("syntax", 6, 6),
      SCM_STRING_CONST_INITIALIZER("macro", 5, 5),
      SCM_STRING_CONST_INITIALIZER("macro?", 6, 6),
      SCM_STRING_CONST_INITIALIZER("syntax?", 7, 7),
      SCM_STRING_CONST_INITIALIZER("make-toplevel-closure", 21, 21),
      SCM_STRING_CONST_INITIALIZER("make-macro-transformer", 22, 22),
      SCM_STRING_CONST_INITIALIZER("compile-syntax-rules", 20, 20),
      SCM_STRING_CONST_INITIALIZER("call-macro-expander", 19, 19),
      SCM_STRING_CONST_INITIALIZER("make-syntax", 11, 11),
      SCM_STRING_CONST_INITIALIZER("call-syntax-handler", 19, 19),
      SCM_STRING_CONST_INITIALIZER("syntax-handler", 14, 14),
      SCM_STRING_CONST_INITIALIZER("%internal-macro-expand", 22, 22),
      SCM_STRING_CONST_INITIALIZER("%procedure-inliner", 18, 18),
      SCM_STRING_CONST_INITIALIZER("(setter %procedure-inliner)", 27, 27),
      SCM_STRING_CONST_INITIALIZER("%mark-binding-inlinable!", 24, 24),
      SCM_STRING_CONST_INITIALIZER("make-compiled-code-builder", 26, 26),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit0!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit-PUSH!", 24, 24),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit-RET!", 23, 23),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit0o!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit0i!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit0oi!", 22, 22),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit1!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit1o!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit1i!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit1oi!", 22, 22),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit2!", 20, 20),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit2o!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit2i!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("compiled-code-emit2oi!", 22, 22),
      SCM_STRING_CONST_INITIALIZER("compiled-code-new-label", 23, 23),
      SCM_STRING_CONST_INITIALIZER("compiled-code-set-label!", 24, 24),
      SCM_STRING_CONST_INITIALIZER("compiled-code-finish-builder", 28, 28),
      SCM_STRING_CONST_INITIALIZER("ENV_HEADER_SIZE", 15, 15),
      SCM_STRING_CONST_INITIALIZER("CONT_FRAME_SIZE", 15, 15),
      SCM_STRING_CONST_INITIALIZER("vm-dump-code", 12, 12),
      SCM_STRING_CONST_INITIALIZER("vm-code->list", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vm-insn-build", 13, 13),
      SCM_STRING_CONST_INITIALIZER("vm-insn-code->name", 18, 18),
      SCM_STRING_CONST_INITIALIZER("vm-insn-name->code", 18, 18),
      SCM_STRING_CONST_INITIALIZER("vm-eval-situation", 17, 17),
      SCM_STRING_CONST_INITIALIZER("SCM_VM_EXECUTING", 16, 16),
      SCM_STRING_CONST_INITIALIZER("SCM_VM_LOADING", 14, 14),
      SCM_STRING_CONST_INITIALIZER("SCM_VM_COMPILING", 16, 16),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-is-set?", 24, 24),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-set!", 21, 21),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-clear!", 23, 23),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-noinline-locals?", 33, 33),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-no-post-inline?", 32, 32),
      SCM_STRING_CONST_INITIALIZER("vm-compiler-flag-no-lifting?", 28, 28),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NOINLINE_GLOBALS", 28, 28),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NOINLINE_LOCALS", 27, 27),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NOINLINE_CONSTS", 27, 27),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NOSOURCE", 20, 20),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_SHOWRESULT", 22, 22),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NOCOMBINE", 21, 21),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NO_POST_INLINE_OPT", 30, 30),
      SCM_STRING_CONST_INITIALIZER("SCM_COMPILE_NO_LIFTING", 22, 22),
      SCM_STRING_CONST_INITIALIZER("vm-current-module", 17, 17),
      SCM_STRING_CONST_INITIALIZER("vm-set-current-module", 21, 21),
      SCM_STRING_CONST_INITIALIZER("%call/pc", 8, 8),
      SCM_STRING_CONST_INITIALIZER("gc-print-static-roots", 21, 21),
      SCM_STRING_CONST_INITIALIZER("profiler-raw-result", 19, 19),
      SCM_STRING_CONST_INITIALIZER("%imax", 5, 5),
      SCM_STRING_CONST_INITIALIZER("%map1c", 6, 6),
      SCM_STRING_CONST_INITIALIZER("%map1cc", 7, 7),
      SCM_STRING_CONST_INITIALIZER("%map-cons", 9, 9),
      SCM_STRING_CONST_INITIALIZER("%apply-rec0", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%apply-rec1", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%apply-rec2", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%apply-rec3", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%apply-rec4", 11, 11),
      SCM_STRING_CONST_INITIALIZER("%apply-rec", 10, 10),
      SCM_STRING_CONST_INITIALIZER("%procedure-currying-set!", 24, 24),
      SCM_STRING_CONST_INITIALIZER("make-case-lambda-dispatcher", 27, 27),
      SCM_STRING_CONST_INITIALIZER("case-lambda-dispatcher", 22, 22),
  },
};
static struct scm__rcRec {
  ScmObj d1004[24];
} scm__rc = {
  {   /* ScmObj d1004 */
    SCM_UNBOUND,
    SCM_NIL,
    SCM_NIL,
    SCM_UNDEFINED,
    SCM_OBJ(&scm__rc.d1004[1]),
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
    SCM_UNBOUND,
  },
};
static ScmObj intlib_pair_attributes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj pair_scm;
  ScmPair* pair;
  SCM_ENTER_SUBR("pair-attributes");
  pair_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(pair_scm)) Scm_Error("pair required, but got %S", pair_scm);
  pair = SCM_PAIR(pair_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_PairAttr(pair));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_pair_attributes__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[0]),SCM_SUBR_IMMEDIATE_ARG, intlib_pair_attributes, NULL, NULL);

static ScmObj intlib_pair_attribute_get(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj pair_scm;
  ScmPair* pair;
  ScmObj key_scm;
  ScmObj key;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("pair-attribute-get");
  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);
  pair_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(pair_scm)) Scm_Error("pair required, but got %S", pair_scm);
  pair = SCM_PAIR(pair_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  if (SCM_ARGCNT > 2+1) {
    fallback_scm = SCM_ARGREF(2);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 59 "intlib.stub"
SCM_RESULT=(Scm_PairAttrGet(SCM_PAIR(pair),key,fallback));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_pair_attribute_get__STUB, 2, 2,SCM_OBJ(&scm__sc.d1003[1]),intlib_pair_attribute_get, NULL, NULL);

static ScmObj intlib_pair_attribute_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj pair_scm;
  ScmPair* pair;
  ScmObj key_scm;
  ScmObj key;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("pair-attribute-set!");
  pair_scm = SCM_ARGREF(0);
  if (!SCM_PAIRP(pair_scm)) Scm_Error("pair required, but got %S", pair_scm);
  pair = SCM_PAIR(pair_scm);
  key_scm = SCM_ARGREF(1);
  key = (key_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  {
{
ScmObj SCM_RESULT;

#line 62 "intlib.stub"
SCM_RESULT=(Scm_PairAttrSet(SCM_PAIR(pair),key,value));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_pair_attribute_setX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[2]),intlib_pair_attribute_setX, NULL, NULL);

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

static SCM_DEFINE_SUBR(intlib_extended_pairP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[3]),intlib_extended_pairP, NULL, NULL);

static ScmObj intlib_extended_cons(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj car_scm;
  ScmObj car;
  ScmObj cdr_scm;
  ScmObj cdr;
  SCM_ENTER_SUBR("extended-cons");
  car_scm = SCM_ARGREF(0);
  car = (car_scm);
  cdr_scm = SCM_ARGREF(1);
  cdr = (cdr_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ExtendedCons(car,cdr));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_extended_cons__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[4]),intlib_extended_cons, NULL, NULL);

static ScmObj intlib_extended_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj elt_scm;
  ScmObj elt;
  ScmObj more_scm;
  ScmObj more;
  SCM_ENTER_SUBR("extended-list");
  elt_scm = SCM_ARGREF(0);
  elt = (elt_scm);
  more_scm = SCM_ARGREF(SCM_ARGCNT-1);
  more = (more_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ExtendedCons(elt,more));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_extended_list__STUB, 1, 1,SCM_OBJ(&scm__sc.d1003[5]),intlib_extended_list, NULL, NULL);

static ScmObj intlib_cond_features(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("cond-features");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_GetFeatures());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_cond_features__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[6]),SCM_SUBR_IMMEDIATE_ARG, intlib_cond_features, NULL, NULL);

static ScmObj intlib_make_syntactic_closure(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj env_scm;
  ScmObj env;
  ScmObj literals_scm;
  ScmObj literals;
  ScmObj expr_scm;
  ScmObj expr;
  SCM_ENTER_SUBR("make-syntactic-closure");
  env_scm = SCM_ARGREF(0);
  env = (env_scm);
  literals_scm = SCM_ARGREF(1);
  literals = (literals_scm);
  expr_scm = SCM_ARGREF(2);
  expr = (expr_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeSyntacticClosure(env,literals,expr));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_make_syntactic_closure__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[7]),intlib_make_syntactic_closure, NULL, NULL);

static ScmObj intlib_make_identifier(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj env_scm;
  ScmObj env;
  SCM_ENTER_SUBR("make-identifier");
  name_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  mod_scm = SCM_ARGREF(1);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  env_scm = SCM_ARGREF(2);
  if (!SCM_LISTP(env_scm)) Scm_Error("list required, but got %S", env_scm);
  env = (env_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeIdentifier(name,mod,env));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_make_identifier__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[8]),SCM_SUBR_IMMEDIATE_ARG, intlib_make_identifier, NULL, NULL);

static ScmObj intlib_identifier_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj id_scm;
  ScmIdentifier* id;
  SCM_ENTER_SUBR("identifier-module");
  id_scm = SCM_ARGREF(0);
  if (!SCM_IDENTIFIERP(id_scm)) Scm_Error("identifier required, but got %S", id_scm);
  id = SCM_IDENTIFIER(id_scm);
  {
{
ScmObj SCM_RESULT;

#line 92 "intlib.stub"
SCM_RESULT=(SCM_OBJ((id)->module));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj intlib_identifier_name(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj id_scm;
  ScmIdentifier* id;
  SCM_ENTER_SUBR("identifier-name");
  id_scm = SCM_ARGREF(0);
  if (!SCM_IDENTIFIERP(id_scm)) Scm_Error("identifier required, but got %S", id_scm);
  id = SCM_IDENTIFIER(id_scm);
  {
{
ScmObj SCM_RESULT;

#line 94 "intlib.stub"
SCM_RESULT=(SCM_OBJ((id)->name));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_identifier_name__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[10]),SCM_SUBR_IMMEDIATE_ARG, intlib_identifier_name, NULL, NULL);

static ScmObj intlib_identifier_env(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj id_scm;
  ScmIdentifier* id;
  SCM_ENTER_SUBR("identifier-env");
  id_scm = SCM_ARGREF(0);
  if (!SCM_IDENTIFIERP(id_scm)) Scm_Error("identifier required, but got %S", id_scm);
  id = SCM_IDENTIFIER(id_scm);
  {
{
ScmObj SCM_RESULT;

#line 96 "intlib.stub"
SCM_RESULT=((id)->env);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_identifier_env__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[11]),SCM_SUBR_IMMEDIATE_ARG, intlib_identifier_env, NULL, NULL);

static ScmObj intlib_find_binding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj stay_in_module_scm;
  int stay_in_module;
  SCM_ENTER_SUBR("find-binding");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  stay_in_module_scm = SCM_ARGREF(2);
  if (!SCM_BOOLP(stay_in_module_scm)) Scm_Error("boolean required, but got %S", stay_in_module_scm);
  stay_in_module = SCM_BOOL_VALUE(stay_in_module_scm);
  {
{
ScmGloc* SCM_RESULT;

#line 106 "intlib.stub"
SCM_RESULT=(Scm_FindBinding(mod,name,
((stay_in_module)?(SCM_BINDING_STAY_IN_MODULE):(0))));
SCM_RETURN(SCM_MAKE_MAYBE(SCM_OBJ, SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_find_binding__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[12]),SCM_SUBR_IMMEDIATE_ARG, intlib_find_binding, NULL, NULL);

static ScmObj intlib_find_const_binding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj id_scm;
  ScmIdentifier* id;
  SCM_ENTER_SUBR("find-const-binding");
  id_scm = SCM_ARGREF(0);
  if (!SCM_IDENTIFIERP(id_scm)) Scm_Error("identifier required, but got %S", id_scm);
  id = SCM_IDENTIFIER(id_scm);
  {
{
ScmObj SCM_RESULT;

#line 113 "intlib.stub"
{ScmGloc* g=Scm_FindBinding((id)->module,(id)->name,0);
if (((!(g))||(
!(SCM_GLOC_CONST_P(g))))||(
SCM_VM_COMPILER_FLAG_IS_SET(Scm_VM(),SCM_COMPILE_NOINLINE_CONSTS))){
#line 118 "intlib.stub"
SCM_RESULT=(SCM_FALSE);} else {
#line 120 "intlib.stub"
SCM_RESULT=(SCM_GLOC_GET(g));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_find_const_binding__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[13]),SCM_SUBR_IMMEDIATE_ARG, intlib_find_const_binding, NULL, NULL);

static ScmObj intlib__25insert_binding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj value_scm;
  ScmObj value;
  ScmObj flags_scm;
  ScmObj flags;
  SCM_ENTER_SUBR("%insert-binding");
  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);
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  value_scm = SCM_ARGREF(2);
  value = (value_scm);
  if (SCM_ARGCNT > 3+1) {
    flags_scm = SCM_ARGREF(3);
  } else {
    flags_scm = SCM_OBJ(&scm__rc.d1004[3]);
  }
  flags = (flags_scm);
  {
{
ScmObj SCM_RESULT;

#line 124 "intlib.stub"
{int z=0;
if (!(SCM_FALSEP(Scm_Memq(scm__rc.d1004[5],flags)))){{
(z)|=(SCM_BINDING_CONST);}}
if (!(SCM_FALSEP(Scm_Memq(scm__rc.d1004[6],flags)))){{
(z)|=(SCM_BINDING_INLINABLE);}}
SCM_RESULT=(SCM_OBJ(Scm_MakeBinding(mod,name,value,z)));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25insert_binding__STUB, 3, 2,SCM_OBJ(&scm__sc.d1003[15]),intlib__25insert_binding, NULL, NULL);

static ScmObj intlib__25hide_binding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj name_scm;
  ScmSymbol* name;
  SCM_ENTER_SUBR("%hide-binding");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  {
Scm_HideBinding(mod,name);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib__25hide_binding__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[18]),SCM_SUBR_IMMEDIATE_ARG, intlib__25hide_binding, NULL, NULL);

static ScmObj intlib__25alias_binding(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj target_scm;
  ScmModule* target;
  ScmObj tname_scm;
  ScmSymbol* tname;
  ScmObj origin_scm;
  ScmModule* origin;
  ScmObj oname_scm;
  ScmSymbol* oname;
  SCM_ENTER_SUBR("%alias-binding");
  target_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(target_scm)) Scm_Error("module required, but got %S", target_scm);
  target = SCM_MODULE(target_scm);
  tname_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(tname_scm)) Scm_Error("symbol required, but got %S", tname_scm);
  tname = SCM_SYMBOL(tname_scm);
  origin_scm = SCM_ARGREF(2);
  if (!SCM_MODULEP(origin_scm)) Scm_Error("module required, but got %S", origin_scm);
  origin = SCM_MODULE(origin_scm);
  oname_scm = SCM_ARGREF(3);
  if (!SCM_SYMBOLP(oname_scm)) Scm_Error("symbol required, but got %S", oname_scm);
  oname = SCM_SYMBOL(oname_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_AliasBinding(target,tname,origin,oname));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib__25alias_binding__STUB, 4, 0,0, SCM_OBJ(&scm__sc.d1003[19]),SCM_SUBR_IMMEDIATE_ARG, intlib__25alias_binding, NULL, NULL);

static ScmObj intlib__25make_wrapper_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj origin_scm;
  ScmModule* origin;
  ScmObj prefix_scm;
  ScmObj prefix;
  SCM_ENTER_SUBR("%make-wrapper-module");
  origin_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(origin_scm)) Scm_Error("module required, but got %S", origin_scm);
  origin = SCM_MODULE(origin_scm);
  prefix_scm = SCM_ARGREF(1);
  prefix = (prefix_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm__MakeWrapperModule(origin,prefix));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25make_wrapper_module__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[20]),intlib__25make_wrapper_module, NULL, NULL);

static ScmObj intlib__25export_symbols(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj names_scm;
  ScmObj names;
  SCM_ENTER_SUBR("%export-symbols");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  names_scm = SCM_ARGREF(1);
  names = (names_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ExportSymbols(mod,names));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25export_symbols__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[21]),intlib__25export_symbols, NULL, NULL);

static ScmObj intlib__25import_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj imported_scm;
  ScmObj imported;
  ScmObj prefix_scm;
  ScmObj prefix;
  ScmObj flags_scm;
  u_long flags;
  SCM_ENTER_SUBR("%import-module");
  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);
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  imported_scm = SCM_ARGREF(1);
  imported = (imported_scm);
  if (SCM_ARGCNT > 2+1) {
    prefix_scm = SCM_ARGREF(2);
  } else {
    prefix_scm = SCM_FALSE;
  }
  prefix = (prefix_scm);
  if (SCM_ARGCNT > 3+1) {
    flags_scm = SCM_ARGREF(3);
  } else {
    flags_scm = SCM_MAKE_INT(0);
  }
  if (!SCM_UINTEGERP(flags_scm)) Scm_Error("C integer required, but got %S", flags_scm);
  flags = Scm_GetIntegerU(flags_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ImportModule(mod,imported,prefix,flags));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25import_module__STUB, 2, 3,SCM_OBJ(&scm__sc.d1003[22]),intlib__25import_module, NULL, NULL);

static ScmObj intlib__25import_modules(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj mods_scm;
  ScmObj mods;
  SCM_ENTER_SUBR("%import-modules");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  mods_scm = SCM_ARGREF(1);
  mods = (mods_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ImportModules(mod,mods));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25import_modules__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[23]),intlib__25import_modules, NULL, NULL);

static ScmObj intlib_gloc_boundP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj gloc_scm;
  ScmGloc* gloc;
  SCM_ENTER_SUBR("gloc-bound?");
  gloc_scm = SCM_ARGREF(0);
  if (!SCM_GLOCP(gloc_scm)) Scm_Error("GLOC required, but got %S", gloc_scm);
  gloc = SCM_GLOC(gloc_scm);
  {
{
int SCM_RESULT;

#line 152 "intlib.stub"
SCM_RESULT=(!(SCM_UNBOUNDP(SCM_GLOC_GET(gloc))));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

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

static ScmObj intlib_gloc_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj gloc_scm;
  ScmGloc* gloc;
  ScmObj fallback_scm;
  ScmObj fallback;
  SCM_ENTER_SUBR("gloc-ref");
  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);
  gloc_scm = SCM_ARGREF(0);
  if (!SCM_GLOCP(gloc_scm)) Scm_Error("GLOC required, but got %S", gloc_scm);
  gloc = SCM_GLOC(gloc_scm);
  if (SCM_ARGCNT > 1+1) {
    fallback_scm = SCM_ARGREF(1);
  } else {
    fallback_scm = SCM_UNBOUND;
  }
  fallback = (fallback_scm);
  {
{
ScmObj SCM_RESULT;

#line 154 "intlib.stub"
{ScmObj v=SCM_GLOC_GET(gloc);
if (SCM_UNBOUNDP(v)){
if (SCM_UNBOUNDP(fallback)){
Scm_Error("gloc %S doesn't have a value",SCM_OBJ(gloc));} else {
SCM_RESULT=(fallback);}} else {
SCM_RESULT=(v);}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_gloc_ref__STUB, 1, 2,SCM_OBJ(&scm__sc.d1003[25]),intlib_gloc_ref, NULL, NULL);

static ScmObj intlib_gloc_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj gloc_scm;
  ScmGloc* gloc;
  ScmObj value_scm;
  ScmObj value;
  SCM_ENTER_SUBR("gloc-set!");
  gloc_scm = SCM_ARGREF(0);
  if (!SCM_GLOCP(gloc_scm)) Scm_Error("GLOC required, but got %S", gloc_scm);
  gloc = SCM_GLOC(gloc_scm);
  value_scm = SCM_ARGREF(1);
  value = (value_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(SCM_GLOC_SET(gloc,value));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_gloc_setX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[26]),intlib_gloc_setX, NULL, NULL);

static ScmObj intlib_gloc_constP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj gloc_scm;
  ScmGloc* gloc;
  SCM_ENTER_SUBR("gloc-const?");
  gloc_scm = SCM_ARGREF(0);
  if (!SCM_GLOCP(gloc_scm)) Scm_Error("GLOC required, but got %S", gloc_scm);
  gloc = SCM_GLOC(gloc_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_GlocConstP(gloc));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_gloc_constP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[27]),SCM_SUBR_IMMEDIATE_ARG, intlib_gloc_constP, NULL, NULL);

static ScmObj intlib_gloc_inlinableP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj gloc_scm;
  ScmGloc* gloc;
  SCM_ENTER_SUBR("gloc-inlinable?");
  gloc_scm = SCM_ARGREF(0);
  if (!SCM_GLOCP(gloc_scm)) Scm_Error("GLOC required, but got %S", gloc_scm);
  gloc = SCM_GLOC(gloc_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_GlocInlinableP(gloc));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_gloc_inlinableP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[28]),SCM_SUBR_IMMEDIATE_ARG, intlib_gloc_inlinableP, NULL, NULL);

#if defined(RECORD_DEPENDED_MODULES)
static ScmModule *stdmods[3];
#endif /* defined(RECORD_DEPENDED_MODULES) */
static ScmObj intlib_global_call_type(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj id_scm;
  ScmObj id;
  ScmObj cenv_scm;
  ScmObj cenv;
  SCM_ENTER_SUBR("global-call-type");
  id_scm = SCM_ARGREF(0);
  id = (id_scm);
  cenv_scm = SCM_ARGREF(1);
  cenv = (cenv_scm);
  {
ScmObj SCM_RESULT0;
ScmObj SCM_RESULT1;
{

#line 203 "intlib.stub"
{ScmModule* mod=(SCM_IDENTIFIER(id))->module;ScmGloc* gloc=
Scm_FindBinding(mod,(SCM_IDENTIFIER(id))->name,0);
#line 206 "intlib.stub"
SCM_RESULT0=(SCM_FALSE),SCM_RESULT1=(SCM_FALSE);
if (gloc){{
{ScmObj gval=SCM_GLOC_GET(gloc);
if (SCM_MACROP(gval)){
SCM_RESULT0=(gval),SCM_RESULT1=(scm__rc.d1004[9]);}else if(
SCM_SYNTAXP(gval)){
SCM_RESULT0=(gval),SCM_RESULT1=(scm__rc.d1004[8]);}else if(
(((SCM_PROCEDUREP(gval))&&(
SCM_PROCEDURE_INLINER(gval)))&&(
!(SCM_FALSEP(SCM_PROCEDURE_INLINER(gval)))))&&(
#line 223 "intlib.stub"
!(SCM_VM_COMPILER_FLAG_IS_SET(
Scm_VM(),SCM_COMPILE_NOINLINE_GLOBALS)))){
SCM_RESULT0=(gval),SCM_RESULT1=(scm__rc.d1004[7]);} else {
goto normal;}
#if defined(RECORD_DEPENDED_MODULES)

#line 228 "intlib.stub"
{
{int i=0;int cise__1005=3;for (; (i)<(cise__1005); (i)++){
if (SCM_EQ(mod,(stdmods)[i])){{goto normal;}}}}
{ScmObj curmod=SCM_VECTOR_ELEMENT(cenv,0);
SCM_ASSERT(SCM_MODULEP(curmod));
if (SCM_FALSEP(
Scm_Memq(SCM_OBJ(mod),
(SCM_MODULE(curmod))->depended))){{
(SCM_MODULE(curmod))->depended=(
Scm_Cons(SCM_OBJ(mod),
(SCM_MODULE(curmod))->depended));}}}}
#endif /* defined(RECORD_DEPENDED_MODULES) */
}}}
#line 240 "intlib.stub"
normal :; }
}
SCM_RETURN(Scm_Values2(SCM_OBJ_SAFE(SCM_RESULT0),SCM_OBJ_SAFE(SCM_RESULT1)));
  }
}

static SCM_DEFINE_SUBR(intlib_global_call_type__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[29]),intlib_global_call_type, NULL, NULL);

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

static SCM_DEFINE_SUBR(intlib_macroP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[33]),intlib_macroP, NULL, NULL);

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

static SCM_DEFINE_SUBR(intlib_syntaxP__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[34]),intlib_syntaxP, NULL, NULL);

static ScmObj intlib_make_toplevel_closure(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj code_scm;
  ScmCompiledCode* code;
  SCM_ENTER_SUBR("make-toplevel-closure");
  code_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(code_scm)) Scm_Error("compiled code required, but got %S", code_scm);
  code = SCM_COMPILED_CODE(code_scm);
  {
{
ScmObj SCM_RESULT;

#line 247 "intlib.stub"
SCM_RESULT=(Scm_MakeClosure(SCM_OBJ(code),NULL));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj intlib_make_macro_transformer(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj proc_scm;
  ScmProcedure* proc;
  SCM_ENTER_SUBR("make-macro-transformer");
  name_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  proc_scm = SCM_ARGREF(1);
  if (!SCM_PROCEDUREP(proc_scm)) Scm_Error("procedure required, but got %S", proc_scm);
  proc = SCM_PROCEDURE(proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeMacroTransformerOld(name,proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_make_macro_transformer__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[36]),SCM_SUBR_IMMEDIATE_ARG, intlib_make_macro_transformer, NULL, NULL);

static ScmObj intlib_compile_syntax_rules(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmObj name;
  ScmObj literals_scm;
  ScmObj literals;
  ScmObj rules_scm;
  ScmObj rules;
  ScmObj mod_scm;
  ScmObj mod;
  ScmObj env_scm;
  ScmObj env;
  SCM_ENTER_SUBR("compile-syntax-rules");
  name_scm = SCM_ARGREF(0);
  name = (name_scm);
  literals_scm = SCM_ARGREF(1);
  literals = (literals_scm);
  rules_scm = SCM_ARGREF(2);
  rules = (rules_scm);
  mod_scm = SCM_ARGREF(3);
  mod = (mod_scm);
  env_scm = SCM_ARGREF(4);
  env = (env_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CompileSyntaxRules(name,literals,rules,mod,env));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_compile_syntax_rules__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[37]),intlib_compile_syntax_rules, NULL, NULL);

static ScmObj intlib_call_macro_expander(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mac_scm;
  ScmMacro* mac;
  ScmObj expr_scm;
  ScmObj expr;
  ScmObj env_scm;
  ScmObj env;
  SCM_ENTER_SUBR("call-macro-expander");
  mac_scm = SCM_ARGREF(0);
  if (!SCM_MACROP(mac_scm)) Scm_Error("macro required, but got %S", mac_scm);
  mac = SCM_MACRO(mac_scm);
  expr_scm = SCM_ARGREF(1);
  expr = (expr_scm);
  env_scm = SCM_ARGREF(2);
  env = (env_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CallMacroExpander(mac,expr,env));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_call_macro_expander__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[38]),intlib_call_macro_expander, NULL, NULL);

static ScmObj intlib_make_syntax(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj name_scm;
  ScmSymbol* name;
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("make-syntax");
  name_scm = SCM_ARGREF(0);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  proc_scm = SCM_ARGREF(1);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeSyntax(name,proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_make_syntax__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[39]),intlib_make_syntax, NULL, NULL);

static ScmObj intlib_call_syntax_handler(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj syn_scm;
  ScmObj syn;
  ScmObj program_scm;
  ScmObj program;
  ScmObj cenv_scm;
  ScmObj cenv;
  SCM_ENTER_SUBR("call-syntax-handler");
  syn_scm = SCM_ARGREF(0);
  syn = (syn_scm);
  program_scm = SCM_ARGREF(1);
  program = (program_scm);
  cenv_scm = SCM_ARGREF(2);
  cenv = (cenv_scm);
  {
{
ScmObj SCM_RESULT;

#line 265 "intlib.stub"
SCM_ASSERT(SCM_SYNTAXP(syn));

#line 266 "intlib.stub"
SCM_RESULT=(Scm_VMApply2((SCM_SYNTAX(syn))->handler,program,cenv));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_call_syntax_handler__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[40]),intlib_call_syntax_handler, NULL, NULL);

static ScmObj intlib_syntax_handler(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj syn_scm;
  ScmObj syn;
  SCM_ENTER_SUBR("syntax-handler");
  syn_scm = SCM_ARGREF(0);
  syn = (syn_scm);
  {
{
ScmObj SCM_RESULT;

#line 269 "intlib.stub"
SCM_ASSERT(SCM_SYNTAXP(syn));

#line 270 "intlib.stub"
SCM_RESULT=((SCM_SYNTAX(syn))->handler);
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_syntax_handler__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[41]),intlib_syntax_handler, NULL, NULL);

static ScmObj intlib__25internal_macro_expand(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj form_scm;
  ScmObj form;
  ScmObj env_scm;
  ScmObj env;
  ScmObj once_scm;
  int once;
  SCM_ENTER_SUBR("%internal-macro-expand");
  form_scm = SCM_ARGREF(0);
  form = (form_scm);
  env_scm = SCM_ARGREF(1);
  env = (env_scm);
  once_scm = SCM_ARGREF(2);
  if (!SCM_BOOLP(once_scm)) Scm_Error("boolean required, but got %S", once_scm);
  once = SCM_BOOL_VALUE(once_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_VMMacroExpand(form,env,once));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25internal_macro_expand__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[42]),intlib__25internal_macro_expand, NULL, NULL);

static ScmObj intlib__25procedure_inliner_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmProcedure* proc;
  ScmObj inliner_scm;
  ScmObj inliner;
  SCM_ENTER_SUBR("(setter %procedure-inliner)");
  proc_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(proc_scm)) Scm_Error("procedure required, but got %S", proc_scm);
  proc = SCM_PROCEDURE(proc_scm);
  inliner_scm = SCM_ARGREF(1);
  inliner = (inliner_scm);
  {

#line 277 "intlib.stub"
(proc)->inliner=(inliner);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib__25procedure_inliner_SETTER__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[44]),intlib__25procedure_inliner_SETTER, NULL, NULL);

static ScmObj intlib__25procedure_inliner(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmProcedure* proc;
  SCM_ENTER_SUBR("%procedure-inliner");
  proc_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(proc_scm)) Scm_Error("procedure required, but got %S", proc_scm);
  proc = SCM_PROCEDURE(proc_scm);
  {
{
ScmObj SCM_RESULT;

#line 278 "intlib.stub"
SCM_RESULT=((((proc)->inliner)?((proc)->inliner):(SCM_FALSE)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj intlib__25mark_binding_inlinableX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  ScmObj name_scm;
  ScmSymbol* name;
  SCM_ENTER_SUBR("%mark-binding-inlinable!");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  name_scm = SCM_ARGREF(1);
  if (!SCM_SYMBOLP(name_scm)) Scm_Error("symbol required, but got %S", name_scm);
  name = SCM_SYMBOL(name_scm);
  {

#line 281 "intlib.stub"
{ScmGloc* g=Scm_FindBinding(mod,name,0);
if (!(g)){{
Scm_Error("[internal] %mark-binding-inlinable!: no such binding for %S in %S",
SCM_OBJ(name),SCM_OBJ(mod));}}
Scm_GlocMark(g,SCM_BINDING_INLINABLE);}
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib__25mark_binding_inlinableX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[45]),SCM_SUBR_IMMEDIATE_ARG, intlib__25mark_binding_inlinableX, NULL, NULL);

static ScmObj intlib_make_compiled_code_builder(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj reqargs_scm;
  u_int reqargs;
  ScmObj optargs_scm;
  u_int optargs;
  ScmObj name_scm;
  ScmObj name;
  ScmObj parent_scm;
  ScmObj parent;
  ScmObj intform_scm;
  ScmObj intform;
  SCM_ENTER_SUBR("make-compiled-code-builder");
  reqargs_scm = SCM_ARGREF(0);
  if (!SCM_UINTP(reqargs_scm)) Scm_Error("C integer required, but got %S", reqargs_scm);
  reqargs = Scm_GetIntegerU(reqargs_scm);
  optargs_scm = SCM_ARGREF(1);
  if (!SCM_UINTP(optargs_scm)) Scm_Error("C integer required, but got %S", optargs_scm);
  optargs = Scm_GetIntegerU(optargs_scm);
  name_scm = SCM_ARGREF(2);
  name = (name_scm);
  parent_scm = SCM_ARGREF(3);
  parent = (parent_scm);
  intform_scm = SCM_ARGREF(4);
  intform = (intform_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_MakeCompiledCodeBuilder(reqargs,optargs,name,parent,intform));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_make_compiled_code_builder__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[46]),intlib_make_compiled_code_builder, NULL, NULL);

static ScmObj intlib_compiled_code_emit0X(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  SCM_ENTER_SUBR("compiled-code-emit0!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  {

#line 299 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,0,0,SCM_FALSE,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_compiled_code_emit0X__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[47]),SCM_SUBR_IMMEDIATE_ARG, intlib_compiled_code_emit0X, NULL, NULL);

static ScmObj intlib_compiled_code_emit_PUSHX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  SCM_ENTER_SUBR("compiled-code-emit-PUSH!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  {

#line 303 "intlib.stub"
Scm_CompiledCodeEmit(cc,SCM_VM_PUSH,0,0,SCM_FALSE,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

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

static ScmObj intlib_compiled_code_emit_RETX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  SCM_ENTER_SUBR("compiled-code-emit-RET!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  {

#line 307 "intlib.stub"
Scm_CompiledCodeEmit(cc,SCM_VM_RET,0,0,SCM_FALSE,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_compiled_code_emit_RETX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[49]),SCM_SUBR_IMMEDIATE_ARG, intlib_compiled_code_emit_RETX, NULL, NULL);

static ScmObj intlib_compiled_code_emit0oX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj operand_scm;
  ScmObj operand;
  SCM_ENTER_SUBR("compiled-code-emit0o!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  operand_scm = SCM_ARGREF(2);
  operand = (operand_scm);
  {

#line 311 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,0,0,operand,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit0oX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[50]),intlib_compiled_code_emit0oX, NULL, NULL);

static ScmObj intlib_compiled_code_emit0iX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit0i!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  info_scm = SCM_ARGREF(2);
  info = (info_scm);
  {

#line 315 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,0,0,SCM_FALSE,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit0iX__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[51]),intlib_compiled_code_emit0iX, NULL, NULL);

static ScmObj intlib_compiled_code_emit0oiX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj operand_scm;
  ScmObj operand;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit0oi!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  operand_scm = SCM_ARGREF(2);
  operand = (operand_scm);
  info_scm = SCM_ARGREF(3);
  info = (info_scm);
  {

#line 319 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,0,0,operand,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit0oiX__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[52]),intlib_compiled_code_emit0oiX, NULL, NULL);

static ScmObj intlib_compiled_code_emit1X(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  SCM_ENTER_SUBR("compiled-code-emit1!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  {

#line 323 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,0,SCM_FALSE,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_compiled_code_emit1X__STUB, 3, 0,0, SCM_OBJ(&scm__sc.d1003[53]),SCM_SUBR_IMMEDIATE_ARG, intlib_compiled_code_emit1X, NULL, NULL);

static ScmObj intlib_compiled_code_emit1oX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj operand_scm;
  ScmObj operand;
  SCM_ENTER_SUBR("compiled-code-emit1o!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  operand_scm = SCM_ARGREF(3);
  operand = (operand_scm);
  {

#line 327 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,0,operand,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit1oX__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[54]),intlib_compiled_code_emit1oX, NULL, NULL);

static ScmObj intlib_compiled_code_emit1iX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit1i!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  info_scm = SCM_ARGREF(3);
  info = (info_scm);
  {

#line 331 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,0,SCM_FALSE,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit1iX__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[55]),intlib_compiled_code_emit1iX, NULL, NULL);

static ScmObj intlib_compiled_code_emit1oiX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj operand_scm;
  ScmObj operand;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit1oi!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  operand_scm = SCM_ARGREF(3);
  operand = (operand_scm);
  info_scm = SCM_ARGREF(4);
  info = (info_scm);
  {

#line 335 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,0,operand,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit1oiX__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[56]),intlib_compiled_code_emit1oiX, NULL, NULL);

static ScmObj intlib_compiled_code_emit2X(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj arg1_scm;
  int arg1;
  SCM_ENTER_SUBR("compiled-code-emit2!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  arg1_scm = SCM_ARGREF(3);
  if (!SCM_INTEGERP(arg1_scm)) Scm_Error("C integer required, but got %S", arg1_scm);
  arg1 = Scm_GetInteger(arg1_scm);
  {

#line 339 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,arg1,SCM_FALSE,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_compiled_code_emit2X__STUB, 4, 0,0, SCM_OBJ(&scm__sc.d1003[57]),SCM_SUBR_IMMEDIATE_ARG, intlib_compiled_code_emit2X, NULL, NULL);

static ScmObj intlib_compiled_code_emit2oX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj arg1_scm;
  int arg1;
  ScmObj operand_scm;
  ScmObj operand;
  SCM_ENTER_SUBR("compiled-code-emit2o!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  arg1_scm = SCM_ARGREF(3);
  if (!SCM_INTEGERP(arg1_scm)) Scm_Error("C integer required, but got %S", arg1_scm);
  arg1 = Scm_GetInteger(arg1_scm);
  operand_scm = SCM_ARGREF(4);
  operand = (operand_scm);
  {

#line 343 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,arg1,operand,SCM_FALSE);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit2oX__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[58]),intlib_compiled_code_emit2oX, NULL, NULL);

static ScmObj intlib_compiled_code_emit2iX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj arg1_scm;
  int arg1;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit2i!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  arg1_scm = SCM_ARGREF(3);
  if (!SCM_INTEGERP(arg1_scm)) Scm_Error("C integer required, but got %S", arg1_scm);
  arg1 = Scm_GetInteger(arg1_scm);
  info_scm = SCM_ARGREF(4);
  info = (info_scm);
  {

#line 347 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,arg1,SCM_FALSE,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit2iX__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[59]),intlib_compiled_code_emit2iX, NULL, NULL);

static ScmObj intlib_compiled_code_emit2oiX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj code_scm;
  int code;
  ScmObj arg0_scm;
  int arg0;
  ScmObj arg1_scm;
  int arg1;
  ScmObj operand_scm;
  ScmObj operand;
  ScmObj info_scm;
  ScmObj info;
  SCM_ENTER_SUBR("compiled-code-emit2oi!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  code_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(code_scm)) Scm_Error("C integer required, but got %S", code_scm);
  code = Scm_GetInteger(code_scm);
  arg0_scm = SCM_ARGREF(2);
  if (!SCM_INTEGERP(arg0_scm)) Scm_Error("C integer required, but got %S", arg0_scm);
  arg0 = Scm_GetInteger(arg0_scm);
  arg1_scm = SCM_ARGREF(3);
  if (!SCM_INTEGERP(arg1_scm)) Scm_Error("C integer required, but got %S", arg1_scm);
  arg1 = Scm_GetInteger(arg1_scm);
  operand_scm = SCM_ARGREF(4);
  operand = (operand_scm);
  info_scm = SCM_ARGREF(5);
  info = (info_scm);
  {

#line 351 "intlib.stub"
Scm_CompiledCodeEmit(cc,code,arg0,arg1,operand,info);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_emit2oiX__STUB, 6, 0,SCM_OBJ(&scm__sc.d1003[60]),intlib_compiled_code_emit2oiX, NULL, NULL);

static ScmObj intlib_compiled_code_new_label(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  SCM_ENTER_SUBR("compiled-code-new-label");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CompiledCodeNewLabel(cc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

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

static ScmObj intlib_compiled_code_set_labelX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj label_scm;
  ScmObj label;
  SCM_ENTER_SUBR("compiled-code-set-label!");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  label_scm = SCM_ARGREF(1);
  label = (label_scm);
  {
Scm_CompiledCodeSetLabel(cc,label);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBR(intlib_compiled_code_set_labelX__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[62]),intlib_compiled_code_set_labelX, NULL, NULL);

static ScmObj intlib_compiled_code_finish_builder(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj cc_scm;
  ScmCompiledCode* cc;
  ScmObj maxstack_scm;
  int maxstack;
  SCM_ENTER_SUBR("compiled-code-finish-builder");
  cc_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(cc_scm)) Scm_Error("compiled code required, but got %S", cc_scm);
  cc = SCM_COMPILED_CODE(cc_scm);
  maxstack_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(maxstack_scm)) Scm_Error("C integer required, but got %S", maxstack_scm);
  maxstack = Scm_GetInteger(maxstack_scm);
  {
Scm_CompiledCodeFinishBuilder(cc,maxstack);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_compiled_code_finish_builder__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[63]),SCM_SUBR_IMMEDIATE_ARG, intlib_compiled_code_finish_builder, NULL, NULL);

static ScmObj intlib_vm_dump_code(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj code_scm;
  ScmCompiledCode* code;
  SCM_ENTER_SUBR("vm-dump-code");
  code_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(code_scm)) Scm_Error("compiled code required, but got %S", code_scm);
  code = SCM_COMPILED_CODE(code_scm);
  {
Scm_CompiledCodeDump(code);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_dump_code__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[66]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_dump_code, NULL, NULL);

static ScmObj intlib_vm_code_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj code_scm;
  ScmCompiledCode* code;
  SCM_ENTER_SUBR("vm-code->list");
  code_scm = SCM_ARGREF(0);
  if (!SCM_COMPILED_CODE_P(code_scm)) Scm_Error("compiled code required, but got %S", code_scm);
  code = SCM_COMPILED_CODE(code_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_CompiledCodeToList(code));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_code_TOlist__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[67]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_code_TOlist, NULL, NULL);

static ScmObj intlib_vm_insn_build(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj insn_scm;
  ScmObj insn;
  SCM_ENTER_SUBR("vm-insn-build");
  insn_scm = SCM_ARGREF(0);
  insn = (insn_scm);
  {
{
u_long SCM_RESULT;

#line 376 "intlib.stub"
SCM_RESULT=(((u_long )(Scm_VMInsnBuild(insn))));
SCM_RETURN(Scm_MakeIntegerFromUI(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_vm_insn_build__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[68]),intlib_vm_insn_build, NULL, NULL);

static ScmObj intlib_vm_insn_code_TOname(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj opcode_scm;
  u_int opcode;
  SCM_ENTER_SUBR("vm-insn-code->name");
  opcode_scm = SCM_ARGREF(0);
  if (!SCM_UINTEGERP(opcode_scm)) Scm_Error("C integer required, but got %S", opcode_scm);
  opcode = Scm_GetIntegerU(opcode_scm);
  {
{
ScmObj SCM_RESULT;

#line 378 "intlib.stub"
SCM_RESULT=(SCM_INTERN(Scm_VMInsnName(opcode)));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_insn_code_TOname__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[69]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_insn_code_TOname, NULL, NULL);

static ScmObj intlib_vm_insn_name_TOcode(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj insn_name_scm;
  ScmObj insn_name;
  SCM_ENTER_SUBR("vm-insn-name->code");
  insn_name_scm = SCM_ARGREF(0);
  insn_name = (insn_name_scm);
  {
{
int SCM_RESULT;
SCM_RESULT=(Scm_VMInsnNameToCode(insn_name));
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib_vm_insn_name_TOcode__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[70]),intlib_vm_insn_name_TOcode, NULL, NULL);

static ScmObj intlib_vm_eval_situation(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj val_scm;
  ScmObj val;
  SCM_ENTER_SUBR("vm-eval-situation");
  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) {
    val_scm = SCM_ARGREF(0);
  } else {
    val_scm = SCM_UNBOUND;
  }
  val = (val_scm);
  {
{
int SCM_RESULT;

#line 384 "intlib.stub"
{ScmVM* vm=Scm_VM();
if (SCM_UNBOUNDP(val)){SCM_RESULT=((vm)->evalSituation);} else {
#line 387 "intlib.stub"
if (!(SCM_INTP(val))){{SCM_TYPE_ERROR(val,"integer");}}
{int prev=(vm)->evalSituation;
(vm)->evalSituation=(SCM_INT_VALUE(val));
SCM_RESULT=(prev);}}}
SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
}
  }
}

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

static ScmObj intlib_vm_compiler_flag_is_setP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj flag_scm;
  u_int flag;
  SCM_ENTER_SUBR("vm-compiler-flag-is-set?");
  flag_scm = SCM_ARGREF(0);
  if (!SCM_UINTEGERP(flag_scm)) Scm_Error("C integer required, but got %S", flag_scm);
  flag = Scm_GetIntegerU(flag_scm);
  {
{
int SCM_RESULT;

#line 398 "intlib.stub"
SCM_RESULT=(SCM_VM_COMPILER_FLAG_IS_SET(Scm_VM(),flag));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_compiler_flag_is_setP__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[75]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_compiler_flag_is_setP, NULL, NULL);

static ScmObj intlib_vm_compiler_flag_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj flag_scm;
  u_int flag;
  SCM_ENTER_SUBR("vm-compiler-flag-set!");
  flag_scm = SCM_ARGREF(0);
  if (!SCM_UINTEGERP(flag_scm)) Scm_Error("C integer required, but got %S", flag_scm);
  flag = Scm_GetIntegerU(flag_scm);
  {

#line 400 "intlib.stub"
SCM_VM_COMPILER_FLAG_SET(Scm_VM(),flag);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_compiler_flag_setX__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[76]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_compiler_flag_setX, NULL, NULL);

static ScmObj intlib_vm_compiler_flag_clearX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj flag_scm;
  u_int flag;
  SCM_ENTER_SUBR("vm-compiler-flag-clear!");
  flag_scm = SCM_ARGREF(0);
  if (!SCM_UINTEGERP(flag_scm)) Scm_Error("C integer required, but got %S", flag_scm);
  flag = Scm_GetIntegerU(flag_scm);
  {

#line 402 "intlib.stub"
SCM_VM_COMPILER_FLAG_CLEAR(Scm_VM(),flag);
SCM_RETURN(SCM_UNDEFINED);
  }
}

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

static ScmObj intlib_vm_compiler_flag_noinline_localsP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("vm-compiler-flag-noinline-locals?");
  {
{
int SCM_RESULT;

#line 405 "intlib.stub"
SCM_RESULT=(SCM_VM_COMPILER_FLAG_IS_SET(Scm_VM(),SCM_COMPILE_NOINLINE_LOCALS));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_compiler_flag_noinline_localsP__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[78]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_compiler_flag_noinline_localsP, NULL, NULL);

static ScmObj intlib_vm_compiler_flag_no_post_inlineP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("vm-compiler-flag-no-post-inline?");
  {
{
int SCM_RESULT;

#line 407 "intlib.stub"
SCM_RESULT=(SCM_VM_COMPILER_FLAG_IS_SET(Scm_VM(),SCM_COMPILE_NO_POST_INLINE_OPT));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_compiler_flag_no_post_inlineP__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[79]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_compiler_flag_no_post_inlineP, NULL, NULL);

static ScmObj intlib_vm_compiler_flag_no_liftingP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("vm-compiler-flag-no-lifting?");
  {
{
int SCM_RESULT;

#line 409 "intlib.stub"
SCM_RESULT=(SCM_VM_COMPILER_FLAG_IS_SET(Scm_VM(),SCM_COMPILE_NO_LIFTING));
SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_compiler_flag_no_liftingP__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[80]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_compiler_flag_no_liftingP, NULL, NULL);

static ScmObj intlib_vm_current_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("vm-current-module");
  {
{
ScmObj SCM_RESULT;

#line 421 "intlib.stub"
SCM_RESULT=(SCM_OBJ((Scm_VM())->module));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_current_module__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[89]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_current_module, NULL, NULL);

static ScmObj intlib_vm_set_current_module(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj mod_scm;
  ScmModule* mod;
  SCM_ENTER_SUBR("vm-set-current-module");
  mod_scm = SCM_ARGREF(0);
  if (!SCM_MODULEP(mod_scm)) Scm_Error("module required, but got %S", mod_scm);
  mod = SCM_MODULE(mod_scm);
  {

#line 423 "intlib.stub"
(Scm_VM())->module=(mod);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_vm_set_current_module__STUB, 1, 0,0, SCM_OBJ(&scm__sc.d1003[90]),SCM_SUBR_IMMEDIATE_ARG, intlib_vm_set_current_module, NULL, NULL);

static ScmObj intlib__25call_2fpc(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  SCM_ENTER_SUBR("%call/pc");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  {
{
ScmObj SCM_RESULT;

#line 426 "intlib.stub"
SCM_RESULT=(Scm_VMCallPC(proc));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25call_2fpc__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[91]),intlib__25call_2fpc, NULL, NULL);

static ScmObj intlib_gc_print_static_roots(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("gc-print-static-roots");
  {
Scm_PrintStaticRoots();
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib_gc_print_static_roots__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[92]),SCM_SUBR_IMMEDIATE_ARG, intlib_gc_print_static_roots, NULL, NULL);

static ScmObj intlib_profiler_raw_result(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  SCM_ENTER_SUBR("profiler-raw-result");
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ProfilerRawResult());
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_profiler_raw_result__STUB, 0, 0,0, SCM_OBJ(&scm__sc.d1003[93]),SCM_SUBR_IMMEDIATE_ARG, intlib_profiler_raw_result, NULL, NULL);

static ScmObj intlib__25imax(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj x_scm;
  ScmObj x;
  ScmObj y_scm;
  ScmObj y;
  SCM_ENTER_SUBR("%imax");
  x_scm = SCM_ARGREF(0);
  x = (x_scm);
  y_scm = SCM_ARGREF(1);
  y = (y_scm);
  {
{
ScmObj SCM_RESULT;

#line 447 "intlib.stub"
if ((SCM_WORD(x))>(SCM_WORD(y))){SCM_RESULT=(x);} else {SCM_RESULT=(y);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25imax__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[94]),intlib__25imax, NULL, NULL);

static ScmObj map1c_cc(ScmObj result,void** data){{
#line 451 "intlib.stub"
{ScmObj proc=SCM_OBJ((data)[0]);ScmObj r=
SCM_OBJ((data)[1]);ScmObj lis=
SCM_OBJ((data)[2]);ScmObj c=
SCM_OBJ((data)[3]);
if (SCM_NULLP(lis)){return (Scm_ReverseX(Scm_Cons(result,r)));} else {
#line 457 "intlib.stub"
(data)[1]=(Scm_Cons(result,r)),
(data)[2]=(SCM_CDR(lis));
Scm_VMPushCC(map1c_cc,data,4);
return (Scm_VMApply2(proc,SCM_CAR(lis),c));}}}}
static ScmObj intlib__25map1c(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj lis_scm;
  ScmObj lis;
  ScmObj c_scm;
  ScmObj c;
  SCM_ENTER_SUBR("%map1c");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  lis_scm = SCM_ARGREF(1);
  lis = (lis_scm);
  c_scm = SCM_ARGREF(2);
  c = (c_scm);
  {
{
ScmObj SCM_RESULT;

#line 463 "intlib.stub"
{void* data[4];
if (SCM_NULLP(lis)){SCM_RESULT=(SCM_NIL);} else {
#line 466 "intlib.stub"
(data)[0]=(proc),
(data)[1]=(SCM_NIL),
(data)[2]=(SCM_CDR(lis)),
(data)[3]=(c);
Scm_VMPushCC(map1c_cc,data,4);
SCM_RESULT=(Scm_VMApply2(proc,SCM_CAR(lis),c));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25map1c__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[95]),intlib__25map1c, NULL, NULL);

static ScmObj map1cc_cc(ScmObj result,void** data){{
#line 475 "intlib.stub"
{ScmObj proc=SCM_OBJ((data)[0]);ScmObj r=
SCM_OBJ((data)[1]);ScmObj lis=
SCM_OBJ((data)[2]);ScmObj c1=
SCM_OBJ((data)[3]);ScmObj c2=
SCM_OBJ((data)[4]);
if (SCM_NULLP(lis)){return (Scm_ReverseX(Scm_Cons(result,r)));} else {
#line 482 "intlib.stub"
(data)[1]=(Scm_Cons(result,r)),
(data)[2]=(SCM_CDR(lis));
Scm_VMPushCC(map1cc_cc,data,5);
return (Scm_VMApply3(proc,SCM_CAR(lis),c1,c2));}}}}
static ScmObj intlib__25map1cc(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj proc_scm;
  ScmObj proc;
  ScmObj lis_scm;
  ScmObj lis;
  ScmObj c1_scm;
  ScmObj c1;
  ScmObj c2_scm;
  ScmObj c2;
  SCM_ENTER_SUBR("%map1cc");
  proc_scm = SCM_ARGREF(0);
  proc = (proc_scm);
  lis_scm = SCM_ARGREF(1);
  lis = (lis_scm);
  c1_scm = SCM_ARGREF(2);
  c1 = (c1_scm);
  c2_scm = SCM_ARGREF(3);
  c2 = (c2_scm);
  {
{
ScmObj SCM_RESULT;

#line 488 "intlib.stub"
if (SCM_NULLP(lis)){
SCM_RESULT=(SCM_NIL);} else {
{void* data[5];
(data)[0]=(proc),
(data)[1]=(SCM_NIL),
(data)[2]=(SCM_CDR(lis)),
(data)[3]=(c1),
(data)[4]=(c2);
Scm_VMPushCC(map1cc_cc,data,5);
SCM_RESULT=(Scm_VMApply3(proc,SCM_CAR(lis),c1,c2));}}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25map1cc__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[96]),intlib__25map1cc, NULL, NULL);

static ScmObj intlib__25map_cons(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj lis1_scm;
  ScmObj lis1;
  ScmObj lis2_scm;
  ScmObj lis2;
  SCM_ENTER_SUBR("%map-cons");
  lis1_scm = SCM_ARGREF(0);
  lis1 = (lis1_scm);
  lis2_scm = SCM_ARGREF(1);
  lis2 = (lis2_scm);
  {
{
ScmObj SCM_RESULT;

#line 501 "intlib.stub"
{ScmObj h=SCM_NIL;ScmObj t=SCM_NIL;
while((SCM_PAIRP(lis1))&&(SCM_PAIRP(lis2))){
SCM_APPEND1(h,t,Scm_Cons(SCM_CAR(lis1),SCM_CAR(lis2)));
lis1=(SCM_CDR(lis1)),lis2=(SCM_CDR(lis2));}
SCM_RESULT=(h);}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25map_cons__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[97]),intlib__25map_cons, NULL, NULL);

static ScmObj intlib__25apply_rec0(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  SCM_ENTER_SUBR("%apply-rec0");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec0(p));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec0__STUB, 1, 0,SCM_OBJ(&scm__sc.d1003[98]),intlib__25apply_rec0, NULL, NULL);

static ScmObj intlib__25apply_rec1(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  ScmObj a_scm;
  ScmObj a;
  SCM_ENTER_SUBR("%apply-rec1");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  a_scm = SCM_ARGREF(1);
  a = (a_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec1(p,a));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec1__STUB, 2, 0,SCM_OBJ(&scm__sc.d1003[99]),intlib__25apply_rec1, NULL, NULL);

static ScmObj intlib__25apply_rec2(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  ScmObj a_scm;
  ScmObj a;
  ScmObj b_scm;
  ScmObj b;
  SCM_ENTER_SUBR("%apply-rec2");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  a_scm = SCM_ARGREF(1);
  a = (a_scm);
  b_scm = SCM_ARGREF(2);
  b = (b_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec2(p,a,b));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec2__STUB, 3, 0,SCM_OBJ(&scm__sc.d1003[100]),intlib__25apply_rec2, NULL, NULL);

static ScmObj intlib__25apply_rec3(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  ScmObj a_scm;
  ScmObj a;
  ScmObj b_scm;
  ScmObj b;
  ScmObj c_scm;
  ScmObj c;
  SCM_ENTER_SUBR("%apply-rec3");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  a_scm = SCM_ARGREF(1);
  a = (a_scm);
  b_scm = SCM_ARGREF(2);
  b = (b_scm);
  c_scm = SCM_ARGREF(3);
  c = (c_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec3(p,a,b,c));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec3__STUB, 4, 0,SCM_OBJ(&scm__sc.d1003[101]),intlib__25apply_rec3, NULL, NULL);

static ScmObj intlib__25apply_rec4(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  ScmObj a_scm;
  ScmObj a;
  ScmObj b_scm;
  ScmObj b;
  ScmObj c_scm;
  ScmObj c;
  ScmObj d_scm;
  ScmObj d;
  SCM_ENTER_SUBR("%apply-rec4");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  a_scm = SCM_ARGREF(1);
  a = (a_scm);
  b_scm = SCM_ARGREF(2);
  b = (b_scm);
  c_scm = SCM_ARGREF(3);
  c = (c_scm);
  d_scm = SCM_ARGREF(4);
  d = (d_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec4(p,a,b,c,d));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec4__STUB, 5, 0,SCM_OBJ(&scm__sc.d1003[102]),intlib__25apply_rec4, NULL, NULL);

static ScmObj intlib__25apply_rec(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmObj p;
  ScmObj args_scm;
  ScmObj args;
  SCM_ENTER_SUBR("%apply-rec");
  p_scm = SCM_ARGREF(0);
  p = (p_scm);
  args_scm = SCM_ARGREF(SCM_ARGCNT-1);
  args = (args_scm);
  {
{
ScmObj SCM_RESULT;
SCM_RESULT=(Scm_ApplyRec(p,args));
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBR(intlib__25apply_rec__STUB, 1, 1,SCM_OBJ(&scm__sc.d1003[103]),intlib__25apply_rec, NULL, NULL);

static ScmObj intlib__25procedure_currying_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj p_scm;
  ScmProcedure* p;
  ScmObj f_scm;
  int f;
  SCM_ENTER_SUBR("%procedure-currying-set!");
  p_scm = SCM_ARGREF(0);
  if (!SCM_PROCEDUREP(p_scm)) Scm_Error("procedure required, but got %S", p_scm);
  p = SCM_PROCEDURE(p_scm);
  f_scm = SCM_ARGREF(1);
  if (!SCM_BOOLP(f_scm)) Scm_Error("boolean required, but got %S", f_scm);
  f = SCM_BOOL_VALUE(f_scm);
  {

#line 522 "intlib.stub"
SCM_PROCEDURE_CURRYING(p)=(f);
SCM_RETURN(SCM_UNDEFINED);
  }
}

static SCM_DEFINE_SUBRX(intlib__25procedure_currying_setX__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[104]),SCM_SUBR_IMMEDIATE_ARG, intlib__25procedure_currying_setX, NULL, NULL);

typedef struct case_lambda_packet_rec {
    ScmVector *dispatch_vector;
    int max_optargs;
    int min_reqargs;
 } case_lambda_packet;
static ScmObj case_lambda_dispatch(ScmObj* args,int nargs,void* data){{
#line 565 "intlib.stub"
{case_lambda_packet* d=((case_lambda_packet* )(data));ScmObj rarg=
(args)[(nargs)-(1)];
SCM_ASSERT((nargs)>((d)->min_reqargs));
SCM_ASSERT((nargs)<=((((d)->min_reqargs)+((d)->max_optargs))+(1)));
#line 572 "intlib.stub"
{ScmObj p=SCM_VECTOR_ELEMENT((d)->dispatch_vector,
((nargs)-((d)->min_reqargs))-(1));
if (SCM_FALSEP(p)){{
Scm_Error("wrong number of arguments to case lambda: %S",
Scm_ArrayToListWithTail(args,(nargs)-(1),
(args)[(nargs)-(1)]));}}
if (SCM_NULLP(rarg)){
switch ((nargs)-(1)) {
case 0 : {return (Scm_VMApply0(p));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 581 "intlib.stub"
case 1 : {return (Scm_VMApply1(p,(args)[0]));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 582 "intlib.stub"
case 2 : {return (Scm_VMApply2(p,(args)[0],(args)[1]));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 583 "intlib.stub"
case 3 : {return (Scm_VMApply3(p,(args)[0],(args)[1],
(args)[2]));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}
#line 585 "intlib.stub"
case 4 : {return (Scm_VMApply4(p,(args)[0],(args)[1],
(args)[2],(args)[3]));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}default: {
#line 587 "intlib.stub"
return (Scm_VMApply(p,Scm_ArrayToList(args,(nargs)-(1))));
#line 542 "../lib/gauche/cgen/cise.scm"
break;}}} else {
#line 588 "intlib.stub"
return (
Scm_VMApply(p,Scm_ArrayToListWithTail(args,(nargs)-(1),rarg)));}}}}}
static ScmObj intlib_make_case_lambda_dispatcher(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
{
  ScmObj dispatch_vector_scm;
  ScmVector* dispatch_vector;
  ScmObj min_reqargs_scm;
  int min_reqargs;
  SCM_ENTER_SUBR("make-case-lambda-dispatcher");
  dispatch_vector_scm = SCM_ARGREF(0);
  if (!SCM_VECTORP(dispatch_vector_scm)) Scm_Error("vector required, but got %S", dispatch_vector_scm);
  dispatch_vector = SCM_VECTOR(dispatch_vector_scm);
  min_reqargs_scm = SCM_ARGREF(1);
  if (!SCM_INTEGERP(min_reqargs_scm)) Scm_Error("C integer required, but got %S", min_reqargs_scm);
  min_reqargs = Scm_GetInteger(min_reqargs_scm);
  {
{
ScmObj SCM_RESULT;

#line 598 "intlib.stub"
{int max_optargs=SCM_VECTOR_SIZE(dispatch_vector);case_lambda_packet* packet=
SCM_NEW(case_lambda_packet);
(packet)->min_reqargs=(min_reqargs),
(packet)->max_optargs=(max_optargs),
(packet)->dispatch_vector=(dispatch_vector);
SCM_RESULT=(Scm_MakeSubr(case_lambda_dispatch,packet,min_reqargs,max_optargs,
#line 605 "intlib.stub"
SCM_LIST3(scm__rc.d1004[23],
SCM_MAKE_INT(min_reqargs),
SCM_OBJ(dispatch_vector))));}
SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
}
  }
}

static SCM_DEFINE_SUBRX(intlib_make_case_lambda_dispatcher__STUB, 2, 0,0, SCM_OBJ(&scm__sc.d1003[105]),SCM_SUBR_IMMEDIATE_ARG, intlib_make_case_lambda_dispatcher, NULL, NULL);

void Scm_Init_intlib(ScmModule *mod){

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("pair-attributes")), SCM_OBJ(&intlib_pair_attributes__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("pair-attribute-get")), SCM_OBJ(&intlib_pair_attribute_get__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("pair-attribute-set!")), SCM_OBJ(&intlib_pair_attribute_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("extended-pair?")), SCM_OBJ(&intlib_extended_pairP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("extended-cons")), SCM_OBJ(&intlib_extended_cons__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("extended-list")), SCM_OBJ(&intlib_extended_list__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("cond-features")), SCM_OBJ(&intlib_cond_features__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-syntactic-closure")), SCM_OBJ(&intlib_make_syntactic_closure__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-identifier")), SCM_OBJ(&intlib_make_identifier__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identifier-module")), SCM_OBJ(&intlib_identifier_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identifier-name")), SCM_OBJ(&intlib_identifier_name__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("identifier-env")), SCM_OBJ(&intlib_identifier_env__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("find-binding")), SCM_OBJ(&intlib_find_binding__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("find-const-binding")), SCM_OBJ(&intlib_find_const_binding__STUB), 0);
  scm__rc.d1004[0] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[14]))); /* quote */
  SCM_SET_CAR(SCM_OBJ(&scm__rc.d1004[3]), scm__rc.d1004[0]);
  scm__rc.d1004[5] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[16]))); /* const */
  scm__rc.d1004[6] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[17]))); /* inlinable */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%insert-binding")), SCM_OBJ(&intlib__25insert_binding__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%hide-binding")), SCM_OBJ(&intlib__25hide_binding__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%alias-binding")), SCM_OBJ(&intlib__25alias_binding__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%make-wrapper-module")), SCM_OBJ(&intlib__25make_wrapper_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%export-symbols")), SCM_OBJ(&intlib__25export_symbols__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%import-module")), SCM_OBJ(&intlib__25import_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%import-modules")), SCM_OBJ(&intlib__25import_modules__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gloc-bound?")), SCM_OBJ(&intlib_gloc_boundP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gloc-ref")), SCM_OBJ(&intlib_gloc_ref__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gloc-set!")), SCM_OBJ(&intlib_gloc_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gloc-const?")), SCM_OBJ(&intlib_gloc_constP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gloc-inlinable?")), SCM_OBJ(&intlib_gloc_inlinableP__STUB), 0);
#if defined(RECORD_DEPENDED_MODULES)
stdmods[0] = Scm_NullModule();
#endif /* defined(RECORD_DEPENDED_MODULES) */
#if defined(RECORD_DEPENDED_MODULES)
stdmods[1] = Scm_SchemeModule();
#endif /* defined(RECORD_DEPENDED_MODULES) */
#if defined(RECORD_DEPENDED_MODULES)
stdmods[2] = Scm_GaucheModule();
#endif /* defined(RECORD_DEPENDED_MODULES) */
  scm__rc.d1004[7] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[30]))); /* inline */
  scm__rc.d1004[8] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[31]))); /* syntax */
  scm__rc.d1004[9] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[32]))); /* macro */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("global-call-type")), SCM_OBJ(&intlib_global_call_type__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("macro?")), SCM_OBJ(&intlib_macroP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("syntax?")), SCM_OBJ(&intlib_syntaxP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-toplevel-closure")), SCM_OBJ(&intlib_make_toplevel_closure__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-macro-transformer")), SCM_OBJ(&intlib_make_macro_transformer__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compile-syntax-rules")), SCM_OBJ(&intlib_compile_syntax_rules__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("call-macro-expander")), SCM_OBJ(&intlib_call_macro_expander__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-syntax")), SCM_OBJ(&intlib_make_syntax__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("call-syntax-handler")), SCM_OBJ(&intlib_call_syntax_handler__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("syntax-handler")), SCM_OBJ(&intlib_syntax_handler__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%internal-macro-expand")), SCM_OBJ(&intlib__25internal_macro_expand__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%procedure-inliner")), SCM_OBJ(&intlib__25procedure_inliner__STUB), 0);
  Scm_SetterSet(SCM_PROCEDURE(&intlib__25procedure_inliner__STUB), SCM_PROCEDURE(&intlib__25procedure_inliner_SETTER__STUB), TRUE);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%mark-binding-inlinable!")), SCM_OBJ(&intlib__25mark_binding_inlinableX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-compiled-code-builder")), SCM_OBJ(&intlib_make_compiled_code_builder__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit0!")), SCM_OBJ(&intlib_compiled_code_emit0X__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit-PUSH!")), SCM_OBJ(&intlib_compiled_code_emit_PUSHX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit-RET!")), SCM_OBJ(&intlib_compiled_code_emit_RETX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit0o!")), SCM_OBJ(&intlib_compiled_code_emit0oX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit0i!")), SCM_OBJ(&intlib_compiled_code_emit0iX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit0oi!")), SCM_OBJ(&intlib_compiled_code_emit0oiX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit1!")), SCM_OBJ(&intlib_compiled_code_emit1X__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit1o!")), SCM_OBJ(&intlib_compiled_code_emit1oX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit1i!")), SCM_OBJ(&intlib_compiled_code_emit1iX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit1oi!")), SCM_OBJ(&intlib_compiled_code_emit1oiX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit2!")), SCM_OBJ(&intlib_compiled_code_emit2X__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit2o!")), SCM_OBJ(&intlib_compiled_code_emit2oX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit2i!")), SCM_OBJ(&intlib_compiled_code_emit2iX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-emit2oi!")), SCM_OBJ(&intlib_compiled_code_emit2oiX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-new-label")), SCM_OBJ(&intlib_compiled_code_new_label__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-set-label!")), SCM_OBJ(&intlib_compiled_code_set_labelX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("compiled-code-finish-builder")), SCM_OBJ(&intlib_compiled_code_finish_builder__STUB), 0);
  scm__rc.d1004[10] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[64]))); /* ENV_HEADER_SIZE */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[10]), SCM_MAKE_INT(ENV_SIZE(0)), SCM_BINDING_CONST);

  scm__rc.d1004[11] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[65]))); /* CONT_FRAME_SIZE */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[11]), SCM_MAKE_INT(CONT_FRAME_SIZE), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-dump-code")), SCM_OBJ(&intlib_vm_dump_code__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-code->list")), SCM_OBJ(&intlib_vm_code_TOlist__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-insn-build")), SCM_OBJ(&intlib_vm_insn_build__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-insn-code->name")), SCM_OBJ(&intlib_vm_insn_code_TOname__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-insn-name->code")), SCM_OBJ(&intlib_vm_insn_name_TOcode__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-eval-situation")), SCM_OBJ(&intlib_vm_eval_situation__STUB), 0);
  scm__rc.d1004[12] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[72]))); /* SCM_VM_EXECUTING */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[12]), Scm_MakeInteger(SCM_VM_EXECUTING), SCM_BINDING_CONST);

  scm__rc.d1004[13] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[73]))); /* SCM_VM_LOADING */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[13]), Scm_MakeInteger(SCM_VM_LOADING), SCM_BINDING_CONST);

  scm__rc.d1004[14] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[74]))); /* SCM_VM_COMPILING */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[14]), Scm_MakeInteger(SCM_VM_COMPILING), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-is-set?")), SCM_OBJ(&intlib_vm_compiler_flag_is_setP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-set!")), SCM_OBJ(&intlib_vm_compiler_flag_setX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-clear!")), SCM_OBJ(&intlib_vm_compiler_flag_clearX__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-noinline-locals?")), SCM_OBJ(&intlib_vm_compiler_flag_noinline_localsP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-no-post-inline?")), SCM_OBJ(&intlib_vm_compiler_flag_no_post_inlineP__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-compiler-flag-no-lifting?")), SCM_OBJ(&intlib_vm_compiler_flag_no_liftingP__STUB), 0);
  scm__rc.d1004[15] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[81]))); /* SCM_COMPILE_NOINLINE_GLOBALS */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[15]), Scm_MakeInteger(SCM_COMPILE_NOINLINE_GLOBALS), SCM_BINDING_CONST);

  scm__rc.d1004[16] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[82]))); /* SCM_COMPILE_NOINLINE_LOCALS */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[16]), Scm_MakeInteger(SCM_COMPILE_NOINLINE_LOCALS), SCM_BINDING_CONST);

  scm__rc.d1004[17] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[83]))); /* SCM_COMPILE_NOINLINE_CONSTS */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[17]), Scm_MakeInteger(SCM_COMPILE_NOINLINE_CONSTS), SCM_BINDING_CONST);

  scm__rc.d1004[18] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[84]))); /* SCM_COMPILE_NOSOURCE */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[18]), Scm_MakeInteger(SCM_COMPILE_NOSOURCE), SCM_BINDING_CONST);

  scm__rc.d1004[19] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[85]))); /* SCM_COMPILE_SHOWRESULT */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[19]), Scm_MakeInteger(SCM_COMPILE_SHOWRESULT), SCM_BINDING_CONST);

  scm__rc.d1004[20] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[86]))); /* SCM_COMPILE_NOCOMBINE */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[20]), Scm_MakeInteger(SCM_COMPILE_NOCOMBINE), SCM_BINDING_CONST);

  scm__rc.d1004[21] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[87]))); /* SCM_COMPILE_NO_POST_INLINE_OPT */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[21]), Scm_MakeInteger(SCM_COMPILE_NO_POST_INLINE_OPT), SCM_BINDING_CONST);

  scm__rc.d1004[22] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[88]))); /* SCM_COMPILE_NO_LIFTING */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(scm__rc.d1004[22]), Scm_MakeInteger(SCM_COMPILE_NO_LIFTING), SCM_BINDING_CONST);

  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-current-module")), SCM_OBJ(&intlib_vm_current_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("vm-set-current-module")), SCM_OBJ(&intlib_vm_set_current_module__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%call/pc")), SCM_OBJ(&intlib__25call_2fpc__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("gc-print-static-roots")), SCM_OBJ(&intlib_gc_print_static_roots__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("profiler-raw-result")), SCM_OBJ(&intlib_profiler_raw_result__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%imax")), SCM_OBJ(&intlib__25imax__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%map1c")), SCM_OBJ(&intlib__25map1c__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%map1cc")), SCM_OBJ(&intlib__25map1cc__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%map-cons")), SCM_OBJ(&intlib__25map_cons__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec0")), SCM_OBJ(&intlib__25apply_rec0__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec1")), SCM_OBJ(&intlib__25apply_rec1__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec2")), SCM_OBJ(&intlib__25apply_rec2__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec3")), SCM_OBJ(&intlib__25apply_rec3__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec4")), SCM_OBJ(&intlib__25apply_rec4__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%apply-rec")), SCM_OBJ(&intlib__25apply_rec__STUB), 0);
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("%procedure-currying-set!")), SCM_OBJ(&intlib__25procedure_currying_setX__STUB), 0);
  scm__rc.d1004[23] = Scm_Intern(SCM_STRING(SCM_OBJ(&scm__sc.d1003[106]))); /* case-lambda-dispatcher */
  Scm_MakeBinding(SCM_MODULE(mod), SCM_SYMBOL(SCM_INTERN("make-case-lambda-dispatcher")), SCM_OBJ(&intlib_make_case_lambda_dispatcher__STUB), 0);
}
