DIRECTORY
SaffronTreeBucketDef,
SaffronTreeDeclsDef,
SaffronGenericDef,
SaffronATDef;

SaffronAG6Def: CEDAR DEFINITIONS = 
BEGIN
OPEN SaffronTreeBucketDef, SaffronTreeDeclsDef, SaffronGenericDef, SaffronATDef;


TypeExptypeidProdData: TYPE = REF TypeExptypeidProdDataBody;
TypeExptypeidProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode];

TypeExptypeidProdProcs: TypeExpNodeProcs;

BuildTypeExptypeidProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode]
RETURNS[TypeExpNode];

TypeExptypeidProdfoo: fooProcType;
TypeExptypeidProdMakeType: MakeTypeProcType;


TypeExpsubrangeProdData: TYPE = REF TypeExpsubrangeProdDataBody;
TypeExpsubrangeProdDataBody: TYPE = RECORD[
Subrange: SubrangeNode];

TypeExpsubrangeProdProcs: TypeExpNodeProcs;

BuildTypeExpsubrangeProdNode: PROC[position: INT, length: INT, Subrange: SubrangeNode]
RETURNS[TypeExpNode];

TypeExpsubrangeProdfoo: fooProcType;
TypeExpsubrangeProdMakeType: MakeTypeProcType;


TypeExpenumProdData: TYPE = REF TypeExpenumProdDataBody;
TypeExpenumProdDataBody: TYPE = RECORD[
MachineDependent: MachineDependentNode, ElementList: ElementListNode];

TypeExpenumProdProcs: TypeExpNodeProcs;

BuildTypeExpenumProdNode: PROC[position: INT, length: INT, MachineDependent: MachineDependentNode, ElementList: ElementListNode]
RETURNS[TypeExpNode];

TypeExpenumProdfoo: fooProcType;
TypeExpenumProdMakeType: MakeTypeProcType;


TypeExprecordProdData: TYPE = REF TypeExprecordProdDataBody;
TypeExprecordProdDataBody: TYPE = RECORD[
MachineDependent: MachineDependentNode, Monitored: MonitoredNode, RecList: RecListNode];

TypeExprecordProdProcs: TypeExpNodeProcs;

BuildTypeExprecordProdNode: PROC[position: INT, length: INT, MachineDependent: MachineDependentNode, Monitored: MonitoredNode, RecList: RecListNode]
RETURNS[TypeExpNode];

TypeExprecordProdfoo: fooProcType;
TypeExprecordProdMakeType: MakeTypeProcType;


TypeExppointerProdData: TYPE = REF TypeExppointerProdDataBody;
TypeExppointerProdDataBody: TYPE = RECORD[
Ordered: OrderedNode, Base: BaseNode, PointerType: PointerTypeNode];

TypeExppointerProdProcs: TypeExpNodeProcs;

BuildTypeExppointerProdNode: PROC[position: INT, length: INT, Ordered: OrderedNode, Base: BaseNode, PointerType: PointerTypeNode]
RETURNS[TypeExpNode];

TypeExppointerProdfoo: fooProcType;
TypeExppointerProdMakeType: MakeTypeProcType;


TypeExpvarProdData: TYPE = REF TypeExpvarProdDataBody;
TypeExpvarProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TypeExpvarProdProcs: TypeExpNodeProcs;

BuildTypeExpvarProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExpvarProdfoo: fooProcType;
TypeExpvarProdMakeType: MakeTypeProcType;


TypeExprefProdData: TYPE = REF TypeExprefProdDataBody;
TypeExprefProdDataBody: TYPE = RECORD[
ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode];

TypeExprefProdProcs: TypeExpNodeProcs;

