DIRECTORY
RefID USING [ID],
Rope USING [ROPE],
RuntimeError USING [ UNCAUGHT ],
SRPCCalls USING [
Conversation, Error, GetSHandle, Handle, NewRPCConversation, ReleaseConversation, ReportProc, SHandle, TimeoutEnable],
Thrush,
ThrushSunRPC,
ThrushSunRPCConvert,
VoiceRopeServer,
VoiceRopeServerSunImport,
VoiceRopeServerSunRPC,
VoiceRopeServerSunRPCClient
;

VoiceRopeServerToVoiceRopeServerSunRPC: CEDAR PROGRAM
IMPORTS RuntimeError, SRPCCalls, ThrushSunRPCConvert, VoiceRopeServerSunRPCClient
EXPORTS VoiceRopeServer, VoiceRopeServerSunImport
~ {

OPEN ThrushSunRPCConvert;

VoiceRope: TYPE = VoiceRopeServer.VoiceRope;
VoiceRopeInterval: TYPE = VoiceRopeServer.VoiceRopeInterval;

InterestClass: TYPE = VoiceRopeServer.InterestClass;

Users: TYPE = VoiceRopeServer.Users;
maxEnergy: INTEGER = VoiceRopeServer.maxEnergy;
EnergyRange: TYPE = VoiceRopeServer.EnergyRange;

EnergySequence: TYPE = VoiceRopeServer.EnergySequence;
EnergySequenceRec: TYPE = VoiceRopeServer.EnergySequenceRec;
VoiceSample: TYPE = VoiceRopeServer.VoiceSample;
VoiceBlock: TYPE = VoiceRopeServer.VoiceBlock;
VoiceBlockRec: TYPE = VoiceRopeServer.VoiceBlockRec;
Interval: TYPE = VoiceRopeServer.Interval;
IntervalSpecs: TYPE = VoiceRopeServer.IntervalSpecs;

sunSHHH: CARD32 = 0;
SHandle: TYPE ~ SRPCCalls.SHandle;
Record: PUBLIC PROC[shhh: Thrush.SHHH _ Thrush.none, credentials: Thrush.Credentials, serviceID: RefID.ID, recordedParty: Thrush.PartyID _ Thrush.nullID, intID: CARD _ 0, queueIt: BOOL _ TRUE] RETURNS [nb: Thrush.NB, voiceRope: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.Record[h: GetInfo[shhh], shhh: sunSHHH, credentials: CredentialsToSr[credentials], serviceID: serviceID, recordedParty: recordedParty, intID: intID, queueIt: queueIt];
nb _ SrToATOM[srNB];
voiceRope _ SrToVoiceRope[srVoiceRope];
};
Play: PUBLIC PROC[shhh: Thrush.SHHH _ Thrush.none, voiceRope: VoiceRope, credentials: Thrush.Credentials, serviceID: RefID.ID, intID: CARD _ 0, queueIt: BOOL _ TRUE] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Play[h: GetInfo[shhh], shhh: sunSHHH, voiceRope: VoiceRopeToSr[voiceRope], credentials: CredentialsToSr[credentials], serviceID: serviceID, intID: intID, queueIt: queueIt];
nb _ SrToATOM[srNB];
};
Stop: PUBLIC PROC[shhh: Thrush.SHHH _ Thrush.none, credentials: Thrush.Credentials, serviceID: RefID.ID] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Stop[h: GetInfo[shhh], shhh: sunSHHH, creentials: CredentialsToSr[credentials], serviceID: serviceID];
nb _ SrToATOM[srNB];
};
Pause: PUBLIC PROC[shhh: Thrush.SHHH _ Thrush.none, credentials: Thrush.Credentials, serviceID: RefID.ID] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Pause[h: GetInfo[shhh], shhh: sunSHHH, cedentials: CredentialsToSr[credentials], serviceID: serviceID];
nb _ SrToATOM[srNB];
};
Resume: PUBLIC PROC[shhh: Thrush.SHHH _ Thrush.none, credentials: Thrush.Credentials, serviceID: RefID.ID] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Resume[h: GetInfo[shhh], shhh: sunSHHH, credentials: CredentialsToSr[credentials], serviceID: serviceID];
nb _ SrToATOM[srNB];
};
Retain: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, callerRName: Rope.ROPE, vr: VoiceRope, class: InterestClass, refID: Rope.ROPE, other: Rope.ROPE _ NIL] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Retain[h: GetInfo[shhh], shhh: sunSHHH, callerRName: ROPEToSr[callerRName], vr: VoiceRopeToSr[vr], class: ROPEToSr[class], refID: ROPEToSr[refID], other: ROPEToSr[other] ];
nb _ SrToATOM[srNB];
};

