/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/defmacro.lsp                    */
#include <ecl/ecl-cmp.h>
#include "lsp/defmacro.eclh"
/* function definition for SEARCH-KEYWORD                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_search_keyword(cl_object v1list, cl_object v2key)
{
 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(v1list))){
  goto L2;
 }
 value0 = ECL_SYM("MISSING-KEYWORD",2044);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = ecl_cdr(v1list);
 if (!(ECL_ATOM(T0))){
  goto L4;
 }
 value0 = ECL_SYM("MISSING-KEYWORD",2044);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 T0 = ecl_car(v1list);
 if (!((T0)==(v2key))){
  goto L6;
 }
 value0 = ecl_cadr(v1list);
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 v1list = ecl_cddr(v1list);
 goto L1;
}
cl_object si_search_keyword_va(cl_narg narg, cl_object v3list, cl_object v4key, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[0]);
 {
  return si_search_keyword(v3list, v4key);
 }
}
/* function definition for CHECK-KEYWORD                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_check_keyword(cl_narg narg, cl_object v1tail, cl_object v2keywords, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[2]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[2]);
 {
  cl_object v3allow_other_keys;
  cl_object v4aok_flag;
  va_list args; va_start(args,v2keywords);
  {
   int i = 2;
   if (i >= narg) {
    v3allow_other_keys = ECL_NIL;
    v4aok_flag = ECL_NIL;
   } else {
    i++;
    v3allow_other_keys = va_arg(args,cl_object);
    v4aok_flag = ECL_T;
   }
  }
  va_end(args);
  {
   cl_object v5head;
   cl_object v6arg;
   cl_object v7err;
   v5head = ECL_NIL;
   v6arg = ECL_NIL;
   v7err = ECL_NIL;
   goto L7;
L6:;
   if (!(ECL_ATOM(v1tail))){
    goto L10;
   }
   cl_error(1, VV[3]);
   goto L9;
L10:;
   v5head = ecl_car(v1tail);
   {
    cl_object v8;
    v8 = ecl_cdr(v1tail);
    if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v1tail = v8;
   }
L9:;
   if (!(ECL_ATOM(v1tail))){
    goto L18;
   }
   cl_error(1, VV[3]);
   goto L17;
L18:;
   v6arg = ecl_car(v1tail);
   {
    cl_object v8;
    v8 = ecl_cdr(v1tail);
    if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v1tail = v8;
   }
L17:;
   if (!((v5head)==(ECL_SYM("ALLOW-OTHER-KEYS",1227)))){
    goto L26;
   }
   if (v4aok_flag!=ECL_NIL) {
    goto L25;
   }
   v3allow_other_keys = v6arg;
   v4aok_flag = ECL_T;
   goto L25;
L26:;
   {
    cl_object v8;
    cl_object v9;
    v8 = v5head;
    v9 = v2keywords;
    if (ecl_memql(v8,v9)!=ECL_NIL) {
     goto L25;
    }
   }
   v7err = v5head;
L25:;
L7:;
   if (v1tail==ECL_NIL) {
    goto L36;
   }
   goto L6;
L36:;
   if (Null(v7err)){
    goto L38;
   }
   if (v3allow_other_keys!=ECL_NIL) {
    goto L38;
   }
   value0 = cl_error(2, VV[4], v7err);
   return value0;
L38:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for DM-TOO-MANY-ARGUMENTS                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_dm_too_many_arguments(cl_object v1_current_form_)
{
 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);
 ecl_bds_bind(cl_env_copy,ECL_SYM("*CURRENT-FORM*",1683),v1_current_form_); /*  *CURRENT-FORM* */
