/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/fixup.lsp                      */
#include <ecl/ecl-cmp.h>
#include "clos/fixup.eclh"
/* function definition for REGISTER-METHOD-WITH-SPECIALIZERS                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2091register_method_with_specializers(cl_object v1method)
{
 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 v2;
  cl_object v3spec;
  cl_object v4;
  {
   cl_object v5;
   v5 = ecl_instance_ref((v1method),((cl_fixnum)(2)));
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v5;
  }
  v3spec = ECL_NIL;
  v4 = v2;
L7:;
  if (!(ecl_endp(v4))){
   goto L9;
  }
  goto L8;
L9:;
  v3spec = ECL_CONS_CAR(v4);
  {
   cl_object v5;
   v5 = ECL_CONS_CDR(v4);
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v4 = v5;
  }
  {
   cl_object v5cell;
   v5cell = ecl_instance_ref((v3spec),((cl_fixnum)(1)));
   {
    cl_object v6;
    v6 = ECL_NIL;
    {
     cl_object v7;
     v7 = v5cell;
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v7;
    }
    (ECL_CONS_CDR(T0)=v6,T0);
   }
   {
    cl_object v6;
    T0 = ecl_car(v5cell);
    T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
    v6 = cl_adjoin(4, v1method, T0, ECL_SYM("TEST",1353), T1);
    {
     cl_object v7;
     v7 = v5cell;
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v7;
    }
    (ECL_CONS_CAR(T0)=v6,T0);
   }
  }
  goto L7;
L8:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for FIXUP-EARLY-METHODS                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2126fixup_early_methods()
{
 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 v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[9]);
  goto L5;
L4:;
  {
   cl_object v2method_info;
   v2method_info = ecl_car(v1);
   {
    cl_object v3method_name;
    cl_object v4gfun;
    cl_object v5standard_method_class;
    v3method_name = ecl_car(v2method_info);
    v4gfun = cl_fdefinition(v3method_name);
    v5standard_method_class = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
    {
     cl_object v6;
     v6 = si_instance_class(v4gfun);
     T0 = ecl_instance_ref((v6),((cl_fixnum)(3)));
    }
    if (!((ECL_T)==(T0))){
     goto L13;
    }
    T0 = cl_find_class(1, ECL_SYM("STANDARD-GENERIC-FUNCTION",978));
    si_instance_class_set(v4gfun, T0);
    si_instance_sig_set(v4gfun);
    (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, v5standard_method_class, v4gfun, VV[16]) /*  (SETF SLOT-VALUE) */;
    (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_NIL, v4gfun, ECL_SYM("DOCSTRING",1655)) /*  (SETF SLOT-VALUE) */;
L13:;
    {
     cl_object v6;
     v6 = ecl_cdr(v2method_info);
     goto L23;
L22:;
     {
      cl_object v7method;
      v7method = ecl_car(v6);
      {
       cl_object v8old_class;
       v8old_class = si_instance_class(v7method);
       if (!(v8old_class==ECL_NIL)){
        goto L30;
       }
       T0 = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
       goto L29;
L30:;
       if (!(ECL_SYMBOLP(v8old_class))){
        goto L32;
       }
       T0 = cl_find_class(1, v8old_class);
       goto L29;
L32:;
       T0 = v8old_class;
L29:;
       si_instance_class_set(v7method, T0);
      }
      si_instance_sig_set(v4gfun);
      L2091register_method_with_specializers(v7method);
     }
     v6 = ecl_cdr(v6);
L23:;
     if (Null(v6)){
      goto L38;
     }
     goto L22;
L38:;
    }
   }
  }
  v1 = ecl_cdr(v1);
L5:;
  if (Null(v1)){
   goto L42;
  }
  goto L4;
L42:;
  value0 = cl_makunbound(VV[9]);
  return value0;
 }
}
static cl_object L2126fixup_early_methods_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[8]);
 {
  return L2126fixup_early_methods();
 }
}
/* function definition for SETF-FIND-CLASS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2127setf_find_class(cl_narg narg, cl_object v1new_value, cl_object v2name, ...)
{
 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[19]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[19]);
 {
  cl_object v3errorp;
  cl_object v4env;
  va_list args; va_start(args,v2name);
  {
   int i = 2;
   if (i >= narg) {
    v3errorp = ECL_NIL;
   } else {
    i++;
    v3errorp = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v4env = ECL_NIL;
   } else {
    i++;
    v4env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v5old_class;
   v5old_class = cl_find_class(3, v2name, ECL_NIL, v4env);
   if (Null(si_of_class_p(2, v5old_class, ECL_SYM("BUILT-IN-CLASS",933)))){
    goto L5;
   }
   cl_error(2, VV[20], v2name);
   goto L3;
L5:;
   {
    cl_object v6;
    v6 = (ECL_SYM("EQ",335)->symbol.gfdef);
    if (!((v2name)==(ECL_SYM("CLASS",937)))){
     goto L13;
    }
    goto L10;
L13:;
    goto L11;
L11:;
    if (!((v2name)==(ECL_SYM("BUILT-IN-CLASS",933)))){
     goto L7;
    }
    goto L8;
L10:;
   }
L8:;
   cl_error(2, VV[23], v2name);
   goto L3;
L7:;
   if (Null((cl_env_copy->function=(VV[24]->symbol.gfdef))->cfun.entry(1, v1new_value) /*  CLASSP */)){
    goto L16;
   }
   if (Null(v4env)){
    goto L18;
   }
   (cl_env_copy->function=(ECL_SYM("PROCLAIM-CLASS",1663)->symbol.gfdef))->cfun.entry(3, v2name, v1new_value, v4env) /*  PROCLAIM-CLASS */;
   goto L3;
