DIRECTORY
Basics USING [BITAND],
BasicTime USING [GetClockPulses, Pulses, PulsesToMicroseconds],
DebuggerSwap USING [CallDebugger],
FastBreak USING [FastBreakProc],
PrincOps,
PrincOpsUtils USING [DisableInterrupts, EnableInterrupts, LongNotify, LongReEnter, LongWait, PsbIndexToHandle, PsbHandleToIndex, ReadPSB, ReadPTC],
Process USING [Detach, GetCurrent, GetPriority, InitializeCondition, Priority, priorityRealTime, priorityNormal, SecondsToTicks, SetPriority],
Rope USING [ROPE],
SafeStorage USING [NWordsAllocated, NWordsReclaimed],
Loader USING [MakeProcedureResident, MakeGlobalFrameResident],
SpyClient USING [DataType],
SpyLog USING [active, Here, OpenForWrite, WriteData],
SpyOps USING [Count, DataType, Frame, SetAllocationBreak, SpyState, Stack, stackHeader, stackLength, StackType],
Terminal USING [Current, Virtual, WaitForBWVerticalRetrace],
VM USING [AddressFault, PageNumberForAddress],
VMStatistics USING [pageFaults];

SpyKernelImpl: MONITOR
IMPORTS
Basics, BasicTime, DebuggerSwap, Loader, PrincOpsUtils, Process, SafeStorage, SpyLog, SpyOps, Terminal, VM, VMStatistics
EXPORTS SpyClient, SpyOps
= { OPEN PrincOps, Rope;

PsbIndex: TYPE = PrincOps.PsbIndex;
Ticks: TYPE = PrincOps.Ticks;

-- SpyKernel parameters --
spyState: PUBLIC SpyOps.SpyState _ off;
watching: PUBLIC SpyOps.DataType _ CPU;
justMe: PUBLIC PsbIndex _ 0;

runningTime: PUBLIC BasicTime.Pulses; -- total time running
pageFaults: PUBLIC LONG CARDINAL;
active, starts, stops: PUBLIC INTEGER _ 0;
wordsAllocated: PUBLIC LONG CARDINAL;
wordsReclaimed: PUBLIC LONG CARDINAL;

code: PUBLIC SpyOps.Count _ 0; -- page faults on code
data: PUBLIC SpyOps.Count _ 0; -- page faults on data


InitializeSpy: PUBLIC ENTRY PROC[
dataType: SpyClient.DataType _ CPU,
process: PsbIndex _ PrincOps.PsbNull,
spyOnSpyLog: BOOL _ FALSE]
RETURNS[errorMsg: ROPE] = {
DisableSpy[];
IF dataType IN [allocations..wordsAllocated] THEN errorMsg _ SpyOps.SetAllocationBreak[];
IF errorMsg # NIL THEN RETURN[errorMsg];
InitializeTables[];
watching _ dataType;
justMe _ IF dataType = process THEN process ELSE 0;
SpyLog.OpenForWrite[spyOnSpyLog];
EnableSpy[];
};

InitializeTables: PROC = {
runningTime _ 0;
code _ data _ 0;
wordsAllocated _ wordsReclaimed _ 0;
};

Initialize: PROC = {
dolphin _ BasicTime.PulsesToMicroseconds[1]#32; -- hack
Loader.MakeProcedureResident[Spy];
Loader.MakeProcedureResident[Record];
Loader.MakeProcedureResident[UserBreak];
Loader.MakeProcedureResident[PageFaultRecorder];
Loader.MakeGlobalFrameResident[Initialize];
Process.InitializeCondition[@processDead, 10000];
SetTimeouts[];
};

SetTimeouts: PROC = {
ticks: Ticks;
cutoff: Ticks;
found: BOOLEAN;
frame: PrincOps.FrameHandle;
cutoff _ Process.SecondsToTicks[10];
ticks _ PrincOpsUtils.ReadPTC[];
FOR psbi: PsbIndex IN [PrincOps.StartPsb..PrincOps.StartPsb+PrincOps.PDA.count) DO
IF PrincOps.PDA.block[psbi].mds = 0 THEN LOOP;
IF PrincOps.PDA.block[psbi].mds - ticks > cutoff THEN LOOP; -- not significant
IF PrincOps.PDA.block[psbi].link.vector
THEN frame _ PDA[PrincOps.PDA.block[psbi].context.state].frame
ELSE frame _ PrincOps.PDA.block[psbi].context.frame;
found _ FALSE;
FOR i: CARDINAL IN [0..index) DO
IF timeout[i] = [frame.accesslink, frame.pc] THEN {found _ TRUE; EXIT};
ENDLOOP;
IF found THEN LOOP;
timeout[index] _ [frame.accesslink, frame.pc];
index _ index + 1;
IF index = maxIndex THEN EXIT;
ENDLOOP;
};  




processDead: CONDITION;
spyProcess: PROCESS _ NIL;
oldSpyState: SpyOps.SpyState _ off;

startTime: BasicTime.Pulses;
startPageFaults: LONG CARDINAL;
startWordsAllocated: LONG CARDINAL;
startWordsReclaimed: LONG CARDINAL;

StartCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {
priority: Process.Priority;
starts _ starts + 1;
IF active = 0 THEN WHILE spyProcess # NIL DO WAIT processDead; ENDLOOP; 
IF (active _ active + 1) > 1 THEN RETURN[useOldBreak: FALSE]; -- a psuedo start
startPageFaults _ VMStatistics.pageFaults;
startWordsAllocated _ SafeStorage.NWordsAllocated[];
startWordsReclaimed _ SafeStorage.NWordsReclaimed[];
startTime _ BasicTime.GetClockPulses[];
IF watching = breakProcess THEN justMe _ LOOPHOLE[Process.GetCurrent[]];
IF justMe # 0 THEN justMePrincOps _ @PrincOps.PDA[PrincOpsUtils.PsbIndexToHandle[justMe]];
SetTimeouts[]; -- do it a second time in case the first time missed some
priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityRealTime];
SELECT watching FROM
CPU, process, breakProcess => Process.Detach[spyProcess _ FORK Spy[]]; 
pagefaults => Process.Detach[spyProcess _ FORK PageFaultRecorder[]];
allocations, wordsAllocated => {
spyState _ on};
ENDCASE => spyState _ on;
Process.SetPriority[priority];
RETURN[useOldBreak: FALSE];
};

StopCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {
IF active = 0 THEN RETURN[useOldBreak: FALSE]; -- already stopped
stops _ stops + 1;
IF (active _  active - 1) > 0 THEN RETURN; -- a psuedo stop
spyState _ off;
runningTime _ runningTime + BasicTime.GetClockPulses[] - startTime;
pageFaults _ pageFaults + VMStatistics.pageFaults - startPageFaults;
wordsAllocated _ wordsAllocated + SafeStorage.NWordsAllocated[] - startWordsAllocated;
wordsReclaimed _ wordsReclaimed + SafeStorage.NWordsReclaimed[] - startWordsReclaimed;
RETURN[useOldBreak: FALSE];
};

DisableSpy: PROC = {
IF spyState = disabled THEN RETURN;
oldSpyState _ spyState; 
spyState _ disabled;
};

EnableSpy: PROC = {spyState _ oldSpyState};



justMePrincOps: LONG POINTER TO ProcessStateBlock _ NIL;
wait: CARDINAL _ 0; -- used with dolphins
monitor: BOOLEAN _ FALSE; -- measure performance of spy
dolphin: BOOLEAN _ FALSE;
maxStackDepth: CARDINAL = 200;
timeout: ARRAY [0..maxIndex) OF RECORD[gfh: PrincOps.GlobalFrameHandle, pc: CARDINAL];
maxIndex: CARDINAL = 20;
index: CARDINAL_ 0;
sampleInterval: INT _ 10*1000; -- measured in microseconds
screen: Terminal.Virtual = Terminal.Current[];
searchReadyList: BOOLEAN _ TRUE; -- sometimes the user gets the machine gets into a state where searching the ready list is a bad idea.  This boolean allows the user to stop the Spy from searching the ready list.

