DIRECTORY
WartDef,
AbstractTypesDef;

AbstractProductionsDef: CEDAR DEFINITIONS = 
BEGIN
OPEN WartDef, AbstractTypesDef;


ProgramProdData: TYPE = REF ProgramProdDataBody;
ProgramProdDataBody: TYPE = RECORD[
identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode, ReferencedProgramList: ReferencedProgramListNode, DeclarationList: DeclarationListNode];

ProgramProdProcs: ProgramNodeProcs;

BuildProgramProdNode: PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode, ReferencedProgramList: ReferencedProgramListNode, DeclarationList: DeclarationListNode]
RETURNS[ProgramNode];

ProgramProdMakeSymbolTable: MakeSymbolTableProcType;


ReferencedProgramListemptyProdData: TYPE = REF ReferencedProgramListemptyProdDataBody;
ReferencedProgramListemptyProdDataBody: TYPE = RECORD[
];

ReferencedProgramListemptyProdProcs: ReferencedProgramListNodeProcs;

BuildReferencedProgramListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ReferencedProgramListNode];

ReferencedProgramListemptyProdReadInTable: ReadInTableProcType;


ReferencedProgramListmoreProdData: TYPE = REF ReferencedProgramListmoreProdDataBody;
ReferencedProgramListmoreProdDataBody: TYPE = RECORD[
ReferencedProgramList: ReferencedProgramListNode, ReferencedProgram: ReferencedProgramNode];

ReferencedProgramListmoreProdProcs: ReferencedProgramListNodeProcs;

BuildReferencedProgramListmoreProdNode: PROC[position: INT, length: INT, ReferencedProgramList: ReferencedProgramListNode, ReferencedProgram: ReferencedProgramNode]
RETURNS[ReferencedProgramListNode];

ReferencedProgramListmoreProdReadInTable: ReadInTableProcType;


ReferencedProgramProdData: TYPE = REF ReferencedProgramProdDataBody;
ReferencedProgramProdDataBody: TYPE = RECORD[
identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode];

ReferencedProgramProdProcs: ReferencedProgramNodeProcs;

BuildReferencedProgramProdNode: PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode]
RETURNS[ReferencedProgramNode];

ReferencedProgramProdReadInTable: ReadInTableProcType;


DeclarationListemptyProdData: TYPE = REF DeclarationListemptyProdDataBody;
DeclarationListemptyProdDataBody: TYPE = RECORD[
];

DeclarationListemptyProdProcs: DeclarationListNodeProcs;

BuildDeclarationListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[DeclarationListNode];

DeclarationListemptyProdBuildTable: BuildTableProcType;
DeclarationListemptyProdRecordNames: RecordNamesProcType;


DeclarationListmoreProdData: TYPE = REF DeclarationListmoreProdDataBody;
DeclarationListmoreProdDataBody: TYPE = RECORD[
DeclarationList: DeclarationListNode, Declaration: DeclarationNode];

DeclarationListmoreProdProcs: DeclarationListNodeProcs;

BuildDeclarationListmoreProdNode: PROC[position: INT, length: INT, DeclarationList: DeclarationListNode, Declaration: DeclarationNode]
RETURNS[DeclarationListNode];

DeclarationListmoreProdBuildTable: BuildTableProcType;
DeclarationListmoreProdRecordNames: RecordNamesProcType;


DeclarationtypeProdData: TYPE = REF DeclarationtypeProdDataBody;
DeclarationtypeProdDataBody: TYPE = RECORD[
identifier: identifierNode, Type: TypeNode];

DeclarationtypeProdProcs: DeclarationNodeProcs;

BuildDeclarationtypeProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode]
RETURNS[DeclarationNode];

DeclarationtypeProdBuildTable: BuildTableProcType;
DeclarationtypeProdRecordNames: RecordNamesProcType;


DeclarationconstantProdData: TYPE = REF DeclarationconstantProdDataBody;
DeclarationconstantProdDataBody: TYPE = RECORD[
identifier: identifierNode, Type: TypeNode, Constant: ConstantNode];

DeclarationconstantProdProcs: DeclarationNodeProcs;

BuildDeclarationconstantProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode, Constant: ConstantNode]
RETURNS[DeclarationNode];

DeclarationconstantProdBuildTable: BuildTableProcType;
DeclarationconstantProdRecordNames: RecordNamesProcType;


TypearrayProdData: TYPE = REF TypearrayProdDataBody;
TypearrayProdDataBody: TYPE = RECORD[
Constant: ConstantNode, Type: TypeNode];

TypearrayProdProcs: TypeNodeProcs;

BuildTypearrayProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode];

TypearrayProdCanonicaliseType: CanonicaliseTypeProcType;


TypebooleanProdData: TYPE = REF TypebooleanProdDataBody;
TypebooleanProdDataBody: TYPE = RECORD[
];

TypebooleanProdProcs: TypeNodeProcs;

BuildTypebooleanProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebooleanProdCanonicaliseType: CanonicaliseTypeProcType;


TypebulkDataSinkProdData: TYPE = REF TypebulkDataSinkProdDataBody;
TypebulkDataSinkProdDataBody: TYPE = RECORD[
];

TypebulkDataSinkProdProcs: TypeNodeProcs;

BuildTypebulkDataSinkProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebulkDataSinkProdCanonicaliseType: CanonicaliseTypeProcType;


TypebulkDataSourceProdData: TYPE = REF TypebulkDataSourceProdDataBody;
TypebulkDataSourceProdDataBody: TYPE = RECORD[
];

TypebulkDataSourceProdProcs: TypeNodeProcs;

BuildTypebulkDataSourceProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebulkDataSourceProdCanonicaliseType: CanonicaliseTypeProcType;


TypecardinalProdData: TYPE = REF TypecardinalProdDataBody;
TypecardinalProdDataBody: TYPE = RECORD[
];

TypecardinalProdProcs: TypeNodeProcs;

BuildTypecardinalProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypecardinalProdCanonicaliseType: CanonicaliseTypeProcType;


TypechoiceProdData: TYPE = REF TypechoiceProdDataBody;
TypechoiceProdDataBody: TYPE = RECORD[
Type: TypeNode, CandidateList: CandidateListNode];

TypechoiceProdProcs: TypeNodeProcs;

BuildTypechoiceProdNode: PROC[position: INT, length: INT, Type: TypeNode, CandidateList: CandidateListNode]
RETURNS[TypeNode];

TypechoiceProdCanonicaliseType: CanonicaliseTypeProcType;


TypeemptyRecordProdData: TYPE = REF TypeemptyRecordProdDataBody;
TypeemptyRecordProdDataBody: TYPE = RECORD[
];

TypeemptyRecordProdProcs: TypeNodeProcs;

BuildTypeemptyRecordProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeemptyRecordProdCanonicaliseType: CanonicaliseTypeProcType;


TypeenumerationProdData: TYPE = REF TypeenumerationProdDataBody;
TypeenumerationProdDataBody: TYPE = RECORD[
CorrespondenceList: CorrespondenceListNode];

TypeenumerationProdProcs: TypeNodeProcs;

BuildTypeenumerationProdNode: PROC[position: INT, length: INT, CorrespondenceList: CorrespondenceListNode]
RETURNS[TypeNode];

TypeenumerationProdCanonicaliseType: CanonicaliseTypeProcType;


TypeerrorProdData: TYPE = REF TypeerrorProdDataBody;
TypeerrorProdDataBody: TYPE = RECORD[
FieldList: FieldListNode];

TypeerrorProdProcs: TypeNodeProcs;

BuildTypeerrorProdNode: PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode];

TypeerrorProdCanonicaliseType: CanonicaliseTypeProcType;


TypeintegerProdData: TYPE = REF TypeintegerProdDataBody;
TypeintegerProdDataBody: TYPE = RECORD[
];

TypeintegerProdProcs: TypeNodeProcs;

BuildTypeintegerProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeintegerProdCanonicaliseType: CanonicaliseTypeProcType;


TypelocalReferenceProdData: TYPE = REF TypelocalReferenceProdDataBody;
TypelocalReferenceProdDataBody: TYPE = RECORD[
identifier: identifierNode];

TypelocalReferenceProdProcs: TypeNodeProcs;

BuildTypelocalReferenceProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[TypeNode];

TypelocalReferenceProdCanonicaliseType: CanonicaliseTypeProcType;


TypelongCardinalProdData: TYPE = REF TypelongCardinalProdDataBody;
TypelongCardinalProdDataBody: TYPE = RECORD[
];

TypelongCardinalProdProcs: TypeNodeProcs;

BuildTypelongCardinalProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypelongCardinalProdCanonicaliseType: CanonicaliseTypeProcType;


TypelongIntegerProdData: TYPE = REF TypelongIntegerProdDataBody;
TypelongIntegerProdDataBody: TYPE = RECORD[
];

TypelongIntegerProdProcs: TypeNodeProcs;

BuildTypelongIntegerProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypelongIntegerProdCanonicaliseType: CanonicaliseTypeProcType;


TypeprocedureProdData: TYPE = REF TypeprocedureProdDataBody;
TypeprocedureProdDataBody: TYPE = RECORD[
FieldListarg: FieldListNode, FieldListres: FieldListNode, NameList: NameListNode];

TypeprocedureProdProcs: TypeNodeProcs;

BuildTypeprocedureProdNode: PROC[position: INT, length: INT, FieldListarg: FieldListNode, FieldListres: FieldListNode, NameList: NameListNode]
RETURNS[TypeNode];

TypeprocedureProdCanonicaliseType: CanonicaliseTypeProcType;


TyperecordProdData: TYPE = REF TyperecordProdDataBody;
TyperecordProdDataBody: TYPE = RECORD[
FieldList: FieldListNode];

