File [Cyan]<CedarChest6.1>ThreeCasabaFour>ThreeC4CSyntax1Impl.mesa!2

DIRECTORY
	ThreeC4CSyntax1Def USING[],
	ThreeC4BaseDecl1Def,
	ThreeC4RecFcnImplAbGramDef,
	ThreeC4MiscAbGramDef,
	ThreeC4Support,
	ThreeC4RootAbGramDef,
	ThreeC4CProdAbGramDef,
	ThreeC4BasicAbTypesDef,
	ThreeC4OtherModItemsAbGramDef,
	ThreeC4ModItemAbGramDef;

ThreeC4CSyntax1Impl: CEDAR PROGRAM IMPORTS ThreeC4RecFcnImplAbGramDef, ThreeC4MiscAbGramDef, ThreeC4RootAbGramDef, ThreeC4CProdAbGramDef, ThreeC4OtherModItemsAbGramDef, ThreeC4ModItemAbGramDef EXPORTS ThreeC4CSyntax1Def= 
BEGIN
OPEN ThreeC4BaseDecl1Def, ThreeC4RecFcnImplAbGramDef, ThreeC4MiscAbGramDef, ThreeC4Support, ThreeC4RootAbGramDef, ThreeC4CProdAbGramDef, ThreeC4BasicAbTypesDef, ThreeC4OtherModItemsAbGramDef, ThreeC4ModItemAbGramDef;
ThreeC4CSyntax1LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[0] ← SeeMainGoal;
prodLinkArray[1] ← SeeWholeFile;
prodLinkArray[2] ← SeeOptionalIncludeClauseempty;
prodLinkArray[3] ← SeeOptionalIncludeClausenonEmpty;
prodLinkArray[4] ← SeeModuleListone;
prodLinkArray[5] ← SeeModuleListmany;
prodLinkArray[6] ← SeeModuleBodycontrol;
prodLinkArray[7] ← SeeModuleBodynormalNoSemi;
prodLinkArray[8] ← SeeModuleBodynormalSemi;
prodLinkArray[9] ← SeeModuleItemListone;
prodLinkArray[10] ← SeeModuleItemListmany;
prodLinkArray[11] ← SeeModuleItemcedarItems;
prodLinkArray[12] ← SeeModuleItembaseItems;
prodLinkArray[13] ← SeeModuleItemabGramItems;
prodLinkArray[14] ← SeeModuleItemcGramItems;
prodLinkArray[15] ← SeeModuleItemgenTkn;
prodLinkArray[16] ← SeeCedarItemscedarTypesFromOne;
prodLinkArray[17] ← SeeCedarItemscedarTypesFromMany;
prodLinkArray[18] ← SeeCedarItemscedarTypesOne;
prodLinkArray[19] ← SeeCedarItemscedarTypesMany;
prodLinkArray[20] ← SeeCedarItemscedarEnumTypeFrom;
prodLinkArray[21] ← SeeCedarItemscedarFnFrom;
prodLinkArray[22] ← SeeCedarItemscedarFnFrom1;
prodLinkArray[23] ← SeeCGramItemssimpleTokens;
prodLinkArray[24] ← SeeCGramItemsnonTerminal;
prodLinkArray[25] ← SeeCGramItemsconcreteProduction;
prodLinkArray[26] ← SeeBaseItemsoneBaseType;
prodLinkArray[27] ← SeeBaseItemsmanyBaseTypes;
prodLinkArray[28] ← SeeBaseItemsenumBaseType;
prodLinkArray[29] ← SeeBaseItemsbaseFcn;
prodLinkArray[30] ← SeeBaseItemstreeRecFcn;
prodLinkArray[31] ← SeeOptionalArgModIdListempty1;
prodLinkArray[32] ← SeeOptionalArgModIdListempty2;
prodLinkArray[33] ← SeeOptionalArgModIdListpresent;
prodLinkArray[34] ← SeeAbGramItemsabType;
prodLinkArray[35] ← SeeAbGramItemsabProdTwoIds;
prodLinkArray[36] ← SeeAbGramItemsabProdOneId;
prodLinkArray[37] ← SeeAbGramItemsabProdFcnImpl;
prodLinkArray[38] ← SeeAbProductionFcnImploneId;
prodLinkArray[39] ← SeeAbProductionFcnImpltwoIds;
prodLinkArray[40] ← SeeRecFcnImplListone;
prodLinkArray[41] ← SeeRecFcnImplListmany;
END;

SeeMainGoal: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
WholeFile: WholeFileNode;
WholeFile ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildMainGoalProdNode[position, length, WholeFile], stack];
RETURN[stack]
END;

SeeWholeFile: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
OptionalIncludeClause: IncludeClauseNode;
ModuleList: ModuleListNode;
ModuleList ← NARROW[stack.first];
stack ← stack.rest;
OptionalIncludeClause ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildWholeFileProdNode[position, length, OptionalIncludeClause, ModuleList], stack];
RETURN[stack]
END;

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

