/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/trace.lsp                       */
#include <ecl/ecl-cmp.h>
#include "lsp/trace.eclh"
/* local function TRACE                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC387trace(cl_object v1, cl_object v2)
{
 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;
  v3 = ecl_cdr(v1);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v3);
  value0 = cl_list(2, VV[2], T0);
  return value0;
 }
}
static cl_object LC387trace_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[3]);
 {
  return LC387trace(v4, v5);
 }
}
/* function definition for TRACE*                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L388trace_(cl_object v1r)
{
 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 (!(v1r==ECL_NIL)){
  goto L2;
 }
 {
  cl_object v2;
  v2 = (ECL_SYM("FIRST",373)->symbol.gfdef);
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946));
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v6;
   }
   v4 = ECL_NIL;
   v5 = v3;
   {
    cl_object v6;
    cl_object v7;
    v6 = ecl_list1(ECL_NIL);
    v7 = v6;
L12:;
    if (!(ecl_endp(v5))){
     goto L14;
    }
    goto L13;
L14:;
    v4 = ECL_CONS_CAR(v5);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v5);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    {
     cl_object v8;
     v8 = v7;
     if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v8;
    }
    T1 = ecl_function_dispatch(cl_env_copy,v2)(1, v4);
    v7 = ecl_list1(T1);
    (ECL_CONS_CDR(T0)=v7,T0);
    goto L12;
L13:;
    value0 = ecl_cdr(v6);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
L2:;
 {
  cl_object v8;
  v8 = (VV[9]->symbol.gfdef);
  {
   cl_object v9;
   cl_object v10;
   cl_object v11;
   {
    cl_object v12;
    v12 = v1r;
    if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v9 = v12;
   }
   v10 = ECL_NIL;
   v11 = v9;
L36:;
   if (!(ecl_endp(v11))){
    goto L38;
   }
   goto L37;
L38:;
   v10 = ECL_CONS_CAR(v11);
   {
    cl_object v12;
    v12 = ECL_CONS_CDR(v11);
    if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v11 = v12;
   }
   ecl_function_dispatch(cl_env_copy,v8)(1, v10);
   goto L36;
L37:;
   value0 = v1r;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L388trace__va(cl_narg narg, cl_object v12r, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[2]);
 {
  return L388trace_(v12r);
 }
}
/* local function UNTRACE                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC389untrace(cl_object v1, cl_object v2)
{
 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;
  v3 = ecl_cdr(v1);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v3);
  value0 = cl_list(2, VV[11], T0);
  return value0;
 }
}
static cl_object LC389untrace_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[12]);
 {
  return LC389untrace(v4, v5);
 }
}
/* function definition for UNTRACE*                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L390untrace_(cl_object v1r)
{
 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 = (VV[13]->symbol.gfdef);
  {
   cl_object v3;
   value0 = v1r;
   if (value0!=ECL_NIL) {
    goto L5;
   }
   v3 = L388trace_(ECL_NIL);
   goto L3;
L5:;
   v3 = value0;
   goto L3;
L3:;
   {
    cl_object v4;
    cl_object v5;
    cl_object v6;
    {
     cl_object v7;
     v7 = v3;
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v4 = v7;
    }
    v5 = ECL_NIL;
    v6 = v4;
L12:;
    if (!(ecl_endp(v6))){
     goto L14;
    }
    goto L13;
L14:;
    v5 = ECL_CONS_CAR(v6);
    {
     cl_object v7;
     v7 = ECL_CONS_CDR(v6);
     if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v7;
    }
    ecl_function_dispatch(cl_env_copy,v2)(1, v5);
    goto L12;
L13:;
    value0 = v3;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L390untrace__va(cl_narg narg, cl_object v7r, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[11]);
 {
  return L390untrace_(v7r);
 }
}
/* function definition for TRACE-ONE                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L391trace_one(cl_object v1spec)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2break;
  cl_object v3exitbreak;
  cl_object v4entrycond;
  cl_object v5exitcond;
  cl_object v6entry;
  cl_object v7exit;
  cl_object v8step;
  cl_object v9barfp;
  cl_object v10fname;
  cl_object v11oldf;
  v2break = ECL_NIL;
  v3exitbreak = ECL_NIL;
  v4entrycond = ECL_T;
  v5exitcond = ECL_T;
  v6entry = ECL_NIL;
  v7exit = ECL_NIL;
  v8step = ECL_NIL;
  v9barfp = ECL_T;
  v10fname = ECL_NIL;
  v11oldf = ECL_NIL;
  if (Null(si_valid_function_name_p(v1spec))){
   goto L13;
  }
  v10fname = v1spec;
  goto L12;
L13:;
  if (si_proper_list_p(v1spec)!=ECL_NIL) {
   goto L16;
  }
  cl_error(2, VV[16], v1spec);
  goto L12;
L16:;
  T0 = ecl_car(v1spec);
  if (Null(si_valid_function_name_p(T0))){
   goto L18;
  }
  v10fname = ecl_car(v1spec);
  {
   cl_object v12specs;
   v12specs = ecl_cdr(v1spec);
   goto L25;
L24:;
   {
    cl_object v13;
    v13 = ecl_car(v12specs);
    if (!((v13)==(VV[17]))){
     goto L29;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v2break = ecl_car(v12specs);
    goto L27;
L29:;
    if (!((v13)==(VV[18]))){
     goto L36;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v3exitbreak = ecl_car(v12specs);
    goto L27;
L36:;
    if (!((v13)==(VV[19]))){
     goto L43;
    }
    v8step = ECL_T;
    goto L27;
L43:;
    if (!((v13)==(VV[20]))){
     goto L46;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v4entrycond = ecl_car(v12specs);
    v5exitcond = v4entrycond;
    goto L27;
L46:;
    if (!((v13)==(VV[21]))){
     goto L54;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v4entrycond = ecl_car(v12specs);
    goto L27;
L54:;
    if (!((v13)==(VV[22]))){
     goto L61;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v5exitcond = ecl_car(v12specs);
    goto L27;
L61:;
    if (!((v13)==(ECL_SYM("PRINT",1327)))){
     goto L68;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v6entry = ecl_car(v12specs);
    goto L27;
L68:;
    if (!((v13)==(VV[23]))){
     goto L75;
    }
    v9barfp = v12specs;
    v12specs = ecl_cdr(v12specs);
    v7exit = ecl_car(v12specs);
    goto L27;
L75:;
    T0 = ecl_car(v12specs);
    cl_error(2, VV[24], T0);
   }
L27:;
   if (v9barfp!=ECL_NIL) {
    goto L82;
   }
   cl_error(1, VV[25]);
L82:;
   v12specs = ecl_cdr(v12specs);
L25:;
   if (v12specs==ECL_NIL) {
    goto L86;
   }
   goto L24;
L86:;
   goto L12;
  }
L18:;
  T0 = ecl_car(v1spec);
  if (Null(si_proper_list_p(T0))){
   goto L88;
  }
  {
   cl_object v13results;
   v13results = ECL_NIL;
   {
    cl_object v14;
    v14 = ecl_car(v1spec);
    goto L95;
L94:;
    {
     cl_object v15fname;
     v15fname = ecl_car(v14);
     T0 = ecl_cdr(v1spec);
     T1 = CONS(v15fname,T0);
     T2 = L391trace_one(T1);
     v13results = CONS(T2,v13results);
    }
    v14 = ecl_cdr(v14);
L95:;
    if (Null(v14)){
     goto L103;
    }
    goto L94;
L103:;
   }
   value0 = cl_nreverse(v13results);
   return value0;
  }
L88:;
  cl_error(2, VV[16], v1spec);
L12:;
  T0 = cl_fboundp(v10fname);
  if (!(T0==ECL_NIL)){
   goto L105;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[26], v10fname) /*  WARN */;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L105:;
  if (!(ECL_SYMBOLP(v10fname))){
   goto L108;
  }
  if (Null(cl_special_operator_p(v10fname))){
   goto L110;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[27], v10fname) /*  WARN */;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L110:;
  if (Null(cl_macro_function(1, v10fname))){
   goto L108;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[28], v10fname) /*  WARN */;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L108:;
  {
   cl_object v12record;
   v12record = L393trace_record(v10fname);
   if (Null(v12record)){
    goto L115;
   }
   if (Null(L399traced_and_redefined_p(v12record))){
    goto L118;
   }
   L397delete_from_trace_list(v10fname);
   goto L115;
L118:;
   (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[32], v10fname) /*  WARN */;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L115:;
  v11oldf = cl_fdefinition(v10fname);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v11oldf);
  T1 = cl_list(3, ECL_SYM("APPLY",91), T0, VV[35]);
  T2 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), T1);
  T3 = cl_list(3, ECL_SYM("SETQ",754), ECL_SYM("VALUES",899), T2);
  if (Null(v4entrycond)){
   goto L125;
  }
  if (!((ECL_T)==(v4entrycond))){
   goto L127;
  }
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T6 = cl_listX(5, VV[37], VV[38], T5, VV[35], v6entry);
  T4 = ecl_list1(T6);
  goto L124;
