/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/kernel.lsp                     */
#include <ecl/ecl-cmp.h>
#include "clos/kernel.eclh"
/* function definition for SETF-FIND-CLASS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1457setf_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[1]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[1]);
 {
  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(v5old_class)){
    goto L5;
   }
   if (si_of_class_p(2, v5old_class, ECL_SYM("BUILT-IN-CLASS",933))!=ECL_NIL) {
    goto L8;
   }
   {
    cl_object v6;
    v6 = (ECL_SYM("EQ",335)->symbol.gfdef);
    if (!((v2name)==(ECL_SYM("CLASS",937)))){
     goto L14;
    }
    goto L11;
L14:;
    goto L12;
L12:;
    if (!((v2name)==(ECL_SYM("BUILT-IN-CLASS",933)))){
     goto L5;
    }
    goto L6;
L11:;
    goto L6;
   }
L8:;
L6:;
   if ((v1new_value)==(v5old_class)) {
    goto L3;
   }
   cl_error(2, VV[4], v2name);
   goto L3;
L5:;
   if (Null(L1459classp(v1new_value))){
    goto L18;
   }
   if (Null(v4env)){
    goto L20;
   }
   (cl_env_copy->function=(ECL_SYM("PROCLAIM-CLASS",1663)->symbol.gfdef))->cfun.entry(3, v2name, v1new_value, v4env) /*  PROCLAIM-CLASS */;
   goto L3;
L20:;
   si_hash_set(v2name, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CLASS-NAME-HASH-TABLE*",1020)), v1new_value);
   goto L3;
L18:;
   if (!(v1new_value==ECL_NIL)){
    goto L22;
   }
   if (Null(v4env)){
    goto L24;
   }
   (cl_env_copy->function=(ECL_SYM("PROCLAIM-CLASS",1663)->symbol.gfdef))->cfun.entry(3, v2name, ECL_NIL, v4env) /*  PROCLAIM-CLASS */;
   goto L3;
L24:;
   cl_remhash(v2name, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CLASS-NAME-HASH-TABLE*",1020)));
   goto L3;
L22:;
   cl_error(2, VV[6], v1new_value);
  }
L3:;
  value0 = v1new_value;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function LAMBDA14                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1458__lambda14(cl_narg narg, cl_object v1v, ...)
{
 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[8]);
 {
  cl_object v2x;
  ecl_va_list args; ecl_va_start(args,v1v,narg,1);
  v2x = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = cl_listX(3, VV[1], v1v, v2x);
  return value0;
 }
}
/* function definition for CLASSP                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1459classp(cl_object v1obj)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_INSTANCEP(v1obj))){
  goto L3;
 }
 {
  cl_object v2topmost;
  v2topmost = cl_find_class(2, ECL_SYM("CLASS",937), ECL_NIL);
  if (v2topmost==ECL_NIL) {
   goto L7;
  }
  T0 = si_instance_class(v1obj);
  if (Null(si_subclassp(2, T0, v2topmost))){
   goto L3;
  }
  goto L5;
L7:;
 }
L5:;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1459classp_va(cl_narg narg, cl_object v2obj, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[5]);
 {
  return L1459classp(v2obj);
 }
}
/* function definition for INSTALL-METHOD                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object clos_install_method(cl_narg narg, cl_object v1name, cl_object v2qualifiers, cl_object v3specializers, cl_object v4lambda_list, cl_object v5fun, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<5)) FEwrong_num_arguments(VV[10]);
 {
  cl_object v6options;
  ecl_va_list args; ecl_va_start(args,v5fun,narg,5);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v1name,env0);                /*  NAME                    */
  CLV1 = env0 = CONS(v3specializers,env0);        /*  SPECIALIZERS            */
  v6options = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v7gf;
   cl_object v8fun;
   cl_object v9specializers;
   cl_object v10method;
   v7gf = (cl_env_copy->function=(VV[27]->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  ENSURE-GENERIC-FUNCTION */;
   v8fun = L1462wrapped_method_function(v5fun);
   {
    cl_object v11;
    {
     cl_object v12;
     v12 = ecl_make_cclosure_va((cl_objectfn)LC1460__lambda23,env0,Cblock,1);
     v11 = v12;
    }
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = ECL_CONS_CAR(CLV1);
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
     {
      cl_object v15;
      cl_object v16;
      v15 = ecl_list1(ECL_NIL);
      v16 = v15;
L12:;
      if (!(ecl_endp(v14))){
       goto L14;
      }
      goto L13;
L14:;
      v13 = ECL_CONS_CAR(v14);
      {
       cl_object v17;
       v17 = ECL_CONS_CDR(v14);
       if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v14 = v17;
      }
      {
       cl_object v17;
       v17 = v16;
       if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v17;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
      v16 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v16,T0);
      goto L12;
L13:;
      v9specializers = ecl_cdr(v15);
      goto L3;
     }
    }
   }
L3:;
   T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHOD-CLASS",1598)->symbol.gfdef))->cfun.entry(1, v7gf) /*  GENERIC-FUNCTION-METHOD-CLASS */;
   v10method = (cl_env_copy->function=(ECL_SYM("MAKE-METHOD",957)->symbol.gfdef))->cfun.entry(6, T0, v2qualifiers, v9specializers, v4lambda_list, v8fun, v6options) /*  MAKE-METHOD */;
   (cl_env_copy->function=(ECL_SYM("ADD-METHOD",932)->symbol.gfdef))->cfun.entry(2, v7gf, v10method) /*  ADD-METHOD */;
   value0 = v10method;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for WRAPPED-METHOD-FUNCTION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1462wrapped_method_function(cl_object v1method_function)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1method_function,env0);      /*  METHOD-FUNCTION         */
 {
  cl_object v2;
  v2 = ecl_make_cclosure_va((cl_objectfn)LC1461__lambda29,env0,Cblock,2);
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L1462wrapped_method_function_va(cl_narg narg, cl_object v3method_function, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[11]);
 {
  return L1462wrapped_method_function(v3method_function);
 }
}
/* function definition for ENSURE-GENERIC-FUNCTION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1479ensure_generic_function(cl_narg narg, cl_object v1name, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[27]);
 {
  cl_object v2lambda_list;
  cl_object v3l_l_p;
  ecl_va_list args; ecl_va_start(args,v1name,narg,1);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L1479ensure_generic_functionkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[1])) {
    v2lambda_list = ECL_UNBOUND;
   } else {
    v2lambda_list = keyvars[0];
   }
   v3l_l_p = keyvars[1];
  }
  if (Null(cl_fboundp(v1name))){
   goto L2;
  }
  T0 = cl_fdefinition(v1name);
  if (!(ECL_INSTANCEP(T0))){
   goto L2;
  }
  value0 = cl_fdefinition(v1name);
  return value0;
L2:;
  {
   cl_object v4_class;
   cl_object v5gfun;
   v4_class = cl_find_class(1, ECL_SYM("STANDARD-GENERIC-FUNCTION",978));
   v5gfun = si_allocate_raw_instance(ECL_NIL, v4_class, ecl_make_int8_t(11));
   si_instance_set(v5gfun, ecl_make_int8_t(0), v1name);
   si_instance_set(v5gfun, ecl_make_int8_t(1), ECL_NIL);
   T0 = (cl_env_copy->function=(ECL_SYM("FIND-METHOD-COMBINATION",1590)->symbol.gfdef))->cfun.entry(3, ECL_NIL, ECL_SYM("STANDARD",976), ECL_NIL) /*  FIND-METHOD-COMBINATION */;
   si_instance_set(v5gfun, ecl_make_int8_t(2), T0);
   si_instance_set(v5gfun, ecl_make_int8_t(3), v2lambda_list);
   if (Null(v3l_l_p)){
    goto L14;
   }
   T1 = si_process_lambda_list(v2lambda_list, ECL_T);
   T0 = ecl_cdr(T1);
   goto L12;
