DIRECTORY
Arpa USING [Address, nullAddress],
ArpaUDP USING [nullPort],
Atom USING [GetPName],
Basics USING [HFromCard16, LowHalf],
BasicTime USING [GMT],
Convert USING [RopeFromCard],
ConvertExtras USING [ArpaAddressFromRope],
FS USING [Error],
FSBackdoor USING [ErrorCode, ProduceError],
FSRemoteFileBackdoor USING [GetServerProc, Register, ServerObject, ServerProcs, ServerProcsObject, SweepProc, ValidateProc],
RefText USING [Append, New],
Rope USING [Cat, Concat, Equal, FromRefText, IsEmpty, ROPE, ToRefText],
SafeStorage USING [EnableFinalization, EstablishFinalization, FinalizationQueue, FQNext, NewFQ],
SunAuthUnix USING [FixNameForUnix],
SunMount USING [EachExportProc, EachGroupProc, FHStatus, program, programVersion],
SunMountClient USING [Export, Mnt, Umntall],
SunNFS USING [FHandle, program, programVersion, Stat],
SunNFSFSRemoteFile USING [DirEntries, GetRemoteDirChild, GetRemoteDirRoot, InsertRemoteDirChild, RemoteDirHandle, RemoteDirObject, ServerData, ServerDataObject, SunNFSDelete, SunNFSDoIO, SunNFSEnumerateForInfo, SunNFSEnumerateForNames, SunNFSGetInfo, SunNFSRename, SunNFSRetrieve, SunNFSStore, SweepRemoteDirCache],
SunPMap USING [ipProtocolUDP, udpPort],
SunPMapClient USING [GetPort],
SunRPC USING [Create, Destroy, Error, Handle, SetRemote],
SunRPCAuth USING [Conversation, Error, Initiate, Terminate, unixFlavor],
SunYPAgent USING [Error, First, Handle, Match, Next, ObtainHandle, ReleaseHandle, TextSeq, Tokenize, TokenizeUsingSeparator],
UserCredentials USING [Get]
;

