/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/top.lsp                         */
#include <ecl/ecl-cmp.h>
#include "clos/top.eclh"
/* function definition for TPL-FORMAT                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2772tpl_format(cl_narg narg, cl_object v1format_string, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[25]);
 {
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,v1format_string,narg,1);
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("FORMAT",389)->symbol.gfdef);
  value0 = cl_apply(4, T0, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), v1format_string, v2args);
  return value0;
 }
}
/* function definition for TOP-LEVEL                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2773top_level(volatile cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[32]);
 {
  cl_object volatile v1process_command_line;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1process_command_line = ECL_NIL;
   } else {
    i++;
    v1process_command_line = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)); /*  BEGIN CATCH CATCH648 */
  {
   ecl_frs_push(cl_env_copy,value0);
   if (__ecl_frs_push_result!=0) {
    value0 = cl_env_copy->values[0];
   } else {
    ecl_bds_bind(cl_env_copy,ECL_SYM("*DEBUGGER-HOOK*",33),ECL_NIL); /*  *DEBUGGER-HOOK* */
    ecl_bds_bind(cl_env_copy,ECL_SYM("+",16),ECL_NIL); /*  +                  */
    ecl_bds_bind(cl_env_copy,ECL_SYM("++",17),ECL_NIL); /*  ++                */
    ecl_bds_bind(cl_env_copy,ECL_SYM("+++",18),ECL_NIL); /*  +++              */
    ecl_bds_bind(cl_env_copy,ECL_SYM("-",19),ECL_NIL); /*  -                  */
    ecl_bds_bind(cl_env_copy,ECL_SYM("*",20),ECL_NIL); /*  *                  */
    ecl_bds_bind(cl_env_copy,ECL_SYM("**",21),ECL_NIL); /*  **                */
    ecl_bds_bind(cl_env_copy,ECL_SYM("***",22),ECL_NIL); /*  ***              */
    ecl_bds_bind(cl_env_copy,ECL_SYM("/",23),ECL_NIL); /*  /                  */
    ecl_bds_bind(cl_env_copy,ECL_SYM("//",24),ECL_NIL); /*  //                */
    ecl_bds_bind(cl_env_copy,ECL_SYM("///",25),ECL_NIL); /*  ///              */
    si_select_package(VV[27]);
    if (ecl_cmp_symbol_value(cl_env_copy,VV[24])!=ECL_NIL) {
     goto L6;
    }
    if (v1process_command_line==ECL_NIL) {
     goto L6;
    }
    (cl_env_copy->function=ecl_fdefinition(ECL_SYM("PROCESS-COMMAND-ARGS",1928)))->cfun.entry(0) /*  PROCESS-COMMAND-ARGS */;
    T0 = cl_lisp_implementation_version();
    T1 = si_lisp_implementation_vcs_id();
    L2772tpl_format(3, VV[28], T0, T1);
    L2772tpl_format(1, VV[29]);
    L2772tpl_format(1, VV[30]);
L6:;
    T0 = ECL_T;
    ecl_cmp_setq(cl_env_copy,VV[24],T0);
    ecl_bds_bind(cl_env_copy,VV[16],ecl_make_int8_t(-1)); /*  *TPL-LEVEL*     */
    L2796tpl(0);
    ecl_bds_unwind1(cl_env_copy);
    value0 = ecl_make_int8_t(0);
    cl_env_copy->nvalues = 1;
    ecl_bds_unwind_n(cl_env_copy,11);
   }
  }
  ecl_frs_pop(cl_env_copy);                       /*  END CATCH CATCH648      */
  return value0;
 }
}
/* function definition for CANDIDATE-TO-GET-CONSOLE-P                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2774candidate_to_get_console_p(cl_object v1process)
{
 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:;
 value0 = ecl_make_bool(ecl_cmp_symbol_value(cl_env_copy,VV[35])==ECL_NIL);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = ecl_make_bool((ecl_cmp_symbol_value(cl_env_copy,VV[35]))==(v1process));
 if (value0!=ECL_NIL) {
  goto L3;
 }
 T0 = mp_process_active_p(ecl_cmp_symbol_value(cl_env_copy,VV[35]));
 value0 = Null(T0)?ECL_T:ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2774candidate_to_get_console_p_va(cl_narg narg, cl_object v2process, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[37]);
 {
  return L2774candidate_to_get_console_p(v2process);
 }
}
/* function definition for REGISTER-IN-WAITING-LIST                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2775register_in_waiting_list(cl_object volatile v1process)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[33]);
  if (Null(mp_get_lock(2, v2, ECL_T))){
   goto L3;
  }
  {
   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 v3;
    v3 = 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),v3); /*  *INTERRUPTS-ENABLED* */
      T0 = CONS(v1process,ecl_cmp_symbol_value(cl_env_copy,VV[36]));
      ecl_cmp_setq(cl_env_copy,VV[36],T0);
      cl_env_copy->values[0] = ecl_cmp_symbol_value(cl_env_copy,VV[36]);
      cl_env_copy->nvalues = 1;
      ecl_bds_unwind1(cl_env_copy);
      }
     }
     ecl_frs_pop(cl_env_copy);
     ecl_stack_frame_push_values(_ecl_inner_frame);
     mp_giveup_lock(v2);
     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 L10;
   }
   si_check_pending_interrupts();
L10:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2775register_in_waiting_list_va(cl_narg narg, cl_object v3process, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[39]);
 {
  return L2775register_in_waiting_list(v3process);
 }
}
/* function definition for DELETE-FROM-WAITING-LIST                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2776delete_from_waiting_list(cl_object volatile v1process)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[33]);
  if (Null(mp_get_lock(2, v2, ECL_T))){
   goto L3;
  }
  {
   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 v3;
    v3 = 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),v3); /*  *INTERRUPTS-ENABLED* */
      T0 = cl_delete(2, v1process, ecl_cmp_symbol_value(cl_env_copy,VV[36]));
      ecl_cmp_setq(cl_env_copy,VV[36],T0);
      cl_env_copy->values[0] = ecl_cmp_symbol_value(cl_env_copy,VV[36]);
      cl_env_copy->nvalues = 1;
      ecl_bds_unwind1(cl_env_copy);
      }
     }
     ecl_frs_pop(cl_env_copy);
     ecl_stack_frame_push_values(_ecl_inner_frame);
     mp_giveup_lock(v2);
     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 L10;
   }
   si_check_pending_interrupts();
L10:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2776delete_from_waiting_list_va(cl_narg narg, cl_object v3process, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[41]);
 {
  return L2776delete_from_waiting_list(v3process);
 }
}
/* function definition for GRAB-CONSOLE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2777grab_console(cl_object volatile v1process)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2repeat;
  v2repeat = ECL_T;
L3:;
  if (v2repeat!=ECL_NIL) {
   goto L5;
  }
  goto L4;
L5:;
  {
   volatile cl_object v3;
   v3 = ecl_cmp_symbol_value(cl_env_copy,VV[33]);
   if (Null(mp_get_lock(2, v3, ECL_T))){
    goto L7;
   }
   {
    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* */
       if (Null(L2774candidate_to_get_console_p(v1process))){
        goto L13;
       }
       T0 = v1process;
       ecl_cmp_setq(cl_env_copy,VV[35],T0);
       v2repeat = ECL_NIL;
       cl_env_copy->values[0] = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_bds_unwind1(cl_env_copy);
       goto L12;
L13:;
       cl_env_copy->values[0] = mp_condition_variable_wait(ecl_cmp_symbol_value(cl_env_copy,VV[34]), ecl_cmp_symbol_value(cl_env_copy,VV[33]));
       ecl_bds_unwind1(cl_env_copy);
L12:;
       }
      }
      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 L19;
    }
    si_check_pending_interrupts();
L19:;
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    ecl_stack_frame_close(_ecl_inner_frame);
   }
  }
L7:;
  goto L3;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2777grab_console_va(cl_narg narg, cl_object v3process, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[43]);
 {
  return L2777grab_console(v3process);
 }
}
/* function definition for RELEASE-CONSOLE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2778release_console(cl_object volatile v1process)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[33]);
  if (Null(mp_get_lock(2, v2, ECL_T))){
   goto L3;
  }
  {
   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 v3;
    v3 = 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),v3); /*  *INTERRUPTS-ENABLED* */
      if (!((v1process)==(ecl_cmp_symbol_value(cl_env_copy,VV[35])))){
       goto L10;
      }
      T0 = ECL_NIL;
      ecl_cmp_setq(cl_env_copy,VV[35],T0);
      goto L8;
L10:;
      goto L8;
L8:;
      cl_env_copy->values[0] = mp_condition_variable_signal(ecl_cmp_symbol_value(cl_env_copy,VV[34]));
      ecl_bds_unwind1(cl_env_copy);
      }
     }
     ecl_frs_pop(cl_env_copy);
     ecl_stack_frame_push_values(_ecl_inner_frame);
     mp_giveup_lock(v2);
     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 L14;
   }
   si_check_pending_interrupts();
L14:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2778release_console_va(cl_narg narg, cl_object v3process, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[46]);
 {
  return L2778release_console(v3process);
 }
}
/* local function WITH-GRABBED-CONSOLE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2779with_grabbed_console(cl_object v1, cl_object v2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cdr(v1);
  T0 = cl_listX(4, ECL_SYM("WITH-RESTORED-INTERRUPTS",1833), VV[49], VV[50], v3);
  T1 = cl_listX(3, ECL_SYM("UNWIND-PROTECT",892), T0, VV[51]);
  value0 = cl_list(2, ECL_SYM("WITHOUT-INTERRUPTS",1832), T1);
  return value0;
 }
}
static cl_object LC2779with_grabbed_console_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[48]);
 {
  return LC2779with_grabbed_console(v4, v5);
 }
}
/* function definition for SIMPLE-TERMINAL-INTERRUPT                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2780simple_terminal_interrupt()
{
 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_error(1, ECL_SYM("INTERACTIVE-INTERRUPT",1741));
 return value0;
}
static cl_object L2780simple_terminal_interrupt_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[55]);
 {
  return L2780simple_terminal_interrupt();
 }
}
/* function definition for SHOW-PROCESS-LIST                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2781show_process_list(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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[57]);
 {
  cl_object v1process_list;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1process_list = mp_all_processes();
   } else {
    i++;
    v1process_list = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2current;
   v2current = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442));
   {
    cl_object v3rank;
    v3rank = ecl_make_int8_t(1);
    {
     cl_object v4;
     cl_object v5process;
     cl_object v6;
     {
      cl_object v7;
      v7 = v1process_list;
      if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v4 = v7;
     }
     v5process = ECL_NIL;
     v6 = v4;
L9:;
     if (!(ecl_endp(v6))){
      goto L11;
     }
     goto L10;
L11:;
     v5process = 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;
     }
     if (!((v5process)==(v2current))){
      goto L21;
     }
     T0 = VV[59];
     goto L20;
L21:;
     T0 = VV[60];
L20:;
     L2772tpl_format(3, T0, v3rank, v5process);
     v3rank = ecl_one_plus(v3rank);
     goto L9;
L10:;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
  }
 }
}
/* function definition for QUERY-PROCESS                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2782query_process(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[63]);
 {
  cl_object v1process_list;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1process_list = mp_all_processes();
   } else {
    i++;
    v1process_list = va_arg(args,cl_object);
   }
  }
  va_end(args);
  L2772tpl_format(1, VV[64]);
  {
   cl_object v2code;
   v2code = ECL_NIL;
L4:;
   L2781show_process_list(1, v1process_list);
   L2798tpl_prompt();
   v2code = L2797tpl_read();
   if (!(ecl_zerop(v2code))){
    goto L10;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L10:;
   if (!(ECL_FIXNUMP(v2code))){
    goto L12;
   }
   {
    cl_fixnum v3;
    v3 = ecl_length(v1process_list);
    if (Null(cl_LE(3, ecl_make_int8_t(1), v2code, ecl_make_fixnum(v3)))){
     goto L12;
    }
   }
   T0 = ecl_one_minus(v2code);
   T1 = ecl_elt(v1process_list,ecl_to_size(T0));
   value0 = ecl_list1(T1);
   cl_env_copy->nvalues = 1;
   return value0;
L12:;
   L2772tpl_format(1, VV[67]);
   goto L4;
  }
 }
}
/* function definition for SINGLE-THREADED-TERMINAL-INTERRUPT                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2784single_threaded_terminal_interrupt()
{
 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:;
 {
  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 L2;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v1;
     v1 = ecl_make_cclosure_va((cl_objectfn)LC2783__lambda90,env2,Cblock,0);
     T0 = v1;
    }
    T1 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(4, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), 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* */
    value0 = L2780simple_terminal_interrupt();
    ecl_frs_pop_n(cl_env_copy, 1);
    ecl_bds_unwind1(cl_env_copy);
    return value0;
L2:;
    {
     cl_object v1;
     v1 = ECL_CONS_CAR(CLV0);
     if (Null(v1)){
      goto L7;
     }
     value0 = si_dm_too_many_arguments(ECL_NIL);
     ecl_frs_pop_n(cl_env_copy, 1);
     return value0;
L7:;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     ecl_frs_pop_n(cl_env_copy, 1);
     return value0;
    }
    }
   }
  }
 }
}
static cl_object L2784single_threaded_terminal_interrupt_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[70]);
 {
  return L2784single_threaded_terminal_interrupt();
 }
}
/* function definition for TERMINAL-INTERRUPT                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2789terminal_interrupt(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1, CLV2;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object volatile v1correctablep;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L2789terminal_interruptkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[1])) {
    v1correctablep = ECL_T;
   } else {
    v1correctablep = keyvars[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 cl_object v2;
    ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),ECL_NIL); /*  *INTERRUPTS-ENABLED* */
    v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),ECL_NIL); /*  *ALLOW-WITH-INTERRUPTS* */
    {
     volatile cl_object v3suspended;
     volatile cl_object v4break_process;
     volatile cl_object env1 = env0;
     v3suspended = ECL_NIL;
     v4break_process = ECL_NIL;
     {
      cl_object v5this;
      v5this = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442));
      {
       cl_object v6;
       cl_object v7p;
       cl_object v8;
       v6 = mp_all_processes();
       v7p = ECL_NIL;
       v8 = v6;
       {
        cl_object v9;
        cl_object v10;
        v9 = ecl_list1(ECL_NIL);
        v10 = v9;
L13:;
        if (!(ecl_endp(v8))){
         goto L15;
        }
        goto L14;
L15:;
        v7p = ECL_CONS_CAR(v8);
        {
         cl_object v11;
         v11 = ECL_CONS_CDR(v8);
         if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v8 = v11;
        }
        if ((v7p)==(v5this)) {
         goto L23;
        }
        {
         cl_object v11;
         v11 = mp_process_name(v7p);
         if (!((v11)==(ECL_SYM("SIGNAL-SERVICING",1871)))){
          goto L29;
         }
         goto L23;
L29:;
         goto L27;
L27:;
         if (!((v11)==(ECL_SYM("HANDLE-SIGNAL",1830)))){
          goto L32;
         }
         goto L23;
L32:;
         goto L24;
        }
L24:;
        {
         cl_object v11;
         v11 = v10;
         if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T1 = v11;
        }
        v10 = ecl_list1(v7p);
        (ECL_CONS_CDR(T1)=v10,T1);
L23:;
        goto L13;
L14:;
        T0 = ecl_cdr(v9);
        goto L6;
       }
      }
     }
L6:;
     env1 = ECL_NIL;
     CLV0 = env1 = CONS(T0,env1);                 /*  ALL-PROCESSES           */
     {
      cl_fixnum v5;
      v5 = ecl_length(ECL_CONS_CAR(CLV0));
      if (!((v5)==((cl_fixnum)(1)))){
       goto L40;
      }
     }
     if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[69]))){
      goto L40;
     }
     T0 = ecl_car(ECL_CONS_CAR(CLV0));
     T1 = (VV[70]->symbol.gfdef);
     mp_interrupt_process(T0, T1);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     ecl_stack_frame_close(_ecl_inner_frame);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
     return value0;
L40:;
     {
      cl_object v5;
      cl_object v6i;
      cl_object v7;
      {
       cl_object v8;
       v8 = ECL_CONS_CAR(CLV0);
       if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v5 = v8;
      }
      v6i = ECL_NIL;
      v7 = v5;
L51:;
      if (!(ecl_endp(v7))){
       goto L53;
      }
      goto L52;
L53:;
      v6i = ECL_CONS_CAR(v7);
      {
       cl_object v8;
       v8 = ECL_CONS_CDR(v7);
       if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v7 = v8;
      }
      L2772tpl_format(2, VV[81], v6i);
      v3suspended = CONS(v6i,v3suspended);
      mp_process_suspend(v6i);
      goto L51;
L52:;
     }
     {
      cl_object volatile v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC2785do_query_process,env1,Cblock,0);
      ecl_bds_bind(cl_env_copy,ECL_SYM("*ALLOW-WITH-INTERRUPTS*",1821),v2); /*  *ALLOW-WITH-INTERRUPTS* */
      ecl_bds_bind(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7),v2); /*  *INTERRUPTS-ENABLED* */
      if (Null(v2)){
       goto L67;
      }
      si_check_pending_interrupts();
