DIRECTORY
BasicTime USING [nullGMT, GMT, Now],
DB USING [
Attribute, AttributeValueList, Entity, EntitySet, GMT, Relship, RelshipSet, Value,
DeclareEntity, DeclareRelship, GetF, NameOf, NextRelship, Null, RelationSubset, ReleaseRelshipSet, SetF, S2V, V2B, V2E, V2I, V2S, V2T],
Rope,
RuntimeError USING [BoundsFault],
VFonts USING [CharWidth, StringWidth],
ViewerTools USING [TiogaContents],
WalnutDefs USING [MsgSet],
WalnutDB USING [],
WalnutDBInternal USING [activeMessageSet, CarefullyApply, ChangeCountOfMsgs, ChangeCountInMsgSet, GetMsgDisplayInfo],
WalnutKernelDefs USING [MsgLogEntry],
WalnutSchema,
WalnutSendOps USING [simpleUserName, userRName, RFC822Date];

WalnutDBMsgImpl: CEDAR PROGRAM
IMPORTS
BasicTime, DB, Rope, RuntimeError, VFonts,
WalnutDBInternal, WalnutSchema, WalnutSendOps

EXPORTS WalnutDB =

BEGIN OPEN WalnutSchema;
ROPE: TYPE = Rope.ROPE;
GMT: TYPE = BasicTime.GMT;
TiogaContents: TYPE = ViewerTools.TiogaContents;

Entity: TYPE = DB.Entity;
EntitySet: TYPE = DB.EntitySet;
Relship: TYPE = DB.Relship;
RelshipSet: TYPE = DB.RelshipSet;

MsgSet: TYPE = WalnutDefs.MsgSet;
MsgLogEntry: TYPE = WalnutKernelDefs.MsgLogEntry;
DBIntValue: REF INT _ NEW[INT];
DBBoolValue: REF BOOL _ NEW[BOOL];
DBGmtValue: REF DB.GMT _ NEW[DB.GMT];
lastMsgEntity: Entity _ NIL;
blankWidth: INT_ VFonts.CharWidth[' ]; -- in default font
blanks: ROPE_ "                                                  "; -- lotsa blanks
IsEntity: TYPE = RECORD [entity: Entity, exists: BOOL];
NullEntity: IsEntity = [NIL, FALSE];
MsgExists: PUBLIC PROC[msg: ROPE] RETURNS [exists: BOOL] = {
IsMsg: PROC = { exists _ GetMsgEntity[msg: msg].exists };
WalnutDBInternal.CarefullyApply[IsMsg];
};


GetHasBeenRead: PUBLIC PROC[msg: ROPE] RETURNS[has: BOOL] = {
Ghbr: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF ~m.exists THEN {has_ FALSE; RETURN };
has_ DB.V2B[DB.GetF[GetMsgDisplayInfoRel[m.entity], mDIHasBeenRead]];
};
WalnutDBInternal.CarefullyApply[Ghbr];
};

SetHasBeenRead: PUBLIC PROC[msg: ROPE] = {
DoSet: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF ~m.exists THEN  RETURN;
DBBoolValue^ _ TRUE;
DB.SetF[GetMsgDisplayInfoRel[m.entity], mDIHasBeenRead, DBBoolValue];
};
WalnutDBInternal.CarefullyApply[DoSet];
};

