/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/loop.lsp                        */
#include <ecl/ecl-cmp.h>
#include "lsp/loop.eclh"
/* local function LOOP-UNSAFE                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC414loop_unsafe(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  value0 = cl_listX(3, ECL_SYM("LOCALLY",492), VV[1], v3);
  return value0;
 }
}
static cl_object LC414loop_unsafe_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[0]);
 {
  return LC414loop_unsafe(v4, v5);
 }
}
/* local function WITH-LOOP-LIST-COLLECTION-HEAD                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC415with_loop_list_collection_head(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 v6head_var;
  cl_object v7tail_var;
  cl_object v8user_head_var;
  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);
   v6head_var = 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);
   v7tail_var = v9;
  }
  if (Null(v5)){
   goto L23;
  }
  {
   cl_object v9;
   v9 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v8user_head_var = v9;
   goto L22;
  }
L23:;
  v8user_head_var = ECL_NIL;
L22:;
  if (Null(v5)){
   goto L28;
  }
  si_dm_too_many_arguments(v1);
L28:;
  {
   cl_object v9l;
   if (Null(v8user_head_var)){
    goto L32;
   }
   T0 = cl_list(2, v8user_head_var, ECL_NIL);
   v9l = ecl_list1(T0);
   goto L30;
L32:;
   v9l = ECL_NIL;
   goto L30;
L30:;
   T0 = cl_list(2, v6head_var, VV[6]);
   T1 = cl_list(2, v7tail_var, v6head_var);
   T2 = cl_listX(3, T0, T1, v9l);
   value0 = cl_listX(3, ECL_SYM("LET*",480), T2, v3);
   return value0;
  }
 }
}
static cl_object LC415with_loop_list_collection_head_va(cl_narg narg, cl_object v10, cl_object v11, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[4]);
 {
  return LC415with_loop_list_collection_head(v10, v11);
 }
}
/* local function LOOP-COLLECT-RPLACD                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC417loop_collect_rplacd(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  cl_object v5;
  cl_object v6head_var;
  cl_object v7tail_var;
  cl_object v8user_head_var;
  cl_object v9form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v10;
   v10 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v10;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v10;
   v10 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6head_var = v10;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v10;
   v10 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7tail_var = v10;
  }
  if (Null(v5)){
   goto L23;
  }
  {
   cl_object v10;
   v10 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v8user_head_var = v10;
   goto L22;
  }
L23:;
  v8user_head_var = ECL_NIL;
L22:;
  if (!(v3==ECL_NIL)){
   goto L29;
  }
  si_dm_too_few_arguments(v1);
L29:;
  {
   cl_object v10;
   v10 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v9form = v10;
  }
  if (Null(v3)){
   goto L34;
  }
  si_dm_too_many_arguments(v1);
L34:;
  if (Null(v5)){
   goto L36;
  }
  si_dm_too_many_arguments(v1);
L36:;
  v9form = cl_macroexpand(2, v9form, v2env);
  {
   cl_object v10ncdrs;
   v10ncdrs = ECL_NIL;
   if (!(ECL_CONSP(v9form))){
    goto L41;
   }
   T0 = ecl_car(v9form);
   if (!((T0)==(ECL_SYM("LIST",483)))){
    goto L43;
   }
   T0 = ecl_cdr(v9form);
   {
    cl_fixnum v11;
    v11 = ecl_length(T0);
    v10ncdrs = ecl_make_integer((v11)-1);
   }
   goto L41;
L43:;
   {
    cl_object v11;
    v11 = ecl_car(v9form);
    if (!((v11)==(ECL_SYM("LIST*",484)))){
     goto L51;
    }
    goto L48;
L51:;
    goto L49;
L49:;
    if (!((v11)==(ECL_SYM("CONS",253)))){
     goto L41;
    }
    goto L46;
L48:;
   }
L46:;
   if (Null(ecl_cddr(v9form))){
    goto L41;
   }
   {
    cl_object v11;
    T0 = ecl_last(v9form,1);
    v11 = ecl_car(T0);
    if (!((v11)==(ECL_NIL))){
     goto L60;
    }
    goto L57;
L60:;
    goto L58;
L58:;
    if (!((v11)==(VV[13]))){
     goto L41;
    }
    goto L54;
L57:;
   }
L54:;
   T0 = ecl_cdr(v9form);
   {
    cl_fixnum v11;
    v11 = ecl_length(T0);
    v10ncdrs = ecl_minus(ecl_make_fixnum(v11),ecl_make_int8_t(2));
   }
L41:;
   {
    cl_object v11answer;
    if (!(v10ncdrs==ECL_NIL)){
     goto L65;
    }
    T0 = cl_list(2, ECL_SYM("CDR",200), v7tail_var);
    T1 = cl_list(3, ECL_SYM("SETF",753), T0, v9form);
    T2 = cl_list(2, ECL_SYM("CDR",200), v7tail_var);
    T3 = cl_list(2, ECL_SYM("LAST",457), T2);
    T4 = cl_list(3, ECL_SYM("SETQ",754), v7tail_var, T3);
    v11answer = cl_list(3, ECL_SYM("WHEN",909), T1, T4);
    goto L64;
L65:;
    if (!(ecl_lower(v10ncdrs,ecl_make_int8_t(0)))){
     goto L67;
    }
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
L67:;
    if (!(ecl_number_equalp(v10ncdrs,ecl_make_int8_t(0)))){
     goto L69;
    }
    T0 = cl_list(3, ECL_SYM("SETQ",754), v7tail_var, v9form);
    v11answer = cl_list(3, ECL_SYM("RPLACD",736), v7tail_var, T0);
    goto L64;
L69:;
    T1 = cl_list(2, ECL_SYM("CDR",200), v7tail_var);
    T2 = cl_list(3, ECL_SYM("SETF",753), T1, v9form);
    T0 = LC416cdr_wrap(T2, v10ncdrs);
    v11answer = cl_list(3, ECL_SYM("SETQ",754), v7tail_var, T0);
L64:;
    if (Null(v8user_head_var)){
     goto L72;
    }
    T0 = cl_list(2, ECL_SYM("CDR",200), v6head_var);
    T1 = cl_list(3, ECL_SYM("SETQ",754), v8user_head_var, T0);
    v11answer = cl_list(3, ECL_SYM("PROGN",674), v11answer, T1);
L72:;
    value0 = v11answer;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object LC417loop_collect_rplacd_va(cl_narg narg, cl_object v12, cl_object v13env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[8]);
 {
  return LC417loop_collect_rplacd(v12, v13env);
 }
}
/* local function LOOP-COLLECT-ANSWER                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC418loop_collect_answer(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 v4head_var;
  cl_object v5user_head_var;
  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);
   v4head_var = v6;
  }
  if (Null(v3)){
   goto L10;
  }
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5user_head_var = v6;
   goto L9;
  }
L10:;
  v5user_head_var = ECL_NIL;
L9:;
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  value0 = v5user_head_var;
  if (value0!=ECL_NIL) {
   goto L18;
  }
  value0 = cl_list(2, ECL_SYM("CDR",200), v4head_var);
  return value0;
L18:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC418loop_collect_answer_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[16]);
 {
  return LC418loop_collect_answer(v6, v7);
 }
}
/* function definition for MAKE-LOOP-MINIMAX-INTERNAL                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L419make_loop_minimax_internal(cl_narg narg, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1;
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  cl_object v6;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[12];
   cl_parse_key(args,6,L419make_loop_minimax_internalkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1 = keyvars[0];
   v2 = keyvars[1];
   v3 = keyvars[2];
   v4 = keyvars[3];
   v5 = keyvars[4];
   v6 = keyvars[5];
  }
  T0 = cl_list(6, v1, v2, v3, v4, v5, v6);
  value0 = cl_make_array(5, VV[22], ECL_SYM("ELEMENT-TYPE",1255), ECL_T, ECL_SYM("INITIAL-CONTENTS",1287), T0);
  return value0;
 }
}
/* function definition for MAKE-LOOP-MINIMAX                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L421make_loop_minimax(cl_object v1answer_variable, cl_object v2type)
{
 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 v3infinity_data;
  {
   cl_object v4;
   cl_object v5;
   v4 = ecl_cmp_symbol_value(cl_env_copy,VV[24]);
   {
    cl_object v6;
    v6 = ecl_make_cfun_va((cl_objectfn)LC420__lambda94_va,ECL_NIL,Cblock,2);
    v5 = v6;
   }
   {
    cl_object v6;
    v6 = v4;
    goto L9;
L8:;
    {
     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);
     if (Null(v8)){
      goto L11;
     }
     {
      cl_object v9;
      {
       cl_object v10;
       v10 = v8;
       if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v10;
      }
      v9 = ECL_CONS_CAR(T1);
      if (Null(cl_subtypep(3, v2type, v9, ecl_cmp_symbol_value(cl_env_copy,VV[27])))){
       goto L11;
      }
      T0 = v8;
      goto L3;
     }
    }
L11:;
    v6 = ECL_CONS_CDR(v6);
L9:;
    if (v6==ECL_NIL) {
     goto L24;
    }
    goto L8;
L24:;
    T0 = ECL_NIL;
   }
  }
L3:;
  v3infinity_data = ecl_cdr(T0);
  T0 = cl_gensym(1, VV[33]);
  if (v3infinity_data!=ECL_NIL) {
   goto L28;
  }
  T1 = cl_gensym(1, VV[35]);
  goto L26;
L28:;
  T1 = ECL_NIL;
  goto L26;
L26:;
  value0 = L419make_loop_minimax_internal(12, VV[31], v1answer_variable, ECL_SYM("TYPE",1356), v2type, VV[32], T0, VV[34], T1, VV[36], ECL_NIL, VV[37], v3infinity_data);
  return value0;
 }
}
/* function definition for LOOP-NOTE-MINIMAX-OPERATION                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L422loop_note_minimax_operation(cl_object v1operation, cl_object v2minimax)
{
 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;
  T0 = (cl_env_copy->function=(VV[39]->symbol.gfdef))->cfun.entry(1, v2minimax) /*  LOOP-MINIMAX-OPERATIONS */;
  v3 = cl_adjoin(2, v1operation, T0);
  ecl_elt_set(v2minimax,(cl_fixnum)(4),v3);
 }
 T0 = (cl_env_copy->function=(VV[39]->symbol.gfdef))->cfun.entry(1, v2minimax) /*  LOOP-MINIMAX-OPERATIONS */;
 if (Null(ecl_cdr(T0))){
  goto L4;
 }
 if ((cl_env_copy->function=(VV[40]->symbol.gfdef))->cfun.entry(1, v2minimax) /*  LOOP-MINIMAX-FLAG-VARIABLE */!=ECL_NIL) {
  goto L4;
 }
 {
  cl_object v3;
  v3 = cl_gensym(1, VV[35]);
  ecl_elt_set(v2minimax,(cl_fixnum)(3),v3);
 }
L4:;
 value0 = v1operation;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function WITH-MINIMAX-VALUE                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC423with_minimax_value(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4lm;
  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);
   v4lm = v5;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   cl_object v8;
   cl_object v9;
   cl_object v10;
   cl_object v11;
   T0 = (cl_env_copy->function=(VV[43]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-TYPE */;
   v5 = L461loop_typed_init(T0);
   T0 = (cl_env_copy->function=(VV[39]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-OPERATIONS */;
   v6 = ecl_car(T0);
   v7 = (cl_env_copy->function=(VV[44]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-INFINITY-DATA */;
   v8 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-ANSWER-VARIABLE */;
   v9 = (cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-TEMP-VARIABLE */;
   v10 = (cl_env_copy->function=(VV[40]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-FLAG-VARIABLE */;
   v11 = (cl_env_copy->function=(VV[43]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-TYPE */;
   if (Null(v10)){
    goto L16;
   }
   T0 = cl_list(2, v8, v5);
   T1 = cl_list(2, v9, v5);
   T2 = cl_list(2, v10, ECL_NIL);
   T3 = cl_list(3, T0, T1, T2);
   T4 = cl_list(4, ECL_SYM("TYPE",872), v11, v8, v9);
   T5 = cl_list(2, ECL_SYM("DECLARE",276), T4);
   value0 = cl_listX(4, ECL_SYM("LET",479), T3, T5, v3);
   return value0;
L16:;
   if (!((v6)==(ECL_SYM("MIN",559)))){
    goto L19;
   }
   T0 = ecl_car(v7);
   goto L18;
L19:;
   T0 = ecl_cadr(v7);
L18:;
   T1 = cl_list(2, v8, T0);
   T2 = cl_list(2, v9, v5);
   T3 = cl_list(2, T1, T2);
   T4 = cl_list(4, ECL_SYM("TYPE",872), v11, v8, v9);
   T5 = cl_list(2, ECL_SYM("DECLARE",276), T4);
   value0 = cl_listX(4, ECL_SYM("LET",479), T3, T5, v3);
   return value0;
  }
 }
}
static cl_object LC423with_minimax_value_va(cl_narg narg, cl_object v12, cl_object v13, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[41]);
 {
  return LC423with_minimax_value(v12, v13);
 }
}
/* local function LOOP-ACCUMULATE-MINIMAX-VALUE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC424loop_accumulate_minimax_value(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4lm;
  cl_object v5operation;
  cl_object v6form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4lm = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5operation = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L16;
  }
  si_dm_too_few_arguments(v1);
L16:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6form = v7;
  }
  if (Null(v3)){
   goto L21;
  }
  si_dm_too_many_arguments(v1);
L21:;
  {
   cl_object v7answer_var;
   cl_object v8temp_var;
   cl_object v9flag_var;
   cl_object v10test;
   v7answer_var = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-ANSWER-VARIABLE */;
   v8temp_var = (cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-TEMP-VARIABLE */;
   v9flag_var = (cl_env_copy->function=(VV[40]->symbol.gfdef))->cfun.entry(1, v4lm) /*  LOOP-MINIMAX-FLAG-VARIABLE */;
   if (!((v5operation)==(ECL_SYM("MIN",559)))){
    goto L28;
   }
   T0 = ECL_SYM("<",74);
   goto L27;
L28:;
   if (!((v5operation)==(ECL_SYM("MAX",553)))){
    goto L30;
   }
   T0 = ECL_SYM(">",77);
   goto L27;
L30:;
   T0 = si_ecase_error(v5operation, VV[49]);
L27:;
   v10test = cl_list(3, T0, v8temp_var, v7answer_var);
   T0 = cl_list(3, ECL_SYM("SETQ",754), v8temp_var, v6form);
   if (Null(v9flag_var)){
    goto L33;
   }
   T2 = cl_list(2, ECL_SYM("NOT",586), v9flag_var);
   T1 = cl_list(3, ECL_SYM("OR",616), T2, v10test);
   goto L32;
L33:;
   T1 = v10test;
L32:;
   if (Null(v9flag_var)){
    goto L37;
   }
   T2 = cl_list(2, v9flag_var, ECL_T);
   goto L35;
L37:;
   T2 = ECL_NIL;
   goto L35;
L35:;
   T3 = cl_list(2, v7answer_var, v8temp_var);
   T4 = ecl_append(T2,T3);
   T5 = CONS(ECL_SYM("SETQ",754),T4);
   T6 = cl_list(3, ECL_SYM("WHEN",909), T1, T5);
   value0 = cl_list(3, ECL_SYM("PROGN",674), T0, T6);
   return value0;
  }
 }
}
static cl_object LC424loop_accumulate_minimax_value_va(cl_narg narg, cl_object v11, cl_object v12, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[48]);
 {
  return LC424loop_accumulate_minimax_value(v11, v12);
 }
}
/* function definition for LOOP-TEQUAL                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L425loop_tequal(cl_object v1x1, cl_object v2x2)
{
 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(v1x1))){
  goto L3;
 }
 value0 = cl_stringE(2, v1x1, v2x2);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-TASSOC                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L426loop_tassoc(cl_object v1kwd, cl_object v2alist)
{
 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(v1kwd))){
  goto L3;
 }
 {
  cl_object v3;
  v3 = (ECL_SYM("STRING=",825)->symbol.gfdef);
  {
   cl_object v4;
   v4 = v2alist;
   goto L9;
L8:;
   {
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = v4;
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v7;
    }
    v6 = ECL_CONS_CAR(v5);
    if (Null(v6)){
     goto L11;
    }
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = v6;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v8;
     }
     v7 = ECL_CONS_CAR(T0);
     if (Null(cl_stringE(2, v1kwd, v7))){
      goto L11;
     }
     value0 = v6;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
L11:;
   v4 = ECL_CONS_CDR(v4);
L9:;
   if (v4==ECL_NIL) {
    goto L24;
   }
   goto L8;
L24:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-TMEMBER                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L427loop_tmember(cl_object v1kwd, cl_object v2list)
{
 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(v1kwd))){
  goto L3;
 }
 {
  cl_object v3;
  v3 = (ECL_SYM("STRING=",825)->symbol.gfdef);
  {
   cl_object v4;
   v4 = v2list;
   goto L9;
L8:;
   {
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = v4;
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v7;
    }
    v6 = ECL_CONS_CAR(v5);
    if (Null(cl_stringE(2, v1kwd, v6))){
     goto L11;
    }
    value0 = v5;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L11:;
   v4 = ECL_CONS_CDR(v4);
L9:;
   if (v4==ECL_NIL) {
    goto L19;
   }
   goto L8;
L19:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-LOOKUP-KEYWORD                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L428loop_lookup_keyword(cl_object v1loop_token, cl_object v2table)
{
 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(v1loop_token))){
  goto L3;
 }
 T0 = ecl_symbol_name(v1loop_token);
 value0 = ecl_gethash_safe(T0,v2table,ECL_NIL);
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function LOOP-STORE-TABLE-DATA                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC429loop_store_table_data(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 v4symbol;
  cl_object v5table;
  cl_object v6datum;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4symbol = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5table = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L16;
  }
  si_dm_too_few_arguments(v1);
L16:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6datum = v7;
  }
  if (Null(v3)){
   goto L21;
  }
  si_dm_too_many_arguments(v1);
L21:;
  T0 = cl_list(2, ECL_SYM("SYMBOL-NAME",846), v4symbol);
  T1 = cl_list(3, ECL_SYM("GETHASH",415), T0, v5table);
  value0 = cl_list(3, ECL_SYM("SETF",753), T1, v6datum);
  return value0;
 }
}
static cl_object LC429loop_store_table_data_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[55]);
 {
  return LC429loop_store_table_data(v7, v8);
 }
}
/* function definition for MAKE-LOOP-UNIVERSE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L430make_loop_universe(cl_narg narg, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1;
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  cl_object v6;
  cl_object v7;
  cl_object v8;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[16];
   cl_parse_key(args,8,L430make_loop_universekeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1 = keyvars[0];
   v2 = keyvars[1];
   v3 = keyvars[2];
   v4 = keyvars[3];
   v5 = keyvars[4];
   v6 = keyvars[5];
   v7 = keyvars[6];
   v8 = keyvars[7];
  }
  T0 = cl_list(8, v1, v2, v3, v4, v5, v6, v7, v8);
  value0 = cl_make_array(5, VV[60], ECL_SYM("ELEMENT-TYPE",1255), ECL_T, ECL_SYM("INITIAL-CONTENTS",1287), T0);
  return value0;
 }
}
/* function definition for MAKE-STANDARD-LOOP-UNIVERSE                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L432make_standard_loop_universe(cl_narg narg, ...)
{
 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);
 {
  cl_object v1keywords;
  cl_object v2for_keywords;
  cl_object v3iteration_keywords;
  cl_object v4path_keywords;
  cl_object v5type_keywords;
  cl_object v6type_symbols;
  cl_object v7ansi;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[14];
   cl_parse_key(args,7,L432make_standard_loop_universekeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1keywords = keyvars[0];
   v2for_keywords = keyvars[1];
   v3iteration_keywords = keyvars[2];
   v4path_keywords = keyvars[3];
   v5type_keywords = keyvars[4];
   v6type_symbols = keyvars[5];
   v7ansi = keyvars[6];
  }
  T0 = LC431maketable(v1keywords);
  T1 = LC431maketable(v2for_keywords);
  T2 = LC431maketable(v3iteration_keywords);
  T3 = LC431maketable(v4path_keywords);
  {
   bool v8;
   v8 = v7ansi==ECL_NIL;
   T4 = (v8)?ECL_NIL:ECL_T;
  }
  T5 = LC431maketable(v5type_keywords);
  {
   cl_object v8size;
   cl_object v9ht;
   v8size = ecl_make_fixnum(ecl_length(v6type_symbols));
   if (!((ecl_fixnum(v8size))<((cl_fixnum)(10)))){
    goto L11;
   }
   T7 = ecl_make_int8_t(10);
   goto L10;
L11:;
   T7 = v8size;
L10:;
   T8 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v9ht = cl_make_hash_table(4, ECL_SYM("SIZE",1345), T7, ECL_SYM("TEST",1353), T8);
   {
    cl_object v10;
    v10 = v6type_symbols;
    goto L18;
L17:;
    {
     cl_object v11x;
     v11x = ecl_car(v10);
     if (!(ECL_ATOM(v11x))){
      goto L23;
     }
     si_hash_set(v11x, v9ht, v11x);
     goto L22;
L23:;
     T7 = ecl_car(v11x);
     T8 = ecl_cadr(v11x);
     si_hash_set(T7, v9ht, T8);
L22:;
    }
    v10 = ecl_cdr(v10);
L18:;
    if (Null(v10)){
     goto L27;
    }
    goto L17;
L27:;
   }
   T6 = v9ht;
  }
  value0 = L430make_loop_universe(16, VV[65], T0, VV[66], T1, VV[67], T2, VV[68], T3, VV[69], v7ansi, VV[70], T4, VV[71], T5, VV[72], T6);
  return value0;
 }
}
/* function definition for LOOP-MAKE-PSETQ                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L433loop_make_psetq(cl_object v1frobs)
{
 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(v1frobs)){
  goto L3;
 }
 T0 = ecl_car(v1frobs);
 T2 = ecl_cddr(v1frobs);
 if (!(T2==ECL_NIL)){
  goto L6;
 }
 T1 = ecl_cadr(v1frobs);
 goto L5;
L6:;
 T2 = ecl_cadr(v1frobs);
 T3 = ecl_cddr(v1frobs);
 T4 = L433loop_make_psetq(T3);
 T1 = cl_list(3, ECL_SYM("PROG1",672), T2, T4);
L5:;
 T2 = cl_list(2, T0, T1);
 value0 = L434loop_make_desetq(T2);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-MAKE-DESETQ                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L434loop_make_desetq(cl_object v1var_val_pairs)
{
 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 (!(v1var_val_pairs==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[73]))){
  goto L5;
 }
 T0 = ecl_cadr(ecl_cmp_symbol_value(cl_env_copy,VV[73]));
 goto L4;
L5:;
 T0 = VV[76];
L4:;
 value0 = CONS(T0,v1var_val_pairs);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function LOOP-REALLY-DESETQ                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC438loop_really_desetq(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 volatile struct ecl_cclosure aux_closure;
 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(v2env,env0);                  /*  ENV                     */
 {
  cl_object v3;
  cl_object v4var_val_pairs;
  v3 = ecl_cdr(v1);
  v4var_val_pairs = v3;
  {
   cl_object v5actions;
   v5actions = ECL_NIL;
   goto L6;
L5:;
   {
    cl_object v6;
    v6 = v4var_val_pairs;
    {
     cl_object v7;
     v7 = v6;
     {
      bool v8;
      v8 = ECL_LISTP(v7);
      if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[79],v7);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v6)){
     goto L16;
    }
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     v4var_val_pairs = v7;
     v6 = ECL_CONS_CAR(v6);
    }
L16:;
    T1 = v6;
   }
   {
    cl_object v6;
    v6 = v4var_val_pairs;
    {
     cl_object v7;
     v7 = v6;
     {
      bool v8;
      v8 = ECL_LISTP(v7);
      if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[79],v7);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v6)){
     goto L27;
    }
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     v4var_val_pairs = v7;
     v6 = ECL_CONS_CAR(v6);
    }
L27:;
    T2 = v6;
   }
   T0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC437loop_desetq_internal(2, T1, T2));
   v5actions = cl_revappend(T0, v5actions);
L6:;
   if (v4var_val_pairs==ECL_NIL) {
    goto L33;
   }
   goto L5;
L33:;
   T0 = ecl_cdr(v5actions);
   if (!(T0==ECL_NIL)){
    goto L35;
   }
   value0 = ecl_car(v5actions);
   cl_env_copy->nvalues = 1;
   return value0;
L35:;
   T0 = cl_nreverse(v5actions);
   value0 = CONS(ECL_SYM("PROGN",674),T0);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC438loop_really_desetq_va(cl_narg narg, cl_object v6, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[76]);
 {
  return LC438loop_really_desetq(v6, v7env);
 }
}
/* function definition for LOOP-CONSTANT-FOLD-IF-POSSIBLE                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L439loop_constant_fold_if_possible(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[108]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[108]);
 {
  cl_object v2expected_type;
  va_list args; va_start(args,v1form);
  {
   int i = 1;
   if (i >= narg) {
    v2expected_type = ECL_NIL;
   } else {
    i++;
    v2expected_type = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3constantp;
   cl_object v4constant_value;
   v3constantp = ECL_NIL;
   v4constant_value = ECL_NIL;
   v3constantp = cl_constantp(1, v1form);
   if (Null(v3constantp)){
    goto L4;
   }
   v4constant_value = cl_eval(v1form);
L4:;
   if (Null(v3constantp)){
    goto L8;
   }
   if (Null(v2expected_type)){
    goto L8;
   }
   if (cl_typep(3, v4constant_value, v2expected_type, ecl_cmp_symbol_value(cl_env_copy,VV[27]))!=ECL_NIL) {
    goto L8;
   }
   L443loop_warn(4, VV[110], v1form, v4constant_value, v2expected_type);
   v3constantp = ECL_NIL;
   v4constant_value = ECL_NIL;
L8:;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = v4constant_value;
   cl_env_copy->values[1] = v3constantp;
   cl_env_copy->values[0] = v1form;
   return cl_env_copy->values[0];
  }
 }
}
/* local function LOOP-BODY                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC440loop_body(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4prologue;
  cl_object v5before_loop;
  cl_object v6main_body;
  cl_object v7after_loop;
  cl_object v8epilogue;
  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);
   v4prologue = v9;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v9;
   v9 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5before_loop = v9;
  }
  if (!(v3==ECL_NIL)){
   goto L16;
  }
  si_dm_too_few_arguments(v1);
L16:;
  {
   cl_object v9;
   v9 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6main_body = v9;
  }
  if (!(v3==ECL_NIL)){
   goto L22;
  }
  si_dm_too_few_arguments(v1);
L22:;
  {
   cl_object v9;
   v9 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v7after_loop = v9;
  }
  if (!(v3==ECL_NIL)){
   goto L28;
  }
  si_dm_too_few_arguments(v1);
L28:;
  {
   cl_object v9;
   v9 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v8epilogue = v9;
  }
  if (Null(v3)){
   goto L33;
  }
  si_dm_too_many_arguments(v1);
L33:;
  {
   cl_fixnum v9;
   v9 = ecl_length(v5before_loop);
   {
    cl_fixnum v10;
    v10 = ecl_length(v7after_loop);
    if ((v9)==(v10)) {
     goto L35;
    }
   }
  }
  cl_error(1, VV[113]);
L35:;
  {
   cl_object v9;
   cl_object v10;
   cl_object v11rbefore;
   cl_object v12rafter;
   v9 = cl_reverse(v5before_loop);
   v10 = cl_reverse(v7after_loop);
   v11rbefore = v9;
   v12rafter = v10;
   goto L44;
L43:;
   {
    cl_object v13;
    v13 = v11rbefore;
    {
     cl_object v14;
     v14 = v13;
     {
      bool v15;
      v15 = ECL_LISTP(v14);
      if (ecl_unlikely(!(v15)))
         FEwrong_type_argument(VV[79],v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v13)){
     goto L53;
    }
    {
     cl_object v14;
     v14 = ECL_CONS_CDR(v13);
     v11rbefore = v14;
     v13 = ECL_CONS_CAR(v13);
    }
L53:;
    T0 = v13;
   }
   v6main_body = CONS(T0,v6main_body);
   {
    cl_object v13;
    v13 = v12rafter;
    {
     cl_object v14;
     v14 = v13;
     {
      bool v15;
      v15 = ECL_LISTP(v14);
      if (ecl_unlikely(!(v15)))
         FEwrong_type_argument(VV[79],v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v13)){
     goto L64;
    }
    {
     cl_object v14;
     v14 = ECL_CONS_CDR(v13);
     v12rafter = v14;
     v13 = ECL_CONS_CAR(v13);
    }
L64:;
   }
L44:;
   if (v11rbefore==ECL_NIL) {
    goto L70;
   }
   T0 = ecl_car(v11rbefore);
   T1 = ecl_car(v12rafter);
   if (!(ecl_equal(T0,T1))){
    goto L70;
   }
   goto L43;
L70:;
   T0 = cl_remove(2, ECL_NIL, v4prologue);
   T1 = cl_remove(2, ECL_NIL, v11rbefore);
   T2 = cl_nreverse(T1);
   T3 = cl_remove(2, ECL_NIL, v6main_body);
   T4 = cl_remove(2, ECL_NIL, v12rafter);
   T5 = cl_nreverse(T4);
   T6 = cl_remove(2, ECL_NIL, v8epilogue);
   T7 = cl_listX(3, VV[115], VV[116], T6);
   T8 = cl_append(3, T3, T5, T7);
   T9 = CONS(VV[114],T8);
   T10 = cl_append(3, T0, T2, T9);
   value0 = CONS(ECL_SYM("TAGBODY",853),T10);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC440loop_body_va(cl_narg narg, cl_object v13, cl_object v14env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[82]);
 {
  return LC440loop_body(v13, v14env);
 }
}
/* function definition for LOOP-CONTEXT                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L441loop_context()
{
 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 v1;
  cl_object v2l;
  cl_object v3new;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[86]);
  v2l = v1;
  v3new = ECL_NIL;
  goto L7;
L6:;
  T0 = ecl_cdr(v2l);
  T1 = ecl_car(v2l);
  v3new = CONS(T1,v3new);
  v2l = T0;
L7:;
  T0 = ecl_cdr(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if ((v2l)==(T0)) {
   goto L12;
  }
  goto L6;
L12:;
  value0 = cl_nreverse(v3new);
  return value0;
 }
}
/* function definition for LOOP-ERROR                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L442loop_error(cl_narg narg, cl_object v1format_string, ...)
{
 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[119]);
 {
  cl_object v2format_args;
  ecl_va_list args; ecl_va_start(args,v1format_string,narg,1);
  v2format_args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = L441loop_context();
  value0 = si_simple_program_error(4, VV[120], v1format_string, v2format_args, T0);
  return value0;
 }
}
/* function definition for LOOP-WARN                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L443loop_warn(cl_narg narg, cl_object v1format_string, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[109]);
 {
  cl_object v2format_args;
  ecl_va_list args; ecl_va_start(args,v1format_string,narg,1);
  v2format_args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = L441loop_context();
  T1 = cl_list(3, v1format_string, v2format_args, T0);
  value0 = (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(5, VV[121], ECL_SYM("FORMAT-CONTROL",1272), VV[120], ECL_SYM("FORMAT-ARGUMENTS",1271), T1) /*  WARN */;
  return value0;
 }
}
/* function definition for LOOP-CHECK-DATA-TYPE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L444loop_check_data_type(cl_narg narg, cl_object v1specified_type, cl_object v2required_type, ...)
{
 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[122]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[122]);
 {
  cl_object v3default_type;
  va_list args; va_start(args,v2required_type);
  {
   int i = 2;
   if (i >= narg) {
    v3default_type = v2required_type;
   } else {
    i++;
    v3default_type = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(v1specified_type==ECL_NIL)){
   goto L2;
  }
  value0 = v3default_type;
  cl_env_copy->nvalues = 1;
  return value0;
L2:;
  {
   cl_object v4;                                  /*  A                       */
   cl_object v5;                                  /*  B                       */
   value0 = cl_subtypep(3, v1specified_type, v2required_type, ecl_cmp_symbol_value(cl_env_copy,VV[27]));
   {
    v4 = value0;
    v5 = cl_env_copy->values[1];
   }
   if (v5!=ECL_NIL) {
    goto L6;
   }
   L443loop_warn(3, VV[123], v1specified_type, v2required_type);
   goto L5;
