/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/predlib.lsp                     */
#include <ecl/ecl-cmp.h>
#include "lsp/predlib.eclh"
/* function definition for CONSTANTLY-T                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L174constantly_t(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);
 {
  va_list args; va_start(args,narg);
  va_end(args);
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for CONSTANTLY-NIL                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L175constantly_nil(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);
 {
  va_list args; va_start(args,narg);
  va_end(args);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for CONSTANTLY                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_constantly(cl_object v1n)
{
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1n,env0);                    /*  N                       */
 if (!((ECL_CONS_CAR(CLV0))==(ECL_NIL))){
  goto L1;
 }
 value0 = ecl_fdefinition(VV[1]);
 cl_env_copy->nvalues = 1;
 return value0;
L1:;
 if (!((ECL_CONS_CAR(CLV0))==(ECL_T))){
  goto L4;
 }
 value0 = ecl_fdefinition(VV[0]);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 {
  cl_object v2;
  v2 = ecl_make_cclosure_va((cl_objectfn)LC176__lambda24,env0,Cblock,0);
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for SUBTYPEP-CLEAR-CACHE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L177subtypep_clear_cache()
{
 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:;
 si_fill_array_with_elt(ecl_cmp_symbol_value(cl_env_copy,VV[5]), ECL_NIL, ecl_make_int8_t(0), ECL_NIL);
 value0 = si_fill_array_with_elt(ecl_cmp_symbol_value(cl_env_copy,VV[6]), ECL_NIL, ecl_make_int8_t(0), ECL_NIL);
 return value0;
}
static cl_object L177subtypep_clear_cache_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[7]);
 {
  return L177subtypep_clear_cache();
 }
}
/* function definition for PROCLAIM-CLASS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L178proclaim_class(cl_narg narg, cl_object v1name, cl_object v2class, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[10]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[10]);
 {
  cl_object v3env;
  va_list args; va_start(args,v2class);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ECL_NIL;
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  L179create_type_name(v1name);
  value0 = (cl_env_copy->function=(VV[9]->symbol.gfdef))->cfun.entry(2, v2class, v1name) /*  SETF-FIND-CLASS */;
  return value0;
 }
}
/* function definition for CREATE-TYPE-NAME                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L179create_type_name(cl_object v1name)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*ALIEN-DECLARATIONS*",1662));
  v3 = v1name;
  v4 = v2;
  if (Null(ecl_memql(v3,v4))){
   goto L2;
  }
 }
 value0 = cl_error(2, VV[11], v1name);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L179create_type_name_va(cl_narg narg, cl_object v2name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[12]);
 {
  return L179create_type_name(v2name);
 }
}
/* function definition for DO-DEFTYPE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_do_deftype(cl_narg narg, cl_object v1name, cl_object v2form, cl_object v3function, ...)
{
 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!=3)) FEwrong_num_arguments(ECL_SYM("DO-DEFTYPE",1660));
 {
L1:;
  if (ECL_SYMBOLP(v1name)) {
   goto L2;
  }
  L212error_type_specifier(v1name);
L2:;
  L179create_type_name(v1name);
  si_put_sysprop(v1name, VV[14], v2form);
  if (Null(cl_functionp(v3function))){
   goto L8;
  }
  T0 = v3function;
  goto L7;
L8:;
  T0 = cl_constantly(v3function);
L7:;
  si_put_sysprop(v1name, VV[15], T0);
  L177subtypep_clear_cache();
  value0 = v1name;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* local function DEFTYPE                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC183deftype(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4name;
  cl_object v5lambda_list;
  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);
   v4name = 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);
   v5lambda_list = v6;
  }
  {
   cl_object v6;
   cl_object v7;
   v6 = ecl_make_cfun_va((cl_objectfn)LC181verify_tree_va,ECL_NIL,Cblock,1);
   v7 = ecl_make_cfun_va((cl_objectfn)LC180set_default_va,ECL_NIL,Cblock,1);
   v5lambda_list = LC182maptree(v7, v5lambda_list, v6);
  }
  {
   cl_object v6;                                  /*  FUNCTION                */
   cl_object v7;                                  /*  DOCUMENTATION           */
   value0 = (cl_env_copy->function=(ECL_SYM("EXPAND-DEFMACRO",1077)->symbol.gfdef))->cfun.entry(4, v4name, v5lambda_list, v3, ECL_SYM("DEFTYPE",290)) /*  EXPAND-DEFMACRO */;
   {
    const int v8 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v9;
    v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v9;
   }
   if (!(v5lambda_list==ECL_NIL)){
    goto L18;
   }
   if (!(ECL_CONSP(v3))){
    goto L18;
   }
   T0 = ecl_cdr(v3);
   if (!(T0==ECL_NIL)){
    goto L18;
   }
   {
    cl_object v8form;
    v8form = ecl_car(v3);
    if (Null(cl_constantp(2, v8form, v2env))){
     goto L18;
    }
    T0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("CONSTANT-FORM-VALUE",2161)))->cfun.entry(2, v8form, v2env) /*  CONSTANT-FORM-VALUE */;
    v6 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("MAYBE-QUOTE",1764)))->cfun.entry(1, T0) /*  MAYBE-QUOTE */;
   }
