DIRECTORY
Atom, Basics, IO, LRUCache, PrincOps, Rope, RuntimeError, TerminalIO, TokenIO, UserProfile;

TokenIOImpl: CEDAR MONITOR 
IMPORTS Atom, IO, LRUCache, Rope, RuntimeError, TerminalIO, UserProfile 
EXPORTS TokenIO =
BEGIN


xTokenIOCode: CARDINAL = 237;  -- this is really a TokenIO file
xVersionCode: CARDINAL = 1;  -- this is really a TokenIO file of correct version

xLongInt: CARDINAL = 255;
xPushFlag: CARDINAL = 254;
xRope: CARDINAL = 253;
xPopFlag: CARDINAL = 252;
xFillTable: CARDINAL = 0;
xReadTableMin: CARDINAL = 1;  -- >0 ! 
dummy: INTEGER = xReadTableMin-1;
xReadTableMax: CARDINAL = 100;
xFirstShortNat: CARDINAL = xReadTableMax+1;
xLastShortNat: CARDINAL = 247;
 shortNatLast: CARDINAL = xLastShortNat-xFirstShortNat; 
xTwoByteCard: CARDINAL = 251;
xTwoByteNegative: CARDINAL = 250;
xOneBytePos: CARDINAL = 249;
xOneByteNeg: CARDINAL = 248;

Mark: TYPE = REF MarkRep;
MarkRep: PUBLIC TYPE = RECORD [index: INT];
TokenType: TYPE = TokenIO.TokenType; 
Token: TYPE = TokenIO.Token;

writer: IO.STREAM_NIL;
stopWriting: PUBLIC BOOL _ FALSE;
lruQueue: LRUCache.Handle _ LRUCache.Create[xReadTableMax-xReadTableMin+1, Hash, Equal];

reader: IO.STREAM _ NIL;
readAgain: BOOL _ FALSE;
token: Token; 
rTtable: REF ARRAY [xReadTableMin..xReadTableMax] OF Token = 
NEW[ARRAY [xReadTableMin..xReadTableMax] OF Token];

WritingStopped: PUBLIC SIGNAL = CODE;

PutByte: PROC [c: CARDINAL] = INLINE {
IO.PutChar[writer, LOOPHOLE[c, CHAR]];
};

PutInt: PROC [i: INT] = INLINE {
Long: Basics.LongNumber = Basics.LongNumber[li[li: i]]; 
Put2Bytes[Long.lowbits];
Put2Bytes[Long.highbits];
};

Put2Bytes: PROC [c: CARDINAL] = INLINE {
IO.PutChar[writer, LOOPHOLE[c / 256, CHAR]];
IO.PutChar[writer, LOOPHOLE[c MOD 256, CHAR]];
};

PutRope: PROC [r: Rope.ROPE] = INLINE {
leng: INT = Rope.Length[r];
IF leng<255 THEN PutByte[leng] ELSE {PutByte[255]; PutInt[leng]};
IO.PutRope[writer, r];
};

PutAtom: PROC [a: ATOM] = INLINE {
IF a=NIL THEN PutByte[0] ELSE PutRope[Atom.GetPName[a]];
};

GetChar: PROC [] RETURNS[CHAR] = INLINE { 
RETURN [IO.GetChar[reader]];
};

XGetChar: PROC [] RETURNS[CHAR] = { --not inline; used as formal procedure
RETURN [GetChar[]];
};

GetByte: PROC [] RETURNS[c: [0..255]] = INLINE {
c _ LOOPHOLE[IO.GetChar[reader], [0..255]];
};

Get2Bytes: PROC [] RETURNS [c: CARDINAL] = INLINE {
h: [0..255] = GetByte[];
c _ h*256+GetByte[];
};

GetInt: PROC [] RETURNS[INT] = INLINE {
long: Basics.LongNumber = Basics.LongNumber[num[ 
lowbits: Get2Bytes[],
highbits: Get2Bytes[]
]];
RETURN [long.li]
};

GetRope: PROC [] RETURNS[Rope.ROPE] = INLINE {
leng: INT _ GetByte[];
IF leng=255 THEN leng _ GetInt[];
IF leng=0 THEN RETURN [""];
RETURN [ Rope.FromProc[len: leng, p: XGetChar] ];
};

