/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpenv-fun.lsp                  */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpenv-fun.eclh"
/* function definition for FUNCTION-ARG-TYPES                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3263function_arg_types(cl_object v1arg_types)
{
 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 v2types;
  v2types = ECL_NIL;
  {
   cl_object v3al;
   {
    cl_object v4;
    v4 = v1arg_types;
    value0 = ecl_make_bool(ECL_FIXNUMP(v4));
    if (value0!=ECL_NIL) {
     goto L9;
    }
    value0 = ecl_make_bool(ECL_CHARACTERP(v4));
    if (value0!=ECL_NIL) {
     goto L9;
    }
    T1 = ecl_make_bool(floatp(v4));
    goto L7;
L9:;
    T1 = value0;
    goto L7;
L7:;
    T0 = Null(T1)?ECL_T:ECL_NIL;
    if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[1],v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3al = v4;
   }
   goto L14;
L13:;
   T0 = ecl_car(v3al);
   v2types = CONS(T0,v2types);
   {
    cl_object v4;
    v4 = ecl_cdr(v3al);
    value0 = ecl_make_bool(ECL_FIXNUMP(v4));
    if (value0!=ECL_NIL) {
     goto L25;
    }
    value0 = ecl_make_bool(ECL_CHARACTERP(v4));
    if (value0!=ECL_NIL) {
     goto L25;
    }
    T1 = ecl_make_bool(floatp(v4));
    goto L23;
L25:;
    T1 = value0;
    goto L23;
L23:;
    T0 = Null(T1)?ECL_T:ECL_NIL;
    if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[1],v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3al = v4;
   }
L14:;
   if (ecl_endp(v3al)) {
    goto L28;
   }
   {
    cl_object v4;
    v4 = ecl_car(v3al);
    if (!((v4)==(ECL_SYM("&OPTIONAL",13)))){
     goto L34;
    }
    goto L28;
L34:;
    goto L32;
L32:;
    if (!((v4)==(ECL_SYM("&REST",14)))){
     goto L38;
    }
    goto L28;
L38:;
    goto L36;
L36:;
    if (!((v4)==(ECL_SYM("&KEY",12)))){
     goto L41;
    }
    goto L28;
L41:;
    goto L29;
   }
L29:;
   goto L13;
L28:;
   value0 = cl_nreverse(v2types);
   return value0;
  }
 }
}
static cl_object L3263function_arg_types_va(cl_narg narg, cl_object v4arg_types, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3263function_arg_types(v4arg_types);
 }
}
/* function definition for PROCLAIM-FUNCTION                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3264proclaim_function(cl_narg narg, cl_object v1fname, cl_object v2decl, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[6]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[6]);
 {
  cl_object v3destination;
  va_list args; va_start(args,v2decl);
  {
   int i = 2;
   if (i >= narg) {
    v3destination = ECL_NIL;
   } else {
    i++;
    v3destination = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(si_valid_function_name_p(v1fname))){
   goto L2;
  }
  {
   cl_object v4arg_types;
   cl_object v5return_types;
   cl_object v6l;
   v4arg_types = ECL_SYM("*",20);
   v5return_types = ECL_SYM("*",20);
   v6l = v2decl;
   {
    cl_object v7;
    v7 = ecl_make_bool(v6l==ECL_NIL);
    if (Null(v7)){
     goto L9;
    }
    goto L7;
L9:;
    if (!(ECL_CONSP(v6l))){
     goto L11;
    }
    {
     cl_object v8;
     v8 = v6l;
     {
      cl_object v9;
      v9 = v8;
      {
       bool v10;
       v10 = ECL_LISTP(v9);
       if (ecl_unlikely(!(v10)))
         FEwrong_type_argument(VV[9],v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v8)){
      goto L18;
     }
     {
      cl_object v9;
      v9 = ECL_CONS_CDR(v8);
      v6l = v9;
      v8 = ECL_CONS_CAR(v8);
     }
L18:;
     v4arg_types = v8;
    }
    goto L7;
L11:;
    (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(3, VV[10], v1fname, v2decl) /*  WARN */;
   }