L18:;
   T0 = si_expand_set_documentation(v4name, ECL_SYM("TYPE",872), v7);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4name);
   T2 = cl_listX(4, ECL_SYM("DEFTYPE",290), v4name, v5lambda_list, v3);
   T3 = cl_list(2, ECL_SYM("QUOTE",682), T2);
   T4 = cl_list(4, ECL_SYM("DO-DEFTYPE",1660), T1, T3, v6);
   T5 = ecl_list1(T4);
   T6 = ecl_append(T0,T5);
   value0 = cl_listX(3, ECL_SYM("EVAL-WHEN",342), VV[24], T6);
   return value0;
  }
 }
}
static cl_object LC183deftype_va(cl_narg narg, cl_object v6, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
  return LC183deftype(v6, v7env);
 }
}
/* local function LAMBDA85                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC184__lambda85(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[29];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC184__lambda85_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[27]);
 {
  return LC184__lambda85(v4, v5);
 }
}
/* local function LAMBDA93                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC185__lambda93(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[32];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC185__lambda93_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[31]);
 {
  return LC185__lambda93(v4, v5);
 }
}
/* local function LAMBDA159                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC186__lambda159(cl_object v1, cl_object v2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4start;
  cl_object v5start_p;
  cl_object v6end;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  v4start = ecl_car(v3);
  goto L3;
L4:;
  v4start = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L8;
  }
  v3 = ecl_cdr(v3);
  v5start_p = ECL_T;
  goto L6;
L8:;
  v5start_p = ECL_NIL;
  goto L6;
L6:;
  if (Null(v3)){
   goto L13;
  }
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v6end = v7;
   goto L12;
  }
L13:;
  v6end = ECL_SYM("*",20);
L12:;
  if (Null(v3)){
   goto L18;
  }
  si_dm_too_many_arguments(v1);
L18:;
  if (Null(v5start_p)){
   goto L20;
  }
  {
   cl_object v7rat_start;
   cl_object v8real_start;
   cl_object v9rat_end;
   cl_object v10real_end;
   v7rat_start = ECL_NIL;
   v8real_start = ECL_NIL;
   v9rat_end = ECL_NIL;
   v10real_end = ECL_NIL;
   if (!(ECL_CONSP(v4start))){
    goto L27;
   }
   v4start = ecl_car(v4start);
   T0 = cl_rational(v4start);
   v7rat_start = ecl_list1(T0);
   T0 = cl_float(1, v4start);
   v8real_start = ecl_list1(T0);
   goto L26;
L27:;
   if (!(ecl_numberp(v4start))){
    goto L34;
   }
   v7rat_start = cl_rational(v4start);
   v8real_start = cl_float(1, v4start);
   goto L26;
L34:;
   v7rat_start = v4start;
   v8real_start = v4start;
L26:;
   if (!(ECL_CONSP(v6end))){
    goto L43;
   }
   v6end = ecl_car(v6end);
   T0 = cl_rational(v6end);
   v9rat_end = ecl_list1(T0);
   T0 = cl_float(1, v6end);
   v10real_end = ecl_list1(T0);
   goto L42;
L43:;
   if (!(ecl_numberp(v6end))){
    goto L50;
   }
   v9rat_end = cl_rational(v6end);
   v10real_end = cl_float(1, v6end);
   goto L42;
L50:;
   v9rat_end = v6end;
   v10real_end = v6end;
L42:;
   T0 = cl_list(3, ECL_SYM("RATIONAL",690), v7rat_start, v9rat_end);
   T1 = cl_list(3, ECL_SYM("FLOAT",376), v8real_start, v10real_end);
   value0 = cl_list(3, ECL_SYM("OR",616), T0, T1);
   return value0;
  }
L20:;
  value0 = VV[34];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC186__lambda159_va(cl_narg narg, cl_object v11, cl_object v12, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[33]);
 {
  return LC186__lambda159(v11, v12);
 }
}
/* local function LAMBDA179                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC187__lambda179(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  value0 = CONS(ECL_SYM("SINGLE-FLOAT",781),v3);
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_SYM("SINGLE-FLOAT",781);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC187__lambda179_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[35]);
 {
  return LC187__lambda179(v4, v5);
 }
}
/* local function LAMBDA184                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC188__lambda184(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[37];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC188__lambda184_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[36]);
 {
  return LC188__lambda184(v4, v5);
 }
}
/* local function LAMBDA189                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC189__lambda189(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4n;
  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);
   v4n = v5;
  }
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  T0 = ecl_one_minus(v4n);
  value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_int8_t(0), T0);
  return value0;
 }
}
static cl_object LC189__lambda189_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[38]);
 {
  return LC189__lambda189(v5, v6);
 }
}
/* local function LAMBDA195                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC190__lambda195(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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 v4s;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4s = v5;
   goto L3;
  }
L4:;
  v4s = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (v4s==ECL_NIL) {
   goto L13;
  }
  if (!((v4s)==(ECL_SYM("*",20)))){
   goto L11;
  }
  goto L12;
L13:;
L12:;
  value0 = VV[40];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_one_minus(v4s);
  T1 = ecl_expt(ecl_make_int8_t(2),T0);
  T2 = ecl_negate(T1);
  T3 = ecl_one_minus(v4s);
  T4 = ecl_expt(ecl_make_int8_t(2),T3);
  T5 = ecl_one_minus(T4);
  value0 = cl_list(3, ECL_SYM("INTEGER",439), T2, T5);
  return value0;
 }
}
static cl_object LC190__lambda195_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[39]);
 {
  return LC190__lambda195(v5, v6);
 }
}
/* local function LAMBDA201                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC191__lambda201(cl_object v1, cl_object v2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4s;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4s = v5;
   goto L3;
  }
L4:;
  v4s = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (v4s==ECL_NIL) {
   goto L13;
  }
  if (!((v4s)==(ECL_SYM("*",20)))){
   goto L11;
  }
  goto L12;
L13:;
L12:;
  value0 = VV[42];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_expt(ecl_make_int8_t(2),v4s);
  T1 = ecl_one_minus(T0);
  value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_int8_t(0), T1);
  return value0;
 }
}
static cl_object LC191__lambda201_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[41]);
 {
  return LC191__lambda201(v5, v6);
 }
}
/* local function LAMBDA207                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC192__lambda207(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[44];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC192__lambda207_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[43]);
 {
  return LC192__lambda207(v4, v5);
 }
}
/* local function LAMBDA212                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC193__lambda212(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[46];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC193__lambda212_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[45]);
 {
  return LC193__lambda212(v4, v5);
 }
}
/* local function LAMBDA217                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC194__lambda217(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[48];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC194__lambda217_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[47]);
 {
  return LC194__lambda217(v4, v5);
 }
}
/* local function LAMBDA228                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC195__lambda228(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[51];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC195__lambda228_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[50]);
 {
  return LC195__lambda228(v4, v5);
 }
}
/* local function LAMBDA233                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC196__lambda233(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4element_type;
  cl_object v5size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4element_type = v6;
   goto L3;
  }
L4:;
  v4element_type = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L10;
  }
  {
   cl_object v6;
   v6 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v5size = v6;
   goto L9;
  }
L10:;
  v5size = ECL_SYM("*",20);
L9:;
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  T0 = ecl_list1(v5size);
  value0 = cl_list(3, ECL_SYM("ARRAY",98), v4element_type, T0);
  return value0;
 }
}
static cl_object LC196__lambda233_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return LC196__lambda233(v6, v7);
 }
}
/* local function LAMBDA240                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC197__lambda240(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;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L3;
  }
  si_dm_too_many_arguments(v1);
L3:;
  value0 = VV[54];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC197__lambda240_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[53]);
 {
  return LC197__lambda240(v4, v5);
 }
}
/* local function LAMBDA245                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC198__lambda245(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 v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (!((v4size)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = VV[56];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_list1(v4size);
  T1 = cl_list(3, ECL_SYM("ARRAY",98), ECL_SYM("BASE-CHAR",122), T0);
  T2 = ecl_list1(v4size);
  T3 = cl_list(3, ECL_SYM("ARRAY",98), ECL_SYM("CHARACTER",224), T2);
  value0 = cl_list(3, ECL_SYM("OR",616), T1, T3);
  return value0;
 }
}
static cl_object LC198__lambda245_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[55]);
 {
  return LC198__lambda245(v5, v6);
 }
}
/* local function LAMBDA251                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC199__lambda251(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (!((v4size)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = VV[58];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("ARRAY",98), ECL_SYM("BASE-CHAR",122), T0);
  return value0;
 }
}
static cl_object LC199__lambda251_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[57]);
 {
  return LC199__lambda251(v5, v6);
 }
}
/* local function LAMBDA257                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC200__lambda257(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (!((v4size)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = VV[60];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("ARRAY",98), ECL_SYM("CHARACTER",224), T0);
  return value0;
 }
}
static cl_object LC200__lambda257_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[59]);
 {
  return LC200__lambda257(v5, v6);
 }
}
/* local function LAMBDA263                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC201__lambda263(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (!((v4size)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = VV[62];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("ARRAY",98), ECL_SYM("BIT",125), T0);
  return value0;
 }
}
static cl_object LC201__lambda263_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[61]);
 {
  return LC201__lambda263(v5, v6);
 }
}
/* local function LAMBDA269                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC202__lambda269(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (!((v4size)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = VV[64];
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("SIMPLE-ARRAY",766), ECL_T, T0);
  return value0;
 }
}
static cl_object LC202__lambda269_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[63]);
 {
  return LC202__lambda269(v5, v6);
 }
}
/* local function LAMBDA275                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC203__lambda275(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 v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (Null(v4size)){
   goto L11;
  }
  T0 = ecl_list1(v4size);
  T1 = cl_list(3, ECL_SYM("SIMPLE-ARRAY",766), ECL_SYM("BASE-CHAR",122), T0);
  T2 = ecl_list1(v4size);
  T3 = cl_list(3, ECL_SYM("SIMPLE-ARRAY",766), ECL_SYM("CHARACTER",224), T2);
  value0 = cl_list(3, ECL_SYM("OR",616), T1, T3);
  return value0;
L11:;
  value0 = VV[66];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC203__lambda275_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[65]);
 {
  return LC203__lambda275(v5, v6);
 }
}
/* local function LAMBDA281                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC204__lambda281(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (Null(v4size)){
   goto L11;
  }
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("SIMPLE-ARRAY",766), ECL_SYM("BASE-CHAR",122), T0);
  return value0;
L11:;
  value0 = VV[68];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC204__lambda281_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[67]);
 {
  return LC204__lambda281(v5, v6);
 }
}
/* local function LAMBDA287                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC205__lambda287(cl_object v1, cl_object v2)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4size;
  v3 = ecl_cdr(v1);
  if (Null(v3)){
   goto L4;
  }
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4size = v5;
   goto L3;
  }
L4:;
  v4size = ECL_SYM("*",20);
L3:;
  if (Null(v3)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  if (Null(v4size)){
   goto L11;
  }
  T0 = ecl_list1(v4size);
  value0 = cl_list(3, ECL_SYM("SIMPLE-ARRAY",766), ECL_SYM("BIT",125), T0);
  return value0;
L11:;
  value0 = VV[70];
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC205__lambda287_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[69]);
 {
  return LC205__lambda287(v5, v6);
 }
}
/* function definition for SIMPLE-ARRAY-P                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L206simple_array_p(cl_object v1x)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_ARRAYP(v1x))){
  goto L3;
 }
 if ((ECL_ARRAYP(v1x)? (void)0: FEtype_error_array(v1x),ECL_ADJUSTABLE_ARRAY_P(v1x))) {
  goto L3;
 }
 if ((ECL_ARRAYP(v1x)?(void)0:FEtype_error_array(v1x),ECL_ARRAY_HAS_FILL_POINTER_P(v1x))) {
  goto L3;
 }
 T0 = cl_array_displacement(v1x);
 value0 = Null(T0)?ECL_T:ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L206simple_array_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[71]);
 {
  return L206simple_array_p(v2x);
 }
}
/* function definition for COMPLEX-ARRAY-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L207complex_array_p(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_ARRAYP(v1x))){
  goto L3;
 }
 value0 = ecl_make_bool((ECL_ARRAYP(v1x)? (void)0: FEtype_error_array(v1x),ECL_ADJUSTABLE_ARRAY_P(v1x)));
 if (value0!=ECL_NIL) {
  goto L6;
 }
 value0 = ecl_make_bool((ECL_ARRAYP(v1x)?(void)0:FEtype_error_array(v1x),ECL_ARRAY_HAS_FILL_POINTER_P(v1x)));
 if (value0!=ECL_NIL) {
  goto L6;
 }
 value0 = cl_array_displacement(v1x);
 return value0;
L6:;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L207complex_array_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[73]);
 {
  return L207complex_array_p(v2x);
 }
}
/* function definition for RATIOP                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_ratiop(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_ratio);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for SHORT-FLOAT-P                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_short_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_singlefloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for SINGLE-FLOAT-P                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_single_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_singlefloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for DOUBLE-FLOAT-P                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_double_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_doublefloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LONG-FLOAT-P                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_long_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_longfloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for COMPLEX-SINGLE-FLOAT-P                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L208complex_single_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_csfloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L208complex_single_float_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[75]);
 {
  return L208complex_single_float_p(v2x);
 }
}
/* function definition for COMPLEX-DOUBLE-FLOAT-P                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L209complex_double_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_cdfloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L209complex_double_float_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[77]);
 {
  return L209complex_double_float_p(v2x);
 }
}
/* function definition for COMPLEX-LONG-FLOAT-P                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L210complex_long_float_p(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:;
 value0 = ecl_make_bool(ecl_t_of(v1x) == t_clfloat);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L210complex_long_float_p_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[79]);
 {
  return L210complex_long_float_p(v2x);
 }
}
/* function definition for UPGRADED-ARRAY-ELEMENT-TYPE                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_upgraded_array_element_type(cl_narg narg, cl_object v1element_type, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("UPGRADED-ARRAY-ELEMENT-TYPE",893));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("UPGRADED-ARRAY-ELEMENT-TYPE",893));
 {
  cl_object v2env;
  va_list args; va_start(args,v1element_type);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ECL_NIL;
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   int8_t v3hash;
   cl_object v4record;
   {
    cl_object v5;
    T0 = si_hash_eql(1, v1element_type);
    v5 = ecl_boole(ECL_BOOLAND,(ecl_make_int8_t(127)),(T0));
    {
     cl_fixnum v6;
     v6 = (cl_fixnum)(0);
     if (!(ECL_FIXNUMP(v5))){
      goto L8;
     }
     v6 = ecl_fixnum(v5);
     if (!((v6)<=((cl_fixnum)(127)))){
      goto L13;
     }
     T0 = ecl_make_bool((v6)>=((cl_fixnum)(0)));
     goto L5;
L13:;
     T0 = ECL_NIL;
     goto L5;
L8:;
     T0 = ECL_NIL;
     goto L5;
    }
L5:;
    if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[85],v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3hash = ecl_fixnum(v5);
   }
   {
    cl_object v5;
    v5 = ecl_cmp_symbol_value(cl_env_copy,VV[6]);
    T0 = v5;
    {
     int8_t v6;
     v6 = v3hash;
     if (ecl_unlikely(((cl_fixnum)(v6))>=(v5)->vector.dim))
           FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum((cl_fixnum)(v6)),(v5)->vector.dim);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = ecl_make_int8_t(v6);
    }
    v4record = ecl_aref_unsafe(T0,ecl_fixnum(T1));
   }
   if (Null(v4record)){
    goto L22;
   }
   T0 = ecl_car(v4record);
   if (!((T0)==(v1element_type))){
    goto L22;
   }
   value0 = ecl_cdr(v4record);
   cl_env_copy->nvalues = 1;
   return value0;
L22:;
   {
    cl_object v5answer;
    {
     cl_object v6;
     cl_object v7;
     cl_object v8;
     v6 = (ECL_SYM("EQ",335)->symbol.gfdef);
     v7 = v1element_type;
     v8 = VV[84];
     if (Null(si_memq(v7,v8))){
      goto L26;
     }
    }
    v5answer = v1element_type;
    goto L25;
L26:;
    {
     cl_object v6;
     v6 = ecl_cmp_symbol_value(cl_env_copy,VV[83]);
     goto L34;
L33:;
     {
      cl_object v7v;
      v7v = ecl_car(v6);
      if (Null(cl_subtypep(3, v1element_type, v7v, v2env))){
       goto L38;
      }
      v5answer = v7v;
      goto L25;
L38:;
     }
     v6 = ecl_cdr(v6);
L34:;
     if (Null(v6)){
      goto L42;
     }
     goto L33;
L42:;
     v5answer = ECL_T;
    }
L25:;
    {
     cl_object v6;
     v6 = ecl_cmp_symbol_value(cl_env_copy,VV[6]);
     T0 = v6;
     {
      int8_t v7;
      v7 = v3hash;
      if (ecl_unlikely(((cl_fixnum)(v7))>=(v6)->vector.dim))
           FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum((cl_fixnum)(v7)),(v6)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = ecl_make_int8_t(v7);
     }
     T2 = CONS(v1element_type,v5answer);
     ecl_aset_unsafe(T0,ecl_fixnum(T1),T2);
    }
    value0 = v5answer;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* function definition for UPGRADED-COMPLEX-PART-TYPE                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_upgraded_complex_part_type(cl_narg narg, cl_object v1real_type, ...)
{
 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("UPGRADED-COMPLEX-PART-TYPE",894));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("UPGRADED-COMPLEX-PART-TYPE",894));
 {
  cl_object v2env;
  va_list args; va_start(args,v1real_type);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ECL_NIL;
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (Null(L254complex_float_feature(v2env))){
   goto L2;
  }
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("NULL",607), v2env))){
   goto L4;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("RATIONAL",690), v2env))){
   goto L6;
  }
  value0 = ECL_SYM("RATIONAL",690);
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("SINGLE-FLOAT",781), v2env))){
   goto L8;
  }
  value0 = ECL_SYM("SINGLE-FLOAT",781);
  cl_env_copy->nvalues = 1;
  return value0;
L8:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("DOUBLE-FLOAT",317), v2env))){
   goto L10;
  }
  value0 = ECL_SYM("DOUBLE-FLOAT",317);
  cl_env_copy->nvalues = 1;
  return value0;
L10:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("LONG-FLOAT",510), v2env))){
   goto L12;
  }
  value0 = ECL_SYM("LONG-FLOAT",510);
  cl_env_copy->nvalues = 1;
  return value0;
L12:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("FLOAT",376), v2env))){
   goto L14;
  }
  value0 = ECL_SYM("FLOAT",376);
  cl_env_copy->nvalues = 1;
  return value0;
L14:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("REAL",706), v2env))){
   goto L16;
  }
  value0 = ECL_SYM("REAL",706);
  cl_env_copy->nvalues = 1;
  return value0;
L16:;
  value0 = cl_error(2, VV[89], v1real_type);
  return value0;
L2:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("NULL",607), v2env))){
   goto L18;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L18:;
  if (Null(cl_subtypep(3, v1real_type, ECL_SYM("REAL",706), v2env))){
   goto L20;
  }
  value0 = ECL_SYM("REAL",706);
  cl_env_copy->nvalues = 1;
  return value0;
L20:;
  value0 = cl_error(2, VV[89], v1real_type);
  return value0;
 }
}
/* function definition for IN-INTERVAL-P                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L211in_interval_p(cl_object v1x, cl_object v2interval)
{
 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 v3low;
  cl_object v4high;
  v3low = ECL_NIL;
  v4high = ECL_NIL;
  if (!(ecl_endp(v2interval))){
   goto L5;
  }
  v3low = ECL_SYM("*",20);
  v4high = ECL_SYM("*",20);
  goto L4;
L5:;
  T0 = ecl_cdr(v2interval);
  if (!(ecl_endp(T0))){
   goto L10;
  }
  v3low = ecl_car(v2interval);
  v4high = ECL_SYM("*",20);
  goto L4;
L10:;
  v3low = ecl_car(v2interval);
  v4high = ecl_cadr(v2interval);
L4:;
  {
   cl_object v5;
   v5 = ecl_make_bool((v3low)==(ECL_SYM("*",20)));
   if (Null(v5)){
    goto L20;
   }
   goto L18;
L20:;
   if (!(ECL_CONSP(v3low))){
    goto L22;
   }
   T0 = ecl_car(v3low);
   if (!(ecl_lowereq(v1x,T0))){
    goto L18;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L22:;
   {
    cl_object v6;
    if (!(ecl_lower(v1x,v3low))){
     goto L26;
    }
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
L26:;
    v6 = ECL_NIL;
   }
  }
L18:;
  {
   cl_object v5;
   v5 = ecl_make_bool((v4high)==(ECL_SYM("*",20)));
   if (Null(v5)){
    goto L31;
   }
   goto L29;
L31:;
   if (!(ECL_CONSP(v4high))){
    goto L33;
   }
   T0 = ecl_car(v4high);
   if (!(ecl_greatereq(v1x,T0))){
    goto L29;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L33:;
   {
    cl_object v6;
    if (!(ecl_greater(v1x,v4high))){
     goto L37;
    }
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
L37:;
    v6 = ECL_NIL;
   }
  }
L29:;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for ERROR-TYPE-SPECIFIER                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L212error_type_specifier(cl_object v1type)
{
 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(2, VV[91], v1type);
 return value0;
}
/* function definition for MATCH-DIMENSIONS                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L213match_dimensions(cl_object v1array, cl_object v2pat)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_make_bool((v2pat)==(ECL_SYM("*",20)));
 if (value0!=ECL_NIL) {
  goto L3;
 }
 {
  cl_object v3rank;
  v3rank = cl_array_rank(v1array);
  if (!(ecl_numberp(v2pat))){
   goto L6;
  }
  value0 = ecl_make_bool(ecl_number_equalp(v3rank,v2pat));
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  if (!(ECL_LISTP(v2pat))){
   goto L8;
  }
  {
   cl_object v4i;
   v4i = ecl_make_int8_t(0);
   goto L13;
L12:;
   if (!(ECL_CONSP(v2pat))){
    goto L18;
   }
   T0 = ecl_car(v2pat);
   if ((T0)==(ECL_SYM("*",20))) {
    goto L15;
   }
   {
    cl_fixnum v5;
    v5 = ecl_array_dimension(v1array,ecl_to_size(v4i));
    T0 = ecl_car(v2pat);
    if ((ecl_make_fixnum(v5))==(T0)) {
     goto L15;
    }
    goto L16;
   }
L18:;
   goto L16;
L16:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L15:;
   v2pat = ecl_cdr(v2pat);
   v4i = ecl_one_plus(v4i);
L13:;
   if (!(ecl_lower(v4i,v3rank))){
    goto L25;
   }
   goto L12;
L25:;
   value0 = ecl_make_bool(v2pat==ECL_NIL);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L8:;
  if (!(ECL_ATOM(v2pat))){
   goto L27;
  }
  value0 = cl_error(2, VV[93], v2pat);
  return value0;
L27:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for TYPEP                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_typep(cl_narg narg, cl_object v1object, cl_object v2type, ...)
{
 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<2)) FEwrong_num_arguments(ECL_SYM("TYPEP",878));
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(ECL_SYM("TYPEP",878));
 {
  cl_object v3env;
  va_list args; va_start(args,v2type);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ECL_NIL;
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4tp;
   cl_object v5i;
   cl_object v6c;
   v4tp = ECL_NIL;
   v5i = ECL_NIL;
   v6c = ECL_NIL;
   if (Null(v3env)){
    goto L5;
   }
   {
    cl_object v7;
    v7 = L265search_type_in_env(v2type, v3env);
    value0 = ecl_make_bool(ECL_SYMBOLP(v7));
    if (value0!=ECL_NIL) {
     goto L12;
    }
    value0 = si_of_class_p(2, v7, ECL_SYM("CLASS",937));
    if (value0!=ECL_NIL) {
     goto L12;
    }
    T0 = ecl_make_bool(ECL_LISTP(v7));
    goto L10;
L12:;
    T0 = value0;
    goto L10;
L10:;
    if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(VV[95],v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v2type = v7;
   }
L5:;
   if (!(ECL_SYMBOLP(v2type))){
    goto L16;
   }
   {
    cl_object v7f;
    v7f = si_get_sysprop(v2type, VV[82]);
    if (Null(v7f)){
     goto L19;
    }
    value0 = ecl_function_dispatch(cl_env_copy,v7f)(1, v1object);
    return value0;
L19:;
    v4tp = v2type;
    v5i = ECL_NIL;
    goto L15;
   }
L16:;
   if (!(ECL_CONSP(v2type))){
    goto L24;
   }
   v4tp = ecl_car(v2type);
   v5i = ecl_cdr(v2type);
   goto L15;
L24:;
   if (!(ECL_INSTANCEP(v2type))){
    goto L29;
   }
   T0 = cl_class_of(v1object);
   value0 = si_subclassp(2, T0, v2type);
   return value0;
L29:;
   L212error_type_specifier(v2type);
L15:;
   if (!((v4tp)==(ECL_SYM("EQL",336)))){
    goto L36;
   }
   goto L33;
L36:;
   goto L34;
L34:;
   if (!((v4tp)==(ECL_SYM("MEMBER",554)))){
    goto L31;
   }
   goto L32;
L33:;
L32:;
   {
    cl_object v7;
    cl_object v8;
    v7 = v1object;
    v8 = v5i;
    if (Null(ecl_memql(v7,v8))){
     goto L40;
    }
   }
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L40:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L31:;
   if (!((v4tp)==(ECL_SYM("NOT",586)))){
    goto L44;
   }
   T0 = ecl_car(v5i);
   T1 = cl_typep(3, v1object, T0, v3env);
   value0 = Null(T1)?ECL_T:ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L44:;
   if (!((v4tp)==(ECL_SYM("OR",616)))){
    goto L46;
   }
   {
    cl_object v7;
    v7 = v5i;
    goto L51;
L50:;
    {
     cl_object v8e;
     v8e = ecl_car(v7);
     if (Null(cl_typep(3, v1object, v8e, v3env))){
      goto L55;
     }
     value0 = ECL_T;
     cl_env_copy->nvalues = 1;
     return value0;
L55:;
    }
    v7 = ecl_cdr(v7);
L51:;
    if (Null(v7)){
     goto L59;
    }
    goto L50;
L59:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L46:;
   if (!((v4tp)==(ECL_SYM("AND",89)))){
    goto L61;
   }
   {
    cl_object v8;
    v8 = v5i;
    goto L66;
L65:;
    {
     cl_object v9e;
     v9e = ecl_car(v8);
     if (cl_typep(3, v1object, v9e, v3env)!=ECL_NIL) {
      goto L70;
     }
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 1;
     return value0;
L70:;
    }
    v8 = ecl_cdr(v8);
L66:;
    if (Null(v8)){
     goto L74;
    }
    goto L65;
L74:;
    value0 = ECL_T;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L61:;
   if (!((v4tp)==(ECL_SYM("SATISFIES",738)))){
    goto L76;
   }
   T0 = ecl_car(v5i);
   value0 = ecl_function_dispatch(cl_env_copy,T0)(1, v1object);
   return value0;
L76:;
   if (!((v4tp)==(ECL_T))){
    goto L83;
   }
   goto L80;
L83:;
   goto L81;
L81:;
   if (!((v4tp)==(ECL_SYM("*",20)))){
    goto L78;
   }
   goto L79;
L80:;
L79:;
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L78:;
   if (!((v4tp)==(ECL_NIL))){
    goto L86;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L86:;
   if (!((v4tp)==(ECL_SYM("BIGNUM",124)))){
    goto L89;
   }
   if (!(ECL_FIXNUMP(v1object)||ECL_BIGNUMP(v1object))){
    goto L92;
   }
   {
    bool v9;
    v9 = ECL_FIXNUMP(v1object);
    value0 = (v9)?ECL_NIL:ECL_T;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L92:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L89:;
   if (!((v4tp)==(ECL_SYM("STANDARD-CHAR",797)))){
    goto L94;
   }
   if (!(ECL_CHARACTERP(v1object))){
    goto L97;
   }
   value0 = cl_standard_char_p(v1object);
   return value0;
L97:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L94:;
   if (!((v4tp)==(ECL_SYM("INTEGER",439)))){
    goto L99;
   }
   if (!(ECL_FIXNUMP(v1object)||ECL_BIGNUMP(v1object))){
    goto L102;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L102:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L99:;
   if (!((v4tp)==(ECL_SYM("RATIO",689)))){
    goto L104;
   }
   if (Null(si_ratiop(v1object))){
    goto L107;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L107:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L104:;
   if (!((v4tp)==(ECL_SYM("RATIONAL",690)))){
    goto L109;
   }
   if (Null(cl_rationalp(v1object))){
    goto L112;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L112:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L109:;
   if (!((v4tp)==(ECL_SYM("FLOAT",376)))){
    goto L114;
   }
   if (!(floatp(v1object))){
    goto L117;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L117:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L114:;
   if (!((v4tp)==(ECL_SYM("REAL",706)))){
    goto L119;
   }
   if (cl_rationalp(v1object)!=ECL_NIL) {
    goto L124;
   }
   if (!(floatp(v1object))){
    goto L122;
   }
   goto L123;
L124:;
L123:;
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L122:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L119:;
   if (!((v4tp)==(ECL_SYM("SHORT-FLOAT",759)))){
    goto L126;
   }
   if (!(ECL_SINGLE_FLOAT_P(v1object))){
    goto L129;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L129:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L126:;
   if (!((v4tp)==(ECL_SYM("SINGLE-FLOAT",781)))){
    goto L131;
   }
   if (!(ECL_SINGLE_FLOAT_P(v1object))){
    goto L134;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L134:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L131:;
   if (!((v4tp)==(ECL_SYM("DOUBLE-FLOAT",317)))){
    goto L136;
   }
   if (!(ECL_DOUBLE_FLOAT_P(v1object))){
    goto L139;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L139:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L136:;
   if (!((v4tp)==(ECL_SYM("LONG-FLOAT",510)))){
    goto L141;
   }
   if (!(ECL_LONG_FLOAT_P(v1object))){
    goto L144;
   }
   value0 = L211in_interval_p(v1object, v5i);
   return value0;
L144:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L141:;
   if (!((v4tp)==(ECL_SYM("COMPLEX",243)))){
    goto L146;
   }
   if (Null(cl_complexp(v1object))){
    goto L149;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L152;
   }
   T0 = cl_realpart(v1object);
   T1 = ecl_car(v5i);
   if (Null(cl_typep(3, T0, T1, v3env))){
    goto L155;
   }
   T0 = cl_imagpart(v1object);
   T1 = ecl_car(v5i);
   value0 = cl_typep(3, T0, T1, v3env);
   return value0;
L155:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L152:;
   cl_env_copy->nvalues = 1;
   return value0;
L149:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L146:;
   if (!((v4tp)==(ECL_SYM("SEQUENCE",744)))){
    goto L157;
   }
   value0 = ecl_make_bool(ECL_LISTP(v1object));
   if (value0!=ECL_NIL) {
    goto L160;
   }
   value0 = ecl_make_bool(ECL_VECTORP(v1object));
   cl_env_copy->nvalues = 1;
   return value0;
L160:;
   cl_env_copy->nvalues = 1;
   return value0;
L157:;
   if (!((v4tp)==(ECL_SYM("CONS",253)))){
    goto L162;
   }
   if (!(ECL_CONSP(v1object))){
    goto L165;
   }
   if (ecl_endp(v5i)) {
    goto L168;
   }
   {
    cl_object v9car_type;
    v9car_type = ecl_car(v5i);
    if ((v9car_type)==(ECL_SYM("*",20))) {
     goto L171;
    }
    T0 = ecl_car(v1object);
    if (Null(cl_typep(3, T0, v9car_type, v3env))){
     goto L165;
    }
    goto L167;
L171:;
    goto L167;
   }
L168:;
L167:;
   T0 = ecl_cdr(v5i);
   value0 = ecl_make_bool(ecl_endp(T0));
   if (value0!=ECL_NIL) {
    goto L174;
   }
   {
    cl_object v9cdr_type;
    v9cdr_type = ecl_cadr(v5i);
    value0 = ecl_make_bool((v9cdr_type)==(ECL_SYM("*",20)));
    if (value0!=ECL_NIL) {
     goto L178;
    }
    T0 = ecl_cdr(v1object);
    value0 = cl_typep(3, T0, v9cdr_type, v3env);
    return value0;
L178:;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L174:;
   cl_env_copy->nvalues = 1;
   return value0;
L165:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L162:;
   if (!((v4tp)==(ECL_SYM("BASE-STRING",123)))){
    goto L180;
   }
   if (!(ECL_BASE_STRING_P(v1object))){
    goto L183;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L186;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L186:;
   cl_env_copy->nvalues = 1;
   return value0;
L183:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L180:;
   if (!((v4tp)==(ECL_SYM("STRING",808)))){
    goto L188;
   }
   if (!(ECL_STRINGP(v1object))){
    goto L191;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L194;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L194:;
   cl_env_copy->nvalues = 1;
   return value0;
L191:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L188:;
   if (!((v4tp)==(ECL_SYM("BIT-VECTOR",136)))){
    goto L196;
   }
   if (!(ECL_BIT_VECTOR_P(v1object))){
    goto L199;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L202;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L202:;
   cl_env_copy->nvalues = 1;
   return value0;
L199:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L196:;
   if (!((v4tp)==(ECL_SYM("SIMPLE-BASE-STRING",767)))){
    goto L204;
   }
   if (!(ECL_BASE_STRING_P(v1object))){
    goto L207;
   }
   if (Null(cl_simple_string_p(v1object))){
    goto L207;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L211;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L211:;
   cl_env_copy->nvalues = 1;
   return value0;
L207:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L204:;
   if (!((v4tp)==(ECL_SYM("SIMPLE-STRING",774)))){
    goto L213;
   }
   if (Null(cl_simple_string_p(v1object))){
    goto L216;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L219;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L219:;
   cl_env_copy->nvalues = 1;
   return value0;
L216:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L213:;
   if (!((v4tp)==(ECL_SYM("SIMPLE-BIT-VECTOR",768)))){
    goto L221;
   }
   if (Null(cl_simple_bit_vector_p(v1object))){
    goto L224;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L227;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L227:;
   cl_env_copy->nvalues = 1;
   return value0;
L224:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L221:;
   if (!((v4tp)==(ECL_SYM("SIMPLE-VECTOR",777)))){
    goto L229;
   }
   if (Null(cl_simple_vector_p(v1object))){
    goto L232;
   }
   value0 = ecl_make_bool(v5i==ECL_NIL);
   if (value0!=ECL_NIL) {
    goto L235;
   }
   value0 = L213match_dimensions(v1object, v5i);
   return value0;
L235:;
   cl_env_copy->nvalues = 1;
   return value0;
L232:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L229:;
   if (!((v4tp)==(ECL_SYM("COMPLEX-ARRAY",1880)))){
    goto L237;
   }
   if (Null(L207complex_array_p(v1object))){
    goto L240;
   }
   if (ecl_endp(v5i)) {
    goto L243;
   }
   T0 = ecl_car(v5i);
   if ((T0)==(ECL_SYM("*",20))) {
    goto L243;
   }
   T0 = cl_array_element_type(v1object);
   T1 = ecl_car(v5i);
   T2 = cl_upgraded_array_element_type(1, T1);
   if (!((T0)==(T2))){
    goto L240;
   }
   goto L242;
L243:;
L242:;
   T0 = ecl_cdr(v5i);
   value0 = ecl_make_bool(ecl_endp(T0));
   if (value0!=ECL_NIL) {
    goto L247;
   }
   T0 = ecl_cadr(v5i);
   value0 = L213match_dimensions(v1object, T0);
   return value0;
L247:;
   cl_env_copy->nvalues = 1;
   return value0;
L240:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L237:;
   if (!((v4tp)==(ECL_SYM("SIMPLE-ARRAY",766)))){
    goto L249;
   }
   if (Null(L206simple_array_p(v1object))){
    goto L252;
   }
   if (ecl_endp(v5i)) {
    goto L255;
   }
   T0 = ecl_car(v5i);
   if ((T0)==(ECL_SYM("*",20))) {
    goto L255;
   }
   T0 = cl_array_element_type(v1object);
   T1 = ecl_car(v5i);
   T2 = cl_upgraded_array_element_type(1, T1);
   if (!((T0)==(T2))){
    goto L252;
   }
   goto L254;
L255:;
L254:;
   T0 = ecl_cdr(v5i);
   value0 = ecl_make_bool(ecl_endp(T0));
   if (value0!=ECL_NIL) {
    goto L259;
   }
   T0 = ecl_cadr(v5i);
   value0 = L213match_dimensions(v1object, T0);
   return value0;
L259:;
   cl_env_copy->nvalues = 1;
   return value0;
L252:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L249:;
   if (!((v4tp)==(ECL_SYM("ARRAY",98)))){
    goto L261;
   }
   if (!(ECL_ARRAYP(v1object))){
    goto L264;
   }
   if (ecl_endp(v5i)) {
    goto L267;
   }
   T0 = ecl_car(v5i);
   if ((T0)==(ECL_SYM("*",20))) {
    goto L267;
   }
   T0 = cl_array_element_type(v1object);
   T1 = ecl_car(v5i);
   T2 = cl_upgraded_array_element_type(1, T1);
   if (!((T0)==(T2))){
    goto L264;
   }
   goto L266;
L267:;
L266:;
   T0 = ecl_cdr(v5i);
   value0 = ecl_make_bool(ecl_endp(T0));
   if (value0!=ECL_NIL) {
    goto L271;
   }
   T0 = ecl_cadr(v5i);
   value0 = L213match_dimensions(v1object, T0);
   return value0;
L271:;
   cl_env_copy->nvalues = 1;
   return value0;
L264:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L261:;
   if (Null(si_get_sysprop(v4tp, VV[15]))){
    goto L273;
   }
   T1 = si_get_sysprop(v4tp, VV[15]);
   T2 = CONS(v4tp,v5i);
   T0 = ecl_function_dispatch(cl_env_copy,T1)(2, T2, v3env);
   value0 = cl_typep(2, v1object, T0);
   return value0;
L273:;
   if (!(ECL_CONSP(v5i))){
    goto L276;
   }
   value0 = L212error_type_specifier(v2type);
   return value0;
L276:;
   v6c = cl_find_class(2, v2type, ECL_NIL);
   if (Null(v6c)){
    goto L278;
   }
   T0 = cl_class_of(v1object);
   value0 = si_subclassp(2, T0, v6c);
   return value0;
L278:;
   value0 = L212error_type_specifier(v2type);
   return value0;
  }
 }
}
/* function definition for SUBCLASSP                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_subclassp(cl_narg narg, cl_object v1low, cl_object v2high, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("SUBCLASSP",1208));
 {
L1:;
  value0 = ecl_make_bool((v1low)==(v2high));
  if (value0!=ECL_NIL) {
   goto L3;
  }
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   cl_object v6;
   v3 = ecl_instance_ref((v1low),(ecl_fixnum(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("+CLASS-PRECEDENCE-LIST-NDX+",1552)))));
   v4 = (ECL_SYM("EQ",335)->symbol.gfdef);
   v5 = v2high;
   v6 = v3;
   value0 = si_memq(v5,v6);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L3:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for OF-CLASS-P                                         */
