DIRECTORY
Ascii: TYPE USING [Lower],
BasicTime: TYPE USING [GMT, Now, Period, ToNSTime],
ComputeServerServer: TYPE USING [Register],
Commander: TYPE USING [Handle],
CommandUtil: TYPE USING [PairList, Echo, Failed, GetNth, GetRootName, ListLength, Parse, SetExtension],
CompilerOps: TYPE USING [AppendHerald, DefaultSwitches, DoTransaction, LetterSwitches, Punt, Start, Stop, StreamId, Transaction],
FileNames: TYPE USING [CurrentWorkingDirectory, GetShortName],
FileParms: TYPE USING [BindingProc, nullActual],
FileParmOps: TYPE USING [ClearAList, Finalize, Initialize, SetAList],
FS: TYPE USING [Delete, Error, FileInfo, GetName, nullOpenFile, OpenFile, OpenFileFromStream, StreamOpen],
IO: TYPE USING [Close, EndOfStream, Error, GetTokenRope, IDProc, int, Put, PutChar, PutRope, RIS, rope, RopeFromROS, ROS, STREAM, time],
Process: TYPE USING [CheckForAbort, GetPriority, MsecToTicks, Priority, priorityBackground, SetPriority, SetTimeout],
Rope: TYPE USING [Cat, Fetch, Find, Length, Replace, ROPE, Substr],
SymbolTable: TYPE USING [CacheSize, SetCacheSize],
TimeStamp: TYPE USING [Null];

CompilerServerCommandImpl: MONITOR
IMPORTS Ascii, BasicTime, CommandUtil, CompilerOps, ComputeServerServer, FileNames, FileParmOps, FS, IO, Process, Rope, SymbolTable
= { 

Outcome: TYPE = {ok, warnings, errors, aborted};

parms: REF CompilerOps.Transaction = NEW[CompilerOps.Transaction];
standardDefaults: CompilerOps.LetterSwitches = CompilerOps.DefaultSwitches[];
sourceName, objectName, errorName, rootName, wDir: Rope.ROPE _ NIL;
sourceStream, objectStream, errorStream: IO.STREAM _ NIL;
useLog: BOOL;		-- use compiler.log for error reporting
log: IO.STREAM _ NIL;

compilerInUse: BOOL _ FALSE;
inUseChanged: CONDITION;
inUseTimeoutMillis: NAT _ 1000;

WaitForCompilerFree: ENTRY PROC RETURNS[BOOL] = {
ENABLE UNWIND => NULL;
IF compilerInUse THEN {
Process.CheckForAbort[];
Process.SetTimeout[@inUseChanged, Process.MsecToTicks[inUseTimeoutMillis]];
WAIT inUseChanged;
RETURN[FALSE]};
RETURN[compilerInUse _ TRUE]};

SetCompilerFree: ENTRY PROC = {
compilerInUse _ FALSE;
BROADCAST inUseChanged};

Compile: SAFE PROC[cmd: Commander.Handle] RETURNS[result: REF _ NIL, msg: Rope.ROPE _ NIL] ~ TRUSTED { 
userAbort: BOOL _ FALSE;	-- set by ^DEL, STOP
errors, warnings: BOOL _ FALSE;
priority: Process.Priority = Process.GetPriority[];
compilerStartTime, moduleStartTime: BasicTime.GMT;
switchDefaults: CompilerOps.LetterSwitches;
moduleCount: CARDINAL _ 0;
complex: BOOL = (SELECT cmd.procData.clientData FROM
$Vanilla => FALSE, $Complex => TRUE, $RemoteVanilla => FALSE, ENDCASE => ERROR);

cmdStream: IO.STREAM;
filesInit: BOOL _ FALSE;
started: BOOL _ FALSE;

Cleanup: PROC = {
Process.SetPriority[priority];
IF log # NIL THEN {
msg _ msg.Cat[" - ", log.RopeFromROS];
log.Close[ ! IO.Error => CONTINUE];
log _ NIL};
IF started THEN {started _ FALSE; CompilerOps.Stop[]};
IF filesInit THEN {filesInit _ FALSE; FileParmOps.Finalize[]};
SetCompilerFree[]};

Initialize: PROC  = {
sourceStream _ FS.StreamOpen[sourceName];
parms.sourceStream _ sourceStream;
parms.source.version _ TimeStamp.Null;
parms.source.version.time _ (FS.FileInfo[name: sourceName, wDir: wDir].created).ToNSTime};

Finalize: PROC[userAbort: BOOL] = {
sourceFileName: Rope.ROPE;
IF objectStream # NIL THEN objectStream.Close[ ! IO.Error => CONTINUE];
IF sourceStream # NIL THEN {
sourceFile: FS.OpenFile _ FS.OpenFileFromStream[sourceStream];
sourceFileName _ sourceFile.GetName[ ! FS.Error => CONTINUE].fullFName;
sourceStream.Close[ ! IO.Error => CONTINUE]};
IF errorStream # NIL AND errorStream # log THEN
errorStream.Close[ ! IO.Error => CONTINUE];
objectStream _ sourceStream _ errorStream _ NIL;
IF userAbort OR parms.nErrors # 0 THEN {
IF objectName # NIL THEN
DO
FS.Delete[name: objectName, wDir: wDir 
! FS.Error => IF error.group = lock OR error.code = $unknownFile THEN EXIT];
ENDLOOP;
};
IF errorName = NIL THEN {
errlogFileName: Rope.ROPE _ CommandUtil.SetExtension[rootName, "errlog"]; 
DO
FS.Delete[name: errlogFileName, wDir: wDir 
! FS.Error => IF error.group = lock OR error.code = $unknownFile THEN EXIT];
ENDLOOP;
};
};

