/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmptype.lsp                     */
#include <ecl/ecl-cmp.h>
#include "cmp/cmptype.eclh"
/* function definition for AND-FORM-TYPE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3420and_form_type(cl_narg narg, cl_object v1type, cl_object v2form, cl_object v3original_form, ...)
{
 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(VV[2]);
 {
  cl_object v4mode;
  cl_object v5format_string;
  cl_object v6format_args;
  ecl_va_list args; ecl_va_start(args,v3original_form,narg,3);
  {
   int i = 3;
   if (i >= narg) {
    v4mode = VV[0];
   } else {
    i++;
    v4mode = ecl_va_arg(args);
   }
   if (i >= narg) {
    v5format_string = VV[1];
   } else {
    i++;
    v5format_string = ecl_va_arg(args);
   }
  }
  v6format_args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v7type2;
   cl_object v8type1;
   v7type2 = (cl_env_copy->function=ecl_fdefinition(VV[3]))->cfun.entry(1, v2form) /*  C1FORM-PRIMARY-TYPE */;
   v8type1 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(2, v1type, v7type2) /*  TYPE-AND */;
   if (Null(v8type1)){
    goto L6;
   }
   ecl_structure_set(v2form,VV[5],(cl_fixnum)(1),v8type1);
   goto L5;
L6:;
   if (!((v4mode)==(VV[0]))){
    goto L9;
   }
   T0 = ecl_fdefinition(VV[6]);
   goto L8;
L9:;
   T0 = ecl_fdefinition(VV[7]);
L8:;
   ecl_function_dispatch(cl_env_copy,T0)(6, VV[8], v5format_string, v6format_args, v3original_form, v7type2, v1type);
L5:;
   value0 = v2form;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for AND-CALL-TYPE                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3421and_call_type(cl_object v1type, cl_object v2form)
{
 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;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[12]))->cfun.entry(1, v2form) /*  C1FORM-TYPE */;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[11]))->cfun.entry(2, v1type, T0) /*  VALUES-TYPE-AND */;
  value0 = ecl_structure_set(v2form,VV[5],(cl_fixnum)(1),v3);
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3421and_call_type_va(cl_narg narg, cl_object v4type, cl_object v5form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[10]);
 {
  return L3421and_call_type(v4type, v5form);
 }
}
/* function definition for DEFAULT-INIT                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3423default_init(cl_narg narg, cl_object v1var, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[14]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[14]);
 {
  cl_object v2warn;
  va_list args; va_start(args,v1var);
  {
   int i = 1;
   if (i >= narg) {
    v2warn = ECL_NIL;
   } else {
    i++;
    v2warn = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3new_value;
   {
    cl_object v4;
    cl_object v5;
    cl_object v6;
    v4 = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v1var) /*  VAR-TYPE */;
    if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[21]))){
     goto L7;
    }
    T1 = VV[22];
    goto L6;
L7:;
    T1 = ECL_NIL;
L6:;
    v5 = cl_listX(6, VV[16], VV[17], VV[18], VV[19], VV[20], T1);
    {
     cl_object v7;
     v7 = ecl_make_cfun_va((cl_objectfn)LC3422__lambda20_va,ECL_NIL,Cblock,2);
     v6 = v7;
    }
    {
     cl_object v7;
     v7 = v5;
     goto L13;
L12:;
     {
      cl_object v8;
      cl_object v9;
      {
       cl_object v10;
       v10 = v7;
       if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v10;
      }
      v9 = ECL_CONS_CAR(v8);
      if (Null(v9)){
       goto L15;
      }
      {
       cl_object v10;
       {
        cl_object v11;
        v11 = v9;
        if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T1 = v11;
       }
       v10 = ECL_CONS_CAR(T1);
       if (Null(cl_subtypep(3, v4, v10, ecl_cmp_symbol_value(cl_env_copy,VV[24])))){
        goto L15;
       }
       T0 = v9;
       goto L3;
      }
     }
L15:;
     v7 = ECL_CONS_CDR(v7);
L13:;
     if (v7==ECL_NIL) {
      goto L28;
     }
     goto L12;
L28:;
     T0 = ECL_NIL;
    }
   }
L3:;
   v3new_value = ecl_cdr(T0);
   if (Null(v3new_value)){
    goto L30;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[28]))->cfun.entry(1, v3new_value) /*  C1CONSTANT-VALUE */;
   return value0;