/* optimize speed 3, debug 1, space 1, safety 0                               */
cl_object si_of_class_p(cl_narg narg, cl_object v1object, cl_object v2class, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3x_class;
  v3x_class = cl_class_of(v1object);
  if (!((v3x_class)==(v2class))){
   goto L3;
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v4x_cpl;
   v4x_cpl = (v3x_class)->instance.slots[ecl_fixnum(ECL_SYM_VAL(cl_env_copy,ECL_SYM("+CLASS-PRECEDENCE-LIST-NDX+",1552)))];
   if (!(ECL_INSTANCEP(v2class))){
    goto L6;
   }
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    v5 = (ECL_SYM("EQ",335)->symbol.gfdef);
    v6 = v2class;
    v7 = v4x_cpl;
    value0 = si_memq(v6,v7);
    cl_env_copy->nvalues = 1;
    return value0;
   }
L6:;
   {
    cl_object v8;
    v8 = v4x_cpl;
    goto L14;
L13:;
    {
     cl_object v9c;
     v9c = _ecl_car(v8);
     T0 = (v9c)->instance.slots[ecl_fixnum(ECL_SYM_VAL(cl_env_copy,ECL_SYM("+CLASS-NAME-NDX+",1551)))];
     if (!((T0)==(v2class))){
      goto L18;
     }
     value0 = ECL_T;
     cl_env_copy->nvalues = 1;
     return value0;
L18:;
    }
    v8 = _ecl_cdr(v8);
L14:;
    if (Null(v8)){
     goto L22;
    }
    goto L13;
L22:;
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
/* function definition for FLATTEN-FUNCTION-TYPES                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L215flatten_function_types(cl_object v1type, cl_object v2env)
{
 cl_object T0, T1, T2, T3;
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v2env,env0);                  /*  ENV                     */
 if (!(ECL_CONSP(v1type))){
  goto L1;
 }
 T0 = ecl_car(v1type);
 if (!((T0)==(ECL_SYM("FUNCTION",398)))){
  goto L1;
 }
 value0 = ECL_SYM("FUNCTION",398);
 cl_env_copy->nvalues = 1;
 return value0;
L1:;
 if (!(ECL_CONSP(v1type))){
  goto L4;
 }
 {
  cl_object v3;
  v3 = ecl_car(v1type);
  if (!((v3)==(ECL_SYM("NOT",586)))){
   goto L11;
  }
  goto L8;
L11:;
  goto L9;
L9:;
  if (!((v3)==(ECL_SYM("OR",616)))){
   goto L15;
  }
  goto L8;
L15:;
  goto L13;
L13:;
  if (!((v3)==(ECL_SYM("AND",89)))){
   goto L19;
  }
  goto L8;
L19:;
  goto L17;
L17:;
  if (!((v3)==(ECL_SYM("CONS",253)))){
   goto L4;
  }
  goto L5;
L8:;
 }
L5:;
 T0 = ecl_car(v1type);
 {
  cl_object v3;
  {
   cl_object v4;
   v4 = ecl_make_cclosure_va((cl_objectfn)LC214__lambda442,env0,Cblock,1);
   v3 = v4;
  }
  {
   cl_object v4;
   cl_object v5;
   cl_object v6;
   {
    cl_object v7;
    v7 = ecl_cdr(v1type);
    if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v4 = v7;
   }
   v5 = ECL_NIL;
   v6 = v4;
   {
    cl_object v7;
    cl_object v8;
    v7 = ecl_list1(ECL_NIL);
    v8 = v7;
L31:;
    if (!(ecl_endp(v6))){
     goto L33;
    }
    goto L32;
L33:;
    v5 = ECL_CONS_CAR(v6);
    {
     cl_object v9;
     v9 = ECL_CONS_CDR(v6);
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v9;
    }
    {
     cl_object v9;
     v9 = v8;
     if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T2 = v9;
    }
    T3 = ecl_function_dispatch(cl_env_copy,v3)(1, v5);
    v8 = ecl_list1(T3);
    (ECL_CONS_CDR(T2)=v8,T2);
    goto L31;
L32:;
    T1 = ecl_cdr(v7);
    goto L22;
   }
  }
 }
L22:;
 value0 = CONS(T0,T1);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 {
  cl_object v3;
  cl_object v4;
  if (!(ECL_CONSP(v1type))){
   goto L50;
  }
  v3 = ecl_car(v1type);
  goto L49;
L50:;
  v3 = v1type;
L49:;
  if (!(ECL_CONSP(v1type))){
   goto L53;
  }
  v4 = ecl_cdr(v1type);
  goto L52;
L53:;
  v4 = ECL_NIL;
L52:;
  {
   cl_object v5fd;
   v5fd = si_get_sysprop(v3, VV[15]);
   if (Null(v5fd)){
    goto L56;
   }
   {
    cl_object v6type_alias;
    cl_object v7flattened_type;
    T0 = CONS(v3,v4);
    v6type_alias = ecl_function_dispatch(cl_env_copy,v5fd)(2, T0, ECL_CONS_CAR(CLV0));
    v7flattened_type = L215flatten_function_types(v6type_alias, ECL_CONS_CAR(CLV0));
    if (!((v7flattened_type)==(v6type_alias))){
     goto L60;
    }
    value0 = v1type;
    cl_env_copy->nvalues = 1;
    return value0;
L60:;
    value0 = v7flattened_type;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L56:;
   value0 = v1type;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L215flatten_function_types_va(cl_narg narg, cl_object v8type, cl_object v9env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[101]);
 {
  return L215flatten_function_types(v8type, v9env);
 }
}
/* function definition for NORMALIZE-TYPE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L216normalize_type(cl_object v1type, cl_object v2env)
{
 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 v3tp;
  cl_object v4i;
  cl_object v5fd;
  v3tp = ECL_NIL;
  v4i = ECL_NIL;
  v5fd = ECL_NIL;
  if (!(ECL_SYMBOLP(v1type))){
   goto L5;
  }
  v5fd = si_get_sysprop(v1type, VV[15]);
  if (Null(v5fd)){
   goto L7;
  }
  T0 = ecl_list1(v1type);
  v1type = ecl_function_dispatch(cl_env_copy,v5fd)(2, T0, v2env);
  goto L1;
L7:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = v1type;
  return cl_env_copy->values[0];
L5:;
  if (Null((cl_env_copy->function=(VV[114]->symbol.gfdef))->cfun.entry(1, v1type) /*  CLASSP */)){
   goto L13;
  }
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = v1type;
  return cl_env_copy->values[0];
L13:;
  if (!(ECL_ATOM(v1type))){
   goto L15;
  }
  value0 = L212error_type_specifier(v1type);
  return value0;
L15:;
  v3tp = ecl_car(v1type);
  v4i = ecl_cdr(v1type);
  v5fd = si_get_sysprop(v3tp, VV[15]);
  if (Null(v5fd)){
   goto L17;
  }
  v1type = ecl_function_dispatch(cl_env_copy,v5fd)(2, v1type, v2env);
  goto L1;
L17:;
  if (!((v3tp)==(ECL_SYM("INTEGER",439)))){
   goto L27;
  }
  T0 = ecl_cadr(v4i);
  if (!(ECL_CONSP(T0))){
   goto L27;
  }
  T0 = ecl_car(v4i);
  T1 = ecl_caadr(v4i);
  T2 = ecl_one_minus(T1);
  T3 = cl_list(2, T0, T2);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T3;
  cl_env_copy->values[0] = v3tp;
  return cl_env_copy->values[0];
L27:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v4i;
  cl_env_copy->values[0] = v3tp;
  return cl_env_copy->values[0];
 }
}
static cl_object L216normalize_type_va(cl_narg narg, cl_object v6type, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[113]);
 {
  return L216normalize_type(v6type, v7env);
 }
}
/* function definition for EXPAND-DEFTYPE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L217expand_deftype(cl_object v1type, cl_object v2env)
{
 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 v3base;
  cl_object v4args;
  v3base = ECL_NIL;
  v4args = ECL_NIL;
  if (!(ECL_ATOM(v1type))){
   goto L5;
  }
  v3base = v1type;
  v4args = ECL_NIL;
  goto L4;
L5:;
  v3base = ecl_car(v1type);
  v4args = ecl_cdr(v1type);
L4:;
  {
   cl_object v5fn;
   v5fn = si_get_sysprop(v3base, VV[15]);
   if (Null(v5fn)){
    goto L14;
   }
   T0 = CONS(v3base,v4args);
   v1type = ecl_function_dispatch(cl_env_copy,v5fn)(2, T0, v2env);
   goto L1;
L14:;
   value0 = v1type;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L217expand_deftype_va(cl_narg narg, cl_object v6type, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[116]);
 {
  return L217expand_deftype(v6type, v7env);
 }
}
/* function definition for COERCE                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_coerce(cl_object v1object, cl_object v2type)
{
 cl_object T0, T1, T2, T3, T4, T5;
 volatile cl_object lex0[2];
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 lex0[0] = v1object;                              /*  OBJECT                  */
 lex0[1] = v2type;                                /*  TYPE                    */
