DIRECTORY
BootStartList USING [
EntryPointer, Enumerate, IndexToEntryPointer, IndexToSpaceEntryPointer, Proc],
DebuggerSwap USING [CallDebugger, WorryCallDebugger],
GermSwap USING [switches],
MPCodes USING [vmInitialized],
PrincOps USING [
AV, AVItem, FaultIndex, FrameHandle, LargeReturnSlot, NoTimeout, PDA, PsbHandle, PsbNull, qFrameFault, qPageFault, qWriteProtectFault, Queue, QueueEmpty, StateVector],
PrincOpsUtils USING
[DisableInterrupts, EnableInterrupts, FrameSize, Free, GetReturnFrame, LongEnter, LongExit, LongReEnter, LongWait, LowHalf, MyLocalFrame, PsbIndexToHandle, Requeue, SetReturnFrame],
Process USING [
Detach, DisableTimeout, priorityFaultHandlers, priorityForeground, SecondsToTicks, SetPriority, SetTimeout, Ticks, Yield],
ProcessorFace USING [SetMP],
VM USING [
AddressFault, AddressForPageNumber, Allocate, CantDoIO, DataState, Free, IOErrorType, Interval, PageCount, PageNumber, PageNumberForAddress, PagesForWords, PageState, State, SwapIn, WordsForPages, WriteProtectFault],
VMEmergency,
VMInternal USING [
AllocateRealMemoryForLocalFrames, AllocateVirtualMemoryInternal, allocationLock, AllocationOutcome, AnyFrameSizeIndex, FrameHeapPiece, FrameHeapPieceHeader, FsiFrame, GetVMMap, InOut, LargeFrame, LargeFrameHeader, largeFrameThresholdFsi, lastVMPage, NormalFrameSizeIndex],
VMSideDoor USING [rmPages],
VMStatistics USING [];

VMFaultsImpl: MONITOR
LOCKS monitor^ USING monitor: POINTER TO MONITORLOCK
IMPORTS
BootStartList, DebuggerSwap, GermSwap, PrincOpsUtils, Process, ProcessorFace, VM, VMEmergency, VMInternal, VMSideDoor
EXPORTS VMInternal, VMStatistics
= BEGIN OPEN PrincOps;


largeFramesLock: MONITORLOCK;

largeFramesInUse: CONDITION;
largeFrameTimeout: Process.Ticks = Process.SecondsToTicks[1];

lastFaultedPage: VM.PageNumber ;
ReadOnlyPageInSize: INT _ 4 ;
ReadWritePageInSize: INT _ 2 ;

pageFaults, writeFaults: PUBLIC INT _ 0;
frameFaults: PUBLIC INT _ 0;
smallFramesAllocated, frameHeapExtensions: PUBLIC INT _ 0;
largeFramesAllocated, largeFramesFreed: PUBLIC INT _ 0;

frameHeapPieceList: PUBLIC VMInternal.FrameHeapPiece _ NIL;
largeFrameList: PUBLIC VMInternal.LargeFrame _ NIL;  -- protected by largeFramesLock

PageFaultProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qPageFault];
faultedPage: VM.PageNumber =
VM.PageNumberForAddress[PDA[PDA[process].context.state].memPointer];
IF faultedPage <= 0 OR faultedPage > VMInternal.lastVMPage
THEN ReportFault[process, VM.AddressFault]
ELSE {
interval: VM.Interval = MapAddressToContainingInterval[faultedPage];
lastFaultedPage _ faultedPage ; -- save for debugging
VM.SwapIn[interval: interval, nextPage: GetNextPageHint[process]
! VM.AddressFault => {
IF faultedPage = VM.PageNumberForAddress[address]
THEN ReportFault[process, VM.AddressFault];
CONTINUE};
 VM.CantDoIO => { ReportCantDoIO[process, reason, page]; CONTINUE};
];
};
RestartFaultee[qPageFault, process];
--*stats*-- pageFaults _ pageFaults.SUCC;
ENDLOOP;
};

WriteProtectFaultProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qWriteProtectFault];
ReportFault[process, VM.WriteProtectFault];
RestartFaultee[qWriteProtectFault, process];
--*stats*-- writeFaults _ writeFaults.SUCC;
ENDLOOP;
};

frameAllocs: ARRAY VMInternal.NormalFrameSizeIndex OF INT _ ALL[0];  -- **temporary**

FrameFaultProcess: PROC = {
OPEN VMInternal;
Process.SetPriority[Process.priorityFaultHandlers];
DO
process: PsbHandle = WaitForFaultee[qFrameFault];
fsi: NormalFrameSizeIndex = PDA[PDA[process].context.state].fsi;
frSize: CARDINAL = PrincOpsUtils.FrameSize[fsi] + AnyFrameSizeIndex.SIZE;
newFrame: FrameHandle;  -- the frame we will allocate and paste into the AV.
IF fsi >= largeFrameThresholdFsi THEN {
pages: CARDINAL = VM.PagesForWords[frSize + LargeFrameHeader.SIZE];
largeFrame: LargeFrame = PageNumberToMDSAddress[AllocateForLocalFrames[pages].page];
largeFrame^ _ [next: NIL, prev: NIL, trueFsi: fsi, fsiFrame: NULL];
NotifyLargeFrame[largeFrame];
largeFrame.fsiFrame[0].fsi _ LargeReturnSlot;  -- (a fsi never generated by the compiler.)
newFrame _ @largeFrame.fsiFrame[0].frame;
--*stats*-- largeFramesAllocated _ largeFramesAllocated.SUCC;
}
ELSE {
piece: FrameHeapPiece _ frameHeapPieceList;
newFsiFrame: POINTER TO FsiFrame;  -- assert:  newFsiFrame MOD 4  = 3
IF piece ~= NIL AND piece.wordsInUse + frSize > piece.wordsAllocated THEN {
framePiecePages: VM.PageCount =
VM.PagesForWords[frSize + FrameHeapPieceHeader.SIZE];
framePieceWords: CARDINAL = VM.WordsForPages[framePiecePages];
minFrameSize: CARDINAL = PrincOpsUtils.FrameSize[0] + AnyFrameSizeIndex.SIZE;
wordsAvailable: CARDINAL;
trialFsi: NormalFrameSizeIndex _ fsi;
newFsiFrame _ @piece.fsiFrame[0] + piece.wordsInUse - FrameHeapPieceHeader.SIZE;
UNTIL (wordsAvailable _ piece.wordsAllocated - piece.wordsInUse) < minFrameSize DO
tFsiWords: CARDINAL =
PrincOpsUtils.FrameSize[trialFsi _ trialFsi.PRED] + AnyFrameSizeIndex.SIZE;
UNTIL wordsAvailable < tFsiWords DO
newFsiFrame.fsi _ trialFsi;
PrincOpsUtils.Free[@newFsiFrame.frame];  -- atomically paste onto frame heap.
newFsiFrame _ newFsiFrame + tFsiWords;
piece.wordsInUse _ piece.wordsInUse + tFsiWords;
wordsAvailable _ wordsAvailable - tFsiWords;
ENDLOOP;
ENDLOOP;
piece _ PageNumberToMDSAddress[AllocateForLocalFrames[framePiecePages].page];
piece^ _ [
next: frameHeapPieceList,
wordsAllocated: framePieceWords,
wordsInUse: FrameHeapPieceHeader.SIZE,
fsiFrame: NULL
];
frameHeapPieceList _ piece;
--*stats*-- frameHeapExtensions _ frameHeapExtensions.SUCC;
};
newFsiFrame _ @piece.fsiFrame[0] + piece.wordsInUse - FrameHeapPieceHeader.SIZE;
newFsiFrame.fsi _ fsi;
newFrame _ @newFsiFrame.frame;
piece.wordsInUse _ piece.wordsInUse + frSize;
--*stats*-- smallFramesAllocated _ smallFramesAllocated.SUCC;
};
PrincOpsUtils.DisableInterrupts[];
LOOPHOLE[newFrame, POINTER TO AVItem]^.link _ AV[fsi].link;
AV[fsi].frame _ newFrame;
--*temporary stats*-- frameAllocs[fsi] _ frameAllocs[fsi].SUCC;
PrincOpsUtils.EnableInterrupts[];
RestartFaultee[qFrameFault, process];
--*stats*-- frameFaults _ frameFaults.SUCC;
ENDLOOP;
};
FlushLargeFramesProcess: PROC = {
Process.SetPriority[Process.priorityFaultHandlers];
DO
largeFrame: VMInternal.LargeFrame = WaitForLargeFrame[];
VM.Free[
[page: VM.PageNumberForAddress[largeFrame],
count: VM.PagesForWords[PrincOpsUtils.FrameSize[largeFrame.trueFsi]]]];
--*stats*-- largeFramesFreed _ largeFramesFreed.SUCC;
ENDLOOP;
};


