/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/change.lsp                     */
#include <ecl/ecl-cmp.h>
#include "clos/change.eclh"
/* local function UPDATE-INSTANCE-FOR-DIFFERENT-CLASS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2028update_instance_for_different_class(cl_narg narg, cl_object v1old_data, cl_object v2new_data, ...)
{
 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<2)) FEwrong_num_arguments(ECL_SYM("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS",983));
 {
  cl_object v3initargs;
  ecl_va_list args; ecl_va_start(args,v2new_data,narg,2);
  v3initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v4;
   cl_object v5;
   cl_object v6added_slots;
   v4 = si_instance_slotds(v1old_data);
   T0 = si_instance_slotds(v2new_data);
   T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
   T2 = (ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef);
   v5 = cl_remove(6, ECL_SYM("INSTANCE",1291), T0, ECL_SYM("TEST-NOT",1354), T1, ECL_SYM("KEY",1297), T2);
   v6added_slots = ECL_NIL;
   {
    cl_object v7;
    v7 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     {
      cl_object v11;
      v11 = v5;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9 = ECL_NIL;
     v10 = v8;
     {
      cl_object v11;
      cl_object v12;
      v11 = ecl_list1(ECL_NIL);
      v12 = v11;
L17:;
      if (!(ecl_endp(v10))){
       goto L19;
      }
      goto L18;
L19:;
      v9 = ECL_CONS_CAR(v10);
      {
       cl_object v13;
       v13 = ECL_CONS_CDR(v10);
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      {
       cl_object v13;
       v13 = v12;
       if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v13;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
      v12 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v12,T1);
      goto L17;
L18:;
      T0 = ecl_cdr(v11);
      goto L8;
     }
    }
   }
L8:;
   {
    cl_object v7;
    v7 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     v8 = v4;
     v9 = ECL_NIL;
     v10 = v8;
     {
      cl_object v11;
      cl_object v12;
      v11 = ecl_list1(ECL_NIL);
      v12 = v11;
L42:;
      if (!(ecl_endp(v10))){
       goto L44;
      }
      goto L43;
L44:;
      v9 = ECL_CONS_CAR(v10);
      {
       cl_object v13;
       v13 = ECL_CONS_CDR(v10);
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      {
       cl_object v13;
       v13 = v12;
       if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v13;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
      v12 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v12,T2);
      goto L42;
L43:;
      T1 = ecl_cdr(v11);
      goto L35;
     }
    }
   }
L35:;
   v6added_slots = cl_set_difference(2, T0, T1);
   T0 = cl_class_of(v2new_data);
   T1 = (ECL_SYM("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS",983)->symbol.gfdef);
   T2 = cl_list(2, v1old_data, v2new_data);
   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, v2new_data, v6added_slots);
   T6 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T4, T5) /*  COMPUTE-APPLICABLE-METHODS */;
   T7 = (cl_env_copy->function=(VV[7]->symbol.gfdef))->cfun.entry(2, T3, T6) /*  VALID-KEYWORDS-FROM-METHODS */;
   (cl_env_copy->function=(VV[6]->symbol.gfdef))->cfun.entry(3, T0, v3initargs, T7) /*  CHECK-INITARGS */;
   T0 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
   value0 = cl_apply(4, T0, v2new_data, v6added_slots, v3initargs);
   return value0;
  }
 }
}
/* local function CHANGE-CLASS                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2029change_class(cl_narg narg, cl_object v1instance, cl_object v2new_class, ...)
{
 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("CHANGE-CLASS",936));
 {
  cl_object v3initargs;
  ecl_va_list args; ecl_va_start(args,v2new_class,narg,2);
  v3initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v4old_instance;
   cl_object v5new_size;
   cl_object v6instance;
   v4old_instance = si_copy_instance(v1instance);
   v5new_size = (cl_env_copy->function=(VV[8]->symbol.gfdef))->cfun.entry(1, v2new_class) /*  CLASS-SIZE */;
   v6instance = si_allocate_raw_instance(v1instance, v2new_class, v5new_size);
   si_instance_sig_set(v6instance);
   {
    cl_object v7new_local_slotds;
    T0 = cl_class_of(v6instance);
    v7new_local_slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-SLOTS */;
    {
     cl_object v8;
     v8 = v7new_local_slotds;
     goto L10;
L9:;
     {
      cl_object v9new_slot;
      v9new_slot = ecl_car(v8);
      T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v9new_slot) /*  SLOT-DEFINITION-ALLOCATION */;
      if (!((T0)==(ECL_SYM("INSTANCE",1291)))){
       goto L14;
      }
      {
       cl_object v10name;
       v10name = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v9new_slot) /*  SLOT-DEFINITION-NAME */;
       if (Null(cl_slot_exists_p(v4old_instance, v10name))){
        goto L17;
       }
       if (Null(cl_slot_boundp(v4old_instance, v10name))){
        goto L17;
       }
       {
        cl_object v11;
        v11 = cl_slot_value(v4old_instance, v10name);
        (cl_env_copy->function=ECL_CONS_CAR(VV[33]))->cfun.entry(3, v11, v6instance, v10name) /*  (SETF SLOT-VALUE) */;
        goto L14;
       }
L17:;
       cl_slot_makunbound(v6instance, v10name);
      }
L14:;
     }
     v8 = ecl_cdr(v8);