L1:;
 {
  cl_object v3aux;
  v3aux = ECL_NIL;
  if (Null(cl_typep(2, lex0[0], lex0[1]))){
   goto L3;
  }
  value0 = lex0[0];
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  {
   cl_object v4type;
   v4type = L217expand_deftype(lex0[1], ECL_NIL);
   if (!(ECL_ATOM(v4type))){
    goto L6;
   }
   if (!((v4type)==(ECL_T))){
    goto L8;
   }
   value0 = lex0[0];
   cl_env_copy->nvalues = 1;
   return value0;
L8:;
   if (!((v4type)==(ECL_SYM("LIST",483)))){
    goto L11;
   }
   {
    cl_object v5;
    cl_object v6io;
    cl_object v7l;
    v5 = si_make_seq_iterator(1, lex0[0]);
    v6io = v5;
    v7l = ECL_NIL;
    goto L18;
L17:;
    T0 = si_seq_iterator_next(lex0[0], v6io);
    T1 = si_seq_iterator_ref(lex0[0], v6io);
    v7l = CONS(T1,v7l);
    v6io = T0;
L18:;
    if (v6io==ECL_NIL) {
     goto L23;
    }
    goto L17;
L23:;
    value0 = v7l;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L11:;
   if (!((v4type)==(ECL_SYM("CHARACTER",224)))){
    goto L30;
   }
   goto L27;
L30:;
   goto L28;
L28:;
   if (!((v4type)==(ECL_SYM("BASE-CHAR",122)))){
    goto L25;
   }
   goto L26;
L27:;
L26:;
   value0 = cl_character(lex0[0]);
   return value0;
L25:;
   if (!((v4type)==(ECL_SYM("FLOAT",376)))){
    goto L33;
   }
   value0 = cl_float(1, lex0[0]);
   return value0;
L33:;
   if (!((v4type)==(ECL_SYM("SHORT-FLOAT",759)))){
    goto L35;
   }
   value0 = ecl_make_single_float(ecl_to_float(lex0[0]));
   cl_env_copy->nvalues = 1;
   return value0;
L35:;
   if (!((v4type)==(ECL_SYM("SINGLE-FLOAT",781)))){
    goto L37;
   }
   value0 = ecl_make_single_float(ecl_to_float(lex0[0]));
   cl_env_copy->nvalues = 1;
   return value0;
L37:;
   if (!((v4type)==(ECL_SYM("DOUBLE-FLOAT",317)))){
    goto L39;
   }
   value0 = ecl_make_double_float(ecl_to_double(lex0[0]));
   cl_env_copy->nvalues = 1;
   return value0;
L39:;
   if (!((v4type)==(ECL_SYM("LONG-FLOAT",510)))){
    goto L41;
   }
   value0 = ecl_make_long_float(ecl_to_long_double(lex0[0]));
   cl_env_copy->nvalues = 1;
   return value0;
L41:;
   if (!((v4type)==(ECL_SYM("COMPLEX",243)))){
    goto L43;
   }
   T0 = cl_realpart(lex0[0]);
   T1 = cl_imagpart(lex0[0]);
   value0 = cl_complex(2, T0, T1);
   return value0;
L43:;
   if (!((v4type)==(ECL_SYM("COMPLEX-SINGLE-FLOAT",1899)))){
    goto L45;
   }
   T0 = cl_realpart(lex0[0]);
   {
    float v8;
    v8 = ecl_to_float(T0);
    T1 = cl_imagpart(lex0[0]);
    {
     float v9;
     v9 = ecl_to_float(T1);
     value0 = cl_complex(2, ecl_make_single_float(v8), ecl_make_single_float(v9));
     return value0;
    }
   }
L45:;
   if (!((v4type)==(ECL_SYM("COMPLEX-DOUBLE-FLOAT",1900)))){
    goto L47;
   }
   T0 = cl_realpart(lex0[0]);
   {
    double v8;
    v8 = ecl_to_double(T0);
    T1 = cl_imagpart(lex0[0]);
    {
     double v9;
     v9 = ecl_to_double(T1);
     value0 = cl_complex(2, ecl_make_double_float(v8), ecl_make_double_float(v9));
     return value0;
    }
   }
L47:;
   if (!((v4type)==(ECL_SYM("COMPLEX-LONG-FLOAT",1901)))){
    goto L49;
   }
   T0 = cl_realpart(lex0[0]);
   {
    long double v8;
    v8 = ecl_to_long_double(T0);
    T1 = cl_imagpart(lex0[0]);
    {
     long double v9;
     v9 = ecl_to_long_double(T1);
     value0 = cl_complex(2, ecl_make_long_float(v8), ecl_make_long_float(v9));
     return value0;
    }
   }
L49:;
   if (!((v4type)==(ECL_SYM("FUNCTION",398)))){
    goto L51;
   }
   value0 = si_coerce_to_function(lex0[0]);
   return value0;
L51:;
   {
    cl_object v8;
    cl_object v9;
    v8 = v4type;
    v9 = VV[125];
    if (Null(ecl_memql(v8,v9))){
     goto L53;
    }
   }
   value0 = cl_concatenate(2, v4type, lex0[0]);
   return value0;
L53:;
   if (ECL_LISTP(lex0[0])) {
    goto L59;
   }
   if (!(ECL_VECTORP(lex0[0]))){
    goto L57;
   }
   goto L58;
L59:;
L58:;
   value0 = cl_concatenate(2, v4type, lex0[0]);
   return value0;
L57:;
   value0 = LC218fail(lex0);
   return value0;
L6:;
   v3aux = ecl_car(v4type);
   if (!((v3aux)==(ECL_SYM("COMPLEX",243)))){
    goto L61;
   }
   if (Null(v4type)){
    goto L64;
   }
   T0 = cl_realpart(lex0[0]);
   T1 = ecl_cadr(v4type);
   T2 = cl_coerce(T0, T1);
   T3 = cl_imagpart(lex0[0]);
   T4 = ecl_cadr(v4type);
   T5 = cl_coerce(T3, T4);
   value0 = cl_complex(2, T2, T5);
   return value0;
L64:;
   T0 = cl_realpart(lex0[0]);
   T1 = cl_imagpart(lex0[0]);
   value0 = cl_complex(2, T0, T1);
   return value0;
L61:;
   {
    cl_object v8;
    cl_object v9;
    v8 = v3aux;
    v9 = VV[126];
    if (Null(ecl_memql(v8,v9))){
     goto L66;
    }
   }
   v3aux = cl_coerce(lex0[0], v3aux);
   if (cl_typep(2, v3aux, v4type)!=ECL_NIL) {
    goto L72;
   }
   LC218fail(lex0);
L72:;
   value0 = v3aux;
   cl_env_copy->nvalues = 1;
   return value0;
L66:;
   if (!((v3aux)==(ECL_SYM("AND",89)))){
    goto L74;
   }
   {
    cl_object v8;
    v8 = ecl_cdr(v4type);
    goto L80;
L79:;
    {
     cl_object v9type;
     v9type = ecl_car(v8);
     v3aux = cl_coerce(v3aux, v9type);
    }
    v8 = ecl_cdr(v8);
L80:;
    if (Null(v8)){
     goto L88;
    }
    goto L79;
L88:;
   }
   if (cl_typep(2, v3aux, v4type)!=ECL_NIL) {
    goto L90;
   }
   LC218fail(lex0);
L90:;
   value0 = v3aux;
   cl_env_copy->nvalues = 1;
   return value0;
L74:;
   if (ECL_LISTP(lex0[0])) {
    goto L94;
   }
   if (!(ECL_VECTORP(lex0[0]))){
    goto L92;
   }
   goto L93;
L94:;
L93:;
   value0 = cl_concatenate(2, v4type, lex0[0]);
   return value0;
L92:;
   value0 = LC218fail(lex0);
   return value0;
  }
 }
}
/* function definition for MAKE-MEMBER-TYPE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L219make_member_type(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 v1object;
  cl_object v2tag;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L219make_member_typekeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1object = keyvars[0];
   v2tag = keyvars[1];
  }
  value0 = cl_list(2, v1object, v2tag);
  return value0;
 }
}
/* function definition for FIND-MEMBER-TYPE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L220find_member_type(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[132]);
  v3 = v1object;
  v4 = v2;
  value0 = ecl_assql(v3,v4);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L220find_member_type_va(cl_narg narg, cl_object v5object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[136]);
 {
  return L220find_member_type(v5object);
 }
}
/* local function LAMBDA520                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC221__lambda520(cl_object v1new_tag, cl_object v2mtype)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_list(2, ECL_SYM("CDR",200), v2mtype);
 value0 = cl_list(3, ECL_SYM("RPLACA",735), T0, v1new_tag);
 return value0;
}
static cl_object LC221__lambda520_va(cl_narg narg, cl_object v3new_tag, cl_object v4mtype, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[140]);
 {
  return LC221__lambda520(v3new_tag, v4mtype);
 }
}
/* function definition for MAKE-ELEMENTARY-TYPE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L222make_elementary_type(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 v1spec;
  cl_object v2tag;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L222make_elementary_typekeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v1spec = keyvars[0];
   v2tag = keyvars[1];
  }
  value0 = cl_list(2, v1spec, v2tag);
  return value0;
 }
}
/* function definition for FIND-ELEMENTARY-TYPE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L223find_elementary_type(cl_object v1spec, cl_object v2test)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[133]);
  v4 = (VV[143]->symbol.gfdef);
  {
   cl_object v5;
   v5 = si_make_seq_iterator(2, v3, ecl_make_int8_t(0));
L5:;
   if (v5!=ECL_NIL) {
    goto L7;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   {
    cl_object v6;
    v6 = si_seq_iterator_ref(v3, v5);
    T0 = cl_first(v6);
    if (Null(ecl_function_dispatch(cl_env_copy,v2test)(2, v1spec, T0))){
     goto L9;
    }
    value0 = v6;
    cl_env_copy->nvalues = 1;
    return value0;
   }
L9:;
   v5 = si_seq_iterator_next(v3, v5);
   goto L5;
  }
 }
}
/* local function LAMBDA549                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC224__lambda549(cl_object v1new_tag, cl_object v2etype)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_list(2, ECL_SYM("CDR",200), v2etype);
 value0 = cl_list(3, ECL_SYM("RPLACA",735), T0, v1new_tag);
 return value0;
}
static cl_object LC224__lambda549_va(cl_narg narg, cl_object v3new_tag, cl_object v4etype, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[146]);
 {
  return LC224__lambda549(v3new_tag, v4etype);
 }
}
/* local function WITH-TYPE-DATABASE                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC225with_type_database(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 v4;
  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);
   v4 = v5;
  }
  if (Null(v4)){
   goto L9;
  }
  si_dm_too_many_arguments(v1);
L9:;
  value0 = cl_listX(3, ECL_SYM("LET",479), VV[148], v3);
  return value0;
 }
}
static cl_object LC225with_type_database_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[147]);
 {
  return LC225with_type_database(v5, v6);
 }
}
/* function definition for NEW-TYPE-TAG                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L226new_type_tag()
{
 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 v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[128]);
  T0 = cl_ash(ecl_cmp_symbol_value(cl_env_copy,VV[128]), ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,VV[128],T0);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for PUSH-NEW-TYPE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L227push_new_type(cl_object v1type, cl_object v2tag)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[132]);
  goto L6;
L5:;
  {
   cl_object v4i;
   v4i = ecl_car(v3);
   T0 = cl_first(v4i);
   if (Null(cl_typep(2, T0, v1type))){
    goto L10;
   }
   T0 = cl_second(v4i);
   v2tag = ecl_boole(ECL_BOOLIOR,(v2tag),(T0));
L10:;
  }
  v3 = ecl_cdr(v3);
L6:;
  if (Null(v3)){
   goto L15;
  }
  goto L5;
L15:;
 }
 T0 = L222make_elementary_type(4, VV[152], v1type, ECL_SYM("TAG",1352), v2tag);
 T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[133]));
 ecl_cmp_setq(cl_env_copy,VV[133],T1);
 value0 = v2tag;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for FIND-REGISTERED-TAG                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L228find_registered_tag(cl_narg narg, cl_object v1type, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[153]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[153]);
 {
  cl_object v2test;
  va_list args; va_start(args,v1type);
  {
   int i = 1;
   if (i >= narg) {
    v2test = (ECL_SYM("EQUAL",337)->symbol.gfdef);
   } else {
    i++;
    v2test = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3etype;
   v3etype = L223find_elementary_type(v1type, v2test);
   if (Null(v3etype)){
    goto L3;
   }
   value0 = cl_second(v3etype);
   return value0;
L3:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for MAKE-REGISTERED-TAG                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L229make_registered_tag(cl_object v1type, cl_object v2same_kingdom_p, cl_object v3type___)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v4;                                   /*  TAG-SUPER               */
  cl_object v5;                                   /*  TAG-SUB                 */
  value0 = L232find_type_bounds(v1type, v2same_kingdom_p, v3type___);
  {
   const int v6 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v7;
   v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v7;
  }
  if (!(v4==ECL_NIL)){
   goto L3;
  }
  value0 = L227push_new_type(v1type, v5);
  return value0;
