/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpmain.lsp                     */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpmain.eclh"
/* function definition for COMPILE-FILE-PATHNAME                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4130compile_file_pathname(cl_narg narg, cl_object v1name, ...)
{
 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[35]);
 {
  cl_object v2output_file;
  cl_object v3type;
  cl_object v4type_supplied_p;
  cl_object v5system_p;
  ecl_va_list args; ecl_va_start(args,v1name,narg,1);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,L4130compile_file_pathnamekeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   if (Null(keyvars[3])) {
    v2output_file = ECL_T;
   } else {
    v2output_file = keyvars[0];
   }
   v3type = keyvars[1];
   v4type_supplied_p = keyvars[4];
   v5system_p = keyvars[2];
  }
  v1name = cl_pathname(v1name);
  {
   cl_object v6format;
   cl_object v7extension;
   v6format = ECL_NIL;
   v7extension = ECL_NIL;
   if (v4type_supplied_p!=ECL_NIL) {
    goto L6;
   }
   if (Null(v5system_p)){
    goto L9;
   }
   v3type = ECL_SYM("OBJECT",1315);
   goto L8;
L9:;
   v3type = VV[1];
L8:;
L6:;
   if (!((v3type)==(VV[3]))){
    goto L17;
   }
   goto L14;
L17:;
   goto L15;
L15:;
   if (!((v3type)==(VV[4]))){
    goto L12;
   }
   goto L13;
L14:;
L13:;
   v6format = ecl_cmp_symbol_value(cl_env_copy,VV[6]);
   goto L11;
L12:;
   if (!((v3type)==(VV[8]))){
    goto L26;
   }
   goto L23;
L26:;
   goto L24;
L24:;
   if (!((v3type)==(VV[9]))){
    goto L30;
   }
   goto L23;
L30:;
   goto L28;
L28:;
   if (!((v3type)==(VV[11]))){
    goto L21;
   }
   goto L22;
L23:;
L22:;
   v6format = ecl_cmp_symbol_value(cl_env_copy,VV[13]);
   goto L11;
L21:;
   if (!((v3type)==(VV[14]))){
    goto L34;
   }
   v7extension = VV[15];
   goto L11;
L34:;
   if (!((v3type)==(VV[16]))){
    goto L37;
   }
   v7extension = VV[17];
   goto L11;
L37:;
   if (!((v3type)==(VV[18]))){
    goto L40;
   }
   {
    cl_object v8;
    cl_object v9;
    cl_object v10;
    v8 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
    v9 = VV[19];
    v10 = v8;
    if (Null(ecl_memql(v9,v10))){
     goto L43;
    }
   }
   v7extension = VV[20];
   goto L42;
L43:;
   v7extension = VV[21];
L42:;
   goto L11;
L40:;
   if (!((v3type)==(VV[22]))){
    goto L48;
   }
   v7extension = VV[23];
   goto L11;
L48:;
   if (!((v3type)==(ECL_SYM("OBJECT",1315)))){
    goto L51;
   }
   v7extension = ecl_cmp_symbol_value(cl_env_copy,VV[24]);
   goto L11;
L51:;
   if (!((v3type)==(VV[25]))){
    goto L54;
   }
   v6format = ecl_cmp_symbol_value(cl_env_copy,VV[26]);
   goto L11;
L54:;
   if (!((v3type)==(VV[27]))){
    goto L57;
   }
   v6format = VV[28];
   goto L11;
L57:;
   if (!((v3type)==(VV[1]))){
    goto L64;
   }
   goto L61;
L64:;
   goto L62;
L62:;
   if (!((v3type)==(VV[30]))){
    goto L11;
   }
   goto L60;
L61:;
L60:;
   v7extension = VV[32];
L11:;
   if (!((v2output_file)==(ECL_T))){
    goto L72;
   }
   goto L68;
L72:;
   goto L70;
L70:;
   if (!((v2output_file)==(ECL_NIL))){
    goto L75;
   }
   goto L68;
L75:;
   goto L69;
L69:;
   value0 = v2output_file;
   cl_env_copy->nvalues = 1;
   return value0;
L68:;
   if (Null(v6format)){
    goto L77;
   }
   T0 = cl_pathname_name(1, v1name);
   T1 = cl_format(3, ECL_NIL, v6format, T0);
   value0 = cl_merge_pathnames(2, T1, v1name);
   return value0;
L77:;
   value0 = cl_make_pathname(4, ECL_SYM("TYPE",1356), v7extension, ECL_SYM("DEFAULTS",1247), v1name);
   return value0;
  }
 }
}
/* function definition for COMPILE-FILE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4134compile_file(volatile cl_narg narg, cl_object volatile v1input_pathname, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10;
 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[94]);
 {
  cl_object volatile v2args;
  cl_object volatile v3c_file;
  cl_object volatile v4h_file;
  cl_object volatile v5data_file;
  cl_object volatile v6system_p;
  cl_object volatile v7output_file;
  cl_object volatile v8target;
  ecl_va_list args; ecl_va_start(args,v1input_pathname,narg,1);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v1input_pathname,env0);      /*  INPUT-PATHNAME          */
  {
   cl_object keyvars[24];
   cl_parse_key(args,12,L4134compile_filekeys,keyvars,(cl_object*)&v2args,FALSE);
   CLV1 = env0 = CONS(v2args,env0);               /*  ARGS                    */
   ecl_va_end(args);
   if (Null(keyvars[12])) {
    ecl_bds_push(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)); /*  *COMPILE-VERBOSE* */
   } else {
    ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31),keyvars[0]); /*  *COMPILE-VERBOSE* */
   }
   if (Null(keyvars[13])) {
    ecl_bds_push(cl_env_copy,ECL_SYM("*COMPILE-PRINT*",30)); /*  *COMPILE-PRINT* */
   } else {
    ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-PRINT*",30),keyvars[1]); /*  *COMPILE-PRINT* */
   }
   CLV2 = env0 = CONS(keyvars[2],env0);           /*  SOURCE-TRUENAME         */
   if (Null(keyvars[15])) {
    CLV3 = env0 = CONS(ecl_make_int8_t(0),env0);  /*  SOURCE-OFFSET           */
   } else {
    CLV3 = env0 = CONS(keyvars[3],env0);          /*  SOURCE-OFFSET           */
   }
   v3c_file = keyvars[4];
   v4h_file = keyvars[5];
   v5data_file = keyvars[6];
   v6system_p = keyvars[7];
   CLV4 = env0 = CONS(keyvars[8],env0);           /*  LOAD                    */
   if (Null(keyvars[21])) {
    CLV5 = env0 = CONS(ECL_SYM("DEFAULT",1246),env0); /*  EXTERNAL-FORMAT     */
   } else {
    CLV5 = env0 = CONS(keyvars[9],env0);          /*  EXTERNAL-FORMAT         */
   }
   v7output_file = keyvars[10];
   v8target = keyvars[11];
  }
  ecl_bds_push(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69)); /*  *STANDARD-OUTPUT* */
  ecl_bds_push(cl_env_copy,ECL_SYM("*ERROR-OUTPUT*",35)); /*  *ERROR-OUTPUT*  */
  ecl_bds_push(cl_env_copy,VV[36]);               /*  *COMPILER-IN-USE*       */
  ecl_bds_push(cl_env_copy,ECL_SYM("*PACKAGE*",45)); /*  *PACKAGE*            */
  ecl_bds_push(cl_env_copy,ECL_SYM("*READTABLE*",67)); /*  *READTABLE*        */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /*  *PRINT-PRETTY* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28),ECL_NIL); /*  *COMPILE-FILE-PATHNAME* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-FILE-TRUENAME*",29),ECL_NIL); /*  *COMPILE-FILE-TRUENAME* */
  T0 = CONS(ECL_CONS_CAR(CLV2),ecl_make_int8_t(0));
  ecl_bds_bind(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210),T0); /*  *SOURCE-LOCATION* */
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[37]);
  if (value0!=ECL_NIL) {
   goto L3;
  }
  T0 = Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)))?ECL_T:ECL_NIL;
  goto L1;
L3:;
  T0 = value0;
  goto L1;
L1:;
  ecl_bds_bind(cl_env_copy,VV[37],T0);            /*  *SUPPRESS-COMPILER-MESSAGES* */
  if (Null(v8target)){
   goto L5;
  }
  ECL_CONS_CAR(CLV1) = cl_copy_list(ECL_CONS_CAR(CLV1));
  {
   cl_object v9;
   cl_object v10;                                 /*  FLAG                    */
   value0 = si_rem_f(ECL_CONS_CAR(CLV1), VV[38]);
   {
    v9 = value0;
    v10 = cl_env_copy->values[1];
   }
   ECL_CONS_CAR(CLV1) = v9;
  }
  {
   cl_object volatile v9;
   v9 = ecl_make_cclosure_va((cl_objectfn)LC4131__lambda69,env0,Cblock,0);
   T0 = v9;
  }
  value0 = L4148compile_with_target_info(T0, v8target);
  ecl_bds_unwind_n(cl_env_copy,12);
  return value0;
L5:;
  {
   cl_object v9;
   cl_object v10;
   cl_object v11;
   v9 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
   v10 = VV[41];
   v11 = v9;
   if (ecl_memql(v10,v11)!=ECL_NIL) {
    goto L14;
   }
  }
  if (v6system_p!=ECL_NIL) {
   goto L14;
  }
  cl_format(2, ECL_T, VV[42]);
