/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/generic.lsp                    */
#include <ecl/ecl-cmp.h>
#include "clos/generic.eclh"
/* local function DEFGENERIC                                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2057defgeneric(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;
  v3 = ecl_cdr(v1);
  {
   cl_object v4;                                  /*  FUNCTION-SPECIFIER      */
   cl_object v5;                                  /*  LAMBDA-LIST             */
   cl_object v6;                                  /*  OPTIONS                 */
   value0 = L2058parse_defgeneric(v3);
   {
    const int v7 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v8;
    v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
    v5 = v8;
    v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
    v6 = v8;
   }
   L2060parse_lambda_list(1, v5);
   {
    cl_object v7;                                 /*  OPTION-LIST             */
    cl_object v8;                                 /*  METHOD-LIST             */
    value0 = L2059parse_generic_options(v6, v5);
    {
     const int v9 = cl_env_copy->nvalues;
     v7 = value0;
     cl_object v10;
     v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
     v8 = v10;
    }
    {
     cl_object v9output;
     T0 = cl_list(2, ECL_SYM("QUOTE",682), v4);
     v9output = cl_listX(5, ECL_SYM("ENSURE-GENERIC-FUNCTION",946), T0, VV[3], ECL_T, v7);
     if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
      goto L7;
     }
     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)));
     if (Null(v8)){
      goto L11;
     }
     T3 = cl_list(2, ECL_SYM("QUOTE",682), v4);
     {
      cl_object v10;
      cl_object v11m;
      cl_object v12;
      {
       cl_object v13;
       v13 = v8;
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      v11m = ECL_NIL;
      v12 = v10;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L21:;
       if (!(ecl_endp(v12))){
        goto L23;
       }
       goto L22;
L23:;
       v11m = ECL_CONS_CAR(v12);
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       {
        cl_object v15;
        v15 = v14;
        if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T5 = v15;
       }
       T6 = cl_listX(3, ECL_SYM("DEFMETHOD",944), v4, v11m);
       v14 = ecl_list1(T6);
       (ECL_CONS_CDR(T5)=v14,T5);
       goto L21;
L22:;
       T4 = ecl_cdr(v13);
       goto L13;
      }
     }
L13:;
     T5 = cl_listX(3, VV[4], T3, T4);
     T2 = cl_list(3, ECL_SYM("PROGN",674), v9output, T5);
     goto L10;
L11:;
     T2 = v9output;
L10:;
     value0 = ecl_function_dispatch(cl_env_copy,T0)(3, T1, v1, T2);
     return value0;
L7:;
     if (Null(v8)){
      goto L38;
     }
     T0 = cl_list(2, ECL_SYM("QUOTE",682), v4);
     {
      cl_object v10;
      cl_object v11m;
      cl_object v12;
      {
       cl_object v13;
       v13 = v8;
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      v11m = ECL_NIL;
      v12 = v10;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L48:;
       if (!(ecl_endp(v12))){
        goto L50;
       }
       goto L49;
L50:;
       v11m = ECL_CONS_CAR(v12);
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       {
        cl_object v15;
        v15 = v14;
        if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T2 = v15;
       }
       T3 = cl_listX(3, ECL_SYM("DEFMETHOD",944), v4, v11m);
       v14 = ecl_list1(T3);
       (ECL_CONS_CDR(T2)=v14,T2);
       goto L48;
L49:;
       T1 = ecl_cdr(v13);
       goto L40;
      }
     }
L40:;
     T2 = cl_listX(3, VV[4], T0, T1);
     value0 = cl_list(3, ECL_SYM("PROGN",674), v9output, T2);
     return value0;