L67:;
      {
       volatile cl_object env2 = env1;
       CLV1 = env2 = CONS(ECL_NIL,env2);
       {
        volatile cl_object env3 = env2;
        CLV2 = env3 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env3); /*  TAGBODY   */
        {
         ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV2));
         if (__ecl_frs_push_result!=0) {
         if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
          goto L69;
         }
         if (cl_env_copy->values[0]==ecl_make_int8_t(1)) {
          goto L70;
         }
         ecl_internal_error("GO found an inexistent tag");
         } else {
         {
          cl_object v6;
          v6 = ecl_make_cclosure_va((cl_objectfn)LC2786__lambda130,env3,Cblock,0);
          T0 = v6;
         }
         T1 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(4, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1273), T0) /*  MAKE-RESTART */;
         {
          cl_object v6;
          v6 = ecl_make_cclosure_va((cl_objectfn)LC2787__lambda132,env3,Cblock,0);
          T2 = v6;
         }
         {
          cl_object v6;
          v6 = ecl_make_cfun_va((cl_objectfn)LC2788__lambda134_va,ECL_NIL,Cblock,1);
          T3 = v6;
         }
         T4 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(8, ECL_SYM("NAME",1309), ECL_SYM("INTERRUPT-PROCESS",1471), ECL_SYM("FUNCTION",1273), T2, VV[86], T3, VV[89], v5) /*  MAKE-RESTART */;
         T5 = cl_list(2, T1, T4);
         T6 = CONS(T5,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
         ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T6); /*  *RESTART-CLUSTERS* */
         L2780simple_terminal_interrupt();
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         ecl_bds_unwind1(cl_env_copy);
         goto L66;
L69:;
         {
          cl_object v6;
          v6 = ECL_CONS_CAR(CLV1);
          if (Null(v6)){
          goto L77;
          }
          si_dm_too_many_arguments(ECL_NIL);
L77:;
          v4break_process = ECL_NIL;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          ecl_bds_unwind1(cl_env_copy);
          goto L66;
         }
L70:;
         {
          cl_object v6;
          cl_object v7process;
          v6 = ECL_CONS_CAR(CLV1);
          if (Null(v6)){
          goto L83;
          }
          {
          cl_object v8;
          v8 = v6;
          {
          cl_object v9;
          v9 = v8;
          {
          bool v10;
          v10 = ECL_LISTP(v9);
          if (ecl_unlikely(!(v10)))
         FEwrong_type_argument(VV[92],v9);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          }
          }
          if (Null(v8)){
          goto L89;
          }
          {
          cl_object v9;
          v9 = ECL_CONS_CDR(v8);
          v6 = v9;
          v8 = ECL_CONS_CAR(v8);
          }
L89:;
          v7process = v8;
          goto L82;
          }
L83:;
          v7process = si_dm_too_few_arguments(ECL_NIL);
L82:;
          if (Null(v6)){
          goto L95;
          }
          si_dm_too_many_arguments(ECL_NIL);
L95:;
          v4break_process = v7process;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          ecl_bds_unwind1(cl_env_copy);
          goto L66;
         }
         }
        }
       }
      }
     }
L66:;
     {
      cl_object v5;
      cl_object v6process;
      cl_object v7;
      {
       cl_object v8;
       v8 = v3suspended;
       if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v5 = v8;
      }
      v6process = ECL_NIL;
      v7 = v5;
L104:;
      if (!(ecl_endp(v7))){
       goto L106;
      }
      goto L105;
L106:;
      v6process = ECL_CONS_CAR(v7);
      {
       cl_object v8;
       v8 = ECL_CONS_CDR(v7);
       if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v7 = v8;
      }
      if ((v6process)==(v4break_process)) {
       goto L114;
      }
      mp_process_resume(v6process);
L114:;
      goto L104;
L105:;
     }
     if (Null(v4break_process)){
      goto L117;
     }
     T0 = (VV[70]->symbol.gfdef);
     cl_env_copy->values[0] = mp_interrupt_process(v4break_process, T0);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
     goto L2;
L117:;
     cl_env_copy->values[0] = ECL_NIL;
     cl_env_copy->nvalues = 1;
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
    }
   }
L2:;
   ecl_stack_frame_push_values(_ecl_inner_frame);
   if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INTERRUPTS-ENABLED*",7)))){
    goto L120;
   }
   si_check_pending_interrupts();
L120:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for TPL                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2796tpl(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object volatile env0 = ECL_NIL;
 volatile struct ecl_cclosure aux_closure;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object volatile v1broken_at;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[8];
   cl_parse_key(args,4,L2796tplkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[4])) {
    ecl_bds_bind(cl_env_copy,VV[21],ecl_cmp_symbol_value(cl_env_copy,VV[19])); /*  *TPL-COMMANDS* */
   } else {
    ecl_bds_bind(cl_env_copy,VV[21],keyvars[0]);  /*  *TPL-COMMANDS*          */
   }
   if (Null(keyvars[5])) {
    ecl_bds_push(cl_env_copy,VV[10]);             /*  *TPL-PROMPT-HOOK*       */
   } else {
    ecl_bds_bind(cl_env_copy,VV[10],keyvars[1]);  /*  *TPL-PROMPT-HOOK*       */
   }
   v1broken_at = keyvars[2];
   env0 = ECL_NIL;
   CLV0 = env0 = CONS(keyvars[3],env0);           /*  QUIET                   */
  }
  {
   volatile cl_object env1 = env0;
   ecl_bds_bind(cl_env_copy,VV[4],ecl_cmp_symbol_value(cl_env_copy,VV[5])); /*  *IHS-BASE* */
   if (Null(v1broken_at)){
    goto L2;
   }
   T0 = L2843ihs_search(2, ECL_T, v1broken_at);
   goto L1;
L2:;
   T0 = si_ihs_top();
L1:;
   ecl_bds_bind(cl_env_copy,VV[5],T0);            /*  *IHS-TOP*               */
   if (Null(v1broken_at)){
    goto L5;
   }
   T0 = si_ihs_prev(ecl_cmp_symbol_value(cl_env_copy,VV[5]));
   goto L4;
L5:;
   T0 = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
L4:;
   ecl_bds_bind(cl_env_copy,VV[6],T0);            /*  *IHS-CURRENT*           */
   value0 = si_sch_frs_base(ecl_cmp_symbol_value(cl_env_copy,VV[8]), ecl_cmp_symbol_value(cl_env_copy,VV[4]));
   if (value0!=ECL_NIL) {
    goto L9;
   }
   T1 = si_frs_top();
   T0 = ecl_one_plus(T1);
   goto L7;
L9:;
   T0 = value0;
   goto L7;
L7:;
   ecl_bds_bind(cl_env_copy,VV[7],T0);            /*  *FRS-BASE*              */
   T0 = si_frs_top();
   ecl_bds_bind(cl_env_copy,VV[8],T0);            /*  *FRS-TOP*               */
   T0 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)),ecl_cmp_symbol_value(cl_env_copy,VV[0]));
   ecl_bds_bind(cl_env_copy,VV[0],T0);            /*  *QUIT-TAGS*             */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836),ecl_cmp_symbol_value(cl_env_copy,VV[0])); /*  *QUIT-TAG* */
   T0 = ecl_one_plus(ecl_cmp_symbol_value(cl_env_copy,VV[16]));
   ecl_bds_bind(cl_env_copy,VV[16],T0);           /*  *TPL-LEVEL*             */
   CLV1 = env1 = CONS(ecl_cmp_symbol_value(cl_env_copy,VV[1]),env1); /*  BREAK-LEVEL */
   CLV2 = env1 = CONS(ECL_NIL,env1);              /*  VALUES                  */
   L2842set_break_env();
   L2841set_current_ihs();
L13:;
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("++",17));
   ecl_cmp_setq(cl_env_copy,ECL_SYM("+++",18),T0);
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+",16));
   ecl_cmp_setq(cl_env_copy,ECL_SYM("++",17),T0);
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("-",19));
   ecl_cmp_setq(cl_env_copy,ECL_SYM("+",16),T0);
   value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)); /*  BEGIN CATCH CATCH649 */
   {
    ecl_frs_push(cl_env_copy,value0);
    if (__ecl_frs_push_result!=0) {
     value0 = cl_env_copy->values[0];
    } else {
     if (!(ecl_zerop(ECL_CONS_CAR(CLV1)))){
      goto L26;
     }
     {
      volatile cl_object env2 = env1;
      CLV3 = env2 = CONS(ECL_NIL,env2);
      {
       volatile cl_object env3 = env2;
       CLV4 = env3 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env3); /*  TAGBODY    */
       {
        ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV4));
        if (__ecl_frs_push_result!=0) {
        if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
         goto L28;
        }
        ecl_internal_error("GO found an inexistent tag");
        } else {
        {
         cl_object v2;
         v2 = ecl_make_cclosure_va((cl_objectfn)LC2792__lambda168,env3,Cblock,0);
         T0 = v2;
        }
        {
         cl_object v2;
         v2 = ecl_make_cfun_va((cl_objectfn)LC2793__lambda170_va,ECL_NIL,Cblock,1);
         T1 = v2;
        }
        T2 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(6, ECL_SYM("NAME",1309), VV[105], ECL_SYM("FUNCTION",1273), T0, VV[86], T1) /*  MAKE-RESTART */;
        T3 = ecl_list1(T2);
        T4 = CONS(T3,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
        ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T4); /*  *RESTART-CLUSTERS* */
        (aux_closure.env=ecl_nthcdr(2,env3),cl_env_copy->function=(cl_object)&aux_closure,LC2791rep(0));
        ecl_frs_pop_n(cl_env_copy, 1);
        ecl_bds_unwind1(cl_env_copy);
        goto L25;
L28:;
        {
         cl_object v2;
         v2 = ECL_CONS_CAR(CLV3);
         if (Null(v2)){
          goto L34;
         }
         si_dm_too_many_arguments(ECL_NIL);
L34:;
         ecl_frs_pop_n(cl_env_copy, 1);
         goto L25;
        }
        }
       }
      }
     }
L26:;
     {
      volatile cl_object env2 = env1;
      CLV3 = env2 = CONS(ECL_NIL,env2);
      {
       volatile cl_object env3 = env2;
       CLV4 = env3 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env3); /*  TAGBODY    */
       {
        ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV4));
        if (__ecl_frs_push_result!=0) {
        if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
         goto L38;
        }
        ecl_internal_error("GO found an inexistent tag");
        } else {
        {
         cl_object v2;
         v2 = ecl_make_cclosure_va((cl_objectfn)LC2794__lambda177,env3,Cblock,0);
         T0 = v2;
        }
        {
         cl_object v2;
         v2 = ecl_make_cclosure_va((cl_objectfn)LC2795__lambda179,env3,Cblock,1);
         T1 = v2;
        }
        T2 = (cl_env_copy->function=(VV[72]->symbol.gfdef))->cfun.entry(6, ECL_SYM("NAME",1309), VV[110], ECL_SYM("FUNCTION",1273), T0, VV[86], T1) /*  MAKE-RESTART */;
        T3 = ecl_list1(T2);
        T4 = CONS(T3,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
        ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T4); /*  *RESTART-CLUSTERS* */
        (aux_closure.env=ecl_nthcdr(2,env3),cl_env_copy->function=(cl_object)&aux_closure,LC2791rep(0));
        ecl_frs_pop_n(cl_env_copy, 1);
        ecl_bds_unwind1(cl_env_copy);
        goto L25;
L38:;
        {
         cl_object v2;
         v2 = ECL_CONS_CAR(CLV3);
         if (Null(v2)){
          goto L44;
         }
         si_dm_too_many_arguments(ECL_NIL);
L44:;
         ecl_frs_pop_n(cl_env_copy, 1);
         goto L25;
        }
        }
       }
      }
     }
L25:;
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
    }
   }
   ecl_frs_pop(cl_env_copy);                      /*  END CATCH CATCH649      */
   if (Null(value0)){
    goto L14;
   }
   ECL_CONS_CAR(CLV0) = ECL_NIL;
L14:;
   goto L13;
  }
 }
}
/* function definition for TPL-READ                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2797tpl_read()
{
 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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*READ-SUPPRESS*",66),ECL_NIL); /*  *READ-SUPPRESS* */
 cl_finish_output(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
L3:;
 {
  cl_object v1;
  v1 = cl_peek_char(4, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), ECL_NIL, ECL_SYM("EOF",1259));
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(41))))){
   goto L6;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(1, VV[116]) /*  WARN */;
  cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  goto L4;
L6:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(32))))){
   goto L15;
  }
  goto L12;
L15:;
  goto L13;
L13:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(9))))){
   goto L10;
  }
  goto L11;
L12:;
L11:;
  cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  goto L4;
L10:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(10))))){
   goto L23;
  }
  goto L20;
L23:;
  goto L21;
L21:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(13))))){
   goto L18;
  }
  goto L19;