L14:;
  T0 = cl_merge_pathnames(1, ECL_CONS_CAR(CLV0));
  T1 = cl_pathname(T0);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28),T1);
  if (cl_probe_file(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28)))!=ECL_NIL) {
   goto L22;
  }
  if (Null(cl_pathname_type(1, ECL_CONS_CAR(CLV0)))){
   goto L24;
  }
  cl_error(3, ECL_SYM("FILE-ERROR",355), ECL_SYM("PATHNAME",1322), ECL_CONS_CAR(CLV0));
  goto L22;
L24:;
  {
   cl_object v9;
   v9 = VV[43];
   goto L29;
L28:;
   {
    cl_object v10ext;
    v10ext = ecl_car(v9);
    T0 = cl_make_pathname(4, ECL_SYM("TYPE",1356), v10ext, ECL_SYM("DEFAULTS",1247), ECL_CONS_CAR(CLV0));
    ecl_cmp_setq(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28),T0);
    if (Null(cl_probe_file(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28))))){
     goto L35;
    }
    goto L22;
L35:;
   }
   v9 = ecl_cdr(v9);
L29:;
   if (Null(v9)){
    goto L39;
   }
   goto L28;
L39:;
   cl_error(3, ECL_SYM("FILE-ERROR",355), ECL_SYM("PATHNAME",1322), ECL_CONS_CAR(CLV0));
  }
L22:;
  if (Null(v6system_p)){
   goto L41;
  }
  if (Null(ECL_CONS_CAR(CLV4))){
   goto L41;
  }
  if (ecl_cmp_symbol_value(cl_env_copy,VV[44])!=ECL_NIL) {
   goto L41;
  }
  cl_error(1, VV[45]);
L41:;
  T0 = cl_namestring(ECL_CONS_CAR(CLV0));
  (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(4, VV[47], T0, ecl_cmp_symbol_value(cl_env_copy,VV[44]), ecl_cmp_symbol_value(cl_env_copy,VV[48])) /*  CMPPROGRESS */;
  {
   volatile cl_object v9compiler_conditions;
   volatile cl_object env1 = env0;
   T0 = cl_truename(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28)));
   CLV6 = env1 = CONS(T0,env1);                   /*  INPUT-FILE              */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-FILE-TRUENAME*",29),ECL_CONS_CAR(CLV6)); /*  *COMPILE-FILE-TRUENAME* */
   ecl_bds_push(cl_env_copy,VV[36]);              /*  *COMPILER-IN-USE*       */
   ecl_bds_bind(cl_env_copy,VV[49],ECL_NIL);      /*  *LOAD-TIME-VALUES*      */
   T0 = (VV[35]->symbol.gfdef);
   T1 = cl_apply(5, T0, ECL_CONS_CAR(CLV6), VV[50], v7output_file, ECL_CONS_CAR(CLV1));
   CLV7 = env1 = CONS(T1,env1);                   /*  OUTPUT-FILE             */
   CLV8 = env1 = CONS(ECL_NIL,env1);              /*  TRUE-OUTPUT-FILE        */
   v9compiler_conditions = ECL_NIL;
   ecl_bds_bind(cl_env_copy,VV[52],ECL_NIL);      /*  *COMPILER-CONDITIONS*   */
   {
    volatile cl_object env2 = env1;
    CLV9 = env2 = CONS(ECL_NIL,env2);
    {
     volatile cl_object env3 = env2;
     CLV10 = env3 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env3); /*  TAGBODY     */
     {
      ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV10));
      if (__ecl_frs_push_result!=0) {
      if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
       goto L50;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object volatile v10;
       v10 = ecl_make_cclosure_va((cl_objectfn)LC4132__lambda88,env3,Cblock,0);
       T0 = v10;
      }
      T1 = (cl_env_copy->function=(VV[54]->symbol.gfdef))->cfun.entry(4, ECL_SYM("NAME",1309), ECL_SYM("ABORT",79), ECL_SYM("FUNCTION",1273), T0) /*  MAKE-RESTART */;
      T2 = ecl_list1(T1);
      T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
      ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T3); /*  *RESTART-CLUSTERS* */
      T0 = ecl_fdefinition(VV[57]);
      T1 = CONS(VV[56],T0);
      T2 = ecl_fdefinition(VV[58]);
      T3 = CONS(ECL_SYM("WARNING",908),T2);
      T4 = ecl_fdefinition(VV[60]);
      T5 = CONS(VV[59],T4);
      T6 = ecl_fdefinition(VV[62]);
      T7 = CONS(VV[61],T6);
      T8 = ecl_fdefinition(VV[60]);
      T9 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T8);
      T10 = cl_list(5, T1, T3, T5, T7, T9);
      T11 = CONS(T10,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
      ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T11); /*  *HANDLER-CLUSTERS* */
      {
       volatile cl_object v10;
       v10 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+LOAD-COMPILE-LOCK+",1472));
       if (Null(mp_get_lock(2, v10, ECL_T))){
        ecl_frs_pop_n(cl_env_copy, 1);
        ecl_bds_unwind1(cl_env_copy);
        ecl_bds_unwind1(cl_env_copy);
        goto L49;
       }
       {
        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 cl_object v11;
         v11 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7));
         ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
         ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
         {
          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 {
          ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v11); /*  *INTERRUPTS-ENABLED* */
          ecl_bds_bind(cl_env_copy,ECL_SYM("*GENSYM-COUNTER*",37),ecl_make_int8_t(0)); /*  *GENSYM-COUNTER* */
          ecl_bds_bind(cl_env_copy,VV[36],ECL_T); /*  *COMPILER-IN-USE*       */
          ecl_bds_bind(cl_env_copy,VV[63],VV[64]); /*  *COMPILER-PHASE*       */
          ecl_bds_bind(cl_env_copy,VV[65],ECL_NIL); /*  *CALLBACKS*           */
          ecl_bds_bind(cl_env_copy,VV[66],ECL_NIL); /*  *FUNCTIONS*           */
          T0 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,VV[67]));
          ecl_bds_bind(cl_env_copy,VV[67],T0);    /*  *CMP-ENV-ROOT*          */
          ecl_bds_bind(cl_env_copy,VV[68],ecl_cmp_symbol_value(cl_env_copy,VV[67])); /*  *CMP-ENV* */
          T0 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
          T1 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_uint8_t(128), ECL_SYM("TEST",1353), T0);
          ecl_bds_bind(cl_env_copy,VV[69],T1);    /*  *LOAD-OBJECTS*          */
          ecl_bds_bind(cl_env_copy,VV[70],ECL_NIL); /*  *MAKE-FORMS*          */
          T0 = si_make_vector(ECL_T, ecl_make_fixnum(256), ECL_T, ecl_make_int8_t(0), ECL_NIL, ecl_make_int8_t(0));
          ecl_bds_bind(cl_env_copy,VV[71],T0);    /*  *REFERENCED-OBJECTS*    */
          ecl_bds_bind(cl_env_copy,VV[72],ECL_NIL); /*  *GLOBAL-VARS*         */
          ecl_bds_bind(cl_env_copy,VV[73],ECL_NIL); /*  *GLOBAL-FUNS*         */
          ecl_bds_bind(cl_env_copy,VV[74],ECL_NIL); /*  *UNDEFINED-VARS*      */
          ecl_bds_bind(cl_env_copy,VV[75],ECL_NIL); /*  *TOP-LEVEL-FORMS*     */
          ecl_bds_bind(cl_env_copy,VV[76],ECL_NIL); /*  *COMPILE-TIME-TOO*    */
          ecl_bds_bind(cl_env_copy,VV[77],ECL_NIL); /*  *CLINES-STRING-LIST*  */
          ecl_bds_bind(cl_env_copy,VV[78],VV[79]); /*  *DEFUN-INLINE-HOOK*    */
          value0 = ecl_cmp_symbol_value(cl_env_copy,VV[80]);
          if (value0!=ECL_NIL) {
          goto L67;
          }
          T0 = ecl_cmp_symbol_value(cl_env_copy,VV[81]);
          goto L65;
L67:;
          T0 = value0;
          goto L65;
L65:;
          ecl_bds_bind(cl_env_copy,VV[80],T0);    /*  *MACHINE*               */
          {
          cl_object volatile v12;
          v12 = ecl_make_cclosure_va((cl_objectfn)LC4133__lambda121,env3,Cblock,0);
          T0 = v12;
          }
          cl_env_copy->values[0] = L4149si__do_compilation_unit(1, T0);
          ecl_bds_unwind_n(cl_env_copy,19);
          }
          }
          ecl_frs_pop(cl_env_copy);
          ecl_stack_frame_push_values(_ecl_inner_frame);
          mp_giveup_lock(v10);
          ecl_stack_frame_pop_values(_ecl_inner_frame);
          if (unwinding) ecl_unwind(cl_env_copy,next_fr);
          ecl_stack_frame_close(_ecl_inner_frame);
          ecl_bds_unwind1(cl_env_copy);
          ecl_bds_unwind1(cl_env_copy);
         }
        }
        ecl_stack_frame_push_values(_ecl_inner_frame);
        if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
         goto L71;
        }
        si_check_pending_interrupts();
L71:;
        ecl_stack_frame_pop_values(_ecl_inner_frame);
        ecl_frs_pop_n(cl_env_copy, 1);
        ecl_stack_frame_close(_ecl_inner_frame);
        ecl_bds_unwind1(cl_env_copy);
        ecl_bds_unwind1(cl_env_copy);
        goto L49;
       }
      }
L50:;
      {
       cl_object v10;
       v10 = ECL_CONS_CAR(CLV9);
       if (Null(v10)){
        ecl_frs_pop_n(cl_env_copy, 1);
        goto L49;
       }
       si_dm_too_many_arguments(ECL_NIL);
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L49;
      }
      }
     }
    }
   }