L38:;
     value0 = v9output;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
 }
}
static cl_object LC2057defgeneric_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[10]);
 {
  return LC2057defgeneric(v4, v5);
 }
}
/* function definition for PARSE-DEFGENERIC                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2058parse_defgeneric(cl_object v1args)
{
 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 v2function_specifier;
  v2function_specifier = ECL_NIL;
  if (v1args!=ECL_NIL) {
   goto L3;
  }
  si_simple_program_error(1, VV[11]);
L3:;
  {
   cl_object v3;
   v3 = v1args;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[14],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L11;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v1args = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L11:;
   v2function_specifier = v3;
  }
  if (v1args!=ECL_NIL) {
   goto L17;
  }
  si_simple_program_error(1, VV[15]);
L17:;
  T0 = ecl_car(v1args);
  T1 = ecl_cdr(v1args);
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = T1;
  cl_env_copy->values[1] = T0;
  cl_env_copy->values[0] = v2function_specifier;
  return cl_env_copy->values[0];
 }
}
/* function definition for PARSE-GENERIC-OPTIONS                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2059parse_generic_options(cl_object v1options, cl_object v2lambda_list)
{
 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 v3processed_options;
  cl_object v4method_list;
  cl_object v5declarations;
  cl_object v6arg_list;
  v3processed_options = ECL_NIL;
  v4method_list = ECL_NIL;
  v5declarations = ECL_NIL;
  v6arg_list = ECL_NIL;
  {
   cl_object v7;
   v7 = v1options;
   goto L10;
L9:;
   {
    cl_object v8option;
    v8option = ecl_car(v7);
    {
     cl_object v9;
     cl_object v10option_value;
     v9 = ecl_car(v8option);
     v10option_value = ECL_NIL;
     if (!((v9)==(ECL_SYM("METHOD",1005)))){
      goto L17;
     }
     T0 = ecl_cdr(v8option);
     v4method_list = CONS(T0,v4method_list);
     goto L14;
L17:;
     if (!((v9)==(ECL_SYM("DECLARE",276)))){
      goto L20;
     }
     T0 = ecl_cdr(v8option);
     v5declarations = ecl_append(T0,v5declarations);
     goto L14;
L20:;
     {
      cl_object v11;
      cl_object v12;
      v11 = v9;
      v12 = v3processed_options;
      if (Null(ecl_memql(v11,v12))){
       goto L23;
      }
     }
     si_simple_program_error(2, VV[16], v9);
     goto L14;
L23:;
     v3processed_options = CONS(v9,v3processed_options);
     if (!((v9)==(ECL_SYM("ARGUMENT-PRECEDENCE-ORDER",988)))){
      goto L31;
     }
     v10option_value = ecl_cdr(v8option);
     goto L30;
L31:;
     if (!((v9)==(ECL_SYM("METHOD-COMBINATION",1007)))){
      goto L33;
     }
     v10option_value = ecl_cdr(v8option);
     goto L30;
L33:;
     if (!((v9)==(ECL_SYM("DOCUMENTATION",1253)))){
      goto L40;
     }
     goto L37;
L40:;
     goto L38;
L38:;
     if (!((v9)==(ECL_SYM("GENERIC-FUNCTION-CLASS",996)))){
      goto L44;
     }
     goto L37;
L44:;
     goto L42;
L42:;
     if (!((v9)==(ECL_SYM("METHOD-CLASS",1006)))){
      goto L35;
     }
     goto L36;
L37:;
L36:;
     T0 = ecl_cddr(v8option);
     if (ecl_endp(T0)) {
      goto L47;
     }
     si_simple_program_error(2, VV[20], v9);
L47:;
     v10option_value = ecl_cadr(v8option);
     goto L30;
L35:;
     v10option_value = si_simple_program_error(2, VV[21], v9);
L30:;
     T0 = cl_list(2, ECL_SYM("QUOTE",682), v9);
     T1 = cl_list(2, ECL_SYM("QUOTE",682), v10option_value);
     v6arg_list = cl_listX(3, T0, T1, v6arg_list);
    }
L14:;
   }
   v7 = ecl_cdr(v7);
L10:;
   if (Null(v7)){
    goto L52;
   }
   goto L9;
L52:;
  }
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v2lambda_list);
  if (Null(v5declarations)){
   goto L55;
  }
  T2 = cl_list(2, ECL_SYM("QUOTE",682), v5declarations);
  T1 = cl_list(2, VV[22], T2);
  goto L54;
L55:;
  T1 = ECL_NIL;
L54:;
  T2 = ecl_append(v6arg_list,T1);
  T3 = cl_listX(3, ECL_SYM("LAMBDA-LIST",1002), T0, T2);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v4method_list;
  cl_env_copy->values[0] = T3;
  return cl_env_copy->values[0];
 }
}
/* function definition for PARSE-LAMBDA-LIST                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2060parse_lambda_list(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[1]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[1]);
 {
  cl_object v2post_keyword;
  va_list args; va_start(args,v1lambda_list);
  {
   int i = 1;
   if (i >= narg) {
    v2post_keyword = ECL_NIL;
   } else {
    i++;
    v2post_keyword = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3arg;
   v3arg = ecl_car(v1lambda_list);
   {
    cl_object v4;
    v4 = ecl_make_bool(v1lambda_list==ECL_NIL);
    if (Null(v4)){
     goto L4;
    }
    value0 = v4;
    cl_env_copy->nvalues = 1;
    return value0;
L4:;
    if (!((v3arg)==(ECL_SYM("&AUX",9)))){
     goto L6;
    }
    value0 = si_simple_program_error(1, VV[23]);
    return value0;
L6:;
    {
     cl_object v5;
     cl_object v6;
     v5 = v3arg;
     v6 = VV[24];
     if (Null(ecl_memql(v5,v6))){
      goto L8;
     }
    }
    T0 = ecl_cdr(v1lambda_list);
    value0 = L2060parse_lambda_list(2, T0, ECL_T);
    return value0;
L8:;
    if (Null(v2post_keyword)){
     goto L12;
    }
    T0 = ecl_cdr(v1lambda_list);
    value0 = L2060parse_lambda_list(2, T0, ECL_T);
    return value0;
L12:;
    if (!(ECL_LISTP(v3arg))){
     goto L14;
    }
    value0 = si_simple_program_error(1, VV[25]);
    return value0;
L14:;
    T0 = ecl_cdr(v1lambda_list);
    value0 = L2060parse_lambda_list(1, T0);
    return value0;
   }
  }
 }
}
/* function definition for VALID-DECLARATION-P                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2061valid_declaration_p(cl_object v1decl)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1decl);
 if (!((T0)==(ECL_SYM("OPTIMIZE",615)))){
  goto L3;
 }
 {
  cl_object v2;
  cl_object v3item;
  cl_object v4;
  {
   cl_object v5;
   v5 = v1decl;
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v5;
  }
  v3item = ECL_NIL;
  v4 = v2;
L10:;
  if (!(ecl_endp(v4))){
   goto L12;
  }
  goto L11;
L12:;
  v3item = ECL_CONS_CAR(v4);
  {
   cl_object v5;
   v5 = ECL_CONS_CDR(v4);
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v4 = v5;
  }
  if (ECL_ATOM(v3item)) {
   goto L20;
  }
  if (!(ECL_CONSP(v3item))){
   goto L24;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_car(v3item);
   v6 = v5;
   v7 = VV[27];
   if (ecl_memql(v6,v7)!=ECL_NIL) {
    goto L20;
   }
   goto L21;
  }
L24:;
  goto L21;
L21:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L20:;
  goto L10;
L11:;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2061valid_declaration_p_va(cl_narg narg, cl_object v5decl, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[26]);
 {
  return L2061valid_declaration_p(v5decl);
 }
}
/* function definition for LAMBDA-LIST-REQUIRED-ARGUMENTS                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2062lambda_list_required_arguments(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:;
 T0 = si_process_lambda_list(v1lambda_list, ECL_T);
 value0 = ecl_cdr(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2062lambda_list_required_arguments_va(cl_narg narg, cl_object v2lambda_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[29]);
 {
  return L2062lambda_list_required_arguments(v2lambda_list);
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2066shared_initialize(cl_narg narg, cl_object v1gfun, cl_object v2slot_names, ...)
{
 cl_object T0, T1, T2, T3;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SHARED-INITIALIZE",969));
 {
  cl_object v3name;
  cl_object v4l_l_p;
  cl_object v5argument_precedence_order;
  cl_object v6a_o_p;
  cl_object v7documentation;
  cl_object v8declarations;
  cl_object v9method_class;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  {
   cl_object keyvars[12];
   cl_parse_key(args,6,LC2066shared_initializekeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   v3name = keyvars[0];
   env0 = ECL_NIL;
   CLV0 = env0 = CONS(keyvars[1],env0);           /*  LAMBDA-LIST             */
   v4l_l_p = keyvars[7];
   v5argument_precedence_order = keyvars[2];
   v6a_o_p = keyvars[8];
   v7documentation = keyvars[3];
   v8declarations = keyvars[4];
   if (Null(keyvars[11])) {
    v9method_class = cl_find_class(1, ECL_SYM("METHOD",958));
   } else {
    v9method_class = keyvars[5];
   }
  }
  {
   cl_object v10gfun_name;
   if (Null(cl_slot_boundp(v1gfun, ECL_SYM("NAME",1611)))){
    goto L3;
   }
   v10gfun_name = cl_slot_value(v1gfun, ECL_SYM("NAME",1611));
   goto L2;
L3:;
   value0 = v3name;
   if (value0!=ECL_NIL) {
    goto L6;
   }
   v10gfun_name = VV[32];
   goto L2;
L6:;
   v10gfun_name = value0;
   goto L2;
L2:;
   if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
    goto L9;
   }
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
   goto L8;