BuildTypeExprefProdNode: PROC[position: INT, length: INT, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExprefProdfoo: fooProcType;
TypeExprefProdMakeType: MakeTypeProcType;


TypeExprefanyProdData: TYPE = REF TypeExprefanyProdDataBody;
TypeExprefanyProdDataBody: TYPE = RECORD[
ReadOnly: ReadOnlyNode];

TypeExprefanyProdProcs: TypeExpNodeProcs;

BuildTypeExprefanyProdNode: PROC[position: INT, length: INT, ReadOnly: ReadOnlyNode]
RETURNS[TypeExpNode];

TypeExprefanyProdfoo: fooProcType;
TypeExprefanyProdMakeType: MakeTypeProcType;


TypeExprefunspecifiedProdData: TYPE = REF TypeExprefunspecifiedProdDataBody;
TypeExprefunspecifiedProdDataBody: TYPE = RECORD[
];

TypeExprefunspecifiedProdProcs: TypeExpNodeProcs;

BuildTypeExprefunspecifiedProdNode: PROC[position: INT, length: INT]
RETURNS[TypeExpNode];

TypeExprefunspecifiedProdfoo: fooProcType;
TypeExprefunspecifiedProdMakeType: MakeTypeProcType;


TypeExplistProdData: TYPE = REF TypeExplistProdDataBody;
TypeExplistProdDataBody: TYPE = RECORD[
ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode];

TypeExplistProdProcs: TypeExpNodeProcs;

BuildTypeExplistProdNode: PROC[position: INT, length: INT, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExplistProdfoo: fooProcType;
TypeExplistProdMakeType: MakeTypeProcType;


TypeExparrayProdData: TYPE = REF TypeExparrayProdDataBody;
TypeExparrayProdDataBody: TYPE = RECORD[
Packed: PackedNode, OptType: OptTypeNode, TypeExp: TypeExpNode];

TypeExparrayProdProcs: TypeExpNodeProcs;

BuildTypeExparrayProdNode: PROC[position: INT, length: INT, Packed: PackedNode, OptType: OptTypeNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExparrayProdfoo: fooProcType;
TypeExparrayProdMakeType: MakeTypeProcType;


TypeExpdescriptorProdData: TYPE = REF TypeExpdescriptorProdDataBody;
TypeExpdescriptorProdDataBody: TYPE = RECORD[
ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode];

TypeExpdescriptorProdProcs: TypeExpNodeProcs;

BuildTypeExpdescriptorProdNode: PROC[position: INT, length: INT, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExpdescriptorProdfoo: fooProcType;
TypeExpdescriptorProdMakeType: MakeTypeProcType;


TypeExptransferProdData: TYPE = REF TypeExptransferProdDataBody;
TypeExptransferProdDataBody: TYPE = RECORD[
Safe: SafeNode, TransferMode: TransferModeNode, Arguments: ArgumentsNode];

TypeExptransferProdProcs: TypeExpNodeProcs;

BuildTypeExptransferProdNode: PROC[position: INT, length: INT, Safe: SafeNode, TransferMode: TransferModeNode, Arguments: ArgumentsNode]
RETURNS[TypeExpNode];

TypeExptransferProdfoo: fooProcType;
TypeExptransferProdMakeType: MakeTypeProcType;


TypeExprelativeProdData: TYPE = REF TypeExprelativeProdDataBody;
TypeExprelativeProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode, TypeExp: TypeExpNode];

TypeExprelativeProdProcs: TypeExpNodeProcs;

BuildTypeExprelativeProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExprelativeProdfoo: fooProcType;
TypeExprelativeProdMakeType: MakeTypeProcType;


TypeExpzoneProdData: TYPE = REF TypeExpzoneProdDataBody;
TypeExpzoneProdDataBody: TYPE = RECORD[
Uncounted: UncountedNode];

TypeExpzoneProdProcs: TypeExpNodeProcs;

BuildTypeExpzoneProdNode: PROC[position: INT, length: INT, Uncounted: UncountedNode]
RETURNS[TypeExpNode];

TypeExpzoneProdfoo: fooProcType;
TypeExpzoneProdMakeType: MakeTypeProcType;


TypeExplongProdData: TYPE = REF TypeExplongProdDataBody;
TypeExplongProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TypeExplongProdProcs: TypeExpNodeProcs;

BuildTypeExplongProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExplongProdfoo: fooProcType;
TypeExplongProdMakeType: MakeTypeProcType;


TypeExpframeProdData: TYPE = REF TypeExpframeProdDataBody;
TypeExpframeProdDataBody: TYPE = RECORD[
id: idNode];

TypeExpframeProdProcs: TypeExpNodeProcs;

BuildTypeExpframeProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[TypeExpNode];

TypeExpframeProdfoo: fooProcType;
TypeExpframeProdMakeType: MakeTypeProcType;


TypeExppaintedProdData: TYPE = REF TypeExppaintedProdDataBody;
TypeExppaintedProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode, TypeExp: TypeExpNode];

TypeExppaintedProdProcs: TypeExpNodeProcs;

BuildTypeExppaintedProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExppaintedProdfoo: fooProcType;
TypeExppaintedProdMakeType: MakeTypeProcType;


TypeExptypeapplyProdData: TYPE = REF TypeExptypeapplyProdDataBody;
TypeExptypeapplyProdDataBody: TYPE = RECORD[
TypeApply: TypeApplyNode];

TypeExptypeapplyProdProcs: TypeExpNodeProcs;

BuildTypeExptypeapplyProdNode: PROC[position: INT, length: INT, TypeApply: TypeApplyNode]
RETURNS[TypeExpNode];

TypeExptypeapplyProdfoo: fooProcType;
TypeExptypeapplyProdMakeType: MakeTypeProcType;


TypeExpunionProdData: TYPE = REF TypeExpunionProdDataBody;
TypeExpunionProdDataBody: TYPE = RECORD[
Tag: TagNode, VariantList: VariantListNode];

TypeExpunionProdProcs: TypeExpNodeProcs;

BuildTypeExpunionProdNode: PROC[position: INT, length: INT, Tag: TagNode, VariantList: VariantListNode]
RETURNS[TypeExpNode];

TypeExpunionProdfoo: fooProcType;
TypeExpunionProdMakeType: MakeTypeProcType;


TypeExpsequenceProdData: TYPE = REF TypeExpsequenceProdDataBody;
TypeExpsequenceProdDataBody: TYPE = RECORD[
Packed: PackedNode, Tag: TagNode, TypeExp: TypeExpNode];

TypeExpsequenceProdProcs: TypeExpNodeProcs;

BuildTypeExpsequenceProdNode: PROC[position: INT, length: INT, Packed: PackedNode, Tag: TagNode, TypeExp: TypeExpNode]
RETURNS[TypeExpNode];

TypeExpsequenceProdfoo: fooProcType;
TypeExpsequenceProdMakeType: MakeTypeProcType;


TypeIdidProdData: TYPE = REF TypeIdidProdDataBody;
TypeIdidProdDataBody: TYPE = RECORD[
id: idNode];

TypeIdidProdProcs: TypeIdNodeProcs;

BuildTypeIdidProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[TypeIdNode];

TypeIdidProdfoo: fooProcType;
TypeIdidProdMakeType: MakeTypeProcType;


TypeIdqualifierProdData: TYPE = REF TypeIdqualifierProdDataBody;
TypeIdqualifierProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode, id: idNode];

TypeIdqualifierProdProcs: TypeIdNodeProcs;

BuildTypeIdqualifierProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode, id: idNode]
RETURNS[TypeIdNode];