EmergencyRefillProcess: PROC = {
WaitForEmergency: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
WHILE lagChange = eList.change DO WAIT emergencyCond; ENDLOOP;
lagChange _ eList.change;
};
interval: VM.Interval = VM.Allocate[count: 1];
lagChange: INT _ -1;
eList: VMEmergency.EmergencyList = VM.AddressForPageNumber[interval.page];
eList.change _ 0;
eList.max _ 16;
eList.pages _ ALL[0];
Process.SetPriority[Process.priorityForeground];
VM.SwapIn[interval: interval, pin: TRUE];
VMEmergency.emergencyList _ eList;  -- install the emergency list
DO
WaitForEmergency[@emergencyLock];
lagChange _ eList.change;
FOR i: NAT IN [0..eList.max) DO
page: VM.PageNumber _ eList.pages[i];
IF page = 0 THEN {
page _ VM.Allocate[count: 1].page;
};
IF VMInternal.InOut[VMInternal.GetVMMap[page]] = out THEN {
eList.pages[i] _ 0;
VM.SwapIn[interval: [page, 1], pin: TRUE];
eList.pages[i] _ page;
emergencyCount _ emergencyCount + 1;
};
ENDLOOP;
ENDLOOP;
};

NoteEmergency: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
BROADCAST emergencyCond;
};

emergencyCond: CONDITION;
emergencyLock: MONITORLOCK;
emergencyCount: INT _ 0;

MapAddressToContainingInterval: PROC
[faultedPage: VM.PageNumber] RETURNS [VM.Interval] = {
firstPage: VM.PageNumber _ faultedPage ;
lastPage: VM.PageNumber _ firstPage ;
page:VM.PageNumber;
pageState: VM.PageState;
dataState: VM.DataState;
pageCount: INT _ 1 ;
maxSize: INT = MAX[ReadOnlyPageInSize, ReadWritePageInSize];
IF firstPage > VMInternal.lastVMPage THEN RETURN [[page: firstPage, count: 0]];
WHILE pageCount < maxSize AND lastPage < VMInternal.lastVMPage DO
page _ lastPage.SUCC;
pageState _ VM.State[page];
dataState _ pageState.dataState;
IF pageState.hasRealMemory OR dataState = none OR dataState = undefined OR (NOT pageState.readOnly AND (pageCount >= ReadWritePageInSize)) THEN EXIT ;
lastPage _ page ;
pageCount _ pageCount.SUCC;
ENDLOOP;
WHILE pageCount < maxSize AND firstPage > 0 DO
page _ firstPage.PRED;
pageState _ VM.State[page];
dataState _ pageState.dataState;
IF pageState.hasRealMemory OR dataState = none OR dataState = undefined OR (NOT pageState.readOnly AND (pageCount >= ReadWritePageInSize)) THEN EXIT ;
firstPage _ page ;
pageCount _ pageCount.SUCC;
ENDLOOP;
RETURN[[page: firstPage, count: pageCount]]
};

GetNextPageHint: PROC [process: PsbHandle] RETURNS [VM.PageNumber] = INLINE {
nextProcess: PsbHandle = PrincOpsUtils.PsbIndexToHandle[PDA[process].link.next];
RETURN[
IF nextProcess = process THEN 0
ELSE VM.PageNumberForAddress[PDA[PDA[nextProcess].context.state].memPointer]]
};

