DIRECTORY
BootFileChanges USING [PageStateFromFlags, PageValue],
PrincOps USING [flagsDirty, flagsVacant, PageFlags, PageState],
PrincOpsUtils USING [DisableInterrupts, EnableInterrupts],
VM USING [nullInterval],
VMInternal USING [
AddToFreeList, AgeInternal, AllocateRealMemoryInternal, checkIn, cleaningRover, CleanOutcome, Crash, GetVMMap, InOut, Interval, lastRealPage, LaundryMode, maxPinCount, Outcome, PageCount, PageNumber, RealPageNumber, RMEntryPointer, rmMap, RMMapEntry, SetVMMap, SwapInOutcome, Victim, VMMapEntry, vmStateLock],
VMStatistics USING [
checkoutConflicts, pinnedPages, rmCleanPasses, trappedPages];

VMSwapImpl: MONITOR LOCKS VMInternal.vmStateLock
IMPORTS BootFileChanges, PrincOpsUtils, VMInternal, VMStatistics
EXPORTS VMInternal
SHARES VMInternal =
BEGIN OPEN VMInternal, VMStatistics;


AllocateForSwapIn: PUBLIC ENTRY PROC
[vmPage: PageNumber, kill, pin: BOOL, dontWait: BOOL]
RETURNS [outcome: SwapInOutcome, victim: Victim] = {
vmEntry: VMMapEntry;
success: BOOL;
[vmEntry, success] _ GetCheckedInVMMap[vmPage, dontWait];
IF ~success THEN RETURN [outcome: couldntCheckOut, victim: NULL];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => {
IF vmE.dataState = none THEN RETURN [outcome: addressFault, victim: NULL];
IF kill THEN
IF vmE.readOnly THEN RETURN [outcome: writeFault, victim: NULL]
ELSE vmE.dataState _ undefined;
outcome _ IF vmE.dataState = undefined THEN noReadNecessary ELSE needsRead;
vmE.checkedOut _ TRUE;
SetVMMap[vmPage, vmE];
victim _ AllocateRealMemoryInternal[vmPage: vmPage, pin: pin];
};
in => {
rmE: RMEntryPointer = @rmMap[vmE.real];
outcome _ alreadyIn;
IF kill THEN {
IF vmE.state.flags.readonly THEN RETURN [outcome: writeFault, victim: NULL];
vmE.state.flags.dirty _ rmE.needsBackingStoreWrite _ FALSE;
SetVMMap[vmPage, vmE];
rmE.dataState _ undefined;
};
IF pin THEN {
WITH rmE: rmE SELECT FROM
free => Crash[];
reclaimable => {
rmMap[vmE.real].body _ pinned[pinCount: 1];
--*stats*-- pinnedPages _ pinnedPages.SUCC;
};
pinned =>
IF rmE.pinCount < maxPinCount THEN rmE.pinCount _ rmE.pinCount + 1
ELSE Crash[];
ENDCASE;
};
};
ENDCASE;
};

SwapInDone: PUBLIC ENTRY PROC [vmPage, bufferPage: PageNumber, worked: BOOL] = {
vmEntry: VMMapEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => {
bufferEntry: VMMapEntry _ GetVMMap[bufferPage];
WITH bE: bufferEntry SELECT InOut[bufferEntry] FROM
in => {
rmE: RMEntryPointer = @rmMap[bE.real];
IF worked THEN {
--*stats*--
SELECT rmE.rmState FROM
free => Crash[];
pinned => pinnedPages _ pinnedPages.SUCC;
reclaimable => NULL;
ENDCASE;
bE.state _ BootFileChanges.PageStateFromFlags[
[readonly: vmE.readOnly, dirty: FALSE, referenced: TRUE]];
SetVMMap[vmPage, bE];
}
ELSE {
IF rmE.rmState = free THEN Crash[];
AddToFreeList[bE.real];
vmE.checkedOut _ FALSE;
SetVMMap[vmPage, vmEntry];
};
BROADCAST checkIn;
vmE.checkedOut _ vmE.readOnly _ FALSE;
vmE.dataState _ undefined;
SetVMMap[bufferPage, vmE];
};
out => Crash[];
ENDCASE;
};
in => Crash[];
ENDCASE;
};

