/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmppass1-var.lsp                */
#include <ecl/ecl-cmp.h>
#include "cmp/cmppass1-var.eclh"
/* function definition for C1LET                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3523c1let(cl_object v1args)
{
 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_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(3, ECL_SYM("LET",479), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2bindings;
  {
   cl_object v3;
   v3 = v1args;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[4],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L8;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v1args = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L8:;
   v2bindings = v3;
  }
  if (!(v2bindings==ECL_NIL)){
   goto L14;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[5]))->cfun.entry(1, v1args) /*  C1LOCALLY */;
  return value0;
L14:;
  if (!(ECL_ATOM(v2bindings))){
   goto L16;
  }
  value0 = L3526invalid_let_bindings(ECL_SYM("LET",479), v2bindings);
  return value0;
L16:;
  T0 = ecl_cdr(v2bindings);
  if (!(T0==ECL_NIL)){
   goto L18;
  }
  value0 = L3525c1let_let_(ECL_SYM("LET*",480), v2bindings, v1args);
  return value0;
L18:;
  {
   cl_object v3temp;
   v3temp = ECL_NIL;
   {
    cl_object v4type_decls;
    {
     struct ecl_stack_frame _ecl_inner_frame_aux;
     cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
     cl_env_copy->values[0] = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(2, v1args, ECL_NIL) /*  C1BODY */;
     ecl_stack_frame_push_values(_ecl_inner_frame);
     T0 = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
     ecl_stack_frame_close(_ecl_inner_frame);
    }
    v4type_decls = ecl_caddr(T0);
    {
     cl_object v5temp_type_decls;
     v5temp_type_decls = ECL_NIL;
     {
      cl_object v6;
      cl_object v7b;
      cl_object v8;
      {
       cl_object v9;
       v9 = v2bindings;
       if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v6 = v9;
      }
      v7b = ECL_NIL;
      v8 = v6;
      {
       cl_object v9;
       cl_object v10;
       cl_object v11real_bindings;
       v9 = ecl_list1(ECL_NIL);
       v10 = v9;
       v11real_bindings = ECL_NIL;
       {
        cl_object v12;
        cl_object v13;
        cl_object v14names;
        v12 = ecl_list1(ECL_NIL);
        v13 = v12;
        v14names = ECL_NIL;
        {
         cl_object v15;
         cl_object v16;
         cl_object v17temp_names;
         v15 = ecl_list1(ECL_NIL);
         v16 = v15;
         v17temp_names = ECL_NIL;
         {
          cl_object v18;
          cl_object v19;
          cl_object v20temp_bindings;
          v18 = ecl_list1(ECL_NIL);
          v19 = v18;
          v20temp_bindings = ECL_NIL;
L42:;
          if (!(ecl_endp(v8))){
          goto L44;
          }
          goto L43;
L44:;
          v7b = ECL_CONS_CAR(v8);
          {
          cl_object v21;
          v21 = ECL_CONS_CDR(v8);
          if (ecl_unlikely(!ECL_LISTP(v21))) FEtype_error_list(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v8 = v21;
          }
          if (!(ECL_ATOM(v7b))){
          goto L53;
          }
          {
          cl_object v21;
          v21 = v10;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          v10 = ecl_list1(v7b);
          (ECL_CONS_CDR(T0)=v10,T0);
          v11real_bindings = ecl_cdr(v9);
          {
          cl_object v21;
          v21 = v13;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          v13 = ecl_list1(v7b);
          (ECL_CONS_CDR(T0)=v13,T0);
          v14names = ecl_cdr(v12);
          goto L52;
L53:;
          {
          cl_object v21;
          v21 = v16;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          v3temp = cl_gensym(1, VV[13]);
          v16 = ecl_list1(v3temp);
          (ECL_CONS_CDR(T0)=v16,T0);
          v17temp_names = ecl_cdr(v15);
          {
          cl_object v21;
          v21 = v19;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          T1 = ecl_cdr(v7b);
          T2 = CONS(v3temp,T1);
          v19 = ecl_list1(T2);
          (ECL_CONS_CDR(T0)=v19,T0);
          v20temp_bindings = ecl_cdr(v18);
          {
          cl_object v21;
          v21 = v10;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          T1 = ecl_car(v7b);
          T2 = cl_list(2, T1, v3temp);
          v10 = ecl_list1(T2);
          (ECL_CONS_CDR(T0)=v10,T0);
          v11real_bindings = ecl_cdr(v9);
          {
          cl_object v21;
          v21 = v13;
          if (ecl_unlikely(ECL_ATOM(v21))) FEtype_error_cons(v21);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v21;
          }
          T1 = ecl_car(v7b);
          v13 = ecl_list1(T1);
          (ECL_CONS_CDR(T0)=v13,T0);
          v14names = ecl_cdr(v12);
          {
          cl_object v21type_decl;
          {
          cl_object v22;
          cl_object v23;
          cl_object v24;
          v22 = ecl_car(v7b);
          v23 = (ECL_SYM("CAR",182)->symbol.gfdef);
          v24 = (ECL_SYM("EQ",335)->symbol.gfdef);
          {
          cl_object v25;
          v25 = si_make_seq_iterator(2, v4type_decls, ecl_make_int8_t(0));
L102:;
          if (v25!=ECL_NIL) {
          goto L104;
          }
          v21type_decl = ECL_NIL;
          goto L97;
L104:;
          {
          cl_object v26;
          v26 = si_seq_iterator_ref(v4type_decls, v25);
          T0 = ecl_car(v26);
          if (!((v22)==(T0))){
          goto L106;
          }
          v21type_decl = v26;
          goto L97;
          }
L106:;
          v25 = si_seq_iterator_next(v4type_decls, v25);
          goto L102;
          }
          }
L97:;
          if (Null(v21type_decl)){
          goto L52;
          }
          T0 = ecl_cdr(v21type_decl);
          T1 = cl_list(3, ECL_SYM("TYPE",872), T0, v3temp);
          v5temp_type_decls = CONS(T1,v5temp_type_decls);
          }
L52:;
          {
          cl_object v21;
          cl_object v22;
          cl_object v23;
          cl_object v24;
          cl_object v25;
          v21 = ecl_car(v14names);
          v22 = ecl_cdr(v14names);
          v23 = (ECL_SYM("EQ",335)->symbol.gfdef);
          v24 = v21;
          v25 = v22;
          if (Null(si_memq(v24,v25))){
          goto L113;
          }
          }
          T0 = ecl_car(v14names);
          (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[20], T0) /*  CMPERR */;
L113:;
          goto L42;
L43:;
          T0 = ecl_nconc(v20temp_bindings,v11real_bindings);
          T1 = CONS(ECL_SYM("IGNORABLE",429),v17temp_names);
          T2 = CONS(VV[21],v17temp_names);
          T3 = cl_listX(4, ECL_SYM("DECLARE",276), T1, T2, v5temp_type_decls);
          T4 = CONS(T3,v1args);
          value0 = L3525c1let_let_(ECL_SYM("LET*",480), T0, T4);
          return value0;
         }
        }
       }
      }
     }
    }
   }
  }
 }
}
static cl_object L3523c1let_va(cl_narg narg, cl_object v21args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[0]);
 {
  return L3523c1let(v21args);
 }
}
/* function definition for C1LET*                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3524c1let_(cl_object v1args)
{
 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->function=ecl_fdefinition(VV[1]))->cfun.entry(3, ECL_SYM("LET*",480), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2bindings;
  {
   cl_object v3;
   v3 = v1args;
   {
    cl_object v4;
    v4 = v3;
    {
     bool v5;
     v5 = ECL_LISTP(v4);
     if (ecl_unlikely(!(v5)))
         FEwrong_type_argument(VV[4],v4);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v3)){
    goto L8;
   }
   {
    cl_object v4;
    v4 = ECL_CONS_CDR(v3);
    v1args = v4;
    v3 = ECL_CONS_CAR(v3);
   }
L8:;
   v2bindings = v3;
  }
  if (!(v2bindings==ECL_NIL)){
   goto L14;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[5]))->cfun.entry(1, v1args) /*  C1LOCALLY */;
  return value0;
L14:;
  if (!(ECL_ATOM(v2bindings))){
   goto L16;
  }
  value0 = L3526invalid_let_bindings(ECL_SYM("LET*",480), v2bindings);
  return value0;
L16:;
  value0 = L3525c1let_let_(ECL_SYM("LET*",480), v2bindings, v1args);
  return value0;
 }
}
static cl_object L3524c1let__va(cl_narg narg, cl_object v3args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[23]);
 {
  return L3524c1let_(v3args);
 }
}
/* function definition for C1LET/LET*                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3525c1let_let_(cl_object v1let_let_, cl_object v2bindings, cl_object v3body)
{
 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 v4setjmps;
  v4setjmps = ecl_cmp_symbol_value(cl_env_copy,VV[25]);
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(0) /*  CMP-ENV-COPY */;
  ecl_bds_bind(cl_env_copy,VV[26],T0);            /*  *CMP-ENV*               */
  {
   cl_object v5;                                  /*  VARS                    */
   cl_object v6;                                  /*  FORMS                   */
   cl_object v7;                                  /*  SPECIALS                */
   cl_object v8;                                  /*  OTHER-DECLS             */
   cl_object v9;                                  /*  BODY                    */
   value0 = L3527process_let_bindings(v1let_let_, v2bindings, v3body);
   {
    const int v10 = cl_env_copy->nvalues;
    v5 = value0;
    cl_object v11;
    v11 = (v10<=1)? ECL_NIL : cl_env_copy->values[1];
    v6 = v11;
    v11 = (v10<=2)? ECL_NIL : cl_env_copy->values[2];
    v7 = v11;
    v11 = (v10<=3)? ECL_NIL : cl_env_copy->values[3];
    v8 = v11;
    v11 = (v10<=4)? ECL_NIL : cl_env_copy->values[4];
    v9 = v11;
   }
   value0 = L3528process_let_body(v1let_let_, v5, v6, v7, v8, v9, v4setjmps);
   ecl_bds_unwind1(cl_env_copy);
   return value0;
  }
 }
}
static cl_object L3525c1let_let__va(cl_narg narg, cl_object v5let_let_, cl_object v6bindings, cl_object v7body, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[7]);
 {
  return L3525c1let_let_(v5let_let_, v6bindings, v7body);
 }
}
/* function definition for INVALID-LET-BINDINGS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3526invalid_let_bindings(cl_object v1let_let_, cl_object v2bindings)
{
 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_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(3, VV[31], v1let_let_, v2bindings) /*  CMPERR */;
 return value0;
}
static cl_object L3526invalid_let_bindings_va(cl_narg narg, cl_object v3let_let_, cl_object v4bindings, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[6]);
 {
  return L3526invalid_let_bindings(v3let_let_, v4bindings);
 }
}
/* function definition for PROCESS-LET-BINDINGS                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3527process_let_bindings(cl_object v1let_let_, cl_object v2bindings, cl_object v3body)
{
 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 v4;                                   /*  BODY                    */
  cl_object v5;                                   /*  SPECIALS                */
  cl_object v6;                                   /*  TYPES                   */
  cl_object v7;                                   /*  IGNOREDS                */
  cl_object v8;                                   /*  OTHER-DECLS             */
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(2, v3body, ECL_NIL) /*  C1BODY */;
  {
   const int v9 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v10;
   v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v10;
   v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
   v6 = v10;
   v10 = (v9<=3)? ECL_NIL : cl_env_copy->values[3];
   v7 = v10;
   v10 = (v9<=4)? ECL_NIL : cl_env_copy->values[4];
   v8 = v10;
  }
  {
   cl_object v9vars;
   cl_object v10forms;
   v9vars = ECL_NIL;
   v10forms = ECL_NIL;
   {
    cl_object v11b;
    cl_object v12name;
    cl_object v13form;
    v11b = v2bindings;
    v12name = ECL_NIL;
    v13form = ECL_NIL;
    goto L11;
L10:;
    {
     cl_object v14;
     v14 = v11b;
     {
      cl_object v15;
      v15 = v14;
      {
       bool v16;
       v16 = ECL_LISTP(v15);
       if (ecl_unlikely(!(v16)))
         FEwrong_type_argument(VV[4],v15);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v14)){
      goto L21;
     }
     {
      cl_object v15;
      v15 = ECL_CONS_CDR(v14);
      v11b = v15;
      v14 = ECL_CONS_CAR(v14);
     }
L21:;
     v13form = v14;
    }
    if (!(ECL_SYMBOLP(v13form))){
     goto L14;
    }
    v12name = v13form;
    v13form = ECL_NIL;
    goto L13;
L14:;
    (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(4, VV[33], v13form, ecl_make_int8_t(1), ecl_make_int8_t(2)) /*  CHECK-ARGS-NUMBER */;
    v12name = ecl_car(v13form);
    v13form = ecl_cdr(v13form);
L13:;
    {
     cl_object v14var;
     cl_object v15type;
     cl_object v16init;
     v14var = L3536c1make_var(v12name, v5, v7, v6);
     v15type = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v14var) /*  VAR-TYPE */;
     if (!(v13form==ECL_NIL)){
      goto L38;
     }
     v16init = (cl_env_copy->function=ecl_fdefinition(VV[36]))->cfun.entry(1, v14var) /*  DEFAULT-INIT */;
     goto L37;
L38:;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v15type) /*  TRIVIAL-TYPE-P */)){
      goto L40;
     }
     T0 = ecl_car(v13form);
     v16init = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T0) /*  C1EXPR */;
     goto L37;
