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

DIRECTORY
	SaffronAG5Def,
	SaffronAG4Def,
	SaffronAG9Def,
	SaffronAG7Def,
	SaffronAG1Def,
	SaffronAG2Def,
	SaffronAG6Def,
	SaffronGenericDef,
	ThreeC4Support,
	SaffronCG4Def USING[],
	SaffronATDef;

SaffronCG4Impl: CEDAR PROGRAM IMPORTS SaffronAG5Def, SaffronAG4Def, SaffronAG9Def, SaffronAG7Def, SaffronAG1Def, SaffronAG2Def, SaffronAG6Def EXPORTS SaffronCG4Def= 
BEGIN
OPEN SaffronAG5Def, SaffronAG4Def, SaffronAG9Def, SaffronAG7Def, SaffronAG1Def, SaffronAG2Def, SaffronAG6Def, SaffronGenericDef, ThreeC4Support, SaffronATDef;
SaffronCG4LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[184] _ Seerangea;
prodLinkArray[185] _ Seerangeb;
prodLinkArray[186] _ Seerangec;
prodLinkArray[187] _ Seeranged;
prodLinkArray[188] _ Seerangee;
prodLinkArray[189] _ Seetrashtrash;
prodLinkArray[190] _ Seetrashnull;
prodLinkArray[191] _ Seedefaultoptgetstrash;
prodLinkArray[192] _ Seedefaultoptgetsexportrash;
prodLinkArray[193] _ Seedefaultoptgets;
prodLinkArray[194] _ Seedefaultoptgetsexp;
prodLinkArray[195] _ Seeorderlistone;
prodLinkArray[196] _ Seeorderlistmore;
prodLinkArray[197] _ Seetrusted;
prodLinkArray[198] _ Seeoptrelationnegative;
prodLinkArray[199] _ Seeoptrelationpositive;
prodLinkArray[200] _ Seerelationtailrange;
prodLinkArray[201] _ Seerelationtailrelop;
prodLinkArray[202] _ Seerelopeq;
prodLinkArray[203] _ Seerelopne;
prodLinkArray[204] _ Seereloplt;
prodLinkArray[205] _ Seerelople;
prodLinkArray[206] _ Seerelopgt;
prodLinkArray[207] _ Seerelopge;
prodLinkArray[208] _ Seesharespresent;
prodLinkArray[209] _ Seesharesabsent;
prodLinkArray[210] _ Seestatementifthen;
prodLinkArray[211] _ Seestatementifthenelse;
prodLinkArray[212] _ Seestatementselect;
prodLinkArray[213] _ Seestatementbasicstmt;
prodLinkArray[214] _ Seebalstmtifthenelse;
prodLinkArray[215] _ Seebalstmtselect;
prodLinkArray[216] _ Seebalstmtbasicstmt;
prodLinkArray[217] _ Seebasicstmtexp;
prodLinkArray[218] _ Seebasicstmtassign;
prodLinkArray[219] _ Seebasicstmtmultiassign;
prodLinkArray[220] _ Seebasicstmtblock;
prodLinkArray[221] _ Seebasicstmtselect;
prodLinkArray[222] _ Seebasicstmtloopcontrol;
prodLinkArray[223] _ Seebasicstmtexit;
prodLinkArray[224] _ Seebasicstmtloop;
prodLinkArray[225] _ Seebasicstmti;
prodLinkArray[226] _ Seebasicstmtj;
prodLinkArray[227] _ Seebasicstmtreturn;
prodLinkArray[228] _ Seebasicstmttransfer;
prodLinkArray[229] _ Seebasicstmtfree;
prodLinkArray[230] _ Seebasicstmtwait;
prodLinkArray[231] _ Seebasicstmterror;
prodLinkArray[232] _ Seebasicstmtstop;
prodLinkArray[233] _ Seebasicstmtnull;
prodLinkArray[234] _ Seebasicstmtresume;
prodLinkArray[235] _ Seebasicstmtreject;
prodLinkArray[236] _ Seebasicstmtcontinue;
prodLinkArray[237] _ Seebasicstmtretry;
prodLinkArray[238] _ Seebasicstmtgetstate;
prodLinkArray[239] _ Seebasicstmtsetstate;
prodLinkArray[240] _ Seeforclauseassignation;
prodLinkArray[241] _ Seeforclauseiteration;
prodLinkArray[242] _ Seeforclauserepetition;
prodLinkArray[243] _ Seeforclauseempty;
prodLinkArray[244] _ Seecontrolidnew;
prodLinkArray[245] _ Seecontrolidold;
prodLinkArray[246] _ Seedirectionyes;
prodLinkArray[247] _ Seedirectionno;
prodLinkArray[248] _ Seedoexita;
prodLinkArray[249] _ Seedoexitb;
prodLinkArray[250] _ Seedoexitc;
prodLinkArray[251] _ Seedoexitd;
prodLinkArray[252] _ Seetransfersignal;
prodLinkArray[253] _ Seetransfererror;
prodLinkArray[254] _ Seetransferreturnwitherror;
prodLinkArray[255] _ Seetransferstart;
prodLinkArray[256] _ Seetransferrestart;
prodLinkArray[257] _ Seetransferjoin;
prodLinkArray[258] _ Seetransfernotify;
prodLinkArray[259] _ Seetransferbroadcast;
prodLinkArray[260] _ Seetransfertransferwith;
prodLinkArray[261] _ Seetransferreturnwith;
END;

