/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpcond.lsp                     */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpcond.eclh"
/* function definition for COMPILER-MESSAGE-REPORT                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3042compiler_message_report(cl_narg narg, cl_object v1stream, cl_object v2c, cl_object v3format_control, ...)
{
 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<3)) FEwrong_num_arguments(VV[4]);
 {
  cl_object v4format_arguments;
  ecl_va_list args; ecl_va_start(args,v3format_control,narg,3);
  v4format_arguments = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   cl_object v8;
   v5 = (cl_env_copy->function=ecl_fdefinition(VV[5]))->cfun.entry(1, v2c) /*  COMPILER-MESSAGE-FILE-POSITION */;
   v6 = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, v2c) /*  COMPILER-MESSAGE-PREFIX */;
   v7 = (cl_env_copy->function=ecl_fdefinition(VV[7]))->cfun.entry(1, v2c) /*  COMPILER-MESSAGE-FILE */;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2c) /*  COMPILER-MESSAGE-TOPLEVEL-FORM */;
   v8 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, T0) /*  INNERMOST-NON-EXPANDED-FORM */;
   if (Null(v8)){
    goto L6;
   }
   if (Null(v5)){
    goto L6;
   }
   if (ecl_minusp(v5)) {
    goto L6;
   }
   if (ecl_equalp(v8,VV[10])) {
    goto L6;
   }
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(2)); /*  *PRINT-LENGTH* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
   T0 = cl_pathname_name(1, v7);
   T1 = cl_pathname_type(1, v7);
   T2 = cl_pathname_version(v7);
   T3 = cl_make_pathname(6, ECL_SYM("NAME",1309), T0, ECL_SYM("TYPE",1356), T1, ECL_SYM("VERSION",1364), T2);
   cl_format(6, v1stream, VV[11], v6, T3, v5, v8);
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   goto L5;
L6:;
   cl_format(3, v1stream, VV[12], v6);
L5:;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v2c) /*  COMPILER-MESSAGE-FORMAT */;
   value0 = cl_format(4, v1stream, T0, v3format_control, v4format_arguments);
   return value0;
  }
 }
}
/* local function LAMBDA5                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3044__lambda5()
{
 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 v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC3043__lambda7_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3044__lambda5_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[16]);
 {
  return LC3044__lambda5();
 }
}
/* local function LAMBDA9                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3045__lambda9()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3045__lambda9_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[18]);
 {
  return LC3045__lambda9();
 }
}
/* local function LAMBDA11                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3046__lambda11()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[20]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3046__lambda11_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[19]);
 {
  return LC3046__lambda11();
 }
}
/* local function LAMBDA13                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3047__lambda13()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[22]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3047__lambda13_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[21]);
 {
  return LC3047__lambda13();
 }
}
/* local function LAMBDA15                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3048__lambda15()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[24]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3048__lambda15_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
  return LC3048__lambda15();
 }
}
/* local function LAMBDA17                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3050__lambda17()
{
 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 v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC3049__lambda19_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3050__lambda17_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[34]);
 {
  return LC3050__lambda17();
 }
}
/* local function LAMBDA21                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3052__lambda21()
{
 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 v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC3051__lambda23_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3052__lambda21_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[38]);
 {
  return LC3052__lambda21();
 }
}
/* local function LAMBDA25                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3054__lambda25()
{
 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 v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC3053__lambda27_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3054__lambda25_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[43]);
 {
  return LC3054__lambda25();
 }
}
/* function definition for PRINT-COMPILER-MESSAGE                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3055print_compiler_message(cl_object v1c, cl_object v2stream)
{
 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 (cl_typep(2, v1c, ecl_cmp_symbol_value(cl_env_copy,VV[57]))!=ECL_NIL) {
  goto L2;
 }
 value0 = cl_format(3, v2stream, VV[58], v1c);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3055print_compiler_message_va(cl_narg narg, cl_object v3c, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[56]);
 {
  return L3055print_compiler_message(v3c, v4stream);
 }
}
/* function definition for HANDLE-COMPILER-NOTE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3056handle_compiler_note(cl_object v1c)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3056handle_compiler_note_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[60]);
 {
  return L3056handle_compiler_note(v2c);
 }
}
/* function definition for HANDLE-COMPILER-WARNING                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3057handle_compiler_warning(cl_object v1c)
{
 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(v1c,ecl_cmp_symbol_value(cl_env_copy,VV[63]));
 ecl_cmp_setq(cl_env_copy,VV[63],T0);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3057handle_compiler_warning_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[62]);
 {
  return L3057handle_compiler_warning(v2c);
 }
}
/* function definition for HANDLE-COMPILER-ERROR                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3058handle_compiler_error(cl_object v1c)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[66]))){
  goto L2;
 }
 (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v1c) /*  INVOKE-DEBUGGER */;