L18:;
   si_hash_set(v2name, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CLASS-NAME-HASH-TABLE*",1020)), v1new_value);
   goto L3;
L16:;
   if (!(v1new_value==ECL_NIL)){
    goto L20;
   }
   if (Null(v4env)){
    goto L22;
   }
   (cl_env_copy->function=(ECL_SYM("PROCLAIM-CLASS",1663)->symbol.gfdef))->cfun.entry(3, v2name, ECL_NIL, v4env) /*  PROCLAIM-CLASS */;
   goto L3;
L22:;
   cl_remhash(v2name, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CLASS-NAME-HASH-TABLE*",1020)));
   goto L3;
L20:;
   cl_error(2, VV[25], v1new_value);
  }
L3:;
  value0 = v1new_value;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for METHOD-P                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2128method_p(cl_object v1method)
{
 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 = si_of_class_p(2, v1method, ECL_SYM("METHOD",958));
 return value0;
}
static cl_object L2128method_p_va(cl_narg narg, cl_object v2method, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[27]);
 {
  return L2128method_p(v2method);
 }
}
/* function definition for MAKE-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2129make_method(cl_object v1method_class, cl_object v2qualifiers, cl_object v3specializers, cl_object v4arglist, cl_object v5function, cl_object v6options)
{
 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 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
 value0 = cl_apply(15, T0, v1method_class, VV[29], ECL_NIL, VV[30], v2qualifiers, ECL_SYM("LAMBDA-LIST",1002), v4arglist, VV[31], v3specializers, ECL_SYM("FUNCTION",1273), v5function, ECL_SYM("ALLOW-OTHER-KEYS",1227), ECL_T, v6options);
 return value0;
}
static cl_object L2129make_method_va(cl_narg narg, cl_object v7method_class, cl_object v8qualifiers, cl_object v9specializers, cl_object v10arglist, cl_object v11function, cl_object v12options, ...)
{
 if (ecl_unlikely(narg!=6)) FEwrong_num_arguments(VV[32]);
 {
  return L2129make_method(v7method_class, v8qualifiers, v9specializers, v10arglist, v11function, v12options);
 }
}
/* function definition for ALL-KEYWORDS                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2130all_keywords(cl_object v1l)
{
 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 v2all_keys;
  v2all_keys = ECL_NIL;
  {
   cl_object v3l;
   v3l = ecl_cdr(v1l);
   goto L6;
L5:;
   T0 = ecl_car(v3l);
   v2all_keys = CONS(T0,v2all_keys);
   v3l = ecl_cddddr(v3l);
L6:;
   if (v3l==ECL_NIL) {
    goto L12;
   }
   goto L5;
L12:;
   value0 = v2all_keys;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for CONGRUENT-LAMBDA-P                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2131congruent_lambda_p(cl_object v1l1, cl_object v2l2)
{
 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 v3;                                   /*  R1                      */
  cl_object v4;                                   /*  OPTS1                   */
  cl_object v5;                                   /*  REST1                   */
  cl_object v6;                                   /*  KEY-FLAG1               */
  cl_object v7;                                   /*  KEYWORDS1               */
  cl_object v8;                                   /*  A-O-K1                  */
  value0 = si_process_lambda_list(v1l1, ECL_SYM("FUNCTION",398));
  {
   const int v9 = cl_env_copy->nvalues;
   v3 = value0;
   cl_object v10;
   v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
   v4 = v10;
   v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
   v5 = v10;
   v10 = (v9<=3)? ECL_NIL : cl_env_copy->values[3];
   v6 = v10;
   v10 = (v9<=4)? ECL_NIL : cl_env_copy->values[4];
   v7 = v10;
   v10 = (v9<=5)? ECL_NIL : cl_env_copy->values[5];
   v8 = v10;
  }
  {
   cl_object v9;                                  /*  R2                      */
   cl_object v10;                                 /*  OPTS2                   */
   cl_object v11;                                 /*  REST2                   */
   cl_object v12;                                 /*  KEY-FLAG2               */
   cl_object v13;                                 /*  KEYWORDS2               */
   cl_object v14;                                 /*  A-O-K2                  */
   value0 = si_process_lambda_list(v2l2, ECL_SYM("FUNCTION",398));
   {
    const int v15 = cl_env_copy->nvalues;
    v9 = value0;
    cl_object v16;
    v16 = (v15<=1)? ECL_NIL : cl_env_copy->values[1];
    v10 = v16;
    v16 = (v15<=2)? ECL_NIL : cl_env_copy->values[2];
    v11 = v16;
    v16 = (v15<=3)? ECL_NIL : cl_env_copy->values[3];
    v12 = v16;
    v16 = (v15<=4)? ECL_NIL : cl_env_copy->values[4];
    v13 = v16;
    v16 = (v15<=5)? ECL_NIL : cl_env_copy->values[5];
    v14 = v16;
   }
   {
    cl_fixnum v15;
    v15 = ecl_length(v9);
    {
     cl_fixnum v16;
     v16 = ecl_length(v3);
     if (!((v15)==(v16))){
      goto L5;
     }
    }
   }
   {
    cl_fixnum v15;
    v15 = ecl_length(v4);
    {
     cl_fixnum v16;
     v16 = ecl_length(v10);
     if (!((v15)==(v16))){
      goto L5;
     }
    }
   }
   if (!(v5==ECL_NIL)){
    goto L11;
   }
   T0 = ecl_make_bool(v6==ECL_NIL);
   goto L9;
L11:;
   T0 = ECL_NIL;
   goto L9;
L9:;
   if (!(v11==ECL_NIL)){
    goto L15;
   }
   T1 = ecl_make_bool(v12==ECL_NIL);
   goto L13;
L15:;
   T1 = ECL_NIL;
   goto L13;
L13:;
   if (!((T0)==(T1))){
    goto L5;
   }
   if (v6==ECL_NIL) {
    goto L18;
   }
   if (v12==ECL_NIL) {
    goto L18;
   }
   if (v8!=ECL_NIL) {
    goto L18;
   }
   if (v14!=ECL_NIL) {
    goto L18;
   }
   T0 = L2130all_keywords(v7);
   T1 = L2130all_keywords(v13);
   T2 = cl_set_difference(2, T0, T1);
   if (!(T2==ECL_NIL)){
    goto L5;
   }
   goto L17;
L18:;
L17:;
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L5:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L2131congruent_lambda_p_va(cl_narg narg, cl_object v3l1, cl_object v4l2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[34]);
 {
  return L2131congruent_lambda_p(v3l1, v4l2);
 }
}
/* function definition for ADD-METHOD                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2132add_method(cl_object v1gf, cl_object v2method)
{
 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 v3other_gf;
  v3other_gf = (cl_env_copy->function=(ECL_SYM("METHOD-GENERIC-FUNCTION",1608)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-GENERIC-FUNCTION */;
  if (v3other_gf==ECL_NIL) {
   goto L2;
  }
  if ((v3other_gf)==(v1gf)) {
   goto L2;
  }
  cl_error(4, VV[36], v2method, v3other_gf, v1gf);
 }