L14:;
   T0 = ECL_NIL;
   goto L12;
L12:;
   si_instance_set(v5gfun, ecl_make_int8_t(4), T0);
   T0 = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
   si_instance_set(v5gfun, ecl_make_int8_t(5), T0);
   si_instance_set(v5gfun, ecl_make_int8_t(6), ECL_NIL);
   si_instance_set(v5gfun, ecl_make_int8_t(7), ECL_NIL);
   si_instance_set(v5gfun, ecl_make_int8_t(8), ECL_NIL);
   si_instance_set(v5gfun, ecl_make_int8_t(9), ECL_NIL);
   si_instance_set(v5gfun, ecl_make_int8_t(10), ECL_NIL);
   if (Null(v4_class)){
    goto L22;
   }
   si_instance_sig_set(v5gfun);
L22:;
   clos_set_funcallable_instance_function(v5gfun, ECL_SYM("STANDARD-GENERIC-FUNCTION",978));
   si_fset(2, v1name, v5gfun);
   value0 = v5gfun;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for (SETF GENERIC-FUNCTION-NAME)                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1480_setf_generic_function_name_(cl_object v1new_name, cl_object v2gf)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[0]))){
  goto L2;
 }
 value0 = (cl_env_copy->function=(ECL_SYM("REINITIALIZE-INSTANCE",967)->symbol.gfdef))->cfun.entry(3, v2gf, ECL_SYM("NAME",1309), v1new_name) /*  REINITIALIZE-INSTANCE */;
 return value0;
L2:;
 value0 = (cl_env_copy->function=ECL_CONS_CAR(VV[84]))->cfun.entry(3, v1new_name, v2gf, ECL_SYM("NAME",1611)) /*  (SETF SLOT-VALUE) */;
 return value0;
}
static cl_object L1480_setf_generic_function_name__va(cl_narg narg, cl_object v3new_name, cl_object v4gf, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[29]);
 {
  return L1480_setf_generic_function_name_(v3new_name, v4gf);
 }
}
/* function definition for STD-COMPUTE-DISCRIMINATING-FUNCTION                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1481std_compute_discriminating_function(cl_object v1generic_function)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(VV[32]->symbol.gfdef))->cfun.entry(1, v1generic_function) /*  UNOPTIMIZED-DISCRIMINATOR */;
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_T;
 cl_env_copy->values[0] = T0;
 return cl_env_copy->values[0];
}
static cl_object L1481std_compute_discriminating_function_va(cl_narg narg, cl_object v2generic_function, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[31]);
 {
  return L1481std_compute_discriminating_function(v2generic_function);
 }
}
/* function definition for COMPUTE-DISCRIMINATING-FUNCTION                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1482compute_discriminating_function(cl_object v1gf)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = (cl_env_copy->function=(VV[31]->symbol.gfdef))->cfun.entry(1, v1gf) /*  STD-COMPUTE-DISCRIMINATING-FUNCTION */;
 return value0;
}
static cl_object L1482compute_discriminating_function_va(cl_narg narg, cl_object v2gf, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[34]);
 {
  return L1482compute_discriminating_function(v2gf);
 }
}
/* function definition for SET-GENERIC-FUNCTION-DISPATCH                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1484set_generic_function_dispatch(cl_object v1gf)
{
 cl_object T0, T1;
 volatile cl_object lex0[1];
 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;                                   /*  COMPUTED-DISCRIMINATOR  */
  cl_object v3;                                   /*  OPTIMIZABLE             */
  value0 = (cl_env_copy->function=(VV[34]->symbol.gfdef))->cfun.entry(1, v1gf) /*  COMPUTE-DISCRIMINATING-FUNCTION */;
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  T0 = cl_slot_value(v1gf, VV[36]);
  {
   cl_fixnum v4;
   v4 = ecl_length(T0);
   if (!((v4)>((cl_fixnum)(63)))){
    goto L3;
   }
  }
  v3 = ECL_NIL;