L3:;
  {
   cl_object v6tag;
   v6tag = L226new_type_tag();
   L231update_types(v4, v6tag);
   v6tag = ecl_boole(ECL_BOOLIOR,(v6tag),(v5));
   value0 = L227push_new_type(v1type, v6tag);
   return value0;
  }
 }
}
static cl_object L229make_registered_tag_va(cl_narg narg, cl_object v4type, cl_object v5same_kingdom_p, cl_object v6type___, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[154]);
 {
  return L229make_registered_tag(v4type, v5same_kingdom_p, v6type___);
 }
}
/* function definition for MAYBE-SAVE-TYPES                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L230maybe_save_types()
{
 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(ecl_cmp_symbol_value(cl_env_copy,VV[127]))){
  goto L2;
 }
 T0 = ECL_NIL;
 ecl_cmp_setq(cl_env_copy,VV[127],T0);
 T0 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,VV[133]));
 ecl_cmp_setq(cl_env_copy,VV[133],T0);
 T0 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,VV[132]));
 ecl_cmp_setq(cl_env_copy,VV[132],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[132]);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for UPDATE-TYPES                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L231update_types(cl_object v1type_mask, cl_object v2new_tag)
{
 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:;
 L230maybe_save_types();
 {
  cl_object v3;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[133]);
  goto L6;
L5:;
  {
   cl_object v4i;
   v4i = ecl_car(v3);
   T0 = cl_second(v4i);
   T1 = ecl_boole(ECL_BOOLAND,(T0),(v1type_mask));
   if (ecl_zerop(T1)) {
    goto L10;
   }
   {
    cl_object v5;
    T0 = cl_second(v4i);
    v5 = ecl_boole(ECL_BOOLIOR,(v2new_tag),(T0));
    T0 = ecl_cdr(v4i);
    (ECL_CONS_CAR(T0)=v5,T0);
   }
L10:;
  }
  v3 = ecl_cdr(v3);
L6:;
  if (Null(v3)){
   goto L15;
  }
  goto L5;
L15:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L231update_types_va(cl_narg narg, cl_object v4type_mask, cl_object v5new_tag, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[156]);
 {
  return L231update_types(v4type_mask, v5new_tag);
 }
}
/* function definition for FIND-TYPE-BOUNDS                                   */
/* optimize speed 1, debug 1, space 1, safety 0                               */
static cl_object L232find_type_bounds(cl_object v1type, cl_object v2in_our_family_p, cl_object v3type___)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v4subtype_tag;
  cl_object v5disjoint_tag;
  cl_object v6supertype_tag;
  v4subtype_tag = ecl_make_int8_t(0);
  v5disjoint_tag = ecl_make_int8_t(0);
  v6supertype_tag = ecl_make_int8_t(0);
  {
   cl_object v7;
   v7 = ECL_SYM_VAL(cl_env_copy,VV[133]);
   goto L9;
L8:;
   {
    cl_object v8i;
    v8i = _ecl_car(v7);
    {
     cl_object v9;
     cl_object v10;
     v9 = cl_first(v8i);
     v10 = cl_second(v8i);
     if (Null((cl_env_copy->function=v2in_our_family_p)->cfun.entry(1, v9))){
      goto L13;
     }
     {
      cl_object v11;
      cl_object v12;
      v11 = (cl_env_copy->function=v3type___)->cfun.entry(2, v1type, v9);
      v12 = (cl_env_copy->function=v3type___)->cfun.entry(2, v9, v1type);
      if (Null(v11)){
       goto L19;
      }
      if (Null(v12)){
       goto L19;
      }
      cl_env_copy->nvalues = 2;
      cl_env_copy->values[1] = v10;
      cl_env_copy->values[0] = ECL_NIL;
      return cl_env_copy->values[0];
L19:;
      if (Null(v11)){
       goto L22;
      }
      v6supertype_tag = ecl_boole(ECL_BOOLIOR,(v10),(v6supertype_tag));
      goto L13;
L22:;
      if (Null(v12)){
       goto L25;
      }
      v4subtype_tag = ecl_boole(ECL_BOOLIOR,(v10),(v4subtype_tag));
      goto L13;
L25:;
      v5disjoint_tag = ecl_boole(ECL_BOOLIOR,(v5disjoint_tag),(v10));
     }
    }
L13:;
   }
   v7 = _ecl_cdr(v7);
L9:;
   if (Null(v7)){
    goto L31;
   }
   goto L8;
L31:;
  }
  T0 = ecl_boole(ECL_BOOLIOR,(v5disjoint_tag),(v4subtype_tag));
  T1 = ecl_boole(ECL_BOOLANDC2,(v6supertype_tag),(T0));
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = v4subtype_tag;
  cl_env_copy->values[0] = T1;
  return cl_env_copy->values[0];
 }
}
/* function definition for REGISTER-TYPE                                      */
/* optimize speed 1, debug 1, space 1, safety 0                               */
static cl_object L233register_type(cl_object v1type, cl_object v2in_our_family_p, cl_object v3type___)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = L228find_registered_tag(1, v1type);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = L229make_registered_tag(v1type, v2in_our_family_p, v3type___);
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for REGISTER-MEMBER-TYPE                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L234register_member_type(cl_object v1object)
{
 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 v2mtype;
  v2mtype = L220find_member_type(v1object);
  if (Null(v2mtype)){
   goto L3;
  }
  value0 = cl_second(v2mtype);
  return value0;
L3:;
  if (cl_realp(v1object)!=ECL_NIL) {
   goto L5;
  }
  value0 = L235simple_member_type(v1object);
  return value0;
L5:;
  if (!(floatp(v1object))){
   goto L7;
  }
  if (!(ecl_zerop(v1object))){
   goto L7;
  }
  T0 = cl_float_sign(1, v1object);
  if (!(ecl_minusp(T0))){
   goto L10;
  }
  value0 = L235simple_member_type(v1object);
  return value0;
L10:;
  T0 = L236number_member_type(v1object);
  T1 = ecl_negate(v1object);
  T2 = L234register_member_type(T1);
  value0 = ecl_boole(ECL_BOOLANDC2,(T0),(T2));
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  value0 = L236number_member_type(v1object);
  return value0;
 }
}
static cl_object L234register_member_type_va(cl_narg narg, cl_object v3object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[162]);
 {
  return L234register_member_type(v3object);
 }
}
/* function definition for SIMPLE-MEMBER-TYPE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L235simple_member_type(cl_object v1object)
{
 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 v2tag;
  v2tag = L226new_type_tag();
  L230maybe_save_types();
  T0 = L219make_member_type(4, ECL_SYM("OBJECT",1315), v1object, ECL_SYM("TAG",1352), v2tag);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[132]));
  ecl_cmp_setq(cl_env_copy,VV[132],T1);
  {
   cl_object v3;
   v3 = ecl_cmp_symbol_value(cl_env_copy,VV[133]);
   goto L10;
L9:;
   {
    cl_object v4i;
    v4i = ecl_car(v3);
    {
     cl_object v5type;
     v5type = cl_first(v4i);
     if (Null(cl_typep(2, v1object, v5type))){
      goto L14;
     }
     {
      cl_object v6;
      T0 = cl_second(v4i);
      v6 = ecl_boole(ECL_BOOLIOR,(v2tag),(T0));
      T0 = ecl_cdr(v4i);
      (ECL_CONS_CAR(T0)=v6,T0);
     }
    }
L14:;
   }
   v3 = ecl_cdr(v3);
L10:;
   if (Null(v3)){
    goto L20;
   }
   goto L9;
L20:;
  }
  value0 = v2tag;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for NUMBER-MEMBER-TYPE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L236number_member_type(cl_object v1object)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2base_type;
  cl_object v3type;
  if (!(ECL_FIXNUMP(v1object)||ECL_BIGNUMP(v1object))){
   goto L3;
  }
  v2base_type = ECL_SYM("INTEGER",439);
  goto L2;
L3:;
  v2base_type = cl_type_of(v1object);
L2:;
  v3type = cl_list(3, v2base_type, v1object, v1object);
  value0 = L228find_registered_tag(1, v3type);
  if (value0!=ECL_NIL) {
   goto L7;
  }
  value0 = L249canonical_interval_type(v3type);
  return value0;
L7:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L236number_member_type_va(cl_narg narg, cl_object v4object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[164]);
 {
  return L236number_member_type(v4object);
 }
}
/* function definition for REGISTER-SATISFIES-TYPE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L237register_satisfies_type(cl_object v1type)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 cl_env_copy->values[0] = ECL_SYM("SATISFIES",738);
 cl_env_copy->nvalues = 1;
 cl_throw(VV[169]);
}
/* function definition for REGISTER-CLASS                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L240register_class(cl_object v1class, cl_object v2env)
{
 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:;
 value0 = L228find_registered_tag(1, v1class);
 if (value0!=ECL_NIL) {
  goto L3;
 }
 {
  cl_object v3name;
  v3name = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-NAME */;
  if (Null(v3name)){
   goto L8;
  }
  T0 = cl_find_class(2, v3name, ECL_NIL);
  if (!((v1class)==(T0))){
   goto L8;
  }
  value0 = L228find_registered_tag(1, v3name);
  if (value0!=ECL_NIL) {
   goto L12;
  }
  value0 = L256find_built_in_tag(v3name, v2env);
  goto L5;
L12:;
  goto L5;
L8:;
  value0 = ECL_NIL;
  goto L5;
 }
L5:;
 if (value0!=ECL_NIL) {
  goto L3;
 }
 if ((cl_env_copy->function=(ECL_SYM("CLASS-FINALIZED-P",1567)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-FINALIZED-P */!=ECL_NIL) {
  goto L16;
 }
 cl_env_copy->values[0] = ECL_NIL;
 cl_env_copy->nvalues = 1;
 cl_throw(VV[169]);
L16:;
 value0 = ECL_NIL;
 goto L14;
L14:;
 if (value0!=ECL_NIL) {
  goto L3;
 }
 {
  cl_object v3;
  v3 = ecl_make_cfun_va((cl_objectfn)LC238__lambda606_va,ECL_NIL,Cblock,1);
  T0 = v3;
 }
 {
  cl_object v3;
  v3 = ecl_make_cfun_va((cl_objectfn)LC239__lambda608_va,ECL_NIL,Cblock,2);
  T1 = v3;
 }
 value0 = L233register_type(v1class, T0, T1);
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for REGISTER-ARRAY-TYPE                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L242register_array_type(cl_object v1type, cl_object v2env)
{
 cl_object T0, T1, T2;
 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;                                   /*  ELT-TYPE                */
  value0 = L244parse_array_type(v1type, v2env);
  {
   const int v4 = cl_env_copy->nvalues;
   env0 = ECL_NIL;
   CLV0 = env0 = CONS(value0,env0);               /*  ARRAY-CLASS             */
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
   v5 = (v4<=2)? ECL_NIL : cl_env_copy->values[2];
   CLV1 = env0 = CONS(v5,env0);                   /*  DIMENSIONS              */
  }
  if (!((v3)==(ECL_SYM("*",20)))){
   goto L3;
  }
  {
   cl_object v4;
   {
    cl_object v5;
    v5 = ecl_make_cclosure_va((cl_objectfn)LC241__lambda617,env0,Cblock,1);
    v4 = v5;
   }
   {
    cl_object v5;
    cl_object v6;
    cl_object v7;
    v5 = ecl_cmp_symbol_value(cl_env_copy,VV[83]);
    v6 = ECL_NIL;
    v7 = v5;
    {
     cl_object v8;
     cl_object v9;
     v8 = ecl_list1(ECL_NIL);
     v9 = v8;
L12:;
     v6 = ECL_CONS_CAR(v7);
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v7);
      value0 = ecl_make_bool(ECL_LISTP(v10));
      if (value0!=ECL_NIL) {
       goto L22;
      }
      T1 = ecl_make_bool(ECL_SYMBOLP(v10));
      goto L20;
L22:;
      T1 = value0;
      goto L20;
L20:;
      if (ecl_unlikely(!((T1)!=ECL_NIL)))
         FEwrong_type_argument(VV[178],v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v10;
     }
     {
      cl_object v10;
      v10 = v9;
      if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = v10;
     }
     T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v6);
     v9 = ecl_list1(T2);
     (ECL_CONS_CDR(T1)=v9,T1);
     if (!(ecl_endp(v7))){
      goto L30;
     }
     goto L13;
L30:;
     goto L12;
L13:;
     T0 = ecl_cdr(v8);
     goto L5;
    }
   }
  }
L5:;
  T1 = CONS(ECL_SYM("OR",616),T0);
  value0 = L260canonical_type(T1, v2env);
  return value0;
L3:;
  {
   cl_object v4;
   v1type = cl_list(3, ECL_CONS_CAR(CLV0), v3, ECL_CONS_CAR(CLV1));
   v4 = L228find_registered_tag(1, v1type);
   if (Null(v4)){
    goto L36;
   }
   value0 = v4;
   cl_env_copy->nvalues = 1;
   return value0;
L36:;
   T0 = (VV[179]->symbol.gfdef);
   T1 = (VV[180]->symbol.gfdef);
   value0 = L233register_type(v1type, T0, T1);
   return value0;
  }
 }
}
/* function definition for FAST-UPGRADED-ARRAY-ELEMENT-TYPE                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L243fast_upgraded_array_element_type(cl_object v1type, cl_object v2env)
{
 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 (!((v1type)==(ECL_SYM("*",20)))){
  goto L2;
 }
 value0 = ECL_SYM("*",20);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3;
  cl_object v4;
  cl_object v5;
  v3 = (ECL_SYM("EQ",335)->symbol.gfdef);
  v4 = v1type;
  v5 = VV[84];
  if (Null(si_memq(v4,v5))){
   goto L4;
  }
 }
 value0 = v1type;
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 {
  cl_object v3;
  v3 = ecl_cmp_symbol_value(cl_env_copy,VV[83]);
  goto L12;
L11:;
  {
   cl_object v4other_type;
   v4other_type = ecl_car(v3);
   if (Null(L262fast_subtypep(v1type, v4other_type, v2env))){
    goto L16;
   }
   value0 = v4other_type;
   cl_env_copy->nvalues = 1;
   return value0;
L16:;
  }
  v3 = ecl_cdr(v3);
L12:;
  if (Null(v3)){
   goto L20;
  }
  goto L11;
L20:;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for PARSE-ARRAY-TYPE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L244parse_array_type(cl_object v1input, cl_object v2env)
{
 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 v3type;
  cl_object v4name;
  cl_object v5elt_type;
  cl_object v6dims;
  v3type = v1input;
  {
   cl_object v7;
   v7 = v3type;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[48],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L8;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v3type = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L8:;
   v4name = v7;
  }
  if (Null(v3type)){
   goto L16;
  }
  {
   cl_object v7;
   v7 = v3type;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[48],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L22;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v3type = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L22:;
   T0 = v7;
   goto L15;
  }
L16:;
  T0 = ECL_SYM("*",20);
L15:;
  v5elt_type = L243fast_upgraded_array_element_type(T0, v2env);
  if (Null(v3type)){
   goto L29;
  }
  {
   cl_object v7;
   v7 = v3type;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[48],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L35;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v3type = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L35:;
   v6dims = v7;
   goto L28;
  }
L29:;
  v6dims = ECL_SYM("*",20);
L28:;
  if (Null(v3type)){
   goto L41;
  }
  cl_error(2, VV[185], v1input);
L41:;
  if (!(ecl_numberp(v6dims))){
   goto L44;
  }
  if (cl_L(3, ecl_make_int8_t(-1), v6dims, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("ARRAY-RANK-LIMIT",107)))!=ECL_NIL) {
   goto L46;
  }
  cl_error(2, VV[186], v1input);
L46:;
  T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("ARRAY-RANK-LIMIT",107)),v6dims);
  v6dims = ecl_nthcdr(ecl_to_size(T0),VV[187]);
  goto L43;
L44:;
  if (!(ECL_CONSP(v6dims))){
   goto L43;
  }
  {
   cl_object v7;
   v7 = v6dims;
   goto L53;
L52:;
   {
    cl_object v8i;
    v8i = ecl_car(v7);
    if ((v8i)==(ECL_SYM("*",20))) {
     goto L57;
    }
    if (!(ECL_FIXNUMP(v8i)||ECL_BIGNUMP(v8i))){
     goto L61;
    }
    if (cl_L(3, ecl_make_int8_t(-1), v8i, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("ARRAY-DIMENSION-LIMIT",100)))!=ECL_NIL) {
     goto L57;
    }
    goto L58;
L61:;
    goto L58;
L58:;
    cl_error(2, VV[188], v1input);
L57:;
   }
   v7 = ecl_cdr(v7);
L53:;
   if (Null(v7)){
    goto L65;
   }
   goto L52;
L65:;
  }
L43:;
  cl_env_copy->nvalues = 3;
  cl_env_copy->values[2] = v6dims;
  cl_env_copy->values[1] = v5elt_type;
  cl_env_copy->values[0] = v4name;
  return cl_env_copy->values[0];
 }
}
/* function definition for ARRAY-TYPE-<=                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L245array_type___(cl_object v1t1, cl_object v2t2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1t1);
 T1 = ecl_car(v2t2);
 if (!((T0)==(T1))){
  goto L5;
 }
 T0 = ecl_cadr(v1t1);
 T1 = ecl_cadr(v2t2);
 if ((T0)==(T1)) {
  goto L2;
 }
 goto L3;
L5:;
 goto L3;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3;
  cl_object v4;
  v3 = ecl_caddr(v1t1);
  v4 = ecl_caddr(v2t2);
  if (!((v4)==(ECL_SYM("*",20)))){
   goto L9;
  }
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  if (!((v3)==(ECL_SYM("*",20)))){
   goto L11;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L11:;
  {
   cl_object v5a;
   cl_object v6b;
   v5a = v3;
   v6b = v4;
   goto L17;
L16:;
   v5a = ecl_cdr(v5a);
   v6b = ecl_cdr(v6b);
L17:;
   if (ecl_endp(v5a)) {
    goto L22;
   }
   if (ecl_endp(v6b)) {
    goto L22;
   }
   T0 = ecl_car(v6b);
   if ((T0)==(ECL_SYM("*",20))) {
    goto L26;
   }
   T0 = ecl_car(v6b);
   T1 = ecl_car(v5a);
   if (!(ecl_eql(T0,T1))){
    goto L22;
   }
   goto L23;
L26:;
L23:;
   goto L16;
L22:;
   if (!(v5a==ECL_NIL)){
    goto L29;
   }
   value0 = ecl_make_bool(v6b==ECL_NIL);
   cl_env_copy->nvalues = 1;
   return value0;
L29:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L245array_type____va(cl_narg narg, cl_object v7t1, cl_object v8t2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[180]);
 {
  return L245array_type___(v7t1, v8t2);
 }
}
/* function definition for ARRAY-TYPE-P                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L246array_type_p(cl_object v1type)
{
 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_CONSP(v1type))){
  goto L3;
 }
 {
  cl_object v2;
  v2 = ecl_car(v1type);
  if (!((v2)==(ECL_SYM("COMPLEX-ARRAY",1880)))){
   goto L10;
  }
  value0 = VV[190];
  goto L8;
L10:;
  value0 = ECL_NIL;
  goto L8;
L8:;
  if (value0!=ECL_NIL) {
   goto L7;
  }
  if (!((v2)==(ECL_SYM("SIMPLE-ARRAY",766)))){
   goto L13;
  }
  value0 = VV[191];
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L246array_type_p_va(cl_narg narg, cl_object v3type, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[179]);
 {
  return L246array_type_p(v3type);
 }
}
/* function definition for NUMERIC-RANGE-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L247numeric_range_p(cl_object v1type)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_CONSP(v1type))){
  goto L3;
 }
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  v2 = ecl_car(v1type);
  v3 = v2;
  v4 = VV[194];
  if (Null(ecl_memql(v3,v4))){
   goto L3;
  }
 }
 T0 = ecl_cddr(v1type);
 value0 = ecl_make_bool(T0==ECL_NIL);
 if (value0!=ECL_NIL) {
  goto L10;
 }
 value0 = cl_error(2, VV[195], v1type);
 return value0;
L10:;
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L247numeric_range_p_va(cl_narg narg, cl_object v2type, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[193]);
 {
  return L247numeric_range_p(v2type);
 }
}
/* function definition for NUMERIC-RANGE-<=                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L248numeric_range___(cl_object v1i1, cl_object v2i2)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_car(v1i1);
 T1 = ecl_car(v2i2);
 if (!((T0)==(T1))){
  goto L3;
 }
 T0 = ecl_cadr(v2i2);
 T1 = ecl_cadr(v1i1);
 value0 = L251bounds___(T0, T1);
 return value0;
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L248numeric_range____va(cl_narg narg, cl_object v3i1, cl_object v4i2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[197]);
 {
  return L248numeric_range___(v3i1, v4i2);
 }
}
/* function definition for CANONICAL-INTERVAL-TYPE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L249canonical_interval_type(cl_object v1interval)
{
 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 v3type;
  cl_object v4low;
  cl_object v5high;
  v2 = v1interval;
  if (!(v2==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1interval);
L4:;
  {
   cl_object v6;
   v6 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v3type = v6;
  }
  if (Null(v2)){
   goto L10;
  }
  {
   cl_object v6;
   v6 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v4low = v6;
   goto L9;
  }
L10:;
  v4low = ECL_SYM("*",20);
L9:;
  if (Null(v2)){
   goto L16;
  }
  {
   cl_object v6;
   v6 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v5high = v6;
   goto L15;
  }
L16:;
  v5high = ECL_SYM("*",20);
L15:;
  if (Null(v2)){
   goto L21;
  }
  si_dm_too_many_arguments(v1interval);
L21:;
  {
   cl_object v6;
   cl_object v7;
   if (!((v5high)==(ECL_SYM("*",20)))){
    goto L24;
   }
   v6 = ecl_make_int8_t(0);
   goto L23;
L24:;
   if (!((v3type)==(ECL_SYM("INTEGER",439)))){
    goto L26;
   }
   if (!(ECL_CONSP(v5high))){
    goto L30;
   }
   T0 = ecl_car(v5high);
   v5high = ecl_ceiling1(T0);
   goto L29;
L30:;
   T0 = ecl_one_plus(v5high);
   v5high = ecl_floor1(T0);
L29:;
   v6 = L250register_interval_type(v3type, v5high);
   goto L23;
L26:;
   if (!(ECL_CONSP(v5high))){
    goto L32;
   }
   T0 = ecl_car(v5high);
   v6 = L250register_interval_type(v3type, T0);
   goto L23;
L32:;
   T0 = ecl_list1(v5high);
   v6 = L250register_interval_type(v3type, T0);
L23:;
   if (!((v4low)==(ECL_SYM("*",20)))){
    goto L35;
   }
   v7 = L250register_interval_type(v3type, v4low);
   goto L34;
L35:;
   if (!((v3type)==(ECL_SYM("INTEGER",439)))){
    goto L37;
   }
   if (!(ECL_CONSP(v4low))){
    goto L41;
   }
   T0 = ecl_car(v4low);
   T1 = ecl_one_plus(T0);
   v4low = ecl_floor1(T1);
   goto L40;
L41:;
   v4low = ecl_ceiling1(v4low);
L40:;
   v7 = L250register_interval_type(v3type, v4low);
   goto L34;
L37:;
   v7 = L250register_interval_type(v3type, v4low);
L34:;
   value0 = ecl_boole(ECL_BOOLANDC2,(v7),(v6));
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for REGISTER-INTERVAL-TYPE                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L250register_interval_type(cl_object v1type, cl_object v2b)
{
 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:;
 v1type = cl_list(2, v1type, v2b);
 T0 = (ECL_SYM("EQUALP",338)->symbol.gfdef);
 value0 = L228find_registered_tag(2, v1type, T0);
 if (value0!=ECL_NIL) {
  goto L5;
 }
 T0 = (VV[193]->symbol.gfdef);
 T1 = (VV[197]->symbol.gfdef);
 value0 = L229make_registered_tag(v1type, T0, T1);
 return value0;
L5:;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for BOUNDS-<=                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L251bounds___(cl_object v1b1, cl_object v2b2)
{
 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 (!((v1b1)==(ECL_SYM("*",20)))){
  goto L2;
 }
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v2b2)==(ECL_SYM("*",20)))){
  goto L4;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 if (!(ECL_CONSP(v1b1))){
  goto L6;
 }
 if (!(ECL_CONSP(v2b2))){
  goto L8;
 }
 T0 = ecl_car(v1b1);
 T1 = ecl_car(v2b2);
 value0 = ecl_make_bool(ecl_lowereq(T0,T1));
 cl_env_copy->nvalues = 1;
 return value0;
L8:;
 T0 = ecl_car(v1b1);
 value0 = ecl_make_bool(ecl_lower(T0,v2b2));
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (!(ECL_CONSP(v2b2))){
  goto L10;
 }
 T0 = ecl_car(v2b2);
 value0 = ecl_make_bool(ecl_lowereq(v1b1,T0));
 cl_env_copy->nvalues = 1;
 return value0;
L10:;
 value0 = ecl_make_bool(ecl_lowereq(v1b1,v2b2));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L251bounds____va(cl_narg narg, cl_object v3b1, cl_object v4b2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[198]);
 {
  return L251bounds___(v3b1, v4b2);
 }
}
/* function definition for CANONICAL-COMPLEX-TYPE                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L252canonical_complex_type(cl_object v1complex_type, cl_object v2env)
{
 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 v5real_type;
  v3 = ecl_cdr(v1complex_type);
  v4 = v3;
  if (Null(v4)){
   goto L5;
  }
  {
   cl_object v6;
   v6 = ecl_car(v4);
   v4 = ecl_cdr(v4);
   v5real_type = v6;
   goto L4;
  }
L5:;
  v5real_type = ECL_SYM("REAL",706);
L4:;
  if (Null(v4)){
   goto L10;
  }
  si_dm_too_many_arguments(v3);
L10:;
  if (!((v5real_type)==(ECL_SYM("*",20)))){
   goto L12;
  }
  v5real_type = ECL_SYM("REAL",706);
L12:;
  {
   cl_object v6upgraded_real;
   cl_object v7upgraded_type;
   v6upgraded_real = cl_upgraded_complex_part_type(2, v5real_type, v2env);
   v7upgraded_type = cl_list(2, ECL_SYM("COMPLEX",243), v6upgraded_real);
   value0 = L228find_registered_tag(1, v7upgraded_type);
   if (value0!=ECL_NIL) {
    goto L18;
   }
   if (Null(L254complex_float_feature(v2env))){
    goto L22;
   }
   if (!((v6upgraded_real)==(ECL_SYM("REAL",706)))){
    goto L24;
   }
   T0 = L252canonical_complex_type(VV[203], v2env);
   T1 = L252canonical_complex_type(VV[204], v2env);
   T2 = L252canonical_complex_type(VV[205], v2env);
   T3 = L252canonical_complex_type(VV[206], v2env);
   value0 = cl_logior(4, T0, T1, T2, T3);
   goto L20;
L24:;
   if (!((v6upgraded_real)==(ECL_SYM("FLOAT",376)))){
    goto L26;
   }
   T0 = L252canonical_complex_type(VV[203], v2env);
   T1 = L252canonical_complex_type(VV[204], v2env);
   T2 = L252canonical_complex_type(VV[205], v2env);
   value0 = cl_logior(3, T0, T1, T2);
   goto L20;
L26:;
   value0 = ECL_NIL;
   goto L20;
L22:;
   value0 = ECL_NIL;
   goto L20;
L20:;
   if (value0!=ECL_NIL) {
    goto L18;
   }
   value0 = L253register_complex_type(v7upgraded_type);
   return value0;
L18:;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for REGISTER-COMPLEX-TYPE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L253register_complex_type(cl_object v1upgraded_type)
{
 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 v2tag;
  v2tag = L226new_type_tag();
  value0 = L227push_new_type(v1upgraded_type, v2tag);
  return value0;
 }
}
/* function definition for COMPLEX-FLOAT-FEATURE                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L254complex_float_feature(cl_object v1env)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = ecl_car(v1env);
  goto L6;
L5:;
  {
   cl_object v3record;
   v3record = ecl_car(v2);
   if (!(ECL_CONSP(v3record))){
    goto L10;
   }
   T0 = ecl_car(v3record);
   if (!((T0)==(ECL_SYM("DECLARE",990)))){
    goto L10;
   }
   T0 = ecl_cadr(v3record);
   if (!((T0)==(VV[208]))){
    goto L10;
   }
   T0 = ecl_caddr(v3record);
   if (!((T0)==(VV[209]))){
    goto L10;
   }
   value0 = ecl_cadddr(v3record);
   cl_env_copy->nvalues = 1;
   return value0;
L10:;
  }
  v2 = ecl_cdr(v2);
L6:;
  if (Null(v2)){
   goto L17;
  }
  goto L5;
L17:;
 }
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for REGISTER-CONS-TYPE                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L255register_cons_type(cl_narg narg, cl_object v1env, ...)
{
 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[210]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[210]);
 {
  cl_object v2car_type;
  cl_object v3cdr_type;
  va_list args; va_start(args,v1env);
  {
   int i = 1;
   if (i >= narg) {
    v2car_type = ECL_SYM("*",20);
   } else {
    i++;
    v2car_type = va_arg(args,cl_object);
   }
   if (i >= narg) {
    v3cdr_type = ECL_SYM("*",20);
   } else {
    i++;
    v3cdr_type = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4;
   cl_object v5;
   if (!((v2car_type)==(ECL_SYM("*",20)))){
    goto L4;
   }
   v4 = ecl_make_int8_t(-1);
   goto L3;
L4:;
   v4 = L260canonical_type(v2car_type, v1env);
L3:;
   if (!((v3cdr_type)==(ECL_SYM("*",20)))){
    goto L7;
   }
   v5 = ecl_make_int8_t(-1);
   goto L6;
L7:;
   v5 = L260canonical_type(v3cdr_type, v1env);
L6:;
   if (ecl_number_equalp(v4,ecl_cmp_symbol_value(cl_env_copy,VV[130]))) {
    goto L11;
   }
   if (!(ecl_number_equalp(v5,ecl_cmp_symbol_value(cl_env_copy,VV[130])))){
    goto L9;
   }
   goto L10;
L11:;
L10:;
   value0 = ecl_make_int8_t(0);
   cl_env_copy->nvalues = 1;
   return value0;
L9:;
   if (!(ecl_number_equalp(v4,ecl_cmp_symbol_value(cl_env_copy,VV[129])))){
    goto L13;
   }
   if (!(ecl_number_equalp(v5,ecl_cmp_symbol_value(cl_env_copy,VV[129])))){
    goto L13;
   }
   value0 = L260canonical_type(ECL_SYM("CONS",253), v1env);
   return value0;
L13:;
   cl_env_copy->values[0] = ECL_SYM("CONS",253);
   cl_env_copy->nvalues = 1;
   cl_throw(VV[169]);
  }
 }
}
/* function definition for FIND-BUILT-IN-TAG                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L256find_built_in_tag(cl_object v1name, cl_object v2env)
{
 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 (!((v1name)==(ECL_T))){
  goto L2;
 }
 value0 = ecl_make_int8_t(-1);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!((v1name)==(ECL_NIL))){
  goto L4;
 }
 value0 = ecl_make_int8_t(0);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 {
  cl_object v3;
  {
   cl_object v4;                                  /*  RECORD                  */
   cl_object v5;                                  /*  FOUNDP                  */
   value0 = cl_gethash(2, v1name, ecl_cmp_symbol_value(cl_env_copy,VV[212]));
   {
    v4 = value0;
    v5 = cl_env_copy->values[1];
   }
   if (!(v5==ECL_NIL)){
    goto L8;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L8:;
   {
    cl_object v6alias;
    {
     cl_object v7;
     v7 = v4;
     {
      cl_object v8;
      v8 = v7;
      {
       bool v9;
       v9 = ECL_LISTP(v8);
       if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[48],v8);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v7)){
      goto L15;
     }
     {
      cl_object v8;
      v8 = ECL_CONS_CDR(v7);
      v4 = v8;
      v7 = ECL_CONS_CAR(v7);
     }
L15:;
     v6alias = v7;
    }
    if (Null(v6alias)){
     goto L21;
    }
    v3 = L260canonical_type(v6alias, v2env);
    goto L6;
L21:;
    {
     cl_object v7strict_supertype;
     cl_object v8strict_supertype_tag;
     cl_object v9new_type_tag;
     value0 = ecl_car(v4);
     if (value0!=ECL_NIL) {
      goto L25;
     }
     v7strict_supertype = ECL_T;
     goto L23;
L25:;
     v7strict_supertype = value0;
     goto L23;
L23:;
     v8strict_supertype_tag = L260canonical_type(v7strict_supertype, v2env);
     v9new_type_tag = L226new_type_tag();
     if ((v7strict_supertype)==(ECL_T)) {
      goto L29;
     }
     L257extend_type_tag(v9new_type_tag, v8strict_supertype_tag);
L29:;
     v3 = L227push_new_type(v1name, v9new_type_tag);
    }
   }
  }
