/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/defcombin.lsp                  */
#include <ecl/ecl-cmp.h>
#include "clos/defcombin.eclh"
/* function definition for SEARCH-METHOD-COMBINATION                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1889search_method_combination(cl_object volatile v1name)
{
 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 v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[0]);
  if (Null(mp_get_lock(2, v2, ECL_T))){
   goto L3;
  }
  {
   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 v3;
    v3 = 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),v3); /*  *INTERRUPTS-ENABLED* */
      value0 = ecl_gethash_safe(v1name,ecl_cmp_symbol_value(cl_env_copy,VV[1]),ECL_NIL);
      if (value0!=ECL_NIL) {
       goto L9;
      }
      cl_env_copy->values[0] = cl_error(2, VV[3], v1name);
      ecl_bds_unwind1(cl_env_copy);
      goto L7;
L9:;
      cl_env_copy->values[0] = value0;
      cl_env_copy->nvalues = 1;
      ecl_bds_unwind1(cl_env_copy);
      goto L7;
L7:;
      }
     }
     ecl_frs_pop(cl_env_copy);
     ecl_stack_frame_push_values(_ecl_inner_frame);
     mp_giveup_lock(v2);
     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 L12;
   }
   si_check_pending_interrupts();
L12:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L1889search_method_combination_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[2]);
 {
  return L1889search_method_combination(v3name);
 }
}
/* function definition for INSTALL-METHOD-COMBINATION                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1890install_method_combination(cl_object volatile v1name, cl_object volatile v2function)
{
 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 v3;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[0]);
  if (Null(mp_get_lock(2, v3, ECL_T))){
   goto L2;
  }
  {
   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* */
      cl_env_copy->values[0] = si_hash_set(v1name, ecl_cmp_symbol_value(cl_env_copy,VV[1]), v2function);
      ecl_bds_unwind1(cl_env_copy);
      }
     }
     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 L9;
   }
   si_check_pending_interrupts();
L9:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
  }
 }