TypeIdqualifierProdfoo: fooProcType;
TypeIdqualifierProdMakeType: MakeTypeProcType;


SubrangenamedProdData: TYPE = REF SubrangenamedProdDataBody;
SubrangenamedProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode, Interval: IntervalNode];

SubrangenamedProdProcs: SubrangeNodeProcs;

BuildSubrangenamedProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode, Interval: IntervalNode]
RETURNS[SubrangeNode];

SubrangenamedProdfoo: fooProcType;
SubrangenamedProdMakeType: MakeTypeProcType;


SubrangeunnamedProdData: TYPE = REF SubrangeunnamedProdDataBody;
SubrangeunnamedProdDataBody: TYPE = RECORD[
Interval: IntervalNode];

SubrangeunnamedProdProcs: SubrangeNodeProcs;

BuildSubrangeunnamedProdNode: PROC[position: INT, length: INT, Interval: IntervalNode]
RETURNS[SubrangeNode];

SubrangeunnamedProdfoo: fooProcType;
SubrangeunnamedProdMakeType: MakeTypeProcType;


IntervalccProdData: TYPE = REF IntervalccProdDataBody;
IntervalccProdDataBody: TYPE = RECORD[
Bounds: BoundsNode];

IntervalccProdProcs: IntervalNodeProcs;