L10:;
     if (Null(v8)){
      goto L23;
     }
     goto L9;
L23:;
    }
   }
   T0 = (ECL_SYM("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS",983)->symbol.gfdef);
   cl_apply(4, T0, v4old_instance, v6instance, v3initargs);
   value0 = v6instance;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function CHANGE-CLASS                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2032change_class(cl_narg narg, cl_object v1instance, cl_object v2new_class, ...)
{
 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("CHANGE-CLASS",936));
 {
  va_list args; va_start(args,v2new_class);
  va_end(args);
  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:;
  lex0[0] = T0;                                   /*  .CLOSED-COMBINED-METHOD-ARGS. */
  lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
  if (Null((cl_env_copy->function=(VV[11]->symbol.gfdef))->cfun.entry(1, v1instance) /*  FORWARD-REFERENCED-CLASS-P */)){
   goto L5;
  }
  value0 = LC2030call_next_method(0, lex0);
  return value0;
L5:;
  value0 = cl_error(1, VV[12]);
  return value0;
 }
}
/* local function UPDATE-INSTANCE-FOR-REDEFINED-CLASS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2033update_instance_for_redefined_class(cl_narg narg, cl_object v1instance, cl_object v2added_slots, cl_object v3discarded_slots, cl_object v4property_list, ...)
{
 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<4)) FEwrong_num_arguments(ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984));
 {
  cl_object v5initargs;
  ecl_va_list args; ecl_va_start(args,v4property_list,narg,4);
  v5initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = cl_class_of(v1instance);
  T1 = (ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984)->symbol.gfdef);
  T2 = cl_list(4, v1instance, v2added_slots, v3discarded_slots, v4property_list);
  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, v2added_slots);
  T6 = (cl_env_copy->function=(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940)->symbol.gfdef))->cfun.entry(2, T4, T5) /*  COMPUTE-APPLICABLE-METHODS */;
  T7 = (cl_env_copy->function=(VV[7]->symbol.gfdef))->cfun.entry(2, T3, T6) /*  VALID-KEYWORDS-FROM-METHODS */;
  (cl_env_copy->function=(VV[6]->symbol.gfdef))->cfun.entry(3, T0, v5initargs, T7) /*  CHECK-INITARGS */;
  T0 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
  value0 = cl_apply(4, T0, v1instance, v2added_slots, v5initargs);
  return value0;
 }
}
/* local function UPDATE-INSTANCE-FOR-REDEFINED-CLASS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2036update_instance_for_redefined_class(cl_narg narg, cl_object v1instance, cl_object v2added_slots, cl_object v3discarded_slots, cl_object v4property_list, ...)
{
 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<4)) FEwrong_num_arguments(ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984));
 {
  va_list args; va_start(args,v4property_list);
  va_end(args);
  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:;
  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 v5;
   v5 = LC2034call_next_method(0, lex0);
   {
    cl_object v6;
    v6 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v1instance) /*  CLASS-DIRECT-SUBCLASSES */;
    goto L10;
