DIRECTORY
Basics USING [BYTE, LongNumber],
IO USING [Backup, EndOfStream, GetBlock, GetChar, GetIndex, GetLength, PutChar, PutRope, SetIndex, STREAM],
IP USING [Op, Vector],
IPMaster USING [Error, nullToken, Rational, Reader, ReaderProcs, ReaderProcsRep, RegisterEncoding, Token, TokenType, Writer, WriterProcs, WriterProcsRep],
IPXeroxEncoding USING [EncodingValue, SequenceType],
Real USING [DefaultSinglePrecision, NumberType, RealToPair],
RefText USING [InlineReserveChars],
Rope USING [Fetch, Length, ROPE];

IPXeroxMasterImpl: CEDAR PROGRAM
IMPORTS IO, IPMaster, Real, RefText, Rope
SHARES IPMaster
~ BEGIN OPEN IPMaster, IP;

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

BYTE: TYPE ~ Basics.BYTE;

ShortNumber: TYPE ~ [-4000..28767];
EncodingValue: TYPE ~ IPXeroxEncoding.EncodingValue;
SequenceType: TYPE ~ IPXeroxEncoding.SequenceType;

EncodeTable: TYPE ~ ARRAY Op OF EncodingValue;
DecodeTable: TYPE ~ PACKED ARRAY EncodingValue OF Op;

encode: REF EncodeTable ~ NEW[EncodeTable _ [nil: nil, get: get, makeveclu: makeveclu, makevec: makevec, shape: shape, openvec: openvec, getprop: getprop, getp: getp, mergeprop: mergeprop, frame: frame, fget: fget, fset: fset, poolop: poolop, pool: pool, pget: pget, pset: pset, env: env, makepool: makepool, nopool: nopool, makeco: makeco, makesimpleco: makesimpleco, do: do, dosave: dosave, dosaveall: dosaveall, dobody: dobody, dosavebody: dosavebody, dosaveallbody: dosaveallbody, dosavesimplebody: dosavesimplebody, makecompiledimage: makecompiledimage, pop: pop, copy: copy, dup: dup, roll: roll, exch: exch, mark: mark, unmark: unmark, unmark0: unmark0, count: count, nop: nop, error: error, if: if, ifelse: ifelse, ifcopy: ifcopy, loop: loop, eq: eq, eqname: eqname, gt: gt, ge: ge, and: and, or: or, not: not, type: type, add: add, sub: sub, neg: neg, abs: abs, floor: floor, ceiling: ceiling, trunc: trunc, round: round, mul: mul, div: div, mod: mod, rem: rem, max: max, min: min, sqrt: sqrt, exp: exp, log: log, sin: sin, cos: cos, atan: atan, iget: iget, iset: iset, dround: dround, maket: maket, opent: opent, translate: translate, rotate: rotate, scale: scale, scale2: scale2, concat: concat, invert: invert, transform: transform, transformvec: transformvec, roundxy: roundxy, roundxyvec: roundxyvec, concatt: concatt, move: move, trans: trans, show: show, showandxrel: showandxrel, setxy: setxy, setxyrel: setxyrel, setxrel: setxrel, setyrel: setyrel, getcp: getcp, getcprounded: getcprounded, makepixelarray: makepixelarray, extractpixelarray: extractpixelarray, finddecompressor: finddecompressor, makegray: makegray, findcolor: findcolor, findcoloroperator: findcoloroperator, findcolormodeloperator: findcolormodeloperator, makesampledcolor: makesampledcolor, makesampledblack: makesampledblack, setgray: setgray, moveto: moveto, lineto: lineto, linetox: linetox, linetoy: linetoy, curveto: curveto, conicto: conicto, arcto: arcto, makeoutline: makeoutline, maskfill: maskfill, maskstroke: maskstroke, maskstrokeclosed: maskstrokeclosed, maskvector: maskvector, maskrectangle: maskrectangle, startunderline: startunderline, maskunderline: maskunderline, masktrapezoidx: masktrapezoidx, masktrapezoidy: masktrapezoidy, maskpixel: maskpixel, clipoutline: clipoutline, cliprectangle: cliprectangle, findfont: findfont, findfontvec: findfontvec, modifyfont: modifyfont, setfont: setfont, correctmask: correctmask, correctspace: correctspace, correct: correct, setcorrectmeasure: setcorrectmeasure, setcorrecttolerance: setcorrecttolerance, space: space, beginBody: beginBody, endBody: endBody, beginBlock: beginBlock, endBlock: endBlock, pageInstructions: pageInstructions, noPages: noPages, metricMaster: metricMaster, environmentMaster: environmentMaster, beginVec: nil, comma: nil, endVec: nil]];

