DIRECTORY
Atom USING [GetPName, MakeAtom],
MessageWindow USING [Append],
NodeStyleOps USING [StyleNameForNode],
Rope USING [Concat, FromChar, IsEmpty, Map, ROPE],
RunReader USING [Backwards, FreeRunReader, Get, GetRunReader, Ref, SetPosition],
TEditDocument USING [Selection],
TEditDocumentPrivate USING [CloseAndOpenPreviousFile, DefaultMenus, DoCloseAndNewViewer, DoCloseAndOpenImplFile, DoLoadFile, DoLoadImplFile, DoNewViewer, DoOpenFile, DoOpenImplFile, DoStoreFile, EmptyViewer, JumpToPrevious, LoadPreviousFile, OpenPreviousFile, Reselect, Reset, Save],
TEditInput USING [AllLevels, CloseEvent, FewerLevels, FirstLevelOnly, MoreLevels, Normalize],
TEditInputOps USING [CallWithLocks, DoFindPlaceholders, DoNextViewer, DoSelectMatchingBrackets],
TEditOps USING [RememberCurrentPosition],
TEditProfile USING [selectionCaret],
TEditRefresh USING [ScrollToEndOfSel],
TEditScrolling USING [ScrollToPosition],
TEditSelection USING [FindWhere, MakeSelection, Position, pSel, SetSelLooks],
TextEdit USING [FetchLooks, FromRope, SetLooks, Size],
TextFind USING [MalformedPattern, PatternErrorCode],
TextFindPrivate USING [FinderRecord],
TextLooks USING [Look, Looks, noLooks, Runs],
TextLooksSupport USING [LooksAND],
TextNode USING [Body, Location, NarrowToTextNode, Ref, RefTextNode, StepBackward, StepForward],
TiogaMenuOps USING [],
TiogaOps USING [CommentControl, Dir, Finder, FinderRec, Pattern, PatternErrorCode, PatternRec, SearchDir],
TiogaOpsDefs USING [Location, Viewer],
TreeFind USING [CommentControl, Create, CreateFromRope, Try, TryBackwards];

TiogaOps2Impl: CEDAR PROGRAM
IMPORTS Atom, MessageWindow, NodeStyleOps, Rope, RunReader, TEditDocumentPrivate, TEditInput, TEditInputOps, TEditOps, TEditProfile, TEditRefresh, TEditScrolling, TEditSelection, TextEdit, TextFind, TextLooksSupport, TextNode, TreeFind
EXPORTS TiogaOpsDefs, TiogaOps, TiogaMenuOps
= BEGIN OPEN TiogaOps, TiogaOpsDefs;

ROPE: TYPE ~ Rope.ROPE;
Ref: TYPE = REF NodeBody; -- points to a Tioga node
NodeBody: PUBLIC TYPE = TextNode.Body;
Finder: TYPE = REF FinderRec;
FinderRec: PUBLIC TYPE = TextFindPrivate.FinderRecord;
MakeName: PROC [r: ROPE] RETURNS [ATOM] ~ {
RETURN [IF r.IsEmpty THEN NIL ELSE Atom.MakeAtom[r]];
};
LooksRope: PROC [looks: TextLooks.Looks] RETURNS [r: ROPE] = {
FOR c: CHAR IN TextLooks.Look DO
IF looks[c] THEN r _ Rope.Concat[r, Rope.FromChar[c]];
ENDLOOP
};

RopeToLooks: PROC [r: ROPE] RETURNS [looks: TextLooks.Looks] = {
Set: PROC [c: CHAR] RETURNS [quit: BOOL _ FALSE] = { looks[c] _ TRUE };
[] _ Rope.Map[base: r, action: Set];
};

tiogaOpsEcFromTextFindEc: ARRAY TextFind.PatternErrorCode OF PatternErrorCode _ [
toobig: toobig,
endquote: endquote,
endtilda: endtilda,
boundary: boundary,
missingNameEnd: missingNameEnd,
unmatchedNameEnd: unmatchedNameEnd
];

