-- SaffronCG6Impl.mesa
 -- Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
 -- Generated by hederman.pa at August 17, 1987 3:57:27 pm PDT
 --  using ThreeCasabaFour [1.2] of June 1, 1987 6:00:00 pm PDT

DIRECTORY
	SaffronAG9Def,
	SaffronAG7Def,
	SaffronAG2Def,
	SaffronAG8Def,
	SaffronAG6Def,
	SaffronGenericDef,
	ThreeC4Support,
	SaffronCG6Def USING[],
	SaffronATDef;

SaffronCG6Impl: CEDAR PROGRAM IMPORTS SaffronAG9Def, SaffronAG7Def, SaffronAG2Def, SaffronAG8Def, SaffronAG6Def EXPORTS SaffronCG6Def= 
BEGIN
OPEN SaffronAG9Def, SaffronAG7Def, SaffronAG2Def, SaffronAG8Def, SaffronAG6Def, SaffronGenericDef, ThreeC4Support, SaffronATDef;
SaffronCG6LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[333] _ Seetypeconsa;
prodLinkArray[334] _ Seetypeconsb;
prodLinkArray[335] _ Seetypeconsc;
prodLinkArray[336] _ Seetypeconsenum;
prodLinkArray[337] _ Seetypeconsrecord;
prodLinkArray[338] _ Seetypeconspointer;
prodLinkArray[339] _ Seetypeconsvar;
prodLinkArray[340] _ Seetypeconsref;
prodLinkArray[341] _ Seetypeconsrefany;
prodLinkArray[342] _ Seetypeconsrefunspecified;
prodLinkArray[343] _ Seetypeconslist;
prodLinkArray[344] _ Seetypeconsarray;
prodLinkArray[345] _ Seetypeconsdescriptor;
prodLinkArray[346] _ Seetypeconstransfer;
prodLinkArray[347] _ Seetypeconso;
prodLinkArray[348] _ Seetypeconsp;
prodLinkArray[349] _ Seetypeconszone;
prodLinkArray[350] _ Seetypeconslong;
prodLinkArray[351] _ Seetypeconsframe;
prodLinkArray[352] _ Seetypeconst;
prodLinkArray[353] _ Seetypeconsu;
prodLinkArray[354] _ Seetypeconstypeapply;
prodLinkArray[355] _ Seedependentyes;
prodLinkArray[356] _ Seedependentno;
prodLinkArray[357] _ Seemonitoredyes;
prodLinkArray[358] _ Seemonitoredno;
prodLinkArray[359] _ Seeorderedyes;
prodLinkArray[360] _ Seeorderedno;
prodLinkArray[361] _ Seebaseyes;
prodLinkArray[362] _ Seebaseno;
prodLinkArray[363] _ Seepointertypeunspecified;
prodLinkArray[364] _ Seepointertypespecified;
prodLinkArray[365] _ Seepointerprefixabsent;
prodLinkArray[366] _ Seepointerprefixpresent;
prodLinkArray[367] _ Seeindextypepresent;
prodLinkArray[368] _ Seeindextypeabsent;
prodLinkArray[369] _ Seetransfermodea;
prodLinkArray[370] _ Seetransfermodeb;
prodLinkArray[371] _ Seetransfermodeport;
prodLinkArray[372] _ Seetransfermodesignal;
prodLinkArray[373] _ Seetransfermodeerror;
prodLinkArray[374] _ Seetransfermodeprocess;
prodLinkArray[375] _ Seetransfermodeprogram;
prodLinkArray[376] _ Seeelementlistempty;
prodLinkArray[377] _ Seeelementlistb;
prodLinkArray[378] _ SeeelementlistPa;
prodLinkArray[379] _ SeeelementlistPb;
prodLinkArray[380] _ Seeelementidwithrep;
prodLinkArray[381] _ Seeelementanon;
prodLinkArray[382] _ Seeelementid;
prodLinkArray[383] _ Seeheapyes;
prodLinkArray[384] _ Seeheapno;
prodLinkArray[385] _ Seetypeappla;
prodLinkArray[386] _ Seetypeapplb;
prodLinkArray[387] _ Seetypeapplc;
prodLinkArray[388] _ Seetypeappld;
prodLinkArray[389] _ SeelengthP;
prodLinkArray[390] _ Seereclista;
prodLinkArray[391] _ Seereclistb;
prodLinkArray[392] _ Seereclistc;
prodLinkArray[393] _ Seereclistd;
prodLinkArray[394] _ Seerecliste;
prodLinkArray[395] _ Seereclistf;
prodLinkArray[396] _ Seereclistg;
prodLinkArray[397] _ Seevariantpair;
prodLinkArray[398] _ Seevariantparta;
prodLinkArray[399] _ Seevariantpartb;
prodLinkArray[400] _ Seevariantpartc;
prodLinkArray[401] _ Seevcaseheadident;
prodLinkArray[402] _ Seevcaseheadcomputed;
prodLinkArray[403] _ Seevcaseheadoverlaid;
prodLinkArray[404] _ Seetagtypestar;
prodLinkArray[405] _ Seetagtypetypeexp;
prodLinkArray[406] _ Seevariantlistone;
prodLinkArray[407] _ Seevariantlistmore;
prodLinkArray[408] _ Seevariantitem;
prodLinkArray[409] _ Seepackedyes;
prodLinkArray[410] _ Seepackedno;
prodLinkArray[411] _ Seeimportsa;
prodLinkArray[412] _ Seeimportsb;
prodLinkArray[413] _ Seeimportsc;
prodLinkArray[414] _ Seeopttypepresent;
prodLinkArray[415] _ Seeopttypeabsent;
END;