L20:;
L19:;
  cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  {
   cl_object v2command;
   v2command = L2800tpl_make_command(VV[122], VV[123]);
   if (Null(v2command)){
    goto L4;
   }
   value0 = v2command;
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
L18:;
  if (!((v1)==(ECL_SYM("EOF",1259)))){
   goto L29;
  }
  (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
  value0 = L2800tpl_make_command(ECL_SYM("EOF",1259), VV[123]);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L29:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(58))))){
   goto L32;
  }
  T0 = cl_read_preserving_whitespace(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  T1 = cl_read_line(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  value0 = L2800tpl_make_command(T0, T1);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L32:;
  if (!(((v1)==ECL_CODE_CHAR((ecl_character)(63))))){
   goto L34;
  }
  cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  {
   cl_object v3;
   v3 = cl_peek_char(4, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), ECL_NIL, ECL_SYM("EOF",1259));
   {
    cl_object v4;
    cl_object v5;
    v4 = v3;
    v5 = VV[124];
    if (Null(ecl_memql(v4,v5))){
     goto L38;
    }
   }
   T0 = cl_read_line(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   value0 = L2800tpl_make_command(VV[125], T0);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
L38:;
   cl_unread_char(2, ECL_CODE_CHAR(63), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   value0 = cl_read_preserving_whitespace(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
L34:;
  value0 = cl_read(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
L4:;
 goto L3;
}
static cl_object L2797tpl_read_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[66]);
 {
  return L2797tpl_read();
 }
}
/* function definition for TPL-PROMPT                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2798tpl_prompt()
{
 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 v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[10]);
  if (Null(cl_functionp(v1))){
   goto L3;
  }
  value0 = ecl_function_dispatch(cl_env_copy,ecl_cmp_symbol_value(cl_env_copy,VV[10]))(0);
  return value0;
L3:;
  if (!(ECL_STRINGP(v1))){
   goto L5;
  }
  value0 = L2772tpl_format(1, ecl_cmp_symbol_value(cl_env_copy,VV[10]));
  return value0;
L5:;
  T1 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PACKAGE*",45));
  T2 = cl_find_package(VV[128]);
  if (!((T1)==(T2))){
   goto L8;
  }
  T0 = VV[123];
  goto L7;
L8:;
  T0 = cl_package_name(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PACKAGE*",45)));
L7:;
  T1 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,VV[16]),ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035)));
  T2 = ecl_minus(T1,ecl_make_int8_t(-1));
  value0 = L2772tpl_format(4, VV[127], T0, T2, VV[123]);
  return value0;
 }
}
static cl_object L2798tpl_prompt_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[65]);
 {
  return L2798tpl_prompt();
 }
}
/* function definition for HARDEN-COMMAND                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2799harden_command(cl_object v1cmd_form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_list(3, ECL_SYM("HANDLER-CASE",418), v1cmd_form, VV[132]);
 value0 = cl_list(4, ECL_SYM("IF",950), VV[130], v1cmd_form, T0);
 return value0;
}
static cl_object L2799harden_command_va(cl_narg narg, cl_object v2cmd_form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[131]);
 {
  return L2799harden_command(v2cmd_form);
 }
}
/* function definition for TPL-MAKE-COMMAND                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2800tpl_make_command(cl_object v1name, cl_object v2line)
{
 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 v3c;
  v3c = ECL_NIL;
  {
   cl_object v4;
   v4 = ecl_cmp_symbol_value(cl_env_copy,VV[21]);
   goto L7;
L6:;
   {
    cl_object v5commands;
    v5commands = ecl_car(v4);
    {
     cl_object v6;
     cl_object v7;
     v6 = ecl_cdr(v5commands);
     v7 = (ECL_SYM("MEMBER",554)->symbol.gfdef);
     {
      cl_object v8;
      v8 = v6;
      goto L19;
L18:;
      {
       cl_object v9;
       cl_object v10;
       {
        cl_object v11;
        v11 = v8;
        if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v9 = v11;
       }
       v10 = ECL_CONS_CAR(v9);
       if (Null(v10)){
        goto L21;
       }
       {
        cl_object v11;
        {
         cl_object v12;
         v12 = v10;
         if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T0 = v12;
        }
        v11 = ECL_CONS_CAR(T0);
        {
         cl_object v12;
         cl_object v13;
         v12 = v1name;
         v13 = v11;
         if (Null(ecl_memql(v12,v13))){
          goto L21;
         }
        }
        v3c = v10;
        goto L13;
       }
      }
L21:;
      v8 = ECL_CONS_CDR(v8);
L19:;
      if (v8==ECL_NIL) {
       goto L36;
      }
      goto L18;
L36:;
      v3c = ECL_NIL;
     }
    }
L13:;
    if (Null(v3c)){
     goto L11;
    }
    goto L3;
L11:;
   }
   v4 = ecl_cdr(v4);
L7:;
   if (Null(v4)){
    goto L40;
   }
   goto L6;
L40:;
  }
L3:;
  if (!(v3c==ECL_NIL)){
   goto L42;
  }
  if (!((v1name)==(VV[122]))){
   goto L44;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L44:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v1name);
  value0 = cl_list(2, VV[135], T0);
  return value0;
L42:;
  T0 = ecl_caddr(v3c);
  if (!((T0)==(VV[136]))){
   goto L46;
  }
  T0 = ecl_cadr(v3c);
  T1 = cl_list(2, ECL_SYM("INVOKE-RESTART-INTERACTIVELY",449), T0);
  value0 = cl_list(2, ECL_SYM("PROGN",674), T1);
  return value0;
L46:;
  T0 = ecl_caddr(v3c);
  if (!((T0)==(VV[137]))){
   goto L48;
  }
  T0 = ecl_cadr(v3c);
  T1 = L2801tpl_parse_forms(1, v2line);
  value0 = CONS(T0,T1);
  cl_env_copy->nvalues = 1;
  return value0;
L48:;
  T0 = ecl_caddr(v3c);
  if (!((T0)==(VV[139]))){
   goto L50;
  }
  T0 = ecl_cadr(v3c);
  T1 = L2803tpl_parse_strings(v2line);
  T2 = CONS(T0,T1);
  value0 = L2799harden_command(T2);
  return value0;
L50:;
  T0 = ecl_caddr(v3c);
  if (!((T0)==(VV[141]))){
   goto L52;
  }
  T0 = ecl_cadr(v3c);
  value0 = L2799harden_command(T0);
  return value0;
L52:;
  T0 = ecl_cadr(v3c);
  T1 = L2801tpl_parse_forms(2, v2line, ECL_T);
  T2 = CONS(T0,T1);
  value0 = L2799harden_command(T2);
  return value0;
 }
}
static cl_object L2800tpl_make_command_va(cl_narg narg, cl_object v4name, cl_object v5line, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[121]);
 {
  return L2800tpl_make_command(v4name, v5line);
 }
}
/* function definition for TPL-PARSE-FORMS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2801tpl_parse_forms(volatile cl_narg narg, cl_object volatile v1line, ...)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[138]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[138]);
 {
  cl_object volatile v2quote;
  va_list args; va_start(args,v1line);
  {
   int i = 1;
   if (i >= narg) {
    v2quote = ECL_NIL;
   } else {
    i++;
    v2quote = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   volatile cl_object v3stream;
   v3stream = cl_make_string_input_stream(3, v1line, ecl_make_int8_t(0), ECL_NIL);
   {
    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 v4;
      cl_object v5form;
      cl_object v6list;
      v4 = cl_read(3, v3stream, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,VV[11]));
      v5form = v4;
      v6list = ECL_NIL;
      goto L9;
L8:;
      if (Null(v2quote)){
       goto L14;
      }
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v5form);
      goto L13;
L14:;
      T0 = v5form;
L13:;
      v6list = CONS(T0,v6list);
      v5form = cl_read(3, v3stream, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,VV[11]));
L9:;
      if ((v5form)==(ecl_cmp_symbol_value(cl_env_copy,VV[11]))) {
       goto L18;
      }
      goto L8;
L18:;
      cl_env_copy->values[0] = cl_nreverse(v6list);
     }
     }
    }
    ecl_frs_pop(cl_env_copy);
    ecl_stack_frame_push_values(_ecl_inner_frame);
    cl_close(1, v3stream);
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    if (unwinding) ecl_unwind(cl_env_copy,next_fr);
    ecl_stack_frame_close(_ecl_inner_frame);
    return cl_env_copy->values[0];
   }
  }
 }
}
/* function definition for TPL-PARSE-STRINGS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2803tpl_parse_strings(cl_object v1line)
{
 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;
  cl_object v3;
  cl_object v4i;
  cl_object v5start;
  cl_object v6end;
  cl_object v7list;
  {
   cl_object v8;
   v8 = ecl_make_cfun_va((cl_objectfn)LC2802__lambda272_va,ECL_NIL,Cblock,1);
   v2 = v8;
  }
  v3 = ecl_make_fixnum(ecl_length(v1line));
  v4i = ecl_make_int8_t(0);
  v5start = ECL_NIL;
  v6end = ECL_NIL;
  v7list = ECL_NIL;
  goto L10;
L9:;
  v5start = cl_position_if_not(4, v2, v1line, ECL_SYM("START",1347), v4i);
  if (!(v5start==ECL_NIL)){
   goto L13;
  }
  v6end = v3;
  goto L12;
L13:;
  T0 = ecl_elt(v1line,ecl_to_size(v5start));
  if (!((ECL_CHAR_CODE(T0))==((ecl_character)(34)))){
   goto L17;
  }
  {
   cl_object v8;                                  /*  STRING                  */
   cl_object v9;                                  /*  N                       */
   value0 = cl_read_from_string(5, v1line, ECL_T, ECL_NIL, ECL_SYM("START",1347), v5start);
   {
    v8 = value0;
    v9 = cl_env_copy->values[1];
   }
   v7list = CONS(v8,v7list);
   v6end = v9;
   goto L12;
  }
L17:;
  value0 = cl_position_if(4, v2, v1line, ECL_SYM("START",1347), v5start);
  if (value0!=ECL_NIL) {
   goto L26;
  }
  v6end = v3;
  goto L24;
L26:;
  v6end = value0;
  goto L24;
L24:;
  T0 = cl_subseq(3, v1line, v5start, v6end);
  v7list = CONS(T0,v7list);
L12:;
  v4i = v6end;
L10:;
  if (ecl_greatereq(v4i,v3)) {
   goto L31;
  }
  goto L9;
L31:;
  value0 = cl_nreverse(v7list);
  return value0;
 }
}
static cl_object L2803tpl_parse_strings_va(cl_narg narg, cl_object v8line, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[140]);
 {
  return L2803tpl_parse_strings(v8line);
 }
}
/* function definition for TPL-UNKNOWN-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2804tpl_unknown_command(cl_object v1command)
{
 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:;
 L2772tpl_format(2, VV[146], v1command);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2804tpl_unknown_command_va(cl_narg narg, cl_object v2command, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[135]);
 {
  return L2804tpl_unknown_command(v2command);
 }
}
/* function definition for TPL-POP-COMMAND                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2805tpl_pop_command(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  va_list args; va_start(args,narg);
  va_end(args);
  {
   cl_object v1;
   v1 = ecl_cmp_symbol_value(cl_env_copy,VV[0]);
   {
    cl_object v2;
    v2 = v1;
    {
     bool v3;
     v3 = ECL_LISTP(v2);
     if (ecl_unlikely(!(v3)))
         FEwrong_type_argument(VV[92],v2);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v1)){
    goto L6;
   }
   {
    cl_object v2;
    v2 = ECL_CONS_CDR(v1);
    T1 = v2;
    ecl_cmp_setq(cl_env_copy,VV[0],T1);
    v1 = ECL_CONS_CAR(v1);
   }
L6:;
   T0 = v1;
  }
  cl_env_copy->values[0] = ECL_T;
  cl_env_copy->nvalues = 1;
  cl_throw(T0);
 }
}
/* function definition for TPL-QUIT-COMMAND                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2806tpl_quit_command(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[150]);
 {
  cl_object v1level;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1level = ecl_make_int8_t(0);
   } else {
    i++;
    v1level = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(ecl_greatereq(v1level,ecl_make_int8_t(0)))){
   goto L2;
  }
  if (!(ecl_lower(v1level,ecl_cmp_symbol_value(cl_env_copy,VV[16])))){
   goto L2;
  }
  {
   cl_object v2x;
   T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,VV[16]),v1level);
   T1 = ecl_minus(T0,ecl_make_int8_t(1));
   v2x = ecl_nth(ecl_to_size(T1),ecl_cmp_symbol_value(cl_env_copy,VV[0]));
   cl_env_copy->values[0] = v2x;
   cl_env_copy->nvalues = 1;
   cl_throw(v2x);
  }
L2:;
  value0 = L2833tpl_print_current();
  return value0;
 }
}
/* function definition for TPL-PREVIOUS                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2807tpl_previous(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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[153]);
 {
  cl_object v1n;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1n = ecl_make_int8_t(1);
   } else {
    i++;
    v1n = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2i;
   v2i = si_ihs_prev(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
   goto L6;
L5:;
   if (Null(L2839ihs_visible(v2i))){
    goto L8;
   }
   T0 = v2i;
   ecl_cmp_setq(cl_env_copy,VV[6],T0);
   v1n = ecl_minus(v1n,ecl_make_int8_t(1));
L8:;
   v2i = si_ihs_prev(v2i);
L6:;
   if (ecl_lower(v2i,ecl_cmp_symbol_value(cl_env_copy,VV[4]))) {
    goto L15;
   }
   if (ecl_lowereq(v1n,ecl_make_int8_t(0))) {
    goto L15;
   }
   goto L5;
L15:;
  }
  L2842set_break_env();
  value0 = L2833tpl_print_current();
  return value0;
 }
}
/* function definition for TPL-NEXT                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2808tpl_next(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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[156]);
 {
  cl_object v1n;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1n = ecl_make_int8_t(1);
   } else {
    i++;
    v1n = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2i;
   v2i = si_ihs_next(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
   goto L6;
L5:;
   if (Null(L2839ihs_visible(v2i))){
    goto L8;
   }
   T0 = v2i;
   ecl_cmp_setq(cl_env_copy,VV[6],T0);
   v1n = ecl_minus(v1n,ecl_make_int8_t(1));
L8:;
   v2i = si_ihs_next(v2i);
L6:;
   if (ecl_greater(v2i,ecl_cmp_symbol_value(cl_env_copy,VV[5]))) {
    goto L15;
   }
   if (ecl_lowereq(v1n,ecl_make_int8_t(0))) {
    goto L15;
   }
   goto L5;
L15:;
  }
  L2842set_break_env();
  value0 = L2833tpl_print_current();
  return value0;
 }
}
/* function definition for TPL-GO                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2809tpl_go(cl_object v1ihs_index)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ((ecl_float_nan_p(ecl_cmp_symbol_value(cl_env_copy,VV[4])) || ecl_greatereq(v1ihs_index,ecl_cmp_symbol_value(cl_env_copy,VV[4])))?v1ihs_index:ecl_cmp_symbol_value(cl_env_copy,VV[4]));
 T1 = ((ecl_float_nan_p(ecl_cmp_symbol_value(cl_env_copy,VV[5])) || ecl_lowereq(T0,ecl_cmp_symbol_value(cl_env_copy,VV[5])))?T0:ecl_cmp_symbol_value(cl_env_copy,VV[5]));
 ecl_cmp_setq(cl_env_copy,VV[6],T1);
 if (Null(L2839ihs_visible(ecl_cmp_symbol_value(cl_env_copy,VV[6])))){
  goto L4;
 }
 L2842set_break_env();
 value0 = L2833tpl_print_current();
 return value0;
L4:;
 value0 = L2807tpl_previous(0);
 return value0;
}
static cl_object L2809tpl_go_va(cl_narg narg, cl_object v2ihs_index, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[158]);
 {
  return L2809tpl_go(v2ihs_index);
 }
}
/* function definition for TPL-PRINT-MESSAGE                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2810tpl_print_message()
{
 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[13]))){
  goto L2;
 }
 L2772tpl_format(2, VV[161], ecl_cmp_symbol_value(cl_env_copy,VV[13]));
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2810tpl_print_message_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[160]);
 {
  return L2810tpl_print_message();
 }
}
/* function definition for TPL-DISASSEMBLE-COMMAND                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2811tpl_disassemble_command()
{
 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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(16)); /*  *PRINT-LENGTH* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_T); /*  *PRINT-PRETTY* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-ESCAPE*",50),ECL_NIL); /*  *PRINT-ESCAPE* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
 T0 = si_ihs_fun(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
 if (si_bc_disassemble(T0)!=ECL_NIL) {
  goto L2;
 }
 L2833tpl_print_current();
 L2772tpl_format(1, VV[164]);
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 ecl_bds_unwind_n(cl_env_copy,5);
 return value0;
}
static cl_object L2811tpl_disassemble_command_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[163]);
 {
  return L2811tpl_disassemble_command();
 }
}
/* function definition for TPL-LAMBDA-EXPRESSION-COMMAND                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2812tpl_lambda_expression_command()
{
 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 v1function;
  cl_object v2le;
  v1function = si_ihs_fun(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  v2le = cl_function_lambda_expression(v1function);
  if (Null(v2le)){
   goto L5;
  }
  cl_pprint(2, v2le, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  goto L4;
L5:;
  L2772tpl_format(1, VV[167]);
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
static cl_object L2812tpl_lambda_expression_command_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[166]);
 {
  return L2812tpl_lambda_expression_command();
 }
}
/* function definition for LAMBDA-LIST-FROM-ANNOTATIONS                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2813lambda_list_from_annotations(cl_object v1name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2args;
  v2args = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("GET-ANNOTATION",1864)))->cfun.entry(3, v1name, ECL_SYM("LAMBDA-LIST",1002), ECL_NIL) /*  GET-ANNOTATION */;
  if (Null(v2args)){
   goto L5;
  }
  T0 = ECL_T;
  goto L3;
L5:;
  T0 = ECL_NIL;
  goto L3;
L3:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T0;
  cl_env_copy->values[0] = v2args;
  return cl_env_copy->values[0];
 }
}
/* function definition for FUNCTION-LAMBDA-LIST                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2814function_lambda_list(cl_object v1function)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_SYMBOLP(v1function))){
  goto L2;
 }
 if (cl_special_operator_p(v1function)!=ECL_NIL) {
  goto L6;
 }
 if (Null(cl_macro_function(1, v1function))){
  goto L4;
 }
 goto L5;
L6:;
L5:;
 value0 = L2813lambda_list_from_annotations(v1function);
 return value0;
L4:;
 v1function = cl_fdefinition(v1function);
 goto L1;
L2:;
 if (Null(si_of_class_p(2, v1function, ECL_SYM("GENERIC-FUNCTION",949)))){
  goto L10;
 }
 if (Null(cl_slot_boundp(v1function, VV[170]))){
  goto L12;
 }
 T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-LAMBDA-LIST",1597)->symbol.gfdef))->cfun.entry(1, v1function) /*  GENERIC-FUNCTION-LAMBDA-LIST */;
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_T;
 cl_env_copy->values[0] = T0;
 return cl_env_copy->values[0];
L12:;
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_NIL;
 cl_env_copy->values[0] = ECL_NIL;
 return cl_env_copy->values[0];