L30:;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[29]))->cfun.entry(0) /*  C1NIL */;
   return value0;
  }
 }
}
/* function definition for LAMBDA-TYPE-CHECK-INIT-FORMS                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3425lambda_type_check_init_forms(cl_object v1optionals, cl_object v2keywords, cl_object v3opt_types, cl_object v4key_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:;
 {
  cl_object v5;
  cl_object v6var;
  cl_object v7;
  {
   cl_object v8;
   v8 = v1optionals;
   if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v5 = v8;
  }
  v6var = ECL_NIL;
  v7 = v5;
  {
   cl_object v8;
   cl_object v9init;
   cl_object v10;
   {
    cl_object v11;
    v11 = ecl_cdr(v1optionals);
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9init = ECL_NIL;
   v10 = v8;
   {
    cl_object v11type_iterator;
    v11type_iterator = ecl_cdr(v3opt_types);
    {
     cl_object v12type;
     v12type = ECL_NIL;
     if (!(ecl_endp(v7))){
      goto L17;
     }
     goto L16;
L17:;
     v6var = ECL_CONS_CAR(v7);
     {
      cl_object v13;
      v13 = ecl_cdddr(v7);
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v13;
     }
     if (!(ecl_endp(v10))){
      goto L25;
     }
     goto L16;
L25:;
     v9init = ECL_CONS_CAR(v10);
     {
      cl_object v13;
      v13 = ecl_cdddr(v10);
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
L15:;
     if (!(ECL_ATOM(v11type_iterator))){
      goto L33;
     }
     goto L16;
L33:;
     v12type = ecl_car(v11type_iterator);
     LC3424maybe_fix_type(v6var, v9init, v12type, v11type_iterator);
     if (!(ecl_endp(v7))){
      goto L38;
     }
     goto L16;
L38:;
     v6var = ECL_CONS_CAR(v7);
     {
      cl_object v13;
      v13 = ecl_cdddr(v7);
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v7 = v13;
     }
     if (!(ecl_endp(v10))){
      goto L46;
     }
     goto L16;
L46:;
     v9init = ECL_CONS_CAR(v10);
     {
      cl_object v13;
      v13 = ecl_cdddr(v10);
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
     v11type_iterator = ecl_cdddr(v11type_iterator);
     goto L15;
L16:;
    }
   }
  }
 }
 {
  cl_object v5key_list;
  v5key_list = v2keywords;
  {
   cl_object v6keyword;
   v6keyword = ECL_NIL;
   {
    cl_object v7var;
    v7var = ECL_NIL;
    {
     cl_object v8init;
     v8init = ECL_NIL;
     {
      cl_object v9type_iterator;
      v9type_iterator = ECL_NIL;
      {
       cl_object v10type;
       v10type = ECL_NIL;
L63:;
       if (!(ECL_ATOM(v5key_list))){
        goto L65;
       }
       goto L64;
L65:;
       v6keyword = ecl_car(v5key_list);
       v7var = ecl_cadr(v5key_list);
       v8init = ecl_caddr(v5key_list);
       {
        cl_object v11key_list;
        v11key_list = ecl_cdr(v4key_types);
L76:;
        if (!(ECL_ATOM(v11key_list))){
         goto L78;
        }
        goto L77;
L78:;
        T0 = ecl_car(v11key_list);
        if (!((v6keyword)==(T0))){
         goto L80;
        }
        v9type_iterator = ecl_cdr(v11key_list);
        goto L74;
L80:;
        v11key_list = ecl_cddr(v11key_list);
        goto L76;
L77:;
        v9type_iterator = VV[44];
        goto L74;
       }
L74:;
       v10type = ecl_car(v9type_iterator);
       LC3424maybe_fix_type(v7var, v8init, v10type, v9type_iterator);
       v5key_list = ecl_cddddr(v5key_list);
       goto L63;
L64:;
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       return value0;
      }
     }
    }
   }
  }
 }
}
static cl_object L3425lambda_type_check_init_forms_va(cl_narg narg, cl_object v11optionals, cl_object v12keywords, cl_object v13opt_types, cl_object v14key_types, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[31]);
 {
  return L3425lambda_type_check_init_forms(v11optionals, v12keywords, v13opt_types, v14key_types);
 }
}
/* function definition for LAMBDA-TYPE-CHECK-ASSOCIATE                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3426lambda_type_check_associate(cl_object v1fname, cl_object v2requireds, cl_object v3optionals, cl_object v4keywords, cl_object v5global_fun_p)
{
 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 v6;                                   /*  ARG-TYPES               */
  cl_object v7;                                   /*  FOUND                   */
  if (Null(v5global_fun_p)){
   goto L4;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[47]))->cfun.entry(3, v1fname, ecl_cmp_symbol_value(cl_env_copy,VV[24]), v5global_fun_p) /*  GET-ARG-TYPES */;
  goto L2;
