/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmputil.lsp                     */
#include <ecl/ecl-cmp.h>
#include "cmp/cmputil.eclh"
/* function definition for BRIEF-NAMESTRING                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3008brief_namestring(cl_object v1path)
{
 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_wild_pathname_p(1, v1path))){
  goto L2;
 }
 cl_error(2, VV[1], v1path);
L2:;
 T0 = si_coerce_to_file_pathname(v1path);
 value0 = cl_enough_namestring(1, T0);
 return value0;
}
static cl_object L3008brief_namestring_va(cl_narg narg, cl_object v2path, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3008brief_namestring(v2path);
 }
}
/* function definition for NORMALIZE-BUILD-TARGET-NAME                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3009normalize_build_target_name(cl_object v1target)
{
 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 (!((v1target)==(VV[5]))){
  goto L7;
 }
 goto L4;
L7:;
 goto L5;
L5:;
 if (!((v1target)==(VV[6]))){
  goto L11;
 }
 goto L4;
L11:;
 goto L9;
L9:;
 if (!((v1target)==(VV[8]))){
  goto L15;
 }
 goto L4;
L15:;
 goto L13;
L13:;
 if (!((v1target)==(VV[10]))){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 value0 = VV[5];
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v1target)==(VV[13]))){
  goto L23;
 }
 goto L20;
L23:;
 goto L21;
L21:;
 if (!((v1target)==(VV[14]))){
  goto L27;
 }
 goto L20;
L27:;
 goto L25;
L25:;
 if (!((v1target)==(VV[16]))){
  goto L31;
 }
 goto L20;
L31:;
 goto L29;
L29:;
 if (!((v1target)==(VV[18]))){
  goto L18;
 }
 goto L19;
L20:;
L19:;
 value0 = VV[13];
 cl_env_copy->nvalues = 1;
 return value0;
L18:;
 if (!((v1target)==(VV[21]))){
  goto L39;
 }
 goto L36;
L39:;
 goto L37;
L37:;
 if (!((v1target)==(VV[22]))){
  goto L34;
 }
 goto L35;
L36:;
L35:;
 value0 = VV[21];
 cl_env_copy->nvalues = 1;
 return value0;
L34:;
 if (!((v1target)==(VV[24]))){
  goto L42;
 }
 value0 = VV[24];
 cl_env_copy->nvalues = 1;
 return value0;
L42:;
 value0 = si_ecase_error(v1target, VV[25]);
 return value0;
}
static cl_object L3009normalize_build_target_name_va(cl_narg narg, cl_object v2target, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[3]);
 {
  return L3009normalize_build_target_name(v2target);
 }
}
/* function definition for INNERMOST-NON-EXPANDED-FORM                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3010innermost_non_expanded_form(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);
L1:;
 if (!(ECL_LISTP(v1form))){
  goto L2;
 }
 {
  cl_object v2output;
  v2output = ECL_NIL;
  {
   cl_object v3;
   cl_object v4f;
   cl_object v5;
   {
    cl_object v6;
    v6 = v1form;
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v6;
   }
   v4f = ECL_NIL;
   v5 = v3;
L10:;
   if (!(ecl_endp(v5))){
    goto L12;
   }
   goto L11;
L12:;
   v4f = ECL_CONS_CAR(v5);
   {
    cl_object v6;
    v6 = ECL_CONS_CDR(v5);
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   if (!((v4f)==(ECL_SYM("MACROEXPAND",521)))){
    goto L21;
   }
   v2output = ECL_NIL;
   goto L20;
L21:;
   if (!(v2output==ECL_NIL)){
    goto L20;
   }
   v2output = v4f;
L20:;
   goto L10;
L11:;
   value0 = v2output;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3010innermost_non_expanded_form_va(cl_narg narg, cl_object v6form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[27]);
 {
  return L3010innermost_non_expanded_form(v6form);
 }
}
/* local function WITH-COMPILER-ENV                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3011with_compiler_env(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 v4;
  cl_object v5;
  cl_object v6compiler_conditions;
  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);
   v4 = v7;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v7;
   v7 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6compiler_conditions = v7;
  }
  if (Null(v5)){
   goto L16;
  }
  si_dm_too_many_arguments(v1);
L16:;
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[38]);
  T1 = cl_listX(3, ECL_SYM("WITH-COMPILATION-UNIT",911), ECL_NIL, v3);
  T2 = cl_list(3, ECL_SYM("LET*",480), T0, T1);
  T3 = cl_list(3, ECL_SYM("WITH-LOCK",1473), VV[37], T2);
  T4 = cl_list(3, ECL_SYM("HANDLER-BIND",419), VV[36], T3);
  T5 = cl_list(3, ECL_SYM("RESTART-CASE",725), T4, VV[39]);
  T6 = cl_list(3, ECL_SYM("SETF",753), v6compiler_conditions, VV[40]);
  value0 = cl_list(5, ECL_SYM("LET",479), VV[34], VV[35], T5, T6);
  return value0;
 }
}
static cl_object LC3011with_compiler_env_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[32]);
 {
  return LC3011with_compiler_env(v7, v8);
 }
}
/* function definition for SAFE-LIST-LENGTH                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L3012safe_list_length(cl_object v1l)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2slow;
  v2slow = v1l;
  {
   cl_object v3fast;
   v3fast = v1l;
   {
    cl_object v4flag;
    v4flag = ECL_T;
    {
     cl_fixnum v5l;
     v5l = (cl_fixnum)(0);
L6:;
     if (!(v3fast==ECL_NIL)){
      goto L9;
     }
     value0 = ecl_make_fixnum(v5l);
     cl_env_copy->nvalues = 1;
     return value0;
L9:;
     if (ECL_CONSP(v3fast)) {
      goto L11;
     }
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
L11:;
     if (Null(v4flag)){
      goto L13;
     }
     v4flag = ECL_NIL;
     v3fast = ECL_CONS_CDR(v3fast);
     goto L8;
L13:;
     if (!((v2slow)==(v3fast))){
      goto L18;
     }
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
L18:;
     v4flag = ECL_T;
     v2slow = ECL_CONS_CDR(v2slow);
     v3fast = ECL_CONS_CDR(v3fast);
L8:;
     v5l = (v5l)+1;
     goto L6;
     value0 = ecl_make_fixnum(v5l);
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
 }
}
static cl_object L3012safe_list_length_va(cl_narg narg, cl_object v6l, ...)
{
 return L3012safe_list_length(v6l);
}
/* function definition for CHECK-ARGS-NUMBER                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3013check_args_number(cl_narg narg, cl_object v1operator, cl_object v2args, ...)
{
 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[45]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[45]);
 {
  cl_object v3min;
  cl_object v4max;
  va_list args; va_start(args,v2args);
  {
   int i = 2;
   if (i >= narg) {
    v3min = ecl_make_int8_t(0);
   } else {
    i++;
    v3min = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v4max = ecl_make_fixnum(2305843009213693951);
   } else {
    i++;
    v4max = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v5l;
   v5l = L3012safe_list_length(v2args);
   if (!(v5l==ECL_NIL)){
    goto L4;
   }
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CIRCLE*",49),ECL_T); /*  *PRINT-CIRCLE* */
   (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[47], v1operator, v2args) /*  CMPERR */;
   ecl_bds_unwind1(cl_env_copy);