ReportFault: PROC [psb: PsbHandle, error: ERROR [LONG POINTER]] = {
Return: PROC _ LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];
state: StateVector = PDA[PDA[psb].context.state];
address: LONG POINTER = state.memPointer;  -- for easy inspection from the debugger.
PDA[PDA[psb].context.state].stkptr _ PDA[PDA[psb].context.state].instbyte _ 0;
PrincOpsUtils.SetReturnFrame[state.frame];
PDA[PDA[psb].context.state].frame _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
Return[];
IF PDA[psb].flags.cleanup ~= PsbNull THEN
DebuggerSwap.WorryCallDebugger["Address fault with dirty cleanup link (see a wizard)"L];
ERROR error[state.memPointer];
};

ReportCantDoIO: PROC [psb: PsbHandle, reason: VM.IOErrorType, page: VM.PageNumber] = {
Return: PROC _ LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];
state: StateVector = PDA[PDA[psb].context.state];
address: LONG POINTER = state.memPointer;  -- for easy inspection from the debugger.
PDA[PDA[psb].context.state].stkptr _ PDA[PDA[psb].context.state].instbyte _ 0;
PrincOpsUtils.SetReturnFrame[state.frame];
PDA[PDA[psb].context.state].frame _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
Return[];
IF PDA[psb].flags.cleanup ~= PsbNull THEN
DebuggerSwap.WorryCallDebugger["Address fault with dirty cleanup link (see a wizard)"L];
ERROR VM.CantDoIO[reason, page];
};

WaitForFaultee: PROC [q: FaultIndex] RETURNS [psb: PsbHandle] = INLINE {
lock: MONITORLOCK;
pCondition: LONG POINTER TO CONDITION = LOOPHOLE[@PDA.fault[q].condition];
--Temp kludge to allow Laundry to get in: -- Process.Yield[]; -- (ADB)
UNTIL PrincOpsUtils.LongEnter[@lock] DO ENDLOOP;
WHILE PDA.fault[q].queue = QueueEmpty DO
PrincOpsUtils.LongWait[@lock, pCondition, NoTimeout];
UNTIL PrincOpsUtils.LongReEnter[@lock, pCondition] DO ENDLOOP;
ENDLOOP;
psb _ PrincOpsUtils.PsbIndexToHandle[PDA.block[PDA.fault[q].queue.tail].link.next];
PrincOpsUtils.LongExit[@lock];
};
RestartFaultee: PROC [q: FaultIndex, psb: PsbHandle] = INLINE {
PrincOpsUtils.Requeue[@PDA.fault[q].queue, @PDA.ready, psb];
};
WaitForLargeFrame: PROC RETURNS [largeFrame: VMInternal.LargeFrame] = INLINE {
WaitForLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
OPEN VMInternal;
DO
IF AV[LargeReturnSlot].tag = frame THEN EXIT;
IF largeFrameList = NIL THEN Process.DisableTimeout[@largeFramesInUse]
ELSE Process.SetTimeout[@largeFramesInUse, largeFrameTimeout];
WAIT largeFramesInUse;
ENDLOOP;
PrincOpsUtils.DisableInterrupts[];  -- prevent AV manipulation
largeFrame _ LOOPHOLE[
AV[LargeReturnSlot].frame - LargeFrameHeader.SIZE - AnyFrameSizeIndex.SIZE];
AV[LargeReturnSlot].link _ AV[LargeReturnSlot].link^.link;
PrincOpsUtils.EnableInterrupts[];  -- AV is now consistent
IF largeFrame = largeFrameList THEN
IF (largeFrameList _ largeFrame.next) ~= NIL THEN largeFrameList.prev _ NIL ELSE NULL
ELSE
IF (largeFrame.prev.next _ largeFrame.next) ~= NIL THEN
largeFrame.next.prev _ largeFrame.prev;
};
WaitForLargeFrameEntry[@largeFramesLock];
};

