/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmppass1-call.lsp               */
#include <ecl/ecl-cmp.h>
#include "cmp/cmppass1-call.eclh"
/* function definition for NOT-A-CLOSURE-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3497not_a_closure_p(cl_object v1fname)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(cl_fboundp(v1fname))){
  goto L4;
 }
 {
  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);
  T2 = cl_fdefinition(v1fname);
  cl_env_copy->values[0] = cl_function_lambda_expression(T2);
  ecl_stack_frame_push_values(_ecl_inner_frame);
  T1 = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
  ecl_stack_frame_close(_ecl_inner_frame);
 }
 T0 = ecl_cadr(T1);
 goto L2;
L4:;
 T0 = ECL_NIL;
 goto L2;
L2:;
 value0 = Null(T0)?ECL_T:ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for FUNCTION-FORM-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3498function_form_p(cl_object v1form)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(ECL_CONSP(v1form))){
  goto L2;
 }
 T0 = ecl_car(v1form);
 if (!((T0)==(ECL_SYM("FUNCTION",398)))){
  goto L2;
 }
 T0 = ecl_cdr(v1form);
 (cl_env_copy->function=ecl_fdefinition(VV[2]))->cfun.entry(4, ECL_SYM("FUNCTION",398), T0, ecl_make_int8_t(1), ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for LAMBDA-FORM-P                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3499lambda_form_p(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:;
 if (Null(L3498function_form_p(v1form))){
  goto L2;
 }
 {
  cl_object v2fval;
  v2fval = ecl_cadr(v1form);
  if (!(ECL_CONSP(v2fval))){
   goto L6;
  }
  {
   cl_object v3;
   v3 = ecl_car(v2fval);
   if (!((v3)==(ECL_SYM("LAMBDA",454)))){
    goto L13;
   }
   goto L10;
L13:;
   goto L11;
L11:;
   if (!((v3)==(ECL_SYM("LAMBDA-BLOCK",1377)))){
    goto L6;
   }
   goto L8;
L10:;
  }
L8:;
  value0 = ECL_T;
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3499lambda_form_p_va(cl_narg narg, cl_object v3form, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[3]);
 {
  return L3499lambda_form_p(v3form);
 }
}
/* function definition for UNOPTIMIZED-FUNCALL                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3500unoptimized_funcall(cl_object v1fun, cl_object v2arguments)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, v1fun) /*  C1EXPR */;
  v4 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2arguments) /*  C1ARGS* */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[11], VV[12], ECL_T, VV[13], ECL_T, VV[14], v3, v4, ECL_NIL, VV[15]) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3500unoptimized_funcall_va(cl_narg narg, cl_object v5fun, cl_object v6arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[7]);
 {
  return L3500unoptimized_funcall(v5fun, v6arguments);
 }
}
/* function definition for OPTIMIZED-LAMBDA-CALL                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3501optimized_lambda_call(cl_object v1lambda_form, cl_object v2arguments, cl_object v3apply_p)
{
 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;                                   /*  BINDINGS                */
  cl_object v5;                                   /*  BODY                    */
  value0 = L3521transform_funcall_apply_into_let_(v1lambda_form, v2arguments, v3apply_p);
  {
   const int v6 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v7;
   v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v7;
  }
  value0 = cl_listX(3, ECL_SYM("LET*",480), v4, v5);
  return value0;
 }
}
static cl_object L3501optimized_lambda_call_va(cl_narg narg, cl_object v4lambda_form, cl_object v5arguments, cl_object v6apply_p, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[17]);
 {
  return L3501optimized_lambda_call(v4lambda_form, v5arguments, v6apply_p);
 }
}
/* function definition for TRY-OPTIMIZED-LAMBDA-CALL                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3502try_optimized_lambda_call(cl_object v1fun, cl_object v2args, cl_object v3apply_p)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(L3499lambda_form_p(v1fun))){
  goto L2;
 }
 T0 = ecl_cadr(v1fun);
 value0 = L3501optimized_lambda_call(T0, v2args, v3apply_p);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3502try_optimized_lambda_call_va(cl_narg narg, cl_object v4fun, cl_object v5args, cl_object v6apply_p, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[20]);
 {
  return L3502try_optimized_lambda_call(v4fun, v5args, v6apply_p);
 }
}
/* function definition for TRY-MACRO-EXPRESSION-CALL                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3503try_macro_expression_call(cl_object v1fun, cl_object v2args)
{
 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_CONSP(v1fun)) {
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3name;
  cl_object v4fd;
  v3name = ecl_car(v1fun);
  if (!(ECL_SYMBOLP(v3name))){
   goto L7;
  }
  if ((v3name)==(ECL_SYM("THE",859))) {
   goto L7;
  }
  v4fd = (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, v3name) /*  CMP-MACRO-FUNCTION */;
  goto L5;
L7:;
  v4fd = ECL_NIL;
  goto L5;
L5:;
  if (Null(v4fd)){
   goto L10;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, v4fd, v1fun) /*  CMP-EXPAND-MACRO */;
  T1 = CONS(T0,v2args);
  value0 = L3505c1funcall(T1);
  return value0;