Forget: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope, class: InterestClass, refID: Rope.ROPE] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.Forget[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr], class: ROPEToSr[class], refID: ROPEToSr[refID] ];
nb _ SrToATOM[srNB];
};

GetByInterest: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, class: InterestClass, refID: Rope.ROPE] RETURNS [nb: Thrush.NB, voiceRope: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.GetByInterest[h: GetInfo[shhh], shhh: sunSHHH, class: ROPEToSr[class], refID: ROPEToSr[refID] ];
nb _ SrToATOM[srNB];
voiceRope _ SrToVoiceRope[srVoiceRope];
};
Cat: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, callerRName: Rope.ROPE, vr1, vr2, vr3, vr4, vr5: VoiceRope _ NIL] RETURNS [nb: Thrush.NB, new: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.Cat[h: GetInfo[shhh], shhh: sunSHHH, callerRName: ROPEToSr[callerRName], vr1: VoiceRopeToSr[vr1], vr2: VoiceRopeToSr[vr2], vr3: VoiceRopeToSr[vr3], vr4: VoiceRopeToSr[vr4], vr5: VoiceRopeToSr[vr5]];
nb _ SrToATOM[srNB];
new _ SrToVoiceRope[srVoiceRope];
};

Substr: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, callerRName: Rope.ROPE, vr: VoiceRope, start: INT _ 0, len: INT _ LAST[INT]] RETURNS [nb: Thrush.NB, new: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.Substr[h: GetInfo[shhh], shhh: sunSHHH, callerRName: ROPEToSr[callerRName], vr: VoiceRopeToSr[vr], start: start, len: len];
nb _ SrToATOM[srNB];
new _ SrToVoiceRope[srVoiceRope];
};

Replace: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, callerRName: Rope.ROPE, vr: VoiceRope, start: INT _ 0, len: INT _ LAST[INT], with: VoiceRope _ NIL] RETURNS [nb: Thrush.NB, new: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.Replace[h: GetInfo[shhh], shhh: sunSHHH, callerRName: ROPEToSr[callerRName], vr: VoiceRopeToSr[vr], start: start, len: len, with: VoiceRopeToSr[with]];
nb _ SrToATOM[srNB];
new _ SrToVoiceRope[srVoiceRope];
};
Length: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope] RETURNS [nb: Thrush.NB, len: INT] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
[srNB, len] _ VoiceRopeServerSunRPCClient.Length[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr]];
nb _ SrToATOM[srNB];
};
DescribeRope: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope, minSilence: INT _ -1] RETURNS [nb: Thrush.NB, length: INT, noise: IntervalSpecs] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srIntervalSpecs: VoiceRopeServerSunRPC.IntervalSpecs;
[srNB, length, srIntervalSpecs] _ VoiceRopeServerSunRPCClient.DescribeRope[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr], minSilence: minSilence];
nb _ SrToATOM[srNB];
noise _ SrToIntervalSpecs[srIntervalSpecs];
};

