/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpbackend-cxx/cmpbackend-cxx.lsp */
#include <ecl/ecl-cmp.h>
#include "cmp/cmpbackend-cxx.eclh"
/* function definition for SAFE-MKSTEMP                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3956safe_mkstemp(cl_object v1template)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2base;
  v2base = si_mkstemp(v1template);
  if (v2base!=ECL_NIL) {
   goto L3;
  }
  cl_error(2, VV[1], v1template);
L3:;
  {
   cl_object v3output;
   T0 = cl_pathname_name(1, v2base);
   value0 = cl_pathname_type(1, v2base);
   if (value0!=ECL_NIL) {
    goto L9;
   }
   T1 = VV[2];
   goto L7;
L9:;
   T1 = value0;
   goto L7;
L7:;
   T2 = cl_concatenate(3, ECL_SYM("STRING",808), T0, T1);
   v3output = cl_make_pathname(6, ECL_SYM("NAME",1309), T2, ECL_SYM("TYPE",1356), VV[3], ECL_SYM("DEFAULTS",1247), v2base);
   if (cl_probe_file(v3output)!=ECL_NIL) {
    goto L11;
   }
   if (Null(si_copy_file(v2base, v3output))){
    goto L11;
   }
   T0 = cl_truename(v3output);
   T1 = cl_truename(v2base);
   v2base = cl_list(2, T0, T1);
   goto L5;
L11:;
   cl_delete_file(v2base);
   v2base = ECL_NIL;
  }
L5:;
  value0 = v2base;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3956safe_mkstemp_va(cl_narg narg, cl_object v3template, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3956safe_mkstemp(v3template);
 }
}
/* function definition for CMP-DELETE-FILE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3957cmp_delete_file(cl_object v1file)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = ecl_make_bool(ecl_cmp_symbol_value(cl_env_copy,VV[6])==ECL_NIL);
  if (Null(v2)){
   goto L3;
  }
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v3;
   v3 = si_getenv(VV[7]);
   if (Null(v3)){
    goto L6;
   }
   value0 = v3;
   cl_env_copy->nvalues = 1;
   return value0;
L6:;
   {
    cl_object v4;
    T0 = cl_probe_file(v1file);
    v4 = ecl_make_bool(T0==ECL_NIL);
    if (Null(v4)){
     goto L9;
    }
    value0 = v4;
    cl_env_copy->nvalues = 1;
    return value0;
L9:;
    if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[8]))){
     goto L11;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(2, VV[10], v1file) /*  CMPPROGRESS */;
    T0 = CONS(v1file,ecl_cmp_symbol_value(cl_env_copy,VV[11]));
    ecl_cmp_setq(cl_env_copy,VV[11],T0);
    value0 = ecl_cmp_symbol_value(cl_env_copy,VV[11]);
    cl_env_copy->nvalues = 1;
    return value0;
L11:;
    value0 = cl_delete_file(v1file);
    return value0;
   }
  }
 }
}
static cl_object L3957cmp_delete_file_va(cl_narg narg, cl_object v5file, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[5]);
 {
  return L3957cmp_delete_file(v5file);
 }
}
/* local function LAMBDA9                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3958__lambda9()
{
 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;
  v1 = (ECL_SYM("DELETE-FILE",295)->symbol.gfdef);
  {
   cl_object v2;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[11]);
   {
    cl_object v3;
    cl_object v4;
    cl_object v5;
    {
     cl_object v6;
     v6 = v2;
     if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v3 = v6;
    }
    v4 = ECL_NIL;
    v5 = v3;
L9:;
    if (!(ecl_endp(v5))){
     goto L11;
    }
    goto L10;
L11:;
    v4 = 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;
    }
    ecl_function_dispatch(cl_env_copy,v1)(1, v4);
    goto L9;
L10:;
    value0 = v2;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object LC3958__lambda9_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[13]);
 {
  return LC3958__lambda9();
 }
}
/* local function FIX-FOR-MINGW                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3959fix_for_mingw(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4directory_namestring;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4directory_namestring = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = v4directory_namestring;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3959fix_for_mingw_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[17]);
 {
  return LC3959fix_for_mingw(v5, v6);
 }
}
/* function definition for GET-DEPRECATED-USER-LD-FLAGS                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3960get_deprecated_user_ld_flags()
{
 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 v1flags;
  v1flags = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[22])) /*  SPLIT-PROGRAM-OPTIONS */;
  if (Null(v1flags)){
   goto L3;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(4, VV[24], VV[22], VV[25], VV[26]) /*  CMPWARN */;
L3:;
  value0 = v1flags;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3960get_deprecated_user_ld_flags_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[20]);
 {
  return L3960get_deprecated_user_ld_flags();
 }
}
/* function definition for LINKER-CC                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3961linker_cc(cl_narg narg, cl_object v1o_pathname, cl_object v2object_files, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[33]);
 {
  cl_object v3type;
  cl_object v4ld_flags;
  cl_object v5ld_libs;
  ecl_va_list args; ecl_va_start(args,v2object_files,narg,2);
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,L3961linker_cckeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[3])) {
    v3type = VV[28];
   } else {
    v3type = keyvars[0];
   }
   if (Null(keyvars[4])) {
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     v6 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
     v7 = VV[29];
     v8 = v6;
     if (Null(ecl_memql(v7,v8))){
      goto L4;
     }
    }
    if (!((v3type)==(VV[28]))){
     goto L4;
    }
    T0 = ecl_cmp_symbol_value(cl_env_copy,VV[30]);
    goto L3;
L4:;
    T0 = ecl_cmp_symbol_value(cl_env_copy,VV[31]);
L3:;
    v4ld_flags = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, T0) /*  SPLIT-PROGRAM-OPTIONS */;
   } else {
    v4ld_flags = keyvars[1];
   }
   if (Null(keyvars[5])) {
    v5ld_libs = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[32])) /*  SPLIT-PROGRAM-OPTIONS */;
   } else {
    v5ld_libs = keyvars[2];
   }
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[35]);
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1o_pathname) /*  BRIEF-NAMESTRING */;
  T2 = L3970ecl_library_directory();
  T3 = cl_concatenate(3, ECL_SYM("STRING",808), VV[38], T2);
  T4 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[25])) /*  SPLIT-PROGRAM-OPTIONS */;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[40]))){
   goto L14;
  }
  T5 = ecl_list1(ecl_cmp_symbol_value(cl_env_copy,VV[40]));
  goto L12;
L14:;
  T5 = ECL_NIL;
  goto L12;
