DIRECTORY
Ascii USING [CR, LF, SP, TAB],
BasicTime USING [GMT],
Commander USING [CommandProc, Handle, Register],
CommandTool USING [DoCommand],
FS USING [Delete, EnumerateForNames, Error, GetInfo, GetName, OpenFile, OpenFileFromStream, StreamOpen],
IO USING [Close, EndOf, EndOfStream, GetBlock, GetIndex, GetTokenRope, PutBlock, PutChar, PutRope, RIS, SetIndex, STREAM],
Rope USING [Concat, Equal, Fetch, Find, FromProc, Length, ROPE, Substr];


ExpungeOpensImpl: CEDAR PROGRAM
IMPORTS IO, FS, Rope, Commander, CommandTool
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;

Scanner: TYPE ~ REF ScannerRep;
ScannerRep: TYPE ~ RECORD [
stream: IO.STREAM,
tokenKind: Kind,
inputBuffer: REF TEXT,
locationOfBufferStart: INT,
tokenStart: NAT,
tokenLength: NAT
];

inputBufferSize: NAT _ 16*1024;
CreateScanner: PROC [stream: IO.STREAM] RETURNS [scanner: Scanner] ~ {
scanner _ NEW[ScannerRep _ [
stream: stream,
tokenKind: whitespace,
inputBuffer: NEW[TEXT[inputBufferSize]],
locationOfBufferStart: IO.GetIndex[stream],
tokenStart: 0,
tokenLength: 0
]];
};

Kind: TYPE ~ {identifier, special, charconst, string, whitespace, newline, comment, eof};
KindOf: PROC [c: CHAR] RETURNS [Kind] ~ {
SELECT c FROM
IN ['a..'z], IN ['A..'Z], IN ['0..'9], '$ => RETURN [identifier];
Ascii.SP, Ascii.TAB, Ascii.LF => RETURN [whitespace];
Ascii.CR => RETURN [newline];
ENDCASE => RETURN [special];
};

breakLoc: INT _ LAST[INT];
breakCount: INT _ 0;

GetCharConstant: PROC [scanner: Scanner] ~ {
IF scanner.tokenStart>=scanner.inputBuffer.length-10 THEN RefillBuffer[scanner];
scanner.tokenKind _ charconst;
scanner.tokenLength _ 2;
IF scanner.inputBuffer[scanner.tokenStart+1] = '\\ THEN {
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] THEN {
WHILE scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] DO
scanner.tokenLength _ scanner.tokenLength + 1;
ENDLOOP;
}
ELSE scanner.tokenLength _ 3;
};
};

GetStringConstant: PROC [scanner: Scanner] ~ {
GetC: PROC ~ {
IF scanner.tokenStart+scanner.tokenLength>=scanner.inputBuffer.length-10 THEN RefillBuffer[scanner];
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] = '\\ THEN {
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] THEN {
WHILE scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] DO
scanner.tokenLength _ scanner.tokenLength + 1;
ENDLOOP;
}
ELSE scanner.tokenLength _ scanner.tokenLength + 1;
};
};
scanner.tokenLength _ 0;
GetC[];
UNTIL scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] = '" DO
GetC[];
ENDLOOP;
scanner.tokenLength _ scanner.tokenLength + 1;
};

GetComment: PROC [scanner: Scanner] ~ {
c: CHAR _ ' ; -- next char after the current end-of-token
cc: CHAR _ ' ; -- char after c
PeekCC: PROC ~ {
IF scanner.tokenStart+scanner.tokenLength+2>=scanner.inputBuffer.length THEN RefillBuffer[scanner];
c _ cc _ '\n;
IF scanner.tokenStart+scanner.tokenLength<scanner.inputBuffer.length THEN
c _ scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength];
IF scanner.tokenStart+scanner.tokenLength+1<scanner.inputBuffer.length THEN
cc _ scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength+1];
};
scanner.tokenLength _ 2;
PeekCC[];
UNTIL c = '\n OR (c = '- AND cc = '-) DO
scanner.tokenLength _ scanner.tokenLength + 1;
PeekCC[];
ENDLOOP;
IF (c = '- AND cc = '-) THEN scanner.tokenLength _ scanner.tokenLength + 2;
scanner.tokenKind _ comment;
};

