-- SaffronCG3Impl.mesa
 -- Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
 -- Generated by hederman.pa at August 17, 1987 3:57:19 pm PDT
 --  using ThreeCasabaFour [1.2] of June 1, 1987 6:00:00 pm PDT

DIRECTORY
	SaffronAG5Def,
	SaffronAG6Def,
	SaffronAG8Def,
	SaffronAG7Def,
	SaffronAG2Def,
	SaffronAG1Def,
	SaffronAG3Def,
	SaffronGenericDef,
	ThreeC4Support,
	SaffronCG3Def USING[],
	SaffronATDef;

SaffronCG3Impl: CEDAR PROGRAM IMPORTS SaffronAG5Def, SaffronAG6Def, SaffronAG8Def, SaffronAG7Def, SaffronAG2Def, SaffronAG1Def, SaffronAG3Def EXPORTS SaffronCG3Def= 
BEGIN
OPEN SaffronAG5Def, SaffronAG6Def, SaffronAG8Def, SaffronAG7Def, SaffronAG2Def, SaffronAG1Def, SaffronAG3Def, SaffronGenericDef, ThreeC4Support, SaffronATDef;
SaffronCG3LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[91] _ Seetransferopsignal;
prodLinkArray[92] _ Seetransferoperror;
prodLinkArray[93] _ Seetransferopstart;
prodLinkArray[94] _ Seetransferopjoin;
prodLinkArray[95] _ Seetransferopnew;
prodLinkArray[96] _ Seetransferopfork;
prodLinkArray[97] _ Seedisjunctor;
prodLinkArray[98] _ Seedisjunctconjunct;
prodLinkArray[99] _ Seeconjunctand;
prodLinkArray[100] _ Seeconjunctnegation;
prodLinkArray[101] _ Seenegationa;
prodLinkArray[102] _ Seenegationb;
prodLinkArray[103] _ Seenegationrelation;
prodLinkArray[104] _ Seerelationrelation;
prodLinkArray[105] _ Seerelationsum;
prodLinkArray[106] _ Seecatchlista;
prodLinkArray[107] _ Seecatchlistb;
prodLinkArray[108] _ Seecatchlistc;
prodLinkArray[109] _ Seecatchlistd;
prodLinkArray[110] _ Seecatchheadempty;
prodLinkArray[111] _ Seecatchheadmore;
prodLinkArray[112] _ Seeidentidposition;
prodLinkArray[113] _ Seeidentid;
prodLinkArray[114] _ Seetypeopcode;
prodLinkArray[115] _ Seetypeopfirst;
prodLinkArray[116] _ Seetypeoplast;
prodLinkArray[117] _ Seetypeopnil;
prodLinkArray[118] _ Seeidlist;
prodLinkArray[119] _ SeeidlistPone;
prodLinkArray[120] _ SeeidlistPmore;
prodLinkArray[121] _ Seearguments;
prodLinkArray[122] _ Seearglistany;
prodLinkArray[123] _ Seearglistfieldlist;
prodLinkArray[124] _ Seearglistempty;
prodLinkArray[125] _ Seereturnlistany;
prodLinkArray[126] _ Seereturnlistfieldlist;
prodLinkArray[127] _ Seereturnlistempty;
prodLinkArray[128] _ Seefieldlistempty;
prodLinkArray[129] _ Seefieldlistpairlist;
prodLinkArray[130] _ Seefieldlisttypelist;
prodLinkArray[131] _ Seetypeexpa;
prodLinkArray[132] _ Seetypeexpb;
prodLinkArray[133] _ Seetypeexpc;
prodLinkArray[134] _ Seenumdecimal;
prodLinkArray[135] _ Seenumoctal;
prodLinkArray[136] _ Seenumhex;
prodLinkArray[137] _ Seelhsid;
prodLinkArray[138] _ Seelhsnum;
prodLinkArray[139] _ Seelhsstring;
prodLinkArray[140] _ Seelhsflnum;
prodLinkArray[141] _ Seelhschar;
prodLinkArray[142] _ Seelhsatom;
prodLinkArray[143] _ Seelhsnarrow;
prodLinkArray[144] _ Seelhsloophole;
prodLinkArray[145] _ Seelhsapply;
prodLinkArray[146] _ Seelhsexp;
prodLinkArray[147] _ Seelhsqualifier;
prodLinkArray[148] _ Seequalifierprefixop;
prodLinkArray[149] _ Seequalifiertypeop;
prodLinkArray[150] _ Seequalifiersize;
prodLinkArray[151] _ Seequalifierbits;
prodLinkArray[152] _ Seequalifierbytes;
prodLinkArray[153] _ Seequalifierunits;
prodLinkArray[154] _ Seequalifierwords;
prodLinkArray[155] _ Seequalifierapply;
prodLinkArray[156] _ Seequalifierselect;
prodLinkArray[157] _ Seequalifierindirect;
prodLinkArray[158] _ Seeexitlistempty;
prodLinkArray[159] _ Seeexitlistb;
prodLinkArray[160] _ Seeexitlistc;
prodLinkArray[161] _ SeeexitlistPa;
prodLinkArray[162] _ SeeexitlistPb;
prodLinkArray[163] _ Seeexititem;
prodLinkArray[164] _ Seeoptexptrash;
prodLinkArray[165] _ Seeoptexpexp;
prodLinkArray[166] _ Seeoptexpempty;
prodLinkArray[167] _ Seecatchcase;
prodLinkArray[168] _ Seelhslistone;
prodLinkArray[169] _ Seelhslistmore;
prodLinkArray[170] _ Seeinitializationempty;
prodLinkArray[171] _ Seeinitializationassignment;
prodLinkArray[172] _ Seeinitializationbinding;
prodLinkArray[173] _ Seeinitvalueblock;
prodLinkArray[174] _ Seeinitvaluecode;
prodLinkArray[175] _ Seeinitvaluec;
prodLinkArray[176] _ Seeinitvalued;
prodLinkArray[177] _ Seeinitvaluetrash;
prodLinkArray[178] _ Seeinitvalueexp;
prodLinkArray[179] _ Seeprocaccess;
prodLinkArray[180] _ Seeinlineyes;
prodLinkArray[181] _ Seeinlineno;
prodLinkArray[182] _ Seecodelistone;
prodLinkArray[183] _ Seecodelistmore;
END;