L9:;
   T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
   T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L8:;
   lex0[0] = T0;                                  /*  .CLOSED-COMBINED-METHOD-ARGS. */
   lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
   if (Null(v6a_o_p)){
    goto L12;
   }
   if (v4l_l_p!=ECL_NIL) {
    goto L14;
   }
   si_simple_program_error(2, VV[34], v10gfun_name);
L14:;
   {
    cl_object v11;
    v11 = L2062lambda_list_required_arguments(ECL_CONS_CAR(CLV0));
    goto L19;
L18:;
    {
     cl_object v12l;
     v12l = ecl_car(v11);
     T0 = cl_count(2, v12l, v5argument_precedence_order);
     if ((ecl_fixnum(T0))==((cl_fixnum)(1))) {
      goto L23;
     }
     si_simple_program_error(4, VV[35], v10gfun_name, v12l, v5argument_precedence_order);
L23:;
    }
    v11 = ecl_cdr(v11);
L19:;
    if (Null(v11)){
     goto L27;
    }
    goto L18;
L27:;
   }
L12:;
   T0 = (VV[26]->symbol.gfdef);
   if (cl_every(2, T0, v8declarations)!=ECL_NIL) {
    goto L29;
   }
   si_simple_program_error(3, VV[36], v10gfun_name, v8declarations);
