/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/method.lsp                     */
#include <ecl/ecl-cmp.h>
#include "clos/method.eclh"
/* function definition for GENERIC-FUNCTION-METHOD-CLASS                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1784generic_function_method_class(cl_object v1generic_function)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[3]))){
  goto L2;
 }
 value0 = cl_slot_value(v1generic_function, VV[4]);
 return value0;
L2:;
 value0 = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
 return value0;
}
static cl_object L1784generic_function_method_class_va(cl_narg narg, cl_object v2generic_function, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[5]);
 {
  return L1784generic_function_method_class(v2generic_function);
 }
}
/* function definition for PROTOTYPES-FOR-MAKE-METHOD-LAMBDA                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1785prototypes_for_make_method_lambda(cl_object v1name)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (ecl_cmp_symbol_value(cl_env_copy,VV[3])!=ECL_NIL) {
  goto L2;
 }
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_NIL;
 cl_env_copy->values[0] = ECL_NIL;
 return cl_env_copy->values[0];
L2:;
 {
  cl_object v2gf_;
  if (Null(cl_fboundp(v1name))){
   goto L6;
  }
  v2gf_ = cl_fdefinition(v1name);
  goto L4;
L6:;
  v2gf_ = ECL_NIL;
  goto L4;
L4:;
  if (v2gf_==ECL_NIL) {
   goto L10;
  }
  if (ECL_INSTANCEP(v2gf_)) {
   goto L8;
  }
  goto L9;
L10:;
L9:;
  T0 = cl_find_class(1, ECL_SYM("STANDARD-GENERIC-FUNCTION",978));
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-PROTOTYPE",1569)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-PROTOTYPE */;
  T2 = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
  T3 = (cl_env_copy->function=(ECL_SYM("CLASS-PROTOTYPE",1569)->symbol.gfdef))->cfun.entry(1, T2) /*  CLASS-PROTOTYPE */;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T3;
  cl_env_copy->values[0] = T1;
  return cl_env_copy->values[0];
L8:;
  value0 = L1784generic_function_method_class(v2gf_);
  if (value0!=ECL_NIL) {
   goto L14;
  }
  T0 = cl_find_class(1, ECL_SYM("STANDARD-METHOD",979));
  goto L12;
L14:;
  T0 = value0;
  goto L12;
L12:;
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-PROTOTYPE",1569)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-PROTOTYPE */;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T1;
  cl_env_copy->values[0] = v2gf_;
  return cl_env_copy->values[0];
 }
}
static cl_object L1785prototypes_for_make_method_lambda_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[6]);
 {
  return L1785prototypes_for_make_method_lambda(v3name);
 }
}
/* local function DEFMETHOD                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1786defmethod(cl_object v1, cl_object v2env)
{
 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);
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;
  }
  {
   cl_object v5;                                  /*  QUALIFIERS              */
   cl_object v6;                                  /*  SPECIALIZED-LAMBDA-LIST */
   cl_object v7;                                  /*  BODY                    */
   value0 = L1797parse_defmethod(v3);
   {
    const int v8 = cl_env_copy->nvalues;
    v5 = value0;
    cl_object v9;
    v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
    v6 = v9;
    v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v9;
   }
   {
    cl_object v8;                                 /*  LAMBDA-LIST             */
    cl_object v9;                                 /*  REQUIRED-PARAMETERS     */
    cl_object v10;                                /*  SPECIALIZERS            */
    value0 = L1799parse_specialized_lambda_list(v6);
    {
     const int v11 = cl_env_copy->nvalues;
     v8 = value0;
     cl_object v12;
     v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
     v9 = v12;
     v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2];
     v10 = v12;
    }
    {
     cl_object v11;                               /*  LAMBDA-FORM             */
     cl_object v12;                               /*  DOCUMENTATION           */
     value0 = L1790make_raw_lambda(v4name, v8, v9, v10, v7, v2env);
     {
      const int v13 = cl_env_copy->nvalues;
      v11 = value0;
      cl_object v14;
      v14 = (v13<=2)? ECL_NIL : cl_env_copy->values[2];
      v12 = v14;
     }
     {
      cl_object v13;                              /*  PROTO-GF                */
      cl_object v14;                              /*  PROTO-METHOD            */
      value0 = L1785prototypes_for_make_method_lambda(v4name);
      {
       const int v15 = cl_env_copy->nvalues;
       v13 = value0;
       cl_object v16;
       v16 = (v15<=1)? ECL_NIL : cl_env_copy->values[1];
       v14 = v16;
      }
      {
       cl_object v15;                             /*  FN-FORM                 */
       cl_object v16;                             /*  OPTIONS                 */
       value0 = (cl_env_copy->function=(VV[35]->symbol.gfdef))->cfun.entry(4, v13, v14, v11, v2env) /*  MAKE-METHOD-LAMBDA */;
       {
        const int v17 = cl_env_copy->nvalues;
        v15 = value0;
        cl_object v18;
        v18 = (v17<=1)? ECL_NIL : cl_env_copy->values[1];
        v16 = v18;
       }
       if (Null(v12)){
        goto L14;
       }
       v16 = cl_listX(3, ECL_SYM("DOCUMENTATION",1253), v12, v16);
L14:;
       if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
        goto L17;
       }
       T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
       T1 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
       T2 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
       T3 = cl_list(2, ECL_SYM("QUOTE",682), v5);
       T4 = L1787specializers_expression(v10);
       T5 = cl_list(2, ECL_SYM("QUOTE",682), v8);
       T6 = L1789simplify_lambda(v15);
       T7 = L1788maybe_remove_block(T6);
       {
        cl_object v17;
        v17 = ecl_fdefinition(ECL_SYM("MAYBE-QUOTE",1764));
        {
         cl_object v18;
         cl_object v19;
         cl_object v20;
         {
          cl_object v21;
          v21 = v16;
          if (ecl_unlikely(!ECL_LISTP(v21))) FEtype_error_list(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v18 = v21;
         }
         v19 = ECL_NIL;
         v20 = v18;
         {
          cl_object v21;
          cl_object v22;
          v21 = ecl_list1(ECL_NIL);
          v22 = v21;
L29:;
          if (!(ecl_endp(v20))){
          goto L31;
          }
          goto L30;
L31:;
          v19 = ECL_CONS_CAR(v20);
          {
          cl_object v23;
          v23 = ECL_CONS_CDR(v20);
          if (ecl_unlikely(!ECL_LISTP(v23))) FEtype_error_list(v23);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v20 = v23;
          }
          {
          cl_object v23;
          v23 = v22;
          if (ecl_unlikely(ECL_ATOM(v23))) FEtype_error_cons(v23);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T9 = v23;
          }
          T10 = ecl_function_dispatch(cl_env_copy,v17)(1, v19);
          v22 = ecl_list1(T10);
          (ECL_CONS_CDR(T9)=v22,T9);
          goto L29;
L30:;
          T8 = ecl_cdr(v21);
          goto L20;
         }
        }
       }
L20:;
       T9 = cl_listX(7, VV[12], T2, T3, T4, T5, T7, T8);
       value0 = ecl_function_dispatch(cl_env_copy,T0)(3, T1, v1, T9);
       return value0;
L17:;
       T0 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
       T1 = cl_list(2, ECL_SYM("QUOTE",682), v5);
       T2 = L1787specializers_expression(v10);
       T3 = cl_list(2, ECL_SYM("QUOTE",682), v8);
       T4 = L1789simplify_lambda(v15);
       T5 = L1788maybe_remove_block(T4);
       {
        cl_object v17;
        v17 = ecl_fdefinition(ECL_SYM("MAYBE-QUOTE",1764));
        {
         cl_object v18;
         cl_object v19;
         cl_object v20;
         {
          cl_object v21;
          v21 = v16;
          if (ecl_unlikely(!ECL_LISTP(v21))) FEtype_error_list(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v18 = v21;
         }
         v19 = ECL_NIL;
         v20 = v18;
         {
          cl_object v21;
          cl_object v22;
          v21 = ecl_list1(ECL_NIL);
          v22 = v21;
L56:;
          if (!(ecl_endp(v20))){
          goto L58;
          }
          goto L57;
L58:;
          v19 = ECL_CONS_CAR(v20);
          {
          cl_object v23;
          v23 = ECL_CONS_CDR(v20);
          if (ecl_unlikely(!ECL_LISTP(v23))) FEtype_error_list(v23);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v20 = v23;
          }
          {
          cl_object v23;
          v23 = v22;
          if (ecl_unlikely(ECL_ATOM(v23))) FEtype_error_cons(v23);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T7 = v23;
          }
          T8 = ecl_function_dispatch(cl_env_copy,v17)(1, v19);
          v22 = ecl_list1(T8);
          (ECL_CONS_CDR(T7)=v22,T7);
          goto L56;
L57:;
          T6 = ecl_cdr(v21);
          goto L47;
         }
        }
       }
L47:;
       value0 = cl_listX(7, VV[12], T0, T1, T2, T3, T5, T6);
       return value0;
      }
     }
    }
   }
  }
 }
}
static cl_object LC1786defmethod_va(cl_narg narg, cl_object v5, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[21]);
 {
  return LC1786defmethod(v5, v6env);
 }
}
/* function definition for SPECIALIZERS-EXPRESSION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1787specializers_expression(cl_object v1specializers)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  cl_object v3spec;
  cl_object v4;
  {
   cl_object v5;
   v5 = v1specializers;
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v5;
  }
  v3spec = ECL_NIL;
  v4 = v2;
  {
   cl_object v5;
   cl_object v6;
   v5 = ecl_list1(ECL_NIL);
   v6 = v5;
L10:;
   if (!(ecl_endp(v4))){
    goto L12;
   }
   goto L11;
L12:;
   v3spec = ECL_CONS_CAR(v4);
   {
    cl_object v7;
    v7 = ECL_CONS_CDR(v4);
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   {
    cl_object v7;
    v7 = v6;
    if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T1 = v7;
   }
   if (!(ECL_ATOM(v3spec))){
    goto L26;
   }
   T2 = v3spec;
   goto L25;
L26:;
   {
    cl_object v7value;
    v7value = ecl_cadr(v3spec);
    if (!(ECL_ATOM(v7value))){
     goto L32;
    }
    if (ECL_SYMBOLP(v7value)) {
     goto L30;
    }
    goto L31;
L32:;
    T4 = ecl_car(v7value);
    if (!((T4)==(ECL_SYM("QUOTE",682)))){
     goto L30;
    }
L31:;
    T3 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("CONSTANT-FORM-VALUE",2161)))->cfun.entry(1, v7value) /*  CONSTANT-FORM-VALUE */;
    goto L28;