IF NOT WaitForCompilerFree[] THEN RETURN[$Failure, "B"];  -- Blocked


cmdStream _ IO.RIS[cmd.commandLine];
sourceName _ NIL;

Process.SetPriority[Process.priorityBackground];
msg _ "A"; -- in case of UNWIND, claim we were aborted
BEGIN ENABLE UNWIND => Cleanup[];

StartPass: PROC[pass: CARDINAL] RETURNS[goOn: BOOL] = {
userAbort _ FALSE;
Process.CheckForAbort[! ABORTED => {userAbort _ TRUE; CONTINUE}];
cmd.out.PutRope[" ." ! ABORTED => {userAbort _ TRUE; CONTINUE}];
IF userAbort THEN cmd.out.PutRope[" aborted."];
RETURN[~userAbort]};

compilerStartTime _ BasicTime.Now[];
switchDefaults _ CompilerOps.DefaultSwitches[];
parms.fileParms _ FileParmOps.Initialize[];
filesInit _ TRUE;
CompilerOps.Start[];
started _ TRUE;

wDir _ FileNames.CurrentWorkingDirectory[];
IF log = NIL THEN log _ IO.ROS[];
WriteHerald[log, NIL];  

DO
first: BOOL;
args, results: CommandUtil.PairList;
switches: Rope.ROPE _ NIL;
localPause: BOOL;
sense: BOOL;