L4:;
   if (!(ecl_lower(v5l,v3min))){
    goto L6;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(3, v1operator, v3min, v5l) /*  TOO-FEW-ARGS */;
L6:;
   if (Null(v4max)){
    goto L8;
   }
   if (!(ecl_greater(v5l,v4max))){
    goto L8;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(3, v1operator, v4max, v5l) /*  TOO-MANY-ARGS */;
   return value0;
L8:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for PRINT-CURRENT-FORM                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3014print_current_form()
{
 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,ECL_SYM("*COMPILE-PRINT*",30)))){
  goto L2;
 }
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(2)); /*  *PRINT-LENGTH* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
 T0 = L3010innermost_non_expanded_form(ecl_cmp_symbol_value(cl_env_copy,VV[53]));
 cl_format(3, ECL_T, VV[52], T0);
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3014print_current_form_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[51]);
 {
  return L3014print_current_form();
 }
}
/* function definition for CMPPROGRESS                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3015cmpprogress(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 v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)))){
   goto L1;
  }
  T0 = (ECL_SYM("FORMAT",389)->symbol.gfdef);
  value0 = cl_apply(3, T0, ECL_T, v1args);
  return value0;
L1:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for CMP-EVAL                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3017cmp_eval(volatile cl_narg narg, cl_object volatile v1form, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[58]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[58]);
 {
  cl_object volatile v2env;
  va_list args; va_start(args,v1form);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ecl_cmp_symbol_value(cl_env_copy,VV[57]);
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   volatile cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(ECL_NIL,env1);
   CLV1 = env1 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env1); /*  TAGBODY        */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
    if (__ecl_frs_push_result!=0) {
    if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
     goto L2;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v3;
     v3 = ecl_make_cclosure_va((cl_objectfn)LC3016__lambda68,env1,Cblock,1);
     T0 = v3;
    }
    T1 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T0);
    T2 = ecl_list1(T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
    value0 = si_eval_with_env(5, v1form, v2env, ECL_NIL, ECL_T, ECL_SYM("EXECUTE",1262));
    ecl_frs_pop_n(cl_env_copy, 1);
    ecl_bds_unwind1(cl_env_copy);
    return value0;
L2:;
    {
     cl_object v3c;
     v3c = ECL_CONS_CAR(CLV0);
     if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[61]))){
      goto L7;
     }
     (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v3c) /*  INVOKE-DEBUGGER */;
L7:;
     (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[62], v1form, v3c) /*  CMPERR */;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     ecl_frs_pop_n(cl_env_copy, 1);
     return value0;
    }
    }
   }
  }
 }
}
/* function definition for CMP-EXPAND-MACRO                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3019cmp_expand_macro(volatile cl_narg narg, cl_object volatile v1fd, cl_object volatile v2form, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[64]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[64]);
 {
  cl_object volatile v3env;
  va_list args; va_start(args,v2form);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ecl_cmp_symbol_value(cl_env_copy,VV[57]);
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   volatile cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(ECL_NIL,env1);
   CLV1 = env1 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env1); /*  TAGBODY        */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
    if (__ecl_frs_push_result!=0) {
    if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
     goto L2;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v4;
     v4 = ecl_make_cclosure_va((cl_objectfn)LC3018__lambda74,env1,Cblock,1);
     T0 = v4;
    }
    T1 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T0);
    T2 = ecl_list1(T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
    {
     cl_object v4new_form;
     v4new_form = ecl_function_dispatch(cl_env_copy,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*MACROEXPAND-HOOK*",42)))(3, v1fd, v2form, v3env);
     {
      bool v5;
      v5 = ecl_eql(v4new_form,v2form);
      T0 = (v5)?ECL_NIL:ECL_T;
     }
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = T0;
     cl_env_copy->values[0] = v4new_form;
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     return cl_env_copy->values[0];
    }
L2:;
    {
     cl_object v4c;
     v4c = ECL_CONS_CAR(CLV0);
     if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[61]))){
      goto L9;
     }
     (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v4c) /*  INVOKE-DEBUGGER */;