L127:;
  T5 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T6 = cl_listX(5, VV[37], VV[38], T5, VV[35], v6entry);
  T7 = cl_list(3, ECL_SYM("WHEN",909), v4entrycond, T6);
  T4 = ecl_list1(T7);
  goto L124;
L125:;
  T4 = ECL_NIL;
L124:;
  if (Null(v2break)){
   goto L130;
  }
  T6 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T7 = cl_list(3, ECL_SYM("BREAK",160), VV[40], T6);
  T8 = cl_list(3, ECL_SYM("LET",479), VV[39], T7);
  T9 = cl_list(3, ECL_SYM("WHEN",909), v2break, T8);
  T5 = ecl_list1(T9);
  goto L129;
L130:;
  T5 = ECL_NIL;
L129:;
  T6 = cl_list(2, ECL_SYM("QUOTE",682), v11oldf);
  T7 = cl_list(3, ECL_SYM("APPLY",91), T6, VV[35]);
  T8 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), T7);
  T9 = cl_list(3, ECL_SYM("LET",479), VV[39], T8);
  T10 = cl_list(3, ECL_SYM("SETQ",754), ECL_SYM("VALUES",899), T9);
  if (Null(v5exitcond)){
   goto L133;
  }
  if (!((ECL_T)==(v5exitcond))){
   goto L135;
  }
  T12 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T13 = cl_listX(5, VV[37], VV[41], T12, ECL_SYM("VALUES",899), v7exit);
  T11 = ecl_list1(T13);
  goto L132;