Seerangea: 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[BuildRangetypeidProdNode[position, length, BuildTypeIdidProdNode[Id.position, Id.length, Id]], stack];
RETURN [stack]
END;

Seerangeb: 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[BuildRangesubrangeProdNode[position, length, BuildSubrangenamedProdNode[Id.position, interval.position + interval.length - Id.position, BuildTypeIdidProdNode[Id.position, Id.length, Id], interval]], stack];
RETURN [stack]
END;

Seerangec: 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[BuildRangesubrangeProdNode[position, length, BuildSubrangenamedProdNode[typeid.position, interval.position + interval.length - typeid.position, typeid, interval]], stack];
RETURN [stack]
END;

Seeranged: 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[BuildRangesubrangeProdNode[position, length, BuildSubrangeunnamedProdNode[interval.position, interval.length, interval]], stack];
RETURN [stack]
END;

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

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

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

Seedefaultoptgetstrash: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trash: JunkNode;
trash _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefaultgetstrashProdNode[position, length], stack];
RETURN [stack]
END;

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

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

Seedefaultoptgetsexp: 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[BuildDefaultgetsexpProdNode[position, length, exp], stack];
RETURN [stack]
END;

Seeorderlistone: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optexp: OptExpNode;
optexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOrderListoneProdNode[position, length, optexp], stack];
RETURN [stack]
END;

Seeorderlistmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
orderlist: OrderListNode;
optexp: OptExpNode;
optexp _ NARROW[stack.first];
stack _ stack.rest;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOrderListmoreProdNode[position, length, orderlist, optexp], stack];
RETURN [stack]
END;

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

Seeoptrelationnegative: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relationtail: RelationTailNode;
relationtail _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationnegativeProdNode[position, length, relationtail], stack];
RETURN [stack]
END;

Seeoptrelationpositive: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relationtail: RelationTailNode;
relationtail _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationpositiveProdNode[position, length, relationtail], stack];
RETURN [stack]
END;

Seerelationtailrange: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationTailrangeProdNode[position, length, range], stack];
RETURN [stack]
END;

Seerelationtailrelop: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relop: RelopNode;
sum: ExpNode;
sum _ NARROW[stack.first];
stack _ stack.rest;
relop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationTailrelopProdNode[position, length, relop, sum], stack];
RETURN [stack]
END;

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

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

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

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

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

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

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

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

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

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

