DIRECTORY IO, IOUtils, Rope, TextNode, TiogaFileOps, TiogaOps, TiogaStreams;

TiogaStreamsImpl: CEDAR PROGRAM
IMPORTS IO, IOUtils, Rope, TN: TextNode, TFO: TiogaFileOps, TiogaOps
EXPORTS TiogaStreams =

BEGIN

ROPE: TYPE = Rope.ROPE;
CommentHandling: TYPE = TiogaStreams.CommentHandling;
DepthOp: TYPE = TiogaStreams.DepthOp;

IsATS: PUBLIC PROC [s: IO.STREAM] RETURNS [is: BOOLEAN] =
{is _
s # NIL AND
s.streamData # NIL AND
(
ISTYPE[s.streamData, TiogaInStreamData] OR
ISTYPE[s.streamData, TiogaOutStreamData]);
};

CreateInput: PUBLIC PROC [from: TN.Ref, commentHandling: CommentHandling _ discard, levelPrefix: ROPE _ NIL] RETURNS [in: IO.STREAM] =
BEGIN
sd: TiogaInStreamData _ NEW [TiogaInStreamDataRep _ [
commentHandling: commentHandling,
levelPrefix: levelPrefix,
node: NIL,
root: from
]];
GoToBeginning[sd];
in _ IO.CreateStream[streamProcs: tiogaInStreamProcs, streamData: sd];
END;

GoToBeginning: PROC [sd: TiogaInStreamData] = {
dd: INT;
IF sd.root = NIL THEN {sd.end _ TRUE; RETURN};
[sd.node, dd] _ TN.Forward[sd.root];
IF sd.node = NIL THEN {sd.end _ TRUE; RETURN};
SELECT dd FROM
<1 => {sd.end _ TRUE; RETURN};
=1 => {
sd.end _ FALSE;
sd.depth _ 1;
sd.indexAtNodeStart _ 0;
NodeHello[sd];
};
ENDCASE => ERROR;
};

tiogaInStreamProcs: REF IO.StreamProcs _ IO.CreateStreamProcs[variety: input, class: $TiogaInStream, getChar: GetChar, endOf: EndOf, backup: BackupIn, getIndex: GetInIndex, setIndex: SetInIndex];

GetChar: PROC [self: IO.STREAM] RETURNS [char: CHAR] =
BEGIN
sd: TiogaInStreamData _ NARROW[self.streamData];
TryForNextChar[sd];
IF sd.end THEN ERROR IO.EndOfStream[self];
char _ sd.nodeRope.Fetch[sd.next];
sd.next _ sd.next + 1;
sd.index _ sd.index + 1;
END;

EndOf: PROC [self: IO.STREAM] RETURNS [end: BOOLEAN] =
BEGIN
sd: TiogaInStreamData _ NARROW[self.streamData];
TryForNextChar[sd];
end _ sd.end;
END;

BackupIn: PROC [self: IO.STREAM, char: CHAR] = {
past: INT _ self.GetIndex[];
oldChar: CHAR;
IF past = 0 THEN ERROR IO.Error[IllegalBackup, self];
self.SetIndex[past-1];
oldChar _ self.GetChar[];
IF oldChar # char THEN ERROR IO.Error[IllegalBackup, self];
self.SetIndex[past-1];
};

GetInIndex: PROC [self: IO.STREAM] RETURNS [index: INT] = {
sd: TiogaInStreamData _ NARROW[self.streamData];
index _ sd.index;
};

SetInIndex: PROC [self: IO.STREAM, index: INT] = {
sd: TiogaInStreamData _ NARROW[self.streamData];
local: INT;
TryForNextChar[sd];
local _ index - sd.indexAtNodeStart;
IF local IN [0 .. sd.nodeLen]
THEN {
sd.next _ local;
sd.index _ index;
sd.end _ FALSE; --well, what this really means is that we don't yet know that it's at the end
}
ELSE {
GoToBeginning[sd];
sd.next _ sd.index _ index;
};
};

CurInNode: PUBLIC PROC [s: IO.STREAM] RETURNS [n: TN.Ref] = {
sd: TiogaInStreamData _ NARROW[s.streamData];
TryForNextChar[sd];
n _ sd.node;
};

