DIRECTORY
BasicTime USING [Now],
FS,
MailBasics,
MailBasicsFileTypes,
MailBasicsItemTypes,
MailMessage USING [ReadOneMessage],
MailRetrieve USING [Failed, Handle, MBXState, ServerState, Accept, Close, Create, MailboxState, NextMessage, NextServer, NewUser, ServerName, StartMessage],
MailUtils USING [Credentials],
Idle USING [IdleHandler, IdleRegistration, RegisterIdleHandler],
IO,
Process USING [Detach, Pause, SecondsToTicks],
RefText,
Rope,
WalnutKernelDefs,
WalnutNewMail USING [],
WalnutDefs USING [CheckReportProc, Error, RetrieveState, ServerResponse, WalnutOpsHandle],
WalnutOps USING [ EndNewMail],
WalnutOpsInternal,
WalnutRoot USING [FlushMailStream, GetOpsHandleList, RootHandle, RootHandleRec],
WalnutStream USING [AbortStream, IdOnFileWithSender, WriteEntry];

WalnutNewMailImpl: CEDAR MONITOR

IMPORTS BasicTime, FS, Idle, IO, MailMessage, MailRetrieve, Process, Rope, WalnutDefs, WalnutOps, WalnutRoot, WalnutStream

EXPORTS
WalnutDefs, WalnutNewMail

= BEGIN

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
CheckReportProc: TYPE = WalnutDefs.CheckReportProc;
WalnutOpsHandle: TYPE = WalnutDefs.WalnutOpsHandle;
RootHandle: TYPE = WalnutRoot.RootHandle;
RootHandleRec: PUBLIC TYPE = WalnutRoot.RootHandleRec;
KernelHandle: TYPE = WalnutOpsInternal.KernelHandle;
KernelHandleRec: PUBLIC TYPE = WalnutOpsInternal.KernelHandleRec;

TiogaCTRL: MailBasics.ItemType = MailBasicsItemTypes.tioga1;

MailHandle: TYPE = WalnutOpsInternal.MailHandle;
MailHandleObject: PUBLIC TYPE = WalnutOpsInternal.MailHandleObject;
copyBuffer: REF TEXT ¬ NEW[TEXT[RefText.page]];
newMailCreateMsg: WalnutKernelDefs.MsgLogEntry ¬ NEW[CreateMsg WalnutKernelDefs.LogEntryObject];

idled: BOOL ¬ FALSE; -- this is true if the machine has been put in the idle state
idleReg: Idle.IdleRegistration;

msgPollingInterval: INT ¬ 300;		-- seconds between pollings
checkingRope: ROPE = "Checking for new mail ...";

EnableMailRetrieval: PUBLIC ENTRY PROC[
opsHandle: WalnutOpsHandle,
registeredUsers: LIST OF MailUtils.Credentials,
reportProc, progressProc: CheckReportProc,
getMailLog: PROC[WalnutOpsHandle] RETURNS[STREAM],
recordMailInfo: PROC[opsHandle: WalnutOpsHandle, logLen: INT, server: ROPE, num: INT] RETURNS[BOOL],
notifyWhenMailRetrieved: PROC[opsHandle: WalnutOpsHandle, ok: BOOL, someMail: BOOL] ] = {
ENABLE UNWIND => NULL;

this: MailHandle;
IF idleReg = NIL THEN idleReg ¬ Idle.RegisterIdleHandler[NewMailIdleProc];
IF opsHandle.kernelHandle.mailHandle # NIL THEN RETURN;

this ¬ NEW[WalnutOpsInternal.MailHandleObject ¬ [
procForReporting: reportProc,
procForProgress: progressProc,
notifyProc: notifyWhenMailRetrieved,
registeredUsers: registeredUsers,
lastStatus: checkingRope,
getMailLogProc: getMailLog,
recordMailInfoProc: recordMailInfo,
mrHandle: MailRetrieve.Create[ msgPollingInterval, WatchMailBox ]
] ];

opsHandle.kernelHandle.mailHandle ¬ this;
TRUSTED{ Process.Detach[ FORK StartIt[this.mrHandle, this.registeredUsers] ] }
};

