/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/standard.lsp                   */
#include <ecl/ecl-cmp.h>
#include "clos/standard.eclh"
/* local function INITIALIZE-INSTANCE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1955initialize_instance(cl_narg narg, cl_object v1instance, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("INITIALIZE-INSTANCE",951));
 {
  cl_object v2initargs;
  ecl_va_list args; ecl_va_start(args,v1instance,narg,1);
  v2initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
  value0 = cl_apply(4, T0, v1instance, ECL_T, v2initargs);
  return value0;
 }
}
/* local function REINITIALIZE-INSTANCE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1956reinitialize_instance(cl_narg narg, cl_object v1instance, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 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("REINITIALIZE-INSTANCE",967));
 {
  cl_object v2initargs;
  ecl_va_list args; ecl_va_start(args,v1instance,narg,1);
  v2initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = cl_class_of(v1instance);
  T1 = (ECL_SYM("REINITIALIZE-INSTANCE",967)->symbol.gfdef);
  T2 = ecl_list1(v1instance);
  T3 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T1, T2) /*  COMPUTE-APPLICABLE-METHODS */;
  T4 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
  T5 = cl_list(2, v1instance, ECL_T);
  T6 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T4, T5) /*  COMPUTE-APPLICABLE-METHODS */;
  T7 = L2009valid_keywords_from_methods(2, T3, T6);
  L2010check_initargs(3, T0, v2initargs, T7);
  T0 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
  value0 = cl_apply(4, T0, v1instance, ECL_NIL, v2initargs);
  return value0;
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1957shared_initialize(cl_narg narg, cl_object v1instance, cl_object v2slot_names, ...)
{
 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("SHARED-INITIALIZE",969));
 {
  cl_object v3initargs;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  v3initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v4class;
   v4class = cl_class_of(v1instance);
   {
    cl_object v5;
    v5 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v4class) /*  CLASS-SLOTS */;
    goto L6;
L5:;
    {
     cl_object v6slotd;
     v6slotd = ecl_car(v5);
     {
      cl_object v7slot_initargs;
      cl_object v8slot_name;
      v7slot_initargs = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef))->cfun.entry(1, v6slotd) /*  SLOT-DEFINITION-INITARGS */;
      v8slot_name = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v6slotd) /*  SLOT-DEFINITION-NAME */;
      {
       cl_object v9l;
       cl_object v10initarg;
       cl_object v11val;
       v9l = v3initargs;
       v10initarg = ECL_NIL;
       v11val = ECL_NIL;
       goto L21;
L20:;
       {
        cl_object v12;
        v12 = v9l;
        {
         cl_object v13;
         v13 = v12;
         {
          bool v14;
          v14 = ECL_LISTP(v13);
          if (ecl_unlikely(!(v14)))
         FEwrong_type_argument(VV[5],v13);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
         }
        }
        if (Null(v12)){
         goto L29;
        }
        {
         cl_object v13;
         v13 = ECL_CONS_CDR(v12);
         v9l = v13;
         v12 = ECL_CONS_CAR(v12);
        }
L29:;
        v10initarg = v12;
       }
       if (!(ecl_endp(v9l))){
        goto L35;
       }
       si_simple_program_error(2, VV[6], v3initargs);
L35:;
       if (ECL_SYMBOLP(v10initarg)) {
        goto L37;
       }
       si_simple_program_error(2, VV[7], v10initarg);
L37:;
       {
        cl_object v12;
        v12 = v9l;
        {
         cl_object v13;
         v13 = v12;
         {
          bool v14;
          v14 = ECL_LISTP(v13);
          if (ecl_unlikely(!(v14)))
         FEwrong_type_argument(VV[5],v13);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
         }
        }
        if (Null(v12)){
         goto L45;
        }
        {
         cl_object v13;
         v13 = ECL_CONS_CDR(v12);
         v9l = v13;
         v12 = ECL_CONS_CAR(v12);
        }
L45:;
        v11val = v12;
       }
       {
        cl_object v12;
        cl_object v13;
        cl_object v14;
        v12 = (ECL_SYM("EQ",335)->symbol.gfdef);
        v13 = v10initarg;
        v14 = v7slot_initargs;
        if (Null(si_memq(v13,v14))){
         goto L51;
        }
       }
       (cl_env_copy->function=ECL_CONS_CAR(VV[138]))->cfun.entry(3, v11val, v1instance, v8slot_name) /*  (SETF SLOT-VALUE) */;
       value0 = ECL_T;
       goto L15;
L51:;
L21:;
       if (v9l==ECL_NIL) {
        goto L57;
       }
       goto L20;
L57:;
       value0 = ECL_NIL;
      }
L15:;
      if (value0!=ECL_NIL) {
       goto L14;
      }
      if (Null(v2slot_names)){
       goto L10;
      }
      if ((v2slot_names)==(ECL_T)) {
       goto L62;
      }
      {
       cl_object v9;
       cl_object v10;
       v9 = v8slot_name;
       v10 = v2slot_names;
       if (Null(ecl_memql(v9,v10))){
        goto L10;
       }
       goto L61;
      }
L62:;
L61:;
      if (cl_slot_boundp(v1instance, v8slot_name)!=ECL_NIL) {
       goto L10;
      }
      {
       cl_object v9initfun;
       v9initfun = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFUNCTION",1622)->symbol.gfdef))->cfun.entry(1, v6slotd) /*  SLOT-DEFINITION-INITFUNCTION */;
       if (Null(v9initfun)){
        goto L10;
       }
       {
        cl_object v10;
        v10 = ecl_function_dispatch(cl_env_copy,v9initfun)(0);
        (cl_env_copy->function=ECL_CONS_CAR(VV[138]))->cfun.entry(3, v10, v1instance, v8slot_name) /*  (SETF SLOT-VALUE) */;
        goto L10;
       }
      }
L14:;
      goto L10;
     }
L10:;
    }
    v5 = ecl_cdr(v5);
L6:;
    if (Null(v5)){
     goto L71;
    }
    goto L5;
L71:;
   }
  }
  value0 = v1instance;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for COMPUTE-INSTANCE-SIZE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1958compute_instance_size(cl_object v1slots)
{
 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:;
 {
  cl_object v2;
  cl_object v3slotd;
  cl_object v4;
  {
   cl_object v5;
   v5 = v1slots;
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v5;
  }
  v3slotd = ECL_NIL;
  v4 = v2;
  {
   cl_object v5last_location;
   v5last_location = ecl_make_int8_t(-1);
   {
    cl_object v6num_slots;
    v6num_slots = ecl_make_int8_t(0);
L9:;
    if (!(ecl_endp(v4))){
     goto L11;
    }
    goto L10;
L11:;
    v3slotd = ECL_CONS_CAR(v4);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v4);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v3slotd) /*  SLOT-DEFINITION-ALLOCATION */;
    if (!((T0)==(ECL_SYM("INSTANCE",1291)))){
     goto L19;
    }
    {
     cl_object v7new_loc;
     v7new_loc = L1992safe_slot_definition_location(1, v3slotd);
     v6num_slots = ecl_plus(v6num_slots,ecl_make_int8_t(1));
     if (Null(v7new_loc)){
      goto L19;
     }
     if (!(ecl_greater(v7new_loc,v5last_location))){
      goto L19;
     }
     v5last_location = v7new_loc;
    }
L19:;
    goto L9;
L10:;
    T0 = ecl_one_plus(v5last_location);
    value0 = ((ecl_float_nan_p(T0) || ecl_greatereq(v6num_slots,T0))?v6num_slots:T0);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L1958compute_instance_size_va(cl_narg narg, cl_object v7slots, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[9]);
 {
  return L1958compute_instance_size(v7slots);
 }
}
/* local function ALLOCATE-INSTANCE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1959allocate_instance(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("ALLOCATE-INSTANCE",931));
 {
  va_list args; va_start(args,v1class);
  va_end(args);
  goto L3;
L2:;
  si_assert_failure(1, VV[14]);
L3:;
  if ((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */!=ECL_NIL) {
   goto L6;
  }
  goto L2;