decode: REF DecodeTable ~ InvertEncodeTable[encode];

InvertEncodeTable: PROC[encode: REF EncodeTable] RETURNS[REF DecodeTable] ~ {
decode: REF DecodeTable ~ NEW[DecodeTable _ ALL[nil]];
FOR op: Op IN Op DO decode[encode[op]] _ op ENDLOOP;
RETURN[decode];
};

DefaultingTokenType: TYPE ~ TokenType _ $nil;
SequenceTable: TYPE ~ ARRAY SequenceType OF DefaultingTokenType;
sequenceTokenType: REF SequenceTable ~ InitSequenceTable[];
InitSequenceTable: PROC RETURNS[s: REF SequenceTable] ~ {
s _ NEW[SequenceTable _ ALL[$nil]];
s[$sequenceInteger] _ $integer;
s[$sequenceRational] _ $rational;
s[$sequenceFloating] _ $real;
s[$sequenceIdentifier] _ $identifier;
s[$sequenceString] _ $string;
s[$sequenceLargeVector] _ $vector;
s[$sequencePackedPixelVector] _ $vector;
s[$sequenceCompressedPixelVector] _ $vector;
s[$sequenceAdaptivePixelVector] _ $vector;
s[$sequenceComment] _ $comment;
s[$sequenceInsertfile] _ $insertfile;
};

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

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


xeroxReaderProcs: ReaderProcs ~ NEW[ReaderProcsRep _ [
getToken: XeroxGetToken,
readInt: XeroxReadInt,
readRational: XeroxReadRational,
readReal: XeroxReadReal,
readVector: XeroxReadVector,
finishBody: XeroxFinishBody
]];

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

SkipBytes: PROC[stream: STREAM, count: INT] ~ {
index: INT ~ stream.GetIndex[];
length: INT ~ stream.GetLength[];
IF count<=(length-index) THEN stream.SetIndex[index+count]
ELSE { stream.SetIndex[length]; ERROR IO.EndOfStream[stream] };
};

Continued: PROC[a: BYTE] RETURNS[BOOL] ~ {
IF a<300B THEN RETURN[FALSE]
ELSE RETURN[LOOPHOLE[a MOD 40B, SequenceType]=$sequenceContinued];
};

