/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/builtin.lsp                    */
#include <ecl/ecl-cmp.h>
#include "clos/builtin.eclh"
/* local function MAKE-INSTANCE                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2012make_instance(cl_narg narg, cl_object v1class, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("MAKE-INSTANCE",953));
 {
  va_list args; va_start(args,v1class);
  va_end(args);
  value0 = cl_error(2, VV[1], v1class);
  return value0;
 }
}
/* local function ENSURE-CLASS-USING-CLASS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2013ensure_class_using_class(cl_narg narg, cl_object v1class, cl_object v2name, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("ENSURE-CLASS-USING-CLASS",1583));
 {
  cl_object v3rest;
  ecl_va_list args; ecl_va_start(args,v2name,narg,2);
  v3rest = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v4;                                  /*  METACLASS               */
   cl_object v5;                                  /*  OPTIONS                 */
   T0 = (VV[3]->symbol.gfdef);
   value0 = cl_apply(2, T0, v3rest);
   {
    const int v6 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v7;
    v7 = (v6<=2)? ECL_NIL : cl_env_copy->values[2];
    v5 = v7;
   }
   T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
   v1class = cl_apply(5, T0, v4, ECL_SYM("NAME",1309), v2name, v5);
   if (Null(v2name)){
    goto L6;
   }
   (cl_env_copy->function=(ECL_SYM("CREATE-TYPE-NAME",1661)->symbol.gfdef))->cfun.entry(1, v2name) /*  CREATE-TYPE-NAME */;
   value0 = (cl_env_copy->function=(VV[4]->symbol.gfdef))->cfun.entry(2, v1class, v2name) /*  SETF-FIND-CLASS */;
   return value0;