L6:;
  if (Null(v3)){
   goto L31;
  }
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
L31:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for EXTEND-TYPE-TAG                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L257extend_type_tag(cl_object v1tag, cl_object v2minimal_supertype_tag)
{
 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_cmp_symbol_value(cl_env_copy,VV[133]);
  goto L5;
L4:;
  {
   cl_object v4type;
   v4type = ecl_car(v3);
   {
    cl_object v5other_tag;
    v5other_tag = cl_second(v4type);
    T0 = ecl_boole(ECL_BOOLANDC2,(v2minimal_supertype_tag),(v5other_tag));
    if (!(ecl_zerop(T0))){
     goto L9;
    }
    {
     cl_object v6;
     v6 = ecl_boole(ECL_BOOLIOR,(v1tag),(v5other_tag));
     T0 = ecl_cdr(v4type);
     (ECL_CONS_CAR(T0)=v6,T0);
    }
   }
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 CANONICAL-TYPE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L260canonical_type(cl_object v1type, cl_object v2env)
{
 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);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v2env,env0);                  /*  ENV                     */
 if (Null(ECL_CONS_CAR(CLV0))){
  goto L1;
 }
 v1type = L265search_type_in_env(v1type, ECL_CONS_CAR(CLV0));
L1:;
 {
  cl_object v3;
  v3 = L228find_registered_tag(1, v1type);
  if (Null(v3)){
   goto L5;
  }
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  if (!((v1type)==(ECL_T))){
   goto L7;
  }
  value0 = ecl_make_int8_t(-1);
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  if (!((v1type)==(ECL_NIL))){
   goto L9;
  }
  value0 = ecl_make_int8_t(0);
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  if (!(ECL_SYMBOLP(v1type))){
   goto L11;
  }
  {
   cl_object v4expander;
   v4expander = si_get_sysprop(v1type, VV[15]);
   if (Null(v4expander)){
    goto L14;
   }
   T1 = ecl_list1(v1type);
   T0 = ecl_function_dispatch(cl_env_copy,v4expander)(2, T1, ECL_CONS_CAR(CLV0));
   value0 = L260canonical_type(T0, ECL_CONS_CAR(CLV0));
   return value0;
L14:;
   {
    cl_object v5;
    v5 = L256find_built_in_tag(v1type, ECL_CONS_CAR(CLV0));
    if (Null(v5)){
     goto L18;
    }
    value0 = v5;
    cl_env_copy->nvalues = 1;
    return value0;
L18:;
    {
     cl_object v6class;
     v6class = cl_find_class(2, v1type, ECL_NIL);
     if (Null(v6class)){
      goto L21;
     }
     value0 = L240register_class(v6class, ECL_CONS_CAR(CLV0));
     return value0;
L21:;
     cl_env_copy->values[0] = ECL_NIL;
     cl_env_copy->nvalues = 1;
     cl_throw(VV[169]);
    }
   }
  }
L11:;
  if (!(ECL_CONSP(v1type))){
   goto L24;
  }
  {
   cl_object v7;
   v7 = ecl_car(v1type);
   if (!((v7)==(ECL_SYM("AND",89)))){
    goto L27;
   }
   T0 = (ECL_SYM("LOGAND",494)->symbol.gfdef);
   {
    cl_object v8;
    {
     cl_object v9;
     v9 = ecl_make_cclosure_va((cl_objectfn)LC258__lambda719,env0,Cblock,1);
     v8 = v9;
    }
    {
     cl_object v9;
     cl_object v10;
     cl_object v11;
     {
      cl_object v12;
      v12 = ecl_cdr(v1type);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     v10 = ECL_NIL;
     v11 = v9;
     {
      cl_object v12;
      cl_object v13;
      v12 = ecl_list1(ECL_NIL);
      v13 = v12;
L39:;
      if (!(ecl_endp(v11))){
       goto L41;
      }
      goto L40;
L41:;
      v10 = ECL_CONS_CAR(v11);
      {
       cl_object v14;
       v14 = ECL_CONS_CDR(v11);
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      {
       cl_object v14;
       v14 = v13;
       if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v14;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v8)(1, v10);
      v13 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v13,T2);
      goto L39;
L40:;
      T1 = ecl_cdr(v12);
      goto L30;
     }
    }
   }
L30:;
   value0 = cl_apply(2, T0, T1);
   return value0;
L27:;
   if (!((v7)==(ECL_SYM("OR",616)))){
    goto L57;
   }
   T0 = (ECL_SYM("LOGIOR",502)->symbol.gfdef);
   {
    cl_object v8;
    {
     cl_object v9;
     v9 = ecl_make_cclosure_va((cl_objectfn)LC259__lambda728,env0,Cblock,1);
     v8 = v9;
    }
    {
     cl_object v9;
     cl_object v10;
     cl_object v11;
     {
      cl_object v12;
      v12 = ecl_cdr(v1type);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     v10 = ECL_NIL;
     v11 = v9;
     {
      cl_object v12;
      cl_object v13;
      v12 = ecl_list1(ECL_NIL);
      v13 = v12;
L69:;
      if (!(ecl_endp(v11))){
       goto L71;
      }
      goto L70;
L71:;
      v10 = ECL_CONS_CAR(v11);
      {
       cl_object v14;
       v14 = ECL_CONS_CDR(v11);
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      {
       cl_object v14;
       v14 = v13;
       if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v14;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v8)(1, v10);
      v13 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v13,T2);
      goto L69;
L70:;
      T1 = ecl_cdr(v12);
      goto L60;
     }
    }
   }
L60:;
   value0 = cl_apply(2, T0, T1);
   return value0;
L57:;
   if (!((v7)==(ECL_SYM("NOT",586)))){
    goto L87;
   }
   T0 = ecl_cadr(v1type);
   T1 = L260canonical_type(T0, ECL_CONS_CAR(CLV0));
   value0 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
   cl_env_copy->nvalues = 1;
   return value0;
L87:;
   if (!((v7)==(ECL_SYM("EQL",336)))){
    goto L94;
   }
   goto L91;
L94:;
   goto L92;
L92:;
   if (!((v7)==(ECL_SYM("MEMBER",554)))){
    goto L89;
   }
   goto L90;
L91:;
L90:;
   T0 = (ECL_SYM("LOGIOR",502)->symbol.gfdef);
   {
    cl_object v8;
    v8 = (VV[162]->symbol.gfdef);
    {
     cl_object v9;
     cl_object v10;
     cl_object v11;
     {
      cl_object v12;
      v12 = ecl_cdr(v1type);
      if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v12;
     }
     v10 = ECL_NIL;
     v11 = v9;
     {
      cl_object v12;
      cl_object v13;
      v12 = ecl_list1(ECL_NIL);
      v13 = v12;
L107:;
      if (!(ecl_endp(v11))){
       goto L109;
      }
      goto L108;
L109:;
      v10 = ECL_CONS_CAR(v11);
      {
       cl_object v14;
       v14 = ECL_CONS_CDR(v11);
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      {
       cl_object v14;
       v14 = v13;
       if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v14;
      }
      T3 = ecl_function_dispatch(cl_env_copy,v8)(1, v10);
      v13 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v13,T2);
      goto L107;
L108:;
      T1 = ecl_cdr(v12);
      goto L98;
     }
    }
   }
L98:;
   value0 = cl_apply(2, T0, T1);
   return value0;
L89:;
   if (!((v7)==(ECL_SYM("SATISFIES",738)))){
    goto L125;
   }
   value0 = L237register_satisfies_type(v1type);
   return value0;
L125:;
   {
    cl_object v8;
    cl_object v9;
    v8 = v7;
    v9 = VV[216];
    if (Null(ecl_memql(v8,v9))){
     goto L127;
    }
   }
   value0 = L249canonical_interval_type(v1type);
   return value0;
L127:;
   if (!((v7)==(ECL_SYM("FLOAT",376)))){
    goto L131;
   }
   T0 = ecl_cdr(v1type);
   T1 = CONS(ECL_SYM("SINGLE-FLOAT",781),T0);
   T2 = ecl_cdr(v1type);
   T3 = CONS(ECL_SYM("DOUBLE-FLOAT",317),T2);
   T4 = ecl_cdr(v1type);
   T5 = CONS(ECL_SYM("LONG-FLOAT",510),T4);
   T6 = cl_list(4, ECL_SYM("OR",616), T1, T3, T5);
   value0 = L260canonical_type(T6, ECL_CONS_CAR(CLV0));
   return value0;
L131:;
   if (!((v7)==(ECL_SYM("REAL",706)))){
    goto L134;
   }
   T0 = ecl_cdr(v1type);
   T1 = CONS(ECL_SYM("INTEGER",439),T0);
   T2 = ecl_cdr(v1type);
   T3 = CONS(ECL_SYM("RATIO",689),T2);
   T4 = ecl_cdr(v1type);
   T5 = CONS(ECL_SYM("SINGLE-FLOAT",781),T4);
   T6 = ecl_cdr(v1type);
   T7 = CONS(ECL_SYM("DOUBLE-FLOAT",317),T6);
   T8 = ecl_cdr(v1type);
   T9 = CONS(ECL_SYM("LONG-FLOAT",510),T8);
   T10 = cl_list(6, ECL_SYM("OR",616), T1, T3, T5, T7, T9);
   value0 = L260canonical_type(T10, ECL_CONS_CAR(CLV0));
   return value0;
L134:;
   if (!((v7)==(ECL_SYM("RATIONAL",690)))){
    goto L137;
   }
   T0 = ecl_cdr(v1type);
   T1 = CONS(ECL_SYM("INTEGER",439),T0);
   T2 = ecl_cdr(v1type);
   T3 = CONS(ECL_SYM("RATIO",689),T2);
   T4 = cl_list(3, ECL_SYM("OR",616), T1, T3);
   value0 = L260canonical_type(T4, ECL_CONS_CAR(CLV0));
   return value0;
L137:;
   if (!((v7)==(ECL_SYM("COMPLEX",243)))){
    goto L140;
   }
   value0 = L252canonical_complex_type(v1type, ECL_CONS_CAR(CLV0));
   return value0;
L140:;
   if (!((v7)==(ECL_SYM("CONS",253)))){
    goto L142;
   }
   T0 = (VV[210]->symbol.gfdef);
   T1 = ecl_cdr(v1type);
   value0 = cl_apply(3, T0, ECL_CONS_CAR(CLV0), T1);
   return value0;
L142:;
   if (!((v7)==(ECL_SYM("ARRAY",98)))){
    goto L145;
   }
   T0 = ecl_cdr(v1type);
   T1 = CONS(ECL_SYM("COMPLEX-ARRAY",1880),T0);
   T2 = L242register_array_type(T1, ECL_CONS_CAR(CLV0));
   T3 = ecl_cdr(v1type);
   T4 = CONS(ECL_SYM("SIMPLE-ARRAY",766),T3);
   T5 = L242register_array_type(T4, ECL_CONS_CAR(CLV0));
   value0 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
   cl_env_copy->nvalues = 1;
   return value0;
L145:;
   if (!((v7)==(ECL_SYM("COMPLEX-ARRAY",1880)))){
    goto L152;
   }
   goto L149;
L152:;
   goto L150;
L150:;
   if (!((v7)==(ECL_SYM("SIMPLE-ARRAY",766)))){
    goto L147;
   }
   goto L148;
L149:;
L148:;
   value0 = L242register_array_type(v1type, ECL_CONS_CAR(CLV0));
   return value0;
L147:;
   if (!((v7)==(ECL_SYM("FUNCTION",398)))){
    goto L155;
   }
   value0 = L260canonical_type(ECL_SYM("FUNCTION",398), ECL_CONS_CAR(CLV0));
   return value0;
L155:;
   {
    cl_object v8expander;
    T0 = ecl_car(v1type);
    v8expander = si_get_sysprop(T0, VV[15]);
    if (Null(v8expander)){
     goto L158;
    }
    T0 = ecl_function_dispatch(cl_env_copy,v8expander)(2, v1type, ECL_CONS_CAR(CLV0));
    value0 = L260canonical_type(T0, ECL_CONS_CAR(CLV0));
    return value0;
L158:;
    T0 = ecl_car(v1type);
    T1 = (ECL_SYM("EQL",336)->symbol.gfdef);
    value0 = L228find_registered_tag(2, T0, T1);
    if (value0!=ECL_NIL) {
     goto L162;
    }
    cl_env_copy->values[0] = ECL_NIL;
    cl_env_copy->nvalues = 1;
    cl_throw(VV[169]);
L162:;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
L24:;
  if (Null((cl_env_copy->function=(VV[114]->symbol.gfdef))->cfun.entry(1, v1type) /*  CLASSP */)){
   goto L166;
  }
  value0 = L240register_class(v1type, ECL_CONS_CAR(CLV0));
  return value0;
L166:;
  if (Null(cl_fboundp(VV[220]))){
   goto L168;
  }
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[220]))->cfun.entry(1, v1type) /*  FUNCTION-TYPE-P */)){
   goto L168;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[221]))->cfun.entry(1, v1type) /*  REGISTER-FUNCTION-TYPE */;
  return value0;
L168:;
  if (Null(cl_fboundp(VV[222]))){
   goto L171;
  }
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[222]))->cfun.entry(1, v1type) /*  VALUES-TYPE-P */)){
   goto L171;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[223]))->cfun.entry(1, v1type) /*  REGISTER-VALUES-TYPE */;
  return value0;
