/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/assert.lsp                      */
#include <ecl/ecl-cmp.h>
#include "lsp/assert.eclh"
/* function definition for READ-EVALUATED-FORM                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L280read_evaluated_form()
{
 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_format(2, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), VV[1]);
 T0 = cl_read(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
 T1 = cl_eval(T0);
 value0 = ecl_list1(T1);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L280read_evaluated_form_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[0]);
 {
  return L280read_evaluated_form();
 }
}
/* function definition for WRONG-TYPE-ARGUMENT                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_wrong_type_argument(volatile cl_narg narg, cl_object volatile v1object, cl_object volatile v2type, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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<2)) FEwrong_num_arguments(ECL_SYM("WRONG-TYPE-ARGUMENT",1682));
 if (ecl_unlikely(narg>4)) FEwrong_num_arguments(ECL_SYM("WRONG-TYPE-ARGUMENT",1682));
 {
  cl_object volatile v3place;
  cl_object volatile v4function;
  va_list args; va_start(args,v2type);
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(v2type,env0);                /*  TYPE                    */
  {
   int i = 2;
   if (i >= narg) {
    v3place = ECL_NIL;
   } else {
    i++;
    v3place = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v4function = ECL_NIL;
   } else {
    i++;
    v4function = va_arg(args,cl_object);
   }
  }
  va_end(args);
L4:;
  {
   volatile cl_object env1 = env0;
   CLV1 = env1 = CONS(ECL_NIL,env1);
   {
    volatile cl_object env2 = env1;
    CLV2 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  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 L6;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC281__lambda6,env2,Cblock,0);
      T0 = v5;
     }
     T1 = (VV[0]->symbol.gfdef);
     {
      cl_object v5;
      v5 = ecl_make_cclosure_va((cl_objectfn)LC282__lambda8,env2,Cblock,1);
      T2 = v5;
     }
     T3 = (cl_env_copy->function=(VV[4]->symbol.gfdef))->cfun.entry(8, ECL_SYM("NAME",1309), ECL_SYM("USE-VALUE",897), ECL_SYM("FUNCTION",1273), T0, VV[6], T1, VV[7], T2) /*  MAKE-RESTART */;
     T4 = ecl_list1(T3);
     T5 = CONS(T4,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
     ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T5); /*  *RESTART-CLUSTERS* */
     {
      cl_object v5;
      T0 = cl_list(4, v4function, v3place, v1object, ECL_CONS_CAR(CLV0));
      T1 = cl_list(8, ECL_SYM("FORMAT-CONTROL",1272), VV[11], ECL_SYM("FORMAT-ARGUMENTS",1271), T0, ECL_SYM("DATUM",1245), v1object, ECL_SYM("EXPECTED-TYPE",1263), ECL_CONS_CAR(CLV0));
      v5 = (cl_env_copy->function=(VV[10]->symbol.gfdef))->cfun.entry(4, ECL_SYM("SIMPLE-TYPE-ERROR",776), T1, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339)) /*  COERCE-TO-CONDITION */;
      T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
      T1 = CONS(v5,T0);
      T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[12]));
      ecl_bds_bind(cl_env_copy,VV[12],T2);        /*  *CONDITION-RESTARTS*    */
      cl_error(1, v5);
      ecl_frs_pop_n(cl_env_copy, 1);
      ecl_bds_unwind1(cl_env_copy);
      ecl_bds_unwind1(cl_env_copy);
      goto L5;
     }
L6:;
     {
      cl_object v5;
      cl_object v6value;
      v5 = ECL_CONS_CAR(CLV1);
      if (Null(v5)){
       goto L15;
      }
      {
       cl_object v7;
       v7 = v5;
       {
        cl_object v8;
        v8 = v7;
        {
         bool v9;
         v9 = ECL_LISTP(v8);
         if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[15],v8);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
        }
       }
       if (Null(v7)){
        goto L21;
       }
       {
        cl_object v8;
        v8 = ECL_CONS_CDR(v7);
        v5 = v8;
        v7 = ECL_CONS_CAR(v7);
       }
L21:;
       v6value = v7;
       goto L14;
      }