L12:;
  T6 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[26])) /*  SPLIT-PROGRAM-OPTIONS */;
  T7 = L3960get_deprecated_user_ld_flags();
  T8 = cl_append(7, T4, v4ld_flags, v2object_files, T5, T6, T7, v5ld_libs);
  T9 = cl_listX(4, VV[36], T1, T3, T8);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, T0, T9) /*  SAFE-RUN-PROGRAM */;
  return value0;
 }
}
/* function definition for LINKER-AR                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3962linker_ar(cl_object v1output_name, cl_object v2o_name, cl_object v3ld_libs)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_namestring(v1output_name);
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v2o_name) /*  BRIEF-NAMESTRING */;
 T2 = CONS(T1,v3ld_libs);
 value0 = L3963static_lib_ar(T0, T2);
 return value0;
}
static cl_object L3962linker_ar_va(cl_narg narg, cl_object v4output_name, cl_object v5o_name, cl_object v6ld_libs, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[42]);
 {
  return L3962linker_ar(v4output_name, v5o_name, v6ld_libs);
 }
}
/* function definition for STATIC-LIB-AR                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3963static_lib_ar(cl_object v1lib, cl_object v2object_files)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3lib;
  v3lib = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1lib) /*  BRIEF-NAMESTRING */;
  if (Null(cl_probe_file(v3lib))){
   goto L3;
  }
  cl_delete_file(v3lib);
L3:;
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[45]);
  {
   cl_object v4;
   v4 = ecl_fdefinition(VV[37]);
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    {
     cl_object v8;
     v8 = v2object_files;
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6 = ECL_NIL;
    v7 = v5;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L16:;
     if (!(ecl_endp(v7))){
      goto L18;
     }
     goto L17;
L18:;
     v6 = ECL_CONS_CAR(v7);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v7);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T2 = v10;
     }
     T3 = ecl_function_dispatch(cl_env_copy,v4)(1, v6);
     v9 = ecl_list1(T3);
     (ECL_CONS_CDR(T2)=v9,T2);
     goto L16;
L17:;
     T1 = ecl_cdr(v8);
     goto L7;
    }
   }
  }
L7:;
  T2 = cl_listX(3, VV[46], v3lib, T1);
  (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, T0, T2) /*  SAFE-RUN-PROGRAM */;
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[50]);
  T1 = ecl_list1(v3lib);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, T0, T1) /*  SAFE-RUN-PROGRAM */;
  return value0;
 }
}
static cl_object L3963static_lib_ar_va(cl_narg narg, cl_object v4lib, cl_object v5object_files, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[43]);
 {
  return L3963static_lib_ar(v4lib, v5object_files);
 }
}
/* function definition for COMPILER-CC                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3964compiler_cc(cl_object v1c_pathname, cl_object v2o_pathname)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15;
 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_cmp_symbol_value(cl_env_copy,VV[53]);
 T1 = L3967precompiled_header_flags();
 T2 = L3969ecl_include_directory();
 T3 = cl_concatenate(3, ECL_SYM("STRING",808), VV[56], T2);
 T4 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[58])) /*  SPLIT-PROGRAM-OPTIONS */;
 T6 = (cl_env_copy->function=ecl_fdefinition(VV[59]))->cfun.entry(1, ECL_SYM("SPEED",794)) /*  CMP-ENV-OPTIMIZATION */;
 if (!(ecl_greatereq(T6,ecl_make_int8_t(2)))){
  goto L5;
 }
 T5 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[60])) /*  SPLIT-PROGRAM-OPTIONS */;
 goto L3;
L5:;
 T5 = ECL_NIL;
 goto L3;
L3:;
 T6 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1c_pathname) /*  BRIEF-NAMESTRING */;
 T7 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v2o_pathname) /*  BRIEF-NAMESTRING */;
 T8 = cl_list(2, VV[36], T7);
 T9 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  SPLIT-PROGRAM-OPTIONS */;
 T10 = ecl_append(T8,T9);
 T11 = cl_listX(3, VV[61], T6, T10);
 T12 = cl_append(3, T4, T5, T11);
 T13 = CONS(T3,T12);
 T14 = ecl_append(T1,T13);
 T15 = CONS(VV[54],T14);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, T0, T15) /*  SAFE-RUN-PROGRAM */;
 return value0;
}
static cl_object L3964compiler_cc_va(cl_narg narg, cl_object v3c_pathname, cl_object v4o_pathname, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return L3964compiler_cc(v3c_pathname, v4o_pathname);
 }
}
/* function definition for NEED-TO-DUMP-PRECOMPILED-HEADER                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3965need_to_dump_precompiled_header()
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v1config;
  cl_object v2need_to_dump;
  v1config = ecl_cmp_symbol_value(cl_env_copy,VV[65]);
  value0 = ecl_make_bool(v1config==ECL_NIL);
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_aref1(v1config,(cl_fixnum)(0));
  {
   bool v3;
   v3 = (T0)==(ecl_cmp_symbol_value(cl_env_copy,VV[53]));
   value0 = (v3)?ECL_NIL:ECL_T;
  }
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_aref1(v1config,(cl_fixnum)(1));
  T1 = L3969ecl_include_directory();
  {
   bool v3;
   v3 = (T0)==(T1);
   value0 = (v3)?ECL_NIL:ECL_T;
  }
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_aref1(v1config,(cl_fixnum)(2));
  {
   bool v3;
   v3 = (T0)==(ecl_cmp_symbol_value(cl_env_copy,VV[58]));
   value0 = (v3)?ECL_NIL:ECL_T;
  }
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_aref1(v1config,(cl_fixnum)(3));
  {
   bool v3;
   v3 = (T0)==(ecl_cmp_symbol_value(cl_env_copy,VV[60]));
   value0 = (v3)?ECL_NIL:ECL_T;
  }
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T0 = ecl_aref1(v1config,(cl_fixnum)(4));
  {
   bool v3;
   v3 = (T0)==(ecl_cmp_symbol_value(cl_env_copy,VV[62]));
   v2need_to_dump = (v3)?ECL_NIL:ECL_T;
   goto L3;
  }
L5:;
  v2need_to_dump = value0;
  goto L3;
L3:;
  if (Null(v2need_to_dump)){
   goto L11;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[53]);
  T1 = L3969ecl_include_directory();
  T2 = cl_vector(5, T0, T1, ecl_cmp_symbol_value(cl_env_copy,VV[58]), ecl_cmp_symbol_value(cl_env_copy,VV[60]), ecl_cmp_symbol_value(cl_env_copy,VV[62]));
  ecl_cmp_setq(cl_env_copy,VV[65],T2);
L11:;
  value0 = v2need_to_dump;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3965need_to_dump_precompiled_header_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[64]);
 {
  return L3965need_to_dump_precompiled_header();
 }
}
/* function definition for PRECOMPILED-HEADER-FLAGS                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3967precompiled_header_flags()
{
 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);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[67]))){
  goto L2;
 }
 if (Null(L3965need_to_dump_precompiled_header())){
  goto L4;
 }
 {
  volatile cl_object env1 = env0;
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(ECL_NIL,env1);
  {
   volatile cl_object env2 = env1;
   CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  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 L6;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v1;
     v1 = ecl_make_cclosure_va((cl_objectfn)LC3966__lambda53,env2,Cblock,1);
     T0 = v1;
    }
    T1 = CONS(ECL_SYM("ERROR",339),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* */
    L3968dump_precompiled_header();
    ecl_frs_pop_n(cl_env_copy, 1);
    ecl_bds_unwind1(cl_env_copy);
    goto L4;