L1:;
 value0 = si_simple_program_error(2, VV[7], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-FORM*",1683)));
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
cl_object si_dm_too_many_arguments_va(cl_narg narg, cl_object v2_current_form_, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[6]);
 {
  return si_dm_too_many_arguments(v2_current_form_);
 }
}
/* function definition for DM-TOO-FEW-ARGUMENTS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_dm_too_few_arguments(cl_object v1form_or_nil)
{
 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(v1form_or_nil)){
  goto L2;
 }
 ecl_bds_bind(cl_env_copy,ECL_SYM("*CURRENT-FORM*",1683),v1form_or_nil); /*  *CURRENT-FORM* */
 value0 = si_simple_program_error(2, VV[10], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-FORM*",1683)));
 ecl_bds_unwind1(cl_env_copy);
 return value0;
L2:;
 value0 = si_simple_program_error(1, VV[11]);
 return value0;
}
cl_object si_dm_too_few_arguments_va(cl_narg narg, cl_object v2form_or_nil, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[9]);
 {
  return si_dm_too_few_arguments(v2form_or_nil);
 }
}
/* function definition for DESTRUCTURE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L13destructure(cl_object v1vl, cl_object v2context)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 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_gensym(0);
 lex0[0] = T0;                                    /*  BASIS-FORM              */
 T0 = ecl_list1(lex0[0]);
 lex0[1] = T0;                                    /*  DESTRUCTURE-SYMBOLS     */
 ecl_bds_bind(cl_env_copy,VV[13],ECL_NIL);        /*  *DL*                    */
 ecl_bds_bind(cl_env_copy,VV[14],ECL_NIL);        /*  *ARG-CHECK*             */
 if (!(ECL_LISTP(v1vl))){
  goto L3;
 }
 T0 = ecl_car(v1vl);
 if (!((T0)==(ECL_SYM("&WHOLE",15)))){
  goto L2;
 }
 {
  cl_object v3named_whole;
  v3named_whole = ecl_cadr(v1vl);
  v1vl = ecl_cddr(v1vl);
  if (!(ECL_LISTP(v3named_whole))){
   goto L9;
  }
  LC11dm_vl(lex0, v3named_whole, lex0[0], ECL_NIL);
  goto L2;
L9:;
  T0 = cl_list(2, v3named_whole, lex0[0]);
  T1 = ecl_list1(T0);
  ecl_cmp_setq(cl_env_copy,VV[13],T1);
  goto L2;
 }
L3:;
 if (!(ECL_SYMBOLP(v1vl))){
  goto L12;
 }
 v1vl = cl_list(2, ECL_SYM("&REST",14), v1vl);
 goto L2;
L12:;
 cl_error(2, VV[31], v1vl);
L2:;
 T0 = LC11dm_vl(lex0, v1vl, lex0[0], v2context);
 T1 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[13]));
 cl_env_copy->nvalues = 5;
 cl_env_copy->values[4] = lex0[1];
 cl_env_copy->values[3] = ecl_cmp_symbol_value(cl_env_copy,VV[14]);
 cl_env_copy->values[2] = T1;
 cl_env_copy->values[1] = lex0[0];
 cl_env_copy->values[0] = T0;
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
 return cl_env_copy->values[0];
}
static cl_object L13destructure_va(cl_narg narg, cl_object v3vl, cl_object v4context, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[32]);
 {
  return L13destructure(v3vl, v4context);
 }
}
/* function definition for FIND-DOCUMENTATION                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_find_documentation(cl_narg narg, cl_object v1body, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[33]);
 {
L1:;
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   cl_env_copy->values[0] = si_process_declarations(2, v1body, ECL_T);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   T0 = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
   ecl_stack_frame_close(_ecl_inner_frame);
  }
  value0 = ecl_cadddr(T0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for REMOVE-DOCUMENTATION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_remove_documentation(cl_object v1body)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;                                   /*  DECLS                   */
  cl_object v3;                                   /*  BODY                    */
  cl_object v4;                                   /*  DOC                     */
  value0 = si_process_declarations(2, v1body, ECL_T);
  {
   const int v5 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v6;
   v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v6;
   v6 = (v5<=2)? ECL_NIL : cl_env_copy->values[2];
   v4 = v6;
  }
  if (Null(v2)){
   goto L3;
  }
  T0 = CONS(ECL_SYM("DECLARE",276),v2);
  v3 = CONS(T0,v3);
L3:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v4;
  cl_env_copy->values[0] = v3;
  return cl_env_copy->values[0];
 }
}
cl_object si_remove_documentation_va(cl_narg narg, cl_object v2body, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[35]);
 {
  return si_remove_documentation(v2body);
 }
}
/* function definition for FIND-DECLARATIONS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_find_declarations(cl_narg narg, cl_object v1body, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[37]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[37]);
 {
  cl_object v2doc;
  va_list args; va_start(args,v1body);
  {
   int i = 1;
   if (i >= narg) {
    v2doc = ECL_T;
   } else {
    i++;
    v2doc = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3;                                  /*  DECLS                   */
   cl_object v4;                                  /*  BODY                    */
   cl_object v5;                                  /*  DOC                     */
   value0 = si_process_declarations(2, v1body, v2doc);
   {
    const int v6 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v7;
    v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v7;
    v7 = (v6<=2)? ECL_NIL : cl_env_copy->values[2];
    v5 = v7;
   }
   if (Null(v3)){
    goto L4;
   }
   T1 = CONS(ECL_SYM("DECLARE",276),v3);
   T0 = ecl_list1(T1);
   goto L3;
L4:;
   T0 = ECL_NIL;