L3:;
  {
   cl_object v4;
   cl_object v5;
   v4 = cl_slot_value(v1gf, VV[37]);
   T0 = cl_class_of(v1gf);
   T1 = cl_slot_value(T0, ECL_SYM("NAME",1611));
   v5 = ecl_make_bool((T1)==(ECL_SYM("STANDARD-GENERIC-FUNCTION",978)));
   lex0[0] = v4;                                  /*  METHODS                 */
   if (v3!=ECL_NIL) {
    goto L9;
   }
   T0 = v2;
   goto L8;
L9:;
   if (v5!=ECL_NIL) {
    goto L11;
   }
   T0 = ECL_T;
   goto L8;
L11:;
   {
    cl_object v6;
    v6 = LC1483only_slot_accessors_p(lex0, ECL_SYM("STANDARD-OPTIMIZED-READER-METHOD",1643));
    if (Null(v6)){
     goto L14;
    }
    T0 = v6;
    goto L8;
L14:;
    {
     cl_object v7;
     v7 = LC1483only_slot_accessors_p(lex0, ECL_SYM("STANDARD-OPTIMIZED-WRITER-METHOD",1644));
     if (Null(v7)){
      goto L17;
     }
     T0 = v7;
     goto L8;
L17:;
     T0 = ECL_SYM("STANDARD-GENERIC-FUNCTION",978);
    }
   }
L8:;
   value0 = clos_set_funcallable_instance_function(v1gf, T0);
   return value0;
  }
 }
}
static cl_object L1484set_generic_function_dispatch_va(cl_narg narg, cl_object v2gf, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[35]);
 {
  return L1484set_generic_function_dispatch(v2gf);
 }
}
/* function definition for STD-COMPUTE-APPLICABLE-METHODS                     */
/* optimize speed 3, debug 1, space 1, safety 2                               */
cl_object clos_std_compute_applicable_methods(cl_object v1gf, cl_object v2args)
{
 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 v3methods;
  {
   cl_object v4;
   cl_object v5method;
   cl_object v6;
   {
    cl_object v7;
    v7 = ecl_instance_ref((v1gf),((cl_fixnum)(7)));
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   v5method = 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:;
    v5method = 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;
    }
    if (Null(LC1551applicable_method_p(v5method, v2args))){
     goto L20;
    }
    {
     cl_object v9;
     v9 = v8;
     if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v9;
    }
    v8 = ecl_list1(v5method);
    (ECL_CONS_CDR(T0)=v8,T0);
L20:;
    goto L10;
L11:;
    v3methods = ecl_cdr(v7);
    goto L2;
   }
  }
L2:;
  {
   cl_object v4;
   v4 = (ECL_SYM("CLASS-OF",939)->symbol.gfdef);
   {
    cl_object v5;
    cl_object v6;
    v5 = ECL_NIL;
    v6 = v2args;
    {
     cl_object v7;
     cl_object v8;
     v7 = ecl_list1(ECL_NIL);
     v8 = v7;
L34:;
     if (!(ecl_endp(v6))){
      goto L36;
     }
     goto L35;
L36:;
     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;
      T1 = v9;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v5);
     v8 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v8,T1);
     goto L34;
L35:;
     T0 = ecl_cdr(v7);
     goto L28;
    }
   }
  }
L28:;
  value0 = L1656sort_applicable_methods(v1gf, v3methods, T0);
  return value0;
 }
}
/* function definition for STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES       */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object L1589std_compute_applicable_methods_using_classes(cl_object volatile v1gf, cl_object volatile v2classes)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 volatile struct ecl_cclosure aux_closure;
 cl_object volatile CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env0); /*  STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES */
  {
   ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV0));
   if (__ecl_frs_push_result!=0) {
   ecl_frs_pop_n(cl_env_copy, 1);
   return cl_env_copy->values[0];
   } else {
   {
    cl_object v3methods;
    cl_object v4sorted_methods;
    {
     cl_object v5;
     cl_object v6method;
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_instance_ref((v1gf),((cl_fixnum)(7)));
      if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v5 = v8;
     }
     v6method = ECL_NIL;
     v7 = v5;
     {
      cl_object v8;
      cl_object v9;
      v8 = ecl_list1(ECL_NIL);
      v9 = v8;
L10:;
      if (!(ecl_endp(v7))){
       goto L12;
      }
      goto L11;
L12:;
      v6method = ECL_CONS_CAR(v7);
      {
       cl_object v10;
       v10 = ECL_CONS_CDR(v7);
       if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v7 = v10;
      }
      if (Null((aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC1588applicable_method_p(2, v6method, v2classes)))){
       goto L20;
      }
      {
       cl_object v10;
       v10 = v9;
       if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v10;
      }
      v9 = ecl_list1(v6method);
      (ECL_CONS_CDR(T0)=v9,T0);
L20:;
      goto L10;
L11:;
      v3methods = ecl_cdr(v8);
      goto L2;
     }
    }
L2:;
    v4sorted_methods = L1656sort_applicable_methods(v1gf, v3methods, v2classes);
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = ECL_T;
    cl_env_copy->values[0] = v4sorted_methods;
    ecl_frs_pop_n(cl_env_copy, 1);
    return cl_env_copy->values[0];
   }
   }
  }
 }
}
static cl_object L1589std_compute_applicable_methods_using_classes_va(cl_narg narg, cl_object v3gf, cl_object v4classes, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return L1589std_compute_applicable_methods_using_classes(v3gf, v4classes);
 }
}
/* function definition for SORT-APPLICABLE-METHODS                            */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L1656sort_applicable_methods(cl_object v1gf, cl_object v2applicable_list, cl_object v3args_specializers)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v4;
  cl_object v5;
  cl_object v6args_classes;
  v4 = ecl_instance_ref((v1gf),((cl_fixnum)(8)));
  {
   cl_object v7arg_spec;
   cl_object v8;
   v7arg_spec = ECL_NIL;
   v8 = v3args_specializers;
   {
    cl_object v9;
    cl_object v10req_args;
    cl_object v11;
    v9 = ecl_instance_ref((v1gf),((cl_fixnum)(4)));
    v10req_args = ECL_NIL;
    v11 = v9;
    {
     cl_object v12;
     cl_object v13;
     v12 = ecl_list1(ECL_NIL);
     v13 = v12;
L11:;
     if (!(v8==ECL_NIL)){
      goto L13;
     }
     goto L12;
L13:;
     v7arg_spec = ECL_CONS_CAR(v8);
     v8 = ECL_CONS_CDR(v8);
     if (!(v11==ECL_NIL)){
      goto L19;
     }
     goto L12;
L19:;
     v10req_args = ECL_CONS_CAR(v11);
     v11 = ECL_CONS_CDR(v11);
     T0 = v13;
     if (Null(ecl_instance_ref((v7arg_spec),((cl_fixnum)(0))))){
      goto L29;
     }
     T2 = ecl_instance_ref((v7arg_spec),((cl_fixnum)(2)));
     T1 = cl_class_of(T2);
     goto L28;
L29:;
     T1 = v7arg_spec;
L28:;
     v13 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v13,T0);
     goto L11;
L12:;
     v5 = _ecl_cdr(v12);
     goto L3;
    }
   }
  }