L6:;
  {
   cl_object v2x;
   T0 = (cl_env_copy->function=(VV[15]->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SIZE */;
   v2x = si_allocate_raw_instance(ECL_NIL, v1class, T0);
   si_instance_sig_set(v2x);
   value0 = v2x;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function MAKE-INSTANCE                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1960make_instance(cl_narg narg, 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);
 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,narg,1);
  v2initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  if ((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */!=ECL_NIL) {
   goto L1;
  }
  (cl_env_copy->function=(ECL_SYM("FINALIZE-INHERITANCE",1589)->symbol.gfdef))->cfun.entry(1, v1class) /*  FINALIZE-INHERITANCE */;
L1:;
  v2initargs = L1962add_default_initargs(v1class, v2initargs);
  {
   cl_object v3keywords;
   if (Null(cl_slot_boundp(v1class, VV[17]))){
    goto L7;
   }
   v3keywords = (cl_env_copy->function=(VV[18]->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-VALID-INITARGS */;
   goto L6;
L7:;
   v3keywords = L1973precompute_valid_initarg_keywords(v1class);
L6:;
   T0 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
   L2010check_initargs(5, v1class, v2initargs, ECL_NIL, T0, v3keywords);
  }
  {
   cl_object v3instance;
   T0 = (ECL_SYM("ALLOCATE-INSTANCE",931)->symbol.gfdef);
   v3instance = cl_apply(3, T0, v1class, v2initargs);
   T0 = (ECL_SYM("INITIALIZE-INSTANCE",951)->symbol.gfdef);
   cl_apply(3, T0, v3instance, v2initargs);
   value0 = v3instance;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for DELETE-KEYWORD                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1961delete_keyword(cl_object v1keyword, cl_object v2list)
{
 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:;
L3:;
 T0 = cl_getf(3, v2list, v1keyword, v2list);
 if (!((T0)==(v2list))){
  goto L5;
 }
 goto L4;
L5:;
 {
  cl_object v3;
  cl_object v4;                                   /*  FLAG                    */
  value0 = si_rem_f(v2list, v1keyword);
  {
   v3 = value0;
   v4 = cl_env_copy->values[1];
  }
  v2list = v3;
 }
 goto L3;
L4:;
 value0 = v2list;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1961delete_keyword_va(cl_narg narg, cl_object v3keyword, cl_object v4list, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[20]);
 {
  return L1961delete_keyword(v3keyword, v4list);
 }
}
/* function definition for ADD-DEFAULT-INITARGS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1962add_default_initargs(cl_object v1class, cl_object v2initargs)
{
 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:;
 {
  cl_object v3output;
  v3output = ECL_NIL;
  {
   cl_object v4;
   v4 = (cl_env_copy->function=(ECL_SYM("CLASS-DEFAULT-INITARGS",1562)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DEFAULT-INITARGS */;
   goto L7;
L6:;
   {
    cl_object v5scan;
    v5scan = ecl_car(v4);
    {
     cl_object v6initarg;
     cl_object v7value;
     cl_object v8supplied_value;
     v6initarg = ecl_car(v5scan);
     v7value = ecl_caddr(v5scan);
     v8supplied_value = si_search_keyword(v2initargs, v6initarg);
     if ((v8supplied_value)==(VV[23])) {
      goto L16;
     }
     if (!((v8supplied_value)==(ECL_SYM("MISSING-KEYWORD",2044)))){
      goto L11;
     }
     goto L15;
L16:;
L15:;
     if (!((v8supplied_value)==(VV[23]))){
      goto L18;
     }
     v2initargs = L1961delete_keyword(v6initarg, v2initargs);
L18:;
     T0 = ecl_function_dispatch(cl_env_copy,v7value)(0);
     v3output = cl_listX(3, T0, v6initarg, v3output);
    }
L11:;
   }
   v4 = ecl_cdr(v4);
L7:;
   if (Null(v4)){
    goto L25;
   }
   goto L6;
L25:;
  }
  if (Null(v3output)){
   goto L27;
  }
  T0 = cl_nreverse(v3output);
  value0 = ecl_append(v2initargs,T0);
  cl_env_copy->nvalues = 1;
  return value0;
L27:;
  value0 = v2initargs;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function DIRECT-SLOT-DEFINITION-CLASS                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1963direct_slot_definition_class(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("DIRECT-SLOT-DEFINITION-CLASS",1579));
 {
  va_list args; va_start(args,v1class);
  va_end(args);
  value0 = cl_find_class(2, ECL_SYM("STANDARD-DIRECT-SLOT-DEFINITION",1636), ECL_NIL);
  return value0;
 }
}
/* local function EFFECTIVE-SLOT-DEFINITION-CLASS                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1964effective_slot_definition_class(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("EFFECTIVE-SLOT-DEFINITION-CLASS",1581));
 {
  va_list args; va_start(args,v1class);
  va_end(args);
  value0 = cl_find_class(2, ECL_SYM("STANDARD-EFFECTIVE-SLOT-DEFINITION",1637), ECL_NIL);
  return value0;
 }
}
/* function definition for HAS-FORWARD-REFERENCED-PARENTS                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1965has_forward_referenced_parents(cl_object v1class)
{
 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);
L1:;
 value0 = L1983forward_referenced_class_p(v1class);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 if ((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */!=ECL_NIL) {
  goto L6;
 }
 T0 = (VV[24]->symbol.gfdef);
 T1 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUPERCLASSES",1566)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SUPERCLASSES */;
 value0 = cl_some(2, T0, T1);
 return value0;
L6:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1965has_forward_referenced_parents_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[24]);
 {
  return L1965has_forward_referenced_parents(v2class);
 }
}
/* function definition for FINALIZE-UNLESS-FORWARD                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1966finalize_unless_forward(cl_object v1class)
{
 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);
L1:;
 if (L1983forward_referenced_class_p(v1class)!=ECL_NIL) {
  goto L2;
 }
 T0 = (VV[24]->symbol.gfdef);
 T1 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUPERCLASSES",1566)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SUPERCLASSES */;
 if (cl_find_if(2, T0, T1)!=ECL_NIL) {
  goto L2;
 }
 value0 = (cl_env_copy->function=(ECL_SYM("FINALIZE-INHERITANCE",1589)->symbol.gfdef))->cfun.entry(1, v1class) /*  FINALIZE-INHERITANCE */;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1966finalize_unless_forward_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[27]);
 {
  return L1966finalize_unless_forward(v2class);
 }
}
/* local function INITIALIZE-INSTANCE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1969initialize_instance(cl_narg narg, cl_object v1class, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 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("INITIALIZE-INSTANCE",951));
 {
  cl_object v2initargs;
  cl_object v3direct_slots;
  cl_object v4direct_superclasses;
  ecl_va_list args; ecl_va_start(args,v1class,narg,1);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,LC1969initialize_instancekeys,keyvars,(cl_object*)&v2initargs,TRUE);
   ecl_va_end(args);
   v3direct_slots = keyvars[0];
   v4direct_superclasses = keyvars[1];
  }
  {
   cl_object env1 = env0;
   if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
    goto L2;
   }
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
   goto L1;
L2:;
   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)));
L1:;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  .CLOSED-COMBINED-METHOD-ARGS. */
   CLV1 = env1 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)),env1); /*  .NEXT-METHODS. */
   {
    cl_object v5;
    v5 = ecl_make_cclosure_va((cl_objectfn)LC1967call_next_method,env1,Cblock,0);
    {
     cl_object v6;
     cl_object v7s;
     cl_object v8;
     {
      cl_object v9;
      v9 = v3direct_slots;
      if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v9;
     }
     v7s = ECL_NIL;
     v8 = v6;
     {
      cl_object v9;
      cl_object v10;
      v9 = ecl_list1(ECL_NIL);
      v10 = v9;
L14:;
      if (!(ecl_endp(v8))){
       goto L16;
      }
      goto L15;
L16:;
      v7s = ECL_CONS_CAR(v8);
      {
       cl_object v11;
       v11 = ECL_CONS_CDR(v8);
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      {
       cl_object v11;
       v11 = v10;
       if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v11;
      }
      T2 = (cl_env_copy->function=(VV[32]->symbol.gfdef))->cfun.entry(2, v1class, v7s) /*  CANONICAL-SLOT-TO-DIRECT-SLOT */;
      v10 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v10,T1);
      goto L14;
L15:;
      T0 = ecl_cdr(v9);
      goto L6;
     }
    }
L6:;
    cl_apply(7, v5, v1class, ECL_SYM("DIRECT-SLOTS",994), T0, ECL_SYM("DIRECT-SUPERCLASSES",995), v4direct_superclasses, v2initargs);
    L1966finalize_unless_forward(v1class);
    value0 = v1class;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1972shared_initialize(cl_narg narg, cl_object v1class, cl_object v2slot_names, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 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("SHARED-INITIALIZE",969));
 {
  cl_object v3initargs;
  cl_object v4direct_superclasses;
  cl_object v5direct_superclasses_p;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,LC1972shared_initializekeys,keyvars,(cl_object*)&v3initargs,TRUE);
   ecl_va_end(args);
   v4direct_superclasses = keyvars[0];
   v5direct_superclasses_p = keyvars[1];
  }
  {
   cl_object env1 = env0;
   if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
    goto L2;
   }
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
   goto L1;
L2:;
   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)));
L1:;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  .CLOSED-COMBINED-METHOD-ARGS. */
   CLV1 = env1 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)),env1); /*  .NEXT-METHODS. */
   {
    cl_object v6;
    v6 = ecl_make_cclosure_va((cl_objectfn)LC1970call_next_method,env1,Cblock,0);
    if (Null(v5direct_superclasses_p)){
     goto L5;
    }
    {
     cl_object v7class;
     cl_object v8direct_superclasses;
     if (Null(cl_slot_boundp(v1class, VV[34]))){
      goto L9;
     }
     T0 = cl_slot_value(v1class, VV[34]);
     goto L8;
L9:;
     T0 = ECL_NIL;
L8:;
     v7class = cl_apply(6, v6, v1class, v2slot_names, ECL_SYM("DIRECT-SUPERCLASSES",995), T0, v3initargs);
     v8direct_superclasses = L1981check_direct_superclasses(v7class, v4direct_superclasses);
     {
      cl_object v9;
      cl_object v10c;
      cl_object v11;
      {
       cl_object v12;
       v12 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUPERCLASSES",1566)->symbol.gfdef))->cfun.entry(1, v7class) /*  CLASS-DIRECT-SUPERCLASSES */;
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v9 = v12;
      }
      v10c = ECL_NIL;
      v11 = v9;
L18:;
      if (!(ecl_endp(v11))){
       goto L20;
      }
      goto L19;
L20:;
      v10c = ECL_CONS_CAR(v11);
      {
       cl_object v12;
       v12 = ECL_CONS_CDR(v11);
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v12;
      }
      {
       cl_object v12;
       cl_object v13;
       cl_object v14;
       v12 = (ECL_SYM("EQ",335)->symbol.gfdef);
       v13 = v10c;
       v14 = v8direct_superclasses;
       if (si_memq(v13,v14)!=ECL_NIL) {
        goto L28;
       }
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-DIRECT-SUBCLASS",1615)->symbol.gfdef))->cfun.entry(2, v10c, v7class) /*  REMOVE-DIRECT-SUBCLASS */;
L28:;
      goto L18;
L19:;
     }
     (cl_env_copy->function=ECL_CONS_CAR(VV[141]))->cfun.entry(2, v8direct_superclasses, v7class) /*  (SETF CLASS-DIRECT-SUPERCLASSES) */;
     {
      cl_object v9;
      cl_object v10c;
      cl_object v11;
      {
       cl_object v12;
       v12 = v8direct_superclasses;
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v9 = v12;
      }
      v10c = ECL_NIL;
      v11 = v9;
L41:;
      if (!(ecl_endp(v11))){
       goto L43;
      }
      goto L42;
L43:;
      v10c = ECL_CONS_CAR(v11);
      {
       cl_object v12;
       v12 = ECL_CONS_CDR(v11);
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v12;
      }
      (cl_env_copy->function=(ECL_SYM("ADD-DIRECT-SUBCLASS",1561)->symbol.gfdef))->cfun.entry(2, v10c, v7class) /*  ADD-DIRECT-SUBCLASS */;
      goto L41;
L42:;
     }
     value0 = v7class;
     cl_env_copy->nvalues = 1;
     return value0;
    }
L5:;
    value0 = cl_apply(4, v6, v1class, v2slot_names, v3initargs);
    return value0;
   }
  }
 }
}
/* function definition for PRECOMPUTE-VALID-INITARG-KEYWORDS                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1973precompute_valid_initarg_keywords(cl_object v1class)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 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 v2;
  {
   cl_object v3methods;
   T0 = (ECL_SYM("ALLOCATE-INSTANCE",931)->symbol.gfdef);
   T1 = ecl_list1(v1class);
   T2 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T0, T1) /*  COMPUTE-APPLICABLE-METHODS */;
   T3 = (ECL_SYM("INITIALIZE-INSTANCE",951)->symbol.gfdef);
   T4 = (cl_env_copy->function=(ECL_SYM("CLASS-PROTOTYPE",1569)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-PROTOTYPE */;
   T5 = ecl_list1(T4);
   T6 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T3, T5) /*  COMPUTE-APPLICABLE-METHODS */;
   T7 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
   T8 = (cl_env_copy->function=(ECL_SYM("CLASS-PROTOTYPE",1569)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-PROTOTYPE */;
   T9 = cl_list(2, T8, ECL_T);
   T10 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T7, T9) /*  COMPUTE-APPLICABLE-METHODS */;
   v3methods = cl_nconc(3, T2, T6, T10);
   {
    cl_object v4;
    cl_object v5m;
    cl_object v6;
    {
     cl_object v7;
     v7 = v3methods;
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    v5m = ECL_NIL;
    v6 = v4;
    {
     cl_object v7k;
     v7k = ECL_NIL;
     {
      cl_object v8;
      cl_object v9;
      v8 = ecl_list1(ECL_NIL);
      v9 = v8;
L15:;
      if (!(ecl_endp(v6))){
       goto L17;
      }
      goto L16;
L17:;
      v5m = ECL_CONS_CAR(v6);
      {
       cl_object v10;
       v10 = ECL_CONS_CDR(v6);
       if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v6 = v10;
      }
      v7k = (cl_env_copy->function=(VV[37]->symbol.gfdef))->cfun.entry(1, v5m) /*  METHOD-KEYWORDS */;
      if (!((v7k)==(ECL_T))){
       goto L27;
      }
      v2 = ECL_T;
      goto L2;
L27:;
      {
       cl_object v10;
       v10 = cl_copy_list(v7k);
       {
        cl_object v11;
        v11 = v9;
        if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v11;
       }
       (ECL_CONS_CDR(T0)=v10,T0);
       if (Null(v10)){
        goto L29;
       }
      }
      T0 = ecl_cdr(v9);
      v9 = ecl_last(T0,1);
L29:;
      goto L15;
L16:;
      v2 = ecl_cdr(v8);
      goto L2;
     }
    }
   }
  }
L2:;
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[142]))->cfun.entry(2, v2, v1class) /*  (SETF CLASS-VALID-INITARGS) */;
  return value0;
 }
}
static cl_object L1973precompute_valid_initarg_keywords_va(cl_narg narg, cl_object v3class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[19]);
 {
  return L1973precompute_valid_initarg_keywords(v3class);
 }
}
/* function definition for UPDATE-DEPENDENTS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1975update_dependents(cl_object v1object, cl_object v2initargs)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1object,env0);               /*  OBJECT                  */
 CLV1 = env0 = CONS(v2initargs,env0);             /*  INITARGS                */
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[41]))){
  goto L1;
 }
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC1974__lambda164,env0,Cblock,1);
  T0 = v3;
 }
 value0 = (cl_env_copy->function=(ECL_SYM("MAP-DEPENDENTS",1605)->symbol.gfdef))->cfun.entry(2, ECL_CONS_CAR(CLV0), T0) /*  MAP-DEPENDENTS */;
 return value0;