SwapInDoneWithoutIO: PUBLIC ENTRY PROC [vmPage: PageNumber, victim: Victim] = {
vmEntry: VMMapEntry = GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => {
SetVMMap[vmPage, [
state: BootFileChanges.PageStateFromFlags[
[readonly: vmE.readOnly, dirty: FALSE, referenced: TRUE]],
body: in[victim.realPage]
]];
BROADCAST checkIn;
--*stats*--
SELECT rmMap[victim.realPage].rmState FROM
free => Crash[];
pinned => pinnedPages _ pinnedPages.SUCC;
reclaimable => NULL;
ENDCASE;
};
in => Crash[];
ENDCASE;
};

VictimWriteDone: PUBLIC ENTRY PROC [
vmPage, bufferPage: PageNumber, victim: dirty Victim, worked: BOOL] = {
vmEntry: VMMapEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => {
IF ~worked THEN {
victimEntry: VMMapEntry = [
state: BootFileChanges.PageStateFromFlags[PrincOps.flagsDirty],
body: in[victim.realPage]];
rmE: RMEntryPointer = @rmMap[victim.realPage];
IF rmE.rmState = free THEN Crash[];
rmE^ _ [
dataState: vmE.dataState, needsBackingStoreWrite: TRUE,
body: pinned[pinReason: cantBeWritten, pinCount: 1]];
SetVMMap[victim.vmPage, victimEntry];
--*stats*-- pinnedPages _ pinnedPages.SUCC;
--*stats*-- trappedPages _ trappedPages.SUCC;
vmE.checkedOut _ FALSE;
SetVMMap[vmPage, vmE];
BROADCAST checkIn;
};
vmE.readOnly _ vmE.checkedOut _ FALSE;
vmE.dataState _ undefined;
SetVMMap[bufferPage, vmE];
};
in => Crash[];
ENDCASE;
};

ConsiderCleaning: PUBLIC ENTRY PROC [vmPage: PageNumber, checkOutClean: BOOL]
RETURNS [outcome: CleanOutcome, real: RealPageNumber] = {
vmEntry: VMMapEntry;
PrincOpsUtils.DisableInterrupts[];
vmEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => outcome _ IF vmE.dataState = none THEN addressFault ELSE cantWrite;
in => {
rmE: RMEntryPointer = @rmMap[real _ vmE.real];
WITH rmE: rmE SELECT FROM
free => Crash[];
reclaimable => {
dirty: BOOL = vmE.state.flags.dirty OR rmE.needsBackingStoreWrite;
IF dirty OR checkOutClean THEN {
newEntry: VMMapEntry = [
state: BootFileChanges.PageStateFromFlags[PrincOps.flagsVacant],
body: out[
checkedOut: TRUE,
readOnly: vmE.state.flags.readonly,
dataState: IF vmE.state.flags.dirty THEN changed ELSE rmE.dataState
]];
rmE.referenced _ vmE.state.flags.referenced;  -- save until CleanDone
SetVMMap[vmPage, newEntry];
};
outcome _
SELECT TRUE FROM
dirty => needsWrite,
checkOutClean => checkedOutClean,
ENDCASE => cantWrite;
};
pinned => outcome _ cantWrite;
ENDCASE;
};
ENDCASE;
PrincOpsUtils.EnableInterrupts[];
};

