/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/conditions.lsp                 */
#include <ecl/ecl-cmp.h>
#include "clos/conditions.eclh"
/* local function UNIQUE-ID                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2312unique_id(cl_object v1, cl_object v2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4obj;
  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);
   v4obj = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = cl_list(2, ECL_SYM("POINTER",1143), v4obj);
  return value0;
 }
}
static cl_object LC2312unique_id_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[1]);
 {
  return LC2312unique_id(v5, v6);
 }
}
/* function definition for COMPUTE-RESTARTS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_compute_restarts(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(ECL_SYM("COMPUTE-RESTARTS",245));
 {
  cl_object v1condition;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1condition = ECL_NIL;
   } else {
    i++;
    v1condition = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2assoc_restart;
   cl_object v3other;
   cl_object v4output;
   v2assoc_restart = ECL_NIL;
   v3other = ECL_NIL;
   v4output = ECL_NIL;
   if (Null(v1condition)){
    goto L5;
   }
   {
    cl_object v5;
    v5 = ecl_cmp_symbol_value(cl_env_copy,VV[4]);
    goto L10;
L9:;
    {
     cl_object v6i;
     v6i = ecl_car(v5);
     T0 = ecl_car(v6i);
     if (!((T0)==(v1condition))){
      goto L15;
     }
     T0 = ecl_cdr(v6i);
     v2assoc_restart = ecl_append(T0,v2assoc_restart);
     goto L14;
L15:;
     T0 = ecl_cdr(v6i);
     v3other = ecl_append(T0,v3other);
L14:;
    }
    v5 = ecl_cdr(v5);
L10:;
    if (Null(v5)){
     goto L21;
    }
    goto L9;
L21:;
   }
L5:;
   {
    cl_object v5;
    v5 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5));
    goto L27;
L26:;
    {
     cl_object v6restart_cluster;
     v6restart_cluster = ecl_car(v5);
     {
      cl_object v7;
      v7 = v6restart_cluster;
      goto L35;
L34:;
      {
       cl_object v8restart;
       v8restart = ecl_car(v7);
       if (Null(v1condition)){
        goto L42;
       }
       {
        cl_object v9;
        cl_object v10;
        v9 = v8restart;
        v10 = v2assoc_restart;
        if (ecl_memql(v9,v10)!=ECL_NIL) {
         goto L42;
        }
       }
       {
        cl_object v9;
        cl_object v10;
        v9 = v8restart;
        v10 = v3other;
        if (ecl_memql(v9,v10)!=ECL_NIL) {
         goto L39;
        }
        goto L41;
       }
L42:;
L41:;
       T0 = (cl_env_copy->function=(VV[5]->symbol.gfdef))->cfun.entry(1, v8restart) /*  RESTART-TEST-FUNCTION */;
       if (Null(ecl_function_dispatch(cl_env_copy,T0)(1, v1condition))){
        goto L39;
       }
       v4output = CONS(v8restart,v4output);
L39:;
      }
      v7 = ecl_cdr(v7);
L35:;
      if (Null(v7)){
       goto L52;
      }
      goto L34;
L52:;
     }
    }
    v5 = ecl_cdr(v5);
L27:;
    if (Null(v5)){
     goto L56;
    }
    goto L26;
L56:;
   }
   value0 = cl_nreverse(v4output);
   return value0;
  }
 }
}
/* function definition for RESTART-PRINT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2313restart_print(cl_object v1restart, cl_object v2stream, cl_object v3depth)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-ESCAPE*",50)))){
  goto L3;
 }
 T0 = cl_type_of(v1restart);
 T1 = si_pointer(v1restart);
 cl_format(4, v2stream, VV[7], T0, T1);
 goto L2;
L3:;
 L2320restart_report(v1restart, v2stream);
L2:;
 value0 = v1restart;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L2313restart_print_va(cl_narg narg, cl_object v4restart, cl_object v5stream, cl_object v6depth, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[6]);
 {
  return L2313restart_print(v4restart, v5stream, v6depth);
 }
}
/* function definition for MAKE-RESTART                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2314make_restart(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 v1;
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[10];
   cl_parse_key(args,5,L2314make_restartkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1 = keyvars[0];
   v2 = keyvars[1];
   v3 = keyvars[2];
   v4 = keyvars[3];
   if (Null(keyvars[9])) {
    v5 = cl_constantly(ECL_T);
   } else {
    v5 = keyvars[4];
   }
  }
  value0 = si_make_structure(6, VV[14], v1, v2, v3, v4, v5);
  return value0;
 }
}
/* local function LAMBDA42                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2315__lambda42(cl_object v1, cl_object v2x)
{
 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 v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2x, T0, ecl_make_int8_t(4), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2x, T2, ecl_make_int8_t(4));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2315__lambda42_va(cl_narg narg, cl_object v5, cl_object v6x, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[17]);
 {
  return LC2315__lambda42(v5, v6x);
 }
}
/* local function LAMBDA47                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2316__lambda47(cl_object v1, cl_object v2x)
{
 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 v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2x, T0, ecl_make_int8_t(3), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2x, T2, ecl_make_int8_t(3));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2316__lambda47_va(cl_narg narg, cl_object v5, cl_object v6x, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[19]);
 {
  return LC2316__lambda47(v5, v6x);
 }
}
/* local function LAMBDA52                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2317__lambda52(cl_object v1, cl_object v2x)
{
 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 v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2x, T0, ecl_make_int8_t(2), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2x, T2, ecl_make_int8_t(2));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2317__lambda52_va(cl_narg narg, cl_object v5, cl_object v6x, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[21]);
 {
  return LC2317__lambda52(v5, v6x);
 }
}
/* local function LAMBDA57                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2318__lambda57(cl_object v1, cl_object v2x)
{
 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 v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2x, T0, ecl_make_int8_t(1), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2x, T2, ecl_make_int8_t(1));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2318__lambda57_va(cl_narg narg, cl_object v5, cl_object v6x, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[23]);
 {
  return LC2318__lambda57(v5, v6x);
 }
}
/* local function LAMBDA62                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2319__lambda62(cl_object v1, cl_object v2x)
{
 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 v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2x, T0, ecl_make_int8_t(0), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_SYM("RESTART",723));
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2x, T2, ecl_make_int8_t(0));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC2319__lambda62_va(cl_narg narg, cl_object v5, cl_object v6x, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[24]);
 {
  return LC2319__lambda62(v5, v6x);
 }
}
/* function definition for RESTART-REPORT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2320restart_report(cl_object v1restart, cl_object v2stream)
{
 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 v3fn;
  v3fn = (cl_env_copy->function=(VV[20]->symbol.gfdef))->cfun.entry(1, v1restart) /*  RESTART-REPORT-FUNCTION */;
  if (Null(v3fn)){
   goto L3;
  }
  value0 = ecl_function_dispatch(cl_env_copy,v3fn)(1, v2stream);
  return value0;
L3:;
  value0 = (cl_env_copy->function=(ECL_SYM("RESTART-NAME",726)->symbol.gfdef))->cfun.entry(1, v1restart) /*  RESTART-NAME */;
  if (value0!=ECL_NIL) {
   goto L7;
  }
  T0 = v1restart;
  goto L5;
L7:;
  T0 = value0;
  goto L5;
L5:;
  value0 = cl_format(3, v2stream, VV[25], T0);
  return value0;
 }
}
/* function definition for BIND-SIMPLE-RESTARTS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_bind_simple_restarts(cl_object v1tag, cl_object v2names)
{
 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 v3i;
  v3i = ecl_make_int8_t(1);
  {
   cl_object v4;
   cl_object v5n;
   cl_object v6;
   {
    cl_object v7;
    if (!(ECL_ATOM(v2names))){
     goto L6;
    }
    v7 = ecl_list1(v2names);
    goto L5;
L6:;
    v7 = v2names;
L5:;
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   v5n = ECL_NIL;
   v6 = v4;
   {
    cl_object v7f;
    v7f = ECL_NIL;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L14:;
     if (!(ecl_endp(v6))){
      goto L16;
     }
     goto L15;
L16:;
     v5n = ECL_CONS_CAR(v6);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v6);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v10;
     }
     v7f = LC2322simple_restart_function(v1tag, v3i);
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v10;
     }
     T2 = L2314make_restart(4, ECL_SYM("NAME",1309), v5n, ECL_SYM("FUNCTION",1273), v7f);
     v9 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v9,T1);
     v3i = ecl_one_plus(v3i);
     goto L14;
L15:;
     T0 = ecl_cdr(v8);
     goto L2;
    }
   }
  }
 }
L2:;
 value0 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for BIND-SIMPLE-HANDLERS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_bind_simple_handlers(cl_object v1tag, cl_object v2names)
{
 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 v3i;
  v3i = ecl_make_int8_t(1);
  {
   cl_object v4;
   cl_object v5n;
   cl_object v6;
   {
    cl_object v7;
    if (!(ECL_ATOM(v2names))){
     goto L6;
    }
    v7 = ecl_list1(v2names);
    goto L5;
L6:;
    v7 = v2names;
L5:;
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   v5n = ECL_NIL;
   v6 = v4;
   {
    cl_object v7f;
    v7f = ECL_NIL;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L14:;
     if (!(ecl_endp(v6))){
      goto L16;
     }
     goto L15;
L16:;
     v5n = ECL_CONS_CAR(v6);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v6);
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v6 = v10;
     }
     v7f = LC2324simple_handler_function(v1tag, v3i);
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v10;
     }
     T2 = CONS(v5n,v7f);
     v9 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v9,T1);
     v3i = ecl_one_plus(v3i);
     goto L14;
L15:;
     T0 = ecl_cdr(v8);
     goto L2;
    }
   }
  }
 }
L2:;
 value0 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function RESTART-BIND                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2326restart_bind(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4bindings;
  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);
   v4bindings = v5;
  }
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_cfun_va((cl_objectfn)LC2325__lambda98_va,ECL_NIL,Cblock,1);
    v5 = v6;
   }
   {
    cl_object v6;
    cl_object v7;
    cl_object v8;
    {
     cl_object v9;
     v9 = v4bindings;
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v9;
    }
    v7 = ECL_NIL;
    v8 = v6;
    {
     cl_object v9;
     cl_object v10;
     v9 = ecl_list1(ECL_NIL);
     v10 = v9;
L18:;
     if (!(ecl_endp(v8))){
      goto L20;
     }
     goto L19;
L20:;
     v7 = 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;
     }
     {
      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;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
     v10 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v10,T1);
     goto L18;
L19:;
     T0 = ecl_cdr(v9);
     goto L9;
    }
   }
  }
L9:;
  T1 = CONS(ECL_SYM("LIST",483),T0);
  T2 = cl_list(3, ECL_SYM("CONS",253), T1, ECL_SYM("*RESTART-CLUSTERS*",5));
  T3 = cl_list(2, ECL_SYM("*RESTART-CLUSTERS*",5), T2);
  T4 = ecl_list1(T3);
  value0 = cl_listX(3, ECL_SYM("LET",479), T4, v3);
  return value0;
 }
}
static cl_object LC2326restart_bind_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[37]);
 {
  return LC2326restart_bind(v5, v6);
 }
}
/* function definition for FIND-RESTART                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_find_restart(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("FIND-RESTART",370));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("FIND-RESTART",370));
 {
  cl_object v2condition;
  va_list args; va_start(args,v1name);
  {
   int i = 1;
   if (i >= narg) {
    v2condition = ECL_NIL;
   } else {
    i++;
    v2condition = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3;
   v3 = cl_compute_restarts(1, v2condition);
   goto L5;
L4:;
   {
    cl_object v4restart;
    v4restart = ecl_car(v3);
    if ((v4restart)==(v1name)) {
     goto L11;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("RESTART-NAME",726)->symbol.gfdef))->cfun.entry(1, v4restart) /*  RESTART-NAME */;
    if (!((T0)==(v1name))){
     goto L9;
    }
    goto L10;
L11:;
L10:;
    value0 = v4restart;
    cl_env_copy->nvalues = 1;
    return value0;
L9:;
   }
   v3 = ecl_cdr(v3);
L5:;
   if (Null(v3)){
    goto L15;
   }
   goto L4;