SeeOptionalIncludeClausenonEmpty: 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[BuildIncludeClauseProdNode[position, length, IdList], stack];
RETURN[stack]
END;

SeeModuleListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModuleBody: ModuleBodyNode;
ModuleBody ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleListOneProdNode[position, length, ModuleBody], stack];
RETURN[stack]
END;

SeeModuleListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModuleList: ModuleListNode;
ModuleBody: ModuleBodyNode;
ModuleBody ← NARROW[stack.first];
stack ← stack.rest;
ModuleList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleListManyProdNode[position, length, ModuleList, ModuleBody], stack];
RETURN[stack]
END;

SeeModuleBodycontrol: 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[BuildModuleBodycontrolProdNode[position, length, Identifier], stack];
RETURN[stack]
END;

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

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

SeeModuleItemListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModuleItem: ModuleItemNode;
ModuleItem ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItemListOneProdNode[position, length, ModuleItem], stack];
RETURN[stack]
END;

SeeModuleItemListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModuleItemList: ModuleItemListNode;
ModuleItem: ModuleItemNode;
ModuleItem ← NARROW[stack.first];
stack ← stack.rest;
ModuleItemList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItemListManyProdNode[position, length, ModuleItemList, ModuleItem], stack];
RETURN[stack]
END;

SeeModuleItemcedarItems: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
CedarItems: CedarItemsNode;
CedarItems ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItemcedarItemsProdNode[position, length, CedarItems], stack];
RETURN[stack]
END;

SeeModuleItembaseItems: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
BaseItems: BaseItemsNode;
BaseItems ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItembaseItemsProdNode[position, length, BaseItems], stack];
RETURN[stack]
END;

SeeModuleItemabGramItems: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
AbGramItems: AbGramItemsNode;
AbGramItems ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItemabGramItemsProdNode[position, length, AbGramItems], stack];
RETURN[stack]
END;

SeeModuleItemcGramItems: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
CGramItems: CGramItemsNode;
CGramItems ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleItemcGramItemsProdNode[position, length, CGramItems], stack];
RETURN[stack]
END;

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

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

SeeCedarItemscedarTypesFromMany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdentifiertName: IdentifierNode;
IdList: IdListNode;
IdentifierfName: IdentifierNode;
IdentifierfName ← NARROW[stack.first];
stack ← stack.rest;
IdList ← NARROW[stack.first];
stack ← stack.rest;
IdentifiertName ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildCedarItemscedarTypesFromProdNode[position, length, BuildIdListnonEmptyProdNode[IdentifiertName.position, IdList.position + IdList.length - IdentifiertName.position, IdentifiertName, IdList], IdentifierfName], stack];
RETURN[stack]
END;

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

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

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

SeeCedarItemscedarFnFrom: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdentifierfnName: IdentifierNode;
OptionalArgModIdList: ModIdListNode;
ModIdList: ModIdListNode;
IdentifierfName: IdentifierNode;
DamageShareAssertionList: DamageShareAssertionsNode;
DamageShareAssertionList ← NARROW[stack.first];
stack ← stack.rest;
IdentifierfName ← NARROW[stack.first];
stack ← stack.rest;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
OptionalArgModIdList ← NARROW[stack.first];
stack ← stack.rest;
IdentifierfnName ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildCedarItemscedarFunctionFromProdNode[position, length, IdentifierfnName, OptionalArgModIdList, ModIdList, IdentifierfName, DamageShareAssertionList], stack];
RETURN[stack]
END;

SeeCedarItemscedarFnFrom1: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdentifierfnName: IdentifierNode;
OptionalArgModIdList: ModIdListNode;
ModIdList: ModIdListNode;
DamageShareAssertionList1: DamageShareAssertionsNode;
IdentifierfName: IdentifierNode;
IdentifierfName ← NARROW[stack.first];
stack ← stack.rest;
DamageShareAssertionList1 ← NARROW[stack.first];
stack ← stack.rest;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
OptionalArgModIdList ← NARROW[stack.first];
stack ← stack.rest;
IdentifierfnName ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildCedarItemscedarFunctionFromProdNode[position, length, IdentifierfnName, OptionalArgModIdList, ModIdList, IdentifierfName, DamageShareAssertionList1], stack];
RETURN[stack]
END;

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

SeeCGramItemsnonTerminal: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
IdentifierntName: IdentifierNode;
IdentifierfName: IdentifierNode;
IdentifierfName ← NARROW[stack.first];
stack ← stack.rest;
IdentifierntName ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildCGramItemsnonTerminalProdNode[position, length, IdentifierntName, IdentifierfName], stack];
RETURN[stack]
END;