L4:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  goto L2;
L2:;
  {
   const int v8 = cl_env_copy->nvalues;
   v6 = value0;
   cl_object v9;
   v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
   v7 = v9;
  }
  if (Null(v7)){
   goto L6;
  }
  {
   cl_object v8;                                  /*  REQ-TYPES               */
   cl_object v9;                                  /*  OPT-TYPES               */
   cl_object v10;                                 /*  KEY-TYPES               */
   value0 = si_process_lambda_list(v6, ECL_SYM("FTYPE",395));
   {
    const int v11 = cl_env_copy->nvalues;
    v8 = value0;
    cl_object v12;
    v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1];
    v9 = v12;
    v12 = (v11<=4)? ECL_NIL : cl_env_copy->values[4];
    v10 = v12;
   }
   L3425lambda_type_check_init_forms(v3optionals, v4keywords, v9, v10);
   {
    cl_object v11;
    cl_object v12var;
    cl_object v13;
    {
     cl_object v14;
     v14 = v2requireds;
     if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v11 = v14;
    }
    v12var = ECL_NIL;
    v13 = v11;
    {
     cl_object v14;
     cl_object v15type;
     cl_object v16;
     {
      cl_object v17;
      v17 = ecl_cdr(v8);
      if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v14 = v17;
     }
     v15type = ECL_NIL;
     v16 = v14;
     {
      cl_object v17;
      cl_object v18;
      v17 = ecl_list1(ECL_NIL);
      v18 = v17;
L23:;
      if (!(ecl_endp(v13))){
       goto L25;
      }
      goto L24;
L25:;
      v12var = ECL_CONS_CAR(v13);
      {
       cl_object v19;
       v19 = ECL_CONS_CDR(v13);
       if (ecl_unlikely(!ECL_LISTP(v19))) FEtype_error_list(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v19;
      }
      if (!(ecl_endp(v16))){
       goto L33;
      }
      goto L24;
L33:;
      v15type = ECL_CONS_CAR(v16);
      {
       cl_object v19;
       v19 = ECL_CONS_CDR(v16);
       if (ecl_unlikely(!ECL_LISTP(v19))) FEtype_error_list(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v16 = v19;
      }
      {
       cl_object v19;
       v19 = v18;
       if (ecl_unlikely(ECL_ATOM(v19))) FEtype_error_cons(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v19;
      }
      T2 = CONS(v12var,v15type);
      v18 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v18,T1);
      goto L23;
L24:;
      T0 = ecl_cdr(v17);
      goto L10;
     }
    }
   }
L10:;
   {
    cl_object v11;
    cl_object v12optional;
    cl_object v13;
    {
     cl_object v14;
     v14 = v3optionals;
     if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v11 = v14;
    }
    v12optional = ECL_NIL;
    v13 = v11;
    {
     cl_object v14;
     cl_object v15type;
     cl_object v16;
     {
      cl_object v17;
      v17 = ecl_cdr(v9);
      if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v14 = v17;
     }
     v15type = ECL_NIL;
     v16 = v14;
     {
      cl_object v17;
      cl_object v18;
      v17 = ecl_list1(ECL_NIL);
      v18 = v17;
L61:;
      if (!(ecl_endp(v13))){
       goto L63;
      }
      goto L62;
L63:;
      v12optional = ECL_CONS_CAR(v13);
      {
       cl_object v19;
       v19 = ecl_cdddr(v13);
       if (ecl_unlikely(!ECL_LISTP(v19))) FEtype_error_list(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v19;
      }
      if (!(ecl_endp(v16))){
       goto L71;
      }
      goto L62;
L71:;
      v15type = ECL_CONS_CAR(v16);
      {
       cl_object v19;
       v19 = ecl_cdddr(v16);
       if (ecl_unlikely(!ECL_LISTP(v19))) FEtype_error_list(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v16 = v19;
      }
      {
       cl_object v19;
       v19 = v18;
       if (ecl_unlikely(ECL_ATOM(v19))) FEtype_error_cons(v19);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T2 = v19;
      }
      T3 = CONS(v12optional,v15type);
      v18 = ecl_list1(T3);
      (ECL_CONS_CDR(T2)=v18,T2);
      goto L61;
L62:;
      T1 = ecl_cdr(v17);
      goto L48;
     }
    }
   }
L48:;
   {
    cl_object v11key_list;
    v11key_list = v4keywords;
    {
     cl_object v12keyword;
     v12keyword = ECL_NIL;
     {
      cl_object v13key_var;
      v13key_var = ECL_NIL;
      {
       cl_object v14type;
       v14type = ECL_NIL;
       {
        cl_object v15;
        cl_object v16;
        v15 = ecl_list1(ECL_NIL);
        v16 = v15;
L93:;
        if (!(ECL_ATOM(v11key_list))){
         goto L95;
        }
        goto L94;
L95:;
        v12keyword = ecl_car(v11key_list);
        v13key_var = ecl_cadr(v11key_list);
        {
         cl_object v17key_list;
         v17key_list = ecl_cdr(v10);
L104:;
         if (!(ECL_ATOM(v17key_list))){
          goto L106;
         }
         goto L105;
L106:;
         T3 = ecl_car(v17key_list);
         if (!((v12keyword)==(T3))){
          goto L108;
         }
         v14type = ecl_cadr(v17key_list);
         goto L102;
L108:;
         v17key_list = ecl_cddr(v17key_list);
         goto L104;
L105:;
         v14type = ECL_T;
         goto L102;
        }
L102:;
        {
         cl_object v17;
         v17 = v16;
         if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         T3 = v17;
        }
        T4 = CONS(v13key_var,v14type);
        v16 = ecl_list1(T4);
        (ECL_CONS_CDR(T3)=v16,T3);
        v11key_list = ecl_cddddr(v11key_list);
        goto L93;
L94:;
        T2 = ecl_cdr(v15);
        goto L86;
       }
      }
     }
    }
   }
L86:;
   value0 = cl_list(3, T0, T1, T2);
   return value0;
  }
L6:;
  {
   cl_object v8;
   cl_object v9var;
   cl_object v10;
   {
    cl_object v11;
    v11 = v2requireds;
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9var = ECL_NIL;
   v10 = v8;
   {
    cl_object v11;
    cl_object v12;
    v11 = ecl_list1(ECL_NIL);
    v12 = v11;
L131:;
    if (!(ecl_endp(v10))){
     goto L133;
    }
    goto L132;
L133:;
    v9var = ECL_CONS_CAR(v10);
    {
     cl_object v13;
     v13 = ECL_CONS_CDR(v10);
     if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v10 = v13;
    }
    {
     cl_object v13;
     v13 = v12;
     if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v13;
    }
    T2 = CONS(v9var,ECL_T);
    v12 = ecl_list1(T2);
    (ECL_CONS_CDR(T1)=v12,T1);
    goto L131;
L132:;
    T0 = ecl_cdr(v11);
    goto L123;
   }
  }
L123:;
  {
   cl_object v8;
   cl_object v9optional;
   cl_object v10;
   {
    cl_object v11;
    v11 = v3optionals;
    if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v8 = v11;
   }
   v9optional = ECL_NIL;
   v10 = v8;
   {
    cl_object v11;
    cl_object v12;
    v11 = ecl_list1(ECL_NIL);
    v12 = v11;
L156:;
    if (!(ecl_endp(v10))){
     goto L158;
    }
    goto L157;
L158:;
    v9optional = ECL_CONS_CAR(v10);
    {
     cl_object v13;
     v13 = ecl_cdddr(v10);
     if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v10 = v13;
    }
    {
     cl_object v13;
     v13 = v12;
     if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T2 = v13;
    }
    T3 = CONS(v9optional,ECL_T);
    v12 = ecl_list1(T3);
    (ECL_CONS_CDR(T2)=v12,T2);
    goto L156;
L157:;
    T1 = ecl_cdr(v11);
    goto L148;
   }
  }
L148:;
  {
   cl_object v8key_list;
   v8key_list = v4keywords;
   {
    cl_object v9key_var;
    v9key_var = ECL_NIL;
    {
     cl_object v10;
     cl_object v11;
     v10 = ecl_list1(ECL_NIL);
     v11 = v10;
L178:;
     if (!(ECL_ATOM(v8key_list))){
      goto L180;
     }
     goto L179;
L180:;
     v9key_var = ecl_cadr(v8key_list);
     {
      cl_object v12;
      v12 = v11;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T3 = v12;
     }
     T4 = CONS(v9key_var,ECL_T);
     v11 = ecl_list1(T4);
     (ECL_CONS_CDR(T3)=v11,T3);
     v8key_list = ecl_cddddr(v8key_list);
     goto L178;
L179:;
     T2 = ecl_cdr(v10);
     goto L173;
    }
   }
  }
L173:;
  value0 = cl_list(3, T0, T1, T2);
  return value0;
 }
}
static cl_object L3426lambda_type_check_associate_va(cl_narg narg, cl_object v6fname, cl_object v7requireds, cl_object v8optionals, cl_object v9keywords, cl_object v10global_fun_p, ...)
{
 if (ecl_unlikely(narg!=5)) FEwrong_num_arguments(VV[46]);
 {
  return L3426lambda_type_check_associate(v6fname, v7requireds, v8optionals, v9keywords, v10global_fun_p);
 }
}
/* function definition for LAMBDA-TYPE-CHECK-PRECISE                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3427lambda_type_check_precise(cl_object v1assoc_list, cl_object v2ts)
{
 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 v4record;
  cl_object v5;
  {
   cl_object v6;
   v6 = v1assoc_list;
   if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   v3 = v6;
  }
  v4record = ECL_NIL;
  v5 = v3;
  {
   cl_object v6var;
   v6var = ECL_NIL;
   {
    cl_object v7type;
    v7type = ECL_NIL;
L10:;
    if (!(ecl_endp(v5))){
     goto L12;
    }
    goto L11;
L12:;
    v4record = ECL_CONS_CAR(v5);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v5);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    v6var = ecl_car(v4record);
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     v8 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v6var) /*  VAR-NAME */;
     v9 = v8;
     v10 = v2ts;
     v7type = ecl_assql(v9,v10);
    }
    if (Null(v7type)){
     goto L27;
    }
    {
     cl_object v8;
     v8 = v4record;
     if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v8;
    }
    T1 = ecl_cdr(v7type);
    (ECL_CONS_CDR(T0)=T1,T0);
L27:;
    goto L10;
L11:;
   }
  }
 }
 value0 = v1assoc_list;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3427lambda_type_check_precise_va(cl_narg narg, cl_object v3assoc_list, cl_object v4ts, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return L3427lambda_type_check_precise(v3assoc_list, v4ts);
 }
}
/* function definition for LAMBDA-TYPE-CHECK-EXPAND                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3428lambda_type_check_expand(cl_object v1type_checks, cl_object v2policy_check_type, cl_object v3other_decls)
{
 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 v4checks;
  v4checks = ECL_NIL;
  {
   cl_object v5new_auxs;
   v5new_auxs = ECL_NIL;
   {
    cl_object v6;
    cl_object v7var;
    cl_object v8type;
    cl_object v9;
    {
     cl_object v10;
     v10 = v1type_checks;
     if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v10;
    }
    v7var = ECL_NIL;
    v8type = ECL_NIL;
    v9 = v6;
    {
     cl_object v10name;
     v10name = ECL_NIL;
L11:;
     if (!(ecl_endp(v9))){
      goto L13;
     }
     goto L12;
L13:;
     {
      cl_object v11;
      v11 = ECL_CONS_CAR(v9);
      v7var = ecl_car(v11);
      v11 = ecl_cdr(v11);
      v8type = v11;
     }
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v9);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v11;
     }
     v10name = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v7var) /*  VAR-NAME */;
     if (!((v8type)==(ECL_T))){
      goto L29;
     }
     v4checks = CONS(ECL_NIL,v4checks);
     goto L28;