L10:;
 {
  cl_object v2;
  {
   cl_object v3f;
   v3f = cl_function_lambda_expression(v1function);
   if (Null(v3f)){
    goto L16;
   }
   {
    cl_object v4list;
    cl_object v5ndx;
    T0 = ecl_car(v3f);
    if (!((T0)==(ECL_SYM("LAMBDA",454)))){
     goto L19;
    }
    v4list = ecl_cadr(v3f);
    goto L18;
L19:;
    v4list = ecl_caddr(v3f);
L18:;
    v5ndx = cl_position(2, ECL_SYM("&AUX",9), v4list);
    if (Null(v5ndx)){
     goto L23;
    }
    T1 = ecl_one_minus(v5ndx);
    T0 = cl_subseq(3, v4list, ecl_make_int8_t(0), T1);
    goto L22;
L23:;
    T0 = v4list;
L22:;
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = ECL_T;
    cl_env_copy->values[0] = T0;
    return cl_env_copy->values[0];
   }
L16:;
   v2 = ECL_NIL;
  }
  if (Null(v2)){
   goto L25;
  }
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
L25:;
  T0 = si_compiled_function_name(v1function);
  value0 = L2813lambda_list_from_annotations(T0);
  return value0;
 }
}
static cl_object L2814function_lambda_list_va(cl_narg narg, cl_object v3function, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[171]);
 {
  return L2814function_lambda_list(v3function);
 }
}
/* function definition for DECODE-ENV-ELT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2815decode_env_elt(cl_object v1env, cl_object v2ndx)
{
 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 v = v1env;
        cl_index ndx = ecl_to_fixnum(v2ndx);
        typedef struct ecl_var_debug_info *pinfo;
        pinfo d = (pinfo)(v->vector.self.t[1]) + ndx;
        cl_object name;
#ifdef ECL_UNICODE
        name = ecl_decode_from_cstring(d->name,-1,ECL_SYM("UTF-8",1759));
        if (!name)
#endif
                name = ecl_make_constant_base_string(d->name,-1);
        void *value = (void*)(v->vector.self.t[2+ndx]);
        cl_object output;
        switch (d->type) {
        case _ecl_object_loc:
                output = *((cl_object*)value);
                break;
        case _ecl_fixnum_loc: {
                cl_fixnum *p = (cl_fixnum*)value;
                output = ecl_make_integer(*p);
                break;
        }
        case _ecl_float_loc: {
                float *p = (float*)value;
                output = ecl_make_single_float(*p);
                break;
        }
        case _ecl_double_loc: {
                double *p = (double*)value;
                output = ecl_make_double_float(*p);
                break;
        }
        case _ecl_long_double_loc: {
                long double *p = (long double*)value;
                output = ecl_make_long_float(*p);
                break;
        }
#ifdef ECL_COMPLEX_FLOAT
        case _ecl_csfloat_loc: {
                _Complex float *p = (_Complex float*)value;
                output = ecl_make_csfloat(*p);
                break;
        }
        case _ecl_cdfloat_loc: {
                _Complex double *p = (_Complex double*)value;
                output = ecl_make_cdfloat(*p);
                break;
        }
        case _ecl_clfloat_loc: {
                _Complex long double *p = (_Complex long double*)value;
                output = ecl_make_clfloat(*p);
                break;
        }
#endif
#ifdef ECL_SSE2
        case _ecl_int_sse_pack_loc: {
                __m128i *p = (__m128i*)value;
                output = ecl_make_int_sse_pack(_mm_loadu_si128(p));
                break;
        }
        case _ecl_float_sse_pack_loc: {
                __m128 *p = (__m128*)value;
                output = ecl_make_float_sse_pack(_mm_loadu_ps((float*)p));
                break;
        }
        case _ecl_double_sse_pack_loc: {
                __m128d *p = (__m128d*)value;
                output = ecl_make_double_sse_pack(_mm_loadu_pd((double*)p));
                break;
        }
#endif
        default: {
                ecl_base_char *p = (ecl_base_char*)value;
                output = ECL_CODE_CHAR(*p);
                break;
        }
        }
        v3= CONS(name,output);

  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2815decode_env_elt_va(cl_narg narg, cl_object v3env, cl_object v4ndx, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[172]);
 {
  return L2815decode_env_elt(v3env, v4ndx);
 }
}
/* function definition for DECODE-IHS-ENV                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2816decode_ihs_env(cl_object v1env)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (ECL_VECTORP(v1env)) {
  goto L4;
 }
 if (Null(si_of_class_p(2, v1env, ECL_SYM("FRAME",1685)))){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 value0 = L2817decode_ihs_locals(v1env);
 return value0;
L2:;
 if (!(ECL_FIXNUMP(v1env)||ECL_BIGNUMP(v1env))){
  goto L6;
 }
 T0 = si_ihs_lcl(v1env);
 T1 = L2817decode_ihs_locals(T0);
 T2 = si_ihs_lex(v1env);
 T3 = L2818decode_ihs_lexenv(T2);
 value0 = ecl_append(T1,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (!(v1env==ECL_NIL)){
  goto L8;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L8:;
 value0 = si_etypecase_error(v1env, VV[177]);
 return value0;
}
static cl_object L2816decode_ihs_env_va(cl_narg narg, cl_object v2env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[174]);
 {
  return L2816decode_ihs_env(v2env);
 }
}
/* function definition for DECODE-IHS-LOCALS                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2817decode_ihs_locals(cl_object v1env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = v1env;
  if (!(ECL_VECTORP(v2))){
   goto L3;
  }
  {
   cl_object v3next;
   T0 = (v1env)->vector.self.t[0];
   v3next = L2817decode_ihs_locals(T0);
   {
    cl_object v4l;
    {
     cl_fixnum v5;
     v5 = ecl_length(v1env);
     v4l = ecl_minus(ecl_make_fixnum(v5),ecl_make_int8_t(2));
    }
    {
     cl_object v5;
     cl_object v6i;
     v5 = v4l;
     v6i = ecl_make_int8_t(0);
L11:;
     if (!(ecl_greatereq(v6i,v5))){
      goto L13;
     }
     goto L12;
L13:;
     T1 = L2815decode_env_elt(v1env, v6i);
     v3next = CONS(T1,v3next);
     v6i = ecl_one_plus(v6i);
     goto L11;
L12:;
     T0 = ECL_NIL;
    }
   }
   value0 = cl_nreconc(T0, v3next);
   return value0;
  }
L3:;
  if (Null(si_of_class_p(2, v2, ECL_SYM("FRAME",1685)))){
   goto L20;
  }
  {
   cl_object v4lcls;
   v4lcls = ECL_NIL;
   loop_across_frame_fifo(elt, (v1env)) {
                        (v4lcls)=ecl_cons(elt, (v4lcls));
                      } end_loop_across_frame();
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   value0 = v4lcls;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L20:;
  if (!(v2==ECL_NIL)){
   goto L24;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L24:;
  value0 = si_etypecase_error(v2, VV[179]);
  return value0;
 }
}
static cl_object L2817decode_ihs_locals_va(cl_narg narg, cl_object v5env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[175]);
 {
  return L2817decode_ihs_locals(v5env);
 }
}
/* function definition for DECODE-IHS-LEXENV                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2818decode_ihs_lexenv(cl_object v1env)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_VECTORP(v1env))){
  goto L2;
 }
 {
  cl_object v2;
  cl_fixnum v3;
  cl_fixnum v4;
  cl_object v5elt;
  cl_fixnum v6;
  cl_fixnum v7;
  {
   cl_object v8;
   v8 = v1env;
   if (ecl_unlikely(!ECL_VECTORP(v8))) FEtype_error_vector(v8);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v2 = v8;
  }
  v3 = (cl_fixnum)(0);
  v4 = (cl_fixnum)(0);
  v5elt = ECL_NIL;
  v6 = v3;
  v7 = v4;
  {
   cl_object v8;
   cl_object v9;
   v8 = ecl_list1(ECL_NIL);
   v9 = v8;
   v7 = ecl_length(v2);
L14:;
   if (!((v6)>=(v7))){
    goto L18;
   }
   goto L15;
L18:;
   {
    cl_object v10;
    v10 = v2;
    T0 = v10;
    {
     cl_fixnum v11;
     v11 = v6;
     if (ecl_unlikely((v11)>=(v10)->vector.dim))
           FEwrong_index(ECL_NIL,v10,-1,ecl_make_fixnum(v11),(v10)->vector.dim);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = ecl_make_fixnum(v11);
    }
    v5elt = ecl_aref_unsafe(T0,ecl_fixnum(T1));
   }
   {
    cl_object v10;
    v10 = ecl_make_integer((v6)+1);
    {
     bool v11;
     v11 = ECL_FIXNUMP(v10);
     if (ecl_unlikely(!(v11)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v6 = ecl_fixnum(v10);
   }
   {
    cl_object v10;
    v10 = v9;
    if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v10;
   }
   v9 = ecl_list1(v5elt);
   (ECL_CONS_CDR(T0)=v9,T0);
   goto L14;
L15:;
   value0 = ecl_cdr(v8);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L2:;
 if (!(v1env==ECL_NIL)){
  goto L39;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L39:;
 value0 = si_etypecase_error(v1env, VV[183]);
 return value0;
}
static cl_object L2818decode_ihs_lexenv_va(cl_narg narg, cl_object v10env, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[176]);
 {
  return L2818decode_ihs_lexenv(v10env);
 }
}
/* function definition for IHS-ENVIRONMENT                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2823ihs_environment(cl_object v1ihs_index)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object env1 = env0;
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(ECL_NIL,env1);               /*  FUNCTIONS               */
  CLV1 = env1 = CONS(ECL_NIL,env1);               /*  BLOCKS                  */
  CLV2 = env1 = CONS(ECL_NIL,env1);               /*  LOCAL-VARIABLES         */
  CLV3 = env1 = CONS(ECL_NIL,env1);               /*  RECORD0                 */
  CLV4 = env1 = CONS(ECL_NIL,env1);               /*  RECORD1                 */
  {
   cl_object v2;
   v2 = ecl_make_cclosure_va((cl_objectfn)LC2822process_env_record,env1,Cblock,1);
   T0 = si_ihs_lcl(v1ihs_index);
   T1 = L2817decode_ihs_locals(T0);
   cl_map(3, ECL_NIL, v2, T1);
   T0 = si_ihs_lex(v1ihs_index);
   T1 = L2818decode_ihs_lexenv(T0);
   cl_map(3, ECL_NIL, v2, T1);
   {
    cl_object v3;                                 /*  SPECIAL-VARIABLES       */
    cl_object v4;                                 /*  RESTARTS                */
    T0 = LC2820special_variables_alist(v1ihs_index);
    value0 = LC2821extract_restarts(T0);
    {
     v3 = value0;
     v4 = cl_env_copy->values[1];
    }
    T0 = cl_nreverse(ECL_CONS_CAR(CLV2));
    T1 = ECL_CONS_CAR(CLV0);
    T2 = ECL_CONS_CAR(CLV1);
    cl_env_copy->nvalues = 5;
    cl_env_copy->values[4] = v4;
    cl_env_copy->values[3] = T2;
    cl_env_copy->values[2] = T1;
    cl_env_copy->values[1] = v3;
    cl_env_copy->values[0] = T0;
    return cl_env_copy->values[0];
   }
  }
 }
}
static cl_object L2823ihs_environment_va(cl_narg narg, cl_object v3ihs_index, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[185]);
 {
  return L2823ihs_environment(v3ihs_index);
 }
}
/* function definition for TPL-PRINT-VARIABLES                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2824tpl_print_variables(cl_object v1prefix, cl_object v2variables, cl_object v3no_values)
{
 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:;
 L2772tpl_format(1, v1prefix);
 if (Null(v2variables)){
  goto L3;
 }
 {
  cl_object v4;
  cl_object v5var;
  cl_object v6value;
  cl_object v7;
  {
   cl_object v8;
   v8 = v2variables;
   if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v4 = v8;
  }
  v5var = ECL_NIL;
  v6value = ECL_NIL;
  v7 = v4;
L11:;
  if (!(ecl_endp(v7))){
   goto L13;
  }
  goto L12;
L13:;
  {
   cl_object v8;
   v8 = ECL_CONS_CAR(v7);
   v5var = ecl_car(v8);
   v8 = ecl_cdr(v8);
   v6value = v8;
  }
  {
   cl_object v8;
   v8 = ECL_CONS_CDR(v7);
   if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v7 = v8;
  }
  if (Null(v3no_values)){
   goto L27;
  }
  L2772tpl_format(2, VV[193], v5var);
  goto L26;
L27:;
  L2772tpl_format(3, VV[194], v5var, v6value);
L26:;
  goto L11;
L12:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = L2772tpl_format(1, VV[195]);
 return value0;
}
static cl_object L2824tpl_print_variables_va(cl_narg narg, cl_object v8prefix, cl_object v9variables, cl_object v10no_values, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[192]);
 {
  return L2824tpl_print_variables(v8prefix, v9variables, v10no_values);
 }
}
/* function definition for TPL-VARIABLES-COMMAND                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2825tpl_variables_command(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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[197]);
 {
  cl_object v1no_values;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1no_values = ECL_NIL;
   } else {
    i++;
    v1no_values = va_arg(args,cl_object);
   }
  }
  va_end(args);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(16)); /*  *PRINT-LENGTH* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_T); /*  *PRINT-PRETTY* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-ESCAPE*",50),ECL_NIL); /*  *PRINT-ESCAPE* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
  {
   cl_object v2;                                  /*  LOCAL-VARIABLES         */
   cl_object v3;                                  /*  SPECIAL-VARIABLES       */
   cl_object v4;                                  /*  FUNCTIONS               */
   cl_object v5;                                  /*  BLOCKS                  */
   cl_object v6;                                  /*  RESTARTS                */
   value0 = L2823ihs_environment(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
   {
    const int v7 = cl_env_copy->nvalues;
    v2 = value0;
    cl_object v8;
    v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
    v3 = v8;
    v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
    v4 = v8;
    v8 = (v7<=3)? ECL_NIL : cl_env_copy->values[3];
    v5 = v8;
    v8 = (v7<=4)? ECL_NIL : cl_env_copy->values[4];
    v6 = v8;
   }
   L2772tpl_format(2, VV[198], v4);
   L2772tpl_format(2, VV[199], v5);
   if (Null(v6)){
    goto L6;
   }
   L2772tpl_format(1, VV[200]);
   {
    cl_object v7;
    cl_object v8r;
    cl_object v9;
    {
     cl_object v10;
     v10 = v6;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v10;
    }
    v8r = ECL_NIL;
    v9 = v7;
L14:;
    if (!(ecl_endp(v9))){
     goto L16;
    }
    goto L15;
L16:;
    v8r = ECL_CONS_CAR(v9);
    {
     cl_object v10;
     v10 = ECL_CONS_CDR(v9);
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v9 = v10;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("RESTART-NAME",726)->symbol.gfdef))->cfun.entry(1, v8r) /*  RESTART-NAME */;
    L2772tpl_format(3, VV[201], T0, v8r);
    goto L14;
L15:;
   }
L6:;
   L2824tpl_print_variables(VV[202], v2, v1no_values);
   L2824tpl_print_variables(VV[203], v3, v1no_values);
  }
  (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  ecl_bds_unwind_n(cl_env_copy,5);
  return value0;
 }
}
/* function definition for TPL-INSPECT-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2827tpl_inspect_command(cl_object v1var_name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_SYMBOLP(v1var_name))){
  goto L2;
 }
 v1var_name = ecl_symbol_name(v1var_name);
L2:;
 {
  cl_object v2val_pair;
  {
   cl_object v3;
   cl_object v4;
   v3 = L2817decode_ihs_locals(ecl_cmp_symbol_value(cl_env_copy,VV[3]));
   {
    cl_object v5;
    v5 = ecl_make_cfun_va((cl_objectfn)LC2826__lambda404_va,ECL_NIL,Cblock,2);
    v4 = v5;
   }
   {
    cl_object v5;
    v5 = v3;
    goto L11;
L10:;
    {
     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 L13;
     }
     {
      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);
      {
       cl_object v9s2;
       v9s2 = v8;
       if (!(ECL_SYMBOLP(v9s2))){
        goto L25;
       }
       v9s2 = ecl_symbol_name(v9s2);
L25:;
       if (!(ECL_STRINGP(v9s2))){
        goto L28;
       }
       if (Null(cl_string_equal(2, v1var_name, v9s2))){
        goto L13;
       }
       goto L23;
L28:;
       goto L13;
      }
L23:;
      v2val_pair = v7;
      goto L5;
     }
    }
L13:;
    v5 = ECL_CONS_CDR(v5);
L11:;
    if (v5==ECL_NIL) {
     goto L32;
    }
    goto L10;
L32:;
    v2val_pair = ECL_NIL;
   }
  }
L5:;
  if (Null(v2val_pair)){
   goto L34;
  }
  {
   cl_object v3val;
   v3val = ecl_cdr(v2val_pair);
   value0 = cl_inspect(v3val);
   return value0;
  }
L34:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2827tpl_inspect_command_va(cl_narg narg, cl_object v4var_name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[205]);
 {
  return L2827tpl_inspect_command(v4var_name);
 }
}
/* function definition for TPL-BDS-COMMAND                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2828tpl_bds_command(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[208]);
 {
  cl_object v1var;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1var = ECL_NIL;
   } else {
    i++;
    v1var = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(v1var)){
   goto L2;
  }
  {
   cl_object v2;
   cl_object v3;
   cl_object v4bi;
   T0 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,VV[7]));
   T1 = ((ecl_float_nan_p(T0) || ecl_greatereq(ecl_make_int8_t(0),T0))?ecl_make_int8_t(0):T0);
   T2 = si_frs_bds(T1);
   v2 = ecl_make_integer((ecl_fixnum(T2))+1);
   T0 = ecl_one_plus(ecl_cmp_symbol_value(cl_env_copy,VV[8]));
   v3 = si_frs_bds(T0);
   v4bi = v2;
   goto L9;
L8:;
   T0 = si_bds_var(v4bi);
   if (!((T0)==(v1var))){
    goto L11;
   }
   {
    cl_object v5val;
    v5val = si_bds_val(v4bi);
    if (!((v5val)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("UNBOUND",2))))){
     goto L14;
    }
    value0 = VV[209];
    cl_env_copy->nvalues = 1;
    return value0;
L14:;
    value0 = v5val;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L11:;
   v4bi = ecl_one_plus(v4bi);
L9:;
   if (ecl_greater(v4bi,v3)) {
    goto L18;
   }
   goto L8;
L18:;
   L2772tpl_format(1, VV[210]);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   return value0;
  }
L2:;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   cl_object v8bi;
   cl_object v9fi;
   T0 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,VV[7]));
   T1 = ((ecl_float_nan_p(T0) || ecl_greatereq(ecl_make_int8_t(0),T0))?ecl_make_int8_t(0):T0);
   T2 = si_frs_bds(T1);
   v5 = ecl_make_integer((ecl_fixnum(T2))+1);
   T0 = ecl_one_plus(ecl_cmp_symbol_value(cl_env_copy,VV[8]));
   v6 = si_frs_bds(T0);
   v7 = ecl_cmp_symbol_value(cl_env_copy,VV[7]);
   v8bi = v5;
   v9fi = v7;
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(16)); /*  *PRINT-LENGTH* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_T); /*  *PRINT-PRETTY* */
   goto L28;
L27:;
   goto L33;
L32:;
   L2831print_frs(v9fi);
   v9fi = ecl_plus(v9fi,ecl_make_int8_t(1));
L33:;
   if (ecl_greater(v9fi,ecl_cmp_symbol_value(cl_env_copy,VV[8]))) {
    goto L38;
   }
   T0 = si_frs_bds(v9fi);
   if (ecl_greatereq(T0,v8bi)) {
    goto L38;
   }
   goto L32;
L38:;
   T0 = si_bds_var(v8bi);
   {
    cl_object v10val;
    v10val = si_bds_val(v8bi);
    if (!((v10val)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("UNBOUND",2))))){
     goto L44;
    }
    T1 = VV[209];
    goto L42;
L44:;
    T1 = v10val;
   }
L42:;
   L2772tpl_format(4, VV[212], v8bi, T0, T1);
   v8bi = ecl_one_plus(v8bi);
L28:;
   if (ecl_greater(v8bi,v6)) {
    goto L48;
   }
   goto L27;
