/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/cmp/cmpbackend-cxx/cmppass2-call.lsp */
#include <ecl/ecl-cmp.h>
#include "cmp/cmppass2-call.eclh"
/* function definition for C2FCALL                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3872c2fcall(cl_object v1c1form, cl_object v2fun, cl_object v3args, cl_object v4fun_val, cl_object v5call_type)
{
 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_fixnum v6;
  v6 = ecl_length(v3args);
  if (!((v6)>(ecl_fixnum(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("C-ARGUMENTS-LIMIT",1056)))))){
   goto L2;
  }
 }
 if (!((v5call_type)==(ECL_SYM("LOCAL",1303)))){
  goto L4;
 }
 value0 = L3876c2call_local_stack(v1c1form, v4fun_val, v3args);
 return value0;
L4:;
 if (!((v5call_type)==(VV[3]))){
  goto L11;
 }
 goto L8;
L11:;
 goto L9;
L9:;
 if (!((v5call_type)==(VV[4]))){
  goto L6;
 }
 goto L7;
L8:;
L7:;
 value0 = L3874c2call_global_stack(v1c1form, v2fun, v3args, ECL_NIL);
 return value0;
L6:;
 value0 = si_ecase_error(v5call_type, VV[7]);
 return value0;
L2:;
 {
  cl_object v6;
  cl_object v7;
  v6 = ecl_cmp_symbol_value(cl_env_copy,VV[9]);
  v7 = ecl_cmp_symbol_value(cl_env_copy,VV[10]);
  ecl_bds_bind(cl_env_copy,VV[11],ecl_make_int8_t(0)); /*  *INLINE-BLOCKS*    */
  ecl_bds_bind(cl_env_copy,VV[9],v6);             /*  *TEMP*                  */
  ecl_bds_bind(cl_env_copy,VV[10],v7);            /*  *LCL*                   */
  if (!((v5call_type)==(ECL_SYM("LOCAL",1303)))){
   goto L17;
  }
  L3878c2call_local(v1c1form, v4fun_val, v3args);
  goto L16;
L17:;
  if (!((v5call_type)==(VV[3]))){
   goto L19;
  }
  L3877c2call_global(v1c1form, v4fun_val, v3args);
  goto L16;
L19:;
  if (!((v5call_type)==(VV[4]))){
   goto L21;
  }
  L3879c2call_unknown(v1c1form, v2fun, v3args);
  goto L16;
L21:;
  si_ecase_error(v5call_type, VV[15]);