TyperecordProdProcs: TypeNodeProcs;

BuildTyperecordProdNode: PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode];

TyperecordProdCanonicaliseType: CanonicaliseTypeProcType;


TyperemoteReferenceProdData: TYPE = REF TyperemoteReferenceProdDataBody;
TyperemoteReferenceProdDataBody: TYPE = RECORD[
identifiera: identifierNode, identifierb: identifierNode];

TyperemoteReferenceProdProcs: TypeNodeProcs;

BuildTyperemoteReferenceProdNode: PROC[position: INT, length: INT, identifiera: identifierNode, identifierb: identifierNode]
RETURNS[TypeNode];

TyperemoteReferenceProdCanonicaliseType: CanonicaliseTypeProcType;


TypesequenceProdData: TYPE = REF TypesequenceProdDataBody;
TypesequenceProdDataBody: TYPE = RECORD[
Constant: ConstantNode, Type: TypeNode];

TypesequenceProdProcs: TypeNodeProcs;

BuildTypesequenceProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode];

TypesequenceProdCanonicaliseType: CanonicaliseTypeProcType;


TypestringProdData: TYPE = REF TypestringProdDataBody;
TypestringProdDataBody: TYPE = RECORD[
];

TypestringProdProcs: TypeNodeProcs;

BuildTypestringProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypestringProdCanonicaliseType: CanonicaliseTypeProcType;


TypeunspecifiedProdData: TYPE = REF TypeunspecifiedProdDataBody;
TypeunspecifiedProdDataBody: TYPE = RECORD[
];

TypeunspecifiedProdProcs: TypeNodeProcs;

BuildTypeunspecifiedProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeunspecifiedProdCanonicaliseType: CanonicaliseTypeProcType;


CorrespondenceListoneProdData: TYPE = REF CorrespondenceListoneProdDataBody;
CorrespondenceListoneProdDataBody: TYPE = RECORD[
identifier: identifierNode, Constant: ConstantNode];

CorrespondenceListoneProdProcs: CorrespondenceListNodeProcs;

BuildCorrespondenceListoneProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[CorrespondenceListNode];

CorrespondenceListoneProdCanonicaliseCorrespondenceList: CanonicaliseCorrespondenceListProcType;
CorrespondenceListoneProdCheckCorrespondenceList: CheckCorrespondenceListProcType;


CorrespondenceListmoreProdData: TYPE = REF CorrespondenceListmoreProdDataBody;
CorrespondenceListmoreProdDataBody: TYPE = RECORD[
CorrespondenceListvalue: CorrespondenceListNode, CorrespondenceListnext: CorrespondenceListNode];

CorrespondenceListmoreProdProcs: CorrespondenceListNodeProcs;

BuildCorrespondenceListmoreProdNode: PROC[position: INT, length: INT, CorrespondenceListvalue: CorrespondenceListNode, CorrespondenceListnext: CorrespondenceListNode]
RETURNS[CorrespondenceListNode];

CorrespondenceListmoreProdCanonicaliseCorrespondenceList: CanonicaliseCorrespondenceListProcType;
CorrespondenceListmoreProdCheckCorrespondenceList: CheckCorrespondenceListProcType;


CandidateListoneProdData: TYPE = REF CandidateListoneProdDataBody;
CandidateListoneProdDataBody: TYPE = RECORD[
NameList: NameListNode, Type: TypeNode];

CandidateListoneProdProcs: CandidateListNodeProcs;

BuildCandidateListoneProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[CandidateListNode];

CandidateListoneProdCanonicaliseCandidateList: CanonicaliseCandidateListProcType;
CandidateListoneProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;


CandidateListmoreProdData: TYPE = REF CandidateListmoreProdDataBody;
CandidateListmoreProdDataBody: TYPE = RECORD[
CandidateListvalue: CandidateListNode, CandidateListnext: CandidateListNode];

CandidateListmoreProdProcs: CandidateListNodeProcs;

BuildCandidateListmoreProdNode: PROC[position: INT, length: INT, CandidateListvalue: CandidateListNode, CandidateListnext: CandidateListNode]
RETURNS[CandidateListNode];

CandidateListmoreProdCanonicaliseCandidateList: CanonicaliseCandidateListProcType;
CandidateListmoreProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;


FieldListemptyProdData: TYPE = REF FieldListemptyProdDataBody;
FieldListemptyProdDataBody: TYPE = RECORD[
];

FieldListemptyProdProcs: FieldListNodeProcs;

BuildFieldListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[FieldListNode];

FieldListemptyProdCanonicaliseFieldList: CanonicaliseFieldListProcType;


FieldListoneProdData: TYPE = REF FieldListoneProdDataBody;
FieldListoneProdDataBody: TYPE = RECORD[
NameList: NameListNode, Type: TypeNode];

FieldListoneProdProcs: FieldListNodeProcs;

BuildFieldListoneProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[FieldListNode];

