DIRECTORY
Basics USING [BYTE, UnsafeBlock],
IO,
IPBasic USING [Op, Rational, XeroxPixelVectorType],
IPReader USING [Class, ClassRep, Error, LargeVector, LargeVectorRep, nullToken, Reader, Register, StreamFromInputStream, Token, TokenType],
IPXerox USING [EncodingTable, EncodingValue, GetEncodingTable, SequenceType, ShortNumber],
RefText USING [InlineReserveChars],
Rope USING [ROPE];

IPXeroxReaderImpl: CEDAR PROGRAM
IMPORTS IO, IPReader, IPXerox, RefText
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;
BYTE: TYPE ~ Basics.BYTE;

Op: TYPE ~ IPBasic.Op;
Rational: TYPE ~ IPBasic.Rational;

Reader: TYPE ~ IPReader.Reader;
Token: TYPE ~ IPReader.Token;

DecodingTable: TYPE ~ REF DecodingTableRep;
DecodingTableRep: TYPE ~ PACKED ARRAY IPXerox.EncodingValue OF Op;

InvertEncodingTable: PROC[encode: IPXerox.EncodingTable] RETURNS[DecodingTable] ~ {
decode: DecodingTable ~ NEW[DecodingTableRep _ ALL[nil]];
FOR op: Op IN Op DO decode[encode[op]] _ op ENDLOOP;
RETURN[decode];
};

decode: DecodingTable ~ InvertEncodingTable[IPXerox.GetEncodingTable[]];

SequenceTable: TYPE ~ REF SequenceTableRep;
SequenceTableRep: TYPE ~ ARRAY IPXerox.SequenceType OF IPReader.TokenType;

sequenceTokenType: SequenceTable ~ InitSequenceTable[];
InitSequenceTable: PROC RETURNS[SequenceTable] ~ {
s: SequenceTable ~ NEW[SequenceTableRep _ ALL[$nil]];
s[$sequenceInteger] _ $integer;
s[$sequenceRational] _ $rational;
s[$sequenceFloating] _ $real;
s[$sequenceIdentifier] _ $identifier;
s[$sequenceString] _ $string;
s[$sequenceLargeVector] _ $largeVector;
s[$sequencePackedPixelVector] _ $largeVector;
s[$sequenceCompressedPixelVector] _ $largeVector;
s[$sequenceAdaptivePixelVector] _ $largeVector;
s[$sequenceComment] _ $comment;
s[$sequenceInsertfile] _ $insertfile;
RETURN[s];
};

InvalidSequenceType: PROC[seq: IPXerox.SequenceType] ~ {
ERROR IPReader.Error[$illegalToken, "Sequence token has illegal SequenceType."];
};

InvalidEncodingValue: PROC[ev: IPXerox.EncodingValue] ~ {
ERROR IPReader.Error[$illegalToken, "Op token has illegal EncodingValue."];
};


xeroxReader: IPReader.Class ~ NEW[IPReader.ClassRep _ [
encoding: $Xerox,
getToken: XeroxGetToken,
readInt: XeroxReadInt,
readRational: XeroxReadRational,
readReal: XeroxReadReal,
readLargeVector: XeroxReadLargeVector,
finishBody: XeroxFinishBody
]];

GetByte: PROC[stream: STREAM] RETURNS[BYTE] ~ INLINE {
RETURN[LOOPHOLE[IO.GetChar[stream]]] };

SkipBytes: PROC[stream: STREAM, count: INT] ~ INLINE {
IO.SetIndex[stream, IO.GetIndex[stream]+count] };

SequenceDescriptor: TYPE ~ RECORD[type: IPXerox.SequenceType, length: INT];

GetSequenceDescriptor: PROC[stream: STREAM] RETURNS[SequenceDescriptor] ~ {
a: BYTE ~ GetByte[stream];
IF a<300B THEN ERROR IPReader.Error[$bug, "Expected a sequence token."]
ELSE RETURN[[type: VAL[a MOD 40B], length: GetSequenceLength[stream, a]]];
};

