/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/walk.lsp                       */
#include <ecl/ecl-cmp.h>
#include "clos/walk.eclh"
/* function definition for UNBOUND-LEXICAL-FUNCTION                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2931unbound_lexical_function(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  va_list args; va_start(args,narg);
  va_end(args);
  value0 = cl_error(1, VV[3]);
  return value0;
 }
}
/* local function WITH-AUGMENTED-ENVIRONMENT                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2932with_augmented_environment(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 v4;
  cl_object v5;
  cl_object v6new_env;
  cl_object v7old_env;
  cl_object v8;
  cl_object v9functions;
  cl_object v10;
  cl_object v11macros;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v12;
   v12 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v12;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v12;
   v12 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6new_env = v12;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v12;
   v12 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7old_env = v12;
  }
  v8 = si_search_keyword(v5, VV[7]);
  if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L24;
  }
  v9functions = ECL_NIL;
  goto L23;
L24:;
  v9functions = v8;
L23:;
  v10 = si_search_keyword(v5, VV[8]);
  if (!((v10)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L28;
  }
  v11macros = ECL_NIL;
  goto L27;
L28:;
  v11macros = v10;
L27:;
  si_check_keyword(2, v5, VV[11]);
  T0 = cl_list(4, VV[12], v7old_env, v9functions, v11macros);
  T1 = cl_list(2, v6new_env, T0);
  T2 = ecl_list1(T1);
  value0 = cl_listX(3, ECL_SYM("LET",479), T2, v3);
  return value0;
 }
}
static cl_object LC2932with_augmented_environment_va(cl_narg narg, cl_object v12, cl_object v13, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[9]);
 {
  return LC2932with_augmented_environment(v12, v13);
 }
}
/* function definition for WITH-AUGMENTED-ENVIRONMENT-INTERNAL                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2933with_augmented_environment_internal(cl_object v1env, cl_object v2functions, cl_object v3macros)
{
 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 v4vars;
  cl_object v5funs;
  v4vars = ecl_car(v1env);
  v5funs = ecl_cdr(v1env);
  {
   cl_object v6;
   v6 = v2functions;
   goto L8;
L7:;
   {
    cl_object v7f;
    v7f = ecl_car(v6);
    T0 = ecl_car(v7f);
    T1 = ecl_fdefinition(VV[2]);
    T2 = cl_list(3, T0, ECL_SYM("FUNCTION",398), T1);
    v5funs = CONS(T2,v5funs);
   }
   v6 = ecl_cdr(v6);
L8:;
   if (Null(v6)){
    goto L17;
   }
   goto L7;
L17:;
  }
  {
   cl_object v6;
   v6 = v3macros;
   goto L23;
L22:;
   {
    cl_object v7m;
    v7m = ecl_car(v6);
    T0 = ecl_car(v7m);
    T1 = ecl_cadr(v7m);
    T2 = cl_list(3, T0, VV[14], T1);
    v5funs = CONS(T2,v5funs);
   }
   v6 = ecl_cdr(v6);
L23:;
   if (Null(v6)){
    goto L31;
   }
   goto L22;
L31:;
  }
  value0 = CONS(v4vars,v5funs);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2933with_augmented_environment_internal_va(cl_narg narg, cl_object v6env, cl_object v7functions, cl_object v8macros, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[12]);
 {
  return L2933with_augmented_environment_internal(v6env, v7functions, v8macros);
 }
}
/* function definition for ENVIRONMENT-MACRO                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2934environment_macro(cl_object v1env, cl_object v2macro)
{
 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(v1env)){
  goto L2;
 }
 {
  cl_object v3entry;
  {
   cl_object v4;
   cl_object v5;
   cl_object v6;
   v4 = ecl_cdr(v1env);
   v5 = v2macro;
   v6 = v4;
   v3entry = ecl_assql(v5,v6);
  }
  if (Null(v3entry)){
   goto L9;
  }
  T0 = ecl_cadr(v3entry);
  if (!((T0)==(VV[14]))){
   goto L9;
  }
  value0 = ecl_caddr(v3entry);
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function WITH-NEW-DEFINITION-IN-ENVIRONMENT                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2935with_new_definition_in_environment(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16;
 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 v4;
  cl_object v5;
  cl_object v6new_env;
  cl_object v7old_env;
  cl_object v8macrolet_flet_labels_form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v9;
   v9 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v9;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v9;
   v9 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6new_env = v9;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v9;
   v9 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7old_env = v9;
  }
  if (!(v5==ECL_NIL)){
   goto L23;
  }
  si_dm_too_few_arguments(v1);
L23:;
  {
   cl_object v9;
   v9 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v8macrolet_flet_labels_form = v9;
  }
  if (Null(v5)){
   goto L28;
  }
  si_dm_too_many_arguments(v1);
L28:;
  {
   cl_object v9functions;
   cl_object v10macros;
   v9functions = cl_make_symbol(VV[19]);
   v10macros = cl_make_symbol(VV[20]);
   T0 = cl_list(2, v9functions, ECL_NIL);
   T1 = cl_list(2, v10macros, ECL_NIL);
   T2 = cl_list(2, T0, T1);
   T3 = cl_list(2, ECL_SYM("CAR",182), v8macrolet_flet_labels_form);
   T4 = cl_list(2, ECL_SYM("SECOND",743), v8macrolet_flet_labels_form);
   T5 = cl_list(2, VV[22], T4);
   T6 = cl_list(3, ECL_SYM("PUSH",680), VV[22], v9functions);
   T7 = cl_list(3, ECL_SYM("DOLIST",315), T5, T6);
   T8 = cl_list(2, VV[21], T7);
   T9 = cl_list(2, ECL_SYM("SECOND",743), v8macrolet_flet_labels_form);
   T10 = cl_list(2, VV[24], T9);
   T11 = cl_list(3, ECL_SYM("PUSH",680), VV[25], v10macros);
   T12 = cl_list(3, ECL_SYM("DOLIST",315), T10, T11);
   T13 = cl_list(2, VV[23], T12);
   T14 = cl_list(4, ECL_SYM("ECASE",323), T3, T8, T13);
   T15 = cl_list(6, v6new_env, v7old_env, VV[7], v9functions, VV[8], v10macros);
   T16 = cl_listX(3, VV[9], T15, v3);
   value0 = cl_list(4, ECL_SYM("LET",479), T2, T14, T16);
   return value0;
  }
 }
}
static cl_object LC2935with_new_definition_in_environment_va(cl_narg narg, cl_object v11, cl_object v12, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[17]);
 {
  return LC2935with_new_definition_in_environment(v11, v12);
 }
}
/* function definition for CONVERT-MACRO-TO-LAMBDA                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2936convert_macro_to_lambda(cl_narg narg, cl_object v1llist, cl_object v2body, ...)
{
 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<2)) FEwrong_num_arguments(VV[28]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[28]);
 {
  cl_object v3name;
  va_list args; va_start(args,v2body);
  {
   int i = 2;
   if (i >= narg) {
    v3name = VV[27];
   } else {
    i++;
    v3name = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4gensym;
   v4gensym = cl_make_symbol(v3name);
   T0 = cl_listX(4, ECL_SYM("DEFMACRO",285), v4gensym, v1llist, v2body);
   cl_eval(T0);
   value0 = cl_macro_function(1, v4gensym);
   return value0;
  }
 }
}
/* local function WALKER-ENVIRONMENT-BIND                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2937walker_environment_bind(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 v4;
  cl_object v5;
  cl_object v6var;
  cl_object v7env;
  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);
   v4 = v8;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6var = v8;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7env = v8;
  }
  T0 = cl_listX(3, VV[30], v7env, v5);
  T1 = cl_list(4, v6var, v7env, VV[8], T0);
  value0 = cl_listX(3, VV[9], T1, v3);
  return value0;
 }
}
static cl_object LC2937walker_environment_bind_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[29]);
 {
  return LC2937walker_environment_bind(v8, v9);
 }
}
/* function definition for ENV-LOCK                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2938env_lock(cl_object v1env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L2934environment_macro(v1env, ecl_cmp_symbol_value(cl_env_copy,VV[32]));
 return value0;
}
/* function definition for WALKER-ENVIRONMENT-BIND-1                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2939walker_environment_bind_1(cl_narg narg, cl_object v1env, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[30]);
 {
  cl_object v2walk_function;
  cl_object v3wfnp;
  cl_object v4walk_form;
  cl_object v5wfop;
  cl_object v6declarations;
  cl_object v7decp;
  cl_object v8lexical_variables;
  cl_object v9lexp;
  ecl_va_list args; ecl_va_start(args,v1env,narg,1);
  {
   cl_object keyvars[8];
   cl_parse_key(args,4,L2939walker_environment_bind_1keys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v2walk_function = keyvars[0];
   v3wfnp = keyvars[4];
   v4walk_form = keyvars[1];
   v5wfop = keyvars[5];
   v6declarations = keyvars[2];
   v7decp = keyvars[6];
   v8lexical_variables = keyvars[3];
   v9lexp = keyvars[7];
  }
  {
   cl_object v10lock;
   v10lock = L2938env_lock(v1env);
   T0 = ecl_cmp_symbol_value(cl_env_copy,VV[32]);
   if (Null(v3wfnp)){
    goto L4;
   }
   T1 = v2walk_function;
   goto L3;
L4:;
   T1 = ecl_car(v10lock);
L3:;
   if (Null(v5wfop)){
    goto L7;
   }
   T2 = v4walk_form;
   goto L6;
L7:;
   T2 = ecl_cadr(v10lock);
L6:;
   if (Null(v7decp)){
    goto L10;
   }
   T3 = v6declarations;
   goto L9;
L10:;
   T3 = ecl_caddr(v10lock);
L9:;
   if (Null(v9lexp)){
    goto L13;
   }
   T4 = v8lexical_variables;
   goto L12;
L13:;
   T4 = ecl_cadddr(v10lock);
L12:;
   T5 = cl_list(4, T1, T2, T3, T4);
   T6 = cl_list(2, T0, T5);
   value0 = ecl_list1(T6);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for ENV-WALK-FUNCTION                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2940env_walk_function(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = L2938env_lock(v1env);
 value0 = ecl_car(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for ENV-WALK-FORM                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2941env_walk_form(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = L2938env_lock(v1env);
 value0 = ecl_cadr(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for ENV-DECLARATIONS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2942env_declarations(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = L2938env_lock(v1env);
 value0 = ecl_caddr(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for ENV-LEXICAL-VARIABLES                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2943env_lexical_variables(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = L2938env_lock(v1env);
 value0 = ecl_cadddr(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for NOTE-DECLARATION                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2944note_declaration(cl_object v1declaration, cl_object v2env)
{
 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 v4;
  v3 = L2938env_lock(v2env);
  T0 = ecl_caddr(v3);
  v4 = CONS(v1declaration,T0);
  {
   cl_object v5;
   v5 = ecl_cddr(v3);
   if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   T0 = v5;
  }
  (ECL_CONS_CAR(T0)=v4,T0);
  value0 = v4;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for NOTE-LEXICAL-BINDING                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2945note_lexical_binding(cl_object v1thing, cl_object v2env)
{
 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 v4;
  cl_object v5;
  v3 = cl_list(2, v1thing, VV[40]);
  v4 = L2938env_lock(v2env);
  T0 = ecl_cadddr(v4);
  v5 = CONS(v3,T0);
  {
   cl_object v6;
   v6 = ecl_cdddr(v4);
   if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   T0 = v6;
  }
  (ECL_CONS_CAR(T0)=v5,T0);
  value0 = v5;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2945note_lexical_binding_va(cl_narg narg, cl_object v6thing, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[39]);
 {
  return L2945note_lexical_binding(v6thing, v7env);
 }
}
/* function definition for VARIABLE-LEXICAL-P                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2946variable_lexical_p(cl_object v1var, cl_object v2env)
{
 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 v3entry;
  {
   cl_object v4;
   cl_object v5;
   v4 = L2943env_lexical_variables(v2env);
   v5 = (ECL_SYM("CAR",182)->symbol.gfdef);
   {
    cl_object v6;
    v6 = v4;
    goto L8;
L7:;
    {
     cl_object v7;
     cl_object v8;
     {
      cl_object v9;
      v9 = v6;
      if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v9;
     }
     v8 = ECL_CONS_CAR(v7);
     T0 = ecl_car(v8);
     if (!(ecl_eql(v1var,T0))){
      goto L10;
     }
     v3entry = v7;
     goto L2;
    }
L10:;
    v6 = ECL_CONS_CDR(v6);
L8:;
    if (v6==ECL_NIL) {
     goto L18;
    }
    goto L7;
L18:;
    v3entry = ECL_NIL;
   }
  }
L2:;
  T0 = ecl_cadar(v3entry);
  if (!((T0)==(VV[40]))){
   goto L20;
  }
  value0 = v3entry;
  cl_env_copy->nvalues = 1;
  return value0;
L20:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for VARIABLE-SYMBOL-MACRO-P                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2947variable_symbol_macro_p(cl_object v1var, cl_object v2env)
{
 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 v3entry;
  {
   cl_object v4;
   cl_object v5;
   v4 = L2943env_lexical_variables(v2env);
   v5 = (ECL_SYM("CAR",182)->symbol.gfdef);
   {
    cl_object v6;
    v6 = v4;
    goto L8;
L7:;
    {
     cl_object v7;
     cl_object v8;
     {
      cl_object v9;
      v9 = v6;
      if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v9;
     }
     v8 = ECL_CONS_CAR(v7);
     T0 = ecl_car(v8);
     if (!(ecl_eql(v1var,T0))){
      goto L10;
     }
     v3entry = v7;
     goto L2;
    }
L10:;
    v6 = ECL_CONS_CDR(v6);
L8:;
    if (v6==ECL_NIL) {
     goto L18;
    }
    goto L7;
L18:;
    v3entry = ECL_NIL;
   }
  }
L2:;
  T0 = ecl_cadar(v3entry);
  if (!((T0)==(VV[47]))){
   goto L20;
  }
  value0 = v3entry;
  cl_env_copy->nvalues = 1;
  return value0;
L20:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for VARIABLE-DECLARATION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2948variable_declaration(cl_object v1declaration, cl_object v2var, cl_object v3env)
{
 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 v4;
  cl_object v5;
  cl_object v6;
  v4 = ecl_cmp_symbol_value(cl_env_copy,VV[48]);
  v5 = v1declaration;
  v6 = v4;
  if (ecl_memql(v5,v6)!=ECL_NIL) {
   goto L2;
  }
 }
 value0 = cl_error(2, VV[50], v1declaration);
 return value0;
L2:;
 {
  cl_object v4id;
  value0 = L2946variable_lexical_p(v2var, v3env);
  if (value0!=ECL_NIL) {
   goto L9;
  }
  v4id = v2var;
  goto L7;
L9:;
  v4id = value0;
  goto L7;
L7:;
  {
   cl_object v5;
   v5 = L2942env_declarations(v3env);
   goto L14;
L13:;
   {
    cl_object v6decl;
    v6decl = ecl_car(v5);
    T0 = ecl_car(v6decl);
    if (!((T0)==(v1declaration))){
     goto L18;
    }
    T0 = ecl_cadr(v6decl);
    if ((T0)==(v4id)) {
     goto L21;
    }
    T0 = ecl_car(v6decl);
    if (!((ECL_SYM("TYPE",872))==(T0))){
     goto L18;
    }
    {
     cl_object v7;
     cl_object v8;
     cl_object v9;
     cl_object v10;
     v7 = ecl_cddr(v6decl);
     v8 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v9 = v2var;
     v10 = v7;
     if (Null(si_memq(v9,v10))){
      goto L18;
     }
     goto L19;
    }
L21:;
L19:;
    value0 = v6decl;
    cl_env_copy->nvalues = 1;
    return value0;
L18:;
   }
   v5 = ecl_cdr(v5);
L14:;
   if (Null(v5)){
    goto L30;
   }
   goto L13;
L30:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L2948variable_declaration_va(cl_narg narg, cl_object v6declaration, cl_object v7var, cl_object v8env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[49]);
 {
  return L2948variable_declaration(v6declaration, v7var, v8env);
 }
}
/* function definition for VARIABLE-SPECIAL-P                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2949variable_special_p(cl_object v1var, cl_object v2env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = L2948variable_declaration(ECL_SYM("SPECIAL",792), v1var, v2env);
 {
  bool v3;
  v3 = T0==ECL_NIL;
  value0 = (v3)?ECL_NIL:ECL_T;
 }
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = L2950variable_globally_special_p(v1var);
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2949variable_special_p_va(cl_narg narg, cl_object v3var, cl_object v4env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return L2949variable_special_p(v3var, v4env);
 }
}
/* function definition for VARIABLE-GLOBALLY-SPECIAL-P                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2950variable_globally_special_p(cl_object v1symbol)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = si_specialp(v1symbol);
 return value0;
}
static cl_object L2950variable_globally_special_p_va(cl_narg narg, cl_object v2symbol, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[53]);
 {
  return L2950variable_globally_special_p(v2symbol);
 }
}
/* local function GET-WALKER-TEMPLATE-INTERNAL                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2951get_walker_template_internal(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 v4x;
  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);
   v4x = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = cl_list(3, ECL_SYM("GET-SYSPROP",1093), v4x, VV[57]);
  return value0;
 }
}
static cl_object LC2951get_walker_template_internal_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[56]);
 {
  return LC2951get_walker_template_internal(v5, v6);
 }
}
/* local function DEFINE-WALKER-TEMPLATE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2952define_walker_template(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 v4name;
  cl_object v5template;
  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 (Null(v3)){
   goto L10;
  }
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5template = v6;
   goto L9;
  }
L10:;
  v5template = VV[59];
L9:;
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), v5template);
  T2 = cl_list(4, ECL_SYM("PUT-SYSPROP",1150), T0, VV[57], T1);
  value0 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[61], T2);
  return value0;
 }
}
static cl_object LC2952define_walker_template_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[60]);
 {
  return LC2952define_walker_template(v6, v7);
 }
}
/* function definition for GET-WALKER-TEMPLATE                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2953get_walker_template(cl_object v1x)
{
 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_SYMBOLP(v1x))){
  goto L2;
 }
 value0 = si_get_sysprop(v1x, VV[64]);
 if (value0!=ECL_NIL) {
  goto L5;
 }
 value0 = L2954get_implementation_dependent_walker_template(v1x);
 return value0;
L5:;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_LISTP(v1x))){
  goto L7;
 }
 T0 = ecl_car(v1x);
 if (!((T0)==(ECL_SYM("LAMBDA",454)))){
  goto L7;
 }
 value0 = VV[66];
 cl_env_copy->nvalues = 1;
 return value0;
L7:;
 value0 = cl_error(2, VV[67], v1x);
 return value0;
}
static cl_object L2953get_walker_template_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[63]);
 {
  return L2953get_walker_template(v2x);
 }
}
/* function definition for GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2954get_implementation_dependent_walker_template(cl_object v1x)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2954get_implementation_dependent_walker_template_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[65]);
 {
  return L2954get_implementation_dependent_walker_template(v2x);
 }
}
/* function definition for MACROEXPAND-ALL                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2955macroexpand_all(cl_narg narg, cl_object v1form, ...)
{
 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[95]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[95]);
 {
  cl_object v2environment;
  va_list args; va_start(args,v1form);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  ecl_bds_bind(cl_env_copy,VV[94],ECL_T);         /*  WALK-FORM-EXPAND-MACROS-P */
  value0 = L2957walk_form(2, v1form, v2environment);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