L171:;
  value0 = L212error_type_specifier(v1type);
  return value0;
 }
}
static cl_object L260canonical_type_va(cl_narg narg, cl_object v9type, cl_object v10env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[176]);
 {
  return L260canonical_type(v9type, v10env);
 }
}
/* function definition for SAFE-CANONICAL-TYPE                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L261safe_canonical_type(cl_object volatile v1type, cl_object volatile v2env)
{
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = VV[169];                                /*  BEGIN CATCH CATCH832    */
 {
  ecl_frs_push(cl_env_copy,value0);
  if (__ecl_frs_push_result!=0) {
   value0 = cl_env_copy->values[0];
  } else {
   value0 = L260canonical_type(v1type, v2env);
  }
 }
 ecl_frs_pop(cl_env_copy);                        /*  END CATCH CATCH832      */
 return value0;
}
static cl_object L261safe_canonical_type_va(cl_narg narg, cl_object v3type, cl_object v4env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[225]);
 {
  return L261safe_canonical_type(v3type, v4env);
 }
}
/* function definition for FAST-SUBTYPEP                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L262fast_subtypep(cl_object v1t1, cl_object v2t2, cl_object v3env)
{
 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 (!((v1t1)==(v2t2))){
  goto L2;
 }
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_T;
 cl_env_copy->values[0] = ECL_T;
 return cl_env_copy->values[0];
L2:;
 {
  cl_object v4tag1;
  cl_object v5tag2;
  v4tag1 = L261safe_canonical_type(v1t1, v3env);
  v5tag2 = L261safe_canonical_type(v2t2, v3env);
  if (!(ecl_numberp(v4tag1))){
   goto L6;
  }
  if (!(ecl_numberp(v5tag2))){
   goto L6;
  }
  v4tag1 = L261safe_canonical_type(v1t1, v3env);
  v5tag2 = L261safe_canonical_type(v2t2, v3env);
L6:;
  if (!(ecl_numberp(v4tag1))){
   goto L12;
  }
  if (!(ecl_numberp(v5tag2))){
   goto L12;
  }
  T0 = ecl_boole(ECL_BOOLANDC2,(v4tag1),(v5tag2));
  {
   bool v6;
   v6 = ecl_zerop(T0);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = ecl_make_bool(v6);
   return cl_env_copy->values[0];
  }
L12:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
/* function definition for SUBTYPEP                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_subtypep(cl_narg narg, cl_object v1t1, cl_object v2t2, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(ECL_SYM("SUBTYPEP",840));
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(ECL_SYM("SUBTYPEP",840));
 {
  cl_object v3env;
  va_list args; va_start(args,v2t2);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ECL_NIL;
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!((v1t1)==(v2t2))){
   goto L2;
  }
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_T;
  cl_env_copy->values[0] = ECL_T;
  return cl_env_copy->values[0];
L2:;
  if (!(ECL_INSTANCEP(v1t1))){
   goto L4;
  }
  if (!(ECL_INSTANCEP(v2t2))){
   goto L4;
  }
  if (Null((cl_env_copy->function=(VV[114]->symbol.gfdef))->cfun.entry(1, v1t1) /*  CLASSP */)){
   goto L4;
  }
  if (Null((cl_env_copy->function=(VV[114]->symbol.gfdef))->cfun.entry(1, v2t2) /*  CLASSP */)){
   goto L4;
  }
  T0 = si_subclassp(2, v1t1, v2t2);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_T;
  cl_env_copy->values[0] = T0;
  return cl_env_copy->values[0];
L4:;
  {
   cl_object v4cache;
   uint8_t v5hash;
   cl_object v6elt;
   v4cache = ecl_cmp_symbol_value(cl_env_copy,VV[5]);
   T0 = si_hash_eql(2, v1t1, v2t2);
   v5hash = ecl_to_uint8_t(ecl_boole(ECL_BOOLAND,(T0),(ecl_make_uint8_t(255))));
   {
    cl_object v7;
    v7 = v4cache;
    T0 = v7;
    {
     cl_object v8;
     v8 = ecl_make_uint8_t(v5hash);
     if (ecl_unlikely((ecl_fixnum(v8))>=(v7)->vector.dim))
           FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v8)),(v7)->vector.dim);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v8;
    }
    v6elt = ecl_aref_unsafe(T0,ecl_fixnum(T1));
   }
   if (Null(v6elt)){
    goto L18;
   }
   T0 = ecl_caar(v6elt);
   if (!((T0)==(v1t1))){
    goto L18;
   }
   T0 = ecl_cdar(v6elt);
   if (!((T0)==(v2t2))){
    goto L18;
   }
   v6elt = ecl_cdr(v6elt);
   T0 = ecl_car(v6elt);
   T1 = ecl_cdr(v6elt);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = T1;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