FieldListoneProdCanonicaliseFieldList: CanonicaliseFieldListProcType;


FieldListmoreProdData: TYPE = REF FieldListmoreProdDataBody;
FieldListmoreProdDataBody: TYPE = RECORD[
FieldListvalue: FieldListNode, FieldListrest: FieldListNode];

FieldListmoreProdProcs: FieldListNodeProcs;

BuildFieldListmoreProdNode: PROC[position: INT, length: INT, FieldListvalue: FieldListNode, FieldListrest: FieldListNode]
RETURNS[FieldListNode];

FieldListmoreProdCanonicaliseFieldList: CanonicaliseFieldListProcType;


ConstantchoiceProdData: TYPE = REF ConstantchoiceProdDataBody;
ConstantchoiceProdDataBody: TYPE = RECORD[
identifier: identifierNode, Constant: ConstantNode];

ConstantchoiceProdProcs: ConstantNodeProcs;

BuildConstantchoiceProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[ConstantNode];

ConstantchoiceProdCoerce: CoerceProcType;
ConstantchoiceProdGetCARDINAL: GetCARDINALProcType;
ConstantchoiceProdConstantToRope: ConstantToRopeProcType;


ConstantcomponentlistProdData: TYPE = REF ConstantcomponentlistProdDataBody;
ConstantcomponentlistProdDataBody: TYPE = RECORD[
ComponentList: ComponentListNode];

ConstantcomponentlistProdProcs: ConstantNodeProcs;

BuildConstantcomponentlistProdNode: PROC[position: INT, length: INT, ComponentList: ComponentListNode]
RETURNS[ConstantNode];

ConstantcomponentlistProdCoerce: CoerceProcType;
ConstantcomponentlistProdGetCARDINAL: GetCARDINALProcType;
ConstantcomponentlistProdConstantToRope: ConstantToRopeProcType;


ConstantelementListProdData: TYPE = REF ConstantelementListProdDataBody;
ConstantelementListProdDataBody: TYPE = RECORD[
ElementList: ElementListNode];

ConstantelementListProdProcs: ConstantNodeProcs;

BuildConstantelementListProdNode: PROC[position: INT, length: INT, ElementList: ElementListNode]
RETURNS[ConstantNode];

ConstantelementListProdCoerce: CoerceProcType;
ConstantelementListProdGetCARDINAL: GetCARDINALProcType;
ConstantelementListProdConstantToRope: ConstantToRopeProcType;


ConstantemptyProdData: TYPE = REF ConstantemptyProdDataBody;
ConstantemptyProdDataBody: TYPE = RECORD[
];

ConstantemptyProdProcs: ConstantNodeProcs;

BuildConstantemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantemptyProdCoerce: CoerceProcType;
ConstantemptyProdGetCARDINAL: GetCARDINALProcType;
ConstantemptyProdConstantToRope: ConstantToRopeProcType;


ConstantfalseProdData: TYPE = REF ConstantfalseProdDataBody;
ConstantfalseProdDataBody: TYPE = RECORD[
];

ConstantfalseProdProcs: ConstantNodeProcs;

BuildConstantfalseProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantfalseProdCoerce: CoerceProcType;
ConstantfalseProdGetCARDINAL: GetCARDINALProcType;
ConstantfalseProdConstantToRope: ConstantToRopeProcType;


ConstantidProdData: TYPE = REF ConstantidProdDataBody;
ConstantidProdDataBody: TYPE = RECORD[
identifier: identifierNode];

ConstantidProdProcs: ConstantNodeProcs;

BuildConstantidProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[ConstantNode];

ConstantidProdCoerce: CoerceProcType;
ConstantidProdGetCARDINAL: GetCARDINALProcType;
ConstantidProdConstantToRope: ConstantToRopeProcType;


ConstantnegativeNumberProdData: TYPE = REF ConstantnegativeNumberProdDataBody;
ConstantnegativeNumberProdDataBody: TYPE = RECORD[
number: numberNode];

ConstantnegativeNumberProdProcs: ConstantNodeProcs;

BuildConstantnegativeNumberProdNode: PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode];

ConstantnegativeNumberProdCoerce: CoerceProcType;
ConstantnegativeNumberProdGetCARDINAL: GetCARDINALProcType;
ConstantnegativeNumberProdConstantToRope: ConstantToRopeProcType;


ConstantnumberProdData: TYPE = REF ConstantnumberProdDataBody;
ConstantnumberProdDataBody: TYPE = RECORD[
number: numberNode];

ConstantnumberProdProcs: ConstantNodeProcs;

BuildConstantnumberProdNode: PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode];

ConstantnumberProdCoerce: CoerceProcType;
ConstantnumberProdGetCARDINAL: GetCARDINALProcType;
ConstantnumberProdConstantToRope: ConstantToRopeProcType;


ConstantremoteReferenceProdData: TYPE = REF ConstantremoteReferenceProdDataBody;
ConstantremoteReferenceProdDataBody: TYPE = RECORD[
identifierleft: identifierNode, identifierright: identifierNode];