L9:;
     (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[67], v2form, v4c) /*  CMPERR */;
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = ECL_NIL;
     cl_env_copy->values[0] = ECL_NIL;
     ecl_frs_pop_n(cl_env_copy, 1);
     return cl_env_copy->values[0];
    }
    }
   }
  }
 }
}
/* function definition for CMP-EXPAND-COMPILER-MACRO                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3021cmp_expand_compiler_macro(volatile cl_narg narg, cl_object volatile v1fd, cl_object volatile v2fname, cl_object volatile v3args, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<3)) FEwrong_num_arguments(VV[69]);
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(VV[69]);
 {
  cl_object volatile v4env;
  va_list args; va_start(args,v3args);
  {
   int i = 3;
   if (i >= narg) {
    v4env = ecl_cmp_symbol_value(cl_env_copy,VV[57]);
   } else {
    i++;
    v4env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   volatile cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(ECL_NIL,env1);
   CLV1 = env1 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env1); /*  TAGBODY        */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
    if (__ecl_frs_push_result!=0) {
    if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
     goto L2;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v5;
     v5 = ecl_make_cclosure_va((cl_objectfn)LC3020__lambda80,env1,Cblock,1);
     T0 = v5;
    }
    T1 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T0);
    T2 = ecl_list1(T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
    T0 = CONS(v2fname,v3args);
    value0 = L3019cmp_expand_macro(3, v1fd, T0, v4env);
    ecl_frs_pop_n(cl_env_copy, 1);
    ecl_bds_unwind1(cl_env_copy);
    return value0;
L2:;
    {
     cl_object v5c;
     v5c = ECL_CONS_CAR(CLV0);
     T0 = cl_list(2, v2fname, v5c);
     (cl_env_copy->function=ecl_fdefinition(VV[72]))->cfun.entry(5, VV[73], ECL_SYM("FORMAT-CONTROL",1272), VV[74], ECL_SYM("FORMAT-ARGUMENTS",1271), T0) /*  DO-CMPWARN */;
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = ECL_NIL;
     cl_env_copy->values[0] = ECL_NIL;
     ecl_frs_pop_n(cl_env_copy, 1);
     return cl_env_copy->values[0];
    }
    }
   }
  }
 }
}
/* function definition for LISP-TO-C-NAME                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3023lisp_to_c_name(cl_object v1obj)
{
 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 (Null(v1obj)){
  goto L3;
 }
 {
  cl_object v2;
  v2 = ecl_make_cfun_va((cl_objectfn)LC3022__lambda83_va,ECL_NIL,Cblock,1);
  T0 = v2;
 }
 T1 = cl_prin1_to_string(v1obj);
 T2 = cl_string_downcase(1, T1);
 value0 = cl_map(3, ECL_SYM("STRING",808), T0, T2);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3023lisp_to_c_name_va(cl_narg narg, cl_object v2obj, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[76]);
 {
  return L3023lisp_to_c_name(v2obj);
 }
}
/* function definition for COLLECT-LINES                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3024collect_lines(cl_object v1stream)
{
 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 v2line;
  v2line = ECL_NIL;
  {
   cl_object v3;
   cl_object v4;
   v3 = ecl_list1(ECL_NIL);
   v4 = v3;
L5:;
   v2line = cl_read_line(3, v1stream, ECL_NIL, ECL_NIL);
   if (v2line!=ECL_NIL) {
    goto L9;
   }
   goto L6;
L9:;
   {
    cl_object v5;
    v5 = v4;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v5;
   }
   v4 = ecl_list1(v2line);
   (ECL_CONS_CDR(T0)=v4,T0);
   goto L5;
L6:;
   value0 = ecl_cdr(v3);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L3024collect_lines_va(cl_narg narg, cl_object v5stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[79]);
 {
  return L3024collect_lines(v5stream);
 }
}
/* local function DEFINE-COMPILER-MACRO*                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3030define_compiler_macro_(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19;
 cl_object env0 = ECL_NIL;
 volatile struct ecl_cclosure aux_closure;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10, CLV11, CLV12, CLV13, CLV14, CLV15;
 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 v4lambda_list;
  cl_object env1 = env0;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L3;
  }
  si_dm_too_few_arguments(v1);
L3:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   T0 = v5;
  }
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(T0,env1);                    /*  NAME                    */
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4lambda_list = v5;
  }
  {
   cl_object v5output;
   cl_object env2 = env1;
   T0 = cl_gensym(1, _ecl_static_0);
   CLV1 = env2 = CONS(T0,env2);                   /*  GIVEN-KEYWORD           */
   T0 = cl_gensym(1, _ecl_static_1);
   CLV2 = env2 = CONS(T0,env2);                   /*  GIVEN-ARG               */
   T0 = cl_gensym(1, _ecl_static_2);
   CLV3 = env2 = CONS(T0,env2);                   /*  SOME-KEYWORD-FOUND      */
   v5output = cl_gensym(1, _ecl_static_3);
   T0 = cl_gensym(1, _ecl_static_4);
   CLV4 = env2 = CONS(T0,env2);                   /*  ALL-FOUND-KEYWORDS      */
   T0 = cl_gensym(1, _ecl_static_5);
   CLV5 = env2 = CONS(T0,env2);                   /*  BINDINGS-FOR-EXPANSION  */
   {
    cl_object v6aux_setf_forms;
    cl_object env3 = env2;
    T0 = cl_gensym(0);
    CLV6 = env3 = CONS(T0,env3);                  /*  WHOLE                   */
    T0 = cl_list(2, ECL_CONS_CAR(CLV6), ECL_SYM("&WHOLE",15));
    CLV7 = env3 = CONS(T0,env3);                  /*  NEW-LAMBDA-LIST         */
    v6aux_setf_forms = ECL_NIL;
    CLV8 = env3 = CONS(ECL_NIL,env3);             /*  PARSE-FORMS-PASS1       */
    CLV9 = env3 = CONS(ECL_NIL,env3);             /*  PARSE-FORMS-PASS2       */
    CLV10 = env3 = CONS(ECL_NIL,env3);            /*  PARSE-FORMS-PASS3       */
    CLV11 = env3 = CONS(ECL_NIL,env3);            /*  KEYWORD-PARSE-FORMS-PASS2 */
    T0 = cl_list(2, ECL_CONS_CAR(CLV4), ECL_CONS_CAR(CLV5));
    CLV12 = env3 = CONS(T0,env3);                 /*  BINDINGS-FOR-BODY       */
    T0 = ecl_car(v4lambda_list);
    if (!((T0)==(ECL_SYM("&WHOLE",15)))){
     goto L17;
    }
    T0 = ecl_cadr(v4lambda_list);
    T1 = cl_list(2, T0, ECL_CONS_CAR(CLV6));
    ECL_CONS_CAR(CLV12) = CONS(T1,ECL_CONS_CAR(CLV12));
    v4lambda_list = ecl_cddr(v4lambda_list);
L17:;
    {
     cl_object v7env;
     {
      cl_object v8;
      cl_object v9;
      v8 = ECL_SYM("&ENVIRONMENT",11);
      v9 = v4lambda_list;
      v7env = ecl_memql(v8,v9);
     }
     if (Null(v7env)){
      goto L22;
     }
     ECL_CONS_CAR(CLV7) = CONS(ECL_SYM("&ENVIRONMENT",11),ECL_CONS_CAR(CLV7));
     T0 = ecl_cadr(v7env);
     ECL_CONS_CAR(CLV7) = CONS(T0,ECL_CONS_CAR(CLV7));
     T0 = cl_ldiff(v4lambda_list, v7env);
     T1 = ecl_cddr(v7env);
     v4lambda_list = ecl_nconc(T0,T1);
    }
L22:;
    {
     cl_object v7;                                /*  REQS                    */
     cl_object v8;                                /*  OPTS                    */
     cl_object v9;                                /*  KEYWORDS                */
     cl_object v10;                               /*  AUXS                    */
     volatile cl_object env4 = env3;
     value0 = si_process_lambda_list(v4lambda_list, ECL_SYM("MACRO",1113));
     {
      const int v11 = cl_env_copy->nvalues;
      v7 = value0;
      cl_object v12;
      v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
      v8 = v12;
      v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2];
      CLV13 = env4 = CONS(v12,env4);              /*  REST                    */
      v12 = (v11<=3)? ECL_NIL : cl_env_copy->values[3];
      CLV14 = env4 = CONS(v12,env4);              /*  KEY-FLAG                */
      v12 = (v11<=4)? ECL_NIL : cl_env_copy->values[4];
      v9 = v12;
      v12 = (v11<=5)? ECL_NIL : cl_env_copy->values[5];
      CLV15 = env4 = CONS(v12,env4);              /*  ALLOW-OTHER-KEYS        */
      v12 = (v11<=6)? ECL_NIL : cl_env_copy->values[6];
      v10 = v12;
     }
     if (Null(ECL_CONS_CAR(CLV13))){
      goto L33;
     }
     if (ECL_CONS_CAR(CLV14)!=ECL_NIL) {
      goto L36;
     }
     if (Null(ECL_CONS_CAR(CLV15))){
      goto L33;
     }
     goto L34;
L36:;
L34:;
     cl_error(1, VV[85]);
L33:;
     {
      cl_object v11;
      v11 = ecl_make_cclosure_va((cl_objectfn)LC3027handle_required_parameter,env4,Cblock,1);
      {
       cl_object v12;
       cl_object v13;
       cl_object v14;
       {
        cl_object v15;
        v15 = ecl_cdr(v7);
        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;
L46:;
        if (!(ecl_endp(v14))){
         goto L48;
        }
        goto L47;
L48:;
        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 L46;
L47:;
        goto L38;
       }
      }
L38:;
      T0 = ecl_car(v8);
      if (!(ecl_greater(T0,ecl_make_int8_t(0)))){
       goto L64;
      }
      ECL_CONS_CAR(CLV7) = CONS(ECL_SYM("&OPTIONAL",13),ECL_CONS_CAR(CLV7));
      {
       cl_object v12o;
       v12o = ecl_cdr(v8);
L69:;
       if (!(ECL_ATOM(v12o))){
        goto L71;
       }
       goto L70;
L71:;
       (aux_closure.env=env4,cl_env_copy->function=(cl_object)&aux_closure,LC3028handle_optional_parameter(1, v12o));
       v12o = ecl_cdddr(v12o);
       goto L69;
L70:;
      }
L64:;
      if (Null(ECL_CONS_CAR(CLV13))){
       goto L77;
      }
      {
       cl_object v12_rest;
       v12_rest = LC3025prefix_symbol(ECL_CONS_CAR(CLV13));
       T0 = cl_list(2, v12_rest, VV[94]);
       ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
       T0 = cl_list(3, ECL_SYM("LIST",483), v12_rest, ECL_CONS_CAR(CLV13));
       T1 = cl_list(3, ECL_SYM("PUSH",680), T0, ECL_CONS_CAR(CLV5));
       ECL_CONS_CAR(CLV9) = CONS(T1,ECL_CONS_CAR(CLV9));
       ECL_CONS_CAR(CLV7) = CONS(ECL_SYM("&REST",14),ECL_CONS_CAR(CLV7));
       ECL_CONS_CAR(CLV7) = CONS(ECL_CONS_CAR(CLV13),ECL_CONS_CAR(CLV7));
      }
L77:;
      if (ECL_CONS_CAR(CLV14)!=ECL_NIL) {
       goto L89;
      }
      if (Null(ECL_CONS_CAR(CLV15))){
       goto L87;
      }
      goto L88;
L89:;
L88:;
      if (ECL_CONS_CAR(CLV13)!=ECL_NIL) {
       goto L91;
      }
      ECL_CONS_CAR(CLV13) = cl_gensym(0);
      ECL_CONS_CAR(CLV7) = CONS(ECL_SYM("&REST",14),ECL_CONS_CAR(CLV7));
      ECL_CONS_CAR(CLV7) = CONS(ECL_CONS_CAR(CLV13),ECL_CONS_CAR(CLV7));
L91:;
      {
       cl_object v12key_spec;
       v12key_spec = ecl_cdr(v9);
L100:;
       if (!(ECL_ATOM(v12key_spec))){
        goto L102;
       }
       goto L101;
L102:;
       (aux_closure.env=env4,cl_env_copy->function=(cl_object)&aux_closure,LC3029handle_keyword_parameter(1, v12key_spec));
       v12key_spec = ecl_cddddr(v12key_spec);
       goto L100;
L101:;
      }
      T0 = cl_list(2, ECL_SYM("NREVERSE",591), ECL_CONS_CAR(CLV4));
      T1 = cl_listX(7, ECL_SYM("LOOP",514), VV[89], ECL_CONS_CAR(CLV1), VV[90], T0, ECL_SYM("DO",309), ECL_CONS_CAR(CLV11));
      ECL_CONS_CAR(CLV9) = CONS(T1,ECL_CONS_CAR(CLV9));
L87:;
      {
       cl_object v12a;
       v12a = ecl_cdr(v10);
L111:;
       if (!(ECL_ATOM(v12a))){
        goto L113;
       }
       goto L112;
L113:;
       T0 = ecl_car(v12a);
       ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
       T0 = ecl_car(v12a);
       T1 = ecl_cadr(v12a);
       T2 = cl_list(3, ECL_SYM("SETF",753), T0, T1);
       v6aux_setf_forms = CONS(T2,v6aux_setf_forms);
       v12a = ecl_cddr(v12a);
       goto L111;
L112:;
      }
      T0 = cl_nreverse(ECL_CONS_CAR(CLV7));
      T1 = cl_nreverse(ECL_CONS_CAR(CLV12));
      T2 = (aux_closure.env=env4,cl_env_copy->function=(cl_object)&aux_closure,LC3026pass1_parse(0));
      T3 = CONS(ECL_SYM("LOCALLY",492),v3);
      T4 = cl_list(3, ECL_SYM("BLOCK",139), ECL_CONS_CAR(CLV0), T3);
      T5 = cl_list(2, v5output, T4);
      T6 = ecl_list1(T5);
      T7 = cl_list(3, ECL_SYM("EQ",335), v5output, ECL_CONS_CAR(CLV6));
      T8 = cl_nreverse(ECL_CONS_CAR(CLV9));
      T9 = cl_nreverse(ECL_CONS_CAR(CLV10));
      T10 = cl_list(2, ECL_SYM("NREVERSE",591), ECL_CONS_CAR(CLV5));
      T11 = cl_list(4, ECL_SYM("LIST",483), VV[98], T10, v5output);
      T12 = ecl_list1(T11);
      T13 = cl_append(3, T8, T9, T12);
      T14 = CONS(ECL_SYM("PROGN",674),T13);
      T15 = cl_list(4, ECL_SYM("IF",950), T7, ECL_CONS_CAR(CLV6), T14);
      T16 = cl_list(3, ECL_SYM("LET",479), T6, T15);
      T17 = ecl_list1(T16);
      T18 = ecl_append(v6aux_setf_forms,T17);
      T19 = cl_listX(4, ECL_SYM("LET*",480), T1, T2, T18);
      value0 = cl_list(4, ECL_SYM("DEFINE-COMPILER-MACRO",281), ECL_CONS_CAR(CLV0), T0, T19);
      return value0;
     }
    }
   }
  }
 }
}
static cl_object LC3030define_compiler_macro__va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[84]);
 {
  return LC3030define_compiler_macro_(v7, v8);
 }
}
/* function definition for EQUAL-WITH-CIRCULARITY                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3032equal_with_circularity(cl_object v1x, cl_object v2y)
{
 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 = LC3031equal_recursive(v1x, v2y, ECL_NIL, ECL_NIL, ECL_T, ecl_make_int8_t(0), ecl_make_int8_t(-1));
 return value0;
}
static cl_object L3032equal_with_circularity_va(cl_narg narg, cl_object v3x, cl_object v4y, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[100]);
 {
  return L3032equal_with_circularity(v3x, v4y);
 }
}
/* function definition for TYPE-SPECIFIER=                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3033type_specifier_(cl_object v1x, cl_object v2y)
{
 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 (!(ECL_CONSP(v1x))){
  goto L2;
 }
 if (!(ECL_CONSP(v2y))){
  goto L2;
 }
 {
  cl_object v3;
  v3 = ecl_car(v1x);
  if (!((v3)==(ECL_SYM("EQL",336)))){
   goto L12;
  }
  goto L9;
L12:;
  goto L10;
L10:;
  if (!((v3)==(ECL_SYM("MEMBER",554)))){
   goto L5;
  }
  goto L7;
L9:;
 }
L7:;
 {
  cl_object v3;
  v3 = ecl_car(v2y);
  if (!((v3)==(ECL_SYM("EQL",336)))){
   goto L19;
  }
  goto L16;
L19:;
  goto L17;
L17:;
  if (!((v3)==(ECL_SYM("MEMBER",554)))){
   goto L5;
  }
  goto L6;
L16:;
 }
L6:;
 {
  cl_fixnum v3;
  v3 = ecl_length(v1x);
  {
   cl_fixnum v4;
   v4 = ecl_length(v2y);
   if (!((v3)==(v4))){
    goto L23;
   }
  }
 }
 T0 = (ECL_SYM("EQL",336)->symbol.gfdef);
 value0 = cl_every(3, T0, v1x, v2y);
 return value0;
L23:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L5:;
 T0 = ecl_car(v1x);
 T1 = ecl_car(v2y);
 if (Null(L3033type_specifier_(T0, T1))){
  goto L27;
 }
 v1x = ecl_cdr(v1x);
 v2y = ecl_cdr(v2y);
 goto L1;
L27:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ecl_make_bool(ecl_eql(v1x,v2y));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3033type_specifier__va(cl_narg narg, cl_object v3x, cl_object v4y, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[104]);
 {
  return L3033type_specifier_(v3x, v4y);
 }
}
/* local function DEFUN-CACHED                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3034defun_cached(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4name;
  cl_object v5lambda_list;
  cl_object v6test;
  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);
   v4name = 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);
   v5lambda_list = 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);
   v6test = v7;
  }
  {
   cl_object v7cache_name;
   cl_object v8reset_name;
   cl_object v9hash_function;
   T0 = cl_string(v4name);
   T1 = cl_concatenate(4, ECL_SYM("STRING",808), VV[109], T0, VV[110]);
   T2 = cl_symbol_package(v4name);
   v7cache_name = cl_intern(2, T1, T2);
   T0 = cl_string(v4name);
   T1 = cl_concatenate(3, ECL_SYM("STRING",808), T0, VV[111]);
   T2 = cl_symbol_package(v4name);
   v8reset_name = cl_intern(2, T1, T2);
   {
    cl_object v10;
    v10 = v6test;
    if (!((v10)==(ECL_SYM("EQ",335)))){
     goto L25;
    }
    v9hash_function = VV[112];
    goto L23;
L25:;
    if (!((v10)==(ECL_SYM("EQL",336)))){
     goto L27;
    }
    v9hash_function = ECL_SYM("HASH-EQL",1738);
    goto L23;
L27:;
    if (!((v10)==(ECL_SYM("EQUAL",337)))){
     goto L34;
    }
    goto L31;
L34:;
    goto L32;
L32:;
    if (!((v10)==(VV[100]))){
     goto L38;
    }
    goto L31;
L38:;
    goto L36;
L36:;
    if (!((v10)==(VV[104]))){
     goto L29;
    }
    goto L30;
L31:;
L30:;
    v9hash_function = ECL_SYM("HASH-EQUAL",1739);
    goto L23;
L29:;
    v6test = ECL_SYM("EQUALP",338);
    v9hash_function = ECL_SYM("HASH-EQUALP",1740);
   }
L23:;
   T0 = cl_list(3, ECL_SYM("DEFVAR",292), v7cache_name, VV[116]);
   T1 = cl_list(3, ECL_SYM("SETF",753), v7cache_name, VV[116]);
   T2 = cl_list(4, ECL_SYM("DEFUN",291), v8reset_name, ECL_NIL, T1);
   T3 = cl_listX(3, v4name, v5lambda_list, v3);
   T4 = ecl_list1(T3);
   T5 = CONS(v9hash_function,v5lambda_list);
   T6 = cl_list(3, ECL_SYM("LOGAND",494), T5, ecl_make_fixnum(1023));
   T7 = cl_list(2, VV[117], T6);
   T8 = cl_list(2, VV[118], v7cache_name);
   T9 = cl_list(3, T7, T8, VV[119]);
   {
    cl_object v10;
    cl_object v11arg;
    cl_object v12;
    {
     cl_object v13;
     v13 = v5lambda_list;
     if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v10 = v13;
    }
    v11arg = ECL_NIL;
    v12 = v10;
    {
     cl_object v13;
     cl_object v14;
     v13 = ecl_list1(ECL_NIL);
     v14 = v13;
L51:;
     if (!(ecl_endp(v12))){
      goto L53;
     }
     goto L52;
L53:;
     v11arg = 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;
      T11 = v15;
     }
     T12 = cl_list(3, v6test, VV[121], v11arg);
     v14 = ecl_list1(T12);
     (ECL_CONS_CDR(T11)=v14,T11);
     goto L51;
L52:;
     T10 = ecl_cdr(v13);
     goto L43;
    }
   }
L43:;
   T11 = cl_listX(3, ECL_SYM("AND",89), ECL_SYM("ELT",329), T10);
   T12 = CONS(v4name,v5lambda_list);
   T13 = cl_list(2, VV[123], T12);
   T14 = ecl_list1(T13);
   T15 = cl_list(3, ECL_SYM("AREF",94), v7cache_name, VV[117]);
   T16 = ecl_append(v5lambda_list,VV[124]);
   T17 = CONS(ECL_SYM("LIST",483),T16);
   T18 = cl_list(3, ECL_SYM("SETF",753), T15, T17);
   T19 = cl_list(4, ECL_SYM("LET",479), T14, T18, VV[123]);
   T20 = cl_list(4, ECL_SYM("IF",950), T11, VV[122], T19);
   T21 = cl_list(4, ECL_SYM("LET*",480), T9, VV[120], T20);
   T22 = cl_list(3, ECL_SYM("FLET",375), T4, T21);
   T23 = cl_list(4, ECL_SYM("DEFUN",291), v4name, v5lambda_list, T22);
   value0 = cl_list(4, ECL_SYM("PROGN",674), T0, T2, T23);
   return value0;
  }
 }
}
static cl_object LC3034defun_cached_va(cl_narg narg, cl_object v10, cl_object v11, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[108]);
 {
  return LC3034defun_cached(v10, v11);
 }
}
/* function definition for SAME-FNAME-P                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3035same_fname_p(cl_object v1name1, cl_object v2name2)
{
 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_make_bool(ecl_equal(v1name1,v2name2));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3035same_fname_p_va(cl_narg narg, cl_object v3name1, cl_object v4name2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[126]);
 {
  return L3035same_fname_p(v3name1, v4name2);
 }
}
/* function definition for EMPTYP                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3036emptyp(cl_object v1item)
{
 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_LISTP(v1item))){
  goto L2;
 }
 value0 = ecl_make_bool(v1item==ECL_NIL);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_VECTORP(v1item))){
  goto L4;
 }
 {
  cl_fixnum v2;
  v2 = ecl_length(v1item);
  value0 = ecl_make_bool((v2)==0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
L4:;
 if (Null(cl_hash_table_p(v1item))){
  goto L6;
 }
 T0 = cl_hash_table_count(v1item);
 value0 = ecl_make_bool((ecl_fixnum(T0))==0);
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 value0 = si_etypecase_error(v1item, VV[129]);
 return value0;
}
static cl_object L3036emptyp_va(cl_narg narg, cl_object v2item, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[128]);
 {
  return L3036emptyp(v2item);
 }
}
/* function definition for CMP-TYPEP                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3037cmp_typep(cl_object v1obj, cl_object v2type)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(VV[132]->symbol.gfdef))->cfun.entry(2, v2type, ecl_cmp_symbol_value(cl_env_copy,VV[57])) /*  FLATTEN-FUNCTION-TYPES */;
 value0 = cl_typep(3, v1obj, T0, ecl_cmp_symbol_value(cl_env_copy,VV[57]));
 return value0;
}
static cl_object L3037cmp_typep_va(cl_narg narg, cl_object v3obj, cl_object v4type, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[131]);
 {
  return L3037cmp_typep(v3obj, v4type);
 }
}
/* function definition for READ-TARGET-INFO                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3038read_target_info(cl_object volatile v1filename)
{
 cl_object T0, T1;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (cl_pathname_name(1, v1filename)!=ECL_NIL) {
  goto L2;
 }
 {
  cl_object v2path1;
  cl_object v3path2;
  cl_object v4files_found;
  v2path1 = cl_merge_pathnames(2, VV[135], v1filename);
  v3path2 = cl_merge_pathnames(2, VV[136], v1filename);
  T0 = cl_directory(1, v2path1);
  T1 = cl_directory(1, v3path2);
  v4files_found = ecl_nconc(T0,T1);
  if (!(v4files_found==ECL_NIL)){
   goto L7;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[137], v2path1, v3path2) /*  CMPERR */;