GetAtom: PROC [] RETURNS [a: ATOM] = INLINE {
r: Rope.ROPE = GetRope[];
IF Rope.InlineIsEmpty[r] THEN RETURN [NIL]
ELSE RETURN [ Atom.MakeAtom[r] ];
};

FillTable: PROC[] RETURNS [t: Token] = INLINE
BEGIN
c: CARDINAL = GetByte[];
SELECT TRUE FROM
c IN [xReadTableMin..xReadTableMax] => {
t _ rTtable[c] _ Token[kind: atom, ref: GetAtom[]]
};
ENDCASE => ERROR
END;

WriteInt: PUBLIC PROC [i: INT] =
BEGIN
IF stopWriting THEN SIGNAL WritingStopped;
SELECT TRUE FROM
i IN [0..shortNatLast] => {PutByte[i+xFirstShortNat]};
i IN [0..255]  => {PutByte[xOneBytePos]; PutByte[i]};
i IN [0..INT[LAST[CARDINAL]]] => {PutByte[xTwoByteCard]; Put2Bytes[i]};
i IN [-256..-1]  => {PutByte[xOneByteNeg]; PutByte[-i-1]};
i IN [-INT[LAST[CARDINAL]]..-1] => {PutByte[xTwoByteNegative]; Put2Bytes[-i-1]};
ENDCASE => {PutByte[xLongInt]; PutInt[i]};
END;

Hash: PROC [x: REF] RETURNS [CARDINAL] = {
HashCode: PROC [REF] RETURNS [CARDINAL] = TRUSTED MACHINE CODE {
PrincOps.zXOR;
};
RETURN [HashCode[x]]
};

Equal: PROC [x, y: REF] RETURNS [b: BOOL] = {
RETURN [x=y]
};

WriteAtom: PUBLIC PROC [a: ATOM] =
BEGIN
index: NAT; insert: BOOL;
IF stopWriting THEN SIGNAL WritingStopped;
[index: index, insert: insert] _ LRUCache.Include[lruQueue, a];
IF insert THEN {
PutByte[xFillTable];
PutByte[index+xReadTableMin];
PutAtom[a];
}
ELSE {
PutByte[index+xReadTableMin];
};
END;

WriteRope: PUBLIC PROC [r: Rope.ROPE] =
BEGIN
IF stopWriting THEN SIGNAL WritingStopped;
PutByte[xRope];
PutRope[r];
END;

WritePushFlag: PUBLIC PROC [a: ATOM_NIL] =
BEGIN
IF stopWriting THEN SIGNAL WritingStopped;
PutByte[xPushFlag];
WriteAtom[a];
END;

WritePopFlag: PUBLIC PROC [] =
BEGIN
IF stopWriting THEN SIGNAL WritingStopped;
PutByte[xPopFlag];
END;

MarkAndWriteInt: PUBLIC PROC [value: INT] RETURNS [Mark] =
BEGIN
mark: Mark = NEW[MarkRep];
IF stopWriting THEN SIGNAL WritingStopped;
PutByte[xLongInt];
mark.index _ IO.GetIndex[writer];
PutInt[value];
RETURN [mark]
END;

UpdateMark: PUBLIC PROC [mark: Mark, value: INT] =
BEGIN
pos: INT = IO.GetIndex[writer];
IO.SetIndex[writer, mark.index];
PutInt[value];
IO.SetIndex[writer, pos];
END;