L48:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
/* function definition for TPL-BACKTRACE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2829tpl_backtrace(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[214]);
 {
  cl_object v1n;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1n = ECL_NIL;
   } else {
    i++;
    v1n = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2;
   cl_object v3;
   cl_object v4base;
   cl_object v5top;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[4]);
   v3 = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /*  *PRINT-PRETTY* */
   v4base = v2;
   v5top = v3;
   L2772tpl_format(1, VV[215]);
   if (!(v1n==ECL_NIL)){
    goto L9;
   }
   {
    cl_object v6i;
    v6i = v5top;
    goto L14;
L13:;
    if (Null(L2839ihs_visible(v6i))){
     goto L16;
    }
    {
     cl_object v7;
     cl_object v8;
     if (!(ecl_number_equalp(v6i,ecl_cmp_symbol_value(cl_env_copy,VV[6])))){
      goto L19;
     }
     v7 = ECL_SYM("UPCASE",1360);
     goto L18;
L19:;
     v7 = ECL_SYM("DOWNCASE",1254);
L18:;
     v8 = L2840ihs_fname(v6i);
     ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CASE*",48),v7); /*  *PRINT-CASE* */
     ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
     L2772tpl_format(2, VV[217], v8);
     if (!((v8)==(ECL_SYM("BYTECODES",1737)))){
      goto L23;
     }
     T0 = si_ihs_fun(v6i);
     T1 = cl_function_lambda_expression(T0);
     L2772tpl_format(2, VV[218], T1);
L23:;
     (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
    }
L16:;
    v6i = si_ihs_prev(v6i);
L14:;
    if (ecl_lower(v6i,v4base)) {
     goto L27;
    }
    goto L13;
L27:;
    goto L8;
   }
L9:;
   if (!((ECL_T)==(v1n))){
    goto L30;
   }
   v4base = ecl_make_int8_t(0);
   goto L29;
L30:;
   if (ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n)) {
    goto L33;
   }
   cl_error(1, VV[219]);
L33:;
   v5top = ecl_cmp_symbol_value(cl_env_copy,VV[6]);
L29:;
   {
    cl_object v7;
    cl_object v8i;
    cl_object v9j;
    if (!((ECL_T)==(v1n))){
     goto L37;
    }
    v7 = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
    goto L36;
L37:;
    v7 = v1n;
L36:;
    v8i = v5top;
    v9j = ecl_make_int8_t(0);
    goto L43;
L42:;
    if (L2839ihs_visible(v8i)!=ECL_NIL) {
     goto L47;
    }
    if (!((ECL_T)==(v1n))){
     goto L45;
    }
    goto L46;
L47:;
L46:;
    {
     cl_object v10;
     cl_object v11;
     if (!(ecl_number_equalp(v8i,ecl_cmp_symbol_value(cl_env_copy,VV[6])))){
      goto L50;
     }
     v10 = ECL_SYM("UPCASE",1360);
     goto L49;
L50:;
     v10 = ECL_SYM("DOWNCASE",1254);
L49:;
     v11 = L2840ihs_fname(v8i);
     ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CASE*",48),v10); /*  *PRINT-CASE* */
     ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
     T0 = L2840ihs_fname(v8i);
     L2772tpl_format(2, VV[217], T0);
     if (!((v11)==(ECL_SYM("BYTECODES",1737)))){
      goto L54;
     }
     T0 = si_ihs_fun(v8i);
     T1 = cl_function_lambda_expression(T0);
     L2772tpl_format(2, VV[218], T1);
L54:;
     (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
    }
L45:;
    v8i = si_ihs_prev(v8i);
    v9j = ecl_one_plus(v9j);
L43:;
    if (ecl_lower(v8i,v4base)) {
     goto L59;
    }
    if (ecl_greatereq(v9j,v7)) {
     goto L59;
    }
    goto L42;
L59:;
    if (!(ecl_zerop(v8i))){
     goto L8;
    }
    L2772tpl_format(1, VV[220]);
   }
L8:;
   (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
   ecl_bds_unwind1(cl_env_copy);
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
/* function definition for TPL-FRS-COMMAND                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2830tpl_frs_command(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);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[222]);
 {
  cl_object v1n;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1n = ECL_NIL;
   } else {
    i++;
    v1n = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (v1n!=ECL_NIL) {
   goto L2;
  }
  v1n = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
L2:;
  if (ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n)) {
   goto L5;
  }
  cl_error(1, VV[223]);
L5:;
  {
   cl_object v2;
   cl_object v3i;
   cl_object v4k;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
   v3i = v2;
   v4k = v1n;
   goto L12;
L11:;
   {
    cl_object v5j;
    value0 = si_sch_frs_base(ecl_cmp_symbol_value(cl_env_copy,VV[7]), v3i);
    if (value0!=ECL_NIL) {
     goto L17;
    }
    v5j = ecl_one_plus(ecl_cmp_symbol_value(cl_env_copy,VV[8]));
    goto L15;
L17:;
    v5j = value0;
    goto L15;
L15:;
    ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(2)); /*  *PRINT-LEVEL* */
    ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(16)); /*  *PRINT-LENGTH* */
    ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_T); /*  *PRINT-PRETTY* */
    goto L21;
L20:;
    L2831print_frs(v5j);
    v5j = ecl_plus(v5j,ecl_make_int8_t(1));
L21:;
    if (ecl_greater(v5j,ecl_cmp_symbol_value(cl_env_copy,VV[8]))) {
     goto L26;
    }
    T0 = si_frs_ihs(v5j);
    if (ecl_greater(T0,v3i)) {
     goto L26;
    }
    goto L20;
L26:;
    ecl_bds_unwind1(cl_env_copy);
    ecl_bds_unwind1(cl_env_copy);
    ecl_bds_unwind1(cl_env_copy);
   }
   v3i = si_ihs_prev(v3i);
   v4k = ecl_one_minus(v4k);
L12:;
   if (ecl_number_equalp(v4k,ecl_make_int8_t(0))) {
    goto L32;
   }
   goto L11;
L32:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   return value0;
  }
 }
}
/* function definition for PRINT-FRS                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2831print_frs(cl_object v1i)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = si_frs_ihs(v1i);
 T1 = si_frs_bds(v1i);
 value0 = L2772tpl_format(4, VV[225], v1i, T0, T1);
 return value0;
}
static cl_object L2831print_frs_va(cl_narg narg, cl_object v2i, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[211]);
 {
  return L2831print_frs(v2i);
 }
}
/* function definition for BREAK-WHERE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2832break_where()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ecl_lowereq(ecl_cmp_symbol_value(cl_env_copy,VV[16]),ecl_make_int8_t(0)))){
  goto L2;
 }
 value0 = L2772tpl_format(2, VV[227], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
 return value0;
L2:;
 value0 = L2833tpl_print_current();
 return value0;
}
static cl_object L2832break_where_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[102]);
 {
  return L2832break_where();
 }
}
/* function definition for TPL-PRINT-CURRENT                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2833tpl_print_current()
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v1;
  v1 = L2840ihs_fname(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
  L2772tpl_format(2, VV[229], v1);
  if (!((v1)==(ECL_SYM("BYTECODES",1737)))){
   ecl_bds_unwind1(cl_env_copy);
   goto L2;
  }
  T0 = si_ihs_fun(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  T1 = cl_function_lambda_expression(T0);
  L2772tpl_format(2, VV[218], T1);
  ecl_bds_unwind1(cl_env_copy);
 }
L2:;
 L2772tpl_format(2, VV[230], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
 {
  cl_object v1fun;
  v1fun = si_ihs_fun(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  if (!(ECL_SYMBOLP(v1fun))){
   goto L9;
  }
  if (Null(cl_fboundp(v1fun))){
   goto L9;
  }
  v1fun = cl_fdefinition(v1fun);
L9:;
  {
   cl_object v2;                                  /*  FILE                    */
   cl_object v3;                                  /*  POSITION                */
   value0 = si_compiled_function_file(v1fun);
   {
    v2 = value0;
    v3 = cl_env_copy->values[1];
   }
   if (Null(v2)){
    goto L7;
   }
   L2772tpl_format(3, VV[231], v2, v3);
  }
 }
L7:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2833tpl_print_current_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[151]);
 {
  return L2833tpl_print_current();
 }
}
/* function definition for TPL-HIDE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2834tpl_hide(cl_object v1fname)
{
 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;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[17]);
  v3 = (ECL_SYM("EQ",335)->symbol.gfdef);
  v4 = v1fname;
  v5 = v2;
  if (si_memq(v4,v5)!=ECL_NIL) {
   goto L2;
  }
 }
 T0 = CONS(v1fname,ecl_cmp_symbol_value(cl_env_copy,VV[17]));
 ecl_cmp_setq(cl_env_copy,VV[17],T0);
 if (L2839ihs_visible(ecl_cmp_symbol_value(cl_env_copy,VV[6]))!=ECL_NIL) {
  goto L2;
 }
 L2841set_current_ihs();
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2834tpl_hide_va(cl_narg narg, cl_object v2fname, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[233]);
 {
  return L2834tpl_hide(v2fname);
 }
}
/* function definition for TPL-UNHIDE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2835tpl_unhide(cl_object v1fname)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_cmp_symbol_value(cl_env_copy,VV[17]);
 T1 = (ECL_SYM("EQ",335)->symbol.gfdef);
 T2 = cl_delete(4, v1fname, T0, ECL_SYM("TEST",1353), T1);
 ecl_cmp_setq(cl_env_copy,VV[17],T2);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2835tpl_unhide_va(cl_narg narg, cl_object v2fname, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[235]);
 {
  return L2835tpl_unhide(v2fname);
 }
}
/* function definition for TPL-UNHIDE-PACKAGE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2836tpl_unhide_package(cl_object v1package)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_find_package(v1package);
 T1 = ecl_cmp_symbol_value(cl_env_copy,VV[18]);
 T2 = (ECL_SYM("EQ",335)->symbol.gfdef);
 T3 = cl_delete(4, T0, T1, ECL_SYM("TEST",1353), T2);
 ecl_cmp_setq(cl_env_copy,VV[18],T3);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2836tpl_unhide_package_va(cl_narg narg, cl_object v2package, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[237]);
 {
  return L2836tpl_unhide_package(v2package);
 }
}
/* function definition for TPL-UNHIDE-ALL                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2837tpl_unhide_all()
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[17],T0);
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[18],T0);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2837tpl_unhide_all_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[239]);
 {
  return L2837tpl_unhide_all();
 }
}
/* function definition for TPL-HIDE-PACKAGE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2838tpl_hide_package(cl_object v1package)
{
 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:;
 v1package = cl_find_package(v1package);
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[18]);
  v3 = (ECL_SYM("EQ",335)->symbol.gfdef);
  v4 = v1package;
  v5 = v2;
  if (si_memq(v4,v5)!=ECL_NIL) {
   goto L4;
  }
 }
 T0 = CONS(v1package,ecl_cmp_symbol_value(cl_env_copy,VV[18]));
 ecl_cmp_setq(cl_env_copy,VV[18],T0);
 if (L2839ihs_visible(ecl_cmp_symbol_value(cl_env_copy,VV[6]))!=ECL_NIL) {
  goto L4;
 }
 L2841set_current_ihs();
L4:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2838tpl_hide_package_va(cl_narg narg, cl_object v2package, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[241]);
 {
  return L2838tpl_hide_package(v2package);
 }
}
/* function definition for IHS-VISIBLE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2839ihs_visible(cl_object v1i)
{
 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 v2fname;
  v2fname = L2840ihs_fname(v1i);
  if (!(ECL_CONSP(v2fname))){
   goto L3;
  }
  T0 = ecl_car(v2fname);
  if (!((ECL_SYM("SETF",753))==(T0))){
   goto L3;
  }
  v2fname = ecl_cadr(v2fname);
L3:;
  value0 = ecl_make_bool((v2fname)==(ECL_SYM("EVAL",341)));
  if (value0!=ECL_NIL) {
   goto L8;
  }
  value0 = ecl_make_bool((v2fname)==(ECL_SYM("BYTECODES",1737)));
  if (value0!=ECL_NIL) {
   goto L8;
  }
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v3 = cl_symbol_package(v2fname);
   v4 = ecl_cmp_symbol_value(cl_env_copy,VV[18]);
   v5 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v6 = v3;
   v7 = v4;
   if (si_memq(v6,v7)!=ECL_NIL) {
    goto L12;
   }
  }
  if (v2fname==ECL_NIL) {
   goto L12;
  }
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   cl_object v6;
   v3 = ecl_cmp_symbol_value(cl_env_copy,VV[17]);
   v4 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v5 = v2fname;
   v6 = v3;
   T0 = si_memq(v5,v6);
  }
  value0 = Null(T0)?ECL_T:ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L12:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L8:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2839ihs_visible_va(cl_narg narg, cl_object v3i, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[154]);
 {
  return L2839ihs_visible(v3i);
 }
}
/* function definition for IHS-FNAME                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2840ihs_fname(cl_object v1i)
{
 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 v2function;
  v2function = si_ihs_fun(v1i);
  if (!(ECL_SYMBOLP(v2function))){
   goto L3;
  }
  value0 = v2function;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  if (Null(cl_compiled_function_p(v2function))){
   goto L5;
  }
  value0 = si_compiled_function_name(v2function);
  if (value0!=ECL_NIL) {
   goto L8;
  }
  value0 = ECL_SYM("LAMBDA",454);
  cl_env_copy->nvalues = 1;
  return value0;
L8:;
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  if (!(ECL_INSTANCEP(v2function))){
   goto L10;
  }
  value0 = cl_slot_value(v2function, VV[244]);
  return value0;
L10:;
  value0 = VV[245];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2840ihs_fname_va(cl_narg narg, cl_object v3i, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[216]);
 {
  return L2840ihs_fname(v3i);
 }
}
/* function definition for SET-CURRENT-IHS                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2841set_current_ihs()
{
 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 v1i;
  v1i = ecl_cmp_symbol_value(cl_env_copy,VV[6]);
  goto L6;
L5:;
  v1i = si_ihs_prev(v1i);
L6:;
  if (Null(L2839ihs_visible(v1i))){
   goto L14;
  }
  T0 = v1i;
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  if (ecl_cmp_symbol_value(cl_env_copy,VV[6])!=ECL_NIL) {
   goto L10;
  }
  goto L12;
L14:;
  goto L12;
L12:;
  if (ecl_lowereq(v1i,ecl_cmp_symbol_value(cl_env_copy,VV[4]))) {
   goto L10;
  }
  goto L5;
L10:;
 }
 value0 = L2842set_break_env();
 return value0;
}
static cl_object L2841set_current_ihs_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[97]);
 {
  return L2841set_current_ihs();
 }
}
/* function definition for SET-BREAK-ENV                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2842set_break_env()
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = si_ihs_lex(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
 ecl_cmp_setq(cl_env_copy,VV[2],T0);
 T0 = si_ihs_lcl(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
 ecl_cmp_setq(cl_env_copy,VV[3],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[3]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2842set_break_env_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[96]);
 {
  return L2842set_break_env();
 }
}
/* function definition for IHS-SEARCH                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2843ihs_search(cl_narg narg, cl_object v1string, cl_object v2unrestricted, ...)
{
 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[95]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[95]);
 {
  cl_object v3start;
  va_list args; va_start(args,v2unrestricted);
  {
   int i = 2;
   if (i >= narg) {
    v3start = si_ihs_top();
   } else {
    i++;
    v3start = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4ihs;
   v4ihs = v3start;
   goto L5;
L4:;
   if (v2unrestricted!=ECL_NIL) {
    goto L10;
   }
   if (Null(L2839ihs_visible(v4ihs))){
    goto L7;
   }
   goto L9;
L10:;
L9:;
   T0 = cl_string(v1string);
   T1 = L2840ihs_fname(v4ihs);
   T2 = ecl_symbol_name(T1);
   T3 = (ECL_SYM("CHAR-EQUAL",209)->symbol.gfdef);
   if (Null(cl_search(4, T0, T2, ECL_SYM("TEST",1353), T3))){
    goto L7;
   }
   value0 = v4ihs;
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   v4ihs = si_ihs_prev(v4ihs);
L5:;
   if (ecl_lower(v4ihs,ecl_cmp_symbol_value(cl_env_copy,VV[4]))) {
    goto L15;
   }
   goto L4;
L15:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for TPL-BACKWARD-SEARCH                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2844tpl_backward_search(cl_object v1string)
{
 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 v2new_ihs;
  v2new_ihs = L2843ihs_search(3, v1string, ECL_NIL, ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  if (Null(v2new_ihs)){
   goto L4;
  }
  T0 = v2new_ihs;
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  L2841set_current_ihs();
  L2833tpl_print_current();
  goto L3;
L4:;
  L2772tpl_format(2, VV[251], v1string);
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
static cl_object L2844tpl_backward_search_va(cl_narg narg, cl_object v3string, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[250]);
 {
  return L2844tpl_backward_search(v3string);
 }
}
/* function definition for TPL-FORWARD-SEARCH                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2845tpl_forward_search(cl_object v1string)
{
 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 v2ihs;
  v2ihs = si_ihs_next(ecl_cmp_symbol_value(cl_env_copy,VV[6]));
  goto L6;
L5:;
  if (Null(L2839ihs_visible(v2ihs))){
   goto L8;
  }
  T0 = L2840ihs_fname(v2ihs);
  T1 = ecl_symbol_name(T0);
  T2 = (ECL_SYM("CHAR-EQUAL",209)->symbol.gfdef);
  if (Null(cl_search(4, v1string, T1, ECL_SYM("TEST",1353), T2))){
   goto L8;
  }
  T0 = v2ihs;
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  L2841set_current_ihs();
  L2833tpl_print_current();
  goto L2;
L8:;
  v2ihs = si_ihs_next(v2ihs);
L6:;
  if (ecl_greater(v2ihs,ecl_cmp_symbol_value(cl_env_copy,VV[5]))) {
   goto L18;
  }
  goto L5;
L18:;
  L2772tpl_format(2, VV[251], v1string);
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2845tpl_forward_search_va(cl_narg narg, cl_object v2string, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[253]);
 {
  return L2845tpl_forward_search(v2string);
 }
}
/* function definition for TPL-APROPOS-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2846tpl_apropos_command(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[255]);
 {
  cl_object v1string;
  cl_object v2pkg;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1string = ECL_NIL;
   } else {
    i++;
    v1string = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v2pkg = ECL_NIL;
   } else {
    i++;
    v2pkg = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(v1string)){
   goto L3;
  }
  value0 = cl_apropos(2, v1string, v2pkg);
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for TPL-DOCUMENT-COMMAND                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2847tpl_document_command(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[257]);
 {
  cl_object v1symbol;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1symbol = ECL_NIL;
   } else {
    i++;
    v1symbol = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(v1symbol)){
   goto L2;
  }
  value0 = (cl_env_copy->function=(VV[258]->symbol.gfdef))->cfun.entry(1, v1symbol) /*  HELP */;
  return value0;
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for TPL-STEP-COMMAND                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2848tpl_step_command(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[260]);
 {
  cl_object v1form;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1form = ECL_NIL;
   } else {
    i++;
    v1form = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(v1form)){
   goto L2;
  }
  value0 = (cl_env_copy->function=(VV[261]->symbol.gfdef))->cfun.entry(1, v1form) /*  STEP* */;
  return value0;
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for TPL-TRACE-COMMAND                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2849tpl_trace_command(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1functions;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1functions = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = (cl_env_copy->function=(VV[264]->symbol.gfdef))->cfun.entry(1, v1functions) /*  TRACE* */;
  return value0;
 }
}
/* function definition for TPL-UNTRACE-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2850tpl_untrace_command(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1functions;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1functions = cl_grab_rest_args(args);
  ecl_va_end(args);
  value0 = (cl_env_copy->function=(VV[267]->symbol.gfdef))->cfun.entry(1, v1functions) /*  UNTRACE* */;
  return value0;
 }
}
/* function definition for TPL-LOAD-COMMAND                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2851tpl_load_command(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 v1files;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1files = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (Null(v1files)){
   goto L1;
  }
  T0 = v1files;
  ecl_cmp_setq(cl_env_copy,VV[269],T0);
L1:;
  {
   cl_object v2;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[269]);
   goto L8;
L7:;
   {
    cl_object v3file;
    v3file = ecl_car(v2);
    cl_load(1, v3file);
   }
   v2 = ecl_cdr(v2);
L8:;
   if (Null(v2)){
    goto L15;
   }
   goto L7;
L15:;
  }
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[269]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for TPL-COMPILE-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2852tpl_compile_command(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 v1files;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1files = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (Null(v1files)){
   goto L1;
  }
  T0 = v1files;
  ecl_cmp_setq(cl_env_copy,VV[272],T0);
L1:;
  {
   cl_object v2;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[272]);
   goto L8;
L7:;
   {
    cl_object v3file;
    v3file = ecl_car(v2);
    (cl_env_copy->function=(ECL_SYM("COMPILE-FILE",236)->symbol.gfdef))->cfun.entry(1, v3file) /*  COMPILE-FILE */;
   }
   v2 = ecl_cdr(v2);
