DIRECTORY
	Rope,
	KipperMain1Def,
	ThreeC4Support;

KipperMain1Impl: CEDAR PROGRAM IMPORTS Rope, KipperMain1Def, ThreeC4Support EXPORTS KipperMain1Def= 
BEGIN
OPEN Rope, KipperMain1Def, ThreeC4Support;
KipperMain1LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
tknLinkArray[tokenID] ← BuildidNode;
END;


-- JunkProd

JunkProdProcs: PUBLIC JunkNodeProcs ←
	NEW[JunkNodeProcsBody ← [JunkProdfoo]];

BuildJunkProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[JunkNode] =
		BEGIN
		RETURN[NEW[JunkNodeBody←[position, length, JunkProdProcs, NIL]]];
		END;

JunkProdfoo: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: INT] =
BEGIN
tree: JunkNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← 0;
END
END;


--id

BuildidNode: PUBLIC PROC[text: Rope.ROPE, firstCharPosition: INT] RETURNS[idNode] =
	{RETURN[NEW[idNodeBody←[text, firstCharPosition, Length[text]]]]};


-- ModuleBodyProd

ModuleBodyProdProcs: PUBLIC ModuleBodyNodeProcs ←
	NEW[ModuleBodyNodeProcsBody ← [ModuleBodyProdFormContext]];

BuildModuleBodyProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode, DecList: DecListNode]
	RETURNS[ModuleBodyNode] =
		BEGIN
		data: ModuleBodyProdData ←
			NEW[ModuleBodyProdDataBody←[
			id, DecList]];
		RETURN[NEW[ModuleBodyNodeBody←[position, length, ModuleBodyProdProcs, data]]];
		END;


-- DecListoneProd

DecListoneProdProcs: PUBLIC DecListNodeProcs ←
	NEW[DecListNodeProcsBody ← [DecListoneProdEnlargeContext]];

BuildDecListoneProdNode: PUBLIC PROC[position: INT, length: INT, Declaration: DeclarationNode]
	RETURNS[DecListNode] =
		BEGIN
		data: DecListoneProdData ←
			NEW[DecListoneProdDataBody←[
			Declaration]];
		RETURN[NEW[DecListNodeBody←[position, length, DecListoneProdProcs, data]]];
		END;


-- DecListmoreProd

DecListmoreProdProcs: PUBLIC DecListNodeProcs ←
	NEW[DecListNodeProcsBody ← [DecListmoreProdEnlargeContext]];

BuildDecListmoreProdNode: PUBLIC PROC[position: INT, length: INT, DecList: DecListNode, Declaration: DeclarationNode]
	RETURNS[DecListNode] =
		BEGIN
		data: DecListmoreProdData ←
			NEW[DecListmoreProdDataBody←[
			DecList, Declaration]];
		RETURN[NEW[DecListNodeBody←[position, length, DecListmoreProdProcs, data]]];
		END;


-- DeclarationtypeProd

DeclarationtypeProdProcs: PUBLIC DeclarationNodeProcs ←
	NEW[DeclarationNodeProcsBody ← [DeclarationtypeProdEnlargeContext]];

BuildDeclarationtypeProdNode: PUBLIC PROC[position: INT, length: INT, IdListR: IdListRNode, DeclFrom: DeclFromNode, TypeExp: TypeExpNode]
	RETURNS[DeclarationNode] =
		BEGIN
		data: DeclarationtypeProdData ←
			NEW[DeclarationtypeProdDataBody←[
			IdListR, DeclFrom, TypeExp]];
		RETURN[NEW[DeclarationNodeBody←[position, length, DeclarationtypeProdProcs, data]]];
		END;


-- DeclFrombuiltinProd

DeclFrombuiltinProdProcs: PUBLIC DeclFromNodeProcs ←
	NEW[DeclFromNodeProcsBody ← [DeclFrombuiltinProdFormWhenceFromDecl]];

BuildDeclFrombuiltinProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[DeclFromNode] =
		BEGIN
		RETURN[NEW[DeclFromNodeBody←[position, length, DeclFrombuiltinProdProcs, NIL]]];
		END;


-- DeclFromfromcedardefProd

