/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpfun.lsp                      */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpfun.eclh"
/* function definition for REGISTER-FUNCTION                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3402register_function(cl_object v1fun)
{
 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 = CONS(v1fun,ecl_cmp_symbol_value(cl_env_copy,VV[1]));
 ecl_cmp_setq(cl_env_copy,VV[1],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[1]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3402register_function_va(cl_narg narg, cl_object v2fun, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3402register_function(v2fun);
 }
}
/* function definition for CHILD-FUNCTION-P                                   */
/* optimize speed 3, debug 1, space 1, safety 2                               */
static cl_object L3403child_function_p(cl_object v1presumed_parent, cl_object v2fun)
{
 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 v3real_parent;
  v3real_parent = ECL_NIL;
L3:;
  v3real_parent = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, v2fun) /*  FUN-PARENT */;
  if (v3real_parent!=ECL_NIL) {
   goto L7;
  }
  goto L4;
L7:;
  if (!((v3real_parent)==(v1presumed_parent))){
   goto L10;
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L10:;
  v2fun = v3real_parent;
  goto L3;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3403child_function_p_va(cl_narg narg, cl_object v4presumed_parent, cl_object v5fun, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[3]);
 {
  return L3403child_function_p(v4presumed_parent, v5fun);
 }
}
/* function definition for COMPUTE-CLOSURE-TYPE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3404compute_closure_type(cl_object v1fun)
{
 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 v2lexical_closure_p;
  v2lexical_closure_p = ECL_NIL;
  {
   cl_object v3;
   v3 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-VARS */;
   goto L7;
L6:;
   {
    cl_object v4var;
    v4var = ecl_car(v3);
    {
     cl_object v5;
     v5 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(1, v4var) /*  GLOBAL-VAR-P */;
     if (Null(v5)){
      goto L13;
     }
     goto L11;
L13:;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[11]))->cfun.entry(1, v4var) /*  REF-REF-CCB */)){
      goto L15;
     }
     value0 = VV[12];
     cl_env_copy->nvalues = 1;
     return value0;
L15:;
     v2lexical_closure_p = ECL_T;
    }
L11:;
   }
   v3 = ecl_cdr(v3);
L7:;
   if (Null(v3)){
    goto L20;
   }
   goto L6;
L20:;
  }
  {
   cl_object v3;
   v3 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-FUNS */;
   goto L26;
L25:;
   {
    cl_object v4f;
    v4f = ecl_car(v3);
    if (L3403child_function_p(v1fun, v4f)!=ECL_NIL) {
     goto L30;
    }
    {
     cl_object v5;
     v5 = (cl_env_copy->function=ecl_fdefinition(VV[14]))->cfun.entry(1, v4f) /*  FUN-CLOSURE */;
     if (!((v5)==(VV[12]))){
      goto L33;
     }
     value0 = VV[12];
     cl_env_copy->nvalues = 1;
     return value0;
L33:;
     if (!((v5)==(VV[15]))){
      goto L30;
     }
     v2lexical_closure_p = ECL_T;
    }
L30:;
   }
   v3 = ecl_cdr(v3);
L26:;
   if (Null(v3)){
    goto L39;
   }
   goto L25;
L39:;
  }
  if (Null(v2lexical_closure_p)){
   goto L41;
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[16]))->cfun.entry(1, v1fun) /*  FUN-REF-CCB */!=ECL_NIL) {
   goto L45;
  }
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[17]))->cfun.entry(1, v1fun) /*  FUN-VAR */)){
   goto L43;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[17]))->cfun.entry(1, v1fun) /*  FUN-VAR */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[18]))->cfun.entry(1, T0) /*  VAR-REF */;
  if (!(ecl_plusp(T1))){
   goto L43;
  }
  goto L44;
L45:;
L44:;
  value0 = VV[12];
  cl_env_copy->nvalues = 1;
  return value0;
L43:;
  value0 = VV[15];
  cl_env_copy->nvalues = 1;
  return value0;