L2:;
 (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIGNAL */;
 T0 = CONS(v1c,ecl_cmp_symbol_value(cl_env_copy,VV[63]));
 ecl_cmp_setq(cl_env_copy,VV[63],T0);
 L3055print_compiler_message(v1c, ECL_T);
 value0 = cl_abort(0);
 return value0;
}
static cl_object L3058handle_compiler_error_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[65]);
 {
  return L3058handle_compiler_error(v2c);
 }
}
/* function definition for HANDLE-COMPILER-INTERNAL-ERROR                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3059handle_compiler_internal_error(cl_object v1c)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[66]))){
  goto L2;
 }
 (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v1c) /*  INVOKE-DEBUGGER */;
L2:;
 T0 = ecl_list1(v1c);
 v1c = cl_make_condition(5, VV[31], ECL_SYM("FORMAT-CONTROL",1272), VV[69], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
 T0 = CONS(v1c,ecl_cmp_symbol_value(cl_env_copy,VV[63]));
 ecl_cmp_setq(cl_env_copy,VV[63],T0);
 (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIGNAL */;
 L3055print_compiler_message(v1c, ECL_T);
 value0 = cl_abort(0);
 return value0;
}
static cl_object L3059handle_compiler_internal_error_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[68]);
 {
  return L3059handle_compiler_internal_error(v2c);
 }
}
/* local function CMPCK                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3060cmpck(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4condition;
  cl_object v5string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4condition = v6;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5string = v6;
  }
  T0 = cl_listX(3, VV[73], v5string, v3);
  value0 = cl_list(3, ECL_SYM("IF",950), v4condition, T0);
  return value0;
 }
}
static cl_object LC3060cmpck_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[72]);
 {
  return LC3060cmpck(v6, v7);
 }
}
/* local function CMPASSERT                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3061cmpassert(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4condition;
  cl_object v5string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4condition = v6;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5string = v6;
  }
  T0 = cl_listX(3, VV[73], v5string, v3);
  value0 = cl_list(3, ECL_SYM("UNLESS",886), v4condition, T0);
  return value0;
 }
}
static cl_object LC3061cmpassert_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[75]);
 {
  return LC3061cmpassert(v6, v7);
 }
}
/* function definition for CMPERR                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3062cmperr(cl_narg narg, cl_object v1string, ...)
{
 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[73]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3c;
   v3c = cl_make_condition(5, VV[29], ECL_SYM("FORMAT-CONTROL",1272), v1string, ECL_SYM("FORMAT-ARGUMENTS",1271), v2args);
   (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(1, v3c) /*  SIGNAL */;
   L3055print_compiler_message(v3c, ECL_T);
   value0 = cl_abort(0);
   return value0;
  }
 }
}
/* function definition for TOO-MANY-ARGS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3063too_many_args(cl_object v1name, cl_object v2upper_bound, cl_object v3n)
{
 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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CASE*",48),ECL_SYM("UPCASE",1360)); /*  *PRINT-CASE* */
 value0 = L3062cmperr(4, VV[79], v1name, v2upper_bound, v3n);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3063too_many_args_va(cl_narg narg, cl_object v4name, cl_object v5upper_bound, cl_object v6n, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[78]);
 {
  return L3063too_many_args(v4name, v5upper_bound, v6n);
 }
}
/* function definition for TOO-FEW-ARGS                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3064too_few_args(cl_object v1name, cl_object v2lower_bound, cl_object v3n)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L3062cmperr(4, VV[82], v1name, v2lower_bound, v3n);
 return value0;
}
static cl_object L3064too_few_args_va(cl_narg narg, cl_object v4name, cl_object v5lower_bound, cl_object v6n, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[81]);
 {
  return L3064too_few_args(v4name, v5lower_bound, v6n);
 }
}
/* function definition for DO-CMPWARN                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3067do_cmpwarn(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object volatile v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   volatile cl_object v2condition;
   T0 = (ECL_SYM("MAKE-CONDITION",526)->symbol.gfdef);
   v2condition = cl_apply(2, T0, v1args);
   {
    volatile cl_object env1 = env0;
    env1 = ECL_NIL;
    CLV0 = env1 = CONS(ECL_NIL,env1);
    {
     volatile cl_object env2 = env1;
     CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY      */
     {
      ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
      if (__ecl_frs_push_result!=0) {
      if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
       goto L4;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v3;
       v3 = ecl_make_cclosure_va((cl_objectfn)LC3065__lambda78,env2,Cblock,0);
       T0 = v3;
      }
      {
       cl_object v3;
       v3 = ecl_make_cfun_va((cl_objectfn)LC3066__lambda80_va,ECL_NIL,Cblock,1);
       T1 = v3;
      }
      T2 = (cl_env_copy->function=(VV[86]->symbol.gfdef))->cfun.entry(6, ECL_SYM("NAME",1309), ECL_SYM("MUFFLE-WARNING",573), ECL_SYM("FUNCTION",1273), T0, VV[88], T1) /*  MAKE-RESTART */;
      T3 = ecl_list1(T2);
      T4 = CONS(T3,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
      ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T4); /*  *RESTART-CLUSTERS* */
      {
       cl_object v3;
       T0 = ECL_NIL;
       v3 = (cl_env_copy->function=(VV[91]->symbol.gfdef))->cfun.entry(4, v2condition, T0, ECL_SYM("SIMPLE-CONDITION",770), ECL_SYM("SIGNAL",763)) /*  COERCE-TO-CONDITION */;
       T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
       T1 = CONS(v3,T0);
       T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[92]));
       ecl_bds_bind(cl_env_copy,VV[92],T2);       /*  *CONDITION-RESTARTS*    */
       (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(1, v3) /*  SIGNAL */;
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       goto L3;
      }