L2:;
 {
  cl_object v3new_lambda_list;
  v3new_lambda_list = (cl_env_copy->function=(ECL_SYM("METHOD-LAMBDA-LIST",1609)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-LAMBDA-LIST */;
  if (Null(cl_slot_boundp(v1gf, VV[37]))){
   goto L8;
  }
  {
   cl_object v4old_lambda_list;
   v4old_lambda_list = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-LAMBDA-LIST",1597)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-LAMBDA-LIST */;
   if (L2131congruent_lambda_p(v4old_lambda_list, v3new_lambda_list)!=ECL_NIL) {
    goto L6;
   }
   cl_error(5, VV[38], v2method, v1gf, v4old_lambda_list, v3new_lambda_list);
   goto L6;
  }
L8:;
  T0 = (cl_env_copy->function=(VV[39]->symbol.gfdef))->cfun.entry(1, v3new_lambda_list) /*  IMPLICIT-GENERIC-LAMBDA */;
  (cl_env_copy->function=(ECL_SYM("REINITIALIZE-INSTANCE",967)->symbol.gfdef))->cfun.entry(3, v1gf, ECL_SYM("LAMBDA-LIST",1002), T0) /*  REINITIALIZE-INSTANCE */;
 }
L6:;
 if (Null((cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-METHODS */)){
  goto L12;
 }
 {
  cl_object v3method_qualifiers;
  cl_object v4specializers;
  cl_object v5found;
  v3method_qualifiers = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-QUALIFIERS */;
  v4specializers = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-SPECIALIZERS */;
  v5found = (cl_env_copy->function=(ECL_SYM("FIND-METHOD",948)->symbol.gfdef))->cfun.entry(4, v1gf, v3method_qualifiers, v4specializers, ECL_NIL) /*  FIND-METHOD */;
  if (Null(v5found)){
   goto L12;
  }
  (cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(2, v1gf, v5found) /*  REMOVE-METHOD */;
 }
L12:;
 {
  cl_object v3;
  T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-METHODS */;
  v3 = CONS(v2method,T0);
  (cl_env_copy->function=ECL_CONS_CAR(VV[93]))->cfun.entry(2, v3, v1gf) /*  (SETF GENERIC-FUNCTION-METHODS) */;
 }
 (cl_env_copy->function=ECL_CONS_CAR(VV[94]))->cfun.entry(2, v1gf, v2method) /*  (SETF METHOD-GENERIC-FUNCTION) */;
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-SPECIALIZERS */;
  goto L25;
L24:;
  {
   cl_object v4spec;
   v4spec = ecl_car(v3);
   (cl_env_copy->function=(ECL_SYM("ADD-DIRECT-METHOD",1560)->symbol.gfdef))->cfun.entry(2, v4spec, v2method) /*  ADD-DIRECT-METHOD */;
  }
  v3 = ecl_cdr(v3);
L25:;
  if (Null(v3)){
   goto L32;
  }
  goto L24;
L32:;
 }
 (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1gf) /*  COMPUTE-G-F-SPEC-LIST */;
 (cl_env_copy->function=(VV[43]->symbol.gfdef))->cfun.entry(1, v1gf) /*  SET-GENERIC-FUNCTION-DISPATCH */;
 T0 = cl_list(2, ECL_SYM("ADD-METHOD",932), v2method);
 (cl_env_copy->function=(VV[44]->symbol.gfdef))->cfun.entry(2, v1gf, T0) /*  UPDATE-DEPENDENTS */;
 value0 = v1gf;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2132add_method_va(cl_narg narg, cl_object v3gf, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[45]);
 {
  return L2132add_method(v3gf, v4method);
 }
}
/* function definition for REMOVE-METHOD                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2133remove_method(cl_object v1gf, cl_object v2method)
{
 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("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-METHODS */;
  v3 = cl_delete(2, v2method, T0);
  (cl_env_copy->function=ECL_CONS_CAR(VV[93]))->cfun.entry(2, v3, v1gf) /*  (SETF GENERIC-FUNCTION-METHODS) */;
 }
 (cl_env_copy->function=ECL_CONS_CAR(VV[94]))->cfun.entry(2, ECL_NIL, v2method) /*  (SETF METHOD-GENERIC-FUNCTION) */;
 si_clear_gfun_hash(v1gf);
 {
  cl_object v3;
  cl_object v4spec;
  cl_object v5;
  {
   cl_object v6;
   v6 = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, v2method) /*  METHOD-SPECIALIZERS */;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4spec = ECL_NIL;
  v5 = v3;
L12:;
  if (!(ecl_endp(v5))){
   goto L14;
  }
  goto L13;
L14:;
  v4spec = 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;
  }
  (cl_env_copy->function=(ECL_SYM("REMOVE-DIRECT-METHOD",1614)->symbol.gfdef))->cfun.entry(2, v4spec, v2method) /*  REMOVE-DIRECT-METHOD */;
  goto L12;
L13:;
 }
 (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1gf) /*  COMPUTE-G-F-SPEC-LIST */;
 (cl_env_copy->function=(VV[43]->symbol.gfdef))->cfun.entry(1, v1gf) /*  SET-GENERIC-FUNCTION-DISPATCH */;
 T0 = cl_list(2, ECL_SYM("REMOVE-METHOD",968), v2method);
 (cl_env_copy->function=(VV[44]->symbol.gfdef))->cfun.entry(2, v1gf, T0) /*  UPDATE-DEPENDENTS */;
 value0 = v1gf;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2133remove_method_va(cl_narg narg, cl_object v3gf, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[46]);
 {
  return L2133remove_method(v3gf, v4method);
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2138_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2138_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2138_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA161                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2148__lambda161(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4method;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v5;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4method = v5;
   }
   if (Null(v2)){
    goto L15;
   }
   si_dm_too_many_arguments(v1args);
L15:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (Null(si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978)))){
    goto L20;
   }
   if (si_of_class_p(2, v4method, ECL_SYM("STANDARD-METHOD",979))!=ECL_NIL) {
    goto L1;
   }
   goto L17;