L41:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for UPDATE-FUN-CLOSURE-TYPE-MANY                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3405update_fun_closure_type_many(cl_object v1function_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:;
 {
  cl_object v2finish;
  cl_object v3recompute;
  v2finish = ECL_NIL;
  v3recompute = ECL_NIL;
  goto L6;
L5:;
  {
   cl_object v4;
   v4 = v1function_list;
   goto L12;
L11:;
   {
    cl_object v5f;
    v5f = ecl_car(v4);
    if (Null(L3407update_fun_closure_type(v5f))){
     goto L16;
    }
    v3recompute = ECL_T;
    v2finish = ECL_NIL;
L16:;
   }
   v4 = ecl_cdr(v4);
L12:;
   if (Null(v4)){
    goto L23;
   }
   goto L11;
L23:;
  }
  v2finish = ECL_T;
L6:;
  if (v2finish!=ECL_NIL) {
   goto L27;
  }
  goto L5;
L27:;
  value0 = v3recompute;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3405update_fun_closure_type_many_va(cl_narg narg, cl_object v4function_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[19]);
 {
  return L3405update_fun_closure_type_many(v4function_list);
 }
}
/* function definition for PREPEND-NEW                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3406prepend_new(cl_object v1l1, cl_object v2l2)
{
 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 v4f;
  cl_object v5;
  {
   cl_object v6;
   v6 = v1l1;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4f = ECL_NIL;
  v5 = v3;
L8:;
  if (!(ecl_endp(v5))){
   goto L10;
  }
  goto L9;
L10:;
  v4f = ECL_CONS_CAR(v5);
  {
   cl_object v6;
   v6 = ECL_CONS_CDR(v5);
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v5 = v6;
  }
  v2l2 = cl_adjoin(2, v4f, v2l2);
  goto L8;
L9:;
 }
 value0 = v2l2;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3406prepend_new_va(cl_narg narg, cl_object v3l1, cl_object v4l2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[22]);
 {
  return L3406prepend_new(v3l1, v4l2);
 }
}
/* function definition for UPDATE-FUN-CLOSURE-TYPE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3407update_fun_closure_type(cl_object v1fun)
{
 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 v2old_type;
  v2old_type = (cl_env_copy->function=ecl_fdefinition(VV[14]))->cfun.entry(1, v1fun) /*  FUN-CLOSURE */;
  if (!((v2old_type)==(VV[12]))){
   goto L3;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v3;
   cl_object v4to_be_updated;
   v3 = L3404compute_closure_type(v1fun);
   v4to_be_updated = ECL_NIL;
   if (!((v3)==(v2old_type))){
    goto L7;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   if (Null((cl_env_copy->function=ecl_fdefinition(VV[24]))->cfun.entry(1, v1fun) /*  FUN-GLOBAL */)){
    goto L9;
   }
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(1, v1fun) /*  FUN-NAME */;
   {
    cl_object v5;
    v5 = ecl_fdefinition(VV[28]);
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     {
      cl_object v9;
      v9 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-VARS */;
      if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v9;
     }
     v7 = ECL_NIL;
     v8 = v6;
     {
      cl_object v9;
      cl_object v10;
      v9 = ecl_list1(ECL_NIL);
      v10 = v9;
L20:;
      if (!(ecl_endp(v8))){
       goto L22;
      }
      goto L21;
L22:;
      v7 = ECL_CONS_CAR(v8);
      {
       cl_object v11;
       v11 = ECL_CONS_CDR(v8);
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      {
       cl_object v11;
       v11 = v10;
       if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v11;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
      v10 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v10,T2);
      goto L20;
L21:;
      T1 = ecl_cdr(v9);
      goto L11;
     }
    }
   }
L11:;
   (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(3, VV[26], T0, T1) /*  CMPNOTE */;
L9:;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[32]))->cfun.entry(1, v1fun) /*  FUN-CHILD-FUNS */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[33]))->cfun.entry(1, v1fun) /*  FUN-REFERENCING-FUNS */;
   v4to_be_updated = ecl_append(T0,T1);
   ecl_structure_set(v1fun,VV[34],(cl_fixnum)(12),v3);
   if (!((v3)==(VV[12]))){
    goto L41;
   }
   {
    cl_object v5;
    v5 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-VARS */;
    goto L47;
L46:;
    {
     cl_object v6var;
     v6var = ecl_car(v5);
     if ((cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(1, v6var) /*  GLOBAL-VAR-P */!=ECL_NIL) {
      goto L51;
     }
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v6var) /*  VAR-KIND */;
     if ((T0)==(v3)) {
      goto L51;
     }
     ecl_structure_set(v6var,VV[36],(cl_fixnum)(3),ECL_NIL);
     ecl_structure_set(v6var,VV[36],(cl_fixnum)(2),ECL_T);
     ecl_structure_set(v6var,VV[36],(cl_fixnum)(6),VV[12]);
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v6var) /*  VAR-FUNCTIONS-READING */;
     T1 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, v6var) /*  VAR-FUNCTIONS-SETTING */;
     T2 = L3406prepend_new(T1, v4to_be_updated);
     v4to_be_updated = L3406prepend_new(T0, T2);