CleanDone: PUBLIC ENTRY PROC [vmPage, bufferPage: PageNumber, worked: BOOL] = {
vmEntry: VMMapEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => {
bufferEntry: VMMapEntry _ GetVMMap[bufferPage];
WITH bE: bufferEntry SELECT InOut[bufferEntry] FROM
in => {
rmEntry: RMEntryPointer = @rmMap[bE.real];
WITH rmE: rmEntry SELECT FROM
reclaimable => {
newEntry: VMMapEntry = [
state: BootFileChanges.PageStateFromFlags[
[readonly: vmE.readOnly, dirty: FALSE, referenced: rmE.referenced]],
body: in[real: bE.real]
];
IF rmE.virtual ~= vmPage THEN Crash[];
IF worked THEN {
rmE.dataState _ vmE.dataState;  -- computed by ConsiderCleaning
rmE.needsBackingStoreWrite _ FALSE;
}
ELSE {
rmEntry^ _ [
dataState: vmE.dataState, needsBackingStoreWrite: TRUE,
body: pinned[pinReason: cantBeWritten, pinCount: 1]];
--*stats*-- pinnedPages _ pinnedPages.SUCC;
--*stats*-- trappedPages _ trappedPages.SUCC;
};
SetVMMap[vmPage, newEntry];
BROADCAST checkIn;
};
free, pinned => Crash[];
ENDCASE;
};
out => Crash[];
ENDCASE;
vmE.checkedOut _ FALSE;
vmE.dataState _ undefined;
SetVMMap[bufferPage, vmE];
};
in => Crash[];
ENDCASE;
};



Age: PUBLIC ENTRY PROC [vmPage: PageNumber] RETURNS [outcome: Outcome _ ok] = {
vmEntry: VMMapEntry;
PrincOpsUtils.DisableInterrupts[];
vmEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
out => IF vmE.dataState = none THEN outcome _ addressFault;
in => AgeInternal[vmPage, vmE];
ENDCASE;
PrincOpsUtils.EnableInterrupts[];
};

GetCleaningCandidate: PUBLIC ENTRY PROC [
desired: PageCount, comfortLevel: PageCount, tryHard: LaundryMode]
RETURNS [interval: Interval _ VM.nullInterval, cleanSkipped: PageCount _ 0,
passes: INT, rover: RealPageNumber] = {
firstPass: BOOL _ TRUE;
ExpandAroundVP: PROC [vP: PageNumber] RETURNS [interval: Interval] = INLINE {
lowerLimit: PageNumber = (IF vP < desired THEN 0 ELSE vP - desired).SUCC;
p: PageNumber _ vP;
interval.page _ vP;
UNTIL interval.page = lowerLimit DO
vmPage: PageNumber = interval.page.PRED;
vmEntry: VMMapEntry = GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
in =>
WITH rmMap[vmE.real] SELECT FROM
rmE: reclaimable RMMapEntry =>
IF rmE.virtual ~= vmPage OR  -- in swap buffer
~(vmE.state.flags.dirty OR rmE.needsBackingStoreWrite) OR
(vmE.state.flags.referenced AND tryHard = casual AND (vP-vmPage >  5)) THEN EXIT;
rmE: pinned RMMapEntry => EXIT;
rmE: free RMMapEntry => Crash[];
ENDCASE;
out => EXIT;
ENDCASE;
interval.page _ vmPage;
ENDLOOP;
UNTIL (p - interval.page).SUCC = desired OR p = lastRealPage DO
vmPage: PageNumber = p.SUCC;
vmEntry: VMMapEntry = GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
in =>
WITH rmMap[vmE.real] SELECT FROM
rmE: reclaimable RMMapEntry =>
IF rmE.virtual ~= vmPage OR  -- in swap buffer
~(vmE.state.flags.dirty OR rmE.needsBackingStoreWrite) OR
(vmE.state.flags.referenced AND tryHard = casual AND (vP-vmPage >  5)) THEN EXIT;
rmE: pinned RMMapEntry => EXIT;
rmE: free RMMapEntry => Crash[];
ENDCASE;
out => EXIT;
ENDCASE;
p _ vmPage;
ENDLOOP;
interval.count _ (p - interval.page).SUCC;
};
cleanPages: PageCount _ 0;
current: RealPageNumber _ cleaningRover;
recentDirtyFound: BOOL _ FALSE;
DO
IF current = RealPageNumber.FIRST THEN {
current _ lastRealPage;
--*stats*-- rmCleanPasses _ rmCleanPasses.SUCC;
}
ELSE current _ current.PRED;
SELECT TRUE FROM
current = cleaningRover =>
IF firstPass AND recentDirtyFound AND tryHard # casual THEN {
firstPass _ FALSE;
cleanPages _ 0;
}
ELSE EXIT;
tryHard = casual AND cleanPages >= comfortLevel => {
cleanSkipped _ cleanPages;
EXIT;
};
ENDCASE;
WITH rmMap[current] SELECT FROM
rmE: reclaimable RMMapEntry => {
vP: PageNumber = rmE.virtual;
vmEntry: VMMapEntry = GetVMMap[vP];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
in => {
refed: BOOL = vmE.state.flags.referenced;
dirty: BOOL = vmE.state.flags.dirty OR rmE.needsBackingStoreWrite;
IF vmE.real ~= current THEN Crash[];
IF dirty THEN
IF refed AND firstPass THEN recentDirtyFound _ TRUE
ELSE {interval _ ExpandAroundVP[vP]; cleanSkipped _ cleanPages; EXIT}
ELSE cleanPages _ cleanPages.SUCC;
};
out => NULL;  -- probably being swapped in
ENDCASE;
};
ENDCASE => NULL;
ENDLOOP;
cleaningRover _ current;
passes _ rmCleanPasses;
rover _ cleaningRover;
};