L6:;
    {
     cl_object v1err;
     v1err = ECL_CONS_CAR(CLV0);
     T0 = ECL_NIL;
     ecl_cmp_setq(cl_env_copy,VV[67],T0);
     T0 = ECL_NIL;
     ecl_cmp_setq(cl_env_copy,VV[71],T0);
     T0 = ECL_NIL;
     ecl_cmp_setq(cl_env_copy,VV[65],T0);
     (cl_env_copy->function=ecl_fdefinition(VV[72]))->cfun.entry(2, VV[73], v1err) /*  CMPNOTE */;
     ecl_frs_pop_n(cl_env_copy, 1);
     goto L4;
    }
    }
   }
  }
 }
L4:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[71]);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3967precompiled_header_flags_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[55]);
 {
  return L3967precompiled_header_flags();
 }
}
/* function definition for DUMP-PRECOMPILED-HEADER                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3968dump_precompiled_header()
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v1input_file;
  cl_object v2output_dir;
  cl_object v3output_file;
  T0 = L3969ecl_include_directory();
  T1 = cl_pathname_directory(1, T0);
  T2 = ecl_append(T1,VV[75]);
  T3 = L3969ecl_include_directory();
  v1input_file = cl_make_pathname(8, ECL_SYM("DIRECTORY",1250), T2, ECL_SYM("DEFAULTS",1247), T3, ECL_SYM("NAME",1309), VV[76], ECL_SYM("TYPE",1356), VV[77]);
  T0 = cl_random(1, ecl_make_fixnum(65535));
  T1 = cl_format(3, ECL_NIL, VV[78], T0);
  T2 = cl_translate_logical_pathname(1, VV[79]);
  v2output_dir = cl_merge_pathnames(2, T1, T2);
  T0 = cl_make_pathname(4, ECL_SYM("NAME",1309), VV[76], ECL_SYM("DEFAULTS",1247), v2output_dir);
  v3output_file = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, T0, ECL_SYM("TYPE",1356), VV[80]) /*  COMPILE-FILE-PATHNAME */;
  cl_ensure_directories_exist(1, v2output_dir);
  T0 = CONS(v2output_dir,ecl_cmp_symbol_value(cl_env_copy,VV[11]));
  ecl_cmp_setq(cl_env_copy,VV[11],T0);
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[53]);
  T1 = cl_namestring(v1input_file);
  T2 = L3969ecl_include_directory();
  T3 = cl_concatenate(3, ECL_SYM("STRING",808), VV[56], T2);
  T4 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[58])) /*  SPLIT-PROGRAM-OPTIONS */;
  T5 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[60])) /*  SPLIT-PROGRAM-OPTIONS */;
  T6 = cl_namestring(v3output_file);
  T7 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[62])) /*  SPLIT-PROGRAM-OPTIONS */;
  T8 = cl_listX(3, VV[36], T6, T7);
  T9 = cl_append(3, T4, T5, T8);
  T10 = cl_listX(5, VV[81], VV[82], T1, T3, T9);
  (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, T0, T10) /*  SAFE-RUN-PROGRAM */;
  T0 = CONS(v3output_file,ecl_cmp_symbol_value(cl_env_copy,VV[11]));
  ecl_cmp_setq(cl_env_copy,VV[11],T0);
  T0 = cl_namestring(v2output_dir);
  T1 = cl_concatenate(3, ECL_SYM("STRING",808), VV[56], T0);
  T2 = cl_namestring(v2output_dir);
  T3 = cl_concatenate(3, ECL_SYM("STRING",808), T2, VV[84]);
  T4 = cl_list(3, T1, VV[83], T3);
  ecl_cmp_setq(cl_env_copy,VV[71],T4);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[71]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3968dump_precompiled_header_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[70]);
 {
  return L3968dump_precompiled_header();
 }
}
/* function definition for ECL-INCLUDE-DIRECTORY                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3969ecl_include_directory()
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[86]))){
  goto L2;
 }
 T0 = cl_merge_pathnames(2, VV[87], ecl_cmp_symbol_value(cl_env_copy,VV[86]));
 if (Null(cl_probe_file(T0))){
  goto L2;
 }
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[86]);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (Null(cl_probe_file(VV[88]))){
  goto L5;
 }
 T0 = cl_translate_logical_pathname(1, VV[89]);
 T1 = cl_namestring(T0);
 ecl_cmp_setq(cl_env_copy,VV[86],T1);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[86]);
 cl_env_copy->nvalues = 1;
 return value0;
L5:;
 {
  cl_object v1;
  v1 = cl_error(1, VV[90]);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3969ecl_include_directory_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[57]);
 {
  return L3969ecl_include_directory();
 }
}
/* function definition for ECL-LIBRARY-DIRECTORY                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3970ecl_library_directory()
{
 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(ecl_cmp_symbol_value(cl_env_copy,VV[92]))){
  goto L2;
 }
 {
  cl_object v1;
  cl_object v2;
  cl_object v3;
  v1 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
  v2 = VV[29];
  v3 = v1;
  if (Null(ecl_memql(v2,v3))){
   goto L6;
  }
 }
 T0 = VV[94];
 goto L5;
L6:;
 T0 = VV[95];
L5:;
 T1 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, VV[93], ECL_SYM("TYPE",1356), T0) /*  COMPILE-FILE-PATHNAME */;
 T2 = cl_merge_pathnames(2, T1, ecl_cmp_symbol_value(cl_env_copy,VV[92]));
 if (Null(cl_probe_file(T2))){
  goto L2;
 }
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[92]);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (Null(cl_probe_file(VV[96]))){
  goto L11;
 }
 T0 = cl_translate_logical_pathname(1, VV[89]);
 T1 = cl_namestring(T0);
 ecl_cmp_setq(cl_env_copy,VV[92],T1);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[92]);
 cl_env_copy->nvalues = 1;
 return value0;
