/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/evalmacros.lsp                  */
#include <ecl/ecl-cmp.h>
#include "lsp/evalmacros.eclh"
/* local function UNLESS                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC36unless(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4pred;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4pred = v5;
  }
  T0 = cl_list(2, ECL_SYM("NOT",586), v4pred);
  T1 = CONS(ECL_SYM("PROGN",674),v3);
  value0 = cl_list(3, ECL_SYM("IF",950), T0, T1);
  return value0;
 }
}
static cl_object LC36unless_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[1]);
 {
  return LC36unless(v5, v6);
 }
}
/* local function DEFMACRO                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC37defmacro(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 v4name;
  cl_object v5vl;
  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);
   v4name = 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);
   v5vl = v6;
  }
  {
   cl_object v6;                                  /*  FUNCTION                */
   cl_object v7;                                  /*  PPRINT                  */
   cl_object v8;                                  /*  DOC-STRING              */
   value0 = (cl_env_copy->function=(ECL_SYM("EXPAND-DEFMACRO",1077)->symbol.gfdef))->cfun.entry(3, v4name, v5vl, v3) /*  EXPAND-DEFMACRO */;
   {
    const int v9 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v7 = v10;
    v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
    v8 = v10;
   }
   v6 = cl_list(2, ECL_SYM("FUNCTION",398), v6);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[2]))){
    goto L18;
   }
   cl_print(1, v6);
   v6 = cl_list(2, ECL_SYM("BC-DISASSEMBLE",1049), v6);
L18:;
   if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
    goto L23;
   }
   T1 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
   T2 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
   T3 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T4 = cl_list(5, ECL_SYM("FSET",1090), T3, v6, ECL_T, v7);
   T0 = ecl_function_dispatch(cl_env_copy,T1)(3, T2, v1, T4);
   goto L22;