L30:;
    T3 = cl_list(2, ECL_SYM("UNQUOTE",1038), v7value);
   }
L28:;
   T2 = cl_list(2, ECL_SYM("EQL",336), T3);
L25:;
   v6 = ecl_list1(T2);
   (ECL_CONS_CDR(T1)=v6,T1);
   goto L10;
L11:;
   T0 = ecl_cdr(v5);
   goto L2;
  }
 }
L2:;
 value0 = cl_list(2, ECL_SYM("QUASIQUOTE",1545), T0);
 return value0;
}
/* function definition for MAYBE-REMOVE-BLOCK                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1788maybe_remove_block(cl_object v1method_lambda)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1method_lambda);
 if (!((T0)==(ECL_SYM("LAMBDA",454)))){
  goto L2;
 }
 {
  cl_object v2;                                   /*  DECLARATIONS            */
  cl_object v3;                                   /*  BODY                    */
  T0 = ecl_cddr(v1method_lambda);
  value0 = si_find_declarations(1, T0);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  {
   cl_object v4block;
   v4block = ECL_NIL;
   T0 = ecl_cdr(v3);
   if (!(T0==ECL_NIL)){
    goto L2;
   }
   v4block = ecl_car(v3);
   if (!(ECL_LISTP(v4block))){
    goto L2;
   }
   T0 = ecl_car(v4block);
   if (!((T0)==(ECL_SYM("BLOCK",139)))){
    goto L2;
   }
   T0 = ecl_cadr(v4block);
   T1 = ecl_cadr(v1method_lambda);
   T2 = ecl_cddr(v4block);
   T3 = ecl_append(v2,T2);
   v1method_lambda = cl_listX(4, ECL_SYM("LAMBDA-BLOCK",1377), T0, T1, T3);
  }
 }