ConstantremoteReferenceProdProcs: ConstantNodeProcs;

BuildConstantremoteReferenceProdNode: PROC[position: INT, length: INT, identifierleft: identifierNode, identifierright: identifierNode]
RETURNS[ConstantNode];

ConstantremoteReferenceProdCoerce: CoerceProcType;
ConstantremoteReferenceProdGetCARDINAL: GetCARDINALProcType;
ConstantremoteReferenceProdConstantToRope: ConstantToRopeProcType;


ConstantstringProdData: TYPE = REF ConstantstringProdDataBody;
ConstantstringProdDataBody: TYPE = RECORD[
Rope: RopeNode];

ConstantstringProdProcs: ConstantNodeProcs;

BuildConstantstringProdNode: PROC[position: INT, length: INT, Rope: RopeNode]
RETURNS[ConstantNode];

ConstantstringProdCoerce: CoerceProcType;
ConstantstringProdGetCARDINAL: GetCARDINALProcType;
ConstantstringProdConstantToRope: ConstantToRopeProcType;


ConstanttrueProdData: TYPE = REF ConstanttrueProdDataBody;
ConstanttrueProdDataBody: TYPE = RECORD[
];

ConstanttrueProdProcs: ConstantNodeProcs;

BuildConstanttrueProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstanttrueProdCoerce: CoerceProcType;
ConstanttrueProdGetCARDINAL: GetCARDINALProcType;
ConstanttrueProdConstantToRope: ConstantToRopeProcType;


ConstantunboundedProdData: TYPE = REF ConstantunboundedProdDataBody;
ConstantunboundedProdDataBody: TYPE = RECORD[
];

ConstantunboundedProdProcs: ConstantNodeProcs;

BuildConstantunboundedProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantunboundedProdCoerce: CoerceProcType;
ConstantunboundedProdGetCARDINAL: GetCARDINALProcType;
ConstantunboundedProdConstantToRope: ConstantToRopeProcType;


ElementListoneProdData: TYPE = REF ElementListoneProdDataBody;
ElementListoneProdDataBody: TYPE = RECORD[
Constant: ConstantNode];

ElementListoneProdProcs: ElementListNodeProcs;

BuildElementListoneProdNode: PROC[position: INT, length: INT, Constant: ConstantNode]
RETURNS[ElementListNode];

ElementListoneProdCoerceElementList: CoerceElementListProcType;
ElementListoneProdConstantToRope: ConstantToRopeProcType;
ElementListoneProdSize: SizeProcType;
ElementListoneProdConstructFunction: ConstructFunctionProcType;


ElementListmoreProdData: TYPE = REF ElementListmoreProdDataBody;
ElementListmoreProdDataBody: TYPE = RECORD[
Constant: ConstantNode, ElementList: ElementListNode];

ElementListmoreProdProcs: ElementListNodeProcs;

BuildElementListmoreProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, ElementList: ElementListNode]
RETURNS[ElementListNode];

ElementListmoreProdCoerceElementList: CoerceElementListProcType;
ElementListmoreProdConstantToRope: ConstantToRopeProcType;
ElementListmoreProdSize: SizeProcType;
ElementListmoreProdConstructFunction: ConstructFunctionProcType;


ComponentListoneProdData: TYPE = REF ComponentListoneProdDataBody;
ComponentListoneProdDataBody: TYPE = RECORD[
Component: ComponentNode];

ComponentListoneProdProcs: ComponentListNodeProcs;

BuildComponentListoneProdNode: PROC[position: INT, length: INT, Component: ComponentNode]
RETURNS[ComponentListNode];

ComponentListoneProdCoerceComponents: CoerceComponentsProcType;
ComponentListoneProdConstantToRope: ConstantToRopeProcType;
ComponentListoneProdCheckAllNames: CheckAllNamesProcType;


ComponentListmoreProdData: TYPE = REF ComponentListmoreProdDataBody;
ComponentListmoreProdDataBody: TYPE = RECORD[
Component: ComponentNode, ComponentList: ComponentListNode];

ComponentListmoreProdProcs: ComponentListNodeProcs;

BuildComponentListmoreProdNode: PROC[position: INT, length: INT, Component: ComponentNode, ComponentList: ComponentListNode]
RETURNS[ComponentListNode];

ComponentListmoreProdCoerceComponents: CoerceComponentsProcType;
ComponentListmoreProdConstantToRope: ConstantToRopeProcType;
ComponentListmoreProdCheckAllNames: CheckAllNamesProcType;


ComponentProdData: TYPE = REF ComponentProdDataBody;
ComponentProdDataBody: TYPE = RECORD[
NameList: NameListNode, Constant: ConstantNode];

ComponentProdProcs: ComponentNodeProcs;

BuildComponentProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Constant: ConstantNode]
RETURNS[ComponentNode];