L11:;
 {
  cl_object v1;
  v1 = cl_error(1, VV[97]);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3970ecl_library_directory_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[39]);
 {
  return L3970ecl_library_directory();
 }
}
/* function definition for GUESS-KIND                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3971guess_kind(cl_object v1pathname)
{
 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 v2record;
  {
   cl_object v3;
   cl_object v4;
   v3 = cl_pathname_type(1, v1pathname);
   v4 = (ECL_SYM("STRING-EQUAL",811)->symbol.gfdef);
   {
    cl_object v5;
    v5 = VV[100];
    goto L8;
L7:;
    {
     cl_object v6;
     cl_object v7;
     {
      cl_object v8;
      v8 = v5;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v8;
     }
     v7 = ECL_CONS_CAR(v6);
     if (Null(v7)){
      goto L10;
     }
     {
      cl_object v8;
      {
       cl_object v9;
       v9 = v7;
       if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v9;
      }
      v8 = ECL_CONS_CAR(T0);
      if (Null(cl_string_equal(2, v3, v8))){
       goto L10;
      }
      v2record = v7;
      goto L2;
     }
    }
L10:;
    v5 = ECL_CONS_CDR(v5);
L8:;
    if (v5==ECL_NIL) {
     goto L23;
    }
    goto L7;
L23:;
    v2record = ECL_NIL;
   }
  }
L2:;
  if (Null(v2record)){
   goto L25;
  }
  value0 = ecl_cadr(v2record);
  cl_env_copy->nvalues = 1;
  return value0;
L25:;
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[104], v1pathname) /*  WARN */;
  value0 = ECL_SYM("OBJECT",1315);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3971guess_kind_va(cl_narg narg, cl_object v3pathname, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[99]);
 {
  return L3971guess_kind(v3pathname);
 }
}
/* function definition for GUESS-LD-LIBS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3972guess_ld_libs(cl_narg narg, cl_object v1pathname, ...)
{
 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[106]);
 {
  cl_object v2kind;
  ecl_va_list args; ecl_va_start(args,v1pathname,narg,1);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L3972guess_ld_libskeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[1])) {
    v2kind = L3971guess_kind(v1pathname);
   } else {
    v2kind = keyvars[0];
   }
  }
  if (!((v2kind)==(ECL_SYM("OBJECT",1315)))){
   goto L7;
  }
  goto L4;
L7:;
  goto L5;
L5:;
  if (!((v2kind)==(VV[108]))){
   goto L2;
  }
  goto L3;
L4:;
L3:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1pathname) /*  BRIEF-NAMESTRING */;
  return value0;
L2:;
  if (!((v2kind)==(VV[111]))){
   goto L15;
  }
  goto L12;
L15:;
  goto L13;
L13:;
  if (!((v2kind)==(VV[112]))){
   goto L10;
  }
  goto L11;
L12:;
L11:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L10:;
  if (!((v2kind)==(VV[95]))){
   goto L23;
  }
  goto L20;
L23:;
  goto L21;
L21:;
  if (!((v2kind)==(VV[115]))){
   goto L18;
  }
  goto L19;
L20:;
L19:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1pathname) /*  BRIEF-NAMESTRING */;
  return value0;
L18:;
  if (!((v2kind)==(VV[94]))){
   goto L31;
  }
  goto L28;
L31:;
  goto L29;
L29:;
  if (!((v2kind)==(VV[118]))){
   goto L26;
  }
  goto L27;
L28:;
L27:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1pathname) /*  BRIEF-NAMESTRING */;
  return value0;
L26:;
  if (!((v2kind)==(VV[28]))){
   goto L34;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L34:;
  value0 = cl_error(2, VV[121], v2kind);
  return value0;
 }
}
/* function definition for SYSTEM-LD-FLAG                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3979system_ld_flag(cl_object v1library)
{
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 lex0[0] = v1library;                             /*  LIBRARY                 */
L1:;
 {
  cl_object v2system;
  lex0[1] = ECL_NIL;                              /*  ASDF                    */
  v2system = ECL_NIL;
  goto L5;
L5:;
  value0 = LC3978fallback(lex0);
  return value0;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3979system_ld_flag_va(cl_narg narg, cl_object v3library, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[123]);
 {
  return L3979system_ld_flag(v3library);
 }
}
/* function definition for SHARED-CC                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3980shared_cc(cl_object v1o_pathname, cl_object v2object_files)
{
 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 v5ld_flags;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[136])) /*  SPLIT-PROGRAM-OPTIONS */;
  v4 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[32])) /*  SPLIT-PROGRAM-OPTIONS */;
  v5ld_flags = v3;
  {
   cl_object v6;
   cl_object v7;
   cl_object v8;
   v6 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
   v7 = VV[137];
   v8 = v6;
   if (Null(ecl_memql(v7,v8))){
    goto L5;
   }
  }
  v5ld_flags = CONS(VV[138],v5ld_flags);
L5:;
  value0 = L3961linker_cc(8, v1o_pathname, v2object_files, ECL_SYM("TYPE",1356), VV[118], VV[139], v5ld_flags, VV[140], v4);
  return value0;
 }
}
static cl_object L3980shared_cc_va(cl_narg narg, cl_object v6o_pathname, cl_object v7object_files, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[135]);
 {
  return L3980shared_cc(v6o_pathname, v7object_files);
 }
}
/* function definition for BUNDLE-CC                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3981bundle_cc(cl_object v1o_pathname, cl_object v2init_name, cl_object v3object_files)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v4;
  cl_object v5;
  cl_object v6ld_flags;
  v4 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[143])) /*  SPLIT-PROGRAM-OPTIONS */;
  v5 = (cl_env_copy->function=ecl_fdefinition(VV[21]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[32])) /*  SPLIT-PROGRAM-OPTIONS */;
  v6ld_flags = v4;
  {
   cl_object v7;
   cl_object v8;
   cl_object v9;
   v7 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
   v8 = VV[137];
   v9 = v7;
   if (Null(ecl_memql(v8,v9))){
    goto L5;
   }
  }
  v6ld_flags = cl_listX(3, VV[138], VV[144], v6ld_flags);