L8:;
   if (Null(v2)){
    goto L15;
   }
   goto L7;
L15:;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[272]);
  ecl_cmp_setq(cl_env_copy,VV[269],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[269]);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for TPL-HELP-COMMAND                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2853tpl_help_command(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[275]);
 {
  cl_object v1topic;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1topic = ECL_NIL;
   } else {
    i++;
    v1topic = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(v1topic==ECL_NIL)){
   goto L3;
  }
  {
   cl_object v2;
   v2 = ecl_cmp_symbol_value(cl_env_copy,VV[21]);
   goto L8;
L7:;
   {
    cl_object v3commands;
    v3commands = ecl_car(v2);
    T0 = ecl_car(v3commands);
    L2772tpl_format(2, VV[276], T0);
    {
     cl_object v4;
     v4 = ecl_cdr(v3commands);
     goto L17;
L16:;
     {
      cl_object v5c;
      v5c = ecl_car(v4);
      if (Null(ecl_cadddr(v5c))){
       goto L21;
      }
      T0 = ecl_cadddr(v5c);
      L2772tpl_format(2, VV[277], T0);
L21:;
     }
     v4 = ecl_cdr(v4);
L17:;
     if (Null(v4)){
      goto L25;
     }
     goto L16;
L25:;
    }
   }
   v2 = ecl_cdr(v2);
L8:;
   if (Null(v2)){
    goto L29;
   }
   goto L7;
L29:;
   goto L2;
  }
L3:;
  if (ECL_STRINGP(v1topic)) {
   goto L33;
  }
  if (!(ECL_SYMBOLP(v1topic))){
   goto L31;
  }
  goto L32;
L33:;
L32:;
  {
   cl_object v3c;
   v3c = ECL_NIL;
   T0 = cl_string(v1topic);
   T1 = cl_find_package(ECL_SYM("KEYWORD",451));
   v1topic = cl_intern(2, T0, T1);
   {
    cl_object v4;
    v4 = ecl_cmp_symbol_value(cl_env_copy,VV[21]);
    goto L42;
L41:;
    {
     cl_object v5commands;
     v5commands = ecl_car(v4);
     {
      cl_object v6;
      cl_object v7;
      v6 = ecl_cdr(v5commands);
      v7 = (ECL_SYM("MEMBER",554)->symbol.gfdef);
      {
       cl_object v8;
       v8 = v6;
       goto L54;
L53:;
       {
        cl_object v9;
        cl_object v10;
        {
         cl_object v11;
         v11 = v8;
         if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v9 = v11;
        }
        v10 = ECL_CONS_CAR(v9);
        if (Null(v10)){
         goto L56;
        }
        {
         cl_object v11;
         {
          cl_object v12;
          v12 = v10;
          if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v12;
         }
         v11 = ECL_CONS_CAR(T0);
         {
          cl_object v12;
          cl_object v13;
          v12 = v1topic;
          v13 = v11;
          if (Null(ecl_memql(v12,v13))){
          goto L56;
          }
         }
         v3c = v10;
         goto L48;
        }
       }
L56:;
       v8 = ECL_CONS_CDR(v8);
L54:;
       if (v8==ECL_NIL) {
        goto L71;
       }
       goto L53;
L71:;
       v3c = ECL_NIL;
      }
     }
L48:;
     if (Null(v3c)){
      goto L46;
     }
     goto L38;
L46:;
    }
    v4 = ecl_cdr(v4);
L42:;
    if (Null(v4)){
     goto L75;
    }
    goto L41;
L75:;
   }
L38:;
   T0 = ecl_cddddr(v3c);
   T1 = ecl_car(T0);
   if (!(T1==ECL_NIL)){
    goto L77;
   }
   T0 = cl_string(v1topic);
   L2772tpl_format(2, VV[278], T0);
   goto L2;
L77:;
   (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
   T0 = ecl_cddddr(v3c);
   T1 = ecl_car(T0);
   L2772tpl_format(1, T1);
   (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
   goto L2;
  }
L31:;
  L2772tpl_format(2, VV[279], v1topic);
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
/* function definition for TPL-HELP-STACK-COMMAND                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2854tpl_help_stack_command()
{
 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 = L2772tpl_format(1, VV[282]);
 return value0;
}
static cl_object L2854tpl_help_stack_command_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[281]);
 {
  return L2854tpl_help_stack_command();
 }
}
/* function definition for COMPUTE-RESTART-COMMANDS                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2855compute_restart_commands(cl_narg narg, cl_object v1condition, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[284]);
 {
  cl_object v2display;
  ecl_va_list args; ecl_va_start(args,v1condition,narg,1);
  {
   cl_object keyvars[2];
   cl_parse_key(args,1,L2855compute_restart_commandskeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v2display = keyvars[0];
  }
  {
   cl_object v3;
   cl_object v4;
   cl_object v5restart_commands;
   v3 = cl_compute_restarts(1, v1condition);
   v4 = ecl_list1(VV[285]);
   v5restart_commands = v4;
   if (Null(v2display)){
    goto L4;
   }
   if (Null(v3)){
    goto L7;
   }
   T0 = VV[286];
   goto L6;
L7:;
   T0 = VV[287];
L6:;
   cl_format(2, v2display, T0);
L4:;
   {
    cl_object v6;
    cl_object v7restart;
    cl_object v8;
    cl_object v9i;
    v6 = v3;
    v7restart = ECL_NIL;
    v8 = v6;
    v9i = ecl_make_int8_t(1);
    if (!(ecl_endp(v8))){
     goto L16;
    }
    goto L15;
L16:;
    v7restart = ECL_CONS_CAR(v8);
L14:;
    {
     cl_object v10;
     v10 = ECL_CONS_CDR(v8);
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v8 = v10;
    }
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     v10 = cl_format(3, ECL_NIL, VV[288], v9i);
     T0 = (cl_env_copy->function=(ECL_SYM("RESTART-NAME",726)->symbol.gfdef))->cfun.entry(1, v7restart) /*  RESTART-NAME */;
     v11 = cl_format(3, ECL_NIL, VV[289], T0);
     v12 = cl_princ_to_string(v7restart);
     T0 = cl_string_upcase(1, v10);
     T1 = cl_intern(2, T0, VV[290]);
     T2 = ecl_list1(T1);
     T3 = cl_format(5, ECL_NIL, VV[291], v10, v12, v11);
     T4 = cl_string_downcase(1, v10);
     T5 = cl_format(6, ECL_NIL, VV[292], T4, VV[293], v11, v12);
     T6 = cl_list(5, T2, v7restart, VV[136], T3, T5);
     v5restart_commands = CONS(T6,v5restart_commands);
     if (Null(v2display)){
      goto L24;
     }
     cl_format(5, v2display, VV[294], v9i, v11, v7restart);
    }
L24:;
    if (!(ecl_endp(v8))){
     goto L31;
    }
    goto L15;
L31:;
    {
     cl_object v10;
     v10 = ECL_CONS_CAR(v8);
     v9i = ecl_one_plus(v9i);
     v7restart = v10;
    }
    goto L14;
L15:;
   }
   if (Null(v2display)){
    goto L39;
   }
   (ecl_terpri(v2display));
L39:;
   value0 = cl_nreverse(v5restart_commands);
   return value0;
  }
 }
}
/* function definition for UPDATE-DEBUG-COMMANDS                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2857update_debug_commands(cl_object v1restart_commands)
{
 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 v2commands;
  v2commands = cl_copy_list(ecl_cmp_symbol_value(cl_env_copy,VV[21]));
  {
   cl_object v3;
   cl_object v4;
   v3 = VV[23];
   v4 = v2commands;
   if (ecl_memql(v3,v4)!=ECL_NIL) {
    goto L3;
   }
  }
  T0 = ecl_list1(ecl_cmp_symbol_value(cl_env_copy,VV[22]));
  v2commands = ecl_nconc(v2commands,T0);
L3:;
  {
   cl_object v3;
   v3 = ecl_make_cfun_va((cl_objectfn)LC2856__lambda592_va,ECL_NIL,Cblock,1);
   T0 = v3;
  }
  cl_delete_if(2, T0, v2commands);
  T0 = ecl_list1(v1restart_commands);
  value0 = ecl_nconc(v2commands,T0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2857update_debug_commands_va(cl_narg narg, cl_object v3restart_commands, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[296]);
 {
  return L2857update_debug_commands(v3restart_commands);
 }
}
/* function definition for CHECK-DEFAULT-DEBUGGER-RUNAWAY                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2858check_default_debugger_runaway()
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ecl_lower(ecl_cmp_symbol_value(cl_env_copy,VV[299]),ecl_cmp_symbol_value(cl_env_copy,VV[1])))){
  goto L2;
 }
 L2772tpl_format(2, VV[301], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
 T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,VV[299]),ecl_make_int8_t(3));
 if (!(ecl_lower(T0,ecl_cmp_symbol_value(cl_env_copy,VV[1])))){
  goto L5;
 }
 si_quit(1, ecl_make_int8_t(-1));
L5:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[302]))->cfun.entry(0) /*  EXIT-PROCESS */;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2858check_default_debugger_runaway_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[300]);
 {
  return L2858check_default_debugger_runaway();
 }
}
/* function definition for TPL-SWITCH-COMMAND                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2859tpl_switch_command(cl_narg narg, ...)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(VV[304]);
 {
  cl_object v1rank;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1rank = ECL_NIL;
   } else {
    i++;
    v1rank = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2elect;
   v2elect = ECL_NIL;
   if (!(ECL_FIXNUMP(v1rank)||ECL_BIGNUMP(v1rank))){
    goto L5;
   }
   {
    cl_object v3max;
    v3max = cl_list_length(ecl_cmp_symbol_value(cl_env_copy,VV[36]));
    if (!(ecl_lower(ecl_make_int8_t(0),v1rank))){
     goto L11;
    }
    if (ecl_lowereq(v1rank,v3max)) {
     goto L7;
    }
    goto L9;
L11:;
    goto L9;
L9:;
    cl_error(1, VV[305]);
   }
L7:;
   T0 = ecl_cmp_symbol_value(cl_env_copy,VV[36]);
   T1 = ecl_one_minus(v1rank);
   v2elect = ecl_elt(T0,ecl_to_size(T1));
   goto L4;
L5:;
   {
    cl_object v3;
    cl_object v4;
    v3 = ecl_cmp_symbol_value(cl_env_copy,VV[36]);
    v4 = ecl_fdefinition(ECL_SYM("PROCESS-NAME",1450));
    {
     cl_object v5;
     v5 = si_make_seq_iterator(2, v3, ecl_make_int8_t(0));
L19:;
     if (v5!=ECL_NIL) {
      goto L21;
     }
     v2elect = ECL_NIL;
     goto L15;
L21:;
     {
      cl_object v6;
      v6 = si_seq_iterator_ref(v3, v5);
      T0 = mp_process_name(v6);
      if (!(ecl_eql(v1rank,T0))){
       goto L23;
      }
      v2elect = v6;
      goto L15;
     }
L23:;
     v5 = si_seq_iterator_next(v3, v5);
     goto L19;
    }
   }
L15:;
L4:;
   if (Null(v2elect)){
    goto L2;
   }
   T0 = v2elect;
   ecl_cmp_setq(cl_env_copy,VV[35],T0);
  }
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
/* function definition for TPL-WAITING-COMMAND                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2860tpl_waiting_command()
{
 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:;
 L2772tpl_format(1, VV[312]);
 {
  cl_object v1;
  cl_object v2process;
  cl_object v3;
  {
   cl_object v4;
   v4 = ecl_cmp_symbol_value(cl_env_copy,VV[36]);
   if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v1 = v4;
  }
  v2process = ECL_NIL;
  v3 = v1;
  {
   cl_object v4rank;
   v4rank = ecl_make_int8_t(1);
   if (!(ecl_endp(v3))){
    goto L12;
   }
   goto L11;
L12:;
   v2process = ECL_CONS_CAR(v3);
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v3);
    if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v5;
   }
L10:;
   if (!((v2process)==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442))))){
    goto L22;
   }
   T0 = VV[313];
   goto L21;
L22:;
   T0 = VV[314];
L21:;
   L2772tpl_format(3, T0, v4rank, v2process);
   if (!(ecl_endp(v3))){
    goto L24;
   }
   goto L11;
L24:;
   v2process = ECL_CONS_CAR(v3);
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v3);
    if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v5;
   }
   v4rank = ecl_one_plus(v4rank);
   goto L10;
L11:;
  }
 }
 (ecl_terpri(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))));
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L2860tpl_waiting_command_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[311]);
 {
  return L2860tpl_waiting_command();
 }
}
/* function definition for DEFAULT-DEBUGGER                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2864default_debugger(cl_object volatile v1condition)
{
 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:;
 {
  volatile cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
  {
   cl_object v4, v5; cl_index v3;
   v4 = ECL_CONS_CAR(v2);
   v5 = ECL_CONS_CDR(v2);
   v3 = ecl_progv(cl_env_copy, v4, v5);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*QUERY-IO*",61),ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32))); /*  *QUERY-IO* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /*  *PRINT-PRETTY* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CIRCLE*",49),ECL_T); /*  *PRINT-CIRCLE* */
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(16)); /*  *PRINT-LENGTH* */
   value0 = ecl_cmp_symbol_value(cl_env_copy,VV[15]);
   if (value0!=ECL_NIL) {
    goto L7;
   }
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READTABLE*",67));
   goto L5;
L7:;
   T0 = value0;
   goto L5;
L5:;
   ecl_bds_bind(cl_env_copy,ECL_SYM("*READTABLE*",67),T0); /*  *READTABLE*    */
   T0 = cl_type_of(v1condition);
   T1 = cl_format(4, ECL_NIL, VV[317], T0, v1condition);
   ecl_bds_bind(cl_env_copy,VV[13],T1);           /*  *BREAK-MESSAGE*         */
   ecl_bds_bind(cl_env_copy,VV[14],v1condition);  /*  *BREAK-CONDITION*       */
   T0 = ecl_one_plus(ecl_cmp_symbol_value(cl_env_copy,VV[1]));
   ecl_bds_bind(cl_env_copy,VV[1],T0);            /*  *BREAK-LEVEL*           */
   ecl_bds_bind(cl_env_copy,VV[3],ECL_NIL);       /*  *BREAK-LOCALS*          */
   ecl_bds_bind(cl_env_copy,VV[2],ECL_NIL);       /*  *BREAK-LEXENV*          */
   L2858check_default_debugger_runaway();
   T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442));
   ecl_cmp_setq(cl_env_copy,VV[35],T0);
   {
    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 L13;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v6;
       v6 = ecl_make_cclosure_va((cl_objectfn)LC2861__lambda627,env2,Cblock,1);
       T0 = v6;
      }
      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* */
      if (Null(cl_listen(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61))))){
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       goto L12;
      }
      cl_clear_input(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      goto L12;
L13:;
      {
       cl_object v6condition;
       v6condition = ECL_CONS_CAR(CLV0);
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L12;
      }
      }
     }
    }
   }