NotifyLargeFrame: PROC [largeFrame: VMInternal.LargeFrame] = INLINE {
NotifyLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {
largeFrame.next _ largeFrameList;
IF largeFrameList ~= NIL THEN largeFrameList.prev _ largeFrame;
largeFrameList _ largeFrame;
Process.SetTimeout[@largeFramesInUse, largeFrameTimeout];  -- OK because it's INLINE
NOTIFY largeFramesInUse;
};
NotifyLargeFrameEntry[@largeFramesLock];
};
AllocateForLocalFrames: PROC [count: VM.PageCount]
RETURNS [interval: VM.Interval] = INLINE {
outcome: VMInternal.AllocationOutcome;
AllocateForLocalFramesEntry: ENTRY PROC
[monitor: POINTER TO MONITORLOCK] = INLINE {
[outcome, interval] _ VMInternal.AllocateVirtualMemoryInternal[count, $mds];
};
AllocateForLocalFramesEntry[@VMInternal.allocationLock];
IF outcome ~= ok THEN DebuggerSwap.WorryCallDebugger["No VM for frame heap"L];
FOR page: VM.PageNumber IN [interval.page..interval.page+interval.count) DO
VMInternal.AllocateRealMemoryForLocalFrames[page];
ENDLOOP;
NoteEmergency[@emergencyLock];
};

PageNumberToMDSAddress: PROC
[page: VM.PageNumber] RETURNS [address: POINTER] = INLINE {
RETURN[PrincOpsUtils.LowHalf[VM.AddressForPageNumber[page]]]
};


Initialize: PROC = {
myFramePage: VM.PageNumber = VM.PageNumberForAddress[PrincOpsUtils.MyLocalFrame[]];
FindOriginalFrameHeap: BootStartList.Proc = {
OPEN BootStartList;
entry: EntryPointer = IndexToEntryPointer[index];
WITH e: entry SELECT FROM
space => NULL;
swapUnit => {
suPage: VM.PageNumber = IndexToSpaceEntryPointer[e.parent].vmPage + e.base;
IF myFramePage IN [suPage..suPage + e.pages) THEN {
frameHeapPieceList _ PageNumberToMDSAddress[suPage];
RETURN[TRUE]
};
};
ENDCASE;
};
PDA.fault[qFrameFault] _ PDA.fault[qPageFault] _ PDA.fault[qWriteProtectFault] _
[queue: QueueEmpty, condition: [tail: PsbNull, abortable: FALSE, wakeup: FALSE]];
Process.Detach[FORK PageFaultProcess];
Process.Detach[FORK WriteProtectFaultProcess];
BootStartList.Enumerate[FindOriginalFrameHeap];
Process.Detach[FORK FrameFaultProcess];
Process.DisableTimeout[@largeFramesInUse];
Process.Detach[FORK FlushLargeFramesProcess];
Process.Detach[FORK EmergencyRefillProcess];
SELECT VMSideDoor.rmPages FROM
IN [0 .. 3100] => {ReadOnlyPageInSize _ 2; ReadWritePageInSize _ 1};
IN (3100 .. 6200] => {ReadOnlyPageInSize _ 4; ReadWritePageInSize _ 2};
> 6200 => {ReadOnlyPageInSize _ 7; ReadWritePageInSize _ 4};
ENDCASE;
};

Initialize[];
IF GermSwap.switches[two] THEN DebuggerSwap.CallDebugger["Key stop 2 (VM)"];
ProcessorFace.SetMP[MPCodes.vmInitialized];

END.