GetSequenceLength: PROC[stream: STREAM, a: BYTE] RETURNS[length: INT] ~ {
IF a<300B THEN ERROR;
length _ GetByte[stream];
IF a<340B THEN NULL -- short
ELSE { -- long
length _ length*400B+GetByte[stream];
length _ length*400B+GetByte[stream];
};
};

Continued: PROC[a: BYTE] RETURNS[BOOL] ~ INLINE {
RETURN[a>=300B AND IPXerox.SequenceType[VAL[a MOD 40B]]=$sequenceContinued];
};

XeroxGetSimpleToken: PROC[reader: Reader, flushComments: BOOL _ TRUE]
RETURNS[token: Token _ IPReader.nullToken] ~ {
stream: STREAM ~ reader.stream;
DO a: BYTE;
token.index _ IO.GetIndex[stream];
a _ GetByte[stream ! IO.EndOfStream => { token.type _ $eof; EXIT }]; -- 1st byte
IF a<200B THEN { -- Short Number
[] _ GetByte[stream];
token.type _ $shortNumber; EXIT;
}
ELSE IF a<300B THEN { -- Op
ev: IPXerox.EncodingValue;
IF a<240B THEN ev _ VAL[a MOD 40B] -- short
ELSE ev _ VAL[(a MOD 40B)*400B+GetByte[stream]]; -- long
token.op _ decode[ev];
IF token.op=$nil THEN InvalidEncodingValue[ev];
token.type _ $op; EXIT;
}
ELSE { -- Sequence
seq: IPXerox.SequenceType ~ VAL[a MOD 40B];
token.type _ sequenceTokenType[seq];
IF token.type=$nil THEN InvalidSequenceType[seq];
DO -- scan sequence data
length: INT ~ GetSequenceLength[stream, a];
SkipBytes[stream, length];
a _ GetByte[stream ! IO.EndOfStream => EXIT]; -- peek at next byte
IF Continued[a] THEN LOOP -- append continuation
ELSE { stream.Backup[VAL[a]]; EXIT }; -- put it back
ENDLOOP;
IF flushComments AND token.type=$comment THEN LOOP ELSE EXIT;
};
ENDLOOP;
};

XeroxGetToken: PROC[reader: Reader, buffer: REF TEXT _ NIL, flushComments: BOOL _ TRUE]
RETURNS[token: Token _ IPReader.nullToken, text: REF TEXT _ NIL] ~ {
stream: STREAM ~ reader.stream;
DO a: BYTE;
token.index _ stream.GetIndex[];
a _ GetByte[stream ! IO.EndOfStream => { token.type _ $eof; EXIT }]; -- 1st byte
IF a<200B THEN { -- Short Number
token.shortNumber _ IPXerox.ShortNumber.FIRST+a*400B+GetByte[stream];
token.type _ $shortNumber; EXIT;
}
ELSE IF a<300B THEN { -- Op
ev: IPXerox.EncodingValue _ VAL[a MOD 40B];
IF a<240B THEN NULL -- short
ELSE ev _ VAL[ORD[ev]*400B+GetByte[stream]]; -- long
token.op _ decode[ev];
IF token.op=$nil THEN InvalidEncodingValue[ev];
token.type _ $op; EXIT;
}
ELSE { -- Sequence
seq: IPXerox.SequenceType ~ VAL[a MOD 40B];
skip: BOOL _ FALSE;
token.type _ sequenceTokenType[seq];
SELECT token.type FROM
$nil => InvalidSequenceType[seq];
$largeVector => skip _ TRUE;
$comment => skip _ flushComments;
ENDCASE;
IF skip OR buffer=NIL THEN text _ NIL
ELSE { text _ buffer; text.length _ 0 };
DO -- scan sequence data
length: INT ~ GetSequenceLength[stream, a];
IF text=NIL THEN SkipBytes[stream, length]
ELSE {
count: NAT ~ length;
text _ RefText.InlineReserveChars[text, count];
IF stream.GetBlock[block: text, startIndex: text.length, count: count]=count THEN NULL
ELSE ERROR IO.EndOfStream[stream];
};
a _ GetByte[stream ! IO.EndOfStream => EXIT]; -- peek at next byte
IF Continued[a] THEN LOOP -- append continuation
ELSE { stream.Backup[VAL[a]]; EXIT }; -- put it back
ENDLOOP;
IF flushComments AND token.type=$comment THEN LOOP ELSE EXIT;
};
ENDLOOP;
};