L40:;
     T0 = ecl_car(v13form);
     T1 = cl_list(3, ECL_SYM("CHECKED-VALUE",2082), v15type, T0);
     v16init = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T1) /*  C1EXPR */;
L37:;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[39]))->cfun.entry(2, v12name, v8) /*  READ-ONLY-VARIABLE-P */)){
      goto L42;
     }
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[40]))->cfun.entry(1, v14var) /*  GLOBAL-VAR-P */)){
      goto L45;
     }
     (cl_env_copy->function=ecl_fdefinition(VV[41]))->cfun.entry(2, VV[42], v12name) /*  CMPWARN */;
     goto L44;
L45:;
     {
      cl_object v17;
      T0 = (cl_env_copy->function=ecl_fdefinition(VV[44]))->cfun.entry(1, v16init) /*  C1FORM-PRIMARY-TYPE */;
      v17 = (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(2, v15type, T0) /*  TYPE-AND */;
      ecl_structure_set(v14var,VV[45],(cl_fixnum)(11),v17);
     }
L44:;
     {
      cl_object v17;                              /*  CONSTANTP               */
      cl_object v18;                              /*  VALUE                   */
      value0 = (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(1, v16init) /*  C1FORM-CONSTANT-P */;
      {
       const int v19 = cl_env_copy->nvalues;
       v17 = value0;
       cl_object v20;
       v20 = (v19<=1)? ECL_NIL : cl_env_copy->values[1];
       v18 = v20;
      }
      if (Null(v17)){
       goto L42;
      }
      T0 = cl_list(2, ECL_SYM("QUOTE",682), v18);
      (cl_env_copy->function=ecl_fdefinition(VV[47]))->cfun.entry(2, v12name, T0) /*  CMP-ENV-REGISTER-SYMBOL-MACRO */;
      v14var = ECL_NIL;
     }
L42:;
     if (Null(v14var)){
      goto L34;
     }
     v9vars = CONS(v14var,v9vars);
     v10forms = CONS(v16init,v10forms);
     if (!((v1let_let_)==(ECL_SYM("LET*",480)))){
      goto L34;
     }
     (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, v14var) /*  CMP-ENV-REGISTER-VAR */;
    }
L34:;
L11:;
    if (ECL_ATOM(v11b)) {
     goto L58;
    }
    goto L10;
L58:;
    if (v11b==ECL_NIL) {
     goto L5;
    }
    L3526invalid_let_bindings(v1let_let_, v2bindings);
   }