BuildIntervalccProdNode: PROC[position: INT, length: INT, Bounds: BoundsNode]
RETURNS[IntervalNode];

IntervalccProdfoo: fooProcType;
IntervalccProdMakeTypeInterval: MakeTypeIntervalProcType;


IntervalcoProdData: TYPE = REF IntervalcoProdDataBody;
IntervalcoProdDataBody: TYPE = RECORD[
Bounds: BoundsNode];

IntervalcoProdProcs: IntervalNodeProcs;

BuildIntervalcoProdNode: PROC[position: INT, length: INT, Bounds: BoundsNode]
RETURNS[IntervalNode];

IntervalcoProdfoo: fooProcType;
IntervalcoProdMakeTypeInterval: MakeTypeIntervalProcType;


IntervalocProdData: TYPE = REF IntervalocProdDataBody;
IntervalocProdDataBody: TYPE = RECORD[
Bounds: BoundsNode];

IntervalocProdProcs: IntervalNodeProcs;

BuildIntervalocProdNode: PROC[position: INT, length: INT, Bounds: BoundsNode]
RETURNS[IntervalNode];

IntervalocProdfoo: fooProcType;
IntervalocProdMakeTypeInterval: MakeTypeIntervalProcType;


IntervalooProdData: TYPE = REF IntervalooProdDataBody;
IntervalooProdDataBody: TYPE = RECORD[
Bounds: BoundsNode];

IntervalooProdProcs: IntervalNodeProcs;

BuildIntervalooProdNode: PROC[position: INT, length: INT, Bounds: BoundsNode]
RETURNS[IntervalNode];

IntervalooProdfoo: fooProcType;
IntervalooProdMakeTypeInterval: MakeTypeIntervalProcType;


BoundsProdData: TYPE = REF BoundsProdDataBody;
BoundsProdDataBody: TYPE = RECORD[
Boundlower: BoundNode, Boundupper: BoundNode];

BoundsProdProcs: BoundsNodeProcs;

BuildBoundsProdNode: PROC[position: INT, length: INT, Boundlower: BoundNode, Boundupper: BoundNode]
RETURNS[BoundsNode];

BoundsProdfoo: fooProcType;
BoundsProdMakeTypeBounds: MakeTypeBoundsProcType;


BoundProdData: TYPE = REF BoundProdDataBody;
BoundProdDataBody: TYPE = RECORD[
Exp: ExpNode];

BoundProdProcs: BoundNodeProcs;

BuildBoundProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[BoundNode];

BoundProdfoo: fooProcType;
BoundProdMakeTypeBound: MakeTypeBoundProcType;


MachineDependentyesProdData: TYPE = REF MachineDependentyesProdDataBody;
MachineDependentyesProdDataBody: TYPE = RECORD[
];

MachineDependentyesProdProcs: MachineDependentNodeProcs;

BuildMachineDependentyesProdNode: PROC[position: INT, length: INT]
RETURNS[MachineDependentNode];

MachineDependentyesProdfoo: fooProcType;


MachineDependentnoProdData: TYPE = REF MachineDependentnoProdDataBody;
MachineDependentnoProdDataBody: TYPE = RECORD[
];

MachineDependentnoProdProcs: MachineDependentNodeProcs;

BuildMachineDependentnoProdNode: PROC[position: INT, length: INT]
RETURNS[MachineDependentNode];

MachineDependentnoProdfoo: fooProcType;


MonitoredyesProdData: TYPE = REF MonitoredyesProdDataBody;
MonitoredyesProdDataBody: TYPE = RECORD[
];