Seetransferopsignal: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOpsignalProdNode[position, length], stack];
RETURN [stack]
END;

Seetransferoperror: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOperrorProdNode[position, length], stack];
RETURN [stack]
END;

Seetransferopstart: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOpstartProdNode[position, length], stack];
RETURN [stack]
END;

Seetransferopjoin: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOpjoinProdNode[position, length], stack];
RETURN [stack]
END;

Seetransferopnew: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOpnewProdNode[position, length], stack];
RETURN [stack]
END;

Seetransferopfork: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTransferOpforkProdNode[position, length], stack];
RETURN [stack]
END;

Seedisjunctor: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
disjunct: ExpNode;
conjunct: ExpNode;
conjunct _ NARROW[stack.first];
stack _ stack.rest;
disjunct _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExporProdNode[position, length, disjunct, conjunct], stack];
RETURN [stack]
END;

Seedisjunctconjunct: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
conjunct: ExpNode;
conjunct _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[conjunct, stack];
RETURN [stack]
END;

Seeconjunctand: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
conjunct: ExpNode;
negation: ExpNode;
negation _ NARROW[stack.first];
stack _ stack.rest;
conjunct _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpandProdNode[position, length, conjunct, negation], stack];
RETURN [stack]
END;

Seeconjunctnegation: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
negation: ExpNode;
negation _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[negation, stack];
RETURN [stack]
END;

Seenegationa: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relation: ExpNode;
relation _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpnotProdNode[position, length, relation], stack];
RETURN [stack]
END;

Seenegationb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relation: ExpNode;
relation _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpnotProdNode[position, length, relation], stack];
RETURN [stack]
END;

Seenegationrelation: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relation: ExpNode;
relation _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[relation, stack];
RETURN [stack]
END;

Seerelationrelation: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
sum: ExpNode;
optrelation: RelationNode;
optrelation _ NARROW[stack.first];
stack _ stack.rest;
sum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExprelationProdNode[position, length, sum, optrelation], stack];
RETURN [stack]
END;

