DIRECTORY
BasicTime,
Commander,
DFOperations,
DFUtilities,
FS,
IO,
MessageWindow,
Process,
ReleaseToolVerify,
Rope,
SymTab,
VersionMap,
ViewerIO;

ReleaseToolDriver: CEDAR PROGRAM
IMPORTS BasicTime, Commander, DFUtilities, FS, IO, MessageWindow, Process, ReleaseToolVerify, Rope, SymTab, VersionMap, ViewerIO
SHARES VersionMap
= BEGIN

CommentItem: TYPE = DFUtilities.CommentItem;
Date: TYPE = DFUtilities.Date;
DirectoryItem: TYPE = DFUtilities.DirectoryItem;
FileItem: TYPE = DFUtilities.FileItem;
Filter: TYPE = DFUtilities.Filter;
ImportsItem: TYPE = DFUtilities.ImportsItem;
IncludeItem: TYPE = DFUtilities.IncludeItem;
Map: TYPE = VersionMap.Map;
MapList: TYPE = VersionMap.MapList;
ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
WhiteSpaceItem: TYPE = DFUtilities.WhiteSpaceItem;

ReleaseToolCommand: Commander.CommandProc = {
EachItem: DFUtilities.ProcessItemProc = {
WITH item SELECT FROM
incl: REF DFUtilities.IncludeItem => {
name: ROPE = incl.path1;
IO.PutRope[outV, "\n\nVerifyDF of "];
IO.PutRope[outV, name];
IF Rope.Equal[ShortName[name], shortDfFile, FALSE] THEN {
IO.PutRope[outV, "\n   not done, short name equals root DF name.\n"];
RETURN;
};
IO.PutF[outV, "\n  starting at %g\n", [time[BasicTime.Now[]]]];
[] _ ReleaseToolVerify.Verify[
name, bcdCache, sourceMaps, symbolsMaps, Interact, outV, outV];
};
ENDCASE;
};

debugging,verifying,moving: BOOL _ FALSE;
inV,outV: STREAM _ NIL;
inStream: STREAM _ NIL;
dfTable: SymTab.Ref _ NIL;
dfFile: ROPE _ "CurrentCedar.df";
shortDfFile: ROPE _ dfFile;
mapPrefix: ROPE _ "Cedar";
releaseDirectory: ROPE _ NIL;
releaseHost: ROPE _ NIL;
ris: STREAM = IO.RIS[cmd.commandLine];
sourceMapName,symbolsMapName: ROPE _ NIL;
sourceMaps,symbolsMaps: MapList _ NIL;
bcdCache: ReleaseToolVerify.BcdCache _ NIL;
Cleanup: PROC = {
IF bcdCache # NIL THEN {ReleaseToolVerify.FlushBcdCache[bcdCache]; bcdCache _ NIL};
IF inStream # NIL THEN {IO.Close[inStream]; inStream _ NIL};
IF inV # NIL THEN {IO.Close[inV]; inV _ NIL};
IF outV # NIL THEN {IO.Close[outV]; outV _ NIL};
};
TimedMessage: PROC [msg: ROPE] = {
IO.PutF[outV, msg, [time[BasicTime.Now[]]]];
};

WITH cmd.procData.clientData SELECT FROM
list: LIST OF REF ANY => {
WHILE list # NIL DO
SELECT list.first FROM
$debug => debugging _ TRUE;
$verify => verifying _ TRUE;
$move => moving _ TRUE;
ENDCASE;
list _ list.rest;
ENDLOOP;
};
ENDCASE;

dfFile _ DefaultExtension[
IO.GetTokenRope[ris, IO.IDProc ! IO.EndOfStream => CONTINUE].token, ".df"];
shortDfFile _ ShortName[dfFile];
mapPrefix _ IO.GetTokenRope[ris, IO.IDProc ! IO.EndOfStream => CONTINUE].token;
releaseHost _ IO.GetTokenRope[ris, IO.IDProc ! IO.EndOfStream => CONTINUE].token;
releaseDirectory _ IO.GetTokenRope[ris, IO.IDProc ! IO.EndOfStream => CONTINUE].token;

sourceMapName _ DefaultExtension[mapPrefix, "Source.VersionMap"];
sourceMaps _ LIST[VersionMap.RestoreMapFromFile[sourceMapName]];
symbolsMapName _ DefaultExtension[mapPrefix, "Symbols.VersionMap"];
symbolsMaps _ LIST[VersionMap.RestoreMapFromFile[symbolsMapName]];
inStream _ FS.StreamOpen[dfFile];

[inV,outV] _ ViewerIO.CreateViewerStreams[
"ReleaseTool.log", NIL, "ReleaseTool.log", FALSE];

{ENABLE
UNWIND => {
TimedMessage["\n\n**** Aborting at %g ****\n"];
Cleanup[];
};

IF verifying THEN {
TimedMessage["\n\nVerification Phase of ReleaseTool starting at %g\n"];
bcdCache _ ReleaseToolVerify.CreateBcdCache[80];
DFUtilities.ParseFromStream[inStream, EachItem];
TimedMessage["\n\nVerification Phase of ReleaseTool ending at %g\n"];
IO.Close[inStream];
inStream _ NIL;
ReleaseToolVerify.FlushBcdCache[bcdCache];
bcdCache _ NIL;
};

IF moving THEN {
TimedMessage["\n\nFile Moving Phase of ReleaseTool starting at %g\n"];
dfTable _ BuildDFTable[dfFile, outV, releaseHost, releaseDirectory];
TimedMessage["\nDF table built at %g\n"];
MoveFiles[dfTable, outV, releaseHost, releaseDirectory, debugging];
TimedMessage["\n\nFile Moving Phase of ReleaseTool ending at %g\n"];
};
};
Cleanup[];
};

