DIRECTORY
TiogaPathOps,
CreateNode USING [CreateInternalRep],
NodeProps,
TiogaLooks,
TiogaNode,
TiogaItemClass,
TiogaBasicClass,
TiogaNodeOps,
Rope,
RopeEdit;

TiogaPathOpsImpl: CEDAR PROGRAM
IMPORTS CreateNode, RopeEdit, NodeProps, TiogaNodeOps
EXPORTS TiogaPathOps
SHARES TiogaNode =

BEGIN OPEN TiogaPathOps;

ROPE: TYPE = Rope.ROPE;
RefBranchNode: TYPE = TiogaNode.RefBranchNode;
RefTextNode: TYPE = TiogaNode.RefTextNode;
RefBoxNode: TYPE = TiogaNode.RefBoxNode;
RefListNode: TYPE = TiogaNode.RefListNode;
Span: TYPE = TiogaNode.Span;

Parent: PUBLIC PROC [p: Path] RETURNS [Path] = { 
node: Ref;
DO
IF (node _ p.node)=NIL OR node.deleted THEN RETURN [nullPath];
UNTIL node.last DO node _ node.next; ENDLOOP;
IF node.next # NIL THEN RETURN [[node.next, p.path]];
IF p.path=NIL THEN RETURN [nullPath];
p _ p.path^; -- go back to the formal or the application and find parent of that
ENDLOOP };

GetTemplate: PROC [name, styleName: TiogaNode.Name] RETURNS [Ref] = {
RETURN [NIL] };

GetActualArg: PROC [formal: Path] RETURNS [Ref] = {
RETURN [NIL] };

GetStyleName: PROC [p: Path] RETURNS [styleName: TiogaNode.Name] = {
RETURN [TiogaNode.nullName] };

ConstructRefPath: PROC [p: Path] RETURNS [ref: REF Path] = {
IF p.path # NIL THEN RETURN [NEW[Path _ p]];
IF (ref _ NARROW[NodeProps.GetProp[p.node, $RefPath]])=NIL THEN -- create one
NodeProps.PutProp[p.node, $RefPath, ref _ NEW[Path _ p]];
RETURN [ref] };

GetTemplatePath: PROC [application: Path] RETURNS [template: Path] = {
RETURN [nullPath] };

GetArgPath: PROC [formal: Path] RETURNS [actual: Path] = {
RETURN [nullPath] };

Sib: PROC [p: Path] RETURNS [Path] = {
node: Ref;
DO
IF (node _ p.node)=NIL THEN RETURN [nullPath];
IF ~node.last THEN {
p _ [node.next, p.path];
RETURN [SELECT node.templateInfo FROM
normal => p,
application => GetTemplatePath[p],
formal => GetArgPath[p],
ENDCASE => ERROR] };
IF node.next # NIL OR p.path = NIL THEN RETURN [nullPath];
p _ p.path^; -- go back to the formal or the application and find Sib of that
ENDLOOP };

Contents: PUBLIC PROC [p: Path] RETURNS [Path] = BEGIN
node: Ref;
IF p.node=NIL THEN RETURN [nullPath];
WITH p.node SELECT FROM
br: RefBranchNode => { CheckInternalRep[br]; node _ br.contents };
bx: RefBoxNode => node _ bx.contents;
ls: RefListNode => node _ ls.contents;
ENDCASE => RETURN [nullPath];
IF node=NIL THEN RETURN [nullPath];
p _ [node, p.path];
RETURN [SELECT node.templateInfo FROM
normal => p,
application => GetTemplatePath[p],
formal => GetArgPath[p],
ENDCASE => ERROR];
END;