L6:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function CHANGE-CLASS                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2014change_class(cl_narg narg, cl_object v1instance, cl_object v2new_class, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("CHANGE-CLASS",936));
 {
  cl_object v3initargs;
  ecl_va_list args; ecl_va_start(args,v2new_class,narg,2);
  v3initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("CHANGE-CLASS",936)->symbol.gfdef);
  T1 = cl_find_class(1, v2new_class);
  value0 = cl_apply(4, T0, v1instance, T1, v3initargs);
  return value0;
 }
}
/* local function MAKE-INSTANCES-OBSOLETE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2015make_instances_obsolete(cl_object v1class)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_find_class(1, v1class);
 (cl_env_copy->function=(ECL_SYM("MAKE-INSTANCES-OBSOLETE",954)->symbol.gfdef))->cfun.entry(1, T0) /*  MAKE-INSTANCES-OBSOLETE */;
 value0 = v1class;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2015make_instances_obsolete_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("MAKE-INSTANCES-OBSOLETE",954));
 {
  return LC2015make_instances_obsolete(v2class);
 }
}
/* local function MAKE-INSTANCE                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2016make_instance(cl_narg narg, cl_object v1class_name, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("MAKE-INSTANCE",953));
 {
  cl_object v2initargs;
  ecl_va_list args; ecl_va_start(args,v1class_name,narg,1);
  v2initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
  T1 = cl_find_class(1, v1class_name);
  value0 = cl_apply(3, T0, T1, v2initargs);
  return value0;
 }
}
/* local function SLOT-MAKUNBOUND-USING-CLASS                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2017slot_makunbound_using_class(cl_object v1class, cl_object v2self, cl_object v3slotd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_error(1, VV[5]);
 return value0;
}
static cl_object LC2017slot_makunbound_using_class_va(cl_narg narg, cl_object v4class, cl_object v5self, cl_object v6slotd, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(ECL_SYM("SLOT-MAKUNBOUND-USING-CLASS",1628));
 {
  return LC2017slot_makunbound_using_class(v4class, v5self, v6slotd);
 }
}
/* local function SLOT-BOUNDP-USING-CLASS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2018slot_boundp_using_class(cl_object v1class, cl_object v2self, cl_object v3slotd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_error(1, VV[6]);
 return value0;
}
static cl_object LC2018slot_boundp_using_class_va(cl_narg narg, cl_object v4class, cl_object v5self, cl_object v6slotd, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(ECL_SYM("SLOT-BOUNDP-USING-CLASS",1617));
 {
  return LC2018slot_boundp_using_class(v4class, v5self, v6slotd);
 }
}
/* local function SLOT-VALUE-USING-CLASS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2019slot_value_using_class(cl_object v1class, cl_object v2self, cl_object v3slotd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_error(1, VV[7]);
 return value0;
}
static cl_object LC2019slot_value_using_class_va(cl_narg narg, cl_object v4class, cl_object v5self, cl_object v6slotd, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(ECL_SYM("SLOT-VALUE-USING-CLASS",1629));
 {
  return LC2019slot_value_using_class(v4class, v5self, v6slotd);
 }
}
/* local function SLOT-VALUE-USING-CLASS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2020slot_value_using_class(cl_object v1val, cl_object v2class, cl_object v3self, cl_object v4slotd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_error(1, VV[7]);
 return value0;
}
static cl_object LC2020slot_value_using_class_va(cl_narg narg, cl_object v5val, cl_object v6class, cl_object v7self, cl_object v8slotd, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(ECL_SYM("SLOT-VALUE-USING-CLASS",1629));
 {
  return LC2020slot_value_using_class(v5val, v6class, v7self, v8slotd);
 }
}
/* local function SLOT-EXISTS-P-USING-CLASS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2021slot_exists_p_using_class(cl_object v1class, cl_object v2self, cl_object v3slotd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2021slot_exists_p_using_class_va(cl_narg narg, cl_object v4class, cl_object v5self, cl_object v6slotd, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[8]);
 {
  return LC2021slot_exists_p_using_class(v4class, v5self, v6slotd);
 }
}
/* local function ALLOCATE-INSTANCE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2022allocate_instance(cl_narg narg, cl_object v1class, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("ALLOCATE-INSTANCE",931));
 {
  va_list args; va_start(args,v1class);
  va_end(args);
  T0 = (ECL_SYM("MAKE-STRUCTURE",1117)->symbol.gfdef);
  T1 = (cl_env_copy->function=(VV[9]->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SIZE */;
  T2 = cl_make_list(3, T1, ECL_SYM("INITIAL-ELEMENT",1286), ECL_NIL);
  value0 = cl_apply(3, T0, v1class, T2);
  return value0;
 }
}
/* local function FINALIZE-INHERITANCE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2025finalize_inheritance(cl_object v1class)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
  goto L3;
 }
 T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
 goto L2;
L3:;
 T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
 T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L2:;
 lex0[0] = T0;                                    /*  .CLOSED-COMBINED-METHOD-ARGS. */
 lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
 if (Null((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */)){
  goto L6;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 LC2023call_next_method(0, lex0);
 {
  cl_object v2;
  v2 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
  goto L12;
L11:;
  {
   cl_object v3slot;
   v3slot = ecl_car(v2);
   T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v3slot) /*  SLOT-DEFINITION-ALLOCATION */;
   if ((ECL_SYM("INSTANCE",1291))==(T0)) {
    goto L16;
   }
   T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-NAME */;
   cl_error(2, VV[11], T0);
L16:;
  }
  v2 = ecl_cdr(v2);
L12:;
  if (Null(v2)){
   goto L20;
  }
  goto L11;
L20:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2025finalize_inheritance_va(cl_narg narg, cl_object v3class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FINALIZE-INHERITANCE",1589));
 {
  return LC2025finalize_inheritance(v3class);
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2026make_load_form(cl_narg narg, cl_object v1object, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = (cl_env_copy->function=(ECL_SYM("MAKE-LOAD-FORM-SAVING-SLOTS",956)->symbol.gfdef))->cfun.entry(3, v1object, ECL_SYM("KEY",1297), v2environment) /*  MAKE-LOAD-FORM-SAVING-SLOTS */;
  return value0;
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2027print_object(cl_object v1obj, cl_object v2stream)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3class;
  cl_object v4slotds;
  v3class = si_instance_class(v1obj);
  v4slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-SLOTS */;
  if (ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59))!=ECL_NIL) {
   goto L4;
  }
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53)))){
   goto L4;
  }
  if (!(ecl_zerop(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53))))){
   goto L4;
  }
  cl_write_string(2, VV[12], v2stream);
  value0 = v1obj;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  cl_write_string(2, VV[13], v2stream);
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-NAME */;
  (ecl_prin1(T0,v2stream));
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53)))){
   goto L13;
  }
  if (!(ecl_greatereq(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53)),ecl_make_int8_t(1)))){
   goto L13;
  }
  T0 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53)));
  goto L12;