L9:;
    {
     cl_object v7class;
     v7class = ecl_car(v6);
     if (Null(si_instance_obsolete_p(v7class))){
      goto L14;
     }
     L2037update_instance(v7class);
L14:;
    }
    v6 = ecl_cdr(v6);
L10:;
    if (Null(v6)){
     goto L18;
    }
    goto L9;
L18:;
   }
   value0 = v5;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for UPDATE-INSTANCE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2037update_instance(cl_object v1instance)
{
 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 v2class;
  cl_object v3old_slotds;
  cl_object v4new_slotds;
  cl_object v5old_instance;
  cl_object v6discarded_slots;
  cl_object v7added_slots;
  cl_object v8property_list;
  v2class = cl_class_of(v1instance);
  v3old_slotds = si_instance_slotds(v1instance);
  v4new_slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v2class) /*  CLASS-SLOTS */;
  v5old_instance = si_copy_instance(v1instance);
  v6discarded_slots = ECL_NIL;
  v7added_slots = ECL_NIL;
  v8property_list = ECL_NIL;
  T0 = (cl_env_copy->function=(VV[8]->symbol.gfdef))->cfun.entry(1, v2class) /*  CLASS-SIZE */;
  v1instance = si_allocate_raw_instance(v1instance, v2class, T0);
  si_instance_sig_set(v1instance);
  {
   cl_fixnum v9new_i;
   cl_object v10old_local_slotds;
   cl_object v11new_local_slotds;
   v9new_i = (cl_fixnum)(0);
   T0 = (ECL_SYM("EQ",335)->symbol.gfdef);
   T1 = (ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef);
   v10old_local_slotds = cl_remove(6, ECL_SYM("INSTANCE",1291), v3old_slotds, ECL_SYM("TEST-NOT",1354), T0, ECL_SYM("KEY",1297), T1);
   T0 = (ECL_SYM("EQ",335)->symbol.gfdef);
   T1 = (ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef);
   v11new_local_slotds = cl_remove(6, ECL_SYM("INSTANCE",1291), v4new_slotds, ECL_SYM("TEST-NOT",1354), T0, ECL_SYM("KEY",1297), T1);
   {
    cl_object v12;
    v12 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
    {
     cl_object v13;
     cl_object v14;
     cl_object v15;
     {
      cl_object v16;
      v16 = v10old_local_slotds;
      if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v16;
     }
     v14 = ECL_NIL;
     v15 = v13;
     {
      cl_object v16;
      cl_object v17;
      v16 = ecl_list1(ECL_NIL);
      v17 = v16;
L31:;
      if (!(ecl_endp(v15))){
       goto L33;
      }
      goto L32;
L33:;
      v14 = ECL_CONS_CAR(v15);
      {
       cl_object v18;
       v18 = ECL_CONS_CDR(v15);
       if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v15 = v18;
      }
      {
       cl_object v18;
       v18 = v17;
       if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v18;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v12)(1, v14);
      v17 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v17,T1);
      goto L31;
L32:;
      T0 = ecl_cdr(v16);
      goto L22;
     }
    }
   }
L22:;
   {
    cl_object v12;
    v12 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
    {
     cl_object v13;
     cl_object v14;
     cl_object v15;
     {
      cl_object v16;
      v16 = v11new_local_slotds;
      if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v16;
     }
     v14 = ECL_NIL;
     v15 = v13;
     {
      cl_object v16;
      cl_object v17;
      v16 = ecl_list1(ECL_NIL);
      v17 = v16;
L58:;
      if (!(ecl_endp(v15))){
       goto L60;
      }
      goto L59;
L60:;
      v14 = ECL_CONS_CAR(v15);
      {
       cl_object v18;
       v18 = ECL_CONS_CDR(v15);
       if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v15 = v18;
      }
      {
       cl_object v18;
       v18 = v17;
       if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v18;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v12)(1, v14);
      v17 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v17,T2);
      goto L58;
L59:;
      T1 = ecl_cdr(v16);
      goto L49;
     }
    }
   }