L29:;
   if (v7documentation==ECL_NIL) {
    goto L32;
   }
   if (ECL_STRINGP(v7documentation)) {
    goto L32;
   }
   T0 = cl_list(2, v10gfun_name, v7documentation);
   cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("FORMAT-CONTROL",1272), VV[37], ECL_SYM("FORMAT-ARGUMENTS",1271), T0, ECL_SYM("DATUM",1245), v7documentation, ECL_SYM("EXPECTED-TYPE",1263), VV[38]);
L32:;
   T0 = cl_find_class(1, ECL_SYM("METHOD",958));
   if (si_subclassp(2, v9method_class, T0)!=ECL_NIL) {
    goto L35;
   }
   T0 = cl_list(2, v10gfun_name, v9method_class);
   cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("FORMAT-CONTROL",1272), VV[39], ECL_SYM("FORMAT-ARGUMENTS",1271), T0, ECL_SYM("DATUM",1245), v9method_class, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("METHOD",958));
L35:;
   if (Null(v4l_l_p)){
    goto L37;
   }
   if (Null(cl_slot_boundp(v1gfun, VV[40]))){
    goto L37;
   }
   {
    cl_object v11;
    v11 = ecl_make_cclosure_va((cl_objectfn)LC2065__lambda115,env0,Cblock,1);
    T0 = v11;
   }
   {
    cl_object v11;
    v11 = (ECL_SYM("METHOD-LAMBDA-LIST",1609)->symbol.gfdef);
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gfun) /*  GENERIC-FUNCTION-METHODS */;
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
     {
      cl_object v15;
      cl_object v16;
      v15 = ecl_list1(ECL_NIL);
      v16 = v15;
L51:;
      if (!(ecl_endp(v14))){
       goto L53;
      }
      goto L52;
L53:;
      v13 = ECL_CONS_CAR(v14);
      {
       cl_object v17;
       v17 = ECL_CONS_CDR(v14);
       if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v14 = v17;
      }
      {
       cl_object v17;
       v17 = v16;
       if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v17;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
      v16 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v16,T2);
      goto L51;
L52:;
      T1 = ecl_cdr(v15);
      goto L42;
     }
    }
   }
L42:;
   if (cl_every(2, T0, T1)!=ECL_NIL) {
    goto L37;
   }
   si_simple_program_error(3, VV[43], v1gfun, ECL_CONS_CAR(CLV0));
