DIRECTORY
	ThreeC4BaseDecl1Def,
	ThreeC4RecFcnImplAbGramDef,
	ThreeC4MiscAbGramDef,
	ThreeC4CSyntax2Def USING[],
	ThreeC4Support,
	ThreeC4FlowGraphAbGramDef,
	ThreeC4CProdAbGramDef,
	ThreeC4BasicAbTypesDef;

ThreeC4CSyntax2Impl: CEDAR PROGRAM IMPORTS ThreeC4RecFcnImplAbGramDef, ThreeC4MiscAbGramDef, ThreeC4FlowGraphAbGramDef, ThreeC4CProdAbGramDef EXPORTS ThreeC4CSyntax2Def= 
BEGIN
OPEN ThreeC4BaseDecl1Def, ThreeC4RecFcnImplAbGramDef, ThreeC4MiscAbGramDef, ThreeC4Support, ThreeC4FlowGraphAbGramDef, ThreeC4CProdAbGramDef, ThreeC4BasicAbTypesDef;
ThreeC4CSyntax2LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[42] ← SeeRecExpressionRecExp1;
prodLinkArray[43] ← SeeRecExpressionwithWhereList;
prodLinkArray[44] ← SeeRecExpressionwithLetList;
prodLinkArray[45] ← SeeRecExp1cond;
prodLinkArray[46] ← SeeRecExp1paranthesis;
prodLinkArray[47] ← SeeRecExp1call;
prodLinkArray[48] ← SeeRecExp1seq;
prodLinkArray[49] ← SeeRecExp1id;
prodLinkArray[50] ← SeeRecExp1modId;
prodLinkArray[51] ← SeeRecExp1rope;
prodLinkArray[52] ← SeeRecExp1numb;
prodLinkArray[53] ← SeeRecExp1sourcePosition;
prodLinkArray[54] ← SeeRecExp1sourceLength;
prodLinkArray[55] ← SeeOptionalRecExpSeqempty;
prodLinkArray[56] ← SeeOptionalRecExpSeqnonEmpty;
prodLinkArray[57] ← SeeRecExpSeqone;
prodLinkArray[58] ← SeeRecExpSeqmany;
prodLinkArray[59] ← SeeWhereExpSeqone;
prodLinkArray[60] ← SeeWhereExpSeqmany;
prodLinkArray[61] ← SeeWhereExponeId;
prodLinkArray[62] ← SeeWhereExpmanyIds;
prodLinkArray[63] ← SeeLetListone;
prodLinkArray[64] ← SeeLetListmany;
prodLinkArray[65] ← SeeLetExponeId;
prodLinkArray[66] ← SeeLetExpmanyIds;
prodLinkArray[67] ← SeeOptionalConcreteRightSideListempty;
prodLinkArray[68] ← SeeOptionalConcreteRightSideListnonEmpty;
prodLinkArray[69] ← SeeConcreteRightSideListone;
prodLinkArray[70] ← SeeConcreteRightSideListmany;
prodLinkArray[71] ← SeeConcreteRightSideItemrope;
prodLinkArray[72] ← SeeConcreteRightSideItemmodId;
prodLinkArray[73] ← SeeBuildExpmodId;
prodLinkArray[74] ← SeeBuildExpbuildNodeBoth;
prodLinkArray[75] ← SeeBuildExpbuildNodeListOnly;
prodLinkArray[76] ← SeeBuildExpbuildNodeIntervalOnly;
prodLinkArray[77] ← SeeBuildExpbuildNodeNeither;
prodLinkArray[78] ← SeeIntervalExpclosed;
prodLinkArray[79] ← SeeIntervalExpleftOpen;
prodLinkArray[80] ← SeeIntervalExprightOpen;
prodLinkArray[81] ← SeeIntervalExpfullOpen;
prodLinkArray[82] ← SeeBuildExpListone;
prodLinkArray[83] ← SeeBuildExpListmany;
prodLinkArray[84] ← SeeModIdoneId;
prodLinkArray[85] ← SeeModIdtwoIds;
prodLinkArray[86] ← SeeIdListone;
prodLinkArray[87] ← SeeIdListmany;
prodLinkArray[88] ← SeeOptionalModIdListempty;
prodLinkArray[89] ← SeeOptionalModIdListnonEmpty;
prodLinkArray[90] ← SeeModIdListone;
prodLinkArray[91] ← SeeModIdListmany;
prodLinkArray[92] ← SeeRopeListone;
prodLinkArray[93] ← SeeRopeListmany;
prodLinkArray[94] ← SeeDamageShareAssertionListempty;
prodLinkArray[95] ← SeeDamageShareAssertionListnonEmpty;
prodLinkArray[96] ← SeeDamageShareAssertionList1one;
prodLinkArray[97] ← SeeDamageShareAssertionList1many;
prodLinkArray[98] ← SeeDamageShareAssertiondamageAssertion;
prodLinkArray[99] ← SeeDamageShareAssertionshareAssertion;
END;

