DIRECTORY
Commander USING [ CommandProc, Register ],
FinchSmarts,
GList USING [ Member, Nconc ],
IO,
LarkFeepRpcControl USING [ Feep, ImportNewInterface ],
LupineRuntime USING [ BindingError ],
NamesGV USING [ GVGetAttribute, GVSetAttribute ],
NamesGVImpExp USING [ GVImport, UnGVImport ],
NamesRPC USING [ StartConversation ],
Nice,

PrincOpsUtils USING [ IsBound ],
Process USING [ SecondsToTicks, SetTimeout, Ticks ],
PupSocket USING [ GetUniqueID ],
RefID USING [ ID ],
RefQ USING [ Dequeue, Enqueue, Map, MapType, Queue ],
Rope,
RPC USING [ AuthenticateFailed, CallFailed, EncryptionKey, ImportFailed, VersionRange ],
ThParty	USING [ Advance, Alert, ConversationInfo, CreateConversation, Deregister, Enable, GetConversationInfo, GetKeyTable, GetParty, GetPartyFromNumber, GetPartyInfo, LookupServiceInterface, Register, RegisterKey, Unvisit, Visit ],
ThPartyRpcControl,
Thrush USING[
ActionReport, ConversationID, ConvEvent, Credentials, EncryptionKey, InterfaceSpec, NB, none, notReallyInConv, nullConvID, nullID, nullKey, PartyID, Reason, ROPE, SHHH, SmartsID, StateInConv, unencrypted ],
ThSmarts,
ThSmartsRpcControl,
ThVersions USING [ GetThrushVR, FinchVersion, FinchVR ],
UserProfile USING [ Token],
VoiceTemp USING [ IntervalSpec, IntervalSpecBody, IntervalSpecs, nullTuneID, TuneID, VoiceTime ],
VoiceTempRpcControl USING [ DescribeInterval, ImportNewInterface, Play, Record, Stop ],
VoiceUtils USING [ CurrentPasskey, CurrentRName, InstanceFromNetAddress, MakeRName, NetAddress, NetAddressFromRope, OwnNetAddress, Problem, ProblemFR, Report ]
;

FinchSmartsImpl: CEDAR MONITOR
IMPORTS Commander, IO, FinchSmarts, GList, LarkFeepRpcControl, LupineRuntime, NamesGV, NamesGVImpExp, NamesRPC, Nice, PrincOpsUtils, Process, PupSocket, RefQ, Rope, RPC, ThParty, ThPartyRpcControl, ThSmartsRpcControl, ThVersions, UserProfile, VoiceTempRpcControl, VoiceUtils
EXPORTS FinchSmarts, ThSmarts = {
OPEN IO;


ConvDesc: TYPE = FinchSmarts.ConvDesc;
ConversationID: TYPE = Thrush.ConversationID;
nullConvID: ConversationID = Thrush.nullConvID;
FinchInfo: TYPE = FinchSmarts.FinchInfo;
NB: TYPE = Thrush.NB;
none: SHHH = Thrush.none;
nullID: RefID.ID = Thrush.nullID;
PartyID: TYPE = Thrush.PartyID;
ROPE: TYPE = Thrush.ROPE;
SHHH: TYPE = Thrush.SHHH;
SmartsID: TYPE = Thrush.SmartsID;
StateInConv: TYPE = Thrush.StateInConv;

PD: TYPE = RECORD [
doReports: BOOL_FALSE,
doNice: BOOL_FALSE,
timeoutNoAction: INTEGER _ 30,
timeoutJayConnect: INTEGER _ 1,
noJayTicks: Process.Ticks _ Process.SecondsToTicks[1],
keyDistTicks: Process.Ticks _ Process.SecondsToTicks[10],
encryptionRequested: BOOLEAN_TRUE,
interfacesAreImported: BOOLEAN_FALSE,
smartsIsExported: BOOLEAN_FALSE,
waitsForConnect: NAT_6,
queueIt: BOOL_FALSE,
finchOn: BOOLEAN_FALSE,
maxProseLength: INT_1000
];

info: FinchInfo;
pd: REF PD _ NEW[PD_[]];

Report: PROC[what: ROPE] = {
IF NOT pd.doReports THEN RETURN;
VoiceUtils.Report[what, $Finch];
};

BeNice: PROC[r: REF, d: INT] = {
IF NOT pd.doNice THEN RETURN;
Nice.BeNice[r, d, $Finch, NIL];
};

NconcIntervals: PROC[l1, l2: VoiceTemp.IntervalSpecs] RETURNS [VoiceTemp.IntervalSpecs] = INLINE { RETURN[NARROW[GList.Nconc[l1, l2]]]; };

Progress: PUBLIC ENTRY PROC[
shh: SHHH,
convEvent: Thrush.ConvEvent
] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
IF convEvent.self.partyID = convEvent.other.partyID THEN [] _ NoteNewState[convEvent];
};

Substitution: PUBLIC ENTRY PROC[
shh: SHHH,
convEvent: Thrush.ConvEvent,
oldPartyID: Thrush.PartyID,
newPartyID: Thrush.PartyID
] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
cDesc: ConvDesc = GetConv[convEvent.self.convID, FALSE];
IF cDesc#NIL THEN cDesc.numParties _ 0; -- This will force the information update.
[] _ NoteNewState[ convEvent ];
};

ReportAction: PUBLIC ENTRY PROC[
shh: SHHH,
report: Thrush.ActionReport
] = {
ENABLE UNWIND => NULL;
request: REF;
cDesc: ConvDesc _ GetConv[report.self.convID, FALSE];
IF cDesc=NIL THEN { Problem["can't find conversation for report"]; RETURN; };
SELECT report.actionClass FROM
$keyDistribution => { BROADCAST cDesc.keysMightBeDistributed; cDesc.keysDistributed _ TRUE; RETURN; };
$recording, $playback => { -- We expect these, add Prose soon
FOR rqs: VoiceTemp.IntervalSpecs _ cDesc.pendingIntervals, rqs.rest WHILE rqs#NIL DO
IF report.actionID#rqs.first.intID THEN LOOP;
request _ rqs.first;
SELECT report.actionType FROM
$finished, $flushed => cDesc.pendingIntervals _ rqs.rest; ENDCASE;
EXIT;
ENDLOOP;
};
ENDCASE=> shh _ shh; -- a place to stand during debugging
IF info.ReportRequestState=NIL THEN RETURN;
IF request = NIL THEN { Problem["missing reports"]; RETURN; };
info.ReportRequestState[report, request];
BROADCAST info.stateChange; -- Sometimes callers wait (Ugh!)}
};

CallInfo: TYPE = REF CallInfoBody; -- needed because MBQueue requires a REF
CallInfoBody: TYPE = RECORD [
convID: Thrush.ConversationID,
calledPartyID: Thrush.PartyID_nullID,
reason: Thrush.Reason_NIL,
comment: ROPE_NIL
];

DisconnectCall: PUBLIC ENTRY PROC[
convID: Thrush.ConversationID,
reason: Thrush.Reason _ $terminating,
comment: ROPE_NIL] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
cDesc: ConvDesc; state: StateInConv;
IF NOT(([,cDesc, state]_FinchOn[convID]).on) THEN RETURN;
SELECT state FROM
$idle, $neverWas => {
info.ReportConversationState[$convNotActive, NIL, "No conversation to disconnect"];
};
ENDCASE => []_Request[cDesc, $idle, reason, comment];
};