L23:;
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T0 = cl_list(5, ECL_SYM("FSET",1090), T1, v6, ECL_T, v7);
L22:;
   T1 = si_expand_set_documentation(v4name, ECL_SYM("FUNCTION",398), v8);
   T2 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T3 = ecl_list1(T2);
   T4 = ecl_append(T1,T3);
   value0 = cl_listX(4, ECL_SYM("EVAL-WHEN",342), VV[3], T0, T4);
   return value0;
  }
 }
}
static cl_object LC37defmacro_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[5]);
 {
  return LC37defmacro(v6, v7);
 }
}
/* local function DEFVAR                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC38defvar(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 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 v4var;
  cl_object v5form;
  cl_object v6form_sp;
  cl_object v7doc_string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4var = v8;
  }
  if (Null(v3)){
   goto L10;
  }
  v5form = ecl_car(v3);
  goto L9;
L10:;
  v5form = ECL_NIL;
L9:;
  if (Null(v3)){
   goto L14;
  }
  v3 = ecl_cdr(v3);
  v6form_sp = ECL_T;
  goto L12;
L14:;
  v6form_sp = ECL_NIL;
  goto L12;
L12:;
  if (Null(v3)){
   goto L19;
  }
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v7doc_string = v8;
   goto L18;
  }
L19:;
  v7doc_string = ECL_NIL;
L18:;
  if (Null(v3)){
   goto L24;
  }
  si_dm_too_many_arguments(v1);
L24:;
  T0 = cl_list(2, ECL_SYM("SPECIAL",792), v4var);
  T1 = cl_list(2, ECL_SYM("DECLARE",276), T0);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T3 = cl_list(2, ECL_SYM("*MAKE-SPECIAL",1031), T2);
  if (Null(v6form_sp)){
   goto L27;
  }
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T6 = cl_list(2, ECL_SYM("BOUNDP",159), T5);
  T7 = cl_list(3, ECL_SYM("SETQ",754), v4var, v5form);
  T8 = cl_list(3, ECL_SYM("UNLESS",886), T6, T7);
  T4 = ecl_list1(T8);
  goto L26;
L27:;
  T4 = ECL_NIL;
L26:;
  T5 = si_expand_set_documentation(v4var, ECL_SYM("VARIABLE",901), v7doc_string);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
   goto L30;
  }
  T7 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
  T8 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
  T6 = ecl_function_dispatch(cl_env_copy,T7)(3, T8, v1, ECL_NIL);
  goto L29;
L30:;
  T6 = ECL_NIL;
L29:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*BYTECODES-COMPILER*",1783)))){
   goto L34;
  }
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(2, ECL_SYM("*MAKE-SPECIAL",1031), T8);
  T7 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T9);
  goto L33;
L34:;
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(2, VV[8], T8);
  T7 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T9);
L33:;
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(3, T6, T7, T8);
  T10 = cl_append(3, T4, T5, T9);
  value0 = cl_listX(4, ECL_SYM("LOCALLY",492), T1, T3, T10);
  return value0;
 }
}
static cl_object LC38defvar_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[9]);
 {
  return LC38defvar(v8, v9);
 }
}
/* local function DEFPARAMETER                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC39defparameter(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 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 v4var;
  cl_object v5form;
  cl_object v6doc_string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4var = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5form = v7;
  }
  if (Null(v3)){
   goto L16;
  }
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6doc_string = v7;
   goto L15;
  }
L16:;
  v6doc_string = ECL_NIL;
L15:;
  if (Null(v3)){
   goto L21;
  }
  si_dm_too_many_arguments(v1);
L21:;
  T0 = cl_list(2, ECL_SYM("SPECIAL",792), v4var);
  T1 = cl_list(2, ECL_SYM("DECLARE",276), T0);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T3 = cl_list(2, ECL_SYM("*MAKE-SPECIAL",1031), T2);
  T4 = cl_list(3, ECL_SYM("SETQ",754), v4var, v5form);
  T5 = si_expand_set_documentation(v4var, ECL_SYM("VARIABLE",901), v6doc_string);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
   goto L24;
  }
  T7 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
  T8 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
  T6 = ecl_function_dispatch(cl_env_copy,T7)(3, T8, v1, ECL_NIL);
  goto L23;
L24:;
  T6 = ECL_NIL;
L23:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*BYTECODES-COMPILER*",1783)))){
   goto L28;
  }
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(2, ECL_SYM("*MAKE-SPECIAL",1031), T8);
  T7 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T9);
  goto L27;
L28:;
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(2, VV[8], T8);
  T7 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T9);
L27:;
  T8 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T9 = cl_list(3, T6, T7, T8);
  T10 = ecl_append(T5,T9);
  value0 = cl_listX(5, ECL_SYM("LOCALLY",492), T1, T3, T4, T10);
  return value0;
 }
}
static cl_object LC39defparameter_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[10]);
 {
  return LC39defparameter(v7, v8);
 }
}
/* local function DEFCONSTANT                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC40defconstant(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 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 v4var;
  cl_object v5form;
  cl_object v6doc_string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4var = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5form = v7;
  }
  if (Null(v3)){
   goto L16;
  }
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6doc_string = v7;
   goto L15;
  }
L16:;
  v6doc_string = ECL_NIL;
L15:;
  if (Null(v3)){
   goto L21;
  }
  si_dm_too_many_arguments(v1);
L21:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T1 = cl_list(3, ECL_SYM("*MAKE-CONSTANT",1030), T0, v5form);
  T2 = si_expand_set_documentation(v4var, ECL_SYM("VARIABLE",901), v6doc_string);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
   goto L24;
  }
  T4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
  T5 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
  T3 = ecl_function_dispatch(cl_env_copy,T4)(3, T5, v1, ECL_NIL);
  goto L23;
L24:;
  T3 = ECL_NIL;
L23:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*BYTECODES-COMPILER*",1783)))){
   goto L28;
  }
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T6 = cl_list(3, ECL_SYM("*MAKE-CONSTANT",1030), T5, v5form);
  T4 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T6);
  goto L27;
L28:;
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T6 = cl_list(3, ECL_SYM("*MAKE-CONSTANT",1030), T5, v5form);
  T7 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T8 = cl_list(2, VV[8], T7);
  T4 = cl_list(4, ECL_SYM("EVAL-WHEN",342), VV[7], T6, T8);
L27:;
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v4var);
  T6 = cl_list(3, T3, T4, T5);
  T7 = ecl_append(T2,T6);
  value0 = cl_listX(3, ECL_SYM("PROGN",674), T1, T7);
  return value0;
 }
}
static cl_object LC40defconstant_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[11]);
 {
  return LC40defconstant(v7, v8);
 }
}
/* local function LAMBDA46                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC41__lambda46(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:;
 {
  cl_object v3proclaimed;
  v3proclaimed = si_get_sysprop(v1fname, ECL_SYM("INLINE",436));
  if (Null(v3proclaimed)){
   goto L3;
  }
  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[15], T1);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[14], T2);
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC41__lambda46_va(cl_narg narg, cl_object v4fname, cl_object v5form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[13]);
 {
  return LC41__lambda46(v4fname, v5form);
 }
}
/* local function DEFUN                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC42defun(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  cl_object v4name;
  cl_object v5vl;
  cl_object v6body;
  cl_object v7doc_string;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4name = v8;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5vl = v8;
  }
  v6body = v3;
  v7doc_string = ECL_NIL;
  value0 = si_remove_documentation(v6body);
  {
   const int v8 = cl_env_copy->nvalues;
   v6body = value0;
   cl_object v9;
   v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
   v7doc_string = v9;
  }
  {
   cl_object v8function;
   cl_object v9global_function;
   T0 = cl_listX(4, ECL_SYM("LAMBDA-BLOCK",1377), v4name, v5vl, v6body);
   v8function = cl_list(2, ECL_SYM("FUNCTION",398), T0);
   T0 = cl_listX(5, ECL_SYM("LAMBDA-BLOCK",1377), v4name, v5vl, VV[17], v6body);
   v9global_function = cl_list(2, ECL_SYM("FUNCTION",398), T0);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[2]))){
    goto L21;
   }
   cl_print(1, v8function);
   v8function = cl_list(2, ECL_SYM("BC-DISASSEMBLE",1049), v8function);
L21:;
   if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
    goto L26;
   }
   T1 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
   T2 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
   T3 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T4 = cl_list(3, ECL_SYM("FSET",1090), T3, v9global_function);
   T0 = ecl_function_dispatch(cl_env_copy,T1)(3, T2, v1, T4);
   goto L25;
L26:;
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T0 = cl_list(3, ECL_SYM("FSET",1090), T1, v9global_function);
L25:;
   T1 = si_expand_set_documentation(v4name, ECL_SYM("FUNCTION",398), v7doc_string);
   {
    cl_object v10hook;
    v10hook = ecl_cmp_symbol_value(cl_env_copy,VV[12]);
    if (Null(v10hook)){
     goto L32;
    }
    T2 = ecl_function_dispatch(cl_env_copy,v10hook)(2, v4name, v9global_function);
    goto L29;
L32:;
    T2 = ECL_NIL;
    goto L29;
   }
L29:;
   T3 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T4 = cl_list(2, T2, T3);
   T5 = ecl_append(T1,T4);
   value0 = cl_listX(3, ECL_SYM("PROGN",674), T0, T5);
   return value0;
  }
 }
}
static cl_object LC42defun_va(cl_narg narg, cl_object v10, cl_object v11, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[18]);
 {
  return LC42defun(v10, v11);
 }
}
/* local function DEFINE-COMPILER-MACRO                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC43define_compiler_macro(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 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 v4name;
  cl_object v5vl;
  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);
   v4name = 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);
   v5vl = v6;
  }
  {
   cl_object v6;                                  /*  FUNCTION                */
   cl_object v7;                                  /*  DOC-STRING              */
   value0 = (cl_env_copy->function=(ECL_SYM("EXPAND-DEFMACRO",1077)->symbol.gfdef))->cfun.entry(4, v4name, v5vl, v3, ECL_SYM("DEFINE-COMPILER-MACRO",281)) /*  EXPAND-DEFMACRO */;
   {
    const int v8 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v9;
    v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v9;
   }
   v6 = cl_list(2, ECL_SYM("FUNCTION",398), v6);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[2]))){
    goto L18;
   }
   cl_print(1, v6);
   v6 = cl_list(2, ECL_SYM("BC-DISASSEMBLE",1049), v6);
