DIRECTORY Basics USING [BITAND, BITSHIFT, FFromInt32, FWORD, HighByte, Int32FromF, LongNumber, LowByte, LowHalf], IO USING [card, int, PutF, STREAM], Process USING [MsecToTicks, SetTimeout], Pup USING [Address, nullAddress ], PupBuffer USING [ Buffer ], PupName USING [ AddressLookup, AddressToRope, Error, NameLookup ], PupSocket USING [ Socket, Get, Send, CreateEphemeral, CreateServer, AllocBuffer, FreeBuffer, Destroy, SetUserBytes ], PupType USING [ Type ], Rope USING [ROPE], TeleLoad; TeleLoadImpl: CEDAR MONITOR IMPORTS Basics, IO, Process, PupName, PupSocket EXPORTS TeleLoad = { OPEN TeleLoad; BitOp: TYPE = PROC [a, b: UNSPECIFIED] RETURNS [UNSPECIFIED]; And: BitOp = INLINE { RETURN[Basics.BITAND[a,b]]; }; Shift: BitOp = INLINE { RETURN[Basics.BITSHIFT[a,b]]; }; locMaxByte: PUBLIC NAT _ 150; kingWaitTime: INT _ 200; -- Packet exchange reply wait time NameToAddress: PUBLIC PROC [name: Rope.ROPE] RETURNS [address: Pup.Address, ok: BOOL _ TRUE] = { address _ PupName.NameLookup[name, teleSwatSocket ! PupName.Error => {ok _ FALSE; CONTINUE; }]; }; AddressToName: PUBLIC PROC [address: Pup.Address] RETURNS [nameRope, addressRope: Rope.ROPE] = { nameRope _ PupName.AddressLookup[address]; addressRope _ PupName.AddressToRope[address]; }; Start: PUBLIC PROC [host: Rope.ROPE, log: IO.STREAM] RETURNS [h: Handle] = { sendHim: Pup.Address; allok: BOOL; [sendHim, allok] _ NameToAddress[host]; sendHim.socket _ TeleLoad.teleSwatSocket; IF NOT allok THEN RETURN[NIL]; h _ NEW[TLObject _ [ host: host, address: sendHim, cacheSize: locMaxByte, log: log]]; RETURN[h]; }; Stop: PUBLIC PROC [h: Handle] = { IF h=NIL THEN RETURN; h.host _ NIL; h.log _ NIL; }; Store: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GStore[h: h, requestcb: cb, type: coreStoreRequest, tries: tries]; }; Fetch: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GFetch[h: h, requestcb: cb, type: coreFetchRequest, tries: tries]; }; SlaveStore: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GStore[h: h, requestcb: cb, type: slaveStoreRequest, tries: tries]; }; SlaveFetch: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GFetch[h: h, requestcb: cb, type: slaveFetchRequest, tries: tries]; }; Call: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GExchange[h: h, requestcb: cb, type: callRequest, tries: tries]; }; Go: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GStore[h: h, requestcb: cb, type: goRequest, tries: 1]; }; GoFromBreak: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GStore[h: h, requestcb: cb, type: goFromBreakRequest, tries: 1]; }; SingleStep: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GStore[h: h, requestcb: cb, type: singleStepRequest, tries: 1]; }; FetchState: PUBLIC ENTRY TeleLoadProc = { ENABLE UNWIND => NULL; [ok, attempts] _ GFetch[h: h, requestcb: cb, type: stateFetchRequest, tries: tries]; }; GoToDebugger: PUBLIC ENTRY TeleLoadProc = TRUSTED { ENABLE UNWIND => NULL; b: PupBuffer.Buffer _ PupSocket.AllocBuffer[king]; replycb: CorePkt; replycb _ LOOPHOLE[@b.body]; replycb.advice _ cb.advice; replycb.address _ cb.address; replycb.count _ cb.count; FOR j: CARDINAL IN [0..cb.count) DO replycb.data[j] _ cb.data[j]; ENDLOOP; PupSocket.SetUserBytes[b, BYTES[CorePktObject]+(cb.count+1)]; b.id _ NewPupID[]; b.type _ debugRequest; KingSend[b, h.address]; }; eventServerUseCount: INT _ 0; eventServerActive: BOOL _ FALSE; eventServerProcess: PROCESS; eventServerPollingInterval: NAT _ 500; eventSocket: PupSocket.Socket _ NIL; eventClientProcedure: EventProc; eventClientData: REF ANY; StartEventServer: PUBLIC ENTRY PROC [proc: EventProc, clientData: REF ANY] = { eventServerUseCount _ eventServerUseCount + 1; IF eventServerUseCount > 1 THEN RETURN; IF eventServerActive THEN RETURN; eventClientProcedure _ proc; eventClientData _ clientData; eventServerActive _ TRUE; eventServerProcess _ FORK TeleloadEventServer[]; }; StopEventServer: PUBLIC ENTRY PROC = TRUSTED { eventServerUseCount _ MAX[0, eventServerUseCount - 1]; IF eventServerUseCount > 0 THEN RETURN; eventServerActive _ FALSE; JOIN eventServerProcess; }; TeleloadEventServer: PROC = TRUSTED{ b: PupBuffer.Buffer _ NIL; er: EventRecord; cp: CorePkt; eventSocket _ PupSocket.CreateServer[ local: teleSwatSocket, getTimeout: eventServerPollingInterval]; DO b _ eventSocket.Get[]; IF b # NIL THEN { cp _ LOOPHOLE[@b.body]; er _ LOOPHOLE[@cp^.data]; eventClientProcedure[b.source, er^, eventClientData]; PupSocket.FreeBuffer[b]; }; IF NOT eventServerActive THEN EXIT; ENDLOOP; eventClientData _ NIL; eventClientProcedure _ NIL; PupSocket.Destroy[eventSocket]; }; GStore: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: NAT] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED { b: PupBuffer.Buffer _ NIL; replycb: CorePkt; IF h=NIL THEN RETURN[FALSE, 0]; FOR actualAttempts IN [1..tries] DO id: Basics.FWORD _ NewPupID[]; IF b#NIL THEN PupSocket.FreeBuffer[b]; b _ PupSocket.AllocBuffer[king]; replycb _ LOOPHOLE[@b.body]; replycb.advice _ requestcb.advice; replycb.address _ requestcb.address; replycb.count _ requestcb.count; FOR j: CARDINAL IN [0..requestcb.count) DO replycb.data[j] _ requestcb.data[j]; ENDLOOP; PupSocket.SetUserBytes[b, BYTES[CorePktObject]+(requestcb.count+1)]; b _ Exchange[h, b, type, id]; IF b=NIL THEN LOOP; replycb _ LOOPHOLE[@b.body]; IF NOT Check[requestcb, replycb] THEN LOOP; requestcb.advice _ replycb.advice; EXIT; REPEAT FINISHED => a _ FALSE; ENDLOOP; IF b#NIL THEN PupSocket.FreeBuffer[b]; }; GFetch: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: CARDINAL] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED { b: PupBuffer.Buffer _ NIL; id: Basics.FWORD _ NewPupID[]; replycb: CorePkt; IF h=NIL THEN RETURN[FALSE, 0]; FOR actualAttempts IN [1..tries] DO IF b#NIL THEN PupSocket.FreeBuffer[b]; b _ PupSocket.AllocBuffer[king]; replycb _ LOOPHOLE[@b.body]; replycb.advice _ requestcb.advice; replycb.address _ requestcb.address; replycb.count _ requestcb.count; PupSocket.SetUserBytes[b, BYTES[CorePktObject]]; b _ Exchange[h, b, type, id]; IF b=NIL THEN LOOP; replycb _ LOOPHOLE[@b.body]; IF replycb.address # requestcb.address THEN LOOP; IF replycb.count # requestcb.count THEN LOOP; FOR j: CARDINAL IN [0..requestcb.count) DO requestcb.data[j] _ replycb.data[j]; ENDLOOP; requestcb.advice _ replycb.advice; EXIT; REPEAT FINISHED => a _ FALSE; ENDLOOP; IF b#NIL THEN PupSocket.FreeBuffer[b]; }; GExchange: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: CARDINAL] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED { b: PupBuffer.Buffer _ NIL; id: Basics.FWORD _ NewPupID[]; replycb: CorePkt; IF h=NIL THEN RETURN[FALSE, 0]; FOR actualAttempts IN [1..tries] DO IF b#NIL THEN PupSocket.FreeBuffer[b]; b _ PupSocket.AllocBuffer[king]; replycb _ LOOPHOLE[@b.body]; replycb.advice _ requestcb.advice; replycb.address _ requestcb.address; replycb.count _ requestcb.count; FOR j: CARDINAL IN [0..requestcb.count) DO replycb.data[j] _ requestcb.data[j]; ENDLOOP; PupSocket.SetUserBytes[b, BYTES[CorePktObject]+(requestcb.count+1)]; b.id _ id; b _ Exchange[h, b, type, id]; IF b=NIL THEN LOOP; replycb _ LOOPHOLE[@b.body]; IF replycb.address # requestcb.address THEN LOOP; IF replycb.count # requestcb.count THEN LOOP; FOR j: CARDINAL IN [0..requestcb.count) DO requestcb.data[j] _ replycb.data[j]; ENDLOOP; requestcb.advice _ replycb.advice; EXIT; REPEAT FINISHED => a _ FALSE; ENDLOOP; IF b#NIL THEN PupSocket.FreeBuffer[b]; }; Exchange: INTERNAL PROC [h: Handle, request: PupBuffer.Buffer, type: PupType.Type, id: Basics.FWORD] RETURNS[PupBuffer.Buffer] = { reply: PupBuffer.Buffer _ NIL; waitTime: INT _ kingWaitTime; request.id _ id; request.type _ type; KingSend[request, h.address]; DO IF reply#NIL THEN PupSocket.FreeBuffer[reply]; reply _ KingGet[h.address, waitTime]; waitTime _ waitTime + kingWaitTime; IF reply = NIL THEN RETURN[NIL]; IF reply.type # LOOPHOLE[LOOPHOLE[type, CARDINAL]+1] THEN LOOP; IF reply.id # id THEN LOOP; RETURN[reply]; ENDLOOP; }; Check: INTERNAL PROC [a: CoreBlock, b: CorePkt] RETURNS [BOOL] = TRUSTED { IF a.address # b.address THEN RETURN[FALSE]; IF a.count # b.count THEN RETURN[FALSE]; FOR i: CARDINAL IN [0..a.count) DO IF a.data[i] # b.data[i] THEN RETURN[FALSE]; ENDLOOP; RETURN[TRUE]; }; Failed: PUBLIC ERROR = CODE; GetCoreBlock: PUBLIC ENTRY PROC[h: Handle, addr: CoreAddress, count: CARDINAL, addressSpace: AddressSpace _ main] RETURNS [cb: CoreBlock] = { ENABLE UNWIND => NULL; RETURN [GetCoreBlockInternal[h, addr, count, addressSpace]]; }; GetCoreBlockInternal: INTERNAL PROC[h: Handle, addr: CoreAddress, count: CARDINAL, addressSpace: AddressSpace] RETURNS [cb: CoreBlock] = { ok: BOOLEAN; tries: NAT; cb _ NEW[CoreBlockObject[count]]; cb.address _ addr; cb.advice _ [FALSE, FALSE, 0]; [ok, tries] _ GFetch[h, cb, IF addressSpace = main THEN coreFetchRequest ELSE slaveFetchRequest, 5]; IF NOT ok THEN { IF h.log # NIL THEN h.log.PutF[" ... %d byte read from %08x failed, (%d tries).\n", IO.card[count], IO.card[cb.address], IO.int[tries]]; cb_NIL; ERROR Failed; }; }; ReadWord: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace _ main] RETURNS [v: CARDINAL] = { ENABLE UNWIND => NULL; RETURN [ReadInternal[h, addr, addressSpace] + LOOPHOLE[Shift[ReadInternal[h, addr+1, addressSpace], 8], CARDINAL]]; }; Read: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace _ main] RETURNS [v: CARDINAL] = { ENABLE UNWIND => NULL; RETURN[ReadInternal[h, addr, addressSpace]]; }; ReadInternal: INTERNAL PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace] RETURNS [v: CARDINAL] = { temp: Basics.LongNumber; blockAddr: CoreAddress; count: NAT _ h.cacheSize; IF h.cacheSize = 0 THEN h.cacheSize _ locMaxByte; h.cacheSize _ MAX[1, MIN[h.cacheSize, locMaxByte]]; temp.lc _ addr; temp.lc _ temp.lc - (temp.lc MOD h.cacheSize); blockAddr _ temp.lc; IF h.cacheCB = NIL THEN { h.cacheCB _ GetCoreBlockInternal[h: h, addr: blockAddr, count: h.cacheSize, addressSpace: addressSpace]; h.addressSpace _ addressSpace; }; IF h.cacheCB.address # blockAddr OR h.addressSpace # addressSpace THEN { FlushWritesInternal[h]; h.cacheCB _ GetCoreBlockInternal[h: h, addr: blockAddr, count: h.cacheSize, addressSpace: addressSpace]; h.addressSpace _ addressSpace; }; RETURN[h.cacheCB.data[Basics.LowHalf[addr-blockAddr]]]; }; WriteWord: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace _ main] = { ENABLE UNWIND => NULL; WriteInternal[h, addr, And[value, 377B], addressSpace]; WriteInternal[h, addr + 1, Shift[value, -8], addressSpace]; }; Write: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace _ main] = { ENABLE UNWIND => NULL; WriteInternal[h, addr, value, addressSpace]; }; WriteInternal: INTERNAL PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace] = { temp: Basics.LongNumber; blockAddr: CoreAddress; [] _ ReadInternal[h, addr, addressSpace]; temp.lc _ addr; temp.lc _ temp.lc - (temp.lc MOD h.cacheSize); blockAddr _ temp.lc; h.cacheCB.data[Basics.LowHalf[addr-blockAddr]] _ value; h.dirty _ TRUE; }; FlushWrites: PUBLIC ENTRY PROC [h: Handle] = { ENABLE UNWIND => NULL; FlushWritesInternal[h]; }; FlushWritesInternal: INTERNAL PROC [h: Handle] = { IF h.dirty THEN { ok: BOOL; tries: NAT; [ok, tries] _ GStore[h, h.cacheCB, IF h.addressSpace = main THEN coreStoreRequest ELSE slaveStoreRequest, 5]; h.dirty _ FALSE; IF NOT ok THEN { IF h.log # NIL THEN h.log.PutF[" Write to %08x failed (%d tries), cache reset anyway.\n", IO.card[h.cacheCB.address], IO.int[tries]]; ERROR Failed; }; }; }; ResetCache: PUBLIC ENTRY PROC [h: Handle] = { ENABLE UNWIND => NULL; FlushWritesInternal[h]; h.cacheCB _ NIL; }; SetCacheSize: PUBLIC ENTRY PROC [h: Handle, bytes: NAT] = { ENABLE UNWIND => NULL; FlushWritesInternal[h]; h.cacheCB _ NIL; h.cacheSize _ IF bytes = 0 THEN locMaxByte ELSE MAX[1, MIN[locMaxByte, bytes]]; }; Swab: PUBLIC PROC [a: CARDINAL] RETURNS [b: CARDINAL] = { b _ Basics.BITSHIFT[Basics.LowByte[a], 8] + Basics.HighByte[a]; }; SwabState: PUBLIC PROC [state: State8086Object] RETURNS [State8086Object] = { FOR i: Registers8086 IN [AX..FL] DO state.Regs[i] _ Swab[state.Regs[i]]; ENDLOOP; RETURN[state]; }; SwabEvent: PUBLIC PROC [state: EventRecordObject] RETURNS [EventRecordObject] = { state.regs _ SwabState[state.regs]; state.reason _ Swab[state.reason]; state.clockLow _ Swab[state.clockLow]; state.clockHigh _ Swab[state.clockHigh]; state.bootSwitches _ Swab[state.bootSwitches]; state.advice _ Swab[state.advice]; state.monRelays _ Swab[state.monRelays]; state.tlNet _ Swab[state.tlNet]; state.tlHost _ Swab[state.tlHost]; state.tlImHost _ Swab[state.tlImHost]; state.localNet _ Swab[state.localNet]; RETURN[state]; }; kingUseCount: INT _ 0; kingWait: CONDITION; lastPacket: PupBuffer.Buffer; pleaseStopKing: BOOL _ TRUE; myID: Basics.FWORD _ [[6, 175], [0,1]]; -- = [1711, 1]; ????? king: PupSocket.Socket; kingProcess: PROCESS; KingGet: INTERNAL PROC [from: Pup.Address, waitTime: INT_kingWaitTime] RETURNS [PupBuffer.Buffer] = TRUSTED { b: PupBuffer.Buffer; IF lastPacket # NIL AND lastPacket.source.net = from.net AND lastPacket.source.host = from.host THEN { b _ lastPacket; lastPacket _ NIL; RETURN[b]; }; Process.SetTimeout[condition: @kingWait, ticks: Process.MsecToTicks[waitTime]]; WAIT kingWait; IF lastPacket # NIL AND lastPacket.source.net = from.net AND lastPacket.source.host = from.host THEN { b _ lastPacket; lastPacket _ NIL; RETURN[b]; }; RETURN[NIL]; }; NewPupID: INTERNAL PROC RETURNS [Basics.FWORD] = { myID _ Basics.FFromInt32[Basics.Int32FromF[myID]+1]; RETURN [myID]; }; KingSend: INTERNAL PROC [b: PupBuffer.Buffer _ NIL, to: Pup.Address] = { IF king = NIL THEN { RETURN; }; PupSocket.Send[king, b, to]; }; KingDaemon: PROC = { b: PupBuffer.Buffer; SetKingPacket: ENTRY PROC [b: PupBuffer.Buffer] = { IF lastPacket # NIL THEN PupSocket.FreeBuffer[lastPacket]; lastPacket _ b; NOTIFY kingWait; }; king _ PupSocket.CreateEphemeral[remote: Pup.nullAddress, getTimeout: 500]; DO IF pleaseStopKing THEN EXIT; b _ king.Get[]; IF b # NIL THEN SetKingPacket[b]; ENDLOOP; PupSocket.Destroy[king]; king _ NIL; SetKingPacket[NIL]; }; StartKing: PUBLIC ENTRY PROC = { kingUseCount _ kingUseCount + 1; IF kingUseCount > 1 THEN RETURN; IF NOT pleaseStopKing THEN RETURN; pleaseStopKing _ FALSE; kingProcess _ FORK KingDaemon[]; }; StopKing: PUBLIC PROC = TRUSTED { giveUp: BOOL _ FALSE; GetLock: ENTRY PROC = TRUSTED { kingUseCount _ MAX[0, kingUseCount - 1]; IF kingUseCount > 0 THEN giveUp _ TRUE; IF pleaseStopKing THEN giveUp _ TRUE; pleaseStopKing _ TRUE; }; GetLock[]; IF NOT giveUp THEN JOIN kingProcess; }; StopHimProbing: PUBLIC ENTRY PROC [h: Handle, setPointers: BOOL] = TRUSTED { replycb: CorePkt; b: PupBuffer.Buffer _ NIL; IF h = NIL THEN RETURN; b _ PupSocket.AllocBuffer[king]; replycb _ LOOPHOLE[@b.body]; replycb.advice _ [setPointers, FALSE, 0]; replycb.address _ 0; replycb.count _ 10; PupSocket.SetUserBytes[b, BYTES[CorePktObject]]; b.id _ NewPupID[]; b.type _ coreFetchRequest; KingSend[b, h.address]; }; GetEventData: PUBLIC PROC [h: Handle, setPointers: BOOL] RETURNS [event: EventRecordObject, ok: BOOL] = TRUSTED { deleteOnReturn: BOOL _ FALSE; er: EventRecord; cb: CoreBlock; IF h = NIL THEN RETURN [event: event, ok: FALSE]; cb _ NEW[CoreBlockObject[SIZE[EventRecordObject] * 2]]; cb.address _ 0DA00H; cb.advice _ [setPointers, FALSE, 0]; ok _ Fetch[h, cb, 1].ok; IF NOT ok THEN RETURN [event: event, ok: FALSE]; er _ LOOPHOLE[BASE[DESCRIPTOR[cb.data]], EventRecord]; event _ SwabEvent[er^]; RETURN [event: event, ok: TRUE]; }; }. December 30, 1981 3:14 PM, Stewart, created from AudioSocket.mesa December 22, 1982 3:17 pm, Stewart, modifications to TeleLoad April 25, 1983 11:22 am, LCS, new Event interface and locMaxByte May 28, 1983 5:47 pm, LCS, cacheSize added, in order to make alteration of running program safe! December 26, 1983 2:40 pm, LCS, patchup addresses with StripChar May 16, 1986 10:26:24 am PDT, DCS, increase packet exchange wait time, make it a global vbl. TeleLoadImpl.mesa Copyright Σ 1986, 1987 by Xerox Corporation. All rights reserved. Last Edited by: Stewart, December 26, 1983 4:11 pm Last Edited by: Swinehart, April 4, 1987 12:55:49 pm PST Hammonds, July 9, 1986 9:23:21 am PDT Fires up a process to watch for unsolicited news items from debugees Communication stuff more conveniently arranged Here lives the single king socket. These variables are only touched by procedures in the monitor These variables are handled outside the monitor PupSocket.FreeBuffer[b]; -- no socket to free it to, "drop it on the floor". Swinehart, May 16, 1986 10:01:07 am PDT Cedar 6.1 changes to: TeleLoadImpl, NameToAddress, AddressToName, Start, Stop, Store, Fetch, SlaveStore, SlaveFetch, Call, Go, GoFromBreak, SingleStep, FetchState, GoToDebugger, StartEventServer, StopEventServer, TeleloadEventServer, GStore, GFetch, GExchange, Exchange, GetCoreBlock, ReadWord, Read, WriteWord, Write, FlushWrites, ResetCache, SetCacheSize, Swab, SwabState, SwabEvent, KingGet, KingSend, KingDaemon, SetKingPacket (local of KingDaemon), StartKing, StopKing, StopHimProbing, GetEventData Swinehart, April 4, 1987 12:35:37 pm PST Cedar 7.0; accommodate byte-level type changes. changes to: DIRECTORY, GoToDebugger, GStore, GFetch, GExchange, NewPupID, StopHimProbing Κ―˜šœ™IcodešœB™BJšœ2™2J™8K™%—J˜šΟk ˜ Jš œœœœ œ6˜gJšœœœ˜#Jšœœ˜(Jšœœ˜"Jšœ œ ˜Jšœœ5˜BJšœ œf˜uJšœœ ˜Jšœœœ˜J˜ J˜—šœ ˜Jšœ œ˜/šœ ˜Jšœ ˜—J˜Jš Οnœœœ œœ œ˜=J˜Jšœ œœœ ˜4Jšœœœœ ˜8J˜Jšœ œœ˜JšœœΟc"˜;J˜šž œœœ œœœœ˜`šœ3˜3Jšœœœ˜+—J˜J˜—š ž œœœœœ˜`Jšœ*˜*Jšœ-˜-J˜J˜—šžœœœ œœœœ˜LJ˜Jšœœ˜ J˜'J˜)Jš œœœœœ˜šœœ ˜Jšœ ˜ Jšœ˜J˜Jšœ ˜ —Jšœ˜ J˜J˜—šžœœœ˜!Jšœœœœ˜Jšœ œ˜ Jšœœ˜ J˜J˜—šœœœ˜$Jšœœœ˜J˜SJ˜J˜—šœœœ˜$Jšœœœ˜JšœS˜SJ˜J˜—šœ œœ˜)Jšœœœ˜JšœT˜TJ˜J˜—šœ œœ˜)Jšœœœ˜JšœT˜TJ˜J˜—šœœœ˜#Jšœœœ˜JšœQ˜QJ˜—J˜šœœœ˜!Jšœœœ˜J˜HJ˜J˜—šœ œœ˜*Jšœœœ˜J˜QJ˜J˜—šœ œœ˜)Jšœœœ˜J˜PJ˜J˜—šœ œœ˜)Jšœœœ˜J˜TJ˜J˜—šž œœœœ˜3Jšœœœ˜Jšœ2˜2J˜Jšœ œ ˜J˜J˜J˜šœœœ˜#J˜Jšœ˜—Jšœœ˜=J˜J˜J˜J˜J˜——JšœD™D˜Jšœœ˜Jšœœœ˜ Jšœœ˜Jšœœ˜&Jšœ œ˜$Jšœ ˜ Jšœœœ˜J˜š žœœœœœœ˜NJ˜.Jšœœœ˜'Jšœœœ˜!J˜Jšœ˜Jšœœ˜Jšœœ˜0J˜J˜—š žœœœœœ˜.Jšœœ˜6Jšœœœ˜'Jšœœ˜Jšœ˜J˜J˜—šžœœœ˜%Jšœœ˜J˜J˜ ˜%J˜?—š˜J˜šœœœ˜Jšœœ ˜Jšœœ ˜Jšœ5˜5Jšœ˜J˜—Jšœœœœ˜#Jšœ˜—Jšœœ˜Jšœœ˜J˜J˜J˜—šžœœœ>œœœœœœ˜‘Jšœœ˜J˜Jš œœœœœ˜šœœ ˜#Jšœ œ˜Jšœœœ˜&Jšœ ˜ Jšœ œ ˜J˜"J˜$J˜ šœœœ˜*J˜$Jšœ˜—Jšœœ%˜DJ˜Jšœœœœ˜Jšœ œ ˜Jšœœœœ˜+J˜"Jšœ˜Jš˜Jšœœ˜Jšœ˜—Jšœœœ˜&J˜J˜—šžœœœ>œœœœœœ˜–Jšœœ˜Jšœ œ˜J˜Jš œœœœœ˜šœœ ˜#Jšœœœ˜&Jšœ ˜ Jšœ œ ˜J˜"J˜$J˜ Jšœœ˜0J˜Jšœœœœ˜Jšœ œ ˜Jšœ%œœ˜1Jšœ!œœ˜-šœœœ˜*J˜$Jšœ˜—J˜"Jšœ˜Jš˜Jšœœ˜Jšœ˜—Jšœœœ˜&J˜J˜—šž œœœ>œœœœœœ˜™Jšœœ˜Jšœ œ˜J˜Jš œœœœœ˜šœœ ˜#Jšœœœ˜&Jšœ ˜ Jšœ œ ˜J˜"J˜$J˜ šœœœ˜*J˜$Jšœ˜—Jšœœ%˜DJ˜ J˜Jšœœœœ˜Jšœ œ ˜Jšœ%œœ˜1Jšœ!œœ˜-šœœœ˜*J˜$Jšœ˜—J˜"Jšœ˜Jš˜Jšœœ˜Jšœ˜—Jšœœœ˜&J˜—J˜š žœœœGœœ˜‚Jšœœ˜Jšœ œ˜Jšœ˜J˜J˜š˜Jšœœœ˜.J˜%Jšœ#˜#Jš œ œœœœ˜ Jš œœœœœœ˜?Jšœœœ˜Jšœ˜Jšœ˜—J˜J˜—š žœœœœœœ˜JJšœœœœ˜,Jšœœœœ˜(šœœœ˜"Jšœœœœ˜,Jšœ˜—Jšœœ˜ J˜—J˜J™.J˜Jšœœœœ˜J™š ž œœœœ&œ%œ˜Jšœœœ˜Jšœ6˜