AnswerCall: PUBLIC ENTRY PROC[convID: Thrush.ConversationID] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
cDesc: ConvDesc; state: StateInConv;
[,cDesc, state]_FinchOn[convID];
SELECT state FROM $ringing, $notified => []_Request[cDesc, $active]; ENDCASE;
};

PlaceCall: PUBLIC ENTRY PROC [
convID: Thrush.ConversationID_nullConvID,
rName: ROPE, -- rName or description
number: ROPE, -- telephone number, if present
useNumber: BOOL_FALSE
] = {
ENABLE {
UNWIND=>NULL; -- 
RestoreInvariant;
RPC.CallFailed => { UninitFinchSmarts["
Communication Failure"]; CONTINUE; };
};
calledPartyID: PartyID;
nb: NB;
reason: Thrush.Reason _ $notFound;
comment: Rope.ROPE _ NIL;
IF ~useNumber THEN {
[nb, calledPartyID] _ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:rName];
SELECT nb FROM $noSuchParty2, $noIdentSupplied => useNumber _ TRUE; ENDCASE;
};
IF useNumber AND number.Length[]>0 THEN
[nb, calledPartyID] _ ThParty.GetPartyFromNumber[
shh: info.shh, partyID: info.partyID, phoneNumber: number, description: rName];
SELECT nb FROM
$success => reason _ NIL; -- reason: NIL, comment: NIL
$noSuchParty2 => NULL; -- reason: $notFound, comment: NIL
$narcissism => comment _ "Attempt to call self rejected on philosophical grounds";
ENDCASE => { info.ReportConversationState[nb, NIL, NIL]; RETURN; };
[--
nb, cDesc--]_Connect[calledPartyID, convID, reason, comment];
};

Feep: PUBLIC ENTRY PROC[convID: ConversationID, feepString: ROPE] = {
cDesc: ConvDesc;
nb: Thrush.NB_$success;
state: StateInConv;
IF NOT(([,cDesc, state]_FinchOn[convID]).on) OR state#$active THEN nb _ $convNotActive;
IF nb=$success AND cDesc.feepInterface=NIL THEN {
IF cDesc.numParties>1 THEN [nb, cDesc.feepInterfaceSpec] _ ThParty.LookupServiceInterface[
info.shh, cDesc.situation.self, cDesc.partyInfo[1].partyID, "LarkFeep"]
ELSE nb_$noFeepingParty;
IF nb=$success THEN
cDesc.feepInterface _ LarkFeepRpcControl.ImportNewInterface[
interfaceName: cDesc.feepInterfaceSpec.interfaceName,
hostHint: cDesc.feepInterfaceSpec.hostHint!RPC.ImportFailed => CONTINUE
];
};
IF nb=$success THEN nb _ LarkFeepRpcControl.Feep[
interface: cDesc.feepInterface, shhh: info.shh,
serviceID: cDesc.feepInterfaceSpec.serviceID,
convID: cDesc.situation.self.convID, requestingParty: cDesc.situation.self.partyID,
number: feepString, noisy: TRUE, on: 100, off: 80
];
IF nb # $success THEN VoiceUtils.Report["Sorry, was not able to `feep'.", $Finch]; 
};
PlaybackTune: PUBLIC ENTRY PROC [
convID: Thrush.ConversationID,
intervalSpec: VoiceTemp.IntervalSpec,
key: Thrush.EncryptionKey,
queueIt: BOOL_TRUE,
failOK: BOOL_FALSE -- playing is optional; leave connection open if tune doesn't exist.
] RETURNS [ started: BOOL_FALSE, newConvID: Thrush.ConversationID_Thrush.nullConvID ] = { -- FALSE if failed
ENABLE UNWIND=>NULL;
cDesc: ConvDesc;
nb: NB;
keyIndex: [0..17B];
IF intervalSpec.tuneID<=VoiceTemp.nullTuneID THEN {
info.ReportConversationState[$convNotActive, NIL, "No such tune"]; RETURN; }; -- UGH!
[nb,cDesc]_VoiceConnect[convID];
IF nb#$success THEN RETURN; -- 
Complain?
newConvID _ cDesc.situation.self.convID;
[nb, keyIndex] _ ThParty.RegisterKey[
shh: info.shh, credentials: cDesc.situation.self, key: key, reportNewKeys: TRUE];
{SELECT nb FROM
$success => NULL;
$newKeys => {
cDesc.keysDistributed _ FALSE;
WAIT cDesc.keysMightBeDistributed;
IF ~cDesc.keysDistributed THEN GOTO Fail;
};
ENDCASE => GOTO Fail;
EXITS Fail => {
IF ~failOK THEN nb _ Request[cDesc, $failed, $error, "Could not encode encryption key"];
RETURN;
}; };
intervalSpec _ NEW[VoiceTemp.IntervalSpecBody _ intervalSpec^];
intervalSpec.keyIndex _ keyIndex;
intervalSpec.intID _ NewID[];
IF (nb_VoiceTempInterface[cDesc]) # $success THEN RETURN; -- sets interface & serviceID
nb _ info.voiceTemp.Play[info.shh, cDesc.situation.self, cDesc.voiceTempID, intervalSpec, queueIt];
started _ nb=$success;
IF ~started THEN RETURN;
cDesc.pendingIntervals _ NconcIntervals[cDesc.pendingIntervals, LIST[intervalSpec]];
};

RecordTune: PUBLIC ENTRY PROC [
convID: Thrush.ConversationID,
useIntervalSpec: VoiceTemp.IntervalSpec_NIL,
useKey: Thrush.EncryptionKey,
queueIt: BOOL_FALSE
]
RETURNS[
nb: NB,
intervalSpec: VoiceTemp.IntervalSpec_NIL,
key: Thrush.EncryptionKey_ Thrush.nullKey,
newConvID: Thrush.ConversationID_Thrush.nullConvID
] = {
cDesc: ConvDesc;
tuneID: VoiceTemp.TuneID;
[nb,cDesc]_VoiceConnect[convID];
IF nb#$success THEN RETURN; -- 
Complain?
newConvID _ cDesc.situation.self.convID;
intervalSpec _ NEW[VoiceTemp.IntervalSpecBody _ []];
IF useIntervalSpec#NIL THEN intervalSpec^ _ useIntervalSpec^;
intervalSpec.keyIndex _ 1;
intervalSpec.intID _ NewID[];
IF (nb_VoiceTempInterface[cDesc]) # $success THEN RETURN; -- sets interface & serviceID
[nb, tuneID] _ info.voiceTemp.Record[info.shh, cDesc.situation.self, cDesc.voiceTempID, intervalSpec, queueIt];
IF nb#$success THEN RETURN;
intervalSpec.tuneID _ tuneID;
cDesc.pendingIntervals _ NconcIntervals[cDesc.pendingIntervals, LIST[intervalSpec]];
WHILE cDesc.situation.self.state#idle AND
GList.Member[intervalSpec,cDesc.pendingIntervals] DO
WAIT info.stateChange;
ENDLOOP;
IF cDesc.keyTable=NIL THEN
[nb, cDesc.keyTable] _ ThParty.GetKeyTable[info.shh, cDesc.situation.self];
IF nb=$success THEN RETURN[nb, intervalSpec, cDesc.keyTable[1], newConvID];
};

StopTune: PUBLIC ENTRY PROC [convID: Thrush.ConversationID] = {
ENABLE UNWIND=>NULL;
cDesc: ConvDesc;
IF ([,cDesc]_VoiceConnect[convID]).nb#$success OR cDesc.situation.self.state#$active OR
VoiceTempInterface[cDesc] # $success THEN RETURN;
[] _ info.voiceTemp.Stop[info.shh, cDesc.situation.self, cDesc.voiceTempID];
};

DescribeInterval: PUBLIC ENTRY PROC [intervalSpec: VoiceTemp.IntervalSpec, minSilence: VoiceTemp.VoiceTime_1]
RETURNS[nb: NB, length: INT, intervals: VoiceTemp.IntervalSpecs] = {
ENABLE UNWIND=>NULL;
IF (nb_VoiceTempInterface[NIL]) # $success THEN RETURN;
[nb, length, intervals] _ info.voiceTemp.DescribeInterval[shhh: info.shh, targetInterval: intervalSpec, minSilence: minSilence, credentials: [], serviceID: nullID];
};

IdentifyVisitor: PUBLIC ENTRY PROC [visitor: Rope.ROPE] ~ {
nb: NB;
visitingPartyID: PartyID;
[nb, visitingPartyID] _ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:visitor];
IF nb#$success THEN RETURN;
nb _ ThParty.Visit[shh: info.shh, visitedParty: info.partyID, visitingParty: visitingPartyID];
IF nb#$success THEN RETURN;
info.visitors _ CONS[visitor, info.visitors];
};

