/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpenv-optimize.lsp             */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpenv-optimize.eclh"
/* function definition for DEFAULT-POLICY                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3281default_policy()
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_list(2, ECL_SYM("SPACE",791), ecl_cmp_symbol_value(cl_env_copy,VV[2]));
 T1 = cl_list(2, ECL_SYM("SAFETY",737), ecl_cmp_symbol_value(cl_env_copy,VV[3]));
 T2 = cl_list(2, ECL_SYM("DEBUG",272), ecl_cmp_symbol_value(cl_env_copy,VV[4]));
 T3 = cl_list(2, ECL_SYM("SPEED",794), ecl_cmp_symbol_value(cl_env_copy,VV[5]));
 T4 = cl_list(2, ECL_SYM("COMPILATION-SPEED",234), ecl_cmp_symbol_value(cl_env_copy,VV[6]));
 T5 = cl_list(5, T0, T1, T2, T3, T4);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(2, T5, ecl_make_int8_t(0)) /*  COMPUTE-POLICY */;
 return value0;
}
static cl_object L3281default_policy_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[0]);
 {
  return L3281default_policy();
 }
}
/* function definition for CMP-ENV-POLICY                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3282cmp_env_policy(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(2, VV[10], v1env) /*  CMP-ENV-SEARCH-DECLARATION */;
 value0 = ecl_car(T0);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = L3281default_policy();
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3282cmp_env_policy_va(cl_narg narg, cl_object v2env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[8]);
 {
  return L3282cmp_env_policy(v2env);
 }
}
/* function definition for ADD-DEFAULT-OPTIMIZATIONS                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3283add_default_optimizations(cl_object v1env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(2, VV[10], v1env) /*  CMP-ENV-SEARCH-DECLARATION */)){
  goto L2;
 }
 value0 = v1env;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = L3281default_policy();
 T1 = ecl_list1(T0);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(3, VV[10], T1, v1env) /*  CMP-ENV-ADD-DECLARATION */;
 return value0;
}
static cl_object L3283add_default_optimizations_va(cl_narg narg, cl_object v2env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[12]);
 {
  return L3283add_default_optimizations(v2env);
 }
}
/* function definition for CMP-ENV-ADD-OPTIMIZATIONS                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3284cmp_env_add_optimizations(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[16]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[16]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1decl);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3old;
   cl_object v4new;
   v3old = L3282cmp_env_policy(v2env);
   v4new = (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(2, v1decl, v3old) /*  COMPUTE-POLICY */;
   T0 = ecl_list1(v4new);
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(3, VV[10], T0, v2env) /*  CMP-ENV-ADD-DECLARATION */;
   return value0;
  }
 }
}
/* function definition for MAYBE-ADD-POLICY                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3285maybe_add_policy(cl_narg narg, cl_object v1decl, ...)
{
 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[18]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[18]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1decl);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(ECL_CONSP(v1decl))){
   goto L2;
  }
  T0 = cl_list_length(v1decl);
  if (!(ecl_lowereq(T0,ecl_make_int8_t(2)))){
   goto L2;
  }
  T0 = ecl_car(v1decl);
  if (Null(ecl_gethash_safe(T0,ecl_cmp_symbol_value(cl_env_copy,VV[19]),ECL_NIL))){
   goto L2;
  }
  {
   cl_object v3name;
   int8_t v4value;
   cl_object v5old_policy;
   cl_object v6new_policy;
   v3name = ecl_car(v1decl);
   T0 = ecl_cdr(v1decl);
   if (ecl_endp(T0)) {
    goto L10;
   }
   if (Null(ecl_cadr(v1decl))){
    goto L8;
   }
   goto L9;
L10:;
L9:;
   if (Null((cl_env_copy->function=ecl_fdefinition(VV[20]))->cfun.entry(1, v3name) /*  STANDARD-OPTIMIZATION-QUALITY-P */)){
    goto L12;
   }
   v4value = 3;
   goto L7;
L12:;
   v4value = 1;
   goto L7;
L8:;
   v4value = 0;
L7:;
   v5old_policy = L3282cmp_env_policy(v2env);
   T0 = cl_list(2, v3name, ecl_make_int8_t(v4value));
   T1 = ecl_list1(T0);
   v6new_policy = (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(2, T1, v5old_policy) /*  COMPUTE-POLICY */;
   T0 = ecl_list1(v6new_policy);
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(3, VV[10], T0, v2env) /*  CMP-ENV-ADD-DECLARATION */;
   return value0;
  }
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for CMP-ENV-ALL-OPTIMIZATIONS                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3286cmp_env_all_optimizations(cl_narg narg, ...)
{
 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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[22]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2o;
   v2o = L3282cmp_env_policy(v1env);
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, v2o) /*  POLICY-TO-DEBUG-LEVEL */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[24]))->cfun.entry(1, v2o) /*  POLICY-TO-SAFETY-LEVEL */;
   T2 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(1, v2o) /*  POLICY-TO-SPACE-LEVEL */;
   T3 = (cl_env_copy->function=ecl_fdefinition(VV[26]))->cfun.entry(1, v2o) /*  POLICY-TO-SPEED-LEVEL */;
   value0 = cl_list(4, T0, T1, T2, T3);
   return value0;
  }
 }
}
/* function definition for CMP-ENV-OPTIMIZATION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3287cmp_env_optimization(cl_narg narg, cl_object v1property, ...)
{
 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[28]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[28]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1property);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3o;
   v3o = L3282cmp_env_policy(v2env);
   if (!((v1property)==(ECL_SYM("DEBUG",272)))){
    goto L3;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, v3o) /*  POLICY-TO-DEBUG-LEVEL */;
   return value0;