L2:;
 value0 = v1name;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1890install_method_combination_va(cl_narg narg, cl_object v3name, cl_object v4function, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[5]);
 {
  return L1890install_method_combination(v3name, v4function);
 }
}
/* function definition for MAKE-METHOD-COMBINATION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1897make_method_combination(cl_object v1name, cl_object v2compiler, cl_object v3options)
{
 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 v4_class;
  cl_object v5o;
  v4_class = cl_find_class(1, ECL_SYM("METHOD-COMBINATION",960));
  v5o = si_allocate_raw_instance(ECL_NIL, v4_class, ecl_make_int8_t(3));
  si_instance_set(v5o, ecl_make_int8_t(0), v1name);
  si_instance_set(v5o, ecl_make_int8_t(1), v2compiler);
  si_instance_set(v5o, ecl_make_int8_t(2), v3options);
  if (Null(v4_class)){
   goto L7;
  }
  si_instance_sig_set(v5o);
L7:;
  value0 = v5o;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L1897make_method_combination_va(cl_narg narg, cl_object v6name, cl_object v7compiler, cl_object v8options, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[7]);
 {
  return L1897make_method_combination(v6name, v7compiler, v8options);
 }
}
/* function definition for FIND-METHOD-COMBINATION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1898find_method_combination(cl_object v1gf, cl_object v2method_combination_type_name, cl_object v3method_combination_options)
{
 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 = L1889search_method_combination(v2method_combination_type_name);
 value0 = L1897make_method_combination(v2method_combination_type_name, T0, v3method_combination_options);
 return value0;
}
static cl_object L1898find_method_combination_va(cl_narg narg, cl_object v4gf, cl_object v5method_combination_type_name, cl_object v6method_combination_options, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[14]);
 {
  return L1898find_method_combination(v4gf, v5method_combination_type_name, v6method_combination_options);
 }
}
/* function definition for DEFINE-SIMPLE-METHOD-COMBINATION                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1899define_simple_method_combination(cl_narg narg, cl_object v1name, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[15]);
 {
  cl_object v2documentation;
  cl_object v3identity_with_one_argument;
  cl_object v4operator;
  ecl_va_list args; ecl_va_start(args,v1name,narg,1);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,L1899define_simple_method_combinationkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v2documentation = keyvars[0];
   v3identity_with_one_argument = keyvars[1];
   if (Null(keyvars[5])) {
    v4operator = v1name;
   } else {
    v4operator = keyvars[2];
   }
  }
  T0 = ecl_list1(v1name);
  T1 = cl_listX(3, VV[18], T0, VV[19]);
  T2 = cl_list(2, VV[17], T1);
  T3 = cl_list(2, ECL_SYM("QUOTE",682), v4operator);
  T4 = cl_list(3, ECL_SYM("LIST*",484), T3, VV[21]);
  T5 = cl_list(2, VV[20], T4);
  T6 = ecl_list1(T5);
  if (Null(v3identity_with_one_argument)){
   goto L3;
  }
  T7 = VV[23];
  goto L2;
L3:;
  T7 = ECL_T;
L2:;
  T8 = cl_list(2, T7, VV[20]);
  T9 = cl_list(4, ECL_SYM("COND",249), VV[22], T8, VV[24]);
  T10 = cl_list(3, ECL_SYM("LET",479), T6, T9);
  value0 = cl_list(6, ECL_SYM("DEFINE-METHOD-COMBINATION",943), v1name, VV[16], T2, v2documentation, T10);
  return value0;
 }
}
/* function definition for METHOD-COMBINATION-ARGUMENTS-RESHUFFLING           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1900method_combination_arguments_reshuffling(cl_object v1mc_whole_arg, cl_object v2mc_lambda_list, cl_object v3gf_lambda_list, cl_object v4body)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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 v5lambda_list;
  cl_object v6let_statements;
  cl_object v7ignored_vars;
  cl_object v8n_gf_requireds;
  cl_object v9n_gf_optionals;
  v5lambda_list = ECL_NIL;
  v6let_statements = ECL_NIL;
  v7ignored_vars = ECL_NIL;
  v8n_gf_requireds = ECL_NIL;
  v9n_gf_optionals = ECL_NIL;
  {
   cl_object v10;                                 /*  MC-REQUIREDS            */
   cl_object v11;                                 /*  MC-OPTIONALS            */
   cl_object v12;                                 /*  MC-REST                 */
   cl_object v13;                                 /*  MC-KEY-FLAG             */
   cl_object v14;                                 /*  MC-KEYWORDS             */
   cl_object v15;                                 /*  MC-AUX-VARS             */
   value0 = si_process_lambda_list(v2mc_lambda_list, ECL_SYM("FUNCTION",398));
   {
    const int v16 = cl_env_copy->nvalues;
    v10 = value0;
    cl_object v17;
    v17 = (v16<=1)? ECL_NIL : cl_env_copy->values[1];
    v11 = v17;
    v17 = (v16<=2)? ECL_NIL : cl_env_copy->values[2];
    v12 = v17;
    v17 = (v16<=3)? ECL_NIL : cl_env_copy->values[3];
    v13 = v17;
    v17 = (v16<=4)? ECL_NIL : cl_env_copy->values[4];
    v14 = v17;
    v17 = (v16<=6)? ECL_NIL : cl_env_copy->values[6];
    v15 = v17;
   }
   {
    cl_object v16;                                /*  GF-REQUIREDS            */
    cl_object v17;                                /*  GF-OPTIONALS            */
    value0 = si_process_lambda_list(v3gf_lambda_list, ECL_SYM("FUNCTION",398));
    {
     const int v18 = cl_env_copy->nvalues;
     v16 = value0;
     cl_object v19;
     v19 = (v18<=1)? ECL_NIL : cl_env_copy->values[1];
     v17 = v19;
    }
    v8n_gf_requireds = ecl_car(v16);
    v9n_gf_optionals = ecl_car(v17);
    if (Null(v1mc_whole_arg)){
     goto L13;
    }
    T0 = cl_list(2, v1mc_whole_arg, VV[27]);
    v6let_statements = CONS(T0,v6let_statements);
L13:;
    {
     cl_object v18;
     cl_object v19r;
     cl_object v20;
     {
      cl_object v21;
      v21 = ecl_cdr(v10);
      if (ecl_unlikely(!ECL_LISTP(v21))) FEtype_error_list(v21);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v18 = v21;
     }
     v19r = ECL_NIL;
     v20 = v18;
     {
      cl_object v21i;
      v21i = ecl_make_int8_t(0);
      if (!(ecl_endp(v20))){
       goto L25;
      }
      goto L24;
L25:;
      v19r = ECL_CONS_CAR(v20);
      {
       cl_object v22;
       v22 = ecl_cdr(v20);
       if (ecl_unlikely(!ECL_LISTP(v22))) FEtype_error_list(v22);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v20 = v22;
      }
L23:;
      if (!(ecl_lower(v21i,v8n_gf_requireds))){
       goto L34;
      }
      v5lambda_list = CONS(v19r,v5lambda_list);
      goto L33;
L34:;
      T0 = cl_list(2, v19r, ECL_NIL);
      v6let_statements = CONS(T0,v6let_statements);
L33:;
      if (!(ecl_endp(v20))){
       goto L38;
      }
      goto L24;
L38:;
      v19r = ECL_CONS_CAR(v20);
      {
       cl_object v22;
       v22 = ecl_cdr(v20);
       if (ecl_unlikely(!ECL_LISTP(v22))) FEtype_error_list(v22);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v20 = v22;
      }
      v21i = ecl_one_plus(v21i);
      goto L23;
L24:;
     }
    }
    {
     cl_object v18;
     cl_object v19;
     cl_object v20v;
     {
      cl_object v21;
      T0 = ecl_car(v10);
      v21 = ecl_minus(v8n_gf_requireds,T0);
      T0 = cl_realp(v21);
      if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("REAL",706),v21);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v18 = v21;
     }
     v19 = v18;
     v20v = ECL_NIL;
L55:;
     v19 = ecl_minus(v19,ecl_make_int8_t(1));
     T0 = v19;
     if (!(ecl_minusp(T0))){
      goto L57;
     }
     goto L56;
L57:;
     v20v = cl_gensym(0);
     v5lambda_list = CONS(v20v,v5lambda_list);
     v7ignored_vars = CONS(v20v,v7ignored_vars);
     goto L55;
L56:;
    }
    v5lambda_list = CONS(ECL_SYM("&OPTIONAL",13),v5lambda_list);
    {
     cl_object v18o;
     v18o = ecl_cdr(v11);
     {
      cl_object v19i;
      v19i = ecl_make_int8_t(0);
      if (!(ECL_ATOM(v18o))){
       goto L75;
      }
      goto L74;
L75:;
L73:;
      if (!(ecl_lower(v19i,v9n_gf_optionals))){
       goto L78;
      }
      if (Null(ecl_caddr(v18o))){
       goto L82;
      }
      T1 = ecl_car(v18o);
      T2 = ecl_cadr(v18o);
      T3 = ecl_caddr(v18o);
      T0 = cl_list(3, T1, T2, T3);
      goto L81;
L82:;
      T1 = ecl_car(v18o);
      T2 = ecl_cadr(v18o);
      T0 = cl_list(2, T1, T2);
L81:;
      v5lambda_list = CONS(T0,v5lambda_list);
      goto L77;
L78:;
      T0 = ecl_car(v18o);
      T1 = ecl_cadr(v18o);
      T2 = cl_list(2, T0, T1);
      v6let_statements = CONS(T2,v6let_statements);
      if (Null(ecl_caddr(v18o))){
       goto L77;
      }
      T0 = ecl_caddr(v18o);
      T1 = cl_list(2, T0, ECL_NIL);
      v6let_statements = CONS(T1,v6let_statements);
L77:;
      v18o = ecl_cdddr(v18o);
      if (!(ECL_ATOM(v18o))){
       goto L90;
      }
      goto L74;
L90:;
      v19i = ecl_one_plus(v19i);
      goto L73;
L74:;
     }
    }
    {
     cl_object v18;
     cl_object v19;
     cl_object v20v;
     {
      cl_object v21;
      T0 = ecl_car(v11);
      v21 = ecl_minus(v9n_gf_optionals,T0);
      T0 = cl_realp(v21);
      if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("REAL",706),v21);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v18 = v21;
     }
     v19 = v18;
     v20v = ECL_NIL;