L16:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[16]))->cfun.entry(0) /*  CLOSE-INLINE-BLOCKS */;
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
static cl_object L3872c2fcall_va(cl_narg narg, cl_object v8c1form, cl_object v9fun, cl_object v10args, cl_object v11fun_val, cl_object v12call_type, ...)
{
 if (ecl_unlikely(narg!=5)) FEwrong_num_arguments(VV[0]);
 {
  return L3872c2fcall(v8c1form, v9fun, v10args, v11fun_val, v12call_type);
 }
}
/* function definition for C2MCALL                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3873c2mcall(cl_object v1c1form, cl_object v2form, cl_object v3args, cl_object v4fun_val, cl_object v5call_type)
{
 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 = L3874c2call_global_stack(v1c1form, v2form, v3args, ECL_T);
 return value0;
}
static cl_object L3873c2mcall_va(cl_narg narg, cl_object v6c1form, cl_object v7form, cl_object v8args, cl_object v9fun_val, cl_object v10call_type, ...)
{
 if (ecl_unlikely(narg!=5)) FEwrong_num_arguments(VV[18]);
 {
  return L3873c2mcall(v6c1form, v7form, v8args, v9fun_val, v10call_type);
 }
}
/* function definition for C2CALL-GLOBAL-STACK                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3874c2call_global_stack(cl_object v1c1form, cl_object v2form, cl_object v3args, cl_object v4values_p)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v5;
  cl_object v6;
  v5 = ecl_cmp_symbol_value(cl_env_copy,VV[9]);
  v6 = ecl_cmp_symbol_value(cl_env_copy,VV[10]);
  ecl_bds_bind(cl_env_copy,VV[11],ecl_make_int8_t(0)); /*  *INLINE-BLOCKS*    */
  ecl_bds_bind(cl_env_copy,VV[9],v5);             /*  *TEMP*                  */
  ecl_bds_bind(cl_env_copy,VV[10],v6);            /*  *LCL*                   */
  (cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(0) /*  OPEN-INLINE-BLOCK */;
  T0 = cl_list(2, VV[26], VV[23]);
  T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[25]));
  ecl_bds_bind(cl_env_copy,VV[25],T1);            /*  *UNWIND-EXIT*           */
  (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(3, VV[28], VV[24], VV[29]) /*  WT-NL */;
  (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(6, ecl_cmp_symbol_value(cl_env_copy,VV[30]), VV[31], VV[23], VV[32], VV[24], VV[33]) /*  WT-NL */;
  {
   cl_object v7loc;
   v7loc = (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, v2form, v3args) /*  EMIT-INLINE-FORM */;
   if (Null(v4values_p)){
    goto L11;
   }
   T0 = VV[36];
   goto L10;
L11:;
   T0 = VV[37];
L10:;
   ecl_bds_bind(cl_env_copy,VV[35],T0);           /*  *DESTINATION*           */
   {
    cl_object v8;
    v8 = v3args;
    goto L16;
L15:;
    {
     cl_object v9arg;
     v9arg = ecl_car(v8);
     (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, v9arg) /*  C2EXPR* */;
     if (Null(v4values_p)){
      goto L22;
     }
     (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(3, VV[39], VV[23], VV[40]) /*  WT-NL */;
     goto L21;
L22:;
     (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(3, VV[41], VV[23], VV[42]) /*  WT-NL */;
L21:;
    }
    v8 = ecl_cdr(v8);
L16:;
    if (Null(v8)){
     goto L26;
    }
    goto L15;
L26:;
    ecl_bds_unwind1(cl_env_copy);
   }
   T0 = L3882call_global_stack_loc(ECL_NIL, v7loc);
   (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, T0) /*  UNWIND-EXIT */;
   ecl_bds_unwind1(cl_env_copy);
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[16]))->cfun.entry(0) /*  CLOSE-INLINE-BLOCKS */;
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
static cl_object L3874c2call_global_stack_va(cl_narg narg, cl_object v7c1form, cl_object v8form, cl_object v9args, cl_object v10values_p, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[6]);
 {
  return L3874c2call_global_stack(v7c1form, v8form, v9args, v10values_p);
 }
}
/* function definition for C2CALL-LOCAL-STACK                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3876c2call_local_stack(cl_object v1c1form, cl_object v2fun, cl_object v3args)
{
 cl_object T0, T1;
 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);
L1:;
 {
  cl_object v4;
  cl_object v5;
  v4 = ecl_cmp_symbol_value(cl_env_copy,VV[9]);
  v5 = ecl_cmp_symbol_value(cl_env_copy,VV[10]);
  ecl_bds_bind(cl_env_copy,VV[11],ecl_make_int8_t(0)); /*  *INLINE-BLOCKS*    */
  ecl_bds_bind(cl_env_copy,VV[9],v4);             /*  *TEMP*                  */
  ecl_bds_bind(cl_env_copy,VV[10],v5);            /*  *LCL*                   */
  (cl_env_copy->function=ecl_fdefinition(VV[22]))->cfun.entry(0) /*  OPEN-INLINE-BLOCK */;
  {
   cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(VV[23],env1);               /*  FRAME                   */
   T0 = cl_list(2, VV[26], ECL_CONS_CAR(CLV0));
   T1 = CONS(T0,ecl_cmp_symbol_value(cl_env_copy,VV[25]));
   ecl_bds_bind(cl_env_copy,VV[25],T1);           /*  *UNWIND-EXIT*           */
   (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(3, VV[28], VV[24], VV[29]) /*  WT-NL */;
   (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(6, ecl_cmp_symbol_value(cl_env_copy,VV[30]), VV[31], ECL_CONS_CAR(CLV0), VV[32], VV[24], VV[33]) /*  WT-NL */;
   {
    cl_object v6evaluated_args;
    {
     cl_object v7;
     {
      cl_object v8;
      v8 = ecl_make_cclosure_va((cl_objectfn)LC3875__lambda37,env1,Cblock,1);
      v7 = v8;
     }
     {
      cl_object v8;
      cl_object v9;
      cl_object v10;
      {
       cl_object v11;
       v11 = v3args;
       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;
L17:;
       if (!(ecl_endp(v10))){
        goto L19;
       }
       goto L18;
L19:;
       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 L17;
L18:;
       v6evaluated_args = ecl_cdr(v11);
       goto L8;
      }
     }
    }
L8:;
    T0 = (cl_env_copy->function=ecl_fdefinition(VV[55]))->cfun.entry(1, v1c1form) /*  C1FORM-PRIMARY-TYPE */;
    T1 = L3883call_local_stack_loc(v2fun, v6evaluated_args, T0);
    (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, T1) /*  UNWIND-EXIT */;
    ecl_bds_unwind1(cl_env_copy);
   }
  }
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[16]))->cfun.entry(0) /*  CLOSE-INLINE-BLOCKS */;
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
static cl_object L3876c2call_local_stack_va(cl_narg narg, cl_object v6c1form, cl_object v7fun, cl_object v8args, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[1]);
 {
  return L3876c2call_local_stack(v6c1form, v7fun, v8args);
 }
}
/* function definition for C2CALL-GLOBAL                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3877c2call_global(cl_object v1c1form, cl_object v2fname, cl_object v3args)
{
 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 v4fun;
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_cmp_symbol_value(cl_env_copy,VV[57]);
   v6 = ecl_fdefinition(VV[58]);
   v7 = ecl_fdefinition(VV[59]);
   {
    cl_object v8;
    v8 = si_make_seq_iterator(2, v5, ecl_make_int8_t(0));
L7:;
    if (v8!=ECL_NIL) {
     goto L9;
    }
    v4fun = ECL_NIL;
    goto L2;
L9:;
    {
     cl_object v9;
     v9 = si_seq_iterator_ref(v5, v8);
     T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v9) /*  FUN-NAME */;
     if (Null((cl_env_copy->function=ecl_fdefinition(VV[59]))->cfun.entry(2, v2fname, T0) /*  SAME-FNAME-P */)){
      goto L11;
     }
     v4fun = v9;
     goto L2;
    }