L5:;
   v9vars = cl_nreverse(v9vars);
   v10forms = cl_nreverse(v10forms);
   if (!((v1let_let_)==(ECL_SYM("LET",479)))){
    goto L65;
   }
   {
    cl_object v11;
    v11 = ecl_fdefinition(VV[48]);
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = v9vars;
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
L73:;
     if (!(ecl_endp(v14))){
      goto L75;
     }
     goto L74;
L75:;
     v13 = ECL_CONS_CAR(v14);
     {
      cl_object v15;
      v15 = ECL_CONS_CDR(v14);
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v14 = v15;
     }
     ecl_function_dispatch(cl_env_copy,v11)(1, v13);
     goto L73;
L74:;
     goto L65;
    }
   }
L65:;
   {
    cl_object v11;
    v11 = ecl_fdefinition(VV[50]);
    {
     cl_object v12;
     cl_object v13;
     cl_object v14;
     {
      cl_object v15;
      v15 = v9vars;
      if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v15;
     }
     v13 = ECL_NIL;
     v14 = v12;
     {
      cl_object v15;
      cl_object v16;
      v15 = ecl_list1(ECL_NIL);
      v16 = v15;
L96:;
      if (!(ecl_endp(v14))){
       goto L98;
      }
      goto L97;
L98:;
      v13 = 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;
       T1 = v17;
      }
      T2 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
      v16 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v16,T1);
      goto L96;
L97:;
      T0 = ecl_cdr(v15);
      goto L87;
     }
    }
   }
L87:;
   (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(3, T0, v6, v7) /*  CHECK-VDECL */;
   cl_env_copy->nvalues = 5;
   cl_env_copy->values[4] = v4;
   cl_env_copy->values[3] = v8;
   cl_env_copy->values[2] = v5;
   cl_env_copy->values[1] = v10forms;
   cl_env_copy->values[0] = v9vars;
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L3527process_let_bindings_va(cl_narg narg, cl_object v4let_let_, cl_object v5bindings, cl_object v6body, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[28]);
 {
  return L3527process_let_bindings(v4let_let_, v5bindings, v6body);
 }
}
/* function definition for PROCESS-LET-BODY                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3528process_let_body(cl_object v1let_let_, cl_object v2vars, cl_object v3forms, cl_object v4specials, cl_object v5other_decls, cl_object v6body, cl_object v7setjmps)
{
 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 v8;
  v8 = ecl_fdefinition(VV[53]);
  {
   cl_object v9;
   cl_object v10;
   cl_object v11;
   {
    cl_object v12;
    v12 = v4specials;
    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;
L9:;
   if (!(ecl_endp(v11))){
    goto L11;
   }
   goto L10;
L11:;
   v10 = ECL_CONS_CAR(v11);
   {
    cl_object v12;
    v12 = ECL_CONS_CDR(v11);
    if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v11 = v12;
   }
   ecl_function_dispatch(cl_env_copy,v8)(1, v10);
   goto L9;
L10:;
   goto L2;
  }
 }
L2:;
 v6body = (cl_env_copy->function=ecl_fdefinition(VV[54]))->cfun.entry(2, v5other_decls, v6body) /*  C1DECL-BODY */;
 value0 = L3529c1let_optimize_read_only_vars(v2vars, v3forms, v6body);
 {
  const int v8 = cl_env_copy->nvalues;
  v2vars = value0;
  cl_object v9;
  v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
  v3forms = v9;
 }
 {
  cl_object v8;
  v8 = ecl_fdefinition(VV[56]);
  {
   cl_object v9;
   cl_object v10;
   cl_object v11;
   {
    cl_object v12;
    v12 = v2vars;
    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;
L33:;
   if (!(ecl_endp(v11))){
    goto L35;
   }
   goto L34;
L35:;
   v10 = ECL_CONS_CAR(v11);
   {
    cl_object v12;
    v12 = ECL_CONS_CDR(v11);
    if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v11 = v12;
   }
   ecl_function_dispatch(cl_env_copy,v8)(1, v10);
   goto L33;
L34:;
   goto L26;
  }
 }
L26:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v6body) /*  C1FORM-TYPE */;
 {
  bool v8;
  v8 = ecl_eql(v7setjmps,ecl_cmp_symbol_value(cl_env_copy,VV[25]));
  T1 = (v8)?ECL_NIL:ECL_T;
 }
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(11, v1let_let_, ECL_SYM("TYPE",1356), T0, VV[59], T1, VV[60], v2vars, VV[61], v2vars, v3forms, v6body) /*  MAKE-C1FORM* */;
 return value0;
}
static cl_object L3528process_let_body_va(cl_narg narg, cl_object v8let_let_, cl_object v9vars, cl_object v10forms, cl_object v11specials, cl_object v12other_decls, cl_object v13body, cl_object v14setjmps, ...)
{
 if (ecl_unlikely(narg!=7)) FEwrong_num_arguments(VV[29]);
 {
  return L3528process_let_body(v8let_let_, v9vars, v10forms, v11specials, v12other_decls, v13body, v14setjmps);
 }
}
/* function definition for C1LET-OPTIMIZE-READ-ONLY-VARS                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3529c1let_optimize_read_only_vars(cl_object v1all_vars, cl_object v2all_forms, cl_object v3body)
{
 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 v4vars;
  v4vars = v1all_vars;
  {
   cl_object v5forms;
   T0 = ecl_list1(v3body);
   v5forms = ecl_nconc(v2all_forms,T0);
   {
    cl_object v6var;
    v6var = ECL_NIL;
    {
     cl_object v7form;
     v7form = ECL_NIL;
     {
      cl_object v8rest_vars;
      v8rest_vars = ECL_NIL;
      {
       cl_object v9rest_forms;
       v9rest_forms = ECL_NIL;
       {
        cl_object v10read_only_p;
        v10read_only_p = ECL_NIL;
        {
         cl_object v11;
         cl_object v12;
         cl_object v13used_vars;
         v11 = ecl_list1(ECL_NIL);
         v12 = v11;
         v13used_vars = ECL_NIL;
         {
          cl_object v14;
          cl_object v15;
          cl_object v16used_forms;
          v14 = ecl_list1(ECL_NIL);
          v15 = v14;
          v16used_forms = ECL_NIL;
          if (!(ECL_ATOM(v4vars))){
          goto L17;
          }
          goto L16;
L17:;
L15:;
          if (!(ECL_ATOM(v5forms))){
          goto L19;
          }
          goto L16;
L19:;
          v6var = ecl_car(v4vars);
          v7form = ecl_car(v5forms);
          v8rest_vars = ecl_cdr(v4vars);
          v9rest_forms = ecl_cdr(v5forms);
          T0 = (cl_env_copy->function=ecl_fdefinition(VV[63]))->cfun.entry(1, v6var) /*  VAR-SET-NODES */;
          if (!(T0==ECL_NIL)){
          goto L32;
          }
          T0 = (cl_env_copy->function=ecl_fdefinition(VV[64]))->cfun.entry(1, v6var) /*  VAR-FUNCTIONS-READING */;
          if (!(T0==ECL_NIL)){
          goto L32;
          }
          T0 = (cl_env_copy->function=ecl_fdefinition(VV[65]))->cfun.entry(1, v6var) /*  VAR-FUNCTIONS-SETTING */;
          if (!(T0==ECL_NIL)){
          goto L32;
          }
          T0 = (cl_env_copy->function=ecl_fdefinition(VV[40]))->cfun.entry(1, v6var) /*  GLOBAL-VAR-P */;
          v10read_only_p = Null(T0)?ECL_T:ECL_NIL;
          goto L30;
L32:;
          v10read_only_p = ECL_NIL;
          goto L30;
L30:;
          if (Null(v10read_only_p)){
          goto L36;
          }
          L3530fix_read_only_variable_type(v6var, v7form);
L36:;
          if (Null(v10read_only_p)){
          goto L41;
          }
          if (L3531c1let_unused_variable_p(v6var, v7form)!=ECL_NIL) {
          goto L38;
          }
          if (L3532c1let_constant_value_p(v6var, v7form)!=ECL_NIL) {
          goto L38;
          }
          if (L3533c1let_constant_variable_p(v6var, v7form, v8rest_vars, v9rest_forms)!=ECL_NIL) {
          goto L38;
          }
          goto L39;
L41:;
          goto L39;