L3:;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = v5;
   cl_env_copy->values[1] = v4;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for EXPAND-DEFMACRO                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L14expand_defmacro(cl_narg narg, cl_object v1name, cl_object v2vl, cl_object v3body, ...)
{
 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);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[39]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[39]);
 {
  cl_object v4context;
  va_list args; va_start(args,v3body);
  {
   int i = 3;
   if (i >= narg) {
    v4context = ECL_SYM("DEFMACRO",285);
   } else {
    i++;
    v4context = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v5;                                  /*  DECLS                   */
   cl_object v6;                                  /*  BODY                    */
   cl_object v7;                                  /*  DOC                     */
   value0 = si_find_declarations(1, v3body);
   {
    const int v8 = cl_env_copy->nvalues;
    v5 = value0;
    cl_object v9;
    v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
    v6 = v9;
    v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v9;
   }
   {
    cl_object v8cell;
    v8cell = ecl_last(v2vl,1);
    if (Null(ecl_cdr(v8cell))){
     goto L3;
    }
    T0 = cl_butlast(2, v2vl, ecl_make_int8_t(0));
    T1 = ecl_cdr(v8cell);
    T2 = cl_list(2, ECL_SYM("&REST",14), T1);
    v2vl = ecl_nconc(T0,T2);
   }
L3:;
   {
    cl_object v8env;
    {
     cl_object v9;
     cl_object v10;
     cl_object v11;
     v9 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v10 = ECL_SYM("&ENVIRONMENT",11);
     v11 = v2vl;
     v8env = si_memq(v10,v11);
    }
    if (Null(v8env)){
     goto L12;
    }
    T0 = cl_ldiff(v2vl, v8env);
    T1 = ecl_cddr(v8env);
    v2vl = ecl_nconc(T0,T1);
    v8env = ecl_cadr(v8env);
    goto L11;
L12:;
    v8env = cl_gensym(0);
    T0 = cl_list(2, ECL_SYM("IGNORE",430), v8env);
    T1 = cl_list(2, ECL_SYM("DECLARE",276), T0);
    v5 = CONS(T1,v5);
L11:;
    {
     cl_object v9;                                /*  PPN                     */
     cl_object v10;                               /*  WHOLE                   */
     cl_object v11;                               /*  DL                      */
     cl_object v12;                               /*  ARG-CHECK               */
     cl_object v13;                               /*  IGNORABLES              */
     value0 = L13destructure(v2vl, v4context);
     {
      const int v14 = cl_env_copy->nvalues;
      v9 = value0;
      cl_object v15;
      v15 = (v14<=1)? ECL_NIL : cl_env_copy->values[1];
      v10 = v15;
      v15 = (v14<=2)? ECL_NIL : cl_env_copy->values[2];
      v11 = v15;
      v15 = (v14<=3)? ECL_NIL : cl_env_copy->values[3];
      v12 = v15;
      v15 = (v14<=4)? ECL_NIL : cl_env_copy->values[4];
      v13 = v15;
     }
     {
      cl_object v14function;
      if (!((v4context)==(ECL_SYM("DEFMACRO",285)))){
       goto L22;
      }
      T0 = cl_listX(4, v10, v8env, ECL_SYM("&AUX",9), v11);
      T1 = CONS(ECL_SYM("IGNORABLE",429),v13);
      T2 = cl_list(2, ECL_SYM("DECLARE",276), T1);
      T3 = cl_append(3, v5, v12, v6);
      v14function = cl_listX(5, ECL_SYM("LAMBDA-BLOCK",1377), v1name, T0, T2, T3);
      goto L21;
L22:;
      T0 = cl_listX(4, v10, v8env, ECL_SYM("&AUX",9), v11);
      T1 = CONS(ECL_SYM("IGNORABLE",429),v13);
      T2 = cl_list(2, ECL_SYM("DECLARE",276), T1);
      T3 = si_function_block_name(v1name);
      T4 = ecl_append(v12,v6);
      T5 = cl_listX(3, ECL_SYM("BLOCK",139), T3, T4);
      T6 = ecl_list1(T5);
      T7 = ecl_append(v5,T6);
      v14function = cl_listX(4, ECL_SYM("LAMBDA",454), T0, T2, T7);
L21:;
      cl_env_copy->nvalues = 3;
      cl_env_copy->values[2] = v7;
      cl_env_copy->values[1] = v9;
      cl_env_copy->values[0] = v14function;
      return cl_env_copy->values[0];
     }
    }
   }
  }
 }
}
/* local function DESTRUCTURING-BIND                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC15destructuring_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 v4vl;
  cl_object v5list;
  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);
   v4vl = 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);
   v5list = v6;
  }
  {
   cl_object v6;                                  /*  DECLS                   */
   cl_object v7;                                  /*  BODY                    */
   value0 = si_find_declarations(1, v3);
   {
    const int v8 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v9;
    v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
    v7 = v9;
   }
   {
    cl_object v8;                                 /*  WHOLE                   */
    cl_object v9;                                 /*  DL                      */
    cl_object v10;                                /*  ARG-CHECK               */
    cl_object v11;                                /*  IGNORABLES              */
    value0 = L13destructure(v4vl, ECL_NIL);
    {
     const int v12 = cl_env_copy->nvalues;
     cl_object v13;
     v13 = (v12<=1)? ECL_NIL : cl_env_copy->values[1];
     v8 = v13;
     v13 = (v12<=2)? ECL_NIL : cl_env_copy->values[2];
     v9 = v13;
     v13 = (v12<=3)? ECL_NIL : cl_env_copy->values[3];
     v10 = v13;
     v13 = (v12<=4)? ECL_NIL : cl_env_copy->values[4];
     v11 = v13;
    }
    T0 = cl_list(2, v8, v5list);
    T1 = CONS(T0,v9);
    T2 = CONS(ECL_SYM("IGNORABLE",429),v11);
    T3 = cl_list(2, ECL_SYM("DECLARE",276), T2);
    T4 = cl_append(3, v6, v10, v7);
    value0 = cl_listX(4, ECL_SYM("LET*",480), T1, T3, T4);
    return value0;
   }
  }
 }
}
static cl_object LC15destructuring_bind_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[40]);
 {
  return LC15destructuring_bind(v6, v7);
 }
}
/* function definition for CMP-ENV-FOR-BYTECODES                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L20cmp_env_for_bytecodes(cl_object v1old_env)
{
 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 v2;
  cl_object v3env;
  cl_object v4variables;
  v2 = ecl_car(v1old_env);
  v3env = v2;
  v4variables = ECL_NIL;
  goto L8;
L7:;
  {
   cl_object v5i;
   v5i = ecl_car(v3env);
   if (!(ECL_CONSP(v5i))){
    goto L10;
   }
   {
    cl_object v6name;
    v6name = ecl_car(v5i);
    if (cl_keywordp(v6name)!=ECL_NIL) {
     goto L10;
    }
    if (Null(ecl_cadr(v5i))){
     goto L17;
    }
    T1 = v5i;
    goto L16;
L17:;
    T2 = LC17local_var_error_function(v6name);
    T1 = cl_list(3, v6name, ECL_SYM("SYMBOL-MACRO",1184), T2);
L16:;
    v4variables = CONS(T1,v4variables);
   }
  }
L10:;
  v3env = ecl_cdr(v3env);
L8:;
  if (ecl_endp(v3env)) {
   goto L22;
  }
  goto L7;
L22:;
  T0 = cl_nreverse(v4variables);
 }
 {
  cl_object v2;
  cl_object v3env;
  cl_object v4macros;
  v2 = ecl_cdr(v1old_env);
  v3env = v2;
  v4macros = ECL_NIL;
  goto L30;
L29:;
  {
   cl_object v5i;
   v5i = ecl_car(v3env);
   if (!(ECL_CONSP(v5i))){
    goto L32;
   }
   T3 = ecl_cadr(v5i);
   if (!((T3)==(ECL_SYM("MACRO",1113)))){
    goto L37;
   }
   T2 = v5i;
   goto L36;
L37:;
   T3 = ecl_car(v5i);
   T5 = ecl_car(v5i);
   T4 = LC19local_fun_error_function(T5);
   T2 = cl_list(3, T3, ECL_SYM("MACRO",1113), T4);
L36:;
   v4macros = CONS(T2,v4macros);
  }
L32:;
  v3env = ecl_cdr(v3env);
L30:;
  if (ecl_endp(v3env)) {
   goto L42;
  }
  goto L29;
L42:;
  T1 = cl_nreverse(v4macros);
 }
 value0 = CONS(T0,T1);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for MACROLET-FUNCTIONS                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L22macrolet_functions(cl_object v1definitions, cl_object v2old_env)
{
 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 v3env;
  v3env = L20cmp_env_for_bytecodes(v2old_env);
  {
   cl_object v4;
   {
    cl_object v5;
    v5 = ecl_make_cfun_va((cl_objectfn)LC21__lambda118_va,ECL_NIL,Cblock,1);
    v4 = v5;
   }
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    {
     cl_object v8;
     v8 = v1definitions;
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6 = ECL_NIL;
    v7 = v5;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L12:;
     if (!(ecl_endp(v7))){
      goto L14;
     }
     goto L13;
L14:;
     v6 = ECL_CONS_CAR(v7);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v7);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v10;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v6);
     v9 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v9,T1);
     goto L12;
L13:;
     T0 = ecl_cdr(v8);
     goto L3;
    }
   }
  }
L3:;
  T1 = CONS(ECL_SYM("LIST",483),T0);
  value0 = si_eval_with_env(4, T1, v3env, ECL_NIL, ECL_T);
  return value0;
 }
}
/* function definition for CMP-ENV-REGISTER-MACROLET                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L23cmp_env_register_macrolet(cl_object v1definitions, cl_object v2old_env)
{
 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 v3macros;
  v3macros = ecl_cdr(v2old_env);
  {
   cl_object v4;
   v4 = L22macrolet_functions(v1definitions, v2old_env);
   goto L7;
L6:;
   {
    cl_object v5record;
    v5record = ecl_car(v4);
    T0 = ecl_car(v5record);
    T1 = ecl_cadr(v5record);
    T2 = cl_list(3, T0, ECL_SYM("MACRO",1113), T1);
    v3macros = CONS(T2,v3macros);
   }
   v4 = ecl_cdr(v4);
L7:;
   if (Null(v4)){
    goto L15;
   }
   goto L6;
L15:;
  }
  value0 = (ECL_CONS_CDR(v2old_env)=v3macros,v2old_env);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L23cmp_env_register_macrolet_va(cl_narg narg, cl_object v4definitions, cl_object v5old_env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[55]);
 {
  return L23cmp_env_register_macrolet(v4definitions, v5old_env);
 }
}
/* local function DM-V                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC12dm_v(volatile cl_object *lex0, cl_object v1v, cl_object v2init)
{
 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(v1v)){
  goto L2;
 }
 if (!(ECL_SYMBOLP(v1v))){
  goto L2;
 }
 {
  cl_object v3push_val;
  if (Null(v2init)){
   goto L6;
  }
  v3push_val = cl_list(2, v1v, v2init);
  goto L5;
L6:;
  v3push_val = v1v;
L5:;
  T0 = CONS(v3push_val,ecl_cmp_symbol_value(cl_env_copy,VV[13]));
  ecl_cmp_setq(cl_env_copy,VV[13],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[13]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 if (Null(v1v)){
  goto L9;
 }
 if (!(ECL_ATOM(v1v))){
  goto L9;
 }
 value0 = cl_error(2, VV[30], v1v);
 return value0;
L9:;
 T0 = ecl_car(v1v);
 if (!((T0)==(ECL_SYM("&WHOLE",15)))){
  goto L12;
 }
 {
  cl_object v4whole_var;
  v4whole_var = ecl_cadr(v1v);
  if (!(ECL_LISTP(v4whole_var))){
   goto L16;
  }
  {
   cl_object v5new_whole;
   v5new_whole = LC10tempsym(lex0);
   LC12dm_v(lex0, v5new_whole, v2init);
   LC11dm_vl(lex0, v4whole_var, v5new_whole, ECL_NIL);
   v4whole_var = v5new_whole;
   goto L15;
  }
L16:;
  LC12dm_v(lex0, v4whole_var, v2init);
L15:;
  T0 = ecl_cddr(v1v);
  value0 = LC11dm_vl(lex0, T0, v4whole_var, ECL_NIL);
  return value0;
 }
L12:;
 {
  cl_object v5temp;
  cl_object v6push_val;
  v5temp = LC10tempsym(lex0);
  if (Null(v2init)){
   goto L24;
  }
  v6push_val = cl_list(2, v5temp, v2init);
  goto L23;
L24:;
  v6push_val = v5temp;
L23:;
  T0 = CONS(v6push_val,ecl_cmp_symbol_value(cl_env_copy,VV[13]));
  ecl_cmp_setq(cl_env_copy,VV[13],T0);
  value0 = LC11dm_vl(lex0, v1v, v5temp, ECL_NIL);
  return value0;
 }
}
/* local function DM-VL                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC11dm_vl(volatile cl_object *lex0, cl_object v1vl, cl_object v2whole, cl_object v3context)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 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;                                   /*  REQS                    */
  cl_object v5;                                   /*  OPTS                    */
  cl_object v6;                                   /*  REST                    */
  cl_object v7;                                   /*  KEY-FLAG                */
  cl_object v8;                                   /*  KEYS                    */
  cl_object v9;                                   /*  ALLOW-OTHER-KEYS        */
  cl_object v10;                                  /*  AUXS                    */
  if (!((v3context)==(ECL_SYM("DEFMACRO",285)))){
   goto L9;
  }
  goto L6;
