/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmppass1-eval.lsp               */
#include <ecl/ecl-cmp.h>
#include "cmp/cmppass1-eval.eclh"
/* function definition for C1EXPR-INNER                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3477c1expr_inner(cl_object v1form)
{
 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(v1form))){
  goto L2;
 }
 v1form = L3488chk_symbol_macrolet(v1form);
 if (ECL_SYMBOLP(v1form)) {
  goto L6;
 }
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (!((v1form)==(ECL_NIL))){
  goto L8;
 }
 value0 = L3479c1nil();
 return value0;
L8:;
 if (!((v1form)==(ECL_T))){
  goto L10;
 }
 value0 = L3480c1t();
 return value0;
L10:;
 if (Null(cl_keywordp(v1form))){
  goto L12;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[6]))->cfun.entry(1, v1form) /*  OBJECT-TYPE */;
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, v1form) /*  ADD-SYMBOL */;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, VV[5], ECL_SYM("TYPE",1356), T0, VV[7], T1) /*  MAKE-C1FORM* */;
 return value0;
L12:;
 if (Null(cl_constantp(2, v1form, ecl_cmp_symbol_value(cl_env_copy,VV[9])))){
  goto L14;
 }
 T0 = cl_symbol_value(v1form);
 T1 = L3490c1constant_symbol_value(v1form, T0);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(2, v1form, T1) /*  C1VARIABLE */;
 return value0;
L14:;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(2, v1form, ECL_NIL) /*  C1VARIABLE */;
 return value0;
L2:;
 if (!(ECL_CONSP(v1form))){
  goto L16;
 }
 if (si_proper_list_p(v1form)!=ECL_NIL) {
  goto L18;
 }
 (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(2, VV[14], v1form) /*  CMPERR */;
L18:;
 {
  cl_object v2fun;
  v2fun = ecl_car(v1form);
  {
   cl_object v3fd;
   v3fd = ecl_gethash_safe(v2fun,ecl_cmp_symbol_value(cl_env_copy,VV[15]),ECL_NIL);
   if (Null(v3fd)){
    goto L21;
   }
   v2fun = v3fd;
   if (Null(v2fun)){
    goto L21;
   }
  }
  T0 = ecl_cdr(v1form);
  value0 = ecl_function_dispatch(cl_env_copy,v2fun)(1, T0);
  return value0;
L21:;
  if (!(ECL_SYMBOLP(v2fun))){
   goto L26;
  }
  T0 = ecl_cdr(v1form);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[16]))->cfun.entry(3, v2fun, T0, ECL_T) /*  C1CALL */;
  return value0;
L26:;
  if (!(ECL_CONSP(v2fun))){
   goto L28;
  }
  T0 = ecl_car(v2fun);
  if (!((T0)==(ECL_SYM("LAMBDA",454)))){
   goto L28;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[17]))->cfun.entry(1, v1form) /*  C1FUNCALL */;
  return value0;
L28:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(2, VV[18], v2fun) /*  CMPERR */;
  return value0;
 }
L16:;
 value0 = L3489c1constant_value(v1form);
 return value0;
}
/* function definition for C1EXPR                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3478c1expr(cl_object v1form)
{
 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:;
 ecl_bds_bind(cl_env_copy,VV[21],v1form);         /*  *CURRENT-FORM*          */