XeroxFinishBody: PROC[reader: Reader] ~ {
stream: STREAM ~ reader.stream;
DO a: BYTE ~ GetByte[stream]; -- 1st byte
IF a<200B THEN [] _ GetByte[stream] -- Short Number
ELSE IF a<300B THEN { -- Op
ev: IPXerox.EncodingValue;
IF a<240B THEN ev _ VAL[a MOD 40B] -- short
ELSE ev _ VAL[(a MOD 40B)*400B+GetByte[stream]]; -- long
IF ev=$endBody THEN EXIT;
IF ev=$beginBody THEN XeroxFinishBody[reader];
}
ELSE { -- Sequence
length: INT ~ GetSequenceLength[stream, a];
SkipBytes[stream, length]; -- skip data bytes
};
ENDLOOP;
};

ParseInt: PROC[text: REF TEXT, start, len: NAT] RETURNS[INT] ~ {
val: INT _ 0;
state: {first, pos, neg} _ first;
IF len>4 THEN ERROR IPReader.Error[$overflow, "Number is too big for an INT."];
FOR i: NAT IN[start..start+len) DO
b: BYTE ~ LOOPHOLE[text[i]];
SELECT state FROM
first => IF b<200B THEN { val _ b; state _ pos } ELSE { val _ 377B-b; state _ neg };
pos => val _ val*400B+b;
neg => val _ val*400B+(377B-b);
ENDCASE;
ENDLOOP;
RETURN[IF state=neg THEN -1-val ELSE val];
};

ParseReal: PROC[text: REF TEXT, start, len: NAT] RETURNS[REAL] ~ {
val: REAL _ 0;
state: {first, pos, neg} _ first;
FOR i: NAT IN[start..start+len) DO
b: BYTE ~ LOOPHOLE[text[i]];
SELECT state FROM
first => IF b<200B THEN { val _ b; state _ pos } ELSE { val _ 377B-b; state _ neg };
pos => val _ val*400B+b;
neg => val _ val*400B+(377B-b);
ENDCASE;
ENDLOOP;
RETURN[IF state=neg THEN -1-val ELSE val];
};

XeroxReadInt: PROC[reader: Reader, token: Token, text: REF TEXT] RETURNS[INT] ~ {
SELECT token.type FROM
$shortNumber => RETURN[token.shortNumber];
$integer => RETURN[ParseInt[text: text, start: 0, len: text.length]];
ENDCASE => ERROR IPReader.Error[$wrongType, "Token type is not $integer."];
};

XeroxReadRational: PROC[reader: Reader, token: Token, text: REF TEXT] RETURNS[Rational] ~ {
SELECT token.type FROM
$rational => {
IF (text.length MOD 2)=0 THEN {
half: NAT ~ text.length/2;
num: INT ~ ParseInt[text: text, start: 0, len: half]; 
den: INT ~ ParseInt[text: text, start: half, len: half];
RETURN[[num, den]];
}
ELSE ERROR IPReader.Error[$illegalToken, "sequenceRational has odd length."]
};
ENDCASE => ERROR IPReader.Error[$wrongType, "Token type is not $rational."];
};

XeroxReadReal: PROC[reader: Reader, token: Token, text: REF TEXT] RETURNS[REAL] ~ {
SELECT token.type FROM
$shortNumber => RETURN[token.shortNumber];
$integer => RETURN[ParseReal[text: text, start: 0, len: text.length]];
$rational => {
IF (text.length MOD 2)=0 THEN {
half: NAT ~ text.length/2;
num: REAL ~ ParseReal[text: text, start: 0, len: half]; 
den: REAL ~ ParseReal[text: text, start: half, len: half];
RETURN[num/den];
}
ELSE ERROR IPReader.Error[$illegalToken, "sequenceRational has odd length."]
};
$real => ERROR IPReader.Error[$bug, "Token type $real unexpected."];
ENDCASE => ERROR IPReader.Error[$wrongType, "Token type is not $integer, $rational, or $real."];
};