L15:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for FIND-RESTART-NEVER-FAIL                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2327find_restart_never_fail(cl_narg narg, cl_object v1restart, ...)
{
 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[38]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[38]);
 {
  cl_object v2condition;
  va_list args; va_start(args,v1restart);
  {
   int i = 1;
   if (i >= narg) {
    v2condition = ECL_NIL;
   } else {
    i++;
    v2condition = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = cl_find_restart(2, v1restart, v2condition);
  if (value0!=ECL_NIL) {
   goto L3;
  }
  T0 = ecl_list1(v1restart);
  value0 = si_signal_simple_error(4, ECL_SYM("CONTROL-ERROR",257), ECL_NIL, VV[39], T0);
  return value0;
L3:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for INVOKE-RESTART                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_invoke_restart(cl_narg narg, cl_object v1restart, ...)
{
 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(ECL_SYM("INVOKE-RESTART",448));
 {
  cl_object v2values;
  ecl_va_list args; ecl_va_start(args,v1restart,narg,1);
  v2values = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3real_restart;
   v3real_restart = L2327find_restart_never_fail(1, v1restart);
   T0 = (cl_env_copy->function=(VV[22]->symbol.gfdef))->cfun.entry(1, v3real_restart) /*  RESTART-FUNCTION */;
   value0 = cl_apply(2, T0, v2values);
   return value0;
  }
 }
}
/* function definition for INVOKE-RESTART-INTERACTIVELY                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_invoke_restart_interactively(cl_object v1restart)
{
 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 v2real_restart;
  v2real_restart = L2327find_restart_never_fail(1, v1restart);
  T0 = (cl_env_copy->function=(VV[22]->symbol.gfdef))->cfun.entry(1, v2real_restart) /*  RESTART-FUNCTION */;
  {
   cl_object v3interactive_function;
   v3interactive_function = (cl_env_copy->function=(VV[18]->symbol.gfdef))->cfun.entry(1, v2real_restart) /*  RESTART-INTERACTIVE-FUNCTION */;
   if (Null(v3interactive_function)){
    goto L5;
   }
   T1 = ecl_function_dispatch(cl_env_copy,v3interactive_function)(0);
   goto L3;
L5:;
   T1 = ECL_NIL;
  }
L3:;
  value0 = cl_apply(2, T0, T1);
  return value0;
 }
}
/* local function RESTART-CASE                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2331restart_case(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 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 v4expression;
  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);
   v4expression = v5;
  }
  {
   cl_object v5;
   v5 = ecl_make_cfun_va((cl_objectfn)LC2328process_clause_va,ECL_NIL,Cblock,1);
   {
    cl_object v6data;
    cl_object env1 = env0;
    T0 = cl_gensym(0);
    env1 = ECL_NIL;
    CLV0 = env1 = CONS(T0,env1);                  /*  BLOCK-TAG               */
    T0 = cl_gensym(0);
    CLV1 = env1 = CONS(T0,env1);                  /*  TEMP-VAR                */
    {
     cl_object v7;
     cl_object v8;
     cl_object v9;
     {
      cl_object v10;
      v10 = v3;
      if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     v8 = ECL_NIL;
     v9 = v7;
     {
      cl_object v10;
      cl_object v11;
      v10 = ecl_list1(ECL_NIL);
      v11 = v10;
L17:;
      if (!(ecl_endp(v9))){
       goto L19;
      }
      goto L18;
L19:;
      v8 = ECL_CONS_CAR(v9);
      {
       cl_object v12;
       v12 = ECL_CONS_CDR(v9);
       if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v9 = v12;
      }
      {
       cl_object v12;
       v12 = v11;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v12;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v8);
      v11 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v11,T0);
      goto L17;
L18:;
      v6data = ecl_cdr(v10);
      goto L9;
     }
    }
L9:;
    {
     cl_object v7expression2;
     v7expression2 = cl_macroexpand(2, v4expression, v2env);
     if (!(ECL_CONSP(v7expression2))){
      goto L35;
     }
     {
      cl_object v8condition_form;
      cl_object v9condition_var;
      cl_object v10name;
      v8condition_form = ECL_NIL;
      v9condition_var = cl_gensym(0);
      v10name = ecl_car(v7expression2);
      if (!((v10name)==(ECL_SYM("SIGNAL",763)))){
       goto L42;
      }
      T0 = ecl_cadr(v7expression2);
      T1 = ecl_cddr(v7expression2);
      T2 = CONS(ECL_SYM("LIST",483),T1);
      v8condition_form = cl_listX(4, VV[50], T0, T2, VV[51]);
      goto L41;
L42:;
      if (!((v10name)==(ECL_SYM("ERROR",339)))){
       goto L45;
      }
      T0 = ecl_cadr(v7expression2);
      T1 = ecl_cddr(v7expression2);
      T2 = CONS(ECL_SYM("LIST",483),T1);
      v8condition_form = cl_listX(4, VV[50], T0, T2, VV[52]);
      goto L41;
L45:;
      if (!((v10name)==(ECL_SYM("CERROR",204)))){
       goto L48;
      }
      T0 = ecl_caddr(v7expression2);
      T1 = ecl_cdddr(v7expression2);
      T2 = CONS(ECL_SYM("LIST",483),T1);
      v8condition_form = cl_listX(4, VV[50], T0, T2, VV[53]);
      goto L41;
L48:;
      if (!((v10name)==(ECL_SYM("WARN",907)))){
       goto L41;
      }
      T0 = ecl_cadr(v7expression2);
      T1 = ecl_cddr(v7expression2);
      T2 = CONS(ECL_SYM("LIST",483),T1);
      v8condition_form = cl_listX(4, VV[50], T0, T2, VV[54]);
L41:;
      if (Null(v8condition_form)){
       goto L35;
      }
      T0 = cl_list(2, v9condition_var, v8condition_form);
      T1 = ecl_list1(T0);
      if (!((v10name)==(ECL_SYM("CERROR",204)))){
       goto L56;
      }
      T3 = ecl_cadr(v7expression2);
      T2 = cl_list(3, ECL_SYM("CERROR",204), T3, v9condition_var);
      goto L55;
L56:;
      T2 = cl_list(2, v10name, v9condition_var);
L55:;
      T3 = cl_list(4, ECL_SYM("WITH-CONDITION-RESTARTS",912), v9condition_var, VV[55], T2);
      v4expression = cl_list(3, ECL_SYM("LET",479), T1, T3);
     }
    }
L35:;
    T0 = cl_list(2, ECL_CONS_CAR(CLV1), ECL_NIL);
    T1 = ecl_list1(T0);
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cclosure_va((cl_objectfn)LC2329__lambda236,env1,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       v11 = v6data;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L67:;
       if (!(ecl_endp(v10))){
        goto L69;
       }
       goto L68;
L69:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = v12;
        if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T3 = v13;
       }
       T4 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
       v12 = ecl_list1(T4);
       (ECL_CONS_CDR(T3)=v12,T3);
       goto L67;
L68:;
       T2 = ecl_cdr(v11);
       goto L58;
      }
     }
    }
L58:;
    T3 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), v4expression);
    T4 = cl_list(3, ECL_SYM("RESTART-BIND",724), T2, T3);
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cclosure_va((cl_objectfn)LC2330__lambda245,env1,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       v11 = v6data;
       if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v11;
      }
      v9 = ECL_NIL;
      v10 = v8;
      {
       cl_object v11;
       cl_object v12;
       v11 = ecl_list1(ECL_NIL);
       v12 = v11;
L94:;
       if (!(ecl_endp(v10))){
        goto L96;
       }
       goto L95;
L96:;
       v9 = ECL_CONS_CAR(v10);
       {
        cl_object v13;
        v13 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v13;
       }
       {
        cl_object v13;
        v13 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
        {
         cl_object v14;
         v14 = v12;
         if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T6 = v14;
        }
        (ECL_CONS_CDR(T6)=v13,T6);
        if (Null(v13)){
         goto L104;
        }
       }
       T6 = ecl_cdr(v12);
       v12 = ecl_last(T6,1);
L104:;
       goto L94;
L95:;
       T5 = ecl_cdr(v11);
       goto L85;
      }
     }
    }
L85:;
    T6 = cl_listX(3, ECL_SYM("TAGBODY",853), T4, T5);
    T7 = cl_list(3, ECL_SYM("LET",479), T1, T6);
    value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_CONS_CAR(CLV0), T7);
    return value0;
   }
  }
 }
}
static cl_object LC2331restart_case_va(cl_narg narg, cl_object v7, cl_object v8env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[60]);
 {
  return LC2331restart_case(v7, v8env);
 }
}
/* local function WITH-SIMPLE-RESTART                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2332with_simple_restart(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4;
  cl_object v5;
  cl_object v6restart_name;
  cl_object v7format_control;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v8;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6restart_name = v8;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7format_control = v8;
  }
  T0 = CONS(ECL_SYM("PROGN",674),v3);
  T1 = cl_listX(4, ECL_SYM("FORMAT",389), ECL_SYM("STREAM",802), v7format_control, v5);
  T2 = cl_list(3, ECL_SYM("LAMBDA",454), VV[48], T1);
  T3 = cl_list(5, v6restart_name, ECL_NIL, ECL_SYM("REPORT",1339), T2, VV[61]);
  value0 = cl_list(3, ECL_SYM("RESTART-CASE",725), T0, T3);
  return value0;
 }
}
static cl_object LC2332with_simple_restart_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[62]);
 {
  return LC2332with_simple_restart(v8, v9);
 }
}
/* local function WITH-CONDITION-RESTARTS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2333with_condition_restarts(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4condition;
  cl_object v5restarts;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4condition = v6;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5restarts = v6;
  }
  T0 = cl_list(3, ECL_SYM("CONS",253), v4condition, v5restarts);
  T1 = cl_list(3, ECL_SYM("CONS",253), T0, VV[4]);
  T2 = cl_list(2, VV[4], T1);
  T3 = ecl_list1(T2);
  value0 = cl_listX(3, ECL_SYM("LET",479), T3, v3);
  return value0;
 }
}
static cl_object LC2333with_condition_restarts_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[63]);
 {
  return LC2333with_condition_restarts(v6, v7);
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2336print_object(cl_object v1c, cl_object v2stream)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_LISTP(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547))))){
  goto L3;
 }
 T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547));
 goto L2;
L3:;
 T1 = (ECL_SYM("LIST",483)->symbol.gfdef);
 T0 = cl_apply(2, T1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
L2:;
 lex0[0] = T0;                                    /*  .CLOSED-COMBINED-METHOD-ARGS. */
 lex0[1] = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*NEXT-METHODS*",1549)); /*  .NEXT-METHODS. */
 if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-ESCAPE*",50)))){
  goto L6;
 }
 value0 = LC2334call_next_method(0, lex0);
 return value0;
L6:;
 {
  cl_object v3reporter;
  v3reporter = cl_slot_value(v1c, ECL_SYM("REPORT-FUNCTION",2048));
  if (!(ECL_STRINGP(v3reporter))){
   goto L9;
  }
  value0 = cl_write_string(2, v3reporter, v2stream);
  return value0;
L9:;
  if (!(v3reporter==ECL_NIL)){
   goto L11;
  }
  value0 = LC2334call_next_method(0, lex0);
  return value0;
L11:;
  value0 = ecl_function_dispatch(cl_env_copy,v3reporter)(2, v1c, v2stream);
  return value0;
 }
}
static cl_object LC2336print_object_va(cl_narg narg, cl_object v4c, cl_object v5stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2336print_object(v4c, v5stream);
 }
}
/* local function DEFINE-CONDITION                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2337define_condition(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4name;
  cl_object v5parent_list;
  cl_object v6slot_specs;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4name = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L10;
  }
  si_dm_too_few_arguments(v1);
L10:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5parent_list = v7;
  }
  if (!(v3==ECL_NIL)){
   goto L16;
  }
  si_dm_too_few_arguments(v1);
L16:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6slot_specs = v7;
  }
  {
   cl_object v7class_options;
   v7class_options = ECL_NIL;
   {
    cl_object v8;
    v8 = v3;
    goto L26;
L25:;
    {
     cl_object v9option;
     v9option = ecl_car(v8);
     {
      cl_object v10;
      v10 = ecl_car(v9option);
      if (!((v10)==(ECL_SYM("DEFAULT-INITARGS",991)))){
       goto L37;
      }
      goto L34;
L37:;
      goto L35;
L35:;
      if (!((v10)==(ECL_SYM("DOCUMENTATION",1253)))){
       goto L32;
      }
      goto L33;
L34:;
L33:;
      v7class_options = CONS(v9option,v7class_options);
      goto L30;
L32:;
      if (!((v10)==(ECL_SYM("REPORT",1339)))){
       goto L41;
      }
      {
       cl_object v11report_function;
       v11report_function = ecl_cadr(v9option);
       if (!(ECL_SYMBOLP(v11report_function))){
        goto L46;
       }
       T0 = cl_list(2, ECL_SYM("QUOTE",682), v11report_function);
       goto L45;
L46:;
       T0 = v11report_function;
L45:;
       T1 = cl_list(3, ECL_SYM("REPORT-FUNCTION",2048), ECL_SYM("INITFORM",1000), T0);
       v6slot_specs = CONS(T1,v6slot_specs);
       goto L30;
      }
L41:;
      cl_cerror(3, VV[68], VV[69], v9option);
     }
L30:;
    }
    v8 = ecl_cdr(v8);
L26:;
    if (Null(v8)){
     goto L50;
    }
    goto L25;
L50:;
   }
   value0 = v5parent_list;
   if (value0!=ECL_NIL) {
    goto L54;
   }
   T0 = VV[70];
   goto L52;
L54:;
   T0 = value0;
   goto L52;
L52:;
   T1 = cl_listX(5, ECL_SYM("DEFCLASS",941), v4name, T0, v6slot_specs, v7class_options);
   T2 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   value0 = cl_list(3, ECL_SYM("PROGN",674), T1, T2);
   return value0;
  }
 }
}
static cl_object LC2337define_condition_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[71]);
 {
  return LC2337define_condition(v8, v9);
 }
}
/* function definition for FIND-SUBCLASSES-OF-TYPE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2338find_subclasses_of_type(cl_object v1type, cl_object v2class)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(cl_subtypep(2, v2class, v1type))){
  goto L2;
 }
 value0 = ecl_list1(v2class);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3;
  cl_object v4c;
  cl_object v5;
  {
   cl_object v6;
   v6 = (cl_env_copy->function=(ECL_SYM("CLASS-DIRECT-SUBCLASSES",1565)->symbol.gfdef))->cfun.entry(1, v2class) /*  CLASS-DIRECT-SUBCLASSES */;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4c = ECL_NIL;
  v5 = v3;
  {
   cl_object v6;
   cl_object v7;
   v6 = ecl_list1(ECL_NIL);
   v7 = v6;
L11:;
   if (!(ecl_endp(v5))){
    goto L13;
   }
   goto L12;
L13:;
   v4c = 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 = L2338find_subclasses_of_type(v1type, v4c);
    {
     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;
    }
    (ECL_CONS_CDR(T0)=v8,T0);
    if (Null(v8)){
     goto L21;
    }
   }
   T0 = ecl_cdr(v7);
   v7 = ecl_last(T0,1);