ReleaseVisitor: PUBLIC ENTRY PROC [visitor: Rope.ROPE] ~ {
nb: NB;
found: BOOL_FALSE;
visitingPartyID: PartyID;
[nb, visitingPartyID] _ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:visitor];
FOR v: LIST OF Rope.ROPE _ info.visitors, v.rest WHILE v#NIL DO
IF v.first.Equal[visitor, FALSE] THEN { found_TRUE; info.visitors _ v.rest; }
ELSE IF v.rest#NIL AND v.rest.first.Equal[visitor, FALSE] THEN {
v.rest _ v.rest.rest; found_TRUE; };
ENDLOOP;
IF nb=$success AND found THEN
[] _ ThParty.Unvisit[shh: info.shh, visitingParty: visitingPartyID];
};


GetConv: PUBLIC PROC[convID: ConversationID, createOK: BOOL_FALSE]
RETURNS [ cDesc: ConvDesc_NIL ] = --INLINE-- {
IsConv: RefQ.MapType = {
cDesc _ NARROW[subqueue.first];
IF cDesc.situation.self.convID = convID THEN RETURN[TRUE];
};
IF convID#nullConvID AND RefQ.Map[info.conversations, IsConv] THEN RETURN;
IF ~createOK THEN RETURN;
cDesc _ NEW[FinchSmarts.ConvDescBody_[
situation: [ self: [ convID: convID, smartsID: info.smartsID, partyID: info.partyID ]]]];
TRUSTED { Process.SetTimeout[@cDesc.keysMightBeDistributed, pd.keyDistTicks]; };
info.conversations _ RefQ.Enqueue[info.conversations, cDesc];
};

FinchOn: INTERNAL PROC[convID: ConversationID_nullConvID] RETURNS [
on: BOOL_FALSE, cDesc: ConvDesc_NIL, state: StateInConv_$idle] = {
IF ~pd.finchOn OR info=NIL THEN {
VoiceUtils.Report["Your Finch is not running", $Finch]; RETURN; };
on_TRUE;
IF convID=nullConvID THEN RETURN;
cDesc _ GetConv[convID, FALSE];
IF cDesc#NIL THEN state_cDesc.situation.self.state;
};

NoteNewState: INTERNAL PROC[convEvent: Thrush.ConvEvent] RETURNS[cDesc: ConvDesc]= {
cInfo: ThParty.ConversationInfo;
nb: NB;
cDesc _ GetConv[convEvent.self.convID, TRUE];
cDesc.situation _ convEvent^;
[nb, cInfo] _ ThParty.GetConversationInfo[shh: info.shh, convID: convEvent.self.convID];
SELECT TRUE FROM
nb # $success => Problem["Can't obtain conversation information"];
cDesc.numParties#cInfo.numParties, cDesc.numActive#cInfo.numActive,
cDesc.numIdle#cInfo.numIdle => {
cDesc.subject _ cInfo.subject;
cDesc.startTime _ cInfo.startTime;
cDesc.numParties _ cInfo.numParties;
cDesc.numActive _ cInfo.numActive;
cDesc.numIdle _ cInfo.numIdle;
[nb, cDesc.partyInfo] _
ThParty.GetPartyInfo[shh: info.shh, credentials: cDesc.situation.self,
nameReq: $description, allParties: TRUE];
IF nb#$success THEN Problem["Can't obtain conversation information", nb]
ELSE IF cDesc.numParties>=1 THEN
cDesc.whoOriginated _
IF cDesc.partyInfo[0].partyID=cInfo.originator THEN $us ELSE $them;
};
ENDCASE;
SELECT cDesc.situation.self.state FROM
$idle, $neverWas => info.conversations _ RefQ.Dequeue[info.conversations, cDesc];
$notified => SELECT filtering FROM -- 
Needs tests for calls already in progress. 
1 => []_Request[cDesc, $idle, $notImportantEnough, "This is a test"];
2 => []_Request[cDesc, $ringing];
3 => []_Request[cDesc, $active, $whatever, "Hot line!"];
ENDCASE;
ENDCASE => cDesc.ultimateState _ cDesc.situation.self.state;
info.ReportConversationState[$success, cDesc, NIL];
BROADCAST info.stateChange;
};

Request: INTERNAL PROC[
cDesc: ConvDesc,
state: StateInConv,
reason: Thrush.Reason_NIL,
comment: ROPE_NIL
]
RETURNS [nb: NB] = {
DO
convEvent: Thrush.ConvEvent;
reportToAll: BOOL = SELECT state FROM
$idle, $active, $inactive, $ringing => TRUE, ENDCASE=>FALSE;
[nb, convEvent] _
ThParty.Advance[shhh: info.shh, credentials: cDesc.situation.self, state: state,
reportToAll: reportToAll, reason: reason, comment: comment];
SELECT nb FROM
$success => []_NoteNewState[convEvent];
$stateMismatch => {
cDesc_NoteNewState[convEvent];
IF state=$idle AND cDesc.situation.self.state # $idle THEN LOOP;
};
ENDCASE => -- 
Some cases are fatal, requiring re-registration! --
info.ReportConversationState[nb, cDesc, "Telephone server action failed"];
EXIT;
ENDLOOP;
};

