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