GetToken: PROC [scanner: Scanner] ~ {
c: CHAR;
scanner.tokenStart _ scanner.tokenStart+scanner.tokenLength;
scanner.tokenLength _ 0;
IF scanner.tokenStart>=scanner.inputBuffer.length-1 THEN RefillBuffer[scanner];
IF scanner.inputBuffer.length = 0 THEN {scanner.tokenKind _ eof; RETURN};
c _ scanner.inputBuffer[scanner.tokenStart];
IF c = '' THEN {GetCharConstant[scanner]; RETURN};
IF c = '" THEN {GetStringConstant[scanner]; RETURN};
IF c = '- AND scanner.inputBuffer[scanner.tokenStart+1] = '- THEN {GetComment[scanner]; RETURN};
scanner.tokenKind _ KindOf[scanner.inputBuffer[scanner.tokenStart]];
IF scanner.tokenKind = special THEN {
scanner.tokenLength _ 1;
RETURN;
};
WHILE scanner.tokenStart+scanner.tokenLength<scanner.inputBuffer.length
AND KindOf[scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength]] = scanner.tokenKind DO
IF scanner.locationOfBufferStart+scanner.tokenStart+scanner.tokenLength = breakLoc THEN breakCount _ breakCount + 1;
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.tokenStart + scanner.tokenLength = scanner.inputBuffer.length THEN {
IF IO.EndOf[scanner.stream] THEN RETURN;
RefillBuffer[scanner];
};
ENDLOOP;
};

RefillBuffer: PROC [scanner: Scanner] = {
residual: NAT ~ scanner.inputBuffer.length-scanner.tokenStart;
FOR i: NAT IN [0..residual) DO
scanner.inputBuffer[i] _ scanner.inputBuffer[i+scanner.tokenStart];
ENDLOOP;
scanner.inputBuffer.length _ residual;
scanner.locationOfBufferStart _ scanner.locationOfBufferStart+scanner.tokenStart;
scanner.tokenStart _ 0;
[] _ scanner.stream.GetBlock[block: scanner.inputBuffer, startIndex: residual, count: scanner.inputBuffer.maxLength-residual];
};

Match: PROC [scanner: Scanner, key: REF READONLY TEXT] RETURNS [equal: BOOLEAN] = {
i: NAT _ scanner.tokenStart;
IF key.length # scanner.tokenLength THEN RETURN [FALSE];
FOR j: NAT IN [0..key.length) DO
IF key[j]#scanner.inputBuffer[i] THEN RETURN [FALSE];
i_i+1;
ENDLOOP;
RETURN [TRUE]
};

MatchRope: PROC [scanner: Scanner, key: ROPE] RETURNS [equal: BOOLEAN] = {
i: NAT _ scanner.tokenStart;
IF key.Length # scanner.tokenLength THEN RETURN [FALSE];
FOR j: NAT IN [0..scanner.tokenLength) DO
IF key.Fetch[j]#scanner.inputBuffer[i] THEN RETURN [FALSE];
i_i+1;
ENDLOOP;
RETURN [TRUE]
};

IDRope: PROC [scanner: Scanner] RETURNS [rope: ROPE] = {
i: INTEGER _ scanner.tokenStart-1;
p: PROC RETURNS [CHAR] ~ {RETURN [scanner.inputBuffer[i_i+1]]};
IF scanner.tokenKind # identifier THEN RaiseError[scanner];
RETURN [Rope.FromProc[scanner.tokenLength, p]];
};

Pair: TYPE ~ RECORD [
member: ROPE,
owner: ROPE
];

ParseError: ERROR [sourceLoc: INT] = CODE;

RaiseError: PROC [scanner: Scanner] = {
ParseError[scanner.locationOfBufferStart+scanner.tokenStart];
};