L15:;
      v6value = si_dm_too_few_arguments(ECL_NIL);
L14:;
      if (Null(v5)){
       goto L27;
      }
      si_dm_too_many_arguments(ECL_NIL);
L27:;
      v1object = v6value;
      if (cl_typep(2, v1object, ECL_CONS_CAR(CLV0))!=ECL_NIL) {
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L5;
      }
      ecl_frs_pop_n(cl_env_copy, 1);
      goto L4;
     }
     }
    }
   }
  }
L5:;
  value0 = v1object;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function CHECK-TYPE                                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC283check_type(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11;
 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 v4place;
  cl_object v5type;
  cl_object v6type_string;
  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);
   v4place = 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);
   v5type = v7;
  }
  if (Null(v3)){
   goto L16;
  }
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6type_string = v7;
   goto L15;
  }
L16:;
  v6type_string = ECL_NIL;
L15:;
  if (Null(v3)){
   goto L21;
  }
  si_dm_too_many_arguments(v1);
L21:;
  {
   cl_object v7aux;
   v7aux = cl_gensym(0);
   T0 = cl_list(2, v7aux, v4place);
   T1 = ecl_list1(T0);
   T2 = cl_list(2, VV[18], v7aux);
   T3 = cl_list(2, ECL_SYM("DECLARE",276), T2);
   T4 = cl_list(2, ECL_SYM("QUOTE",682), v5type);
   T5 = cl_list(3, ECL_SYM("TYPEP",878), v7aux, T4);
   T6 = cl_list(2, ECL_SYM("QUOTE",682), v5type);
   T7 = cl_list(2, ECL_SYM("QUOTE",682), v6type_string);
   T8 = cl_list(2, ECL_SYM("QUOTE",682), v4place);
   T9 = cl_list(5, ECL_SYM("DO-CHECK-TYPE",1893), v7aux, T6, T7, T8);
   T10 = cl_list(3, ECL_SYM("SETF",753), v4place, T9);
   T11 = cl_list(3, ECL_SYM("UNLESS",886), T5, T10);
   value0 = cl_list(5, ECL_SYM("LET",479), T1, T3, T11, ECL_NIL);
   return value0;
  }
 }
}
static cl_object LC283check_type_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[19]);
 {
  return LC283check_type(v8, v9);
 }
}
/* function definition for DO-CHECK-TYPE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_do_check_type(cl_object volatile v1value, cl_object volatile v2type, cl_object volatile v3type_string, cl_object volatile v4place)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v4place,env0);                /*  PLACE                   */
L2:;
 if (cl_typep(2, v1value, v2type)!=ECL_NIL) {
  goto L3;
 }
 {
  volatile cl_object env1 = env0;
  CLV1 = env1 = CONS(ECL_NIL,env1);
  {
   volatile cl_object env2 = env1;
   CLV2 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  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 v5;
     v5 = ecl_make_cclosure_va((cl_objectfn)LC284__lambda29,env2,Cblock,0);
     T0 = v5;
    }
    T1 = (VV[0]->symbol.gfdef);
    {
     cl_object v5;
     v5 = ecl_make_cclosure_va((cl_objectfn)LC285__lambda31,env2,Cblock,1);
     T2 = v5;
    }
    T3 = (cl_env_copy->function=(VV[4]->symbol.gfdef))->cfun.entry(8, ECL_SYM("NAME",1309), ECL_SYM("STORE-VALUE",801), ECL_SYM("FUNCTION",1273), T0, VV[6], T1, VV[7], T2) /*  MAKE-RESTART */;
    T4 = ecl_list1(T3);
    T5 = CONS(T4,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T5); /*  *RESTART-CLUSTERS* */
    {
     cl_object v5;
     T0 = cl_list(4, ECL_CONS_CAR(CLV0), v1value, v3type_string, v2type);
     T1 = cl_list(8, ECL_SYM("DATUM",1245), v1value, ECL_SYM("EXPECTED-TYPE",1263), v2type, ECL_SYM("FORMAT-CONTROL",1272), VV[24], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
     v5 = (cl_env_copy->function=(VV[10]->symbol.gfdef))->cfun.entry(4, ECL_SYM("SIMPLE-TYPE-ERROR",776), T1, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339)) /*  COERCE-TO-CONDITION */;
     T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
     T1 = CONS(v5,T0);
     T2 = CONS(T1,ecl_cmp_symbol_value(cl_env_copy,VV[12]));
     ecl_bds_bind(cl_env_copy,VV[12],T2);         /*  *CONDITION-RESTARTS*    */
     cl_error(1, v5);
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     ecl_bds_unwind1(cl_env_copy);
     goto L3;
    }
L5:;
    {
     cl_object v5;
     cl_object v6new_value;
     v5 = ECL_CONS_CAR(CLV1);
     if (Null(v5)){
      goto L14;
     }
     {
      cl_object v7;
      v7 = v5;
      {
       cl_object v8;
       v8 = v7;
       {
        bool v9;
        v9 = ECL_LISTP(v8);
        if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[15],v8);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
       }
      }
      if (Null(v7)){
       goto L20;
      }
      {
       cl_object v8;
       v8 = ECL_CONS_CDR(v7);
       v5 = v8;
       v7 = ECL_CONS_CAR(v7);
      }
L20:;
      v6new_value = v7;
      goto L13;
     }
L14:;
     v6new_value = si_dm_too_few_arguments(ECL_NIL);
L13:;
     if (Null(v5)){
      goto L26;
     }
     si_dm_too_many_arguments(ECL_NIL);
L26:;
     v1value = v6new_value;
     ecl_frs_pop_n(cl_env_copy, 1);
     goto L2;
    }
    }
   }
  }
 }