L2:;
 value0 = v1method_lambda;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1788maybe_remove_block_va(cl_narg narg, cl_object v2method_lambda, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[14]);
 {
  return L1788maybe_remove_block(v2method_lambda);
 }
}
/* function definition for SIMPLIFY-LAMBDA                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1789simplify_lambda(cl_object v1fn_form)
{
 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 v2aux;
  v2aux = v1fn_form;
  {
   cl_object v3;
   v3 = v2aux;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[26],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L11;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v2aux = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L11:;
   T0 = v3;
  }
  if (!((T0)==(ECL_SYM("LAMBDA",454)))){
   goto L3;
  }
  {
   cl_object v3;
   v3 = v2aux;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[26],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L23;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v2aux = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L23:;
   T0 = v3;
  }
  if (!(ecl_equalp(T0,VV[27]))){
   goto L3;
  }
  {
   cl_object v3;
   v3 = v2aux;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[26],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L35;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v2aux = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L35:;
   T0 = v3;
  }
  if (!(ecl_equalp(T0,VV[28]))){
   goto L3;
  }
  T0 = ecl_cdr(v2aux);
  if (!(T0==ECL_NIL)){
   goto L3;
  }
  v2aux = ecl_car(v2aux);
  {
   cl_fixnum v3;
   v3 = ecl_length(v2aux);
   if (!((v3)==((cl_fixnum)(3)))){
    goto L3;
   }
  }
  T0 = ecl_car(v2aux);
  if (!((T0)==(ECL_SYM("APPLY",91)))){
   goto L3;
  }
  T0 = ecl_caddr(v2aux);
  if (!((T0)==(ECL_SYM(".COMBINED-METHOD-ARGS.",1547)))){
   goto L3;
  }
  v2aux = ecl_cadr(v2aux);
  if (!(ECL_LISTP(v2aux))){
   goto L3;
  }
  T0 = ecl_car(v2aux);
  if (!((T0)==(ECL_SYM("LAMBDA",454)))){
   goto L3;
  }
  value0 = v2aux;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = cl_error(1, VV[29]);
  return value0;
 }
}
static cl_object L1789simplify_lambda_va(cl_narg narg, cl_object v3fn_form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[15]);
 {
  return L1789simplify_lambda(v3fn_form);
 }
}
/* function definition for MAKE-RAW-LAMBDA                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1790make_raw_lambda(cl_object v1name, cl_object v2lambda_list, cl_object v3required_parameters, cl_object v4specializers, cl_object v5body, cl_object v6env)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v7;                                   /*  DECLARATIONS            */
  cl_object v8;                                   /*  REAL-BODY               */
  cl_object v9;                                   /*  DOCUMENTATION           */
  value0 = si_find_declarations(1, v5body);
  {
   const int v10 = cl_env_copy->nvalues;
   v7 = value0;
   cl_object v11;
   v11 = (v10<=1)? ECL_NIL : cl_env_copy->values[1];
   v8 = v11;
   v11 = (v10<=2)? ECL_NIL : cl_env_copy->values[2];
   v9 = v11;
  }
  {
   cl_object v10;
   cl_object v11;
   v10 = ECL_SYM("&KEY",12);
   v11 = v2lambda_list;
   if (Null(ecl_memql(v10,v11))){
    goto L3;
   }
  }
  {
   cl_object v10;
   cl_object v11;
   v10 = ECL_SYM("&ALLOW-OTHER-KEYS",8);
   v11 = v2lambda_list;
   if (ecl_memql(v10,v11)!=ECL_NIL) {
    goto L3;
   }
  }
  {
   cl_object v10x;
   v10x = cl_position(2, ECL_SYM("&AUX",9), v2lambda_list);
   T0 = cl_subseq(3, v2lambda_list, ecl_make_int8_t(0), v10x);
   if (Null(v10x)){
    goto L14;
   }
   T1 = cl_subseq(2, v2lambda_list, v10x);
   goto L12;
L14:;
   T1 = ECL_NIL;
   goto L12;
L12:;
   v2lambda_list = cl_append(4, T0, VV[31], T1, ECL_NIL);
  }
L3:;
  {
   cl_object v10copied_variables;
   cl_object v11ignorable;
   cl_object v12block_name;
   cl_object v13class_declarations;
   cl_object v14block;
   cl_object v15method_lambda;
   v10copied_variables = ECL_NIL;
   T0 = CONS(ECL_SYM("IGNORABLE",429),v3required_parameters);
   v11ignorable = cl_list(2, ECL_SYM("DECLARE",276), T0);
   v12block_name = si_function_block_name(v1name);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[2]))){
    goto L21;
   }
   {
    cl_object v16;
    cl_object v17name;
    cl_object v18;
    {
     cl_object v19;
     v19 = v3required_parameters;
     if (ecl_unlikely(!ECL_LISTP(v19))) FEtype_error_list(v19);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v16 = v19;
    }
    v17name = ECL_NIL;
    v18 = v16;
    {
     cl_object v19;
     cl_object v20type;
     cl_object v21;
     {
      cl_object v22;
      v22 = v4specializers;
      if (ecl_unlikely(!ECL_LISTP(v22))) FEtype_error_list(v22);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v19 = v22;
     }
     v20type = ECL_NIL;
     v21 = v19;
     {
      cl_object v22;
      cl_object v23;
      v22 = ecl_list1(ECL_NIL);
      v23 = v22;
L35:;
      if (!(ecl_endp(v18))){
       goto L37;
      }
      goto L36;
L37:;
      v17name = ECL_CONS_CAR(v18);
      {
       cl_object v24;
       v24 = ECL_CONS_CDR(v18);
       if (ecl_unlikely(!ECL_LISTP(v24))) FEtype_error_list(v24);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v18 = v24;
      }
      if (!(ecl_endp(v21))){
       goto L45;
      }
      goto L36;
L45:;
      v20type = ECL_CONS_CAR(v21);
      {
       cl_object v24;
       v24 = ECL_CONS_CDR(v21);
       if (ecl_unlikely(!ECL_LISTP(v24))) FEtype_error_list(v24);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v21 = v24;
      }
      if ((v20type)==(ECL_T)) {
       goto L53;
      }
      if (!(ECL_SYMBOLP(v20type))){
       goto L53;
      }
      T1 = cl_list(2, v17name, v17name);
      v10copied_variables = CONS(T1,v10copied_variables);
      {
       cl_object v24;
       T2 = cl_list(3, ECL_SYM("TYPE",872), v20type, v17name);
       T3 = cl_list(2, VV[32], v17name);
       v24 = cl_list(2, T2, T3);
       {
        cl_object v25;
        v25 = v23;
        if (ecl_unlikely(ECL_ATOM(v25))) FEtype_error_cons(v25);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v25;
       }
       (ECL_CONS_CDR(T2)=v24,T2);
       T1 = v24;
      }
      v23 = ecl_cdr(T1);
L53:;
      goto L35;
L36:;
      T0 = ecl_cdr(v22);
      goto L20;
     }
    }
   }
L21:;
   T0 = ECL_NIL;
L20:;
   T1 = cl_list(2, ECL_SYM("FUNCTION-BLOCK-NAME",1091), v12block_name);
   T2 = ecl_list1(T1);
   T3 = ecl_cdar(v7);
   v13class_declarations = cl_nconc(3, T0, T2, T3);
   v14block = cl_listX(3, ECL_SYM("BLOCK",139), v12block_name, v8);
   if (Null(v13class_declarations)){
    goto L71;
   }
   T1 = CONS(ECL_SYM("DECLARE",276),v13class_declarations);
   T0 = ecl_list1(T1);
   goto L69;
L71:;
   T0 = ECL_NIL;
   goto L69;
L69:;
   if (Null(v10copied_variables)){
    goto L74;
   }
   T1 = cl_list(4, ECL_SYM("LET*",480), v10copied_variables, v11ignorable, v14block);
   goto L73;