GetUsingLists: PROC [stem: ROPE] RETURNS [list: LIST OF Pair] ~ {
stream: IO.STREAM _ FS.StreamOpen[Rope.Concat[stem, ".usingList"]];
scanner: Scanner _ CreateScanner[stream];
GetTok: PROC ~ {
GetToken[scanner];
WHILE scanner.tokenKind = comment OR scanner.tokenKind = whitespace OR scanner.tokenKind = newline DO
GetToken[scanner];
ENDLOOP;
};
GetTok[];
UNTIL scanner.tokenKind = eof OR Match[scanner, "DIRECTORY"] DO
GetToken[scanner];
ENDLOOP;
IF scanner.tokenKind = eof THEN RaiseError[scanner];
GetTok[];
UNTIL Match[scanner, ";"] DO
module: ROPE ~ IDRope[scanner];
GetTok[];
IF NOT Match[scanner, "USING"] THEN RaiseError[scanner];
GetTok[];
IF NOT Match[scanner, "["] THEN RaiseError[scanner];
GetTok[];
UNTIL Match[scanner, "]"] DO
element: ROPE ~ IDRope[scanner];
list _ CONS[[element, module], list];
GetTok[];
IF Match[scanner, ","] THEN GetTok[]
ELSE IF NOT Match[scanner, "]"] THEN RaiseError[scanner];
ENDLOOP;
GetTok[];
IF Match[scanner, ","] THEN GetTok[]
ELSE IF NOT Match[scanner, ";"] THEN RaiseError[scanner];
ENDLOOP;
stream.Close;
};

maxNest: INT ~ 200;