L5:;
  value0 = L3961linker_cc(8, v1o_pathname, v3object_files, ECL_SYM("TYPE",1356), VV[111], VV[139], v6ld_flags, VV[140], v5);
  return value0;
 }
}
static cl_object L3981bundle_cc_va(cl_narg narg, cl_object v7o_pathname, cl_object v8init_name, cl_object v9object_files, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[142]);
 {
  return L3981bundle_cc(v7o_pathname, v8init_name, v9object_files);
 }
}
/* function definition for COMPILER-PASS/ASSEMBLE-CXX                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3982compiler_pass_assemble_cxx(cl_narg narg, cl_object v1input_file, cl_object v2output_file, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[158]);
 {
  cl_object v3c_file;
  cl_object v4h_file;
  cl_object v5data_file;
  cl_object v6system_p;
  ecl_va_list args; ecl_va_start(args,v2output_file,narg,2);
  {
   cl_object keyvars[8];
   cl_parse_key(args,4,L3982compiler_pass_assemble_cxxkeys,keyvars,NULL,TRUE);
   ecl_va_end(args);
   v3c_file = keyvars[0];
   v4h_file = keyvars[1];
   v5data_file = keyvars[2];
   v6system_p = keyvars[3];
  }
  {
   cl_object v7cpath;
   cl_object v8hpath;
   cl_object v9dpath;
   cl_object v10opath;
   cl_object v11to_delete;
   cl_object v12init_name;
   v7cpath = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(5, v2output_file, VV[159], v3c_file, ECL_SYM("TYPE",1356), VV[108]) /*  COMPILE-FILE-PATHNAME */;
   v8hpath = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(5, v2output_file, VV[159], v4h_file, ECL_SYM("TYPE",1356), VV[160]) /*  COMPILE-FILE-PATHNAME */;
   v9dpath = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(5, v2output_file, VV[159], v5data_file, ECL_SYM("TYPE",1356), VV[161]) /*  COMPILE-FILE-PATHNAME */;
   v10opath = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, v2output_file, ECL_SYM("TYPE",1356), ECL_SYM("OBJECT",1315)) /*  COMPILE-FILE-PATHNAME */;
   if (v3c_file!=ECL_NIL) {
    goto L7;
   }
   T0 = ecl_list1(v7cpath);
   goto L6;
L7:;
   T0 = ECL_NIL;
L6:;
   if (v4h_file!=ECL_NIL) {
    goto L10;
   }
   T1 = ecl_list1(v8hpath);
   goto L9;
L10:;
   T1 = ECL_NIL;
L9:;
   if (v5data_file!=ECL_NIL) {
    goto L13;
   }
   T2 = ecl_list1(v9dpath);
   goto L12;
L13:;
   T2 = ECL_NIL;
L12:;
   if (v6system_p!=ECL_NIL) {
    goto L16;
   }
   T3 = ecl_list1(v10opath);
   goto L15;
L16:;
   T3 = ECL_NIL;
L15:;
   v11to_delete = cl_nconc(4, T0, T1, T2, T3);
   if (Null(v6system_p)){
    goto L20;
   }
   T0 = ECL_SYM("OBJECT",1315);
   goto L19;
L20:;
   T0 = VV[111];
L19:;
   v12init_name = (cl_env_copy->function=ecl_fdefinition(VV[162]))->cfun.entry(3, v2output_file, VV[163], T0) /*  COMPUTE-INIT-NAME */;
   (cl_env_copy->function=ecl_fdefinition(VV[164]))->cfun.entry(5, v7cpath, v8hpath, v9dpath, v12init_name, v1input_file) /*  COMPILER-PASS/GENERATE-CXX */;
   if (Null(v6system_p)){
    goto L24;
   }
   L3964compiler_cc(v7cpath, v10opath);
   goto L23;
L24:;
   L3964compiler_cc(v7cpath, v10opath);
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v2output_file) /*  BRIEF-NAMESTRING */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v10opath) /*  BRIEF-NAMESTRING */;
   T2 = ecl_list1(T1);
   L3981bundle_cc(T0, v12init_name, T2);