L12:;
   {
    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 L22;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v6;
       v6 = ecl_make_cclosure_va((cl_objectfn)LC2862__lambda632,env2,Cblock,1);
       T0 = v6;
      }
      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* */
      cl_finish_output(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      goto L21;
L22:;
      {
       cl_object v6condition;
       v6condition = ECL_CONS_CAR(CLV0);
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L21;
      }
      }
     }
    }
   }
L21:;
   {
    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 L30;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v6;
       v6 = ecl_make_cclosure_va((cl_objectfn)LC2863__lambda637,env2,Cblock,1);
       T0 = v6;
      }
      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* */
      L2772tpl_format(2, VV[324], ecl_cmp_symbol_value(cl_env_copy,VV[13]));
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      goto L29;
L30:;
      {
       cl_object v6condition;
       v6condition = ECL_CONS_CAR(CLV0);
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L29;
      }
      }
     }
    }
   }
L29:;
L37:;
   {
    cl_object v6restart_commands;
    cl_object v7debug_commands;
    v6restart_commands = L2855compute_restart_commands(3, v1condition, VV[325], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
    v7debug_commands = L2857update_debug_commands(v6restart_commands);
    L2796tpl(2, VV[326], v7debug_commands);
   }
   goto L37;
  }
 }
}
static cl_object L2864default_debugger_va(cl_narg narg, cl_object v3condition, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[316]);
 {
  return L2864default_debugger(v3condition);
 }
}
/* function definition for INVOKE-DEBUGGER                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2865invoke_debugger(cl_object v1condition)
{
 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 v2old_hook;
  v2old_hook = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INVOKE-DEBUGGER-HOOK*",1861));
  if (Null(v2old_hook)){
   goto L2;
  }
  ecl_bds_bind(cl_env_copy,ECL_SYM("*INVOKE-DEBUGGER-HOOK*",1861),ECL_NIL); /*  *INVOKE-DEBUGGER-HOOK* */
  ecl_function_dispatch(cl_env_copy,v2old_hook)(2, v1condition, v2old_hook);
  ecl_bds_unwind1(cl_env_copy);
 }
L2:;
 {
  cl_object v2old_hook;
  v2old_hook = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUGGER-HOOK*",33));
  if (Null(v2old_hook)){
   goto L5;
  }
  ecl_bds_bind(cl_env_copy,ECL_SYM("*DEBUGGER-HOOK*",33),ECL_NIL); /*  *DEBUGGER-HOOK* */
  ecl_function_dispatch(cl_env_copy,v2old_hook)(2, v1condition, v2old_hook);
  ecl_bds_unwind1(cl_env_copy);
 }
L5:;
 if (!(ecl_lowereq(ecl_make_int8_t(0),ecl_cmp_symbol_value(cl_env_copy,VV[16])))){
  goto L9;
 }
 (cl_env_copy->function=(VV[316]->symbol.gfdef))->cfun.entry(1, v1condition) /*  DEFAULT-DEBUGGER */;
 goto L8;
L9:;
 ecl_bds_push(cl_env_copy,ECL_SYM("*INVOKE-DEBUGGER-HOOK*",1861)); /*  *INVOKE-DEBUGGER-HOOK* */
 ecl_bds_push(cl_env_copy,ECL_SYM("*DEBUGGER-HOOK*",33)); /*  *DEBUGGER-HOOK* */
 ecl_bds_push(cl_env_copy,VV[5]);                 /*  *IHS-TOP*               */
 ecl_bds_push(cl_env_copy,VV[16]);                /*  *TPL-LEVEL*             */
 ecl_bds_push(cl_env_copy,VV[21]);                /*  *TPL-COMMANDS*          */
 ecl_bds_bind(cl_env_copy,ECL_SYM("+",16),ECL_NIL); /*  +                     */
 ecl_bds_bind(cl_env_copy,ECL_SYM("++",17),ECL_NIL); /*  ++                   */
 ecl_bds_bind(cl_env_copy,ECL_SYM("+++",18),ECL_NIL); /*  +++                 */
 ecl_bds_bind(cl_env_copy,ECL_SYM("-",19),ECL_NIL); /*  -                     */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*",20),ECL_NIL); /*  *                     */
 ecl_bds_bind(cl_env_copy,ECL_SYM("**",21),ECL_NIL); /*  **                   */
 ecl_bds_bind(cl_env_copy,ECL_SYM("***",22),ECL_NIL); /*  ***                 */
 ecl_bds_bind(cl_env_copy,ECL_SYM("/",23),ECL_NIL); /*  /                     */
 ecl_bds_bind(cl_env_copy,ECL_SYM("//",24),ECL_NIL); /*  //                   */
 ecl_bds_bind(cl_env_copy,ECL_SYM("///",25),ECL_NIL); /*  ///                 */
 (cl_env_copy->function=(VV[316]->symbol.gfdef))->cfun.entry(1, v1condition) /*  DEFAULT-DEBUGGER */;
 ecl_bds_unwind_n(cl_env_copy,15);