Connect: INTERNAL PROC [calledPartyID: PartyID, convID: ConversationID_nullConvID, reason: Thrush.Reason _ NIL, comment: ROPE_NIL]
RETURNS [ nb: NB_$success, cDesc: ConvDesc_NIL ] = {
state: StateInConv;
newState: StateInConv =IF reason=NIL THEN $initiating ELSE $failed;
convEvent: Thrush.ConvEvent;
IF ~(([,cDesc, state]_FinchOn[convID]).on) THEN { nb _ $finchInactive; RETURN; }; --

SELECT state FROM
$idle => {
[nb, convEvent] _ ThParty.CreateConversation[
shhh: info.shh,
credentials: [partyID: info.partyID, smartsID: info.smartsID],
state: newState,
reason: reason,
comment: comment
];
IF nb = $success THEN cDesc _ NoteNewState[convEvent];
};
$reserved, $parsing => nb _ Request[cDesc, newState, reason, comment];
ENDCASE => {
info.ReportConversationState[$convStillActive, NIL, "Conversation already in progress"];
RETURN;
};
IF nb # $success OR newState=$failed THEN RETURN;
cDesc.originatorRecorded _ TRUE;
nb_ThParty.Alert[shhh: info.shh,
credentials: cDesc.situation.self, calledPartyID: calledPartyID];
SELECT nb FROM
$success => NULL;
$stateMismatch => {
nb_Request[cDesc, $failed, $error, "Conversation already in progress"];
RETURN;
};
ENDCASE => {
-- 
Do something interesting  see other smarts for more confusion -- ERROR; };
};

WaitForActive: INTERNAL PROC[cDesc: ConvDesc] RETURNS [nb: NB_$success] = {
FOR i: NAT IN [0..pd.waitsForConnect) DO
TRUSTED { Process.SetTimeout[@info.stateChange, pd.noJayTicks]; };
WAIT info.stateChange; -- <<The supervisor condition vbl; will this work?>>
SELECT cDesc.situation.self.state FROM
$active => RETURN;
$idle, $neverWas, $failed => EXIT;
ENDCASE;
ENDLOOP;
nb_Request[cDesc, $failed, $error, "Finch failed to connect to voice service."];
IF nb=$success THEN nb_$timedOut;
};

VoiceConnect: INTERNAL PROC[convID: ConversationID_nullConvID] RETURNS [
nb: NB_$success,
cDesc: ConvDesc_NIL,
state: StateInConv_idle
] = {
calledPartyID: PartyID;
IF NOT (([,cDesc, state]_FinchOn[convID]).on) THEN {
Problem["Your Finch is not running"]; RETURN; };
IF cDesc=NIL THEN [convID, cDesc, state] _ GetActiveConversation[]; -- 
Hack
SELECT state FROM
idle, reserved => {
[nb, calledPartyID] _ ThParty.GetParty[shh: info.shh, partyID: info.partyID, rName: "recording", type: $service];
IF nb=$success THEN [nb, cDesc] _ Connect[calledPartyID, convID, NIL, NIL]
};
ENDCASE;
IF nb=$success THEN nb _ WaitForActive[cDesc];
};

GetActiveConversation: PROC
RETURNS[convID: ConversationID_Thrush.nullConvID, cDesc: ConvDesc_NIL, state: StateInConv_$idle] = {
FOR convs: LIST OF REF _ info.conversations, convs.rest WHILE convs#NIL DO
cDesc _ NARROW[convs.first];
IF cDesc.situation.self.state > Thrush.notReallyInConv THEN {
convID _ cDesc.situation.self.convID; state _ cDesc.situation.self.state; RETURN; }
ENDLOOP;
};

Problem: PROC[remark: ROPE_NIL, nb: NB_NIL] = {
IF nb=NIL THEN VoiceUtils.Problem[remark, $Finch]
ELSE VoiceUtils.ProblemFR["%g, reason: %g", $Finch, NIL, rope[remark], atom[nb]];
};

VoiceTempInterface: PROC[cDesc: ConvDesc] RETURNS [nb: NB_$success] = {
partyID: Thrush.PartyID_Thrush.nullID;
interfaceSpec: Thrush.InterfaceSpec;
credentials: Thrush.Credentials;
IF cDesc#NIL THEN {
IF cDesc.voiceTempID#nullID THEN RETURN;
credentials _ cDesc.situation.self;
IF cDesc.numParties>1 THEN partyID _ cDesc.partyInfo[1].partyID;
}
ELSE {
IF info.voiceTemp#NIL THEN RETURN; -- want interface only
credentials _ [info.partyID, info.smartsID];
[nb, partyID] _ThParty.GetParty[
shh: info.shh, partyID: info.partyID, rName: "recording", type: $service];
IF nb#$success THEN RETURN;
};
IF partyID = Thrush.nullID THEN RETURN[$noSuchParty2];
[nb, interfaceSpec] _ ThParty.LookupServiceInterface[
info.shh, credentials, partyID, "VoiceTemp"];
IF nb#$success THEN RETURN;
info.voiceTemp _ VoiceTempRpcControl.ImportNewInterface[
interfaceName: interfaceSpec.interfaceName,
hostHint: interfaceSpec.hostHint!RPC.ImportFailed => CONTINUE
];
IF info.voiceTemp=NIL THEN RETURN[$noVoiceTempInterface];
IF cDesc#NIL THEN cDesc.voiceTempID _ interfaceSpec.serviceID;
};

NewID: PROC RETURNS[LONG CARDINAL] ={RETURN[LOOPHOLE[PupSocket.GetUniqueID[]]]};