L39:;
          {
          cl_object v17;
          v17 = v12;
          if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v17;
          }
          v12 = ecl_list1(v6var);
          (ECL_CONS_CDR(T0)=v12,T0);
          v13used_vars = ecl_cdr(v11);
          {
          cl_object v17;
          v17 = v15;
          if (ecl_unlikely(ECL_ATOM(v17))) FEtype_error_cons(v17);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T0 = v17;
          }
          v15 = ecl_list1(v7form);
          (ECL_CONS_CDR(T0)=v15,T0);
          v16used_forms = ecl_cdr(v14);
L38:;
          v4vars = ECL_CONS_CDR(v4vars);
          if (!(ECL_ATOM(v4vars))){
          goto L60;
          }
          goto L16;
L60:;
          v5forms = ECL_CONS_CDR(v5forms);
          goto L15;
L16:;
          cl_env_copy->nvalues = 2;
          cl_env_copy->values[1] = v16used_forms;
          cl_env_copy->values[0] = v13used_vars;
          return cl_env_copy->values[0];
         }
        }
       }
      }
     }
    }
   }
  }
 }
}
static cl_object L3529c1let_optimize_read_only_vars_va(cl_narg narg, cl_object v17all_vars, cl_object v18all_forms, cl_object v19body, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[55]);
 {
  return L3529c1let_optimize_read_only_vars(v17all_vars, v18all_forms, v19body);
 }
}
/* function definition for FIX-READ-ONLY-VARIABLE-TYPE                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3530fix_read_only_variable_type(cl_object v1var, cl_object v2form)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v1var) /*  VAR-TYPE */;
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1var) /*  VAR-NAME */;
 (cl_env_copy->function=ecl_fdefinition(VV[71]))->cfun.entry(5, T0, v2form, T1, VV[72], VV[73]) /*  AND-FORM-TYPE */;
 {
  cl_object v3form_type;
  v3form_type = (cl_env_copy->function=ecl_fdefinition(VV[44]))->cfun.entry(1, v2form) /*  C1FORM-PRIMARY-TYPE */;
  ecl_structure_set(v1var,VV[45],(cl_fixnum)(11),v3form_type);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[74]))->cfun.entry(2, v1var, v3form_type) /*  UPDATE-VARIABLE-TYPE */;
  return value0;
 }
}
static cl_object L3530fix_read_only_variable_type_va(cl_narg narg, cl_object v4var, cl_object v5form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[66]);
 {
  return L3530fix_read_only_variable_type(v4var, v5form);
 }
}
/* function definition for C1LET-UNUSED-VARIABLE-P                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3531c1let_unused_variable_p(cl_object v1var, 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:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[76]))->cfun.entry(1, v1var) /*  VAR-REF */;
 if (!(ecl_number_equalp(ecl_make_int8_t(0),T0))){
  goto L2;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[77]))->cfun.entry(1, v1var) /*  VAR-KIND */;
  if (!((v3)==(ECL_SYM("SPECIAL",792)))){
   goto L9;
  }
  goto L2;
L9:;
  goto L7;
L7:;
  if (!((v3)==(VV[79]))){
   goto L12;
  }
  goto L2;
L12:;
  goto L5;
 }
L5:;
 if ((cl_env_copy->function=ecl_fdefinition(VV[81]))->cfun.entry(1, v2form) /*  C1FORM-SIDE-EFFECTS */!=ECL_NIL) {
  goto L2;
 }
 if ((cl_env_copy->function=ecl_fdefinition(VV[82]))->cfun.entry(1, v1var) /*  VAR-IGNORABLE */!=ECL_NIL) {
  goto L14;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1var) /*  VAR-NAME */;
 (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(2, VV[84], T0) /*  CMPDEBUG */;
L14:;
 (cl_env_copy->function=ecl_fdefinition(VV[85]))->cfun.entry(1, v2form) /*  DELETE-C1FORMS */;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3531c1let_unused_variable_p_va(cl_narg narg, cl_object v3var, cl_object v4form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[67]);
 {
  return L3531c1let_unused_variable_p(v3var, v4form);
 }
}
/* function definition for C1LET-CONSTANT-VALUE-P                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3532c1let_constant_value_p(cl_object v1var, cl_object v2form)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[87]))->cfun.entry(1, v2form) /*  C1FORM-NAME */;
 if (!((T0)==(VV[88]))){
  goto L2;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[91]))->cfun.entry(1, v2form) /*  C1FORM-ARGS */;
 T1 = ecl_car(T0);
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[89]))->cfun.entry(1, T1) /*  LOC-IN-C1FORM-MOVABLE-P */)){
  goto L2;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1var) /*  VAR-NAME */;
 (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(3, VV[92], T0, v2form) /*  CMPDEBUG */;
 (cl_env_copy->function=ecl_fdefinition(VV[93]))->cfun.entry(2, v1var, v2form) /*  NSUBST-VAR */;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3532c1let_constant_value_p_va(cl_narg narg, cl_object v3var, cl_object v4form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[68]);
 {
  return L3532c1let_constant_value_p(v3var, v4form);
 }
}
/* function definition for C1LET-CONSTANT-VARIABLE-P                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3533c1let_constant_variable_p(cl_object v1var, cl_object v2form, cl_object v3rest_vars, cl_object v4rest_forms)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[87]))->cfun.entry(1, v2form) /*  C1FORM-NAME */;
 if (!((T0)==(ECL_SYM("VARIABLE",901)))){
  goto L2;
 }
 {
  cl_object v5other_var;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[91]))->cfun.entry(1, v2form) /*  C1FORM-ARGS */;
  v5other_var = ecl_car(T0);
  if ((cl_env_copy->function=ecl_fdefinition(VV[40]))->cfun.entry(1, v5other_var) /*  GLOBAL-VAR-P */!=ECL_NIL) {
   goto L5;
  }
  {
   cl_object v6;
   cl_object v7;
   v6 = v5other_var;
   v7 = v3rest_vars;
   if (ecl_memql(v6,v7)!=ECL_NIL) {
    goto L5;
   }
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[95]))->cfun.entry(2, v5other_var, v4rest_forms) /*  VAR-CHANGED-IN-FORM-LIST */!=ECL_NIL) {
   goto L5;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1var) /*  VAR-NAME */;
  (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(3, VV[92], T0, v2form) /*  CMPDEBUG */;
  (cl_env_copy->function=ecl_fdefinition(VV[93]))->cfun.entry(2, v1var, v2form) /*  NSUBST-VAR */;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3533c1let_constant_variable_p_va(cl_narg narg, cl_object v6var, cl_object v7form, cl_object v8rest_vars, cl_object v9rest_forms, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[69]);
 {
  return L3533c1let_constant_variable_p(v6var, v7form, v8rest_vars, v9rest_forms);
 }
}
/* function definition for C1LET-CAN-MOVE-VARIABLE-VALUE-P                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3535c1let_can_move_variable_value_p(cl_object v1var, cl_object v2form, cl_object v3rest_vars, cl_object v4rest_forms)
{
 cl_object T0;
 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(v2form,env0);                 /*  FORM                    */
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[76]))->cfun.entry(1, v1var) /*  VAR-REF */;
 if (!(ecl_number_equalp(ecl_make_int8_t(1),T0))){
  goto L1;
 }
 if ((cl_env_copy->function=ecl_fdefinition(VV[81]))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  C1FORM-SIDE-EFFECTS */!=ECL_NIL) {
  goto L1;
 }
 {
  cl_object v5;
  v5 = ecl_make_cclosure_va((cl_objectfn)LC3534__lambda133,env0,Cblock,1);
  T0 = v5;
 }
 if (Null(cl_notany(2, T0, v3rest_vars))){
  goto L1;
 }
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(2, v1var, v4rest_forms) /*  REPLACEABLE */)){
  goto L1;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v1var) /*  VAR-NAME */;
 (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(3, VV[92], T0, ECL_CONS_CAR(CLV0)) /*  CMPDEBUG */;
 (cl_env_copy->function=ecl_fdefinition(VV[93]))->cfun.entry(2, v1var, ECL_CONS_CAR(CLV0)) /*  NSUBST-VAR */;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L1:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3535c1let_can_move_variable_value_p_va(cl_narg narg, cl_object v5var, cl_object v6form, cl_object v7rest_vars, cl_object v8rest_forms, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[97]);
 {
  return L3535c1let_can_move_variable_value_p(v5var, v6form, v7rest_vars, v8rest_forms);
 }
}
/* function definition for C1MAKE-VAR                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3536c1make_var(cl_object v1name, cl_object v2specials, cl_object v3ignores, cl_object v4types)
{
 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_SYMBOLP(v1name)) {
  goto L2;
 }
 (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[102], v1name) /*  CMPERR */;
