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..