DeclFromfromcedardefProdProcs: PUBLIC DeclFromNodeProcs ←
	NEW[DeclFromNodeProcsBody ← [DeclFromfromcedardefProdFormWhenceFromDecl]];

BuildDeclFromfromcedardefProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
	RETURNS[DeclFromNode] =
		BEGIN
		data: DeclFromfromcedardefProdData ←
			NEW[DeclFromfromcedardefProdDataBody←[
			id]];
		RETURN[NEW[DeclFromNodeBody←[position, length, DeclFromfromcedardefProdProcs, data]]];
		END;


-- DeclFromnominalProd

DeclFromnominalProdProcs: PUBLIC DeclFromNodeProcs ←
	NEW[DeclFromNodeProcsBody ← [DeclFromnominalProdFormWhenceFromDecl]];

BuildDeclFromnominalProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[DeclFromNode] =
		BEGIN
		RETURN[NEW[DeclFromNodeBody←[position, length, DeclFromnominalProdProcs, NIL]]];
		END;


-- TypeExptypeidProd

TypeExptypeidProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExptypeidProdFormType]];

BuildTypeExptypeidProdNode: PUBLIC PROC[position: INT, length: INT, TypeId: TypeIdNode]
	RETURNS[TypeExpNode] =
		BEGIN
		data: TypeExptypeidProdData ←
			NEW[TypeExptypeidProdDataBody←[
			TypeId]];
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExptypeidProdProcs, data]]];
		END;


-- TypeExpelementsProd

TypeExpelementsProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExpelementsProdFormType]];

BuildTypeExpelementsProdNode: PUBLIC PROC[position: INT, length: INT, ElementList: ElementListNode]
	RETURNS[TypeExpNode] =
		BEGIN
		data: TypeExpelementsProdData ←
			NEW[TypeExpelementsProdDataBody←[
			ElementList]];
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExpelementsProdProcs, data]]];
		END;


-- TypeExprecordProd

TypeExprecordProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExprecordProdFormType]];

BuildTypeExprecordProdNode: PUBLIC PROC[position: INT, length: INT, FieldList: FieldListNode]
	RETURNS[TypeExpNode] =
		BEGIN
		data: TypeExprecordProdData ←
			NEW[TypeExprecordProdDataBody←[
			FieldList]];
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExprecordProdProcs, data]]];
		END;


-- TypeExprefProd

TypeExprefProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExprefProdFormType]];

BuildTypeExprefProdNode: PUBLIC PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeExpNode] =
		BEGIN
		data: TypeExprefProdData ←
			NEW[TypeExprefProdDataBody←[
			TypeExp]];
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExprefProdProcs, data]]];
		END;


-- TypeExprefAnyProd

TypeExprefAnyProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExprefAnyProdFormType]];

BuildTypeExprefAnyProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[TypeExpNode] =
		BEGIN
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExprefAnyProdProcs, NIL]]];
		END;


-- TypeExplistProd

TypeExplistProdProcs: PUBLIC TypeExpNodeProcs ←
	NEW[TypeExpNodeProcsBody ← [TypeExplistProdFormType]];

BuildTypeExplistProdNode: PUBLIC PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeExpNode] =
		BEGIN
		data: TypeExplistProdData ←
			NEW[TypeExplistProdDataBody←[
			TypeExp]];
		RETURN[NEW[TypeExpNodeBody←[position, length, TypeExplistProdProcs, data]]];
		END;


-- TypeIdmodProd

TypeIdmodProdProcs: PUBLIC TypeIdNodeProcs ←
	NEW[TypeIdNodeProcsBody ← [TypeIdmodProdFormTypeIdDesc]];

BuildTypeIdmodProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode, TypeId: TypeIdNode]
	RETURNS[TypeIdNode] =
		BEGIN
		data: TypeIdmodProdData ←
			NEW[TypeIdmodProdDataBody←[
			id, TypeId]];
		RETURN[NEW[TypeIdNodeBody←[position, length, TypeIdmodProdProcs, data]]];
		END;


-- TypeIdoneProd

TypeIdoneProdProcs: PUBLIC TypeIdNodeProcs ←
	NEW[TypeIdNodeProcsBody ← [TypeIdoneProdFormTypeIdDesc]];