MalformedPattern: PUBLIC ERROR [ec: PatternErrorCode] ~ CODE;

ReportMalformedPattern: PROC [textFindEc: TextFind.PatternErrorCode] ~ {
tiogaOpsEc: PatternErrorCode ~ tiogaOpsEcFromTextFindEc[textFindEc];
ERROR MalformedPattern[tiogaOpsEc];
};

CreateGeneralPattern: PUBLIC PROC [
target: Ref, -- node from which to get the pattern
text: BOOL _ TRUE, -- if true, match target text
looks: BOOL _ FALSE, -- if true, match target looks
format: BOOL _ FALSE, -- if true, match target format
style: BOOL _ FALSE, -- if true, match target style
comment: BOOL _ FALSE, -- if true, match target comment property
case: BOOL _ TRUE, -- if true, match case
literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
word: BOOL _ FALSE, -- if true, match words only
subset: BOOL _ TRUE, -- if true, use subset for looks test, else use equality
addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
RETURNS [pattern: Pattern] = {
error: BOOL _ FALSE;
errorCode: TextFind.PatternErrorCode;
txt: TextNode.RefTextNode = TextNode.NarrowToTextNode[target];
patternTxt: TextNode.RefTextNode _ txt;
pattern _ NEW[PatternRec];
IF looks AND ~text THEN { -- make a phony search pattern and get the looks
size: INT = TextEdit.Size[txt];
lks: TextLooks.Looks = IF size=0 THEN TextLooks.noLooks ELSE TextEdit.FetchLooks[txt,0];
pattern.searchLooks _ LooksRope[lks];
FOR i: INT IN [1..size) DO
IF TextEdit.FetchLooks[txt,i]#lks THEN {
OPEN MessageWindow;
Append["Search pattern does not have uniform looks.",TRUE];
Append["  Using looks from first char."];
EXIT };
ENDLOOP;
literal _ FALSE;
patternTxt _ TextEdit.FromRope["#*"];
TextEdit.SetLooks[NIL, patternTxt, lks];
};
pattern.text _ text;
pattern.looks _ looks;
pattern.word _ word;
pattern.looksExact _ ~subset;
pattern.commentControl _ IF ~comment OR txt=NIL THEN includeComments
ELSE IF txt.comment THEN commentsOnly ELSE excludeComments;
pattern.checkFormat _ format;
pattern.format _ IF target=NIL OR target.formatName=NIL THEN NIL ELSE
Atom.GetPName[target.formatName];
pattern.checkStyle _ style;
pattern.style _ IF ~style THEN NIL ELSE Atom.GetPName[NodeStyleOps.StyleNameForNode[target]];
IF text OR looks THEN { -- create a description of the pattern
pattern.finder _ TreeFind.Create[patternTxt, literal, word, ~looks, ~case, addBounds !
TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
};
IF error THEN ReportMalformedPattern[errorCode];
};

CreateSimplePattern: PUBLIC PROC [
target: ROPE, -- node from which to get the pattern
case: BOOL _ TRUE, -- if true, match case
literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
word: BOOL _ FALSE, -- if true, match words only
addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
RETURNS [pattern: Pattern] = {
error: BOOL _ FALSE;
errorCode: TextFind.PatternErrorCode;
pattern _ NEW[PatternRec];
pattern.text _ TRUE;
pattern.looks _ FALSE;
pattern.word _ word;
pattern.commentControl _ includeComments;
pattern.checkFormat _ FALSE;
pattern.format _ NIL;
pattern.checkStyle _ FALSE;
pattern.style _ NIL;
pattern.finder _ TreeFind.CreateFromRope[target, literal, word, ~case, addBounds !
TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
IF error THEN ReportMalformedPattern[errorCode];
};

FindCC: PROC [cc: CommentControl] RETURNS [TreeFind.CommentControl] = {
RETURN [SELECT cc FROM
includeComments => includeComments,
excludeComments => excludeComments,
commentsOnly => commentsOnly,
ENDCASE => ERROR] };

SelectionSearch: PUBLIC PROC [
pattern: Pattern, whichDir: SearchDir _ forwards, interrupt: REF BOOL _ NIL,
startBoundaryNode, endBoundaryNode: Ref _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL] = {
pSel: TEditDocument.Selection = TEditSelection.pSel;
Found: PROC [tSel: TEditDocument.Selection] = {
tSel.viewer _ pSel.viewer;
tSel.data _ pSel.data;
TEditOps.RememberCurrentPosition[pSel.viewer];
TEditSelection.SetSelLooks[tSel];
TEditSelection.MakeSelection[new: tSel];
TEditInput.CloseEvent[];
TEditRefresh.ScrollToEndOfSel[tSel.viewer, FALSE] };
Locations: PROC RETURNS [start, end: TextNode.Location] = {
start _ pSel.start.pos; end _ pSel.end.pos };
found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] };

DocLoc: PROC [loc: Location] RETURNS [TextNode.Location] = {
RETURN [[loc.node, loc.where]] };

MyLoc: PROC [loc: TextNode.Location] RETURNS [Location] = {
RETURN [[loc.node, loc.where]] };

NodeSearch: PUBLIC PROC [
pattern: Pattern, whichDir: SearchDir _ forwards,
startLoc, endLoc: Location, interrupt: REF BOOL _ NIL,
startBoundaryNode, endBoundaryNode: Ref _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL, start, end: Location] = {
Found: PROC [tSel: TEditDocument.Selection] = {
start _ MyLoc[tSel.start.pos]; end _ MyLoc[tSel.end.pos] };
Locations: PROC RETURNS [start, end: TextNode.Location] = {
start _ DocLoc[startLoc]; end _ DocLoc[endLoc] };
found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] };

DoSearch: PROC [
pattern: Pattern, whichDir: SearchDir _ forwards, interrupt: REF BOOL _ NIL,
foundProc: PROC [tSel: TEditDocument.Selection],
locationProc: PROC RETURNS [start, end: TextNode.Location],
startBoundaryNode, endBoundaryNode: Ref _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL] = {
at, atEnd, offset: INT;
first: TextNode.Ref;
where: TextNode.RefTextNode;
startLoc, endLoc: TextNode.Location;

DoLookForPattern: PROC [root: TextNode.Ref, tSel: TEditDocument.Selection] = {
Forwards: PROC = {
IF (offset _ endLoc.where+1) >=
TextEdit.Size[TextNode.NarrowToTextNode[first _ endLoc.node]] THEN {
first _ TextNode.StepForward[first]; offset _ 0 };
[found,where,at,atEnd,,] _
TreeFind.Try[finder: pattern.finder, first: first, start: offset,
last: endBoundaryNode, lastLen: endBoundaryOffset,
interrupt: interrupt,
looksExact: pattern.looksExact,
checkFormat: pattern.checkFormat,
format: MakeName[pattern.format],
commentControl: FindCC[pattern.commentControl],
checkStyle: pattern.checkStyle,
style: MakeName[pattern.style],
styleProc: NodeStyleOps.StyleNameForNode] };

Backwards: PROC = {
IF (offset _ startLoc.where)=0 THEN {
first _ TextNode.StepBackward[startLoc.node];
offset _ LAST[INT] }
ELSE first _ startLoc.node;
[found,where,at,atEnd,,] _
TreeFind.TryBackwards[finder: pattern.finder,
first: first, len: offset,
last: startBoundaryNode, lastStart: startBoundaryOffset,
interrupt: interrupt,
looksExact: pattern.looksExact,
checkFormat: pattern.checkFormat,
format: MakeName[pattern.format],
commentControl: FindCC[pattern.commentControl],
checkStyle: pattern.checkStyle,
style: MakeName[pattern.style],
styleProc: NodeStyleOps.StyleNameForNode] };

[startLoc, endLoc] _ locationProc[];
IF interrupt#NIL THEN interrupt^ _ FALSE;
SELECT whichDir FROM
forwards => Forwards[];
backwards => Backwards[];
anywhere => {
Forwards[];
IF found THEN whichDir _ forwards ELSE {
whichDir _ backwards; Backwards[] }};
ENDCASE => ERROR;
IF ~found OR where=NIL THEN RETURN;
IF pattern.looks AND ~pattern.text AND ~pattern.word THEN
[at,atEnd] _ Extend[whichDir=forwards,
pattern.looksExact, RopeToLooks[pattern.searchLooks], where, at, atEnd];
tSel.start.pos _ [where,at];
tSel.end.pos _ [where,MAX[0,atEnd-1]];
tSel.granularity _
IF ~pattern.looks AND ~pattern.text THEN node
ELSE IF pattern.word THEN word ELSE char;
tSel.insertion _ IF TEditProfile.selectionCaret=before THEN before ELSE after;
foundProc[tSel];
};

TEditInputOps.CallWithLocks[DoLookForPattern, read] };

Extend: PROC
[forward, looksExact: BOOL, searchLooks: TextLooks.Looks,
where: TextNode.RefTextNode, at, atEnd: INT,
last: TextNode.Ref _ NIL, lastLen: INT _ LAST[INT]]
RETURNS [newAt, newAtEnd: INT] = {
runrdr: RunReader.Ref _ RunReader.GetRunReader[];
looks: TextLooks.Looks;
runLen: INT;
runs: TextLooks.Runs _ where.runs;
IF forward THEN { -- extend toward end of node
size: INT ~ TextEdit.Size[where];
IF atEnd<size THEN {
lastLen _ IF where=last THEN MIN[size,lastLen] ELSE size;
RunReader.SetPosition[runrdr,runs,atEnd];
WHILE atEnd < lastLen DO
IF runs=NIL THEN { runLen _ size-atEnd; looks _ TextLooks.noLooks }
ELSE [runLen,looks] _ RunReader.Get[runrdr];
IF ~looksExact THEN looks _ TextLooksSupport.LooksAND[looks,searchLooks];
IF searchLooks # looks THEN EXIT;
atEnd _ atEnd+runLen;
ENDLOOP;
atEnd _ MIN[atEnd,lastLen];
};
}
ELSE IF at>0 THEN { -- extend backward
RunReader.SetPosition[runrdr,runs,at];
WHILE at > 0 DO
IF runs=NIL THEN { runLen _ at; looks _ TextLooks.noLooks }
ELSE [runLen,looks] _ RunReader.Backwards[runrdr];
IF ~looksExact THEN looks _ TextLooksSupport.LooksAND[looks,searchLooks];
IF searchLooks # looks THEN EXIT;
at _ at-runLen;
ENDLOOP;
};
RunReader.FreeRunReader[runrdr];
RETURN[at, atEnd];
};

SelectMatchingBrackets: PUBLIC PROC [before, after: CHAR] RETURNS [found: BOOL] = {
found _ TEditInputOps.DoSelectMatchingBrackets[before, after] };

NextPlaceholder: PUBLIC PROC [dir: Dir _ forward, gotoend: BOOL,
startBoundaryNode, endBoundaryNode: Ref _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found, wenttoend: BOOL] = {
[found, wenttoend] _ TEditInputOps.DoFindPlaceholders[
dir=forward, gotoend,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] };

NextViewer: PUBLIC PROC [dir: Dir _ forward] RETURNS [found: BOOL] = {
found _ TEditInputOps.DoNextViewer[dir=forward] };

SearchWhere: PROC [whichDir: SearchDir] RETURNS [TEditSelection.FindWhere] = INLINE {
RETURN [SELECT whichDir FROM
forwards => forwards,
backwards => backwards,
anywhere => anywhere,
ENDCASE => ERROR] };

Position: PUBLIC PROC [viewer: Viewer] = {
TEditSelection.Position[viewer];
};

Normalize: PUBLIC PROC [viewer: Viewer] = {
[] _ TEditInput.Normalize[viewer];
};

PrevPlace: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.JumpToPrevious[viewer];
};