/* function definition for WALK-FORM                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2957walk_form(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[96]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[96]);
 {
  cl_object v2environment;
  cl_object v3walk_function;
  va_list args; va_start(args,v1form);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
   if (i >= narg) {
    {
     cl_object v4;
     v4 = ecl_make_cfun_va((cl_objectfn)LC2956__lambda161_va,ECL_NIL,Cblock,3);
     v3walk_function = v4;
    }
   } else {
    i++;
    v3walk_function = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4new_env;
   T0 = L2939walker_environment_bind_1(3, v2environment, VV[99], v3walk_function);
   v4new_env = L2933with_augmented_environment_internal(v2environment, ECL_NIL, T0);
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v1form, VV[101], v4new_env) /*  WALK-FORM-INTERNAL */;
   return value0;
  }
 }
}
/* function definition for WALK-FORM-INTERNAL                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2958walk_form_internal(cl_object volatile v1form, cl_object volatile v2context, cl_object volatile v3env)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v4fn;
  volatile cl_object v5template;
  v4fn = ECL_NIL;
  v5template = ECL_NIL;
  value0 = v1form;                                /*  BEGIN CATCH CATCH426    */
  {
   ecl_frs_push(cl_env_copy,value0);
   if (__ecl_frs_push_result!=0) {
    value0 = cl_env_copy->values[0];
   } else {
    {
     cl_object volatile v6;                       /*  NEWFORM                 */
     cl_object volatile v7;                       /*  WALK-NO-MORE-P          */
     T0 = L2940env_walk_function(v3env);
     value0 = ecl_function_dispatch(cl_env_copy,T0)(3, v1form, v2context, v3env);
     {
      const int v8 = cl_env_copy->nvalues;
      v6 = value0;
      cl_object v9;
      v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
      v7 = v9;
     }
     value0 = v6;                                 /*  BEGIN CATCH CATCH427    */
     {
      ecl_frs_push(cl_env_copy,value0);
      if (__ecl_frs_push_result!=0) {
       value0 = cl_env_copy->values[0];
      } else {
       if (Null(v7)){
        goto L11;
       }
       value0 = v6;
       cl_env_copy->nvalues = 1;
       goto L10;
L11:;
       if ((v1form)==(v6)) {
        goto L13;
       }
       value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v6, v2context, v3env) /*  WALK-FORM-INTERNAL */;
       goto L10;
L13:;
       if (ECL_CONSP(v6)) {
        goto L15;
       }
       {
        cl_object v8symmac;
        T0 = L2947variable_symbol_macro_p(v6, v3env);
        v8symmac = ecl_car(T0);
        if (Null(v8symmac)){
         goto L18;
        }
        {
         cl_object v9newnewform;
         T0 = ecl_cddr(v8symmac);
         v9newnewform = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T0, v2context, v3env) /*  WALK-FORM-INTERNAL */;
         T0 = ecl_cddr(v8symmac);
         if (!((v9newnewform)==(T0))){
          goto L21;
         }
         if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[94]))){
          goto L23;
         }
         value0 = v9newnewform;
         cl_env_copy->nvalues = 1;
         goto L10;
L23:;
         value0 = v6;
         cl_env_copy->nvalues = 1;
         goto L10;
L21:;
         value0 = v9newnewform;
         cl_env_copy->nvalues = 1;
         goto L10;
        }
L18:;
        value0 = v6;
        cl_env_copy->nvalues = 1;
        goto L10;
       }
L15:;
       v4fn = ecl_car(v6);
       v5template = L2953get_walker_template(v4fn);
       if (Null(v5template)){
        goto L25;
       }
       if (!(ECL_SYMBOLP(v5template))){
        goto L29;
       }
       value0 = ecl_function_dispatch(cl_env_copy,v5template)(3, v6, v2context, v3env);
       goto L10;
L29:;
       value0 = L2959walk_template(v6, v5template, v2context, v3env);
       goto L10;
L25:;
       {
        cl_object volatile v10;                   /*  NEWNEWFORM              */
        cl_object volatile v11;                   /*  MACROP                  */
        {
         cl_object v12new_env;
         T0 = L2939walker_environment_bind_1(3, v3env, VV[104], v6);
         v12new_env = L2933with_augmented_environment_internal(v3env, ECL_NIL, T0);
         value0 = cl_macroexpand_1(2, v6, v12new_env);
        }
        {
         v10 = value0;
         v11 = cl_env_copy->values[1];
        }
        if (Null(v11)){
         goto L33;
        }
        {
         cl_object v12newnewnewform;
         v12newnewnewform = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v10, v2context, v3env) /*  WALK-FORM-INTERNAL */;
         if (!((v12newnewnewform)==(v10))){
          goto L36;
         }
         if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[94]))){
          goto L38;
         }
         value0 = v10;
         cl_env_copy->nvalues = 1;
         goto L10;