L2:;
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[103]))->cfun.entry(1, v1name) /*  CONSTANT-VARIABLE-P */)){
  goto L4;
 }
 (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[104], v1name) /*  CMPERR */;
L4:;
 {
  cl_object v5;
  cl_object v6;
  cl_object v7kind;
  cl_object v8type;
  {
   cl_object v9;
   cl_object v10;
   v9 = v1name;
   v10 = v3ignores;
   T0 = ecl_assql(v9,v10);
  }
  v5 = ecl_cdr(T0);
  {
   cl_object v9;
   cl_object v10;
   v9 = v1name;
   v10 = v4types;
   v6 = ecl_assql(v9,v10);
  }
  v7kind = VV[105];
  v8type = v6;
  if (!(v8type==ECL_NIL)){
   goto L16;
  }
  v8type = ECL_T;
  goto L15;
L16:;
  v8type = ecl_cdr(v8type);
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[106]))->cfun.entry(1, v8type) /*  MACHINE-C-TYPE-P */)){
   goto L15;
  }
  v7kind = v8type;
  v8type = (cl_env_copy->function=ecl_fdefinition(VV[107]))->cfun.entry(1, v8type) /*  HOST-TYPE->LISP-TYPE */;
L15:;
  {
   cl_object v9;
   cl_object v10;
   v9 = v1name;
   v10 = v2specials;
   if (ecl_memql(v9,v10)!=ECL_NIL) {
    goto L26;
   }
  }
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[108]))->cfun.entry(1, v1name) /*  SPECIAL-VARIABLE-P */)){
   goto L24;
  }
  goto L25;
L26:;
L25:;
  if ((v7kind)==(VV[105])) {
   goto L30;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(3, VV[109], v1name, v8type) /*  CMPERR */;
L30:;
  if (!((v8type)==(ECL_T))){
   goto L32;
  }
  value0 = si_get_sysprop(v1name, VV[110]);
  if (value0!=ECL_NIL) {
   goto L36;
  }
  v8type = ECL_T;
  goto L34;
L36:;
  v8type = value0;
  goto L34;
L34:;
L32:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[111]))->cfun.entry(5, v1name, VV[112], ECL_SYM("SPECIAL",792), ECL_SYM("TYPE",1356), v8type) /*  MAKE-GLOBAL-VAR */;
  return value0;
L24:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[113]))->cfun.entry(12, ECL_SYM("NAME",1309), v1name, ECL_SYM("TYPE",1356), v8type, VV[114], VV[115], VV[112], v7kind, VV[116], v5, VV[117], ecl_make_int8_t(0)) /*  MAKE-VAR */;
  return value0;
 }
}
static cl_object L3536c1make_var_va(cl_narg narg, cl_object v9name, cl_object v10specials, cl_object v11ignores, cl_object v12types, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[34]);
 {
  return L3536c1make_var(v9name, v10specials, v11ignores, v12types);
 }
}
/* function definition for C1VARIABLE                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3537c1variable(cl_object v1name, cl_object v2loc)
{
 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 v3var;
  cl_object v4output;
  v3var = L3538c1vref(v1name);
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v3var) /*  VAR-TYPE */;
  v4output = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(6, ECL_SYM("VARIABLE",901), ECL_SYM("TYPE",1356), T0, VV[61], v3var, v2loc) /*  MAKE-C1FORM* */;
  (cl_env_copy->function=ecl_fdefinition(VV[121]))->cfun.entry(2, v3var, v4output) /*  ADD-TO-READ-NODES */;
  value0 = v4output;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3537c1variable_va(cl_narg narg, cl_object v5name, cl_object v6loc, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[119]);
 {
  return L3537c1variable(v5name, v6loc);
 }
}
/* function definition for C1VREF                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3538c1vref(cl_object v1name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;                                   /*  VAR                     */
  cl_object v3;                                   /*  CFB                     */
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[123]))->cfun.entry(1, v1name) /*  CMP-ENV-SEARCH-VAR */;
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  if (!(v2==ECL_NIL)){
   goto L3;
  }
  value0 = si_get_sysprop(v1name, VV[110]);
  if (value0!=ECL_NIL) {
   goto L7;
  }
  T0 = ECL_T;
  goto L5;
L7:;
  T0 = value0;
  goto L5;
L5:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[111]))->cfun.entry(5, v1name, VV[124], ECL_T, ECL_SYM("TYPE",1356), T0) /*  MAKE-GLOBAL-VAR */;
  return value0;
L3:;
  if ((cl_env_copy->function=ecl_fdefinition(VV[125]))->cfun.entry(1, v2) /*  VAR-P */!=ECL_NIL) {
   goto L9;
  }
  T0 = ecl_list1(v1name);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[126]))->cfun.entry(4, ECL_SYM("FORMAT-CONTROL",1272), VV[127], ECL_SYM("FORMAT-ARGUMENTS",1271), T0) /*  BABOON */;
  return value0;
L9:;
  {
   cl_object v4;
   v4 = (cl_env_copy->function=ecl_fdefinition(VV[77]))->cfun.entry(1, v2) /*  VAR-KIND */;
   if (!((v4)==(ECL_SYM("SPECIAL",792)))){
    goto L16;
   }
   goto L11;
L16:;
   goto L14;
L14:;
   if (!((v4)==(VV[79]))){
    goto L19;
   }
   goto L11;
L19:;
   goto L13;
L13:;
   if (!((v4)==(VV[129]))){
    goto L23;
   }
   goto L11;
L23:;
   goto L21;
L21:;
   if (!((v4)==(VV[105]))){
    goto L25;
   }
   if (Null(v3)){
    goto L11;
   }
   ecl_structure_set(v2,VV[45],(cl_fixnum)(3),ECL_T);
   goto L11;
L25:;
   if (Null(v3)){
    goto L11;
   }
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[50]))->cfun.entry(1, v2) /*  VAR-NAME */;
   (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[131], T0) /*  CMPERR */;
  }
L11:;
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3538c1vref_va(cl_narg narg, cl_object v2name, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[120]);
 {
  return L3538c1vref(v2name);
 }
}
/* function definition for C1SETQ                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3539c1setq(cl_object v1args)
{
 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 v2l;
  v2l = ecl_make_fixnum(ecl_length(v1args));
  if (!(ecl_oddp(v2l))){
   goto L3;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(1, VV[134]) /*  CMPERR */;
L3:;
  if (!((ecl_fixnum(v2l))==0)){
   goto L5;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[135]))->cfun.entry(0) /*  C1NIL */;
  return value0;
L5:;
  if (!((ecl_fixnum(v2l))==((cl_fixnum)(2)))){
   goto L7;
  }
  T0 = ecl_car(v1args);
  T1 = ecl_cadr(v1args);
  value0 = L3540c1setq1(T0, T1);
  return value0;
L7:;
  {
   cl_object v3;
   cl_object v4;
   v3 = ecl_list1(ECL_NIL);
   v4 = v3;
L12:;
   if (v1args!=ECL_NIL) {
    goto L14;
   }
   goto L13;
L14:;
   {
    cl_object v5;
    v5 = v4;
    if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T1 = v5;
   }
   {
    cl_object v5;
    v5 = v1args;
    {
     cl_object v6;
     v6 = v5;
     {
      bool v7;
      v7 = ECL_LISTP(v6);
      if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[4],v6);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v5)){
     goto L26;
    }
    {
     cl_object v6;
     v6 = ECL_CONS_CDR(v5);
     v1args = v6;
     v5 = ECL_CONS_CAR(v5);
    }
L26:;
    T2 = v5;
   }
   {
    cl_object v5;
    v5 = v1args;
    {
     cl_object v6;
     v6 = v5;
     {
      bool v7;
      v7 = ECL_LISTP(v6);
      if (ecl_unlikely(!(v7)))
         FEwrong_type_argument(VV[4],v6);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v5)){
     goto L37;
    }
    {
     cl_object v6;
     v6 = ECL_CONS_CDR(v5);
     v1args = v6;
     v5 = ECL_CONS_CAR(v5);
    }
L37:;
    T3 = v5;
   }
   T4 = cl_list(3, ECL_SYM("SETQ",754), T2, T3);
   v4 = ecl_list1(T4);
   (ECL_CONS_CDR(T1)=v4,T1);
   goto L12;