L10:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3503try_macro_expression_call_va(cl_narg narg, cl_object v5fun, cl_object v6args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[22]);
 {
  return L3503try_macro_expression_call(v5fun, v6args);
 }
}
/* function definition for TRY-FUNCTION-SPECIAL-CALL                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3504try_function_special_call(cl_object v1fun, cl_object v2args)
{
 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 (L3498function_form_p(v1fun)!=ECL_NIL) {
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3fname;
  v3fname = ecl_cadr(v1fun);
  if (Null(si_valid_function_name_p(v3fname))){
   goto L5;
  }
  value0 = L3515c1call(v3fname, v2args, ECL_NIL);
  return value0;
L5:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[29]))->cfun.entry(2, VV[30], v3fname) /*  CMPERR */;
  return value0;
 }
}
static cl_object L3504try_function_special_call_va(cl_narg narg, cl_object v4fun, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[27]);
 {
  return L3504try_function_special_call(v4fun, v5args);
 }
}
/* function definition for C1FUNCALL                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3505c1funcall(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[2]))->cfun.entry(3, ECL_SYM("FUNCALL",396), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2;
  cl_object v3fun;
  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);
   v3fun = v4;
  }
  value0 = L3502try_optimized_lambda_call(v3fun, v2, ECL_NIL);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3503try_macro_expression_call(v3fun, v2);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3504try_function_special_call(v3fun, v2);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3500unoptimized_funcall(v3fun, v2);
  return value0;
L11:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3505c1funcall_va(cl_narg narg, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[24]);
 {
  return L3505c1funcall(v4args);
 }
}
/* function definition for TRY-SPILL-VALUES-FUNCALL                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3507try_spill_values_funcall(cl_object volatile v1fun, cl_object volatile v2arguments)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 volatile struct ecl_cclosure aux_closure;
 cl_object volatile CLV0;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  env0 = ECL_NIL;
  CLV0 = env0 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env0); /*  TRY-SPILL-VALUES-FUNCALL */
  {
   ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV0));
   if (__ecl_frs_push_result!=0) {
   ecl_frs_pop_n(cl_env_copy, 1);
   return cl_env_copy->values[0];
   } else {
   {
    cl_object v3;
    cl_object v4arg;
    cl_object v5;
    {
     cl_object v6;
     v6 = v2arguments;
     if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v3 = v6;
    }
    v4arg = ECL_NIL;
    v5 = v3;
    {
     cl_object v6val;
     v6val = ECL_NIL;
     {
      cl_object v7;
      cl_object v8;
      cl_object v9values;
      v7 = ecl_list1(ECL_NIL);
      v8 = v7;
      v9values = ECL_NIL;
L11:;
      if (!(ecl_endp(v5))){
       goto L13;
      }
      goto L12;
L13:;
      v4arg = ECL_CONS_CAR(v5);
      {
       cl_object v10;
       v10 = ECL_CONS_CDR(v5);
       if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v5 = v10;
      }
      v6val = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC3506values_form(1, v4arg));
      if (!(ECL_ATOM(v6val))){
       goto L24;
      }
      {
       cl_object v10;
       v10 = v8;
       if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v10;
      }
      v8 = ecl_list1(v6val);
      (ECL_CONS_CDR(T0)=v8,T0);
      v9values = ecl_cdr(v7);
      goto L23;
L24:;
      {
       cl_object v10;
       T0 = ecl_cdr(v6val);
       v10 = cl_copy_list(T0);
       {
        cl_object v11;
        v11 = v8;
        if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v11;
       }
       (ECL_CONS_CDR(T0)=v10,T0);
       if (Null(v10)){
        goto L32;
       }
      }
      T0 = ecl_cdr(v8);
      v8 = ecl_last(T0,1);
L32:;
      v9values = ecl_cdr(v7);
L23:;
      goto L11;
L12:;
      T0 = CONS(v1fun,v9values);
      value0 = L3505c1funcall(T0);
      ecl_frs_pop_n(cl_env_copy, 1);
      return value0;
     }
    }
   }
   }
  }
 }
}
static cl_object L3507try_spill_values_funcall_va(cl_narg narg, cl_object v3fun, cl_object v4arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[34]);
 {
  return L3507try_spill_values_funcall(v3fun, v4arguments);
 }
}
/* function definition for TRY-MACRO-EXPRESSION-MVC                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3508try_macro_expression_mvc(cl_object v1fun, cl_object v2arguments)
{
 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_CONSP(v1fun)) {
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3name;
  cl_object v4fd;
  v3name = ecl_car(v1fun);
  if (!(ECL_SYMBOLP(v3name))){
   goto L7;
  }
  if ((v3name)==(ECL_SYM("THE",859))) {
   goto L7;
  }
  v4fd = (cl_env_copy->function=ecl_fdefinition(VV[23]))->cfun.entry(1, v3name) /*  CMP-MACRO-FUNCTION */;
  goto L5;
L7:;
  v4fd = ECL_NIL;
  goto L5;
L5:;
  if (Null(v4fd)){
   goto L10;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, v4fd, v1fun) /*  CMP-EXPAND-MACRO */;
  T1 = CONS(T0,v2arguments);
  value0 = L3511c1multiple_value_call(T1);
  return value0;
L10:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3508try_macro_expression_mvc_va(cl_narg narg, cl_object v5fun, cl_object v6arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[42]);
 {
  return L3508try_macro_expression_mvc(v5fun, v6arguments);
 }
}
/* function definition for TRY-FUNCTION-SPECIAL-MVC                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3509try_function_special_mvc(cl_object v1fun, cl_object v2arguments)
{
 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 (L3498function_form_p(v1fun)!=ECL_NIL) {
  goto L2;
 }
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3fname;
  v3fname = ecl_cadr(v1fun);
  if (Null(si_valid_function_name_p(v3fname))){
   goto L5;
  }
  {
   cl_object v4funob;
   v4funob = (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(1, v3fname) /*  LOCAL-FUNCTION-REF */;
   if (Null(v4funob)){
    goto L8;
   }
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, v1fun) /*  C1EXPR */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2arguments) /*  C1ARGS* */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[47], VV[12], ECL_T, VV[13], ECL_T, VV[14], T0, T1, v4funob, ECL_SYM("LOCAL",1303)) /*  MAKE-C1FORM* */;
   return value0;
L8:;
   T0 = (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, v3fname) /*  FUNCTION-MAY-CHANGE-SP */;
   T1 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(1, v3fname) /*  FUNCTION-MAY-HAVE-SIDE-EFFECTS */;
   T2 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, v1fun) /*  C1EXPR */;
   T3 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2arguments) /*  C1ARGS* */;
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[47], VV[12], T0, VV[13], T1, VV[14], T2, T3, v3fname, VV[50]) /*  MAKE-C1FORM* */;
   return value0;
  }
L5:;
  if (Null(L3499lambda_form_p(v1fun))){
   goto L10;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L10:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[29]))->cfun.entry(2, VV[30], v3fname) /*  CMPERR */;
  return value0;
 }
}
static cl_object L3509try_function_special_mvc_va(cl_narg narg, cl_object v5fun, cl_object v6arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[45]);
 {
  return L3509try_function_special_mvc(v5fun, v6arguments);
 }
}
/* function definition for UNOPTIMIZED-MVC                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3510unoptimized_mvc(cl_object v1fun, cl_object v2arguments)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, v1fun) /*  C1EXPR */;
  v4 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2arguments) /*  C1ARGS* */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[47], VV[12], ECL_T, VV[13], ECL_T, VV[14], v3, v4, ECL_NIL, VV[15]) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3510unoptimized_mvc_va(cl_narg narg, cl_object v5fun, cl_object v6arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[52]);
 {
  return L3510unoptimized_mvc(v5fun, v6arguments);
 }
}
/* function definition for C1MULTIPLE-VALUE-CALL                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3511c1multiple_value_call(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[2]))->cfun.entry(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), v1args, ecl_make_int8_t(1)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2;
  cl_object v3fun;
  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);
   v3fun = v4;
  }
  value0 = L3507try_spill_values_funcall(v3fun, v2);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3508try_macro_expression_mvc(v3fun, v2);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3509try_function_special_mvc(v3fun, v2);
  if (value0!=ECL_NIL) {
   goto L11;
  }
  value0 = L3510unoptimized_mvc(v3fun, v2);
  return value0;
L11:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3511c1multiple_value_call_va(cl_narg narg, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[43]);
 {
  return L3511c1multiple_value_call(v4args);
 }
}
/* function definition for C1APPLY                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3514c1apply(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[2]))->cfun.entry(3, ECL_SYM("APPLY",91), v1args, ecl_make_int8_t(2)) /*  CHECK-ARGS-NUMBER */;
 {
  cl_object v2;
  cl_object v3fun;
  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);
   v3fun = v4;
  }
  if (Null(LC3513last_argument_is_frame_p(v2))){
   goto L10;
  }
  value0 = LC3512default_apply(v3fun, v2);
  return value0;