L6:;
   if (v4!=ECL_NIL) {
    goto L5;
   }
   L442loop_error(3, VV[124], v1specified_type, v2required_type);
L5:;
   value0 = v1specified_type;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function LOOP-FINISH                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC445loop_finish(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[125];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC445loop_finish_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[126]);
 {
  return LC445loop_finish(v4, v5);
 }
}
/* function definition for SUBST-GENSYMS-FOR-NIL                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L446subst_gensyms_for_nil(cl_object v1tree)
{
 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 (!(v1tree==ECL_NIL)){
  goto L2;
 }
 T0 = cl_gensym(0);
 T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[127]));
 ecl_cmp_setq(cl_env_copy,VV[127],T1);
 value0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[127]));
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_ATOM(v1tree))){
  goto L5;
 }
 value0 = v1tree;
 cl_env_copy->nvalues = 1;
 return value0;
L5:;
 T0 = ecl_cdr(v1tree);
 if (!(ECL_ATOM(T0))){
  goto L7;
 }
 T0 = ecl_car(v1tree);
 T1 = L446subst_gensyms_for_nil(T0);
 T2 = ecl_cdr(v1tree);
 T3 = L446subst_gensyms_for_nil(T2);
 value0 = CONS(T1,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L7:;
 {
  cl_object v2acc;
  cl_object v3acc_last;
  cl_object v4elt;
  v2acc = CONS(ECL_SYM("&OPTIONAL",13),ECL_NIL);
  v3acc_last = v2acc;
  v4elt = v1tree;
  goto L14;
L13:;
  {
   cl_object v5;
   T0 = ecl_car(v4elt);
   T1 = L446subst_gensyms_for_nil(T0);
   v5 = CONS(T1,ECL_NIL);
   {
    cl_object v6;
    v6 = v3acc_last;
    if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v6;
   }
   (ECL_CONS_CDR(T0)=v5,T0);
  }
  v3acc_last = ecl_cdr(v3acc_last);
  v4elt = ecl_cdr(v4elt);
L14:;
  if (ECL_ATOM(v4elt)) {
   goto L26;
  }
  goto L13;
L26:;
  {
   cl_object v5;
   v5 = v4elt;
   {
    cl_object v6;
    v6 = v3acc_last;
    if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v6;
   }
   (ECL_CONS_CDR(T0)=v5,T0);
  }
  value0 = v2acc;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L446subst_gensyms_for_nil_va(cl_narg narg, cl_object v5tree, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[128]);
 {
  return L446subst_gensyms_for_nil(v5tree);
 }
}
/* function definition for LOOP-BUILD-DESTRUCTURING-BINDINGS                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L447loop_build_destructuring_bindings(cl_object v1crocks, cl_object v2forms)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(v1crocks)){
  goto L2;
 }
 ecl_bds_bind(cl_env_copy,VV[127],ECL_NIL);       /*  *IGNORES*               */
 T0 = ecl_car(v1crocks);
 T1 = L446subst_gensyms_for_nil(T0);
 T2 = ecl_cadr(v1crocks);
 T3 = CONS(ECL_SYM("IGNORE",430),ecl_cmp_symbol_value(cl_env_copy,VV[127]));
 T4 = cl_list(2, ECL_SYM("DECLARE",276), T3);
 T5 = ecl_cddr(v1crocks);
 T6 = L447loop_build_destructuring_bindings(T5, v2forms);
 T7 = cl_listX(5, ECL_SYM("DESTRUCTURING-BIND",302), T1, T2, T4, T6);
 value0 = ecl_list1(T7);
 cl_env_copy->nvalues = 1;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
L2:;
 value0 = v2forms;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L447loop_build_destructuring_bindings_va(cl_narg narg, cl_object v3crocks, cl_object v4forms, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[130]);
 {
  return L447loop_build_destructuring_bindings(v3crocks, v4forms);
 }
}
/* function definition for LOOP-TRANSLATE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L448loop_translate(cl_object v1_loop_source_code_, cl_object v2_loop_macro_environment_, cl_object v3_loop_universe_)
{
 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);
 ecl_bds_bind(cl_env_copy,VV[84],v1_loop_source_code_); /*  *LOOP-SOURCE-CODE* */
 ecl_bds_bind(cl_env_copy,VV[27],v2_loop_macro_environment_); /*  *LOOP-MACRO-ENVIRONMENT* */
 ecl_bds_bind(cl_env_copy,VV[62],v3_loop_universe_); /*  *LOOP-UNIVERSE*      */
L1:;
 {
  cl_object v4;
  v4 = ecl_cmp_symbol_value(cl_env_copy,VV[84]);
  ecl_bds_bind(cl_env_copy,VV[85],v4);            /*  *LOOP-ORIGINAL-SOURCE-CODE* */
  ecl_bds_bind(cl_env_copy,VV[86],ECL_NIL);       /*  *LOOP-SOURCE-CONTEXT*   */
  ecl_bds_bind(cl_env_copy,VV[95],ECL_NIL);       /*  *LOOP-ITERATION-VARIABLES* */
  ecl_bds_bind(cl_env_copy,VV[89],ECL_NIL);       /*  *LOOP-VARIABLES*        */
  ecl_bds_bind(cl_env_copy,VV[94],ECL_NIL);       /*  *LOOP-NODECLARE*        */
  ecl_bds_bind(cl_env_copy,VV[88],ECL_NIL);       /*  *LOOP-NAMED-VARIABLES*  */
  ecl_bds_bind(cl_env_copy,VV[90],ECL_NIL);       /*  *LOOP-DECLARATIONS*     */
  ecl_bds_bind(cl_env_copy,VV[91],ECL_NIL);       /*  *LOOP-DESETQ-CROCKS*    */
  ecl_bds_bind(cl_env_copy,VV[93],ECL_NIL);       /*  *LOOP-BIND-STACK*       */
  ecl_bds_bind(cl_env_copy,VV[96],ECL_NIL);       /*  *LOOP-PROLOGUE*         */
  ecl_bds_bind(cl_env_copy,VV[92],ECL_NIL);       /*  *LOOP-WRAPPERS*         */
  ecl_bds_bind(cl_env_copy,VV[97],ECL_NIL);       /*  *LOOP-BEFORE-LOOP*      */
  ecl_bds_bind(cl_env_copy,VV[98],ECL_NIL);       /*  *LOOP-BODY*             */
  ecl_bds_bind(cl_env_copy,VV[100],ECL_NIL);      /*  *LOOP-EMITTED-BODY*     */
  ecl_bds_bind(cl_env_copy,VV[99],ECL_NIL);       /*  *LOOP-AFTER-BODY*       */
  ecl_bds_bind(cl_env_copy,VV[101],ECL_NIL);      /*  *LOOP-EPILOGUE*         */
  ecl_bds_bind(cl_env_copy,VV[102],ECL_NIL);      /*  *LOOP-AFTER-EPILOGUE*   */
  ecl_bds_bind(cl_env_copy,VV[103],ECL_NIL);      /*  *LOOP-FINAL-VALUE-CULPRIT* */
  ecl_bds_bind(cl_env_copy,VV[104],ECL_NIL);      /*  *LOOP-INSIDE-CONDITIONAL* */
  ecl_bds_bind(cl_env_copy,VV[105],ECL_NIL);      /*  *LOOP-WHEN-IT-VARIABLE* */
  ecl_bds_bind(cl_env_copy,VV[106],ECL_NIL);      /*  *LOOP-NEVER-STEPPED-VARIABLE* */
  ecl_bds_bind(cl_env_copy,VV[87],ECL_NIL);       /*  *LOOP-NAMES*            */
  ecl_bds_bind(cl_env_copy,VV[107],ECL_NIL);      /*  *LOOP-COLLECTION-CRUFT* */
  L449loop_iteration_driver();
  L465loop_bind_block();
  {
   cl_object v5answer;
   T0 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[96]));
   T1 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[97]));
   T2 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[98]));
   T3 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[99]));
   T4 = ecl_cmp_symbol_value(cl_env_copy,VV[101]);
   T5 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[102]));
   T6 = cl_nreconc(T4, T5);
   v5answer = cl_list(6, VV[82], T0, T1, T2, T3, T6);
   {
    cl_object v6;
    v6 = ecl_cmp_symbol_value(cl_env_copy,VV[93]);
    goto L11;
L10:;
    {
     cl_object v7entry;
     v7entry = ecl_car(v6);
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      cl_object v11;
      v8 = ecl_car(v7entry);
      v9 = ecl_cadr(v7entry);
      v10 = ecl_caddr(v7entry);
      v11 = ecl_cadddr(v7entry);
      {
       cl_object v12;
       v12 = v11;
       goto L24;
L23:;
       {
        cl_object v13w;
        v13w = ecl_car(v12);
        T0 = ecl_list1(v5answer);
        v5answer = ecl_append(v13w,T0);
       }
       v12 = ecl_cdr(v12);
L24:;
       if (Null(v12)){
        goto L32;
       }
       goto L23;
L32:;
      }
      if (v8!=ECL_NIL) {
       goto L35;
      }
      if (v9!=ECL_NIL) {
       goto L35;
      }
      if (Null(v10)){
       goto L15;
      }
      goto L34;
L35:;
L34:;
      {
       cl_object v12forms;
       v12forms = ecl_list1(v5answer);
       if (Null(v9)){
        goto L39;
       }
       T0 = CONS(ECL_SYM("DECLARE",276),v9);
       v12forms = CONS(T0,v12forms);
L39:;
       if (v8!=ECL_NIL) {
        goto L44;
       }
       T0 = ECL_SYM("LOCALLY",492);
       goto L43;
L44:;
       if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[73]))){
        goto L46;
       }
       T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[73]));
       goto L43;
L46:;
       T0 = ECL_SYM("LET",479);
L43:;
       T1 = L447loop_build_destructuring_bindings(v10, v12forms);
       v5answer = cl_listX(3, T0, v8, T1);
      }
     }
L15:;
    }
    v6 = ecl_cdr(v6);
L11:;
    if (Null(v6)){
     goto L50;
    }
    goto L10;
L50:;
   }
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[87]))){
    goto L52;
   }
   goto L56;
L55:;
   {
    cl_object v6;
    v6 = ecl_cmp_symbol_value(cl_env_copy,VV[87]);
    {
     cl_object v7;
     v7 = v6;
     {
      bool v8;
      v8 = ECL_LISTP(v7);
      if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[79],v7);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v6)){
     goto L65;
    }
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     T1 = v7;
     ecl_cmp_setq(cl_env_copy,VV[87],T1);
     v6 = ECL_CONS_CAR(v6);
    }
L65:;
    T0 = v6;
   }
   v5answer = cl_list(3, ECL_SYM("BLOCK",139), T0, v5answer);
L56:;
   T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[87]));
   if (T0==ECL_NIL) {
    goto L71;
   }
   goto L55;
L71:;
   value0 = v5answer;
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind_n(cl_env_copy,26);
   return value0;