L49:;
   v9compiler_conditions = ecl_cmp_symbol_value(cl_env_copy,VV[52]);
   ecl_bds_unwind1(cl_env_copy);
   T0 = ECL_CONS_CAR(CLV8);
   value0 = L4135compiler_output_values(T0, v9compiler_conditions);
   ecl_bds_unwind_n(cl_env_copy,15);
   return value0;
  }
 }
}
/* function definition for COMPILER-OUTPUT-VALUES                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4135compiler_output_values(cl_object v1main_value, cl_object v2conditions)
{
 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 v4i;
  cl_object v5;
  {
   cl_object v6;
   v6 = v2conditions;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4i = ECL_NIL;
  v5 = v3;
  {
   cl_object v6warning_p;
   v6warning_p = ECL_NIL;
   {
    cl_object v7failure_p;
    v7failure_p = ECL_NIL;
L9:;
    if (!(ecl_endp(v5))){
     goto L11;
    }
    goto L10;
L11:;
    v4i = ECL_CONS_CAR(v5);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v5);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    if (Null(si_of_class_p(2, v4i, ECL_SYM("STYLE-WARNING",830)))){
     goto L20;
    }
    v6warning_p = ECL_T;
    goto L19;
L20:;
    if (si_of_class_p(2, v4i, VV[61])!=ECL_NIL) {
     goto L24;
    }
    if (Null(si_of_class_p(2, v4i, ECL_SYM("WARNING",908)))){
     goto L19;
    }
    goto L23;
L24:;
L23:;
    v6warning_p = ECL_T;
    v7failure_p = ECL_T;
L19:;
    goto L9;
L10:;
    cl_env_copy->nvalues = 3;
    cl_env_copy->values[2] = v7failure_p;
    cl_env_copy->values[1] = v6warning_p;
    cl_env_copy->values[0] = v1main_value;
    return cl_env_copy->values[0];
   }
  }
 }
}
static cl_object L4135compiler_output_values_va(cl_narg narg, cl_object v8main_value, cl_object v9conditions, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[93]);
 {
  return L4135compiler_output_values(v8main_value, v9conditions);
 }
}
/* function definition for COMPILE                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4140compile(volatile cl_narg narg, cl_object volatile v1name, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8;
 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[119]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[119]);
 {
  cl_object volatile v2supplied_p;
  va_list args; va_start(args,v1name);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v1name,env0);                /*  NAME                    */
  {
   int i = 1;
   if (i >= narg) {
    CLV1 = env0 = CONS(ECL_NIL,env0);             /*  DEF                     */
    v2supplied_p = ECL_NIL;
   } else {
    i++;
    CLV1 = env0 = CONS(va_arg(args,cl_object),env0); /*  DEF                  */
    v2supplied_p = ECL_T;
   }
  }
  va_end(args);
  {
   volatile cl_object env1 = env0;
   CLV2 = env1 = CONS(ECL_NIL,env1);              /*  FORM                    */
   CLV3 = env1 = CONS(ECL_NIL,env1);              /*  LEXENV                  */
   value0 = ecl_cmp_symbol_value(cl_env_copy,VV[37]);
   if (value0!=ECL_NIL) {
    goto L3;
   }
   T0 = Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)))?ECL_T:ECL_NIL;
   goto L1;
L3:;
   T0 = value0;
   goto L1;
L1:;
   ecl_bds_bind(cl_env_copy,VV[37],T0);           /*  *SUPPRESS-COMPILER-MESSAGES* */
   ecl_bds_push(cl_env_copy,VV[36]);              /*  *COMPILER-IN-USE*       */
   ecl_bds_push(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69)); /*  *STANDARD-OUTPUT* */
   ecl_bds_push(cl_env_copy,ECL_SYM("*ERROR-OUTPUT*",35)); /*  *ERROR-OUTPUT* */
   ecl_bds_push(cl_env_copy,ECL_SYM("*PACKAGE*",45)); /*  *PACKAGE*           */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILE-PRINT*",30),ECL_NIL); /*  *COMPILE-PRINT* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /*  *PRINT-PRETTY* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*COMPILER-CONSTANTS*",1021),ECL_T); /*  *COMPILER-CONSTANTS* */
   if (si_valid_function_name_p(ECL_CONS_CAR(CLV0))!=ECL_NIL) {
    goto L5;
   }
   cl_error(2, VV[99], ECL_CONS_CAR(CLV0));
L5:;
   if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[44]))){
    goto L7;
   }
   {
    cl_object volatile v3;
    v3 = ecl_make_cclosure_va((cl_objectfn)LC4136__lambda137,env1,Cblock,0);
    T0 = v3;
   }
   value0 = L4148compile_with_target_info(T0, ecl_cmp_symbol_value(cl_env_copy,VV[101]));
   ecl_bds_unwind_n(cl_env_copy,8);
   return value0;
L7:;
   if (Null(v2supplied_p)){
    goto L11;
   }
   if (Null(ECL_CONS_CAR(CLV1))){
    goto L11;
   }
   if (Null(cl_functionp(ECL_CONS_CAR(CLV1)))){
    goto L14;
   }
   if (cl_function_lambda_expression(ECL_CONS_CAR(CLV1))!=ECL_NIL) {
    goto L16;
   }
   value0 = ECL_CONS_CAR(CLV1);
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind_n(cl_env_copy,8);
   return value0;
L16:;
   {
    cl_object v3;
    v3 = ECL_NIL;
    value0 = cl_function_lambda_expression(ECL_CONS_CAR(CLV1));
    {
     v3 = value0;
     ECL_CONS_CAR(CLV3) = cl_env_copy->values[1];
    }
    {
     cl_object v4;
     v4 = v3;
     value0 = ecl_make_bool(ECL_LISTP(v4));
     if (value0!=ECL_NIL) {
      goto L28;
     }
     T0 = cl_functionp(v4);
     goto L26;
L28:;
     T0 = value0;
     goto L26;
L26:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[102],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     ECL_CONS_CAR(CLV1) = v4;
    }
   }
   if (!((ECL_CONS_CAR(CLV3))==(ECL_T))){
    goto L14;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(1, VV[103]) /*  WARN */;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = ECL_NIL;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = ECL_CONS_CAR(CLV1);
   ecl_bds_unwind_n(cl_env_copy,8);
   return cl_env_copy->values[0];
L14:;
   if (Null(ECL_CONS_CAR(CLV0))){
    goto L33;
   }
   T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV0));
   T1 = cl_list(2, ECL_SYM("FDEFINITION",351), T0);
   T2 = cl_list(2, ECL_SYM("FUNCTION",398), ECL_CONS_CAR(CLV1));
   ECL_CONS_CAR(CLV2) = cl_list(3, ECL_SYM("SETF",753), T1, T2);
   goto L32;
L33:;
   T0 = cl_list(2, ECL_SYM("FUNCTION",398), ECL_CONS_CAR(CLV1));
   ECL_CONS_CAR(CLV2) = cl_list(3, ECL_SYM("SET",746), VV[104], T0);
L32:;
   goto L10;
L11:;
   if (cl_fboundp(ECL_CONS_CAR(CLV0))!=ECL_NIL) {
    goto L35;
   }
   cl_error(2, VV[105], ECL_CONS_CAR(CLV0));
   goto L10;
L35:;
   ECL_CONS_CAR(CLV1) = cl_fdefinition(ECL_CONS_CAR(CLV0));
   if (Null(si_of_class_p(2, ECL_CONS_CAR(CLV1), ECL_SYM("STANDARD-GENERIC-FUNCTION",978)))){
    goto L37;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(1, VV[106]) /*  WARN */;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = ECL_NIL;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = ECL_CONS_CAR(CLV1);
   ecl_bds_unwind_n(cl_env_copy,8);
   return cl_env_copy->values[0];
L37:;
   ECL_CONS_CAR(CLV2) = cl_function_lambda_expression(ECL_CONS_CAR(CLV1));
   if (!(ECL_CONS_CAR(CLV2)==ECL_NIL)){
    goto L41;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[107], ECL_CONS_CAR(CLV0)) /*  WARN */;
   cl_env_copy->nvalues = 3;
   cl_env_copy->values[2] = ECL_NIL;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = ECL_CONS_CAR(CLV1);
   ecl_bds_unwind_n(cl_env_copy,8);
   return cl_env_copy->values[0];
L41:;
   T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV0));
   T1 = cl_list(2, ECL_SYM("FDEFINITION",351), T0);
   T2 = cl_list(2, ECL_SYM("FUNCTION",398), ECL_CONS_CAR(CLV2));
   ECL_CONS_CAR(CLV2) = cl_list(3, ECL_SYM("SETF",753), T1, T2);