Seestatementselect: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, BuildOptStatementpresentProdNode[statement.position, statement.length, statement]], stack];
RETURN [stack]
END;

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

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

Seebalstmtselect: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
balstmt: StatementNode;
balstmt _ NARROW[stack.first];
stack _ stack.rest;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, BuildOptStatementpresentProdNode[balstmt.position, balstmt.length, balstmt]], stack];
RETURN [stack]
END;

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

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

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

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

Seebasicstmtblock: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trusted: JunkNode;
checked: CheckedNode;
block: BlockNode;
block _ NARROW[stack.first];
stack _ stack.rest;
checked _ NARROW[stack.first];
stack _ stack.rest;
trusted _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementblockProdNode[position, length, checked, block], stack];
RETURN [stack]
END;

Seebasicstmtselect: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, BuildOptStatementabsentProdNode[casestmtlist.position + casestmtlist.length, casestmtlist.position + casestmtlist.length - casestmtlist.position - casestmtlist.length]], stack];
RETURN [stack]
END;

Seebasicstmtloopcontrol: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
forclause: ForClauseNode;
dotest: DoTestNode;
scope: ScopeNode;
doexit: DoExitNode;
doexit _ NARROW[stack.first];
stack _ stack.rest;
scope _ NARROW[stack.first];
stack _ stack.rest;
dotest _ NARROW[stack.first];
stack _ stack.rest;
forclause _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementloopcontrolProdNode[position, length, forclause, dotest, scope, doexit], stack];
RETURN [stack]
END;

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

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

Seebasicstmti: 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[BuildStatementgotoProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seebasicstmtj: 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[BuildStatementgotoProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seebasicstmtreturn: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optargs: OptArgsNode;
optargs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementreturnProdNode[position, length, optargs], stack];
RETURN [stack]
END;

Seebasicstmttransfer: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
transfer: TransferNode;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
transfer _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementtransferProdNode[position, length, transfer, lhs], stack];
RETURN [stack]
END;

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

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

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

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

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

Seebasicstmtresume: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optargs: OptArgsNode;
optargs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementresumeProdNode[position, length, optargs], stack];
RETURN [stack]
END;

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

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

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

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

Seebasicstmtsetstate: 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[BuildStatementsetstateProdNode[position, length, exp], stack];
RETURN [stack]
END;

Seeforclauseassignation: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
controlid: ControlIdNode;
expinitial: ExpNode;
expnext: ExpNode;
expnext _ NARROW[stack.first];
stack _ stack.rest;
expinitial _ NARROW[stack.first];
stack _ stack.rest;
controlid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauseassignationProdNode[position, length, controlid, expinitial, expnext], stack];
RETURN [stack]
END;

Seeforclauseiteration: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
controlid: ControlIdNode;
direction: DecreasingNode;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
direction _ NARROW[stack.first];
stack _ stack.rest;
controlid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauseiterationProdNode[position, length, controlid, direction, range], stack];
RETURN [stack]
END;

Seeforclauserepetition: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauserepetitionProdNode[position, length, range], stack];
RETURN [stack]
END;

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

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

Seecontrolidold: 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[BuildControlIdoldProdNode[position, length, Id], stack];
RETURN [stack]
END;

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

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

Seedoexita: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildDoExitProdNode[position, length, BuildExitListemptyProdNode[position, length], BuildOptStatementabsentProdNode[position, length]], stack];
RETURN [stack]
END;

Seedoexitb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementabsentProdNode[exitlist.position + exitlist.length, exitlist.position + exitlist.length - exitlist.position - exitlist.length]], stack];
RETURN [stack]
END;

Seedoexitc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementpresentProdNode[statement.position, statement.length, statement]], stack];
RETURN [stack]
END;

Seedoexitd: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementpresentProdNode[statement.position, statement.length, statement]], stack];
RETURN [stack]
END;

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

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

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

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

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

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

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

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

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

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

END..