L29:;
     if (Null(v2policy_check_type)){
      goto L32;
     }
     {
      cl_object v11;
      cl_object v12decl;
      cl_object v13;
      {
       cl_object v14;
       v14 = v3other_decls;
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      v12decl = ECL_NIL;
      v13 = v11;
L40:;
      if (!(ecl_endp(v13))){
       goto L42;
      }
      goto L41;
L42:;
      v12decl = ECL_CONS_CAR(v13);
      {
       cl_object v14;
       v14 = ECL_CONS_CDR(v13);
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v13 = v14;
      }
      if (!(ECL_CONSP(v12decl))){
       goto L50;
      }
      T0 = ecl_car(v12decl);
      if (!((T0)==(VV[55]))){
       goto L50;
      }
      {
       cl_object v14;
       cl_object v15;
       cl_object v16;
       v14 = ecl_cdr(v12decl);
       v15 = v10name;
       v16 = v14;
       if (Null(ecl_memql(v15,v16))){
        goto L50;
       }
      }
      goto L32;
L50:;
      goto L40;
L41:;
      goto L33;
     }
L33:;
     ecl_structure_set(v7var,VV[41],(cl_fixnum)(11),ECL_T);
     T0 = cl_list(3, VV[56], v10name, v8type);
     v4checks = CONS(T0,v4checks);
     T0 = cl_list(3, ECL_SYM("TRULY-THE",2081), v8type, v10name);
     v5new_auxs = cl_listX(3, T0, v10name, v5new_auxs);
     goto L28;
L32:;
     {
      cl_object v11;
      T0 = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v7var) /*  VAR-TYPE */;
      v11 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(2, T0, v8type) /*  TYPE-AND */;
      ecl_structure_set(v7var,VV[41],(cl_fixnum)(11),v11);
     }