GetEnergies: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope, samplesPerSegment: [1..8000] _ 160] RETURNS [nb: Thrush.NB, energies: EnergySequence] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srEnergySequence: VoiceRopeServerSunRPC.EnergySequence;
[srNB, srEnergySequence] _ VoiceRopeServerSunRPCClient.GetEnergies[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr], samplesPerSegment: samplesPerSegment];
nb _ SrToATOM[srNB];
energies _ SrToEnergySequence[srEnergySequence];
};
FetchBlock: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope, start: INT, len: INT _ 8000, decrypt: BOOLEAN _ TRUE] RETURNS [nb: Thrush.NB, block: VoiceBlock] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceBlock: VoiceRopeServerSunRPC.VoiceBlock;
[srNB, srVoiceBlock] _ VoiceRopeServerSunRPCClient.FetchBlock[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr], start: start, len: len, decrypt: decrypt];
nb _ SrToATOM[srNB];
block _ SrToVoiceBlock[srVoiceBlock];
};
StoreBlock: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, block: VoiceBlock, key: Thrush.EncryptionKey _ Thrush.nullKey] RETURNS [nb: Thrush.NB, voiceRope: VoiceRope] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srVoiceRope: VoiceRopeServerSunRPC.VoiceRope;
[srNB, srVoiceRope] _ VoiceRopeServerSunRPCClient.StoreBlock[h: GetInfo[shhh], shhh: sunSHHH, block: VoiceBlockToSr[block], key: EncryptionKeyToSr[key]];
nb _ SrToATOM[srNB];
voiceRope _ SrToVoiceRope[srVoiceRope];
};
SetPermissions: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, callerRName: Rope.ROPE, vr: VoiceRope, playAccess: Users, editAccess: Users] RETURNS [nb: Thrush.NB] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srNB _ VoiceRopeServerSunRPCClient.SetPermissions[h: GetInfo[shhh], shhh: sunSHHH, callerRName: ROPEToSr[callerRName], vr: VoiceRopeToSr[vr], playAccess: UsersToSr[playAccess], editAccess: UsersToSr[editAccess]];
nb _ SrToATOM[srNB];
};
GetPermissions: PUBLIC PROC [shhh: Thrush.SHHH _ Thrush.none, vr: VoiceRope] RETURNS [nb: Thrush.NB, playAccess: Users, editAccess: Users] = {
ENABLE {
SRPCCalls.Error => { nb _ ReportError[shhh, errCode, explanation]; CONTINUE; };
RuntimeError.UNCAUGHT => { nb _ ReportError[shhh, $unknownError]; CONTINUE; };
};
srNB: ThrushSunRPC.NB;
srPlayAccess, srEditAccess: VoiceRopeServerSunRPC.Users;
[srNB, srPlayAccess, srEditAccess] _ VoiceRopeServerSunRPCClient.GetPermissions[h: GetInfo[shhh], shhh: sunSHHH, vr: VoiceRopeToSr[vr]];
nb _ SrToATOM[srNB];
playAccess _ SrToUsers[srPlayAccess];
editAccess _ SrToUsers[srEditAccess];
};
GetInfo: PROC[shhh: Thrush.SHHH] RETURNS [h: SRPCCalls.Handle] ~ {
sHandle: SHandle;
IF shhh = NIL THEN SRPCCalls.Error[$noConversationSupplied];
sHandle _ SRPCCalls.GetSHandle[shhh];
IF sHandle=NIL THEN SRPCCalls.Error[$invalidConversationSupplied];
h _ sHandle.handle;
};

sunPgm: CARD _ 390912;  -- decimal program number for VoiceRopeServer
sunPgmVersion: CARD _ 1;
sunCallTimeout: INT _ 3000;
sunCallRetries: INT _ 3;
sunCallTimeoutEnable: SRPCCalls.TimeoutEnable _ always;

ReportProblem: TYPE ~ VoiceRopeServerSunImport.ReportProblem;

VRHandle: TYPE ~ REF VRHandleRec;
VRHandleRec: TYPE ~ RECORD [
reportProblem: ReportProblem,
reportData: REF
];

ImportInterface: PUBLIC PROC [instance: Rope.ROPE, reportProblem: ReportProblem_NIL, reportData: REF_NIL] RETURNS [shhh: Thrush.SHHH] ~ {
vrHandle: VRHandle _ NEW[VRHandleRec _ [reportProblem, reportData]];
shhh _ SRPCCalls.NewRPCConversation[serverName: instance, rpcProgram: sunPgm, rpcVersion: sunPgmVersion, timeoutEnable: sunCallTimeoutEnable, timeoutInMs: sunCallTimeout, retries: sunCallRetries, reportProc: ForwardReports, clientData: vrHandle];
SRPCCalls.GetSHandle[shhh].enabled _ TRUE;
};