L11:;
    v8 = si_seq_iterator_next(v5, v8);
    goto L7;
   }
  }
L2:;
  if (Null(v4fun)){
   goto L16;
  }
  if (Null(L3881c2try_tail_recursive_call(v4fun, v3args))){
   goto L16;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L16:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[66]))->cfun.entry(1, v3args) /*  INLINE-ARGS */;
  T1 = (cl_env_copy->function=ecl_fdefinition(VV[55]))->cfun.entry(1, v1c1form) /*  C1FORM-PRIMARY-TYPE */;
  T2 = (cl_env_copy->function=ecl_fdefinition(VV[68]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[35])) /*  LOC-LISP-TYPE */;
  T3 = (cl_env_copy->function=ecl_fdefinition(VV[67]))->cfun.entry(2, T1, T2) /*  TYPE-AND */;
  T4 = L3885call_global_loc(v2fname, v4fun, T0, T3);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, T4) /*  UNWIND-EXIT */;
  return value0;
 }
}
static cl_object L3877c2call_global_va(cl_narg narg, cl_object v5c1form, cl_object v6fname, cl_object v7args, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[13]);
 {
  return L3877c2call_global(v5c1form, v6fname, v7args);
 }
}
/* function definition for C2CALL-LOCAL                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3878c2call_local(cl_object v1c1form, cl_object v2fun, cl_object v3args)
{
 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 (L3881c2try_tail_recursive_call(v2fun, v3args)!=ECL_NIL) {
  goto L2;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v2fun) /*  FUN-NAME */;
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[66]))->cfun.entry(1, v3args) /*  INLINE-ARGS */;
 T2 = (cl_env_copy->function=ecl_fdefinition(VV[55]))->cfun.entry(1, v1c1form) /*  C1FORM-PRIMARY-TYPE */;
 T3 = L3884call_loc(T0, v2fun, T1, T2);
 value0 = (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, T3) /*  UNWIND-EXIT */;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3878c2call_local_va(cl_narg narg, cl_object v4c1form, cl_object v5fun, cl_object v6args, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[12]);
 {
  return L3878c2call_local(v4c1form, v5fun, v6args);
 }
}
/* function definition for C2CALL-UNKNOWN                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3879c2call_unknown(cl_object v1c1form, cl_object v2form, 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 v4form_type;
  cl_object v5function_p;
  cl_object v6loc;
  cl_object v7args;
  v4form_type = (cl_env_copy->function=ecl_fdefinition(VV[55]))->cfun.entry(1, v2form) /*  C1FORM-PRIMARY-TYPE */;
  if (Null(cl_subtypep(3, v4form_type, ECL_SYM("FUNCTION",398), ecl_cmp_symbol_value(cl_env_copy,VV[72])))){
   goto L5;
  }
  v5function_p = (cl_env_copy->function=ecl_fdefinition(VV[73]))->cfun.entry(0) /*  POLICY-ASSUME-RIGHT-TYPE */;
  goto L3;
