DIRECTORY
AlpineDebugRpcControl,
AlpineFileRpcControl,
AlpInstance,
AlpineEnvironment,
AlpineFile,
AlpineImportLocal,
AlpineOwner,
AlpineOwnerRpcControl,
AlpineVolume,
AlpineVolumeRpcControl,
AlpineControl USING [],
AlpineIdentity USING [myFileStore, myEncryptionKey],
AlpineTransaction,
AlpineTransactionRpcControl,
AlpineTransMgrRpcControl,
FilePrivate,
Rope,
RPC,
Process;

AlpineRemoteExportImpl: PROGRAM
IMPORTS
AlpineDebugRpcControl,
AlpineFile,
AlpineFileRpcControl,
AlpineImportLocal,
AlpineOwner,
AlpineOwnerRpcControl,
AlpineVolume,
AlpineVolumeRpcControl,
AlpineIdentity,
AlpineTransaction,
AlpineTransactionRpcControl,
AlpineTransMgrRpcControl,
FilePrivate,
Rope,
RPC,
Process
EXPORTS
AlpineControl
= BEGIN

version: RPC.VersionRange _ [6, 6];
exportRetryInterval: Process.Ticks _ Process.SecondsToTicks[60];

Conversation: TYPE = RPC.Conversation;
TransID: TYPE = AlpineTransaction.TransID;
Priority: TYPE = AlpineEnvironment.TransactionPriority;
OpenFileID: TYPE = AlpineFile.OpenFileID;
LockOption: TYPE = AlpineFile.LockOption;
VolumeGroupID: TYPE = AlpineOwner.VolumeGroupID;