Seetypeconsa: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpsubrangeProdNode[position, length, BuildSubrangeunnamedProdNode[interval.position, interval.length, interval]], stack];
RETURN [stack]
END;

Seetypeconsb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpsubrangeProdNode[position, length, BuildSubrangenamedProdNode[Id.position, interval.position + interval.length - Id.position, BuildTypeIdidProdNode[Id.position, Id.length, Id], interval]], stack];
RETURN [stack]
END;

Seetypeconsc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpsubrangeProdNode[position, length, BuildSubrangenamedProdNode[typeid.position, interval.position + interval.length - typeid.position, typeid, interval]], stack];
RETURN [stack]
END;

Seetypeconsenum: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
dependent: MachineDependentNode;
elementlist: ElementListNode;
elementlist _ NARROW[stack.first];
stack _ stack.rest;
dependent _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpenumProdNode[position, length, dependent, elementlist], stack];
RETURN [stack]
END;

Seetypeconsrecord: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
dependent: MachineDependentNode;
monitored: MonitoredNode;
reclist: RecListNode;
reclist _ NARROW[stack.first];
stack _ stack.rest;
monitored _ NARROW[stack.first];
stack _ stack.rest;
dependent _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExprecordProdNode[position, length, dependent, monitored, reclist], stack];
RETURN [stack]
END;

Seetypeconspointer: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ordered: OrderedNode;
base: BaseNode;
pointertype: PointerTypeNode;
pointertype _ NARROW[stack.first];
stack _ stack.rest;
base _ NARROW[stack.first];
stack _ stack.rest;
ordered _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExppointerProdNode[position, length, ordered, base, pointertype], stack];
RETURN [stack]
END;

Seetypeconsvar: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpvarProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seetypeconsref: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
readonly: ReadOnlyNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
readonly _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExprefProdNode[position, length, readonly, typeexp], stack];
RETURN [stack]
END;

Seetypeconsrefany: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
readonly: ReadOnlyNode;
readonly _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExprefanyProdNode[position, length, readonly], stack];
RETURN [stack]
END;

Seetypeconsrefunspecified: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeExprefunspecifiedProdNode[position, length], stack];
RETURN [stack]
END;

Seetypeconslist: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
readonly: ReadOnlyNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
readonly _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExplistProdNode[position, length, readonly, typeexp], stack];
RETURN [stack]
END;

Seetypeconsarray: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
packed: PackedNode;
indextype: OptTypeNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
indextype _ NARROW[stack.first];
stack _ stack.rest;
packed _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExparrayProdNode[position, length, packed, indextype, typeexp], stack];
RETURN [stack]
END;

Seetypeconsdescriptor: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
readonly: ReadOnlyNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
readonly _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpdescriptorProdNode[position, length, readonly, typeexp], stack];
RETURN [stack]
END;

Seetypeconstransfer: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
safe: SafeNode;
transfermode: TransferModeNode;
arguments: ArgumentsNode;
arguments _ NARROW[stack.first];
stack _ stack.rest;
transfermode _ NARROW[stack.first];
stack _ stack.rest;
safe _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExptransferProdNode[position, length, safe, transfermode, arguments], stack];
RETURN [stack]
END;

Seetypeconso: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExprelativeProdNode[position, length, BuildTypeIdidProdNode[Id.position, Id.length, Id], typeexp], stack];
RETURN [stack]
END;

Seetypeconsp: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExprelativeProdNode[position, length, typeid, typeexp], stack];
RETURN [stack]
END;

Seetypeconszone: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
heap: UncountedNode;
heap _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpzoneProdNode[position, length, heap], stack];
RETURN [stack]
END;

Seetypeconslong: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExplongProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seetypeconsframe: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpframeProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seetypeconst: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExppaintedProdNode[position, length, BuildTypeIdidProdNode[Id.position, Id.length, Id], typeexp], stack];
RETURN [stack]
END;