MonitoredyesProdProcs: MonitoredNodeProcs;

BuildMonitoredyesProdNode: PROC[position: INT, length: INT]
RETURNS[MonitoredNode];

MonitoredyesProdfoo: fooProcType;


MonitorednoProdData: TYPE = REF MonitorednoProdDataBody;
MonitorednoProdDataBody: TYPE = RECORD[
];

MonitorednoProdProcs: MonitoredNodeProcs;

BuildMonitorednoProdNode: PROC[position: INT, length: INT]
RETURNS[MonitoredNode];

MonitorednoProdfoo: fooProcType;


ElementListemptyProdData: TYPE = REF ElementListemptyProdDataBody;
ElementListemptyProdDataBody: TYPE = RECORD[
];

ElementListemptyProdProcs: ElementListNodeProcs;

BuildElementListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ElementListNode];

ElementListemptyProdfoo: fooProcType;
ElementListemptyProdMakeEltList: MakeEltListProcType;


ElementListmoreProdData: TYPE = REF ElementListmoreProdDataBody;
ElementListmoreProdDataBody: TYPE = RECORD[
ElementList: ElementListNode, Element: ElementNode];

ElementListmoreProdProcs: ElementListNodeProcs;

BuildElementListmoreProdNode: PROC[position: INT, length: INT, ElementList: ElementListNode, Element: ElementNode]
RETURNS[ElementListNode];

ElementListmoreProdfoo: fooProcType;
ElementListmoreProdMakeEltList: MakeEltListProcType;


ElementidProdData: TYPE = REF ElementidProdDataBody;
ElementidProdDataBody: TYPE = RECORD[
id: idNode];

ElementidProdProcs: ElementNodeProcs;

BuildElementidProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[ElementNode];

ElementidProdfoo: fooProcType;
ElementidProdInsertElement: InsertElementProcType;


ElementidwithrepProdData: TYPE = REF ElementidwithrepProdDataBody;
ElementidwithrepProdDataBody: TYPE = RECORD[
id: idNode, Exp: ExpNode];

ElementidwithrepProdProcs: ElementNodeProcs;

BuildElementidwithrepProdNode: PROC[position: INT, length: INT, id: idNode, Exp: ExpNode]
RETURNS[ElementNode];

ElementidwithrepProdfoo: fooProcType;
ElementidwithrepProdInsertElement: InsertElementProcType;


ElementanonymousrepProdData: TYPE = REF ElementanonymousrepProdDataBody;
ElementanonymousrepProdDataBody: TYPE = RECORD[
Exp: ExpNode];

ElementanonymousrepProdProcs: ElementNodeProcs;

BuildElementanonymousrepProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[ElementNode];

ElementanonymousrepProdfoo: fooProcType;
ElementanonymousrepProdInsertElement: InsertElementProcType;


RecListemptyProdData: TYPE = REF RecListemptyProdDataBody;
RecListemptyProdDataBody: TYPE = RECORD[
];

RecListemptyProdProcs: RecListNodeProcs;

BuildRecListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[RecListNode];

RecListemptyProdfoo: fooProcType;
RecListemptyProdMakeFieldList: MakeFieldListProcType;


RecListpairlistProdData: TYPE = REF RecListpairlistProdDataBody;
RecListpairlistProdDataBody: TYPE = RECORD[
PairList: PairListNode];

RecListpairlistProdProcs: RecListNodeProcs;

BuildRecListpairlistProdNode: PROC[position: INT, length: INT, PairList: PairListNode]
RETURNS[RecListNode];

RecListpairlistProdfoo: fooProcType;
RecListpairlistProdMakeFieldList: MakeFieldListProcType;


RecListtypelistProdData: TYPE = REF RecListtypelistProdDataBody;
RecListtypelistProdDataBody: TYPE = RECORD[
TypeList: TypeListNode];

RecListtypelistProdProcs: RecListNodeProcs;

BuildRecListtypelistProdNode: PROC[position: INT, length: INT, TypeList: TypeListNode]
RETURNS[RecListNode];