ExportInterfaces: PUBLIC PROC [newNames: BOOL _ FALSE] = {
suffix: Rope.ROPE _ IF newNames THEN "newAlpine" ELSE "alpine";
ExportTransMgr: PROC [] = {
AlpineTransMgrRpcControl.ExportInterface[ 
interfaceName: [type: Rope.Cat["AlpineTransMgr.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey] 
};
ExportTransaction: PROC [] = {
AlpineTransactionRpcControl.ExportInterface[
interfaceName: [type: Rope.Cat["AlpineTransaction.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey]
};
ExportDebug: PROC [] = {
AlpineDebugRpcControl.ExportInterface[
interfaceName: [type: Rope.Cat["AlpineDebug.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey, parameterStorage: [gc: FilePrivate.stdPZone]]
};
ExportFile: PROC [] = {
AlpineFileRpcControl.ExportInterface[
interfaceName: [type: Rope.Cat["AlpineFile.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey, parameterStorage: [gc: FilePrivate.stdPZone]]
};
ExportOwner: PROC [] = {
AlpineOwnerRpcControl.ExportInterface[
interfaceName: [type: Rope.Cat["AlpineOwner.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey, parameterStorage: [gc: FilePrivate.stdPZone]]
};
ExportVolume: PROC [] = {
AlpineVolumeRpcControl.ExportInterface[
interfaceName: [type: Rope.Cat["AlpineVolume.", suffix], instance: AlpineIdentity.myFileStore, version: version], user: AlpineIdentity.myFileStore, password: AlpineIdentity.myEncryptionKey, parameterStorage: [gc: FilePrivate.stdPZone]]
};
Stubbornly[ExportTransMgr];
Stubbornly[ExportTransaction];
Stubbornly[ExportDebug];
Stubbornly[ExportFile];
Stubbornly[ExportOwner];
Stubbornly[ExportVolume];
AlpineImportLocal.Register[exportedFileStore: AlpineIdentity.myFileStore, importLocalProc: LocalImport ];
};

Stubbornly: PROC [proc: PROC] RETURNS [] ~ {
DO 
BEGIN
proc[ ! RPC.ExportFailed => { IF why = communications THEN GOTO Wait }];
RETURN;
EXITS
Wait => Process.Pause[exportRetryInterval];
END
ENDLOOP;
};


UnexportInterfaces: PUBLIC PROC [] ~ {
AlpineImportLocal.Unregister[];
AlpineTransMgrRpcControl.UnexportInterface[];
AlpineTransactionRpcControl.UnexportInterface[];
AlpineDebugRpcControl.UnexportInterface[];
AlpineFileRpcControl.UnexportInterface[];
AlpineOwnerRpcControl.UnexportInterface[];
AlpineVolumeRpcControl.UnexportInterface[];
};

LocalImport: SAFE PROC [handle: AlpInstance.Handle] = CHECKED {
handle.trans _ NEW[AlpineTransactionRpcControl.InterfaceRecordObject];
handle.trans^ _ [clientStubCreate: transCreate, clientStubCreateWorker: transCreateWorker, clientStubAssertAlpineWheel: transAssertAlpineWheel, clientStubFinish: transFinish, Unknown: AlpineTransaction.Unknown, OperationFailed: AlpineTransaction.OperationFailed];
handle.file _ NEW[AlpineFileRpcControl.InterfaceRecordObject];
handle.file^ _ [clientStubOpen: fileOpen, clientStubCreate: fileCreate, clientStubClose: fileClose, clientStubDelete: fileDelete, clientStubGetUniversalFile: fileGetUniversalFile, clientStubGetTransID: fileGetTransID, clientStubGetAccessRights: fileGetAccessRights, clientStubGetLockOption: fileGetLockOption, clientStubSetLockOption: fileSetLockOption, clientStubGetRecoveryOption: fileGetRecoveryOption, clientStubGetReferencePattern: fileGetReferencePattern, clientStubSetReferencePattern: fileSetReferencePattern, clientStubReadPages: fileReadPages, clientStubWritePages: fileWritePages, clientStubLockPages: fileLockPages, clientStubUnlockPages: fileUnlockPages, clientStubValidateCachePageLock: fileValidateCachePageLock, clientStubValidateCachePageLocks: fileValidateCachePageLocks,
 clientStubReadProperties: fileReadProperties, clientStubWriteProperties: fileWriteProperties, clientStubReadUserProperties: fileReadUserProperties, clientStubWriteUserProperties: fileWriteUserProperties,  clientStubUnlockVersion: fileUnlockVersion, clientStubIncrementVersion: fileIncrementVersion, clientStubGetSize: fileGetSize, clientStubSetSize: fileSetSize, clientStubUnlockFile: fileUnlockFile, AccessFailed: AlpineFile.AccessFailed, LockFailed: AlpineFile.LockFailed, OperationFailed: AlpineFile.OperationFailed, StaticallyInvalid: AlpineFile.StaticallyInvalid, Unknown: AlpineFile.Unknown, PossiblyDamaged: AlpineFile.PossiblyDamaged];
handle.owner _ NEW[AlpineOwnerRpcControl.InterfaceRecordObject];
handle.owner^ _ [clientStubReadProperties: ownerReadProperties, clientStubWriteProperties: ownerWriteProperties, clientStubCreate: ownerCreate, clientStubDestroy: ownerDestroy, clientStubReadNext: ownerReadNext, clientStubReadDBProperties: ownerReadDBProperties, clientStubReorganizeDB: ownerReorganizeDB, clientStubUnlock: ownerUnlock, AccessFailed: AlpineOwner.AccessFailed, LockFailed: AlpineOwner.LockFailed, OperationFailed: AlpineOwner.OperationFailed, StaticallyInvalid: AlpineOwner.StaticallyInvalid, Unknown: AlpineOwner.Unknown];
handle.volume _ NEW[AlpineVolumeRpcControl.InterfaceRecordObject];
handle.volume^ _ [clientStubGetNextGroup: volumeGetNextGroup, clientStubGetGroup: volumeGetGroup, clientStubGetEnclosingGroup: volumeGetEnclosingGroup, AccessFailed: AlpineVolume.AccessFailed, Unknown: AlpineVolume.Unknown, StaticallyInvalid: AlpineVolume.StaticallyInvalid];
};

transCreate: PROCEDURE [interface: AlpineTransactionRpcControl.InterfaceRecord, conversation: Conversation, createLocalWorker: BOOL, priority: Priority] RETURNS [transID: TransID] = {
RETURN[AlpineTransaction.Create[conversation, createLocalWorker, priority]];
};
transCreateWorker: PROCEDURE [interface: AlpineTransactionRpcControl.InterfaceRecord,  conversation: Conversation, transID: TransID, coordinator: AlpineEnvironment.FileStore, priority: Priority] = {
AlpineTransaction.CreateWorker[conversation, transID, coordinator, priority];
};
transAssertAlpineWheel: PROCEDURE [interface: AlpineTransactionRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, enable: BOOL] = {
AlpineTransaction.AssertAlpineWheel[conversation, transID, enable];
};
transFinish: PROCEDURE [interface: AlpineTransactionRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, requestedOutcome: AlpineTransaction.RequestedOutcome, continue: BOOL] RETURNS [outcome: AlpineTransaction.Outcome, newTrans: TransID] = {
[outcome, newTrans] _ AlpineTransaction.Finish[conversation, transID, requestedOutcome, continue];
};


fileOpen: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, universalFile: AlpineFile.UniversalFile, access: AlpineFile.AccessRights, lock: LockOption, recoveryOption: AlpineFile.RecoveryOption, referencePattern: AlpineFile.ReferencePattern] RETURNS [openFileID: OpenFileID, fileID: AlpineFile.FileID] = { 
[openFileID, fileID] _ AlpineFile.Open[conversation, transID, universalFile, access, lock, recoveryOption, referencePattern];
};
fileCreate: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeID: AlpineFile.VolOrVolGroupID, owner: AlpineFile.OwnerName, initialSize: AlpineFile.PageCount, recoveryOption: AlpineFile.RecoveryOption, referencePattern: AlpineFile.ReferencePattern] RETURNS [openFileID: OpenFileID, universalFile: AlpineFile.UniversalFile] = {
[openFileID, universalFile] _ AlpineFile.Create[conversation,
      transID, volumeID, owner, initialSize, recoveryOption, referencePattern];
};
fileClose: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] = {
AlpineFile.Close[conversation, openFileID];
};
fileDelete: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] = {
AlpineFile.Delete[conversation, openFileID];
};
fileGetUniversalFile: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [universalFile: AlpineFile.UniversalFile] = {
RETURN AlpineFile.GetUniversalFile[conversation, openFileID];
};
fileGetTransID: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [transID: TransID] = {
RETURN AlpineFile.GetTransID[conversation, openFileID];
};
fileGetAccessRights: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [access: AlpineFile.AccessRights] = {
RETURN AlpineFile.GetAccessRights[conversation, openFileID];
};
fileGetLockOption: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [lock: LockOption] = {
RETURN AlpineFile.GetLockOption[conversation, openFileID];
};
fileSetLockOption: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, lock: LockOption] = {
AlpineFile.SetLockOption[conversation, openFileID, lock];
};
fileGetRecoveryOption: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [recoveryOption: AlpineFile.RecoveryOption] = {
RETURN AlpineFile.GetRecoveryOption[conversation, openFileID];
};
fileGetReferencePattern: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] RETURNS [referencePattern: AlpineFile.ReferencePattern] = {
RETURN AlpineFile.GetReferencePattern[conversation, openFileID];
};
fileSetReferencePattern: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, referencePattern: AlpineFile.ReferencePattern] = {
AlpineFile.SetReferencePattern[conversation, openFileID, referencePattern];
};
fileReadPages: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, pageRun: AlpineFile.PageRun, pageBuffer: AlpineFile.RESULTPageBuffer, lock: LockOption] = {
AlpineFile.ReadPages[conversation, openFileID, pageRun, pageBuffer, lock];
};
fileWritePages: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, pageRun: AlpineFile.PageRun, pageBuffer: AlpineFile.VALUEPageBuffer, lock: LockOption] = {
AlpineFile.WritePages[conversation, openFileID, pageRun, pageBuffer, lock];
};
fileLockPages: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, pageRun: AlpineFile.PageRun, lock: LockOption] = {
AlpineFile.LockPages[conversation, openFileID, pageRun, lock];
};
fileUnlockPages: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, pageRun: AlpineFile.PageRun, retainCacheLocks: BOOLEAN] = {
AlpineFile.UnlockPages[conversation, openFileID, pageRun, retainCacheLocks];
};
fileValidateCachePageLock: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, lock: AlpineFile.CachePageLockConversion] RETURNS [BOOLEAN]= {
RETURN AlpineFile.ValidateCachePageLock[conversation, lock];
};
fileValidateCachePageLocks: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, locks: AlpineFile.CachePageLockConversions] RETURNS [locksGranted, locksNotGranted: LIST OF AlpineFile.CachePageLockConversion]= {
RETURN AlpineFile.ValidateCachePageLocks[conversation, locks];
};
fileReadProperties: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, desiredProperties: AlpineFile.PropertySet, lock: LockOption] RETURNS [properties: LIST OF AlpineFile.PropertyValuePair] = {
RETURN AlpineFile.ReadProperties[conversation, openFileID, desiredProperties, lock];
};
fileWriteProperties: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, properties: LIST OF AlpineFile.PropertyValuePair, lock: LockOption] = {
AlpineFile.WriteProperties[conversation, openFileID, properties, lock];
};
fileReadUserProperties: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, desiredProperties: AlpineFile.UserProperties, lock: LockOption] RETURNS [properties: AlpineFile.UserPropertyValuePairs]= {
RETURN AlpineFile.ReadUserProperties[conversation, openFileID, desiredProperties, lock];
};
fileWriteUserProperties: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, properties: AlpineFile.UserPropertyValuePairs, lock: LockOption] = {
AlpineFile.WriteUserProperties[conversation, openFileID, properties, lock];
};
fileUnlockVersion: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID] = {
AlpineFile.UnlockVersion[conversation, openFileID];
};
fileIncrementVersion: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, increment: LONG INTEGER] = {
AlpineFile.IncrementVersion[conversation, openFileID, increment];
};
fileGetSize: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, lock: LockOption] RETURNS [size: AlpineFile.PageCount] = {
RETURN AlpineFile.GetSize[conversation, openFileID, lock];
};
fileSetSize: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, size: AlpineFile.PageCount, lock: LockOption] = {
AlpineFile.SetSize[conversation, openFileID, size, lock];
};
fileUnlockFile: PROCEDURE [interface: AlpineFileRpcControl.InterfaceRecord, conversation: Conversation, openFileID: OpenFileID, retainCacheLocks: BOOLEAN] = {
AlpineFile.UnlockFile[conversation, openFileID, retainCacheLocks];
};