L28:;
     goto L11;
L12:;
     cl_env_copy->nvalues = 2;
     cl_env_copy->values[1] = v5new_auxs;
     cl_env_copy->values[0] = v4checks;
     return cl_env_copy->values[0];
    }
   }
  }
 }
}
static cl_object L3428lambda_type_check_expand_va(cl_narg narg, cl_object v11type_checks, cl_object v12policy_check_type, cl_object v13other_decls, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[54]);
 {
  return L3428lambda_type_check_expand(v11type_checks, v12policy_check_type, v13other_decls);
 }
}
/* function definition for EXTRACT-LAMBDA-TYPE-CHECKS                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3430extract_lambda_type_checks(cl_object v1fname, cl_object v2requireds, cl_object v3optionals, cl_object v4keywords, cl_object v5ts, cl_object v6other_decls)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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(v5ts,env0);                   /*  TS                      */
 {
  cl_object v7global_fun_p;
  cl_object v8policy_check_type;
  cl_object v9all_type_checks;
  cl_object v10checks;
  cl_object v11new_auxs;
  {
   cl_object v12;
   cl_object v13;
   cl_object v14;
   v12 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
   v13 = VV[59];
   v14 = v6other_decls;
   v7global_fun_p = ecl_member(v13,v14);
  }
  v8policy_check_type = (cl_env_copy->function=ecl_fdefinition(VV[60]))->cfun.entry(0) /*  POLICY-CHECK-ARGUMENTS-TYPE */;
  {
   cl_object v12;
   {
    cl_object v13;
    v13 = ecl_make_cclosure_va((cl_objectfn)LC3429__lambda124,env0,Cblock,1);
    v12 = v13;
   }
   {
    cl_object v13;
    cl_object v14;
    cl_object v15;
    {
     cl_object v16;
     v16 = L3426lambda_type_check_associate(v1fname, v2requireds, v3optionals, v4keywords, v7global_fun_p);
     if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v13 = v16;
    }
    v14 = ECL_NIL;
    v15 = v13;
    {
     cl_object v16;
     cl_object v17;
     v16 = ecl_list1(ECL_NIL);
     v17 = v16;
L15:;
     if (!(ecl_endp(v15))){
      goto L17;
     }
     goto L16;
L17:;
     v14 = ECL_CONS_CAR(v15);
     {
      cl_object v18;
      v18 = ECL_CONS_CDR(v15);
      if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v15 = v18;
     }
     {
      cl_object v18;
      v18 = v17;
      if (ecl_unlikely(ECL_ATOM(v18))) FEtype_error_cons(v18);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v18;
     }
     T1 = ecl_function_dispatch(cl_env_copy,v12)(1, v14);
     v17 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v17,T0);
     goto L15;
L16:;
     v9all_type_checks = ecl_cdr(v16);
     goto L6;
    }
   }
  }