L1:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1975update_dependents_va(cl_narg narg, cl_object v3object, cl_object v4initargs, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[40]);
 {
  return L1975update_dependents(v3object, v4initargs);
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1978shared_initialize(cl_narg narg, cl_object v1class, cl_object v2slot_names, ...)
{
 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);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SHARED-INITIALIZE",969));
 {
  cl_object v3initargs;
  cl_object v4optimize_slot_access;
  cl_object v5sealedp;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,LC1978shared_initializekeys,keyvars,(cl_object*)&v3initargs,TRUE);
   ecl_va_end(args);
   if (Null(keyvars[2])) {
    v4optimize_slot_access = ecl_list1(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*OPTIMIZE-SLOT-ACCESS*",1550)));
   } else {
    v4optimize_slot_access = keyvars[0];
   }
   v5sealedp = keyvars[1];
  }
  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. */
  {
   cl_object v6;
   v6 = ecl_car(v4optimize_slot_access);
   (cl_env_copy->function=ECL_CONS_CAR(VV[138]))->cfun.entry(3, v6, v1class, VV[44]) /*  (SETF SLOT-VALUE) */;
  }
  {
   cl_object v6;
   if (Null(v5sealedp)){
    goto L11;
   }
   v6 = ECL_T;
   goto L9;
L11:;
   v6 = ECL_NIL;
   goto L9;
L9:;
   (cl_env_copy->function=ECL_CONS_CAR(VV[138]))->cfun.entry(3, v6, v1class, VV[45]) /*  (SETF SLOT-VALUE) */;
  }
  v1class = LC1976call_next_method(0, lex0);
  L1975update_dependents(v1class, v3initargs);
  value0 = v1class;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function ADD-DIRECT-SUBCLASS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1979add_direct_subclass(cl_object v1parent, cl_object v2child)
{
 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:;
 {
  cl_object v3;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v1parent) /*  CLASS-DIRECT-SUBCLASSES */;
  v3 = cl_adjoin(2, v2child, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[145]))->cfun.entry(2, v3, v1parent) /*  (SETF CLASS-DIRECT-SUBCLASSES) */;
  return value0;
 }
}
static cl_object LC1979add_direct_subclass_va(cl_narg narg, cl_object v4parent, cl_object v5child, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("ADD-DIRECT-SUBCLASS",1561));
 {
  return LC1979add_direct_subclass(v4parent, v5child);
 }
}
/* local function REMOVE-DIRECT-SUBCLASS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1980remove_direct_subclass(cl_object v1parent, cl_object v2child)
{
 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:;
 {
  cl_object v3;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v1parent) /*  CLASS-DIRECT-SUBCLASSES */;
  v3 = cl_remove(2, v2child, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[145]))->cfun.entry(2, v3, v1parent) /*  (SETF CLASS-DIRECT-SUBCLASSES) */;
  return value0;
 }
}
static cl_object LC1980remove_direct_subclass_va(cl_narg narg, cl_object v4parent, cl_object v5child, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("REMOVE-DIRECT-SUBCLASS",1615));
 {
  return LC1980remove_direct_subclass(v4parent, v5child);
 }
}
/* function definition for CHECK-DIRECT-SUPERCLASSES                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1981check_direct_superclasses(cl_object v1class, cl_object v2supplied_superclasses)
{
 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:;
 if (v2supplied_superclasses!=ECL_NIL) {
  goto L2;
 }
 if (Null(si_of_class_p(2, v1class, ECL_SYM("STANDARD-CLASS",977)))){
  goto L5;
 }
 T0 = cl_find_class(1, ECL_SYM("STANDARD-OBJECT",980));
 v2supplied_superclasses = ecl_list1(T0);
 goto L4;
L5:;
 if (Null(si_of_class_p(2, v1class, ECL_SYM("STRUCTURE-CLASS",981)))){
  goto L7;
 }
 T0 = cl_find_class(1, ECL_SYM("STRUCTURE-OBJECT",982));
 v2supplied_superclasses = ecl_list1(T0);
 goto L4;
L7:;
 if (Null(si_of_class_p(2, v1class, ECL_SYM("FUNCALLABLE-STANDARD-CLASS",1592)))){
  goto L9;
 }
 T0 = cl_find_class(1, ECL_SYM("FUNCALLABLE-STANDARD-OBJECT",1594));
 v2supplied_superclasses = ecl_list1(T0);
 goto L4;
L9:;
 if (Null(si_of_class_p(2, v1class, ECL_SYM("FORWARD-REFERENCED-CLASS",1591)))){
  goto L11;
 }
 v2supplied_superclasses = ECL_NIL;
 goto L4;
L11:;
 T0 = cl_class_of(v1class);
 v2supplied_superclasses = cl_error(2, VV[47], T0);
L4:;
L2:;
 if (!((ecl_cmp_symbol_value(cl_env_copy,VV[41]))==(ECL_T))){
  goto L13;
 }
 {
  cl_object v3;
  cl_object v4superclass;
  cl_object v5;
  {
   cl_object v6;
   v6 = v2supplied_superclasses;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4superclass = ECL_NIL;
  v5 = v3;
L20:;
  if (!(ecl_endp(v5))){
   goto L22;
  }
  goto L21;
L22:;
  v4superclass = ECL_CONS_CAR(v5);
  {
   cl_object v6;
   v6 = ECL_CONS_CDR(v5);
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v5 = v6;
  }
  if ((cl_env_copy->function=(ECL_SYM("VALIDATE-SUPERCLASS",1651)->symbol.gfdef))->cfun.entry(2, v1class, v4superclass) /*  VALIDATE-SUPERCLASS */!=ECL_NIL) {
   goto L30;
  }
  cl_error(3, VV[48], v4superclass, v1class);
L30:;
  goto L20;
L21:;
 }
L13:;
 value0 = v2supplied_superclasses;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1981check_direct_superclasses_va(cl_narg narg, cl_object v3class, cl_object v4supplied_superclasses, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[35]);
 {
  return L1981check_direct_superclasses(v3class, v4supplied_superclasses);
 }
}
/* local function VALIDATE-SUPERCLASS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1982validate_superclass(cl_object v1class, cl_object v2superclass)
{
 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_make_bool((v2superclass)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+THE-T-CLASS+",1553))));
 if (value0!=ECL_NIL) {
  goto L3;
 }
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_class_of(v1class);
  v4 = cl_class_of(v2superclass);
  value0 = ecl_make_bool((v3)==(v4));
  if (value0!=ECL_NIL) {
   goto L9;
  }
  if (!((v3)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+THE-STANDARD-CLASS+",1556))))){
   goto L13;
  }
  value0 = ecl_make_bool((v4)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+THE-FUNCALLABLE-STANDARD-CLASS+",1557))));
  goto L11;
L13:;
  value0 = ECL_NIL;
  goto L11;
L11:;
  if (value0!=ECL_NIL) {
   goto L9;
  }
  if (!((v4)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+THE-STANDARD-CLASS+",1556))))){
   goto L16;
  }
  value0 = ecl_make_bool((v3)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+THE-FUNCALLABLE-STANDARD-CLASS+",1557))));
  goto L5;
L16:;
  value0 = ECL_NIL;
  goto L5;
L9:;
  goto L5;
 }
L5:;
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = L1983forward_referenced_class_p(v1class);
 if (value0!=ECL_NIL) {
  goto L19;
 }
 value0 = L1983forward_referenced_class_p(v2superclass);
 return value0;
L19:;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1982validate_superclass_va(cl_narg narg, cl_object v3class, cl_object v4superclass, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("VALIDATE-SUPERCLASS",1651));
 {
  return LC1982validate_superclass(v3class, v4superclass);
 }
}
/* function definition for FORWARD-REFERENCED-CLASS-P                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1983forward_referenced_class_p(cl_object v1x)
{
 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:;
 {
  cl_object v2y;
  v2y = cl_find_class(2, ECL_SYM("FORWARD-REFERENCED-CLASS",1591), ECL_NIL);
  if (Null(v2y)){
   goto L4;
  }
  T0 = cl_class_of(v1x);
  value0 = si_subclassp(2, T0, v2y);
  return value0;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L1983forward_referenced_class_p_va(cl_narg narg, cl_object v3x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[25]);
 {
  return L1983forward_referenced_class_p(v3x);
 }
}
/* local function FINALIZE-INHERITANCE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1984finalize_inheritance(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);
L1:;
 {
  cl_object v2cpl;
  v2cpl = (cl_env_copy->function=(ECL_SYM("COMPUTE-CLASS-PRECEDENCE-LIST",1572)->symbol.gfdef))->cfun.entry(1, v1class) /*  COMPUTE-CLASS-PRECEDENCE-LIST */;
  {
   cl_object v3x;
   T0 = (VV[25]->symbol.gfdef);
   T1 = ecl_cdr(v2cpl);
   v3x = cl_find_if(2, T0, T1);
   if (Null(v3x)){
    goto L4;
   }
   T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-NAME */;
   T1 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v3x) /*  CLASS-NAME */;
   cl_error(3, VV[51], T0, T1);
  }
L4:;
  {
   cl_object v3x;
   T0 = (ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef);
   v3x = cl_find_if_not(4, T0, v2cpl, VV[52], ECL_T);
   if (Null(v3x)){
    goto L8;
   }
   if ((v3x)==(v1class)) {
    goto L8;
   }
   value0 = (cl_env_copy->function=(ECL_SYM("FINALIZE-INHERITANCE",1589)->symbol.gfdef))->cfun.entry(1, v3x) /*  FINALIZE-INHERITANCE */;
   return value0;
  }