L9:;
  goto L7;
L7:;
  if (!((v3context)==(ECL_SYM("DEFINE-COMPILER-MACRO",281)))){
   goto L13;
  }
  goto L6;
L13:;
  goto L11;
L11:;
  if (!((v3context)==(ECL_SYM("DEFINE-SETF-EXPANDER",283)))){
   goto L17;
  }
  goto L6;
L17:;
  goto L15;
L15:;
  if (!((v3context)==(ECL_SYM("DEFTYPE",290)))){
   goto L4;
  }
  goto L5;
L6:;
L5:;
  T0 = ECL_SYM("MACRO",1113);
  goto L3;
L4:;
  T0 = ECL_SYM("DESTRUCTURING-BIND",302);
L3:;
  value0 = si_process_lambda_list(v1vl, T0);
  {
   const int v11 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v12;
   v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v12;
   v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2];
   v6 = v12;
   v12 = (v11<=3)? ECL_NIL : cl_env_copy->values[3];
   v7 = v12;
   v12 = (v11<=4)? ECL_NIL : cl_env_copy->values[4];
   v8 = v12;
   v12 = (v11<=5)? ECL_NIL : cl_env_copy->values[5];
   v9 = v12;
   v12 = (v11<=6)? ECL_NIL : cl_env_copy->values[6];
   v10 = v12;
  }
  {
   cl_object v11pointer;
   cl_object v12cons_pointer;
   cl_object v13unsafe_car;
   cl_object v14unsafe_cdr;
   cl_object v15unsafe_pop;
   cl_object v16no_check;
   cl_object v17ppn;
   cl_object v18all_keywords;
   v11pointer = LC10tempsym(lex0);
   v12cons_pointer = cl_list(3, ECL_SYM("TRULY-THE",2081), ECL_SYM("CONS",253), v11pointer);
   v13unsafe_car = cl_list(2, ECL_SYM("CAR",182), v12cons_pointer);
   v14unsafe_cdr = cl_list(2, ECL_SYM("CDR",200), v12cons_pointer);
   v15unsafe_pop = cl_list(3, ECL_SYM("SETQ",754), v11pointer, v14unsafe_cdr);
   v16no_check = ECL_NIL;
   {
    cl_fixnum v19;
    v19 = ecl_length(v4);
    T0 = ecl_car(v5);
    v17ppn = ecl_plus(ecl_make_fixnum(v19),T0);
   }
   v18all_keywords = ECL_NIL;
   if (!((v3context)==(ECL_SYM("DEFINE-COMPILER-MACRO",281)))){
    goto L30;
   }
   T1 = cl_list(2, ECL_SYM("CAR",182), v2whole);
   T2 = cl_list(3, ECL_SYM("EQ",335), T1, VV[22]);
   T3 = cl_list(2, ECL_SYM("CAADR",172), v2whole);
   T4 = cl_list(3, ECL_SYM("EQ",335), T3, VV[23]);
   T5 = cl_list(3, ECL_SYM("AND",89), T2, T4);
   T6 = cl_list(3, ECL_SYM("TRULY-THE",2081), ECL_SYM("CONS",253), v2whole);
   T7 = cl_list(2, ECL_SYM("CDDR",199), T6);
   T8 = cl_list(3, ECL_SYM("TRULY-THE",2081), ECL_SYM("CONS",253), v2whole);
   T9 = cl_list(2, ECL_SYM("CDR",200), T8);
   T0 = cl_list(4, ECL_SYM("IF",950), T5, T7, T9);
   goto L29;
L30:;
   if (!((v3context)==(ECL_SYM("DEFMACRO",285)))){
    goto L37;
   }
   goto L34;
L37:;
   goto L35;
L35:;
   if (!((v3context)==(ECL_SYM("DEFINE-SETF-EXPANDER",283)))){
    goto L41;
   }
   goto L34;
L41:;
   goto L39;
L39:;
   if (!((v3context)==(ECL_SYM("DEFTYPE",290)))){
    goto L32;
   }
   goto L33;
L34:;
L33:;
   T1 = cl_list(3, ECL_SYM("TRULY-THE",2081), ECL_SYM("CONS",253), v2whole);
   T0 = cl_list(2, ECL_SYM("CDR",200), T1);
   goto L29;
L32:;
   T0 = v2whole;
L29:;
   LC12dm_v(lex0, v11pointer, T0);
   {
    cl_object v19;
    v19 = ecl_cdr(v4);
    goto L48;
L47:;
    {
     cl_object v20v;
     v20v = ecl_car(v19);
     T0 = cl_list(2, ECL_SYM("NULL",607), v11pointer);
     T1 = cl_list(2, VV[9], lex0[0]);
     T2 = cl_list(3, ECL_SYM("IF",950), T0, T1);
     T3 = cl_list(3, ECL_SYM("PROG1",672), v13unsafe_car, v15unsafe_pop);
     T4 = cl_list(3, ECL_SYM("PROGN",674), T2, T3);
     LC12dm_v(lex0, v20v, T4);
    }
    v19 = ecl_cdr(v19);
L48:;
    if (Null(v19)){
     goto L55;
    }
    goto L47;
L55:;
   }
   {
    cl_object v19;
    {
     cl_object v20;
     v20 = v5;
     {
      cl_object v21;
      v21 = v20;
      {
       bool v22;
       v22 = ECL_LISTP(v21);
       if (ecl_unlikely(!(v22)))
         FEwrong_type_argument(VV[27],v21);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v20)){
      goto L63;
     }
     {
      cl_object v21;
      v21 = ECL_CONS_CDR(v20);
      v5 = v21;
      v20 = ECL_CONS_CAR(v20);
     }
L63:;
     v19 = v20;
    }
    {
     cl_object v20i;
     v20i = ecl_make_int8_t(0);
     goto L71;
L70:;
     {
      cl_object v21x;
      cl_object v22init;
      cl_object v23sv;
      v21x = ecl_car(v5);
      v22init = ecl_cadr(v5);
      v23sv = ecl_caddr(v5);
      v5 = ecl_cdddr(v5);
      if (Null(v23sv)){
       goto L79;
      }
      T0 = cl_list(4, ECL_SYM("IF",950), v11pointer, v13unsafe_car, v22init);
      LC12dm_v(lex0, v21x, T0);
      T0 = cl_list(3, ECL_SYM("PROGN",674), v15unsafe_pop, ECL_T);
      T1 = cl_list(3, ECL_SYM("AND",89), v11pointer, T0);
      LC12dm_v(lex0, v23sv, T1);
      goto L73;
L79:;
      T0 = cl_list(3, ECL_SYM("PROG1",672), v13unsafe_car, v15unsafe_pop);
      T1 = cl_list(4, ECL_SYM("IF",950), v11pointer, T0, v22init);
      LC12dm_v(lex0, v21x, T1);
     }
L73:;
     v20i = ecl_one_plus(v20i);
L71:;
     if (!(ecl_lower(v20i,v19))){
      goto L84;
     }
     goto L70;
L84:;
    }
   }
   if (Null(v6)){
    goto L86;
   }
   LC12dm_v(lex0, v6, v11pointer);
   v16no_check = ECL_T;
L86:;
   {
    cl_object v19;
    {
     cl_object v20;
     v20 = v8;
     {
      cl_object v21;
      v21 = v20;
      {
       bool v22;
       v22 = ECL_LISTP(v21);
       if (ecl_unlikely(!(v22)))
         FEwrong_type_argument(VV[27],v21);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v20)){
      goto L96;
     }
     {
      cl_object v21;
      v21 = ECL_CONS_CDR(v20);
      v8 = v21;
      v20 = ECL_CONS_CAR(v20);
     }
L96:;
     v19 = v20;
    }
    {
     cl_object v20i;
     v20i = ecl_make_int8_t(0);
     goto L104;
L103:;
     {
      cl_object v21temp;
      cl_object v22k;
      cl_object v23v;
      cl_object v24init;
      cl_object v25sv;
      v21temp = LC10tempsym(lex0);
      v22k = ecl_car(v8);
      v23v = ecl_cadr(v8);
      v24init = ecl_caddr(v8);
      v25sv = ecl_cadddr(v8);
      v16no_check = ECL_T;
      v8 = ecl_cddddr(v8);
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v22k);
      T1 = cl_list(3, VV[0], v11pointer, T0);
      LC12dm_v(lex0, v21temp, T1);
      T0 = cl_list(3, ECL_SYM("EQ",335), v21temp, VV[28]);
      T1 = cl_list(4, ECL_SYM("IF",950), T0, v24init, v21temp);
      LC12dm_v(lex0, v23v, T1);
      if (Null(v25sv)){
       goto L118;
      }
      T0 = cl_list(3, ECL_SYM("EQ",335), v21temp, VV[28]);
      T1 = cl_list(2, ECL_SYM("NOT",586), T0);
      LC12dm_v(lex0, v25sv, T1);
L118:;
      v18all_keywords = CONS(v22k,v18all_keywords);
     }
     v20i = ecl_one_plus(v20i);
L104:;
     if (!(ecl_lower(v20i,v19))){
      goto L123;
     }
     goto L103;
L123:;
    }
   }
   {
    cl_object v19l;
    v19l = ecl_cdr(v10);
    goto L129;
L128:;
    {
     cl_object v20v;
     cl_object v21init;
     v20v = ecl_car(v19l);
     v21init = ecl_cadr(v19l);
     LC12dm_v(lex0, v20v, v21init);
    }
    v19l = ecl_cddr(v19l);
L129:;
    if (ecl_endp(v19l)) {
     goto L136;
    }
    goto L128;
L136:;
   }
   if (Null(v7)){
    goto L139;
   }
   T0 = cl_list(2, ECL_SYM("QUOTE",682), v18all_keywords);
   if (Null(v9)){
    goto L143;
   }
   T1 = VV[29];
   goto L142;