L51:;
    }
    v5 = ecl_cdr(v5);
L47:;
    if (Null(v5)){
     goto L60;
    }
    goto L46;
L60:;
   }
   {
    cl_object v5;
    v5 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-FUNS */;
    goto L65;
L64:;
    {
     cl_object v6f;
     v6f = ecl_car(v5);
     ecl_structure_set(v6f,VV[34],(cl_fixnum)(2),ECL_T);
    }
    v5 = ecl_cdr(v5);
L65:;
    if (Null(v5)){
     goto L72;
    }
    goto L64;
L72:;
   }
L41:;
   if (Null(L3405update_fun_closure_type_many(v4to_be_updated))){
    goto L74;
   }
   L3407update_fun_closure_type(v1fun);
L74:;
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L3407update_fun_closure_type_va(cl_narg narg, cl_object v5fun, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[20]);
 {
  return L3407update_fun_closure_type(v5fun);
 }
}
/* function definition for LOCAL-FUNCTION-REF                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3408local_function_ref(cl_narg narg, cl_object v1fname, ...)
{
 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[40]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[40]);
 {
  cl_object v2build_object;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2build_object = ECL_NIL;
   } else {
    i++;
    v2build_object = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3;                                  /*  FUN                     */
   cl_object v4;                                  /*  CFB                     */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[41]))->cfun.entry(1, v1fname) /*  CMP-ENV-SEARCH-FUNCTION */;
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L3;
   }
   if (Null(cl_functionp(v3))){
    goto L5;
   }
   if (Null(v2build_object)){
    goto L7;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(2, VV[43], v1fname) /*  CMPERR */;
L7:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L5:;
   {
    cl_object v5;
    T0 = (cl_env_copy->function=ecl_fdefinition(VV[44]))->cfun.entry(1, v3) /*  FUN-REF */;
    v5 = ecl_plus(T0,ecl_make_int8_t(1));
    ecl_structure_set(v3,VV[34],(cl_fixnum)(1),v5);
   }
   if (Null(v2build_object)){
    goto L12;
   }
   ecl_structure_set(v3,VV[34],(cl_fixnum)(2),ECL_T);
   goto L11;
L12:;
   {
    cl_object v5caller;
    v5caller = ecl_cmp_symbol_value(cl_env_copy,VV[45]);
    if (Null(v5caller)){
     goto L11;
    }
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     cl_object v9;
     v6 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v5caller) /*  FUN-REFERENCED-FUNS */;
     v7 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v8 = v3;
     v9 = v6;
     if (si_memq(v8,v9)!=ECL_NIL) {
      goto L11;
     }
    }
    {
     cl_object v6;
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v5caller) /*  FUN-REFERENCED-FUNS */;
     v6 = CONS(v3,T0);
     ecl_structure_set(v5caller,VV[34],(cl_fixnum)(23),v6);
    }
    {
     cl_object v6;
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[33]))->cfun.entry(1, v3) /*  FUN-REFERENCING-FUNS */;
     v6 = CONS(v5caller,T0);
     ecl_structure_set(v3,VV[34],(cl_fixnum)(24),v6);
    }
   }
L11:;
   {
    cl_object v5var;
    v5var = (cl_env_copy->function=ecl_fdefinition(VV[17]))->cfun.entry(1, v3) /*  FUN-VAR */;
    if (Null(v4)){
     goto L3;
    }
    if (Null(v2build_object)){
     goto L3;
    }
    ecl_structure_set(v5var,VV[36],(cl_fixnum)(3),ECL_T);
    T0 = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v5var) /*  VAR-KIND */;
    if ((T0)==(VV[12])) {
     goto L3;
    }
    ecl_structure_set(v5var,VV[36],(cl_fixnum)(6),VV[15]);
   }