showInfo: BOOL _ FALSE;
Interact: DFOperations.InteractionProc = {
out: STREAM = NARROW[clientData];
IF showInfo THEN
WITH interaction SELECT FROM
info: REF DFOperations.InfoInteraction => {
IO.PutRope[out, info.message];
};
dfInfo: REF DFOperations.DFInfoInteraction => {
IO.PutRope[out, dfInfo.message];
};
abort: REF DFOperations.AbortInteraction => {
Process.CheckForAbort[];
};
ENDCASE;
};

DefaultExtension: PROC [name: ROPE, ext: ROPE] RETURNS [ROPE] = {
len: INT = Rope.Length[name];
eLen: INT = Rope.Length[ext];
pos, bang, dot: INT _ len;
WHILE pos > 0 DO
posM: INT = pos-1;
SELECT Rope.Fetch[name, posM] FROM
'! => bang _ dot _ posM;
'. => dot _ posM;
'>, '/, '] => EXIT;
ENDCASE;
pos _ posM;
ENDLOOP;
IF bang = len
AND (bang-dot # eLen OR Rope.Run[name, dot, ext, 0, FALSE] # eLen)
THEN name _ Rope.Concat[name, ext];
RETURN [name];
};

DFTableEntry: TYPE = REF DFTableEntryRep;
DFTableEntryRep: TYPE = RECORD [
tempName: ROPE,
destName: ROPE,
time: BasicTime.GMT
];
BuildDFTable: PROC [topDF: ROPE, log: STREAM, host,dir: ROPE] RETURNS [tab: SymTab.Ref] = {
now: BasicTime.GMT = BasicTime.Now[];
index: INT _ 0;
EachDF: PROC [dfName: ROPE, dfDate: Date _ []] = {
EachDFPass[dfName, dfDate, TRUE];
EachDFPass[dfName, dfDate, FALSE];
};
EachDFPass: PROC [dfName: ROPE, dfDate: Date _ [], selfReferenceOnly: BOOL] = {
inStream: STREAM _ NIL;
currentDir: REF DirectoryItem _ NIL;
EachItem: DFUtilities.ProcessItemProc = {
WITH item SELECT FROM
dirItem: REF DirectoryItem => {
currentDir _ dirItem;
};
fileItem: REF FileItem => {
SELECT TRUE FROM
NOT selfReferenceOnly => RETURN;
currentDir = NIL =>
IO.PutF[log, "\n**** NIL directory: %g", [rope[dfName]]];
currentDir.path2 = NIL =>
IO.PutF[log, "\n**** no ReleaseAs clause for: %g", [rope[dfName]]];
currentDir.path2IsCameFrom => {
IO.PutF[log, "\n**** CameFrom clause for : %g", [rope[dfName]]];
};
ENDCASE => {
destName: ROPE _ Rope.Concat[
ReplaceHostAndDir[currentDir.path2, host, dir],
RemoveVersion[fileItem.name]];
entry.destName _ destName;
};
stop _ selfReferenceOnly;
};
inclItem: REF IncludeItem => {
IF selfReferenceOnly THEN RETURN;
EachDF[inclItem.path1, inclItem.date];
};
ENDCASE;
};
Cleanup: PROC = {
IF inStream # NIL THEN {IO.Close[inStream]; inStream _ NIL};
};
entry: DFTableEntry _ NIL;
stripped: ROPE = RemoveVersion[dfName];
realName: ROPE _ NIL;
key: ROPE _ NIL;
[realName, dfDate] _ MakeExplicit[dfName, dfDate];
IF realName = NIL THEN {
IO.PutF[log, "\n**** DF file not found: %g", [rope[dfName]]];
GO TO skipIt
};
inStream _ FS.StreamOpen[dfName _ realName];
key _ RemoveVersion[dfName];
WITH SymTab.Fetch[tab, key].val SELECT FROM
e: DFTableEntry => {
IF selfReferenceOnly THEN RETURN;
entry _ e;
};
ENDCASE => {
entry _ NEW[DFTableEntryRep _ [
tempName: IO.PutFR["Temp.%g.df", [integer[index]]],
destName: ReplaceHostAndDir[dfName, host, dir],
time: BasicTime.Update[now, index]
]];
IO.PutF[log, "\nDF table entry for: %g", [rope[dfName]]];
index _ index + 1;
[] _ SymTab.Store[tab, key, entry];
};
{ENABLE UNWIND => Cleanup[];
filter: Filter _ [filterA: source, filterB: public, filterC: defining];
IF selfReferenceOnly THEN {
using: REF DFUtilities.UsingList  _ NEW[DFUtilities.UsingList[1]];
using[0] _ [name: ShortName[dfName]];
using.nEntries _ 1;
filter _ [filterA: source, filterB: all, filterC: defining, list: using];
};
DFUtilities.ParseFromStream[
inStream, EachItem, filter
! DFUtilities.SyntaxError => {
IO.PutF[log, "\n**** Syntax Error: %g", [rope[reason]]];
CONTINUE;
}];
};
Cleanup[];
EXITS skipIt => {};
};
tab _ SymTab.Create[151, FALSE];
EachDF[topDF];
};

MakeExplicit: PROC [name: ROPE, date: Date] RETURNS [realName: ROPE _ NIL, realDate: Date] = {
realDate.format _ explicit;
[fullFName: realName, created: realDate.gmt] _ FS.FileInfo[name, date.gmt
! FS.Error => IF error.group # bug THEN CONTINUE];
IF realName = NIL THEN
[fullFName: realName, created: realDate.gmt] _ FS.FileInfo[RemoveVersion[name], date.gmt
! FS.Error => IF error.group # bug THEN CONTINUE];
};

ReplaceHostAndDir: PROC [name,host,dir: ROPE] RETURNS [dest: ROPE] = {
rbPos: INT = Rope.SkipTo[dest _ name, 1, "]"];
laPos: INT = Rope.SkipTo[dest, rbPos+1, "<"];
raPos: INT = Rope.SkipTo[dest, laPos+1, ">"];
IF dir # NIL THEN dest _ Rope.Replace[name, laPos+1, raPos-laPos-1, dir];
IF host # NIL THEN dest _ Rope.Replace[dest, 1, rbPos-1, host];
dest _ RemoveVersion[dest];
};

RemoveVersion: PROC [name: ROPE] RETURNS [ROPE] = {
pos: INT _ Rope.Length[name];
WHILE (pos _ pos - 1) > 0 DO
SELECT Rope.Fetch[name, pos] FROM
'! => RETURN [Rope.Flatten[name, 0, pos]];
'>, '], '. => EXIT;
ENDCASE;
ENDLOOP;
RETURN [name];
};

ShortName: PROC [name: ROPE] RETURNS [ROPE] = {
pos: INT _ Rope.Length[name];
bang: INT _ Rope.Length[name];
WHILE (pos _ pos - 1) > 0 DO
SELECT Rope.Fetch[name, pos] FROM
'! => bang _ pos;
'>, '] => RETURN [Rope.Flatten[name, pos+1, bang-pos-1]];
ENDCASE;
ENDLOOP;
RETURN [Rope.Flatten[name, 0, bang]];
};

FindDFName: PROC [table: SymTab.Ref, name: ROPE, date: Date] RETURNS [destName: ROPE, destDate: Date, tempName: ROPE _ NIL] = {
destName _ RemoveVersion[name];
destDate _ date;
WITH SymTab.Fetch[table, destName].val SELECT FROM
entry: DFTableEntry => {
destName _ entry.destName;
destDate.format _ explicit;
destDate.gmt _ entry.time; 
tempName _ entry.tempName; 
};
ENDCASE;
};

FindNonDF: PROC [table: SymTab.Ref, name: ROPE, date: Date] RETURNS [realName: ROPE _ NIL, realDate: Date _ []] = {
stripped: ROPE _ RemoveVersion[name];
WITH SymTab.Fetch[table, stripped].val SELECT FROM
entry: DFTableEntry => {
};
ENDCASE => {
[realName, realDate] _ MakeExplicit[name, date];
};
};

MoveFiles: PROC [table: SymTab.Ref, log: STREAM, host, dir: ROPE, debugging: BOOL] = {
nonDfAction: SymTab.EachPairAction = {
quit _ FALSE;
totalCount _ MoveDFContents[key, table, log, host, dir, totalCount, debugging];
};
dfAction: SymTab.EachPairAction = {
quit _ FALSE;
totalCount _ MoveDFTemp[key, val, log, totalCount, debugging];
};
totalCount: INT _ 0;
[] _ SymTab.Pairs[table, nonDfAction];
[] _ SymTab.Pairs[table, dfAction];
};

MoveDFContents: PROC [dfName: ROPE, table: SymTab.Ref, log: STREAM, host,dir: ROPE, count: INT, debugging: BOOL] RETURNS [INT _ 0] = {
entry: DFTableEntry _ NIL;
inStream,outStream: STREAM _ NIL;
currentDirItem: REF DirectoryItem;
currentSourcePrefix: ROPE _ NIL;
currentDestPrefix: ROPE _ NIL;
EachItem: DFUtilities.ProcessItemProc = {
WITH item SELECT FROM
dirItem: REF DirectoryItem => {
IF NOT dirItem.path2IsCameFrom AND dirItem.path2 # NIL THEN {
currentSourcePrefix _ dirItem.path1;
currentDestPrefix _ ReplaceHostAndDir[dirItem.path2, host, dir];
dirItem.path1 _ currentDestPrefix;
dirItem.path2 _ currentSourcePrefix;
dirItem.path2IsCameFrom _ TRUE;
};
currentDirItem _ dirItem;
};
file: REF FileItem => {
date: Date _ file.date;
sourceName: ROPE _ Rope.Concat[currentSourcePrefix, file.name];
destName: ROPE _ Rope.Concat[currentDestPrefix, RemoveVersion[file.name]];
destExists: BOOL _ FALSE;
realName,tempName: ROPE _ NIL;
[realName, date] _ FindNonDF[table, sourceName, file.date];
IF realName = NIL THEN {
[destName, date, tempName] _ FindDFName[table, sourceName, date];
IF NOT Rope.Match["*.df", destName, FALSE] THEN {
IO.PutF[log, "\n**** File not found: %g", [rope[sourceName]]];
GO TO skip1
};
IO.PutF[log, "\nFuture copy %g (%g)\n    to %g",
[rope[sourceName]], [rope[tempName]], [rope[destName]]];
file.date _ date;
GO TO skip1;
};

file.date _ date;
IO.PutF[log, "\nCopy %g\n    to ", [rope[sourceName _ realName]]];
IF debugging
THEN IO.PutF[log, "%g\n    (not copied, debugging)", [rope[destName]]]
ELSE {
ENABLE FS.Error =>
IF error.group # bug THEN {
IO.PutF[log, "\n**** Copy failed: %g", [rope[error.explanation]]];
GO TO skip1
};
gmt: BasicTime.GMT;
realName _ NIL;

[fullFName: realName, created: gmt] _ FS.FileInfo[destName
! FS.Error => IF error.group # bug THEN CONTINUE];
IF realName # NIL AND gmt = date.gmt
THEN {
destName _ realName;
IO.PutRope[log, destName];
IO.PutRope[log, "\n    (already there)"];
}
ELSE {
tempName: ROPE _ "ReleaseTool.Temp";
IF date.gmt # BasicTime.nullGMT
AND ReleaseToolVerify.IsInFileCache[sourceName, date]
THEN {
tempName _ sourceName;
}
ELSE {
tempName _ FS.Copy[from: sourceName, to: tempName];
};
destName _ FS.Copy[from: tempName, to: destName];
IO.PutRope[log, destName];
date.format _ explicit;
date.gmt _ gmt;
};
file.name _ Rope.Substr[destName, Rope.Length[currentDestPrefix]];
};
MessageWindow.Append[
IO.PutFR["  %g files moved.", [integer[count _ count + 1]]], TRUE];
EXITS skip1 => {};
};
imports: REF ImportsItem => {
destName, tempName: ROPE;
destDate: Date;
[destName, destDate, tempName] _ FindDFName[table, imports.path1, imports.date];
IF tempName = NIL
THEN {
[destName, destDate] _ MakeExplicit[imports.path1, imports.date];
IF destName = NIL
THEN IO.PutF[log, "\n**** File not found: %g", [rope[imports.path1]]]
ELSE {imports.path1 _ destName; imports.date _ destDate};
}
ELSE {
imports.path2 _ imports.path1;
imports.path1 _ destName;
imports.date _ destDate;
};
};
include: REF IncludeItem => {
IF NOT include.path2IsCameFrom OR include.path2 = NIL THEN {
destName, tempName: ROPE;
destDate: Date;
[destName, destDate, tempName] _ FindDFName[table, include.path1, include.date];
IF tempName = NIL
THEN {
[destName, destDate] _ MakeExplicit[include.path1, include.date];
IF destName = NIL
THEN IO.PutF[log, "\n**** File not found: %g", [rope[include.path1]]]
ELSE {include.path1 _ destName; include.date _ destDate};
}
ELSE {
include.path2IsCameFrom _ TRUE;
include.path2 _ include.path1;
include.path1 _ destName;
include.date _ destDate;
};
};
};
ENDCASE;
DFUtilities.WriteItemToStream[outStream, item];
};
WITH SymTab.Fetch[table, dfName].val SELECT FROM
e: DFTableEntry => entry _ e;
ENDCASE => {
IO.PutF[log, "\n**** DF file not in table: %g", [rope[dfName]]];
GO TO quit
};
inStream _ FS.StreamOpen[dfName
! FS.Error =>
IF error.group # bug THEN {
IO.PutF[log, "\n**** DF file not found: %g", [rope[error.explanation]]];
GO TO quit
};
];
outStream _ FS.StreamOpen[entry.tempName, create
! FS.Error =>
IF error.group # bug THEN {
IO.PutF[log, "\n**** temp DF file not opened: %g", [rope[error.explanation]]];
IO.Close[inStream];
GO TO quit
};
];
IO.PutF[log, "\n\nMoving contents of %g (%g)", [rope[dfName]], [rope[entry.tempName]]];
DFUtilities.ParseFromStream[inStream, EachItem, [comments: TRUE]
! DFUtilities.SyntaxError => {
IO.PutF[log, "\n**** Syntax Error: %g", [rope[reason]]];
CONTINUE;
}];
IO.Close[inStream];
FS.SetByteCountAndCreatedTime[FS.OpenFileFromStream[outStream], -1, entry.time];
IO.Close[outStream];
RETURN [count];
EXITS quit => {};
};