L10:;
  value0 = L3502try_optimized_lambda_call(v3fun, v2, ECL_T);
  if (value0!=ECL_NIL) {
   goto L13;
  }
  value0 = LC3512default_apply(v3fun, v2);
  return value0;
L13:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L3514c1apply_va(cl_narg narg, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[55]);
 {
  return L3514c1apply(v4args);
 }
}
/* function definition for C1CALL                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3515c1call(cl_object v1fname, cl_object v2args, cl_object v3macros_allowed)
{
 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 v4fd;
  cl_object v5success;
  cl_object v6can_inline;
  v4fd = ECL_NIL;
  v5success = ECL_NIL;
  v6can_inline = ECL_NIL;
  (cl_env_copy->function=ecl_fdefinition(VV[62]))->cfun.entry(1, v1fname) /*  ADD-FNAME */;
  v4fd = (cl_env_copy->function=ecl_fdefinition(VV[46]))->cfun.entry(1, v1fname) /*  LOCAL-FUNCTION-REF */;
  if (Null(v4fd)){
   goto L6;
  }
  value0 = L3517c1call_local(v1fname, v4fd, v2args);
  return value0;
L6:;
  if (Null(v3macros_allowed)){
   goto L9;
  }
  v4fd = (cl_env_copy->function=ecl_fdefinition(VV[64]))->cfun.entry(1, v1fname) /*  CMP-ENV-SEARCH-MACRO */;
  if (Null(v4fd)){
   goto L9;
  }
  T0 = CONS(v1fname,v2args);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, v4fd, T0) /*  CMP-EXPAND-MACRO */;
  return value0;
L9:;
  v6can_inline = (cl_env_copy->function=ecl_fdefinition(VV[65]))->cfun.entry(1, v1fname) /*  INLINE-POSSIBLE */;
  if (Null(v6can_inline)){
   goto L13;
  }
  v4fd = (cl_env_copy->function=ecl_fdefinition(VV[66]))->cfun.entry(1, v1fname) /*  CMP-COMPILER-MACRO-FUNCTION */;
  if (Null(v4fd)){
   goto L13;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[67]))->cfun.entry(3, v4fd, v1fname, v2args) /*  CMP-EXPAND-COMPILER-MACRO */;
  {
   const int v7 = cl_env_copy->nvalues;
   v4fd = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5success = v8;
  }
  if (Null(v5success)){
   goto L13;
  }
  value0 = v4fd;
  cl_env_copy->nvalues = 1;
  return value0;
L13:;
  if (Null(v6can_inline)){
   goto L21;
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[68]))->cfun.entry(2, v1fname, v2args) /*  CLOS-COMPILER-MACRO-EXPAND */;
  {
   const int v7 = cl_env_copy->nvalues;
   v4fd = value0;
   cl_object v8;
   v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
   v5success = v8;
  }
  if (Null(v5success)){
   goto L21;
  }
  value0 = v4fd;
  cl_env_copy->nvalues = 1;
  return value0;
L21:;
  if (Null(v3macros_allowed)){
   goto L26;
  }
  v4fd = cl_macro_function(1, v1fname);
  if (Null(v4fd)){
   goto L26;
  }
  T0 = CONS(v1fname,v2args);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[25]))->cfun.entry(2, v4fd, T0) /*  CMP-EXPAND-MACRO */;
  return value0;
L26:;
  v6can_inline = (cl_env_copy->function=ecl_fdefinition(VV[69]))->cfun.entry(1, v1fname) /*  DECLARED-INLINE-P */;
  if (Null(v6can_inline)){
   goto L30;
  }
  if (!(ecl_plusp(ecl_cmp_symbol_value(cl_env_copy,VV[70])))){
   goto L30;
  }
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[71]))->cfun.entry(1, ECL_SYM("SPACE",791)) /*  CMP-ENV-OPTIMIZATION */;
  if (!(ecl_lowereq(T0,ecl_make_int8_t(1)))){
   goto L30;
  }
  {
   cl_object v7;
   cl_object v8;
   cl_object v9;
   v7 = ecl_cmp_symbol_value(cl_env_copy,VV[72]);
   v8 = ecl_fdefinition(VV[73]);
   v9 = ecl_fdefinition(VV[74]);
   {
    cl_object v10;
    v10 = si_make_seq_iterator(2, v7, ecl_make_int8_t(0));
L43:;
    if (v10!=ECL_NIL) {
     goto L45;
    }
    v4fd = ECL_NIL;
    goto L38;
L45:;
    {
     cl_object v11;
     v11 = si_seq_iterator_ref(v7, v10);
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[73]))->cfun.entry(1, v11) /*  FUN-NAME */;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[74]))->cfun.entry(2, v1fname, T0) /*  SAME-FNAME-P */)){
      goto L47;
     }
     v4fd = v11;
     goto L38;
    }
L47:;
    v10 = si_seq_iterator_next(v7, v10);
    goto L43;
   }
  }
L38:;
  if (Null(v4fd)){
   goto L35;
  }
  if ((cl_env_copy->function=ecl_fdefinition(VV[79]))->cfun.entry(1, v4fd) /*  FUN-CLOSURE */!=ECL_NIL) {
   goto L35;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[80]))->cfun.entry(2, VV[81], v1fname) /*  CMPNOTE */;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(1, v4fd) /*  FUN-LAMBDA-EXPRESSION */;
  value0 = L3516inline_local(T0, v4fd, v2args);
  return value0;
L35:;
  if (Null(L3498function_form_p(v6can_inline))){
   goto L53;
  }
  if (Null(L3497not_a_closure_p(v1fname))){
   goto L53;
  }
  T0 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,VV[70]));
  ecl_bds_bind(cl_env_copy,VV[70],T0);            /*  *INLINE-MAX-DEPTH*      */
  (cl_env_copy->function=ecl_fdefinition(VV[80]))->cfun.entry(2, VV[81], v1fname) /*  CMPNOTE */;
  value0 = cl_listX(3, ECL_SYM("FUNCALL",396), v6can_inline, v2args);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L53:;
  value0 = L3518c1call_global(v1fname, v2args);
  return value0;
