text: /* Generated by Eclipse Common Lisp 1.1-HOSTED on cad0.
     Thursday the twenty-eighth of May, 1998, 10:45:27 am CDT. */
  #include <eclipse.h>
  
  clObject clDIVEQUAL_FUNC(clProto), cl1PLUS_FUNC(clProto),
    clAddInteger(clProto), clApply(clProto),
    clCanonicalizeSpecializer(clProto), clCar(clProto), clCarEq(clProto),
    clCdr(clProto), clCharpSimpleBaseString __P((clCharp)),
    clClassOf(clProto), clClassp(clProto), clConcatenateNames(clProto),
    clCons(clProto), clEndp(clProto), clEnsureClass(clProto),
    clEnsureGenericFunction(clProto), clEnsureMethod(clProto),
    clEq(clProto), clError(clProto), clExpandType(clProto),
    clExtraArgs(clProto), clFastFind __P((clObject, clObject)),
    clFastFindSlot __P((clObject, clObject)), clFindClass(clProto),
    clFindType(clProto), clFirst(clProto), clFuncall(clProto),
    clGeInteger(clProto), clGensym(clProto), clGetf(clProto),
    clKeyNotAllowed(clProto), clLength(clProto), clList(clProto),
    clMakeDirectSlotDefinition(clProto),
    clMakeEffectiveSlotDefinition(clProto),
    clMakeEmptyStructure(clProto), clMakeHiddenSlot(clProto),
    clMakeKeyword(clProto),
    clMakeStandardInstance __P((clObject, clObject, clObject)),
    clMakeSymbol(clProto), clMissingArgs(clProto), clNot(clProto),
    clNull(clProto), clProperName(clProto), clRest(clProto),
    clRplacd(clProto), clSecond(clProto), clSignalProgramError(clProto),
    cl_SETF_SlotValue(clProto), clStandardInstanceAccess(clProto),
    cl_SETF_Structref(clProto), clStructref(clProto),
    clUpdateInstance(clProto);
  
  extern clObject clampersandKEY, clampersandOPTIONAL, clampersandREST,
    clDYNAMIC_EXTENT, clIGNORE, clQUOTE, clSTRUCTURE, clTYPE,
    clstarCURRENT_LEVELstar, clABSTRACT, clABSTRACT_CLASS_P,
    clABSTRACT_STRUCTURE_CLASS_P, clADD, clALLOCATE_INSTANCE, clCLASS,
    clCLASS_FINALIZED_P, clCLASS_NAME, clCLASS_PROTOTYPE, clCLASS_SLOTS,
    clCOMPUTE_EFFECTIVE_SLOT_DEFINITION, clCONC_NAME, clCONSTRUCTORS,
    clCONTRIBUTING_SLOTS, clCOPIER, clCOPY_STRUCTURE,
    clDIRECT_SLOT_DEFINITION, clDIRECT_SLOT_DEFINITION_CLASS,
    clDIRECT_SLOT_DEFINITIONS, clDIRECT_SLOTS, clDIRECT_SUPERCLASSES,
    clEFFECTIVE_SLOT_DEFINITION, clEFFECTIVE_SLOT_DEFINITION_CLASS,
    clEFFECTIVE_SLOTS, clENSURE_CLASS, clENSURE_STRUCTURE, clENVIRONMENT,
    clFINALIZE_INHERITANCE, clFIND_TYPE, clFUNCTION, clHIDDEN,
    clILLEGAL_STRUCTURE_INITIALIZATION, clINHERITED_SLOTS, clINITARGS,
    clINITFORM, clINITFUNCTION, clINITIAL_OFFSET,
    clLEVEL_STRUCTURE_PRINTER, clLIST, clMAKE_EMPTY_STRUCTURE,
    clMAKE_HIDDEN_SLOT, clMAKE_INSTANCE, clMAKE_LOAD_FORM,
    clMAKE_STANDARD_STRUCTURE_CONSTRUCTOR_NAME, clMAKE_STRUCTURE,
    clMAKE_STRUCTURE_KEYLIST, clMETHOD_FUNCTION, clNAME, clNAMED,
    clNEW_VALUE, clNO_NEXT_METHOD, clNONE, clOBJECT, clOR, clPREDICATE,
    clREAD_ONLY, clSETF, clSHALLOW_COPY, clSHARED_INITIALIZE, clSLOT,
    clSLOT_BOUNDP_USING_CLASS, clSLOT_DEFINITION,
    clSLOT_DEFINITION_HIDDEN, clSLOT_DEFINITION_INITFORM,
    clSLOT_DEFINITION_LOCATION, clSLOT_DEFINITION_NAME,
    clSLOT_DEFINITION_READ_ONLY, clSLOT_DEFINITION_TYPE, clSLOT_NAMES,
    clSLOT_VALUE_USING_CLASS, clSTANDARD_CLASS, clSTANDARD_METHOD,
    clSTRUCTREF, clSTRUCTURE_CLASS, clSTRUCTURE_CONC_NAME,
    clSTRUCTURE_CONSTRUCTORS, clSTRUCTURE_COPIER,
    clSTRUCTURE_DIRECT_SLOT_DEFINITION,
    clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION, clSTRUCTURE_INHERITED_SLOTS,
    clSTRUCTURE_INITIAL_OFFSET, clSTRUCTURE_NAMED, clSTRUCTURE_OBJECT,
    clSTRUCTURE_PREDICATE, clSTRUCTURE_SLOT_DEFINITION, clSTRUCTURE_TYPE,
    clSUBT, clSUBTYPEP, clTYPE_ERROR, clTYPE_FOR_COPY, clTYPE_NAME_INDEX;
  
  static clObject 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_40, CONS_41, CONS_42, CONS_43, CONS_44, CONS_45,
    CONS_46, CONS_47, CONS_48, CONS_49, CONS_5, CONS_50, CONS_51,
    CONS_52, CONS_53, CONS_54, CONS_55, CONS_56, CONS_57, CONS_58,
    CONS_59, CONS_6, CONS_60, CONS_61, CONS_62, CONS_63, CONS_64, CONS_7,
    CONS_8, CONS_9, I_0, I_1, I_16, I_2, I_3, I_4, keyABSTRACT, keyAFTER,
    keyCONC_NAME, keyCONSTRUCTORS, keyCOPIER, keyDATUM, keyDECLARATIONS,
    keyDIRECT_DEFAULT_INITARGS, keyDIRECT_SLOTS, keyDIRECT_SUPERCLASSES,
    keyDOCUMENTATION, keyEXPECTED_TYPE, keyFUNCTION, keyHIDDEN,
    keyINHERITED_SLOTS, keyINITARGS, keyINITFORM, keyINITFUNCTION,
    keyINITIAL_OFFSET, keyLAMBDA_LIST, keyMETACLASS, keyNAME, keyNAMED,
    keyPREDICATE, keyQUALIFIERS, keyREAD_ONLY, keyREADERS,
    keySPECIALIZERS, keyTYPE, STR__P__31, STR____30, STR_ABSTRACT__2,
    STR_AFTER__29, STR_CONC_NAME__12, STR_CONSTRUCTORS__15,
    STR_COPIER__14, STR_COPY___32, STR_DATUM__37, STR_DECLARATIONS__24,
    STR_DIRECT_SLOTS__1, STR_DIRECT_SUPERCLASSES__0,
    STR_DOCUMENTATION__25, STR_EXPECTED_TYPE__38, STR_FUNCTION__23,
    STR_HIDDEN__19, STR_INHERITED_SLOTS__11, STR_INITARGS__6,
    STR_INITFORM__5, STR_INITFUNCTION__4, STR_INITIAL_OFFSET__10,
    STR_LAMBDA_LIST__21, STR_LTV__36, STR_MAKE___39, STR_METACLASS__35,
    STR_NAMED__9, STR_NAME__3, STR_PAD__26, STR_PREDICATE__13,
    STR_QUALIFIERS__20, STR_READ_ONLY__18, STR_READERS__8,
    STR_SPECIALIZERS__22, STR_TYPE__7, STRn_16, STRn_17, STRn_27,
    STRn_28, STRn_33, STRn_34, SYM_0_LTV;
  
  clObject clStructref clVdecl(_ap)
  { clObject CL_struct, location;
    { clBeginParse(_ap);
      clSetq(CL_struct,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(location,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject CL_wrapper;
      { clObject L_0;
        clSetq(L_0, CL_struct);
        clSetq(CL_wrapper, clTaggedInstanceWrapper(L_0)); }
      if (clTrue(clWrapperInvalidP(CL_wrapper)))
        { clObject L_2, L_0;
          clSetq(L_0, CL_struct);
          { clObject L_0__R1;
            clSetq(L_0__R1, CL_struct);
            clSetq(L_2, clObjectClass(L_0__R1)); }
          clUpdateInstance(L_0, CL_wrapper, L_2, clEOA); }
      { clObject L_1, L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, CL_struct);
          clSetq(L_0, clStandardInstanceSlots(L_0__R1)); }
        clSetq(L_1, location);
        return(clValues1(clGetSlot(L_0, L_1))); } } }
  
  clObject cl_SETF_Structref clVdecl(_ap)
  { clObject val, CL_struct, location;
    { clBeginParse(_ap);
      clSetq(val,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(CL_struct,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      clSetq(location,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_3, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject CL_wrapper;
      { clObject L_0;
        clSetq(L_0, CL_struct);
        clSetq(CL_wrapper, clTaggedInstanceWrapper(L_0)); }
      if (clTrue(clWrapperInvalidP(CL_wrapper)))
        { clObject L_2, L_0;
          clSetq(L_0, CL_struct);
          { clObject L_0__R1;
            clSetq(L_0__R1, CL_struct);
            clSetq(L_2, clObjectClass(L_0__R1)); }
          clUpdateInstance(L_0, CL_wrapper, L_2, clEOA); }
      { clObject L_2, L_1, L_0;
        { clObject L_0__R1;
          clSetq(L_0__R1, CL_struct);
          clSetq(L_0, clStandardInstanceSlots(L_0__R1)); }
        clSetq(L_1, location);
        clSetq(L_2, val);
        return(clValues1(clSetSlot(L_0, L_1, L_2))); } } }
  
  clObject clMakeEmptyStructure clVdecl(_ap)
  { clObject CL_class, length;
    { clBeginParse(_ap);
      clSetq(CL_class,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(length,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_2, L_1, L_0;
      clSetq(L_0, length);
      clSetq(L_1, CL_class);
      { clObject L_0__R1;
        clSetq(L_0__R1, CL_class);
        clSetq(L_2, clStandardInstanceAccess(L_0__R1, I_16, clEOA)); }
      return(clValues1(clMakeStandardInstance(L_0, L_1, L_2))); } }
  
  clObject clMakeStructure clVdecl(_ap)
  { clObject name, slot_values;
    { clBeginParse(_ap);
      clSetq(name,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(slot_values, clVargs(_ap));
      clEndParse(_ap); }
    { clObject CL_class, CL_struct, slots;
      { clObject L_0;
        clSetq(L_0, name);
        clSetq(CL_class, clFindType(L_0, clEOA)); }
      clSetq(CL_struct,
             clMakeEmptyStructure(CL_class,
                                  clLength(slot_values, clEOA),
                                  clEOA));
      clSetq(slots, clStandardInstanceSlots(CL_struct));
      { clObject value, L_g0, index;
        clSetq(value, clNIL);
        clSetq(L_g0, slot_values);
        clSetq(index, I_0);
        if (clTrue(clEndp(L_g0, clEOA))) goto END_LOOP;
        clSetq(value, clCar(L_g0, clEOA));
        clLabel(NEXT_LOOP);
        { clObject L_0;
          clSetq(L_0, L_g0);
          clSetq(L_g0, clCdr(L_0, clEOA)); }
        { clObject L_2;
          clSetq(L_2, value);
          clSetSlot(slots, index, L_2); }
        { clObject L_test;
          { clObject L_0;
            clSetq(L_0, L_g0);
            clSetq(L_test, clEndp(L_0, clEOA)); }
          if (clTrue(L_test)) goto END_LOOP; }
        { clObject L_first_val395;
          { clObject L_0;
            clSetq(L_0, L_g0);
            clSetq(L_first_val395, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, index);
            clSetq(index, cl1PLUS_FUNC(L_0, clEOA)); }
          clSetq(value, L_first_val395); }
        goto NEXT_LOOP;
        clLabel(END_LOOP); }
      return(clValues1(CL_struct)); } }
  
  clObject clAbstractStructureClassP clVdecl(_ap)
  { clObject CL_class;
    { clBeginParse(_ap);
      clSetq(CL_class,
             (_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, CL_class);
        clSetq(L_test,
               clClassp(L_0,
                        clFindType(clSTRUCTURE_CLASS, clEOA),
                        clEOA)); }
      if (clTrue(L_test))
        { clObject L_0;
          clSetq(L_0, CL_class);
          return(clFuncallFunction(clSymbolFunctionValue(clABSTRACT_CLASS_P),
                                   L_0,
                                   clEOA)); }
      else return(clValues1(clNIL)); } }
  
  static clObject clLambda clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clSTRUCTURE_OBJECT)); }
  
  static clObject clLambda_r1 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(I_0)); }
  
  static clObject clLambda_r2 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clNIL)); }
  
  static clObject clLambda_r3 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clList(clFindType(clSTRUCTURE_OBJECT, clEOA), clEOA)); }
  
  clObject clIllegalStructureInitialization clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clError(STRn_17, clEOA)); }
  
  static clObject clLambda_r4 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clNIL)); }
  
  static clObject clLambda_r5 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clNIL)); }
  
  static clObject clLambda_r6 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clNIL)); }
  
  static clObject clLambda_r7 clVdecl(_ap)
  { { clBeginParse(_ap);
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clSymbolFunctionValue(clILLEGAL_STRUCTURE_INITIALIZATION))); }
  
  clObject clMakeLoadForm_clSTRUCTURE_CLASS clVdecl(_ap)
  { clObject *L_args396 = clMakeBinding(),
    *L_methods397 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args396,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods397,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form401, object, environment;
      clSetq(L_form401, *L_args396);
      if (clTrue(L_form401))
        { clObject L_top402;
          clSetq(L_top402, clCar(L_form401, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form401);
            clSetq(L_form401, clCdr(L_0, clEOA)); }
          clSetq(object, L_top402); }
      else clSetq(object, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form401))
        { clObject L_top403;
          { clObject L_0;
            clSetq(L_0, L_form401);
            clSetq(L_top403, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form401);
            clSetq(L_form401, clCdr(L_0, clEOA)); }
          clSetq(environment, L_top403); }
      else clSetq(environment, clNIL);
      if (clTrue(L_form401))
        { clObject L_0;
          clSetq(L_0, L_form401);
          clExtraArgs(L_0, clEOA); }
      { clObject L_1;
        { clObject L_1__R1;
          { clObject L_2, L_0__R2;
            clSetq(L_0__R2, object);
            clSetq(L_2, environment);
            clSetq(L_1__R1, clProperName(L_0__R2, clT, L_2, clEOA)); }
          clSetq(L_1, clList(clQUOTE, L_1__R1, clEOA)); }
        return(clList(clENSURE_STRUCTURE, L_1, clEOA)); } } }
  
  clObject clDirectSlotDefinitionClass_clSTRUCTURE_CLASS clVdecl(_ap)
  { clObject *L_args404 = clMakeBinding(),
    *L_methods405 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args404,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods405,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form407, CL_class, initargs;
      clSetq(L_form407, *L_args404);
      if (clTrue(L_form407))
        { clObject L_top408;
          clSetq(L_top408, clCar(L_form407, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form407);
            clSetq(L_form407, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top408); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      clSetq(initargs, L_form407);
      return(clFindType(clSTRUCTURE_DIRECT_SLOT_DEFINITION, clEOA)); } }
  
  clObject clEffectiveSlotDefinitionClass_clSTRUCTURE_CLASS clVdecl(_ap)
  { clObject *L_args409 = clMakeBinding(),
    *L_methods410 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args409,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods410,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form412, CL_class, initargs;
      clSetq(L_form412, *L_args409);
      if (clTrue(L_form412))
        { clObject L_top413;
          clSetq(L_top413, clCar(L_form412, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form412);
            clSetq(L_form412, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top413); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      clSetq(initargs, L_form412);
      return(clFindType(clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                        clEOA)); } }
  
  clObject clMakeHiddenSlot clVdecl(_ap)
  { clObject initform;
    { clBeginParse(_ap);
      clSetq(initform, (_clVp(_ap) ? clVpop(_ap) : clNIL));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_8, L_2;
      { clObject L_0__R1;
        clSetq(L_0__R1, (clTrue(initform) ? STR_NAME__3 : STR_PAD__26));
        clSetq(L_2, clGensym(L_0__R1, clEOA)); }
      clSetq(L_8, initform);
      return(clFuncallFunction(clSymbolFunctionValue(clMAKE_INSTANCE),
                               clSTRUCTURE_DIRECT_SLOT_DEFINITION,
                               keyNAME,
                               L_2,
                               keyHIDDEN,
                               clT,
                               keyREAD_ONLY,
                               clT,
                               keyINITFORM,
                               L_8,
                               clEOA)); } }
  
  clObject clComputeEffectiveSlotDefinition_clSTRUCTURE_CLASS_clT_clT clVdecl(_ap)
  { clObject *L_args414 = clMakeBinding(),
    *L_methods415 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args414,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods415,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form417, CL_class, name, direct_slot_definitions;
      clSetq(L_form417, *L_args414);
      if (clTrue(L_form417))
        { clObject L_top418;
          clSetq(L_top418, clCar(L_form417, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form417);
            clSetq(L_form417, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top418); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form417))
        { clObject L_top419;
          { clObject L_0;
            clSetq(L_0, L_form417);
            clSetq(L_top419, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form417);
            clSetq(L_form417, clCdr(L_0, clEOA)); }
          clSetq(name, L_top419); }
      else clSetq(name, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form417))
        { clObject L_top420;
          { clObject L_0;
            clSetq(L_0, L_form417);
            clSetq(L_top420, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form417);
            clSetq(L_form417, clCdr(L_0, clEOA)); }
          clSetq(direct_slot_definitions, L_top420); }
      else clSetq(direct_slot_definitions, clMissingArgs(I_3, clEOA));
      if (clTrue(L_form417))
        { clObject L_0;
          clSetq(L_0, L_form417);
          clExtraArgs(L_0, clEOA); }
      { clObject first, second, plist;
        { clObject L_0;
          clSetq(L_0, direct_slot_definitions);
          clSetq(first, clFirst(L_0, clEOA)); }
        { clObject L_0;
          clSetq(L_0, direct_slot_definitions);
          clSetq(second, clSecond(L_0, clEOA)); }
        { clObject L_9, L_7, L_5, L_3, L_1;
          clSetq(L_1, name);
          clSetq(L_3,
                 clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_INITFORM),
                                   first,
                                   clEOA));
          { clObject type, super;
            clSetq(type,
                   clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_TYPE),
                                     first,
                                     clEOA));
            clSetq(super,
                   (clTrue(second) ?
                    clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_TYPE),
                                      second,
                                      clEOA) :
                    clT));
            { clObject L_test;
              { clObject L_1__R1;
                clSetq(L_1__R1, super);
                clSetq(L_test,
                       clFuncallFunction(clSymbolFunctionValue(clSUBTYPEP),
                                         type,
                                         L_1__R1,
                                         clEOA)); }
              if (clTrue(L_test))
                clSetq(L_5, type);
              else
                { clObject L_3__R1, L_2__R1;
                  clSetq(L_2__R1, name);
                  clSetq(L_3__R1, super);
                  clSetq(L_5,
                         clSignalProgramError(STRn_27,
                                              type,
                                              L_2__R1,
                                              L_3__R1,
                                              clEOA)); } } }
          clSetq(L_7,
                 clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_HIDDEN),
                                   first,
                                   clEOA));
          if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_READ_ONLY),
                                       first,
                                       clEOA)))
            clSetq(L_9, clT);
          else if (clTrue((clTrue(second) ?
                           clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_READ_ONLY),
                                             second,
                                             clEOA) :
                           clNIL)))
            { clObject L_1__R1;
              clSetq(L_1__R1, name);
              clSetq(L_9,
                     clSignalProgramError(STRn_28, L_1__R1, clEOA)); }
          else clSetq(L_9, clNIL);
          clSetq(plist,
                 clList(keyNAME,
                        L_1,
                        keyINITFORM,
                        L_3,
                        keyTYPE,
                        L_5,
                        keyHIDDEN,
                        L_7,
                        keyREAD_ONLY,
                        L_9,
                        clEOA)); }
        { clObject L_0;
          clSetq(L_0, CL_class);
          return(clMakeEffectiveSlotDefinition(L_0,
                                               plist,
                                               clEOA)); } } } }
  
  clObject clSharedInitialize_keyAFTER_clSTRUCTURE_CLASS_clT clVdecl(_ap)
  { clObject *L_args421 = clMakeBinding(),
    *L_methods422 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args421,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods422,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form424, structure, slot_names, initargs;
      clSetq(L_form424, *L_args421);
      if (clTrue(L_form424))
        { clObject L_top425;
          clSetq(L_top425, clCar(L_form424, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form424);
            clSetq(L_form424, clCdr(L_0, clEOA)); }
          clSetq(structure, L_top425); }
      else clSetq(structure, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form424))
        { clObject L_top426;
          { clObject L_0;
            clSetq(L_0, L_form424);
            clSetq(L_top426, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form424);
            clSetq(L_form424, clCdr(L_0, clEOA)); }
          clSetq(slot_names, L_top426); }
      else clSetq(slot_names, clMissingArgs(I_2, clEOA));
      clSetq(initargs, L_form424);
      { clObject L_instance427, L_class428, L_contributing_slots437,
        L_inherited_slots436, L_direct_slots435, L_initial_offset434,
        L_direct_superclasses433, L_named432, L_type431, L_abstract430,
        L_name429;
        clSetq(L_instance427, structure);
        clSetq(L_class428, clClassOf(L_instance427, clEOA));
        clSetq(L_contributing_slots437,
               clFastFindSlot(L_class428, clCONTRIBUTING_SLOTS));
        clSetq(L_inherited_slots436,
               clFastFindSlot(L_class428, clINHERITED_SLOTS));
        clSetq(L_direct_slots435,
               clFastFindSlot(L_class428, clDIRECT_SLOTS));
        clSetq(L_initial_offset434,
               clFastFindSlot(L_class428, clINITIAL_OFFSET));
        clSetq(L_direct_superclasses433,
               clFastFindSlot(L_class428, clDIRECT_SUPERCLASSES));
        clSetq(L_named432, clFastFindSlot(L_class428, clNAMED));
        clSetq(L_type431, clFastFindSlot(L_class428, clTYPE));
        clSetq(L_abstract430, clFastFindSlot(L_class428, clABSTRACT));
        clSetq(L_name429, clFastFindSlot(L_class428, clNAME));
        { clObject struct_name;
          clSetq(struct_name,
                 clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                   L_class428,
                                   L_instance427,
                                   L_name429,
                                   clEOA));
          { clObject L_value438;
            { clObject L_0;
              { clObject L_0__R1;
                clSetq(L_0__R1,
                       clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class428,
                                         L_instance427,
                                         L_type431,
                                         clEOA));
                clSetq(L_0, clEq(L_0__R1, clSTRUCTURE_OBJECT, clEOA)); }
              clSetq(L_value438, clNot(L_0, clEOA)); }
            clFuncallFunction(clFdefinition(CONS_53, clEOA),
                              L_value438,
                              L_class428,
                              L_instance427,
                              L_abstract430,
                              clEOA); }
          { clObject L_test;
            if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class428,
                                         L_instance427,
                                         L_abstract430,
                                         clEOA)))
              { clObject L_0;
                clSetq(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class428,
                                         L_instance427,
                                         L_direct_superclasses433,
                                         clEOA));
                clSetq(L_test,
                       clCarEq(L_0,
                               clFindType(clSTRUCTURE_OBJECT, clEOA),
                               clEOA)); }
            else clSetq(L_test, clNIL);
            if (clTrue(L_test))
              { clObject L_value442;
                clSetq(L_value442,
                       clList(clFindType(clT, clEOA), clEOA));
                clFuncallFunction(clFdefinition(CONS_53, clEOA),
                                  L_value442,
                                  L_class428,
                                  L_instance427,
                                  L_direct_superclasses433,
                                  clEOA); } }
          { clObject L_test;
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, clGetf(initargs, keyNAMED, clNONE, clEOA));
                clSetq(L_test__R1, clEq(L_0, clNONE, clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_g451;
                  { clObject L_0;
                    clSetq(L_0, slot_names);
                    clSetq(L_g451, clEq(L_0, clT, clEOA)); }
                  if (clTrue(L_g451))
                    clSetq(L_test, L_g451);
                  else
                    { { clObject L_sub452;
                        clSetq(L_sub452, slot_names);
                        clLabel(l_ITERATE455);
                        if (clTrue(clEndp(L_sub452, clEOA)))
                        { clSetq(L_test, clNIL); clLocalReturn(NIL); }
                        if (_clEq(clNAMED, clCar(L_sub452, clEOA)))
                        { clSetq(L_test, L_sub452);
                          clLocalReturn(l_MEMBER454); }
                        { clObject L_value456;
                          clSetq(L_value456, clCdr(L_sub452, clEOA));
                          clSetq(L_sub452, L_value456); }
                        goto l_ITERATE455; }
                      clBlockEnd(NIL);
                      clBlockEnd(l_MEMBER454); } }
              else clSetq(L_test, clNIL); }
            if (clTrue(L_test))
              { clObject L_arg458, L_value457;
                clSetq(L_arg458, structure);
                clSetq(L_value457,
                       clNot(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                               L_class428,
                                               L_instance427,
                                               L_abstract430,
                                               clEOA),
                             clEOA));
                cl_SETF_SlotValue(L_value457,
                                  L_arg458,
                                  clNAMED,
                                  clEOA); } }
          { clObject L_test;
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0,
                       clGetf(initargs, keyCONC_NAME, clNONE, clEOA));
                clSetq(L_test__R1, clEq(L_0, clNONE, clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_g465;
                  { clObject L_0;
                    clSetq(L_0, slot_names);
                    clSetq(L_g465, clEq(L_0, clT, clEOA)); }
                  if (clTrue(L_g465))
                    clSetq(L_test, L_g465);
                  else
                    { { clObject L_sub466;
                        clSetq(L_sub466, slot_names);
                        clLabel(l_ITERATE469);
                        if (clTrue(clEndp(L_sub466, clEOA)))
                        { clSetq(L_test, clNIL);
                          clLocalReturn(NIL__r1); }
                        if (_clEq(clCONC_NAME, clCar(L_sub466, clEOA)))
                        { clSetq(L_test, L_sub466);
                          clLocalReturn(l_MEMBER468); }
                        { clObject L_value470;
                          clSetq(L_value470, clCdr(L_sub466, clEOA));
                          clSetq(L_sub466, L_value470); }
                        goto l_ITERATE469; }
                      clBlockEnd(NIL__r1);
                      clBlockEnd(l_MEMBER468); } }
              else clSetq(L_test, clNIL); }
            if (clTrue(L_test))
              { clObject L_arg472, L_value471;
                clSetq(L_arg472, structure);
                clSetq(L_value471,
                       clConcatenateNames(struct_name,
                                          STR____30,
                                          clEOA));
                cl_SETF_SlotValue(L_value471,
                                  L_arg472,
                                  clCONC_NAME,
                                  clEOA); } }
          { clObject L_test;
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0,
                       clGetf(initargs, keyPREDICATE, clNONE, clEOA));
                clSetq(L_test__R1, clEq(L_0, clNONE, clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_g479;
                  { clObject L_0;
                    clSetq(L_0, slot_names);
                    clSetq(L_g479, clEq(L_0, clT, clEOA)); }
                  if (clTrue(L_g479))
                    clSetq(L_test, L_g479);
                  else
                    { { clObject L_sub480;
                        clSetq(L_sub480, slot_names);
                        clLabel(l_ITERATE483);
                        if (clTrue(clEndp(L_sub480, clEOA)))
                        { clSetq(L_test, clNIL);
                          clLocalReturn(NIL__r2); }
                        if (_clEq(clPREDICATE, clCar(L_sub480, clEOA)))
                        { clSetq(L_test, L_sub480);
                          clLocalReturn(l_MEMBER482); }
                        { clObject L_value484;
                          clSetq(L_value484, clCdr(L_sub480, clEOA));
                          clSetq(L_sub480, L_value484); }
                        goto l_ITERATE483; }
                      clBlockEnd(NIL__r2);
                      clBlockEnd(l_MEMBER482); } }
              else clSetq(L_test, clNIL); }
            if (clTrue(L_test))
              { clObject L_arg486, L_value485;
                clSetq(L_arg486, structure);
                clSetq(L_value485,
                       (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                                 L_class428,
                                                 L_instance427,
                                                 L_named432,
                                                 clEOA)) ?
                        clConcatenateNames(struct_name,
                                           STR__P__31,
                                           clEOA) :
                        clNIL));
                { clObject L_0;
                  clSetq(L_0, L_value485);
                  cl_SETF_SlotValue(L_0,
                                    L_arg486,
                                    clPREDICATE,
                                    clEOA); } } }
          { clObject L_test;
            { clObject L_test__R1;
              { clObject L_0;
                clSetq(L_0, clGetf(initargs, keyCOPIER, clNONE, clEOA));
                clSetq(L_test__R1, clEq(L_0, clNONE, clEOA)); }
              if (clTrue(L_test__R1))
                { clObject L_g493;
                  { clObject L_0;
                    clSetq(L_0, slot_names);
                    clSetq(L_g493, clEq(L_0, clT, clEOA)); }
                  if (clTrue(L_g493))
                    clSetq(L_test, L_g493);
                  else
                    { { clObject L_sub494;
                        clSetq(L_sub494, slot_names);
                        clLabel(l_ITERATE497);
                        if (clTrue(clEndp(L_sub494, clEOA)))
                        { clSetq(L_test, clNIL);
                          clLocalReturn(NIL__r3); }
                        if (_clEq(clCOPIER, clCar(L_sub494, clEOA)))
                        { clSetq(L_test, L_sub494);
                          clLocalReturn(l_MEMBER496); }
                        { clObject L_value498;
                          clSetq(L_value498, clCdr(L_sub494, clEOA));
                          clSetq(L_sub494, L_value498); }
                        goto l_ITERATE497; }
                      clBlockEnd(NIL__r3);
                      clBlockEnd(l_MEMBER496); } }
              else clSetq(L_test, clNIL); }
            if (clTrue(L_test))
              { clObject L_arg500, L_value499;
                clSetq(L_arg500, structure);
                clSetq(L_value499,
                       clConcatenateNames(STR_COPY___32,
                                          struct_name,
                                          clEOA));
                cl_SETF_SlotValue(L_value499,
                                  L_arg500,
                                  clCOPIER,
                                  clEOA); } }
          { clObject slots;
            clSetq(slots,
                   clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                     L_class428,
                                     L_instance427,
                                     L_direct_slots435,
                                     clEOA));
            if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class428,
                                         L_instance427,
                                         L_abstract430,
                                         clEOA)))
              { if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                             L_class428,
                                             L_instance427,
                                             L_named432,
                                             clEOA)))
                  { clObject L_1, L_0;
                    clSetq(L_0,
                           clMakeHiddenSlot(clList(clQUOTE,
                                                   clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                                                     L_class428,
                                                                     L_instance427,
                                                                     L_name429,
                                                                     clEOA),
                                                   clEOA),
                                            clEOA));
                    clSetq(L_1, slots);
                    clSetq(slots, clCons(L_0, L_1, clEOA)); }
                { clObject L_end502, n;
                  clSetq(L_end502,
                         clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                           L_class428,
                                           L_instance427,
                                           L_initial_offset434,
                                           clEOA));
                  clSetq(n, I_0);
                  clLabel(l_ITERATE503);
                  if (clTrue(clGeInteger(n, L_end502, clEOA)))
                    clLocalReturn(NIL__r4);
                  { clObject L_1, L_0;
                    clSetq(L_0, clMakeHiddenSlot(clEOA));
                    clSetq(L_1, slots);
                    clSetq(slots, clCons(L_0, L_1, clEOA)); }
                  { clObject L_0;
                    clSetq(L_0, n);
                    clSetq(n, clAddInteger(L_0, I_1, clEOA)); }
                  goto l_ITERATE503; }
                clBlockEnd(NIL__r4); }
            { clObject L_value504;
              clSetq(L_value504, slots);
              clFuncallFunction(clFdefinition(CONS_53, clEOA),
                                L_value504,
                                L_class428,
                                L_instance427,
                                L_contributing_slots437,
                                clEOA); }
            { clObject L_value508;
              { clObject L_sublist512, spec;
                clSetq(L_sublist512,
                       clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class428,
                                         L_instance427,
                                         L_inherited_slots436,
                                         clEOA));
                clSetq(spec, clCar(L_sublist512, clEOA));
                clLabel(l_ITERATE513);
                if (clTrue(clEndp(L_sublist512, clEOA)))
                  { clSetq(L_value508, slots); clLocalReturn(NIL__r5); }
                { clObject L_1, L_0;
                  { clObject L_0__R1;
                    clSetq(L_0__R1, structure);
                    clSetq(L_0,
                           clMakeDirectSlotDefinition(L_0__R1,
                                                      spec,
                                                      clEOA)); }
                  clSetq(L_1, slots);
                  clSetq(slots, clCons(L_0, L_1, clEOA)); }
                { clObject L_0;
                  clSetq(L_0, L_sublist512);
                  clSetq(L_sublist512, clCdr(L_0, clEOA)); }
                { clObject L_0;
                  clSetq(L_0, L_sublist512);
                  clSetq(spec, clCar(L_0, clEOA)); }
                goto l_ITERATE513; }
              clBlockEnd(NIL__r5);
              return(clFuncallFunction(clFdefinition(CONS_53, clEOA),
                                       L_value508,
                                       L_class428,
                                       L_instance427,
                                       L_direct_slots435,
                                       clEOA)); } } } } } }
  
  clObject clFinalizeInheritance_keyAFTER_clSTRUCTURE_CLASS clVdecl(_ap)
  { clObject *L_args514 = clMakeBinding(),
    *L_methods515 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args514,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods515,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form517, structure;
      clSetq(L_form517, *L_args514);
      if (clTrue(L_form517))
        { clObject L_top518;
          clSetq(L_top518, clCar(L_form517, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form517);
            clSetq(L_form517, clCdr(L_0, clEOA)); }
          clSetq(structure, L_top518); }
      else clSetq(structure, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form517))
        { clObject L_0;
          clSetq(L_0, L_form517);
          clExtraArgs(L_0, clEOA); }
      { clObject L_instance519, L_class520, L_effective_slots527,
        L_contributing_slots526, L_type_name_index525,
        L_initial_offset524, L_predicate523, L_named522, L_abstract521;
        clSetq(L_instance519, structure);
        clSetq(L_class520, clClassOf(L_instance519, clEOA));
        clSetq(L_effective_slots527,
               clFastFindSlot(L_class520, clEFFECTIVE_SLOTS));
        clSetq(L_contributing_slots526,
               clFastFindSlot(L_class520, clCONTRIBUTING_SLOTS));
        clSetq(L_type_name_index525,
               clFastFindSlot(L_class520, clTYPE_NAME_INDEX));
        clSetq(L_initial_offset524,
               clFastFindSlot(L_class520, clINITIAL_OFFSET));
        clSetq(L_predicate523, clFastFindSlot(L_class520, clPREDICATE));
        clSetq(L_named522, clFastFindSlot(L_class520, clNAMED));
        clSetq(L_abstract521, clFastFindSlot(L_class520, clABSTRACT));
        { clObject L_test;
          { clObject L_0;
            { clObject L_g528;
              clSetq(L_g528,
                     clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                       L_class520,
                                       L_instance519,
                                       L_abstract521,
                                       clEOA));
              clSetq(L_0,
                     (clTrue(L_g528) ? L_g528 :
                      clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                        L_class520,
                                        L_instance519,
                                        L_named522,
                                        clEOA))); }
            clSetq(L_test, clNot(L_0, clEOA)); }
          if (clTrue(L_test))
            { clObject L_2;
              clSetq(L_2, structure);
              clKeyNotAllowed(keyNAMED, STRn_33, L_2, clEOA); } }
        if (clTrue((clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                             L_class520,
                                             L_instance519,
                                             L_predicate523,
                                             clEOA)) ?
                    clNot(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                            L_class520,
                                            L_instance519,
                                            L_named522,
                                            clEOA),
                          clEOA) :
                    clNIL)))
          { clObject L_2;
            clSetq(L_2, structure);
            clKeyNotAllowed(keyPREDICATE, STRn_34, L_2, clEOA); }
        if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                     L_class520,
                                     L_instance519,
                                     L_abstract521,
                                     clEOA)))
          if (clTrue(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                       L_class520,
                                       L_instance519,
                                       L_named522,
                                       clEOA)))
            { clObject L_value529;
              { clObject L_1, L_0;
                clSetq(L_0,
                       clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                         L_class520,
                                         L_instance519,
                                         L_initial_offset524,
                                         clEOA));
                { clObject L_0__R1;
                  clSetq(L_0__R1,
                         clLength(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                                    L_class520,
                                                    L_instance519,
                                                    L_effective_slots527,
                                                    clEOA),
                                  clEOA));
                  clSetq(L_1,
                         clFuncallFunction(clSymbolFunctionValue(clSUBT),
                                           L_0__R1,
                                           clLength(clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                                                      L_class520,
                                                                      L_instance519,
                                                                      L_contributing_slots526,
                                                                      clEOA),
                                                    clEOA),
                                           clEOA)); }
                clSetq(L_value529,
                       clFuncallFunction(clSymbolFunctionValue(clADD),
                                         L_0,
                                         L_1,
                                         clEOA)); }
              return(clFuncallFunction(clFdefinition(CONS_53, clEOA),
                                       L_value529,
                                       L_class520,
                                       L_instance519,
                                       L_type_name_index525,
                                       clEOA)); }
          else return(clValues1(clNIL));
        else
          { clObject L_test__R1;
            { clObject L_0;
              clSetq(L_0,
                     clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                       L_class520,
                                       L_instance519,
                                       L_initial_offset524,
                                       clEOA));
              clSetq(L_test__R1, clDIVEQUAL_FUNC(L_0, I_0, clEOA)); }
            if (clTrue(L_test__R1))
              { clObject L_2;
                clSetq(L_2, structure);
                return(clKeyNotAllowed(keyINITIAL_OFFSET,
                                       STRn_33,
                                       L_2,
                                       clEOA)); }
            else return(clValues1(clNIL)); } } } }
  
  clObject clAllocateInstance_clSTRUCTURE_CLASS clVdecl(_ap)
  { clObject *L_args533 = clMakeBinding(),
    *L_methods534 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args533,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods534,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form536, CL_class;
      clSetq(L_form536, *L_args533);
      if (clTrue(L_form536))
        { clObject L_top537;
          clSetq(L_top537, clCar(L_form536, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form536);
            clSetq(L_form536, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top537); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      { clObject L_test;
        { clObject L_0;
          { clObject L_0__R1;
            clSetq(L_0__R1, CL_class);
            clSetq(L_0,
                   clFuncallFunction(clSymbolFunctionValue(clCLASS_FINALIZED_P),
                                     L_0__R1,
                                     clEOA)); }
          clSetq(L_test, clNot(L_0, clEOA)); }
        if (clTrue(L_test))
          { clObject L_0;
            clSetq(L_0, CL_class);
            clFuncallFunction(clSymbolFunctionValue(clFINALIZE_INHERITANCE),
                              L_0,
                              clEOA); } }
      { clObject L_1, L_0;
        clSetq(L_0, CL_class);
        { clObject L_0__R1;
          { clObject L_0__R2;
            clSetq(L_0__R2, CL_class);
            clSetq(L_0__R1,
                   clFuncallFunction(clSymbolFunctionValue(clCLASS_SLOTS),
                                     L_0__R2,
                                     clEOA)); }
          clSetq(L_1, clLength(L_0__R1, clEOA)); }
        return(clMakeEmptyStructure(L_0, L_1, clEOA)); } } }
  
  clObject clSlotValueUsingClass_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION clVdecl(_ap)
  { clObject *L_args538 = clMakeBinding(),
    *L_methods539 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args538,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods539,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form541, CL_class, object, slot;
      clSetq(L_form541, *L_args538);
      if (clTrue(L_form541))
        { clObject L_top542;
          clSetq(L_top542, clCar(L_form541, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form541);
            clSetq(L_form541, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top542); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form541))
        { clObject L_top543;
          { clObject L_0;
            clSetq(L_0, L_form541);
            clSetq(L_top543, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form541);
            clSetq(L_form541, clCdr(L_0, clEOA)); }
          clSetq(object, L_top543); }
      else clSetq(object, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form541))
        { clObject L_top544;
          { clObject L_0;
            clSetq(L_0, L_form541);
            clSetq(L_top544, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form541);
            clSetq(L_form541, clCdr(L_0, clEOA)); }
          clSetq(slot, L_top544); }
      else clSetq(slot, clMissingArgs(I_3, clEOA));
      if (clTrue(L_form541))
        { clObject L_0;
          clSetq(L_0, L_form541);
          clExtraArgs(L_0, clEOA); }
      { clObject L_1, L_0;
        clSetq(L_0, object);
        { clObject L_0__R1;
          clSetq(L_0__R1, slot);
          clSetq(L_1,
                 clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_LOCATION),
                                   L_0__R1,
                                   clEOA)); }
        return(clStructref(L_0, L_1, clEOA)); } } }
  
  clObject cl_SETF_SlotValueUsingClass_clT_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION clVdecl(_ap)
  { clObject *L_args545 = clMakeBinding(),
    *L_methods546 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args545,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods546,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form548, new_value, CL_class, object, slot;
      clSetq(L_form548, *L_args545);
      if (clTrue(L_form548))
        { clObject L_top549;
          clSetq(L_top549, clCar(L_form548, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_form548, clCdr(L_0, clEOA)); }
          clSetq(new_value, L_top549); }
      else clSetq(new_value, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form548))
        { clObject L_top550;
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_top550, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_form548, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top550); }
      else clSetq(CL_class, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form548))
        { clObject L_top551;
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_top551, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_form548, clCdr(L_0, clEOA)); }
          clSetq(object, L_top551); }
      else clSetq(object, clMissingArgs(I_3, clEOA));
      if (clTrue(L_form548))
        { clObject L_top552;
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_top552, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form548);
            clSetq(L_form548, clCdr(L_0, clEOA)); }
          clSetq(slot, L_top552); }
      else clSetq(slot, clMissingArgs(I_4, clEOA));
      if (clTrue(L_form548))
        { clObject L_0;
          clSetq(L_0, L_form548);
          clExtraArgs(L_0, clEOA); }
      { clObject L_arg554, L_arg555, L_value553;
        clSetq(L_arg554, object);
        { clObject L_0;
          clSetq(L_0, slot);
          clSetq(L_arg555,
                 clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_LOCATION),
                                   L_0,
                                   clEOA)); }
        clSetq(L_value553, new_value);
        return(cl_SETF_Structref(L_value553,
                                 L_arg554,
                                 L_arg555,
                                 clEOA)); } } }
  
  clObject clSlotBoundpUsingClass_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION clVdecl(_ap)
  { clObject *L_args556 = clMakeBinding(),
    *L_methods557 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args556,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods557,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form559, CL_class, object, slot;
      clSetq(L_form559, *L_args556);
      if (clTrue(L_form559))
        { clObject L_top560;
          clSetq(L_top560, clCar(L_form559, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form559);
            clSetq(L_form559, clCdr(L_0, clEOA)); }
          clSetq(CL_class, L_top560); }
      else clSetq(CL_class, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form559))
        { clObject L_top561;
          { clObject L_0;
            clSetq(L_0, L_form559);
            clSetq(L_top561, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form559);
            clSetq(L_form559, clCdr(L_0, clEOA)); }
          clSetq(object, L_top561); }
      else clSetq(object, clMissingArgs(I_2, clEOA));
      if (clTrue(L_form559))
        { clObject L_top562;
          { clObject L_0;
            clSetq(L_0, L_form559);
            clSetq(L_top562, clCar(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_form559);
            clSetq(L_form559, clCdr(L_0, clEOA)); }
          clSetq(slot, L_top562); }
      else clSetq(slot, clMissingArgs(I_3, clEOA));
      if (clTrue(L_form559))
        { clObject L_0;
          clSetq(L_0, L_form559);
          clExtraArgs(L_0, clEOA); }
      return(clValues1(clT)); } }
  
  clObject clEnsureStructure clVdecl(_ap)
  { clObject name, keys;
    { clBeginParse(_ap);
      clSetq(name,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(keys, clVargs(_ap));
      clEndParse(_ap); }
    { clObject CL_class;
      { clObject L_1, L_0;
        clSetq(L_0, clSymbolFunctionValue(clENSURE_CLASS));
        clSetq(L_1, name);
        clSetq(CL_class,
               clApply(L_0, L_1, keyMETACLASS, clSTRUCTURE_CLASS, keys,
                       clEOA)); }
      clFuncallFunction(clSymbolFunctionValue(clFINALIZE_INHERITANCE),
                        CL_class,
                        clEOA);
      return(clValues1(CL_class)); } }
  
  clObject clTypeForCopy_clT clVdecl(_ap)
  { clObject *L_args564 = clMakeBinding(),
    *L_methods565 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args564,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods565,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form567, object;
      clSetq(L_form567, *L_args564);
      if (clTrue(L_form567))
        { clObject L_top568;
          clSetq(L_top568, clCar(L_form567, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form567);
            clSetq(L_form567, clCdr(L_0, clEOA)); }
          clSetq(object, L_top568); }
      else clSetq(object, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form567))
        { clObject L_0;
          clSetq(L_0, L_form567);
          clExtraArgs(L_0, clEOA); }
      { clObject L_0;
        clSetq(L_0, object);
        return(clClassOf(L_0, clEOA)); } } }
  
  clObject clShallowCopy_clT clVdecl(_ap)
  { clObject *L_args570 = clMakeBinding(),
    *L_methods571 = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*L_args570,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      clSetq(*L_methods571,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_form573, object;
      clSetq(L_form573, *L_args570);
      if (clTrue(L_form573))
        { clObject L_top574;
          clSetq(L_top574, clCar(L_form573, clEOA));
          { clObject L_0;
            clSetq(L_0, L_form573);
            clSetq(L_form573, clCdr(L_0, clEOA)); }
          clSetq(object, L_top574); }
      else clSetq(object, clMissingArgs(I_1, clEOA));
      if (clTrue(L_form573))
        { clObject L_0;
          clSetq(L_0, L_form573);
          clExtraArgs(L_0, clEOA); }
      { clObject CL_class, copy;
        { clObject L_0;
          clSetq(L_0, object);
          clSetq(CL_class,
                 clFuncallFunction(clSymbolFunctionValue(clTYPE_FOR_COPY),
                                   L_0,
                                   clEOA)); }
        clSetq(copy,
               clFuncallFunction(clSymbolFunctionValue(clALLOCATE_INSTANCE),
                                 CL_class,
                                 clEOA));
        { clObject L_sublist575, slot;
          { clObject L_0;
            { clObject L_0__R1;
              clSetq(L_0__R1, object);
              clSetq(L_0, clClassOf(L_0__R1, clEOA)); }
            clSetq(L_sublist575,
                   clFuncallFunction(clSymbolFunctionValue(clCLASS_SLOTS),
                                     L_0,
                                     clEOA)); }
          clSetq(slot, clCar(L_sublist575, clEOA));
          clLabel(l_ITERATE576);
          if (clTrue(clEndp(L_sublist575, clEOA))) clLocalReturn(NIL);
          { clObject L_arg580, L_value577;
            clSetq(L_arg580,
                   clFastFindSlot(CL_class,
                                  clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_NAME),
                                                    slot,
                                                    clEOA)));
            { clObject L_1;
              clSetq(L_1, object);
              clSetq(L_value577,
                     clFuncallFunction(clSymbolFunctionValue(clSLOT_VALUE_USING_CLASS),
                                       CL_class,
                                       L_1,
                                       slot,
                                       clEOA)); }
            clFuncallFunction(clFdefinition(CONS_53, clEOA),
                              L_value577,
                              CL_class,
                              copy,
                              L_arg580,
                              clEOA); }
          { clObject L_0;
            clSetq(L_0, L_sublist575);
            clSetq(L_sublist575, clCdr(L_0, clEOA)); }
          { clObject L_0;
            clSetq(L_0, L_sublist575);
            clSetq(slot, clCar(L_0, clEOA)); }
          goto l_ITERATE576; }
        clBlockEnd(NIL);
        return(clValues1(copy)); } } }
  
  clObject clCopyStructure clVdecl(_ap)
  { clObject structure;
    { clBeginParse(_ap);
      clSetq(structure,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_g581;
      clSetq(L_g581, structure);
      { clObject L_cpl584;
        clSetq(L_cpl584, clInstanceCpl(L_g581));
        if (clTrue(clFastFind(SYM_0_LTV, L_cpl584)))
          { clObject L_0;
            clSetq(L_0, structure);
            return(clFuncallFunction(clSymbolFunctionValue(clSHALLOW_COPY),
                                     L_0,
                                     clEOA)); }
        else
          return(clError(clTYPE_ERROR,
                         keyDATUM,
                         L_g581,
                         keyEXPECTED_TYPE,
                         CONS_64,
                         clEOA)); } } }
  
  clObject clMakeStandardStructureConstructorName clVdecl(_ap)
  { clObject structure_name;
    { clBeginParse(_ap);
      clSetq(structure_name,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject L_1;
      clSetq(L_1, structure_name);
      return(clConcatenateNames(STR_MAKE___39, L_1, clEOA)); } }
  
  clObject clMakeStructureKeylist clVdecl(_ap)
  { clObject instance;
    { clBeginParse(_ap);
      clSetq(instance,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    { clObject CL_class;
      { clObject L_0;
        clSetq(L_0, instance);
        clSetq(CL_class, clClassOf(L_0, clEOA)); }
      { clObject slot, L_g1;
        clSetq(slot, clNIL);
        clSetq(L_g1,
               clFuncallFunction(clSymbolFunctionValue(clCLASS_SLOTS),
                                 CL_class,
                                 clEOA));
        { clObject L_g2, L_g3, plist;
          clSetq(L_g2, clList(clNIL, clEOA));
          clSetq(L_g3, L_g2);
          clSetq(plist, clNIL);
          clLabel(NEXT_LOOP);
          if (clTrue(clEndp(L_g1, clEOA))) goto END_LOOP;
          clSetq(slot, clCar(L_g1, clEOA));
          { clObject L_0;
            clSetq(L_0, L_g1);
            clSetq(L_g1, clCdr(L_0, clEOA)); }
          { clObject L_0;
            { clObject L_g586;
              { clObject L_1, L_0__R1;
                { clObject L_0__R2;
                  { clObject L_0__R3;
                    clSetq(L_0__R3, slot);
                    clSetq(L_0__R2,
                           clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_NAME),
                                             L_0__R3,
                                             clEOA)); }
                  clSetq(L_0__R1, clMakeKeyword(L_0__R2, clEOA)); }
                { clObject L_1__R1, L_0__R2;
                  clSetq(L_0__R2, instance);
                  { clObject L_0__R3;
                    clSetq(L_0__R3, slot);
                    clSetq(L_1__R1,
                           clFuncallFunction(clSymbolFunctionValue(clSLOT_DEFINITION_LOCATION),
                                             L_0__R3,
                                             clEOA)); }
                  clSetq(L_1, clStructref(L_0__R2, L_1__R1, clEOA)); }
                clSetq(L_g586, clList(L_0__R1, L_1, clEOA)); }
              clRplacd(L_g3, L_g586, clEOA);
              clSetq(L_0, L_g586); }
            clSetq(L_g3, clCdr(L_0, clEOA)); }
          clSetq(plist, clCdr(L_g2, clEOA));
          goto NEXT_LOOP;
          clLabel(END_LOOP);
          { clObject L_1, L_0;
            clSetq(L_0,
                   clFuncallFunction(clSymbolFunctionValue(clCLASS_NAME),
                                     CL_class,
                                     clEOA));
            clSetq(L_1, plist);
            return(clCons(L_0, L_1, clEOA)); }
          return(clValues1(clNIL)); } } } }
  
  clDeclareEnv(clLevelStructurePrinter_Lambda);
  static clObject clLevelStructurePrinter_Lambda clVdecl(_ap)
  { clUseEnv(clLevelStructurePrinter_Lambda);
    { clObject object, stream;
      { clBeginParse(_ap);
        clSetq(object,
               (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
        clSetq(stream,
               (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_2, clEOA)));
        if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
        clEndParse(_ap); }
      { clObject L_2, L_1, L_0;
        clSetq(L_0, clEnv(0, *func));
        clSetq(L_1, object);
        clSetq(L_2, stream);
        return(clFuncall(L_0,
                         L_1,
                         L_2,
                         clSymbolValue(clstarCURRENT_LEVELstar, clEOA),
                         clEOA)); } } }
  
  clObject clLevelStructurePrinter clVdecl(_ap)
  { clObject *func = clMakeBinding();
    { clBeginParse(_ap);
      clSetq(*func,
             (_clVp(_ap) ? clVpop(_ap) : clMissingArgs(I_1, clEOA)));
      if (_clVp(_ap)) clExtraArgs(clVargs(_ap), clEOA);
      clEndParse(_ap); }
    return(clValues1(clMakeClosure(1,
                                   clLevelStructurePrinter_Lambda,
                                   &clEnvHook(clLevelStructurePrinter_Lambda),
                                   &*func))); }
  
  void clInitStructRun __P((void)) 
  { clDbind(clstarPACKAGEstar);
    clDbind(clstarREADTABLEstar);
    clDbind(clstarLOAD_TRUENAMEstar);
    clDbind(clstarLOAD_PATHNAMEstar);
    clSetq(I_1, clIntFixnum(1));
    clSetq(I_2, clIntFixnum(2));
    clSetq(I_3, clIntFixnum(3));
    clSetq(CONS_1, clCons(clSTRUCTREF, clNIL, clEOA));
    clSetq(CONS_0, clCons(clSETF, CONS_1, clEOA));
    clSetq(I_16, clIntFixnum(16));
    clSetq(I_0, clIntFixnum(0));
    clSetq(STR_DIRECT_SUPERCLASSES__0,
           clCharpSimpleBaseString("DIRECT-SUPERCLASSES"));
    clSetq(keyDIRECT_SUPERCLASSES,
           clMakeKeyword(STR_DIRECT_SUPERCLASSES__0, clEOA));
    clSetq(CONS_2, clCons(clT, clNIL, clEOA));
    clSetq(STR_DIRECT_SLOTS__1, clCharpSimpleBaseString("DIRECT-SLOTS"));
    clSetq(keyDIRECT_SLOTS, clMakeKeyword(STR_DIRECT_SLOTS__1, clEOA));
    clSetq(STR_ABSTRACT__2, clCharpSimpleBaseString("ABSTRACT"));
    clSetq(keyABSTRACT, clMakeKeyword(STR_ABSTRACT__2, clEOA));
    clSetq(CONS_3, clCons(clSTANDARD_CLASS, clNIL, clEOA));
    clSetq(STR_NAME__3, clCharpSimpleBaseString("NAME"));
    clSetq(keyNAME, clMakeKeyword(STR_NAME__3, clEOA));
    clSetq(STR_INITFUNCTION__4, clCharpSimpleBaseString("INITFUNCTION"));
    clSetq(keyINITFUNCTION, clMakeKeyword(STR_INITFUNCTION__4, clEOA));
    clSetq(STR_INITFORM__5, clCharpSimpleBaseString("INITFORM"));
    clSetq(keyINITFORM, clMakeKeyword(STR_INITFORM__5, clEOA));
    clSetq(CONS_5, clCons(clSTRUCTURE_OBJECT, clNIL, clEOA));
    clSetq(CONS_4, clCons(clQUOTE, CONS_5, clEOA));
    clSetq(STR_INITARGS__6, clCharpSimpleBaseString("INITARGS"));
    clSetq(keyINITARGS, clMakeKeyword(STR_INITARGS__6, clEOA));
    clSetq(STR_TYPE__7, clCharpSimpleBaseString("TYPE"));
    clSetq(keyTYPE, clMakeKeyword(STR_TYPE__7, clEOA));
    clSetq(CONS_6, clCons(keyTYPE, clNIL, clEOA));
    clSetq(STR_READERS__8, clCharpSimpleBaseString("READERS"));
    clSetq(keyREADERS, clMakeKeyword(STR_READERS__8, clEOA));
    clSetq(CONS_7, clCons(clSTRUCTURE_TYPE, clNIL, clEOA));
    clSetq(STR_NAMED__9, clCharpSimpleBaseString("NAMED"));
    clSetq(keyNAMED, clMakeKeyword(STR_NAMED__9, clEOA));
    clSetq(CONS_8, clCons(keyNAMED, clNIL, clEOA));
    clSetq(CONS_9, clCons(clSTRUCTURE_NAMED, clNIL, clEOA));
    clSetq(STR_INITIAL_OFFSET__10,
           clCharpSimpleBaseString("INITIAL-OFFSET"));
    clSetq(keyINITIAL_OFFSET,
           clMakeKeyword(STR_INITIAL_OFFSET__10, clEOA));
    clSetq(CONS_10, clCons(keyINITIAL_OFFSET, clNIL, clEOA));
    clSetq(CONS_11, clCons(clSTRUCTURE_INITIAL_OFFSET, clNIL, clEOA));
    clSetq(STR_INHERITED_SLOTS__11,
           clCharpSimpleBaseString("INHERITED-SLOTS"));
    clSetq(keyINHERITED_SLOTS,
           clMakeKeyword(STR_INHERITED_SLOTS__11, clEOA));
    clSetq(CONS_12, clCons(keyINHERITED_SLOTS, clNIL, clEOA));
    clSetq(CONS_13, clCons(clSTRUCTURE_INHERITED_SLOTS, clNIL, clEOA));
    clSetq(STR_CONC_NAME__12, clCharpSimpleBaseString("CONC-NAME"));
    clSetq(keyCONC_NAME, clMakeKeyword(STR_CONC_NAME__12, clEOA));
    clSetq(CONS_14, clCons(keyCONC_NAME, clNIL, clEOA));
    clSetq(CONS_15, clCons(clSTRUCTURE_CONC_NAME, clNIL, clEOA));
    clSetq(STR_PREDICATE__13, clCharpSimpleBaseString("PREDICATE"));
    clSetq(keyPREDICATE, clMakeKeyword(STR_PREDICATE__13, clEOA));
    clSetq(CONS_16, clCons(keyPREDICATE, clNIL, clEOA));
    clSetq(CONS_17, clCons(clSTRUCTURE_PREDICATE, clNIL, clEOA));
    clSetq(STR_COPIER__14, clCharpSimpleBaseString("COPIER"));
    clSetq(keyCOPIER, clMakeKeyword(STR_COPIER__14, clEOA));
    clSetq(CONS_18, clCons(keyCOPIER, clNIL, clEOA));
    clSetq(CONS_19, clCons(clSTRUCTURE_COPIER, clNIL, clEOA));
    clSetq(STR_CONSTRUCTORS__15,
           clCharpSimpleBaseString("CONSTRUCTORS"));
    clSetq(keyCONSTRUCTORS, clMakeKeyword(STR_CONSTRUCTORS__15, clEOA));
    clSetq(CONS_20, clCons(keyCONSTRUCTORS, clNIL, clEOA));
    clSetq(CONS_21, clCons(clSTRUCTURE_CONSTRUCTORS, clNIL, clEOA));
    clSetq(STRn_16, clCharpSimpleBaseString("DIRECT-DEFAULT-INITARGS"));
    clSetq(keyDIRECT_DEFAULT_INITARGS, clMakeKeyword(STRn_16, clEOA));
    clSetq(CONS_25, clCons(CONS_4, clNIL, clEOA));
    clSetq(CONS_24, clCons(clFIND_TYPE, CONS_25, clEOA));
    clSetq(CONS_23, clCons(CONS_24, clNIL, clEOA));
    clSetq(CONS_22, clCons(clLIST, CONS_23, clEOA));
    clSetq(STRn_17,
           clCharpSimpleBaseString("Structure slot definitions are not initialized through initfunctions."));
    clSetq(CONS_26, clCons(clSLOT_DEFINITION, clNIL, clEOA));
    clSetq(STR_READ_ONLY__18, clCharpSimpleBaseString("READ-ONLY"));
    clSetq(keyREAD_ONLY, clMakeKeyword(STR_READ_ONLY__18, clEOA));
    clSetq(CONS_27, clCons(keyREAD_ONLY, clNIL, clEOA));
    clSetq(CONS_28, clCons(clSLOT_DEFINITION_READ_ONLY, clNIL, clEOA));
    clSetq(STR_HIDDEN__19, clCharpSimpleBaseString("HIDDEN"));
    clSetq(keyHIDDEN, clMakeKeyword(STR_HIDDEN__19, clEOA));
    clSetq(CONS_29, clCons(keyHIDDEN, clNIL, clEOA));
    clSetq(CONS_30, clCons(clSLOT_DEFINITION_HIDDEN, clNIL, clEOA));
    clSetq(CONS_32,
           clCons(clILLEGAL_STRUCTURE_INITIALIZATION, clNIL, clEOA));
    clSetq(CONS_31, clCons(clFUNCTION, CONS_32, clEOA));
    clSetq(CONS_34, clCons(clDIRECT_SLOT_DEFINITION, clNIL, clEOA));
    clSetq(CONS_33, clCons(clSTRUCTURE_SLOT_DEFINITION, CONS_34, clEOA));
    clSetq(CONS_36, clCons(clEFFECTIVE_SLOT_DEFINITION, clNIL, clEOA));
    clSetq(CONS_35, clCons(clSTRUCTURE_SLOT_DEFINITION, CONS_36, clEOA));
    clSetq(STR_QUALIFIERS__20, clCharpSimpleBaseString("QUALIFIERS"));
    clSetq(keyQUALIFIERS, clMakeKeyword(STR_QUALIFIERS__20, clEOA));
    clSetq(STR_LAMBDA_LIST__21, clCharpSimpleBaseString("LAMBDA-LIST"));
    clSetq(keyLAMBDA_LIST, clMakeKeyword(STR_LAMBDA_LIST__21, clEOA));
    clSetq(CONS_39, clCons(clENVIRONMENT, clNIL, clEOA));
    clSetq(CONS_38, clCons(clampersandOPTIONAL, CONS_39, clEOA));
    clSetq(CONS_37, clCons(clOBJECT, CONS_38, clEOA));
    clSetq(STR_SPECIALIZERS__22,
           clCharpSimpleBaseString("SPECIALIZERS"));
    clSetq(keySPECIALIZERS, clMakeKeyword(STR_SPECIALIZERS__22, clEOA));
    clSetq(STR_FUNCTION__23, clCharpSimpleBaseString("FUNCTION"));
    clSetq(keyFUNCTION, clMakeKeyword(STR_FUNCTION__23, clEOA));
    clSetq(STR_DECLARATIONS__24,
           clCharpSimpleBaseString("DECLARATIONS"));
    clSetq(keyDECLARATIONS, clMakeKeyword(STR_DECLARATIONS__24, clEOA));
    clSetq(STR_DOCUMENTATION__25,
           clCharpSimpleBaseString("DOCUMENTATION"));
    clSetq(keyDOCUMENTATION,
           clMakeKeyword(STR_DOCUMENTATION__25, clEOA));
    clSetq(CONS_42, clCons(clINITARGS, clNIL, clEOA));
    clSetq(CONS_41, clCons(clampersandREST, CONS_42, clEOA));
    clSetq(CONS_40, clCons(clCLASS, CONS_41, clEOA));
    clSetq(CONS_44, clCons(clIGNORE, CONS_42, clEOA));
    clSetq(CONS_46, clCons(clDYNAMIC_EXTENT, CONS_42, clEOA));
    clSetq(CONS_45, clCons(CONS_46, clNIL, clEOA));
    clSetq(CONS_43, clCons(CONS_44, CONS_45, clEOA));
    clSetq(STR_PAD__26, clCharpSimpleBaseString("PAD"));
    clSetq(CONS_49, clCons(clDIRECT_SLOT_DEFINITIONS, clNIL, clEOA));
    clSetq(CONS_48, clCons(clNAME, CONS_49, clEOA));
    clSetq(CONS_47, clCons(clCLASS, CONS_48, clEOA));
    clSetq(STRn_27,
           clCharpSimpleBaseString("Type ~s for slot ~s is not a subtype of ~s."));
    clSetq(STRn_28,
           clCharpSimpleBaseString("Cannot make read-only slot ~s readable."));
    clSetq(STR_AFTER__29, clCharpSimpleBaseString("AFTER"));
    clSetq(keyAFTER, clMakeKeyword(STR_AFTER__29, clEOA));
    clSetq(CONS_50, clCons(keyAFTER, clNIL, clEOA));
    clSetq(CONS_52, clCons(clSLOT_NAMES, CONS_41, clEOA));
    clSetq(CONS_51, clCons(clSTRUCTURE, CONS_52, clEOA));
    clSetq(CONS_54, clCons(clSLOT_VALUE_USING_CLASS, clNIL, clEOA));
    clSetq(CONS_53, clCons(clSETF, CONS_54, clEOA));
    clSetq(STR____30, clCharpSimpleBaseString("-"));
    clSetq(STR__P__31, clCharpSimpleBaseString("-P"));
    clSetq(STR_COPY___32, clCharpSimpleBaseString("COPY-"));
    clSetq(CONS_55, clCons(clSTRUCTURE, clNIL, clEOA));
    clSetq(STRn_33,
           clCharpSimpleBaseString("for untyped structure ~s."));
    clSetq(STRn_34, clCharpSimpleBaseString("for unamed structure ~s."));
    clSetq(CONS_57, clCons(clampersandKEY, clNIL, clEOA));
    clSetq(CONS_56, clCons(clCLASS, CONS_57, clEOA));
    clSetq(CONS_60, clCons(clSLOT, clNIL, clEOA));
    clSetq(CONS_59, clCons(clOBJECT, CONS_60, clEOA));
    clSetq(CONS_58, clCons(clCLASS, CONS_59, clEOA));
    clSetq(CONS_61, clCons(clSETF, CONS_54, clEOA));
    clSetq(CONS_62, clCons(clNEW_VALUE, CONS_58, clEOA));
    clSetq(I_4, clIntFixnum(4));
    clSetq(STR_METACLASS__35, clCharpSimpleBaseString("METACLASS"));
    clSetq(keyMETACLASS, clMakeKeyword(STR_METACLASS__35, clEOA));
    clSetq(CONS_63, clCons(clOBJECT, clNIL, clEOA));
    clSetq(STR_LTV__36, clCharpSimpleBaseString("LTV"));
    clSetq(SYM_0_LTV, clMakeSymbol(STR_LTV__36, clEOA));
    clSetq(SYM_0_LTV, clExpandType(clSTRUCTURE_OBJECT, clNIL, clEOA));
    clSetq(STR_DATUM__37, clCharpSimpleBaseString("DATUM"));
    clSetq(keyDATUM, clMakeKeyword(STR_DATUM__37, clEOA));
    clSetq(STR_EXPECTED_TYPE__38,
           clCharpSimpleBaseString("EXPECTED-TYPE"));
    clSetq(keyEXPECTED_TYPE,
           clMakeKeyword(STR_EXPECTED_TYPE__38, clEOA));
    clSetq(CONS_64, clCons(clOR, CONS_5, clEOA));
    clSetq(STR_MAKE___39, clCharpSimpleBaseString("MAKE-"));
  
    clSetSymbolFunctionValue(clSTRUCTREF,
                             clMakeClosure(0, clStructref, clNULL_HOOK));
    (void) clSTRUCTREF;
    clSetSymbolSetfFunctionValue(clSTRUCTREF,
                                 clMakeClosure(0,
                                               cl_SETF_Structref,
                                               clNULL_HOOK));
    (void) CONS_0;
    clSetSymbolFunctionValue(clMAKE_EMPTY_STRUCTURE,
                             clMakeClosure(0,
                                           clMakeEmptyStructure,
                                           clNULL_HOOK));
    (void) clMAKE_EMPTY_STRUCTURE;
    clSetSymbolFunctionValue(clMAKE_STRUCTURE,
                             clMakeClosure(0,
                                           clMakeStructure,
                                           clNULL_HOOK));
    (void) clMAKE_STRUCTURE;
    clSetSymbolFunctionValue(clABSTRACT_STRUCTURE_CLASS_P,
                             clMakeClosure(0,
                                           clAbstractStructureClassP,
                                           clNULL_HOOK));
    (void) clABSTRACT_STRUCTURE_CLASS_P;
    { clObject L_4;
      clSetq(L_4, clList(clEOA));
      clEnsureClass(clSTRUCTURE_OBJECT, keyDIRECT_SUPERCLASSES, CONS_2,
                    keyDIRECT_SLOTS, L_4, keyABSTRACT, clT, clEOA); }
    { clObject L_4;
      { clObject L_8, L_7, L_6__R1, L_5__R1, L_4__R1, L_3__R1, L_2__R1,
        L_1__R1, L_0__R1;
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda, clNULL_HOOK));
          clSetq(L_0__R1,
                 clList(keyNAME,
                        clTYPE,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        CONS_4,
                        keyINITARGS,
                        CONS_6,
                        keyREADERS,
                        CONS_7,
                        clEOA)); }
        clSetq(L_1__R1,
               clList(keyNAME, clNAMED, keyINITARGS, CONS_8, keyREADERS,
                      CONS_9, clEOA));
        clSetq(L_2__R1, clList(keyNAME, clTYPE_NAME_INDEX, clEOA));
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r1, clNULL_HOOK));
          clSetq(L_3__R1,
                 clList(keyNAME,
                        clINITIAL_OFFSET,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        I_0,
                        keyINITARGS,
                        CONS_10,
                        keyREADERS,
                        CONS_11,
                        clEOA)); }
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r2, clNULL_HOOK));
          clSetq(L_4__R1,
                 clList(keyNAME,
                        clINHERITED_SLOTS,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        clNIL,
                        keyINITARGS,
                        CONS_12,
                        keyREADERS,
                        CONS_13,
                        clEOA)); }
        clSetq(L_5__R1,
               clList(keyNAME, clCONC_NAME, keyINITARGS, CONS_14,
                      keyREADERS, CONS_15, clEOA));
        clSetq(L_6__R1,
               clList(keyNAME, clPREDICATE, keyINITARGS, CONS_16,
                      keyREADERS, CONS_17, clEOA));
        clSetq(L_7,
               clList(keyNAME, clCOPIER, keyINITARGS, CONS_18,
                      keyREADERS, CONS_19, clEOA));
        clSetq(L_8,
               clList(keyNAME, clCONSTRUCTORS, keyINITARGS, CONS_20,
                      keyREADERS, CONS_21, clEOA));
        clSetq(L_4,
               clList(L_0__R1, L_1__R1, L_2__R1, L_3__R1, L_4__R1,
                      L_5__R1, L_6__R1, L_7, L_8,
                      clList(keyNAME, clCONTRIBUTING_SLOTS, clEOA),
                      clEOA)); }
      clEnsureClass(clSTRUCTURE_CLASS, keyDIRECT_SUPERCLASSES, CONS_3,
                    keyDIRECT_SLOTS, L_4, keyDIRECT_DEFAULT_INITARGS,
                    clList(clList(keyDIRECT_SUPERCLASSES,
                                  CONS_22,
                                  clMakeClosure(0,
                                                clLambda_r3,
                                                clNULL_HOOK),
                                  clEOA),
                           clEOA),
                    clEOA); }
    clSetSymbolFunctionValue(clILLEGAL_STRUCTURE_INITIALIZATION,
                             clMakeClosure(0,
                                           clIllegalStructureInitialization,
                                           clNULL_HOOK));
    (void) clILLEGAL_STRUCTURE_INITIALIZATION;
    { clObject L_4;
      { clObject L_3__R1, L_2__R1, L_1__R1, L_0__R1;
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r4, clNULL_HOOK));
          clSetq(L_0__R1,
                 clList(keyNAME,
                        clREAD_ONLY,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        clNIL,
                        keyINITARGS,
                        CONS_27,
                        keyREADERS,
                        CONS_28,
                        clEOA)); }
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r5, clNULL_HOOK));
          clSetq(L_1__R1,
                 clList(keyNAME,
                        clHIDDEN,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        clNIL,
                        keyINITARGS,
                        CONS_29,
                        keyREADERS,
                        CONS_30,
                        clEOA)); }
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r6, clNULL_HOOK));
          clSetq(L_2__R1,
                 clList(keyNAME,
                        clINITFORM,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        clNIL,
                        clEOA)); }
        { clObject L_3__R2;
          clSetq(L_3__R2, clMakeClosure(0, clLambda_r7, clNULL_HOOK));
          clSetq(L_3__R1,
                 clList(keyNAME,
                        clINITFUNCTION,
                        keyINITFUNCTION,
                        L_3__R2,
                        keyINITFORM,
                        CONS_31,
                        clEOA)); }
        clSetq(L_4, clList(L_0__R1, L_1__R1, L_2__R1, L_3__R1, clEOA)); }
      clEnsureClass(clSTRUCTURE_SLOT_DEFINITION, keyDIRECT_SUPERCLASSES,
                    CONS_26, keyDIRECT_SLOTS, L_4, clEOA); }
    clEnsureClass(clSTRUCTURE_DIRECT_SLOT_DEFINITION,
                  keyDIRECT_SUPERCLASSES, CONS_33, keyDIRECT_SLOTS,
                  clList(clEOA), clEOA);
    clEnsureClass(clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                  keyDIRECT_SUPERCLASSES, CONS_35, keyDIRECT_SLOTS,
                  clList(clEOA), clEOA);
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clMAKE_LOAD_FORM, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0,
                           clMakeLoadForm_clSTRUCTURE_CLASS,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_37,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clDIRECT_SLOT_DEFINITION_CLASS,
                                     clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0,
                           clDirectSlotDefinitionClass_clSTRUCTURE_CLASS,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_40,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_43, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clEFFECTIVE_SLOT_DEFINITION_CLASS,
                                     clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0,
                           clEffectiveSlotDefinitionClass_clSTRUCTURE_CLASS,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_40,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, CONS_43, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clSetSymbolFunctionValue(clMAKE_HIDDEN_SLOT,
                             clMakeClosure(0,
                                           clMakeHiddenSlot,
                                           clNULL_HOOK));
    (void) clMAKE_HIDDEN_SLOT;
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clCOMPUTE_EFFECTIVE_SLOT_DEFINITION,
                                     clEOA));
      { clObject L_1__R1, L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA));
        clSetq(L_1__R1, clCanonicalizeSpecializer(clT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, L_1__R1,
                      clCanonicalizeSpecializer(clT, clEOA), clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clComputeEffectiveSlotDefinition_clSTRUCTURE_CLASS_clT_clT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_47,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSHARED_INITIALIZE, clEOA));
      { clObject L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA));
        clSetq(L_6,
               clList(L_0__R1, clCanonicalizeSpecializer(clT, clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clSharedInitialize_keyAFTER_clSTRUCTURE_CLASS_clT,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, CONS_50, keyLAMBDA_LIST,
                     CONS_51, keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clFINALIZE_INHERITANCE, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0,
                           clFinalizeInheritance_keyAFTER_clSTRUCTURE_CLASS,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, CONS_50, keyLAMBDA_LIST,
                     CONS_55, keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clALLOCATE_INSTANCE, clEOA));
      clSetq(L_6,
             clList(clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA),
                    clEOA));
      clSetq(L_8,
             clMakeClosure(0,
                           clAllocateInstance_clSTRUCTURE_CLASS,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_56,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clSLOT_VALUE_USING_CLASS, clEOA));
      { clObject L_1__R1, L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA));
        clSetq(L_1__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_OBJECT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, L_1__R1,
                      clCanonicalizeSpecializer(clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                                                clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clSlotValueUsingClass_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_58,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(CONS_61, clEOA));
      { clObject L_2__R1, L_1__R1, L_0__R1;
        clSetq(L_0__R1, clCanonicalizeSpecializer(clT, clEOA));
        clSetq(L_1__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA));
        clSetq(L_2__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_OBJECT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, L_1__R1, L_2__R1,
                      clCanonicalizeSpecializer(clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                                                clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           cl_SETF_SlotValueUsingClass_clT_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_62,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    { clObject L_8, L_6, L_0;
      clSetq(L_0,
             clEnsureGenericFunction(clSLOT_BOUNDP_USING_CLASS, clEOA));
      { clObject L_1__R1, L_0__R1;
        clSetq(L_0__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_CLASS, clEOA));
        clSetq(L_1__R1,
               clCanonicalizeSpecializer(clSTRUCTURE_OBJECT, clEOA));
        clSetq(L_6,
               clList(L_0__R1, L_1__R1,
                      clCanonicalizeSpecializer(clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                                                clEOA),
                      clEOA)); }
      clSetq(L_8,
             clMakeClosure(0,
                           clSlotBoundpUsingClass_clSTRUCTURE_CLASS_clSTRUCTURE_OBJECT_clSTRUCTURE_EFFECTIVE_SLOT_DEFINITION,
                           clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_58,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clSetSymbolFunctionValue(clENSURE_STRUCTURE,
                             clMakeClosure(0,
                                           clEnsureStructure,
                                           clNULL_HOOK));
    (void) clENSURE_STRUCTURE;
    clEnsureGenericFunction(clTYPE_FOR_COPY,
                            keyLAMBDA_LIST,
                            CONS_63,
                            clEOA);
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clTYPE_FOR_COPY, clEOA));
      clSetq(L_6, clList(clCanonicalizeSpecializer(clT, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clTypeForCopy_clT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_63,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clEnsureGenericFunction(clSHALLOW_COPY,
                            keyLAMBDA_LIST,
                            CONS_63,
                            clEOA);
    { clObject L_8, L_6, L_0;
      clSetq(L_0, clEnsureGenericFunction(clSHALLOW_COPY, clEOA));
      clSetq(L_6, clList(clCanonicalizeSpecializer(clT, clEOA), clEOA));
      clSetq(L_8, clMakeClosure(0, clShallowCopy_clT, clNULL_HOOK));
      clEnsureMethod(L_0, keyQUALIFIERS, clNIL, keyLAMBDA_LIST, CONS_63,
                     keySPECIALIZERS, L_6, keyFUNCTION, L_8,
                     keyDECLARATIONS, clNIL, keyDOCUMENTATION, clNIL,
                     clEOA); }
    clSetSymbolFunctionValue(clCOPY_STRUCTURE,
                             clMakeClosure(0,
                                           clCopyStructure,
                                           clNULL_HOOK));
    (void) clCOPY_STRUCTURE;
    clSetSymbolFunctionValue(clMAKE_STANDARD_STRUCTURE_CONSTRUCTOR_NAME,
                             clMakeClosure(0,
                                           clMakeStandardStructureConstructorName,
                                           clNULL_HOOK));
    (void) clMAKE_STANDARD_STRUCTURE_CONSTRUCTOR_NAME;
    clSetSymbolFunctionValue(clMAKE_STRUCTURE_KEYLIST,
                             clMakeClosure(0,
                                           clMakeStructureKeylist,
                                           clNULL_HOOK));
    (void) clMAKE_STRUCTURE_KEYLIST;
    clSetSymbolFunctionValue(clLEVEL_STRUCTURE_PRINTER,
                             clMakeClosure(0,
                                           clLevelStructurePrinter,
                                           clNULL_HOOK));
    (void) clLEVEL_STRUCTURE_PRINTER;
    clUnwind(4); }
  