L7:;
   {
    cl_object v7;
    v7 = ecl_make_bool(v6l==ECL_NIL);
    if (Null(v7)){
     goto L26;
    }
    goto L24;
L26:;
    if (ECL_ATOM(v6l)) {
     goto L30;
    }
    if (Null(ecl_cdr(v6l))){
     goto L28;
    }
    goto L29;
L30:;
L29:;
    (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(3, VV[10], v1fname, v2decl) /*  WARN */;
    goto L24;
L28:;
    v5return_types = ecl_car(v6l);
   }
L24:;
   if (!((v4arg_types)==(ECL_NIL))){
    goto L33;
   }
   v4arg_types = VV[11];
L33:;
   if (!((v4arg_types)==(ECL_SYM("*",20)))){
    goto L37;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[12]))->cfun.entry(3, v1fname, VV[13], v3destination) /*  REM-PROPERTY */;
   goto L36;
L37:;
   (cl_env_copy->function=ecl_fdefinition(VV[14]))->cfun.entry(4, v1fname, VV[13], v4arg_types, v3destination) /*  PUT-PROPERTY */;
L36:;
   {
    cl_object v7;
    v7 = (ECL_SYM("EQUALP",338)->symbol.gfdef);
    if (!(ecl_equalp(v5return_types,ECL_SYM("*",20)))){
     goto L45;
    }
    goto L42;
L45:;
    goto L43;
L43:;
    if (!(ecl_equalp(v5return_types,VV[16]))){
     goto L39;
    }
    goto L40;
L42:;
   }
L40:;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[12]))->cfun.entry(3, v1fname, VV[18], v3destination) /*  REM-PROPERTY */;
   return value0;
L39:;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[14]))->cfun.entry(4, v1fname, VV[18], v5return_types, v3destination) /*  PUT-PROPERTY */;
   return value0;
  }
L2:;
  value0 = (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(3, VV[10], v1fname, v2decl) /*  WARN */;
  return value0;
 }
}
/* function definition for ADD-FUNCTION-DECLARATION                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3265add_function_declaration(cl_narg narg, cl_object v1fname, cl_object v2ftype, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[21]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[21]);
 {
  cl_object v3env;
  va_list args; va_start(args,v2ftype);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(si_valid_function_name_p(v1fname))){
   goto L3;
  }
  {
   cl_object v4fun;
   v4fun = (cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(1, v1fname) /*  CMP-ENV-SEARCH-FUNCTION */;
   if (Null(cl_functionp(v4fun))){
    goto L6;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[23], v1fname) /*  WARN */;
   goto L2;
L6:;
   (cl_env_copy->function=ecl_fdefinition(VV[24]))->cfun.entry(3, v1fname, v2ftype, v3env) /*  CMP-ENV-REGISTER-FTYPE */;
   goto L2;
  }
L3:;
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[25], v1fname) /*  WARN */;
L2:;
  value0 = v3env;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for GET-ARG-TYPES                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3266get_arg_types(cl_narg narg, cl_object v1fname, ...)
{
 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[27]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[27]);
 {
  cl_object v2env;
  cl_object v3may_be_global;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v3may_be_global = ECL_T;
   } else {
    i++;
    v3may_be_global = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4x;
   v4x = (cl_env_copy->function=ecl_fdefinition(VV[28]))->cfun.entry(2, v1fname, v2env) /*  CMP-ENV-SEARCH-FTYPE */;
   if (Null(v4x)){
    goto L4;
   }
   {
    cl_object v5arg_types;
    v5arg_types = ecl_car(v4x);
    if ((v5arg_types)==(ECL_SYM("*",20))) {
     goto L7;
    }
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = ECL_T;
    cl_env_copy->values[0] = v5arg_types;
    return cl_env_copy->values[0];
L7:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L4:;
   if (Null(v3may_be_global)){
    goto L9;
   }
   {
    cl_object v6fun;
    v6fun = (cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(2, v1fname, v2env) /*  CMP-ENV-SEARCH-FUNCTION */;
    if (v6fun==ECL_NIL) {
     goto L14;
    }
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[29]))->cfun.entry(1, v6fun) /*  FUN-P */)){
     goto L12;
    }
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[30]))->cfun.entry(1, v6fun) /*  FUN-GLOBAL */)){
     goto L12;
    }
    goto L13;