L30:;
  value0 = L3518c1call_global(v1fname, v2args);
  return value0;
 }
}
static cl_object L3515c1call_va(cl_narg narg, cl_object v7fname, cl_object v8args, cl_object v9macros_allowed, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[28]);
 {
  return L3515c1call(v7fname, v8args, v9macros_allowed);
 }
}
/* function definition for INLINE-LOCAL                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3516inline_local(cl_object v1lambda, cl_object v2fun, cl_object v3args)
{
 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 v4;
  cl_object v5;
  cl_object v6;
  v4 = ecl_one_minus(ecl_cmp_symbol_value(cl_env_copy,VV[70]));
  v5 = ecl_cmp_symbol_value(cl_env_copy,VV[86]);
  v6 = (cl_env_copy->function=ecl_fdefinition(VV[87]))->cfun.entry(0) /*  CMP-ENV-COPY */;
  ecl_bds_bind(cl_env_copy,VV[70],v4);            /*  *INLINE-MAX-DEPTH*      */
  ecl_bds_bind(cl_env_copy,VV[88],v6);            /*  *CMP-ENV*               */
  {
   cl_object v7;                                  /*  BINDINGS                */
   cl_object v8;                                  /*  BODY                    */
   value0 = L3521transform_funcall_apply_into_let_(v1lambda, v3args, ECL_NIL);
   {
    const int v9 = cl_env_copy->nvalues;
    v7 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v8 = v10;
   }
   {
    cl_object v9;                                 /*  LET-VARS                */
    cl_object v10;                                /*  LET-INITS               */
    cl_object v11;                                /*  SPECIALS                */
    cl_object v12;                                /*  OTHER-DECLS             */
    cl_object v13;                                /*  BODY                    */
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[89]))->cfun.entry(3, ECL_SYM("LET*",480), v7, v8) /*  PROCESS-LET-BINDINGS */;
    {
     const int v14 = cl_env_copy->nvalues;
     v9 = value0;
     cl_object v15;
     v15 = (v14<=1)? ECL_NIL : cl_env_copy->values[1];
     v10 = v15;
     v15 = (v14<=2)? ECL_NIL : cl_env_copy->values[2];
     v11 = v15;
     v15 = (v14<=3)? ECL_NIL : cl_env_copy->values[3];
     v12 = v15;
     v15 = (v14<=4)? ECL_NIL : cl_env_copy->values[4];
     v13 = v15;
    }
    T0 = (cl_env_copy->function=ecl_fdefinition(VV[90]))->cfun.entry(1, v2fun) /*  FUN-CMP-ENV */;
    T1 = (cl_env_copy->function=ecl_fdefinition(VV[87]))->cfun.entry(1, T0) /*  CMP-ENV-COPY */;
    ecl_bds_bind(cl_env_copy,VV[88],T1);          /*  *CMP-ENV*               */
    {
     cl_object v14;
     v14 = ecl_fdefinition(VV[91]);
     {
      cl_object v15;
      cl_object v16;
      cl_object v17;
      {
       cl_object v18;
       v18 = v9;
       if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v15 = v18;
      }
      v16 = ECL_NIL;
      v17 = v15;
L14:;
      if (!(ecl_endp(v17))){
       goto L16;
      }
      goto L15;
L16:;
      v16 = ECL_CONS_CAR(v17);
      {
       cl_object v18;
       v18 = ECL_CONS_CDR(v17);
       if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v17 = v18;
      }
      ecl_function_dispatch(cl_env_copy,v14)(1, v16);
      goto L14;
L15:;
      goto L7;
     }
    }
L7:;
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[92]))->cfun.entry(7, ECL_SYM("LET*",480), v9, v10, v11, v12, v13, v5) /*  PROCESS-LET-BODY */;
    ecl_bds_unwind1(cl_env_copy);
    ecl_bds_unwind1(cl_env_copy);
    ecl_bds_unwind1(cl_env_copy);
    return value0;
   }
  }
 }
}
/* function definition for C1CALL-LOCAL                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3517c1call_local(cl_object v1fname, cl_object v2fun, cl_object v3args)
{
 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 v4lambda;
  v4lambda = (cl_env_copy->function=ecl_fdefinition(VV[83]))->cfun.entry(1, v2fun) /*  FUN-LAMBDA-EXPRESSION */;
  if (Null(v4lambda)){
   goto L2;
  }
  if (Null((cl_env_copy->function=ecl_fdefinition(VV[69]))->cfun.entry(1, v1fname) /*  DECLARED-INLINE-P */)){
   goto L2;
  }
  if (!(ecl_plusp(ecl_cmp_symbol_value(cl_env_copy,VV[70])))){
   goto L2;
  }
  value0 = L3516inline_local(v4lambda, v2fun, v3args);
  return value0;
 }