UnImportInterface: PUBLIC PROC [shhh: Thrush.SHHH] ~ {
SRPCCalls.ReleaseConversation[shhh];
};

ReportError: PROC[shhh: Thrush.SHHH, errCode: ATOM, explanation: Rope.ROPE_NIL]
RETURNS[nb: Thrush.NB] ~ {
sHandle: SHandle _ SRPCCalls.GetSHandle[shhh];
IF sHandle=NIL THEN RETURN;
ForwardReports[sHandle, errCode, explanation];
nb _ $callFailed;
};

ForwardReports: SRPCCalls.ReportProc ~ {
vrHandle: VRHandle _ NARROW[sHandle.clientData];
IF vrHandle=NIL THEN RETURN; -- Can't report, perhaps handle has been released
vrHandle.reportProblem[vrHandle.reportData, ec, expl];
};
}.
6
VoiceRopeServerToVoiceRopeServerSunRPC.mesa
Copyright ำ 1990 by Xerox Corporation.  All rights reserved.
Pier, May 24, 1990 12:51:46 pm PDT
Swinehart, September 16, 1990 9:58:35 pm PDT
Polle Zellweger, December 28, 1990 12:11 pm PST
VoiceRopeServer is a voice service interface.  It is exported to $recording service parties to provide access to procedures for recording and playing voice, and for VoiceRope editing activities.


The following two definitions are identical to those in Jukebox; they are reproduced here to avoid a dependency on Jukebox


Creating and playing voice ropes



Pause playing the scheduled intervals.  No effect on recording.  No reports at present.

Interests in voice ropes
Editing voice ropes
Information about voice ropes

Retrieval and storage of voice samples

Creates a new voice rope whose contents are the given block.
Access control
Restricts access to the specified voice rope.  Only the creator of a voice rope may change its access control lists, i.e. invoke this operation.

Handles
Connecting
instance should be a SunRPC address, in the form "sun#[1.2.3.4]#5", where [1.2.3.4] is the Arpa address, and 5 is the port.
Polle Zellweger (PTZ) August 14, 1990 10:45:24 pm PDT
changes to: DIRECTORY, EXPORTS
Polle Zellweger (PTZ) October 29, 1990 5:13:22 pm PST
Allow detection of NIL ropes across a SunRPC connection.
changes to: Retain, Forget, GetByInterest
Polle Zellweger, December 27, 1990 6:15:26 pm PST
Added callerRName field to operations that need to know the caller's name.
changes to: Retain, Cat, Substr, Replace, SetPermissions

สค•NewlineDelimiter