BuildTypeIdoneProdNode: PUBLIC PROC[position: INT, length: INT, IdListL: IdListLNode]
	RETURNS[TypeIdNode] =
		BEGIN
		data: TypeIdoneProdData ←
			NEW[TypeIdoneProdDataBody←[
			IdListL]];
		RETURN[NEW[TypeIdNodeBody←[position, length, TypeIdoneProdProcs, data]]];
		END;


-- ElementListemptyProd

ElementListemptyProdProcs: PUBLIC ElementListNodeProcs ←
	NEW[ElementListNodeProcsBody ← [ElementListemptyProdFormElementSeq]];

BuildElementListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[ElementListNode] =
		BEGIN
		RETURN[NEW[ElementListNodeBody←[position, length, ElementListemptyProdProcs, NIL]]];
		END;


-- ElementListmoreProd

ElementListmoreProdProcs: PUBLIC ElementListNodeProcs ←
	NEW[ElementListNodeProcsBody ← [ElementListmoreProdFormElementSeq]];

BuildElementListmoreProdNode: PUBLIC PROC[position: INT, length: INT, ElementList: ElementListNode, Element: ElementNode]
	RETURNS[ElementListNode] =
		BEGIN
		data: ElementListmoreProdData ←
			NEW[ElementListmoreProdDataBody←[
			ElementList, Element]];
		RETURN[NEW[ElementListNodeBody←[position, length, ElementListmoreProdProcs, data]]];
		END;


-- ElementidProd

ElementidProdProcs: PUBLIC ElementNodeProcs ←
	NEW[ElementNodeProcsBody ← [ElementidProdFormName]];

BuildElementidProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
	RETURNS[ElementNode] =
		BEGIN
		data: ElementidProdData ←
			NEW[ElementidProdDataBody←[
			id]];
		RETURN[NEW[ElementNodeBody←[position, length, ElementidProdProcs, data]]];
		END;


-- FieldListemptyProd

FieldListemptyProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListemptyProdFormFieldSeq]];

BuildFieldListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[FieldListNode] =
		BEGIN
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListemptyProdProcs, NIL]]];
		END;


-- FieldListnullProd

FieldListnullProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListnullProdFormFieldSeq]];

BuildFieldListnullProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[FieldListNode] =
		BEGIN
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListnullProdProcs, NIL]]];
		END;


-- FieldListpairsProd

FieldListpairsProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListpairsProdFormFieldSeq]];

BuildFieldListpairsProdNode: PUBLIC PROC[position: INT, length: INT, PairList: PairListNode]
	RETURNS[FieldListNode] =
		BEGIN
		data: FieldListpairsProdData ←
			NEW[FieldListpairsProdDataBody←[
			PairList]];
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListpairsProdProcs, data]]];
		END;


-- FieldListvpairsProd

FieldListvpairsProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListvpairsProdFormFieldSeq]];

BuildFieldListvpairsProdNode: PUBLIC PROC[position: INT, length: INT, PairList: PairListNode, VPair: VPairNode]
	RETURNS[FieldListNode] =
		BEGIN
		data: FieldListvpairsProdData ←
			NEW[FieldListvpairsProdDataBody←[
			PairList, VPair]];
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListvpairsProdProcs, data]]];
		END;


-- FieldListtypesProd

FieldListtypesProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListtypesProdFormFieldSeq]];

BuildFieldListtypesProdNode: PUBLIC PROC[position: INT, length: INT, TypeList: TypeListNode]
	RETURNS[FieldListNode] =
		BEGIN
		data: FieldListtypesProdData ←
			NEW[FieldListtypesProdDataBody←[
			TypeList]];
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListtypesProdProcs, data]]];
		END;


-- FieldListvtypesProd

FieldListvtypesProdProcs: PUBLIC FieldListNodeProcs ←
	NEW[FieldListNodeProcsBody ← [FieldListvtypesProdFormFieldSeq]];

BuildFieldListvtypesProdNode: PUBLIC PROC[position: INT, length: INT, TypeList: TypeListNode, VPart: VPartNode]
	RETURNS[FieldListNode] =
		BEGIN
		data: FieldListvtypesProdData ←
			NEW[FieldListvtypesProdDataBody←[
			TypeList, VPart]];
		RETURN[NEW[FieldListNodeBody←[position, length, FieldListvtypesProdProcs, data]]];
		END;