L2:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v3args) /*  C1ARGS* */;
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[11], VV[12], ECL_T, VV[13], ECL_T, VV[14], ECL_NIL, T0, v2fun, ECL_SYM("LOCAL",1303)) /*  MAKE-C1FORM* */;
 return value0;
}
/* function definition for C1CALL-GLOBAL                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3518c1call_global(cl_object v1fname, cl_object v2args)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3forms;
  v3forms = (cl_env_copy->function=ecl_fdefinition(VV[9]))->cfun.entry(1, v2args) /*  C1ARGS* */;
  {
   cl_object v4value;
   v4value = L3520c1call_constant_fold(v1fname, v3forms);
   if (Null(v4value)){
    goto L3;
   }
   value0 = v4value;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L3:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[48]))->cfun.entry(1, v1fname) /*  FUNCTION-MAY-CHANGE-SP */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[49]))->cfun.entry(1, v1fname) /*  FUNCTION-MAY-HAVE-SIDE-EFFECTS */;
  T2 = cl_list(2, ECL_SYM("FUNCTION",398), v1fname);
  T3 = (cl_env_copy->function=ecl_fdefinition(VV[8]))->cfun.entry(1, T2) /*  C1EXPR */;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(10, VV[11], VV[12], T0, VV[13], T1, VV[14], T3, v3forms, v1fname, VV[50]) /*  MAKE-C1FORM* */;
  return value0;
 }
}
static cl_object L3518c1call_global_va(cl_narg narg, cl_object v4fname, cl_object v5args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[84]);
 {
  return L3518c1call_global(v4fname, v5args);
 }
}
/* function definition for C1CALL-CONSTANT-FOLD                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3520c1call_constant_fold(cl_object volatile v1fname, cl_object volatile v2forms)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[95]))->cfun.entry(1, v1fname) /*  FUNCTION-IS-PURE */)){
  goto L2;
 }
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[96]))->cfun.entry(0) /*  POLICY-EVALUATE-FORMS */)){
  goto L2;
 }
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[65]))->cfun.entry(1, v1fname) /*  INLINE-POSSIBLE */)){
  goto L2;
 }
 {
  volatile cl_object env1 = env0;
  env1 = ECL_NIL;
  CLV0 = env1 = CONS(ECL_NIL,env1);
  {
   volatile cl_object env2 = env1;
   CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY        */
   {
    ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
    if (__ecl_frs_push_result!=0) {
    if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
     goto L6;
    }
    ecl_internal_error("GO found an inexistent tag");
    } else {
    {
     cl_object v3;
     v3 = ecl_make_cclosure_va((cl_objectfn)LC3519__lambda89,env2,Cblock,1);
     T0 = v3;
    }
    T1 = CONS(ECL_SYM("ERROR",339),T0);
    T2 = ecl_list1(T1);
    T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
    ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
    {
     cl_object v3all_values;
     v3all_values = ECL_NIL;
     {
      cl_object v4constant_p;
      v4constant_p = ECL_NIL;
      {
       cl_object v5v;
       v5v = ECL_NIL;
       {
        cl_object v6;
        cl_object v7form;
        cl_object v8;
        {
         cl_object v9;
         v9 = v2forms;
         if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v6 = v9;
        }
        v7form = ECL_NIL;
        v8 = v6;
L17:;
        if (!(ecl_endp(v8))){
         goto L19;
        }
        goto L18;
L19:;
        v7form = ECL_CONS_CAR(v8);
        {
         cl_object v9;
         v9 = ECL_CONS_CDR(v8);
         if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v8 = v9;
        }
        value0 = (cl_env_copy->function=ecl_fdefinition(VV[99]))->cfun.entry(1, v7form) /*  C1FORM-CONSTANT-P */;
        {
         const int v9 = cl_env_copy->nvalues;
         v4constant_p = value0;
         cl_object v10;
         v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
         v5v = v10;
        }
        if (Null(value0)){
         goto L28;
        }
        v3all_values = CONS(v5v,v3all_values);
        goto L27;
L28:;
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 1;
        ecl_frs_pop_n(cl_env_copy, 1);
        ecl_bds_unwind1(cl_env_copy);
        return value0;
L27:;
        goto L17;
L18:;
        {
         cl_object v9results;
         {
          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);
          T0 = cl_nreverse(v3all_values);
          cl_env_copy->values[0] = cl_apply(2, v1fname, T0);
          ecl_stack_frame_push_values(_ecl_inner_frame);
          v9results = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
          ecl_stack_frame_close(_ecl_inner_frame);
         }
         T0 = ecl_cdr(v9results);
         if (!(ecl_endp(T0))){
          goto L36;
         }
         T0 = ecl_car(v9results);
         value0 = (cl_env_copy->function=ecl_fdefinition(VV[100]))->cfun.entry(1, T0) /*  C1CONSTANT-VALUE */;
         ecl_frs_pop_n(cl_env_copy, 1);
         ecl_bds_unwind1(cl_env_copy);
         return value0;
L36:;
         {
          cl_object v10results;
          {
          cl_object v11;
          v11 = ecl_fdefinition(VV[100]);
          {
          cl_object v12;
          cl_object v13;
          cl_object v14;
          {
          cl_object v15;
          v15 = v9results;
          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;
L47:;
          if (!(ecl_endp(v14))){
          goto L49;
          }
          goto L48;
L49:;
          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;
          T0 = v17;
          }
          T1 = ecl_function_dispatch(cl_env_copy,v11)(1, v13);
          v16 = ecl_list1(T1);
          (ECL_CONS_CDR(T0)=v16,T0);
          goto L47;
L48:;
          v10results = ecl_cdr(v15);
          goto L38;
          }
          }
          }
L38:;
          T0 = (ECL_SYM("IDENTITY",428)->symbol.gfdef);
          if (Null(cl_every(2, T0, v10results))){
          goto L65;
          }
          value0 = (cl_env_copy->function=ecl_fdefinition(VV[10]))->cfun.entry(3, ECL_SYM("VALUES",899), VV[14], v10results) /*  MAKE-C1FORM* */;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          return value0;
L65:;
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 1;
          ecl_frs_pop_n(cl_env_copy, 1);
          ecl_bds_unwind1(cl_env_copy);
          return value0;
         }
        }
       }
      }
     }
    }
L6:;
    {
     cl_object v3c;
     v3c = ECL_CONS_CAR(CLV0);
     value0 = (cl_env_copy->function=ecl_fdefinition(VV[102]))->cfun.entry(4, VV[103], v1fname, v2forms, v3c) /*  CMPDEBUG */;
     ecl_frs_pop_n(cl_env_copy, 1);
     return value0;
    }
    }
   }
  }
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3520c1call_constant_fold_va(cl_narg narg, cl_object v3fname, cl_object v4forms, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[93]);
 {
  return L3520c1call_constant_fold(v3fname, v4forms);
 }
}
/* function definition for TRANSFORM-FUNCALL/APPLY-INTO-LET*                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3521transform_funcall_apply_into_let_(cl_object v1lambda_form, cl_object v2arguments, cl_object v3apply_p)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 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 v4apply_list;
  cl_object v5apply_var;
  cl_object v6let_vars;
  cl_object v7extra_stmts;
  cl_object v8all_keys;
  v4apply_list = ECL_NIL;
  v5apply_var = ECL_NIL;
  v6let_vars = ECL_NIL;
  v7extra_stmts = ECL_NIL;
  v8all_keys = ECL_NIL;
  T0 = ecl_car(v1lambda_form);
  if (!((T0)==(ECL_SYM("LAMBDA-BLOCK",1377)))){
   goto L7;
  }
  v1lambda_form = cl_macroexpand_1(1, v1lambda_form);
L7:;
  {
   cl_object v9;                                  /*  REQUIREDS               */
   cl_object v10;                                 /*  OPTIONALS               */
   cl_object v11;                                 /*  REST                    */
   cl_object v12;                                 /*  KEY-FLAG                */
   cl_object v13;                                 /*  KEYWORDS                */
   cl_object v14;                                 /*  ALLOW-OTHER-KEYS        */
   cl_object v15;                                 /*  AUX-VARS                */
   T0 = ecl_cadr(v1lambda_form);
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[105]))->cfun.entry(1, T0) /*  CMP-PROCESS-LAMBDA-LIST */;
   {
    const int v16 = cl_env_copy->nvalues;
    v9 = value0;
    cl_object v17;
    v17 = (v16<=1)? ECL_NIL : cl_env_copy->values[1];
    v10 = v17;
    v17 = (v16<=2)? ECL_NIL : cl_env_copy->values[2];
    v11 = v17;
    v17 = (v16<=3)? ECL_NIL : cl_env_copy->values[3];
    v12 = v17;
    v17 = (v16<=4)? ECL_NIL : cl_env_copy->values[4];
    v13 = v17;
    v17 = (v16<=5)? ECL_NIL : cl_env_copy->values[5];
    v14 = v17;
    v17 = (v16<=6)? ECL_NIL : cl_env_copy->values[6];
    v15 = v17;
   }
   if (Null(v3apply_p)){
    goto L11;
   }
   T0 = ecl_last(v2arguments,1);
   v4apply_list = ecl_car(T0);
   v5apply_var = cl_gensym(0);
   v2arguments = ecl_butlast(v2arguments,1);