BranchChild: PUBLIC PROC [p: Path] RETURNS [Path] = BEGIN
n: RefBranchNode = TiogaNodeOps.NarrowToBranchNode[p.node];
node: RefBranchNode;
IF n=NIL THEN RETURN [nullPath];
CheckInternalRep[n];
IF (node _ n.child)=NIL THEN RETURN [nullPath];
CheckInternalRep[node];
p _ [node, p.path];
RETURN [SELECT node.templateInfo FROM
normal => p,
application => GetTemplatePath[p],
formal => GetArgPath[p],
ENDCASE => ERROR];
END;

Root: PUBLIC PROC [p: Path] RETURNS [Path] = { 
parent: Path;
DO
IF (parent_Parent[p]).node=NIL THEN RETURN [p];
p _ parent;
ENDLOOP };

Next: PUBLIC PROC [p: Path] RETURNS [nxt: Path] = {
nxt _ Sib[p];
WITH nxt.node SELECT FROM
br: RefBranchNode => CheckInternalRep[br];
ENDCASE };

FirstSibling: PUBLIC PROC [p: Path, parent: Path _ nullPath] RETURNS [sib: Path] = {
IF p.node=NIL THEN RETURN [nullPath];
IF parent.node=NIL THEN parent _ Parent[p];
IF parent.node=NIL THEN RETURN [nullPath];
RETURN [
IF TiogaNodeOps.IsBranch[p.node] AND TiogaNodeOps.IsBranch[parent.node] THEN BranchChild[parent]
ELSE Contents[parent]] };

LastSibling: PUBLIC PROC [p: Path] RETURNS [sib: Path] = {
IF p.node=NIL THEN RETURN [nullPath];
UNTIL (sib _ Sib[p]).node = NIL DO p _ sib; ENDLOOP;
WITH sib.node SELECT FROM
br: RefBranchNode => CheckInternalRep[br];
ENDCASE };

Previous: PUBLIC PROC [p: Path, parent: Path _ nullPath] RETURNS [sib: Path] = {
IF p.node=NIL THEN RETURN [nullPath];
IF (sib _ FirstSibling[p, parent])=p OR sib.node=NIL THEN RETURN [nullPath];
UNTIL InlineEqual[sib _ Sib[p], p] DO p _ sib; ENDLOOP;
WITH sib.node SELECT FROM
br: RefBranchNode => CheckInternalRep[br];
ENDCASE };

LastWithin: PUBLIC PROC [p: Path] RETURNS [Path] = {
nxt: Path;
DO
IF p.node=NIL THEN RETURN [nullPath];
IF ~TiogaNodeOps.IsBranch[p.node] OR (nxt _ BranchChild[p]).node=NIL THEN nxt _ Contents[p];
IF nxt.node=NIL THEN RETURN [p];
p _ LastSibling[nxt];
ENDLOOP };

Forward: PUBLIC PROC [p: Path] RETURNS [nx: Path, levelDelta: INTEGER] = {
fakeLevel: INTEGER = 100;
nxLevel: INTEGER;
[nx, nxLevel] _ ForwardClipped[p, LAST[INTEGER], fakeLevel];
RETURN [nx, nxLevel-fakeLevel] };

ForwardClipped: PUBLIC PROC [p: Path, maxLevel: INTEGER, nodeLevel: INTEGER _ 0]
RETURNS [nx: Path, nxLevel: INTEGER] = {
IF nodeLevel <= 0 THEN nodeLevel _ Level[p];
IF nodeLevel < maxLevel AND (nx _ BranchChild[p]).node # NIL THEN
RETURN [nx, nodeLevel+1]; -- return the child
IF ~TiogaNodeOps.IsBranch[p.node] THEN RETURN [nullPath, 0];
DO -- move to next node, sibling or up* then sibling
IF (nx _ Next[p]).node # NIL THEN RETURN;
IF (p _ Parent[p]).node = NIL THEN RETURN [nullPath, 0]; -- move to the parent
nodeLevel _ nodeLevel-1;
ENDLOOP };