SkipChildren: PUBLIC PROC [s: IO.STREAM] = {
sd: TiogaInStreamData = NARROW[s.streamData];

Work: PROC [of: TN.Ref] RETURNS [next: TN.Ref, dd, di: INT] = {
rawSize: INT = TN.NodeRope[of].Length[];
di _ IF NOT of.comment
THEN rawSize+1
ELSE SELECT sd.commentHandling FROM
discard => 0,
useDirectly => rawSize+1,
prefixWithDashDash => rawSize+3,
ENDCASE => ERROR;
[next, dd] _ TN.Forward[of];
IF dd > 1 THEN ERROR;
IF dd < 1 THEN RETURN;
dd _ dd - 1;
WHILE dd = 0 DO
ddi: INT;
[next, dd, ddi] _ Work[next];
di _ di + ddi;
ENDLOOP;
dd _ dd + 1;
};

new: TN.Ref;
dd, di, newStart: INT;
TryForNextChar[sd];
[new, dd, di] _ Work[sd.node];
newStart _ sd.indexAtNodeStart + di;
IF newStart < sd.index THEN ERROR;
sd.index _ newStart;
IF sd.depth+dd <= 0 OR new = NIL THEN {sd.end _ TRUE; RETURN};
sd.node _ new;
sd.indexAtNodeStart _ newStart;
sd.depth _ sd.depth + dd;
sd.next _ 0;
NodeHello[sd];
};

TiogaInStreamData: TYPE = REF TiogaInStreamDataRep;
TiogaInStreamDataRep: TYPE = RECORD [
commentHandling: CommentHandling,
end: BOOLEAN _ FALSE,
next, nodeLen, depth: INT _ 0,
indexAtNodeStart, index: INT _ 0,
nodeRope: ROPE _ NIL,
levelPrefix: ROPE,
node, root: TN.Ref];

TryForNextChar: PROC [sd: TiogaInStreamData] =
BEGIN
IF sd.end THEN RETURN;
WHILE sd.next >= sd.nodeLen DO
dd: INT;
next: TN.Ref;
[next, dd] _ TN.Forward[sd.node];
IF sd.depth+dd <= 0 OR next = NIL THEN {sd.end _ TRUE; RETURN};
sd.next _ sd.next - sd.nodeLen;
sd.depth _ sd.depth + dd;
sd.indexAtNodeStart _ sd.indexAtNodeStart + sd.nodeLen;
sd.node _ next;
NodeHello[sd];
ENDLOOP;
END;

NodeHello: PROC [sd: TiogaInStreamData] =
BEGIN
tn: TN.RefTextNode _ sd.node;
Use: PROC [prefix: ROPE] = {
sd.nodeRope _ TN.NodeRope[tn].Concat["\n"];
IF prefix # NIL THEN sd.nodeRope _ prefix.Concat[sd.nodeRope];
IF sd.levelPrefix.Length[] # 0 THEN THROUGH [1 .. sd.depth) DO
sd.nodeRope _ sd.levelPrefix.Concat[sd.nodeRope];
ENDLOOP;
sd.nodeLen _ sd.nodeRope.Length[];
};
IF tn.comment
THEN SELECT sd.commentHandling FROM
discard => {
sd.nodeRope _ NIL;
sd.nodeLen _ 0;
};
useDirectly => Use[NIL];
prefixWithDashDash => Use["--"];
ENDCASE => ERROR
ELSE Use[NIL];
END;

