/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/stdmethod.lsp                  */
#include <ecl/ecl-cmp.h>
#include "clos/stdmethod.eclh"
/* local function FUNCTION-KEYWORDS                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2045function_keywords(cl_object v1method)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;                                   /*  KEY-FLAG                */
  cl_object v3;                                   /*  KEYWORDS                */
  T0 = cl_slot_value(v1method, VV[1]);
  value0 = si_process_lambda_list(T0, ECL_SYM("FUNCTION",398));
  {
   const int v4 = cl_env_copy->nvalues;
   cl_object v5;
   v5 = (v4<=3)? ECL_NIL : cl_env_copy->values[3];
   v2 = v5;
   v5 = (v4<=4)? ECL_NIL : cl_env_copy->values[4];
   v3 = v5;
  }
  if (Null(v2)){
   goto L3;
  }
  {
   cl_object v4output;
   cl_object v5l;
   v4output = ECL_NIL;
   v5l = ecl_cdr(v3);
   goto L9;
L8:;
   T0 = ecl_car(v5l);
   v4output = CONS(T0,v4output);
   v5l = ecl_cddddr(v5l);
L9:;
   if (ecl_endp(v5l)) {
    goto L15;
   }
   goto L8;
L15:;
   value0 = v4output;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2045function_keywords_va(cl_narg narg, cl_object v2method, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FUNCTION-KEYWORDS",399));
 {
  return LC2045function_keywords(v2method);
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2048shared_initialize(cl_narg narg, cl_object v1method, cl_object v2slot_names, ...)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SHARED-INITIALIZE",969));
 {
  cl_object v3specializers;
  cl_object v4spec_supplied_p;
  cl_object v5lambda_list;
  cl_object v6lambda_supplied_p;
  cl_object v7generic_function;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,LC2048shared_initializekeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   v3specializers = keyvars[0];
   v4spec_supplied_p = keyvars[3];
   v5lambda_list = keyvars[1];
   v6lambda_supplied_p = keyvars[4];
   v7generic_function = keyvars[2];
  }
  if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
   goto L2;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
  goto L1;
L2:;
  T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
  T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L1:;
  lex0[0] = T0;                                   /*  .CLOSED-COMBINED-METHOD-ARGS. */
  lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
  if (Null(v2slot_names)){
   goto L5;
  }
  if (v4spec_supplied_p!=ECL_NIL) {
   goto L7;
  }
  cl_error(1, VV[3]);
L7:;
  if (v6lambda_supplied_p!=ECL_NIL) {
   goto L9;
  }
  cl_error(1, VV[4]);
L9:;
  T0 = si_process_lambda_list(v5lambda_list, ECL_SYM("METHOD",958));
  T1 = ecl_car(T0);
  {
   cl_fixnum v8;
   v8 = ecl_length(v3specializers);
   if (ecl_number_equalp(T1,ecl_make_fixnum(v8))) {
    goto L5;
   }
  }
  cl_error(2, VV[5], v5lambda_list);
L5:;
  if (Null(v4spec_supplied_p)){
   goto L12;
  }
  {
   cl_object v8;
   cl_object v9s;
   cl_object v10;
   {
    cl_object v11;
    v11 = v3specializers;
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9s = ECL_NIL;
   v10 = v8;
L19:;
   if (!(ecl_endp(v10))){
    goto L21;
   }
   goto L20;
L21:;
   v9s = ECL_CONS_CAR(v10);
   {
    cl_object v11;
    v11 = ECL_CONS_CDR(v10);
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v10 = v11;
   }
   if (si_of_class_p(2, v9s, ECL_SYM("SPECIALIZER",1632))!=ECL_NIL) {
    goto L29;
   }
   cl_error(2, VV[8], v9s);
L29:;
   goto L19;
L20:;
  }
L12:;
  v1method = LC2046call_next_method(0, lex0);
  {
   cl_object v8;
   T0 = (cl_env_copy->function=(ECL_SYM("METHOD-LAMBDA-LIST",1609)->symbol.gfdef))->cfun.entry(1, v1method) /*  METHOD-LAMBDA-LIST */;
   v8 = (cl_env_copy->function=(VV[9]->symbol.gfdef))->cfun.entry(1, T0) /*  COMPUTE-METHOD-KEYWORDS */;
   (cl_env_copy->function=ECL_CONS_CAR(VV[20]))->cfun.entry(2, v8, v1method) /*  (SETF METHOD-KEYWORDS) */;
  }
  value0 = v1method;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for INTERN-EQL-SPECIALIZER                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2049intern_eql_specializer(cl_object volatile v1object)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2table;
  v2table = ecl_cmp_symbol_value(cl_env_copy,VV[13]);
  {
   volatile cl_object v3;
   v3 = ecl_cmp_symbol_value(cl_env_copy,VV[12]);
   if (Null(mp_get_lock(2, v3, ECL_T))){
    goto L4;
   }
   {
    struct ecl_stack_frame _ecl_inner_frame_aux;
    volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
    {
     volatile cl_object v4;
     v4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7));
     ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
     ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
     {
      struct ecl_stack_frame _ecl_inner_frame_aux;
      volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
      volatile bool unwinding = FALSE;
      ecl_frame_ptr next_fr;
      {
       ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG);
       if (__ecl_frs_push_result!=0) {
         unwinding = TRUE; next_fr=cl_env_copy->frs_stack.nlj_fr;
       } else {
       ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v4); /*  *INTERRUPTS-ENABLED* */
       value0 = ecl_gethash_safe(v1object,v2table,ECL_NIL);
       if (value0!=ECL_NIL) {
        goto L10;
       }
       T0 = (cl_env_copy->function=(ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef))->cfun.entry(3, ECL_SYM("EQL-SPECIALIZER",1585), ECL_SYM("OBJECT",1315), v1object) /*  MAKE-INSTANCE */;
       cl_env_copy->values[0] = si_hash_set(v1object, v2table, T0);
       ecl_bds_unwind1(cl_env_copy);
       goto L8;
L10:;
       cl_env_copy->values[0] = value0;
       cl_env_copy->nvalues = 1;
       ecl_bds_unwind1(cl_env_copy);
       goto L8;
L8:;
       }
      }
      ecl_frs_pop(cl_env_copy);
      ecl_stack_frame_push_values(_ecl_inner_frame);
      mp_giveup_lock(v3);
      ecl_stack_frame_pop_values(_ecl_inner_frame);
      if (unwinding) ecl_unwind(cl_env_copy,next_fr);
      ecl_stack_frame_close(_ecl_inner_frame);
      ecl_bds_unwind1(cl_env_copy);
      ecl_bds_unwind1(cl_env_copy);
     }
    }
    ecl_stack_frame_push_values(_ecl_inner_frame);
    if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
     goto L13;
    }
    si_check_pending_interrupts();
L13:;
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    ecl_stack_frame_close(_ecl_inner_frame);
    return cl_env_copy->values[0];
   }
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L2049intern_eql_specializer_va(cl_narg narg, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[14]);
 {
  return L2049intern_eql_specializer(v4object);
 }
}
/* local function ADD-DIRECT-METHOD                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2050add_direct_method(cl_object v1spec, cl_object v2method)
{
 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 v3cell;
  v3cell = (cl_env_copy->function=(VV[15]->symbol.gfdef))->cfun.entry(1, v1spec) /*  SPECIALIZER-METHOD-HOLDER */;
  {
   cl_object v4;
   v4 = ECL_NIL;
   {
    cl_object v5;
    v5 = v3cell;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v5;
   }
   (ECL_CONS_CDR(T0)=v4,T0);
  }
  {
   cl_object v4;
   T0 = ecl_car(v3cell);
   T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v4 = cl_adjoin(4, v2method, T0, ECL_SYM("TEST",1353), T1);
   {
    cl_object v5;
    v5 = v3cell;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v5;
   }
   (ECL_CONS_CAR(T0)=v4,T0);
  }
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object LC2050add_direct_method_va(cl_narg narg, cl_object v3spec, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("ADD-DIRECT-METHOD",1560));
 {
  return LC2050add_direct_method(v3spec, v4method);
 }
}
/* local function REMOVE-DIRECT-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2051remove_direct_method(cl_object v1spec, cl_object v2method)
{
 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 v3cell;
  v3cell = (cl_env_copy->function=(VV[15]->symbol.gfdef))->cfun.entry(1, v1spec) /*  SPECIALIZER-METHOD-HOLDER */;
  {
   cl_object v4;
   v4 = ECL_NIL;
   {
    cl_object v5;
    v5 = v3cell;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v5;
   }
   (ECL_CONS_CDR(T0)=v4,T0);
  }
  {
   cl_object v4;
   T0 = ecl_car(v3cell);
   T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v4 = cl_delete(4, v2method, T0, ECL_SYM("TEST",1353), T1);
   {
    cl_object v5;
    v5 = v3cell;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v5;
   }
   (ECL_CONS_CAR(T0)=v4,T0);
  }
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object LC2051remove_direct_method_va(cl_narg narg, cl_object v3spec, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("REMOVE-DIRECT-METHOD",1614));
 {
  return LC2051remove_direct_method(v3spec, v4method);
 }
}
/* local function REMOVE-DIRECT-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2054remove_direct_method(cl_object volatile v1spec, cl_object volatile v2method)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
  goto L3;
 }
 T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
 goto L2;
L3:;
 T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
 T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L2:;
 lex0[0] = T0;                                    /*  .CLOSED-COMBINED-METHOD-ARGS. */
 lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
 {
  volatile cl_object v3;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[12]);
  if (Null(mp_get_lock(2, v3, ECL_T))){
   goto L6;
  }
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   {
    volatile cl_object v4;
    v4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
    ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
    {
     struct ecl_stack_frame _ecl_inner_frame_aux;
     volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
     volatile bool unwinding = FALSE;
     ecl_frame_ptr next_fr;
     {
      ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG);
      if (__ecl_frs_push_result!=0) {
        unwinding = TRUE; next_fr=cl_env_copy->frs_stack.nlj_fr;
      } else {
      ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v4); /*  *INTERRUPTS-ENABLED* */
      LC2052call_next_method(0, lex0);
      if ((cl_env_copy->function=(ECL_SYM("SPECIALIZER-DIRECT-METHODS",1634)->symbol.gfdef))->cfun.entry(1, v1spec) /*  SPECIALIZER-DIRECT-METHODS */!=ECL_NIL) {
       goto L13;
      }
      cl_env_copy->values[0] = cl_remhash(v1spec, ecl_cmp_symbol_value(cl_env_copy,VV[13]));
      ecl_bds_unwind1(cl_env_copy);
      goto L11;
L13:;
      cl_env_copy->values[0] = ECL_NIL;
      cl_env_copy->nvalues = 1;
      ecl_bds_unwind1(cl_env_copy);
L11:;
      }
     }
     ecl_frs_pop(cl_env_copy);
     ecl_stack_frame_push_values(_ecl_inner_frame);
     mp_giveup_lock(v3);
     ecl_stack_frame_pop_values(_ecl_inner_frame);
     if (unwinding) ecl_unwind(cl_env_copy,next_fr);
     ecl_stack_frame_close(_ecl_inner_frame);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
    }
   }
   ecl_stack_frame_push_values(_ecl_inner_frame);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
    goto L16;
   }
   si_check_pending_interrupts();
