Include [SaffronAG, SaffronTreeDecls, SaffronBaseDecls];
SaffronMakeType: Module = Begin
for Top.modulep:	AbstractProduction [ ModuleP ]
let DoTop[tree, fileName, env] _ MakeEnvironment [ModuleP, fileName, env]
let Explore [tree, fileName, env] _ Explore [ModuleP, fileName, env]
;
for ModuleP.impl:	AbstractProduction [ Directory, IdentList, Cedar, ProgHead, Checked, Block ]
let MakeEnvironment [tree, fileName, env] _ <env, interface>
where env _ AddInterfaceToEnvironment [CreateEmptyEnvironment [], "", interface]
where interface _ CreateInterfaceFromContextTree [ct, EmptyNameSequence[]]
where  ct _ EmptyContextTree [ RootContextRib []]
let Explore [tree, fileName, env] _ <env, interface>
where env _ AddInterfaceToEnvironment [CreateEmptyEnvironment [], "", interface]
where interface _ CreateInterfaceFromContextTree [ct, EmptyNameSequence[]]
where  ct _ EmptyContextTree [ RootContextRib []]
;
for ModuleP.def:	AbstractProduction [ Directory, IdentList, Cedar, DefHead, DefBody ]
let MakeEnvironment [tree, fileName, env] _ <env2, interface>
where env2 _ AddInterfaceToEnvironment [env1, fileName, interface]
where interface _ CreateInterfaceFromContextTree [contextTree, nameSequence]
where contextTree _ MakeContextTree [DefBody, contextRib, paintRecords]
where contextRib _ FreezeLocalContext [localContext]
where paintRecords _ True []
where nameSequence _ MakeNameSequence [IdentList]
where <localContext, env1> _ ProcessDirectoryClause [Directory, rootContext, env]
where rootContext _ CreateEmptyContext [RootContextRib []] 
let Explore [tree, fileName, env] _ <env2, interface>
where env2 _ AddInterfaceToEnvironment [env1, fileName, interface]
where interface _ CreateInterfaceFromContextTree [ct, EmptyNameSequence[]]
where  ct _ EmptyContextTree [ RootContextRib []]
where env1 _ ExploreDirectoryClause [Directory, env]
;
for Directory.empty:	AbstractProduction [ ]
let ProcessDirectoryClause [tree, localContext, env] _
<FakeDamageContext [localContext], FakeDamageEnvironment [env]>
let ExploreDirectoryClause [tree, env] _ FakeDamageEnvironment [env]
;
for Directory.more:	AbstractProduction [ Directory, IncludeItem ]
let ProcessDirectoryClause [tree, localContext, env] _  
ProcessDirectoryClause [IncludeItem, 
									ProcessDirectoryClause [Directory, localContext, env]]
let ExploreDirectoryClause [tree, env] _  
ExploreDirectoryClause [IncludeItem, 
									ExploreDirectoryClause [Directory, env]]
;
for IncludeItem.fromp:	AbstractProduction [ Id, String, Using ]
let ProcessDirectoryClause [tree, localContext, env] _ <localContext3, env2>
where localContext3 _ AddArcFromLVTGNToTGN [localContext2, lvTgn,
											NullAccessVal[], interfaceTgn, NullDefaultVal []] 
where <localContext2, lvTgn> _ 
							CreateLocallyVisibleTGN [localContext1, Id, NullAccessVal[]]					