CreateOutput: PUBLIC PROC [to: TFO.Ref, breakAtNewline: BOOL _ FALSE, levelPrefix, defaultFormat: ROPE _ NIL] RETURNS [out: IO.STREAM] =
BEGIN
sd: TiogaOutStreamData _ NEW [TiogaOutStreamDataRep _ [
breakAtNewline: breakAtNewline,
parsePrefix: levelPrefix # NIL,
levelPrefix: levelPrefix,
root: to,
nodes: LIST[to],
lpLength: levelPrefix.Length[],
nextDepth: 1,
defaultFormat: defaultFormat
]];
pfp: IOUtils.PFProcs;
out _ IO.CreateStream[streamProcs: tiogaOutStreamProcs, streamData: sd];
pfp _ IOUtils.CopyPFProcs[out];
[] _ IOUtils.SetPFCodeProc[pfProcs: pfp, char: 'l, codeProc: FormatL];
[] _ IOUtils.SetPFProcs[stream: out, pfProcs: pfp];
PrepareForChar[out, sd];
END;

tiogaOutStreamProcs: REF IO.StreamProcs _ IO.CreateStreamProcs[variety: output, class: $TiogaOutStream, putChar: PutChar, putBlock: PutBlock, close: CloseOut];

PutChar: PROC [self: IO.STREAM, char: CHAR] =
BEGIN
sd: TiogaOutStreamData _ NARROW[self.streamData];
SELECT TRUE FROM
sd.breakAtNewline AND char = '\n => EndNode[self, reset, FALSE];
sd.parsePrefix AND (NOT sd.ready) AND char = sd.levelPrefix.Fetch[sd.lpCharsSeen] => {
sd.lpCharsSeen _ sd.lpCharsSeen + 1;
IF sd.lpCharsSeen = sd.lpLength THEN {
sd.lpCharsSeen _ 0;
sd.nextDepth _ sd.nextDepth + 1;
};
};
ENDCASE => {
PrepareForChar[self, sd];
sd.contents _ sd.contents.Concat[Rope.FromChar[char]];
};
END;

PutBlock: PROC [self: IO.STREAM, block: REF READONLY TEXT, startIndex, count: NAT] =
BEGIN
sd: TiogaOutStreamData _ NARROW[self.streamData];
next: NAT _ startIndex;
afterLast: NAT _ startIndex + count;
WHILE next < afterLast DO
nextCR, subsize: NAT;
WHILE (NOT sd.ready) OR block[next] = '\n DO
PutChar[self, block[next]];
next _ next + 1;
IF next >= afterLast THEN RETURN;
ENDLOOP;
FOR nextCR _ next, nextCR + 1 WHILE nextCR < afterLast AND block[nextCR] # '\n DO NULL ENDLOOP;
IF (subsize _ nextCR - next) # 0 THEN {
sd.contents _ sd.contents.Concat[RopeFromSubText[block, next, subsize]];
next _ nextCR;
};
ENDLOOP;
END;

CloseOut: PROC [self: IO.STREAM, abort: BOOL _ FALSE] =
BEGIN
EndNode[self];
IOUtils.AmbushStream[self: self, streamProcs: IOUtils.closedStreamProcs, streamData: NIL];
END;

CurOutNode: PUBLIC PROC [s: IO.STREAM] RETURNS [n: TFO.Ref] =
BEGIN
sd: TiogaOutStreamData _ NARROW[s.streamData];
n _ sd.nodes.first;
END;

SetFormat: PUBLIC PROC [of: IO.STREAM, format: ROPE] =
BEGIN
n: TFO.Ref _ CurOutNode[of];
TFO.SetFormat[n, format];
END;

FormatL: PROC [stream: IO.STREAM, val: IO.Value, format: IOUtils.Format, char: CHAR] = {
sd: TiogaOutStreamData _ NARROW[stream.streamData];
PrepareForChar[stream, sd];
WITH val SELECT FROM
rv: IO.Value[rope] => LooksWork[stream, sd, rv.value];
ENDCASE => ERROR IO.Error[PFUnprintableValue, stream];
};

LooksWork: PROC [stream: IO.STREAM, sd: TiogaOutStreamData, chars: ROPE] = {
index: INT _ sd.contents.Length[];
FOR i: INT IN [0 .. chars.Length[]) DO
c: CHAR _ chars.Fetch[i];
SELECT c FROM
'  => LooksWork[stream, sd, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"];
IN ['a .. 'z] => {
IF sd.looks[c] = NIL OR sd.looks[c].first.afterLast # notClosed THEN sd.looks[c] _ CONS[[first: index, afterLast: notClosed], sd.looks[c]]
};
IN ['A .. 'Z] => {l: Look _ c + ('a - 'A);
IF sd.looks[l] # NIL AND sd.looks[l].first.afterLast = notClosed THEN sd.looks[l].first.afterLast _ index;
};
ENDCASE => ERROR IO.Error[PFUnprintableValue, stream];
ENDLOOP;
};