L13:;
   T0 = ecl_cdr(v3);
   goto L9;
  }
L9:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[137]))->cfun.entry(1, T0) /*  C1PROGN */;
  return value0;
 }
}
static cl_object L3539c1setq_va(cl_narg narg, cl_object v3args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[133]);
 {
  return L3539c1setq(v3args);
 }
}
/* function definition for C1SETQ1                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3540c1setq1(cl_object v1name, cl_object v2form)
{
 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 (ECL_SYMBOLP(v1name)) {
  goto L2;
 }
 (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[102], v1name) /*  CMPERR */;
L2:;
 if (Null(cl_constantp(1, v1name))){
  goto L4;
 }
 (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[139], v1name) /*  CMPERR */;
L4:;
 v1name = (cl_env_copy->function=ecl_fdefinition(VV[140]))->cfun.entry(1, v1name) /*  CHK-SYMBOL-MACROLET */;
 if (!(ECL_SYMBOLP(v1name))){
  goto L8;
 }
 {
  cl_object v3name;
  cl_object v4type;
  cl_object v5form;
  v3name = L3538c1vref(v1name);
  v4type = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v3name) /*  VAR-TYPE */;
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v4type) /*  TRIVIAL-TYPE-P */)){
   goto L14;
  }
  T0 = v2form;
  goto L13;
L14:;
  T0 = cl_list(3, ECL_SYM("CHECKED-VALUE",2082), v4type, v2form);
L13:;
  v5form = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T0) /*  C1EXPR */;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v5form) /*  C1FORM-TYPE */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(6, ECL_SYM("SETQ",754), ECL_SYM("TYPE",1356), T0, VV[61], v3name, v5form) /*  MAKE-C1FORM* */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[141]))->cfun.entry(2, v3name, T1) /*  ADD-TO-SET-NODES */;
  return value0;
 }
L8:;
 value0 = cl_list(3, ECL_SYM("SETF",753), v1name, v2form);
 return value0;
}
static cl_object L3540c1setq1_va(cl_narg narg, cl_object v6name, cl_object v7form, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[136]);
 {
  return L3540c1setq1(v6name, v7form);
 }
}
/* function definition for C1PROGV                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3541c1progv(cl_object v1args)
{
 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_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(3, ECL_SYM("PROGV",676), v1args, ecl_make_int8_t(2)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  T0 = ecl_car(v1args);
  v2 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T0) /*  C1EXPR */;
  T0 = ecl_cadr(v1args);
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T0) /*  C1EXPR */;
  T0 = ecl_cddr(v1args);
  v4 = (cl_env_copy->function=ecl_fdefinition(VV[137]))->cfun.entry(1, T0) /*  C1PROGN */;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v4) /*  C1FORM-TYPE */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(7, ECL_SYM("PROGV",676), ECL_SYM("TYPE",1356), T0, VV[61], v2, v3, v4) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3541c1progv_va(cl_narg narg, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[143]);
 {
  return L3541c1progv(v5args);
 }
}
/* function definition for C1PSETQ                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3542c1psetq(cl_object v1old_args)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2args;
  cl_object v3use_psetf;
  v2args = ECL_NIL;
  v3use_psetf = ECL_NIL;
  {
   cl_object v4l;
   v4l = v1old_args;
   goto L8;
L7:;
   {
    cl_object v5var;
    {
     cl_object v6;
     v6 = v4l;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[4],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L16;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v4l = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L16:;
     v5var = v6;
    }
    if (ECL_SYMBOLP(v5var)) {
     goto L22;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[102], v5var) /*  CMPERR */;
L22:;
    if (!(ecl_endp(v4l))){
     goto L24;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[146], v5var) /*  CMPERR */;
L24:;
    v5var = (cl_env_copy->function=ecl_fdefinition(VV[140]))->cfun.entry(1, v5var) /*  CHK-SYMBOL-MACROLET */;
    {
     cl_object v6;
     v6 = v4l;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[4],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L35;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v4l = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L35:;
     T0 = v6;
    }
    T1 = cl_list(2, v5var, T0);
    v2args = ecl_nconc(v2args,T1);
    if (!(ECL_SYMBOLP(v5var))){
     goto L41;
    }
    if (Null(cl_constantp(1, v5var))){
     goto L10;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[139], v5var) /*  CMPERR */;
    goto L10;
L41:;
    v3use_psetf = ECL_T;
   }
L10:;
L8:;
   if (ecl_endp(v4l)) {
    goto L45;
   }
   goto L7;
L45:;
  }
  if (Null(v3use_psetf)){
   goto L47;
  }
  value0 = CONS(ECL_SYM("PSETF",678),v2args);
  cl_env_copy->nvalues = 1;
  return value0;
L47:;
  {
   cl_object v4vrefs;
   cl_object v5forms;
   v4vrefs = ECL_NIL;
   v5forms = ECL_NIL;
   goto L53;
L52:;
   {
    cl_object v6vref;
    cl_object v7type;
    cl_object v8form;
    {
     cl_object v9;
     v9 = v2args;
     {
      cl_object v10;
      v10 = v9;
      {
       bool v11;
       v11 = ECL_LISTP(v10);
       if (ecl_unlikely(!(v11)))
         FEwrong_type_argument(VV[4],v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v9)){
      goto L62;
     }
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v9);
      v2args = v10;
      v9 = ECL_CONS_CAR(v9);
     }
L62:;
     T0 = v9;
    }
    v6vref = L3538c1vref(T0);
    v7type = (cl_env_copy->function=ecl_fdefinition(VV[35]))->cfun.entry(1, v6vref) /*  VAR-TYPE */;
    {
     cl_object v9;
     v9 = v2args;
     {
      cl_object v10;
      v10 = v9;
      {
       bool v11;
       v11 = ECL_LISTP(v10);
       if (ecl_unlikely(!(v11)))
         FEwrong_type_argument(VV[4],v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v9)){
      goto L74;
     }
     {
      cl_object v10;
      v10 = ECL_CONS_CDR(v9);
      v2args = v10;
      v9 = ECL_CONS_CAR(v9);
     }
L74:;
     v8form = v9;
    }
    v4vrefs = CONS(v6vref,v4vrefs);
    if (Null((cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v7type) /*  TRIVIAL-TYPE-P */)){
     goto L84;
    }
    T0 = v8form;
    goto L83;
L84:;
    T0 = cl_list(3, ECL_SYM("CHECKED-VALUE",2082), v7type, v8form);
L83:;
    T1 = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, T0) /*  C1EXPR */;
    v5forms = CONS(T1,v5forms);
   }
L53:;
   if (ecl_endp(v2args)) {
    goto L86;
   }
   goto L52;
L86:;
   T0 = cl_reverse(v4vrefs);
   T1 = cl_nreverse(v5forms);
   T2 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(6, ECL_SYM("PSETQ",679), ECL_SYM("TYPE",1356), VV[148], VV[61], T0, T1) /*  MAKE-C1FORM* */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[147]))->cfun.entry(2, v4vrefs, T2) /*  ADD-TO-SET-NODES-OF-VAR-LIST */;
   return value0;
  }
 }
}
static cl_object L3542c1psetq_va(cl_narg narg, cl_object v6old_args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[145]);
 {
  return L3542c1psetq(v6old_args);
 }
}
/* function definition for C1MULTIPLE-VALUE-BIND                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3543c1multiple_value_bind(cl_object v1args)
{
 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_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(3, ECL_SYM("MULTIPLE-VALUE-BIND",574), v1args, ecl_make_int8_t(2)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2variables;
  cl_object v3init_form;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(0) /*  CMP-ENV-COPY */;
  ecl_bds_bind(cl_env_copy,VV[26],T0);            /*  *CMP-ENV*               */
  {
   cl_object v4;
   v4 = v1args;
   {
    cl_object v5;
    v5 = v4;
    {
     bool v6;
     v6 = ECL_LISTP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(VV[4],v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v4)){
    goto L8;
   }
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v4);
    v1args = v5;
    v4 = ECL_CONS_CAR(v4);
   }
