DIRECTORY
PS,
Ascii,
Convert,
IO,
Real,
RefText;

PSScannerImpl: CEDAR PROGRAM
IMPORTS PS, Convert, IO, Real, RefText
EXPORTS PS
~ BEGIN OPEN PS;

Class: TYPE ~ {
newLine, -- CR, LF
space, -- SP, TAB
openParen, -- '(
closeParen, -- ')
openBracket, -- '[
closeBracket, -- ']
openAngle, -- '<
closeAngle, -- '>
openBrace, -- '{
closeBrace, -- '}
slash, -- '/
percent, -- '%
dot, -- '.
hash, -- '#
sign, -- '+, '-
digitOctal, -- IN ['0..'7]
digitOther, -- IN ['0..'9]  (other than digitOctal)
letterE, -- 'E, 'e
letterHex, -- IN ['A..'F], IN ['a..'f]  (other than letterE)
letterOther, -- IN ['A..'Z], IN ['a..'z]  (other than letterE, letterHex)
backslash, -- '\
other -- everything else
};

WhiteSpace: TYPE ~ Class[newLine..space];
Special: TYPE ~ Class[openParen..percent];
Regular: TYPE ~ Class[dot..other];
DecimalDigit: TYPE ~ Class[digitOctal..digitOther]; -- ['0..'9]
HexDigit: TYPE ~ Class[digitOctal..letterHex]; -- ['0..'9], ['A..'F], ['a..'f]
RadixDigit: TYPE ~ Class[digitOctal..letterOther]; -- ['0..'9], ['A..'Z], ['a..'z]

ClassArray: TYPE ~ PACKED ARRAY CHAR OF Class;

InitClassArray: PROC RETURNS [array: REF ClassArray] ~ {
array _ NEW [ClassArray];
FOR char: CHAR IN CHAR DO
array[char] _ SELECT char FROM
Ascii.CR, Ascii.LF => newLine,
Ascii.SP, Ascii.TAB => space,
'( => openParen,
') => closeParen,
'[ => openBracket,
'] => closeBracket,
'< => openAngle,
'> => closeAngle,
'{ => openBrace,
'} => closeBrace,
'/ => slash,
'% => percent,
'. => dot,
'# => hash,
'+, '- => sign,
IN ['0..'7] => digitOctal,
IN ['0..'9] => digitOther,
'E, 'e => letterE,
IN ['A..'F], IN ['a..'f] => letterHex,
IN ['A..'Z], IN ['a..'z] => letterOther,
'\\ => backslash,
ENDCASE => other;
ENDLOOP;
};

classFromChar: REF ClassArray ~ InitClassArray[];


Digit: TYPE ~ [0..36);

DigitArray: TYPE ~ PACKED ARRAY CHAR OF Digit;