lvProcs: REF IO.StreamProcs ~ IO.CreateStreamProcs[
variety: $input, class: $InterpressLargeVectorXerox,
getChar: LVGetChar,
unsafeGetBlock: LVUnsafeGetBlock,
endOf: LVEndOf,
getIndex: LVGetIndex,
setIndex: LVSetIndex,
getLength: LVGetLength
];

LVData: TYPE ~ REF LVDataRep;
LVDataRep: TYPE ~ RECORD[
master: STREAM, -- stream on the master file
tokenIndex: INT, -- index in master of first sequence token
seqType: IPXerox.SequenceType _ $nil, -- sequence type
bytesPerElement: BYTE _ 0, -- data bytes per vector element
rem: INT _ 0, -- number of data bytes remaining in current sequence token
index: INT _ 0, -- current stream index
length: INT _ unknownLength -- stream length, if known
];

unknownLength: INT ~ -1;

LVInit: PROC[data: LVData] ~ {
sd: SequenceDescriptor;
IO.SetIndex[data.master, data.tokenIndex];
sd _ GetSequenceDescriptor[data.master];
data.rem _ sd.length;
data.index _ 0;
SELECT (data.seqType _ sd.type) FROM
$sequenceLargeVector => {
IF MoreData[data] THEN {
char: CHAR ~ IO.GetChar[data.master];
data.rem _ data.rem-1;
data.bytesPerElement _ ORD[char];
}
ELSE ERROR IPReader.Error[$illegalToken, "sequenceLargeVector has zero length."];
};
$sequencePackedPixelVector,
$sequenceCompressedPixelVector,
$sequenceAdaptivePixelVector => data.bytesPerElement _ 2;
ENDCASE => ERROR IPReader.Error[$bug, "Invalid SequenceType for large vector."];
};

MoreData: PROC[data: LVData] RETURNS[BOOL] ~ {
IF data.length=unknownLength OR data.index#data.length THEN {
UNTIL data.rem>0 DO
peek: BYTE ~ GetByte[data.master ! IO.EndOfStream => GOTO End]; -- peek at next byte
IF Continued[peek] THEN data.rem _ GetSequenceLength[data.master, peek]
ELSE { IO.Backup[data.master, VAL[peek]]; GOTO End }; -- put it back
ENDLOOP;
RETURN[TRUE];
EXITS End => data.length _ data.index;
};
RETURN[FALSE];
};

LVGetChar: PROC[self: STREAM] RETURNS[CHAR] ~ {
data: LVData ~ NARROW[self.streamData];
IF MoreData[data] THEN {
char: CHAR ~ IO.GetChar[data.master];
data.rem _ data.rem-1;
data.index _ data.index+1;
RETURN[char];
}
ELSE ERROR IO.EndOfStream[self];
};

LVUnsafeGetBlock: UNSAFE PROC[self: STREAM, block: Basics.UnsafeBlock]
RETURNS[nBytesRead: INT _ 0] ~ {
data: LVData ~ NARROW[self.streamData];
chunk: Basics.UnsafeBlock _ block;
WHILE nBytesRead<block.count AND MoreData[data] DO
got: INT;
chunk.startIndex _ block.startIndex+nBytesRead;
chunk.count _ MIN[data.rem, block.count-nBytesRead];
TRUSTED { got _ IO.UnsafeGetBlock[data.master, chunk] };
IF got<chunk.count THEN ERROR IO.EndOfStream[data.master];
nBytesRead _ nBytesRead+got;
data.index _ data.index+got;
data.rem _ data.rem-got;
ENDLOOP;
};

LVEndOf: PROC[self: STREAM] RETURNS[BOOL] ~ {
data: LVData ~ NARROW[self.streamData];
RETURN[NOT MoreData[data]];
};

