DIRECTORY
Atom USING [ GetPName, MakeAtom ],
BasicTime USING [ GMT, Now, OutOfRange, Period, Update ],
Commander	USING [ CommandProc, Register ],
CommandTool USING [ NextArgument ],
IO,
LupineRuntime USING [ BindingError ],
MBQueue USING [ Create ],
NamesGV USING [ GVGetAttribute ],
NamesRPC USING [ StartConversation ],
Nice,
Pup USING [ nullAddress ],
PupSocket USING [ CreateEphemeral, GetLocalAddress, Socket ],
RefID USING [ ID, Release, Reseal, Seal ],
Rope USING [ Concat, Cat, Length, Substr ],
RPC USING [ AuthenticateFailed, EncryptionKey, ExportFailed, ImportFailed ],
ThNet USING [ CloseWhitePagesDatabase, HowToDial, InitWhitePagesDatabase, pd, WhitePagesEntry, WPListing, WPState ],
ThParty USING [ Credentials, NameReq, SmartsInterfaceName, SmartsInterfaceRecord, SmartsProperties ],
ThPartyPrivate USING [ AlertOne, DoAdvance, ConversationData, ConvState, GetConvState, MakeSubstitution, PartyBody, PartyData, SmartsBody, SmartsData, UnsealParty, UnsealSmarts ],
ThPartyRpcControl,
ThPartyMonitorImpl,
Thrush USING [
ConversationID, Credentials, NB, NetAddress, noAddress, notReallyInConv, nullID, PartyID, PartyType, ROPE, SHHH, SmartsID, unencrypted ],
ThSmartsRpcControl USING [ ImportNewInterface ],
ThVersions USING [ ThrushVR ],
Triples USING [ Any, Erase, Foreach, ForeachProc, Item, Make, Select ],
TU USING [ MakeUnique, RefAddr ],
VoiceUtils USING [ CmdOrToken, CurrentPasskey, InstanceFromNetAddress, MakeAtom, MakeRName, Registrize, RnameToRspec, FindWhere, Problem, RegisterWhereToReport, Report, ReportFR, WhereProc ]
;

ThPartyInitImpl: CEDAR MONITOR LOCKS root
IMPORTS Atom,
BasicTime,
Commander,
CommandTool,
IO,
LupineRuntime,
MBQueue,
NamesGV,
NamesRPC,
Nice,
PupSocket,
root: ThPartyMonitorImpl,
RefID,
Rope,
RPC,
SmartsRpc: ThSmartsRpcControl,
ThNet,
ThPartyPrivate,
ThPartyRpcControl,
ThVersions,
Triples,
TU,
VoiceUtils
EXPORTS ThParty, ThPartyPrivate
SHARES ThPartyMonitorImpl = {
OPEN IO, pd: ThNet.pd;

NB: TYPE = Thrush.NB;
PartyData: TYPE = ThPartyPrivate.PartyData;	-- REF Concrete
PartyID: TYPE = Thrush.PartyID;	-- ID
nullID: PartyID = Thrush.nullID;
ROPE: TYPE = Thrush.ROPE;
SmartsData: TYPE = ThPartyPrivate.SmartsData;	-- REF Concrete
SmartsID: TYPE = Thrush.SmartsID;	-- ID
SHHH: TYPE = Thrush.SHHH;
none: SHHH = Thrush.unencrypted;
Reseal: PROC[r: REF] RETURNS[RefID.ID] = INLINE {RETURN[RefID.Reseal[r]]; };
Any: Triples.Item = Triples.Any;

larkRegistry: ROPE=".Lark";

wpState: ThNet.WPState;


GetParty: PUBLIC ENTRY PROC[shh: SHHH_NIL, partyID: PartyID,
rName: Thrush.ROPE, type: Thrush.PartyType_NIL]
RETURNS [nb: NB, newPartyID: PartyID] = {
ENABLE UNWIND=>NULL;
newParty: PartyData;
[nb, newParty] _ GetActiveParty[partyID, rName, type];
newPartyID _ Reseal[newParty];
};

GetPartyFromFeepNum: PUBLIC ENTRY PROC[
shh: SHHH_none, partyID: PartyID, feepNum: Thrush.ROPE_NIL]
RETURNS [nb: NB_$success, newPartyID: PartyID_nullID] = {
ENABLE UNWIND=>NULL;
party: PartyData _ NIL;
rName: ROPE _ ThNet.WhitePagesEntry [
wpState: wpState, name: feepNum, feep: TRUE, key: $OfficeNumber].fullRName;
IF rName=NIL THEN RETURN[nb: $noSuchParty2];
[nb, party] _ GetActiveParty[partyID, rName, NIL];
newPartyID _ Reseal[party];
};

GetPartyFromNumber: PUBLIC ENTRY PROC[
shh: SHHH, partyID: PartyID, phoneNumber: Thrush.ROPE,
description: ROPE]
RETURNS [nb: NB, newPartyID: PartyID] = {
ENABLE UNWIND => NULL;
[nb, newPartyID] _ GetPartyFromNumberInt[partyID, phoneNumber, description, FALSE];
};

GetNumbersForRName: PUBLIC PROC[shh: SHHH_none, rName: Thrush.ROPE]
RETURNS [fullRName: ROPE, number: ROPE, homeNumber: ROPE] = {
listing: ThNet.WPListing;
[fullRName, number, listing] _ ThNet.WhitePagesEntry[
wpState: wpState, name: rName, key: $OfficeNumber];
IF listing#NIL THEN homeNumber _ ThNet.WhitePagesEntry[
wpState: wpState, key: $OutsideNumber, listing: listing].entry;
};
GetActiveParty: INTERNAL PROC[partyID: PartyID, rName: Thrush.ROPE,
type: Thrush.PartyType]
RETURNS [nb: NB_$success, newParty: PartyData_NIL] = {
party: PartyData _ ThPartyPrivate.UnsealParty[partyID];
[nb, newParty] _ GetActivePartyDo[party, rName, type];
IF nb = $success AND VoiceParty[newParty] = VoiceParty[party] THEN nb_$narcissism;
};
VoiceParty: INTERNAL PROC[party: PartyData] RETURNS [voiceParty: PartyData ] = {
IF party.type#$individual
OR (voiceParty _ NARROW[Triples.Select[$Poaching, party, -- poachee --]]) = NIL
THEN voiceParty _ party;
};

GetActivePartyDo: INTERNAL PROC[party: PartyData, rName: Thrush.ROPE,
type: Thrush.PartyType]
RETURNS [nb: NB_$success, newParty: PartyData_NIL] = {
number: ROPE;
listing: ThNet.WPListing;
wpRname: ROPE;
partyID: PartyID;
partyID _ Reseal[party];
IF rName=NIL THEN RETURN[$noIdentSupplied, NIL];
IF type = NIL THEN { -- request for $individual or $telephone
[nb, newParty] _ GetActiveParty[partyID, rName, $individual];
IF nb # $success THEN [nb, newParty] _ GetActiveParty[partyID, rName, $telephone];
RETURN;
};
SELECT type FROM
$service => { [nb, newParty] _ GetIdleParty[partyID, rName]; RETURN; };
$individual, $telephone => NULL; -- go on
$trunk => ERROR; -- until further notice
ENDCASE => ERROR;
newParty _ NARROW[
Triples.Select[type, VoiceUtils.MakeAtom[VoiceUtils.Registrize[rName]], --party-- ] ];
IF newParty#NIL AND newParty.enabled THEN {
SetPoaching[newParty];
RETURN;
};
IF type # $telephone THEN RETURN[nb: $noSuchParty2];
[wpRname, number, listing] _ ThNet.WhitePagesEntry [
wpState: wpState, name: rName, key: $OfficeNumber];
IF wpRname=NIL OR listing=NIL THEN RETURN[nb: $noSuchParty2];
IF number=NIL THEN number _ ThNet.WhitePagesEntry [
wpState: wpState, name: rName, key: $OutsideNumber, listing: listing].entry;
IF number=NIL THEN RETURN[nb: $noSuchParty2];
[nb, partyID] _ GetPartyFromNumberInt[Reseal[party], number, wpRname, TRUE];
IF nb=$success THEN newParty _ ThPartyPrivate.UnsealParty[partyID];
};