L21:;
   goto L11;
L12:;
   value0 = ecl_cdr(v6);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for MAKE-CONDITION                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_make_condition(cl_narg narg, cl_object v1type, ...)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("MAKE-CONDITION",526));
 {
  cl_object v2slot_initializations;
  ecl_va_list args; ecl_va_start(args,v1type,narg,1);
  v2slot_initializations = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3class;
   if (!(ECL_SYMBOLP(v1type))){
    goto L6;
   }
   value0 = cl_find_class(2, v1type, ECL_NIL);
   goto L4;
L6:;
   value0 = ECL_NIL;
   goto L4;
L4:;
   if (value0!=ECL_NIL) {
    goto L3;
   }
   T0 = cl_find_class(1, ECL_SYM("CONDITION",250));
   T1 = L2338find_subclasses_of_type(v1type, T0);
   T2 = (ECL_SYM("SUBCLASSP",1208)->symbol.gfdef);
   T3 = cl_sort(2, T1, T2);
   T4 = ecl_last(T3,1);
   v3class = ecl_car(T4);
   goto L1;
L3:;
   v3class = value0;
   goto L1;
L1:;
   if (v3class!=ECL_NIL) {
    goto L9;
   }
   T0 = ecl_list1(v1type);
   cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v1type, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("CONDITION",250), ECL_SYM("FORMAT-CONTROL",1272), VV[73], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L9:;
   T0 = (ECL_SYM("MAKE-INSTANCE",953)->symbol.gfdef);
   value0 = cl_apply(3, T0, v3class, v2slot_initializations);
   return value0;
  }
 }
}
/* local function HANDLER-BIND                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2341handler_bind(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4bindings;
  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);
   v4bindings = v5;
  }
  {
   cl_object v5;
   v5 = ecl_make_cfun_va((cl_objectfn)LC2339__lambda336_va,ECL_NIL,Cblock,1);
   T0 = v5;
  }
  if (cl_every(2, T0, v4bindings)!=ECL_NIL) {
   goto L9;
  }
  cl_error(1, VV[75]);
L9:;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_cfun_va((cl_objectfn)LC2340__lambda343_va,ECL_NIL,Cblock,1);
    v5 = v6;
   }
   {
    cl_object v6;
    cl_object v7;
    cl_object v8;
    {
     cl_object v9;
     v9 = v4bindings;
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v9;
    }
    v7 = ECL_NIL;
    v8 = v6;
    {
     cl_object v9;
     cl_object v10;
     v9 = ecl_list1(ECL_NIL);
     v10 = v9;
L21:;
     if (!(ecl_endp(v8))){
      goto L23;
     }
     goto L22;
L23:;
     v7 = 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;
     }
     {
      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;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
     v10 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v10,T1);
     goto L21;
L22:;
     T0 = ecl_cdr(v9);
     goto L12;
    }
   }
  }
L12:;
  T1 = CONS(ECL_SYM("LIST",483),T0);
  T2 = cl_list(3, ECL_SYM("CONS",253), T1, ECL_SYM("*HANDLER-CLUSTERS*",6));
  T3 = cl_list(2, ECL_SYM("*HANDLER-CLUSTERS*",6), T2);
  T4 = ecl_list1(T3);
  value0 = cl_listX(3, ECL_SYM("LET",479), T4, v3);
  return value0;
 }
}
static cl_object LC2341handler_bind_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[77]);
 {
  return LC2341handler_bind(v5, v6);
 }
}
/* function definition for SIGNAL                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2342signal(cl_narg narg, cl_object v1datum, ...)
{
 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[79]);
 {
  cl_object v2arguments;
  ecl_va_list args; ecl_va_start(args,v1datum,narg,1);
  v2arguments = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3condition;
   v3condition = L2343coerce_to_condition(v1datum, v2arguments, ECL_SYM("SIMPLE-CONDITION",770), ECL_SYM("SIGNAL",763));
   ecl_bds_push(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)); /*  *HANDLER-CLUSTERS* */
   if (Null(cl_typep(2, v3condition, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*BREAK-ON-SIGNALS*",27))))){
    goto L2;
   }
   L2346break(2, VV[78], v3condition);
L2:;
L5:;
   if (ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6))!=ECL_NIL) {
    goto L7;
   }
   goto L4;
L7:;
   {
    cl_object v4cluster;
    {
     cl_object v5;
     v5 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6));
     {
      cl_object v6;
      v6 = v5;
      {
       bool v7;
       v7 = ECL_LISTP(v6);
       if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[43],v6);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v5)){
      goto L14;
     }
     {
      cl_object v6;
      v6 = ECL_CONS_CDR(v5);
      T0 = v6;
      ecl_cmp_setq(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T0);
      v5 = ECL_CONS_CAR(v5);
     }
L14:;
     v4cluster = v5;
    }
    {
     cl_object v5;
     v5 = v4cluster;
     goto L23;
L22:;
     {
      cl_object v6handler;
      v6handler = ecl_car(v5);
      T0 = ecl_car(v6handler);
      if (Null(cl_typep(2, v3condition, T0))){
       goto L27;
      }
      T0 = ecl_cdr(v6handler);
      ecl_function_dispatch(cl_env_copy,T0)(1, v3condition);
L27:;
     }
     v5 = ecl_cdr(v5);
L23:;
     if (Null(v5)){
      goto L31;
     }
     goto L22;
L31:;
    }
   }
   goto L5;
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
/* function definition for COERCE-TO-CONDITION                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2343coerce_to_condition(cl_object v1datum, cl_object v2arguments, cl_object v3default_type, cl_object v4function_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 (Null(si_of_class_p(2, v1datum, ECL_SYM("CONDITION",250)))){
  goto L2;
 }
 if (Null(v2arguments)){
  goto L4;
 }
 T0 = cl_list(2, v1datum, v4function_name);
 cl_cerror(10, VV[80], ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v2arguments, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("NULL",607), ECL_SYM("FORMAT-CONTROL",1272), VV[81], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L4:;
 value0 = v1datum;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ECL_SYMBOLP(v1datum))){
  goto L6;
 }
 T0 = (ECL_SYM("MAKE-CONDITION",526)->symbol.gfdef);
 value0 = cl_apply(3, T0, v1datum, v2arguments);
 return value0;
L6:;
 if (ECL_STRINGP(v1datum)) {
  goto L11;
 }
 if (Null(cl_functionp(v1datum))){
  goto L9;
 }
 goto L10;
L11:;
L10:;
 value0 = cl_make_condition(5, v3default_type, ECL_SYM("FORMAT-CONTROL",1272), v1datum, ECL_SYM("FORMAT-ARGUMENTS",1271), v2arguments);
 return value0;
L9:;
 T0 = cl_list(2, v4function_name, v1datum);
 value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v1datum, ECL_SYM("EXPECTED-TYPE",1263), VV[82], ECL_SYM("FORMAT-CONTROL",1272), VV[83], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
 return value0;
}
static cl_object L2343coerce_to_condition_va(cl_narg narg, cl_object v5datum, cl_object v6arguments, cl_object v7default_type, cl_object v8function_name, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[50]);
 {
  return L2343coerce_to_condition(v5datum, v6arguments, v7default_type, v8function_name);
 }
}
/* function definition for BREAK                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2346break(volatile cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4;
 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);
 {
  cl_object volatile v1format_control;
  cl_object volatile v2format_arguments;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   int i = 0;
   if (i >= narg) {
    v1format_control = VV[85];
   } else {
    i++;
    v1format_control = ecl_va_arg(args);
   }
  }
  v2format_arguments = cl_grab_rest_args(args);
  ecl_va_end(args);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*DEBUGGER-HOOK*",33),ECL_NIL); /*  *DEBUGGER-HOOK* */
  {
   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 L3;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object v3;
      v3 = ecl_make_cclosure_va((cl_objectfn)LC2344__lambda360,env2,Cblock,0);
      T0 = v3;
     }
     {
      cl_object v3;
      v3 = ecl_make_cfun_va((cl_objectfn)LC2345__lambda362_va,ECL_NIL,Cblock,1);
      T1 = v3;
     }
     T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
     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* */
     T0 = cl_make_condition(5, ECL_SYM("SIMPLE-CONDITION",770), ECL_SYM("FORMAT-CONTROL",1272), v1format_control, ECL_SYM("FORMAT-ARGUMENTS",1271), v2format_arguments);
     (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, T0) /*  INVOKE-DEBUGGER */;
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
     goto L2;
L3:;
     {
      cl_object v3;
      v3 = ECL_CONS_CAR(CLV0);
      if (Null(v3)){
       goto L9;
      }
      si_dm_too_many_arguments(ECL_NIL);
L9:;
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      goto L2;
     }
     }
    }
   }
  }
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for WARN                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2349warn(volatile cl_narg narg, cl_object volatile v1datum, ...)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[97]);
 {
  cl_object volatile v2arguments;
  ecl_va_list args; ecl_va_start(args,v1datum,narg,1);
  v2arguments = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   volatile cl_object v3condition;
   v3condition = L2343coerce_to_condition(v1datum, v2arguments, ECL_SYM("SIMPLE-WARNING",779), ECL_SYM("WARN",907));
   {
    cl_object v4;
    v4 = v3condition;
    if (si_of_class_p(2, v4, ECL_SYM("WARNING",908))!=ECL_NIL) {
     goto L4;
    }
    v3condition = si_do_check_type(v4, ECL_SYM("WARNING",908), VV[91], ECL_SYM("CONDITION",250));
L4:;
   }
   {
    volatile cl_object env1 = env0;
    env1 = ECL_NIL;
    CLV0 = env1 = CONS(ECL_NIL,env1);
    {
     volatile cl_object env2 = env1;
     CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY      */
     {
      ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
      if (__ecl_frs_push_result!=0) {
      if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
       goto L8;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v4;
       v4 = ecl_make_cclosure_va((cl_objectfn)LC2347__lambda372,env2,Cblock,0);
       T0 = v4;
      }
      {
       cl_object v4;
       v4 = ecl_make_cfun_va((cl_objectfn)LC2348__lambda374_va,ECL_NIL,Cblock,1);
       T1 = v4;
      }
      T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("MUFFLE-WARNING",573), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
      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* */
      {
       cl_object v4;
       T0 = ECL_NIL;
       v4 = L2343coerce_to_condition(v3condition, T0, ECL_SYM("SIMPLE-CONDITION",770), ECL_SYM("SIGNAL",763));
       T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
       T1 = CONS(v4,T0);
       T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[4]));
       ecl_bds_bind(cl_env_copy,VV[4],T2);        /*  *CONDITION-RESTARTS*    */
       L2342signal(1, v4);
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       goto L7;
      }
L8:;
      {
       cl_object v4;
       v4 = ECL_CONS_CAR(CLV0);
       if (Null(v4)){
        goto L15;
       }
       si_dm_too_many_arguments(ECL_NIL);
L15:;
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_frs_pop_n(cl_env_copy, 1);
       return value0;
      }
      }
     }
    }
   }