L3:;
   value0 = v3;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for FUN-NEEDS-NARG                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3409fun_needs_narg(cl_object v1fun)
{
 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 = L3410fun_fixed_narg(v1fun);
 value0 = Null(T0)?ECL_T:ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3409fun_needs_narg_va(cl_narg narg, cl_object v2fun, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
  return L3409fun_needs_narg(v2fun);
 }
}
/* function definition for FUN-FIXED-NARG                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3410fun_fixed_narg(cl_object v1fun)
{
 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 v2narg;
  v2narg = ECL_NIL;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[14]))->cfun.entry(1, v1fun) /*  FUN-CLOSURE */;
  if ((T0)==(VV[12])) {
   goto L4;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1fun) /*  FUN-MINARG */;
  v2narg = (cl_env_copy->function=ecl_fdefinition(VV[51]))->cfun.entry(1, v1fun) /*  FUN-MAXARG */;
  if (!(ecl_number_equalp(T0,v2narg))){
   goto L4;
  }
  if (!(ecl_lowereq(v2narg,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("C-ARGUMENTS-LIMIT",1056))))){
   goto L4;
  }
  value0 = v2narg;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3410fun_fixed_narg_va(cl_narg narg, cl_object v3fun, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[48]);
 {
  return L3410fun_fixed_narg(v3fun);
 }
}
/* function definition for ADD-TO-FUN-REFERENCED-VARS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3411add_to_fun_referenced_vars(cl_object v1fun, cl_object v2var_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:;
 {
  cl_object v3new_vars;
  v3new_vars = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-VARS */;
  {
   cl_object v4locals;
   v4locals = (cl_env_copy->function=ecl_fdefinition(VV[54]))->cfun.entry(1, v1fun) /*  FUN-LOCAL-VARS */;
   {
    cl_object v5change;
    v5change = ECL_NIL;
    {
     cl_object v6;
     cl_object v7v;
     cl_object v8;
     {
      cl_object v9;
      v9 = v2var_list;
      if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v9;
     }
     v7v = ECL_NIL;
     v8 = v6;
L10:;
     if (!(ecl_endp(v8))){
      goto L12;
     }
     goto L11;
L12:;
     v7v = ECL_CONS_CAR(v8);
     {
      cl_object v9;
      v9 = ECL_CONS_CDR(v8);
      if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v9;
     }
     {
      cl_object v9;
      cl_object v10;
      cl_object v11;
      v9 = (ECL_SYM("EQ",335)->symbol.gfdef);
      v10 = v7v;
      v11 = v4locals;
      if (si_memq(v10,v11)!=ECL_NIL) {
       goto L20;
      }
     }
     {
      cl_object v9;
      cl_object v10;
      cl_object v11;
      v9 = (ECL_SYM("EQ",335)->symbol.gfdef);
      v10 = v7v;
      v11 = v3new_vars;
      if (si_memq(v10,v11)!=ECL_NIL) {
       goto L20;
      }
     }
     v5change = ECL_T;
     v3new_vars = CONS(v7v,v3new_vars);
L20:;
     goto L10;
L11:;
     if (Null(v5change)){
      goto L33;
     }
     ecl_structure_set(v1fun,VV[34],(cl_fixnum)(22),v3new_vars);
     value0 = ECL_T;
     cl_env_copy->nvalues = 1;
     return value0;
L33:;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
 }
}
static cl_object L3411add_to_fun_referenced_vars_va(cl_narg narg, cl_object v9fun, cl_object v10var_list, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[53]);
 {
  return L3411add_to_fun_referenced_vars(v9fun, v10var_list);
 }
}
/* function definition for ADD-TO-FUN-REFERENCED-FUNS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3412add_to_fun_referenced_funs(cl_object v1fun, cl_object v2fun_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 v3new_funs;
  v3new_funs = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v1fun) /*  FUN-REFERENCED-FUNS */;
  {
   cl_object v4change;
   v4change = ECL_NIL;
   {
    cl_object v5;
    cl_object v6f;
    cl_object v7;
    {
     cl_object v8;
     v8 = v2fun_list;
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6f = ECL_NIL;
    v7 = v5;
L9:;
    if (!(ecl_endp(v7))){
     goto L11;
    }
    goto L10;
L11:;
    v6f = ECL_CONS_CAR(v7);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v7);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    if ((v1fun)==(v6f)) {
     goto L19;
    }
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     v8 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v9 = v6f;
     v10 = v3new_funs;
     if (si_memq(v9,v10)!=ECL_NIL) {
      goto L19;
     }
    }
    if (L3403child_function_p(v1fun, v6f)!=ECL_NIL) {
     goto L19;
    }
    v4change = ECL_T;
    v3new_funs = CONS(v6f,v3new_funs);
    {
     cl_object v8;
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[33]))->cfun.entry(1, v6f) /*  FUN-REFERENCING-FUNS */;
     v8 = CONS(v1fun,T0);
     ecl_structure_set(v6f,VV[34],(cl_fixnum)(24),v8);
    }