StepForwardNode: PUBLIC PROC [p: Path] RETURNS [nx: Path] = {
IF p.node=NIL THEN RETURN [nullPath];
nx _ Contents[p];
IF nx.node=NIL AND TiogaNodeOps.IsBranch[p.node] THEN nx _ BranchChild[p];
IF nx.node # NIL THEN RETURN; -- descend in the tree
DO
IF (nx _ Next[p]).node # NIL THEN RETURN;
IF (nx _ Parent[p]).node = NIL THEN RETURN [nullPath];
IF ~TiogaNodeOps.IsBranch[p.node] AND TiogaNodeOps.IsBranch[nx.node] AND (p _ BranchChild[nx]).node # NIL THEN
RETURN [p]; -- have visited contents of this branch; now visit children
p _ nx; -- move to the parent
ENDLOOP };

Backward: PUBLIC PROC [p: Path, parent: Path _ nullPath]
RETURNS [back: Path, backparent: Path, levelDelta: INTEGER] = {
backLevel: INTEGER;
fakeLevel: INTEGER = 100;
[back, backparent, backLevel] _ BackwardClipped[p, LAST[INTEGER], parent, fakeLevel];
RETURN [back, backparent, backLevel-fakeLevel] };

BackwardClipped: PUBLIC PROC [
p: Path, maxLevel: INTEGER, parent: Path _ nullPath, nodeLevel: INTEGER _ 0]
RETURNS [back: Path, backparent: Path, backLevel: INTEGER] = {
child, child2: Path;
IF parent.node=NIL THEN parent _ Parent[p];
IF parent.node=NIL OR ~TiogaNodeOps.IsBranch[p.node] THEN RETURN [nullPath, nullPath, 0];
IF nodeLevel <= 0 THEN nodeLevel _ Level[p];
IF (child _ Previous[p, parent]).node=NIL THEN -- p is first following parent
IF ~TiogaNodeOps.IsBranch[parent.node] THEN RETURN [nullPath, nullPath, 0]
ELSE RETURN [parent, Parent[parent], nodeLevel-1];
DO -- go deeper in tree until reach maxLevel
IF nodeLevel >= maxLevel OR (child2 _ BranchChild[child]).node = NIL THEN
RETURN [child, parent, nodeLevel];
nodeLevel _ nodeLevel+1;
parent _ child; child _ LastSibling[child2]; ENDLOOP };

StepBackwardNode: PUBLIC PROC [p: Path, parent: Path _ nullPath]
RETURNS [back, backparent: Path] = {
child, child2: Path;
IF parent.node=NIL THEN parent _ Parent[p];
IF parent.node=NIL OR p.node=NIL THEN RETURN [nullPath, nullPath];
IF (child _ Previous[p, parent]).node=NIL THEN RETURN [parent, Parent[parent]];
DO -- find last node within predecessor
IF ~TiogaNodeOps.IsBranch[child.node] OR (child2 _ BranchChild[child]).node=NIL THEN
child2 _ Contents[child];
IF child2.node=NIL THEN RETURN [child, parent];
parent _ child; child _ LastSibling[child2]; ENDLOOP };

Equal: PUBLIC PROC [p1, p2: Path] RETURNS [yes: BOOL] = { RETURN [InlineEqual[p1, p2]] };

InlineEqual: PROC [p1, p2: Path] RETURNS [yes: BOOL] = INLINE BEGIN
DO
IF p1.node # p2.node THEN RETURN [FALSE];
IF p1.path = p2.path THEN RETURN [TRUE];
IF p1.path = NIL OR p2.path = NIL THEN RETURN [FALSE];
p1 _ p1.path^; p2 _ p2.path^;
ENDLOOP;
END;

Level: PUBLIC PROC [p: Path] RETURNS [level: INTEGER] = {
level _ 0;  UNTIL (p _ Parent[p]).node=NIL DO level _ level+1; ENDLOOP };