Spy: PROC = {
top: PsbIndex;
frame: FrameHandle;
myPrincOps: PsbHandle = PrincOpsUtils.ReadPSB[];
handleMask: PsbLink = [
failed: FALSE, priority: 0, next: LAST[PsbIndex], reserved: 0, vector: FALSE];
NextHandle: PROC [link: CARDINAL] RETURNS [PsbHandle] = INLINE {
RETURN[LOOPHOLE[Basics.BITAND[link, LOOPHOLE[handleMask]]]]};
SearchReadyList: PROC = INLINE {
skip, once: BOOLEAN _ FALSE;
headOfReadyList, current: PsbHandle;
PrincOpsUtils.DisableInterrupts[];
top _ PrincOps.PsbNull;
headOfReadyList _ NextHandle[LOOPHOLE[PDA.ready]];
headOfReadyList _ NextHandle[LOOPHOLE[PDA[headOfReadyList].link]]; -- want the SECOND psb.
FOR current _ headOfReadyList, NextHandle[LOOPHOLE[PDA[current].link]] DO
psb: LONG POINTER TO ProcessStateBlock = @PDA[current];
link: PsbLink = psb.link;
level: Process.Priority = link.priority;
IF current = headOfReadyList THEN IF once THEN EXIT ELSE once _ TRUE;
IF level = 0 THEN LOOP;
IF current = myPrincOps THEN LOOP;
IF ~link.vector AND PDA.state[level] = NullStateVectorHandle THEN LOOP; -- no SV.
frame _ IF link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;
skip _ FALSE;
FOR i: CARDINAL IN [0..maxIndex) DO
IF timeout[i] = [NIL, 0] THEN EXIT;
IF timeout[i] # [frame.accesslink, frame.pc] THEN LOOP;
skip _ TRUE; EXIT;
ENDLOOP;
IF skip THEN LOOP;
top _ PrincOpsUtils.PsbHandleToIndex[current];
EXIT; ENDLOOP;
PrincOpsUtils.EnableInterrupts[];
};
spyState _ on;
-- MAIN LOOP --
DO -- IF IntervalTimerFace.exists 
-- THEN IntervalTimer.WaitForExpirationInterval[sampleInterval] ELSE 
Terminal.WaitForBWVerticalRetrace[screen];
IF active <= 0 THEN EXIT;
IF spyState = disabled THEN LOOP;
IF dolphin AND wait > 0 THEN {wait _ wait - 1; LOOP} ELSE wait _ 8;
IF monitor THEN SpyLog.Here[];
IF justMe = 0 OR searchReadyList THEN SearchReadyList[];
SELECT TRUE FROM
justMe = 0 => Record[top, frame];
justMePrincOps.link.failed => Record[justMe, NIL, 2]; -- waiting ML
justMePrincOps.flags.waiting => Record[justMe, NIL, 3]; -- waiting CV
OnQueue[justMe, @PDA.fault[PrincOps.qPageFault].queue] => 
Record[justMe, NIL, 1]; -- waiting pagefault
OnQueue[justMe, @PDA.fault[PrincOps.qPageFault+4].queue] => 
Record[justMe, NIL, 1]; -- waiting pagefault
OnQueue[justMe, @PrincOps.PDA.ready] => 
SELECT TRUE FROM
PDA.state[justMePrincOps.link.priority] = NullStateVectorHandle AND 
~justMePrincOps.link.vector => Record[justMe, NIL, 5]; -- waiting SV
searchReadyList AND justMe # top => Record[justMe, NIL, 4]; -- prempted by a higher priority process 
ENDCASE => Record[justMe]; -- ready
ENDCASE => Record[justMe, NIL, 6]; -- in some unknown state
IF monitor THEN SpyLog.Here[];
ENDLOOP;
spyProcess _ NIL;
spyState _ off;
NotifyProcessDead[];
Process.SetPriority[Process.priorityNormal];    
};

OnQueue: PROC[psbi: PsbIndex, queueHandle: PrincOps.QueueHandle]
RETURNS[BOOL] = INLINE {
tail, prev: PsbIndex;
IF queueHandle^ = PrincOps.QueueEmpty THEN RETURN[FALSE];
prev _ tail _ queueHandle.tail;
THROUGH [FIRST[PsbIndex]..LAST[PsbIndex]+1] -- garbage protection --
DO next: PsbIndex = PrincOps.PDA.block[prev].link.next;
IF next = psbi THEN RETURN[TRUE];
prev _ next;
IF prev = tail THEN RETURN[FALSE];
ENDLOOP;
RETURN[FALSE] -- actually, the queue is thoroughly mangled! --
};


recordPageFaulted: BOOLEAN _ FALSE;
Data: TYPE = RECORD[process: CARDINAL, page: INTEGER];
CodeBase: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF PrincOps.op;