Seerelationsum: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
sum: ExpNode;
sum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[sum, stack];
RETURN [stack]
END;

Seecatchlista: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
catchhead: CatchCaseListNode;
catchcase: CatchCaseNode;
catchcase _ NARROW[stack.first];
stack _ stack.rest;
catchhead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchProdNode[position, length, BuildCatchCaseListmoreProdNode[catchhead.position, catchcase.position + catchcase.length - catchhead.position, catchhead, catchcase], BuildCatchAnyabsentProdNode[catchcase.position + catchcase.length, catchcase.position + catchcase.length - catchcase.position - catchcase.length]], stack];
RETURN [stack]
END;

Seecatchlistb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
catchhead: CatchCaseListNode;
catchhead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchProdNode[position, length, catchhead, BuildCatchAnyabsentProdNode[catchhead.position + catchhead.length, catchhead.position + catchhead.length - catchhead.position - catchhead.length]], stack];
RETURN [stack]
END;

Seecatchlistc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
catchhead: CatchCaseListNode;
catchany: CatchAnyNode;
catchany _ NARROW[stack.first];
stack _ stack.rest;
catchhead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchProdNode[position, length, catchhead, catchany], stack];
RETURN [stack]
END;

Seecatchlistd: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
catchhead: CatchCaseListNode;
catchany: CatchAnyNode;
catchany _ NARROW[stack.first];
stack _ stack.rest;
catchhead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchProdNode[position, length, catchhead, catchany], stack];
RETURN [stack]
END;

Seecatchheadempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildCatchCaseListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seecatchheadmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
catchhead: CatchCaseListNode;
catchcase: CatchCaseNode;
catchcase _ NARROW[stack.first];
stack _ stack.rest;
catchhead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchCaseListmoreProdNode[position, length, catchhead, catchcase], stack];
RETURN [stack]
END;

Seeidentidposition: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
positionP: PositionNode;
positionP _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdentidpositionProdNode[position, length, Id, positionP], stack];
RETURN [stack]
END;

Seeidentid: 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[BuildIdentidProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seetypeopcode: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeOpcodeProdNode[position, length], stack];
RETURN [stack]
END;

Seetypeopfirst: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeOpfirstProdNode[position, length], stack];
RETURN [stack]
END;

Seetypeoplast: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeOplastProdNode[position, length], stack];
RETURN [stack]
END;

Seetypeopnil: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeOpnilProdNode[position, length], stack];
RETURN [stack]
END;

Seeidlist: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
idlistP: IdListNode;
idlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[idlistP, stack];
RETURN [stack]
END;

SeeidlistPone: 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[BuildIdListoneProdNode[position, length, Id], stack];
RETURN [stack]
END;

SeeidlistPmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Id: IdNode;
idlistP: IdListNode;
idlistP _ NARROW[stack.first];
stack _ stack.rest;
Id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdListmoreProdNode[position, length, Id, idlistP], stack];
RETURN [stack]
END;

Seearguments: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
arglist: ParameterListNode;
returnlist: ParameterListNode;
returnlist _ NARROW[stack.first];
stack _ stack.rest;
arglist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildArgumentsProdNode[position, length, arglist, returnlist], stack];
RETURN [stack]
END;

Seearglistany: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildParameterListanyProdNode[position, length], stack];
RETURN [stack]
END;

Seearglistfieldlist: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
fieldlist: ParameterListNode;
fieldlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[fieldlist, stack];
RETURN [stack]
END;

Seearglistempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildParameterListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seereturnlistany: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildParameterListanyProdNode[position, length], stack];
RETURN [stack]
END;

Seereturnlistfieldlist: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
fieldlist: ParameterListNode;
fieldlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[fieldlist, stack];
RETURN [stack]
END;

Seereturnlistempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildParameterListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seefieldlistempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildParameterListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seefieldlistpairlist: 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[BuildParameterListpairlistProdNode[position, length, pairlist], stack];
RETURN [stack]
END;

Seefieldlisttypelist: 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[BuildParameterListtypelistProdNode[position, length, typelist], stack];
RETURN [stack]
END;

Seetypeexpa: 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, BuildTypeIdidProdNode[Id.position, Id.length, Id]], stack];
RETURN [stack]
END;

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

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