L7:;
  v1filename = ecl_car(v4files_found);
 }
L2:;
 {
  volatile cl_object v2s;
  v2s = cl_open(1, v1filename);
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   volatile bool unwinding = FALSE;
   ecl_frame_ptr next_fr;
   {
    ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG);
    if (__ecl_frs_push_result!=0) {
      unwinding = TRUE; next_fr=cl_env_copy->frs_stack.nlj_fr;
    } else {
    {
     struct ecl_stack_frame _ecl_inner_frame_aux;
     volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
     {
      cl_object v3;
      v3 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
      {
       cl_object v5, v6; cl_index v4;
       v5 = ECL_CONS_CAR(v3);
       v6 = ECL_CONS_CDR(v3);
       v4 = ecl_progv(cl_env_copy, v5, v6);
       cl_env_copy->values[0] = cl_read(1, v2s);
       ecl_bds_unwind(cl_env_copy,v4);
      }
     }
     ecl_stack_frame_push_values(_ecl_inner_frame);
     if (Null(v2s)){
      goto L16;
     }
     cl_close(1, v2s);
L16:;
     ecl_stack_frame_pop_values(_ecl_inner_frame);
     ecl_stack_frame_close(_ecl_inner_frame);
    }
    }
   }
   ecl_frs_pop(cl_env_copy);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   if (Null(v2s)){
    goto L18;
   }
   cl_close(3, v2s, ECL_SYM("ABORT",1225), ECL_T);