L101:;
     v19 = ecl_minus(v19,ecl_make_int8_t(1));
     T0 = v19;
     if (!(ecl_minusp(T0))){
      goto L103;
     }
     goto L102;
L103:;
     v20v = cl_gensym(0);
     v5lambda_list = CONS(v20v,v5lambda_list);
     v7ignored_vars = CONS(v20v,v7ignored_vars);
     goto L101;
L102:;
    }
    if (v12!=ECL_NIL) {
     goto L114;
    }
    v12 = cl_gensym(0);
    v7ignored_vars = CONS(v12,v7ignored_vars);
L114:;
    v5lambda_list = CONS(ECL_SYM("&REST",14),v5lambda_list);
    v5lambda_list = CONS(v12,v5lambda_list);
    if (Null(v13)){
     goto L123;
    }
    v5lambda_list = CONS(ECL_SYM("&KEY",12),v5lambda_list);
    {
     cl_object v18k;
     v18k = ecl_cdr(v14);
L129:;
     if (!(ECL_ATOM(v18k))){
      goto L131;
     }
     goto L130;
L131:;
     if (Null(ecl_cadddr(v18k))){
      goto L136;
     }
     T1 = ecl_car(v18k);
     T2 = ecl_cadr(v18k);
     T3 = cl_list(2, T1, T2);
     T4 = ecl_caddr(v18k);
     T5 = ecl_cadddr(v18k);
     T0 = cl_list(3, T3, T4, T5);
     goto L135;
L136:;
     T1 = ecl_car(v18k);
     T2 = ecl_cadr(v18k);
     T3 = cl_list(2, T1, T2);
     T4 = ecl_caddr(v18k);
     T0 = cl_list(2, T3, T4);
L135:;
     v5lambda_list = CONS(T0,v5lambda_list);
     v18k = ecl_cddddr(v18k);
     goto L129;
L130:;
    }
    v5lambda_list = CONS(ECL_SYM("&ALLOW-OTHER-KEYS",8),v5lambda_list);
L123:;
    if (Null(v15)){
     goto L142;
    }
    v5lambda_list = CONS(ECL_SYM("&AUX",9),v5lambda_list);
    {
     cl_object v18a;
     v18a = ecl_cdr(v15);
L147:;
     if (!(ECL_ATOM(v18a))){
      goto L149;
     }
     goto L148;
L149:;
     T0 = ecl_car(v18a);
     T1 = ecl_cadr(v18a);
     T2 = cl_list(2, T0, T1);
     v5lambda_list = CONS(T2,v5lambda_list);
     v18a = ecl_cddr(v18a);
     goto L147;
L148:;
    }