GetIdleParty: INTERNAL PROC[partyID: PartyID, serviceName: ROPE]
RETURNS [nb: NB, newParty: PartyData _ NIL] = {
ENABLE UNWIND=>NULL;
found: BOOL_FALSE;
now: BasicTime.GMT = BasicTime.Now[];
myName: ROPE;
party: PartyData_ ThPartyPrivate.UnsealParty[partyID];
serviceNameAtom: ATOM = MakeServiceRname[serviceName].serviceRnameAtom;
FindIdleParty: Triples.ForeachProc = {
newParty _ NARROW[trip.val];
IF newParty.numConvs#0 THEN RETURN;
IF newParty.numConvs=0 AND newParty.enabled AND
(newParty.reservedBy=Thrush.nullID OR
BasicTime.Period[from: newParty.reservationTime, to: now!
BasicTime.OutOfRange => CONTINUE] > pd.serviceGuaranteedReservationTime) THEN { found _ TRUE; RETURN[FALSE]; };
};
IF party = NIL THEN RETURN[nb: $noSuchParty];
[nb, myName,] _ GetRnameFromParty[party];
IF nb # $success THEN RETURN[nb: nb, newParty: NIL];
Triples.Foreach[$service, serviceNameAtom, Triples.Any--party--, FindIdleParty];
IF ~found THEN RETURN[nb: $noSuchParty2];
newParty.reservedBy _ partyID;
newParty.name _ myName;
newParty.reservationTime _ now;
};

ReleaseParty: PUBLIC ENTRY PROC[shh: SHHH_none, partyID: PartyID, targetPartyID: PartyID]
RETURNS [nb: NB_$success] = {
targetParty: PartyData _ ThPartyPrivate.UnsealParty[targetPartyID];
IF targetParty=NIL OR targetParty.reservedBy#partyID OR targetParty.type#$service
THEN RETURN;
targetParty.reservationTime _ BasicTime.Update[targetParty.reservationTime, -100!
BasicTime.OutOfRange => CONTINUE];
};

GetPartyFromNumberInt: INTERNAL PROC[
partyID: PartyID, phoneNumber: Thrush.ROPE,
description: ROPE, trunkRequired: BOOL]
RETURNS [nb: NB_$success, newPartyID: PartyID_nullID] = {
isExt: BOOLEAN _ FALSE;
num: ROPE _ NIL;
party: PartyData _ ThPartyPrivate.UnsealParty[partyID];
trunkParty: PartyData;
myExtAtom: ATOM;
myExt: ROPE;
IF party=NIL THEN RETURN[$noSuchParty, nullID];
myExtAtom _ GetRnameFromParty[party, $current].rAtom; -- rName for party.
myExtAtom _  IF myExtAtom=NIL THEN NIL
ELSE NARROW[Triples.Select[$Extension, myExtAtom, -- extension --]];
myExt _ IF myExtAtom=NIL THEN NIL ELSE Atom.GetPName[myExtAtom];
[num, isExt] _ ThNet.HowToDial[phoneNumber, myExt];
IF isExt AND ~trunkRequired THEN {
atom: ATOM_Atom.MakeAtom[num]; -- phone extension
IF atom #NIL THEN atom _ NARROW[Triples.Select[$Extension, --party--, atom]];
IF atom#NIL THEN {
newParty: PartyData;
[nb, newParty]_ GetActiveParty[partyID, Atom.GetPName[atom], NIL];
newPartyID _ Reseal[newParty];
SELECT nb FROM
$noSuchParty2 => NULL; -- extension info is there, but party isn't!
ENDCASE => RETURN;
};
};
[nb, trunkParty] _ GetRelatedParty[party]; -- trunk if telephone/individual, or vice/versa
IF nb # $success THEN {
party _ NARROW[Triples.Select[$Poaching, party, -- poachee--]];
IF party#NIL THEN [nb, trunkParty] _ GetRelatedParty[party];
};
IF nb # $success THEN RETURN;
trunkParty.outgoing _ num;
trunkParty.reservedBy _ partyID;
trunkParty.name _ description; -- starts out as name of trunk owner, changes on first use
newPartyID _ Reseal[trunkParty];
};

GetRelatedParty: INTERNAL PROC[party: PartyData]
RETURNS [nb: NB, relatedParty: PartyData_NIL] = {
rAtom: ATOM;
[nb,,rAtom]_GetRnameFromParty[party, $owner];
IF nb # $success THEN RETURN; -- VERY strange
SELECT party.type FROM
$individual, $telephone =>
relatedParty _ NARROW[Triples.Select[$trunk, rAtom, -- trunk party --]];
$trunk =>
relatedParty _ NARROW[Triples.Select[$telephone, rAtom, -- telephone party --]];
ENDCASE;
IF relatedParty = NIL THEN nb _ $noSuchParty2
ELSE IF relatedParty.numConvs#0 THEN nb _ $convStillActive -- busy
ELSE IF ~relatedParty.enabled THEN nb _ $noSuchParty2; -- not available yet
};

Register: PUBLIC PROC[
shh: SHHH_none,
rName: ROPE_NIL, -- party identification
type: Thrush.PartyType _ $individual,
clonePartyID: PartyID,
interface: ThParty.SmartsInterfaceName, -- interface
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials_[] ] = {
[nb, credentials] _ DoRegister[rName, type, clonePartyID, interface, NIL, properties];
};

RegisterLocal: PUBLIC PROC[
shh: SHHH_none,
rName: ROPE_NIL, -- party identification
type: Thrush.PartyType _ $individual,
clonePartyID: PartyID,
interfaceRecord: ThParty.SmartsInterfaceRecord _ NIL,
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials_[] ] = {
[nb, credentials] _ DoRegister[rName, type, clonePartyID, [ ], interfaceRecord, properties];
};

DoRegister: PROC[
rName: ROPE_NIL, -- party identification
type: Thrush.PartyType _ $individual,
clonePartyID: PartyID,
interface: ThParty.SmartsInterfaceName, -- interface
interfaceRecord: ThParty.SmartsInterfaceRecord,
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials_[] ] = {
hostAtom: ATOM = VoiceUtils.MakeAtom[
VoiceUtils.InstanceFromNetAddress[properties.netAddress, Atom.GetPName[type]]];
smarts: SmartsData_NARROW[Triples.Select[$SmartsForHost, hostAtom, -- smarts --]];
party: PartyData;
partyToSmartsShh: SHHH _ none;
IF clonePartyID#nullID THEN {
[nb, credentials] _ RegisterClone[clonePartyID, hostAtom]; RETURN; };
IF smarts#NIL AND smarts.type#$service THEN {
nb_Deregister[none, Reseal[smarts]];
IF nb # $success THEN RETURN;
};
IF rName=NIL THEN RETURN[nb: $noIdentSupplied];
IF interfaceRecord=NIL THEN {
partyToSmartsShh _ NamesRPC.StartConversation[
caller: serverInterfaceName.instance,
callee: rName,
key: serverPassword,
level: --<<ECB>>--CBCCheck ! RPC.AuthenticateFailed =>
{ VoiceUtils.Problem["Authenticate failed", $System]; CONTINUE}];
IF partyToSmartsShh=NIL THEN RETURN[nb: $couldntAuthenticate];
interfaceRecord _ SmartsRpc.ImportNewInterface[
interfaceName: interface ! RPC.ImportFailed =>
{ VoiceUtils.Problem["Import failed", $System]; CONTINUE}];
IF interfaceRecord=NIL THEN RETURN[nb: $couldntConnect];
};
{ RegisterEntry: ENTRY PROC={
[nb, party] _ CreateParty[rName, type];
IF nb#$success THEN RETURN;
smarts_NEW[ThPartyPrivate.SmartsBody_[
properties: properties, 
type: type,
interface: interfaceRecord,
shh: partyToSmartsShh,
notifications: MBQueue.Create[],
pupSocket: PupSocket.CreateEphemeral[remote: Pup.nullAddress]
]];
smarts.properties.netAddress.socket _ PupSocket.GetLocalAddress[smarts.pupSocket].socket;
TU.MakeUnique[$Smarts, party, smarts];
IF type#$service THEN TU.MakeUnique[$SmartsForHost, hostAtom, smarts]; --
Figure out how to do this stuff for services
credentials.partyID _ RefID.Reseal[party];
credentials.smartsID _ RefID.Seal[smarts];
SetPoaching[party];  -- This is recomputed on every GetParty, included here for debugging ease.
}; RegisterEntry[]; };
VoiceUtils.Report[IO.PutFR["Register[%g, %g, %g] -> [%g, %g]",
rope[rName], atom[type], TU.RefAddr[ThPartyPrivate.UnsealParty[clonePartyID]],
TU.RefAddr[party], TU.RefAddr[smarts]]];
};