L3:;
  v6args_classes = v5;
  if (Null(v4)){
   goto L35;
  }
  v6args_classes = ecl_function_dispatch(cl_env_copy,v4)(1, v6args_classes);
L35:;
  {
   cl_object v7scan;
   cl_object v8most_specific;
   cl_object v9ordered_list;
   v7scan = v2applicable_list;
   v8most_specific = _ecl_car(v7scan);
   v9ordered_list = ECL_NIL;
   goto L43;
L42:;
   {
    cl_object v10;
    v10 = _ecl_cdr(v7scan);
    goto L49;
L48:;
    {
     cl_object v11method;
     v11method = _ecl_car(v10);
     T0 = L1671compare_methods(v8most_specific, v11method, v6args_classes, v4);
     if (!((T0)==(ecl_make_int8_t(2)))){
      goto L53;
     }
     v8most_specific = v11method;
L53:;
    }
    v10 = _ecl_cdr(v10);
L49:;
    if (Null(v10)){
     goto L58;
    }
    goto L48;
L58:;
   }
   v7scan = cl_delete(2, v8most_specific, v7scan);
   v9ordered_list = CONS(v8most_specific,v9ordered_list);
   v8most_specific = _ecl_car(v7scan);
L43:;
   T0 = _ecl_cdr(v7scan);
   if (T0==ECL_NIL) {
    goto L66;
   }
   goto L42;
L66:;
   if (Null(v8most_specific)){
    goto L68;
   }
   v9ordered_list = CONS(v8most_specific,v9ordered_list);
   value0 = cl_nreverse(v9ordered_list);
   return value0;
L68:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L1656sort_applicable_methods_va(cl_narg narg, cl_object v10gf, cl_object v11applicable_list, cl_object v12args_specializers, ...)
{
 return L1656sort_applicable_methods(v10gf, v11applicable_list, v12args_specializers);
}
/* function definition for COMPARE-METHODS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1671compare_methods(cl_object v1method_1, cl_object v2method_2, cl_object v3args_classes, cl_object v4f)
{
 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 v5;
  cl_object v6;
  cl_object v7specializers_list_1;
  cl_object v8specializers_list_2;
  v5 = ecl_instance_ref((v1method_1),((cl_fixnum)(2)));
  v6 = ecl_instance_ref((v2method_2),((cl_fixnum)(2)));
  v7specializers_list_1 = v5;
  v8specializers_list_2 = v6;
  if (Null(v4f)){
   goto L6;
  }
  v7specializers_list_1 = ecl_function_dispatch(cl_env_copy,v4f)(1, v7specializers_list_1);
  v8specializers_list_2 = ecl_function_dispatch(cl_env_copy,v4f)(1, v8specializers_list_2);
L6:;
  value0 = L1672compare_specializers_lists(v7specializers_list_1, v8specializers_list_2, v3args_classes);
  return value0;
 }
}
/* function definition for COMPARE-SPECIALIZERS-LISTS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1672compare_specializers_lists(cl_object v1spec_list_1, cl_object v2spec_list_2, cl_object v3args_classes)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (v1spec_list_1!=ECL_NIL) {
  goto L4;
 }
 if (Null(v2spec_list_2)){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 {
  cl_object v4;
  T0 = ecl_car(v1spec_list_1);
  T1 = ecl_car(v2spec_list_2);
  T2 = ecl_car(v3args_classes);
  v4 = L1744compare_specializers(T0, T1, T2);
  if (!((v4)==(ecl_make_int8_t(1)))){
   goto L7;
  }
  value0 = ecl_make_int8_t(1);
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  if (!((v4)==(ecl_make_int8_t(2)))){
   goto L9;
  }
  value0 = ecl_make_int8_t(2);
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  if (!((v4)==(ECL_SYM("=",76)))){
   goto L11;
  }
  v1spec_list_1 = ecl_cdr(v1spec_list_1);
  v2spec_list_2 = ecl_cdr(v2spec_list_2);
  v3args_classes = ecl_cdr(v3args_classes);
  goto L1;
L11:;
  if (!((v4)==(ECL_NIL))){
   goto L17;
  }
  value0 = ecl_car(v1spec_list_1);
  if (value0!=ECL_NIL) {
   goto L22;
  }
  T0 = ECL_T;
  goto L20;
L22:;
  T0 = value0;
  goto L20;
L20:;
  value0 = ecl_car(v2spec_list_2);
  if (value0!=ECL_NIL) {
   goto L26;
  }
  T1 = ECL_T;
  goto L24;
L26:;
  T1 = value0;
  goto L24;
L24:;
  T2 = ecl_car(v3args_classes);
  value0 = cl_error(4, VV[58], T0, T1, T2);
  return value0;
L17:;
  value0 = si_ecase_error(v4, VV[59]);
  return value0;
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for FAST-SUBTYPEP                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1709fast_subtypep(cl_object v1spec1, cl_object v2spec2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_instance_ref((v1spec1),((cl_fixnum)(0))))){
  goto L2;
 }
 if (Null(ecl_instance_ref((v2spec2),((cl_fixnum)(0))))){
  goto L4;
 }
 T0 = ecl_instance_ref((v1spec1),((cl_fixnum)(2)));
 T1 = ecl_instance_ref((v2spec2),((cl_fixnum)(2)));
 value0 = ecl_make_bool(ecl_eql(T0,T1));
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 T0 = ecl_instance_ref((v1spec1),((cl_fixnum)(2)));
 value0 = si_of_class_p(2, T0, v2spec2);
 return value0;
L2:;
 if (Null(ecl_instance_ref((v2spec2),((cl_fixnum)(0))))){
  goto L9;
 }
 T0 = ecl_instance_ref((v2spec2),((cl_fixnum)(2)));
 if (!(T0==ECL_NIL)){
  goto L12;
 }
 T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1spec1) /*  CLASS-NAME */;
 value0 = ecl_make_bool((T0)==(ECL_SYM("NULL",607)));
 cl_env_copy->nvalues = 1;
 return value0;
L12:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L9:;
 value0 = si_subclassp(2, v1spec1, v2spec2);
 return value0;
}
/* function definition for COMPARE-SPECIALIZERS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1744compare_specializers(cl_object v1spec_1, cl_object v2spec_2, cl_object v3arg_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_object v4cpl;
  v4cpl = ecl_instance_ref((v3arg_class),((cl_fixnum)(7)));
  if (!((v1spec_1)==(v2spec_2))){
   goto L3;
  }
  value0 = ECL_SYM("=",76);
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  if (Null(L1709fast_subtypep(v1spec_1, v2spec_2))){
   goto L5;
  }
  value0 = ecl_make_int8_t(1);
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  if (Null(L1709fast_subtypep(v2spec_2, v1spec_1))){
   goto L7;
  }
  value0 = ecl_make_int8_t(2);
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  if (Null(ecl_instance_ref((v1spec_1),((cl_fixnum)(0))))){
   goto L9;
  }
  value0 = ecl_make_int8_t(1);
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  if (Null(ecl_instance_ref((v2spec_2),((cl_fixnum)(0))))){
   goto L11;
  }
  value0 = ecl_make_int8_t(2);
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   {
    cl_object v8;
    cl_object v9;
    v8 = v2spec_2;
    v9 = v4cpl;
    v5 = ecl_memql(v8,v9);
   }
   v6 = v1spec_1;
   v7 = v5;
   if (Null(ecl_memql(v6,v7))){
    goto L13;
   }
  }
  value0 = ecl_make_int8_t(2);
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   {
    cl_object v8;
    cl_object v9;
    v8 = v1spec_1;
    v9 = v4cpl;
    v5 = ecl_memql(v8,v9);
   }
   v6 = v2spec_2;
   v7 = v5;
   if (Null(ecl_memql(v6,v7))){
    goto L20;
   }
  }
  value0 = ecl_make_int8_t(1);
  cl_env_copy->nvalues = 1;
  return value0;
L20:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for COMPUTE-G-F-SPEC-LIST                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1782compute_g_f_spec_list(cl_object v1gf)
{
 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 v2;
  v2 = ecl_make_cfun_va((cl_objectfn)LC1754method_specializers_va,ECL_NIL,Cblock,1);
  {
   cl_object v3;
   v3 = ecl_make_cfun_va((cl_objectfn)LC1781nupdate_profile_va,ECL_NIL,Cblock,2);
   {
    cl_object v4;
    T0 = ecl_instance_ref((v1gf),((cl_fixnum)(7)));
    v4 = cl_reduce(6, v3, T0, ECL_SYM("KEY",1297), v2, VV[63], ECL_NIL);
    si_instance_set(v1gf, ecl_make_int8_t(1), v4);
   }
   {
    cl_object v4;
    cl_object v5;
    cl_object v6function;
    v4 = ecl_instance_ref((v1gf),((cl_fixnum)(4)));
    v5 = ecl_instance_ref((v1gf),((cl_fixnum)(3)));
    v6function = ECL_NIL;
    if (!(ECL_CONSP(v5))){
     goto L9;
    }
    {
     cl_object v7required_arguments;
     T0 = si_process_lambda_list(v5, ECL_T);
     v7required_arguments = ecl_cdr(T0);
     if (ecl_equal(v4,v7required_arguments)) {
      goto L9;
     }
     T0 = CONS(ECL_SYM("LIST",483),v4);
     T1 = cl_list(4, ECL_SYM("DESTRUCTURING-BIND",302), v7required_arguments, VV[66], T0);
     T2 = cl_list(3, ECL_SYM("LAMBDA",454), VV[65], T1);
     v6function = si_coerce_to_function(T2);
    }
L9:;
    si_instance_set(v1gf, ecl_make_int8_t(8), v6function);
   }
   value0 = si_clear_gfun_hash(v1gf);
   return value0;
  }
 }
}
static cl_object L1782compute_g_f_spec_list_va(cl_narg narg, cl_object v4gf, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[61]);
 {
  return L1782compute_g_f_spec_list(v4gf);
 }
}
/* function definition for PRINT-OBJECT                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1783print_object(cl_object v1object, cl_object v2stream)
{
 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_print_unreadable_object_function(v1object, v2stream, ECL_NIL, ECL_NIL, ECL_NIL);
 return value0;
}
static cl_object L1783print_object_va(cl_narg narg, cl_object v3object, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[69]);
 {
  return L1783print_object(v3object, v4stream);
 }
}
/* closure LAMBDA23                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1460__lambda23(cl_narg narg, cl_object v1x, ...)
{
 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;                                     /*  SPECIALIZERS            */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[12]);
 {
L1:;
  if (!(ECL_CONSP(v1x))){
   goto L2;
  }
  T0 = ecl_cadr(v1x);
  value0 = (cl_env_copy->function=(ECL_SYM("INTERN-EQL-SPECIALIZER",1602)->symbol.gfdef))->cfun.entry(1, T0) /*  INTERN-EQL-SPECIALIZER */;
  return value0;
L2:;
  if (Null(si_of_class_p(2, v1x, ECL_SYM("SPECIALIZER",1632)))){
   goto L4;
  }
  value0 = v1x;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  {
   cl_object v2;
   v2 = cl_find_class(2, v1x, ECL_NIL);
   if (Null(v2)){
    goto L7;
   }
   value0 = v2;
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   value0 = cl_error(3, VV[13], ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1));
   return value0;
  }
 }
 }
}
/* closure LAMBDA29                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1461__lambda29(cl_narg narg, cl_object v1_combined_method_args_, cl_object v2_next_methods_, ...)
{
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  METHOD-FUNCTION         */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[20]);
 {
  ecl_bds_bind(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547),v1_combined_method_args_); /*  .COMBINED-METHOD-ARGS. */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549),v2_next_methods_); /*  *NEXT-METHODS* */