L18:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   if (unwinding) ecl_unwind(cl_env_copy,next_fr);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L3038read_target_info_va(cl_narg narg, cl_object v3filename, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[134]);
 {
  return L3038read_target_info(v3filename);
 }
}
/* function definition for GET-TARGET-INFO                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3040get_target_info()
{
 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 v2;
   v2 = ecl_make_cfun_va((cl_objectfn)LC3039__lambda397_va,ECL_NIL,Cblock,1);
   v1 = v2;
  }
  {
   cl_object v2;
   cl_object v3;
   cl_object v4;
   {
    cl_object v5;
    v5 = ecl_cmp_symbol_value(cl_env_copy,VV[141]);
    if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v2 = v5;
   }
   v3 = ECL_NIL;
   v4 = v2;
   {
    cl_object v5;
    cl_object v6;
    v5 = ecl_list1(ECL_NIL);
    v6 = v5;
L10:;
    if (!(ecl_endp(v4))){
     goto L12;
    }
    goto L11;
L12:;
    v3 = ECL_CONS_CAR(v4);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v4);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    {
     cl_object v7;
     v7 = v6;
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v7;
    }
    T1 = ecl_function_dispatch(cl_env_copy,v1)(1, v3);
    v6 = ecl_list1(T1);
    (ECL_CONS_CDR(T0)=v6,T0);
    goto L10;
L11:;
    value0 = ecl_cdr(v5);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L3040get_target_info_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[139]);
 {
  return L3040get_target_info();
 }
}
/* function definition for WRITE-TARGET-INFO                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3041write_target_info(cl_object volatile v1filename)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2s;
  v2s = cl_open(7, v1filename, ECL_SYM("DIRECTION",1249), ECL_SYM("OUTPUT",1319), ECL_SYM("IF-EXISTS",1279), ECL_SYM("SUPERSEDE",1351), ECL_SYM("IF-DOES-NOT-EXIST",1277), ECL_SYM("CREATE",1244));
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   volatile bool unwinding = FALSE;
   ecl_frame_ptr next_fr;
   {
    ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG);
    if (__ecl_frs_push_result!=0) {
      unwinding = TRUE; next_fr=cl_env_copy->frs_stack.nlj_fr;
    } else {
    {
     struct ecl_stack_frame _ecl_inner_frame_aux;
     volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
     {
      cl_object v3;
      v3 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
      {
       cl_object v5, v6; cl_index v4;
       v5 = ECL_CONS_CAR(v3);
       v6 = ECL_CONS_CDR(v3);
       v4 = ecl_progv(cl_env_copy, v5, v6);
       ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CIRCLE*",49),ECL_T); /*  *PRINT-CIRCLE* */
       T0 = L3040get_target_info();
       cl_env_copy->values[0] = cl_format(3, v2s, VV[144], T0);
       ecl_bds_unwind(cl_env_copy,v4);
      }
     }
     ecl_stack_frame_push_values(_ecl_inner_frame);
     if (Null(v2s)){
      goto L8;
     }
     cl_close(1, v2s);