-- PairListemptyProd

PairListemptyProdProcs: PUBLIC PairListNodeProcs ←
	NEW[PairListNodeProcsBody ← [PairListemptyProdFormFieldSeq]];

BuildPairListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[PairListNode] =
		BEGIN
		RETURN[NEW[PairListNodeBody←[position, length, PairListemptyProdProcs, NIL]]];
		END;


-- PairListoneProd

PairListoneProdProcs: PUBLIC PairListNodeProcs ←
	NEW[PairListNodeProcsBody ← [PairListoneProdFormFieldSeq]];

BuildPairListoneProdNode: PUBLIC PROC[position: INT, length: INT, PairItem: PairItemNode]
	RETURNS[PairListNode] =
		BEGIN
		data: PairListoneProdData ←
			NEW[PairListoneProdDataBody←[
			PairItem]];
		RETURN[NEW[PairListNodeBody←[position, length, PairListoneProdProcs, data]]];
		END;


-- PairListmoreProd

PairListmoreProdProcs: PUBLIC PairListNodeProcs ←
	NEW[PairListNodeProcsBody ← [PairListmoreProdFormFieldSeq]];

BuildPairListmoreProdNode: PUBLIC PROC[position: INT, length: INT, PairList: PairListNode, PairItem: PairItemNode]
	RETURNS[PairListNode] =
		BEGIN
		data: PairListmoreProdData ←
			NEW[PairListmoreProdDataBody←[
			PairList, PairItem]];
		RETURN[NEW[PairListNodeBody←[position, length, PairListmoreProdProcs, data]]];
		END;


-- PairItemProd

PairItemProdProcs: PUBLIC PairItemNodeProcs ←
	NEW[PairItemNodeProcsBody ← [PairItemProdFormFieldSeq]];

BuildPairItemProdNode: PUBLIC PROC[position: INT, length: INT, IdListR: IdListRNode, TypeExp: TypeExpNode]
	RETURNS[PairItemNode] =
		BEGIN
		data: PairItemProdData ←
			NEW[PairItemProdDataBody←[
			IdListR, TypeExp]];
		RETURN[NEW[PairItemNodeBody←[position, length, PairItemProdProcs, data]]];
		END;


-- VPairProd

VPairProdProcs: PUBLIC VPairNodeProcs ←
	NEW[VPairNodeProcsBody ← [VPairProdFormFieldSeq]];

BuildVPairProdNode: PUBLIC PROC[position: INT, length: INT, IdListR: IdListRNode, VPart: VPartNode]
	RETURNS[VPairNode] =
		BEGIN
		data: VPairProdData ←
			NEW[VPairProdDataBody←[
			IdListR, VPart]];
		RETURN[NEW[VPairNodeBody←[position, length, VPairProdProcs, data]]];
		END;


-- TypeListemptyProd

TypeListemptyProdProcs: PUBLIC TypeListNodeProcs ←
	NEW[TypeListNodeProcsBody ← [TypeListemptyProdFormFieldSeq]];

BuildTypeListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
	RETURNS[TypeListNode] =
		BEGIN
		RETURN[NEW[TypeListNodeBody←[position, length, TypeListemptyProdProcs, NIL]]];
		END;


-- TypeListoneProd

TypeListoneProdProcs: PUBLIC TypeListNodeProcs ←
	NEW[TypeListNodeProcsBody ← [TypeListoneProdFormFieldSeq]];

BuildTypeListoneProdNode: PUBLIC PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeListNode] =
		BEGIN
		data: TypeListoneProdData ←
			NEW[TypeListoneProdDataBody←[
			TypeExp]];
		RETURN[NEW[TypeListNodeBody←[position, length, TypeListoneProdProcs, data]]];
		END;


-- TypeListmoreProd

TypeListmoreProdProcs: PUBLIC TypeListNodeProcs ←
	NEW[TypeListNodeProcsBody ← [TypeListmoreProdFormFieldSeq]];