L74:;
   T1 = v14block;
L73:;
   T2 = cl_list(2, v11ignorable, T1);
   T3 = ecl_append(T0,T2);
   v15method_lambda = cl_listX(3, ECL_SYM("LAMBDA",454), v2lambda_list, T3);
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = v9;
   cl_env_copy->values[1] = v7;
   cl_env_copy->values[0] = v15method_lambda;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for MAKE-METHOD-LAMBDA                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1791make_method_lambda(cl_object v1gf, cl_object v2method, cl_object v3method_lambda, cl_object v4env)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v5;                                   /*  IN-CLOSURE-P            */
  value0 = L1795walk_method_lambda(v3method_lambda, v4env);
  {
   const int v6 = cl_env_copy->nvalues;
   cl_object v7;
   v7 = (v6<=2)? ECL_NIL : cl_env_copy->values[2];
   v5 = v7;
  }
  if (Null(v5)){
   goto L4;
  }
  T0 = L1792add_call_next_method_closure(v3method_lambda);
  goto L3;
L4:;
  T0 = v3method_lambda;
L3:;
  T1 = cl_list(3, ECL_SYM("APPLY",91), T0, ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
  T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[27], VV[28], T1);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = T2;
  return cl_env_copy->values[0];
 }
}
static cl_object L1791make_method_lambda_va(cl_narg narg, cl_object v5gf, cl_object v6method, cl_object v7method_lambda, cl_object v8env, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[35]);
 {
  return L1791make_method_lambda(v5gf, v6method, v7method_lambda, v8env);
 }
}
/* function definition for ADD-CALL-NEXT-METHOD-CLOSURE                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1792add_call_next_method_closure(cl_object v1method_lambda)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;                                   /*  DECLARATIONS            */
  cl_object v3;                                   /*  REAL-BODY               */
  T0 = ecl_cddr(v1method_lambda);
  value0 = si_find_declarations(1, T0);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  T0 = ecl_cadr(v1method_lambda);
  T1 = cl_listX(3, ECL_SYM("FLET",375), VV[37], v3);
  T2 = cl_list(3, ECL_SYM("LET*",480), VV[36], T1);
  T3 = ecl_list1(T2);
  T4 = ecl_append(v2,T3);
  value0 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, T4);
  return value0;
 }
}
static cl_object L1792add_call_next_method_closure_va(cl_narg narg, cl_object v2method_lambda, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[34]);
 {
  return L1792add_call_next_method_closure(v2method_lambda);
 }
}
/* function definition for ENVIRONMENT-CONTAINS-CLOSURE                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1793environment_contains_closure(cl_object v1env)
{
 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_fixnum v2counter;
  v2counter = (cl_fixnum)(0);
  {
   cl_object v3;
   v3 = ecl_car(v1env);
   goto L6;
L5:;
   {
    cl_object v4item;
    v4item = ecl_car(v3);
    if (!((v4item)==(ECL_SYM("FUNCTION-BOUNDARY",1947)))){
     goto L10;
    }
    {
     cl_object v5;
     v5 = ecl_plus(ecl_make_fixnum(v2counter),ecl_make_int8_t(1));
     {
      bool v6;
      v6 = ECL_FIXNUMP(v5);
      if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v5);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
     v2counter = ecl_fixnum(v5);
    }
    T0 = ecl_make_fixnum(v2counter);
    if (!((ecl_fixnum(T0))>((cl_fixnum)(1)))){
     goto L10;
    }
    value0 = ECL_T;
    cl_env_copy->nvalues = 1;
    return value0;
L10:;
   }
   v3 = ecl_cdr(v3);
L6:;
   if (Null(v3)){
    goto L19;
   }
   goto L5;
L19:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L1793environment_contains_closure_va(cl_narg narg, cl_object v4env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[39]);
 {
  return L1793environment_contains_closure(v4env);
 }
}
/* function definition for WALK-METHOD-LAMBDA                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1795walk_method_lambda(cl_object v1method_lambda, cl_object v2env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1, CLV2;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object env1 = env0;
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(ECL_NIL,env1);               /*  CALL-NEXT-METHOD-P      */
  CLV1 = env1 = CONS(ECL_NIL,env1);               /*  NEXT-METHOD-P-P         */
  CLV2 = env1 = CONS(ECL_NIL,env1);               /*  IN-CLOSURE-P            */
  {
   cl_object v3;
   v3 = ecl_make_cclosure_va((cl_objectfn)LC1794code_walker,env1,Cblock,2);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*CODE-WALKER*",1665),v3); /*  *CODE-WALKER* */
   si_eval_with_env(5, v1method_lambda, v2env, ECL_NIL, ECL_T, ECL_SYM("COMPILE-TOPLEVEL",1238));
   ecl_bds_unwind1(cl_env_copy);
  }
  T0 = ECL_CONS_CAR(CLV0);
  T1 = ECL_CONS_CAR(CLV1);
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = ECL_CONS_CAR(CLV2);
  cl_env_copy->values[1] = T1;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
 }
}
/* function definition for LEGAL-GENERIC-FUNCTION-NAME-P                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1796legal_generic_function_name_p(cl_object v1name)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_valid_function_name_p(v1name);
 return value0;
}
static cl_object L1796legal_generic_function_name_p_va(cl_narg narg, cl_object v2name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[42]);
 {
  return L1796legal_generic_function_name_p(v2name);
 }
}
/* function definition for PARSE-DEFMETHOD                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1797parse_defmethod(cl_object v1cdr_of_form)
{
 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 v2qualifiers;
  cl_object v3spec_ll;
  v2qualifiers = ECL_NIL;
  v3spec_ll = ECL_NIL;
L5:;
  if (Null(ecl_car(v1cdr_of_form))){
   goto L7;
  }
  T0 = ecl_car(v1cdr_of_form);
  if (!(ECL_ATOM(T0))){
   goto L7;
  }
  {
   cl_object v4;
   v4 = v1cdr_of_form;
   {
    cl_object v5;
    v5 = v4;
    {
     bool v6;
     v6 = ECL_LISTP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(VV[26],v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v4)){
    goto L16;
   }
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v4);
    {
     cl_object v6;
     v6 = v5;
     if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v1cdr_of_form = v6;
    }
    v4 = ECL_CONS_CAR(v4);
   }
L16:;
   T0 = v4;
  }
  v2qualifiers = CONS(T0,v2qualifiers);
  goto L6;
L7:;
  v2qualifiers = cl_nreverse(v2qualifiers);
  goto L4;
L6:;
  goto L5;
L4:;
  {
   cl_object v4;
   v4 = v1cdr_of_form;
   {
    cl_object v5;
    v5 = v4;
    {
     bool v6;
     v6 = ECL_LISTP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(VV[26],v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v4)){
    goto L32;
   }
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v4);
    {
     cl_object v6;
     v6 = v5;
     if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v1cdr_of_form = v6;
    }
    v4 = ECL_CONS_CAR(v4);
   }
L32:;
   v3spec_ll = v4;
  }
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = v1cdr_of_form;
  cl_env_copy->values[1] = v3spec_ll;
  cl_env_copy->values[0] = v2qualifiers;
  return cl_env_copy->values[0];
 }
}
/* function definition for IMPLICIT-GENERIC-LAMBDA                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1798implicit_generic_lambda(cl_object v1lambda_list)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(v1lambda_list)){
  goto L2;
 }
 {
  cl_object v2acc;
  v2acc = ECL_NIL;
  {
   cl_object v3ll;
   cl_object v4elt;
   v3ll = v1lambda_list;
   v4elt = ecl_car(v3ll);
   goto L9;
L8:;
   v2acc = CONS(v4elt,v2acc);
   v3ll = ecl_cdr(v3ll);
   v4elt = ecl_car(v3ll);
L9:;
   T0 = ecl_cdr(v3ll);
   if (ecl_endp(T0)) {
    goto L17;
   }
   if ((v4elt)==(ECL_SYM("&KEY",12))) {
    goto L17;
   }
   goto L8;
L17:;
   T0 = CONS(v4elt,v2acc);
   value0 = cl_nreverse(T0);
   return value0;
  }
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1798implicit_generic_lambda_va(cl_narg narg, cl_object v5lambda_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[44]);
 {
  return L1798implicit_generic_lambda(v5lambda_list);
 }
}
/* function definition for EXTRACT-LAMBDA-LIST                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object clos_extract_lambda_list(cl_object v1specialized_lambda_list)
{
 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 = L1799parse_specialized_lambda_list(v1specialized_lambda_list);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for EXTRACT-SPECIALIZER-NAMES                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object clos_extract_specializer_names(cl_object v1specialized_lambda_list)
{
 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:;
 {
  struct ecl_stack_frame _ecl_inner_frame_aux;
  cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
  cl_env_copy->values[0] = L1799parse_specialized_lambda_list(v1specialized_lambda_list);
  ecl_stack_frame_push_values(_ecl_inner_frame);
  T0 = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
  ecl_stack_frame_close(_ecl_inner_frame);
 }
 value0 = ecl_caddr(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for PARSE-SPECIALIZED-LAMBDA-LIST                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1799parse_specialized_lambda_list(cl_object v1specialized_lambda_list)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2arglist;
  cl_object v3lambda_list;
  cl_object v4ll;
  cl_object v5required_parameters;
  cl_object v6specializers;
  cl_object v7arg;
  cl_object v8variable;
  cl_object v9specializer;
  T0 = si_process_lambda_list(v1specialized_lambda_list, ECL_SYM("METHOD",958));
  v2arglist = ecl_cdr(T0);
  v3lambda_list = cl_copy_list(v1specialized_lambda_list);
  v4ll = v3lambda_list;
  v5required_parameters = ECL_NIL;
  v6specializers = ECL_NIL;
  v7arg = ECL_NIL;
  v8variable = ECL_NIL;
  v9specializer = ECL_NIL;
  goto L12;
L11:;
  v7arg = ecl_car(v2arglist);
  if (!(ECL_ATOM(v7arg))){
   goto L17;
  }
  v8variable = v7arg;
  v9specializer = ECL_T;
  goto L16;
L17:;
  T0 = ecl_cddr(v7arg);
  if (ecl_endp(T0)) {
   goto L22;
  }
  si_simple_program_error(2, VV[46], v7arg);
  goto L16;
L22:;
  v8variable = ecl_car(v7arg);
  v9specializer = ecl_cadr(v7arg);
  if (!(v9specializer==ECL_NIL)){
   goto L24;
  }
  si_simple_program_error(1, VV[47]);
  goto L16;
L24:;
  {
   cl_object v10;
   v10 = ecl_make_bool(ECL_ATOM(v9specializer));
   if (Null(v10)){
    goto L30;
   }
   goto L16;
L30:;
   {
    cl_object v11;
    T0 = ecl_car(v9specializer);
    if (!((T0)==(ECL_SYM("EQL",336)))){
     goto L34;
    }
    if (Null(ecl_cdr(v9specializer))){
     goto L34;
    }
    T0 = ecl_cddr(v9specializer);
    v11 = ecl_make_bool(ecl_endp(T0));
    goto L32;
L34:;
    v11 = ECL_NIL;
    goto L32;
L32:;
    if (Null(v11)){
     goto L37;
    }
    goto L16;
L37:;
    si_simple_program_error(2, VV[46], v7arg);
   }
  }
L16:;
  {
   cl_object v10;
   v10 = v8variable;
   {
    cl_object v11;
    v11 = v4ll;
    if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v11;
   }
   (ECL_CONS_CAR(T0)=v10,T0);
  }
  v5required_parameters = CONS(v8variable,v5required_parameters);
  v6specializers = CONS(v9specializer,v6specializers);
  v2arglist = ecl_cdr(v2arglist);
  v4ll = ecl_cdr(v4ll);
L12:;
  if (v2arglist==ECL_NIL) {
   goto L53;
  }
  goto L11;
L53:;
  T0 = cl_nreverse(v5required_parameters);
  T1 = cl_nreverse(v6specializers);
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = T1;
  cl_env_copy->values[1] = T0;
  cl_env_copy->values[0] = v3lambda_list;
  return cl_env_copy->values[0];
 }
}
/* function definition for DECLARATION-SPECIALIZERS                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1800declaration_specializers(cl_object v1arglist, cl_object v2declarations)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4argscan;
  cl_object v5declist;
  if (Null(v2declarations)){
   goto L3;
  }
  v3 = ecl_cdr(v2declarations);
  goto L2;
L3:;
  v3 = ECL_NIL;
L2:;
  v4argscan = v1arglist;
  v5declist = v3;
  goto L9;
L8:;
  T0 = ecl_car(v4argscan);
  if (!(ECL_LISTP(T0))){
   goto L11;
  }
  T0 = ecl_cadar(v4argscan);
  T1 = ecl_caar(v4argscan);
  T2 = cl_list(3, ECL_SYM("TYPE",872), T0, T1);
  v5declist = CONS(T2,v5declist);
L11:;
  v4argscan = ecl_cdr(v4argscan);
L9:;
  if (v4argscan==ECL_NIL) {
   goto L16;
  }
  {
   cl_object v6;
   cl_object v7;
   cl_object v8;
   v6 = ecl_car(v4argscan);
   v7 = v6;
   v8 = VV[49];
   if (ecl_memql(v7,v8)!=ECL_NIL) {
    goto L16;
   }
  }
  goto L8;
L16:;
  value0 = CONS(ECL_SYM("DECLARE",276),v5declist);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for COMPUTE-METHOD-KEYWORDS                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1801compute_method_keywords(cl_object v1lambda_list)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;                                   /*  KEYWORDS                */
  cl_object v3;                                   /*  ALLOW-OTHER-KEYS        */
  value0 = si_process_lambda_list(v1lambda_list, ECL_T);
  {
   const int v4 = cl_env_copy->nvalues;
   cl_object v5;
   v5 = (v4<=4)? ECL_NIL : cl_env_copy->values[4];
   v2 = v5;
   v5 = (v4<=5)? ECL_NIL : cl_env_copy->values[5];
   v3 = v5;
  }
  if (Null(v3)){
   goto L3;
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v4;
   cl_object v5k;
   cl_object v6;
   {
    cl_object v7;
    v7 = ecl_cdr(v2);
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   v5k = ECL_NIL;
   v6 = v4;
   {
    cl_object v7;
    cl_object v8;
    v7 = ecl_list1(ECL_NIL);
    v8 = v7;
L12:;
    if (!(ecl_endp(v6))){
     goto L14;
    }
    goto L13;
L14:;
    v5k = ECL_CONS_CAR(v6);
    {
     cl_object v9;
     v9 = ecl_cddddr(v6);
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v9;
    }
    {
     cl_object v9;
     v9 = v8;
     if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v9;
    }
    v8 = ecl_list1(v5k);
    (ECL_CONS_CDR(T0)=v8,T0);
    goto L12;
L13:;
    value0 = ecl_cdr(v7);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L1801compute_method_keywords_va(cl_narg narg, cl_object v2lambda_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[50]);
 {
  return L1801compute_method_keywords(v2lambda_list);
 }
}
/* function definition for MAKE-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1818make_method(cl_object v1method_class, cl_object v2qualifiers, cl_object v3specializers, cl_object v4lambda_list, cl_object v5fun, cl_object v6options)
{
 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 v7_class;
  cl_object v8method;
  if (!(ECL_INSTANCEP(v1method_class))){
   goto L3;
  }
  v7_class = v1method_class;
  goto L2;
L3:;
  v7_class = cl_find_class(1, v1method_class);
L2:;
  v8method = si_allocate_raw_instance(ECL_NIL, v7_class, ecl_make_int8_t(9));
  si_instance_set(v8method, ecl_make_int8_t(0), ECL_NIL);
  si_instance_set(v8method, ecl_make_int8_t(1), v4lambda_list);
  si_instance_set(v8method, ecl_make_int8_t(2), v3specializers);
  si_instance_set(v8method, ecl_make_int8_t(3), v2qualifiers);
  si_instance_set(v8method, ecl_make_int8_t(4), v5fun);
  si_instance_set(v8method, ecl_make_int8_t(5), ECL_NIL);
  si_instance_set(v8method, ecl_make_int8_t(6), ECL_NIL);
  si_instance_set(v8method, ecl_make_int8_t(7), ECL_NIL);
  si_instance_set(v8method, ecl_make_int8_t(8), ECL_NIL);
  if (Null(v7_class)){
   goto L15;
  }
  si_instance_sig_set(v8method);
L15:;
  value0 = v8method;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L1818make_method_va(cl_narg narg, cl_object v9method_class, cl_object v10qualifiers, cl_object v11specializers, cl_object v12lambda_list, cl_object v13fun, cl_object v14options, ...)
{
 if (ecl_unlikely(narg!=6)) FEwrong_num_arguments(VV[56]);
 {
  return L1818make_method(v9method_class, v10qualifiers, v11specializers, v12lambda_list, v13fun, v14options);
 }
}
/* function definition for METHOD-P                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1819method_p(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 = ecl_make_bool(ECL_INSTANCEP(v1x));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1819method_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[57]);
 {
  return L1819method_p(v2x);
 }
}
/* function definition for ADD-METHOD                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1850add_method(cl_object v1gf, cl_object v2method)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3name;
  cl_object v4method_entry;
  v3name = cl_slot_value(v1gf, ECL_SYM("NAME",1611));
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[1]);
   v6 = v3name;
   v7 = v5;
   v4method_entry = ecl_assql(v6,v7);
  }
  if (v4method_entry!=ECL_NIL) {
   goto L8;
  }
  v4method_entry = ecl_list1(v3name);
  T0 = CONS(v4method_entry,ecl_cmp_symbol_value(cl_env_copy,VV[1]));
  ecl_cmp_setq(cl_env_copy,VV[1],T0);
L8:;
  {
   cl_object v5;
   T0 = ecl_cdr(v4method_entry);
   v5 = CONS(v2method,T0);
   {
    cl_object v6;
    v6 = v4method_entry;
    if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v6;
   }
   (ECL_CONS_CDR(T0)=v5,T0);
  }
 }
 {
  cl_object v3;
  T0 = ecl_instance_ref((v1gf),((cl_fixnum)(7)));
  v3 = CONS(v2method,T0);
  si_instance_set(v1gf, ecl_make_int8_t(7), v3);
 }
 si_instance_set(v2method, ecl_make_int8_t(0), v1gf);
 T0 = ecl_instance_ref((v1gf),((cl_fixnum)(3)));
 if ((T0)!=ECL_UNBOUND) {
  goto L22;
 }
 {
  cl_object v3;
  T0 = ecl_instance_ref((v2method),((cl_fixnum)(1)));
  v3 = L1798implicit_generic_lambda(T0);
  si_instance_set(v1gf, ecl_make_int8_t(3), v3);
 }
 {
  cl_object v3;
  T0 = ecl_instance_ref((v2method),((cl_fixnum)(1)));
  T1 = si_process_lambda_list(T0, ECL_T);
  v3 = ecl_cdr(T1);
  si_instance_set(v1gf, ecl_make_int8_t(4), v3);
 }
L22:;
 (cl_env_copy->function=(VV[66]->symbol.gfdef))->cfun.entry(1, v1gf) /*  COMPUTE-G-F-SPEC-LIST */;
 (cl_env_copy->function=(VV[67]->symbol.gfdef))->cfun.entry(1, v1gf) /*  SET-GENERIC-FUNCTION-DISPATCH */;
 value0 = v2method;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L1850add_method_va(cl_narg narg, cl_object v3gf, cl_object v4method, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[68]);
 {
  return L1850add_method(v3gf, v4method);
 }
}
/* function definition for FIND-METHOD                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L1853find_method(cl_narg narg, cl_object v1gf, cl_object v2qualifiers, cl_object v3specializers, ...)
{
 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<3)) FEwrong_num_arguments(VV[75]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[75]);
 {
  cl_object v4errorp;
  va_list args; va_start(args,v3specializers);
  {
   int i = 3;
   if (i >= narg) {
    v4errorp = ECL_T;
   } else {
    i++;
    v4errorp = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v5;
   cl_object v6;
   v5 = ecl_make_cfun_va((cl_objectfn)LC1852specializer__va,ECL_NIL,Cblock,2);
   v6 = ecl_make_cfun_va((cl_objectfn)LC1851filter_specializer_va,ECL_NIL,Cblock,1);
   {
    cl_fixnum v7;
    v7 = ecl_length(v3specializers);
    T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER",1595)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER */;
    {
     cl_fixnum v8;
     v8 = ecl_length(T0);
     if (!((v7)!=(v8))){
      goto L3;
     }
    }
   }
   T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-NAME */;
   cl_error(3, VV[73], v3specializers, T0);
