text: /* Generated by Eclipse Common Lisp 1.1-HOSTED on cad0.
     Monday the first of June, 1998, 3:50:28 pm CDT. */
  #include <eclipse.h>
  
  void clMillisleep __P((int));
  clObject clSTAR_FUNC(clProto), clPLUS_FUNC(clProto),
    cl1PLUS_FUNC(clProto), cl1MINUS_FUNC(clProto), clAcons(clProto),
    clAdjoin(clProto), clAppend(clProto), clApply(clProto),
    clAssoc(clProto), clBoundp(clProto), clCanonicalYear(clProto),
    clCar(clProto), clCdr(clProto), clCeiling(clProto),
    clCharpSimpleBaseString __P((clCharp)), clCons(clProto),
    clDecodeUniversalTime(clProto), clDelete(clProto),
    clDescribe(clProto), clEndp(clProto), clEq(clProto),
    clError(clProto), clExtraArgs(clProto), cl_SETF_Fdefinition(clProto),
    clFind(clProto), clFirstNonEmptyIndex __P((clObject, clObject)),
    clFixnump(clProto), clGcData __P((void)), clGetDecodedTime(clProto),
    clGetTimezone __P((clObject)), clGetUniversalTime(clProto),
    cl_SETF_GlobalDeclaration(clProto), clHashTableNBuckets(clProto),
    clHashTableValue __P((clObject, clObject)), clIdString(clProto),
    clIntInteger __P((int)), clLeapDaysSince1900(clProto),
    clLispImplementationVersion(clProto), clList(clProto),
    clListSTAR(clProto), clListAllPackages(clProto), clListArg(clProto),
    clListTraced(clProto), clMachineType(clProto),
    cl_SETF_MacroFunction(clProto), clMakeGeneralVector __P((clObject)),
    clMakeKeyword(clProto), clMakeRestart(clProto),
    clMakeSymbol(clProto), clMakeXint __P((clObject)), clMapcar(clProto),
    clMissingArgs(clProto), clMod(clProto), clNot(clProto),
    clNull(clProto), clOutputStream(clProto),
    clPackageExternals(clProto), clPackageInternals(clProto),
    clPackageUses(clProto), clPkg(clProto), clRealTime(clProto),
    clRedefineConstant(clProto), clRoom(clProto), clRunTime(clProto),
    clSearch(clProto), clShortSiteName(clProto), clSoftwareType(clProto),
    clString(clProto), clStringUpcase(clProto), clSvref(clProto),
    cl_SETF_Svref(clProto), clSymbolName(clProto), clTerpri(clProto),
    clTruncate(clProto), clUname __P((int)), clUnixTime __P((void)),
    clValues(clProto), clValuesList(clProto), clWarn(clProto),
    clWriteToplevel(clProto), clZerop(clProto);
  
  extern clObject clFIXNUM, clLET, clMULTIPLE_VALUE_PROG1, clQUOTE,
    clSPECIAL, clstarCONSTANT_CHECK_HOOKstar, clstarDEBUG_IOstar,
    clstarFEATURESstar, clstarLONG_SITE_NAMEstar,
    clstarMACHINE_VERSIONstar, clstarPRINT_ESCAPEstar,
    clstarPRINT_READABLYstar, clstarRESTARTSstar,
    clstarSHORT_SITE_NAMEstar, clstarSTANDARD_OUTPUTstar,
    clstarTRACE_DATAstar, clstarTRACE_LEVELstar, clstarTRACE_OUTPUTstar,
    clABORT, clADD, clAPROPOS, clAPROPOS_LIST, clCANONICAL_YEAR, clCAR,
    clCONSTANT, clCONSTANTLY, clDAYS_IN_YEAR_BY_MONTH,
    clDECODE_UNIVERSAL_TIME, clDESCRIBE, clDESCRIBE_OBJECT, clDIV, clED,
    clENCODE_UNIVERSAL_TIME, clEND_TIME, clEQ_NUMBER, clFORMAT, clGE,
    clGET_DECODED_TIME, clGET_INTERNAL_REAL_TIME,
    clGET_INTERNAL_RUN_TIME, clGET_UNIVERSAL_TIME, clGETHASH,
    clGLOBAL_VARIABLE, clGT, clHEAP_START, clID_STRING, clINSPECT,
    clINSPECT_OBJECT, clINTERNAL_TIME_UNITS_PER_SECOND,
    clLEAP_DAYS_SINCE_1900, clLISP_IMPLEMENTATION_TYPE,
    clLISP_IMPLEMENTATION_VERSION, clLIST, clLIST_TRACED,
    clLONG_SITE_NAME, clLT, clMACHINE_INSTANCE, clMACHINE_TYPE,
    clMACHINE_VERSION, clMEMBER, clMINUTES_PER_DAY, clMULT, clNOT_FOUND,
    clNOVEMBER_17_1858, clOR, clQUARTER_DAYS_PER_CENTURY,
    clQUARTER_DAYS_PER_YEAR, clREAL_START, clREAL_TIME, clROOM,
    clRUN_START, clRUN_TIME, clSECONDS_IN_WEEK, clSECONDS_OFFSET,
    clSECONDS_PER_DAY, clSECONDS_PER_HOUR, clSHORT_SITE_NAME, clSLEEP,
    clSOFTWARE_TYPE, clSOFTWARE_VERSION, clSTREAM_WRITE_STRING, clSUBT,
    clTIME, clTRACE, clTRACE1, clTYPE_ERROR, clUNIX_TO_UNIVERSAL_TIME,
    clUNTRACE, clUNTRACE1, clUSER_ID, clWEEKDAY_NOVEMBER_17_1858,
    clWEEKS_OFFSET;
  
  static clObject A_19, C_m, C_n, C_r, C_s, C_u, C_z, CONS_0, CONS_1,
    CONS_10, CONS_11, CONS_12, CONS_13, CONS_14, 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_5, CONS_6, CONS_7,
    CONS_8, CONS_9, I_minus1, I_minus4, I_0, I_1, I_10, I_100, I_1000,
    I_11, I_119, I_12, I_13, I_1440, I_146097, I_1461, I_150, I_153,
    I_180, I_1836, I_1900, I_1989, I_2, I_211, I_2145, I_2208988800,
    I_24, I_242, I_272, I_29, I_3, I_30, I_303, I_32384, I_333, I_33706,
    I_3600, I_365, I_4, I_400, I_432000, I_456, I_5, I_50, I_58, I_59,
    I_6, I_60, I_604800, I_678882, I_7, I_8, I_86400, I_89, I_9,
    keyANSI_CL, keyCOMMON_LISP, keyDATUM, keyDEFAULT, keyECLIPSE,
    keyELWOOD, keyEXPECTED_TYPE, keyEXTERNAL, keyHP,
    keyIEEE_FLOATING_POINT, keyINHERITED, keyINTEL, keyINTERNAL, keyKEY,
    keyNT, keyPA_RISC, keyPC, keyREPORT_FUNCTION, keySPARC, keySUN,
    keyUCS_4_IO, keyUNIX, keyWIN32, keyWIN95, keyWINDOWS, keyX3J13,
    keyX86, STR____21, STR_dot__20, STR_9000__31, STR_95__46,
    STR_ANSI_CL__25, STR_COMMON_LISP__24, STR_DATUM__17, STR_DEFAULT__9,
    STR_ECLIPSE___28, STR_ECLIPSE__22, STR_ELWOOD__23,
    STR_EXPECTED_TYPE__18, STR_EXTERNAL__16, STR_Eclipse_Common_Lisp__19,
    STR_HP__41, STR_I386__33, STR_I486__34, STR_I586__35, STR_I686__36,
    STR_IEEE_FLOATING_POINT__27, STR_INHERITED__14, STR_INTEL__39,
    STR_INTERNAL__15, STR_KEY__2, STR_LINUX__43, STR_NT__48,
    STR_PA_RISC__32, STR_PC__38, STR_Quit_inspectordot__8,
    STR_REPORT_FUNCTION__7, STR_SPARC__30, STR_SUN__29, STR_UCS_4_IO__42,
    STR_UNIX__40, STR_VALUES1__6, STR_WIN32__45, STR_WIN95__47,
    STR_WINDOWS__44, STR_X3J13__26, STR_X86__37, STRn_0, STRn_1, STRn_10,
    STRn_11, STRn_12, STRn_13, STRn_3, STRn_4, STRn_5, SYM_0_VALUES1;
  
  clObject clListTraced clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0, clSymbolFunctionValue(clCAR));
      return(clMapcar(L_0, clSymbolValue(clstarTRACE_DATAstar, clEOA),
                      clEOA)); } }
  
  clDeclareEnv(clTrace1_Lambda);
  static clObject clTrace1_Lambda clVdecl(_ap)
  { clUseEnv(clTrace1_Lambda);
    { clObject args;
      { clBeginParse(_ap); clSetq(args, clVargs(_ap)); clEndParse(_ap); }
      { clObject indent;
        clDbind(clstarTRACE_LEVELstar);
        clSetSymbolValueValue(clstarTRACE_LEVELstar,
                              cl1PLUS_FUNC(clSymbolValue(clstarTRACE_LEVELstar,
                                                         clEOA),
                                           clEOA));
        { clObject L_0;
          clSetq(L_0, clSymbolValue(clstarTRACE_LEVELstar, clEOA));
          clSetq(indent,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0,
                                   I_2,
                                   clEOA)); }
        { clObject L_3, L_0;
          clSetq(L_0, clSymbolValue(clstarTRACE_OUTPUTstar, clEOA));
          clSetq(L_3, clSymbolValue(clstarTRACE_LEVELstar, clEOA));
          clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                            L_0,
                            STRn_0,
                            indent,
                            L_3,
                            clEnv(0, *function_name__R1),
                            args,
                            clEOA); }
        { clObject values;
          { clMultipleValueCall(MVC);
            clSetq(MVC, clSymbolFunctionValue(clLIST));
            clApply(clEnv(1, *original), args, clEOA);
            clAccumulateValues(MVC);
            clSetq(values, clMultipleValueFuncall(MVC)); }
          { clObject L_3, L_0;
            clSetq(L_0, clSymbolValue(clstarTRACE_OUTPUTstar, clEOA));
            clSetq(L_3, clSymbolValue(clstarTRACE_LEVELstar, clEOA));
            clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                              L_0,
                              STRn_1,
                              indent,
                              L_3,
                              clEnv(0, *function_name__R1),
                              values,
                              clEOA); }
          clUnwindReturn(clValuesList(values, clEOA), 1); } } } }
  
  clObject clTrace1 clVdecl(_ap)
  { clObject function_names;
    { clBeginParse(_ap);
      clSetq(function_names,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_sublist411, function_name;
      clSetq(L_sublist411, function_names);
      clSetq(function_name, clCar(L_sublist411, clEOA));
      clLabel(l_ITERATE412);
      if (clTrue(clEndp(L_sublist411, clEOA)))
        return(clListTraced(clEOA));
      if (clTrue(clNot(clAssoc(function_name,
                               clSymbolValue(clstarTRACE_DATAstar,
                                             clEOA),
                               clEOA),
                       clEOA)))
        { clObject *original = clMakeBinding(),
          *function_name__R1 = clMakeBinding();
          clSetq(*original, clFdefinition(function_name, clEOA));
          clSetq(*function_name__R1, function_name);
          clSetSymbolValueValue(clstarTRACE_DATAstar,
                                clAcons(*function_name__R1,
                                        *original,
                                        clSymbolValue(clstarTRACE_DATAstar,
                                                      clEOA),
                                        clEOA));
          { clObject L_arg414, L_value413;
            clSetq(L_arg414, *function_name__R1);
            clSetq(L_value413,
                   clMakeClosure(2,
                                 clTrace1_Lambda,
                                 &clEnvHook(clTrace1_Lambda),
                                 &*function_name__R1,
                                 &*original));
            cl_SETF_Fdefinition(L_value413, L_arg414, clEOA); } }
      { clObject L_0;
        clSetq(L_0, L_sublist411);
        clSetq(L_sublist411, clCdr(L_0, clEOA)); }
      { clObject L_0;
        clSetq(L_0, L_sublist411);
        clSetq(function_name, clCar(L_0, clEOA)); }
      goto l_ITERATE412; } }
  
  static clObject clUntrace1_Untrace0 clVdecl(_ap)
  { clObject pair;
    { clBeginParse(_ap);
      clSetq(pair,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_arg416, L_value415;
      { clObject L_0;
        clSetq(L_0, pair);
        clSetq(L_arg416, clCar(L_0, clEOA)); }
      { clObject L_0;
        clSetq(L_0, pair);
        clSetq(L_value415, clCdr(L_0, clEOA)); }
      return(cl_SETF_Fdefinition(L_value415, L_arg416, clEOA)); } }
  
  clObject clUntrace1 clVdecl(_ap)
  { clObject function_names;
    { clBeginParse(_ap);
      clSetq(function_names,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject _Untrace0_;
      clSetq(_Untrace0_,
             clMakeClosure(0, clUntrace1_Untrace0, clNULL_HOOK));
      if (clTrue(function_names))
        { clObject L_sublist417, function_name;
          clSetq(L_sublist417, function_names);
          clSetq(function_name, clCar(L_sublist417, clEOA));
          clLabel(l_ITERATE418);
          if (clTrue(clEndp(L_sublist417, clEOA)))
            return(clListTraced(clEOA));
          { clObject pair;
            { clObject L_1;
              clSetq(L_1, clSymbolValue(clstarTRACE_DATAstar, clEOA));
              clSetq(pair,
                     clFind(function_name,
                            L_1,
                            keyKEY,
                            clSymbolFunctionValue(clCAR),
                            clEOA)); }
            if (clTrue(pair))
              { clFuncallFunction(_Untrace0_, pair, clEOA);
                { clObject L_1;
                  clSetq(L_1,
                         clSymbolValue(clstarTRACE_DATAstar, clEOA));
                  clSetSymbolValueValue(clstarTRACE_DATAstar,
                                        clDelete(function_name,
                                                 L_1,
                                                 keyKEY,
                                                 clSymbolFunctionValue(clCAR),
                                                 clEOA)); } } }
          { clObject L_0;
            clSetq(L_0, L_sublist417);
            clSetq(L_sublist417, clCdr(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_sublist417);
            clSetq(function_name, clCar(L_0, clEOA)); }
          goto l_ITERATE418; }
      else
        { clObject L_sublist419, pair;
          clSetq(L_sublist419,
                 clSymbolValue(clstarTRACE_DATAstar, clEOA));
          clSetq(pair, clCar(L_sublist419, clEOA));
          clLabel(l_ITERATE420);
          if (clTrue(clEndp(L_sublist419, clEOA)))
            return(clValues1(clSetSymbolValueValue(clstarTRACE_DATAstar,
                                                   clNIL)));
          clFuncallFunction(_Untrace0_, pair, clEOA);
          { clObject L_0;
            clSetq(L_0, L_sublist419);
            clSetq(L_sublist419, clCdr(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_sublist419);
            clSetq(pair, clCar(L_0, clEOA)); }
          goto l_ITERATE420; } } }
  
  clObject clTrace clVdecl(_ap)
  { clObject L_form, L_ignored, function_names;
    { clBeginParse(_ap);
      clSetq(L_form,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(L_ignored,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      { clObject L_0;
        clSetq(L_0, L_form);
        clSetq(L_form, clCdr(L_0, clEOA)); }
      clSetq(function_names, L_form);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clList(clTRACE1, clList(clQUOTE, function_names, clEOA),
                  clEOA)); }
  
  clObject clUntrace clVdecl(_ap)
  { clObject L_form, L_ignored, function_names;
    { clBeginParse(_ap);
      clSetq(L_form,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(L_ignored,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      { clObject L_0;
        clSetq(L_0, L_form);
        clSetq(L_form, clCdr(L_0, clEOA)); }
      clSetq(function_names, L_form);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clList(clUNTRACE1, clList(clQUOTE, function_names, clEOA),
                  clEOA)); }
  
  clObject clEndTime clVdecl(_ap)
  { clObject real_start, run_start, heap_start;
    { clBeginParse(_ap);
      clSetq(real_start,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(run_start,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      clSetq(heap_start,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_3, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject real_end, run_end, heap_end;
      clSetq(real_end, clRealTime(clNIL, clEOA));
      clSetq(run_end, clRunTime(clEOA));
      clSetq(heap_end, clRoom(clNIL, clEOA));
      { clObject L_2, L_0;
        clSetq(L_0, clSymbolValue(clstarTRACE_OUTPUTstar, clEOA));
        { clObject L_0__R1;
          { clObject L_1__R2, L_0__R2;
            clSetq(L_0__R2, clIntInteger(clObjectWord(real_end)));
            { int L_0__R3;
              { clObject L_0__R4;
                clSetq(L_0__R4, real_start);
                L_0__R3 = clObjectWord(L_0__R4); }
              clSetq(L_1__R2, clIntInteger(L_0__R3)); }
            clSetq(L_0__R1,
                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                     L_0__R2,
                                     L_1__R2,
                                     clEOA)); }
          clSetq(L_2,
                 clFuncallFunction(clSymbolFunctionValue(clDIV),
                                   L_0__R1,
                                   clSymbolValue(clINTERNAL_TIME_UNITS_PER_SECOND,
                                                 clEOA),
                                   clEOA)); }
        clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                          L_0,
                          STRn_3,
                          L_2,
                          clEOA); }
      { clObject L_2, L_0;
        clSetq(L_0, clSymbolValue(clstarTRACE_OUTPUTstar, clEOA));
        { clObject L_0__R1;
          { clObject L_1__R2, L_0__R2;
            clSetq(L_0__R2, clIntInteger(clObjectWord(run_end)));
            { int L_0__R3;
              { clObject L_0__R4;
                clSetq(L_0__R4, run_start);
                L_0__R3 = clObjectWord(L_0__R4); }
              clSetq(L_1__R2, clIntInteger(L_0__R3)); }
            clSetq(L_0__R1,
                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                     L_0__R2,
                                     L_1__R2,
                                     clEOA)); }
          clSetq(L_2,
                 clFuncallFunction(clSymbolFunctionValue(clDIV),
                                   L_0__R1,
                                   clSymbolValue(clINTERNAL_TIME_UNITS_PER_SECOND,
                                                 clEOA),
                                   clEOA)); }
        clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                          L_0,
                          STRn_4,
                          L_2,
                          clEOA); }
      { clObject L_2, L_0;
        clSetq(L_0, clSymbolValue(clstarTRACE_OUTPUTstar, clEOA));
        { clObject L_1__R1;
          clSetq(L_1__R1, heap_start);
          clSetq(L_2,
                 clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                   heap_end,
                                   L_1__R1,
                                   clEOA)); }
        clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                          L_0,
                          STRn_5,
                          L_2,
                          clEOA); }
      return(clTerpri(clSymbolValue(clstarTRACE_OUTPUTstar, clEOA),
                      clEOA)); } }
  
  clObject clTime clVdecl(_ap)
  { clObject L_form, L_ignored, form;
    { clBeginParse(_ap);
      clSetq(L_form,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(L_ignored,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      { clObject L_0;
        clSetq(L_0, L_form);
        clSetq(L_form, clCdr(L_0, clEOA)); }
      if (clTrue(L_form))
        { clObject L_top427;
          { clObject L_0;
            clSetq(L_0, L_form);
            clSetq(L_top427, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form);
            clSetq(L_form, clCdr(L_0, clEOA)); }
          clSetq(form, L_top427); }
      else clSetq(form, clMissingArgs(I_1, clEOA));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    if (clTrue(L_form))
      { clObject L_0; clSetq(L_0, L_form); clExtraArgs(L_0, clEOA); }
    { clObject L_2;
      { clObject L_1__R1;
        clSetq(L_1__R1, form);
        clSetq(L_2,
               clListSTAR(clMULTIPLE_VALUE_PROG1,
                          L_1__R1,
                          CONS_13,
                          clEOA)); }
      return(clList(clLET, CONS_0, L_2, clEOA)); } }
  
  clObject clDescribe clVdecl(_ap)
  { clObject x, stream;
    { clBeginParse(_ap);
      clSetq(x, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(stream, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_1, L_0;
      clSetq(L_0, x);
      { clObject L_0__R1;
        clSetq(L_0__R1, stream);
        clSetq(L_1, clOutputStream(L_0__R1, clEOA)); }
      clFuncallFunction(clSymbolFunctionValue(clDESCRIBE_OBJECT),
                        L_0,
                        L_1,
                        clEOA); }
    return(clValues(clEOA)); }
  
  clDeclareEnv(clInspect_Lambda);
  static clObject clInspect_Lambda clVdecl(_ap)
  { clUseEnv(clInspect_Lambda);
    { clObject temp;
      { clBeginParse(_ap); clSetq(temp, clVargs(_ap)); clEndParse(_ap); }
      clSetSymbolValueValue(SYM_0_VALUES1, temp);
      clGo(clEnv(0, l_G2), 1);
      return(clValues1(clNIL)); } }
  
  static clObject clInspect_Lambda_r1 clVdecl(_ap)
  { clObject s;
    { clBeginParse(_ap);
      clSetq(s, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0, s);
      return(clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                               L_0,
                               STR_Quit_inspectordot__8,
                               clEOA)); } }
  
  clObject clInspect clVdecl(_ap)
  { volatile clObject object;
    { clBeginParse(_ap);
      clSetq(object,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clBlock(l_RESTART_BIND0);
      if (clTrue(clReturned(l_RESTART_BIND0)))
        return(clSavedValue(l_RESTART_BIND0));
      else
        { clDbind(SYM_0_VALUES1);
          clSetSymbolValueValue(SYM_0_VALUES1, clNIL);
          { clTagbody(TAGBODY);
            clDefineLabel(l_G2, 1);
            clTagbodyStart(TAGBODY);
            { clObject STARrestartsSTAR;
              { clObject L_0;
                { clObject L_0__R1;
                  { clObject L_1__R1;
                    clSetq(L_1__R1,
                           clMakeClosure(1,
                                         clInspect_Lambda,
                                         &clEnvHook(clInspect_Lambda),
                                         &TAGBODY));
                    clSetq(L_0__R1,
                           clMakeRestart(clABORT,
                                         L_1__R1,
                                         keyREPORT_FUNCTION,
                                         clMakeClosure(0,
                                                       clInspect_Lambda_r1,
                                                       clNULL_HOOK),
                                         clEOA)); }
                  clSetq(L_0, clList(L_0__R1, clEOA)); }
                clSetq(STARrestartsSTAR,
                       clCons(L_0,
                              clSymbolValue(clstarRESTARTSstar, clEOA),
                              clEOA)); }
              clDbind(clstarRESTARTSstar);
              clSetSymbolValueValue(clstarRESTARTSstar,
                                    STARrestartsSTAR);
              { clObject L_0;
                clSetq(L_0, object);
                clReturnFrom(l_RESTART_BIND0,
                             clFuncallFunction(clSymbolFunctionValue(clINSPECT_OBJECT),
                                               L_0,
                                               clSymbolValue(clstarDEBUG_IOstar,
                                                             clEOA),
                                               clEOA)); }
              clUnwind(1); }
            clLabel(l_G2);
            { clObject L_form428;
              clSetq(L_form428, clSymbolValue(SYM_0_VALUES1, clEOA));
              if (clTrue(L_form428)) clExtraArgs(L_form428, clEOA);
              clReturnFrom(l_RESTART_BIND0,
                           clValues(clNIL, clT, clEOA)); }
            clUnwindReturn(clValues1(clNIL), 1);
            clTagbodyEnd(TAGBODY); } } } }
  
  clObject clRoom clVdecl(_ap)
  { clObject amount;
    { clBeginParse(_ap);
      clSetq(amount, (_clVp(_ap) ? clVpop(_ap) : keyDEFAULT));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    if (clTrue(amount))
      { clObject L_values429, bytes, since, mem, limit;
        { clMultipleValueCall(MVC);
          clSetq(MVC, clSymbolFunctionValue(clLIST));
          clGcData();
          clAccumulateValues(MVC);
          clSetq(L_values429, clMultipleValueFuncall(MVC)); }
        clSetq(bytes, clCar(L_values429, clEOA));
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_values429);
            clSetq(L_0, clSetq(L_values429, clCdr(L_0__R1, clEOA))); }
          clSetq(since, clCar(L_0, clEOA)); }
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_values429);
            clSetq(L_0, clSetq(L_values429, clCdr(L_0__R1, clEOA))); }
          clSetq(mem, clCar(L_0, clEOA)); }
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_values429);
            clSetq(L_0, clSetq(L_values429, clCdr(L_0__R1, clEOA))); }
          clSetq(limit, clCar(L_0, clEOA)); }
        { clObject L_0;
          clSetq(L_0, clSymbolValue(clstarSTANDARD_OUTPUTstar, clEOA));
          clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                            L_0,
                            STRn_10,
                            bytes,
                            clEOA); }
        { clObject L_test__R1;
          { clObject L_0;
            clSetq(L_0, amount);
            clSetq(L_test__R1, clEq(L_0, clT, clEOA)); }
          if (clTrue(L_test__R1))
            { { clObject L_0;
                clSetq(L_0,
                       clSymbolValue(clstarSTANDARD_OUTPUTstar, clEOA));
                clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                                  L_0,
                                  STRn_11,
                                  since,
                                  clEOA); }
              { clObject L_0;
                clSetq(L_0,
                       clSymbolValue(clstarSTANDARD_OUTPUTstar, clEOA));
                clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                                  L_0,
                                  STRn_12,
                                  mem,
                                  limit,
                                  clEOA); } } }
        return(clValues(clEOA)); }
    else return(clGcData()); }
  
  clObject clEd clVdecl(_ap)
  { clObject x;
    { clBeginParse(_ap);
      clSetq(x, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clWarn(STRn_13, clEOA)); }
  
  clDeclareEnv(clApropos_l_NextSymbol13);
  static clObject clApropos_l_NextSymbol13 clVdecl(_ap)
  { clUseEnv(clApropos_l_NextSymbol13);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      { clObject index;
        clSetq(index, clNIL);
        clLabel(NEXT_LOOP);
        clSetq(index,
               (clTrue(clEnv(0, *L_table5)) ?
                clFirstNonEmptyIndex(clEnv(0, *L_table5),
                                     clEnv(1, *L_index7)) :
                clSymbolValue(clNOT_FOUND, clEOA)));
        { clObject L_test;
          { clObject L_0;
            clSetq(L_0, index);
            clSetq(L_test,
                   clFuncallFunction(clSymbolFunctionValue(clLT),
                                     L_0,
                                     clEnv(2, *L_limit6),
                                     clEOA)); }
          if (clTrue(L_test))
            { clObject symbol;
              { clObject L_1;
                clSetq(L_1, index);
                clSetq(symbol,
                       clHashTableValue(clEnv(0, *L_table5), L_1)); }
              { clObject L_0;
                clSetq(L_0, index);
                clSetq(clEnv(1, *L_index7), cl1PLUS_FUNC(L_0, clEOA)); }
              { clObject L_test__R1;
                { clObject L_0;
                  if (_clEq(clEnv(3, *L_acessibility12), keyINHERITED))
                    { clObject L_values432, L_ignore_431, L_keeper430;
                      { clMultipleValueCall(MVC);
                        clSetq(MVC, clSymbolFunctionValue(clLIST));
                        { clObject L_0__R1;
                          clSetq(L_0__R1, clSymbolName(symbol, clEOA));
                          clFuncallFunction(clSymbolFunctionValue(clGETHASH),
                                            L_0__R1,
                                            clPackageInternals(clEnv(4, *L_package9),
                                                               clEOA),
                                            clEOA); }
                        clAccumulateValues(MVC);
                        clSetq(L_values432,
                               clMultipleValueFuncall(MVC)); }
                      clSetq(L_ignore_431, clCar(L_values432, clEOA));
                      { clObject L_0__R1;
                        { clObject L_0__R2;
                          clSetq(L_0__R2, L_values432);
                          clSetq(L_0__R1,
                                 clSetq(L_values432,
                                        clCdr(L_0__R2, clEOA))); }
                        clSetq(L_keeper430, clCar(L_0__R1, clEOA)); }
                      clSetq(L_0, L_keeper430); }
                  else clSetq(L_0, clNIL);
                  clSetq(L_test__R1, clNot(L_0, clEOA)); }
                if (clTrue(L_test__R1)) return(clValues1(symbol)); } }
          else if (clTrue(clNot(clFuncallFunction(clEnv(5, *_l_NextTable14_),
                                                  clEOA),
                                clEOA)))
            return(clValues1(clSymbolValue(clNOT_FOUND, clEOA))); }
        goto NEXT_LOOP;
        clLabel(END_LOOP);
        return(clValues1(clNIL)); } } }
  
  clDeclareEnv(clApropos_l_NextTable14);
  static clObject clApropos_l_NextTable14 clVdecl(_ap)
  { clUseEnv(clApropos_l_NextTable14);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      if (clTrue(clEnv(0, *L_remaining_uses11)))
        { { clObject L_0;
            { clObject L_top433;
              clSetq(L_top433,
                     clCar(clEnv(0, *L_remaining_uses11), clEOA));
              clSetq(clEnv(0, *L_remaining_uses11),
                     clCdr(clEnv(0, *L_remaining_uses11), clEOA));
              clSetq(L_0, L_top433); }
            clSetq(clEnv(1, *L_table5),
                   clPackageExternals(L_0, clEOA)); }
          clSetq(clEnv(2, *L_index7), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table5));
            return(clValues1(clSetq(clEnv(3, *L_limit6),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(4, *L_remaining_types10)))
        { { clObject L_g434;
            { clObject L_top435;
              clSetq(L_top435,
                     clCar(clEnv(4, *L_remaining_types10), clEOA));
              clSetq(clEnv(4, *L_remaining_types10),
                     clCdr(clEnv(4, *L_remaining_types10), clEOA));
              clSetq(L_g434,
                     clSetq(clEnv(5, *L_acessibility12), L_top435)); }
            if (_clEq(L_g434, keyINTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package9));
                clSetq(clEnv(1, *L_table5),
                       clPackageInternals(L_0, clEOA)); }
            else if (_clEq(L_g434, keyEXTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package9));
                clSetq(clEnv(1, *L_table5),
                       clPackageExternals(L_0, clEOA)); }
            else if (_clEq(L_g434, keyINHERITED))
              { { clObject L_0;
                  clSetq(L_0, clEnv(6, *L_package9));
                  clSetq(clEnv(0, *L_remaining_uses11),
                         clPackageUses(L_0, clEOA)); }
                return(clFuncallFunction(clEnv(7, *_l_NextTable14_),
                                         clEOA)); }
            else
              clError(clTYPE_ERROR, keyDATUM, L_g434, keyEXPECTED_TYPE,
                      CONS_18, clEOA); }
          clSetq(clEnv(2, *L_index7), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table5));
            return(clValues1(clSetq(clEnv(3, *L_limit6),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(8, *L_package_list8)))
        { clSetq(clEnv(4, *L_remaining_types10), CONS_22);
          { clObject L_0;
            { clObject L_top437;
              clSetq(L_top437, clCar(clEnv(8, *L_package_list8), clEOA));
              clSetq(clEnv(8, *L_package_list8),
                     clCdr(clEnv(8, *L_package_list8), clEOA));
              clSetq(L_0, L_top437); }
            clSetq(clEnv(6, *L_package9), clPkg(L_0, clEOA)); }
          return(clFuncallFunction(clEnv(7, *_l_NextTable14_), clEOA)); }
      else return(clValues1(clNIL)); } }
  
  clDeclareEnv(clApropos_l_NextSymbol26);
  static clObject clApropos_l_NextSymbol26 clVdecl(_ap)
  { clUseEnv(clApropos_l_NextSymbol26);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      { clObject index;
        clSetq(index, clNIL);
        clLabel(NEXT_LOOP);
        clSetq(index,
               (clTrue(clEnv(0, *L_table18)) ?
                clFirstNonEmptyIndex(clEnv(0, *L_table18),
                                     clEnv(1, *L_index20)) :
                clSymbolValue(clNOT_FOUND, clEOA)));
        { clObject L_test;
          { clObject L_0;
            clSetq(L_0, index);
            clSetq(L_test,
                   clFuncallFunction(clSymbolFunctionValue(clLT),
                                     L_0,
                                     clEnv(2, *L_limit19),
                                     clEOA)); }
          if (clTrue(L_test))
            { clObject symbol;
              { clObject L_1;
                clSetq(L_1, index);
                clSetq(symbol,
                       clHashTableValue(clEnv(0, *L_table18), L_1)); }
              { clObject L_0;
                clSetq(L_0, index);
                clSetq(clEnv(1, *L_index20), cl1PLUS_FUNC(L_0, clEOA)); }
              { clObject L_test__R1;
                { clObject L_0;
                  if (_clEq(clEnv(3, *L_acessibility25), keyINHERITED))
                    { clObject L_values443, L_ignore_442, L_keeper441;
                      { clMultipleValueCall(MVC);
                        clSetq(MVC, clSymbolFunctionValue(clLIST));
                        { clObject L_0__R1;
                          clSetq(L_0__R1, clSymbolName(symbol, clEOA));
                          clFuncallFunction(clSymbolFunctionValue(clGETHASH),
                                            L_0__R1,
                                            clPackageInternals(clEnv(4, *L_package22),
                                                               clEOA),
                                            clEOA); }
                        clAccumulateValues(MVC);
                        clSetq(L_values443,
                               clMultipleValueFuncall(MVC)); }
                      clSetq(L_ignore_442, clCar(L_values443, clEOA));
                      { clObject L_0__R1;
                        { clObject L_0__R2;
                          clSetq(L_0__R2, L_values443);
                          clSetq(L_0__R1,
                                 clSetq(L_values443,
                                        clCdr(L_0__R2, clEOA))); }
                        clSetq(L_keeper441, clCar(L_0__R1, clEOA)); }
                      clSetq(L_0, L_keeper441); }
                  else clSetq(L_0, clNIL);
                  clSetq(L_test__R1, clNot(L_0, clEOA)); }
                if (clTrue(L_test__R1)) return(clValues1(symbol)); } }
          else if (clTrue(clNot(clFuncallFunction(clEnv(5, *_l_NextTable27_),
                                                  clEOA),
                                clEOA)))
            return(clValues1(clSymbolValue(clNOT_FOUND, clEOA))); }
        goto NEXT_LOOP;
        clLabel(END_LOOP);
        return(clValues1(clNIL)); } } }
  
  clDeclareEnv(clApropos_l_NextTable27);
  static clObject clApropos_l_NextTable27 clVdecl(_ap)
  { clUseEnv(clApropos_l_NextTable27);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      if (clTrue(clEnv(0, *L_remaining_uses24)))
        { { clObject L_0;
            { clObject L_top444;
              clSetq(L_top444,
                     clCar(clEnv(0, *L_remaining_uses24), clEOA));
              clSetq(clEnv(0, *L_remaining_uses24),
                     clCdr(clEnv(0, *L_remaining_uses24), clEOA));
              clSetq(L_0, L_top444); }
            clSetq(clEnv(1, *L_table18),
                   clPackageExternals(L_0, clEOA)); }
          clSetq(clEnv(2, *L_index20), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table18));
            return(clValues1(clSetq(clEnv(3, *L_limit19),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(4, *L_remaining_types23)))
        { { clObject L_g445;
            { clObject L_top446;
              clSetq(L_top446,
                     clCar(clEnv(4, *L_remaining_types23), clEOA));
              clSetq(clEnv(4, *L_remaining_types23),
                     clCdr(clEnv(4, *L_remaining_types23), clEOA));
              clSetq(L_g445,
                     clSetq(clEnv(5, *L_acessibility25), L_top446)); }
            if (_clEq(L_g445, keyINTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package22));
                clSetq(clEnv(1, *L_table18),
                       clPackageInternals(L_0, clEOA)); }
            else if (_clEq(L_g445, keyEXTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package22));
                clSetq(clEnv(1, *L_table18),
                       clPackageExternals(L_0, clEOA)); }
            else if (_clEq(L_g445, keyINHERITED))
              { { clObject L_0;
                  clSetq(L_0, clEnv(6, *L_package22));
                  clSetq(clEnv(0, *L_remaining_uses24),
                         clPackageUses(L_0, clEOA)); }
                return(clFuncallFunction(clEnv(7, *_l_NextTable27_),
                                         clEOA)); }
            else
              clError(clTYPE_ERROR, keyDATUM, L_g445, keyEXPECTED_TYPE,
                      CONS_18, clEOA); }
          clSetq(clEnv(2, *L_index20), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table18));
            return(clValues1(clSetq(clEnv(3, *L_limit19),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(8, *L_package_list21)))
        { clSetq(clEnv(4, *L_remaining_types23), CONS_24);
          { clObject L_0;
            { clObject L_top448;
              clSetq(L_top448,
                     clCar(clEnv(8, *L_package_list21), clEOA));
              clSetq(clEnv(8, *L_package_list21),
                     clCdr(clEnv(8, *L_package_list21), clEOA));
              clSetq(L_0, L_top448); }
            clSetq(clEnv(6, *L_package22), clPkg(L_0, clEOA)); }
          return(clFuncallFunction(clEnv(7, *_l_NextTable27_), clEOA)); }
      else return(clValues1(clNIL)); } }
  
  clObject clApropos clVdecl(_ap)
  { clObject string, package;
    { clBeginParse(_ap);
      clSetq(string,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(package, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0, string);
      clSetq(string, clString(L_0, clEOA)); }
    if (clTrue(package))
      { clObject *L_package_list8 = clMakeBinding(),
        *L_package9 = clMakeBinding(),
        *L_acessibility12 = clMakeBinding(),
        *L_remaining_uses11 = clMakeBinding(),
        *L_remaining_types10 = clMakeBinding(),
        *L_table5 = clMakeBinding(), *L_limit6 = clMakeBinding(),
        *L_index7 = clMakeBinding();
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, package);
            clSetq(L_0, clPkg(L_0__R1, clEOA)); }
          clSetq(*L_package_list8, clListArg(L_0, clEOA)); }
        clSetq(*L_package9, clNIL);
        clSetq(*L_acessibility12, clNIL);
        clSetq(*L_remaining_uses11, clNIL);
        clSetq(*L_remaining_types10, clNIL);
        clSetq(*L_table5, clNIL);
        clSetq(*L_limit6, I_0);
        clSetq(*L_index7, I_0);
        { clObject *_l_NextTable14_ = clMakeBinding(), _l_NextSymbol13_;
          clSetq(_l_NextSymbol13_,
                 clMakeClosure(6,
                               clApropos_l_NextSymbol13,
                               &clEnvHook(clApropos_l_NextSymbol13),
                               &*L_table5,
                               &*L_index7,
                               &*L_limit6,
                               &*L_acessibility12,
                               &*L_package9,
                               &*_l_NextTable14_));
          clSetq(*_l_NextTable14_,
                 clMakeClosure(9,
                               clApropos_l_NextTable14,
                               &clEnvHook(clApropos_l_NextTable14),
                               &*L_remaining_uses11,
                               &*L_table5,
                               &*L_index7,
                               &*L_limit6,
                               &*L_remaining_types10,
                               &*L_acessibility12,
                               &*L_package9,
                               &*_l_NextTable14_,
                               &*L_package_list8));
          if (clTrue(*L_package_list8))
            clFuncallFunction(*_l_NextTable14_, clEOA);
          clLabel(l_LOOP15);
          { clObject L_values438, L_more4, symbol;
            { clMultipleValueCall(MVC);
              clSetq(MVC, clSymbolFunctionValue(clLIST));
              { clObject symbol__R1;
                clSetq(symbol__R1,
                       clFuncallFunction(_l_NextSymbol13_, clEOA));
                if (clTrue(clNot(clEq(symbol__R1,
                                      clSymbolValue(clNOT_FOUND, clEOA),
                                      clEOA),
                                 clEOA)))
                  { clObject L_3, L_2;
                    clSetq(L_2, *L_acessibility12);
                    clSetq(L_3, *L_package9);
                    clValues(clT, symbol__R1, L_2, L_3, clEOA); }
                else clValues1(clNIL); }
              clAccumulateValues(MVC);
              clSetq(L_values438, clMultipleValueFuncall(MVC)); }
            clSetq(L_more4, clCar(L_values438, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values438);
                clSetq(L_0,
                       clSetq(L_values438, clCdr(L_0__R1, clEOA))); }
              clSetq(symbol, clCar(L_0, clEOA)); }
            if (clTrue(clNot(L_more4, clEOA))) clLocalReturn(NIL);
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, string);
                clSetq(L_test__R1,
                       clSearch(L_0, clString(symbol, clEOA), clEOA)); }
              if (clTrue(L_test__R1)) clDescribe(symbol, clEOA); } }
          goto l_LOOP15;
          clBlockEnd(NIL); } }
    else
      { clObject *L_package_list21 = clMakeBinding(),
        *L_package22 = clMakeBinding(),
        *L_acessibility25 = clMakeBinding(),
        *L_remaining_uses24 = clMakeBinding(),
        *L_remaining_types23 = clMakeBinding(),
        *L_table18 = clMakeBinding(), *L_limit19 = clMakeBinding(),
        *L_index20 = clMakeBinding();
        clSetq(*L_package_list21,
               clListArg(clListAllPackages(clEOA), clEOA));
        clSetq(*L_package22, clNIL);
        clSetq(*L_acessibility25, clNIL);
        clSetq(*L_remaining_uses24, clNIL);
        clSetq(*L_remaining_types23, clNIL);
        clSetq(*L_table18, clNIL);
        clSetq(*L_limit19, I_0);
        clSetq(*L_index20, I_0);
        { clObject *_l_NextTable27_ = clMakeBinding(), _l_NextSymbol26_;
          clSetq(_l_NextSymbol26_,
                 clMakeClosure(6,
                               clApropos_l_NextSymbol26,
                               &clEnvHook(clApropos_l_NextSymbol26),
                               &*L_table18,
                               &*L_index20,
                               &*L_limit19,
                               &*L_acessibility25,
                               &*L_package22,
                               &*_l_NextTable27_));
          clSetq(*_l_NextTable27_,
                 clMakeClosure(9,
                               clApropos_l_NextTable27,
                               &clEnvHook(clApropos_l_NextTable27),
                               &*L_remaining_uses24,
                               &*L_table18,
                               &*L_index20,
                               &*L_limit19,
                               &*L_remaining_types23,
                               &*L_acessibility25,
                               &*L_package22,
                               &*_l_NextTable27_,
                               &*L_package_list21));
          if (clTrue(*L_package_list21))
            clFuncallFunction(*_l_NextTable27_, clEOA);
          clLabel(l_LOOP28);
          { clObject L_values449, L_more17, symbol;
            { clMultipleValueCall(MVC__r1);
              clSetq(MVC__r1, clSymbolFunctionValue(clLIST));
              { clObject symbol__R1;
                clSetq(symbol__R1,
                       clFuncallFunction(_l_NextSymbol26_, clEOA));
                if (clTrue(clNot(clEq(symbol__R1,
                                      clSymbolValue(clNOT_FOUND, clEOA),
                                      clEOA),
                                 clEOA)))
                  { clObject L_3, L_2;
                    clSetq(L_2, *L_acessibility25);
                    clSetq(L_3, *L_package22);
                    clValues(clT, symbol__R1, L_2, L_3, clEOA); }
                else clValues1(clNIL); }
              clAccumulateValues(MVC__r1);
              clSetq(L_values449, clMultipleValueFuncall(MVC__r1)); }
            clSetq(L_more17, clCar(L_values449, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values449);
                clSetq(L_0,
                       clSetq(L_values449, clCdr(L_0__R1, clEOA))); }
              clSetq(symbol, clCar(L_0, clEOA)); }
            if (clTrue(clNot(L_more17, clEOA))) clLocalReturn(NIL__r1);
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, string);
                clSetq(L_test__R1,
                       clSearch(L_0, clString(symbol, clEOA), clEOA)); }
              if (clTrue(L_test__R1)) clDescribe(symbol, clEOA); } }
          goto l_LOOP28;
          clBlockEnd(NIL__r1); } }
    return(clValues(clEOA)); }
  
  clDeclareEnv(clAproposList_l_NextSymbol39);
  static clObject clAproposList_l_NextSymbol39 clVdecl(_ap)
  { clUseEnv(clAproposList_l_NextSymbol39);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      { clObject index;
        clSetq(index, clNIL);
        clLabel(NEXT_LOOP);
        clSetq(index,
               (clTrue(clEnv(0, *L_table31)) ?
                clFirstNonEmptyIndex(clEnv(0, *L_table31),
                                     clEnv(1, *L_index33)) :
                clSymbolValue(clNOT_FOUND, clEOA)));
        { clObject L_test;
          { clObject L_0;
            clSetq(L_0, index);
            clSetq(L_test,
                   clFuncallFunction(clSymbolFunctionValue(clLT),
                                     L_0,
                                     clEnv(2, *L_limit32),
                                     clEOA)); }
          if (clTrue(L_test))
            { clObject symbol;
              { clObject L_1;
                clSetq(L_1, index);
                clSetq(symbol,
                       clHashTableValue(clEnv(0, *L_table31), L_1)); }
              { clObject L_0;
                clSetq(L_0, index);
                clSetq(clEnv(1, *L_index33), cl1PLUS_FUNC(L_0, clEOA)); }
              { clObject L_test__R1;
                { clObject L_0;
                  if (_clEq(clEnv(3, *L_acessibility38), keyINHERITED))
                    { clObject L_values454, L_ignore_453, L_keeper452;
                      { clMultipleValueCall(MVC);
                        clSetq(MVC, clSymbolFunctionValue(clLIST));
                        { clObject L_0__R1;
                          clSetq(L_0__R1, clSymbolName(symbol, clEOA));
                          clFuncallFunction(clSymbolFunctionValue(clGETHASH),
                                            L_0__R1,
                                            clPackageInternals(clEnv(4, *L_package35),
                                                               clEOA),
                                            clEOA); }
                        clAccumulateValues(MVC);
                        clSetq(L_values454,
                               clMultipleValueFuncall(MVC)); }
                      clSetq(L_ignore_453, clCar(L_values454, clEOA));
                      { clObject L_0__R1;
                        { clObject L_0__R2;
                          clSetq(L_0__R2, L_values454);
                          clSetq(L_0__R1,
                                 clSetq(L_values454,
                                        clCdr(L_0__R2, clEOA))); }
                        clSetq(L_keeper452, clCar(L_0__R1, clEOA)); }
                      clSetq(L_0, L_keeper452); }
                  else clSetq(L_0, clNIL);
                  clSetq(L_test__R1, clNot(L_0, clEOA)); }
                if (clTrue(L_test__R1)) return(clValues1(symbol)); } }
          else if (clTrue(clNot(clFuncallFunction(clEnv(5, *_l_NextTable40_),
                                                  clEOA),
                                clEOA)))
            return(clValues1(clSymbolValue(clNOT_FOUND, clEOA))); }
        goto NEXT_LOOP;
        clLabel(END_LOOP);
        return(clValues1(clNIL)); } } }
  
  clDeclareEnv(clAproposList_l_NextTable40);
  static clObject clAproposList_l_NextTable40 clVdecl(_ap)
  { clUseEnv(clAproposList_l_NextTable40);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      if (clTrue(clEnv(0, *L_remaining_uses37)))
        { { clObject L_0;
            { clObject L_top455;
              clSetq(L_top455,
                     clCar(clEnv(0, *L_remaining_uses37), clEOA));
              clSetq(clEnv(0, *L_remaining_uses37),
                     clCdr(clEnv(0, *L_remaining_uses37), clEOA));
              clSetq(L_0, L_top455); }
            clSetq(clEnv(1, *L_table31),
                   clPackageExternals(L_0, clEOA)); }
          clSetq(clEnv(2, *L_index33), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table31));
            return(clValues1(clSetq(clEnv(3, *L_limit32),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(4, *L_remaining_types36)))
        { { clObject L_g456;
            { clObject L_top457;
              clSetq(L_top457,
                     clCar(clEnv(4, *L_remaining_types36), clEOA));
              clSetq(clEnv(4, *L_remaining_types36),
                     clCdr(clEnv(4, *L_remaining_types36), clEOA));
              clSetq(L_g456,
                     clSetq(clEnv(5, *L_acessibility38), L_top457)); }
            if (_clEq(L_g456, keyINTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package35));
                clSetq(clEnv(1, *L_table31),
                       clPackageInternals(L_0, clEOA)); }
            else if (_clEq(L_g456, keyEXTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package35));
                clSetq(clEnv(1, *L_table31),
                       clPackageExternals(L_0, clEOA)); }
            else if (_clEq(L_g456, keyINHERITED))
              { { clObject L_0;
                  clSetq(L_0, clEnv(6, *L_package35));
                  clSetq(clEnv(0, *L_remaining_uses37),
                         clPackageUses(L_0, clEOA)); }
                return(clFuncallFunction(clEnv(7, *_l_NextTable40_),
                                         clEOA)); }
            else
              clError(clTYPE_ERROR, keyDATUM, L_g456, keyEXPECTED_TYPE,
                      CONS_18, clEOA); }
          clSetq(clEnv(2, *L_index33), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table31));
            return(clValues1(clSetq(clEnv(3, *L_limit32),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(8, *L_package_list34)))
        { clSetq(clEnv(4, *L_remaining_types36), CONS_22);
          { clObject L_0;
            { clObject L_top459;
              clSetq(L_top459,
                     clCar(clEnv(8, *L_package_list34), clEOA));
              clSetq(clEnv(8, *L_package_list34),
                     clCdr(clEnv(8, *L_package_list34), clEOA));
              clSetq(L_0, L_top459); }
            clSetq(clEnv(6, *L_package35), clPkg(L_0, clEOA)); }
          return(clFuncallFunction(clEnv(7, *_l_NextTable40_), clEOA)); }
      else return(clValues1(clNIL)); } }
  
  clDeclareEnv(clAproposList_l_NextSymbol52);
  static clObject clAproposList_l_NextSymbol52 clVdecl(_ap)
  { clUseEnv(clAproposList_l_NextSymbol52);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      { clObject index;
        clSetq(index, clNIL);
        clLabel(NEXT_LOOP);
        clSetq(index,
               (clTrue(clEnv(0, *L_table44)) ?
                clFirstNonEmptyIndex(clEnv(0, *L_table44),
                                     clEnv(1, *L_index46)) :
                clSymbolValue(clNOT_FOUND, clEOA)));
        { clObject L_test;
          { clObject L_0;
            clSetq(L_0, index);
            clSetq(L_test,
                   clFuncallFunction(clSymbolFunctionValue(clLT),
                                     L_0,
                                     clEnv(2, *L_limit45),
                                     clEOA)); }
          if (clTrue(L_test))
            { clObject symbol;
              { clObject L_1;
                clSetq(L_1, index);
                clSetq(symbol,
                       clHashTableValue(clEnv(0, *L_table44), L_1)); }
              { clObject L_0;
                clSetq(L_0, index);
                clSetq(clEnv(1, *L_index46), cl1PLUS_FUNC(L_0, clEOA)); }
              { clObject L_test__R1;
                { clObject L_0;
                  if (_clEq(clEnv(3, *L_acessibility51), keyINHERITED))
                    { clObject L_values465, L_ignore_464, L_keeper463;
                      { clMultipleValueCall(MVC);
                        clSetq(MVC, clSymbolFunctionValue(clLIST));
                        { clObject L_0__R1;
                          clSetq(L_0__R1, clSymbolName(symbol, clEOA));
                          clFuncallFunction(clSymbolFunctionValue(clGETHASH),
                                            L_0__R1,
                                            clPackageInternals(clEnv(4, *L_package48),
                                                               clEOA),
                                            clEOA); }
                        clAccumulateValues(MVC);
                        clSetq(L_values465,
                               clMultipleValueFuncall(MVC)); }
                      clSetq(L_ignore_464, clCar(L_values465, clEOA));
                      { clObject L_0__R1;
                        { clObject L_0__R2;
                          clSetq(L_0__R2, L_values465);
                          clSetq(L_0__R1,
                                 clSetq(L_values465,
                                        clCdr(L_0__R2, clEOA))); }
                        clSetq(L_keeper463, clCar(L_0__R1, clEOA)); }
                      clSetq(L_0, L_keeper463); }
                  else clSetq(L_0, clNIL);
                  clSetq(L_test__R1, clNot(L_0, clEOA)); }
                if (clTrue(L_test__R1)) return(clValues1(symbol)); } }
          else if (clTrue(clNot(clFuncallFunction(clEnv(5, *_l_NextTable53_),
                                                  clEOA),
                                clEOA)))
            return(clValues1(clSymbolValue(clNOT_FOUND, clEOA))); }
        goto NEXT_LOOP;
        clLabel(END_LOOP);
        return(clValues1(clNIL)); } } }
  
  clDeclareEnv(clAproposList_l_NextTable53);
  static clObject clAproposList_l_NextTable53 clVdecl(_ap)
  { clUseEnv(clAproposList_l_NextTable53);
    { { clBeginParse(_ap);
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      if (clTrue(clEnv(0, *L_remaining_uses50)))
        { { clObject L_0;
            { clObject L_top466;
              clSetq(L_top466,
                     clCar(clEnv(0, *L_remaining_uses50), clEOA));
              clSetq(clEnv(0, *L_remaining_uses50),
                     clCdr(clEnv(0, *L_remaining_uses50), clEOA));
              clSetq(L_0, L_top466); }
            clSetq(clEnv(1, *L_table44),
                   clPackageExternals(L_0, clEOA)); }
          clSetq(clEnv(2, *L_index46), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table44));
            return(clValues1(clSetq(clEnv(3, *L_limit45),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(4, *L_remaining_types49)))
        { { clObject L_g467;
            { clObject L_top468;
              clSetq(L_top468,
                     clCar(clEnv(4, *L_remaining_types49), clEOA));
              clSetq(clEnv(4, *L_remaining_types49),
                     clCdr(clEnv(4, *L_remaining_types49), clEOA));
              clSetq(L_g467,
                     clSetq(clEnv(5, *L_acessibility51), L_top468)); }
            if (_clEq(L_g467, keyINTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package48));
                clSetq(clEnv(1, *L_table44),
                       clPackageInternals(L_0, clEOA)); }
            else if (_clEq(L_g467, keyEXTERNAL))
              { clObject L_0;
                clSetq(L_0, clEnv(6, *L_package48));
                clSetq(clEnv(1, *L_table44),
                       clPackageExternals(L_0, clEOA)); }
            else if (_clEq(L_g467, keyINHERITED))
              { { clObject L_0;
                  clSetq(L_0, clEnv(6, *L_package48));
                  clSetq(clEnv(0, *L_remaining_uses50),
                         clPackageUses(L_0, clEOA)); }
                return(clFuncallFunction(clEnv(7, *_l_NextTable53_),
                                         clEOA)); }
            else
              clError(clTYPE_ERROR, keyDATUM, L_g467, keyEXPECTED_TYPE,
                      CONS_18, clEOA); }
          clSetq(clEnv(2, *L_index46), I_0);
          { clObject L_0;
            clSetq(L_0, clEnv(1, *L_table44));
            return(clValues1(clSetq(clEnv(3, *L_limit45),
                                    clHashTableNBuckets(L_0,
                                                        clEOA)))); } }
      else if (clTrue(clEnv(8, *L_package_list47)))
        { clSetq(clEnv(4, *L_remaining_types49), CONS_24);
          { clObject L_0;
            { clObject L_top470;
              clSetq(L_top470,
                     clCar(clEnv(8, *L_package_list47), clEOA));
              clSetq(clEnv(8, *L_package_list47),
                     clCdr(clEnv(8, *L_package_list47), clEOA));
              clSetq(L_0, L_top470); }
            clSetq(clEnv(6, *L_package48), clPkg(L_0, clEOA)); }
          return(clFuncallFunction(clEnv(7, *_l_NextTable53_), clEOA)); }
      else return(clValues1(clNIL)); } }
  
  clObject clAproposList clVdecl(_ap)
  { clObject string, package, list;
    { clBeginParse(_ap);
      clSetq(string,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(package, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      clSetq(list, clNIL);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0, string);
      clSetq(string, clString(L_0, clEOA)); }
    if (clTrue(package))
      { clObject *L_package_list34 = clMakeBinding(),
        *L_package35 = clMakeBinding(),
        *L_acessibility38 = clMakeBinding(),
        *L_remaining_uses37 = clMakeBinding(),
        *L_remaining_types36 = clMakeBinding(),
        *L_table31 = clMakeBinding(), *L_limit32 = clMakeBinding(),
        *L_index33 = clMakeBinding();
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, package);
            clSetq(L_0, clPkg(L_0__R1, clEOA)); }
          clSetq(*L_package_list34, clListArg(L_0, clEOA)); }
        clSetq(*L_package35, clNIL);
        clSetq(*L_acessibility38, clNIL);
        clSetq(*L_remaining_uses37, clNIL);
        clSetq(*L_remaining_types36, clNIL);
        clSetq(*L_table31, clNIL);
        clSetq(*L_limit32, I_0);
        clSetq(*L_index33, I_0);
        { clObject *_l_NextTable40_ = clMakeBinding(), _l_NextSymbol39_;
          clSetq(_l_NextSymbol39_,
                 clMakeClosure(6,
                               clAproposList_l_NextSymbol39,
                               &clEnvHook(clAproposList_l_NextSymbol39),
                               &*L_table31,
                               &*L_index33,
                               &*L_limit32,
                               &*L_acessibility38,
                               &*L_package35,
                               &*_l_NextTable40_));
          clSetq(*_l_NextTable40_,
                 clMakeClosure(9,
                               clAproposList_l_NextTable40,
                               &clEnvHook(clAproposList_l_NextTable40),
                               &*L_remaining_uses37,
                               &*L_table31,
                               &*L_index33,
                               &*L_limit32,
                               &*L_remaining_types36,
                               &*L_acessibility38,
                               &*L_package35,
                               &*_l_NextTable40_,
                               &*L_package_list34));
          if (clTrue(*L_package_list34))
            clFuncallFunction(*_l_NextTable40_, clEOA);
          clLabel(l_LOOP41);
          { clObject L_values460, L_more30, symbol;
            { clMultipleValueCall(MVC);
              clSetq(MVC, clSymbolFunctionValue(clLIST));
              { clObject symbol__R1;
                clSetq(symbol__R1,
                       clFuncallFunction(_l_NextSymbol39_, clEOA));
                if (clTrue(clNot(clEq(symbol__R1,
                                      clSymbolValue(clNOT_FOUND, clEOA),
                                      clEOA),
                                 clEOA)))
                  { clObject L_3, L_2;
                    clSetq(L_2, *L_acessibility38);
                    clSetq(L_3, *L_package35);
                    clValues(clT, symbol__R1, L_2, L_3, clEOA); }
                else clValues1(clNIL); }
              clAccumulateValues(MVC);
              clSetq(L_values460, clMultipleValueFuncall(MVC)); }
            clSetq(L_more30, clCar(L_values460, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values460);
                clSetq(L_0,
                       clSetq(L_values460, clCdr(L_0__R1, clEOA))); }
              clSetq(symbol, clCar(L_0, clEOA)); }
            if (clTrue(clNot(L_more30, clEOA))) clLocalReturn(NIL);
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, string);
                clSetq(L_test__R1,
                       clSearch(L_0, clString(symbol, clEOA), clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_1;
                  clSetq(L_1, list);
                  clSetq(list, clAdjoin(symbol, L_1, clEOA)); } } }
          goto l_LOOP41;
          clBlockEnd(NIL); } }
    else
      { clObject *L_package_list47 = clMakeBinding(),
        *L_package48 = clMakeBinding(),
        *L_acessibility51 = clMakeBinding(),
        *L_remaining_uses50 = clMakeBinding(),
        *L_remaining_types49 = clMakeBinding(),
        *L_table44 = clMakeBinding(), *L_limit45 = clMakeBinding(),
        *L_index46 = clMakeBinding();
        clSetq(*L_package_list47,
               clListArg(clListAllPackages(clEOA), clEOA));
        clSetq(*L_package48, clNIL);
        clSetq(*L_acessibility51, clNIL);
        clSetq(*L_remaining_uses50, clNIL);
        clSetq(*L_remaining_types49, clNIL);
        clSetq(*L_table44, clNIL);
        clSetq(*L_limit45, I_0);
        clSetq(*L_index46, I_0);
        { clObject *_l_NextTable53_ = clMakeBinding(), _l_NextSymbol52_;
          clSetq(_l_NextSymbol52_,
                 clMakeClosure(6,
                               clAproposList_l_NextSymbol52,
                               &clEnvHook(clAproposList_l_NextSymbol52),
                               &*L_table44,
                               &*L_index46,
                               &*L_limit45,
                               &*L_acessibility51,
                               &*L_package48,
                               &*_l_NextTable53_));
          clSetq(*_l_NextTable53_,
                 clMakeClosure(9,
                               clAproposList_l_NextTable53,
                               &clEnvHook(clAproposList_l_NextTable53),
                               &*L_remaining_uses50,
                               &*L_table44,
                               &*L_index46,
                               &*L_limit45,
                               &*L_remaining_types49,
                               &*L_acessibility51,
                               &*L_package48,
                               &*_l_NextTable53_,
                               &*L_package_list47));
          if (clTrue(*L_package_list47))
            clFuncallFunction(*_l_NextTable53_, clEOA);
          clLabel(l_LOOP54);
          { clObject L_values471, L_more43, symbol;
            { clMultipleValueCall(MVC__r1);
              clSetq(MVC__r1, clSymbolFunctionValue(clLIST));
              { clObject symbol__R1;
                clSetq(symbol__R1,
                       clFuncallFunction(_l_NextSymbol52_, clEOA));
                if (clTrue(clNot(clEq(symbol__R1,
                                      clSymbolValue(clNOT_FOUND, clEOA),
                                      clEOA),
                                 clEOA)))
                  { clObject L_3, L_2;
                    clSetq(L_2, *L_acessibility51);
                    clSetq(L_3, *L_package48);
                    clValues(clT, symbol__R1, L_2, L_3, clEOA); }
                else clValues1(clNIL); }
              clAccumulateValues(MVC__r1);
              clSetq(L_values471, clMultipleValueFuncall(MVC__r1)); }
            clSetq(L_more43, clCar(L_values471, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values471);
                clSetq(L_0,
                       clSetq(L_values471, clCdr(L_0__R1, clEOA))); }
              clSetq(symbol, clCar(L_0, clEOA)); }
            if (clTrue(clNot(L_more43, clEOA))) clLocalReturn(NIL__r1);
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, string);
                clSetq(L_test__R1,
                       clSearch(L_0, clString(symbol, clEOA), clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_1;
                  clSetq(L_1, list);
                  clSetq(list, clAdjoin(symbol, L_1, clEOA)); } } }
          goto l_LOOP54;
          clBlockEnd(NIL__r1); } }
    return(clValues1(list)); }
  
  clObject clGetInternalRunTime clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clIntInteger(clObjectWord(clRunTime(clEOA))))); }
  
  clObject clGetInternalRealTime clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clIntInteger(clObjectWord(clRealTime(clNIL,
                                                          clEOA))))); }
  
  clObject clGetUniversalTime clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_0;
      clSetq(L_0, clUnixTime());
      return(clFuncallFunction(clSymbolFunctionValue(clADD),
                               L_0,
                               I_2208988800,
                               clEOA)); } }
  
  clObject clDecodeUniversalTime clVdecl(_ap)
  { clObject universal_time, time_zone;
    { clBeginParse(_ap);
      clSetq(universal_time,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(time_zone, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_values546, weeks, secs;
      { clMultipleValueCall(MVC);
        clSetq(MVC, clSymbolFunctionValue(clLIST));
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, universal_time);
            clSetq(L_0,
                   clFuncallFunction(clSymbolFunctionValue(clADD),
                                     L_0__R1,
                                     I_432000,
                                     clEOA)); }
          clTruncate(L_0, I_604800, clEOA); }
        clAccumulateValues(MVC);
        clSetq(L_values546, clMultipleValueFuncall(MVC)); }
      clSetq(weeks, clCar(L_values546, clEOA));
      { clObject L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, L_values546);
          clSetq(L_0, clSetq(L_values546, clCdr(L_0__R1, clEOA))); }
        clSetq(secs, clCar(L_0, clEOA)); }
      { clObject weeks__R1, second, minute, hour, date, month, year, day,
        daylightp, zone;
        clSetq(weeks__R1,
               clFuncallFunction(clSymbolFunctionValue(clADD),
                                 weeks,
                                 I_2145,
                                 clEOA));
        clSetq(second, clNIL);
        clSetq(minute, clNIL);
        clSetq(hour, clNIL);
        clSetq(date, clNIL);
        clSetq(month, clNIL);
        clSetq(year, clNIL);
        clSetq(day, clNIL);
        clSetq(daylightp, clNIL);
        if (clTrue(time_zone))
          { clObject L_0;
            clSetq(L_0, time_zone);
            clSetq(zone,
                   clFuncallFunction(clSymbolFunctionValue(clMULT),
                                     L_0,
                                     I_60,
                                     clEOA)); }
        else
          { clObject L_values547, minwest, dst;
            { clMultipleValueCall(MVC__r1);
              clSetq(MVC__r1, clSymbolFunctionValue(clLIST));
              { clObject L_0;
                { clObject L_0__R1;
                  clSetq(L_0__R1, universal_time);
                  clSetq(L_0,
                         clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                           L_0__R1,
                                           I_2208988800,
                                           clEOA)); }
                clGetTimezone(L_0); }
              clAccumulateValues(MVC__r1);
              clSetq(L_values547, clMultipleValueFuncall(MVC__r1)); }
            clSetq(minwest, clCar(L_values547, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values547);
                clSetq(L_0,
                       clSetq(L_values547, clCdr(L_0__R1, clEOA))); }
              clSetq(dst, clCar(L_0, clEOA)); }
            clSetq(daylightp, dst);
            clSetq(zone, minwest); }
        { clObject L_values549, t1, seconds;
          { clMultipleValueCall(MVC__r2);
            clSetq(MVC__r2, clSymbolFunctionValue(clLIST));
            clTruncate(secs, I_60, clEOA);
            clAccumulateValues(MVC__r2);
            clSetq(L_values549, clMultipleValueFuncall(MVC__r2)); }
          clSetq(t1, clCar(L_values549, clEOA));
          { clObject L_0;
            { clObject L_0__R1;
              clSetq(L_0__R1, L_values549);
              clSetq(L_0, clSetq(L_values549, clCdr(L_0__R1, clEOA))); }
            clSetq(seconds, clCar(L_0, clEOA)); }
          clSetq(second, seconds);
          { clObject L_1, L_0;
            clSetq(L_0, t1);
            clSetq(L_1, zone);
            clSetq(t1,
                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                     L_0,
                                     L_1,
                                     clEOA)); }
          { clObject tday;
            { clObject L_test;
              { clObject L_0;
                clSetq(L_0, t1);
                clSetq(L_test,
                       clFuncallFunction(clSymbolFunctionValue(clLT),
                                         L_0,
                                         I_0,
                                         clEOA)); }
              if (clTrue(L_test))
                { clObject L_0;
                  { clObject L_0__R1;
                    { clObject L_0__R2;
                      clSetq(L_0__R2, t1);
                      clSetq(L_0__R1, cl1PLUS_FUNC(L_0__R2, clEOA)); }
                    clSetq(L_0, clTruncate(L_0__R1, I_1440, clEOA)); }
                  clSetq(tday, cl1MINUS_FUNC(L_0, clEOA)); }
              else
                { clObject L_0;
                  clSetq(L_0, t1);
                  clSetq(tday, clTruncate(L_0, I_1440, clEOA)); } }
            { clObject L_values552, L_hour550, L_minute551;
              { clMultipleValueCall(MVC__r3);
                clSetq(MVC__r3, clSymbolFunctionValue(clLIST));
                { clObject L_0;
                  { clObject L_1__R1, L_0__R1;
                    clSetq(L_0__R1, t1);
                    { clObject L_0__R2;
                      clSetq(L_0__R2, tday);
                      clSetq(L_1__R1,
                             clFuncallFunction(clSymbolFunctionValue(clMULT),
                                               L_0__R2,
                                               I_1440,
                                               clEOA)); }
                    clSetq(L_0,
                           clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                             L_0__R1,
                                             L_1__R1,
                                             clEOA)); }
                  clTruncate(L_0, I_60, clEOA); }
                clAccumulateValues(MVC__r3);
                clSetq(L_values552, clMultipleValueFuncall(MVC__r3)); }
              clSetq(L_hour550, clCar(L_values552, clEOA));
              { clObject L_0;
                { clObject L_0__R1;
                  clSetq(L_0__R1, L_values552);
                  clSetq(L_0,
                         clSetq(L_values552, clCdr(L_0__R1, clEOA))); }
                clSetq(L_minute551, clCar(L_0, clEOA)); }
              clSetq(hour, L_hour550);
              clSetq(minute, L_minute551);
              (void) L_hour550; }
            { clObject t2, tcent;
              { clObject L_0;
                { clObject L_0__R1;
                  { clObject L_1__R1, L_0__R2;
                    clSetq(L_0__R2,
                           clFuncallFunction(clSymbolFunctionValue(clMULT),
                                             weeks__R1,
                                             I_7,
                                             clEOA));
                    clSetq(L_1__R1, tday);
                    clSetq(L_0__R1,
                           clPLUS_FUNC(L_0__R2,
                                       L_1__R1,
                                       I_678882,
                                       clEOA)); }
                  clSetq(L_0,
                         clFuncallFunction(clSymbolFunctionValue(clMULT),
                                           L_0__R1,
                                           I_4,
                                           clEOA)); }
                clSetq(t2, cl1MINUS_FUNC(L_0, clEOA)); }
              clSetq(tcent, clTruncate(t2, I_146097, clEOA));
              { clObject L_0;
                clSetq(L_0, t2);
                clSetq(t2, clMod(L_0, I_146097, clEOA)); }
              { clObject L_0;
                { clObject L_1__R1, L_0__R1;
                  clSetq(L_0__R1, t2);
                  { clObject L_0__R2;
                    clSetq(L_0__R2, t2);
                    clSetq(L_1__R1, clMod(L_0__R2, I_4, clEOA)); }
                  clSetq(L_0,
                         clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                           L_0__R1,
                                           L_1__R1,
                                           clEOA)); }
                clSetq(t2,
                       clFuncallFunction(clSymbolFunctionValue(clADD),
                                         L_0,
                                         I_3,
                                         clEOA)); }
              { clObject L_1, L_0;
                clSetq(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clMULT),
                                         tcent,
                                         I_100,
                                         clEOA));
                { clObject L_0__R1;
                  clSetq(L_0__R1, t2);
                  clSetq(L_1, clTruncate(L_0__R1, I_1461, clEOA)); }
                clSetq(year,
                       clFuncallFunction(clSymbolFunctionValue(clADD),
                                         L_0,
                                         L_1,
                                         clEOA)); }
              { clObject days_since_mar0;
                { clObject L_0;
                  { clObject L_0__R1;
                    { clObject L_0__R2;
                      clSetq(L_0__R2, t2);
                      clSetq(L_0__R1, clMod(L_0__R2, I_1461, clEOA)); }
                    clSetq(L_0, clTruncate(L_0__R1, I_4, clEOA)); }
                  clSetq(days_since_mar0, cl1PLUS_FUNC(L_0, clEOA)); }
                { clObject L_0;
                  { clObject L_0__R1;
                    clSetq(L_0__R1, tday);
                    clSetq(L_0,
                           clFuncallFunction(clSymbolFunctionValue(clADD),
                                             L_0__R1,
                                             I_2,
                                             clEOA)); }
                  clSetq(day, clMod(L_0, I_7, clEOA)); }
                { clObject t3;
                  { clObject L_0;
                    clSetq(L_0,
                           clFuncallFunction(clSymbolFunctionValue(clMULT),
                                             days_since_mar0,
                                             I_5,
                                             clEOA));
                    clSetq(t3,
                           clFuncallFunction(clSymbolFunctionValue(clADD),
                                             L_0,
                                             I_456,
                                             clEOA)); }
                  if (clTrue(clFuncallFunction(clSymbolFunctionValue(clGE),
                                               t3,
                                               I_1989,
                                               clEOA)))
                    { { clObject L_0;
                        clSetq(L_0, t3);
                        clSetq(t3,
                               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                 L_0,
                                                 I_1836,
                                                 clEOA)); }
                      { clObject L_0;
                        clSetq(L_0, year);
                        clSetq(year, cl1PLUS_FUNC(L_0, clEOA)); } }
                  { clObject L_values555, L_month553, L_t3554;
                    { clMultipleValueCall(MVC__r4);
                      clSetq(MVC__r4, clSymbolFunctionValue(clLIST));
                      { clObject L_0;
                        clSetq(L_0, t3);
                        clTruncate(L_0, I_153, clEOA); }
                      clAccumulateValues(MVC__r4);
                      clSetq(L_values555,
                             clMultipleValueFuncall(MVC__r4)); }
                    clSetq(L_month553, clCar(L_values555, clEOA));
                    { clObject L_0;
                      { clObject L_0__R1;
                        clSetq(L_0__R1, L_values555);
                        clSetq(L_0,
                               clSetq(L_values555,
                                      clCdr(L_0__R1, clEOA))); }
                      clSetq(L_t3554, clCar(L_0, clEOA)); }
                    clSetq(month, L_month553);
                    clSetq(t3, L_t3554);
                    (void) L_month553; }
                  { clObject L_0;
                    { clObject L_0__R1;
                      clSetq(L_0__R1, t3);
                      clSetq(L_0, clTruncate(L_0__R1, I_5, clEOA)); }
                    clSetq(date, cl1PLUS_FUNC(L_0, clEOA)); } } } } } }
        { clObject L_8, L_7, L_6, L_5, L_4, L_3, L_2, L_1, L_0;
          clSetq(L_0, second);
          clSetq(L_1, minute);
          clSetq(L_2, hour);
          clSetq(L_3, date);
          clSetq(L_4, month);
          clSetq(L_5, year);
          clSetq(L_6, day);
          clSetq(L_7, daylightp);
          if (clTrue(daylightp))
            { clObject L_0__R1;
              { clObject L_0__R2;
                clSetq(L_0__R2, zone);
                clSetq(L_0__R1,
                       clFuncallFunction(clSymbolFunctionValue(clDIV),
                                         L_0__R2,
                                         I_60,
                                         clEOA)); }
              clSetq(L_8, cl1PLUS_FUNC(L_0__R1, clEOA)); }
          else
            { clObject L_0__R1;
              clSetq(L_0__R1, zone);
              clSetq(L_8,
                     clFuncallFunction(clSymbolFunctionValue(clDIV),
                                       L_0__R1,
                                       I_60,
                                       clEOA)); }
          return(clValues(L_0,
                          L_1,
                          L_2,
                          L_3,
                          L_4,
                          L_5,
                          L_6,
                          L_7,
                          L_8,
                          clEOA)); } } } }
  
  clObject clGetDecodedTime clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clDecodeUniversalTime(clGetUniversalTime(clEOA), clEOA)); }
  
  clObject clCanonicalYear clVdecl(_ap)
  { clObject year;
    { clBeginParse(_ap);
      clSetq(year,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_test;
      { clObject L_0;
        clSetq(L_0, year);
        clSetq(L_test,
               clFuncallFunction(clSymbolFunctionValue(clGE),
                                 L_0,
                                 I_100,
                                 clEOA)); }
      if (clTrue(L_test))
        return(clValues1(year));
      else
        { clObject current_year, guess;
          { clObject L_values625, L_ignore_624, L_ignore_623,
            L_ignore_622, L_ignore_621, L_ignore_620, L_keeper619;
            { clMultipleValueCall(MVC);
              clSetq(MVC, clSymbolFunctionValue(clLIST));
              clGetDecodedTime(clEOA);
              clAccumulateValues(MVC);
              clSetq(L_values625, clMultipleValueFuncall(MVC)); }
            clSetq(L_ignore_624, clCar(L_values625, clEOA));
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values625);
                clSetq(L_0,
                       clSetq(L_values625, clCdr(L_0__R1, clEOA))); }
              clSetq(L_ignore_623, clCar(L_0, clEOA)); }
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values625);
                clSetq(L_0,
                       clSetq(L_values625, clCdr(L_0__R1, clEOA))); }
              clSetq(L_ignore_622, clCar(L_0, clEOA)); }
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values625);
                clSetq(L_0,
                       clSetq(L_values625, clCdr(L_0__R1, clEOA))); }
              clSetq(L_ignore_621, clCar(L_0, clEOA)); }
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values625);
                clSetq(L_0,
                       clSetq(L_values625, clCdr(L_0__R1, clEOA))); }
              clSetq(L_ignore_620, clCar(L_0, clEOA)); }
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1, L_values625);
                clSetq(L_0,
                       clSetq(L_values625, clCdr(L_0__R1, clEOA))); }
              clSetq(L_keeper619, clCar(L_0, clEOA)); }
            clSetq(current_year, L_keeper619); }
          { clObject L_1, L_0;
            clSetq(L_0, year);
            { clObject L_0__R1;
              { clObject L_0__R2;
                clSetq(L_0__R2,
                       clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                         current_year,
                                         I_50,
                                         clEOA));
                clSetq(L_0__R1, clTruncate(L_0__R2, I_100, clEOA)); }
              clSetq(L_1,
                     clFuncallFunction(clSymbolFunctionValue(clMULT),
                                       L_0__R1,
                                       I_100,
                                       clEOA)); }
            clSetq(guess,
                   clFuncallFunction(clSymbolFunctionValue(clADD),
                                     L_0,
                                     L_1,
                                     clEOA)); }
          { clObject L_test__R1;
            { clObject L_0;
              clSetq(L_0,
                     clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                       current_year,
                                       guess,
                                       clEOA));
              clSetq(L_test__R1,
                     clFuncallFunction(clSymbolFunctionValue(clGT),
                                       L_0,
                                       I_50,
                                       clEOA)); }
            if (clTrue(L_test__R1))
              return(clFuncallFunction(clSymbolFunctionValue(clADD),
                                       guess,
                                       I_100,
                                       clEOA));
            else return(clValues1(guess)); } } } }
  
  clObject clLeapDaysSince1900 clVdecl(_ap)
  { clObject years_since_1900, days_in_year;
    { clBeginParse(_ap);
      clSetq(years_since_1900,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(days_in_year,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_values626, year_by_4, rem_by_4;
      { clMultipleValueCall(MVC);
        clSetq(MVC, clSymbolFunctionValue(clLIST));
        { clObject L_0;
          clSetq(L_0, years_since_1900);
          clTruncate(L_0, I_4, clEOA); }
        clAccumulateValues(MVC);
        clSetq(L_values626, clMultipleValueFuncall(MVC)); }
      clSetq(year_by_4, clCar(L_values626, clEOA));
      { clObject L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, L_values626);
          clSetq(L_0, clSetq(L_values626, clCdr(L_0__R1, clEOA))); }
        clSetq(rem_by_4, clCar(L_0, clEOA)); }
      { clObject L_values627, year_by_100, rem_by_100;
        { clMultipleValueCall(MVC__r1);
          clSetq(MVC__r1, clSymbolFunctionValue(clLIST));
          { clObject L_0;
            clSetq(L_0, years_since_1900);
            clTruncate(L_0, I_100, clEOA); }
          clAccumulateValues(MVC__r1);
          clSetq(L_values627, clMultipleValueFuncall(MVC__r1)); }
        clSetq(year_by_100, clCar(L_values627, clEOA));
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_values627);
            clSetq(L_0, clSetq(L_values627, clCdr(L_0__R1, clEOA))); }
          clSetq(rem_by_100, clCar(L_0, clEOA)); }
        { clObject L_values628, year_by_400, rem_by_400;
          { clMultipleValueCall(MVC__r2);
            clSetq(MVC__r2, clSymbolFunctionValue(clLIST));
            { clObject L_0;
              { clObject L_1__R1;
                clSetq(L_1__R1, years_since_1900);
                clSetq(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clADD),
                                         I_1900,
                                         L_1__R1,
                                         clEOA)); }
              clTruncate(L_0, I_400, clEOA); }
            clAccumulateValues(MVC__r2);
            clSetq(L_values628, clMultipleValueFuncall(MVC__r2)); }
          clSetq(year_by_400, clCar(L_values628, clEOA));
          { clObject L_0;
            { clObject L_0__R1;
              clSetq(L_0__R1, L_values628);
              clSetq(L_0, clSetq(L_values628, clCdr(L_0__R1, clEOA))); }
            clSetq(rem_by_400, clCar(L_0, clEOA)); }
          { clObject L_4, L_1;
            clSetq(L_1,
                   clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                     I_0,
                                     year_by_100,
                                     clEOA));
            { clObject L_test;
              if (clTrue(clZerop(rem_by_4, clEOA)))
                { clObject L_test__R2;
                  { clObject L_g629;
                    clSetq(L_g629, clZerop(rem_by_400, clEOA));
                    clSetq(L_test__R2,
                           (clTrue(L_g629) ?
                            L_g629 :
                            clNot(clZerop(rem_by_100, clEOA), clEOA))); }
                  if (clTrue(L_test__R2))
                    { clObject L_0__R1;
                      clSetq(L_0__R1, days_in_year);
                      clSetq(L_test,
                             clFuncallFunction(clSymbolFunctionValue(clLT),
                                               L_0__R1,
                                               I_59,
                                               clEOA)); }
                  else clSetq(L_test, clNIL); }
              else clSetq(L_test, clNIL);
              clSetq(L_4, (clTrue(L_test) ? I_minus1 : I_0)); }
            return(clPLUS_FUNC(year_by_4,
                               L_1,
                               year_by_400,
                               I_minus4,
                               L_4,
                               clEOA)); } } } } }
  
  clObject clEncodeUniversalTime clVdecl(_ap)
  { clObject L_ap, second, minute, hour, date, month, year, time_zone,
    time_zone_p;
    { clBeginParse(_ap);
      clSetq(second,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(minute,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      clSetq(hour,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_3, clEOA)));
      clSetq(date,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_4, clEOA)));
      clSetq(month,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_5, clEOA)));
      clSetq(year,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_6, clEOA)));
      clSetq(time_zone,
             (clTrue(clSetq(L_ap, clVp(_ap))) ? clVpop(_ap) : I_0));
      clSetq(time_zone_p, L_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject years_since_1900, days_in_year, raw;
      { clObject L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, year);
          clSetq(L_0, clCanonicalYear(L_0__R1, clEOA)); }
        clSetq(years_since_1900,
               clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                 L_0,
                                 I_1900,
                                 clEOA)); }
      { clObject L_1, L_0;
        clSetq(L_0, date);
        { clObject L_1__R1, L_0__R1;
          clSetq(L_0__R1, clSymbolValue(clDAYS_IN_YEAR_BY_MONTH, clEOA));
          clSetq(L_1__R1, month);
          clSetq(L_1, clSvref(L_0__R1, L_1__R1, clEOA)); }
        clSetq(days_in_year,
               clFuncallFunction(clSymbolFunctionValue(clADD),
                                 L_0,
                                 L_1,
                                 clEOA)); }
      { clObject L_3, L_2, L_1, L_0;
        { clObject L_1__R1;
          { clObject L_1__R2, L_0__R2;
            clSetq(L_0__R2,
                   clFuncallFunction(clSymbolFunctionValue(clMULT),
                                     I_365,
                                     years_since_1900,
                                     clEOA));
            { clObject L_1__R3;
              { clObject L_1__R4;
                { clObject L_test;
                  { clObject L_test__R1;
                    { clObject L_0__R5;
                      clSetq(L_0__R5, month);
                      clSetq(L_test__R1,
                             clFuncallFunction(clSymbolFunctionValue(clEQ_NUMBER),
                                               L_0__R5,
                                               I_2,
                                               clEOA)); }
                    if (clTrue(L_test__R1))
                      { clObject L_0__R5;
                        clSetq(L_0__R5, date);
                        clSetq(L_test,
                               clFuncallFunction(clSymbolFunctionValue(clEQ_NUMBER),
                                                 L_0__R5,
                                                 I_29,
                                                 clEOA)); }
                    else clSetq(L_test, clNIL); }
                  clSetq(L_1__R4, (clTrue(L_test) ? I_1 : I_0)); }
                clSetq(L_1__R3,
                       clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                         days_in_year,
                                         L_1__R4,
                                         clEOA)); }
              clSetq(L_1__R2,
                     clLeapDaysSince1900(years_since_1900,
                                         L_1__R3,
                                         clEOA)); }
            clSetq(L_1__R1,
                   clPLUS_FUNC(L_0__R2, L_1__R2, days_in_year, clEOA)); }
          clSetq(L_0,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   I_86400,
                                   L_1__R1,
                                   clEOA)); }
        { clObject L_0__R1;
          { clObject L_1__R2, L_0__R2;
            clSetq(L_0__R2, hour);
            clSetq(L_1__R2, time_zone);
            clSetq(L_0__R1,
                   clFuncallFunction(clSymbolFunctionValue(clADD),
                                     L_0__R2,
                                     L_1__R2,
                                     clEOA)); }
          clSetq(L_1,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   I_3600,
                                   clEOA)); }
        { clObject L_0__R1;
          clSetq(L_0__R1, minute);
          clSetq(L_2,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   I_60,
                                   clEOA)); }
        clSetq(L_3, second);
        clSetq(raw, clPLUS_FUNC(L_0, L_1, L_2, L_3, clEOA)); }
      if (clTrue(time_zone_p))
        return(clValues1(raw));
      else
        { clObject L_1;
          { clObject L_0__R1;
            clSetq(L_0__R1,
                   clGetTimezone(clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                                   raw,
                                                   I_2208988800,
                                                   clEOA)));
            clSetq(L_1,
                   clFuncallFunction(clSymbolFunctionValue(clMULT),
                                     L_0__R1,
                                     I_60,
                                     clEOA)); }
          return(clFuncallFunction(clSymbolFunctionValue(clADD),
                                   raw,
                                   L_1,
                                   clEOA)); } } }
  
  clObject clSleep clVdecl(_ap)
  { clObject seconds;
    { clBeginParse(_ap);
      clSetq(seconds,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject s;
      { clObject L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, seconds);
          clSetq(L_0,
                 clFuncallFunction(clSymbolFunctionValue(clMULT),
                                   L_0__R1,
                                   I_1000,
                                   clEOA)); }
        clSetq(s, clCeiling(L_0, clEOA)); }
      if (clTrue(clFixnump(s, clEOA)))
        clMillisleep(clFixnumInt(s));
      else
        clError(clTYPE_ERROR, keyDATUM, s, keyEXPECTED_TYPE, CONS_26,
                clEOA); }
    return(clValues1(clNIL)); }
  
  clObject clLispImplementationType clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(STR_Eclipse_Common_Lisp__19)); }
  
  clObject clLispImplementationVersion clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clCharpSimpleBaseString(clEclipseVersion()))); }
  
  clObject clUserId clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clUname(clCharacterInt(C_u)))); }
  
  clObject clMachineVersion clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_g638;
      clSetq(L_g638, clSymbolValue(clstarMACHINE_VERSIONstar, clEOA));
      if (clTrue(L_g638))
        return(clValues1(L_g638));
      else return(clValues1(clUname(clCharacterInt(C_z)))); } }
  
  clObject clMachineInstance clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clUname(clCharacterInt(C_n)))); }
  
  clObject clMachineType clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clUname(clCharacterInt(C_m)))); }
  
  clObject clSoftwareType clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clUname(clCharacterInt(C_s)))); }
  
  clObject clSoftwareVersion clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clUname(clCharacterInt(C_r)))); }
  
  clObject clShortSiteName clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clSymbolValue(clstarSHORT_SITE_NAMEstar, clEOA))); }
  
  clObject clLongSiteName clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_g647;
      clSetq(L_g647, clSymbolValue(clstarLONG_SITE_NAMEstar, clEOA));
      if (clTrue(L_g647))
        return(clValues1(L_g647));
      else return(clShortSiteName(clEOA)); } }
  
  static clObject clIdString_Lambda clVdecl(_ap)
  { clObject xp, L_args;
    { clBeginParse(_ap);
      clSetq(xp, (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(L_args, clVargs(_ap));
      clEndParse(_ap); }
    { clObject STARprint_escapeSTAR, STARprint_readablySTAR, arg;
      clSetq(STARprint_escapeSTAR, clNIL);
      clSetq(STARprint_readablySTAR, clNIL);
      { clObject L_top648;
        clSetq(L_top648, clCar(L_args, clEOA));
        { clObject L_0;
          clSetq(L_0, L_args);
          clSetq(L_args, clCdr(L_0, clEOA)); }
        clSetq(arg, L_top648); }
      clDbind(clstarPRINT_READABLYstar);
      clSetSymbolValueValue(clstarPRINT_READABLYstar,
                            STARprint_readablySTAR);
      clDbind(clstarPRINT_ESCAPEstar);
      clSetSymbolValueValue(clstarPRINT_ESCAPEstar,
                            STARprint_escapeSTAR);
      { clObject L_1;
        clSetq(L_1, xp);
        clWriteToplevel(arg, L_1, clEOA); }
      clUnwind(2); }
    { clObject L_test649;
      { clObject L_0;
        { clObject L_top650;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_args);
            clSetq(L_top650, clCar(L_0__R1, clEOA)); }
          { clObject L_0__R1;
            clSetq(L_0__R1, L_args);
            clSetq(L_args, clCdr(L_0__R1, clEOA)); }
          clSetq(L_0, L_top650); }
        clSetq(L_test649, clNull(L_0, clEOA)); }
      if (clTrue(L_test649))
        (void) L_test649;
      else
        { clObject L_0;
          clSetq(L_0, xp);
          clFuncallFunction(clSymbolFunctionValue(clSTREAM_WRITE_STRING),
                            L_0,
                            STR_dot__20,
                            clEOA); } }
    { clObject STARprint_escapeSTAR, STARprint_readablySTAR, arg;
      clSetq(STARprint_escapeSTAR, clNIL);
      clSetq(STARprint_readablySTAR, clNIL);
      { clObject L_top651;
        { clObject L_0;
          clSetq(L_0, L_args);
          clSetq(L_top651, clCar(L_0, clEOA)); }
        { clObject L_0;
          clSetq(L_0, L_args);
          clSetq(L_args, clCdr(L_0, clEOA)); }
        clSetq(arg, L_top651); }
      clDbind(clstarPRINT_READABLYstar);
      clSetSymbolValueValue(clstarPRINT_READABLYstar,
                            STARprint_readablySTAR);
      clDbind(clstarPRINT_ESCAPEstar);
      clSetSymbolValueValue(clstarPRINT_ESCAPEstar,
                            STARprint_escapeSTAR);
      { clObject L_1;
        clSetq(L_1, xp);
        clWriteToplevel(arg, L_1, clEOA); }
      clUnwind(2); }
    { clObject L_test652;
      { clObject L_0;
        { clObject L_top653;
          { clObject L_0__R1;
            clSetq(L_0__R1, L_args);
            clSetq(L_top653, clCar(L_0__R1, clEOA)); }
          { clObject L_0__R1;
            clSetq(L_0__R1, L_args);
            clSetq(L_args, clCdr(L_0__R1, clEOA)); }
          clSetq(L_0, L_top653); }
        clSetq(L_test652, clNull(L_0, clEOA)); }
      if (clTrue(L_test652))
        (void) L_test652;
      else
        { clObject L_0;
          clSetq(L_0, xp);
          clFuncallFunction(clSymbolFunctionValue(clSTREAM_WRITE_STRING),
                            L_0,
                            STR____21,
                            clEOA); } }
    { clObject L_test;
      { clObject L_0;
        clSetq(L_0, L_args);
        clSetq(L_test, clCar(L_0, clEOA)); }
      if (clTrue(L_test))
        { clObject STARprint_escapeSTAR, STARprint_readablySTAR, arg;
          clSetq(STARprint_escapeSTAR, clNIL);
          clSetq(STARprint_readablySTAR, clNIL);
          { clObject L_top654;
            { clObject L_0;
              clSetq(L_0, L_args);
              clSetq(L_top654, clCar(L_0, clEOA)); }
            { clObject L_0;
              clSetq(L_0, L_args);
              clSetq(L_args, clCdr(L_0, clEOA)); }
            clSetq(arg, L_top654); }
          clDbind(clstarPRINT_READABLYstar);
          clSetSymbolValueValue(clstarPRINT_READABLYstar,
                                STARprint_readablySTAR);
          clDbind(clstarPRINT_ESCAPEstar);
          clSetSymbolValueValue(clstarPRINT_ESCAPEstar,
                                STARprint_escapeSTAR);
          { clObject L_1;
            clSetq(L_1, xp);
            clWriteToplevel(arg, L_1, clEOA); }
          clUnwind(2); }
      else
        { clObject L_top655;
          { clObject L_0;
            clSetq(L_0, L_args);
            clSetq(L_top655, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_args);
            clSetq(L_args, clCdr(L_0, clEOA)); }
          (void) L_top655; } }
    return(clValues1(L_args)); }
  
  clObject clIdString clVdecl(_ap)
  { clObject major, minor, qualifier, decimalp, spacep;
    { clBeginParse(_ap);
      clSetq(major,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(minor,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      clSetq(qualifier, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      clSetq(decimalp, (_clVp(_ap) ? clVpop(_ap) : clT));
      clSetq(spacep, (_clVp(_ap) ? clVpop(_ap) : decimalp));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_6, L_5, L_4, L_3, L_2, L_1;
      clSetq(L_1, clMakeClosure(0, clIdString_Lambda, clNULL_HOOK));
      clSetq(L_2, major);
      clSetq(L_3, decimalp);
      clSetq(L_4, minor);
      clSetq(L_5, (clTrue(spacep) ? qualifier : clNIL));
      clSetq(L_6, qualifier);
      return(clFuncallFunction(clSymbolFunctionValue(clFORMAT),
                               clNIL,
                               L_1,
                               L_2,
                               L_3,
                               L_4,
                               L_5,
                               L_6,
                               clEOA)); } }
  
  clDeclareEnv(clConstantly_Lambda);
  static clObject clConstantly_Lambda clVdecl(_ap)
  { clUseEnv(clConstantly_Lambda);
    { clObject args;
      { clBeginParse(_ap); clSetq(args, clVargs(_ap)); clEndParse(_ap); }
      return(clValues1(clEnv(0, *object))); } }
  
  clObject clConstantly clVdecl(_ap)
  { clObject *object = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*object,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clMakeClosure(1,
                                   clConstantly_Lambda,
                                   &clEnvHook(clConstantly_Lambda),
                                   &*object))); }
  
  void clInitMiscel __P((void)) 
  { clDbind(clstarPACKAGEstar);
    clDbind(clstarREADTABLEstar);
    clDbind(clstarLOAD_TRUENAMEstar);
    clDbind(clstarLOAD_PATHNAMEstar);
    clSetq(I_0, clIntFixnum(0));
    clSetq(I_1, clIntFixnum(1));
    clSetq(I_2, clIntFixnum(2));
    clSetq(STRn_0,
           clCharpSimpleBaseString("~&~v@t~d Call ~s, Args:~{ ~s~}~%"));
    clSetq(STRn_1,
           clCharpSimpleBaseString("~&~v@t~d  ~s  Returned:~{ ~s~}~%"));
    clSetq(STR_KEY__2, clCharpSimpleBaseString("KEY"));
    clSetq(keyKEY, clMakeKeyword(STR_KEY__2, clEOA));
    clSetq(I_3, clIntFixnum(3));
    clSetq(STRn_3,
           clCharpSimpleBaseString("~%~9,2f seconds of real time."));
    clSetq(STRn_4,
           clCharpSimpleBaseString("~%~10,3f seconds of run time."));
    clSetq(STRn_5,
           clCharpSimpleBaseString("~%The heap grew by ~d bytes."));
    clSetq(CONS_4, clCons(clNIL, clNIL, clEOA));
    clSetq(CONS_3, clCons(clROOM, CONS_4, clEOA));
    clSetq(CONS_2, clCons(CONS_3, clNIL, clEOA));
    clSetq(CONS_1, clCons(clHEAP_START, CONS_2, clEOA));
    clSetq(CONS_8, clCons(clREAL_TIME, CONS_4, clEOA));
    clSetq(CONS_7, clCons(CONS_8, clNIL, clEOA));
    clSetq(CONS_6, clCons(clREAL_START, CONS_7, clEOA));
    clSetq(CONS_12, clCons(clRUN_TIME, clNIL, clEOA));
    clSetq(CONS_11, clCons(CONS_12, clNIL, clEOA));
    clSetq(CONS_10, clCons(clRUN_START, CONS_11, clEOA));
    clSetq(CONS_9, clCons(CONS_10, clNIL, clEOA));
    clSetq(CONS_5, clCons(CONS_6, CONS_9, clEOA));
    clSetq(CONS_0, clCons(CONS_1, CONS_5, clEOA));
    clSetq(CONS_17, clCons(clHEAP_START, clNIL, clEOA));
    clSetq(CONS_16, clCons(clRUN_START, CONS_17, clEOA));
    clSetq(CONS_15, clCons(clREAL_START, CONS_16, clEOA));
    clSetq(CONS_14, clCons(clEND_TIME, CONS_15, clEOA));
    clSetq(CONS_13, clCons(CONS_14, clNIL, clEOA));
    clSetq(STR_VALUES1__6, clCharpSimpleBaseString("VALUES1"));
    clSetq(SYM_0_VALUES1, clMakeSymbol(STR_VALUES1__6, clEOA));
    clSetq(STR_REPORT_FUNCTION__7,
           clCharpSimpleBaseString("REPORT-FUNCTION"));
    clSetq(keyREPORT_FUNCTION,
           clMakeKeyword(STR_REPORT_FUNCTION__7, clEOA));
    clSetq(STR_Quit_inspectordot__8,
           clCharpSimpleBaseString("Quit inspector."));
    clSetq(STR_DEFAULT__9, clCharpSimpleBaseString("DEFAULT"));
    clSetq(keyDEFAULT, clMakeKeyword(STR_DEFAULT__9, clEOA));
    clSetq(STRn_10, clCharpSimpleBaseString("~:d bytes allocated.~%"));
    clSetq(STRn_11,
           clCharpSimpleBaseString("~:d bytes allocated since the last GC.~%"));
    clSetq(STRn_12,
           clCharpSimpleBaseString("Total memory usage is ~:d out of ~:d bytes available.~%"));
    clSetq(STRn_13, clCharpSimpleBaseString("No Lisp-resident editor."));
    clSetq(STR_INHERITED__14, clCharpSimpleBaseString("INHERITED"));
    clSetq(keyINHERITED, clMakeKeyword(STR_INHERITED__14, clEOA));
    clSetq(STR_INTERNAL__15, clCharpSimpleBaseString("INTERNAL"));
    clSetq(keyINTERNAL, clMakeKeyword(STR_INTERNAL__15, clEOA));
    clSetq(STR_EXTERNAL__16, clCharpSimpleBaseString("EXTERNAL"));
    clSetq(keyEXTERNAL, clMakeKeyword(STR_EXTERNAL__16, clEOA));
    clSetq(STR_DATUM__17, clCharpSimpleBaseString("DATUM"));
    clSetq(keyDATUM, clMakeKeyword(STR_DATUM__17, clEOA));
    clSetq(STR_EXPECTED_TYPE__18,
           clCharpSimpleBaseString("EXPECTED-TYPE"));
    clSetq(keyEXPECTED_TYPE,
           clMakeKeyword(STR_EXPECTED_TYPE__18, clEOA));
    clSetq(CONS_21, clCons(keyINHERITED, clNIL, clEOA));
    clSetq(CONS_20, clCons(keyEXTERNAL, CONS_21, clEOA));
    clSetq(CONS_19, clCons(keyINTERNAL, CONS_20, clEOA));
    clSetq(CONS_18, clCons(clMEMBER, CONS_19, clEOA));
    clSetq(CONS_23, clCons(keyINTERNAL, CONS_21, clEOA));
    clSetq(CONS_22, clCons(keyEXTERNAL, CONS_23, clEOA));
    clSetq(CONS_25, clCons(keyINTERNAL, clNIL, clEOA));
    clSetq(CONS_24, clCons(keyEXTERNAL, CONS_25, clEOA));
    clSetq(I_32384, clIntFixnum(32384));
    clSetq(I_33706, clIntFixnum(33706));
    clSetq(I_2208988800, clXintBignum(clMakeXint(I_3)));
    clSetDigitref(I_2208988800, I_0, I_32384);
    clSetDigitref(I_2208988800, I_1, I_33706);
    clSetDigitref(I_2208988800, I_2, I_0);
    clSetq(I_24, clIntFixnum(24));
    clSetq(I_60, clIntFixnum(60));
    clSetq(I_432000, clIntFixnum(432000));
    clSetq(I_7, clIntFixnum(7));
    clSetq(I_2145, clIntFixnum(2145));
    clSetq(I_678882, clIntFixnum(678882));
    clSetq(I_365, clIntFixnum(365));
    clSetq(I_4, clIntFixnum(4));
    clSetq(I_146097, clIntFixnum(146097));
    clSetq(I_604800, clIntFixnum(604800));
    clSetq(I_1440, clIntFixnum(1440));
    clSetq(I_100, clIntFixnum(100));
    clSetq(I_1461, clIntFixnum(1461));
    clSetq(I_5, clIntFixnum(5));
    clSetq(I_456, clIntFixnum(456));
    clSetq(I_1989, clIntFixnum(1989));
    clSetq(I_1836, clIntFixnum(1836));
    clSetq(I_153, clIntFixnum(153));
    clSetq(I_13, clIntFixnum(13));
    clSetq(I_minus1, clIntFixnum(-1));
    clSetq(I_30, clIntFixnum(30));
    clSetq(I_58, clIntFixnum(58));
    clSetq(I_89, clIntFixnum(89));
    clSetq(I_119, clIntFixnum(119));
    clSetq(I_6, clIntFixnum(6));
    clSetq(I_150, clIntFixnum(150));
    clSetq(I_180, clIntFixnum(180));
    clSetq(I_8, clIntFixnum(8));
    clSetq(I_211, clIntFixnum(211));
    clSetq(I_9, clIntFixnum(9));
    clSetq(I_242, clIntFixnum(242));
    clSetq(I_10, clIntFixnum(10));
    clSetq(I_272, clIntFixnum(272));
    clSetq(I_11, clIntFixnum(11));
    clSetq(I_303, clIntFixnum(303));
    clSetq(I_12, clIntFixnum(12));
    clSetq(I_333, clIntFixnum(333));
    clSetq(A_19, clMakeGeneralVector(I_13));
    cl_SETF_Svref(clNIL, A_19, I_0, clEOA);
    cl_SETF_Svref(I_minus1, A_19, I_1, clEOA);
    cl_SETF_Svref(I_30, A_19, I_2, clEOA);
    cl_SETF_Svref(I_58, A_19, I_3, clEOA);
    cl_SETF_Svref(I_89, A_19, I_4, clEOA);
    cl_SETF_Svref(I_119, A_19, I_5, clEOA);
    cl_SETF_Svref(I_150, A_19, I_6, clEOA);
    cl_SETF_Svref(I_180, A_19, I_7, clEOA);
    cl_SETF_Svref(I_211, A_19, I_8, clEOA);
    cl_SETF_Svref(I_242, A_19, I_9, clEOA);
    cl_SETF_Svref(I_272, A_19, I_10, clEOA);
    cl_SETF_Svref(I_303, A_19, I_11, clEOA);
    cl_SETF_Svref(I_333, A_19, I_12, clEOA);
    clSetq(I_50, clIntFixnum(50));
    clSetq(I_1900, clIntFixnum(1900));
    clSetq(I_400, clIntFixnum(400));
    clSetq(I_minus4, clIntFixnum(-4));
    clSetq(I_59, clIntFixnum(59));
    clSetq(I_86400, clIntFixnum(86400));
    clSetq(I_29, clIntFixnum(29));
    clSetq(I_3600, clIntFixnum(3600));
    clSetq(I_1000, clIntFixnum(1000));
    clSetq(CONS_27, clCons(clFIXNUM, clNIL, clEOA));
    clSetq(CONS_26, clCons(clOR, CONS_27, clEOA));
    clSetq(STR_Eclipse_Common_Lisp__19,
           clCharpSimpleBaseString("Eclipse Common Lisp"));
    clSetq(C_u, clIntCharacter('u'));
    clSetq(C_z, clIntCharacter('z'));
    clSetq(C_n, clIntCharacter('n'));
    clSetq(C_m, clIntCharacter('m'));
    clSetq(C_s, clIntCharacter('s'));
    clSetq(C_r, clIntCharacter('r'));
    clSetq(STR_dot__20, clCharpSimpleBaseString("."));
    clSetq(STR____21, clCharpSimpleBaseString(" "));
    clSetq(STR_ECLIPSE__22, clCharpSimpleBaseString("ECLIPSE"));
    clSetq(keyECLIPSE, clMakeKeyword(STR_ECLIPSE__22, clEOA));
    clSetq(STR_ELWOOD__23, clCharpSimpleBaseString("ELWOOD"));
    clSetq(keyELWOOD, clMakeKeyword(STR_ELWOOD__23, clEOA));
    clSetq(STR_COMMON_LISP__24, clCharpSimpleBaseString("COMMON-LISP"));
    clSetq(keyCOMMON_LISP, clMakeKeyword(STR_COMMON_LISP__24, clEOA));
    clSetq(STR_ANSI_CL__25, clCharpSimpleBaseString("ANSI-CL"));
    clSetq(keyANSI_CL, clMakeKeyword(STR_ANSI_CL__25, clEOA));
    clSetq(STR_X3J13__26, clCharpSimpleBaseString("X3J13"));
    clSetq(keyX3J13, clMakeKeyword(STR_X3J13__26, clEOA));
    clSetq(STR_IEEE_FLOATING_POINT__27,
           clCharpSimpleBaseString("IEEE-FLOATING-POINT"));
    clSetq(keyIEEE_FLOATING_POINT,
           clMakeKeyword(STR_IEEE_FLOATING_POINT__27, clEOA));
    clSetq(STR_ECLIPSE___28, clCharpSimpleBaseString("ECLIPSE-"));
    clSetq(STR_SUN__29, clCharpSimpleBaseString("SUN"));
    clSetq(STR_SPARC__30, clCharpSimpleBaseString("SPARC"));
    clSetq(keySPARC, clMakeKeyword(STR_SPARC__30, clEOA));
    clSetq(CONS_28, clCons(keySPARC, clNIL, clEOA));
    clSetq(STR_9000__31, clCharpSimpleBaseString("9000"));
    clSetq(STR_PA_RISC__32, clCharpSimpleBaseString("PA-RISC"));
    clSetq(keyPA_RISC, clMakeKeyword(STR_PA_RISC__32, clEOA));
    clSetq(CONS_29, clCons(keyPA_RISC, clNIL, clEOA));
    clSetq(STR_I386__33, clCharpSimpleBaseString("I386"));
    clSetq(STR_I486__34, clCharpSimpleBaseString("I486"));
    clSetq(STR_I586__35, clCharpSimpleBaseString("I586"));
    clSetq(STR_I686__36, clCharpSimpleBaseString("I686"));
    clSetq(STR_X86__37, clCharpSimpleBaseString("X86"));
    clSetq(STR_PC__38, clCharpSimpleBaseString("PC"));
    clSetq(keyPC, clMakeKeyword(STR_PC__38, clEOA));
    clSetq(STR_INTEL__39, clCharpSimpleBaseString("INTEL"));
    clSetq(keyINTEL, clMakeKeyword(STR_INTEL__39, clEOA));
    clSetq(keyX86, clMakeKeyword(STR_X86__37, clEOA));
    clSetq(CONS_32, clCons(keyX86, clNIL, clEOA));
    clSetq(CONS_31, clCons(keyINTEL, CONS_32, clEOA));
    clSetq(CONS_30, clCons(keyPC, CONS_31, clEOA));
    clSetq(keySUN, clMakeKeyword(STR_SUN__29, clEOA));
    clSetq(STR_UNIX__40, clCharpSimpleBaseString("UNIX"));
    clSetq(keyUNIX, clMakeKeyword(STR_UNIX__40, clEOA));
    clSetq(CONS_34, clCons(keyUNIX, clNIL, clEOA));
    clSetq(CONS_33, clCons(keySUN, CONS_34, clEOA));
    clSetq(STR_HP__41, clCharpSimpleBaseString("HP"));
    clSetq(keyHP, clMakeKeyword(STR_HP__41, clEOA));
    clSetq(STR_UCS_4_IO__42, clCharpSimpleBaseString("UCS-4-IO"));
    clSetq(keyUCS_4_IO, clMakeKeyword(STR_UCS_4_IO__42, clEOA));
    clSetq(CONS_37, clCons(keyUCS_4_IO, clNIL, clEOA));
    clSetq(CONS_36, clCons(keyUNIX, CONS_37, clEOA));
    clSetq(CONS_35, clCons(keyHP, CONS_36, clEOA));
    clSetq(STR_LINUX__43, clCharpSimpleBaseString("LINUX"));
    clSetq(STR_WINDOWS__44, clCharpSimpleBaseString("WINDOWS"));
    clSetq(keyWINDOWS, clMakeKeyword(STR_WINDOWS__44, clEOA));
    clSetq(STR_WIN32__45, clCharpSimpleBaseString("WIN32"));
    clSetq(keyWIN32, clMakeKeyword(STR_WIN32__45, clEOA));
    clSetq(STR_95__46, clCharpSimpleBaseString("95"));
    clSetq(STR_WIN95__47, clCharpSimpleBaseString("WIN95"));
    clSetq(keyWIN95, clMakeKeyword(STR_WIN95__47, clEOA));
    clSetq(CONS_38, clCons(keyWIN95, clNIL, clEOA));
    clSetq(STR_NT__48, clCharpSimpleBaseString("NT"));
    clSetq(keyNT, clMakeKeyword(STR_NT__48, clEOA));
    clSetq(CONS_39, clCons(keyNT, clNIL, clEOA));
  
    cl_SETF_GlobalDeclaration(clT,
                              clINTERNAL_TIME_UNITS_PER_SECOND,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    cl_SETF_GlobalDeclaration(clT,
                              clINTERNAL_TIME_UNITS_PER_SECOND,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    cl_SETF_GlobalDeclaration(clT,
                              clstarTRACE_LEVELstar,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    clSetSymbolValueValue(clstarTRACE_LEVELstar, I_0);
    (void) clstarTRACE_LEVELstar;
    cl_SETF_GlobalDeclaration(clT,
                              clstarTRACE_DATAstar,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    clSetSymbolValueValue(clstarTRACE_DATAstar, clNIL);
    (void) clstarTRACE_DATAstar;
    clSetSymbolFunctionValue(clLIST_TRACED,
                             clMakeClosure(0,
                                           clListTraced,
                                           clNULL_HOOK));
    (void) clLIST_TRACED;
    clSetSymbolFunctionValue(clTRACE1,
                             clMakeClosure(0, clTrace1, clNULL_HOOK));
    (void) clTRACE1;
    clSetSymbolFunctionValue(clUNTRACE1,
                             clMakeClosure(0, clUntrace1, clNULL_HOOK));
    (void) clUNTRACE1;
    { clObject L_value421;
      clSetq(L_value421, clMakeClosure(0, clTrace, clNULL_HOOK));
      cl_SETF_MacroFunction(L_value421, clTRACE, clEOA); }
    (void) clTRACE;
    { clObject L_value423;
      clSetq(L_value423, clMakeClosure(0, clUntrace, clNULL_HOOK));
      cl_SETF_MacroFunction(L_value423, clUNTRACE, clEOA); }
    (void) clUNTRACE;
    clSetSymbolFunctionValue(clEND_TIME,
                             clMakeClosure(0, clEndTime, clNULL_HOOK));
    (void) clEND_TIME;
    { clObject L_value425;
      clSetq(L_value425, clMakeClosure(0, clTime, clNULL_HOOK));
      cl_SETF_MacroFunction(L_value425, clTIME, clEOA); }
    (void) clTIME;
    clSetSymbolFunctionValue(clDESCRIBE,
                             clMakeClosure(0, clDescribe, clNULL_HOOK));
    (void) clDESCRIBE;
    clSetSymbolFunctionValue(clINSPECT,
                             clMakeClosure(0, clInspect, clNULL_HOOK));
    (void) clINSPECT;
    clSetSymbolFunctionValue(clROOM,
                             clMakeClosure(0, clRoom, clNULL_HOOK));
    (void) clROOM;
    clSetSymbolFunctionValue(clED, clMakeClosure(0, clEd, clNULL_HOOK));
    (void) clED;
    clSetSymbolFunctionValue(clAPROPOS,
                             clMakeClosure(0, clApropos, clNULL_HOOK));
    (void) clAPROPOS;
    clSetSymbolFunctionValue(clAPROPOS_LIST,
                             clMakeClosure(0,
                                           clAproposList,
                                           clNULL_HOOK));
    (void) clAPROPOS_LIST;
    clSetSymbolFunctionValue(clGET_INTERNAL_RUN_TIME,
                             clMakeClosure(0,
                                           clGetInternalRunTime,
                                           clNULL_HOOK));
    (void) clGET_INTERNAL_RUN_TIME;
    clSetSymbolFunctionValue(clGET_INTERNAL_REAL_TIME,
                             clMakeClosure(0,
                                           clGetInternalRealTime,
                                           clNULL_HOOK));
    (void) clGET_INTERNAL_REAL_TIME;
    cl_SETF_GlobalDeclaration(clT,
                              clUNIX_TO_UNIVERSAL_TIME,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clUNIX_TO_UNIVERSAL_TIME, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clUNIX_TO_UNIVERSAL_TIME,
                             I_2208988800,
                             clEOA); }
    else clSetSymbolValueValue(clUNIX_TO_UNIVERSAL_TIME, I_2208988800);
    cl_SETF_GlobalDeclaration(clT,
                              clUNIX_TO_UNIVERSAL_TIME,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clUNIX_TO_UNIVERSAL_TIME;
    clSetSymbolFunctionValue(clGET_UNIVERSAL_TIME,
                             clMakeClosure(0,
                                           clGetUniversalTime,
                                           clNULL_HOOK));
    (void) clGET_UNIVERSAL_TIME;
    cl_SETF_GlobalDeclaration(clT,
                              clMINUTES_PER_DAY,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clMINUTES_PER_DAY, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clMINUTES_PER_DAY,
                             clFuncallFunction(clSymbolFunctionValue(clMULT),
                                               I_24,
                                               I_60,
                                               clEOA),
                             clEOA); }
    else
      clSetSymbolValueValue(clMINUTES_PER_DAY,
                            clFuncallFunction(clSymbolFunctionValue(clMULT),
                                              I_24,
                                              I_60,
                                              clEOA));
    cl_SETF_GlobalDeclaration(clT,
                              clMINUTES_PER_DAY,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clMINUTES_PER_DAY;
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_OFFSET,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clSECONDS_OFFSET, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clSECONDS_OFFSET, I_432000, clEOA); }
    else clSetSymbolValueValue(clSECONDS_OFFSET, I_432000);
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_OFFSET,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clSECONDS_OFFSET;
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_IN_WEEK,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clSECONDS_IN_WEEK, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clSECONDS_IN_WEEK,
                             clSTAR_FUNC(I_60, I_60, I_24, I_7, clEOA),
                             clEOA); }
    else
      clSetSymbolValueValue(clSECONDS_IN_WEEK,
                            clSTAR_FUNC(I_60, I_60, I_24, I_7, clEOA));
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_IN_WEEK,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clSECONDS_IN_WEEK;
    cl_SETF_GlobalDeclaration(clT,
                              clWEEKS_OFFSET,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clWEEKS_OFFSET, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clWEEKS_OFFSET, I_2145, clEOA); }
    else clSetSymbolValueValue(clWEEKS_OFFSET, I_2145);
    cl_SETF_GlobalDeclaration(clT,
                              clWEEKS_OFFSET,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clWEEKS_OFFSET;
    cl_SETF_GlobalDeclaration(clT,
                              clNOVEMBER_17_1858,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clNOVEMBER_17_1858, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clNOVEMBER_17_1858, I_678882, clEOA); }
    else clSetSymbolValueValue(clNOVEMBER_17_1858, I_678882);
    cl_SETF_GlobalDeclaration(clT,
                              clNOVEMBER_17_1858,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clNOVEMBER_17_1858;
    cl_SETF_GlobalDeclaration(clT,
                              clWEEKDAY_NOVEMBER_17_1858,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clWEEKDAY_NOVEMBER_17_1858, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clWEEKDAY_NOVEMBER_17_1858, I_2, clEOA); }
    else clSetSymbolValueValue(clWEEKDAY_NOVEMBER_17_1858, I_2);
    cl_SETF_GlobalDeclaration(clT,
                              clWEEKDAY_NOVEMBER_17_1858,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clWEEKDAY_NOVEMBER_17_1858;
    cl_SETF_GlobalDeclaration(clT,
                              clQUARTER_DAYS_PER_YEAR,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clQUARTER_DAYS_PER_YEAR, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clQUARTER_DAYS_PER_YEAR,
                             cl1PLUS_FUNC(clFuncallFunction(clSymbolFunctionValue(clMULT),
                                                            I_365,
                                                            I_4,
                                                            clEOA),
                                          clEOA),
                             clEOA); }
    else
      clSetSymbolValueValue(clQUARTER_DAYS_PER_YEAR,
                            cl1PLUS_FUNC(clFuncallFunction(clSymbolFunctionValue(clMULT),
                                                           I_365,
                                                           I_4,
                                                           clEOA),
                                         clEOA));
    cl_SETF_GlobalDeclaration(clT,
                              clQUARTER_DAYS_PER_YEAR,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clQUARTER_DAYS_PER_YEAR;
    cl_SETF_GlobalDeclaration(clT,
                              clQUARTER_DAYS_PER_CENTURY,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clQUARTER_DAYS_PER_CENTURY, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clQUARTER_DAYS_PER_CENTURY,
                             I_146097,
                             clEOA); }
    else clSetSymbolValueValue(clQUARTER_DAYS_PER_CENTURY, I_146097);
    cl_SETF_GlobalDeclaration(clT,
                              clQUARTER_DAYS_PER_CENTURY,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clQUARTER_DAYS_PER_CENTURY;
    clSetSymbolFunctionValue(clDECODE_UNIVERSAL_TIME,
                             clMakeClosure(0,
                                           clDecodeUniversalTime,
                                           clNULL_HOOK));
    (void) clDECODE_UNIVERSAL_TIME;
    clSetSymbolFunctionValue(clGET_DECODED_TIME,
                             clMakeClosure(0,
                                           clGetDecodedTime,
                                           clNULL_HOOK));
    (void) clGET_DECODED_TIME;
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_PER_HOUR,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clSECONDS_PER_HOUR, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clSECONDS_PER_HOUR,
                             clFuncallFunction(clSymbolFunctionValue(clMULT),
                                               I_60,
                                               I_60,
                                               clEOA),
                             clEOA); }
    else
      clSetSymbolValueValue(clSECONDS_PER_HOUR,
                            clFuncallFunction(clSymbolFunctionValue(clMULT),
                                              I_60,
                                              I_60,
                                              clEOA));
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_PER_HOUR,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clSECONDS_PER_HOUR;
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_PER_DAY,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clSECONDS_PER_DAY, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clSECONDS_PER_DAY,
                             clSTAR_FUNC(I_60, I_60, I_24, clEOA),
                             clEOA); }
    else
      clSetSymbolValueValue(clSECONDS_PER_DAY,
                            clSTAR_FUNC(I_60, I_60, I_24, clEOA));
    cl_SETF_GlobalDeclaration(clT,
                              clSECONDS_PER_DAY,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clSECONDS_PER_DAY;
    cl_SETF_GlobalDeclaration(clT,
                              clDAYS_IN_YEAR_BY_MONTH,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clBoundp(clDAYS_IN_YEAR_BY_MONTH, clEOA)))
      { if (clTrue(clSymbolValue(clstarCONSTANT_CHECK_HOOKstar, clEOA)))
          clRedefineConstant(clDAYS_IN_YEAR_BY_MONTH, A_19, clEOA); }
    else clSetSymbolValueValue(clDAYS_IN_YEAR_BY_MONTH, A_19);
    cl_SETF_GlobalDeclaration(clT,
                              clDAYS_IN_YEAR_BY_MONTH,
                              clGLOBAL_VARIABLE,
                              clCONSTANT,
                              clEOA);
    (void) clDAYS_IN_YEAR_BY_MONTH;
    clSetSymbolFunctionValue(clCANONICAL_YEAR,
                             clMakeClosure(0,
                                           clCanonicalYear,
                                           clNULL_HOOK));
    (void) clCANONICAL_YEAR;
    clSetSymbolFunctionValue(clLEAP_DAYS_SINCE_1900,
                             clMakeClosure(0,
                                           clLeapDaysSince1900,
                                           clNULL_HOOK));
    (void) clLEAP_DAYS_SINCE_1900;
    clSetSymbolFunctionValue(clENCODE_UNIVERSAL_TIME,
                             clMakeClosure(0,
                                           clEncodeUniversalTime,
                                           clNULL_HOOK));
    (void) clENCODE_UNIVERSAL_TIME;
    clSetSymbolFunctionValue(clSLEEP,
                             clMakeClosure(0, clSleep, clNULL_HOOK));
    (void) clSLEEP;
    clSetSymbolFunctionValue(clLISP_IMPLEMENTATION_TYPE,
                             clMakeClosure(0,
                                           clLispImplementationType,
                                           clNULL_HOOK));
    (void) clLISP_IMPLEMENTATION_TYPE;
    clSetSymbolFunctionValue(clLISP_IMPLEMENTATION_VERSION,
                             clMakeClosure(0,
                                           clLispImplementationVersion,
                                           clNULL_HOOK));
    (void) clLISP_IMPLEMENTATION_VERSION;
    clSetSymbolFunctionValue(clUSER_ID,
                             clMakeClosure(0, clUserId, clNULL_HOOK));
    (void) clUSER_ID;
    cl_SETF_GlobalDeclaration(clT,
                              clstarMACHINE_VERSIONstar,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clNot(clBoundp(clstarMACHINE_VERSIONstar, clEOA), clEOA)))
      clSetSymbolValueValue(clstarMACHINE_VERSIONstar, clNIL);
    (void) clstarMACHINE_VERSIONstar;
    clSetSymbolFunctionValue(clMACHINE_VERSION,
                             clMakeClosure(0,
                                           clMachineVersion,
                                           clNULL_HOOK));
    (void) clMACHINE_VERSION;
    clSetSymbolFunctionValue(clMACHINE_INSTANCE,
                             clMakeClosure(0,
                                           clMachineInstance,
                                           clNULL_HOOK));
    (void) clMACHINE_INSTANCE;
    clSetSymbolFunctionValue(clMACHINE_TYPE,
                             clMakeClosure(0,
                                           clMachineType,
                                           clNULL_HOOK));
    (void) clMACHINE_TYPE;
    clSetSymbolFunctionValue(clSOFTWARE_TYPE,
                             clMakeClosure(0,
                                           clSoftwareType,
                                           clNULL_HOOK));
    (void) clSOFTWARE_TYPE;
    clSetSymbolFunctionValue(clSOFTWARE_VERSION,
                             clMakeClosure(0,
                                           clSoftwareVersion,
                                           clNULL_HOOK));
    (void) clSOFTWARE_VERSION;
    cl_SETF_GlobalDeclaration(clT,
                              clstarSHORT_SITE_NAMEstar,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clNot(clBoundp(clstarSHORT_SITE_NAMEstar, clEOA), clEOA)))
      clSetSymbolValueValue(clstarSHORT_SITE_NAMEstar, clNIL);
    (void) clstarSHORT_SITE_NAMEstar;
    cl_SETF_GlobalDeclaration(clT,
                              clstarLONG_SITE_NAMEstar,
                              clGLOBAL_VARIABLE,
                              clSPECIAL,
                              clEOA);
    if (clTrue(clNot(clBoundp(clstarLONG_SITE_NAMEstar, clEOA), clEOA)))
      clSetSymbolValueValue(clstarLONG_SITE_NAMEstar, clNIL);
    (void) clstarLONG_SITE_NAMEstar;
    clSetSymbolFunctionValue(clSHORT_SITE_NAME,
                             clMakeClosure(0,
                                           clShortSiteName,
                                           clNULL_HOOK));
    (void) clSHORT_SITE_NAME;
    clSetSymbolFunctionValue(clLONG_SITE_NAME,
                             clMakeClosure(0,
                                           clLongSiteName,
                                           clNULL_HOOK));
    (void) clLONG_SITE_NAME;
    clSetSymbolFunctionValue(clID_STRING,
                             clMakeClosure(0, clIdString, clNULL_HOOK));
    (void) clID_STRING;
    { clObject machine, software;
      clSetq(machine, clStringUpcase(clMachineType(clEOA), clEOA));
      clSetq(software, clStringUpcase(clSoftwareType(clEOA), clEOA));
      { clObject L_8, L_7, L_6;
        { clObject L_0__R1;
          { clObject L_1__R1;
            clSetq(L_1__R1, clLispImplementationVersion(clEOA));
            clSetq(L_0__R1,
                   clIdString(STR_ECLIPSE___28,
                              L_1__R1,
                              clNIL,
                              clNIL,
                              clEOA)); }
          clSetq(L_6, clMakeKeyword(L_0__R1, clEOA)); }
        clSetq(L_7, clMakeKeyword(machine, clEOA));
        { clObject L_1__R1, L_0__R1;
          if (clTrue(clSearch(STR_SUN__29, machine, clEOA)))
            clSetq(L_0__R1, CONS_28);
          else if (clTrue(clSearch(STR_9000__31, machine, clEOA)))
            clSetq(L_0__R1, CONS_29);
          else
            { clObject L_test__R2;
              { clObject L_g656;
                clSetq(L_g656, clSearch(STR_I386__33, machine, clEOA));
                if (clTrue(L_g656))
                  clSetq(L_test__R2, L_g656);
                else
                  { clObject L_g657;
                    clSetq(L_g657,
                           clSearch(STR_I486__34, machine, clEOA));
                    if (clTrue(L_g657))
                      clSetq(L_test__R2, L_g657);
                    else
                      { clObject L_g658;
                        clSetq(L_g658,
                               clSearch(STR_I586__35, machine, clEOA));
                        if (clTrue(L_g658))
                        clSetq(L_test__R2, L_g658);
                        else
                        { clObject L_g659;
                          clSetq(L_g659,
                                 clSearch(STR_I686__36, machine, clEOA));
                          clSetq(L_test__R2,
                                 (clTrue(L_g659) ?
                                  L_g659 :
                                  clSearch(STR_X86__37,
                                           machine,
                                           clEOA))); } } } }
              clSetq(L_0__R1, (clTrue(L_test__R2) ? CONS_30 : clNIL)); }
          { clObject L_1__R2, L_0__R2;
            clSetq(L_0__R2, clMakeKeyword(software, clEOA));
            if (clTrue(clSearch(STR_SUN__29, software, clEOA)))
              clSetq(L_1__R2, CONS_33);
            else if (clTrue(clSearch(STR_HP__41, software, clEOA)))
              clSetq(L_1__R2, CONS_35);
            else if (clTrue(clSearch(STR_LINUX__43, software, clEOA)))
              clSetq(L_1__R2, CONS_34);
            else if (clTrue(clSearch(STR_WINDOWS__44, software, clEOA)))
              { clObject L_2__R1;
                { clObject L_1__R4, L_0__R4;
                  clSetq(L_0__R4,
                         (clTrue(clSearch(STR_95__46, software, clEOA)) ?
                          CONS_38 :
                          clNIL));
                  clSetq(L_1__R4,
                         (clTrue(clSearch(STR_NT__48, software, clEOA)) ?
                          CONS_39 :
                          clNIL));
                  clSetq(L_2__R1, clAppend(L_0__R4, L_1__R4, clEOA)); }
                clSetq(L_1__R2,
                       clListSTAR(keyWINDOWS,
                                  keyWIN32,
                                  L_2__R1,
                                  clEOA)); }
            else clSetq(L_1__R2, clNIL);
            clSetq(L_1__R1, clListSTAR(L_0__R2, L_1__R2, clEOA)); }
          clSetq(L_8, clAppend(L_0__R1, L_1__R1, clEOA)); }
        clSetSymbolValueValue(clstarFEATURESstar,
                              clListSTAR(keyECLIPSE,
                                         keyELWOOD,
                                         keyCOMMON_LISP,
                                         keyANSI_CL,
                                         keyX3J13,
                                         keyIEEE_FLOATING_POINT,
                                         L_6,
                                         L_7,
                                         L_8,
                                         clEOA)); } }
    clSetSymbolFunctionValue(clCONSTANTLY,
                             clMakeClosure(0,
                                           clConstantly,
                                           clNULL_HOOK));
    (void) clCONSTANTLY;
    clUnwind(4); }
  