L7:;
   cl_format(3, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*ERROR-OUTPUT*",35)), VV[96], v3condition);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* local function SIMPLE-CONDITION-FORMAT-CONTROL                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2350simple_condition_format_control(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("SIMPLE-CONDITION",770));
 return value0;
}
static cl_object LC2350simple_condition_format_control_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771));
 {
  return LC2350simple_condition_format_control(v2instance);
 }
}
/* local function SIMPLE-CONDITION-FORMAT-ARGUMENTS                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2351simple_condition_format_arguments(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("SIMPLE-CONDITION",770));
 return value0;
}
static cl_object LC2351simple_condition_format_arguments_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772));
 {
  return LC2351simple_condition_format_arguments(v2instance);
 }
}
/* local function LAMBDA379                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2353__lambda379()
{
 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_make_cfun_va((cl_objectfn)LC2352__lambda381_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2353__lambda379_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[100]);
 {
  return LC2353__lambda379();
 }
}
/* local function LAMBDA383                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2355__lambda383()
{
 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_make_cfun_va((cl_objectfn)LC2354__lambda385_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2355__lambda383_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[104]);
 {
  return LC2355__lambda383();
 }
}
/* local function LAMBDA387                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2357__lambda387()
{
 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_make_cfun_va((cl_objectfn)LC2356__lambda389_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2357__lambda387_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[108]);
 {
  return LC2357__lambda387();
 }
}
/* local function LAMBDA391                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2359__lambda391()
{
 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_make_cfun_va((cl_objectfn)LC2358__lambda393_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2359__lambda391_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[112]);
 {
  return LC2359__lambda391();
 }
}
/* local function TYPE-ERROR-DATUM                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2360type_error_datum(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("TYPE-ERROR",873));
 return value0;
}
static cl_object LC2360type_error_datum_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("TYPE-ERROR-DATUM",874));
 {
  return LC2360type_error_datum(v2instance);
 }
}
/* local function TYPE-ERROR-EXPECTED-TYPE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2361type_error_expected_type(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("TYPE-ERROR",873));
 return value0;
}
static cl_object LC2361type_error_expected_type_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("TYPE-ERROR-EXPECTED-TYPE",875));
 {
  return LC2361type_error_expected_type(v2instance);
 }
}
/* local function LAMBDA397                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2363__lambda397()
{
 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_make_cfun_va((cl_objectfn)LC2362__lambda399_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2363__lambda397_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[115]);
 {
  return LC2363__lambda397();
 }
}
/* local function LAMBDA401                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2365__lambda401()
{
 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_make_cfun_va((cl_objectfn)LC2364__lambda403_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2365__lambda401_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[119]);
 {
  return LC2365__lambda401();
 }
}
/* local function STREAM-ERROR-STREAM                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2366stream_error_stream(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("STREAM-ERROR",804));
 return value0;
}
static cl_object LC2366stream_error_stream_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("STREAM-ERROR-STREAM",805));
 {
  return LC2366stream_error_stream(v2instance);
 }
}
/* local function LAMBDA406                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2368__lambda406()
{
 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_make_cfun_va((cl_objectfn)LC2367__lambda408_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2368__lambda406_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[124]);
 {
  return LC2368__lambda406();
 }
}
/* local function FILE-ERROR-PATHNAME                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2369file_error_pathname(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("FILE-ERROR",355));
 return value0;
}
static cl_object LC2369file_error_pathname_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("FILE-ERROR-PATHNAME",356));
 {
  return LC2369file_error_pathname(v2instance);
 }
}
/* local function LAMBDA411                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2371__lambda411()
{
 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_make_cfun_va((cl_objectfn)LC2370__lambda413_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2371__lambda411_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[127]);
 {
  return LC2371__lambda411();
 }
}
/* local function PACKAGE-ERROR-PACKAGE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2372package_error_package(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("PACKAGE-ERROR",620));
 return value0;
}
static cl_object LC2372package_error_package_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("PACKAGE-ERROR-PACKAGE",621));
 {
  return LC2372package_error_package(v2instance);
 }
}
/* local function CELL-ERROR-NAME                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2373cell_error_name(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("CELL-ERROR",202));
 return value0;
}
static cl_object LC2373cell_error_name_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("CELL-ERROR-NAME",203));
 {
  return LC2373cell_error_name(v2instance);
 }
}
/* local function LAMBDA417                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2375__lambda417()
{
 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_make_cfun_va((cl_objectfn)LC2374__lambda419_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2375__lambda417_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[130]);
 {
  return LC2375__lambda417();
 }
}
/* local function UNBOUND-SLOT-INSTANCE                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2376unbound_slot_instance(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("UNBOUND-SLOT",879));
 return value0;
}
static cl_object LC2376unbound_slot_instance_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("UNBOUND-SLOT-INSTANCE",880));
 {
  return LC2376unbound_slot_instance(v2instance);
 }
}
/* local function LAMBDA422                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2378__lambda422()
{
 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_make_cfun_va((cl_objectfn)LC2377__lambda424_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2378__lambda422_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[133]);
 {
  return LC2378__lambda422();
 }
}
/* local function LAMBDA426                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2380__lambda426()
{
 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_make_cfun_va((cl_objectfn)LC2379__lambda428_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2380__lambda426_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[136]);
 {
  return LC2380__lambda426();
 }
}
/* local function ARITHMETIC-ERROR-OPERATION                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2381arithmetic_error_operation(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("ARITHMETIC-ERROR",95));
 return value0;
}
static cl_object LC2381arithmetic_error_operation_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("ARITHMETIC-ERROR-OPERATION",97));
 {
  return LC2381arithmetic_error_operation(v2instance);
 }
}
/* local function ARITHMETIC-ERROR-OPERANDS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2382arithmetic_error_operands(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("ARITHMETIC-ERROR",95));
 return value0;
}
static cl_object LC2382arithmetic_error_operands_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("ARITHMETIC-ERROR-OPERANDS",96));
 {
  return LC2382arithmetic_error_operands(v2instance);
 }
}
/* local function PRINT-NOT-READABLE-OBJECT                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2383print_not_readable_object(cl_object v1instance)
{
 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(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1instance, ECL_SYM("EXPECTED-TYPE",1263), ECL_SYM("PRINT-NOT-READABLE",666));
 return value0;
}
static cl_object LC2383print_not_readable_object_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("PRINT-NOT-READABLE-OBJECT",667));
 {
  return LC2383print_not_readable_object(v2instance);
 }
}
/* local function LAMBDA433                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2385__lambda433()
{
 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_make_cfun_va((cl_objectfn)LC2384__lambda435_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2385__lambda433_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[140]);
 {
  return LC2385__lambda433();
 }
}
/* local function LAMBDA437                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2387__lambda437()
{
 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_make_cfun_va((cl_objectfn)LC2386__lambda439_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2387__lambda437_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[143]);
 {
  return LC2387__lambda437();
 }
}
/* local function LAMBDA441                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2388__lambda441()
{
 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_cmp_symbol_value(cl_env_copy,VV[150]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2388__lambda441_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[149]);
 {
  return LC2388__lambda441();
 }
}
/* local function LAMBDA443                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2389__lambda443()
{
 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_cmp_symbol_value(cl_env_copy,VV[152]);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2389__lambda443_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[151]);
 {
  return LC2389__lambda443();
 }
}
/* function definition for SIGNAL-SIMPLE-ERROR                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_signal_simple_error(cl_narg narg, cl_object v1base_condition, cl_object v2continue_message, cl_object v3format_control, cl_object v4format_args, ...)
{
 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<4)) FEwrong_num_arguments(ECL_SYM("SIGNAL-SIMPLE-ERROR",1168));
 {
  cl_object v5args;
  ecl_va_list args; ecl_va_start(args,v4format_args,narg,4);
  v5args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v6simple_error_name;
   T0 = cl_string(v1base_condition);
   T1 = cl_concatenate(3, ECL_SYM("STRING",808), VV[153], T0);
   T2 = cl_find_package(VV[154]);
   v6simple_error_name = cl_intern(2, T1, T2);
   if (cl_find_class(2, v6simple_error_name, ECL_NIL)!=ECL_NIL) {
    goto L2;
   }
   T0 = cl_list(2, ECL_SYM("SIMPLE-ERROR",773), v1base_condition);
   T1 = cl_list(4, ECL_SYM("DEFCLASS",941), v6simple_error_name, T0, ECL_NIL);
   cl_eval(T1);
L2:;
   if (Null(v2continue_message)){
    goto L4;
   }
   T0 = (ECL_SYM("CERROR",204)->symbol.gfdef);
   value0 = cl_apply(8, T0, v2continue_message, v6simple_error_name, ECL_SYM("FORMAT-CONTROL",1272), v3format_control, ECL_SYM("FORMAT-ARGUMENTS",1271), v4format_args, v5args);
   return value0;
L4:;
   T0 = (ECL_SYM("ERROR",339)->symbol.gfdef);
   value0 = cl_apply(7, T0, v6simple_error_name, ECL_SYM("FORMAT-CONTROL",1272), v3format_control, ECL_SYM("FORMAT-ARGUMENTS",1271), v4format_args, v5args);
   return value0;
  }
 }
}
/* local function HANDLER-CASE                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2393handler_case(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 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;
  }
  {
   cl_object v5no_error_clause;
   {
    cl_object v6;
    cl_object v7;
    v6 = VV[155];
    v7 = v3;
    v5no_error_clause = ecl_assql(v6,v7);
   }
   if (Null(v5no_error_clause)){
    goto L12;
   }
   {
    cl_object v6normal_return;
    cl_object v7error_return;
    v6normal_return = cl_make_symbol(VV[156]);
    v7error_return = cl_make_symbol(VV[157]);
    T0 = ecl_cdr(v5no_error_clause);
    T1 = CONS(ECL_SYM("LAMBDA",454),T0);
    T2 = cl_list(2, ECL_SYM("FUNCTION",398), T1);
    T3 = cl_list(3, ECL_SYM("RETURN-FROM",728), v6normal_return, v4form);
    T4 = cl_remove(2, v5no_error_clause, v3);
    T5 = cl_listX(3, ECL_SYM("HANDLER-CASE",418), T3, T4);
    T6 = cl_list(3, ECL_SYM("RETURN-FROM",728), v7error_return, T5);
    T7 = cl_list(3, ECL_SYM("BLOCK",139), v6normal_return, T6);
    T8 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), T2, T7);
    value0 = cl_list(3, ECL_SYM("BLOCK",139), v7error_return, T8);
    return value0;
   }
L12:;
   {
    cl_object v8annotated_cases;
    cl_object env1 = env0;
    T0 = cl_gensym(0);
    env1 = ECL_NIL;
    CLV0 = env1 = CONS(T0,env1);                  /*  TAG                     */
    T0 = cl_gensym(0);
    CLV1 = env1 = CONS(T0,env1);                  /*  VAR                     */
    {
     cl_object v9;
     {
      cl_object v10;
      v10 = ecl_make_cfun_va((cl_objectfn)LC2390__lambda469_va,ECL_NIL,Cblock,1);
      v9 = v10;
     }
     {
      cl_object v10;
      cl_object v11;
      cl_object v12;
      {
       cl_object v13;
       v13 = v3;
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      v11 = ECL_NIL;
      v12 = v10;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L25:;
       if (!(ecl_endp(v12))){
        goto L27;
       }
       goto L26;
L27:;
       v11 = ECL_CONS_CAR(v12);
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       {
        cl_object v15;
        v15 = v14;
        if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v15;
       }
       T1 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
       v14 = ecl_list1(T1);
       (ECL_CONS_CDR(T0)=v14,T0);
       goto L25;
L26:;
       v8annotated_cases = ecl_cdr(v13);
       goto L16;
      }
     }
    }
L16:;
    T0 = cl_list(2, ECL_CONS_CAR(CLV1), ECL_NIL);
    T1 = ecl_list1(T0);
    T2 = cl_list(2, ECL_SYM("IGNORABLE",429), ECL_CONS_CAR(CLV1));
    T3 = cl_list(2, ECL_SYM("DECLARE",276), T2);
    {
     cl_object v9;
     {
      cl_object v10;
      v10 = ecl_make_cclosure_va((cl_objectfn)LC2391__lambda478,env1,Cblock,1);
      v9 = v10;
     }
     {
      cl_object v10;
      cl_object v11;
      cl_object v12;
      {
       cl_object v13;
       v13 = v8annotated_cases;
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      v11 = ECL_NIL;
      v12 = v10;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L52:;
       if (!(ecl_endp(v12))){
        goto L54;
       }
       goto L53;
L54:;
       v11 = ECL_CONS_CAR(v12);
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       {
        cl_object v15;
        v15 = v14;
        if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T5 = v15;
       }
       T6 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
       v14 = ecl_list1(T6);
       (ECL_CONS_CDR(T5)=v14,T5);
       goto L52;
L53:;
       T4 = ecl_cdr(v13);
       goto L43;
      }
     }
    }
L43:;
    T5 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), v4form);
    T6 = cl_list(3, ECL_SYM("HANDLER-BIND",419), T4, T5);
    {
     cl_object v9;
     {
      cl_object v10;
      v10 = ecl_make_cclosure_va((cl_objectfn)LC2392__lambda487,env1,Cblock,1);
      v9 = v10;
     }
     {
      cl_object v10;
      cl_object v11;
      cl_object v12;
      {
       cl_object v13;
       v13 = v8annotated_cases;
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      v11 = ECL_NIL;
      v12 = v10;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L79:;
       if (!(ecl_endp(v12))){
        goto L81;
       }
       goto L80;
L81:;
       v11 = ECL_CONS_CAR(v12);
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v12);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v12 = v15;
       }
       {
        cl_object v15;
        v15 = ecl_function_dispatch(cl_env_copy,v9)(1, v11);
        {
         cl_object v16;
         v16 = v14;
         if (ecl_unlikely(ECL_ATOM(v16))) FEtype_error_cons(v16);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T8 = v16;
        }
        (ECL_CONS_CDR(T8)=v15,T8);
        if (Null(v15)){
         goto L89;
        }
       }
       T8 = ecl_cdr(v14);
       v14 = ecl_last(T8,1);
L89:;
       goto L79;
L80:;
       T7 = ecl_cdr(v13);
       goto L70;
      }
     }
    }