EndNode: PUBLIC PROC [s: IO.STREAM, depthOp: DepthOp _ reset, idempotently: BOOLEAN _ FALSE] =
BEGIN
sd: TiogaOutStreamData _ NARROW[s.streamData];
IF NOT sd.ready THEN
BEGIN
IF idempotently THEN RETURN;
PrepareForChar[s, sd];
END;
TFO.SetContents[sd.nodes.first, sd.contents];
SetLooks[sd];
sd.ready _ FALSE;
sd.lpCharsSeen _ 0;
sd.contents _ NIL;
sd.nextDepth _ SELECT depthOp FROM
same => sd.userDepth,
reset => 1,
ENDCASE => ERROR;
END;

SetLooks: PROC [sd: TiogaOutStreamData] = {
len: INT _ sd.contents.Length[];
FOR l: Look IN Look DO
FOR lr: LooksRuns _ sd.looks[l], lr.rest WHILE lr # NIL DO
afterLast: INT _ IF lr.first.afterLast = notClosed THEN len ELSE lr.first.afterLast;
TFO.AddLooks[x: sd.nodes.first, start: lr.first.first, len: afterLast - lr.first.first, look: l, root: sd.root];
ENDLOOP;
ENDLOOP;
sd.looks _ ALL[NIL];
};

ChangeDepth: PUBLIC PROC [s: IO.STREAM, deltaDepth: INTEGER _ 0, autoEndNode: BOOLEAN _ TRUE, idempotently: BOOLEAN _ FALSE] =
BEGIN
sd: TiogaOutStreamData _ NARROW[s.streamData];
IF autoEndNode THEN EndNode[s, same, idempotently];
IF sd.ready THEN ERROR NotNow[s];
sd.nextDepth _ sd.nextDepth + deltaDepth;
END;

NotNow: PUBLIC ERROR [s: IO.STREAM] = CODE;
BadDepth: PUBLIC ERROR [s: IO.STREAM, depth: INT] = CODE;

TiogaOutStreamData: TYPE = REF TiogaOutStreamDataRep;
TiogaOutStreamDataRep: TYPE = RECORD [
breakAtNewline, parsePrefix: BOOL,
levelPrefix: ROPE,
root: TFO.Ref _ NIL,
nodes: LIST OF TFO.Ref _ NIL,
ready: BOOLEAN _ FALSE,
lpCharsSeen, lpLength: INT _ 0,
nodeDepth, userDepth, --deltaDepth--nextDepth: INT _ 0,
contents: ROPE _ NIL,
defaultFormat: ROPE _ NIL,
looks: ARRAY Look OF LooksRuns _ ALL[NIL]];

LooksRuns: TYPE = LIST OF LooksRun;
LooksRun: TYPE = RECORD [first, afterLast: INT];
Look: TYPE = CHAR['a .. 'z];
notClosed: INT = -1;

PrepareForChar: PROC [s: IO.STREAM, sd: TiogaOutStreamData] =
BEGIN
IF sd.ready THEN RETURN;
IF sd.nextDepth < 0 THEN ERROR BadDepth[s, sd.nextDepth];
WHILE sd.nextDepth < sd.nodeDepth DO
sd.nodes _ sd.nodes.rest;
sd.nodeDepth _ sd.nodeDepth - 1;
ENDLOOP;
IF sd.nextDepth > sd.nodeDepth
THEN {
sd.nodes _ CONS[TFO.InsertAsLastChild[x: sd.nodes.first], sd.nodes];
sd.nodeDepth _ sd.nodeDepth + 1}
ELSE {
sd.nodes.first _ TFO.InsertNode[x: sd.nodes.first, child: FALSE];
};
IF sd.defaultFormat # NIL THEN TFO.SetFormat[sd.nodes.first, sd.defaultFormat];
sd.contents _ NIL;
sd.ready _ TRUE;
sd.userDepth _ sd.nodeDepth;
WHILE sd.userDepth < sd.nextDepth DO
sd.contents _ sd.contents.Concat[sd.levelPrefix];
sd.userDepth _ sd.userDepth + 1;
ENDLOOP;
IF sd.lpCharsSeen > 0 THEN {
sd.contents _ sd.contents.Concat[sd.levelPrefix.Substr[len: sd.lpCharsSeen]];
};
END;