L23:;
   {
    cl_object v13;
    cl_object v14;
    cl_object v15;
    {
     cl_object v16;
     v16 = v11to_delete;
     if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v13 = v16;
    }
    v14 = ECL_NIL;
    v15 = v13;
L32:;
    if (!(ecl_endp(v15))){
     goto L34;
    }
    goto L33;
L34:;
    v14 = ECL_CONS_CAR(v15);
    {
     cl_object v16;
     v16 = ECL_CONS_CDR(v15);
     if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v15 = v16;
    }
    ecl_function_dispatch(cl_env_copy,VV[5])(1, v14);
    goto L32;
L33:;
    value0 = v11to_delete;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* function definition for BUILDER                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3983builder(volatile cl_narg narg, cl_object volatile v1target, cl_object volatile v2output_name, ...)
{
 cl_object T0, T1, T2;
 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<2)) FEwrong_num_arguments(VV[170]);
 {
  cl_object volatile v3lisp_files;
  cl_object volatile v4ld_flags;
  cl_object volatile v5ld_libs;
  cl_object volatile v6init_name;
  cl_object volatile v7main_name;
  cl_object volatile v8prologue_code;
  cl_object volatile v9epilogue_code;
  cl_object volatile v10system;
  ecl_va_list args; ecl_va_start(args,v2output_name,narg,2);
  {
   cl_object keyvars[16];
   cl_parse_key(args,8,L3983builderkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v3lisp_files = keyvars[0];
   v4ld_flags = keyvars[1];
   v5ld_libs = keyvars[2];
   v6init_name = keyvars[3];
   v7main_name = keyvars[4];
   if (Null(keyvars[13])) {
    v8prologue_code = VV[2];
   } else {
    v8prologue_code = keyvars[5];
   }
   if (Null(keyvars[14])) {
    if (!((v1target)==(VV[28]))){
     goto L3;
    }
    v9epilogue_code = VV[166];
    goto L2;
L3:;
    v9epilogue_code = ECL_NIL;
L2:;
   } else {
    v9epilogue_code = keyvars[6];
   }
   if (Null(keyvars[15])) {
    v10system = VV[167];
   } else {
    v10system = keyvars[7];
   }
  }
  {
   volatile cl_object v11target;
   volatile cl_object v12output_name;
   volatile cl_object v13wrap_name;
   value0 = ecl_cmp_symbol_value(cl_env_copy,VV[168]);
   if (value0!=ECL_NIL) {
    goto L8;
   }
   T0 = Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*COMPILE-VERBOSE*",31)))?ECL_T:ECL_NIL;
   goto L6;
L8:;
   T0 = value0;
   goto L6;
L6:;
   ecl_bds_bind(cl_env_copy,VV[168],T0);          /*  *SUPPRESS-COMPILER-MESSAGES* */
   v11target = (cl_env_copy->function=ecl_fdefinition(VV[169]))->cfun.entry(1, v1target) /*  NORMALIZE-BUILD-TARGET-NAME */;
   if (ECL_SYMBOLP(v2output_name)) {
    goto L14;
   }
   if (!(ECL_STRINGP(v2output_name))){
    goto L12;
   }
   goto L13;
L14:;
L13:;
   v12output_name = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, v2output_name, ECL_SYM("TYPE",1356), v11target) /*  COMPILE-FILE-PATHNAME */;
   goto L11;
L12:;
   v12output_name = v2output_name;
L11:;
   v13wrap_name = v6init_name;
   v6init_name = (cl_env_copy->function=ecl_fdefinition(VV[162]))->cfun.entry(3, v12output_name, VV[163], v11target) /*  COMPUTE-INIT-NAME */;
   if (v13wrap_name==ECL_NIL) {
    goto L19;
   }
   if (!(ecl_equal(v6init_name,v13wrap_name))){
    goto L21;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, VV[171]) /*  CMPWARN */;
   v13wrap_name = ECL_NIL;
   goto L19;
L21:;
   if (!((v11target)==(VV[95]))){
    goto L31;
   }
   value0 = VV[172];
   goto L29;
L31:;
   value0 = ECL_NIL;
   goto L29;
L29:;
   if (value0!=ECL_NIL) {
    goto L28;
   }
   if (!((v11target)==(VV[94]))){
    goto L34;
   }
   T0 = VV[173];
   goto L26;
L34:;
   T0 = ECL_NIL;
   goto L26;
L28:;
   T0 = value0;
   goto L26;
L26:;
   if (!(T0==ECL_NIL)){
    goto L19;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, VV[174]) /*  CMPWARN */;
L19:;
   if (v7main_name!=ECL_NIL) {
    goto L36;
   }
   v7main_name = (cl_env_copy->function=ecl_fdefinition(VV[162]))->cfun.entry(5, v12output_name, VV[163], v11target, VV[175], VV[176]) /*  COMPUTE-INIT-NAME */;
L36:;
   if (!(v9epilogue_code==ECL_NIL)){
    goto L40;
   }
   v9epilogue_code = VV[2];
   goto L39;
L40:;
   if (ECL_STRINGP(v9epilogue_code)) {
    goto L39;
   }
   {
    volatile cl_object v14;
    v14 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
    {
     cl_object v16, v17; cl_index v15;
     v16 = ECL_CONS_CAR(v14);
     v17 = ECL_CONS_CDR(v14);
     v15 = ecl_progv(cl_env_copy, v16, v17);
     {
      volatile cl_object v18stream;
      v18stream = cl_make_string_output_stream(0);
      {
       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_princ(VV[177],v18stream);
        T0 = cl_write_to_string(1, v9epilogue_code);
        (cl_env_copy->function=ecl_fdefinition(VV[178]))->cfun.entry(2, T0, v18stream) /*  WT-FILTERED-DATA */;
        ecl_princ(VV[179],v18stream);
        cl_env_copy->values[0] = cl_get_output_stream_string(v18stream);
        }
       }
       ecl_frs_pop(cl_env_copy);
       ecl_stack_frame_push_values(_ecl_inner_frame);
       cl_close(1, v18stream);
       ecl_stack_frame_pop_values(_ecl_inner_frame);
       if (unwinding) ecl_unwind(cl_env_copy,next_fr);
       v9epilogue_code = cl_env_copy->values[0];
       ecl_stack_frame_close(_ecl_inner_frame);
      }
     }
     ecl_bds_unwind(cl_env_copy,v15);
    }
   }
L39:;
   if (!(v8prologue_code==ECL_NIL)){
    goto L55;
   }
   v8prologue_code = VV[2];
   goto L54;
L55:;
   {
    volatile cl_object v14;
    v14 = ecl_make_bool(ECL_STRINGP(v8prologue_code));
    if (Null(v14)){
     goto L59;
    }
    goto L54;
L59:;
    {
     volatile cl_object v15;
     v15 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
     {
      cl_object v17, v18; cl_index v16;
      v17 = ECL_CONS_CAR(v15);
      v18 = ECL_CONS_CDR(v15);
      v16 = ecl_progv(cl_env_copy, v17, v18);
      {
       volatile cl_object v19stream;
       v19stream = cl_make_string_output_stream(0);
       {
        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_princ(VV[177],v19stream);
         T0 = cl_write_to_string(1, v8prologue_code);
         (cl_env_copy->function=ecl_fdefinition(VV[178]))->cfun.entry(2, T0, v19stream) /*  WT-FILTERED-DATA */;
         ecl_princ(VV[179],v19stream);
         cl_env_copy->values[0] = cl_get_output_stream_string(v19stream);
         }
        }
        ecl_frs_pop(cl_env_copy);
        ecl_stack_frame_push_values(_ecl_inner_frame);
        cl_close(1, v19stream);
        ecl_stack_frame_pop_values(_ecl_inner_frame);
        if (unwinding) ecl_unwind(cl_env_copy,next_fr);
        v8prologue_code = cl_env_copy->values[0];
        ecl_stack_frame_close(_ecl_inner_frame);
       }
      }
      ecl_bds_unwind(cl_env_copy,v16);
     }
    }
   }