L135:;
  T12 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T13 = cl_listX(5, VV[37], VV[41], T12, ECL_SYM("VALUES",899), v7exit);
  T14 = cl_list(3, ECL_SYM("WHEN",909), v5exitcond, T13);
  T11 = ecl_list1(T14);
  goto L132;
L133:;
  T11 = ECL_NIL;
L132:;
  if (Null(v3exitbreak)){
   goto L138;
  }
  T13 = cl_list(2, ECL_SYM("QUOTE",682), v10fname);
  T14 = cl_list(3, ECL_SYM("BREAK",160), VV[42], T13);
  T15 = cl_list(3, ECL_SYM("LET",479), VV[39], T14);
  T16 = cl_list(3, ECL_SYM("WHEN",909), v3exitbreak, T15);
  T12 = ecl_list1(T16);
  goto L137;
L138:;
  T12 = ECL_NIL;
L137:;
  T13 = ecl_append(T11,T12);
  T14 = CONS(T10,T13);
  T15 = cl_append(3, T4, T5, T14);
  T16 = cl_listX(3, ECL_SYM("LET",479), VV[36], T15);
  T17 = cl_list(4, ECL_SYM("IF",950), VV[15], T3, T16);
  T18 = cl_list(4, ECL_SYM("LET*",480), VV[34], T17, VV[43]);
  T19 = cl_list(4, ECL_SYM("DEFUN",291), v10fname, VV[33], T18);
  cl_eval(T19);
  L398add_to_trace_list(v10fname, v11oldf);
  value0 = ecl_list1(v10fname);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L391trace_one_va(cl_narg narg, cl_object v12spec, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[9]);
 {
  return L391trace_one(v12spec);
 }
}
/* function definition for TRACE-PRINT                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L392trace_print(volatile cl_narg narg, cl_object volatile v1direction, cl_object volatile v2fname, cl_object volatile v3vals, ...)
{
 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<3)) FEwrong_num_arguments(VV[37]);
 {
  cl_object volatile v4extras;
  ecl_va_list args; ecl_va_start(args,v3vals,narg,3);
  v4extras = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   volatile cl_object v5;
   T0 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,VV[0]));
   T1 = ecl_times(T0,ecl_make_int8_t(2));
   v5 = ((ecl_float_nan_p(ecl_cmp_symbol_value(cl_env_copy,VV[1])) || ecl_lowereq(T1,ecl_cmp_symbol_value(cl_env_copy,VV[1])))?T1:ecl_cmp_symbol_value(cl_env_copy,VV[1]));
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-CIRCLE*",49),ECL_T); /*  *PRINT-CIRCLE* */
   T1 = cl_make_string_output_stream(0);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71),T1); /*  *TRACE-OUTPUT* */
   {
    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_fresh_line(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
     if (!((v1direction)==(VV[46]))){
      goto L6;
     }
     {
      cl_object v6;                               /*  BARS                    */
      cl_object v7;                               /*  REM                     */
      value0 = ecl_floor2(v5,ecl_make_int8_t(4));
      {
       v6 = value0;
       v7 = cl_env_copy->values[1];
      }
      {
       cl_object v8i;
       v8i = ecl_make_int8_t(0);
       goto L13;
L12:;
       if (!(ecl_lower(v8i,ecl_make_int8_t(10)))){
        goto L17;
       }
       T1 = VV[47];
       goto L16;
L17:;
       T1 = VV[48];
L16:;
       ecl_princ(T1,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
       v8i = ecl_one_plus(v8i);
L13:;
       if (!(ecl_lower(v8i,v6))){
        goto L21;
       }
       goto L12;
L21:;
      }
      if (!(ecl_plusp(v7))){
       goto L8;
      }
      cl_format(4, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[49], v7, VV[50]);
     }
L8:;
     cl_format(5, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[51], ecl_cmp_symbol_value(cl_env_copy,VV[0]), v2fname, v3vals);
     goto L5;
L6:;
     if (!((v1direction)==(ECL_SYM("EXIT",1839)))){
      goto L5;
     }
     {
      cl_object v6;                               /*  BARS                    */
      cl_object v7;                               /*  REM                     */
      value0 = ecl_floor2(v5,ecl_make_int8_t(4));
      {
       v6 = value0;
       v7 = cl_env_copy->values[1];
      }
      {
       cl_object v8i;
       v8i = ecl_make_int8_t(0);
       goto L30;
L29:;
       ecl_princ(VV[47],ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
       v8i = ecl_one_plus(v8i);
L30:;
       if (!(ecl_lower(v8i,v6))){
        goto L35;
       }
       goto L29;
L35:;
      }
      if (!(ecl_plusp(v7))){
       goto L25;
      }
      cl_format(4, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[49], v7, VV[50]);
     }
L25:;
     cl_format(5, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[52], ecl_cmp_symbol_value(cl_env_copy,VV[0]), v2fname, v3vals);
L5:;
     if (Null(v4extras)){
      goto L38;
     }
     {
      cl_object volatile v6;                      /*  BARS                    */
      cl_object volatile v7;                      /*  REM                     */
      value0 = ecl_floor2(v5,ecl_make_int8_t(4));
      {
       v6 = value0;
       v7 = cl_env_copy->values[1];
      }
      {
       cl_object v8i;
       v8i = ecl_make_int8_t(0);
       goto L45;
L44:;
       ecl_princ(VV[47],ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
       v8i = ecl_one_plus(v8i);
L45:;
       if (!(ecl_lower(v8i,v6))){
        goto L50;
       }
       goto L44;
L50:;
      }
      if (!(ecl_plusp(v7))){
       goto L40;
      }
      cl_format(4, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[49], v7, VV[50]);
     }
L40:;
     cl_format(3, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)), VV[53], v4extras);
L38:;
     cl_env_copy->values[0] = cl_get_output_stream_string(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
     }
    }
    ecl_frs_pop(cl_env_copy);
    ecl_stack_frame_push_values(_ecl_inner_frame);
    cl_close(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    if (unwinding) ecl_unwind(cl_env_copy,next_fr);
    T0 = cl_env_copy->values[0];
    ecl_stack_frame_close(_ecl_inner_frame);
    ecl_bds_unwind1(cl_env_copy);
   }
   value0 = ecl_princ(T0,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-OUTPUT*",71)));
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
/* function definition for TRACE-RECORD                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L393trace_record(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;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946));
  v3 = (ECL_SYM("FIRST",373)->symbol.gfdef);
  v4 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
  {
   cl_object v5;
   v5 = si_make_seq_iterator(2, v2, ecl_make_int8_t(0));
L6:;
   if (v5!=ECL_NIL) {
    goto L8;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L8:;
   {
    cl_object v6;
    v6 = si_seq_iterator_ref(v2, v5);
    T0 = ecl_car(v6);
    if (!(ecl_equal(v1fname,T0))){
     goto L10;
    }
    value0 = v6;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L10:;
   v5 = si_seq_iterator_next(v2, v5);
   goto L6;
  }
 }
}
/* function definition for TRACE-RECORD-NAME                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L394trace_record_name(cl_object v1record)
{
 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_car(v1record);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for TRACE-RECORD-DEFINITION                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L395trace_record_definition(cl_object v1record)
{
 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_cadr(v1record);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for TRACE-RECORD-OLD-DEFINITION                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L396trace_record_old_definition(cl_object v1record)
{
 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_caddr(v1record);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for TRACED-OLD-DEFINITION                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_traced_old_definition(cl_object v1fname)
{
 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;
  v2record = L393trace_record(v1fname);
  if (Null(v2record)){
   goto L3;
  }
  if (L399traced_and_redefined_p(v2record)!=ECL_NIL) {
   goto L5;
  }
  value0 = L396trace_record_old_definition(v2record);
  return value0;
L5:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for DELETE-FROM-TRACE-LIST                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L397delete_from_trace_list(cl_object v1fname)
{
 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 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946));
 T1 = (ECL_SYM("FIRST",373)->symbol.gfdef);
 T2 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
 T3 = cl_delete(6, v1fname, T0, ECL_SYM("KEY",1297), T1, ECL_SYM("TEST",1353), T2);
 ecl_cmp_setq(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946),T3);
 value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L397delete_from_trace_list_va(cl_narg narg, cl_object v2fname, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[31]);
 {
  return L397delete_from_trace_list(v2fname);
 }
}
/* function definition for ADD-TO-TRACE-LIST                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L398add_to_trace_list(cl_object v1fname, cl_object v2old_definition)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_fdefinition(v1fname);
 T1 = cl_list(3, v1fname, T0, v2old_definition);
 T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946)));
 ecl_cmp_setq(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946),T2);
 value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TRACE-LIST*",1946));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L398add_to_trace_list_va(cl_narg narg, cl_object v3fname, cl_object v4old_definition, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[44]);
 {
  return L398add_to_trace_list(v3fname, v4old_definition);
 }
}
/* function definition for TRACED-AND-REDEFINED-P                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L399traced_and_redefined_p(cl_object v1record)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(v1record)){
  goto L3;
 }
 T0 = L395trace_record_definition(v1record);
 T1 = L394trace_record_name(v1record);
 T2 = cl_fdefinition(T1);
 {
  bool v2;
  v2 = (T0)==(T2);
  value0 = (v2)?ECL_NIL:ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for UNTRACE-ONE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L400untrace_one(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 v2record;
  v2record = L393trace_record(v1fname);
  if (!(v2record==ECL_NIL)){
   goto L4;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[64], v1fname) /*  WARN */;
  goto L3;
L4:;
  if (Null(L399traced_and_redefined_p(v2record))){
   goto L6;
  }
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(2, VV[65], v1fname) /*  WARN */;
  goto L3;
L6:;
  T0 = L396trace_record_old_definition(v2record);
  si_fset(2, v1fname, T0);
L3:;
  L397delete_from_trace_list(v1fname);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
static cl_object L400untrace_one_va(cl_narg narg, cl_object v3fname, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[13]);
 {
  return L400untrace_one(v3fname);
 }
}
/* function definition for STEPPER-ENTER                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L401stepper_enter(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036));
  if (Null(cl_typep(2, v2, VV[73]))){
   goto L3;
  }
  T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035)),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035),T0);
  value0 = L409stepper(v1form);
  return value0;
L3:;
  {
   cl_object v3;
   v3 = ecl_make_int8_t(0);
   if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))){
    goto L7;
   }
   v3 = v2;
   if (!(ecl_greatereq(v3,ecl_make_int8_t(0)))){
    goto L7;
   }
  }
  T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036)),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036));
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  value0 = si_etypecase_error(v2, VV[75]);
  return value0;
 }
}
static cl_object L401stepper_enter_va(cl_narg narg, cl_object v3form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[72]);
 {
  return L401stepper_enter(v3form);
 }
}
/* function definition for STEPPER-LEAVE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L402stepper_leave(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036));
  if (Null(cl_typep(2, v2, VV[73]))){
   goto L3;
  }
  T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035)),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035),T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035));
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v3;
   v3 = ecl_make_int8_t(0);
   if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))){
    goto L6;
   }
   v3 = v2;
   if (!(ecl_greatereq(v3,ecl_make_int8_t(1)))){
    goto L6;
   }
  }
  T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036)),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036));
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  {
   cl_fixnum v3;
   v3 = (cl_fixnum)(0);
   if (!(ECL_FIXNUMP(v2))){
    goto L13;
   }
   v3 = ecl_fixnum(v2);
   if (!((v3)<=((cl_fixnum)(0)))){
    goto L13;
   }
   if (!((v3)>=((cl_fixnum)(0)))){
    goto L13;
   }
  }
  T0 = ECL_T;
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),T0);
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L402stepper_leave_va(cl_narg narg, cl_object v3form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[77]);
 {
  return L402stepper_leave(v3form);
 }
}
/* function definition for STEPPER-CALL                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L403stepper_call(cl_object v1form)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!((ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036)))==(ECL_T))){
  goto L2;
 }
 value0 = L409stepper(v1form);
 return value0;
L2:;
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L403stepper_call_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[79]);
 {
  return L403stepper_call(v2form);
 }
}
/* function definition for STEPPER-HOOK                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L404stepper_hook(cl_object v1form, cl_object v2delta)
{
 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_number_equalp(v2delta,ecl_make_int8_t(1)))){
  goto L2;
 }
 value0 = L401stepper_enter(v1form);
 return value0;
L2:;
 if (!(ecl_number_equalp(v2delta,ecl_make_int8_t(-1)))){
  goto L4;
 }
 value0 = L402stepper_leave(v1form);
 return value0;
L4:;
 {
  cl_object v3;
  v3 = L403stepper_call(v1form);
  if (Null(v3)){
   goto L7;
  }
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L404stepper_hook_va(cl_narg narg, cl_object v4form, cl_object v5delta, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[81]);
 {
  return L404stepper_hook(v4form, v5delta);
 }
}
/* local function STEP                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC405step(cl_object v1, cl_object v2)
{
 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 v4form;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4form = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v4form);
  value0 = cl_list(2, VV[84], T0);
  return value0;
 }
}
static cl_object LC405step_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[85]);
 {
  return LC405step(v5, v6);
 }
}
/* function definition for STEP*                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L406step_(cl_object volatile v1form)
{
 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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),ECL_T); /*  *STEP-ACTION* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*STEP-LEVEL*",1035),ecl_make_int8_t(0)); /*  *STEP-LEVEL* */
 T0 = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_uint8_t(128), ECL_SYM("TEST",1353), ECL_SYM("EQ",335));
 ecl_bds_bind(cl_env_copy,VV[69],T0);             /*  *STEP-FUNCTIONS*        */
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[68]); /*  BEGIN CATCH CATCH146  */
 {
  ecl_frs_push(cl_env_copy,value0);
  if (__ecl_frs_push_result!=0) {
   value0 = cl_env_copy->values[0];
  } else {
   value0 = si_eval_with_env(3, v1form, ECL_NIL, ECL_T);
  }
 }
 ecl_frs_pop(cl_env_copy);                        /*  END CATCH CATCH146      */
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L406step__va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[84]);
 {
  return L406step_(v2form);
 }
}
/* function definition for STEPPABLE-FUNCTION                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L407steppable_function(cl_object v1form)
{
 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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),ECL_NIL); /*  *STEP-ACTION* */
 value0 = ecl_gethash_safe(v1form,ecl_cmp_symbol_value(cl_env_copy,VV[69]),ECL_NIL);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 {
  cl_object v2;                                   /*  F                       */
  cl_object v3;                                   /*  ENV                     */
  cl_object v4;                                   /*  NAME                    */
  value0 = cl_function_lambda_expression(v1form);
  {
   v2 = value0;
   v3 = cl_env_copy->values[1];
   v4 = cl_env_copy->values[2];
  }
  if (L393trace_record(v4)!=ECL_NIL) {
   goto L6;
  }
  if (Null(v2)){
   goto L6;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,VV[69]);
  T1 = cl_list(2, ECL_SYM("FUNCTION",398), v2);
  T2 = si_eval_with_env(3, T1, v3, ECL_T);
  value0 = si_hash_set(v1form, T0, T2);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L6:;
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
L3:;
 cl_env_copy->nvalues = 1;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L407steppable_function_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[87]);
 {
  return L407steppable_function(v2form);
 }
}
/* function definition for STEPPER                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L409stepper(cl_object volatile v1form)
{
 cl_object T0, T1, T2;
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1form,env0);                 /*  FORM                    */
 if (ECL_SYMBOLP(ECL_CONS_CAR(CLV0))) {
  goto L3;
 }
 if (Null(cl_functionp(ECL_CONS_CAR(CLV0)))){
  goto L1;
 }
 goto L2;