L2:;
 v1form = L3477c1expr_inner(v1form);
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(1, v1form) /*  C1FORM-P */)){
  goto L3;
 }
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
L3:;
 goto L2;
}
static cl_object L3478c1expr_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[20]);
 {
  return L3478c1expr(v2form);
 }
}
/* function definition for C1NIL                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3479c1nil()
{
 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:;
 ecl_bds_bind(cl_env_copy,VV[21],ECL_NIL);        /*  *CURRENT-FORM*          */
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, VV[5], ECL_SYM("TYPE",1356), ECL_SYM("NULL",607), VV[7], ecl_cmp_symbol_value(cl_env_copy,VV[24])) /*  MAKE-C1FORM* */;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3479c1nil_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[2]);
 {
  return L3479c1nil();
 }
}
/* function definition for C1T                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3480c1t()
{
 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:;
 ecl_bds_bind(cl_env_copy,VV[21],ECL_T);          /*  *CURRENT-FORM*          */
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, VV[5], ECL_SYM("TYPE",1356), VV[28], VV[7], ecl_cmp_symbol_value(cl_env_copy,VV[26])) /*  MAKE-C1FORM* */;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3480c1t_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[3]);
 {
  return L3480c1t();
 }
}
/* function definition for C1WITH-BACKEND                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3481c1with_backend(cl_object v1forms)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2tag;
  v2tag = ECL_NIL;
  {
   cl_object v3form;
   v3form = ECL_NIL;
   {
    cl_object v4;
    cl_object v5;
    v4 = ecl_list1(ECL_NIL);
    v5 = v4;
L7:;
    {
     cl_object v6;
     v6 = v1forms;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[37],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L15;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v1forms = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L15:;
     v2tag = v6;
    }
    {
     cl_object v6;
     v6 = v1forms;
     {
      cl_object v7;
      v7 = v6;
      {
       bool v8;
       v8 = ECL_LISTP(v7);
       if (ecl_unlikely(!(v8)))
         FEwrong_type_argument(VV[37],v7);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v6)){
      goto L27;
     }
     {
      cl_object v7;
      v7 = ECL_CONS_CDR(v6);
      v1forms = v7;
      v6 = ECL_CONS_CAR(v6);
     }
L27:;
     v3form = v6;
    }
    if (v2tag!=ECL_NIL) {
     goto L33;
    }
    goto L8;
L33:;
    if (!((v2tag)==(ECL_SYM("C/C++",1876)))){
     goto L35;
    }
    {
     cl_object v6;
     v6 = v5;
     if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v6;
    }
    v5 = ecl_list1(v3form);
    (ECL_CONS_CDR(T1)=v5,T1);
L35:;
    goto L7;
L8:;
    T0 = ecl_cdr(v4);
    goto L2;
   }
  }
 }
L2:;
 value0 = L3482c1progn(T0);
 return value0;
}
static cl_object L3481c1with_backend_va(cl_narg narg, cl_object v2forms, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[30]);
 {
  return L3481c1with_backend(v2forms);
 }
}
/* function definition for C1PROGN                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3482c1progn(cl_object v1forms)
{
 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_endp(v1forms))){
  goto L2;
 }
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[41]))->cfun.entry(1, ECL_NIL) /*  T1/C1EXPR */;
 return value0;
L2:;
 T0 = ecl_cdr(v1forms);
 if (!(ecl_endp(T0))){
  goto L4;
 }
 T0 = ecl_car(v1forms);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[41]))->cfun.entry(1, T0) /*  T1/C1EXPR */;
 return value0;
L4:;
 {
  cl_object v2fl;
  cl_object v3output_form;
  cl_object v4output_type;
  {
   cl_object v5;
   v5 = ecl_fdefinition(VV[41]);
   {
    cl_object v6;
    cl_object v7;
    cl_object v8;
    {
     cl_object v9;
     v9 = v1forms;
     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;
L15:;
     if (!(ecl_endp(v8))){
      goto L17;
     }
     goto L16;
L17:;
     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;
      T0 = v11;
     }
     T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v7);
     v10 = ecl_list1(T1);
     (ECL_CONS_CDR(T0)=v10,T0);
     goto L15;
L16:;
     v2fl = ecl_cdr(v9);
     goto L6;
    }
   }
  }
L6:;
  T0 = ecl_last(v2fl,1);
  v3output_form = ecl_car(T0);
  if (Null(v3output_form)){
   goto L36;
  }
  v4output_type = (cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v3output_form) /*  C1FORM-TYPE */;
  goto L34;
L36:;
  v4output_type = ECL_NIL;
  goto L34;