ComponentProdCoerceComponents: CoerceComponentsProcType;
ComponentProdConstantToRope: ConstantToRopeProcType;
ComponentProdCheckAllNames: CheckAllNamesProcType;


NameListemptyProdData: TYPE = REF NameListemptyProdDataBody;
NameListemptyProdDataBody: TYPE = RECORD[
];

NameListemptyProdProcs: NameListNodeProcs;

BuildNameListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[NameListNode];

NameListemptyProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListemptyProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListemptyProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListemptyProdNameListToRope: NameListToRopeProcType;
NameListemptyProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListemptyProdTypeOfNameList: TypeOfNameListProcType;


NameListoneProdData: TYPE = REF NameListoneProdDataBody;
NameListoneProdDataBody: TYPE = RECORD[
identifier: identifierNode];

NameListoneProdProcs: NameListNodeProcs;

BuildNameListoneProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[NameListNode];

NameListoneProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListoneProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListoneProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListoneProdNameListToRope: NameListToRopeProcType;
NameListoneProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListoneProdTypeOfNameList: TypeOfNameListProcType;


NameListmoreProdData: TYPE = REF NameListmoreProdDataBody;
NameListmoreProdDataBody: TYPE = RECORD[
identifier: identifierNode, NameList: NameListNode];

NameListmoreProdProcs: NameListNodeProcs;

BuildNameListmoreProdNode: PROC[position: INT, length: INT, identifier: identifierNode, NameList: NameListNode]
RETURNS[NameListNode];

NameListmoreProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListmoreProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListmoreProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListmoreProdNameListToRope: NameListToRopeProcType;
NameListmoreProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListmoreProdTypeOfNameList: TypeOfNameListProcType;


numberdecimalProdData: TYPE = REF numberdecimalProdDataBody;
numberdecimalProdDataBody: TYPE = RECORD[
numberD: numberDNode];

numberdecimalProdProcs: numberNodeProcs;

BuildnumberdecimalProdNode: PROC[position: INT, length: INT, numberD: numberDNode]
RETURNS[numberNode];

numberdecimalProdGetCARDINAL: GetCARDINALProcType;
numberdecimalProdNumberToCard: NumberToCardProcType;


numberhexProdData: TYPE = REF numberhexProdDataBody;
numberhexProdDataBody: TYPE = RECORD[
numberH: numberHNode];

numberhexProdProcs: numberNodeProcs;

BuildnumberhexProdNode: PROC[position: INT, length: INT, numberH: numberHNode]
RETURNS[numberNode];

numberhexProdGetCARDINAL: GetCARDINALProcType;
numberhexProdNumberToCard: NumberToCardProcType;


numberoctalProdData: TYPE = REF numberoctalProdDataBody;
numberoctalProdDataBody: TYPE = RECORD[
numberO: numberONode];

numberoctalProdProcs: numberNodeProcs;

BuildnumberoctalProdNode: PROC[position: INT, length: INT, numberO: numberONode]
RETURNS[numberNode];

numberoctalProdGetCARDINAL: GetCARDINALProcType;
numberoctalProdNumberToCard: NumberToCardProcType;
END..