SeeRecExpressionRecExp1: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[RecExp1, stack];
RETURN[stack]
END;

SeeRecExpressionwithWhereList: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExp1: RecExpressionNode;
WhereExpSeq: WhereExpSeqNode;
WhereExpSeq ← NARROW[stack.first];
stack ← stack.rest;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionwithWhereListProdNode[position, length, RecExp1, WhereExpSeq], stack];
RETURN[stack]
END;

SeeRecExpressionwithLetList: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
LetList: WhereExpSeqNode;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
LetList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionwithWhereListProdNode[position, length, RecExp1, LetList], stack];
RETURN[stack]
END;

SeeRecExp1cond: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExp1ifClause: RecExpressionNode;
RecExp1thenClause: RecExpressionNode;
RecExp1elseClause: RecExpressionNode;
RecExp1elseClause ← NARROW[stack.first];
stack ← stack.rest;
RecExp1thenClause ← NARROW[stack.first];
stack ← stack.rest;
RecExp1ifClause ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressioncondProdNode[position, length, RecExp1ifClause, RecExp1thenClause, RecExp1elseClause], stack];
RETURN[stack]
END;

SeeRecExp1paranthesis: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExpression: RecExpressionNode;
RecExpression ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[RecExpression, stack];
RETURN[stack]
END;

SeeRecExp1call: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
OptionalRecExpSeq: RecExpSeqNode;
OptionalRecExpSeq ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressioncallProdNode[position, length, Identifier, OptionalRecExpSeq], stack];
RETURN[stack]
END;

SeeRecExp1seq: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExpSeq: RecExpSeqNode;
RecExpSeq ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionseqProdNode[position, length, RecExpSeq], stack];
RETURN[stack]
END;

SeeRecExp1id: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionidProdNode[position, length, Identifier], stack];
RETURN[stack]
END;

SeeRecExp1modId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifiera: IdentifierNode;
Identifierb: IdentifierNode;
Identifierb ← NARROW[stack.first];
stack ← stack.rest;
Identifiera ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionmodIdProdNode[position, length, Identifiera, Identifierb], stack];
RETURN[stack]
END;

SeeRecExp1rope: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Rope: RopeNode;
Rope ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionropeProdNode[position, length, Rope], stack];
RETURN[stack]
END;

SeeRecExp1numb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
NonNegInteger: NonNegIntegerNode;
NonNegInteger ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionnumbProdNode[position, length, NonNegInteger], stack];
RETURN[stack]
END;

SeeRecExp1sourcePosition: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionsourcePositionProdNode[position, length, ModId], stack];
RETURN[stack]
END;

SeeRecExp1sourceLength: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpressionsourceLengthProdNode[position, length, ModId], stack];
RETURN[stack]
END;

SeeOptionalRecExpSeqempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
stack ← CONS[BuildRecExpSeqemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeOptionalRecExpSeqnonEmpty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExpSeq: RecExpSeqNode;
RecExpSeq ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[RecExpSeq, stack];
RETURN[stack]
END;

SeeRecExpSeqone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExpression: RecExpressionNode;
RecExpression ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpSeqoneProdNode[position, length, RecExpression], stack];
RETURN[stack]
END;

SeeRecExpSeqmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecExpSeq: RecExpSeqNode;
RecExpression: RecExpressionNode;
RecExpression ← NARROW[stack.first];
stack ← stack.rest;
RecExpSeq ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecExpSeqmanyProdNode[position, length, RecExpSeq, BuildRecExpSeqoneProdNode[RecExpression.position, RecExpression.length, RecExpression]], stack];
RETURN[stack]
END;

SeeWhereExpSeqone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
WhereExp: WhereExpSeqNode;
WhereExp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[WhereExp, stack];
RETURN[stack]
END;

SeeWhereExpSeqmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
WhereExpSeq: WhereExpSeqNode;
WhereExp: WhereExpSeqNode;
WhereExp ← NARROW[stack.first];
stack ← stack.rest;
WhereExpSeq ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqmanyProdNode[position, length, WhereExpSeq, WhereExp], stack];
RETURN[stack]
END;

SeeWhereExponeId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqoneProdNode[position, length, BuildIdListnonEmptyProdNode[Identifier.position, Identifier.position + Identifier.length + Identifier.position + Identifier.length - Identifier.position - Identifier.length - Identifier.position, Identifier, BuildIdListEmptyProdNode[Identifier.position + Identifier.length, Identifier.position + Identifier.length - Identifier.position - Identifier.length]], RecExp1], stack];
RETURN[stack]
END;

SeeWhereExpmanyIds: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdList: IdListNode;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
IdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqoneProdNode[position, length, IdList, RecExp1], stack];
RETURN[stack]
END;

SeeLetListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
LetExp: WhereExpSeqNode;
LetExp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[LetExp, stack];
RETURN[stack]
END;

SeeLetListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
LetExp: WhereExpSeqNode;
LetList: WhereExpSeqNode;
LetList ← NARROW[stack.first];
stack ← stack.rest;
LetExp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqmanyProdNode[position, length, LetList, LetExp], stack];
RETURN[stack]
END;

SeeLetExponeId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqoneProdNode[position, length, BuildIdListnonEmptyProdNode[Identifier.position, Identifier.position + Identifier.length + Identifier.position + Identifier.length - Identifier.position - Identifier.length - Identifier.position, Identifier, BuildIdListEmptyProdNode[Identifier.position + Identifier.length, Identifier.position + Identifier.length - Identifier.position - Identifier.length]], RecExp1], stack];
RETURN[stack]
END;

SeeLetExpmanyIds: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdList: IdListNode;
RecExp1: RecExpressionNode;
RecExp1 ← NARROW[stack.first];
stack ← stack.rest;
IdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWhereExpSeqoneProdNode[position, length, IdList, RecExp1], stack];
RETURN[stack]
END;

SeeOptionalConcreteRightSideListempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
stack ← CONS[BuildConcreteRightSideListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeOptionalConcreteRightSideListnonEmpty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ConcreteRightSideList: ConcreteRightSideListNode;
ConcreteRightSideList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[ConcreteRightSideList, stack];
RETURN[stack]
END;

SeeConcreteRightSideListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ConcreteRightSideItem: ConcreteRightSideItemNode;
ConcreteRightSideItem ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildConcreteRightSideListoneProdNode[position, length, ConcreteRightSideItem], stack];
RETURN[stack]
END;

SeeConcreteRightSideListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ConcreteRightSideList: ConcreteRightSideListNode;
ConcreteRightSideItem: ConcreteRightSideItemNode;
ConcreteRightSideItem ← NARROW[stack.first];
stack ← stack.rest;
ConcreteRightSideList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildConcreteRightSideListmanyProdNode[position, length, ConcreteRightSideList, ConcreteRightSideItem], stack];
RETURN[stack]
END;