{  -- start scope for EXITS
parms.switches _ switchDefaults;
parms.switches['p] _ FALSE;
parms.debugPass _ CARDINAL.LAST;
parms.getStream _ GetStream;
parms.startPass _ StartPass;
parms.objectBytes _ parms.objectFrameSize _ parms.linkCount _ 0;
parms.nErrors _ parms.nWarnings _ 0;
parms.sourceTokens _ 0;

IF complex THEN
[sourceName, args, results, switches] _ CommandUtil.Parse[cmdStream
! CommandUtil.Failed => GOTO badSyntax]
ELSE {
token: Rope.ROPE;
token _ cmdStream.GetTokenRope[IO.IDProc ! IO.EndOfStream => EXIT].token;
IF token.Length[] > 0 THEN SELECT token.Fetch[0] FROM
'- => switches _ token.Substr[1, token.Length[]-1];
ENDCASE => sourceName _ token};
IF sourceName = NIL AND switches = NIL THEN EXIT;
log.PutRope["\nCommand: "];
CommandUtil.Echo[log, sourceName, args, results, switches];
IF CommandUtil.ListLength[results] > 1 THEN GOTO badSemantics;
IF sourceName = NIL THEN GOTO globalSwitches;
rootName _ (CommandUtil.GetRootName[IF CommandUtil.ListLength[results] = 1
THEN CommandUtil.GetNth[results, 0]
ELSE FileNames.GetShortName[sourceName]]);
IF switches # NIL THEN {
sense _ TRUE;
FOR i: INT IN [0..switches.Length[]) DO
c: CHAR = switches.Fetch[i];
SELECT c FROM
'-, '~ => {sense _ ~sense; LOOP};
IN ['a..'z], IN ['A..'Z] =>
parms.switches[Ascii.Lower[c]] _ sense;
IN ['1..'5] =>
parms.debugPass _ c-'0;
ENDCASE;
sense _ TRUE;
ENDLOOP;
switches _ NIL};
sourceName _ CommandUtil.SetExtension[sourceName, "mesa"];
parms.source.locator _ FileNames.GetShortName[sourceName];

IF CommandUtil.ListLength[results] # 0 THEN {
objectName _ CommandUtil.GetNth[list: results, n: 0, delete: TRUE];
results _ NIL}
ELSE objectName _ rootName;
objectName _ CommandUtil.SetExtension[objectName, "bcd"];
parms.objectName _ objectName;
parms.objectFile _ FS.nullOpenFile;

moduleCount _ moduleCount + 1;