L20:;
   goto L17;
L17:;
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2153_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2153_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2153_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA190                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2163__lambda190(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4method;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v5;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4method = v5;
   }
   if (Null(v2)){
    goto L15;
   }
   si_dm_too_many_arguments(v1args);
L15:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (Null(si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978)))){
    goto L20;
   }
   if (si_of_class_p(2, v4method, ECL_SYM("STANDARD-METHOD",979))!=ECL_NIL) {
    goto L1;
   }
   goto L17;
L20:;
   goto L17;
L17:;
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2168_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2168_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2168_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA219                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2178__lambda219(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4qualifiers;
   cl_object v5specializers;
   cl_object v6error;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v7;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4qualifiers = v7;
   }
   if (!(v2==ECL_NIL)){
    goto L16;
   }
   si_dm_too_few_arguments(v1args);
L16:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v5specializers = v7;
   }
   if (Null(v2)){
    goto L22;
   }
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v6error = v7;
    goto L21;
   }
L22:;
   v6error = ECL_NIL;
L21:;
   if (Null(v2)){
    goto L27;
   }
   si_dm_too_many_arguments(v1args);
L27:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2183_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2183_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2183_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA250                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2193__lambda250(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v4;
    v4 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v4;
   }
   if (Null(v2)){
    goto L9;
   }
   si_dm_too_many_arguments(v1args);
L9:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2198_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2198_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2198_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA278                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2208__lambda278(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v4;
    v4 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v4;
   }
   if (Null(v2)){
    goto L9;
   }
   si_dm_too_many_arguments(v1args);
L9:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2213_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2213_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2213_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA306                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2223__lambda306(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3name;
   cl_object v4gf;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3name = v5;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4gf = v5;
   }
   if (Null(v2)){
    goto L15;
   }
   si_dm_too_many_arguments(v1args);
L15:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v4gf, ECL_SYM("GENERIC-FUNCTION",949))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2228_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2228_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2228_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA335                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2238__lambda335(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4method_combination_type_name;
   cl_object v5method_combination_options;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v6;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4method_combination_type_name = v6;
   }
   if (!(v2==ECL_NIL)){
    goto L16;
   }
   si_dm_too_few_arguments(v1args);
L16:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v5method_combination_options = v6;
   }
   if (Null(v2)){
    goto L21;
   }
   si_dm_too_many_arguments(v1args);
L21:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2243_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2243_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2243_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA365                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2253__lambda365(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4method;
   cl_object v5lambda_form;
   cl_object v6environment;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v7;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4method = v7;
   }
   if (!(v2==ECL_NIL)){
    goto L16;
   }
   si_dm_too_few_arguments(v1args);
L16:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v5lambda_form = v7;
   }
   if (!(v2==ECL_NIL)){
    goto L22;
   }
   si_dm_too_few_arguments(v1args);
L22:;
   {
    cl_object v7;
    v7 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v6environment = v7;
   }
   if (Null(v2)){
    goto L27;
   }
   si_dm_too_many_arguments(v1args);
L27:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (Null(si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978)))){
    goto L32;
   }
   if (si_of_class_p(2, v4method, ECL_SYM("STANDARD-METHOD",979))!=ECL_NIL) {
    goto L1;
   }
   goto L29;
L32:;
   goto L29;
L29:;
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2258_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2258_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2258_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA396                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2268__lambda396(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4classes;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v5;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4classes = v5;
   }
   if (Null(v2)){
    goto L15;
   }
   si_dm_too_many_arguments(v1args);
L15:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2273_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2273_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2273_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA425                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2283__lambda425(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4arguments;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v5;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v5;
    v5 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4arguments = v5;
   }
   if (Null(v2)){
    goto L15;
   }
   si_dm_too_many_arguments(v1args);