L5:;
  v5function_p = ECL_NIL;
  goto L3;
L3:;
  v6loc = (cl_env_copy->function=ecl_fdefinition(VV[34]))->cfun.entry(2, v2form, v3args) /*  EMIT-INLINE-FORM */;
  v7args = (cl_env_copy->function=ecl_fdefinition(VV[66]))->cfun.entry(1, v3args) /*  INLINE-ARGS */;
  T0 = L3887call_unknown_global_loc(v6loc, v7args, v5function_p);
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[43]))->cfun.entry(1, T0) /*  UNWIND-EXIT */;
  return value0;
 }
}
static cl_object L3879c2call_unknown_va(cl_narg narg, cl_object v8c1form, cl_object v9form, cl_object v10args, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[14]);
 {
  return L3879c2call_unknown(v8c1form, v9form, v10args);
 }
}
/* function definition for TAIL-RECURSION-POSSIBLE                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3880tail_recursion_possible()
{
 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 v1;
  v1 = ecl_cmp_symbol_value(cl_env_copy,VV[25]);
  goto L5;
L4:;
  {
   cl_object v2ue;
   v2ue = ecl_car(v1);
   if (!((v2ue)==(ecl_cmp_symbol_value(cl_env_copy,VV[77])))){
    goto L10;
   }
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L10:;
   if ((v2ue)==(VV[78])) {
    goto L14;
   }
   if (!((v2ue)==(VV[79]))){
    goto L12;
   }
   goto L13;
L14:;
L13:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L12:;
   {
    cl_object v3;
    value0 = ecl_make_bool(ECL_CONSP(v2ue));
    if (value0!=ECL_NIL) {
     goto L18;
    }
    value0 = (cl_env_copy->function=ecl_fdefinition(VV[80]))->cfun.entry(1, v2ue) /*  LABELP */;
    if (value0!=ECL_NIL) {
     goto L18;
    }
    v3 = ecl_make_bool((v2ue)==(VV[81]));
    goto L16;
L18:;
    v3 = value0;
    goto L16;
L16:;
    if (Null(v3)){
     goto L21;
    }
    goto L9;
L21:;
    (cl_env_copy->function=ecl_fdefinition(VV[82]))->cfun.entry(2, ECL_SYM("FORMAT-CONTROL",1272), VV[83]) /*  BABOON */;
   }
L9:;
  }
  v1 = ecl_cdr(v1);
L5:;
  if (Null(v1)){
   goto L25;
  }
  goto L4;