CheckIn: PUBLIC PROC[shh: SHHH_none, credentials: ThParty.Credentials]
RETURNS [nb: NB_$success] = { NULL; };

CreateParty: INTERNAL PROC[rName: Thrush.ROPE, type: Thrush.PartyType]
RETURNS [nb: NB_$success, party: PartyData_NIL] = {
partyRname: Thrush.ROPE = IF type # $service THEN rName ELSE MakeServiceRname[rName].serviceRname;
partyID: PartyID_nullID;
rAtom: ATOM=VoiceUtils.MakeAtom[partyRname];
extension: ATOM_NIL;
IF partyRname=NIL THEN RETURN[nb: $noIdentSupplied];
IF type # $service THEN party_ NARROW[Triples.Select[type, rAtom, --party--]];
IF party#NIL THEN RETURN[$success, party];
party _ NEW[ThPartyPrivate.PartyBody _ [type: type, name: rName]];
SELECT type FROM
$individual, $telephone, $service => { -- Local telephone number
num: ROPE_GetNumbersForRName[rName: partyRname].number;
party.outgoing _ num;
IF num#NIL AND ~(([num,]_ThNet.HowToDial[num]).isLocalExtension) THEN num_NIL;
IF num#NIL THEN extension _ VoiceUtils.MakeAtom[num];
};
ENDCASE;
partyID _ RefID.Seal[party];
TU.MakeUnique[type, rAtom, party];
IF extension#NIL THEN TU.MakeUnique[$Extension, rAtom, extension];
};

SetPoaching: INTERNAL PROC[party: PartyData, callingParty: PartyData_NIL] = {
poacher, poachee: PartyData_NIL;
tempParty: PartyData _ NIL;
rName: ROPE _ party.name;
smarts: REF;
workstation: ATOM;
wsName: ROPE;
nb: NB;
{SELECT party.type FROM
$individual => {
poacheeID: PartyID;
poacher_party;
IF (smarts _ Triples.Select[$Smarts, poacher, -- smarts --]) = NIL THEN {
VoiceUtils.Problem["No smarts connection?"]; RETURN; };
IF (workstation _ NARROW[Triples.Select[$SmartsForHost,-- host--,smarts]]) = NIL THEN {
VoiceUtils.Problem["No SmartsForHost?"]; RETURN; };
wsName _ Atom.GetPName[workstation]; -- $"3#456#individual" =>
wsName _ wsName.Substr[len: wsName.Length[]-Rope.Length["individual"]];
wsName _ wsName.Concat[larkRegistry]; 		-- "3#456#.lark"
IF (rName _ NamesGV.GVGetAttribute[wsName, $owner, NIL]) = NIL THEN GOTO Done;
poachee _ NARROW[Triples.Select[$telephone, VoiceUtils.MakeAtom[rName], --party--]];
IF poachee#NIL OR callingParty=NIL THEN GOTO Done;
IF party.outgoing = NIL THEN GOTO Done; -- 
No phone number?
[nb, poacheeID] _ GetPartyFromNumberInt[
partyID: Reseal[callingParty],
phoneNumber: party.outgoing,
description: rName,
trunkRequired: TRUE
];
IF nb#$success OR poacheeID=nullID THEN GOTO Done;
poachee _ ThPartyPrivate.UnsealParty[poacheeID];
};
$telephone => {
wsRope: ROPE _
NamesGV.GVGetAttribute[rName.Concat[larkRegistry], $workstationhost, NIL];
workstation _ VoiceUtils.MakeAtom[wsRope.Concat["individual"]];
IF workstation = NIL THEN GOTO Done;
poachee_party;
IF (smarts _ Triples.Select[$SmartsForHost, workstation,-- smarts--])= NIL THEN GOTO Done;
poacher _ NARROW[Triples.Select[$Smarts, -- party --, smarts]];
IF poacher = NIL THEN { VoiceUtils.Problem["No smarts connection?"]; RETURN; };
};
ENDCASE=>RETURN;
EXITS Done => NULL; };
IF poachee#NIL THEN {
tempParty _ NARROW[Triples.Select[$Poaching, Any, poachee]];
IF tempParty#NIL AND tempParty.enabled AND poacher=tempParty AND poacher.enabled
THEN RETURN; -- Already set up as desired
ThPartyPrivate.MakeSubstitution[oldParty: tempParty, newParty: poachee]; -- If tempParty#NIL
Triples.Erase[$Poaching, Any, poachee];
};
IF poacher#NIL THEN {
tempParty _ NARROW[Triples.Select[$Poaching, poacher, Any]];
ThPartyPrivate.MakeSubstitution[oldParty: poacher, newParty: tempParty]; -- See MakeSubstitution
Triples.Erase[$Poaching, poacher, Any];
};
IF poacher=NIL OR poachee=NIL OR ~poacher.enabled OR ~poachee.enabled THEN RETURN;
Triples.Make[$Poaching, poacher, poachee];
ThPartyPrivate.MakeSubstitution[oldParty: poachee, newParty: poacher];
};

RegisterClone: ENTRY PROC[clonePartyID: PartyID, hostAtom: ATOM]
RETURNS [nb: NB_$success, credentials: ThParty.Credentials_[]] = {
cloneParty: PartyData_ThPartyPrivate.UnsealParty[clonePartyID];
party: PartyData;
cloneSmarts, smarts: SmartsData;
rName: ROPE; rAtom: ATOM;
[nb, rName,rAtom] _ GetRnameFromParty[cloneParty, $owner];
IF nb#$success THEN RETURN;
IF cloneParty=NIL THEN RETURN[nb: $noSuchParty];
cloneSmarts _ NARROW[Triples.Select[$Smarts, cloneParty, -- Smarts --]];
IF cloneSmarts=NIL THEN {
VoiceUtils.Problem["No Smarts for party?"]; RETURN[nb: $noSuchSmarts]; };
party _ NEW[ThPartyPrivate.PartyBody _ [type: cloneParty.type, name: cloneParty.name]];
smarts_NEW[ ThPartyPrivate.SmartsBody _ [
properties: cloneSmarts.properties, 
type: cloneSmarts.type,
interface: cloneSmarts.interface,
shh: cloneSmarts.shh,
notifications: MBQueue.Create[],
pupSocket: PupSocket.CreateEphemeral[remote: Pup.nullAddress]
]];
smarts.properties.netAddress.socket _ PupSocket.GetLocalAddress[smarts.pupSocket].socket;
TU.MakeUnique[$Smarts, party, smarts];
IF party.type#$service THEN TU.MakeUnique[$SmartsForHost,hostAtom, smarts];
Triples.Make[cloneParty.type, rAtom, party];
credentials.partyID _ RefID.Seal[party];
credentials.smartsID _ RefID.Seal[smarts];
VoiceUtils.Report[IO.PutFR["RegisterClone[%g, %g] -> [%g, %g]",
TU.RefAddr[party], TU.RefAddr[cloneParty], card[credentials.smartsID], TU.RefAddr[smarts]    ],  $Party, party];
};