L14:;
L13:;
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[31]))->cfun.entry(2, v1fname, VV[13]) /*  GET-GLOBAL-PROPERTY */;
    return value0;
L12:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L9:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for GET-RETURN-TYPE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3267get_return_type(cl_narg narg, cl_object v1fname, ...)
{
 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[33]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[33]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3x;
   v3x = (cl_env_copy->function=ecl_fdefinition(VV[28]))->cfun.entry(2, v1fname, v2env) /*  CMP-ENV-SEARCH-FTYPE */;
   if (Null(v3x)){
    goto L3;
   }
   {
    cl_object v4return_types;
    v4return_types = ecl_cadr(v3x);
    if ((v4return_types)==(ECL_SYM("*",20))) {
     goto L6;
    }
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = ECL_T;
    cl_env_copy->values[0] = v4return_types;
    return cl_env_copy->values[0];
L6:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L3:;
   {
    cl_object v5fun;
    v5fun = (cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(2, v1fname, v2env) /*  CMP-ENV-SEARCH-FUNCTION */;
    if (v5fun==ECL_NIL) {
     goto L11;
    }
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[29]))->cfun.entry(1, v5fun) /*  FUN-P */)){
     goto L9;
    }
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[30]))->cfun.entry(1, v5fun) /*  FUN-GLOBAL */)){
     goto L9;
    }
    goto L10;
L11:;
L10:;
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[31]))->cfun.entry(2, v1fname, VV[18]) /*  GET-GLOBAL-PROPERTY */;
    return value0;
L9:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* function definition for GET-LOCAL-ARG-TYPES                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3268get_local_arg_types(cl_narg 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[35]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[35]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fun);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3x;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[36]))->cfun.entry(1, v1fun) /*  FUN-NAME */;
   v3x = (cl_env_copy->function=ecl_fdefinition(VV[28]))->cfun.entry(2, T0, v2env) /*  CMP-ENV-SEARCH-FTYPE */;
   if (Null(v3x)){
    goto L3;
   }
   T0 = ecl_car(v3x);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
L3:;
   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];
  }
 }
}
/* function definition for GET-LOCAL-RETURN-TYPE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3269get_local_return_type(cl_narg 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[38]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[38]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fun);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3x;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[36]))->cfun.entry(1, v1fun) /*  FUN-NAME */;
   v3x = (cl_env_copy->function=ecl_fdefinition(VV[28]))->cfun.entry(2, T0, v2env) /*  CMP-ENV-SEARCH-FTYPE */;
   if (Null(v3x)){
    goto L3;
   }
   T0 = ecl_cadr(v3x);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