InternalReadToken: PROC [] RETURNS [Token] =
BEGIN
ENABLE { 
IO.EndOfStream => IF NotDebugging[] THEN GOTO endOfStreamReturn;
IO.Error => IF NotDebugging[] THEN GOTO endOfStreamReturn;
RuntimeError.UNCAUGHT => {
TerminalIO.WriteRope["** unknown TokenIO error\n"];
IF NotDebugging[] THEN GOTO errorReturn;
}
};
b: [0..255]; 
b _ GetByte[];
IF b<=xLastShortNat THEN {--this if statement for speed only
SELECT TRUE FROM
b IN [xFirstShortNat..xLastShortNat] => 
{RETURN [Token[kind: int, ref: NEW[INT_ b-xFirstShortNat]]]};
b IN [xReadTableMin..xReadTableMax] => {RETURN [rTtable[b]]};
b=xFillTable => {RETURN FillTable[]};
ENDCASE => ERROR;
}
ELSE {
SELECT TRUE FROM
b=xPopFlag => {RETURN [Token[kind: popFlag, ref: NIL]]};
b=xPushFlag => {
t: Token _ InternalReadToken[];
IF t.kind#atom THEN RETURN [Token[kind: error, ref: NIL]];
RETURN [Token[kind: pushFlag, ref: t.ref]]
};
b=xTwoByteCard => {RETURN [Token[kind: int, ref: NEW[INT_Get2Bytes[]]]]};
b=xRope => {RETURN [Token[kind: rope, ref: GetRope[]]]};
b=xOneBytePos => {RETURN [Token[kind: int, ref: NEW[INT_GetByte[]]]]};
b=xOneByteNeg => 
{i: INT = GetByte[]; RETURN [Token[kind: int, ref: NEW[INT_-i-1]]]};
b=xLongInt => {RETURN [Token[kind: int, ref: NEW[INT_GetInt[]]]]};
b=xTwoByteNegative => 
{i: INT = Get2Bytes[]; RETURN [Token[kind: int, ref: NEW[INT_-i-1]]]};
ENDCASE => ERROR;
}
EXITS
errorReturn => RETURN [Token[kind: error, ref: NIL]];
endOfStreamReturn => {
TerminalIO.WriteRope["** end of TokenIO stream\n"];
RETURN [Token[kind: endOfStream, ref: NIL]]
};
END;



debugMax: NAT = 10;
debugBuffer: REF ARRAY [0..debugMax) OF Token _ NEW[ARRAY [0..debugMax) OF Token];
debugIndex:  [0..debugMax] _ 0;
doDebug: BOOL _ FALSE;

NotDebugging: PROC RETURNS [BOOL] = {
RETURN [ UserProfile.Boolean["ChipNDale.CatchLowLevelErrors", TRUE] ]
};

ReadToken: PUBLIC PROC [] RETURNS [Token] =
BEGIN
IF readAgain THEN {readAgain_FALSE; RETURN [token]};
token _ InternalReadToken[];
IF doDebug THEN {
debugBuffer[debugIndex] _ token; 
debugIndex _ (debugIndex+1) MOD debugMax;
};
RETURN [token]
END;

ReadAgain: PUBLIC PROC [] =
BEGIN
readAgain _ TRUE
END;


Error: PUBLIC ERROR[why: TokenIO.Err, explanation: REF_NIL] = CODE;  

ReleaseReader: PUBLIC PROC [] =
BEGIN
reader _ NIL
END;

DoAttachR: ENTRY PROC [stream: IO.STREAM] RETURNS [ok: BOOL] =
BEGIN ENABLE UNWIND => NULL;
IF (ok _ reader=NIL) THEN reader _ stream
END;

AttachReader: PUBLIC PROC [stream: IO.STREAM] =
BEGIN
ok: BOOL;
ok _ DoAttachR[stream];
IF ~ok THEN ERROR Error[alreadyAttached, Rope.FromRefText["file is already attached"]];
IF GetByte[ ! IO.EndOfStream => GOTO empty ]#xTokenIOCode THEN { 
reader _ NIL;
ERROR Error[wrongVersion, Rope.FromRefText["file not produced with TokenIO"]];
};
IF GetByte[]#xVersionCode THEN { 
reader _ NIL;
ERROR Error[wrongVersion, Rope.FromRefText["TokenIO version missmatch"]];
};
EXITS 
empty =>{
reader _ NIL;
ERROR Error[why: other, explanation: Rope.FromRefText["empty file"]];
};
END;


DoAttachW: ENTRY PROC [stream: IO.STREAM] RETURNS [ok: BOOL] =
BEGIN ENABLE UNWIND => NULL;
IF (ok _ writer=NIL) THEN writer _ stream
END;

