text: /* Generated by Eclipse Common Lisp 1.1-HOSTED for howard on circe.
     Monday the sixth of April, 1998, 8:56:58 am CDT. */
  #include <eclipse.h>
  
  clObject cl1PLUS_FUNC(clProto), cl1MINUS_FUNC(clProto),
    clAcosComplex(clProto), clAcos1DoubleFloat __P((clObject)),
    clAcos1Integer __P((clObject)), clAcos1Ratio __P((clObject)),
    clAcos1SingleFloat __P((clObject)), clAcoshComplex(clProto),
    clAcosh1DoubleFloat __P((clObject)), clAcosh1Integer __P((clObject)),
    clAcosh1Ratio __P((clObject)), clAcosh1SingleFloat __P((clObject)),
    clApply(clProto), clAsinComplex(clProto),
    clAsin1DoubleFloat __P((clObject)), clAsin1Integer __P((clObject)),
    clAsin1Ratio __P((clObject)), clAsin1SingleFloat __P((clObject)),
    clAsinhComplex(clProto), clAsinhDoubleFloat __P((clObject)),
    clAsinhInteger __P((clObject)), clAsinhRatio __P((clObject)),
    clAsinhSingleFloat __P((clObject)), clAtan(clProto),
    clAtan1Complex(clProto), clAtan1DoubleFloat __P((clObject)),
    clAtan1Integer __P((clObject)), clAtan1Ratio __P((clObject)),
    clAtan1SingleFloat __P((clObject)),
    clAtan2DoubleFloatDoubleFloat __P((clObject, clObject)),
    clAtan2DoubleFloatInteger __P((clObject, clObject)),
    clAtan2DoubleFloatRatio __P((clObject, clObject)),
    clAtan2DoubleFloatSingleFloat __P((clObject, clObject)),
    clAtan2IntegerDoubleFloat __P((clObject, clObject)),
    clAtan2IntegerInteger __P((clObject, clObject)),
    clAtan2IntegerRatio __P((clObject, clObject)),
    clAtan2IntegerSingleFloat __P((clObject, clObject)),
    clAtan2RatioDoubleFloat __P((clObject, clObject)),
    clAtan2RatioInteger __P((clObject, clObject)),
    clAtan2RatioRatio __P((clObject, clObject)),
    clAtan2RatioSingleFloat __P((clObject, clObject)),
    clAtan2SingleFloatDoubleFloat __P((clObject, clObject)),
    clAtan2SingleFloatInteger __P((clObject, clObject)),
    clAtan2SingleFloatRatio __P((clObject, clObject)),
    clAtan2SingleFloatSingleFloat __P((clObject, clObject)),
    clAtanhComplex(clProto), clAtanh1DoubleFloat __P((clObject)),
    clAtanh1Integer __P((clObject)), clAtanh1Ratio __P((clObject)),
    clAtanh1SingleFloat __P((clObject)),
    clCanonicalizeSpecializer(clProto), clCar(clProto), clCdr(clProto),
    clCharpSimpleBaseString __P((clCharp)), clComplex(clProto),
    clCons(clProto), clCosComplex(clProto),
    clCosDoubleFloat __P((clObject)), clCosInteger __P((clObject)),
    clCosRatio __P((clObject)), clCosSingleFloat __P((clObject)),
    clCoshComplex(clProto), clCoshDoubleFloat __P((clObject)),
    clCoshInteger __P((clObject)), clCoshRatio __P((clObject)),
    clCoshSingleFloat __P((clObject)), clDoubleDoubleFloat __P((double)),
    clDoubleSingleFloat __P((double)), clEnsureGenericFunction(clProto),
    clEnsureMethod(clProto), clExtraArgs(clProto), clFindClass(clProto),
    clISTAR_FUNC(clProto), clList(clProto), clLog(clProto),
    clMakeComplex __P((clObject, clObject)), clMakeKeyword(clProto),
    clMinusp(clProto), clMissingArgs(clProto), clNot(clProto),
    clNull(clProto), clRest(clProto), clSinComplex(clProto),
    clSinDoubleFloat __P((clObject)), clSinInteger __P((clObject)),
    clSinRatio __P((clObject)), clSinSingleFloat __P((clObject)),
    clSinhComplex(clProto), clSinhDoubleFloat __P((clObject)),
    clSinhInteger __P((clObject)), clSinhRatio __P((clObject)),
    clSinhSingleFloat __P((clObject)), clTanComplex(clProto),
    clTanDoubleFloat __P((clObject)), clTanInteger __P((clObject)),
    clTanRatio __P((clObject)), clTanSingleFloat __P((clObject)),
    clTanhComplex(clProto), clTanhDoubleFloat __P((clObject)),
    clTanhInteger __P((clObject)), clTanhRatio __P((clObject)),
    clTanhSingleFloat __P((clObject)), clZerop(clProto), clZroot(clProto);
  
  extern clObject clDOUBLE_FLOAT, clINLINE, clINTEGER, clNUMBER, clRATIO,
    clREAL, clSINGLE_FLOAT, clABS, clACOS, clACOS_COMPLEX, clACOSH,
    clACOSH_COMPLEX, clADD, clASIN, clASIN_COMPLEX, clASINH,
    clASINH_COMPLEX, clASINH_DOUBLE_FLOAT, clASINH_INTEGER,
    clASINH_RATIO, clASINH_SINGLE_FLOAT, clATAN, clATAN1,
    clATAN1_COMPLEX, clATAN1_DOUBLE_FLOAT, clATAN1_INTEGER,
    clATAN1_RATIO, clATAN1_SINGLE_FLOAT, clATAN2,
    clATAN2_DOUBLE_FLOAT_DOUBLE_FLOAT, clATAN2_DOUBLE_FLOAT_INTEGER,
    clATAN2_DOUBLE_FLOAT_RATIO, clATAN2_DOUBLE_FLOAT_SINGLE_FLOAT,
    clATAN2_INTEGER_DOUBLE_FLOAT, clATAN2_INTEGER_INTEGER,
    clATAN2_INTEGER_RATIO, clATAN2_INTEGER_SINGLE_FLOAT,
    clATAN2_RATIO_DOUBLE_FLOAT, clATAN2_RATIO_INTEGER,
    clATAN2_RATIO_RATIO, clATAN2_RATIO_SINGLE_FLOAT,
    clATAN2_SINGLE_FLOAT_DOUBLE_FLOAT, clATAN2_SINGLE_FLOAT_INTEGER,
    clATAN2_SINGLE_FLOAT_RATIO, clATAN2_SINGLE_FLOAT_SINGLE_FLOAT,
    clATANH, clATANH_COMPLEX, clCIS, clCLASS_PROTOTYPE, clCOMPLEX, clCOS,
    clCOS_COMPLEX, clCOS_DOUBLE_FLOAT, clCOS_INTEGER, clCOS_RATIO,
    clCOS_SINGLE_FLOAT, clCOSH, clCOSH_COMPLEX, clCOSH_DOUBLE_FLOAT,
    clCOSH_INTEGER, clCOSH_RATIO, clCOSH_SINGLE_FLOAT, clDIV, clEXP,
    clGE, clIstar, clIMAGPART, clLE, clMETHOD_FUNCTION, clMULT,
    clNO_NEXT_METHOD, clPHASE, clREALPART, clSIGNUM, clSIN,
    clSIN_COMPLEX, clSIN_DOUBLE_FLOAT, clSIN_INTEGER, clSIN_RATIO,
    clSIN_SINGLE_FLOAT, clSINH, clSINH_COMPLEX, clSINH_DOUBLE_FLOAT,
    clSINH_INTEGER, clSINH_RATIO, clSINH_SINGLE_FLOAT, clSQRT,
    clSTANDARD_METHOD, clSUBT, clTAN, clTAN_COMPLEX, clTAN_DOUBLE_FLOAT,
    clTAN_INTEGER, clTAN_RATIO, clTAN_SINGLE_FLOAT, clTANH,
    clTANH_COMPLEX, clTANH_DOUBLE_FLOAT, clTANH_INTEGER, clTANH_RATIO,
    clTANH_SINGLE_FLOAT, clX, clY, clZROOT;
  
  static clObject CONS_0, CONS_1, CONS_10, CONS_100, CONS_101, CONS_102,
    CONS_103, CONS_104, CONS_105, CONS_106, CONS_107, CONS_108, CONS_109,
    CONS_11, CONS_110, CONS_111, CONS_112, CONS_113, CONS_114, CONS_115,
    CONS_116, CONS_117, CONS_118, CONS_119, CONS_12, CONS_120, CONS_121,
    CONS_122, CONS_123, CONS_124, CONS_125, CONS_126, CONS_127, CONS_128,
    CONS_129, CONS_13, CONS_130, CONS_131, CONS_132, CONS_133, CONS_134,
    CONS_135, CONS_136, CONS_137, CONS_138, CONS_139, CONS_14, CONS_140,
    CONS_141, CONS_142, CONS_143, CONS_144, CONS_145, CONS_146, CONS_147,
    CONS_148, CONS_15, CONS_16, CONS_17, CONS_18, CONS_19, CONS_2,
    CONS_20, CONS_21, CONS_22, CONS_23, CONS_24, CONS_25, CONS_26,
    CONS_27, CONS_28, CONS_29, CONS_3, CONS_30, CONS_31, CONS_32,
    CONS_33, CONS_34, CONS_35, CONS_36, CONS_37, CONS_38, CONS_39,
    CONS_4, CONS_40, CONS_41, CONS_42, CONS_43, CONS_44, CONS_45,
    CONS_46, CONS_47, CONS_48, CONS_49, CONS_5, CONS_50, CONS_51,
    CONS_52, CONS_53, CONS_54, CONS_55, CONS_56, CONS_57, CONS_58,
    CONS_59, CONS_6, CONS_60, CONS_61, CONS_62, CONS_63, CONS_64,
    CONS_65, CONS_66, CONS_67, CONS_68, CONS_69, CONS_7, CONS_70,
    CONS_71, CONS_72, CONS_73, CONS_74, CONS_75, CONS_76, CONS_77,
    CONS_78, CONS_79, CONS_8, CONS_80, CONS_81, CONS_82, CONS_83,
    CONS_84, CONS_85, CONS_86, CONS_87, CONS_88, CONS_89, CONS_9,
    CONS_90, CONS_91, CONS_92, CONS_93, CONS_94, CONS_95, CONS_96,
    CONS_97, CONS_98, CONS_99, D_minus1_0d0, D_0_0d0, D_1_0d0,
    D_3_141592653589793d0, F_minus1_0, F_0_0, F_1_0, F_3_1415927,
    I_minus1, I_0, I_1, I_2, keyDECLARATIONS, keyDOCUMENTATION,
    keyFUNCTION, keyLAMBDA_LIST, keyQUALIFIERS, keySPECIALIZERS,
    STR_DECLARATIONS__4, STR_DOCUMENTATION__5, STR_FUNCTION__3,
    STR_LAMBDA_LIST__1, STR_QUALIFIERS__0, STR_SPECIALIZERS__2, X_0plus2I;
  
  clObject clAbs_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3624 = clMakeBinding(),
    *L_methods3625 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3624,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3625,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3627, x;
      clSetq(L_form3627, *L_args3624);
      if (clTrue(L_form3627))
        { clObject L_top3628;
          clSetq(L_top3628, clCar(L_form3627, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3627);
            clSetq(L_form3627, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3628); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3627))
        { clObject L_0;
          clSetq(L_0, L_form3627);
          clExtraArgs(L_0, clEOA); }
      { clObject r, i;
        clSetq(r,
               clFuncallFunction(clSymbolFunctionValue(clREALPART),
                                 x,
                                 clEOA));
        clSetq(i,
               clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                                 x,
                                 clEOA));
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1,
                   clFuncallFunction(clSymbolFunctionValue(clMULT),
                                     r,
                                     r,
                                     clEOA));
            clSetq(L_0,
                   clFuncallFunction(clSymbolFunctionValue(clADD),
                                     L_0__R1,
                                     clFuncallFunction(clSymbolFunctionValue(clMULT),
                                                       i,
                                                       i,
                                                       clEOA),
                                     clEOA)); }
          return(clFuncallFunction(clSymbolFunctionValue(clSQRT),
                                   L_0,
                                   clEOA)); } } } }
  
  clObject clPhase_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3630 = clMakeBinding(),
    *L_methods3631 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3630,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3631,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3633, number;
      clSetq(L_form3633, *L_args3630);
      if (clTrue(L_form3633))
        { clObject L_top3634;
          clSetq(L_top3634, clCar(L_form3633, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3633);
            clSetq(L_form3633, clCdr(L_0, clEOA)); }
          clSetq(number, L_top3634); }
      else clSetq(number, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3633))
        { clObject L_0;
          clSetq(L_0, L_form3633);
          clExtraArgs(L_0, clEOA); }
      { clObject L_0;
        clSetq(L_0,
               clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                                 number,
                                 clEOA));
        return(clAtan(L_0,
                      clFuncallFunction(clSymbolFunctionValue(clREALPART),
                                        number,
                                        clEOA),
                      clEOA)); } } }
  
  clObject clPhase_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3635 = clMakeBinding(),
    *L_methods3636 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3635,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3636,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3638, number;
      clSetq(L_form3638, *L_args3635);
      if (clTrue(L_form3638))
        { clObject L_top3639;
          clSetq(L_top3639, clCar(L_form3638, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3638);
            clSetq(L_form3638, clCdr(L_0, clEOA)); }
          clSetq(number, L_top3639); }
      else clSetq(number, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3638))
        { clObject L_0;
          clSetq(L_0, L_form3638);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clMinusp(number, clEOA)))
        return(clValues1(D_3_141592653589793d0));
      else return(clValues1(D_0_0d0)); } }
  
  clObject clPhase_clREAL clVdecl(_ap)
  { clObject *L_args3640 = clMakeBinding(),
    *L_methods3641 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3640,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3641,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3643, number;
      clSetq(L_form3643, *L_args3640);
      if (clTrue(L_form3643))
        { clObject L_top3644;
          clSetq(L_top3644, clCar(L_form3643, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3643);
            clSetq(L_form3643, clCdr(L_0, clEOA)); }
          clSetq(number, L_top3644); }
      else clSetq(number, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3643))
        { clObject L_0;
          clSetq(L_0, L_form3643);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clMinusp(number, clEOA)))
        return(clValues1(F_3_1415927));
      else return(clValues1(F_0_0)); } }
  
  clObject clSignum_clINTEGER clVdecl(_ap)
  { clObject *L_args3650 = clMakeBinding(),
    *L_methods3651 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3650,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3651,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3653, x;
      clSetq(L_form3653, *L_args3650);
      if (clTrue(L_form3653))
        { clObject L_top3654;
          clSetq(L_top3654, clCar(L_form3653, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3653);
            clSetq(L_form3653, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3654); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3653))
        { clObject L_0;
          clSetq(L_0, L_form3653);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clZerop(x, clEOA)))
        return(clValues1(x));
      else if (clTrue(clMinusp(x, clEOA)))
        return(clValues1(I_minus1));
      else return(clValues1(I_1)); } }
  
  clObject clSignum_clRATIO clVdecl(_ap)
  { clObject *L_args3660 = clMakeBinding(),
    *L_methods3661 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3660,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3661,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3663, x;
      clSetq(L_form3663, *L_args3660);
      if (clTrue(L_form3663))
        { clObject L_top3664;
          clSetq(L_top3664, clCar(L_form3663, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3663);
            clSetq(L_form3663, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3664); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3663))
        { clObject L_0;
          clSetq(L_0, L_form3663);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clZerop(x, clEOA)))
        return(clValues1(x));
      else if (clTrue(clMinusp(x, clEOA)))
        return(clValues1(I_minus1));
      else return(clValues1(I_1)); } }
  
  clObject clSignum_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3670 = clMakeBinding(),
    *L_methods3671 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3670,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3671,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3673, x;
      clSetq(L_form3673, *L_args3670);
      if (clTrue(L_form3673))
        { clObject L_top3674;
          clSetq(L_top3674, clCar(L_form3673, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3673);
            clSetq(L_form3673, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3674); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3673))
        { clObject L_0;
          clSetq(L_0, L_form3673);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clZerop(x, clEOA)))
        return(clValues1(x));
      else if (clTrue(clMinusp(x, clEOA)))
        return(clValues1(F_minus1_0));
      else return(clValues1(F_1_0)); } }
  
  clObject clSignum_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3680 = clMakeBinding(),
    *L_methods3681 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3680,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3681,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3683, x;
      clSetq(L_form3683, *L_args3680);
      if (clTrue(L_form3683))
        { clObject L_top3684;
          clSetq(L_top3684, clCar(L_form3683, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3683);
            clSetq(L_form3683, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3684); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3683))
        { clObject L_0;
          clSetq(L_0, L_form3683);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clZerop(x, clEOA)))
        return(clValues1(x));
      else if (clTrue(clMinusp(x, clEOA)))
        return(clValues1(D_minus1_0d0));
      else return(clValues1(D_1_0d0)); } }
  
  clObject clSignum_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3685 = clMakeBinding(),
    *L_methods3686 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3685,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3686,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3688, x;
      clSetq(L_form3688, *L_args3685);
      if (clTrue(L_form3688))
        { clObject L_top3689;
          clSetq(L_top3689, clCar(L_form3688, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3688);
            clSetq(L_form3688, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3689); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3688))
        { clObject L_0;
          clSetq(L_0, L_form3688);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clZerop(x, clEOA)))
        return(clValues1(x));
      else
        return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                                 x,
                                 clFuncallFunction(clSymbolFunctionValue(clABS),
                                                   x,
                                                   clEOA),
                                 clEOA)); } }
  
  clObject clCis clVdecl(_ap)
  { clObject radians;
    { clBeginParse(_ap);
      clSetq(radians,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0,
             clFuncallFunction(clSymbolFunctionValue(clCOS),
                               radians,
                               clEOA));
      return(clComplex(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clSIN),
                                         radians,
                                         clEOA),
                       clEOA)); } }
  
  clObject clSin_clINTEGER clVdecl(_ap)
  { clObject *L_args3693 = clMakeBinding(),
    *L_methods3694 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3693,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3694,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3696, CL_x;
      clSetq(L_form3696, *L_args3693);
      if (clTrue(L_form3696))
        { clObject L_top3697;
          clSetq(L_top3697, clCar(L_form3696, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3696);
            clSetq(L_form3696, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3697); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3696))
        { clObject L_0;
          clSetq(L_0, L_form3696);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinInteger(CL_x))); } }
  
  clObject clSin_clRATIO clVdecl(_ap)
  { clObject *L_args3698 = clMakeBinding(),
    *L_methods3699 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3698,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3699,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3701, CL_x;
      clSetq(L_form3701, *L_args3698);
      if (clTrue(L_form3701))
        { clObject L_top3702;
          clSetq(L_top3702, clCar(L_form3701, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3701);
            clSetq(L_form3701, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3702); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3701))
        { clObject L_0;
          clSetq(L_0, L_form3701);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinRatio(CL_x))); } }
  
  clObject clSin_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3703 = clMakeBinding(),
    *L_methods3704 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3703,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3704,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3706, CL_x;
      clSetq(L_form3706, *L_args3703);
      if (clTrue(L_form3706))
        { clObject L_top3707;
          clSetq(L_top3707, clCar(L_form3706, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3706);
            clSetq(L_form3706, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3707); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3706))
        { clObject L_0;
          clSetq(L_0, L_form3706);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinSingleFloat(CL_x))); } }
  
  clObject clSin_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3708 = clMakeBinding(),
    *L_methods3709 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3708,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3709,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3711, CL_x;
      clSetq(L_form3711, *L_args3708);
      if (clTrue(L_form3711))
        { clObject L_top3712;
          clSetq(L_top3712, clCar(L_form3711, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3711);
            clSetq(L_form3711, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3712); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3711))
        { clObject L_0;
          clSetq(L_0, L_form3711);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinDoubleFloat(CL_x))); } }
  
  clObject clSin_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3713 = clMakeBinding(),
    *L_methods3714 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3713,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3714,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3716, x;
      clSetq(L_form3716, *L_args3713);
      if (clTrue(L_form3716))
        { clObject L_top3717;
          clSetq(L_top3717, clCar(L_form3716, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3716);
            clSetq(L_form3716, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3717); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3716))
        { clObject L_0;
          clSetq(L_0, L_form3716);
          clExtraArgs(L_0, clEOA); }
      return(clSinComplex(x, clEOA)); } }
  
  clObject clCos_clINTEGER clVdecl(_ap)
  { clObject *L_args3721 = clMakeBinding(),
    *L_methods3722 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3721,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3722,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3724, CL_x;
      clSetq(L_form3724, *L_args3721);
      if (clTrue(L_form3724))
        { clObject L_top3725;
          clSetq(L_top3725, clCar(L_form3724, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3724);
            clSetq(L_form3724, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3725); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3724))
        { clObject L_0;
          clSetq(L_0, L_form3724);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCosInteger(CL_x))); } }
  
  clObject clCos_clRATIO clVdecl(_ap)
  { clObject *L_args3726 = clMakeBinding(),
    *L_methods3727 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3726,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3727,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3729, CL_x;
      clSetq(L_form3729, *L_args3726);
      if (clTrue(L_form3729))
        { clObject L_top3730;
          clSetq(L_top3730, clCar(L_form3729, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3729);
            clSetq(L_form3729, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3730); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3729))
        { clObject L_0;
          clSetq(L_0, L_form3729);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCosRatio(CL_x))); } }
  
  clObject clCos_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3731 = clMakeBinding(),
    *L_methods3732 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3731,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3732,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3734, CL_x;
      clSetq(L_form3734, *L_args3731);
      if (clTrue(L_form3734))
        { clObject L_top3735;
          clSetq(L_top3735, clCar(L_form3734, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3734);
            clSetq(L_form3734, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3735); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3734))
        { clObject L_0;
          clSetq(L_0, L_form3734);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCosSingleFloat(CL_x))); } }
  
  clObject clCos_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3736 = clMakeBinding(),
    *L_methods3737 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3736,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3737,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3739, CL_x;
      clSetq(L_form3739, *L_args3736);
      if (clTrue(L_form3739))
        { clObject L_top3740;
          clSetq(L_top3740, clCar(L_form3739, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3739);
            clSetq(L_form3739, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3740); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3739))
        { clObject L_0;
          clSetq(L_0, L_form3739);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCosDoubleFloat(CL_x))); } }
  
  clObject clCos_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3741 = clMakeBinding(),
    *L_methods3742 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3741,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3742,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3744, x;
      clSetq(L_form3744, *L_args3741);
      if (clTrue(L_form3744))
        { clObject L_top3745;
          clSetq(L_top3745, clCar(L_form3744, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3744);
            clSetq(L_form3744, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3745); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3744))
        { clObject L_0;
          clSetq(L_0, L_form3744);
          clExtraArgs(L_0, clEOA); }
      return(clCosComplex(x, clEOA)); } }
  
  clObject clTan_clINTEGER clVdecl(_ap)
  { clObject *L_args3749 = clMakeBinding(),
    *L_methods3750 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3749,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3750,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3752, CL_x;
      clSetq(L_form3752, *L_args3749);
      if (clTrue(L_form3752))
        { clObject L_top3753;
          clSetq(L_top3753, clCar(L_form3752, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3752);
            clSetq(L_form3752, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3753); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3752))
        { clObject L_0;
          clSetq(L_0, L_form3752);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanInteger(CL_x))); } }
  
  clObject clTan_clRATIO clVdecl(_ap)
  { clObject *L_args3754 = clMakeBinding(),
    *L_methods3755 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3754,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3755,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3757, CL_x;
      clSetq(L_form3757, *L_args3754);
      if (clTrue(L_form3757))
        { clObject L_top3758;
          clSetq(L_top3758, clCar(L_form3757, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3757);
            clSetq(L_form3757, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3758); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3757))
        { clObject L_0;
          clSetq(L_0, L_form3757);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanRatio(CL_x))); } }
  
  clObject clTan_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3759 = clMakeBinding(),
    *L_methods3760 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3759,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3760,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3762, CL_x;
      clSetq(L_form3762, *L_args3759);
      if (clTrue(L_form3762))
        { clObject L_top3763;
          clSetq(L_top3763, clCar(L_form3762, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3762);
            clSetq(L_form3762, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3763); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3762))
        { clObject L_0;
          clSetq(L_0, L_form3762);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanSingleFloat(CL_x))); } }
  
  clObject clTan_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3764 = clMakeBinding(),
    *L_methods3765 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3764,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3765,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3767, CL_x;
      clSetq(L_form3767, *L_args3764);
      if (clTrue(L_form3767))
        { clObject L_top3768;
          clSetq(L_top3768, clCar(L_form3767, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3767);
            clSetq(L_form3767, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3768); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3767))
        { clObject L_0;
          clSetq(L_0, L_form3767);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanDoubleFloat(CL_x))); } }
  
  clObject clTan_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3769 = clMakeBinding(),
    *L_methods3770 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3769,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3770,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3772, x;
      clSetq(L_form3772, *L_args3769);
      if (clTrue(L_form3772))
        { clObject L_top3773;
          clSetq(L_top3773, clCar(L_form3772, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3772);
            clSetq(L_form3772, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3773); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3772))
        { clObject L_0;
          clSetq(L_0, L_form3772);
          clExtraArgs(L_0, clEOA); }
      return(clTanComplex(x, clEOA)); } }
  
  clObject clSinh_clINTEGER clVdecl(_ap)
  { clObject *L_args3777 = clMakeBinding(),
    *L_methods3778 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3777,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3778,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3780, CL_x;
      clSetq(L_form3780, *L_args3777);
      if (clTrue(L_form3780))
        { clObject L_top3781;
          clSetq(L_top3781, clCar(L_form3780, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3780);
            clSetq(L_form3780, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3781); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3780))
        { clObject L_0;
          clSetq(L_0, L_form3780);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinhInteger(CL_x))); } }
  
  clObject clSinh_clRATIO clVdecl(_ap)
  { clObject *L_args3782 = clMakeBinding(),
    *L_methods3783 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3782,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3783,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3785, CL_x;
      clSetq(L_form3785, *L_args3782);
      if (clTrue(L_form3785))
        { clObject L_top3786;
          clSetq(L_top3786, clCar(L_form3785, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3785);
            clSetq(L_form3785, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3786); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3785))
        { clObject L_0;
          clSetq(L_0, L_form3785);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinhRatio(CL_x))); } }
  
  clObject clSinh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3787 = clMakeBinding(),
    *L_methods3788 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3787,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3788,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3790, CL_x;
      clSetq(L_form3790, *L_args3787);
      if (clTrue(L_form3790))
        { clObject L_top3791;
          clSetq(L_top3791, clCar(L_form3790, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3790);
            clSetq(L_form3790, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3791); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3790))
        { clObject L_0;
          clSetq(L_0, L_form3790);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinhSingleFloat(CL_x))); } }
  
  clObject clSinh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3792 = clMakeBinding(),
    *L_methods3793 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3792,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3793,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3795, CL_x;
      clSetq(L_form3795, *L_args3792);
      if (clTrue(L_form3795))
        { clObject L_top3796;
          clSetq(L_top3796, clCar(L_form3795, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3795);
            clSetq(L_form3795, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3796); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3795))
        { clObject L_0;
          clSetq(L_0, L_form3795);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clSinhDoubleFloat(CL_x))); } }
  
  clObject clSinh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3797 = clMakeBinding(),
    *L_methods3798 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3797,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3798,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3800, x;
      clSetq(L_form3800, *L_args3797);
      if (clTrue(L_form3800))
        { clObject L_top3801;
          clSetq(L_top3801, clCar(L_form3800, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3800);
            clSetq(L_form3800, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3801); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3800))
        { clObject L_0;
          clSetq(L_0, L_form3800);
          clExtraArgs(L_0, clEOA); }
      return(clSinhComplex(x, clEOA)); } }
  
  clObject clCosh_clINTEGER clVdecl(_ap)
  { clObject *L_args3805 = clMakeBinding(),
    *L_methods3806 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3805,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3806,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3808, CL_x;
      clSetq(L_form3808, *L_args3805);
      if (clTrue(L_form3808))
        { clObject L_top3809;
          clSetq(L_top3809, clCar(L_form3808, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3808);
            clSetq(L_form3808, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3809); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3808))
        { clObject L_0;
          clSetq(L_0, L_form3808);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCoshInteger(CL_x))); } }
  
  clObject clCosh_clRATIO clVdecl(_ap)
  { clObject *L_args3810 = clMakeBinding(),
    *L_methods3811 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3810,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3811,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3813, CL_x;
      clSetq(L_form3813, *L_args3810);
      if (clTrue(L_form3813))
        { clObject L_top3814;
          clSetq(L_top3814, clCar(L_form3813, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3813);
            clSetq(L_form3813, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3814); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3813))
        { clObject L_0;
          clSetq(L_0, L_form3813);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCoshRatio(CL_x))); } }
  
  clObject clCosh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3815 = clMakeBinding(),
    *L_methods3816 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3815,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3816,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3818, CL_x;
      clSetq(L_form3818, *L_args3815);
      if (clTrue(L_form3818))
        { clObject L_top3819;
          clSetq(L_top3819, clCar(L_form3818, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3818);
            clSetq(L_form3818, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3819); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3818))
        { clObject L_0;
          clSetq(L_0, L_form3818);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCoshSingleFloat(CL_x))); } }
  
  clObject clCosh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3820 = clMakeBinding(),
    *L_methods3821 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3820,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3821,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3823, CL_x;
      clSetq(L_form3823, *L_args3820);
      if (clTrue(L_form3823))
        { clObject L_top3824;
          clSetq(L_top3824, clCar(L_form3823, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3823);
            clSetq(L_form3823, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3824); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3823))
        { clObject L_0;
          clSetq(L_0, L_form3823);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clCoshDoubleFloat(CL_x))); } }
  
  clObject clCosh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3825 = clMakeBinding(),
    *L_methods3826 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3825,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3826,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3828, x;
      clSetq(L_form3828, *L_args3825);
      if (clTrue(L_form3828))
        { clObject L_top3829;
          clSetq(L_top3829, clCar(L_form3828, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3828);
            clSetq(L_form3828, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3829); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3828))
        { clObject L_0;
          clSetq(L_0, L_form3828);
          clExtraArgs(L_0, clEOA); }
      return(clCoshComplex(x, clEOA)); } }
  
  clObject clTanh_clINTEGER clVdecl(_ap)
  { clObject *L_args3833 = clMakeBinding(),
    *L_methods3834 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3833,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3834,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3836, CL_x;
      clSetq(L_form3836, *L_args3833);
      if (clTrue(L_form3836))
        { clObject L_top3837;
          clSetq(L_top3837, clCar(L_form3836, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3836);
            clSetq(L_form3836, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3837); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3836))
        { clObject L_0;
          clSetq(L_0, L_form3836);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanhInteger(CL_x))); } }
  
  clObject clTanh_clRATIO clVdecl(_ap)
  { clObject *L_args3838 = clMakeBinding(),
    *L_methods3839 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3838,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3839,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3841, CL_x;
      clSetq(L_form3841, *L_args3838);
      if (clTrue(L_form3841))
        { clObject L_top3842;
          clSetq(L_top3842, clCar(L_form3841, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3841);
            clSetq(L_form3841, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3842); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3841))
        { clObject L_0;
          clSetq(L_0, L_form3841);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanhRatio(CL_x))); } }
  
  clObject clTanh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3843 = clMakeBinding(),
    *L_methods3844 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3843,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3844,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3846, CL_x;
      clSetq(L_form3846, *L_args3843);
      if (clTrue(L_form3846))
        { clObject L_top3847;
          clSetq(L_top3847, clCar(L_form3846, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3846);
            clSetq(L_form3846, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3847); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3846))
        { clObject L_0;
          clSetq(L_0, L_form3846);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanhSingleFloat(CL_x))); } }
  
  clObject clTanh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3848 = clMakeBinding(),
    *L_methods3849 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3848,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3849,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3851, CL_x;
      clSetq(L_form3851, *L_args3848);
      if (clTrue(L_form3851))
        { clObject L_top3852;
          clSetq(L_top3852, clCar(L_form3851, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3851);
            clSetq(L_form3851, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3852); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3851))
        { clObject L_0;
          clSetq(L_0, L_form3851);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clTanhDoubleFloat(CL_x))); } }
  
  clObject clTanh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3853 = clMakeBinding(),
    *L_methods3854 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3853,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3854,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3856, x;
      clSetq(L_form3856, *L_args3853);
      if (clTrue(L_form3856))
        { clObject L_top3857;
          clSetq(L_top3857, clCar(L_form3856, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3856);
            clSetq(L_form3856, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3857); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3856))
        { clObject L_0;
          clSetq(L_0, L_form3856);
          clExtraArgs(L_0, clEOA); }
      return(clTanhComplex(x, clEOA)); } }
  
  clObject clAtan1_clINTEGER clVdecl(_ap)
  { clObject *L_args3861 = clMakeBinding(),
    *L_methods3862 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3861,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3862,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3864, CL_x;
      clSetq(L_form3864, *L_args3861);
      if (clTrue(L_form3864))
        { clObject L_top3865;
          clSetq(L_top3865, clCar(L_form3864, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3864);
            clSetq(L_form3864, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3865); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3864))
        { clObject L_0;
          clSetq(L_0, L_form3864);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan1Integer(CL_x))); } }
  
  clObject clAtan1_clRATIO clVdecl(_ap)
  { clObject *L_args3866 = clMakeBinding(),
    *L_methods3867 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3866,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3867,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3869, CL_x;
      clSetq(L_form3869, *L_args3866);
      if (clTrue(L_form3869))
        { clObject L_top3870;
          clSetq(L_top3870, clCar(L_form3869, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3869);
            clSetq(L_form3869, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3870); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3869))
        { clObject L_0;
          clSetq(L_0, L_form3869);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan1Ratio(CL_x))); } }
  
  clObject clAtan1_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3871 = clMakeBinding(),
    *L_methods3872 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3871,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3872,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3874, CL_x;
      clSetq(L_form3874, *L_args3871);
      if (clTrue(L_form3874))
        { clObject L_top3875;
          clSetq(L_top3875, clCar(L_form3874, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3874);
            clSetq(L_form3874, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3875); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3874))
        { clObject L_0;
          clSetq(L_0, L_form3874);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan1SingleFloat(CL_x))); } }
  
  clObject clAtan1_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3876 = clMakeBinding(),
    *L_methods3877 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3876,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3877,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3879, CL_x;
      clSetq(L_form3879, *L_args3876);
      if (clTrue(L_form3879))
        { clObject L_top3880;
          clSetq(L_top3880, clCar(L_form3879, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3879);
            clSetq(L_form3879, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3880); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3879))
        { clObject L_0;
          clSetq(L_0, L_form3879);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan1DoubleFloat(CL_x))); } }
  
  clObject clAtan1_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3881 = clMakeBinding(),
    *L_methods3882 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3881,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3882,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3884, x;
      clSetq(L_form3884, *L_args3881);
      if (clTrue(L_form3884))
        { clObject L_top3885;
          clSetq(L_top3885, clCar(L_form3884, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3884);
            clSetq(L_form3884, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3885); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3884))
        { clObject L_0;
          clSetq(L_0, L_form3884);
          clExtraArgs(L_0, clEOA); }
      return(clAtan1Complex(x, clEOA)); } }
  
  clObject clAsinh_clINTEGER clVdecl(_ap)
  { clObject *L_args3889 = clMakeBinding(),
    *L_methods3890 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3889,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3890,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3892, CL_x;
      clSetq(L_form3892, *L_args3889);
      if (clTrue(L_form3892))
        { clObject L_top3893;
          clSetq(L_top3893, clCar(L_form3892, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3892);
            clSetq(L_form3892, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3893); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3892))
        { clObject L_0;
          clSetq(L_0, L_form3892);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAsinhInteger(CL_x))); } }
  
  clObject clAsinh_clRATIO clVdecl(_ap)
  { clObject *L_args3894 = clMakeBinding(),
    *L_methods3895 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3894,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3895,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3897, CL_x;
      clSetq(L_form3897, *L_args3894);
      if (clTrue(L_form3897))
        { clObject L_top3898;
          clSetq(L_top3898, clCar(L_form3897, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3897);
            clSetq(L_form3897, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3898); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3897))
        { clObject L_0;
          clSetq(L_0, L_form3897);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAsinhRatio(CL_x))); } }
  
  clObject clAsinh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3899 = clMakeBinding(),
    *L_methods3900 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3899,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3900,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3902, CL_x;
      clSetq(L_form3902, *L_args3899);
      if (clTrue(L_form3902))
        { clObject L_top3903;
          clSetq(L_top3903, clCar(L_form3902, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3902);
            clSetq(L_form3902, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3903); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3902))
        { clObject L_0;
          clSetq(L_0, L_form3902);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAsinhSingleFloat(CL_x))); } }
  
  clObject clAsinh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3904 = clMakeBinding(),
    *L_methods3905 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3904,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3905,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3907, CL_x;
      clSetq(L_form3907, *L_args3904);
      if (clTrue(L_form3907))
        { clObject L_top3908;
          clSetq(L_top3908, clCar(L_form3907, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3907);
            clSetq(L_form3907, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top3908); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3907))
        { clObject L_0;
          clSetq(L_0, L_form3907);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAsinhDoubleFloat(CL_x))); } }
  
  clObject clAsinh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3909 = clMakeBinding(),
    *L_methods3910 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3909,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3910,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3912, x;
      clSetq(L_form3912, *L_args3909);
      if (clTrue(L_form3912))
        { clObject L_top3913;
          clSetq(L_top3913, clCar(L_form3912, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3912);
            clSetq(L_form3912, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3913); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3912))
        { clObject L_0;
          clSetq(L_0, L_form3912);
          clExtraArgs(L_0, clEOA); }
      return(clAsinhComplex(x, clEOA)); } }
  
  clObject clAsin_clINTEGER clVdecl(_ap)
  { clObject *L_args3921 = clMakeBinding(),
    *L_methods3922 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3921,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3922,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3924, x;
      clSetq(L_form3924, *L_args3921);
      if (clTrue(L_form3924))
        { clObject L_top3925;
          clSetq(L_top3925, clCar(L_form3924, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3924);
            clSetq(L_form3924, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3925); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3924))
        { clObject L_0;
          clSetq(L_0, L_form3924);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAsin1Integer(x)));
      else return(clAsinComplex(x, clEOA)); } }
  
  clObject clAsin_clRATIO clVdecl(_ap)
  { clObject *L_args3933 = clMakeBinding(),
    *L_methods3934 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3933,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3934,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3936, x;
      clSetq(L_form3936, *L_args3933);
      if (clTrue(L_form3936))
        { clObject L_top3937;
          clSetq(L_top3937, clCar(L_form3936, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3936);
            clSetq(L_form3936, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3937); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3936))
        { clObject L_0;
          clSetq(L_0, L_form3936);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAsin1Ratio(x)));
      else return(clAsinComplex(x, clEOA)); } }
  
  clObject clAsin_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args3945 = clMakeBinding(),
    *L_methods3946 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3945,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3946,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3948, x;
      clSetq(L_form3948, *L_args3945);
      if (clTrue(L_form3948))
        { clObject L_top3949;
          clSetq(L_top3949, clCar(L_form3948, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3948);
            clSetq(L_form3948, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3949); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3948))
        { clObject L_0;
          clSetq(L_0, L_form3948);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAsin1SingleFloat(x)));
      else return(clAsinComplex(x, clEOA)); } }
  
  clObject clAsin_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args3957 = clMakeBinding(),
    *L_methods3958 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3957,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3958,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3960, x;
      clSetq(L_form3960, *L_args3957);
      if (clTrue(L_form3960))
        { clObject L_top3961;
          clSetq(L_top3961, clCar(L_form3960, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3960);
            clSetq(L_form3960, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3961); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3960))
        { clObject L_0;
          clSetq(L_0, L_form3960);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAsin1DoubleFloat(x)));
      else return(clAsinComplex(x, clEOA)); } }
  
  clObject clAsin_clCOMPLEX clVdecl(_ap)
  { clObject *L_args3965 = clMakeBinding(),
    *L_methods3966 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3965,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3966,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3968, x;
      clSetq(L_form3968, *L_args3965);
      if (clTrue(L_form3968))
        { clObject L_top3969;
          clSetq(L_top3969, clCar(L_form3968, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3968);
            clSetq(L_form3968, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3969); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3968))
        { clObject L_0;
          clSetq(L_0, L_form3968);
          clExtraArgs(L_0, clEOA); }
      return(clAsinComplex(x, clEOA)); } }
  
  clObject clAcos_clINTEGER clVdecl(_ap)
  { clObject *L_args3977 = clMakeBinding(),
    *L_methods3978 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3977,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3978,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3980, x;
      clSetq(L_form3980, *L_args3977);
      if (clTrue(L_form3980))
        { clObject L_top3981;
          clSetq(L_top3981, clCar(L_form3980, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3980);
            clSetq(L_form3980, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3981); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3980))
        { clObject L_0;
          clSetq(L_0, L_form3980);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAcos1Integer(x)));
      else return(clAcosComplex(x, clEOA)); } }
  
  clObject clAcos_clRATIO clVdecl(_ap)
  { clObject *L_args3989 = clMakeBinding(),
    *L_methods3990 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args3989,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods3990,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form3992, x;
      clSetq(L_form3992, *L_args3989);
      if (clTrue(L_form3992))
        { clObject L_top3993;
          clSetq(L_top3993, clCar(L_form3992, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form3992);
            clSetq(L_form3992, clCdr(L_0, clEOA)); }
          clSetq(x, L_top3993); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form3992))
        { clObject L_0;
          clSetq(L_0, L_form3992);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAcos1Ratio(x)));
      else return(clAcosComplex(x, clEOA)); } }
  
  clObject clAcos_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4001 = clMakeBinding(),
    *L_methods4002 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4001,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4002,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4004, x;
      clSetq(L_form4004, *L_args4001);
      if (clTrue(L_form4004))
        { clObject L_top4005;
          clSetq(L_top4005, clCar(L_form4004, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4004);
            clSetq(L_form4004, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4005); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4004))
        { clObject L_0;
          clSetq(L_0, L_form4004);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAcos1SingleFloat(x)));
      else return(clAcosComplex(x, clEOA)); } }
  
  clObject clAcos_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4013 = clMakeBinding(),
    *L_methods4014 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4013,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4014,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4016, x;
      clSetq(L_form4016, *L_args4013);
      if (clTrue(L_form4016))
        { clObject L_top4017;
          clSetq(L_top4017, clCar(L_form4016, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4016);
            clSetq(L_form4016, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4017); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4016))
        { clObject L_0;
          clSetq(L_0, L_form4016);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAcos1DoubleFloat(x)));
      else return(clAcosComplex(x, clEOA)); } }
  
  clObject clAcos_clCOMPLEX clVdecl(_ap)
  { clObject *L_args4021 = clMakeBinding(),
    *L_methods4022 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4021,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4022,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4024, x;
      clSetq(L_form4024, *L_args4021);
      if (clTrue(L_form4024))
        { clObject L_top4025;
          clSetq(L_top4025, clCar(L_form4024, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4024);
            clSetq(L_form4024, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4025); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4024))
        { clObject L_0;
          clSetq(L_0, L_form4024);
          clExtraArgs(L_0, clEOA); }
      return(clAcosComplex(x, clEOA)); } }
  
  clObject clAtanh_clINTEGER clVdecl(_ap)
  { clObject *L_args4033 = clMakeBinding(),
    *L_methods4034 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4033,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4034,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4036, x;
      clSetq(L_form4036, *L_args4033);
      if (clTrue(L_form4036))
        { clObject L_top4037;
          clSetq(L_top4037, clCar(L_form4036, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4036);
            clSetq(L_form4036, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4037); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4036))
        { clObject L_0;
          clSetq(L_0, L_form4036);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAtanh1Integer(x)));
      else return(clAtanhComplex(x, clEOA)); } }
  
  clObject clAtanh_clRATIO clVdecl(_ap)
  { clObject *L_args4045 = clMakeBinding(),
    *L_methods4046 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4045,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4046,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4048, x;
      clSetq(L_form4048, *L_args4045);
      if (clTrue(L_form4048))
        { clObject L_top4049;
          clSetq(L_top4049, clCar(L_form4048, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4048);
            clSetq(L_form4048, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4049); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4048))
        { clObject L_0;
          clSetq(L_0, L_form4048);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAtanh1Ratio(x)));
      else return(clAtanhComplex(x, clEOA)); } }
  
  clObject clAtanh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4057 = clMakeBinding(),
    *L_methods4058 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4057,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4058,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4060, x;
      clSetq(L_form4060, *L_args4057);
      if (clTrue(L_form4060))
        { clObject L_top4061;
          clSetq(L_top4061, clCar(L_form4060, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4060);
            clSetq(L_form4060, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4061); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4060))
        { clObject L_0;
          clSetq(L_0, L_form4060);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAtanh1SingleFloat(x)));
      else return(clAtanhComplex(x, clEOA)); } }
  
  clObject clAtanh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4069 = clMakeBinding(),
    *L_methods4070 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4069,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4070,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4072, x;
      clSetq(L_form4072, *L_args4069);
      if (clTrue(L_form4072))
        { clObject L_top4073;
          clSetq(L_top4073, clCar(L_form4072, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4072);
            clSetq(L_form4072, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4073); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4072))
        { clObject L_0;
          clSetq(L_0, L_form4072);
          clExtraArgs(L_0, clEOA); }
      if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clLE),
                                           I_minus1,
                                           x,
                                           clEOA)) ?
                  clFuncallFunction(clSymbolFunctionValue(clLE),
                                    x,
                                    I_1,
                                    clEOA) :
                  clNIL)))
        return(clValues1(clAtanh1DoubleFloat(x)));
      else return(clAtanhComplex(x, clEOA)); } }
  
  clObject clAtanh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args4077 = clMakeBinding(),
    *L_methods4078 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4077,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4078,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4080, x;
      clSetq(L_form4080, *L_args4077);
      if (clTrue(L_form4080))
        { clObject L_top4081;
          clSetq(L_top4081, clCar(L_form4080, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4080);
            clSetq(L_form4080, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4081); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4080))
        { clObject L_0;
          clSetq(L_0, L_form4080);
          clExtraArgs(L_0, clEOA); }
      return(clAtanhComplex(x, clEOA)); } }
  
  clObject clAcosh_clINTEGER clVdecl(_ap)
  { clObject *L_args4089 = clMakeBinding(),
    *L_methods4090 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4089,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4090,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4092, x;
      clSetq(L_form4092, *L_args4089);
      if (clTrue(L_form4092))
        { clObject L_top4093;
          clSetq(L_top4093, clCar(L_form4092, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4092);
            clSetq(L_form4092, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4093); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4092))
        { clObject L_0;
          clSetq(L_0, L_form4092);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clFuncallFunction(clSymbolFunctionValue(clGE),
                                   x,
                                   I_1,
                                   clEOA)))
        return(clValues1(clAcosh1Integer(x)));
      else return(clAcoshComplex(x, clEOA)); } }
  
  clObject clAcosh_clRATIO clVdecl(_ap)
  { clObject *L_args4098 = clMakeBinding(),
    *L_methods4099 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4098,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4099,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4101, x;
      clSetq(L_form4101, *L_args4098);
      if (clTrue(L_form4101))
        { clObject L_top4102;
          clSetq(L_top4102, clCar(L_form4101, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4101);
            clSetq(L_form4101, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4102); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4101))
        { clObject L_0;
          clSetq(L_0, L_form4101);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clFuncallFunction(clSymbolFunctionValue(clGE),
                                   x,
                                   I_1,
                                   clEOA)))
        return(clValues1(clAcosh1Ratio(x)));
      else return(clAcoshComplex(x, clEOA)); } }
  
  clObject clAcosh_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4107 = clMakeBinding(),
    *L_methods4108 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4107,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4108,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4110, x;
      clSetq(L_form4110, *L_args4107);
      if (clTrue(L_form4110))
        { clObject L_top4111;
          clSetq(L_top4111, clCar(L_form4110, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4110);
            clSetq(L_form4110, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4111); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4110))
        { clObject L_0;
          clSetq(L_0, L_form4110);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clFuncallFunction(clSymbolFunctionValue(clGE),
                                   x,
                                   I_1,
                                   clEOA)))
        return(clValues1(clAcosh1SingleFloat(x)));
      else return(clAcoshComplex(x, clEOA)); } }
  
  clObject clAcosh_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4116 = clMakeBinding(),
    *L_methods4117 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4116,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4117,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4119, x;
      clSetq(L_form4119, *L_args4116);
      if (clTrue(L_form4119))
        { clObject L_top4120;
          clSetq(L_top4120, clCar(L_form4119, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4119);
            clSetq(L_form4119, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4120); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4119))
        { clObject L_0;
          clSetq(L_0, L_form4119);
          clExtraArgs(L_0, clEOA); }
      if (clTrue(clFuncallFunction(clSymbolFunctionValue(clGE),
                                   x,
                                   I_1,
                                   clEOA)))
        return(clValues1(clAcosh1DoubleFloat(x)));
      else return(clAcoshComplex(x, clEOA)); } }
  
  clObject clAcosh_clCOMPLEX clVdecl(_ap)
  { clObject *L_args4121 = clMakeBinding(),
    *L_methods4122 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4121,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4122,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4124, x;
      clSetq(L_form4124, *L_args4121);
      if (clTrue(L_form4124))
        { clObject L_top4125;
          clSetq(L_top4125, clCar(L_form4124, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4124);
            clSetq(L_form4124, clCdr(L_0, clEOA)); }
          clSetq(x, L_top4125); }
      else clSetq(x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4124))
        { clObject L_0;
          clSetq(L_0, L_form4124);
          clExtraArgs(L_0, clEOA); }
      return(clAcoshComplex(x, clEOA)); } }
  
  clObject clAtan2_clSINGLE_FLOAT_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4126 = clMakeBinding(),
    *L_methods4127 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4126,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4127,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4129, CL_x, CL_y;
      clSetq(L_form4129, *L_args4126);
      if (clTrue(L_form4129))
        { clObject L_top4130;
          clSetq(L_top4130, clCar(L_form4129, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4129);
            clSetq(L_form4129, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4130); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4129))
        { clObject L_top4131;
          { clObject L_0;
            clSetq(L_0, L_form4129);
            clSetq(L_top4131, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4129);
            clSetq(L_form4129, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4131); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4129))
        { clObject L_0;
          clSetq(L_0, L_form4129);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2SingleFloatSingleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clDOUBLE_FLOAT_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4132 = clMakeBinding(),
    *L_methods4133 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4132,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4133,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4135, CL_x, CL_y;
      clSetq(L_form4135, *L_args4132);
      if (clTrue(L_form4135))
        { clObject L_top4136;
          clSetq(L_top4136, clCar(L_form4135, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4135);
            clSetq(L_form4135, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4136); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4135))
        { clObject L_top4137;
          { clObject L_0;
            clSetq(L_0, L_form4135);
            clSetq(L_top4137, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4135);
            clSetq(L_form4135, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4137); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4135))
        { clObject L_0;
          clSetq(L_0, L_form4135);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2DoubleFloatDoubleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clINTEGER_clINTEGER clVdecl(_ap)
  { clObject *L_args4138 = clMakeBinding(),
    *L_methods4139 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4138,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4139,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4141, CL_x, CL_y;
      clSetq(L_form4141, *L_args4138);
      if (clTrue(L_form4141))
        { clObject L_top4142;
          clSetq(L_top4142, clCar(L_form4141, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4141);
            clSetq(L_form4141, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4142); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4141))
        { clObject L_top4143;
          { clObject L_0;
            clSetq(L_0, L_form4141);
            clSetq(L_top4143, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4141);
            clSetq(L_form4141, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4143); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4141))
        { clObject L_0;
          clSetq(L_0, L_form4141);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2IntegerInteger(CL_x, CL_y))); } }
  
  clObject clAtan2_clRATIO_clRATIO clVdecl(_ap)
  { clObject *L_args4144 = clMakeBinding(),
    *L_methods4145 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4144,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4145,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4147, CL_x, CL_y;
      clSetq(L_form4147, *L_args4144);
      if (clTrue(L_form4147))
        { clObject L_top4148;
          clSetq(L_top4148, clCar(L_form4147, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4147);
            clSetq(L_form4147, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4148); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4147))
        { clObject L_top4149;
          { clObject L_0;
            clSetq(L_0, L_form4147);
            clSetq(L_top4149, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4147);
            clSetq(L_form4147, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4149); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4147))
        { clObject L_0;
          clSetq(L_0, L_form4147);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2RatioRatio(CL_x, CL_y))); } }
  
  clObject clAtan2_clSINGLE_FLOAT_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4150 = clMakeBinding(),
    *L_methods4151 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4150,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4151,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4153, CL_x, CL_y;
      clSetq(L_form4153, *L_args4150);
      if (clTrue(L_form4153))
        { clObject L_top4154;
          clSetq(L_top4154, clCar(L_form4153, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4153);
            clSetq(L_form4153, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4154); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4153))
        { clObject L_top4155;
          { clObject L_0;
            clSetq(L_0, L_form4153);
            clSetq(L_top4155, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4153);
            clSetq(L_form4153, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4155); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4153))
        { clObject L_0;
          clSetq(L_0, L_form4153);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2SingleFloatDoubleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clSINGLE_FLOAT_clRATIO clVdecl(_ap)
  { clObject *L_args4156 = clMakeBinding(),
    *L_methods4157 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4156,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4157,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4159, CL_x, CL_y;
      clSetq(L_form4159, *L_args4156);
      if (clTrue(L_form4159))
        { clObject L_top4160;
          clSetq(L_top4160, clCar(L_form4159, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4159);
            clSetq(L_form4159, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4160); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4159))
        { clObject L_top4161;
          { clObject L_0;
            clSetq(L_0, L_form4159);
            clSetq(L_top4161, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4159);
            clSetq(L_form4159, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4161); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4159))
        { clObject L_0;
          clSetq(L_0, L_form4159);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2SingleFloatRatio(CL_x, CL_y))); } }
  
  clObject clAtan2_clSINGLE_FLOAT_clINTEGER clVdecl(_ap)
  { clObject *L_args4162 = clMakeBinding(),
    *L_methods4163 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4162,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4163,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4165, CL_x, CL_y;
      clSetq(L_form4165, *L_args4162);
      if (clTrue(L_form4165))
        { clObject L_top4166;
          clSetq(L_top4166, clCar(L_form4165, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4165);
            clSetq(L_form4165, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4166); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4165))
        { clObject L_top4167;
          { clObject L_0;
            clSetq(L_0, L_form4165);
            clSetq(L_top4167, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4165);
            clSetq(L_form4165, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4167); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4165))
        { clObject L_0;
          clSetq(L_0, L_form4165);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2SingleFloatInteger(CL_x, CL_y))); } }
  
  clObject clAtan2_clDOUBLE_FLOAT_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4168 = clMakeBinding(),
    *L_methods4169 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4168,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4169,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4171, CL_x, CL_y;
      clSetq(L_form4171, *L_args4168);
      if (clTrue(L_form4171))
        { clObject L_top4172;
          clSetq(L_top4172, clCar(L_form4171, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4171);
            clSetq(L_form4171, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4172); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4171))
        { clObject L_top4173;
          { clObject L_0;
            clSetq(L_0, L_form4171);
            clSetq(L_top4173, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4171);
            clSetq(L_form4171, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4173); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4171))
        { clObject L_0;
          clSetq(L_0, L_form4171);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2DoubleFloatSingleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clDOUBLE_FLOAT_clRATIO clVdecl(_ap)
  { clObject *L_args4174 = clMakeBinding(),
    *L_methods4175 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4174,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4175,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4177, CL_x, CL_y;
      clSetq(L_form4177, *L_args4174);
      if (clTrue(L_form4177))
        { clObject L_top4178;
          clSetq(L_top4178, clCar(L_form4177, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4177);
            clSetq(L_form4177, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4178); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4177))
        { clObject L_top4179;
          { clObject L_0;
            clSetq(L_0, L_form4177);
            clSetq(L_top4179, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4177);
            clSetq(L_form4177, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4179); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4177))
        { clObject L_0;
          clSetq(L_0, L_form4177);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2DoubleFloatRatio(CL_x, CL_y))); } }
  
  clObject clAtan2_clDOUBLE_FLOAT_clINTEGER clVdecl(_ap)
  { clObject *L_args4180 = clMakeBinding(),
    *L_methods4181 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4180,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4181,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4183, CL_x, CL_y;
      clSetq(L_form4183, *L_args4180);
      if (clTrue(L_form4183))
        { clObject L_top4184;
          clSetq(L_top4184, clCar(L_form4183, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4183);
            clSetq(L_form4183, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4184); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4183))
        { clObject L_top4185;
          { clObject L_0;
            clSetq(L_0, L_form4183);
            clSetq(L_top4185, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4183);
            clSetq(L_form4183, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4185); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4183))
        { clObject L_0;
          clSetq(L_0, L_form4183);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2DoubleFloatInteger(CL_x, CL_y))); } }
  
  clObject clAtan2_clRATIO_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4186 = clMakeBinding(),
    *L_methods4187 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4186,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4187,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4189, CL_x, CL_y;
      clSetq(L_form4189, *L_args4186);
      if (clTrue(L_form4189))
        { clObject L_top4190;
          clSetq(L_top4190, clCar(L_form4189, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4189);
            clSetq(L_form4189, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4190); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4189))
        { clObject L_top4191;
          { clObject L_0;
            clSetq(L_0, L_form4189);
            clSetq(L_top4191, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4189);
            clSetq(L_form4189, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4191); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4189))
        { clObject L_0;
          clSetq(L_0, L_form4189);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2RatioSingleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clRATIO_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4192 = clMakeBinding(),
    *L_methods4193 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4192,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4193,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4195, CL_x, CL_y;
      clSetq(L_form4195, *L_args4192);
      if (clTrue(L_form4195))
        { clObject L_top4196;
          clSetq(L_top4196, clCar(L_form4195, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4195);
            clSetq(L_form4195, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4196); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4195))
        { clObject L_top4197;
          { clObject L_0;
            clSetq(L_0, L_form4195);
            clSetq(L_top4197, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4195);
            clSetq(L_form4195, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4197); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4195))
        { clObject L_0;
          clSetq(L_0, L_form4195);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2RatioDoubleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clRATIO_clINTEGER clVdecl(_ap)
  { clObject *L_args4198 = clMakeBinding(),
    *L_methods4199 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4198,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4199,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4201, CL_x, CL_y;
      clSetq(L_form4201, *L_args4198);
      if (clTrue(L_form4201))
        { clObject L_top4202;
          clSetq(L_top4202, clCar(L_form4201, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4201);
            clSetq(L_form4201, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4202); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4201))
        { clObject L_top4203;
          { clObject L_0;
            clSetq(L_0, L_form4201);
            clSetq(L_top4203, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4201);
            clSetq(L_form4201, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4203); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4201))
        { clObject L_0;
          clSetq(L_0, L_form4201);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2RatioInteger(CL_x, CL_y))); } }
  
  clObject clAtan2_clINTEGER_clRATIO clVdecl(_ap)
  { clObject *L_args4204 = clMakeBinding(),
    *L_methods4205 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4204,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4205,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4207, CL_x, CL_y;
      clSetq(L_form4207, *L_args4204);
      if (clTrue(L_form4207))
        { clObject L_top4208;
          clSetq(L_top4208, clCar(L_form4207, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4207);
            clSetq(L_form4207, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4208); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4207))
        { clObject L_top4209;
          { clObject L_0;
            clSetq(L_0, L_form4207);
            clSetq(L_top4209, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4207);
            clSetq(L_form4207, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4209); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4207))
        { clObject L_0;
          clSetq(L_0, L_form4207);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2IntegerRatio(CL_x, CL_y))); } }
  
  clObject clAtan2_clINTEGER_clSINGLE_FLOAT clVdecl(_ap)
  { clObject *L_args4210 = clMakeBinding(),
    *L_methods4211 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4210,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4211,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4213, CL_x, CL_y;
      clSetq(L_form4213, *L_args4210);
      if (clTrue(L_form4213))
        { clObject L_top4214;
          clSetq(L_top4214, clCar(L_form4213, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4213);
            clSetq(L_form4213, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4214); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4213))
        { clObject L_top4215;
          { clObject L_0;
            clSetq(L_0, L_form4213);
            clSetq(L_top4215, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4213);
            clSetq(L_form4213, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4215); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4213))
        { clObject L_0;
          clSetq(L_0, L_form4213);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2IntegerSingleFloat(CL_x, CL_y))); } }
  
  clObject clAtan2_clINTEGER_clDOUBLE_FLOAT clVdecl(_ap)
  { clObject *L_args4216 = clMakeBinding(),
    *L_methods4217 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args4216,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods4217,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form4219, CL_x, CL_y;
      clSetq(L_form4219, *L_args4216);
      if (clTrue(L_form4219))
        { clObject L_top4220;
          clSetq(L_top4220, clCar(L_form4219, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form4219);
            clSetq(L_form4219, clCdr(L_0, clEOA)); }
          clSetq(CL_x, L_top4220); }
      else clSetq(CL_x, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form4219))
        { clObject L_top4221;
          { clObject L_0;
            clSetq(L_0, L_form4219);
            clSetq(L_top4221, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form4219);
            clSetq(L_form4219, clCdr(L_0, clEOA)); }
          clSetq(CL_y, L_top4221); }
      else clSetq(CL_y, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form4219))
        { clObject L_0;
          clSetq(L_0, L_form4219);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clAtan2IntegerDoubleFloat(CL_x, CL_y))); } }
  
  clObject clAtan clVdecl(_ap)
  { clObject L_ap, y, x, xp;
    { clBeginParse(_ap);
      clSetq(y, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(x, (clTrue(clSetq(L_ap, clVp(_ap))) ? clVpop(_ap) : clNIL));
      clSetq(xp, L_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    if (clTrue(xp))
      { clObject L_1;
        clSetq(L_1, x);
        return(clFuncallFunction(clSymbolFunctionValue(clATAN2),
                                 y,
                                 L_1,
                                 clEOA)); }
    else
      return(clFuncallFunction(clSymbolFunctionValue(clATAN1),
                               y,
                               clEOA)); }
  
  clObject clSinComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject r, i;
      clSetq(r,
             clFuncallFunction(clSymbolFunctionValue(clREALPART),
                               z,
                               clEOA));
      clSetq(i,
             clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                               z,
                               clEOA));
      { clObject L_1, L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1,
                 clFuncallFunction(clSymbolFunctionValue(clSIN),
                                   r,
                                   clEOA));
          clSetq(L_0,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   clFuncallFunction(clSymbolFunctionValue(clCOSH),
                                                     i,
                                                     clEOA),
                                   clEOA)); }
        { clObject L_0__R1;
          clSetq(L_0__R1,
                 clFuncallFunction(clSymbolFunctionValue(clCOS),
                                   r,
                                   clEOA));
          clSetq(L_1,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   clFuncallFunction(clSymbolFunctionValue(clSINH),
                                                     i,
                                                     clEOA),
                                   clEOA)); }
        return(clComplex(L_0, L_1, clEOA)); } } }
  
  clObject clCosComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject r, i;
      clSetq(r,
             clFuncallFunction(clSymbolFunctionValue(clREALPART),
                               z,
                               clEOA));
      clSetq(i,
             clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                               z,
                               clEOA));
      { clObject L_1, L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1,
                 clFuncallFunction(clSymbolFunctionValue(clCOS),
                                   r,
                                   clEOA));
          clSetq(L_0,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   clFuncallFunction(clSymbolFunctionValue(clCOSH),
                                                     i,
                                                     clEOA),
                                   clEOA)); }
        { clObject L_1__R1;
          { clObject L_0__R2;
            clSetq(L_0__R2,
                   clFuncallFunction(clSymbolFunctionValue(clSIN),
                                     r,
                                     clEOA));
            clSetq(L_1__R1,
                   clFuncallFunction(clSymbolFunctionValue(clMULT),
                                     L_0__R2,
                                     clFuncallFunction(clSymbolFunctionValue(clSINH),
                                                       i,
                                                       clEOA),
                                     clEOA)); }
          clSetq(L_1,
                 clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                   I_0,
                                   L_1__R1,
                                   clEOA)); }
        return(clComplex(L_0, L_1, clEOA)); } } }
  
  clObject clTanComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0,
             clFuncallFunction(clSymbolFunctionValue(clSIN), z, clEOA));
      return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                               L_0,
                               clFuncallFunction(clSymbolFunctionValue(clCOS),
                                                 z,
                                                 clEOA),
                               clEOA)); } }
  
  clObject clISTAR_FUNC clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0,
             clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                               z,
                               clEOA));
      return(clComplex(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                         I_0,
                                         clFuncallFunction(clSymbolFunctionValue(clREALPART),
                                                           z,
                                                           clEOA),
                                         clEOA),
                       clEOA)); } }
  
  clObject clZroot clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clFuncallFunction(clSymbolFunctionValue(clSQRT),
                             clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                               I_1,
                                               clFuncallFunction(clSymbolFunctionValue(clMULT),
                                                                 z,
                                                                 z,
                                                                 clEOA),
                                               clEOA),
                             clEOA)); }
  
  clObject clAsinComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_1;
      { clObject L_0__R1;
        { clObject L_0__R2;
          { clObject L_0__R3;
            clSetq(L_0__R3, clISTAR_FUNC(z, clEOA));
            clSetq(L_0__R2,
                   clFuncallFunction(clSymbolFunctionValue(clADD),
                                     L_0__R3,
                                     clZroot(z, clEOA),
                                     clEOA)); }
          clSetq(L_0__R1, clLog(L_0__R2, clEOA)); }
        clSetq(L_1, clISTAR_FUNC(L_0__R1, clEOA)); }
      return(clFuncallFunction(clSymbolFunctionValue(clSUBT),
                               I_0,
                               L_1,
                               clEOA)); } }
  
  clObject clAcosComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clFuncallFunction(clSymbolFunctionValue(clSUBT),
                             I_0,
                             clISTAR_FUNC(clLog(clFuncallFunction(clSymbolFunctionValue(clADD),
                                                                  z,
                                                                  clISTAR_FUNC(clZroot(z,
                                                                                       clEOA),
                                                                               clEOA),
                                                                  clEOA),
                                                clEOA),
                                          clEOA),
                             clEOA)); }
  
  clObject clAtan1Complex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject r, i;
      clSetq(r,
             clFuncallFunction(clSymbolFunctionValue(clREALPART),
                               z,
                               clEOA));
      clSetq(i,
             clFuncallFunction(clSymbolFunctionValue(clIMAGPART),
                               z,
                               clEOA));
      { clObject L_0;
        { clObject L_1__R1, L_0__R1;
          { clObject L_0__R2;
            { clObject L_0__R3;
              clSetq(L_0__R3,
                     clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                       I_1,
                                       i,
                                       clEOA));
              clSetq(L_0__R2, clComplex(L_0__R3, r, clEOA)); }
            clSetq(L_0__R1, clLog(L_0__R2, clEOA)); }
          { clObject L_0__R2;
            { clObject L_0__R3;
              clSetq(L_0__R3,
                     clFuncallFunction(clSymbolFunctionValue(clADD),
                                       I_1,
                                       i,
                                       clEOA));
              clSetq(L_0__R2,
                     clComplex(L_0__R3,
                               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                 I_0,
                                                 r,
                                                 clEOA),
                               clEOA)); }
            clSetq(L_1__R1, clLog(L_0__R2, clEOA)); }
          clSetq(L_0,
                 clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                   L_0__R1,
                                   L_1__R1,
                                   clEOA)); }
        return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                                 L_0,
                                 X_0plus2I,
                                 clEOA)); } } }
  
  clObject clSinhComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clFuncallFunction(clSymbolFunctionValue(clEXP),
                                 z,
                                 clEOA));
        clSetq(L_0,
               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                 L_0__R1,
                                 clFuncallFunction(clSymbolFunctionValue(clEXP),
                                                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                                     I_0,
                                                                     z,
                                                                     clEOA),
                                                   clEOA),
                                 clEOA)); }
      return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                               L_0,
                               I_2,
                               clEOA)); } }
  
  clObject clCoshComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clFuncallFunction(clSymbolFunctionValue(clEXP),
                                 z,
                                 clEOA));
        clSetq(L_0,
               clFuncallFunction(clSymbolFunctionValue(clADD),
                                 L_0__R1,
                                 clFuncallFunction(clSymbolFunctionValue(clEXP),
                                                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                                     I_0,
                                                                     z,
                                                                     clEOA),
                                                   clEOA),
                                 clEOA)); }
      return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                               L_0,
                               I_2,
                               clEOA)); } }
  
  clObject clTanhComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject e, e_minus;
      clSetq(e,
             clFuncallFunction(clSymbolFunctionValue(clEXP), z, clEOA));
      clSetq(e_minus,
             clFuncallFunction(clSymbolFunctionValue(clEXP),
                               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                 I_0,
                                                 z,
                                                 clEOA),
                               clEOA));
      { clObject L_0;
        clSetq(L_0,
               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                 e,
                                 e_minus,
                                 clEOA));
        return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                                 L_0,
                                 clFuncallFunction(clSymbolFunctionValue(clADD),
                                                   e,
                                                   e_minus,
                                                   clEOA),
                                 clEOA)); } } }
  
  clObject clAsinhComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clLog(clFuncallFunction(clSymbolFunctionValue(clADD),
                                   z,
                                   clFuncallFunction(clSymbolFunctionValue(clSQRT),
                                                     cl1PLUS_FUNC(clFuncallFunction(clSymbolFunctionValue(clMULT),
                                                                                    z,
                                                                                    z,
                                                                                    clEOA),
                                                                  clEOA),
                                                     clEOA),
                                   clEOA),
                 clEOA)); }
  
  clObject clAcoshComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_1;
      { clObject L_0__R1;
        { clObject L_1__R1, L_0__R2;
          { clObject L_0__R3;
            { clObject L_0__R4;
              clSetq(L_0__R4, cl1PLUS_FUNC(z, clEOA));
              clSetq(L_0__R3,
                     clFuncallFunction(clSymbolFunctionValue(clDIV),
                                       L_0__R4,
                                       I_2,
                                       clEOA)); }
            clSetq(L_0__R2,
                   clFuncallFunction(clSymbolFunctionValue(clSQRT),
                                     L_0__R3,
                                     clEOA)); }
          { clObject L_0__R3;
            { clObject L_0__R4;
              clSetq(L_0__R4, cl1MINUS_FUNC(z, clEOA));
              clSetq(L_0__R3,
                     clFuncallFunction(clSymbolFunctionValue(clDIV),
                                       L_0__R4,
                                       I_2,
                                       clEOA)); }
            clSetq(L_1__R1,
                   clFuncallFunction(clSymbolFunctionValue(clSQRT),
                                     L_0__R3,
                                     clEOA)); }
          clSetq(L_0__R1,
                 clFuncallFunction(clSymbolFunctionValue(clADD),
                                   L_0__R2,
                                   L_1__R1,
                                   clEOA)); }
        clSetq(L_1, clLog(L_0__R1, clEOA)); }
      return(clFuncallFunction(clSymbolFunctionValue(clMULT),
                               I_2,
                               L_1,
                               clEOA)); } }
  
  clObject clAtanhComplex clVdecl(_ap)
  { clObject z;
    { clBeginParse(_ap);
      clSetq(z, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clLog(clFuncallFunction(clSymbolFunctionValue(clADD),
                                       I_1,
                                       z,
                                       clEOA),
                     clEOA));
        clSetq(L_0,
               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                 L_0__R1,
                                 clLog(clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                         I_1,
                                                         z,
                                                         clEOA),
                                       clEOA),
                                 clEOA)); }
      return(clFuncallFunction(clSymbolFunctionValue(clDIV),
                               L_0,
                               I_2,
                               clEOA)); } }
  
  void clInitTrig __P((void)) 
  { clDbind(clstarPACKAGEstar);
    clDbind(clstarREADTABLEstar);
    clDbind(clstarLOAD_TRUENAMEstar);
    clDbind(clstarLOAD_PATHNAMEstar);
    clSetq(STR_QUALIFIERS__0,
           clCharpSimpleBaseString("QUALIFIERS"));
    clSetq(keyQUALIFIERS, clMakeKeyword(STR_QUALIFIERS__0, clEOA));
    clSetq(STR_LAMBDA_LIST__1,
           clCharpSimpleBaseString("LAMBDA-LIST"));
    clSetq(keyLAMBDA_LIST, clMakeKeyword(STR_LAMBDA_LIST__1, clEOA));
    clSetq(CONS_0, clCons(clX, clNIL, clEOA));
    clSetq(STR_SPECIALIZERS__2,
           clCharpSimpleBaseString("SPECIALIZERS"));
    clSetq(keySPECIALIZERS, clMakeKeyword(STR_SPECIALIZERS__2, clEOA));
    clSetq(STR_FUNCTION__3,
           clCharpSimpleBaseString("FUNCTION"));
    clSetq(keyFUNCTION, clMakeKeyword(STR_FUNCTION__3, clEOA));
    clSetq(I_1, clIntFixnum(1));
    clSetq(I_2, clIntFixnum(2));
    clSetq(STR_DECLARATIONS__4,
           clCharpSimpleBaseString("DECLARATIONS"));
    clSetq(keyDECLARATIONS, clMakeKeyword(STR_DECLARATIONS__4, clEOA));
    clSetq(STR_DOCUMENTATION__5,
           clCharpSimpleBaseString("DOCUMENTATION"));
    clSetq(keyDOCUMENTATION, clMakeKeyword(STR_DOCUMENTATION__5, clEOA));
    clSetq(CONS_1, clCons(clNUMBER, clNIL, clEOA));
    clSetq(D_3_141592653589793d0,
           clDoubleDoubleFloat(3.141592653589793));
    clSetq(D_0_0d0, clDoubleDoubleFloat(0.0));
    clSetq(F_3_1415927, clDoubleSingleFloat(3.1415927410125732));
    clSetq(F_0_0, clDoubleSingleFloat(0.0));
    clSetq(I_minus1, clIntFixnum(-1));
    clSetq(F_minus1_0, clDoubleSingleFloat(-1.0));
    clSetq(F_1_0, clDoubleSingleFloat(1.0));
    clSetq(D_minus1_0d0, clDoubleDoubleFloat(-1.0));
    clSetq(D_1_0d0, clDoubleDoubleFloat(1.0));
    clSetq(CONS_2, clCons(clX, clNIL, clEOA));
    clSetq(CONS_5, clCons(clSIN_INTEGER, clNIL, clEOA));
    clSetq(CONS_4, clCons(clINLINE, CONS_5, clEOA));
    clSetq(CONS_3, clCons(CONS_4, clNIL, clEOA));
    clSetq(CONS_8, clCons(clSIN_RATIO, clNIL, clEOA));
    clSetq(CONS_7, clCons(clINLINE, CONS_8, clEOA));
    clSetq(CONS_6, clCons(CONS_7, clNIL, clEOA));
    clSetq(CONS_11, clCons(clSIN_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_10, clCons(clINLINE, CONS_11, clEOA));
    clSetq(CONS_9, clCons(CONS_10, clNIL, clEOA));
    clSetq(CONS_14, clCons(clSIN_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_13, clCons(clINLINE, CONS_14, clEOA));
    clSetq(CONS_12, clCons(CONS_13, clNIL, clEOA));
    clSetq(CONS_17, clCons(clCOS_INTEGER, clNIL, clEOA));
    clSetq(CONS_16, clCons(clINLINE, CONS_17, clEOA));
    clSetq(CONS_15, clCons(CONS_16, clNIL, clEOA));
    clSetq(CONS_20, clCons(clCOS_RATIO, clNIL, clEOA));
    clSetq(CONS_19, clCons(clINLINE, CONS_20, clEOA));
    clSetq(CONS_18, clCons(CONS_19, clNIL, clEOA));
    clSetq(CONS_23, clCons(clCOS_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_22, clCons(clINLINE, CONS_23, clEOA));
    clSetq(CONS_21, clCons(CONS_22, clNIL, clEOA));
    clSetq(CONS_26, clCons(clCOS_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_25, clCons(clINLINE, CONS_26, clEOA));
    clSetq(CONS_24, clCons(CONS_25, clNIL, clEOA));
    clSetq(CONS_29, clCons(clTAN_INTEGER, clNIL, clEOA));
    clSetq(CONS_28, clCons(clINLINE, CONS_29, clEOA));
    clSetq(CONS_27, clCons(CONS_28, clNIL, clEOA));
    clSetq(CONS_32, clCons(clTAN_RATIO, clNIL, clEOA));
    clSetq(CONS_31, clCons(clINLINE, CONS_32, clEOA));
    clSetq(CONS_30, clCons(CONS_31, clNIL, clEOA));
    clSetq(CONS_35, clCons(clTAN_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_34, clCons(clINLINE, CONS_35, clEOA));
    clSetq(CONS_33, clCons(CONS_34, clNIL, clEOA));
    clSetq(CONS_38, clCons(clTAN_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_37, clCons(clINLINE, CONS_38, clEOA));
    clSetq(CONS_36, clCons(CONS_37, clNIL, clEOA));
    clSetq(CONS_41, clCons(clSINH_INTEGER, clNIL, clEOA));
    clSetq(CONS_40, clCons(clINLINE, CONS_41, clEOA));
    clSetq(CONS_39, clCons(CONS_40, clNIL, clEOA));
    clSetq(CONS_44, clCons(clSINH_RATIO, clNIL, clEOA));
    clSetq(CONS_43, clCons(clINLINE, CONS_44, clEOA));
    clSetq(CONS_42, clCons(CONS_43, clNIL, clEOA));
    clSetq(CONS_47, clCons(clSINH_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_46, clCons(clINLINE, CONS_47, clEOA));
    clSetq(CONS_45, clCons(CONS_46, clNIL, clEOA));
    clSetq(CONS_50, clCons(clSINH_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_49, clCons(clINLINE, CONS_50, clEOA));
    clSetq(CONS_48, clCons(CONS_49, clNIL, clEOA));
    clSetq(CONS_53, clCons(clCOSH_INTEGER, clNIL, clEOA));
    clSetq(CONS_52, clCons(clINLINE, CONS_53, clEOA));
    clSetq(CONS_51, clCons(CONS_52, clNIL, clEOA));
    clSetq(CONS_56, clCons(clCOSH_RATIO, clNIL, clEOA));
    clSetq(CONS_55, clCons(clINLINE, CONS_56, clEOA));
    clSetq(CONS_54, clCons(CONS_55, clNIL, clEOA));
    clSetq(CONS_59, clCons(clCOSH_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_58, clCons(clINLINE, CONS_59, clEOA));
    clSetq(CONS_57, clCons(CONS_58, clNIL, clEOA));
    clSetq(CONS_62, clCons(clCOSH_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_61, clCons(clINLINE, CONS_62, clEOA));
    clSetq(CONS_60, clCons(CONS_61, clNIL, clEOA));
    clSetq(CONS_65, clCons(clTANH_INTEGER, clNIL, clEOA));
    clSetq(CONS_64, clCons(clINLINE, CONS_65, clEOA));
    clSetq(CONS_63, clCons(CONS_64, clNIL, clEOA));
    clSetq(CONS_68, clCons(clTANH_RATIO, clNIL, clEOA));
    clSetq(CONS_67, clCons(clINLINE, CONS_68, clEOA));
    clSetq(CONS_66, clCons(CONS_67, clNIL, clEOA));
    clSetq(CONS_71, clCons(clTANH_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_70, clCons(clINLINE, CONS_71, clEOA));
    clSetq(CONS_69, clCons(CONS_70, clNIL, clEOA));
    clSetq(CONS_74, clCons(clTANH_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_73, clCons(clINLINE, CONS_74, clEOA));
    clSetq(CONS_72, clCons(CONS_73, clNIL, clEOA));
    clSetq(CONS_77, clCons(clATAN1_INTEGER, clNIL, clEOA));
    clSetq(CONS_76, clCons(clINLINE, CONS_77, clEOA));
    clSetq(CONS_75, clCons(CONS_76, clNIL, clEOA));
    clSetq(CONS_80, clCons(clATAN1_RATIO, clNIL, clEOA));
    clSetq(CONS_79, clCons(clINLINE, CONS_80, clEOA));
    clSetq(CONS_78, clCons(CONS_79, clNIL, clEOA));
    clSetq(CONS_83, clCons(clATAN1_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_82, clCons(clINLINE, CONS_83, clEOA));
    clSetq(CONS_81, clCons(CONS_82, clNIL, clEOA));
    clSetq(CONS_86, clCons(clATAN1_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_85, clCons(clINLINE, CONS_86, clEOA));
    clSetq(CONS_84, clCons(CONS_85, clNIL, clEOA));
    clSetq(CONS_89, clCons(clASINH_INTEGER, clNIL, clEOA));
    clSetq(CONS_88, clCons(clINLINE, CONS_89, clEOA));
    clSetq(CONS_87, clCons(CONS_88, clNIL, clEOA));
    clSetq(CONS_92, clCons(clASINH_RATIO, clNIL, clEOA));
    clSetq(CONS_91, clCons(clINLINE, CONS_92, clEOA));
    clSetq(CONS_90, clCons(CONS_91, clNIL, clEOA));
    clSetq(CONS_95, clCons(clASINH_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_94, clCons(clINLINE, CONS_95, clEOA));
    clSetq(CONS_93, clCons(CONS_94, clNIL, clEOA));
    clSetq(CONS_98, clCons(clASINH_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_97, clCons(clINLINE, CONS_98, clEOA));
    clSetq(CONS_96, clCons(CONS_97, clNIL, clEOA));
    clSetq(CONS_100, clCons(clY, clNIL, clEOA));
    clSetq(CONS_99, clCons(clX, CONS_100, clEOA));
    clSetq(CONS_103,
           clCons(clATAN2_SINGLE_FLOAT_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_102, clCons(clINLINE, CONS_103, clEOA));
    clSetq(CONS_101, clCons(CONS_102, clNIL, clEOA));
    clSetq(CONS_106,
           clCons(clATAN2_DOUBLE_FLOAT_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_105, clCons(clINLINE, CONS_106, clEOA));
    clSetq(CONS_104, clCons(CONS_105, clNIL, clEOA));
    clSetq(CONS_109, clCons(clATAN2_INTEGER_INTEGER, clNIL, clEOA));
    clSetq(CONS_108, clCons(clINLINE, CONS_109, clEOA));
    clSetq(CONS_107, clCons(CONS_108, clNIL, clEOA));
    clSetq(CONS_112, clCons(clATAN2_RATIO_RATIO, clNIL, clEOA));
    clSetq(CONS_111, clCons(clINLINE, CONS_112, clEOA));
    clSetq(CONS_110, clCons(CONS_111, clNIL, clEOA));
    clSetq(CONS_115,
           clCons(clATAN2_SINGLE_FLOAT_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_114, clCons(clINLINE, CONS_115, clEOA));
    clSetq(CONS_113, clCons(CONS_114, clNIL, clEOA));
    clSetq(CONS_118, clCons(clATAN2_SINGLE_FLOAT_RATIO, clNIL, clEOA));
    clSetq(CONS_117, clCons(clINLINE, CONS_118, clEOA));
    clSetq(CONS_116, clCons(CONS_117, clNIL, clEOA));
    clSetq(CONS_121, clCons(clATAN2_SINGLE_FLOAT_INTEGER, clNIL, clEOA));
    clSetq(CONS_120, clCons(clINLINE, CONS_121, clEOA));
    clSetq(CONS_119, clCons(CONS_120, clNIL, clEOA));
    clSetq(CONS_124,
           clCons(clATAN2_DOUBLE_FLOAT_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_123, clCons(clINLINE, CONS_124, clEOA));
    clSetq(CONS_122, clCons(CONS_123, clNIL, clEOA));
    clSetq(CONS_127, clCons(clATAN2_DOUBLE_FLOAT_RATIO, clNIL, clEOA));
    clSetq(CONS_126, clCons(clINLINE, CONS_127, clEOA));
    clSetq(CONS_125, clCons(CONS_126, clNIL, clEOA));
    clSetq(CONS_130, clCons(clATAN2_DOUBLE_FLOAT_INTEGER, clNIL, clEOA));
    clSetq(CONS_129, clCons(clINLINE, CONS_130, clEOA));
    clSetq(CONS_128, clCons(CONS_129, clNIL, clEOA));
    clSetq(CONS_133, clCons(clATAN2_RATIO_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_132, clCons(clINLINE, CONS_133, clEOA));
    clSetq(CONS_131, clCons(CONS_132, clNIL, clEOA));
    clSetq(CONS_136, clCons(clATAN2_RATIO_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_135, clCons(clINLINE, CONS_136, clEOA));
    clSetq(CONS_134, clCons(CONS_135, clNIL, clEOA));
    clSetq(CONS_139, clCons(clATAN2_RATIO_INTEGER, clNIL, clEOA));
    clSetq(CONS_138, clCons(clINLINE, CONS_139, clEOA));
    clSetq(CONS_137, clCons(CONS_138, clNIL, clEOA));
    clSetq(CONS_142, clCons(clATAN2_INTEGER_RATIO, clNIL, clEOA));
    clSetq(CONS_141, clCons(clINLINE, CONS_142, clEOA));
    clSetq(CONS_140, clCons(CONS_141, clNIL, clEOA));
    clSetq(CONS_145, clCons(clATAN2_INTEGER_SINGLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_144, clCons(clINLINE, CONS_145, clEOA));
    clSetq(CONS_143, clCons(CONS_144, clNIL, clEOA));
    clSetq(CONS_148, clCons(clATAN2_INTEGER_DOUBLE_FLOAT, clNIL, clEOA));
    clSetq(CONS_147, clCons(clINLINE, CONS_148, clEOA));
    clSetq(CONS_146, clCons(CONS_147, clNIL, clEOA));
    clSetq(I_0, clIntFixnum(0));
    clSetq(X_0plus2I, clMakeComplex(I_0, I_2));
  
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clABS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAbs_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clPHASE, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clPhase_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_1,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clPHASE, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clPhase_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_1,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clPHASE, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clREAL, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clPhase_clREAL, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_1,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIGNUM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSignum_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIGNUM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSignum_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIGNUM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0, clSignum_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIGNUM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0, clSignum_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIGNUM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSignum_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clSetSymbolFunctionValue(clCIS,
                             clMakeClosure(0, clCis, clNULL_HOOK));
    (void) clCIS;
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSin_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_3, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSin_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_6, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clSin_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_9, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clSin_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_12, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSin_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCos_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_15, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCos_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_18, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clCos_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_21, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clCos_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_24, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCos_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTAN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTan_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_27, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTAN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTan_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_30, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTAN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clTan_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_33, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTAN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clTan_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_36, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTAN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTan_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSinh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_39, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSinh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_42, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clSinh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_45, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clSinh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_48, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clSinh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCosh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_51, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCosh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_54, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clCosh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_57, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clCosh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_60, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clCOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clCosh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTanh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_63, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTanh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_66, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clTanh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_69, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clTanh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_72, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTanh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN1, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtan1_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_75, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN1, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtan1_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_78, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN1, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAtan1_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_81, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN1, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAtan1_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_84, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN1, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtan1_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsinh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_87, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsinh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_90, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAsinh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_93, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAsinh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_2,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_96, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASINH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsinh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsin_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsin_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAsin_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAsin_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clASIN, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAsin_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcos_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcos_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAcos_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAcos_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOS, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcos_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtanh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtanh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAtanh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAtanh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATANH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAtanh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clINTEGER, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcosh_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clRATIO, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcosh_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAcosh_clSINGLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                    clEOA));
      clSetq(L_8, clMakeClosure(0, clAcosh_clDOUBLE_FLOAT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clACOSH, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clCOMPLEX, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clAcosh_clCOMPLEX, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_0,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clSINGLE_FLOAT_clSINGLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_101, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clDOUBLE_FLOAT_clDOUBLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_104, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clINTEGER, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clINTEGER, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0, clAtan2_clINTEGER_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_107, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA));
        clSetq(L_6,
               clList(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0, clAtan2_clRATIO_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_110, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clSINGLE_FLOAT_clDOUBLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_113, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clSINGLE_FLOAT_clRATIO,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_116, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clINTEGER, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clSINGLE_FLOAT_clINTEGER,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_119, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clDOUBLE_FLOAT_clSINGLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_122, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clDOUBLE_FLOAT_clRATIO,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_125, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clINTEGER, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clDOUBLE_FLOAT_clINTEGER,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_128, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clRATIO_clSINGLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_131, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clRATIO_clDOUBLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_134, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clINTEGER, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0, clAtan2_clRATIO_clINTEGER, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_137, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clINTEGER, clEOA));
        clSetq(L_6,
               clList(L_0__R1, clCanonicalizeSpecializer(clRATIO, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0, clAtan2_clINTEGER_clRATIO, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_140, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clINTEGER, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clSINGLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clINTEGER_clSINGLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_143, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clATAN2, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clINTEGER, clEOA));
        clSetq(L_6,
               clList(L_0__R1,
                      clCanonicalizeSpecializer(clDOUBLE_FLOAT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clAtan2_clINTEGER_clDOUBLE_FLOAT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_99,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_146, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clSetSymbolFunctionValue(clATAN,
                             clMakeClosure(0, clAtan, clNULL_HOOK));
    (void) clATAN;
    clSetSymbolFunctionValue(clSIN_COMPLEX,
                             clMakeClosure(0,
                                           clSinComplex,
                                           clNULL_HOOK));
    (void) clSIN_COMPLEX;
    clSetSymbolFunctionValue(clCOS_COMPLEX,
                             clMakeClosure(0,
                                           clCosComplex,
                                           clNULL_HOOK));
    (void) clCOS_COMPLEX;
    clSetSymbolFunctionValue(clTAN_COMPLEX,
                             clMakeClosure(0,
                                           clTanComplex,
                                           clNULL_HOOK));
    (void) clTAN_COMPLEX;
    clSetSymbolFunctionValue(clIstar,
                             clMakeClosure(0,
                                           clISTAR_FUNC,
                                           clNULL_HOOK));
    (void) clIstar;
    clSetSymbolFunctionValue(clZROOT,
                             clMakeClosure(0, clZroot, clNULL_HOOK));
    (void) clZROOT;
    clSetSymbolFunctionValue(clASIN_COMPLEX,
                             clMakeClosure(0,
                                           clAsinComplex,
                                           clNULL_HOOK));
    (void) clASIN_COMPLEX;
    clSetSymbolFunctionValue(clACOS_COMPLEX,
                             clMakeClosure(0,
                                           clAcosComplex,
                                           clNULL_HOOK));
    (void) clACOS_COMPLEX;
    clSetSymbolFunctionValue(clATAN1_COMPLEX,
                             clMakeClosure(0,
                                           clAtan1Complex,
                                           clNULL_HOOK));
    (void) clATAN1_COMPLEX;
    clSetSymbolFunctionValue(clSINH_COMPLEX,
                             clMakeClosure(0,
                                           clSinhComplex,
                                           clNULL_HOOK));
    (void) clSINH_COMPLEX;
    clSetSymbolFunctionValue(clCOSH_COMPLEX,
                             clMakeClosure(0,
                                           clCoshComplex,
                                           clNULL_HOOK));
    (void) clCOSH_COMPLEX;
    clSetSymbolFunctionValue(clTANH_COMPLEX,
                             clMakeClosure(0,
                                           clTanhComplex,
                                           clNULL_HOOK));
    (void) clTANH_COMPLEX;
    clSetSymbolFunctionValue(clASINH_COMPLEX,
                             clMakeClosure(0,
                                           clAsinhComplex,
                                           clNULL_HOOK));
    (void) clASINH_COMPLEX;
    clSetSymbolFunctionValue(clACOSH_COMPLEX,
                             clMakeClosure(0,
                                           clAcoshComplex,
                                           clNULL_HOOK));
    (void) clACOSH_COMPLEX;
    clSetSymbolFunctionValue(clATANH_COMPLEX,
                             clMakeClosure(0,
                                           clAtanhComplex,
                                           clNULL_HOOK));
    (void) clATANH_COMPLEX;
    clUnwind(4); }
  