L34:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, ECL_SYM("PROGN",674), ECL_SYM("TYPE",1356), v4output_type, VV[7], v2fl) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3482c1progn_va(cl_narg narg, cl_object v5forms, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[31]);
 {
  return L3482c1progn(v5forms);
 }
}
/* function definition for C1ARGS*                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3483c1args_(cl_object v1forms)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  v2 = ecl_fdefinition(VV[20]);
  {
   cl_object v3;
   cl_object v4;
   cl_object v5;
   {
    cl_object v6;
    v6 = v1forms;
    if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v3 = v6;
   }
   v4 = ECL_NIL;
   v5 = v3;
   {
    cl_object v6;
    cl_object v7;
    v6 = ecl_list1(ECL_NIL);
    v7 = v6;
L10:;
    if (!(ecl_endp(v5))){
     goto L12;
    }
    goto L11;
L12:;
    v4 = ECL_CONS_CAR(v5);
    {
     cl_object v8;
     v8 = ECL_CONS_CDR(v5);
     if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v5 = v8;
    }
    {
     cl_object v8;
     v8 = v7;
     if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v8;
    }
    T1 = ecl_function_dispatch(cl_env_copy,v2)(1, v4);
    v7 = ecl_list1(T1);
    (ECL_CONS_CDR(T0)=v7,T0);
    goto L10;
L11:;
    value0 = ecl_cdr(v6);
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L3483c1args__va(cl_narg narg, cl_object v8forms, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[44]);
 {
  return L3483c1args_(v8forms);
 }
}
/* function definition for C1DECL-BODY                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3484c1decl_body(cl_object v1decls, cl_object v2body)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(v1decls==ECL_NIL)){
  goto L2;
 }
 value0 = L3482c1progn(v2body);
 return value0;
L2:;
 T0 = ecl_fdefinition(VV[47]);
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[9])) /*  CMP-ENV-COPY */;
 T2 = cl_reduce(4, T0, v1decls, VV[48], T1);
 ecl_bds_bind(cl_env_copy,VV[9],T2);              /*  *CMP-ENV*               */
 value0 = L3482c1progn(v2body);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3484c1decl_body_va(cl_narg narg, cl_object v3decls, cl_object v4body, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[46]);
 {
  return L3484c1decl_body(v3decls, v4body);
 }
}
/* function definition for C1LOCALLY                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3485c1locally(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_object v2;                                   /*  BODY                    */
  cl_object v3;                                   /*  SS                      */
  cl_object v4;                                   /*  TS                      */
  cl_object v5;                                   /*  IS                      */
  cl_object v6;                                   /*  OTHER-DECL              */
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[52]))->cfun.entry(2, v1args, ECL_T) /*  C1BODY */;
  {
   const int v7 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v8;
   v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
   v4 = v8;
   v8 = (v7<=3)? ECL_NIL : cl_env_copy->values[3];
   v5 = v8;
   v8 = (v7<=4)? ECL_NIL : cl_env_copy->values[4];
   v6 = v8;
  }
  if (v3!=ECL_NIL) {
   goto L5;
  }
  if (v4!=ECL_NIL) {
   goto L5;
  }
  if (v5!=ECL_NIL) {
   goto L5;
  }
  if (Null(v6)){
   goto L3;
  }
  goto L4;