L15:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function (SETF METHOD-FUNCTION)                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2288_setf_method_function_(cl_object v1value, cl_object v2object)
{
 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 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC2288_setf_method_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[49]);
 {
  return LC2288_setf_method_function_(v3value, v4object);
 }
}
/* closure LAMBDA454                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2298__lambda454(cl_narg narg, ...)
{
 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;                                     /*  GENERIC-FUNCTION        */
 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);
  {
   cl_object v2;
   cl_object v3gf;
   cl_object v4method_combination;
   cl_object v5applicable_methods;
   v2 = v1args;
   if (!(v2==ECL_NIL)){
    goto L4;
   }
   si_dm_too_few_arguments(v1args);
L4:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v3gf = v6;
   }
   if (!(v2==ECL_NIL)){
    goto L10;
   }
   si_dm_too_few_arguments(v1args);
L10:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v4method_combination = v6;
   }
   if (!(v2==ECL_NIL)){
    goto L16;
   }
   si_dm_too_few_arguments(v1args);
L16:;
   {
    cl_object v6;
    v6 = ecl_car(v2);
    v2 = ecl_cdr(v2);
    v5applicable_methods = v6;
   }
   if (Null(v2)){
    goto L21;
   }
   si_dm_too_many_arguments(v1args);
L21:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[53])==ECL_NIL) {
    goto L1;
   }
   if (si_of_class_p(2, v3gf, ECL_SYM("STANDARD-GENERIC-FUNCTION",978))!=ECL_NIL) {
    goto L1;
   }
   T0 = (ECL_SYM("NO-APPLICABLE-METHOD",963)->symbol.gfdef);
   cl_apply(3, T0, ECL_CONS_CAR(CLV1), v1args);
  }
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), v1args);
  return value0;
 }
 }
}
/* local function READER-METHOD-CLASS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2299reader_method_class(cl_narg narg, cl_object v1class, cl_object v2direct_slot, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("READER-METHOD-CLASS",1612));
 {
  va_list args; va_start(args,v2direct_slot);
  va_end(args);
  {
   cl_object v3;
   T1 = cl_class_of(v1class);
   v3 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T1) /*  CLASS-NAME */;
   if (!((v3)==(ECL_SYM("STANDARD-CLASS",977)))){
    goto L8;
   }
   goto L5;
L8:;
   goto L6;
L6:;
   if (!((v3)==(ECL_SYM("FUNCALLABLE-STANDARD-CLASS",1592)))){
    goto L12;
   }
   goto L5;
L12:;
   goto L10;
L10:;
   if (!((v3)==(ECL_SYM("STRUCTURE-CLASS",981)))){
    goto L2;
   }
   goto L3;
L5:;
  }
L3:;
  T0 = ECL_SYM("STANDARD-OPTIMIZED-READER-METHOD",1643);
  goto L1;
L2:;
  T0 = ECL_SYM("STANDARD-READER-METHOD",1640);
L1:;
  value0 = cl_find_class(1, T0);
  return value0;
 }
}
/* local function WRITER-METHOD-CLASS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2300writer_method_class(cl_narg narg, cl_object v1class, cl_object v2direct_slot, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("WRITER-METHOD-CLASS",1652));
 {
  va_list args; va_start(args,v2direct_slot);
  va_end(args);
  {
   cl_object v3;
   T1 = cl_class_of(v1class);
   v3 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T1) /*  CLASS-NAME */;
   if (!((v3)==(ECL_SYM("STANDARD-CLASS",977)))){
    goto L8;
   }
   goto L5;
L8:;
   goto L6;
L6:;
   if (!((v3)==(ECL_SYM("FUNCALLABLE-STANDARD-CLASS",1592)))){
    goto L12;
   }
   goto L5;
L12:;
   goto L10;
L10:;
   if (!((v3)==(ECL_SYM("STRUCTURE-CLASS",981)))){
    goto L2;
   }
   goto L3;
L5:;
  }
L3:;
  T0 = ECL_SYM("STANDARD-OPTIMIZED-WRITER-METHOD",1644);
  goto L1;
L2:;
  T0 = ECL_SYM("STANDARD-READER-METHOD",1640);
L1:;
  value0 = cl_find_class(1, T0);
  return value0;
 }
}
/* local function NO-APPLICABLE-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2301no_applicable_method(cl_narg narg, cl_object v1gf, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("NO-APPLICABLE-METHOD",963));
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1gf,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-NAME */;
  {
   cl_object v3;
   v3 = (ECL_SYM("TYPE-OF",876)->symbol.gfdef);
   {
    cl_object v4;
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = v2args;
     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;
L10:;
     if (!(ecl_endp(v6))){
      goto L12;
     }
     goto L11;
L12:;
     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 L10;
L11:;
     T1 = ecl_cdr(v7);
     goto L1;
    }
   }
  }