L6:;
  v10checks = ECL_NIL;
  v11new_auxs = ECL_NIL;
  {
   cl_object v12;
   cl_object v13i;
   cl_object v14;
   {
    cl_object v15;
    v15 = v9all_type_checks;
    if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v12 = v15;
   }
   v13i = ECL_NIL;
   v14 = v12;
   {
    cl_object v15;
    cl_object v16;
    v15 = ecl_list1(ECL_NIL);
    v16 = v15;
L44:;
    if (!(ecl_endp(v14))){
     goto L46;
    }
    goto L45;
L46:;
    v13i = ECL_CONS_CAR(v14);
    {
     cl_object v17;
     v17 = ECL_CONS_CDR(v14);
     if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v14 = v17;
    }
    {
     cl_object v17;
     v17 = v16;
     if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v17;
    }
    {
     cl_object v17;                               /*  CHECK                   */
     cl_object v18;                               /*  NEW-AUX                 */
     value0 = L3428lambda_type_check_expand(v13i, v8policy_check_type, v6other_decls);
     {
      const int v19 = cl_env_copy->nvalues;
      v17 = value0;
      cl_object v20;
      v20 = (v19<=1)? ECL_NIL : cl_env_copy->values[1];
      v18 = v20;
     }
     v11new_auxs = ecl_nconc(v18,v11new_auxs);
     T1 = v17;
    }
    v16 = ecl_list1(T1);
    (ECL_CONS_CDR(T0)=v16,T0);
    goto L44;
L45:;
    v10checks = ecl_cdr(v15);
    goto L36;
   }
  }
L36:;
  if (Null(v11new_auxs)){
   goto L65;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[39])) /*  FUN-NAME */;
  {
   cl_object v12;
   cl_object v13i;
   cl_object v14;
   {
    cl_object v15;
    v15 = ecl_cdr(v11new_auxs);
    if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v12 = v15;
   }
   v13i = ECL_NIL;
   v14 = v12;
   {
    cl_object v15;
    cl_object v16;
    v15 = ecl_list1(ECL_NIL);
    v16 = v15;
L75:;
    if (!(ecl_endp(v14))){
     goto L77;
    }
    goto L76;
L77:;
    v13i = ECL_CONS_CAR(v14);
    {
     cl_object v17;
     v17 = ecl_cddr(v14);
     if (ecl_unlikely(!ECL_LISTP(v17))) FEtype_error_list(v17);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v14 = v17;
    }
    {
     cl_object v17;
     v17 = v16;
     if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T2 = v17;
    }
    v16 = ecl_list1(v13i);
    (ECL_CONS_CDR(T2)=v16,T2);
    goto L75;
L76:;
    T1 = ecl_cdr(v15);
    goto L67;
   }
  }
L67:;
  T2 = cl_nreverse(T1);
  (cl_env_copy->function=ecl_fdefinition(VV[62]))->cfun.entry(3, VV[63], T0, T2) /*  CMPNOTE */;