PageFaultRecorder: PROC = {
fault: Data;
type: CARDINAL;
codePage: INTEGER;
handle: PrincOps.PsbHandle;
frame: PrincOps.FrameHandle;
pda: PrincOps.PDABase = PrincOps.PDA;
qPageFault: PrincOps.FaultIndex = PrincOps.qPageFault;
pPageFaultCondition: LONG POINTER TO PrincOps.Condition = 
@pda.fault[qPageFault].condition;
pPageFaultCONDITION: LONG POINTER TO CONDITION =
LOOPHOLE[pPageFaultCondition];
recorderLock: MONITORLOCK;
shouldNotifyPilot: BOOLEAN _ FALSE;
spyState _ on;
DO  
PrincOpsUtils.LongWait[@recorderLock, pPageFaultCONDITION, 1];
UNTIL PrincOpsUtils.LongReEnter[@recorderLock, pPageFaultCONDITION] DO
NULL ENDLOOP;
IF pda.fault[qPageFault].queue.tail = PrincOps.PsbNull THEN { -- timed out
IF shouldNotifyPilot
AND pda.fault[qPageFault].condition.tail ~= PrincOps.PsbNull THEN {
LongNakedNotify[pPageFaultCONDITION];
shouldNotifyPilot _ FALSE};
IF active <= 0 THEN EXIT;
LOOP};  -- go back and wait again.
fault.process _ pda.block[pda.fault[qPageFault].queue.tail].link.next;  -- walk to tail, then to head.
handle _ PrincOpsUtils.PsbIndexToHandle[fault.process];
fault.page _ VM.PageNumberForAddress[pda[pda[handle].context.state].memPointer];
frame _ IF pda[handle].link.vector 
THEN pda[pda[handle].context.state].frame 
ELSE pda[handle].context.frame;
codePage _ LOOPHOLE[frame.accesslink.code.longbase+frame.pc/2, INT]/256;
SELECT TRUE FROM
ABS[codePage - fault.page] <= 1  => {code _ code + 1; type _ 2};
Xfer[frame.accesslink.code.longbase, frame.pc]  => {code _ code + 1; type _ 3}; 
ENDCASE => {data _ data + 1; type _ 1};
PrincOpsUtils.DisableInterrupts[];
IF pPageFaultCondition^.tail = PrincOps.PsbNull 
THEN shouldNotifyPilot _ TRUE  -- Pilot not ready for this fault yet...
ELSE LongNakedNotify[pPageFaultCONDITION];
PrincOpsUtils.EnableInterrupts[];
IF active <= 0 THEN EXIT;
IF recordPageFaulted THEN SpyLog.WriteData[@fault, SIZE[Data], CODE[Data]];
Record[fault.process, NIL, type];
ENDLOOP;
spyProcess _ NIL;
spyState _ off;
NotifyProcessDead[];
Process.SetPriority[Process.priorityNormal];    
};

Xfer: PROC[base: CodeBase, pc: PrincOps.BytePC] RETURNS[BOOLEAN] = INLINE {
IF base[pc] IN [PrincOps.zEFC0..PrincOps.zKFCB] THEN RETURN[TRUE];
RETURN[FALSE];
};

LongNakedNotify: PROC [pCondition: LONG POINTER TO CONDITION] = INLINE {
pCond: LONG POINTER TO PrincOps.Condition = LOOPHOLE[pCondition];
PrincOpsUtils.DisableInterrupts[];
IF pCond^.tail=PrincOps.PsbNull 
THEN {pCond^.wakeup _ TRUE; PrincOpsUtils.EnableInterrupts[]}
ELSE {PrincOpsUtils.EnableInterrupts[]; PrincOpsUtils.LongNotify[pCondition]}};

NotifyProcessDead: ENTRY PROC = INLINE {NOTIFY processDead}; 


stack: SpyOps.Stack;
break: BOOLEAN _ FALSE;
breakAtom: ATOM _ NIL;

AllocationBreak: PUBLIC FastBreak.FastBreakProc = {
words: CARDINAL;
type: SpyOps.StackType;
local: POINTER TO ARRAY [0..7] OF CARDINAL;
IF active = 0 THEN RETURN;
IF watching NOT IN [allocations..wordsAllocated] THEN RETURN;
words _ 1; type _ 0; IF watching = wordsAllocated THEN local _ @frame.local[0];
IF data = NIL AND watching = wordsAllocated THEN words _ local[0];
IF data = LOOPHOLE[$Permanent, LONG POINTER] THEN {
type _ 1; IF watching = wordsAllocated THEN words _ local[2]};
IF data = LOOPHOLE[$Unsafe, LONG POINTER] THEN {
type _ 2; IF watching = wordsAllocated THEN words _ local[4]};
IF break AND data = LOOPHOLE[breakAtom, LONG POINTER] 
THEN DebuggerSwap.CallDebugger["Allocation break"];
Record[
psbi: LOOPHOLE[Process.GetCurrent[]],
type: type,
frame: frame,
count: words];
};

UserBreak: PUBLIC FastBreak.FastBreakProc = TRUSTED {
count: CARDINAL _ 1;
type: SpyOps.StackType _ 1;
IF spyState # on THEN RETURN[useOldBreak: FALSE];
IF watching # userDefined THEN RETURN[useOldBreak: FALSE];
IF data # NIL THEN type _ LOOPHOLE[data, LONG POINTER TO SpyOps.StackType]^;
Record[LOOPHOLE[Process.GetCurrent[]], frame, type, count];
RETURN[useOldBreak: FALSE];
};