L8:;
 value0 = cl_finish_output(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
 return value0;
}
static cl_object L2865invoke_debugger_va(cl_narg narg, cl_object v2condition, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[328]);
 {
  return L2865invoke_debugger(v2condition);
 }
}
/* function definition for SAFE-EVAL                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_safe_eval(volatile cl_narg narg, cl_object volatile v1form, cl_object volatile v2env, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SAFE-EVAL",1157));
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(ECL_SYM("SAFE-EVAL",1157));
 {
  cl_object volatile v3err_value_p;
  va_list args; va_start(args,v2env);
  {
   int i = 2;
   if (i >= narg) {
    env0 = ECL_NIL;
    CLV0 = env0 = CONS(ECL_NIL,env0);             /*  ERR-VALUE               */
    v3err_value_p = ECL_NIL;
   } else {
    i++;
    env0 = ECL_NIL;
    CLV0 = env0 = CONS(va_arg(args,cl_object),env0); /*  ERR-VALUE            */
    v3err_value_p = ECL_T;
   }
  }
  va_end(args);
  {
   CLV1 = env0 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env0); /*  SAFE-EVAL      */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
    if (__ecl_frs_push_result!=0) {
    ecl_frs_pop_n(cl_env_copy, 1);
    return cl_env_copy->values[0];
    } else {
    {
     volatile cl_object v4output;
     volatile cl_object v5ok;
     v4output = ECL_NIL;
     v5ok = ECL_NIL;
     {
      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 {
       if (Null(v3err_value_p)){
        goto L5;
       }
       {
        cl_object v6;
        v6 = ecl_make_cclosure_va((cl_objectfn)LC2866__lambda644,env0,Cblock,1);
        T0 = v6;
        goto L4;
       }
L5:;
       T0 = (VV[328]->symbol.gfdef);
L4:;
       T1 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T0);
       T2 = ecl_list1(T1);
       T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
       ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
       v4output = si_eval_with_env(2, v1form, v2env);
       v5ok = ECL_T;
       cl_env_copy->values[0] = ECL_T;
       cl_env_copy->nvalues = 1;
       ecl_bds_unwind1(cl_env_copy);
       }
      }
      ecl_frs_pop(cl_env_copy);
      ecl_stack_frame_push_values(_ecl_inner_frame);
      if (Null(v5ok)){
       goto L11;
      }
      value0 = v4output;
      cl_env_copy->nvalues = 1;
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_stack_frame_close(_ecl_inner_frame);
      return value0;
L11:;
      value0 = ECL_CONS_CAR(CLV0);
      cl_env_copy->nvalues = 1;
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_stack_frame_close(_ecl_inner_frame);
      return value0;
      ecl_stack_frame_pop_values(_ecl_inner_frame);
      if (unwinding) ecl_unwind(cl_env_copy,next_fr);
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_stack_frame_close(_ecl_inner_frame);
      return cl_env_copy->values[0];
     }
    }
    }
   }
  }
 }
}
/* closure LAMBDA90                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2783__lambda90(cl_narg narg, ...)
{
 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 */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure DO-QUERY-PROCESS                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2785do_query_process(cl_narg narg, ...)
{
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  ALL-PROCESSES           */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[82]);
 {
L1:;
  cl_print(1, ECL_CONS_CAR(CLV0));
  value0 = L2782query_process(1, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA130                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2786__lambda130(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2;
 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 ... */
 CLV2 = env0;                                     /*  TAGBODY                 */
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV1) = v1temp;
  cl_go(ECL_CONS_CAR(CLV2),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA132                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2787__lambda132(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2;
 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 ... */
 CLV2 = env0;                                     /*  TAGBODY                 */
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV1) = v1temp;
  cl_go(ECL_CONS_CAR(CLV2),ecl_make_fixnum(1));
 }
 }
}
/* local function LAMBDA134                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2788__lambda134(cl_object v1stream)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_princ(VV[88],v1stream);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2788__lambda134_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[87]);
 {
  return LC2788__lambda134(v2stream);
 }
}
/* closure REP                                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2791rep(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile CLV0, CLV1, CLV2, CLV3;
 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 ... */
 CLV2 = env0;                                     /*  VALUES                  */
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[98]);
 {
L1:;
  {
   cl_object volatile env1 = env0;
   CLV3 = env1 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env1); /*  REP            */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV3));
    if (__ecl_frs_push_result!=0) {
    ecl_frs_pop_n(cl_env_copy, 1);
    return cl_env_copy->values[0];
    } else {
    {
     cl_object volatile v1;
     v1 = ecl_make_cclosure_va((cl_objectfn)LC2790__lambda147,env1,Cblock,1);
     T0 = v1;
    }
    T1 = CONS(ECL_SYM("SERIOUS-CONDITION",745),T0);
    T2 = ecl_list1(T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
    {
     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 v1;
      v1 = 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),v1); /*  *INTERRUPTS-ENABLED* */
        L2775register_in_waiting_list(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
        L2777grab_console(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
        if (ECL_CONS_CAR(CLV0)!=ECL_NIL) {
         goto L8;
        }
        L2832break_where();
        ECL_CONS_CAR(CLV0) = ECL_T;
L8:;
        L2798tpl_prompt();
        T0 = (cl_env_copy->function=(VV[66]->symbol.gfdef))->cfun.entry(0) /*  TPL-READ */;
        ecl_cmp_setq(cl_env_copy,ECL_SYM("-",19),T0);
        {
         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);
         cl_env_copy->values[0] = si_eval_with_env(2, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("-",19)), ecl_cmp_symbol_value(cl_env_copy,VV[2]));
         ecl_stack_frame_push_values(_ecl_inner_frame);
         ECL_CONS_CAR(CLV2) = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
         ecl_stack_frame_close(_ecl_inner_frame);
        }
        T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("//",24));
        ecl_cmp_setq(cl_env_copy,ECL_SYM("///",25),T0);
        T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("/",23));
        ecl_cmp_setq(cl_env_copy,ECL_SYM("//",24),T0);
        T0 = ECL_CONS_CAR(CLV2);
        ecl_cmp_setq(cl_env_copy,ECL_SYM("/",23),T0);
        T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("**",21));
        ecl_cmp_setq(cl_env_copy,ECL_SYM("***",22),T0);
        T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*",20));
        ecl_cmp_setq(cl_env_copy,ECL_SYM("**",21),T0);
        T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("/",23)));
        ecl_cmp_setq(cl_env_copy,ECL_SYM("*",20),T0);
        cl_env_copy->values[0] = L2772tpl_format(2, VV[103], ECL_CONS_CAR(CLV2));
        ecl_bds_unwind1(cl_env_copy);
        }
       }
       ecl_frs_pop(cl_env_copy);
       ecl_stack_frame_push_values(_ecl_inner_frame);
       L2776delete_from_waiting_list(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
       L2778release_console(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*CURRENT-PROCESS*",1442)));
       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 L32;
     }
     si_check_pending_interrupts();
L32:;
     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);
     return cl_env_copy->values[0];
    }
    }
   }
  }
 }
 }
}
/* closure LAMBDA168                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2792__lambda168(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV3) = v1temp;
  cl_go(ECL_CONS_CAR(CLV4),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA170                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2793__lambda170(cl_object v1stream)
{
 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_format(2, v1stream, VV[108]);
 return value0;
}
static cl_object LC2793__lambda170_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[107]);
 {
  return LC2793__lambda170(v2stream);
 }
}
/* closure LAMBDA177                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2794__lambda177(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV3) = v1temp;
  cl_go(ECL_CONS_CAR(CLV4),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA179                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2795__lambda179(cl_narg narg, cl_object v1stream, ...)
{
 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;
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);                           /*  BREAK-LEVEL             */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[112]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[113], ECL_CONS_CAR(CLV1));
  return value0;
 }
 }
}
/* local function LAMBDA272                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2802__lambda272(cl_object v1c)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_make_bool(((v1c)==ECL_CODE_CHAR((ecl_character)(32))));
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = ecl_make_bool(((v1c)==ECL_CODE_CHAR((ecl_character)(9))));
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2802__lambda272_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[144]);
 {
  return LC2802__lambda272(v2c);
 }
}
/* closure PROCESS-ENV-RECORD                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2822process_env_record(cl_narg narg, cl_object v1record, ...)
{
 cl_object T0, T1;
 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;                                     /*  RECORD1                 */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[189]);
 {
L1:;
  if (!(ECL_ATOM(v1record))){
   goto L2;
  }
  T0 = si_compiled_function_name(v1record);
  ECL_CONS_CAR(CLV0) = CONS(T0,ECL_CONS_CAR(CLV0));
  value0 = ECL_CONS_CAR(CLV0);
  cl_env_copy->nvalues = 1;
  return value0;
L2:;
  ECL_CONS_CAR(CLV3) = ecl_car(v1record);
  ECL_CONS_CAR(CLV4) = ecl_cdr(v1record);
  if (!(ECL_STRINGP(ECL_CONS_CAR(CLV3)))){
   goto L11;
  }
  T0 = cl_find_package(VV[190]);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*         */
  {
   cl_object v2;
   v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
   {
    cl_object v4, v5; cl_index v3;
    v4 = ECL_CONS_CAR(v2);
    v5 = ECL_CONS_CDR(v2);
    v3 = ecl_progv(cl_env_copy, v4, v5);
    ECL_CONS_CAR(CLV3) = cl_read_from_string(1, ECL_CONS_CAR(CLV3));
    ecl_bds_unwind(cl_env_copy,v3);
    ecl_bds_unwind1(cl_env_copy);
   }
  }
L11:;
  if (ECL_SYMBOLP(ECL_CONS_CAR(CLV3))) {
   goto L17;
  }
  if (!(ECL_STRINGP(ECL_CONS_CAR(CLV3)))){
   goto L5;
  }
  goto L6;
L17:;
L6:;
  T0 = ECL_CONS_CAR(CLV3);
  T1 = ECL_CONS_CAR(CLV4);
  ECL_CONS_CAR(CLV2) = cl_acons(T0, T1, ECL_CONS_CAR(CLV2));
  value0 = ECL_CONS_CAR(CLV2);
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  if (!(ECL_SYMBOLP(ECL_CONS_CAR(CLV4)))){
   goto L22;
  }
  T0 = ECL_CONS_CAR(CLV4);
  ECL_CONS_CAR(CLV1) = CONS(T0,ECL_CONS_CAR(CLV1));
  value0 = ECL_CONS_CAR(CLV1);
  cl_env_copy->nvalues = 1;
  return value0;
L22:;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function EXTRACT-RESTARTS                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2821extract_restarts(cl_object v1variables_alist)
{
 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 = ECL_SYM("*RESTART-CLUSTERS*",5);
   v4 = v1variables_alist;
   v2record = ecl_assql(v3,v4);
  }
  if (Null(v2record)){
   goto L5;
  }
  {
   cl_object v3bindings;
   cl_object v4new_bindings;
   v3bindings = ecl_cdr(v2record);
   v4new_bindings = ecl_car(v3bindings);
   T0 = cl_delete(2, v2record, v1variables_alist);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = v4new_bindings;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
  }
L5:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = v1variables_alist;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2821extract_restarts_va(cl_narg narg, cl_object v5variables_alist, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[188]);
 {
  return LC2821extract_restarts(v5variables_alist);
 }
}
/* local function SPECIAL-VARIABLES-ALIST                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2820special_variables_alist(cl_object v1ihs_index)
{
 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 v2top;
  v2top = si_ihs_top();
  if (ecl_greater(v1ihs_index,v2top)) {
   goto L3;
  }
  {
   cl_object v3bds_min;
   cl_object v4bds_top;
   cl_object v5bds_max;
   cl_object v6variables;
   T0 = si_ihs_bds(v1ihs_index);
   v3bds_min = ecl_one_plus(T0);
   v4bds_top = si_bds_top();
   if (!(ecl_number_equalp(v1ihs_index,v2top))){
    goto L8;
   }
   v5bds_max = v4bds_top;
   goto L7;
L8:;
   T0 = ecl_one_plus(v1ihs_index);
   v5bds_max = si_ihs_bds(T0);
L7:;
   v6variables = LC2819newly_bound_special_variables(v3bds_min, v5bds_max);
   {
    cl_object v7output;
    v7output = ECL_NIL;
    {
     cl_object v8;
     cl_object v9;
     cl_object v10i;
     v8 = ecl_one_plus(v5bds_max);
     v9 = v4bds_top;
     v10i = v8;
     {
      cl_object v11var;
      v11var = ECL_NIL;
L16:;
      if (!(ecl_greater(v10i,v9))){
       goto L18;
      }
      goto L17;
L18:;
      v11var = si_bds_var(v10i);
      {
       cl_object v12;
       cl_object v13;
       cl_object v14;
       v12 = (ECL_SYM("EQ",335)->symbol.gfdef);
       v13 = v11var;
       v14 = v6variables;
       if (Null(si_memq(v13,v14))){
        goto L22;
       }
      }
      v6variables = cl_delete(2, v11var, v6variables);
      T0 = si_bds_val(v10i);
      v7output = cl_acons(v11var, T0, v7output);
L22:;
      v10i = ecl_one_plus(v10i);
      goto L16;
L17:;
      {
       cl_object v12;
       cl_object v13v;
       cl_object v14;
       {
        cl_object v15;
        v15 = v6variables;
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       v13v = ECL_NIL;
       v14 = v12;
       {
        cl_object v15;
        cl_object v16;
        v15 = ecl_list1(ECL_NIL);
        v16 = v15;
L42:;
        if (!(ecl_endp(v14))){
         goto L44;
        }
        goto L43;
L44:;
        v13v = ECL_CONS_CAR(v14);
        {
         cl_object v17;
         v17 = ECL_CONS_CDR(v14);
         if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v14 = v17;
        }
        {
         cl_object v17;
         v17 = v16;
         if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T1 = v17;
        }
        T2 = cl_symbol_value(v13v);
        T3 = CONS(v13v,T2);
        v16 = ecl_list1(T3);
        (ECL_CONS_CDR(T1)=v16,T1);
        goto L42;
L43:;
        T0 = ecl_cdr(v15);
        goto L34;
       }
      }
L34:;
      value0 = ecl_append(T0,v7output);
      cl_env_copy->nvalues = 1;
      return value0;
     }
    }
   }
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2820special_variables_alist_va(cl_narg narg, cl_object v12ihs_index, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[187]);
 {
  return LC2820special_variables_alist(v12ihs_index);
 }
}
/* local function NEWLY-BOUND-SPECIAL-VARIABLES                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2819newly_bound_special_variables(cl_object v1bds_min, cl_object v2bds_max)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  cl_object v5i;
  {
   cl_object v6;
   v6 = v1bds_min;
   {
    bool v7;
    v7 = ecl_numberp(v6);
    if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(ECL_SYM("NUMBER",608),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
   }
   v3 = v6;
  }
  {
   cl_object v6;
   v6 = v2bds_max;
   {
    bool v7;
    v7 = ecl_numberp(v6);
    if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(ECL_SYM("NUMBER",608),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
   }
   v4 = v6;
  }
  v5i = v3;
  {
   cl_object v6variable;
   v6variable = ECL_NIL;
   {
    cl_object v7;
    cl_object v8;
    cl_object v9output;
    v7 = ecl_list1(ECL_NIL);
    v8 = v7;
    v9output = ECL_NIL;
L13:;
    if (!(ecl_greater(v5i,v4))){
     goto L15;
    }
    goto L14;
L15:;
    v6variable = si_bds_var(v5i);
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     v10 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v11 = v6variable;
     v12 = v9output;
     if (si_memq(v11,v12)!=ECL_NIL) {
      goto L19;
     }
    }
    {
     cl_object v10;
     v10 = v8;
     if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v10;
    }
    v8 = ecl_list1(v6variable);
    (ECL_CONS_CDR(T0)=v8,T0);
    v9output = ecl_cdr(v7);
L19:;
    v5i = ecl_one_plus(v5i);
    goto L13;
L14:;
    value0 = v9output;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object LC2819newly_bound_special_variables_va(cl_narg narg, cl_object v10bds_min, cl_object v11bds_max, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[186]);
 {
  return LC2819newly_bound_special_variables(v10bds_min, v11bds_max);
 }
}
/* local function LAMBDA404                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2826__lambda404(cl_object v1s1, cl_object v2s2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_SYMBOLP(v2s2))){
  goto L2;
 }
 v2s2 = ecl_symbol_name(v2s2);
L2:;
 if (!(ECL_STRINGP(v2s2))){
  goto L5;
 }
 value0 = cl_string_equal(2, v1s1, v2s2);
 return value0;
L5:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2826__lambda404_va(cl_narg narg, cl_object v3s1, cl_object v4s2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[206]);
 {
  return LC2826__lambda404(v3s1, v4s2);
 }
}
/* local function LAMBDA592                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2856__lambda592(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 = ecl_car(v1x);
 value0 = cl_stringE(2, VV[285], T0);
 return value0;
}
static cl_object LC2856__lambda592_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[297]);
 {
  return LC2856__lambda592(v2x);
 }
}
/* closure LAMBDA627                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2861__lambda627(cl_narg narg, cl_object v1temp, ...)
{
 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[319]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA632                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2862__lambda632(cl_narg narg, cl_object v1temp, ...)
{
 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[321]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA637                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2863__lambda637(cl_narg narg, cl_object v1temp, ...)
{
 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[323]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA644                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2866__lambda644(cl_narg narg, cl_object v1condition, ...)
{
 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;                                     /*  SAFE-EVAL               */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[329]);
 {
L1:;
  cl_env_copy->values[0] = ECL_CONS_CAR(CLV0);
  cl_env_copy->nvalues = 1;
  cl_return_from(ECL_CONS_CAR(CLV1),ECL_SYM("SAFE-EVAL",1157));
 }
 }
}
/* closure LAMBDA147                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2790__lambda147(cl_narg narg, cl_object v1condition, ...)
{
 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;                                     /*  REP                     */
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[99]);
 {
L1:;
  cl_clear_input(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  {
   cl_object v2;
   v2 = ecl_make_bool(ecl_lower(ECL_CONS_CAR(CLV1),ecl_make_int8_t(1)));
   if (Null(v2)){
    goto L4;
   }
   value0 = v2;
   cl_env_copy->nvalues = 1;
   return value0;
L4:;
   {
    cl_object v3;
    v3 = ecl_cmp_symbol_value(cl_env_copy,VV[53]);
    if (Null(v3)){
     goto L7;
    }
    value0 = v3;
    cl_env_copy->nvalues = 1;
    return value0;
L7:;
    T0 = cl_type_of(v1condition);
    L2772tpl_format(3, VV[100], T0, v1condition);
    L2772tpl_format(1, VV[101]);
    cl_env_copy->values[0] = ECL_T;
    cl_env_copy->nvalues = 1;
    cl_return_from(ECL_CONS_CAR(CLV3),VV[98]);
   }
  }
 }
 }
}
#include "clos/top.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclPKhqiz3cklOm9_sTG0M881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:LSP;TOP.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclPKhqiz3cklOm9_sTG0M881@";
 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]);
  cl_export(1, VVtemp[1]);
  si_Xmake_special(ECL_SYM("*QUIT-TAG*",1836));
  T0 = CONS(ECL_NIL,ECL_NIL);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836),T0);
  si_Xmake_special(VV[0]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[0],T0);
  si_Xmake_special(VV[1]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[1],T0);
  si_Xmake_special(VV[2]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[2],T0);
  si_Xmake_special(VV[3]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[3],T0);
  si_Xmake_special(VV[4]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[4],T0);
  si_Xmake_special(VV[5]);
  T0 = si_ihs_top();
  ecl_cmp_setq(cl_env_copy,VV[5],T0);
  si_Xmake_special(VV[6]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  si_Xmake_special(VV[7]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[7],T0);
  si_Xmake_special(VV[8]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[8],T0);
  si_Xmake_special(VV[9]);
  T0 = ECL_T;
  ecl_cmp_setq(cl_env_copy,VV[9],T0);
  si_Xmake_special(VV[10]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[10],T0);
  si_Xmake_special(VV[11]);
  T0 = CONS(ECL_NIL,ECL_NIL);
  ecl_cmp_setq(cl_env_copy,VV[11],T0);
  si_Xmake_special(VV[12]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[12],T0);
  si_Xmake_special(VV[13]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[13],T0);
  si_Xmake_special(VV[14]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[14],T0);
  si_Xmake_special(VV[15]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[15],T0);
  si_Xmake_special(VV[16]);
  T0 = ecl_make_int8_t(-1);
  ecl_cmp_setq(cl_env_copy,VV[16],T0);
  si_Xmake_special(ECL_SYM("*STEP-LEVEL*",1035));
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035),T0);
  si_Xmake_special(VV[17]);
  T0 = VVtemp[2];
  ecl_cmp_setq(cl_env_copy,VV[17],T0);
  si_Xmake_special(VV[18]);
  T0 = cl_find_package(ECL_SYM("SYSTEM",1185));
  T1 = ecl_list1(T0);
  ecl_cmp_setq(cl_env_copy,VV[18],T1);
  si_Xmake_constant(VV[19], VV[20]);
  si_Xmake_special(VV[21]);
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[19]);
  ecl_cmp_setq(cl_env_copy,VV[21],T0);
  si_Xmake_constant(VV[22], VV[23]);
  si_Xmake_special(VV[24]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[24],T0);
  ecl_cmp_defun(VV[330]);                         /*  TPL-FORMAT              */
  ecl_cmp_defun(VV[331]);                         /*  TOP-LEVEL               */
  si_Xmake_special(VV[33]);
  T0 = mp_make_lock(2, ECL_SYM("NAME",1309), VVtemp[3]);
  ecl_cmp_setq(cl_env_copy,VV[33],T0);
  si_Xmake_special(VV[34]);
  T0 = mp_make_condition_variable();
  ecl_cmp_setq(cl_env_copy,VV[34],T0);
  si_Xmake_special(VV[35]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[35],T0);
  si_Xmake_special(VV[36]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[36],T0);
  ecl_cmp_defun(VV[332]);                         /*  CANDIDATE-TO-GET-CONSOLE-P */
  ecl_cmp_defun(VV[333]);                         /*  REGISTER-IN-WAITING-LIST */
  ecl_cmp_defun(VV[334]);                         /*  DELETE-FROM-WAITING-LIST */
  ecl_cmp_defun(VV[335]);                         /*  GRAB-CONSOLE            */
  ecl_cmp_defun(VV[336]);                         /*  RELEASE-CONSOLE         */
  ecl_cmp_defmacro(VV[337]);                      /*  WITH-GRABBED-CONSOLE    */
  si_Xmake_special(VV[53]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[53],T0);
  si_Xmake_special(VV[54]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[54],T0);
  ecl_cmp_defun(VV[338]);                         /*  SIMPLE-TERMINAL-INTERRUPT */
  ecl_cmp_defun(VV[339]);                         /*  SHOW-PROCESS-LIST       */
  ecl_cmp_defun(VV[340]);                         /*  QUERY-PROCESS           */
  si_Xmake_special(VV[69]);
  T0 = ECL_T;
  ecl_cmp_setq(cl_env_copy,VV[69],T0);
  ecl_cmp_defun(VV[341]);                         /*  SINGLE-THREADED-TERMINAL-INTERRUPT */
  ecl_cmp_defun(VV[342]);                         /*  TERMINAL-INTERRUPT      */
  ecl_cmp_defun(VV[343]);                         /*  TPL                     */
  ecl_cmp_defun(VV[344]);                         /*  TPL-READ                */
  ecl_cmp_defun(VV[345]);                         /*  TPL-PROMPT              */
  si_Xmake_special(VV[130]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[130],T0);
  ecl_cmp_defun(VV[346]);                         /*  HARDEN-COMMAND          */
  ecl_cmp_defun(VV[347]);                         /*  TPL-MAKE-COMMAND        */
  ecl_cmp_defun(VV[348]);                         /*  TPL-PARSE-FORMS         */
  ecl_cmp_defun(VV[349]);                         /*  TPL-PARSE-STRINGS       */
  ecl_cmp_defun(VV[350]);                         /*  TPL-UNKNOWN-COMMAND     */
  ecl_cmp_defun(VV[351]);                         /*  TPL-POP-COMMAND         */
  ecl_cmp_defun(VV[352]);                         /*  TPL-QUIT-COMMAND        */
  ecl_cmp_defun(VV[353]);                         /*  TPL-PREVIOUS            */
  ecl_cmp_defun(VV[354]);                         /*  TPL-NEXT                */
  ecl_cmp_defun(VV[355]);                         /*  TPL-GO                  */
  ecl_cmp_defun(VV[356]);                         /*  TPL-PRINT-MESSAGE       */
  ecl_cmp_defun(VV[357]);                         /*  TPL-DISASSEMBLE-COMMAND */
  ecl_cmp_defun(VV[358]);                         /*  TPL-LAMBDA-EXPRESSION-COMMAND */
  (void)0; /* No entry created for LAMBDA-LIST-FROM-ANNOTATIONS */
  ecl_cmp_defun(VV[359]);                         /*  FUNCTION-LAMBDA-LIST    */
  ecl_cmp_defun(VV[360]);                         /*  DECODE-ENV-ELT          */
  ecl_cmp_defun(VV[361]);                         /*  DECODE-IHS-ENV          */
  ecl_cmp_defun(VV[362]);                         /*  DECODE-IHS-LOCALS       */
  ecl_cmp_defun(VV[363]);                         /*  DECODE-IHS-LEXENV       */
  ecl_cmp_defun(VV[364]);                         /*  IHS-ENVIRONMENT         */
  ecl_cmp_defun(VV[365]);                         /*  TPL-PRINT-VARIABLES     */
  ecl_cmp_defun(VV[366]);                         /*  TPL-VARIABLES-COMMAND   */
  ecl_cmp_defun(VV[367]);                         /*  TPL-INSPECT-COMMAND     */
  ecl_cmp_defun(VV[368]);                         /*  TPL-BDS-COMMAND         */
  ecl_cmp_defun(VV[369]);                         /*  TPL-BACKTRACE           */
  ecl_cmp_defun(VV[370]);                         /*  TPL-FRS-COMMAND         */
  ecl_cmp_defun(VV[371]);                         /*  PRINT-FRS               */
  ecl_cmp_defun(VV[372]);                         /*  BREAK-WHERE             */
  ecl_cmp_defun(VV[373]);                         /*  TPL-PRINT-CURRENT       */
  ecl_cmp_defun(VV[374]);                         /*  TPL-HIDE                */
  ecl_cmp_defun(VV[375]);                         /*  TPL-UNHIDE              */
  ecl_cmp_defun(VV[376]);                         /*  TPL-UNHIDE-PACKAGE      */
  ecl_cmp_defun(VV[377]);                         /*  TPL-UNHIDE-ALL          */
  ecl_cmp_defun(VV[378]);                         /*  TPL-HIDE-PACKAGE        */
  ecl_cmp_defun(VV[379]);                         /*  IHS-VISIBLE             */
  ecl_cmp_defun(VV[380]);                         /*  IHS-FNAME               */
  ecl_cmp_defun(VV[381]);                         /*  SET-CURRENT-IHS         */
  ecl_cmp_defun(VV[382]);                         /*  SET-BREAK-ENV           */
  ecl_cmp_defun(VV[383]);                         /*  IHS-SEARCH              */
  ecl_cmp_defun(VV[384]);                         /*  TPL-BACKWARD-SEARCH     */
  ecl_cmp_defun(VV[385]);                         /*  TPL-FORWARD-SEARCH      */
  ecl_cmp_defun(VV[386]);                         /*  TPL-APROPOS-COMMAND     */
  ecl_cmp_defun(VV[387]);                         /*  TPL-DOCUMENT-COMMAND    */
  ecl_cmp_defun(VV[388]);                         /*  TPL-STEP-COMMAND        */
  ecl_cmp_defun(VV[389]);                         /*  TPL-TRACE-COMMAND       */
  ecl_cmp_defun(VV[390]);                         /*  TPL-UNTRACE-COMMAND     */
  si_Xmake_special(VV[269]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[269],T0);
  ecl_cmp_defun(VV[391]);                         /*  TPL-LOAD-COMMAND        */
  si_Xmake_special(VV[272]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[272],T0);
  ecl_cmp_defun(VV[392]);                         /*  TPL-COMPILE-COMMAND     */
  ecl_cmp_defun(VV[393]);                         /*  TPL-HELP-COMMAND        */
  ecl_cmp_defun(VV[394]);                         /*  TPL-HELP-STACK-COMMAND  */
  ecl_cmp_defun(VV[395]);                         /*  COMPUTE-RESTART-COMMANDS */
  ecl_cmp_defun(VV[396]);                         /*  UPDATE-DEBUG-COMMANDS   */
  si_Xmake_special(VV[299]);
  T0 = ecl_make_int8_t(16);
  ecl_cmp_setq(cl_env_copy,VV[299],T0);
  ecl_cmp_defun(VV[397]);                         /*  CHECK-DEFAULT-DEBUGGER-RUNAWAY */
  ecl_cmp_defun(VV[398]);                         /*  TPL-SWITCH-COMMAND      */
  ecl_cmp_defun(VV[399]);                         /*  TPL-WAITING-COMMAND     */
  ecl_cmp_defun(VV[400]);                         /*  DEFAULT-DEBUGGER        */
  ecl_cmp_defun(VV[401]);                         /*  INVOKE-DEBUGGER         */
  (void)0; /* No entry created for SAFE-EVAL */
 }
}