BackLoc: PUBLIC PROC [loc: Location] RETURNS [new: Location] = {
text: RefTextNode;
new.path _ StepBackwardNode[loc.path].back;
new.where _ IF loc.where=TiogaNode.NodeItself OR (text _ TiogaNodeOps.NarrowToTextNode[new.path.node])=NIL
THEN TiogaNode.NodeItself ELSE RopeEdit.Size[text.rope] };

ForwardLoc: PUBLIC PROC [loc: Location] RETURNS [new: Location] = {
new.path _ StepForwardNode[loc.path];
new.where _ IF loc.where=TiogaNode.NodeItself OR TiogaNodeOps.NarrowToTextNode[new.path.node]=NIL
THEN TiogaNode.NodeItself ELSE 0 };

LastLocWithin: PUBLIC PROC [p: Path] RETURNS [Location] = {
last: Path = LastWithin[p];
lastText: RefTextNode = TiogaNodeOps.NarrowToTextNode[last.node];
where: Offset = IF lastText # NIL THEN RopeEdit.Size[lastText.rope] ELSE TiogaNode.NodeItself;
RETURN [[last,where]] };

BadArgs: PUBLIC ERROR = CODE;

LocNumber: PUBLIC PROC [at: Location, break: NAT _ 1, skipCommentNodes: BOOL _ FALSE]
RETURNS [count: Offset] = { RETURN [LocOffset[[Root[at.path],0],at,break,skipCommentNodes]] };
LocOffset: PUBLIC PROC [loc1, loc2: Location,
break: NAT _ 1, skipCommentNodes: BOOL _ FALSE] RETURNS [count: Offset] = {
path: Path _ loc2.path;
p: Path _ loc1.path;
txt: RefTextNode;
count _ IF loc2.where # TiogaNode.NodeItself THEN loc2.where ELSE 0;
count _ count - MAX[loc1.where,0];
DO -- add in counts for text nodes before location
IF InlineEqual[p, path] THEN RETURN;
IF p.node=NIL THEN ERROR BadArgs;
txt _ TiogaNodeOps.NarrowToTextNode[p.node];
IF txt # NIL AND (~skipCommentNodes OR ~txt.comment) THEN
count _ count+RopeEdit.Size[txt.rope]+break;
p _ StepForwardNode[p];
ENDLOOP };

LocRelative: PUBLIC PROC [location: Location, count: Offset,
break: NAT _ 1, skipCommentNodes: BOOL _ FALSE] RETURNS [Location] = {
p: Path _ location.path;
size, lastWhere, where: Offset;
last: Path _ p;
IF count=0 AND Parent[p].node=NIL THEN -- avoid returning root node
RETURN [[BranchChild[p],0]]; -- return first child of root instead
lastWhere _ where _ MAX[location.where,0]; -- where we are in the current node
WHILE p.node # NIL DO
txt: RefTextNode _ TiogaNodeOps.NarrowToTextNode[p.node];
IF txt # NIL AND (~skipCommentNodes OR ~txt.comment) THEN {
lastWhere _ size _ RopeEdit.Size[txt.rope];
IF (count _ count-(size-where)) <= 0 THEN RETURN [[p,MAX[0,count+size]]];
count _ count-break; last _ p };
p _ StepForwardNode[p];
where _ 0;
ENDLOOP;
RETURN [[last,lastWhere]] };

CheckInternalRep: PROC [br: TiogaNode.RefBranchNode] = INLINE {
IF ~br.internalRepCreated THEN CreateNode.CreateInternalRep[br] };

Apply: PUBLIC PROC [span: Span, proc: ApplyProc] = {
path, last: Path;
start, lastLen: Offset;
IF (path _ span.start.path).node = NIL THEN RETURN;
IF (last _ span.end.path).node = NIL THEN RETURN;
IF (start _ span.start.where)=TiogaNode.NodeItself THEN start _ 0;
IF span.end.where=TiogaNode.NodeItself THEN lastLen _ LAST[Offset]
ELSE IF span.end.where=LAST[Offset] THEN lastLen _ LAST[Offset]
ELSE { lastLen _ span.end.where+1; IF Equal[path, last] THEN lastLen _ lastLen-start };
DO
lastOne: BOOL = Equal[path, last];
IF proc[path, start, IF lastOne THEN lastLen ELSE LAST[Offset]] THEN RETURN;
IF lastOne OR (path _ StepForwardNode[path]).node=NIL THEN RETURN;
start _ 0;
ENDLOOP;
};

