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