L8:;
  (cl_env_copy->function=ECL_CONS_CAR(VV[146]))->cfun.entry(2, v2cpl, v1class) /*  (SETF CLASS-PRECEDENCE-LIST) */;
  {
   cl_object v3oslotds_p;
   cl_object v4oslotds;
   cl_object v5nslotds;
   v3oslotds_p = cl_slot_boundp(v1class, VV[54]);
   if (Null(v3oslotds_p)){
    goto L18;
   }
   v4oslotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
   goto L16;
L18:;
   v4oslotds = ECL_NIL;
   goto L16;
L16:;
   v5nslotds = (cl_env_copy->function=(ECL_SYM("COMPUTE-SLOTS",1577)->symbol.gfdef))->cfun.entry(1, v1class) /*  COMPUTE-SLOTS */;
   (cl_env_copy->function=ECL_CONS_CAR(VV[147]))->cfun.entry(2, v5nslotds, v1class) /*  (SETF CLASS-SLOTS) */;
   {
    cl_object v6;
    v6 = L1958compute_instance_size(v5nslotds);
    (cl_env_copy->function=ECL_CONS_CAR(VV[148]))->cfun.entry(2, v6, v1class) /*  (SETF CLASS-SIZE) */;
   }
   {
    cl_object v6;
    v6 = (cl_env_copy->function=(ECL_SYM("COMPUTE-DEFAULT-INITARGS",1573)->symbol.gfdef))->cfun.entry(1, v1class) /*  COMPUTE-DEFAULT-INITARGS */;
    (cl_env_copy->function=ECL_CONS_CAR(VV[149]))->cfun.entry(2, v6, v1class) /*  (SETF CLASS-DEFAULT-INITARGS) */;
   }
   (cl_env_copy->function=ECL_CONS_CAR(VV[150]))->cfun.entry(2, ECL_T, v1class) /*  (SETF CLASS-FINALIZED-P) */;
   if (Null((cl_env_copy->function=(VV[59]->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SEALEDP */)){
    goto L27;
   }
   {
    cl_object v6free_slots;
    cl_object v7all_slots;
    {
     cl_object v8;
     v8 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
     {
      cl_object v9;
      cl_object v10;
      cl_object v11;
      {
       cl_object v12;
       v12 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v9 = v12;
      }
      v10 = ECL_NIL;
      v11 = v9;
      {
       cl_object v12;
       cl_object v13;
       v12 = ecl_list1(ECL_NIL);
       v13 = v12;
L39:;
       if (!(ecl_endp(v11))){
        goto L41;
       }
       goto L40;
L41:;
       v10 = ECL_CONS_CAR(v11);
       {
        cl_object v14;
        v14 = ECL_CONS_CDR(v11);
        if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v11 = v14;
       }
       {
        cl_object v14;
        v14 = v13;
        if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T1 = v14;
       }
       T2 = ecl_function_dispatch(cl_env_copy,v8)(1, v10);
       v13 = ecl_list1(T2);
       (ECL_CONS_CDR(T1)=v13,T1);
       goto L39;
L40:;
       T0 = ecl_cdr(v12);
       goto L30;
      }
     }
    }
L30:;
    v6free_slots = cl_delete_duplicates(1, T0);
    v7all_slots = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
    {
     cl_object v8;
     cl_object v9c;
     cl_object v10;
     {
      cl_object v11;
      v11 = v2cpl;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9c = ECL_NIL;
     v10 = v8;
L64:;
     if (!(ecl_endp(v10))){
      goto L66;
     }
     goto L65;
L66:;
     v9c = ECL_CONS_CAR(v10);
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v10);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v11;
     }
     {
      cl_object v11;
      cl_object v12slotd;
      cl_object v13;
      {
       cl_object v14;
       v14 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SLOTS",1564)->symbol.gfdef))->cfun.entry(1, v9c) /*  CLASS-DIRECT-SLOTS */;
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      v12slotd = ECL_NIL;
      v13 = v11;
L80:;
      if (!(ecl_endp(v13))){
       goto L82;
      }
      goto L81;
L82:;
      v12slotd = ECL_CONS_CAR(v13);
      {
       cl_object v14;
       v14 = ECL_CONS_CDR(v13);
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v14;
      }
      if (Null(L1992safe_slot_definition_location(1, v12slotd))){
       goto L90;
      }
      T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v12slotd) /*  SLOT-DEFINITION-NAME */;
      v6free_slots = cl_delete(2, T0, v6free_slots);
L90:;
      goto L80;
L81:;
     }
     goto L64;
L65:;
    }
    {
     cl_object v8;
     cl_object v9slotd;
     cl_object v10;
     {
      cl_object v11;
      v11 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SLOTS",1564)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SLOTS */;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9slotd = ECL_NIL;
     v10 = v8;
L101:;
     if (!(ecl_endp(v10))){
      goto L103;
     }
     goto L102;
L103:;
     v9slotd = ECL_CONS_CAR(v10);
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v10);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v11;
     }
     {
      cl_object v11name;
      cl_object v12other_slotd;
      v11name = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v9slotd) /*  SLOT-DEFINITION-NAME */;
      {
       cl_object v13;
       v13 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
       {
        cl_object v14;
        v14 = si_make_seq_iterator(2, v7all_slots, ecl_make_int8_t(0));
L116:;
        if (v14!=ECL_NIL) {
         goto L118;
        }
        v12other_slotd = ECL_NIL;
        goto L113;
L118:;
        {
         cl_object v15;
         v15 = si_seq_iterator_ref(v7all_slots, v14);
         T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v15) /*  SLOT-DEFINITION-NAME */;
         if (!(ecl_eql(v11name,T0))){
          goto L120;
         }
         v12other_slotd = v15;
         goto L113;
        }
L120:;
        v14 = si_seq_iterator_next(v7all_slots, v14);
        goto L116;
       }
      }
L113:;
      {
       cl_object v13;
       v13 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v12other_slotd) /*  SLOT-DEFINITION-LOCATION */;
       (cl_env_copy->function=ECL_CONS_CAR(VV[151]))->cfun.entry(2, v13, v9slotd) /*  (SETF SLOT-DEFINITION-LOCATION) */;
      }
      v6free_slots = cl_delete(2, v11name, v6free_slots);
     }
     goto L101;
L102:;
    }
    {
     cl_object v8;
     cl_object v9name;
     cl_object v10;
     {
      cl_object v11;
      v11 = v6free_slots;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9name = ECL_NIL;
     v10 = v8;
     {
      cl_object v11direct_slots;
      v11direct_slots = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SLOTS",1564)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SLOTS */;
L135:;
      if (!(ecl_endp(v10))){
       goto L137;
      }
      goto L136;
L137:;
      v9name = ECL_CONS_CAR(v10);
      {
       cl_object v12;
       v12 = ECL_CONS_CDR(v10);
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v12;
      }
      {
       cl_object v12effective_slotd;
       cl_object v13def;
       {
        cl_object v14;
        v14 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
        {
         cl_object v15;
         v15 = si_make_seq_iterator(2, v7all_slots, ecl_make_int8_t(0));
L149:;
         if (v15!=ECL_NIL) {
          goto L151;
         }
         v12effective_slotd = ECL_NIL;
         goto L146;
L151:;
         {
          cl_object v16;
          v16 = si_seq_iterator_ref(v7all_slots, v15);
          T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v16) /*  SLOT-DEFINITION-NAME */;
          if (!(ecl_eql(v9name,T0))){
          goto L153;
          }
          v12effective_slotd = v16;
          goto L146;
         }
L153:;
         v15 = si_seq_iterator_next(v7all_slots, v15);
         goto L149;
        }
       }
L146:;
       v13def = (cl_env_copy->function=(VV[65]->symbol.gfdef))->cfun.entry(1, v12effective_slotd) /*  DIRECT-SLOT-TO-CANONICAL-SLOT */;
       T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
       T1 = (cl_env_copy->function=(ECL_SYM("DIRECT-SLOT-DEFINITION-CLASS",1579)->symbol.gfdef))->cfun.entry(2, v1class, v13def) /*  DIRECT-SLOT-DEFINITION-CLASS */;
       T2 = cl_apply(3, T0, T1, v13def);
       v11direct_slots = CONS(T2,v11direct_slots);
      }
      goto L135;
L136:;
      (cl_env_copy->function=ECL_CONS_CAR(VV[152]))->cfun.entry(2, v11direct_slots, v1class) /*  (SETF CLASS-DIRECT-SLOTS) */;
     }
    }
   }
L27:;
   if (!(v3oslotds_p==ECL_NIL)){
    goto L163;
   }
   si_instance_new_stamp(v1class);
   goto L14;
L163:;
   if ((cl_env_copy->function=(VV[67]->symbol.gfdef))->cfun.entry(2, v4oslotds, v5nslotds) /*  SLOT-DEFINITIONS-COMPATIBLE-P */!=ECL_NIL) {
    goto L14;
   }
   (cl_env_copy->function=(ECL_SYM("MAKE-INSTANCES-OBSOLETE",954)->symbol.gfdef))->cfun.entry(1, v1class) /*  MAKE-INSTANCES-OBSOLETE */;
  }
L14:;
  (cl_env_copy->function=(VV[68]->symbol.gfdef))->cfun.entry(0) /*  SUBTYPEP-CLEAR-CACHE */;
 }
 {
  cl_object v2;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SUBCLASSES */;
  v2 = cl_reverse(T0);
  goto L170;
L169:;
  {
   cl_object v3subclass;
   v3subclass = ecl_car(v2);
   L1966finalize_unless_forward(v3subclass);
  }
  v2 = ecl_cdr(v2);
L170:;
  if (Null(v2)){
   goto L177;
  }
  goto L169;
L177:;
 }
 value0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1class) /*  STD-CREATE-SLOTS-TABLE */;
 return value0;
}
static cl_object LC1984finalize_inheritance_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FINALIZE-INHERITANCE",1589));
 {
  return LC1984finalize_inheritance(v2class);
 }
}
/* local function FINALIZE-INHERITANCE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1987finalize_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. */
 LC1985call_next_method(0, lex0);
 value0 = (cl_env_copy->function=(VV[70]->symbol.gfdef))->cfun.entry(1, v1class) /*  STD-CLASS-GENERATE-ACCESSORS */;
 return value0;
}
static cl_object LC1987finalize_inheritance_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FINALIZE-INHERITANCE",1589));
 {
  return LC1987finalize_inheritance(v2class);
 }
}
/* local function FINALIZE-INHERITANCE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1988finalize_inheritance(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);
L1:;
 value0 = cl_error(2, VV[71], v1class);
 return value0;
}
static cl_object LC1988finalize_inheritance_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FINALIZE-INHERITANCE",1589));
 {
  return LC1988finalize_inheritance(v2class);
 }
}
/* local function COMPUTE-CLASS-PRECEDENCE-LIST                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1989compute_class_precedence_list(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_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUPERCLASSES",1566)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SUPERCLASSES */;
 value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, v1class, T0) /*  COMPUTE-CLOS-CLASS-PRECEDENCE-LIST */;
 return value0;
}
static cl_object LC1989compute_class_precedence_list_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("COMPUTE-CLASS-PRECEDENCE-LIST",1572));
 {
  return LC1989compute_class_precedence_list(v2class);
 }
}
/* local function COMPUTE-SLOTS                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1990compute_slots(cl_object v1class)
{
 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 v2all_slots;
  cl_object v3all_names;
  cl_object v4output;
  cl_object v5scan;
  T0 = (ECL_SYM("APPEND",90)->symbol.gfdef);
  {
   cl_object v6;
   v6 = (ECL_SYM("CLASS-DIRECT-SLOTS",1564)->symbol.gfdef);
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     T2 = (cl_env_copy->function=(ECL_SYM("CLASS-PRECEDENCE-LIST",1568)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-PRECEDENCE-LIST */;
     v10 = cl_reverse(T2);
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8 = ECL_NIL;
    v9 = v7;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L13:;
     if (!(ecl_endp(v9))){
      goto L15;
     }
     goto L14;
L15:;
     v8 = ECL_CONS_CAR(v9);
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     {
      cl_object v12;
      v12 = v11;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T2 = v12;
     }
     T3 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
     v11 = ecl_list1(T3);
     (ECL_CONS_CDR(T2)=v11,T2);
     goto L13;
L14:;
     T1 = ecl_cdr(v10);
     goto L4;
    }
   }
  }
L4:;
  v2all_slots = cl_reduce(2, T0, T1);
  {
   cl_object v6;
   v6 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     v10 = v2all_slots;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8 = ECL_NIL;
    v9 = v7;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L41:;
     if (!(ecl_endp(v9))){
      goto L43;
     }
     goto L42;
L43:;
     v8 = ECL_CONS_CAR(v9);
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     {
      cl_object v12;
      v12 = v11;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v12;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
     v11 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v11,T1);
     goto L41;
L42:;
     T0 = ecl_cdr(v10);
     goto L32;
    }
   }
  }