BuildTypeListmoreProdNode: PUBLIC PROC[position: INT, length: INT, TypeExp: TypeExpNode, TypeList: TypeListNode]
	RETURNS[TypeListNode] =
		BEGIN
		data: TypeListmoreProdData ←
			NEW[TypeListmoreProdDataBody←[
			TypeExp, TypeList]];
		RETURN[NEW[TypeListNodeBody←[position, length, TypeListmoreProdProcs, data]]];
		END;


-- VPartseqProd

VPartseqProdProcs: PUBLIC VPartNodeProcs ←
	NEW[VPartNodeProcsBody ← [VPartseqProdFormType]];

BuildVPartseqProdNode: PUBLIC PROC[position: INT, length: INT, VCaseHead: VCaseHeadNode, TypeExp: TypeExpNode]
	RETURNS[VPartNode] =
		BEGIN
		data: VPartseqProdData ←
			NEW[VPartseqProdDataBody←[
			VCaseHead, TypeExp]];
		RETURN[NEW[VPartNodeBody←[position, length, VPartseqProdProcs, data]]];
		END;


-- VCaseHeadidentProd

VCaseHeadidentProdProcs: PUBLIC VCaseHeadNodeProcs ←
	NEW[VCaseHeadNodeProcsBody ← [VCaseHeadidentProdFormVCaseHead]];

BuildVCaseHeadidentProdNode: PUBLIC PROC[position: INT, length: INT, Ident: IdentNode, Tagtype: TagtypeNode]
	RETURNS[VCaseHeadNode] =
		BEGIN
		data: VCaseHeadidentProdData ←
			NEW[VCaseHeadidentProdDataBody←[
			Ident, Tagtype]];
		RETURN[NEW[VCaseHeadNodeBody←[position, length, VCaseHeadidentProdProcs, data]]];
		END;


-- TagtypeexpProd

TagtypeexpProdProcs: PUBLIC TagtypeNodeProcs ←
	NEW[TagtypeNodeProcsBody ← [TagtypeexpProdFormType]];

BuildTagtypeexpProdNode: PUBLIC PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TagtypeNode] =
		BEGIN
		data: TagtypeexpProdData ←
			NEW[TagtypeexpProdDataBody←[
			TypeExp]];
		RETURN[NEW[TagtypeNodeBody←[position, length, TagtypeexpProdProcs, data]]];
		END;


-- IdListRoneProd

IdListRoneProdProcs: PUBLIC IdListRNodeProcs ←
	NEW[IdListRNodeProcsBody ← [IdListRoneProdFormNameSeq]];

BuildIdListRoneProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdListRNode] =
		BEGIN
		data: IdListRoneProdData ←
			NEW[IdListRoneProdDataBody←[
			id]];
		RETURN[NEW[IdListRNodeBody←[position, length, IdListRoneProdProcs, data]]];
		END;


-- IdListRmoreProd

IdListRmoreProdProcs: PUBLIC IdListRNodeProcs ←
	NEW[IdListRNodeProcsBody ← [IdListRmoreProdFormNameSeq]];

BuildIdListRmoreProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode, IdListR: IdListRNode]
	RETURNS[IdListRNode] =
		BEGIN
		data: IdListRmoreProdData ←
			NEW[IdListRmoreProdDataBody←[
			id, IdListR]];
		RETURN[NEW[IdListRNodeBody←[position, length, IdListRmoreProdProcs, data]]];
		END;


-- IdListLoneProd

IdListLoneProdProcs: PUBLIC IdListLNodeProcs ←
	NEW[IdListLNodeProcsBody ← [IdListLoneProdFormNameSeq]];

BuildIdListLoneProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdListLNode] =
		BEGIN
		data: IdListLoneProdData ←
			NEW[IdListLoneProdDataBody←[
			id]];
		RETURN[NEW[IdListLNodeBody←[position, length, IdListLoneProdProcs, data]]];
		END;


-- IdListLmoreProd

IdListLmoreProdProcs: PUBLIC IdListLNodeProcs ←
	NEW[IdListLNodeProcsBody ← [IdListLmoreProdFormNameSeq]];

BuildIdListLmoreProdNode: PUBLIC PROC[position: INT, length: INT, IdListL: IdListLNode, id: idNode]
	RETURNS[IdListLNode] =
		BEGIN
		data: IdListLmoreProdData ←
			NEW[IdListLmoreProdDataBody←[
			IdListL, id]];
		RETURN[NEW[IdListLNodeBody←[position, length, IdListLmoreProdProcs, data]]];
		END;