GetCheckedInVMMap: INTERNAL PROC [vmPage: PageNumber, dontWait: BOOL _ FALSE]
RETURNS [vmEntry: VMMapEntry, success: BOOL _ TRUE] = INLINE {
firstTime: BOOL _ TRUE;
DO
vmEntry _ GetVMMap[vmPage];
WITH vmE: vmEntry SELECT InOut[vmEntry] FROM
in => EXIT;
out =>
IF ~vmE.checkedOut OR vmE.dataState = none THEN EXIT;
ENDCASE;
IF dontWait THEN {success_ FALSE; EXIT};
IF firstTime THEN {checkoutConflicts _ checkoutConflicts.SUCC; firstTime _ FALSE};
WAIT checkIn;
ENDLOOP;
};

END.





DVMSwapImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Russ Atkinson, June 8, 1984 6:46:56 pm PDT
Bob Hagmann, May 4, 1984 1:32:54 pm PDT

Utilities for VM.SwapIn and VM.Clean
This is a specialized procedure for VM.SwapIn.
Note: the rmMap entry has now been updated for eventual association (by SwapInDone) with vmPage.
Strictly speaking, we should disable interrupts, reread the map, clear the dirty bit, and set the map before enabling interrupts.  This will avoid losing the referenced bit.  However, since the page is being killed, the referenced bit isn't very interesting now anyway.
This is a specialized procedure for VM.SwapIn.  "bufferPage" should be a page whose VMMapEntry is "in" and whose real page matches the one returned for the corresponding "vmPage" by AllocateForSwapIn, above.
In either case above, 'vmPage' has been checked back in, so...
Now we make the swap buffer page vacant.
This SetVMMap implicitly cleared the "checkedOut" bit, so...
Restore victim's map entry, but pin the page (permanently), since it can't be written out.  The only way anyone will discover this happened is by looking at the counter in VMStatistics.
Check the original page back in.
Make the swap buffer page vacant.
This is a specialized procedure for VM.Clean.
Interrupts must be disabled if the map entry says "present", so that the test for "dirty" and subsequent setting of "vacant" are atomic.  Interrupts need not be disabled if the map entry says "vacant", but it doesn't hurt, since we spend minimal time in that state and it simplifies the code.
This is a specialized procedure for VM.Clean.  "bufferPage" should be a page whose VMMapEntry is "in" and whose real page matches the one returned for the corresponding "vmPage" by ConsiderCleaning, above.
The above SetVMMap implicitly cleared the "checkedOut" bit, so we must wake up any potential waiters.
Aging
Interrupts must be disabled if the map entry says present, so that the resetting of "referenced" is atomic.  Interrupts need not be disabled if the map entry says "vacant", but it doesn't hurt, since we spend minimal time in that state and it simplifies the code.
This is a specialized procedure for VM.Age.