LVGetIndex: PROC[self: STREAM] RETURNS[INT] ~ {
data: LVData ~ NARROW[self.streamData];
RETURN[data.index];
};

LVSetIndex: PROC[self: STREAM, index: INT] ~ {
data: LVData ~ NARROW[self.streamData];
IF index<0 THEN ERROR IO.Error[$BadIndex, self];
IF index<data.index THEN LVInit[data];
WHILE data.index<index AND MoreData[data] DO
count: INT ~ MIN[data.rem, index-data.index];
SkipBytes[data.master, count];
data.rem _ data.rem-count;
data.index _ data.index+count;
ENDLOOP;
IF data.index<index THEN ERROR IO.EndOfStream[self];
};

LVGetLength: PROC[self: STREAM] RETURNS[INT] ~ {
data: LVData ~ NARROW[self.streamData];
IF data.length=unknownLength THEN ERROR;
RETURN[data.length];
};

XeroxReadLargeVector: PROC[reader: Reader, token: Token] RETURNS[IPReader.LargeVector] ~ {
SELECT token.type FROM
$largeVector => {
stream: STREAM ~ IPReader.StreamFromInputStream[reader.stream];
lvData: LVData ~ NEW[LVDataRep _ [master: stream, tokenIndex: token.index]];
LVInit[lvData];
RETURN[NEW[IPReader.LargeVectorRep _ [
source: IO.CreateStream[streamProcs: lvProcs, streamData: lvData],
bytesPerElement: lvData.bytesPerElement,
type: SELECT lvData.seqType FROM
$sequenceLargeVector => $nil,
$sequencePackedPixelVector => $packed,
$sequenceCompressedPixelVector => $compressed,
$sequenceAdaptivePixelVector => $adaptive,
ENDCASE => ERROR
]]];
};
ENDCASE => ERROR IPReader.Error[$wrongType, "Token type is not $largeVector."];
};

IPReader.Register[xeroxReader];

END.

RIPXeroxReaderImpl.mesa
Copyright c 1984 Xerox Corporation.  All rights reserved.
Doug Wyatt, August 24, 1984 10:41:00 am PDT

Continued: PROC[a: BYTE] RETURNS[BOOL] ~ INLINE {
RETURN[a>=300B AND (a MOD 40B)=ORD[IPXerox.SequenceType[$sequenceContinued]]];
};

Invariant: IF MoreData[data] THEN data.rem>0 ELSE data.index=data.length
�ÊO˜š
œ™Jšœ
Ïm
œ.™9Jš
œ+™+—J™š
Ïk	˜	Jšœžœžœ˜!Jšžœ
˜Jšœžœ&˜3Jšœ	žœ}˜‹
JšœžœM˜ZJšœžœ˜#Jšœžœžœ˜J˜—Jšœžœ
ž˜ Jšžœ
žœ˜&Jšœž˜J˜Jšžœžœžœ
˜Jšžœžœžœ
žœ
˜Jšžœžœ
žœ
˜J˜Jšœžœ˜Jšœ
žœ˜"J˜Jšœžœ˜Jšœžœ˜J˜Jšœžœžœ˜+Jš	œžœžœ
žœžœ˜BJ˜šÏnœžœ žœ˜SJšœžœžœ˜9Jšžœžœžœžœ
˜4Jšžœ	˜J˜J˜—Jš
œH˜HJ˜Jšœžœžœ˜+Jšœžœžœžœ˜JJ˜Jš
œ7˜7šŸœžœ
žœ˜2Jšœžœžœ˜5Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ%˜%Jš
œ˜Jš
œ'˜'Jš
œ-˜-Jš
œ1˜1Jš
œ/˜/Jš
œ˜Jš
œ%˜%Jšžœ˜
J˜J˜—šŸœžœ˜8JšžœK˜PJ˜J˜—šŸœžœ˜9JšžœF˜KJ˜J˜—J˜šœžœ˜7J˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ˜Jš
œ&˜&Jš
œ˜Jš
œ˜J˜—šŸœžœ	žœžœ
žœžœ˜6Jšžœ
žœ
žœ˜'J˜—š
Ÿ	œžœ	žœ	žœžœ˜6Jšžœžœ˜1J˜—Jšœžœžœ%žœ˜KJ˜šŸœžœ	žœžœ˜KJšœžœ˜Jšžœžœ
žœ3˜GJšžœ
žœžœžœ.˜JJ˜J˜—šŸœžœ	žœžœžœ	žœ˜IJšžœžœ
žœ
˜J˜Jšžœžœ
žœ
Ïc˜šžœ ˜Jš
œ%˜%Jš
œ%˜%J˜—J˜J˜—šŸ	œžœžœžœ
žœžœ™1Jšžœ	žœžœžœ,™NJ™J™—šŸ	œžœžœžœ
žœžœ˜1Jšžœ	žœžœžœ˜LJ˜J˜—šŸœžœ žœžœ
˜EJšžœ'˜.Jšœžœ˜šžœžœ
˜Jšœžœ˜"Jšœžœ%žœ ˜Pšžœžœ ˜ Jš
œ˜Jšœžœ
˜ J˜
—šžœ
žœžœ ˜Jš
œ˜Jš	žœžœžœžœ ˜+Jšžœžœžœ ˜8Jš
œ˜Jšžœžœ˜/Jšœžœ
˜J˜
—šžœ ˜Jšœžœžœ˜+Jš
œ$˜$Jšžœžœ˜1šžœ
 ˜Jšœžœ ˜+Jš
