DIRECTORY
ClassInscript,
Interminal USING [ terminal ],
Intime USING [ EventTime, EventTimeDifference, MsTicks, ReadEventTime ],
Loader USING [ MakeProcedureResident, MakeGlobalFrameResident ],
PrincOpsUtils USING [ BITAND, BITSHIFT, LongCOPY ],
Process USING [ EnableAborts, MsecToTicks, SecondsToTicks, Ticks ],
Terminal USING [ RegisterNotifier, SwapAction, SwapNotifier ],
VM USING [ Allocate, Free, Interval, AddressForPageNumber, Pin, Unpin, wordsPerPage ]
;

InscriptImpl: MONITOR -- invariant: File contents consistent

IMPORTS
Interminal, Intime, Loader, PrincOpsUtils, Process, Terminal, VM
EXPORTS ClassInscript
SHARES ClassInscript =
BEGIN OPEN ClassInscript, Intime;

InscriptData: TYPE = LONG POINTER TO InscriptState;
InscriptObject: PUBLIC TYPE = InscriptState;

InscriptState: TYPE = RECORD [refCount: INT];
inscriptSpace: VM.Interval;

earliestPage: InscriptPageNumber _ 0;
latestRecordedD: InscriptPageDescBody_nullDescBody;
subspaceSize: CARDINAL; -- # of pages of inscr. file mapped as a unit to insc. VM
spaceBase: InscriptPage;
spaceLimit: InscriptPage;

writeDescriptor: PageDescriptor=@writeD; -- all entries into file use this
writeD: InscriptPageDescBody_nullDescBody;

actualPageMask: WORD; --<<>>
subspaceMask: WORD; --<<>>
hintPageNumber: ActualIPN; --<<>>
hintPage: InscriptPage;
minPagesInUse: ActualIPN;   --<<]>>;

stdInscriptState: InscriptState;
stdInscript: InscriptData=@stdInscriptState;

InscriptError: PUBLIC ERROR [code: InscriptErrorCode] = CODE;


Internal: ERROR[code: CARDINAL] = CODE;
pageSize: INTEGER=VM.wordsPerPage;
PageIndex: TYPE = [0..pageSize);

PageDescriptor: TYPE = LONG POINTER TO InscriptPageDescBody;
InscriptPageDescBody: PUBLIC TYPE = RECORD [
pageNumber: InscriptPageNumber,
iP: InscriptPage, -- base of current page.
index: PageIndex ];

nullDescBody: InscriptPageDescBody =[pageNumber:-1,iP:NIL,index:NULL];

InscriptPage: TYPE = LONG POINTER TO InscriptPageValue;
InscriptPageValue: TYPE = MACHINE DEPENDENT RECORD [
seal: CARDINAL, -- and this one --
data: SELECT OVERLAID * FROM
entryPage=> [ 
length: CARDINAL, -- excludes this word --
entries: ARRAY [0..nInscriptPageIndex) OF WORD],
hintPage=> [
earliestPage: CARDINAL,
latestPage: CARDINAL,
subspaceSize: CARDINAL,
rest: ARRAY [0..nInscriptPageIndex-2) OF WORD ],
ENDCASE];
nInscriptPageIndex: PageIndex = pageSize - 2;
inscriptPageSeal: CARDINAL = 154275B;

ActualIPN: TYPE = INTEGER;
nullAIPN: ActualIPN=-1;
Time0: OrderKey=[0,0,0];