Enable: PUBLIC ENTRY PROC[shh: SHHH_none, smartsID: SmartsID]
RETURNS [nb: Thrush.NB] = { RETURN[Able[smartsID, TRUE]]; };
Disable: PUBLIC ENTRY PROC[shh: SHHH_none, smartsID: SmartsID]
RETURNS [nb: Thrush.NB] = { RETURN[Able[smartsID, FALSE]]; };

Able: INTERNAL PROC[smartsID: SmartsID, enabling: BOOL]
RETURNS[nb: Thrush.NB_$success] = {
smarts: SmartsData=ThPartyPrivate.UnsealSmarts[smartsID];
party: PartyData;
IF smarts=NIL THEN RETURN[$noSuchSmarts];
IF (party_NARROW[Triples.Select[$Smarts, --party--, smarts]])=NIL
THEN RETURN[$noSuchParty];
party.enabled_ smarts.enablesParty_ enabling;
SetPoaching[party];
};

GetPupSocket: PUBLIC PROC[partyID: PartyID] RETURNS [PupSocket.Socket_NIL] = {
party: PartyData _ ThPartyPrivate.UnsealParty[partyID];
smarts: SmartsData = NARROW[Triples.Select[$Smarts, party, --smarts--]];
IF smarts=NIL THEN RETURN;
IF smarts.properties.role=$voiceTerminal THEN RETURN[smarts.pupSocket];
party _ NARROW[Triples.Select[$Poaching, party, --poachee--]];
IF party#NIL THEN RETURN[GetPupSocket[Reseal[party]]];
};

Deregister: PUBLIC ENTRY PROC[shh: SHHH, smartsID: SmartsID]
RETURNS [nb: NB _ $success] = {
ENABLE UNWIND => NULL;
party: PartyData;
smarts: SmartsData _ ThPartyPrivate.UnsealSmarts[smartsID];
IF smarts=NIL THEN RETURN[$noSuchSmarts];
party _ NARROW[Triples.Select[$Smarts, --party--, smarts]];
IF party#NIL THEN {
IF party.type # $individual THEN IdleConversationsForParty[party, smartsID]
ELSE {
newParty: PartyData;
SetPoaching[party];
newParty _ NARROW[Triples.Select[$Poaching, party, Triples.Any]];
IF newParty#NIL AND newParty.type=$telephone THEN
ThPartyPrivate.MakeSubstitution[party, newParty];
};
EraseAsObjOrVal[party];
VoiceUtils.ReportFR[
"DeleteParty[%g, %g]", $System, NIL, card[Reseal[party]], TU.RefAddr[party]];
IF ~RefID.Release[Reseal[party]] THEN nb _ $noSuchParty; -- ??
}
ELSE nb _ $noSuchParty;
EraseAsObjOrVal[smarts];
smarts.failed _ TRUE;
VoiceUtils.ReportFR[
"UnregisterSmarts[%g, %g]", $System, NIL, card[smartsID], TU.RefAddr[smarts]];
IF ~RefID.Release[smartsID] THEN ERROR; -- Having successfully dehandled above!
};

IdleConversationsForParty: INTERNAL PROC[party: PartyData, smartsID: SmartsID] = {
convState: ThPartyPrivate.ConvState_NIL;
IdleOneConv: Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  ={
WITH trip.att SELECT FROM r: ThPartyPrivate.ConvState => convState _ r; ENDCASE => RETURN[TRUE];
IF convState.state<= Thrush.notReallyInConv THEN { convState _ NIL; RETURN[TRUE]; };
[--
nb, convEvent; do your best, I guess.--] _ ThPartyPrivate.DoAdvance[ 
credentials: [
partyID: Reseal[party],
smartsID: smartsID, -- 
This is very questionable
convID: NARROW[trip.obj, ThPartyPrivate.ConversationData].convID,
state: convState.state,
stateID: convState.stateID
],
state: $idle,
reportToAll: TRUE,
reason: $terminating,
newInConv: FALSE
]; -- Idle party in conversation!!
RETURN[FALSE];
};
IdleRelated: INTERNAL Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  = { 
IdleConversationsForParty[NARROW[trip.obj], smartsID];
};
DO
convState_NIL;
Triples.Foreach[Any, Any, party, IdleOneConv];
IF convState = NIL THEN EXIT;
ENDLOOP;
Triples.Foreach[$Poaching, Any, party, IdleRelated];
Triples.Foreach[$Visiting, Any, party, IdleRelated];
};

DescribeParty: PUBLIC PROC[partyID: Thrush.PartyID, nameReq: ThParty.NameReq]
RETURNS[nb: NB, description: Thrush.ROPE] = {
a: ATOM;
[nb, description, a] _ GetRnameFromParty[ThPartyPrivate.UnsealParty[partyID], nameReq];
};


Visit: PUBLIC ENTRY PROC[shh: SHHH_none, visitedParty: PartyID, visitingParty: PartyID]
RETURNS [nb: Thrush.NB_$success] = {
visitor, visitee: PartyData;
InterceptVisitingCalls: INTERNAL Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  = { 
convState: ThPartyPrivate.ConvState_NIL;
credentials: Thrush.Credentials;
originator: PartyData;
conv: ThPartyPrivate.ConversationData;
WITH trip.att SELECT FROM
r: ThPartyPrivate.ConvState => convState _ r; ENDCASE => RETURN;
SELECT convState.state FROM $ringing, $notified => NULL; ENDCASE=>RETURN;
conv _ NARROW[trip.obj];
originator _ NARROW[Triples.Select[$Originator, conv, --originator--]];
IF originator=NIL THEN RETURN;
credentials.partyID _ Reseal[originator];
credentials.smartsID _ Reseal[Triples.Select[$Smarts, originator, --smarts--]];
credentials.convID _ conv.convID;
credentials.stateID _ ThPartyPrivate.GetConvState[conv, originator, FALSE].stateID;
[] _ ThPartyPrivate.AlertOne[credentials, Reseal[visitee], Reseal[visitor]];
};
UnvisitInternal[visitingParty];
visitor _ ThPartyPrivate.UnsealParty[visitingParty];
visitee _ ThPartyPrivate.UnsealParty[visitedParty];
IF visitee = NIL THEN RETURN[$noSuchParty];
IF visitor = NIL THEN RETURN[$noSuchParty2];
IF visitor = visitee THEN RETURN[$narcissism];
SELECT visitee.type FROM $individual => NULL; ENDCASE => RETURN[$visitingIllegal];
SELECT visitor.type FROM
$individual, $telephone => NULL; ENDCASE => RETURN[$visitingIllegal];
Triples.Make[$Visiting, visitor, visitee];
Triples.Foreach[Any, Any, visitor, InterceptVisitingCalls];
};

Unvisit: PUBLIC ENTRY PROC[shh: SHHH_none, visitingParty: PartyID]
RETURNS [nb: Thrush.NB_$success] = { UnvisitInternal[visitingParty]; };
UnvisitInternal: PUBLIC INTERNAL PROC[visitingParty: PartyID] = {
visitor, visitee: PartyData;
visitor _ ThPartyPrivate.UnsealParty[visitingParty];
IF visitor=NIL THEN RETURN;
visitee _ NARROW[Triples.Select[$Visiting, visitor, -- visitee--]];
IF visitee=NIL THEN RETURN;
Triples.Erase[$Visiting, visitor, Triples.Any];
};