L52:;
   value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, v5answer);
   ecl_bds_unwind_n(cl_env_copy,26);
   return value0;
  }
 }
}
/* function definition for LOOP-ITERATION-DRIVER                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L449loop_iteration_driver()
{
 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:;
 goto L4;
L3:;
 {
  cl_object v1;
  cl_object v2tem;
  v1 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  v2tem = ECL_NIL;
  if (ECL_SYMBOLP(v1)) {
   goto L9;
  }
  L442loop_error(2, VV[135], v1);
  goto L6;
L9:;
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[84]);
  ecl_cmp_setq(cl_env_copy,VV[86],T0);
  L450loop_pop_source();
  T0 = (cl_env_copy->function=(VV[137]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-KEYWORDS */;
  v2tem = L428loop_lookup_keyword(v1, T0);
  if (Null(v2tem)){
   goto L14;
  }
  T0 = ecl_car(v2tem);
  T1 = cl_symbol_function(T0);
  T2 = ecl_cdr(v2tem);
  cl_apply(2, T1, T2);
  goto L6;
L14:;
  T0 = (cl_env_copy->function=(VV[138]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-ITERATION-KEYWORDS */;
  v2tem = L428loop_lookup_keyword(v1, T0);
  if (Null(v2tem)){
   goto L17;
  }
  L489loop_hack_iteration(v2tem);
  goto L6;
L17:;
  if (Null(L427loop_tmember(v1, VV[140]))){
   goto L20;
  }
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  T1 = ecl_cadr(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  L442loop_error(4, VV[141], v1, T0, T1);
  goto L6;
L20:;
  L442loop_error(2, VV[142], v1);
 }
L6:;
L4:;
 if (ecl_cmp_symbol_value(cl_env_copy,VV[84])==ECL_NIL) {
  goto L22;
 }
 goto L3;
L22:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-POP-SOURCE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L450loop_pop_source()
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[84]))){
  goto L2;
 }
 {
  cl_object v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[84]);
  {
   cl_object v2;
   v2 = v1;
   {
    bool v3;
    v3 = ECL_LISTP(v2);
    if (ecl_unlikely(!(v3)))
         FEwrong_type_argument(VV[79],v2);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
   }
  }
  if (Null(v1)){
   goto L8;
  }
  {
   cl_object v2;
   v2 = ECL_CONS_CDR(v1);
   T0 = v2;
   ecl_cmp_setq(cl_env_copy,VV[84],T0);
   v1 = ECL_CONS_CAR(v1);
  }
L8:;
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = L442loop_error(1, VV[143]);
 return value0;
}
/* function definition for LOOP-GET-COMPOUND-FORM                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L451loop_get_compound_form()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v1form;
  v1form = L453loop_get_form();
  if (ECL_CONSP(v1form)) {
   goto L3;
  }
  L442loop_error(2, VV[146], v1form);
L3:;
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-GET-PROGN                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L452loop_get_progn()
{
 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 v1;
  cl_object v2;
  cl_object v3forms;
  cl_object v4nextform;
  T0 = L451loop_get_compound_form();
  v1 = ecl_list1(T0);
  v2 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  v3forms = v1;
  v4nextform = v2;
  goto L8;
L7:;
  T0 = L451loop_get_compound_form();
  v3forms = CONS(T0,v3forms);
  v4nextform = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
L8:;
  if (ECL_ATOM(v4nextform)) {
   goto L13;
  }
  goto L7;
L13:;
  T0 = ecl_cdr(v3forms);
  if (!(T0==ECL_NIL)){
   goto L15;
  }
  value0 = ecl_car(v3forms);
  cl_env_copy->nvalues = 1;
  return value0;
L15:;
  T0 = cl_nreverse(v3forms);
  value0 = CONS(ECL_SYM("PROGN",674),T0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-GET-FORM                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L453loop_get_form()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[84]))){
  goto L2;
 }
 value0 = L450loop_pop_source();
 return value0;
L2:;
 value0 = L442loop_error(1, VV[148]);
 return value0;
}
/* function definition for LOOP-CONSTRUCT-RETURN                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L454loop_construct_return(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[87]));
 value0 = cl_list(3, ECL_SYM("RETURN-FROM",728), T0, v1form);
 return value0;
}
/* function definition for LOOP-PSEUDO-BODY                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L455loop_pseudo_body(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (ecl_cmp_symbol_value(cl_env_copy,VV[100])!=ECL_NIL) {
  goto L4;
 }
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[104]))){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 T0 = CONS(v1form,ecl_cmp_symbol_value(cl_env_copy,VV[98]));
 ecl_cmp_setq(cl_env_copy,VV[98],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[98]);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = CONS(v1form,ecl_cmp_symbol_value(cl_env_copy,VV[97]));
 ecl_cmp_setq(cl_env_copy,VV[97],T0);
 T0 = CONS(v1form,ecl_cmp_symbol_value(cl_env_copy,VV[99]));
 ecl_cmp_setq(cl_env_copy,VV[99],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[99]);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-EMIT-BODY                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L456loop_emit_body(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ECL_T;
 ecl_cmp_setq(cl_env_copy,VV[100],T0);
 T0 = CONS(v1form,ecl_cmp_symbol_value(cl_env_copy,VV[98]));
 ecl_cmp_setq(cl_env_copy,VV[98],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[98]);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-EMIT-FINAL-VALUE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L457loop_emit_final_value(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[152]);
 {
  cl_object v1form;
  cl_object v2form_supplied_p;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1form = ECL_NIL;
    v2form_supplied_p = ECL_NIL;
   } else {
    i++;
    v1form = va_arg(args,cl_object);
    v2form_supplied_p = ECL_T;
   }
  }
  va_end(args);
  if (Null(v2form_supplied_p)){
   goto L2;
  }
  T0 = L454loop_construct_return(v1form);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[102]));
  ecl_cmp_setq(cl_env_copy,VV[102],T1);
L2:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[103]))){
   goto L5;
  }
  L443loop_warn(2, VV[153], ecl_cmp_symbol_value(cl_env_copy,VV[103]));
L5:;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[86]));
  ecl_cmp_setq(cl_env_copy,VV[103],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[103]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-DISALLOW-CONDITIONAL                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L458loop_disallow_conditional(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[154]);
 {
  cl_object v1kwd;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1kwd = ECL_NIL;
   } else {
    i++;
    v1kwd = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[104]))){
   goto L2;
  }
  value0 = L442loop_error(2, VV[155], v1kwd);
  return value0;
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-DISALLOW-ANONYMOUS-COLLECTORS                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L459loop_disallow_anonymous_collectors()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(cl_find_if_not(2, VV[157], ecl_cmp_symbol_value(cl_env_copy,VV[107])))){
  goto L2;
 }
 value0 = L442loop_error(1, VV[158]);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L459loop_disallow_anonymous_collectors_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[156]);
 {
  return L459loop_disallow_anonymous_collectors();
 }
}
/* function definition for LOOP-DISALLOW-AGGREGATE-BOOLEANS                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L460loop_disallow_aggregate_booleans()
{
 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(L427loop_tmember(ecl_cmp_symbol_value(cl_env_copy,VV[103]), VV[161]))){
  goto L2;
 }
 value0 = L442loop_error(1, VV[162]);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L460loop_disallow_aggregate_booleans_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[160]);
 {
  return L460loop_disallow_aggregate_booleans();
 }
}
/* function definition for LOOP-TYPED-INIT                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L461loop_typed_init(cl_object v1data_type)
{
 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 (!(v1data_type==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (Null(cl_subtypep(2, v1data_type, ECL_SYM("CHARACTER",224)))){
  goto L4;
 }
 value0 = ECL_CODE_CHAR(48);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 if (cl_subtypep(2, v1data_type, ECL_SYM("NUMBER",608))!=ECL_NIL) {
  goto L6;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (Null(cl_subtypep(2, v1data_type, VV[164]))){
  goto L8;
 }
 value0 = cl_coerce(ecl_make_int8_t(0), v1data_type);
 return value0;
L8:;
 value0 = ecl_make_int8_t(0);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-OPTIONAL-TYPE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L464loop_optional_type(cl_narg narg, ...)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[165]);
 {
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    lex0[0] = ECL_NIL;                            /*  VARIABLE                */
   } else {
    i++;
    lex0[0] = va_arg(args,cl_object);             /*  VARIABLE                */
   }
  }
  va_end(args);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[84]))){
   goto L2;
  }
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  lex0[1] = T0;                                   /*  Z                       */
  if (Null(L425loop_tequal(lex0[1], VV[166]))){
   goto L4;
  }
  L450loop_pop_source();
  value0 = L450loop_pop_source();
  return value0;
L4:;
  if (!(ECL_SYMBOLP(lex0[1]))){
   goto L7;
  }
  {
   cl_object v1type_spec;
   T0 = (cl_env_copy->function=(VV[167]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-TYPE-SYMBOLS */;
   value0 = ecl_gethash_safe(lex0[1],T0,ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L11;
   }
   T0 = ecl_symbol_name(lex0[1]);
   T1 = (cl_env_copy->function=(VV[168]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-TYPE-KEYWORDS */;
   v1type_spec = ecl_gethash_safe(T0,T1,ECL_NIL);
   goto L9;
L11:;
   v1type_spec = value0;
   goto L9;
L9:;
   if (Null(v1type_spec)){
    goto L13;
   }
   L450loop_pop_source();
   value0 = v1type_spec;
   cl_env_copy->nvalues = 1;
   return value0;
L13:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L7:;
  if (!(ECL_CONSP(lex0[0]))){
   goto L17;
  }
  if (ECL_CONSP(lex0[1])) {
   goto L16;
  }
  L442loop_error(2, VV[169], lex0[1]);
  goto L16;
L17:;
  L442loop_error(2, VV[170], lex0[1]);
L16:;
  L450loop_pop_source();
  value0 = LC462translate(lex0, lex0[1], lex0[0]);
  return value0;
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-BIND-BLOCK                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L465loop_bind_block()
{
 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:;
 if (ecl_cmp_symbol_value(cl_env_copy,VV[89])!=ECL_NIL) {
  goto L4;
 }
 if (ecl_cmp_symbol_value(cl_env_copy,VV[90])!=ECL_NIL) {
  goto L4;
 }
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[92]))){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 T0 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[89]));
 T1 = cl_list(4, T0, ecl_cmp_symbol_value(cl_env_copy,VV[90]), ecl_cmp_symbol_value(cl_env_copy,VV[91]), ecl_cmp_symbol_value(cl_env_copy,VV[92]));
 T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[93]));
 ecl_cmp_setq(cl_env_copy,VV[93],T2);
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[89],T0);
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[90],T0);
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[91],T0);
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[92],T0);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-VARIABLE-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L466loop_variable_p(cl_object v1name)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2entry;
  v2entry = ecl_cmp_symbol_value(cl_env_copy,VV[93]);
  goto L5;
L4:;
  if (!(v2entry==ECL_NIL)){
   goto L8;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L8:;
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   cl_object v6;
   v3 = ecl_caar(v2entry);
   v4 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v5 = v1name;
   v6 = v3;
   if (Null(ecl_assq(v5,v6))){
    goto L7;
   }
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  v2entry = ecl_cdr(v2entry);
L5:;
  goto L4;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L466loop_variable_p_va(cl_narg narg, cl_object v3name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[175]);
 {
  return L466loop_variable_p(v3name);
 }
}
/* function definition for LOOP-MAKE-VARIABLE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L467loop_make_variable(cl_narg narg, cl_object v1name, cl_object v2initialization, cl_object v3dtype, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[177]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[177]);
 {
  cl_object v4iteration_variable_p;
  va_list args; va_start(args,v3dtype);
  {
   int i = 3;
   if (i >= narg) {
    v4iteration_variable_p = ECL_NIL;
   } else {
    i++;
    v4iteration_variable_p = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(v1name==ECL_NIL)){
   goto L3;
  }
  if (v2initialization==ECL_NIL) {
   goto L2;
  }
  v1name = cl_gensym(1, VV[178]);
  T0 = cl_list(2, v1name, v2initialization);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[89]));
  ecl_cmp_setq(cl_env_copy,VV[89],T1);
  T0 = cl_list(2, ECL_SYM("IGNORE",430), v1name);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[90]));
  ecl_cmp_setq(cl_env_copy,VV[90],T1);
  goto L2;
L3:;
  if (!(ECL_ATOM(v1name))){
   goto L10;
  }
  if (Null(v4iteration_variable_p)){
   goto L13;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[95]);
   v6 = v1name;
   v7 = v5;
   if (Null(ecl_memql(v6,v7))){
    goto L15;
   }
  }
  L442loop_error(2, VV[179], v1name);
  goto L12;
L15:;
  T0 = CONS(v1name,ecl_cmp_symbol_value(cl_env_copy,VV[95]));
  ecl_cmp_setq(cl_env_copy,VV[95],T0);
  goto L12;
L13:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[89]);
   v6 = v1name;
   v7 = v5;
   if (Null(ecl_assql(v6,v7))){
    goto L12;
   }
  }
  L442loop_error(2, VV[180], v1name);
L12:;
  if (ECL_SYMBOLP(v1name)) {
   goto L25;
  }
  L442loop_error(2, VV[181], v1name);
L25:;
  {
   cl_object v5init;
   value0 = v2initialization;
   if (value0!=ECL_NIL) {
    goto L29;
   }
   v5init = L461loop_typed_init(v3dtype);
   goto L27;
L29:;
   v5init = value0;
   goto L27;
L27:;
   L470loop_declare_variable(3, v1name, v3dtype, v5init);
   T0 = cl_list(2, v1name, v5init);
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[89]));
   ecl_cmp_setq(cl_env_copy,VV[89],T1);
   goto L2;
  }
L10:;
  if (Null(v2initialization)){
   goto L33;
  }
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[73]))){
   goto L35;
  }
  L470loop_declare_variable(2, v1name, v3dtype);
  T0 = cl_list(2, v1name, v2initialization);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[89]));
  ecl_cmp_setq(cl_env_copy,VV[89],T1);
  goto L2;
L35:;
  {
   cl_object v6newvar;
   v6newvar = cl_gensym(1, VV[183]);
   L470loop_declare_variable(2, v1name, v3dtype);
   T0 = cl_list(2, v6newvar, v2initialization);
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[89]));
   ecl_cmp_setq(cl_env_copy,VV[89],T1);
   T0 = cl_listX(3, v1name, v6newvar, ecl_cmp_symbol_value(cl_env_copy,VV[91]));
   ecl_cmp_setq(cl_env_copy,VV[91],T0);
   goto L2;
  }
L33:;
  {
   cl_object v7tcar;
   cl_object v8tcdr;
   v7tcar = ECL_NIL;
   v8tcdr = ECL_NIL;
   if (!(ECL_ATOM(v3dtype))){
    goto L47;
   }
   v8tcdr = v3dtype;
   v7tcar = v8tcdr;
   goto L46;
L47:;
   v7tcar = ecl_car(v3dtype);
   v8tcdr = ecl_cdr(v3dtype);
L46:;
   T0 = ecl_car(v1name);
   L467loop_make_variable(4, T0, ECL_NIL, v7tcar, v4iteration_variable_p);
   T0 = ecl_cdr(v1name);
   L467loop_make_variable(4, T0, ECL_NIL, v8tcdr, v4iteration_variable_p);
  }
L2:;
  value0 = v1name;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-MAKE-ITERATION-VARIABLE                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L468loop_make_iteration_variable(cl_object v1name, cl_object v2initialization, cl_object v3dtype)
{
 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 = L467loop_make_variable(4, v1name, v2initialization, v3dtype, ECL_T);
 return value0;
}
/* function definition for LOOP-DECLARE-VARIABLE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L470loop_declare_variable(cl_narg narg, cl_object v1name, cl_object v2dtype, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[182]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[182]);
 {
  cl_object v3initialization;
  cl_object v4initialization_p;
  va_list args; va_start(args,v2dtype);
  {
   int i = 2;
   if (i >= narg) {
    v3initialization = ECL_NIL;
    v4initialization_p = ECL_NIL;
   } else {
    i++;
    v3initialization = va_arg(args,cl_object);
    v4initialization_p = ECL_T;
   }
  }
  va_end(args);
  if (v1name==ECL_NIL) {
   goto L4;
  }
  if (v2dtype==ECL_NIL) {
   goto L4;
  }
  if (!((v2dtype)==(ECL_T))){
   goto L2;
  }
  goto L3;
L4:;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L2:;
  if (!(ECL_SYMBOLP(v1name))){
   goto L7;
  }
  if ((v2dtype)==(ECL_T)) {
   goto L9;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[94]);
   v6 = v1name;
   v7 = v5;
   if (ecl_memql(v6,v7)!=ECL_NIL) {
    goto L9;
   }
  }
  if (Null(v4initialization_p)){
   goto L15;
  }
  if (Null(cl_constantp(1, v3initialization))){
   goto L15;
  }
  {
   cl_object v5init_type;
   v5init_type = cl_type_of(v3initialization);
   if (cl_subtypep(3, v5init_type, v2dtype, ecl_cmp_symbol_value(cl_env_copy,VV[27]))!=ECL_NIL) {
    goto L15;
   }
   v2dtype = cl_list(3, ECL_SYM("OR",616), v2dtype, v5init_type);
  }
L15:;
  {
   cl_object v5previous;
   {
    cl_object v6;
    cl_object v7;
    v6 = ecl_cmp_symbol_value(cl_env_copy,VV[90]);
    {
     cl_object v8;
     v8 = ecl_make_cfun_va((cl_objectfn)LC469__lambda486_va,ECL_NIL,Cblock,1);
     v7 = v8;
    }
    {
     cl_object v8;
     v8 = si_make_seq_iterator(2, v6, ecl_make_int8_t(0));
L25:;
     if (v8!=ECL_NIL) {
      goto L27;
     }
     v5previous = ECL_NIL;
     goto L21;
L27:;
     {
      cl_object v9;
      v9 = si_seq_iterator_ref(v6, v8);
      if (!(ECL_CONSP(v9))){
       goto L34;
      }
      {
       cl_fixnum v10;
       v10 = ecl_length(v9);
       if (!((v10)==((cl_fixnum)(3)))){
        goto L34;
       }
      }
      T1 = ECL_CONS_CAR(v9);
      if (!((T1)==(ECL_SYM("TYPE",872)))){
       goto L34;
      }
      T0 = ecl_caddr(v9);
      goto L32;
L34:;
      T0 = ECL_NIL;
      goto L32;
L32:;
      if (!(ecl_eql(v1name,T0))){
       goto L29;
      }
      v5previous = v9;
      goto L21;
     }
L29:;
     v8 = si_seq_iterator_next(v6, v8);
     goto L25;
    }
   }
L21:;
   if (Null(v5previous)){
    goto L40;
   }
   {
    cl_object v6;
    v6 = v2dtype;
    {
     cl_object v7;
     v7 = ecl_cdr(v5previous);
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v7;
    }
    (ECL_CONS_CAR(T0)=v6,T0);
    value0 = v6;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L40:;
   T0 = cl_list(3, ECL_SYM("TYPE",872), v2dtype, v1name);
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[90]));
   ecl_cmp_setq(cl_env_copy,VV[90],T1);
   value0 = ecl_cmp_symbol_value(cl_env_copy,VV[90]);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L9:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  if (!(ECL_CONSP(v1name))){
   goto L48;
  }
  if (!(ECL_CONSP(v2dtype))){
   goto L50;
  }
  T0 = ecl_car(v1name);
  T1 = ecl_car(v2dtype);
  L470loop_declare_variable(3, T0, T1, ECL_NIL);
  T0 = ecl_cdr(v1name);
  T1 = ecl_cdr(v2dtype);
  value0 = L470loop_declare_variable(2, T0, T1);
  return value0;
L50:;
  T0 = ecl_car(v1name);
  L470loop_declare_variable(3, T0, v2dtype, ECL_NIL);
  T0 = ecl_cdr(v1name);
  value0 = L470loop_declare_variable(2, T0, v2dtype);
  return value0;
L48:;
  value0 = cl_error(2, VV[190], v1name);
  return value0;
 }
}
/* function definition for LOOP-MAYBE-BIND-FORM                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L471loop_maybe_bind_form(cl_object v1form, cl_object v2data_type)
{
 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(cl_constantp(2, v1form, ecl_cmp_symbol_value(cl_env_copy,VV[27])))){
  goto L2;
 }
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = cl_gensym(1, VV[192]);
 value0 = L467loop_make_variable(3, T0, v1form, v2data_type);
 return value0;
}
/* function definition for LOOP-DO-IF                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L473loop_do_if(cl_object v1for, cl_object v2negatep)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4form;
  v3 = L453loop_get_form();
  v4form = v3;
  ecl_bds_bind(cl_env_copy,VV[104],ECL_T);        /*  *LOOP-INSIDE-CONDITIONAL* */
  lex0[0] = ECL_NIL;                              /*  IT-P                    */
  lex0[1] = ECL_T;                                /*  FIRST-CLAUSE-P          */
  {
   cl_object v5;
   cl_object v6;
   v5 = LC472get_clause(lex0, v1for);
   T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   if (Null(L425loop_tequal(T0, VV[200]))){
    goto L6;
   }
   L450loop_pop_source();
   T0 = LC472get_clause(lex0, VV[200]);
   v6 = ecl_list1(T0);
   goto L5;
L6:;
   v6 = ECL_NIL;
L5:;
   T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   if (Null(L425loop_tequal(T0, ECL_SYM("END",1256)))){
    goto L10;
   }
   L450loop_pop_source();
L10:;
   if (Null(lex0[0])){
    goto L12;
   }
   T0 = lex0[0];
   v4form = cl_list(3, ECL_SYM("SETQ",754), T0, v4form);
L12:;
   if (Null(v2negatep)){
    goto L17;
   }
   T0 = cl_list(2, ECL_SYM("NOT",586), v4form);
   goto L16;
L17:;
   T0 = v4form;
L16:;
   T1 = cl_listX(4, ECL_SYM("IF",950), T0, v5, v6);
   value0 = L455loop_pseudo_body(T1);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
static cl_object L473loop_do_if_va(cl_narg narg, cl_object v7for, cl_object v8negatep, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[193]);
 {
  return L473loop_do_if(v7for, v8negatep);
 }
}
/* function definition for LOOP-DO-INITIALLY                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L474loop_do_initially()
{
 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:;
 L458loop_disallow_conditional(1, VV[203]);
 T0 = L452loop_get_progn();
 T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[96]));
 ecl_cmp_setq(cl_env_copy,VV[96],T1);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[96]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L474loop_do_initially_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[202]);
 {
  return L474loop_do_initially();
 }
}
/* function definition for LOOP-DO-FINALLY                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L475loop_do_finally()
{
 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:;
 L458loop_disallow_conditional(1, VV[206]);
 T0 = L452loop_get_progn();
 T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[101]));
 ecl_cmp_setq(cl_env_copy,VV[101],T1);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[101]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L475loop_do_finally_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[205]);
 {
  return L475loop_do_finally();
 }
}
/* function definition for LOOP-DO-DO                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L476loop_do_do()
{
 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 = L452loop_get_progn();
 value0 = L456loop_emit_body(T0);
 return value0;
}
static cl_object L476loop_do_do_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[208]);
 {
  return L476loop_do_do();
 }
}
/* function definition for LOOP-DO-NAMED                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L477loop_do_named()
{
 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 v1name;
  v1name = L450loop_pop_source();
  if (ECL_SYMBOLP(v1name)) {
   goto L3;
  }
  L442loop_error(2, VV[211], v1name);
L3:;
  if (ecl_cmp_symbol_value(cl_env_copy,VV[97])!=ECL_NIL) {
   goto L7;
  }
  if (ecl_cmp_symbol_value(cl_env_copy,VV[98])!=ECL_NIL) {
   goto L7;
  }
  if (ecl_cmp_symbol_value(cl_env_copy,VV[102])!=ECL_NIL) {
   goto L7;
  }
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[104]))){
   goto L5;
  }
  goto L6;
L7:;
L6:;
  L442loop_error(2, VV[212], v1name);
L5:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[87]))){
   goto L11;
  }
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[87]));
  L442loop_error(3, VV[213], T0, v1name);
L11:;
  T0 = cl_list(2, v1name, ECL_NIL);
  ecl_cmp_setq(cl_env_copy,VV[87],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[87]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L477loop_do_named_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[210]);
 {
  return L477loop_do_named();
 }
}
/* function definition for LOOP-DO-RETURN                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L478loop_do_return()
{
 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 = L453loop_get_form();
 T1 = L454loop_construct_return(T0);
 value0 = L456loop_emit_body(T1);
 return value0;
}
static cl_object L478loop_do_return_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[215]);
 {
  return L478loop_do_return();
 }
}
/* function definition for MAKE-LOOP-COLLECTOR                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L479make_loop_collector(cl_narg narg, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1;
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  cl_object v6;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[12];
   cl_parse_key(args,6,L479make_loop_collectorkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1 = keyvars[0];
   v2 = keyvars[1];
   v3 = keyvars[2];
   v4 = keyvars[3];
   v5 = keyvars[4];
   v6 = keyvars[5];
  }
  T0 = cl_list(6, v1, v2, v3, v4, v5, v6);
  value0 = cl_make_array(5, VV[22], ECL_SYM("ELEMENT-TYPE",1255), ECL_T, ECL_SYM("INITIAL-CONTENTS",1287), T0);
  return value0;
 }
}
/* function definition for LOOP-GET-COLLECTION-INFO                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L480loop_get_collection_info(cl_object v1collector, cl_object v2class, cl_object v3default_type)
{
 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 v4;
  cl_object v5;
  cl_object v6;
  cl_object v7dtype;
  v4 = L453loop_get_form();
  if ((cl_env_copy->function=(VV[222]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-ANSI */!=ECL_NIL) {
   goto L5;
  }
  v5 = L464loop_optional_type(0);
  goto L3;