(VMFaultsImpl.mesa
Levin on November 15, 1983 1:46 pm
Birrell, April 25, 1983 1:54 pm
Bob Hagmann, May 4, 1984 10:36:53 am PDT
Russ Atkinson, May 24, 1984 2:25:48 pm PDT

Global Variables

Some VM tuning parameters.
The desired size of the interval to swapin around a faulted page.  A size of 1 means only swapin the faulted page.  Sizes are set independantly by type of page faulted: readOnly pages (code) and readWrite pages (data).  By convention ReadOnlyPageInSize >= ReadWritePageInSize.  The values of these entries can be changed during initialization.


Exports to VMStatistics

Exports to VMInternal

Fault-Handling Processes
Reserve a state vector for this process
Reserve a state vector for this process
Reserve a state vector for this process.
We will allocate a large frame (i.e., an integral number of pages).
We will allocate a small frame, which may or may not require extension of the heap.
Assert: frSize MOD 4 = 0.
The remaining space in the most recent extension piece is insufficient for the faultee.  We subdivide the available space into the smallest set of frames that will exhaust (or nearly exhaust) it.
We now allocate a new piece from which to build frames.
Fabricate a new frame
Atomically chain the new frame onto the AV:
Note that we can not do a Frame.Free[] here because large frames
have an fsi different than that of the AV slot we put them in.
Restart faulted process:

This process can run at any priority and without a reserved state vector.
Emergency frame stuff
This process refills the emergency page list used by frame allocation when there are no available clean pages. We give this a foreground priority to try to stay ahead of greedy processes.
This page needs a new allocation
The page needs to have real memory pinned beneath it for the use of the frame allocator.  We temporarily remove it from the emergency list to keep from being found in an unhappy state.

Internal Procedures
If the successor of "process" on the queue differs from "process", we extract the page number on which it has faulted.  Note that another process may come along and be inserted between the two, but this is unlikely and we're only looking for a hint to optimize disk arm motion.
Splice me in as top-of-stack of psb.
Return to caller without disturbing this frame.
Control returns here in the context of the faulting process.  If it has
a dirty cleanup link, disaster may ensue if a signal is raised, since it is
almost certain to be uncaught and the AMEvents stuff will doubtless do a WAIT.
If someone caught it and did a wait, similar bad things would happen.  So, we
call the world-swap debugger instead.
Splice me in as top-of-stack of psb.
Return to caller without disturbing this frame.
Control returns here in the context of the faulting process.  If it has
a dirty cleanup link, disaster may ensue if a signal is raised, since it is
almost certain to be uncaught and the AMEvents stuff will doubtless do a WAIT.
If someone caught it and did a wait, similar bad things would happen.  So, we
call the world-swap debugger instead.
Implementation note:  The explicit use of PrincOpsUtils to invoke monitor instructions is required because FaultQueues do not have full CONDITION variables in them.  Rather, they have only the Queue portion; there is no timeout field.  Since the generated code for WAIT assumes a timeout word follows the Queue, the language construct can't be used.  Of course, the use of monitor locks is really unnecessary anyway, since there is only a single process doing waits and the condition variable is notified by microcode with a naked notify.  However, it is the easiest way to achieve the desired effect.


Note:  AV[LargeReturnSlot] can go from non-empty to empty only as a result of this procedure.  Therefore, the test of AV[LargeReturnSlot] need not be made with interrupts disabled.
The following are legal only because they are INLINEs.
head of large frame list is being freed.

This is a specialized procedure for use by the frame fault handler.  It is semantically equivalent to {interval _ Allocate[count, mds]; SwapIn[interval, kill: TRUE, pin: TRUE]}, but must be implemented carefully because of the delicate state of the world at the time it is invoked.
The following is actually a coroutine call (to avoid frame allocation).
The following is actually a coroutine call (to avoid frame allocation).
Initialization
ΚΠ–

"Cedar" style˜š
œ™Jš
œ"™"J™J™(J™*—J˜š
Οk	˜	šœœ˜Jš
œN˜N—Jšœ
œ#˜5Jšœ	œ˜Jšœœ˜šœ	œ˜JšœAœc˜§
—šœ˜Jš
œ΅
˜΅
—šœœ˜Jš
œz˜z—Jšœœ	˜šœ
œ˜
Jš
œΨ
˜Ψ
—J˜šœœ˜Jš
œ˜—Jšœœ˜Jšœ
œ˜J˜—šœ˜Jš	œ
œ
œ
œ
˜4š
˜JšœNœ%˜u—Jšœ˜ Jšœ
œ
˜—J˜J™™J˜Jšœœ
˜J˜Jšœ	œ
˜J˜=J˜Jšœœ
˜ J™—š
œς™ςJ™Jšœœ˜Jšœœ˜J™—™J˜Jšœœ
œ˜(Jšœ
œ
œ˜Jšœ+œ
œ˜:Jšœ(œ
œ˜7J™—™J˜Jšœœœ
˜;JšœœœΟc˜TJ™—™J˜šΟnœœ˜Jš
œ'™'J˜3š
˜Jš
œ0˜0šœ
œ
˜Jšœœ
œ%˜D—šœœ$˜:Jšœœ˜*šœ˜Jšœ
œ8˜DJšœ ž˜5šœ>˜@šœœ˜šœœ˜1Jšœœ˜+—Jšœ˜
—Jšœ
œ6œ˜CJ˜—J˜——Jš
œ$˜$Jšžœœ
˜)Jšœ
˜—J˜—J˜šŸœœ˜"Jš
œ'™'J˜3š
˜Jš
œ8˜8Jšœœ˜+Jš
œ,˜,Jšžœœ
˜+Jšœ
˜—J˜—J˜Jš
œ
œ!œ
œœž˜UJ˜šŸœœ˜Jš
œ(™(Jšœ˜J˜3š
˜Jš
œ1˜1Jšœœ
œ˜@Jšœœ4œ
˜IJšœž4˜Lšœœ˜'Jš
œC™CJšœœœ)œ˜CJš
œT˜TJšœœœœ˜CJš
œ˜Jšœ/ž+˜ZJš
œ)˜)Jšžœ-œ
˜=Jš
œ
˜
—šœ˜Jš
œS™SJšœœ™Jš
œ+˜+Jšœ
œ
œž"˜Ešœ
œ
œ2œ˜KJš
œΓ
™Γ
šœœ˜Jšœ-œ˜5—Jšœœœ ˜>Jšœœ2œ
˜MJšœœ
˜Jš
œ%˜%JšœKœ
˜PšœK˜Ršœœ˜Jšœ,œœ
˜K—šœ˜#Jš
œ˜Jšœ)ž$˜MJš
œ&˜&Jš
œ0˜0Jš
œ,˜,Jšœ
˜—Jšœ
˜—Jš
œ7™7Jšœ
œE˜Mš
œ
˜
Jš
œ˜Jš
œ ˜ Jšœ!œ
˜&Jšœ
˜Jš
œ˜—Jš
œ˜Jšžœ+œ
˜;Jš
œ˜—Jš
œ™JšœKœ
˜PJ˜J˜Jš
œ-˜-Jšžœ-œ
˜=Jš
œ˜—Jš
œ+™+Jš
œ@™@Jš
œ>™>Jš
œ"˜"Jšœœ
œœ˜;Jšœ˜Jšžœ%œ
˜?J˜!Jš
œ™J˜%Jšžœœ
˜+Jšœ
˜—J˜—J™šŸœœ˜!Jš
œI™IJš
œ3˜3š
˜Jš
œ8˜8šœ˜Jšœœ"˜+Jšœœ>˜G—Jšžœ%œ
˜5Jšœ
˜—J˜J˜——š
œ™J˜šŸœœ˜ Jš
œ»
™»
šŸœœ
œœ
œ
œœ˜IJšœœ
œœ
˜>Jš
œ˜J˜—Jšœ
œœ˜.Jšœœ˜Jšœ#œ%˜JJš
œ˜Jš
œ˜Jšœœ˜Jš
œ0˜0Jšœ!œ˜)Jšœ$ž˜Aš
˜Jš
œ!˜!Jš
œ˜šœœ
œ˜Jšœœ˜%šœ
œ˜Jš
œ ™ Jšœœ˜"J˜—šœ3œ˜;Jš
œΈ
™Έ
Jš
œ˜Jšœ"œ˜*Jš
œ˜Jš
œ$˜$J˜—Jšœ
˜—Jšœ
˜—J˜J˜—šŸ
œœ
œœ
œ
œœ˜FJš	œ˜J˜J˜—Jšœ	œ
˜Jšœœ
˜Jšœœ˜J™—š
œ™J˜šŸœ˜$Jšœœ
œœ˜6Jšœœ˜(Jšœ
œ˜%Jšœœ˜Jšœœ˜Jšœœ˜Jšœœ˜Jšœ	œœ*˜<Jšœ#œ
œ˜Ošœœ"˜AJšœœ
˜Jšœœ
˜Jš
œ ˜ Jšœœœœœœ%œ
œ˜–
Jš
œ˜Jšœœ
˜Jšœ
˜—šœœ˜.Jšœœ
˜Jšœœ
˜Jš
œ ˜ Jšœœœœœœ%œ
œ˜–
Jš
œ˜Jšœœ
˜Jšœ
˜—Jšœ%˜+Jš
œ˜J˜—š
Ÿœœœœœ˜MJš
œ•™•Jšœ8œ˜Pšœ
˜Jšœœ˜Jšœ
œœ
œ)˜M—Jš
œ˜J˜—š
Ÿœœœœ
œ˜CJšŸœœœ!˜8Jšœœ
œ˜1Jšœ	œ
œž)˜TJš
œ$™$Jšœ
œœ
œ"˜NJš
œ*˜*Jšœ
œœ˜KJš
œ/™/J˜	Jš
œG™GJš
œK™KJš
œN™NJš
œM™MJš
œ%™%šœ
œ˜)Jš
œX˜X—Jšœ˜J˜—J˜šŸœœœœ˜VJšŸœœœ!˜8Jšœœ
œ˜1Jšœ	œ
œž)˜TJš
œ$™$Jšœ
œœ
œ"˜NJš
œ*˜*Jšœ
œœ˜KJš
œ/™/J˜	Jš
œG™GJš
œK™KJš
œN™NJš
œM™MJš
œ%™%šœ
œ˜)Jš
œX˜X—Jšœ˜ J˜J˜—šŸœœœœ˜HJš
œΩ™ΩJšœœ
˜Jš
œœ
œ
œ
	œœœ˜JJšž,œž˜FJšœ œ