InitFinchSmarts: PUBLIC PROC [
thrushInstance: Thrush.ROPE_NIL,
ReportSystemState: PROC[ on: BOOL ],
ReportConversationState: PROC[ nb: NB, cDesc: ConvDesc, remark: Rope.ROPE ],
ReportRequestState: PROC[ actionReport: Thrush.ActionReport, actionRequest: REF ]
] = {
problem: ROPE_NIL; nb: NB; {
ENABLE RPC.CallFailed => { problem _ "Communication Failure"; GOTO InitFailed; };
credentials: Thrush.Credentials;
thVR: RPC.VersionRange = ThVersions.GetThrushVR;
problem: Thrush.ROPE _ NIL;
namesGVInstance: Thrush.ROPE_NIL;
hostHint: VoiceUtils.NetAddress;

UninitFinchSmarts[NIL];

info _ NEW[FinchSmarts.FinchInfoBody]; -- Dump any old one!
info.conversations _ NIL;
info.ReportSystemState_ReportSystemState;
info.ReportConversationState_ReportConversationState;
info.ReportRequestState_ReportRequestState;
thrushInstance _ VoiceUtils.MakeRName[style: rName, name:
IF thrushInstance#NIL THEN thrushInstance
ELSE UserProfile.Token[key: "ThrushClientServerInstance", default: "Strowger.Lark"]];
info.myName _ [
type: "ThSmarts.Lark",
instance: VoiceUtils.InstanceFromNetAddress[netAddress: VoiceUtils.OwnNetAddress[], suffix: "0"],
version: ThVersions.FinchVR];
info.myRName _ VoiceUtils.CurrentRName[];
info.myPassword _ VoiceUtils.CurrentPasskey[];
ThSmartsRpcControl.ExportInterface[
interfaceName: info.myName,
user: info.myRName,
password: info.myPassword];
pd.smartsIsExported_TRUE;

namesGVInstance _ UserProfile.Token[key: "NamesGVInstance", default: "Strowger.lark"];
IF ~(PrincOpsUtils.IsBound[LOOPHOLE[NamesGVImpExp.GVImport]] AND NamesGVImpExp.GVImport[namesGVInstance]) THEN {
problem _ "Couldn't import Grapevine Package"; GOTO InitFailed; };

info.shh _ IF NOT pd.encryptionRequested THEN Thrush.unencrypted
ELSE NamesRPC.StartConversation [
caller: info.myRName,
callee: thrushInstance,
key:	info.myPassword,
level:	--<<ECB>>--CBCCheck !
RPC.AuthenticateFailed=> { problem_"Could not authenticate"; GOTO InitFailed}];

hostHint _
VoiceUtils.NetAddressFromRope[NamesGV.GVGetAttribute[thrushInstance, $connect, NIL]];

ThPartyRpcControl.ImportInterface[
interfaceName: [type: "ThParty.Lark", instance: thrushInstance, version: thVR],
hostHint: hostHint! RPC.ImportFailed=> {
IF why=wrongVersion THEN
problem _ IO.PutFR["Finch version %d too old; import failed",
card[ThVersions.FinchVersion]];
GOTO InitFailed;
}];
pd.interfacesAreImported_TRUE;

[nb, credentials]_ThParty.Register[
shh: info.shh,
rName: info.myRName,
type: $individual,
interface: info.myName,
properties: [$controller, VoiceUtils.OwnNetAddress[]]
];
IF nb=$success THEN nb _ ThParty.Enable[shh: info.shh, smartsID: credentials.smartsID];
IF nb#$success THEN {
problem_"Can't register with server"; GOTO InitFailed; };
info.smartsID _ credentials.smartsID;
info.partyID _ credentials.partyID;
pd.finchOn_TRUE;
info.ReportSystemState[pd.finchOn];
EXITS
InitFailed => UninitFinchSmarts[problem, nb];
};};

UninitFinchSmarts: PUBLIC PROC[problem: ROPE_NIL, nb: NB_NIL] = {
ENABLE RPC.CallFailed => GOTO Failed;
IF problem#NIL THEN Problem[problem, nb];
 IF info#NIL THEN {
IF pd.finchOn AND info.partyID#nullID AND info.smartsID#nullID THEN
[-- 
nb --]_ThParty.Deregister[info.shh, info.smartsID!RPC.CallFailed=>CONTINUE];
info.shh_none;
info.ReportSystemState[FALSE];
{
ClearConvs: RefQ.MapType = {
cDesc: ConvDesc=NARROW[subqueue.first];
cDesc.clientData _ NIL;
};
[]_RefQ.Map[info.conversations, ClearConvs];
info.conversations _ NIL;
};
};
pd.finchOn_FALSE;
IF PrincOpsUtils.IsBound[LOOPHOLE[NamesGVImpExp.UnGVImport]] THEN
NamesGVImpExp.UnGVImport[];
pd.interfacesAreImported_FALSE;
IF pd.smartsIsExported THEN
ThSmartsRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
pd.smartsIsExported_FALSE;
EXITS
Failed => pd.interfacesAreImported _ pd.smartsIsExported _ FALSE;
};

FinchIsRunning: PUBLIC PROC RETURNS [finchIsRunning: BOOL] = { RETURN[pd.finchOn]; }; 

ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[pd, "Finch PD"];
};

SetFiltering: PROC[which: INT, deferAnswer: ROPE_ "true"] _ {
filtering _ which;
NamesGV.GVSetAttribute[
VoiceUtils.MakeRName[VoiceUtils.CurrentRName[]], $deferanswer, deferAnswer];
};
filtering: INT_0;

FilterResetCmd: Commander.CommandProc = TRUSTED {
SetFiltering[0, "false"];
};

FilterZeroCmd: Commander.CommandProc = TRUSTED {
SetFiltering[0];
};

FilterOneCmd: Commander.CommandProc = TRUSTED {
SetFiltering[1];
};

FilterTwoCmd: Commander.CommandProc = TRUSTED {
SetFiltering[2];
};

FilterThreeCmd: Commander.CommandProc = TRUSTED {
SetFiltering[3];
};
Commander.Register["VuFinch", ViewCmd, "Program Management variables Finch"];
Commander.Register["FReset", FilterResetCmd, "Reset filtration method.  This is a test."];
Commander.Register["F0", FilterZeroCmd, "Zeroth filtration method.  This is a test."];
Commander.Register["F1", FilterOneCmd, "First filtration method.  This is a test."];
Commander.Register["F2", FilterTwoCmd, "Second filtration method.  This is a test."];
Commander.Register["F3", FilterThreeCmd, "Third filtration method.  This is a test."];
FinchSmarts.Register[NEW[FinchSmarts.ProcsRecord _ [
playbackTune: PlaybackTune,
recordTune: RecordTune,
stopTune: StopTune,
describeInterval: DescribeInterval,
finchIsRunning: FinchIsRunning
]]];
}.

FinchSmartsImpl.mesa
Copyright c 1984, 1986 by Xerox Corporation.  All rights reserved.
Last Edited by: Swinehart, August 14, 1986 11:32:31 pm PDT
Polle Zellweger (PTZ) October 24, 1985 4:55:57 pm PDT
Declarations
Supervision