SeeConcreteRightSideItemrope: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Rope: RopeNode;
Rope ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildConcreteRightSideItemropeProdNode[position, length, Rope], stack];
RETURN[stack]
END;

SeeConcreteRightSideItemmodId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildConcreteRightSideItemmodIdProdNode[position, length, ModId], stack];
RETURN[stack]
END;

SeeBuildExpmodId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpmodIdProdNode[position, length, ModId], stack];
RETURN[stack]
END;

SeeBuildExpbuildNodeBoth: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
IntervalExp: IntervalExpNode;
BuildExpList: BuildExpListNode;
BuildExpList ← NARROW[stack.first];
stack ← stack.rest;
IntervalExp ← NARROW[stack.first];
stack ← stack.rest;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpbuildNodeProdNode[position, length, ModId, IntervalExp, BuildExpList], stack];
RETURN[stack]
END;

SeeBuildExpbuildNodeListOnly: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
BuildExpList: BuildExpListNode;
BuildExpList ← NARROW[stack.first];
stack ← stack.rest;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpbuildNodeProdNode[position, length, ModId, BuildIntervalExpnoneProdNode[BuildExpList.position, BuildExpList.position - BuildExpList.length], BuildExpList], stack];
RETURN[stack]
END;

SeeBuildExpbuildNodeIntervalOnly: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
IntervalExp: IntervalExpNode;
IntervalExp ← NARROW[stack.first];
stack ← stack.rest;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpbuildNodeProdNode[position, length, ModId, IntervalExp, BuildBuildExpListemptyProdNode[IntervalExp.position + IntervalExp.length, IntervalExp.position + IntervalExp.length - IntervalExp.position - IntervalExp.length]], stack];
RETURN[stack]
END;

SeeBuildExpbuildNodeNeither: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpbuildNodeProdNode[position, length, ModId, BuildIntervalExpnoneProdNode[ModId.position + ModId.length, ModId.position + ModId.length - ModId.position - ModId.length], BuildBuildExpListemptyProdNode[ModId.position + ModId.length, ModId.position + ModId.length - ModId.position - ModId.length]], stack];
RETURN[stack]
END;

SeeIntervalExpclosed: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdleft: ModIdNode;
ModIdright: ModIdNode;
ModIdright ← NARROW[stack.first];
stack ← stack.rest;
ModIdleft ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIntervalExppresentProdNode[position, length, IntervalForm.closed, ModIdleft, ModIdright], stack];
RETURN[stack]
END;

SeeIntervalExpleftOpen: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdleft: ModIdNode;
ModIdright: ModIdNode;
ModIdright ← NARROW[stack.first];
stack ← stack.rest;
ModIdleft ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIntervalExppresentProdNode[position, length, IntervalForm.leftOpen, ModIdleft, ModIdright], stack];
RETURN[stack]
END;

SeeIntervalExprightOpen: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdleft: ModIdNode;
ModIdright: ModIdNode;
ModIdright ← NARROW[stack.first];
stack ← stack.rest;
ModIdleft ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIntervalExppresentProdNode[position, length, IntervalForm.rightOpen, ModIdleft, ModIdright], stack];
RETURN[stack]
END;

SeeIntervalExpfullOpen: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdleft: ModIdNode;
ModIdright: ModIdNode;
ModIdright ← NARROW[stack.first];
stack ← stack.rest;
ModIdleft ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIntervalExppresentProdNode[position, length, IntervalForm.fullOpen, ModIdleft, ModIdright], stack];
RETURN[stack]
END;

SeeBuildExpListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
BuildExp: BuildExpNode;
BuildExp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpListoneProdNode[position, length, BuildExp], stack];
RETURN[stack]
END;

SeeBuildExpListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
BuildExpList: BuildExpListNode;
BuildExp: BuildExpNode;
BuildExp ← NARROW[stack.first];
stack ← stack.rest;
BuildExpList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBuildExpListmanyProdNode[position, length, BuildExpList, BuildExp], stack];
RETURN[stack]
END;