L11:;
   {
    cl_object v16n_args_wanted_min;
    cl_object v17n_args_wanted_max;
    cl_object v18apply_constant_args_p;
    cl_object v19n_args_got_min;
    cl_object v20n_args_got_max;
    v16n_args_wanted_min = ecl_car(v9);
    if (v12!=ECL_NIL) {
     goto L23;
    }
    if (v14!=ECL_NIL) {
     goto L23;
    }
    if (Null(v11)){
     goto L21;
    }
    goto L22;
L23:;
L22:;
    v17n_args_wanted_max = ecl_make_fixnum(65536);
    goto L20;
L21:;
    T0 = ecl_car(v9);
    T1 = ecl_car(v10);
    v17n_args_wanted_max = ecl_plus(T0,T1);
L20:;
    if (Null(v3apply_p)){
     goto L28;
    }
    if (Null(cl_constantp(1, v4apply_list))){
     goto L28;
    }
    T0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("CONSTANT-FORM-VALUE",2161)))->cfun.entry(1, v4apply_list) /*  CONSTANT-FORM-VALUE */;
    v18apply_constant_args_p = ecl_make_bool(ECL_LISTP(T0));
    goto L26;
L28:;
    v18apply_constant_args_p = ECL_NIL;
    goto L26;
L26:;
    if (Null(v18apply_constant_args_p)){
     goto L32;
    }
    {
     cl_fixnum v21;
     v21 = ecl_length(v2arguments);
     T0 = (cl_env_copy->function=ecl_fdefinition(ECL_SYM("CONSTANT-FORM-VALUE",2161)))->cfun.entry(1, v4apply_list) /*  CONSTANT-FORM-VALUE */;
     {
      cl_fixnum v22;
      v22 = ecl_length(T0);
      v19n_args_got_min = ecl_plus(ecl_make_fixnum(v21),ecl_make_fixnum(v22));
      goto L31;
     }
    }
L32:;
    v19n_args_got_min = ecl_make_fixnum(ecl_length(v2arguments));
L31:;
    if (Null(v3apply_p)){
     goto L35;
    }
    if (v18apply_constant_args_p!=ECL_NIL) {
     goto L35;
    }
    v20n_args_got_max = ECL_NIL;
    goto L34;
L35:;
    v20n_args_got_max = v19n_args_got_min;
L34:;
    if (Null(v20n_args_got_max)){
     goto L38;
    }
    if (!(ecl_lower(v20n_args_got_max,v16n_args_wanted_min))){
     goto L38;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[106]))->cfun.entry(3, v1lambda_form, v16n_args_wanted_min, v19n_args_got_min) /*  TOO-FEW-ARGS */;
L38:;
    if (!(ecl_greater(v19n_args_got_min,v17n_args_wanted_max))){
     goto L18;
    }
    (cl_env_copy->function=ecl_fdefinition(VV[107]))->cfun.entry(3, v1lambda_form, v17n_args_wanted_max, v20n_args_got_max) /*  TOO-MANY-ARGS */;
   }
L18:;
   v2arguments = cl_copy_list(v2arguments);
   {
    cl_object v16scan;
    v16scan = v2arguments;
    goto L48;
L47:;
    {
     cl_object v17form;
     v17form = ecl_car(v16scan);
     if (cl_constantp(1, v17form)!=ECL_NIL) {
      goto L50;
     }
     {
      cl_object v18aux_var;
      v18aux_var = cl_gensym(0);
      T0 = cl_list(2, v18aux_var, v17form);
      v6let_vars = CONS(T0,v6let_vars);
      {
       cl_object v19;
       v19 = v18aux_var;
       {
        cl_object v20;
        v20 = v16scan;
        if (ecl_unlikely(ECL_ATOM(v20))) FEtype_error_cons(v20);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v20;
       }
       (ECL_CONS_CAR(T0)=v19,T0);
      }
     }
    }
L50:;
    v16scan = ecl_cdr(v16scan);
L48:;
    if (ecl_endp(v16scan)) {
     goto L63;
    }
    goto L47;
L63:;
   }
   if (Null(v5apply_var)){
    goto L65;
   }
   T0 = cl_list(2, v5apply_var, v4apply_list);
   v6let_vars = CONS(T0,v6let_vars);
L65:;
   {
    cl_object v16;
    v16 = ecl_cdr(v9);
    goto L72;
L71:;
    {
     cl_object v17i;
     v17i = ecl_car(v16);
     if (Null(v2arguments)){
      goto L79;
     }
     {
      cl_object v18;
      v18 = v2arguments;
      {
       cl_object v19;
       v19 = v18;
       {
        bool v20;
        v20 = ECL_LISTP(v19);
        if (ecl_unlikely(!(v20)))
         FEwrong_type_argument(VV[110],v19);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
       }
      }
      if (Null(v18)){
       goto L85;
      }
      {
       cl_object v19;
       v19 = ECL_CONS_CDR(v18);
       v2arguments = v19;
       v18 = ECL_CONS_CAR(v18);
      }
L85:;
      T0 = v18;
      goto L78;
     }
L79:;
     if (Null(v3apply_p)){
      goto L91;
     }
     T1 = cl_list(2, ECL_SYM("POP",646), v5apply_var);
     T0 = cl_list(4, ECL_SYM("IF",950), v5apply_var, T1, VV[111]);
     goto L78;
L91:;
     T0 = ECL_NIL;
L78:;
     T1 = cl_list(2, v17i, T0);
     v6let_vars = CONS(T1,v6let_vars);
    }
    v16 = ecl_cdr(v16);
L72:;
    if (Null(v16)){
     goto L95;
    }
    goto L71;
L95:;
   }
   {
    cl_object v16scan;
    v16scan = ecl_cdr(v10);
    goto L101;
L100:;
    {
     cl_object v17;
     cl_object v18;
     cl_object v19;
     v17 = ecl_car(v16scan);
     v18 = ecl_caddr(v16scan);
     v19 = ecl_cadr(v16scan);
     if (Null(v2arguments)){
      goto L107;
     }
     {
      cl_object v20;
      v20 = v2arguments;
      {
       cl_object v21;
       v21 = v20;
       {
        bool v22;
        v22 = ECL_LISTP(v21);
        if (ecl_unlikely(!(v22)))
         FEwrong_type_argument(VV[110],v21);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
       }
      }
      if (Null(v20)){
       goto L115;
      }
      {
       cl_object v21;
       v21 = ECL_CONS_CDR(v20);
       v2arguments = v21;
       v20 = ECL_CONS_CAR(v20);
      }
L115:;
      T0 = v20;
     }
     T1 = cl_list(2, v17, T0);
     T2 = cl_list(2, v18, ECL_T);
     v6let_vars = cl_listX(3, T1, T2, v6let_vars);
     goto L103;
L107:;
     if (Null(v3apply_p)){
      goto L121;
     }
     T0 = cl_list(2, ECL_SYM("POP",646), v5apply_var);
     T1 = cl_list(4, ECL_SYM("IF",950), v5apply_var, T0, v19);
     T2 = cl_list(2, v17, T1);
     T3 = cl_list(2, v18, v5apply_var);
     v6let_vars = cl_listX(3, T2, T3, v6let_vars);
     goto L103;
L121:;
     T0 = cl_list(2, v17, v19);
     T1 = cl_list(2, v18, ECL_NIL);
     v6let_vars = cl_listX(3, T0, T1, v6let_vars);
    }
L103:;
    v16scan = ecl_cdddr(v16scan);
L101:;
    if (ecl_endp(v16scan)) {
     goto L127;
    }
    goto L100;
L127:;
   }
   if (v12!=ECL_NIL) {
    goto L131;
   }
   if (Null(v14)){
    goto L129;
   }
   goto L130;
