DIRECTORY Basics, NodeStyleExtra, NodeStyle, NodeStyleObject, TextNode, TextLooks, EditNotify, NodeProps, NameSymbolTable, JaMOps; NodeStyleApplyImpl: CEDAR MONITOR IMPORTS Basics, JaMOps, TextNode, EditNotify, NodeProps, NodeStyle, NodeStyleExtra, NameSymbolTable EXPORTS NodeStyle, NodeStyleExtra = BEGIN OPEN NodeStyle, NodeStyleExtra; defaultStyle: PUBLIC Ref; defaultName, rootName: Name; ApplyAll: PUBLIC PROC [ref: Ref, node: TextNode.Ref, kind: OfStyle _ screen] = { [] _ DoApplyAll[ref,node,kind] }; DoApplyAll: PROC [ref: Ref, node: TextNode.Ref, kind: OfStyle] RETURNS [depth: CARDINAL] = { found: BOOLEAN; parent: TextNode.Ref; alt: Name; IF node=NIL THEN { ref^ _ defaultStyle^; RETURN [0] }; [found,depth] _ FindInApplyAllCache[ref,node,kind]; IF found THEN RETURN [depth+1]; parent _ TextNode.Parent[node]; alt _ IF parent=NIL THEN rootName ELSE defaultName; depth _ DoApplyAll[ref,parent,kind]; ApplyForNode[ref,node,alt,kind]; EnterInApplyAllCache[ref,node,depth]; RETURN [depth+1] }; applyCacheInfo: REF ApplyCacheRecord _ TextNode.pZone.NEW[ApplyCacheRecord]; ApplyCacheRecord: TYPE = RECORD [ applyCacheDepth: CARDINAL _ 0, -- next free entry applyCacheResults: REF ApplyCacheResults, applyCacheNodes: REF ApplyCacheNodes, applyCacheProbes, applyCacheHits, applyCacheSaves: INT _ 0 ]; applyCacheSize: CARDINAL = 8; -- number of levels deep in tree ApplyCacheNodes: TYPE = ARRAY [0..applyCacheSize) OF TextNode.Ref; ApplyCacheResults: TYPE = ARRAY [0..applyCacheSize) OF StyleBody; InitApplyCacheRecord: PROC = { OPEN applyCacheInfo; applyCacheResults _ TextNode.pZone.NEW[ApplyCacheResults]; applyCacheNodes _ TextNode.pZone.NEW[ApplyCacheNodes] }; RemoveAllFromApplyAllCache: PUBLIC PROC = { FlushApplyAllCache[] }; FlushApplyAllCache: PUBLIC ENTRY PROC [init: BOOLEAN _ FALSE] = { ENABLE UNWIND => NULL; ClearApplyAllCache[init] }; ClearApplyAllCache: PROC [init: BOOLEAN] = { OPEN applyCacheInfo; nodes: REF ApplyCacheNodes _ applyCacheNodes; FOR i:CARDINAL IN [0..applyCacheSize) DO nodes[i] _ NIL; ENDLOOP; applyCacheDepth _ 0 }; RemoveNodeFromApplyAllCache: PUBLIC ENTRY PROC [node: TextNode.Ref] = { OPEN applyCacheInfo; ENABLE UNWIND => NULL; nodes: REF ApplyCacheNodes _ applyCacheNodes; FOR i:CARDINAL IN [0..applyCacheDepth) DO IF nodes[i]=node THEN { -- clear from here on FOR j:CARDINAL IN [i..applyCacheSize) DO nodes[j] _ NIL; ENDLOOP; applyCacheDepth _ i; EXIT }; ENDLOOP }; FindInApplyAllCache: ENTRY PROC [ref: Ref, node: TextNode.Ref, kind: OfStyle] RETURNS [found: BOOLEAN, depth: CARDINAL] = { OPEN applyCacheInfo; ENABLE UNWIND => NULL; nodes: REF ApplyCacheNodes _ applyCacheNodes; print: BOOL = (kind=print); -- if true, then find result with print true also applyCacheProbes _ applyCacheProbes+1; FOR i:CARDINAL DECREASING IN [0..applyCacheDepth) DO IF nodes[i]=node AND print=applyCacheResults[i].print THEN { -- found it applyCacheHits _ applyCacheHits+1; applyCacheSaves _ applyCacheSaves+i+1; ref^ _ applyCacheResults[i]; RETURN [TRUE, i] }; ENDLOOP; RETURN [FALSE, 0] }; EnterInApplyAllCache: ENTRY PROC [ref: Ref, node: TextNode.Ref, depth: CARDINAL] = { OPEN applyCacheInfo; ENABLE UNWIND => NULL; nodes: REF ApplyCacheNodes _ applyCacheNodes; IF depth >= applyCacheSize THEN RETURN; nodes[depth] _ node; applyCacheResults[depth] _ ref^; FOR i:CARDINAL IN [depth+1..applyCacheSize) DO nodes[i] _ NIL; ENDLOOP; applyCacheDepth _ depth+1 }; prefixAtom: ATOM = NodeProps.PrefixAtom[]; postfixAtom: ATOM = NodeProps.PostfixAtom[]; Notify: PROC [change: REF READONLY EditNotify.Change] = TRUSTED { DoNode: PROC [node: TextNode.Ref] = TRUSTED { IF TextNode.FirstChild[node] # NIL THEN FlushApplyAllCache ELSE RemoveNodeFromApplyAllCache[node] }; WITH x:change SELECT FROM InsertingNode => IF TextNode.FirstChild[x.new] # NIL THEN FlushApplyAllCache; MovingNodes => FlushApplyAllCache; NodeNesting => IF x.first = x.last -- only changing one node AND TextNode.FirstChild[x.first] = NIL -- node has no children THEN SELECT x.change FROM 1 => -- increasing nesting in tree IF TextNode.Next[x.first] = NIL THEN RemoveNodeFromApplyAllCache[x.first] ELSE FlushApplyAllCache; -1 => -- decreasing nesting in tree RemoveNodeFromApplyAllCache[x.first]; ENDCASE => FlushApplyAllCache ELSE FlushApplyAllCache; ChangingType => DoNode[x.node]; ChangingProp => SELECT x.propAtom FROM prefixAtom, postfixAtom, $Comment, $StyleDef => DoNode[x.node]; ENDCASE; ENDCASE => ERROR; -- not expecting notify for any other kinds of changes }; ApplyForNode: PUBLIC PROC [ref: Ref, node: TextNode.Ref, alt: Name, kind: OfStyle] = { text: TextNode.RefTextNode = TextNode.NarrowToTextNode[node]; ext: ATOM; ref.isComment _ IF text # NIL THEN text.comment ELSE FALSE; ref.print _ (kind=print); ref.nestingLevel _ MIN[TextNode.Level[node], MaxNestingLevel]; EvalFreeVars[ref, node]; IF node.hasstyledef THEN { localStyle: LocalStyle _ NARROW[NodeProps.GetProp[node, $StyleDef]]; IF localStyle # NIL THEN ref.name[style] _ localStyle.name }; IF node.hasprefix THEN ApplyObject[ref, NodeProps.GetPrefixObject[node], kind] ELSE IF ref.nestingLevel=0 -- root node -- AND -- check for file extension default (ext _ NARROW[NodeProps.GetProp[node, $FileExtension]])#NIL THEN FOR list: LIST OF ExtObjPair _ defaultStylesForExtensions, list.rest UNTIL list=NIL DO IF list.first.fileExtension # ext THEN LOOP; ApplyObject[ref, list.first.styleObject, kind]; EXIT; ENDLOOP; ApplyType[ref, node.typename, alt, kind]; IF node.haspostfix THEN ApplyObject[ref,NodeProps.GetPostfixObject[node],kind] }; ApplyType: PUBLIC PROC [ref: Ref, name, alt: Name, kind: OfStyle _ screen] = { OPEN ruleCacheInfo; names: REF RuleCacheNames _ ruleCacheNames; inputs: REF RuleCacheBodies _ ruleCacheInputs; input: StyleBody; initloc, loc: CARDINAL; FindInRuleCache: ENTRY PROC RETURNS [BOOLEAN] = { ENABLE UNWIND => NULL; ruleCacheProbes _ ruleCacheProbes+1; DO -- search cache SELECT names[loc] FROM name => IF inputs[loc] = ref^ THEN { ref^ _ ruleCacheResults[loc]; ruleCacheHits _ ruleCacheHits+1; RETURN [TRUE] }; TextNode.nullTypeName => RETURN [FALSE]; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM ruleCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE]; initloc => RETURN [FALSE]; ENDCASE; ENDLOOP }; PutInRuleCache: ENTRY PROC = { ENABLE UNWIND => NULL; IF ruleCacheCount = ruleCacheMax THEN ClearRuleCache[]; loc _ initloc; DO -- search cache for place to put the entry SELECT names[loc] FROM name => IF inputs[loc] = input THEN RETURN; -- already in cache TextNode.nullTypeName => EXIT; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM ruleCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full initloc => ERROR; -- cache full ENDCASE; ENDLOOP; ruleCacheCount _ ruleCacheCount+1; inputs[loc] _ input; ruleCacheResults[loc] _ ref^; names[loc] _ name }; ok: BOOLEAN; frame: Frame _ NIL; styleName: Name; IF name = TextNode.nullTypeName AND (name _ alt) = TextNode.nullTypeName THEN RETURN; loc _ initloc _ Basics.BITXOR[LOOPHOLE[name,CARDINAL],Hash[ref]] MOD ruleCacheSize; IF FindInRuleCache[] THEN RETURN; frame _ GetFrame[ref, styleName _ ref.name[style], kind]; input _ ref^; -- save the input value of the record ok _ ExecuteName[frame,name]; FreeFrame[frame,styleName,kind]; frame _ NIL; IF ok THEN PutInRuleCache[] -- save results in cache ELSE IF name # alt THEN ApplyType[ref,alt,TextNode.nullTypeName] }; ruleCacheInfo: REF RuleCacheInfoRecord _ TextNode.pZone.NEW[RuleCacheInfoRecord]; RuleCacheInfoRecord: TYPE = RECORD [ ruleCacheCount: CARDINAL _ 0, -- number of entries currently in use ruleCacheNames: REF RuleCacheNames, ruleCacheInputs: REF RuleCacheBodies, ruleCacheResults: REF RuleCacheBodies, ruleCacheProbes, ruleCacheHits: INT _ 0 ]; ruleCacheSize: CARDINAL = 64; -- should be a power of 2 ruleCacheMax: CARDINAL = (ruleCacheSize*4)/5; -- don't fill too full RuleCacheNames: TYPE = ARRAY [0..ruleCacheSize) OF TextNode.TypeName; RuleCacheBodies: TYPE = ARRAY [0..ruleCacheSize) OF StyleBody; InitRuleCacheInfo: PROC = { OPEN ruleCacheInfo; ruleCacheNames _ TextNode.pZone.NEW[RuleCacheNames]; ruleCacheInputs _ TextNode.pZone.NEW[RuleCacheBodies]; ruleCacheResults _ TextNode.pZone.NEW[RuleCacheBodies] }; FlushRuleCache: ENTRY PROC [init: BOOLEAN _ FALSE] = { ENABLE UNWIND => NULL; ClearRuleCache[] }; ClearRuleCache: PROC [init: BOOLEAN _ FALSE] = { OPEN ruleCacheInfo; names: REF RuleCacheNames _ ruleCacheNames; IF ~init AND ruleCacheCount = 0 THEN RETURN; ruleCacheCount _ 0; FOR i: CARDINAL IN [0..ruleCacheSize) DO names[i] _ TextNode.nullTypeName; ENDLOOP }; Hash: PROC [ref: Ref] RETURNS [CARDINAL] = { RETURN [LOOPHOLE[ Basics.BITXOR[LOOPHOLE[ref.name[style]], Basics.BITXOR[LOOPHOLE[ref.name[fontFamily],CARDINAL], Basics.BITXOR[ref.real[fontSize], Basics.BITXOR[ref.real[leftIndent], ref.real[leading]]]]],CARDINAL]] }; ApplyLooks: PUBLIC PROC [ref: Ref, looks: TextLooks.Looks, kind: OfStyle] = { OPEN looksCacheInfo; lks: REF LooksCacheLooks _ looksCacheLooks; inputs: REF LooksCacheBodies _ looksCacheInputs; initloc, loc: CARDINAL; input: StyleBody; FindInLooksCache: ENTRY PROC RETURNS [BOOLEAN] = { ENABLE UNWIND => NULL; looksCacheProbes _ looksCacheProbes+1; DO -- search cache SELECT lks[loc] FROM looks => IF inputs[loc] = ref^ THEN { ref^ _ looksCacheResults[loc]; looksCacheHits _ looksCacheHits+1; RETURN [TRUE] }; TextLooks.noLooks => RETURN [FALSE]; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM looksCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE]; initloc => RETURN [FALSE]; ENDCASE; ENDLOOP }; PutInLooksCache: ENTRY PROC = { ENABLE UNWIND => NULL; IF looksCacheCount = looksCacheMax THEN ClearLooksCache[]; loc _ initloc; DO -- search cache SELECT lks[loc] FROM looks => IF inputs[loc] = input THEN RETURN; -- already in cache TextLooks.noLooks => EXIT; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM looksCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full initloc => ERROR; -- cache full ENDCASE; ENDLOOP; looksCacheResults[loc] _ ref^; lks[loc] _ looks; inputs[loc] _ input; looksCacheCount _ looksCacheCount+1 }; frame: Frame _ NIL; styleName: Name; IF looks = TextLooks.noLooks THEN RETURN; loc _ initloc _ Basics.BITXOR[LOOPHOLE[looks, TextLooks.LooksBytes].byte0, Basics.BITXOR[LOOPHOLE[looks, TextLooks.LooksBytes].byte1, Basics.BITXOR[LOOPHOLE[looks, TextLooks.LooksBytes].byte2, Hash[ref]]]] MOD looksCacheSize; IF FindInLooksCache[] THEN RETURN; frame _ GetFrame[ref, styleName _ ref.name[style], kind]; input _ ref^; -- save the input value of the record FOR c: CHARACTER IN TextLooks.Look DO IF looks[c] THEN [] _ ExecuteName[frame,lookNames[c]] ENDLOOP; FreeFrame[frame,styleName,kind]; frame _ NIL; PutInLooksCache[] }; looksCacheInfo: REF LooksCacheInfoRecord _ TextNode.pZone.NEW[LooksCacheInfoRecord]; LooksCacheInfoRecord: TYPE = RECORD [ looksCacheCount: CARDINAL _ 0, looksCacheLooks: REF LooksCacheLooks, looksCacheInputs: REF LooksCacheBodies, looksCacheResults: REF LooksCacheBodies, looksCacheProbes, looksCacheHits: INT _ 0 ]; looksCacheSize: CARDINAL = 16; -- should be a power of 2 looksCacheMax: CARDINAL = (looksCacheSize*4)/5; -- don't fill too full LooksCacheLooks: TYPE = ARRAY [0..looksCacheSize) OF TextLooks.Looks; LooksCacheBodies: TYPE = ARRAY [0..looksCacheSize) OF StyleBody; InitLooksCacheInfo: PROC = { OPEN looksCacheInfo; looksCacheLooks _ TextNode.pZone.NEW[LooksCacheLooks]; looksCacheInputs _ TextNode.pZone.NEW[LooksCacheBodies]; looksCacheResults _ TextNode.pZone.NEW[LooksCacheBodies]; }; lookNames: ARRAY TextLooks.Look OF Name; FlushLooksCache: ENTRY PROC [init: BOOLEAN _ FALSE] = { ENABLE UNWIND => NULL; ClearLooksCache[] }; ClearLooksCache: PROC [init: BOOLEAN _ FALSE] = { OPEN looksCacheInfo; IF ~init AND looksCacheCount = 0 THEN RETURN; looksCacheCount _ 0; FOR i: CARDINAL IN [0..looksCacheSize) DO looksCacheLooks[i] _ TextLooks.noLooks; ENDLOOP }; nullObject: NameSymbolTable.Object = NameSymbolTable.NullObject[]; ApplyObject: PUBLIC PROC [ref: Ref, object: NameSymbolTable.Object, kind: OfStyle _ screen] = { OPEN objectCacheInfo; objects: REF ObjectCacheObjects _ objectCacheObjects; inputs: REF ObjectCacheBodies _ objectCacheInputs; input: StyleBody; initloc, loc: CARDINAL; initDepth, finalDepth: CARDINAL; obj: Object _ LOOPHOLE[object]; FindInObjectCache: ENTRY PROC RETURNS [BOOLEAN] = { ENABLE UNWIND => NULL; objectCacheProbes _ objectCacheProbes+1; DO -- search cache SELECT objects[loc] FROM object => IF inputs[loc] = ref^ THEN { ref^ _ objectCacheResults[loc]; objectCacheHits _ objectCacheHits+1; RETURN [TRUE] }; nullObject => RETURN [FALSE]; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM objectCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE]; initloc => RETURN [FALSE]; ENDCASE; ENDLOOP }; PutInObjectCache: ENTRY PROC = { ENABLE UNWIND => NULL; IF objectCacheCount = objectCacheMax THEN ClearObjectCache[]; loc _ initloc; DO -- search cache for place to put the entry SELECT objects[loc] FROM object => IF inputs[loc] = input THEN RETURN; -- already in cache nullObject => EXIT; -- this is an unused entry ENDCASE; SELECT (loc _ loc+1) FROM objectCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full initloc => ERROR; -- cache full ENDCASE; ENDLOOP; objectCacheCount _ objectCacheCount+1; inputs[loc] _ input; objectCacheResults[loc] _ ref^; objects[loc] _ object }; HashObject: PROC RETURNS [CARDINAL] = { ob: RECORD [ a, b, c, d: CARDINAL ] _ LOOPHOLE[object]; RETURN [ob.b] }; frame: Frame _ NIL; styleName: Name; IF object = nullObject THEN RETURN; loc _ initloc _ Basics.BITXOR[HashObject[],Hash[ref]] MOD objectCacheSize; IF FindInObjectCache[] THEN RETURN; frame _ GetFrame[ref, styleName _ ref.name[style], kind]; input _ ref^; -- save the input value of the record TRUSTED {initDepth _ JaMOps.CountStack[frame.opstk]; JaMOps.Execute[frame,CVX[obj]]; IF (finalDepth _ JaMOps.CountStack[frame.opstk]) # initDepth THEN { PushObject[frame,obj]; PushText[frame,"Failed to leave stack at same depth after execution. "]; StyleError[frame,2] } ELSE PutInObjectCache[]}; FreeFrame[frame,styleName,kind]; frame _ NIL }; objectCacheInfo: REF ObjectCacheInfoRecord _ TextNode.pZone.NEW[ObjectCacheInfoRecord]; ObjectCacheInfoRecord: TYPE = RECORD [ objectCacheCount: CARDINAL, objectCacheObjects: REF ObjectCacheObjects, objectCacheInputs: REF ObjectCacheBodies, objectCacheResults: REF ObjectCacheBodies, objectCacheProbes, objectCacheHits: INT _ 0 ]; objectCacheSize: CARDINAL = 16; -- should be a power of 2 objectCacheMax: CARDINAL = (objectCacheSize*4)/5; -- don't fill too full ObjectCacheObjects: TYPE = ARRAY [0..objectCacheSize) OF NameSymbolTable.Object; ObjectCacheBodies: TYPE = ARRAY [0..objectCacheSize) OF StyleBody; InitObjectCacheInfo: PROC = { OPEN objectCacheInfo; objectCacheObjects _ TextNode.pZone.NEW[ObjectCacheObjects]; objectCacheInputs _ TextNode.pZone.NEW[ObjectCacheBodies]; objectCacheResults _ TextNode.pZone.NEW[ObjectCacheBodies] }; FlushObjectCache: ENTRY PROC [init: BOOLEAN _ FALSE] = { ENABLE UNWIND => NULL; ClearObjectCache[] }; ClearObjectCache: PROC [init: BOOLEAN _ FALSE] = { OPEN objectCacheInfo; IF ~init AND objectCacheCount = 0 THEN RETURN; objectCacheCount _ 0; FOR i: CARDINAL IN [0..objectCacheSize) DO objectCacheObjects[i] _ nullObject; ENDLOOP }; FlushCaches: PUBLIC ENTRY PROC = { ENABLE UNWIND => NULL; ClearCaches[FALSE] }; ClearCaches: PROC [init: BOOLEAN] = { ClearApplyAllCache[init]; ClearRuleCache[init]; ClearLooksCache[init]; ClearObjectCache[init] }; executingName: PUBLIC Name; ExecuteName: PROC [frame: Frame, name: Name] RETURNS [ok: BOOLEAN] = TRUSTED { initDepth: CARDINAL _ JaMOps.CountStack[frame.opstk]; finalDepth: CARDINAL; nameObj: Object; [ok,] _ JaMOps.TryToLoad[frame, nameObj _ NameToObject[name]]; IF ~ok THEN RETURN; executingName _ name; JaMOps.Execute[frame,CVX[nameObj]]; executingName _ NameSymbolTable.nullName; IF (finalDepth _ JaMOps.CountStack[frame.opstk]) # initDepth THEN { PushText[frame,"failed to leave stack at same depth after execution."]; PushName[frame,name]; StyleError[frame,2] }}; StyleError: PUBLIC PROC [frame: Frame, num: INTEGER] = TRUSTED { PushInteger[frame,num]; JaMOps.Execute[frame,CVX[NameToObject[styleerror]]] }; StyleNameForNode: PUBLIC PROC [node: TextNode.Ref] RETURNS [name: Name] = { s: Ref _ Alloc[]; ApplyAll[s, node]; name _ GetStyleName[s]; Free[s] }; started: BOOLEAN _ FALSE; InitLookNames: PROC = TRUSTED { txt: STRING _ [6]; txt[0] _ 'l; txt[1] _ txt[2] _ 'o; txt[3] _ 'k; txt[4] _ '.; txt.length _ 6; FOR c: CHARACTER IN TextLooks.Look DO txt[5] _ c; lookNames[c] _ MakeName[LOOPHOLE[LONG[txt],REF READONLY TEXT]]; ENDLOOP}; StartApply: PUBLIC PROCEDURE = BEGIN changeSet: EditNotify.ChangeSet; frame: Frame _ NIL; IF started THEN RETURN; started _ TRUE; frame _ JaMOps.defaultFrame; changeSet[ChangingProp] _ TRUE; changeSet[ChangingType] _ TRUE; changeSet[MovingNodes] _ TRUE; changeSet[NodeNesting] _ TRUE; changeSet[InsertingNode] _ TRUE; EditNotify.AddNotifyProc[Notify,after,high,changeSet]; defaultStyle _ Create[]; defaultName _ MakeName["default"]; rootName _ MakeName["root"]; InitLookNames[]; InitApplyCacheRecord[]; InitRuleCacheInfo[]; InitLooksCacheInfo[]; InitObjectCacheInfo[]; ClearCaches[TRUE]; SetDefaultStyle["Cedar"]; END; StartApply; END. @NodeStyleApplyImpl.Mesa written by Bill Paxton, January 1981 Paxton, December 21, 1982 9:55 am Maxwell, January 6, 1983 9:50 am Russ Atkinson, July 25, 1983 5:22 pm -- Apply operations -- when clearing, go all the way to applyCacheSize rather than stopping at applyCacheDepth -- if change invalidates one node only, remove that node -- else clear entire cache -- ***** Execute -- makes sure that same stack depth after execute -- ***** Miscellaneous -- does an ApplyAll and then returns the style name -- Initialization -- names are "look.a", "look.b", "look.c", etc. Êd˜šÏc™Jš$™$Jš!™!J™ J™$J™—šÏk ˜ J˜J˜J˜ J˜J˜ J˜ J˜ J˜ J˜J˜J˜—šœž ˜!šž˜Jšœ[˜[—Jšžœ˜!Jšœž œ˜'—J˜Jš™J˜Jšœžœ˜J˜J˜šÏnœžœžœ;˜PJ˜!J˜—šŸ œžœ/žœ žœ˜\Jšœžœ˜J˜J˜ Jšžœžœžœžœ˜6J˜3Jšžœžœžœ ˜J˜Jš œžœžœžœ žœ ˜3J˜$J˜ J˜%Jšžœ ˜J˜—Jšœžœ#žœ˜Lšœžœžœ˜!Jšœžœ˜2Jšœžœ˜)Jšœžœ˜%Jšœ3žœ˜=—Jšœžœ ˜>Jšœžœžœžœ˜BJšœžœžœžœ ˜BJ˜šŸœžœžœ˜3Jšœ#žœ˜:Jšœ!žœ˜8J˜—šŸœžœžœ˜CJ˜—š Ÿœž œžœžœžœ˜AJšžœžœžœ˜J˜J˜—šŸœžœžœžœ˜AJšœžœ#˜-JšZ™ZJš žœžœžœžœ žœžœ˜AJ˜J˜—šŸœž œžœ˜GJšžœ˜Jšžœžœžœ˜Jšœžœ#˜-šžœžœžœžœ˜*šžœžœ˜-šžœžœžœž˜(Jšœ žœžœ˜—Jšœžœ˜—Jšžœ˜ —J˜—šŸœžœžœ.˜MJšžœ žœ žœžœ˜BJšžœžœžœ˜Jšœžœ#˜-Jšœžœ1˜MJ˜&š žœžœž œžœž˜4šžœžœ"žœ ˜HJ˜"J˜&J˜Jšžœžœ˜—Jšžœ˜—Jšžœžœ˜J˜—šŸœžœžœ'žœ˜TJšžœ˜Jšžœžœžœ˜Jšœžœ#˜-Jšžœžœžœ˜'J˜J˜ Jš žœžœžœžœ žœžœ˜GJ˜J˜—Jšœ žœ˜*Jšœ žœ˜,J˜š Ÿœžœ žœžœžœ˜AJš8™8Jš™šŸœžœžœ˜-Jšžœžœžœ˜:Jšžœ%˜)—Jšžœ žœž˜Jšœžœžœžœ˜MJ˜"šœžœ˜šžœžœ ž˜šœ˜"Jšžœžœžœ%˜IJšžœ˜—šœ˜#J˜%—Jšžœ˜—Jšžœ˜—J˜šœžœ ž˜&J˜?Jšžœ˜—Jšžœžœ6˜HJ˜J˜—šŸ œžœžœ=˜VJ˜=Jšœžœ˜ Jš œžœžœžœžœžœ˜;Jšœ˜Jšœžœ(˜>J˜šžœžœ˜Jšœžœ%˜DJšžœžœžœ%˜=—Jšžœžœ8˜Nš žœžœœžœ#˜RJšœžœ+žœž˜@š žœžœžœ4žœžœž˜VJšžœ žœžœ˜,Jšœ/˜/Jšžœ˜Jšžœ˜——J˜)šžœžœ:˜QJ˜——šŸ œžœžœ8˜NJšžœ˜Jšœžœ!˜+Jšœžœ#˜.J˜Jšœžœ˜J˜š Ÿœžœžœžœžœ˜1Jšžœžœžœ˜J˜$šžœ˜šžœ ž˜šœžœžœ˜$J˜J˜ Jšžœžœ˜—Jšœžœžœ˜CJšžœ˜—šžœž˜Jš œžœžœžœžœ˜:Jšœ žœžœ˜Jšžœ˜—Jšžœ˜ J˜——šŸœžœžœ˜Jšžœžœžœ˜Jšžœžœ˜7J˜šžœ*˜-šžœ ž˜Jšœžœžœžœ˜?Jšœžœ˜9Jšžœ˜—šžœž˜Jšœžœžœžœ ˜?Jšœ žœ ˜Jšžœ˜—Jšžœ˜—J˜"J˜J˜J˜J˜—Jšœžœ˜ Jšœžœ˜J˜J˜šžœž˜#Jšœ%žœžœ˜1—Jš œžœžœžœ žœ˜SJšžœžœžœ˜!J˜9Jšœ%˜3J˜Jšœ)žœ˜-Jšžœžœ˜4Jšžœžœ žœ,˜CJ˜—Jšœžœ&žœ˜Qšœžœžœ˜$Jšœžœ%˜CJšœžœ˜#Jšœžœ˜%Jšœžœ˜&Jšœ žœ˜*—Jšœžœ˜7Jšœžœ˜DJšœžœžœžœ˜EJšœžœžœžœ ˜>J˜šŸœžœžœ˜/Jšœ žœ˜4Jšœ!žœ˜6Jšœ"žœ˜9J˜—š Ÿœžœžœžœžœ˜6Jšžœžœžœ˜J˜J˜—š Ÿœžœžœžœžœ˜DJšœžœ!˜+Jšžœžœžœžœ˜,J˜šžœžœžœž˜(Jšœ"žœ˜,—J˜—šŸœžœ žœžœ˜-šžœžœ˜šœžœžœ˜(šœžœžœžœ˜6šœžœ˜!šœžœ˜#Jšœžœ˜#J˜——————šŸ œžœžœ6˜MJšžœ˜Jšœžœ#˜+Jšœžœ%˜0Jšœžœ˜J˜J˜š Ÿœžœžœžœžœ˜2Jšžœžœžœ˜J˜&šžœ˜šžœ ž˜šœ žœžœ˜%J˜J˜"Jšžœžœ˜—Jšœžœžœ˜?Jšžœ˜—šžœž˜Jš œžœžœžœžœ˜;Jšœ žœžœ˜Jšžœ˜—Jšžœ˜ J˜——šŸœžœžœ˜Jšžœžœžœ˜Jšžœ!žœ˜:J˜šžœ˜šžœ ž˜Jšœ žœžœžœ˜@Jšœžœ˜5Jšžœ˜—šžœž˜Jšœžœžœžœ ˜@Jšœ žœ ˜Jšžœ˜—Jšžœ˜—J˜J˜J˜J˜&J˜—Jšœžœ˜J˜J˜Jšžœžœžœ˜)šœ˜šœžœžœ$˜:šœžœžœ$˜:šœžœžœ$˜:Jšœ žœ˜ ————Jšžœžœžœ˜"J˜9Jšœ%˜3šžœž œžœž˜%Jšžœ žœ%˜5Jšžœ˜—Jšœ)žœ˜-J˜J˜—Jšœžœ'žœ˜Tšœžœžœ˜%Jšœžœ˜Jšœžœ˜%Jšœžœ˜'Jšœžœ˜(Jšœ"žœ˜,—Jšœžœ˜8Jšœžœ˜FJšœžœžœžœ˜EJšœžœžœžœ ˜@J˜šŸœžœžœ˜1Jšœ!žœ˜6Jšœ"žœ˜8Jšœ#žœ˜9J˜J˜—Jšœ žœžœ˜)J˜š Ÿœžœžœžœžœ˜7Jšžœžœžœ˜J˜J˜—š Ÿœžœžœžœžœ˜FJšžœžœžœžœ˜-J˜šžœžœžœž˜)Jšœ(žœ˜2—J˜—J˜BJ˜šŸ œžœžœG˜_Jšžœ˜Jšœ žœ)˜5Jšœžœ'˜2J˜Jšœžœ˜Jšœžœ˜ Jšœžœ ˜J˜š Ÿœžœžœžœžœ˜3Jšžœžœžœ˜J˜(šžœ˜šžœž˜šœ žœžœ˜&J˜J˜$Jšžœžœ˜—Jšœžœžœ˜8Jšžœ˜—šžœž˜Jš œžœžœžœžœ˜Jšžœžœžœ˜J˜Jšœžœ ˜#Jšœ(ž˜)šžœ;žœ˜CJ˜GJ˜Jšœ˜J˜——š Ÿ œžœžœžœžœ˜@J˜Jšœžœ˜6J˜J˜—Jš™J˜šŸœžœžœžœ˜KJš3™3J˜J˜J˜J˜ J˜J˜—Jš™J˜Jšœ žœžœ˜J˜šŸ œžœžœ˜Jš/™/Jšœžœ˜J˜Lšžœž œžœž˜%J˜ Jš œžœžœžœžœžœ˜?Jšžœ˜ J˜——šŸ œžœž œ˜Jšž˜J˜ Jšœžœ˜J˜Jšžœ žœžœ žœ˜'J˜J˜J˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜ J˜6J˜J˜J˜"J˜J˜J˜J˜J˜J˜J˜Jšœ žœ˜J˜J˜J˜Jšžœ˜J˜—J˜ J˜Jšžœ˜J˜—…—Cœ[@