/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmptype-assert.lsp              */
#include <ecl/ecl-cmp.h>
#include "cmp/cmptype-assert.eclh"
/* function definition for C1COMPILER-TYPECASE                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3434c1compiler_typecase(cl_object v1args)
{
 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 v2form;
  v2form = ecl_car(v1args);
  {
   cl_object v3;                                  /*  CONSTANTP               */
   cl_object v4;                                  /*  VALUE                   */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(2, v2form, ecl_cmp_symbol_value(cl_env_copy,VV[2])) /*  CONSTANT-VALUE-P */;
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L2;
   }
   {
    cl_object v5;
    cl_object v6type;
    cl_object v7forms;
    cl_object v8;
    {
     cl_object v9;
     v9 = ecl_cdr(v1args);
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v9;
    }
    v6type = ECL_NIL;
    v7forms = ECL_NIL;
    v8 = v5;
L12:;
    if (!(ecl_endp(v8))){
     goto L14;
    }
    goto L13;
L14:;
    {
     cl_object v9;
     v9 = ECL_CONS_CAR(v8);
     v6type = ecl_car(v9);
     v9 = ecl_cdr(v9);
     v7forms = v9;
    }
    {
     cl_object v9;
     v9 = ECL_CONS_CDR(v8);
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v8 = v9;
    }
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[5]))->cfun.entry(2, v4, v6type) /*  CMP-TYPEP */)){
     goto L27;
    }
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, v7forms) /*  C1PROGN */;
    return value0;
L27:;
    goto L12;
L13:;
    (cl_env_copy->function=ecl_fdefinition(VV[7]))->cfun.entry(2, ECL_SYM("FORMAT-CONTROL",1272), VV[8]) /*  BABOON */;
   }
  }
 }
L2:;
 {
  cl_object v2var_name;
  cl_object v3var;
  cl_object v4first_case;
  {
   cl_object v5;
   v5 = v1args;
   {
    cl_object v6;
    v6 = v5;
    {
     bool v7;
     v7 = ECL_LISTP(v6);
     if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[11],v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v5)){
    goto L36;
   }
   {
    cl_object v6;
    v6 = ECL_CONS_CDR(v5);
    v1args = v6;
    v5 = ECL_CONS_CAR(v5);
   }
L36:;
   v2var_name = v5;
  }
  v3var = (cl_env_copy->function=ecl_fdefinition(VV[12]))->cfun.entry(1, v2var_name) /*  C1VREF */;
  v4first_case = ecl_car(v1args);
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v3var) /*  VAR-TYPE */;
  T1 = ecl_car(v4first_case);
  if (Null(cl_subtypep(3, T0, T1, ecl_cmp_symbol_value(cl_env_copy,VV[2])))){
   goto L44;
  }
  T0 = ecl_cdr(v4first_case);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, T0) /*  C1PROGN */;
  return value0;
L44:;
  {
   cl_object v5types;
   cl_object v6expressions;
   v5types = ECL_NIL;
   {
    cl_object v7;
    cl_object v8type;
    cl_object v9forms;
    cl_object v10;
    {
     cl_object v11;
     v11 = v1args;
     if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v11;
    }
    v8type = ECL_NIL;
    v9forms = ECL_NIL;
    v10 = v7;
    {
     cl_object v11c1form;
     v11c1form = ECL_NIL;
     {
      cl_object v12c1form_type;
      v12c1form_type = ECL_NIL;
      {
       cl_object v13;
       cl_object v14;
       v13 = ecl_list1(ECL_NIL);
       v14 = v13;
L58:;
       if (!(ecl_endp(v10))){
        goto L60;
       }
       goto L59;
L60:;
       {
        cl_object v15;
        v15 = ECL_CONS_CAR(v10);
        v8type = ecl_car(v15);
        v15 = ecl_cdr(v15);
        v9forms = v15;
       }
       {
        cl_object v15;
        v15 = ECL_CONS_CDR(v10);
        if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v10 = v15;
       }
       v11c1form = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, v9forms) /*  C1PROGN */;
       v12c1form_type = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v11c1form) /*  C1FORM-PRIMARY-TYPE */;
       v5types = CONS(v12c1form_type,v5types);
       {
        cl_object v15;
        v15 = v14;
        if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v15;
       }
       T1 = cl_list(2, v8type, v11c1form);
       v14 = ecl_list1(T1);
       (ECL_CONS_CDR(T0)=v14,T0);
       goto L58;
L59:;
       v6expressions = ecl_cdr(v13);
       goto L47;
      }
     }
    }
   }
