DIRECTORY
	KipperMain1Def,
	KipperMain2Def USING[],
	ThreeC4Support;

KipperMain2Impl: CEDAR PROGRAM IMPORTS KipperMain1Def EXPORTS KipperMain2Def= 
BEGIN
OPEN KipperMain1Def, ThreeC4Support;
KipperMain2LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[0] ← SeeMainGoal;
prodLinkArray[1] ← SeeModuleBodynosemicolon;
prodLinkArray[2] ← SeeModuleBodyeithsemicolon;
prodLinkArray[3] ← Seedeclistone;
prodLinkArray[4] ← Seedeclistmore;
prodLinkArray[5] ← Seedeclarationtype;
prodLinkArray[6] ← Seedeclarationcedartype;
prodLinkArray[7] ← Seefromno;
prodLinkArray[8] ← Seefromyes;
prodLinkArray[9] ← Seeidentlist;
prodLinkArray[10] ← SeeidentlistPid;
prodLinkArray[11] ← SeeidentlistPidmore;
prodLinkArray[12] ← Seetypeexpid;
prodLinkArray[13] ← Seetypeexptypeid;
prodLinkArray[14] ← Seetypeexptypecons;
prodLinkArray[15] ← Seetypeididid;
prodLinkArray[16] ← Seetypeididtypeid;
prodLinkArray[17] ← Seetypeidtypeidp;
prodLinkArray[18] ← SeetypeidPtwo;
prodLinkArray[19] ← SeetypeidPmore;
prodLinkArray[20] ← Seetypeconselements;
prodLinkArray[21] ← Seetypeconsrecord;
prodLinkArray[22] ← Seetypeconsref;
prodLinkArray[23] ← Seetypeconsrefany;
prodLinkArray[24] ← Seetypeconslist;
prodLinkArray[25] ← Seeelementlistempty;
prodLinkArray[26] ← Seeelementlistnonempty;
prodLinkArray[27] ← SeeelementlistPone;
prodLinkArray[28] ← SeeelementlistPmore;
prodLinkArray[29] ← Seeelementid;
prodLinkArray[30] ← Seereclistempty;
prodLinkArray[31] ← Seereclistnull;
prodLinkArray[32] ← Seereclistpairs;
prodLinkArray[33] ← Seereclisttypes;
prodLinkArray[34] ← Seereclistvpairs;
prodLinkArray[35] ← Seereclistvpart;
prodLinkArray[36] ← Seereclistvpair;
prodLinkArray[37] ← Seevariantpair;
prodLinkArray[38] ← Seevariantpartseq;
prodLinkArray[39] ← Seevcaseheadident;
prodLinkArray[40] ← Seetagtypeexp;
prodLinkArray[41] ← Seeident;
prodLinkArray[42] ← Seepairlistone;
prodLinkArray[43] ← Seepairlistmore;
prodLinkArray[44] ← Seepairitem;
prodLinkArray[45] ← Seetypelisttypecons;
prodLinkArray[46] ← Seetypelisttypeid;
prodLinkArray[47] ← Seetypelistid;
prodLinkArray[48] ← Seetypelisttypeconsmore;
prodLinkArray[49] ← Seetypelisttypeidmore;
prodLinkArray[50] ← Seetypelistidmore;
END;

SeeMainGoal: 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[BuildJunkProdNode[position, length], stack];
RETURN[stack]
END;

SeeModuleBodynosemicolon: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
declist: DecListNode;
declist ← NARROW[stack.first];
stack ← stack.rest;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleBodyProdNode[position, length, id, declist], stack];
RETURN[stack]
END;

SeeModuleBodyeithsemicolon: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
declist: DecListNode;
declist ← NARROW[stack.first];
stack ← stack.rest;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildModuleBodyProdNode[position, length, id, declist], stack];
RETURN[stack]
END;

Seedeclistone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
declaration: DeclarationNode;
declaration ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDecListoneProdNode[position, length, declaration], stack];
RETURN[stack]
END;

Seedeclistmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
declist: DecListNode;
declaration: DeclarationNode;
declaration ← NARROW[stack.first];
stack ← stack.rest;
declist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDecListmoreProdNode[position, length, declist, declaration], stack];
RETURN[stack]
END;