L3:;
 value0 = v1value;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function ASSERT                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC286assert(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 v4test_form;
  cl_object v5places;
  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);
   v4test_form = v6;
  }
  if (Null(v3)){
   goto L10;
  }
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5places = v6;
   goto L9;
  }
L10:;
  v5places = ECL_NIL;
L9:;
  {
   cl_object v6repl;
   if (Null(v5places)){
    goto L16;
   }
   T0 = CONS(ECL_SYM("VALUES",899),v5places);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4test_form);
   T2 = cl_list(2, ECL_SYM("QUOTE",682), v5places);
   T3 = CONS(ECL_SYM("LIST",483),v5places);
   T4 = cl_listX(5, ECL_SYM("ASSERT-FAILURE",1888), T1, T2, T3, v3);
   v6repl = cl_list(3, ECL_SYM("SETF",753), T0, T4);
   goto L15;
L16:;
   T0 = cl_list(2, ECL_SYM("QUOTE",682), v4test_form);
   if (Null(v3)){
    goto L20;
   }
   T1 = cl_listX(3, ECL_NIL, ECL_NIL, v3);
   goto L18;
L20:;
   T1 = ECL_NIL;
   goto L18;
L18:;
   v6repl = cl_listX(3, ECL_SYM("ASSERT-FAILURE",1888), T0, T1);