SeeModIdoneId: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModIdoneIdProdNode[position, length, Identifier], stack];
RETURN[stack]
END;

SeeModIdtwoIds: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifierleft: IdentifierNode;
Identifierright: IdentifierNode;
Identifierright ← NARROW[stack.first];
stack ← stack.rest;
Identifierleft ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModIdtwoIdsProdNode[position, length, Identifierleft, Identifierright], stack];
RETURN[stack]
END;

SeeIdListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListnonEmptyProdNode[position, length, Identifier, BuildIdListEmptyProdNode[Identifier.position + Identifier.length, Identifier.position + Identifier.length - Identifier.position - Identifier.length]], stack];
RETURN[stack]
END;

SeeIdListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
IdList: IdListNode;
IdList ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListnonEmptyProdNode[position, length, Identifier, IdList], stack];
RETURN[stack]
END;

SeeOptionalModIdListempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
stack ← CONS[BuildModIdListEmptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeOptionalModIdListnonEmpty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdList: ModIdListNode;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[ModIdList, stack];
RETURN[stack]
END;

SeeModIdListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModIdListManyProdNode[position, length, BuildModIdListEmptyProdNode[ModId.position, ModId.position - ModId.length], ModId], stack];
RETURN[stack]
END;

SeeModIdListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdList: ModIdListNode;
ModId: ModIdNode;
ModId ← NARROW[stack.first];
stack ← stack.rest;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModIdListManyProdNode[position, length, ModIdList, ModId], stack];
RETURN[stack]
END;

SeeRopeListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Rope: RopeNode;
Rope ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRopeListOneProdNode[position, length, Rope], stack];
RETURN[stack]
END;

SeeRopeListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RopeList: RopeListNode;
Rope: RopeNode;
Rope ← NARROW[stack.first];
stack ← stack.rest;
RopeList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRopeListManyProdNode[position, length, RopeList, Rope], stack];
RETURN[stack]
END;

SeeDamageShareAssertionListempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
stack ← CONS[BuildDamageShareAssertionsemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeDamageShareAssertionListnonEmpty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
DamageShareAssertionList: DamageShareAssertionsNode;
DamageShareAssertion: DamageShareAssertionNode;
DamageShareAssertion ← NARROW[stack.first];
stack ← stack.rest;
DamageShareAssertionList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDamageShareAssertionsmanyProdNode[position, length, DamageShareAssertionList, DamageShareAssertion], stack];
RETURN[stack]
END;

SeeDamageShareAssertionList1one: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
DamageShareAssertion: DamageShareAssertionNode;
DamageShareAssertion ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDamageShareAssertionsmanyProdNode[position, length, BuildDamageShareAssertionsemptyProdNode[DamageShareAssertion.position + DamageShareAssertion.length, DamageShareAssertion.position + DamageShareAssertion.length - DamageShareAssertion.position - DamageShareAssertion.length], DamageShareAssertion], stack];
RETURN[stack]
END;

SeeDamageShareAssertionList1many: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
DamageShareAssertionList1: DamageShareAssertionsNode;
DamageShareAssertion: DamageShareAssertionNode;
DamageShareAssertion ← NARROW[stack.first];
stack ← stack.rest;
DamageShareAssertionList1 ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDamageShareAssertionsmanyProdNode[position, length, DamageShareAssertionList1, DamageShareAssertion], stack];
RETURN[stack]
END;

SeeDamageShareAssertiondamageAssertion: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdList: ModIdListNode;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDamageShareAssertiondamagedRepsProdNode[position, length, ModIdList], stack];
RETURN[stack]
END;

SeeDamageShareAssertionshareAssertion: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModIdList: ModIdListNode;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDamageShareAssertionsharedRepsProdNode[position, length, ModIdList], stack];
RETURN[stack]
END;

END..