L5:;
L4:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(0) /*  CMP-ENV-COPY */;
  ecl_bds_bind(cl_env_copy,VV[9],T0);             /*  *CMP-ENV*               */
  {
   cl_object v7;
   v7 = ecl_fdefinition(VV[53]);
   {
    cl_object v8;
    cl_object v9;
    cl_object v10;
    {
     cl_object v11;
     v11 = v3;
     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;
L16:;
    if (!(ecl_endp(v10))){
     goto L18;
    }
    goto L17;
L18:;
    v9 = ECL_CONS_CAR(v10);
    {
     cl_object v11;
     v11 = ECL_CONS_CDR(v10);
     if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v10 = v11;
    }
    ecl_function_dispatch(cl_env_copy,v7)(1, v9);
    goto L16;
L17:;
    goto L9;
   }
  }
L9:;
  (cl_env_copy->function=ecl_fdefinition(VV[54]))->cfun.entry(3, ECL_NIL, v4, v5) /*  CHECK-VDECL */;
  value0 = L3484c1decl_body(v6, v2);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L3:;
  value0 = L3482c1progn(v2);
  return value0;
 }
}
static cl_object L3485c1locally_va(cl_narg narg, cl_object v2args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[51]);
 {
  return L3485c1locally(v2args);
 }
}
/* function definition for C1MACROLET                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3486c1macrolet(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[57]))->cfun.entry(3, ECL_SYM("MACROLET",523), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 T0 = ecl_car(v1args);
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(0) /*  CMP-ENV-COPY */;
 T2 = (cl_env_copy->function=(ECL_SYM("CMP-ENV-REGISTER-MACROLET",1679)->symbol.gfdef))->cfun.entry(2, T0, T1) /*  CMP-ENV-REGISTER-MACROLET */;
 ecl_bds_bind(cl_env_copy,VV[9],T2);              /*  *CMP-ENV*               */
 T0 = ecl_cdr(v1args);
 value0 = L3485c1locally(T0);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3486c1macrolet_va(cl_narg narg, cl_object v2args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[56]);
 {
  return L3486c1macrolet(v2args);
 }
}
/* function definition for C1SYMBOL-MACROLET                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3487c1symbol_macrolet(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[57]))->cfun.entry(3, ECL_SYM("SYMBOL-MACROLET",845), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(0) /*  CMP-ENV-COPY */;
 ecl_bds_bind(cl_env_copy,VV[9],T0);              /*  *CMP-ENV*               */
 {
  cl_object v2;
  v2 = ecl_car(v1args);
  goto L7;
L6:;
  {
   cl_object v3def;
   v3def = ecl_car(v2);
   {
    cl_object v4name;
    v4name = ecl_car(v3def);
    if (ecl_endp(v3def)) {
     goto L15;
    }
    if (!(ECL_SYMBOLP(v4name))){
     goto L15;
    }
    T0 = ecl_cdr(v3def);
    if (!(ecl_endp(T0))){
     goto L13;
    }
    goto L14;
L15:;
L14:;
    (cl_env_copy->function=ecl_fdefinition(VV[13]))->cfun.entry(2, VV[60], v3def) /*  CMPERR */;
L13:;
    T0 = ecl_cadr(v3def);
    (cl_env_copy->function=ecl_fdefinition(VV[61]))->cfun.entry(2, v4name, T0) /*  CMP-ENV-REGISTER-SYMBOL-MACRO */;
   }
  }
  v2 = ecl_cdr(v2);
L7:;
  if (Null(v2)){
   goto L20;
  }
  goto L6;
L20:;
 }
 T0 = ecl_cdr(v1args);
 value0 = L3485c1locally(T0);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L3487c1symbol_macrolet_va(cl_narg narg, cl_object v2args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[59]);
 {
  return L3487c1symbol_macrolet(v2args);
 }
}
/* function definition for CHK-SYMBOL-MACROLET                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3488chk_symbol_macrolet(cl_object v1form)
{
 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:;
L2:;
 if (ECL_SYMBOLP(v1form)) {
  goto L4;
 }
 value0 = v1form;
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 {
  cl_object v2new_form;
  v2new_form = cl_macroexpand_1(2, v1form, ecl_cmp_symbol_value(cl_env_copy,VV[9]));
  if (!((v2new_form)==(v1form))){
   goto L7;
  }
  value0 = v1form;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  v1form = v2new_form;
 }
 goto L2;
}
static cl_object L3488chk_symbol_macrolet_va(cl_narg narg, cl_object v2form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[1]);
 {
  return L3488chk_symbol_macrolet(v2form);
 }
}
/* function definition for C1CONSTANT-VALUE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3489c1constant_value(cl_object v1val)
{
 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 (!((v1val)==(ECL_NIL))){
  goto L2;
 }
 value0 = L3479c1nil();
 return value0;
L2:;
 if (!((v1val)==(ECL_T))){
  goto L4;
 }
 value0 = L3480c1t();
 return value0;
L4:;
 {
  cl_object v2;
  T0 = cl_list(2, ECL_SYM("EQL",336), v1val);
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[64]))->cfun.entry(1, v1val) /*  ADD-OBJECT */;
  v2 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, VV[5], ECL_SYM("TYPE",1356), T0, VV[7], T1) /*  MAKE-C1FORM* */;
  if (Null(v2)){
   goto L7;
  }
  value0 = v2;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3489c1constant_value_va(cl_narg narg, cl_object v3val, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[19]);
 {
  return L3489c1constant_value(v3val);
 }
}
/* function definition for C1CONSTANT-SYMBOL-VALUE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3490c1constant_symbol_value(cl_object v1name, cl_object v2val)
{
 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 (si_need_to_make_load_form_p(v2val)!=ECL_NIL) {
  goto L2;
 }
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[64]))->cfun.entry(1, v2val) /*  ADD-OBJECT */;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3490c1constant_symbol_value_va(cl_narg narg, cl_object v3name, cl_object v4val, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[11]);
 {
  return L3490c1constant_symbol_value(v3name, v4val);
 }
}
/* function definition for C1IF                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3491c1if(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[57]))->cfun.entry(4, ECL_SYM("IF",950), v1args, ecl_make_int8_t(2), ecl_make_int8_t(3)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2test;
  T0 = ecl_car(v1args);
  v2test = L3478c1expr(T0);
  {
   cl_object v3;                                  /*  CONSTANT-P              */
   cl_object v4;                                  /*  VALUE                   */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[68]))->cfun.entry(1, v2test) /*  C1FORM-CONSTANT-P */;
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L4;
   }
   if (Null(v4)){
    goto L7;
   }
   value0 = ecl_cadr(v1args);
   cl_env_copy->nvalues = 1;
   return value0;