L37:;
   LC2063call_next_method(0, lex0);
   {
    cl_object v11combination;
    v11combination = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHOD-COMBINATION",1599)->symbol.gfdef))->cfun.entry(1, v1gfun) /*  GENERIC-FUNCTION-METHOD-COMBINATION */;
    if (si_of_class_p(2, v11combination, ECL_SYM("METHOD-COMBINATION",960))!=ECL_NIL) {
     goto L70;
    }
    {
     cl_object v12;
     T0 = ecl_car(v11combination);
     T1 = ecl_cdr(v11combination);
     v12 = (cl_env_copy->function=(ECL_SYM("FIND-METHOD-COMBINATION",1590)->symbol.gfdef))->cfun.entry(3, v1gfun, T0, T1) /*  FIND-METHOD-COMBINATION */;
     (cl_env_copy->function=ECL_CONS_CAR(VV[73]))->cfun.entry(2, v12, v1gfun) /*  (SETF GENERIC-FUNCTION-METHOD-COMBINATION) */;
    }
   }
L70:;
   if (Null(v4l_l_p)){
    goto L74;
   }
   if (v6a_o_p!=ECL_NIL) {
    goto L74;
   }
   {
    cl_object v11;
    v11 = L2062lambda_list_required_arguments(ECL_CONS_CAR(CLV0));
    (cl_env_copy->function=ECL_CONS_CAR(VV[74]))->cfun.entry(2, v11, v1gfun) /*  (SETF GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER) */;
   }
L74:;
   (cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v1gfun) /*  SET-GENERIC-FUNCTION-DISPATCH */;
   value0 = v1gfun;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function SHARED-INITIALIZE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2069shared_initialize(cl_narg narg, cl_object v1gfun, cl_object v2slot_names, ...)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SHARED-INITIALIZE",969));
 {
  cl_object v3initargs;
  ecl_va_list args; ecl_va_start(args,v2slot_names,narg,2);
  v3initargs = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
   goto L2;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
  goto L1;
L2:;
  T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
  T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L1:;
  lex0[0] = T0;                                   /*  .CLOSED-COMBINED-METHOD-ARGS. */
  lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
  LC2067call_next_method(0, lex0);
  if (Null((cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gfun) /*  GENERIC-FUNCTION-METHODS */)){
   goto L6;
  }
  (cl_env_copy->function=(VV[47]->symbol.gfdef))->cfun.entry(1, v1gfun) /*  COMPUTE-G-F-SPEC-LIST */;
L6:;
  (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(2, v1gfun, v3initargs) /*  UPDATE-DEPENDENTS */;
  value0 = v1gfun;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for ASSOCIATE-METHODS-TO-GFUN                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object clos_associate_methods_to_gfun(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[4]);
 {
  cl_object v2methods;
  ecl_va_list args; ecl_va_start(args,v1name,narg,1);
  v2methods = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3gfun;
   v3gfun = cl_fdefinition(v1name);
   {
    cl_object v4;
    v4 = v2methods;
    goto L6;
L5:;
    {
     cl_object v5method;
     v5method = ecl_car(v4);
     {
      cl_object v6;
      T0 = (cl_env_copy->function=(VV[50]->symbol.gfdef))->cfun.entry(1, v5method) /*  METHOD-PLIST */;
      v6 = si_put_f(T0, ECL_T, VV[49]);
      (cl_env_copy->function=ECL_CONS_CAR(VV[75]))->cfun.entry(2, v6, v5method) /*  (SETF METHOD-PLIST) */;
     }
    }
    v4 = ecl_cdr(v4);
L6:;
    if (Null(v4)){
     goto L15;
    }
    goto L5;
L15:;
   }
   value0 = v3gfun;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function ENSURE-GENERIC-FUNCTION-USING-CLASS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2070ensure_generic_function_using_class(cl_narg narg, cl_object v1gfun, cl_object v2name, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584));
 {
  cl_object v3args;
  cl_object v4method_class;
  cl_object v5method_class_p;
  cl_object v6generic_function_class;
  cl_object v7delete_methods;
  ecl_va_list args; ecl_va_start(args,v2name,narg,2);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,LC2070ensure_generic_function_using_classkeys,keyvars,(cl_object*)&v3args,TRUE);
   ecl_va_end(args);
   if (Null(keyvars[3])) {
    v4method_class = ECL_SYM("STANDARD-METHOD",979);
   } else {
    v4method_class = keyvars[0];
   }
   v5method_class_p = keyvars[3];
   if (Null(keyvars[4])) {
    v6generic_function_class = cl_class_of(v1gfun);
   } else {
    v6generic_function_class = keyvars[1];
   }
   v7delete_methods = keyvars[2];
  }
  v3args = cl_copy_list(v3args);
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, ECL_SYM("GENERIC-FUNCTION-CLASS",996));
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, ECL_SYM("DECLARE",990));
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, VV[53]);
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, VV[3]);
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  if (!(ECL_SYMBOLP(v6generic_function_class))){
   goto L21;
  }
  v6generic_function_class = cl_find_class(1, v6generic_function_class);