Some party has changed state in a conversation we know about (or should).
Two cases:
Our party has changed state in a conversation, whether or not we're going to deal with it (at present, LarkSmarts makes all such decisions)
Another party changed state in a conversation we know about (at present, we don't need to know that; again, LarkSmarts does all the work.)  That case is filtered out in Progress, above.
It is our duty to obtain all relevant information about the call when the information becomes available, and to notify any Finch Clients.
One party has replaced another (they were or are now in a poacher/poachee relationship) in this conversation, so we need to update our information about the conversation.  Same as Progress, except that we clear any indication that we know anything about the present state before noting the new state.

If this notice indicates that our own party is the oldPartyID, we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation.  We should also pull the conv. from our active list.  This happens when the same user logs in and runs Finch somewhere else.
Throw away pending intervals that are complete.  This includes intervals preceding the one being reported on.
Client Functions



A quandary.  I hate these things that wait until something else has happened.  Would rather queue up later tasks to do and return.  But haven't come up with a general method yet.  The problem here is that we don't want to schedule new voice until the encryption keys for it have been distributed.  The Register key function will tell everybody about the keys and then tell us that it's told everybody.  We wait one time around a timeout for a special condition variable (ugh) and then give up. 
$stateMismatch => ???;
Don't unvisit unless visitor is in your list.  This isn't good enough.
Utilities
New conversation
Now gather up additional information that we might not know yet:
Who started this?
Who the other party(s) is (are)
State information guaranteed correct only as of last time one of these numbers changed.

If we've been called due to a Substitution that's kicking us out (cf Subst.), we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation.  We should also do a Dequeue as above. 

Real confused about Problem (typeout only) reporting vs. client reporting.  The responsibilities are unconvincingly distributed among Smarts and client.
If there's a reason, the connect request's only purpose is to record an error condition, audibly as well as visually.  This requires the creation of a conversation, then its immediate termination.

Some smarts don't do this.  They probably should.
For use in Recording, and so on, where client needs to wait for setup.
Hack.  Won't work when lots of conversations are the norm
Registration
info.requests _ MBQueue.Create[];
For the purpose of importing NamesGV, use prior binding of serverInstance if there is one and the server name is the same as before.

ThParty.ConversationsForParty[shh: info.shh, partyID: partyID];
Debugging nonsense

Registration for use by arms-length systems
textToSpeech: TextToSpeech,
registerTranslateProc: RegisterTranslateProc,
stopSpeech: StopSpeech,
Swinehart, May 22, 1985 1:08:51 pm PDT
Changes to GetParty.
changes to: JayConnection
Polle Zellweger (PTZ) July 13, 1985 5:20:26 pm PDT
adding Text-to-Speech server
changes to: DIRECTORY, ProseSpec, ProseSpecs, stopIntervalSpec (was stopSpec), stopProseSpec, Progress, Supervise, DisconnectCall, PlaceCall, StopSpeech, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, EnqueueProses, Complain, Connect, ProseConnection
Swinehart, August 6, 1985 5:43:08 pm PDT
Merge PTZ prose changes
changes to: DIRECTORY, NB, PD, stopIntervalSpec, stopProseSpec, Report, Progress, Supervise, DisconnectCall, PlaceCall, StopTune, NoiseSpec, PlaybackTune, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, CompareIntID, EnqueueProses, Complain, Connect, JayConnection, ProseConnection, RepRet, FinchSmarts
Polle Zellweger (PTZ) August 19, 1985 4:16:40 pm PDT
Meter text in TextToSpeech so as to avoid sending large ropes all at once.  Allows speech to begin sooner and flush faster. Also flushing changes.
changes to: FinchInfo, PD, Supervise, TextToSpeech, StopSpeech, ReportProses (comments only)
Polle Zellweger (PTZ) September 3, 1985 6:28:29 pm PDT
Allow registration of defaultTranslateProc.
changes to: Supervise, defaultTranslateProc, RegisterTranslateProc, TextToSpeech, FinchSmarts
Swinehart, September 16, 1985 10:00:59 am PDT
If Finch has never been initialized, info is NIL -- don't let that bother you.
changes to: GetRname, PlayNoise, FinchOn

Polle Zellweger (PTZ) October 22, 1985 5:10:44 pm PDT
changes to: Progress (add prose debugging reports), TextToSpeech (report connection failure), ReportProses (fix debugging reports), JayConnection (report connection failure), ProseConnection (report connection failure)
Polle Zellweger (PTZ) October 24, 1985 4:53:21 pm PDT
Move bluejayConnection and proseConnection from FinchInfo to ConvDesc.
changes to: Supervise, DisconnectCall, InitFinchSmarts, Connect, JayConnection, ProseConnection
Swinehart, October 28, 1985 12:31:20 pm PST
Merge Above changes with other other minor changes (RefQ and the like)
changes to: DIRECTORY, FinchSmartsImpl, Progress, Supervise, DisconnectCall, TextToSpeech, InitFinchSmarts, UninitFinchSmarts, IsConv, GetConv, IsConv (local of GetConvDesc), GetConvDesc, ReportProses, FinchOn, Connect, JayConnection, ProseConnection, PlaybackTune, ClearConvs (local of UninitFinchSmarts)

Swinehart, December 13, 1985 2:52:25 pm PST
Massive change to new Thrush, leaving out proses and intervals for the moment.
changes to: ConversationHandle, FinchInfo, Progress, Supervise, DisconnectCall, AnswerCall, PlaceCall, Apprise, Complain, Connect, Problem, FinchSmarts, Progress, QdProgress

Swinehart, December 17, 1985 10:05:46 am PST
Major revision for new Thrush.  Removed all Prose and Bluejay stuff temporarily
changes to: QdProgress, NoteNewState, PutFTime, Connect, Problem, Progress, Other, Supervise

Swinehart, May 19, 1986 12:22:17 pm PDT
Cedar 6.1
changes to: DIRECTORY, SHHH
Swinehart, June 1, 1986 7:48:10 pm PDT
Add ReportAction, eliminate the MBQueueing of ThParty-provoked actions.  Others remain, but should go.
changes to: Progress, Substitution, ReportAction

Κ“˜Jš
œ™šœ
Οm
œ7™BJš
œ:™:Icodeš
œ5™5—J˜š
Οk	˜	Jšœ
žœ˜*Jš
œ˜Jšœžœ˜Jšžœ
˜Jšœžœ˜6Jšœžœ˜%Jšœžœ$˜1Jšœžœ˜-Jšœ	žœ˜%J˜J˜Jšœžœ
˜ Jšœžœ'˜4Jšœ
žœ˜ Jšœžœžœ˜Jšœžœ+˜5Jš
œ˜Jšžœ
žœO˜XJšœžœΫ
˜θ
Jš
œ˜šœžœ
˜
JšœTžœGžœžœ'˜Ξ
—J˜	Jš
œ˜J˜8Jšœžœ
˜Jš
œa˜aJš
œW˜WJšœžœ
˜Ÿ
J˜
J˜—šœžœ
ž˜Jšžœžœ
žœj˜’Jšžœ˜!Jšžœ
žœ
˜J˜—™J˜Jšœ
žœ˜&šœžœ˜-J˜/—Jšœžœ˜(Jšžœžœ
žœ
˜Jšœžœ˜J˜!Jšœ	žœ˜Jšžœžœ
žœ
˜Jšžœžœ
žœ
˜Jšœ
žœ˜!Jšœ
žœ˜'J˜šžœžœžœ˜Jšœžœ
žœ
˜Jšœžœ
žœ
˜Jšœžœ˜Jšœžœ˜Jš
œ6˜6J˜9Jšœžœ
žœ
˜"Jšœžœ
žœ
˜%Jšœžœ
žœ
˜ Jšœžœ˜Jšœ	žœ
žœ
˜Jšœ	žœ
ž˜Jšœžœ˜J˜—J˜Jš
œ˜Jš	œžœ
žœžœ
žœ˜J˜šΟnœžœžœ˜Jšžœ
žœžœ
žœ
˜ J˜ J˜—J˜šŸœžœžœžœ˜ Jšžœ
žœžœ
žœ
˜Jšœžœ˜J˜J˜—šŸœžœ"žœžœžœ
žœ˜Š
J˜——™J™šŸœžœ
žœ
žœ
˜Jšœžœ
˜
Jš
œ˜Jš
œ˜Kšžœ
žœžœΟc˜-J™I™
J™‹
J™Ή
J™‰
—Jšžœ2žœ˜VJ˜J˜—šŸœžœ
žœ
žœ
˜ Jšœžœ
˜
Jš
œ˜J˜J˜Jš
œ˜Kšžœ
žœžœ ˜-J™¬J™΅Jšœ1žœ˜8Jšžœžœ
žœ *˜RJš
œ˜J˜J˜—šŸœžœ
žœ
žœ
˜ Jšœžœ
˜
Jš
œ˜Jš
œ˜Kšžœ
žœžœ
˜Kšœ	žœ
˜
Kšœ.žœ˜5Kšžœžœ
žœ2žœ˜Mšžœž˜Kšœž	œ7žœžœ˜fšœ "˜=šžœAžœžœ
ž˜TKšžœ!žœ
žœ
˜-K˜šžœž˜K™mKšœ:žœ
˜B—Kšžœ
˜Kšžœ
˜—K˜—Kšžœ $˜9—Kšžœžœ
žœ
žœ
˜+Jšžœžœ
žœžœ˜>Jš
œ)˜)Jšž	œ  œ
˜=Jš
œ˜J˜——™J™Jšœ
žœžœ (˜Kšœžœžœ˜Jš
œ˜J˜%Jšœžœ
˜Jšœ	žœ
ž˜J˜J˜—šŸœžœ
žœ
žœ
˜"Jš
œ˜J˜%Jšœ	žœ
žœ˜Kšžœ
žœžœ ˜-J˜$Jšžœ
žœ'žœ
žœ
˜9šžœž˜š
œ˜Jšœ-žœ#˜SJ˜—Jšžœ*˜5—J˜J˜—šŸ
œžœ
žœ
žœ#˜@Kšžœ
žœžœ ˜-J˜$Jš
œ ˜ Jšžœžœ2žœ
˜MJš
œ˜J˜—šŸ	œžœ
žœ
žœ˜Jš
œ)˜)Jšœžœ ˜$Jšœžœ ˜-Jšœžœ
ž˜Jš
œ˜šžœ˜Jšžœžœ ˜$Jšžœ?žœ˜NJš
œ˜—Jš
œ˜Jšœžœ
˜Jš
œ"˜"Jšœžœžœ
˜šžœžœ˜Jš
œW˜WJšžœžœ0žœžœ
˜LJ˜—šžœžœž˜'Jš
œ1˜1Jš
œO˜O—šžœž˜Jšœžœ ˜6Jšœžœ "˜9Jš
œR˜RJšžœ'žœžœžœ˜C—JšœΟt
œ	‘
œ4˜BJš
œ˜J˜—š
Ÿœžœ
žœ
žœ%žœ˜EJš
œ˜Jšœžœ
˜J˜Jšžœ
žœ'žœžœ˜Wšžœ
žœžœ
žœ˜1šžœžœ@˜ZJš
œG˜G—Jšžœ˜šžœ
ž˜š
œ<˜<J˜5Jšœ+žœž˜GJ˜——J˜—šžœ
žœ˜1Jš
œ/˜/Jš
œ-˜-J˜SJšœžœ˜1J˜—Jšžœžœ<‘
œ
˜SJš
œ˜J™—šŸœžœ˜!Jš
œ˜Jš
œ%˜%J˜Jšœ	žœ
ž˜Jšœžœ
žœ
 D˜WJšœžœžœ
