DIRECTORY BootFile USING [Location, nullLink], BootStartList USING [Base], DebuggerFormat USING [ DebugParameter, ExternalStateVector, SwapInfo, SwapReason, VersionID], DebuggerSwap USING [Frozen], DeviceCleanup USING [InitializeDeviceCleanup, Perform], GermSwap USING [GetPStartListHeader, Initialize, InLoad, mdsiGerm, OutLoad, switches--.h, .i, .r--, Teledebug], KeyboardFace USING [DownUp, keyboard], Keys USING [KeyBits], MPCodes USING [cantWorldSwap, emptyMP, hanging], PrincOps USING [Byte, ControlLink, Frame, FrameHandle, FaultIndex, GlobalFrameHandle, NullFrame, NullLink, PageNumber, PDA, Port, Priority, PsbIndex, QueueHandle, sAlternateBreak, sBreak, sBreakBlock, sBreakBlockSize, SD, sError, sErrorList, sReturnError, sReturnErrorList, sSignal, sSignalList, StateVector, sUnnamedError, SVPointer, sXferTrap, XferTrapStatus, zDUP], PrincOpsUtils USING [ DisableInterrupts, EnableAndRequeue, EnableInterrupts, GetReturnFrame, GetReturnLink, HighHalf, MyLocalFrame, PsbHandleToIndex, PsbIndexToHandle, ReadPSB, ReadPTC, ReadWDC, ReadXTS, SetReturnFrame, SetReturnLink, WritePSB, WritePTC, WriteWDC, WriteXTS], Process USING [Detach, DisableTimeout, GetPriority, InitializeCondition, InitializeMonitor, Priority, priorityClient3, prioritySwatWatcher, SetPriority], ProcessorFace USING [BootButton, GetClockPulses, microsecondsPerHundredPulses, SetMP], RuntimeError USING [UCSProc]; DebugNub: MONITOR -- for CheckInterrupt IMPORTS DeviceCleanup, GermSwap, KeyboardFace, PrincOpsUtils, Process, ProcessorFace EXPORTS DebuggerSwap SHARES DeviceCleanup = BEGIN teledebug: PUBLIC BOOL; -- TRUE forces teledebugging diskDebugger: BOOL; -- TRUE means disk debugging is available locDebuggee: BootFile.Location; locDebugger: BootFile.Location; pMicrocodeCopy: LONG POINTER; -- debugger's microcode (not implemented) pGermCopy: LONG POINTER; -- debugger's germ (not implemented) nGerm: CARDINAL; -- number of words in debugger's germ CAbort: ERROR = CODE; KillThisTurkey: ERROR = CODE; Quit: ERROR = CODE; InitBreakBlocks: PROC = -- Pilot remnant BEGIN PrincOps.SD[PrincOps.sBreakBlock] _ 0 --NIL--; PrincOps.SD[PrincOps.sBreakBlockSize] _ 0; END; Break: PROC = BEGIN state: RECORD [ padding: ARRAY [0..2) OF UNSPECIFIED, v: PrincOps.StateVector]; state.v _ STATE; state.v.dest _ PrincOpsUtils.GetReturnLink[]; state.v.source _ PrincOps.NullLink; CoreSwap[breakpoint, @state.v]; IF PrincOpsUtils.ReadXTS[] = on THEN PrincOpsUtils.WriteXTS[skip1]; RETURN WITH state.v; END; WorryBreaker: PROC RETURNS [PrincOps.FrameHandle] = BEGIN state: RECORD [padding: ARRAY [0..2) OF UNSPECIFIED, v: PrincOps.StateVector]; state.v.instbyte _ 0; state.v.stkptr _ 1; state.v.stk[0] _ PrincOpsUtils.MyLocalFrame[]; state.v.dest _ PrincOpsUtils.GetReturnLink[]; state.v.source _ PrincOps.NullLink; PrincOpsUtils.DisableInterrupts[]; DO IF PrincOpsUtils.ReadXTS[] = on THEN PrincOpsUtils.WriteXTS[skip1]; PrincOpsUtils.EnableInterrupts[]; TRANSFER WITH state.v; PrincOpsUtils.DisableInterrupts[]; state.v _ STATE; state.v.dest _ PrincOpsUtils.GetReturnLink[]; state.v.source _ PrincOps.NullLink; swapInfo.state _ @state.v; swapInfo.reason _ worrybreak; -- set mds too ToDebugger[@swapInfo]; ENDLOOP; END; Catcher: PUBLIC RuntimeError.UCSProc = BEGIN signallerGF: PrincOps.GlobalFrameHandle; state: PrincOps.StateVector; f: PrincOps.FrameHandle; state.stk[0] _ msg; state.stk[1] _ signal; state.stkptr _ 0; f _ PrincOpsUtils.GetReturnFrame[]; signallerGF _ f.accesslink; f _ (state.dest _ f.returnlink).frame; IF f.accesslink = signallerGF THEN state.dest _ f.returnlink; CoreSwap[uncaughtsignal, @state ! CAbort => GOTO abort]; EXITS abort => IF signal = LOOPHOLE[ABORTED] THEN {BackStop[frame]; ERROR KillThisTurkey} ELSE ERROR ABORTED; END; BackStop: PROC [root: PrincOps.FrameHandle] = BEGIN endProcess: PrincOps.ControlLink = root.returnlink; Caller: PROC = LOOPHOLE[PrincOpsUtils.GetReturnLink[]]; root.returnlink _ [frame[PrincOpsUtils.MyLocalFrame[]]]; PrincOpsUtils.SetReturnFrame[PrincOps.NullFrame]; Caller[ ! KillThisTurkey => CONTINUE]; PrincOpsUtils.SetReturnLink[endProcess]; END; StubSignalHandler: PROC = -- handles signals before SignalsImpl is available BEGIN state: RECORD [padding: ARRAY [0..2) OF UNSPECIFIED, v: PrincOps.StateVector]; state.v _ STATE; DO WorryCallDebugger["Signal too early"L] ENDLOOP; END; swatWatcherEnabled: BOOL; interruptWanted: BOOL; interrupter: CONDITION; CheckInterrupt: ENTRY PROC = BEGIN interruptState: KeyboardFace.DownUp _ up; pKeys: LONG POINTER TO Keys.KeyBits = LOOPHOLE[KeyboardFace.keyboard]; wakeup: CONDITION; Process.InitializeCondition[@wakeup, 1]; DO --FOREVER-- ENABLE ABORTED => CONTINUE; WAIT wakeup; IF pKeys[Spare3] = down AND pKeys[Ctrl] = down THEN BEGIN IF interruptState = up AND swatWatcherEnabled THEN BEGIN interruptState _ down; teledebug _ pKeys[Spare1]=down; IF pKeys[LeftShift] = down THEN WorryCallDebugger["Keyboard interrupt (worry mode)"L] ELSE { interruptWanted _ TRUE; NOTIFY interrupter }; END; END ELSE interruptState _ up; ENDLOOP; END; InterruptSpawner: PROC = BEGIN WaitUntilWanted: ENTRY PROC = BEGIN ENABLE UNWIND => NULL; interruptWanted _ FALSE; UNTIL interruptWanted DO WAIT interrupter ENDLOOP; END; DO ENABLE ABORTED => CONTINUE; WaitUntilWanted[]; Process.Detach[FORK Interrupt[]]; ENDLOOP; END; Interrupt: PROC = BEGIN CallDebugger["Keyboard interrupt"L]; END; swatWatcherStarted: BOOL; StartSwatWatcher: PUBLIC ENTRY SAFE PROC[enabled: BOOL] = TRUSTED BEGIN IF NOT swatWatcherStarted THEN BEGIN priorityPrev: PrincOps.Priority = Process.GetPriority[]; Process.InitializeCondition[@interrupter, 0]; Process.DisableTimeout[@interrupter]; Process.SetPriority[Process.priorityClient3]; Process.Detach[FORK InterruptSpawner[]]; Process.SetPriority[Process.prioritySwatWatcher]; Process.Detach[FORK CheckInterrupt[]]; Process.SetPriority[priorityPrev]; swatWatcherStarted _ TRUE; END; swatWatcherEnabled _ enabled; END; EnableSwatWatcher: PUBLIC ENTRY SAFE PROCEDURE[enabled: BOOL] = CHECKED{ swatWatcherEnabled _ enabled }; CallDebugger: PUBLIC SAFE PROC [s: STRING] = TRUSTED BEGIN state: RECORD [a, b: UNSPECIFIED, v: PrincOps.StateVector]; state.v _ STATE; state.v.stk[0] _ s; state.v.stkptr _ 1; state.v.dest _ PrincOpsUtils.GetReturnLink[]; CoreSwap[explicitcall, @state.v] END; worryCallIndirect: PORT; WorryCallDebugger: PUBLIC SAFE PROC[STRING]; DoWorryCallDebugger: PROC RETURNS [SAFE PROC[STRING]] = BEGIN OPEN PrincOps; state: RECORD [padding: ARRAY [0..2) OF UNSPECIFIED, v: StateVector]; state.v.instbyte _ 0; state.v.stkptr _ 1; LOOPHOLE[worryCallIndirect, PrincOps.Port].frame _ PrincOpsUtils.MyLocalFrame[]; state.v.stk[0] _ @worryCallIndirect; state.v.dest _ PrincOpsUtils.GetReturnLink[]; state.v.source _ PrincOps.NullLink; PrincOpsUtils.DisableInterrupts[]; DO --FOREVER-- IF PrincOpsUtils.ReadXTS[] = on THEN PrincOpsUtils.WriteXTS[skip1]; PrincOpsUtils.EnableInterrupts[]; TRANSFER WITH state.v; PrincOpsUtils.DisableInterrupts[]; state.v _ STATE; state.v.dest _ state.v.stk[state.v.stkptr + 1]; PrincOpsUtils.SetReturnLink[state.v.dest]; state.v.source _ PrincOps.NullLink; swapInfo.state _ @state.v; swapInfo.reason _ worrycall; ToDebugger[@swapInfo]; ENDLOOP END; freezeesTable: PUBLIC DebuggerSwap.Frozen; freezer: PUBLIC POINTER TO local PrincOps.Frame; qFreeze: PrincOps.FaultIndex = 3; AllocFreezer: PROC RETURNS[ POINTER TO local PrincOps.Frame ] = BEGIN Caller: PROC[PrincOps.FrameHandle] = LOOPHOLE[PrincOpsUtils.GetReturnFrame[]]; DummyReturnLink: PROC = {ERROR}; -- PrincOps.NullLink breaks ValidateFrame PrincOpsUtils.SetReturnLink[LOOPHOLE[DummyReturnLink]]; Caller[FreezingPoint[]]; ERROR END; FreezingPoint: PROC RETURNS[ POINTER TO local PrincOps.Frame ] = BEGIN freezeQueue: PrincOps.QueueHandle = @PrincOps.PDA.fault[qFreeze].queue; state: RECORD[a, b: UNSPECIFIED, v: PrincOps.StateVector]; Caller: PROC[PrincOps.FrameHandle] = LOOPHOLE[PrincOpsUtils.GetReturnFrame[]]; Caller[PrincOpsUtils.MyLocalFrame[]]; PrincOpsUtils.DisableInterrupts[]; DO state.v _ STATE; FreezeTrapFrame[@state.v]; PrincOpsUtils.EnableAndRequeue[@PrincOps.PDA.ready, freezeQueue, PrincOpsUtils.ReadPSB[]]; PrincOpsUtils.DisableInterrupts[]; ENDLOOP; END; FreezeTrapFrame: PROC[sv: POINTER TO PrincOps.StateVector] = BEGIN -- executed with interrupts disabled -- state: RECORD[a, b: UNSPECIFIED, v: PrincOps.StateVector]; Caller: PROC = LOOPHOLE[PrincOpsUtils.GetReturnFrame[]]; psbi: PrincOps.PsbIndex = PrincOpsUtils.PsbHandleToIndex[PrincOpsUtils.ReadPSB[]]; state.v _ sv^; PrincOpsUtils.SetReturnLink[freezeesTable[psbi]]; freezeesTable[psbi] _ [frame[PrincOpsUtils.MyLocalFrame[]]]; Caller[]; state.v.dest.frame _ PrincOpsUtils.GetReturnFrame[]; state.v.source _ PrincOps.NullLink; RETURN WITH state.v; END; swapInfo: DebuggerFormat.ExternalStateVector; -- nub-debugger communication area CoreSwap: PROC [why: DebuggerFormat.SwapReason, sp: PrincOps.SVPointer] = BEGIN DP: DebuggerFormat.DebugParameter; Decode: PROC RETURNS [proceed: BOOLEAN] = -- decode the SwapReason BEGIN f: PrincOps.GlobalFrameHandle; lsv: PrincOps.StateVector; SELECT swapInfo.reason FROM proceed, resume => RETURN[TRUE]; call => BEGIN lsv _ swapInfo.parameter.sv; lsv.source _ [frame[PrincOpsUtils.MyLocalFrame[]]]; TRANSFER WITH lsv; lsv _ STATE; swapInfo.parameter.sv _ lsv; why _ return END; start => BEGIN f _ swapInfo.parameter.frame; IF ~f.started THEN START LOOPHOLE[f, PROGRAM] ELSE RESTART f; why _ return END; quit => ERROR Quit; ENDCASE => RETURN[TRUE]; RETURN[FALSE] END; --decode-- swapInfo.state _ sp; DP.spare _ NIL; swapInfo.parameter _ @DP; DO swapInfo.reason _ why; PrincOpsUtils.DisableInterrupts[]; ToDebugger[@swapInfo]; PrincOpsUtils.EnableInterrupts[]; BEGIN IF Decode[ ! CAbort => IF swapInfo.level > 0 THEN {why _ return; CONTINUE}; Quit => GOTO abort] THEN EXIT EXITS abort => ERROR CAbort END ENDLOOP END; level: INTEGER; ToDebugger: PORT [POINTER TO DebuggerFormat.ExternalStateVector]; -- formerly WBPort FromPilot: PORT RETURNS [POINTER TO DebuggerFormat.ExternalStateVector]; -- formerly CSPort MemorySwap: PROC [pESV: POINTER TO DebuggerFormat.ExternalStateVector] = BEGIN PKeys: PROC RETURNS [LONG POINTER TO Keys.KeyBits] = INLINE {RETURN[LOOPHOLE[KeyboardFace.keyboard]]}; SwapIt: PROC = INLINE BEGIN savewdc, saveptc: UNSPECIFIED; xferTrapStatus: PrincOps.XferTrapStatus = PrincOpsUtils.ReadXTS[]; xferTrapHandler: UNSPECIFIED = PrincOps.SD[PrincOps.sXferTrap]; pESV.level _ level; pESV.mds _ PrincOpsUtils.HighHalf[LONG[LOOPHOLE[1, POINTER]]]; -- ("1" since pESV.psb _ PrincOpsUtils.PsbHandleToIndex[PrincOpsUtils.ReadPSB[]]; PrincOps.SD[PrincOps.sXferTrap] _ PrincOpsUtils.MyLocalFrame[]; -- in case we are restarted in trap mode PrincOpsUtils.WriteXTS[off]; saveptc _ PrincOpsUtils.ReadPTC[]; savewdc _ PrincOpsUtils.ReadWDC[]; PrincOps.PDA.block[pESV.psb].context.frame _ PrincOpsUtils.MyLocalFrame[]; PrincOps.PDA.block[pESV.psb].link.vector _ FALSE; DeviceCleanup.Perform[turnOff]; IF GermSwap.switches[h] THEN BEGIN AddToStack: PROC [BOOLEAN] = MACHINE CODE BEGIN END; GetTOS: PROC RETURNS [BOOLEAN] = MACHINE CODE BEGIN PrincOps.zDUP; END; RemoveFromStack: PROC RETURNS [BOOLEAN] = MACHINE CODE BEGIN END; AddToStack[TRUE]; ProcessorFace.SetMP[MPCodes.hanging]; WHILE GetTOS[] DO ENDLOOP; [] _ RemoveFromStack[]; END ELSE IF NOT diskDebugger OR teledebug OR GermSwap.switches[r] THEN BEGIN ProcessorFace.SetMP[MPCodes.cantWorldSwap]; GermSwap.Teledebug[@locDebugger]; END ELSE IF GermSwap.OutLoad[@locDebuggee, restore] = outLoaded THEN BEGIN IF pMicrocodeCopy ~= NIL THEN DeviceCleanup.Perform[kill]; GermSwap.InLoad[ pMicrocodeCopy, pGermCopy, nGerm, @locDebugger] END; PrincOpsUtils.WriteWDC[savewdc]; PrincOpsUtils.WritePTC[saveptc]; PrincOpsUtils.WritePSB[PrincOpsUtils.PsbIndexToHandle[pESV.psb]]; DeviceCleanup.Perform[turnOn]; level _ pESV.level; PrincOpsUtils.WriteXTS[xferTrapStatus]; PrincOps.SD[PrincOps.sXferTrap] _ xferTrapHandler; ProcessorFace.SetMP[MPCodes.emptyMP]; END; DO pESV _ FromPilot[]; PrincOpsUtils.SetReturnLink[LOOPHOLE[FromPilot, PrincOps.Port].dest.link^]; DO SwapIt[]; SELECT pESV.reason FROM kill => ProcessorFace.BootButton[]; showscreen => BEGIN pulsesThen: LONG CARDINAL = ProcessorFace.GetClockPulses[]; prevSpare3: KeyboardFace.DownUp _ PKeys[][Spare3]; DO IF (ProcessorFace.GetClockPulses[] - pulsesThen) > LONG[20]*1000000*100/ProcessorFace.microsecondsPerHundredPulses THEN EXIT; IF prevSpare3=down THEN prevSpare3 _ PKeys[][Spare3] ELSE IF PKeys[][Spare3]=down THEN {WHILE PKeys[][Spare3]=down DO --snoore-- ENDLOOP; EXIT} ELSE NULL -- both up ENDLOOP; END; ENDCASE => EXIT; pESV.reason _ return; ENDLOOP ENDLOOP END; Initialize: PUBLIC PROC = BEGIN h: BootStartList.Base; teledebug _ FALSE; diskDebugger _ FALSE; swatWatcherStarted _ FALSE; swatWatcherEnabled _ FALSE; level _ -1; GermSwap.Initialize[GermSwap.mdsiGerm]; Process.InitializeMonitor[@LOCK]; -- because our main program is never executed DeviceCleanup.InitializeDeviceCleanup[]; h _ GermSwap.GetPStartListHeader[]; pMicrocodeCopy _ pGermCopy _ NIL; -- until microcode swapping installed NoteDiskDebugger[debugger: h.locDebugger, debuggee: h.locDebuggee]; NoteLoadstate[h[h.initLoadState].base + h[h[h.initLoadState].parent].vmPage]; swapInfo.versionident _ DebuggerFormat.VersionID; swapInfo.vmRunTable _ NIL; swapInfo.fill _ ALL[0]; LOOPHOLE[PrincOps.PDA.available, DebuggerFormat.SwapInfo].externalStateVector _ @swapInfo; InitBreakBlocks[]; PrincOps.SD[PrincOps.sSignalList] _ StubSignalHandler; PrincOps.SD[PrincOps.sSignal] _ StubSignalHandler; PrincOps.SD[PrincOps.sErrorList] _ StubSignalHandler; PrincOps.SD[PrincOps.sError] _ StubSignalHandler; PrincOps.SD[PrincOps.sReturnErrorList] _ StubSignalHandler; PrincOps.SD[PrincOps.sReturnError] _ StubSignalHandler; PrincOps.SD[PrincOps.sUnnamedError] _ StubSignalHandler; PrincOps.SD[PrincOps.sBreak] _ WorryBreaker[]; PrincOps.SD[PrincOps.sAlternateBreak] _ Break; PrincOps.SD[205B] _ freezer _ AllocFreezer[]; LOOPHOLE[@(PrincOps.SD[206B]), POINTER TO LONG POINTER TO DebuggerSwap.Frozen]^ _ LONG[@freezeesTable]; FOR p: PrincOps.PsbIndex IN PrincOps.PsbIndex DO freezeesTable[p] _ PrincOps.NullLink ENDLOOP; WorryCallDebugger _ DoWorryCallDebugger[]; LOOPHOLE[ToDebugger, PrincOps.Port].out _ @FromPilot; LOOPHOLE[FromPilot, PrincOps.Port].out _ @ToDebugger; LOOPHOLE[FromPilot, PrincOps.Port].in _ MemorySwap; ToDebugger[NIL]; -- allocate frame for MemorySwap END; NoteDiskDebugger: PUBLIC PROC[debugger, debuggee: BootFile.Location] = BEGIN locDebuggee _ debuggee; locDebugger _ debugger; IF locDebuggee.diskFileID.firstLink ~= BootFile.nullLink THEN diskDebugger _ TRUE; END; NoteLoadstate: PUBLIC PROC[page: PrincOps.PageNumber] = { swapInfo.loadstatepage _ page }; NoteVMRunTable: PUBLIC PROC[table: LONG POINTER] = { swapInfo.vmRunTable _ table }; END. ���ö��Cedar Nucleus: interface with debugger DebugNub.mesa Andrew Birrell July 26, 1983 4:52 pm Last Edited by: Levin, June 20, 1983 4:53 pm ******** Global variables ******** ******** Breakpoints ******** executed by (non-worry) BRK instruction executed by worry-mode BRK instruction ******** Uncaught signals ******** The call stack below here is: Signaller, [Signaller,] offender ******** Interrupts (CTRL-SWAT) ******** Must not be invoked until KeyboardFace and Process have been initialized. ******** CallDebugger ******** The following dance is needed because fixed frame procedures that are not called as trap handlers don't have source & destination links put on the stack. We insert an indirect link to force them to be put there. ******** Data structures for process freezing ******** The rest of this procedure is magic. It is simultaneously on the stack of several processes. ******** Procedures that cause swap to debugger ******** Body of CoreSwap: versionident, debuggee, lspages, fill, mapLog set by Initialize level, loadstatepage. mds set by MemorySwap 0 collides with NIL.) Save processor state not captured in PDA: Manually save the state of the current process so that Copilot will be able to examine it just as if we were waiting: OutLoad onto swatee, then boot Debugger. The next line should be in GermSwap.InLoad but blows up the compiler never returns Restore processor state not captured in PDA: Restore process state not captured in PDA: Set our return link so Display Stack will work: ******** Initialization ******** Remember: this module has NOTRAP in its bootmesa description, so the main program is never executed. Therefore, this procedure is responsible for any required initialisation of global variables (like the monitor lock!). In addition, this procedure is called before the mesa runtime has been initialised, so beware of KFCB's or instructions that trap to software. swapInfo.state set in caller of MemorySwap (e.g. CoreSwap, WorryBreaker, WorryCallDebugger) swapInfo.reason set in caller of MemorySwap (e.g. CoreSwap, WorryBreaker, WorryCallDebugger) swapInfo.level set in MemorySwap swapInfo.parameter set by debugger and obeyed by CoreSwap swapInfo.mds set in MemorySwap connect ToDebugger to FromPilot connect FromPilot to ToDebugger ÊÍ��– "Cedar" style˜�J™&J™ J™%J™,J˜�šÏk ˜ Jšœ œ˜$Jšœœ˜JšœœI˜]Jšœ œ ˜Jšœœ$˜7Jšœ œFÏcœ ˜oJšœ œ˜&Jšœœ˜Jšœœ#˜0Jšœ œiœ`œ”˜ðJšœœ€˜“JšœœŒ˜™JšœœC˜VJšœ œ˜—J˜�šœ œž˜'JšœM˜TJšœ ˜Jšœ˜—J˜�š˜J˜�—J™�šœ"™"J˜�Jšœœœž˜4J˜�Jšœœž)˜=J˜�J˜J˜Jšœœœž)˜GJšœœœž$˜=Jšœœž%˜6J˜�Jšœœœ˜Jšœœœ˜Jšœœœ˜J˜�—J™�šœ™J˜�J˜�šÏnœœž˜(Jš˜Jšœ œžœ˜.Jšœ œ˜*Jšœ˜J˜�—šŸœœ˜ Jšœ'™'Jš˜šœœ˜Jšœ œœœ˜?—Jšœ œ˜Jšœ-˜-J˜#Jšœ˜Jšœœ˜CJšœœ ˜Jšœ˜J˜�—šŸœœœ˜3Jšœ&™&Jš˜Jš œœœœœ˜NJ˜J˜Jšœ.˜.Jšœ-˜-J˜#Jšœ"˜"š˜Jšœœ˜CJšœ!˜!Jšœœ ˜Jšœ"˜"Jšœ œ˜Jšœ-˜-J˜#J˜Jšœž˜,J˜Jšœ˜—Jšœ˜J˜�——J™�šœ"™"J˜�šÏbœœ˜&Jš˜J˜(J˜J˜J˜J˜J˜Jšœ>™>J˜#J˜Jšœ&˜&Jšœœ˜=Jšœ,œ˜8š˜˜Jš œ œœœœ˜JJšœœœ˜——Jšœ˜J˜�—šŸœœ˜-Jš˜J˜3JšŸœœœ ˜7J˜8J˜1Jšœœ˜&J˜(Jšœ˜—J˜�šŸœœž2˜LJš˜Jš œœœœœ˜NJšœ œ˜Jšœ(œ˜2Jšœ˜J˜�——J˜�šœ(™(J˜�Jšœœ˜Jšœœ˜Jšœ œ˜J˜�šŸœœœ˜Jš˜J˜)Jš œœœœœ˜FJšœ œ˜J˜(šœž˜Jšœœœ˜Jšœ˜šœœ˜3Jš˜šœœ˜2Jš˜Jšœ˜Jšœ˜šœ˜Jšœ5˜5—Jšœœœ˜4Jšœ˜—Jš˜—Jšœ˜Jšœ˜—Jšœ˜—J˜�šŸœœ˜Jš˜šŸœœœ˜Jš˜Jšœœœ˜Jšœœ˜Jšœœœ œ˜2Jšœ˜—šœœœœ˜J˜Jšœœ˜!—Jšœ˜Jšœ˜—J˜�šŸ œœ˜Jš˜J˜$Jšœ˜—J˜�Jšœœ˜J˜�š Ÿœœœœœ œ˜AJšœI™IJš˜Jšœœ˜šœ˜ J˜8Jšœ-˜-Jšœ%˜%Jšœ-˜-Jšœœ˜(J˜1Jšœœ˜&J˜"Jšœœ˜Jšœ˜—Jšœ˜Jšœ˜—J˜�šŸœœœœ œ œ˜?Jšœ!˜(J˜�——J™�šœ™J˜�šŸœœœœœ˜4Jš˜Jšœœœ˜;Jšœ œ˜J˜J˜J˜-J˜ Jšœ˜J˜�—Jšœœ˜J˜�Jš Ÿœœœœœ˜,J˜�šŸœœœœœœ˜7Jšœœ ˜Jš œœœœœ˜EJ˜J˜JšœI™IJšœH™HJšœA™AJšœH˜PJ˜$Jšœ-˜-J˜#Jšœ"˜"šœž˜Jšœœ˜CJšœ!˜!Jšœœ ˜Jšœ"˜"Jšœ œ˜J˜/Jšœ*˜*J˜#J˜J˜J˜Jš˜—Jšœ˜J˜�——J™�šœ6™6J˜�Jšœœ˜*J˜�Jšœ œœœ˜0J˜�Jšœ!˜!J˜�š Ÿœœœœœ˜?Jš˜JšŸœœœ!˜NJšŸœœœž)˜JJšœœ˜7Jšœ˜Jš˜Jšœ˜—J˜�š Ÿ œœœœœ˜@Jš˜Jšœ.œ˜GJšœœœ˜:JšŸœœœ!˜NJšœ%˜%Jšœ]™]Jšœ"˜"š˜Jšœ œ˜Jšœ˜Jšœ)œ.˜ZJšœ"˜"—Jšœ˜Jšœ˜—J˜�šŸœœœœ˜<Jš˜Jšž'˜'Jšœœœ˜:JšŸœœœ!˜8JšœR˜RJšœ˜Jšœ1˜1Jšœ<˜<Jšœ ˜ Jšœ4˜4Jšœ#˜#Jšœœ ˜Jšœ˜J˜�——J™�šœ8™8J˜�Jšœ.ž"˜PJ˜�šŸœœ;˜IJš˜Jšœ ˜"J˜�š Ÿœœœœž˜BJš˜J˜J˜šœ˜Jšœœœ˜ ˜Jš˜Jšœ˜Jšœ3˜3Jšœœ˜Jšœœ˜Jšœ˜J˜Jšœ˜—˜Jš˜Jšœ˜Jšœœœœœœœ˜=J˜Jšœ˜—Jšœœ˜Jšœœœ˜—Jšœœ˜ Jšœž ˜J˜�—Jšœ™J˜�J˜Jšœ œ˜Jšœœ˜Jšœ?™?Jšœ+™+š˜J˜J˜"J˜J˜!Jš˜šœ˜ šœœœœ˜@Jšœœœ˜——Jšœ œ˜Jš˜Jš˜—Jšœ˜J˜�—Jšœœ˜J˜�Jšœœœœ&ž˜TJš œœœœœ&ž˜[J˜�šŸ œœœœ&˜HJš˜J˜�š Ÿœœœœœœ˜;Jšœœœ˜*J˜�—šŸœœ˜Jš˜Jšœœ˜JšœB˜BJšœœœ˜?J˜šœ"œœœž ˜MJšœ™—JšœC˜CJšœ œ6ž(˜iJšœ˜Jšœ)™)Jšœ"˜"Jšœ"˜"Jšœ>™>Jšœ6™6Jšœ œ>˜JJšœ œœ˜1Jšœ˜šœ˜Jš˜JšŸ œœœœœœœ˜4JšŸœœœœœœœœ˜GJšŸœœœœœœœœ˜AJšœœ˜J˜%Jšœ œœ˜J˜Jš˜—šœœœœœ˜BJš˜J˜+J˜!Jš˜—Jšœ(™(šœœ5˜@Jš˜JšœD™Dšœœ˜Jšœ˜—šœ˜Jšœ˜Jšœ ˜ Jšœ˜Jšœ ˜ Jšœ ™ —Jšœ˜—Jšœ,™,Jšœ ˜ Jšœ ˜ Jšœ*™*JšœA˜AJšœ˜J˜Jšœ'˜'Jšœ œ'˜2Jšœ%˜%Jšœ˜—š˜J˜Jšœ/™/Jšœœ'˜Kš˜J˜ šœ ˜J˜#˜ Jš˜Jšœœœ"˜;J˜2š˜šœ.˜0Jšœœ<œœ˜L—Jšœœ˜4šœœ˜!Jšœœœž œœœ˜8—Jšœœž ˜Jšœ˜—Jšœ˜—Jšœœ˜—J˜Jš˜—Jš˜Jšœ˜J˜�———J™�šœ ™ J˜�šŸ œœœ˜Jš˜Jš œå™íJšœ˜Jšœœ˜Jšœœ˜Jšœœ˜Jšœœ˜J˜J˜'Jšœœž-˜OJ˜(J˜#Jšœœž%˜GJšœC˜CJšœM˜MJšœ*™*Jšœ0™0Jšœ+™+Jšœ0™0Jšœ ™ Jšœ9™9J˜1Jšœœ˜Jšœ™Jšœœ˜šœ œ8˜MJ˜—J˜Jšœ œ+˜6Jšœ œ'˜2Jšœ œ*˜5Jšœ œ&˜1Jšœ œ0˜;Jšœ œ,˜7Jšœ œ-˜8Jšœ œ#˜.Jšœ œ#˜.Jšœ œ"˜-Jšœœ œœœœœœ˜gJšœœ˜-Jšœ&œ˜0J˜*šœ-˜5Jšœ™—šœ-˜5Jšœ™—Jšœ+˜3Jšœœž ˜1Jšœ˜—J˜�šŸœœœ)˜FJš˜Jšœ˜Jšœ˜Jšœ7œœ˜RJšœ˜—J˜�šÐbn œœœ˜7Jšœ"˜"—J˜�š ¡œœœœœ˜2Jšœ œ˜ —J˜�—J˜�Jšœ˜J˜�—�…—����9Ò��U•��