L32:;
  v3all_names = cl_nreverse(T0);
  v4output = ECL_NIL;
  v5scan = v3all_names;
  goto L63;
L62:;
  {
   cl_object v6name;
   v6name = ecl_car(v5scan);
   {
    cl_object v7;
    v7 = ecl_cdr(v5scan);
    {
     cl_object v8;
     v8 = si_make_seq_iterator(2, v7, ecl_make_int8_t(0));
L70:;
     if (v8!=ECL_NIL) {
      goto L72;
     }
     goto L67;
L72:;
     {
      cl_object v9;
      v9 = si_seq_iterator_ref(v7, v8);
      if (!(ecl_eql(v6name,v9))){
       goto L74;
      }
      if (v9!=ECL_NIL) {
       goto L65;
      }
      goto L67;
     }
L74:;
     v8 = si_seq_iterator_next(v7, v8);
     goto L70;
    }
   }
L67:;
   T0 = cl_reverse(v2all_slots);
   T1 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
   T2 = (ECL_SYM("EQ",335)->symbol.gfdef);
   T3 = cl_delete(6, v6name, T0, ECL_SYM("KEY",1297), T1, ECL_SYM("TEST-NOT",1354), T2);
   T4 = (cl_env_copy->function=(ECL_SYM("COMPUTE-EFFECTIVE-SLOT-DEFINITION",1576)->symbol.gfdef))->cfun.entry(3, v1class, v6name, T3) /*  COMPUTE-EFFECTIVE-SLOT-DEFINITION */;
   v4output = CONS(T4,v4output);
  }
L65:;
  v5scan = ecl_cdr(v5scan);
L63:;
  if (ecl_endp(v5scan)) {
   goto L84;
  }
  goto L62;
L84:;
  value0 = v4output;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC1990compute_slots_va(cl_narg narg, cl_object v6class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("COMPUTE-SLOTS",1577));
 {
  return LC1990compute_slots(v6class);
 }
}
/* function definition for SLOT-DEFINITION-TO-PLIST                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1991slot_definition_to_plist(cl_object v1slotd)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 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_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-NAME */;
 T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFORM",1621)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-INITFORM */;
 T2 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFUNCTION",1622)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-INITFUNCTION */;
 T3 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-TYPE",1626)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-TYPE */;
 T4 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-ALLOCATION */;
 T5 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-INITARGS */;
 T6 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-READERS",1625)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-READERS */;
 T7 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-WRITERS",1627)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-WRITERS */;
 T8 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-DOCUMENTATION */;
 T9 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-LOCATION */;
 value0 = cl_list(20, ECL_SYM("NAME",1309), T0, ECL_SYM("INITFORM",1000), T1, ECL_SYM("INITFUNCTION",1001), T2, ECL_SYM("TYPE",1356), T3, ECL_SYM("ALLOCATION",989), T4, ECL_SYM("INITARGS",999), T5, ECL_SYM("READERS",1011), T6, ECL_SYM("WRITERS",1014), T7, ECL_SYM("DOCUMENTATION",1253), T8, ECL_SYM("LOCATION",1003), T9);
 return value0;
}
static cl_object L1991slot_definition_to_plist_va(cl_narg narg, cl_object v2slotd, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[74]);
 {
  return L1991slot_definition_to_plist(v2slotd);
 }
}
/* function definition for SAFE-SLOT-DEFINITION-LOCATION                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1992safe_slot_definition_location(cl_narg narg, cl_object v1slotd, ...)
{
 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(VV[12]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[12]);
 {
  cl_object v2default;
  va_list args; va_start(args,v1slotd);
  {
   int i = 1;
   if (i >= narg) {
    v2default = ECL_NIL;
   } else {
    i++;
    v2default = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (ECL_LISTP(v1slotd)) {
   goto L4;
  }
  if (Null(cl_slot_boundp(v1slotd, ECL_SYM("LOCATION",1869)))){
   goto L2;
  }
  goto L3;
L4:;
L3:;
  value0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v1slotd) /*  SLOT-DEFINITION-LOCATION */;
  return value0;
L2:;
  value0 = v2default;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function COMPUTE-EFFECTIVE-SLOT-DEFINITION                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1995compute_effective_slot_definition(cl_object v1class, cl_object v2name, cl_object v3direct_slots)
{
 cl_object T0, T1, T2;
 volatile cl_object lex0[1];
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 lex0[0] = v1class;                               /*  CLASS                   */
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v2name,env0);                 /*  NAME                    */
 {
  cl_object v4;
  v4 = ecl_make_cclosure_va((cl_objectfn)LC1994combine_slotds,env0,Cblock,2);
  T0 = ecl_cdr(v3direct_slots);
  T2 = ecl_car(v3direct_slots);
  T1 = LC1993direct_to_effective(lex0, T2);
  value0 = cl_reduce(4, v4, T0, VV[87], T1);
  return value0;
 }
}
static cl_object LC1995compute_effective_slot_definition_va(cl_narg narg, cl_object v5class, cl_object v6name, cl_object v7direct_slots, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(ECL_SYM("COMPUTE-EFFECTIVE-SLOT-DEFINITION",1576));
 {
  return LC1995compute_effective_slot_definition(v5class, v6name, v7direct_slots);
 }
}
/* local function COMPUTE-DEFAULT-INITARGS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1996compute_default_initargs(cl_object v1class)
{
 cl_object T0, T1, T2, T3;
 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 v2all_initargs;
  T0 = (ECL_SYM("APPEND",90)->symbol.gfdef);
  {
   cl_object v3;
   v3 = (ECL_SYM("CLASS-DIRECT-DEFAULT-INITARGS",1563)->symbol.gfdef);
   {
    cl_object v4;
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = (cl_env_copy->function=(ECL_SYM("CLASS-PRECEDENCE-LIST",1568)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-PRECEDENCE-LIST */;
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    v5 = ECL_NIL;
    v6 = v4;
    {
     cl_object v7;
     cl_object v8;
     v7 = ecl_list1(ECL_NIL);
     v8 = v7;
L13:;
     if (!(ecl_endp(v6))){
      goto L15;
     }
     goto L14;
L15:;
     v5 = ECL_CONS_CAR(v6);
     {
      cl_object v9;
      v9 = ECL_CONS_CDR(v6);
      if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v9;
     }
     {
      cl_object v9;
      v9 = v8;
      if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T2 = v9;
     }
     T3 = ecl_function_dispatch(cl_env_copy,v3)(1, v5);
     v8 = ecl_list1(T3);
     (ECL_CONS_CDR(T2)=v8,T2);
     goto L13;
L14:;
     T1 = ecl_cdr(v7);
     goto L4;
    }
   }
  }
L4:;
  v2all_initargs = cl_reduce(2, T0, T1);
  T0 = cl_reverse(v2all_initargs);
  T1 = (ECL_SYM("FIRST",373)->symbol.gfdef);
  T2 = cl_remove_duplicates(3, T0, ECL_SYM("KEY",1297), T1);
  value0 = cl_nreverse(T2);
  return value0;
 }
}
static cl_object LC1996compute_default_initargs_va(cl_narg narg, cl_object v3class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("COMPUTE-DEFAULT-INITARGS",1573));
 {
  return LC1996compute_default_initargs(v3class);
 }
}
/* local function ENSURE-CLASS-USING-CLASS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1997ensure_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;
  cl_object v4direct_slots;
  cl_object v5direct_default_initargs;
  ecl_va_list args; ecl_va_start(args,v2name,narg,2);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,LC1997ensure_class_using_classkeys,keyvars,(cl_object*)&v3rest,TRUE);
   ecl_va_end(args);
   v4direct_slots = keyvars[0];
   v5direct_default_initargs = keyvars[1];
  }
  {
   cl_object v6;                                  /*  METACLASS               */
   cl_object v7;                                  /*  OPTIONS                 */
   T0 = (VV[88]->symbol.gfdef);
   value0 = cl_apply(2, T0, v3rest);
   {
    const int v8 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v9;
    v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v9;
   }
   if (Null(L1983forward_referenced_class_p(v1class))){
    goto L4;
   }
   (cl_env_copy->function=(ECL_SYM("CHANGE-CLASS",936)->symbol.gfdef))->cfun.entry(2, v1class, v6) /*  CHANGE-CLASS */;
   goto L3;
L4:;
   T0 = cl_class_of(v1class);
   if ((T0)==(v6)) {
    goto L3;
   }
   cl_error(1, VV[89]);
L3:;
   T0 = (ECL_SYM("REINITIALIZE-INSTANCE",967)->symbol.gfdef);
   v1class = cl_apply(5, T0, v1class, ECL_SYM("NAME",1309), v2name, v7);
   if (Null(v2name)){
    goto L10;
   }
   (cl_env_copy->function=(ECL_SYM("CREATE-TYPE-NAME",1661)->symbol.gfdef))->cfun.entry(1, v2name) /*  CREATE-TYPE-NAME */;
   (cl_env_copy->function=(VV[90]->symbol.gfdef))->cfun.entry(2, v1class, v2name) /*  SETF-FIND-CLASS */;
L10:;
   value0 = v1class;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for COERCE-TO-CLASS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1998coerce_to_class(cl_narg narg, cl_object v1class_or_symbol, ...)
{
 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(VV[91]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[91]);
 {
  cl_object v2fail;
  va_list args; va_start(args,v1class_or_symbol);
  {
   int i = 1;
   if (i >= narg) {
    v2fail = ECL_NIL;
   } else {
    i++;
    v2fail = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(ECL_INSTANCEP(v1class_or_symbol))){
   goto L2;
  }
  value0 = v1class_or_symbol;
  cl_env_copy->nvalues = 1;
  return value0;
L2:;
  if (ECL_SYMBOLP(v1class_or_symbol)) {
   goto L4;
  }
  value0 = cl_error(2, VV[92], v1class_or_symbol);
  return value0;
L4:;
  {
   cl_object v3;
   v3 = cl_find_class(2, v1class_or_symbol, v2fail);
   if (Null(v3)){
    goto L7;
   }
   value0 = v3;
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   T0 = ecl_list1(v1class_or_symbol);
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(5, VV[93], ECL_SYM("FORMAT-CONTROL",1272), VV[94], ECL_SYM("FORMAT-ARGUMENTS",1271), T0) /*  WARN */;
   T0 = cl_find_class(1, ECL_SYM("STANDARD-OBJECT",980));
   T1 = ecl_list1(T0);
   value0 = clos_ensure_class(7, v1class_or_symbol, ECL_SYM("METACLASS",1004), ECL_SYM("FORWARD-REFERENCED-CLASS",1591), ECL_SYM("DIRECT-SUPERCLASSES",995), T1, ECL_SYM("DIRECT-SLOTS",994), ECL_NIL);
   return value0;
  }
 }
}
/* function definition for HELP-ENSURE-CLASS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1999help_ensure_class(cl_narg narg, ...)
{
 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);
 {
  cl_object v1options;
  cl_object v2metaclass;
  cl_object v3direct_superclasses;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L1999help_ensure_classkeys,keyvars,(cl_object*)&v1options,TRUE);
   ecl_va_end(args);
   if (Null(keyvars[2])) {
    v2metaclass = ECL_SYM("STANDARD-CLASS",977);
   } else {
    v2metaclass = keyvars[0];
   }
   v3direct_superclasses = keyvars[1];
  }
  {
   cl_object v4;
   cl_object v5;                                  /*  FLAG                    */
   value0 = si_rem_f(v1options, ECL_SYM("METACLASS",1004));
   {
    v4 = value0;
    v5 = cl_env_copy->values[1];
   }
   v1options = v4;
  }
  {
   cl_object v4;
   cl_object v5;                                  /*  FLAG                    */
   value0 = si_rem_f(v1options, ECL_SYM("DIRECT-SUPERCLASSES",995));
   {
    v4 = value0;
    v5 = cl_env_copy->values[1];
   }
   v1options = v4;
  }
  v2metaclass = L1998coerce_to_class(2, v2metaclass, ECL_T);
  {
   cl_object v4;
   v4 = (VV[91]->symbol.gfdef);
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    {
     cl_object v8;
     v8 = v3direct_superclasses;
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6 = ECL_NIL;
    v7 = v5;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L22:;
     if (!(ecl_endp(v7))){
      goto L24;
     }
     goto L23;
L24:;
     v6 = ECL_CONS_CAR(v7);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v7);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v10;
     }
     T1 = ecl_function_dispatch(cl_env_copy,v4)(1, v6);
     v9 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v9,T0);
     goto L22;