L131:;
L130:;
   if (v11!=ECL_NIL) {
    goto L129;
   }
   v11 = cl_gensym(0);
L129:;
   if (Null(v11)){
    goto L136;
   }
   if (Null(v2arguments)){
    goto L140;
   }
   if (Null(v3apply_p)){
    goto L142;
   }
   T1 = ecl_list1(v5apply_var);
   T2 = ecl_append(v2arguments,T1);
   T0 = CONS(ECL_SYM("LIST*",484),T2);
   goto L139;
L142:;
   T0 = CONS(ECL_SYM("LIST",483),v2arguments);
   goto L139;
L140:;
   if (Null(v3apply_p)){
    goto L144;
   }
   T0 = v5apply_var;
   goto L139;
L144:;
   T0 = ECL_NIL;
L139:;
   T1 = cl_list(2, v11, T0);
   v6let_vars = CONS(T1,v6let_vars);
   goto L135;
L136:;
   if (Null(v3apply_p)){
    goto L135;
   }
   T0 = cl_list(3, ECL_SYM("WHEN",909), v5apply_var, VV[112]);
   v7extra_stmts = CONS(T0,v7extra_stmts);
L135:;
   {
    cl_object v16scan;
    v16scan = ecl_cdr(v13);
    goto L152;
L151:;
    {
     cl_object v17;
     cl_object v18;
     cl_object v19;
     cl_object v20;
     v17 = ecl_car(v16scan);
     v18 = ecl_cadr(v16scan);
     v19 = ecl_caddr(v16scan);
     value0 = ecl_cadddr(v16scan);
     if (value0!=ECL_NIL) {
      goto L160;
     }
     v20 = cl_gensym(0);
     goto L158;
L160:;
     v20 = value0;
     goto L158;
L158:;
     v8all_keys = CONS(v17,v8all_keys);
     T0 = cl_list(3, ECL_SYM("EQ",335), v20, VV[113]);
     if (Null(ecl_cadddr(v16scan))){
      goto L166;
     }
     T1 = cl_list(3, ECL_SYM("SETF",753), v20, ECL_NIL);
     goto L165;
L166:;
     T1 = ECL_NIL;
L165:;
     T2 = cl_list(3, ECL_SYM("PROG1",672), v19, T1);
     if (Null(ecl_cadddr(v16scan))){
      goto L169;
     }
     T3 = cl_list(3, ECL_SYM("SETF",753), v20, ECL_T);
     goto L168;
L169:;
     T3 = ECL_NIL;
L168:;
     T4 = cl_list(3, ECL_SYM("PROG1",672), v20, T3);
     T5 = cl_list(4, ECL_SYM("IF",950), T0, T2, T4);
     T6 = cl_list(2, v18, T5);
     T7 = cl_list(3, VV[114], v11, v17);
     T8 = cl_list(2, v20, T7);
     v6let_vars = cl_listX(3, T6, T8, v6let_vars);
    }
    v16scan = ecl_cddddr(v16scan);
L152:;
    if (ecl_endp(v16scan)) {
     goto L173;
    }
    goto L151;
L173:;
   }
   if (Null(v12)){
    goto L175;
   }
   if (v14!=ECL_NIL) {
    goto L175;
   }
   T0 = cl_list(2, ECL_SYM("QUOTE",682), v8all_keys);
   T1 = cl_list(3, VV[115], v11, T0);
   v7extra_stmts = CONS(T1,v7extra_stmts);
L175:;
   {
    cl_object v16;
    v16 = v15;
    {
     cl_object v17;
     v17 = v16;
     {
      bool v18;
      v18 = ECL_LISTP(v17);
      if (ecl_unlikely(!(v18)))
         FEwrong_type_argument(VV[110],v17);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v16)){
     goto L184;
    }
    {
     cl_object v17;
     v17 = ECL_CONS_CDR(v16);
     v15 = v17;
     v16 = ECL_CONS_CAR(v16);
    }
L184:;
   }
L191:;
   if (v15!=ECL_NIL) {
    goto L193;
   }
   goto L192;
L193:;
   {
    cl_object v16;
    v16 = v15;
    {
     cl_object v17;
     v17 = v16;
     {
      bool v18;
      v18 = ECL_LISTP(v17);
      if (ecl_unlikely(!(v18)))
         FEwrong_type_argument(VV[110],v17);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v16)){
     goto L202;
    }
    {
     cl_object v17;
     v17 = ECL_CONS_CDR(v16);
     v15 = v17;
     v16 = ECL_CONS_CAR(v16);
    }
L202:;
    T0 = v16;
   }
   {
    cl_object v16;
    v16 = v15;
    {
     cl_object v17;
     v17 = v16;
     {
      bool v18;
      v18 = ECL_LISTP(v17);
      if (ecl_unlikely(!(v18)))
         FEwrong_type_argument(VV[110],v17);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
     }
    }
    if (Null(v16)){
     goto L213;
    }
    {
     cl_object v17;
     v17 = ECL_CONS_CDR(v16);
     v15 = v17;
     v16 = ECL_CONS_CAR(v16);
    }
L213:;
    T1 = v16;
   }
   T2 = cl_list(2, T0, T1);
   v6let_vars = CONS(T2,v6let_vars);
   goto L191;
L192:;
   T0 = (ECL_SYM("FIRST",373)->symbol.gfdef);
   T1 = cl_delete_if_not(2, T0, v6let_vars);
   T2 = cl_nreverse(T1);
   if (Null(v5apply_var)){
    goto L223;
   }
   T4 = cl_list(2, ECL_SYM("IGNORABLE",429), v5apply_var);
   T5 = cl_list(2, ECL_SYM("DECLARE",276), T4);
   T3 = ecl_list1(T5);
   goto L221;