L4:;
      {
       cl_object v3;
       v3 = ECL_CONS_CAR(CLV0);
       if (Null(v3)){
        goto L11;
       }
       si_dm_too_many_arguments(ECL_NIL);
L11:;
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_frs_pop_n(cl_env_copy, 1);
       return value0;
      }
      }
     }
    }
   }
L3:;
   value0 = L3055print_compiler_message(v2condition, ECL_T);
   return value0;
  }
 }
}
/* function definition for CMPWARN-STYLE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3068cmpwarn_style(cl_narg narg, cl_object v1string, ...)
{
 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[94]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = L3067do_cmpwarn(5, VV[32], ECL_SYM("FORMAT-CONTROL",1272), v1string, ECL_SYM("FORMAT-ARGUMENTS",1271), v2args);
  return value0;
 }
}
/* function definition for CMPWARN                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3069cmpwarn(cl_narg narg, cl_object v1string, ...)
{
 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[96]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = L3067do_cmpwarn(5, VV[27], ECL_SYM("FORMAT-CONTROL",1272), v1string, ECL_SYM("FORMAT-ARGUMENTS",1271), v2args);
  return value0;
 }
}
/* function definition for CMPNOTE                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3070cmpnote(cl_narg narg, cl_object v1string, ...)
{
 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[98]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = L3067do_cmpwarn(5, VV[25], ECL_SYM("FORMAT-CONTROL",1272), v1string, ECL_SYM("FORMAT-ARGUMENTS",1271), v2args);
  return value0;
 }
}
/* function definition for CMPDEBUG                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3071cmpdebug(cl_narg narg, cl_object v1string, ...)
{
 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[100]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = L3067do_cmpwarn(5, VV[26], ECL_SYM("FORMAT-CONTROL",1272), v1string, ECL_SYM("FORMAT-ARGUMENTS",1271), v2args);
  return value0;
 }
}
/* function definition for UNDEFINED-VARIABLE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3072undefined_variable(cl_object v1sym)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L3067do_cmpwarn(3, VV[33], ECL_SYM("NAME",1309), v1sym);
 return value0;
}
static cl_object L3072undefined_variable_va(cl_narg narg, cl_object v2sym, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[102]);
 {
  return L3072undefined_variable(v2sym);
 }
}
/* function definition for WARN-DEAD-CODE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3073warn_dead_code(cl_narg narg, cl_object v1dead_forms, cl_object v2context, cl_object v3explanation, ...)
{
 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<3)) FEwrong_num_arguments(VV[104]);
 {
  cl_object v4explanation_args;
  ecl_va_list args; ecl_va_start(args,v3explanation,narg,3);
  v4explanation_args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (!(ECL_LISTP(v1dead_forms))){
   goto L2;
  }
  T0 = v1dead_forms;
  goto L1;
L2:;
  T0 = ecl_list1(v1dead_forms);
L1:;
  value0 = L3067do_cmpwarn(9, VV[42], VV[105], T0, VV[106], v2context, VV[107], v3explanation, VV[108], v4explanation_args);
  return value0;
 }
}
/* function definition for BABOON                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3074baboon(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);
 {
  cl_object v1format_control;
  cl_object v2format_arguments;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L3074baboonkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[2])) {
    v1format_control = VV[110];
   } else {
    v1format_control = keyvars[0];
   }
   v2format_arguments = keyvars[1];
  }
  value0 = (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(5, VV[31], ECL_SYM("FORMAT-CONTROL",1272), v1format_control, ECL_SYM("FORMAT-ARGUMENTS",1271), v2format_arguments) /*  SIGNAL */;
  return value0;
 }
}
/* local function WITH-CMP-PROTECTION                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3075with_cmp_protection(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4main_form;
  cl_object v5error_form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4main_form = v6;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5error_form = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  T0 = cl_list(3, ECL_SYM("HANDLER-BIND",419), VV[115], v4main_form);
  T1 = cl_list(4, ECL_SYM("IF",950), VV[66], T0, v4main_form);
  T2 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), T1, VV[116]);
  T3 = cl_list(3, ECL_SYM("WHEN",909), VV[117], v5error_form);
  T4 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T2, T3);
  value0 = cl_list(3, ECL_SYM("LET*",480), VV[114], T4);
  return value0;
 }
}
static cl_object LC3075with_cmp_protection_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[113]);
 {
  return LC3075with_cmp_protection(v6, v7);
 }
}
/* local function LAMBDA7                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3043__lambda7(cl_object v1c, cl_object v2stream)
{
 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:;
 T0 = ecl_fdefinition(VV[4]);
 T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
 T2 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
 value0 = cl_apply(5, T0, v2stream, v1c, T1, T2);
 return value0;
}
static cl_object LC3043__lambda7_va(cl_narg narg, cl_object v3c, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[17]);
 {
  return LC3043__lambda7(v3c, v4stream);
 }
}
/* local function LAMBDA19                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3049__lambda19(cl_object v1c, cl_object v2stream)
{
 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_slot_value(v1c, ECL_SYM("VARIABLE",901));
 value0 = L3042compiler_message_report(4, v2stream, v1c, VV[36], T0);
 return value0;
}
static cl_object LC3049__lambda19_va(cl_narg narg, cl_object v3c, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[35]);
 {
  return LC3049__lambda19(v3c, v4stream);
 }
}
/* local function LAMBDA23                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3051__lambda23(cl_object v1c, cl_object v2stream)
{
 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[41]))->cfun.entry(1, v1c) /*  COMPILER-MESSAGE-FORM */;
 value0 = L3042compiler_message_report(4, v2stream, v1c, VV[40], T0);
 return value0;
}
static cl_object LC3051__lambda23_va(cl_narg narg, cl_object v3c, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[39]);
 {
  return LC3051__lambda23(v3c, v4stream);
 }
}
/* local function LAMBDA27                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3053__lambda27(cl_object v1c, cl_object v2stream)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3dead_forms;
  v3dead_forms = cl_slot_value(v1c, VV[45]);
  {
   cl_fixnum v4;
   v4 = ecl_length(v3dead_forms);
   {
    cl_object v5;
    v5 = ecl_fdefinition(VV[47]);
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     {
      cl_object v9;
      v9 = v3dead_forms;
      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;
L12:;
      if (!(ecl_endp(v8))){
       goto L14;
      }
      goto L13;
L14:;
      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;
       T1 = v11;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
      v10 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v10,T1);
      goto L12;
L13:;
      T0 = ecl_cdr(v9);
      goto L3;
     }
    }
   }
L3:;
   T1 = cl_slot_value(v1c, VV[53]);
   T2 = (cl_env_copy->function=ecl_fdefinition(VV[47]))->cfun.entry(1, T1) /*  C1FORM-FORM */;
   T3 = cl_slot_value(v1c, VV[54]);
   {
    cl_object v5;
    v5 = ecl_fdefinition(VV[47]);
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     {
      cl_object v9;
      v9 = cl_slot_value(v1c, VV[55]);
      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;
L39:;
      if (!(ecl_endp(v8))){
       goto L41;
      }
      goto L40;
L41:;
      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;
       T5 = v11;
      }
      T6 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
      v10 = ecl_list1(T6);
      (ECL_CONS_CDR(T5)=v10,T5);
      goto L39;
L40:;
      T4 = ecl_cdr(v9);
      goto L30;
     }
    }
   }