AddNewMsg: PUBLIC PROC[msg: MsgLogEntry] RETURNS[mExisted: BOOL] = {
DoAddNew: PROC = {
msgRope: ROPE = Rope.FromRefText[msg.msg];
m: IsEntity = GetMsgEntity[msg: msgRope];
IF mExisted _ m.exists THEN RETURN;		-- id's assumed unique
BEGIN
me: Entity = DB.DeclareEntity[MsgDomain, msgRope, NewOnly];
herald, toc: ROPE;
startOfSubject, shortNameLen: INT;
[herald, toc, startOfSubject, shortNameLen] _ ComputeHeraldAndTOC[msg];
SetMsgTextInfo[me, msg, herald, shortNameLen];
SetMsgDisplayInfo[me, FALSE, toc, startOfSubject];
SetMsgInfo[me, msg.date, msg.show];
WalnutDBInternal.ChangeCountOfMsgs[1];
DBGmtValue^ _ [msg.date];
BEGIN		-- put it in active - no checking necessary
avl: DB.AttributeValueList = LIST[
[cdMsg, me],
[cdMsgSet, WalnutDBInternal.activeMessageSet],
[cdDate, DBGmtValue] ];
[] _ DB.DeclareRelship[cdRelation, avl];
IF msg.show THEN
WalnutDBInternal.ChangeCountInMsgSet[WalnutDBInternal.activeMessageSet, 1];
END;
END;
};
WalnutDBInternal.CarefullyApply[DoAddNew];
};

GetMsgEntryPosition: PUBLIC PROC[msg: ROPE] RETURNS[pos: INT] = {
Gmep: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF ~m.exists THEN {pos _ -1; RETURN};
pos _ DB.V2I[DB.GetF[GetMsgTextInfoRel[lastMsgEntity], mTIEntryStart] ];
};
WalnutDBInternal.CarefullyApply[Gmep];
};

SetMsgEntryPosition: PUBLIC PROC[to: INT] = {
Smep: PROC = {
IF DB.Null[lastMsgEntity] THEN RETURN;
DBIntValue^ _ to;
DB.SetF[GetMsgTextInfoRel[lastMsgEntity], mTIEntryStart, DBIntValue];
};
WalnutDBInternal.CarefullyApply[Smep];
};

GetMsgDate: PUBLIC PROC[msg: ROPE] RETURNS[date: GMT] = {
Gmd: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
date _ BasicTime.nullGMT;
IF ~m.exists THEN { date _ BasicTime.nullGMT; RETURN}
ELSE {
rel: Relship = DB.DeclareRelship[mInfo, LIST[[mInfoOf, m.entity]]];
date _ DB.V2T[DB.GetF[rel, mDateIs]];
};
};
WalnutDBInternal.CarefullyApply[Gmd];
};

GetMsgTextInfo: PUBLIC PROC[msg: ROPE] RETURNS[textStart, textLen, formatLen: INT] = {
Gmti: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF ~m.exists THEN {
textStart _ textLen _ formatLen _ 0;
RETURN;
};
[textStart, textLen, formatLen] _ GetTextInfo[m.entity];
};
WalnutDBInternal.CarefullyApply[Gmti];
};

GetMsgText: PUBLIC PROC[msg: ROPE]
RETURNS[textStart, textLen, formatLen: INT, herald: ROPE, shortNameLen: INT] = {
Gmt: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF ~m.exists THEN {
textStart _ textLen _ formatLen _ shortNameLen _ 0;
RETURN;
};
[textStart, textLen, formatLen, herald, shortNameLen] _ GetAllMsgTextInfo[m.entity];
};
WalnutDBInternal.CarefullyApply[Gmt];
};

GetDisplayProps: PUBLIC PROC[msg: ROPE]
RETURNS [hasBeenRead: BOOL_ TRUE, TOCentry: ROPE_ NIL, startOfSubject: INT_ 0] = {
DoDisplayProps: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
IF m.exists THEN [hasBeenRead, TOCentry, startOfSubject]_
	WalnutDBInternal.GetMsgDisplayInfo[m.entity];
};
WalnutDBInternal.CarefullyApply[DoDisplayProps];
};