L21:;
  T0 = cl_find_class(1, ECL_SYM("GENERIC-FUNCTION",949));
  if (si_subclassp(2, v6generic_function_class, T0)!=ECL_NIL) {
   goto L24;
  }
  cl_error(2, VV[54], v6generic_function_class);
L24:;
  if (Null(v5method_class_p)){
   goto L26;
  }
  if (!(ECL_SYMBOLP(v4method_class))){
   goto L26;
  }
  T0 = cl_find_class(1, v4method_class);
  v3args = cl_listX(3, ECL_SYM("METHOD-CLASS",1006), T0, v3args);
L26:;
  if (Null(v7delete_methods)){
   goto L30;
  }
  {
   cl_object v8;
   T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-METHODS",1600)->symbol.gfdef))->cfun.entry(1, v1gfun) /*  GENERIC-FUNCTION-METHODS */;
   v8 = cl_copy_list(T0);
   goto L35;
L34:;
   {
    cl_object v9m;
    v9m = ecl_car(v8);
    T0 = (cl_env_copy->function=(VV[50]->symbol.gfdef))->cfun.entry(1, v9m) /*  METHOD-PLIST */;
    if (Null(cl_getf(2, T0, VV[49]))){
     goto L39;
    }
    (cl_env_copy->function=(ECL_SYM("REMOVE-METHOD",968)->symbol.gfdef))->cfun.entry(2, v1gfun, v9m) /*  REMOVE-METHOD */;
L39:;
   }
   v8 = ecl_cdr(v8);
L35:;
   if (Null(v8)){
    goto L43;
   }
   goto L34;
L43:;
  }
L30:;
  T0 = cl_class_of(v1gfun);
  if (!((T0)==(v6generic_function_class))){
   goto L45;
  }
  T0 = (ECL_SYM("REINITIALIZE-INSTANCE",967)->symbol.gfdef);
  value0 = cl_apply(3, T0, v1gfun, v3args);
  return value0;
L45:;
  T0 = (ECL_SYM("CHANGE-CLASS",936)->symbol.gfdef);
  value0 = cl_apply(4, T0, v1gfun, v6generic_function_class, v3args);
  return value0;
 }
}
/* local function ENSURE-GENERIC-FUNCTION-USING-CLASS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2071ensure_generic_function_using_class(cl_narg narg, cl_object v1gfun, cl_object v2name, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584));
 {
  cl_object v3args;
  cl_object v4method_class;
  cl_object v5method_class_p;
  cl_object v6generic_function_class;
  cl_object v7delete_methods;
  ecl_va_list args; ecl_va_start(args,v2name,narg,2);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,LC2071ensure_generic_function_using_classkeys,keyvars,(cl_object*)&v3args,TRUE);
   ecl_va_end(args);
   if (Null(keyvars[3])) {
    v4method_class = ECL_SYM("STANDARD-METHOD",979);
   } else {
    v4method_class = keyvars[0];
   }
   v5method_class_p = keyvars[3];
   if (Null(keyvars[4])) {
    v6generic_function_class = ECL_SYM("STANDARD-GENERIC-FUNCTION",978);
   } else {
    v6generic_function_class = keyvars[1];
   }
   v7delete_methods = keyvars[2];
  }
  v3args = cl_copy_list(v3args);
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, ECL_SYM("GENERIC-FUNCTION-CLASS",996));
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, ECL_SYM("DECLARE",990));
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, VV[53]);
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  {
   cl_object v8;
   cl_object v9;                                  /*  FLAG                    */
   value0 = si_rem_f(v3args, VV[3]);
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v3args = v8;
  }
  if (Null(v5method_class_p)){
   goto L21;
  }
  if (!(ECL_SYMBOLP(v6generic_function_class))){
   goto L21;
  }
  T0 = cl_find_class(1, v4method_class);
  v3args = cl_listX(3, ECL_SYM("METHOD-CLASS",1006), T0, v3args);