Laundry process support
We could probably get away without claiming the monitor lock.
This procedure constructs an interval surrounding it whose 'dirty' and 'referenced' states are the same as 'vP'.  It implicitly uses 'desired' and 'firstPass' and updates 'cleaningRover'.
We have completed a scan of real memory.

INTERNAL procedures
A note in VMInternal.VMMapEntry explains the following non-intuitive test.
*stats*--
�Ê
Ęš
œ™Jšœ
Ïm
œ1™<J™*J™'J™—J˜š
Ïk	˜	Jšœžœ!˜6Jšœ	žœ1˜?Jšœžœ'˜:Jšžœ
žœ˜šœžœ˜Jš
œµ˜µ—šœ
žœ˜Jš
œ=˜=——J˜šœžœ
žœ˜0Jšžœ9˜@Jšžœ˜Jšžœ
˜Jšž
œ˜$J˜—™$J˜šÏnœž˜$Jšœ žœ
žœ
˜5Jšžœ-˜4J™.J˜Jšœ	žœ
˜Jš
œ9˜9Jšžœ
žœ
žœ$žœ˜Ašžœžœž˜,š
œ˜Jšžœžœ
žœ!žœ˜Jšžœž˜Jšžœžœ
žœžœ
˜?Jšžœ˜—Jšœ
žœžœžœ˜KJšœžœ
˜Jš
œ˜J˜>Jš
œ`™`J˜—š
œ˜Jš
œ'˜'J˜šžœžœ˜Jš
œ�™�Jšžœžœ
žœžœ˜LJšœ5žœ
˜;J˜Jš
œ˜J˜—šžœžœ˜
šžœ
žœ
ž˜J˜š
œ˜Jš
œ+˜+JšÏcœžœ
˜+J˜—š
œ	˜	Jšžœžœ ˜BJšžœ	˜
—Jšžœ
˜—J˜—J˜—Jšžœ
˜—J˜—J˜š
Ÿ
œžœ
žœ
žœ*žœ˜PJš
œÏ
™Ï
J˜'šžœžœž˜,š
œ˜Jš
œ/˜/šžœžœž˜3˜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˜—šŸœžœ
žœ
žœ)˜OJ˜'šžœžœž˜,š
œ˜š
œ˜š
œ*˜*Jšœ žœžœ˜:—Jš
œ˜Jš
œ˜—Jš
œ<™<Jšž	œ	˜š
 ˜šžœ ž˜*Jš