L15:;
   T0 = cl_list(2, ECL_SYM("NOT",586), v4test_form);
   value0 = cl_list(3, ECL_SYM("WHILE",1543), T0, v6repl);
   return value0;
  }
 }
}
static cl_object LC286assert_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[25]);
 {
  return LC286assert(v7, v8);
 }
}
/* function definition for ACCUMULATE-CASES                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L287accumulate_cases(cl_object v1cases, cl_object v2list_is_atom_p)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3c;
  cl_object v4l;
  v3c = v1cases;
  v4l = ECL_NIL;
  goto L6;
L5:;
  {
   cl_object v5keys;
   v5keys = ecl_caar(v3c);
   if (!(ECL_ATOM(v5keys))){
    goto L10;
   }
   if (v5keys==ECL_NIL) {
    goto L8;
   }
   v4l = CONS(v5keys,v4l);
   goto L8;
L10:;
   if (Null(v2list_is_atom_p)){
    goto L14;
   }
   v4l = CONS(v5keys,v4l);
   goto L8;
L14:;
   v4l = ecl_append(v5keys,v4l);
  }
L8:;
  v3c = ecl_cdr(v3c);
L6:;
  if (v3c==ECL_NIL) {
   goto L20;
  }
  goto L5;
L20:;
  value0 = cl_nreverse(v4l);
  return value0;
 }
}
/* function definition for ECASE-ERROR                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_ecase_error(cl_object v1value, cl_object v2values)
{
 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 = CONS(ECL_SYM("MEMBER",554),v2values);
 value0 = cl_error(9, VV[27], ECL_SYM("NAME",1309), ECL_SYM("ECASE",323), ECL_SYM("DATUM",1245), v1value, ECL_SYM("EXPECTED-TYPE",1263), T0, VV[28], v2values);
 return value0;
}
/* local function ECASE                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC288ecase(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 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 v4keyform;
  cl_object v5clauses;
  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);
   v4keyform = v6;
  }
  v5clauses = v3;
  v5clauses = L292remove_otherwise_from_clauses(v5clauses);
  {
   cl_object v6key;
   v6key = cl_gensym(0);
   T0 = cl_list(2, v6key, v4keyform);
   T1 = ecl_list1(T0);
   T2 = L287accumulate_cases(v5clauses, ECL_NIL);
   T3 = cl_list(2, ECL_SYM("QUOTE",682), T2);
   T4 = cl_list(3, ECL_SYM("ECASE-ERROR",1890), v6key, T3);
   T5 = cl_list(2, ECL_T, T4);
   T6 = ecl_list1(T5);
   T7 = ecl_append(v5clauses,T6);
   T8 = cl_listX(3, ECL_SYM("CASE",183), v6key, T7);
   value0 = cl_list(3, ECL_SYM("LET",479), T1, T8);
   return value0;
  }
 }
}
static cl_object LC288ecase_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[30]);
 {
  return LC288ecase(v7, v8);
 }
}
/* function definition for CCASE-ERROR                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_ccase_error(cl_object volatile v1keyform, cl_object volatile v2key, cl_object volatile v3values)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1keyform,env0);              /*  KEYFORM                 */
 {
  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 L1;
   }
   ecl_internal_error("GO found an inexistent tag");
   } else {
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC289__lambda67,env1,Cblock,0);
    T0 = v4;
   }
   T1 = (VV[0]->symbol.gfdef);
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC290__lambda69,env1,Cblock,1);
    T2 = v4;
   }
   T3 = (cl_env_copy->function=(VV[4]->symbol.gfdef))->cfun.entry(8, ECL_SYM("NAME",1309), ECL_SYM("STORE-VALUE",801), ECL_SYM("FUNCTION",1273), T0, VV[6], T1, VV[7], T2) /*  MAKE-RESTART */;
   T4 = ecl_list1(T3);
   T5 = CONS(T4,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
   ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T5); /*  *RESTART-CLUSTERS* */
   {
    cl_object v4;
    T0 = CONS(ECL_SYM("MEMBER",554),v3values);
    T1 = cl_list(8, ECL_SYM("NAME",1309), ECL_SYM("CCASE",185), ECL_SYM("DATUM",1245), v2key, ECL_SYM("EXPECTED-TYPE",1263), T0, VV[28], v3values);
    v4 = (cl_env_copy->function=(VV[10]->symbol.gfdef))->cfun.entry(4, VV[27], T1, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339)) /*  COERCE-TO-CONDITION */;
    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[12]));
    ecl_bds_bind(cl_env_copy,VV[12],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;
   }