L5:;
  v5 = ECL_NIL;
  goto L3;
L3:;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[223]))){
   goto L8;
  }
  L450loop_pop_source();
  v6 = L450loop_pop_source();
  goto L7;
L8:;
  v6 = ECL_NIL;
L7:;
  v7dtype = v5;
  if (ECL_SYMBOLP(v6)) {
   goto L12;
  }
  L442loop_error(2, VV[224], v6);
L12:;
  if (v6!=ECL_NIL) {
   goto L14;
  }
  L460loop_disallow_aggregate_booleans();
L14:;
  if (v7dtype!=ECL_NIL) {
   goto L16;
  }
  value0 = L464loop_optional_type(0);
  if (value0!=ECL_NIL) {
   goto L20;
  }
  v7dtype = v3default_type;
  goto L18;
L20:;
  v7dtype = value0;
  goto L18;
L18:;
L16:;
  {
   cl_object v8cruft;
   {
    cl_object v9;
    cl_object v10;
    v9 = ecl_cmp_symbol_value(cl_env_copy,VV[107]);
    v10 = (VV[157]->symbol.gfdef);
    {
     cl_object v11;
     v11 = si_make_seq_iterator(2, v9, ecl_make_int8_t(0));
L26:;
     if (v11!=ECL_NIL) {
      goto L28;
     }
     v8cruft = ECL_NIL;
     goto L22;
L28:;
     {
      cl_object v12;
      v12 = si_seq_iterator_ref(v9, v11);
      T0 = (cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v12) /*  LOOP-COLLECTOR-NAME */;
      if (!((v6)==(T0))){
       goto L30;
      }
      v8cruft = v12;
      goto L22;
     }
L30:;
     v11 = si_seq_iterator_next(v9, v11);
     goto L26;
    }
   }
L22:;
   if (v8cruft!=ECL_NIL) {
    goto L36;
   }
   if (Null(v6)){
    goto L38;
   }
   if (Null(L466loop_variable_p(v6))){
    goto L38;
   }
   L442loop_error(2, VV[225], v6);
L38:;
   T0 = ecl_list1(v1collector);
   v8cruft = L479make_loop_collector(8, ECL_SYM("NAME",1309), v6, VV[226], v2class, VV[227], T0, VV[228], v7dtype);
   T0 = CONS(v8cruft,ecl_cmp_symbol_value(cl_env_copy,VV[107]));
   ecl_cmp_setq(cl_env_copy,VV[107],T0);
   goto L35;
L36:;
   T0 = (cl_env_copy->function=(VV[229]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-CLASS */;
   if ((T0)==(v2class)) {
    goto L43;
   }
   T0 = (cl_env_copy->function=(VV[231]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-HISTORY */;
   T1 = ecl_car(T0);
   L442loop_error(4, VV[230], v6, T1, v1collector);
L43:;
   T0 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-DTYPE */;
   if (ecl_equal(v7dtype,T0)) {
    goto L45;
   }
   T0 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-DTYPE */;
   L443loop_warn(4, VV[233], v6, v7dtype, T0);
   T0 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-DTYPE */;
   if (!((T0)==(ECL_T))){
    goto L45;
   }
   ecl_elt_set(v8cruft,(cl_fixnum)(4),v7dtype);
L45:;
   {
    cl_object v9;
    T0 = (cl_env_copy->function=(VV[231]->symbol.gfdef))->cfun.entry(1, v8cruft) /*  LOOP-COLLECTOR-HISTORY */;
    v9 = CONS(v1collector,T0);
    ecl_elt_set(v8cruft,(cl_fixnum)(2),v9);
   }
L35:;
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = v4;
   cl_env_copy->values[0] = v8cruft;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for LOOP-LIST-COLLECTION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L481loop_list_collection(cl_object v1specifically)
{
 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 v2;                                   /*  LC                      */
  cl_object v3;                                   /*  FORM                    */
  value0 = L480loop_get_collection_info(v1specifically, ECL_SYM("LIST",483), ECL_SYM("LIST",483));
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  {
   cl_object v4tempvars;
   v4tempvars = (cl_env_copy->function=(VV[235]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-TEMPVARS */;
   if (v4tempvars!=ECL_NIL) {
    goto L4;
   }
   {
    cl_object v5;
    T0 = cl_gensym(1, VV[236]);
    T1 = cl_gensym(1, VV[237]);
    if (Null((cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-NAME */)){
     goto L11;
    }
    T3 = (cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-NAME */;
    T2 = ecl_list1(T3);
    goto L9;
L11:;
    T2 = ECL_NIL;
    goto L9;
L9:;
    v4tempvars = cl_listX(3, T0, T1, T2);
    v5 = v4tempvars;
    ecl_elt_set(v2,(cl_fixnum)(3),v5);
   }
   T0 = cl_list(2, VV[4], v4tempvars);
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[92]));
   ecl_cmp_setq(cl_env_copy,VV[92],T1);
   if ((cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-NAME */!=ECL_NIL) {
    goto L4;
   }
   T0 = ecl_car(v4tempvars);
   T1 = ecl_cddr(v4tempvars);
   T2 = cl_listX(3, VV[16], T0, T1);
   L457loop_emit_final_value(1, T2);
L4:;
   if (!((v1specifically)==(ECL_SYM("LIST",483)))){
    goto L17;
   }
   v3 = cl_list(2, ECL_SYM("LIST",483), v3);
   goto L16;
L17:;
   if ((v1specifically)==(ECL_SYM("NCONC",583))) {
    goto L16;
   }
   if (!((v1specifically)==(ECL_SYM("APPEND",90)))){
    goto L21;
   }
   if (!(ECL_CONSP(v3))){
    goto L25;
   }
   T0 = ecl_car(v3);
   if ((T0)==(ECL_SYM("LIST",483))) {
    goto L16;
   }
   goto L23;
L25:;
   goto L23;
L23:;
   v3 = cl_list(2, ECL_SYM("COPY-LIST",259), v3);
   goto L16;
L21:;
   si_ecase_error(v1specifically, VV[238]);
L16:;
   T0 = cl_list(3, VV[8], v4tempvars, v3);
   value0 = L456loop_emit_body(T0);
   return value0;
  }
 }
}
static cl_object L481loop_list_collection_va(cl_narg narg, cl_object v2specifically, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[234]);
 {
  return L481loop_list_collection(v2specifically);
 }
}
/* function definition for LOOP-SUM-COLLECTION                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L482loop_sum_collection(cl_object v1specifically, cl_object v2required_type, cl_object v3default_type)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v4;                                   /*  LC                      */
  cl_object v5;                                   /*  FORM                    */
  value0 = L480loop_get_collection_info(v1specifically, VV[241], v3default_type);
  {
   const int v6 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v7;
   v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v7;
  }
  T0 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-DTYPE */;
  L444loop_check_data_type(2, T0, v2required_type);
  {
   cl_object v6tempvars;
   v6tempvars = (cl_env_copy->function=(VV[235]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-TEMPVARS */;
   if (v6tempvars!=ECL_NIL) {
    goto L5;
   }
   {
    cl_object v7;
    value0 = (cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-NAME */;
    if (value0!=ECL_NIL) {
     goto L12;
    }
    T0 = cl_gensym(1, VV[242]);
    goto L10;
L12:;
    T0 = value0;
    goto L10;
L10:;
    T1 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-DTYPE */;
    T2 = L467loop_make_variable(3, T0, ECL_NIL, T1);
    v6tempvars = ecl_list1(T2);
    v7 = v6tempvars;
    ecl_elt_set(v4,(cl_fixnum)(3),v7);
   }
   if ((cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-NAME */!=ECL_NIL) {
    goto L5;
   }
   T0 = (cl_env_copy->function=(VV[235]->symbol.gfdef))->cfun.entry(1, v4) /*  LOOP-COLLECTOR-TEMPVARS */;
   T1 = ecl_car(T0);
   L457loop_emit_final_value(1, T1);
L5:;
   if (!((v1specifically)==(ECL_SYM("COUNT",268)))){
    goto L16;
   }
   T1 = ecl_car(v6tempvars);
   T2 = ecl_car(v6tempvars);
   T3 = cl_list(2, ECL_SYM("1+",72), T2);
   T4 = cl_list(3, ECL_SYM("SETQ",754), T1, T3);
   T0 = cl_list(3, ECL_SYM("WHEN",909), v5, T4);
   goto L15;
L16:;
   T1 = ecl_car(v6tempvars);
   T2 = ecl_car(v6tempvars);
   T3 = cl_list(3, ECL_SYM("+",16), T2, v5);
   T0 = cl_list(3, ECL_SYM("SETQ",754), T1, T3);
L15:;
   value0 = L456loop_emit_body(T0);
   return value0;
  }
 }
}
static cl_object L482loop_sum_collection_va(cl_narg narg, cl_object v4specifically, cl_object v5required_type, cl_object v6default_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[240]);
 {
  return L482loop_sum_collection(v4specifically, v5required_type, v6default_type);
 }
}
/* function definition for LOOP-MAXMIN-COLLECTION                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L483loop_maxmin_collection(cl_object v1specifically)
{
 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 v2;                                   /*  LC                      */
  cl_object v3;                                   /*  FORM                    */
  value0 = L480loop_get_collection_info(v1specifically, VV[245], ECL_SYM("REAL",706));
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  T0 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-DTYPE */;
  L444loop_check_data_type(2, T0, ECL_SYM("REAL",706));
  {
   cl_object v4data;
   v4data = (cl_env_copy->function=(VV[246]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-DATA */;
   if (v4data!=ECL_NIL) {
    goto L5;
   }
   {
    cl_object v5;
    value0 = (cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-NAME */;
    if (value0!=ECL_NIL) {
     goto L12;
    }
    T0 = cl_gensym(1, VV[247]);
    goto L10;
L12:;
    T0 = value0;
    goto L10;
L10:;
    T1 = (cl_env_copy->function=(VV[232]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-DTYPE */;
    v4data = L421make_loop_minimax(T0, T1);
    v5 = v4data;
    ecl_elt_set(v2,(cl_fixnum)(5),v5);
   }
   if ((cl_env_copy->function=(VV[157]->symbol.gfdef))->cfun.entry(1, v2) /*  LOOP-COLLECTOR-NAME */!=ECL_NIL) {
    goto L5;
   }
   T0 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v4data) /*  LOOP-MINIMAX-ANSWER-VARIABLE */;
   L457loop_emit_final_value(1, T0);
L5:;
   L422loop_note_minimax_operation(v1specifically, v4data);
   T0 = cl_list(2, VV[41], v4data);
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[92]));
   ecl_cmp_setq(cl_env_copy,VV[92],T1);
   T0 = cl_list(4, VV[48], v4data, v1specifically, v3);
   value0 = L456loop_emit_body(T0);
   return value0;
  }
 }
}
static cl_object L483loop_maxmin_collection_va(cl_narg narg, cl_object v2specifically, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[244]);
 {
  return L483loop_maxmin_collection(v2specifically);
 }
}
/* function definition for LOOP-DO-ALWAYS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L484loop_do_always(cl_object v1restrictive, cl_object v2negate)
{
 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 v3form;
  v3form = L453loop_get_form();
  if (Null(v1restrictive)){
   goto L3;
  }
  L458loop_disallow_conditional(0);
L3:;
  L459loop_disallow_anonymous_collectors();
  if (Null(v2negate)){
   goto L8;
  }
  T0 = ECL_SYM("WHEN",909);
  goto L7;
L8:;
  T0 = ECL_SYM("UNLESS",886);
L7:;
  T1 = L454loop_construct_return(ECL_NIL);
  T2 = cl_list(3, T0, v3form, T1);
  L456loop_emit_body(T2);
  value0 = L457loop_emit_final_value(1, ECL_T);
  return value0;
 }
}
static cl_object L484loop_do_always_va(cl_narg narg, cl_object v4restrictive, cl_object v5negate, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[249]);
 {
  return L484loop_do_always(v4restrictive, v5negate);
 }
}
/* function definition for LOOP-DO-THEREIS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L485loop_do_thereis(cl_object v1restrictive)
{
 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(v1restrictive)){
  goto L2;
 }
 L458loop_disallow_conditional(0);
L2:;
 L459loop_disallow_anonymous_collectors();
 L457loop_emit_final_value(0);
 T0 = L492loop_when_it_variable();
 T1 = L453loop_get_form();
 T2 = cl_list(3, ECL_SYM("SETQ",754), T0, T1);
 T3 = L454loop_construct_return(ecl_cmp_symbol_value(cl_env_copy,VV[105]));
 T4 = cl_list(3, ECL_SYM("WHEN",909), T2, T3);
 value0 = L456loop_emit_body(T4);
 return value0;
}
static cl_object L485loop_do_thereis_va(cl_narg narg, cl_object v2restrictive, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[251]);
 {
  return L485loop_do_thereis(v2restrictive);
 }
}
/* function definition for LOOP-DO-WHILE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L486loop_do_while(cl_object v1negate, cl_object v2kwd)
{
 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 v3form;
  v3form = L453loop_get_form();
  L458loop_disallow_conditional(1, v2kwd);
  if (Null(v1negate)){
   goto L5;
  }
  T0 = ECL_SYM("WHEN",909);
  goto L4;
L5:;
  T0 = ECL_SYM("UNLESS",886);
L4:;
  T1 = cl_list(3, T0, v3form, VV[125]);
  value0 = L455loop_pseudo_body(T1);
  return value0;
 }
}
static cl_object L486loop_do_while_va(cl_narg narg, cl_object v4negate, cl_object v5kwd, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[253]);
 {
  return L486loop_do_while(v4negate, v5kwd);
 }
}
/* function definition for LOOP-DO-WITH                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L487loop_do_with()
{
 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:;
 L458loop_disallow_conditional(1, VV[256]);
 {
  cl_object v1var;
  cl_object v2val;
  cl_object v3dtype;
  v1var = ECL_NIL;
  v2val = ECL_NIL;
  v3dtype = ECL_NIL;
  goto L8;
L7:;
  v1var = L450loop_pop_source();
  v3dtype = L464loop_optional_type(1, v1var);
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[257]))){
   goto L16;
  }
  L450loop_pop_source();
  v2val = L453loop_get_form();
  goto L15;
L16:;
  v2val = ECL_NIL;
L15:;
  if (Null(v1var)){
   goto L19;
  }
  if (Null(L466loop_variable_p(v1var))){
   goto L19;
  }
  L442loop_error(2, VV[258], v1var);
L19:;
  L467loop_make_variable(3, v1var, v2val, v3dtype);
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[199]))){
   goto L24;
  }
  L450loop_pop_source();
  goto L23;
L24:;
  value0 = L465loop_bind_block();
  return value0;
L23:;
L8:;
  goto L7;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L487loop_do_with_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[255]);
 {
  return L487loop_do_with();
 }
}
/* function definition for LOOP-HACK-ITERATION                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L489loop_hack_iteration(cl_object v1entry)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2pre_step_tests;
  cl_object v3steps;
  cl_object v4post_step_tests;
  cl_object v5pseudo_steps;
  cl_object v6pre_loop_pre_step_tests;
  cl_object v7pre_loop_steps;
  cl_object v8pre_loop_post_step_tests;
  cl_object v9pre_loop_pseudo_steps;
  cl_object v10tem;
  cl_object v11data;
  v2pre_step_tests = ECL_NIL;
  v3steps = ECL_NIL;
  v4post_step_tests = ECL_NIL;
  v5pseudo_steps = ECL_NIL;
  v6pre_loop_pre_step_tests = ECL_NIL;
  v7pre_loop_steps = ECL_NIL;
  v8pre_loop_post_step_tests = ECL_NIL;
  v9pre_loop_pseudo_steps = ECL_NIL;
  v10tem = ECL_NIL;
  v11data = ECL_NIL;
  goto L14;
L13:;
  T0 = ecl_car(v1entry);
  T1 = cl_symbol_function(T0);
  T2 = ecl_cdr(v1entry);
  v11data = cl_apply(2, T1, T2);
  v10tem = v11data;
  if (Null(ecl_car(v10tem))){
   goto L21;
  }
  T0 = ecl_car(v10tem);
  v2pre_step_tests = CONS(T0,v2pre_step_tests);
  goto L19;
L21:;
  goto L19;
L19:;
  v10tem = ecl_cdr(v10tem);
  T0 = ecl_car(v10tem);
  T1 = cl_copy_list(T0);
  v3steps = ecl_nconc(v3steps,T1);
  v10tem = ecl_cdr(v10tem);
  if (Null(ecl_car(v10tem))){
   goto L29;
  }
  T0 = ecl_car(v10tem);
  v4post_step_tests = CONS(T0,v4post_step_tests);
  goto L27;
L29:;
  goto L27;
L27:;
  v10tem = ecl_cdr(v10tem);
  T0 = ecl_car(v10tem);
  T1 = cl_copy_list(T0);
  v5pseudo_steps = ecl_nconc(v5pseudo_steps,T1);
  v10tem = ecl_cdr(v10tem);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[100]))){
   goto L38;
  }
  L442loop_error(1, VV[261]);
L38:;
  if (v10tem!=ECL_NIL) {
   goto L40;
  }
  v10tem = v11data;
L40:;
  if (Null(ecl_car(v10tem))){
   goto L43;
  }
  T0 = ecl_car(v10tem);
  v6pre_loop_pre_step_tests = CONS(T0,v6pre_loop_pre_step_tests);
L43:;
  v10tem = ecl_cdr(v10tem);
  T0 = ecl_car(v10tem);
  T1 = cl_copy_list(T0);
  v7pre_loop_steps = ecl_nconc(v7pre_loop_steps,T1);
  v10tem = ecl_cdr(v10tem);
  if (Null(ecl_car(v10tem))){
   goto L49;
  }
  T0 = ecl_car(v10tem);
  v8pre_loop_post_step_tests = CONS(T0,v8pre_loop_post_step_tests);
L49:;
  T0 = ecl_cadr(v10tem);
  T1 = cl_copy_list(T0);
  v9pre_loop_pseudo_steps = ecl_nconc(v9pre_loop_pseudo_steps,T1);
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (L425loop_tequal(T0, VV[199])!=ECL_NIL) {
   goto L55;
  }
  T0 = L434loop_make_desetq(v9pre_loop_pseudo_steps);
  T1 = LC488make_endtest(v8pre_loop_post_step_tests);
  T2 = L433loop_make_psetq(v7pre_loop_steps);
  T3 = LC488make_endtest(v6pre_loop_pre_step_tests);
  T4 = cl_listX(5, T0, T1, T2, T3, ecl_cmp_symbol_value(cl_env_copy,VV[97]));
  ecl_cmp_setq(cl_env_copy,VV[97],T4);
  T0 = L434loop_make_desetq(v5pseudo_steps);
  T1 = LC488make_endtest(v4post_step_tests);
  T2 = L433loop_make_psetq(v3steps);
  T3 = LC488make_endtest(v2pre_step_tests);
  T4 = cl_listX(5, T0, T1, T2, T3, ecl_cmp_symbol_value(cl_env_copy,VV[99]));
  ecl_cmp_setq(cl_env_copy,VV[99],T4);
  L465loop_bind_block();
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L55:;
  L450loop_pop_source();
  if ((cl_env_copy->function=(VV[262]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED */!=ECL_NIL) {
   goto L67;
  }
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  T1 = (cl_env_copy->function=(VV[138]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-ITERATION-KEYWORDS */;
  v10tem = L428loop_lookup_keyword(T0, T1);
  if (Null(v10tem)){
   goto L67;
  }
  L450loop_pop_source();
  v1entry = v10tem;
L67:;
L14:;
  goto L13;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-DO-FOR                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L490loop_do_for()
{
 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 v1var;
  cl_object v2data_type;
  cl_object v3keyword;
  cl_object v4first_arg;
  cl_object v5tem;
  v1var = L450loop_pop_source();
  v2data_type = L464loop_optional_type(1, v1var);
  v3keyword = L450loop_pop_source();
  v4first_arg = ECL_NIL;
  v5tem = ECL_NIL;
  v4first_arg = L453loop_get_form();
  if (!(ECL_SYMBOLP(v3keyword))){
   goto L12;
  }
  T0 = (cl_env_copy->function=(VV[264]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-FOR-KEYWORDS */;
  v5tem = L428loop_lookup_keyword(v3keyword, T0);
  if (v5tem!=ECL_NIL) {
   goto L9;
  }
  goto L10;
L12:;
  goto L10;
L10:;
  L442loop_error(2, VV[265], v3keyword);
L9:;
  T0 = ecl_car(v5tem);
  T1 = ecl_cdr(v5tem);
  value0 = cl_apply(5, T0, v1var, v4first_arg, v2data_type, T1);
  return value0;
 }
}
static cl_object L490loop_do_for_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[263]);
 {
  return L490loop_do_for();
 }
}
/* function definition for LOOP-DO-REPEAT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L491loop_do_repeat()
{
 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:;
 L458loop_disallow_conditional(1, VV[268]);
 {
  cl_object v1form;
  cl_object v2type;
  cl_object v3var;
  cl_object v4form;
  v1form = L453loop_get_form();
  if (!(ECL_FIXNUMP(v1form))){
   goto L5;
  }
  v2type = ECL_SYM("FIXNUM",374);
  goto L4;
L5:;
  v2type = ECL_SYM("REAL",706);
L4:;
  T0 = cl_gensym(0);
  v3var = L467loop_make_variable(3, T0, v1form, v2type);
  T0 = cl_list(2, ECL_SYM("DECF",273), v3var);
  T1 = cl_list(2, ECL_SYM("MINUSP",560), T0);
  T2 = cl_list(3, ECL_SYM("WHEN",909), T1, VV[125]);
  v4form = cl_list(2, VV[0], T2);
  T0 = CONS(v4form,ecl_cmp_symbol_value(cl_env_copy,VV[97]));
  ecl_cmp_setq(cl_env_copy,VV[97],T0);
  T0 = CONS(v4form,ecl_cmp_symbol_value(cl_env_copy,VV[99]));
  ecl_cmp_setq(cl_env_copy,VV[99],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[99]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L491loop_do_repeat_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[267]);
 {
  return L491loop_do_repeat();
 }
}
/* function definition for LOOP-WHEN-IT-VARIABLE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L492loop_when_it_variable()
{
 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:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[105]);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 T0 = cl_gensym(1, VV[270]);
 T1 = L467loop_make_variable(3, T0, ECL_NIL, ECL_NIL);
 ecl_cmp_setq(cl_env_copy,VV[105],T1);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[105]);
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LOOP-ANSI-FOR-EQUALS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L493loop_ansi_for_equals(cl_object v1var, cl_object v2val, cl_object v3data_type)
{
 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:;
 L468loop_make_iteration_variable(v1var, ECL_NIL, v3data_type);
 T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
 if (Null(L425loop_tequal(T0, VV[272]))){
  goto L3;
 }
 L450loop_pop_source();
 T0 = L453loop_get_form();
 T1 = cl_list(2, v1var, T0);
 T2 = cl_list(2, v1var, v2val);
 value0 = cl_listX(7, ECL_NIL, T1, ECL_NIL, ECL_NIL, ECL_NIL, T2, VV[273]);
 return value0;
L3:;
 T0 = cl_list(2, v1var, v2val);
 value0 = cl_listX(3, ECL_NIL, T0, VV[273]);
 return value0;
}
static cl_object L493loop_ansi_for_equals_va(cl_narg narg, cl_object v4var, cl_object v5val, cl_object v6data_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[271]);
 {
  return L493loop_ansi_for_equals(v4var, v5val, v6data_type);
 }
}
/* function definition for LOOP-FOR-ACROSS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L494loop_for_across(cl_object v1var, cl_object v2val, cl_object v3data_type)
{
 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:;
 L468loop_make_iteration_variable(v1var, ECL_NIL, v3data_type);
 {
  cl_object v4;
  cl_object v5;
  v4 = cl_gensym(1, VV[276]);
  v5 = cl_gensym(1, VV[277]);
  {
   cl_object v6;                                  /*  VECTOR-FORM             */
   cl_object v7;                                  /*  CONSTANTP               */
   cl_object v8;                                  /*  VECTOR-VALUE            */
   value0 = L439loop_constant_fold_if_possible(2, v2val, ECL_SYM("VECTOR",902));
   {
    const int v9 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v7 = v10;
    v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
    v8 = v10;
   }
   if (!(ECL_CONSP(v6))){
    goto L8;
   }
   T1 = ecl_car(v6);
   if (!((T1)==(ECL_SYM("THE",859)))){
    goto L8;
   }
   T0 = ecl_cadr(v6);
   goto L7;
L8:;
   T0 = ECL_SYM("VECTOR",902);
L7:;
   L467loop_make_variable(3, v4, v6, T0);
   L467loop_make_variable(3, v5, ecl_make_int8_t(0), ECL_SYM("FIXNUM",374));
   {
    cl_fixnum v9length;
    cl_object v10length_form;
    cl_object v11first_test;
    cl_object v12other_test;
    cl_object v13step;
    cl_object v14pstep;
    v9length = (cl_fixnum)(0);
    if (v7!=ECL_NIL) {
     goto L14;
    }
    {
     cl_object v15v;
     v15v = cl_gensym(1, VV[278]);
     T0 = cl_list(2, ECL_SYM("LENGTH",478), v4);
     T1 = cl_list(3, ECL_SYM("SETQ",754), v15v, T0);
     T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[96]));
     ecl_cmp_setq(cl_env_copy,VV[96],T2);
     v10length_form = L467loop_make_variable(3, v15v, ecl_make_int8_t(0), ECL_SYM("FIXNUM",374));
     goto L13;
    }
L14:;
    v9length = ecl_length(v8);
    v10length_form = ecl_make_fixnum(v9length);
L13:;
    v11first_test = cl_list(3, ECL_SYM(">=",78), v5, v10length_form);
    v12other_test = v11first_test;
    T0 = cl_list(3, ECL_SYM("AREF",94), v4, v5);
    v13step = cl_list(2, v1var, T0);
    T0 = cl_list(2, ECL_SYM("1+",72), v5);
    v14pstep = cl_list(2, v5, T0);
    if (Null(v7)){
     goto L24;
    }
    v11first_test = ecl_make_bool((v9length)==((cl_fixnum)(0)));
    if (!((v9length)<=((cl_fixnum)(1)))){
     goto L24;
    }
    v12other_test = ECL_T;
L24:;
    if ((v11first_test)==(v12other_test)) {
     goto L32;
    }
    T0 = cl_list(4, v11first_test, v13step, ECL_NIL, v14pstep);
    goto L30;
L32:;
    T0 = ECL_NIL;
    goto L30;
L30:;
    value0 = cl_listX(5, v12other_test, v13step, ECL_NIL, v14pstep, T0);
    return value0;
   }
  }
 }
}
static cl_object L494loop_for_across_va(cl_narg narg, cl_object v6var, cl_object v7val, cl_object v8data_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[275]);
 {
  return L494loop_for_across(v6var, v7val, v8data_type);
 }
}
/* function definition for LOOP-LIST-STEP                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L495loop_list_step(cl_object v1listvar)
{
 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 v2stepper;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[281]))){
   goto L3;
  }
  L450loop_pop_source();
  v2stepper = L453loop_get_form();
  goto L2;
L3:;
  v2stepper = VV[282];
L2:;
  if (!(ECL_CONSP(v2stepper))){
   goto L6;
  }
  T0 = ecl_car(v2stepper);
  if (!((T0)==(ECL_SYM("QUOTE",682)))){
   goto L6;
  }
  L443loop_warn(1, VV[283]);
  T0 = cl_list(3, ECL_SYM("FUNCALL",396), v2stepper, v1listvar);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
L6:;
  if (!(ECL_CONSP(v2stepper))){
   goto L10;
  }
  T0 = ecl_car(v2stepper);
  if (!((T0)==(ECL_SYM("FUNCTION",398)))){
   goto L10;
  }
  T0 = ecl_cadr(v2stepper);
  T1 = cl_list(2, T0, v1listvar);
  T2 = ecl_cadr(v2stepper);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T2;
  cl_env_copy->values[0] = T1;
  return cl_env_copy->values[0];
L10:;
  T0 = cl_gensym(1, VV[284]);
  T1 = L467loop_make_variable(3, T0, v2stepper, ECL_SYM("FUNCTION",398));
  T2 = cl_list(3, ECL_SYM("FUNCALL",396), T1, v1listvar);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = T2;
  return cl_env_copy->values[0];
 }
}
/* function definition for LOOP-FOR-ON                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L496loop_for_on(cl_object v1var, cl_object v2val, cl_object v3data_type)
{
 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;                                   /*  LIST                    */
  cl_object v5;                                   /*  CONSTANTP               */
  cl_object v6;                                   /*  LIST-VALUE              */
  value0 = L439loop_constant_fold_if_possible(1, v2val);
  {
   const int v7 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v8;
   v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
   v6 = v8;
  }
  {
   cl_object v7listvar;
   v7listvar = v1var;
   if (Null(v1var)){
    goto L5;
   }
   if (!(ECL_SYMBOLP(v1var))){
    goto L5;
   }
   L468loop_make_iteration_variable(v1var, v4, v3data_type);
   goto L4;
L5:;
   v7listvar = cl_gensym(0);
   L467loop_make_variable(3, v7listvar, v4, ECL_NIL);
   L468loop_make_iteration_variable(v1var, ECL_NIL, v3data_type);
L4:;
   {
    cl_object v8list_step;
    v8list_step = L495loop_list_step(v7listvar);
    {
     cl_object v9first_endtest;
     cl_object v10other_endtest;
     v9first_endtest = cl_list(2, ECL_SYM("ATOM",121), v7listvar);
     v10other_endtest = v9first_endtest;
     if (Null(v5)){
      goto L13;
     }
     if (!(ECL_LISTP(v6))){
      goto L13;
     }
     v9first_endtest = ecl_make_bool(v6==ECL_NIL);
L13:;
     if (!((v1var)==(v7listvar))){
      goto L17;
     }
     T0 = cl_list(2, v7listvar, v8list_step);
     value0 = cl_list(8, ECL_NIL, T0, v10other_endtest, ECL_NIL, ECL_NIL, ECL_NIL, v9first_endtest, ECL_NIL);
     return value0;
L17:;
     {
      cl_object v11;
      cl_object v12;
      v11 = cl_list(2, v1var, v7listvar);
      v12 = cl_list(2, v7listvar, v8list_step);
      if ((v9first_endtest)==(v10other_endtest)) {
       goto L23;
      }
      T0 = cl_list(4, v9first_endtest, v11, ECL_NIL, v12);
      goto L21;
L23:;
      T0 = ECL_NIL;
      goto L21;
L21:;
      value0 = cl_listX(5, v10other_endtest, v11, ECL_NIL, v12, T0);
      return value0;
     }
    }
   }
  }
 }
}
static cl_object L496loop_for_on_va(cl_narg narg, cl_object v4var, cl_object v5val, cl_object v6data_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[285]);
 {
  return L496loop_for_on(v4var, v5val, v6data_type);
 }
}
/* function definition for LOOP-FOR-IN                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L497loop_for_in(cl_object v1var, cl_object v2val, cl_object v3data_type)
{
 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;                                   /*  LIST                    */
  cl_object v5;                                   /*  CONSTANTP               */
  cl_object v6;                                   /*  LIST-VALUE              */
  value0 = L439loop_constant_fold_if_possible(1, v2val);
  {
   const int v7 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v8;
   v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
   v6 = v8;
  }
  {
   cl_object v7listvar;
   v7listvar = cl_gensym(1, VV[288]);
   L468loop_make_iteration_variable(v1var, ECL_NIL, v3data_type);
   L467loop_make_variable(3, v7listvar, v4, ECL_SYM("LIST",483));
   {
    cl_object v8list_step;
    v8list_step = L495loop_list_step(v7listvar);
    {
     cl_object v9first_endtest;
     cl_object v10other_endtest;
     cl_object v11step;
     cl_object v12pseudo_step;
     v9first_endtest = cl_list(2, ECL_SYM("ENDP",332), v7listvar);
     v10other_endtest = v9first_endtest;
     T0 = cl_list(2, ECL_SYM("CONS-CAR",1885), v7listvar);
     v11step = cl_list(2, v1var, T0);
     v12pseudo_step = cl_list(2, v7listvar, v8list_step);
     if (Null(v5)){
      goto L11;
     }
     if (!(ECL_LISTP(v6))){
      goto L11;
     }
     v9first_endtest = ecl_make_bool(v6==ECL_NIL);
L11:;
     if ((v9first_endtest)==(v10other_endtest)) {
      goto L17;
     }
     T0 = cl_list(4, v9first_endtest, v11step, ECL_NIL, v12pseudo_step);
     goto L15;
L17:;
     T0 = ECL_NIL;
     goto L15;
L15:;
     value0 = cl_listX(5, v10other_endtest, v11step, ECL_NIL, v12pseudo_step, T0);
     return value0;
    }
   }
  }
 }
}
static cl_object L497loop_for_in_va(cl_narg narg, cl_object v4var, cl_object v5val, cl_object v6data_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[287]);
 {
  return L497loop_for_in(v4var, v5val, v6data_type);
 }
}
/* function definition for MAKE-LOOP-PATH                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L498make_loop_path(cl_narg narg, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1;
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[10];
   cl_parse_key(args,5,L498make_loop_pathkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1 = keyvars[0];
   v2 = keyvars[1];
   v3 = keyvars[2];
   v4 = keyvars[3];
   v5 = keyvars[4];
  }
  T0 = cl_list(5, v1, v2, v3, v4, v5);
  value0 = cl_make_array(5, VV[293], ECL_SYM("ELEMENT-TYPE",1255), ECL_T, ECL_SYM("INITIAL-CONTENTS",1287), T0);
  return value0;
 }
}
/* function definition for ADD-LOOP-PATH                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L500add_loop_path(cl_narg narg, cl_object v1names, cl_object v2function, cl_object v3universe, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[295]);
 {
  cl_object v4preposition_groups;
  cl_object v5inclusive_permitted;
  cl_object v6user_data;
  ecl_va_list args; ecl_va_start(args,v3universe,narg,3);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,L500add_loop_pathkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v4preposition_groups = keyvars[0];
   v5inclusive_permitted = keyvars[1];
   v6user_data = keyvars[2];
  }
  if (ECL_LISTP(v1names)) {
   goto L1;
  }
  v1names = ecl_list1(v1names);
L1:;
  {
   cl_object v7;
   cl_object v8;
   v7 = (cl_env_copy->function=(VV[296]->symbol.gfdef))->cfun.entry(1, v3universe) /*  LOOP-UNIVERSE-PATH-KEYWORDS */;
   {
    cl_object v9;
    v9 = (ECL_SYM("SYMBOL-NAME",846)->symbol.gfdef);
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     {
      cl_object v13;
      v13 = v1names;
      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;
L15:;
      if (!(ecl_endp(v12))){
       goto L17;
      }
      goto L16;
L17:;
      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;
       T1 = v15;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
      v14 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v14,T1);
      goto L15;
L16:;
      T0 = ecl_cdr(v13);
      goto L6;
     }
    }
   }