DoDescribeParty: PUBLIC PROC[ party: PartyData, nameReq: ThParty.NameReq ]
RETURNS[ description: Thrush.ROPE_NIL] = {
type: Thrush.PartyType _ party.type;
DescribeTrunk: PROC RETURNS[des: ROPE] = INLINE {
more: ROPE=IF party.outgoing#NIL THEN party.outgoing ELSE "outside line";
des _ IF party.name=NIL THEN more
ELSE IO.PutFR["%s (%s)", IO.rope[party.name], IO.rope[more]];
};
Sel: PROC[type: Thrush.PartyType, party: PartyData] RETURNS [name: Thrush.ROPE] = {
a: ATOM _ NARROW[Triples.Select[type, -- owner --, party]];
RETURN[IF a=NIL THEN NIL ELSE Atom.GetPName[a]];
};
IF nameReq=$none THEN RETURN;
description _ SELECT type FROM
$individual, $telephone => party.name,
$trunk => (SELECT nameReq FROM
$owner => Sel[$trunk, party],
$description => DescribeTrunk[],
$current => party.name,
$address => party.outgoing,
ENDCASE=>ERROR),
$service => (SELECT nameReq FROM
$description => IO.PutFR["%s service (%s)",
rope[VoiceUtils.RnameToRspec[Sel[$service, party]].simpleName], rope[party.name]],
$address => party.name,
$owner, $current => Sel[$service, party],
ENDCASE=>ERROR),
ENDCASE => ERROR;
};
GetRnameFromParty: PUBLIC PROC[party: PartyData, nameReq: ThParty.NameReq_$current]
RETURNS [nb: NB_$success, rName: Thrush.ROPE_NIL, rAtom: ATOM_NIL] = {
IF party=NIL THEN RETURN[nb: $noSuchParty];
rName _ DoDescribeParty[party, nameReq];
IF rName=NIL THEN nb _ $noNameAvailable
ELSE rAtom _ VoiceUtils.MakeAtom[rName];
};

MakeServiceRname: PUBLIC PROC[serviceName: Thrush.ROPE]
RETURNS [serviceRname: Thrush.ROPE, serviceRnameAtom: ATOM] = {
serviceRname _ Rope.Cat[serviceName, larkRegistry];
serviceRnameAtom _ VoiceUtils.MakeAtom[serviceRname];
};

GetCurrentParty: PUBLIC ENTRY PROC[shh: Thrush.SHHH_none, smartsID: Thrush.SmartsID]
RETURNS [nb: NB_$success, partyID: Thrush.PartyID_Thrush.nullID] = {
smarts: REF _ ThPartyPrivate.UnsealSmarts[smartsID];
party: PartyData;
p: PartyData;
IF smarts=NIL THEN RETURN[nb: $noSuchSmarts];
party _ NARROW[Triples.Select[$Smarts, --party--, smarts]];
IF party#NIL AND ~party.enabled THEN RETURN[nb: $noSuchParty];
IF party=NIL THEN { VoiceUtils.Problem["No party?"]; RETURN[nb: $noSuchParty]; };
SetPoaching[party]; -- make sure $Poaching link is correct
IF (p_NARROW[Triples.Select[$Poaching, -- poacher --, party]])#NIL
AND p.enabled THEN party _ p;
partyID _ Reseal[party];
};

EraseAsObjOrVal: INTERNAL PROC[ref: REF] = {
Triples.Erase[Any, ref, Any];
Triples.Erase[Any, Any, ref];
};

ReportSystem: VoiceUtils.WhereProc = { s_NIL; };

ReportParty: VoiceUtils.WhereProc = {
party: PartyData = NARROW[whereData];
smarts: SmartsData;
IF party=NIL OR
( smarts _ NARROW[Triples.Select[$VoiceTerminal, party, Any]] ) = NIL THEN RETURN;
SELECT smarts.properties.role FROM
$voiceTerminal => s_Nice.LarkConLogStream[smarts.properties.netAddress]; ENDCASE;
IF s=NIL OR s=Nice.LarkConLogStream[Thrush.noAddress] THEN s_VoiceUtils.FindWhere[$System, NIL];
};

WhitePagesInit: Commander.CommandProc = {
treeName: ROPE;
IF wpState#NIL AND ThNet.CloseWhitePagesDatabase[wpState] THEN wpState_NIL;
treeName _ CommandTool.NextArgument[cmd];
IF wpState=NIL THEN wpState _ ThNet.InitWhitePagesDatabase[
treeName -- Optional, defaults supplied by WP impl.,
];
};

serverInterfaceName: ThPartyRpcControl.InterfaceName;
serverPassword: RPC.EncryptionKey;

ThPartyInit: Commander.CommandProc = {
ENABLE
RPC.ExportFailed => { VoiceUtils.Problem["ThParty export failed", $System]; GOTO Failed; };
instance: ROPE = VoiceUtils.MakeRName[style: rName, name:
VoiceUtils.CmdOrToken[cmd: cmd, key: "ThrushServerInstance", default: "Strowger.Lark"]];
serverInterfaceName _ [
type: "ThParty.Lark",
instance: instance,
version: ThVersions.ThrushVR];
serverPassword _ VoiceUtils.CurrentPasskey[VoiceUtils.CmdOrToken[
cmd: cmd, key: "ThrushServerPassword", default: "MFLFLX"]];
VoiceUtils.RegisterWhereToReport[ReportSystem, $System];
VoiceUtils.RegisterWhereToReport[ReportParty, $Party];
ThPartyRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
ThPartyRpcControl.ExportInterface[
interfaceName: serverInterfaceName,
user: instance,
password: serverPassword];
VoiceUtils.ReportFR["Export[ThParty.Lark, %s]", $System, NIL, rope[serverInterfaceName.instance]];
EXITS
Failed => ThPartyRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
};

Commander.Register["WhitePages", WhitePagesInit, "WhitePages <TreeName (opt.)> -- Initialize and Open White Pages Database"];
Commander.Register["ThParty", ThPartyInit,
"ThParty <ExportInstance[Strowger]> <ServerPassword[...]>\nInitialize and Export ThParty"];
}.
úThPartyInitImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Last modified by D. Swinehart, November 9, 1986 9:01:01 am PST
Definitions	
Functions for obtaining existing parties, or phone numbers

Obtains a $service, $individual, or $telephone party, if available
No active party; try to get a trunk line for that individual
Locates an idle $service party, if available
e.g., $"text-to-speech.lark"
[trip: Triples.TripleRec] RETURNS [continue: BOOLEAN _ TRUE]
A service party is available if it is enabled, not involved in a conversation, and either has never been reserved or the guaranteed reservation period has expired.
e.g., $"myself.pa"
Reserve the party
Always successful, since optional
Party description has not yielded a party, so phone number will have to do.  Perhaps the phone number is an extension of an active $individual; if not, try to find an idle outgoing trunk.
myExt is used as Intelnet authorization code.
IF phoneNumber = NIL THEN RETURN[$noIdentSupplied, nullID];
A null phoneNumber is a request for a direct outside line connection.
Get Trunk Party
Making new parties and smartses

Deregister any previous smarts from this machine.  When cloning to produce multiple smarts and parties for a multi-channel service, obviously don't want to do this.
Multi-channel services must deregister explicitly, since this won't handle it.
Includes setting RName access, poaching and visiting designations.
But IMPORTANT!!  Net and host remain those supplied by the client. We're only providing a socket ID here that is in the range available to Bluejay. 
See ThPartyPrivate
Not implemented yet.  See ThParty for description.
rName is a misnomer; it's the name of a service, without registry, if type is service.
There's no voice path for this individual.  Try to create one using calling party's trunk.
Splice in poachees for poachers in any relationships that are ending, poachers for poachees in any that are beginning.