L10:;
   {
    volatile cl_object env2 = env1;
    ecl_bds_bind(cl_env_copy,VV[49],ECL_SYM("VALUES",899)); /*  *LOAD-TIME-VALUES* */
    T1 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,VV[98]),ecl_make_int8_t(1));
    ecl_cmp_setq(cl_env_copy,VV[98],T1);
    T0 = ecl_cmp_symbol_value(cl_env_copy,VV[98]);
    T1 = cl_format(3, ECL_NIL, VV[109], T0);
    T2 = (cl_env_copy->function=ecl_fdefinition(VV[108]))->cfun.entry(1, T1) /*  SAFE-MKSTEMP */;
    CLV4 = env2 = CONS(T2,env2);                  /*  TMP-NAMES               */
    T0 = ecl_car(ECL_CONS_CAR(CLV4));
    T1 = L4130compile_file_pathname(1, T0);
    CLV5 = env2 = CONS(T1,env2);                  /*  SO-PATHNAME             */
    CLV6 = env2 = CONS(ECL_NIL,env2);             /*  COMPILER-CONDITIONS     */
    ecl_bds_bind(cl_env_copy,VV[110],ECL_T);      /*  *PERMANENT-DATA*        */
    ecl_bds_push(cl_env_copy,VV[67]);             /*  *CMP-ENV-ROOT*          */
    ecl_bds_bind(cl_env_copy,VV[52],ECL_NIL);     /*  *COMPILER-CONDITIONS*   */
    {
     volatile cl_object env3 = env2;
     CLV7 = env3 = CONS(ECL_NIL,env3);
     {
      volatile cl_object env4 = env3;
      CLV8 = env4 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env4); /*  TAGBODY     */
      {
       ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV8));
       if (__ecl_frs_push_result!=0) {
       if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
        goto L50;
       }
       ecl_internal_error("GO found an inexistent tag");
       } else {
       {
        cl_object volatile v3;
        v3 = ecl_make_cclosure_va((cl_objectfn)LC4137__lambda150,env4,Cblock,0);
        T0 = v3;
       }
       T1 = (cl_env_copy->function=(VV[54]->symbol.gfdef))->cfun.entry(4, ECL_SYM("NAME",1309), ECL_SYM("ABORT",79), ECL_SYM("FUNCTION",1273), T0) /*  MAKE-RESTART */;
       T2 = ecl_list1(T1);
       T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
       ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T3); /*  *RESTART-CLUSTERS* */
       T0 = ecl_fdefinition(VV[57]);
       T1 = CONS(VV[56],T0);
       T2 = ecl_fdefinition(VV[58]);
       T3 = CONS(ECL_SYM("WARNING",908),T2);
       T4 = ecl_fdefinition(VV[60]);
       T5 = CONS(VV[59],T4);
       T6 = ecl_fdefinition(VV[62]);
       T7 = CONS(VV[61],T6);
       T8 = ecl_fdefinition(VV[60]);
       T9 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T8);
       T10 = cl_list(5, T1, T3, T5, T7, T9);
       T11 = CONS(T10,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
       ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T11); /*  *HANDLER-CLUSTERS* */
       {
        volatile cl_object v3;
        v3 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+LOAD-COMPILE-LOCK+",1472));
        if (Null(mp_get_lock(2, v3, ECL_T))){
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         goto L49;
        }
        {
         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 cl_object v4;
          v4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7));
          ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
          ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
          {
          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 {
          ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v4); /*  *INTERRUPTS-ENABLED* */
          ecl_bds_bind(cl_env_copy,ECL_SYM("*GENSYM-COUNTER*",37),ecl_make_int8_t(0)); /*  *GENSYM-COUNTER* */
          ecl_bds_bind(cl_env_copy,VV[36],ECL_T); /*  *COMPILER-IN-USE*       */
          ecl_bds_bind(cl_env_copy,VV[63],VV[64]); /*  *COMPILER-PHASE*       */
          ecl_bds_bind(cl_env_copy,VV[65],ECL_NIL); /*  *CALLBACKS*           */
          ecl_bds_bind(cl_env_copy,VV[66],ECL_NIL); /*  *FUNCTIONS*           */
          T0 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,VV[67]));
          ecl_bds_bind(cl_env_copy,VV[67],T0);    /*  *CMP-ENV-ROOT*          */
          ecl_bds_bind(cl_env_copy,VV[68],ecl_cmp_symbol_value(cl_env_copy,VV[67])); /*  *CMP-ENV* */
          T0 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
          T1 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_uint8_t(128), ECL_SYM("TEST",1353), T0);
          ecl_bds_bind(cl_env_copy,VV[69],T1);    /*  *LOAD-OBJECTS*          */
          ecl_bds_bind(cl_env_copy,VV[70],ECL_NIL); /*  *MAKE-FORMS*          */
          T0 = si_make_vector(ECL_T, ecl_make_fixnum(256), ECL_T, ecl_make_int8_t(0), ECL_NIL, ecl_make_int8_t(0));
          ecl_bds_bind(cl_env_copy,VV[71],T0);    /*  *REFERENCED-OBJECTS*    */
          ecl_bds_bind(cl_env_copy,VV[72],ECL_NIL); /*  *GLOBAL-VARS*         */
          ecl_bds_bind(cl_env_copy,VV[73],ECL_NIL); /*  *GLOBAL-FUNS*         */
          ecl_bds_bind(cl_env_copy,VV[74],ECL_NIL); /*  *UNDEFINED-VARS*      */
          ecl_bds_bind(cl_env_copy,VV[75],ECL_NIL); /*  *TOP-LEVEL-FORMS*     */
          ecl_bds_bind(cl_env_copy,VV[76],ECL_NIL); /*  *COMPILE-TIME-TOO*    */
          ecl_bds_bind(cl_env_copy,VV[77],ECL_NIL); /*  *CLINES-STRING-LIST*  */
          ecl_bds_bind(cl_env_copy,VV[78],VV[79]); /*  *DEFUN-INLINE-HOOK*    */
          value0 = ecl_cmp_symbol_value(cl_env_copy,VV[80]);
          if (value0!=ECL_NIL) {
          goto L67;
          }
          T0 = ecl_cmp_symbol_value(cl_env_copy,VV[81]);
          goto L65;
L67:;
          T0 = value0;
          goto L65;
L65:;
          ecl_bds_bind(cl_env_copy,VV[80],T0);    /*  *MACHINE*               */
          {
          cl_object v5;
          v5 = ecl_make_cclosure_va((cl_objectfn)LC4138__lambda183,env4,Cblock,0);
          T0 = v5;
          }
          cl_env_copy->values[0] = L4149si__do_compilation_unit(1, T0);
          ecl_bds_unwind_n(cl_env_copy,19);
          }
          }
          ecl_frs_pop(cl_env_copy);
          ecl_stack_frame_push_values(_ecl_inner_frame);
          mp_giveup_lock(v3);
          ecl_stack_frame_pop_values(_ecl_inner_frame);
          if (unwinding) ecl_unwind(cl_env_copy,next_fr);
          ecl_stack_frame_close(_ecl_inner_frame);
          ecl_bds_unwind1(cl_env_copy);
          ecl_bds_unwind1(cl_env_copy);
          }
         }
         ecl_stack_frame_push_values(_ecl_inner_frame);
         if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
          goto L71;
         }
         si_check_pending_interrupts();
L71:;
         ecl_stack_frame_pop_values(_ecl_inner_frame);
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_stack_frame_close(_ecl_inner_frame);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         goto L49;
        }
       }
L50:;
       {
        cl_object v3;
        v3 = ECL_CONS_CAR(CLV7);
        if (Null(v3)){
         ecl_frs_pop_n(cl_env_copy, 1);
         goto L49;
        }
        si_dm_too_many_arguments(ECL_NIL);
        ecl_frs_pop_n(cl_env_copy, 1);
        goto L49;
       }
       }
      }
     }
    }