L70:;
    T8 = cl_listX(3, ECL_SYM("TAGBODY",853), T6, T7);
    T9 = cl_list(4, ECL_SYM("LET",479), T1, T3, T8);
    value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_CONS_CAR(CLV0), T9);
    return value0;
   }
  }
 }
}
static cl_object LC2393handler_case_va(cl_narg narg, cl_object v9, cl_object v10, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[163]);
 {
  return LC2393handler_case(v9, v10);
 }
}
/* local function IGNORE-ERRORS                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2394ignore_errors(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 = CONS(ECL_SYM("PROGN",674),v3);
  value0 = cl_list(3, ECL_SYM("HANDLER-CASE",418), T0, VV[164]);
  return value0;
 }
}
static cl_object LC2394ignore_errors_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[165]);
 {
  return LC2394ignore_errors(v4, v5);
 }
}
/* function definition for ABORT                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_abort(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(ECL_SYM("ABORT",79));
 {
  cl_object v1c;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1c = ECL_NIL;
   } else {
    i++;
    v1c = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = L2327find_restart_never_fail(2, ECL_SYM("ABORT",79), v1c);
  cl_invoke_restart(1, T0);
  value0 = cl_error(1, VV[139]);
  return value0;
 }
}
/* function definition for CONTINUE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_continue(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(ECL_SYM("CONTINUE",252));
 {
  cl_object v1c;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1c = ECL_NIL;
   } else {
    i++;
    v1c = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v2restart;
   v2restart = cl_find_restart(2, ECL_SYM("CONTINUE",252), v1c);
   if (Null(v2restart)){
    goto L4;
   }
   value0 = cl_invoke_restart(1, v2restart);
   return value0;
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for MUFFLE-WARNING                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_muffle_warning(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(ECL_SYM("MUFFLE-WARNING",573));
 {
  cl_object v1c;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1c = ECL_NIL;
   } else {
    i++;
    v1c = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = L2327find_restart_never_fail(2, ECL_SYM("MUFFLE-WARNING",573), v1c);
  value0 = cl_invoke_restart(1, T0);
  return value0;
 }
}
/* function definition for STORE-VALUE                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_store_value(cl_narg narg, cl_object v1value, ...)
{
 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(ECL_SYM("STORE-VALUE",801));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("STORE-VALUE",801));
 {
  cl_object v2c;
  va_list args; va_start(args,v1value);
  {
   int i = 1;
   if (i >= narg) {
    v2c = ECL_NIL;
   } else {
    i++;
    v2c = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3restart;
   v3restart = cl_find_restart(2, ECL_SYM("STORE-VALUE",801), v2c);
   if (Null(v3restart)){
    goto L4;
   }
   value0 = cl_invoke_restart(2, v3restart, v1value);
   return value0;
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for USE-VALUE                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_use_value(cl_narg narg, cl_object v1value, ...)
{
 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(ECL_SYM("USE-VALUE",897));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("USE-VALUE",897));
 {
  cl_object v2c;
  va_list args; va_start(args,v1value);
  {
   int i = 1;
   if (i >= narg) {
    v2c = ECL_NIL;
   } else {
    i++;
    v2c = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3restart;
   v3restart = cl_find_restart(2, ECL_SYM("USE-VALUE",897), v2c);
   if (Null(v3restart)){
    goto L4;
   }
   value0 = cl_invoke_restart(2, v3restart, v1value);
   return value0;
L4:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for ASSERT-REPORT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2395assert_report(cl_object v1names, cl_object v2stream)
{
 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_format(2, v2stream, VV[167]);
 if (Null(v1names)){
  goto L3;
 }
 {
  cl_fixnum v3;
  v3 = ecl_length(v1names);
  value0 = cl_format(4, v2stream, VV[168], ecl_make_fixnum(v3), v1names);
  return value0;
 }
L3:;
 value0 = cl_format(2, v2stream, VV[169]);
 return value0;
}
/* function definition for ASSERT-PROMPT                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2397assert_prompt(cl_object v1name, cl_object v2value)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(cl_y_or_n_p(3, VV[171], v1name, v2value))){
  goto L2;
 }
 cl_format(2, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), VV[173]);
 if (!(ECL_SYMBOLP(v1name))){
  goto L5;
 }
 {
  cl_object v4, v5; cl_index v3;
  v4 = ecl_list1(v1name);
  v5 = ecl_list1(v2value);
  v3 = ecl_progv(cl_env_copy, v4, v5);
  value0 = LC2396read_it();
  ecl_bds_unwind(cl_env_copy,v3);
  return value0;
 }
L5:;
 value0 = LC2396read_it();
 return value0;
L2:;
 value0 = v2value;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for ASSERT-FAILURE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_assert_failure(volatile cl_narg narg, cl_object volatile v1test_form, ...)
{
 cl_object T0, T1, T2, T3, T4;
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("ASSERT-FAILURE",1888));
 {
  cl_object volatile v2values;
  cl_object volatile v3arguments;
  ecl_va_list args; ecl_va_start(args,v1test_form,narg,1);
  {
   int i = 1;
   if (i >= narg) {
    env0 = ECL_NIL;
    CLV0 = env0 = CONS(ECL_NIL,env0);             /*  PLACE-NAMES             */
   } else {
    i++;
    env0 = ECL_NIL;
    CLV0 = env0 = CONS(ecl_va_arg(args),env0);    /*  PLACE-NAMES             */
   }
   if (i >= narg) {
    v2values = ECL_NIL;
   } else {
    i++;
    v2values = ecl_va_arg(args);
   }
  }
  v3arguments = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (v3arguments!=ECL_NIL) {
   goto L2;
  }
  T0 = ecl_list1(v1test_form);
  v3arguments = cl_list(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("DATUM",1245), v1test_form, ECL_SYM("EXPECTED-TYPE",1263), ECL_NIL, ECL_SYM("FORMAT-CONTROL",1272), VV[174], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L2:;
  {
   volatile cl_object env1 = env0;
   CLV1 = env1 = CONS(ECL_NIL,env1);
   CLV2 = env1 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env1); /*  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 L5;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v4;
     v4 = ecl_make_cclosure_va((cl_objectfn)LC2398__lambda514,env1,Cblock,0);
     T0 = v4;
    }
    {
     cl_object v4;
     v4 = ecl_make_cclosure_va((cl_objectfn)LC2399__lambda516,env1,Cblock,1);
     T1 = v4;
    }
    T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
    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* */
    {
     cl_object v4;
     T0 = ecl_car(v3arguments);
     T1 = ecl_cdr(v3arguments);
     T2 = L2343coerce_to_condition(T0, T1, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ASSERT",115));
     T3 = ECL_NIL;
     v4 = L2343coerce_to_condition(T2, T3, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339));
     T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
     T1 = CONS(v4,T0);
     T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[4]));
     ecl_bds_bind(cl_env_copy,VV[4],T2);          /*  *CONDITION-RESTARTS*    */
     value0 = cl_error(1, v4);
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
     return value0;
    }
L5:;
    {
     cl_object v4;
     v4 = ECL_CONS_CAR(CLV1);
     if (Null(v4)){
      goto L12;
     }
     si_dm_too_many_arguments(ECL_NIL);
L12:;
     {
      cl_object v5;
      cl_object v6place_name;
      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;
      }
      v6place_name = ECL_NIL;
      v7 = v5;
      {
       cl_object v8;
       cl_object v9value;
       cl_object v10;
       {
        cl_object v11;
        v11 = v2values;
        if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v8 = v11;
       }
       v9value = ECL_NIL;
       v10 = v8;
       {
        cl_object v11;
        cl_object v12;
        v11 = ecl_list1(ECL_NIL);
        v12 = v11;
L27:;
        if (!(ecl_endp(v7))){
         goto L29;
        }
        goto L28;
L29:;
        v6place_name = ECL_CONS_CAR(v7);
        {
         cl_object v13;
         v13 = ECL_CONS_CDR(v7);
         if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v7 = v13;
        }
        if (!(ecl_endp(v10))){
         goto L37;
        }
        goto L28;
L37:;
        v9value = ECL_CONS_CAR(v10);
        {
         cl_object v13;
         v13 = ECL_CONS_CDR(v10);
         if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v10 = v13;
        }
        {
         cl_object v13;
         v13 = v12;
         if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T1 = v13;
        }
        T2 = L2397assert_prompt(v6place_name, v9value);
        v12 = ecl_list1(T2);
        (ECL_CONS_CDR(T1)=v12,T1);
        goto L27;
L28:;
        T0 = ecl_cdr(v11);
        goto L14;
       }
      }
     }
L14:;
     value0 = cl_values_list(T0);
     ecl_frs_pop_n(cl_env_copy, 1);
     return value0;
    }
    }
   }
  }
 }
}
/* function definition for UNIVERSAL-ERROR-HANDLER                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2410universal_error_handler(cl_object volatile v1continue_string, cl_object volatile v2datum, cl_object volatile v3args)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7;
 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(v1continue_string,env0);      /*  CONTINUE-STRING         */
 CLV1 = env0 = CONS(v3args,env0);                 /*  ARGS                    */
 {
  volatile cl_object v4condition;
  v4condition = L2343coerce_to_condition(v2datum, ECL_CONS_CAR(CLV1), ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339));
  if (!((ECL_T)==(ECL_CONS_CAR(CLV0)))){
   goto L2;
  }
  {
   volatile cl_object env1 = env0;
   CLV2 = env1 = CONS(ECL_NIL,env1);
   {
    volatile cl_object env2 = env1;
    CLV3 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY       */
    {
     ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV3));
     if (__ecl_frs_push_result!=0) {
     if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
      goto L4;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC2400__lambda532,env2,Cblock,0);
      T0 = v5;
     }
     {
      cl_object v5;
      v5 = ecl_make_cfun_va((cl_objectfn)LC2401__lambda534_va,ECL_NIL,Cblock,1);
      T1 = v5;
     }
     T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("IGNORE",430), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
     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* */
     L2342signal(1, v4condition);
     value0 = (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v4condition) /*  INVOKE-DEBUGGER */;
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     return value0;
L4:;
     {
      cl_object v5;
      v5 = ECL_CONS_CAR(CLV2);
      if (Null(v5)){
       goto L11;
      }
      si_dm_too_many_arguments(ECL_NIL);
L11:;
      cl_env_copy->nvalues = 2;
      cl_env_copy->values[1] = ECL_T;
      cl_env_copy->values[0] = ECL_NIL;
      ecl_frs_pop_n(cl_env_copy, 1);
      return cl_env_copy->values[0];
     }
     }
    }
   }
  }
L2:;
  if (!(ECL_STRINGP(ECL_CONS_CAR(CLV0)))){
   goto L13;
  }
  {
   volatile cl_object env1 = env0;
   CLV2 = env1 = CONS(ECL_NIL,env1);
   {
    volatile cl_object env2 = env1;
    CLV3 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY       */
    {
     ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV3));
     if (__ecl_frs_push_result!=0) {
     if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
      goto L15;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC2402__lambda541,env2,Cblock,0);
      T0 = v5;
     }
     {
      cl_object v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC2403__lambda543,env2,Cblock,1);
      T1 = v5;
     }
     T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
     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* */
     L2342signal(1, v4condition);
     value0 = (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v4condition) /*  INVOKE-DEBUGGER */;
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     return value0;
L15:;
     {
      cl_object v5;
      v5 = ECL_CONS_CAR(CLV2);
      if (Null(v5)){
       goto L22;
      }
      si_dm_too_many_arguments(ECL_NIL);
L22:;
      cl_env_copy->nvalues = 2;
      cl_env_copy->values[1] = ECL_T;
      cl_env_copy->values[0] = ECL_NIL;
      ecl_frs_pop_n(cl_env_copy, 1);
      return cl_env_copy->values[0];
     }
     }
    }
   }
  }
L13:;
  if (Null(ECL_CONS_CAR(CLV0))){
   goto L24;
  }
  if (!(ECL_SYMBOLP(ECL_CONS_CAR(CLV0)))){
   goto L24;
  }
  {
   volatile cl_object env1 = env0;
   CLV2 = env1 = CONS(ECL_NIL,env1);
   {
    volatile cl_object env2 = env1;
    CLV3 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY       */
    {
     ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV3));
     if (__ecl_frs_push_result!=0) {
     if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
      goto L27;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object volatile v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC2404__lambda550,env2,Cblock,0);
      T0 = v5;
     }
     {
      cl_object volatile v5;
      v5 = ecl_make_cfun_va((cl_objectfn)LC2405__lambda552_va,ECL_NIL,Cblock,1);
      T1 = v5;
     }
     T2 = L2314make_restart(6, ECL_SYM("NAME",1309), VV[187], ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
     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* */
     {
      cl_object volatile v5;                      /*  RV                      */
      cl_object volatile v6;                      /*  USED-RESTART            */
      {
       volatile cl_object env3 = env2;
       CLV4 = env3 = CONS(ECL_NIL,env3);
       {
        volatile cl_object env4 = env3;
        CLV5 = env4 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env4); /*  TAGBODY   */
        {
         ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV5));
         if (__ecl_frs_push_result!=0) {
         if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
          goto L32;
         }
         ecl_internal_error("GO found an inexistent tag");
         } else {
         {
          cl_object volatile v7;
          v7 = ecl_make_cclosure_va((cl_objectfn)LC2406__lambda558,env4,Cblock,0);
          T0 = v7;
         }
         {
          cl_object volatile v7;
          v7 = ecl_make_cfun_va((cl_objectfn)LC2407__lambda560_va,ECL_NIL,Cblock,1);
          T1 = v7;
         }
         T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("IGNORE",430), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
         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* */
         {
          cl_object volatile v7;                  /*  RV                      */
          cl_object volatile v8;                  /*  USED-RESTART            */
          {
          volatile cl_object env5 = env4;
          CLV6 = env5 = CONS(ECL_NIL,env5);
          {
          volatile cl_object env6 = env5;
          CLV7 = env6 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env6); /*  TAGBODY */
          {
          ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV7));
          if (__ecl_frs_push_result!=0) {
          if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
          goto L37;
          }
          ecl_internal_error("GO found an inexistent tag");
          } else {
          {
          cl_object v9;
          v9 = ecl_make_cclosure_va((cl_objectfn)LC2408__lambda566,env6,Cblock,0);
          T0 = v9;
          }
          {
          cl_object v9;
          v9 = ecl_make_cclosure_va((cl_objectfn)LC2409__lambda568,env6,Cblock,1);
          T1 = v9;
          }
          T2 = L2314make_restart(6, ECL_SYM("NAME",1309), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1273), T0, VV[47], T1);
          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* */
          L2342signal(1, v4condition);
          value0 = (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v4condition) /*  INVOKE-DEBUGGER */;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          goto L36;
L37:;
          {
          cl_object v9;
          v9 = ECL_CONS_CAR(CLV6);
          if (Null(v9)){
          goto L44;
          }
          si_dm_too_many_arguments(ECL_NIL);
L44:;
          cl_env_copy->nvalues = 2;
          cl_env_copy->values[1] = ECL_T;
          cl_env_copy->values[0] = ECL_NIL;
          value0 = cl_env_copy->values[0];
          ecl_frs_pop_n(cl_env_copy, 1);
          goto L36;
          }
          }
          }
          }
          }