L23:;
     v3direct_superclasses = ecl_cdr(v8);
     goto L13;
    }
   }
  }
L13:;
  T0 = cl_listX(3, ECL_SYM("DIRECT-SUPERCLASSES",995), v3direct_superclasses, v1options);
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = T0;
  cl_env_copy->values[1] = v3direct_superclasses;
  cl_env_copy->values[0] = v2metaclass;
  return cl_env_copy->values[0];
 }
}
/* function definition for CLASS-COMPUTE-SLOTS                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2000class_compute_slots(cl_object v1class, cl_object v2slots)
{
 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);
L1:;
 {
  cl_object v3size;
  cl_object v4instance_slots;
  cl_object v5numbered_slots;
  cl_object v6other_slots;
  cl_object v7aux;
  v3size = L1958compute_instance_size(v2slots);
  T0 = (ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef);
  T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
  v4instance_slots = cl_remove(6, ECL_SYM("INSTANCE",1291), v2slots, ECL_SYM("KEY",1297), T0, ECL_SYM("TEST-NOT",1354), T1);
  T0 = (VV[12]->symbol.gfdef);
  v5numbered_slots = cl_remove_if_not(2, T0, v4instance_slots);
  T0 = (VV[12]->symbol.gfdef);
  v6other_slots = cl_remove_if(2, T0, v4instance_slots);
  T0 = si_make_pure_array(ECL_T, v3size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  v7aux = si_fill_array_with_elt(T0, ECL_NIL, ecl_make_int8_t(0), ECL_NIL);
  {
   cl_object v8;
   cl_object v9i;
   cl_object v10;
   {
    cl_object v11;
    v11 = v5numbered_slots;
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9i = ECL_NIL;
   v10 = v8;
L17:;
   if (!(ecl_endp(v10))){
    goto L19;
   }
   goto L18;
L19:;
   v9i = ECL_CONS_CAR(v10);
   {
    cl_object v11;
    v11 = ECL_CONS_CDR(v10);
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v10 = v11;
   }
   {
    cl_object v11loc;
    v11loc = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v9i) /*  SLOT-DEFINITION-LOCATION */;
    {
     cl_object v12;
     v12 = v7aux;
     T0 = v12;
     {
      cl_object v13;
      v13 = v11loc;
      if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v13;
     }
     if (Null(ecl_aref_unsafe(T0,ecl_fixnum(T1)))){
      goto L29;
     }
    }
    {
     cl_object v12;
     v12 = v7aux;
     T1 = v12;
     {
      cl_object v13;
      v13 = v11loc;
      if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T2 = v13;
     }
     T0 = ecl_aref_unsafe(T1,ecl_fixnum(T2));
    }
    T1 = cl_list(3, T0, v9i, v1class);
    cl_error(5, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("FORMAT-CONTROL",1272), VV[100], VV[101], T1);
L29:;
    {
     cl_object v12;
     v12 = v7aux;
     T0 = v12;
     {
      cl_object v13;
      v13 = v11loc;
      if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v13;
     }
     ecl_aset_unsafe(T0,ecl_fixnum(T1),v9i);
    }
   }
   goto L17;
L18:;
  }
  {
   cl_object v8;
   cl_object v9i;
   cl_object v10;
   {
    cl_object v11;
    v11 = v6other_slots;
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9i = ECL_NIL;
   v10 = v8;
   {
    cl_object v11index;
    v11index = ecl_make_int8_t(0);
L58:;
    if (!(ecl_endp(v10))){
     goto L60;
    }
    goto L59;
L60:;
    v9i = ECL_CONS_CAR(v10);
    {
     cl_object v12;
     v12 = ECL_CONS_CDR(v10);
     if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v10 = v12;
    }
L69:;
    {
     cl_object v12;
     v12 = v7aux;
     T0 = v12;
     {
      cl_object v13;
      v13 = v11index;
      if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v13;
     }
     if (ecl_aref_unsafe(T0,ecl_fixnum(T1))!=ECL_NIL) {
      goto L71;
     }
    }
    goto L70;
L71:;
    v11index = ecl_plus(v11index,ecl_make_int8_t(1));
    goto L69;
L70:;
    {
     cl_object v12;
     v12 = v7aux;
     T0 = v12;
     {
      cl_object v13;
      v13 = v11index;
      if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v13;
     }
     ecl_aset_unsafe(T0,ecl_fixnum(T1),v9i);
    }
    (cl_env_copy->function=ECL_CONS_CAR(VV[151]))->cfun.entry(2, v11index, v9i) /*  (SETF SLOT-DEFINITION-LOCATION) */;
    goto L58;
L59:;
   }
  }
  value0 = v2slots;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2000class_compute_slots_va(cl_narg narg, cl_object v8class, cl_object v9slots, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[97]);
 {
  return L2000class_compute_slots(v8class, v9slots);
 }
}
/* local function COMPUTE-SLOTS                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2003compute_slots(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. */
 T0 = LC2001call_next_method(0, lex0);
 value0 = L2000class_compute_slots(v1class, T0);
 return value0;
}
static cl_object LC2003compute_slots_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("COMPUTE-SLOTS",1577));
 {
  return LC2003compute_slots(v2class);
 }
}
/* function definition for STD-CLASS-COMPUTE-SLOTS                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2004std_class_compute_slots(cl_object v1class, cl_object v2slots)
{
 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:;
 {
  cl_object v3direct_slots;
  v3direct_slots = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SLOTS",1564)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SLOTS */;
  {
   cl_object v4;
   v4 = v2slots;
   goto L7;
L6:;
   {
    cl_object v5slotd;
    v5slotd = ecl_car(v4);
    {
     cl_object v6name;
     cl_object v7allocation;
     v6name = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v5slotd) /*  SLOT-DEFINITION-NAME */;
     v7allocation = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v5slotd) /*  SLOT-DEFINITION-ALLOCATION */;
     {
      cl_object v8;
      T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v5slotd) /*  SLOT-DEFINITION-ALLOCATION */;
      {
       bool v9;
       v9 = (T0)==(VV[104]);
       v8 = (v9)?ECL_NIL:ECL_T;
      }
      if (Null(v8)){
       goto L15;
      }
      goto L11;
L15:;
      {
       cl_object v9;
       v9 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
       {
        cl_object v10;
        v10 = si_make_seq_iterator(2, v3direct_slots, ecl_make_int8_t(0));
L21:;
        if (v10!=ECL_NIL) {
         goto L23;
        }
        goto L17;
L23:;
        {
         cl_object v11;
         v11 = si_seq_iterator_ref(v3direct_slots, v10);
         T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v11) /*  SLOT-DEFINITION-NAME */;
         if (!(ecl_eql(v6name,T0))){
          goto L25;
         }
         if (Null(v11)){
          goto L17;
         }
         goto L18;
        }
L25:;
        v10 = si_seq_iterator_next(v3direct_slots, v10);
        goto L21;
       }
      }
L18:;
      {
       cl_object v9initfunc;
       cl_object v10value;
       v9initfunc = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFUNCTION",1622)->symbol.gfdef))->cfun.entry(1, v5slotd) /*  SLOT-DEFINITION-INITFUNCTION */;
       if (Null(v9initfunc)){
        goto L32;
       }
       v10value = ecl_function_dispatch(cl_env_copy,v9initfunc)(0);
       goto L31;
L32:;
       v10value = ECL_UNBOUND;
L31:;
       {
        cl_object v11;
        v11 = ecl_list1(v10value);
        (cl_env_copy->function=ECL_CONS_CAR(VV[151]))->cfun.entry(2, v11, v5slotd) /*  (SETF SLOT-DEFINITION-LOCATION) */;
        goto L11;
       }
      }
L17:;
      {
       cl_object v12;
       v12 = (cl_env_copy->function=(ECL_SYM("CLASS-PRECEDENCE-LIST",1568)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-PRECEDENCE-LIST */;
       goto L38;
L37:;
       {
        cl_object v13c;
        v13c = ecl_car(v12);
        if (ecl_eql(v13c,v1class)) {
         goto L42;
        }
        {
         cl_object v14other;
         {
          cl_object v15;
          cl_object v16;
          cl_object v17;
          v15 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v5slotd) /*  SLOT-DEFINITION-NAME */;
          v16 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v13c) /*  CLASS-SLOTS */;
          v17 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
          {
          cl_object v18;
          v18 = si_make_seq_iterator(2, v16, ecl_make_int8_t(0));
L49:;
          if (v18!=ECL_NIL) {
          goto L51;
          }
          v14other = ECL_NIL;
          goto L44;
L51:;
          {
          cl_object v19;
          v19 = si_seq_iterator_ref(v16, v18);
          T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v19) /*  SLOT-DEFINITION-NAME */;
          if (!(ecl_eql(v15,T0))){
          goto L53;
          }
          v14other = v19;
          goto L44;
          }
L53:;
          v18 = si_seq_iterator_next(v16, v18);
          goto L49;
          }
         }
L44:;
         if (Null(v14other)){
          goto L42;
         }
         T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v14other) /*  SLOT-DEFINITION-ALLOCATION */;
         if (!((T0)==(v7allocation))){
          goto L42;
         }
         {
          cl_object v15;
          v15 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v14other) /*  SLOT-DEFINITION-LOCATION */;
          if (Null((cl_env_copy->function=ECL_CONS_CAR(VV[151]))->cfun.entry(2, v15, v5slotd) /*  (SETF SLOT-DEFINITION-LOCATION) */)){
          goto L42;
          }
         }
         goto L11;
        }
L42:;
       }
       v12 = ecl_cdr(v12);
L38:;
       if (Null(v12)){
        goto L64;
       }
       goto L37;
L64:;
      }
     }
    }
L11:;
   }
   v4 = ecl_cdr(v4);
L7:;
   if (Null(v4)){
    goto L68;
   }
   goto L6;