žœ; ˜lJšžœ
žœžœ
˜J˜Jšœžœ
˜Jš
œ˜šžœ+žœ˜3Jšœ-žœžœ ˜U—Jš
œ ˜ Jš
žœ
žœ
žœ Πct
 	’
˜*J˜(š
œ%˜%JšœKžœ˜Q—šΟb
žœž˜Jšœžœ
˜šœž
˜
Jš‘
œξ‘
™πJšœžœ
˜Jšžœ˜"Jšžœžœ
žœ˜)J˜—Jšœžœ
™Jšžœžœ˜šžœ
˜Jšžœ	žœI˜XJšžœ
˜Jšœ£˜——Jšœžœ-˜?J˜!Jš
œ˜Jšžœ+žœ
žœ ˜WJšœ‘P˜cJ˜Jšžœ
žœ
žœ
˜Jšœ@žœ˜TJ˜J˜—šŸ
œžœ
žœ
žœ˜Jš
œ˜Jšœ(žœ
˜,Jš
œ˜Jšœ	žœ
ž˜Jš
œ
˜
Jšžœ
˜Jšœžœ
˜Jšœ%žœ
˜)Jš
œ*˜*Jš
œ2˜2J˜J˜Jš
œ˜Jš
œ ˜ Jš
žœ
žœ
žœ ’
 	’