œ
˜0šœ
œ˜(Jš
œ5˜5Jšœ.œ
œ
˜>Jšœ
˜—Jšœ%œœ!˜SJš
œ˜J˜—J™šŸœœ#œ˜?Jšœœœ
˜<J˜—J™šŸœœ
œ'œ˜NšŸœœ
œœ
œ
œœ˜OJš
œ΄
™΄
Jšœ˜š
˜Jšœ
œœ
œ
˜-Jš
œ6™6Jšœœ
œ*˜FJšœ:˜>Jšœ˜Jšœ
˜—Jšœ$ž˜>šœ
œ
˜Jšœ+œœ˜L—Jšœœ˜:Jšœ#ž˜:šœ˜#Jš
œ(™(Jšœ'œ
œ
˜U—š
˜šœ-œ
˜7J˜'——J˜—Jš
œ)˜)J˜—J˜šŸœœ'œ˜EšŸœœ
œœ
œ
œœ˜NJš
œ!˜!Jšœœ
œ"˜?Jš
œ˜Jšœ;ž˜TJšœ˜J˜—Jš
œ(˜(J˜—J™šŸœœ	œ˜2Jšœœ
œ˜*J™™Jš
œ&˜&šŸœœ
˜'Jš	œ
œ
œ
œœ˜,Jš
œG™GJš
œL˜LJ˜—Jš
œ8˜8Jšœœ9˜Nšœœœ/˜KJš
œG™GJš
œ2˜2Jšœ
˜—Jš
œ˜J˜—J˜šŸœ˜Jš	œœ
œœœ˜;Jšœœ˜<J˜J˜——š
œ™J˜šŸ
œœ˜Jšœ
œœ4˜S˜-Jšœ˜J˜1šœ
œ
˜Jšœ	œ
˜š
œ
˜
Jšœœ7œ˜Kšœ
œœ˜3Jš
œ4˜4Jšœ
œ
˜Jš
œ˜—J˜—Jšœ
˜—Jš
œ˜—šœœœ˜PJšœ:œ
œ˜Q—Jšœœ˜&Jšœœ˜.J˜/Jšœœ˜'J˜*Jšœœ˜-Jšœœ˜,šœ˜JšœB˜DJšœE˜GJš
œ<˜<Jšœ
˜—Jš
œ˜—J˜J˜
Jšœœ.˜LJ˜+J˜—Jšœ
˜J˜J˜—…—8’Zš