L6:;
   {
    cl_object v9;
    {
     cl_object v10;
     v10 = ecl_make_cfun_va((cl_objectfn)LC499__lambda645_va,ECL_NIL,Cblock,1);
     v9 = v10;
    }
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     {
      cl_object v13;
      v13 = v4preposition_groups;
      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;
L42:;
      if (!(ecl_endp(v12))){
       goto L44;
      }
      goto L43;
L44:;
      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;
       T2 = v15;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
      v14 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v14,T2);
      goto L42;
L43:;
      T1 = ecl_cdr(v13);
      goto L33;
     }
    }
   }
L33:;
   v8 = L498make_loop_path(10, VV[297], T0, ECL_SYM("FUNCTION",1273), v2function, VV[298], v6user_data, VV[299], T1, VV[301], v5inclusive_permitted);
   {
    cl_object v9;
    v9 = v1names;
    goto L64;
L63:;
    {
     cl_object v10name;
     v10name = ecl_car(v9);
     T0 = ecl_symbol_name(v10name);
     si_hash_set(T0, v7, v8);
    }
    v9 = ecl_cdr(v9);
L64:;
    if (Null(v9)){
     goto L71;
    }
    goto L63;
L71:;
   }
   value0 = v8;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for LOOP-FOR-BEING                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L501loop_for_being(cl_object v1var, cl_object v2val, cl_object v3data_type)
{
 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 v4path;
  cl_object v5data;
  cl_object v6inclusive;
  cl_object v7stuff;
  cl_object v8initial_prepositions;
  v4path = ECL_NIL;
  v5data = ECL_NIL;
  v6inclusive = ECL_NIL;
  v7stuff = ECL_NIL;
  v8initial_prepositions = ECL_NIL;
  if (Null(L427loop_tmember(v2val, VV[303]))){
   goto L8;
  }
  v4path = L450loop_pop_source();
  goto L7;
L8:;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[199]))){
   goto L11;
  }
  L450loop_pop_source();
  v6inclusive = ECL_T;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (L427loop_tmember(T0, VV[304])!=ECL_NIL) {
   goto L16;
  }
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  L442loop_error(2, VV[305], T0);
L16:;
  L450loop_pop_source();
  v4path = L450loop_pop_source();
  T0 = cl_list(2, VV[306], v2val);
  v8initial_prepositions = ecl_list1(T0);
  goto L7;
L11:;
  L442loop_error(1, VV[307]);
L7:;
  if (ECL_SYMBOLP(v4path)) {
   goto L23;
  }
  L442loop_error(2, VV[308], v4path);
  goto L22;
L23:;
  T0 = (cl_env_copy->function=(VV[296]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-PATH-KEYWORDS */;
  v5data = L428loop_lookup_keyword(v4path, T0);
  if (v5data!=ECL_NIL) {
   goto L25;
  }
  L442loop_error(2, VV[309], v4path);
  goto L22;
L25:;
  if (Null(v6inclusive)){
   goto L22;
  }
  if ((cl_env_copy->function=(VV[310]->symbol.gfdef))->cfun.entry(1, v5data) /*  LOOP-PATH-INCLUSIVE-PERMITTED */!=ECL_NIL) {
   goto L22;
  }
  L442loop_error(2, VV[311], v4path);
L22:;
  {
   cl_object v9;
   cl_object v10;
   cl_object v11;
   cl_object v12fun;
   v9 = (cl_env_copy->function=(VV[312]->symbol.gfdef))->cfun.entry(1, v5data) /*  LOOP-PATH-FUNCTION */;
   T0 = (cl_env_copy->function=(VV[314]->symbol.gfdef))->cfun.entry(1, v5data) /*  LOOP-PATH-PREPOSITION-GROUPS */;
   T1 = L505loop_collect_prepositional_phrases(2, T0, ECL_T);
   v10 = ecl_nconc(v8initial_prepositions,T1);
   v11 = (cl_env_copy->function=(VV[315]->symbol.gfdef))->cfun.entry(1, v5data) /*  LOOP-PATH-USER-DATA */;
   v12fun = v9;
   if (!(ECL_SYMBOLP(v12fun))){
    goto L35;
   }
   v12fun = cl_symbol_function(v12fun);
L35:;
   if (Null(v6inclusive)){
    goto L39;
   }
   v7stuff = cl_apply(7, v12fun, v1var, v3data_type, v10, VV[316], ECL_T, v11);
   goto L38;
L39:;
   v7stuff = cl_apply(5, v12fun, v1var, v3data_type, v10, v11);
L38:;
  }
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[88]))){
   goto L41;
  }
  L442loop_error(2, VV[317], ecl_cmp_symbol_value(cl_env_copy,VV[88]));