What should happen here anyhow, wrt SmartsForHost

Find socket structure associated with the voiceTerminal smarts currently associated with this party.  
See ThPartyPrivate discussion of sockets.
Deregister Smarts from Party, destroy both

There's but one party per smarts, these days.  When the Smarts goes, so goes the party.  For the most part, we can (after idling all the conversations in which the party participates) merely erase all the interconnections between the party and smarts and other objects, and release their ID's.
Don't hang up calls for $individual parties with valid poachees, since a poachee can carry on a conversation by itself.
$Visiting implementations and hints for implementations are only suggestions, for now.
Transfer $Visitors from authenticated to assumed.
smarts.notifications.Flush[]; -- Abandon progress-report queue
They have to be allowed to empty themselves, so that the "reports outstanding" counts will be maintained correctly.
Idle any conversations in which the party is involved.  Outside loop avoids Foreach/Erase conflicts.
Apply the process recursively to poachers and visitors: if a poacher is in a conversation, the poachee is not recorded as being in the same one; similarly for visitors, at least at present.  But the poachee or visitee is always vital to the conversation's existence, so out it goes.

This is still bogus.  It won't work as well as older systems at dealing properly with Finch dropping out. 
Visiting Registration/Deregistration
This would be bogus, except that Alert does not change the stateID of the caller.
Worry about Patching the visitee into a ringing call!
If visitor is in a conversation, in state notified or ringing, simulate having the originator notify the visitee.



ThPartyPrivate.MakeSubstitution[oldParty: visitor, newParty: visitee];

Only workstations would care when visiting ended.  At present, there's no direct way to tell them.
ThPartyPrivate Implementations


Returns (bogus) service name if type = $service
Which party should we be when initiating calls?
Initialization


Log
Swinehart, May 15, 1985 10:24:49 am PDT
Cedar 6.0
changes to: larkRegistry, GetParty, GetActiveParty, GeIdleParty, CreateParty, NewParty
Swinehart, May 16, 1985 9:18:28 am PDT
CommandToolExtras zapped.
Swinehart, May 22, 1985 12:01:41 pm PDT
ServiceName changes
recording => service
Jay => serviceName, to generalize
individual and service treated similarly in places
changes to: GetIdleParty, CreateParty, NewParty, DoDescribeParty, MakeServiceRname
changes to: CreateParty, ExistingParty, NewParty, DoDescribeParty
changes to: GetIdleParty
changes to: CreateParty, ExistingParty, NewParty
Swinehart, October 25, 1985 6:45:23 pm PDT
Handle => ID, NamesAndLog => VoiceUtils
changes to: DIRECTORY, ThPartyInitImpl, GetActiveParty, GetIdleParty, CreateParty, ExistingParty, DoRegister, RegisterClone, Deregister, EnterSmarts, MakeServiceRname, GetStdRingInfo, ReportSystem, ReportParty, ThPartyInit, ConversationID, PartyID, SmartsID, nullID, Reseal, GetParty, GetPartyFromFeepNum, GetPartyFromNumber, GetPartyFromNumberInt, GetTrunkParty, GetRname, Register, RegisterLocal, EnterSmartsE (local of EnterSmarts), Enable, Disable, DescribeParty, DoDescribeParty, GetCurrentParty, GetPartySmarts, SetStdRingInfo, SetRingEnable, NewParty


Swinehart, October 29, 1985 5:55:37 pm PST
Major revisions for visiting and poaching.  See design document.
changes to: CreateParty, Register, RegisterLocal, DoRegister, EnterSmarts, Able, Deregister, PrepareRingTune, GetPartyFromNumber, GetRname, DescribeParty, GetActiveParty, GetIdleParty, GetPartyFromNumberInt, GetTrunkParty, Deregister, Deregister, EraseAsObj, Deregister



Swinehart, December 11, 1985 3:29:30 pm PST
Just improve comments
changes to: GetRelatedParty, SetPoaching

Swinehart, May 17, 1986 5:38:13 pm PDT
Cedar 6.1
changes to: DIRECTORY, DoRegister, ReportParty
Swinehart, June 29, 1986 11:40:51 am PDT
Pull PartyAvailable stuff, counting on Smarts to get it right.
changes to: VoiceParty, GetActivePartyDo
Swinehart, August 8, 1986 10:26:54 am PDT
Visiting.
changes to: Visit
 , Unvisit
 , UnvisitInternal
 , EraseAsObjOrVal
 

�Ê ,˜Jš
œ™šœ
Ïm
œ7™BJš
œ>™>J˜—š
Ïk	˜	Jšœžœ˜"Jšœ
žœ*˜9Jšœ
žœ˜*Jšœžœ˜#J˜Jšœžœ˜%Jšœžœ˜Jšœžœ˜!Jšœ	žœ˜%J˜J˜Jšœ
žœ.˜=Jšœžœžœ˜*Jšœžœ!˜+Jšžœ
žœC˜LJšœžœž
œf˜tJš
œe˜eJšœžœŸ
˜³
Jš
œ˜J˜šœžœ˜JšœžœFžœžœ˜‰
—Jšœžœ˜0J˜Jšœžœ:˜GJšžœ
žœ˜!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˜
—Jšžœ˜šžœ˜Jšžœ
žœ˜—J˜—š
œ™Jšžœžœ
žœ
˜JšœžœÏc˜;šœ	žœŸ˜%J˜ —Jšžœžœ
žœ
˜JšœžœŸ˜=Jšœ
žœŸ˜'šžœžœ
žœ
˜Jšœžœ˜ —JšÏnœžœžœžœžœžœžœ˜LJ˜ J˜Jšœžœ	˜J˜J˜J˜—™:J˜š
 œžœ
ž
œžœ
žœ˜<Jšœžœžœ
˜/Jšžœžœ˜)Jšžœ
žœžœ
˜J˜Jš
œ6˜6J˜Jš
œ˜J˜—š œžœ
ž
œ
˜'Jšœžœ)žœ
žœ
˜;Jšžœžœ*˜9Jšžœ
žœžœ
˜Jšœžœ
˜šœžœ˜%Jšœ'žœ ˜K—Jšžœžœ
žœ
žœ˜,Jšœ-žœ˜2J˜Jš
œ˜J˜—š œžœ
žœ
žœ
˜&Jšœžœ(žœ
˜6Jšœ
žœ
˜Jšžœžœ˜)Jšžœ
žœžœ
˜JšœLžœ˜SJ˜J˜—š
 œžœ