cmd.out.Put[IO.rope["Compiling: "], IO.rope[rootName]];
first _ TRUE;
FOR c: CHAR IN ['a..'z] DO
sd: BOOL = (IF c = 'p THEN FALSE ELSE standardDefaults[c]);
IF parms.switches[c] # sd THEN {
IF first THEN {first _ FALSE; cmd.out.PutChar['/]};
IF sd THEN cmd.out.PutChar['-];
cmd.out.PutChar[c]};
ENDLOOP;
useLog _ parms.switches['g];  parms.switches['g] _ FALSE;
localPause _ parms.switches['p];  parms.switches['p] _ FALSE;

Initialize[ ! FS.Error => GOTO noSource];
sourceName _ FileNames.GetShortName[sourceName];
{ ENABLE UNWIND => Finalize[userAbort];
FileParmOps.SetAList[args];
{ ENABLE UNWIND => FileParmOps.ClearAList[];

BindPattern: FileParms.BindingProc = {
parms.pattern _ actual;
parms.op _ IF actual = FileParms.nullActual THEN $compile ELSE $replace};

parms.fileParms.Binding[formalId: "$", formalType: NIL, binder: BindPattern];

log.PutChar['\n];  
moduleStartTime _ BasicTime.Now[];
CompilerOps.DoTransaction[parms
! 
CompilerOps.Punt => {
FileParmOps.ClearAList[];
Finalize[userAbort];
GOTO punt};
ABORTED => {
userAbort _ TRUE;
FileParmOps.ClearAList[];
Finalize[userAbort];
GOTO truncateList};
];
};  -- end  ENABLE UNWIND => FileParmOps.ClearAList[];
FileParmOps.ClearAList[];
};  -- end ENABLE UNWIND => Finalize[];
Finalize[userAbort];

SELECT WriteResults[cmd.out, moduleStartTime ! IO.Error => CONTINUE] FROM
$errors => errors _ TRUE;
$warnings => warnings _ TRUE;
ENDCASE;

EXITS
globalSwitches => {
objectName _ NIL;
sense _ TRUE;
FOR i: INT IN [0..switches.Length[]) DO
c: CHAR = switches.Fetch[i];
SELECT c FROM
'-, '~ => sense _ ~sense;
IN ['a..'z] => {switchDefaults[c] _ sense; sense _ TRUE};
IN ['A..'Z] => {
switchDefaults[VAL['a.ORD+(c.ORD-'A.ORD)]] _ sense; sense _ TRUE};
ENDCASE => EXIT;
ENDLOOP;
switches _ NIL;
args _ NIL};
noSource => {
log.Put[IO.rope[" -- source not found\n"], IO.time[]];
cmd.out.PutRope[" -- source not found\n"];
errors _ TRUE;
parms.nErrors _ 1;
args _ NIL};
badSemantics => {
objectName _ NIL; errors _ TRUE;
log.PutRope[" -- Illegal command"];
args _ NIL};
};

sourceName _ rootName _ objectName _ errorName _ NIL;
parms.objectName _ NIL;
results _ NIL;
log.PutChar['\n];
IF userAbort THEN {log.PutRope["\n... command aborted\n"];  GOTO truncateList};
IF (errors OR warnings) AND localPause THEN GOTO truncateList;

REPEAT
badSyntax => {log.PutRope["\n-- Illegal syntax"]; errors _ TRUE};
truncateList => switchDefaults['p] _ TRUE;
punt => {-- was Finalize[]; , but this is done by new UNWIND catch phrase
errors _ TRUE;
[] _ WriteResults[cmd.out, moduleStartTime ! IO.Error => CONTINUE];
log.PutChar['\n]};
ENDLOOP;
WriteClosing[cmd.out, compilerStartTime, moduleCount];

SELECT TRUE FROM 
userAbort => {
result _ $Failure;
msg _ "A"};
errors => {
result _ $Failure;
msg _ "F"};
warnings => {
result _ $Failure;
msg _ "W"};
ENDCASE =>  {
result _ $Success;
msg _ "S"};
END;  -- end catch phrase to release the resource and reset the process priority
Cleanup[]};

WriteResults: PROC[out: IO.STREAM, startTime: BasicTime.GMT] RETURNS[Outcome] = {
elapsed: INT;
log.Put[IO.rope[sourceName], IO.rope[" -- "]];
elapsed _ startTime.Period[to: BasicTime.Now[]];
IF parms.nErrors # 0 THEN {
log.Put[IO.rope["aborted, "], IO.int[parms.nErrors], IO.rope[" errors"]];
IF parms.nWarnings # 0 THEN {
log.Put[IO.rope[" and "], IO.int[parms.nWarnings], IO.rope[" warnings"]]};
IF ~useLog THEN log.Put[IO.rope[" on "], IO.rope[wDir], IO.rope[errorName]];
log.Put[IO.rope[", seconds: "], IO.int[elapsed]]}
ELSE {
log.Put[IO.rope["source tokens: "], IO.int[parms.sourceTokens]];
log.Put[IO.rope[", seconds: "], IO.int[elapsed]];
IF parms.objectBytes # 0 THEN {
log.Put[IO.rope["\n  code bytes: "], IO.int[parms.objectBytes]]; 
log.Put[IO.rope[", links: "], IO.int[parms.linkCount]];
log.Put[IO.rope[", frame size: "], IO.int[parms.objectFrameSize]];
IF parms.matched THEN log.PutChar['.]};
IF parms.nWarnings # 0 THEN {
log.PutChar['\n];
log.Put[IO.int[parms.nWarnings], IO.rope[" warnings"]];
IF log # NIL AND ~useLog THEN log.Put[IO.rope[" on "], IO.rope[errorName]]}};
out.PutRope[" "];
IF parms.nErrors = 0 THEN out.PutRope["no errors"]
ELSE out.Put[IO.int[parms.nErrors], IO.rope[" errors"]];
IF parms.nWarnings # 0 THEN
out.Put[IO.rope[", "], IO.int[parms.nWarnings], IO.rope[" warnings"]];
out.PutRope[".\n"];
RETURN[SELECT TRUE FROM
parms.nErrors # 0 => $errors,
parms.nWarnings # 0 => $warnings,
ENDCASE => $ok];
};

WriteHerald: PROC[s: IO.STREAM, id: Rope.ROPE] = {
CompilerOps.AppendHerald[s];
s.PutRope[" (Cedar 6 Version)\n"];
IF id # NIL THEN {s.Put[IO.rope[id], IO.rope[" -- "]]};
s.Put[IO.time[], IO.rope["\n"]]};

WriteClosing: PROC[out: IO.STREAM, startTime: BasicTime.GMT, moduleCount: CARDINAL] = {
elapsed: INT;
out.PutRope["End of compilation\n"];
elapsed _ startTime.Period[to: BasicTime.Now[]];
IF moduleCount > 1 THEN log.Put[IO.rope["\nTotal elapsed seconds: "], IO.int[elapsed]];
log.PutChar['\n]};


GetStream: PROC[id: CompilerOps.StreamId] RETURNS[IO.STREAM] = {
SELECT id FROM
source => RETURN[sourceStream];
object => {
IF objectStream = NIL THEN objectStream _ NewOutputStream[objectName];
RETURN[objectStream]};
log => {IF errorStream = NIL THEN ErrorInit[]; RETURN[errorStream]};
ENDCASE => ERROR;
};

NewOutputStream: PROC[fileName: Rope.ROPE] RETURNS[IO.STREAM] = {
RETURN[FS.StreamOpen[fileName: fileName, accessOptions: $create]]}; 

ErrorInit: PROC = {
IF errorStream = NIL THEN
IF useLog THEN errorStream _ log
ELSE {
errorName _ CommandUtil.SetExtension[rootName, "errlog"];
errorStream _ FS.StreamOpen[fileName: errorName, accessOptions: $create];
WriteHerald[errorStream, errorName];
errorStream.PutChar['\n]
}
};

IF SymbolTable.CacheSize[] < 256 THEN SymbolTable.SetCacheSize[256];
ComputeServerServer.Register["RemoteCompiler", NIL, Compile, "", $Vanilla];
ComputeServerServer.Register["RemoteComplexCompiler", NIL, Compile, "", $Complex];


}.

8CompilerServerCommandImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Satterthwaite, March 27, 1986 2:32:35 pm PST
Maxwell, January 26, 1984 9:05:33 am PST
Paul Rovner, December 4, 1983 11:57 am
Spreitzer, May 16, 1984 7:45:09 pm PDT
Russ Atkinson (RRA) April 3, 1985 4:02:43 pm PST
Bob Hagmann March 24, 1986 10:39:12 am PST

assumes that msg has a one character code in it (on entry) for the success/falilure of the compilation
acquire the compiler's resource lock; await success
init cmdStream and sourceName
do the compilation
IF log = NIL THEN log _ FS.StreamOpen[fileName: "Compiler.log", accessOptions: $create];
use a simple syntax for the command line
feedback to user
main line code
Here after completion of subcommand
Here after completion of all subcommands


compiler sequencing
write to the Commander output file
special output stream control
START HERE
Bob Hagmann March 24, 1986 8:41:20 am PST
changed log writing from writing Compiler.log to writing a ROS and returning it as part of the parameter "msg"
changes to: Cleanup, Compile


Κα˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ,™,K™(K™&K™&K™0K™*—K˜š
Οk	˜	Kšœžœ
žœ	˜Kšœžœ
žœžœ˜3Kšœžœ
žœ˜+Kšœžœ
žœ
˜Kšœ
žœ
žœP˜gKšœ
žœ
žœj˜
Kšœžœ
žœ)˜>Kšœžœ
žœ˜0Kšœ
žœ
žœ.˜EKšžœžœ
žœ\˜jKšžœžœ
žœOžœžœžœ˜ˆ
Kšœ	žœ
žœb˜uKšœžœ
žœ%žœ
˜CKšœ
žœ
žœ˜2Kšœžœ
žœ˜K˜—šœž˜"KšžœZžœžœ˜ƒ
Kš
œ˜K˜—Kšœ	žœ#˜0K˜Kšœžœžœ˜BK˜MKšœ8žœžœ
˜CKšœ)žœ
žœžœ
˜9K™KšœžœΟc'˜6Kšœžœ
žœžœ
˜K˜Kšœžœžœ
˜Kšœž	œ
˜Kšœžœ˜K˜š
Οnœžœ
žœ
žœ
žœ˜1Kšžœ
žœžœ
˜šžœžœ˜K˜Kš
œK˜KKšžœ˜Kšžœ
žœ˜—Kšžœžœ˜K˜—š œžœ
žœ˜Kšœžœ
˜Kšž	œ˜—K˜š œž	œžœ	žœžœžœžœžœ˜gKšœžœžœŸ˜-Kšœžœžœ
˜K˜3Kšœ.žœ
˜2K˜+Kšœ
žœ˜Kšœ	žœžœžœ
žœžœžœžœžœ˜…
K˜Kšœžœ
žœ
˜Kšœžœžœ
˜Kšœ	žœžœ
˜K˜š œžœ˜K™fK˜šžœžœ
žœ˜Kš
œ&˜&Kšœ
žœ
žœ˜#Kšœžœ˜—Kšžœ	žœžœ˜6Kšžœžœžœ˜>Kš
œ˜K˜—š 
œžœ˜Kšœžœ˜)Kš
œ"˜"K˜&Kšœžœ;˜ZK˜—š œžœžœ˜#Kšœžœ
˜Kš
žœžœ
žœžœ
žœ˜Gšžœžœ
žœ˜Kšœžœžœ"˜>Kšœ'žœ
žœ˜GKšœžœ
žœ˜-—šžœžœ
žœž˜/Kšœžœ
žœ˜+—Kšœ,žœ
˜0šžœžœžœ˜(šžœžœ
ž˜š
ž˜šžœ%˜'Kšœžœ
žœžœžœ
žœ˜L—Kšžœ
˜——K˜—šžœ
žœ
žœ˜Kšœžœ1˜Jš
ž˜šžœ)˜+Kšœžœ
žœžœžœ
žœ˜L—Kšžœ
˜—K˜—K˜—K˜Kš
œ3™3Kš	žœ
žœžœ
žœŸ
˜DK˜Kš
œ™K˜Kšœžœ
žœ˜$Kšœ
žœ
˜K˜Kš
œ™K˜0KšœŸ+˜6šžœ
žœ
žœ˜!K˜š
 	œžœžœžœžœ˜7Kšœžœ
˜Kšœžœžœžœ˜AKšœžœžœžœ˜@Kšžœžœ˜/Kšžœ˜K˜—K˜$K˜/K˜+Kšœžœ
˜K˜Kšœ
žœ
˜K˜K˜+Kšžœžœ
žœžœ>™XKš
žœžœ
žœžœ
žœ˜!Kšœžœ˜K˜š
ž˜Kšœžœ
˜K˜$Kšœžœžœ
˜Kšœžœ
˜Kšœžœ
˜K˜šœŸ˜Kš
œ ˜ Kšœžœ
˜Kšœžœ
žœ
˜ K˜K˜K˜@K˜$K˜K˜šžœž˜š
œC˜CKšœžœ˜'——šžœ˜Kš
œ(™(Kšœžœ
˜Kšœžœ
žœžœ˜Išžœžœ
žœž˜5K˜3Kšžœ˜——Kšžœžœ
žœžœ
žœ
žœ
˜1Kš
œ˜K˜;Kšžœ%žœ
žœ˜>Kšžœžœ
žœ
žœ˜-šœ$žœ$˜JKšžœ˜#Kšžœ&˜*—šžœžœ
žœ˜Kšœžœ
˜
šžœžœ
žœž˜'Kšœžœ˜šžœž˜
Kšœžœ˜!šžœžœ˜Kš
œ'˜'—šžœ˜Kš
œ˜—Kšžœ
˜—Kšœž˜
Kšžœ
˜—Kšœžœ˜—K˜:Kš
œ:˜:K˜šžœ%žœ˜-Kšœ=žœ˜CKšœ
žœ
˜—Kšžœ˜K˜9K˜Kšœžœ˜#K˜K˜K˜Kš
œ™Kšœžœžœ˜7Kšœžœ
˜
šžœžœ
žœ
ž˜Kšœžœžœžœ
žœ
žœ˜;šžœžœ˜ Kšžœžœ
žœ˜3Kšžœžœ˜Kš
œ˜—Kšžœ
˜—Kšœ3žœ
˜9Kšœ7žœ
˜=K˜K™Kšœžœ
žœ
ž
˜)K˜0šœžœ
žœ˜'K˜šœžœ
žœ˜,K˜šΟbœ˜&K˜Kšœžœžœ
žœ˜I—K˜Kšœ3žœ˜MK˜Kš
œ˜K˜"š
œ˜š
œ˜š
œ˜Kš
œ˜Kš
œ˜Kšžœ˜—šžœ˜Kšœžœ
˜Kš
œ˜Kš
œ˜Kšžœ˜—Kš
œ˜——KšœŸ2˜6—K˜KšœŸ#˜'—Kš
œ˜K˜šžœ)žœ
žœž˜IKšœžœ
˜Kšœžœ
˜Kšžœ
˜—K˜š
ž˜˜Kšœ
žœ
˜Kšœžœ
˜
šžœžœ
žœž˜'Kšœžœ˜šžœž˜
K˜Kšžœ1žœ˜9šžœ˜Kšœžœžœžœžœžœ˜B—Kšžœžœ
˜—Kšžœ
˜—Kšœžœ
˜Kšœžœ˜—˜
Kšœžœ!žœ	˜6Kš
œ*˜*Kšœ	žœ
˜Kš
œ˜Kšœžœ˜—˜Kšœ
žœžœ
˜ Kš
œ#˜#Kšœžœ˜——Kš
œ˜—K˜K™#Kšœ1žœ
˜5Kšœžœ
˜Kšœ
žœ
˜Kš
œ˜Kšžœžœ+žœ˜OKš
žœ	žœžœžœ
žœ˜>K˜š
ž˜Kšœ;žœ˜AKšœ%žœ
˜*šœ	Ÿ@˜IKšœ	žœ
˜Kšœ-žœ
žœ˜CKš
œ˜——Kšžœ
˜—K™(K˜6K˜šžœ
žœ
žœ
˜š
œ˜Jš
œ˜J˜—š
œ˜Jš
œ˜Jš
œ˜—š
œ
˜
Jš
œ˜Jš
œ˜—šžœ˜
Jš
œ˜J˜——KšžœŸJ˜P—Kš
œ˜—K™K™Kš
œ™K˜š œžœžœ
žœžœžœ
˜QKšœ	žœ
˜
Kšœžœžœ˜.Kš
œ0˜0šžœžœ˜Kšœžœžœžœ˜Išžœžœ˜Kšœžœžœžœ˜J—Kš
žœ	žœ	žœžœ
žœ˜LKšœžœžœ˜1—šžœ˜Kšœžœžœ˜@Kšœžœžœ˜1šžœžœ˜Kšœžœžœ˜AKšœžœžœ˜7Kšœžœžœ˜BKšžœžœ˜'—šžœžœ˜Kš
œ˜Kšœžœžœ˜7Kšžœžœ
žœ	žœ	žœžœ˜M——Kš
œ"™"Kšœž
˜Kšžœžœ˜2Kšžœ	žœžœ˜8šžœž˜Kšœžœ
žœžœ˜F—Kš
œ˜šžœ
žœ
žœ
ž˜Kš
œ˜K˜!Kšžœ	˜—Kš
œ˜K˜—š
 œžœžœ
žœžœ˜2Kš
œ˜Kš
œ"˜"Kš
žœžœ
žœžœžœ˜7Kšœžœ	žœ˜!K˜—š œžœžœ
žœžœžœ˜WKšœ	žœ
˜
Kš
œ$˜$Kš
œ0˜0Kšžœžœ	žœ$žœ˜WKš
œ˜K˜—Kš
œ™K˜š
 	œžœžœ
žœ
žœ˜@šžœž˜Kšœ
žœ˜š
œ˜Kšžœžœ
žœ,˜FKšžœ˜—Kš	œžœžœ
žœžœ˜DKšžœžœ
˜—Kš
œ˜K˜—š œžœžœžœ
žœ
žœ˜AKšžœ
žœ;˜DK˜—š 	œžœ˜šžœžœ
ž˜Kšžœžœ˜ šžœ˜Kš
œ9˜9Kšœžœ9˜IK˜$Kš
œ˜—Kš
œ
˜
—Kš
œ˜—K˜Kš
œ
™
Kšžœžœ˜DKš
œK˜KKš
œR˜RK˜K˜˜K˜—™)K™nKšœΟr™—K™K™—…—1¬FΕ