StartIt: PROC[mH: MailRetrieve.Handle, users: LIST OF MailUtils.Credentials] = {
FOR rnL: LIST OF MailUtils.Credentials ¬ users, rnL.rest UNTIL rnL = NIL DO
MailRetrieve.NewUser[mH, rnL.first.rName, rnL.first.password]
ENDLOOP;
};

DisableMailRetrieval: PUBLIC ENTRY PROC[opsHandle: WalnutOpsHandle] = {
ENABLE UNWIND => NULL;
this: MailHandle = opsHandle.kernelHandle.mailHandle;
opsHandle.kernelHandle.mailHandle ¬ NIL;
IF this # NIL THEN
IF this.mailInProgress THEN this.needsClosing ¬ TRUE
ELSE {
this.hasBeenClosed ¬ TRUE;
TRUSTED { Process.Detach[ FORK MailRetrieve.Close[this.mrHandle] ] }
};
};

GetLastMailBoxStatus: PUBLIC ENTRY PROC[opsHandle: WalnutOpsHandle]
RETURNS[mbxState: MailRetrieve.MBXState, status: ROPE] = {
ENABLE UNWIND => NULL;
this: MailHandle = opsHandle.kernelHandle.mailHandle;
IF this = NIL THEN RETURN[unknown, NIL];
RETURN[this.lastStateReported, this.lastStatus]
};

CheckMailBoxes: PUBLIC ENTRY PROC[opsHandle: WalnutOpsHandle] = {
ENABLE UNWIND => NULL;
this: MailHandle = opsHandle.kernelHandle.mailHandle;
IF ( this = NIL ) OR ( this.mailInProgress ) THEN RETURN;
this.tryForNewMail ¬ FALSE;
this.mailInProgress ¬ TRUE;
TRUSTED { Process.Detach[FORK AutoNewMailProc[opsHandle, this]] }
};