Seenumdecimal: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Decimalnum: DecimalnumNode;
Decimalnum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNumdecimalProdNode[position, length, Decimalnum], stack];
RETURN [stack]
END;

Seenumoctal: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Octalnum: OctalnumNode;
Octalnum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNumoctalProdNode[position, length, Octalnum], stack];
RETURN [stack]
END;

Seenumhex: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Hexnum: HexnumNode;
Hexnum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNumhexProdNode[position, length, Hexnum], stack];
RETURN [stack]
END;

Seelhsid: 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[BuildExpidProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seelhsnum: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
num: NumNode;
num _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpnumProdNode[position, length, num], stack];
RETURN [stack]
END;

Seelhsstring: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
String: StringNode;
String _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpstringProdNode[position, length, String], stack];
RETURN [stack]
END;

Seelhsflnum: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Flnum: FlnumNode;
Flnum _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpflnumProdNode[position, length, Flnum], stack];
RETURN [stack]
END;

Seelhschar: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Char: CharNode;
Char _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpcharProdNode[position, length, Char], stack];
RETURN [stack]
END;

Seelhsatom: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Atom: AtomNode;
Atom _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpatomProdNode[position, length, Atom], stack];
RETURN [stack]
END;

Seelhsnarrow: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
opttype: OptTypeNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
opttype _ NARROW[stack.first];
stack _ stack.rest;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpnarrowProdNode[position, length, exp, opttype, optcatch], stack];
RETURN [stack]
END;

Seelhsloophole: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
opttype: OptTypeNode;
opttype _ NARROW[stack.first];
stack _ stack.rest;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExploopholeProdNode[position, length, exp, opttype], stack];
RETURN [stack]
END;

Seelhsapply: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exprator: ExpNode;
exprand: ExpNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
exprand _ NARROW[stack.first];
stack _ stack.rest;
exprator _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpapplyProdNode[position, length, exprator, exprand, optcatch], stack];
RETURN [stack]
END;

Seelhsexp: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[exp, stack];
RETURN [stack]
END;

Seelhsqualifier: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
qualifier: QualifierNode;
qualifier _ NARROW[stack.first];
stack _ stack.rest;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpqualifierProdNode[position, length, lhs, qualifier], stack];
RETURN [stack]
END;

Seequalifierprefixop: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
prefixop: PrefixOpNode;
prefixop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildQualifierprefixopProdNode[position, length, prefixop], stack];
RETURN [stack]
END;

Seequalifiertypeop: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeop: TypeOpNode;
typeop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildQualifiertypeopProdNode[position, length, typeop], stack];
RETURN [stack]
END;

Seequalifiersize: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifiersizeProdNode[position, length], stack];
RETURN [stack]
END;

Seequalifierbits: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifierbitsProdNode[position, length], stack];
RETURN [stack]
END;

Seequalifierbytes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifierbytesProdNode[position, length], stack];
RETURN [stack]
END;

Seequalifierunits: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifierunitsProdNode[position, length], stack];
RETURN [stack]
END;

Seequalifierwords: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifierwordsProdNode[position, length], stack];
RETURN [stack]
END;

Seequalifierapply: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
explist: ExpListNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
explist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildQualifierapplyProdNode[position, length, explist, optcatch], stack];
RETURN [stack]
END;

Seequalifierselect: 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[BuildQualifierselectProdNode[position, length, Id], stack];
RETURN [stack]
END;

Seequalifierindirect: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildQualifierindirectProdNode[position, length], stack];
RETURN [stack]
END;

Seeexitlistempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildExitListemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seeexitlistb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlistP: ExitListNode;
exitlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[exitlistP, stack];
RETURN [stack]
END;

Seeexitlistc: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlistP: ExitListNode;
exitlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[exitlistP, stack];
RETURN [stack]
END;

SeeexitlistPa: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exititem: ExitItemNode;
exititem _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExitListmoreProdNode[position, length, BuildExitListemptyProdNode[exititem.position, exititem.position - exititem.length], exititem], stack];
RETURN [stack]
END;