L38:;
         value0 = v6;
         cl_env_copy->nvalues = 1;
         goto L10;
L36:;
         value0 = v12newnewnewform;
         cl_env_copy->nvalues = 1;
         goto L10;
        }
L33:;
        if (!(ECL_SYMBOLP(v4fn))){
         goto L40;
        }
        if (cl_fboundp(v4fn)!=ECL_NIL) {
         goto L40;
        }
        if (Null(cl_special_operator_p(v4fn))){
         goto L40;
        }
        value0 = cl_error(2, VV[105], v4fn);
        goto L10;
L40:;
        value0 = L2959walk_template(v10, VV[106], v2context, v3env);
       }
L10:;
      }
     }
     ecl_frs_pop(cl_env_copy);                    /*  END CATCH CATCH427      */
    }
   }
  }
  ecl_frs_pop(cl_env_copy);                       /*  END CATCH CATCH426      */
  return value0;
 }
}
static cl_object L2958walk_form_internal_va(cl_narg narg, cl_object v6form, cl_object v7context, cl_object v8env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[100]);
 {
  return L2958walk_form_internal(v6form, v7context, v8env);
 }
}
/* function definition for WALK-TEMPLATE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2959walk_template(cl_object v1form, cl_object v2template, cl_object v3context, cl_object v4env)
{
 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:;
 if (!(ECL_ATOM(v2template))){
  goto L2;
 }
 {
  cl_object v5;
  cl_object v6;
  v5 = v2template;
  v6 = VV[108];
  if (Null(ecl_memql(v5,v6))){
   goto L4;
  }
 }
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v1form, VV[101], v4env) /*  WALK-FORM-INTERNAL */;
 return value0;
L4:;
 if (!((v2template)==(ECL_SYM("QUOTE",682)))){
  goto L13;
 }
 goto L10;
L13:;
 goto L11;
L11:;
 if (!((v2template)==(ECL_NIL))){
  goto L8;
 }
 goto L9;
L10:;
L9:;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
L8:;
 if (!((v2template)==(ECL_SYM("SET",746)))){
  goto L16;
 }
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v1form, VV[111], v4env) /*  WALK-FORM-INTERNAL */;
 return value0;
L16:;
 if (!((v2template)==(ECL_SYM("LAMBDA",454)))){
  goto L23;
 }
 goto L20;
L23:;
 goto L21;
L21:;
 if (!((v2template)==(VV[113]))){
  goto L18;
 }
 goto L19;
L20:;
L19:;
 if (ECL_SYMBOLP(v1form)) {
  goto L28;
 }
 if (!(ECL_LISTP(v1form))){
  goto L26;
 }
 {
  cl_fixnum v5;
  v5 = ecl_length(v1form);
  if (!((v5)==((cl_fixnum)(2)))){
   goto L26;
  }
 }
 T0 = ecl_car(v1form);
 if (!((T0)==(ECL_SYM("SETF",753)))){
  goto L26;
 }
 goto L27;
L28:;
L27:;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
L26:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v1form, v3context, v4env) /*  WALK-FORM-INTERNAL */;
 return value0;
L18:;
 value0 = si_ecase_error(v2template, VV[115]);
 return value0;