ownerReadProperties: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, owner: AlpineOwner.OwnerName, desiredProperties: AlpineOwner.OwnerPropertySet] RETURNS [properties: LIST OF AlpineOwner.OwnerPropertyValuePair] = {
RETURN AlpineOwner.ReadProperties[ conversation, transID, volumeGroupID, owner, desiredProperties];
};
ownerWriteProperties: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, owner: AlpineOwner.OwnerName, properties: LIST OF AlpineOwner.OwnerPropertyValuePair, enforceTotalQuota: BOOL] = {
AlpineOwner.WriteProperties[conversation, transID, volumeGroupID, owner, properties, enforceTotalQuota];
};
ownerCreate: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, owner: AlpineOwner.OwnerName, properties: LIST OF AlpineOwner.OwnerPropertyValuePair, enforceTotalQuota: BOOL] RETURNS [spaceLeftOnVolumeGroup: AlpineOwner.PageCount] = {
RETURN AlpineOwner.Create[conversation, transID, volumeGroupID, owner, properties, enforceTotalQuota];
};
ownerDestroy: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, owner: AlpineOwner.OwnerName] = {
AlpineOwner.Destroy[conversation, transID, volumeGroupID, owner];
};
ownerReadNext: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, previousOwner: AlpineOwner.OwnerName, desiredProperties: AlpineOwner.OwnerPropertySet] RETURNS [owner: AlpineOwner.OwnerName, properties: LIST OF AlpineOwner.OwnerPropertyValuePair] = {
RETURN AlpineOwner.ReadNext[conversation, transID, volumeGroupID, previousOwner, desiredProperties];
};
ownerReadDBProperties: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID] RETURNS [nOwners: NAT, nEntriesUsed: NAT, nEntries: NAT, totalQuota: AlpineOwner.PageCount, totalSpaceInUse: AlpineOwner.PageCount, volumeGroupSize: AlpineOwner.PageCount] = {
RETURN AlpineOwner.ReadDBProperties[conversation, transID, volumeGroupID];
};
ownerReorganizeDB: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, nEntries: NAT] = {
AlpineOwner.ReorganizeDB[conversation, transID, volumeGroupID, nEntries];
};
ownerUnlock: PROCEDURE [interface: AlpineOwnerRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID] = {
AlpineOwner.Unlock[ conversation, transID, volumeGroupID];
};