œ˜Jšœ$žœ
˜)Jšœžœ
˜Jšžœ
˜——J˜—Jš
œ˜Jšžœ
˜—J˜—J˜šŸœžœ
žœ
žœ˜$Jšœ>žœ˜GJ˜'šžœžœž˜,š
œ˜šžœ	žœ˜Jš
œ¹
™¹
˜Jš
œ?˜?Jš
œ˜—Jš
œ.˜.Jšžœžœ	˜#š
œ˜Jšœ2žœ
˜7Jš
œ5˜5—J˜%Jš œžœ
˜+Jš œžœ
˜-Jš
œ ™ Jšœžœ
˜Jš
œ˜Jšž	œ	˜J˜—Jš
œ!™!Jšœ žœ
˜&Jš
œ˜Jš
œ˜J˜—Jš
œ˜Jšžœ
˜—J˜—J˜šŸœžœ%žœ
˜MJšžœ2˜9J™-Jš
œ¤™¤J˜J˜"J˜šžœžœž˜,Jšœžœžœžœ˜Jš
œ˜Jš
œ.˜.šžœ
žœ
ž˜Jš
œ˜š
œ˜Jšœžœžœ˜Bšžœžœ
žœ˜ ˜Jš
œ@˜@š
œ
˜
Jšœžœ
˜Jš
œ#˜#Jšœžœžœ	žœ˜CJš
œ˜——Jšœ. ˜EJ˜J˜—š
œ	˜	šžœ
žœ
ž˜Jš
œ˜Jš
œ!˜!Jšžœ˜——J˜—Jš
œ˜Jšžœ
˜—J˜—Jšžœ
˜—J˜!J˜—J˜š
Ÿ	œžœ
žœ
žœ*žœ˜OJš
œÍ
™Í
J˜'šžœžœž˜,š
œ˜Jš
œ/˜/šžœžœž˜3š
œ˜Jš
œ*˜*šžœžœ
ž˜š
œ˜š
œ˜š
œ*˜*Jšœ žœ˜D—Jš
œ˜J˜—Jšžœžœ	˜&šžœžœ˜Jšœ  ˜?Jšœžœ
˜#J˜
—šžœ˜š
œ˜Jšœ2žœ
˜7Jš
œ5˜5—Jš œžœ
˜+Jš œžœ
˜-Jš
œ˜—Jš
œ˜Jš
œe™eJšž	œ	˜J˜—J˜Jšžœ
˜—J˜—Jš
œ˜Jšžœ
˜—Jšœžœ
˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jšžœ
˜—J˜—J˜J˜—™J˜šŸœžœžœ˜OJš
œ‡™‡J™+J˜Jš
œ"˜"J˜šžœžœž˜,Jšœžœžœ˜;Jš
œ˜Jšžœ
˜—Jš
œ!˜!J˜—J™—™J˜šŸœžœ
žœ
žœ˜)Jš
œB˜BJšžœžœS˜sJš
œ=™=Jšœžœžœ
˜šŸœžœžœžœ˜MJšœmž
œM™»
Jš	œžœžœžœžœ
˜IJ˜Jš
œ˜šžœž˜#Jšœ#žœ
˜(Jš
œ'˜'šžœžœž˜,˜šžœžœ
ž˜ š
œ˜šžœžœ ˜.Jšœžœž˜9Jš	œžœžœžœ
žœ
˜Q——Jšœžœ
˜Jš
œ ˜ Jšžœ
˜——Jšœžœ
˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—šžœžœžœž˜?Jšœžœ
˜Jš
œ'˜'šžœžœž˜,˜šžœžœ
ž˜ š
œ˜šžœžœ ˜.Jšœžœž˜9Jš	œžœžœžœ
žœ
˜Q——Jšœžœ
˜Jš
œ ˜ Jšžœ
˜——Jšœžœ
˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—Jšœ%žœ
˜*J˜—Jš
œ˜Jš
œ(˜(Jšœžœžœ
˜š
ž˜šžœžœ
žœ˜(Jš
œ˜Jš œžœ
˜/J˜
—Jšžœžœ
˜šžœ
žœ
ž˜š
œ˜Jš
œ(™(šžœžœžœžœ˜=Jšœžœ
˜Jš
œ˜Jš
œ
˜
—Jšžœ
žœ
˜
—šœžœž
˜4Jš
œ˜Jšžœ
˜J˜—Jšžœ
˜—šžœžœ
ž˜š
œ ˜ Jš
œ˜Jš
œ#˜#šžœžœž˜,˜Jšœžœ˜)Jšœžœžœ˜BJšžœžœ	˜$šžœž˜
Jšžœžœžœž˜3Jšžœ<žœ
˜E—Jšžœžœ
˜"J˜—Jšœžœ ˜*Jšžœ
˜—J˜—Jšžœžœ
˜—Jšžœ
˜—Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜——J™™J˜š
Ÿœžœ
žœ žœžœ
˜MJšžœ žœžœžœ˜>Jšœžœžœ
˜š
ž˜Jš
œ˜šžœžœž˜,Jšœžœ
˜š
œ˜Jš
œJ™JJšžœžœžœ
žœ
˜5—Jšžœ
˜—Jšžœ
žœžœžœ˜(š
œ	™	Jšžœžœ(žœžœ˜R—Jšžœ	˜
Jšžœ
˜—Jš
œ˜J˜——Jšžœ
˜J˜J˜J˜J˜—…—'À?È