CheckMailReport: CheckReportProc = {
this: MailHandle = opsH.kernelHandle.mailHandle;
IF ( this # NIL ) AND ( this.procForReporting # NIL ) THEN this.procForReporting[opsH, format, v1, v2, v3];
};

ProgressReport: CheckReportProc = {
this: MailHandle = opsH.kernelHandle.mailHandle;
IF this = NIL THEN RETURN;	-- race condition
IF this.procForProgress # NIL THEN this.procForProgress[opsH, format, v1, v2, v3];
};

NewMailIdleProc: ENTRY Idle.IdleHandler = {
ENABLE UNWIND => NULL;
idled ¬ reason = becomingIdle;
FOR wL: LIST OF WalnutOpsHandle ¬ WalnutRoot.GetOpsHandleList[], wL.rest UNTIL wL = NIL DO
this: MailHandle;
opsH: WalnutOpsHandle = wL.first;
IF ( opsH.kernelHandle = NIL ) OR ( ( this ¬ opsH.kernelHandle.mailHandle ) = NIL ) THEN LOOP;
IF this.tryForNewMail AND NOT idled THEN TRUSTED {
this.tryForNewMail ¬ FALSE;
this.mailInProgress ¬ TRUE;
Process.Detach[FORK AutoNewMailProc[wL.first, this]]
};
ENDLOOP;
}; 

WatchMailBox: ENTRY PROC[mrH: MailRetrieve.Handle, newState: MailRetrieve.MBXState] = {
ENABLE UNWIND => NULL;
status: ROPE;
this: MailHandle;
opsH: WalnutOpsHandle;
IF newState = unknown THEN RETURN;
opsH ¬ FindOpsHandle[mrH];
IF ( opsH = NIL ) OR ( this ¬ opsH.kernelHandle.mailHandle ) = NIL THEN RETURN;
IF ( this.lastStateReported = notEmpty ) AND
( ( newState = someEmpty ) OR ( newState = allEmpty ) ) THEN
status ¬ "New mail was read"
ELSE
{ SELECT newState FROM
badName   => status ¬ "Your user name is invalid, please log in";
badPwd    => status ¬ "Your password is invalid";
cantAuth  => status ¬ "Can't check your credentials at this time";
userOK    => status ¬ "Your credentials are OK";
allDown   => status ¬ "All of the mail servers are down";
someEmpty => status ¬ "All of the mail servers checked are empty";
allEmpty  => status ¬ "There is no new mail";
notEmpty  => status ¬ "You have new mail";
ENDCASE   => status ¬ "Bad State!";
};
this.lastStateReported ¬ newState;
this.lastStatus ¬ status;
this.tryForNewMail ¬ NOT this.mailInProgress AND
( ( this.tryForNewMail ) OR ( newState = notEmpty ) );
IF ( this.tryForNewMail ) AND ( NOT idled ) THEN TRUSTED {
this.tryForNewMail ¬ FALSE;
this.mailInProgress ¬ TRUE;
Process.Detach[FORK AutoNewMailProc[FindOpsHandle[mrH], this]] };
};

MailFetchDone: ENTRY PROC[this: MailHandle] = {
IF ( this.needsClosing ) AND ( NOT this.hasBeenClosed ) THEN {
this.hasBeenClosed ¬ TRUE;
TRUSTED { Process.Detach[ FORK MailRetrieve.Close[this.mrHandle] ]};
};
this.mailInProgress ¬ FALSE
};

AutoNewMailProc: PROC[opsH: WalnutOpsHandle, this: MailHandle] = {
ok, someMail: BOOL;
IF this.registeredUsers = NIL THEN RETURN;
DO
[ok, someMail] ¬ DoNewMail[opsH, this];
IF ok THEN EXIT;
IF ( this.notifyProc # NIL ) THEN this.notifyProc[opsH, ok, someMail];
Process.Pause[Process.SecondsToTicks[60]];
ENDLOOP;
MailFetchDone[this];
IF ( this.notifyProc # NIL ) THEN this.notifyProc[opsH, ok, someMail];
};

FindOpsHandle: PROC[mrH: MailRetrieve.Handle] RETURNS[opsH: WalnutOpsHandle] = {
FOR opsL: LIST OF WalnutOpsHandle ¬ WalnutRoot.GetOpsHandleList[], opsL.rest UNTIL opsL = NIL DO
IF ( opsL.first.kernelHandle.mailHandle # NIL ) AND
( opsL.first.kernelHandle.mailHandle.mrHandle = mrH ) THEN RETURN[opsL.first];
ENDLOOP;
RETURN[NIL];
};

DoNewMail: PROC[opsH: WalnutOpsHandle, mH: MailHandle] RETURNS[ok: BOOL, someMail: BOOL] = {
mailStream: STREAM;
serverKnown: BOOL ¬ FALSE;
sr: WalnutDefs.ServerResponse;
errMsg: ROPE;
err: ROPE = " during new mail; retrieval abandoned";
someMail ¬ FALSE;
ok ¬ FALSE;

BEGIN ENABLE BEGIN
WalnutDefs.Error => {
errMsg ¬ "\n WalnutDefs Error during New Mail; retrieval abandoned";
GOTO noGood;
};
FS.Error => { errMsg ¬ error.explanation.Concat[err]; GOTO noGood};
IO.Error => {
ed: FS.ErrorDesc;
<<ed ¬ FS.ErrorFromStream[stream ! IO.Error, FS.Error => CONTINUE];>>
IF ed.explanation # NIL THEN
errMsg ¬ ed.explanation.Concat[err]
ELSE errMsg ¬ "IO Error during new mail; retrieval abandoned";
GOTO noGood
};
END;

IF CheckForStopping[mH] THEN RETURN[TRUE, FALSE];

IF mH.getMailLogProc = NIL THEN RETURN[FALSE, FALSE];	-- had been shut down
IF ( mailStream ¬ mH.getMailLogProc[opsH] ) = NIL THEN {
ProgressReport[opsH, "\tCan't get newMailLog for %g @ %g\n", [rope[mH.registeredUsers.first.rName.name]], [time[BasicTime.Now[]]] ];
RETURN[FALSE, FALSE]
};

IF CheckForStopping[mH] THEN RETURN[TRUE, FALSE];

ProgressReport[opsH, "\n ~~~ Retrieving mail for %g @ %g\n", [rope[mH.registeredUsers.first.rName.name]], [time[BasicTime.Now[]]] ];
mailStream.SetIndex[mailStream.GetLength[]];

SELECT MailRetrieve.MailboxState[mH.mrHandle] FROM
badName => {
msg: ROPE ~ "\nSome mailbox reported badName - possibly no mailBox\n";
CheckMailReport[opsH, "%g\n", [rope[errMsg]] ];
ProgressReport[opsH, "%g\n", [rope[msg]] ];
};
badPwd => {
msg: ROPE ~ "\nSome mailbox reported badPwd\n";
CheckMailReport[opsH, "%g\n", [rope[errMsg]] ];
ProgressReport[opsH, "%g\n", [rope[msg]] ];
};
cantAuth => {
msg: ROPE ~ "\nSome server not found\n";
CheckMailReport[opsH, "%g\n", [rope[errMsg]] ];
ProgressReport[opsH, "%g\n", [rope[msg]] ];
};
ENDCASE; --ok to try

DO 			-- Loops over servers.
state: WalnutDefs.RetrieveState;
num: INT ¬ 0;		-- the number of messages read from server.
noMore: BOOLEAN;			-- TRUE if no more servers.
serverState: MailRetrieve.ServerState;	-- The state of the server.
thisServer: MailBasics.RName;

BEGIN
ENABLE UNWIND => {
DO
[noMore, serverState] ¬ MailRetrieve.NextServer[mH.mrHandle];	-- cycle thru servers
IF ~noMore THEN LOOP;
ENDLOOP;
};
-- Step through the servers.
IF CheckForStopping[mH] THEN RETURN[TRUE, FALSE];

[noMore, serverState] ¬ MailRetrieve.NextServer[mH.mrHandle];
IF noMore THEN EXIT;			-- Last server?  Then done.
serverKnown ¬ TRUE;

thisServer ¬ MailRetrieve.ServerName[mH.mrHandle];
ProgressReport[opsH, "(%g) %g: ", [atom[thisServer.ns]], [rope[thisServer.name]] ];
SELECT serverState FROM
unknown => state ¬ $didNotRespond;
empty => state ¬ $OK;
notEmpty => {
curPos: INT ¬ mailStream.GetLength[];
[num, state] ¬ DrainServer[mailStream, opsH, mH];
IF num = -1 THEN {
mailStream.SetLength[curPos];
WalnutRoot.FlushMailStream[opsH]
};
};
ENDCASE;

IF serverState = notEmpty AND state = $OK AND okToFlush THEN {
sr.state ¬ state;
sr.num ¬ num;
IF num # -1 THEN {
IF ~mH.recordMailInfoProc[opsH, mailStream.GetLength[], thisServer.name, num]
THEN { ReleaseNewMail[opsH, mailStream]; ok ¬ FALSE; RETURN };
MailRetrieve.Accept[mH.mrHandle ! MailRetrieve.Failed => {state ¬ $FlushFailed; CONTINUE}];
someMail ¬ TRUE;
};
};

IF mH.procForProgress # NIL THEN {
SELECT serverState FROM
unknown => ProgressReport[opsH, " did not respond\n"];
empty => ProgressReport[opsH, " empty\n"];
notEmpty =>
IF num = -1 THEN ProgressReport[opsH, " retrieval abandoned\n"]
ELSE ProgressReport[opsH, " %g messages\n", [integer[num]] ];
ENDCASE;
IF state = $FlushFailed THEN
ProgressReport[opsH, "\n   Flush of (%g) %g failed; you may get some messages again\n", [atom[thisServer.ns]], [rope[thisServer.name]] ];
};
END;
ENDLOOP;	-- End of servers loop, exit.

ok ¬ TRUE;
WalnutOps.EndNewMail[opsH];		-- release the newMailLog
IF NOT serverKnown THEN CheckMailReport[opsH, "NoMailboxes\n"];
EXITS
noGood => {
CheckMailReport[opsH, "%g\n", [rope[errMsg]] ];
ProgressReport[opsH, "%g\n", [rope[errMsg]] ];
ReleaseNewMail[opsH, mailStream];  -- release the newMailLog
};

END;
};

ReleaseNewMail: PROC[opsH: WalnutOpsHandle, strm: STREAM] = {
IF strm # NIL THEN
WalnutStream.AbortStream[strm ! IO.Error, FS.Error => CONTINUE]; -- ignore errors
WalnutOps.EndNewMail[opsH ! WalnutDefs.Error => CONTINUE];
};

okToFlush: BOOL ¬ TRUE;		-- for debugging

DrainServer: PROC[strm: STREAM, opsH: WalnutOpsHandle, mH: MailHandle]
	RETURNS[num: INT, state: WalnutDefs.RetrieveState] = {
ENABLE UNWIND => NULL;
msgState: MsgState;
num ¬ 0;
DO
[msgState, state] ¬ ReadMessageItems[strm, opsH, mH];
SELECT msgState FROM
noMore => EXIT;
OK, wasDeleted => NULL;
retrieveFailed => {num ¬ -1; EXIT};
ENDCASE => ERROR;
IF NOT (msgState = wasDeleted) THEN {
IF (num ¬ num + 1) MOD 10 = 0 THEN ProgressReport[opsH, "! "]
ELSE ProgressReport[opsH, "."];		-- report progress
};
ENDLOOP;
};

MsgState: TYPE = {OK, retrieveFailed, noMore, wasDeleted};

ReadMessageItems: PROC[strm: STREAM, opsH: WalnutOpsHandle, mH: MailHandle]
RETURNS [msgState: MsgState, state: WalnutDefs.RetrieveState] = {
-- This routine reads the next message on this connection, returning MsgState = noMore when there aren't any more.
ENABLE MailRetrieve.Failed => {
state ¬ why;
GOTO thisFailed;
};

msgExists, archived, deleted, ok: BOOLEAN;
timeStamp: MailBasics.Timestamp;
sender: MailBasics.RName;

IF CheckForStopping[mH] THEN {
ProgressReport[opsH, "  stopping retrieval\n"];
RETURN[retrieveFailed, $OK];
};

msgState ¬ OK;
state ¬ $OK;

[msgExists, archived, deleted] ¬ MailRetrieve.NextMessage[mH.mrHandle];

IF deleted THEN { msgState ¬ wasDeleted; RETURN};
IF NOT msgExists THEN { msgState ¬ noMore; RETURN};

-- Now read all the items in the message, terminating on the LastItem, and skipping the ones that we're not yet interested in.

[timeStamp, sender, ] ¬ MailRetrieve.StartMessage[mH.mrHandle] ;
ok ¬ MsgToStream[strm, timeStamp, sender, opsH, mH];
IF ~ok THEN msgState ¬ retrieveFailed;

EXITS
thisFailed => msgState ¬ retrieveFailed;
};

CheckForStopping: ENTRY PROC[mH: MailHandle] RETURNS[stop: BOOL] = {
IF (stop ¬ mH.needsClosing) AND ~mH.hasBeenClosed THEN {
mH.hasBeenClosed ¬ TRUE;
TRUSTED { Process.Detach[ FORK MailRetrieve.Close[mH.mrHandle] ] };
};
};

MsgToStream: PROC[strm: STREAM, timeStamp: MailBasics.Timestamp, sender: MailBasics.RName, opsH: WalnutOpsHandle, mH: MailHandle]
RETURNS[ok: BOOL] = {
curPos: INT;
msg: ROPE = WalnutStream.IdOnFileWithSender[timeStamp, sender];
newMailCreateMsg.msg ¬ msg;
	-- other fields are set later & entry is re-written
curPos ¬ WalnutStream.WriteEntry[strm, newMailCreateMsg, -1];
[ , , newMailCreateMsg.textLen, newMailCreateMsg.formatLen, ] ¬
MailMessage.ReadOneMessage[mH.mrHandle, timeStamp, sender.name, strm];

IF newMailCreateMsg.textLen = -1 THEN { strm.SetLength[curPos]; RETURN[FALSE]};
[] ¬ WalnutStream.WriteEntry[strm, newMailCreateMsg, curPos];
WalnutRoot.FlushMailStream[opsH];
RETURN[TRUE];
};


END.
ώ
WalnutNewMailImpl.mesa
Copyright Σ 1984, 1988, 1989, 1992 by Xerox Corporation.  All rights reserved.
Willie-Sue, November 27, 1989 4:16:54 pm PST

Walnut New Mail Operations Implementation
Terry, August 30, 1990 11:40 am PDT
Willie-s, August 12, 1993 11:11 am PDT

WalnutSendOps USING [TiogaCTRL],


Types
TiogaCTRL: MailBasics.ItemType = WalnutSendOps.TiogaCTRL;

Variables


Procedures

Watch the mailbox & retrieve mail when available
make sure that only one idle proc is registered here!
This is called when the condition of the mailbox changes
If there is new mail, then tryForNewMail is true, unless idle is FALSE and the new mail retrieval process succeeds

Cycle through the servers, until you find one that has mail.
now we can flush the server
Reads mail from the next grapevine server via mH.
Write a message on the newMailLog stream
writes a createMsg entry, then copies the message from grapevine to the stream, returns ok if there were no errors; flushes the stream; catches errors and returns FALSE
ΚG•NewlineDelimiter

–
(cedarcode) style™
codeš
Οb™Kšœ
Οe
œC™NK™,K™Kš
œ)™)K™#K™&K™—š
Οk	˜	Kšœ
Ÿœ˜KšŸœ
˜Kš
œ˜K˜K˜KšœŸœ˜#Kšœ
ŸœŠ
˜œ
Kšœ
Ÿœ˜KšœŸœ6˜@KšŸœ
˜KšœŸœ!˜.Kš
œ˜Kš
œ˜K˜KšœŸœ˜KšœŸœJ˜ZKšœ
Ÿœ˜Kš
œ˜KšœŸœ@˜PKšœŸœ
™ Kšœ
Ÿœ/˜AK˜—šœŸœ
Ÿ˜ K˜šŸœŸœŸœ[˜zK˜—š
Ÿ˜Kš
œ˜K˜—KšœŸ˜K™K™š
™K˜KšŸœŸœŸœ
˜KšŸœŸœŸœ
Ÿœ
˜KšœŸœ˜3KšœŸœ˜3KšœŸœ˜)KšœŸœ˜6KšœŸœ"˜4KšœŸœ
Ÿœ%˜AK˜K™9K˜<K˜KšœŸœ ˜0KšœŸœ
Ÿœ&˜C—K™š
	™	K™Kš	œŸœ