L3:;
   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];
  }
 }
}
/* function definition for GET-PROCLAIMED-NARG                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3270get_proclaimed_narg(cl_narg narg, cl_object v1fun, ...)
{
 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 v2env;
  va_list args; va_start(args,v1fun);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3;                                  /*  ARG-LIST                */
   cl_object v4;                                  /*  FOUND                   */
   value0 = L3266get_arg_types(2, v1fun, v2env);
   {
    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(v4)){
    goto L3;
   }
   {
    cl_object v5;
    cl_object v6type;
    cl_object v7;
    {
     cl_object v8;
     v8 = v3;
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6type = ECL_NIL;
    v7 = v5;
    {
     cl_object v8minarg;
     cl_object v9maxarg;
     cl_object v10in_optionals;
     v8minarg = ecl_make_int8_t(0);
     v9maxarg = ecl_make_int8_t(0);
     v10in_optionals = ECL_NIL;
L13:;
     if (!(ecl_endp(v7))){
      goto L15;
     }
     goto L14;
L15:;
     v6type = ECL_CONS_CAR(v7);
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v7);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v11;
     }
     {
      cl_object v11;
      v11 = (ECL_SYM("EQ",335)->symbol.gfdef);
      if (!((v6type)==(ECL_SYM("*",20)))){
       goto L30;
      }
      goto L27;
L30:;
      goto L28;
L28:;
      if (!((v6type)==(ECL_SYM("&REST",14)))){
       goto L34;
      }
      goto L27;
L34:;
      goto L32;
L32:;
      if (!((v6type)==(ECL_SYM("&KEY",12)))){
       goto L38;
      }
      goto L27;
L38:;
      goto L36;
L36:;
      if (!((v6type)==(ECL_SYM("&ALLOW-OTHER-KEYS",8)))){
       goto L24;
      }
      goto L25;
L27:;
     }
L25:;
     cl_env_copy->nvalues = 3;
     cl_env_copy->values[2] = v4;
     cl_env_copy->values[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("CALL-ARGUMENTS-LIMIT",181));
     cl_env_copy->values[0] = v8minarg;
     return cl_env_copy->values[0];
L24:;
     if (!((v6type)==(ECL_SYM("&OPTIONAL",13)))){
      goto L41;
     }
     v10in_optionals = ECL_T;
     v9maxarg = v8minarg;
     goto L23;
L41:;
     if (Null(v10in_optionals)){
      goto L46;
     }
     v9maxarg = ecl_plus(v9maxarg,ecl_make_int8_t(1));
     goto L23;
L46:;
     v8minarg = ecl_plus(v8minarg,ecl_make_int8_t(1));
     v9maxarg = ecl_plus(v9maxarg,ecl_make_int8_t(1));
L23:;
     goto L13;
L14:;
     cl_env_copy->nvalues = 3;
     cl_env_copy->values[2] = v4;
     cl_env_copy->values[1] = v9maxarg;
     cl_env_copy->values[0] = v8minarg;
     return cl_env_copy->values[0];
    }
   }
L3:;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = v4;
   cl_env_copy->values[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("CALL-ARGUMENTS-LIMIT",181));
   cl_env_copy->values[0] = ecl_make_int8_t(0);
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for DECLARE-INLINE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3271declare_inline(cl_narg narg, cl_object v1fname, ...)
{
 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[48]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[48]);
 {
  cl_object v2env;
  cl_object v3definition;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v3definition = ECL_T;
   } else {
    i++;
    v3definition = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (si_valid_function_name_p(v1fname)!=ECL_NIL) {
   goto L3;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(2, VV[50], v1fname) /*  CMPERR */;
L3:;
  T0 = CONS(v1fname,v3definition);
  T1 = ecl_list1(T0);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[51]))->cfun.entry(3, ECL_SYM("INLINE",436), T1, v2env) /*  CMP-ENV-EXTEND-DECLARATION */;
  return value0;
 }
}
/* function definition for DECLARE-NOTINLINE                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3272declare_notinline(cl_narg narg, cl_object v1fname, ...)
{
 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[53]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[53]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L3271declare_inline(3, v1fname, v2env, ECL_NIL);
  return value0;
 }
}
/* function definition for PROCLAIM-INLINE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3273proclaim_inline(cl_object v1fname_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 v2;
  v2 = v1fname_list;
  goto L5;
L4:;
  {
   cl_object v3fun;
   v3fun = ecl_car(v2);
   if (si_valid_function_name_p(v3fun)!=ECL_NIL) {
    goto L9;
   }
   cl_error(2, VV[56], v3fun);
L9:;
   if (si_get_sysprop(v3fun, ECL_SYM("INLINE",436))!=ECL_NIL) {
    goto L11;
   }
   si_put_sysprop(v3fun, ECL_SYM("INLINE",436), ECL_T);
   si_rem_sysprop(v3fun, ECL_SYM("NOTINLINE",589));
L11:;
  }
  v2 = ecl_cdr(v2);
L5:;
  if (Null(v2)){
   goto L16;
  }
  goto L4;
L16:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3273proclaim_inline_va(cl_narg narg, cl_object v3fname_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[55]);
 {
  return L3273proclaim_inline(v3fname_list);
 }
}
/* function definition for PROCLAIM-NOTINLINE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3274proclaim_notinline(cl_object v1fname_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 v2;
  v2 = v1fname_list;
  goto L5;
L4:;
  {
   cl_object v3fun;
   v3fun = ecl_car(v2);
   if (si_valid_function_name_p(v3fun)!=ECL_NIL) {
    goto L9;
   }
   cl_error(2, VV[59], v3fun);
L9:;
   si_rem_sysprop(v3fun, ECL_SYM("INLINE",436));
   si_put_sysprop(v3fun, ECL_SYM("NOTINLINE",589), ECL_T);
  }
  v2 = ecl_cdr(v2);
L5:;
  if (Null(v2)){
   goto L15;
  }
  goto L4;
L15:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3274proclaim_notinline_va(cl_narg narg, cl_object v3fname_list, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[58]);
 {
  return L3274proclaim_notinline(v3fname_list);
 }
}
/* function definition for DECLARED-INLINE-P                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3275declared_inline_p(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[61]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[61]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3x;
   cl_object v4flag;
   v3x = (cl_env_copy->function=ecl_fdefinition(VV[62]))->cfun.entry(2, ECL_SYM("INLINE",436), v2env) /*  CMP-ENV-SEARCH-DECLARATION */;
   {
    cl_object v5;
    v5 = ecl_fdefinition(VV[63]);
    {
     cl_object v6;
     v6 = v3x;
     goto L8;
L7:;
     {
      cl_object v7;
      cl_object v8;
      {
       cl_object v9;
       v9 = v6;
       if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v7 = v9;
      }
      v8 = ECL_CONS_CAR(v7);
      if (Null(v8)){
       goto L10;
      }
      {
       cl_object v9;
       {
        cl_object v10;
        v10 = v8;
        if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v10;
       }
       v9 = ECL_CONS_CAR(T0);
       if (Null((cl_env_copy->function=ecl_fdefinition(VV[63]))->cfun.entry(2, v1fname, v9) /*  SAME-FNAME-P */)){
        goto L10;
       }
       v4flag = v8;
       goto L3;
      }
     }
L10:;
     v6 = ECL_CONS_CDR(v6);
L8:;
     if (v6==ECL_NIL) {
      goto L23;
     }
     goto L7;
L23:;
     v4flag = ECL_NIL;
    }
   }