L41:;
  {
   cl_object v9;
   v9 = ecl_make_fixnum(ecl_length(v7stuff));
   if (!((ecl_fixnum(v9))==((cl_fixnum)(6)))){
    goto L48;
   }
   goto L43;
L48:;
   goto L46;
L46:;
   if (!((ecl_fixnum(v9))==((cl_fixnum)(10)))){
    goto L51;
   }
   goto L43;
L51:;
   goto L44;
  }
L44:;
  L442loop_error(2, VV[320], v4path);
L43:;
  {
   cl_object v9;
   cl_object v10l;
   cl_object v11x;
   v9 = ecl_car(v7stuff);
   v10l = v9;
   v11x = ECL_NIL;
   goto L59;
L58:;
   v11x = ecl_car(v10l);
   if (!(ECL_ATOM(v11x))){
    goto L62;
   }
   L468loop_make_iteration_variable(v11x, ECL_NIL, ECL_NIL);
   goto L61;
L62:;
   T0 = ecl_car(v11x);
   T1 = ecl_cadr(v11x);
   T2 = ecl_caddr(v11x);
   L468loop_make_iteration_variable(T0, T1, T2);
L61:;
   v10l = ecl_cdr(v10l);
L59:;
   if (v10l==ECL_NIL) {
    goto L67;
   }
   goto L58;
L67:;
  }
  T0 = ecl_cadr(v7stuff);
  T1 = cl_reverse(T0);
  T2 = ecl_nconc(T1,ecl_cmp_symbol_value(cl_env_copy,VV[96]));
  ecl_cmp_setq(cl_env_copy,VV[96],T2);
  value0 = ecl_cddr(v7stuff);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L501loop_for_being_va(cl_narg narg, cl_object v9var, cl_object v10val, cl_object v11data_type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[302]);
 {
  return L501loop_for_being(v9var, v10val, v11data_type);
 }
}
/* function definition for LOOP-NAMED-VAR                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L502loop_named_var(cl_object v1name)
{
 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 v2tem;
  {
   cl_object v3;
   v3 = L426loop_tassoc(v1name, ecl_cmp_symbol_value(cl_env_copy,VV[88]));
   if (ecl_unlikely(!ECL_LISTP(v3))) FEtype_error_list(v3);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2tem = v3;
  }
  if (!(v2tem==ECL_NIL)){
   goto L5;
  }
  T0 = cl_gensym(0);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
L5:;
  T0 = cl_delete(2, v2tem, ecl_cmp_symbol_value(cl_env_copy,VV[88]));
  ecl_cmp_setq(cl_env_copy,VV[88],T0);
  T0 = ecl_cdr(v2tem);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_T;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
 }
}
/* function definition for LOOP-COLLECT-PREPOSITIONAL-PHRASES                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L505loop_collect_prepositional_phrases(cl_narg narg, cl_object v1preposition_groups, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[313]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[313]);
 {
  cl_object v2using_allowed;
  cl_object v3initial_phrases;
  va_list args; va_start(args,v1preposition_groups);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v1preposition_groups,env0);  /*  PREPOSITION-GROUPS      */
  {
   int i = 1;
   if (i >= narg) {
    v2using_allowed = ECL_NIL;
   } else {
    i++;
    v2using_allowed = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v3initial_phrases = ECL_NIL;
   } else {
    i++;
    v3initial_phrases = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4;
   cl_object v5;
   cl_object v6token;
   cl_object v7prepositional_phrases;
   cl_object v8this_group;
   cl_object v9this_prep;
   cl_object v10used_prepositions;
   {
    cl_object v11;
    {
     cl_object v12;
     v12 = ecl_make_cclosure_va((cl_objectfn)LC504__lambda692,env0,Cblock,1);
     v11 = v12;
    }
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = v3initial_phrases;
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
     {
      cl_object v15;
      cl_object v16;
      v15 = ecl_list1(ECL_NIL);
      v16 = v15;
L12:;
      if (!(ecl_endp(v14))){
       goto L14;
      }
      goto L13;
L14:;
      v13 = ECL_CONS_CAR(v14);
      {
       cl_object v17;
       v17 = ECL_CONS_CDR(v14);
       if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v14 = v17;
      }
      {
       cl_object v17;
       v17 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
       {
        cl_object v18;
        v18 = v16;
        if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v18;
       }
       (ECL_CONS_CDR(T0)=v17,T0);
       if (Null(v17)){
        goto L22;
       }
      }
      T0 = ecl_cdr(v16);
      v16 = ecl_last(T0,1);
L22:;
      goto L12;
L13:;
      v4 = ecl_cdr(v15);
      goto L3;
     }
    }
   }
L3:;
   {
    cl_object v11;
    v11 = (ECL_SYM("CAR",182)->symbol.gfdef);
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = v3initial_phrases;
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
     {
      cl_object v15;
      cl_object v16;
      v15 = ecl_list1(ECL_NIL);
      v16 = v15;
L41:;
      if (!(ecl_endp(v14))){
       goto L43;
      }
      goto L42;
L43:;
      v13 = ECL_CONS_CAR(v14);
      {
       cl_object v17;
       v17 = ECL_CONS_CDR(v14);
       if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v14 = v17;
      }
      {
       cl_object v17;
       v17 = v16;
       if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v17;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
      v16 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v16,T0);
      goto L41;
L42:;
      v5 = ecl_cdr(v15);
      goto L32;
     }
    }
   }
L32:;
   v6token = ECL_NIL;
   v7prepositional_phrases = v3initial_phrases;
   v8this_group = ECL_NIL;
   v9this_prep = ECL_NIL;
   v10used_prepositions = v5;
   goto L66;
L65:;
   v6token = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   {
    cl_object v11;
    v11 = ECL_CONS_CAR(CLV0);
    goto L74;
L73:;
    {
     cl_object v12group;
     v12group = ecl_car(v11);
     {
      cl_object v13;
      v13 = LC503in_group_p(v6token, v12group);
      {
       bool v14;
       v14 = ECL_SYMBOLP(v13);
       if (ecl_unlikely(!(v14)))
         FEwrong_type_argument(ECL_SYM("SYMBOL",843),v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
      v9this_prep = v13;
     }
     if (Null(v9this_prep)){
      goto L78;
     }
     v8this_group = v12group;
     goto L70;
L78:;
    }
    v11 = ecl_cdr(v11);
L74:;
    if (Null(v11)){
     goto L86;
    }
    goto L73;
L86:;
   }
L70:;
   if (Null(v8this_group)){
    goto L89;
   }
   {
    cl_object v11;
    cl_object v12;
    v11 = v9this_prep;
    v12 = v4;
    if (Null(ecl_memql(v11,v12))){
     goto L91;
    }
   }
   {
    cl_object v11;
    cl_object v12;
    v11 = v9this_prep;
    v12 = v10used_prepositions;
    if (Null(ecl_memql(v11,v12))){
     goto L96;
    }
   }
   T0 = VV[325];
   goto L95;
L96:;
   T0 = VV[326];
L95:;
   L442loop_error(2, T0, v6token);
L91:;
   if (!(ECL_LISTP(v8this_group))){
    goto L102;
   }
   v10used_prepositions = ecl_append(v8this_group,v10used_prepositions);
   goto L101;
L102:;
   v10used_prepositions = CONS(v8this_group,v10used_prepositions);
L101:;
   L450loop_pop_source();
   T0 = L453loop_get_form();
   T1 = cl_list(2, v9this_prep, T0);
   v7prepositional_phrases = CONS(T1,v7prepositional_phrases);
   goto L88;
L89:;
   if (Null(v2using_allowed)){
    goto L106;
   }
   if (Null(L425loop_tequal(v6token, VV[327]))){
    goto L106;
   }
   L450loop_pop_source();
   {
    cl_object v11;
    cl_object v12z;
    cl_object v13tem;
    v11 = L450loop_pop_source();
    v12z = v11;
    v13tem = ECL_NIL;
    goto L115;
L114:;
    if (Null(ecl_cadr(v12z))){
     goto L117;
    }
    T0 = ecl_car(v12z);
    v13tem = L426loop_tassoc(T0, ecl_cmp_symbol_value(cl_env_copy,VV[88]));
    if (Null(v13tem)){
     goto L119;
    }
    T0 = ecl_car(v12z);
    T1 = ecl_cadr(v12z);
    T2 = ecl_cadr(v13tem);
    L442loop_error(4, VV[328], T0, T1, T2);
    goto L117;
L119:;
    T0 = ecl_car(v12z);
    T1 = ecl_cadr(v12z);
    T2 = CONS(T0,T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,VV[88]));
    ecl_cmp_setq(cl_env_copy,VV[88],T3);
L117:;
    if (ecl_cmp_symbol_value(cl_env_copy,VV[84])==ECL_NIL) {
     goto L125;
    }
    T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
    if (!(ECL_SYMBOLP(T0))){
     goto L123;
    }
    goto L124;
L125:;
L124:;
    goto L88;
L123:;
    v12z = L450loop_pop_source();
L115:;
    goto L114;
    goto L88;
   }
L106:;
   value0 = cl_nreverse(v7prepositional_phrases);
   return value0;
L88:;
   v8this_group = ECL_NIL;
   v9this_prep = ECL_NIL;
L66:;
   if (ecl_cmp_symbol_value(cl_env_copy,VV[84])==ECL_NIL) {
    goto L133;
   }
   goto L65;
L133:;
   value0 = cl_nreverse(v7prepositional_phrases);
   return value0;
  }
 }
}
/* function definition for LOOP-SEQUENCER                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L506loop_sequencer(cl_object v1indexv, cl_object v2indexv_type, cl_object v3indexv_user_specified_p, cl_object v4variable, cl_object v5variable_type, cl_object v6sequence_variable, cl_object v7sequence_type, cl_object v8step_hack, cl_object v9default_top, cl_object v10prep_phrases)
{
 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 v11;
  cl_object v12endform;
  cl_object v13sequencep;
  cl_object v14testfn;
  cl_object v15test;
  cl_object v16stepby;
  cl_object v17stepby_constantp;
  cl_object v18step;
  cl_object v19dir;
  cl_object v20inclusive_iteration;
  cl_object v21start_given;
  cl_object v22start_value;
  cl_object v23start_constantp;
  cl_object v24limit_given;
  cl_object v25limit_constantp;
  cl_object v26limit_value;
  value0 = L461loop_typed_init(v2indexv_type);
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_make_int8_t(0);
  goto L3;
L5:;
  T0 = value0;
  goto L3;
L3:;
  v11 = ecl_one_plus(T0);
  v12endform = ECL_NIL;
  v13sequencep = ECL_NIL;
  v14testfn = ECL_NIL;
  v15test = ECL_NIL;
  v16stepby = v11;
  v17stepby_constantp = ECL_T;
  v18step = ECL_NIL;
  v19dir = ECL_NIL;
  v20inclusive_iteration = ECL_NIL;
  v21start_given = ECL_NIL;
  v22start_value = ECL_NIL;
  v23start_constantp = ECL_NIL;
  v24limit_given = ECL_NIL;
  v25limit_constantp = ECL_NIL;
  v26limit_value = ECL_NIL;
  if (Null(v4variable)){
   goto L22;
  }
  L468loop_make_iteration_variable(v4variable, ECL_NIL, v5variable_type);
L22:;
  {
   cl_object v27l;
   cl_object v28prep;
   cl_object v29form;
   cl_object v30odir;
   v27l = v10prep_phrases;
   v28prep = ECL_NIL;
   v29form = ECL_NIL;
   v30odir = ECL_NIL;
   goto L31;
L30:;
   v28prep = ecl_caar(v27l);
   v29form = ecl_cadar(v27l);
   if (!((v28prep)==(VV[331]))){
    goto L43;
   }
   goto L40;
L43:;
   goto L41;
L41:;
   if (!((v28prep)==(VV[306]))){
    goto L38;
   }
   goto L39;
L40:;
L39:;
   v13sequencep = ECL_T;
   L467loop_make_variable(3, v6sequence_variable, v29form, v7sequence_type);
   goto L37;
L38:;
   if (!((v28prep)==(VV[334]))){
    goto L53;
   }
   goto L50;
L53:;
   goto L51;
L51:;
   if (!((v28prep)==(VV[335]))){
    goto L57;
   }
   goto L50;
L57:;
   goto L55;
L55:;
   if (!((v28prep)==(VV[337]))){
    goto L48;
   }
   goto L49;
L50:;
L49:;
   v21start_given = ECL_T;
   if (!((v28prep)==(VV[335]))){
    goto L63;
   }
   v19dir = VV[339];
   goto L62;
L63:;
   if (!((v28prep)==(VV[337]))){
    goto L62;
   }
   v19dir = ECL_SYM("UP",1359);
L62:;
   value0 = L439loop_constant_fold_if_possible(2, v29form, v2indexv_type);
   {
    const int v31 = cl_env_copy->nvalues;
    v29form = value0;
    cl_object v32;
    v32 = (v31<=1)? ECL_NIL : cl_env_copy->values[1];
    v23start_constantp = v32;
    v32 = (v31<=2)? ECL_NIL : cl_env_copy->values[2];
    v22start_value = v32;
   }
   L468loop_make_iteration_variable(v1indexv, v29form, v2indexv_type);
   goto L37;
L48:;
   {
    cl_object v31;
    cl_object v32;
    v31 = v28prep;
    v32 = VV[340];
    if (Null(ecl_memql(v31,v32))){
     goto L70;
    }
   }
   if (Null(L425loop_tequal(v28prep, VV[341]))){
    goto L75;
   }
   v19dir = ECL_SYM("UP",1359);
   v20inclusive_iteration = ECL_SYM("UP",1359);
   goto L74;
L75:;
   if (Null(L425loop_tequal(v28prep, VV[342]))){
    goto L79;
   }
   v20inclusive_iteration = ECL_T;
   goto L74;
L79:;
   if (Null(L425loop_tequal(v28prep, VV[343]))){
    goto L82;
   }
   v19dir = VV[339];
   v20inclusive_iteration = VV[339];
   goto L74;
L82:;
   if (Null(L425loop_tequal(v28prep, VV[344]))){
    goto L86;
   }
   v19dir = VV[339];
   goto L74;
L86:;
   if (Null(L425loop_tequal(v28prep, VV[345]))){
    goto L74;
   }
   v19dir = ECL_SYM("UP",1359);
L74:;
   v24limit_given = ECL_T;
   value0 = L439loop_constant_fold_if_possible(2, v29form, v2indexv_type);
   {
    const int v31 = cl_env_copy->nvalues;
    v29form = value0;
    cl_object v32;
    v32 = (v31<=1)? ECL_NIL : cl_env_copy->values[1];
    v25limit_constantp = v32;
    v32 = (v31<=2)? ECL_NIL : cl_env_copy->values[2];
    v26limit_value = v32;
   }
   if (Null(v25limit_constantp)){
    goto L96;
   }
   v12endform = cl_list(2, ECL_SYM("QUOTE",682), v26limit_value);
   goto L95;
L96:;
   T0 = cl_gensym(1, VV[346]);
   v12endform = L467loop_make_variable(3, T0, v29form, v2indexv_type);
L95:;
   goto L37;
L70:;
   if (!((v28prep)==(VV[281]))){
    goto L98;
   }
   value0 = L439loop_constant_fold_if_possible(2, v29form, v2indexv_type);
   {
    const int v31 = cl_env_copy->nvalues;
    v29form = value0;
    cl_object v32;
    v32 = (v31<=1)? ECL_NIL : cl_env_copy->values[1];
    v17stepby_constantp = v32;
    v32 = (v31<=2)? ECL_NIL : cl_env_copy->values[2];
    v16stepby = v32;
   }
   if (v17stepby_constantp!=ECL_NIL) {
    goto L37;
   }
   v16stepby = cl_gensym(1, VV[347]);
   L467loop_make_variable(3, v16stepby, v29form, v2indexv_type);
   goto L37;
L98:;
   L442loop_error(2, VV[348], v28prep);
L37:;
   if (Null(v30odir)){
    goto L104;
   }
   if (Null(v19dir)){
    goto L104;
   }
   if ((v19dir)==(v30odir)) {
    goto L104;
   }
   L442loop_error(1, VV[349]);
L104:;
   v30odir = v19dir;
   v27l = ecl_cdr(v27l);
L31:;
   if (v27l==ECL_NIL) {
    goto L112;
   }
   goto L30;
L112:;
  }
  if (Null(v6sequence_variable)){
   goto L114;
  }
  if (v13sequencep!=ECL_NIL) {
   goto L114;
  }
  L442loop_error(1, VV[350]);
L114:;
  if (v21start_given!=ECL_NIL) {
   goto L117;
  }
  v23start_constantp = ECL_T;
  value0 = L461loop_typed_init(v2indexv_type);
  if (value0!=ECL_NIL) {
   goto L123;
  }
  v22start_value = ecl_make_int8_t(0);
  goto L121;
L123:;
  v22start_value = value0;
  goto L121;
L121:;
  L468loop_make_iteration_variable(v1indexv, v22start_value, v2indexv_type);
L117:;
  if (!((v19dir)==(ECL_NIL))){
   goto L131;
  }
  goto L128;
L131:;
  goto L129;
L129:;
  if (!((v19dir)==(ECL_SYM("UP",1359)))){
   goto L126;
  }
  goto L127;
L128:;
L127:;
  if (v24limit_given!=ECL_NIL) {
   goto L136;
  }
  if (Null(v9default_top)){
   goto L134;
  }
  goto L135;
L136:;
L135:;
  if (v24limit_given!=ECL_NIL) {
   goto L138;
  }
  v12endform = cl_gensym(1, VV[353]);
  L467loop_make_variable(3, v12endform, ECL_NIL, v2indexv_type);
  T0 = cl_list(3, ECL_SYM("SETQ",754), v12endform, v9default_top);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[96]));
  ecl_cmp_setq(cl_env_copy,VV[96],T1);
L138:;
  if (Null(v20inclusive_iteration)){
   goto L144;
  }
  v14testfn = ECL_SYM(">",77);
  goto L143;
L144:;
  v14testfn = ECL_SYM(">=",78);
L143:;
L134:;
  if (!((v16stepby)==(ecl_make_int8_t(1)))){
   goto L147;
  }
  v18step = cl_list(2, ECL_SYM("1+",72), v1indexv);
  goto L146;
L147:;
  v18step = cl_list(3, ECL_SYM("+",16), v1indexv, v16stepby);
L146:;
  goto L125;
L126:;
  if (v21start_given!=ECL_NIL) {
   goto L149;
  }
  if (v9default_top!=ECL_NIL) {
   goto L151;
  }
  L442loop_error(1, VV[354]);
L151:;
  T0 = cl_list(2, ECL_SYM("1-",73), v9default_top);
  T1 = cl_list(3, ECL_SYM("SETQ",754), v1indexv, T0);
  T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[96]));
  ecl_cmp_setq(cl_env_copy,VV[96],T2);
L149:;
  if (Null(v9default_top)){
   goto L154;
  }
  if (v12endform!=ECL_NIL) {
   goto L154;
  }
  v12endform = L461loop_typed_init(v2indexv_type);
  v20inclusive_iteration = ECL_T;
L154:;
  if (Null(v12endform)){
   goto L160;
  }
  if (Null(v20inclusive_iteration)){
   goto L163;
  }
  v14testfn = ECL_SYM("<",74);
  goto L162;
L163:;
  v14testfn = ECL_SYM("<=",75);
L162:;
L160:;
  if (!((v16stepby)==(ecl_make_int8_t(1)))){
   goto L166;
  }
  v18step = cl_list(2, ECL_SYM("1-",73), v1indexv);
  goto L165;
L166:;
  v18step = cl_list(3, ECL_SYM("-",19), v1indexv, v16stepby);
L165:;
L125:;
  v18step = cl_list(2, VV[0], v18step);
  if (Null(v14testfn)){
   goto L170;
  }
  v15test = cl_list(3, v14testfn, v1indexv, v12endform);
L170:;
  if (Null(v8step_hack)){
   goto L173;
  }
  v8step_hack = cl_list(2, v4variable, v8step_hack);
L173:;
  {
   cl_object v27first_test;
   cl_object v28remaining_tests;
   v27first_test = v15test;
   v28remaining_tests = v15test;
   if (Null(v17stepby_constantp)){
    goto L178;
   }
   if (Null(v23start_constantp)){
    goto L178;
   }
   {
    cl_object v29new_type;
    {
     cl_object v30;
     v30 = ecl_plus(v22start_value,v16stepby);
     if (!(ECL_FIXNUMP(v30)||ECL_BIGNUMP(v30))){
      goto L184;
     }
     if (!(ECL_FIXNUMP(v22start_value))){
      goto L186;
     }
     if (Null(v25limit_constantp)){
      goto L186;
     }
     T0 = ecl_one_plus(v26limit_value);
     if (!(ECL_FIXNUMP(T0))){
      goto L186;
     }
     T0 = ecl_one_minus(v26limit_value);
     if (!(ECL_FIXNUMP(T0))){
      goto L186;
     }
     v29new_type = ECL_SYM("FIXNUM",374);
     goto L182;
L186:;
     v29new_type = ECL_SYM("INTEGER",439);
     goto L182;
L184:;
     if (!(ECL_SINGLE_FLOAT_P(v30))){
      goto L191;
     }
     v29new_type = ECL_SYM("SINGLE-FLOAT",781);
     goto L182;
L191:;
     if (!(ECL_DOUBLE_FLOAT_P(v30))){
      goto L193;
     }
     v29new_type = ECL_SYM("DOUBLE-FLOAT",317);
     goto L182;
L193:;
     if (!(ECL_LONG_FLOAT_P(v30))){
      goto L195;
     }
     v29new_type = ECL_SYM("LONG-FLOAT",510);
     goto L182;
L195:;
     if (!(ECL_SINGLE_FLOAT_P(v30))){
      goto L197;
     }
     v29new_type = ECL_SYM("SHORT-FLOAT",759);
     goto L182;
L197:;
     v29new_type = v2indexv_type;
    }
L182:;
    T0 = cl_type_of(v22start_value);
    if (cl_subtypep(3, T0, v29new_type, ecl_cmp_symbol_value(cl_env_copy,VV[27]))!=ECL_NIL) {
     goto L199;
    }
    T0 = cl_type_of(v22start_value);
    v29new_type = cl_list(3, ECL_SYM("OR",616), T0, v29new_type);
L199:;
    if (cl_subtypep(3, v2indexv_type, v29new_type, ecl_cmp_symbol_value(cl_env_copy,VV[27]))!=ECL_NIL) {
     goto L181;
    }
    L470loop_declare_variable(2, v1indexv, v29new_type);
   }
L181:;
   if (Null(v25limit_constantp)){
    goto L178;
   }
   T0 = cl_symbol_function(v14testfn);
   v27first_test = ecl_function_dispatch(cl_env_copy,T0)(2, v22start_value, v26limit_value);
   if (Null(v27first_test)){
    goto L178;
   }
   v28remaining_tests = ECL_T;
L178:;
   T0 = cl_list(2, v1indexv, v18step);
   value0 = cl_list(8, ECL_NIL, T0, v28remaining_tests, v8step_hack, ECL_NIL, ECL_NIL, v27first_test, v8step_hack);
   return value0;
  }
 }
}
/* function definition for LOOP-FOR-ARITHMETIC                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L507loop_for_arithmetic(cl_object v1var, cl_object v2val, cl_object v3data_type, cl_object v4kwd)
{
 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 (v1var!=ECL_NIL) {
  goto L2;
 }
 v1var = cl_gensym(0);
L2:;
 T0 = L444loop_check_data_type(2, v3data_type, ECL_SYM("NUMBER",608));
 T1 = cl_list(2, v4kwd, v2val);
 T2 = ecl_list1(T1);
 T3 = L505loop_collect_prepositional_phrases(3, VV[356], ECL_NIL, T2);
 value0 = L506loop_sequencer(v1var, T0, ECL_T, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, T3);
 return value0;
}
static cl_object L507loop_for_arithmetic_va(cl_narg narg, cl_object v5var, cl_object v6val, cl_object v7data_type, cl_object v8kwd, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[355]);
 {
  return L507loop_for_arithmetic(v5var, v6val, v7data_type, v8kwd);
 }
}
/* function definition for LOOP-HASH-TABLE-ITERATION-PATH                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L508loop_hash_table_iteration_path(cl_narg narg, cl_object v1variable, cl_object v2data_type, cl_object v3prep_phrases, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[358]);
 {
  cl_object v4which;
  ecl_va_list args; ecl_va_start(args,v3prep_phrases,narg,3);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L508loop_hash_table_iteration_pathkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v4which = keyvars[0];
  }
  {
   cl_object v5;
   v5 = v4which;
   if (!((v5)==(VV[360]))){
    goto L7;
   }
   goto L3;
L7:;
   goto L5;
L5:;
   if (!((v5)==(VV[361]))){
    goto L10;
   }
   goto L3;
L10:;
   goto L4;
L4:;
   v4which = si_do_check_type(v5, VV[363], ECL_NIL, VV[364]);
L3:;
  }
  if (ecl_cdr(v3prep_phrases)!=ECL_NIL) {
   goto L16;
  }
  {
   cl_object v5;
   v5 = ecl_caar(v3prep_phrases);
   if (!((v5)==(VV[306]))){
    goto L21;
   }
   goto L14;
L21:;
   goto L19;
L19:;
   if (!((v5)==(VV[331]))){
    goto L24;
   }
   goto L14;
L24:;
   goto L15;
  }
L16:;
L15:;
  L442loop_error(1, VV[367]);
  goto L13;
L14:;
  if (!(v3prep_phrases==ECL_NIL)){
   goto L13;
  }
  L442loop_error(1, VV[368]);
L13:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7dummy_predicate_var;
   cl_object v8post_steps;
   v5 = cl_gensym(1, VV[369]);
   v6 = cl_gensym(1, VV[370]);
   v7dummy_predicate_var = ECL_NIL;
   v8post_steps = ECL_NIL;
   {
    cl_object v9;                                 /*  OTHER-VAR               */
    cl_object v10;                                /*  OTHER-P                 */
    if (!((v4which)==(VV[360]))){
     goto L33;
    }
    T0 = VV[361];
    goto L32;