tProgramProd
ReferencedProgramListemptyProd
ReferencedProgramListmoreProd
ReferencedProgramProd
DeclarationListemptyProd
DeclarationListmoreProd
DeclarationtypeProd
DeclarationconstantProd
TypearrayProd
TypebooleanProd
TypebulkDataSinkProd
TypebulkDataSourceProd
TypecardinalProd
TypechoiceProd
TypeemptyRecordProd
TypeenumerationProd
TypeerrorProd
TypeintegerProd
TypelocalReferenceProd
TypelongCardinalProd
TypelongIntegerProd
TypeprocedureProd
TyperecordProd
TyperemoteReferenceProd
TypesequenceProd
TypestringProd
TypeunspecifiedProd
CorrespondenceListoneProd
CorrespondenceListmoreProd
CandidateListoneProd
CandidateListmoreProd
FieldListemptyProd
FieldListoneProd
FieldListmoreProd
ConstantchoiceProd
ConstantcomponentlistProd
ConstantelementListProd
ConstantemptyProd
ConstantfalseProd
ConstantidProd
ConstantnegativeNumberProd
ConstantnumberProd
ConstantremoteReferenceProd
ConstantstringProd
ConstanttrueProd
ConstantunboundedProd
ElementListoneProd
ElementListmoreProd
ComponentListoneProd
ComponentListmoreProd
ComponentProd
NameListemptyProd
NameListoneProd
NameListmoreProd
numberdecimalProd
numberhexProd
numberoctalProd
�Ê/˜š
Ïk	˜	J˜J˜—J˜JšÏnœ�œ
�œ˜,Jš
�˜Jš�œ˜J˜Jš
œ™J˜Jšœ�œ�œ˜0Jšœ�œ�œ
˜#JšœSžœžœ˜«
J˜Jšžœ˜#J˜šžœ�œ�œ
�œUžœžœ˜á
Jš�œ˜—J˜Jšžœ˜4J˜Jš
œ™J˜Jšœ$�œ�œ(˜VJšœ(�œ�œ
˜6J˜J˜Jšž#œ!˜DJ˜šž'œ�œ�œ
�œ
˜IJš�œ˜#—J˜Jšž)œ˜?J˜Jš
œ™J˜Jšœ#�œ�œ'˜TJšœ'�œ�œ
˜5Jšžœžœ˜\J˜Jšž"œ!˜CJ˜šž&œ�œ�œ
�œžœžœ˜¤
Jš�œ˜#—J˜Jšž(œ˜>J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-J˜SJ˜Jšžœ˜7J˜šžœ�œ�œ
�œT˜“
Jš�œ˜—J˜Jšž œ˜6J˜Jš
œ™J˜Jšœ�œ�œ"˜JJšœ"�œ�œ
˜0J˜J˜Jšžœ˜8J˜šž!œ�œ�œ
�œ
˜CJš�œ˜—J˜Jšž"œ˜7Jšž#œ˜9J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/Jšžœžœ˜DJ˜Jšžœ˜7J˜šž œ�œ�œ
�œžœžœ˜†
Jš�œ˜—J˜Jšž!œ˜6Jšž"œ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšœžœ˜,J˜Jšžœ˜/J˜š
žœ�œ�œ
�œžœ˜jJš�œ˜—J˜Jšžœ˜2Jšžœ˜4J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/Jšœžœžœ˜DJ˜Jšžœ˜3J˜šž œ�œ�œ
�œžœžœ˜†
Jš�œ˜—J˜Jšž!œ˜6Jšž"œ˜8J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%Jšžœžœ˜(J˜Jšžœ˜"J˜šžœ�œ�œ
�œžœžœ˜`Jš�œ˜—J˜Jšžœ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜$J˜šžœ�œ�œ
�œ
˜:Jš�œ˜—J˜Jšžœ˜:J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜?Jš�œ˜—J˜Jšž$œ˜?J˜Jš
œ™J˜Jšœ�œ�œ ˜FJšœ �œ�œ
˜.J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ
˜AJš�œ˜—J˜Jšž&œ˜AJ˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜%J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜Jšž œ˜;J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœž
œ˜2J˜Jšžœ˜#J˜šžœ�œ�œ
�œžœž
œ˜kJš�œ˜—J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜>Jš�œ˜—J˜Jšž#œ˜>J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜,J˜Jšžœ˜(J˜š
žœ�œ�œ
�œžœ˜jJš�œ˜—J˜Jšž#œ˜>J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%Jšž	œ˜J˜Jšžœ˜"J˜š
žœ�œ�œ
�œž	œ˜RJš�œ˜—J˜Jšžœ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜$J˜šžœ�œ�œ
�œ
˜:Jš�œ˜—J˜Jšžœ˜:J˜Jš
œ™J˜Jšœ�œ�œ ˜FJšœ �œ�œ
˜.J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ˜]Jš�œ˜—J˜Jšž&œ˜AJ˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜?Jš�œ˜—J˜Jšž$œ˜?J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜>Jš�œ˜—J˜Jšž#œ˜>J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœžœžœ˜RJ˜Jšžœ˜&J˜šžœ�œ�œ
�œžœžœžœ˜Ž
Jš�œ˜—J˜Jšž!œ˜<J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšž	œ˜J˜Jšžœ˜#J˜š
žœ�œ�œ
�œž	œ˜SJš�œ˜—J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/J˜:J˜Jšžœ˜,J˜šž œ�œ�œ
�œ;˜|Jš�œ˜—J˜Jšž'œ˜BJ˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜(J˜Jšžœ˜%J˜šžœ�œ�œ
�œžœžœ˜cJš�œ˜—J˜Jšž œ˜;J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&J˜J˜Jšžœ˜#J˜šžœ�œ�œ
�œ
˜9Jš�œ˜—J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜>Jš�œ˜—J˜Jšž#œ˜>J˜Jš
œ™J˜Jšœ�œ�œ#˜LJšœ#�œ�œ
˜1Jšœžœ˜4J˜Jšžœ˜<J˜š
ž"œ�œ�œ
�œžœ˜xJš�œ˜ —J˜Jšž7œ)˜`Jšž0œ"˜RJ˜Jš
œ™J˜Jšœ �œ�œ$˜NJšœ$�œ�œ
˜2Jšžœžœ˜aJ˜Jšžœ˜=J˜šž#œ�œ�œ
�œžœžœ˜¦
Jš�œ˜ —J˜Jšž8œ)˜aJšž1œ"˜SJ˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšžœžœ˜(J˜Jšžœ˜2J˜šžœ�œ�œ
�œžœžœ˜gJš�œ˜—J˜Jšž-œ$˜QJšž)œ ˜IJ˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-Jšžœžœ˜MJ˜Jšžœ˜3J˜šžœ�œ�œ
�œžœžœ˜�
Jš�œ˜—J˜Jšž.œ$˜RJšž*œ ˜JJ˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜=Jš�œ˜—J˜Jšž'œ ˜GJ˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜(J˜Jšžœ˜*J˜šžœ�œ�œ
�œžœžœ˜cJš�œ˜—J˜Jšž%œ ˜EJ˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœž
œ˜=J˜Jšžœ˜+J˜šžœ�œ�œ
�œžœž
œ˜yJš�œ˜—J˜Jšž&œ ˜FJ˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšœžœ˜4J˜Jšžœ˜+J˜š
žœ�œ�œ
�œžœ˜qJš�œ˜—J˜Jšžœ˜)Jšžœ˜3Jšž œ˜9J˜Jš
œ™J˜Jšœ�œ�œ#˜LJšœ#�œ�œ
˜1Jšž
œ˜"J˜Jšžœ˜2J˜š
ž"œ�œ�œ
�œž
œ˜fJš�œ˜—J˜Jšžœ˜0Jšž$œ˜:Jšž'œ˜@J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/Jšžœ˜J˜Jšžœ˜0J˜š
ž œ�œ�œ
�œžœ˜`Jš�œ˜—J˜Jšžœ˜.Jšž"œ˜8Jšž%œ˜>J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜Jšžœ˜(Jšžœ˜2Jšžœ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜Jšžœ˜(Jšžœ˜2Jšžœ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&J˜J˜Jšžœ˜'J˜šžœ�œ�œ
�œ˜UJš�œ˜—J˜Jšžœ˜%Jšžœ˜/Jšžœ˜5J˜Jš
œ™J˜Jšœ �œ�œ$˜NJšœ$�œ�œ
˜2J˜J˜Jšžœ˜3J˜šž#œ�œ�œ
�œ˜YJš�œ˜—J˜Jšž œ˜1Jšž%œ˜;Jšž(œ˜AJ˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ˜QJš�œ˜—J˜Jšžœ˜)Jšžœ˜3Jšž œ˜9J˜Jš
œ™J˜Jšœ!�œ�œ%˜PJšœ%�œ�œ
˜3J˜AJ˜Jšž œ˜4J˜šž$œ�œ�œ
�œB˜‡
Jš�œ˜—J˜Jšž!œ˜2Jšž&œ˜<Jšž)œ˜BJ˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœ˜J˜Jšžœ˜+J˜š
žœ�œ�œ
�œžœ˜MJš�œ˜—J˜Jšžœ˜)Jšžœ˜3Jšž œ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜Jšžœ˜'Jšžœ˜1Jšžœ˜7J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-J˜J˜Jšžœ˜.J˜šžœ�œ�œ
�œ
˜@Jš�œ˜—J˜Jšžœ˜,Jšž œ˜6Jšž#œ˜<J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœ˜J˜Jšžœ˜.J˜š
žœ�œ�œ
�œžœ˜UJš�œ˜—J˜Jšž#œ˜?Jšž œ˜9Jšžœ˜%Jšž#œ˜?J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœžœ˜6J˜Jšžœ˜/J˜šžœ�œ�œ
�œžœžœ˜tJš�œ˜—J˜Jšž$œ˜@Jšž!œ˜:Jšžœ˜&Jšž$œ˜@J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšž	œ˜J˜Jšžœ˜2J˜š
žœ�œ�œ
�œž	œ˜YJš�œ˜—J˜Jšž$œ˜?Jšž"œ˜;Jšž!œ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-Jšž	œž
œ˜<J˜Jšžœ˜3J˜šžœ�œ�œ
�œž	œž
œ˜|Jš�œ˜—J˜Jšž%œ˜@Jšž#œ˜<Jšž"œ˜:J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%Jšžœžœ˜0J˜Jšžœ˜'J˜šžœ�œ�œ
�œžœžœ˜hJš�œ˜—J˜Jšžœ˜8Jšžœ˜4Jšžœ˜2J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜Jšž"œ˜>Jšž/œ)˜XJšž(œ"˜JJšžœ˜8Jšž&œ ˜FJšžœ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ˜VJš�œ˜—J˜Jšž œ˜<Jšž-œ)˜VJšž&œ"˜HJšžœ˜6Jšž$œ ˜DJšžœ˜6J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšœžœ˜4J˜Jšžœ˜)J˜š
žœ�œ�œ
�œžœ˜oJš�œ˜—J˜Jšž!œ˜=Jšž.œ)˜WJšž'œ"˜IJšžœ˜7Jšž%œ ˜EJšžœ˜7J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜J˜(J˜šžœ�œ�œ
�œ˜RJš�œ
˜—J˜J˜2J˜4J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%J˜J˜J˜$J˜šžœ�œ�œ
�œ˜NJš�œ
˜—J˜J˜.J˜0J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜J˜&J˜šžœ�œ�œ
�œ˜PJš�œ
˜—J˜J˜0J˜2Jš�œ˜J˜—…—b<�ß