NewStdInscript: PUBLIC PROC [
KeyProc: KEyProc, ComProc: COmProc, initializeFile: BOOLEAN _ FALSE,
lnFileSize: INTEGER_4, lnGroupSize: INTEGER_2] RETURNS [Inscript] = {
ENABLE InscriptError => { IF code=invalidInscriptFile THEN VM.Free[inscriptSpace]; };
Complain: PROC={ IF ~initializeFile THEN ERROR InscriptError[invalidInscriptFile]; };

refCount: INT=stdInscript.refCount+1;
fileLength: ActualIPN=TwoToThe[lnFileSize]+2; --1 for leader page, 1 for my trailer

IF refCount#1 THEN ERROR Internal[6]; -- not now
IF lnGroupSize>=lnFileSize OR lnGroupSize < 2 THEN
ERROR InscriptError[invalidInscriptSpecs];

inscriptSpace_VM.Allocate[count: fileLength-1];

subspaceSize_TwoToThe[lnGroupSize];
actualPageMask_PrincOpsUtils.BITSHIFT[-1,lnFileSize-16]; --//
subspaceMask_PrincOpsUtils.BITSHIFT[-1,lnGroupSize]; --//
minPagesInUse_fileLength-2-2*subspaceSize; --//
hintPageNumber_fileLength-2; --//
spaceBase_AccessIP[0];
spaceLimit_hintPage_AccessIP[hintPageNumber];

earliestPage_0; writeD_nullDescBody; writeD.pageNumber_0;
IF initializeFile THEN []_SetPage[stdInscript, writeDescriptor, 0, TRUE]
ELSE { -- file init: old
pD: PageDescriptor=@latestRecordedD; -- use as temp here
KeyFrom: PROC[pN: InscriptPageNumber] RETURNS [OrderKey] = {
IF SetPage[stdInscript, pD, pN] THEN
RETURN[KeyProc[stdInscript, pD !
InscriptError=>IF code=invalidPageKey THEN CONTINUE]];
RETURN[Time0]};
latestTime, nextTime: OrderKey; latestPage, maxLP: InscriptPageNumber;
IF hintPage.seal#inscriptPageSeal OR hintPage.subspaceSize#subspaceSize THEN Complain[];
earliestPage_PrincOpsUtils.BITAND[hintPage.earliestPage,actualPageMask]; -- normalize
latestPage_writeD.pageNumber_hintPage.latestPage-(hintPage.earliestPage-earliestPage);
maxLP_latestPage+fileLength-3; -- search max distance
latestTime_KeyFrom[latestPage];
IF latestTime=Time0 THEN ERROR InscriptError[invalidInscriptFile];
FOR pageNumber: InscriptPageNumber IN [latestPage+1..maxLP) DO
nextTime_KeyFrom[pageNumber];
IF ComProc[latestTime, nextTime] THEN EXIT
ELSE { latestTime_nextTime; latestPage_pageNumber; };
ENDLOOP;
IF ~SetPage[stdInscript, writeDescriptor, latestPage] THEN ERROR Internal[1];
writeD.index _ writeD.iP.length; };
latestRecordedD_writeD;
InscriptNotifier[Interminal.terminal, coming, NIL]; -- lock inscript space, enable recording.
stdInscript.refCount_refCount;
RETURN[stdInscript]; };

Release: PUBLIC ENTRY PROC [self: InscriptData] RETURNS [nilInscript: Inscript] = {
ENABLE UNWIND => NULL;
IF(self.refCount_self.refCount-1)#0 THEN RETURN[NIL[Inscript]];
InscriptNotifier[Interminal.terminal, going, NIL]; -- <<superfluous?>>
VM.Free[inscriptSpace];
RETURN[NIL[Inscript]];
};

GetPageLimits: PUBLIC ENTRY PROC [self: InscriptData]
RETURNS [earliestPageNo: InscriptPageNumber, latestPageNo: InscriptPageNumber] = {
RETURN[earliestPageNo: earliestPage, latestPageNo: writeD.pageNumber]; };