XeroxGetToken: PROC[reader: Reader, flushComments: BOOL _ TRUE] ~ {
stream: STREAM ~ reader.stream;
token: Token _ nullToken;
reader.text _ NIL; reader.length _ 0;
DO a: BYTE;
reader.index _ stream.GetIndex[];
a _ GetByte[stream ! IO.EndOfStream => { token.type _ $eof; EXIT }]; -- 1st byte
IF a<200B THEN { -- Short Number
reader.shortNumber _ ShortNumber.FIRST+a*400B+GetByte[stream];
token.type _ $shortNumber; EXIT;
}
ELSE IF a<300B THEN { -- Op
ev: [0..17777B] _ a MOD 40B;
IF a<240B THEN NULL -- short
ELSE ev _ ev*400B+GetByte[stream]; -- long
token.op _ decode[LOOPHOLE[ev, EncodingValue]];
IF token.op=$nil THEN InvalidEncodingValue[ev];
token.type _ $op; EXIT;
}
ELSE { -- Sequence
seq: SequenceType ~ LOOPHOLE[a MOD 40B];
text: REF TEXT _ reader.buffer;
text.length _ 0;
SELECT (token.type _ sequenceTokenType[seq]) FROM
$nil, $vector => text _ NIL;
$comment => IF flushComments THEN text _ NIL;
ENDCASE;
DO -- scan sequence data, including continuations
length: INT _ GetByte[stream];
IF a<340B THEN NULL -- short
ELSE { -- long
length _ length*400B+GetByte[stream];
length _ length*400B+GetByte[stream];
};
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];
};
reader.length _ reader.length+length;
a _ GetByte[stream ! IO.EndOfStream => EXIT]; -- peek at next byte
IF NOT Continued[a] THEN { stream.Backup[LOOPHOLE[a]]; EXIT }; -- put it back
ENDLOOP;
SELECT token.type FROM
$nil => InvalidSequenceType[seq];
$comment => IF flushComments THEN LOOP;
ENDCASE;
reader.text _ text;
EXIT;
};
ENDLOOP;
reader.token _ token;
};