RecListtypelistProdfoo: fooProcType;
RecListtypelistProdMakeFieldList: MakeFieldListProcType;


PairListoneProdData: TYPE = REF PairListoneProdDataBody;
PairListoneProdDataBody: TYPE = RECORD[
PairItem: PairItemNode];

PairListoneProdProcs: PairListNodeProcs;

BuildPairListoneProdNode: PROC[position: INT, length: INT, PairItem: PairItemNode]
RETURNS[PairListNode];

PairListoneProdfoo: fooProcType;
PairListoneProdMakeNamedFieldList: MakeNamedFieldListProcType;


PairListmanyProdData: TYPE = REF PairListmanyProdDataBody;
PairListmanyProdDataBody: TYPE = RECORD[
PairListhead: PairListNode, PairListtail: PairListNode];

PairListmanyProdProcs: PairListNodeProcs;

BuildPairListmanyProdNode: PROC[position: INT, length: INT, PairListhead: PairListNode, PairListtail: PairListNode]
RETURNS[PairListNode];

PairListmanyProdfoo: fooProcType;
PairListmanyProdMakeNamedFieldList: MakeNamedFieldListProcType;


PairItemProdData: TYPE = REF PairItemProdDataBody;
PairItemProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Access: AccessNode, TypeExp: TypeExpNode, Default: DefaultNode];

PairItemProdProcs: PairItemNodeProcs;

BuildPairItemProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, TypeExp: TypeExpNode, Default: DefaultNode]
RETURNS[PairItemNode];

PairItemProdfoo: fooProcType;
PairItemProdMakeNamedFieldList: MakeNamedFieldListProcType;


TypeListoneProdData: TYPE = REF TypeListoneProdDataBody;
TypeListoneProdDataBody: TYPE = RECORD[
TypeItem: TypeItemNode];

TypeListoneProdProcs: TypeListNodeProcs;

BuildTypeListoneProdNode: PROC[position: INT, length: INT, TypeItem: TypeItemNode]
RETURNS[TypeListNode];

TypeListoneProdfoo: fooProcType;
TypeListoneProdMakeUnnamedFieldList: MakeUnnamedFieldListProcType;


TypeListmanyProdData: TYPE = REF TypeListmanyProdDataBody;
TypeListmanyProdDataBody: TYPE = RECORD[
TypeListhead: TypeListNode, TypeListtail: TypeListNode];

TypeListmanyProdProcs: TypeListNodeProcs;

BuildTypeListmanyProdNode: PROC[position: INT, length: INT, TypeListhead: TypeListNode, TypeListtail: TypeListNode]
RETURNS[TypeListNode];

TypeListmanyProdfoo: fooProcType;
TypeListmanyProdMakeUnnamedFieldList: MakeUnnamedFieldListProcType;


TypeItemProdData: TYPE = REF TypeItemProdDataBody;
TypeItemProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode, Default: DefaultNode];

TypeItemProdProcs: TypeItemNodeProcs;

BuildTypeItemProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode, Default: DefaultNode]
RETURNS[TypeItemNode];

TypeItemProdfoo: fooProcType;
TypeItemProdMakeUnnamedFieldList: MakeUnnamedFieldListProcType;
END..