Record: PUBLIC ENTRY PROC[psbi: PsbIndex, frame: FrameHandle _ NIL, 
type: SpyOps.StackType _ 0, count: CARDINAL _ 1] = {
level: Process.Priority;
psb: LONG POINTER TO ProcessStateBlock;
IF spyState = disabled THEN RETURN;
IF active <= 0 THEN RETURN;
IF psbi = PrincOps.PsbNull THEN 
IF PDA.fault[qPageFault].queue.tail = PrincOps.PsbNull
AND PDA.fault[qPageFault+4].queue.tail = PrincOps.PsbNull
THEN {LogStack[psbi, 0, NIL, count, 0]; RETURN}
ELSE {LogStack[psbi, 0, NIL, count, 1]; RETURN}; -- waiting for a page fault
psb _ @PDA[PrincOpsUtils.PsbIndexToHandle[psbi]];
level _ psb.link.priority;
IF frame = NIL THEN 
frame _ IF psb.link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;
LogStack[psbi, level, frame, count, type]
};

LogStack: INTERNAL PROC
[process: PsbIndex, level: Process.Priority, frame: FrameHandle, count, type: CARDINAL] = {
sdLength: CARDINAL = PrincOps.SD[PrincOps.sGFTLength];
gfi: GFTIndex _ 0;
gf: GlobalFrameHandle _ NIL;
length: CARDINAL _ 0;
ValidFrame: PROC [f: ControlLink] RETURNS [FrameHandle] = {
OPEN PrincOps;
IF f.proc OR f.indirect OR f.frame =NIL OR (gf _ f.frame.accesslink) = NIL OR
(gfi _ gf.gfi) > sdLength OR PrincOps.GFT[gfi].framePtr ~= gf THEN RETURN[NIL];
RETURN[f.frame]
};
IF ~SpyLog.active THEN RETURN;
stack.type _ type;
stack.count _ count;
stack.level _ level;
stack.process _ process;
frame _ ValidFrame[LOOPHOLE[frame] ! VM.AddressFault => {frame _ NIL; CONTINUE}];
THROUGH [0..maxStackDepth) UNTIL frame = NIL DO
IF length >= SpyOps.stackLength THEN {stack.level _ 7; length _ 0; EXIT};
stack.frame[length] _ [0, gfi, frame.pc];
IF length > 0 AND stack.frame[length] = stack.frame[length-1] 
THEN length _ length - 1; -- skip recursive frames
length _ length + 1;
frame _ ValidFrame[frame.returnlink ! VM.AddressFault => EXIT];
ENDLOOP;
SpyLog.WriteData[@stack,
SpyOps.stackHeader + length*SpyOps.Frame.SIZE, 
SpyOps.Stack.CODE];
};

Initialize[];

}.

ΰSpyKernelImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Bruce	14-Feb-81 19:30:51
MBrown	16-Aug-81 13:30:07
Levin	2-Nov-81 18:16:29
Maxwell	September 16, 1983 3:44 pm
Russ Atkinson	January 8, 1985 0:28:36 am PST
IntervalTimer USING [WaitForExpirationInterval],
IntervalTimerFace USING [exists],
PageMap USING [GetF, flagsVacant],
general statistics
****************************************************************************
initializing the Spy and data
****************************************************************************
IF IntervalTimerFace.exists THEN RETURN;
PrincOpsUtils.DisableInterrupts[]; -- stops the clock. NO PAGE FAULTS ALLOWED!
PrincOpsUtils.EnableInterrupts[];
ZeroLog: PUBLIC PROC = {
SpyLog.Initialize[NIL, 40, TRUE];
SpyLog.Open[TRUE]};
****************************************************************************
starting and stopping the Spy
****************************************************************************
Note:  These procedures need not be resident.
RTStorageAccounting.AllocatorCallbackProcForSpy _ SensitiveBreak;
*********************************************************************
watching CPU    
*********************************************************************
All code invoked by this process should be resident
skip over a process that appears in the ready queue because it just timed out.
(The Spy wakes up with all of the other timeouts.  Since it is the highest priority,
it will run first.  All of the other timeouts will appear on the ready list.  Most likely,
they will just check some condition and then go back to sleep.  This will mask the
more interesting processes.)  
we have a good process!
*********************************************************************
watching pagefaults    
*********************************************************************
stolen from Ben.mesa
NO PAGE FAULTS ALLOWED!
wait for a page fault:
figure out who faulted:
wake up the Pilot fault handler:
log the fault:
is the current pc pointing to some sort of xfer?
Used ONLY to notify a condition from a high priority process outside the relevant monitor.
***************************************************************************
recording the information
***************************************************************************
data: FastBreakData, frame: PrincOps.FrameHandle, sv: PrincOps.SVPointer
Log the stack on the Trace Log --
This procedure is supposed to validate a control link.  For various race conditions (presumably), we have observed address faults when the accesslink gets clobbered.  Since we can't handle the address faults in here, we insist that the caller be prepared for such an eventuality. (RRA)
Note: as a side-effect, this procedure sets 'gf' and 'gfi', which are
used by the other local procedures below and the main loop of IncrementBucket.
PageMap.GetF[Basics.LongDiv[LOOPHOLE[LONG[gf]], wordsPerPage]].flags = flagsVacant OR
save the current frame
this also saves the last ignored frame