Reselect: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Reselect[viewer];
};
Save: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Save[viewer];
};

Load: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL,
fileNameProcViewer: Viewer _ NIL] = {
[] _ TEditDocumentPrivate.DoLoadFile[viewer, fileName, FALSE, fileNameProcViewer];
};

Open: PUBLIC PROC [fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoOpenFile[fileName, fileNameProcViewer]];
};

CloseAndOpen: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoLoadFile[viewer, fileName, TRUE, fileNameProcViewer]];
};

LoadImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
[] _ TEditDocumentPrivate.DoLoadImplFile[viewer, fileName];
};

OpenImpl: PUBLIC PROC [fileName: ROPE _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoOpenImplFile[fileName]];
};

CloseAndOpenImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoCloseAndOpenImplFile[viewer, fileName]];
};

LoadPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.LoadPreviousFile[parent];
};

OpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.OpenPreviousFile[parent];
};

CloseAndOpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.CloseAndOpenPreviousFile[parent];
};

DefaultMenus: PUBLIC PROC [viewer: Viewer, paint: BOOL _ FALSE] = {
TEditDocumentPrivate.DefaultMenus[viewer, paint];
};

Store: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
TEditDocumentPrivate.DoStoreFile[viewer, fileName];
};

New: PUBLIC PROC RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoNewViewer[]];
};

