DIRECTORY
BootFile USING [Location, nullLink],
BootStartList USING [Base],
DebuggerFormat USING [ DebugParameter, ExternalStateVector, SwapInfo, SwapReason, VersionID],
DebuggerSwap USING [Frozen, VolumeID],
DeviceCleanup USING [InitializeDeviceCleanup, Perform],
GermSwap USING [GetPStartListHeader, Initialize, InLoad, mdsiGerm, OutLoad, switches--.h, .i, .t--, Teledebug],
MPCodes USING [cantWorldSwap, emptyMP, hanging],
PrincOps USING [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],
TerminalDefs USING [DownUp, KeyBits],
TerminalFace USING [keyboard];


DebugNub: MONITOR -- for CheckInterrupt
IMPORTS DeviceCleanup, GermSwap, PrincOpsUtils, Process, ProcessorFace, TerminalFace
EXPORTS DebuggerSwap
SHARES DeviceCleanup = BEGIN

StateVector: TYPE = PrincOps.StateVector;


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
{
PrincOps.SD[PrincOps.sBreakBlock] _ 0 --NIL--;
PrincOps.SD[PrincOps.sBreakBlockSize] _ 0;
};

Break: PROC =
{
state: RECORD [
padding: ARRAY [0..2) OF WORD, v: 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;
};

WorryBreaker: PROC RETURNS [PrincOps.FrameHandle] =
{
state: RECORD [padding: ARRAY [0..2) OF WORD, v: StateVector];
state.v.instbyte _ 0;
state.v.stkptr _ 1;
state.v.stk[0] _ LOOPHOLE[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;
};


Catcher: PUBLIC RuntimeError.UCSProc =
{
signallerGF: PrincOps.GlobalFrameHandle;
state: StateVector;
f: PrincOps.FrameHandle;
state.stk[0] _ msg;
state.stk[1] _ LOOPHOLE[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;
};

BackStop: PROC [root: PrincOps.FrameHandle] =
{
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];
};

StubSignalHandler: PROC = -- handles signals before SignalsImpl is available
{
state: RECORD [padding: ARRAY [0..2) OF WORD, v: StateVector];
state.v _ STATE;
DO WorryCallDebugger["Signal too early"L] ENDLOOP;
};



swatWatcherEnabled: BOOL;
interruptWanted: BOOL;
interrupter: CONDITION;

CheckInterrupt: ENTRY PROC = {
interruptState: TerminalDefs.DownUp _ up;
keyboard: LONG POINTER TO READONLY TerminalDefs.KeyBits ~ TerminalFace.keyboard;
wakeup: CONDITION;
Process.InitializeCondition[@wakeup, 1];
DO --FOREVER--
ENABLE ABORTED => CONTINUE;
WAIT wakeup;
IF keyboard[Spare3]=down AND keyboard[Ctrl]=down THEN {
IF interruptState=up AND swatWatcherEnabled THEN {
interruptState _ down;
teledebug _ (keyboard[Spare1]=down);
IF keyboard[LeftShift]=down THEN
WorryCallDebugger["Keyboard interrupt (worry mode)"L]
ELSE { interruptWanted _ TRUE; NOTIFY interrupter };
};
}
ELSE interruptState _ up;
ENDLOOP;
};

InterruptSpawner: PROC = {
WaitUntilWanted: ENTRY PROC = {
ENABLE UNWIND => NULL;
interruptWanted _ FALSE;
UNTIL interruptWanted DO WAIT interrupter ENDLOOP;
};
DO ENABLE ABORTED => CONTINUE;
WaitUntilWanted[];
Process.Detach[FORK Interrupt[]];
ENDLOOP;
};

Interrupt: PROC = {
CallDebugger["Keyboard interrupt"L];
};

swatWatcherStarted: BOOL;

StartSwatWatcher: PUBLIC ENTRY SAFE PROC[enabled: BOOL] = TRUSTED {
IF NOT swatWatcherStarted
THEN {
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;
};
swatWatcherEnabled _ enabled;
};

EnableSwatWatcher: PUBLIC ENTRY SAFE PROCEDURE[enabled: BOOL] =
CHECKED{ swatWatcherEnabled _ enabled };


CallDebugger: PUBLIC SAFE PROC [s: STRING] = TRUSTED
{
state: RECORD [a, b: WORD, v: StateVector];
state.v _ STATE;
state.v.stk[0] _ LOOPHOLE[s];
state.v.stkptr _ 1;
state.v.dest _ PrincOpsUtils.GetReturnLink[];
CoreSwap[explicitcall, @state.v]
};

worryCallIndirect: PORT;

WorryCallDebugger: PUBLIC SAFE PROC[STRING];

DoWorryCallDebugger: PROC RETURNS [SAFE PROC[STRING]] = { OPEN PrincOps;
state: RECORD [padding: ARRAY [0..2) OF WORD, v: StateVector];
state.v.instbyte _ 0;
state.v.stkptr _ 1;
LOOPHOLE[worryCallIndirect, PrincOps.Port].frame _ PrincOpsUtils.MyLocalFrame[];
state.v.stk[0] _ LOOPHOLE[@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 _ LOOPHOLE[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
};


freezeesTable: PUBLIC DebuggerSwap.Frozen;

freezer: PUBLIC POINTER TO local PrincOps.Frame;

qFreeze: PrincOps.FaultIndex = 3;

AllocFreezer: PROC RETURNS[ POINTER TO local PrincOps.Frame ] =
{
Caller: PROC[PrincOps.FrameHandle] = LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];
DummyReturnLink: PROC = {ERROR}; -- PrincOps.NullLink breaks ValidateFrame
PrincOpsUtils.SetReturnLink[LOOPHOLE[DummyReturnLink]];
Caller[FreezingPoint[]];
ERROR
};

FreezingPoint: PROC RETURNS[ POINTER TO local PrincOps.Frame ] =
{
freezeQueue: PrincOps.QueueHandle = @PrincOps.PDA.fault[qFreeze].queue;
state: RECORD[a, b: WORD, v: 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;
};

FreezeTrapFrame: PROC[sv: POINTER TO StateVector] = {
-- executed with interrupts disabled --
state: RECORD[a, b: WORD, v: 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;
};


swapInfo: DebuggerFormat.ExternalStateVector; -- nub-debugger communication area

CoreSwap: PROC [why: DebuggerFormat.SwapReason, sp: PrincOps.SVPointer] =
{
DP: DebuggerFormat.DebugParameter;

Decode: PROC RETURNS [proceed: BOOLEAN] = -- decode the SwapReason
{
f: PrincOps.GlobalFrameHandle;
lsv: StateVector;
SELECT swapInfo.reason FROM
proceed, resume => RETURN[TRUE];
call =>
{
lsv _ swapInfo.parameter.sv;
lsv.source _ [frame[PrincOpsUtils.MyLocalFrame[]]];
TRANSFER WITH lsv;
lsv _ STATE;
swapInfo.parameter.sv _ lsv;
why _ return
};
start =>
{
f _ swapInfo.parameter.frame;
IF ~f.started THEN START LOOPHOLE[f, PROGRAM] ELSE RESTART f;
why _ return
};
quit => ERROR Quit;
ENDCASE => RETURN[TRUE];
RETURN[FALSE]
}; --decode--


swapInfo.state _ sp;
DP.spare _ NIL;
swapInfo.parameter _ @DP;
DO
swapInfo.reason _ why;
PrincOpsUtils.DisableInterrupts[];
ToDebugger[@swapInfo];
PrincOpsUtils.EnableInterrupts[];
{
IF Decode[
! CAbort => IF swapInfo.level > 0 THEN {why _ return; CONTINUE};
Quit => GOTO abort] THEN EXIT
EXITS abort => ERROR CAbort
}
ENDLOOP
};

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] = {

SwapIt: PROC = INLINE {
savewdc, saveptc: WORD;
xferTrapStatus: PrincOps.XferTrapStatus = PrincOpsUtils.ReadXTS[];
xferTrapHandler: WORD = 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] _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
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 {
AddToStack: PROC [BOOLEAN] = MACHINE CODE { };
GetTOS: PROC RETURNS [BOOLEAN] = MACHINE CODE { PrincOps.zDUP; };
RemoveFromStack: PROC RETURNS [BOOLEAN] = MACHINE CODE { };
AddToStack[TRUE];
ProcessorFace.SetMP[MPCodes.hanging];
WHILE GetTOS[] DO ENDLOOP;
[] _ RemoveFromStack[];
}
ELSE IF NOT diskDebugger OR teledebug OR GermSwap.switches[t] THEN {
ProcessorFace.SetMP[MPCodes.cantWorldSwap];
GermSwap.Teledebug[@locDebugger];
}
ELSE IF GermSwap.OutLoad[@locDebuggee, restore] = outLoaded THEN {
IF pMicrocodeCopy ~= NIL THEN
DeviceCleanup.Perform[kill];
GermSwap.InLoad[
pMicrocodeCopy,
pGermCopy,
nGerm,
@locDebugger]
};
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];
};

DO
pESV _ FromPilot[];
PrincOpsUtils.SetReturnLink[LOOPHOLE[FromPilot, PrincOps.Port].dest.link^];
DO
SwapIt[];
SELECT pESV.reason FROM
kill => ProcessorFace.BootButton[];
showscreen => {
pulsesThen: LONG CARDINAL = ProcessorFace.GetClockPulses[];
prevSpare3: TerminalDefs.DownUp _ TerminalFace.keyboard[Spare3];
DO
IF (ProcessorFace.GetClockPulses[] - pulsesThen)
> LONG[20]*1000000*100/ProcessorFace.microsecondsPerHundredPulses THEN EXIT;
IF prevSpare3=down THEN prevSpare3 _ TerminalFace.keyboard[Spare3]
ELSE IF TerminalFace.keyboard[Spare3]=down THEN {
WHILE TerminalFace.keyboard[Spare3]=down DO --snore-- ENDLOOP;
EXIT;
}
ELSE NULL -- both up
ENDLOOP;
};
ENDCASE => EXIT;
pESV.reason _ return;
ENDLOOP
ENDLOOP

};


Initialize: PUBLIC PROC = {
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.loadState _ NIL;
swapInfo.display _ NIL;
swapInfo.systemVolumeKnown _ FALSE;
LOOPHOLE[PrincOps.PDA.available, DebuggerFormat.SwapInfo].externalStateVector
_ @swapInfo;
InitBreakBlocks[];
{
sd: POINTER TO ARRAY NAT OF PROC ANY RETURNS ANY = LOOPHOLE[PrincOps.SD];
sd[PrincOps.sSignalList] _ StubSignalHandler;
sd[PrincOps.sSignal] _ StubSignalHandler;
sd[PrincOps.sErrorList] _ StubSignalHandler;
sd[PrincOps.sError] _ StubSignalHandler;
sd[PrincOps.sReturnErrorList] _ StubSignalHandler;
sd[PrincOps.sReturnError] _ StubSignalHandler;
sd[PrincOps.sUnnamedError] _ StubSignalHandler;
sd[PrincOps.sBreak] _ Break;
sd[PrincOps.sAlternateBreak] _ LOOPHOLE[WorryBreaker[]];
sd[205B] _ LOOPHOLE[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 _ LOOPHOLE[@FromPilot];
LOOPHOLE[FromPilot, PrincOps.Port].out _ LOOPHOLE[@ToDebugger];
LOOPHOLE[FromPilot, PrincOps.Port].in _ LOOPHOLE[MemorySwap];
ToDebugger[NIL]; -- allocate frame for MemorySwap
};

NoteDiskDebugger: PUBLIC PROC[debugger, debuggee: BootFile.Location] = {
locDebuggee _ debuggee;
locDebugger _ debugger;
IF locDebuggee.diskFileID.firstLink ~= BootFile.nullLink THEN diskDebugger _ TRUE;
};

NoteLoadstate: PUBLIC PROC[page: PrincOps.PageNumber] = {
swapInfo.loadstatepage _ page;
};

NoteVMRunTable: PUBLIC PROC[table: LONG POINTER] = {
swapInfo.vmRunTable _ table;
};

NoteRealLoadState: PUBLIC PROC[loadState: LONG POINTER] = {
swapInfo.loadState _ loadState;
};

NoteSystemVolume: PUBLIC PROC[id: DebuggerSwap.VolumeID] = {
swapInfo.systemVolume _ LOOPHOLE[id];
};

NoteDisplay: PUBLIC PROC[bitmap: LONG POINTER, w, h: CARDINAL] = {
swapInfo.display _ bitmap; swapInfo.displayW _ w; swapInfo.displayH _ h;
};


END.
	DebugNub.mesa: interface with debugger
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Andrew Birrell  December 2, 1983 11:06 am
Levin, August 8, 1983 3:26 pm
Russ Atkinson (RRA) January 30, 1985 9:23:35 pm PST
Doug Wyatt, April 12, 1985 4:37:28 pm PST

******** 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, mds set by MemorySwap
0 collides with NIL.)
in case we are restarted in trap mode
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˜
code™&Kšœ
Οm
œ1™<K™)K™J™3K™)—K˜š
Οk	˜	Kšœ	žœ˜$Kšœžœ˜KšœžœI˜]Kšœ
žœ˜&Kšœžœ$˜7Kšœ	žœFΟcœ
˜oKšœžœ#˜0Kšœ	žœcžœ`žœ”
˜κKšœžœ€˜“KšœžœŒ
˜™
KšœžœC˜VKšœ
žœ˜Kšœ
žœ˜%Kšœ
žœ˜K˜—K˜šœ
žœ
Ÿ˜'KšžœM˜TKšžœ
˜Kšžœž˜K˜Kšœ
žœ˜)K˜—K™š
œ"™"K˜Kšœžœ
žœŸ˜4K˜KšœžœŸ)˜=K˜K˜K˜Kšœžœ
žœŸ)˜GKšœžœ
žœŸ$˜=KšœžœŸ%˜6K˜Kšœžœžœ
˜Kšœžœžœ
˜Kšœžœžœ
˜K˜—K™š
œ™K˜K˜šΟnœžœŸ˜(Kš
œ
˜
Kšœ	žœŸœ
˜.Kšœ	žœ˜*Kš
œ˜K˜—š œžœ˜
Kš
œ'™'Kš
œ
˜
šœžœ˜Kšœ	žœžœ
žœ˜/—Kšœ
žœ
˜Kš
œ-˜-K˜#Kš
œ˜Kšžœžœ˜CKšžœ
žœ	˜Kš
œ˜K˜—š œžœ
žœ˜3Kš
œ&™&Kš
œ
˜
Kš	œžœžœžœ
žœ˜>K˜K˜Kšœžœ˜8Kš
œ-˜-K˜#Kš
œ"˜"š
ž˜Kšžœžœ˜CKš
œ!˜!Kšžœ
žœ	˜Kš
œ"˜"Kšœ
žœ
˜Kš
œ-˜-K˜#K˜KšœŸ˜,K˜Kšžœ
˜—Kš
œ˜K˜——K™š
œ"™"K˜šΟbœžœ˜&Kš
œ
˜
K˜(Kš
œ˜K˜K˜Kšœžœ	˜ K˜Kš
œ>™>K˜#K˜Kš
œ&˜&Kšžœžœ˜=Kšœ,žœ˜8š
ž˜˜Kš
žœ
žœ
žœžœžœ˜JKšžœ
žœ
žœ
˜——Kš
œ˜K˜—š œžœ˜-Kš
œ
˜
K˜3Kš œžœžœ ˜7K˜8K˜1Kšœžœ˜&K˜(Kš
œ˜—K˜š œžœŸ2˜LKš
œ
˜
Kš	œžœžœžœ
žœ˜>Kšœ
žœ
˜Kšžœ(žœ
˜2Kš
œ˜K˜——K˜š
œ(™(K˜Kšœžœ
˜Kšœžœ
˜Kšœ
ž	œ
˜K˜š œžœ
žœ˜Kš
œ)˜)Kš	œ
žœ
žœ
žœ
žœ.˜PKšœž	œ
˜K˜(šžœ
Ÿ˜Kšžœ
žœžœ
˜Kšžœ˜šžœžœžœ˜7šžœžœžœ˜2Kš
œ˜Kš
œ$˜$šžœž˜ Kš
œ5˜5—Kšžœžœžœ˜4Kš
œ˜—Kš
œ
˜
—Kšžœ˜Kšžœ
˜—Kš
œ˜—K˜š œžœ˜š œžœ
žœ˜Kšžœ
žœžœ
˜Kšœžœ
˜Kšžœžœ
žœ
žœ
˜2Kš
œ˜—šžœ
žœ
žœžœ
˜K˜Kšœžœ˜!Kšžœ
˜—Kš
œ˜—K˜š 	œžœ˜K˜$Kš
œ˜—K˜Kšœžœ
˜K˜š œžœ
žœ
žœ
žœ
žœžœ˜CKš
œI™IKšžœ
žœ˜šžœ˜K˜8Kš
œ-˜-Kš
œ%˜%Kš
œ-˜-Kšœžœ˜(K˜1Kšœžœ˜&K˜"Kšœžœ
˜Kš
œ˜—Kš
œ˜Kš
œ˜—K˜š œžœ
žœ
žœ
ž	œ
žœ˜?Kšžœ!˜(K˜——K™š
œ™K˜š œžœ
žœ
žœžœž˜4Kš
œ
˜
Kšœžœžœ˜+Kšœ
žœ
˜Kšœžœ˜K˜K˜-K˜ Kš
œ˜K˜—Kšœžœ
˜K˜Kš
 œžœ
žœ
žœ
žœ˜,K˜š œžœ
žœžœ
žœ
žœž
œžœ
˜HKš	œžœžœžœ
žœ˜>K˜K˜Kš
œI™IKš
œH™HKš
œA™AKšžœH˜PKšœžœ˜.Kš
œ-˜-K˜#Kš
œ"˜"šžœ
Ÿ˜Kšžœžœ˜CKš
œ!˜!Kšžœ
žœ	˜Kš
œ"˜"Kšœ
žœ
˜Kšœžœ"˜9Kš
œ*˜*K˜#K˜K˜K˜Kš
ž˜—Kš
œ˜K˜——K™š
œ6™6K˜Kšœžœ˜*K˜Kšœ	žœ
žœ
žœ˜0K˜Kš
œ!˜!K˜š
 œžœ
žœžœ
žœ˜?Kš
œ
˜
Kš œžœžœ!˜NKš œžœžœŸ)˜JKšœžœ˜7Kš
œ˜Kš
ž˜Kš
œ˜—K˜š
 
œžœ
žœžœ
žœ˜@Kš
œ
˜
Kšœ.žœ˜GKšœžœžœ˜*Kš œžœžœ!˜NKš
œ%˜%Kš
œ]™]Kš
œ"˜"š
ž˜Kšœ
žœ
˜Kš
œ˜Kšœ)žœ.˜ZKš
œ"˜"—Kšžœ
˜Kš
œ˜—K˜š
 œžœžœ
žœž
œ
˜5Kš
Ÿ'˜'Kšœžœžœ˜*Kš œžœžœ!˜8Kš
œR˜RKš
œ˜Kš
œ1˜1Kš
œ<˜<Kš
œ	˜	Kš
œ4˜4Kš
œ#˜#Kšžœ
žœ	˜Kš
œ˜K˜——K™š
œ8™8K˜Kšœ.Ÿ"˜PK˜š œžœ;˜IKš
œ
˜
Kšžœ ˜"K˜š	 œžœ
žœžœŸ˜BKš
œ
˜
K˜K˜šžœž˜Kšœžœ
žœ˜ ˜Kš
œ
˜
Kš
œ˜Kš
œ3˜3Kšžœ
žœ˜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šžœ
žœ˜Kš
œ
˜
Kš
ž˜—Kš
œ˜K˜—Kšœžœ
˜K˜Kšœžœžœ
žœ&Ÿ˜TKš
œžœ
žœžœ
žœ&Ÿ˜[K˜š
 
œžœžœ
žœ&ž
œ
˜JK˜š œžœžœ
˜Kšœžœ
˜Kš
œB˜BKšœžœžœ˜8K˜šœ"žœ
žœžœŸ
˜MKš
œ™—Kš
œC˜Cšœ	žœžœ˜IKš
œ%™%—Kš
œ˜Kš
œ)™)Kš
œ"˜"Kš
œ"˜"Kš
œ>™>Kš
œ6™6Kšœ	žœ>˜JKšœ	žœžœ
˜1Kš
œ˜šžœžœ˜Kš
 
œžœžœžœ
žœ˜.Kš œžœ
žœžœžœ
žœ˜AKš œžœ
žœžœžœ
žœ˜;Kšœžœ˜K˜%Kšžœ
žœ
žœ
˜K˜Kš
œ
˜
—šžœ
žœ
žœžœžœžœ˜DK˜+K˜!Kš
œ
˜
—Kš
œ(™(šžœ
žœ5žœ˜BKš
œD™Dšžœžœ
ž˜Kš
œ˜—š
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ
™
—Kš
œ˜—Kš
œ,™,Kš
œ ˜ Kš
œ ˜ Kš
œ*™*Kš
œA˜AKš
œ˜K˜Kš
œ'˜'Kšœ	žœ'˜2Kš
œ%˜%Kš
œ˜—K˜š
ž˜K˜Kš
œ/™/Kšœžœ'˜Kš
ž˜K˜	šžœ
ž˜K˜#š
œ˜Kšœžœ
žœ"˜;Kš
œ@˜@š
ž˜šžœ.˜0Kšœžœ<žœ
žœ
˜L—Kšžœžœ+˜Bšžœ
žœ$žœ˜1Kšžœ$žœ
Ÿ	œ
žœ
˜>Kšžœ
˜Kš
œ
˜
—Kšžœ
žœ
Ÿ
˜Kšžœ
˜—Kš
œ˜—Kšžœžœ
˜—K˜Kš
ž˜—Kš
ž˜—K˜š
œ˜K˜———K™š
œ ™ K˜š 
œžœ
žœ˜Kš‘œε™νKš
œ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜K˜K˜'KšœžœŸ-˜OK˜(K˜#KšœžœŸ%˜GKš
œC˜CKš
œM˜MKš
œ*™*Kš
œ0™0Kš
œ+™+Kš
œ0™0Kš
œ ™ Kš
œ9™9K˜1Kšœžœ
˜Kš
œ™Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜#šžœ
žœ8˜MK˜—K˜˜
Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ
žœ˜IKš
œ-˜-Kš
œ)˜)Kš
œ,˜,Kš
œ(˜(Kš
œ2˜2Kš
œ.˜.Kš
œ/˜/Kš
œ˜Kšœžœ˜8Kšœžœ˜.K˜—Kšžœžœ	žœ
žœ
žœ
žœ
žœžœ˜gšžœžœž˜0Kš
œ%˜%Kšžœ
˜—K˜*šžœ"žœ
˜?Kš
œ™—šžœ!žœ˜?Kš
œ™—Kšžœ žœ
˜=KšœžœŸ ˜1Kš
œ˜—K˜š œžœ
žœ+˜HKš
œ˜Kš
œ˜Kšžœ7žœžœ
˜RKš
œ˜—K˜šΠbn
œžœ
žœ˜9Kš
œ˜Kš
œ˜—K˜š
’œžœ
žœžœ
žœ˜4Kš
œ˜Kš
œ˜—K˜š’ 
œžœ
žœžœ
žœ˜;Kš
œ˜Kš
œ˜—K˜š œžœ
žœ˜<Kšœžœ˜%Kš
œ˜—K˜š œžœ
žœ	žœ
žœžœ˜BKš
œH˜HKš
œ˜—K˜—K˜Kšžœ
˜—…—:ZW