L2:;
 {
  cl_object v5;
  v5 = ecl_car(v2template);
  if (!((v5)==(VV[116]))){
   goto L33;
  }
  T0 = ecl_cdr(v2template);
  T2 = ecl_cddr(v2template);
  if (!(T2==ECL_NIL)){
   goto L36;
  }
  T1 = ECL_NIL;
  goto L35;
L36:;
  {
   cl_fixnum v6;
   v6 = ecl_length(v1form);
   T2 = ecl_cddr(v2template);
   {
    cl_fixnum v7;
    v7 = ecl_length(T2);
    T3 = ecl_minus(ecl_make_fixnum(v6),ecl_make_fixnum(v7));
    T1 = ecl_nthcdr(ecl_to_size(T3),v1form);
   }
  }
L35:;
  value0 = L2960walk_template_handle_repeat(v1form, T0, T1, v3context, v4env);
  return value0;
L33:;
  if (!((v5)==(ECL_SYM("IF",950)))){
   goto L38;
  }
  T0 = v1form;
  T1 = ecl_cadr(v2template);
  if (!(ECL_LISTP(T1))){
   goto L45;
  }
  T1 = ecl_cadr(v2template);
  if (Null(cl_eval(T1))){
   goto L43;
  }
  goto L44;
L45:;
  T1 = ecl_cadr(v2template);
  if (Null(ecl_function_dispatch(cl_env_copy,T1)(1, v1form))){
   goto L43;
  }
L44:;
  v2template = ecl_caddr(v2template);
  goto L42;
L43:;
  v2template = ecl_cadddr(v2template);
L42:;
  v1form = T0;
  goto L1;
L38:;
  if (!((v5)==(VV[118]))){
   goto L49;
  }
  v2template = ecl_cadr(v2template);
  goto L1;
L49:;
  if (!(ECL_ATOM(v1form))){
   goto L56;
  }
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  return value0;
L56:;
  T0 = ecl_car(v1form);
  T1 = ecl_car(v2template);
  T2 = L2959walk_template(T0, T1, v3context, v4env);
  T3 = ecl_cdr(v1form);
  T4 = ecl_cdr(v2template);
  T5 = L2959walk_template(T3, T4, v3context, v4env);
  value0 = L2963recons(v1form, T2, T5);
  return value0;
 }
}
/* function definition for WALK-TEMPLATE-HANDLE-REPEAT                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2960walk_template_handle_repeat(cl_object v1form, cl_object v2template, cl_object v3stop_form, cl_object v4context, cl_object v5env)
{
 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 (!((v1form)==(v3stop_form))){
  goto L2;
 }
 T0 = ecl_cdr(v2template);
 value0 = L2959walk_template(v1form, T0, v4context, v5env);
 return value0;
L2:;
 T0 = ecl_car(v2template);
 value0 = L2961walk_template_handle_repeat_1(v1form, v2template, T0, v3stop_form, v4context, v5env);
 return value0;
}
/* function definition for WALK-TEMPLATE-HANDLE-REPEAT-1                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2961walk_template_handle_repeat_1(cl_object v1form, cl_object v2template, cl_object v3repeat_template, cl_object v4stop_form, cl_object v5context, cl_object v6env)
{
 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:;
 if (!(v1form==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v1form)==(v4stop_form))){
  goto L4;
 }
 if (!(v3repeat_template==ECL_NIL)){
  goto L6;
 }
 T0 = ecl_cdr(v2template);
 value0 = L2959walk_template(v4stop_form, T0, v5context, v6env);
 return value0;
L6:;
 value0 = cl_error(1, VV[121]);
 return value0;
L4:;
 if (!(v3repeat_template==ECL_NIL)){
  goto L8;
 }
 T0 = v2template;
 v3repeat_template = ecl_car(v2template);
 v2template = T0;
 goto L1;
L8:;
 T0 = ecl_car(v1form);
 T1 = ecl_car(v3repeat_template);
 T2 = L2959walk_template(T0, T1, v5context, v6env);
 T3 = ecl_cdr(v1form);
 T4 = ecl_cdr(v3repeat_template);
 T5 = L2961walk_template_handle_repeat_1(T3, v2template, T4, v4stop_form, v5context, v6env);
 value0 = L2963recons(v1form, T2, T5);
 return value0;
}
/* function definition for WALK-REPEAT-EVAL                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2962walk_repeat_eval(cl_object v1form, cl_object v2env)
{
 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:;
 if (Null(v1form)){
  goto L3;
 }
 T0 = ecl_car(v1form);
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T0, VV[101], v2env) /*  WALK-FORM-INTERNAL */;
 T2 = ecl_cdr(v1form);
 T3 = L2962walk_repeat_eval(T2, v2env);
 value0 = L2963recons(v1form, T1, T3);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2962walk_repeat_eval_va(cl_narg narg, cl_object v3form, cl_object v4env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[122]);
 {
  return L2962walk_repeat_eval(v3form, v4env);
 }
}
/* function definition for RECONS                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2963recons(cl_object v1x, cl_object v2car, cl_object v3cdr)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1x);
 if (!((T0)==(v2car))){
  goto L4;
 }
 T0 = ecl_cdr(v1x);
 if ((T0)==(v3cdr)) {
  goto L2;
 }
 goto L3;
L4:;
L3:;
 value0 = CONS(v2car,v3cdr);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = v1x;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2963recons_va(cl_narg narg, cl_object v4x, cl_object v5car, cl_object v6cdr, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[119]);
 {
  return L2963recons(v4x, v5car, v6cdr);
 }
}
/* function definition for RELIST                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2964relist(cl_narg narg, cl_object v1x, ...)
{
 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[125]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1x,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (!(v2args==ECL_NIL)){
   goto L1;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L1:;
  value0 = L2966relist_internal(v1x, v2args, ECL_NIL);
  return value0;
 }
}
/* function definition for RELIST*                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2965relist_(cl_narg narg, cl_object v1x, ...)
{
 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[127]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1x,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = L2966relist_internal(v1x, v2args, ECL_T);
  return value0;
 }
}
/* function definition for RELIST-INTERNAL                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2966relist_internal(cl_object v1x, cl_object v2args, cl_object v3_p)
{
 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:;
 T0 = ecl_cdr(v2args);
 if (!(T0==ECL_NIL)){
  goto L2;
 }
 if (Null(v3_p)){
  goto L4;
 }
 value0 = ecl_car(v2args);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 T0 = ecl_car(v2args);
 value0 = L2963recons(v1x, T0, ECL_NIL);
 return value0;
L2:;
 T0 = ecl_car(v2args);
 T1 = ecl_cdr(v1x);
 T2 = ecl_cdr(v2args);
 T3 = L2966relist_internal(T1, T2, v3_p);
 value0 = L2963recons(v1x, T0, T3);
 return value0;
}
/* function definition for WALK-DECLARATIONS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2967walk_declarations(cl_narg narg, cl_object v1body, cl_object v2fn, cl_object v3env, ...)
{
 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);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[128]);
 if (ecl_unlikely(narg>6)) FEwrong_num_arguments(VV[128]);
 {
  cl_object v4doc_string_p;
  cl_object v5declarations;
  cl_object v6old_body;
  va_list args; va_start(args,v3env);
  {
   int i = 3;
   if (i >= narg) {
    v4doc_string_p = ECL_NIL;
   } else {
    i++;
    v4doc_string_p = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v5declarations = ECL_NIL;
   } else {
    i++;
    v5declarations = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v6old_body = ECL_NIL;
   } else {
    i++;
    v6old_body = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v7form;
   cl_object v8macrop;
   cl_object v9new_form;
   v7form = ecl_car(v1body);
   v8macrop = ECL_NIL;
   v9new_form = ECL_NIL;
   if (!(ECL_STRINGP(v7form))){
    goto L7;
   }
   if (Null(ecl_cdr(v1body))){
    goto L7;
   }
   if (!(v4doc_string_p==ECL_NIL)){
    goto L7;
   }
   if (!(v5declarations==ECL_NIL)){
    goto L7;
   }
   T0 = ecl_cdr(v1body);
   T1 = L2967walk_declarations(4, T0, v2fn, v3env, ECL_T);
   value0 = L2963recons(v1body, v7form, T1);
   return value0;
L7:;
   if (!(ECL_LISTP(v7form))){
    goto L12;
   }
   T0 = ecl_car(v7form);
   if (!((T0)==(ECL_SYM("DECLARE",276)))){
    goto L12;
   }
   {
    cl_object v10;
    v10 = ecl_cdr(v7form);
    goto L19;
L18:;
    {
     cl_object v11declaration;
     v11declaration = ecl_car(v10);
     {
      cl_object v12type;
      cl_object v13name;
      cl_object v14args;
      v12type = ecl_car(v11declaration);
      v13name = ecl_cadr(v11declaration);
      v14args = ecl_cddr(v11declaration);
      {
       cl_object v15;
       cl_object v16;
       cl_object v17;
       v15 = ecl_cmp_symbol_value(cl_env_copy,VV[48]);
       v16 = v12type;
       v17 = v15;
       if (Null(ecl_memql(v16,v17))){
        goto L28;
       }
      }
      value0 = L2946variable_lexical_p(v13name, v3env);
      if (value0!=ECL_NIL) {
       goto L35;
      }
      T0 = v13name;
      goto L33;
L35:;
      T0 = value0;
      goto L33;
L33:;
      T1 = cl_listX(3, v12type, T0, v14args);
      L2944note_declaration(T1, v3env);
      goto L27;
L28:;
      L2944note_declaration(v11declaration, v3env);
L27:;
      v5declarations = CONS(v11declaration,v5declarations);
     }
    }
    v10 = ecl_cdr(v10);
L19:;
    if (Null(v10)){
     goto L40;
    }
    goto L18;
L40:;
   }
   T0 = ecl_cdr(v1body);
   T1 = L2967walk_declarations(5, T0, v2fn, v3env, v4doc_string_p, v5declarations);
   value0 = L2963recons(v1body, v7form, T1);
   return value0;
L12:;
   if (Null(v7form)){
    goto L42;
   }
   if (!(ECL_LISTP(v7form))){
    goto L42;
   }
   T0 = ecl_car(v7form);
   T1 = L2953get_walker_template(T0);
   if (!(T1==ECL_NIL)){
    goto L42;
   }
   value0 = cl_macroexpand_1(2, v7form, v3env);
   {
    v9new_form = value0;
    v8macrop = cl_env_copy->values[1];
   }
   if (Null(v8macrop)){
    goto L42;
   }
   T0 = ecl_cdr(v1body);
   T1 = L2963recons(v1body, v9new_form, T0);
   value0 = v6old_body;
   if (value0!=ECL_NIL) {
    goto L51;
   }
   T2 = v1body;
   goto L49;
L51:;
   T2 = value0;
   goto L49;
L49:;
   value0 = L2967walk_declarations(6, T1, v2fn, v3env, v4doc_string_p, v5declarations, T2);
   return value0;
L42:;
   value0 = v6old_body;
   if (value0!=ECL_NIL) {
    goto L55;
   }
   T0 = v1body;
   goto L53;
L55:;
   T0 = value0;
   goto L53;
L53:;
   value0 = ecl_function_dispatch(cl_env_copy,v2fn)(2, T0, v3env);
   return value0;
  }
 }
}
/* function definition for WALK-UNEXPECTED-DECLARE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2968walk_unexpected_declare(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[129], v1form) /*  WARN */;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for WALK-ARGLIST                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2969walk_arglist(cl_narg narg, cl_object v1arglist, cl_object v2context, cl_object v3env, ...)
{
 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);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[130]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[130]);
 {
  cl_object v4destructuringp;
  va_list args; va_start(args,v3env);
  {
   int i = 3;
   if (i >= narg) {
    v4destructuringp = ECL_NIL;
   } else {
    i++;
    v4destructuringp = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v5arg;
   v5arg = ECL_NIL;
   if (!(v1arglist==ECL_NIL)){
    goto L3;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L3:;
   v5arg = ecl_car(v1arglist);
   if (!(ECL_SYMBOLP(v5arg))){
    goto L5;
   }
   {
    cl_object v6;
    cl_object v7;
    v6 = v5arg;
    v7 = VV[131];
    value0 = ecl_memql(v6,v7);
   }
   if (value0!=ECL_NIL) {
    goto L10;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, v5arg, v3env) /*  NOTE-LEXICAL-BINDING */;
   goto L8;
L10:;
   goto L8;
L8:;
   T0 = ecl_cdr(v1arglist);
   if (Null(v4destructuringp)){
    goto L16;
   }
   {
    cl_object v6;
    cl_object v7;
    v6 = v5arg;
    v7 = VV[131];
    T2 = ecl_memql(v6,v7);
   }
   T1 = Null(T2)?ECL_T:ECL_NIL;
   goto L14;
L16:;
   T1 = ECL_NIL;
   goto L14;
L14:;
   T2 = L2969walk_arglist(4, T0, v2context, v3env, T1);
   value0 = L2963recons(v1arglist, v5arg, T2);
   return value0;
L5:;
   if (!(ECL_CONSP(v5arg))){
    goto L21;
   }
   {
    cl_object v6;
    if (Null(v4destructuringp)){
     goto L25;
    }
    T0 = L2969walk_arglist(4, v5arg, v2context, v3env, v4destructuringp);
    goto L24;
L25:;
    T1 = ecl_car(v5arg);
    T2 = ecl_cadr(v5arg);
    T3 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T2, VV[101], v3env) /*  WALK-FORM-INTERNAL */;
    T4 = ecl_cddr(v5arg);
    T0 = L2965relist_(4, v5arg, T1, T3, T4);
L24:;
    T1 = ecl_cdr(v1arglist);
    T2 = L2969walk_arglist(4, T1, v2context, v3env, ECL_NIL);
    v6 = L2963recons(v1arglist, T0, T2);
    T0 = ecl_car(v5arg);
    if (!(ECL_SYMBOLP(T0))){
     goto L28;
    }
    T0 = ecl_car(v5arg);
    (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, T0, v3env) /*  NOTE-LEXICAL-BINDING */;
    goto L27;
L28:;
    T0 = ecl_cadar(v5arg);
    (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, T0, v3env) /*  NOTE-LEXICAL-BINDING */;
L27:;
    T0 = ecl_cddr(v5arg);
    value0 = ecl_make_bool(T0==ECL_NIL);
    if (value0!=ECL_NIL) {
     goto L32;
    }
    T0 = ecl_caddr(v5arg);
    {
     bool v7;
     v7 = ECL_SYMBOLP(T0);
     value0 = (v7)?ECL_NIL:ECL_T;
    }
    if (value0!=ECL_NIL) {
     goto L32;
    }
    T0 = ecl_caddr(v5arg);
    (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, T0, v3env) /*  NOTE-LEXICAL-BINDING */;
    goto L30;
L32:;
    goto L30;
L30:;
    value0 = v6;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L21:;
   value0 = cl_error(2, VV[132], v1arglist);
   return value0;
  }
 }
}
/* function definition for WALK-LET                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2970walk_let(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[133]))->cfun.entry(4, v1form, v2context, v3env, ECL_NIL) /*  WALK-LET/LET* */;
 return value0;
}
static cl_object L2970walk_let_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[77]);
 {
  return L2970walk_let(v4form, v5context, v6env);
 }
}
/* function definition for WALK-LET*                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2971walk_let_(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[133]))->cfun.entry(4, v1form, v2context, v3env, ECL_T) /*  WALK-LET/LET* */;
 return value0;
}
static cl_object L2971walk_let__va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[78]);
 {
  return L2971walk_let_(v4form, v5context, v6env);
 }
}
/* function definition for WALK-PROG                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2972walk_prog(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L2979walk_prog_prog_(v1form, v2context, v3env, ECL_NIL);
 return value0;
}
static cl_object L2972walk_prog_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[90]);
 {
  return L2972walk_prog(v4form, v5context, v6env);
 }
}
/* function definition for WALK-PROG*                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2973walk_prog_(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L2979walk_prog_prog_(v1form, v2context, v3env, ECL_T);
 return value0;
}
static cl_object L2973walk_prog__va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[91]);
 {
  return L2973walk_prog_(v4form, v5context, v6env);
 }
}
/* function definition for WALK-DO                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2974walk_do(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L2980walk_do_do_(v1form, v2context, v3env, ECL_NIL);
 return value0;
}
static cl_object L2974walk_do_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[88]);
 {
  return L2974walk_do(v4form, v5context, v6env);
 }
}
/* function definition for WALK-DO*                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2975walk_do_(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L2980walk_do_do_(v1form, v2context, v3env, ECL_T);
 return value0;
}
static cl_object L2975walk_do__va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[89]);
 {
  return L2975walk_do_(v4form, v5context, v6env);
 }
}
/* function definition for WALK-LET/LET*                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2976walk_let_let_(cl_object v1form, cl_object v2context, cl_object v3old_env, cl_object v4sequentialp)
{
 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 v5new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v5new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v6let_let_;
   cl_object v7bindings;
   cl_object v8body;
   cl_object v9walked_bindings;
   cl_object v10walked_body;
   v6let_let_ = ecl_car(v1form);
   v7bindings = ecl_cadr(v1form);
   v8body = ecl_cddr(v1form);
   v9walked_bindings = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, v7bindings, v3old_env, v5new_env, v2context, v4sequentialp) /*  WALK-BINDINGS-1 */;
   T0 = ecl_fdefinition(VV[122]);
   v10walked_body = L2967walk_declarations(3, v8body, T0, v5new_env);
   value0 = L2965relist_(4, v1form, v6let_let_, v9walked_bindings, v10walked_body);
   return value0;
  }
 }
}
static cl_object L2976walk_let_let__va(cl_narg narg, cl_object v11form, cl_object v12context, cl_object v13old_env, cl_object v14sequentialp, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[133]);
 {
  return L2976walk_let_let_(v11form, v12context, v13old_env, v14sequentialp);
 }
}
/* function definition for WALK-LOCALLY                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2977walk_locally(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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 v4locally;
  cl_object v5body;
  cl_object v6walked_body;
  v4locally = ecl_car(v1form);
  v5body = ecl_cdr(v1form);
  T0 = ecl_fdefinition(VV[122]);
  v6walked_body = L2967walk_declarations(3, v5body, T0, v3env);
  value0 = L2965relist_(3, v1form, v4locally, v6walked_body);
  return value0;
 }
}
static cl_object L2977walk_locally_va(cl_narg narg, cl_object v7form, cl_object v8context, cl_object v9env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[79]);
 {
  return L2977walk_locally(v7form, v8context, v9env);
 }
}
/* function definition for WALK-PROG/PROG*                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2979walk_prog_prog_(cl_object v1form, cl_object v2context, cl_object v3old_env, cl_object v4sequentialp)
{
 cl_object T0, T1, T2, T3;
 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(v2context,env0);              /*  CONTEXT                 */
 {
  cl_object v5new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v5new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v6possible_block_name;
   cl_object v7blocked_prog;
   v6possible_block_name = ecl_cadr(v1form);
   if (!(ECL_SYMBOLP(v6possible_block_name))){
    goto L5;
   }
   {
    bool v8;
    v8 = (v6possible_block_name)==(ECL_NIL);
    v7blocked_prog = (v8)?ECL_NIL:ECL_T;
    goto L3;
   }
L5:;
   v7blocked_prog = ECL_NIL;
   goto L3;
L3:;
   {
    cl_object v8;                                 /*  LET/LET*                */
    cl_object v9;                                 /*  BLOCK-NAME              */
    cl_object v10;                                /*  BINDINGS                */
    cl_object v11;                                /*  BODY                    */
    if (Null(v7blocked_prog)){
     goto L8;
    }
    T0 = ecl_car(v1form);
    T1 = ecl_cadr(v1form);
    T2 = ecl_caddr(v1form);
    T3 = ecl_cdddr(v1form);
    cl_env_copy->nvalues = 4;
    cl_env_copy->values[3] = T3;
    cl_env_copy->values[2] = T2;
    cl_env_copy->values[1] = T1;
    cl_env_copy->values[0] = T0;
    value0 = cl_env_copy->values[0];
    goto L7;
L8:;
    T0 = ecl_car(v1form);
    T1 = ecl_cadr(v1form);
    T2 = ecl_cddr(v1form);
    cl_env_copy->nvalues = 4;
    cl_env_copy->values[3] = T2;
    cl_env_copy->values[2] = T1;
    cl_env_copy->values[1] = ECL_NIL;
    cl_env_copy->values[0] = T0;
    value0 = cl_env_copy->values[0];
L7:;
    {
     v8 = value0;
     v9 = cl_env_copy->values[1];
     v10 = cl_env_copy->values[2];
     v11 = cl_env_copy->values[3];
    }
    {
     cl_object v12walked_bindings;
     cl_object v13walked_body;
     v12walked_bindings = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, v10, v3old_env, v5new_env, ECL_CONS_CAR(CLV0), v4sequentialp) /*  WALK-BINDINGS-1 */;
     {
      cl_object v14;
      v14 = ecl_make_cclosure_va((cl_objectfn)LC2978__lambda252,env0,Cblock,2);
      T0 = v14;
     }
     v13walked_body = L2967walk_declarations(3, v11, T0, v5new_env);
     if (Null(v9)){
      goto L13;
     }
     value0 = L2965relist_(5, v1form, v8, v9, v12walked_bindings, v13walked_body);
     return value0;
L13:;
     value0 = L2965relist_(4, v1form, v8, v12walked_bindings, v13walked_body);
     return value0;
    }
   }
  }
 }
}
static cl_object L2979walk_prog_prog__va(cl_narg narg, cl_object v8form, cl_object v9context, cl_object v10old_env, cl_object v11sequentialp, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[136]);
 {
  return L2979walk_prog_prog_(v8form, v9context, v10old_env, v11sequentialp);
 }
}
/* function definition for WALK-DO/DO*                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2980walk_do_do_(cl_object v1form, cl_object v2context, cl_object v3old_env, cl_object v4sequentialp)
{
 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 v5new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v5new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v6do_do_;
   cl_object v7bindings;
   cl_object v8end_test;
   cl_object v9body;
   cl_object v10walked_bindings;
   cl_object v11walked_body;
   v6do_do_ = ecl_car(v1form);
   v7bindings = ecl_cadr(v1form);
   v8end_test = ecl_caddr(v1form);
   v9body = ecl_cdddr(v1form);
   v10walked_bindings = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, v7bindings, v3old_env, v5new_env, v2context, v4sequentialp) /*  WALK-BINDINGS-1 */;
   T0 = ecl_fdefinition(VV[122]);
   v11walked_body = L2967walk_declarations(3, v9body, T0, v5new_env);
   T0 = L2989walk_bindings_2(v7bindings, v10walked_bindings, v2context, v5new_env);
   T1 = L2959walk_template(v8end_test, VV[149], v2context, v5new_env);
   value0 = L2965relist_(5, v1form, v6do_do_, T0, T1, v11walked_body);
   return value0;
  }
 }
}
static cl_object L2980walk_do_do__va(cl_narg narg, cl_object v12form, cl_object v13context, cl_object v14old_env, cl_object v15sequentialp, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[139]);
 {
  return L2980walk_do_do_(v12form, v13context, v14old_env, v15sequentialp);
 }
}
/* function definition for WALK-DOTIMES/DOLIST                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2981walk_dotimes_dolist(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 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 v4new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v4new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v5dotimes_dolist;
   cl_object v6bindings;
   cl_object v7body;
   cl_object v8walked_bindings;
   cl_object v9walked_body;
   v5dotimes_dolist = ecl_car(v1form);
   v6bindings = ecl_cadr(v1form);
   v7body = ecl_cddr(v1form);
   v8walked_bindings = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, v6bindings, v3old_env, v4new_env, v2context, ECL_T) /*  WALK-BINDINGS-1 */;
   T0 = ecl_fdefinition(VV[122]);
   v9walked_body = L2967walk_declarations(3, v7body, T0, v4new_env);
   T0 = L2989walk_bindings_2(v6bindings, v8walked_bindings, v2context, v4new_env);
   value0 = L2965relist_(4, v1form, v5dotimes_dolist, T0, v9walked_body);
   return value0;
  }
 }
}
static cl_object L2981walk_dotimes_dolist_va(cl_narg narg, cl_object v10form, cl_object v11context, cl_object v12old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[86]);
 {
  return L2981walk_dotimes_dolist(v10form, v11context, v12old_env);
 }
}
/* function definition for WALK-MULTIPLE-VALUE-SETQ                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2985walk_multiple_value_setq(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object T0, T1;
 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(v3env,env0);                  /*  ENV                     */
 {
  cl_object v4vars;
  v4vars = ecl_cadr(v1form);
  {
   cl_object v5;
   v5 = ecl_make_cclosure_va((cl_objectfn)LC2982__lambda257,env0,Cblock,1);
   T0 = v5;
  }
  if (Null(cl_some(2, T0, v4vars))){
   goto L2;
  }
  {
   cl_object v5temps;
   cl_object v6sets;
   cl_object v7expanded;
   cl_object v8walked;
   {
    cl_object v9;
    {
     cl_object v10;
     v10 = ecl_make_cfun_va((cl_objectfn)LC2983__lambda264_va,ECL_NIL,Cblock,1);
     v9 = v10;
    }
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     {
      cl_object v13;
      v13 = v4vars;
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
     v11 = ECL_NIL;
     v12 = v10;
     {
      cl_object v13;
      cl_object v14;
      v13 = ecl_list1(ECL_NIL);
      v14 = v13;
L14:;
      if (!(ecl_endp(v12))){
       goto L16;
      }
      goto L15;
L16:;
      v11 = ECL_CONS_CAR(v12);
      {
       cl_object v15;
       v15 = ECL_CONS_CDR(v12);
       if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v12 = v15;
      }
      {
       cl_object v15;
       v15 = v14;
       if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v15;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
      v14 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v14,T0);
      goto L14;
L15:;
      v5temps = ecl_cdr(v13);
      goto L5;
     }
    }
   }
L5:;
   {
    cl_object v9;
    {
     cl_object v10;
     v10 = ecl_make_cfun_va((cl_objectfn)LC2984__lambda275_va,ECL_NIL,Cblock,2);
     v9 = v10;
    }
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     {
      cl_object v13;
      v13 = v4vars;
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
     v11 = ECL_NIL;
     v12 = v10;
     {
      cl_object v13;
      cl_object v14;
      cl_object v15;
      {
       cl_object v16;
       v16 = v5temps;
       if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v16;
      }
      v14 = ECL_NIL;
      v15 = v13;
      {
       cl_object v16;
       cl_object v17;
       v16 = ecl_list1(ECL_NIL);
       v17 = v16;
L46:;
       if (!(ecl_endp(v12))){
        goto L48;
       }
       goto L47;
L48:;
       v11 = ECL_CONS_CAR(v12);
       {
        cl_object v18;
        v18 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v18;
       }
       if (!(ecl_endp(v15))){
        goto L56;
       }
       goto L47;
L56:;
       v14 = ECL_CONS_CAR(v15);
       {
        cl_object v18;
        v18 = ECL_CONS_CDR(v15);
        if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v15 = v18;
       }
       {
        cl_object v18;
        v18 = v17;
        if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v18;
       }
       T1 = ecl_function_dispatch(cl_env_copy,v9)(2, v11, v14);
       v17 = ecl_list1(T1);
       (ECL_CONS_CDR(T0)=v17,T0);
       goto L46;
L47:;
       v6sets = ecl_cdr(v16);
       goto L32;
      }
     }
    }
   }
L32:;
   T0 = ecl_caddr(v1form);
   v7expanded = cl_listX(4, ECL_SYM("MULTIPLE-VALUE-BIND",574), v5temps, T0, v6sets);
   v8walked = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v7expanded, v2context, ECL_CONS_CAR(CLV0)) /*  WALK-FORM-INTERNAL */;
   if (!((v8walked)==(v7expanded))){
    goto L74;
   }
   value0 = v1form;
   cl_env_copy->nvalues = 1;
   return value0;
L74:;
   value0 = v8walked;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L2:;
  value0 = L2959walk_template(v1form, VV[160], v2context, ECL_CONS_CAR(CLV0));
  return value0;
 }
}
static cl_object L2985walk_multiple_value_setq_va(cl_narg narg, cl_object v9form, cl_object v10context, cl_object v11env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[81]);
 {
  return L2985walk_multiple_value_setq(v9form, v10context, v11env);
 }
}
/* function definition for WALK-MULTIPLE-VALUE-BIND                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2987walk_multiple_value_bind(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 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(v2context,env0);              /*  CONTEXT                 */
 CLV1 = env0 = CONS(v3old_env,env0);              /*  OLD-ENV                 */
 {
  cl_object env1 = env0;
  T0 = L2939walker_environment_bind_1(1, ECL_CONS_CAR(CLV1));
  T1 = L2933with_augmented_environment_internal(ECL_CONS_CAR(CLV1), ECL_NIL, T0);
  CLV2 = env1 = CONS(T1,env1);                    /*  NEW-ENV                 */
  {
   cl_object v4mvb;
   cl_object v5mv_form;
   cl_object v6body;
   cl_object v7walked_body;
   cl_object env2 = env1;
   v4mvb = ecl_car(v1form);
   T0 = ecl_cadr(v1form);
   CLV3 = env2 = CONS(T0,env2);                   /*  BINDINGS                */
   T0 = ecl_caddr(v1form);
   v5mv_form = L2959walk_template(T0, ECL_SYM("EVAL",341), ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1));
   v6body = ecl_cdddr(v1form);
   CLV4 = env2 = CONS(ECL_NIL,env2);              /*  WALKED-BINDINGS         */
   {
    cl_object v8;
    v8 = ecl_make_cclosure_va((cl_objectfn)LC2986__lambda282,env2,Cblock,2);
    T0 = v8;
   }
   v7walked_body = L2967walk_declarations(3, v6body, T0, ECL_CONS_CAR(CLV2));
   T0 = ECL_CONS_CAR(CLV4);
   value0 = L2965relist_(5, v1form, v4mvb, T0, v5mv_form, v7walked_body);
   return value0;
  }
 }
}
static cl_object L2987walk_multiple_value_bind_va(cl_narg narg, cl_object v8form, cl_object v9context, cl_object v10old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[82]);
 {
  return L2987walk_multiple_value_bind(v8form, v9context, v10old_env);
 }
}
/* function definition for WALK-BINDINGS-1                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2988walk_bindings_1(cl_object v1bindings, cl_object v2old_env, cl_object v3new_env, cl_object v4context, cl_object v5sequentialp)
{
 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:;
 if (Null(v1bindings)){
  goto L3;
 }
 {
  cl_object v6binding;
  v6binding = ecl_car(v1bindings);
  if (!(ECL_SYMBOLP(v6binding))){
   goto L7;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, v6binding, v3new_env) /*  NOTE-LEXICAL-BINDING */;
  T0 = v6binding;
  goto L6;