Seedeclarationtype: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
identlist: IdListRNode;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
identlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDeclarationtypeProdNode[position, length, identlist, BuildDeclFromnominalProdNode[identlist.position + identlist.length, typeexp.position - identlist.position - identlist.length], typeexp], stack];
RETURN[stack]
END;

Seedeclarationcedartype: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
identlist: IdListRNode;
from: DeclFromNode;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
from ← NARROW[stack.first];
stack ← stack.rest;
identlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDeclarationtypeProdNode[position, length, identlist, from, typeexp], stack];
RETURN[stack]
END;

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

Seefromyes: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildDeclFromfromcedardefProdNode[position, length, id], stack];
RETURN[stack]
END;

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

SeeidentlistPid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListRoneProdNode[position, length, id], stack];
RETURN[stack]
END;

SeeidentlistPidmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
identlistP: IdListRNode;
identlistP ← NARROW[stack.first];
stack ← stack.rest;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListRmoreProdNode[position, length, id, identlistP], stack];
RETURN[stack]
END;

Seetypeexpid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExptypeidProdNode[position, length, BuildTypeIdoneProdNode[id.position, id.length, BuildIdListLoneProdNode[id.position, id.length, id]]], stack];
RETURN[stack]
END;

Seetypeexptypeid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeid: TypeIdNode;
typeid ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExptypeidProdNode[position, length, typeid], stack];
RETURN[stack]
END;

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

Seetypeididid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ida: idNode;
idb: idNode;
idb ← NARROW[stack.first];
stack ← stack.rest;
ida ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeIdmodProdNode[position, length, ida, BuildTypeIdoneProdNode[idb.position, idb.length, BuildIdListLoneProdNode[idb.position, idb.length, idb]]], stack];
RETURN[stack]
END;

Seetypeididtypeid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
typeid: TypeIdNode;
typeid ← NARROW[stack.first];
stack ← stack.rest;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeIdmodProdNode[position, length, id, typeid], stack];
RETURN[stack]
END;

Seetypeidtypeidp: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeidP: IdListLNode;
typeidP ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeIdoneProdNode[position, length, typeidP], stack];
RETURN[stack]
END;

SeetypeidPtwo: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ida: idNode;
idb: idNode;
idb ← NARROW[stack.first];
stack ← stack.rest;
ida ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListLmoreProdNode[position, length, BuildIdListLoneProdNode[ida.position, ida.length, ida], idb], stack];
RETURN[stack]
END;

SeetypeidPmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeidP: IdListLNode;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
typeidP ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdListLmoreProdNode[position, length, typeidP, id], stack];
RETURN[stack]
END;

Seetypeconselements: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
elementlist: ElementListNode;
elementlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExpelementsProdNode[position, length, elementlist], stack];
RETURN[stack]
END;

Seetypeconsrecord: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
reclist: FieldListNode;
reclist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExprecordProdNode[position, length, reclist], stack];
RETURN[stack]
END;

Seetypeconsref: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExprefProdNode[position, length, typeexp], stack];
RETURN[stack]
END;

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

Seetypeconslist: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeExplistProdNode[position, length, typeexp], stack];
RETURN[stack]
END;

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

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

SeeelementlistPone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
element: ElementNode;
element ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildElementListmoreProdNode[position, length, BuildElementListemptyProdNode[element.position, element.position - element.length], element], stack];
RETURN[stack]
END;

SeeelementlistPmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
elementlistP: ElementListNode;
element: ElementNode;
element ← NARROW[stack.first];
stack ← stack.rest;
elementlistP ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildElementListmoreProdNode[position, length, elementlistP, element], stack];
RETURN[stack]
END;

Seeelementid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildElementidProdNode[position, length, id], stack];
RETURN[stack]
END;

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

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

Seereclistpairs: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
pairlist: PairListNode;
pairlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildFieldListpairsProdNode[position, length, pairlist], stack];
RETURN[stack]
END;

Seereclisttypes: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typelist: TypeListNode;
typelist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildFieldListtypesProdNode[position, length, typelist], stack];
RETURN[stack]
END;