MoveDFTemp: PROC [name: ROPE, val: REF, log: STREAM, count: INT, debugging: BOOL] RETURNS [INT] = {
WITH val SELECT FROM
entry: DFTableEntry => {
IO.PutF[log, "\nCopy %g (%g)\n    to %g",
[rope[name]], [rope[entry.tempName]], [rope[entry.destName]]];
IF debugging
THEN
IO.PutRope[log, "\n    (not copied, debugging)"]
ELSE 
[] _ FS.Copy[from: entry.tempName, to: entry.destName
! FS.Error =>
IF error.group # bug THEN {
IO.PutF[log, "\n**** Copy failed: %g", [rope[error.explanation]]];
CONTINUE;
};
];
MessageWindow.Append[
IO.PutFR["  %g files moved.", [integer[count _ count + 1]]], TRUE];
};
ENDCASE;
RETURN [count];
};

Commander.Register[
"TestMovingPhase",
ReleaseToolCommand,
"tests the file moving phase of the ReleaseTool without moving files.  The command line has, in order (all optional):  <dfFile> <mapPrefix> <releaseHost> <releaseDirectory>",
LIST[$debug, $move]];

Commander.Register[
"VerifyRelease",
ReleaseToolCommand,
"verifies the files in a release.  We assume that the version maps are valid.  The command line has, in order (all optional):  <dfFile> <mapPrefix> <releaseHost> <releaseDirectory>",
LIST[$verify]];