žœžœžœ
˜CJšžœ
žœ
žœžœ˜=J˜š
œ5˜5Jš
œ3˜3—šžœ	žœ
žœ$˜7J˜?—J˜J™—š œžœ
žœ!žœ
˜CJš
œ˜Jšžœžœžœ˜6J™BJš
œ7˜7Jš
œ6˜6Jšžœžœ*žœ˜RJ˜š 
œžœ
žœžœ˜Pšžœ˜šžœžœ"Ÿ
œž˜OJšžœ˜——J˜J˜——š œžœ
žœ!žœ
˜EJš
œ˜Jšžœžœžœ˜6Jšœžœ
˜
J˜Jšœ	žœ
˜J˜J˜Jš
žœžœ
žœ
žœžœ˜0šžœžœ
žœ+˜=Jš
œ=˜=Jšžœžœ=˜RJšžœ
˜J˜—šžœž˜Jšœ=žœ˜GJšœžœŸ˜)Jšœ
žœŸ˜(Jšžœžœ
˜—šœžœ
˜JšœŸ
œ2Ÿœ˜V—šžœ
žœ
žœžœ˜+Jš
œ˜Jšžœ
˜Jš
œ˜—Jšžœžœ
žœ˜4J™<š
œ4˜4Jš
œ3˜3—Jšžœ	žœ
žœ	žœ
žœ
žœ˜=šžœžœ
žœ!˜3Jš
œL˜L—Jšžœžœ
žœ
žœ˜-JšœFžœ˜LJšžœ
žœ0˜CJ˜J˜—š œžœ
žœ žœ
˜@Jšžœžœžœ˜/J™,Jšžœ
žœžœ
˜J•StartOfExpansion@ -- [trip: Triples.TripleRec] RETURNS [continue: BOOLEAN _ TRUE]šœžœ
žœ
˜Jšœžœ˜%Jšœžœ
˜
Jš
œ6˜6šœžœ2˜GJ™—š 
œ˜&J–= -- [att: Triples.Item, obj: Triples.Item, val: Triples.Item]š
Ðck<™<J™£
Jšœžœ˜Jšžœžœ
žœ
˜#šžœžœž˜/Jšœ#ž˜%š
œ9˜9Jšœžœ)žœžœžœ
žœ˜o——J˜—Jšžœ	žœ
žœ
žœ˜-š
œ)˜)J™—Jšžœžœ
žœžœ˜4Jšœ6Ÿ	œ˜PJšžœžœ
žœ˜)J™J˜J˜J˜Jš
œ˜J˜—š
 œžœ