L7:;
  {
   cl_object v7;
   T1 = ecl_car(v6binding);
   T2 = ecl_cadr(v6binding);
   if (Null(v5sequentialp)){
    goto L12;
   }
   T3 = v3new_env;
   goto L11;
L12:;
   T3 = v2old_env;
L11:;
   T4 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T2, v4context, T3) /*  WALK-FORM-INTERNAL */;
   T5 = ecl_cddr(v6binding);
   v7 = L2965relist_(4, v6binding, T1, T4, T5);
   T1 = ecl_car(v6binding);
   (cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, T1, v3new_env) /*  NOTE-LEXICAL-BINDING */;
   T0 = v7;
  }
L6:;
  T1 = ecl_cdr(v1bindings);
  T2 = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, T1, v2old_env, v3new_env, v4context, v5sequentialp) /*  WALK-BINDINGS-1 */;
  value0 = L2963recons(v1bindings, T0, T2);
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2988walk_bindings_1_va(cl_narg narg, cl_object v7bindings, cl_object v8old_env, cl_object v9new_env, cl_object v10context, cl_object v11sequentialp, ...)
{
 if (ecl_unlikely(narg!=5)) FEwrong_num_arguments(VV[142]);
 {
  return L2988walk_bindings_1(v7bindings, v8old_env, v9new_env, v10context, v11sequentialp);
 }
}
/* function definition for WALK-BINDINGS-2                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2989walk_bindings_2(cl_object v1bindings, cl_object v2walked_bindings, cl_object v3context, cl_object v4env)
{
 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:;
 if (Null(v1bindings)){
  goto L3;
 }
 {
  cl_object v5;
  cl_object v6;
  v5 = ecl_car(v1bindings);
  v6 = ecl_car(v2walked_bindings);
  if (!(ECL_SYMBOLP(v5))){
   goto L8;
  }
  T0 = v5;
  goto L7;
L8:;
  T1 = ecl_car(v6);
  T2 = ecl_cadr(v6);
  T3 = ecl_cddr(v5);
  T4 = L2959walk_template(T3, VV[165], v3context, v4env);
  T0 = L2965relist_(4, v5, T1, T2, T4);
L7:;
  T1 = ecl_cdr(v1bindings);
  T2 = ecl_cdr(v2walked_bindings);
  T3 = L2989walk_bindings_2(T1, T2, v3context, v4env);
  value0 = L2963recons(v1bindings, T0, T3);
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for WALK-LAMBDA                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2990walk_lambda(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 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 v4new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v4new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v5arglist;
   cl_object v6body;
   cl_object v7walked_arglist;
   cl_object v8walked_body;
   v5arglist = ecl_cadr(v1form);
   v6body = ecl_cddr(v1form);
   v7walked_arglist = L2969walk_arglist(3, v5arglist, v2context, v4new_env);
   T0 = ecl_fdefinition(VV[122]);
   v8walked_body = L2967walk_declarations(3, v6body, T0, v4new_env);
   T0 = ecl_car(v1form);
   value0 = L2965relist_(4, v1form, T0, v7walked_arglist, v8walked_body);
   return value0;
  }
 }
}
static cl_object L2990walk_lambda_va(cl_narg narg, cl_object v9form, cl_object v10context, cl_object v11old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[76]);
 {
  return L2990walk_lambda(v9form, v10context, v11old_env);
 }
}
/* function definition for WALK-NAMED-LAMBDA                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2991walk_named_lambda(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 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 v4new_env;
  T0 = L2939walker_environment_bind_1(1, v3old_env);
  v4new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T0);
  {
   cl_object v5name;
   cl_object v6arglist;
   cl_object v7body;
   cl_object v8walked_arglist;
   cl_object v9walked_body;
   v5name = ecl_cadr(v1form);
   v6arglist = ecl_caddr(v1form);
   v7body = ecl_cdddr(v1form);
   v8walked_arglist = L2969walk_arglist(3, v6arglist, v2context, v4new_env);
   T0 = ecl_fdefinition(VV[122]);
   v9walked_body = L2967walk_declarations(3, v7body, T0, v4new_env);
   T0 = ecl_car(v1form);
   value0 = L2965relist_(5, v1form, T0, v5name, v8walked_arglist, v9walked_body);
   return value0;
  }
 }
}
static cl_object L2991walk_named_lambda_va(cl_narg narg, cl_object v10form, cl_object v11context, cl_object v12old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[92]);
 {
  return L2991walk_named_lambda(v10form, v11context, v12old_env);
 }
}
/* function definition for WALK-SETQ                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2992walk_setq(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cdddr(v1form))){
  goto L2;
 }
 {
  cl_object v4expanded;
  cl_object v5walked;
  {
   cl_object v6rforms;
   cl_object v7tail;
   v6rforms = ECL_NIL;
   v7tail = ecl_cdr(v1form);
L7:;
   if (!(v7tail==ECL_NIL)){
    goto L9;
   }
   v4expanded = cl_nreverse(v6rforms);
   goto L4;
L9:;
   {
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     v10 = v7tail;
     {
      cl_object v11;
      v11 = v10;
      {
       bool v12;
       v12 = ECL_LISTP(v11);
       if (ecl_unlikely(!(v12)))
         FEwrong_type_argument(VV[168],v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v10)){
      goto L16;
     }
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v10);
      v7tail = v11;
      v10 = ECL_CONS_CAR(v10);
     }
L16:;
     v8 = v10;
    }
    {
     cl_object v10;
     v10 = v7tail;
     {
      cl_object v11;
      v11 = v10;
      {
       bool v12;
       v12 = ECL_LISTP(v11);
       if (ecl_unlikely(!(v12)))
         FEwrong_type_argument(VV[168],v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v10)){
      goto L27;
     }
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v10);
      v7tail = v11;
      v10 = ECL_CONS_CAR(v10);
     }
L27:;
     v9 = v10;
    }
    T0 = cl_list(3, ECL_SYM("SETQ",754), v8, v9);
    v6rforms = CONS(T0,v6rforms);
   }
   goto L7;
  }
L4:;
  v5walked = L2962walk_repeat_eval(v4expanded, v3env);
  if (!((v4expanded)==(v5walked))){
   goto L36;
  }
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  return value0;
L36:;
  value0 = CONS(ECL_SYM("PROGN",674),v5walked);
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 {
  cl_object v6var;
  cl_object v7val;
  cl_object v8symmac;
  v6var = ecl_cadr(v1form);
  v7val = ecl_caddr(v1form);
  T0 = L2947variable_symbol_macro_p(v6var, v3env);
  v8symmac = ecl_car(T0);
  if (Null(v8symmac)){
   goto L41;
  }
  {
   cl_object v9expanded;
   cl_object v10walked;
   T0 = ecl_cddr(v8symmac);
   v9expanded = cl_list(3, ECL_SYM("SETF",753), T0, v7val);
   v10walked = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v9expanded, v2context, v3env) /*  WALK-FORM-INTERNAL */;
   if (!((v9expanded)==(v10walked))){
    goto L45;
   }
   value0 = v1form;
   cl_env_copy->nvalues = 1;
   return value0;