L36:;
          {
          const int v9 = cl_env_copy->nvalues;
          v7 = value0;
          cl_object v10;
          v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
          v8 = v10;
          }
          if (Null(v8)){
          goto L46;
          }
          value0 = ECL_CONS_CAR(CLV0);
          cl_env_copy->nvalues = 1;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          goto L31;
L46:;
          value0 = v7;
          cl_env_copy->nvalues = 1;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          goto L31;
         }
L32:;
         {
          cl_object v7;
          v7 = ECL_CONS_CAR(CLV4);
          if (Null(v7)){
          goto L50;
          }
          si_dm_too_many_arguments(ECL_NIL);
L50:;
          cl_env_copy->nvalues = 2;
          cl_env_copy->values[1] = ECL_T;
          cl_env_copy->values[0] = ECL_NIL;
          value0 = cl_env_copy->values[0];
          ecl_frs_pop_n(cl_env_copy, 1);
          goto L31;
         }
         }
        }
       }
      }
L31:;
      {
       const int v7 = cl_env_copy->nvalues;
       v5 = value0;
       cl_object v8;
       v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
       v6 = v8;
      }
      if (Null(v6)){
       goto L52;
      }
      value0 = ECL_T;
      cl_env_copy->nvalues = 1;
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      return value0;
L52:;
      value0 = v5;
      cl_env_copy->nvalues = 1;
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      return value0;
     }
L27:;
     {
      cl_object v5;
      v5 = ECL_CONS_CAR(CLV2);
      if (Null(v5)){
       goto L56;
      }
      si_dm_too_many_arguments(ECL_NIL);
L56:;
      cl_env_copy->nvalues = 2;
      cl_env_copy->values[1] = ECL_T;
      cl_env_copy->values[0] = ECL_NIL;
      ecl_frs_pop_n(cl_env_copy, 1);
      return cl_env_copy->values[0];
     }
     }
    }
   }
  }
L24:;
  L2342signal(1, v4condition);
  value0 = (cl_env_copy->function=(ECL_SYM("INVOKE-DEBUGGER",447)->symbol.gfdef))->cfun.entry(1, v4condition) /*  INVOKE-DEBUGGER */;
  return value0;
 }
}
static cl_object L2410universal_error_handler_va(cl_narg narg, cl_object v5continue_string, cl_object v6datum, cl_object v7args, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[198]);
 {
  return L2410universal_error_handler(v5continue_string, v6datum, v7args);
 }
}
/* function definition for TPL-CONTINUE-COMMAND                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2411tpl_continue_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 v1any;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1any = cl_grab_rest_args(args);
  ecl_va_end(args);
  T0 = (ECL_SYM("INVOKE-RESTART",448)->symbol.gfdef);
  value0 = cl_apply(3, T0, ECL_SYM("CONTINUE",252), v1any);
  return value0;
 }
}
/* local function SIMPLE-RESTART-FUNCTION                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2322simple_restart_function(cl_object v1tag, cl_object v2code)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1tag,env0);                  /*  TAG                     */
 CLV1 = env0 = CONS(v2code,env0);                 /*  CODE                    */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2321__lambda69,env0,Cblock,0);
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2322simple_restart_function_va(cl_narg narg, cl_object v4tag, cl_object v5code, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
  return LC2322simple_restart_function(v4tag, v5code);
 }
}
/* local function SIMPLE-HANDLER-FUNCTION                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2324simple_handler_function(cl_object v1tag, cl_object v2code)
{
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1tag,env0);                  /*  TAG                     */
 CLV1 = env0 = CONS(v2code,env0);                 /*  CODE                    */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2323__lambda78,env0,Cblock,1);
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2324simple_handler_function_va(cl_narg narg, cl_object v4tag, cl_object v5code, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[34]);
 {
  return LC2324simple_handler_function(v4tag, v5code);
 }
}
/* local function LAMBDA98                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2325__lambda98(cl_object v1binding)
{
 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_car(v1binding);
 T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
 T2 = ecl_cadr(v1binding);
 T3 = ecl_cddr(v1binding);
 value0 = cl_listX(6, VV[13], ECL_SYM("NAME",1309), T1, ECL_SYM("FUNCTION",1273), T2, T3);
 return value0;
}
static cl_object LC2325__lambda98_va(cl_narg narg, cl_object v2binding, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[36]);
 {
  return LC2325__lambda98(v2binding);
 }
}
/* local function PROCESS-CLAUSE                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2328process_clause(cl_object v1clause)
{
 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;
  cl_object v3;
  cl_object v4opts;
  cl_object v5keys;
  cl_object v6forms;
  {
   cl_object v7;
   v7 = v1clause;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[43],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L7;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v1clause = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L7:;
   v2 = v7;
  }
  {
   cl_object v7;
   v7 = v1clause;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[43],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L18;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v1clause = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L18:;
   v3 = v7;
  }
  v4opts = VV[44];
  v5keys = ECL_NIL;
  v6forms = v1clause;
  goto L29;
L28:;
  {
   cl_object v7;
   cl_object v8;
   v7 = ecl_car(v6forms);
   v8 = ecl_cadr(v6forms);
   v4opts = cl_remove(2, v7, v4opts);
   if (!((v7)==(ECL_SYM("TEST",1353)))){
    goto L37;
   }
   T0 = cl_list(2, ECL_SYM("FUNCTION",398), v8);
   v5keys = cl_listX(3, VV[45], T0, v5keys);
   goto L36;
L37:;
   if (!((v7)==(ECL_SYM("INTERACTIVE",1290)))){
    goto L39;
   }
   T0 = cl_list(2, ECL_SYM("FUNCTION",398), v8);
   v5keys = cl_listX(3, VV[46], T0, v5keys);
   goto L36;
L39:;
   if (!((v7)==(ECL_SYM("REPORT",1339)))){
    goto L41;
   }
   if (!(ECL_STRINGP(v8))){
    goto L44;
   }
   T1 = cl_list(3, ECL_SYM("WRITE-STRING",926), v8, ECL_SYM("STREAM",802));
   T0 = cl_list(3, ECL_SYM("LAMBDA",454), VV[48], T1);
   goto L43;
L44:;
   T0 = cl_list(2, ECL_SYM("FUNCTION",398), v8);
L43:;
   v5keys = cl_listX(3, VV[47], T0, v5keys);
   goto L36;
L41:;
   v5keys = si_ecase_error(v7, VV[49]);
L36:;
  }
  v6forms = ecl_cddr(v6forms);
L29:;
  if (v6forms==ECL_NIL) {
   goto L48;
  }
  {
   cl_object v7;
   cl_object v8;
   cl_object v9;
   v7 = ecl_car(v6forms);
   v8 = v7;
   v9 = v4opts;
   if (Null(ecl_memql(v8,v9))){
    goto L48;
   }
  }
  goto L28;
L48:;
  T0 = cl_gensym(0);
  value0 = cl_list(5, v2, T0, v5keys, v3, v6forms);
  return value0;
 }
}
static cl_object LC2328process_clause_va(cl_narg narg, cl_object v7clause, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[40]);
 {
  return LC2328process_clause(v7clause);
 }
}
/* closure LAMBDA236                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2329__lambda236(cl_narg narg, cl_object v1datum, ...)
{
 cl_object T0, T1, T2, T3;
 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;                                     /*  TEMP-VAR                */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[56]);
 {
L1:;
  {
   cl_object v2name;
   cl_object v3tag;
   cl_object v4keys;
   v2name = ecl_car(v1datum);
   v3tag = ecl_cadr(v1datum);
   v4keys = ecl_caddr(v1datum);
   T0 = cl_list(3, ECL_SYM("SETQ",754), ECL_CONS_CAR(CLV1), VV[58]);
   T1 = cl_list(2, ECL_SYM("GO",416), v3tag);
   T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[57], T0, T1);
   T3 = cl_list(2, ECL_SYM("FUNCTION",398), T2);
   value0 = cl_listX(3, v2name, T3, v4keys);
   return value0;
  }
 }
 }
}
/* closure LAMBDA245                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2330__lambda245(cl_narg narg, cl_object v1datum, ...)
{
 cl_object T0, T1, T2, T3;
 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;                                     /*  TEMP-VAR                */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[59]);
 {
L1:;
  {
   cl_object v2tag;
   cl_object v3bvl;
   cl_object v4body;
   v2tag = ecl_cadr(v1datum);
   v3bvl = ecl_cadddr(v1datum);
   T0 = ecl_cddddr(v1datum);
   v4body = ecl_car(T0);
   T0 = cl_listX(3, ECL_SYM("LAMBDA",454), v3bvl, v4body);
   T1 = cl_list(2, ECL_SYM("FUNCTION",398), T0);
   T2 = cl_list(3, ECL_SYM("APPLY",91), T1, ECL_CONS_CAR(CLV1));
   T3 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), T2);
   value0 = cl_list(2, v2tag, T3);
   return value0;
  }
 }
 }
}
/* local function CALL-NEXT-METHOD                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2334call_next_method(cl_narg narg, volatile cl_object *lex0, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
  cl_object v1clos__args;
  ecl_va_list args; ecl_va_start(args,lex0,narg,0);
  v1clos__args = cl_grab_rest_args(args);
  ecl_va_end(args);
  if (lex0[1]!=ECL_NIL) {
   goto L1;
  }
  cl_error(1, VV[65]);
L1:;
  T0 = ecl_car(lex0[1]);
  value0 = v1clos__args;
  if (value0!=ECL_NIL) {
   goto L5;
  }
  T1 = lex0[0];
  goto L3;
L5:;
  T1 = value0;
  goto L3;
L3:;
  T2 = ecl_cdr(lex0[1]);
  value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, T2);
  return value0;
 }
}
/* local function LAMBDA336                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2339__lambda336(cl_object v1x)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_LISTP(v1x))){
  goto L3;
 }
 {
  cl_fixnum v2;
  v2 = ecl_length(v1x);
  value0 = ecl_make_bool((v2)==((cl_fixnum)(2)));
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2339__lambda336_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[74]);
 {
  return LC2339__lambda336(v2x);
 }
}
/* local function LAMBDA343                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2340__lambda343(cl_object v1x)
{
 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_car(v1x);
 T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
 T2 = ecl_cadr(v1x);
 value0 = cl_list(3, ECL_SYM("CONS",253), T1, T2);
 return value0;
}
static cl_object LC2340__lambda343_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[76]);
 {
  return LC2340__lambda343(v2x);
 }
}
/* closure LAMBDA360                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2344__lambda360(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));
 }
 }
}
/* local function LAMBDA362                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2345__lambda362(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[89]);
 return value0;
}
static cl_object LC2345__lambda362_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[88]);
 {
  return LC2345__lambda362(v2stream);
 }
}
/* closure LAMBDA372                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2347__lambda372(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));
 }
 }
}
/* local function LAMBDA374                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2348__lambda374(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_write_string(2, VV[95], v1stream);
 return value0;
}
static cl_object LC2348__lambda374_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[94]);
 {
  return LC2348__lambda374(v2stream);
 }
}
/* local function LAMBDA381                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2352__lambda381(cl_object v1condition, cl_object v2stream)
{
 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 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1condition) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
 T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1condition) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
 value0 = cl_format(4, v2stream, VV[102], T0, T1);
 return value0;
}
static cl_object LC2352__lambda381_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[101]);
 {
  return LC2352__lambda381(v3condition, v4stream);
 }
}
/* local function LAMBDA385                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2354__lambda385(cl_object v1condition, cl_object v2stream)
{
 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 v3type;
  cl_object v4size;
  v3type = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("STACK-OVERFLOW-TYPE",1745)))->cfun.entry(1, v1condition) /*  STACK-OVERFLOW-TYPE */;
  v4size = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("STACK-OVERFLOW-SIZE",1744)))->cfun.entry(1, v1condition) /*  STACK-OVERFLOW-SIZE */;
  if (Null(v4size)){
   goto L4;
  }
  value0 = cl_format(4, v2stream, VV[106], v3type, v4size);
  return value0;