L142:;
    T0 = cl_nreverse(v5lambda_list);
    T1 = CONS(ECL_SYM("IGNORE",430),v7ignored_vars);
    T2 = cl_list(2, ECL_SYM("DECLARE",276), T1);
    T3 = cl_nreverse(v6let_statements);
    T4 = cl_list(3, ECL_SYM("LET",479), T3, v4body);
    T5 = cl_list(4, ECL_SYM("LAMBDA",454), T0, T2, T4);
    T6 = cl_list(2, ECL_SYM("FUNCTION",398), T5);
    value0 = cl_list(3, ECL_SYM("APPLY",91), T6, ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
    return value0;
   }
  }
 }
}
static cl_object L1900method_combination_arguments_reshuffling_va(cl_narg narg, cl_object v10mc_whole_arg, cl_object v11mc_lambda_list, cl_object v12gf_lambda_list, cl_object v13body, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[26]);
 {
  return L1900method_combination_arguments_reshuffling(v10mc_whole_arg, v11mc_lambda_list, v12gf_lambda_list, v13body);
 }
}
/* function definition for PROCESS-DEFINE-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1902process_define_method_combination_arguments_lambda_list(cl_object v1lambda_list, cl_object v2generic_function, cl_object v3body)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 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 (!(v1lambda_list==ECL_NIL)){
  goto L2;
 }
 value0 = v3body;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v4whole;
  T0 = ecl_car(v1lambda_list);
  if (!((T0)==(ECL_SYM("&WHOLE",15)))){
   goto L5;
  }
  {
   cl_object v5;
   v5 = ecl_cadr(v1lambda_list);
   v1lambda_list = ecl_cddr(v1lambda_list);
   v4whole = v5;
   goto L4;
  }
L5:;
  v4whole = ECL_NIL;
L4:;
  {
   cl_object v5;                                  /*  REQUIREDS               */
   cl_object v6;                                  /*  OPTIONALS               */
   cl_object v7;                                  /*  REST                    */
   cl_object v8;                                  /*  KEYWORDS                */
   cl_object v9;                                  /*  AUX-VARS                */
   value0 = si_process_lambda_list(v1lambda_list, ECL_SYM("FUNCTION",398));
   {
    const int v10 = cl_env_copy->nvalues;
    v5 = value0;
    cl_object v11;
    v11 = (v10<=1)? ECL_NIL : cl_env_copy->values[1];
    v6 = v11;
    v11 = (v10<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v11;
    v11 = (v10<=4)? ECL_NIL : cl_env_copy->values[4];
    v8 = v11;
    v11 = (v10<=6)? ECL_NIL : cl_env_copy->values[6];
    v9 = v11;
   }
   {
    cl_object v10;
    {
     cl_object v11;
     v11 = ecl_make_cfun_va((cl_objectfn)LC1901__lambda91_va,ECL_NIL,Cblock,1);
     v10 = v11;
    }
    {
     cl_object v11;
     cl_object v12;
     cl_object v13;
     {
      cl_object v14;
      if (Null(v4whole)){
       goto L16;
      }
      T1 = ecl_list1(v4whole);
      goto L15;
L16:;
      T1 = ECL_NIL;
L15:;
      T2 = ecl_cdr(v5);
      {
       cl_object v15o;
       v15o = ecl_cdr(v6);
       {
        cl_object v16;
        cl_object v17;
        v16 = ecl_list1(ECL_NIL);
        v17 = v16;
L22:;
        if (!(ECL_ATOM(v15o))){
         goto L24;
        }
        goto L23;
L24:;
        {
         cl_object v18;
         v18 = v17;
         if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T4 = v18;
        }
        T5 = ecl_car(v15o);
        v17 = ecl_list1(T5);
        (ECL_CONS_CDR(T4)=v17,T4);
        if (Null(ecl_caddr(v15o))){
         goto L31;
        }
        {
         cl_object v18;
         v18 = v17;
         if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T4 = v18;
        }
        T5 = ecl_caddr(v15o);
        v17 = ecl_list1(T5);
        (ECL_CONS_CDR(T4)=v17,T4);
L31:;
        v15o = ecl_cdddr(v15o);
        goto L22;
L23:;
        T3 = ecl_cdr(v16);
        goto L18;
       }
      }
L18:;
      if (Null(v7)){
       goto L42;
      }
      T4 = ecl_list1(v7);
      goto L41;
L42:;
      T4 = ECL_NIL;
L41:;
      {
       cl_object v15k;
       v15k = ecl_cdr(v8);
       {
        cl_object v16;
        cl_object v17;
        v16 = ecl_list1(ECL_NIL);
        v17 = v16;
L48:;
        if (!(ECL_ATOM(v15k))){
         goto L50;
        }
        goto L49;
L50:;
        {
         cl_object v18;
         v18 = v17;
         if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T6 = v18;
        }
        T7 = ecl_cadr(v15k);
        v17 = ecl_list1(T7);
        (ECL_CONS_CDR(T6)=v17,T6);
        if (Null(ecl_cadddr(v15k))){
         goto L57;
        }
        {
         cl_object v18;
         v18 = v17;
         if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T6 = v18;
        }
        T7 = ecl_cadddr(v15k);
        v17 = ecl_list1(T7);
        (ECL_CONS_CDR(T6)=v17,T6);
L57:;
        v15k = ecl_cddddr(v15k);
        goto L48;
L49:;
        T5 = ecl_cdr(v16);
        goto L44;
       }
      }
L44:;
      {
       cl_object v15a;
       v15a = ecl_cdr(v9);
       {
        cl_object v16;
        cl_object v17;
        v16 = ecl_list1(ECL_NIL);
        v17 = v16;
L71:;
        if (!(ECL_ATOM(v15a))){
         goto L73;
        }
        goto L72;
L73:;
        {
         cl_object v18;
         v18 = v17;
         if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T7 = v18;
        }
        T8 = ecl_car(v15a);
        v17 = ecl_list1(T8);
        (ECL_CONS_CDR(T7)=v17,T7);
        v15a = ecl_cddr(v15a);
        goto L71;
L72:;
        T6 = ecl_cdr(v16);
        goto L67;
       }
      }
L67:;
      v14 = cl_append(6, T1, T2, T3, T4, T5, T6);
      if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v11 = v14;
     }
     v12 = ECL_NIL;
     v13 = v11;
     {
      cl_object v14;
      cl_object v15;
      v14 = ecl_list1(ECL_NIL);
      v15 = v14;
L89:;
      if (!(ecl_endp(v13))){
       goto L91;
      }
      goto L90;
L91:;
      v12 = ECL_CONS_CAR(v13);
      {
       cl_object v16;
       v16 = ECL_CONS_CDR(v13);
       if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v16;
      }
      {
       cl_object v16;
       v16 = v15;
       if (ecl_unlikely(ECL_ATOM(v16))) FEtype_error_cons(v16);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v16;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v10)(1, v12);
      v15 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v15,T1);
      goto L89;
L90:;
      T0 = ecl_cdr(v14);
      goto L11;
     }
    }
   }