L19:;
    goto L9;
L10:;
    if (Null(v4change)){
     goto L32;
    }
    ecl_structure_set(v1fun,VV[34],(cl_fixnum)(23),v3new_funs);
    value0 = ECL_T;
    cl_env_copy->nvalues = 1;
    return value0;
L32:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L3412add_to_fun_referenced_funs_va(cl_narg narg, cl_object v8fun, cl_object v9fun_list, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[56]);
 {
  return L3412add_to_fun_referenced_funs(v8fun, v9fun_list);
 }
}
/* function definition for FUNCTION-BLOCK-NAME-DECLARATION                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3413function_block_name_declaration(cl_object v1declarations)
{
 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;
  cl_object v3i;
  cl_object v4;
  {
   cl_object v5;
   v5 = v1declarations;
   if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v5;
  }
  v3i = ECL_NIL;
  v4 = v2;
L7:;
  if (!(ecl_endp(v4))){
   goto L9;
  }
  goto L8;
L9:;
  v3i = 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_CONSP(v3i))){
   goto L17;
  }
  T0 = ecl_car(v3i);
  if (!((T0)==(ECL_SYM("FUNCTION-BLOCK-NAME",1091)))){
   goto L17;
  }
  {
   cl_object v5;
   cl_object v6;
   v5 = ecl_cadr(v3i);
   v6 = ecl_cddr(v3i);
   if (!(ECL_SYMBOLP(v5))){
    goto L25;
   }
   if (v6==ECL_NIL) {
    goto L22;
   }
   goto L23;
L25:;
   goto L23;
L23:;
   (cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(3, VV[59], ECL_SYM("FUNCTION-BLOCK-NAME",1091), v3i) /*  CMPERR */;
L22:;
   value0 = v5;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L17:;
  goto L7;
L8:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3413function_block_name_declaration_va(cl_narg narg, cl_object v5declarations, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[58]);
 {
  return L3413function_block_name_declaration(v5declarations);
 }
}
/* function definition for EXPORTED-FNAME                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3414exported_fname(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:;
 {
  cl_object v2cname;
  v2cname = ECL_NIL;
  if (!(ECL_SYMBOLP(v1name))){
   goto L3;
  }
  v2cname = si_get_sysprop(v1name, VV[62]);
  if (Null(v2cname)){
   goto L3;
  }
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_T;
  cl_env_copy->values[0] = v2cname;
  return cl_env_copy->values[0];
L3:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[63]))->cfun.entry(2, VV[64], v1name) /*  NEXT-CFUN */;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
 }
}
static cl_object L3414exported_fname_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[61]);
 {
  return L3414exported_fname(v3name);
 }
}
#include "cmp/cmpfun.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclrllw5SGHSV7k9_l1S0M881(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:CMP;CMPFUN.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclrllw5SGHSV7k9_l1S0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(_ecl_static_0);
  ecl_cmp_defun(VV[66]);                          /*  REGISTER-FUNCTION       */
  ecl_cmp_defun(VV[67]);                          /*  CHILD-FUNCTION-P        */
  (void)0; /* No entry created for COMPUTE-CLOSURE-TYPE */
  ecl_cmp_defun(VV[68]);                          /*  UPDATE-FUN-CLOSURE-TYPE-MANY */
  ecl_cmp_defun(VV[69]);                          /*  PREPEND-NEW             */
  ecl_cmp_defun(VV[70]);                          /*  UPDATE-FUN-CLOSURE-TYPE */
  ecl_cmp_defun(VV[71]);                          /*  LOCAL-FUNCTION-REF      */
  ecl_cmp_defun(VV[72]);                          /*  FUN-NEEDS-NARG          */
  ecl_cmp_defun(VV[73]);                          /*  FUN-FIXED-NARG          */
  ecl_cmp_defun(VV[74]);                          /*  ADD-TO-FUN-REFERENCED-VARS */
  ecl_cmp_defun(VV[75]);                          /*  ADD-TO-FUN-REFERENCED-FUNS */
  ecl_cmp_defun(VV[76]);                          /*  FUNCTION-BLOCK-NAME-DECLARATION */
  ecl_cmp_defun(VV[77]);                          /*  EXPORTED-FNAME          */
}