L4:;
  value0 = cl_format(3, v2stream, VV[107], v3type);
  return value0;
 }
}
static cl_object LC2354__lambda385_va(cl_narg narg, cl_object v5condition, cl_object v6stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[105]);
 {
  return LC2354__lambda385(v5condition, v6stream);
 }
}
/* local function LAMBDA389                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2356__lambda389(cl_object v1condition, cl_object v2stream)
{
 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_slot_value(v1condition, VV[111]);
 value0 = cl_format(3, v2stream, VV[110], T0);
 return value0;
}
static cl_object LC2356__lambda389_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[109]);
 {
  return LC2356__lambda389(v3condition, v4stream);
 }
}
/* local function LAMBDA393                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2358__lambda393(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("UNIX-SIGNAL-RECEIVED-CODE",1913)))->cfun.entry(1, v1condition) /*  UNIX-SIGNAL-RECEIVED-CODE */;
 value0 = cl_format(3, v2stream, VV[114], T0);
 return value0;
}
static cl_object LC2358__lambda393_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[113]);
 {
  return LC2358__lambda393(v3condition, v4stream);
 }
}
/* local function LAMBDA399                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2362__lambda399(cl_object v1condition, cl_object v2stream)
{
 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 = (cl_env_copy->function=(ECL_SYM("TYPE-ERROR-DATUM",874)->symbol.gfdef))->cfun.entry(1, v1condition) /*  TYPE-ERROR-DATUM */;
 T1 = (cl_env_copy->function=(ECL_SYM("TYPE-ERROR-EXPECTED-TYPE",875)->symbol.gfdef))->cfun.entry(1, v1condition) /*  TYPE-ERROR-EXPECTED-TYPE */;
 value0 = cl_format(4, v2stream, VV[117], T0, T1);
 return value0;
}
static cl_object LC2362__lambda399_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[116]);
 {
  return LC2362__lambda399(v3condition, v4stream);
 }
}
/* local function LAMBDA403                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2364__lambda403(cl_object v1condition, cl_object v2stream)
{
 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_env_copy->function=(ECL_SYM("TYPE-ERROR-DATUM",874)->symbol.gfdef))->cfun.entry(1, v1condition) /*  TYPE-ERROR-DATUM */;
 T1 = (cl_env_copy->function=(VV[122]->symbol.gfdef))->cfun.entry(1, v1condition) /*  CASE-FAILURE-NAME */;
 T2 = (cl_env_copy->function=(VV[123]->symbol.gfdef))->cfun.entry(1, v1condition) /*  CASE-FAILURE-POSSIBILITIES */;
 value0 = cl_format(5, v2stream, VV[121], T0, T1, T2);
 return value0;
}
static cl_object LC2364__lambda403_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[120]);
 {
  return LC2364__lambda403(v3condition, v4stream);
 }
}
/* local function LAMBDA408                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2367__lambda408(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(ECL_SYM("STREAM-ERROR-STREAM",805)->symbol.gfdef))->cfun.entry(1, v1condition) /*  STREAM-ERROR-STREAM */;
 value0 = cl_format(3, v2stream, VV[126], T0);
 return value0;
}
static cl_object LC2367__lambda408_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[125]);
 {
  return LC2367__lambda408(v3condition, v4stream);
 }
}
/* local function LAMBDA413                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2370__lambda413(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(ECL_SYM("FILE-ERROR-PATHNAME",356)->symbol.gfdef))->cfun.entry(1, v1condition) /*  FILE-ERROR-PATHNAME */;
 value0 = cl_format(3, v2stream, VV[129], T0);
 return value0;
}
static cl_object LC2370__lambda413_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[128]);
 {
  return LC2370__lambda413(v3condition, v4stream);
 }
}
/* local function LAMBDA419                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2374__lambda419(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(ECL_SYM("CELL-ERROR-NAME",203)->symbol.gfdef))->cfun.entry(1, v1condition) /*  CELL-ERROR-NAME */;
 value0 = cl_format(3, v2stream, VV[132], T0);
 return value0;
}
static cl_object LC2374__lambda419_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[131]);
 {
  return LC2374__lambda419(v3condition, v4stream);
 }
}
/* local function LAMBDA424                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2377__lambda424(cl_object v1condition, cl_object v2stream)
{
 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 = (cl_env_copy->function=(ECL_SYM("CELL-ERROR-NAME",203)->symbol.gfdef))->cfun.entry(1, v1condition) /*  CELL-ERROR-NAME */;
 T1 = (cl_env_copy->function=(ECL_SYM("UNBOUND-SLOT-INSTANCE",880)->symbol.gfdef))->cfun.entry(1, v1condition) /*  UNBOUND-SLOT-INSTANCE */;
 value0 = cl_format(4, v2stream, VV[135], T0, T1);
 return value0;
}
static cl_object LC2377__lambda424_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[134]);
 {
  return LC2377__lambda424(v3condition, v4stream);
 }
}
/* local function LAMBDA428                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2379__lambda428(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(ECL_SYM("CELL-ERROR-NAME",203)->symbol.gfdef))->cfun.entry(1, v1condition) /*  CELL-ERROR-NAME */;
 value0 = cl_format(3, v2stream, VV[138], T0);
 return value0;
}
static cl_object LC2379__lambda428_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[137]);
 {
  return LC2379__lambda428(v3condition, v4stream);
 }
}
/* local function LAMBDA435                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2384__lambda435(cl_object v1condition, cl_object v2stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(ECL_SYM("PRINT-NOT-READABLE-OBJECT",667)->symbol.gfdef))->cfun.entry(1, v1condition) /*  PRINT-NOT-READABLE-OBJECT */;
 value0 = cl_format(3, v2stream, VV[142], T0);
 return value0;
}
static cl_object LC2384__lambda435_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[141]);
 {
  return LC2384__lambda435(v3condition, v4stream);
 }
}
/* local function LAMBDA439                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2386__lambda439(cl_object v1condition, cl_object v2stream)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=(VV[146]->symbol.gfdef))->cfun.entry(1, v1condition) /*  FORMAT-ERROR-PRINT-BANNER */;
 T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1condition) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
 T2 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1condition) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
 T3 = (cl_env_copy->function=(VV[147]->symbol.gfdef))->cfun.entry(1, v1condition) /*  FORMAT-ERROR-CONTROL-STRING */;
 T4 = (cl_env_copy->function=(VV[148]->symbol.gfdef))->cfun.entry(1, v1condition) /*  FORMAT-ERROR-OFFSET */;
 value0 = cl_format(7, v2stream, VV[145], T0, T1, T2, T3, T4);
 return value0;
}
static cl_object LC2386__lambda439_va(cl_narg narg, cl_object v3condition, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[144]);
 {
  return LC2386__lambda439(v3condition, v4stream);
 }
}
/* local function LAMBDA469                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2390__lambda469(cl_object v1case)
{
 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_gensym(0);
 value0 = CONS(T0,v1case);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2390__lambda469_va(cl_narg narg, cl_object v2case, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[158]);
 {
  return LC2390__lambda469(v2case);
 }
}
/* closure LAMBDA478                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2391__lambda478(cl_narg narg, cl_object v1annotated_case, ...)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 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;                                     /*  VAR                     */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[159]);
 {
L1:;
  T0 = ecl_cadr(v1annotated_case);
  if (Null(ecl_caddr(v1annotated_case))){
   goto L3;
  }
  T2 = cl_list(3, ECL_SYM("SETQ",754), ECL_CONS_CAR(CLV1), VV[58]);
  T1 = ecl_list1(T2);
  goto L2;
L3:;
  T1 = ECL_NIL;
L2:;
  T2 = ecl_car(v1annotated_case);
  T3 = cl_list(2, ECL_SYM("GO",416), T2);
  T4 = ecl_list1(T3);
  T5 = ecl_append(T1,T4);
  T6 = cl_listX(4, ECL_SYM("LAMBDA",454), VV[160], VV[161], T5);
  T7 = cl_list(2, ECL_SYM("FUNCTION",398), T6);
  value0 = cl_list(2, T0, T7);
  return value0;
 }
 }
}
/* closure LAMBDA487                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2392__lambda487(cl_narg narg, cl_object v1annotated_case, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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;                                     /*  VAR                     */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[162]);
 {
L1:;
  T0 = ecl_car(v1annotated_case);
  {
   cl_object v2body;
   v2body = ecl_cdddr(v1annotated_case);
   if (Null(ecl_caddr(v1annotated_case))){
    goto L5;
   }
   T3 = ecl_caaddr(v1annotated_case);
   T4 = cl_list(2, T3, ECL_CONS_CAR(CLV1));
   T5 = ecl_list1(T4);
   T2 = cl_listX(3, ECL_SYM("LET",479), T5, v2body);
   goto L4;
L5:;
   T2 = CONS(ECL_SYM("LOCALLY",492),v2body);
L4:;
   T1 = cl_list(3, ECL_SYM("RETURN-FROM",728), ECL_CONS_CAR(CLV0), T2);
  }
  value0 = cl_list(2, T0, T1);
  return value0;
 }
 }
}
/* local function READ-IT                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2396read_it()
{
 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_read(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
 value0 = cl_eval(T0);
 return value0;
}
static cl_object LC2396read_it_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[172]);
 {
  return LC2396read_it();
 }
}
/* closure LAMBDA514                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2398__lambda514(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 LAMBDA516                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2399__lambda516(cl_narg narg, cl_object v1stream, ...)
{
 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;
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);                           /*  PLACE-NAMES             */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[177]);
 {
L1:;
  value0 = L2395assert_report(ECL_CONS_CAR(CLV0), v1stream);
  return value0;
 }
 }
}
/* closure LAMBDA532                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2400__lambda532(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 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(CLV2) = v1temp;
  cl_go(ECL_CONS_CAR(CLV3),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA534                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2401__lambda534(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[181]);
 return value0;
}
static cl_object LC2401__lambda534_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[180]);
 {
  return LC2401__lambda534(v2stream);
 }
}
/* closure LAMBDA541                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2402__lambda541(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 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(CLV2) = v1temp;
  cl_go(ECL_CONS_CAR(CLV3),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA543                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2403__lambda543(cl_narg narg, cl_object v1stream, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV3 = env0;
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);                           /*  ARGS                    */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[184]);
 {
L1:;
  T0 = cl_format(4, ECL_NIL, VV[102], ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1));
  value0 = cl_format(3, v1stream, VV[185], T0);
  return value0;
 }
 }
}
/* closure LAMBDA550                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2404__lambda550(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 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(CLV2) = v1temp;
  cl_go(ECL_CONS_CAR(CLV3),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA552                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2405__lambda552(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[190]);
 return value0;
}
static cl_object LC2405__lambda552_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[189]);
 {
  return LC2405__lambda552(v2stream);
 }
}
/* closure LAMBDA558                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2406__lambda558(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV5 = env0;                                     /*  TAGBODY                 */
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object 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(CLV4) = v1temp;
  cl_go(ECL_CONS_CAR(CLV5),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA560                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2407__lambda560(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[181]);
 return value0;
}
static cl_object LC2407__lambda560_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[193]);
 {
  return LC2407__lambda560(v2stream);
 }
}
/* closure LAMBDA566                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2408__lambda566(cl_narg narg, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7;
 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 ... */
 CLV7 = env0;                                     /*  TAGBODY                 */
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object 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(CLV6) = v1temp;
  cl_go(ECL_CONS_CAR(CLV7),ecl_make_fixnum(0));
 }
 }
}
/* closure LAMBDA568                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2409__lambda568(cl_narg narg, cl_object v1stream, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4, CLV5, CLV6, CLV7;
 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 ... */
 CLV7 = env0;
 CLV6 = _ecl_cdr(CLV7);
 CLV5 = _ecl_cdr(CLV6);
 CLV4 = _ecl_cdr(CLV5);
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);                           /*  CONTINUE-STRING         */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[196]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[197], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA69                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2321__lambda69(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;                                     /*  CODE                    */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1args = cl_grab_rest_args(args);
  ecl_va_end(args);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v1args;
  cl_env_copy->values[0] = ECL_CONS_CAR(CLV1);
  cl_throw(ECL_CONS_CAR(CLV0));
 }
 }
}
/* closure LAMBDA78                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2323__lambda78(cl_narg narg, cl_object v1c, ...)
{
 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;                                     /*  CODE                    */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[35]);
 {
L1:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v1c;
  cl_env_copy->values[0] = ECL_CONS_CAR(CLV1);
  cl_throw(ECL_CONS_CAR(CLV0));
 }
 }
}
#include "clos/conditions.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclGuCK9TZIbNLp9_mT60M881(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:CLOS;CONDITIONS.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclGuCK9TZIbNLp9_mT60M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1, T2, T3, T4, T5, T6;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defmacro(VV[201]);                      /*  UNIQUE-ID               */
  si_Xmake_special(ECL_SYM("*RESTART-CLUSTERS*",5));
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T0);
  si_Xmake_special(VV[4]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[4],T0);
  (void)0; /* No entry created for COMPUTE-RESTARTS */
  ecl_cmp_defun(VV[202]);                         /*  RESTART-PRINT           */
  si_define_structure(ECL_SYM("RESTART",723), _ecl_static_0, ECL_NIL, ECL_NIL, VVtemp[1], VVtemp[2], VV[11], ECL_NIL, VV[6], ECL_NIL, VVtemp[3], ecl_make_int8_t(5), ECL_NIL, ECL_NIL, VV[12]);
  VV[14]=cl_find_class(1, ECL_SYM("RESTART",723));
  ecl_cmp_defun(VV[203]);                         /*  MAKE-RESTART            */
  {
   cl_object v1package;
   v1package = cl_symbol_package(VV[5]);
   if (Null(v1package)){
    goto L29;
   }
   if (Null(si_package_locked_p(v1package))){
    goto L29;
   }
   if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L29;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[4], VVtemp[5], VVtemp[6], ECL_SYM("PACKAGE",1321), v1package);
  }
L29:;
  {
   cl_object volatile v2;
   v2 = ecl_make_cfun_va((cl_objectfn)LC2315__lambda42_va,ECL_NIL,Cblock,2);
   T0 = v2;
  }
  si_put_sysprop(VV[5], VV[16], T0);
  {
   cl_object v2package;
   v2package = cl_symbol_package(VV[18]);
   if (Null(v2package)){
    goto L37;
   }
   if (Null(si_package_locked_p(v2package))){
    goto L37;
   }
   if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L37;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[4], VVtemp[5], VVtemp[7], ECL_SYM("PACKAGE",1321), v2package);
  }