L8:;
   v2variables = v4;
  }
  {
   cl_object v4;
   v4 = v1args;
   {
    cl_object v5;
    v5 = v4;
    {
     bool v6;
     v6 = ECL_LISTP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(VV[4],v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
   }
   if (Null(v4)){
    goto L19;
   }
   {
    cl_object v5;
    v5 = ECL_CONS_CDR(v4);
    v1args = v5;
    v4 = ECL_CONS_CAR(v4);
   }
L19:;
   v3init_form = v4;
  }
  {
   cl_fixnum v4;
   v4 = ecl_length(v2variables);
   if (!((v4)==((cl_fixnum)(1)))){
    goto L25;
   }
  }
  T0 = ecl_car(v2variables);
  T1 = cl_list(2, T0, v3init_form);
  T2 = ecl_list1(T1);
  value0 = cl_listX(3, ECL_SYM("LET*",480), T2, v1args);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L25:;
  {
   cl_object v4;                                  /*  BODY                    */
   cl_object v5;                                  /*  SS                      */
   cl_object v6;                                  /*  TS                      */
   cl_object v7;                                  /*  IS                      */
   cl_object v8;                                  /*  OTHER-DECLS             */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(2, v1args, ECL_NIL) /*  C1BODY */;
   {
    const int v9 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v5 = v10;
    v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
    v6 = v10;
    v10 = (v9<=3)? ECL_NIL : cl_env_copy->values[3];
    v7 = v10;
    v10 = (v9<=4)? ECL_NIL : cl_env_copy->values[4];
    v8 = v10;
   }
   {
    cl_object v9;
    v9 = ecl_fdefinition(VV[53]);
    {
     cl_object v10;
     cl_object v11;
     cl_object v12;
     {
      cl_object v13;
      v13 = v5;
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
     v11 = ECL_NIL;
     v12 = v10;
L35:;
     if (!(ecl_endp(v12))){
      goto L37;
     }
     goto L36;
L37:;
     v11 = ECL_CONS_CAR(v12);
     {
      cl_object v13;
      v13 = ECL_CONS_CDR(v12);
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v12 = v13;
     }
     ecl_function_dispatch(cl_env_copy,v9)(1, v11);
     goto L35;
L36:;
     goto L28;
    }
   }
L28:;
   {
    cl_object v9vars;
    {
     cl_object v10;
     cl_object v11name;
     cl_object v12;
     {
      cl_object v13;
      v13 = v2variables;
      if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v10 = v13;
     }
     v11name = ECL_NIL;
     v12 = v10;
     {
      cl_object v13;
      cl_object v14;
      v13 = ecl_list1(ECL_NIL);
      v14 = v13;
L56:;
      if (!(ecl_endp(v12))){
       goto L58;
      }
      goto L57;
L58:;
      v11name = ECL_CONS_CAR(v12);
      {
       cl_object v15;
       v15 = ECL_CONS_CDR(v12);
       if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v12 = v15;
      }
      {
       cl_object v15;
       v15 = v14;
       if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v15;
      }
      T1 = L3536c1make_var(v11name, v5, v7, v6);
      v14 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v14,T0);
      goto L56;
L57:;
      v9vars = ecl_cdr(v13);
      goto L48;
     }
    }
L48:;
    v3init_form = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, v3init_form) /*  C1EXPR */;
    {
     cl_object v10;
     v10 = ecl_fdefinition(VV[48]);
     {
      cl_object v11;
      cl_object v12;
      cl_object v13;
      {
       cl_object v14;
       v14 = v9vars;
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      v12 = ECL_NIL;
      v13 = v11;
L82:;
      if (!(ecl_endp(v13))){
       goto L84;
      }
      goto L83;
L84:;
      v12 = 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;
      }
      ecl_function_dispatch(cl_env_copy,v10)(1, v12);
      goto L82;
L83:;
      goto L75;
     }
    }
L75:;
    (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(3, v2variables, v6, v7) /*  CHECK-VDECL */;
    v4 = (cl_env_copy->function=ecl_fdefinition(VV[54]))->cfun.entry(2, v8, v4) /*  C1DECL-BODY */;
    {
     cl_object v10;
     v10 = ecl_fdefinition(VV[56]);
     {
      cl_object v11;
      cl_object v12;
      cl_object v13;
      {
       cl_object v14;
       v14 = v9vars;
       if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v14;
      }
      v12 = ECL_NIL;
      v13 = v11;
L105:;
      if (!(ecl_endp(v13))){
       goto L107;
      }
      goto L106;
L107:;
      v12 = 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;
      }
      ecl_function_dispatch(cl_env_copy,v10)(1, v12);
      goto L105;
L106:;
      goto L98;
     }
    }
L98:;
    T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v4) /*  C1FORM-TYPE */;
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(9, ECL_SYM("MULTIPLE-VALUE-BIND",574), ECL_SYM("TYPE",1356), T0, VV[60], v9vars, VV[61], v9vars, v3init_form, v4) /*  MAKE-C1FORM* */;
    ecl_bds_unwind1(cl_env_copy);
    return value0;
   }
  }
 }
}
static cl_object L3543c1multiple_value_bind_va(cl_narg narg, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[150]);
 {
  return L3543c1multiple_value_bind(v4args);
 }
}
/* function definition for C1MULTIPLE-VALUE-SETQ                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3544c1multiple_value_setq(cl_object v1args)
{
 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 v2vars;
  cl_object v3value_bindings;
  cl_object v4storing_forms;
  cl_object v5return_value;
  v2vars = ECL_NIL;
  v3value_bindings = ECL_NIL;
  v4storing_forms = ECL_NIL;
  v5return_value = ECL_NIL;
  (cl_env_copy->function=ecl_fdefinition(VV[1]))->cfun.entry(4, ECL_SYM("MULTIPLE-VALUE-SETQ",578), v1args, ecl_make_int8_t(2), ecl_make_int8_t(2)) /*  CHECK-ARGS-NUMBER */;
  {
   cl_object v6;
   T0 = ecl_car(v1args);
   v6 = cl_reverse(T0);
   goto L11;
L10:;
   {
    cl_object v7var;
    v7var = ecl_car(v6);
    if (ECL_SYMBOLP(v7var)) {
     goto L15;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[102], v7var) /*  CMPERR */;
L15:;
    {
     cl_object v8var_or_form;
     cl_object v9type;
     v8var_or_form = (cl_env_copy->function=ecl_fdefinition(VV[140]))->cfun.entry(1, v7var) /*  CHK-SYMBOL-MACROLET */;
     v9type = ECL_T;
     if (!(ECL_SYMBOLP(v8var_or_form))){
      goto L20;
     }
     if (Null(cl_constantp(1, v8var_or_form))){
      goto L22;
     }
     (cl_env_copy->function=ecl_fdefinition(VV[19]))->cfun.entry(2, VV[139], v8var_or_form) /*  CMPERR */;
L22:;
     v5return_value = v8var_or_form;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[153]))->cfun.entry(0) /*  POLICY-TYPE-ASSERTIONS */)){
      goto L28;
     }
     v9type = (cl_env_copy->function=ecl_fdefinition(VV[154]))->cfun.entry(1, v8var_or_form) /*  VARIABLE-TYPE-IN-ENV */;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[37]))->cfun.entry(1, v9type) /*  TRIVIAL-TYPE-P */)){
      goto L26;
     }
     goto L27;
L28:;
L27:;
     v2vars = CONS(v8var_or_form,v2vars);
     goto L17;
L26:;
     {
      cl_object v10new_var;
      v10new_var = cl_gensym(0);
      v2vars = CONS(v10new_var,v2vars);
      v3value_bindings = CONS(v10new_var,v3value_bindings);
      T0 = cl_list(3, ECL_SYM("CHECKED-VALUE",2082), v9type, v10new_var);
      T1 = cl_list(3, ECL_SYM("SETF",753), v8var_or_form, T0);
      v4storing_forms = CONS(T1,v4storing_forms);
      goto L17;
     }