L1:;
   {
    cl_object v4;
    cl_object v5value;
    v4 = ECL_CONS_CAR(CLV1);
    if (Null(v4)){
     goto L10;
    }
    {
     cl_object v6;
     v6 = v4;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[15],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L16;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v4 = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L16:;
     v5value = v6;
     goto L9;
    }
L10:;
    v5value = si_dm_too_few_arguments(ECL_NIL);
L9:;
    if (Null(v4)){
     goto L22;
    }
    si_dm_too_many_arguments(ECL_NIL);
L22:;
    value0 = v5value;
    cl_env_copy->nvalues = 1;
    ecl_frs_pop_n(cl_env_copy, 1);
    return value0;
   }
   }
  }
 }
}
/* function definition for REMOVE-OTHERWISE-FROM-CLAUSES                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L292remove_otherwise_from_clauses(cl_object v1clauses)
{
 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;
   v3 = ecl_make_cfun_va((cl_objectfn)LC291__lambda80_va,ECL_NIL,Cblock,1);
   v2 = v3;
  }
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   {
    cl_object v6;
    v6 = v1clauses;
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v6;
   }
   v4 = ECL_NIL;
   v5 = v3;
   {
    cl_object v6;
    cl_object v7;
    v6 = ecl_list1(ECL_NIL);
    v7 = v6;
L10:;
    if (!(ecl_endp(v5))){
     goto L12;
    }
    goto L11;
L12:;
    v4 = ECL_CONS_CAR(v5);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v5);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    {
     cl_object v8;
     v8 = v7;
     if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v8;
    }
    T1 = ecl_function_dispatch(cl_env_copy,v2)(1, v4);
    v7 = ecl_list1(T1);
    (ECL_CONS_CDR(T0)=v7,T0);
    goto L10;
L11:;
    value0 = ecl_cdr(v6);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* local function CCASE                                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC293ccase(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14;
 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 v4keyplace;
  cl_object v5clauses;
  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);
   v4keyplace = v6;
  }
  v5clauses = v3;
  {
   cl_object v6key;
   cl_object v7repeat;
   cl_object v8block;
   v6key = cl_gensym(0);
   v7repeat = cl_gensym(0);
   v8block = cl_gensym(0);
   v5clauses = L292remove_otherwise_from_clauses(v5clauses);
   T0 = cl_list(2, v6key, v4keyplace);
   T1 = ecl_list1(T0);
   T2 = cl_list(2, ECL_SYM("QUOTE",682), v4keyplace);
   T3 = L287accumulate_cases(v5clauses, ECL_NIL);
   T4 = cl_list(2, ECL_SYM("QUOTE",682), T3);
   T5 = cl_list(4, ECL_SYM("CCASE-ERROR",1889), T2, v6key, T4);
   T6 = cl_list(3, ECL_SYM("SETF",753), v4keyplace, T5);
   T7 = cl_list(2, ECL_SYM("GO",416), v7repeat);
   T8 = cl_list(3, ECL_T, T6, T7);
   T9 = ecl_list1(T8);
   T10 = ecl_append(v5clauses,T9);
   T11 = cl_listX(3, ECL_SYM("CASE",183), v6key, T10);
   T12 = cl_list(3, ECL_SYM("RETURN-FROM",728), v8block, T11);
   T13 = cl_list(3, ECL_SYM("LET",479), T1, T12);
   T14 = cl_list(3, ECL_SYM("TAGBODY",853), v7repeat, T13);
   value0 = cl_list(3, ECL_SYM("BLOCK",139), v8block, T14);
   return value0;
  }
 }
}
static cl_object LC293ccase_va(cl_narg narg, cl_object v9, cl_object v10, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[42]);
 {
  return LC293ccase(v9, v10);
 }
}
/* local function TYPECASE                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC294typecase(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 v4keyform;
  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);
   v4keyform = v5;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7l;
   cl_object v8form;
   v5 = cl_reverse(v3);
   v6 = cl_gensym(0);
   v7l = v5;
   v8form = ECL_NIL;
   goto L15;
L14:;
   T0 = ecl_caar(v7l);
   if ((T0)==(ECL_T)) {
    goto L20;
   }
   T0 = ecl_caar(v7l);
   if (!((T0)==(ECL_SYM("OTHERWISE",617)))){
    goto L18;
   }
   goto L19;
L20:;
L19:;
   T0 = ecl_cdar(v7l);
   v8form = CONS(ECL_SYM("PROGN",674),T0);
   goto L17;
L18:;
   T0 = ecl_caar(v7l);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   T2 = cl_list(3, ECL_SYM("TYPEP",878), v6, T1);
   T3 = ecl_cdar(v7l);
   T4 = CONS(ECL_SYM("PROGN",674),T3);
   v8form = cl_list(4, ECL_SYM("IF",950), T2, T4, v8form);
L17:;
   v7l = ecl_cdr(v7l);
L15:;
   if (ecl_endp(v7l)) {
    goto L26;
   }
   goto L14;
L26:;
   T0 = cl_list(2, v6, v4keyform);
   T1 = ecl_list1(T0);
   value0 = cl_list(3, ECL_SYM("LET",479), T1, v8form);
   return value0;
  }
 }
}
static cl_object LC294typecase_va(cl_narg narg, cl_object v9, cl_object v10, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[43]);
 {
  return LC294typecase(v9, v10);
 }
}
/* function definition for ETYPECASE-ERROR                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_etypecase_error(cl_object v1value, cl_object v2types)
{
 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 = CONS(ECL_SYM("OR",616),v2types);
 value0 = cl_error(9, VV[27], ECL_SYM("NAME",1309), ECL_SYM("ETYPECASE",340), ECL_SYM("DATUM",1245), v1value, ECL_SYM("EXPECTED-TYPE",1263), T0, VV[28], v2types);
 return value0;
}
/* local function ETYPECASE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC295etypecase(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 v4keyform;
  cl_object v5clauses;
  cl_object v6key;
  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);
   v4keyform = v7;
  }
  v5clauses = v3;
  v6key = cl_gensym(0);
  v5clauses = L292remove_otherwise_from_clauses(v5clauses);
  {
   cl_object v7;
   cl_object v8;
   cl_object v9l;
   cl_object v10form;
   v7 = cl_reverse(v5clauses);
   T0 = L287accumulate_cases(v5clauses, ECL_T);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   v8 = cl_list(3, ECL_SYM("ETYPECASE-ERROR",1891), v6key, T1);
   v9l = v7;
   v10form = v8;
   goto L19;
L18:;
   T0 = ecl_caar(v9l);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   T2 = cl_list(3, ECL_SYM("TYPEP",878), v6key, T1);
   T3 = ecl_cdar(v9l);
   T4 = CONS(ECL_SYM("PROGN",674),T3);
   v10form = cl_list(4, ECL_SYM("IF",950), T2, T4, v10form);
   v9l = ecl_cdr(v9l);
L19:;
   if (ecl_endp(v9l)) {
    goto L25;
   }
   goto L18;
L25:;
   T0 = cl_list(2, v6key, v4keyform);
   T1 = ecl_list1(T0);
   value0 = cl_list(3, ECL_SYM("LET",479), T1, v10form);
   return value0;
  }
 }
}
static cl_object LC295etypecase_va(cl_narg narg, cl_object v11, cl_object v12, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[44]);
 {
  return LC295etypecase(v11, v12);
 }
}
/* function definition for CTYPECASE-ERROR                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_ctypecase_error(cl_object volatile v1keyplace, cl_object volatile v2value, cl_object volatile v3types)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1keyplace,env0);             /*  KEYPLACE                */
 {
  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 L1;
   }
   ecl_internal_error("GO found an inexistent tag");
   } else {
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC296__lambda133,env1,Cblock,0);
    T0 = v4;
   }
   T1 = (VV[0]->symbol.gfdef);
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC297__lambda135,env1,Cblock,1);
    T2 = v4;
   }
   T3 = (cl_env_copy->function=(VV[4]->symbol.gfdef))->cfun.entry(8, ECL_SYM("NAME",1309), ECL_SYM("STORE-VALUE",801), ECL_SYM("FUNCTION",1273), T0, VV[6], T1, VV[7], T2) /*  MAKE-RESTART */;
   T4 = ecl_list1(T3);
   T5 = CONS(T4,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
   ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T5); /*  *RESTART-CLUSTERS* */
   {
    cl_object v4;
    T0 = CONS(ECL_SYM("OR",616),v3types);
    T1 = cl_list(8, ECL_SYM("NAME",1309), ECL_SYM("CTYPECASE",271), ECL_SYM("DATUM",1245), v2value, ECL_SYM("EXPECTED-TYPE",1263), T0, VV[28], v3types);
    v4 = (cl_env_copy->function=(VV[10]->symbol.gfdef))->cfun.entry(4, VV[27], T1, ECL_SYM("SIMPLE-ERROR",773), ECL_SYM("ERROR",339)) /*  COERCE-TO-CONDITION */;
    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[12]));
    ecl_bds_bind(cl_env_copy,VV[12],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;
   }