L47:;
   T0 = ecl_fdefinition(VV[19]);
   T1 = cl_reduce(2, T0, v5types);
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[18]))->cfun.entry(6, ECL_SYM("COMPILER-TYPECASE",1887), ECL_SYM("TYPE",1356), T1, VV[20], v3var, v6expressions) /*  MAKE-C1FORM* */;
   return value0;
  }
 }
}
static cl_object L3434c1compiler_typecase_va(cl_narg narg, cl_object v7args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3434c1compiler_typecase(v7args);
 }
}
/* function definition for C2COMPILER-TYPECASE                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3435c2compiler_typecase(cl_object v1c1form, cl_object v2var, cl_object v3expressions)
{
 cl_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 v4var_type;
  v4var_type = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(1, v2var) /*  VAR-TYPE */;
  {
   cl_object v5;
   cl_object v6type;
   cl_object v7form;
   cl_object v8;
   {
    cl_object v9;
    v9 = v3expressions;
    if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v9;
   }
   v6type = ECL_NIL;
   v7form = ECL_NIL;
   v8 = v5;
L9:;
   if (!(ecl_endp(v8))){
    goto L11;
   }
   goto L10;
L11:;
   {
    cl_object v9;
    v9 = ECL_CONS_CAR(v8);
    v6type = ecl_car(v9);
    v9 = ecl_cdr(v9);
    v7form = ecl_car(v9);
   }
   {
    cl_object v9;
    v9 = ECL_CONS_CDR(v8);
    if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v9;
   }
   if (!((v6type)==(ECL_T))){
    goto L30;
   }
   goto L26;
L30:;
   goto L28;
L28:;
   if (!((v6type)==(ECL_SYM("OTHERWISE",617)))){
    goto L33;
   }
   goto L26;
L33:;
   goto L27;
L27:;
   if (Null(cl_subtypep(3, v4var_type, v6type, ecl_cmp_symbol_value(cl_env_copy,VV[2])))){
    goto L24;
   }
   goto L25;
L26:;
L25:;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(1, v7form) /*  C2EXPR */;
   return value0;
L24:;
   goto L9;
L10:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L3435c2compiler_typecase_va(cl_narg narg, cl_object v9c1form, cl_object v10var, cl_object v11expressions, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[22]);
 {
  return L3435c2compiler_typecase(v9c1form, v10var, v11expressions);
 }
}
/* function definition for SIMPLE-TYPE-ASSERTION                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3436simple_type_assertion(cl_object v1value, cl_object v2type)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3simple_form;
  {
   cl_object v4;
   cl_object v5;
   v4 = v2type;
   v5 = VV[28];
   T0 = ecl_assql(v4,v5);
  }
  v3simple_form = ecl_cdr(T0);
  if (Null(v3simple_form)){
   goto L6;
  }
  T0 = ecl_list1(v1value);
  value0 = cl_listX(6, ECL_SYM("C-INLINE",2106), T0, VV[30], ECL_SYM("VOID",1424), v3simple_form, VV[31]);
  return value0;
L6:;
  T0 = (cl_env_copy->function=(VV[32]->symbol.gfdef))->cfun.entry(2, v2type, ecl_cmp_symbol_value(cl_env_copy,VV[2])) /*  FLATTEN-FUNCTION-TYPES */;
  T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
  T2 = cl_list(3, ECL_SYM("TYPEP",878), v1value, T1);
  T3 = cl_list(2, ECL_SYM("QUOTE",682), v2type);
  T4 = cl_list(3, T2, T3, v1value);
  value0 = cl_listX(3, ECL_SYM("C-INLINE",2106), T4, VV[33]);
  return value0;
 }
}
static cl_object L3436simple_type_assertion_va(cl_narg narg, cl_object v4value, cl_object v5type, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[29]);
 {
  return L3436simple_type_assertion(v4value, v5type);
 }
}
/* function definition for EXPAND-TYPE-ASSERTION                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3437expand_type_assertion(cl_object v1value, cl_object v2type, cl_object v3env, cl_object v4compulsory)
{
 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_SYMBOLP(v1value))){
  goto L4;
 }
 if ((cl_env_copy->function=ecl_fdefinition(VV[36]))->cfun.entry(1, v1value) /*  SPECIAL-VARIABLE-P */!=ECL_NIL) {
  goto L4;
 }
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1value) /*  SYMBOL-MACRO-P */)){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 T0 = cl_list(2, VV[38], v1value);
 T1 = ecl_list1(T0);
 T2 = L3437expand_type_assertion(VV[38], v2type, v3env, v4compulsory);
 value0 = cl_list(4, ECL_SYM("LET*",480), T1, VV[39], T2);
 return value0;
L2:;
 if (Null(v4compulsory)){
  goto L7;
 }
 value0 = L3436simple_type_assertion(v1value, v2type);
 return value0;
L7:;
 T0 = ecl_list1(v2type);
 T1 = L3436simple_type_assertion(v1value, v2type);
 T2 = cl_list(2, ECL_T, T1);
 value0 = cl_list(4, ECL_SYM("COMPILER-TYPECASE",1887), v1value, T0, T2);
 return value0;
}
static cl_object L3437expand_type_assertion_va(cl_narg narg, cl_object v5value, cl_object v6type, cl_object v7env, cl_object v8compulsory, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[35]);
 {
  return L3437expand_type_assertion(v5value, v6type, v7env, v8compulsory);
 }
}
/* function definition for C1CHECKED-VALUE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3438c1checked_value(cl_object v1args)
{
 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 v2type;
  cl_object v3value;
  cl_object v4form;
  cl_object v5form_type;
  cl_object v6and_type;
  {
   cl_object v7;
   v7 = v1args;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[11],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L7;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v1args = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L7:;
   v2type = v7;
  }
  {
   cl_object v7;
   v7 = v1args;
   {
    cl_object v8;
    v8 = v7;
    {
     bool v9;
     v9 = ECL_LISTP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(VV[11],v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v7)){
    goto L18;
   }
   {
    cl_object v8;
    v8 = ECL_CONS_CDR(v7);
    v1args = v8;
    v7 = ECL_CONS_CAR(v7);
   }
L18:;
   v3value = v7;
  }
  v4form = ECL_NIL;
  v5form_type = ECL_NIL;
  v6and_type = ECL_NIL;
  if ((cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v2type) /*  TRIVIAL-TYPE-P */!=ECL_NIL) {
   goto L29;
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(0) /*  POLICY-TYPE-ASSERTIONS */!=ECL_NIL) {
   goto L27;
  }
  goto L28;