L11:;
   T1 = cl_list(3, ECL_SYM("LET",479), T0, v3body);
   T2 = cl_list(2, VV[33], T1);
   T3 = ecl_list1(T2);
   T4 = cl_list(2, ECL_SYM("QUOTE",682), v4whole);
   T5 = cl_list(2, ECL_SYM("QUOTE",682), v1lambda_list);
   T6 = cl_list(2, ECL_SYM("GENERIC-FUNCTION-LAMBDA-LIST",1597), v2generic_function);
   T7 = cl_list(5, VV[26], T4, T5, T6, VV[33]);
   value0 = cl_list(3, ECL_SYM("LET",479), T3, T7);
   return value0;
  }
 }
}
/* local function WITH-METHOD-GROUPS                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1904with_method_groups(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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 v4;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v5;
  }
  {
   cl_object v5group_names;
   cl_object v6matchers;
   cl_object v7cleanup;
   v5group_names = ECL_NIL;
   v6matchers = ECL_NIL;
   v7cleanup = ECL_NIL;
   {
    cl_object v8;
    v8 = v4;
    goto L16;
L15:;
    {
     cl_object v9group;
     v9group = ecl_car(v8);
     {
      cl_object v10;
      cl_object v11name;
      cl_object v12pattern;
      cl_object v13;
      cl_object v14description;
      cl_object v15;
      cl_object v16order;
      cl_object v17;
      cl_object v18required;
      v10 = v9group;
      if (!(v10==ECL_NIL)){
       goto L23;
      }
      si_dm_too_few_arguments(v9group);
L23:;
      {
       cl_object v19;
       v19 = ecl_car(v10);
       v10 = ecl_cdr(v10);
       v11name = v19;
      }
      if (!(v10==ECL_NIL)){
       goto L29;
      }
      si_dm_too_few_arguments(v9group);
L29:;
      {
       cl_object v19;
       v19 = ecl_car(v10);
       v10 = ecl_cdr(v10);
       v12pattern = v19;
      }
      v13 = si_search_keyword(v10, ECL_SYM("DESCRIPTION",992));
      if (!((v13)==(ECL_SYM("MISSING-KEYWORD",2044)))){
       goto L36;
      }
      v14description = ECL_NIL;
      goto L35;
L36:;
      v14description = v13;
L35:;
      v15 = si_search_keyword(v10, ECL_SYM("ORDER",1009));
      if (!((v15)==(ECL_SYM("MISSING-KEYWORD",2044)))){
       goto L40;
      }
      v16order = VV[49];
      goto L39;
L40:;
      v16order = v15;
L39:;
      v17 = si_search_keyword(v10, ECL_SYM("REQUIRED",1012));
      if (!((v17)==(ECL_SYM("MISSING-KEYWORD",2044)))){
       goto L44;
      }
      v18required = ECL_NIL;
      goto L43;
L44:;
      v18required = v17;
L43:;
      si_check_keyword(2, v10, VV[51]);
      v5group_names = CONS(v11name,v5group_names);
      T0 = LC1903parse_qualifier_pattern(v12pattern);
      T1 = cl_list(3, ECL_SYM("PUSH",680), VV[52], v11name);
      T2 = cl_list(2, T0, T1);
      v6matchers = CONS(T2,v6matchers);
      if (Null(v18required)){
       goto L52;
      }
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v11name);
      T1 = cl_list(3, ECL_SYM("ERROR",339), VV[53], T0);
      T2 = cl_list(3, ECL_SYM("UNLESS",886), v11name, T1);
      v7cleanup = CONS(T2,v7cleanup);
L52:;
      if (!((v16order)==(VV[49]))){
       goto L55;
      }
      T0 = cl_list(2, ECL_SYM("NREVERSE",591), v11name);
      T1 = cl_list(3, ECL_SYM("SETF",753), v11name, T0);
      v7cleanup = CONS(T1,v7cleanup);
      goto L20;
L55:;
      if ((v16order)==(VV[54])) {
       goto L20;
      }
      T0 = cl_list(3, ECL_SYM("EQ",335), v16order, VV[49]);
      T1 = cl_list(2, ECL_SYM("NREVERSE",591), v11name);
      T2 = cl_list(3, ECL_SYM("SETF",753), v11name, T1);
      T3 = cl_list(3, ECL_SYM("WHEN",909), T0, T2);
      v7cleanup = CONS(T3,v7cleanup);
     }
L20:;
    }
    v8 = ecl_cdr(v8);
L16:;
    if (Null(v8)){
     goto L62;
    }
    goto L15;
L62:;
   }
   T0 = cl_nreverse(v6matchers);
   {
    cl_object v8;
    v8 = (ECL_SYM("CAR",182)->symbol.gfdef);
    {
     cl_object v9;
     v9 = v6matchers;
     goto L71;
L70:;
     {
      cl_object v10;
      cl_object v11;
      {
       cl_object v12;
       v12 = v9;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v12;
      }
      v11 = ECL_CONS_CAR(v10);
      T2 = ecl_car(v11);
      if (!((ECL_T)==(T2))){
       goto L73;
      }
      if (v10!=ECL_NIL) {
       goto L65;
      }
      goto L66;
     }
L73:;
     v9 = ECL_CONS_CDR(v9);
L71:;
     if (v9==ECL_NIL) {
      goto L81;
     }
     goto L70;
L81:;
    }
   }
L66:;
   T1 = VV[61];
   goto L64;
L65:;
   T1 = ECL_NIL;
L64:;
   T2 = ecl_append(T0,T1);
   T3 = CONS(ECL_SYM("COND",249),T2);
   T4 = cl_list(4, ECL_SYM("LET",479), VV[56], VV[57], T3);
   T5 = cl_list(3, ECL_SYM("DOLIST",315), VV[55], T4);
   T6 = ecl_append(v7cleanup,v3);
   value0 = cl_listX(4, ECL_SYM("LET",479), v5group_names, T5, T6);
   return value0;
  }
 }
}
static cl_object LC1904with_method_groups_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[39]);
 {
  return LC1904with_method_groups(v8, v9);
 }
}
/* function definition for DEFINE-COMPLEX-METHOD-COMBINATION                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1906define_complex_method_combination(cl_object v1form)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14;
 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);
 lex0[0] = v1form;                                /*  FORM                    */