™š
œ+™+Icode™<Kš
œ"™"K™,K™/—J˜JšœAฯo
œw™ย
J™š
ฯk	˜	Kšœžœžœ˜Jšœžœžœ˜Jšœ
žœžœ˜ šœ
žœ˜J˜v—Jš
œ˜Jš
œ
˜
J˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜
J˜—Jšฯn&œžœ
ž˜5JšžœJ˜QJšžœ*˜1Kš
œ˜K˜Kšžœ˜J˜Jšœžœ˜,Jšœžœ%˜<J˜Kšœžœ!˜4K˜Jšœžœ˜$J™Jš
œz™zJšœžœž
œ	ž
˜/Jšœ
žœ˜0J˜Jšœžœ"˜6šœžœž
œž
˜<J™—Jšœ
žœ˜0Jšœžœ˜.šœžœ!˜4J™—Jšœ
žœ˜*Jšœžœ!˜4J˜Icode0šœ	žœ˜Jšœ	žœ˜"
head™ šŸœžœžœBžœ8žœžœžœžœ
žœ˜๒
š
ะos˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ-˜-Jšœ2ฯbœก
˜ู
Kš
œ˜Kš
œ'˜'J˜—J™šŸœžœžœXžœ	žœžœžœžœ
žœ˜ม
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ#กœจ
˜ฯ
Kš
œ˜J˜J™—šŸœžœžœBžœžœ
žœ˜„
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ#กœb˜‰
Kš
œ˜J˜—J™šŸœžœžœžœ2žœžœ
žœ˜…
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—J™WJšœžœ
˜Jšœ#กœb˜Š
Kš
œ˜J˜J™—šŸœžœžœžœ2žœžœ
žœ˜†
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ#Ÿœc˜Œ
Kš
œ˜J˜——™šŸœžœžœ"žœ3žœžœžœžœ
žœ˜ธ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Kšœ#Ÿœฆ
˜ฯ
Kš
œ˜K˜J˜—šŸœžœžœAžœžœ
žœ˜ˆ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ#Ÿœj˜“
Kš
œ˜K˜—J˜šŸ
œžœžœ2žœžœ
žœ˜–
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ-˜-Jšœ2Ÿ
œS˜’
Kš
œ˜Kš
œ'˜'J˜——™šŸœžœžœ"žœ'žœžœ
žœ˜ 
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ-˜-Jšœ2Ÿœร
˜๘
Kš
œ˜Kš
œ!˜!K˜—K˜šŸœžœžœ"žœžœžœžœ
žœžœ
žœ˜ฎ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ-˜-Jšœ2Ÿœu˜ญ
Kš
œ˜Kš
œ!˜!K˜—K˜šŸœžœžœ"žœžœžœžœ
žœžœžœ
žœ˜ฦ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ-˜-Jšœ2Ÿœ
˜ษ
Kš
œ˜Kš
œ!˜!K˜——™šŸœžœžœžœ
žœžœ˜jš
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ*กœ9˜iKš
œ˜K˜K™—šŸœžœžœ+žœžœ
žœ
žœ˜Ÿ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ5˜5Jšœ>ŸœQ˜›
Kš
œ˜Kš
œ+˜+J˜K˜—š
ŸœžœžœCžœ
žœ˜ฃ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ7˜7Jšœ7Ÿœ_˜ก
Kš
œ˜Kš
œ0˜0J˜——™&šŸ
œžœžœ&žœžœžœžœžœ
žœ˜ญ
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ/˜/Jšœ3Ÿ
œc˜ 
Kš
œ˜Kš
œ%˜%K˜K™—š
Ÿ
œžœžœOžœ
žœ˜ช
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—K™<Jšœžœ
˜Jš
œ-˜-Jšœ2Ÿ
œ]˜™
Kš
œ˜Kš
œ'˜'K˜——™šŸœžœžœ"žœ7žœ
žœ˜ฆ
Kš
œ
™
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jšœ#กœฃ
˜ิ
Kš
œ˜K˜K™—š
Ÿœžœžœžœ
žœ+˜Ž
š
 ˜Jš
 O˜OJš
 N˜NJš
 ˜—Jšœžœ
˜Jš
œ8˜8JšœAกœ9˜ˆ
Kš
œ˜Kš
œ%˜%Kš
œ%˜%K˜——™šŸœžœžœžœ˜BKš
œ˜Kšžœžœ
žœ*˜<Kš
œ%˜%Kšžœ	žœ
žœ/˜BK˜K˜K˜——™
Jšœžœฯc-˜EJšœžœ˜Jšœžœ˜Jšœžœ˜J˜7J˜Jšœžœ*˜=K˜Kšœ
žœžœ
˜!šœ
žœžœ˜K˜Kšœž˜K˜—K˜šŸœžœ
žœžœžœžœ
žœžœžœ˜‰
K™{Kšœžœ,˜DKš
œ๖
˜๖
Kšœ%žœ
˜*K˜K˜—šŸœžœ
žœžœ˜6K˜$K˜K˜—š
Ÿœžœžœžœžœ
˜OKšžœž	œ˜Kš
œ.˜.Kšžœ	žœ
žœ
žœ
˜K˜.K˜K˜K˜—šŸœ˜(Kšœžœ˜0Kš	žœ
žœ
žœ
žœ
ž2˜NK˜6K˜——Jš
œ˜™5Kšœฯr™—™5K™8Kšœฃ™)—™1K™JKšœฃ,™8—K™—…—6,H