L223:;
   T3 = ECL_NIL;
   goto L221;
L221:;
   {
    cl_object v16;                                /*  DECL                    */
    cl_object v17;                                /*  BODY                    */
    T5 = ecl_cddr(v1lambda_form);
    value0 = si_find_declarations(1, T5);
    {
     const int v18 = cl_env_copy->nvalues;
     v16 = value0;
     cl_object v19;
     v19 = (v18<=1)? ECL_NIL : cl_env_copy->values[1];
     v17 = v19;
    }
    T4 = cl_append(3, v16, v7extra_stmts, v17);
   }
   T5 = ecl_append(T3,T4);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = T5;
   cl_env_copy->values[0] = T2;
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L3521transform_funcall_apply_into_let__va(cl_narg narg, cl_object v9lambda_form, cl_object v10arguments, cl_object v11apply_p, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[18]);
 {
  return L3521transform_funcall_apply_into_let_(v9lambda_form, v10arguments, v11apply_p);
 }
}
/* function definition for OPTIMIZE-FUNCALL/APPLY-LAMBDA                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3522optimize_funcall_apply_lambda(cl_object v1lambda_form, cl_object v2arguments, cl_object v3apply_p)
{
 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;                                   /*  BINDINGS                */
  cl_object v5;                                   /*  BODY                    */
  value0 = L3521transform_funcall_apply_into_let_(v1lambda_form, v2arguments, v3apply_p);
  {
   const int v6 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v7;
   v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v7;
  }
  value0 = cl_listX(3, ECL_SYM("LET*",480), v4, v5);
  return value0;
 }
}
static cl_object L3522optimize_funcall_apply_lambda_va(cl_narg narg, cl_object v4lambda_form, cl_object v5arguments, cl_object v6apply_p, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[118]);
 {
  return L3522optimize_funcall_apply_lambda(v4lambda_form, v5arguments, v6apply_p);
 }
}
/* closure VALUES-FORM                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3506values_form(cl_narg narg, cl_object v1arg, ...)
{
 cl_object T0;
 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;                                     /*  TRY-SPILL-VALUES-FUNCALL */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[35]);
 {
L1:;
  v1arg = (cl_env_copy->function=ecl_fdefinition(VV[36]))->cfun.entry(1, v1arg) /*  CHK-SYMBOL-MACROLET */;
  if (ECL_ATOM(v1arg)) {
   goto L6;
  }
  T0 = ecl_car(v1arg);
  if (!((T0)==(ECL_SYM("VALUES",899)))){
   goto L4;
  }
  goto L5;
L6:;
L5:;
  value0 = v1arg;
  cl_env_copy->nvalues = 1;
  return value0;
L4:;
  cl_env_copy->values[0] = ECL_NIL;
  cl_env_copy->nvalues = 1;
  cl_return_from(ECL_CONS_CAR(CLV0),VV[34]);
 }
 }
}
/* local function LAST-ARGUMENT-IS-FRAME-P                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3513last_argument_is_frame_p(cl_object v1arguments)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = ecl_last(v1arguments,1);
 T1 = ecl_car(T0);
 value0 = ecl_make_bool((T1)==(ECL_SYM(".COMBINED-METHOD-ARGS.",1547)));
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC3513last_argument_is_frame_p_va(cl_narg narg, cl_object v2arguments, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[60]);
 {
  return LC3513last_argument_is_frame_p(v2arguments);
 }
}
/* local function DEFAULT-APPLY                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3512default_apply(cl_object v1fun, cl_object v2arguments)
{
 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 v3form;
  T0 = cl_listX(3, VV[57], v1fun, v2arguments);
  v3form = L3505c1funcall(T0);
  if (Null(L3498function_form_p(v1fun))){
   goto L3;
  }
  {
   cl_object v4fname;
   cl_object v5type;
   v4fname = ecl_cadr(v1fun);
   v5type = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v4fname) /*  GET-RETURN-TYPE */;
   if (Null(v5type)){
    goto L3;
   }
   ecl_structure_set(v3form,VV[59],(cl_fixnum)(1),v5type);
  }
L3:;
  value0 = v3form;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC3512default_apply_va(cl_narg narg, cl_object v4fun, cl_object v5arguments, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[56]);
 {
  return LC3512default_apply(v4fun, v5arguments);
 }
}
/* closure LAMBDA89                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3519__lambda89(cl_narg narg, cl_object v1si__temp, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[98]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1si__temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
#include "cmp/cmppass1-call.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclAiEafgbcZUqr9_vhT0M881(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-CALL.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclAiEafgbcZUqr9_vhT0M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(_ecl_static_0);
  (void)0; /* No entry created for NOT-A-CLOSURE-P */
  (void)0; /* No entry created for FUNCTION-FORM-P */
  ecl_cmp_defun(VV[120]);                         /*  LAMBDA-FORM-P           */
  ecl_cmp_defun(VV[121]);                         /*  UNOPTIMIZED-FUNCALL     */
  ecl_cmp_defun(VV[122]);                         /*  OPTIMIZED-LAMBDA-CALL   */
  ecl_cmp_defun(VV[123]);                         /*  TRY-OPTIMIZED-LAMBDA-CALL */
  ecl_cmp_defun(VV[124]);                         /*  TRY-MACRO-EXPRESSION-CALL */
  ecl_cmp_defun(VV[125]);                         /*  TRY-FUNCTION-SPECIAL-CALL */
  ecl_cmp_defun(VV[126]);                         /*  C1FUNCALL               */
  ecl_cmp_defun(VV[127]);                         /*  TRY-SPILL-VALUES-FUNCALL */
  ecl_cmp_defun(VV[128]);                         /*  TRY-MACRO-EXPRESSION-MVC */
  ecl_cmp_defun(VV[129]);                         /*  TRY-FUNCTION-SPECIAL-MVC */
  ecl_cmp_defun(VV[130]);                         /*  UNOPTIMIZED-MVC         */
  ecl_cmp_defun(VV[131]);                         /*  C1MULTIPLE-VALUE-CALL   */
  ecl_cmp_defun(VV[132]);                         /*  C1APPLY                 */
  ecl_cmp_defun(VV[133]);                         /*  C1CALL                  */
  (void)0; /* No entry created for INLINE-LOCAL */
  (void)0; /* No entry created for C1CALL-LOCAL */
  ecl_cmp_defun(VV[134]);                         /*  C1CALL-GLOBAL           */
  ecl_cmp_defun(VV[135]);                         /*  C1CALL-CONSTANT-FOLD    */
  ecl_cmp_defun(VV[136]);                         /*  TRANSFORM-FUNCALL/APPLY-INTO-LET* */
  ecl_cmp_defun(VV[137]);                         /*  OPTIMIZE-FUNCALL/APPLY-LAMBDA */
}