L1:;
 {
  cl_object v2;
  cl_object v3name;
  cl_object v4lambda_list;
  cl_object v5method_groups;
  cl_object v6body;
  cl_object v7generic_function;
  cl_object v8arguments;
  cl_object v9decls;
  cl_object v10documentation;
  v2 = lex0[0];
  if (!(v2==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(lex0[0]);
L4:;
  {
   cl_object v11;
   v11 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v3name = v11;
  }
  if (!(v2==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(lex0[0]);
L10:;
  {
   cl_object v11;
   v11 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v4lambda_list = v11;
  }
  if (!(v2==ECL_NIL)){
   goto L16;
  }
  si_dm_too_few_arguments(lex0[0]);
L16:;
  {
   cl_object v11;
   v11 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v5method_groups = v11;
  }
  v6body = v2;
  v7generic_function = VV[66];
  v8arguments = ECL_NIL;
  v9decls = ECL_NIL;
  v10documentation = ECL_NIL;
  {
   cl_object v11x;
   v11x = ecl_car(v6body);
   if (!(ECL_CONSP(v11x))){
    goto L26;
   }
   T0 = ecl_car(v11x);
   if (!((T0)==(VV[67]))){
    goto L26;
   }
   v6body = ecl_cdr(v6body);
   v8arguments = ecl_cdr(v11x);
  }
L26:;
  {
   cl_object v11x;
   v11x = ecl_car(v6body);
   if (!(ECL_CONSP(v11x))){
    goto L33;
   }
   T0 = ecl_car(v11x);
   if (!((T0)==(VV[68]))){
    goto L33;
   }
   v6body = ecl_cdr(v6body);
   v7generic_function = ecl_cadr(v11x);
  }
L33:;
  if (!(ECL_SYMBOLP(v3name))){
   goto L43;
  }
  if (ECL_SYMBOLP(v7generic_function)) {
   goto L40;
  }
  goto L41;
L43:;
  goto L41;
L41:;
  cl_error(2, VV[65], lex0[0]);
L40:;
  value0 = si_find_declarations(2, v6body, ECL_T);
  {
   const int v11 = cl_env_copy->nvalues;
   v9decls = value0;
   cl_object v12;
   v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
   v6body = v12;
   v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2];
   v10documentation = v12;
  }
  T0 = si_expand_set_documentation(v3name, ECL_SYM("METHOD-COMBINATION",960), v10documentation);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), v3name);
  T2 = cl_listX(3, v7generic_function, VV[71], v4lambda_list);
  T3 = cl_list(2, ECL_SYM("IGNORABLE",429), v7generic_function);
  T4 = cl_list(2, ECL_SYM("DECLARE",276), T3);
  T5 = cl_listX(3, VV[39], v5method_groups, v6body);
  T6 = L1902process_define_method_combination_arguments_lambda_list(v8arguments, v7generic_function, T5);
  T7 = cl_list(3, VV[72], T6, ECL_T);
  T8 = cl_list(3, ECL_SYM("BLOCK",139), v3name, T7);
  T9 = ecl_list1(T8);
  T10 = ecl_append(v9decls,T9);
  T11 = cl_listX(4, ECL_SYM("LAMBDA",454), T2, T4, T10);
  T12 = cl_list(3, VV[5], T1, T11);
  T13 = ecl_list1(T12);
  T14 = ecl_append(T0,T13);
  value0 = CONS(ECL_SYM("PROGN",674),T14);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function DEFINE-METHOD-COMBINATION                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1907define_method_combination(cl_object v1, cl_object v2)
{
 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 v4name;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4name = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  T0 = ecl_car(v3);
  if (!(ECL_LISTP(T0))){
   goto L9;
  }
  T0 = CONS(v4name,v3);
  value0 = L1906define_complex_method_combination(T0);
  return value0;
L9:;
  T0 = (VV[15]->symbol.gfdef);
  value0 = cl_apply(3, T0, v4name, v3);
  return value0;
 }
}
static cl_object LC1907define_method_combination_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[73]);
 {
  return LC1907define_method_combination(v5, v6);
 }
}
/* function definition for METHOD-COMBINATION-ERROR                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_method_combination_error(cl_narg narg, cl_object v1format_control, ...)
{
 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(ECL_SYM("METHOD-COMBINATION-ERROR",959));
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1format_control,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("FORMAT",389)->symbol.gfdef);
  T1 = cl_apply(4, T0, ECL_NIL, v1format_control, v2args);
  value0 = cl_error(2, VV[74], T1);
  return value0;
 }
}
/* function definition for INVALID-METHOD-ERROR                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_invalid_method_error(cl_narg narg, cl_object v1method, cl_object v2format_control, ...)
{
 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("INVALID-METHOD-ERROR",952));
 {
  cl_object v3args;
  ecl_va_list args; ecl_va_start(args,v2format_control,narg,2);
  v3args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("FORMAT",389)->symbol.gfdef);
  T1 = cl_apply(4, T0, ECL_NIL, v2format_control, v3args);
  value0 = cl_error(3, VV[75], v1method, T1);
  return value0;
 }
}
/* local function LAMBDA251                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1909__lambda251(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[77]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[77]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[79];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1908__lambda273_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("PROGN",674),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA277                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1911__lambda277(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[82]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[82]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[83];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1910__lambda299_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("AND",89),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA303                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1913__lambda303(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[85]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[85]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[86];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1912__lambda325_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("MAX",553),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA329                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1915__lambda329(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[88]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[88]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[89];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1914__lambda351_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("+",16),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA355                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1917__lambda355(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[91]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[91]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[92];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1916__lambda377_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("NCONC",583),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA381                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1919__lambda381(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[94]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[94]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[95];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1918__lambda403_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("APPEND",90),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    T0 = v6main_effective_method;
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA407                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1921__lambda407(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[97]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[97]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[98];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1920__lambda429_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("LIST",483),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    T0 = v6main_effective_method;
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA433                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1923__lambda433(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[100]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[100]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[101];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1922__lambda455_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("MIN",559),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA459                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1925__lambda459(cl_narg narg, cl_object v1_generic_function_, cl_object v2_methods_list_, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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[103]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[103]);
 {
  cl_object v3order;
  va_list args; va_start(args,v2_methods_list_);
  {
   int i = 2;
   if (i >= narg) {
    v3order = VV[49];
   } else {
    i++;
    v3order = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4principal;
   cl_object v5around;
   v4principal = ECL_NIL;
   v5around = ECL_NIL;
   {
    cl_object v6;
    v6 = v2_methods_list_;
    goto L9;
L8:;
    {
     cl_object v7_method_;
     v7_method_ = ecl_car(v6);
     {
      cl_object v8_method_qualifiers_;
      v8_method_qualifiers_ = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v7_method_) /*  METHOD-QUALIFIERS */;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[78];
       v10qualifiers = v8_method_qualifiers_;
       goto L21;