L30:;
   value0 = L3042compiler_message_report(8, v2stream, v1c, VV[46], ecl_make_fixnum(v4), T0, T2, T3, T4);
   return value0;
  }
 }
}
static cl_object LC3053__lambda27_va(cl_narg narg, cl_object v4c, cl_object v5stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[44]);
 {
  return LC3053__lambda27(v4c, v5stream);
 }
}
/* closure LAMBDA78                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3065__lambda78(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1si__temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1si__temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA80                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3066__lambda80(cl_object v1stream)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_write_string(2, VV[90], v1stream);
 return value0;
}
static cl_object LC3066__lambda80_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[89]);
 {
  return LC3066__lambda80(v2stream);
 }
}
#include "cmp/cmpcond.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclUx8ykYaHNXGr9_0fM0M881(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;CMPCOND.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclUx8ykYaHNXGr9_0fM0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(_ecl_static_0);
  si_Xmake_constant(VV[0], VVtemp[0]);
  si_Xmake_constant(VV[1], VVtemp[1]);
  si_Xmake_constant(VV[2], VVtemp[2]);
  si_Xmake_constant(VV[3], VVtemp[3]);
  ecl_cmp_defun(VV[119]);                         /*  COMPILER-MESSAGE-REPORT */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3044__lambda5_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[5]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3045__lambda9_va,ECL_NIL,Cblock,0);
   T2 = v1;
  }
  T3 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T2, VVtemp[8]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3046__lambda11_va,ECL_NIL,Cblock,0);
   T4 = v1;
  }
  T5 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T4, VVtemp[9]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3047__lambda13_va,ECL_NIL,Cblock,0);
   T6 = v1;
  }
  T7 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T6, VVtemp[10]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3048__lambda15_va,ECL_NIL,Cblock,0);
   T8 = v1;
  }
  T9 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T8, VVtemp[11]);
  T10 = cl_list(7, T1, VVtemp[6], VVtemp[7], T3, T5, T7, T9);
  clos_load_defclass(VV[15], VVtemp[4], T10, ECL_NIL);
  clos_load_defclass(VV[25], VVtemp[12], ECL_NIL, ECL_NIL);
  clos_load_defclass(VV[26], VVtemp[13], ECL_NIL, ECL_NIL);
  clos_load_defclass(VV[27], VVtemp[14], VVtemp[15], ECL_NIL);
  clos_load_defclass(VV[28], VVtemp[16], ECL_NIL, ECL_NIL);
  clos_load_defclass(VV[29], VVtemp[12], VVtemp[17], ECL_NIL);
  clos_load_defclass(VV[30], VVtemp[18], VVtemp[19], ECL_NIL);
  clos_load_defclass(VV[31], VVtemp[20], VVtemp[21], ECL_NIL);
  clos_load_defclass(VV[32], VVtemp[14], VVtemp[22], ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3050__lambda17_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[24]);
  T2 = cl_list(2, T1, VVtemp[25]);
  clos_load_defclass(VV[33], VVtemp[23], T2, ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3052__lambda21_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[26]);
  T2 = ecl_list1(T1);
  clos_load_defclass(VV[37], VVtemp[18], T2, ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3054__lambda25_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[27]);
  T2 = cl_list(5, T1, VVtemp[28], VVtemp[29], VVtemp[30], VVtemp[31]);
  clos_load_defclass(VV[42], VVtemp[13], T2, ECL_NIL);
  ecl_cmp_defun(VV[120]);                         /*  PRINT-COMPILER-MESSAGE  */
  ecl_cmp_defun(VV[121]);                         /*  HANDLE-COMPILER-NOTE    */
  ecl_cmp_defun(VV[122]);                         /*  HANDLE-COMPILER-WARNING */
  ecl_cmp_defun(VV[123]);                         /*  HANDLE-COMPILER-ERROR   */
  ecl_cmp_defun(VV[124]);                         /*  HANDLE-COMPILER-INTERNAL-ERROR */
  ecl_cmp_defmacro(VV[125]);                      /*  CMPCK                   */
  ecl_cmp_defmacro(VV[126]);                      /*  CMPASSERT               */
  ecl_cmp_defun(VV[127]);                         /*  CMPERR                  */
  ecl_cmp_defun(VV[128]);                         /*  TOO-MANY-ARGS           */
  ecl_cmp_defun(VV[129]);                         /*  TOO-FEW-ARGS            */
  (void)0; /* No entry created for DO-CMPWARN */
  ecl_cmp_defun(VV[130]);                         /*  CMPWARN-STYLE           */
  ecl_cmp_defun(VV[131]);                         /*  CMPWARN                 */
  ecl_cmp_defun(VV[132]);                         /*  CMPNOTE                 */
  ecl_cmp_defun(VV[133]);                         /*  CMPDEBUG                */
  ecl_cmp_defun(VV[134]);                         /*  UNDEFINED-VARIABLE      */
  ecl_cmp_defun(VV[135]);                         /*  WARN-DEAD-CODE          */
  ecl_cmp_defun(VV[136]);                         /*  BABOON                  */
  ecl_cmp_defmacro(VV[137]);                      /*  WITH-CMP-PROTECTION     */
 }
}