L25:;
  value0 = (cl_env_copy->function=ecl_fdefinition(VV[82]))->cfun.entry(2, ECL_SYM("FORMAT-CONTROL",1272), VV[84]) /*  BABOON */;
  return value0;
 }
}
static cl_object L3880tail_recursion_possible_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[76]);
 {
  return L3880tail_recursion_possible();
 }
}
/* function definition for C2TRY-TAIL-RECURSIVE-CALL                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3881c2try_tail_recursive_call(cl_object v1fun, cl_object v2args)
{
 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(ecl_cmp_symbol_value(cl_env_copy,VV[86]))){
  goto L2;
 }
 T0 = ecl_car(ecl_cmp_symbol_value(cl_env_copy,VV[86]));
 if (!((v1fun)==(T0))){
  goto L2;
 }
 if (!((ecl_cmp_symbol_value(cl_env_copy,VV[87]))==(VV[37]))){
  goto L2;
 }
 if (Null(L3880tail_recursion_possible())){
  goto L2;
 }
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v1fun) /*  FUN-NAME */;
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[88]))->cfun.entry(1, T0) /*  INLINE-POSSIBLE */)){
  goto L2;
 }
 {
  cl_fixnum v3;
  v3 = ecl_length(v2args);
  T0 = ecl_cdr(ecl_cmp_symbol_value(cl_env_copy,VV[86]));
  {
   cl_fixnum v4;
   v4 = ecl_length(T0);
   if (!((v3)==(v4))){
    goto L2;
   }
  }
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=ecl_fdefinition(VV[80]))->cfun.entry(1, ECL_NIL) /*  LABELP */;
  if (Null(v3)){
   goto L12;
  }
  T0 = ECL_NIL;
  goto L11;
L12:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[90]))->cfun.entry(1, ECL_NIL) /*  NEXT-LABEL */;
L11:;
  ecl_bds_bind(cl_env_copy,VV[87],T0);            /*  *EXIT*                  */
  T0 = cl_adjoin(2, ecl_cmp_symbol_value(cl_env_copy,VV[87]), ecl_cmp_symbol_value(cl_env_copy,VV[25]));
  ecl_bds_bind(cl_env_copy,VV[25],T0);            /*  *UNWIND-EXIT*           */
  ecl_bds_bind(cl_env_copy,VV[35],VV[91]);        /*  *DESTINATION*           */
  T0 = ecl_cdr(ecl_cmp_symbol_value(cl_env_copy,VV[86]));
  (cl_env_copy->function=ecl_fdefinition(VV[92]))->cfun.entry(3, ECL_NIL, T0, v2args) /*  C2PSETQ */;
  ecl_bds_unwind1(cl_env_copy);
  if (v3!=ECL_NIL) {
   ecl_bds_unwind1(cl_env_copy);
   ecl_bds_unwind1(cl_env_copy);
   goto L9;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[93]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[87])) /*  WT-LABEL */;
  ecl_bds_unwind1(cl_env_copy);
  ecl_bds_unwind1(cl_env_copy);
 }
L9:;
 (cl_env_copy->function=ecl_fdefinition(VV[94]))->cfun.entry(1, ecl_cmp_symbol_value(cl_env_copy,VV[77])) /*  UNWIND-JUMP */;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[58]))->cfun.entry(1, v1fun) /*  FUN-NAME */;
 (cl_env_copy->function=ecl_fdefinition(VV[95]))->cfun.entry(2, VV[96], T0) /*  CMPDEBUG */;
 value0 = ECL_T;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L3881c2try_tail_recursive_call_va(cl_narg narg, cl_object v3fun, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[64]);
 {
  return L3881c2try_tail_recursive_call(v3fun, v4args);
 }
}
/* function definition for CALL-GLOBAL-STACK-LOC                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3882call_global_stack_loc(cl_object v1fname, cl_object v2loc)
{
 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_list(3, VV[98], v2loc, v1fname);
 return value0;
}
static cl_object L3882call_global_stack_loc_va(cl_narg narg, cl_object v3fname, cl_object v4loc, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[44]);
 {
  return L3882call_global_stack_loc(v3fname, v4loc);
 }
}
/* function definition for CALL-LOCAL-STACK-LOC                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3883call_local_stack_loc(cl_object v1fun, cl_object v2args, cl_object v3type)
{
 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[101]))->cfun.entry(1, v2args) /*  COERCE-ARGS */;
 value0 = cl_list(4, VV[100], v1fun, T0, v3type);
 return value0;
}
static cl_object L3883call_local_stack_loc_va(cl_narg narg, cl_object v4fun, cl_object v5args, cl_object v6type, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[54]);
 {
  return L3883call_local_stack_loc(v4fun, v5args, v6type);
 }
}
/* function definition for CALL-LOC                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3884call_loc(cl_object v1fname, cl_object v2fun, cl_object v3args, cl_object v4type)
{
 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[101]))->cfun.entry(1, v3args) /*  COERCE-ARGS */;
 value0 = cl_list(4, VV[103], v2fun, T0, v4type);
 return value0;
}
static cl_object L3884call_loc_va(cl_narg narg, cl_object v5fname, cl_object v6fun, cl_object v7args, cl_object v8type, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[70]);
 {
  return L3884call_loc(v5fname, v6fun, v7args, v8type);
 }
}
/* function definition for CALL-GLOBAL-LOC                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3885call_global_loc(cl_object v1fname, cl_object v2fun, cl_object v3args, cl_object v4type)
{
 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 ((cl_env_copy->function=ecl_fdefinition(VV[88]))->cfun.entry(1, v1fname) /*  INLINE-POSSIBLE */!=ECL_NIL) {
  goto L2;
 }
 value0 = L3888call_unknown_global_fun(v1fname, v3args);
 return value0;