L29:;
L28:;
  value0 = v3value;
  cl_env_copy->nvalues = 1;
  return value0;
L27:;
  if (!(ECL_CONSP(v2type))){
   goto L31;
  }
  T0 = ecl_car(v2type);
  if (!((T0)==(ECL_SYM("VALUES",899)))){
   goto L31;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[44]))->cfun.entry(1, v2type) /*  VALUES-TYPE-PRIMARY-TYPE */;
  v1args = cl_list(2, T0, v3value);
  goto L1;
L31:;
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[45]))->cfun.entry(0) /*  POLICY-EVALUATE-FORMS */)){
   goto L36;
  }
  if (Null(cl_constantp(2, v3value, ecl_cmp_symbol_value(cl_env_copy,VV[2])))){
   goto L36;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("CONSTANT-FORM-VALUE",2161)))->cfun.entry(2, v3value, ecl_cmp_symbol_value(cl_env_copy,VV[2])) /*  CONSTANT-FORM-VALUE */;
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[5]))->cfun.entry(2, T0, v2type) /*  CMP-TYPEP */)){
   goto L39;
  }
  value0 = v3value;
  cl_env_copy->nvalues = 1;
  return value0;
L39:;
  (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[47], v3value, v2type) /*  CMPWARN */;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), v2type);
  T1 = cl_list(2, ECL_SYM("QUOTE",682), v2type);
  T2 = cl_list(3, ECL_SYM("LIST",483), v3value, T1);
  T3 = cl_list(10, ECL_SYM("ERROR",339), VV[49], ECL_SYM("DATUM",1245), v3value, ECL_SYM("EXPECTED-TYPE",1263), T0, ECL_SYM("FORMAT-CONTROL",1272), VV[50], ECL_SYM("FORMAT-ARGUMENTS",1271), T2);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, T3) /*  C1EXPR */;
  return value0;
L36:;
  v4form = (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, v3value) /*  C1EXPR */;
  v5form_type = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v4form) /*  C1FORM-PRIMARY-TYPE */;
  v6and_type = (cl_env_copy->function=ecl_fdefinition(VV[51]))->cfun.entry(2, v5form_type, v2type) /*  TYPE-AND */;
  if (!((v6and_type)==(v5form_type))){
   goto L42;
  }
  value0 = v4form;
  cl_env_copy->nvalues = 1;
  return value0;