L65:;
  T0 = ecl_car(v10checks);
  T1 = cl_nreverse(T0);
  T2 = ecl_cadr(v10checks);
  T3 = cl_nreverse(T2);
  T4 = ecl_caddr(v10checks);
  T5 = cl_nreverse(T4);
  T6 = cl_nreverse(v11new_auxs);
  cl_env_copy->nvalues = 4;
  cl_env_copy->values[3] = T6;
  cl_env_copy->values[2] = T5;
  cl_env_copy->values[1] = T3;
  cl_env_copy->values[0] = T1;
  return cl_env_copy->values[0];
 }
}
static cl_object L3430extract_lambda_type_checks_va(cl_narg narg, cl_object v12fname, cl_object v13requireds, cl_object v14optionals, cl_object v15keywords, cl_object v16ts, cl_object v17other_decls, ...)
{
 if (ecl_unlikely(narg!=6)) FEwrong_num_arguments(VV[58]);
 {
  return L3430extract_lambda_type_checks(v12fname, v13requireds, v14optionals, v15keywords, v16ts, v17other_decls);
 }
}
/* local function ASSERT-TYPE-IF-KNOWN                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3431assert_type_if_known(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object 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_object v6;                                  /*  TRIVIAL                 */
   cl_object v7;                                  /*  VALID                   */
   value0 = cl_subtypep(3, ECL_T, v5type, ecl_cmp_symbol_value(cl_env_copy,VV[24]));
   {
    v6 = value0;
    v7 = cl_env_copy->values[1];
   }
   if (Null(v6)){
    goto L18;
   }
   if (Null(v7)){
    goto L18;
   }
   value0 = v4value;
   cl_env_copy->nvalues = 1;
   return value0;
L18:;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[67]))->cfun.entry(2, v4value, v2env) /*  CONSTANT-VALUE-P */;
   {
    const int v8 = cl_env_copy->nvalues;
    v7 = value0;
    cl_object v9;
    v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
    v4value = v9;
   }
   if (Null(value0)){
    goto L21;
   }
   value0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("MAYBE-QUOTE",1764)))->cfun.entry(1, v4value) /*  MAYBE-QUOTE */;
   return value0;
L21:;
   T0 = cl_list(2, VV[68], v4value);
   T1 = ecl_list1(T0);
   T2 = (cl_env_copy->function=(VV[70]->symbol.gfdef))->cfun.entry(2, v5type, v2env) /*  FLATTEN-FUNCTION-TYPES */;
   T3 = (cl_env_copy->function=ecl_fdefinition(VV[69]))->cfun.entry(2, VV[68], T2) /*  SIMPLE-TYPE-ASSERTION */;
   T4 = cl_list(3, ECL_SYM("TRULY-THE",2081), v5type, VV[68]);
   value0 = cl_list(4, ECL_SYM("LET*",480), T1, T3, T4);
   return value0;
  }
 }
}
static cl_object LC3431assert_type_if_known_va(cl_narg narg, cl_object v6, cl_object v7env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[27]);
 {
  return LC3431assert_type_if_known(v6, v7env);
 }
}
/* local function OPTIONAL-TYPE-CHECK                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3432optional_type_check(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 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[72]))->cfun.entry(0) /*  POLICY-ASSUME-RIGHT-TYPE */)){
   goto L17;
  }
  value0 = v4value;
  cl_env_copy->nvalues = 1;
  return value0;