L20:;
       if (Null(v9pattern)){
        goto L26;
       }
       if (Null(v10qualifiers)){
        goto L26;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L23;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L23;
       }
       goto L24;
L26:;
       goto L24;
L24:;
       goto L15;
L23:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L21:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L33;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L37;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L33;
       }
       goto L34;
L37:;
       goto L34;
L34:;
       goto L20;
L33:;
      }
      v5around = CONS(v7_method_,v5around);
      goto L13;
L15:;
      {
       cl_object v9pattern;
       cl_object v10qualifiers;
       v9pattern = VV[104];
       v10qualifiers = v8_method_qualifiers_;
       goto L46;
L45:;
       if (Null(v9pattern)){
        goto L51;
       }
       if (Null(v10qualifiers)){
        goto L51;
       }
       T1 = ecl_car(v9pattern);
       if ((T1)==(ECL_SYM("*",20))) {
        goto L48;
       }
       T1 = ecl_car(v9pattern);
       T2 = ecl_car(v10qualifiers);
       if ((T1)==(T2)) {
        goto L48;
       }
       goto L49;
L51:;
       goto L49;
L49:;
       goto L40;
L48:;
       v9pattern = ecl_cdr(v9pattern);
       v10qualifiers = ecl_cdr(v10qualifiers);
L46:;
       if ((v9pattern)==(ECL_SYM("*",20))) {
        goto L58;
       }
       if (!(v9pattern==ECL_NIL)){
        goto L62;
       }
       if (v10qualifiers==ECL_NIL) {
        goto L58;
       }
       goto L59;
L62:;
       goto L59;
L59:;
       goto L45;
L58:;
      }
      v4principal = CONS(v7_method_,v4principal);
      goto L13;
L40:;
      cl_invalid_method_error(3, v7_method_, VV[80], v8_method_qualifiers_);
     }
L13:;
    }
    v6 = ecl_cdr(v6);
L9:;
    if (Null(v6)){
     goto L67;
    }
    goto L8;
L67:;
   }
   v4principal = cl_nreverse(v4principal);
   if (v4principal!=ECL_NIL) {
    goto L71;
   }
   cl_error(2, VV[53], VV[18]);
L71:;
   v5around = cl_nreverse(v5around);
   {
    cl_object v6main_effective_method;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cfun_va((cl_objectfn)LC1924__lambda481_va,ECL_NIL,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       if (!((v3order)==(VV[54]))){
        goto L81;
       }
       v11 = cl_reverse(v4principal);
       goto L80;
L81:;
       v11 = v4principal;
L80:;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L88:;
       if (!(ecl_endp(v10))){
        goto L90;
       }
       goto L89;
L90:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v13;
       }
       T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v12,T2);
       goto L88;
L89:;
       T1 = ecl_cdr(v11);
       goto L77;
      }
     }
    }
L77:;
    v6main_effective_method = CONS(ECL_SYM("OR",616),T1);
    if (Null(v5around)){
     goto L106;
    }
    T1 = ecl_car(v5around);
    T2 = ecl_cdr(v5around);
    T3 = cl_list(2, ECL_SYM("MAKE-METHOD",957), v6main_effective_method);
    T4 = ecl_list1(T3);
    T5 = ecl_append(T2,T4);
    T0 = cl_list(3, ECL_SYM("CALL-METHOD",934), T1, T5);
    goto L2;
L106:;
    if (Null(ecl_cdr(v4principal))){
     goto L108;
    }
    T0 = v6main_effective_method;
    goto L2;
L108:;
    T0 = ecl_cadr(v6main_effective_method);
   }
  }