L143:;
   T1 = ECL_NIL;
L142:;
   T2 = cl_listX(4, VV[2], v11pointer, T0, T1);
   T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,VV[14]));
   ecl_cmp_setq(cl_env_copy,VV[14],T3);
   goto L138;
L139:;
   if (v16no_check!=ECL_NIL) {
    goto L138;
   }
   T0 = cl_list(2, VV[6], lex0[0]);
   T1 = cl_list(3, ECL_SYM("IF",950), v11pointer, T0);
   T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[14]));
   ecl_cmp_setq(cl_env_copy,VV[14],T2);
L138:;
   value0 = v17ppn;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function TEMPSYM                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC10tempsym(volatile cl_object *lex0)
{
 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 v1x;
  v1x = cl_gensym(0);
  lex0[1] = CONS(v1x,lex0[1]);
  value0 = v1x;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function LOCAL-FUN-ERROR-FUNCTION                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC19local_fun_error_function(cl_object v1name)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1name,env0);                 /*  NAME                    */
 {
  cl_object v2;
  v2 = ecl_make_cclosure_va((cl_objectfn)LC18__lambda100,env0,Cblock,2);
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC19local_fun_error_function_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[45]);
 {
  return LC19local_fun_error_function(v3name);
 }
}
/* local function LOCAL-VAR-ERROR-FUNCTION                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC17local_var_error_function(cl_object v1name)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1name,env0);                 /*  NAME                    */
 {
  cl_object v2;
  v2 = ecl_make_cclosure_va((cl_objectfn)LC16__lambda98,env0,Cblock,2);
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC17local_var_error_function_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[42]);
 {
  return LC17local_var_error_function(v3name);
 }
}
/* local function LAMBDA118                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC21__lambda118(cl_object v1x)
{
 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 v2name;
  cl_object v3llist;
  cl_object v4def;
  v2name = ecl_car(v1x);
  v3llist = ecl_cadr(v1x);
  v4def = ecl_cddr(v1x);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v2name);
  T1 = L14expand_defmacro(3, v2name, v3llist, v4def);
  value0 = cl_list(3, ECL_SYM("LIST",483), T0, T1);
  return value0;
 }
}
static cl_object LC21__lambda118_va(cl_narg narg, cl_object v5x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[49]);
 {
  return LC21__lambda118(v5x);
 }
}
/* closure LAMBDA100                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC18__lambda100(cl_narg narg, cl_object v1whole, cl_object v2env, ...)
{
 cl_object CLV0;
 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 ... */
 CLV0 = env0;                                     /*  NAME                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[46]);
 {
L1:;
  value0 = cl_error(2, VV[47], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA98                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC16__lambda98(cl_narg narg, cl_object v1whole, cl_object v2env, ...)
{
 cl_object CLV0;
 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 ... */
 CLV0 = env0;                                     /*  NAME                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[43]);
 {
L1:;
  value0 = cl_error(2, VV[44], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
#include "lsp/defmacro.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl1E5Ab5Y4R0bi9_ifazL881(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;DEFMACRO.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl1E5Ab5Y4R0bi9_ifazL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[56]);                          /*  SEARCH-KEYWORD          */
  ecl_cmp_defun(VV[57]);                          /*  CHECK-KEYWORD           */
  ecl_cmp_defun(VV[58]);                          /*  DM-TOO-MANY-ARGUMENTS   */
  ecl_cmp_defun(VV[59]);                          /*  DM-TOO-FEW-ARGUMENTS    */
  ecl_cmp_defun(VV[60]);                          /*  DESTRUCTURE             */
  ecl_cmp_defun(VV[61]);                          /*  FIND-DOCUMENTATION      */
  ecl_cmp_defun(VV[62]);                          /*  REMOVE-DOCUMENTATION    */
  ecl_cmp_defun(VV[63]);                          /*  FIND-DECLARATIONS       */
  ecl_cmp_defun(VV[64]);                          /*  EXPAND-DEFMACRO         */
  ecl_cmp_defmacro(VV[65]);                       /*  DESTRUCTURING-BIND      */
  (void)0; /* No entry created for CMP-ENV-FOR-BYTECODES */
  (void)0; /* No entry created for MACROLET-FUNCTIONS */
  ecl_cmp_defun(VV[66]);                          /*  CMP-ENV-REGISTER-MACROLET */
}