L54:;
   {
    cl_object v14tmp_names;
    cl_object v15tmp_name;
    cl_object v16c_name;
    cl_object v17o_name;
    cl_object v18submodules;
    cl_object v19c_file;
    v14tmp_names = L3956safe_mkstemp(VV[180]);
    v15tmp_name = ecl_car(v14tmp_names);
    T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, v15tmp_name, ECL_SYM("TYPE",1356), VV[108]) /*  COMPILE-FILE-PATHNAME */;
    v16c_name = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, T0) /*  BRIEF-NAMESTRING */;
    T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, v15tmp_name, ECL_SYM("TYPE",1356), ECL_SYM("OBJECT",1315)) /*  COMPILE-FILE-PATHNAME */;
    v17o_name = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, T0) /*  BRIEF-NAMESTRING */;
    v18submodules = ECL_NIL;
    v19c_file = ECL_NIL;
    {
     cl_object v20;
     v20 = cl_reverse(v3lisp_files);
     goto L81;
L80:;
     {
      cl_object v21item;
      v21item = ecl_car(v20);
      {
       cl_object v22path;
       cl_object v23kind;
       if (!(ECL_SYMBOLP(v21item))){
        goto L87;
       }
       v22path = L3979system_ld_flag(v21item);
       goto L86;
L87:;
       if (Null(cl_pathnamep(v21item))){
        goto L89;
       }
       v22path = v21item;
       goto L86;
L89:;
       if (!(ECL_STRINGP(v21item))){
        goto L91;
       }
       v22path = cl_parse_namestring(1, v21item);
       goto L86;
L91:;
       v22path = si_etypecase_error(v21item, VV[181]);
L86:;
       v23kind = L3971guess_kind(v22path);
       {
        cl_object v24;
        cl_object v25;
        cl_object v26;
        if ((v11target)==(VV[95])) {
         goto L98;
        }
        T0 = VV[182];
        goto L97;
L98:;
        T0 = ECL_NIL;
L97:;
        v24 = ecl_append(T0,VV[107]);
        v25 = v23kind;
        v26 = v24;
        if (ecl_memql(v25,v26)!=ECL_NIL) {
         goto L94;
        }
       }
       cl_error(4, VV[183], v21item, v23kind, v11target);
L94:;
       {
        cl_object v24;
        cl_object v25;
        v24 = (cl_env_copy->function=ecl_fdefinition(VV[184]))->cfun.entry(2, v22path, v23kind) /*  GUESS-INIT-NAME */;
        v25 = L3972guess_ld_libs(1, v22path);
        if (Null(v25)){
         goto L104;
        }
        v5ld_libs = CONS(v25,v5ld_libs);
L104:;
        if (Null(v24)){
         goto L85;
        }
        T0 = cl_list(2, v24, v22path);
        v18submodules = CONS(T0,v18submodules);
       }
      }
L85:;
     }
     v20 = ecl_cdr(v20);
L81:;
     if (Null(v20)){
      goto L111;
     }
     goto L80;
L111:;
    }
    v19c_file = cl_open(5, v16c_name, ECL_SYM("DIRECTION",1249), ECL_SYM("OUTPUT",1319), ECL_SYM("EXTERNAL-FORMAT",1267), ECL_SYM("DEFAULT",1246));
    cl_format(3, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[146]), v18submodules);
    {
     cl_object v20init_tag;
     v20init_tag = (cl_env_copy->function=ecl_fdefinition(VV[185]))->cfun.entry(3, v6init_name, VV[163], v11target) /*  INIT-NAME-TAG */;
     if (!((v11target)==(VV[28]))){
      goto L118;
     }
     cl_format(7, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[148]), v6init_name, v20init_tag, VV[2], v18submodules, VV[2]);
     if (!((v10system)==(VV[167]))){
      goto L123;
     }
     T0 = ecl_cmp_symbol_value(cl_env_copy,VV[152]);
     goto L122;
L123:;
     if (!((v10system)==(VV[186]))){
      goto L125;
     }
     T0 = ecl_cmp_symbol_value(cl_env_copy,VV[156]);
     goto L122;
L125:;
     T0 = si_ecase_error(v10system, VV[187]);
L122:;
     cl_format(5, v19c_file, T0, v8prologue_code, v6init_name, v9epilogue_code);
     cl_close(1, v19c_file);
     L3964compiler_cc(v16c_name, v17o_name);
     T0 = cl_namestring(v17o_name);
     T1 = ecl_list1(T0);
     T2 = cl_append(3, v4ld_flags, T1, v5ld_libs);
     L3961linker_cc(2, v12output_name, T2);
     goto L117;
L118:;
     if (!((v11target)==(VV[95]))){
      goto L129;
     }
     cl_format(7, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[148]), v6init_name, v20init_tag, v8prologue_code, v18submodules, v9epilogue_code);
     if (Null(v13wrap_name)){
      goto L132;
     }
     cl_format(4, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[150]), v13wrap_name, v6init_name);
L132:;
     cl_format(6, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[154]), v7main_name, v8prologue_code, v6init_name, v9epilogue_code);
     cl_close(1, v19c_file);
     L3964compiler_cc(v16c_name, v17o_name);
     if (Null(cl_probe_file(v12output_name))){
      goto L137;
     }
     cl_delete_file(v12output_name);
L137:;
     L3962linker_ar(v12output_name, v17o_name, v5ld_libs);
     goto L117;
L129:;
     if (!((v11target)==(VV[94]))){
      goto L139;
     }
     cl_format(7, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[148]), v6init_name, v20init_tag, v8prologue_code, v18submodules, v9epilogue_code);
     if (Null(v13wrap_name)){
      goto L142;
     }
     cl_format(4, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[150]), v13wrap_name, v6init_name);
L142:;
     cl_format(6, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[154]), v7main_name, v8prologue_code, v6init_name, v9epilogue_code);
     cl_close(1, v19c_file);
     L3964compiler_cc(v16c_name, v17o_name);
     T0 = ecl_list1(v17o_name);
     T1 = cl_append(3, v4ld_flags, T0, v5ld_libs);
     L3980shared_cc(v12output_name, T1);
     goto L117;
L139:;
     if (!((v11target)==(VV[111]))){
      goto L147;
     }
     cl_format(7, v19c_file, ecl_cmp_symbol_value(cl_env_copy,VV[148]), v6init_name, v20init_tag, v8prologue_code, v18submodules, v9epilogue_code);
     cl_close(1, v19c_file);
     L3964compiler_cc(v16c_name, v17o_name);
     T0 = ecl_list1(v17o_name);
     T1 = cl_append(3, v4ld_flags, T0, v5ld_libs);
     L3981bundle_cc(v12output_name, v6init_name, T1);
     goto L117;
L147:;
     si_ecase_error(v11target, VV[188]);
L117:;
     {
      cl_object v21;
      cl_object v22;
      cl_object v23;
      {
       cl_object v24;
       v24 = v14tmp_names;
       if (ecl_unlikely(!ECL_LISTP(v24))) FEtype_error_list(v24);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v21 = v24;
      }
      v22 = ECL_NIL;
      v23 = v21;
L158:;
      if (!(ecl_endp(v23))){
       goto L160;
      }
      goto L159;
L160:;
      v22 = ECL_CONS_CAR(v23);
      {
       cl_object v24;
       v24 = ECL_CONS_CDR(v23);
       if (ecl_unlikely(!ECL_LISTP(v24))) FEtype_error_list(v24);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v23 = v24;
      }
      ecl_function_dispatch(cl_env_copy,VV[5])(1, v22);
      goto L158;
L159:;
      goto L152;
     }