volumeGetNextGroup: PROCEDURE [interface: AlpineVolumeRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, previousGroup: VolumeGroupID, lock: LockOption] RETURNS [volumeGroupID: VolumeGroupID] = {
RETURN AlpineVolume.GetNextGroup[conversation, transID, previousGroup, lock];
};
volumeGetGroup: PROCEDURE [interface: AlpineVolumeRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeGroupID: VolumeGroupID, lock: LockOption] RETURNS [volumes: LIST OF AlpineVolume.VolumeID] = {
RETURN AlpineVolume.GetGroup[ conversation, transID, volumeGroupID, lock];
};
volumeGetEnclosingGroup: PROCEDURE [interface: AlpineVolumeRpcControl.InterfaceRecord, conversation: Conversation, transID: TransID, volumeID: AlpineVolume.VolumeID, lock: LockOption] RETURNS [volumeGroupID: AlpineVolume.VolumeGroupID] = {
RETURN AlpineVolume.GetEnclosingGroup[conversation, transID, volumeID, lock];
};

END.--AlpineRemoteExportImpl

CHANGE LOG
¢AlpineRemoteExportImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last edited by
Kolling on June 3, 1983 5:57 pm
MBrown on February 1, 1984 3:34:05 pm PST
Bob Hagmann June 3, 1985 10:23:52 am PDT
Carl Hauser, March 25, 1987 12:01:08 pm PST
NOTES
If calls to these procedures are FORKed, there is no way for anyone outside of this module to determine whether or not exporting has succeeded.  But there doesn't seem to be anything to do but call a wizard when export fails, anyway.  Repeated export failure due to communications problems should be noted in an activity log.
Last Edited by: Kupfer, February 28, 1985 5:57:47 pm PST
handle.trans _ AlpineTransactionRpcControl.NewInterfaceRecord[];
handle.file _ AlpineFileRpcControl.NewInterfaceRecord[];
handle.owner _ AlpineOwnerRpcControl.NewInterfaceRecord[];
handle.volume _ AlpineVolumeRpcControl.NewInterfaceRecord[];
AlpineTransaction interface