L3:;
   if (!((v1property)==(ECL_SYM("SAFETY",737)))){
    goto L5;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[24]))->cfun.entry(1, v3o) /*  POLICY-TO-SAFETY-LEVEL */;
   return value0;
L5:;
   if (!((v1property)==(ECL_SYM("SPACE",791)))){
    goto L7;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(1, v3o) /*  POLICY-TO-SPACE-LEVEL */;
   return value0;
L7:;
   if (!((v1property)==(ECL_SYM("SPEED",794)))){
    goto L9;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[26]))->cfun.entry(1, v3o) /*  POLICY-TO-SPEED-LEVEL */;
   return value0;
L9:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for SAFE-COMPILE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3288safe_compile()
{
 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 = L3287cmp_env_optimization(1, ECL_SYM("SAFETY",737));
 value0 = ecl_make_bool(ecl_greatereq(T0,ecl_make_int8_t(2)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3288safe_compile_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[30]);
 {
  return L3288safe_compile();
 }
}
/* function definition for COMPILER-PUSH-EVENTS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3289compiler_push_events()
{
 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 = L3287cmp_env_optimization(1, ECL_SYM("SAFETY",737));
 value0 = ecl_make_bool(ecl_greatereq(T0,ecl_make_int8_t(3)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3289compiler_push_events_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[32]);
 {
  return L3289compiler_push_events();
 }
}
/* function definition for POLICY-ASSUME-NO-ERRORS                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3290policy_assume_no_errors(cl_narg narg, ...)
{
 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[34]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(2097152));
   return value0;
  }
 }
}
/* function definition for POLICY-ASSUME-RIGHT-TYPE                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3291policy_assume_right_type(cl_narg narg, ...)
{
 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[36]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L3290policy_assume_no_errors(1, v1env);
  return value0;
 }
}
/* function definition for POLICY-TYPE-ASSERTIONS                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3292policy_type_assertions(cl_narg narg, ...)
{
 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]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = L3290policy_assume_no_errors(1, v1env);
  value0 = Null(T0)?ECL_T:ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for POLICY-CHECK-STACK-OVERFLOW                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3293policy_check_stack_overflow(cl_narg narg, ...)
{
 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]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(4194304));
   return value0;
  }
 }
}
/* function definition for POLICY-CHECK-ARGUMENTS-TYPE                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3294policy_check_arguments_type(cl_narg narg, ...)
{
 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[42]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(8388608));
   return value0;
  }
 }
}
/* function definition for POLICY-ARRAY-BOUNDS-CHECK                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3295policy_array_bounds_check(cl_narg narg, ...)
{
 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[44]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(16777216));
   return value0;
  }
 }
}
/* function definition for POLICY-GLOBAL-VAR-CHECKING                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3296policy_global_var_checking(cl_narg narg, ...)
{
 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[46]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(33554432));
   return value0;
  }
 }
}
/* function definition for POLICY-GLOBAL-FUNCTION-CHECKING                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3297policy_global_function_checking(cl_narg narg, ...)
{
 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]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(67108864));
   return value0;
  }
 }
}
/* function definition for POLICY-CHECK-NARGS                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3298policy_check_nargs(cl_narg narg, ...)
{
 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[50]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(134217728));
   return value0;
  }
 }
}
/* function definition for POLICY-THE-IS-CHECKED                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3299policy_the_is_checked(cl_narg narg, ...)
{
 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[52]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(268435456));
   return value0;
  }
 }
}
/* function definition for POLICY-ASSUME-TYPES-DONT-CHANGE                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3300policy_assume_types_dont_change(cl_narg narg, ...)
{
 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[54]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(536870912));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-SLOT-ACCESS                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3301policy_inline_slot_access(cl_narg narg, ...)
{
 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[56]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(1073741824));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-ACCESSORS                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3302policy_inline_accessors(cl_narg narg, ...)
{
 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[58]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(2147483648));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-BIT-OPERATIONS                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3303policy_inline_bit_operations(cl_narg narg, ...)
{
 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[60]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(4294967296));
   return value0;
  }
 }
}
/* function definition for POLICY-OPEN-CODE-AREF/ASET                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3304policy_open_code_aref_aset(cl_narg narg, ...)
{
 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[62]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L3302policy_inline_accessors(1, v1env);
  return value0;
 }
}
/* function definition for POLICY-EVALUATE-FORMS                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3305policy_evaluate_forms(cl_narg narg, ...)
{
 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[64]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(8589934592));
   return value0;
  }
 }
}
/* function definition for POLICY-USE-DIRECT-C-CALL                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3306policy_use_direct_c_call(cl_narg narg, ...)
{
 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]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(17179869184));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-TYPE-CHECKS                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3307policy_inline_type_checks(cl_narg narg, ...)
{
 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]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(34359738368));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-SEQUENCE-FUNCTIONS                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3308policy_inline_sequence_functions(cl_narg narg, ...)
{
 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[70]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(68719476736));
   return value0;
  }
 }
}
/* function definition for POLICY-INLINE-NARGS-CHECK                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3309policy_inline_nargs_check(cl_narg narg, ...)
{
 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[72]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(137438953472));
   return value0;
  }
 }
}
/* function definition for POLICY-DEBUG-VARIABLE-BINDINGS                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3310policy_debug_variable_bindings(cl_narg narg, ...)
{
 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[74]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   if (Null(cl_logtest(v2bits, ecl_make_fixnum(274877906944)))){
    goto L4;
   }
   value0 = L3311policy_debug_ihs_frame(1, v1env);
   return value0;
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for POLICY-DEBUG-IHS-FRAME                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3311policy_debug_ihs_frame(cl_narg narg, ...)
{
 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[75]);
 {
  cl_object v1env;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1env = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   } else {
    i++;
    v1env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2bits;
   v2bits = L3282cmp_env_policy(v1env);
   value0 = cl_logtest(v2bits, ecl_make_fixnum(549755813888));
   return value0;
  }
 }
}
#include "cmp/cmpenv-optimize.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclXzYDHfioD7fj9_N4Q0M881(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-OPTIMIZE.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXzYDHfioD7fj9_N4Q0M881@";
 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[78]);                          /*  DEFAULT-POLICY          */
  ecl_cmp_defun(VV[79]);                          /*  CMP-ENV-POLICY          */
  ecl_cmp_defun(VV[80]);                          /*  ADD-DEFAULT-OPTIMIZATIONS */
  ecl_cmp_defun(VV[81]);                          /*  CMP-ENV-ADD-OPTIMIZATIONS */
  ecl_cmp_defun(VV[82]);                          /*  MAYBE-ADD-POLICY        */
  ecl_cmp_defun(VV[83]);                          /*  CMP-ENV-ALL-OPTIMIZATIONS */
  ecl_cmp_defun(VV[84]);                          /*  CMP-ENV-OPTIMIZATION    */
  ecl_cmp_defun(VV[85]);                          /*  SAFE-COMPILE            */
  ecl_cmp_defun(VV[86]);                          /*  COMPILER-PUSH-EVENTS    */
  ecl_cmp_defun(VV[87]);                          /*  POLICY-ASSUME-NO-ERRORS */
  ecl_cmp_defun(VV[88]);                          /*  POLICY-ASSUME-RIGHT-TYPE */
  ecl_cmp_defun(VV[89]);                          /*  POLICY-TYPE-ASSERTIONS  */
  ecl_cmp_defun(VV[90]);                          /*  POLICY-CHECK-STACK-OVERFLOW */
  ecl_cmp_defun(VV[91]);                          /*  POLICY-CHECK-ARGUMENTS-TYPE */
  ecl_cmp_defun(VV[92]);                          /*  POLICY-ARRAY-BOUNDS-CHECK */
  ecl_cmp_defun(VV[93]);                          /*  POLICY-GLOBAL-VAR-CHECKING */
  ecl_cmp_defun(VV[94]);                          /*  POLICY-GLOBAL-FUNCTION-CHECKING */
  ecl_cmp_defun(VV[95]);                          /*  POLICY-CHECK-NARGS      */
  ecl_cmp_defun(VV[96]);                          /*  POLICY-THE-IS-CHECKED   */
  ecl_cmp_defun(VV[97]);                          /*  POLICY-ASSUME-TYPES-DONT-CHANGE */
  ecl_cmp_defun(VV[98]);                          /*  POLICY-INLINE-SLOT-ACCESS */
  ecl_cmp_defun(VV[99]);                          /*  POLICY-INLINE-ACCESSORS */
  ecl_cmp_defun(VV[100]);                         /*  POLICY-INLINE-BIT-OPERATIONS */
  ecl_cmp_defun(VV[101]);                         /*  POLICY-OPEN-CODE-AREF/ASET */
  ecl_cmp_defun(VV[102]);                         /*  POLICY-EVALUATE-FORMS   */
  ecl_cmp_defun(VV[103]);                         /*  POLICY-USE-DIRECT-C-CALL */
  ecl_cmp_defun(VV[104]);                         /*  POLICY-INLINE-TYPE-CHECKS */
  ecl_cmp_defun(VV[105]);                         /*  POLICY-INLINE-SEQUENCE-FUNCTIONS */
  ecl_cmp_defun(VV[106]);                         /*  POLICY-INLINE-NARGS-CHECK */
  ecl_cmp_defun(VV[107]);                         /*  POLICY-DEBUG-VARIABLE-BINDINGS */
  ecl_cmp_defun(VV[108]);                         /*  POLICY-DEBUG-IHS-FRAME  */
}