žœ
žœžœ0˜YJšžœžœ˜Jš
Ÿ!™!Jš
œC˜Cšžœ
žœ
žœ žœ˜QJšžœ
žœ
˜—˜QJšœžœ˜"—J˜J˜—š œž
œ
˜%Jšœ&žœ
˜+Jšœ
žœžœ
˜'Jšžœžœ*˜9J™»
Jšœžœžœ
˜Jšœžœžœ
˜J˜7J˜Jšœžœ
˜Jšœžœ
˜J™-Jšžœžœ
žœ
žœ˜/J˜Išœ
žœžœ
žœ
ž˜&Jšžœ
žœ'Ÿœ˜D—Jšœžœžœ
žœ
žœ
žœ˜@šžœžœ
žœ
žœ™;J™E—Jš
œ3˜3šžœžœžœ˜"JšœžœŸ˜1Jš
žœžœ
žœžœŸ	œ	˜Mšžœžœ
žœ˜J˜Jšœ=žœ˜BJš
œ˜šžœ˜JšœžœŸ,˜CJšžœžœ
˜—Jš
œ˜—Jš
œ˜—J™Jšœ+Ÿ/˜Zšžœžœ˜Jšœžœ"Ÿœ˜?Jšžœžœ
žœ+˜<J˜—Jšžœžœ
žœ
˜Jš
œ˜Jš
œ ˜ JšœŸ:˜YJš
œ ˜ J˜J˜—š œžœ
žœ˜0Jšžœžœžœ˜1Jšœžœ
˜Jš
œ-˜-Jšžœžœ
žœŸ˜-šžœž˜š
œ˜JšœžœŸœ˜H—š
œ	˜	Jšœžœ#Ÿœ˜P—Jšžœ
˜—Jšžœžœ
žœ˜-Jšžœ
žœžœŸ˜BJšžœ
žœžœŸ˜KJš
œ˜J˜——™J™š œžœ
žœ
˜Jšœžœ˜Jšœžœ
žœŸ˜(J˜%J˜Jšœ(Ÿ˜4J˜$Jšœžœ˜Jšœžœ+˜1JšœEžœ˜VJ˜J˜—š 
œžœ
žœ
˜Jšœžœ˜Jšœžœ
žœŸ˜(J˜%J˜Jšœ1žœ
˜5J˜$Jšœžœ˜Jšœžœ+˜1Jš
œ\˜\J˜J˜—š 
œžœ
˜Jšœžœ
žœŸ˜(J˜%J˜Jšœ(Ÿ˜4Jš
œ/˜/J˜$Jšœžœ˜Jšœžœ+˜1šœ
žœ˜%Jš
œO˜O—Jšœžœ*Ÿœ˜RJ˜Jšœžœ˜šžœžœ˜Jšœ;žœ˜E—šžœžœ
žœžœ˜-J™¤
J™NJš
œ$˜$Jšžœžœ
žœ
˜J˜—Jšžœžœ
žœ
žœ˜/šžœžœ
žœ˜š
œ.˜.Jš
œ%˜%Jš
œ˜Jš
œ˜JšœŸœžœ˜6Jšœ6žœ˜A—Jšžœžœ
žœ
žœ˜>š
œ/˜/Jšœžœ˜.Jšœ0žœ˜;—Jšžœžœ
žœ
žœ˜8J˜—JšÏbÐbn
¢Ðbk¢
¤¢˜Jš
œ'˜'šžœ
žœ
žœ
˜Jš
œB™B—šœžœ˜&Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ J˜=Jš
œ˜—˜YJšœ¤œRžœ1Ït
ϴ
™¨
—Jšžœ$˜&Jš
žœžœ
žœ/ŸÐct
Ÿ,¦
˜wJ˜*J˜*JšœŸJ˜_Jš
¢˜š
œ>˜>J˜NJ˜(—J˜J˜—š œžœ
žœžœ(˜FJšžœžœžœ˜&J™2J˜—š œžœ
žœžœ˜FJšžœžœžœ˜3J™VJš	œžœžœžœžœ&˜bJ˜Jšœžœ!˜,Jšœžœ
žœ
˜Jšžœžœ
žœ
žœ˜4JšžœžœžœŸ	œ˜NJšžœžœ
žœ
žœ˜*Jšœžœ7˜Bšžœž˜šœ'Ÿ˜@Jšœžœ.˜7Jš
œ˜Jš
žœžœ
žœ3žœžœ
˜NJšžœžœ
žœ&˜5J˜—Jšžœ
˜—J˜Jšžœ ˜"Jšžœžœ
žœ
žœ*˜BJš
œ˜J˜—š œžœ
žœ+žœ˜MJšœžœ
˜ Jšœžœ
˜Jšœžœ˜Jšœžœ
˜Jšœ
žœ
˜Jšœžœ
˜
Jšœžœ
˜š¢
žœž˜˜J˜J˜šžœ,Ÿœžœ
žœ˜IJšœ-žœ˜7—š
žœžœŸ	œ
žœ
žœ˜WJšœ)žœ˜3—Jšœ%Ÿ˜>J˜GJšœ(Ÿ˜8Jš
žœ1žœžœ
žœ
žœ˜NJšœ
žœ8Ÿ	œ˜TJš
žœ	žœ
žœ
žœ
žœ˜2Jš
¥Z™ZJš	žœžœ
žœ
žœŸ˜=˜(J˜J˜J˜Jšœž˜Jš
œ˜—Jšžœ
žœžœ
žœ˜2J˜0J˜—˜š
œ˜JšœEžœ˜J—J˜?Jšžœžœ
žœ
žœ˜$J˜Jš
žœ6Ÿœžœ
žœ
žœ˜ZJšœ
žœ/˜?Jšžœžœ
žœ0žœ˜OJ˜—Jšžœžœ
˜—Jšžœ
¢œžœ¢
œ
˜™všžœ	žœ
žœ˜Jšœžœ*˜<š
žœžœ
žœžœžœ˜PJšžœ
žœŸ˜)—JšœIŸ˜\J˜'J˜—šžœ	žœ
žœ˜Jšœžœ*˜<JšœIŸ˜`J˜'J˜—Jšžœ	žœ
žœ	žœ
žœžœžœ
žœ
˜RJ˜*J˜F—J˜J˜—š 
œžœ
žœ"žœ
˜@Jšžœžœ3˜BJš
œ?˜?Jš
œ˜J˜ Jšœžœ	žœ
˜Jš
œ:˜:Jšžœ
žœ
žœ
˜Jšžœžœ
žœ
žœ˜0Jšœžœ%Ÿœ˜Hšžœ
žœ
žœ˜Jšœ,žœ˜I—JšœžœL˜Wšœžœ˜)J˜$J˜J˜!J˜Jš
œ ˜ J˜=J˜—J˜YJšžœ$˜&Jšžœžœ
žœ-˜KJš
œ,˜,J˜(J˜*Jš¥
œ1¥
™3š
œ?˜?Jšžœžœ2žœ'˜p—Jš
œ˜J˜—š
 œžœ
žœ
žœžœ˜=Jšžœ
žœžœžœ˜<J™—š
 œžœ
žœ
žœžœ˜>Jšžœ
žœžœžœ˜=—J˜š œžœ
žœžœ
˜7Jšžœžœ˜#J˜9J˜Jšžœžœ
žœ
žœ˜)šžœžœŸ	œž˜AJšžœ
žœ˜—Jš
œ-˜-Jš
œ˜J˜J˜—š
 œžœ
žœžœžœ˜NJšœf¥
œ)¥
™‘
Jš
œ7˜7Jšœžœ Ÿ
œ˜HJšžœžœ
žœ
žœ
˜Jšžœ'žœ
žœ˜GJšœžœ"Ÿœ˜>Jšžœžœ
žœ
žœ˜6J˜J˜——™*J™š
 
œžœ
žœ
žœžœ˜<Jšžœžœ˜J™¥J™wJ™VJšžœ
žœžœ
˜J˜J˜;Jšžœžœ
žœ
žœ˜)JšœžœŸ	œ˜;šžœžœ
žœ˜Jšžœžœ+˜Kšžœ˜J˜J˜Jšœžœ0˜Ašžœ
žœ
žœž˜1Jš
œ1˜1—J˜—J™1Jš
œ˜š
œ˜Jšœ žœžœ˜M—JšžœžœŸ˜>J˜
—Jšžœ˜Jš
œ˜Jšœžœ
˜šœŸ ™>J™s—š
œ˜Jšœ%žœžœ˜N—Jšžœžœ
žœŸ'˜OJ˜J˜—š œžœ
žœ*˜RJšœ$žœ
˜(š œ¡˜5Jš¡(œ˜,Jšžœ
žœ
žœ/žœžœ
žœ˜`Jš
žœ*žœžœžœ
žœ˜Tšœ
Ÿ+œ˜J˜J˜JšœŸÑbceŸœ
˜2Jšœžœ3˜AJ˜J˜J˜—J˜
Jšœ
žœ
˜Jš
œ˜Jšœž˜JšœŸ˜"—Jšžœ
žœ˜J˜—š œžœ¡˜>Jš¡(œ˜.Jšœžœ˜6J˜—J™dš
ž˜Jšœ
žœ
˜J˜.Jšžœ
žœ
žœ
žœ
˜Jšžœ
˜—J™šJ™lJš
œ4˜4Jš
œ4˜4J˜J˜—š 
œžœ3˜MJšžœžœžœ˜-Jšœžœ
˜J˜WJ˜J˜——š
œ$™$J˜š
 œžœ
žœ
žœžœ5˜WJšžœ
žœ˜$Jš
œ˜š œžœ¡˜IJš¡(œ˜.Jšœ$žœ
˜(J˜ J˜J˜&šžœ
žœ
ž˜Jšœ.žœžœ
˜@—Jš
žœžœžœžœžœ
˜IJšœžœ˜Jšœ
žœ#Ÿœ˜GJšžœžœ
žœ
žœ
˜J˜)JšœBŸ
œ˜OJ˜!šœDžœ
˜SJ™Q—J˜LJ˜—Jš
œ˜Jš
œ4˜4Jš
œ3˜3Jšžœžœ
žœ
žœ˜+Jšžœžœ
žœ
žœ˜,Jšžœžœ
žœ˜.Jš
žœžœžœžœžœ˜Ršžœž˜Jšœžœžœžœ˜E—Jš
œ*˜*š
œ5™5Jš
œq™q—J˜;Jš
œ˜J˜J™—š œžœžœ˜BJšžœ
žœ1˜GJ™—š œžœ˜AJš
œ˜Jš
œ4˜4Jšžœ	žœ
žœ
žœ
˜Jšœ
žœ$Ÿœ˜CJšžœ	žœ
žœ
žœ
˜Jš
œ/˜/š¥
œF¥
™HJš¥
œb¥
™d—Jš
œ˜—J˜—™J™š œžœ
žœ.˜JJšžœžœ
žœ˜*J˜$š
 
œžœ
žœžœžœ˜1Jšœžœ
žœžœ
žœžœ˜Išœžœžœ
žœ˜!Jšžœ
žœžœžœ
˜=—J˜—š œžœ+žœžœ˜SJšœžœžœŸœ
˜;Jšžœ
žœžœ
žœ
žœ
žœ˜0J˜—Jšžœžœ
žœ
˜šœžœž˜J˜&šœžœ	ž˜Jš
œ˜J˜ Jš
œ˜J˜Jšžœžœ˜—šœ
žœ	ž˜ šœžœ˜+Jš
œR˜R—Jš
œ˜Jš
œ)˜)Jšžœžœ˜—Jšžœžœ
˜—J˜J™—š œžœ5˜SJšžœžœžœ
žœ	žœ
žœ˜FJ™/Jšžœžœ
žœ
žœ˜+J˜(Jšžœžœ
žœ˜'Jšžœ$˜(Jš
œ˜—J˜š œžœ
žœžœ
˜7Jšžœžœžœ˜?Jš
œ3˜3Jš
œ5˜5Jš
œ˜—J˜J™/š œžœ
ž
œ
žœ!˜TJšžœžœ5˜DJšœžœ)˜4J˜Jš
œ
˜
Jšžœžœ
žœ
žœ˜-JšœžœŸ	œ˜;Jš
žœžœ
žœžœ
žœ˜>Jšžœžœ
žœ$žœ˜QJšœŸ&˜:šžœžœŸ
œž˜BJšžœžœ˜—J˜J˜—J˜š œžœ
žœžœ˜,J˜J˜J˜J˜——™J™š œžœ˜0J˜—š œ˜%Jšœžœ˜%Jš
œ˜šžœžœ
ž˜Jš	œžœ1žœ
žœ
žœ
˜R—šžœž˜"JšœHžœ
˜Q—Jš
žœžœ
žœ+žœ!žœ˜`J˜—J˜š œ˜)Jšœ
žœ
˜Jš
žœ	žœ
žœ(žœ	žœ
˜KJš
œ)˜)šžœ	žœ
žœ(˜;Jšœ	Ÿ+˜4J˜—J˜—J˜Jš
œ5˜5Jšœžœ˜"J˜š œ˜&š
ž˜JšžœIžœ˜[—šœ
žœ+˜9Jš
œX˜X—š
œ˜J˜Jš
œ˜J˜—š
œA˜AJ˜;—Jš
œ8˜8Jš
œ6˜6JšœAžœ˜Kš
œ"˜"Jš
œ#˜#Jš
œ˜J˜—Jšœ9žœ&˜bš
ž˜JšœKžœ˜U—J˜—J˜Jš
œ}˜}š
œ*˜*Jš
œ[˜[—J˜Icode™—™™'K™	KšœÏrJ™V—™&K™—™'K™K™K™!K™2Kšœ¨F™RKšœ¨5™AKšœ¨™Kšœ¨$™0—™*K™'Kšœ¨�œ¨{™­K™K™—™*K™@Kšœ¨�™�—K™K™—K™™+K™Kšœ¨™(—K™™&K™	Kšœ¨"™.—™(K™>Kšœ¨™(—™)K™	Kš
œ¨œ
¨œ
¨œ
¨œ
¨
™H—K™—…—l˜¤¾