AlpineFile interface
AlpineOwner Interface
AlpineVolume Interface
Edited on February 28, 1985 5:57:36 pm PST, by Kupfer
Add routines to unexport the public interfaces.

Bob Hagmann June 3, 1985 9:31:14 am PDT
Add routines to do same machine (local) import

�Ê	õ˜Jš
œ™Jšœ
Ïm
œ1™<š
œ™Jš
œ™Jš
œ)™)Icode™(K™+—J˜Jš
œ™J˜Jš
œÅ™ÅJ™8J˜š
Ïk	˜	K˜K˜K˜K˜K˜Kš
œ˜K˜K˜K˜
K˜Kšœžœ˜Kšœžœ ˜4K˜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šœž˜K˜Kšœ	žœ˜#K˜@K˜Kšœžœžœ˜&Kšœ	žœ˜*Kšœ
žœ)˜7Kšœžœ˜)Kšœžœ˜)Kšœžœ˜0K˜š
Ïnœžœ
žœžœžœ˜:Kš	œ
žœžœ
žœ
žœ
˜?šŸœžœ˜˜*K˜À
—K˜—šŸœžœ˜˜,K˜Â
—K˜—šŸœžœ˜˜&K˜ê
—K˜—šŸ
œžœ˜˜%K˜é
—K˜—šŸœžœ˜˜&K˜ê
—K˜—šŸœžœ˜˜'K˜ë
—K˜—K˜K˜K˜K˜K˜K˜Kš
œi˜iK˜—K˜šŸ
œžœžœžœ˜,šžœ
˜š
ž˜š	œžœžœžœ
žœ	˜HKšžœ
˜—š
ž˜K˜+—Kš
ž˜—Kšžœ
˜—K˜K˜K˜—šŸœžœ˜&Kš
œ˜J˜-J˜0J˜*J˜)J˜*J˜+J˜—K˜šŸœžœ
žœ žœ˜?Jš
œ@™@Jšœžœ4˜FJš
œ‡˜‡Jš
œ8™8Jšœžœ-˜>Jš
œXž
œž
œSž
œXž
œ[ž
œ‹ž
œŠ
˜•JšœIž
œË
ž
œ‰
ž
œLž
œUž
œA˜„Jš
œ:™:Jšœžœ.˜@JšœZž
œiž
œYž
ϟ
˜›Jš
œ<™<Jšœžœ/˜BJš
œ“˜“J˜——˜Jš
œ™J™šÏbœž	œižœžœ˜·
JšžœE˜LJš
œ˜—š œž	œª
˜Æ
Jš
œM˜MJš
œ˜—š œž	œpžœ˜š
Jš
œC˜CJš
œ˜—š œž	œ¨
žœžœ<˜‡Jš
œb˜bJ˜—J˜Jš
œ™J˜š œž	œ—žœ9˜êJš
œ}˜}J˜—š 
œž	œ¡žœF˜ƒJš
œ�
˜�
Jš
œ˜—š 	œž	œj˜~Jš
œ+˜+Jš
œ˜—š 
œž	œj˜Jš
œ,˜,Jš
œ˜—š œž	œgžœ.˜»
Jšžœ7˜=Jš
œ˜—š œž	œgžœ˜ž
Jšžœ1˜7Jš
œ˜—š œž	œgžœ&˜²
Jšžœ6˜<Jš
œ˜—š œž	œgžœ˜¡
Jšžœ4˜:Jš
œ˜—š œž	œ|˜˜
Jš
œ9˜9Jš
œ˜—š œž	œgžœ0˜¾
Jšžœ8˜>Jš
œ˜—š œž	œgžœ4˜Ä
Jšžœ:˜@Jš
œ˜—š œž	œ™
˜»
Jš
œK˜KJš
œ˜—š 
œž	œÂ
˜Ú
Jš
œJ˜JJš
œ˜—š œž	œÁ
˜Ú
Jš
œK˜KJš
œ˜—š 
œž	œ™
˜±
Jš
œ>˜>Jš
œ˜—š œž	œ–
žœ˜¼
Jš
œL˜LJš
œ˜—š œž	œyžœžœ˜±
Jšžœ6˜<Jš
œ˜—š
 œž	œ{žœ!žœ
žœ'˜ö
Jšžœ8˜>Jš
œ˜—š
 œž	œ¤
žœžœ
žœ"˜ÿ
JšžœN˜TJš
œ˜—š œž	œsžœ
žœ4˜Ì
Jš
œG˜GJš
œ˜—š œž	œ§
žœ3˜‚JšžœR˜XJš
œ˜—š œž	œ«
˜Í
Jš
œK˜KJš
œ˜—š œž	œj˜†
Jš
œ3˜3Jš
œ˜—š œž	œržœ
žœ˜¢
Jš
œA˜AJš
œ˜—š œž	œyžœ!˜·
Jšžœ4˜:Jš
œ˜—š œž	œ˜
˜®
Jš
œ9˜9Jš
œ˜—š œž	œyžœ˜ž
Jš
œB˜BJš
œ˜—J˜Jš
œ™J˜š
 œž	œÏ
žœžœ
žœ(˜±Jšžœ]˜cJš
œ˜—š
 œž	œª
žœ
žœ8žœ˜‘J˜hJš
œ˜—š œž	œª
žœ
žœ8žœžœ4˜ÀJšžœ`˜fJš
œ˜—š œž	œ¡
˜¸
Jš
œA˜AJš
œ˜—š
 
œž	œ×
žœ,žœ
žœ(˜ÑJšžœ^˜dJš
œ˜—š œž	œ€
žœžœžœžœx˜ÏJšžœD˜JJš
œ˜—š œž	œŠ
žœ˜®
Jš
œI˜IJš
œ˜—š œž	œƒ
˜™
Jš
œ:˜:Jš
œ˜—J˜Jš
œ™J˜š œž	œ“
žœ#˜Ú
JšžœG˜MJ˜—š
 œž	œ“
žœžœ
žœ˜à
JšžœD˜JJ˜—š œž	œ–
žœ0˜ï
JšžœG˜MJ˜—J˜Jšžœ
Ïc˜—J˜Jšžœ
ž˜
™5Jš
œ/™/—J™™'Kš
œ.™.—K™—…—IÞXu