END.


TiogaPathOpsImpl.mesa; Written by Paxton, July 1983
Edited by Paxton, August 16, 1983 1:17 pm
If p points to root of template or actual arg, Parent returns parent of corresponding application or formal arg.
If path is of form [node, NIL], then save ref to it away on node's property list since can reuse it.
Could consider doing this for case in which p.path # NIL if take care to avoid hanging onto ref's to nodes that have been deleted.
name: TiogaNode.Name = NodeProps.GetTemplateName[node];
styleName: TiogaNode.Name = GetStyleName[p];
templateNode: Ref _ GetTemplate[name, styleName];
refApplicationPath: REF Path = ConstructRefPath[application];
save back pointer with template to application
RETURN [[templateNode, refApplicationPath]] };
Must take care of case in which actual parameter is an application or a formal.  Keep going until find a normal node.
This is like Next but doesn't create internal rep for branches
If p points to root of template or actual arg, Sib returns sibling of corresponding application or formal arg.
Returns p if p is the first sibling
Returns p if p is the last sibling
Returns NIL if p=FirstSibling[p]
returns next branch in standard tree walk order
like Forward, but limits how deep will go in tree
if pass nodeLevel=0, correct value will be computed 
nxLevel = Level[nx] <= MAX[maxLevel,Level[node]]
returns next node in standard tree walk order; visits branch contents before branch children
The previous node is not a branch, but its parent is.
This implies that previous node was last of branch contents since child of branch must be a branch.
returns preceeding node in standard tree walk order
like Backward, but limits how deep will go in tree
backLevel = Level[back] <= MAX[maxLevel,Level[node]]