L7:;
   value0 = ecl_caddr(v1args);
   cl_env_copy->nvalues = 1;
   return value0;
  }
L4:;
  {
   cl_object v3true_branch;
   cl_object v4false_branch;
   T0 = ecl_cadr(v1args);
   v3true_branch = L3478c1expr(T0);
   T0 = ecl_caddr(v1args);
   v4false_branch = L3478c1expr(T0);
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v3true_branch) /*  C1FORM-TYPE */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[42]))->cfun.entry(1, v4false_branch) /*  C1FORM-TYPE */;
   T2 = (cl_env_copy->function=ecl_fdefinition(VV[69]))->cfun.entry(2, T0, T1) /*  VALUES-TYPE-OR */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(7, ECL_SYM("IF",950), ECL_SYM("TYPE",1356), T2, VV[7], v2test, v3true_branch, v4false_branch) /*  MAKE-C1FORM* */;
   return value0;
  }
 }
}
static cl_object L3491c1if_va(cl_narg narg, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[67]);
 {
  return L3491c1if(v5args);
 }
}
/* function definition for C1NOT                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3492c1not(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[57]))->cfun.entry(4, ECL_SYM("NOT",586), v1args, ecl_make_int8_t(1), ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2value;
  T0 = ecl_car(v1args);
  v2value = L3478c1expr(T0);
  {
   cl_object v3;                                  /*  CONSTANT-P              */
   cl_object v4;                                  /*  VALUE                   */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[68]))->cfun.entry(1, v2value) /*  C1FORM-CONSTANT-P */;
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L4;
   }
   value0 = Null(v4)?ECL_T:ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L4:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(5, VV[72], ECL_SYM("TYPE",1356), VV[73], VV[7], v2value) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3492c1not_va(cl_narg narg, cl_object v3args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[71]);
 {
  return L3492c1not(v3args);
 }
}
/* function definition for C1AND                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3493c1and(cl_object v1args)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(v1args==ECL_NIL)){
  goto L2;
 }
 value0 = L3480c1t();
 return value0;
L2:;
 {
  cl_object v2values;
  cl_object v3last;
  cl_object v4butlast;
  v2values = L3483c1args_(v1args);
  T0 = ecl_last(v2values,1);
  v3last = ecl_car(T0);
  v4butlast = ecl_nbutlast(v2values,1);
  if (Null(v4butlast)){
   goto L7;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[78]))->cfun.entry(1, v3last) /*  C1FORM-PRIMARY-TYPE */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[77]))->cfun.entry(2, ECL_SYM("NULL",607), T0) /*  TYPE-OR */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(6, VV[76], ECL_SYM("TYPE",1356), T1, VV[7], v4butlast, v3last) /*  MAKE-C1FORM* */;
  return value0;
L7:;
  value0 = v3last;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3493c1and_va(cl_narg narg, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[75]);
 {
  return L3493c1and(v5args);
 }
}
/* function definition for C1OR                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3494c1or(cl_object v1args)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(v1args==ECL_NIL)){
  goto L2;
 }
 value0 = L3479c1nil();
 return value0;
L2:;
 {
  cl_object v2values;
  cl_object v3last;
  cl_object v4butlast;
  v2values = L3483c1args_(v1args);
  T0 = ecl_last(v2values,1);
  v3last = ecl_car(T0);
  v4butlast = ecl_butlast(v2values,1);
  if (Null(v4butlast)){
   goto L7;
  }
  T0 = ecl_fdefinition(VV[77]);
  T1 = ecl_fdefinition(VV[78]);
  T2 = (cl_env_copy->function=ecl_fdefinition(VV[78]))->cfun.entry(1, v3last) /*  C1FORM-PRIMARY-TYPE */;
  T3 = cl_reduce(6, T0, v4butlast, ECL_SYM("KEY",1297), T1, VV[48], T2);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(6, VV[81], ECL_SYM("TYPE",1356), T3, VV[7], v4butlast, v3last) /*  MAKE-C1FORM* */;
  return value0;