L3:;
   {
    cl_object v7specializers;
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     {
      cl_object v11;
      v11 = v3specializers;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9 = ECL_NIL;
     v10 = v8;
     {
      cl_object v11;
      cl_object v12;
      v11 = ecl_list1(ECL_NIL);
      v12 = v11;
L14:;
      if (!(ecl_endp(v10))){
       goto L16;
      }
      goto L15;
L16:;
      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;
       T0 = v13;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v6)(1, v9);
      v12 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v12,T0);
      goto L14;
L15:;
      v7specializers = ecl_cdr(v11);
      goto L6;
     }
    }
L6:;
    {
     cl_object v8;
     cl_object v9method;
     cl_object v10;
     {
      cl_object v11;
      v11 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-METHODS */;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9method = ECL_NIL;
     v10 = v8;
L37:;
     if (!(ecl_endp(v10))){
      goto L39;
     }
     goto L38;
L39:;
     v9method = ECL_CONS_CAR(v10);
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v10);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v11;
     }
     T0 = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, v9method) /*  METHOD-QUALIFIERS */;
     if (!(ecl_equal(v2qualifiers,T0))){
      goto L47;
     }
     T0 = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, v9method) /*  METHOD-SPECIALIZERS */;
     if (Null(cl_every(3, v5, v7specializers, T0))){
      goto L47;
     }
     value0 = v9method;
     cl_env_copy->nvalues = 1;
     return value0;