true: REF ANY _ NEW [BOOL _ TRUE];

CopyChildren: PUBLIC PROC [from: TN.Ref, to: TFO.Ref] =
BEGIN

Work: PROC [from: TN.Ref, to: TFO.Ref] RETURNS [next: TN.Ref, dd: INT] = TRUSTED {
last: TFO.Ref _ to;
lastIsParent: BOOLEAN _ TRUE;
[next, dd] _ TN.Forward[from];
IF dd > 1 THEN ERROR;
IF dd < 1 THEN RETURN;
dd _ dd - 1;
WHILE dd = 0 DO
toKid: TFO.Ref;
tn: TN.RefTextNode _ next;
r: ROPE _ TN.NodeRope[tn];
toKid _ last.InsertNode[child: lastIsParent];
toKid.SetContents[r];
IF tn.comment THEN TiogaOps.PutProp[n: LOOPHOLE[toKid], name: $Comment, value: true];
last _ toKid; lastIsParent _ FALSE;
[next, dd] _ Work[next, toKid];
ENDLOOP;
dd _ dd + 1;
};

[] _ Work[from, to];
END;

RopeFromSubText: PROC [text: REF READONLY TEXT, startIndex, count: NAT] RETURNS [rope: ROPE] = {
GetChar: PROC RETURNS [c: CHAR] = {
c _ text[startIndex];
startIndex _ startIndex + 1;
count _ count - 1;
};
rope _ Rope.FromProc[count, GetChar];
};