Seereclistvpairs: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
pairlist: PairListNode;
variantpair: VPairNode;
variantpair ← NARROW[stack.first];
stack ← stack.rest;
pairlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildFieldListvpairsProdNode[position, length, pairlist, variantpair], stack];
RETURN[stack]
END;

Seereclistvpart: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
variantpart: VPartNode;
variantpart ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildFieldListvtypesProdNode[position, length, BuildTypeListemptyProdNode[variantpart.position, variantpart.position - variantpart.length], variantpart], stack];
RETURN[stack]
END;

Seereclistvpair: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
variantpair: VPairNode;
variantpair ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildFieldListvpairsProdNode[position, length, BuildPairListemptyProdNode[variantpair.position, variantpair.position - variantpair.length], variantpair], stack];
RETURN[stack]
END;

Seevariantpair: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
identlist: IdListRNode;
variantpart: VPartNode;
variantpart ← NARROW[stack.first];
stack ← stack.rest;
identlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildVPairProdNode[position, length, identlist, variantpart], stack];
RETURN[stack]
END;

Seevariantpartseq: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
vcasehead: VCaseHeadNode;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
vcasehead ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildVPartseqProdNode[position, length, vcasehead, typeexp], stack];
RETURN[stack]
END;

Seevcaseheadident: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
ident: IdentNode;
tagtype: TagtypeNode;
tagtype ← NARROW[stack.first];
stack ← stack.rest;
ident ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildVCaseHeadidentProdNode[position, length, ident, tagtype], stack];
RETURN[stack]
END;

Seetagtypeexp: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTagtypeexpProdNode[position, length, typeexp], stack];
RETURN[stack]
END;

Seeident: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildIdentProdNode[position, length, id], stack];
RETURN[stack]
END;

Seepairlistone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
pairitem: PairItemNode;
pairitem ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildPairListoneProdNode[position, length, pairitem], stack];
RETURN[stack]
END;

Seepairlistmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
pairlist: PairListNode;
pairitem: PairItemNode;
pairitem ← NARROW[stack.first];
stack ← stack.rest;
pairlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildPairListmoreProdNode[position, length, pairlist, pairitem], stack];
RETURN[stack]
END;

Seepairitem: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
identlist: IdListRNode;
typeexp: TypeExpNode;
typeexp ← NARROW[stack.first];
stack ← stack.rest;
identlist ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildPairItemProdNode[position, length, identlist, typeexp], stack];
RETURN[stack]
END;

Seetypelisttypecons: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typecons: TypeExpNode;
typecons ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListoneProdNode[position, length, typecons], stack];
RETURN[stack]
END;

Seetypelisttypeid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeid: TypeIdNode;
typeid ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListoneProdNode[position, length, BuildTypeExptypeidProdNode[typeid.position, typeid.length, typeid]], stack];
RETURN[stack]
END;

Seetypelistid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListoneProdNode[position, length, BuildTypeExptypeidProdNode[id.position, id.length, BuildTypeIdoneProdNode[id.position, id.length, BuildIdListLoneProdNode[id.position, id.length, id]]]], stack];
RETURN[stack]
END;

Seetypelisttypeconsmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typecons: TypeExpNode;
typelist: TypeListNode;
typelist ← NARROW[stack.first];
stack ← stack.rest;
typecons ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListmoreProdNode[position, length, typecons, typelist], stack];
RETURN[stack]
END;

Seetypelisttypeidmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
typeid: TypeIdNode;
typelist: TypeListNode;
typelist ← NARROW[stack.first];
stack ← stack.rest;
typeid ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListmoreProdNode[position, length, BuildTypeExptypeidProdNode[typeid.position, typeid.length, typeid], typelist], stack];
RETURN[stack]
END;

Seetypelistidmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY ← nodes;
id: idNode;
typelist: TypeListNode;
typelist ← NARROW[stack.first];
stack ← stack.rest;
id ← NARROW[stack.first];
stack ← stack.rest;
stack ← CONS[BuildTypeListmoreProdNode[position, length, BuildTypeExptypeidProdNode[id.position, id.length, BuildTypeIdoneProdNode[id.position, id.length, BuildIdListLoneProdNode[id.position, id.length, id]]], typelist], stack];
RETURN[stack]
END;

END..