L2:;
  value0 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(2, T0, ECL_T) /*  EFFECTIVE-METHOD-FUNCTION */;
  return value0;
 }
}
/* local function LAMBDA91                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1901__lambda91(cl_object v1v)
{
 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_list(2, ECL_SYM("QUOTE",682), v1v);
 value0 = cl_list(2, v1v, T0);
 return value0;
}
static cl_object LC1901__lambda91_va(cl_narg narg, cl_object v2v, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[34]);
 {
  return LC1901__lambda91(v2v);
 }
}
/* local function PARSE-QUALIFIER-PATTERN                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1903parse_qualifier_pattern(cl_object v1pattern)
{
 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 (!((v1pattern)==(ECL_SYM("*",20)))){
  goto L2;
 }
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v1pattern)==(ECL_NIL))){
  goto L4;
 }
 value0 = VV[41];
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 if (!(ECL_SYMBOLP(v1pattern))){
  goto L6;
 }
 value0 = cl_list(2, v1pattern, VV[42]);
 return value0;
L6:;
 if (!(ECL_LISTP(v1pattern))){
  goto L8;
 }
 T0 = cl_list(2, ECL_SYM("QUOTE",682), v1pattern);
 T1 = cl_list(3, VV[43], T0, VV[44]);
 T2 = cl_list(2, T1, VV[45]);
 value0 = cl_listX(3, ECL_SYM("DO",309), T2, VV[46]);
 return value0;
L8:;
 value0 = cl_error(2, VV[47], v1pattern);
 return value0;
}
static cl_object LC1903parse_qualifier_pattern_va(cl_narg narg, cl_object v2pattern, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[40]);
 {
  return LC1903parse_qualifier_pattern(v2pattern);
 }
}
/* local function LAMBDA273                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1908__lambda273(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1908__lambda273_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[81]);
 {
  return LC1908__lambda273(v2x);
 }
}
/* local function LAMBDA299                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1910__lambda299(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1910__lambda299_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[84]);
 {
  return LC1910__lambda299(v2x);
 }
}
/* local function LAMBDA325                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1912__lambda325(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1912__lambda325_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[87]);
 {
  return LC1912__lambda325(v2x);
 }
}
/* local function LAMBDA351                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1914__lambda351(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1914__lambda351_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[90]);
 {
  return LC1914__lambda351(v2x);
 }
}
/* local function LAMBDA377                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1916__lambda377(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1916__lambda377_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[93]);
 {
  return LC1916__lambda377(v2x);
 }
}
/* local function LAMBDA403                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1918__lambda403(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1918__lambda403_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[96]);
 {
  return LC1918__lambda403(v2x);
 }
}
/* local function LAMBDA429                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1920__lambda429(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1920__lambda429_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[99]);
 {
  return LC1920__lambda429(v2x);
 }
}
/* local function LAMBDA455                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1922__lambda455(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1922__lambda455_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[102]);
 {
  return LC1922__lambda455(v2x);
 }
}
/* local function LAMBDA481                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1924__lambda481(cl_object v1x)
{
 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_list(3, ECL_SYM("CALL-METHOD",934), v1x, ECL_NIL);
 return value0;
}
static cl_object LC1924__lambda481_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[105]);
 {
  return LC1924__lambda481(v2x);
 }
}
#include "clos/defcombin.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclZzkmRpkmicDq9_L230M881(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;DEFCOMBIN.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclZzkmRpkmicDq9_L230M881@";
 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 = mp_make_lock(2, ECL_SYM("NAME",1309), ECL_SYM("FIND-METHOD-COMBINATION",1590));
  ecl_cmp_setq(cl_env_copy,VV[0],T0);
  si_Xmake_special(VV[1]);
  T0 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_int8_t(32), ECL_SYM("TEST",1353), ECL_SYM("EQ",335));
  ecl_cmp_setq(cl_env_copy,VV[1],T0);
  ecl_cmp_defun(VV[106]);                         /*  SEARCH-METHOD-COMBINATION */
  ecl_cmp_defun(VV[107]);                         /*  INSTALL-METHOD-COMBINATION */
  ecl_cmp_defun(VV[108]);                         /*  MAKE-METHOD-COMBINATION */
  ecl_cmp_defun(VV[109]);                         /*  FIND-METHOD-COMBINATION */
  ecl_cmp_defun(VV[110]);                         /*  DEFINE-SIMPLE-METHOD-COMBINATION */
  ecl_cmp_defun(VV[111]);                         /*  METHOD-COMBINATION-ARGUMENTS-RESHUFFLING */
  (void)0; /* No entry created for PROCESS-DEFINE-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST */
  ecl_cmp_defmacro(VV[112]);                      /*  WITH-METHOD-GROUPS      */
  (void)0; /* No entry created for DEFINE-COMPLEX-METHOD-COMBINATION */
  ecl_cmp_defmacro(VV[113]);                      /*  DEFINE-METHOD-COMBINATION */
  (void)0; /* No entry created for METHOD-COMBINATION-ERROR */
  (void)0; /* No entry created for INVALID-METHOD-ERROR */
  L1890install_method_combination(ECL_SYM("STANDARD",976), VV[76]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1909__lambda251,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("PROGN",674), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1911__lambda277,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("AND",89), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1913__lambda303,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("MAX",553), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1915__lambda329,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("+",16), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1917__lambda355,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("NCONC",583), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1919__lambda381,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("APPEND",90), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1921__lambda407,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("LIST",483), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1923__lambda433,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("MIN",559), T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC1925__lambda459,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  L1890install_method_combination(ECL_SYM("OR",616), T0);
 }
}