SeeCGramItemsconcreteProduction: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ModId: ModIdNode;
OptionalConcreteRightSideList: ConcreteRightSideListNode;
BuildExp: BuildExpNode;
BuildExp ← NARROW[stack.first];
stack ← stack.rest;
OptionalConcreteRightSideList ← NARROW[stack.first];
stack ← stack.rest;
ModId ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildCGramItemsconcreteProductionProdNode[position, length, BuildConcreteProductionProdNode[ModId.position, BuildExp.position + BuildExp.length - ModId.position, ModId, OptionalConcreteRightSideList, BuildExp]], stack];
RETURN[stack]
END;

SeeBaseItemsoneBaseType: 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[BuildBaseItemsbaseTypesProdNode[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]]], stack];
RETURN[stack]
END;

SeeBaseItemsmanyBaseTypes: 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[BuildBaseItemsbaseTypesProdNode[position, length, BuildIdListnonEmptyProdNode[Identifier.position, IdList.position + IdList.length - Identifier.position, Identifier, IdList]], stack];
RETURN[stack]
END;

SeeBaseItemsenumBaseType: 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[BuildBaseItemsenumBaseTypeProdNode[position, length, Identifier, IdList], stack];
RETURN[stack]
END;

SeeBaseItemsbaseFcn: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
OptionalArgModIdList: ModIdListNode;
ModIdList: ModIdListNode;
DamageShareAssertionList: DamageShareAssertionsNode;
DamageShareAssertionList ← NARROW[stack.first];
stack ← stack.rest;
ModIdList ← NARROW[stack.first];
stack ← stack.rest;
OptionalArgModIdList ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBaseItemsbaseFcnProdNode[position, length, Identifier, OptionalArgModIdList, ModIdList, DamageShareAssertionList], stack];
RETURN[stack]
END;

SeeBaseItemstreeRecFcn: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
Identifier: IdentifierNode;
ModIdListargs: ModIdListNode;
ModIdListresults: ModIdListNode;
DamageShareAssertionList: DamageShareAssertionsNode;
DamageShareAssertionList ← NARROW[stack.first];
stack ← stack.rest;
ModIdListresults ← NARROW[stack.first];
stack ← stack.rest;
ModIdListargs ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildBaseItemstreeRecFcnProdNode[position, length, Identifier, ModIdListargs, ModIdListresults, DamageShareAssertionList], stack];
RETURN[stack]
END;

SeeOptionalArgModIdListempty1: 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;

SeeOptionalArgModIdListempty2: 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;

SeeOptionalArgModIdListpresent: 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;

SeeAbGramItemsabType: 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[BuildAbGramItemsabTypeProdNode[position, length, Identifier, IdList], stack];
RETURN[stack]
END;

SeeAbGramItemsabProdTwoIds: 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;
OptionalModIdList: ModIdListNode;
OptionalModIdList ← NARROW[stack.first];
stack ← stack.rest;
Identifierb ← NARROW[stack.first];
stack ← stack.rest;
Identifiera ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildAbGramItemsabProdProdNode[position, length, BuildModIdtwoIdsProdNode[Identifiera.position, Identifierb.position + Identifierb.length - Identifiera.position, Identifiera, Identifierb], OptionalModIdList], stack];
RETURN[stack]
END;

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

SeeAbGramItemsabProdFcnImpl: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
AbProductionFcnImpl: AbProductionFcnImplNode;
AbProductionFcnImpl ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildAbGramItemsabProdFcnImplProdNode[position, length, AbProductionFcnImpl], stack];
RETURN[stack]
END;

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

SeeAbProductionFcnImpltwoIds: 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;
OptionalModIdList: ModIdListNode;
RecFcnImplList: RecFcnImplListNode;
RecFcnImplList ← NARROW[stack.first];
stack ← stack.rest;
OptionalModIdList ← NARROW[stack.first];
stack ← stack.rest;
Identifierb ← NARROW[stack.first];
stack ← stack.rest;
Identifiera ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildAbProductionFcnImplProdNode[position, length, BuildModIdtwoIdsProdNode[Identifiera.position, Identifierb.position + Identifierb.length - Identifiera.position, Identifiera, Identifierb], OptionalModIdList, RecFcnImplList], stack];
RETURN[stack]
END;

SeeRecFcnImplListone: 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;
RecExpression: RecExpressionNode;
RecExpression ← NARROW[stack.first];
stack ← stack.rest;
IdList ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecFcnImplListoneProdNode[position, length, Identifier, IdList, RecExpression], stack];
RETURN[stack]
END;

SeeRecFcnImplListmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
RecFcnImplList: RecFcnImplListNode;
Identifier: IdentifierNode;
IdList: IdListNode;
RecExpression: RecExpressionNode;
RecExpression ← NARROW[stack.first];
stack ← stack.rest;
IdList ← NARROW[stack.first];
stack ← stack.rest;
Identifier ← NARROW[stack.first];
stack ← stack.rest;
RecFcnImplList ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildRecFcnImplListmanyProdNode[position, length, RecFcnImplList, BuildRecFcnImplListoneProdNode[Identifier.position, RecExpression.position + RecExpression.length - Identifier.position, Identifier, IdList, RecExpression]], stack];
RETURN[stack]
END;

END..