L49:;
   v6discarded_slots = cl_set_difference(2, T0, T1);
   {
    cl_object v12;
    v12 = v6discarded_slots;
    goto L80;
L79:;
    {
     cl_object v13slot_name;
     v13slot_name = ecl_car(v12);
     {
      cl_object v14ndx;
      T0 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
      v14ndx = cl_position(4, v13slot_name, v10old_local_slotds, ECL_SYM("KEY",1297), T0);
      T0 = si_instance_ref(v5old_instance, v14ndx);
      v8property_list = cl_listX(3, v13slot_name, T0, v8property_list);
     }
    }
    v12 = ecl_cdr(v12);
L80:;
    if (Null(v12)){
     goto L90;
    }
    goto L79;
L90:;
   }
   {
    cl_object v12;
    v12 = v11new_local_slotds;
    goto L95;
L94:;
    {
     cl_object v13new_slot;
     v13new_slot = ecl_car(v12);
     {
      cl_object v14name;
      cl_object v15old_i;
      v14name = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v13new_slot) /*  SLOT-DEFINITION-NAME */;
      T0 = (ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef);
      v15old_i = cl_position(4, v14name, v10old_local_slotds, ECL_SYM("KEY",1297), T0);
      if (Null(v15old_i)){
       goto L104;
      }
      T0 = si_instance_ref(v5old_instance, v15old_i);
      si_instance_set(v1instance, ecl_make_fixnum(v9new_i), T0);
      goto L103;
L104:;
      v7added_slots = CONS(v14name,v7added_slots);
L103:;
      {
       cl_object v16;
       v16 = ecl_plus(ecl_make_fixnum(v9new_i),ecl_make_int8_t(1));
       {
        bool v17;
        v17 = ECL_FIXNUMP(v16);
        if (ecl_unlikely(!(v17)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v16);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
       }
       v9new_i = ecl_fixnum(v16);
      }
     }
    }
    v12 = ecl_cdr(v12);
L95:;
    if (Null(v12)){
     goto L112;
    }
    goto L94;
L112:;
   }
  }
  value0 = (cl_env_copy->function=(ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984)->symbol.gfdef))->cfun.entry(4, v1instance, v7added_slots, v6discarded_slots, v8property_list) /*  UPDATE-INSTANCE-FOR-REDEFINED-CLASS */;
  return value0;
 }
}
static cl_object L2037update_instance_va(cl_narg narg, cl_object v9instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[14]);
 {
  return L2037update_instance(v9instance);
 }
}
/* local function REINITIALIZE-INSTANCE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2040reinitialize_instance(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("REINITIALIZE-INSTANCE",967));
 {
  cl_object v2direct_superclasses;
  cl_object v3direct_superclasses_p;
  cl_object v4direct_slots;
  cl_object v5direct_slots_p;
  ecl_va_list args; ecl_va_start(args,v1class,narg,1);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,LC2040reinitialize_instancekeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   v2direct_superclasses = keyvars[0];
   v3direct_superclasses_p = keyvars[2];
   v4direct_slots = keyvars[1];
   v5direct_slots_p = keyvars[3];
  }
  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:;
  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 v6name;
   v6name = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-NAME */;
   {
    cl_object v7;
    v7 = (ECL_SYM("EQ",335)->symbol.gfdef);
    if (!((v6name)==(ECL_SYM("CLASS",937)))){
     goto L12;
    }
    goto L9;
L12:;
    goto L10;
L10:;
    if (!((v6name)==(ECL_SYM("BUILT-IN-CLASS",933)))){
     goto L5;
    }
    goto L7;
L9:;
   }
L7:;
   cl_error(2, VV[17], v6name);
  }