L16:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
  }
 }
L6:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object LC2054remove_direct_method_va(cl_narg narg, cl_object v3spec, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("REMOVE-DIRECT-METHOD",1614));
 {
  return LC2054remove_direct_method(v3spec, v4method);
 }
}
/* local function SPECIALIZER-DIRECT-METHODS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2055specializer_direct_methods(cl_object v1spec)
{
 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[15]->symbol.gfdef))->cfun.entry(1, v1spec) /*  SPECIALIZER-METHOD-HOLDER */;
 value0 = ecl_car(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2055specializer_direct_methods_va(cl_narg narg, cl_object v2spec, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("SPECIALIZER-DIRECT-METHODS",1634));
 {
  return LC2055specializer_direct_methods(v2spec);
 }
}
/* local function SPECIALIZER-DIRECT-GENERIC-FUNCTIONS                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2056specializer_direct_generic_functions(cl_object v1spec)
{
 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 v2cell;
  v2cell = (cl_env_copy->function=(VV[15]->symbol.gfdef))->cfun.entry(1, v1spec) /*  SPECIALIZER-METHOD-HOLDER */;
  value0 = ecl_cdr(v2cell);
  if (value0!=ECL_NIL) {
   goto L4;
  }
  if (Null(ecl_car(v2cell))){
   goto L6;
  }
  {
   cl_object v3acc;
   v3acc = ECL_NIL;
   {
    cl_object v4;
    cl_object v5method;
    cl_object v6;
    {
     cl_object v7;
     v7 = ecl_car(v2cell);
     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;
L14:;
    if (!(ecl_endp(v6))){
     goto L16;
    }
    goto L15;
L16:;
    v5method = 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;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("METHOD-GENERIC-FUNCTION",1608)->symbol.gfdef))->cfun.entry(1, v5method) /*  METHOD-GENERIC-FUNCTION */;
    T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
    v3acc = cl_adjoin(4, T0, v3acc, ECL_SYM("TEST",1353), T1);
    goto L14;
L15:;
    {
     cl_object v7;
     v7 = cl_nreverse(v3acc);
     {
      cl_object v8;
      v8 = v2cell;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v8;
     }
     (ECL_CONS_CDR(T0)=v7,T0);
     value0 = v7;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
L6:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2056specializer_direct_generic_functions_va(cl_narg narg, cl_object v7spec, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("SPECIALIZER-DIRECT-GENERIC-FUNCTIONS",1633));
 {
  return LC2056specializer_direct_generic_functions(v7spec);
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2046call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[2]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2052call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[2]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
#include "clos/stdmethod.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl7X8g8ORGax1i9_E950M881(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;STDMETHOD.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7X8g8ORGax1i9_E950M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2045function_keywords_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("FUNCTION-KEYWORDS",399), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2048shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[3], VVtemp[4], T0);
  si_Xmake_special(VV[12]);
  T0 = mp_make_lock(2, ECL_SYM("NAME",1309), ECL_SYM("EQL-SPECIALIZER",1585));
  ecl_cmp_setq(cl_env_copy,VV[12],T0);
  si_Xmake_special(VV[13]);
  T0 = (ECL_SYM("EQL",336)->symbol.gfdef);
  T1 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_uint8_t(128), ECL_SYM("TEST",1353), T0);
  ecl_cmp_setq(cl_env_copy,VV[13],T1);
  ecl_cmp_defun(VV[16]);                          /*  INTERN-EQL-SPECIALIZER  */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2050add_direct_method_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ADD-DIRECT-METHOD",1560), ECL_NIL, VVtemp[5], VVtemp[6], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2051remove_direct_method_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("REMOVE-DIRECT-METHOD",1614), ECL_NIL, VVtemp[5], VVtemp[6], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2054remove_direct_method_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("REMOVE-DIRECT-METHOD",1614), ECL_NIL, VVtemp[7], VVtemp[6], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2055specializer_direct_methods_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SPECIALIZER-DIRECT-METHODS",1634), ECL_NIL, VVtemp[8], VVtemp[9], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2056specializer_direct_generic_functions_va,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SPECIALIZER-DIRECT-GENERIC-FUNCTIONS",1633), ECL_NIL, VVtemp[8], VVtemp[9], T0);
 }
}
