DIRECTORY Convert USING [ CardFromRope, IntFromRope ], FS USING [ StreamOpen ], IO USING [ card, int, rope, BreakProc, CharClass, Close, GetTokenRope, PutF, PutFR, STREAM ], PriorityQueue USING [ Create, SortPred ], Rope USING [ ROPE, Cat, Concat, Equal, IsEmpty, Length, Substr ], RopeList USING [ Cons, Map ], SiroccoBaseDef USING [ MkCType, SendError ], SiroccoCGDef USING [ Generic, ItemKind, ValueKind ], SymTab USING [ Copy, Create, EachPairAction, Fetch, GetSize, Insert, Key, Pairs, Ref ], SiroccoPrivate USING [ AbstractValue, AbstractValueObject, AquireState, CComponent, CComponentBody, CONTEXT, ContextRep, CType, CTypeBody, Handle, InterfaceItem, ITEM, NodeRep, PQItem, RIB, SCOPE, ScopeRep, TABLES, TablesBody, TypeGraph, TypeGraphNode ]; SiroccoBase1Impl: CEDAR PROGRAM IMPORTS Convert, FS, IO, PriorityQueue, Rope, RopeList, SymTab, SiroccoBaseDef, SiroccoPrivate EXPORTS SiroccoBaseDef, SiroccoPrivate ~ { OPEN SiroccoBaseDef, SiroccoCGDef, SiroccoPrivate; ROPE: TYPE ~ Rope.ROPE; PQFirst: PUBLIC PriorityQueue.SortPred ~ { one: REF PQItem ~ NARROW[x]; two: REF PQItem ~ NARROW[y]; RETURN[( one.position < two.position )]; }; UpdateItem: PUBLIC PROC [ left: TypeGraph, name: ROPE, node: TypeGraphNode, value: AbstractValue ] RETURNS [ new: TypeGraph ] ~ { item: ITEM ~ ItemFromContext[left.context, name]; itemtype: REF NodeRep ~ NARROW[item.type]; itemvalue: REF AbstractValueObject ~ NARROW[item.value]; SELECT TRUE FROM item.type = NIL => { ERROR }; item.value = NIL => { ERROR }; itemtype.specifics # NIL => { ERROR }; itemvalue.specifics # NIL => { ERROR }; ENDCASE => { NULL }; itemtype.specifics _ node; itemvalue.specifics _ value; new _ left; }; CreateContext: PUBLIC PROC [rib: RIB, scope: SCOPE, name: ROPE, pgm: CARD, version: CARD] RETURNS [context: CONTEXT] ~ { scope.id _ name; scope.pgm _ pgm; scope.version _ version; context _ NEW [ContextRep _ [ rib: rib, scope: scope ]]; }; ItemFromContext: PUBLIC PROC [context: CONTEXT, name: ROPE] RETURNS [item: ITEM] ~ { item _ ItemFromScope[context.scope, name]; }; EmptyScope: PUBLIC PROC [] RETURNS [new: SCOPE] ~ { id: ROPE ~ ""; pgm: CARD ~ 0; version: CARD ~ 0; items: SymTab.Ref ~ SymTab.Create[]; tables: TABLES ~ NIL; new _ NEW [ScopeRep _ [ id: id, pgm: pgm, version: version, items: items, tables: tables ]]; }; ItemConcat: PUBLIC PROC [old: SCOPE, item: ITEM] RETURNS [new: SCOPE] ~ { IF ( NOT SymTab.Insert[old.items, item.name, item] ) THEN ERROR; new _ old; }; ItemFromScope: PUBLIC PROC [scope: SCOPE, name: ROPE] RETURNS [item: ITEM] ~ { WITH SymTab.Fetch[scope.items, name].val SELECT FROM i: ITEM => item _ i; ENDCASE => ERROR; }; EmptyRIB: PUBLIC PROC [] RETURNS [new: RIB] ~ { new _ SymTab.Create[]; }; ScopeConcat: PUBLIC PROC [old: RIB, scope: SCOPE] RETURNS [new: RIB] ~ { IF ( NOT SymTab.Insert[old, scope.id, scope] ) THEN ERROR; new _ old; }; ScopeFromRIB: PUBLIC PROC [rib: RIB, name: ROPE] RETURNS [scope: SCOPE] ~ { scope _ NIL; }; ImportItem: PUBLIC PROC [t: TABLES, interface, item: SymTab.Key] RETURNS [entry: InterfaceItem] ~ { entry _ ItemFromInterface[InterfaceFromName[t, interface], item]; }; TypeNameForItem: PUBLIC PROC [entry: InterfaceItem] RETURNS [type: ROPE] ~ { type _ entry.type; }; ConstantForItem: PUBLIC PROC [entry: InterfaceItem] RETURNS [constant: ROPE] ~ { constant _ entry.constant; }; ValueFromName: PUBLIC PROC [constant: ROPE] RETURNS [value: CARD] ~ { value _ Convert.CardFromRope[constant]; }; FetchFromTypeTable: PUBLIC PROC [t1: TABLES, key: ROPE] RETURNS [value: CType] ~ { value _ CTypeFromName[t1, key]; -- just change the name in the ThreeC4 code! }; CTypeFromName: PROC [tables: TABLES, type: ROPE] RETURNS [ctype: CType] ~ { WITH SymTab.Fetch[tables.typeTable, type].val SELECT FROM ct: CType => ctype _ ct; ENDCASE => ERROR; }; ItemFromInterface: PROC [x: SymTab.Ref, name: SymTab.Key] RETURNS [item: InterfaceItem] ~ { WITH SymTab.Fetch[x, name].val SELECT FROM entry: REF InterfaceItem => item _ entry^; ENDCASE => [] _ SendError["Undeclared Remote Identifier"]; }; InterfaceFromName: PROC [t: TABLES, name: SymTab.Key] RETURNS [s: SymTab.Ref] ~ { WITH SymTab.Fetch[t.globalTable, name].val SELECT FROM symtab: SymTab.Ref => s _ symtab; ENDCASE => ERROR; }; Array: PUBLIC PROC [constantType: ROPE, tables: TABLES] RETURNS [yes: BOOLEAN] ~ { ctype: CType ~ CTypeFromName[tables, constantType]; yes _ ( ctype.class = array ); }; CheckCanonicalType: PUBLIC PROC [r1, r2: ROPE] RETURNS [same: BOOLEAN] ~ { IF ( NOT (same _ Rope.Equal[r1, r2]) ) THEN [] _ SendError[Rope.Cat["Type Mismatch Expected ", r2, " found ", r1]]; }; CheckResultsForSourceAndSink: PUBLIC PROC [results: CComponent] RETURNS [ok: BOOLEAN] ~ { ok _ TRUE; FOR tail: CComponent _ results, tail.sibling WHILE ( tail # NIL ) DO IF ( ( Rope.Equal[tail.type, "SOURCE"] ) OR ( Rope.Equal[tail.type, "SINK"] ) ) THEN { [] _ SendError["Result Has Source or Sink"]; ok _ FALSE; EXIT; }; ENDLOOP; }; ClassToRope: PROC [class: Generic] RETURNS [rope: ROPE] ~ { SELECT class FROM array => rope _ "ARRAY"; bool => rope _ "BOOLEAN"; card16 => rope _ "CARDINAL"; card32 => rope _ "LONGCARDINAL"; choice => rope _ "CHOICE"; enum => rope _ "ENUMERATION"; error => rope _ "ERROR"; int16 => rope _ "INTEGER"; int32 => rope _ "LONGINTEGER"; proc => rope _ "PROCEDURE"; record => rope _ "RECORD"; seq => rope _ "SEQUENCE"; sink => rope _ "SINK"; source => rope _ "SOURCE"; string => rope _ "STRING"; unspec => rope _ "UNSPECIFIED"; ENDCASE => ERROR; }; RopeToClass: PROC [rope: ROPE] RETURNS [class: Generic] ~ { SELECT TRUE FROM Rope.Equal[rope, "ARRAY"] => class _ array; Rope.Equal[rope, "BOOLEAN"] => class _ bool; Rope.Equal[rope, "CARDINAL"] => class _ card16; Rope.Equal[rope, "CHOICE"] => class _ choice; Rope.Equal[rope, "ENUMERATION"] => class _ enum; Rope.Equal[rope, "ERROR"] => class _ error; Rope.Equal[rope, "INTEGER"] => class _ int16; Rope.Equal[rope, "LONGCARDINAL"] => class _ card32; Rope.Equal[rope, "LONGINTEGER"] => class _ int32; Rope.Equal[rope, "PROCEDURE"] => class _ proc; Rope.Equal[rope, "RECORD"]=> class _ record; Rope.Equal[rope, "SEQUENCE"] => class _ seq; Rope.Equal[rope, "SINK"] => class _ sink; Rope.Equal[rope, "SOURCE"] => class _ source; Rope.Equal[rope, "STRING"] => class _ string; Rope.Equal[rope, "UNSPECIFIED"] => class _ unspec; ENDCASE => ERROR; }; MkPrimitiveCType: PUBLIC PROC [g: Generic] RETURNS [ctype: CType, name: ROPE] ~ { name _ ClassToRope[g]; ctype _ NEW[CTypeBody _ [bound: 0, children: NIL, class: g]]; }; CompareTypes: PUBLIC PROC [first: CType, second: CType, tables: TABLES] RETURNS [INT _ 1] ~ { Mismatch: PROC ~ { [] _ SendError["Type Mismatch"]; }; CompareCComponents: PROC [first: CComponent, second: CComponent] ~ { SELECT TRUE FROM ( ( first = NIL ) AND ( second = NIL ) ) => RETURN; ( first = NIL ) => Mismatch[]; ( second = NIL ) => Mismatch[]; ( NOT Rope.Equal[first.name, second.name] ) => Mismatch[]; ( first.val # second.val ) => Mismatch[]; ( NOT Rope.Equal[first.type, second.type] ) => { one: CType ~ CTypeFromName[tables, first.type]; two: CType ~ CTypeFromName[tables, second.type]; [] _ CompareTypes[one, two, tables]; }; ENDCASE => NULL; CompareCComponents[first.sibling, second.sibling]; }; SELECT first.class FROM enum, record, choice => { NULL }; -- Comparison of names already done bool, card16, card32, int16, int32, string, unspec => { IF ( first.class # second.class ) THEN Mismatch[]; }; array, seq => { IF ( first.class = second.class ) AND ( first.bound = second.bound ) THEN { CompareCComponents[first.children, second.children]; IF ( GetLengthOfCComponentList[first.children, first.bound] # 0 ) THEN ERROR; } }; proc, error => { IF ( second.class # card16 ) THEN { IF ( first.class # second.class ) OR ( first.bound # second.bound ) THEN Mismatch[] ELSE CompareCComponents[first.children, second.children]; }; }; ENDCASE => { Mismatch[] }; }; TypeOfSequence: PUBLIC PROC [sequenceName: ROPE, tables: TABLES] RETURNS [typeOf: ROPE] ~ { ctype: CType ~ CTypeFromName[tables, sequenceName]; typeOf _ ctype.children.type; }; GetTypeOfComponent: PUBLIC PROC [id: ROPE, name: ROPE, tables: TABLES] RETURNS [typeOf: ROPE] ~ { ctype: CType ~ CTypeFromName[tables, name]; FOR tail: CComponent _ ctype.children, tail.sibling WHILE ( tail # NIL ) DO IF ( Rope.Equal[tail.name, id] ) THEN { typeOf _ tail.type; RETURN }; ENDLOOP; ERROR; }; GetCType: PUBLIC PROC [id: ROPE, list: CComponent, tables: TABLES] RETURNS [type: CType, name: ROPE] ~ { FOR tail: CComponent _ list, tail.sibling WHILE ( tail # NIL ) DO IF ( Rope.Equal[id, tail.name] ) THEN { RETURN[CTypeFromName[tables, tail.name], tail.type]; } ENDLOOP; [] _ SendError["Type Mismatch"]; }; GetTypeOfElement: PUBLIC PROC [name: ROPE, tables: TABLES] RETURNS [typeOf: ROPE] ~ { ctype: CType ~ CTypeFromName[tables, name]; list: CComponent ~ ctype.children; IF ( list = NIL ) THEN ERROR; typeOf _ list.type; }; GetLengthOfCComponentList: PUBLIC PROC [list: CComponent, initial: INT] RETURNS [final: INT] ~ { FOR tail: CComponent _ list, tail.sibling WHILE ( tail # NIL ) DO initial _ initial.PRED; ENDLOOP; final _ (0 - initial); IF ( final >= 0 ) THEN { final _ (0 - initial); RETURN; } ELSE [] _ SendError["Type Mismatch"]; -- Incorrect Length }; SeeIfArrOrSeq: PUBLIC PROC [first: CType, size: CARD, tables: TABLES] RETURNS [type: CType, name: ROPE] ~ { SELECT TRUE FROM ( first.class = array ) => { IF ( first.bound # size ) THEN [] _ SendError["Wrong number of elements in array constant"]; }; ( first.class = seq ) => { IF ( size > first.bound ) THEN [] _ SendError["Too many elements in sequence constant"]; }; ENDCASE => [] _ SendError["Type Mismatch"]; type _ CTypeFromName[tables, first.children.type]; name _ first.children.type; }; Merge: PROC [t1, t2: SymTab.Ref] RETURNS [new: SymTab.Ref] ~ { EachPair: SymTab.EachPairAction ~ { IF ( NOT SymTab.Insert[new, key, val] ) THEN ERROR; }; big, small: SymTab.Ref; IF ( SymTab.GetSize[t1] > SymTab.GetSize[t2] ) THEN { big _ t1; small _ t2 } ELSE { big _ t2; small _ t1 }; new _ SymTab.Copy[big]; IF ( SymTab.Pairs[small, EachPair] ) THEN ERROR; }; DiskToTable: PUBLIC PROC [id: ROPE, pgm, version: CARD] RETURNS [scope: SCOPE] ~ { ProgramFile: PROC RETURNS [name: ROPE] ~ { name _ IO.PutFR["%gP%gV%g", IO.rope[id], IO.card[pgm], IO.card[version] ]; }; info: REF InterfaceItem; keyRope: ROPE; sibling: CComponent; fname: ROPE ~ Rope.Concat[ProgramFile[], ".Tables"]; sourceStream: IO.STREAM _ FS.StreamOpen[fname]; successful: BOOLEAN; table: SymTab.Ref _ SymTab.Create[]; token: ROPE; type: CType; NextToken: PROC RETURNS [text: ROPE] ~ { charsSkipped: INT; [text, charsSkipped] _ IO.GetTokenRope[sourceStream, Control]; }; Control: IO.BreakProc ~ { SELECT char FROM '\r, '| => RETURN[sepr]; ENDCASE => RETURN[other]; }; Normalize: PROC [arg: ROPE] RETURNS [res: ROPE] ~ { length: INT ~ Rope.Length[arg]; res _ IF (length > 1) THEN Rope.Substr[arg, 0, length.PRED] ELSE ""; }; TokenToInt: PROC [arg: ROPE] RETURNS [res: INT] ~ { length: INT ~ Rope.Length[arg]; res _ IF (length > 1) THEN Convert.IntFromRope[Rope.Substr[arg, 0, length.PRED]] ELSE 0; }; scope _ NEW [ScopeRep _ [id, pgm, version, NIL, CreateTables[]]]; [] _ SymTab.Insert[scope.tables.directory, id, ProgramFile[]]; token _ NextToken[]; -- Skip Heading keyRope _ token _ NextToken[]; -- Get First Key WHILE ( NOT Rope.Equal[keyRope, "TypeTables"] ) DO -- While Local Table is not exhausted info _ NEW[InterfaceItem]; info.type _ token _ NextToken[]; info.constant _ Normalize[token _ NextToken[]]; token _ NextToken[]; -- Throw away Function Header token _ NextToken[]; WHILE ( NOT Rope.Equal[token, "~~~~~"] ) DO info.functions _ RopeList.Cons[info.functions, token]; token _ NextToken[]; ENDLOOP; info.value _ NIL; successful _ SymTab.Insert[table, keyRope, info]; keyRope _ token _ NextToken[]; ENDLOOP; [] _ SymTab.Insert[scope.tables.globalTable, id, table]; -- Local Tables over token _ NextToken[]; -- Skip Type Heading keyRope _ token _ NextToken[]; -- Get First Type Name WHILE ( NOT Rope.Equal[keyRope, "."] ) DO -- Process Type Table type _ NEW[CTypeBody]; -- Allocate CType type.class _ RopeToClass[token _ NextToken[]]; -- Get Class type.bound _ Convert.CardFromRope[token _ NextToken[]]; -- Get bound token _ NextToken[]; IF ( NOT Rope.Equal[token, "TYPE"] ) THEN { -- Are there any children sibling _ NEW[CComponentBody]; type.children _ sibling --First Child }; WHILE ( NOT Rope.Equal[token, "TYPE"] ) DO sibling.name _ Normalize[token]; sibling.val _ TokenToInt[token _ NextToken[]]; sibling.type _ Normalize[token _ NextToken[]]; token _ NextToken[]; IF ( NOT Rope.Equal[token, "TYPE"] ) THEN { sibling.sibling _ NEW[CComponentBody]; --Rest Of the Children sibling _ sibling.sibling; } ENDLOOP; [] _ SymTab.Insert[scope.tables.typeTable, keyRope, type]; -- Enter Type keyRope _ token _ NextToken[]; -- Get Next Type Name ENDLOOP; token _ NextToken[]; --Skip Header keyRope _ token _ NextToken[]; WHILE ( NOT Rope.Equal[keyRope, "."] ) DO token _ NextToken[]; [] _ SymTab.Insert[scope.tables.functionTable, keyRope, token]; keyRope _ token _ NextToken[]; ENDLOOP; }; TableMerge: PUBLIC PROC [t1, t2: TABLES] RETURNS [new: TABLES] ~ { new _ t1; new.unresolvedConstantTable _ Merge[t1.unresolvedConstantTable, t2.unresolvedConstantTable]; new.unresolvedTypeTable _ Merge[t1.unresolvedTypeTable, t2.unresolvedTypeTable]; }; Collapse: PUBLIC PROC ~ { failure: BOOLEAN; outStream: IO.STREAM; tables: TABLES; h: SiroccoPrivate.Handle; AddUsedTypes: SymTab.EachPairAction ~ { usedTable: SymTab.Ref ~ tables.condensedTypeTable; TraverseCtype: PUBLIC PROC [type: CType] ~ { FOR list: CComponent _ type.children, list.sibling WHILE (list # NIL) DO IF ( NOT Rope.IsEmpty[list.type] ) THEN { ctype: CType ~ CTypeFromName[tables, list.type]; IF ( SymTab.Insert[usedTable, list.type, ctype] ) THEN TraverseCtype[ctype]; }; ENDLOOP; }; entry: REF InterfaceItem ~ NARROW[val]; ctype: CType ~ CTypeFromName[tables, entry.type]; IF ( NOT SymTab.Insert[usedTable, entry.type, ctype] ) THEN RETURN[FALSE]; TraverseCtype[ctype]; }; WriteOutLocalTableEntry: SymTab.EachPairAction ~ { keyRope: ROPE _ NARROW[key]; entry: REF InterfaceItem _ NARROW[val]; FuctionsToDisk: PROC[name: ROPE] ~ { IO.PutF[outStream, "%g|", IO.rope[name] ]; }; IO.PutF[outStream, "|%g|%g|%g |\nFunctions|", IO.rope[keyRope], IO.rope[entry.type], IO.rope[entry.constant] ]; RopeList.Map[entry.functions, FuctionsToDisk]; IO.PutF[outStream, "~~~~~\n"] }; WriteOutTypeTableEntry: SymTab.EachPairAction ~ { type: CType _ NARROW[val]; keyRope: ROPE _ NARROW[key]; list: CComponent _ type.children; IO.PutF[outStream, "TYPE|%g|%g|%g|\n", IO.rope[keyRope], IO.rope[ClassToRope[type.class]], IO.card[type.bound] ]; WHILE ( list # NIL ) DO IO.PutF[outStream, "%g |%g |%g |\n", IO.rope[list.name], IO.int[list.val], IO.rope[list.type] ]; list _ list.sibling; ENDLOOP; }; WriteOutFunctionTableEntry: SymTab.EachPairAction ~ { IO.PutF[outStream, "%g|%g\n", IO.rope[NARROW[key]], IO.rope[NARROW[val]] ] }; h _ SIGNAL SiroccoPrivate.AquireState; tables _ h.allTheTables; failure _ SymTab.Pairs[tables.localTable, AddUsedTypes]; outStream _ FS.StreamOpen[Rope.Concat[h.programKey,"Tables"], $create]; IO.PutF[outStream, "LocalTables\n"]; failure _ SymTab.Pairs[tables.localTable, WriteOutLocalTableEntry]; IO.PutF[outStream, "\nTypeTables\n"]; failure _ SymTab.Pairs[tables.condensedTypeTable, WriteOutTypeTableEntry]; IO.PutF[outStream, "\nTYPE|.\n"]; IO.PutF[outStream, "\nFunctions\n"]; failure _ SymTab.Pairs[tables.functionTable, WriteOutFunctionTableEntry]; IO.PutF[outStream, "\n.\n"]; IO.Close[outStream]; }; CreateTables: PUBLIC PROC RETURNS [t: TABLES] ~ { h: SiroccoPrivate.Handle ~ SIGNAL SiroccoPrivate.AquireState; InsertValue: PROC [key: ROPE, type: Generic] RETURNS [ok: BOOLEAN] ~ { ok _ SymTab.Insert[h.allTheTables.typeTable, key, MkCType[type, 0, NIL]] }; h.allTheTables _ NEW [TablesBody]; h.allTheTables.condensedTypeTable _ SymTab.Create[]; h.allTheTables.directory _ SymTab.Create[]; h.allTheTables.errors _ SymTab.Create[]; h.allTheTables.functionTable _ SymTab.Create[]; h.allTheTables.globalTable _ SymTab.Create[]; h.allTheTables.index _ PriorityQueue.Create[PQFirst]; -- just plain vanilla, please! h.allTheTables.localTable _ SymTab.Create[]; h.allTheTables.procedures _ SymTab.Create[]; h.allTheTables.typeTable _ SymTab.Create[]; h.allTheTables.unresolvedConstantTable _ SymTab.Create[]; h.allTheTables.unresolvedTypeTable _ SymTab.Create[]; h.allTheTables.workTable _ SymTab.Create[]; RETURN[h.allTheTables]; }; }. ΰSiroccoBase1Impl.Mesa Copyright Σ 1986, 1987 by Xerox Corporation. All rights reserved. Bhargava, August 9, 1986 2:56:46 pm PDT Demers, December 29, 1986 9:48:13 pm PST Bill Jackson (bj) August 25, 1987 6:46:38 pm PDT Scopes, Ribs & Contexts Context Scope Ribs Interface/Item procedures "Fetch" procedures "Check" procedures xxxx Check on status of unspecified xxxx Junk h.allTheTables.condensedFunctionTable _ SymTab.Create[]; XXXX Put Predefined Values: integer, boolean, etc. into the table IF ( NOT InsertValue["BOOLEAN", bool] ) THEN ERROR; IF ( NOT InsertValue["CARDINAL", card16] ) THEN ERROR; IF ( NOT InsertValue["LONGCARDINAL", card32] ) THEN ERROR; IF ( NOT InsertValue["INTEGER", int16] ) THEN ERROR; IF ( NOT InsertValue["LONGINTEGER", int32] ) THEN ERROR; IF ( NOT InsertValue["STRING", string] ) THEN ERROR; IF ( NOT InsertValue["SOURCE", source] ) THEN ERROR; IF ( NOT InsertValue["SINK", sink] ) THEN ERROR; IF ( NOT InsertValue["UNSPECIFIED", unspec] ) THEN ERROR; Κa˜codešœ™KšœB™BK™'K™(K™0—K˜šΟk ˜ Kšœœ˜,Kšœœ˜KšœœLœ˜]Kšœœ˜)Kšœœœ0˜AKšœ œ˜Kšœœ˜,Kšœ œ"˜4KšœœK˜WKš œœPœ7œœœ œ)˜ώ—K˜šΟnœœ˜Kšœ œœG˜^Kšœ#˜*Kšœ.˜2Kšœœœ˜K˜šžœœ˜*Kšœœ œ˜Kšœœ œ˜Kšœ"˜(Kšœ˜—headšΟz™š ž œœœœ.œ˜Kšœœ'˜1Kšœ œ œ ˜*Kšœ œœ ˜8šœœ˜Kšœ œœ˜Kšœ œœ˜Kšœœœ˜&Kšœœœ˜'Kšœœ˜—Kšœ˜Kšœ˜Kšœ ˜ Kšœ˜—šŸ™šž œœœœ œœœ œœ œ˜xKšœ˜Kšœ˜Kšœ˜Kšœ œ+˜8Kšœ˜—šžœœœ œœœœ˜TKšœ*˜*Kšœ˜——šŸ™š ž œœœœœ˜3Kšœœ˜Kšœœ˜Kšœ œ˜Kšœ$˜$Kšœœœ˜KšœœR˜\Kšœ˜K˜—šž œœœœœœœ˜IKšœœ-œœ˜@Kšœ ˜ Kšœ˜K˜—šž œœœ œœœœ˜Nšœ%œ˜4Kšœœ ˜Kšœœ˜—Kšœ˜——šŸ™š žœœœœœ˜/Kšœ˜Kšœ˜K˜—šž œœœœ œœœ˜HKšœœ'œœ˜:Kšœ ˜ Kšœ˜K˜—šž œœœœœœ œ˜KKšœœ˜ Kšœ˜———šŸ™š ž œœœœœ˜cKšœA˜AKšœ˜K˜—š žœœœœœ˜LJšœ˜Kšœ˜K˜—š žœœœœ œ˜PJšœ˜Kšœ˜K˜—š ž œœœ œœ œ˜EKšœ'˜'Kšœ˜——šŸ™š žœœœœœœ˜RKšœ Οc,˜LK˜K˜—š ž œœ œœœ˜Kšœ*œ˜9Kšœ˜Kšœœ˜—K˜K˜—šžœœ#œ˜[šœœ˜*Kšœœ ˜*Kšœ3˜:—K˜K˜—šžœœœœ˜Ršœ'œ˜6Kšœ!˜!Kšœœ˜—Kšœ˜——šŸ™šžœœœœ œœœ˜RKšœ3˜3Kšœ˜Kšœ˜K˜—š Πbnœœœ œœœ˜KKšœœœH˜sK˜K˜—š žœœœœœ˜ZKšœœ˜ šœ*œ œ˜Dšœ'œ%œ˜VKšœ,˜,Kšœœ˜ Kšœ˜Kšœ˜—Kšœ˜—K˜——šŸ™šž œœœœ˜;šœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ ˜ Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœœ˜—K˜—šž œœœœ˜;šœœ˜Kšœ+˜+Kšœ,˜,Kšœ/˜/Kšœ-˜-Kšœ0˜0Kšœ+˜+Kšœ-˜-Kšœ3˜3Kšœ1˜1Kšœ.˜.Kšœ,˜,Kšœ,˜,Kšœ)˜)Kšœ-˜-Kšœ-˜-Kšœ2˜2Kšœœ˜—K˜—š žœœœœœ˜QKšœ˜Kšœœ"œ ˜=Kšœ˜—K˜š ž œœœ(œœœ ˜^šžœœ˜Kšœ ˜ Kšœ˜—šžœœ,˜Dšœœ˜Kš œ œœ œœ˜3Kšœ œ˜Kšœ œ˜Kšœœ5˜:Kšœ)˜)šœœ+˜0Kšœ/˜/Kšœ0˜0Kšœ$˜$K˜—Kšœœ˜—Kšœ3˜3Kšœ˜—Kšœ™šœ ˜Kšœœ #˜Ešœ7˜7Kšœœ ˜2K˜—šœ˜šœœ˜Dšœ˜Kšœ4˜4Kšœ?œœ˜MKšœ˜—K˜——šœ˜šœ˜šœ˜šœœ˜CKšœ ˜Kšœ5˜9—Kšœ˜—K˜——Kšœ˜—K˜K˜—šžœœœœ œœ œ˜[Kšœ3˜3Kšœ˜K˜K˜—šžœœœœœ œœ œ˜aKšœ+˜+šœ1œ œ˜KKšœœœ˜EKšœ˜ —Kšœ˜Kšœ˜K˜—šžœœœœœœœ˜hšœ'œ œ˜Ašœœ˜'Kšœ.˜4Kšœ˜—Kšœ˜—Kšœ ˜ K˜K˜—šžœœœœ œœ œ˜UKšœ+˜+Kšœ"˜"Kšœ œœœ˜Kšœ˜K˜K˜—š žœœœœœ œ˜`šœ'œ œ˜AKšœœ˜Kšœ˜—Kšœ˜šœ˜šœ˜Kšœ˜Kšœ˜K˜—Kšœ" ˜9—K˜K˜—šž œœœœ œœœ˜kšœœ˜šœ˜Kšœœ>˜\Kšœ˜—šœ˜Kšœœ:˜XK˜—Kšœ$˜+—Kšœ2˜2Kšœ˜K˜——šŸ™šžœœœ˜>šžœ˜#Kšœœ œœ˜3K˜—Kšœ˜šœ,˜.Kšœ˜Kšœ˜—Kšœ˜Kšœ#œœ˜0K˜K˜—šž œœœœœœœ˜Ršž œœœœ˜*šœœ˜Kšœ ˜ Kšœ ˜ Kšœ˜K˜—K˜—Kšœœ˜Kšœ œ˜K˜Kšœœ)˜4Kšœœœœ˜/Kšœ œ˜Kšœ$˜$Kšœœ˜ K˜ šž œœœœ˜(Kšœœ˜Kšœœ&˜?K˜—šžœœ˜šœ˜Kšœ œ˜Kšœœ˜—Kšœ˜—š ž œœœœœ˜3Kšœœ˜šœœ ˜Kšœœ˜%Kšœ˜—K˜—š œž œœœœœ˜4Kšœœ˜šœœ ˜Kšœ0œ˜:Kšœ˜—K˜—Kšœœ œ˜AKšœ>˜>Kšœ ˜$Kšœ ˜/šœœ%œ %˜XKšœœ˜Kšœ ˜ Kšœ/˜/Kšœ ˜3Kšœ˜šœœ˜,Kšœ6˜6Kšœ˜Kšœ˜—Kšœ œ˜Kšœ1˜1Kšœ˜Kšœ˜—Kšœ9 ˜MKšœ ˜*Kšœ ˜5šœœœ ˜?Kšœœ  ˜(Kšœ/  ˜;Kšœ8  ˜DKšœ˜šœœœ ˜EKšœ œ˜Kšœ  ˜%Kšœ˜—šœœ˜*Kšœ ˜ Kšœ.˜.Kšœ.˜.Kšœ˜šœœœ˜+Kšœœ ˜=Kšœ˜Kšœ˜—Kšœ˜—Kšœ;  ˜HKšœ ˜4Kšœ˜—Kšœ  ˜"Kšœ˜šœœ˜)Kšœ˜Kšœ?˜?Kšœ˜Kšœ˜—K˜K˜—š ž œœœ œœœ˜BKšœ ˜ Kšœ\˜\KšœP˜PKšœ˜——šŸ™šžœœœ˜Kšœ œ˜Kšœ œœ˜Kšœœ˜Kšœ˜šž œ˜'Kšœ2˜2šž œœœ˜,šœ0œ œ˜Hšœœœ˜)Kšœ0˜0Kšœ/œ˜LK˜—Kšœ˜—K˜—Kšœœœ˜'Kšœ1˜1Kš œœ/œœœ˜JKšœ˜K˜—šžœ˜2Kšœ œœ˜Kšœœœ˜'šžœœœ˜$šœ˜Kšœ ˜ Kšœ˜—K˜—šœ+˜-Kšœ˜Kšœ˜Kšœ˜Kšœ˜—Kšœ.˜.Kšœ˜K˜—šžœ˜1Kšœœ˜Kšœ œœ˜K˜!šœ$˜&Kšœ˜Kšœ˜!Kšœ˜Kšœ˜—šœ œ˜šœ"˜$Kšœ˜Kšœ˜Kšœ˜Kšœ˜—Kšœ˜Kšœ˜—K˜—šžœ˜5šœ˜Kšœœ˜Kšœœ˜Kšœ˜—K˜—Kšœœ˜&Kšœ˜Kšœ8˜8Kšœ œ9˜GKšœ"˜$KšœC˜CKšœ#˜%KšœJ˜JKšœ˜!Kšœ"˜$KšœI˜IKšœ˜Kšœ˜K˜K˜—š ž œœœœœ˜1Kšœœ˜=š ž œœœœœ˜FKšœCœ˜HK˜—Kšœœ ˜"Kšœ:™>Kšœ4˜4Kšœ+˜+Kšœ(˜(Kšœ/˜/Kšœ-˜-Kšœ6 ˜TKšœ,˜,Kšœ,˜,Kšœ+˜+Kšœ9˜9Kšœ5˜5Kšœ+˜+šŸ<™