L47:;
     goto L37;
L38:;
    }
   }
   if (Null(v4errorp)){
    goto L2;
   }
   T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-NAME */;
   cl_error(4, VV[74], T0, v2qualifiers, v3specializers);
  }
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function WITH-ACCESSORS                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1854with_accessors(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4slot_accessor_pairs;
  cl_object v5instance_form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4slot_accessor_pairs = v6;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5instance_form = v6;
  }
  {
   cl_object v6temp;
   cl_object v7accessors;
   v6temp = cl_gensym(0);
   {
    cl_object v8scan;
    cl_object v9res;
    v8scan = v4slot_accessor_pairs;
    v9res = ECL_NIL;
    goto L21;
L20:;
    T0 = ecl_caar(v8scan);
    T1 = ecl_cadar(v8scan);
    T2 = cl_list(2, T1, v6temp);
    T3 = cl_list(2, T0, T2);
    v9res = CONS(T3,v9res);
    v8scan = ecl_cdr(v8scan);
L21:;
    if (v8scan==ECL_NIL) {
     goto L27;
    }
    goto L20;
L27:;
    v7accessors = cl_nreverse(v9res);
   }
   T0 = cl_list(2, v6temp, v5instance_form);
   T1 = ecl_list1(T0);
   T2 = cl_listX(3, ECL_SYM("SYMBOL-MACROLET",845), v7accessors, v3);
   value0 = cl_list(3, ECL_SYM("LET",479), T1, T2);
   return value0;
  }
 }
}
static cl_object LC1854with_accessors_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[76]);
 {
  return LC1854with_accessors(v8, v9);
 }
}
/* closure CODE-WALKER                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1794code_walker(cl_narg narg, cl_object v1form, cl_object v2env, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV2 = env0;                                     /*  IN-CLOSURE-P            */
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[41]);
 {
L1:;
  if (ECL_ATOM(v1form)) {
   goto L2;
  }
  {
   cl_object v3name;
   v3name = ecl_car(v1form);
   if (!((v3name)==(ECL_SYM("CALL-NEXT-METHOD",935)))){
    goto L5;
   }
   value0 = ECL_CONS_CAR(CLV0);
   if (value0!=ECL_NIL) {
    goto L10;
   }
   ECL_CONS_CAR(CLV0) = ECL_T;
   goto L8;
L10:;
   ECL_CONS_CAR(CLV0) = value0;
   goto L8;
L8:;
   value0 = ECL_CONS_CAR(CLV2);
   if (value0!=ECL_NIL) {
    goto L14;
   }
   ECL_CONS_CAR(CLV2) = L1793environment_contains_closure(v2env);
   goto L12;
L14:;
   ECL_CONS_CAR(CLV2) = value0;
   goto L12;
L12:;
   goto L2;
L5:;
   if (!((v3name)==(ECL_SYM("NEXT-METHOD-P",962)))){
    goto L16;
   }
   ECL_CONS_CAR(CLV1) = ECL_T;
   value0 = ECL_CONS_CAR(CLV2);
   if (value0!=ECL_NIL) {
    goto L22;
   }
   ECL_CONS_CAR(CLV2) = L1793environment_contains_closure(v2env);
   goto L20;
L22:;
   ECL_CONS_CAR(CLV2) = value0;
   goto L20;
L20:;
   goto L2;
L16:;
   if (!((v3name)==(ECL_SYM("FUNCTION",398)))){
    goto L2;
   }
   T0 = ecl_cadr(v1form);
   if (!((T0)==(ECL_SYM("CALL-NEXT-METHOD",935)))){
    goto L25;
   }
   ECL_CONS_CAR(CLV2) = ECL_T;
   ECL_CONS_CAR(CLV0) = ECL_SYM("FUNCTION",398);
L25:;
   T0 = ecl_cadr(v1form);
   if (!((T0)==(ECL_SYM("NEXT-METHOD-P",962)))){
    goto L2;
   }
   ECL_CONS_CAR(CLV1) = ECL_SYM("FUNCTION",398);
   ECL_CONS_CAR(CLV2) = ECL_T;
  }
L2:;
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function (SETF METHOD-GENERIC-FUNCTION)                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1848_setf_method_generic_function_(cl_object v1value, cl_object v2object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_instance_set(v2object, ecl_make_int8_t(0), v1value);
 return value0;
}
static cl_object LC1848_setf_method_generic_function__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[63]);
 {
  return LC1848_setf_method_generic_function_(v3value, v4object);
 }
}
/* local function METHOD-LAMBDA-LIST                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1847method_lambda_list(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(1)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1847method_lambda_list_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("METHOD-LAMBDA-LIST",1609));
 {
  return LC1847method_lambda_list(v2object);
 }
}
/* local function GENERIC-FUNCTION-LAMBDA-LIST                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1831generic_function_lambda_list(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(3)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1831generic_function_lambda_list_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-LAMBDA-LIST",1597));
 {
  return LC1831generic_function_lambda_list(v2object);
 }
}
/* local function (SETF GENERIC-FUNCTION-LAMBDA-LIST)                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1830_setf_generic_function_lambda_list_(cl_object v1value, cl_object v2object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_instance_set(v2object, ecl_make_int8_t(3), v1value);
 return value0;
}
static cl_object LC1830_setf_generic_function_lambda_list__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[64]);
 {
  return LC1830_setf_generic_function_lambda_list_(v3value, v4object);
 }
}
/* local function (SETF GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER)           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1828_setf_generic_function_argument_precedence_order_(cl_object v1value, cl_object v2object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_instance_set(v2object, ecl_make_int8_t(4), v1value);
 return value0;
}
static cl_object LC1828_setf_generic_function_argument_precedence_order__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[65]);
 {
  return LC1828_setf_generic_function_argument_precedence_order_(v3value, v4object);
 }
}
/* local function GENERIC-FUNCTION-METHODS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1827generic_function_methods(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_instance_ref((v1object),((cl_fixnum)(7)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1827generic_function_methods_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("GENERIC-FUNCTION-METHODS",1600));
 {
  return LC1827generic_function_methods(v2object);
 }
}
/* local function (SETF GENERIC-FUNCTION-METHODS)                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1826_setf_generic_function_methods_(cl_object v1value, cl_object v2object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_instance_set(v2object, ecl_make_int8_t(7), v1value);
 return value0;
}
static cl_object LC1826_setf_generic_function_methods__va(cl_narg narg, cl_object v3value, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[62]);
 {
  return LC1826_setf_generic_function_methods_(v3value, v4object);
 }
}
/* local function SPECIALIZER=                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1852specializer_(cl_object v1cons_or_class, cl_object v2specializer)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_CONSP(v1cons_or_class))){
  goto L2;
 }
 if (Null((cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(1, v2specializer) /*  EQL-SPECIALIZER-FLAG */)){
  goto L5;
 }
 T0 = ecl_car(v1cons_or_class);
 T1 = (cl_env_copy->function=(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586)->symbol.gfdef))->cfun.entry(1, v2specializer) /*  EQL-SPECIALIZER-OBJECT */;
 value0 = ecl_make_bool(ecl_eql(T0,T1));
 cl_env_copy->nvalues = 1;
 return value0;