L45:;
   value0 = v10walked;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L41:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v6var, VV[111], v3env) /*  WALK-FORM-INTERNAL */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v7val, VV[101], v3env) /*  WALK-FORM-INTERNAL */;
  value0 = L2964relist(4, v1form, ECL_SYM("SETQ",754), T0, T1);
  return value0;
 }
}
static cl_object L2992walk_setq_va(cl_narg narg, cl_object v11form, cl_object v12context, cl_object v13env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[83]);
 {
  return L2992walk_setq(v11form, v12context, v13env);
 }
}
/* function definition for WALK-SYMBOL-MACROLET                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2994walk_symbol_macrolet(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 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 v4bindings;
  v4bindings = ecl_cadr(v1form);
  {
   cl_object v5new_env;
   {
    cl_object v6;
    {
     cl_object v7;
     v7 = ecl_make_cfun_va((cl_objectfn)LC2993__lambda307_va,ECL_NIL,Cblock,1);
     v6 = v7;
    }
    {
     cl_object v7;
     cl_object v8;
     cl_object v9;
     {
      cl_object v10;
      v10 = v4bindings;
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     v8 = ECL_NIL;
     v9 = v7;
     {
      cl_object v10;
      cl_object v11;
      v10 = ecl_list1(ECL_NIL);
      v11 = v10;
L13:;
      if (!(ecl_endp(v9))){
       goto L15;
      }
      goto L14;
L15:;
      v8 = ECL_CONS_CAR(v9);
      {
       cl_object v12;
       v12 = ECL_CONS_CDR(v9);
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v9 = v12;
      }
      {
       cl_object v12;
       v12 = v11;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v12;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
      v11 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v11,T1);
      goto L13;
L14:;
      T0 = ecl_cdr(v10);
      goto L4;
     }
    }
   }
L4:;
   T1 = L2943env_lexical_variables(v3old_env);
   T2 = ecl_append(T0,T1);
   T3 = L2939walker_environment_bind_1(3, v3old_env, VV[170], T2);
   v5new_env = L2933with_augmented_environment_internal(v3old_env, ECL_NIL, T3);
   T0 = ecl_cddr(v1form);
   T1 = L2962walk_repeat_eval(T0, v5new_env);
   value0 = L2965relist_(4, v1form, ECL_SYM("SYMBOL-MACROLET",845), v4bindings, T1);
   return value0;
  }
 }
}
static cl_object L2994walk_symbol_macrolet_va(cl_narg narg, cl_object v6form, cl_object v7context, cl_object v8old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[84]);
 {
  return L2994walk_symbol_macrolet(v6form, v7context, v8old_env);
 }
}
/* function definition for WALK-TAGBODY                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2995walk_tagbody(cl_object v1form, cl_object v2context, cl_object v3env)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1form);
 T1 = ecl_cdr(v1form);
 T2 = L2996walk_tagbody_1(T1, v2context, v3env);
 value0 = L2963recons(v1form, T0, T2);
 return value0;
}
static cl_object L2995walk_tagbody_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[85]);
 {
  return L2995walk_tagbody(v4form, v5context, v6env);
 }
}
/* function definition for WALK-TAGBODY-1                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2996walk_tagbody_1(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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:;
 if (Null(v1form)){
  goto L3;
 }
 T0 = ecl_car(v1form);
 T2 = ecl_car(v1form);
 if (!(ECL_SYMBOLP(T2))){
  goto L6;
 }
 T1 = ECL_SYM("QUOTE",682);
 goto L5;
L6:;
 T1 = v2context;
L5:;
 T2 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T0, T1, v3env) /*  WALK-FORM-INTERNAL */;
 T3 = ecl_cdr(v1form);
 T4 = L2996walk_tagbody_1(T3, v2context, v3env);
 value0 = L2963recons(v1form, T2, T4);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for WALK-COMPILER-LET                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2997walk_compiler_let(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 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 v4vars;
  cl_object v5vals;
  v4vars = ECL_NIL;
  v5vals = ECL_NIL;
  {
   cl_object v6;
   v6 = ecl_cadr(v1form);
   goto L8;
L7:;
   {
    cl_object v7binding;
    v7binding = ecl_car(v6);
    if (!(ECL_SYMBOLP(v7binding))){
     goto L13;
    }
    v4vars = CONS(v7binding,v4vars);
    v5vals = CONS(ECL_NIL,v5vals);
    goto L12;
L13:;
    T0 = ecl_car(v7binding);
    v4vars = CONS(T0,v4vars);
    T0 = ecl_cadr(v7binding);
    T1 = cl_eval(T0);
    v5vals = CONS(T1,v5vals);
L12:;
   }
   v6 = ecl_cdr(v6);
L8:;
   if (Null(v6)){
    goto L23;
   }
   goto L7;
L23:;
  }
  T0 = ecl_car(v1form);
  T1 = ecl_cadr(v1form);
  {
   cl_object v7, v8; cl_index v6;
   v7 = v4vars;
   v8 = v5vals;
   v6 = ecl_progv(cl_env_copy, v7, v8);
   T3 = ecl_cddr(v1form);
   T2 = L2962walk_repeat_eval(T3, v3old_env);
   ecl_bds_unwind(cl_env_copy,v6);
  }
  value0 = L2965relist_(4, v1form, T0, T1, T2);
  return value0;
 }
}
static cl_object L2997walk_compiler_let_va(cl_narg narg, cl_object v6form, cl_object v7context, cl_object v8old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[71]);
 {
  return L2997walk_compiler_let(v6form, v7context, v8old_env);
 }
}
/* function definition for WALK-MACROLET                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2999walk_macrolet(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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);
 lex0[0] = v2context;                             /*  CONTEXT                 */
L1:;
 T0 = L2940env_walk_function(v3old_env);
 T1 = L2939walker_environment_bind_1(3, ECL_NIL, VV[99], T0);
 T2 = L2933with_augmented_environment_internal(ECL_NIL, ECL_NIL, T1);
 lex0[1] = T2;                                    /*  MACRO-ENV               */
 {
  cl_object v4;
  cl_object v5;
  v4 = ECL_NIL;
  v5 = ECL_NIL;
  {
   cl_object v6;
   v6 = ecl_car(v1form);
   if (!((v6)==(ECL_SYM("FLET",375)))){
    goto L11;
   }
   goto L8;
L11:;
   goto L9;
L9:;
   if (!((v6)==(ECL_SYM("LABELS",453)))){
    goto L6;
   }
   goto L7;
L8:;
L7:;
   {
    cl_object v7;
    v7 = ecl_cadr(v1form);
    goto L17;
L16:;
    {
     cl_object v8fn;
     v8fn = ecl_car(v7);
     v4 = CONS(v8fn,v4);
    }
    v7 = ecl_cdr(v7);
L17:;
    if (Null(v7)){
     goto L25;
    }
    goto L16;
L25:;
    goto L4;
   }
L6:;
   if (!((v6)==(ECL_SYM("MACROLET",523)))){
    goto L27;
   }
   {
    cl_object v8;
    v8 = ecl_cadr(v1form);
    goto L33;
L32:;
    {
     cl_object v9mac;
     v9mac = ecl_car(v8);
     T0 = ecl_car(v9mac);
     T1 = ecl_cadr(v9mac);
     T2 = ecl_cddr(v9mac);
     T3 = ecl_car(v9mac);
     T4 = cl_string(T3);
     T5 = L2936convert_macro_to_lambda(3, T1, T2, T4);
     T6 = cl_list(2, T0, T5);
     v5 = CONS(T6,v5);
    }
    v8 = ecl_cdr(v8);
L33:;
    if (Null(v8)){
     goto L41;
    }
    goto L32;
L41:;
    goto L4;
   }
L27:;
   si_ecase_error(v6, VV[177]);
  }
L4:;
  {
   cl_object v6new_env;
   v6new_env = L2933with_augmented_environment_internal(v3old_env, v4, v5);
   T0 = ecl_car(v1form);
   T2 = ecl_cadr(v1form);
   T1 = LC2998walk_definitions(lex0, T2);
   T2 = ecl_cddr(v1form);
   T3 = ecl_fdefinition(VV[122]);
   T4 = L2967walk_declarations(3, T2, T3, v6new_env);
   value0 = L2965relist_(4, v1form, T0, T1, T4);
   return value0;
  }
 }
}
static cl_object L2999walk_macrolet_va(cl_narg narg, cl_object v7form, cl_object v8context, cl_object v9old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[80]);
 {
  return L2999walk_macrolet(v7form, v8context, v9old_env);
 }
}
/* function definition for WALK-FLET                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3001walk_flet(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 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);
 lex0[0] = v2context;                             /*  CONTEXT                 */
 lex0[1] = v3old_env;                             /*  OLD-ENV                 */