L18:;
   if (ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*BYTECODES-COMPILER*",1783))!=ECL_NIL) {
    goto L23;
   }
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T2 = cl_list(3, VV[19], T1, v6);
   T0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T2);
   goto L22;
L23:;
   T0 = ECL_NIL;
L22:;
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T2 = cl_list(4, ECL_SYM("PUT-SYSPROP",1150), T1, VV[20], v6);
   T3 = si_expand_set_documentation(v4name, ECL_SYM("COMPILER-MACRO",240), v7);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
    goto L26;
   }
   T5 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
   T6 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
   T4 = ecl_function_dispatch(cl_env_copy,T5)(3, T6, v1, ECL_NIL);
   goto L25;
L26:;
   T4 = ECL_NIL;
L25:;
   T5 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T6 = cl_list(2, T4, T5);
   T7 = ecl_append(T3,T6);
   value0 = cl_listX(4, ECL_SYM("PROGN",674), T0, T2, T7);
   return value0;
  }
 }
}
static cl_object LC43define_compiler_macro_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[21]);
 {
  return LC43define_compiler_macro(v6, v7);
 }
}
/* function definition for COMPILER-MACRO-FUNCTION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L44compiler_macro_function(cl_narg narg, cl_object v1name, ...)
{
 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]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[22]);
 {
  cl_object v2env;
  va_list args; va_start(args,v1name);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ECL_NIL;
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = si_get_sysprop(v1name, ECL_SYM("COMPILER-MACRO",240));
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function LOOP                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC45loop(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  cl_object v4tag;
  v3 = ecl_cdr(v1);
  v4tag = cl_gensym(0);
  T0 = CONS(ECL_SYM("PROGN",674),v3);
  T1 = cl_list(2, ECL_SYM("GO",416), v4tag);
  T2 = cl_list(4, ECL_SYM("TAGBODY",853), v4tag, T0, T1);
  value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T2);
  return value0;
 }
}
static cl_object LC45loop_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("LOOP",514));
 {
  return LC45loop(v5, v6);
 }
}
/* local function LAMBDA                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC46lambda(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;
  v3 = ecl_cdr(v1);
  T0 = CONS(ECL_SYM("LAMBDA",454),v3);
  value0 = cl_list(2, ECL_SYM("FUNCTION",398), T0);
  return value0;
 }
}
static cl_object LC46lambda_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[23]);
 {
  return LC46lambda(v4, v5);
 }
}
/* local function LAMBDA-BLOCK                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC47lambda_block(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 v4name;
  cl_object v5lambda_list;
  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);
   v4name = 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);
   v5lambda_list = v6;
  }
  {
   cl_object v6;                                  /*  DECL                    */
   cl_object v7;                                  /*  BODY                    */
   cl_object v8;                                  /*  DOC                     */
   value0 = si_process_declarations(1, v3);
   {
    const int v9 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v7 = v10;
    v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
    v8 = v10;
   }
   {
    cl_object v9;
    cl_object v10;
    if (Null(v6)){
     goto L18;
    }
    T0 = CONS(ECL_SYM("DECLARE",276),v6);
    v9 = ecl_list1(T0);
    goto L16;
L18:;
    v9 = ECL_NIL;
    goto L16;
L16:;
    v10 = si_function_block_name(v4name);
    T0 = cl_list(2, ECL_SYM("FUNCTION-BLOCK-NAME",1091), v10);
    T1 = cl_list(2, ECL_SYM("DECLARE",276), T0);
    T2 = cl_listX(3, ECL_SYM("BLOCK",139), v10, v7);
    T3 = cl_list(2, T1, T2);
    T4 = cl_append(3, v8, v9, T3);
    value0 = cl_listX(3, ECL_SYM("LAMBDA",454), v5lambda_list, T4);
    return value0;
   }
  }
 }
}
static cl_object LC47lambda_block_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[24]);
 {
  return LC47lambda_block(v6, v7);
 }
}
/* local function PSETQ                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC48psetq(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  {
   cl_object v4l;
   cl_object v5forms;
   cl_object v6bindings;
   v4l = v3;
   v5forms = ECL_NIL;
   v6bindings = ECL_NIL;
   goto L8;
L7:;
   {
    cl_object v7sym;
    v7sym = cl_gensym(0);
    T0 = ecl_cadr(v4l);
    T1 = cl_list(2, v7sym, T0);
    v6bindings = CONS(T1,v6bindings);
    T0 = ecl_car(v4l);
    T1 = cl_list(3, ECL_SYM("SETQ",754), T0, v7sym);
    v5forms = CONS(T1,v5forms);
   }
   v4l = ecl_cddr(v4l);
L8:;
   if (ecl_endp(v4l)) {
    goto L17;
   }
   goto L7;
L17:;
   T0 = cl_nreverse(v6bindings);
   T1 = CONS(ECL_NIL,v5forms);
   T2 = cl_nreverse(T1);
   value0 = cl_listX(3, ECL_SYM("LET*",480), T0, T2);
   return value0;
  }
 }
}
static cl_object LC48psetq_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[25]);
 {
  return LC48psetq(v7, v8);
 }
}
/* local function COND                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC49cond(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4form;
  v3 = ecl_cdr(v1);
  v4form = ECL_NIL;
  {
   cl_object v5;
   v5 = cl_reverse(v3);
   goto L7;
L6:;
   {
    cl_object v6l;
    v6l = ecl_car(v5);
    T0 = ecl_cdr(v6l);
    if (!(ecl_endp(T0))){
     goto L12;
    }
    T0 = ecl_car(v6l);
    if (!((T0)==(ECL_T))){
     goto L14;
    }
    v4form = ECL_T;
    goto L11;
L14:;
    {
     cl_object v7sym;
     v7sym = cl_gensym(0);
     T0 = ecl_car(v6l);
     T1 = cl_list(2, v7sym, T0);
     T2 = ecl_list1(T1);
     T3 = cl_list(4, ECL_SYM("IF",950), v7sym, v7sym, v4form);
     v4form = cl_list(3, ECL_SYM("LET",479), T2, T3);
     goto L11;
    }
L12:;
    T0 = ecl_car(v6l);
    if (!((T0)==(ECL_T))){
     goto L19;
    }
    T0 = ecl_cddr(v6l);
    if (!(ecl_endp(T0))){
     goto L22;
    }
    v4form = ecl_cadr(v6l);
    goto L21;
L22:;
    T0 = ecl_cdr(v6l);
    v4form = CONS(ECL_SYM("PROGN",674),T0);
L21:;
    goto L11;
L19:;
    T0 = ecl_cddr(v6l);
    if (!(ecl_endp(T0))){
     goto L25;
    }
    T0 = ecl_car(v6l);
    T1 = ecl_cadr(v6l);
    v4form = cl_list(4, ECL_SYM("IF",950), T0, T1, v4form);
    goto L24;
L25:;
    T0 = ecl_car(v6l);
    T1 = ecl_cdr(v6l);
    T2 = CONS(ECL_SYM("PROGN",674),T1);
    v4form = cl_list(4, ECL_SYM("IF",950), T0, T2, v4form);
L24:;
L11:;
   }
   v5 = ecl_cdr(v5);
L7:;
   if (Null(v5)){
    goto L29;
   }
   goto L6;
L29:;
   value0 = v4form;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC49cond_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
  return LC49cond(v6, v7);
 }
}
/* local function PROG                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC50prog(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4vl;
  cl_object v5body;
  cl_object v6decl;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4vl = v7;
  }
  v5body = v3;
  v6decl = ECL_NIL;
  value0 = si_find_declarations(1, v5body);
  {
   const int v7 = cl_env_copy->nvalues;
   v6decl = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5body = v8;
  }
  T0 = CONS(ECL_SYM("TAGBODY",853),v5body);
  T1 = ecl_list1(T0);
  T2 = ecl_append(v6decl,T1);
  T3 = cl_listX(3, ECL_SYM("LET",479), v4vl, T2);
  value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T3);
  return value0;
 }
}
static cl_object LC50prog_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[28]);
 {
  return LC50prog(v7, v8);
 }
}
/* local function PROG*                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC51prog_(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4vl;
  cl_object v5body;
  cl_object v6decl;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4vl = v7;
  }
  v5body = v3;
  v6decl = ECL_NIL;
  value0 = si_find_declarations(1, v5body);
  {
   const int v7 = cl_env_copy->nvalues;
   v6decl = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5body = v8;
  }
  T0 = CONS(ECL_SYM("TAGBODY",853),v5body);
  T1 = ecl_list1(T0);
  T2 = ecl_append(v6decl,T1);
  T3 = cl_listX(3, ECL_SYM("LET*",480), v4vl, T2);
  value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T3);
  return value0;
 }
}
static cl_object LC51prog__va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[29]);
 {
  return LC51prog_(v7, v8);
 }
}
/* local function PROG1                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC52prog1(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4first;
  cl_object v5sym;
  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);
   v4first = v6;
  }
  v5sym = cl_gensym(0);
  T0 = cl_list(2, v5sym, v4first);
  T1 = ecl_list1(T0);
  T2 = ecl_list1(v5sym);
  T3 = ecl_append(v3,T2);
  value0 = cl_listX(3, ECL_SYM("LET",479), T1, T3);
  return value0;
 }
}
static cl_object LC52prog1_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[30]);
 {
  return LC52prog1(v6, v7);
 }
}
/* local function PROG2                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC53prog2(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 v4first;
  cl_object v5second;
  cl_object v6sym;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4first = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5second = v7;
  }
  v6sym = cl_gensym(0);
  T0 = cl_list(2, v6sym, v5second);
  T1 = ecl_list1(T0);
  T2 = ecl_list1(v6sym);
  T3 = ecl_append(v3,T2);
  T4 = cl_listX(3, ECL_SYM("LET",479), T1, T3);
  value0 = cl_list(3, ECL_SYM("PROGN",674), v4first, T4);
  return value0;
 }
}
static cl_object LC53prog2_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[31]);
 {
  return LC53prog2(v7, v8);
 }
}
/* local function MULTIPLE-VALUE-LIST                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC54multiple_value_list(cl_object v1, cl_object v2)
{
 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 v4form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4form = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), VV[32], v4form);
  return value0;
 }
}
static cl_object LC54multiple_value_list_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[33]);
 {
  return LC54multiple_value_list(v5, v6);
 }
}
/* local function MULTIPLE-VALUE-SETQ                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC55multiple_value_setq(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  cl_object v4vars;
  cl_object v5form;
  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);
   v4vars = 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);
   v5form = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  {
   cl_object v6;
   cl_object v7vl;
   cl_object v8forms;
   cl_fixnum v9n;
   v6 = cl_gensym(0);
   v7vl = v4vars;
   v8forms = ECL_NIL;
   v9n = (cl_fixnum)(0);
   goto L23;
L22:;
   T0 = ecl_car(v7vl);
   T1 = cl_list(3, ECL_SYM("NTH",604), ecl_make_fixnum(v9n), v6);
   T2 = cl_list(3, ECL_SYM("SETQ",754), T0, T1);
   v8forms = CONS(T2,v8forms);
   v7vl = ecl_cdr(v7vl);
   v9n = ecl_to_fixnum(ecl_make_integer((v9n)+1));
L23:;
   if (ecl_endp(v7vl)) {
    goto L30;
   }
   goto L22;
L30:;
   T0 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), v5form);
   T1 = cl_list(2, v6, T0);
   T2 = ecl_list1(T1);
   value0 = cl_listX(3, ECL_SYM("LET",479), T2, v8forms);
   return value0;
  }
 }
}
static cl_object LC55multiple_value_setq_va(cl_narg narg, cl_object v10, cl_object v11, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[34]);
 {
  return LC55multiple_value_setq(v10, v11);
 }
}
/* local function MULTIPLE-VALUE-BIND                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC56multiple_value_bind(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 v4vars;
  cl_object v5form;
  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);
   v4vars = 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);
   v5form = v6;
  }
  {
   cl_object v6;
   cl_object v7;
   T0 = (ECL_SYM("LIST",483)->symbol.gfdef);
   v6 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v4vars) /*  MAPCAR */;
   v7 = cl_gensym(0);
   T0 = cl_list(2, ECL_SYM("&REST",14), v7);
   T1 = ecl_append(v6,T0);
   T2 = CONS(ECL_SYM("&OPTIONAL",13),T1);
   T3 = cl_listX(3, ECL_SYM("LAMBDA",454), T2, v3);
   T4 = cl_list(2, ECL_SYM("FUNCTION",398), T3);
   value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), T4, v5form);
   return value0;
  }
 }
}
static cl_object LC56multiple_value_bind_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[35]);
 {
  return LC56multiple_value_bind(v8, v9);
 }
}
/* function definition for WHILE-UNTIL                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L57while_until(cl_object v1test, cl_object v2body, cl_object v3jmp_op)
{
 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 v4;
  cl_object v5;
  v4 = cl_gensym(0);
  v5 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("GO",416), v5);
  T1 = cl_list(2, ECL_SYM("GO",416), v4);
  T2 = cl_list(3, v3jmp_op, v1test, T1);
  T3 = cl_list(2, v5, T2);
  T4 = ecl_append(v2body,T3);
  value0 = cl_listX(4, ECL_SYM("TAGBODY",853), T0, v4, T4);
  return value0;
 }
}
/* local function WHILE                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC58while(cl_object v1, cl_object v2)
{
 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 v4test;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4test = v5;
  }
  value0 = L57while_until(v4test, v3, ECL_SYM("WHEN",909));
  return value0;
 }
}
static cl_object LC58while_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[37]);
 {
  return LC58while(v5, v6);
 }
}
/* local function UNTIL                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC59until(cl_object v1, cl_object v2)
{
 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 v4test;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4test = v5;
  }
  value0 = L57while_until(v4test, v3, ECL_SYM("UNLESS",886));
  return value0;
 }
}
static cl_object LC59until_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[38]);
 {
  return LC59until(v5, v6);
 }
}
/* local function CASE                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC60case(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4keyform;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4keyform = v5;
  }
  {
   cl_object v5last;
   cl_object v6form;
   cl_object v7key;
   v5last = ECL_T;
   v6form = ECL_NIL;
   v7key = cl_gensym(0);
   {
    cl_object v8;
    v8 = cl_reverse(v3);
    goto L15;
L14:;
    {
     cl_object v9clause;
     v9clause = ecl_car(v8);
     {
      cl_object v10selector;
      v10selector = ecl_car(v9clause);
      if ((v10selector)==(ECL_T)) {
       goto L24;
      }
      if (!((v10selector)==(ECL_SYM("OTHERWISE",617)))){
       goto L22;
      }
      goto L23;
L24:;
L23:;
      if (v5last!=ECL_NIL) {
       goto L26;
      }
      T0 = ecl_list1(v10selector);
      si_signal_simple_error(4, ECL_SYM("PROGRAM-ERROR",675), ECL_NIL, VV[39], T0);
L26:;
      T0 = ecl_cdr(v9clause);
      v6form = CONS(ECL_SYM("PROGN",674),T0);
      goto L21;
L22:;
      if (!(ECL_CONSP(v10selector))){
       goto L29;
      }
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v10selector);
      T1 = cl_list(3, ECL_SYM("MEMBER",554), v7key, T0);
      T2 = ecl_cdr(v9clause);
      T3 = CONS(ECL_SYM("PROGN",674),T2);
      v6form = cl_list(4, ECL_SYM("IF",950), T1, T3, v6form);
      goto L21;
L29:;
      if (Null(v10selector)){
       goto L21;
      }
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v10selector);
      T1 = cl_list(3, ECL_SYM("EQL",336), v7key, T0);
      T2 = ecl_cdr(v9clause);
      T3 = CONS(ECL_SYM("PROGN",674),T2);
      v6form = cl_list(4, ECL_SYM("IF",950), T1, T3, v6form);
L21:;
      v5last = ECL_NIL;
     }
    }
    v8 = ecl_cdr(v8);
L15:;
    if (Null(v8)){
     goto L37;
    }
    goto L14;
L37:;
    T0 = cl_list(2, v7key, v4keyform);
    T1 = ecl_list1(T0);
    value0 = cl_list(3, ECL_SYM("LET",479), T1, v6form);
    return value0;
   }
  }
 }
}
static cl_object LC60case_va(cl_narg narg, cl_object v9, cl_object v10, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[40]);
 {
  return LC60case(v9, v10);
 }
}
/* local function RETURN                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC61return(cl_object v1, cl_object v2)
{
 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 v4val;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4val = v5;
   goto L3;
  }
L4:;
  v4val = ECL_NIL;
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_NIL, v4val);
  return value0;
 }
}
static cl_object LC61return_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[41]);
 {
  return LC61return(v5, v6);
 }
}
/* local function DECLAIM                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC62declaim(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  if (Null(ecl_cdr(v3))){
   goto L3;
  }
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v3);
  T1 = cl_list(3, ECL_SYM("MAPCAR",547), VV[42], T0);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[3], T1);
  return value0;
L3:;
  T0 = ecl_car(v3);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
  T2 = cl_list(2, ECL_SYM("PROCLAIM",669), T1);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[3], T2);
  return value0;
 }
}
static cl_object LC62declaim_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("DECLAIM",274));
 {
  return LC62declaim(v4, v5);
 }
}
/* local function C-DECLAIM                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC63c_declaim(cl_object v1, cl_object v2)
{
 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:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  if (Null(ecl_cdr(v3))){
   goto L3;
  }
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v3);
  T1 = cl_list(3, ECL_SYM("MAPCAR",547), VV[42], T0);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T1);
  return value0;
L3:;
  T0 = ecl_car(v3);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
  T2 = cl_list(2, ECL_SYM("PROCLAIM",669), T1);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[7], T2);
  return value0;
 }
}
static cl_object LC63c_declaim_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[43]);
 {
  return LC63c_declaim(v4, v5);
 }
}
/* local function IN-PACKAGE                                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC64in_package(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4name;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4name = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  T0 = cl_string(v4name);
  T1 = cl_list(2, ECL_SYM("SELECT-PACKAGE",1162), T0);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[3], T1);
  return value0;
 }
}
static cl_object LC64in_package_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[44]);
 {
  return LC64in_package(v5, v6);
 }
}
/* local function DEFINE-SYMBOL-MACRO                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC65define_symbol_macro(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4symbol;
  cl_object v5expansion;
  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);
   v4symbol = 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);
   v5expansion = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  if (ECL_SYMBOLP(v4symbol)) {
   goto L17;
  }
  value0 = cl_error(2, VV[45], v4symbol);
  return value0;
L17:;
  if (Null(si_specialp(v4symbol))){
   goto L19;
  }
  value0 = cl_error(2, VV[46], v4symbol);
  return value0;
L19:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v4symbol);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), v5expansion);
  T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[48], VV[49], T1);
  T3 = cl_list(4, ECL_SYM("PUT-SYSPROP",1150), T0, VV[47], T2);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
   goto L22;
  }
  T5 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
  T6 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
  T4 = ecl_function_dispatch(cl_env_copy,T5)(3, T6, v1, ECL_NIL);
  goto L21;
L22:;
  T4 = ECL_NIL;
L21:;
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v4symbol);
  value0 = cl_list(5, ECL_SYM("EVAL-WHEN",342), VV[3], T3, T4, T5);
  return value0;
 }
}
static cl_object LC65define_symbol_macro_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[50]);
 {
  return LC65define_symbol_macro(v6, v7);
 }
}
/* local function NTH-VALUE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC66nth_value(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 v4n;
  cl_object v5expr;
  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);
   v4n = 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);
   v5expr = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  T0 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), v5expr);
  value0 = cl_list(3, ECL_SYM("NTH",604), v4n, T0);
  return value0;
 }
}
static cl_object LC66nth_value_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[51]);
 {
  return LC66nth_value(v6, v7);
 }
}
/* function definition for MAYBE-UNQUOTE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L67maybe_unquote(cl_object v1form)
{
 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 (!(ECL_CONSP(v1form))){
  goto L2;
 }
 T0 = ecl_car(v1form);
 if (!((T0)==(ECL_SYM("QUOTE",682)))){
  goto L2;
 }
 value0 = ecl_cadr(v1form);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L67maybe_unquote_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[52]);
 {
  return L67maybe_unquote(v2form);
 }
}
/* function definition for MAYBE-QUOTE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L68maybe_quote(cl_object v1form)
{
 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 (!(ECL_ATOM(v1form))){
  goto L4;
 }
 if (!(ECL_SYMBOLP(v1form))){
  goto L2;
 }
 if (cl_keywordp(v1form)!=ECL_NIL) {
  goto L2;
 }
 if (!((v1form)==(ECL_NIL))){
  goto L10;
 }
 goto L2;
L10:;
 goto L8;
L8:;
 if (!((v1form)==(ECL_T))){
  goto L13;
 }
 goto L2;
L13:;
 goto L3;
L4:;
 T0 = ecl_car(v1form);
 if ((T0)==(ECL_SYM("QUOTE",682))) {
  goto L2;
 }
L3:;
 value0 = cl_list(2, ECL_SYM("QUOTE",682), v1form);
 return value0;
L2:;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L68maybe_quote_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[55]);
 {
  return L68maybe_quote(v2form);
 }
}
/* local function TRULY-THE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC69truly_the(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  value0 = CONS(ECL_SYM("THE",859),v3);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC69truly_the_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[56]);
 {
  return LC69truly_the(v4, v5);
 }
}
/* local function CHECKED-VALUE                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC70checked_value(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  value0 = CONS(ECL_SYM("THE",859),v3);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC70checked_value_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[57]);
 {
  return LC70checked_value(v4, v5);
 }
}
#include "lsp/evalmacros.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclcOleXkoPxtSn9_jAbzL881(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:LSP;EVALMACROS.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclcOleXkoPxtSn9_jAbzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defmacro(VV[58]);                       /*  UNLESS                  */
  ecl_cmp_defmacro(VV[59]);                       /*  DEFMACRO                */
  ecl_cmp_defmacro(VV[60]);                       /*  DEFVAR                  */
  ecl_cmp_defmacro(VV[61]);                       /*  DEFPARAMETER            */
  ecl_cmp_defmacro(VV[62]);                       /*  DEFCONSTANT             */
  si_Xmake_special(VV[12]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC41__lambda46_va,ECL_NIL,Cblock,2);
   T0 = v1;
   ecl_cmp_setq(cl_env_copy,VV[12],T0);
  }
  ecl_cmp_defmacro(VV[63]);                       /*  DEFUN                   */
  ecl_cmp_defmacro(VV[64]);                       /*  DEFINE-COMPILER-MACRO   */
  ecl_cmp_defun(VV[65]);                          /*  COMPILER-MACRO-FUNCTION */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC45loop_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_fset(4, ECL_SYM("LOOP",514), T0, ECL_T, ecl_make_int8_t(1));
  ecl_cmp_defmacro(VV[66]);                       /*  LAMBDA                  */
  ecl_cmp_defmacro(VV[67]);                       /*  LAMBDA-BLOCK            */
  ecl_cmp_defmacro(VV[68]);                       /*  PSETQ                   */
  ecl_cmp_defmacro(VV[69]);                       /*  COND                    */
  ecl_cmp_defmacro(VV[70]);                       /*  PROG                    */
  ecl_cmp_defmacro(VV[71]);                       /*  PROG*                   */
  ecl_cmp_defmacro(VV[72]);                       /*  PROG1                   */
  ecl_cmp_defmacro(VV[73]);                       /*  PROG2                   */
  ecl_cmp_defmacro(VV[74]);                       /*  MULTIPLE-VALUE-LIST     */
  ecl_cmp_defmacro(VV[75]);                       /*  MULTIPLE-VALUE-SETQ     */
  ecl_cmp_defmacro(VV[76]);                       /*  MULTIPLE-VALUE-BIND     */
  (void)0; /* No entry created for WHILE-UNTIL */
  ecl_cmp_defmacro(VV[77]);                       /*  WHILE                   */
  ecl_cmp_defmacro(VV[78]);                       /*  UNTIL                   */
  ecl_cmp_defmacro(VV[79]);                       /*  CASE                    */
  ecl_cmp_defmacro(VV[80]);                       /*  RETURN                  */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC62declaim_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_fset(4, ECL_SYM("DECLAIM",274), T0, ECL_T, ecl_make_int8_t(1));
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC63c_declaim_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_fset(4, VV[43], T0, ECL_T, ecl_make_int8_t(1));
  ecl_cmp_defmacro(VV[81]);                       /*  IN-PACKAGE              */
  ecl_cmp_defmacro(VV[82]);                       /*  DEFINE-SYMBOL-MACRO     */
  ecl_cmp_defmacro(VV[83]);                       /*  NTH-VALUE               */
  ecl_cmp_defun(VV[84]);                          /*  MAYBE-UNQUOTE           */
  ecl_cmp_defun(VV[85]);                          /*  MAYBE-QUOTE             */
  ecl_cmp_defmacro(VV[86]);                       /*  TRULY-THE               */
  ecl_cmp_defmacro(VV[87]);                       /*  CHECKED-VALUE           */
 }
}