L2:;
 {
  cl_object v5inline_loc;
  v5inline_loc = (cl_env_copy->function=ecl_fdefinition(VV[106]))->cfun.entry(3, v1fname, v4type, v3args) /*  APPLY-INLINER */;
  if (Null(v5inline_loc)){
   goto L4;
  }
  value0 = v5inline_loc;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L4:;
 if (Null(v2fun)){
  goto L7;
 }
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[107]))->cfun.entry(0) /*  POLICY-USE-DIRECT-C-CALL */)){
  goto L7;
 }
 value0 = L3884call_loc(v1fname, v2fun, v3args, v4type);
 return value0;
L7:;
 if (ECL_SYMBOLP(v1fname)) {
  goto L10;
 }
 value0 = L3888call_unknown_global_fun(v1fname, v3args);
 return value0;
L10:;
 {
  cl_object v5;                                   /*  FOUND                   */
  cl_object v6;                                   /*  FD                      */
  cl_object v7;                                   /*  MINARG                  */
  cl_object v8;                                   /*  MAXARG                  */
  value0 = si_mangle_name(2, v1fname, ECL_T);
  {
   const int v9 = cl_env_copy->nvalues;
   v5 = value0;
   cl_object v10;
   v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
   v6 = v10;
   v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
   v7 = v10;
   v10 = (v9<=3)? ECL_NIL : cl_env_copy->values[3];
   v8 = v10;
  }
  if (Null(v5)){
   goto L12;
  }
  value0 = L3886call_exported_function_loc(v1fname, v3args, v6, v7, v8, ECL_T, v4type);
  return value0;
 }
L12:;
 if (Null((cl_env_copy->function=ecl_fdefinition(VV[107]))->cfun.entry(0) /*  POLICY-USE-DIRECT-C-CALL */)){
  goto L15;
 }
 {
  cl_object v5fd;
  v5fd = si_get_sysprop(v1fname, VV[109]);
  if (Null(v5fd)){
   goto L15;
  }
  {
   cl_object v6;                                  /*  MINARG                  */
   cl_object v7;                                  /*  MAXARG                  */
   cl_object v8;                                  /*  FOUND                   */
   value0 = (cl_env_copy->function=ecl_fdefinition(VV[110]))->cfun.entry(1, v1fname) /*  GET-PROCLAIMED-NARG */;
   {
    const int v9 = cl_env_copy->nvalues;
    v6 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v7 = v10;
    v10 = (v9<=2)? ECL_NIL : cl_env_copy->values[2];
    v8 = v10;
   }
   if (v8!=ECL_NIL) {
    goto L20;
   }
   if (v8!=ECL_NIL) {
    goto L20;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[111]))->cfun.entry(3, VV[112], v1fname, v5fd) /*  CMPERR */;
L20:;
   T0 = si_mangle_name(1, v1fname);
   value0 = L3886call_exported_function_loc(v1fname, v3args, v5fd, v6, v7, T0, v4type);
   return value0;
  }
 }