L3:;
L2:;
 T0 = si_coerce_to_function(ECL_CONS_CAR(CLV0));
 value0 = L407steppable_function(T0);
 return value0;
L1:;
 {
  volatile cl_object v2prompt;
  volatile cl_object env1 = env0;
  ecl_bds_bind(cl_env_copy,VV[67],ECL_CONS_CAR(CLV0)); /*  *STEP-FORM*        */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),ECL_NIL); /*  *STEP-ACTION* */
  T0 = ecl_times(ecl_cmp_symbol_value(cl_env_copy,VV[89]),ecl_make_int8_t(2));
  T1 = ((ecl_float_nan_p(ecl_make_int8_t(20)) || ecl_lowereq(T0,ecl_make_int8_t(20)))?T0:ecl_make_int8_t(20));
  CLV1 = env1 = CONS(T1,env1);                    /*  INDENT                  */
  v2prompt = ECL_NIL;
  {
   cl_object volatile v3;
   v3 = ecl_make_cclosure_va((cl_objectfn)LC408__lambda139,env1,Cblock,0);
   v2prompt = v3;
  }
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[68]); /*  BEGIN CATCH CATCH147 */
  {
   ecl_frs_push(cl_env_copy,value0);
   if (__ecl_frs_push_result!=0) {
    value0 = cl_env_copy->values[0];
   } else {
    T0 = ecl_cmp_symbol_value(cl_env_copy,VV[70]);
    T1 = cl_adjoin(2, ecl_cmp_symbol_value(cl_env_copy,VV[96]), ecl_cmp_symbol_value(cl_env_copy,VV[97]));
    T2 = cl_adjoin(2, T0, T1);
    value0 = (cl_env_copy->function=(VV[92]->symbol.gfdef))->cfun.entry(8, VV[93], ECL_T, VV[94], T2, VV[98], VV[74], VV[99], v2prompt) /*  TPL */;
   }
  }
  ecl_frs_pop(cl_env_copy);                       /*  END CATCH CATCH147      */
  if (Null(value0)){
   goto L8;
  }
  cl_env_copy->values[0] = ECL_T;
  cl_env_copy->nvalues = 1;
  cl_throw(ecl_cmp_symbol_value(cl_env_copy,VV[68]));