L5:;
  if (Null((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */)){
   goto L15;
  }
  L2044remove_optional_slot_accessors(v1class);
L15:;
  LC2038call_next_method(0, lex0);
  if (Null(v5direct_slots_p)){
   goto L18;
  }
  {
   cl_object v6;
   {
    cl_object v7;
    cl_object v8s;
    cl_object v9;
    {
     cl_object v10;
     v10 = v4direct_slots;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8s = ECL_NIL;
    v9 = v7;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L28:;
     if (!(ecl_endp(v9))){
      goto L30;
     }
     goto L29;
L30:;
     v8s = 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;
      T0 = v12;
     }
     T1 = (cl_env_copy->function=(VV[19]->symbol.gfdef))->cfun.entry(2, v1class, v8s) /*  CANONICAL-SLOT-TO-DIRECT-SLOT */;
     v11 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v11,T0);
     goto L28;
L29:;
     v6 = ecl_cdr(v10);
     goto L20;
    }
   }
L20:;
   (cl_env_copy->function=ECL_CONS_CAR(VV[36]))->cfun.entry(2, v6, v1class) /*  (SETF CLASS-DIRECT-SLOTS) */;
  }
L18:;
  if (Null(v3direct_superclasses_p)){
   goto L45;
  }
  v2direct_superclasses = (cl_env_copy->function=(VV[21]->symbol.gfdef))->cfun.entry(2, v1class, v2direct_superclasses) /*  CHECK-DIRECT-SUPERCLASSES */;
  {
   cl_object v6;
   v6 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUPERCLASSES",1566)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-DIRECT-SUPERCLASSES */;
   goto L53;
L52:;
   {
    cl_object v7l;
    v7l = ecl_car(v6);
    {
     cl_object v8;
     cl_object v9;
     v8 = v7l;
     v9 = v2direct_superclasses;
     if (ecl_memql(v8,v9)!=ECL_NIL) {
      goto L57;
     }
    }
    (cl_env_copy->function=(ECL_SYM("REMOVE-DIRECT-SUBCLASS",1615)->symbol.gfdef))->cfun.entry(2, v7l, v1class) /*  REMOVE-DIRECT-SUBCLASS */;
L57:;
   }
   v6 = ecl_cdr(v6);
L53:;
   if (Null(v6)){
    goto L63;
   }
   goto L52;
L63:;
  }
  {
   cl_object v6;
   v6 = (cl_env_copy->function=ECL_CONS_CAR(VV[37]))->cfun.entry(2, v2direct_superclasses, v1class) /*  (SETF CLASS-DIRECT-SUPERCLASSES) */;
   goto L68;
L67:;
   {
    cl_object v7l;
    v7l = ecl_car(v6);
    (cl_env_copy->function=(ECL_SYM("ADD-DIRECT-SUBCLASS",1561)->symbol.gfdef))->cfun.entry(2, v7l, v1class) /*  ADD-DIRECT-SUBCLASS */;
   }
   v6 = ecl_cdr(v6);
L68:;
   if (Null(v6)){
    goto L75;
   }
   goto L67;
L75:;
  }