L68:;
  }
  value0 = v2slots;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function COMPUTE-SLOTS                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2007compute_slots(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. */
 T0 = LC2005call_next_method(0, lex0);
 value0 = L2004std_class_compute_slots(v1class, T0);
 return value0;
}
static cl_object LC2007compute_slots_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("COMPUTE-SLOTS",1577));
 {
  return LC2007compute_slots(v2class);
 }
}
/* local function DESCRIBE-OBJECT                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2008describe_object(cl_object v1obj, cl_object v2stream)
{
 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:;
 {
  cl_object v3class;
  cl_object v4slotds;
  cl_object v5slotname;
  cl_object v6has_shared_slots;
  v3class = si_instance_class(v1obj);
  v4slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-SLOTS */;
  v5slotname = ECL_NIL;
  v6has_shared_slots = ECL_NIL;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-NAME */;
  cl_format(4, v2stream, VV[105], v1obj, T0);
  if (Null(v4slotds)){
   goto L2;
  }
  cl_format(2, v2stream, VV[106]);
  {
   cl_object v7;
   v7 = v4slotds;
   goto L14;
L13:;
   {
    cl_object v8slot;
    v8slot = ecl_car(v7);
    v5slotname = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v8slot) /*  SLOT-DEFINITION-NAME */;
    {
     cl_object v9;
     v9 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v8slot) /*  SLOT-DEFINITION-ALLOCATION */;
     if (!((v9)==(ECL_SYM("INSTANCE",1291)))){
      goto L22;
     }
     if (Null(cl_slot_boundp(v1obj, v5slotname))){
      goto L25;
     }
     T0 = cl_slot_value(v1obj, v5slotname);
     goto L24;
L25:;
     T0 = VV[108];
L24:;
     cl_format(4, v2stream, VV[107], v5slotname, T0);
     goto L20;
L22:;
     v6has_shared_slots = ECL_T;
    }
L20:;
   }
   v7 = ecl_cdr(v7);
L14:;
   if (Null(v7)){
    goto L30;
   }
   goto L13;
L30:;
  }
  if (Null(v6has_shared_slots)){
   goto L2;
  }
  cl_format(2, v2stream, VV[109]);
  {
   cl_object v7;
   v7 = v4slotds;
   goto L37;
L36:;
   {
    cl_object v8slot;
    v8slot = ecl_car(v7);
    v5slotname = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v8slot) /*  SLOT-DEFINITION-NAME */;
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v8slot) /*  SLOT-DEFINITION-ALLOCATION */;
    if ((T0)==(ECL_SYM("INSTANCE",1291))) {
     goto L43;
    }
    if (Null(cl_slot_boundp(v1obj, v5slotname))){
     goto L46;
    }
    T0 = cl_slot_value(v1obj, v5slotname);
    goto L45;
L46:;
    T0 = VV[108];
L45:;
    cl_format(4, v2stream, VV[107], v5slotname, T0);
L43:;
   }
   v7 = ecl_cdr(v7);
L37:;
   if (Null(v7)){
    goto L50;
   }
   goto L36;
L50:;
  }
 }
L2:;
 value0 = v1obj;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2008describe_object_va(cl_narg narg, cl_object v3obj, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("DESCRIBE-OBJECT",945));
 {
  return LC2008describe_object(v3obj, v4stream);
 }
}
/* function definition for VALID-KEYWORDS-FROM-METHODS                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2009valid_keywords_from_methods(cl_narg narg, ...)
{
 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);
 {
  cl_object v1method_lists;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1method_lists = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v2;
   cl_object v3methods;
   cl_object v4;
   {
    cl_object v5;
    v5 = v1method_lists;
    if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v2 = v5;
   }
   v3methods = ECL_NIL;
   v4 = v2;
   {
    cl_object v5;
    cl_object v6;
    v5 = ecl_list1(ECL_NIL);
    v6 = v5;
L8:;
    if (!(ecl_endp(v4))){
     goto L10;
    }
    goto L9;
L10:;
    v3methods = ECL_CONS_CAR(v4);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v4);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    {
     cl_object v7;
     v7 = (VV[37]->symbol.gfdef);
     {
      cl_object v8;
      v8 = v3methods;
      goto L24;
L23:;
      {
       cl_object v9;
       cl_object v10;
       {
        cl_object v11;
        v11 = v8;
        if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v9 = v11;
       }
       v10 = ECL_CONS_CAR(v9);
       T0 = (cl_env_copy->function=(VV[37]->symbol.gfdef))->cfun.entry(1, v10) /*  METHOD-KEYWORDS */;
       if (!((ECL_T)==(T0))){
        goto L26;
       }
       if (Null(v9)){
        goto L18;
       }
       goto L19;
      }
L26:;
      v8 = ECL_CONS_CDR(v8);
L24:;
      if (v8==ECL_NIL) {
       goto L34;
      }
      goto L23;
L34:;
      goto L18;
     }
    }
L19:;
    value0 = ECL_T;
    cl_env_copy->nvalues = 1;
    return value0;
L18:;
    {
     cl_object v7;
     v7 = v3methods;
     {
      cl_object v8;
      v8 = v6;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v8;
     }
     (ECL_CONS_CDR(T0)=v7,T0);
     if (Null(v7)){
      goto L36;
     }
    }
    T0 = ecl_cdr(v6);
    v6 = ecl_last(T0,1);
L36:;
    goto L8;