L8:;
     ecl_stack_frame_pop_values(_ecl_inner_frame);
     ecl_stack_frame_close(_ecl_inner_frame);
    }
    }
   }
   ecl_frs_pop(cl_env_copy);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   if (Null(v2s)){
    goto L10;
   }
   cl_close(3, v2s, ECL_SYM("ABORT",1225), ECL_T);
L10:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   if (unwinding) ecl_unwind(cl_env_copy,next_fr);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L3041write_target_info_va(cl_narg narg, cl_object v3filename, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[143]);
 {
  return L3041write_target_info(v3filename);
 }
}
/* closure LAMBDA68                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3016__lambda68(cl_narg narg, cl_object v1si__temp, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[60]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA74                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3018__lambda74(cl_narg narg, cl_object v1si__temp, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[66]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA80                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3020__lambda80(cl_narg narg, cl_object v1si__temp, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[71]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA83                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3022__lambda83(cl_object v1c)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2cc;
  v2cc = cl_char_code(v1c);
  if ((((cl_fixnum)(97))<=(ecl_fixnum(v2cc)) && (ecl_fixnum(v2cc))<=((cl_fixnum)(122)))) {
   goto L5;
  }
  if (!((((cl_fixnum)(48))<=(ecl_fixnum(v2cc)) && (ecl_fixnum(v2cc))<=((cl_fixnum)(57))))){
   goto L3;
  }
  goto L4;
L5:;
L4:;
  value0 = v1c;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_CODE_CHAR(95);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3022__lambda83_va(cl_narg narg, cl_object v3c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[77]);
 {
  return LC3022__lambda83(v3c);
 }
}
/* closure HANDLE-KEYWORD-PARAMETER                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3029handle_keyword_parameter(cl_narg narg, cl_object v1key_spec, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10, CLV11, CLV12, CLV13, CLV14, CLV15;
 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 ... */
 CLV15 = env0;
 CLV14 = _ecl_cdr(CLV15);
 CLV13 = _ecl_cdr(CLV14);
 CLV12 = _ecl_cdr(CLV13);                         /*  BINDINGS-FOR-BODY       */
 CLV11 = _ecl_cdr(CLV12);
 CLV10 = _ecl_cdr(CLV11);
 CLV9 = _ecl_cdr(CLV10);
 CLV8 = _ecl_cdr(CLV9);
 CLV7 = _ecl_cdr(CLV8);
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[97]);
 {
L1:;
  {
   cl_object v2keyword;
   cl_object v3symbol;
   cl_object v4init;
   cl_object v5supplied_p;
   cl_object v6_symbol;
   v2keyword = ecl_car(v1key_spec);
   v3symbol = ecl_cadr(v1key_spec);
   v4init = ecl_caddr(v1key_spec);
   value0 = ecl_cadddr(v1key_spec);
   if (value0!=ECL_NIL) {
    goto L7;
   }
   v5supplied_p = cl_gensym(0);
   goto L5;
L7:;
   v5supplied_p = value0;
   goto L5;
L5:;
   v6_symbol = LC3025prefix_symbol(v3symbol);
   T0 = cl_list(2, v6_symbol, VV[94]);
   ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
   T0 = cl_list(2, v3symbol, v4init);
   ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
   T0 = cl_list(2, v5supplied_p, ECL_NIL);
   ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
   T0 = cl_list(3, ECL_SYM("EQ",335), ECL_CONS_CAR(CLV1), v2keyword);
   T1 = cl_list(2, ECL_SYM("NOT",586), v5supplied_p);
   T2 = cl_list(3, ECL_SYM("AND",89), T0, T1);
   T3 = cl_list(3, ECL_SYM("SETF",753), ECL_CONS_CAR(CLV3), ECL_T);
   T4 = cl_list(3, ECL_SYM("SETF",753), v3symbol, ECL_CONS_CAR(CLV2));
   T5 = cl_list(3, ECL_SYM("SETF",753), v5supplied_p, ECL_T);
   T6 = cl_list(3, ECL_SYM("PUSH",680), v2keyword, ECL_CONS_CAR(CLV4));
   T7 = cl_list(6, ECL_SYM("WHEN",909), T2, T3, T4, T5, T6);
   ECL_CONS_CAR(CLV8) = CONS(T7,ECL_CONS_CAR(CLV8));
   T0 = cl_list(3, ECL_SYM("EQ",335), ECL_CONS_CAR(CLV1), v2keyword);
   T1 = cl_list(3, ECL_SYM("LIST",483), v6_symbol, v3symbol);
   T2 = cl_list(3, ECL_SYM("PUSH",680), T1, ECL_CONS_CAR(CLV5));
   T3 = cl_list(3, ECL_SYM("WHEN",909), T0, T2);
   ECL_CONS_CAR(CLV11) = CONS(T3,ECL_CONS_CAR(CLV11));
   T0 = cl_list(3, ECL_SYM("LIST",483), v6_symbol, v3symbol);
   T1 = cl_list(3, ECL_SYM("PUSH",680), T0, ECL_CONS_CAR(CLV5));
   T2 = cl_list(3, ECL_SYM("UNLESS",886), v5supplied_p, T1);
   ECL_CONS_CAR(CLV10) = CONS(T2,ECL_CONS_CAR(CLV10));
   value0 = ECL_CONS_CAR(CLV10);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* closure HANDLE-OPTIONAL-PARAMETER                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3028handle_optional_parameter(cl_narg narg, cl_object v1opt_spec, ...)
{
 cl_object T0, T1, T2;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10, CLV11, CLV12, CLV13, CLV14, CLV15;
 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 ... */
 CLV15 = env0;
 CLV14 = _ecl_cdr(CLV15);
 CLV13 = _ecl_cdr(CLV14);
 CLV12 = _ecl_cdr(CLV13);                         /*  BINDINGS-FOR-BODY       */
 CLV11 = _ecl_cdr(CLV12);
 CLV10 = _ecl_cdr(CLV11);
 CLV9 = _ecl_cdr(CLV10);
 CLV8 = _ecl_cdr(CLV9);
 CLV7 = _ecl_cdr(CLV8);
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[96]);
 {
L1:;
  {
   cl_object v2symbol;
   cl_object v3init;
   cl_object v4supplied_p;
   cl_object v5_symbol;
   v2symbol = ecl_car(v1opt_spec);
   v3init = ecl_cadr(v1opt_spec);
   value0 = ecl_caddr(v1opt_spec);
   if (value0!=ECL_NIL) {
    goto L6;
   }
   v4supplied_p = cl_gensym(0);
   goto L4;
L6:;
   v4supplied_p = value0;
   goto L4;
L4:;
   v5_symbol = LC3025prefix_symbol(v2symbol);
   T0 = cl_list(2, v5_symbol, VV[94]);
   ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
   T0 = cl_list(3, v2symbol, v3init, v4supplied_p);
   ECL_CONS_CAR(CLV7) = CONS(T0,ECL_CONS_CAR(CLV7));
   T0 = cl_list(3, ECL_SYM("LIST",483), v5_symbol, v2symbol);
   T1 = cl_list(3, ECL_SYM("PUSH",680), T0, ECL_CONS_CAR(CLV5));
   T2 = cl_list(3, ECL_SYM("WHEN",909), v4supplied_p, T1);
   ECL_CONS_CAR(CLV9) = CONS(T2,ECL_CONS_CAR(CLV9));
   T0 = cl_list(3, ECL_SYM("LIST",483), v5_symbol, v2symbol);
   T1 = cl_list(3, ECL_SYM("PUSH",680), T0, ECL_CONS_CAR(CLV5));
   T2 = cl_list(3, ECL_SYM("UNLESS",886), v4supplied_p, T1);
   ECL_CONS_CAR(CLV10) = CONS(T2,ECL_CONS_CAR(CLV10));
   value0 = ECL_CONS_CAR(CLV10);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* closure HANDLE-REQUIRED-PARAMETER                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3027handle_required_parameter(cl_narg narg, cl_object v1symbol, ...)
{
 cl_object T0, T1;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10, CLV11, CLV12, CLV13, CLV14, CLV15;
 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 ... */
 CLV15 = env0;
 CLV14 = _ecl_cdr(CLV15);
 CLV13 = _ecl_cdr(CLV14);
 CLV12 = _ecl_cdr(CLV13);                         /*  BINDINGS-FOR-BODY       */
 CLV11 = _ecl_cdr(CLV12);
 CLV10 = _ecl_cdr(CLV11);
 CLV9 = _ecl_cdr(CLV10);
 CLV8 = _ecl_cdr(CLV9);
 CLV7 = _ecl_cdr(CLV8);
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[95]);
 {
L1:;
  {
   cl_object v2_symbol;
   v2_symbol = LC3025prefix_symbol(v1symbol);
   T0 = cl_list(2, v2_symbol, VV[94]);
   ECL_CONS_CAR(CLV12) = CONS(T0,ECL_CONS_CAR(CLV12));
   ECL_CONS_CAR(CLV7) = CONS(v1symbol,ECL_CONS_CAR(CLV7));
   T0 = cl_list(3, ECL_SYM("LIST",483), v2_symbol, v1symbol);
   T1 = cl_list(3, ECL_SYM("PUSH",680), T0, ECL_CONS_CAR(CLV5));
   ECL_CONS_CAR(CLV9) = CONS(T1,ECL_CONS_CAR(CLV9));
   value0 = ECL_CONS_CAR(CLV9);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* closure PASS1-PARSE                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3026pass1_parse(cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10, CLV11, CLV12, CLV13, CLV14, CLV15;
 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 ... */
 CLV15 = env0;                                    /*  ALLOW-OTHER-KEYS        */
 CLV14 = _ecl_cdr(CLV15);
 CLV13 = _ecl_cdr(CLV14);
 CLV12 = _ecl_cdr(CLV13);
 CLV11 = _ecl_cdr(CLV12);
 CLV10 = _ecl_cdr(CLV11);
 CLV9 = _ecl_cdr(CLV10);
 CLV8 = _ecl_cdr(CLV9);
 CLV7 = _ecl_cdr(CLV8);
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[88]);
 {
L1:;
  if (Null(ECL_CONS_CAR(CLV14))){
   goto L2;
  }
  T0 = cl_list(2, ECL_SYM("LENGTH",478), ECL_CONS_CAR(CLV13));
  T1 = cl_list(3, ECL_SYM("MOD",562), T0, ecl_make_int8_t(2));
  T2 = cl_list(2, ECL_SYM("ZEROP",930), T1);
  T3 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV6));
  T4 = cl_list(3, ECL_SYM("UNLESS",886), T2, T3);
  T5 = cl_list(2, ECL_SYM("REST",722), ECL_CONS_CAR(CLV13));
  T6 = cl_list(2, ECL_SYM("KEYWORDP",452), ECL_CONS_CAR(CLV1));
  T7 = cl_list(2, ECL_SYM("NOT",586), T6);
  T8 = cl_list(3, ECL_SYM("EQ",335), ECL_CONS_CAR(CLV1), ECL_SYM("ALLOW-OTHER-KEYS",1227));
  T9 = cl_list(3, ECL_SYM("OR",616), T7, T8);
  T10 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV6));
  T11 = cl_list(3, ECL_SYM("WHEN",909), T9, T10);
  T12 = ECL_CONS_CAR(CLV8);
  T13 = cl_list(2, ECL_SYM("NOT",586), ECL_CONS_CAR(CLV3));
  T14 = cl_list(4, ECL_SYM("LIST",483), VV[93], VV[94], ECL_CONS_CAR(CLV2));
  T15 = cl_list(3, ECL_SYM("PUSH",680), T14, ECL_CONS_CAR(CLV5));
  T16 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV6));
  T17 = cl_list(4, ECL_SYM("IF",950), ECL_CONS_CAR(CLV15), T15, T16);
  T18 = cl_list(3, ECL_SYM("WHEN",909), T13, T17);
  T19 = ecl_list1(T18);
  T20 = ecl_append(T12,T19);
  T21 = cl_listX(20, ECL_SYM("LOOP",514), VV[89], ECL_CONS_CAR(CLV1), VV[90], ECL_CONS_CAR(CLV13), VV[91], VV[92], VV[89], ECL_CONS_CAR(CLV2), VV[90], T5, VV[91], VV[92], VV[89], ECL_CONS_CAR(CLV3), ECL_SYM("=",76), ECL_NIL, ECL_SYM("DO",309), T11, T20);
  value0 = cl_list(3, ECL_SYM("PROGN",674), T4, T21);
  return value0;
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function PREFIX-SYMBOL                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3025prefix_symbol(cl_object v1s)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_symbol_name(v1s);
 T1 = cl_concatenate(3, ECL_SYM("STRING",808), VV[87], T0);
 value0 = cl_intern(1, T1);
 return value0;
}
static cl_object LC3025prefix_symbol_va(cl_narg narg, cl_object v2s, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[86]);
 {
  return LC3025prefix_symbol(v2s);
 }
}
/* local function EQUAL-RECURSIVE                                             */
/* optimize speed 1, debug 1, space 1, safety 0                               */
static cl_object LC3031equal_recursive(cl_object v1x, cl_object v2y, cl_object v3x0, cl_object v4y0, cl_object v5switch, cl_object v6path_spec, cl_object v7n)
{
 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);
 cl_fixnum v8n;
 v8n = ecl_fixnum(v7n);