L21:;
  T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
  value0 = cl_apply(5, T0, v6generic_function_class, ECL_SYM("NAME",1309), v2name, v3args);
  return value0;
 }
}
/* function definition for ENSURE-GENERIC-FUNCTION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2072ensure_generic_function(cl_narg narg, cl_object v1name, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[61]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1name,narg,1);
  cl_parse_key(args,0,NULL,NULL,(cl_object*)&v2args,TRUE);
  ecl_va_end(args);
  {
   cl_object v3gfun;
   v3gfun = si_traced_old_definition(v1name);
   if ((cl_env_copy->function=(VV[55]->symbol.gfdef))->cfun.entry(1, v1name) /*  LEGAL-GENERIC-FUNCTION-NAME-P */!=ECL_NIL) {
    goto L2;
   }
   value0 = si_simple_program_error(2, VV[56], v1name);
   return value0;
L2:;
   if (cl_fboundp(v1name)!=ECL_NIL) {
    goto L4;
   }
   T0 = (ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584)->symbol.gfdef);
   T1 = cl_apply(4, T0, v3gfun, v1name, v2args);
   value0 = si_fset(2, v1name, T1);
   return value0;
L4:;
   value0 = v3gfun;
   if (value0!=ECL_NIL) {
    goto L11;
   }
   v3gfun = cl_fdefinition(v1name);
   T0 = v3gfun;
   goto L9;
L11:;
   T0 = value0;
   goto L9;
L9:;
   if (!(ECL_INSTANCEP(T0))){
    goto L7;
   }
   T0 = (ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584)->symbol.gfdef);
   value0 = cl_apply(4, T0, v3gfun, v1name, v2args);
   return value0;
L7:;
   if (Null(cl_special_operator_p(v1name))){
    goto L15;
   }
   value0 = si_simple_program_error(2, VV[57], v1name);
   return value0;
L15:;
   if (Null(cl_macro_function(1, v1name))){
    goto L17;
   }
   value0 = si_simple_program_error(2, VV[58], v1name);
   return value0;
L17:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[59])!=ECL_NIL) {
    goto L19;
   }
   T0 = (ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584)->symbol.gfdef);
   T1 = cl_apply(4, T0, ECL_NIL, v1name, v2args);
   si_fset(2, v1name, T1);
   value0 = cl_fdefinition(v1name);
   return value0;
L19:;
   value0 = si_simple_program_error(2, VV[60], v1name);
   return value0;
  }
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2063call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[33]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
/* closure LAMBDA115                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2065__lambda115(cl_narg narg, cl_object v1x, ...)
{
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  LAMBDA-LIST             */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[41]);
 {
L1:;
  value0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(2, ECL_CONS_CAR(CLV0), v1x) /*  CONGRUENT-LAMBDA-P */;
  return value0;
 }
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2067call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[33]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
#include "clos/generic.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclXvY0gHUUtTin9_uL50M881(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;GENERIC.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXvY0gHUUtTin9_uL50M881@";
 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]);
  ecl_cmp_defmacro(VV[62]);                       /*  DEFGENERIC              */
  (void)0; /* No entry created for PARSE-DEFGENERIC */
  (void)0; /* No entry created for PARSE-GENERIC-OPTIONS */
  (void)0; /* No entry created for PARSE-LAMBDA-LIST */
  ecl_cmp_defun(VV[63]);                          /*  VALID-DECLARATION-P     */
  ecl_cmp_defun(VV[64]);                          /*  LAMBDA-LIST-REQUIRED-ARGUMENTS */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2066shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2069shared_initialize,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("SHARED-INITIALIZE",969), ECL_NIL, VVtemp[3], VVtemp[4], T0);
  ecl_cmp_defun(VV[65]);                          /*  ASSOCIATE-METHODS-TO-GFUN */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2070ensure_generic_function_using_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584), ECL_NIL, VVtemp[1], VVtemp[5], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2071ensure_generic_function_using_class,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("ENSURE-GENERIC-FUNCTION-USING-CLASS",1584), ECL_NIL, VVtemp[6], VVtemp[7], T0);
  ecl_cmp_defun(VV[66]);                          /*  ENSURE-GENERIC-FUNCTION */
 }
}