where <localContext1, interfaceTgn> _ MakeInterfaceTGN [Using, localContext, interface]
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( MakeEnvironment [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromString [String]
let ExploreDirectoryClause [tree, env] _ env2
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( Explore [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromString [String]
;
for IncludeItem.type:	AbstractProduction [ Id, Using ]
let ProcessDirectoryClause [tree, localContext, env] _ <localContext3, env2>
where localContext3 _ AddArcFromLVTGNToTGN [localContext2, lvTgn,
											NullAccessVal[], interfaceTgn, NullDefaultVal []] 
where <localContext2, lvTgn> _ 
							CreateLocallyVisibleTGN [localContext1, Id, NullAccessVal[]]					
where <localContext1, interfaceTgn> _ MakeInterfaceTGN [Using, localContext, interface]
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( MakeEnvironment [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id]
let ExploreDirectoryClause [tree, env] _ env2
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( Explore [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id]
;
for IncludeItem.plain:	AbstractProduction [ Id, Using ]
let ProcessDirectoryClause [tree, localContext, env] _ <localContext3, env2>
where localContext3 _ AddArcFromLVTGNToTGN [localContext2, lvTgn,
											NullAccessVal[], interfaceTgn, NullDefaultVal []] 
where <localContext2, lvTgn> _ 
							CreateLocallyVisibleTGN [localContext1, Id, NullAccessVal[]]					
where <localContext1, interfaceTgn> _ MakeInterfaceTGN [Using, localContext, interface]
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( MakeEnvironment [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id]
let ExploreDirectoryClause [tree, env] _ env2
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( Explore [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id]
;
for IncludeItem.typeandid:	AbstractProduction [ Id.local, Id.global, Using ]
let ProcessDirectoryClause [tree, localContext, env] _ <localContext3, env2>
where localContext3 _ AddArcFromLVTGNToTGN [localContext2, lvTgn,
											NullAccessVal[], interfaceTgn, NullDefaultVal []] 
where <localContext2, lvTgn> _ 
						CreateLocallyVisibleTGN [localContext1, Id.local, NullAccessVal[]]					
where <localContext1, interfaceTgn> _ MakeInterfaceTGN [Using, localContext, interface]
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( MakeEnvironment [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id.local]
let ExploreDirectoryClause [tree, env] _ env2
where <env2, interface> _ 
if IsInterfaceInEnv [env, fileName]
then ( <env1, LookupInterfaceInEnv [env1, fileName]>
where env1 _ FakeDamageEnvironment [env] )
else ( Explore [defFile, fileName, env]
where defFile _ ModulePVal [ReadDefFile [fileName]] )
where fileName _ RopeFromId [Id.local]
;
for Using.restricted:	AbstractProduction [ IdList ]
let MakeInterfaceTGN [tree, localContext, interface] _ 
<AddIdsToInterfaceTGN [IdList, localContext1, interfaceTGN, interface], interfaceTGN>
where <localContext1, interfaceTGN> _ CreateEmptyInterfaceTGN [localContext]
;
for Using.nothing:	AbstractProduction [ ]
let MakeInterfaceTGN [tree, localContext, interface] _ 
													CreateEmptyInterfaceTGN [localContext]
;
for Using.unrestricted:	AbstractProduction [ ]
let MakeInterfaceTGN [tree, localContext, interface] _
CreateInterfaceTGNFromInterface [localContext, interface]
;
for DefBody:	AbstractProduction [ BindList, DecList ]
let MakeContextTree [tree, contextRib, paintRecords] _
MakeBindListContextTreeWithDefBody [BindList, defBodyPTree, contextRib, paintRecords]
where defBodyPTree _ DefBodyPTreeVal [tree]
let MakeContextTree1 [tree, rib, paintRecords] _
     HangContextsFromContextTree [DecList, thisScopeContextTree, newRib, paintRecords]
where thisScopeContextTree _ EmptyContextTree [newRib]
where newRib _ FreezeLocalContext [thisScopeLocalContext]
where thisScopeLocalContext _ UpdateLocalContext [DecList, localContext, paintRecords ]
where localContext _ CreateEmptyContext [rib]
;
for TypeExp.record:	AbstractProduction [ MachineDependent, Monitored, RecList ]
let MakeType[tree, localContext, paintRecords] _ <localContext4, newTgn>
where  <localContext4, newTgn> _
CreateRecordTGN [ localContext3, paint,	machineDependent, monitored, frozenFieldList] 
where <localContext3, frozenFieldList> _ FreezeFieldList [localContext2, fieldList]
where <localContext2, fieldList> _ MakeFieldList [RecList, localContext1, paintRecords]
where <localContext1, paint> _
if paintRecords then GetUniquePaint [localContext]
	    else GetUnpaintedPaint [localContext]
where machineDependent _ GetBooleanVal [MachineDependent]
where monitored _ GetBooleanVal [Monitored]
;
for TypeExp.union:	AbstractProduction [ Tag, VariantList ]
let MakeType[tree, localContext, paintRecords] _
CreateVariantPartTGN [localContext3, variantFlavor, tagTypeTgn1, unionList]
where variantFlavor _ MakeVariantFlavor [Tag]
where <localContext3, tagTypeTgn1> _ 
if isStarTagType
then MakeStarTagType [VariantList, localContext2] 
else <FakeDamageContext [localContext2], tagTypeTgn>
where <localContext2, tagTypeTgn, isStarTagType> _ 
MakeTagType [Tag, localContext1, paintRecords]
where <localContext1, unionList> _ 
MakeUnionList [VariantList, localContext, paintRecords]
;

for TypeExp.sequence:	AbstractProduction [ Packed, Tag, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ 
CreateSequenceTGN [localContext2, packed, GetSequenceTagInfo [Tag], tagTypeTgn, tgn]
where  packed _ GetBooleanVal [Packed]
where  x _ if isStarTagType then Error ["Sequence Tag must not be a star"] else True[]
where <localContext2, tagTypeTgn, isStarTagType> _ 
MakeTagType [Tag, localContext1, paintRecords]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]

;
for TypeExp.enum:	AbstractProduction [ MachineDependent, ElementList ]
let MakeType[tree, localContext, paintRecords] _ MakeElementList [ElementList, localContext, machineDependent]
where machineDependent _ GetBooleanVal [MachineDependent]
;

for TypeExp.ref:	AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords] _
		CreateRefTGN [localContext1, readOnly, referentTgn]
where <localContext1, referentTgn> _ MakeType [TypeExp, localContext, paintRecords]
where readOnly _ GetBooleanVal [ReadOnly]
;

for TypeExp.refany:	AbstractProduction [ ReadOnly ]
let MakeType[tree, localContext, paintRecords] _
											CreateRefTGN [localContext1, readOnly, topTgn] 
where topTgn _ FindTopTGN [localContext1]
where localContext1 _ FakeDamageContext [localContext]
where readOnly _ GetBooleanVal [ReadOnly]
;
for TypeExp.refunspecified:	AbstractProduction [ ]
let MakeType[tree, localContext, paintRecords] _ 
											CreateRefTGN [localContext1, readOnly, topTgn] 
where topTgn _ FindTopTGN [localContext1]
where localContext1 _ FakeDamageContext [localContext]
where readOnly _ False []
;
for TypeExp.typeid:	AbstractProduction [ TypeId ]
let MakeType[tree, localContext, paintRecords] _
												MakeType [TypeId, localContext, paintRecords] 
;

for TypeExp.subrange:	AbstractProduction [ Subrange ]
let MakeType[tree, localContext, paintRecords] _
												MakeType[Subrange, localContext, paintRecords]
;

for TypeExp.pointer:	AbstractProduction [ Ordered, Base, PointerType ]
let MakeType[tree, localContext, paintRecords] _  
					CreatePointerTGN [localContext1, ordered, base, bounds, readOnly, tgn]
where ordered _ GetBooleanVal [Ordered]
where base _ GetBooleanVal [Base]
where <localContext1, bounds, readOnly, tgn> _
			GetPointerTypeInfo [PointerType, localContext, paintRecords]
;

for TypeExp.var:	AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords] _ CreateVarTGN [localContext1, tgn]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
;

for TypeExp.list:	AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ 
		CreateListTGN [localContext1, readOnly, itemTgn]
where <localContext1, itemTgn> _ MakeType [TypeExp, localContext, paintRecords]
where readOnly _ GetBooleanVal [ReadOnly]
;

for TypeExp.array:	AbstractProduction [ Packed, OptType, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ 
								CreateArrayTGN [localContext2, packed, indexTgn, itemTgn]
where <localContext2, itemTgn> _ MakeType [TypeExp, localContext1, paintRecords]
where <localContext1, indexTgn> _ MakeType [OptType, localContext, paintRecords]
where packed _ GetBooleanVal [Packed]
;

for TypeExp.descriptor:	AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ 
											CreateDescriptorTGN [localContext1, readOnly, tgn]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
where readOnly _ GetBooleanVal [ReadOnly]
;

for TypeExp.transfer:	AbstractProduction [ Safe, TransferMode, Arguments ]
let MakeType[tree, localContext, paintRecords] _ 
				CreateTransferTGN [localContext1, safe, transferMode, fflInput, fflOutput]
where <localContext1, fflInput, fflOutput> _
							MakeArgumentLists [Arguments, localContext, paintRecords]
where transferMode _ MakeTransferMode [TransferMode]
where safe _ GetBooleanVal [Safe]
;

for TypeExp.relative:	AbstractProduction [ TypeId, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ 
										CreateRelativeTGN [localContext2, baseTgn, tgn]
where <localContext2, tgn> _ MakeType [TypeExp, localContext1, paintRecords]
where <localContext1, baseTgn> _ LookupTypeId [TypeId, localContext]
;

for TypeExp.zone:	AbstractProduction [ Uncounted ]
let MakeType[tree, localContext, paintRecords] _ 
							CreateZoneTGN [localContext, GetBooleanVal [Uncounted]]
;

for TypeExp.long:	AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords] _ CreateLongTGN [localContext1, tgn]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
;

for TypeExp.frame:	AbstractProduction [ Id ]
let MakeType[tree, localContext, paintRecords] _
											<localContext1, FindFrameTGN [localContext1, Id]>
where localContext1 _ FakeDamageContext [localContext]
;

for TypeExp.painted:	AbstractProduction [ TypeId, TypeExp ]
let MakeType[tree, localContext, paintRecords] _ <c, n> 
where n _ FindBottomTGN[c]
where c _ FakeDamageContext [localContext]
where x _ Error [" Unimplemented Construct"]
;

for TypeExp.typeapply:	AbstractProduction [ TypeApply ]
let MakeType[tree, localContext, paintRecords] _ 
									MakeType [TypeApply, localContext, paintRecords]
;
for TypeApply.one:	AbstractProduction [ TypeId, Exp ]
let MakeType[tree, localContext, paintRecords] _ 
CreateSpecianatedTGNUsingExp [localContext1, tgn, ExpPTreeVal [Exp]]
where <localContext1, tgn> _ LookupTypeId [TypeId, localContext]
;
for TypeApply.morelengths:	AbstractProduction [ TypeApply, Exp ]
let MakeType[tree, localContext, paintRecords] _ 
CreateSpecianatedTGNUsingExp [localContext1, tgn, ExpPTreeVal [Exp]]
where <localContext1, tgn> _ MakeType [TypeApply, localContext, paintRecords]
;
for TypeApply.moreids:	AbstractProduction [ TypeApply, Id ]
let MakeType[tree, localContext, paintRecords] _ 
CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> _ MakeType [TypeApply, localContext, paintRecords]
;
for TypeId.id:	AbstractProduction [ Id ]
let MakeType[tree, localContext, paintRecords] _ <localContext1, tgn>
  where localContext1 _ FakeDamageContext [localContext]
  where tgn _ FindLocallyVisibleTGN [ localContext, Id ]
let LookupTypeId [tree, localContext] _<localContext1, tgn>
  where localContext1 _ FakeDamageContext [localContext]
  where tgn _ FindLocallyVisibleTGN [ localContext, Id ]
;

for TypeId.qualifier:	AbstractProduction [ TypeId, Id ]
let MakeType[tree, localContext, paintRecords] _ LookupTypeId [tree, localContext]
let LookupTypeId [tree, localContext] _
CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> _ LookupTypeId [TypeId, localContext]
;
for OptType.absent:	AbstractProduction [ ]
let MakeType[tree, localContext, paintRecords] _ <localContext1, tgn>
  where localContext1 _ FakeDamageContext [localContext]
  where tgn _ FindBottomTGN [localContext]
;
for OptType.present:	AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords] _
												MakeType[TypeExp, localContext, paintRecords]
;
for Subrange.named:	AbstractProduction [ TypeId, Interval ]
let MakeType[tree, localContext, paintRecords] _
CreateSubrangeTGN [localContext1, tgn, bounds]
where <localContext1, tgn> _ LookupTypeId [TypeId, localContext]
where bounds _ GetBoundsVal [Interval]
;
for Subrange.unnamed:	AbstractProduction [ Interval ]
let MakeType[tree, localContext, paintRecords] _ CreateSubrangeTGN [localContext, tgn, bounds]
where tgn _ FindBottomTGN [localContext]
where bounds _ GetBoundsVal [Interval]
;
for Interval.cc:	AbstractProduction [ Bounds ]
let GetBoundsVal [tree] _ BoundsValFun ["[", GetLowerAndUpper [Bounds], "]"]
;
for Interval.co:	AbstractProduction [ Bounds ]
let GetBoundsVal [tree] _ BoundsValFun ["[", GetLowerAndUpper [Bounds], ")"]
;
for Interval.oc:	AbstractProduction [ Bounds ]
let GetBoundsVal [tree] _ BoundsValFun ["(", GetLowerAndUpper [Bounds], "]"]
;
for Interval.oo:	AbstractProduction [ Bounds ]
let GetBoundsVal [tree] _ BoundsValFun ["(", GetLowerAndUpper [Bounds], ")"]
;
for Bounds:	AbstractProduction [ Exp.lower, Exp.upper ]
let GetLowerAndUpper [tree] _ <ExpPTreeVal [Exp.lower], ExpPTreeVal [Exp.upper]>
;
for PointerType.unspecified:	AbstractProduction [ OptInterval ]
let GetPointerTypeInfo [tree, localContext, paintRecords] _ <localContext1, bounds, readOnly, tgn>
where bounds _ GetBoundsVal [OptInterval]
where readOnly _ False []
where tgn _ FindBottomTGN[localContext1]
where localContext1 _ FakeDamageContext [localContext]
;
for PointerType.specified:	AbstractProduction [ OptInterval, ReadOnly, TypeExp ]
let GetPointerTypeInfo [tree, localContext, paintRecords] _ <localContext1, bounds, readOnly, tgn>
where bounds _ GetBoundsVal [OptInterval]
where readOnly _ GetBooleanVal [ReadOnly]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
;
for OptInterval.absent:	AbstractProduction [ ]
let GetBoundsVal [tree] _ NullBounds []
;
for OptInterval.present:	AbstractProduction [ Interval ]
let GetBoundsVal [tree] _ GetBoundsVal [Interval]
;
for TransferMode.proc:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "proc"
;
for TransferMode.port:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "port"
;
for TransferMode.signal:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "signal"
;
for TransferMode.error:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "error"
;
for TransferMode.process:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "process"
;
for TransferMode.program:	AbstractProduction [ ]
let MakeTransferMode [tree] _ "program"
;
for Arguments:	AbstractProduction [ ParameterList.input, ParameterList.output ]
let MakeArgumentLists [tree, localContext, paintRecords] _ <localContext2, frozenInputlist, frozenOutputList>
where <localContext2, frozenOutputList> _ 
FreezeFieldList [MakeFieldList [ParameterList.output, localContext1, paintRecords]]
where <localContext1, frozenInputlist> _ 
FreezeFieldList [MakeFieldList [ParameterList.input, localContext, paintRecords]]
;
for Default.empty:	AbstractProduction [ ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["", NullExpPTree []]
;
for Default.gets:	AbstractProduction [ ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_", NullExpPTree []]
;
for Default.getsexp:	AbstractProduction [ Exp ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_e", ExpPTreeVal [Exp]]
;
for Default.getstrash:	AbstractProduction [ ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_TRASH", NullExpPTree []]
;
for Default.getsexportrash:	AbstractProduction [ Exp ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_e|TRASH", ExpPTreeVal [Exp]]
;
for Packed.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Packed.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Monitored.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Monitored.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for MachineDependent.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for MachineDependent.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Ordered.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Ordered.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Base.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Base.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Safe.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Safe.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Safe.empty:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for Uncounted.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for Uncounted.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
for ReadOnly.yes:	AbstractProduction [ ]
let GetBooleanVal [tree] _ True []
;
for ReadOnly.no:	AbstractProduction [ ]
let GetBooleanVal [tree] _ False []
;
End; 

SaffronMakeFieldList: Module = Begin
for RecList.empty: 	AbstractProduction [ ]
let MakeFieldList [tree, localContext, paintRecords ] _ 
< FakeDamageContext[localContext], CreateEmptyFieldList []>
;
for RecList.pairlist: 	AbstractProduction [ PairList ]
let MakeFieldList [tree, localContext, paintRecords] _ <localContext1, fieldList>
where <localContext1, fieldList> _ 
AddPairsToFieldList [PairList, localContext, newFieldList, paintRecords]
where newFieldList _ CreateEmptyFieldList []
;
for RecList.typelist:	AbstractProduction [ TypeList ]
let MakeFieldList [tree, localContext, paintRecords] _ <localContext1, fieldList>
where <localContext1, fieldList> _ AddToFieldList [TypeList, localContext, newFieldList, paintRecords]
where newFieldList _ CreateEmptyFieldList []
;
for ParameterList.empty:	AbstractProduction [ ]
let MakeFieldList [tree, localContext, paintRecords ] _ 
	<FakeDamageContext[localContext], CreateEmptyFieldList []>
;
for ParameterList.any:	AbstractProduction [ ]
let MakeFieldList [tree, localContext, paintRecords] _ 
						<FakeDamageContext [localContext], AnyFieldList []>
;
for ParameterList.pairlist:	AbstractProduction [ PairList ]
let MakeFieldList [tree, localContext, paintRecords] _ <localContext1, fieldList>
where <localContext1, fieldList> _ 
AddPairsToFieldList [PairList, localContext, newFieldList, paintRecords]
where newFieldList _ CreateEmptyFieldList []
;
for ParameterList.typelist:	AbstractProduction [ TypeList ]
let MakeFieldList [tree, localContext, paintRecords] _ <localContext1, fieldList>
where <localContext1, fieldList> _ AddToFieldList [TypeList, localContext, newFieldList, paintRecords]
where newFieldList _ CreateEmptyFieldList []
;
for VariantList.one:	AbstractProduction [ VariantItem ]
let MakeUnionList [tree, localContext, paintRecords] _
 AddVariantsToUnionList [VariantItem, localContext, newUnionList, paintRecords]
where newUnionList _ CreateEmptyUnionList []
let AddVariantsToUnionList [tree, localContext, unionList, paintRecords] _
 AddVariantsToUnionList [VariantItem, localContext, unionList, paintRecords]
let MakeStarTagType [tree, localContext] _ <localContext2, tgn>
where localContext2 _
AddVariantNamesToEnumTypeTGN [VariantItem, localContext1, tgn]
where <localContext1, tgn> _ CreateEmptyEnumTypeTGN [localContext, False []]
let AddVariantNamesToEnumTypeTGN [tree, localContext, tgn] _
AddVariantNamesToEnumTypeTGN [VariantItem, localContext, tgn]
;
for VariantList.more:	AbstractProduction [ VariantList, VariantItem ]
let MakeUnionList [tree, localContext, paintRecords] _
 AddVariantsToUnionList [VariantItem, localContext1, unionList, paintRecords]
where <localContext1, unionList> _
AddVariantsToUnionList [VariantList, localContext, newUnionList, paintRecords]
where newUnionList _ CreateEmptyUnionList []

let AddVariantsToUnionList [tree, localContext, unionList, paintRecords] _
 AddVariantsToUnionList [VariantItem, localContext1, unionList1, paintRecords]
where <localContext1, unionList1> _
AddVariantsToUnionList [VariantList, localContext, unionList, paintRecords]
let MakeStarTagType [tree, localContext] _ <localContext3, tgn>
where localContext3 _ 
AddVariantNamesToEnumTypeTGN [VariantItem, localContext2, tgn]
where localContext2 _ 
AddVariantNamesToEnumTypeTGN [VariantList, localContext1, tgn]
where <localContext1, tgn> _ CreateEmptyEnumTypeTGN [localContext, False []]
let AddVariantNamesToEnumTypeTGN [tree, localContext, tgn] _
AddVariantNamesToEnumTypeTGN [VariantItem, localContext1, tgn]
where localContext1 _ 
AddVariantNamesToEnumTypeTGN [VariantList, localContext, tgn] 
;
for VariantItem:	AbstractProduction [ IdList, RecList ]
let AddVariantsToUnionList [tree, localContext, unionList, paintRecords] _ < localContext2, AddNamesToUnionList [IdList, ffl, unionList]>
where <localContext2, ffl> _ FreezeFieldList [localContext1, fieldList]
where <localContext1, fieldList> _ MakeFieldList [RecList, localContext, paintRecords ]
let AddVariantNamesToEnumTypeTGN [tree, localContext, tgn] _
AddVariantNamesToEnumTypeTGN [IdList, localContext, tgn]
;
for IdList.one:	AbstractProduction [ Id ]
let AddNamesToUnionList [tree, ffl, unionList] _ AppendToUnionList [unionList, Id, ffl]
let AddVariantNamesToEnumTypeTGN [tree, localContext, tgn] _
AppendElementToEnumTypeTGN [localContext, tgn, Id, NullExpPTree[]]
let AddIdsToInterfaceTGN [tree, localContext, interfaceTGN, interface] _
    AddTGNToInterfaceTGN [localContext1, interfaceTGN, Id, accessVal, linkTgn]
where <localContext1, linkTgn> _ CreateLinkTGN [localContext, entryTgn, interface, Id]
where <accessVal, entryTgn> _ LookupInterfaceEntry [interface, Id]
;
for IdList.more:	AbstractProduction [ Id, IdList ]
let AddNamesToUnionList [tree, ffl, unionList] _
AddNamesToUnionList [IdList, ffl, unionList1]
where unionList1 _ AppendToUnionList [unionList, Id, ffl]
let AddVariantNamesToEnumTypeTGN [tree, localContext, tgn] _
AddVariantNamesToEnumTypeTGN [IdList, localContext1, tgn]
where localContext1 _ AppendElementToEnumTypeTGN [localContext, tgn, Id, NullExpPTree[]]
let AddIdsToInterfaceTGN [tree, localContext, interfaceTGN, interface] _
	 AddIdsToInterfaceTGN [IdList, localContext2, interfaceTGN, interface]
where localContext2 _ 
AddTGNToInterfaceTGN [localContext1, interfaceTGN, Id, accessVal, linkTgn]
where <localContext1, linkTgn> _ CreateLinkTGN [localContext, entryTgn, interface, Id]
where <accessVal, entryTgn> _ LookupInterfaceEntry [interface, Id]
;
for Tag.ident:	AbstractProduction [ Ident, Access, TagType ]
let MakeVariantFlavor [tree] _ 
VanillaVariantFlavorVal [GetIdentInfo [Ident], GetAccessVal [Access]]
let MakeTagType [tree, localContext, paintRecords] _ 
MakeTagType [TagType, localContext, paintRecords] 
let GetSequenceTagInfo [tree] _ <GetIdentInfo [Ident], GetAccessVal [Access]>
;
for Tag.computed:	AbstractProduction [ TagType ]
let MakeVariantFlavor [tree] _ ComputedVariantFlavorConst []
let MakeTagType [tree, localContext, paintRecords] _ 
MakeTagType [TagType, localContext, paintRecords] 
let GetSequenceTagInfo [tree] _ <NullId [], NullPosition [], AccessValConst ["empty"]>
;
for Tag.overlaid:	AbstractProduction [ TagType ]
let MakeVariantFlavor [tree] _ OverlaidVariantFlavorConst  []
let MakeTagType [tree, localContext, paintRecords] _ 
MakeTagType [TagType, localContext, paintRecords] 
let GetSequenceTagInfo [tree] _ <NullId [], NullPosition [], AccessValConst ["empty"]>
where x _ Error ["Sequences can't be overlaid"]
;

for TagType.star:	AbstractProduction [ ]
let MakeTagType [tree, localContext, paintRecords] _ 
<localContext1, FindBottomTGN [localContext1], True []>
where localContext1 _ FakeDamageContext [localContext]
;
for TagType.typeexp:	AbstractProduction [ TypeExp ]
let MakeTagType [tree, localContext, paintRecords] _ 
<MakeType [TypeExp, localContext, paintRecords], False []>
;
End;

SaffronAddToFieldList: Module = Begin
for TypeList.many:	AbstractProduction [ TypeList.head, TypeList.tail ]
let AddToFieldList [tree, localContext, fieldList, paintRecords] _ 
AddToFieldList [ TypeList.tail, localContext1, fieldList1, paintRecords]
where <localContext1, fieldList1> _ 
AddToFieldList [ TypeList.head, localContext, fieldList, paintRecords]
;
for TypeList.one:	AbstractProduction [ TypeItem ]
let AddToFieldList [tree, localContext, fieldList, paintRecords] _  
AddToFieldList [ TypeItem, localContext, fieldList, paintRecords]
;


for TypeItem:	AbstractProduction [ TypeExp, Default ]

let AddToFieldList [tree, localContext, fieldList, paintRecords] _ <localContext1, fieldList1>
where fieldList1 _ AppendFieldToFieldList [ fieldList, field]
where field _ CreateUnnamedField [tgn, defaultExp]
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
where defaultExp _ GetDefaultExpVal [Default]
End;

SaffronAddPairsToFieldList: Module = Begin

for PairList.many:	AbstractProduction [ PairList.head, PairList.tail ]
let AddPairsToFieldList [tree, localContext, fieldList, paintRecords] _
AddPairsToFieldList [ PairList.tail, localContext1, fieldList1, paintRecords]
where <localContext1, fieldList1> _ 
AddPairsToFieldList [PairList.head, localContext, fieldList, paintRecords]
;

for PairList.one:	AbstractProduction [ PairItem ]
let AddPairsToFieldList [tree, localContext, fieldList, paintRecords] _
AddPairsToFieldList [PairItem, localContext, fieldList, paintRecords]
;


for PairItem:	AbstractProduction [ IdentList, Access, TypeExp, Default ]
let AddPairsToFieldList [tree, localContext, fieldList, paintRecords] _
< localContext1, AddNamesToFieldList [IdentList, accessVal, tgn, defaultExp, fieldList] >
where <localContext1, tgn> _ MakeType [TypeExp, localContext, paintRecords]
where accessVal _ GetAccessVal [Access]
where defaultExp _ GetDefaultExpVal [Default]
;
for Access.empty:		AbstractProduction [ ]
let GetAccessVal [tree] _ AccessValConst ["empty"]
;
for Access.public:		AbstractProduction [ ]
let GetAccessVal [tree] _ AccessValConst ["public"]
;
for Access.private:	AbstractProduction [ ]
let GetAccessVal [tree] _ AccessValConst ["private"]
;

End;

SaffronAddNamesToFieldList: Module = Begin
for IdentList.many:	AbstractProduction [ IdentList.head, IdentList.tail ]
let AddNamesToFieldList [tree, accessVal, tgn, defaultExp, fieldList] _
AddNamesToFieldList [IdentList.tail, accessVal, tgn, defaultExp, fieldList1]
where fieldList1 _ AddNamesToFieldList [IdentList.head, accessVal, tgn, defaultExp, fieldList]
let PutNewNamesInLocalContext1[tree, localContext, accessVal]_
PutNewNamesInLocalContext1[IdentList.tail, localContext1, accessVal]
where localContext1 _
PutNewNamesInLocalContext1[IdentList.head, localContext, accessVal]
let RecAddArcsfromLVTGNtoTGN[tree, localContext, accessVal, tgn, defaultExp]_
RecAddArcsfromLVTGNtoTGN[IdentList.tail, localContext1, accessVal, tgn, defaultExp]
where localContext1 _ RecAddArcsfromLVTGNtoTGN[IdentList.head, localContext, accessVal, tgn, defaultExp]
let MakeNameSequence [tree] _ AddNamesToSequence [IdentList.head, nameSequence1]
where nameSequence1 _ AddNamesToSequence [IdentList.tail, nameSequence]
where nameSequence _ EmptyNameSequence []
let AddNamesToSequence [tree, nameSequence] _ 
		AddNamesToSequence [IdentList.head, nameSequence1]
where nameSequence1 _ AddNamesToSequence [IdentList.tail, nameSequence]
;

for IdentList.one:	AbstractProduction [ Ident ]
let AddNamesToFieldList [tree, accessVal, tgn, defaultExp, fieldList] _
AddNamesToFieldList [Ident, accessVal, tgn, defaultExp, fieldList]
let PutNewNamesInLocalContext1[tree, localContext, accessVal] _
 PutNewNamesInLocalContext1[Ident, localContext, accessVal]
let RecAddArcsfromLVTGNtoTGN[tree, localContext, accessVal, tgn, defaultExp] _
 RecAddArcsfromLVTGNtoTGN[Ident, localContext, accessVal, tgn, defaultExp]
let MakeNameSequence [tree] _ AddNamesToSequence [Ident, nameSequence]
where nameSequence _ EmptyNameSequence []
let AddNamesToSequence [tree, nameSequence] _ 
		AddNamesToSequence [Ident, nameSequence]
;
for Ident.id:	AbstractProduction [ Id ]
let AddNamesToFieldList [tree, accessVal, tgn, defaultExp, fieldList] _
AppendFieldToFieldList [fieldList, field]
where field _ CreateNamedField [Id, NullPosition [], accessVal, tgn, defaultExp]
let PutNewNamesInLocalContext1[tree, localContext, accessVal] _ localContext1
where <localContext1, tgn> _ CreateLocallyVisibleTGN [localContext, Id, accessVal ]

let RecAddArcsfromLVTGNtoTGN[tree, localContext, accessVal, tgn, defaultExp] _
 AddArcFromLVTGNToTGN [localContext, lvtgn, accessVal, tgn, defaultExp]
where lvtgn _ FindLocallyVisibleTGN [localContext, Id]
let GetIdentInfo [tree] _ <Id, NullPosition []>
let AddNamesToSequence [tree, nameSequence] _
		InsertNameOnNameSequence [Id, nameSequence]
;

for Ident.idposition:	AbstractProduction [ Id, Position ]
let AddNamesToFieldList [tree, accessVal, tgn,  defaultExp, fieldList] _
AppendFieldToFieldList [fieldList, field]
where field _ CreateNamedField [Id, GetPositionVal [Position], accessVal, tgn, defaultExp]
let PutNewNamesInLocalContext1[tree, localContext, accessVal] _ localContext1
where <localContext1, tgn> _ CreateLocallyVisibleTGN [localContext, Id, accessVal ]

let RecAddArcsfromLVTGNtoTGN[tree, localContext, accessVal, tgn, defaultExp] _
 AddArcFromLVTGNToTGN [localContext, lvtgn, accessVal, tgn, defaultExp]
where lvtgn _ FindLocallyVisibleTGN [localContext, Id]
let GetIdentInfo [tree] _ <Id, GetPositionVal [Position]>
let AddNamesToSequence [tree, nameSequence] _
		InsertNameOnNameSequence [Id, nameSequence]
where x _ Error ["Is Position field valid in a ModuleName list"]
;
for Position:	AbstractProduction [ Exp, OptBits ]
let GetPositionVal [tree] _ PositionValFun [ExpPTreeVal [Exp], boundsVal]
where boundsVal _ GetBoundsVal [OptBits]
;
for OptBits.absent:	AbstractProduction [ ]
let GetBoundsVal [tree] _ NullBounds []
;
for OptBits.present:	AbstractProduction [ Bounds ]
let GetBoundsVal [tree] _ BoundsValFun ["[", GetLowerAndUpper [Bounds], "]"]
;
End;

SaffronMakeElementList: Module = Begin
for ElementList.empty:	AbstractProduction [ ]
let MakeElementList [tree, localContext, machineDependent] _ CreateEmptyEnumTypeTGN [localContext, machineDependent]
;

for ElementList.more:	AbstractProduction [ ElementList, Element ]
let MakeElementList [tree, localContext, machineDependent] _ <localContext1, tgn>
where localContext1 _ 
AppendElementToEnumTypeTGN [localContext2, tgn, elementName, rep]
where <localContext2, tgn> _ MakeElementList [ElementList, localContext, machineDependent]
where <elementName, rep> _ ElementInfo [Element]


End;

SaffronElementName: Module = Begin
for Element.id:	AbstractProduction [ Id ]
let ElementInfo [tree] _ <Id, NullExpPTree[]>
;

for Element.idwithrep:	AbstractProduction [ Id, Exp ]
let ElementInfo [tree] _ <Id, ExpPTreeVal [Exp]>
;

for Element.anonymousrep:	AbstractProduction [ Exp ]
let ElementInfo [tree] _ <NullId [], ExpPTreeVal [Exp]>
;
for Exp.id:	AbstractProduction [ Id ]
let IdVal [tree] _ Id
;
for Exp.sum:	AbstractProduction [ Exp.left, AddOp, Exp.right ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.unarysum:	AbstractProduction [ AddOp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.product:	AbstractProduction [ Exp.left, MultOp, Exp.right ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.or:	AbstractProduction [ Exp.left, Exp.right ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.and:	AbstractProduction [ Exp.left, Exp.right ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.not:	AbstractProduction [ Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.relation:	AbstractProduction [ Exp, Relation ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.ifthenelse:	AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.select:	AbstractProduction [ SelectHead, SelectExpList, Exp.default ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.assign:	AbstractProduction [ Exp.lhs, Exp.rhs ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.multiassign:	AbstractProduction [ ExpList, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.num:	AbstractProduction [ Num ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.string:	AbstractProduction [ String ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.flnum:	AbstractProduction [ Flnum ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.char:	AbstractProduction [ Char ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.atom:	AbstractProduction [ Atom ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.narrow:	AbstractProduction [ Exp, OptType, Catch ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.loophole:	AbstractProduction [ Exp, OptType ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.apply:	AbstractProduction [ Exp.rator, Exp.rand, Catch ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.qualifier:	AbstractProduction [ Exp, Qualifier ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.explist:	AbstractProduction [ ExpList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.prefixop:	AbstractProduction [ PrefixOp, OrderList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.val:	AbstractProduction [ OrderList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.all:	AbstractProduction [ OrderList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.new:	AbstractProduction [ New, TypeExp, Initialization, Catch ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.cons:	AbstractProduction [ Cons, ExpList, Catch ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.listcons:	AbstractProduction [ ListCons, ExpList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.nil:	AbstractProduction [ ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.typeop:	AbstractProduction [ TypeOp, TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.size:	AbstractProduction [ TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.size2:	AbstractProduction [ TypeExp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.bits:	AbstractProduction [ TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.bits2:	AbstractProduction [ TypeExp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.bytes:	AbstractProduction [ TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.bytes2:	AbstractProduction [ TypeExp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.units:	AbstractProduction [ TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.units2:	AbstractProduction [ TypeExp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.words:	AbstractProduction [ TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.words2:	AbstractProduction [ TypeExp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.istype:	AbstractProduction [ Exp, TypeExp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.address:	AbstractProduction [ Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.descriptor:	AbstractProduction [ DescList ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.error:	AbstractProduction [ ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
for Exp.transfer:	AbstractProduction [ TransferOp, Exp ]
let IdVal [tree] _ NullId [] where x _ Error ["Expected an Id"];
End;

SaffronScope: Module = Begin
for Scope:	AbstractProduction [ BindList, Catch, OptDecList, StatementList ]
let MakeContextTree [tree, rib, paintRecords] _
MakeBindListContextTreeWithScope [BindList, scopePTree, rib, paintRecords]
where scopePTree _ ScopePTreeVal [tree]
let MakeContextTree1 [tree, rib, paintRecords] _
 HangContextsFromContextTree [StatementList,  decListContextTree, newRib, paintRecords]
where decListContextTree _ HangContextsFromContextTree [OptDecList, thisScopeContextTree, newRib, paintRecords]
where thisScopeContextTree _ EmptyContextTree [newRib]
where newRib _ FreezeLocalContext [thisScopeLocalContext]
where thisScopeLocalContext _ UpdateLocalContext [OptDecList, localContext, paintRecords ]
where localContext _ CreateEmptyContext [rib]
;
for BindList.empty:	AbstractProduction [ ]
let MakeBindListContextTreeWithDefBody [tree, defBodyPTree, rib, paintRecords] _
MakeContextTree1 [defBody, rib, paintRecords]
where defBody _ DefBodyVal [defBodyPTree]
let MakeBindListContextTreeWithScope [tree, scopePTree, rib, paintRecords] _
MakeContextTree1 [scope, rib, paintRecords]
where scope _ ScopeVal [scopePTree]
let UpdateLocalContext [tree, localContext, paintRecords] _
FakeDamageContext [localContext]
;
for BindList.more:	AbstractProduction [ BindList, BindItem ]
let MakeBindListContextTreeWithDefBody [tree, defBodyPTree, rib, paintRecords] _ 
	AddSubContextTree [EmptyContextTree [rib2], contextTree2]
where contextTree2 _ MakeContextTree1[defBody, rib2, paintRecords]
where defBody _ DefBodyVal [defBodyPTree]
where rib2 _ FreezeLocalContext [bindListsLocalContext]
where bindListsLocalContext _ UpdateLocalContext [tree, localContext, paintRecords]
where localContext _ CreateEmptyContext [rib]

let MakeBindListContextTreeWithScope [tree, scopePTree, rib, paintRecords] _ 
	AddSubContextTree [EmptyContextTree [rib2], contextTree2]
where contextTree2 _ MakeContextTree1[scope, rib2, paintRecords]
where scope _ ScopeVal [scopePTree]
where rib2 _ FreezeLocalContext [bindListsLocalContext]
where bindListsLocalContext _ UpdateLocalContext [tree, localContext, paintRecords]
where localContext _ CreateEmptyContext [rib]

let UpdateLocalContext [tree, localContext, paintRecords] _
UpdateLocalContext [BindItem, localContext1, paintRecords]
where localContext1 _ UpdateLocalContext [BindList, localContext, paintRecords]
;
for BindItem.named:	AbstractProduction [ Id, Exp ]
let UpdateLocalContext [tree, localContext, paintRecords] _
RenameInterface [localContext, Id, interfaceTgn]
where interfaceTgn _ FindLocallyVisibleTGN [localContext, IdVal [Exp]]
;
for BindItem.unnamed:	AbstractProduction [ Exp ]
let UpdateLocalContext [tree, localContext, paintRecords] _
OpenInterface [localContext, interfaceTgn]
where interfaceTgn _ FindLocallyVisibleTGN [localContext, IdVal [Exp]]
;
for OptDecList.absent:	AbstractProduction [ ]
let UpdateLocalContext [tree, localContext, paintRecords] _ 
FakeDamageContext [localContext]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree];

for OptDecList.present:	AbstractProduction [ DecList ]
let UpdateLocalContext [tree, localContext, paintRecords] _ 
FillInLocalContext [DecList, localContext1, paintRecords]
where localContext1 _ PutNewNamesInLocalContext [DecList, localContext]

let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [DecList, contextTree, rib, paintRecords]
;
for DecList.many:	AbstractProduction [ DecList.head, DecList.tail ]
let UpdateLocalContext [tree, localContext, paintRecords] _ 
FillInLocalContext [tree, localContext1, paintRecords]
where localContext1 _ PutNewNamesInLocalContext [tree, localContext]
let PutNewNamesInLocalContext [tree, localContext] _ 
PutNewNamesInLocalContext [DecList.tail, localContext1]
where localContext1 _ PutNewNamesInLocalContext [DecList.head, localContext] 

let FillInLocalContext [tree, localContext, paintRecords] _ 
FillInLocalContext [DecList.tail, localContext1, paintRecords]
where localContext1 _ FillInLocalContext [DecList.head, localContext, paintRecords]

let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [DecList.tail, contextTree1, rib, paintRecords]
where contextTree1 _ HangContextsFromContextTree [DecList.head, contextTree, rib, paintRecords]

;

for DecList.one:	AbstractProduction [ Declaration ]
let UpdateLocalContext [tree, localContext, paintRecords] _ 
FillInLocalContext [tree, localContext1, paintRecords]
where localContext1 _ PutNewNamesInLocalContext [tree, localContext]
let PutNewNamesInLocalContext[tree, localContext] _
PutNewNamesInLocalContext[Declaration, localContext]

let FillInLocalContext[tree, localContext, paintRecords] _
FillInLocalContext[Declaration, localContext, paintRecords]

let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [Declaration, contextTree, rib, paintRecords]
;
for Declaration.opaquetype:	AbstractProduction [ IdentList, Access, OptSize ]
let PutNewNamesInLocalContext[tree, localContext]  _
 PutNewNamesInLocalContext1[IdentList, localContext, GetAccessVal[Access]]
let FillInLocalContext[tree, localContext, paintRecords] _
RecAddArcsfromLVTGNtoTGN [IdentList, localContext2, NullAccessVal [], tgn, NullDefaultVal []]
where <localContext2, tgn> _ CreateOpaqueTGN [localContext1, paint, sizeExp]
where <localContext1, paint> _ GetUniquePaint [localContext]
where sizeExp _ GetExpVal [OptSize]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;

for Declaration.type:	AbstractProduction [ IdentList, Access.id, Access.type, TypeExp, Default ]
let PutNewNamesInLocalContext[tree, localContext]  _
 PutNewNamesInLocalContext1[IdentList, localContext, GetAccessVal[Access.id]]
let FillInLocalContext[tree, localContext, paintRecords] _
RecAddArcsfromLVTGNtoTGN [IdentList, localContext1, GetAccessVal[Access.type], tgn, defaultExp]
where <localContext1, tgn> _ MakeType [TypeExp, localContext,  paintRecords]
where defaultExp _ GetDefaultExpVal [Default]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;

for Declaration.value:	AbstractProduction [ IdentList, Access, Entry, ReadOnly, TypeExp, Initialization ]
let PutNewNamesInLocalContext[tree, localContext] _ FakeDamageContext [localContext]
let FillInLocalContext[tree, localContext, paintRecords] _ 
FakeDamageContext [localContext]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for OptSize.absent:	AbstractProduction [ ]
let GetExpVal [tree] _ NullExpPTree []
;
for OptSize.present:	AbstractProduction [ Exp ]
let GetExpVal [tree] _ ExpPTreeVal [Exp]
;

for StatementList.empty:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;

for StatementList.more:	AbstractProduction [ StatementList, Statement ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [Statement, contextTree1, rib, paintRecords]
where contextTree1 _ 
HangContextsFromContextTree [StatementList, contextTree, rib, paintRecords]
;
for Statement.ifthen:	AbstractProduction [ Exp, Statement ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [Statement, contextTree, rib, paintRecords]
;
for Statement.ifthenelse:	AbstractProduction [ Exp, Statement.thenpart, Statement.elsepart ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [Statement.elsepart, contextTree1, rib, paintRecords]
where contextTree1 _ 
HangContextsFromContextTree [Statement.thenpart, contextTree, rib, paintRecords]
;
for Statement.select:	AbstractProduction [ SelectHead, SelectStmtList, OptStatement ] 
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.exp:	AbstractProduction [ Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;

for Statement.assign:	AbstractProduction [ Exp.lhs, Exp.rhs ] 
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.multiassign:	AbstractProduction [ ExpList, Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.block:	AbstractProduction [ Checked, Block ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
HangContextsFromContextTree [Block, contextTree, rib, paintRecords]
;
for Statement.loopcontrol:	AbstractProduction [ ForClause, DoTest, Scope, DoExit ]
 
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;

for Statement.exit:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.loop:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.goto:	AbstractProduction [ Id ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.return:	AbstractProduction [ OptArgs ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.transfer:	AbstractProduction [ Transfer, Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.free:	AbstractProduction [ Free, Exp, Catch ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.wait:	AbstractProduction [ Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.error:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.stop:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.null:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.resume:	AbstractProduction [ OptArgs ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.reject:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.continue:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.retry:	AbstractProduction [ ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.getstate:	AbstractProduction [ Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;
for Statement.setstate:	AbstractProduction [ Exp ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _
FakeDamageContextTree [contextTree]
;



for Block:	AbstractProduction [ Scope, ExitList ]
let HangContextsFromContextTree [tree, contextTree, rib, paintRecords] _ 
AddSubContextTree[contextTree, subContextTree]
where subContextTree _ MakeContextTree [Scope, rib, paintRecords]
;

End.


	¨SaffronMethods.ThreeC4 (July 16, 1987 4:02:51 pm PDT)
Copyright Ó 1987 by Xerox Corporation. All rights reserved.
Lucy Hederman August 20, 1987 3:49:01 pm PDT
Sturgis, July 21, 1987 3:16:17 pm PDT


need DoTop to take MakeType of the TypeExp 

Top
ModuleP
NOTE : This isn't really doing much.. Also ignoring Cedar, ProgHead, Checked
NOTE : ignoring Cedar, DefHead
Directory
IncludeItem
NOTE should check recorded module name against expected : Id
NOTE should check recorded module name against expected : Id
NOTE should check recorded module name against expected : Id
NOTE should check recorded module name against expected : Id.global
Using
DefBody
Make the contextTree for the entire DefBody, nesting the DecList inside the bindlist's context.
Make the contextTree for the context nested within the BindList.
(note: Freeze will "process" the type graph, looking for cycles etc.)
TypeExp
then Make up a Tag type by an enumeration of the VariantList types
TypeApply
TypeId
OptType
Subrange
Interval
Bounds
PointerType
OptInterval
TransferMode
Arguments
Default
Packed
Monitored
MachineDependent
Ordered
Base
Safe
ignoring safety default till we have flags.
Uncounted
ReadOnly
RecList
ParameterList
VariantList
VariantItem
IdList
entryTgn is NIL if the Id is for an entry point rather than a type.
Until we know about entry points we can't handle this correctly
verify that entryTgn is as intended
Tag
TagType
TypeList
TypeItem
PairList
PairItem
Access
IdentList
Ident
Position
OptBits
ElementList
Element
Exp
Scope
Look carefully at this. The syntax does not match the nesting semantics. 
Make the contextTree for the entire scope, nesting everything else inside the bindlist's context.
Make the contextTree for the context nested within the BindList.
(process statements here?  this will probably require a nested context for newly constructed types, but they can never be circular)
(note: Freeze will "process" the type graph, looking for cycles etc.)
ignoring Catch in Scope 
BindList
avoids making an unnecessary context tree node
avoids making an unnecessary context tree node
Semantically the scope creates a subcontext (contextTree2) of the Bindlist.
Rib2 is the rib corresponding to the context of Bindlist.
BindItem
OptDecList
DecList
Declaration
ignoring optsize
ignoring value declarations
OptSize
StatementList
Statement
can exp change context tree ?

can exp change context tree ?
ignoring Checked on a block statement
Block
ignoring ExitList
eof...

�Ê*˜
codeš
œ5™5K™;K™,K™%—K™J˜8K™Kš
Ïn+™+K™š�œ˜
headš
Ðnz™
codetabšÐizœ
ÏbœŸœ˜/MšŸœF˜IMšŸœA˜DMš
œ
˜
——š
ž™šŸ 
œŸœ:˜^Mš
œL™LšŸœ9˜<MšŸœ8�
œ˜PMšŸœE˜JMšŸœ,˜1—šŸœ1˜4MšŸœ8�
œ˜PMšŸœE˜JMšŸœ,˜1—Mš
œ
˜
—šŸ œŸœ2˜UšŸœ:˜=MšŸœ=˜BšŸœG˜LšŸœB˜GMšŸœ/˜4MšŸœ˜—MšŸœ,˜1—šŸœL˜QMšŸœ6˜;——šŸœ2˜5MšŸœ=˜BšŸœE˜JMšŸœ,˜1—MšŸœ/˜4—M˜
—Mš
œ™—š
ž	™	šŸ œŸœ˜+šŸœ3˜6Mš
œ?˜?—MšŸœA˜DM˜
—šŸ œŸœ˜AšŸœ5˜8Mš
œe˜e—šŸœ'˜*Mš
œW˜W—Mš
œ
˜
——š
ž™šŸ œŸœ˜?šŸœI˜LMšŸœ<˜AMš
œ=˜=MšŸœc˜hMšŸœR˜WMš
œ<™<šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ+˜/MšŸœ0˜5——MšŸœ#˜(—šŸœ*˜-šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ#˜'MšŸœ0˜5——MšŸœ#˜(—Mš
œ
˜
—šŸ œŸœ˜6šŸœI˜LMšŸœ<˜AMš
œ=˜=MšŸœc˜hMšŸœR˜WMš
œ<™<šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ+˜/MšŸœ0˜5——MšŸœ˜ —šŸœ*˜-šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ#˜'MšŸœ0˜5——MšŸœ˜ —Mš
œ
˜
—šŸ œŸœ˜7šŸœI˜LMšŸœ<˜AMš
œ=˜=MšŸœc˜hMšŸœR˜WMš
œ<™<šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ+˜/MšŸœ0˜5——MšŸœ˜ —šŸœ*˜-šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ#˜'MšŸœ0˜5——MšŸœ˜ —Mš
œ
˜
—šŸ œŸœ˜LšŸœI˜LMšŸœ<˜AMš
œ=˜=MšŸœh˜mMšŸœR˜WMš
œC™CšŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ+˜/MšŸœ0˜5——MšŸœ!˜&—šŸœ*˜-šŸœ˜MšŸœ!˜#šŸœ0˜4MšŸœ%˜*—šŸœ#˜'MšŸœ0˜5——MšŸœ!˜&—Mš
œ
˜
——š
ž™šŸ œŸœ˜3šŸœ4˜7˜UMšŸœG˜L——Mš
œ
˜
—šŸ œŸœ˜)šŸœ4˜7Mš
œ3˜3—Mš
œ
˜
—šŸ œŸœ˜.šŸœ3˜6M˜9—Mš
œ
˜
——š
ž™šŸœ
�	Ÿœ˜5MšŸœ3˜6š
œ_™_Kš
œU˜UKšŸœ&˜+—KšŸœ-˜0™@Kš
œV˜VKšŸœ1˜6šŸœ4˜9K™E—KšŸœR˜WKšŸœ(˜-—Mš
œ
˜
——š
ž™šŸœ
 œŸœ)˜OšŸœE˜HMšŸœr˜wMšŸœN˜SMšŸœR˜WMšŸœŸœŸœ$Ÿœ!˜|MšŸœ4˜9MšŸœ&˜+—Mš
œ
˜
—šŸœ
 
œŸœ˜:šŸœy˜|MšŸœ(˜-šŸœ ˜%šŸœ˜M™BMšŸœ.˜2MšŸœ0˜4——MšŸœ]˜bMšŸœV˜[—š
œ
˜
M˜——šŸœ
 œŸœ˜AšŸœƒ
˜†
MšŸœ!˜&MšŸœŸœŸœ+Ÿœ˜VMšŸœ]˜bMšŸœF˜KM˜—M˜
—šŸœ
 œŸœ"˜FšŸœk˜nMšŸœ4˜9—M˜
M˜—šŸœ
 œŸœ˜9šŸœc˜fKšŸœN˜SKšŸœ$˜)—Kš
œ
˜
K˜—šŸœ
 œŸœ
˜3šŸœh˜kMšŸœ$˜)MšŸœ1˜6KšŸœ$˜)—Mš
œ
˜
—šŸœ
 œŸœ˜2šŸœi˜lMšŸœ$˜)MšŸœ1˜6KšŸœ˜—Mš
œ
˜
—šŸœ
 œŸœ˜1MšŸœh˜kMš
œ˜—šŸœ
 œŸœ
˜5MšŸœh˜kš
œ
˜
M˜——šŸœ
 œŸœ˜FšŸœ{˜~MšŸœ"˜'MšŸœ˜!MšŸœi˜n—š
œ
˜
M˜——šŸœ
 œŸœ˜/šŸœO˜RMšŸœF˜K—š
œ
˜
M˜——šŸœ
 œŸœ˜:šŸœa˜dKšŸœJ˜OKšŸœ$˜)—J˜
J˜—šŸœ
 
œŸœ˜BšŸœp˜sMšŸœK˜PMšŸœK˜PMšŸœ ˜%—š
œ
˜
M˜——šŸœ
 œŸœ˜@šŸœl˜oMšŸœF˜KKšŸœ$˜)—š
œ
˜
M˜——šŸœ
 œŸœ"˜JšŸœ}˜€
MšŸœh˜mMšŸœ/˜4MšŸœ˜!—Mš
œ
˜
M˜—šŸœ
 œŸœ˜<šŸœh˜kMšŸœG˜LMšŸœ?˜D—š
œ
˜
M˜——šŸœ
 œŸœ˜2MšŸœm˜pš
œ
˜
M˜——šŸœ
 œŸœ˜0šŸœP˜SMšŸœF˜K—š
œ
˜
M˜——šŸœ
 
œŸœ˜,šŸœj˜mMšŸœ1˜6—š
œ
˜
M˜——šŸœ
 œŸœ˜;šŸœ5˜8MšŸœ˜MšŸœ%˜*MšŸœ'˜,—š
œ
˜
M˜——šŸœ
 œŸœ˜7MšŸœh˜kMš
œ
˜
——š
ž	™	šŸœ
 
œŸœ˜5šŸœ.˜1Mš
œD˜DMšŸœ;˜@—Mš
œ
˜
—šŸœ
 œŸœ˜@šŸœ.˜1Mš
œD˜DMšŸœH˜M—Mš
œ
˜
—šŸœ
 œŸœ˜;šŸœ.˜1Mš
œ4˜4MšŸœH˜M—M˜
——š
ž™šŸœ
 	œŸœ˜(MšŸœEŸœ4Ÿœ1˜·
MšŸœ;Ÿœ4Ÿœ1˜­
Mš
œ
˜
M˜—šŸœ
 œŸœ˜7MšŸœO˜RšŸœ$˜'Mš
œ4˜4MšŸœ;˜@—Mš
œ
˜
——š
Ïz™šŸœ
 œŸœ˜*MšŸœEŸœ4Ÿœ#˜©
Mš
œ
˜
—šŸœ
 œŸœ˜3MšŸœg˜jMš
œ
˜
——š
¡™šŸ œŸœ˜;šŸœ-˜0Mš
œ.˜.MšŸœ;˜@MšŸœ!˜&——Mš
œ
˜
šŸ œŸœ
˜5šŸœ[˜^MšŸœ#˜(MšŸœ!˜&—Mš
œ
˜
——š
ž™šŸ œŸœ˜.MšŸœI˜LMš
œ
˜
—šŸ œŸœ˜.MšŸœI˜LMš
œ
˜
—šŸ œŸœ˜.MšŸœI˜LMš
œ
˜
—šŸ œŸœ˜.MšŸœI˜LMš
œ
˜
——š
ž™šŸœ
�œŸœ˜7KšŸœM˜PK˜
——š
¡™šŸ œŸœ˜?šŸœ_˜bKšŸœ$˜)KšŸœ˜KšŸœ#˜(Kš
œ6˜6—Kš
œ
˜
—šŸ œŸœ#˜PšŸœ_˜bKšŸœ$˜)KšŸœ$˜)KšŸœF˜K—Mš
œ
˜
——š
ž™šŸ œŸœ˜.MšŸœ$˜'Mš
œ
˜
—šŸ œŸœ
˜8MšŸœ.˜1Mš
œ
˜
——š
¡™šŸ œŸœ˜-MšŸœ!˜$Mš
œ
˜
—šŸ œŸœ˜-Mš
œ$˜$Mš
œ
˜
—šŸ œŸœ˜/Mš
œ&˜&Mš
œ
˜
—šŸ œŸœ˜.Mš
œ%˜%Mš
œ
˜
—šŸ œŸœ˜0Mš
œ'˜'Mš
œ
˜
—šŸ œŸœ˜0Mš
œ'˜'Mš
œ
˜
——š
¡	™	šŸ 
�	œŸœ.˜OšŸœj˜mKšŸœy˜~KšŸœv˜{—Kš
œ
˜
——š
Ðbz™šŸ œŸœ˜)MšŸœ>˜AMš
œ
˜
—šŸ 
œŸœ˜(MšŸœ?˜BMš
œ
˜
—šŸ œŸœ˜/MšŸœB˜EMš
œ
˜
—šŸ œŸœ˜-MšŸœD˜GMš
œ
˜
—šŸ œŸœ˜6MšŸœH˜KMš
œ
˜
——š
ž™šŸœ
 
œŸœ˜&MšŸœ˜"Mš
œ
˜
—šŸœ
 	œŸœ˜%MšŸœ ˜#Mš
œ
˜
——š
¢	™	šŸœ
 
œŸœ˜)MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜(MšŸœ ˜#Mš
œ
˜
——š
¢™šŸœ
 œŸœ˜0MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜/MšŸœ ˜#Mš
œ
˜
——š
ž™šŸœ
 œŸœ˜'MšŸœ˜"Mš
œ
˜
—šŸœ
 
œŸœ˜&MšŸœ ˜#Mš
œ
˜
——š
ž™šŸœ
 œŸœ˜$MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜#MšŸœ ˜#Mš
œ
˜
——š
ž™šŸœ
 œŸœ˜$MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜#MšŸœ ˜#Mš
œ
˜
—šŸœ
 
œŸœ˜&MšŸœ ˜#Mš
œ
˜
—M™+—š
ž	™	šŸœ
 
œŸœ˜)MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜(MšŸœ ˜#Mš
œ
˜
——š
ž™šŸœ
 œŸœ˜(MšŸœ˜"Mš
œ
˜
—šŸœ
 œŸœ˜'MšŸœ ˜#Mš
œ
˜
——K˜K˜—š œ˜$š
¢™šŸœ
 
œŸœ˜*KšŸœq˜tK˜
—šŸœ
 œŸœ
˜6šŸœN˜QKšŸœg˜lKšŸœ'˜,—K˜
—šŸœ
 œŸœ
˜5šŸœN˜QKšŸœa˜fKšŸœ'˜,—K˜
——š
ž
™
šŸ œŸœ˜/KšŸœq˜tMš
œ
˜
—šŸ œŸœ˜-MšŸœn˜qMš
œ
˜
—šŸ œŸœ
˜;šŸœN˜QKšŸœg˜lKšŸœ'˜,—Mš
œ
˜
—šŸ œŸœ
˜;šŸœN˜QKšŸœa˜fKšŸœ'˜,—Mš
œ
˜
——š
¢™šŸœ
 œŸœ˜7šŸœƒ
˜†
KšŸœ'˜,—KšŸœ”
˜—
šŸœ<˜?KšŸœO˜TKšŸœG˜L—KšŸœw˜zK˜
—šŸ œŸœ˜EšŸœ�
˜„
KšŸœl˜qKšŸœ'˜,—K˜šŸœ–
˜™
KšŸœj˜o—šŸœ<˜?KšŸœP˜UKšŸœP˜UKšŸœG˜L—šŸœx˜{KšŸœP˜U—Kš
Ÿ
˜
——š
ž™šŸœ
�œŸœ˜7šŸœ†
˜‰
KšŸœB˜GKšŸœR˜W—KšŸœr˜uKš
œ
˜
——š
¢™šŸœ
 
œŸœ˜)KšŸœT˜WKšŸœ|˜šŸœE˜HKš
œN˜NKšŸœQ˜VK™CK™?KšŸœ=˜B—Kš
œ
˜
—šŸœ
 œŸœ˜2šŸœ[˜^Kš
œ9˜9—šŸœs˜vKšŸœS˜X—šŸœE˜HKš
œG˜GšŸœ˜Kš
œJ˜J—KšŸœQ˜VKšŸœ=˜BK™#—K˜
——š
¡™šŸœ
 	œŸœ˜<KšŸœb˜eKšŸœe˜hKšŸœJ˜MKš
œ
˜
—šŸ 
œŸœ˜0KšŸœ9˜<KšŸœe˜hKšŸœS˜VKš
œ
˜
—šŸ 
œŸœ˜0KšŸœ:˜=KšŸœe˜hšŸœS˜VKšŸœ*˜/—Kš
œ
˜
K˜——š
¢™šŸœ
 œŸœ˜(šŸœj˜mKšŸœ1˜6—K˜
—šŸœ
 œŸœ˜3KšŸœm˜pK˜
——K˜K˜—š œ˜%š
¢™šŸœ
 
œŸœ!˜FšŸœ‰
˜Œ
KšŸœf˜k—K˜
—šŸœ
 œŸœ
˜1KšŸœƒ
˜†
K˜
—K˜—š
¢™K˜KšŸœ
�œŸœ˜5˜šŸœ[˜^KšŸœ8˜=KšŸœ-˜2KšŸœF˜KKšŸœ(˜-———˜K˜——š œ˜*š
¢™K˜šŸœ
 
œŸœ!˜FšŸœ’
˜•
KšŸœj˜o—K˜
—K˜šŸœ
 œŸœ
˜1KšŸœŠ
˜�
K˜
—K˜—š
¢™K˜šŸœ
ÐbnœŸœ(˜HšŸœž
˜¡
KšŸœF˜KKšŸœ"˜'KšŸœ(˜-—K˜
——š
¢™šŸœ
 œŸœ˜)KšŸœ/˜2K˜
—šŸœ
 
œŸœ˜*KšŸœ0˜3K˜
—šŸœ
 œŸœ˜*KšŸœ1˜4K˜
—K˜—˜K˜——š œ˜*š
¢	™	šŸœ
 œŸœ#˜IšŸœ‘
˜”
KšŸœY˜^—šŸœ€
˜ƒ
KšŸœT˜Y—šŸœž
˜¡
KšŸœc˜h—šŸœM˜PKšŸœB˜GKšŸœ$˜)—šŸœ`˜cKšŸœB˜G—K˜
—K˜šŸœ
 
œŸœ
˜/KšŸœ‡
˜Š
KšŸœx˜{KšŸœ–
˜™
šŸœC˜FKšŸœ$˜)—KšŸœV˜YK˜
——š
¢™šŸœ
 œŸœ˜'šŸœn˜qKšŸœK˜P—šŸœJ˜MKšŸœN˜SK˜—šŸœ“
˜–
KšŸœ1˜6—KšŸœ,˜/KšŸœX˜[K˜
K˜—šŸœ
 œŸœ˜9šŸœo˜rKšŸœU˜Z—šŸœJ˜MKšŸœN˜SK˜—šŸœ“
˜–
KšŸœ1˜6—KšŸœ6˜9šŸœX˜[KšŸœ;˜@—K˜
——š
¢™šŸœ
�œŸœ˜1šŸœF˜IKšŸœ#˜(—K˜
——š
ž™šŸœ
 œŸœ˜*KšŸœ$˜'K˜
—šŸœ
 œŸœ˜2šŸœI˜LK˜
———K˜K˜—š œ˜&š
¢™šŸœ
 œŸœ˜-KšŸœq˜tK˜
K˜—šŸœ
 œŸœ˜AšŸœN˜QKšŸœS˜XKšŸœU˜ZKšŸœ+˜0—K˜—K˜—K˜K˜—š�œ˜"š
Ñbiz™šŸœ
 
œŸœ˜)KšŸœ*˜-Kš
œ
˜
K˜—šŸœ
 œŸœ˜5KšŸœ-˜0Kš
œ
˜
K˜—šŸœ
 œŸœ˜4KšŸœ4˜7K˜
——š
¤™šŸ œŸœ˜%KšŸœ˜Kš
œ
˜
—šŸ œŸœ˜>KšŸœŸœ˜@—šŸ 
œŸœ˜3KšŸœŸœ˜@—šŸ œŸœ ˜CKšŸœŸœ˜@—šŸ œŸœ˜6KšŸœŸœ˜@—šŸ œŸœ˜7KšŸœŸœ˜@—šŸ œŸœ˜'KšŸœŸœ˜@—šŸ 
œŸœ˜6KšŸœŸœ˜@—šŸ œŸœ)˜OKšŸœŸœ˜@—šŸ œŸœ+˜MKšŸœŸœ˜@—šŸ œŸœ˜7KšŸœŸœ˜@—šŸ œŸœ˜8KšŸœŸœ˜@—šŸ œŸœ˜'KšŸœŸœ˜@—šŸ œŸœ˜-KšŸœŸœ˜@—šŸ 
œŸœ
˜+KšŸœŸœ˜@—šŸ 	œŸœ	˜)KšŸœŸœ˜@—šŸ 	œŸœ	˜)KšŸœŸœ˜@—šŸ œŸœ˜:KšŸœŸœ˜@—šŸ 
œŸœ˜5KšŸœŸœ˜@—šŸ 
œŸœ˜@KšŸœŸœ˜@—šŸ œŸœ˜8KšŸœŸœ˜@—šŸ œŸœ˜/KšŸœŸœ˜@—šŸ 
œŸœ˜<KšŸœŸœ˜@—šŸ œŸœ˜-KšŸœŸœ˜@—šŸ œŸœ˜-KšŸœŸœ˜@—šŸ œŸœ(˜GKšŸœŸœ˜@—šŸ 	œŸœ˜9KšŸœŸœ˜@—šŸ 
œŸœ˜:KšŸœŸœ˜@—šŸ œŸœ˜#KšŸœŸœ˜@—šŸ œŸœ˜6KšŸœŸœ˜@—šŸ 	œŸœ˜,KšŸœŸœ˜@—šŸ 
œŸœ˜2KšŸœŸœ˜@—šŸ 	œŸœ˜,KšŸœŸœ˜@—šŸ 
œŸœ˜2KšŸœŸœ˜@—šŸ 
œŸœ˜-KšŸœŸœ˜@—šŸ œŸœ˜3KšŸœŸœ˜@—šŸ 
œŸœ˜-KšŸœŸœ˜@—šŸ œŸœ˜3KšŸœŸœ˜@—šŸ 
œŸœ˜-KšŸœŸœ˜@—šŸ œŸœ˜3KšŸœŸœ˜@—šŸ œŸœ˜3KšŸœŸœ˜@—šŸ œŸœ˜+KšŸœŸœ˜@—šŸ œŸœ
˜3KšŸœŸœ˜@—šŸ 
œŸœ˜%KšŸœŸœ˜@—šŸ 
œŸœ˜8KšŸœŸœ˜@——˜K˜——š�œ˜š
¤™M™IšŸœ
�œŸœ/˜LKšŸœ,˜/™aš
œJ˜JKšŸœ"˜'——KšŸœ-˜0™@Kš
œW˜WKšŸœj˜ošŸœ1˜6K™ƒ
—šŸœ4˜9K™E—KšŸœU˜ZKšŸœ(˜-—Kš
œ
˜
Kš
œ™——š
¡™šŸ œŸœ˜*šŸœM˜PMš
œ-˜-MšŸœ$˜)M™.—šŸœI˜LMš
œ+˜+MšŸœ˜#M™.—šŸœ8˜;Mš
œ ˜ —Mš
œ
˜
—MšŸ œŸœ˜<Mš
œK™K™9šŸœN˜QKš
œ:˜:šŸœ=˜BMšŸœ$˜)—Kš¡œ2˜7KšŸœN˜SKšŸœ(˜-K˜—šŸœJ˜MKš
œ:˜:šŸœ;˜@MšŸœ˜#—Kš¡œ2˜7KšŸœN˜SKšŸœ(˜-—K˜šŸœ8˜;Kš
œ:˜:KšŸœJ˜O—K˜
——š
Ÿ™šŸœ
 œŸœ˜2šŸœ8˜;Kš
œ0˜0KšŸœA˜F—Mš
œ
˜
—šŸœ
 œŸœ˜0šŸœ8˜;Kš
œ*˜*KšŸœA˜F—Mš
œ
˜
——š
Ÿ
™
šŸœ
 œŸœ˜-KšŸœZ˜]KšŸœj˜mK˜—šŸœ
 œŸœ˜6šŸœs˜vKšŸœB˜G—K˜KšŸœ‹
˜Ž
Kš
œ
˜
——š
Ÿ™šŸœ
 œŸœ˜CšŸœp˜sKšŸœ?˜D—šŸœj˜mKšŸœH˜MK˜—šŸœx˜{KšŸœN˜S—K˜šŸœ‘
˜”
KšŸœZ˜_—K˜Kš
œ
˜
K˜—šŸœ
 œŸœ˜3šŸœp˜sKšŸœ?˜D—šŸœ0˜3Kš
œ4˜4K˜—šŸœ7˜:Kš
œ;˜;—K˜KšŸœ�
˜’
Kš
œ
˜
——š
Ÿ™šŸœ
 œŸœ˜MKšŸœ|˜šŸœ•
˜˜
KšŸœG˜LKšŸœ7˜<KšŸœ˜#—KšŸœi˜lJš
œ
˜
J™K˜—šŸœ
 œŸœ8˜`KšŸœ˜‚
šŸœ—
˜š
KšŸœG˜LKšŸœ(˜-—KšŸœi˜lKš
œ
˜
—M˜šŸœ
 œŸœ@˜iKšŸœQ˜TKšŸœY˜\KšŸœi˜lJš
œ
˜
J™——š
Ÿ™šŸ œŸœ˜*MšŸœ#˜&Mš
œ
˜
—šŸ œŸœ˜/MšŸœ%˜(Mš
œ
˜
—L˜—š
Ñinz
™
šŸœ
 œŸœ˜/KšŸœi˜lKš
œ
˜
K˜—šŸœ
 œŸœ˜GšŸœŽ
˜‘
KšŸœ\˜a—Kš
Ÿ
˜
——š
¥	™	šŸœ
 œŸœ˜;KšŸœ�
˜�
Kš
œ
˜
—K™K™šŸœ
 œŸœ0˜\šŸœ—
˜š
KšŸœa˜f—Kš
Ÿ
˜
—šŸœ
 œŸœ.˜VKšŸœi˜lKš
Ÿ
˜
—šŸœ
 
œŸœ˜-KšŸœi˜lKš
Ÿ
˜
—K™K˜šŸœ
 œŸœ˜>KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜>KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜:KšŸœ‰
˜Œ
Kš
Ÿ
˜
Kš
œ%™%—KšŸœ
 œŸœ%˜Rš
œ
˜
KšŸœi˜lKš
Ÿ
˜
—K˜šŸœ
 œŸœ˜*KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜*KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜-KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜4KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜<KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜;KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜.KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜+KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜*KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜*KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜4KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜,KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜.KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜+KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜2KšŸœi˜lKš
Ÿ
˜
—šŸœ
 œŸœ˜2KšŸœi˜lKš
Ÿ
˜
—K˜K˜K˜—š
¥™šŸœ
�œŸœ˜1šŸœu˜xKšŸœ<˜A—Kš
œ
˜
Kš
œ™K˜——K˜K˜—K˜K™K™—…—Ëxÿ3