Commander.Register[
"MoveRelease",
ReleaseToolCommand,
"moves the files in a release.  We assume that the version maps are valid, and that the files have been verified (although no state is retained between verification and moving).  The command line has, in order (all optional):  <dfFile> <mapPrefix> <releaseHost> <releaseDirectory>",
LIST[$move]];

END.

`ReleaseToolDriver.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Russ Atkinson, March 12, 1985 3:27:09 pm PST
[item: REF ANY] RETURNS [stop: BOOL _ FALSE]
The command line has the following items (all optional):
dfFile mapPrefix releaseHost releaseDirectory
[interaction: REF, clientData: REF]
RETURNS [abort: BOOL _ FALSE, abortMessageForLog: ROPE _ NIL, response: REF _ NIL]
Build a table of source DF names and entries.  Each entry gets a distinct desired create time, which is bounded by the start time of the procedure and the start time plus N seconds, where N is the number of DF files.
First check to see if we have seen this dfName before.
This file has a previous entry (put there on the previous pass)
Only need to do this stuff if this is the first entry for this file
This is the most restrictive fileter we can use to just get the Includes clauses
We are ONLY looking for the self-reference, so make the list say that.
In this case, the file is a DF file in our table, so we return NIL to indicate that it should NOT be moved!
[key: Key, val: Val] RETURNS [quit: BOOL]
[key: Key, val: Val] RETURNS [quit: BOOL]
The file requested is either a DF file (which does NOT get moved yet) or it does not exist, in which case we put a message to the log.
At this point, realName is the real long name of the sourceFile, and date is the real explicit date of the source file.
First, check to see if the file needs moving at all (based on the create date).
No move needed, since it it already there!
Move the file from the old place to the new place.
No need to copy to a temp file, since we already have this file in our cache.  Therefore, we just make the tempName the real source name.
It pays to copy this file to a temp file first, since that means we don't have to mess up our current file cache with entries that are better flushed.  This would not have to happen if FS did the right thing with remote to remote copies!
This is an imported file NOT being released.
This is an imported file that is being released.
This is an included file NOT being released.
This is an included file that is being released.
�ÊÀ˜
codeš
œ™Kšœ
Ïm
œ1™<Kš
œ,™,—K˜š
Ïk	˜	Kš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kšžœ
˜Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	K˜—šœžœ
ž˜ Kšžœ"žœžœO˜€
Kšžœ˜Kšœž˜K˜Kšœ
žœ˜,Kšœžœ˜Kšœžœ˜0Kšœ
žœ˜&Kšœžœ˜"Kšœ
žœ˜,Kšœ
žœ˜,Kšœžœ˜Kšœ	žœ˜#Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜Kšœžœ˜2K˜—š
œ-˜-š
œ)˜)Kšœžœ
žœžœžœžœ
™,šžœžœ
ž˜šœžœ˜&Kšœžœ˜Kšžœ#˜%Kšžœ˜šžœ*žœžœ˜9KšžœC˜EKšžœ
˜K˜—Kšžœ=˜?š
œ˜Kš
œ?˜?—K˜—Kšžœ
˜—K˜K˜—Kšœžœžœ
˜)Kšœ
žœžœ
˜Kšœ
žœžœ
˜Kšœžœ
˜Kšœžœ˜!Kšœ
žœ
˜Kšœžœ˜Kšœžœžœ
˜Kšœ
žœžœ
˜Kšœžœžœ
žœ˜&Kšœžœžœ
˜)Kšœ"žœ
˜&Kšœ'žœ
˜+šÏnœžœ˜Kšžœžœ
žœ8žœ˜SKš
žœžœ
žœžœžœ˜<Kš
žœžœ
žœžœžœ˜-Kš
žœžœ
žœžœžœ˜0K˜—šŸœžœžœ˜"Kšžœ*˜,K˜—K˜šžœžœ
ž˜(š	œžœ
žœ
žœ
žœ˜šžœžœ
ž˜šžœž˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜—Kšžœ
˜—K˜š
œ8™8Kš
œ-™-—š
œ˜Kšžœžœ
žœžœ˜K—Kš
œ ˜ Kš	œžœžœ
žœžœ˜OKš	œžœžœ
žœžœ˜QKš	œžœžœ
žœžœ˜VK˜Kš
œA˜AKšœ
žœ/˜@Kš
œC˜CKšœžœ0˜BKšœžœ˜!K˜š
œ*˜*Kšœžœžœ˜2K˜—šœ
ž˜šžœ˜Kš
œ/˜/Kš
œ
˜
K˜—K˜šžœžœ˜Kš
œG˜GKš
œ0˜0Kš
œ0˜0Kš
œE˜EKšžœ˜Kšœžœ
˜Kš
œ*˜*Kšœžœ
˜Kš
œ˜—K˜šžœžœ˜Kš
œF˜FKš
œD˜DKš
œ)˜)Kš
œC˜CKš
œD˜DK˜—K˜—K˜
Kš
œ˜K˜—Kšœ
žœžœ
˜š
œ*˜*Kšœžœžœ
™#Kšžœ	žœžœžœžœžœžœ
™RKšœžœžœ
˜!šžœž˜šžœ
žœ
ž˜šœžœ"˜+Kšžœ˜K˜—šœžœ$˜/Kšžœ˜ K˜—šœžœ#˜-Kš
œ˜K˜—Kšžœ
˜——Kš
œ˜K˜—šŸœžœžœžœžœžœ˜AKšœžœ˜Kšœžœ˜Kšœžœ˜šžœ	ž˜Kšœžœ	˜šžœž˜"Kš
œ˜Kš
œ˜Kšœžœ
˜Kšžœ
˜—K˜Kšžœ
˜—šžœ˜
Kšžœžœžœ	˜BKšžœ˜#—Kšžœ˜K˜K˜—Kšœžœžœ˜)šœžœžœ˜ Kšœ
žœ
˜Kšœ
žœ
˜Kšœž˜Kš
œ˜—šŸœžœ	žœžœžœžœ˜[Kš
ϯ
™Ø
Kšœžœ˜%Kšœžœ˜šŸœžœ
žœ˜2Kšœžœ˜!Kšœžœ˜"K˜—šŸ
œžœ
žœ(žœ˜OKšœ
žœžœ
˜Kšœžœžœ
˜$š
œ)˜)šžœžœ
ž˜šœ	žœ˜Kš
œ˜Kš
œ˜—šœ
žœ˜šžœ
žœ
ž˜Kšžœžœ
˜ šœ
žœ˜Kšžœ7˜9—šœžœ˜KšžœA˜C—š
œ˜Kšžœ>˜@K˜—šžœ˜šœ
žœ˜Kš
œ/˜/Kš
œ˜—Kš
œ˜K˜——Kš
œ˜Kš
œ˜—šœ
žœ˜Kšžœžœ
žœ
˜!Kš
œ&˜&Kš
œ˜—Kšžœ
˜—K˜—šŸœžœ˜Kš
žœžœ
žœžœžœ˜<K˜—Kš
œ6™6Kšœžœ
˜Kšœ
žœ˜'Kšœ
žœžœ
˜Kšœžœžœ
˜Kš
œ2˜2šžœžœ
žœ˜Kšžœ;˜=Kšžœ
žœ˜K˜—Kšœžœ˜,Kš
œ˜šžœžœ
ž˜+š
œ˜Kš
œ?™?Kšžœžœ
žœ
˜!Kš
œ
˜
K˜—šžœ˜Kš
œC™Cšœžœ˜Kšœ
žœ'˜3Kš
œ/˜/Kš
œ"˜"Kš
œ˜—Kšžœ7˜9Kš
œ˜Kš
œ#˜#Kš
œ˜——šœ
žœ
žœ˜š
œG˜GKš
œP™P—šžœžœ˜Kš
œF™FKšœžœžœ˜BKš
œ%˜%Kš
œ˜Kš
œI˜IK˜—š
œ˜Kš
œ˜š
œ˜Kšžœ6˜8Kšžœ
˜	Kš
œ˜——K˜—Kš
œ
˜
Kšžœ˜K˜—Kšœžœ˜ Kš
œ˜K˜K˜—šŸœžœžœžœžœžœ˜^Kš
œ˜šœ/žœ˜IKš	œžœ
žœžœ
žœ˜2—šžœžœ
ž˜šœ/žœ'˜XKš	œžœ
žœžœ
žœ˜2——K˜K˜—š
Ÿœžœžœžœžœ˜FKšœžœ$˜.Kšœžœ#˜-Kšœžœ#˜-Kšžœžœ
žœ8˜IKšžœžœ
žœ-˜?Kš
œ˜K˜K˜—š
Ÿ
œžœžœžœžœ˜3Kšœžœ˜šžœž˜šžœž˜!Kšœžœ˜*Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜K˜K˜—š
Ÿ	œžœžœžœžœ˜/Kšœžœ˜Kšœžœ˜šžœž˜šžœž˜!Kš
œ˜Kšœ
žœ)˜9Kšžœ
˜—Kšžœ
˜—Kšžœ˜%K˜K˜—šŸ
œžœžœ
žœžœžœžœ˜Kš
œ˜Kš
œ˜šžœ#žœ
ž˜2š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ
˜—K˜K˜—šŸ	œžœžœ
žœžœžœ˜sKšœ
žœ˜%šžœ#žœ
ž˜2š
œ˜Kš
œk™kKš
œ˜—šžœ˜Kš
œ0˜0Kš
œ˜——K˜K˜—š
Ÿ	œžœžœ
žœ
žœ˜Vš
œ&˜&Kšœžœžœ
™)Kšœžœ
˜
Kš
œO˜OKš
œ˜—š
œ#˜#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šœ
žœ<˜JKšœžœžœ
˜Kšœžœžœ
˜Kš
œ;˜;šžœžœ
žœ˜Kš
Ϡ
™†
Kš
œA˜Ašžœ
žœžœžœ˜1Kšžœ<˜>Kšžœ
žœ˜K˜—šžœ.˜0Kš
œ8˜8—K˜Kšžœ
žœ˜K˜K˜—Kš
œw™wK˜Kšžœ@˜Bšžœ
˜Kšžœ
žœ?˜Fšžœ˜šžœ
žœ	˜šžœžœ˜Kšžœ@˜BKšžœ
žœ˜K˜——Kšœžœ
˜Kšœžœ
˜K˜Kš
œO™Ošœ&žœ˜:Kš	œžœ
žœžœ
žœ˜2—šžœžœ
žœ˜$šžœ˜Kš
œ*™*Kš
œ˜Kšžœ˜Kšžœ'˜)K˜
—šžœ˜Kš
œ2™2Kšœ
žœ˜$šžœ˜Kšžœ2˜5šžœ˜Kš
œ‰
™‰
Kš
œ˜Kš
œ
˜
—šžœ˜Kš
ϒ
™í
Kšœžœ&˜3K˜——Kšœžœ$˜1Kšžœ˜K˜Kš
œ˜K˜——Kš
œB˜BK˜——š
œ˜Kšžœ;žœ˜C—Kšžœ
˜K˜—šœ	žœ˜Kšœžœ
˜K˜Kš
œP˜Pšžœž˜šžœ˜Kš
œ,™,Kš
œA˜Ašžœž˜Kšžœ
žœ>˜EKšžœ5˜9—K˜
—šžœ˜Kš
œ0™0Kš
œ˜Kš
œ˜Kš
œ˜K˜——K˜—šœ	žœ˜š
žœ
žœžœžœ
žœ˜<Kšœžœ
˜K˜Kš
œP˜Pšžœž˜šžœ˜Kš
œ,™,Kš
œA˜Ašžœž˜Kšžœ
žœ>˜EKšžœ5˜9—K˜
—šžœ˜Kš
œ0™0Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜K˜——K˜—K˜—Kšžœ
˜—Kš
œ/˜/K˜—šžœ!žœ
ž˜0Kš
œ˜šžœ˜Kšžœ>˜@Kšžœ
žœ˜
K˜——šœžœ˜šœžœ	˜
šžœžœ˜KšžœF˜HKšžœ
žœ˜
K˜——K˜—šœžœ"˜0šœžœ	˜
šžœžœ˜KšžœL˜NKšžœ˜Kšžœ
žœ˜
Kš
œ˜——Kš
œ˜—KšžœU˜Wšœ;žœ
˜@š
œ˜Kšžœ6˜8Kšžœ
˜	Kš
œ˜——Kšžœ˜Kšžœžœ0˜PKšžœ˜Kšžœ	˜Kšžœ˜K˜K˜—šŸ
œžœžœžœžœ	žœ
žœžœžœ˜cšžœžœ
ž˜š
œ˜šžœ'˜)Kš
œ>˜>—šžœ
˜š
ž˜Kšžœ.˜0—šžœ
˜šœžœ.˜5šœžœ	˜
šžœžœ˜Kšžœ@˜BKšžœ
˜	K˜——Kš
œ˜———š
œ˜Kšžœ;žœ˜C—Kš
œ˜—Kšžœ
˜—Kšžœ	˜K˜K˜—š
œ˜Kš
œ˜Kš
œ˜Kš
Ϩ
˜®
Kšžœ˜K˜—š
œ˜Kš
œ˜Kš
œ˜Kš
Ϧ
˜¶
Kšžœ˜K˜—š
œ˜Kš
œ˜Kš
œ˜Kš
œš˜šKšžœ	˜
K˜—Kšžœ
˜K˜—…—>š\º