L15:;
 value0 = L3888call_unknown_global_fun(v1fname, v3args);
 return value0;
}
static cl_object L3885call_global_loc_va(cl_narg narg, cl_object v5fname, cl_object v6fun, cl_object v7args, cl_object v8type, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[65]);
 {
  return L3885call_global_loc(v5fname, v6fun, v7args, v8type);
 }
}
/* function definition for CALL-EXPORTED-FUNCTION-LOC                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3886call_exported_function_loc(cl_object v1fname, cl_object v2args, cl_object v3fun_c_name, cl_object v4minarg, cl_object v5maxarg, cl_object v6in_core, cl_object v7type)
{
 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 (v6in_core!=ECL_NIL) {
  goto L2;
 }
 {
  cl_object v8;                                   /*  DECLARED                */
  value0 = cl_gethash(2, v3fun_c_name, ecl_cmp_symbol_value(cl_env_copy,VV[114]));
  {
   v8 = cl_env_copy->values[1];
  }
  if (v8!=ECL_NIL) {
   goto L2;
  }
  if (!(ecl_number_equalp(v5maxarg,v4minarg))){
   goto L7;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[115]))->cfun.entry(3, VV[116], v3fun_c_name, VV[117]) /*  WT-NL-H */;
  {
   cl_object v9i;
   v9i = ecl_make_int8_t(0);
   goto L13;
L12:;
   if (!(ecl_greater(v9i,ecl_make_int8_t(0)))){
    goto L15;
   }
   (cl_env_copy->function=ecl_fdefinition(VV[118]))->cfun.entry(1, VV[48]) /*  WT-H1 */;
L15:;
   (cl_env_copy->function=ecl_fdefinition(VV[118]))->cfun.entry(1, VV[119]) /*  WT-H1 */;
   v9i = ecl_one_plus(v9i);
L13:;
   if (!(ecl_lower(v9i,v5maxarg))){
    goto L20;
   }
   goto L12;
L20:;
  }
  (cl_env_copy->function=ecl_fdefinition(VV[118]))->cfun.entry(1, VV[40]) /*  WT-H1 */;
  goto L6;
L7:;
  (cl_env_copy->function=ecl_fdefinition(VV[115]))->cfun.entry(3, VV[116], v3fun_c_name, VV[120]) /*  WT-NL-H */;
  {
   cl_object v9;
   v9 = ((ecl_float_nan_p(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("C-ARGUMENTS-LIMIT",1056))) || ecl_lowereq(v4minarg,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("C-ARGUMENTS-LIMIT",1056))))?v4minarg:ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("C-ARGUMENTS-LIMIT",1056)));
   {
    cl_object v10i;
    v10i = ecl_make_int8_t(0);
    goto L27;
L26:;
    (cl_env_copy->function=ecl_fdefinition(VV[118]))->cfun.entry(1, VV[121]) /*  WT-H1 */;
    v10i = ecl_one_plus(v10i);
L27:;
    if (!(ecl_lower(v10i,v9))){
     goto L32;
    }
    goto L26;
L32:;
   }
  }
  (cl_env_copy->function=ecl_fdefinition(VV[118]))->cfun.entry(1, VV[122]) /*  WT-H1 */;
L6:;
  si_hash_set(v3fun_c_name, ecl_cmp_symbol_value(cl_env_copy,VV[114]), ecl_make_int8_t(1));
 }