L1:;
   {
    cl_object v4;
    cl_object v5value;
    v4 = ECL_CONS_CAR(CLV1);
    if (Null(v4)){
     goto L10;
    }
    {
     cl_object v6;
     v6 = v4;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[15],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L16;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v4 = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L16:;
     v5value = v6;
     goto L9;
    }
L10:;
    v5value = si_dm_too_few_arguments(ECL_NIL);
L9:;
    if (Null(v4)){
     goto L22;
    }
    si_dm_too_many_arguments(ECL_NIL);
L22:;
    value0 = v5value;
    cl_env_copy->nvalues = 1;
    ecl_frs_pop_n(cl_env_copy, 1);
    return value0;
   }
   }
  }
 }
}
/* local function CTYPECASE                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC299ctypecase(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 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 v4keyplace;
  cl_object v5clauses;
  cl_object env1 = env0;
  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);
   v4keyplace = v6;
  }
  v5clauses = v3;
  T0 = cl_gensym(0);
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(T0,env1);                    /*  KEY                     */
  v5clauses = L292remove_otherwise_from_clauses(v5clauses);
  T0 = cl_list(2, ECL_CONS_CAR(CLV0), v4keyplace);
  T1 = ecl_list1(T0);
  {
   cl_object v6;
   {
    cl_object v7;
    v7 = ecl_make_cclosure_va((cl_objectfn)LC298__lambda153,env1,Cblock,1);
    v6 = v7;
   }
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    {
     cl_object v10;
     v10 = v5clauses;
     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;
L21:;
     if (!(ecl_endp(v9))){
      goto L23;
     }
     goto L22;
L23:;
     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;
      T3 = v12;
     }
     T4 = ecl_function_dispatch(cl_env_copy,v6)(1, v8);
     v11 = ecl_list1(T4);
     (ECL_CONS_CDR(T3)=v11,T3);
     goto L21;
L22:;
     T2 = ecl_cdr(v10);
     goto L12;
    }
   }
  }