L9:;
    value0 = ecl_cdr(v5);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* function definition for CHECK-INITARGS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2010check_initargs(cl_narg narg, cl_object v1class, cl_object v2initargs, ...)
{
 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(VV[1]);
 if (ecl_unlikely(narg>5)) FEwrong_num_arguments(VV[1]);
 {
  cl_object v3methods;
  cl_object v4slots;
  cl_object v5cached_keywords;
  va_list args; va_start(args,v2initargs);
  {
   int i = 2;
   if (i >= narg) {
    v3methods = ECL_NIL;
   } else {
    i++;
    v3methods = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v4slots = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
   } else {
    i++;
    v4slots = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v5cached_keywords = ECL_NIL;
   } else {
    i++;
    v5cached_keywords = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if ((v3methods)==(ECL_T)) {
   goto L4;
  }
  if ((v5cached_keywords)==(ECL_T)) {
   goto L4;
  }
  {
   cl_object v6name_loc;
   cl_object v7allow_other_keys;
   cl_object v8allow_other_keys_found;
   cl_object v9unknown_key_names;
   v6name_loc = v2initargs;
   v7allow_other_keys = ECL_NIL;
   v8allow_other_keys_found = ECL_NIL;
   v9unknown_key_names = ECL_NIL;
   goto L13;
L12:;
   {
    cl_object v10name;
    v10name = ecl_car(v6name_loc);
    T0 = ecl_cdr(v6name_loc);
    if (!(T0==ECL_NIL)){
     goto L17;
    }
    si_simple_program_error(2, VV[112], v10name);
    goto L15;
L17:;
    if (!((v10name)==(ECL_SYM("ALLOW-OTHER-KEYS",1227)))){
     goto L19;
    }
    if (v8allow_other_keys_found!=ECL_NIL) {
     goto L19;
    }
    v7allow_other_keys = ecl_cadr(v6name_loc);
    v8allow_other_keys_found = ECL_T;
    goto L15;
L19:;
    {
     cl_object v11;
     {
      cl_object v12;
      cl_object v13;
      v12 = (ECL_SYM("MEMBER",554)->symbol.gfdef);
      v13 = (ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef);
      {
       cl_object v14;
       v14 = v4slots;
       goto L31;
L30:;
       {
        cl_object v15;
        cl_object v16;
        {
         cl_object v17;
         v17 = v14;
         if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v15 = v17;
        }
        v16 = ECL_CONS_CAR(v15);
        {
         cl_object v17;
         cl_object v18;
         cl_object v19;
         v17 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef))->cfun.entry(1, v16) /*  SLOT-DEFINITION-INITARGS */;
         v18 = v10name;
         v19 = v17;
         if (Null(ecl_memql(v18,v19))){
          goto L33;
         }
        }
        v11 = v15;
        goto L25;
       }
L33:;
       v14 = ECL_CONS_CDR(v14);
L31:;
       if (v14==ECL_NIL) {
        goto L44;
       }
       goto L30;
L44:;
       v11 = ECL_NIL;
      }
     }
L25:;
     if (Null(v11)){
      goto L46;
     }
     goto L15;
L46:;
     {
      cl_object v12;
      {
       cl_object v13;
       cl_object v14;
       v13 = v10name;
       v14 = v5cached_keywords;
       v12 = ecl_memql(v13,v14);
      }
      if (Null(v12)){
       goto L51;
      }
      goto L15;
L51:;
      {
       cl_object v13;
       if (Null(v3methods)){
        goto L55;
       }
       {
        cl_object v14;
        cl_object v15;
        v14 = (ECL_SYM("MEMBER",554)->symbol.gfdef);
        v15 = (VV[37]->symbol.gfdef);
        {
         cl_object v16;
         v16 = v3methods;
         goto L62;
L61:;
         {
          cl_object v17;
          cl_object v18;
          {
          cl_object v19;
          v19 = v16;
          if (ecl_unlikely(ECL_ATOM(v19))) FEtype_error_cons(v19);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v17 = v19;
          }
          v18 = ECL_CONS_CAR(v17);
          {
          cl_object v19;
          cl_object v20;
          cl_object v21;
          v19 = (cl_env_copy->function=(VV[37]->symbol.gfdef))->cfun.entry(1, v18) /*  METHOD-KEYWORDS */;
          v20 = v10name;
          v21 = v19;
          if (Null(ecl_memql(v20,v21))){
          goto L64;
          }
          }
          v13 = v17;
          goto L53;
         }
L64:;
         v16 = ECL_CONS_CDR(v16);
L62:;
         if (v16==ECL_NIL) {
          goto L75;
         }
         goto L61;
L75:;
         v13 = ECL_NIL;
         goto L53;
        }
       }
L55:;
       v13 = ECL_NIL;
       goto L53;
L53:;
       if (Null(v13)){
        goto L77;
       }
       goto L15;
L77:;
       v9unknown_key_names = CONS(v10name,v9unknown_key_names);
      }
     }
    }
   }
L15:;
   v6name_loc = ecl_cddr(v6name_loc);
L13:;
   if (v6name_loc==ECL_NIL) {
    goto L82;
   }
   goto L12;
L82:;
   if (v7allow_other_keys!=ECL_NIL) {
    goto L84;
   }
   if (Null(v9unknown_key_names)){
    goto L84;
   }
   T0 = cl_nreverse(v9unknown_key_names);
   value0 = si_simple_program_error(3, VV[113], T0, v1class);
   return value0;
L84:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function DESCRIBE-OBJECT                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2011describe_object(cl_object v1obj, cl_object v2stream)
{
 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);
L1:;
 {
  cl_object v3slotds;
  T0 = si_instance_class(v1obj);
  v3slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-SLOTS */;
  T0 = si_instance_class(v1obj);
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-NAME */;
  cl_format(4, v2stream, VV[115], v1obj, T1);
  {
   cl_object v4scan;
   cl_fixnum v5i;
   v4scan = v3slotds;
   v5i = (cl_fixnum)(0);
   goto L9;
L8:;
   T0 = ecl_car(v4scan);
   T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
   (ecl_print(T1,v2stream));
   ecl_princ(VV[116],v2stream);
   {
    cl_object v6;
    T0 = ecl_car(v4scan);
    v6 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
    if (!((v6)==(VV[118]))){
     goto L20;
    }
    goto L17;
L20:;
    goto L18;
L18:;
    if (!((v6)==(VV[119]))){
     goto L24;
    }
    goto L17;
L24:;
    goto L22;
L22:;
    if (!((v6)==(VV[121]))){
     goto L15;
    }
    goto L16;
L17:;
L16:;
    ecl_princ_char((ecl_character)(40),v2stream);
    {
     cl_object v7scan;
     cl_object v8e;
     v7scan = ecl_instance_ref((v1obj),(v5i));
     v8e = ecl_car(v7scan);
     goto L33;
L32:;
     T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v8e) /*  CLASS-NAME */;
     (ecl_prin1(T0,v2stream));
     if (Null(ecl_cdr(v7scan))){
      goto L36;
     }
     ecl_princ_char((ecl_character)(32),v2stream);
L36:;
     v7scan = ecl_cdr(v7scan);
     v8e = ecl_car(v7scan);
L33:;
     if (v7scan==ECL_NIL) {
      goto L42;
     }
     goto L32;
L42:;
    }
    ecl_princ_char((ecl_character)(41),ECL_NIL);
    goto L13;
L15:;
    T0 = ecl_instance_ref((v1obj),(v5i));
    (ecl_prin1(T0,v2stream));
   }
L13:;
   v4scan = ecl_cdr(v4scan);
   {
    cl_object v6;
    v6 = ecl_make_integer((v5i)+1);
    {
     bool v7;
     v7 = ECL_FIXNUMP(v6);
     if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v5i = ecl_fixnum(v6);
   }
L9:;
   if (v4scan==ECL_NIL) {
    goto L49;
   }
   goto L8;
L49:;
  }
 }
 value0 = v1obj;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2011describe_object_va(cl_narg narg, cl_object v3obj, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("DESCRIBE-OBJECT",945));
 {
  return LC2011describe_object(v3obj, v4stream);
 }
}
/* closure CALL-NEXT-METHOD                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1967call_next_method(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  .NEXT-METHODS.          */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (ECL_CONS_CAR(CLV1)!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[29]);
L1:;
  T0 = ecl_car(ECL_CONS_CAR(CLV1));
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = ECL_CONS_CAR(CLV0);
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(ECL_CONS_CAR(CLV1));
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
 }
}
/* closure CALL-NEXT-METHOD                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1970call_next_method(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  .NEXT-METHODS.          */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (ECL_CONS_CAR(CLV1)!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[29]);
L1:;
  T0 = ecl_car(ECL_CONS_CAR(CLV1));
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = ECL_CONS_CAR(CLV0);
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(ECL_CONS_CAR(CLV1));
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
 }
}
/* closure LAMBDA164                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1974__lambda164(cl_narg narg, cl_object v1dep, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  INITARGS                */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[42]);
 {
L1:;
  T0 = (ECL_SYM("UPDATE-DEPENDENT",1649)->symbol.gfdef);
  value0 = cl_apply(4, T0, ECL_CONS_CAR(CLV0), v1dep, ECL_CONS_CAR(CLV1));
  return value0;
 }
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1976call_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[29]);
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;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1985call_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[29]);
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;
 }
}
/* closure COMBINE-SLOTDS                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1994combine_slotds(cl_narg narg, cl_object v1new_slotd, cl_object v2old_slotd, ...)
{
 cl_object T0, T1;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  NAME                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[79]);
 {
L1:;
  {
   cl_object v3new_type;
   cl_object v4old_type;
   cl_object v5loc1;
   cl_object v6loc2;
   v3new_type = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-TYPE",1626)->symbol.gfdef))->cfun.entry(1, v1new_slotd) /*  SLOT-DEFINITION-TYPE */;
   v4old_type = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-TYPE",1626)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-TYPE */;
   v5loc1 = L1992safe_slot_definition_location(1, v1new_slotd);
   v6loc2 = L1992safe_slot_definition_location(1, v2old_slotd);
   if (Null(v6loc2)){
    goto L6;
   }
   if (Null(v5loc1)){
    goto L8;
   }
   if (ecl_eql(v5loc1,v6loc2)) {
    goto L6;
   }
   T0 = cl_list(3, v5loc1, v6loc2, ECL_CONS_CAR(CLV0));
   cl_error(5, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("FORMAT-CONTROL",1272), VV[80], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
   goto L6;
L8:;
   (cl_env_copy->function=ECL_CONS_CAR(VV[151]))->cfun.entry(2, v6loc2, v1new_slotd) /*  (SETF SLOT-DEFINITION-LOCATION) */;
L6:;
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef))->cfun.entry(1, v1new_slotd) /*  SLOT-DEFINITION-INITARGS */;
    T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITARGS",1620)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-INITARGS */;
    v7 = cl_union(2, T0, T1);
    (cl_env_copy->function=ECL_CONS_CAR(VV[157]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-INITARGS) */;
   }
   if ((cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFUNCTION",1622)->symbol.gfdef))->cfun.entry(1, v1new_slotd) /*  SLOT-DEFINITION-INITFUNCTION */!=ECL_NIL) {
    goto L13;
   }
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFORM",1621)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-INITFORM */;
    (cl_env_copy->function=ECL_CONS_CAR(VV[158]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-INITFORM) */;
   }
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-INITFUNCTION",1622)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-INITFUNCTION */;
    (cl_env_copy->function=ECL_CONS_CAR(VV[159]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-INITFUNCTION) */;
   }
L13:;
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-READERS",1625)->symbol.gfdef))->cfun.entry(1, v1new_slotd) /*  SLOT-DEFINITION-READERS */;
    T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-READERS",1625)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-READERS */;
    v7 = cl_union(2, T0, T1);
    (cl_env_copy->function=ECL_CONS_CAR(VV[160]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-READERS) */;
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-WRITERS",1627)->symbol.gfdef))->cfun.entry(1, v1new_slotd) /*  SLOT-DEFINITION-WRITERS */;
    T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-WRITERS",1627)->symbol.gfdef))->cfun.entry(1, v2old_slotd) /*  SLOT-DEFINITION-WRITERS */;
    v7 = cl_union(2, T0, T1);
    (cl_env_copy->function=ECL_CONS_CAR(VV[161]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-WRITERS) */;
   }
   {
    cl_object v7;
    if (Null(cl_subtypep(2, v3new_type, v4old_type))){
     goto L24;
    }
    v7 = v3new_type;
    goto L23;
L24:;
    if (Null(cl_subtypep(2, v4old_type, v3new_type))){
     goto L26;
    }
    v7 = v4old_type;
    goto L23;
L26:;
    v7 = cl_list(3, ECL_SYM("AND",89), v3new_type, v4old_type);
L23:;
    (cl_env_copy->function=ECL_CONS_CAR(VV[162]))->cfun.entry(2, v7, v1new_slotd) /*  (SETF SLOT-DEFINITION-TYPE) */;
   }
   value0 = v1new_slotd;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* local function DIRECT-TO-EFFECTIVE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1993direct_to_effective(volatile cl_object *lex0, cl_object v1old_slot)
{
 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);
L1:;
 if (!(ECL_CONSP(v1old_slot))){
  goto L2;
 }
 value0 = cl_copy_list(v1old_slot);
 return value0;
L2:;
 {
  cl_object v2initargs;
  v2initargs = L1991slot_definition_to_plist(v1old_slot);
  T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
  T1 = (ECL_SYM("EFFECTIVE-SLOT-DEFINITION-CLASS",1581)->symbol.gfdef);
  T2 = cl_apply(3, T1, lex0[0], v2initargs);
  value0 = cl_apply(3, T0, T2, v2initargs);
  return value0;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2001call_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[29]);
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;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2005call_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[29]);
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/standard.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclcwhL8lOoCIPk9_s740M881(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;STANDARD.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclcwhL8lOoCIPk9_s740M881@";
 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)LC1955initialize_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("INITIALIZE-INSTANCE",951), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1956reinitialize_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("REINITIALIZE-INSTANCE",967), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1957shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[3], VVtemp[4], T0);
  ecl_cmp_defun(VV[123]);                         /*  COMPUTE-INSTANCE-SIZE   */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1959allocate_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ALLOCATE-INSTANCE",931), ECL_NIL, VVtemp[5], VVtemp[6], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1960make_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCE",953), ECL_NIL, VVtemp[5], VVtemp[6], T0);
  ecl_cmp_defun(VV[124]);                         /*  DELETE-KEYWORD          */
  (void)0; /* No entry created for ADD-DEFAULT-INITARGS */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1963direct_slot_definition_class,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("DIRECT-SLOT-DEFINITION-CLASS",1579), ECL_NIL, VVtemp[1], VVtemp[7], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1964effective_slot_definition_class,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("EFFECTIVE-SLOT-DEFINITION-CLASS",1581), ECL_NIL, VVtemp[1], VVtemp[7], T0);
  ecl_cmp_defun(VV[125]);                         /*  HAS-FORWARD-REFERENCED-PARENTS */
  ecl_cmp_defun(VV[126]);                         /*  FINALIZE-UNLESS-FORWARD */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1969initialize_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("INITIALIZE-INSTANCE",951), ECL_NIL, VVtemp[5], VVtemp[8], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1972shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[9], VVtemp[10], T0);
  ecl_cmp_defun(VV[127]);                         /*  PRECOMPUTE-VALID-INITARG-KEYWORDS */
  ecl_cmp_defun(VV[128]);                         /*  UPDATE-DEPENDENTS       */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1978shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1979add_direct_subclass_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ADD-DIRECT-SUBCLASS",1561), ECL_NIL, VVtemp[9], VVtemp[13], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1980remove_direct_subclass_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("REMOVE-DIRECT-SUBCLASS",1615), ECL_NIL, VVtemp[9], VVtemp[13], T0);
  ecl_cmp_defun(VV[129]);                         /*  CHECK-DIRECT-SUPERCLASSES */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1982validate_superclass_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("VALIDATE-SUPERCLASS",1651), ECL_NIL, VVtemp[14], VVtemp[15], T0);
  ecl_cmp_defun(VV[130]);                         /*  FORWARD-REFERENCED-CLASS-P */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1984finalize_inheritance_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("FINALIZE-INHERITANCE",1589), ECL_NIL, VVtemp[5], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1987finalize_inheritance_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("FINALIZE-INHERITANCE",1589), ECL_NIL, VVtemp[16], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1988finalize_inheritance_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("FINALIZE-INHERITANCE",1589), ECL_NIL, VVtemp[17], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1989compute_class_precedence_list_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-CLASS-PRECEDENCE-LIST",1572), ECL_NIL, VVtemp[5], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1990compute_slots_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-SLOTS",1577), ECL_NIL, VVtemp[5], VVtemp[5], T0);
  ecl_cmp_defun(VV[131]);                         /*  SLOT-DEFINITION-TO-PLIST */
  ecl_cmp_defun(VV[132]);                         /*  SAFE-SLOT-DEFINITION-LOCATION */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1995compute_effective_slot_definition_va,ECL_NIL,Cblock,3);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-EFFECTIVE-SLOT-DEFINITION",1576), ECL_NIL, VVtemp[18], VVtemp[19], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1996compute_default_initargs_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-DEFAULT-INITARGS",1573), ECL_NIL, VVtemp[5], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1997ensure_class_using_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ENSURE-CLASS-USING-CLASS",1583), ECL_NIL, VVtemp[9], VVtemp[20], T0);
  ecl_cmp_defun(VV[133]);                         /*  COERCE-TO-CLASS         */
  ecl_cmp_defun(VV[134]);                         /*  HELP-ENSURE-CLASS       */
  ecl_cmp_defun(VV[135]);                         /*  CLASS-COMPUTE-SLOTS     */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2003compute_slots_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-SLOTS",1577), VVtemp[21], VVtemp[5], VVtemp[5], T0);
  (void)0; /* No entry created for STD-CLASS-COMPUTE-SLOTS */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2007compute_slots_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("COMPUTE-SLOTS",1577), VVtemp[21], VVtemp[16], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2008describe_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("DESCRIBE-OBJECT",945), ECL_NIL, VVtemp[22], VVtemp[23], T0);
  ecl_cmp_defun(VV[136]);                         /*  VALID-KEYWORDS-FROM-METHODS */
  ecl_cmp_defun(VV[137]);                         /*  CHECK-INITARGS          */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2011describe_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("DESCRIBE-OBJECT",945), ECL_NIL, VVtemp[11], VVtemp[23], T0);
 }
}