L13:;
  T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53));
L12:;
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),T0); /*  *PRINT-LEVEL* */
  {
   cl_object v5;
   cl_object v6scan;
   cl_fixnum v7i;
   cl_object v8sv;
   value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52));
   if (value0!=ECL_NIL) {
    goto L18;
   }
   v5 = ecl_make_fixnum(2305843009213693951);
   goto L16;
L18:;
   v5 = value0;
   goto L16;
L16:;
   v6scan = v4slotds;
   v7i = (cl_fixnum)(0);
   v8sv = ECL_NIL;
   goto L25;
L24:;
   if (!(ecl_greatereq(ecl_make_fixnum(v7i),v5))){
    goto L27;
   }
   cl_write_string(2, VV[14], v2stream);
   ecl_bds_unwind1(cl_env_copy);
   goto L11;
L27:;
   v8sv = ecl_instance_ref((v1obj),(v7i));
   cl_write_string(2, VV[15], v2stream);
   T0 = ecl_car(v6scan);
   T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
   T2 = ecl_symbol_name(T1);
   T3 = cl_find_package(ECL_SYM("KEYWORD",451));
   T4 = cl_intern(2, T2, T3);
   (ecl_prin1(T4,v2stream));
   cl_write_string(2, VV[15], v2stream);
   (ecl_prin1(v8sv,v2stream));
   v6scan = ecl_cdr(v6scan);
   {
    cl_object v9;
    v9 = ecl_make_integer((v7i)+1);
    {
     bool v10;
     v10 = ECL_FIXNUMP(v9);
     if (ecl_unlikely(!(v10)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v7i = ecl_fixnum(v9);
   }
L25:;
   if (v6scan==ECL_NIL) {
    goto L41;
   }
   goto L24;
L41:;
   ecl_bds_unwind1(cl_env_copy);
  }
L11:;
  cl_write_string(2, VV[16], v2stream);
  value0 = v1obj;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2027print_object_va(cl_narg narg, cl_object v5obj, cl_object v6stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2027print_object(v5obj, v6stream);
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2023call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[10]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
#include "clos/builtin.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclENZkQW83YBXs9_bS40M881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:CLOS;BUILTIN.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclENZkQW83YBXs9_bS40M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2012make_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCE",953), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  si_Xmake_constant(ECL_SYM("+BUILTIN-CLASSES+",1548), ecl_cmp_symbol_value(cl_env_copy,VV[2]));
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2013ensure_class_using_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ENSURE-CLASS-USING-CLASS",1583), ECL_NIL, VVtemp[4], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2014change_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("CHANGE-CLASS",936), ECL_NIL, VVtemp[6], VVtemp[7], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2015make_instances_obsolete_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCES-OBSOLETE",954), ECL_NIL, VVtemp[8], VVtemp[9], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2016make_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCE",953), ECL_NIL, VVtemp[8], VVtemp[10], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2017slot_makunbound_using_class_va,ECL_NIL,Cblock,3);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SLOT-MAKUNBOUND-USING-CLASS",1628), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2018slot_boundp_using_class_va,ECL_NIL,Cblock,3);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SLOT-BOUNDP-USING-CLASS",1617), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2019slot_value_using_class_va,ECL_NIL,Cblock,3);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SLOT-VALUE-USING-CLASS",1629), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2020slot_value_using_class_va,ECL_NIL,Cblock,4);
   T0 = v1;
  }
  clos_install_method(5, VVtemp[13], ECL_NIL, VVtemp[14], VVtemp[15], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2021slot_exists_p_using_class_va,ECL_NIL,Cblock,3);
   T0 = v1;
  }
  clos_install_method(5, VV[8], ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2022allocate_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ALLOCATE-INSTANCE",931), ECL_NIL, VVtemp[16], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2025finalize_inheritance_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("FINALIZE-INHERITANCE",1589), ECL_NIL, VVtemp[16], VVtemp[9], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2026make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[17], VVtemp[18], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2027print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[19], VVtemp[20], T0);
 }
}