L152:;
     L3957cmp_delete_file(v16c_name);
     L3957cmp_delete_file(v17o_name);
     value0 = v12output_name;
     cl_env_copy->nvalues = 1;
     ecl_bds_unwind1(cl_env_copy);
     return value0;
    }
   }
  }
 }
}
/* function definition for BUILD-FASL                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3984build_fasl(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);
  T0 = ecl_fdefinition(VV[170]);
  value0 = cl_apply(3, T0, VV[111], v1args);
  return value0;
 }
}
/* function definition for BUILD-PROGRAM                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3985build_program(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);
  T0 = ecl_fdefinition(VV[170]);
  value0 = cl_apply(3, T0, VV[28], v1args);
  return value0;
 }
}
/* function definition for BUILD-STATIC-LIBRARY                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3986build_static_library(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);
  T0 = ecl_fdefinition(VV[170]);
  value0 = cl_apply(3, T0, VV[95], v1args);
  return value0;
 }
}
/* function definition for BUILD-SHARED-LIBRARY                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3987build_shared_library(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);
  {
   cl_object v2;
   cl_object v3;
   cl_object v4;
   v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36));
   v3 = VV[29];
   v4 = v2;
   if (Null(ecl_memql(v3,v4))){
    goto L1;
   }
  }
  T0 = ecl_fdefinition(VV[170]);
  value0 = cl_apply(3, T0, VV[94], v1args);
  return value0;
L1:;
  value0 = cl_error(1, VV[197]);
  return value0;
 }
}
/* closure LAMBDA53                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3966__lambda53(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[69]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* local function FALLBACK                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3978fallback(volatile cl_object *lex0)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_string_downcase(1, lex0[0]);
 T1 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(3, T0, ECL_SYM("TYPE",1356), VV[131]) /*  COMPILE-FILE-PATHNAME */;
 T2 = cl_merge_pathnames(2, VV[89], T1);
 value0 = cl_translate_logical_pathname(1, T2);
 return value0;
}
/* local function FIND-ARCHIVE                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3977find_archive(volatile cl_object *lex0, cl_object v1system)
{
 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 = LC3976existing_system_output(lex0, v1system, VV[131]);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = LC3976existing_system_output(lex0, v1system, VV[94]);
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function EXISTING-SYSTEM-OUTPUT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3976existing_system_output(volatile cl_object *lex0, cl_object v1system, cl_object v2type)
{
 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 v3o;
  v3o = LC3975system_output(lex0, v1system, v2type);
  if (Null(v3o)){
   goto L4;
  }
  v3o = cl_probe_file(v3o);
  if (Null(v3o)){
   goto L4;
  }
  value0 = cl_namestring(v3o);
  return value0;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function SYSTEM-OUTPUT                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3975system_output(volatile cl_object *lex0, cl_object v1system, 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:;
 {
  cl_object v3build;
  T0 = LC3973asdfsym(lex0, VV[127]);
  v3build = (cl_env_copy->function=(ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef))->cfun.entry(3, T0, ECL_SYM("TYPE",1356), v2type) /*  MAKE-INSTANCE */;
  T0 = LC3974asdfcall(3, lex0, VV[128], v3build, v1system);
  value0 = ecl_car(T0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function ASDFCALL                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3974asdfcall(cl_narg narg, volatile cl_object *lex0, cl_object v1fun, ...)
{
 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[125]);
 {
  cl_object v2rest;
  ecl_va_list args; ecl_va_start(args,v1fun,narg,1);
  v2rest = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = LC3973asdfsym(lex0, v1fun);
  value0 = cl_apply(2, T0, v2rest);
  return value0;
 }
}
/* local function ASDFSYM                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3973asdfsym(volatile cl_object *lex0, cl_object v1x)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_string(v1x);
 value0 = cl_find_symbol(2, T0, lex0[1]);
 return value0;
}
#include "cmp/cmpbackend-cxx.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclhYomhh32vmkk9_wYd0M881(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;CMPBACKEND-CXX;CMPBACKEND-CXX.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclhYomhh32vmkk9_wYd0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[199]);                         /*  SAFE-MKSTEMP            */
  ecl_cmp_defun(VV[200]);                         /*  CMP-DELETE-FILE         */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC3958__lambda9_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*EXIT-HOOKS*",1546)));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*EXIT-HOOKS*",1546),T1);
  ecl_cmp_defmacro(VV[201]);                      /*  FIX-FOR-MINGW           */
  ecl_cmp_defun(VV[202]);                         /*  GET-DEPRECATED-USER-LD-FLAGS */
  ecl_cmp_defun(VV[203]);                         /*  LINKER-CC               */
  ecl_cmp_defun(VV[204]);                         /*  LINKER-AR               */
  ecl_cmp_defun(VV[205]);                         /*  STATIC-LIB-AR           */
  ecl_cmp_defun(VV[206]);                         /*  COMPILER-CC             */
  ecl_cmp_defun(VV[207]);                         /*  NEED-TO-DUMP-PRECOMPILED-HEADER */
  ecl_cmp_defun(VV[208]);                         /*  PRECOMPILED-HEADER-FLAGS */
  ecl_cmp_defun(VV[209]);                         /*  DUMP-PRECOMPILED-HEADER */
  ecl_cmp_defun(VV[210]);                         /*  ECL-INCLUDE-DIRECTORY   */
  ecl_cmp_defun(VV[211]);                         /*  ECL-LIBRARY-DIRECTORY   */
  ecl_cmp_defun(VV[212]);                         /*  GUESS-KIND              */
  ecl_cmp_defun(VV[213]);                         /*  GUESS-LD-LIBS           */
  ecl_cmp_defun(VV[214]);                         /*  SYSTEM-LD-FLAG          */
  ecl_cmp_defun(VV[215]);                         /*  SHARED-CC               */
  ecl_cmp_defun(VV[216]);                         /*  BUNDLE-CC               */
  si_Xmake_constant(VV[146], VV[147]);
  si_Xmake_constant(VV[148], VV[149]);
  si_Xmake_constant(VV[150], VV[151]);
  si_Xmake_constant(VV[152], VV[153]);
  si_Xmake_constant(VV[154], VV[155]);
  si_Xmake_constant(VV[156], VV[157]);
  ecl_cmp_defun(VV[217]);                         /*  COMPILER-PASS/ASSEMBLE-CXX */
  ecl_cmp_defun(VV[218]);                         /*  BUILDER                 */
  ecl_cmp_defun(VV[219]);                         /*  BUILD-FASL              */
  ecl_cmp_defun(VV[220]);                         /*  BUILD-PROGRAM           */
  ecl_cmp_defun(VV[221]);                         /*  BUILD-STATIC-LIBRARY    */
  ecl_cmp_defun(VV[222]);                         /*  BUILD-SHARED-LIBRARY    */
 }
}