œ˜Jšœžœžœ ˜BJšžœžœ
žœ
 ˜0Jšžœžœžœ ˜4Jšžœ
˜—Jšžœžœžœ
žœ
žœ
žœ
˜=J˜—Jšžœ
˜—J˜J˜—šŸ
œžœžœ
žœžœžœžœ
˜WJšžœ*žœ
žœžœ˜DJšœžœ˜šžœžœ
˜Jš
œ ˜ Jšœžœ%žœ ˜Pšžœžœ ˜ Jšœ(žœ˜EJšœžœ
˜ J˜
—šžœ
žœžœ ˜Jšœžœžœ˜+Jšžœžœ
žœ
 ˜Jšžœžœ
žœ ˜4Jš
œ˜Jšžœžœ˜/Jšœžœ
˜J˜
—šžœ ˜Jšœžœžœ˜+Jšœžœžœ
˜Jš
œ$˜$šžœž˜Jš
œ!˜!Jšœžœ
˜Jš
œ!˜!Jšžœ
˜—Jš	žœžœžœ
žœž˜%Jšžœ$˜(šžœ
 ˜Jšœžœ ˜+Jšžœžœ
žœ˜*šžœ˜Jšœžœ
˜Jš
œ/˜/JšžœKžœ
ž˜VJšžœ
žœ
žœ˜"J˜—Jšœžœžœ ˜BJšžœžœ
žœ
 ˜0Jšžœžœžœ ˜4Jšžœ
˜—Jšžœžœžœ
žœ
žœ
žœ
˜=J˜—Jšžœ
˜—J˜J˜—šŸœžœ˜)Jšœžœ˜šžœžœ ˜)Jšžœžœ ˜3šžœ
žœžœ ˜Jš
œ˜Jš	žœžœžœžœ ˜+Jšžœžœžœ ˜8Jšžœ
žœ
žœ
˜Jšžœžœ˜.J˜
—šžœ ˜Jšœžœ ˜+Jšœ ˜-J˜—Jšžœ
˜—J˜J˜—šŸœžœžœ
žœžœžœ
žœ˜@Jšœžœ˜
J˜!Jšžœžœ
žœ<˜Ošžœžœ
žœž˜"Jšœžœžœ
˜šžœž˜Jšœ	žœžœžœ˜TJ˜Jš
œ˜Jšžœ
˜—Jšžœ
˜—Jšžœ
žœžœžœ˜*J˜—J˜šŸ	œžœžœ
žœžœžœ
žœ˜BJšœžœ˜J˜!šžœžœ
žœž˜"Jšœžœžœ
˜šžœž˜Jšœ	žœžœžœ˜TJ˜Jš
œ˜Jšžœ
˜—Jšžœ
˜—Jšžœ
žœžœžœ˜*J˜—J˜šŸœžœ%žœ
žœžœ
žœ˜Qšžœž˜Jšœžœ˜*Jšœžœ3˜EJšžœžœ;˜K—J˜J˜—š
Ÿœžœ%žœ
žœžœ˜[šžœž˜˜šžœžœžœ˜Jšœžœ˜Jšœžœ.˜6Jšœžœ0˜8Jšžœ
˜J˜
—Jšžœ
žœB˜LJ˜—Jšžœžœ<˜L—J˜J˜—šŸ
œžœ%žœ
žœžœ
žœ˜Sšžœž˜Jšœžœ˜*Jšœžœ4˜F˜šžœžœžœ˜Jšœžœ˜Jšœžœ/˜8Jšœžœ1˜:Jšžœ
˜J˜
—Jšžœ
žœB˜LJ˜—Jšœ	žœ6˜DJšžœžœP˜`—J˜J˜—šœ	žœ
žœžœ˜3Jš
œ4˜4Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jšœžœžœ˜šœžœžœ
˜Jšœžœ ˜,Jšœžœ *˜;Jšœ& ˜6Jšœžœ  ˜;Jšœžœ ;˜IJšœžœ ˜'Jšœžœ ˜6J˜J˜—Jšœžœ˜J˜šŸœžœ˜J˜Jšžœ(˜*J˜(J˜J˜šžœž˜$š
œ˜šžœžœ˜Jšœžœžœ˜%J˜Jšœžœ˜!J˜
—Jšžœ
žœG˜QJ˜—Jš
œ˜Jš
œ˜Jš
œ9˜9Jšžœžœ@˜P—J˜J˜—šŸœžœžœ
žœ˜.Jšœžœžœ'™Hšžœžœžœ˜=šžœž˜Jšœžœžœžœ ˜TJšžœžœ0˜GJš	žœžœžœ	žœ ˜DJšžœ
˜—Jšžœ
žœ˜
Jšžœ!˜&J˜—Jšžœ
žœ˜J˜J˜—š
Ÿ	œžœžœžœ
žœ˜/Jšœžœ˜'šžœžœ˜Jšœžœžœ˜%J˜J˜Jšžœ˜
J˜
—Jšžœ
žœ
žœ˜ J˜J˜—šŸœžœ
žœžœ˜FJšžœ
žœ	˜ Jšœžœ˜'Jš
œ"˜"šžœžœž˜2Jšœžœ
˜	Jš
œ/˜/Jšœžœ#˜4Jšžœ	žœ&˜8Jšžœžœ
žœ
žœ˜:Jš
œ˜Jš
œ˜J˜Jšžœ
˜—J˜J˜—š
Ÿœžœžœžœ
žœ˜-Jšœžœ˜'Jšžœ
žœ˜J˜J˜—š
Ÿ
œžœžœžœ
žœ˜/Jšœžœ˜'Jšžœ
˜J˜J˜—šŸ
œžœžœ	žœ˜.Jšœžœ˜'Jšžœ	žœ
žœ
žœ˜0Jšžœžœ˜&šžœžœž˜,Jšœžœžœ˜-J˜J˜J˜Jšžœ
˜—Jšžœžœ
žœ
žœ˜4J˜J˜—š
Ÿœžœžœžœ
žœ˜0Jšœžœ˜'Jšžœžœ
žœ
˜(Jšžœ˜J˜J˜—šŸœžœžœ˜Zšžœž˜š
œ˜Jšœžœ1˜?Jšœžœ8˜LJ˜šžœ
žœ˜&Jšœžœ8˜BJš
œ(˜(šœžœž˜ Jš
œ˜Jš
œ&˜&Jš
œ.˜.Jš
œ*˜*Jšžœž˜—Jš
œ˜—J˜—Jšžœžœ?˜O—J˜J˜—Jš
œ˜J˜Jšžœ
˜—…—2àE