END.
ÎTiogaStreamsImpl.Mesa
Last Edited by: Spreitzer, September 18, 1985 5:59:06 pm PDT
PrepareForChar[sd];
sd.contents _ sd.contents.Concat[Rope.FromRefText[block].Substr[start: startIndex, len: count]];
�Ê®˜Jš
œ™J™<J˜JšÏk	œ
�œ@˜LIcode˜šÐbxœ�œ
�˜Kš�œ
�œ�œ�œ˜DKš�œ˜—K˜Kš
�˜K˜Kš�œ�œ�œ
˜Kšœ�œ ˜5Kšœ	�œ˜%K˜šÏnœ�œ
�œ�œ
�œ�œ�œ˜9š
œ˜Kšœ�œ
�˜Kšœ�œ
�˜š
œ
˜
Kš�œ"�˜*Kš�œ$˜*——Kš
œ˜—K˜šŸœ�œ
�œ�œ?�œ�œ�œ�œ
�œ˜†
Kš
�˜šœ�œ˜5Kš
œ!˜!K˜Kšœ�œ
˜
Kš
œ
˜
Kš
œ˜—Kš
œ˜Kšœ�œ?˜FKš�œ
˜—K˜šŸ
œ�œ˜/Kšœ�œ
˜Kš
�œ�œ
�œ�œ
�œ˜.Kšœ�œ˜$Kš
�œ�œ
�œ�œ
�œ˜.š�œ�˜Kšœ�œ�œ˜˜Kšœ	�œ
˜K˜
Kš
œ˜Kš
œ˜K˜—Kš�œ�œ
˜—K˜—K˜Kšœ�œ
�œ�œ˜
˜Ã
K˜šŸœ�œ�œ
�œ�œ�œ˜6Kš
�˜Kšœ�œ˜0K˜Kš�œ�œ
�œ
�œ˜*Kš
œ"˜"K˜K˜Kš�œ
˜—K˜šŸœ�œ�œ
�œ�œ�œ˜6Kš
�˜Kšœ�œ˜0K˜K˜
Kš�œ
˜—K˜š
Ÿœ�œ�œ
�œ�œ˜0Kšœ�œ˜Kšœ	�œ
˜Kš�œ
�œ
�œ
�œ˜5K˜Kš
œ˜Kš�œ�œ
�œ
�œ˜;K˜K˜—K˜šŸ
œ�œ�œ
�œ�œ	�œ˜;Kšœ�œ˜0K˜Kš
œ˜—K˜š
Ÿ
œ�œ�œ
�œ	�œ˜2Kšœ�œ˜0Kšœ�œ
˜Kš
œ˜Kš
œ$˜$š�œ�œ˜š�œ˜Kš
œ˜K˜Kšœ	�œÏcM˜]K˜
—š�œ˜Kš
œ˜K˜K˜——Kš
œ˜—K˜šŸ	œ�œ
�œ�œ
�œ�œ�œ	˜=Kšœ�œ˜-Kš
œ˜K˜Kš
œ˜—K˜š
Ÿœ�œ
�œ�œ
�œ˜,Kšœ�œ˜-K˜šŸœ�œ�œ�œ�œ�œ˜?Kšœ	�œ�œ˜(šœ�œ
�œ˜Kš�œ
˜š�œ
�œ�˜#Kš
œ
˜
Kš
œ˜Kš
œ ˜ Kš�œ�œ
˜——Kšœ
�œ
˜Kš�œ�œ
�œ
˜Kš�œ�œ
�œ
˜K˜š�œ�˜Kšœ�œ
˜	Kš
œ˜K˜Kš�œ
˜—K˜Kš
œ˜—K˜Kšœ�œ˜Kšœ�œ
˜Kš
œ˜K˜Kš
œ$˜$Kš�œ�œ
�œ
˜"K˜Kš�œ�œ�œ
�œ�œ�œ˜>K˜Kš
œ˜K˜K˜K˜Kš
œ˜—K˜Kšœ�œ�œ˜3šœ�œ�œ˜%K˜!Kšœ�œ�œ
˜Kšœ�œ˜Kšœ�œ˜!Kšœ
�œ�œ
˜Kšœ
�œ
˜Kšœ�œ˜—K˜šŸœ�œ˜.Kš
�˜Kš�œ�œ
�œ
˜š�œ�˜Kšœ�œ
˜Kšœ�œ˜
Kšœ
�œ˜!Kš�œ�œ�œ
�œ�œ�œ˜?K˜K˜Kš
œ7˜7K˜Kš
œ˜Kš�œ
˜—Kš�œ
˜—K˜šŸ	œ�œ˜)Kš
�˜Kšœ�œ˜šŸœ�œ
�œ˜Kšœ�œ˜+Kš�œ
�œ
�œ*˜>š�œ�œ
�œ�˜>Kš
œ1˜1Kš�œ
˜—Kš
œ"˜"K˜—š�œ˜
š�œ
�œ�˜#š
œ˜Kšœ�œ
˜Kš
œ˜K˜—Kšœ�œ˜Kš
œ ˜ Kš�œ�˜—Kš�œ�œ˜—Kš�œ
˜—K˜šŸœ�œ
�œ�œ�œ�œ�œ�œ�œ�œ
�œ˜ˆ
Kš
�˜šœ�œ˜7Kš
œ˜Kšœ�œ
˜Kš
œ˜Kš
œ	˜	Kšœ�œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜—K˜Kšœ�œ@˜HK˜K˜FK˜3K˜Kš�œ
˜—K˜Kšœ�œ
�œ�œs˜Ÿ
K˜š
Ÿœ�œ�œ
�œ�œ˜-Kš
�˜Kšœ�œ˜1š�œ
�œ
�˜Kšœ�œ$�œ˜@šœ�œ�œ�œ1˜VKš
œ$˜$š�œ�œ˜&Kš
œ˜Kš
œ ˜ K˜—K˜—š�œ˜K˜K˜6K˜——Kš�œ
˜—K˜šŸœ�œ�œ
�œ	�œ
�œ
�œ�œ˜TKš
�˜Kšœ�œ˜1Kšœ�œ˜Kšœ�œ˜$š�œ�˜Kšœ�œ
˜š�œ�œ�œ�˜,K˜K˜Kš�œ�œ
�œ
˜!Kš�œ
˜—Kš�œ�œ�œ�œ
�œ
�œ
˜_š�œ�œ˜'Kš
œH˜HK˜K˜—Kš�œ
˜—K™Kš
œ`™`Kš�œ
˜—K˜šŸœ�œ�œ
�œ	�œ�œ˜7Kš
�˜K˜KšœU�œ˜ZKš�œ
˜—K˜šŸ
œ�œ
�œ�œ
�œ�œ�œ˜=Kš
�˜Kšœ�œ˜.K˜Kš�œ
˜—K˜šŸ	œ�œ
�œ�œ
�œ
�œ˜6Kš
�˜Kšœ�œ˜Kš�œ˜Kš�œ
˜—K˜šŸœ�œ
�œ
�œ�œ&�œ˜XKšœ�œ˜3K˜š�œ�œ
�˜Kšœ�œ0˜6Kš�œ�œ
�œ#˜6—K˜—K˜š
Ÿ	œ�œ
�œ
�œ!�œ˜LKšœ�œ˜"š�œ�œ
�œ�˜&Kšœ�œ˜š�œ�˜
K˜:š�œ˜Kš
�œ�œ
�œ)�œ�œ3˜Š
K˜—š�œ(˜*Kš�œ�œ
�œ)�œ%˜jK˜—Kš�œ�œ
�œ#˜6—Kš�œ
˜—K˜—K˜šŸœ�œ
�œ�œ
�œ*�œ�œ˜^Kš
�˜Kšœ�œ˜.š�œ
�œ
�˜Kš
�˜Kš�œ�œ
�œ
˜K˜Kš�œ
˜—Kš�œ*˜-K˜
Kšœ�œ
˜Kš
œ˜Kšœ�œ
˜šœ�œ	�˜"K˜K˜Kš�œ�œ
˜—Kš�œ
˜—K˜šŸœ�œ˜+Kšœ�œ˜ š�œ	�œ�˜š�œ&�œ�œ
�˜:Kš	œ�œ�œ �œ�œ˜TKš�œm˜pKš�œ
˜—Kš�œ
˜—Kšœ�œ
�œ˜K˜—K˜šŸœ�œ
�œ�œ
�œ�œ�œ�œ�œ�œ˜~Kš
�˜Kšœ�œ˜.Kš�œ
�œ ˜3Kš�œ
�œ
�œ˜!Kš
œ)˜)Kš�œ
˜—K˜Kšœ�œ
�œ�œ
�œ�œ
˜+Kš
œ
�œ
�œ�œ
�œ	�œ�œ
˜9K˜Kšœ�œ�œ˜5šœ�œ�œ˜&Kšœ�œ
˜"Kšœ
�œ
˜Kšœ�œ�œ
˜Kš	œ�œ
�œ
�œ�œ
˜Kšœ�œ�œ
˜Kšœ�œ˜Kšœ œ�œ˜7Kšœ
�œ�œ
˜Kšœ�œ�œ
˜Kš	œ�œ�œ
�œ
�œ˜+—K˜Kšœ�œ�œ
�œ
˜#Kšœ
�œ�œ�œ˜0Kšœ�œ�œ˜Kšœ�œ˜K˜šŸœ�œ�œ
�œ˜=Kš
�˜Kš�œ
�œ
�œ
˜Kš�œ�œ
�œ˜9š�œ�˜$K˜Kš
œ ˜ Kš�œ
˜—š�œ˜š�œ˜Kšœ�œ
�œ1˜DKš
œ ˜ —š�œ˜Kšœ�œ&�œ˜AKš
œ˜——Kš�œ�œ
�œ
�œ-˜OKšœ�œ
˜Kšœ�œ
˜Kš
œ˜š�œ�˜$Kš
œ1˜1K˜ Kš�œ
˜—š�œ�œ˜Kš
œM˜MK˜—Kš�œ
˜—K˜Kšœ�œ
�œ�œ�œ�œ˜"K˜š
Ÿœ�œ
�œ�œ
�œ˜7Kš
�˜K˜šŸœ�œ�œ
�œ�œ�œ
�œ�œ˜RKšœ�œ
˜Kšœ�œ�œ
˜Kšœ
�œ˜Kš�œ�œ
�œ
˜Kš�œ�œ
�œ
˜K˜š�œ�˜Kšœ�œ˜Kšœ�œ˜Kšœ�œ�œ˜K˜-Kš
œ˜Kš�œ�œ�œ&˜UKšœ�œ
˜#K˜Kš�œ
˜—K˜Kš
œ˜—K˜K˜Kš�œ
˜—K˜šŸœ�œ�œ
�œ
�œ�œ�œ�œ˜`šŸœ�œ
�œ�œ˜#K˜K˜K˜K˜—K˜%K˜—K˜Kš�œ
˜—…—.\@Ø