useCurlys: BOOLEAN _ TRUE;
adjustLineBreaks: BOOLEAN _ TRUE;
adjustIndentation: BOOLEAN _ TRUE;
ExpungeOpensIn: PROC [fileName: ROPE, stem: ROPE, cmd: Commander.Handle] ~ {
idTable: LIST OF Pair _ GetUsingLists[stem];
stream: IO.STREAM _ FS.StreamOpen[fileName];
output: IO.STREAM _ FS.StreamOpen[fileName, $create];
BEGIN
ENABLE UNWIND => {
openFile: FS.OpenFile ~ FS.OpenFileFromStream[output];
fullFName: ROPE ~ FS.GetName[openFile].fullFName;
wantedCreatedTime: BasicTime.GMT _ FS.GetInfo[openFile].created;
output.Close[abort: TRUE];
FS.Delete[fullFName, wantedCreatedTime ! FS.Error => CONTINUE];
};
scanner: Scanner ~ CreateScanner[stream];
opens: ARRAY [0..maxNest) OF LIST OF ROPE _ ALL[NIL];
startLine: ARRAY [0..maxNest) OF INT _ ALL[0];
nest: INT _ 0;
afterDot: BOOLEAN _ TRUE;
CopyToken: PROC ~ {
output.PutBlock[scanner.inputBuffer, scanner.tokenStart, scanner.tokenLength];
IF scanner.tokenKind # whitespace THEN somethingSinceNewLine _ TRUE;
};
Nest: PROC ~ {
nest _ nest + 1;
startLine[nest] _ lineNumber;
};
UnNest: PROC ~ {
opens[nest] _ NIL;
nest _ nest - 1;
};
GetTok: PROC ~ {
GetToken[scanner];
WHILE scanner.tokenKind = comment OR scanner.tokenKind = whitespace OR scanner.tokenKind = newline DO
CopyToken[];
GetToken[scanner];
ENDLOOP;
};
IsModuleName: PROC [id: ROPE] RETURNS [BOOLEAN] ~ {
IF id.Concat["Impl"].Equal[stem, FALSE] THEN RETURN [FALSE];
FOR p: LIST OF Pair _ idTable, p.rest UNTIL p = NIL DO
IF p.first.owner.Equal[id] THEN RETURN [TRUE]
ENDLOOP;
RETURN [FALSE];
};
IsOpen: PROC [id: ROPE] RETURNS [BOOLEAN] ~ {
FOR i: INT DECREASING IN [0..nest] DO
FOR p: LIST OF ROPE _ opens[i], p.rest UNTIL p = NIL DO
IF id.Equal[p.first] THEN RETURN [TRUE];
ENDLOOP;
ENDLOOP;
RETURN [FALSE];
};
ParseOpen: PROC ~ {
didOpen: BOOLEAN _ FALSE;
afterDot _ FALSE;
GetTok[];
UNTIL Match[scanner, ";"] DO
id: ROPE _ IDRope[scanner];
GetTok[];
IF Match[scanner, ":"] THEN {
IF didOpen THEN output.PutRope[", "] ELSE output.PutRope["OPEN "];
didOpen _ TRUE;
somethingSinceNewLine _ TRUE;
output.PutRope[id];
CopyToken[]; -- the colon
GetTok[];
CopyToken[]; -- the name
GetTok[];
}
ELSE IF (Match[scanner, ","] OR Match[scanner, ";"]) AND IsModuleName[id] THEN {
opens[nest] _ CONS[id, opens[nest]];
}
ELSE {
understood: BOOL _ (Match[scanner, ","] OR Match[scanner, ";"]);
IF didOpen THEN output.PutRope[", "] ELSE output.PutRope["OPEN "];
didOpen _ TRUE;
somethingSinceNewLine _ TRUE;
output.PutRope[id];
IF NOT understood THEN {CopyToken[]; RETURN};
};
IF Match[scanner, ","] THEN {
GetTok[];
}
ELSE IF NOT Match[scanner, ";"] THEN RaiseError[scanner];
ENDLOOP;
IF didOpen THEN {output.PutChar[';]; somethingSinceNewLine _ TRUE};
};
TryToInsertQualifier: PROC ~ {
FOR p: LIST OF Pair _ idTable, p.rest UNTIL p = NIL DO
IF MatchRope[scanner, p.first.member] AND IsOpen[p.first.owner] THEN {
somethingSinceNewLine _ TRUE;
output.PutRope[p.first.owner];
output.PutChar['.];
RETURN;
};
ENDLOOP;
};
EmitCurlyBegin: PROC ~ {
IF adjustLineBreaks AND NOT somethingSinceNewLine AND tokenKindBeforeNewLine = special THEN {
output.SetIndex[lastNewLineOutputIndex];
output.PutChar[' ];
};
output.PutChar['{];
somethingSinceNewLine _ TRUE;
afterDot _ FALSE;
Nest[];
};
EmitCurlyEnd: PROC ~ {
IF adjustLineBreaks AND adjustIndentation AND somethingSinceNewLine AND lineNumber # startLine[nest] THEN EmitNewLine[];
output.PutChar['}];
afterDot _ FALSE;
somethingSinceNewLine _ TRUE;
UnNest[];
};
EmitNewLine: PROC ~ {
tokenKindBeforeNewLine _ prevNonWhiteTokenKind;
lastNewLineOutputIndex _ output.GetIndex;
output.PutChar['\n];
IF adjustIndentation THEN {
FOR i: INT IN [0..nest) DO
output.PutChar['\t];
ENDLOOP;
IF specialNest THEN output.PutChar['\t];
};
somethingSinceNewLine _ FALSE;
};
lastNewLineOutputIndex: INT _ 0;
tokenKindBeforeNewLine: Kind _ whitespace;
prevNonWhiteTokenKind: Kind _ whitespace;
somethingSinceNewLine: BOOLEAN _ FALSE;
lineNumber: INT _ 0;
specialNest: BOOLEAN _ FALSE;
DO
IF scanner.tokenKind # whitespace THEN
prevNonWhiteTokenKind _ scanner.tokenKind;
GetToken[scanner];
SELECT scanner.tokenKind FROM
identifier => {
SELECT TRUE FROM
Match[scanner, "DIRECTORY"], Match[scanner, "PROGRAM"], Match[scanner, "MONITOR"] => specialNest _ TRUE;
Match[scanner, "BEGIN"] =>
{IF useCurlys THEN {EmitCurlyBegin[]; LOOP} ELSE Nest[]};
Match[scanner, "DO"], Match[scanner, "FROM"] => Nest[];
Match[scanner, "END"] =>
{IF useCurlys THEN {EmitCurlyEnd[]; LOOP} ELSE UnNest[]};
Match[scanner, "ENDLOOP"], Match[scanner, "ENDCASE"] => UnNest[];
Match[scanner, "OPEN"] => {ParseOpen[]; LOOP};
ENDCASE => {
IF afterDot THEN NULL
ELSE TryToInsertQualifier[];
};
afterDot _ FALSE;
CopyToken[];
};
special => {
char: CHAR _ scanner.inputBuffer[scanner.tokenStart];
IF char = '_ OR char = '\251 THEN specialNest _ TRUE;
IF char = '; OR char = '~ OR char = '= OR char = '} THEN specialNest _ FALSE;
IF char = '{ OR char = '( OR char = '[ THEN Nest[]
ELSE IF char = '} THEN {EmitCurlyEnd[]; LOOP}
ELSE IF  char = ') OR char = '] THEN UnNest[];
afterDot _ (char = '.);
CopyToken[];
};
charconst, string => {afterDot _ FALSE; CopyToken[]};
whitespace =>
{IF adjustIndentation AND NOT somethingSinceNewLine THEN NULL ELSE CopyToken[]};
comment => CopyToken[];
newline => {lineNumber _ lineNumber + 1; EmitNewLine[]};
eof => EXIT;
ENDCASE => ERROR; 
ENDLOOP;
END;
stream.Close;
output.Close;
};

GetCmdToken: PROC [stream: IO.STREAM] RETURNS [rope: ROPE _ NIL] ~ {
rope _ IO.GetTokenRope[stream ! IO.EndOfStream => CONTINUE].token;
};

ExpungeOpensCommand: Commander.CommandProc ~ {
c: IO.STREAM _ IO.RIS[cmd.commandLine];
FOR stem: ROPE _ GetCmdToken[c], GetCmdToken[c] UNTIL stem.Length = 0 DO
pattern: ROPE _ Rope.Concat[stem, ".mesa"];
ForEachFile: PROC [fullFName: ROPE] RETURNS [continue: BOOLEAN _ TRUE] ~ {
base: ROPE _ fullFName.Substr[0, fullFName.Find[".mesa"]];
result _ CommandTool.DoCommand[Rope.Concat["SetKeep 6 ", fullFName], cmd];
IF result = $Failure THEN RETURN [FALSE];
result _ CommandTool.DoCommand[Rope.Concat["WriteMesaPlain ", fullFName], cmd];
IF result = $Failure THEN RETURN [FALSE];
result _ CommandTool.DoCommand[Rope.Concat["UsingList ", base], cmd];
IF result = $Failure THEN RETURN [FALSE];
ExpungeOpensIn[fullFName, base, cmd];
result _ CommandTool.DoCommand[Rope.Concat["TiogaMesa ", fullFName], cmd];
IF result = $Failure THEN RETURN [FALSE];
};
IF Rope.Find[pattern, "*"] >= 0 THEN FS.EnumerateForNames[pattern, ForEachFile ! FS.Error => {cmd.out.PutRope[error.explanation]; cmd.out.PutChar['\n]; result _ $Failure; CONTINUE}]
ELSE [] _ ForEachFile[pattern ! FS.Error => {cmd.out.PutRope[error.explanation]; cmd.out.PutChar['\n]; result _ $Failure; CONTINUE}];
IF result = $Failure THEN RETURN;
ENDLOOP;
};

Commander.Register["ExpungeOpens", ExpungeOpensCommand, "Attempt to remove OPENs from a Cedar program"];

END.

XExpungeOpensImpl.mesa
Copyright (C) 1984, Xerox Corporation.  All rights reserved.
Michael Plass, March 14, 1985 9:46:35 am PST
Gets the next token into inputBuffer[tokenStart] .. inputBuffer[tokenLength-1]
Leave opens for the normally-named exported interface alone.
a named open - leave it alone.
Something unusual, like an expression
�Ês˜Jš
œ™Jš
œ<™<Jš
œ,™,J˜š
Ïk	˜	Jšœ�œ�œ�œ�œ�œ˜Jšœ
�œ�œ˜Jšœ
�œ!˜0Jšœ�œ
˜Jš�œ
�œ`˜hJš�œ
�œ[�œ�œ˜zJšœ�œ0�œ
˜HJ˜—J˜šœ�œ
�˜Jš�œ
�œ�œ˜,Jšœ�˜J˜Jš�œ�œ�œ
˜J˜Jšœ	�œ�œ˜šœ�œ�œ˜Jšœ�œ
�œ
˜Jš
œ˜Jšœ
�œ
�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ
�˜Jš
œ˜J˜—Jšœ�œ˜š
Ïn
œ�œ
�œ
�œ�œ˜Fšœ
�œ˜Jš
œ˜Jš
œ˜Jšœ
�œ
�œ˜(Jšœ�œ˜+Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜J˜—Jšœ�œO˜Yšžœ�œ�œ�œ˜)š�œ�˜
Jš�œ�œ�œ�œ˜AJš	œ�œ�œ�œ�œ˜5Jšœ�œ�œ˜Jš�œ�œ˜—Jš
œ˜J˜—Jšœ
�œ�œ
�œ˜šœ�œ˜J˜—šžœ�œ˜,Jš�œ3�œ˜PJš
œ˜Jš
œ˜š�œ1�œ˜9š�œ=�œ
�œ˜Qš�œ=�œ
�˜PJš
œ.˜.Jš�œ
˜—Jš
œ
˜
—Jš�œ˜Jš
œ˜—Jš
œ˜J˜—šžœ�œ˜.šžœ�œ˜Jš�œG�œ˜dJš
œ.˜.š�œC�œ˜KJš
œ.˜.š�œ=�œ
�œ˜Qš�œ=�œ
�˜PJš
œ.˜.Jš�œ
˜—Jš
œ
˜
—Jš�œ/˜3Jš
œ˜—Jš
œ˜—Jš
œ˜Jš
œ˜š�œB�˜IJš
œ˜Jš�œ
˜—Jš
œ.˜.Jš
œ˜J˜—šž
œ�œ˜'Jšœ�œÏc+˜9Jšœ�œŸœ
˜šžœ�œ˜Jš�œF�œ˜cJ˜
š�œC�˜IJš
œ@˜@—š�œE�˜KJš
œC˜C—Jš
œ˜—Jš
œ˜Jš
œ	˜	š�œ	�œ	�œ
�˜(Jš
œ.˜.Jš
œ	˜	Jš�œ
˜—Jš�œ	�œ
�œ/˜KJš
œ˜Jš
œ˜J˜—šžœ�œ˜%Jš
œN™NJšœ�œ
˜Jš
œ<˜<Jš
œ˜Jš�œ2�œ˜OJš�œ �œ�œ˜IJš
œ,˜,Jš�œ�œ�œ˜2Jš�œ�œ�œ˜4Jš�œ�œ0�œ�œ˜`Jš
œD˜Dš�œ�œ˜%Jš
œ˜Jš�œ
˜Jš
œ˜—Jš�œB˜Gš�œY�˜^Jš�œQ�œ˜tJš
œ.˜.š�œG�œ˜OJš�œ
�œ�œ
�œ
˜(Jš
œ˜Jš
œ˜—Jš�œ
˜—Jš
œ˜J˜—šžœ�œ˜)Jšœ
�œ1˜>š�œ�œ
�œ�˜Jš
œC˜CJš�œ
˜—Jš
œ&˜&Jš
œQ˜QJš
œ˜Jš
œ~˜~J˜J˜—šžœ�œ�œ
�œ
�œ�œ	�œ˜SJšœ�œ˜Jš�œ"�œ
�œ�œ˜8š�œ�œ
�œ�˜ Jš�œ�œ
�œ�œ˜5J˜Jš�œ
˜—Jš�œ�œ
˜
J˜J˜—š
ž	œ�œ�œ�œ	�œ˜JJšœ�œ˜Jš�œ"�œ
�œ�œ˜8š�œ�œ
�œ�˜)Jš�œ%�œ
�œ�œ˜;J˜Jš�œ
˜—Jš�œ�œ
˜
J˜J˜—šžœ�œ�œ�œ˜8Jšœ�œ˜"Jš	œ�œ
�œ�œ�œ˜?Jš�œ �œ˜;Jš�œ)˜/J˜J˜—šœ�œ�œ˜Jšœ�œ
˜
Jšœ�˜Jš
œ˜J˜—šœ�œ
�œ�œ
˜*J˜—šœ�œ˜'Jš
œ=˜=J˜J˜—šž
œ�œ�œ�œ�œ
�œ
˜AJšœ�œ
�œ�œ-˜CJš
œ)˜)šžœ�œ˜Jš
œ˜š�œ�œ �œ�˜eJš
œ˜Jš�œ
˜—Jš
œ˜—Jš
œ	˜	š�œ�œ�˜?Jš
œ˜Jš�œ
˜—Jš�œ�œ˜4Jš
œ	˜	š�œ�˜Jšœ�œ˜Jš
œ	˜	Jš�œ
�œ�œ˜8Jš
œ	˜	Jš�œ
�œ�œ˜4Jš
œ	˜	š�œ�˜Jšœ	�œ˜ Jšœ�œ˜%Jš
œ	˜	Jš�œ�œ	˜$Jš�œ
�œ
�œ�œ˜9Jš�œ
˜—Jš
œ	˜	Jš�œ�œ	˜$Jš�œ
�œ
�œ�œ˜9Jš�œ
˜—Jš
œ
˜
Jš
œ˜J˜—šœ	�œ˜J˜—Jšœ�œ�œ
˜Jšœ�œ�œ
˜!Jšœ�œ�œ
˜"šžœ�œ�œ�œ˜LJšœ	�œ
�œ˜,Jšœ�œ
�œ�œ˜,Jšœ�œ
�œ�œ˜5š
�˜š�œ
�œ˜Jšœ
�œ�œ˜6Jšœ�œ�œ˜1Jšœ�œ�œ˜@Jšœ�œ˜Jš�œ'�œ
�œ˜?Jš
œ˜—Jš
œ)˜)Jšœ�œ�œ
�œ
�œ
�œ�œ
�œ˜5Jš	œ�œ�œ
�œ�œ˜.Jšœ�œ˜Jšœ
�œ�œ
˜šž	œ�œ˜Jš
œN˜NJš�œ �œ�œ
˜DJš
œ˜—šžœ�œ˜Jš
œ˜Jš
œ˜Jš
œ˜—šžœ�œ˜Jšœ�œ
˜Jš
œ˜Jš
œ˜—šžœ�œ˜Jš
œ˜š�œ�œ �œ�˜eJš
œ˜Jš
œ˜Jš�œ
˜—Jš
œ˜—š
žœ�œ�œ�œ�œ˜3š
�œ�œ�œ
�œ�œ˜<J™<—š�œ�œ
�œ�œ�œ
�˜6Jš�œ�œ
�œ�œ
˜-Jš�œ
˜—Jš�œ�œ˜Jš
œ˜—š
žœ�œ�œ�œ�œ˜-š	�œ�œ
�
œ
�œ�˜%š
�œ�œ
�œ
�œ�œ�œ
�˜7Jš�œ�œ
�œ�œ˜(Jš�œ
˜—Jš�œ
˜—Jš�œ�œ˜Jš
œ˜—šž	œ�œ˜Jšœ	�œ�œ
˜Jšœ�œ
˜Jš
œ	˜	š�œ�˜Jšœ�œ˜Jš
œ	˜	š�œ�œ˜J™Jš�œ	�œ�œ˜BJšœ
�œ
˜Jšœ�œ
˜Jš
œ˜Jšœ
Ÿ˜Jš
œ	˜	Jšœ
Ÿ˜Jš
œ	˜	Jš
œ
˜
—š
�œ
�œ�œ�œ�œ˜PJšœ�œ˜$Jš
œ
˜
—š�œ˜J™%Jšœ�œ�œ˜@Jš�œ	�œ�œ˜BJšœ
�œ
˜Jšœ�œ
˜Jš
œ˜Jš�œ
�œ�œ�œ˜-Jš
œ˜—š�œ�œ˜Jš
œ	˜	Jš
œ
˜
—Jš�œ
�œ
�œ�œ˜9Jš�œ
˜—Jš�œ	�œ.�œ˜CJš
œ˜—šžœ�œ˜š�œ�œ
�œ�œ�œ
�˜6š�œ$�œ�œ˜FJšœ�œ
˜Jš
œ˜Jš
œ˜Jš�œ
˜Jš
œ˜—Jš�œ
˜—Jš
œ˜—šžœ�œ˜š
�œ�œ
�œ�œ"�œ˜]Jš
œ(˜(Jš
œ˜Jš
œ˜—Jš
œ˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ˜Jš
œ˜—šžœ�œ˜Jš
�œ�œ�œ�œ�œ˜xJš
œ˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ	˜	Jš
œ˜—šžœ�œ˜Jš
œ/˜/Jš
œ)˜)Jš
œ˜š�œ�œ˜š�œ�œ
�œ�˜Jš
œ˜Jš�œ
˜—Jš�œ
�œ˜(Jš
œ˜—Jšœ�œ
˜Jš
œ˜—Jšœ�œ˜ Jš
œ*˜*Jš
œ)˜)Jšœ�œ�œ
˜'Jšœ�œ˜Jšœ
�œ�œ
˜š
�˜š�œ �˜&Jš
œ*˜*—Jš
œ˜š�œ�˜š
œ˜š�œ
�œ
�˜Jšœc�œ
˜hš
œ˜Jš	œ
�œ�œ�œ�œ	˜9—J˜7š
œ˜Jš	œ
�œ�œ�œ�œ˜9—J˜AJšœ(�œ˜.š�œ˜Jš�œ
�œ
�˜Jš�œ˜Jš
œ˜——Jšœ�œ
˜Jš
œ˜Jš
œ˜—š
œ˜Jšœ�œ+˜5Jš�œ�œ�œ�œ
˜5Jš�œ�œ�œ�œ�œ�œ
˜MJš�œ�œ�œ�œ˜2Jš�œ
�œ�œ�œ
˜-Jš�œ
�œ�œ�œ
˜.Jš
œ˜Jš
œ˜Jš
œ˜—Jšœ!�œ˜5š
œ
˜
Jš
œ
�œ�œ
�œ�œ
�œ
�œ˜P—Jš
œ˜Jš
œ8˜8Jšœ�œ
˜Jš�œ�œ˜—Jš�œ
˜—Jš�œ
˜—Jš
œ
˜
Jš
œ
˜
J˜J˜—šžœ�œ
�œ
�œ�œ�œ�œ˜DJšœ�œ�œ�œ˜BJ˜J˜—šžœ˜.Jš	œ�œ
�œ�œ
�œ˜'š�œ�œ"�œ�˜HJšœ	�œ˜+šžœ�œ
�œ�œ�œ�œ˜JJšœ�œ0˜:J˜JJš�œ�œ
�œ�œ˜)J˜OJš�œ�œ
�œ�œ˜)J˜EJš�œ�œ
�œ�œ˜)J˜%J˜JJš�œ�œ
�œ�œ˜)J˜—Jš
�œ�œ
�œ*�œX�œ˜µ
Jš�œ�œX�œ˜…
Jš�œ�œ
�œ
˜!Jš�œ
˜—J˜J˜—J˜hJ˜Jš�œ
˜——…—6îK¹