L18:;
   {
    cl_object v7;
    cl_object v8;
    cl_object v9;
    v7 = ecl_cmp_symbol_value(cl_env_copy,VV[128]);
    v8 = ecl_cmp_symbol_value(cl_env_copy,VV[132]);
    v9 = ecl_cmp_symbol_value(cl_env_copy,VV[133]);
    ecl_bds_bind(cl_env_copy,VV[128],v7);         /*  *HIGHEST-TYPE-TAG*      */
    ecl_bds_bind(cl_env_copy,VV[127],ECL_T);      /*  *SAVE-TYPES-DATABASE*   */
    ecl_bds_bind(cl_env_copy,VV[132],v8);         /*  *MEMBER-TYPES*          */
    ecl_bds_bind(cl_env_copy,VV[133],v9);         /*  *ELEMENTARY-TYPES*      */
    {
     cl_object v10;                               /*  TEST                    */
     cl_object v11;                               /*  CONFIDENT               */
     value0 = L262fast_subtypep(v1t1, v2t2, v3env);
     {
      const int v12 = cl_env_copy->nvalues;
      v10 = value0;
      cl_object v13;
      v13 = (v12<=1)? ECL_NIL : cl_env_copy->values[1];
      v11 = v13;
     }
     {
      cl_object v12;
      v12 = v4cache;
      T0 = v12;
      {
       cl_object v13;
       v13 = ecl_make_uint8_t(v5hash);
       if (ecl_unlikely((ecl_fixnum(v13))>=(v12)->vector.dim))
           FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v13)),(v12)->vector.dim);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v13;
      }
      T2 = CONS(v1t1,v2t2);
      T3 = cl_listX(3, T2, v10, v11);
      ecl_aset_unsafe(T0,ecl_fixnum(T1),T3);
     }
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = v11;
     cl_env_copy->values[0] = v10;
     ecl_bds_unwind_n(cl_env_copy,4);
     return cl_env_copy->values[0];
    }
   }
  }
 }
}
/* function definition for FAST-TYPE=                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L263fast_type_(cl_object v1t1, cl_object v2t2, cl_object v3env)
{
 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 (!((v1t1)==(v2t2))){
  goto L2;
 }
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = ECL_T;
 cl_env_copy->values[0] = ECL_T;
 return cl_env_copy->values[0];
L2:;
 {
  cl_object v4;
  cl_object v5;
  cl_object v6;
  cl_object v7tag1;
  cl_object v8tag2;
  v4 = L261safe_canonical_type(v1t1, v3env);
  v5 = L261safe_canonical_type(v2t2, v3env);
  v6 = L261safe_canonical_type(ECL_SYM("COMPLEX",243), v3env);
  v7tag1 = v4;
  v8tag2 = v5;
  if (!(ecl_numberp(v7tag1))){
   goto L9;
  }
  if (!(ecl_numberp(v8tag2))){
   goto L9;
  }
  if (!(!ecl_number_equalp(v8tag2,v6))){
   goto L9;
  }
  v7tag1 = L261safe_canonical_type(v1t1, v3env);
  v8tag2 = L261safe_canonical_type(v2t2, v3env);
L9:;
  if (!(ecl_numberp(v7tag1))){
   goto L16;
  }
  if (!(ecl_numberp(v8tag2))){
   goto L16;
  }
  if (!(!ecl_number_equalp(v8tag2,v6))){
   goto L16;
  }
  {
   bool v9;
   v9 = ecl_number_equalp(v7tag1,v8tag2);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_T;
   cl_env_copy->values[0] = ecl_make_bool(v9);
   return cl_env_copy->values[0];
  }
L16:;
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
/* function definition for TYPE=                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L264type_(cl_narg narg, cl_object v1t1, cl_object v2t2, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[228]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[228]);
 {
  cl_object v3env;
  va_list args; va_start(args,v2t2);
  {
   int i = 2;
   if (i >= narg) {
    v3env = ECL_NIL;
   } else {
    i++;
    v3env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v4;
   cl_object v5;
   cl_object v6;
   v4 = ecl_cmp_symbol_value(cl_env_copy,VV[128]);
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[132]);
   v6 = ecl_cmp_symbol_value(cl_env_copy,VV[133]);
   ecl_bds_bind(cl_env_copy,VV[128],v4);          /*  *HIGHEST-TYPE-TAG*      */
   ecl_bds_bind(cl_env_copy,VV[127],ECL_T);       /*  *SAVE-TYPES-DATABASE*   */
   ecl_bds_bind(cl_env_copy,VV[132],v5);          /*  *MEMBER-TYPES*          */
   ecl_bds_bind(cl_env_copy,VV[133],v6);          /*  *ELEMENTARY-TYPES*      */
   value0 = L263fast_type_(v1t1, v2t2, v3env);
   ecl_bds_unwind_n(cl_env_copy,4);
   return value0;
  }
 }
}
/* function definition for SEARCH-TYPE-IN-ENV                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L265search_type_in_env(cl_object v1type, cl_object v2env)
{
 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 v3type_name;
  cl_object v4type_args;
  v3type_name = v1type;
  v4type_args = ECL_NIL;
  if (!(ECL_CONSP(v1type))){
   goto L5;
  }
  v3type_name = ecl_car(v1type);
  v4type_args = ecl_cdr(v1type);
L5:;
  {
   cl_object v5;
   v5 = ecl_car(v2env);
   goto L13;
L12:;
   {
    cl_object v6record;
    v6record = ecl_car(v5);
    if (!(ECL_CONSP(v6record))){
     goto L17;
    }
    T0 = ecl_car(v6record);
    if (!((T0)==(ECL_SYM("TYPE",1356)))){
     goto L17;
    }
    T0 = ecl_cadr(v6record);
    if (!((T0)==(v3type_name))){
     goto L17;
    }
    T0 = ecl_caddr(v6record);
    if (Null(cl_functionp(T0))){
     goto L21;
    }
    T0 = ecl_caddr(v6record);
    T1 = CONS(v3type_name,v4type_args);
    value0 = ecl_function_dispatch(cl_env_copy,T0)(2, T1, v2env);
    return value0;
L21:;
    value0 = ecl_caddr(v6record);
    cl_env_copy->nvalues = 1;
    return value0;
L17:;
   }
   v5 = ecl_cdr(v5);
L13:;
   if (Null(v5)){
    goto L25;
   }
   goto L12;
L25:;
  }
 }
 value0 = v1type;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L265search_type_in_env_va(cl_narg narg, cl_object v3type, cl_object v4env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[94]);
 {
  return L265search_type_in_env(v3type, v4env);
 }
}
/* closure LAMBDA24                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC176__lambda24(cl_narg narg, ...)
{
 cl_object CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV0 = env0;                                     /*  N                       */
 { /* ... closure scanning finished */
 {
  va_list args; va_start(args,narg);
  va_end(args);
  value0 = ECL_CONS_CAR(CLV0);
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function MAPTREE                                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC182maptree(cl_object v1function, cl_object v2tree, cl_object v3test)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(ecl_function_dispatch(cl_env_copy,v3test)(1, v2tree))){
  goto L2;
 }
 value0 = ecl_function_dispatch(cl_env_copy,v1function)(1, v2tree);
 return value0;
L2:;
 if (!(ECL_CONSP(v2tree))){
  goto L4;
 }
 T1 = ecl_car(v2tree);
 T0 = LC182maptree(v1function, T1, v3test);
 T2 = ecl_cdr(v2tree);
 T1 = LC182maptree(v1function, T2, v3test);
 value0 = CONS(T0,T1);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 value0 = v2tree;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC182maptree_va(cl_narg narg, cl_object v4function, cl_object v5tree, cl_object v6test, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[23]);
 {
  return LC182maptree(v4function, v5tree, v6test);
 }
}
/* local function VERIFY-TREE                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC181verify_tree(cl_object v1elt)
{
 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_CONSP(v1elt))){
  goto L3;
 }
 {
  cl_object v2;
  v2 = ecl_car(v1elt);
  if (!((v2)==(ECL_SYM("&KEY",12)))){
   goto L10;
  }
  value0 = VV[21];
  goto L8;
L10:;
  value0 = ECL_NIL;
  goto L8;
L8:;
  if (value0!=ECL_NIL) {
   goto L7;
  }
  if (!((v2)==(ECL_SYM("&OPTIONAL",13)))){
   goto L13;
  }
  value0 = VV[22];
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC181verify_tree_va(cl_narg narg, cl_object v3elt, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[20]);
 {
  return LC181verify_tree(v3elt);
 }
}
/* local function SET-DEFAULT                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC180set_default(cl_object v1list_)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_CONSP(v1list_))){
  goto L2;
 }
 {
  cl_object v2variable;
  v2variable = ecl_car(v1list_);
  if (!(ECL_SYMBOLP(v2variable))){
   goto L6;
  }
  {
   cl_object v3;
   cl_object v4;
   v3 = v2variable;
   v4 = VV[18];
   if (ecl_memql(v3,v4)!=ECL_NIL) {
    goto L6;
   }
  }
  T0 = cl_list(2, v2variable, VV[19]);
  goto L5;
L6:;
  T0 = v2variable;
L5:;
  T2 = ecl_cdr(v1list_);
  T1 = LC180set_default(T2);
  value0 = CONS(T0,T1);
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = v1list_;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC180set_default_va(cl_narg narg, cl_object v3list_, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[17]);
 {
  return LC180set_default(v3list_);
 }
}
/* closure LAMBDA442                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC214__lambda442(cl_narg narg, cl_object v1tp, ...)
{
 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;                                     /*  ENV                     */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[106]);
 {
L1:;
  value0 = L215flatten_function_types(v1tp, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* local function FAIL                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC218fail(volatile cl_object *lex0)
{
 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(3, VV[119], lex0[0], lex0[1]);
 return value0;
}
/* local function LAMBDA606                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC238__lambda606(cl_object v1c)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = ecl_make_bool(ECL_INSTANCEP(v1c));
 if (value0!=ECL_NIL) {
  goto L3;
 }
 value0 = ecl_make_bool(ECL_SYMBOLP(v1c));
 cl_env_copy->nvalues = 1;
 return value0;
L3:;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC238__lambda606_va(cl_narg narg, cl_object v2c, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[172]);
 {
  return LC238__lambda606(v2c);
 }
}
/* local function LAMBDA608                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC239__lambda608(cl_object v1c1, cl_object v2c2)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_SYMBOLP(v1c1))){
  goto L2;
 }
 v1c1 = cl_find_class(2, v1c1, ECL_NIL);
L2:;
 if (!(ECL_SYMBOLP(v2c2))){
  goto L5;
 }
 v2c2 = cl_find_class(2, v2c2, ECL_NIL);
L5:;
 if (Null(v1c1)){
  goto L9;
 }
 if (Null(v2c2)){
  goto L9;
 }
 value0 = si_subclassp(2, v1c1, v2c2);
 return value0;
L9:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC239__lambda608_va(cl_narg narg, cl_object v3c1, cl_object v4c2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[173]);
 {
  return LC239__lambda608(v3c1, v4c2);
 }
}
/* closure LAMBDA617                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC241__lambda617(cl_narg narg, cl_object v1type, ...)
{
 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;                                     /*  DIMENSIONS              */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[177]);
 {
L1:;
  value0 = cl_list(3, ECL_CONS_CAR(CLV0), v1type, ECL_CONS_CAR(CLV1));
  return value0;
 }
 }
}
/* closure LAMBDA719                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC258__lambda719(cl_narg narg, cl_object v1tp, ...)
{
 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;                                     /*  ENV                     */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[214]);
 {
L1:;
  value0 = L260canonical_type(v1tp, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA728                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC259__lambda728(cl_narg narg, cl_object v1tp, ...)
{
 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;                                     /*  ENV                     */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[215]);
 {
L1:;
  value0 = L260canonical_type(v1tp, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
#include "lsp/predlib.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclqGeUMgTYTtUr9_diczL881(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;PREDLIB.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclqGeUMgTYTtUr9_diczL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[231]);                         /*  CONSTANTLY-T            */
  ecl_cmp_defun(VV[232]);                         /*  CONSTANTLY-NIL          */
  (void)0; /* No entry created for CONSTANTLY */
  si_Xmake_special(VV[5]);
  T0 = si_make_vector(ECL_T, ecl_make_fixnum(256), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  ecl_cmp_setq(cl_env_copy,VV[5],T0);
  si_Xmake_special(VV[6]);
  T0 = si_make_vector(ECL_T, ecl_make_uint8_t(128), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  ecl_cmp_defun(VV[233]);                         /*  SUBTYPEP-CLEAR-CACHE    */
  ecl_cmp_defun(VV[234]);                         /*  PROCLAIM-CLASS          */
  ecl_cmp_defun(VV[235]);                         /*  CREATE-TYPE-NAME        */
  (void)0; /* No entry created for DO-DEFTYPE */
  ecl_cmp_defmacro(VV[236]);                      /*  DEFTYPE                 */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC184__lambda85_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("BOOLEAN",157), VVtemp[1], T0);
  si_do_deftype(3, VV[30], VVtemp[2], VVtemp[3]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC185__lambda93_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("FIXNUM",374), VVtemp[4], T0);
  si_do_deftype(3, ECL_SYM("BIGNUM",124), VVtemp[5], VVtemp[6]);
  si_do_deftype(3, ECL_SYM("BYTE8",1368), VVtemp[7], VVtemp[8]);
  si_do_deftype(3, ECL_SYM("INTEGER8",1373), VVtemp[9], VVtemp[10]);
  si_do_deftype(3, ECL_SYM("BYTE16",1369), VVtemp[11], VVtemp[12]);
  si_do_deftype(3, ECL_SYM("INTEGER16",1374), VVtemp[13], VVtemp[14]);
  si_do_deftype(3, ECL_SYM("BYTE32",1370), VVtemp[15], VVtemp[16]);
  si_do_deftype(3, ECL_SYM("INTEGER32",1375), VVtemp[17], VVtemp[18]);
  si_do_deftype(3, ECL_SYM("BYTE64",1371), VVtemp[19], VVtemp[20]);
  si_do_deftype(3, ECL_SYM("INTEGER64",1376), VVtemp[21], VVtemp[22]);
  si_do_deftype(3, ECL_SYM("CL-FIXNUM",1658), VVtemp[23], VVtemp[24]);
  si_do_deftype(3, ECL_SYM("CL-INDEX",1659), VVtemp[25], VVtemp[26]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC186__lambda159_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("REAL",706), VVtemp[27], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC187__lambda179_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SHORT-FLOAT",759), VVtemp[28], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC188__lambda184_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("BIT",125), VVtemp[29], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC189__lambda189_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("MOD",562), VVtemp[30], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC190__lambda195_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SIGNED-BYTE",764), VVtemp[31], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC191__lambda201_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("UNSIGNED-BYTE",889), VVtemp[32], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC192__lambda207_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("NULL",607), VVtemp[33], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC193__lambda212_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SEQUENCE",744), VVtemp[34], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC194__lambda217_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("LIST",483), VVtemp[35], T0);
  si_do_deftype(3, VV[49], VVtemp[36], VVtemp[37]);
  si_do_deftype(3, ECL_SYM("PROPERTY-LIST",1736), VVtemp[38], VVtemp[39]);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC195__lambda228_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("ATOM",121), VVtemp[40], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC196__lambda233_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("VECTOR",902), VVtemp[41], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC197__lambda240_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("EXTENDED-CHAR",348), VVtemp[42], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC198__lambda245_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("STRING",808), VVtemp[43], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC199__lambda251_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("BASE-STRING",123), VVtemp[44], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC200__lambda257_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("EXTENDED-STRING",1755), VVtemp[45], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC201__lambda263_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("BIT-VECTOR",136), VVtemp[46], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC202__lambda269_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SIMPLE-VECTOR",777), VVtemp[47], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC203__lambda275_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SIMPLE-STRING",774), VVtemp[48], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC204__lambda281_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SIMPLE-BASE-STRING",767), VVtemp[49], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC205__lambda287_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  si_do_deftype(3, ECL_SYM("SIMPLE-BIT-VECTOR",768), VVtemp[50], T0);
  si_do_deftype(3, ECL_SYM("ARRAY-INDEX",1877), VVtemp[51], VVtemp[52]);
  si_do_deftype(3, ECL_SYM("VIRTUAL-STREAM",1879), VVtemp[53], VVtemp[54]);
  ecl_cmp_defun(VV[237]);                         /*  SIMPLE-ARRAY-P          */
  ecl_cmp_defun(VV[238]);                         /*  COMPLEX-ARRAY-P         */
  (void)0; /* No entry created for RATIOP */
  (void)0; /* No entry created for SHORT-FLOAT-P */
  (void)0; /* No entry created for SINGLE-FLOAT-P */
  (void)0; /* No entry created for DOUBLE-FLOAT-P */
  (void)0; /* No entry created for LONG-FLOAT-P */
  ecl_cmp_defun(VV[239]);                         /*  COMPLEX-SINGLE-FLOAT-P  */
  ecl_cmp_defun(VV[240]);                         /*  COMPLEX-DOUBLE-FLOAT-P  */
  ecl_cmp_defun(VV[241]);                         /*  COMPLEX-LONG-FLOAT-P    */
  si_Xmake_constant(VV[81], VVtemp[55]);
  {
   cl_object v1;
   v1 = ecl_cmp_symbol_value(cl_env_copy,VV[81]);
   goto L135;
L134:;
   {
    cl_object v2l;
    v2l = ecl_car(v1);
    T0 = ecl_car(v2l);
    T1 = ecl_cdr(v2l);
    si_put_sysprop(T0, VV[82], T1);
   }
   v1 = ecl_cdr(v1);
L135:;
   if (Null(v1)){
    goto L142;
   }
   goto L134;
L142:;
  }
  si_Xmake_constant(VV[83], VV[84]);
  (void)0; /* No entry created for UPGRADED-ARRAY-ELEMENT-TYPE */
  (void)0; /* No entry created for UPGRADED-COMPLEX-PART-TYPE */
  (void)0; /* No entry created for IN-INTERVAL-P */
  (void)0; /* No entry created for ERROR-TYPE-SPECIFIER */
  (void)0; /* No entry created for MATCH-DIMENSIONS */
  (void)0; /* No entry created for TYPEP */
  (void)0; /* No entry created for SUBCLASSP */
  (void)0; /* No entry created for OF-CLASS-P */
  ecl_cmp_defun(VV[242]);                         /*  FLATTEN-FUNCTION-TYPES  */
  ecl_cmp_defun(VV[243]);                         /*  NORMALIZE-TYPE          */
  ecl_cmp_defun(VV[244]);                         /*  EXPAND-DEFTYPE          */
  (void)0; /* No entry created for COERCE */
  si_Xmake_special(VV[127]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[127],T0);
  si_Xmake_special(VV[128]);
  T0 = ecl_make_int8_t(1);
  ecl_cmp_setq(cl_env_copy,VV[128],T0);
  si_Xmake_constant(VV[129], ecl_make_int8_t(-1));
  si_Xmake_constant(VV[130], ecl_make_int8_t(0));
  si_Xmake_special(VV[131]);
  T0 = ecl_make_int8_t(1);
  ecl_cmp_setq(cl_env_copy,VV[131],T0);
  si_Xmake_special(VV[132]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[132],T0);
  si_Xmake_special(VV[133]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[133],T0);
  ecl_cmp_defun(VV[245]);                         /*  MAKE-MEMBER-TYPE        */
  ecl_cmp_defun(VV[246]);                         /*  FIND-MEMBER-TYPE        */
  T0 = (ECL_SYM("FIRST",373)->symbol.gfdef);
  si_fset(2, VV[138], T0);
  T0 = (ECL_SYM("SECOND",743)->symbol.gfdef);
  si_fset(2, VV[139], T0);
  {
   cl_object volatile v2;
   v2 = ecl_make_cfun_va((cl_objectfn)LC221__lambda520_va,ECL_NIL,Cblock,2);
   T0 = v2;
  }
  si_do_defsetf(3, VV[139], T0, ecl_make_int8_t(1));
  (void)0; /* No entry created for MAKE-ELEMENTARY-TYPE */
  (void)0; /* No entry created for FIND-ELEMENTARY-TYPE */
  T0 = (ECL_SYM("FIRST",373)->symbol.gfdef);
  si_fset(2, VV[143], T0);
  T0 = (ECL_SYM("SECOND",743)->symbol.gfdef);
  si_fset(2, VV[145], T0);
  {
   cl_object volatile v2;
   v2 = ecl_make_cfun_va((cl_objectfn)LC224__lambda549_va,ECL_NIL,Cblock,2);
   T0 = v2;
  }
  si_do_defsetf(3, VV[145], T0, ecl_make_int8_t(1));
  ecl_cmp_defmacro(VV[247]);                      /*  WITH-TYPE-DATABASE      */
  (void)0; /* No entry created for NEW-TYPE-TAG */
  (void)0; /* No entry created for PUSH-NEW-TYPE */
  (void)0; /* No entry created for FIND-REGISTERED-TAG */
  ecl_cmp_defun(VV[248]);                         /*  MAKE-REGISTERED-TAG     */
  (void)0; /* No entry created for MAYBE-SAVE-TYPES */
  ecl_cmp_defun(VV[249]);                         /*  UPDATE-TYPES            */
  (void)0; /* No entry created for FIND-TYPE-BOUNDS */
  (void)0; /* No entry created for REGISTER-TYPE */
  ecl_cmp_defun(VV[250]);                         /*  REGISTER-MEMBER-TYPE    */
  (void)0; /* No entry created for SIMPLE-MEMBER-TYPE */
  ecl_cmp_defun(VV[251]);                         /*  NUMBER-MEMBER-TYPE      */
  (void)0; /* No entry created for REGISTER-SATISFIES-TYPE */
  (void)0; /* No entry created for REGISTER-CLASS */
  (void)0; /* No entry created for REGISTER-ARRAY-TYPE */
  (void)0; /* No entry created for FAST-UPGRADED-ARRAY-ELEMENT-TYPE */
  (void)0; /* No entry created for PARSE-ARRAY-TYPE */
  ecl_cmp_defun(VV[252]);                         /*  ARRAY-TYPE-<=           */
  ecl_cmp_defun(VV[253]);                         /*  ARRAY-TYPE-P            */
  ecl_cmp_defun(VV[254]);                         /*  NUMERIC-RANGE-P         */
  ecl_cmp_defun(VV[255]);                         /*  NUMERIC-RANGE-<=        */
  (void)0; /* No entry created for CANONICAL-INTERVAL-TYPE */
  (void)0; /* No entry created for REGISTER-INTERVAL-TYPE */
  ecl_cmp_defun(VV[256]);                         /*  BOUNDS-<=               */
  (void)0; /* No entry created for CANONICAL-COMPLEX-TYPE */
  (void)0; /* No entry created for REGISTER-COMPLEX-TYPE */
  (void)0; /* No entry created for COMPLEX-FLOAT-FEATURE */
  ecl_cmp_defun(VV[257]);                         /*  REGISTER-CONS-TYPE      */
  T0 = cl_make_hash_table(4, ECL_SYM("TEST",1353), ECL_SYM("EQ",335), ECL_SYM("SIZE",1345), ecl_make_uint8_t(128));
  T1 = si_hash_table_fill(T0, VVtemp[56]);
  si_Xmake_constant(VV[212], T1);
  (void)0; /* No entry created for FIND-BUILT-IN-TAG */
  (void)0; /* No entry created for EXTEND-TYPE-TAG */
  ecl_cmp_defun(VV[258]);                         /*  CANONICAL-TYPE          */
  ecl_cmp_defun(VV[259]);                         /*  SAFE-CANONICAL-TYPE     */
  (void)0; /* No entry created for FAST-SUBTYPEP */
  (void)0; /* No entry created for SUBTYPEP */
  (void)0; /* No entry created for FAST-TYPE= */
  ecl_cmp_defun(VV[260]);                         /*  TYPE=                   */
  ecl_cmp_defun(VV[261]);                         /*  SEARCH-TYPE-IN-ENV      */
 }
}