L49:;
    ECL_CONS_CAR(CLV6) = ecl_cmp_symbol_value(cl_env_copy,VV[52]);
    ecl_bds_unwind1(cl_env_copy);
    {
     cl_object v3output;
     value0 = ECL_CONS_CAR(CLV0);
     if (value0!=ECL_NIL) {
      goto L79;
     }
     if (!(ecl_boundp(cl_env_copy,VV[116]))){
      goto L83;
     }
     value0 = cl_symbol_value(VV[116]);
     goto L81;
L83:;
     value0 = ECL_NIL;
     goto L81;
L81:;
     if (value0!=ECL_NIL) {
      goto L79;
     }
     {
      cl_object v4;
      v4 = ecl_make_cclosure_va((cl_objectfn)LC4139__lambda195,env2,Cblock,0);
      v3output = v4;
      goto L77;
     }
L79:;
     v3output = value0;
     goto L77;
L77:;
     cl_set(VV[116], ECL_NIL);
     si_gc(1, ECL_T);
     value0 = L4135compiler_output_values(v3output, ECL_CONS_CAR(CLV6));
     ecl_bds_unwind_n(cl_env_copy,11);
     return value0;
    }
   }
  }
 }
}
/* function definition for DISASSEMBLE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4144disassemble(volatile cl_narg narg, cl_object volatile v1thing, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6;
 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[154]);
 {
  ecl_va_list args; ecl_va_start(args,v1thing,narg,1);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L4144disassemblekeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   env0 = ECL_NIL;
   CLV0 = env0 = CONS(keyvars[0],env0);           /*  H-FILE                  */
   CLV1 = env0 = CONS(keyvars[1],env0);           /*  DATA-FILE               */
  }
  {
   volatile cl_object env1 = env0;
   CLV2 = env1 = CONS(ECL_NIL,env1);              /*  LEXENV                  */
   CLV3 = env1 = CONS(ECL_NIL,env1);              /*  DISASSEMBLED-FORM       */
   ecl_bds_push(cl_env_copy,VV[36]);              /*  *COMPILER-IN-USE*       */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /*  *PRINT-PRETTY* */
   if (Null(si_valid_function_name_p(v1thing))){
    goto L1;
   }
   v1thing = cl_fdefinition(v1thing);
L1:;
   if (Null(cl_functionp(v1thing))){
    goto L4;
   }
   if (Null(cl_function_lambda_expression(v1thing))){
    goto L4;
   }
   {
    cl_object v2;
    v2 = ECL_NIL;
    value0 = cl_function_lambda_expression(v1thing);
    {
     v2 = value0;
     ECL_CONS_CAR(CLV2) = cl_env_copy->values[1];
    }
    {
     cl_object v3;
     v3 = v2;
     value0 = ecl_make_bool(ECL_SYMBOLP(v3));
     if (value0!=ECL_NIL) {
      goto L20;
     }
     value0 = cl_functionp(v3);
     goto L18;
L20:;
     goto L18;
L18:;
     if (value0!=ECL_NIL) {
      goto L17;
     }
     T0 = ecl_make_bool(ECL_LISTP(v3));
     goto L15;
L17:;
     T0 = value0;
     goto L15;
L15:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[120],v3);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v1thing = v3;
    }
   }
   if (!((ECL_CONS_CAR(CLV2))==(ECL_T))){
    goto L4;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(1, VV[121]) /*  WARN */;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
L4:;
   {
    cl_object v2;
    v2 = ecl_make_bool(v1thing==ECL_NIL);
    if (Null(v2)){
     goto L26;
    }
    goto L24;
L26:;
    if (Null(cl_functionp(v1thing))){
     goto L28;
    }
    if (si_bc_disassemble(v1thing)!=ECL_NIL) {
     goto L24;
    }
    (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[122], v1thing) /*  WARN */;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    ecl_bds_unwind1(cl_env_copy);
    ecl_bds_unwind1(cl_env_copy);
    return value0;
L28:;
    if (!(ECL_ATOM(v1thing))){
     goto L32;
    }
    T0 = ecl_list1(v1thing);
    cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v1thing, ECL_SYM("EXPECTED-TYPE",1263), VV[123], ECL_SYM("FORMAT-CONTROL",1272), VV[124], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
    goto L24;
L32:;
    T0 = ecl_car(v1thing);
    if (!((T0)==(ECL_SYM("LAMBDA",454)))){
     goto L34;
    }
    T0 = ecl_cdr(v1thing);
    ECL_CONS_CAR(CLV3) = cl_listX(3, ECL_SYM("DEFUN",291), VV[116], T0);
    goto L24;
L34:;
    T0 = ecl_car(v1thing);
    if (!((T0)==(ECL_SYM("LAMBDA-BLOCK",1377)))){
     goto L37;
    }
    T0 = ecl_cdr(v1thing);
    ECL_CONS_CAR(CLV3) = CONS(ECL_SYM("DEFUN",291),T0);
    goto L24;
L37:;
    T0 = ecl_list1(v1thing);
    cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v1thing, ECL_SYM("EXPECTED-TYPE",1263), VV[123], ECL_SYM("FORMAT-CONTROL",1272), VV[124], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
   }
L24:;
   {
    volatile cl_object v2null_stream;
    volatile cl_object v3compiler_conditions;
    volatile cl_object env2 = env1;
    v2null_stream = cl_make_broadcast_stream(0);
    ecl_bds_bind(cl_env_copy,VV[125],v2null_stream); /*  *COMPILER-OUTPUT1*   */
    if (Null(ECL_CONS_CAR(CLV0))){
     goto L43;
    }
    T0 = cl_open(5, ECL_CONS_CAR(CLV0), ECL_SYM("DIRECTION",1249), ECL_SYM("OUTPUT",1319), ECL_SYM("EXTERNAL-FORMAT",1267), ECL_SYM("DEFAULT",1246));
    goto L42;
L43:;
    T0 = v2null_stream;
L42:;
    ecl_bds_bind(cl_env_copy,VV[126],T0);         /*  *COMPILER-OUTPUT2*      */
    T0 = cl_symbol_function(VV[127]);
    CLV4 = env2 = CONS(T0,env2);                  /*  T3FUNCTION              */
    v3compiler_conditions = ECL_NIL;
    ecl_bds_push(cl_env_copy,VV[67]);             /*  *CMP-ENV-ROOT*          */
    ecl_bds_bind(cl_env_copy,VV[52],ECL_NIL);     /*  *COMPILER-CONDITIONS*   */
    {
     volatile cl_object env3 = env2;
     CLV5 = env3 = CONS(ECL_NIL,env3);
     {
      volatile cl_object env4 = env3;
      CLV6 = env4 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env4); /*  TAGBODY     */
      {
       ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV6));
       if (__ecl_frs_push_result!=0) {
       if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
        goto L47;
       }
       ecl_internal_error("GO found an inexistent tag");
       } else {
       {
        cl_object volatile v4;
        v4 = ecl_make_cclosure_va((cl_objectfn)LC4141__lambda212,env4,Cblock,0);
        T0 = v4;
       }
       T1 = (cl_env_copy->function=(VV[54]->symbol.gfdef))->cfun.entry(4, ECL_SYM("NAME",1309), ECL_SYM("ABORT",79), ECL_SYM("FUNCTION",1273), T0) /*  MAKE-RESTART */;
       T2 = ecl_list1(T1);
       T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
       ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T3); /*  *RESTART-CLUSTERS* */
       T0 = ecl_fdefinition(VV[57]);
       T1 = CONS(VV[56],T0);
       T2 = ecl_fdefinition(VV[58]);
       T3 = CONS(ECL_SYM("WARNING",908),T2);
       T4 = ecl_fdefinition(VV[60]);
       T5 = CONS(VV[59],T4);
       T6 = ecl_fdefinition(VV[62]);
       T7 = CONS(VV[61],T6);
       T8 = ecl_fdefinition(VV[60]);
       T9 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T8);
       T10 = cl_list(5, T1, T3, T5, T7, T9);
       T11 = CONS(T10,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
       ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T11); /*  *HANDLER-CLUSTERS* */
       {
        volatile cl_object v4;
        v4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+LOAD-COMPILE-LOCK+",1472));
        if (Null(mp_get_lock(2, v4, ECL_T))){
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         goto L46;
        }
        {
         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 cl_object v5;
          v5 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7));
          ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
          ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
          {
          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 {
          ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v5); /*  *INTERRUPTS-ENABLED* */
          ecl_bds_bind(cl_env_copy,ECL_SYM("*GENSYM-COUNTER*",37),ecl_make_int8_t(0)); /*  *GENSYM-COUNTER* */
          ecl_bds_bind(cl_env_copy,VV[36],ECL_T); /*  *COMPILER-IN-USE*       */
          ecl_bds_bind(cl_env_copy,VV[63],VV[64]); /*  *COMPILER-PHASE*       */
          ecl_bds_bind(cl_env_copy,VV[65],ECL_NIL); /*  *CALLBACKS*           */
          ecl_bds_bind(cl_env_copy,VV[66],ECL_NIL); /*  *FUNCTIONS*           */
          T0 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,VV[67]));
          ecl_bds_bind(cl_env_copy,VV[67],T0);    /*  *CMP-ENV-ROOT*          */
          ecl_bds_bind(cl_env_copy,VV[68],ecl_cmp_symbol_value(cl_env_copy,VV[67])); /*  *CMP-ENV* */
          T0 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
          T1 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_uint8_t(128), ECL_SYM("TEST",1353), T0);
          ecl_bds_bind(cl_env_copy,VV[69],T1);    /*  *LOAD-OBJECTS*          */
          ecl_bds_bind(cl_env_copy,VV[70],ECL_NIL); /*  *MAKE-FORMS*          */
          T0 = si_make_vector(ECL_T, ecl_make_fixnum(256), ECL_T, ecl_make_int8_t(0), ECL_NIL, ecl_make_int8_t(0));
          ecl_bds_bind(cl_env_copy,VV[71],T0);    /*  *REFERENCED-OBJECTS*    */
          ecl_bds_bind(cl_env_copy,VV[72],ECL_NIL); /*  *GLOBAL-VARS*         */
          ecl_bds_bind(cl_env_copy,VV[73],ECL_NIL); /*  *GLOBAL-FUNS*         */
          ecl_bds_bind(cl_env_copy,VV[74],ECL_NIL); /*  *UNDEFINED-VARS*      */
          ecl_bds_bind(cl_env_copy,VV[75],ECL_NIL); /*  *TOP-LEVEL-FORMS*     */
          ecl_bds_bind(cl_env_copy,VV[76],ECL_NIL); /*  *COMPILE-TIME-TOO*    */
          ecl_bds_bind(cl_env_copy,VV[77],ECL_NIL); /*  *CLINES-STRING-LIST*  */
          ecl_bds_bind(cl_env_copy,VV[78],VV[79]); /*  *DEFUN-INLINE-HOOK*    */
          value0 = ecl_cmp_symbol_value(cl_env_copy,VV[80]);
          if (value0!=ECL_NIL) {
          goto L64;
          }
          T0 = ecl_cmp_symbol_value(cl_env_copy,VV[81]);
          goto L62;
L64:;
          T0 = value0;
          goto L62;
L62:;
          ecl_bds_bind(cl_env_copy,VV[80],T0);    /*  *MACHINE*               */
          {
          cl_object volatile v6;
          v6 = ecl_make_cclosure_va((cl_objectfn)LC4143__lambda245,env4,Cblock,0);
          T0 = v6;
          }
          cl_env_copy->values[0] = L4149si__do_compilation_unit(1, T0);
          ecl_bds_unwind_n(cl_env_copy,19);
          }
          }
          ecl_frs_pop(cl_env_copy);
          ecl_stack_frame_push_values(_ecl_inner_frame);
          mp_giveup_lock(v4);
          ecl_stack_frame_pop_values(_ecl_inner_frame);
          if (unwinding) ecl_unwind(cl_env_copy,next_fr);
          ecl_stack_frame_close(_ecl_inner_frame);
          ecl_bds_unwind1(cl_env_copy);
          ecl_bds_unwind1(cl_env_copy);
          }
         }
         ecl_stack_frame_push_values(_ecl_inner_frame);
         if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
          goto L68;
         }
         si_check_pending_interrupts();