L12:;
  T3 = cl_list(2, ECL_SYM("QUOTE",682), v4keyplace);
  T4 = L287accumulate_cases(v5clauses, ECL_T);
  T5 = cl_list(2, ECL_SYM("QUOTE",682), T4);
  T6 = cl_list(4, ECL_SYM("CTYPECASE-ERROR",1892), T3, ECL_CONS_CAR(CLV0), T5);
  T7 = cl_list(3, ECL_SYM("SETF",753), v4keyplace, T6);
  T8 = ecl_list1(T7);
  T9 = ecl_append(T2,T8);
  T10 = cl_listX(3, ECL_SYM("LET",479), T1, T9);
  value0 = cl_list(2, ECL_SYM("LOOP",514), T10);
  return value0;
 }
}
static cl_object LC299ctypecase_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[50]);
 {
  return LC299ctypecase(v6, v7);
 }
}
/* closure LAMBDA6                                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC281__lambda6(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 LAMBDA8                                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC282__lambda8(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);                           /*  TYPE                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[8]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[9], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA29                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC284__lambda29(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 LAMBDA31                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC285__lambda31(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                   */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[22]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[23], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA67                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC289__lambda67(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 LAMBDA69                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC290__lambda69(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);                           /*  KEYFORM                 */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[33]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[23], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* local function LAMBDA80                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC291__lambda80(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 v2options;
  v2options = ecl_car(v1clause);
  if (!((v2options)==(ECL_T))){
   goto L8;
  }
  goto L5;
L8:;
  goto L6;
L6:;
  if (!((v2options)==(ECL_SYM("OTHERWISE",617)))){
   goto L3;
  }
  goto L4;
L5:;
L4:;
  T0 = ecl_list1(v2options);
  T1 = ecl_cdr(v1clause);
  value0 = CONS(T0,T1);
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = v1clause;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC291__lambda80_va(cl_narg narg, cl_object v3clause, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[34]);
 {
  return LC291__lambda80(v3clause);
 }
}
/* closure LAMBDA133                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC296__lambda133(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 LAMBDA135                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC297__lambda135(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);                           /*  KEYPLACE                */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[47]);
 {
L1:;
  value0 = cl_format(3, v1stream, VV[48], ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA153                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC298__lambda153(cl_narg narg, cl_object v1l, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  KEY                     */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[49]);
 {
L1:;
  T0 = ecl_car(v1l);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
  T2 = cl_list(3, ECL_SYM("TYPEP",878), ECL_CONS_CAR(CLV0), T1);
  T3 = ecl_cdr(v1l);
  T4 = CONS(ECL_SYM("PROGN",674),T3);
  T5 = cl_list(2, ECL_SYM("RETURN",727), T4);
  value0 = cl_list(3, ECL_SYM("WHEN",909), T2, T5);
  return value0;
 }
 }
}
#include "lsp/assert.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclq5YNTE49wkdn9_MKfzL881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:LSP;ASSERT.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclq5YNTE49wkdn9_MKfzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[51]);                          /*  READ-EVALUATED-FORM     */
  (void)0; /* No entry created for WRONG-TYPE-ARGUMENT */
  ecl_cmp_defmacro(VV[52]);                       /*  CHECK-TYPE              */
  (void)0; /* No entry created for DO-CHECK-TYPE */
  ecl_cmp_defmacro(VV[53]);                       /*  ASSERT                  */
  (void)0; /* No entry created for ACCUMULATE-CASES */
  (void)0; /* No entry created for ECASE-ERROR */
  ecl_cmp_defmacro(VV[54]);                       /*  ECASE                   */
  (void)0; /* No entry created for CCASE-ERROR */
  (void)0; /* No entry created for REMOVE-OTHERWISE-FROM-CLAUSES */
  ecl_cmp_defmacro(VV[55]);                       /*  CCASE                   */
  ecl_cmp_defmacro(VV[56]);                       /*  TYPECASE                */
  (void)0; /* No entry created for ETYPECASE-ERROR */
  ecl_cmp_defmacro(VV[57]);                       /*  ETYPECASE               */
  (void)0; /* No entry created for CTYPECASE-ERROR */
  ecl_cmp_defmacro(VV[58]);                       /*  CTYPECASE               */
}