InitDigitArray: PROC RETURNS [array: REF DigitArray] ~ {
array _ NEW [DigitArray];
FOR char: CHAR IN CHAR DO
array[char] _ SELECT char FROM
IN ['0..'9] => char-'0,
IN ['A..'Z] => 10+(char-'A),
IN ['a..'z] => 10+(char-'a),
ENDCASE => 0;
ENDLOOP;
};

digit: REF DigitArray ~ InitDigitArray[];


EscapeArray: TYPE ~ PACKED ARRAY CHAR OF CHAR;

InitEscapeArray: PROC RETURNS [array: REF EscapeArray] ~ {
array _ NEW [EscapeArray];
FOR char: CHAR IN CHAR DO
array[char] _ SELECT char FROM
'n => Ascii.LF,
'r => Ascii.CR,
't => Ascii.TAB,
'b => Ascii.BS,
'f => Ascii.FF,
IN ['0..'7] => VAL[digit[char]],
ENDCASE => char;
ENDLOOP;
};

escape: REF EscapeArray ~ InitEscapeArray[];


State: TYPE ~ {
empty, -- only whitespace so far
sign, -- + | -
int0, -- digit | int0 digit   a valid integer (without sign)
int1, -- sign digit | int1 digit   a valid integer (with sign)
real0, -- . | sign .
real1, -- ( int0 | int1 ) . | real0 digit | real1 digit   a valid real (without exponent)
real2, -- ( int0 | int1 | real1 ) ( e | E )
real3, -- real2 ( + | - )
real4, -- ( real2 | real3 ) digit | real4 digit   a valid real (with exponent)
radix0, -- int0 #
radix1, -- radix0 rdigit | radix1 rdigit   a valid radix number
slash, -- /
name, -- char | slash char | // | name char   a sequence of regular chars
string0, -- ( ...
string1, -- ( ... \
string2, -- ( ... \d
string3, -- ( ... \dd
hex0, -- < ...   even number of digits
hex1, -- < ...   odd number of digits
comment, -- % ...
string, -- ( ... )
hex, -- < ... >
proc0, -- {
proc1, -- }
error -- syntax error
};

Action: TYPE ~ {
skip, -- ignore char
putBack, -- return char to input source
append, -- append char to text buffer
noteSlash, -- note slash preceding name (ignore '/ and increment slash count)
stringStart, -- start string literal (ignore '( and start with next char)
stringChar, -- include char in string literal
escapeStart, -- begin escape sequence in string literal with '\
escapeChar, -- translate escape char following '\
escapeDigit, -- include another octal digit in escape sequence
hexDigit1, -- char is first hex digit
hexDigit2, -- char is second hex digit, append byte
hexFill -- use zero for missing second digit and append byte
};

TransitionResult: TYPE ~ RECORD [action: Action, state: State, stop: BOOL _ FALSE];

Transition: PROC [state: State, class: Class] RETURNS [TransitionResult] ~ {
SELECT state FROM
empty => {
IF class IN WhiteSpace THEN RETURN [[action: skip, state: empty]];
IF class IN Special THEN SELECT class FROM
openBrace => RETURN [[action: skip, state: proc0, stop: TRUE]];
closeBrace => RETURN [[action: skip, state: proc1, stop: TRUE]];
openBracket, closeBracket => RETURN [[action: append, state: name, stop: TRUE]];
openParen => RETURN [[action: stringStart, state: string0]];
openAngle => RETURN [[action: skip, state: hex0]];
slash => RETURN [[action: noteSlash, state: slash]];
percent => RETURN [[action: skip, state: comment]];
ENDCASE => RETURN [[action: append, state: error, stop: TRUE]];
};
IN[sign..name] => IF state=slash AND class=slash THEN NULL ELSE {
IF class IN WhiteSpace THEN RETURN [[action: skip, state: state, stop: TRUE]];
IF class IN Special THEN RETURN [[action: putBack, state: state, stop: TRUE]];
};
IN[hex0..hex1] => {
IF class IN WhiteSpace THEN RETURN [[action: skip, state: state]];
};
ENDCASE;
SELECT state FROM
empty => SELECT class FROM
sign => RETURN [[action: append, state: sign]];
dot => RETURN [[action: append, state: real0]];
IN DecimalDigit => RETURN [[action: append, state: int0]];
ENDCASE => RETURN [[action: append, state: name]];
sign => SELECT class FROM
dot => RETURN [[action: append, state: real0]];
IN DecimalDigit => RETURN [[action: append, state: int1]];
ENDCASE => RETURN [[action: append, state: name]];
int0 => SELECT class FROM
dot => RETURN [[action: append, state: real1]];
letterE => RETURN [[action: append, state: real2]];
hash => RETURN [[action: append, state: radix0]];
IN DecimalDigit => RETURN [[action: append, state: int0]];
ENDCASE => RETURN [[action: append, state: name]];
int1 => SELECT class FROM
dot => RETURN [[action: append, state: real1]];
letterE => RETURN [[action: append, state: real2]];
IN DecimalDigit => RETURN [[action: append, state: int1]];
ENDCASE => RETURN [[action: append, state: name]];
real0 => SELECT class FROM
IN DecimalDigit => RETURN [[action: append, state: real1]];
ENDCASE => RETURN [[action: append, state: name]];
real1 => SELECT class FROM
letterE => RETURN [[action: append, state: real2]];
IN DecimalDigit => RETURN [[action: append, state: real1]];
ENDCASE => RETURN [[action: append, state: name]];
real2 => SELECT class FROM
sign => RETURN [[action: append, state: real3]];
IN DecimalDigit => RETURN [[action: append, state: real4]];
ENDCASE => RETURN [[action: append, state: name]];
real3 => SELECT class FROM
IN DecimalDigit => RETURN [[action: append, state: real4]];
ENDCASE => RETURN [[action: append, state: name]];
real4 => SELECT class FROM
IN DecimalDigit => RETURN [[action: append, state: real4]];
ENDCASE => RETURN [[action: append, state: name]];
radix0 => SELECT class FROM
IN RadixDigit => RETURN [[action: append, state: radix1]];
ENDCASE => RETURN [[action: append, state: name]];
radix1 => SELECT class FROM
IN RadixDigit => RETURN [[action: append, state: radix1]];
ENDCASE => RETURN [[action: append, state: name]];
slash => SELECT class FROM
slash => RETURN [[action: noteSlash, state: name]];
ENDCASE => RETURN [[action: append, state: name]];
name => RETURN [[action: append, state: name]];
string0 => SELECT class FROM
closeParen => RETURN [[action: skip, state: string, stop: TRUE]];
backslash => RETURN [[action: escapeStart, state: string1]];
ENDCASE => RETURN [[action: stringChar, state: string0]];
string1 => SELECT class FROM
newLine => RETURN [[action: skip, state: string0]];
digitOctal => RETURN [[action: escapeChar, state: string2]];
ENDCASE => RETURN [[action: escapeChar, state: string0]];
string2 => SELECT class FROM
closeParen => RETURN [[action: skip, state: string, stop: TRUE]];
digitOctal => RETURN [[action: escapeDigit, state: string3]];
ENDCASE => RETURN [[action: stringChar, state: string0]];
string3 => SELECT class FROM
digitOctal => RETURN [[action: escapeDigit, state: string0]];
ENDCASE => RETURN [[action: stringChar, state: string0]];
hex0 => SELECT class FROM
closeAngle => RETURN [[action: skip, state: hex, stop: TRUE]];
IN HexDigit => RETURN [[action: hexDigit1, state: hex1]];
ENDCASE => RETURN [[action: skip, state: error, stop: TRUE]];
hex1 => SELECT class FROM
closeAngle => RETURN [[action: hexFill, state: hex, stop: TRUE]];
IN HexDigit => RETURN [[action: hexDigit2, state: hex0]];
ENDCASE => RETURN [[action: skip, state: error, stop: TRUE]];
comment => SELECT class FROM
newLine => RETURN [[action: skip, state: empty]];
ENDCASE => RETURN [[action: skip, state: comment]];
ENDCASE => RETURN [[action: skip, state: error, stop: TRUE]];
};

TransitionTable: TYPE ~ ARRAY State OF REF TransitionArray;
TransitionArray: TYPE ~ ARRAY Class OF TransitionResult;

InitTransitionTable: PROC RETURNS [table: REF TransitionTable] ~ {
table _ NEW [TransitionTable];
FOR state: State IN State DO
array: REF TransitionArray ~ NEW [TransitionArray];
FOR class: Class IN Class DO
array[class] _ Transition[state, class];
ENDLOOP;
table[state] _ array;
ENDLOOP;
};

transition: REF TransitionTable ~ InitTransitionTable[];

RClass: TYPE ~ {
digit, -- IN ['0..'9]
sign, -- '+, '-
dot, -- '.
letterE, -- 'E, 'e
other -- everything else
};

RClassArray: TYPE ~ ARRAY CHAR OF RClass;

RClassInit: PROC RETURNS [array: REF RClassArray] ~ {
array _ NEW [RClassArray];
FOR char: CHAR IN CHAR DO
array[char] _ SELECT char FROM
IN ['0..'9] => digit,
'+, '- => sign,
'. => dot,
'E, 'e => letterE,
ENDCASE => other;
ENDLOOP;
};

rclassFromChar: REF RClassArray ~ RClassInit[];

RState: TYPE ~ {
empty, -- beginning
msign, -- + | -
int, -- ( empty | msign | int ) digit   integer part
dot, -- ( empty | msign ) .
idot, -- int . 
frac, -- ( dot | idot | frac ) digit   fraction part
epref, -- ( int | idot | frac ) ( e | E )
esign, -- epref ( + | - )
exp, -- ( epref | esign | exp ) digit   exponent part
error
};

RTransition: PROC [state: RState, class: RClass] RETURNS [RState] ~ {
RETURN [SELECT state FROM
empty => SELECT class FROM digit => int, sign => msign, dot => dot,
ENDCASE => error,
msign => SELECT class FROM digit => int, dot => dot,
ENDCASE => error,
int => SELECT class FROM digit => int, dot => idot, letterE => epref,
ENDCASE => error,
dot => SELECT class FROM digit => frac,
ENDCASE => error,
idot, frac => SELECT class FROM digit => frac, letterE => epref,
ENDCASE => error,
epref => SELECT class FROM digit => exp, sign => esign,
ENDCASE => error,
esign => SELECT class FROM digit => exp,
ENDCASE => error,
exp => SELECT class FROM digit => exp,
ENDCASE => error,
ENDCASE => error];
};

RTransitionTable: TYPE ~ ARRAY RState OF REF RTransitionArray;
RTransitionArray: TYPE ~ ARRAY RClass OF RState;

RTransitionInit: PROC RETURNS [table: REF RTransitionTable] ~ {
table _ NEW [RTransitionTable];
FOR state: RState IN RState DO
array: REF RTransitionArray ~ NEW [RTransitionArray];
FOR class: RClass IN RClass DO
array[class] _ RTransition[state, class];
ENDLOOP;
table[state] _ array;
ENDLOOP;
};

rtransition: REF RTransitionTable ~ RTransitionInit[];

TokenInt: PROC [self: Root, text: Text] RETURNS [Any] ~ {
RETURN [AnyFromInt[Convert.IntFromRope[RefText.TrustTextAsRope[text]
! Convert.Error => GOTO Overflow]]];
EXITS Overflow => RETURN [TokenReal[self, text]];
};

TokenReal: PROC [self: Root, text: Text] RETURNS [Any] ~ {
state: RState _ empty;
fr: INT _ 0; -- mantissa
exp, adj: INTEGER _ 0; -- exponent and adjustment
mNeg, eNeg: BOOL _ FALSE;
mDigits, eDigits: NAT _ 0; -- significant digits
real: REAL;
FOR i: NAT IN[0..text.length) DO
char: CHAR ~ text[i];
state _ rtransition[state][rclassFromChar[char]];
SELECT state FROM
msign => mNeg _ (char='-);
int, frac => { d: [0..10) ~ char-'0;
IF state=frac THEN adj _ adj-1;
IF mDigits=0 AND d=0 THEN NULL -- leading zero
ELSE IF mDigits<9 THEN { fr _ fr*10+d; mDigits _ mDigits+1 }
ELSE { adj _ adj+1; IF mDigits=9 AND d>5 THEN fr _ fr+1; }; -- round if 10th digit >5
};
esign => eNeg _ (char='-);
exp => { d: [0..10) ~ char-'0;
IF eDigits=0 AND d=0 THEN NULL -- leading zero
ELSE IF eDigits<3 THEN { exp _ exp*10+d; eDigits _ eDigits+1 };
};
error => GOTO Fail;
ENDCASE;
ENDLOOP;
SELECT state FROM
int, idot, frac, exp => NULL; -- ok
ENDCASE => GOTO Fail;
IF mNeg THEN fr _ -fr;
IF eNeg THEN exp _ -exp;
real _ Real.PairToReal[fr: fr, exp10: exp+adj ! Real.RealException => RESUME];
RETURN [AnyFromReal[real]];
EXITS Fail => RETURN [TokenName[self, text]];
};

TokenRadix: PROC [self: Root, text: Text] RETURNS [Any] ~ {
state: {radix, val} _ radix;
radix: NAT _ 0;
val, limit: CARD _ 0;
FOR i: NAT IN [0..text.length) DO
char: CHAR ~ text[i];
d: Digit ~ digit[char];
SELECT state FROM
radix => SELECT char FROM
IN ['0..'9] => {
radix _ radix*10+d;
IF radix>36 THEN GOTO Bogus;
};
'# => {
IF radix NOT IN [2..36] THEN GOTO Bogus;
limit _ CARD.LAST/radix;
state _ val;
};
ENDCASE => GOTO Bogus;
val => {
IF NOT d<radix THEN GOTO Bogus;
IF val>limit THEN GOTO Bogus ELSE val _ val*radix;
IF d>(CARD.LAST-val) THEN GOTO Bogus ELSE val _ val+d;
};
ENDCASE => ERROR;
ENDLOOP;
RETURN [AnyFromInt[LOOPHOLE[val]]];
EXITS Bogus => RETURN [TokenName[self, text]];
};

TokenName: PROC [self: Root, text: Text] RETURNS [Any] ~ {
RETURN [AnyFromName[NameFromText[self, text]]];
};

TokenString: PROC [self: Root, text: Text] RETURNS [Any] ~ {
RETURN [AnyFromString[StringCreateFromText[self, text]]];
};

TokenProc: PROC [self: Root] RETURNS [Any] ~ {
size: INT ~ CountToMark[self];
array: Array ~ ArrayCreate[self, size];
AStore[self, array];
PopMark[self];
RETURN [CvX[AnyFromArray[array]]];
};


FileToken: PUBLIC PROC [self: Root, file: File] RETURNS [found: BOOL, token: Any] ~ {
stream: IO.STREAM ~ file.ref.stream;
text: REF TEXT _ self.buffer;
maxLength: NAT _ text.maxLength;
nest: INT _ 0; -- procedure nesting level
DO -- for each token in procedure
state: State _ empty;
slashes: [0..2] _ 0; -- number of slashes preceding name
val: CARDINAL _ 0;
length: NAT _ 0; -- text length
ExpandText: PROC ~ {
text.length _ length; text _ RefText.ReserveChars[text, 1]; maxLength _ text.maxLength;
};
Append: PROC [char: CHAR] ~ INLINE {
IF length=maxLength THEN ExpandText[];
text[length] _ char; length _ length+1;
};
DO -- for each character
char: CHAR ~ IO.GetChar[stream !
IO.EndOfStream => EXIT;
IO.Error => IF ec=StreamClosed THEN EXIT ELSE GOTO IOError;
];
result: TransitionResult ~ transition[state][classFromChar[char]];
state _ result.state;
SELECT result.action FROM
skip, stringStart, escapeStart => NULL;
putBack => IO.Backup[stream, char];
noteSlash => slashes _ slashes+1;
append, stringChar => Append[char];
escapeChar => Append[escape[char]];
escapeDigit => text[length-1] _ VAL[(ORD[text[length-1]]*8+digit[char]) MOD 256];
hexDigit1 => val _ digit[char];
hexDigit2 => Append[VAL[val*16+digit[char]]];
hexFill => Append[VAL[val*16]];
ENDCASE => ERROR Bug;
IF result.stop THEN EXIT;
ENDLOOP;
text.length _ length;
SELECT state FROM
empty, comment => { token _ null; EXIT };
int0, int1 => token _ TokenInt[self, text];
real1, real4 => token _ TokenReal[self, text];
radix1 => token _ TokenRadix[self, text];
sign, real0, real2, real3, radix0, slash, name => token _ TokenName[self, text];
string, hex => token _ TokenString[self, text];
proc0 => { token _ mark; nest _ nest+1 };
proc1 => { IF nest>0 THEN token _ TokenProc[self]; nest _ nest-1 };
ENDCASE => ERROR Error[syntaxerror];
SELECT slashes FROM
1 => token _ CvLit[token]; -- literal name
2 => token _ Load[self, token]; -- immediately evaluated name
ENDCASE;
IF nest>0 THEN PushAny[self, token] ELSE EXIT;
ENDLOOP;
IF nest#0 THEN Error[syntaxerror];
found _ Type[token]#null;
EXITS IOError => ERROR Error[ioerror];
};

StringToken: PUBLIC PROC [self: Root, string: String] 
RETURNS [found: BOOL, token: Any, post: String] ~ {
text: REF TEXT _ IF self=NIL THEN NIL ELSE self.buffer;
maxLength: NAT _ IF text=NIL THEN 0 ELSE text.maxLength;
nest: INT _ 0; -- procedure nesting level
stringLength: StringIndex ~ StringLength[string];
index: StringIndex _ 0;
DO -- for each token in procedure
state: State _ empty;
slashes: [0..2] _ 0; -- number of slashes preceding name
val: CARDINAL _ 0;
length: NAT _ 0;
start, stop: StringIndex _ 0;
ExpandText: PROC ~ {
IF text=NIL THEN text _ RefText.New[20];
text.length _ length; text _ RefText.ReserveChars[text, 1]; maxLength _ text.maxLength;
};
Append: PROC [char: CHAR] ~ INLINE {
IF length=maxLength THEN ExpandText[];
text[length] _ char; length _ length+1;
};
WHILE index<stringLength DO -- for each character
char: CHAR ~ string.ref[string.val.start+index];
result: TransitionResult ~ transition[state][classFromChar[char]];
index _ index+1;
state _ result.state;
SELECT result.action FROM
skip => NULL;
putBack => index _ index-1;
noteSlash => slashes _ slashes+1;
stringStart => start _ stop _ index;
stringChar => stop _ index;
escapeStart => { stop _ index; state _ string0 }; -- no escape convention in strings
append => Append[char];
hexDigit1 => val _ digit[char];
hexDigit2 => Append[VAL[val*16+digit[char]]];
hexFill => Append[VAL[val*16]];
ENDCASE => ERROR Bug;
IF result.stop THEN EXIT;
ENDLOOP;
text.length _ length;
SELECT state FROM
empty, comment => { token _ null; EXIT };
int0, int1 => token _ TokenInt[self, text];
real1, real4 => token _ TokenReal[self, text];
radix1 => token _ TokenRadix[self, text];
sign, real0, real2, real3, radix0, slash, name => token _ TokenName[self, text];
string => token _ CvLit[AnyFromString[StringGetInterval[string, start, stop-start]]];
hex => token _ TokenString[self, text];
proc0 => { token _ mark; nest _ nest+1 };
proc1 => { IF nest>0 THEN token _ TokenProc[self]; nest _ nest-1 };
ENDCASE => ERROR Error[syntaxerror];
SELECT slashes FROM
1 => token _ CvLit[token]; -- literal name
2 => token _ Load[self, token]; -- immediately evaluated name
ENDCASE;
IF nest>0 AND self#NIL THEN PushAny[self, token] ELSE EXIT;
ENDLOOP;
IF nest#0 THEN Error[syntaxerror];
found _ Type[token]#null;
post _ StringGetInterval[string, index, stringLength-index];
};


END.
‚PSScannerImpl.mesa
Copyright Σ 1987 by Xerox Corporation.  All rights reserved.
Doug Wyatt, August 20, 1987 4:32:43 pm PDT
Κ&˜
codeš
œ™Kš
œ<™<K™*—K˜š
Οk	˜	Kšœ
˜K˜K˜Kšœ
˜Kš
œ˜K˜—K˜KšΟn
œœ
˜Kšœ
œœ˜&Kšœ
˜
Kšœœ
œ
œ
˜K˜šœœ˜Iunitšœ	Οc	˜KšœŸ
˜LšœŸ˜KšœŸ˜Kšœ
Ÿ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜Kšœ	Ÿ˜LšœŸ˜
KšœŸ˜KšœŸ	˜KšœŸ˜KšœŸ'˜3Kšœ	Ÿ	˜KšœŸ1˜<Kšœ
Ÿ<˜IKšœŸ˜KšœŸ˜L˜K˜—Kšœœ˜)Kšœ	œ˜*Kšœ	œ˜"Kšœœ"Ÿ˜?Kšœ
œ!Ÿ˜Nšœœ#Ÿ˜RK˜—šœœœ
œ
œ
œ˜.K˜—šžœœ
œ	œ˜8Kšœœ˜š	œœ
œ
œ
˜šœœ˜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˜—šœœ˜1K˜—K˜šœœ˜K˜—šœœœ
œ
œ
œ˜.K˜—šžœœ
œ	œ˜8Kšœœ˜š	œœ
œ
œ
˜šœœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜
—Kšœ
˜—K˜K˜—šœœ˜)K˜—K˜š
œ
œœ
œ
œ
œ
œ
˜.K˜—šžœœ
œ	œ˜:Kšœœ˜š	œœ
œ
œ
˜šœœ˜Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœ
œ˜ Kšœ	˜—Kšœ
˜—K˜K˜—šœœ!˜,K˜—K˜šœœ˜LšœŸ˜ Lšœ	Πbf
œ 
˜Kšœ	Πbiœ‘œŸ˜<Kšœ‘œ‘œŸ˜>Kšœ
 
œ 
˜Kšœ 
œ	‘œ	‘œŸ˜YKšœ$Οb
œ’
œ˜+Kšœ 
œ 
œ˜Kšœ‘œ	‘œŸ˜NKšœ 
˜Kšœ‘œ
‘œŸ˜?Kšœ
 
˜Kš
œ	‘œ	‘œ œ‘œŸ˜ILšœ 
œ˜Kšœ 
œ 
˜Kšœ 
œ 
‘
˜Kšœ 
œ 
‘˜Kšœ	 
œŸ˜&Kšœ	 
œŸ˜%Kšœ 
œ˜Lšœ 
œ 
˜Kšœ 
œ 
˜Kšœ
 
˜Kšœ
 
˜Kšœ	Ÿ˜L˜K˜—šœœ˜KšœŸ˜KšœŸ˜'KšœŸ˜%KšœŸB˜MKšœ
Ÿ<˜IKšœŸ!˜-Kšœ
Ÿ2˜?KšœŸ%˜1Kšœ
Ÿ1˜>KšœŸ˜%KšœŸ(˜3KšœŸ4˜<K˜K˜—š	œœœ&œœ˜SK˜—šž
œœœ˜Lšœ˜š
œ
˜
Kšœœœ
œ ˜Bš	œœ	œ
œ˜*Kšœ
œ%œ˜?Kšœœ%œ˜@Kšœœ&œ˜PKšœ
œ)˜<Kšœ
œ˜2Kšœ	œ%˜4Kšœœ"˜3Kšœœ'œ˜?—K˜—šœœ
œ
œ
œ
œ˜AKš
œœœ
œ%œ˜NKš
œœ	œ
œ(œ˜NK˜—šœ˜Kšœœœ
œ ˜BK˜—Kšœ
˜—šœ˜šœ	œ˜Kšœœ!˜/Kšœœ"˜/Kšœœ!˜:Kšœœ!˜2—šœœ˜Kšœœ"˜/Kšœœ!˜:Kšœœ!˜2—šœœ˜Kšœœ"˜/Kšœœ"˜3Kšœœ#˜1Kšœœ!˜:Kšœœ!˜2—šœœ˜Kšœœ"˜/Kšœœ"˜3Kšœœ!˜:Kšœœ!˜2—šœ	œ˜Kšœœ"˜;Kšœœ!˜2—šœ	œ˜Kšœœ"˜3Kšœœ"˜;Kšœœ!˜2—šœ	œ˜Kšœœ"˜0Kšœœ"˜;Kšœœ!˜2—šœ	œ˜Kšœœ"˜;Kšœœ!˜2—šœ	œ˜Kšœœ"˜;Kšœœ!˜2—šœ
œ˜Kšœœ#˜:Kšœœ!˜2—šœ
œ˜Kšœœ#˜:Kšœœ!˜2—šœ	œ˜Kšœ	œ$˜3Kšœœ!˜2—Kšœœ!˜/šœœ˜Kšœœ&œ˜AKšœ
œ)˜<Kšœœ(˜9—šœœ˜Kšœœ"˜3Kšœœ(˜<Kšœœ(˜9—šœœ˜Kšœœ&œ˜AKšœœ)˜=Kšœœ(˜9—šœœ˜Kšœœ)˜=Kšœœ(˜9—šœœ˜Kšœœ#œ˜>Kšœ
œ$˜9Kšœœ%œ˜=—šœœ˜Kšœœ&œ˜AKšœ
œ$˜9Kšœœ%œ˜=—šœœ˜Kšœœ ˜1Kšœœ"˜3—Kšœœ%œ˜=—K˜K˜—Kš	œœœœ
œ˜;šœœœœ˜8K˜—šžœœ
œ	œ˜BKšœœ˜šœœ˜Kšœœœ˜3šœœ˜K˜(Kšœ
˜—K˜Kšœ
˜—K˜K˜—šœœ)˜8K˜—šœœ˜KšœŸΠckŸ	˜Kšœ	Ÿ˜KšœŸ˜
Kšœ	Ÿ	˜KšœŸ˜K˜K˜—š	œ
œœ
œ
œ˜)K˜—šž
œœ
œ	œ˜5Kšœœ˜š	œœ
œ
œ
˜šœœ˜Kšœ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kšœ
˜—Kšœ
˜—K˜K˜—šœœ˜/K˜—šœœ˜KšœŸ˜Kšœ
 
œ 
˜Kšœ ‘œŸ˜4Kšœ 
˜Kšœ
 
œ
˜Kšœ‘œŸ
˜4Kšœ"’
œ’
œ˜)Kšœ 
œ 
œ˜Kšœ ‘œŸ
˜5K˜K˜K˜—šžœœ œ
˜Ešœœ˜šœ	œœ)˜CKšœ
˜—šœ	œœ˜4Kšœ
˜—šœœœ-˜EKšœ
˜—šœœœ˜'Kšœ
˜—šœœœ!˜@Kšœ
˜—šœ	œœ˜7Kšœ
˜—šœ	œœ˜(Kšœ
˜—šœœœ˜&Kšœ
˜—Kšœ˜—K˜K˜—Kš	œœœœ
œ˜>šœœœœ˜0K˜—šžœœ
œ	œ˜?Kšœœ˜šœœ˜Kšœœœ˜5šœœ˜K˜)Kšœ
˜—K˜Kšœ
˜—K˜K˜—šœ
œ&˜6K˜—šžœœœ
˜9šœ>˜DKšœœ
˜$—Kšœ
œ˜1K˜K˜—šž	œœœ
˜:Kš
œ˜KšœœŸ˜Kšœ
œŸ˜1Kšœœœ
˜KšœœŸ˜0Kšœœ
˜šœœ
œ˜ Kšœœ˜Kš
œ1˜1šœ˜Kš
œ˜š
œ$˜$Kšœœ
˜Kš	œœœ
œ
Ÿ˜.Kšœ
œœ&˜<Kš	œœœœŸ˜UK˜—Kš
œ˜š
œ˜Kš	œœœ
œ
Ÿ˜.Kšœ
œœ)˜?K˜—Kšœ	œ˜Kšœ
˜—Kšœ
˜—šœ˜KšœœŸ˜#Kšœœ˜—Kšœœ
˜Kšœœ˜KšœFœ˜NKšœ˜Kšœ	œ˜-K˜K˜—šž
œœœ
˜;J˜Jšœœ˜Jšœœ˜šœœ
œ˜!Jšœœ˜Jš
œ˜šœ˜šœ	œ˜šœ˜J˜Jšœ
œ
œ˜J˜—˜Jš
œœ
œ	œ
œ˜(Jšœœ
œ˜J˜J˜—Jšœœ˜—˜Jšœ
œ	œ
œ˜Jšœœ
œœ˜2Jšœœ
œœ
œœ
˜6J˜—Jšœœ
˜—Jšœ
˜—Kšœ
œ˜#Kšœ
œ˜.K˜K˜—šž	œœœ
˜:Jšœ)˜/K˜K˜—šžœœœ
˜<Jšœ3˜9K˜K˜—šž	œœœ
˜.Kšœœ˜Kš
œ'˜'Jš
œ˜K˜Kšœ˜"K˜K˜—K˜š
ž	œœ
œœ	œ˜UKšœœ
œ˜$Kšœœ
œ˜Kšœœ˜ KšœœŸ˜)šœ
Ÿ˜!Kš
œ˜KšœŸ#˜8Kšœœ˜KšœœŸ˜šž
œœ˜Kš
œW˜WK˜—šžœœœœ˜$Kšœœ˜&Kš
œ'˜'Kš
œ˜—šœ
Ÿ˜šœœœ˜ Kšœœ
˜Kšœ
œœ
œ
œ
œ	˜;Kš
œ˜—Kš
œB˜BK˜šœ˜Kšœ"œ
˜'Kšœœ˜#Kš
œ!˜!Kš
œ#˜#K˜#Kšœ œœ œ˜QKš
œ˜Kšœœ˜-Kšœœ
˜Kšœœ˜—Kšœ
œ
œ
˜Kšœ
˜—K˜šœ˜Kšœ"œ˜)Kš
œ+˜+Kš
œ.˜.Kš
œ)˜)Kš
œP˜PKš
œ/˜/Kš
œ)˜)Kšœœœ*˜CKšœœ˜$—šœ	˜KšœŸ˜*Kšœ Ÿ˜=Kšœ
˜—Kšœœœ
œ
˜.Kšœ
˜—Kšœœ˜"K˜Kšœœ˜&K˜K˜—š
žœœ
œœ	œ˜jKšœœ
œœœ
œ
œ
œ
˜7Kšœœœœ
œœ˜8KšœœŸ˜)K˜1K˜šœ
Ÿ˜!Kš
œ˜KšœŸ#˜8Kšœœ˜Kšœœ˜K˜šž
œœ˜Kšœœ
œ˜(Kš
œW˜WK˜—šžœœœœ˜$Kšœœ˜&Kš
œ'˜'Kš
œ˜—šœœ
Ÿ˜1Kšœœ&˜0Kš
œB˜BK˜K˜šœ˜Kšœœ
˜
Kš
œ˜Kš
œ!˜!Kš
œ$˜$Kš
œ˜Kšœ2Ÿ"˜TKš
œ˜Kš
œ˜Kšœœ˜-Kšœœ
˜Kšœœ˜—Kšœ
œ
œ
˜Kšœ
˜—K˜šœ˜Kšœ"œ˜)Kš
œ+˜+Kš
œ.˜.Kš
œ)˜)Kš
œP˜PKš
œU˜UKš
œ'˜'Kš
œ)˜)Kšœœœ*˜CKšœœ˜$—šœ	˜KšœŸ˜*Kšœ Ÿ˜=Kšœ
˜—Kšœœœ
œœ
œ
˜;Kšœ
˜—Kšœœ˜"K˜K˜<K˜K˜—K˜Kšœ
˜—…—F€_L