2SaffronAG6Def.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Generated by BJackson.pa at April 27, 1987 10:51:20 pm PDT
using ThreeCasabaFour [1.1] of April 14, 1987 6:34:07 pm PDT
TypeExptypeidProd
TypeExpsubrangeProd
TypeExpenumProd
TypeExprecordProd
TypeExppointerProd
TypeExpvarProd
TypeExprefProd
TypeExprefanyProd
TypeExprefunspecifiedProd
TypeExplistProd
TypeExparrayProd
TypeExpdescriptorProd
TypeExptransferProd
TypeExprelativeProd
TypeExpzoneProd
TypeExplongProd
TypeExpframeProd
TypeExppaintedProd
TypeExptypeapplyProd
TypeExpunionProd
TypeExpsequenceProd
TypeIdidProd
TypeIdqualifierProd
SubrangenamedProd
SubrangeunnamedProd
IntervalccProd
IntervalcoProd
IntervalocProd
IntervalooProd
BoundsProd
BoundProd
MachineDependentyesProd
MachineDependentnoProd
MonitoredyesProd
MonitorednoProd
ElementListemptyProd
ElementListmoreProd
ElementidProd
ElementidwithrepProd
ElementanonymousrepProd
RecListemptyProd
RecListpairlistProd
RecListtypelistProd
PairListoneProd
PairListmanyProd
PairItemProd
TypeListoneProd
TypeListmanyProd
TypeItemProd
�Ê3˜š
œ™Jš
œ<™<Jš
œ:™:Jš
œ<™<—J˜š
Ïk	˜	J˜J˜J˜J˜
—J˜JšÏn
œ�œ
�œ˜#Jš
�˜Jš�œL˜PJ˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœ˜J˜Jšžœ˜)J˜š
žœ�œ�œ
�œžœ
˜PJš�œ˜—J˜J˜"Jšžœ˜,J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜+J˜š
žœ�œ�œ
�œžœ˜VJš�œ˜—J˜J˜$Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœžœ˜FJ˜Jšžœ˜'J˜šžœ�œ�œ
�œžœžœ˜€
Jš�œ˜—J˜J˜ Jšžœ˜*J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœž	œžœ˜XJ˜Jšžœ˜)J˜šžœ�œ�œ
�œžœž	œžœ˜”
Jš�œ˜—J˜J˜"Jšžœ˜,J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœžœžœ˜DJ˜Jšžœ˜*J˜šžœ�œ�œ
�œžœžœžœ˜�
Jš�œ˜—J˜J˜#Jšžœ˜-J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜&J˜š
žœ�œ�œ
�œžœ˜OJš�œ˜—J˜J˜Jšžœ˜)J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœžœ˜.J˜Jšžœ˜&J˜šžœ�œ�œ
�œžœžœ˜gJš�œ˜—J˜J˜Jšžœ˜)J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœ˜J˜Jšžœ˜)J˜š
žœ�œ�œ
�œžœ˜TJš�œ˜—J˜J˜"Jšžœ˜,J˜Jš
œ™J˜Jšœ�œ�œ#˜LJšœ#�œ�œ
˜1J˜J˜Jšžœ˜1J˜šž"œ�œ�œ
�œ
˜DJš�œ˜—J˜J˜*Jšž!œ˜4J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœžœ˜.J˜Jšžœ˜'J˜šžœ�œ�œ
�œžœžœ˜hJš�œ˜—J˜J˜ Jšžœ˜*J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœžœ˜@J˜Jšžœ˜(J˜šžœ�œ�œ
�œžœžœžœ˜{Jš�œ˜—J˜J˜!Jšžœ˜+J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-Jšžœžœ˜.J˜Jšžœ˜-J˜šžœ�œ�œ
�œžœžœ˜nJš�œ˜—J˜J˜&Jšžœ˜0J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœžœž	œ˜JJ˜Jšžœ˜+J˜šžœ�œ�œ
�œžœžœž	œ˜ˆ
Jš�œ˜—J˜J˜$Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœžœ˜*J˜Jšžœ˜+J˜šžœ�œ�œ
�œžœžœ˜hJš�œ˜—J˜J˜$Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšž	œ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œž	œ˜TJš�œ˜—J˜J˜ Jšžœ˜*J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œžœ˜PJš�œ˜—J˜J˜ Jšžœ˜*J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜GJš�œ˜—J˜J˜!Jšžœ˜+J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœžœ˜*J˜Jšžœ˜*J˜šžœ�œ�œ
�œžœžœ˜gJš�œ˜—J˜J˜#Jšžœ˜-J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšž	œ˜J˜Jšžœ˜,J˜š
žœ�œ�œ
�œž	œ˜YJš�œ˜—J˜J˜%Jšžœ˜/J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜,J˜Jšžœ˜(J˜šžœ�œ�œ
�œžœžœ˜gJš�œ˜—J˜J˜!Jšžœ˜+J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœžœžœ˜8J˜Jšžœ˜+J˜šžœ�œ�œ
�œžœžœžœ˜vJš�œ˜—J˜J˜$Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$J˜J˜Jšžœ˜#J˜šžœ�œ�œ
�œ
˜CJš�œ
˜—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˜šžœ�œ�œ
�œžœžœ˜hJš�œ˜—J˜J˜"Jšžœ˜,J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜,J˜š
žœ�œ�œ
�œžœ˜VJš�œ˜—J˜J˜$Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œžœ
˜MJš�œ˜—J˜J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œžœ
˜MJš�œ˜—J˜J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œžœ
˜MJš�œ˜—J˜J˜Jšžœ˜9J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜'J˜š
žœ�œ�œ
�œžœ
˜MJš�œ˜—J˜J˜Jšžœ˜9J˜Jš
œ
™
J˜Jšœ�œ�œ˜.Jšœ�œ�œ
˜"Jšž
œ
ž
œ
˜.J˜Jšžœ˜!J˜šžœ�œ�œ
�œž
œ
ž
œ˜cJš�œ
˜—J˜J˜Jšžœ˜1J˜Jš
œ	™	J˜Jšœ�œ�œ˜,Jšœ�œ�œ
˜!Jšžœ˜J˜Jšžœ˜J˜š
žœ�œ�œ
�œžœ
˜BJš�œ˜—J˜J˜Jšžœ˜.J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/J˜J˜Jšžœ˜8J˜šž œ�œ�œ
�œ
˜BJš�œ˜—J˜J˜(J˜Jš
œ™J˜Jšœ�œ�œ ˜FJšœ �œ�œ
˜.J˜J˜Jšžœ˜7J˜šžœ�œ�œ
�œ
˜AJš�œ˜—J˜J˜'J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜:Jš�œ˜—J˜J˜ J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,J˜J˜Jšžœ˜0J˜šžœ�œ�œ
�œ
˜?Jš�œ˜—J˜J˜%Jšžœ˜5J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœžœ˜4J˜Jšžœ˜/J˜šžœ�œ�œ
�œžœžœ˜rJš�œ˜—J˜J˜$Jšžœ˜4J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%J˜J˜Jšžœ˜%J˜šžœ�œ�œ
�œ
˜DJš�œ˜—J˜J˜Jšžœ˜2J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšœžœ˜J˜Jšžœ˜,J˜š
žœ�œ�œ
�œžœ
˜YJš�œ˜—J˜J˜%Jšž!œ˜9J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/Jšžœ˜J˜Jšžœ˜/J˜š
ž œ�œ�œ
�œžœ
˜PJš�œ˜—J˜J˜(Jšž$œ˜<J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!Jšžœ˜5J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜+J˜š
žœ�œ�œ
�œžœ˜VJš�œ˜—J˜J˜$Jšž œ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜+J˜š
žœ�œ�œ
�œžœ˜VJš�œ˜—J˜J˜$Jšž œ˜8J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœ˜J˜Jšžœ˜(J˜š
žœ�œ�œ
�œžœ˜RJš�œ˜—J˜J˜ Jšž!œ˜>J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜8J˜Jšžœ˜)J˜šžœ�œ�œ
�œžœžœ˜sJš�œ˜—J˜J˜!Jšž"œ˜?J˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$Jšž	œžœžœžœ˜ZJ˜Jšžœ˜%J˜šžœ�œ�œ
�œž	œžœžœžœ˜‘
Jš�œ˜—J˜J˜Jšžœ˜;J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœ˜J˜Jšžœ˜(J˜š
žœ�œ�œ
�œžœ˜RJš�œ˜—J˜J˜ Jšž#œ˜BJ˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜8J˜Jšžœ˜)J˜šžœ�œ�œ
�œžœžœ˜sJš�œ˜—J˜J˜!Jšž$œ˜CJ˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$Jšžœžœ˜,J˜Jšžœ˜%J˜šžœ�œ�œ
�œžœžœ˜cJš�œ˜—J˜J˜Jšž œ˜?Jš�œ˜J˜—…—Izdß