L17:;
  value0 = cl_list(3, VV[27], v4value, v5type);
  return value0;
 }
}
static cl_object LC3432optional_type_check_va(cl_narg narg, cl_object v6, cl_object v7, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
  return LC3432optional_type_check(v6, v7);
 }
}
/* local function WITH-LET*-TYPE-CHECK                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3433with_let__type_check(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 v4triplets;
  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);
   v4triplets = v5;
  }
  {
   cl_object v5;
   cl_object v6var;
   cl_object v7value;
   cl_object v8type;
   cl_object v9;
   {
    cl_object v10;
    v10 = v4triplets;
    if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v10;
   }
   v6var = ECL_NIL;
   v7value = ECL_NIL;
   v8type = ECL_NIL;
   v9 = v5;
   {
    cl_object v10;
    cl_object v11;
    v10 = ecl_list1(ECL_NIL);
    v11 = v10;
L19:;
    if (!(ecl_endp(v9))){
     goto L21;
    }
    goto L20;
L21:;
    {
     cl_object v12;
     v12 = ECL_CONS_CAR(v9);
     v6var = ecl_car(v12);
     v12 = ecl_cdr(v12);
     v7value = ecl_car(v12);
     v12 = ecl_cdr(v12);
     v8type = ecl_car(v12);
    }
    {
     cl_object v12;
     v12 = ECL_CONS_CDR(v9);
     if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v9 = v12;
    }
    {
     cl_object v12;
     v12 = v11;
     if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v12;
    }
    T2 = cl_list(3, VV[27], v7value, v8type);
    T3 = cl_list(2, v6var, T2);
    v11 = ecl_list1(T3);
    (ECL_CONS_CDR(T1)=v11,T1);
    goto L19;
L20:;
    T0 = ecl_cdr(v10);
    goto L9;
   }
  }
L9:;
  {
   cl_object v5;
   v5 = (ECL_SYM("CAR",182)->symbol.gfdef);
   {
    cl_object v6;
    cl_object v7;
    cl_object v8;
    {
     cl_object v9;
     v9 = v4triplets;
     if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v6 = v9;
    }
    v7 = ECL_NIL;
    v8 = v6;
    {
     cl_object v9;
     cl_object v10;
     v9 = ecl_list1(ECL_NIL);
     v10 = v9;
L54:;
     if (!(ecl_endp(v8))){
      goto L56;
     }
     goto L55;
L56:;
     v7 = ECL_CONS_CAR(v8);
     {
      cl_object v11;
      v11 = ECL_CONS_CDR(v8);
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     {
      cl_object v11;
      v11 = v10;
      if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T2 = v11;
     }
     T3 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
     v10 = ecl_list1(T3);
     (ECL_CONS_CDR(T2)=v10,T2);
     goto L54;
L55:;
     T1 = ecl_cdr(v9);
     goto L45;
    }
   }
  }
L45:;
  T2 = CONS(VV[75],T1);
  T3 = cl_list(2, ECL_SYM("DECLARE",276), T2);
  value0 = cl_listX(4, ECL_SYM("LET*",480), T0, T3, v3);
  return value0;
 }
}
static cl_object LC3433with_let__type_check_va(cl_narg narg, cl_object v5, cl_object v6, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[74]);
 {
  return LC3433with_let__type_check(v5, v6);
 }
}
/* local function LAMBDA20                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3422__lambda20(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);
L1:;
 value0 = cl_subtypep(3, v1t1, v2t2, ecl_cmp_symbol_value(cl_env_copy,VV[24]));
 return value0;
}
static cl_object LC3422__lambda20_va(cl_narg narg, cl_object v3t1, cl_object v4t2, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[23]);
 {
  return LC3422__lambda20(v3t1, v4t2);
 }
}
/* local function MAYBE-FIX-TYPE                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3424maybe_fix_type(cl_object v1var, cl_object v2init, cl_object v3type, cl_object v4type_iterator)
{
 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 v5;                                   /*  CONSTANTP               */
  cl_object v6;                                   /*  VALUE                   */
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[33]))->cfun.entry(1, v2init) /*  C1FORM-CONSTANT-P */;
  {
   const int v7 = cl_env_copy->nvalues;
   v5 = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v6 = v8;
  }
  if (Null(v5)){
   goto L3;
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, v6, v3type) /*  CMP-TYPEP */!=ECL_NIL) {
   goto L3;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v1var) /*  VAR-NAME */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[39])) /*  FUN-NAME */;
  (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(4, VV[36], T0, T1, v3type) /*  CMPWARN-STYLE */;
  {
   cl_object v7;
   T0 = cl_list(2, ECL_SYM("EQL",336), v6);
   v7 = (cl_env_copy->function=ecl_fdefinition(VV[40]))->cfun.entry(2, v3type, T0) /*  TYPE-OR */;
   {
    cl_object v8;
    v8 = v4type_iterator;
    if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v8;
   }
   (ECL_CONS_CAR(T0)=v7,T0);
  }
  {
   cl_object v7;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[15]))->cfun.entry(1, v1var) /*  VAR-TYPE */;
   T1 = cl_list(2, ECL_SYM("EQL",336), v6);
   v7 = (cl_env_copy->function=ecl_fdefinition(VV[40]))->cfun.entry(2, T0, T1) /*  TYPE-OR */;
   value0 = ecl_structure_set(v1var,VV[41],(cl_fixnum)(11),v7);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3424maybe_fix_type_va(cl_narg narg, cl_object v5var, cl_object v6init, cl_object v7type, cl_object v8type_iterator, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[32]);
 {
  return LC3424maybe_fix_type(v5var, v6init, v7type, v8type_iterator);
 }
}
/* closure LAMBDA124                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3429__lambda124(cl_narg narg, cl_object v1checks, ...)
{
 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;                                     /*  TS                      */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[61]);
 {
L1:;
  value0 = L3427lambda_type_check_precise(v1checks, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
#include "cmp/cmptype.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclx94MDemStPEk9_9NS0M881(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.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclx94MDemStPEk9_9NS0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[77]);                          /*  AND-FORM-TYPE           */
  ecl_cmp_defun(VV[78]);                          /*  AND-CALL-TYPE           */
  ecl_cmp_defun(VV[79]);                          /*  DEFAULT-INIT            */
  ecl_cmp_defun(VV[80]);                          /*  LAMBDA-TYPE-CHECK-INIT-FORMS */
  ecl_cmp_defun(VV[81]);                          /*  LAMBDA-TYPE-CHECK-ASSOCIATE */
  ecl_cmp_defun(VV[82]);                          /*  LAMBDA-TYPE-CHECK-PRECISE */
  ecl_cmp_defun(VV[83]);                          /*  LAMBDA-TYPE-CHECK-EXPAND */
  ecl_cmp_defun(VV[84]);                          /*  EXTRACT-LAMBDA-TYPE-CHECKS */
  ecl_cmp_defmacro(VV[85]);                       /*  ASSERT-TYPE-IF-KNOWN    */
  ecl_cmp_defmacro(VV[86]);                       /*  OPTIONAL-TYPE-CHECK     */
  ecl_cmp_defmacro(VV[87]);                       /*  WITH-LET*-TYPE-CHECK    */
}