˜*J˜(Jšœžœ"˜4Jšžœžœ
žœ"˜=Jš
œ˜Jš
œ˜Jšžœ+žœ
žœ ˜WJšœ‘R˜oJšžœ
žœ
žœ
˜J˜Jšœ@žœ˜Tšžœ!ž˜)Jšœ2ž˜4Jšžœ˜Jšžœ
˜—šžœžœ
ž˜Jš
œK˜K—Jšžœ
žœ
žœ1˜KJ˜J˜—šŸœžœ
žœ
žœ$˜?Jšžœ
žœžœ
˜J˜šžœ-žœ$ž˜WJšœ%žœ
žœ
˜1—Jšœ‘9˜LJš
œ˜J˜—šŸœžœ
žœ
žœJ˜mJšžœžœ
žœ)˜DJšžœ
žœžœ
˜Jšžœžœžœ
žœ
˜7Jšœ(‘
œ‘k˜€
Jš
œ˜J˜—šŸœžœžœ˜;Kšœžœ
˜K˜Kš
œ[˜[Kšžœ
žœ
žœ
˜Kš
œ^˜^Kšžœ
žœ
žœ
˜Kšœžœ˜-K˜K˜—šŸœžœžœ˜:K™FKšœžœ
˜Kšœžœ
žœ
˜K˜Kš
œ[˜[š
žœžœ
žœžœžœžœ
ž˜?Kšžœžœžœ	žœ˜Mšžœ
žœžœ
žœžœžœ˜@Kšœžœ˜$—Kšžœ
˜—šžœ
žœž˜Kš
œD˜D—K˜—J˜—™	J˜š
Ÿœžœ
žœ#žœ
žœ
˜BJšžœžœ 
œ˜.šŸœ˜Jšœžœ˜Jšžœ&žœ
žœ
žœ˜:Jš
œ˜—Jšžœžœ&žœ
žœ
˜JJšžœžœ
žœ
˜Jš
œ™šœžœ˜&Jš
œY˜Y—JšžœI˜PJš
œ=˜=J˜J˜—šŸœžœ
žœ$žœ˜CJšœžœ
žœžœ˜Bšžœ
žœžœ
žœ˜!Jšœ8žœ˜B—Jšœžœ
˜Jšžœžœ
žœ
˜!Jšœžœ˜Jšžœžœ
žœ"˜3J˜J˜—šŸœžœ
žœžœ˜TJ˜ Jšœžœ
˜Jšœ'žœ˜-J˜Jš
œX˜X™@J™J™—šžœ
žœ
ž˜J˜Bš
œd˜dK™WJ˜J˜"Jš
œ$˜$Jš
œ"˜"Jš
œ˜š
œ˜š
œF˜FJšœ#žœ˜)——Jšžœ
žœ5˜Hšžœ
žœž˜ š
œ˜Jšžœ-žœžœ˜C——J˜—Jšžœ
˜—šžœž˜&Jš
œQ˜Qš	œ
žœžœ
 ’
 +’
˜SJ˜EJ˜!J˜8Jšžœ
˜—Jšžœ5˜<—J™ο
Jšœ.žœ˜3Jšž	œ˜J˜—J˜šŸœžœ
žœ
˜J˜J˜Jšœžœ
˜Jšœ	žœ
ž˜J˜
Jšžœžœ˜š
ž˜J˜šœ
žœžœž˜%Jšœ'žœžœžœ
˜<—š
œ˜Jš
œP˜PJš
œ<˜<—šžœž˜Jš
œ'˜'š
œ˜Jš
œ˜Jšžœ
žœ$žœ
žœ
˜@Jš
œ˜—šžœ 8˜CJš
œJ˜JJ™š
——Jšžœ
˜Jšžœ
˜—J˜J˜—šŸœžœ
žœUžœžœ
žœ
˜‚
Jšžœžœžœ˜4J™Δ
Jš
œ˜Jš	œžœžœ
žœ
žœ	˜CJ˜Jšžœ)žœžœ‘˜Všžœž˜š
œ
˜
˜-J˜J˜>Jš
œ˜J˜J˜J˜—Jšžœžœ!˜6J˜—Jš
œF˜Fšžœ˜Jšœ/žœ&˜XJšžœ
˜Jš
œ˜——Jšžœžœžœ
žœ
˜1Jšœžœ
˜ ˜ J˜A—šžœž˜Jšœžœ
˜š
œ˜š
œG˜GJ™3—Jšžœ
˜Jš
œ˜—šžœ˜Jš Fœ
žœ˜P——J˜J˜—š
Ÿ
œžœ
žœžœžœ˜KJ™Fšžœžœ
žœž˜(Jšžœ;˜BJšžœ 4˜Kšžœž˜&Jšœžœ
˜Jšœžœ
˜"Jšžœ
˜—Jšžœ
˜—J˜PJšžœ
žœ˜!Jš
œ˜J˜—šŸœžœ
žœ$žœ˜HJšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜J˜šžœ
žœ'žœ˜4Jšœ&žœ˜0—Jš
žœžœ
žœ3 ’
 ’
˜Mšžœž˜š
œ˜Jš
œq˜qJšžœ
žœ.žœžœ
˜JJ˜—Jšžœ
˜—Jšžœ
žœ˜.Jš
œ˜J˜—šŸœž˜Jšžœ;žœ˜dJ™9š
žœžœ
žœ
žœ"žœžœ
ž˜JJšœžœ˜šžœ5žœ˜=JšœJžœ˜S—Jšžœ
˜—J˜J˜—šŸœžœ	žœ
žœžœ
žœ˜/šžœžœ
žœ#˜1Jšžœ0žœ˜Q—Jš
œ˜J˜—šŸœžœžœžœ˜GJ˜&J˜$J˜ šžœžœ
žœ
ž
˜Jšžœžœ
ž˜(J˜#Jšžœžœ&˜@J˜
—šžœ
ž
˜Jš	žœžœ
žœ
žœ ˜9J˜,š
œ ˜ Jš
œJ˜J—Jšžœ
žœ
ž˜J˜—Jšžœžœ
žœ˜6š
œ5˜5Jš
œ-˜-—Jšžœ
žœ
žœ
˜š
œ8˜8J˜+Jšœ!žœž˜=J˜—Jšžœžœ
žœ
žœ˜9Jšžœžœ
žœ-˜>J˜J˜—šŸœžœ
žœ
žœ
žœžœ
žœ˜PJ˜——™J˜šŸœžœ
žœ˜Jšœžœ
žœ
˜ JšŸœžœžœ˜$JšŸœžœžœ žœ˜LJšŸœžœ4žœ˜QJš
œ˜Jšœ	žœ
žœžœ˜Jšžœ
žœ4žœ˜QJ˜ J˜0Jšœžœžœ
˜Jšœžœ
žœ
˜!J˜ J˜Jšœžœ˜J˜Jšœžœ ˜;J™!Jšœžœ
˜Jš
œ)˜)Jš
œ5˜5Jš
œ+˜+š
œ9˜9Jšžœžœ
žœ˜)JšžœQ˜U—š
œ˜J˜J˜—Jš
œ)˜)Jš
œ.˜.˜#J˜Jš
œ˜Jš
œ˜—šœžœ
˜J˜—J™„
J˜Všžœžœžœ)žœ˜pJšœ/žœ˜B—J˜Jšœžœ
žœžœ˜@šžœ˜!Jš
œ˜Jš
œ˜Jš
œ˜Jšœ œ
˜Jšžœ:žœ˜OJ˜—š
œ
˜
JšœOžœ˜U—J˜˜"Jš
œO˜Ošœ 
žœ˜(š
œ˜š
œ=˜=Jš
œ˜——Jšžœ˜Jš
œ˜——Jšœžœ
˜J˜š
œ#˜#Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ5˜5Jš
œ˜—Jšžœ
žœD˜Wšžœ
žœ˜Jšœ&žœ˜9—J˜%Jš
œ#˜#J™AJšœžœ
˜Jš
œ#˜#š
ž˜J˜-—J˜—J˜šŸœžœ
žœ
žœ
žœžœ
žœ˜AJšžœ
žœžœ˜%Jšžœ	žœ
žœ˜)šžœžœ
žœ˜šžœžœžœž˜CJšœ8žœ
žœ˜R—J˜Jšœžœ˜š
œ
˜
šŸ
œ˜Jšœžœ˜'Jšœžœ
˜Jš
œ˜—Jš
œ,˜,Jšœžœ
˜Jš
œ˜—J˜—Jšœžœ
˜šžœžœž˜AJš
œ˜—Jšœžœ
˜šžœž˜JšœBžœ˜L—Jšœžœ
˜š
ž˜Jšœ;žœ
˜A—˜J˜——š
Ÿœžœ
žœžœžœ˜VJ˜——™šœ!žœ˜*Jš
œ˜Jš
œ˜—J˜šŸœžœžœžœ
˜=J˜˜Jš
œL˜L—J˜—šœžœ˜J˜—šœ(žœ˜1Jš
œ˜Jš
œ˜J˜—šœ'žœ˜0J˜Jš
œ˜J˜—šœ&žœ˜/J˜Jš
œ˜—J˜šœ&žœ˜/J˜Jš
œ˜—J˜šœ(žœ˜1J˜Jš
œ˜—Jš
œM˜MJš
œZ˜ZJš
œV˜VJš
œT˜TJš
œU˜UJš
œV˜VJ™—™+šœžœ˜4J˜Jš
œ˜Jš
œ˜J˜#J™J™-J™Jš
œ˜J˜——J˜J˜™&K™KšœΟr
™—™2K™Kšœ€2œ€΄
™—™(K™Kšœ€¨™΄—™4Kšœ€œx™’
Kšœ€P™\—šœ€ ™6Kšœ€œ
™+Kšœ€Q™]—™-K™NKšœ€™(—K™š
œ5™5Kšœ€	œ€œ€œ€œ€œ™Ϊ
—š
œ5™5Kš
œF™FKšœ€S™_—™+K™FKšœ€Š
œ€gœ™±—K™™+K™NKšœ€‘
™­
—K™™,K™OKšœ€P™\—K™™'K™	Kšœ€™—™&K™fKšœ€$™0—K™—…—a>—η