XeroxFinishBody: PROC[reader: Reader] ~ {
stream: STREAM ~ reader.stream;
reader.token _ nullToken; reader.text _ NIL;
DO a: BYTE;
a _ GetByte[stream]; -- 1st byte
IF a<200B THEN { -- Short Number
[] _ GetByte[stream];
}
ELSE IF a<300B THEN { -- Op
ev: [0..17777B] _ a MOD 40B;
IF a<240B THEN NULL -- short
ELSE ev _ ev*400B+GetByte[stream]; -- long
SELECT LOOPHOLE[ev, EncodingValue] FROM
$beginBody => XeroxFinishBody[reader];
$endBody => EXIT;
ENDCASE;
}
ELSE { -- Sequence
length: INT _ GetByte[stream];
IF a<340B THEN NULL -- short
ELSE { -- long
length _ length*400B+GetByte[stream];
length _ length*400B+GetByte[stream];
};
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 Error[$overflow, "Too many bytes 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] RETURNS[INT] ~ {
token: Token ~ reader.token;
text: REF TEXT ~ reader.text;
SELECT token.type FROM
$integer => RETURN[ParseInt[text: text, start: 0, len: text.length]];
ENDCASE => ERROR Error[$illegalArgument, "Token type is not $integer."];
};

XeroxReadReal: PROC[reader: Reader] RETURNS[REAL] ~ {
token: Token ~ reader.token;
text: REF TEXT ~ reader.text;
SELECT token.type FROM
$integer => RETURN[ParseReal[text: text, start: 0, len: text.length]];
$real => ERROR Error[$bug, "Token type $real unexpected."];
ENDCASE => ERROR Error[$illegalArgument, "Token type is not $integer or $real."];
};

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

XeroxReadVector: PROC[reader: Reader] RETURNS[Vector] ~ {
token: Token ~ reader.token;
text: REF TEXT ~ reader.text;
SELECT token.type FROM
$vector => ERROR Error[$unimplemented, "Can't handle a Vector token yet."];
ENDCASE => ERROR Error[$illegalArgument, "Token is not a vector."];
};


xeroxWriterProcs: WriterProcs ~ NEW[WriterProcsRep _ [
putOp: XeroxPutOp,
putInt: XeroxPutInt,
putReal: XeroxPutReal,
putRational: XeroxPutRational,
putIdentifier: XeroxPutIdentifier,
putString: XeroxPutString,
putInsertfile: XeroxPutInsertfile,
putComment: XeroxPutComment,
putAnnotation: XeroxPutAnnotation
]];


AppendByte: PROC[stream: STREAM, byte: BYTE] ~ INLINE {
stream.PutChar[LOOPHOLE[byte]];
};

NBytes: TYPE ~ [0..4];

BytesInInt: PROC[i: INT] RETURNS[NBytes] ~ {
SELECT i FROM
IN[-LONG[200B]..LONG[200B]) => RETURN[1];
IN[-LONG[100000B]..LONG[100000B]) => RETURN[2];
IN[-40000000B..40000000B) => RETURN[3];
ENDCASE => RETURN[4];
};

AppendInt: PROC[stream: STREAM, int: INT, b: NBytes] ~ {
IF b>3 THEN AppendByte[stream, LOOPHOLE[int, Basics.LongNumber].hh];
IF b>2 THEN AppendByte[stream, LOOPHOLE[int, Basics.LongNumber].hl];
IF b>1 THEN AppendByte[stream, LOOPHOLE[int, Basics.LongNumber].lh];
IF b>0 THEN AppendByte[stream, LOOPHOLE[int, Basics.LongNumber].ll];
};

AppendSequenceDescriptor: PROC[stream: STREAM, type: SequenceType, length: INT] ~ {
x: [0..40B) ~ LOOPHOLE[type];
SELECT length FROM
<0 => ERROR Error[$bug, "Sequence length is negative."];
<=377B => { AppendByte[stream, 300B+x]; AppendInt[stream, length, 1] }; -- short
<=77777777B => { AppendByte[stream, 340B+x]; AppendInt[stream, length, 3] }; -- long
ENDCASE => ERROR Error[$bug, "Sequence length is too big."];
};

XeroxPutOp: PROC[writer: Writer, op: Op] ~ {
stream: STREAM ~ writer.stream;
ev: EncodingValue ~ encode[op];
IF ev#nil THEN {
x: [0..17777B] ~ LOOPHOLE[ev];
IF x<40B THEN AppendByte[stream, 200B+x] -- short
ELSE { AppendByte[stream, 240B+x/400B]; AppendByte[stream, x MOD 400B] }; -- long
}
ELSE ERROR Error[$illegalArgument, "PutOp[nil] is illegal."];
};

XeroxPutInt: PROC[writer: Writer, value: INT] ~ {
stream: STREAM ~ writer.stream;
IF value IN[ShortNumber.FIRST .. ShortNumber.LAST] THEN {
x: [0..77777B] ~ value-ShortNumber.FIRST;
AppendByte[stream, x/400B]; AppendByte[stream, x MOD 400B];
}
ELSE {
b: NBytes ~ BytesInInt[value];
AppendSequenceDescriptor[stream, sequenceInteger, b];
AppendInt[stream, value, b];
};
};

XeroxPutRational: PROC[writer: Writer, value: Rational] ~ {
stream: STREAM ~ writer.stream;
WITH value: value SELECT FROM
int => {
bn: NBytes ~ BytesInInt[value.num];
bd: NBytes ~ BytesInInt[value.den];
b: NBytes ~ MAX[bn, bd];
AppendSequenceDescriptor[stream, sequenceRational, 2*b];
AppendInt[stream, value.num, b];
AppendInt[stream, value.den, b];
};
real => Error[$unimplemented, "Can't handle real variant of Rational."];
ENDCASE => ERROR;
};

PowerIndex: TYPE ~ [0..9];
PowerArray: TYPE ~ ARRAY PowerIndex OF INT;
power: REF READONLY PowerArray ~ NEW[PowerArray =
[1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000]];

XeroxPutReal: PROC[writer: Writer, value: REAL] ~ {
type: Real.NumberType; fr: INT; exp10: INTEGER;
[type, fr, exp10] _ Real.RealToPair[value, Real.DefaultSinglePrecision];
SELECT type FROM
normal =>
IF exp10=0 THEN XeroxPutInt[writer, fr]
ELSE {
e: INTEGER _ -exp10;
f: INT _ fr;
THROUGH[0..10) WHILE (f MOD 10)=0 DO f _ f/10; e _ e-1 ENDLOOP;
IF e IN PowerIndex THEN XeroxPutRational[writer, [int[f, power[e]]]]
ELSE ERROR Error[$bug, "Failed to convert a REAL to a RATIONAL."];
};
zero => XeroxPutInt[writer, 0];
ENDCASE => ERROR Error[$illegalArgument, "Illegal value for a REAL."];
};

XeroxPutIdentifier: PROC[writer: Writer, rope: ROPE] ~ {
stream: STREAM ~ writer.stream;
len: INT ~ rope.Length[];
IF len=0 THEN ERROR Error[$illegalArgument, "Identifier may not have zero length."];
FOR i: INT IN[0..len) DO
char: CHAR ~ rope.Fetch[i];
IF i=0 THEN SELECT char FROM
IN['a..'z], IN['A..'Z] => NULL;
ENDCASE => ERROR Error[$illegalArgument, "Identifier must begin with a letter."]
ELSE SELECT char FROM
IN['a..'z], IN['A..'Z], IN['0..'9], '- => NULL;
ENDCASE => ERROR Error[$illegalArgument, "Illegal character in identifier."];
ENDLOOP;
AppendSequenceDescriptor[stream, sequenceIdentifier, len];
stream.PutRope[rope];
};

XeroxPutString: PROC[writer: Writer, rope: ROPE] ~ {
stream: STREAM ~ writer.stream;
AppendSequenceDescriptor[stream, sequenceString, rope.Length[]];
stream.PutRope[rope];
};

XeroxPutInsertfile: PROC[writer: Writer, rope: ROPE] ~ {
stream: STREAM ~ writer.stream;
AppendSequenceDescriptor[stream, sequenceInsertfile, rope.Length[]];
stream.PutRope[rope];
};

XeroxPutComment: PROC[writer: Writer, rope: ROPE] ~ {
stream: STREAM ~ writer.stream;
AppendSequenceDescriptor[stream, sequenceComment, rope.Length[]];
stream.PutRope[rope];
};

XeroxPutAnnotation: PROC[writer: Writer, rope: ROPE] ~ {
ERROR Error[$unimplemented, "Xerox encoding doesn't have annotations."];
};


RegisterEncoding[name: "Xerox", version: [2, 1],
readerProcs: xeroxReaderProcs, writerProcs: xeroxWriterProcs];

END.


ÔIPXeroxMasterImpl.mesa

Last edited by:
Doug Wyatt, March 1, 1984 2:57:47 pm PST
StringMap: PROC[rope: ROPE, action: PROC[CARDINAL] RETURNS[BOOL]] RETURNS[BOOL] ~ {
size: INT ~ rope.Size[];
i: INT _ 0; -- current index into rope
offset: CARDINAL _ 0; -- current offset
Get: PROC RETURNS[BYTE] ~ INLINE {
c: CHAR ~ rope.Fetch[i]; i _ i+1; RETURN[LOOPHOLE[c]] };
WHILE i<size DO
c: BYTE ~ Get[];
IF c=255 THEN { IF i<size THEN offset _ Get[]*256 }
ELSE IF action[offset+c] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};

StringShape: PROC[self: Vector] RETURNS[VectorShape] ~ {
rope: ROPE ~ NARROW[self.data];
n: Integer _ 0; -- vector element count
action: PROC[c: CARDINAL] RETURNS[BOOL] ~ {
IF n<maxInteger THEN { n _ n+1; RETURN[FALSE] }
ELSE RETURN[TRUE];
};
IF StringMap[rope, action] THEN ERROR IPOps.MasterError[LimitExceeded]
ELSE RETURN[[l: 0, n: n]];
};

StringGet: PROC[self: Vector, n: Integer] RETURNS[Any] ~ {
rope: ROPE ~ NARROW[self.data];
i: INT _ 0; -- current vector index
result: CARDINAL _ 0;
action: PROC[c: CARDINAL] RETURNS[BOOL] ~ {
IF i=n THEN { result _ c; RETURN[TRUE] }
ELSE { i _ i+1; RETURN[FALSE] };
};
IF StringMap[rope, action] THEN RETURN[IPOps.IntegerToAny[result]]
ELSE ERROR IPOps.MasterError[BoundsFault];
};

GetVector: PROC[self: Ref, token: Token] RETURNS[Vector] ~ {
IF token.type=vector THEN {
stream: STREAM ~ GetRR[self, token.index];
seq: SequenceDescriptor ~ GetDescriptor[stream];
IF seq.type=sequenceString THEN {
get: PROC RETURNS[CHAR] ~ { RETURN[stream.Get[]] };
rope: ROPE ~ Rope.FromProc[seq.length, get];
RETURN[NEW[VectorRep _ [class: $String,
shape: StringShape, get: StringGet, data: rope]]];
}
ELSE ERROR Error["unimplemented vector type"];
}
ELSE ERROR Error["wrong token type"];
};
�ʘJš
œ™J™š
œ™Jš
œ(™(J˜—š
Ïk	˜	Jšœ�œ�œ˜ Jš�œ
�œ[�œ˜kJš�œ
�œ˜Jšœ	�œŒ
˜š
Jšœ�œ˜4Jšœ�œ2˜<Jšœ�œ˜#Jšœ�œ�œ˜!J˜—Jšœ�œ
�˜ Jš�œ
�œ˜)Jš�œ	˜Jšœ�œ
�œ�œ
˜J˜Jš�œ�œ�œ
˜Jš�œ�œ�œ
�œ
˜J˜Jš�œ�œ
�œ
˜J˜Jšœ
�œ˜#Jšœ�œ!˜4Jšœ�œ ˜2J˜Jšœ
�œ�œ�œ˜.Jš	œ
�œ�œ
�œ�œ˜5J˜Jšœ�œ�œá˜þJ˜Jšœ�œ)˜4J˜š
Ïnœ�œ	�œ�œ
�œ˜MJšœ�œ�œ�œ˜6Jš�œ�œ�œ�œ
˜4Jš�œ	˜J˜J˜—Jšœ�œ˜-Jšœ�œ�œ�œ˜@Jšœ�œ%˜;šžœ�œ
�œ�œ˜9Jšœ�œ�œ˜#Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ%˜%Jš
œ˜Jš
œ"˜"Jš
œ(˜(Jš
œ,˜,Jš
œ*˜*Jš
œ˜Jš
œ%˜%J˜J˜—šžœ�œ˜0Jš�œB˜GJ˜J˜—šžœ�œ�œ˜'Jš�œ=˜BJ˜J˜—J˜šœ �œ˜6Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—šžœ�œ	�œ�œ
�œ�œ˜6Jš�œ
�œ˜"Jš
œ˜J˜—šž	œ�œ	�œ	�œ˜/Jšœ�œ˜Jšœ�œ˜!Jš�œ�œ˜:Jš�œ�œ
�œ˜?Jš
œ˜J˜—š
ž	œ�œ�œ�œ
�œ˜*Jš�œ�œ
�œ
�œ
˜Jš�œ
�œ
�œ�œ(˜BJ˜J˜—šž
œ�œ �œ�œ˜CJšœ�œ˜Jš
œ˜Jšœ�œ˜%š�œ�œ
˜Jš
œ!˜!Jšœ�œ%�œÏc˜Pš�œ�œŸ˜ Jšœ!�œ˜>Jšœ�œ
˜ J˜
—š�œ
�œ�œŸ˜Jšœ�œ˜Jš�œ�œ
�œ
Ÿ˜Jš�œŸ˜*Jšœ�œ˜/Jš�œ�œ˜/Jšœ�œ
˜J˜
—š�œŸ˜Jšœ�œ�œ˜(Jšœ�œ
�œ˜J˜š�œ'�˜1Jšœ�œ
˜Jšœ�œ�œ�œ
˜-Jš�œ
˜—š�œ
Ÿ.˜1Jšœ�œ˜Jš�œ�œ
�œ
Ÿ˜š�œŸ˜Jš
œ%˜%Jš
œ%˜%J˜—Jš�œ�œ
�œ˜*š�œ˜Jšœ�œ
˜Jš
œ/˜/Jš�œK�œ
�˜VJš�œ
�œ
�œ˜"J˜—J˜%Jšœ�œ�œŸ˜BJš�œ
�œ�œ�œ�œŸ˜MJš�œ
˜—š�œ�˜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š�œ
˜—J˜J˜—šžœ�œ�œ
�œ�œ�œ
�œ˜@Jšœ�œ˜
J˜!Jš�œ�œ
�œ0˜Cš�œ�œ
�œ�˜"Jšœ�œ�œ
˜š�œ�˜Jšœ	�œ�œ�œ˜TJ˜Jš
œ˜Jš�œ
˜—Jš�œ
˜—Jš�œ
�œ�œ�œ˜*J˜—J˜šž	œ�œ�œ
�œ�œ�œ
�œ˜BJšœ�œ˜J˜!š�œ�œ
�œ�˜"Jšœ�œ�œ
˜š�œ�˜Jšœ	�œ�œ�œ˜TJ˜Jš
œ˜Jš�œ
˜—Jš�œ
˜—Jš�œ
�œ�œ�œ˜*J˜—J˜šžœ�œ�œ
�œ˜3Jš
œ˜Jšœ�œ
�œ˜š�œ�˜Jšœ�œ3˜EJš�œ�œ8˜H—J˜J˜—šž
œ�œ�œ
�œ˜5Jš
œ˜Jšœ�œ
�œ˜š�œ�˜Jšœ�œ4˜FJšœ	�œ-˜;Jš�œ�œA˜Q—J˜J˜—šžœ�œ�œ˜=Jš
œ˜Jšœ�œ
�œ˜š�œ�˜˜š�œ�œ�œ˜Jšœ�œ˜š�œ	�œ˜Jšœ�œ-˜5Jšœ�œ0˜8Jš�œ˜J˜
—š�œ˜Jšœ�œ.˜7Jšœ�œ1˜:Jš�œ˜J˜—J˜
—Jš�œ
�œ9˜CJ˜—Jš�œ�œ9˜I—J˜J˜—šžœ�œ�œ˜9Jš
œ˜Jšœ�œ
�œ˜š�œ�˜Jšœ�œ;˜KJš�œ�œ3˜C—J˜J˜—J˜šœ �œ˜6Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜Jš
œ"˜"Jš
œ˜Jš
œ!˜!Jš
œ˜J˜—J˜š
ž
œ�œ	�œ�œ�œ˜7Jšœ�œ˜Jš
œ˜J˜—Jšœ�œ
˜J˜šž
œ�œ�œ�œ˜,š�œ�˜
Jš�œ�œ�œ�œ˜)Jš�œ�œ�œ�œ˜/Jš�œ�œ˜'Jš�œ�œ˜—J˜J˜—šž	œ�œ	�œ�œ˜8Jš�œ�œ�œ˜DJš�œ�œ�œ˜DJš�œ�œ�œ˜DJš�œ�œ�œ˜DJ˜J˜—šžœ�œ	�œ�œ˜SJšœ�œ˜š�œ�˜Jšœ�œ-˜8JšœHŸ˜PJšœMŸ˜TJš�œ�œ,˜<—J˜J˜—šž
œ�œ˜,Jšœ�œ˜J˜š�œ�œ˜Jšœ�œ˜Jš�œ�œŸ˜1Jš�œ9�œ
Ÿ˜QJ˜
—Jš�œ
�œ3˜=Jš
œ˜J˜—šžœ�œ�œ˜1Jšœ�œ˜š
�œ�œ
�œ�œ�œ˜9Jšœ#�œ
˜)Jšœ1�œ˜;J˜
—š�œ˜Jš
œ˜Jš
œ5˜5J˜J˜—Jš
œ˜J˜—šžœ�œ%˜;Jšœ�œ˜š�œ�œ
�˜˜Jš
œ#˜#Jš
œ#˜#Jšœ�œ	˜Jš
œ8˜8Jš
œ ˜ Jš
œ ˜ J˜—Jš
œH˜HJš�œ�œ
˜—Jš
œ˜J˜—Jšœ�œ
˜Jš	œ�œ�œ�œ
�œ
˜+šœ�œ
�œ�œ
˜1Jš
œM˜MJ˜—šžœ�œ�œ˜3Jšœ�œ	�œ
˜/Jš
œH˜Hš�œ�˜š
œ	˜	Jš�œ	�œ˜'š�œ˜Jšœ�œ
˜Jšœ�œ˜Jš
�œ�œ�œ�œ�œ
˜?Jš�œ�œ�œ-˜DJš�œ
�œ8˜BJ˜——J˜Jš�œ�œ6˜F—Jš
œ˜J˜—šžœ�œ�œ˜8Jšœ�œ˜Jšœ�œ˜Jš�œ�œ
�œA˜Tš�œ�œ
�œ	�˜Jšœ�œ˜š�œ�œ
�œ�˜Jš�œ
�œ�œ
˜Jš�œ�œ@˜P—š�œ
�œ�˜Jš�œ
�œ
�œ�œ
˜/Jš�œ�œ=˜M—Jš�œ
˜—Jš
œ:˜:J˜Jš
œ˜J˜—šžœ�œ�œ˜4Jšœ�œ˜Jš
œ@˜@J˜Jš
œ˜J˜—šžœ�œ�œ˜8Jšœ�œ˜Jš
œD˜DJ˜Jš
œ˜J˜—šžœ�œ�œ˜5Jšœ�œ˜Jš
œA˜AJ˜Jš
œ˜J˜—šžœ�œ�œ˜8Jš�œC˜HJš
œ˜J˜—J˜˜0J˜>—J˜Jš�œ
˜J˜šž	œ�œ�œ
�œ
�œ�œ
�œ�œ
�œ™SJšœ�œ™Jšœ�œŸ™&Jšœ�œŸ™'š
žœ�œ
�œ
�œ�œ™"Jšœ�œ�œ
�œ™8—š�œ�™Jšœ�œ	™Jš�œ�œ�œ�œ™3Jš
�œ
�œ�œ
�œ
�œ™+Jš�œ
™—Jš�œ
�œ™J™—J™šžœ�œ�œ™8Jšœ�œ�œ™JšœŸ™'š	œ�œ�œ�œ
�œ™+Jš�œ�œ�œ
�œ™/Jš�œ
�œ
�œ™Jš
œ™—Jš�œ�œ
�œ!™FJš�œ
�œ™J™—J™šž	œ�œ�œ	™:Jšœ�œ�œ™Jšœ�œŸ™#Jšœ�œ™š	œ�œ�œ�œ
�œ™+Jš�œ�œ�œ
�œ™(Jš�œ�œ
�œ™ J™—Jš�œ�œ
�œ™BJš�œ
�œ ™*J™—J™šž	œ�œ�œ™<š�œ�œ™Jšœ�œ™*J™0š�œ�œ™!Jš	œ�œ
�œ
�œ�œ™3Jšœ�œ"™,š�œ
�œ™'Jš
œ2™2—J™
—Jš�œ
�œ$™.J™
—Jš�œ
�œ™%J™—J˜—…—;æUÏ