L1:;
  value0 = cl_error(3, VV[68], T0, T1);
  return value0;
 }
}
/* local function NO-NEXT-METHOD                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2302no_next_method(cl_narg narg, cl_object v1gf, cl_object v2method, ...)
{
 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("NO-NEXT-METHOD",964));
 {
  cl_object v3args;
  ecl_va_list args; ecl_va_start(args,v2method,narg,2);
  v3args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = cl_error(3, VV[72], v2method, v3args);
  return value0;
 }
}
/* function definition for NO-PRIMARY-METHOD                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2303no_primary_method(cl_narg narg, cl_object v1gf, ...)
{
 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(VV[73]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1gf,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-NAME */;
  value0 = cl_error(3, VV[74], T0, v2args);
  return value0;
 }
}
/* local function ADD-DEPENDENT                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2304add_dependent(cl_object v1c, cl_object v2dep)
{
 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=(VV[12]->symbol.gfdef))->cfun.entry(1, v1c) /*  CLASS-DEPENDENTS */;
  v3 = cl_adjoin(2, v2dep, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[95]))->cfun.entry(2, v3, v1c) /*  (SETF CLASS-DEPENDENTS) */;
  return value0;
 }
}
static cl_object LC2304add_dependent_va(cl_narg narg, cl_object v4c, cl_object v5dep, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("ADD-DEPENDENT",1559));
 {
  return LC2304add_dependent(v4c, v5dep);
 }
}
/* local function ADD-DEPENDENT                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2305add_dependent(cl_object v1c, cl_object v2dependent)
{
 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=(VV[77]->symbol.gfdef))->cfun.entry(1, v1c) /*  GENERIC-FUNCTION-DEPENDENTS */;
  v3 = cl_adjoin(2, v2dependent, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[96]))->cfun.entry(2, v3, v1c) /*  (SETF GENERIC-FUNCTION-DEPENDENTS) */;
  return value0;
 }
}
static cl_object LC2305add_dependent_va(cl_narg narg, cl_object v4c, cl_object v5dependent, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("ADD-DEPENDENT",1559));
 {
  return LC2305add_dependent(v4c, v5dependent);
 }
}
/* local function REMOVE-DEPENDENT                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2306remove_dependent(cl_object v1c, cl_object v2dep)
{
 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=(VV[12]->symbol.gfdef))->cfun.entry(1, v1c) /*  CLASS-DEPENDENTS */;
  v3 = cl_remove(2, v2dep, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[95]))->cfun.entry(2, v3, v1c) /*  (SETF CLASS-DEPENDENTS) */;
  return value0;
 }
}
static cl_object LC2306remove_dependent_va(cl_narg narg, cl_object v4c, cl_object v5dep, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("REMOVE-DEPENDENT",1613));
 {
  return LC2306remove_dependent(v4c, v5dep);
 }
}
/* local function REMOVE-DEPENDENT                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2307remove_dependent(cl_object v1c, cl_object v2dep)
{
 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=(VV[77]->symbol.gfdef))->cfun.entry(1, v1c) /*  GENERIC-FUNCTION-DEPENDENTS */;
  v3 = cl_remove(2, v2dep, T0);
  value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[96]))->cfun.entry(2, v3, v1c) /*  (SETF GENERIC-FUNCTION-DEPENDENTS) */;
  return value0;
 }
}
static cl_object LC2307remove_dependent_va(cl_narg narg, cl_object v4c, cl_object v5dep, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("REMOVE-DEPENDENT",1613));
 {
  return LC2307remove_dependent(v4c, v5dep);
 }
}
/* local function MAP-DEPENDENTS                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2308map_dependents(cl_object v1c, cl_object v2function)
{
 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;
  v3 = (cl_env_copy->function=(VV[12]->symbol.gfdef))->cfun.entry(1, v1c) /*  CLASS-DEPENDENTS */;
  goto L5;
L4:;
  {
   cl_object v4d;
   v4d = ecl_car(v3);
   ecl_function_dispatch(cl_env_copy,v2function)(1, v4d);
  }
  v3 = ecl_cdr(v3);
L5:;
  if (Null(v3)){
   goto L12;
  }
  goto L4;
L12:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2308map_dependents_va(cl_narg narg, cl_object v4c, cl_object v5function, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("MAP-DEPENDENTS",1605));
 {
  return LC2308map_dependents(v4c, v5function);
 }
}
/* local function MAP-DEPENDENTS                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2309map_dependents(cl_object v1c, cl_object v2function)
{
 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;
  v3 = (cl_env_copy->function=(VV[77]->symbol.gfdef))->cfun.entry(1, v1c) /*  GENERIC-FUNCTION-DEPENDENTS */;
  goto L5;
L4:;
  {
   cl_object v4d;
   v4d = ecl_car(v3);
   ecl_function_dispatch(cl_env_copy,v2function)(1, v4d);
  }
  v3 = ecl_cdr(v3);
L5:;
  if (Null(v3)){
   goto L12;
  }
  goto L4;
L12:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2309map_dependents_va(cl_narg narg, cl_object v4c, cl_object v5function, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("MAP-DEPENDENTS",1605));
 {
  return LC2309map_dependents(v4c, v5function);
 }
}
/* function definition for RECURSIVELY-UPDATE-CLASSES                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2310recursively_update_classes(cl_object v1a_class)
{
 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_slot_makunbound(v1a_class, VV[81]);
 {
  cl_object v2;
  v2 = (VV[80]->symbol.gfdef);
  {
   cl_object v3;
   v3 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v1a_class) /*  CLASS-DIRECT-SUBCLASSES */;
   {
    cl_object v4;
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = v3;
     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;
L10:;
    if (!(ecl_endp(v6))){
     goto L12;
    }
    goto L11;
L12:;
    v5 = ECL_CONS_CAR(v6);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v7;
    }
    ecl_function_dispatch(cl_env_copy,v2)(1, v5);
    goto L10;
L11:;
    value0 = v3;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L2310recursively_update_classes_va(cl_narg narg, cl_object v7a_class, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[80]);
 {
  return L2310recursively_update_classes(v7a_class);
 }
}
/* local function UPDATE-DEPENDENT                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2311update_dependent(cl_narg narg, cl_object v1object, cl_object v2dep, ...)
{
 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("UPDATE-DEPENDENT",1649));
 {
  cl_object v3added_method;
  cl_object v4am_p;
  cl_object v5removed_method;
  cl_object v6rm_p;
  ecl_va_list args; ecl_va_start(args,v2dep,narg,2);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,LC2311update_dependentkeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   v3added_method = keyvars[0];
   v4am_p = keyvars[2];
   v5removed_method = keyvars[1];
   v6rm_p = keyvars[3];
  }
  {
   cl_object v7method;
   if (Null(v4am_p)){
    goto L2;
   }
   v7method = v3added_method;
   goto L1;
L2:;
   if (Null(v6rm_p)){
    goto L4;
   }
   v7method = v5removed_method;
   goto L1;
L4:;
   v7method = ECL_NIL;
L1:;
   if (Null(v7method)){
    goto L6;
   }
   {
    cl_object v8spec;
    T0 = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, v7method) /*  METHOD-SPECIALIZERS */;
    v8spec = ecl_car(T0);
    if (Null((cl_env_copy->function=(VV[24]->symbol.gfdef))->cfun.entry(1, v8spec) /*  CLASSP */)){
     goto L9;
    }
    value0 = L2310recursively_update_classes(v8spec);
    return value0;