L1:;
 if (!(ECL_CONSP(v1x))){
  goto L4;
 }
 if (ECL_CONSP(v2y)) {
  goto L2;
 }
 goto L3;
L4:;
L3:;
 value0 = ecl_make_bool(ecl_equal(v1x,v2y));
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v1x)==(v2y))){
  goto L6;
 }
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (!((v1x)==(v3x0))){
  goto L8;
 }
 if (!((v2y)==(v4y0))){
  goto L8;
 }
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L8:;
 if ((v1x)==(v3x0)) {
  goto L13;
 }
 if (!((v2y)==(v4y0))){
  goto L11;
 }
 goto L12;
L13:;
L12:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L11:;
 if (!((v8n)==((cl_fixnum)(-1)))){
  goto L15;
 }
 T0 = _ecl_car(v1x);
 T1 = _ecl_car(v2y);
 if (Null(LC3031equal_recursive(T0, T1, v1x, v2y, ECL_NIL, ecl_make_int8_t(1), ecl_make_int8_t(0)))){
  goto L18;
 }
 T0 = _ecl_cdr(v1x);
 T1 = _ecl_cdr(v2y);
 v3x0 = v1x;
 v4y0 = v2y;
 v5switch = ECL_NIL;
 v6path_spec = ecl_make_int8_t(0);
 v8n = (cl_fixnum)(0);
 v2y = T1;
 v1x = T0;
 goto L1;