-- IdentProd

IdentProdProcs: PUBLIC IdentNodeProcs ←
	NEW[IdentNodeProcsBody ← [IdentProdFormId]];

BuildIdentProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdentNode] =
		BEGIN
		data: IdentProdData ←
			NEW[IdentProdDataBody←[
			id]];
		RETURN[NEW[IdentNodeBody←[position, length, IdentProdProcs, data]]];
		END;

ModuleBodyProdFormContext: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeContextNode] =
BEGIN
tree: ModuleBodyNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: ModuleBodyProdData ← NARROW[tree.data];
BEGIN
context3: TypeContextNode;
context2: TypeContextNode;
context1: TypeContextNode;
context0: TypeContextNode;
implModName: NameNode;
defModName: NameNode;
defModName ← BuildName[treeData.id];
implModName ← BuildImplModName[treeData.id];
context0 ← BuildEmptyTypeContext[defModName, implModName];
context1 ← NoteDefFileName[context0, defModName];
context2 ← NoteImplFileName[context1, implModName];
context3 ← treeData.DecList.procs.EnlargeContext[treeData.DecList, defModName, implModName, context2];
temp0 ← CloseTypeContext[context3];
END;
END
END;

DecListoneProdEnlargeContext: PUBLIC PROC[ref: REF ANY, defModuleName: NameNode, implModuleName: NameNode, context: TypeContextNode] RETURNS[temp0: TypeContextNode] =
BEGIN
tree: DecListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: DecListoneProdData ← NARROW[tree.data];
temp0 ← treeData.Declaration.procs.EnlargeContext[treeData.Declaration, defModuleName, implModuleName, context];
END
END;

DecListmoreProdEnlargeContext: PUBLIC PROC[ref: REF ANY, defModuleName: NameNode, implModuleName: NameNode, context: TypeContextNode] RETURNS[temp0: TypeContextNode] =
BEGIN
tree: DecListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: DecListmoreProdData ← NARROW[tree.data];
temp0 ← treeData.Declaration.procs.EnlargeContext[treeData.Declaration, defModuleName, implModuleName, treeData.DecList.procs.EnlargeContext[treeData.DecList, defModuleName, implModuleName, context]];
END
END;

DeclarationtypeProdEnlargeContext: PUBLIC PROC[ref: REF ANY, defModuleName: NameNode, implModuleName: NameNode, context: TypeContextNode] RETURNS[temp0: TypeContextNode] =
BEGIN
tree: DeclarationNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: DeclarationtypeProdData ← NARROW[tree.data];
BEGIN
typeDefFile: NameNode;
typeNames: NameSeqNode;
type: TypeNode;
type ← treeData.TypeExp.procs.FormType[treeData.TypeExp];
typeNames ← treeData.IdListR.procs.FormNameSeq[treeData.IdListR];
typeDefFile ← treeData.DeclFrom.procs.FormWhenceFromDecl[treeData.DeclFrom, defModuleName];
temp0 ← RecordTypeDecl[context, typeDefFile, defModuleName, implModuleName, typeNames, type];
END;
END
END;

DeclFrombuiltinProdFormWhenceFromDecl: PUBLIC PROC[ref: REF ANY, moduleName: NameNode] RETURNS[temp0: NameNode] =
BEGIN
tree: DeclFromNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildNullName[];
END
END;

DeclFromfromcedardefProdFormWhenceFromDecl: PUBLIC PROC[ref: REF ANY, moduleName: NameNode] RETURNS[temp0: NameNode] =
BEGIN
tree: DeclFromNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: DeclFromfromcedardefProdData ← NARROW[tree.data];
temp0 ← BuildName[treeData.id];
END
END;

DeclFromnominalProdFormWhenceFromDecl: PUBLIC PROC[ref: REF ANY, moduleName: NameNode] RETURNS[temp0: NameNode] =
BEGIN
tree: DeclFromNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← FakeCopyName[moduleName];
END
END;

TypeExptypeidProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeExptypeidProdData ← NARROW[tree.data];
temp1: NameSeqNode;
temp2: NameSeqNode;
[temp1, temp2] ← treeData.TypeId.procs.FormTypeIdDesc[treeData.TypeId];
temp0 ← BuildNamedType[temp1, temp2];
END
END;

TypeExpelementsProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeExpelementsProdData ← NARROW[tree.data];
temp0 ← BuildEnumeratedType[treeData.ElementList.procs.FormElementSeq[treeData.ElementList]];
END
END;

TypeExprecordProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeExprecordProdData ← NARROW[tree.data];
temp0 ← BuildRecordType[treeData.FieldList.procs.FormFieldSeq[treeData.FieldList]];
END
END;

TypeExprefProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeExprefProdData ← NARROW[tree.data];
temp0 ← BuildRefType[treeData.TypeExp.procs.FormType[treeData.TypeExp]];
END
END;

TypeExprefAnyProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildRefAnyType[];
END
END;

TypeExplistProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TypeExpNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeExplistProdData ← NARROW[tree.data];
temp0 ← BuildListType[treeData.TypeExp.procs.FormType[treeData.TypeExp]];
END
END;

TypeIdmodProdFormTypeIdDesc: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode, temp1: NameSeqNode] =
BEGIN
tree: TypeIdNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeIdmodProdData ← NARROW[tree.data];
BEGIN
seq1: NameSeqNode;
seq2: NameSeqNode;
[seq1, seq2] ← treeData.TypeId.procs.FormTypeIdDesc[treeData.TypeId];
temp1 ← seq2;
temp0 ← PrefixToNameSeq[BuildName[treeData.id], seq1];
END;
END
END;

TypeIdoneProdFormTypeIdDesc: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode, temp1: NameSeqNode] =
BEGIN
tree: TypeIdNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeIdoneProdData ← NARROW[tree.data];
temp1 ← treeData.IdListL.procs.FormNameSeq[treeData.IdListL];
temp0 ← BuildEmptyNameSeq[];
END
END;

ElementListemptyProdFormElementSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: ElementSeqNode] =
BEGIN
tree: ElementListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildEmptyElementSeq[];
END
END;

ElementListmoreProdFormElementSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: ElementSeqNode] =
BEGIN
tree: ElementListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: ElementListmoreProdData ← NARROW[tree.data];
temp0 ← AppendNameToElementSeq[treeData.ElementList.procs.FormElementSeq[treeData.ElementList], treeData.Element.procs.FormName[treeData.Element]];
END
END;

ElementidProdFormName: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameNode] =
BEGIN
tree: ElementNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: ElementidProdData ← NARROW[tree.data];
temp0 ← BuildName[treeData.id];
END
END;

FieldListemptyProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildEmptyFieldSeq[];
END
END;

FieldListnullProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildEmptyFieldSeq[];
END
END;

FieldListpairsProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: FieldListpairsProdData ← NARROW[tree.data];
temp0 ← treeData.PairList.procs.FormFieldSeq[treeData.PairList];
END
END;

FieldListvpairsProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: FieldListvpairsProdData ← NARROW[tree.data];
temp0 ← ConcatFieldSeq[treeData.PairList.procs.FormFieldSeq[treeData.PairList], treeData.VPair.procs.FormFieldSeq[treeData.VPair]];
END
END;

FieldListtypesProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: FieldListtypesProdData ← NARROW[tree.data];
temp0 ← treeData.TypeList.procs.FormFieldSeq[treeData.TypeList];
END
END;

FieldListvtypesProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: FieldListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: FieldListvtypesProdData ← NARROW[tree.data];
BEGIN
vFieldSeq: FieldSeqNode;
vFieldSeq ← PrefixTypeToFieldSeq[treeData.VPart.procs.FormType[treeData.VPart], BuildEmptyFieldSeq[]];
temp0 ← ConcatFieldSeq[treeData.TypeList.procs.FormFieldSeq[treeData.TypeList], vFieldSeq];
END;
END
END;

PairListemptyProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: PairListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildEmptyFieldSeq[];
END
END;

PairListoneProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: PairListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: PairListoneProdData ← NARROW[tree.data];
temp0 ← treeData.PairItem.procs.FormFieldSeq[treeData.PairItem];
END
END;

PairListmoreProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: PairListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: PairListmoreProdData ← NARROW[tree.data];
temp0 ← ConcatFieldSeq[treeData.PairList.procs.FormFieldSeq[treeData.PairList], treeData.PairItem.procs.FormFieldSeq[treeData.PairItem]];
END
END;

PairItemProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: PairItemNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: PairItemProdData ← NARROW[tree.data];
temp0 ← BuildOnePairFieldSeq[treeData.IdListR.procs.FormNameSeq[treeData.IdListR], treeData.TypeExp.procs.FormType[treeData.TypeExp]];
END
END;

VPairProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: VPairNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: VPairProdData ← NARROW[tree.data];
temp0 ← BuildOnePairFieldSeq[treeData.IdListR.procs.FormNameSeq[treeData.IdListR], treeData.VPart.procs.FormType[treeData.VPart]];
END
END;

TypeListemptyProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: TypeListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← BuildEmptyFieldSeq[];
END
END;

TypeListoneProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: TypeListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeListoneProdData ← NARROW[tree.data];
temp0 ← PrefixTypeToFieldSeq[treeData.TypeExp.procs.FormType[treeData.TypeExp], BuildEmptyFieldSeq[]];
END
END;

TypeListmoreProdFormFieldSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: FieldSeqNode] =
BEGIN
tree: TypeListNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TypeListmoreProdData ← NARROW[tree.data];
temp0 ← PrefixTypeToFieldSeq[treeData.TypeExp.procs.FormType[treeData.TypeExp], treeData.TypeList.procs.FormFieldSeq[treeData.TypeList]];
END
END;

VPartseqProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: VPartNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: VPartseqProdData ← NARROW[tree.data];
BEGIN
sizeName: NameNode;
sizeId: idNode;
sizeType: TypeNode;
fieldType: TypeNode;
fieldType ← treeData.TypeExp.procs.FormType[treeData.TypeExp];
[sizeId, sizeType] ← treeData.VCaseHead.procs.FormVCaseHead[treeData.VCaseHead];
sizeName ← BuildName[sizeId];
temp0 ← BuildSeqType[sizeName, sizeType, fieldType];
END;
END
END;

VCaseHeadidentProdFormVCaseHead: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: idNode, temp1: TypeNode] =
BEGIN
tree: VCaseHeadNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: VCaseHeadidentProdData ← NARROW[tree.data];
temp1 ← treeData.Tagtype.procs.FormType[treeData.Tagtype];
temp0 ← treeData.Ident.procs.FormId[treeData.Ident];
END
END;

TagtypeexpProdFormType: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: TypeNode] =
BEGIN
tree: TagtypeNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: TagtypeexpProdData ← NARROW[tree.data];
temp0 ← treeData.TypeExp.procs.FormType[treeData.TypeExp];
END
END;

IdListRoneProdFormNameSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode] =
BEGIN
tree: IdListRNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: IdListRoneProdData ← NARROW[tree.data];
temp0 ← AppendToNameSeq[BuildEmptyNameSeq[], BuildName[treeData.id]];
END
END;

IdListRmoreProdFormNameSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode] =
BEGIN
tree: IdListRNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: IdListRmoreProdData ← NARROW[tree.data];
temp0 ← PrefixToNameSeq[BuildName[treeData.id], treeData.IdListR.procs.FormNameSeq[treeData.IdListR]];
END
END;

IdListLoneProdFormNameSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode] =
BEGIN
tree: IdListLNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: IdListLoneProdData ← NARROW[tree.data];
temp0 ← AppendToNameSeq[BuildEmptyNameSeq[], BuildName[treeData.id]];
END
END;

IdListLmoreProdFormNameSeq: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: NameSeqNode] =
BEGIN
tree: IdListLNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: IdListLmoreProdData ← NARROW[tree.data];
temp0 ← AppendToNameSeq[treeData.IdListL.procs.FormNameSeq[treeData.IdListL], BuildName[treeData.id]];
END
END;

IdentProdFormId: PUBLIC PROC[ref: REF ANY] RETURNS[temp0: idNode] =
BEGIN
tree: IdentNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: IdentProdData ← NARROW[tree.data];
temp0 ← treeData.id;
END
END;

END..