L42:;
  if (!(v6and_type==ECL_NIL)){
   goto L51;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(3, VV[52], v3value, v2type) /*  CMPWARN */;
  goto L50;
L51:;
  (cl_env_copy->function=ecl_fdefinition(VV[53]))->cfun.entry(3, VV[54], v3value, v2type) /*  CMPDEBUG */;
L50:;
  {
   cl_object v7full_check;
   T0 = cl_list(2, VV[55], v3value);
   T1 = ecl_list1(T0);
   T2 = L3437expand_type_assertion(VV[55], v2type, ecl_cmp_symbol_value(cl_env_copy,VV[2]), ECL_NIL);
   if (!(v6and_type==ECL_NIL)){
    goto L55;
   }
   T3 = VV[55];
   goto L54;
L55:;
   T3 = cl_list(3, ECL_SYM("TRULY-THE",2081), v2type, VV[55]);
L54:;
   v7full_check = cl_list(5, ECL_SYM("LET*",480), T1, VV[56], T2, T3);
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, v7full_check) /*  C1EXPR */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[18]))->cfun.entry(7, ECL_SYM("CHECKED-VALUE",2082), ECL_SYM("TYPE",1356), v2type, VV[20], v2type, v4form, T0) /*  MAKE-C1FORM* */;
   return value0;
  }
 }
}
static cl_object L3438c1checked_value_va(cl_narg narg, cl_object v8args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[41]);
 {
  return L3438c1checked_value(v8args);
 }
}
/* function definition for C2CHECKED-VALUE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3439c2checked_value(cl_object v1c1form, cl_object v2type, cl_object v3value, cl_object v4let_form)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v3value) /*  C1FORM-PRIMARY-TYPE */;
 if (Null(cl_subtypep(3, T1, v2type, ecl_cmp_symbol_value(cl_env_copy,VV[2])))){
  goto L3;
 }
 T0 = v3value;
 goto L2;
L3:;
 T0 = v4let_form;
L2:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(1, T0) /*  C2EXPR */;
 return value0;
}
static cl_object L3439c2checked_value_va(cl_narg narg, cl_object v5c1form, cl_object v6type, cl_object v7value, cl_object v8let_form, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[58]);
 {
  return L3439c2checked_value(v5c1form, v6type, v7value, v8let_form);
 }
}
/* local function OPTIONAL-TYPE-ASSERTION                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3440optional_type_assertion(cl_object v1, 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:;
 {
  cl_object v3;
  cl_object v4value;
  cl_object v5type;
  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);
   v4value = 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);
   v5type = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, v2env) /*  POLICY-TYPE-ASSERTIONS */)){
   goto L17;
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v5type) /*  TRIVIAL-TYPE-P */!=ECL_NIL) {
   goto L17;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[53]))->cfun.entry(3, VV[63], v4value, v5type) /*  CMPDEBUG */;
  value0 = cl_list(3, ECL_SYM("CHECKED-VALUE",2082), v5type, v4value);
  return value0;
L17:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3440optional_type_assertion_va(cl_narg narg, cl_object v6, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[61]);
 {
  return LC3440optional_type_assertion(v6, v7env);
 }
}
/* local function TYPE-ASSERTION                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3441type_assertion(cl_object v1, 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:;
 {
  cl_object v3;
  cl_object v4value;
  cl_object v5type;
  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);
   v4value = 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);
   v5type = v6;
  }
  if (Null(v3)){
   goto L15;
  }
  si_dm_too_many_arguments(v1);
L15:;
  (cl_env_copy->function=ecl_fdefinition(VV[53]))->cfun.entry(3, VV[63], v4value, v5type) /*  CMPDEBUG */;
  if ((cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v5type) /*  TRIVIAL-TYPE-P */!=ECL_NIL) {
   goto L18;
  }
  value0 = L3437expand_type_assertion(v4value, v5type, v2env, ECL_T);
  return value0;
L18:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3441type_assertion_va(cl_narg narg, cl_object v6, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[65]);
 {
  return LC3441type_assertion(v6, v7env);
 }
}
#include "cmp/cmptype-assert.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclZhgT5jTjpnrn9_TNS0M881(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:CMP;CMPTYPE-ASSERT.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclZhgT5jTjpnrn9_TNS0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[67]);                          /*  C1COMPILER-TYPECASE     */
  ecl_cmp_defun(VV[68]);                          /*  C2COMPILER-TYPECASE     */
  si_Xmake_constant(VV[27], VV[28]);
  ecl_cmp_defun(VV[69]);                          /*  SIMPLE-TYPE-ASSERTION   */
  ecl_cmp_defun(VV[70]);                          /*  EXPAND-TYPE-ASSERTION   */
  ecl_cmp_defun(VV[71]);                          /*  C1CHECKED-VALUE         */
  ecl_cmp_defun(VV[72]);                          /*  C2CHECKED-VALUE         */
  ecl_cmp_defmacro(VV[73]);                       /*  OPTIONAL-TYPE-ASSERTION */
  ecl_cmp_defmacro(VV[74]);                       /*  TYPE-ASSERTION          */
}