L1:;
 T0 = ecl_car(v1form);
 T1 = ecl_cdr(v1form);
 T3 = ecl_cadr(v1form);
 T2 = LC3000walk_definitions(lex0, T3);
 {
  cl_object v4;
  cl_object v5;
  v4 = ECL_NIL;
  v5 = ECL_NIL;
  {
   cl_object v6;
   v6 = ecl_car(v1form);
   if (!((v6)==(ECL_SYM("FLET",375)))){
    goto L13;
   }
   goto L10;
L13:;
   goto L11;
L11:;
   if (!((v6)==(ECL_SYM("LABELS",453)))){
    goto L8;
   }
   goto L9;
L10:;
L9:;
   {
    cl_object v7;
    v7 = ecl_cadr(v1form);
    goto L19;
L18:;
    {
     cl_object v8fn;
     v8fn = ecl_car(v7);
     v4 = CONS(v8fn,v4);
    }
    v7 = ecl_cdr(v7);
L19:;
    if (Null(v7)){
     goto L27;
    }
    goto L18;
L27:;
    goto L6;
   }
L8:;
   if (!((v6)==(ECL_SYM("MACROLET",523)))){
    goto L29;
   }
   {
    cl_object v8;
    v8 = ecl_cadr(v1form);
    goto L35;
L34:;
    {
     cl_object v9mac;
     v9mac = ecl_car(v8);
     T4 = ecl_car(v9mac);
     T5 = ecl_cadr(v9mac);
     T6 = ecl_cddr(v9mac);
     T7 = ecl_car(v9mac);
     T8 = cl_string(T7);
     T9 = L2936convert_macro_to_lambda(3, T5, T6, T8);
     T10 = cl_list(2, T4, T9);
     v5 = CONS(T10,v5);
    }
    v8 = ecl_cdr(v8);
L35:;
    if (Null(v8)){
     goto L43;
    }
    goto L34;
L43:;
    goto L6;
   }
L29:;
   si_ecase_error(v6, VV[177]);
  }
L6:;
  {
   cl_object v6new_env;
   v6new_env = L2933with_augmented_environment_internal(lex0[1], v4, v5);
   T4 = ecl_cddr(v1form);
   T5 = ecl_fdefinition(VV[122]);
   T3 = L2967walk_declarations(3, T4, T5, v6new_env);
  }
 }
 T4 = L2963recons(T1, T2, T3);
 value0 = L2963recons(v1form, T0, T4);
 return value0;
}
static cl_object L3001walk_flet_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[73]);
 {
  return L3001walk_flet(v4form, v5context, v6old_env);
 }
}
/* function definition for WALK-LABELS                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3003walk_labels(cl_object v1form, cl_object v2context, cl_object v3old_env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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);
 lex0[0] = v2context;                             /*  CONTEXT                 */
L1:;
 {
  cl_object v4;
  cl_object v5;
  v4 = ECL_NIL;
  v5 = ECL_NIL;
  {
   cl_object v6;
   v6 = ecl_car(v1form);
   if (!((v6)==(ECL_SYM("FLET",375)))){
    goto L11;
   }
   goto L8;
L11:;
   goto L9;
L9:;
   if (!((v6)==(ECL_SYM("LABELS",453)))){
    goto L6;
   }
   goto L7;
L8:;
L7:;
   {
    cl_object v7;
    v7 = ecl_cadr(v1form);
    goto L17;
L16:;
    {
     cl_object v8fn;
     v8fn = ecl_car(v7);
     v4 = CONS(v8fn,v4);
    }
    v7 = ecl_cdr(v7);
L17:;
    if (Null(v7)){
     goto L25;
    }
    goto L16;
L25:;
    goto L4;
   }
L6:;
   if (!((v6)==(ECL_SYM("MACROLET",523)))){
    goto L27;
   }
   {
    cl_object v8;
    v8 = ecl_cadr(v1form);
    goto L33;
L32:;
    {
     cl_object v9mac;
     v9mac = ecl_car(v8);
     T0 = ecl_car(v9mac);
     T1 = ecl_cadr(v9mac);
     T2 = ecl_cddr(v9mac);
     T3 = ecl_car(v9mac);
     T4 = cl_string(T3);
     T5 = L2936convert_macro_to_lambda(3, T1, T2, T4);
     T6 = cl_list(2, T0, T5);
     v5 = CONS(T6,v5);
    }
    v8 = ecl_cdr(v8);
L33:;
    if (Null(v8)){
     goto L41;
    }
    goto L32;
L41:;
    goto L4;
   }
L27:;
   si_ecase_error(v6, VV[177]);
  }
L4:;
  T0 = L2933with_augmented_environment_internal(v3old_env, v4, v5);
  lex0[1] = T0;                                   /*  NEW-ENV                 */
  T0 = ecl_car(v1form);
  T1 = ecl_cdr(v1form);
  T3 = ecl_cadr(v1form);
  T2 = LC3002walk_definitions(lex0, T3);
  T3 = ecl_cddr(v1form);
  T4 = ecl_fdefinition(VV[122]);
  T5 = L2967walk_declarations(3, T3, T4, lex0[1]);
  T6 = L2963recons(T1, T2, T5);
  value0 = L2963recons(v1form, T0, T6);
  return value0;
 }
}
static cl_object L3003walk_labels_va(cl_narg narg, cl_object v6form, cl_object v7context, cl_object v8old_env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[75]);
 {
  return L3003walk_labels(v6form, v7context, v8old_env);
 }
}
/* function definition for WALK-IF                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3004walk_if(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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 v4predicate;
  cl_object v5arm1;
  cl_object v6arm2;
  v4predicate = ecl_cadr(v1form);
  v5arm1 = ecl_caddr(v1form);
  if (Null(ecl_cddddr(v1form))){
   goto L5;
  }
  T0 = ecl_cdr(v1form);
  {
   cl_fixnum v7;
   v7 = ecl_length(T0);
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(3, VV[181], v1form, ecl_make_fixnum(v7)) /*  WARN */;
  }
  T0 = ecl_cdddr(v1form);
  v6arm2 = CONS(ECL_SYM("PROGN",674),T0);
  goto L4;
L5:;
  v6arm2 = ecl_cadddr(v1form);
L4:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v4predicate, v2context, v3env) /*  WALK-FORM-INTERNAL */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v5arm1, v2context, v3env) /*  WALK-FORM-INTERNAL */;
  T2 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, v6arm2, v2context, v3env) /*  WALK-FORM-INTERNAL */;
  value0 = L2964relist(5, v1form, ECL_SYM("IF",950), T0, T1, T2);
  return value0;
 }
}
static cl_object L3004walk_if_va(cl_narg narg, cl_object v7form, cl_object v8context, cl_object v9env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[74]);
 {
  return L3004walk_if(v7form, v8context, v9env);
 }
}
/* function definition for WALK-WHEN/UNLESS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3005walk_when_unless(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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:;
 T0 = ecl_car(v1form);
 T1 = ecl_cadr(v1form);
 T2 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(3, T1, v2context, v3env) /*  WALK-FORM-INTERNAL */;
 T3 = ecl_cddr(v1form);
 T4 = L2962walk_repeat_eval(T3, v3env);
 value0 = L2965relist_(4, v1form, T0, T2, T4);
 return value0;
}
static cl_object L3005walk_when_unless_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[87]);
 {
  return L3005walk_when_unless(v4form, v5context, v6env);
 }
}
/* function definition for WALK-C-INLINE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3006walk_c_inline(cl_object v1form, cl_object v2context, cl_object v3env)
{
 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:;
 T0 = ecl_car(v1form);
 T1 = ecl_cadr(v1form);
 T2 = L2962walk_repeat_eval(T1, v3env);
 T3 = ecl_cddr(v1form);
 value0 = L2965relist_(4, v1form, T0, T2, T3);
 return value0;
}
static cl_object L3006walk_c_inline_va(cl_narg narg, cl_object v4form, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[93]);
 {
  return L3006walk_c_inline(v4form, v5context, v6env);
 }
}
/* local function LAMBDA161                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2956__lambda161(cl_object v1subform, cl_object v2context, cl_object v3env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = v1subform;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2956__lambda161_va(cl_narg narg, cl_object v4subform, cl_object v5context, cl_object v6env, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[98]);
 {
  return LC2956__lambda161(v4subform, v5context, v6env);
 }
}
/* closure LAMBDA252                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2978__lambda252(cl_narg narg, cl_object v1real_body, cl_object v2real_env, ...)
{
 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;                                     /*  CONTEXT                 */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[145]);
 {
L1:;
  value0 = L2996walk_tagbody_1(v1real_body, ECL_CONS_CAR(CLV0), v2real_env);
  return value0;
 }
 }
}
/* closure LAMBDA257                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2982__lambda257(cl_narg narg, cl_object v1var, ...)
{
 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;                                     /*  ENV                     */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[152]);
 {
L1:;
  value0 = L2947variable_symbol_macro_p(v1var, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* local function LAMBDA264                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2983__lambda264(cl_object v1var)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_gensym(0);
 return value0;
}
static cl_object LC2983__lambda264_va(cl_narg narg, cl_object v2var, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[153]);
 {
  return LC2983__lambda264(v2var);
 }
}
/* local function LAMBDA275                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2984__lambda275(cl_object v1var, cl_object v2temp)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = cl_list(3, ECL_SYM("SETQ",754), v1var, v2temp);
 return value0;
}
static cl_object LC2984__lambda275_va(cl_narg narg, cl_object v3var, cl_object v4temp, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[159]);
 {
  return LC2984__lambda275(v3var, v4temp);
 }
}
/* closure LAMBDA282                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2986__lambda282(cl_narg narg, cl_object v1real_body, cl_object v2real_env, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 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 ... */
 CLV4 = env0;                                     /*  WALKED-BINDINGS         */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[162]);
 {
L1:;
  ECL_CONS_CAR(CLV4) = (cl_env_copy->function=ecl_fdefinition(VV[142]))->cfun.entry(5, ECL_CONS_CAR(CLV3), ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV0), ECL_NIL) /*  WALK-BINDINGS-1 */;
  value0 = L2962walk_repeat_eval(v1real_body, v2real_env);
  return value0;
 }
 }
}
/* local function LAMBDA307                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2993__lambda307(cl_object v1binding)
{
 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:;
 T0 = ecl_car(v1binding);
 T1 = ecl_cadr(v1binding);
 value0 = cl_listX(3, T0, VV[47], T1);
 return value0;
}
static cl_object LC2993__lambda307_va(cl_narg narg, cl_object v2binding, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[171]);
 {
  return LC2993__lambda307(v2binding);
 }
}
/* local function WALK-DEFINITIONS                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2998walk_definitions(volatile cl_object *lex0, cl_object v1definitions)
{
 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:;
 if (Null(v1definitions)){
  goto L3;
 }
 {
  cl_object v2definition;
  v2definition = ecl_car(v1definitions);
  T0 = ecl_car(v2definition);
  T1 = ecl_cadr(v2definition);
  T2 = L2969walk_arglist(4, T1, lex0[0], lex0[1], ECL_T);
  T3 = ecl_cddr(v2definition);
  T4 = ecl_fdefinition(VV[122]);
  T5 = L2967walk_declarations(3, T3, T4, lex0[1]);
  T6 = L2965relist_(4, v2definition, T0, T2, T5);
  T8 = ecl_cdr(v1definitions);
  T7 = LC2998walk_definitions(lex0, T8);
  value0 = L2963recons(v1definitions, T6, T7);
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function WALK-DEFINITIONS                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3000walk_definitions(volatile cl_object *lex0, cl_object v1definitions)
{
 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:;
 if (!(v1definitions==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = ecl_car(v1definitions);
 T1 = L2990walk_lambda(T0, lex0[0], lex0[1]);
 T3 = ecl_cdr(v1definitions);
 T2 = LC3000walk_definitions(lex0, T3);
 value0 = L2963recons(v1definitions, T1, T2);
 return value0;
}
/* local function WALK-DEFINITIONS                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3002walk_definitions(volatile cl_object *lex0, cl_object v1definitions)
{
 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:;
 if (!(v1definitions==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = ecl_car(v1definitions);
 T1 = L2990walk_lambda(T0, lex0[0], lex0[1]);
 T3 = ecl_cdr(v1definitions);
 T2 = LC3002walk_definitions(lex0, T3);
 value0 = L2963recons(v1definitions, T1, T2);
 return value0;
}
#include "clos/walk.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl7JmT9FqQeKFq9_LCJ0M881(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:CLOS;WALK.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7JmT9FqQeKFq9_LCJ0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  T0 = cl_adjoin(2, VV[0], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36)));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*FEATURES*",36),T0);
  (cl_env_copy->function=(VV[1]->symbol.gfdef))->cfun.entry(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, VVtemp[3], ECL_NIL) /*  DODEFPACKAGE */;
  si_select_package(VVtemp[0]);
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[4]) /*  MAPC */;
  ecl_cmp_defun(VV[185]);                         /*  UNBOUND-LEXICAL-FUNCTION */
  ecl_cmp_defmacro(VV[186]);                      /*  WITH-AUGMENTED-ENVIRONMENT */
  ecl_cmp_defun(VV[187]);                         /*  WITH-AUGMENTED-ENVIRONMENT-INTERNAL */
  (void)0; /* No entry created for ENVIRONMENT-MACRO */
  ecl_cmp_defmacro(VV[188]);                      /*  WITH-NEW-DEFINITION-IN-ENVIRONMENT */
  (void)0; /* No entry created for CONVERT-MACRO-TO-LAMBDA */
  ecl_cmp_defmacro(VV[189]);                      /*  WALKER-ENVIRONMENT-BIND */
  si_Xmake_special(VV[32]);
  if (ecl_boundp(cl_env_copy,VV[32])) {
   goto L26;
  }
  T0 = cl_gensym(0);
  ecl_cmp_setq(cl_env_copy,VV[32],T0);