ŸœŸœ
Ÿœ˜/šœ1Ÿœ,˜`K˜—KšœŸœŸœΟc=˜Rš
œ˜K˜—KšœŸœ	 ˜;KšœŸœ˜1—K™Kš

™
K™š
0™0K˜š$ΟnœŸœ
Ÿœ
Ÿœ/Ÿœ
ŸœOŸœŸœ
ŸœŸœ%Ÿœ
ŸœŸœŸœ
ŸœŸœ!ŸœŸœ˜KšŸœ
ŸœŸœ
˜K˜K˜KšŸœŸœ
Ÿœ5˜JKš
œ5™5KšŸœ%Ÿœ
Ÿœ
Ÿœ
˜7K˜šœŸœΜ˜ΦK˜—K˜)KšŸœŸœ1˜NK˜K˜—š‘œŸœ!Ÿœ
Ÿœ˜PšŸœŸœ
Ÿœ)ŸœŸœ
Ÿ˜KKš
œ=˜=KšŸœ
˜—K˜—K˜š‘œŸœ
Ÿœ
Ÿœ ˜GKšŸœ
ŸœŸœ
˜Kš
œ5˜5Kšœ$Ÿœ
˜(šŸœŸœ
Ÿ˜KšŸœŸœŸ˜4šŸœ˜KšœŸœ
˜KšŸœŸœ&˜DK˜——K˜—K˜š‘œŸœ
Ÿœ
ŸœŸœ*Ÿœ˜~KšŸœ
ŸœŸœ
˜Kš
œ5˜5Kš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜(KšŸœ)˜/Kš
œ˜—K˜š‘œŸœ
Ÿœ
Ÿœ ˜AKšŸœ
ŸœŸœ
˜Kš
œ5˜5Kš
Ÿœ
ŸœŸœŸœ
Ÿœ
˜9KšœŸœ
˜KšœŸœ
˜KšŸœŸœ$˜AK˜—K˜š‘œ˜$Kš
œ0˜0Kš
Ÿœ
ŸœŸœŸœŸœ1˜kKš
œ˜—K˜š‘œ˜#Kš
œ0˜0Kš	ŸœŸœ
Ÿœ
Ÿœ ˜,KšŸœŸœ
Ÿœ0˜RKš
œ˜—K˜š‘œŸœ˜+KšŸœ
ŸœŸœ
˜K˜šŸœŸœ
Ÿœ:ŸœŸœ
Ÿ˜ZKš
œ˜Kš
œ!˜!KšŸœŸœŸœ-ŸœŸœ
Ÿœ
˜^š
ŸœŸœ
ŸœŸœ
Ÿœ˜2KšœŸœ
˜KšœŸœ
˜KšœŸœ!˜4Kš
œ˜—KšŸœ
˜—Kš
œ˜—K˜š‘œŸœ
Ÿœ?˜WKš
œ8™8K™rKšŸœ
ŸœŸœ
˜KšœŸœ
˜
K˜K˜KšŸœŸœ
Ÿœ
˜"K˜KšŸœ
ŸœŸœ+Ÿœ
Ÿœ
Ÿœ
˜OšŸœ'ŸœŸœŸ˜iK˜š
Ÿ˜šœŸœ
Ÿ˜K˜AK˜1K˜BK˜0K˜9K˜BK˜-K˜*KšŸœ˜#—K˜——K˜"K˜KšœŸœŸœŸœ˜gš
ŸœŸœŸœ	Ÿœ
Ÿœ˜:KšœŸœ
˜KšœŸœ
˜KšœŸœ.˜A—Kš
œ˜—K˜š‘
œŸœ
Ÿœ˜/šŸœŸœŸœŸœ˜>KšœŸœ
˜KšŸœŸœ&˜DK˜—KšœŸ˜Kš
œ˜—K˜š‘œŸœ-˜BKšœŸœ
˜KšŸœŸœ
Ÿœ
Ÿœ
˜*š
Ÿ˜K˜'KšŸœŸœ
Ÿœ
˜KšŸœŸœŸœ%˜FKš
œ*˜*KšŸœ
˜—Kš
œ˜KšŸœŸœŸœ%˜FKš
œ˜K˜—š‘
œŸœŸœ˜PšŸœŸœ
Ÿœ<ŸœŸœ
Ÿ˜`Kš
Ÿœ(ŸœŸœ7Ÿœ
Ÿœ
˜‚
KšŸœ
˜—KšŸœ
Ÿœ˜K˜K˜—š
‘	œŸœ(ŸœŸœŸœ˜\KšœŸœ
˜Kšœ
ŸœŸœ
˜K˜KšœŸœ
˜
KšœŸœ+˜4KšœŸœ
˜KšœŸœ
˜K˜šŸœ
Ÿœ
Ÿ˜š
œ˜K˜DKšŸœ˜K˜—KšŸœ4Ÿœ	˜CšŸœ˜
KšœŸœ˜Kš	œŸœŸœŸœ
Ÿœ˜EšŸœŸœ
Ÿ˜K˜#KšŸœ:˜>—KšŸœ˜K˜—KšŸœ
˜—K˜Kš
ŸœŸœ
Ÿœ
ŸœŸœ˜1K˜Kš
ŸœŸœ
Ÿœ
Ÿœ
ŸœŸœ ˜KšŸœ,Ÿœ
Ÿœ˜8Kš
œ„
˜„
KšŸœ
ŸœŸœ
˜K˜—K˜Kš
ŸœŸœ
Ÿœ
ŸœŸœ˜1K˜Kš
œ„
˜„
Kš
œ,˜,K˜šŸœ(Ÿ˜2š
œ˜KšœŸœ=˜FKš
œ/˜/Kš
œ+˜+K˜—š
œ˜KšœŸœ&˜/Kš
œ/˜/Kš
œ+˜+K˜—š
œ
˜
KšœŸœ˜(Kš
œ/˜/Kš
œ+˜+K˜—KšŸœ ˜—K˜šŸœ ˜Kš
œ ˜ KšœŸœ +˜:—K™š
œ<™<KšœŸœ ˜.Kšœ' ˜BKš
œ˜K˜Kš
Ÿ˜šŸœ
Ÿœ˜š
Ÿ˜Kšœ> ˜SKšŸœ	Ÿœ
Ÿœ
˜KšŸœ
˜—Kš
œ˜—Kš
 ˜Kš
ŸœŸœ
Ÿœ
ŸœŸœ˜1K˜K˜=KšŸœŸœ
Ÿœ ˜2KšœŸœ
˜K˜K˜2Kš
œS˜SšŸœ
Ÿ˜K˜"K˜š
œ
˜
KšœŸœ˜%K˜1šŸœ
Ÿœ˜Kš
œ˜Kš
œ ˜ K˜—K˜—KšŸœ
˜—K˜šŸœŸœ
ŸœŸœ˜>K˜K˜
šŸœ
Ÿœ˜šŸœK˜MKšŸœ*ŸœŸœ˜>—Kš
œ™KšœPŸœ˜[KšœŸœ
˜K˜—K˜—K˜šŸœŸœ
Ÿœ˜"šŸœ
Ÿ˜Kš
œ6˜6Kš
œ*˜*š
œ˜šŸœ
Ÿœ/˜?KšŸœ9˜=——KšŸœ
˜—KšŸœŸœŠ
˜¦
K˜—KšŸœ
˜—KšŸœ ˜&K˜KšœŸœ
˜
Kšœ ˜6KšŸœ
Ÿœ
Ÿœ(˜?š
Ÿ˜š
œ˜Kš
œ/˜/Kš
œ.˜.Kšœ# ˜<K˜——K˜KšŸœ
˜K˜—K˜š‘œŸœŸœ˜=Kš
ŸœŸœ
Ÿœ!ŸœŸœ
Ÿœ ˜dKšœ0Ÿœ˜:K˜—K˜KšœŸœŸœ ˜)K˜š‘œŸœŸœ(˜FKšœ
ŸœŸœ&˜7Kš
œ1™1KšŸœ
ŸœŸœ
˜Kš
œ˜K˜š
Ÿ˜K˜5šŸœ
Ÿ˜Kšœ
Ÿœ
˜KšŸœŸœ
˜KšœŸœ˜#KšŸœŸœ
˜—šŸœ
ŸœŸœ˜%šŸœŸœŸœ˜=KšŸœ ˜3—K˜——KšŸœ
˜K˜—K˜Kšœ
ŸœŸœ&˜:K˜Kš‘œŸœŸœ)Ÿœ:˜
š Eœ %˜ršŸœ˜KšœŸ
˜KšŸœ˜K˜—Kšœ"Ÿœ
˜*Kš
œ ˜ Kš
œ˜K˜šŸœŸœ˜Kš
œ/˜/KšŸœ˜K˜—K˜KšœŸœ
˜K˜K˜K˜GK˜KšŸœ	ŸœŸœ˜1KšŸœ
ŸœŸœŸœ˜3—K˜Kš
 ~˜~˜K˜@K˜4KšŸœŸœ˜&K˜š
Ÿ˜KšœŸ
œ
Ÿ
œ˜(—K˜—K˜š
‘œŸœ
ŸœŸœŸœ˜DšŸœŸœŸœ˜8KšœŸœ
˜KšŸœŸœ%˜CK˜—K˜——Kš
(™(˜š
‘œŸœŸœdŸœŸœ˜—
K™¨
KšœŸœ
˜KšœŸœ6˜?K˜Kšœ
 3˜4K˜=˜?Kš
œF˜F—K˜KšŸœŸœŸœ
Ÿœ˜OK˜=K˜!KšŸœ
Ÿœ˜
K˜—K˜K˜—KšŸœ
˜——…—8LQ