Seetypeconsu: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExppaintedProdNode[position, length, typeid, typeexp], stack];
RETURN [stack]
END;

Seetypeconstypeapply: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeappl: TypeApplyNode;
typeappl _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExptypeapplyProdNode[position, length, typeappl], stack];
RETURN [stack]
END;

Seedependentyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildMachineDependentyesProdNode[position, length], stack];
RETURN [stack]
END;

Seedependentno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildMachineDependentnoProdNode[position, length], stack];
RETURN [stack]
END;

Seemonitoredyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildMonitoredyesProdNode[position, length], stack];
RETURN [stack]
END;

Seemonitoredno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildMonitorednoProdNode[position, length], stack];
RETURN [stack]
END;

Seeorderedyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOrderedyesProdNode[position, length], stack];
RETURN [stack]
END;

Seeorderedno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOrderednoProdNode[position, length], stack];
RETURN [stack]
END;

Seebaseyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildBaseyesProdNode[position, length], stack];
RETURN [stack]
END;

Seebaseno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildBasenoProdNode[position, length], stack];
RETURN [stack]
END;

Seepointertypeunspecified: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
pointerprefix: OptIntervalNode;
pointerprefix _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildPointerTypeunspecifiedProdNode[position, length, pointerprefix], stack];
RETURN [stack]
END;

Seepointertypespecified: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
pointerprefix: OptIntervalNode;
readonly: ReadOnlyNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
readonly _ NARROW[stack.first];
stack _ stack.rest;
pointerprefix _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildPointerTypespecifiedProdNode[position, length, pointerprefix, readonly, typeexp], stack];
RETURN [stack]
END;

Seepointerprefixabsent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOptIntervalabsentProdNode[position, length], stack];
RETURN [stack]
END;

Seepointerprefixpresent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptIntervalpresentProdNode[position, length, interval], stack];
RETURN [stack]
END;

Seeindextypepresent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptTypepresentProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeindextypeabsent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOptTypeabsentProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodea: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeprocProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodeb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeprocProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodeport: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeportProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodesignal: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModesignalProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodeerror: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeerrorProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodeprocess: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeprocessProdNode[position, length], stack];
RETURN [stack]
END;

Seetransfermodeprogram: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferModeprogramProdNode[position, length], stack];
RETURN [stack]
END;

Seeelementlistempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildElementListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seeelementlistb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
elementlistP: ElementListNode;
elementlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[elementlistP, stack];
RETURN [stack]
END;

SeeelementlistPa: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
element: ElementNode;
element _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListmoreProdNode[position, length, BuildElementListemptyProdNode[element.position, element.position - element.length], element], stack];
RETURN [stack]
END;

SeeelementlistPb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
elementlistP: ElementListNode;
element: ElementNode;
element _ NARROW[stack.first];
stack _ stack.rest;
elementlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListmoreProdNode[position, length, elementlistP, element], stack];
RETURN [stack]
END;

Seeelementidwithrep: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementidwithrepProdNode[position, length, Id, exp], stack];
RETURN [stack]
END;

Seeelementanon: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementanonymousrepProdNode[position, length, exp], stack];
RETURN [stack]
END;

Seeelementid: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementidProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seeheapyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildUncountedyesProdNode[position, length], stack];
RETURN [stack]
END;

Seeheapno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildUncountednoProdNode[position, length], stack];
RETURN [stack]
END;

Seetypeappla: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeappl: TypeApplyNode;
Id: IdNode;
Id _ NARROW[stack.first];
stack _ stack.rest;
typeappl _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeApplymoreidsProdNode[position, length, typeappl, Id], stack];
RETURN [stack]
END;

Seetypeapplb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
lengthP: ExpNode;
lengthP _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeApplyoneProdNode[position, length, BuildTypeIdidProdNode[Id.position, Id.length, Id], lengthP], stack];
RETURN [stack]
END;

Seetypeapplc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
lengthP: ExpNode;
lengthP _ NARROW[stack.first];
stack _ stack.rest;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeApplyoneProdNode[position, length, typeid, lengthP], stack];
RETURN [stack]
END;

Seetypeappld: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeappl: TypeApplyNode;
lengthP: ExpNode;
lengthP _ NARROW[stack.first];
stack _ stack.rest;
typeappl _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeApplymorelengthsProdNode[position, length, typeappl, lengthP], stack];
RETURN [stack]
END;

SeelengthP: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[exp, stack];
RETURN [stack]
END;

Seereclista: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildRecListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seereclistb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildRecListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seereclistc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
pairlist: PairListNode;
pairlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRecListpairlistProdNode[position, length, pairlist], stack];
RETURN [stack]
END;