L26:;
  (void)0; /* No entry created for ENV-LOCK */
  (void)0; /* No entry created for WALKER-ENVIRONMENT-BIND-1 */
  (void)0; /* No entry created for ENV-WALK-FUNCTION */
  (void)0; /* No entry created for ENV-WALK-FORM */
  (void)0; /* No entry created for ENV-DECLARATIONS */
  (void)0; /* No entry created for ENV-LEXICAL-VARIABLES */
  (void)0; /* No entry created for NOTE-DECLARATION */
  ecl_cmp_defun(VV[190]);                         /*  NOTE-LEXICAL-BINDING    */
  (void)0; /* No entry created for VARIABLE-LEXICAL-P */
  (void)0; /* No entry created for VARIABLE-SYMBOL-MACRO-P */
  si_Xmake_special(VV[48]);
  if (ecl_boundp(cl_env_copy,VV[48])) {
   goto L63;
  }
  T0 = VVtemp[5];
  ecl_cmp_setq(cl_env_copy,VV[48],T0);
L63:;
  ecl_cmp_defun(VV[191]);                         /*  VARIABLE-DECLARATION    */
  ecl_cmp_defun(VV[192]);                         /*  VARIABLE-SPECIAL-P      */
  ecl_cmp_defun(VV[193]);                         /*  VARIABLE-GLOBALLY-SPECIAL-P */
  ecl_cmp_defmacro(VV[194]);                      /*  GET-WALKER-TEMPLATE-INTERNAL */
  ecl_cmp_defmacro(VV[195]);                      /*  DEFINE-WALKER-TEMPLATE  */
  ecl_cmp_defun(VV[196]);                         /*  GET-WALKER-TEMPLATE     */
  ecl_cmp_defun(VV[197]);                         /*  GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE */
  si_put_sysprop(ECL_SYM("BLOCK",139), VV[64], VVtemp[6]);
  si_put_sysprop(ECL_SYM("CATCH",184), VV[64], VVtemp[7]);
  si_put_sysprop(VV[70], VV[64], VV[71]);
  si_put_sysprop(ECL_SYM("DECLARE",276), VV[64], VV[72]);
  si_put_sysprop(ECL_SYM("EVAL-WHEN",342), VV[64], VVtemp[8]);
  si_put_sysprop(ECL_SYM("FLET",375), VV[64], VV[73]);
  si_put_sysprop(ECL_SYM("FUNCTION",398), VV[64], VVtemp[9]);
  si_put_sysprop(ECL_SYM("GO",416), VV[64], VVtemp[10]);
  si_put_sysprop(ECL_SYM("IF",950), VV[64], VV[74]);
  si_put_sysprop(ECL_SYM("LABELS",453), VV[64], VV[75]);
  si_put_sysprop(ECL_SYM("LAMBDA",454), VV[64], VV[76]);
  si_put_sysprop(ECL_SYM("LET",479), VV[64], VV[77]);
  si_put_sysprop(ECL_SYM("LET*",480), VV[64], VV[78]);
  si_put_sysprop(ECL_SYM("LOCALLY",492), VV[64], VV[79]);
  si_put_sysprop(ECL_SYM("MACROLET",523), VV[64], VV[80]);
  si_put_sysprop(ECL_SYM("MULTIPLE-VALUE-CALL",575), VV[64], VVtemp[7]);
  si_put_sysprop(ECL_SYM("MULTIPLE-VALUE-PROG1",577), VV[64], VVtemp[11]);
  si_put_sysprop(ECL_SYM("MULTIPLE-VALUE-SETQ",578), VV[64], VV[81]);
  si_put_sysprop(ECL_SYM("MULTIPLE-VALUE-BIND",574), VV[64], VV[82]);
  si_put_sysprop(ECL_SYM("PROGN",674), VV[64], VV[59]);
  si_put_sysprop(ECL_SYM("PROGV",676), VV[64], VVtemp[12]);
  si_put_sysprop(ECL_SYM("QUOTE",682), VV[64], VVtemp[10]);
  si_put_sysprop(ECL_SYM("RETURN-FROM",728), VV[64], VVtemp[13]);
  si_put_sysprop(ECL_SYM("SETQ",754), VV[64], VV[83]);
  si_put_sysprop(ECL_SYM("SYMBOL-MACROLET",845), VV[64], VV[84]);
  si_put_sysprop(ECL_SYM("TAGBODY",853), VV[64], VV[85]);
  si_put_sysprop(ECL_SYM("THE",859), VV[64], VVtemp[14]);
  si_put_sysprop(ECL_SYM("THROW",861), VV[64], VVtemp[15]);
  si_put_sysprop(ECL_SYM("UNWIND-PROTECT",892), VV[64], VVtemp[11]);
  si_put_sysprop(ECL_SYM("DOTIMES",316), VV[64], VV[86]);
  si_put_sysprop(ECL_SYM("DOLIST",315), VV[64], VV[86]);
  si_put_sysprop(ECL_SYM("WHEN",909), VV[64], VV[87]);
  si_put_sysprop(ECL_SYM("UNLESS",886), VV[64], VV[87]);
  si_put_sysprop(ECL_SYM("DO",309), VV[64], VV[88]);
  si_put_sysprop(ECL_SYM("DO*",310), VV[64], VV[89]);
  si_put_sysprop(ECL_SYM("PROG",670), VV[64], VV[90]);
  si_put_sysprop(ECL_SYM("PROG*",671), VV[64], VV[91]);
  si_put_sysprop(ECL_SYM("COND",249), VV[64], VVtemp[16]);
  si_put_sysprop(ECL_SYM("LAMBDA-BLOCK",1377), VV[64], VV[92]);
  si_put_sysprop(ECL_SYM("C-INLINE",2106), VV[64], VV[93]);
  si_Xmake_special(VV[94]);
  if (ecl_boundp(cl_env_copy,VV[94])) {
   goto L129;
  }
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[94],T0);
L129:;
  ecl_cmp_defun(VV[198]);                         /*  MACROEXPAND-ALL         */
  ecl_cmp_defun(VV[199]);                         /*  WALK-FORM               */
  ecl_cmp_defun(VV[200]);                         /*  WALK-FORM-INTERNAL      */
  (void)0; /* No entry created for WALK-TEMPLATE */
  (void)0; /* No entry created for WALK-TEMPLATE-HANDLE-REPEAT */
  (void)0; /* No entry created for WALK-TEMPLATE-HANDLE-REPEAT-1 */
  ecl_cmp_defun(VV[201]);                         /*  WALK-REPEAT-EVAL        */
  ecl_cmp_defun(VV[202]);                         /*  RECONS                  */
  (void)0; /* No entry created for RELIST */
  (void)0; /* No entry created for RELIST* */
  (void)0; /* No entry created for RELIST-INTERNAL */
  (void)0; /* No entry created for WALK-DECLARATIONS */
  (void)0; /* No entry created for WALK-UNEXPECTED-DECLARE */
  (void)0; /* No entry created for WALK-ARGLIST */
  ecl_cmp_defun(VV[203]);                         /*  WALK-LET                */
  ecl_cmp_defun(VV[204]);                         /*  WALK-LET*               */
  ecl_cmp_defun(VV[205]);                         /*  WALK-PROG               */
  ecl_cmp_defun(VV[206]);                         /*  WALK-PROG*              */
  ecl_cmp_defun(VV[207]);                         /*  WALK-DO                 */
  ecl_cmp_defun(VV[208]);                         /*  WALK-DO*                */
  ecl_cmp_defun(VV[209]);                         /*  WALK-LET/LET*           */
  ecl_cmp_defun(VV[210]);                         /*  WALK-LOCALLY            */
  ecl_cmp_defun(VV[211]);                         /*  WALK-PROG/PROG*         */
  ecl_cmp_defun(VV[212]);                         /*  WALK-DO/DO*             */
  ecl_cmp_defun(VV[213]);                         /*  WALK-DOTIMES/DOLIST     */
  ecl_cmp_defun(VV[214]);                         /*  WALK-MULTIPLE-VALUE-SETQ */
  ecl_cmp_defun(VV[215]);                         /*  WALK-MULTIPLE-VALUE-BIND */
  ecl_cmp_defun(VV[216]);                         /*  WALK-BINDINGS-1         */
  (void)0; /* No entry created for WALK-BINDINGS-2 */
  ecl_cmp_defun(VV[217]);                         /*  WALK-LAMBDA             */
  ecl_cmp_defun(VV[218]);                         /*  WALK-NAMED-LAMBDA       */
  ecl_cmp_defun(VV[219]);                         /*  WALK-SETQ               */
  ecl_cmp_defun(VV[220]);                         /*  WALK-SYMBOL-MACROLET    */
  ecl_cmp_defun(VV[221]);                         /*  WALK-TAGBODY            */
  (void)0; /* No entry created for WALK-TAGBODY-1 */
  ecl_cmp_defun(VV[222]);                         /*  WALK-COMPILER-LET       */
  ecl_cmp_defun(VV[223]);                         /*  WALK-MACROLET           */
  ecl_cmp_defun(VV[224]);                         /*  WALK-FLET               */
  ecl_cmp_defun(VV[225]);                         /*  WALK-LABELS             */
  ecl_cmp_defun(VV[226]);                         /*  WALK-IF                 */
  ecl_cmp_defun(VV[227]);                         /*  WALK-WHEN/UNLESS        */
  ecl_cmp_defun(VV[228]);                         /*  WALK-C-INLINE           */
 }
}