L8:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
static cl_object L409stepper_va(cl_narg narg, cl_object v3form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[74]);
 {
  return L409stepper(v3form);
 }
}
/* function definition for STEP-NEXT                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L410step_next()
{
 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_env_copy->values[0] = ECL_NIL;
 cl_env_copy->nvalues = 1;
 cl_throw(ecl_cmp_symbol_value(cl_env_copy,VV[68]));
}
static cl_object L410step_next_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[101]);
 {
  return L410step_next();
 }
}
/* function definition for STEP-SKIP                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L411step_skip(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[103]);
 {
  cl_object v1when;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1when = ecl_make_int8_t(0);
   } else {
    i++;
    v1when = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),T0);
  cl_env_copy->values[0] = ECL_NIL;
  cl_env_copy->nvalues = 1;
  cl_throw(ecl_cmp_symbol_value(cl_env_copy,VV[68]));
 }
}
/* function definition for STEP-PRINT                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L412step_print()
{
 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_write(9, ecl_cmp_symbol_value(cl_env_copy,VV[67]), ECL_SYM("STREAM",1350), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32)), ECL_SYM("PRETTY",1326), ECL_T, ECL_SYM("LEVEL",1299), ECL_NIL, ECL_SYM("LENGTH",1298), ECL_NIL);
 cl_terpri(0);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 0;
 return value0;
}
static cl_object L412step_print_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[105]);
 {
  return L412step_print();
 }
}
/* function definition for STEP-QUIT                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L413step_quit()
{
 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_env_copy->values[0] = ECL_T;
 cl_env_copy->nvalues = 1;
 cl_throw(ecl_cmp_symbol_value(cl_env_copy,VV[68]));
}
static cl_object L413step_quit_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[107]);
 {
  return L413step_quit();
 }
}
/* closure LAMBDA139                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC408__lambda139(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;                                     /*  INDENT                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[90]);
 {
L1:;
  cl_format(3, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32)), VV[91], ECL_CONS_CAR(CLV1));
  cl_write(9, ECL_CONS_CAR(CLV0), ECL_SYM("STREAM",1350), ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32)), ECL_SYM("PRETTY",1326), ECL_NIL, ECL_SYM("LEVEL",1299), ecl_make_int8_t(2), ECL_SYM("LENGTH",1298), ecl_make_int8_t(2));
  ecl_princ_char((ecl_character)(32),ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32)));
  value0 = ECL_CODE_CHAR(ecl_princ_char((ecl_character)(45),ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*DEBUG-IO*",32))));
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
#include "lsp/trace.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl0i7oRRI7KYIr9_K8mzL881(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;TRACE.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl0i7oRRI7KYIr9_K8mzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  si_Xmake_special(VV[0]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[0],T0);
  si_Xmake_special(VV[1]);
  T0 = ecl_make_int8_t(20);
  ecl_cmp_setq(cl_env_copy,VV[1],T0);
  ecl_cmp_defmacro(VV[109]);                      /*  TRACE                   */
  ecl_cmp_defun(VV[110]);                         /*  TRACE*                  */
  ecl_cmp_defmacro(VV[111]);                      /*  UNTRACE                 */
  ecl_cmp_defun(VV[112]);                         /*  UNTRACE*                */
  si_Xmake_special(VV[15]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[15],T0);
  ecl_cmp_defun(VV[113]);                         /*  TRACE-ONE               */
  ecl_cmp_defun(VV[114]);                         /*  TRACE-PRINT             */
  (void)0; /* No entry created for TRACE-RECORD */
  (void)0; /* No entry created for TRACE-RECORD-NAME */
  (void)0; /* No entry created for TRACE-RECORD-DEFINITION */
  (void)0; /* No entry created for TRACE-RECORD-OLD-DEFINITION */
  (void)0; /* No entry created for TRACED-OLD-DEFINITION */
  ecl_cmp_defun(VV[115]);                         /*  DELETE-FROM-TRACE-LIST  */
  ecl_cmp_defun(VV[116]);                         /*  ADD-TO-TRACE-LIST       */
  (void)0; /* No entry created for TRACED-AND-REDEFINED-P */
  ecl_cmp_defun(VV[117]);                         /*  UNTRACE-ONE             */
  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(ECL_SYM("*STEP-ACTION*",1036));
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STEP-ACTION*",1036),T0);
  si_Xmake_special(VV[67]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[67],T0);
  si_Xmake_special(VV[68]);
  T0 = CONS(ECL_NIL,ECL_NIL);
  ecl_cmp_setq(cl_env_copy,VV[68],T0);
  si_Xmake_special(VV[69]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[69],T0);
  si_Xmake_constant(VV[70], VV[71]);
  ecl_cmp_defun(VV[118]);                         /*  STEPPER-ENTER           */
  ecl_cmp_defun(VV[119]);                         /*  STEPPER-LEAVE           */
  ecl_cmp_defun(VV[120]);                         /*  STEPPER-CALL            */
  ecl_cmp_defun(VV[121]);                         /*  STEPPER-HOOK            */
  ecl_cmp_defmacro(VV[122]);                      /*  STEP                    */
  ecl_cmp_defun(VV[123]);                         /*  STEP*                   */
  ecl_cmp_defun(VV[124]);                         /*  STEPPABLE-FUNCTION      */
  ecl_cmp_defun(VV[125]);                         /*  STEPPER                 */
  ecl_cmp_defun(VV[126]);                         /*  STEP-NEXT               */
  ecl_cmp_defun(VV[127]);                         /*  STEP-SKIP               */
  ecl_cmp_defun(VV[128]);                         /*  STEP-PRINT              */
  ecl_cmp_defun(VV[129]);                         /*  STEP-QUIT               */
 }
}