AttachWriter: PUBLIC PROC [stream: IO.STREAM] =
BEGIN
ok: BOOL;
ok _ DoAttachW[stream];
IF ~ok THEN ERROR Error[alreadyAttached, Rope.FromRefText["file is already attached"]];
[] _ IO.GetIndex[stream! IO.Error => GOTO NoGetIndex];
stopWriting _ FALSE;
writer _ stream;
LRUCache.Reset[lruQueue]; 
PutByte[xTokenIOCode];
PutByte[xVersionCode];
EXITS
NoGetIndex => {
writer _ NIL;
Error[other, Rope.FromRefText["file uses stream without GetIndex"]];
}
END;

ReleaseWriter: PUBLIC PROC [] =
BEGIN
writer _ NIL
END;


EncodingError: PUBLIC SIGNAL = CODE;  --For normal users it is an ERROR

ReadInt: PUBLIC PROC [] RETURNS [INT] =
BEGIN
t: Token _ ReadToken[];
IF t.kind#int THEN SIGNAL EncodingError;
RETURN [NARROW[t.ref, REF INT]^]
END;

ReadAtom: PUBLIC PROC [] RETURNS [ATOM] =
BEGIN
t: Token _ ReadToken[];
IF t.kind#atom THEN SIGNAL EncodingError;
RETURN [NARROW[t.ref, ATOM]]
END;

ReadRope: PUBLIC PROC [] RETURNS [Rope.ROPE] =
BEGIN
t: Token _ ReadToken[];
IF t.kind#rope THEN SIGNAL EncodingError;
RETURN [NARROW[t.ref, Rope.ROPE]]
END;

ReadPushFlag: PUBLIC PROC [] RETURNS [ATOM] =
BEGIN
t: Token _ ReadToken[];
IF t.kind#pushFlag THEN SIGNAL EncodingError;
RETURN [NARROW[t.ref, ATOM]]
END;

ReadPopFlag: PUBLIC PROC [] =
BEGIN
t: Token _ ReadToken[];
IF t.kind#TokenType[popFlag] THEN SIGNAL EncodingError;
END;

END.



ΖTokenIOImpl.mesa
Copyright c 1983, 1985, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi August 24, 1983 3:10 pm
Last Edited by: Christian Jacobi, August 16, 1986 6:28:41 pm PDT
-- we use read, write for encoded, (exported) IO
-- we use get/put for actual unencoded IO
-- codes

-- types
{atom, int, rope, pushFlag, popFlag, endOfStream, error};
RECORD [
kind: TokenType,
ref: REF_NIL   - - either ATOM, Rope.ROPE, REF INT or NIL (Rope.ROPE or NIL if error)
];
--kind = atom => ISTYPE[ref, ATOM]
--kind = int => ISTYPE[ref, REF INT]
--kind = rope => ISTYPE[ref, Rope.ROPE] 
--kind = pushFlag => ref=NIL or ISTYPE[ref, ATOM]
--kind = popFlag => ref=NIL 
--kind = endOfStream => ref=NIL
--kind = error => ref=NIL OR ISTYPE[ref, Rope.ROPE] 
-- output tables

LinkRecord: TYPE = RECORD[older, younger: INTEGER];
accessList: REF ARRAY [dummy..xReadTableMax] OF LinkRecord = 
NEW[ARRAY [dummy..xReadTableMax] OF LinkRecord];
--doubly linked LRU list
wAtomTable: REF ARRAY [xReadTableMin..xReadTableMax] OF ATOM =
NEW[ARRAY [xReadTableMin..xReadTableMax] OF ATOM];
freeEntry: INTEGER;
--input tables