L9:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L6:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function METHOD-SPECIALIZERS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2086method_specializers(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(2)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2086method_specializers_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-SPECIALIZERS",1610));
 {
  return LC2086method_specializers(v2object);
 }
}
/* local function SPECIALIZER-METHOD-HOLDER                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2074specializer_method_holder(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(1)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2074specializer_method_holder_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[2]);
 {
  return LC2074specializer_method_holder(v2object);
 }
}
/* local function CLASS-ID                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2121class_id(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(3)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2121class_id_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[15]);
 {
  return LC2121class_id(v2object);
 }
}
#include "clos/fixup.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecloXDyXt9wisGp9_yr50M881(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;FIXUP.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecloXDyXt9wisGp9_yr50M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
  cl_object volatile CLV0, CLV1;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  (void)0; /* No entry created for REGISTER-METHOD-WITH-SPECIALIZERS */
  ecl_cmp_defun(VV[83]);                          /*  FIXUP-EARLY-METHODS     */
  L2126fixup_early_methods();
  ecl_cmp_defun(VV[84]);                          /*  SETF-FIND-CLASS         */
  ecl_cmp_defun(VV[85]);                          /*  METHOD-P                */
  ecl_cmp_defun(VV[86]);                          /*  MAKE-METHOD             */
  (void)0; /* No entry created for ALL-KEYWORDS */
  ecl_cmp_defun(VV[87]);                          /*  CONGRUENT-LAMBDA-P      */
  ecl_cmp_defun(VV[88]);                          /*  ADD-METHOD              */
  ecl_cmp_defun(VV[89]);                          /*  REMOVE-METHOD           */
  {
   cl_object v1method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("ADD-METHOD",932));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[1]);
   v1method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v2;
    v2 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v1method, ecl_make_int8_t(4), v2);
   }
   si_fset(2, ECL_SYM("ADD-METHOD",932), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("ADD-METHOD",932), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v2;
    v2 = ecl_make_cclosure_va((cl_objectfn)LC2148__lambda161,env1,Cblock,0);
    T0 = v2;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v2method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("REMOVE-METHOD",968));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[1]);
   v2method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v3;
    v3 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v2method, ecl_make_int8_t(4), v3);
   }
   si_fset(2, ECL_SYM("REMOVE-METHOD",968), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("REMOVE-METHOD",968), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v3;
    v3 = ecl_make_cclosure_va((cl_objectfn)LC2163__lambda190,env1,Cblock,0);
    T0 = v3;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v3method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("FIND-METHOD",948));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[2]);
   v3method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v4;
    v4 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v3method, ecl_make_int8_t(4), v4);
   }
   si_fset(2, ECL_SYM("FIND-METHOD",948), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("FIND-METHOD",948), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC2178__lambda219,env1,Cblock,0);
    T0 = v4;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v4method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("COMPUTE-DISCRIMINATING-FUNCTION",1574));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[3]);
   v4method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v5;
    v5 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v4method, ecl_make_int8_t(4), v5);
   }
   si_fset(2, ECL_SYM("COMPUTE-DISCRIMINATING-FUNCTION",1574), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("COMPUTE-DISCRIMINATING-FUNCTION",1574), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v5;
    v5 = ecl_make_cclosure_va((cl_objectfn)LC2193__lambda250,env1,Cblock,0);
    T0 = v5;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v5method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("GENERIC-FUNCTION-METHOD-CLASS",1598));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[3]);
   v5method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v6;
    v6 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v5method, ecl_make_int8_t(4), v6);
   }
   si_fset(2, ECL_SYM("GENERIC-FUNCTION-METHOD-CLASS",1598), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("GENERIC-FUNCTION-METHOD-CLASS",1598), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v6;
    v6 = ecl_make_cclosure_va((cl_objectfn)LC2208__lambda278,env1,Cblock,0);
    T0 = v6;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v6method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(VVtemp[4]);
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[5]);
   v6method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v6method, ecl_make_int8_t(4), v7);
   }
   si_fset(2, VVtemp[4], ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, VVtemp[4], ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v7;
    v7 = ecl_make_cclosure_va((cl_objectfn)LC2223__lambda306,env1,Cblock,0);
    T0 = v7;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v7method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("FIND-METHOD-COMBINATION",1590));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[6]);
   v7method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v8;
    v8 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v7method, ecl_make_int8_t(4), v8);
   }
   si_fset(2, ECL_SYM("FIND-METHOD-COMBINATION",1590), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("FIND-METHOD-COMBINATION",1590), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v8;
    v8 = ecl_make_cclosure_va((cl_objectfn)LC2238__lambda335,env1,Cblock,0);
    T0 = v8;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v8method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("MAKE-METHOD-LAMBDA",1604));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[7]);
   v8method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v9;
    v9 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v8method, ecl_make_int8_t(4), v9);
   }
   si_fset(2, ECL_SYM("MAKE-METHOD-LAMBDA",1604), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("MAKE-METHOD-LAMBDA",1604), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v9;
    v9 = ecl_make_cclosure_va((cl_objectfn)LC2253__lambda365,env1,Cblock,0);
    T0 = v9;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v9method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("COMPUTE-APPLICABLE-METHODS-USING-CLASSES",1571));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[8]);
   v9method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v10;
    v10 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v9method, ecl_make_int8_t(4), v10);
   }
   si_fset(2, ECL_SYM("COMPUTE-APPLICABLE-METHODS-USING-CLASSES",1571), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("COMPUTE-APPLICABLE-METHODS-USING-CLASSES",1571), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v10;
    v10 = ecl_make_cclosure_va((cl_objectfn)LC2268__lambda396,env1,Cblock,0);
    T0 = v10;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v10method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("COMPUTE-APPLICABLE-METHODS",940));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[9]);
   v10method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v10method, ecl_make_int8_t(4), v11);
   }
   si_fset(2, ECL_SYM("COMPUTE-APPLICABLE-METHODS",940), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("COMPUTE-APPLICABLE-METHODS",940), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v11;
    v11 = ecl_make_cclosure_va((cl_objectfn)LC2283__lambda425,env1,Cblock,0);
    T0 = v11;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object v11method;
   cl_object env1 = env0;
   T0 = cl_fdefinition(ECL_SYM("COMPUTE-EFFECTIVE-METHOD",1575));
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  OLD-FUNCTION            */
   T0 = cl_list(3, ECL_SYM("DEFMETHOD",944), VV[47], VVtemp[10]);
   v11method = cl_eval(T0);
   T0 = cl_fdefinition(VV[47]);
   CLV1 = env1 = CONS(T0,env1);                   /*  GENERIC-FUNCTION        */
   {
    cl_object v12;
    v12 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  WRAPPED-METHOD-FUNCTION */;
    si_instance_set(v11method, ecl_make_int8_t(4), v12);
   }
   si_fset(2, ECL_SYM("COMPUTE-EFFECTIVE-METHOD",1575), ECL_CONS_CAR(CLV1));
   (cl_env_copy->function=ECL_CONS_CAR(VV[90]))->cfun.entry(3, ECL_SYM("COMPUTE-EFFECTIVE-METHOD",1575), ECL_CONS_CAR(CLV1), ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
   {
    cl_object v12;
    v12 = ecl_make_cclosure_va((cl_objectfn)LC2298__lambda454,env1,Cblock,0);
    T0 = v12;
   }
   clos_set_funcallable_instance_function(ECL_CONS_CAR(CLV1), T0);
   cl_fmakunbound(VV[47]);
  }
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2299reader_method_class,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("READER-METHOD-CLASS",1612), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2300writer_method_class,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("WRITER-METHOD-CLASS",1652), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2301no_applicable_method,ECL_NIL,Cblock,1);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("NO-APPLICABLE-METHOD",963), ECL_NIL, VVtemp[13], VVtemp[14], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2302no_next_method,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("NO-NEXT-METHOD",964), ECL_NIL, VVtemp[15], VVtemp[16], T0);
  ecl_cmp_defun(VV[91]);                          /*  NO-PRIMARY-METHOD       */
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2304add_dependent_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("ADD-DEPENDENT",1559), ECL_NIL, VVtemp[17], VVtemp[18], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2305add_dependent_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("ADD-DEPENDENT",1559), ECL_NIL, VVtemp[19], VVtemp[20], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2306remove_dependent_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("REMOVE-DEPENDENT",1613), ECL_NIL, VVtemp[17], VVtemp[18], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2307remove_dependent_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("REMOVE-DEPENDENT",1613), ECL_NIL, VVtemp[21], VVtemp[18], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2308map_dependents_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("MAP-DEPENDENTS",1605), ECL_NIL, VVtemp[17], VVtemp[22], T0);
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2309map_dependents_va,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("MAP-DEPENDENTS",1605), ECL_NIL, VVtemp[21], VVtemp[22], T0);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(3, ECL_SYM("UPDATE-DEPENDENT",1649), ECL_SYM("LAMBDA-LIST",1002), VVtemp[23]) /*  ENSURE-GENERIC-FUNCTION */;
  T0 = ECL_SYM("MAP-DEPENDENTS",1605);
  ecl_cmp_setq(cl_env_copy,VV[53],T0);
  clos_load_defclass(VV[79], ECL_NIL, ECL_NIL, ECL_NIL);
  ecl_cmp_defun(VV[92]);                          /*  RECURSIVELY-UPDATE-CLASSES */
  {
   cl_object volatile v12;
   v12 = ecl_make_cfun_va((cl_objectfn)LC2311update_dependent,ECL_NIL,Cblock,2);
   T0 = v12;
  }
  clos_install_method(5, ECL_SYM("UPDATE-DEPENDENT",1649), ECL_NIL, VVtemp[24], VVtemp[25], T0);
  {
   cl_object v12x;
   v12x = (cl_env_copy->function=(ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef))->cfun.entry(1, VV[79]) /*  MAKE-INSTANCE */;
   T0 = (ECL_SYM("SHARED-INITIALIZE",969)->symbol.gfdef);
   (cl_env_copy->function=(ECL_SYM("ADD-DEPENDENT",1559)->symbol.gfdef))->cfun.entry(2, T0, v12x) /*  ADD-DEPENDENT */;
   T0 = (ECL_SYM("INITIALIZE-INSTANCE",951)->symbol.gfdef);
   (cl_env_copy->function=(ECL_SYM("ADD-DEPENDENT",1559)->symbol.gfdef))->cfun.entry(2, T0, v12x) /*  ADD-DEPENDENT */;
   T0 = (ECL_SYM("ALLOCATE-INSTANCE",931)->symbol.gfdef);
   (cl_env_copy->function=(ECL_SYM("ADD-DEPENDENT",1559)->symbol.gfdef))->cfun.entry(2, T0, v12x) /*  ADD-DEPENDENT */;
  }
 }
}