L33:;
    T0 = VV[360];
L32:;
    value0 = L502loop_named_var(T0);
    {
     const int v11 = cl_env_copy->nvalues;
     v9 = value0;
     cl_object v12;
     v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
     v10 = v12;
    }
    v10 = ECL_T;
    v7dummy_predicate_var = L492loop_when_it_variable();
    {
     cl_object v11key_var;
     cl_object v12val_var;
     cl_object v13temp_val_var;
     cl_object v14temp_key_var;
     cl_object v15temp_predicate_var;
     cl_object v16variable;
     cl_object v17bindings;
     v11key_var = ECL_NIL;
     v12val_var = ECL_NIL;
     v13temp_val_var = cl_gensym(1, VV[371]);
     v14temp_key_var = cl_gensym(1, VV[372]);
     v15temp_predicate_var = cl_gensym(1, VV[373]);
     value0 = v1variable;
     if (value0!=ECL_NIL) {
      goto L46;
     }
     v16variable = cl_gensym(0);
     goto L44;
L46:;
     v16variable = value0;
     goto L44;
L44:;
     T0 = cl_list(3, v16variable, ECL_NIL, v2data_type);
     T1 = ecl_cadar(v3prep_phrases);
     T2 = cl_list(2, v5, T1);
     if (Null(v10)){
      goto L51;
     }
     if (Null(v9)){
      goto L51;
     }
     T4 = cl_list(2, v9, ECL_NIL);
     T3 = ecl_list1(T4);
     goto L49;
L51:;
     T3 = ECL_NIL;
     goto L49;
L49:;
     v17bindings = cl_listX(3, T0, T2, T3);
     if (!((v4which)==(VV[360]))){
      goto L55;
     }
     v11key_var = v16variable;
     if (Null(v10)){
      goto L61;
     }
     v12val_var = v9;
     goto L59;
L61:;
     v12val_var = ECL_NIL;
     goto L59;
L59:;
     goto L54;
L55:;
     if (Null(v10)){
      goto L66;
     }
     v11key_var = v9;
     goto L64;
L66:;
     v11key_var = ECL_NIL;
     goto L64;
L64:;
     v12val_var = v16variable;
L54:;
     T0 = cl_list(2, v6, v5);
     T1 = cl_list(2, ECL_SYM("WITH-HASH-TABLE-ITERATOR",913), T0);
     T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[92]));
     ecl_cmp_setq(cl_env_copy,VV[92],T2);
     if (!(ECL_CONSP(v11key_var))){
      goto L71;
     }
     T0 = v11key_var;
     v11key_var = cl_gensym(1, VV[372]);
     v8post_steps = cl_listX(3, T0, v11key_var, v8post_steps);
     T0 = cl_list(2, v11key_var, ECL_NIL);
     v17bindings = CONS(T0,v17bindings);
L71:;
     if (!(ECL_CONSP(v12val_var))){
      goto L78;
     }
     T0 = v12val_var;
     v12val_var = cl_gensym(1, VV[371]);
     v8post_steps = cl_listX(3, T0, v12val_var, v8post_steps);
     T0 = cl_list(2, v12val_var, ECL_NIL);
     v17bindings = CONS(T0,v17bindings);
L78:;
     T0 = cl_list(3, v15temp_predicate_var, v14temp_key_var, v13temp_val_var);
     T1 = ecl_list1(v6);
     T2 = cl_list(3, ECL_SYM("SETQ",754), v12val_var, v13temp_val_var);
     T3 = cl_list(3, ECL_SYM("SETQ",754), v11key_var, v14temp_key_var);
     T4 = cl_list(4, ECL_SYM("WHEN",909), v15temp_predicate_var, T2, T3);
     T5 = cl_list(3, ECL_SYM("SETQ",754), v7dummy_predicate_var, v15temp_predicate_var);
     T6 = cl_list(5, ECL_SYM("MULTIPLE-VALUE-BIND",574), T0, T1, T4, T5);
     T7 = cl_list(2, ECL_SYM("NOT",586), T6);
     value0 = cl_list(6, v17bindings, ECL_NIL, ECL_NIL, ECL_NIL, T7, v8post_steps);
     return value0;
    }
   }
  }
 }
}
/* function definition for LOOP-PACKAGE-SYMBOLS-ITERATION-PATH                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L509loop_package_symbols_iteration_path(cl_narg narg, cl_object v1variable, cl_object v2data_type, cl_object v3prep_phrases, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[375]);
 {
  cl_object v4symbol_types;
  ecl_va_list args; ecl_va_start(args,v3prep_phrases,narg,3);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L509loop_package_symbols_iteration_pathkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v4symbol_types = keyvars[0];
  }
  if (Null(v3prep_phrases)){
   goto L2;
  }
  if (Null(ecl_cdr(v3prep_phrases))){
   goto L2;
  }
  L442loop_error(1, VV[367]);
  goto L1;
L2:;
  if (Null(v3prep_phrases)){
   goto L1;
  }
  {
   cl_object v5;
   v5 = ecl_caar(v3prep_phrases);
   if (!((v5)==(VV[306]))){
    goto L10;
   }
   goto L1;
L10:;
   goto L8;
L8:;
   if (!((v5)==(VV[331]))){
    goto L13;
   }
   goto L1;
L13:;
   goto L5;
  }
L5:;
  T0 = ecl_caar(v3prep_phrases);
  L442loop_error(2, VV[376], T0);
L1:;
  if (ECL_SYMBOLP(v1variable)) {
   goto L15;
  }
  L442loop_error(1, VV[377]);
L15:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   cl_object v8;
   v5 = cl_gensym(1, VV[378]);
   v6 = cl_gensym(1, VV[379]);
   value0 = v1variable;
   if (value0!=ECL_NIL) {
    goto L21;
   }
   v7 = cl_gensym(0);
   goto L19;
L21:;
   v7 = value0;
   goto L19;
L19:;
   value0 = ecl_cadar(v3prep_phrases);
   if (value0!=ECL_NIL) {
    goto L25;
   }
   v8 = ECL_SYM("*PACKAGE*",45);
   goto L23;
L25:;
   v8 = value0;
   goto L23;
L23:;
   T0 = cl_listX(3, v6, v5, v4symbol_types);
   T1 = cl_list(2, ECL_SYM("WITH-PACKAGE-ITERATOR",918), T0);
   T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[92]));
   ecl_cmp_setq(cl_env_copy,VV[92],T2);
   T0 = cl_list(3, v7, ECL_NIL, v2data_type);
   T1 = cl_list(2, v5, v8);
   T2 = cl_list(2, T0, T1);
   T3 = L492loop_when_it_variable();
   T4 = cl_list(2, T3, v7);
   T5 = ecl_list1(v6);
   T6 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-SETQ",578), T4, T5);
   T7 = cl_list(2, ECL_SYM("NOT",586), T6);
   value0 = cl_list(6, T2, ECL_NIL, ECL_NIL, ECL_NIL, T7, ECL_NIL);
   return value0;
  }
 }
}
/* function definition for MAKE-ANSI-LOOP-UNIVERSE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L510make_ansi_loop_universe(cl_object v1extended_p)
{
 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 v2w;
  if (Null(v1extended_p)){
   goto L4;
  }
  T0 = VV[386];
  goto L3;
L4:;
  T0 = ECL_T;
L3:;
  v2w = L432make_standard_loop_universe(12, VV[65], VV[382], VV[66], VV[383], VV[67], VV[384], VV[72], VV[385], VV[71], ECL_NIL, VV[69], T0);
  L500add_loop_path(9, VV[387], VV[358], v2w, VV[299], VV[388], VV[301], ECL_NIL, VV[298], VV[389]);
  L500add_loop_path(9, VV[390], VV[358], v2w, VV[299], VV[388], VV[301], ECL_NIL, VV[298], VV[391]);
  L500add_loop_path(9, VV[392], VV[375], v2w, VV[299], VV[388], VV[301], ECL_NIL, VV[298], VV[393]);
  L500add_loop_path(9, VV[394], VV[375], v2w, VV[299], VV[388], VV[301], ECL_NIL, VV[298], VV[395]);
  L500add_loop_path(9, VV[396], VV[375], v2w, VV[299], VV[388], VV[301], ECL_NIL, VV[298], VV[397]);
  value0 = v2w;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for LOOP-STANDARD-EXPANSION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L511loop_standard_expansion(cl_object v1keywords_and_forms, cl_object v2environment, cl_object v3universe)
{
 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_SYM("ATOM",121)->symbol.gfdef);
 if (Null(cl_some(2, T0, v1keywords_and_forms))){
  goto L2;
 }
 T0 = ecl_car(v1keywords_and_forms);
 if (!(ECL_SYMBOLP(T0))){
  goto L5;
 }
 value0 = L448loop_translate(v1keywords_and_forms, v2environment, v3universe);
 return value0;
L5:;
 T0 = ecl_car(v1keywords_and_forms);
 value0 = cl_error(2, VV[400], T0);
 return value0;
L2:;
 {
  cl_object v4tag;
  v4tag = cl_gensym(0);
  T0 = CONS(ECL_SYM("PROGN",674),v1keywords_and_forms);
  T1 = cl_list(2, ECL_SYM("GO",416), v4tag);
  T2 = cl_list(4, ECL_SYM("TAGBODY",853), v4tag, T0, T1);
  value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T2);
  return value0;
 }
}
/* local function LOOP                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC512loop(cl_object v1, cl_object v2env)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  value0 = L511loop_standard_expansion(v3, v2env, ecl_cmp_symbol_value(cl_env_copy,VV[398]));
  return value0;
 }
}
static cl_object LC512loop_va(cl_narg narg, cl_object v4, cl_object v5env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[401]);
 {
  return LC512loop(v4, v5env);
 }
}
/* local function CDR-WRAP                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC416cdr_wrap(cl_object v1form, cl_object v2n)
{
 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);
 cl_fixnum v3n;
 v3n = ecl_to_fixnum(v2n);
L1:;
 goto L4;
L3:;
 v1form = cl_list(2, ECL_SYM("CDDDDR",197), v1form);
 {
  cl_object v4;
  v4 = ecl_minus(ecl_make_fixnum(v3n),ecl_make_int8_t(4));
  {
   bool v5;
   v5 = ECL_FIXNUMP(v4);
   if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v4);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
  }
  v3n = ecl_fixnum(v4);
 }
L4:;
 if ((v3n)<=((cl_fixnum)(4))) {
  goto L12;
 }
 goto L3;
L12:;
 if (!((v3n)==((cl_fixnum)(1)))){
  goto L16;
 }
 T0 = ECL_SYM("CDR",200);
 goto L15;
L16:;
 if (!((v3n)==((cl_fixnum)(2)))){
  goto L18;
 }
 T0 = ECL_SYM("CDDR",199);
 goto L15;
L18:;
 if (!((v3n)==((cl_fixnum)(3)))){
  goto L20;
 }
 T0 = ECL_SYM("CDDDR",198);
 goto L15;
L20:;
 if (!((v3n)==((cl_fixnum)(4)))){
  goto L22;
 }
 T0 = ECL_SYM("CDDDDR",197);
 goto L15;
L22:;
 T0 = ECL_NIL;
L15:;
 v1form = cl_list(2, T0, v1form);
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC416cdr_wrap_va(cl_narg narg, cl_object v4form, cl_object v5n, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[9]);
 {
  return LC416cdr_wrap(v4form, v5n);
 }
}
/* local function LAMBDA94                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC420__lambda94(cl_object v1t1, cl_object v2t2)
{
 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_subtypep(3, v1t1, v2t2, ecl_cmp_symbol_value(cl_env_copy,VV[27]));
 return value0;
}
static cl_object LC420__lambda94_va(cl_narg narg, cl_object v3t1, cl_object v4t2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
  return LC420__lambda94(v3t1, v4t2);
 }
}
/* local function MAKETABLE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC431maketable(cl_object v1entries)
{
 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 v2size;
  cl_object v3ht;
  v2size = ecl_make_fixnum(ecl_length(v1entries));
  if (!((ecl_fixnum(v2size))<((cl_fixnum)(10)))){
   goto L5;
  }
  T0 = ecl_make_int8_t(10);
  goto L4;
L5:;
  T0 = v2size;
L4:;
  T1 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
  v3ht = cl_make_hash_table(4, ECL_SYM("SIZE",1345), T0, ECL_SYM("TEST",1353), T1);
  {
   cl_object v4;
   v4 = v1entries;
   goto L12;
L11:;
   {
    cl_object v5x;
    v5x = ecl_car(v4);
    T0 = ecl_car(v5x);
    T1 = ecl_symbol_name(T0);
    T2 = ecl_cadr(v5x);
    si_hash_set(T1, v3ht, T2);
   }
   v4 = ecl_cdr(v4);
L12:;
   if (Null(v4)){
    goto L19;
   }
   goto L11;
L19:;
  }
  value0 = v3ht;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC431maketable_va(cl_narg narg, cl_object v4entries, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[64]);
 {
  return LC431maketable(v4entries);
 }
}
/* closure LOOP-DESETQ-INTERNAL                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC437loop_desetq_internal(cl_narg narg, cl_object v1var, cl_object v2val, ...)
{
 cl_object T0, T1, T2, T3, T4;
 volatile struct ecl_cclosure aux_closure;
 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<2)) FEwrong_num_arguments(VV[80]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[80]);
 {
  cl_object v3temp;
  va_list args; va_start(args,v2val);
  {
   int i = 2;
   if (i >= narg) {
    v3temp = ECL_NIL;
   } else {
    i++;
    v3temp = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(ECL_CONSP(v2val))){
   goto L2;
  }
  T0 = ecl_car(v2val);
  if (!((T0)==(VV[0]))){
   goto L2;
  }
  {
   cl_object v4forms;
   v4forms = ecl_cdr(v2val);
   if (Null(ecl_cdr(v4forms))){
    goto L8;
   }
   v4forms = CONS(ECL_SYM("PROGN",674),v4forms);
   goto L7;
L8:;
   v4forms = ecl_car(v4forms);
L7:;
   T0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC437loop_desetq_internal(2, v1var, v4forms));
   T1 = CONS(VV[0],T0);
   value0 = ecl_list1(T1);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L2:;
  if (!(v1var==ECL_NIL)){
   goto L11;
  }
  if (!(ECL_CONSP(v2val))){
   goto L13;
  }
  T0 = ecl_car(v2val);
  if (!((T0)==(ECL_SYM("PROG1",672)))){
   goto L15;
  }
  {
   cl_object v4;
   {
    cl_object v5;
    v5 = ecl_make_cclosure_va((cl_objectfn)LC436__lambda258,env0,Cblock,1);
    v4 = v5;
   }
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_cdr(v2val);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6 = ECL_NIL;
    v7 = v5;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L25:;
     if (!(ecl_endp(v7))){
      goto L27;
     }
     goto L26;
L27:;
     v6 = ECL_CONS_CAR(v7);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v7);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     {
      cl_object v10;
      v10 = ecl_function_dispatch(cl_env_copy,v4)(1, v6);
      {
       cl_object v11;
       v11 = v9;
       if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v11;
      }
      (ECL_CONS_CDR(T0)=v10,T0);
      if (Null(v10)){
       goto L35;
      }
     }
     T0 = ecl_cdr(v9);
     v9 = ecl_last(T0,1);
L35:;
     goto L25;
L26:;
     value0 = ecl_cdr(v8);
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
L15:;
  value0 = ecl_list1(v2val);
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  if (!(ECL_CONSP(v1var))){
   goto L45;
  }
  {
   cl_object v10car;
   cl_object v11cdr;
   cl_object v12car_non_null;
   cl_object v13cdr_non_null;
   v10car = ecl_car(v1var);
   v11cdr = ecl_cdr(v1var);
   v12car_non_null = LC435find_non_null(v10car);
   v13cdr_non_null = LC435find_non_null(v11cdr);
   if (v12car_non_null!=ECL_NIL) {
    goto L53;
   }
   if (Null(v13cdr_non_null)){
    goto L51;
   }
   goto L52;
L53:;
L52:;
   if (Null(v13cdr_non_null)){
    goto L55;
   }
   {
    cl_object v14temp;
    cl_object v15body;
    value0 = v3temp;
    if (value0!=ECL_NIL) {
     goto L59;
    }
    v14temp = ecl_cmp_symbol_value(cl_env_copy,VV[77]);
    goto L57;
L59:;
    v14temp = value0;
    goto L57;
L57:;
    T1 = cl_list(2, ECL_SYM("CAR",182), v14temp);
    T0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC437loop_desetq_internal(2, v10car, T1));
    T1 = cl_list(2, ECL_SYM("CDR",200), v14temp);
    T2 = cl_list(3, ECL_SYM("SETQ",754), v14temp, T1);
    T3 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC437loop_desetq_internal(3, v11cdr, v14temp, v14temp));
    T4 = CONS(T2,T3);
    v15body = ecl_append(T0,T4);
    if (Null(v3temp)){
     goto L64;
    }
    if ((v14temp)==(v2val)) {
     goto L67;
    }
    T1 = cl_list(3, ECL_SYM("SETQ",754), v14temp, v2val);
    T0 = ecl_list1(T1);
    goto L66;
L67:;
    T0 = ECL_NIL;
L66:;
    value0 = ecl_append(T0,v15body);
    cl_env_copy->nvalues = 1;
    return value0;
L64:;
    T0 = cl_list(2, v14temp, v2val);
    T1 = ecl_list1(T0);
    T2 = cl_listX(3, ECL_SYM("LET",479), T1, v15body);
    value0 = ecl_list1(T2);
    cl_env_copy->nvalues = 1;
    return value0;
   }
L55:;
   T0 = cl_list(2, ECL_SYM("CAR",182), v2val);
   value0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC437loop_desetq_internal(3, v10car, T0, v3temp));
   return value0;
L51:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L45:;
  if ((v1var)==(v2val)) {
   goto L69;
  }
  T0 = cl_list(3, ECL_SYM("SETQ",754), v1var, v2val);
  value0 = ecl_list1(T0);
  cl_env_copy->nvalues = 1;
  return value0;
L69:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function FIND-NON-NULL                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC435find_non_null(cl_object v1var)
{
 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 v2tail;
  v2tail = v1var;
  goto L5;
L4:;
  {
   cl_object v3;
   v3 = v2tail;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[79],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L14;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v2tail = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L14:;
   T0 = v3;
  }
  if (Null(LC435find_non_null(T0))){
   goto L7;
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
L5:;
  if (!(ECL_CONSP(v2tail))){
   goto L20;
  }
  goto L4;
L20:;
  value0 = v2tail;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC435find_non_null_va(cl_narg narg, cl_object v3var, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[78]);
 {
  return LC435find_non_null(v3var);
 }
}
/* local function REPLICATE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC463replicate(cl_object v1typ, cl_object v2v)
{
 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:;
 if (!(ECL_ATOM(v2v))){
  goto L2;
 }
 value0 = v1typ;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T1 = ecl_car(v2v);
 T0 = LC463replicate(v1typ, T1);
 T2 = ecl_cdr(v2v);
 T1 = LC463replicate(v1typ, T2);
 value0 = CONS(T0,T1);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC463replicate_va(cl_narg narg, cl_object v3typ, cl_object v4v, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[172]);
 {
  return LC463replicate(v3typ, v4v);
 }
}
/* local function TRANSLATE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC462translate(volatile cl_object *lex0, cl_object v1k, cl_object v2v)
{
 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 (!(v1k==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_ATOM(v1k))){
  goto L4;
 }
 T1 = (cl_env_copy->function=(VV[167]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-TYPE-SYMBOLS */;
 value0 = ecl_gethash_safe(v1k,T1,ECL_NIL);
 if (value0!=ECL_NIL) {
  goto L8;
 }
 T1 = ecl_symbol_name(v1k);
 T2 = (cl_env_copy->function=(VV[168]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-TYPE-KEYWORDS */;
 value0 = ecl_gethash_safe(T1,T2,ECL_NIL);
 if (value0!=ECL_NIL) {
  goto L8;
 }
 T0 = L442loop_error(3, VV[173], lex0[1], v1k);
 goto L6;
L8:;
 T0 = value0;
 goto L6;
L6:;
 value0 = LC463replicate(T0, v2v);
 return value0;
L4:;
 if (!(ECL_ATOM(v2v))){
  goto L11;
 }
 value0 = L442loop_error(3, VV[174], lex0[1], lex0[0]);
 return value0;
L11:;
 T1 = ecl_car(v1k);
 T2 = ecl_car(v2v);
 T0 = LC462translate(lex0, T1, T2);
 T2 = ecl_cdr(v1k);
 T3 = ecl_cdr(v2v);
 T1 = LC462translate(lex0, T2, T3);
 value0 = CONS(T0,T1);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function LAMBDA486                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC469__lambda486(cl_object v1d)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_CONSP(v1d))){
  goto L3;
 }
 {
  cl_fixnum v2;
  v2 = ecl_length(v1d);
  if (!((v2)==((cl_fixnum)(3)))){
   goto L3;
  }
 }
 T0 = ECL_CONS_CAR(v1d);
 if (!((T0)==(ECL_SYM("TYPE",872)))){
  goto L3;
 }
 value0 = ecl_caddr(v1d);
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC469__lambda486_va(cl_narg narg, cl_object v2d, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[185]);
 {
  return LC469__lambda486(v2d);
 }
}
/* local function GET-CLAUSE                                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC472get_clause(volatile cl_object *lex0, cl_object v1for)
{
 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 v2body;
  v2body = ECL_NIL;
  goto L5;
L4:;
  {
   cl_object v3;
   cl_object v4data;
   v3 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   ecl_bds_bind(cl_env_copy,VV[98],ECL_NIL);      /*  *LOOP-BODY*             */
   v4data = ECL_NIL;
   if (ECL_SYMBOLP(v3)) {
    goto L10;
   }
   L442loop_error(3, VV[195], v3, v1for);
   ecl_bds_unwind1(cl_env_copy);
   goto L7;