L68:;
         ecl_stack_frame_pop_values(_ecl_inner_frame);
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_stack_frame_close(_ecl_inner_frame);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         goto L46;
        }
       }
L47:;
       {
        cl_object v4;
        v4 = ECL_CONS_CAR(CLV5);
        if (Null(v4)){
         ecl_frs_pop_n(cl_env_copy, 1);
         goto L46;
        }
        si_dm_too_many_arguments(ECL_NIL);
        ecl_frs_pop_n(cl_env_copy, 1);
        goto L46;
       }
       }
      }
     }
    }
L46:;
    v3compiler_conditions = ecl_cmp_symbol_value(cl_env_copy,VV[52]);
    ecl_bds_unwind_n(cl_env_copy,4);
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
/* function definition for COMPILER-PASS1                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4145compiler_pass1(cl_narg narg, cl_object v1object, ...)
{
 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[86]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[86]);
 {
  cl_object v2source_offset;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2source_offset = ECL_NIL;
   } else {
    i++;
    v2source_offset = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(cl_streamp(v1object))){
   goto L3;
  }
  {
   cl_object v3form;
   ecl_bds_bind(cl_env_copy,VV[155],ecl_make_int8_t(0)); /*  *COMPILE-FILE-POSITION* */
   v3form = si_read_object_or_ignore(v1object, VV[34]);
   goto L8;
L7:;
   if (Null(v3form)){
    goto L10;
   }
   {
    cl_object v4;
    v4 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210));
    {
     cl_object v5;
     v5 = ecl_plus(v2source_offset,ecl_cmp_symbol_value(cl_env_copy,VV[155]));
     {
      cl_object v6;
      v6 = v4;
      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);
    }
   }
   (cl_env_copy->function=ecl_fdefinition(VV[156]))->cfun.entry(1, v3form) /*  T1EXPR */;
L10:;
   T0 = cl_file_position(1, v1object);
   ecl_cmp_setq(cl_env_copy,VV[155],T0);
   v3form = si_read_object_or_ignore(v1object, VV[34]);
L8:;
   if ((v3form)==(VV[34])) {
    goto L23;
   }
   goto L7;
L23:;
   ecl_bds_unwind1(cl_env_copy);
   goto L2;
  }
L3:;
  (cl_env_copy->function=ecl_fdefinition(VV[156]))->cfun.entry(1, v1object) /*  T1EXPR */;
L2:;
  T0 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[75]));
  ecl_cmp_setq(cl_env_copy,VV[75],T0);
  T0 = cl_nreverse(ecl_cmp_symbol_value(cl_env_copy,VV[70]));
  ecl_cmp_setq(cl_env_copy,VV[70],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[70]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for COMPILER-PASS/PROPAGATE-TYPES                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4146compiler_pass_propagate_types()
{
 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[158]))){
  goto L2;
 }
 T0 = VV[159];
 ecl_cmp_setq(cl_env_copy,VV[63],T0);
 {
  cl_object v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[75]);
  goto L9;
L8:;
  {
   cl_object v2form;
   v2form = ecl_car(v1);
   (cl_env_copy->function=ecl_fdefinition(VV[159]))->cfun.entry(1, v2form) /*  P1PROPAGATE */;
  }
  v1 = ecl_cdr(v1);
L9:;
  if (Null(v1)){
   goto L16;
  }
  goto L8;
L16:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L4146compiler_pass_propagate_types_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[87]);
 {
  return L4146compiler_pass_propagate_types();
 }
}
/* function definition for PRINT-COMPILER-INFO                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4147print_compiler_info()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(5, VV[161], ecl_cmp_symbol_value(cl_env_copy,VV[162]), ecl_cmp_symbol_value(cl_env_copy,VV[163]), ecl_cmp_symbol_value(cl_env_copy,VV[164]), ecl_cmp_symbol_value(cl_env_copy,VV[165])) /*  CMPPROGRESS */;
 return value0;
}
static cl_object L4147print_compiler_info_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[84]);
 {
  return L4147print_compiler_info();
 }
}
/* function definition for COMPILE-WITH-TARGET-INFO                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4148compile_with_target_info(cl_object v1closure, cl_object v2target_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 v3;
  v3 = v2target_info;
  if (ECL_LISTP(v3)) {
   goto L4;
  }
  if (cl_pathnamep(v3)!=ECL_NIL) {
   goto L4;
  }
  if (ECL_STRINGP(v3)) {
   goto L4;
  }
  if (si_of_class_p(2, v3, ECL_SYM("FILE-STREAM",360))!=ECL_NIL) {
   goto L4;
  }
  v2target_info = si_do_check_type(v3, VV[167], ECL_NIL, VV[168]);
L4:;
 }
 if (cl_pathnamep(v2target_info)!=ECL_NIL) {
  goto L12;
 }
 if (ECL_STRINGP(v2target_info)) {
  goto L12;
 }
 if (Null(si_of_class_p(2, v2target_info, ECL_SYM("FILE-STREAM",360)))){
  goto L10;
 }
 goto L11;
L12:;
L11:;
 v2target_info = (cl_env_copy->function=ecl_fdefinition(VV[169]))->cfun.entry(1, v2target_info) /*  READ-TARGET-INFO */;
L10:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[101]);
 if (value0!=ECL_NIL) {
  goto L18;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[170]))->cfun.entry(0) /*  GET-TARGET-INFO */;
 goto L16;
L18:;
 T0 = value0;
 goto L16;
L16:;
 ecl_bds_bind(cl_env_copy,VV[101],T0);            /*  *HOST-INFO*             */
 {
  cl_object v4, v5; cl_index v3;
  {
   cl_object v6;
   v6 = (ECL_SYM("CAR",182)->symbol.gfdef);
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     v10 = v2target_info;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8 = ECL_NIL;
    v9 = v7;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L29:;
     if (!(ecl_endp(v9))){
      goto L31;
     }
     goto L30;
L31:;
     v8 = ECL_CONS_CAR(v9);
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     {
      cl_object v12;
      v12 = v11;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v12;
     }
     T1 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
     v11 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v11,T0);
     goto L29;
L30:;
     v4 = ecl_cdr(v10);
     goto L20;
    }
   }
  }
L20:;
  {
   cl_object v6;
   v6 = (ECL_SYM("CDR",200)->symbol.gfdef);
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     v10 = v2target_info;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8 = ECL_NIL;
    v9 = v7;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L56:;
     if (!(ecl_endp(v9))){
      goto L58;
     }
     goto L57;
L58:;
     v8 = ECL_CONS_CAR(v9);
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     {
      cl_object v12;
      v12 = v11;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v12;
     }
     T1 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
     v11 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v11,T0);
     goto L56;
L57:;
     v5 = ecl_cdr(v10);
     goto L47;
    }
   }
  }
L47:;
  v3 = ecl_progv(cl_env_copy, v4, v5);
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[174]);
  T1 = cl_lisp_implementation_version();
  if (cl_stringE(2, T0, T1)!=ECL_NIL) {
   goto L74;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[174]);
  T1 = cl_lisp_implementation_version();
  cl_error(3, VV[175], T0, T1);
L74:;
  {
   cl_object v6missing_features;
   v6missing_features = cl_intersection(2, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36)));
   if (v6missing_features==ECL_NIL) {
    goto L78;
   }
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[176], v6missing_features) /*  WARN */;
  }
L78:;
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   ecl_bds_bind(cl_env_copy,VV[44],ECL_T);        /*  *CROSS-COMPILING*       */
   cl_env_copy->values[0] = ecl_function_dispatch(cl_env_copy,v1closure)(0);
   ecl_bds_unwind1(cl_env_copy);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   {
    cl_object v6features;
    {
     cl_object v7;
     v7 = (ECL_SYM("CAR",182)->symbol.gfdef);
     {
      cl_object v8;
      v8 = si_make_seq_iterator(2, v2target_info, ecl_make_int8_t(0));
L86:;
      if (v8!=ECL_NIL) {
       goto L88;
      }
      v6features = ECL_NIL;
      goto L83;
L88:;
      {
       cl_object v9;
       v9 = si_seq_iterator_ref(v2target_info, v8);
       T0 = ecl_car(v9);
       if (!((ECL_SYM("*FEATURES*",36))==(T0))){
        goto L90;
       }
       v6features = v9;
       goto L83;
      }
L90:;
      v8 = si_seq_iterator_next(v2target_info, v8);
      goto L86;
     }
    }
L83:;
    {
     cl_object v7;
     v7 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
     {
      cl_object v8;
      v8 = v6features;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v8;
     }
     (ECL_CONS_CDR(T0)=v7,T0);
    }
   }
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   ecl_bds_unwind(cl_env_copy,v3);
   ecl_bds_unwind1(cl_env_copy);
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L4148compile_with_target_info_va(cl_narg narg, cl_object v3closure, cl_object v4target_info, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[39]);
 {
  return L4148compile_with_target_info(v3closure, v4target_info);
 }
}
/* function definition for DO-COMPILATION-UNIT                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L4149si__do_compilation_unit(volatile cl_narg narg, cl_object volatile v1closure, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[82]);
 {
  cl_object volatile v2override;
  cl_object volatile v3target;
  ecl_va_list args; ecl_va_start(args,v1closure,narg,1);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L4149si__do_compilation_unitkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v2override = keyvars[0];
   v3target = keyvars[1];
  }
  if (Null(v2override)){
   goto L1;
  }
  ecl_bds_bind(cl_env_copy,VV[182],ECL_NIL);      /*  *ACTIVE-PROTECTION*     */
  value0 = L4149si__do_compilation_unit(3, v1closure, VV[38], v3target);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L1:;
  if (!(ecl_cmp_symbol_value(cl_env_copy,VV[182])==ECL_NIL)){
   goto L3;
  }
  ecl_bds_bind(cl_env_copy,VV[182],ECL_T);        /*  *ACTIVE-PROTECTION*     */
  ecl_bds_bind(cl_env_copy,VV[183],ECL_NIL);      /*  *PENDING-ACTIONS*       */
  {
   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 {
    cl_env_copy->values[0] = L4149si__do_compilation_unit(3, v1closure, VV[38], v3target);
    }
   }
   ecl_frs_pop(cl_env_copy);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   {
    cl_object v4;
    cl_object v5action;
    cl_object v6;
    {
     cl_object v7;
     v7 = ecl_cmp_symbol_value(cl_env_copy,VV[183]);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    v5action = ECL_NIL;
    v6 = v4;
L12:;
    if (!(ecl_endp(v6))){
     goto L14;
    }
    goto L13;
L14:;
    v5action = ECL_CONS_CAR(v6);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v7;
    }
    ecl_function_dispatch(cl_env_copy,v5action)(0);
    goto L12;
L13:;
   }
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   if (unwinding) ecl_unwind(cl_env_copy,next_fr);
   ecl_stack_frame_close(_ecl_inner_frame);
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   return cl_env_copy->values[0];
  }