L45:;
  if (Null((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */)){
   goto L78;
  }
  (cl_env_copy->function=(ECL_SYM("FINALIZE-INHERITANCE",1589)->symbol.gfdef))->cfun.entry(1, v1class) /*  FINALIZE-INHERITANCE */;
  goto L77;
L78:;
  (cl_env_copy->function=(VV[23]->symbol.gfdef))->cfun.entry(1, v1class) /*  FINALIZE-UNLESS-FORWARD */;
L77:;
  value0 = v1class;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for SLOT-DEFINITIONS-COMPATIBLE-P                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2041slot_definitions_compatible_p(cl_object v1old_slotds, cl_object v2new_slotds)
{
 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 v3o;
  v3o = ECL_NIL;
  {
   cl_object v4n;
   v4n = ECL_NIL;
L4:;
   {
    cl_object v5;
    v5 = v1old_slotds;
    {
     cl_object v6;
     v6 = v5;
     {
      bool v7;
      v7 = ECL_LISTP(v6);
      if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[27],v6);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v5)){
     goto L12;
    }
    {
     cl_object v6;
     v6 = ECL_CONS_CDR(v5);
     v1old_slotds = v6;
     v5 = ECL_CONS_CAR(v5);
    }
L12:;
    v3o = v5;
   }
   {
    cl_object v5;
    v5 = v2new_slotds;
    {
     cl_object v6;
     v6 = v5;
     {
      bool v7;
      v7 = ECL_LISTP(v6);
      if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[27],v6);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v5)){
     goto L24;
    }
    {
     cl_object v6;
     v6 = ECL_CONS_CDR(v5);
     v2new_slotds = v6;
     v5 = ECL_CONS_CAR(v5);
    }
L24:;
    v4n = v5;
   }
   if (Null(v3o)){
    goto L33;
   }
   if (v4n!=ECL_NIL) {
    goto L30;
   }
   goto L31;
L33:;
   goto L31;
L31:;
   goto L5;
L30:;
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    cl_object v8;
    v5 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v3o) /*  SLOT-DEFINITION-ALLOCATION */;
    v6 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v4n) /*  SLOT-DEFINITION-ALLOCATION */;
    v7 = cl_class_of(v3o);
    v8 = cl_class_of(v4n);
    if (!((v5)==(v6))){
     goto L42;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v3o) /*  SLOT-DEFINITION-NAME */;
    T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v4n) /*  SLOT-DEFINITION-NAME */;
    if (!((T0)==(T1))){
     goto L42;
    }
    if (!((v5)==(ECL_SYM("INSTANCE",1291)))){
     goto L46;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v3o) /*  SLOT-DEFINITION-LOCATION */;
    T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-LOCATION",1623)->symbol.gfdef))->cfun.entry(1, v4n) /*  SLOT-DEFINITION-LOCATION */;
    if (!(ecl_number_equalp(T0,T1))){
     goto L42;
    }
    goto L45;
L46:;
L45:;
    if (!((v7)==(v8))){
     goto L42;
    }
    T0 = cl_find_class(1, ECL_SYM("STANDARD-DIRECT-SLOT-DEFINITION",1636));
    if ((v8)==(T0)) {
     goto L35;
    }
    T0 = cl_find_class(1, ECL_SYM("STANDARD-EFFECTIVE-SLOT-DEFINITION",1637));
    if ((v8)==(T0)) {
     goto L35;
    }
    goto L40;
L42:;
    goto L40;
L40:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L35:;
   goto L4;
L5:;
   if (!(v3o==ECL_NIL)){
    goto L53;
   }
   if (!(v4n==ECL_NIL)){
    goto L53;
   }
   if (!(v1old_slotds==ECL_NIL)){
    goto L53;
   }
   value0 = ecl_make_bool(v2new_slotds==ECL_NIL);
   cl_env_copy->nvalues = 1;
   return value0;
L53:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L2041slot_definitions_compatible_p_va(cl_narg narg, cl_object v5old_slotds, cl_object v6new_slotds, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[24]);
 {
  return L2041slot_definitions_compatible_p(v5old_slotds, v6new_slotds);
 }
}
/* local function MAKE-INSTANCES-OBSOLETE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2042make_instances_obsolete(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:;
 si_instance_new_stamp(v1class);
 value0 = v1class;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2042make_instances_obsolete_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("MAKE-INSTANCES-OBSOLETE",954));
 {
  return LC2042make_instances_obsolete(v2class);
 }
}
/* local function MAKE-INSTANCES-OBSOLETE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2043make_instances_obsolete(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 = v1class;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2043make_instances_obsolete_va(cl_narg narg, cl_object v2class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("MAKE-INSTANCES-OBSOLETE",954));
 {
  return LC2043make_instances_obsolete(v2class);
 }
}
/* function definition for REMOVE-OPTIONAL-SLOT-ACCESSORS                     */
/* optimize speed 1, debug 1, space 1, safety 0                               */
static cl_object L2044remove_optional_slot_accessors(cl_object v1class)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2;
  v2 = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-SLOTS */;
  goto L5;