22-Jan-82 Maxwell: Removed cross-partition code; converted to Cedar
4-Feb-82 Maxwell: Added stack active option
11-Mar-82 Maxwell: Added page fault recorder
October 14, 1982 10:07 am Maxwell: Removed Pilot Spy code
Russ Atkinson (RRA) January 8, 1985 0:26:03 am PST
Tried to fix the problem with referencing frame.accesslink.gfi with interrupts disabled, which could crash the world if it found a swapped-out global frame.  We now use the global frame instead of the gfi.
changes to: SetTimeouts, timeout, SearchReadyList (local of Spy)

Κq˜š
œ™Jšœ
Οm
œ7™BJ–1.5 in tabStopsš
œ™J–1.5 in tabStopsš
œ™J–1.5 in tabStopsš
œ™J–1.5 in tabStopsš
œ"™"J–1.5 in tabStopsš
œ,™,—J˜š
Οk	˜	Jšœžœžœ˜Jšœ
žœ0˜?Jšœ
žœ˜"Jšœ
žœ˜ Jšœžœ™0Jšœžœ
™!Jš
œ	˜	Jšœžœ€
˜“
Jšœžœ™"Jšœžœ
˜Ž
Jšœžœžœ˜Jšœžœ$˜5Jšœžœ2˜>Jšœ
žœ˜Jšœžœ)˜5Jšœžœd˜pJšœ	žœ.˜<Jšžœ
žœ&˜.Jšœ
žœ˜ —J˜šœž˜š
ž˜Jšœhžœ˜x—Jšžœ˜Jšœ
ž
œžœ˜J˜Jšœ
žœ˜#Jšœžœ˜—J˜š
Οc˜Jšœ
žœ˜'Jšœ
žœžœ
˜'Jšœžœ˜J˜—š
œ™Jšœ
žœŸ˜;Jšœžœ
žœ
žœ
˜!Jšœžœ
žœ˜*Jšœžœ
žœ
žœ
˜%Jšœžœ
žœ
žœ
˜%J˜JšœžœŸ˜5JšœžœŸ˜5—J˜Jš
œL™LJš
œ™Jš
œL™LJ˜šΟn
œžœ
žœ
žœ
˜!Jšœžœ
˜#Jš
œ%˜%Jšœ
žœ
˜Jšžœžœ˜J˜
Jšžœ
žœžœ(˜YJšžœžœ
žœ
žœ˜(J˜J˜Jšœ	žœžœ	žœ˜3Jš
œ!˜!J˜Jš
œ˜—J˜š œžœ˜J˜J˜J˜$Jš
œ˜J˜—š 
œžœ˜Jšœ0Ÿ˜7J˜"Jš
œ%˜%Jš
œ(˜(Jš
œ0˜0J˜+J˜1J˜Jš
œ˜J˜—š œžœ˜Jš
œ
˜
Jš
œ˜Jšœžœ
˜J˜Jšžœžœ
žœ
™(J˜$Jšœ#Ÿ+™NJš
œ ˜ šžœžœ0žœž˜RJšžœ
žœžœ
žœ
˜.Jš	žœ
žœ"žœ
žœŸ˜Nšžœ
žœ˜'Jšžœ	žœ
žœ!˜>Jšžœžœ˜4—Jšœžœ
˜šžœžœ
žœž˜ Jšžœ+žœ
žœžœ˜GJšžœ
˜—Jšžœžœ
žœ
˜J˜.J˜Jšžœžœ
žœ
˜Jšžœ
˜—Jš
œ!™!š
œ˜J˜——š œžœ
žœ™Jšœžœžœ™!Jšœžœ™—J˜Jš
œL™LJš
œ™š
œL™LJ˜Jš
œ-™-J˜Jšœ
ž	œ
˜Jšœžœžœ
˜J˜#J˜J˜Jšœžœ
žœ
˜Jšœžœ
žœ
˜#Jšœžœ
žœ
˜#J˜—šΟb
œžœ
žœ˜7J˜J˜Jšžœžœ
žœžœ
žœ
žœžœ˜HJš	žœžœ
žœžœŸ˜OJš
œ*˜*J˜4J˜4J˜'Jšžœžœ
žœ˜HJšžœžœžœ)˜ZJšœŸ9˜HJ˜!Jš
œ.˜.šžœ
ž˜Jšžœ7žœ	˜GJšœ*žœ˜D˜ J™AJ˜—Jšžœ˜—J˜Jšžœžœ˜Jš
œ˜J˜—š‘œžœ
žœ˜6Jš	žœžœ
žœžœŸ˜AJ˜Jšžœžœ
žœŸ˜;Jš
œ˜Jš
œC˜CJš
œD˜DJ˜VJ˜VJšžœžœ˜Jš
œ˜J˜—š 
œžœ˜Jšžœžœ
žœ
˜#J˜J˜Jš
œ˜J˜—Jš 	œžœ˜+J˜Jš
œE™EJš
œ™Jš
œE™EJ˜š
œ3™3J˜Jš	œžœ
žœ
žœžœ
˜8JšœžœŸ˜)Jšœ	žœžœŸ˜7Jšœ	žœžœ
˜Jšœžœ˜Jš	œ	žœžœ
žœ&žœ˜VJšœ
žœ˜Jšœžœ˜JšœžœŸ˜:J˜.JšœžœžœŸ³
˜Τ
J˜—š œžœ˜
J˜J˜J˜0š
œ˜Jšœžœžœ!žœ˜N—š
 
œžœžœžœžœ˜@Jšžœ
žœžœžœ˜=—š œžœžœ˜ Jšœžœžœ
˜J˜$Jš
œ"˜"Jš
œ˜Jšœžœ
žœ	˜2Jšœžœ
žœŸ˜Zšžœ'žœ
žœž˜IJš	œžœ
žœ
žœžœ
˜7J˜J˜(Jšžœžœ
žœžœ
žœ
žœžœ
˜EJšžœžœ
žœ
˜Jšžœžœ
žœ
˜"Jšžœžœ
žœ&žœ
žœŸ	˜QJš	œžœ
žœ
žœžœ˜PJš
œN™NJš
œT™TJš
œZ™ZJš
œR™RJš
œ™Jšœžœ
˜
šžœžœ
žœž˜#Jšžœžœžœ
žœ
˜#Jšžœ+žœ
žœ
˜7Jšœžœžœ
˜Jšžœ
˜—Jšžœžœ
žœ
˜Jš
œ™J˜.Jšžœžœ
˜—Jš
œ!˜!Jš
œ˜—J˜Jš
Ÿ˜šžœ
žœ˜"Jšžœ9žœ
˜EJš
œ*˜*Jšžœ
žœ
žœ
˜Jšžœžœ
žœ
˜!Jš
žœ	žœ
žœžœžœ
˜CJšžœ	žœ˜Jšžœžœžœ˜8šžœ
žœ
ž˜J˜!Jšœ-žœŸ
˜CJšœ/žœŸ
˜Ešœžœžœ˜:JšœžœŸ˜,—šœžœžœ˜<JšœžœŸ˜,—šœžœ
žœ˜(šžœ
žœ
ž˜šžœ=žœ
˜DJšœ.žœŸ
˜D—Jšœžœ žœŸ)˜eJšžœŸ˜#——JšžœžœŸ˜;—Jšžœ	žœ˜Jšžœ
˜—Jšœ
žœ
˜J˜J˜J˜0Jš
œ˜J˜—š œžœžœ
˜@Jšžœ
žœžœ˜J˜Jš
žœžœžœ
žœ
žœ˜9J˜šžœžœžœŸ˜Dšžœžœ
žœ˜7Jšžœ
žœ
žœ
žœ˜!J˜Jšžœ
žœ
žœ
žœ˜"—Jšžœ
˜—Jšžœ
žœŸ0˜>Jš
œ˜—J˜Jš
œE™EJš
œ™Jš
œE™E˜Jšœžœžœ
˜#Jš	œžœžœ
žœžœ˜6Jšœ
žœžœ
žœ
žœ
žœ
žœžœ
˜DJ˜—š œžœ˜Jš
œ™J˜Jšœžœ
˜Jšœ
žœ
˜Jš
œ˜J˜Jšœ!žœ
˜%Jš
œ6˜6šœžœ
žœ
žœ˜:J˜!—š	œžœ
žœ
žœ
ž	œ˜0Jšžœ˜—Jšœžœ
˜Jšœžœžœ
˜#Jš
œ™J˜šžœ˜Jš
œ™Jš
œ>˜>šžœ?ž˜FJšžœ
žœ
˜
—šžœ5žœŸ˜Jšžœ˜Jšžœ:žœ˜C˜%Jšœžœ˜——Jšžœ
žœ
žœ
˜JšžœŸ˜"—Jš
œ™JšœHŸ˜fJ˜7Jšœ
žœA˜Pšœžœ˜#Jšžœ&˜*Jšžœ˜—Jšœžœ,žœ˜Hšžœ
žœ
ž˜Jšžœ=˜@J˜PJšžœ ˜'—Jš
œ ™ Jš
œ"˜"šžœ.˜0JšžœžœŸ(˜GJšžœ&˜*—Jš
œ!˜!Jš
œ™Jšžœ
žœ
žœ
˜Jšžœžœžœžœ˜KJšœžœ˜!Jšžœ
˜—Jšœ
žœ
˜J˜J˜J˜0Jš
œ˜J˜—š
 œžœ&žœ
žœžœ˜KJš
œ0™0Jš
žœ
žœ"žœ
žœ
žœ˜BJšžœ
žœ˜Jš
œ˜J˜—š œžœžœ
žœ
žœ
ž	œžœ˜HJš
œZ™ZJšœžœ
žœ
žœ
žœ
žœ
˜AJš
œ"˜"šžœ
žœ	˜ Jšžœžœ#˜=JšžœK˜OJ˜——Jš
 œžœ
žœžœžœ˜=J˜Jš
œK™KJš
œ™Jš
œK™KJ˜J˜Jšœžœžœ
˜Jšœžœžœ
˜J˜š‘œžœ˜3Jš
œH™HJšœžœ
˜Jš
œ˜Jšœžœ
žœ
žœžœ
žœ
˜+Jšžœžœ
žœ
˜Jš
žœ
žœ
žœžœ
žœ
˜=Jšœžœžœ˜OJšžœžœ
žœžœ˜Bš
žœžœ
žœ
žœžœ˜3Jšœ
žœžœ˜>—š
žœžœ
žœ
žœžœ˜0Jšœ
žœžœ˜>—š
žœžœžœžœ
žœ˜6Jšžœ/˜3—˜Jšœžœ˜%Jš
œ˜Jš
œ
˜
Jš
œ˜—Jš
œ˜J˜—š‘	œžœžœ˜5Jšœžœ˜Jš
œ˜Jšžœžœ
žœžœ˜1Jšžœžœ
žœžœ˜:Jšžœžœ
žœžœžœ
žœ
žœ˜LJšœžœ,˜;Jšžœžœ˜Jš
œ˜J˜—š
 œžœ
žœ
žœ&žœ˜DJšœ#žœ	˜4J˜Jšœžœ
žœ
žœ˜'Jšžœžœ
žœ
˜#Jšžœ
žœ
žœ
˜šžœžœ
˜ Jšžœ
žœ0˜6šžœ
žœ2˜9Jšžœžœ
žœ
˜/Jšžœžœ
žœŸ˜L——Jšœžœ'˜1J˜šžœ	žœ
žœ
˜Jš	œžœžœ
žœžœ˜T—J˜)Jš
œ˜J˜—š œžœ
ž˜JšœNžœ˜[Jš
œ!™!Jšœ
žœžœ˜6J˜Jšœžœ
˜Jšœžœ˜š 
œžœžœ˜;Jš
œ™Jšžœ
˜Jš
œE™EJš
œN™Nš
žœžœžœ
žœ
žœžœ
ž˜MJšœžœ
žœ*ž™UJšœžœ
žœžœ
žœ
žœ˜O—Jšžœ	˜Jš
œ˜—Jšžœžœ
žœ
˜J˜J˜J˜J˜Jš	œžœ
žœžœžœ˜Qšžœžœ	žœ
ž˜/Jš
œ™Jš
œ&™&Jšžœžœžœ˜IJ˜)šžœžœ-˜>JšžœŸ˜2—J˜Jšœ&žœžœ˜?Jšžœ
˜—š
œ˜Jšœ)žœ˜/Jšœ
žœ˜—Jš
œ˜—J˜J˜
J˜J™Jš
œ˜J™Jš
œC™CJš
œ+™+Jš
œ,™,Jš
œ9™9™2J™Ν
JšœΟr%œ™@—J™—…—;p]Α