L3:;
  if (Null(v3target)){
   goto L24;
  }
  value0 = L4148compile_with_target_info(v1closure, v3target);
  return value0;
L24:;
  value0 = ecl_function_dispatch(cl_env_copy,v1closure)(0);
  return value0;
 }
}
/* closure INSTALL-C-COMPILER                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4150install_c_compiler(cl_narg narg, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV4 = env0;                                     /*  DO-COMPILATION-UNIT     */
 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(ECL_SYM("INSTALL-C-COMPILER",2084));
 {
L1:;
  T0 = cl_find_package(VV[186]);
  si_package_lock(T0, ECL_NIL);
  T0 = cl_delete(2, VV[185], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36)));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*FEATURES*",36),T0);
  si_fset(2, ECL_SYM("DISASSEMBLE",307), ECL_CONS_CAR(CLV1));
  si_fset(2, ECL_SYM("COMPILE",235), ECL_CONS_CAR(CLV0));
  si_fset(2, ECL_SYM("COMPILE-FILE",236), ECL_CONS_CAR(CLV2));
  si_fset(2, ECL_SYM("COMPILE-FILE-PATHNAME",237), ECL_CONS_CAR(CLV3));
  si_fset(2, VV[82], ECL_CONS_CAR(CLV4));
  T0 = cl_find_package(VV[186]);
  value0 = si_package_lock(T0, ECL_T);
  return value0;
 }
 }
}
/* closure LAMBDA69                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4131__lambda69(cl_narg narg, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5;
 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 ... */
 CLV5 = env0;
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);                           /*  ARGS                    */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[40]);
 {
L1:;
  T0 = (VV[94]->symbol.gfdef);
  value0 = cl_apply(3, T0, ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1));
  return value0;
 }
 }
}
/* closure LAMBDA88                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4132__lambda88(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10;
 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 ... */
 CLV10 = env0;                                    /*  TAGBODY                 */
 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 */
 {
  cl_object v1si__temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1si__temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV9) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV10),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA121                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4133__lambda121(volatile cl_narg narg, ...)
{
 cl_object T0;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8, CLV9, CLV10;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile env0 = cl_env_copy->function->cclosure.env;
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV10 = env0;
 CLV9 = _ecl_cdr(CLV10);
 CLV8 = _ecl_cdr(CLV9);                           /*  TRUE-OUTPUT-FILE        */
 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[83]);
 {
L1:;
  L4147print_compiler_info();
  if (Null(cl_probe_file(VV[85]))){
   goto L3;
  }
  cl_load(3, VV[85], ECL_SYM("VERBOSE",1363), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)));
L3:;
  {
   volatile cl_object v1stream;
   v1stream = cl_open(3, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28)), ECL_SYM("EXTERNAL-FORMAT",1267), ECL_CONS_CAR(CLV5));
   {
    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);
      if (ECL_CONS_CAR(CLV2)!=ECL_NIL) {
       goto L9;
      }
      {
       cl_object v2;
       v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210));
       {
        cl_object v3;
        v3 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-FILE-PATHNAME*",28));
        {
         cl_object v4;
         v4 = v2;
         if (ecl_unlikely(ECL_ATOM(v4))) FEtype_error_cons(v4);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T0 = v4;
        }
        (ECL_CONS_CAR(T0)=v3,T0);
       }
      }
L9:;
      cl_env_copy->values[0] = L4145compiler_pass1(2, v1stream, ECL_CONS_CAR(CLV3));
      ecl_stack_frame_push_values(_ecl_inner_frame);
      if (Null(v1stream)){
       goto L17;
      }
      cl_close(1, v1stream);
L17:;
      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(v1stream)){
     goto L19;
    }
    cl_close(3, v1stream, ECL_SYM("ABORT",1225), ECL_T);
L19:;
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    if (unwinding) ecl_unwind(cl_env_copy,next_fr);
    ecl_stack_frame_close(_ecl_inner_frame);
   }
  }
  L4146compiler_pass_propagate_types();
  T0 = ecl_fdefinition(VV[88]);
  cl_apply(4, T0, ECL_CONS_CAR(CLV6), ECL_CONS_CAR(CLV7), ECL_CONS_CAR(CLV1));
  ECL_CONS_CAR(CLV8) = cl_probe_file(ECL_CONS_CAR(CLV7));
  if (Null(ECL_CONS_CAR(CLV8))){
   goto L25;
  }
  T0 = cl_namestring(ECL_CONS_CAR(CLV0));
  (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(2, VV[89], T0) /*  CMPPROGRESS */;
  goto L24;
L25:;
  (cl_env_copy->function=ecl_fdefinition(VV[90]))->cfun.entry(1, VV[91]) /*  CMPERR */;
L24:;
  if (Null(ECL_CONS_CAR(CLV4))){
   goto L28;
  }
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[44]))){
   goto L30;
  }
  value0 = cl_load(3, ECL_CONS_CAR(CLV6), ECL_SYM("VERBOSE",1363), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)));
  return value0;
L30:;
  T0 = ECL_CONS_CAR(CLV8);
  value0 = cl_load(3, T0, ECL_SYM("VERBOSE",1363), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)));
  return value0;
L28:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure LAMBDA137                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4136__lambda137(cl_narg narg, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3;
 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 ... */
 CLV3 = env0;
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);                           /*  DEF                     */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[100]);
 {
L1:;
  ecl_bds_bind(cl_env_copy,VV[44],ECL_NIL);       /*  *CROSS-COMPILING*       */
  T0 = ECL_CONS_CAR(CLV0);
  value0 = L4140compile(2, T0, ECL_CONS_CAR(CLV1));
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
/* closure LAMBDA150                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4137__lambda150(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8;
 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 ... */
 CLV8 = env0;                                     /*  TAGBODY                 */
 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 */
 {
  cl_object v1si__temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1si__temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV7) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV8),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA183                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4138__lambda183(cl_narg narg, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7, CLV8;
 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 ... */
 CLV8 = env0;
 CLV7 = _ecl_cdr(CLV8);
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);                           /*  SO-PATHNAME             */
 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[113]);
 {
L1:;
  T0 = ECL_CONS_CAR(CLV2);
  ECL_CONS_CAR(CLV2) = (cl_env_copy->function=ecl_fdefinition(VV[114]))->cfun.entry(3, T0, ECL_CONS_CAR(CLV3), ecl_cmp_symbol_value(cl_env_copy,VV[68])) /*  SET-CLOSURE-ENV */;
  L4145compiler_pass1(1, ECL_CONS_CAR(CLV2));
  L4146compiler_pass_propagate_types();
  (cl_env_copy->function=ecl_fdefinition(VV[88]))->cfun.entry(2, ECL_NIL, ECL_CONS_CAR(CLV5)) /*  COMPILER-PASS/ASSEMBLE-CXX */;
  {
   cl_object v1;
   cl_object v2;
   cl_object v3;
   {
    cl_object v4;
    v4 = ECL_CONS_CAR(CLV4);
    if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v1 = v4;
   }
   v2 = ECL_NIL;
   v3 = v1;
L14:;
   if (!(ecl_endp(v3))){
    goto L16;
   }
   goto L15;
L16:;
   v2 = ECL_CONS_CAR(v3);
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v4;
   }
   ecl_function_dispatch(cl_env_copy,VV[115])(1, v2);
   goto L14;
L15:;
   goto L8;
  }
L8:;
  if (Null(cl_probe_file(ECL_CONS_CAR(CLV5)))){
   goto L27;
  }
  cl_load(3, ECL_CONS_CAR(CLV5), ECL_SYM("VERBOSE",1363), ECL_NIL);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[115]))->cfun.entry(1, ECL_CONS_CAR(CLV5)) /*  CMP-DELETE-FILE */;
  return value0;