L4:;
  {
   cl_object v3slotd;
   v3slotd = _ecl_car(v2);
   {
    cl_object v4;
    v4 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-READERS",1625)->symbol.gfdef))->cfun.entry(1, v3slotd) /*  SLOT-DEFINITION-READERS */;
    goto L13;
L12:;
    {
     cl_object v5reader;
     v5reader = _ecl_car(v4);
     {
      cl_object v6gf_object;
      cl_object v7found;
      v6gf_object = cl_fdefinition(v5reader);
      v7found = ECL_NIL;
      T0 = ecl_list1(v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, ECL_NIL, T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L20;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
L20:;
      T0 = ecl_list1(v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, VV[29], T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L23;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
L23:;
      T0 = ecl_list1(v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, VV[30], T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L17;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
     }
L17:;
    }
    v4 = _ecl_cdr(v4);
L13:;
    if (Null(v4)){
     goto L30;
    }
    goto L12;
L30:;
   }
   {
    cl_object v4;
    v4 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-WRITERS",1627)->symbol.gfdef))->cfun.entry(1, v3slotd) /*  SLOT-DEFINITION-WRITERS */;
    goto L36;
L35:;
    {
     cl_object v5writer;
     v5writer = _ecl_car(v4);
     {
      cl_object v6gf_object;
      cl_object v7found;
      v6gf_object = cl_fdefinition(v5writer);
      v7found = ECL_NIL;
      T0 = cl_list(2, ECL_T, v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, ECL_NIL, T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L43;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
L43:;
      T0 = cl_list(2, ECL_T, v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, VV[29], T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L46;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
L46:;
      T0 = cl_list(2, ECL_T, v1class);
      v7found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v6gf_object, VV[30], T0, ECL_NIL) /*  FIND-METHOD */;
      if (Null(v7found)){
       goto L40;
      }
      (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v6gf_object, v7found) /*  REMOVE-METHOD */;
     }
L40:;
    }
    v4 = _ecl_cdr(v4);
L36:;
    if (Null(v4)){
     goto L53;
    }
    goto L35;
L53:;
   }
  }
  v2 = _ecl_cdr(v2);
L5:;
  if (Null(v2)){
   goto L57;
  }
  goto L4;
L57:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2030call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[10]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2034call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[10]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2038call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[10]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
#include "clos/change.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclG9LfcF2entYm9_Cv40M881(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;CHANGE.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclG9LfcF2entYm9_Cv40M881@";
 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)LC2028update_instance_for_different_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS",983), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2029change_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("CHANGE-CLASS",936), ECL_NIL, VVtemp[3], VVtemp[4], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2032change_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("CHANGE-CLASS",936), ECL_NIL, VVtemp[5], VVtemp[4], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2033update_instance_for_redefined_class,ECL_NIL,Cblock,4);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984), ECL_NIL, VVtemp[6], VVtemp[7], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2036update_instance_for_redefined_class,ECL_NIL,Cblock,4);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("UPDATE-INSTANCE-FOR-REDEFINED-CLASS",984), ECL_NIL, VVtemp[8], VVtemp[7], T0);
  ecl_cmp_defun(VV[31]);                          /*  UPDATE-INSTANCE         */
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(3, ECL_SYM("REINITIALIZE-INSTANCE",967), ECL_SYM("LAMBDA-LIST",1002), VVtemp[9]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2040reinitialize_instance,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("REINITIALIZE-INSTANCE",967), ECL_NIL, VVtemp[10], VVtemp[11], T0);
  ecl_cmp_defun(VV[32]);                          /*  SLOT-DEFINITIONS-COMPATIBLE-P */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2042make_instances_obsolete_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCES-OBSOLETE",954), ECL_NIL, VVtemp[10], VVtemp[10], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2043make_instances_obsolete_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-INSTANCES-OBSOLETE",954), ECL_NIL, VVtemp[12], VVtemp[10], T0);
  (void)0; /* No entry created for REMOVE-OPTIONAL-SLOT-ACCESSORS */
 }
}