L3:;
   if (Null(v4flag)){
    goto L25;
   }
   value0 = ecl_cdr(v4flag);
   cl_env_copy->nvalues = 1;
   return value0;
L25:;
   value0 = si_get_sysprop(v1fname, ECL_SYM("INLINE",436));
   return value0;
  }
 }
}
/* function definition for DECLARED-NOTINLINE-P                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3276declared_notinline_p(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[66]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[66]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3x;
   cl_object v4flag;
   v3x = (cl_env_copy->function=ecl_fdefinition(VV[62]))->cfun.entry(2, ECL_SYM("INLINE",436), v2env) /*  CMP-ENV-SEARCH-DECLARATION */;
   {
    cl_object v5;
    v5 = ecl_fdefinition(VV[63]);
    {
     cl_object v6;
     v6 = v3x;
     goto L8;
L7:;
     {
      cl_object v7;
      cl_object v8;
      {
       cl_object v9;
       v9 = v6;
       if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v7 = v9;
      }
      v8 = ECL_CONS_CAR(v7);
      if (Null(v8)){
       goto L10;
      }
      {
       cl_object v9;
       {
        cl_object v10;
        v10 = v8;
        if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v10;
       }
       v9 = ECL_CONS_CAR(T0);
       if (Null((cl_env_copy->function=ecl_fdefinition(VV[63]))->cfun.entry(2, v1fname, v9) /*  SAME-FNAME-P */)){
        goto L10;
       }
       v4flag = v8;
       goto L3;
      }
     }
L10:;
     v6 = ECL_CONS_CDR(v6);
L8:;
     if (v6==ECL_NIL) {
      goto L23;
     }
     goto L7;
L23:;
     v4flag = ECL_NIL;
    }
   }
L3:;
   if (Null(v4flag)){
    goto L25;
   }
   T0 = ecl_cdr(v4flag);
   value0 = ecl_make_bool(T0==ECL_NIL);
   cl_env_copy->nvalues = 1;
   return value0;