L10:;
   T0 = ecl_cmp_symbol_value(cl_env_copy,VV[84]);
   ecl_cmp_setq(cl_env_copy,VV[86],T0);
   L450loop_pop_source();
   T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   if (Null(L425loop_tequal(T0, VV[196]))){
    goto L15;
   }
   if (Null(lex0[1])){
    goto L15;
   }
   value0 = lex0[0];
   if (value0!=ECL_NIL) {
    goto L21;
   }
   lex0[0] = L492loop_when_it_variable();
   T0 = lex0[0];
   goto L19;
L21:;
   T0 = value0;
   goto L19;
L19:;
   T1 = ecl_cdr(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
   T2 = CONS(T0,T1);
   ecl_cmp_setq(cl_env_copy,VV[84],T2);
L15:;
   T0 = (cl_env_copy->function=(VV[137]->symbol.gfdef))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  LOOP-UNIVERSE-KEYWORDS */;
   v4data = L428loop_lookup_keyword(v3, T0);
   if (Null(v4data)){
    goto L26;
   }
   T0 = ecl_car(v4data);
   T1 = cl_symbol_function(T0);
   T2 = ecl_cdr(v4data);
   cl_apply(2, T1, T2);
   if (!(ecl_cmp_symbol_value(cl_env_copy,VV[98])==ECL_NIL)){
    goto L24;
   }
   goto L25;
L26:;
L25:;
   L442loop_error(3, VV[198], v3, v1for);
   ecl_bds_unwind1(cl_env_copy);
   goto L7;
L24:;
   v2body = cl_nreconc(ecl_cmp_symbol_value(cl_env_copy,VV[98]), v2body);
   ecl_bds_unwind1(cl_env_copy);
  }
L7:;
  lex0[1] = ECL_NIL;
  T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[84]));
  if (Null(L425loop_tequal(T0, VV[199]))){
   goto L34;
  }
  L450loop_pop_source();
  goto L33;
L34:;
  if (Null(ecl_cdr(v2body))){
   goto L36;
  }
  T0 = cl_nreverse(v2body);
  value0 = CONS(ECL_SYM("PROGN",674),T0);
  cl_env_copy->nvalues = 1;
  return value0;
L36:;
  value0 = ecl_car(v2body);
  cl_env_copy->nvalues = 1;
  return value0;
L33:;
L5:;
  goto L4;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function MAKE-ENDTEST                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC488make_endtest(cl_object v1list_of_forms)
{
 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 (!(v1list_of_forms==ECL_NIL)){
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v2;
  cl_object v3;
  v2 = ECL_T;
  v3 = v1list_of_forms;
  if (Null(ecl_memql(v2,v3))){
   goto L4;
  }
 }
 value0 = VV[125];
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 v1list_of_forms = cl_nreverse(v1list_of_forms);
 T1 = ecl_cdr(v1list_of_forms);
 if (!(T1==ECL_NIL)){
  goto L9;
 }
 T0 = ecl_car(v1list_of_forms);
 goto L8;
L9:;
 T0 = CONS(ECL_SYM("OR",616),v1list_of_forms);
L8:;
 value0 = cl_list(3, ECL_SYM("WHEN",909), T0, VV[125]);
 return value0;
}
static cl_object LC488make_endtest_va(cl_narg narg, cl_object v2list_of_forms, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[260]);
 {
  return LC488make_endtest(v2list_of_forms);
 }
}
/* local function LAMBDA645                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC499__lambda645(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:;
 if (!(ECL_LISTP(v1x))){
  goto L2;
 }
 value0 = v1x;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ecl_list1(v1x);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC499__lambda645_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[300]);
 {
  return LC499__lambda645(v2x);
 }
}
/* local function IN-GROUP-P                                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC503in_group_p(cl_object v1x, cl_object v2group)
{
 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 = L427loop_tmember(v1x, v2group);
 value0 = ecl_car(T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC503in_group_p_va(cl_narg narg, cl_object v3x, cl_object v4group, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[323]);
 {
  return LC503in_group_p(v3x, v4group);
 }
}
/* closure LAMBDA692                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC504__lambda692(cl_narg narg, cl_object v1x, ...)
{
 cl_object T0;
 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;                                     /*  PREPOSITION-GROUPS      */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[324]);
 {
L1:;
  {
   cl_object v2;
   v2 = ecl_car(v1x);
   {
    cl_object v3;
    v3 = si_make_seq_iterator(2, ECL_CONS_CAR(CLV0), ecl_make_int8_t(0));
L5:;
    if (v3!=ECL_NIL) {
     goto L7;
    }
    T0 = ECL_NIL;
    goto L2;
L7:;
    {
     cl_object v4;
     v4 = si_seq_iterator_ref(ECL_CONS_CAR(CLV0), v3);
     if (Null(LC503in_group_p(v2, v4))){
      goto L9;
     }
     T0 = v4;
     goto L2;
    }
L9:;
    v3 = si_seq_iterator_next(ECL_CONS_CAR(CLV0), v3);
    goto L5;
   }
  }
L2:;
  value0 = cl_copy_list(T0);
  return value0;
 }
 }
}
/* closure LAMBDA258                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC436__lambda258(cl_narg narg, cl_object v1x, ...)
{
 cl_object T0;
 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[81]);
 {
L1:;
  if (!(ECL_CONSP(v1x))){
   goto L3;
  }
  T0 = ecl_car(v1x);
  if (!((T0)==(ECL_SYM("CAR",182)))){
   goto L6;
  }
  T0 = ecl_cadr(v1x);
  if (!(ECL_SYMBOLP(T0))){
   goto L6;
  }
  v1x = cl_macroexpand(2, v1x, ECL_CONS_CAR(CLV0));
  if (ECL_SYMBOLP(v1x)) {
   goto L3;
  }
  goto L5;
L6:;
L5:;
  value0 = CONS(v1x,ECL_NIL);
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
#include "lsp/loop.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclz9aU79Gzoq3o9_tMnzL881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:LSP;LOOP.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclz9aU79Gzoq3o9_tMnzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defmacro(VV[402]);                      /*  LOOP-UNSAFE             */
  ecl_cmp_defmacro(VV[403]);                      /*  WITH-LOOP-LIST-COLLECTION-HEAD */
  ecl_cmp_defmacro(VV[404]);                      /*  LOOP-COLLECT-RPLACD     */
  ecl_cmp_defmacro(VV[405]);                      /*  LOOP-COLLECT-ANSWER     */
  si_define_structure(VV[19], _ecl_static_0, ECL_SYM("VECTOR",902), ECL_NIL, VVtemp[1], VVtemp[2], VV[20], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[3], ecl_make_int8_t(6), ECL_NIL, ECL_NIL, ECL_NIL);
  ecl_cmp_defun(VV[406]);                         /*  MAKE-LOOP-MINIMAX-INTERNAL */
  si_Xmake_special(VV[24]);
  T0 = VVtemp[4];
  ecl_cmp_setq(cl_env_copy,VV[24],T0);
  (void)0; /* No entry created for MAKE-LOOP-MINIMAX */
  (void)0; /* No entry created for LOOP-NOTE-MINIMAX-OPERATION */
  ecl_cmp_defmacro(VV[407]);                      /*  WITH-MINIMAX-VALUE      */
  ecl_cmp_defmacro(VV[408]);                      /*  LOOP-ACCUMULATE-MINIMAX-VALUE */
  (void)0; /* No entry created for LOOP-TEQUAL */
  (void)0; /* No entry created for LOOP-TASSOC */
  (void)0; /* No entry created for LOOP-TMEMBER */
  (void)0; /* No entry created for LOOP-LOOKUP-KEYWORD */
  ecl_cmp_defmacro(VV[409]);                      /*  LOOP-STORE-TABLE-DATA   */
  si_define_structure(VV[57], _ecl_static_1, ECL_SYM("VECTOR",902), ECL_NIL, VVtemp[5], VVtemp[6], VV[58], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[7], ecl_make_int8_t(8), ECL_NIL, ECL_NIL, ECL_NIL);
  ecl_cmp_defun(VV[410]);                         /*  MAKE-LOOP-UNIVERSE      */
  si_Xmake_special(VV[62]);
  (void)0; /* No entry created for MAKE-STANDARD-LOOP-UNIVERSE */
  si_Xmake_special(VV[73]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[73],T0);
  (void)0; /* No entry created for LOOP-MAKE-PSETQ */
  (void)0; /* No entry created for LOOP-MAKE-DESETQ */
  si_Xmake_special(VV[77]);
  T0 = cl_make_symbol(VVtemp[8]);
  ecl_cmp_setq(cl_env_copy,VV[77],T0);
  ecl_cmp_defmacro(VV[411]);                      /*  LOOP-REALLY-DESETQ      */
  si_Xmake_special(VV[84]);
  si_Xmake_special(VV[85]);
  si_Xmake_special(VV[86]);
  si_Xmake_special(VV[87]);
  si_Xmake_special(VV[27]);
  si_Xmake_special(VV[88]);
  si_Xmake_special(VV[89]);
  si_Xmake_special(VV[90]);
  si_Xmake_special(VV[91]);
  si_Xmake_special(VV[92]);
  si_Xmake_special(VV[93]);
  si_Xmake_special(VV[94]);
  si_Xmake_special(VV[95]);
  si_Xmake_special(VV[96]);
  si_Xmake_special(VV[97]);
  si_Xmake_special(VV[98]);
  si_Xmake_special(VV[99]);
  si_Xmake_special(VV[100]);
  si_Xmake_special(VV[101]);
  si_Xmake_special(VV[102]);
  si_Xmake_special(VV[103]);
  si_Xmake_special(VV[104]);
  si_Xmake_special(VV[105]);
  si_Xmake_special(VV[106]);
  si_Xmake_special(VV[107]);
  (void)0; /* No entry created for LOOP-CONSTANT-FOLD-IF-POSSIBLE */
  si_Xmake_special(VV[111]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[111],T0);
  si_Xmake_special(VV[112]);
  T0 = cl_make_symbol(VVtemp[9]);
  ecl_cmp_setq(cl_env_copy,VV[112],T0);
  ecl_cmp_defmacro(VV[412]);                      /*  LOOP-BODY               */
  (void)0; /* No entry created for LOOP-CONTEXT */
  (void)0; /* No entry created for LOOP-ERROR */
  (void)0; /* No entry created for LOOP-WARN */
  (void)0; /* No entry created for LOOP-CHECK-DATA-TYPE */
  ecl_cmp_defmacro(VV[413]);                      /*  LOOP-FINISH             */
  ecl_cmp_defun(VV[414]);                         /*  SUBST-GENSYMS-FOR-NIL   */
  ecl_cmp_defun(VV[415]);                         /*  LOOP-BUILD-DESTRUCTURING-BINDINGS */
  (void)0; /* No entry created for LOOP-TRANSLATE */
  (void)0; /* No entry created for LOOP-ITERATION-DRIVER */
  (void)0; /* No entry created for LOOP-POP-SOURCE */
  (void)0; /* No entry created for LOOP-GET-COMPOUND-FORM */
  (void)0; /* No entry created for LOOP-GET-PROGN */
  (void)0; /* No entry created for LOOP-GET-FORM */
  (void)0; /* No entry created for LOOP-CONSTRUCT-RETURN */
  (void)0; /* No entry created for LOOP-PSEUDO-BODY */
  (void)0; /* No entry created for LOOP-EMIT-BODY */
  (void)0; /* No entry created for LOOP-EMIT-FINAL-VALUE */
  (void)0; /* No entry created for LOOP-DISALLOW-CONDITIONAL */
  ecl_cmp_defun(VV[416]);                         /*  LOOP-DISALLOW-ANONYMOUS-COLLECTORS */
  ecl_cmp_defun(VV[417]);                         /*  LOOP-DISALLOW-AGGREGATE-BOOLEANS */
  (void)0; /* No entry created for LOOP-TYPED-INIT */
  (void)0; /* No entry created for LOOP-OPTIONAL-TYPE */
  (void)0; /* No entry created for LOOP-BIND-BLOCK */
  ecl_cmp_defun(VV[418]);                         /*  LOOP-VARIABLE-P         */
  (void)0; /* No entry created for LOOP-MAKE-VARIABLE */
  (void)0; /* No entry created for LOOP-MAKE-ITERATION-VARIABLE */
  (void)0; /* No entry created for LOOP-DECLARE-VARIABLE */
  (void)0; /* No entry created for LOOP-MAYBE-BIND-FORM */
  ecl_cmp_defun(VV[419]);                         /*  LOOP-DO-IF              */
  ecl_cmp_defun(VV[420]);                         /*  LOOP-DO-INITIALLY       */
  ecl_cmp_defun(VV[421]);                         /*  LOOP-DO-FINALLY         */
  ecl_cmp_defun(VV[422]);                         /*  LOOP-DO-DO              */
  ecl_cmp_defun(VV[423]);                         /*  LOOP-DO-NAMED           */
  ecl_cmp_defun(VV[424]);                         /*  LOOP-DO-RETURN          */
  si_define_structure(VV[217], _ecl_static_2, ECL_SYM("VECTOR",902), ECL_NIL, VVtemp[10], VVtemp[11], VV[218], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[12], ecl_make_int8_t(6), ECL_NIL, ECL_NIL, ECL_NIL);
  ecl_cmp_defun(VV[425]);                         /*  MAKE-LOOP-COLLECTOR     */
  (void)0; /* No entry created for LOOP-GET-COLLECTION-INFO */
  ecl_cmp_defun(VV[426]);                         /*  LOOP-LIST-COLLECTION    */
  ecl_cmp_defun(VV[427]);                         /*  LOOP-SUM-COLLECTION     */
  ecl_cmp_defun(VV[428]);                         /*  LOOP-MAXMIN-COLLECTION  */
  ecl_cmp_defun(VV[429]);                         /*  LOOP-DO-ALWAYS          */
  ecl_cmp_defun(VV[430]);                         /*  LOOP-DO-THEREIS         */
  ecl_cmp_defun(VV[431]);                         /*  LOOP-DO-WHILE           */
  ecl_cmp_defun(VV[432]);                         /*  LOOP-DO-WITH            */
  (void)0; /* No entry created for LOOP-HACK-ITERATION */
  ecl_cmp_defun(VV[433]);                         /*  LOOP-DO-FOR             */
  ecl_cmp_defun(VV[434]);                         /*  LOOP-DO-REPEAT          */
  (void)0; /* No entry created for LOOP-WHEN-IT-VARIABLE */
  ecl_cmp_defun(VV[435]);                         /*  LOOP-ANSI-FOR-EQUALS    */
  ecl_cmp_defun(VV[436]);                         /*  LOOP-FOR-ACROSS         */
  (void)0; /* No entry created for LOOP-LIST-STEP */
  ecl_cmp_defun(VV[437]);                         /*  LOOP-FOR-ON             */
  ecl_cmp_defun(VV[438]);                         /*  LOOP-FOR-IN             */
  si_define_structure(VV[290], _ecl_static_3, ECL_SYM("VECTOR",902), ECL_NIL, VVtemp[13], VVtemp[14], VV[291], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[15], ecl_make_int8_t(5), ECL_NIL, ECL_NIL, ECL_NIL);
  ecl_cmp_defun(VV[439]);                         /*  MAKE-LOOP-PATH          */
  (void)0; /* No entry created for ADD-LOOP-PATH */
  ecl_cmp_defun(VV[440]);                         /*  LOOP-FOR-BEING          */
  (void)0; /* No entry created for LOOP-NAMED-VAR */
  (void)0; /* No entry created for LOOP-COLLECT-PREPOSITIONAL-PHRASES */
  (void)0; /* No entry created for LOOP-SEQUENCER */
  ecl_cmp_defun(VV[441]);                         /*  LOOP-FOR-ARITHMETIC     */
  ecl_cmp_defun(VV[442]);                         /*  LOOP-HASH-TABLE-ITERATION-PATH */
  ecl_cmp_defun(VV[443]);                         /*  LOOP-PACKAGE-SYMBOLS-ITERATION-PATH */
  (void)0; /* No entry created for MAKE-ANSI-LOOP-UNIVERSE */
  si_Xmake_special(VV[398]);
  T0 = L510make_ansi_loop_universe(ECL_NIL);
  ecl_cmp_setq(cl_env_copy,VV[398],T0);
  (void)0; /* No entry created for LOOP-STANDARD-EXPANSION */
  ecl_cmp_defmacro(VV[444]);                      /*  LOOP                    */
 }
}
