DIRECTORY
	ThreeC4BaseDecl1Def,
	ThreeC4RecFcnImplAbGramDef,
	ThreeC4Support,
	ThreeC4BaseDecl2Def;

ThreeC4RecFcnImplImpl2Impl: CEDAR PROGRAM IMPORTS ThreeC4BaseDecl1Def, ThreeC4Support, ThreeC4BaseDecl2Def EXPORTS ThreeC4RecFcnImplAbGramDef= 
BEGIN
OPEN ThreeC4BaseDecl1Def, ThreeC4RecFcnImplAbGramDef, ThreeC4Support, ThreeC4BaseDecl2Def;
RecExpressionropeProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionropeProdData ← NARROW[tree.data];
temp0 ← IntegerFromRope["1"];
END
END;

RecExpressionropeProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionropeProdData ← NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] ← tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] ← PartitionFirstName[varNames];
statementCode ← ConcatCode4[RopeCode1["%g ← ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 ← use;
temp4 ← nextTempX;
temp3 ← restNames;
temp2 ← valTypes;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

RecExpressionropeProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionropeProdData ← NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
types: TypeListNode;
types ← BuildOneTypeList[LookUpType[context, BuildRopeName["ROPE"]]];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode ← BuildErrorCode["rope is not a tree"];
} ELSE {firstArgCode ← BuildEmptyCode[];
};
argCode ← RopeCode1["\"%g\"", CodeFill[RopeCode[RopeFromRopeNode[treeData.Rope]]]];
temp6 ← FakeUsageCopy[usage];
temp5 ← FakeCopyInteger[firstTempX];
temp4 ← types;
temp3 ← firstArgCode;
temp2 ← argCode;
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END;
END
END;

RecExpressionnumbProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionnumbProdData ← NARROW[tree.data];
temp0 ← IntegerFromRope["1"];
END
END;

RecExpressionnumbProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionnumbProdData ← NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] ← tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] ← PartitionFirstName[varNames];
statementCode ← ConcatCode4[RopeCode1["%g ← ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 ← use;
temp4 ← nextTempX;
temp3 ← restNames;
temp2 ← valTypes;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

RecExpressionnumbProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionnumbProdData ← NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
types: TypeListNode;
types ← BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode ← BuildErrorCode["number is not a tree"];
} ELSE {firstArgCode ← BuildEmptyCode[];
};
argCode ← RopeCode[RopeFromNonNegIntegerNode[treeData.NonNegInteger]];
temp6 ← FakeUsageCopy[usage];
temp5 ← FakeCopyInteger[firstTempX];
temp4 ← types;
temp3 ← firstArgCode;
temp2 ← argCode;
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END;
END
END;

RecExpressionsourcePositionProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourcePositionProdData ← NARROW[tree.data];
temp0 ← IntegerFromRope["1"];
END
END;

RecExpressionsourcePositionProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourcePositionProdData ← NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] ← tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] ← PartitionFirstName[varNames];
statementCode ← ConcatCode4[RopeCode1["%g ← ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 ← use;
temp4 ← nextTempX;
temp3 ← restNames;
temp2 ← valTypes;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

RecExpressionsourcePositionProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourcePositionProdData ← NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
types: TypeListNode;
check: BOOLEAN;
vType: TypeNode;
unused: MesaCodeNode;
[vType, unused] ← treeData.ModId.procs.FormValueInfo[treeData.ModId, context];
check ← CompareValTypeWithVarType[vType, LookUpType[context, BuildRopeName["Tree"]]];
types ← BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode ← BuildErrorCode["sourcePosition is not a tree"];
} ELSE {firstArgCode ← BuildEmptyCode[];
};
argCode ← RopeCode1["%g.position", NameFill[treeData.ModId.procs.FormName[treeData.ModId]]];
temp6 ← FakeUsageCopy[usage];
temp5 ← FakeCopyInteger[firstTempX];
temp4 ← types;
temp3 ← firstArgCode;
temp2 ← argCode;
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END;
END
END;

RecExpressionsourceLengthProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourceLengthProdData ← NARROW[tree.data];
temp0 ← IntegerFromRope["1"];
END
END;

RecExpressionsourceLengthProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourceLengthProdData ← NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] ← tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] ← PartitionFirstName[varNames];
statementCode ← ConcatCode4[RopeCode1["%g ← ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 ← use;
temp4 ← nextTempX;
temp3 ← restNames;
temp2 ← valTypes;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

RecExpressionsourceLengthProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionsourceLengthProdData ← NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
types: TypeListNode;
check: BOOLEAN;
vType: TypeNode;
unused: MesaCodeNode;
[vType, unused] ← treeData.ModId.procs.FormValueInfo[treeData.ModId, context];
check ← CompareValTypeWithVarType[vType, LookUpType[context, BuildRopeName["Tree"]]];
types ← BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode ← BuildErrorCode["sourceLength is not a tree"];
} ELSE {firstArgCode ← BuildEmptyCode[];
};
argCode ← RopeCode1["%g.length", NameFill[treeData.ModId.procs.FormName[treeData.ModId]]];
temp6 ← FakeUsageCopy[usage];
temp5 ← FakeCopyInteger[firstTempX];
temp4 ← types;
temp3 ← firstArgCode;
temp2 ← argCode;
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END;
END
END;

RecExpSeqemptyProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp0 ← IntegerFromRope["0"];
END
END;

RecExpSeqemptyProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp5 ← FakeUsageCopy[usage];
temp4 ← FakeCopyInteger[firstTempX];
temp3 ← varNames;
temp2 ← BuildEmptyTypeList[];
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END
END;

RecExpSeqemptyProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
temp6 ← FakeUsageCopy[usage];
temp5 ← FakeCopyInteger[firstTempX];
temp4 ← BuildEmptyTypeList[];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {temp3 ← BuildErrorCode["expecting at least a tree argument"];
} ELSE {temp3 ← BuildEmptyCode[];
};
temp2 ← BuildEmptyCode[];
temp1 ← BuildEmptyCode[];
temp0 ← BuildEmptyCode[];
END
END;

RecExpSeqoneProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqoneProdData ← NARROW[tree.data];
temp0 ← treeData.RecExpression.procs.CountVals[treeData.RecExpression, context];
END
END;

RecExpSeqoneProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqoneProdData ← NARROW[tree.data];
[temp0, temp1, temp2, temp3, temp4, temp5] ← treeData.RecExpression.procs.CompForVars[treeData.RecExpression, varNames, firstTempX, context, usage];
END
END;

RecExpSeqoneProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqoneProdData ← NARROW[tree.data];
[temp0, temp1, temp2, temp3, temp4, temp5, temp6] ← treeData.RecExpression.procs.CompForArgs[treeData.RecExpression, treeCallFlag, firstTempX, context, usage];
END
END;

RecExpSeqmanyProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqmanyProdData ← NARROW[tree.data];
temp0 ← Add[treeData.RecExpSeqb.procs.CountVals[treeData.RecExpSeqb, context], treeData.RecExpSeqa.procs.CountVals[treeData.RecExpSeqa, context]];
END
END;

RecExpSeqmanyProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqmanyProdData ← NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
varTypes: TypeListNode;
bDeclCode: MesaCodeNode;
bStatementCode: MesaCodeNode;
bVarTypes: TypeListNode;
bRestNames: NameListNode;
bNextTempX: IntegerNode;
use2: UsageNode;
aDeclCode: MesaCodeNode;
aStatementCode: MesaCodeNode;
aVarTypes: TypeListNode;
aRestNames: NameListNode;
aNextTempX: IntegerNode;
use1: UsageNode;
[aDeclCode, aStatementCode, aVarTypes, aRestNames, aNextTempX, use1] ← treeData.RecExpSeqa.procs.CompForVars[treeData.RecExpSeqa, varNames, firstTempX, context, usage];
[bDeclCode, bStatementCode, bVarTypes, bRestNames, bNextTempX, use2] ← treeData.RecExpSeqb.procs.CompForVars[treeData.RecExpSeqb, aRestNames, aNextTempX, context, use1];
varTypes ← ConcatTypeLists[aVarTypes, bVarTypes];
statementCode ← ConcatCode2[bStatementCode, aStatementCode];
varDeclCode ← ConcatCode2[bDeclCode, aDeclCode];
temp5 ← use2;
temp4 ← bNextTempX;
temp3 ← bRestNames;
temp2 ← varTypes;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

RecExpSeqmanyProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpSeqmanyProdData ← NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
argCode: MesaCodeNode;
argTypes: TypeListNode;
bDeclCode: MesaCodeNode;
bStatementCode: MesaCodeNode;
bArgCode: MesaCodeNode;
unused: MesaCodeNode;
bVarTypes: TypeListNode;
bNextTempX: IntegerNode;
use2: UsageNode;
aDeclCode: MesaCodeNode;
aStatementCode: MesaCodeNode;
aArgCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
aVarTypes: TypeListNode;
aNextTempX: IntegerNode;
use1: UsageNode;
[aDeclCode, aStatementCode, aArgCode, firstArgCode, aVarTypes, aNextTempX, use1] ← treeData.RecExpSeqa.procs.CompForArgs[treeData.RecExpSeqa, treeCallFlag, firstTempX, context, usage];
[bDeclCode, bStatementCode, bArgCode, unused, bVarTypes, bNextTempX, use2] ← treeData.RecExpSeqb.procs.CompForArgs[treeData.RecExpSeqb, TreeCallFlag.no, aNextTempX, context, use1];
argTypes ← ConcatTypeLists[aVarTypes, bVarTypes];
argCode ← ConcatCode3[aArgCode, RopeCode[", "], bArgCode];
statementCode ← ConcatCode2[bStatementCode, aStatementCode];
varDeclCode ← ConcatCode2[bDeclCode, aDeclCode];
temp6 ← use2;
temp5 ← bNextTempX;
temp4 ← argTypes;
temp3 ← firstArgCode;
temp2 ← argCode;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

WhereExpSeqoneProdCompWhere: PUBLIC PROC[ref: REF ANY, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: IntegerNode, temp3: LookupContextNode, temp4: UsageNode] =
BEGIN
tree: WhereExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: WhereExpSeqoneProdData ← NARROW[tree.data];
BEGIN
nestedContext: LookupContextNode;
varDeclCode: MesaCodeNode;
use: UsageNode;
expVarDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
expTypes: TypeListNode;
expRestNames: NameListNode;
nextTempX: IntegerNode;
use1: UsageNode;
[expVarDeclCode, statementCode, expTypes, expRestNames, nextTempX, use1] ← treeData.RecExpression.procs.CompForVars[treeData.RecExpression, treeData.IdList.procs.FormNameList[treeData.IdList], firstTempX, context, usage];
use ← RecordTypesUse[use1, expTypes];
varDeclCode ← ConcatCode2[treeData.IdList.procs.FormVarDeclCode[treeData.IdList, expTypes], expVarDeclCode];
nestedContext ← RecordVarSeq[context, treeData.IdList.procs.FormNameList[treeData.IdList], expTypes];
temp4 ← use;
temp3 ← nestedContext;
temp2 ← nextTempX;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

WhereExpSeqmanyProdCompWhere: PUBLIC PROC[ref: REF ANY, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: IntegerNode, temp3: LookupContextNode, temp4: UsageNode] =
BEGIN
tree: WhereExpSeqNode← NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: WhereExpSeqmanyProdData ← NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
aVarDeclCode: MesaCodeNode;
aStatementCode: MesaCodeNode;
nextTempX: IntegerNode;
nestedContext: LookupContextNode;
use2: UsageNode;
bVarDeclCode: MesaCodeNode;
bStatementCode: MesaCodeNode;
nextTempX1: IntegerNode;
nestedContext1: LookupContextNode;
use1: UsageNode;
[bVarDeclCode, bStatementCode, nextTempX1, nestedContext1, use1] ← treeData.WhereExpSeqb.procs.CompWhere[treeData.WhereExpSeqb, firstTempX, context, usage];
[aVarDeclCode, aStatementCode, nextTempX, nestedContext, use2] ← treeData.WhereExpSeqa.procs.CompWhere[treeData.WhereExpSeqa, nextTempX1, nestedContext1, use1];
statementCode ← ConcatCode2[bStatementCode, aStatementCode];
varDeclCode ← ConcatCode2[aVarDeclCode, bVarDeclCode];
temp4 ← use2;
temp3 ← nestedContext;
temp2 ← nextTempX;
temp1 ← statementCode;
temp0 ← varDeclCode;
END;
END
END;

END..