L27:;
  ECL_CONS_CAR(CLV0) = ECL_NIL;
  cl_set(VV[116], ECL_NIL);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[90]))->cfun.entry(2, VV[117], ECL_CONS_CAR(CLV0)) /*  CMPERR */;
  return value0;
 }
 }
}
/* closure LAMBDA195                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4139__lambda195(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6;
 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 ... */
 CLV6 = env0;                                     /*  COMPILER-CONDITIONS     */
 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 */
 {
  va_list args; va_start(args,narg);
  va_end(args);
  {
   cl_object v1;
   cl_object v2c;
   cl_object v3;
   {
    cl_object v4;
    v4 = ECL_CONS_CAR(CLV6);
    if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v1 = v4;
   }
   v2c = ECL_NIL;
   v3 = v1;
L6:;
   if (!(ecl_endp(v3))){
    goto L8;
   }
   goto L7;
L8:;
   v2c = ECL_CONS_CAR(v3);
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v4;
   }
   if (Null(si_of_class_p(2, v2c, VV[61]))){
    goto L16;
   }
   T0 = (ECL_SYM("SIMPLE-PROGRAM-ERROR",1167)->symbol.gfdef);
   T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v2c) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
   T2 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v2c) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
   cl_apply(3, T0, T1, T2);
L16:;
   goto L6;
L7:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* closure LAMBDA212                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4141__lambda212(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6;
 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 ... */
 CLV6 = env0;                                     /*  TAGBODY                 */
 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 */
 {
  cl_object v1si__temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1si__temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV5) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV6),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA245                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4143__lambda245(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile env0 = cl_env_copy->function->cclosure.env;
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV6 = env0;
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);                           /*  T3FUNCTION              */
 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[130]);
 {
L1:;
  {
   volatile cl_object v1;
   volatile cl_object v2;
   volatile cl_object v3;
   volatile cl_object v4;
   volatile cl_object v5;
   {
    cl_object v6r;
    v6r = (cl_env_copy->function=ecl_fdefinition(VV[132]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[80])) /*  MACHINE-INLINE-INFORMATION */;
    if (Null(v6r)){
     goto L4;
    }
    v1 = si_copy_hash_table(v6r);
    goto L2;
L4:;
    v1 = (cl_env_copy->function=ecl_fdefinition(VV[133]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[80])) /*  MAKE-INLINE-INFORMATION */;
   }
L2:;
   v2 = (cl_env_copy->function=ecl_fdefinition(VV[134]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[80])) /*  MAKE-OPTIMIZABLE-CONSTANTS */;
   v3 = si_make_vector(ECL_T, ecl_make_uint8_t(128), ECL_T, ecl_make_int8_t(0), ECL_NIL, ecl_make_int8_t(0));
   v4 = si_make_vector(ECL_T, ecl_make_uint8_t(128), ECL_T, ecl_make_int8_t(0), ECL_NIL, ecl_make_int8_t(0));
   v5 = cl_make_hash_table(0);
   ecl_bds_bind(cl_env_copy,VV[135],ecl_make_int8_t(0)); /*  *OPENED-C-BRACES* */
   ecl_bds_bind(cl_env_copy,VV[136],ecl_make_int8_t(0)); /*  *INLINE-BLOCKS*  */
   ecl_bds_bind(cl_env_copy,VV[137],ecl_make_int8_t(0)); /*  *NEXT-CFUN*      */
   ecl_bds_bind(cl_env_copy,VV[138],v1);          /*  *INLINE-INFORMATION*    */
   ecl_bds_bind(cl_env_copy,VV[139],ECL_NIL);     /*  *SETF-DEFINITIONS*      */
   ecl_bds_bind(cl_env_copy,VV[140],ECL_NIL);     /*  *GLOBAL-CFUNS-ARRAY*    */
   ecl_bds_bind(cl_env_copy,VV[141],ECL_NIL);     /*  *STATIC-CONSTANTS*      */
   ecl_bds_bind(cl_env_copy,VV[142],v2);          /*  *OPTIMIZABLE-CONSTANTS* */
   ecl_bds_bind(cl_env_copy,VV[143],v3);          /*  *PERMANENT-OBJECTS*     */
   ecl_bds_bind(cl_env_copy,VV[144],v4);          /*  *TEMPORARY-OBJECTS*     */
   ecl_bds_bind(cl_env_copy,VV[145],v5);          /*  *COMPILER-DECLARED-GLOBALS* */
   T0 = ECL_CONS_CAR(CLV3);
   ECL_CONS_CAR(CLV3) = (cl_env_copy->function=ecl_fdefinition(VV[114]))->cfun.entry(3, T0, ECL_CONS_CAR(CLV2), ecl_cmp_symbol_value(cl_env_copy,VV[68])) /*  SET-CLOSURE-ENV */;
   {
    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 {
     {
      cl_object volatile v6;
      v6 = ecl_make_cclosure_va((cl_objectfn)LC4142__lambda293,env0,Cblock,0);
      T0 = v6;
     }
     si_fset(2, VV[127], T0);
     L4145compiler_pass1(1, ECL_CONS_CAR(CLV3));
     L4146compiler_pass_propagate_types();
     (cl_env_copy->function=ecl_fdefinition(VV[147]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[71])) /*  OPTIMIZE-CXX-DATA */;
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[149]))->cfun.entry(3, VV[150], VV[151], VV[1]) /*  COMPUTE-INIT-NAME */;
     if (Null(ECL_CONS_CAR(CLV0))){
      goto L21;
     }
     T1 = ECL_CONS_CAR(CLV0);
     goto L20;
L21:;
     T1 = VV[152];
L20:;
     if (Null(ECL_CONS_CAR(CLV1))){
      goto L24;
     }
     T2 = ECL_CONS_CAR(CLV1);
     goto L23;
L24:;
     T2 = VV[152];
L23:;
     (cl_env_copy->function=ecl_fdefinition(VV[148]))->cfun.entry(3, T0, T1, T2) /*  CTOP-WRITE */;
     if (Null(ECL_CONS_CAR(CLV1))){
      goto L26;
     }
     cl_env_copy->values[0] = (cl_env_copy->function=ecl_fdefinition(VV[153]))->cfun.entry(1, ECL_CONS_CAR(CLV1)) /*  DATA-C-DUMP */;
     goto L13;
L26:;
     cl_env_copy->values[0] = ECL_NIL;
     cl_env_copy->nvalues = 1;
L13:;
     }
    }
    ecl_frs_pop(cl_env_copy);
    ecl_stack_frame_push_values(_ecl_inner_frame);
    si_fset(2, VV[127], ECL_CONS_CAR(CLV4));
    if (Null(ECL_CONS_CAR(CLV0))){
     goto L28;
    }
    cl_close(1, ecl_cmp_symbol_value(cl_env_copy,VV[126]));
L28:;
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    if (unwinding) ecl_unwind(cl_env_copy,next_fr);
    ecl_stack_frame_close(_ecl_inner_frame);
    ecl_bds_unwind_n(cl_env_copy,11);
    return cl_env_copy->values[0];
   }
  }
 }
 }
}
/* closure LAMBDA293                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC4142__lambda293(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6;
 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 ... */
 CLV6 = env0;
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);                           /*  T3FUNCTION              */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  ecl_bds_bind(cl_env_copy,VV[125],ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69))); /*  *COMPILER-OUTPUT1* */
  value0 = cl_apply(2, ECL_CONS_CAR(CLV4), v1args);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
#include "cmp/cmpmain.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclIeaWmFmPMfph9_XTh0M881(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;CMPMAIN.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclIeaWmFmPMfph9_XTh0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
  cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_package_lock(VVtemp[0], ECL_NIL);
  si_select_package(VVtemp[1]);
  ecl_cmp_defun(VV[188]);                         /*  COMPILE-FILE-PATHNAME   */
  ecl_cmp_defun(VV[189]);                         /*  COMPILE-FILE            */
  ecl_cmp_defun(VV[190]);                         /*  COMPILER-OUTPUT-VALUES  */
  si_Xmake_special(VV[98]);
  if (ecl_boundp(cl_env_copy,VV[98])) {
   goto L13;
  }
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[98],T0);
L13:;
  ecl_cmp_defun(VV[191]);                         /*  COMPILE                 */
  ecl_cmp_defun(VV[192]);                         /*  DISASSEMBLE             */
  ecl_cmp_defun(VV[193]);                         /*  COMPILER-PASS1          */
  ecl_cmp_defun(VV[194]);                         /*  COMPILER-PASS/PROPAGATE-TYPES */
  ecl_cmp_defun(VV[195]);                         /*  PRINT-COMPILER-INFO     */
  ecl_cmp_defun(VV[196]);                         /*  COMPILE-WITH-TARGET-INFO */
  ecl_cmp_defun(VV[197]);                         /*  DO-COMPILATION-UNIT     */
  si_package_lock(VVtemp[0], ECL_T);
  T0 = cl_delete(2, VV[185], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36)));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*FEATURES*",36),T0);
  {
   cl_object env1 = env0;
   T0 = (VV[119]->symbol.gfdef);
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  COMPILE                 */
   T0 = (VV[154]->symbol.gfdef);
   CLV1 = env1 = CONS(T0,env1);                   /*  DISASSEMBLE             */
   T0 = (VV[94]->symbol.gfdef);
   CLV2 = env1 = CONS(T0,env1);                   /*  COMPILE-FILE            */
   T0 = (VV[35]->symbol.gfdef);
   CLV3 = env1 = CONS(T0,env1);                   /*  COMPILE-FILE-PATHNAME   */
   T0 = (VV[82]->symbol.gfdef);
   CLV4 = env1 = CONS(T0,env1);                   /*  DO-COMPILATION-UNIT     */
   {
    cl_object v1;
    v1 = ecl_make_cclosure_va((cl_objectfn)LC4150install_c_compiler,env1,Cblock,0);
    T0 = v1;
   }
   si_fset(2, ECL_SYM("INSTALL-C-COMPILER",2084), T0);
  }
  cl_provide(VV[187]);
 }
}