Empty: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.EmptyViewer[viewer];
};

CloseAndNewViewer: PUBLIC PROC [viewer: Viewer] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoCloseAndNewViewer[viewer]];
};

Reset: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Reset[viewer];
};

Jump: PUBLIC PROC [viewer: Viewer, loc: Location] = {
[] _ TEditScrolling.ScrollToPosition[viewer, [loc.node, loc.where]];
};

FirstLevelOnly: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FirstLevelOnly[viewer] };

MoreLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.MoreLevels[viewer] };

FewerLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FewerLevels[viewer] };

AllLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.AllLevels[viewer] };

END.



άTiogaOps2Impl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
written by Bill Paxton. June 1982
last written by Paxton. December 30, 1982 11:13 am
Last Edited by: Maxwell, January 6, 1983 11:48 am
Russ Atkinson (RRA) January 23, 1986 0:02:15 am PST
Michael Plass, March 29, 1985 5:51:36 pm PST
Rick Beach, March 28, 1985 10:15:04 am PST
Doug Wyatt, April 14, 1985 7:58:45 pm PST
Search
Places menu commands
Files and text viewers
Levels menu commands
Κ”˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ!™!Kš
œ2™2K™1K™3K™,K™*K™)—K˜š
Οk	˜	Kšœžœ˜ Kšœžœ
˜Kšœ
žœ˜&Kšœžœ"žœ˜2Kšœ
žœA˜PKšœžœ
˜ Kšœžœ˜›KšœžœM˜]KšœžœM˜`Kšœ	žœ˜)Kšœ
žœ˜$Kšœ
žœ˜&Kšœžœ˜(Kšœžœ9˜MKšœ	žœ(˜6Kšœ	žœ&˜4Kšœžœ˜%Kšœ
žœ˜-Kšœžœ˜"Kšœ	žœQ˜_Kšœ
žœ˜Kšœ	žœ\˜jKšœ
žœ˜&Kšœ	žœ=˜K—K˜KšΠbl
œžœ
ž˜Kšžœδ
˜λ
Kšžœ%˜,šœžœ
žœ˜$K˜Kšžœžœžœ
˜KšœžœžœΟc˜3Kšœ
žœ
žœ˜&Kšœžœžœ˜Kšœžœ
žœ ˜6š
Οnœžœžœžœžœ˜+Jš
žœžœžœ
žœ
žœ˜5J˜——
headš
œ™š‘	œžœžœžœ˜>šžœžœ
žœž˜ Kšžœ
žœ&˜6Kš
ž˜—K˜K˜—š‘œžœžœžœ˜@Kš‘œžœžœžœžœžœžœ˜GK˜$K˜K˜—šœžœžœ˜QKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜—K˜Kšœžœ
žœžœ
˜=K˜š‘œžœ,˜HKš
œD˜DJšžœ˜#K˜K˜—š‘œžœ
žœ˜#Kšœ
 %˜2Kšœžœžœ ˜0Kšœžœžœ ˜3Kšœžœžœ ˜5Kšœžœžœ ˜3Kšœ	žœžœ )˜@Kšœžœžœ ˜)Kšœ	žœžœ ;˜RKšœžœžœ ˜0Kšœžœžœ 8˜MKšœžœžœ +˜DKšžœ˜Kšœžœžœ
˜Kš
œ%˜%Kš
œ>˜>Kš
œ'˜'Kšœ
žœ
˜šžœžœžœ 0˜JKšœžœ˜Kšœžœžœžœ˜XKš
œ%˜%šžœžœ
žœž˜šžœ žœ˜(Kšžœ˜Kšœ5žœ˜;Kš
œ)˜)Kšžœ˜—Kšžœ
˜—Kšœ
žœ
˜Kš
œ%˜%Kšœžœ˜(Kš
œ˜—Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š	œžœ
žœžœ
žœ˜DKšžœ
žœ
žœžœ˜;—Kš
œ˜šœžœžœ
žœžœ
žœ
žœ
ž˜EKš
œ!˜!—Kš
œ˜Kš	œžœžœ
žœ
žœ6˜]šžœžœžœ &˜>KšœŽ
žœžœ˜ 
Kš
œ˜—Kšžœžœ#˜0K˜K˜—š‘œžœ
žœ˜"Kšœžœ %˜3Kšœžœžœ ˜)Kšœ	žœžœ ;˜RKšœžœžœ ˜0Kšœžœžœ +˜DKšžœ˜Kšœžœžœ
˜Kš
œ%˜%Kšœ
žœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ)˜)Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜KšœŠ
žœžœ˜œ
Kšžœžœ#˜0K˜K˜—š‘œžœžœ˜Gšžœžœž˜Kš
œ#˜#Kš
œ#˜#Kš
œ˜Kšžœžœ˜K˜——š‘œžœ
žœ˜Kšœ=žœ
žœžœ
˜LKšœ*žœ
˜.Kš	œžœžœžœ
žœ˜AKšžœ	žœ˜K˜4š‘œžœ$˜/Kš
œ˜Kš
œ˜Kš
œ.˜.K˜!Kš
œ(˜(Kš
œ˜Kšœ+žœ˜4—š‘	œžœ
žœ$˜;Kš
œ-˜-—š
œ@˜@Kš
œ#˜#Kš
œ*˜*—K˜—š‘œžœžœ˜<Kšžœ˜!K˜—š‘œžœžœ˜;Kšžœ˜!K˜—š‘
œžœ
žœ˜Kš
œ1˜1Kšœ'žœ
žœžœ
˜6Kšœ*žœ
˜.Kš	œžœžœžœ
žœ˜AKšžœ	žœ˜/š‘œžœ$˜/Kš
œ;˜;—š‘	œžœ
žœ$˜;Kš
œ1˜1—š
œ@˜@Kš
œ#˜#Kš
œ*˜*—K˜—š‘œžœ˜Kšœ=žœ
žœžœ
˜LKšœžœ!˜0Kšœžœ
žœ!˜;Kšœ*žœ
˜.Kš	œžœžœžœ
žœ˜AKšžœ	žœ˜Kšœžœ
˜Kš
œ˜Kš
œ˜K˜$K˜š‘œžœ8˜Nš‘œžœ˜šžœ˜Kšœ>žœ˜DKš
œ2˜2—š
œ˜š
œA˜AKš
œ2˜2Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ!˜!Kš
œ/˜/Kš
œ˜Kš
œ˜Kš
œ,˜,———K˜š‘	œžœ˜šžœžœ˜%Kš
œ-˜-Kšœ	žœ
žœ˜—Kšžœ˜š
œ˜š
œ-˜-Kš
œ˜Kš
œ8˜8Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ!˜!Kš
œ/˜/Kš
œ˜Kš
œ˜Kš
œ,˜,———K˜K˜$Kšžœžœ
žœžœ
˜)šžœ
ž˜K˜K˜š
œ
˜
Kš
œ˜šžœžœžœ˜(Kš
œ%˜%——Kšžœžœ
˜—Kš
žœžœžœ
žœ
žœ
˜#šžœžœžœž˜9š
œ&˜&Kš
œH˜H——Kš
œ˜Kšœžœ
˜&š
œ˜Kšžœžœžœ˜-Kšžœ
žœžœžœ˜)—Kšœžœ$žœžœ˜NKš
œ˜Kš
œ˜—K˜Kš
œ6˜6K˜—š‘œž˜šœžœ˜9Kšœ(žœ
˜,Kš	œžœžœžœ
žœ˜3—Kšžœžœ˜"K˜1K˜Kšœžœ
˜K˜"šžœ	žœ ˜.Kšœžœ˜!šžœžœ˜Kš	œ
žœžœ
žœžœ˜9K˜)šžœž˜Kšžœžœ
žœ3˜CKšžœ(˜,Kšžœ
žœ6˜IKšžœžœ
žœ
˜!K˜Kšžœ
˜—Kšœžœ˜K˜—Kš
œ
˜
—šžœ
žœžœ ˜&K˜&šžœž˜Kšžœžœ
žœ+˜;Kšžœ.˜2Kšžœ
žœ6˜IKšžœžœ
žœ
˜!K˜Kšžœ
˜—K˜—Kš
œ ˜ Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœ	žœ˜SK˜@K˜—š‘œžœ
žœžœ
˜@Kšœ*žœ
˜.Kš	œžœžœžœ
žœ˜AKšžœžœ˜$š
œ6˜6Kš
œ˜Kš
œ#˜#Kš
œ*˜*—K˜—š
‘
œžœ
žœžœ	žœ˜FK˜2K˜—š‘œžœžœžœ˜Ušžœžœ
ž˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ˜K˜———š
œ™š‘œžœ
žœ˜*Kš
œ ˜ Kš
œ˜—K˜š‘	œžœ
žœ˜+Kš
œ"˜"Kš
œ˜—K˜š‘	œžœ
žœ˜+Kš
œ,˜,Kš
œ˜K˜—š‘œžœ
žœ˜*Kš
œ&˜&Kš
œ˜——š
œ™š‘œžœ
žœ˜&Kš
œ"˜"Kš
œ˜K˜—š
‘œžœ
žœžœžœ
˜8Kšœžœ˜%Kšœ7žœ˜RKš
œ˜K˜—š‘œžœ
žœžœžœžœ
žœ
˜_KšžœA˜GKš
œ˜K˜—š‘œžœ
žœžœžœžœ
žœ
˜wKšžœ4žœ˜UKš
œ˜K˜—š
‘œžœ
žœžœžœ˜@K˜;K˜K˜—š‘œžœ
žœžœžœžœ
˜AKšžœ1˜7Kš
œ˜K˜—š‘œžœ
žœžœžœ
žœ
˜YKšžœA˜GKš
œ˜K˜—š‘œžœ
žœ˜2Kš
œ.˜.Kš
œ˜—K˜š‘œžœ
žœ˜2Kš
œ.˜.Kš
œ˜—K˜š‘œžœ
žœ˜:Kš
œ6˜6Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜CKš
œ1˜1Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜=K˜3K˜K˜—š‘œžœ
žœ
žœ
˜%Kšžœ&˜,Kš
œ˜K˜—š‘œžœ
žœ˜'Kš
œ)˜)Kš
œ˜K˜—š‘œžœ
žœžœ
˜DKšžœ4˜:Kš
œ˜—K˜š‘œžœ
žœ˜'Kš
œ#˜#Kš
œ˜K˜—š‘œžœ
žœ$˜5Kš
œD˜DKš
œ˜——Lš
œ™˜Kš‘œžœ
žœ?˜ZK˜Kš‘
œžœ
žœ;˜RK˜Kš‘œžœ
žœ<˜TK˜Kš‘	œžœ
žœ:˜PK˜—Kšžœ
˜K˜K˜—…—<TOΔ