-- SaffronTypeCompileImpl.mesa
 -- Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
 -- Generated by Rauen.pa at September 1, 1988 3:12:56 pm PDT
 --  using ThreeCasabaFour [1.2] of June 1, 1987 6:00:00 pm PDT

DIRECTORY
	SaffronAG6aDef,
	SaffronAG6bDef,
	ThreeC4Support,
	SaffronBaseDef,
	BigIntegers,
	SaffronATDef;

SaffronTypeCompileImpl: CEDAR PROGRAM IMPORTS ThreeC4Support, SaffronBaseDef EXPORTS SaffronAG6aDef, SaffronAG6bDef= 
BEGIN
OPEN SaffronAG6aDef, SaffronAG6bDef, ThreeC4Support, SaffronBaseDef, BigIntegers, SaffronATDef;
TypeExprecordProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on RECORD types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprecordProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on RECORD types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprecordProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of RECORD not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprecordProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on RECORD types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprecordProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on RECORD types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprecordProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprecordProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of RECORD not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpunionProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on UNION types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpunionProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on UNION types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpunionProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of UNION not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpunionProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on UNION types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpunionProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on UNION types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpunionProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpunionProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of UNION not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpsequenceProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on SEQUENCE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpsequenceProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on SEQUENCE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpsequenceProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of SEQUENCE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpsequenceProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on SEQUENCE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpsequenceProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on SEQUENCE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpsequenceProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsequenceProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of SEQUENCE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpenumProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of Enumerated not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpenumProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of Enumerated not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpenumProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Enumerated not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpenumProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of Enumerated not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpenumProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of Enumerated not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpenumProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpenumProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Enumerated not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefanyProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF ANY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefanyProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF ANY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefanyProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF ANY not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefanyProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF ANY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefanyProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF ANY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefanyProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprefanyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF ANY not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefunspecifiedProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF UNSPECIFIED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefunspecifiedProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF UNSPECIFIED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefunspecifiedProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF UNSPECIFIED not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprefunspecifiedProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on REF UNSPECIFIED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefunspecifiedProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on REF UNSPECIFIED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprefunspecifiedProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of REF UNSPECIFIED not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExptypeidProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.CompileLastOfTypeExpression[treeData.TypeId, contextTree, cs, targetType];
END
END;

TypeExptypeidProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.CompileFirstOfTypeExpression[treeData.TypeId, contextTree, cs, targetType];
END
END;

TypeExptypeidProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.CompileSizeOfTypeExpression[treeData.TypeId, contextTree, cs, targetType];
END
END;

TypeExptypeidProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.EvaluateLastOfTypeExpression[treeData.TypeId, lc, fl, cs, targetType];
END
END;

TypeExptypeidProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.EvaluateFirstOfTypeExpression[treeData.TypeId, lc, fl, cs, targetType];
END
END;

TypeExptypeidProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeidProdData _ NARROW[tree.data];
temp0 _ treeData.TypeId.procs.EvaluateSizeOfTypeExpression[treeData.TypeId, lc, fl, cs, targetType];
END
END;

TypeExpsubrangeProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.CompileLastOfTypeExpression[treeData.Subrange, contextTree, cs, targetType];
END
END;

TypeExpsubrangeProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.CompileFirstOfTypeExpression[treeData.Subrange, contextTree, cs, targetType];
END
END;

TypeExpsubrangeProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.CompileSizeOfTypeExpression[treeData.Subrange, contextTree, cs, targetType];
END
END;

TypeExpsubrangeProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.EvaluateLastOfTypeExpression[treeData.Subrange, lc, fl, cs, targetType];
END
END;

TypeExpsubrangeProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.EvaluateFirstOfTypeExpression[treeData.Subrange, lc, fl, cs, targetType];
END
END;

TypeExpsubrangeProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpsubrangeProdData _ NARROW[tree.data];
temp0 _ treeData.Subrange.procs.EvaluateSizeOfTypeExpression[treeData.Subrange, lc, fl, cs, targetType];
END
END;

TypeExppointerProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on POINTER types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppointerProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on POINTER types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppointerProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of POINTER not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExppointerProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on POINTER types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppointerProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on POINTER types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppointerProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppointerProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of POINTER not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpvarProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on VAR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpvarProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on VAR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpvarProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of VAR not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpvarProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on VAR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpvarProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on VAR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpvarProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpvarProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of VAR not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExplistProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on LIST types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplistProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on LIST types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplistProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of LIST not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExplistProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on LIST types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplistProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on LIST types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplistProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplistProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of LIST not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExparrayProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on ARRAY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExparrayProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on ARRAY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExparrayProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of ARRAY not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExparrayProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on ARRAY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExparrayProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on ARRAY types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExparrayProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExparrayProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of ARRAY not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpdescriptorProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on DESCRIPTOR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpdescriptorProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on DESCRIPTOR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpdescriptorProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of DESCRIPTOR not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpdescriptorProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on DESCRIPTOR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpdescriptorProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on DESCRIPTOR types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpdescriptorProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpdescriptorProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of DESCRIPTOR not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExptransferProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on Transfer types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptransferProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on Transfer types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptransferProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Transfer type not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExptransferProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on Transfer types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptransferProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on Transfer types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptransferProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptransferProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Transfer type not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprelativeProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on RELATIVE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprelativeProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on RELATIVE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprelativeProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of RELATIVE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExprelativeProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on RELATIVE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprelativeProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on RELATIVE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExprelativeProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExprelativeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of RELATIVE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpzoneProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on ZONE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpzoneProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on ZONE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpzoneProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of ZONE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpzoneProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on ZONE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpzoneProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on ZONE types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpzoneProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpzoneProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of ZONE not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExplongProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of LONG not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplongProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of LONG not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplongProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of LONG not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExplongProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of LONG not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplongProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of LONG not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExplongProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExplongProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of LONG not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpframeProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on FRAME types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpframeProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on FRAME types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpframeProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of FRAME not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExpframeProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on FRAME types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpframeProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on FRAME types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExpframeProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExpframeProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of FRAME not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExppaintedProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on PAINTED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppaintedProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on PAINTED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppaintedProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of PAINTED not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExppaintedProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on PAINTED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppaintedProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on PAINTED types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExppaintedProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExppaintedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of PAINTED not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExptypeapplyProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on TypeApply types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptypeapplyProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on TypeApply types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptypeapplyProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of TypeApply not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeExptypeapplyProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST is not a valid operation on TypeApply types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptypeapplyProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST is not a valid operation on TypeApply types."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeExptypeapplyProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeExpNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeExptypeapplyProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of TypeApply not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

SubrangenamedProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of Named subrange not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

SubrangenamedProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of Named subrange not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

SubrangenamedProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Named subrange not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

SubrangenamedProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of Named subrange not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

SubrangenamedProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of Named subrange not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

SubrangenamedProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangenamedProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of Named subrange not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

SubrangeunnamedProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.CompileLastOfTypeExpression[treeData.Interval, contextTree, cs, targetType];
END
END;

SubrangeunnamedProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.CompileFirstOfTypeExpression[treeData.Interval, contextTree, cs, targetType];
END
END;

SubrangeunnamedProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.CompileSizeOfTypeExpression[treeData.Interval, contextTree, cs, targetType];
END
END;

SubrangeunnamedProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.EvaluateLastOfTypeExpression[treeData.Interval, lc, fl, cs, targetType];
END
END;

SubrangeunnamedProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.EvaluateFirstOfTypeExpression[treeData.Interval, lc, fl, cs, targetType];
END
END;

SubrangeunnamedProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	SubrangeNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	SubrangeunnamedProdData _ NARROW[tree.data];
temp0 _ treeData.Interval.procs.EvaluateSizeOfTypeExpression[treeData.Interval, lc, fl, cs, targetType];
END
END;

IntervalccProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
temp0 _ Last[targetType];
END
END;

IntervalccProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
temp0 _ First[targetType];
END
END;

IntervalccProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalccProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
temp0 _ Last[targetType];
END
END;

IntervalccProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
temp0 _ First[targetType];
END
END;

IntervalccProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalccProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalcoProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
temp0 _ Pred[Last[targetType]];
END
END;

IntervalcoProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
temp0 _ First[targetType];
END
END;

IntervalcoProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalcoProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
temp0 _ Pred[Last[targetType]];
END
END;

IntervalcoProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
temp0 _ First[targetType];
END
END;

IntervalcoProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalcoProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalocProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
temp0 _ Last[targetType];
END
END;

IntervalocProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
temp0 _ Succ[First[targetType]];
END
END;

IntervalocProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalocProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
temp0 _ Last[targetType];
END
END;

IntervalocProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
temp0 _ Succ[First[targetType]];
END
END;

IntervalocProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalocProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalooProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
temp0 _ Pred[Last[targetType]];
END
END;

IntervalooProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
temp0 _ Succ[First[targetType]];
END
END;

IntervalooProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

IntervalooProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
temp0 _ Pred[Last[targetType]];
END
END;

IntervalooProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
temp0 _ Succ[First[targetType]];
END
END;

IntervalooProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	IntervalNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	IntervalooProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of interval not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeIdidProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
access:	AccessValNode;
tgn:	TypeGraphNodeNode;
field:	FieldNode;
field _ LookupNameInContextRib[treeData.Id, Rib[contextTree]];
[access, tgn] _ DemandTypeDeclarationField[field];
temp0 _ Last[tgn];
END;
END
END;

TypeIdidProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
access:	AccessValNode;
tgn:	TypeGraphNodeNode;
field:	FieldNode;
field _ LookupNameInContextRib[treeData.Id, Rib[contextTree]];
[access, tgn] _ DemandTypeDeclarationField[field];
temp0 _ First[tgn];
END;
END
END;

TypeIdidProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of id not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeIdidProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
access:	AccessValNode;
tgn:	TypeGraphNodeNode;
field2:	FieldNode;
field1:	FieldNode;
field1 _ LookupNameInFieldList[fl, treeData.Id];
IF FieldExists[field1] THEN {field2 _ field1;
} ELSE {field2 _ LookupNameInContextRib[treeData.Id, ParentRib[lc]];
};
[access, tgn] _ DemandTypeDeclarationField[field2];
temp0 _ Last[tgn];
END;
END
END;

TypeIdidProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
access:	AccessValNode;
tgn:	TypeGraphNodeNode;
field2:	FieldNode;
field1:	FieldNode;
field1 _ LookupNameInFieldList[fl, treeData.Id];
IF FieldExists[field1] THEN {field2 _ field1;
} ELSE {field2 _ LookupNameInContextRib[treeData.Id, ParentRib[lc]];
};
[access, tgn] _ DemandTypeDeclarationField[field2];
temp0 _ First[tgn];
END;
END
END;

TypeIdidProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdidProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of id not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeIdqualifierProdCompileLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of TypeId.qualifier not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeIdqualifierProdCompileFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of TypeId.qualifier not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeIdqualifierProdCompileSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, contextTree: ContextTreeNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of TypeId.qualifier not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

TypeIdqualifierProdEvaluateLastOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["LAST of TypeId.qualifier not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeIdqualifierProdEvaluateFirstOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: ValueNode] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["FIRST of TypeId.qualifier not implemented yet."];
temp0 _ MakeDummy[""];
END;
END
END;

TypeIdqualifierProdEvaluateSizeOfTypeExpression:	PUBLIC PROC[ref: REF ANY, lc: LocalContextNode, fl: FieldListNode, cs: CompilerStateNode, targetType: TypeGraphNodeNode] RETURNS[temp0: BigINT] =
BEGIN
tree:	TypeIdNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData:	TypeIdqualifierProdData _ NARROW[tree.data];
BEGIN
err:	BOOLEAN;
err _ Error["SIZE of TypeId.qualifier not implemented yet."];
temp0 _ DummyBigINT[];
END;
END
END;

END..