Seereclistd: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typelist: TypeListNode;
typelist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRecListtypelistProdNode[position, length, typelist], stack];
RETURN [stack]
END;

Seerecliste: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
pairlist: PairListNode;
variantpair: PairItemNode;
variantpair _ NARROW[stack.first];
stack _ stack.rest;
pairlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRecListpairlistProdNode[position, length, BuildPairListmanyProdNode[pairlist.position, variantpair.position + variantpair.length - pairlist.position, pairlist, BuildPairListoneProdNode[variantpair.position, variantpair.length, variantpair]]], stack];
RETURN [stack]
END;

Seereclistf: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
variantpart: TypeExpNode;
default: DefaultNode;
default _ NARROW[stack.first];
stack _ stack.rest;
variantpart _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRecListtypelistProdNode[position, length, BuildTypeListoneProdNode[variantpart.position, default.position + default.length - variantpart.position, BuildTypeItemProdNode[variantpart.position, default.position + default.length - variantpart.position, variantpart, default]]], stack];
RETURN [stack]
END;

Seereclistg: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
variantpair: PairItemNode;
variantpair _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRecListpairlistProdNode[position, length, BuildPairListoneProdNode[variantpair.position, variantpair.length, variantpair]], stack];
RETURN [stack]
END;

Seevariantpair: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identlist: IdentListNode;
public: AccessNode;
variantpart: TypeExpNode;
default: DefaultNode;
default _ NARROW[stack.first];
stack _ stack.rest;
variantpart _ NARROW[stack.first];
stack _ stack.rest;
public _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildPairItemProdNode[position, length, identlist, public, variantpart, default], stack];
RETURN [stack]
END;

Seevariantparta: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
vcasehead: TagNode;
variantlist: VariantListNode;
variantlist _ NARROW[stack.first];
stack _ stack.rest;
vcasehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpunionProdNode[position, length, vcasehead, variantlist], stack];
RETURN [stack]
END;

Seevariantpartb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
vcasehead: TagNode;
variantlist: VariantListNode;
variantlist _ NARROW[stack.first];
stack _ stack.rest;
vcasehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpunionProdNode[position, length, vcasehead, variantlist], stack];
RETURN [stack]
END;

Seevariantpartc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
packed: PackedNode;
vcasehead: TagNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
vcasehead _ NARROW[stack.first];
stack _ stack.rest;
packed _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeExpsequenceProdNode[position, length, packed, vcasehead, typeexp], stack];
RETURN [stack]
END;

Seevcaseheadident: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ident: IdentNode;
public: AccessNode;
tagtype: TagTypeNode;
tagtype _ NARROW[stack.first];
stack _ stack.rest;
public _ NARROW[stack.first];
stack _ stack.rest;
ident _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTagidentProdNode[position, length, ident, public, tagtype], stack];
RETURN [stack]
END;

Seevcaseheadcomputed: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
tagtype: TagTypeNode;
tagtype _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTagcomputedProdNode[position, length, tagtype], stack];
RETURN [stack]
END;

Seevcaseheadoverlaid: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
tagtype: TagTypeNode;
tagtype _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTagoverlaidProdNode[position, length, tagtype], stack];
RETURN [stack]
END;

Seetagtypestar: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTagTypestarProdNode[position, length], stack];
RETURN [stack]
END;

Seetagtypetypeexp: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTagTypetypeexpProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seevariantlistone: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
variantitem: VariantItemNode;
variantitem _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildVariantListoneProdNode[position, length, variantitem], stack];
RETURN [stack]
END;

Seevariantlistmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
variantlist: VariantListNode;
variantitem: VariantItemNode;
variantitem _ NARROW[stack.first];
stack _ stack.rest;
variantlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildVariantListmoreProdNode[position, length, variantlist, variantitem], stack];
RETURN [stack]
END;

Seevariantitem: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
idlist: IdListNode;
reclist: RecListNode;
reclist _ NARROW[stack.first];
stack _ stack.rest;
idlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildVariantItemProdNode[position, length, idlist, reclist], stack];
RETURN [stack]
END;

Seepackedyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildPackedyesProdNode[position, length], stack];
RETURN [stack]
END;

Seepackedno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildPackednoProdNode[position, length], stack];
RETURN [stack]
END;

Seeimportsa: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildModuleListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seeimportsb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
modulelist: ModuleListNode;
modulelist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[modulelist, stack];
RETURN [stack]
END;

Seeimportsc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildModuleListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seeopttypepresent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptTypepresentProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeopttypeabsent: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOptTypeabsentProdNode[position, length], stack];
RETURN [stack]
END;

END..