L20:;
     {
      cl_object v11;                              /*  SETF-VARS               */
      cl_object v12;                              /*  SETF-VALS               */
      cl_object v13;                              /*  STORES                  */
      cl_object v14;                              /*  STORING-FORM            */
      cl_object v15;                              /*  GET-FORM                */
      value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v8var_or_form, ecl_cmp_symbol_value(cl_env_copy,VV[26])) /*  GET-SETF-EXPANSION */;
      {
       v11 = value0;
       v12 = cl_env_copy->values[1];
       v13 = cl_env_copy->values[2];
       v14 = cl_env_copy->values[3];
       v15 = cl_env_copy->values[4];
      }
      T0 = ecl_car(v13);
      v2vars = CONS(T0,v2vars);
      {
       cl_object v16;
       v16 = (ECL_SYM("LIST",483)->symbol.gfdef);
       {
        cl_object v17;
        cl_object v18;
        cl_object v19;
        {
         cl_object v20;
         v20 = v11;
         if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v17 = v20;
        }
        v18 = ECL_NIL;
        v19 = v17;
        {
         cl_object v20;
         cl_object v21;
         cl_object v22;
         {
          cl_object v23;
          v23 = v12;
          if (ecl_unlikely(!ECL_LISTP(v23))) FEtype_error_list(v23);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v20 = v23;
         }
         v21 = ECL_NIL;
         v22 = v20;
         {
          cl_object v23;
          cl_object v24;
          v23 = ecl_list1(ECL_NIL);
          v24 = v23;
L57:;
          if (!(ecl_endp(v19))){
          goto L59;
          }
          goto L58;
L59:;
          v18 = ECL_CONS_CAR(v19);
          {
          cl_object v25;
          v25 = ECL_CONS_CDR(v19);
          if (ecl_unlikely(!ECL_LISTP(v25))) FEtype_error_list(v25);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v19 = v25;
          }
          if (!(ecl_endp(v22))){
          goto L67;
          }
          goto L58;
L67:;
          v21 = ECL_CONS_CAR(v22);
          {
          cl_object v25;
          v25 = ECL_CONS_CDR(v22);
          if (ecl_unlikely(!ECL_LISTP(v25))) FEtype_error_list(v25);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v22 = v25;
          }
          {
          cl_object v25;
          v25 = v24;
          if (ecl_unlikely(ECL_ATOM(v25))) FEtype_error_cons(v25);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          T1 = v25;
          }
          T2 = ecl_function_dispatch(cl_env_copy,v16)(2, v18, v21);
          v24 = ecl_list1(T2);
          (ECL_CONS_CDR(T1)=v24,T1);
          goto L57;
L58:;
          T0 = ecl_cdr(v23);
          goto L43;
         }
        }
       }
      }
L43:;
      v3value_bindings = cl_nconc(3, T0, v13, v3value_bindings);
      v4storing_forms = CONS(v14,v4storing_forms);
      v5return_value = v15;
     }
    }
L17:;
   }
   v6 = ecl_cdr(v6);
L11:;
   if (Null(v6)){
    goto L88;
   }
   goto L10;
L88:;
  }
  {
   cl_object v6value;
   v6value = ecl_cadr(v1args);
   if (Null(v3value_bindings)){
    goto L91;
   }
   T0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-SETQ",578), v2vars, v6value);
   T1 = ecl_list1(v5return_value);
   T2 = ecl_append(v4storing_forms,T1);
   value0 = cl_listX(4, ECL_SYM("LET*",480), v3value_bindings, T0, T2);
   return value0;
L91:;
   if (!(ecl_endp(v2vars))){
    goto L93;
   }
   value0 = cl_list(2, ECL_SYM("VALUES",899), v6value);
   return value0;
L93:;
   {
    cl_fixnum v7;
    v7 = ecl_length(v2vars);
    if (!((v7)==((cl_fixnum)(1)))){
     goto L95;
    }
   }
   T0 = ecl_car(v2vars);
   value0 = cl_list(3, ECL_SYM("SETQ",754), T0, v6value);
   return value0;
L95:;
   v6value = (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, v6value) /*  C1EXPR */;
   {
    cl_object v7;
    v7 = ecl_fdefinition(VV[120]);
    {
     cl_object v8;
     cl_object v9;
     cl_object v10;
     {
      cl_object v11;
      v11 = v2vars;
      if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v8 = v11;
     }
     v9 = ECL_NIL;
     v10 = v8;
     {
      cl_object v11;
      cl_object v12;
      v11 = ecl_list1(ECL_NIL);
      v12 = v11;
L109:;
      if (!(ecl_endp(v10))){
       goto L111;
      }
      goto L110;
L111:;
      v9 = ECL_CONS_CAR(v10);
      {
       cl_object v13;
       v13 = ECL_CONS_CDR(v10);
       if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v13;
      }
      {
       cl_object v13;
       v13 = v12;
       if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v13;
      }
      T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v9);
      v12 = ecl_list1(T1);
      (ECL_CONS_CDR(T0)=v12,T0);
      goto L109;
L110:;
      v2vars = ecl_cdr(v11);
      goto L100;
     }
    }
   }
L100:;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(4, ECL_SYM("MULTIPLE-VALUE-SETQ",578), VV[61], v2vars, v6value) /*  MAKE-C1FORM* */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[147]))->cfun.entry(2, v2vars, T0) /*  ADD-TO-SET-NODES-OF-VAR-LIST */;
   return value0;
  }
 }
}
static cl_object L3544c1multiple_value_setq_va(cl_narg narg, cl_object v7args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[152]);
 {
  return L3544c1multiple_value_setq(v7args);
 }
}
/* closure LAMBDA133                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3534__lambda133(cl_narg narg, cl_object v1v, ...)
{
 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;                                     /*  FORM                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[98]);
 {
L1:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[99]))->cfun.entry(2, v1v, ECL_CONS_CAR(CLV0)) /*  VAR-REFERENCED-IN-FORM */;
  return value0;
 }
 }
}
#include "cmp/cmppass1-var.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclk5nfTY7I0RTm9_mRU0M881(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;CMPPASS1-VAR.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclk5nfTY7I0RTm9_mRU0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(_ecl_static_0);
  ecl_cmp_defun(VV[156]);                         /*  C1LET                   */
  ecl_cmp_defun(VV[157]);                         /*  C1LET*                  */
  ecl_cmp_defun(VV[158]);                         /*  C1LET/LET*              */
  ecl_cmp_defun(VV[159]);                         /*  INVALID-LET-BINDINGS    */
  ecl_cmp_defun(VV[160]);                         /*  PROCESS-LET-BINDINGS    */
  ecl_cmp_defun(VV[161]);                         /*  PROCESS-LET-BODY        */
  ecl_cmp_defun(VV[162]);                         /*  C1LET-OPTIMIZE-READ-ONLY-VARS */
  ecl_cmp_defun(VV[163]);                         /*  FIX-READ-ONLY-VARIABLE-TYPE */
  ecl_cmp_defun(VV[164]);                         /*  C1LET-UNUSED-VARIABLE-P */
  ecl_cmp_defun(VV[165]);                         /*  C1LET-CONSTANT-VALUE-P  */
  ecl_cmp_defun(VV[166]);                         /*  C1LET-CONSTANT-VARIABLE-P */
  ecl_cmp_defun(VV[167]);                         /*  C1LET-CAN-MOVE-VARIABLE-VALUE-P */
  ecl_cmp_defun(VV[168]);                         /*  C1MAKE-VAR              */
  ecl_cmp_defun(VV[169]);                         /*  C1VARIABLE              */
  ecl_cmp_defun(VV[170]);                         /*  C1VREF                  */
  ecl_cmp_defun(VV[171]);                         /*  C1SETQ                  */
  ecl_cmp_defun(VV[172]);                         /*  C1SETQ1                 */
  ecl_cmp_defun(VV[173]);                         /*  C1PROGV                 */
  ecl_cmp_defun(VV[174]);                         /*  C1PSETQ                 */
  ecl_cmp_defun(VV[175]);                         /*  C1MULTIPLE-VALUE-BIND   */
  ecl_cmp_defun(VV[176]);                         /*  C1MULTIPLE-VALUE-SETQ   */
}