L18:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L15:;
 if (Null(v5switch)){
  goto L28;
 }
 {
  cl_object v9mask;
  cl_object v10x0;
  cl_object v11y0;
  v9mask = cl_ash(ecl_make_int8_t(1), ecl_make_fixnum(v8n));
  T0 = ecl_boole(ECL_BOOLAND,(v6path_spec),(v9mask));
  if (!(ecl_zerop(T0))){
   goto L32;
  }
  v10x0 = _ecl_cdr(v3x0);
  goto L31;
L32:;
  v10x0 = _ecl_car(v3x0);
L31:;
  T0 = ecl_boole(ECL_BOOLAND,(v6path_spec),(v9mask));
  if (!(ecl_zerop(T0))){
   goto L35;
  }
  v11y0 = _ecl_cdr(v4y0);
  goto L34;
L35:;
  v11y0 = _ecl_car(v4y0);
L34:;
  T0 = _ecl_car(v1x);
  T1 = _ecl_car(v2y);
  T2 = ecl_boole(ECL_BOOLANDC2,(v6path_spec),(v9mask));
  T3 = ecl_ash(T2,(cl_fixnum)(1));
  T4 = ecl_boole(ECL_BOOLIOR,(T3),(ecl_make_int8_t(1)));
  if (Null(LC3031equal_recursive(T0, T1, v10x0, v11y0, ECL_NIL, T4, ecl_make_fixnum(v8n)))){
   goto L38;
  }
  v1x = _ecl_cdr(v1x);
  v2y = _ecl_cdr(v2y);
  v3x0 = v10x0;
  v4y0 = v11y0;
  v5switch = ECL_NIL;
  T0 = ecl_boole(ECL_BOOLANDC2,(v6path_spec),(v9mask));
  v6path_spec = ecl_ash(T0,(cl_fixnum)(1));
  goto L1;
L38:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L28:;
 T0 = _ecl_car(v1x);
 T1 = _ecl_car(v2y);
 T2 = ecl_ash(v6path_spec,(cl_fixnum)(1));
 T3 = ecl_boole(ECL_BOOLIOR,(T2),(ecl_make_int8_t(1)));
 {
  cl_fixnum v12;
  v12 = (v8n)+1;
  if (Null(LC3031equal_recursive(T0, T1, v3x0, v4y0, ECL_T, T3, ecl_make_fixnum(v12)))){
   goto L49;
  }
 }
 v1x = _ecl_cdr(v1x);
 v2y = _ecl_cdr(v2y);
 v5switch = ECL_T;
 v6path_spec = ecl_ash(v6path_spec,(cl_fixnum)(1));
 v8n = (v8n)+1;
 goto L1;
L49:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3031equal_recursive_va(cl_narg narg, cl_object v12x, cl_object v13y, cl_object v14x0, cl_object v15y0, cl_object v16switch, cl_object v17path_spec, cl_object v18n, ...)
{
 return LC3031equal_recursive(v12x, v13y, v14x0, v15y0, v16switch, v17path_spec, v18n);
}
/* local function LAMBDA397                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3039__lambda397(cl_object v1option)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_symbol_value(v1option);
 value0 = CONS(v1option,T0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3039__lambda397_va(cl_narg narg, cl_object v2option, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[140]);
 {
  return LC3039__lambda397(v2option);
 }
}
#include "cmp/cmputil.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclvN1x8aNAbT3p9_VAM0M881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:CMP;CMPUTIL.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclvN1x8aNAbT3p9_VAM0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[146]);                         /*  BRIEF-NAMESTRING        */
  ecl_cmp_defun(VV[147]);                         /*  NORMALIZE-BUILD-TARGET-NAME */
  ecl_cmp_defun(VV[148]);                         /*  INNERMOST-NON-EXPANDED-FORM */
  ecl_cmp_defmacro(VV[149]);                      /*  WITH-COMPILER-ENV       */
  ecl_cmp_defun(VV[150]);                         /*  SAFE-LIST-LENGTH        */
  ecl_cmp_defun(VV[151]);                         /*  CHECK-ARGS-NUMBER       */
  ecl_cmp_defun(VV[152]);                         /*  PRINT-CURRENT-FORM      */
  ecl_cmp_defun(VV[153]);                         /*  CMPPROGRESS             */
  ecl_cmp_defun(VV[154]);                         /*  CMP-EVAL                */
  ecl_cmp_defun(VV[155]);                         /*  CMP-EXPAND-MACRO        */
  ecl_cmp_defun(VV[156]);                         /*  CMP-EXPAND-COMPILER-MACRO */
  ecl_cmp_defun(VV[157]);                         /*  LISP-TO-C-NAME          */
  ecl_cmp_defun(VV[158]);                         /*  COLLECT-LINES           */
  ecl_cmp_defmacro(VV[159]);                      /*  DEFINE-COMPILER-MACRO*  */
  ecl_cmp_defun(VV[160]);                         /*  EQUAL-WITH-CIRCULARITY  */
  ecl_cmp_defun(VV[161]);                         /*  TYPE-SPECIFIER=         */
  ecl_cmp_defmacro(VV[162]);                      /*  DEFUN-CACHED            */
  ecl_cmp_defun(VV[163]);                         /*  SAME-FNAME-P            */
  ecl_cmp_defun(VV[164]);                         /*  EMPTYP                  */
  ecl_cmp_defun(VV[165]);                         /*  CMP-TYPEP               */
  ecl_cmp_defun(VV[166]);                         /*  READ-TARGET-INFO        */
  ecl_cmp_defun(VV[167]);                         /*  GET-TARGET-INFO         */
  ecl_cmp_defun(VV[168]);                         /*  WRITE-TARGET-INFO       */
}