L5:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ecl_make_bool((v1cons_or_class)==(v2specializer));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC1852specializer__va(cl_narg narg, cl_object v3cons_or_class, cl_object v4specializer, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[71]);
 {
  return LC1852specializer_(v3cons_or_class, v4specializer);
 }
}
/* local function FILTER-SPECIALIZER                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC1851filter_specializer(cl_object v1name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(si_of_class_p(2, v1name, ECL_SYM("SPECIALIZER",1632)))){
  goto L2;
 }
 value0 = v1name;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_ATOM(v1name))){
  goto L4;
 }
 {
  cl_object v2class;
  v2class = cl_find_class(2, v1name, ECL_NIL);
  if (v2class!=ECL_NIL) {
   goto L7;
  }
  cl_error(2, VV[70], v1name);
L7:;
  value0 = v2class;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L4:;
 T0 = ecl_car(v1name);
 if (!((T0)==(ECL_SYM("EQL",336)))){
  goto L9;
 }
 T0 = ecl_cddr(v1name);
 if (!(T0==ECL_NIL)){
  goto L9;
 }
 value0 = ecl_cdr(v1name);
 cl_env_copy->nvalues = 1;
 return value0;
L9:;
 value0 = cl_error(2, VV[70], v1name);
 return value0;
}
static cl_object LC1851filter_specializer_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[69]);
 {
  return LC1851filter_specializer(v3name);
 }
}
#include "clos/method.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclVFOqlpdj6TSk9_R620M881(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;METHOD.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclVFOqlpdj6TSk9_R620M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  si_Xmake_special(VV[0]);
  T0 = ecl_make_int8_t(32);
  ecl_cmp_setq(cl_env_copy,VV[0],T0);
  si_Xmake_special(VV[1]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[1],T0);
  si_Xmake_special(ECL_SYM("*NEXT-METHODS*",1549));
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549),T0);
  si_Xmake_special(VV[2]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[2],T0);
  ecl_cmp_defun(VV[78]);                          /*  GENERIC-FUNCTION-METHOD-CLASS */
  ecl_cmp_defun(VV[79]);                          /*  PROTOTYPES-FOR-MAKE-METHOD-LAMBDA */
  ecl_cmp_defmacro(VV[80]);                       /*  DEFMETHOD               */
  (void)0; /* No entry created for SPECIALIZERS-EXPRESSION */
  ecl_cmp_defun(VV[81]);                          /*  MAYBE-REMOVE-BLOCK      */
  ecl_cmp_defun(VV[82]);                          /*  SIMPLIFY-LAMBDA         */
  (void)0; /* No entry created for MAKE-RAW-LAMBDA */
  ecl_cmp_defun(VV[83]);                          /*  MAKE-METHOD-LAMBDA      */
  ecl_cmp_defun(VV[84]);                          /*  ADD-CALL-NEXT-METHOD-CLOSURE */
  ecl_cmp_defun(VV[85]);                          /*  ENVIRONMENT-CONTAINS-CLOSURE */
  (void)0; /* No entry created for WALK-METHOD-LAMBDA */
  ecl_cmp_defun(VV[86]);                          /*  LEGAL-GENERIC-FUNCTION-NAME-P */
  (void)0; /* No entry created for PARSE-DEFMETHOD */
  ecl_cmp_defun(VV[87]);                          /*  IMPLICIT-GENERIC-LAMBDA */
  (void)0; /* No entry created for EXTRACT-LAMBDA-LIST */
  (void)0; /* No entry created for EXTRACT-SPECIALIZER-NAMES */
  (void)0; /* No entry created for PARSE-SPECIALIZED-LAMBDA-LIST */
  (void)0; /* No entry created for DECLARATION-SPECIALIZERS */
  ecl_cmp_defun(VV[88]);                          /*  COMPUTE-METHOD-KEYWORDS */
  ecl_cmp_defun(VV[89]);                          /*  MAKE-METHOD             */
  ecl_cmp_defun(VV[90]);                          /*  METHOD-P                */
  ecl_cmp_defun(VV[91]);                          /*  ADD-METHOD              */
  ecl_cmp_defun(VV[92]);                          /*  FIND-METHOD             */
  ecl_cmp_defmacro(VV[93]);                       /*  WITH-ACCESSORS          */
  T0 = cl_symbol_function(ECL_SYM("GETHASH",415));
  si_fset(2, VV[77], T0);
 }
}