SeeexitlistPb: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlistP: ExitListNode;
exititem: ExitItemNode;
exititem _ NARROW[stack.first];
stack _ stack.rest;
exitlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExitListmoreProdNode[position, length, exitlistP, exititem], stack];
RETURN [stack]
END;

Seeexititem: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
idlist: IdListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
idlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExitItemProdNode[position, length, idlist, statement], stack];
RETURN [stack]
END;

Seeoptexptrash: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trash: JunkNode;
trash _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptExptrashProdNode[position, length], stack];
RETURN [stack]
END;

Seeoptexpexp: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptExpexpProdNode[position, length, exp], stack];
RETURN [stack]
END;

Seeoptexpempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildOptExpemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seecatchcase: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhslist: SignalListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
lhslist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCatchCaseProdNode[position, length, lhslist, statement], stack];
RETURN [stack]
END;

Seelhslistone: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSignalListoneProdNode[position, length, lhs], stack];
RETURN [stack]
END;

Seelhslistmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhslist: SignalListNode;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
lhslist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSignalListmoreProdNode[position, length, lhslist, lhs], stack];
RETURN [stack]
END;

Seeinitializationempty: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildInitializationemptyProdNode[position, length], stack];
RETURN [stack]
END;

Seeinitializationassignment: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
initvalue: InitialValueNode;
initvalue _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitializationassignmentProdNode[position, length, initvalue], stack];
RETURN [stack]
END;

Seeinitializationbinding: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
tilde: JunkNode;
initvalue: InitialValueNode;
initvalue _ NARROW[stack.first];
stack _ stack.rest;
tilde _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitializationbindingProdNode[position, length, initvalue], stack];
RETURN [stack]
END;

Seeinitvalueblock: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
procaccess: JunkNode;
trusted: JunkNode;
checked: CheckedNode;
inline: InlineNode;
block: BlockNode;
block _ NARROW[stack.first];
stack _ stack.rest;
inline _ NARROW[stack.first];
stack _ stack.rest;
checked _ NARROW[stack.first];
stack _ stack.rest;
trusted _ NARROW[stack.first];
stack _ stack.rest;
procaccess _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitialValueblockProdNode[position, length, checked, inline, block], stack];
RETURN [stack]
END;

Seeinitvaluecode: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildInitialValuecodeProdNode[position, length], stack];
RETURN [stack]
END;

Seeinitvaluec: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
procaccess: JunkNode;
trusted: JunkNode;
checked: CheckedNode;
codelist: CodeListNode;
codelist _ NARROW[stack.first];
stack _ stack.rest;
checked _ NARROW[stack.first];
stack _ stack.rest;
trusted _ NARROW[stack.first];
stack _ stack.rest;
procaccess _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitialValuemachinecodeProdNode[position, length, checked, codelist], stack];
RETURN [stack]
END;

Seeinitvalued: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
procaccess: JunkNode;
trusted: JunkNode;
checked: CheckedNode;
codelist: CodeListNode;
codelist _ NARROW[stack.first];
stack _ stack.rest;
checked _ NARROW[stack.first];
stack _ stack.rest;
trusted _ NARROW[stack.first];
stack _ stack.rest;
procaccess _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitialValuemachinecodeProdNode[position, length, checked, codelist], stack];
RETURN [stack]
END;

Seeinitvaluetrash: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trash: JunkNode;
trash _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitialValuetrashProdNode[position, length], stack];
RETURN [stack]
END;

Seeinitvalueexp: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInitialValueexpProdNode[position, length, exp], stack];
RETURN [stack]
END;

Seeprocaccess: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildJunkProdNode[position, length], stack];
RETURN [stack]
END;

Seeinlineyes: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildInlineyesProdNode[position, length], stack];
RETURN [stack]
END;

Seeinlineno: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildInlinenoProdNode[position, length], stack];
RETURN [stack]
END;

Seecodelistone: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
orderlist: OrderListNode;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCodeListoneProdNode[position, length, orderlist], stack];
RETURN [stack]
END;

Seecodelistmore: PROC [nodes: LIST OF REF ANY, position: INT, length: INT]
	RETURNS [LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
codelist: CodeListNode;
orderlist: OrderListNode;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
codelist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCodeListmoreProdNode[position, length, codelist, orderlist], stack];
RETURN [stack]
END;

END..