L1:;
  value0 = cl_apply(2, ECL_CONS_CAR(CLV0), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
/* local function ONLY-SLOT-ACCESSORS-P                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1483only_slot_accessors_p(volatile cl_object *lex0, cl_object v1class_name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(lex0[0])){
  goto L3;
 }
 {
  cl_object v2class;
  v2class = cl_find_class(2, v1class_name, ECL_NIL);
  {
   cl_object v3;
   cl_object v4m;
   cl_object v5;
   {
    cl_object v6;
    v6 = lex0[0];
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v6;
   }
   v4m = ECL_NIL;
   v5 = v3;
L12:;
   if (!(ecl_endp(v5))){
    goto L14;
   }
   goto L13;
L14:;
   v4m = 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;
   }
   T0 = cl_class_of(v4m);
   if ((v2class)==(T0)) {
    goto L22;
   }
   goto L3;
L22:;
   goto L12;
L13:;
   goto L5;
  }
 }
L5:;
 value0 = v1class_name;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function METHOD-SPECIALIZERS                                         */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1546method_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 LC1546method_specializers_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-SPECIALIZERS",1610));
 {
  return LC1546method_specializers(v2object);
 }
}
/* local function GENERIC-FUNCTION-METHODS                                    */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1528generic_function_methods(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)(7)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1528generic_function_methods_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-METHODS",1600));
 {
  return LC1528generic_function_methods(v2object);
 }
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1520eql_specializer_flag(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)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1520eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return LC1520eql_specializer_flag(v2object);
 }
}
/* local function EQL-SPECIALIZER-OBJECT                                      */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1516eql_specializer_object(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 LC1516eql_specializer_object_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586));
 {
  return LC1516eql_specializer_object(v2object);
 }
}
/* local function APPLICABLE-METHOD-P                                         */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1551applicable_method_p(cl_object v1method, cl_object v2args)
{
 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;
  cl_object v4spec;
  cl_object v5;
  {
   cl_object v6;
   v6 = ecl_instance_ref((v1method),((cl_fixnum)(2)));
   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;
  {
   cl_object v6;
   cl_object v7arg;
   cl_object v8;
   {
    cl_object v9;
    v9 = v2args;
    if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v6 = v9;
   }
   v7arg = ECL_NIL;
   v8 = v6;
L12:;
   if (!(ecl_endp(v5))){
    goto L14;
   }
   goto L13;
L14:;
   v4spec = ECL_CONS_CAR(v5);
   {
    cl_object v9;
    v9 = ECL_CONS_CDR(v5);
    if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v9;
   }
   if (!(ecl_endp(v8))){
    goto L22;
   }
   goto L13;
L22:;
   v7arg = ECL_CONS_CAR(v8);
   {
    cl_object v9;
    v9 = ECL_CONS_CDR(v8);
    if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v9;
   }
   if (Null(ecl_instance_ref((v4spec),((cl_fixnum)(0))))){
    goto L32;
   }
   T0 = ecl_instance_ref((v4spec),((cl_fixnum)(2)));
   if (ecl_eql(v7arg,T0)) {
    goto L30;
   }
   goto L31;
L32:;
   if (si_of_class_p(2, v7arg, v4spec)!=ECL_NIL) {
    goto L30;
   }
L31:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L30:;
   goto L12;
L13:;
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC1551applicable_method_p_va(cl_narg narg, cl_object v9method, cl_object v10args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[50]);
 {
  return LC1551applicable_method_p(v9method, v10args);
 }
}
/* local function METHOD-SPECIALIZERS                                         */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1583method_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 LC1583method_specializers_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-SPECIALIZERS",1610));
 {
  return LC1583method_specializers(v2object);
 }
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1573eql_specializer_flag(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)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1573eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return LC1573eql_specializer_flag(v2object);
 }
}
/* local function EQL-SPECIALIZER-OBJECT                                      */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1569eql_specializer_object(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 LC1569eql_specializer_object_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586));
 {
  return LC1569eql_specializer_object(v2object);
 }
}
/* local function GENERIC-FUNCTION-METHODS                                    */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1559generic_function_methods(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)(7)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1559generic_function_methods_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-METHODS",1600));
 {
  return LC1559generic_function_methods(v2object);
 }
}
/* closure APPLICABLE-METHOD-P                                                */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object LC1588applicable_method_p(cl_narg narg, cl_object v1method, cl_object v2classes, ...)
{
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[50]);
 {
L1:;
  {
   cl_object v3eql_spec_p;
   v3eql_spec_p = ECL_NIL;
   {
    cl_object v4;
    cl_object v5spec;
    cl_object v6;
    {
     cl_object v7;
     v7 = ecl_instance_ref((v1method),((cl_fixnum)(2)));
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    v5spec = ECL_NIL;
    v6 = v4;
    {
     cl_object v7;
     cl_object v8class;
     cl_object v9;
     {
      cl_object v10;
      v10 = v2classes;
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     v8class = ECL_NIL;
     v9 = v7;
L13:;
     if (!(ecl_endp(v6))){
      goto L15;
     }
     goto L14;
L15:;
     v5spec = ECL_CONS_CAR(v6);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v6);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v10;
     }
     if (!(ecl_endp(v9))){
      goto L23;
     }
     goto L14;
L23:;
     v8class = ECL_CONS_CAR(v9);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v10;
     }
     if (Null(ecl_instance_ref((v5spec),((cl_fixnum)(0))))){
      goto L32;
     }
     {
      cl_object v10object;
      v10object = ecl_instance_ref((v5spec),((cl_fixnum)(2)));
      if (Null(si_of_class_p(2, v10object, v8class))){
       goto L35;
      }
      v3eql_spec_p = ECL_T;
      goto L31;
L35:;
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 1;
      return value0;
     }
L32:;
     if (si_subclassp(2, v8class, v5spec)!=ECL_NIL) {
      goto L31;
     }
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
L31:;
     goto L13;
L14:;
     if (Null(v3eql_spec_p)){
      goto L41;
     }
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = ECL_NIL;
     cl_env_copy->values[0] = ECL_NIL;
     cl_return_from(ECL_CONS_CAR(CLV0),VV[52]);
L41:;
     value0 = ECL_T;
     cl_env_copy->nvalues = 1;
     return value0;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
 }
 }
}
/* local function GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC1635generic_function_argument_precedence_order(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(4)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1635generic_function_argument_precedence_order_va(cl_narg narg, cl_object v2object, ...)
{
 return LC1635generic_function_argument_precedence_order(v2object);
}
/* local function GENERIC-FUNCTION-A-P-O-FUNCTION                             */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC1631generic_function_a_p_o_function(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(8)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1631generic_function_a_p_o_function_va(cl_narg narg, cl_object v2object, ...)
{
 return LC1631generic_function_a_p_o_function(v2object);
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC1625eql_specializer_flag(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1625eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 return LC1625eql_specializer_flag(v2object);
}
/* local function EQL-SPECIALIZER-OBJECT                                      */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC1621eql_specializer_object(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(2)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1621eql_specializer_object_va(cl_narg narg, cl_object v2object, ...)
{
 return LC1621eql_specializer_object(v2object);
}
/* local function METHOD-SPECIALIZERS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1666method_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 LC1666method_specializers_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-SPECIALIZERS",1610));
 {
  return LC1666method_specializers(v2object);
 }
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1708eql_specializer_flag(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)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1708eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return LC1708eql_specializer_flag(v2object);
 }
}
/* local function EQL-SPECIALIZER-OBJECT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1704eql_specializer_object(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 LC1704eql_specializer_object_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586));
 {
  return LC1704eql_specializer_object(v2object);
 }
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1743eql_specializer_flag(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)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1743eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return LC1743eql_specializer_flag(v2object);
 }
}
/* local function CLASS-PRECEDENCE-LIST                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1731class_precedence_list(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)(7)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1731class_precedence_list_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("CLASS-PRECEDENCE-LIST",1568));
 {
  return LC1731class_precedence_list(v2object);
 }
}
/* local function (SETF GENERIC-FUNCTION-SPEC-LIST)                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1779_setf_generic_function_spec_list_(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(1), v1value);
 return value0;
}
static cl_object LC1779_setf_generic_function_spec_list__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[64]);
 {
  return LC1779_setf_generic_function_spec_list_(v3value, v4object);
 }
}
/* local function GENERIC-FUNCTION-LAMBDA-LIST                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1776generic_function_lambda_list(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 LC1776generic_function_lambda_list_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-LAMBDA-LIST",1597));
 {
  return LC1776generic_function_lambda_list(v2object);
 }
}
/* local function GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1774generic_function_argument_precedence_order(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)(4)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1774generic_function_argument_precedence_order_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER",1595));
 {
  return LC1774generic_function_argument_precedence_order(v2object);
 }
}
/* local function GENERIC-FUNCTION-METHODS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1772generic_function_methods(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)(7)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1772generic_function_methods_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-METHODS",1600));
 {
  return LC1772generic_function_methods(v2object);
 }
}
/* local function (SETF GENERIC-FUNCTION-A-P-O-FUNCTION)                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1769_setf_generic_function_a_p_o_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(8), v1value);
 return value0;
}
static cl_object LC1769_setf_generic_function_a_p_o_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[67]);
 {
  return LC1769_setf_generic_function_a_p_o_function_(v3value, v4object);
 }
}
/* local function EQL-SPECIALIZER-FLAG                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1764eql_specializer_flag(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)(0)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1764eql_specializer_flag_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return LC1764eql_specializer_flag(v2object);
 }
}
/* local function EQL-SPECIALIZER-OBJECT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1760eql_specializer_object(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 LC1760eql_specializer_object_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586));
 {
  return LC1760eql_specializer_object(v2object);
 }
}
/* local function METHOD-SPECIALIZERS                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1754method_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 LC1754method_specializers_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-SPECIALIZERS",1610));
 {
  return LC1754method_specializers(v2object);
 }
}
/* local function NUPDATE-PROFILE                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1781nupdate_profile(cl_object v1spec_how_list, cl_object v2specializers)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(v1spec_how_list==ECL_NIL)){
  goto L2;
 }
 {
  cl_object v3;
  cl_object v4spec;
  cl_object v5;
  {
   cl_object v6;
   v6 = v2specializers;
   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;
  {
   cl_object v6;
   cl_object v7;
   v6 = ecl_list1(ECL_NIL);
   v7 = v6;
L11:;
   if (!(ecl_endp(v5))){
    goto L13;
   }
   goto L12;
L13:;
   v4spec = ECL_CONS_CAR(v5);
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v5);
    if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v8;
   }
   {
    cl_object v8;
    v8 = v7;
    if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v8;
   }
   if (Null(ecl_instance_ref((v4spec),((cl_fixnum)(0))))){
    goto L27;
   }
   T2 = ecl_instance_ref((v4spec),((cl_fixnum)(2)));
   T1 = cl_list(2, ECL_NIL, T2);
   goto L26;
L27:;
   T2 = cl_find_class(1, ECL_T);
   if (!((v4spec)==(T2))){
    goto L30;
   }
   T1 = CONS(ECL_NIL,ECL_NIL);
   goto L26;
L30:;
   T1 = CONS(ECL_T,ECL_NIL);
L26:;
   v7 = ecl_list1(T1);
   (ECL_CONS_CDR(T0)=v7,T0);
   goto L11;
L12:;
   value0 = ecl_cdr(v6);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L2:;
 {
  cl_object v8;
  cl_object v9spec;
  cl_object v10;
  {
   cl_object v11;
   v11 = v2specializers;
   if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v8 = v11;
  }
  v9spec = ECL_NIL;
  v10 = v8;
  {
   cl_object v11;
   cl_object v12arg_profile;
   v11 = v1spec_how_list;
   v12arg_profile = ECL_NIL;
L41:;
   if (!(ecl_endp(v10))){
    goto L43;
   }
   goto L42;
L43:;
   v9spec = 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;
   }
   if (!(ECL_ATOM(v11))){
    goto L51;
   }
   goto L42;
L51:;
   v12arg_profile = ecl_car(v11);
   v11 = ECL_CONS_CDR(v11);
   if (Null(ecl_instance_ref((v9spec),((cl_fixnum)(0))))){
    goto L58;
   }
   {
    cl_object v13;
    cl_object v14;
    v13 = ecl_instance_ref((v9spec),((cl_fixnum)(2)));
    T0 = ecl_cdr(v12arg_profile);
    v14 = CONS(v13,T0);
    {
     cl_object v15;
     v15 = v12arg_profile;
     if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v15;
    }
    (ECL_CONS_CDR(T0)=v14,T0);
    goto L57;
   }
L58:;
   if (ecl_car(v12arg_profile)!=ECL_NIL) {
    goto L57;
   }
   T0 = cl_find_class(1, ECL_T);
   if ((v9spec)==(T0)) {
    goto L57;
   }
   {
    cl_object v15;
    v15 = ECL_T;
    {
     cl_object v16;
     v16 = v12arg_profile;
     if (ecl_unlikely(ECL_ATOM(v16))) FEtype_error_cons(v16);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v16;
    }
    (ECL_CONS_CAR(T0)=v15,T0);
   }
L57:;
   goto L41;
L42:;
   value0 = v1spec_how_list;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC1781nupdate_profile_va(cl_narg narg, cl_object v13spec_how_list, cl_object v14specializers, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[62]);
 {
  return LC1781nupdate_profile(v13spec_how_list, v14specializers);
 }
}
#include "clos/kernel.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclfcsH3z4q37do9_Xw10M881(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;KERNEL.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclfcsH3z4q37do9_Xw10M881@";
 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]);
  si_Xmake_special(VV[0]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[0],T0);
  ecl_cmp_defun(VV[70]);                          /*  SETF-FIND-CLASS         */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1458__lambda14,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  si_do_defsetf(3, ECL_SYM("FIND-CLASS",947), T0, ecl_make_int8_t(1));
  ecl_cmp_defun(VV[71]);                          /*  CLASSP                  */
  ecl_cmp_defun(VV[72]);                          /*  INSTALL-METHOD          */
  ecl_cmp_defun(VV[73]);                          /*  WRAPPED-METHOD-FUNCTION */
  ecl_cmp_defun(VV[74]);                          /*  ENSURE-GENERIC-FUNCTION */
  ecl_cmp_defun(VV[75]);                          /*  (SETF GENERIC-FUNCTION-NAME) */
  ecl_cmp_defun(VV[76]);                          /*  STD-COMPUTE-DISCRIMINATING-FUNCTION */
  ecl_cmp_defun(VV[77]);                          /*  COMPUTE-DISCRIMINATING-FUNCTION */
  ecl_cmp_defun(VV[78]);                          /*  SET-GENERIC-FUNCTION-DISPATCH */
  (void)0; /* No entry created for STD-COMPUTE-APPLICABLE-METHODS */
  ecl_cmp_defun(VV[79]);                          /*  STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES */
  T0 = (ECL_SYM("STD-COMPUTE-APPLICABLE-METHODS",1645)->symbol.gfdef);
  si_fset(2, ECL_SYM("COMPUTE-APPLICABLE-METHODS",940), T0);
  T0 = (VV[52]->symbol.gfdef);
  si_fset(2, ECL_SYM("COMPUTE-APPLICABLE-METHODS-USING-CLASSES",1571), T0);
  ecl_cmp_defun(VV[80]);                          /*  SORT-APPLICABLE-METHODS */
  (void)0; /* No entry created for COMPARE-METHODS */
  (void)0; /* No entry created for COMPARE-SPECIALIZERS-LISTS */
  (void)0; /* No entry created for FAST-SUBTYPEP */
  (void)0; /* No entry created for COMPARE-SPECIALIZERS */
  ecl_cmp_defun(VV[81]);                          /*  COMPUTE-G-F-SPEC-LIST   */
  ecl_cmp_defun(VV[82]);                          /*  PRINT-OBJECT            */
 }
}