SunNFSFSRemoteServerImpl: CEDAR MONITOR
IMPORTS Atom, Basics, Convert, ConvertExtras, FS, FSBackdoor, FSRemoteFileBackdoor, RefText, Rope, SafeStorage, SunAuthUnix, SunMountClient, SunNFSFSRemoteFile, SunPMapClient, SunRPC, SunRPCAuth, SunYPAgent, UserCredentials
EXPORTS SunNFSFSRemoteFile
~ {
OPEN SunNFSFSRemoteFile;
ROPE: TYPE ~ Rope.ROPE;
ServerHandle: TYPE ~ REF ServerObject;
ServerObject: TYPE ~ FSRemoteFileBackdoor.ServerObject;
myFlavor: ATOM _ $NFS;
hostsMapName: ROPE _ "hosts.byname";
initialRemoteDirTTL: CARDINAL _ 120;
downServerTTL: CARDINAL _ 60;
upServerTTL: CARDINAL _ 0; -- irrelevant
myServerProcs: FSRemoteFileBackdoor.ServerProcs _
NEW[FSRemoteFileBackdoor.ServerProcsObject _ [
sweep~SunNFSSweepServer,
validate~SunNFSValidate,
delete~SunNFSDelete,
enumerateForInfo~SunNFSEnumerateForInfo,
enumerateForNames~SunNFSEnumerateForNames,
getInfo~SunNFSGetInfo,
rename~SunNFSRename,
retrieve~SunNFSRetrieve,
store~SunNFSStore,
doIO~SunNFSDoIO
]
];

SunNFSGetServer: PUBLIC FSRemoteFileBackdoor.GetServerProc -- [server: ROPE] RETURNS [h: ServerHandle, downMsg: ROPE] -- ~ {
ypH: SunYPAgent.Handle _ NIL;
rpcH: SunRPC.Handle _ NIL;
c: SunRPCAuth.Conversation _ NIL;
data: ServerData;
val: REF TEXT;

downMsg _ "BUG in SunNFSGetServer"; -- hope not to see this.


{
ENABLE {
SunYPAgent.Error => { downMsg _ NIL; GOTO Out };
SunRPCAuth.Error => { downMsg _ "Sun Auth error"; GOTO Out };
SunRPC.Error => { downMsg _ "Sun RPC error"; GOTO Out };
};
tokens: SunYPAgent.TextSeq;
myName, myPassword: ROPE;
mountPort, nfsPort: CARD;
mntResult: SunMount.FHStatus;
data _ NEW[ServerDataObject _
[ ttl~upServerTTL,
downMsg~NIL,
hostName~server,
address~Arpa.nullAddress,
port~ArpaUDP.nullPort,
mountPort~ArpaUDP.nullPort
]
];
SafeStorage.EnableFinalization[data];
ypH _ SunYPAgent.ObtainHandle[];
val _ SunYPAgent.Match[ypH, hostsMapName, server
! SunYPAgent.Error => CONTINUE];
IF val = NIL THEN val _ YPMatchIgnoringCase[ypH, hostsMapName, server];
tokens _ SunYPAgent.Tokenize[val];
IF tokens.length < 1 THEN { downMsg _ "error in YP hosts map"; GOTO Out };
data.address _ ConvertExtras.ArpaAddressFromRope[Rope.FromRefText[tokens[0]]];
SunYPAgent.ReleaseHandle[ypH]; ypH _ NIL;
rpcH _ SunRPC.Create[data.address, Basics.HFromCard16[SunPMap.udpPort]];
[myName, myPassword] _ UserCredentials.Get[];
c _ SunRPCAuth.Initiate[SunRPCAuth.unixFlavor, SunAuthUnix.FixNameForUnix[myName], myPassword];
mountPort _ SunPMapClient.GetPort[rpcH, c, SunMount.program, SunMount.programVersion, SunPMap.ipProtocolUDP];
nfsPort _ SunPMapClient.GetPort[rpcH, c, SunNFS.program, SunNFS.programVersion, SunPMap.ipProtocolUDP];
data.port _ Basics.HFromCard16[Basics.LowHalf[nfsPort]];
data.mountPort _ Basics.HFromCard16[Basics.LowHalf[mountPort]];
IF (mountPort = 0) OR (nfsPort = 0)
THEN { downMsg _ "service not exported"; GOTO Out };
rpcH _ SunRPC.SetRemote[rpcH, data.address, data.mountPort];
mntResult _ SunMountClient.Mnt[rpcH, c, Rope.ToRefText["/"]];
SunMountClient.Umntall[rpcH, c
! SunRPC.Error => CONTINUE];
IF mntResult.status # 0 THEN { downMsg _ "mount failed (/)"; GOTO Out };
data.remoteDirs _ NEW[RemoteDirObject _
[ nameComponent~"",
fHandle~mntResult.directory,
createMode~0,
createModeTTL~0,
contentMTime~[0, 0],
contentTTL~0,
useCount~1,
ttl~initialRemoteDirTTL
]
];
h _ NEW[FSRemoteFileBackdoor.ServerObject _
[ flavor~myFlavor,
name~server,
procs~myServerProcs,
data~data
]
];
downMsg _ MountExportedDirectories[h, rpcH, c];
IF downMsg # NIL THEN { h _ NIL; GOTO Out };
rpcH _ SunRPC.SetRemote[rpcH, data.address, data.port];
ReleaseRPCHandleAndConversation[h, rpcH, c];
rpcH _ NIL; c _ NIL;
downMsg _ NIL;
EXITS
Out => NULL;
};
IF (downMsg # NIL) AND (h # NIL) THEN ERROR; -- DEBUG
IF ypH # NIL THEN SunYPAgent.ReleaseHandle[ypH]; ypH _ NIL;
IF rpcH # NIL THEN SunRPC.Destroy[rpcH]; rpcH _ NIL;
IF c # NIL THEN SunRPCAuth.Terminate[c]; c _ NIL;
};

YPMatchIgnoringCase: PROC [ypH: SunYPAgent.Handle, mapName: ROPE, server: ROPE]
RETURNS [val: REF TEXT] ~ {
key: ROPE;
[key, val] _ SunYPAgent.First[ypH, mapName];
DO
IF Rope.Equal[key, server, FALSE] THEN RETURN;
[key, val] _ SunYPAgent.Next[ypH, mapName, key];
ENDLOOP;
};


Export: TYPE ~ REF ExportObject;
ExportObject: TYPE ~ RECORD [
next: Export,
path: REF TEXT
];

MountExportedDirectories: PROC [sH: ServerHandle, mountH: SunRPC.Handle, mountC: SunRPCAuth.Conversation]
RETURNS [failMsg: ROPE _ NIL] ~ {
exports, exportsTail: Export _ NIL;
EachExport: SunMount.EachExportProc -- [fileSys: Path] RETURNS [continue: BOOL] -- ~ {
IF exportsTail = NIL
THEN exports _ exportsTail _ NEW[ExportObject]
ELSE { exportsTail.next _ NEW[ExportObject]; exportsTail _ exportsTail.next };
exportsTail.path _ RefText.Append[RefText.New[fileSys.length], fileSys];
};
EachGroup: SunMount.EachGroupProc -- [group] RETURNS [continue: BOOL] -- ~ {
RETURN [TRUE];
};

{
ENABLE SunRPC.Error, SunRPCAuth.Error, FS.Error => {
failMsg _ "can't get exports from mount server";
GOTO Out;
};
SunMountClient.Export[mountH, mountC, EachExport, EachGroup];
IF exports = NIL THEN { failMsg _ "no exported file system on server"; GOTO Out };
};

DO
swapped: BOOL _ FALSE;
FOR p: Export _ exports, p.next WHILE p.next # NIL DO
IF p.path.length > p.next.path.length THEN {
temp: REF TEXT ~ p.path;
p.path _ p.next.path;
p.next.path _ temp;
swapped _ TRUE;
};
ENDLOOP;
IF NOT swapped THEN EXIT;
ENDLOOP;

FOR p: Export _ exports, p.next WHILE p # NIL DO
ENABLE SunRPC.Error, SunRPCAuth.Error, FS.Error => {
failMsg _ Rope.Cat["mount failed (", Rope.FromRefText[p.path], ")"];
GOTO Out;
};
pathComponents: SunYPAgent.TextSeq;
mntResult: SunMount.FHStatus;
dH: RemoteDirHandle;
IF (p.path.length < 1) OR (p.path[0] # '/) THEN {
failMsg _ Rope.Cat["mount export syntax error: ", Rope.FromRefText[p.path]];
GOTO Out;
};
WHILE (p.path.length > 1) AND (p.path[p.path.length-1] = '/) DO
p.path.length _ p.path.length - 1;
ENDLOOP;
IF p.path.length = 1 THEN LOOP; -- root has already been mounted
mntResult _ SunMountClient.Mnt[mountH, mountC, p.path];
SunMountClient.Umntall[mountH, mountC ! SunRPC.Error => CONTINUE];
IF mntResult.status # 0 THEN {
failMsg _ Rope.Cat["mount failed (", Rope.FromRefText[p.path], ")"];
GOTO Out;
};
pathComponents _ SunYPAgent.TokenizeUsingSeparator[p.path, '/];
IF pathComponents.length < 2 THEN ERROR; -- already checked for this above!
dH _ GetRemoteDirRoot[sH];
FOR j: CARDINAL IN [1 .. pathComponents.length-1) DO
[dHChild~dH] _ GetRemoteDirChild[sH, dH, Rope.FromRefText[pathComponents.refText[j]], FALSE
! FS.Error => { failMsg _ "mount failed (subdir search)"; GOTO Out }];
ENDLOOP;
dH _ InsertRemoteDirChild[dH, Rope.FromRefText[pathComponents.refText[pathComponents.length-1]], mntResult.directory];
ENDLOOP;
EXITS
Out => NULL;
};

SunNFSValidate: PUBLIC FSRemoteFileBackdoor.ValidateProc -- [h: ServerHandle] RETURNS [obsolete: BOOL, downMsg: ROPE] -- ~ {
data: ServerData _ NARROW[h.data];
IF (data.ttl = 0) AND (data.downMsg # NIL) THEN RETURN [TRUE, data.downMsg];
RETURN [FALSE, data.downMsg];
};

SunNFSSweepServer: FSRemoteFileBackdoor.SweepProc -- [h: ServerHandle, seconds: CARD] -- ~ {
data: ServerData _ NARROW[h.data];
rpcH: SunRPC.Handle;
c: SunRPCAuth.Conversation;
SweepServerInner: ENTRY PROC ~ INLINE {
ENABLE UNWIND => NULL;
IF data.ttl > seconds
THEN {
data.ttl _ data.ttl - seconds;
}
ELSE {
data.ttl _ 0;
rpcH _ data.h; data.h _ NIL;
c _ data.c; data.c _ NIL;
};
};
SweepRemoteDirCache[data.remoteDirs, seconds];
SweepServerInner[];
IF rpcH # NIL THEN SunRPC.Destroy[rpcH];
IF c # NIL THEN SunRPCAuth.Terminate[c];
};

ObtainRPCHandleAndConversation: PUBLIC PROC [sH: ServerHandle]
RETURNS [h: SunRPC.Handle, c: SunRPCAuth.Conversation] ~ {
ENABLE UNWIND => {
IF h # NIL THEN SunRPC.Destroy[h];
IF c # NIL THEN SunRPCAuth.Terminate[c];
};
data: ServerData _ NARROW[sH.data];
myName, myPassword: ROPE;
[myName, myPassword] _ UserCredentials.Get[];
[h, c] _ ObtainRPCHandleAndConversationInner[sH];
IF h = NIL THEN
h _ SunRPC.Create[data.address, data.port];
IF c = NIL THEN
c _ SunRPCAuth.Initiate[SunRPCAuth.unixFlavor, SunAuthUnix.FixNameForUnix[myName], myPassword
! SunRPCAuth.Error => ReportAuthError[code, sH, NIL]];
};

ObtainRPCHandleAndConversationInner: ENTRY PROC [sH: ServerHandle]
RETURNS [h: SunRPC.Handle, c: SunRPCAuth.Conversation] ~ {
ENABLE UNWIND => NULL;
data: ServerData _ NARROW[sH.data];
h _ data.h; data.h _ NIL;
c _ data.c; data.c _ NIL;
};

ReleaseRPCHandleAndConversation: PUBLIC PROC [sH: ServerHandle, h: SunRPC.Handle, c: SunRPCAuth.Conversation] ~ {
[h, c] _ ReleaseRPCHandleAndConversationInner[sH, h, c];
IF h # NIL THEN SunRPC.Destroy[h];
IF c # NIL THEN SunRPCAuth.Terminate[c];
};

ReleaseRPCHandleAndConversationInner: ENTRY PROC [sH: ServerHandle, h: SunRPC.Handle, c: SunRPCAuth.Conversation]
RETURNS [hOut: SunRPC.Handle, cOut: SunRPCAuth.Conversation] ~ {
ENABLE UNWIND => NULL;
data: ServerData _ NARROW[sH.data];
IF data.h = NIL THEN data.h _ h ELSE hOut _ h;
IF data.c = NIL THEN data.c _ c ELSE cOut _ c;
};

SetServerDown: ENTRY PROC [sH: ServerHandle, downMsg: ROPE] ~ {
data: ServerData _ NARROW[sH.data];
data.downMsg _ downMsg;
data.ttl _ downServerTTL;
};
ReportRPCError: PUBLIC PROC [code: ATOM, sH: ServerHandle, name, msg: ROPE] ~ {
r: ROPE;
fsErrorCode: FSBackdoor.ErrorCode;


r _ Rope.Cat["SunRPC.Error[", Atom.GetPName[code], "]"];
IF sH # NIL THEN {
SetServerDown[sH, r];
r _ Rope.Cat[r, ", Server: ", sH.name];
};
IF NOT Rope.IsEmpty[name] THEN r _ Rope.Cat[r, ", File: ", name];
IF NOT Rope.IsEmpty[msg] THEN r _ Rope.Cat[r, ", ", msg];

fsErrorCode _ (SELECT code FROM
$unreachable => serverInaccessible,
$timeout => connectionTimedOut,
$badCredentials, $badVerifier => badCredentials,
$wrongCredentials, $wrongVerifier, $weakCredentials => accessDenied,
$wrongProgram, $wrongProgramVersion, $wrongProc => connectionRejected,
ENDCASE => software);

FSBackdoor.ProduceError[fsErrorCode, r];
};

ReportAuthError: PUBLIC PROC [code: ATOM, sH: ServerHandle, msg: ROPE] ~ {
r: ROPE;
fsErrorCode: FSBackdoor.ErrorCode;

r _ Rope.Cat["SunRPCAuth.Error[", Atom.GetPName[code], "]"];
IF sH # NIL THEN {
SetServerDown[sH, r];
r _ Rope.Cat[r, ", Server: ", sH.name];
};
IF NOT Rope.IsEmpty[msg] THEN r _ Rope.Cat[r, ", ", msg];

fsErrorCode _ (SELECT code FROM
$badCredentials, $badVerifier => badCredentials,
$wrongUserPassword, $wrongService, $wrongCredentials, $wrongVerifier => accessDenied,
$timeout => serverInaccessible,
ENDCASE => software);

FSBackdoor.ProduceError[fsErrorCode, r];
};

ReportNFSError: PUBLIC PROC [status: SunNFS.Stat, sH: ServerHandle, name, msg: ROPE] ~ {
r, statusRope: ROPE;
fsErrorCode: FSBackdoor.ErrorCode;

SELECT status FROM
perm => { statusRope _ "perm"; fsErrorCode _ accessDenied };
noent => { statusRope _ "noent"; fsErrorCode _ unknownFile };
io => { statusRope _ "io"; fsErrorCode _ hardware };
nxio => { statusRope _ "nxio"; fsErrorCode _ unknownVolume };
acces => { statusRope _ "acces"; fsErrorCode _ accessDenied };
exist => { statusRope _ "exist"; fsErrorCode _ accessDenied };
nodev => { statusRope _ "nodev"; fsErrorCode _ unknownVolume };
notdir => { statusRope _ "notdir"; fsErrorCode _ fileTypeMismatch };
isdir => { statusRope _ "isdir"; fsErrorCode _ fileTypeMismatch };
fbig => { statusRope _ "fbig"; fsErrorCode _ quotaExceeded };
nospc => { statusRope _ "nospc"; fsErrorCode _ volumeFull };
rofs => { statusRope _ "rofs"; fsErrorCode _ accessDenied };
nametoolong => { statusRope _ "nametoolong"; fsErrorCode _ illegalName };
dquot => { statusRope _ "dquot"; fsErrorCode _ quotaExceeded };
stale => { statusRope _ "stale"; fsErrorCode _ invalidOpenFile };
ENDCASE => {
statusRope _ Convert.RopeFromCard[ORD[status]];
fsErrorCode _ software;
};

r _ Rope.Cat["SunNFS Error[", statusRope, "]"];
IF sH # NIL THEN r _ Rope.Cat[r, ", Server: ", sH.name];
IF NOT Rope.IsEmpty[name] THEN r _ Rope.Cat[r, ", File: ", name];
IF NOT Rope.IsEmpty[msg] THEN r _ Rope.Cat[r, ", ", msg];

FSBackdoor.ProduceError[fsErrorCode, r];
};

ReportFSError: PUBLIC PROC [code: FSBackdoor.ErrorCode, sH: ServerHandle, name, msg: ROPE] ~ {
r: ROPE _ NIL;

IF sH # NIL THEN r _ Rope.Concat["Server: ", sH.name];
IF NOT Rope.IsEmpty[name] THEN {
IF r # NIL THEN r _ Rope.Concat[r, ", "];
r _ Rope.Cat[r, "File: ", name];
};
IF NOT Rope.IsEmpty[msg] THEN {
IF r # NIL THEN r _ Rope.Concat[r, ", "];
r _ Rope.Concat[r, msg];
};

FSBackdoor.ProduceError[code, r];
};
dfq: SafeStorage.FinalizationQueue _ SafeStorage.NewFQ[];

Finalizer: PROC ~ {
DO
data: ServerData _ NARROW[SafeStorage.FQNext[dfq]];
p, next: RemoteDirHandle;
FOR p _ data.remoteDirs, next WHILE p # NIL DO
SELECT TRUE FROM
(p.child # NIL) => { next _ p.child; p.child _ NIL };
(p.sibling # NIL) => { next _ p.sibling; p.sibling _ NIL };
ENDCASE => { next _ p.parent };
ENDLOOP;
ENDLOOP;
};

SafeStorage.EstablishFinalization[type~CODE[ServerDataObject], npr~0, fq~dfq];
FSRemoteFileBackdoor.Register[myFlavor, SunNFSGetServer];

}...

ΤSunNFSFSRemoteServerImpl.mesa
Copyright Σ 1987 by Xerox Corporation.  All rights reserved.
Demers, November 5, 1987 9:27:09 pm PST
Copied Types
Parameters
Registered with FSRemoteFileBackdoor
Create server data object ...
Look up host address
Contact the server PortMapper, bind to Mount and NFS service ports.
Get fHandle for desired file system ...
Create server object (it's a little early to do this, but we need it to mount subdirectories, so we create it now and NIL it out if the subdirectory mounts fail) ...
Get fHandles for mounted subdirectories, if any (note at this point h looks like a valid, up handle) ...
Store RPC handle and credentials into server object ...
Okay ...
On failure raises SunYPAgent.Error[$noMoreEntries].
Ask mount server for exported mount points ...
Sort mount paths by length to ensure the mounts are done in the right order.  Bubble sort is good enough, since they ought to be presented by the server in order anyway ...
Mount each specified directory, making a pinned directory cache entry for it ...
Syntax check ...
Get fHandle for mount
Insert entry in directory cache ...
(Drop dH without unpinning it, so fHandle is never flushed from cache)
Error Reporting
Finalization
Initialization
Κο˜
codeš
œ™K™<K™'K˜—š
Οk	˜	Kšœœ˜"Kšœœ˜Kšœœ˜Kšœœ˜$Kšœ
œœ˜Kšœœ˜Kšœœ˜*Kšœ
œ	˜Kšœœ˜+Kšœœb˜|Kšœœ˜Kšœœ,œ
˜GKšœœO˜`Kšœœ˜#Kšœ	œD˜RKšœœ˜,Kšœœ*˜6Kšœœ£˜»Kšœœ˜'Kšœœ˜Kšœœ-˜9Kšœœ8˜HKšœœm˜}Kšœœ˜Kš
œ
˜
K˜—šΟnœœ
˜'Kšœ'œ―
˜ί
Kšœ˜K˜Kšœ˜
head™Kšœœœ
˜Kšœœœ˜&Kšœœ%˜7—™
Kšœ
œ˜Kšœœ˜$Kšœœ˜$Kšœœ˜Kšœ
œΟc
˜(—™$š
œ1˜1šœ+˜.K˜K˜K˜K˜(Kš
œ*˜*Kš
œ˜Kš
œ˜K˜K˜K˜K˜
—K˜K˜—šžœœ$Ÿ=œ˜|Kšœœ
˜Kšœœ
˜Kšœœ
˜!Kš
œ˜Kšœœ
œ
˜K˜Kšœ$Ÿ˜<˜K˜—š
œ
˜
šœ˜Kšœ œœ˜0Kšœ2œ˜=Kšœ-œ˜8K˜—K˜Kšœœ
˜Kšœœ
˜K˜™šœœ˜˜Kšœœ
˜Kš
œ˜J˜J˜J˜J˜
—J˜—J˜%—™Kš
œ ˜ š
œ0˜0Kšœœ˜ —Kšœœ
œ6˜GK˜"Kšœœ&œ˜JK˜NKšœ%œ
˜)—™CK˜HK˜-Kš
œ_˜_K˜mK˜gK˜8K˜?Kšœœœ%œ˜X—™'K˜<K˜=Kšœ1œ˜;Kšœœ!œ˜Hšœœ˜'š
œ˜Kš
œ˜Kš
œ
˜
K˜K˜K˜
K˜K˜K˜
—K˜——™₯
šœœ$˜+˜K˜K˜K˜	K˜
—K˜——™hKš
œ/˜/Kš
œœ
œœœ˜,—™7K˜7Kš
œ,˜,Kšœœœ
˜—™Kšœ
œ
˜—š
˜Kšœœ
˜—K˜—Kš
œœœœœ
œŸ˜5Kšœœ
œ&œ
˜;Kšœœ
œœ
˜4Kšœœ
œœ
˜1K˜K˜—šžœœ#œ
œœœ
œ˜kK™3Kšœœ
˜
K˜,š
˜Kšœœœ
œ
˜.K˜0Kšœ
˜—K˜K˜—K˜Kšœœœ˜ šœœœ˜K˜
Kšœœ
˜K˜K˜—šžœœK˜iKšœœœ˜!Jšœœ
˜#šž
œŸ.œ˜Všœ˜Kšœœ˜.Kšœœ1˜N—K˜HK˜—šž	œŸ&œ˜LKšœœ˜K˜K˜—™.˜
šœ!œ˜4K˜0Kšœ˜	K˜—Kš
œ=˜=Kšœœ
œ2œ˜RK˜K˜——™¬
š
˜Kšœ	œœ
˜šœœ
œ
˜5šœ$œ˜,Kšœœ
œ
˜K˜K˜Kšœ
œ
˜K˜—Kšœ
˜—Kšœ
œ	œ
œ
˜Kšœ
˜—K˜—™Pšœœœ
˜0šœ!œ˜4Kš
œD˜DKšœ˜	K˜—Kš
œ#˜#K˜Kš
œ˜™šœœœ˜1Kš
œL˜LKšœ˜	K˜—šœœ ˜?K˜"Kšœ
˜—Kšœœ
œŸ ˜@—™Kš
œ7˜7Kšœ8œ˜Bšœœ˜Kš
œD˜DKšœ˜	Kš
œ˜——™#Kš
œ?˜?Kšœœ
œŸ"˜KKš
œ˜šœœ
œ ˜4šœV˜[Kšœœ6œ˜F—Kšœ
˜—K˜v—K™FKšœ
˜——š
˜Kšœœ
˜—K˜K˜—šžœœ#Ÿ?œ˜|Kšœœ	˜"Jšœœœœ
œœ˜LJšœœ˜K˜K˜—šžœ!Ÿ&œ˜\Kšœœ	˜"K˜K˜šžœœ
œœ˜'Kšœ
œœ
˜šœ˜šœ˜Kš
œ˜K˜
—šœ˜Kš
œ
˜
Kšœœ
˜Kšœœ
˜K˜——K˜—K˜.Kš
œ˜Kšœœ
œ˜(Kšœœ
œ˜(K˜K˜—šžœœ
œœ3˜yšœ
œ˜Kšœœ
œ˜"Kšœœ
œ˜(K˜—Kšœœ
˜#Kšœœ
˜Kš
œ-˜-Kš
œ1˜1šœœ
˜K˜+—šœœ
˜KšœŽ
œ˜”
—K˜K˜—šž#œœ
œœ3˜}Kšœ
œœ
˜Kšœœ
˜#Kšœœ
˜Kšœœ
˜K˜K˜—šžœœ
œE˜qKš
œ8˜8Kšœœ
œ˜"Kšœœ
œ˜(K˜K˜—šž$œœ
œA˜qKšœ9˜@Kšœ
œœ
˜Kšœœ
˜#Kšœ
œ
œœ
˜.Kšœ
œ
œœ
˜.K˜K˜—šž
œœ
œœ˜?Kšœœ
˜#Kš
œ˜K˜K˜——™š
žœœ
œœœ˜OKšœœ
˜K˜"K˜K˜Kš
œ8˜8šœœ
œ˜Kš
œ˜Kš
œ'˜'J˜—Kšœ
œœ#˜AKšœ
œœ˜9K˜šœœ˜Kš
œ#˜#Kš
œ˜Kš
œ0˜0Kš
œD˜DKš
œF˜FKšœ˜—K˜K˜(K˜—K˜š
žœœ
œœœ˜JKšœœ
˜K˜"K˜Kš
œ<˜<šœœ
œ˜Kš
œ˜Kš
œ'˜'K˜—Kšœ
œœ˜9K˜šœœ˜Kš
œ0˜0Kš
œU˜UKš
œ˜Kšœ˜—K˜K˜(K˜K˜—šžœœ
œ4œ˜XKšœœ
˜K˜"K˜šœ˜Kš
œ<˜<Kš
œ=˜=Kš
œ4˜4Kš
œ=˜=Kš
œ>˜>Kš
œ>˜>Kš
œ?˜?Kš
œD˜DKš
œB˜BKš
œ=˜=Kš
œ<˜<Kš
œ<˜<Kš
œI˜IKš
œ?˜?Kš
œA˜Ašœ˜Kšœ"œ
˜/Kš
œ˜K˜K˜——Kš
œ/˜/Kšœœ
œ(˜8Kšœ
œœ#˜AKšœ
œœ˜9K˜K˜(Kš
œ˜K˜—šž
œœ
œ;œ˜^Kšœœœ
˜K˜Kšœœ
œ&˜6šœ
œœ˜ Kšœœ
œ˜)Kš
œ ˜ K˜—šœ
œœ˜Kšœœ
œ˜)Kš
œ˜K˜—K˜K˜!Kš
œ˜——™Kš
œ9˜9K˜šž	œœ˜š
˜Kšœœ˜3Kš
œ˜šœœœ
˜.šœ
œ
˜Kšœœ!œ˜5Kšœ
œ%œ˜;Kšœ˜—Kšœ
˜—Kšœ
˜—K˜K˜——™Kšœ'œ#˜Nš
œ9˜9K˜——K˜—K˜—…—80Kσ