L2:;
 {
  cl_object v8fun;
  v8fun = (cl_env_copy->function=ecl_fdefinition(VV[123]))->cfun.entry(12, ECL_SYM("NAME",1309), v1fname, VV[3], ECL_T, VV[124], v3fun_c_name, VV[125], ECL_NIL, VV[126], v4minarg, VV[127], v5maxarg) /*  MAKE-FUN */;
  value0 = L3884call_loc(v1fname, v8fun, v2args, v7type);
  return value0;
 }
}
static cl_object L3886call_exported_function_loc_va(cl_narg narg, cl_object v9fname, cl_object v10args, cl_object v11fun_c_name, cl_object v12minarg, cl_object v13maxarg, cl_object v14in_core, cl_object v15type, ...)
{
 if (ecl_unlikely(narg!=7)) FEwrong_num_arguments(VV[108]);
 {
  return L3886call_exported_function_loc(v9fname, v10args, v11fun_c_name, v12minarg, v13maxarg, v14in_core, v15type);
 }
}
/* function definition for CALL-UNKNOWN-GLOBAL-LOC                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3887call_unknown_global_loc(cl_object v1loc, cl_object v2args, cl_object v3function_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:;
 T0 = (cl_env_copy->function=ecl_fdefinition(VV[101]))->cfun.entry(1, v2args) /*  COERCE-ARGS */;
 value0 = cl_list(5, VV[129], v1loc, T0, ECL_NIL, v3function_p);
 return value0;
}
static cl_object L3887call_unknown_global_loc_va(cl_narg narg, cl_object v4loc, cl_object v5args, cl_object v6function_p, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[74]);
 {
  return L3887call_unknown_global_loc(v4loc, v5args, v6function_p);
 }
}
/* function definition for CALL-UNKNOWN-GLOBAL-FUN                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L3888call_unknown_global_fun(cl_object v1fname, 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:;
 T0 = cl_list(2, ECL_SYM("FDEFINITION",351), v1fname);
 T1 = (cl_env_copy->function=ecl_fdefinition(VV[101]))->cfun.entry(1, v2args) /*  COERCE-ARGS */;
 value0 = cl_list(5, VV[129], T0, T1, v1fname, ECL_T);
 return value0;
}
static cl_object L3888call_unknown_global_fun_va(cl_narg narg, cl_object v3fname, cl_object v4args, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[105]);
 {
  return L3888call_unknown_global_fun(v3fname, v4args);
 }
}
/* closure LAMBDA37                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC3875__lambda37(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;                                     /*  FRAME                   */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[46]);
 {
L1:;
  T0 = (cl_env_copy->function=ecl_fdefinition(VV[47]))->cfun.entry(1, ECL_T) /*  MAKE-TEMP-VAR */;
  ecl_bds_bind(cl_env_copy,VV[35],T0);            /*  *DESTINATION*           */
  (cl_env_copy->function=ecl_fdefinition(VV[38]))->cfun.entry(1, v1arg) /*  C2EXPR* */;
  (cl_env_copy->function=ecl_fdefinition(VV[27]))->cfun.entry(5, VV[41], ECL_CONS_CAR(CLV0), VV[48], ecl_cmp_symbol_value(cl_env_copy,VV[35]), VV[40]) /*  WT-NL */;
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[35]);
  cl_env_copy->nvalues = 1;
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
#include "cmp/cmppass2-call.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecle1cTlCFf3SBq9_Qpb0M881(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;CMPBACKEND-CXX;CMPPASS2-CALL.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecle1cTlCFf3SBq9_Qpb0M881@";
 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[132]);                         /*  C2FCALL                 */
  ecl_cmp_defun(VV[133]);                         /*  C2MCALL                 */
  ecl_cmp_defun(VV[134]);                         /*  C2CALL-GLOBAL-STACK     */
  ecl_cmp_defun(VV[135]);                         /*  C2CALL-LOCAL-STACK      */
  ecl_cmp_defun(VV[136]);                         /*  C2CALL-GLOBAL           */
  ecl_cmp_defun(VV[137]);                         /*  C2CALL-LOCAL            */
  ecl_cmp_defun(VV[138]);                         /*  C2CALL-UNKNOWN          */
  ecl_cmp_defun(VV[139]);                         /*  TAIL-RECURSION-POSSIBLE */
  ecl_cmp_defun(VV[140]);                         /*  C2TRY-TAIL-RECURSIVE-CALL */
  ecl_cmp_defun(VV[141]);                         /*  CALL-GLOBAL-STACK-LOC   */
  ecl_cmp_defun(VV[142]);                         /*  CALL-LOCAL-STACK-LOC    */
  ecl_cmp_defun(VV[143]);                         /*  CALL-LOC                */
  ecl_cmp_defun(VV[144]);                         /*  CALL-GLOBAL-LOC         */
  ecl_cmp_defun(VV[145]);                         /*  CALL-EXPORTED-FUNCTION-LOC */
  ecl_cmp_defun(VV[146]);                         /*  CALL-UNKNOWN-GLOBAL-LOC */
  ecl_cmp_defun(VV[147]);                         /*  CALL-UNKNOWN-GLOBAL-FUN */
}