returns character offset of location2 relative to location1
�Ê”˜Jš
œ3™3Jš
œ)™)J˜š
Ïk	˜	J˜
Jšœ�œ˜%J˜
J˜J˜
Jš
œ˜Jš
œ˜J˜
J˜Jš
œ	˜	—J˜šœ�œ
�˜Jš�œ.˜5Jš�œ
˜Jš�œ˜—J˜Jš�œ
�œ˜J˜Jš�œ�œ�œ
˜Jšœ�œ˜.Jšœ
�œ˜*Jšœ�œ˜(Jšœ
�œ˜*šœ�œ˜J˜—šÏnœ�œ
�œ�œ˜1J™pJš
œ
˜
š
�˜Jš
�œ�œ
�œ�œ
�œ˜>Jš�œ�œ�œ
˜-Jš�œ
�œ
�œ
�œ˜5Jš�œ�œ
�œ
�œ˜%Jšœ
ÏcC˜PJš�œ˜
—J˜—šžœ�œ#�œ
˜EJš�œ�œ˜J˜—šžœ�œ�œ
˜3Jš�œ�œ˜J˜—šžœ�œ�œ ˜DJš�œ˜J˜—šžœ�œ�œ�œ
˜<šœ�œG™dJ™‚
—Jš
�œ
�œ
�œ
�œ�œ˜,š	�œ�œ'�œ
�œ
Ÿ
˜MJšœ*�œ˜9—Jš�œ	˜J˜—šžœ�œ�œ˜FJ™7J™,Jš
œ1™1Jš
œ=™=J™.Jš
œ.™.Jš�œ˜J˜—šž
œ�œ�œ˜:J™uJš�œ˜J˜—šžœ�œ�œ˜&J™>J™nJ˜
š
�˜Jš�œ�œ
�œ
�œ˜.š�œ�œ˜Jš
œ˜š�œ�œ�˜%Jš
œ˜Jš
œ"˜"Jš
œ˜Jš�œ�œ˜——Jš�œ
�œ
�œ
�œ
�œ
�œ˜:Jšœ
Ÿ@˜MJš�œ˜
—J˜—š	žœ�œ
�œ�œ
�˜6J˜
Jš�œ�œ
�œ
�œ˜%š�œ�œ
�˜Jš
œB˜BJš
œ%˜%Jš
œ&˜&Jš�œ�œ˜—Jš�œ�œ
�œ
�œ˜#Jš
œ˜š�œ�œ�˜%Jš
œ˜Jš
œ"˜"Jš
œ˜Jš�œ�œ˜—Jš�œ
˜J˜—š	žœ�œ
�œ�œ
�˜9J˜;J˜Jš�œ�œ
�œ
�œ˜ Jš
œ˜Jš�œ�œ
�œ
�œ˜/Jš
œ˜Jš
œ˜š�œ�œ�˜%Jš
œ˜Jš
œ"˜"Jš
œ˜Jš�œ�œ˜—Jš�œ
˜J˜—šžœ�œ
�œ�œ˜/Jš
œ
˜
š
�˜Jš�œ�œ
�œ
�œ˜/Jš
œ˜Jš�œ˜
—J˜—šžœ�œ
�œ�œ˜3J˜
š�œ
�œ
�˜Jš
œ*˜*Jš�œ˜
—J˜—šžœ�œ
�œ$�œ˜TJ™#Jš�œ�œ
�œ
�œ˜%Jš�œ
�œ
�œ˜+Jš�œ
�œ
�œ
�œ˜*š�œ˜Jš�œ�œ$�œ˜`Jš�œ˜—J˜—šžœ�œ
�œ�œ˜:J™"Jš�œ�œ
�œ
�œ˜%Jš�œ�œ
�œ
�œ
˜4š�œ
�œ
�˜Jš
œ*˜*Jš�œ˜
—J˜—šžœ�œ
�œ$�œ˜PJšœ�œ™ Jš�œ�œ
�œ
�œ˜%Jš
�œ#�œ
�œ
�œ
�œ˜LJš�œ�œ
�œ
˜7š�œ
�œ
�˜Jš
œ*˜*Jš�œ˜
—J˜—šž
œ�œ
�œ�œ˜4Jš
œ
˜
š
�˜Jš�œ�œ
�œ
�œ˜%Jš�œ �œ�œ
�œ˜\Jš�œ
�œ
�œ
�œ˜ J˜Jš�œ˜
J˜——š
žœ�œ
�œ�œ�œ˜JJš
œ/™/Jšœ�œ˜Jšœ	�œ
˜Jšœ"�œ
�œ˜<š�œ˜!J˜——š
žœ�œ
�œ�œ
�œ˜PJš�œ�œ˜(Jš
œ1™1Jš
œ4™4Jš
œ0™0Jš�œ�œ˜,š�œ�œ�œ
�˜AJš�œŸ˜-—Jš�œ �œ
�œ˜<š�œ
Ÿ1˜4Jš�œ�œ
�œ
�œ
˜)Jš	�œ�œ
�œ
�œŸ˜NJ˜Jš�œ˜
J˜——šžœ�œ
�œ�œ˜=Jš
œ\™\Jš�œ�œ
�œ
�œ˜%Jš
œ˜Jš�œ	�œ
�œ�œ˜JJš	�œ�œ
�œ
�œŸ˜4š
�˜Jš�œ�œ
�œ
�œ
˜)Jš�œ�œ
�œ
�œ˜6š	�œ �œ �œ�œ
�˜nJš�œŸ;˜GJ™5J™c—JšœŸ˜Jš�œ˜
J˜——šžœ�œ
�œ#˜8Jš�œ,�œ˜?Jš
œ3™3Jšœ�œ
˜Jšœ�œ˜Jšœ3�œ
�œ˜Uš�œ+˜1J˜——šžœ�œ
�œ˜Jšœ�œ&�œ˜LJš�œ+�œ˜>Jš
œ2™2Jš
œ4™4Jš
œ˜Jš�œ
�œ
�œ˜+Jš
�œ
�œ
�œ �œ
�œ˜YJš�œ�œ˜,š�œ$�œ
�œ
Ÿ˜MJš�œ%�œ
�œ˜JJš�œ
�œ'˜2—š�œ
Ÿ)˜,š�œ�œ&�œ
�˜IJš�œ˜"—J˜Jšœ�
œ�œ˜7J˜——šžœ�œ
�œ#˜@Jš�œ˜$Jš
œ˜Jš�œ
�œ
�œ˜+Jš�œ
�œ
�œ�œ
�œ
�œ˜BJš�œ$�œ
�œ
�œ˜Oš�œ
Ÿ$˜'š�œ$�œ$�œ
�˜TJš
œ˜—Jš�œ
�œ
�œ
�œ˜/Jšœ,�œ˜7J˜——šžœ�œ
�œ�œ�œ�œ˜YJ˜—š	žœ�œ�œ�œ�˜Cš
�˜Jš�œ�œ
�œ�œ˜)Jš�œ�œ
�œ�œ˜(Jš�œ�œ
�œ�œ
�œ
�œ�œ˜6J˜Jš�œ
˜—Jš�œ
˜J˜—š
žœ�œ
�œ�œ	�œ˜9Jš	œ�œ�œ
�œ�œ˜IJ˜—šžœ�œ
�œ�œ˜@J˜J˜+šœ�œ �œ7�˜jJš�œ�œ˜:J˜——šž
œ�œ
�œ�œ˜CJ˜%šœ�œ �œ.�˜aJš�œ�œ˜#—J˜—šž
œ�œ
�œ�œ˜;Jš
œ˜Jš
œA˜AJš	œ�œ�œ
�œ�œ˜^Jš�œ˜J˜—šœ	�œ
�œ�œ
˜J˜—šž	œ�œ
�œ�œ�œ�œ
˜UJš�œ�œ<˜^J™—šž	œ�œ
�œ˜-Jš	œ�œ�œ�œ�œ˜KJš
œ;™;Jš
œ˜Jš
œ˜J˜Jšœ�œ#�œ�œ˜DJšœ�œ˜"š�œ
Ÿ/˜2Jš�œ�œ
�œ
˜$Jš�œ�œ
�œ
�œ	˜!Jš
œ,˜,š	�œ�œ
�œ�œ�˜9J˜,—Jš
œ˜Jš�œ˜
J˜——šžœ�œ
�œ$˜<Jš	œ�œ�œ�œ�œ˜FJš
œ˜Jš
œ˜Jš
œ˜š	�œ	�œ�œ
�œ
Ÿ˜CJš�œŸ%˜B—Jšœ�œŸ#˜Nš�œ
�œ
�˜Jš
œ9˜9š
�œ�œ
�œ�œ�œ˜;Jš
œ+˜+Jš�œ#�œ
�œ�œ˜IJ˜ —Jš
œ˜J˜
Jš�œ
˜—Jš�œ˜J˜—šžœ�œ!�œ˜?Jš�œ�œ$˜BJ˜—šžœ�œ
�œ"˜4J˜J˜Jš�œ!�œ
�œ
�œ
˜3Jš�œ�œ
�œ
�œ
˜1Jš�œ1�œ˜BJš�œ%�œ�œ˜BJš
�œ
�œ�œ	�œ�œ˜?Jš�œ�œ�œ˜Wš
�˜Jšœ	�œ˜"Jš�œ�œ	�œ	�œ
�œ
�œ
�œ
˜LJš
�œ	�œ%�œ
�œ
�œ
˜BJš
œ
˜
Jš�œ
˜—š
œ˜J˜——Jš�œ
˜J˜J˜—…—+pB