L25:;
   value0 = si_get_sysprop(v1fname, ECL_SYM("NOTINLINE",589));
   return value0;
  }
 }
}
/* function definition for INLINE-POSSIBLE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3277inline_possible(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[68]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[68]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1fname);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = L3276declared_notinline_p(2, v1fname, v2env);
  value0 = Null(T0)?ECL_T:ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for MAYBE-INSTALL-INLINE-FUNCTION                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3278maybe_install_inline_function(cl_object v1fname, cl_object v2form)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(L3275declared_inline_p(2, v1fname, ecl_cmp_symbol_value(cl_env_copy,VV[71])))){
  goto L2;
 }
 L3271declare_inline(2, v1fname, ecl_cmp_symbol_value(cl_env_copy,VV[71]));
 si_rem_sysprop(v1fname, ECL_SYM("INLINE",436));
 T0 = cl_list(2, ECL_SYM("QUOTE",682), v1fname);
 T1 = cl_list(2, ECL_SYM("QUOTE",682), v2form);
 T2 = cl_list(4, ECL_SYM("PUT-SYSPROP",1150), T0, VV[73], T1);
 value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[72], T2);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3278maybe_install_inline_function_va(cl_narg narg, cl_object v3fname, cl_object v4form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[70]);
 {
  return L3278maybe_install_inline_function(v3fname, v4form);
 }
}
/* function definition for SET-CLOSURE-ENV                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3280set_closure_env(cl_narg narg, cl_object v1definition, cl_object v2lexenv, ...)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[75]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[75]);
 {
  va_list args; va_start(args,v2lexenv);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v1definition,env0);          /*  DEFINITION              */
  {
   int i = 2;
   if (i >= narg) {
    CLV1 = env0 = CONS(ecl_cmp_symbol_value(cl_env_copy,VV[20]),env0); /*  ENV */
   } else {
    i++;
    CLV1 = env0 = CONS(va_arg(args,cl_object),env0); /*  ENV                  */
   }
  }
  va_end(args);
  {
   cl_object v3;
   v3 = ecl_make_cclosure_va((cl_objectfn)LC3279handle_record,env0,Cblock,1);
   cl_map(3, ECL_NIL, v3, v2lexenv);
   value0 = ECL_CONS_CAR(CLV0);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* closure HANDLE-RECORD                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3279handle_record(cl_narg narg, cl_object v1record, ...)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object CLV0, CLV1;
 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 ... */
 CLV1 = env0;                                     /*  ENV                     */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[76]);
 {
L1:;
  if (ECL_LISTP(v1record)) {
   goto L2;
  }
  {
   cl_object v2;                                  /*  RECORD-DEF              */
   cl_object v3;                                  /*  RECORD-LEXENV           */
   value0 = cl_function_lambda_expression(v1record);
   {
    v2 = value0;
    v3 = cl_env_copy->values[1];
   }
   {
    cl_object v4self_ref;
    cl_object v5flet_env;
    v4self_ref = cl_position(2, v1record, v3);
    v5flet_env = cl_remove(2, v1record, v3);
    {
     cl_object v6;
     v6 = ecl_car(v2);
     if (!((v6)==(ECL_SYM("LAMBDA",454)))){
      goto L9;
     }
     v2 = ecl_cdr(v2);
     goto L7;
L9:;
     if (!((v6)==(ECL_SYM("LAMBDA-BLOCK",1377)))){
      goto L12;
     }
     v2 = ecl_cddr(v2);
     goto L7;
L12:;
     cl_error(2, VV[77], v2);
    }
L7:;
    {
     cl_object v6;
     {
      cl_fixnum v7;
      v7 = ecl_length(v2);
      if (!((v7)==((cl_fixnum)(2)))){
       goto L18;
      }
     }
     T0 = ecl_cadr(v2);
     goto L17;
L18:;
     T1 = ecl_cdr(v2);
     T0 = CONS(ECL_SYM("PROGN",674),T1);
L17:;
     T1 = L3280set_closure_env(3, T0, v5flet_env, ECL_CONS_CAR(CLV1));
     v6 = ecl_list1(T1);
     {
      cl_object v7;
      v7 = v2;
      if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v7;
     }
     (ECL_CONS_CDR(T0)=v6,T0);
    }
    if (Null(v4self_ref)){
     goto L25;
    }
    T0 = si_compiled_function_name(v1record);
    T1 = CONS(T0,v2);
    T2 = ecl_list1(T1);
    ECL_CONS_CAR(CLV0) = cl_list(3, ECL_SYM("LABELS",453), T2, ECL_CONS_CAR(CLV0));
    goto L24;
L25:;
    T0 = si_compiled_function_name(v1record);
    T1 = CONS(T0,v2);
    T2 = ecl_list1(T1);
    ECL_CONS_CAR(CLV0) = cl_list(3, ECL_SYM("FLET",375), T2, ECL_CONS_CAR(CLV0));
L24:;
    value0 = ECL_CONS_CAR(CLV0);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
L2:;
  if (!(ECL_LISTP(v1record))){
   goto L27;
  }
  T0 = ecl_car(v1record);
  if (!(ECL_SYMBOLP(T0))){
   goto L27;
  }
  T0 = ecl_car(v1record);
  if (!((T0)==(ECL_SYM("MACRO",1113)))){
   goto L30;
  }
  T0 = ecl_cddr(v1record);
  T1 = ecl_cadr(v1record);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[78]))->cfun.entry(3, T0, T1, ECL_CONS_CAR(CLV1)) /*  CMP-ENV-REGISTER-MACRO */;
  return value0;
L30:;
  T0 = ecl_car(v1record);
  if (!((T0)==(ECL_SYM("SYMBOL-MACRO",1184)))){
   goto L32;
  }
  T0 = ecl_cddr(v1record);
  T1 = ecl_cadr(v1record);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[79]))->cfun.entry(3, T0, T1, ECL_CONS_CAR(CLV1)) /*  CMP-ENV-REGISTER-SYMBOL-MACRO-FUNCTION */;
  return value0;