L37:;
  {
   cl_object volatile v3;
   v3 = ecl_make_cfun_va((cl_objectfn)LC2316__lambda47_va,ECL_NIL,Cblock,2);
   T0 = v3;
  }
  si_put_sysprop(VV[18], VV[16], T0);
  {
   cl_object v3package;
   v3package = cl_symbol_package(VV[20]);
   if (Null(v3package)){
    goto L45;
   }
   if (Null(si_package_locked_p(v3package))){
    goto L45;
   }
   if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L45;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[4], VVtemp[5], VVtemp[8], ECL_SYM("PACKAGE",1321), v3package);
  }
L45:;
  {
   cl_object volatile v4;
   v4 = ecl_make_cfun_va((cl_objectfn)LC2317__lambda52_va,ECL_NIL,Cblock,2);
   T0 = v4;
  }
  si_put_sysprop(VV[20], VV[16], T0);
  {
   cl_object v4package;
   v4package = cl_symbol_package(VV[22]);
   if (Null(v4package)){
    goto L53;
   }
   if (Null(si_package_locked_p(v4package))){
    goto L53;
   }
   if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L53;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[4], VVtemp[5], VVtemp[9], ECL_SYM("PACKAGE",1321), v4package);
  }
L53:;
  {
   cl_object volatile v5;
   v5 = ecl_make_cfun_va((cl_objectfn)LC2318__lambda57_va,ECL_NIL,Cblock,2);
   T0 = v5;
  }
  si_put_sysprop(VV[22], VV[16], T0);
  {
   cl_object v5package;
   v5package = cl_symbol_package(ECL_SYM("RESTART-NAME",726));
   if (Null(v5package)){
    goto L61;
   }
   if (Null(si_package_locked_p(v5package))){
    goto L61;
   }
   if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L61;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[4], VVtemp[5], VVtemp[10], ECL_SYM("PACKAGE",1321), v5package);
  }
L61:;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2319__lambda62_va,ECL_NIL,Cblock,2);
   T0 = v6;
  }
  si_put_sysprop(ECL_SYM("RESTART-NAME",726), VV[16], T0);
  (void)0; /* No entry created for RESTART-REPORT */
  (void)0; /* No entry created for BIND-SIMPLE-RESTARTS */
  (void)0; /* No entry created for BIND-SIMPLE-HANDLERS */
  ecl_cmp_defmacro(VV[204]);                      /*  RESTART-BIND            */
  (void)0; /* No entry created for FIND-RESTART */
  (void)0; /* No entry created for FIND-RESTART-NEVER-FAIL */
  (void)0; /* No entry created for INVOKE-RESTART */
  (void)0; /* No entry created for INVOKE-RESTART-INTERACTIVELY */
  ecl_cmp_defmacro(VV[205]);                      /*  RESTART-CASE            */
  ecl_cmp_defmacro(VV[206]);                      /*  WITH-SIMPLE-RESTART     */
  ecl_cmp_defmacro(VV[207]);                      /*  WITH-CONDITION-RESTARTS */
  clos_load_defclass(ECL_SYM("CONDITION",250), ECL_NIL, VVtemp[11], ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2336print_object_va,ECL_NIL,Cblock,2);
   T0 = v6;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[12], VVtemp[13], T0);
  ecl_cmp_defmacro(VV[208]);                      /*  DEFINE-CONDITION        */
  (void)0; /* No entry created for FIND-SUBCLASSES-OF-TYPE */
  (void)0; /* No entry created for MAKE-CONDITION */
  si_Xmake_special(ECL_SYM("*HANDLER-CLUSTERS*",6));
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T0);
  ecl_cmp_defmacro(VV[209]);                      /*  HANDLER-BIND            */
  ecl_cmp_defun(VV[210]);                         /*  SIGNAL                  */
  ecl_cmp_defun(VV[211]);                         /*  COERCE-TO-CONDITION     */
  ecl_cmp_defun(VV[212]);                         /*  BREAK                   */
  ecl_cmp_defun(VV[213]);                         /*  WARN                    */
  clos_load_defclass(ECL_SYM("WARNING",908), VV[70], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("SERIOUS-CONDITION",745), VV[70], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("ERROR",339), VVtemp[14], ECL_NIL, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2350simple_condition_format_control_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771), T1);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2351simple_condition_format_arguments_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772), T1);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2353__lambda379_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[17]);
  T2 = cl_list(3, T1, VVtemp[18], VVtemp[19]);
  clos_load_defclass(ECL_SYM("SIMPLE-CONDITION",770), VV[70], T2, ECL_NIL);
  clos_load_defclass(ECL_SYM("SIMPLE-WARNING",779), VVtemp[20], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("STYLE-WARNING",830), VVtemp[21], ECL_NIL, ECL_NIL);
  clos_load_defclass(VV[103], VVtemp[22], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("SIMPLE-ERROR",773), VVtemp[23], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("STORAGE-CONDITION",800), VVtemp[14], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("SEGMENTATION-VIOLATION",1754), VVtemp[24], VVtemp[25], ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2355__lambda383_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[26]);
  T2 = cl_list(3, T1, VVtemp[27], VVtemp[28]);
  clos_load_defclass(ECL_SYM("STACK-OVERFLOW",1743), VVtemp[24], T2, ECL_NIL);
  clos_load_defclass(ECL_SYM("STORAGE-EXHAUSTED",1742), VVtemp[24], VVtemp[29], ECL_NIL);
  clos_load_defclass(ECL_SYM("ILLEGAL-INSTRUCTION",1751), VVtemp[14], VVtemp[30], ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2357__lambda387_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[31]);
  T2 = cl_list(2, T1, VVtemp[32]);
  T3 = cl_list(2, ECL_SYM("DOCUMENTATION",1253), VVtemp[33]);
  clos_load_defclass(ECL_SYM("TIMEOUT",1438), VVtemp[14], T2, T3);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2359__lambda391_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[34]);
  T2 = cl_list(2, T1, VVtemp[35]);
  clos_load_defclass(ECL_SYM("UNIX-SIGNAL-RECEIVED",1912), VV[70], T2, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("TYPE-ERROR-DATUM",874), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2360type_error_datum_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("TYPE-ERROR-DATUM",874), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("TYPE-ERROR-DATUM",874), T1);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("TYPE-ERROR-EXPECTED-TYPE",875), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2361type_error_expected_type_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("TYPE-ERROR-EXPECTED-TYPE",875), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("TYPE-ERROR-EXPECTED-TYPE",875), T1);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2363__lambda397_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[37]);
  T2 = cl_list(3, T1, VVtemp[38], VVtemp[39]);
  clos_load_defclass(ECL_SYM("TYPE-ERROR",873), VVtemp[36], T2, ECL_NIL);
  clos_load_defclass(ECL_SYM("SIMPLE-TYPE-ERROR",776), VVtemp[40], ECL_NIL, ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2365__lambda401_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[42]);
  T2 = cl_list(3, T1, VVtemp[43], VVtemp[44]);
  clos_load_defclass(VV[118], VVtemp[41], T2, ECL_NIL);
  clos_load_defclass(ECL_SYM("PROGRAM-ERROR",675), VVtemp[36], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("CONTROL-ERROR",257), VVtemp[36], ECL_NIL, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("STREAM-ERROR-STREAM",805), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2366stream_error_stream_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("STREAM-ERROR-STREAM",805), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("STREAM-ERROR-STREAM",805), T1);
  clos_load_defclass(ECL_SYM("STREAM-ERROR",804), VVtemp[36], VVtemp[45], ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2368__lambda406_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[47]);
  T2 = ecl_list1(T1);
  clos_load_defclass(ECL_SYM("END-OF-FILE",331), VVtemp[46], T2, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("FILE-ERROR-PATHNAME",356), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2369file_error_pathname_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("FILE-ERROR-PATHNAME",356), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("FILE-ERROR-PATHNAME",356), T1);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2371__lambda411_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[48]);
  T2 = cl_list(2, T1, VVtemp[49]);
  clos_load_defclass(ECL_SYM("FILE-ERROR",355), VVtemp[36], T2, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("PACKAGE-ERROR-PACKAGE",621), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2372package_error_package_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("PACKAGE-ERROR-PACKAGE",621), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("PACKAGE-ERROR-PACKAGE",621), T1);
  clos_load_defclass(ECL_SYM("PACKAGE-ERROR",620), VVtemp[36], VVtemp[50], ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("CELL-ERROR-NAME",203), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2373cell_error_name_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("CELL-ERROR-NAME",203), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("CELL-ERROR-NAME",203), T1);
  clos_load_defclass(ECL_SYM("CELL-ERROR",202), VVtemp[36], VVtemp[51], ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2375__lambda417_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[53]);
  T2 = ecl_list1(T1);
  clos_load_defclass(ECL_SYM("UNBOUND-VARIABLE",881), VVtemp[52], T2, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("UNBOUND-SLOT-INSTANCE",880), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2376unbound_slot_instance_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("UNBOUND-SLOT-INSTANCE",880), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("UNBOUND-SLOT-INSTANCE",880), T1);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2378__lambda422_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[54]);
  T2 = cl_list(2, T1, VVtemp[55]);
  clos_load_defclass(ECL_SYM("UNBOUND-SLOT",879), VVtemp[52], T2, ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2380__lambda426_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[56]);
  T2 = ecl_list1(T1);
  clos_load_defclass(ECL_SYM("UNDEFINED-FUNCTION",882), VVtemp[52], T2, ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("ARITHMETIC-ERROR-OPERATION",97), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2381arithmetic_error_operation_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("ARITHMETIC-ERROR-OPERATION",97), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("ARITHMETIC-ERROR-OPERATION",97), T1);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("ARITHMETIC-ERROR-OPERANDS",96), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2382arithmetic_error_operands_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("ARITHMETIC-ERROR-OPERANDS",96), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("ARITHMETIC-ERROR-OPERANDS",96), T1);
  clos_load_defclass(ECL_SYM("ARITHMETIC-ERROR",95), VVtemp[36], VVtemp[57], ECL_NIL);
  clos_load_defclass(ECL_SYM("DIVISION-BY-ZERO",308), VVtemp[58], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("FLOATING-POINT-OVERFLOW",383), VVtemp[58], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("FLOATING-POINT-UNDERFLOW",384), VVtemp[58], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("FLOATING-POINT-INEXACT",381), VVtemp[58], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("FLOATING-POINT-INVALID-OPERATION",382), VVtemp[58], ECL_NIL, ECL_NIL);
  clos_load_defclass(VV[139], VVtemp[59], VVtemp[60], ECL_NIL);
  (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",946)->symbol.gfdef))->cfun.entry(5, ECL_SYM("PRINT-NOT-READABLE-OBJECT",667), VV[98], ECL_T, ECL_SYM("LAMBDA-LIST",1002), VVtemp[15]) /*  ENSURE-GENERIC-FUNCTION */;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2383print_not_readable_object_va,ECL_NIL,Cblock,1);
   T0 = v6;
  }
  T1 = clos_install_method(5, ECL_SYM("PRINT-NOT-READABLE-OBJECT",667), ECL_NIL, VVtemp[16], VVtemp[15], T0);
  clos_associate_methods_to_gfun(2, ECL_SYM("PRINT-NOT-READABLE-OBJECT",667), T1);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2385__lambda433_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[61]);
  T2 = cl_list(2, T1, VVtemp[62]);
  clos_load_defclass(ECL_SYM("PRINT-NOT-READABLE",666), VVtemp[36], T2, ECL_NIL);
  clos_load_defclass(ECL_SYM("PARSE-ERROR",629), VVtemp[36], ECL_NIL, ECL_NIL);
  clos_load_defclass(ECL_SYM("READER-ERROR",702), VVtemp[63], ECL_NIL, ECL_NIL);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2387__lambda437_va,ECL_NIL,Cblock,0);
   T0 = v6;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[65]);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2388__lambda441_va,ECL_NIL,Cblock,0);
   T2 = v6;
  }
  T3 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T2, VVtemp[68]);
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC2389__lambda443_va,ECL_NIL,Cblock,0);
   T4 = v6;
  }
  T5 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T4, VVtemp[69]);
  T6 = cl_list(6, T1, VVtemp[66], VVtemp[67], T3, T5, VVtemp[70]);
  clos_load_defclass(ECL_SYM("FORMAT-ERROR",1084), VVtemp[64], T6, ECL_NIL);
  clos_load_defclass(ECL_SYM("INTERACTIVE-INTERRUPT",1741), VVtemp[14], VVtemp[71], ECL_NIL);
  (void)0; /* No entry created for SIGNAL-SIMPLE-ERROR */
  ecl_cmp_defmacro(VV[214]);                      /*  HANDLER-CASE            */
  ecl_cmp_defmacro(VV[215]);                      /*  IGNORE-ERRORS           */
  (void)0; /* No entry created for ABORT */
  (void)0; /* No entry created for CONTINUE */
  (void)0; /* No entry created for MUFFLE-WARNING */
  (void)0; /* No entry created for STORE-VALUE */
  (void)0; /* No entry created for USE-VALUE */
  (void)0; /* No entry created for ASSERT-REPORT */
  (void)0; /* No entry created for ASSERT-PROMPT */
  (void)0; /* No entry created for ASSERT-FAILURE */
  ecl_cmp_defun(VV[216]);                         /*  UNIVERSAL-ERROR-HANDLER */
  ecl_cmp_defun(VV[217]);                         /*  TPL-CONTINUE-COMMAND    */
 }
}