GetCategories: PUBLIC PROC[msg: ROPE] RETURNS [msList: LIST OF ROPE] = {
DoCats: PROC = {
m: IsEntity = GetMsgEntity[msg: msg];
lastInList: LIST OF ROPE;
rs: RelshipSet;
rel: Relship;
IF ~m.exists THEN RETURN;
lastInList_ msList_ NIL;		-- for retries
rs _ DB.RelationSubset[cdRelation, LIST[[cdMsg, m.entity]]];
BEGIN ENABLE UNWIND => {IF rs#NIL THEN DB.ReleaseRelshipSet[rs]};
UNTIL DB.Null[rel_ DB.NextRelship[rs]] DO
new: LIST OF ROPE _ CONS[DB.NameOf[DB.V2E[DB.GetF[rel, cdMsgSet]]], NIL];
IF msList = NIL THEN lastInList_ msList_ new
ELSE {lastInList.rest_ new; lastInList_ lastInList.rest};
ENDLOOP;
DB.ReleaseRelshipSet[rs];
END;
};
WalnutDBInternal.CarefullyApply[DoCats];
};

SizeOfDatabase: PUBLIC PROC RETURNS[messages, msgSets: INT] = {
SizeOf: PROC = {
messages _ DB.V2I[DB.GetF[rVersionInfo, gMsgCount]];
msgSets _ DB.V2I[DB.GetF[rVersionInfo, gMsgSetCount]];
};
WalnutDBInternal.CarefullyApply[SizeOf];
};
ComputeHeraldAndTOC: PROC[mle: MsgLogEntry]
RETURNS[herald, toc: ROPE, startOfSubject, shortNameLen: INT] = {
date, tocx: ROPE;
from: ROPE = IF mle.sender.Equal[WalnutSendOps.userRName, FALSE] OR
mle.sender.Equal[WalnutSendOps.simpleUserName, FALSE]
THEN Rope.Concat["To: ", mle.to]
ELSE mle.sender;
IF mle.date = BasicTime.nullGMT THEN mle.date_ BasicTime.Now[];
date_ Rope.Substr[WalnutSendOps.RFC822Date[mle.date], 0, 9];
tocx_ date.Cat["   ", from];
tocx_ SquashRopeIntoWidth[tocx, 165];
startOfSubject_ tocx.Length[];
toc_ Rope.Concat[tocx, mle.subject];
herald_ RemoveComments[from];
herald_ Rope.Cat[herald, " ", date];
shortNameLen_ herald.Length[];
herald_ Rope.Cat[herald, " ", mle.subject];
IF herald.Length[] > 60 THEN herald_ Rope.Concat[herald.Substr[0, 56], " ..."];
IF herald.Length[] < shortNameLen THEN shortNameLen_ herald.Length[];
};

SquashRopeIntoWidth: PROC[s: ROPE, colWidth: INT] RETURNS[ROPE] =
BEGIN
blankCount: INT;
width: INT;
BEGIN ENABLE RuntimeError.BoundsFault => GOTO doItTheHardWay;
width_ VFonts.StringWidth[s];
DO
IF width<= colWidth THEN EXIT;
-- truncate
BEGIN
guessLength: INT_  s.Length[] * colWidth / width;
s_ Rope.Cat[s.Substr[0, MAX[0, guessLength-4]], "..."];
width_ VFonts.StringWidth[s];
END;
ENDLOOP;
EXITS
doItTheHardWay => [width, s]_ DoItTheHardWay[s, colWidth];
END;		-- of enable
-- At this point s is shorter than colWidth and we want to extend it with blanks
blankCount_ ((colWidth - width) / blankWidth) + 1;		-- force at least one blank
s_ Rope.Cat[s, Rope.Substr[blanks, 0, MIN[blankCount, blanks.Length[]]]];
RETURN[s]
END;

DoItTheHardWay: PROC[s: ROPE, colWidth: INT] RETURNS[width: INT, s1: ROPE] = {
thisWidth: INTEGER;
dots: ROPE = "...";
nullWidth: INTEGER = VFonts.CharWidth['\000];
width_ VFonts.StringWidth[dots];
FOR i: INT IN [0 .. s.Length[]) DO
thisWidth_ VFonts.CharWidth[s.Fetch[i] ! RuntimeError.BoundsFault =>
thisWidth_ nullWidth ];
width_ width + thisWidth;
IF width > colWidth THEN
{ width_ width - thisWidth;
s1_ Rope.Concat[s.Substr[0, MAX[0, i-1]], dots];
RETURN
};
ENDLOOP;
s1_ s.Concat[dots];
};

RemoveComments: PROC[name: ROPE] RETURNS[shortName: ROPE] = {
start, end: INT;
name _ Rope.Concat[base: name, rest: " "];
start _ Rope.Find[name, "<"];
IF start > 0 THEN
{ end _ Rope.Find[s1: name, s2: ">", pos1: start+1];
IF end > 0 THEN name _ Rope.Replace[name, start, end-start+1] };
start _ Rope.Find[name, "("];
IF start > 0 THEN
{ end _ Rope.Find[s1: name, s2: ")", pos1: start+1];
IF end > 0 THEN name _ Rope.Replace[name, start, end-start+1] };
shortName _ Rope.Substr[name, 0, Rope.Length[name]-1]
};

GetMsgEntity: PROC[msg: ROPE] RETURNS[e: IsEntity] = {
IF msg.Length[] = 0 THEN {
lastMsgEntity _ NIL;
RETURN[NullEntity];
};
e.entity _ DB.DeclareEntity[MsgDomain, msg, OldOnly];
e.exists _ NOT DB.Null[lastMsgEntity _ e.entity];
};

GetMsgTextInfoRel: PROC[m: Entity] RETURNS[rel: Relship] = INLINE
{ RETURN[DB.DeclareRelship[mTextInfo, LIST[[mTIOf, m]]]] };

GetAllMsgTextInfo: PROC[m: Entity]
RETURNS[textStart, textLen, formatLen: INT, herald: ROPE, shortNameLen: INT] = {
rel: Relship_ GetMsgTextInfoRel[m];
textStart _ DB.V2I[DB.GetF[rel, mTIEntryStart]] + DB.V2I[DB.GetF[rel, mTITextOffset]];
textLen_ DB.V2I[DB.GetF[rel, mTITextLen]];
formatLen_ DB.V2I[DB.GetF[rel, mTIFormatLen]];
herald_ DB.V2S[DB.GetF[rel, mTIHerald]];
shortNameLen_ DB.V2I[DB.GetF[rel, mTIShortNameLen]];
};

GetTextInfo: PROC[m: Entity] RETURNS[textStart, textLen, formatLen: INT] = {
rel: Relship_ GetMsgTextInfoRel[m];
textStart _ DB.V2I[DB.GetF[rel, mTIEntryStart]] + DB.V2I[DB.GetF[rel, mTITextOffset]];
textLen_ DB.V2I[DB.GetF[rel, mTITextLen]];
formatLen_ DB.V2I[DB.GetF[rel, mTIFormatLen]];
};

SetMsgTextInfo: PROC[m: Entity, mle: MsgLogEntry, herald: ROPE, shortNameLen: INT] = {
rel: Relship = DB.DeclareRelship[mTextInfo, LIST[[mTIOf, m]], NewOnly];
DBIntValue^ _ mle.entryStart;
DB.SetF[rel, mTIEntryStart, DBIntValue];
DBIntValue^ _ mle.textOffset;
DB.SetF[rel, mTITextOffset, DBIntValue];
DBIntValue^ _ mle.textLen;
DB.SetF[rel, mTITextLen, DBIntValue];
DBIntValue^ _ mle.formatLen;
DB.SetF[rel, mTIFormatLen, DBIntValue];
DB.SetF[rel, mTIHerald, DB.S2V[herald]];
DBIntValue^ _ shortNameLen;
DB.SetF[rel, mTIShortNameLen, DBIntValue];
};

GetMsgDisplayInfoRel: PROC[m: Entity] RETURNS[Relship] = INLINE
{ RETURN[DB.DeclareRelship[mDisplayInfo, LIST[[mDIOf, m]]]] };

SetMsgDisplayInfo: PROC
[m: Entity, hasBeenRead: BOOL, tocEntry: ROPE, startOfSubject: INT] = {
rel: Relship = DB.DeclareRelship[mDisplayInfo, LIST[[mDIOf, m]], NewOnly];
DBBoolValue^ _ hasBeenRead;
DB.SetF[rel, mDIHasBeenRead, DBBoolValue];
DB.SetF[rel, mDITOCEntry, DB.S2V[tocEntry]];
DBIntValue^ _ startOfSubject;
DB.SetF[rel, mDIStartOfSubject, DBIntValue];
};

SetMsgInfo: PROC[m: Entity, date: GMT, show: BOOL] = {
rel: Relship = DB.DeclareRelship[mInfo, LIST[[mInfoOf, m]], NewOnly];
DBGmtValue^ _ [date];
DB.SetF[rel, mDateIs, DBGmtValue];
DBBoolValue^ _ show;
DB.SetF[rel, mShowIs, DBBoolValue]
};

END.

	
WalnutDBMsgImplbind waln.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Willie-Sue, July 11, 1985 3:07:08 pm PDT
Donahue, May 17, 1985 4:03:40 pm PDT
(Changed treatment of new messages)

Contents: procedures dealing with Msgs in the Walnut message database
Initiated by Donahue, 19 April 1983
Willie-Sue, January 18, 1985 1:29:34 pm PST
Last Edited by: Willie-Sue, January 4, 1985 10:40:02 am PST
Types
Private Variables
Internal Types
Operations on Messages
The message invariants are as follows:

All messages belong to at least one message set. A message which is a member of the Deleted message set cannot belong to any other message sets. 
A message is automatically added to the Active message set when it is created.
A message cannot be destroyed unless it has been deleted.

Does a message with this name exist in the database.
DestroyMsg is not allowed; this is ONLY done by the Expunge operation
returns the mHasBeenReadIs attribute for msg
sets the mHasBeenReadIs attribute for msg to TRUE (no check on old value)
takes a parsed message from the log & puts it in the database -- if the message already exists in the database, then return TRUE.  Note: this guy takes the LogEntry given and has the responsibility for constructing the TOCEntry and herald for the message
returns the log position for the entry for this message (-1 if the message doesn't exist);  used by the lazy evaluator
Sets the message entry position to refer to the new value.  We depend on the fact that SetMsgEntryPosition is ONLY called by the expunge code and that it has just done a MsgExists call, which sets the local cached variable lastMsgEntity
returns the date by which the message is indexed in the database
returns information needed to get the tioga text for msg from log
returns information needed to get the tioga text for msg from log (also produce the herald to be used if displaying it in a viewer
Return the display properties of a message (the hasbeenread flag and the table of contents entry.
Return the msgSets that the message belongs to.
Internal procedures
Truncates s with "..." or expands it with blanks, so that it is about
colWidth characters wide.  Not exact, uses a few heuristics here...
first remove any "< . . .>" in the name
then do the same for any ( . . . ) in the name
ΚΗ˜š
Οn™Jšœ
Οm
œ1™<J™(Icode™$K™#—J™Jš
œE™Eš
œ#™#J™+—J˜Jš
œ;™;J˜š
Οk	˜	Jšœ
ŸœŸœ˜$šŸœ
Ÿœ˜
Jšœ2Ÿœ˜RJš
œ‡
˜‡
—Jš
œ˜Jšœ
Ÿœ˜!JšœŸœ˜&JšœŸœ˜"JšœŸœ
˜Jšœ	Ÿœ˜JšœŸœ_˜uJšœŸœ˜%J˜
JšœŸœ)˜<J˜—šœŸœ
Ÿ˜š
Ÿ˜JšœŸœ˜*Jš
œ-˜-—J˜JšŸœ˜J˜—JšŸœ
Ÿœ˜
head1š
Οb™JšŸœŸœŸœ
˜JšŸœŸœ
Ÿœ
˜JšœŸœ˜0J˜JšœŸœŸœ˜JšœŸœŸœ˜Jšœ	ŸœŸœ	˜JšœŸœŸœ˜!J˜JšœŸœ˜!Jšœ
Ÿœ ˜1—š
 ™Jš	œŸœ
ŸœŸœ
Ÿœ˜Jš	œ
Ÿœ
ŸœŸœ
Ÿœ˜"Jš
œŸœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ˜%JšœŸœ
˜JšœŸœΟc˜9JšœŸœ8‘˜S—™Jšœ
ŸœŸœŸœ˜7JšœŸœŸœ˜$—š
 ™™&J™J™‘
JšŸ
œM™NJ™9—J™š	œŸœ
ŸœŸœŸœ
Ÿœ˜<Jš
œ4™4JšœŸœ.˜9Jš
œ'˜'J˜J˜—Jš
œE™EJ˜šœŸœ
ŸœŸœŸœŸœ˜=Jš
œ,™,šœŸœ˜Jš
œ%˜%JšŸœŸœŸœŸœ˜(JšœŸœŸœ7˜EJ˜—Jš
œ&˜&J˜—J˜šœŸœ
ŸœŸœ˜*Jš
œI™IšœŸœ˜Jš
œ%˜%JšŸœŸœŸœ
˜JšœŸœ
˜JšŸœC˜EJ˜—Jš
œ'˜'J˜—J˜š
	œŸœ
ŸœŸœŸœ˜DJš
œώ
™ώ
šœŸœ˜Jšœ	Ÿœ˜*Jš
œ)˜)JšŸœŸœ
Ÿœ‘˜;š
Ÿ˜Jšœ
Ÿœ,˜;Jšœ
Ÿœ
˜JšœŸœ
˜"Jš
œG˜GJš
œ.˜.JšœŸœ˜2Jš
œ#˜#Jš
œ&˜&Jš
œ˜šŸœ‘+˜2šœŸœŸœ
˜"Jš
œ˜Jš
œ.˜.Jš
œ˜—JšœŸœ!˜(šŸœ
Ÿ˜Jš
œK˜K—JšŸœ
˜——JšŸœ
˜J˜—Jš
œ*˜*J˜—J˜šœŸœ
ŸœŸœŸœŸœ˜AJ™všœŸœ˜Jš
œ%˜%JšŸœŸœŸœ˜%JšœŸœŸœ9˜HJ˜—Jš
œ&˜&J˜—J˜šœŸœ
ŸœŸœ˜-Jš
œμ
™μ
šœŸœ˜JšŸœ
ŸœŸœ
Ÿœ
˜&Jš
œ˜JšŸœC˜EJ˜—Jš
œ&˜&J˜—J˜š
œŸœ
ŸœŸœŸœŸœ˜9Jš
œ@™@šœŸœ˜
Jš
œ%˜%J˜šŸœŸœŸœ
˜5šŸœ˜JšœŸœŸœ˜CJšœŸœŸœ˜%J˜——J˜—Jš
œ%˜%J˜—J˜šœŸœ
ŸœŸœŸœ Ÿœ˜VJš
œA™AšœŸœ˜Jš
œ%˜%šŸœŸœ˜Jš
œ$˜$JšŸœ
˜J˜—Jš
œ8˜8J˜—Jš
œ&˜&J˜—J˜š
œŸœ
ŸœŸœŸœ Ÿœ
ŸœŸœ˜sJš
œ‚
™‚
šœŸœ˜
Jš
œ%˜%šŸœŸœ˜Jš
œ3˜3JšŸœ
˜J˜—Jš
œT˜TJ˜—Jš
œ%˜%J˜—J˜šœŸœ
ŸœŸœŸœŸœŸœŸœŸœŸœ˜zJš
œa™ašœŸœ˜Jš
œ%˜%šŸœ
Ÿœ)˜9Jš
œ.˜.—J˜—Jš
œ0˜0J˜—J˜š
œŸœ
ŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜HJš
œ/™/šœŸœ˜Jš
œ%˜%JšœŸœ
Ÿœ
Ÿœ
˜Jš
œ˜J˜
JšŸœŸœ
Ÿœ
˜JšœŸœ‘˜(JšœŸœŸœ˜<šŸœ
Ÿœ
ŸœŸœŸœ
Ÿœ
Ÿœ˜AšŸœ
ŸœŸœŸ˜)JšœŸœ
Ÿœ
ŸœŸœ
ŸœŸœŸœŸœ˜IšŸœ
Ÿœ
Ÿœ˜,JšŸœ5˜9—JšŸœ
˜—JšŸœ˜—JšŸœ
˜J˜—Jš
œ(˜(J˜—J˜šœŸœ
ŸœŸœ˜?šœŸœ˜JšœŸœŸœ ˜4Jšœ
ŸœŸœ#˜6Jš
œ˜—Jš
œ(˜(J˜—Lš
 ™š
œŸœŸœŸœ Ÿœ˜mJšœŸœ
˜šœŸœŸœ+ŸœŸ˜Cšœ/Ÿœ
˜5JšŸœ˜ JšŸœ˜——JšŸœŸœ˜?Jš
œ<˜<Jš
œ˜Jš
œ%˜%J˜Jš
œ$˜$Jš
œ˜Jš
œ$˜$Jš
œ˜Jš
œ+˜+JšŸœŸœ3˜OJšŸœ Ÿœ˜EJ˜—J˜šœŸœŸœŸœŸœ
Ÿœ˜AJš
œE™EJš
œC™Cš
Ÿ˜JšœŸœ
˜JšœŸœ
˜šŸ
œŸœ˜=Jš
œ˜š
Ÿ˜JšŸœŸœ
Ÿœ
˜Jš
‘˜š
Ÿ˜Jšœ
Ÿœ!˜1JšœŸœ˜7Jš
œ˜—JšŸœ
˜—JšŸœ
˜š
Ÿ˜Jš
œ:˜:——JšŸœ‘˜Jš
‘P˜PJšœ4‘˜OJšœ&Ÿœ ˜IJšŸœ˜	—JšŸœ
˜—J˜šœŸœŸœŸœŸœŸœŸœ˜NJšœŸœ
˜JšœŸœ	˜JšœŸœ˜-Jš
œ ˜ šŸœŸœ
ŸœŸ˜"š
œD˜DJš
œ˜—Jš
œ˜šŸœŸ˜š
œ˜JšœŸœ˜0Jš
Ÿ˜—J˜——JšŸœ
˜Jš
œ˜Jš
œ˜—J˜š
œŸœŸœŸœŸœ˜=JšœŸœ
˜J˜*Jš
œ'™'J˜šŸœŸ˜˜4JšŸœ	Ÿœ1˜@——Jš
œ.™.J˜šŸœŸ˜˜4JšŸœ	Ÿœ1˜@——J˜5J˜—J˜šœŸœŸœŸœ˜6šŸœŸœ˜JšœŸœ
˜JšŸœ
˜J˜—JšœŸœ(˜5JšœŸœ
Ÿœ ˜1J˜—J˜šœŸœŸœŸ˜AJšœŸœ
ŸœŸœ˜;—J˜šœŸœŸœ Ÿœ
ŸœŸœ˜sJš
œ#˜#Jš	œŸœŸœŸœŸœ˜VJšœ	ŸœŸœ˜*JšœŸœŸœ˜.JšœŸœŸœ˜(JšœŸœŸœ˜4J˜—J˜šœŸœŸœ Ÿœ˜LJš
œ#˜#Jš	œŸœŸœŸœŸœ˜VJšœ	ŸœŸœ˜*JšœŸœŸœ˜.J˜—J˜šœŸœ&ŸœŸœ˜VJšœŸœŸœ˜GJš
œ˜JšŸœ&˜(Jš
œ˜JšŸœ&˜(Jš
œ˜JšŸœ#˜%Jš
œ˜JšŸœ%˜'JšŸœŸœ˜(Jš
œ˜JšŸœ(˜*J˜—J˜šœŸœŸœŸ˜?JšœŸœ
ŸœŸœ˜>—J˜š
œŸœŸœŸœŸœ˜_JšœŸœŸœ˜JJš
œ˜JšŸœ(˜*JšŸœŸœ˜,Jš
œ˜JšŸœ*˜,J˜—J˜š
œŸœŸœŸœ˜6JšœŸœŸœ˜EJš
œ˜JšŸœ ˜"Jš
œ˜JšŸœ ˜"Jš
œ˜—J˜—JšŸœ
˜J˜—…—*φBΗ