L32:;
  T0 = ecl_car(v1record);
  T1 = ecl_cdr(v1record);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), T1);
  T3 = cl_list(2, T0, T2);
  T4 = ecl_list1(T3);
  ECL_CONS_CAR(CLV0) = cl_list(3, ECL_SYM("LET",479), T4, ECL_CONS_CAR(CLV0));
  value0 = ECL_CONS_CAR(CLV0);
  cl_env_copy->nvalues = 1;
  return value0;
L27:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
#include "cmp/cmpenv-fun.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl5shPkhxZsTcr9_kpP0M881(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;CMPENV-FUN.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl5shPkhxZsTcr9_kpP0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[81]);                          /*  FUNCTION-ARG-TYPES      */
  ecl_cmp_defun(VV[82]);                          /*  PROCLAIM-FUNCTION       */
  ecl_cmp_defun(VV[83]);                          /*  ADD-FUNCTION-DECLARATION */
  ecl_cmp_defun(VV[84]);                          /*  GET-ARG-TYPES           */
  ecl_cmp_defun(VV[85]);                          /*  GET-RETURN-TYPE         */
  ecl_cmp_defun(VV[86]);                          /*  GET-LOCAL-ARG-TYPES     */
  ecl_cmp_defun(VV[87]);                          /*  GET-LOCAL-RETURN-TYPE   */
  ecl_cmp_defun(VV[88]);                          /*  GET-PROCLAIMED-NARG     */
  ecl_cmp_defun(VV[89]);                          /*  DECLARE-INLINE          */
  ecl_cmp_defun(VV[90]);                          /*  DECLARE-NOTINLINE       */
  ecl_cmp_defun(VV[91]);                          /*  PROCLAIM-INLINE         */
  ecl_cmp_defun(VV[92]);                          /*  PROCLAIM-NOTINLINE      */
  ecl_cmp_defun(VV[93]);                          /*  DECLARED-INLINE-P       */
  ecl_cmp_defun(VV[94]);                          /*  DECLARED-NOTINLINE-P    */
  ecl_cmp_defun(VV[95]);                          /*  INLINE-POSSIBLE         */
  ecl_cmp_defun(VV[96]);                          /*  MAYBE-INSTALL-INLINE-FUNCTION */
  ecl_cmp_defun(VV[97]);                          /*  SET-CLOSURE-ENV         */
}