ResetPageDescriptor: PUBLIC ENTRY PROC [self: InscriptData, descriptor: PageDescriptor] = {
IF descriptor#NIL THEN descriptor^_nullDescBody}; -- now invalid

CopyPageDescriptor: PUBLIC ENTRY PROC [
self: InscriptData, dest: PageDescriptor, source: PageDescriptor] = {
dest^ _ source^; };

WaitForEntry: PUBLIC ENTRY PROC [
self: InscriptData, waitMode: WaitMode, waitInterval: MsTicks _ waitALongTime,
descriptor: PageDescriptor, waitStartTime: LONG POINTER TO EventTime _ NIL]
RETURNS [moreEntries: BOOLEAN] = {
ENABLE UNWIND => NULL;
t0, t1: EventTime;
waitTime: MsTicks _ waitInterval;
IF waitMode = timed AND waitStartTime = NIL THEN {
t0 _ ReadEventTime[]; waitStartTime _ @t0; };
DO
--   IF descriptor.pageNumber > writeD.pageNumber THEN ERROR Internal[5] --
--ELSE-- IF descriptor.pageNumber < writeD.pageNumber OR
descriptor.index<writeD.index THEN RETURN[TRUE];
SELECT waitMode FROM
dontWait => RETURN[FALSE];
forever => waitTime_waitALongTime;
timed => {
dif: MsTicks;
t1 _ ReadEventTime[];
dif _ EventTimeDifference[@t1, waitStartTime];
IF dif >= waitInterval THEN RETURN[FALSE];
waitTime _ waitInterval - dif; };
ENDCASE;
Wait[Process.MsecToTicks[waitTime]];
ENDLOOP; };

SetPage: PUBLIC PROC [
self: InscriptData, descriptor: PageDescriptor,
pageNumber: InscriptPageNumber, init: BOOLEAN_FALSE] RETURNS [success: BOOLEAN_TRUE] = {
IF ~IsValidPd[descriptor] OR descriptor.pageNumber # pageNumber THEN {
iP: InscriptPage;
IF earliestPage > pageNumber OR writeD.pageNumber < pageNumber THEN RETURN[FALSE];
descriptor.iP_iP_AccessIP[  IPNToActual[ descriptor.pageNumber_pageNumber ]  ];
IF init THEN { iP.length_0; iP.seal _ inscriptPageSeal; }
-- Next test useful only during initialization, in FindTimeSeam --
ELSE IF iP.seal # inscriptPageSeal THEN success_FALSE; };
descriptor.index _ 0; };

AdvancePage: PUBLIC PROC [self: InscriptData, descriptor: PageDescriptor]
RETURNS [success: BOOLEAN] = {
pageNumber: InscriptPageNumber=descriptor.pageNumber+1;
IF ~IsValidPd[descriptor] THEN ERROR InscriptError[descriptorUninitialized];
IF earliestPage > pageNumber OR writeD.pageNumber < pageNumber THEN RETURN[FALSE];
descriptor.pageNumber_pageNumber;
descriptor.iP_descriptor.iP+pageSize; IF LC[descriptor.iP]>=LC[spaceLimit] THEN descriptor.iP_spaceBase;
descriptor.index_0;
RETURN[TRUE]; };

SetWritePage: PUBLIC ENTRY PROC [self: InscriptData] RETURNS [success: BOOLEAN] = {
writeD.pageNumber_writeD.pageNumber+1;
writeD.iP_writeD.iP+pageSize; IF LC[writeD.iP]>=LC[spaceLimit] THEN writeD.iP_spaceBase;
writeD.iP.seal_inscriptPageSeal;
writeD.index_writeD.iP.length_0;
earliestPage _ PrincOpsUtils.BITAND[MAX[earliestPage, writeD.pageNumber-minPagesInUse], subspaceMask];
NOTIFY pageDone;
RETURN[TRUE]; };

ReadEntry: PUBLIC ENTRY PROC [
self: InscriptData, descriptor: PageDescriptor,
destination: LONG POINTER TO UNSPECIFIED, LengthProc: LengthProcType]
RETURNS [success: BOOLEAN] = {
ENABLE UNWIND => NULL;
index: PageIndex _ descriptor.index;
len: CARDINAL;
entry: LONG POINTER TO UNSPECIFIED;
pageNumber: InscriptPageNumber = descriptor.pageNumber;
inscriptPage: InscriptPage=descriptor.iP;
IF ~IsValidPd[descriptor] THEN ERROR InscriptError[descriptorUninitialized];
IF earliestPage > pageNumber -- OR pageNumber > writeD.pageNumber -- THEN 
ERROR InscriptError[entryOutOfBounds];
IF index >= inscriptPage.length THEN RETURN[FALSE];
entry _ @(inscriptPage.entries[index]);
PrincOpsUtils.LongCOPY[from: entry, to: destination, nwords: (len_LengthProc[entry])];
descriptor.index _ index + len;
RETURN[TRUE]; };

WriteEntry: PUBLIC ENTRY PROC [
self: InscriptData, entry: LONG DESCRIPTOR FOR ARRAY OF WORD]
RETURNS [success: BOOLEAN] = {
ENABLE UNWIND => NULL;
newIndex: CARDINAL = writeD.index+LENGTH[entry];
IF newIndex > nInscriptPageIndex THEN RETURN[FALSE];
PrincOpsUtils.LongCOPY[BASE[entry], LENGTH[entry], @writeD.iP.entries[writeD.index]];
writeD.index _ writeD.iP.length _ newIndex;
maintDue_FALSE; -- non-preemptive notify for page maintainer
BROADCAST entriesWaiting;
RETURN[TRUE]; };




dirtyThreshhold: INTEGER=2;
MaintainPage: ENTRY PROC[forceDirty: BOOLEAN] RETURNS [{dirty, aborted}] = { 
DO
ENABLE ABORTED => EXIT;
IF ~forceDirty THEN {
dif: INTEGER;
WAIT pageDone;
dif_writeD.pageNumber-latestRecordedD.pageNumber;
IF latestRecordedD=writeD OR (dif<dirtyThreshhold AND ~maintDue) THEN {
maintDue_TRUE; LOOP }; };
maintDue_FALSE;
latestRecordedD_writeD;
hintPage.seal_inscriptPageSeal;
hintPage.earliestPage_earliestPage;
hintPage.latestPage_latestRecordedD.pageNumber;
hintPage.subspaceSize_subspaceSize;
RETURN[dirty]; ENDLOOP;
RETURN[aborted];};

AccessIP: PROC[actualIPN: ActualIPN]
RETURNS[page: InscriptPage] = INLINE
{RETURN[LOOPHOLE[VM.AddressForPageNumber[inscriptSpace.page+actualIPN]]];};

IPNToActual: PROC [pN: InscriptPageNumber]
RETURNS [ActualIPN] = INLINE -- Assert 0<=pN
{RETURN[PrincOpsUtils.BITAND[pN, actualPageMask]]; };

IsValidPd: PROC[pD: PageDescriptor] RETURNS [BOOLEAN] = INLINE
{ RETURN[pD.iP#NIL]};

LC:PROC[iP:InscriptPage]RETURNS[LONG CARDINAL]=INLINE{RETURN[LOOPHOLE[iP]]};


Wait: INTERNAL PROC [t: CARDINAL] = INLINE {
entriesWaiting.timeout_t; WAIT entriesWaiting};

TwoToThe: PROC[ln: CARDINAL] RETURNS [CARDINAL] = INLINE {
RETURN[PrincOpsUtils.BITSHIFT[1, ln]]};

entriesWaiting: CONDITION;
pageDone: CONDITION;
maintTicks: Process.Ticks=Process.SecondsToTicks[6];
maintDue: BOOLEAN_FALSE;

-- Initialization --

inscriptCurrent: INTEGER _ 0;

InscriptNotifier: Terminal.SwapNotifier = TRUSTED {
SELECT action FROM
coming => {
IF inscriptCurrent = 0 THEN VM.Pin[inscriptSpace]; 
inscriptCurrent _ inscriptCurrent + 1; };
going => {
inscriptCurrent _ inscriptCurrent - 1;
IF inscriptCurrent = 0 THEN {
VM.Unpin[inscriptSpace];
[]_MaintainPage[TRUE];
}};
here, gone => NULL;
ENDCASE=>ERROR;
};

Loader.MakeProcedureResident[--e.g.--InscriptNotifier];
Loader.MakeGlobalFrameResident[--e.g.--InscriptNotifier];

pageDone.timeout _ maintTicks;
-- NOTE: Must be locked because of known planned use by other abstractions! --
[]_Intime.ReadEventTime[]; -- make sure Time starts first.
Process.EnableAborts[@pageDone];
Process.EnableAborts[@entriesWaiting];
Terminal.RegisterNotifier[Interminal.terminal, InscriptNotifier];

END.


	@InscriptImpl.mesa  -  Manage Inscript file
Stone June 14, 1982 4:32 pm
McGregor, 14-Sep-81 16:38:27
Swinehart, April 29, 1982 5:13 pm
Paul Rovner, August 10, 1983 5:46 pm
Russ Atkinson, September 23, 1983 10:32 am
Birrell, August 23, 1983 9:33 am

<< This version requires that the Inscript file be resident.  Its default size has therefore been made much smaller than previous versions (16 pages, of which at least 8 have predictable contents (steady state)>>
<< This version also assumes (and ensures) that there is but one inscript per module instance.>> 

<<Denotes variables that would have to move into object for multiple files.>>
<< One inscript per instance; state entirely contained in frame.
NewStdInscript ups ref count; destroy downs it.>>
file information
mapping information
output page information:
maintProcess: PROCESS;  background, writes dirty pages occasionally
this and that
<<Everything is built in, for now; possibly multiple simultaneous inscripts using this code wouldn't work.>>
Types, specifications for the low-level Ring-buffer inscript
file implemented here
<<Must be 4 words long, or must change opaque type in ClassInscript>>
Final init
maintProcess _ FORK PageMaintainer[];
Process.Detach[maintProcess];
Process.Abort[maintProcess];

Cleans up descriptor, if necessary
Reads the indicated pages
success: page available, has seal; failure: page unavailable, or does not have seal (uninit.)
If init is TRUE, assumes page contents is valueless, initializes page
Read the next page, set descriptor.
Failure: same as SetPage
Raises InscriptError[descriptorUninitialized] if there's no current page.
IF index+len > inscriptPage.length THEN RETURN[FALSE];
Put entry in a buffer (indicate if page filled up).  See MaintainPage for actual file write
Utilities, Cleanup process, mapping functions, machine extensions
PageMaintainer: PROC = {
Monitored only where required.   Says here.
For the current page, this function merely keeps the inscript file
tracking reality approximately; for pages that are finished, no other process will
be changing them again.  Says here.
DO  forever
ENABLE Process.Aborted => EXIT;  (almost forever)
SELECT MaintainPage[FALSE] FROM
dirty=> Space.ForceOut[inscriptSpace];
aborted=>EXIT;
ENDCASE; ENDLOOP; };
Wait on entriesWaiting for specified time
[vt: Virtual, action: SwapAction, clientData: REF ANY]
�Ê
ÿ˜š
œ*™*Jš
œ™Jš
œ™Jš
œ!™!Jš
œ$™$J™*Jš
œ ™ J™—Jš
œÔ
™Ô
Jš
œa™aJ˜š
Ïk	˜	J˜Jšœ�œ˜Jšœ�œ<˜HJšœ�œ4˜@Jšœ�œ�œ�œ
˜3Jšœ�œ6˜CJšœ	�œ0˜>Jš�œ
�œM˜UJ˜
—J™Jš
œM™MJ˜Jšœ�œ
Ïc&˜<˜š
�˜Jšœ>�˜@—Jš�œ˜Jš�œ˜Jš�œ
�œ˜!J˜Jš	œ�œ�œ
�œ
�œ˜3Jšœ�œ
�œ˜,J˜—Jšœ�œ�œ�œ˜-š
œ@™@Jš
œ1™1š
œ™Jšœ�œ
˜J˜—š
œ™J˜%J˜3Jšœ�œž9˜QJ˜J˜J˜—š
œ™Jšœ)ž!˜JJ˜*——Jš
œC™CJ˜š
œ
™
Jšœ�œž˜Jšœ�œž˜Jšœž˜!J˜Jšœž˜$J˜Jš
œl™lJ˜ J˜,J˜Jšœ�œ
�œ�œ
˜=—˜Jš
œ<™<Jš
œ™J˜Jšœ
�œ�œ�œ
˜'Jšœ
�œ
�œ˜"Jšœ�œ˜ J˜Jš	œ�œ�œ
�œ
�œ˜<Jš
œE™Ešœ�œ
�œ�œ˜,J˜Jšœž˜*J˜J˜—Jšœ6�œ�œ˜FJ˜Jš	œ�œ�œ
�œ
�œ˜7š	œ�œ�œ
�	œ
�œ˜4Jšœ�œž˜"šœ�œ
�œ�˜˜Jšœ�œž˜*Jšœ	�œ�œ
�œ˜0—˜šœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ�œ
�œ˜0——Jš�œ˜	——J˜-Jšœ�œ˜%J˜Jšœ�œ�œ
˜J˜J˜J˜—šÏnœ�œ
�œ˜Jšœ4�œ�œ
˜DJšœ�œ�œ�œ˜EJš�œ�œ�œ
�œ˜UJš
Ÿœ�œ�œ�œ
�œ'˜UJ˜Jšœ
�œ˜%Jšœ.ž%˜SJ˜Jš�œ�œ
�œž
˜0š�œ�œ�˜2Jš�œ%˜*J˜—Jšœ�œ˜/J˜J˜#Jšœ�œž˜=Jšœ�œž˜9Jšœ+ž˜/Jšœž˜!J˜J˜-J˜J˜9Jš�œ�œ-�œ
˜Hš�œž˜Jšœ%ž˜8šŸœ�œ�œ˜<š�œ�˜$š�œ˜ Jšœ�œ�œ
�œ˜6——Jš�œ	˜—J˜FJš�œ �œ$�œ˜XJšœ�œ(ž˜UJ˜VJšœž˜5J˜Jš�œ�œ
�œ$˜Bš�œ �œ�˜>J˜Jš�œ�œ
�˜*Jš�œ1˜5Jš�œ
˜—Jš�œ4�œ
�œ
˜MJ˜#—Jš
œ
™
J˜Jšœ.�œž)˜]—Jš
œ%™%š
œ™J˜Jš�œ˜—J˜š
Ÿœ�œ
�œ
�œ�œ˜SJš�œ
�œ�œ
˜Jš�œ"�œ
�œ
�œ˜?Jš
œ™Jšœ-�œž˜FJš�œ˜Jš�œ
�œ˜Jš
œ˜J˜—šŸ
œ�œ
�œ
�œ˜5Jš�œK˜Rš�œC˜IJ˜——šŸœ�œ
�œ
�œ5˜[Jš�œ�œ
�œž˜@J˜—šŸœ�œ
�œ
�œ˜'˜EJ˜J˜——šŸœ�œ
�œ
�œ˜!J˜NJš	œ+�œ
�œ
�œ
�œ
˜KJš�œ�œ˜"Jš�œ
�œ�œ
˜J˜J˜!š�œ�œ�œ
�œ˜2J˜-—Jš
�˜š
žK˜Kšžœ
�œ+�˜8Jšœ�œ
�œ
�œ˜0—š�œ
�˜Jšœ�œ
�œ˜J˜"˜
J˜
J˜J˜.Jš�œ�œ
�œ
�œ˜*J˜!—Jš�œ
˜—J˜$Jš�œ˜——J™š
œ"™"Jš
œ™Jš
œ]™]Jš
œE™E—J˜šŸœ�œ
�œ˜J˜/Jšœ&�œ
�œ�œ�œ
�œ˜Xš�œ�œ$�œ˜FJ˜Jš
�œ�œ �œ
�œ
�œ˜RJ˜OJš�œ�œ-˜9Jš
žB˜BJš�œ
�œ�œ	�œ˜9—J˜J˜—Jš
œ#™#Jš
œ™Jš
œI™IšŸœ�œ
�œ1˜IJš�œ�œ˜J˜7Jš�œ�œ
�œ(˜LJš
�œ�œ �œ
�œ
�œ˜RJ˜!Jš	œ&�œ
�œ�œ
�œ˜hJ˜Jš�œ
�œ˜J˜—šŸœ�œ
�œ
�œ�œ�œ˜SJ˜&Jš	œ�œ
�œ
�œ
�œ˜XJ˜ J˜ Jšœ�œ
�œ?˜fJš�œ
˜Jš�œ
�œ˜J˜—šŸ	œ�œ
�œ
�œ˜J˜/Jš	œ
�œ
�œ
�œ
�œ˜EJš�œ�œ˜Jš�œ
�œ�œ
˜J˜$Jšœ�œ
˜Jš	œ�œ
�œ
�œ
�œ
˜#J˜7J˜)Jš�œ�œ
�œ(˜Lš�œž'œ
�œ
˜JJš�œ!˜&—Jš�œ�œ
�œ
�œ˜3J˜'J˜Vš
œ6™6J˜Jš�œ
�œ˜J˜——Jš
œ[™[šŸ
œ�œ
�œ
�œ˜Jš
œ�œ
�
œ
�œ
�œ
�œ
�œ
˜=Jš�œ�œ˜Jš�œ
�œ�œ
˜Jšœ
�œ�œ˜0Jš�œ�œ
�œ
�œ˜4Jšœ�œ	�œ+˜UJ˜+Jšœ	�œž,˜<Jš�	œ˜š�œ
�œ˜J˜——Jš
œA™AJ˜Jš
œ™Jš
œ+™+Jš
œB™BJš
œR™RJš
œ#™#J˜Jš
œ™Jš
œ1™1Jš
œ™Jš
œ&™&Jš
œ™Jš
œ™J˜Jšœ�œ˜š
Ÿœ�œ
�œ
�œ�œ˜Mš
�˜Jš�œ
�œ�œ
˜š�œ
�œ˜Jšœ�œ
˜
Jš�œ
˜J˜1š�œ�œ�œ�œ˜GJšœ	�œ�œ˜——Jšœ	�œ
˜J˜J˜J˜#J˜/J˜#Jš�œ	�œ
˜—Jš�œ˜—J˜šŸœ�œ˜$Jš�œ�˜$Jšœ
�œ
�œ
�œ8˜KJ˜—šŸœ�œ˜*Jš�œ�œ
ž˜,Jšœ
�œ�œ˜5J˜—š	Ÿ	œ�œ�œ�œ�˜>Jšœ�œ�œ˜J˜—š�œ
�œ�œ
�œ
�œ�œ
�œ
�œ˜LJ˜—Jš
œ)™)J˜š
Ÿœ�œ
�œ�œ�œ˜,Jšœ�œ˜/J˜—šŸœ�œ�œ�œ�œ�œ˜:š�œ�œ
˜'J˜—Jšœ�	œ
˜Jšœ
�	œ
˜J˜4Jšœ
�œ
�œ
˜J˜Jš
ž˜J˜—Jšœ�œ˜J˜šœ*�œ˜3Jš
œ6™6š�œ�˜˜Jš�œ�œ
�œ˜3J˜)—˜
J˜&š�œ�œ˜Jš�œ˜Jšœ�œ˜J˜——Jšœ�œ
˜Jš�œ�œ
˜Jš
œ˜J˜—Jšœžœ˜7Jšœžœ˜9J˜J˜Jš
žN˜NJšœž˜:J˜ J˜&J˜A—J˜Jš�œ
˜J˜J˜—…—,üD;