i: INTEGER;
BEGIN
IF stopWriting THEN SIGNAL WritingStopped;
FOR i _ accessList[dummy].older, accessList[i].older WHILE i#dummy DO
IF a=wAtomTable[i] THEN {
PutByte[i];
-- Remove atom i from access list
accessList[accessList[i].older].younger _ accessList[i].younger;
accessList[accessList[i].younger].older _ accessList[i].older;
GOTO touchI
};
ENDLOOP;
--not found
--Determine where atom will go in table
IF freeEntry<=xReadTableMax THEN {
i _ freeEntry; 
freeEntry _ freeEntry + 1;
}
ELSE {
--reuse oldest entry
i _ accessList[dummy].younger;
accessList[dummy].younger _ accessList[i].younger;
accessList[accessList[i].younger].older _ dummy;
};
--Add atom to atom table
wAtomTable[i] _ a;
PutByte[xFillTable];
PutByte[i];
PutAtom[a];
GOTO touchI;
EXITS
touchI --i is touched atom-- => {
--Put atom most recently touched (i) at the front
accessList[i].older _ accessList[dummy].older;
accessList[i].younger _ dummy;
accessList[accessList[dummy].older].younger _ i;
accessList[dummy].older _ i;
};
END;
--features used to debug TokenIO and other ChipNDale IO
--debugging optional; the MOD operation costs 5% runtime on read!
--cause next call of ReadToken to get the same value as the last read
--works only one level deep (reads again only the last value returned by ReadToken)
--Attaching TokenIo to STREAMS
--while TokenIo is attached to a stream no other operations on this
--stream should occur 
only on Attach or Release
XX accessList[dummy] _ LinkRecord[dummy, dummy];
XX freeEntry _ xReadTableMin;
--also invalidates marks
--making a signal allows proceeding with the debugger, which is usefull
--on emergency cases...
Κ¬˜š
œ™Jšœ
Οm
œ=™HJš
œ3™3Icode™@J˜—š
Οk	˜	JšœžœK˜[—J˜šΠblœžœ
žœ
˜Jšžœžœ8˜HJšžœ
˜—Jš
ž˜J˜Jš
œ0™0Jš
œ)™)J˜Jš
œ™Jšœžœ	Οc ˜?Jšœžœ 3˜PJ˜Jšœ
žœ˜Jšœžœ˜Jšœžœ˜Jšœ
žœ˜Jšœžœ˜šœžœ ˜&Jšœžœ˜!—Jšœžœ˜Jšœžœ˜+Jšœžœžœ!˜WJšœžœ˜Jšœžœ˜!Jšœ
žœ˜Jšœ
žœ˜J˜J™Jš
œ™Jšœžœžœ	˜Jš	œ	žœ
žœžœ	žœ˜+šœžœ˜%Jš
œ9™9—šœžœ˜š
œ™Jš
œ™Jš
œU™UJš
œ™Jš
œ"™"Jš
œ$™$Jš
œ(™(Jš
œ1™1Jš
œ™Jš
œ™Jš
œ4™4——J˜Jš
œ™Jšœžœ
žœ
žœ
˜Jšœ
žœ
žœžœ
˜!J™Jš
œX˜XJšœžœžœžœ™3šœžœ
žœžœ™=Jšžœ
žœžœ
™0Jš
œ™—š	œžœ
žœ žœ
žœ™>Jšžœ
žœ žœ
žœ™2—Jšœžœ
™J˜Jš
œ™Jšœžœ
žœžœ
˜Jšœžœžœ
˜Jš
œ˜šœ	žœ
žœ žœ	˜=Jšžœ
žœ žœ˜3—J˜Jšœžœ
žœžœ
˜%J˜šΟnœžœžœžœ˜&Jšžœžœžœ˜&Jš
œ˜—J˜š‘œžœžœžœ˜ Jš
œ8˜8Jš
œ˜Jš
œ˜Jš
œ˜—J˜š‘	œžœžœžœ˜(Jšžœžœ
žœ˜,Jšžœžœžœžœ˜.Jš
œ˜—J˜š‘œžœ
žœžœ˜'Jšœžœ˜Jšžœ
žœžœ˜AJšžœ˜Jš
œ˜J˜—š‘œžœžœžœ˜"Jšžœžœ
žœžœ˜8Jš
œ˜J˜—š
‘œžœžœ
žœžœ˜*Jšžœžœ˜Jš
œ˜J˜—š	‘œžœžœ
žœ &˜JJšžœ
˜Jš
œ˜J˜—š‘œžœžœžœ˜0Jšœžœ
žœ˜+Jš
œ˜—J˜š
‘	œžœžœžœžœ˜3Jš
œ˜Jš
œ˜J˜J˜—š
‘œžœžœ
žœžœ˜'š
œ1˜1Jš
œ˜Jš
œ˜J˜—Jšžœ
˜Jš
œ˜J˜—š
‘œžœžœžœžœ˜.Jšœžœ
˜Jšžœ
žœ˜!Jšžœžœ
žœ˜Jšžœ+˜1Jš
œ˜J˜—š
‘œžœžœžœžœ˜-Jšœžœ
˜Jšžœžœ
žœžœ
˜*Jšžœ
žœ˜!Jš
œ˜—J˜š‘	œžœžœž˜-Jš
ž˜Jšœžœ
˜šžœ
žœ
ž˜šœžœ$˜(Jš
œ2˜2Jš
œ˜—Jšžœž˜—Jšžœ
˜—J˜š‘œžœ
žœžœ˜ Jš
ž˜Jšžœ
žœ
žœ˜*šžœ
žœ
ž˜Jšœžœ2˜6Jšœžœ1˜5Jš	œžœžœ
žœ
žœ-˜GJšœžœ6˜:Jš	œžœžœ
žœ
žœ8˜PJšžœ#˜*—Jšžœ
˜—J˜š
‘œžœžœžœžœ˜*š‘œžœžœžœžœžœ
žœ
žœ˜@Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜—J˜š
‘œžœžœžœžœ˜-Jšžœ˜Jš
œ˜—J˜š‘	œžœ
žœžœ˜"Jš
ž˜Jšœžœ
žœ
˜Jšžœ
žœ
žœ˜*Jš
œ?˜?šžœžœ˜J˜Jš
œ˜Jš
œ˜J˜
—šžœ˜Jš
œ˜J˜—J™šœžœ
™Jš
ž™Jšžœ
žœ
žœ™*šžœ2žœ	ž™Ešžœžœ™J™J™!J™@J™>Jšžœ™Jš
œ™—Jšžœ
™—Jš
œ™J™'šžœžœ™"Jš
œ™Jš
œ™Jš
œ
™
—šžœ™J™Jš
œ™Jš
œ2™2Jš
œ0™0Jš
œ™—J™J™J™J™Jš
œ™Jšžœ™š
ž™šœ œ™!Jš
œ1™1Jš
œ.™.Jš
œ™Jš
œ0™0Jš
œ™J™——Jšžœ
™—Jšžœ
˜J˜—š‘	œžœ
žœ
žœ˜'Jš
ž˜Jšžœ
žœ
žœ˜*Jš
œ˜Jš
œ˜Jšžœ
˜J˜—š
‘
œžœ
žœžœ
žœ˜*Jš
ž˜Jšžœ
žœ
žœ˜*Jš
œ˜Jš
œ
˜
Jšžœ
˜J˜—š‘œžœ
žœ˜Jš
ž˜Jšžœ
žœ
žœ˜*Jš
œ˜Jšžœ
˜J˜—š
‘œžœ
žœ	žœžœ	˜:Jš
ž˜Jš
œ˜Jšžœ
žœ
žœ˜*Jš
œ˜Jšœ
žœ˜!Jš
œ˜Jšžœ˜
Jšžœ
˜J˜—š‘
œžœ
žœžœ˜2Jš
ž˜Jšœžœžœ˜Jšžœ˜ Jš
œ˜Jšžœ˜Jšžœ
˜—J˜š‘œžœžœ
˜,š
ž˜šžœ˜	Jšžœžœžœ
žœ˜@Jšžœ
žœžœ
žœ˜:šœ
žœ˜J˜3Jšžœžœ
žœ
˜(J˜
—J˜——Jš
œ
˜
Jš
œ˜šžœžœ "˜<šžœ
žœ
ž˜šœžœ$˜(Jšœ
žœžœ
žœ˜=—Jšœžœ$žœ˜=Jšœžœ˜%Jšžœžœ
˜—J˜
—šžœ˜šžœ
žœ
ž˜Jšœžœžœ˜8š
œ˜Jš
œ˜Jšžœ
žœ
žœžœ˜:Jšžœ$˜*Jš
œ˜—Jšœžœžœ
žœ˜IJšœžœ&˜8Jšœžœžœ
žœ˜Fš
œ˜Jš	œžœžœžœ
žœ
˜D—Jšœžœžœ
žœ˜Bš
œ˜Jš	œžœžœžœ
žœ
˜F—Jšžœžœ
˜—J˜
—š
ž˜Jšœžœžœ˜5š
œ˜J˜3Jšžœ žœ˜+Jš
œ˜——Jšžœ
˜—J˜J˜Jš
œ7™7J˜Jšœ
žœ˜Jš
œ
žœ
žœžœ	žœ
žœžœ˜RJš
œ˜Jšœ	žœžœ
˜J˜š‘œžœ
žœžœ˜%Jšžœ8žœ˜EJš
œ˜—J˜š‘	œžœ
žœžœ
˜+Jš
ž˜Jšžœžœžœžœ
˜4Jš
œ˜šžœ	žœ˜Jšœžœ$™AJš
œ!˜!Jšœžœ
˜)J˜—Jšžœ˜Jšžœ
˜—J˜š‘	œžœ
žœ˜Jš
œE™EJš
œS™SJš
ž˜Jšœž˜Jšžœ
˜J˜—Jš
œ™Jš
œC™CJš
œ™J˜šœžœ
žœ žœ
žœžœ˜EJš
œ™—J˜š‘
œžœ
žœ˜Jš
ž˜Jšœ	ž˜Jšžœ
˜—J˜š‘	œžœ
žœ
žœ
žœžœžœ˜>Jšžœ
žœ
žœžœ
˜Jšžœžœžœ˜)Jšžœ
˜—J˜š
‘œžœ
žœ
žœ
žœ˜/Jš
ž˜Jšœžœ
˜	Jš
œ˜Jšžœžœ
žœF˜Wšžœžœžœžœ˜AJšœ	žœ
˜
JšžœI˜NJ˜—šžœžœ˜!Jšœ	žœ
˜
JšžœD˜IJ˜—šžœ
˜š
œ	˜	Jšœ	žœ
˜
Jšžœ@˜EJ˜——Jšžœ
˜—J˜J˜š‘	œžœ
žœ
žœ
žœžœžœ˜>Jšžœ
žœ
žœžœ
˜Jšžœžœžœ˜)Jšžœ
˜—J˜š
‘œžœ
žœ
žœ
žœ˜/Jš
ž˜Jšœžœ
˜	Jš
œ˜Jšžœžœ
žœF˜WJšœžœžœ
žœ
˜6Jšœžœ
˜Jš
œ˜Jš
œ˜Jš
œ0™0Jš
œ™Jš
œ˜Jš
œ˜š
ž˜š
œ˜Jšœ	žœ
˜
Jš
œD˜DJ˜
——Jšžœ
˜—J˜š‘
œžœ
žœ˜Jš
œ™Jš
ž˜Jšœ	ž˜Jšžœ
˜—J˜J˜šœžœ
žœžœ !˜GJš
œG™GJš
œ™—J˜š
‘œžœ
žœžœžœ˜'Jš
ž˜Jš
œ˜Jšžœžœ
žœ˜(Jšžœžœžœ
žœ˜ Jšžœ
˜J˜—š
‘œžœ
žœžœžœ˜)Jš
ž˜Jš
œ˜Jšžœ
žœ
žœ˜)Jšžœžœžœ˜Jšžœ
˜J˜—š
‘œžœ
žœžœžœ˜.Jš
ž˜Jš
œ˜Jšžœ
žœ
žœ˜)Jšžœžœ
žœ˜!Jšžœ
˜J˜—š
‘œžœ
žœžœžœ˜-Jš
ž˜Jš
œ˜Jšžœžœ
žœ˜-Jšžœžœžœ˜Jšžœ
˜J˜—š‘œžœ
žœ˜Jš
ž˜Jš
œ˜Jšžœžœ
žœ˜7Jšžœ
˜—J˜Jšžœ
˜J˜J˜—…—$Aˆ