L7:;
  value0 = v3last;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3494c1or_va(cl_narg narg, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[80]);
 {
  return L3494c1or(v5args);
 }
}
/* function definition for C1MULTIPLE-VALUE-PROG1                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3495c1multiple_value_prog1(cl_object v1args)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 (cl_env_copy->function=ecl_fdefinition(VV[57]))->cfun.entry(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2;
  cl_object v3form;
  v2 = v1args;
  if (!(v2==ECL_NIL)){
   goto L5;
  }
  si_dm_too_few_arguments(v1args);
L5:;
  {
   cl_object v4;
   v4 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v3form = v4;
  }
  T0 = L3478c1expr(v3form);
  T1 = L3483c1args_(v2);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(4, VV[85], VV[7], T0, T1) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3495c1multiple_value_prog1_va(cl_narg narg, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[83]);
 {
  return L3495c1multiple_value_prog1(v4args);
 }
}
/* function definition for C1VALUES                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3496c1values(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:;
 T0 = L3483c1args_(v1args);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[4]))->cfun.entry(3, ECL_SYM("VALUES",899), VV[7], T0) /*  MAKE-C1FORM* */;
 return value0;
}
static cl_object L3496c1values_va(cl_narg narg, cl_object v2args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[87]);
 {
  return L3496c1values(v2args);
 }
}
#include "cmp/cmppass1-eval.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl4Cfvx8SWd5Nj9_AfT0M881(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-EVAL.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4Cfvx8SWd5Nj9_AfT0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(_ecl_static_0);
  (void)0; /* No entry created for C1EXPR-INNER */
  ecl_cmp_defun(VV[89]);                          /*  C1EXPR                  */
  si_Xmake_special(VV[24]);
  if (ecl_boundp(cl_env_copy,VV[24])) {
   goto L9;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, ECL_SYM("VALUE",2074), ECL_NIL) /*  MAKE-VV */;
  ecl_cmp_setq(cl_env_copy,VV[24],T0);
L9:;
  si_Xmake_special(VV[26]);
  if (ecl_boundp(cl_env_copy,VV[26])) {
   goto L16;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, ECL_SYM("VALUE",2074), ECL_T) /*  MAKE-VV */;
  ecl_cmp_setq(cl_env_copy,VV[26],T0);
L16:;
  ecl_cmp_defun(VV[90]);                          /*  C1NIL                   */
  ecl_cmp_defun(VV[91]);                          /*  C1T                     */
  ecl_cmp_defun(VV[92]);                          /*  C1WITH-BACKEND          */
  ecl_cmp_defun(VV[93]);                          /*  C1PROGN                 */
  ecl_cmp_defun(VV[94]);                          /*  C1ARGS*                 */
  ecl_cmp_defun(VV[95]);                          /*  C1DECL-BODY             */
  ecl_cmp_defun(VV[96]);                          /*  C1LOCALLY               */
  ecl_cmp_defun(VV[97]);                          /*  C1MACROLET              */
  ecl_cmp_defun(VV[98]);                          /*  C1SYMBOL-MACROLET       */
  ecl_cmp_defun(VV[99]);                          /*  CHK-SYMBOL-MACROLET     */
  ecl_cmp_defun(VV[100]);                         /*  C1CONSTANT-VALUE        */
  ecl_cmp_defun(VV[101]);                         /*  C1CONSTANT-SYMBOL-VALUE */
  ecl_cmp_defun(VV[102]);                         /*  C1IF                    */
  ecl_cmp_defun(VV[103]);                         /*  C1NOT                   */
  ecl_cmp_defun(VV[104]);                         /*  C1AND                   */
  ecl_cmp_defun(VV[105]);                         /*  C1OR                    */
  ecl_cmp_defun(VV[106]);                         /*  C1MULTIPLE-VALUE-PROG1  */
  ecl_cmp_defun(VV[107]);                         /*  C1VALUES                */
 }
}
