DIRECTORY
Atom USING [ GetPName, MakeAtom ],
BasicTime USING [ Now, Update ],
Commander	USING [ CommandProc, Register ],
CommandTool USING [ NextArgument ],
ExplicitExport USING [ ExportExplicitly ],
IO,
LarkPlay USING [ PlayString, Tone, ToneSpec, ToneSpecRec ],
Log USING [ FindWhere, Problem, ProblemHandle, RegisterWhereToReport, Report, ReportFR, WhereProc ],
LupineRuntime USING [ BindingError ],
Names USING [ CmdOrToken, CurrentPasskey, InstanceFromNetAddress, MakeAtom, Registrize ],
NamesGV USING [ GVGetAttribute, GVSetAttribute, GVUpdate ],
NamesRPC USING [ StartConversation ],
Nice,
Rope USING [ Concat, Cat, Fetch ],
RPC USING [ AuthenticateFailed, EncryptionKey, ExportFailed, ImportFailed ],
SafeStorage USING [ GetCanonicalType, Type ],
Thrush USING [
AlertKind, CallUrgency, ConversationHandle, Enhandle, HandleFault, KillHandle, NB, PartyHandle, PartyType, H, nullHandle, Machine, pERROR, Priorities, RingEnable, Rname, ROPE, SHHH, SmartsHandle, TBD, ThHandle, unencrypted ],
ThNet USING [ CloseWhitePagesDatabase, FeepName, HowToDial, InitWhitePagesDatabase, List, NewListing, pd, WhitePagesEnter, WhitePagesEntry, WPListing, WPState ],
ThParty,
ThPartyPrivate USING [ CFRef, DehandleParty, DehandleSmarts, DoAdvance, PartyBody, PartyData, SmartsBody, SmartsData, Supervise ],
ThPartyRpcControl,
ThPartyRpcServerImpl,
ThPartyMonitorImpl,
ThSmarts USING [ SmartsInterface, SmartsProperties ],
ThSmartsRpcControl USING [ ImportNewInterface, InterfaceRecord ],
ThVersions USING [ ThrushVR ],
Triples USING [ Any, Erase, Foreach, ForeachProc, Make, Select ],
TU USING [ MakeUnique, RefAddr ]
;

ThPartyInitImpl: CEDAR MONITOR LOCKS root
IMPORTS Atom,
BasicTime,
IO,
Commander,
CommandTool,
ExplicitExport,
LarkPlay,
Log,
LupineRuntime,
Names,
NamesGV,
NamesRPC,
Nice,
root: ThPartyMonitorImpl,
Rope,
RPC,
SafeStorage,
SmartsRpc: ThSmartsRpcControl,
Thrush,
ThNet,
ThPartyPrivate,
ThPartyRpcControl,
ThPartyRpcServerImpl,
ThVersions,
Triples,
TU	
EXPORTS ThParty, ThPartyPrivate
SHARES ThPartyMonitorImpl, ThPartyRpcServerImpl = {
OPEN IO;

AlertKind: TYPE = Thrush.AlertKind;
CallUrgency: TYPE = Thrush.CallUrgency;
CFRef: TYPE = ThPartyPrivate.CFRef;
ConversationHandle: TYPE = Thrush.ConversationHandle;
PartyBody: TYPE = ThPartyPrivate.PartyBody;	-- Concrete
RTPartyType: SafeStorage.Type = SafeStorage.GetCanonicalType[CODE[PartyBody]];
PartyData: TYPE = ThPartyPrivate.PartyData;	-- REF Concrete
PartyHandle: TYPE = Thrush.PartyHandle;	-- Handle
ROPE: TYPE = Thrush.ROPE;
SmartsBody: TYPE = ThPartyPrivate.SmartsBody;	-- Concrete
SmartsData: TYPE = ThPartyPrivate.SmartsData;	-- REF Concrete
RTSmartsType: SafeStorage.Type =SafeStorage.GetCanonicalType[CODE[SmartsBody]];
SmartsHandle: TYPE = Thrush.SmartsHandle;	-- Handle
SmartsInterface: TYPE = ThSmarts.SmartsInterface;
LocalSmartsInterface: TYPE = SmartsRpc.InterfaceRecord;
nullHandle: Thrush.PartyHandle = Thrush.nullHandle;
SHHH: TYPE = Thrush.SHHH;
none: SHHH = Thrush.unencrypted;
TBD: TYPE = Thrush.TBD;
pERROR: ERROR = Thrush.pERROR;
H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; };

larkRegistry: ROPE=".Lark";

ringTone: LarkPlay.ToneSpec _ NIL;
subduedRingTone: LarkPlay.ToneSpec _ NIL;
outsideRingTune: PUBLIC LarkPlay.ToneSpec _ NIL;
outsideRingTuneRope: ROPE _ "@300;G%>G<%G%>G<%G%>G<%G%>G<%G%>*C";

thPartyExported: BOOL_FALSE;
wpState: ThNet.WPState;

standardPriorities: Thrush.Priorities = LIST [
LIST [$Supervisor], LIST [$Manager], LIST[$LocatedTerminal], LIST [$AdjacentTerminal],
LIST [$VoiceTerminal, $LabPhone], LIST [$Secretary], LIST [$Receptionist] ];


GetParty: PUBLIC ENTRY PROC[shh: SHHH_NIL, partyID: PartyHandle,
rName: Thrush.Rname, type: Thrush.PartyType]
RETURNS [newPartyID: PartyHandle] = {
ENABLE UNWIND=>NULL;
RETURN[H[GetActiveParty[partyID, rName, type]]]; };

GetActiveParty: INTERNAL PROC[partyID: PartyHandle, rName: Thrush.Rname,
type: Thrush.PartyType]
RETURNS [newParty: PartyData] = {
rAtom: ATOM;
IF rName=NIL THEN RETURN[NIL];
IF type=service THEN RETURN[GetIdleParty[partyID, rName]];
rName _ Names.Registrize[rName];
rAtom _ Names.MakeAtom[rName];
RETURN[NARROW[Triples.Select[$RnameForParty, --party--, rAtom]]];
};

GetIdleParty: INTERNAL PROC[partyID: PartyHandle, serviceName: ROPE]
RETURNS [newPartyData: PartyData _ NIL] = {
ENABLE UNWIND=>NULL;
party: PartyData_ ThPartyPrivate.DehandleParty[partyID];
rAtom: ATOM;
serviceNameAtom: ATOM = MakeServiceRname[serviceName].serviceRnameAtom;
IF party = NIL THEN RETURN;
rAtom _ NARROW[Triples.Select[$RnameForParty, party, -- rAtom --]];
rAtom _ Names.MakeAtom[Rope.Cat[Atom.GetPName[rAtom], ".", serviceName]];
party _ NARROW[Triples.Select[$RnameForParty, --party--, serviceNameAtom]];
IF party = NIL OR party.numEnabled = 0 THEN RETURN;
TU.MakeUnique[$RnameForParty, party, rAtom];
RETURN[party]; };

GetPartyFromFeepNum: PUBLIC ENTRY PROC[
shh: SHHH_none, partyID: PartyHandle, feepNum: Thrush.ROPE_NIL]
RETURNS [newPartyID: PartyHandle_nullHandle] = {
ENABLE UNWIND=>NULL;
party: PartyData _ NIL;
rName, officeNumber: ROPE;
listing: ThNet.WPListing;
[rName, officeNumber, listing] _ ThNet.WhitePagesEntry [
wpState: wpState, name: feepNum, feep: TRUE, key: $officeNumber];
IF rName=NIL THEN RETURN; 
party _ GetActiveParty[partyID, rName, individual];
IF party#NIL THEN RETURN[H[party]];
IF officeNumber=NIL THEN RETURN;
RETURN[GetPartyFromNumberInt[partyID, officeNumber, rName, TRUE]];
};

GetPartyFromNumber: PUBLIC ENTRY PROC[
shh: SHHH, partyID: PartyHandle, phoneNumber: Thrush.ROPE,
description: ROPE, trunkOK: BOOL]
RETURNS [newPartyID: PartyHandle] = {
ENABLE UNWIND => NULL;
RETURN[GetPartyFromNumberInt[partyID, phoneNumber, description, trunkOK]];
};

GetPartyFromNumberInt: INTERNAL PROC[
partyID: PartyHandle, phoneNumber: Thrush.ROPE,
description: ROPE, trunkOK: BOOL]
RETURNS [newPartyID: PartyHandle] = {
isExt: BOOLEAN _ FALSE;
num: ROPE _ NIL;
party: PartyData = ThPartyPrivate.DehandleParty[partyID];
myExtAtom: ATOM = IF party=NIL THEN NIL ELSE NARROW[Triples.Select[$Extension, party,]];
myExt: ROPE = IF myExtAtom=NIL THEN NIL ELSE Atom.GetPName[myExtAtom];
IF phoneNumber#NIL THEN [num, isExt] _ ThNet.HowToDial[phoneNumber, myExt];
IF isExt THEN {
extAtom: ATOM=Atom.MakeAtom[num];
newPartyID _ H[NARROW[Triples.Select[$Extension, --party--, extAtom]]];
IF newPartyID#nullHandle THEN RETURN[newPartyID]; };
IF ~trunkOK THEN RETURN[nullHandle];
RETURN[H[GetTrunkParty[partyID: partyID, description: description, address: num]]];
};

GetTrunkParty: INTERNAL PROC[
partyID: PartyHandle, description: Thrush.ROPE, address: Thrush.ROPE]
RETURNS[trunkParty: PartyData_NIL] = {
party: PartyData = ThPartyPrivate.DehandleParty[partyID];
IF party#NIL THEN trunkParty _ NARROW[Triples.Select[$TrunkParty, party, Triples.Any]];
IF trunkParty = NIL OR trunkParty.numConvs#0 THEN RETURN;
TRUSTED {
SELECT trunkParty.type FROM
trunk => {
trunkParty.outgoing _ address;
trunkParty.reservedBy _ partyID;
Triples.Erase[$RnameForTrunk, trunkParty, Triples.Any];
IF description#NIL THEN
Triples.Make[$RnameForTrunk, trunkParty, Atom.MakeAtom[description]];
};
ENDCASE => ERROR;
};
};

GetNumbersForRName: PUBLIC PROC[shh: SHHH_none, rName: Thrush.Rname]
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;
};
GetRname: PUBLIC PROC[shh: SHHH_none, partyID: PartyHandle] 
RETURNS [rName: Thrush.Rname] = {
RETURN[GetRnameFromParty[ThPartyPrivate.DehandleParty[partyID]]]; };

CreateParty: PUBLIC PROC[shh: SHHH_NIL, rName: Thrush.Rname, type: Thrush.PartyType]
RETURNS [partyID: PartyHandle_nullHandle] = {
party: PartyData_NIL;
partyRname: Thrush.Rname = IF type#service THEN rName ELSE MakeServiceRname[rName].serviceRname;
larkName: ROPE= partyRname.Concat[larkRegistry];
rAtom: ATOM=Names.MakeAtom[partyRname];
extension: ATOM_NIL;
wpListing: ThNet.WPListing _ NIL;
ExistingParty: ENTRY PROC = -- INLINE -- {
ENABLE UNWIND=>NULL;
party_IF type=service THEN NIL ELSE NARROW[Triples.Select[$RnameForParty, --party--, rAtom]];
IF party#NIL AND ~party.partyFailed AND party.type#type THEN {
Log.Problem[remark: "Same party name, new type", where: $System]; party_NIL; };
};
NewParty: ENTRY PROC = -- INLINE -- {
party _ NEW[PartyBody _ [type: type]];
SELECT type FROM
individual, service => {
IF extension#NIL THEN TU.MakeUnique[$Extension, party, extension];
party.serviceName _ rName; -- useful in service case only
};
ENDCASE;
party.supervisor _ NIL;
IF partyRname#NIL THEN TU.MakeUnique[$RnameForParty, party, rAtom];
TU.MakeUnique[$Priorities, party, standardPriorities];
IF wpListing#NIL THEN {
ThNet.WhitePagesEnter[wpState: wpState, listing: wpListing];
[]_ThNet.CloseWhitePagesDatabase[ wpState: wpState];
};
partyID _ Thrush.Enhandle[party];
IF type=individual THEN
SetRingEnable[partyID: Thrush.Enhandle[party], update: TRUE]; -- Get defaults
};

IF partyRname=NIL AND type#trunk THEN RETURN;
ExistingParty[];
IF party#NIL THEN RETURN[H[party]];
SELECT type FROM
individual, service => {
attr: ROPE_NamesGV.GVGetAttribute[larkName, $extension, NIL];
feepNum: ROPE;
IF attr=NIL THEN {
attr _ GetNumbersForRName[rName: partyRname].number;
IF attr#NIL AND ~(([attr,]_ThNet.HowToDial[attr]).isLocalExtension) THEN attr_NIL;
};
IF attr#NIL THEN {
extension _ Names.MakeAtom[attr];
feepNum _ ThNet.FeepName[partyRname];
IF ThNet.WhitePagesEntry[ wpState: wpState, name: feepNum, feep: TRUE, key: $officeNumber].fullRName = NIL THEN {
wpListing _ ThNet.NewListing[];
ThNet.List[wpListing, $rName, partyRname];
ThNet.List[wpListing, $name, partyRname]; -- Just in case needed
ThNet.List[wpListing, $officeNumber, Rope.Cat["8923", attr]];
};
};
};
ENDCASE;
NewParty[];
Log.Report[IO.PutFR["CreateParty[%s, %s] -> [ %g, %g ]",
rope[rName], rope[SELECT type FROM
individual => "individual", trunk=>"trunk", service=>"service", ENDCASE=>NIL],
card[partyID], IF party=NIL THEN atom[$Unknown] ELSE TU.RefAddr[party]], $Party, party];
};

Register: PUBLIC PROC[shh: SHHH, partyID: PartyHandle, interface: SmartsInterface,
properties: ThSmarts.SmartsProperties, oldSmartsID: SmartsHandle]
RETURNS [smartsID: SmartsHandle] = {
RETURN[DoRegister[ThPartyPrivate.DehandleParty[partyID], NIL, interface, properties]]; };


RegisterLocal: PUBLIC PROC[partyID: PartyHandle, interface: LocalSmartsInterface,
properties: ThSmarts.SmartsProperties, oldSmartsID: SmartsHandle]
RETURNS [smartsID: SmartsHandle] = {
RETURN[DoRegister[ThPartyPrivate.DehandleParty[partyID], interface, NIL, properties]]; };

DoRegister: PROC[party: PartyData, localInterface: LocalSmartsInterface,
remoteInterface: SmartsInterface, properties: ThSmarts.SmartsProperties]
RETURNS [smartsID: Thrush.SmartsHandle_nullHandle] ={
rName: ROPE;
smarts: SmartsData;
shh: SHHH;
interface: SmartsRpc.InterfaceRecord;
IF party=NIL THEN RETURN[nullHandle];
IF properties.role = manager THEN {
smarts _ NARROW[Triples.Select[$Manager, party, Triples.Any]];
IF smarts#NIL THEN Deregister[shh: none, smartsID: H[smarts]];
};
rName_GetRnameFromParty[IF party.type#trunk THEN party ELSE GetHostParty[party]];
IF rName=NIL THEN RETURN[Log.ProblemHandle["No RName for own party", $System]];

shh _ NamesRPC.StartConversation[caller: myName.instance, callee: rName,
key: serverPassword, level: --<<ECB>>--CBCCheck ! RPC.AuthenticateFailed =>
{ smartsID _ Log.ProblemHandle["Authenticate failed", $System]; GOTO Failed}];
interface _ IF remoteInterface=NIL THEN localInterface
ELSE SmartsRpc.ImportNewInterface[interfaceName: remoteInterface^ ! RPC.ImportFailed =>
{ smartsID _ Log.ProblemHandle["Import failed", $System]; GOTO Failed}];

smarts_NEW[ThPartyPrivate.SmartsBody_[interface: interface, properties: properties, 
type: party.type, shh: shh, authenticated: FALSE--, remote: remoteInterface#NIL--]];
smartsID _ EnterSmarts[party, smarts];
Log.Report[IO.PutFR["RegisterSmarts[%g, %s] -> [%g, %g]",
TU.RefAddr[party],
rope[SELECT properties.role FROM voiceTerminal=>"voice", manager=>"mgr", ENDCASE=>"NIY"],
card[smartsID], TU.RefAddr[smarts]], $Party, party];
EXITS
Failed => smartsID_nullHandle;
};

GetHostParty: PROC[party: PartyData] RETURNS [hostParty: PartyData ] = {
RETURN[NARROW[Triples.Select[$TrunkParty, Triples.Any, party]]]; };

RegisterClone: PUBLIC PROC[
shh: SHHH_none, partyID: PartyHandle,
clonePartyID: PartyHandle, oldSmartsID: SmartsHandle_nullHandle
] RETURNS [smartsID: SmartsHandle] = {
cloneParty: PartyData_ThPartyPrivate.DehandleParty[clonePartyID];
party: PartyData _ ThPartyPrivate.DehandleParty[partyID];
cloneSmarts: SmartsData;
smData: SmartsData;
IF party=NIL OR cloneParty=NIL THEN RETURN[nullHandle];
cloneSmarts _ NARROW[Triples.Select[$VoiceTerminal, cloneParty, -- Smarts --]];
IF cloneSmarts=NIL THEN RETURN[nullHandle];
smData_NEW[ ThPartyPrivate.SmartsBody _ [
interface: cloneSmarts.interface, properties: cloneSmarts.properties, 
shh: cloneSmarts.shh, authenticated: cloneSmarts.authenticated--, remote: cloneSmarts.remote--]];
smartsID _ EnterSmarts[party, smData];
Log.Report[IO.PutFR["RegisterClone[%g, %g] -> [%g, %g]",
TU.RefAddr[party], TU.RefAddr[cloneParty], card[smartsID], TU.RefAddr[smData]],
$Party, party];
};

Deregister: PUBLIC ENTRY PROC[shh: SHHH, smartsID: SmartsHandle] = {
OPEN Triples;
ENABLE {
UNWIND => NULL;
};
party: PartyData;
cfRef: CFRef;
smarts: SmartsData;

CleanupParty: INTERNAL ForeachProc -- [trip: Triples.TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  = {
WITH trip.att SELECT FROM
r: CFRef =>
IF (party.numEnabled=0 OR r.voiceSmartsID = smartsID) AND r.event.state#idle THEN {
cfRef _ r;
[] _ ThPartyPrivate.DoAdvance[ 
smartsID: smartsID,
party: party,
conv: NARROW[trip.obj],
cfRef: cfRef,
state: idle,
reason: terminating]; -- Idle party in conversation!!
RETURN[FALSE];
};
ENDCASE;
};

DeregisterOneParty: INTERNAL ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  = {
WITH trip.obj SELECT FROM
p: PartyData => party _ p;
ENDCASE => RETURN;	-- not a party to smarts connection
Erase[trip.att, party, smarts -- (trip.val) --]; 
party.numSmarts _ party.numSmarts - 1;
IF smarts.enablesParty THEN party.numEnabled _ party.numEnabled - 1;
SELECT NARROW[trip.att, ATOM] FROM
$Manager => {
adjSmarts: SmartsData=NARROW[Select[$AdjacentTerminal, party, Any]];
Erase[$ManagerOwner, trip.val, Any];
IF adjSmarts#NIL THEN {
Erase[$AdjacentTerminal, party, Any];
party.numSmarts _ party.numSmarts - 1;
IF adjSmarts.enablesParty THEN party.numEnabled _ party.numEnabled - 1;
};
};
ENDCASE;
DO
cfRef_NIL;
Foreach[Any, Any, party, CleanupParty];
IF cfRef = NIL THEN EXIT;
ENDLOOP;
IF party.numSmarts = 0 THEN {
party.partyFailed_TRUE;
ThPartyPrivate.Supervise[party];
Log.ReportFR["DeleteParty[%g, %g]", $System, NIL, card[H[party]], TU.RefAddr[party]];
};
RETURN[FALSE];
};

smarts _ ThPartyPrivate.DehandleSmarts[smartsID];
IF smarts=NIL THEN RETURN;
DO -- Outside loop avoids conflict when Deregister erases things.
party_NIL;
Foreach[Any, Any, smarts, DeregisterOneParty];
IF party = NIL THEN EXIT;
ENDLOOP;
Log.ReportFR["UnregisterSmarts[%g, %g]", $System, NIL, card[smartsID], TU.RefAddr[smarts]];
Thrush.KillHandle[smartsID, RTSmartsType!
Thrush.HandleFault=>{Log.Problem["Problem killing smarts handle", $System]; CONTINUE}];
};
EnterSmarts: PROC[party: PartyData, smarts: SmartsData] RETURNS[smartsID: SmartsHandle] = {
managerOwnerRAtom: ATOM_NIL;
EnterSmartsE: ENTRY PROC RETURNS[smartsID: SmartsHandle] = -- INLINE -- {
attr: ATOM=WITH props: smarts.properties SELECT FROM
backstop=> $BackStop,
manager=> $Manager,
supervisor=> $Supervisor,
voiceTerminal=> $VoiceTerminal,
ENDCASE=>ERROR pERROR;
smartsID _ Thrush.Enhandle[smarts];
TU.MakeUnique[attr, party, smarts];
party.numSmarts _ party.numSmarts + 1;
IF smarts.enablesParty THEN party.numEnabled _ party.numEnabled + 1;

WITH props: smarts.properties SELECT FROM
manager => {
OPEN Triples;
TU.MakeUnique[$ManagerOwner, smarts, managerOwnerRAtom];
WITH Select[$RnameForParty, --party--, managerOwnerRAtom] SELECT FROM
managerOwnerParty: PartyData => {
mgrOwnSmarts: SmartsData _
NARROW[Select[$VoiceTerminal, managerOwnerParty, --smarts--]];
IF mgrOwnSmarts#NIL THEN {
TU.MakeUnique[$AdjacentTerminal, party, mgrOwnSmarts];
party.numSmarts _ party.numSmarts + 1;
IF mgrOwnSmarts.enablesParty THEN party.numEnabled _ party.numEnabled + 1;
};
};
ENDCASE;
};
voiceTerminal => IF party.type=individual THEN {
OPEN Triples;
managerOwnerSmarts: REF;
managerOwnerParty: PartyData;
managerOwnerRAtom _ NARROW[Select[$RnameForParty, party, -- rAtom --]];
IF managerOwnerRAtom=NIL THEN RETURN; -- This is really an Error, though.
managerOwnerSmarts _ Select[$ManagerOwner, --smarts--, managerOwnerRAtom];
IF managerOwnerSmarts=NIL THEN RETURN;
managerOwnerParty _ NARROW[Select[$Manager, -- party--, managerOwnerSmarts]];
IF managerOwnerParty=NIL THEN RETURN;
TU.MakeUnique[$AdjacentTerminal, managerOwnerParty, smarts];
managerOwnerParty.numSmarts _ managerOwnerParty.numSmarts + 1;
IF smarts.enablesParty THEN
managerOwnerParty.numEnabled _ managerOwnerParty.numEnabled + 1;
};
ENDCASE;
};

WITH props: smarts.properties SELECT FROM
manager => {
managerOwner: ROPE _ NamesGV.GVGetAttribute[
rName: Names.InstanceFromNetAddress[props.machine, larkRegistry],
attribute: $owner, default: NIL];
IF managerOwner#NIL THEN managerOwnerRAtom _ Names.MakeAtom[managerOwner];
};
ENDCASE;
RETURN[EnterSmartsE[]];
};

Enable: PUBLIC ENTRY PROC[shh: SHHH_none, smartsID: SmartsHandle]
RETURNS [nb: Thrush.NB] = {
smarts: SmartsData=ThPartyPrivate.DehandleSmarts[smartsID];
IF smarts=NIL THEN RETURN[noSuchSmarts];
IF smarts.enablesParty THEN RETURN[success];
smarts.enablesParty_TRUE;
RETURN[Able[smarts, 1]];
};
Disable: PUBLIC ENTRY PROC[shh: SHHH_none, smartsID: SmartsHandle]
RETURNS [nb: Thrush.NB] = {
smarts: SmartsData=ThPartyPrivate.DehandleSmarts[smartsID];
IF smarts=NIL THEN RETURN[noSuchSmarts];
IF ~smarts.enablesParty THEN RETURN[success];
smarts.enablesParty_FALSE;
RETURN[Able[smarts, -1]];
};

Able: INTERNAL PROC[smarts: SmartsData, direction: INT]
RETURNS[nb: Thrush.NB_success] = {
AbleOne: Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN _ TRUE] --  ={
WITH trip.obj SELECT FROM
party: PartyData => {
res: INT=party.numEnabled+direction;
IF res<0 THEN nb_invalidTransition
ELSE party.numEnabled _ res;
};
ENDCASE;
};
Triples.Foreach[Triples.Any, Triples.Any, smarts, AbleOne];
};

DescribeParty: PUBLIC ENTRY PROC[shh: SHHH_none,
partyID: PartyHandle]
RETURNS[ description: Thrush.ROPE] = {
ENABLE UNWIND=>NULL;
RETURN[DoDescribeParty[partyID]];
};

DoDescribeParty: PUBLIC INTERNAL PROC[ partyID: PartyHandle ]
RETURNS[ description: Thrush.ROPE] = TRUSTED {
party: PartyData = ThPartyPrivate.DehandleParty[partyID];
IF party=NIL THEN RETURN[NIL];
description _ GetRnameFromParty[party];
SELECT party.type FROM
individual => RETURN[description];
trunk => {
more: ROPE=IF party.outgoing#NIL THEN party.outgoing ELSE "outside line";
IF description=NIL THEN description _ more
ELSE description _ IO.PutFR["%s (%s)", IO.rope[description], IO.rope[more]];
RETURN[description];
};
service => RETURN[IO.PutFR["%g service", rope[party.serviceName]]];
ENDCASE;
};
GetRnameFromParty: PROC[party: PartyData] RETURNS [rName: Thrush.Rname] = {
rRef: REF ANY;
IF party=NIL THEN RETURN[NIL];
rRef _ Triples.Select[$RnameForParty, party, --rRef--];
IF rRef=NIL THEN rRef_Triples.Select[$RnameForTrunk, party, --rRef--];
IF rRef=NIL THEN RETURN[NIL];
RETURN[Atom.GetPName[NARROW[rRef]]]; };

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

GetCurrentParty: PUBLIC ENTRY PROC[shh: Thrush.SHHH_none, smartsID: Thrush.SmartsHandle]
RETURNS [partyID: Thrush.PartyHandle_Thrush.nullHandle] = {
ENABLE UNWIND=>NULL;
smarts: REF _ ThPartyPrivate.DehandleSmarts[smartsID];
IF smarts=NIL THEN RETURN;
FOR p: Thrush.Priorities _ standardPriorities, p.rest WHILE p#NIL DO
FOR s: Thrush.Priorities _ NARROW[p.first], s.rest WHILE s#NIL DO
att: ATOM_NARROW[s.first];
party: REF_Triples.Select[att, Triples.Any, smarts];
IF party#NIL THEN RETURN[H[party]];
ENDLOOP;
ENDLOOP; };

GetPartySmarts: PUBLIC ENTRY PROC[partyID: Thrush.PartyHandle, kind: ATOM
] RETURNS [smartsID: Thrush.SmartsHandle]={
ENABLE UNWIND=>NULL;
party: PartyData_ThPartyPrivate.DehandleParty[partyID];
IF party=NIL THEN RETURN [Thrush.nullHandle];
RETURN[H[Triples.Select[kind, party, --smarts--]]]; };

GetStdRingInfo: PUBLIC PROC [partyID: PartyHandle] = TRUSTED {
party: PartyData_ThPartyPrivate.DehandleParty[partyID];
larkRname: ROPE;
rdAtom: ATOM;
IF party=NIL THEN RETURN;
SELECT party.type FROM
individual => {
larkRname _ GetRnameFromParty[party].Concat[larkRegistry];
IF larkRname=larkRegistry THEN RETURN;
party.ringEnable _ SELECT
NamesGV.GVGetAttribute[rName: larkRname, attribute: $ringmode, default: "R"].Fetch[0] FROM
'R => on,
'S => subdued,
'O => off,
ENDCASE => on;
rdAtom _ Names.MakeAtom[NamesGV.GVGetAttribute[rName: larkRname, attribute: $dotune, default: "false"]];
party.ringDo _ SELECT rdAtom FROM
$true => ownTune,
$false => standard,
$tune => ownTune,
$both => bothTunes,
ENDCASE => standard;
party.ringTuneRope _ Rope.Cat[NamesGV.GVGetAttribute[larkRname, $tunea, NIL],
NamesGV.GVGetAttribute[larkRname, $tuneb, NIL],
NamesGV.GVGetAttribute[larkRname, $tunec, NIL]];
};
ENDCASE;
};

SetStdRingInfo: PUBLIC PROC[partyID: PartyHandle, update: BOOL_FALSE] = TRUSTED {
party: PartyData_ThPartyPrivate.DehandleParty[partyID];
larkRname: ROPE;
IF party=NIL THEN RETURN;
SELECT party.type FROM
individual => {
r: ROPE;
larkRname _ GetRnameFromParty[party].Concat[larkRegistry];
IF larkRname=larkRegistry THEN RETURN;
r _ SELECT party.ringEnable FROM on => "R", subdued => "S", off => "O", ENDCASE => NIL;
IF r#NIL THEN NamesGV.GVSetAttribute[larkRname, $ringmode, r];
IF update THEN NamesGV.GVUpdate[larkRname];
};
ENDCASE;
};

SetRingEnable: PUBLIC PROC[shh: SHHH_none, partyID: PartyHandle, ringEnable: Thrush.RingEnable_noChange, ringInterval: INT_0, update: BOOL_FALSE] = TRUSTED {
party: PartyData_ThPartyPrivate.DehandleParty[partyID];
GetStdRingInfo[partyID];
SELECT party.type FROM
individual => {
IF ringEnable=noChange THEN ringEnable _ party.ringEnable;
party.ringEnable _ ringEnable;
party.ringTime _ BasicTime.Update[BasicTime.Now[], ringInterval];
[] _ PrepareRingTune[party];
SELECT ringEnable FROM
on, subdued, off => {
IF update AND ringEnable#party.defaultRingEnable THEN
SetStdRingInfo[partyID, ThNet.pd.autoGVUpdate];
party.defaultRingEnable _ ringEnable;
};
ENDCASE; 
};
ENDCASE;
};

PrepareRingTune: PROC[party: PartyData] RETURNS[ringTune: LarkPlay.ToneSpec] = TRUSTED {
SELECT party.type FROM
individual => {
IF ThNet.pd.ringsInvalid THEN {
ThNet.pd.ringsInvalid _ FALSE;
ringTone _ NEW[LarkPlay.ToneSpecRec _ [
repeatIndefinitely: TRUE, volume: ThNet.pd.defaultRingVolume,
tones: LIST[LIST[
[f1: 440, f2: 480, on: 2000, off: 4000],
[f1: 440, f2: 480, on: 2000, off: 4000]]]]]; 
subduedRingTone _ NEW[LarkPlay.ToneSpecRec _ [
repeatIndefinitely: FALSE,
volume: ThNet.pd.defaultRingVolume+ThNet.pd.subduedVolumeInterval,
tones: LIST[LIST[[f1: 440, f2: 480, on: 500, off: 0]]]
]]; 
outsideRingTune _ LarkPlay.PlayString[outsideRingTuneRope, FALSE, ThNet.pd.defaultRingVolume];
};
IF party.ringDo#standard AND party.ringTuneRope#NIL THEN
ringTune _ LarkPlay.PlayString[music: party.ringTuneRope, file: FALSE, volume: ThNet.pd.defaultRingVolume]
ELSE {
pattern: LarkPlay.ToneSpec = SELECT party.ringEnable FROM
subdued, subduedTimed => subduedRingTone, ENDCASE => ringTone;
ringTune _ NEW[LarkPlay.ToneSpecRec_pattern^];
};
IF ringTune#NIL THEN SELECT party.ringEnable FROM
subdued, subduedTimed => {
ringTune.volume _ ringTune.volume + ThNet.pd.subduedVolumeInterval;
ringTune.repeatIndefinitely _ FALSE;
};
ENDCASE;
party.ringTune _ ringTune;
};
ENDCASE;
};

ReportSystem: Log.WhereProc = CHECKED {
s_NIL;
};

ReportParty: Log.WhereProc = TRUSTED {
party: PartyData = NARROW[whereData];
smarts: SmartsData;
IF s=NIL THEN s _ Log.FindWhere[$System, NIL];
IF party=NIL THEN RETURN;
smarts _ NARROW[Triples.Select[$VoiceTerminal, party, Triples.Any]];
IF smarts=NIL THEN RETURN;
WITH props: smarts.properties SELECT FROM
voiceTerminal => s_Nice.LarkConLogStream[props.machine]; ENDCASE;
IF s#NIL AND s=Nice.LarkConLogStream[[[0],[0]]] THEN s_Log.FindWhere[$System, NIL];
};

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

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

ThPartyInit: Commander.CommandProc = {
ENABLE
RPC.ExportFailed => { Log.Problem["ThParty export failed", $System]; GOTO Failed; };
myName _ [
type: "ThParty.Lark",
instance: Names.CmdOrToken[cmd: cmd, key: "ThrushServerInstance", default: "Morley.Lark"],
version: ThVersions.ThrushVR];
serverPassword _ Names.CurrentPasskey[Names.CmdOrToken[
cmd: cmd, key: "ThrushServerPassword", default: "MFLFLX"]];
IF thPartyExported THEN RETURN;
Log.RegisterWhereToReport[ReportSystem, $System];
Log.RegisterWhereToReport[ReportParty, $Party];
ThPartyRpcControl.ExportInterface[
interfaceName: myName,
user: myName.instance,
password: serverPassword];
ExplicitExport.ExportExplicitly["ThParty.Lark", myName.instance, ThVersions.ThrushVR, ThPartyRpcControl.LupineProtocolVersion, ThPartyRpcServerImpl.ServerDispatcher];
Log.ReportFR["Export[ThParty.Lark, %s]", $System, NIL, rope[myName.instance]];
thPartyExported _ TRUE;
EXITS
Failed => ThPartyRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
};

Commander.Register["WhitePages", WhitePagesInit, "WhitePages <TreeName (opt.) <IntExtMapFileName (opt)>> -- Initialize and Open White Pages Database"];
Commander.Register["ThParty", ThPartyInit,
"ThParty <ExportInstance(opt.) <ServerPassword (opt)>> -- Initialize and Export ThParty"];
}.
NThPartyInitImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last modified by D. Swinehart, July 21, 1985 10:35:14 pm PDT
Copies	
Implementation
|Need an NB return on failure|
myExt is used as Intelnet authorization code.
<< This is still not right.  Trunk parties ought to get invented as callers want them, deleted somehow (how?), connected to smarts when call attempt starts (one only at a time).  Problem reserved for future reference (maybe a structure that the GC can hack.>>

Return the Rname for a given party
|Need NB indicating why null handle returned.|
rName is a misnomer; it's the name of a service, without registry, if type is service.
Party does not already exist.  Make one if possible.
Get data base information
Telephone system extension
Will be entered in NewParty, under monitor
Party does not already exist.  Make one if possible.
Doesn't handle oldHandle (ReRegister) yet.
Implementation of ThPartyPrivate
|Need NB why failed|
Doesn't handle oldHandle (ReRegister) yet.
|Need NB why failed|
Allow only one Manager. Allow it to be the new one.
Take care of encryption, and talking to calling smarts
Create Smarts body, link with Party; we're rolling.
Remove party from each conversation in which smarts is the voiceSmarts, or to which no enabled smarts remain connected.  Outside loop avoids Foreach/Erase conflicts.
Party is serving no smarts; destroy the party itself.

Discussion:
The idea is that as Smarts register with a Party they are connected by links whose attributes are derived from their properties and degree of authentication.
When Parties initiate actions that involve Smarts they will select the Smarts to respond in an order determined by the attributes, including SmartsRole, authentication (maybe, see notes), etc.
Each kind of Smarts has its own link name to its Party
A Manager also needs to know the party to whom the physical workstation belongs, as an aid to locating the corresponding voice terminal.  Set up the relationship, then locate the adjacent terminal, if one already exists.
When the Manager registers first, the $Adjacent link must be sent when the Lark smarts arrives or dies and revives.
A Manager also needs to know the party to whom the physical workstation belongs, as an aid to locating the corresponding voice terminal.  Set up the relationship, then locate the adjacent terminal, if one already exists.


See if it works just to get the first instance of the highest priority connection that exists,
using standardPriorities.
| Should have an NB |
Set Defaults

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

Κw˜Jš
œ™šœ
Οm
œ1™<Jš
œ<™<—J˜š
Οk	˜	Jšœžœ˜"Jšœ
žœ˜ Jšœ
žœ˜*Jšœžœ˜#Jšœžœ˜*J˜Jšœ	žœ-˜;Jšœžœ[˜dJšœžœ˜%JšœžœN˜YJšœžœ.˜;Jšœ	žœ˜%J˜Jšœžœ˜"Jšžœ
žœC˜LJšœžœ˜-šœžœ˜JšœOžœž
œ>žœžœžœ˜α
—Jšœžœž
œ“
˜‘
J˜Jšœžœn˜‚
Jš
œ˜J˜J˜Jšœ	žœ'˜5Jšœžœ)˜AJ˜Jšœžœ4˜AJšžœ
žœ˜ 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šžœ˜šžœ-˜3Jšžœ
žœ
˜—J˜—š
œ™Jšœžœ˜#Jšœ
žœ˜'Jšœžœ˜#Jšœžœ˜5šœžœΟc˜7Jšœ=žœ
˜N—JšœžœŸ˜;Jšœ
žœŸ	˜1Jšžœžœ
žœ
˜JšœžœŸ˜9šœžœŸ˜=Jšœ=žœ˜O—JšœžœŸ	˜3Jšœžœ˜1Jšœžœ˜7J˜3Jšžœžœ
žœ
˜Jšœžœ˜ Jšžœžœ
žœ
˜Jšœžœ˜Jšž
œžœžœžœžœžœž
œ˜JJ˜Jšœžœ	˜J˜Jšœžœ
˜"Jšœ%žœ
˜)Jšœžœžœ
˜0Jšœžœ(˜AJ˜Jšœžœ
žœ
˜J˜J˜šœ(žœ˜.Jšžœžœ
žœžœ˜VJšžœžœžœ˜LJ˜——J™J˜š
Οnœžœ
ž
œžœ
žœ˜@Jš
œ,˜,Jšžœ˜%Jšžœ
žœžœ
˜J™Jšžœ-˜3J˜—š œž
œ+˜HJš
œ˜Jšžœ˜!Jšœžœ
˜Jš
žœžœ
žœ
žœ
žœ˜Jšžœžœ
žœ˜:J˜ Jš
œ˜Jšžœ
žœ Ÿ	œ˜AJ˜J˜—š œžœ
žœ$žœ
˜DJšžœžœ˜+Jšž
œžœ
˜Jš
œ8˜8Jšœžœ
˜Jšœžœ2˜GJšžœ	žœ
žœ
žœ
˜Jšœžœ'Ÿœ˜CJš
œI˜IJšœžœ Ÿ	œ˜KJš
žœ	žœ
žœžœ
žœ
˜3J˜,Jšžœ˜J˜—š œžœ
ž
œ
˜'Jšœžœ-žœ
žœ
˜?Jšžœ)˜0Jšžœ
žœžœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜š
œ8˜8Jšœ'žœ˜A—Jšžœžœ
žœ
žœ˜J˜3Jš
žœžœ
žœ
žœ
ž
œ	˜#Jšžœžœ
žœ
žœ
˜ Jšžœ5žœ˜BJš
œ˜J˜—š œžœ
žœ
žœ
˜&Jšœžœ,žœ
˜:Jšœ
žœžœ
˜!Jšžœ˜%Jšžœ
žœžœ
˜JšžœD˜JJ˜—J˜š œž
œ
˜%Jšœ*žœ
˜/Jšœ
žœžœ
˜!Jšžœ˜%Jšœžœžœ
˜Jšœžœžœ
˜J˜9J™-Jšœžœžœžœ
žœ
žœ
žœ
žœ%˜XJš
œžœžœžœ
žœ
žœ
žœ˜FJšžœ
žœ
žœ4˜Kšžœžœ˜Jšœ	žœ˜!Jšœ
ž
œ
žœŸ	œ
˜GJšžœžœ
žœ˜4—Jšžœ
žœ
žœ
˜$Jšžœ
ž
œK˜SJš
œ˜J˜—š 
œž
œ
˜Jšœ*žœžœ
˜EJšžœžœ˜&Jš
œ9˜9Jšžœžœ
žœžœ2˜Wš
žœžœ
žœžœ
žœ
˜9J™ƒ—Jš
ž	˜	šžœž˜š
œ
˜
Jš
œ˜Jš
œ ˜ Jš
œ7˜7šžœ
žœ
ž˜Jš
œE˜E—Jš
œ˜—Jšžœžœ
˜J˜—˜J˜——š œžœ
žœžœ˜DJšžœ
žœ
žœžœ˜=J˜š
œ5˜5Jš
œ3˜3—šžœ	žœ
žœ$˜7J˜?—J˜J™—š
œ"™"š œžœ
žœžœ˜<Jšžœ˜!šžœ>˜DJ˜———š
 œžœ
žœžœ
žœ.˜TJšžœ&˜-J™.J™VJšœžœ
˜Jšœžœžœžœ&˜`Jšœ
žœ
ž
œ ˜0Jšœžœ˜'Jšœžœ
žœ
˜Jšœžœ
˜!š 
œžœ
žœŸœ˜*Jšžœ
žœžœ
˜Jš
œžœžœ
žœ
žœ
žœ Ÿ	œ
˜]š
žœžœ
žœžœžœ˜>JšœHžœ˜O—J˜—š œžœ
žœŸœ˜%Jš
œ4™4Jšœžœ˜&šžœž˜˜Jšžœžœ
žœ-˜BJšœŸ˜9J˜—Jšžœ
˜—Jšœžœ
˜Jšžœžœ
žœ-˜CJ˜6šžœžœ
žœ˜J˜<J˜4J˜—J˜!šžœž˜Jšœ7žœŸ˜M—š
œ˜J˜——Jš
žœžœ
žœžœ
žœ
˜-J˜Jš
žœžœ
žœ
žœ
ž
œ	˜#J™šžœž˜š
œ˜Jš
œ™Jšœžœ.žœ˜=Jšœ	žœ
˜šžœžœ
žœ˜Jš
œ4˜4Jš
žœžœ
žœ5žœžœ
˜RJ˜—šžœžœ
žœ˜Jš
œ!˜!Jš
œ%˜%šžœ?žœ"žœ
žœ˜qJ˜Jš
œ*˜*Jšœ*Ÿ˜@J˜=Jš
œ*™*J˜—J˜—J˜—Jšžœ
˜—Jš
œ4™4Jš
œ˜šœžœ+˜8šœžœž˜"Jšœ@žœžœ˜N—Jšœžœžœ
žœžœ
žœ!˜X—š
œ˜J˜——š œžœ
žœžœ3˜RJ˜AJšžœ˜$Jš
œ*™*Jšžœ3žœ˜YJ˜—Jš
œ ™ J˜š 
œžœ
žœ7˜QJ˜AJšžœ˜$J™Jš
œ*™*Jšžœ>žœ˜YJ˜—š 
œžœ8˜HJ˜HJšžœ.˜5J™Jšœžœ
˜J˜Jšœžœ
˜
J˜%Jšžœžœ
žœ
žœ
˜%šžœžœ˜#J™3Jšœ	žœ/˜>Jšžœžœ
žœ!ž
œ
˜>J˜—Jšœžœžœžœ˜QJšžœžœ
žœ
žœ7˜OJ˜Jš
œ6™6š
œH˜HJšœŸœžœ˜KJšœ@žœ
˜N—šœžœžœ
žœ˜6šžœ@žœ˜WJšœ:žœ
˜H—J˜—Jš
œ3™3šœžœJ˜TJšœ+žœžœ˜T—Jš
œ&˜&˜9J˜Jšœžœžœ)žœ	˜YJš
œ4˜4—š
ž˜J˜—Jš
œ˜J˜—š œžœžœ˜HJšžœ
žœ6˜CJ˜—š 
œžœ
žœ
˜Jšœžœ˜%Jš
œ?˜?Jšœžœ˜&Jš
œA˜AJš
œ9˜9J˜J˜Jšžœžœ
žœžœ
žœ
žœ
˜7Jšœžœ,Ÿœ˜OJšžœ
žœ
žœ
žœ
˜+šœžœ˜)˜FJ˜a——Jš
œ&˜&˜8Jš
œO˜OJš
œ˜—Jš
œ˜J˜—š
 
œžœ
žœ
žœžœ˜DJšžœ	˜
šžœ
ž
˜Jšžœžœ
˜J˜—J˜J˜
J˜J•StartOfExpansionD -- [trip: Triples.TripleRec] RETURNS [continue: BOOLEAN _ TRUE] -- ˜š œžœΠck˜?JšŸ(œ˜-šžœ
žœ
ž˜š
œ˜šžœžœžœžœ˜SJ˜
š
œ˜Jš
œ˜Jš
œ
˜
Jšœžœ˜Jš
œ
˜
J˜JšœŸ˜5—Jšžœ
žœ˜J˜——Jšžœ
˜—J˜J˜—–D -- [trip: Triples.TripleRec] RETURNS [continue: BOOLEAN _ TRUE] -- š œžœ‘˜=Jš‘(œ˜-šžœ
žœ
ž˜J˜JšžœžœŸ#˜6—J˜1J˜&Jšžœžœ)˜Dšžœ
žœžœž˜"˜
Jšœžœ(˜DJ˜$šžœžœ
žœ˜J˜%J˜&Jšœžœ)˜GJ˜—J˜—Jšžœ
˜—š
ž˜J™₯
Jšœžœ
˜
J˜'Jšžœ	žœ
žœ
žœ
˜Jšžœ
˜—šžœžœ˜J™5Jšœžœ
˜Jš
œ ˜ Jšœ-žœž
œ
žœ˜UJ˜—Jšžœ
žœ˜J˜—J˜J˜1Jšžœžœ
žœ
žœ
˜šžœ
Ÿ>˜AJšœžœ
˜
Jš
œ.˜.Jšžœ	žœ
žœ
žœ
˜Jšžœ
˜—Jšœ2žœžœ˜[š
œ)˜)JšœLžœ˜W—J˜J™—š œžœ'žœ˜[Jš
œ™Jš
œ
™
Jš
œΐ
™ΐ
Jšœžœ
žœ
˜š
 œžœ
žœ
žœŸœ˜IJ™6šœžœ
žœžœ
ž˜4J˜Jš
œ˜J˜J˜Jšžœžœ˜—J˜#J˜#Jš
œ&˜&Jšžœžœ)˜DJ˜šžœžœ
ž˜)J™ά
˜Jšžœ	˜
Jš
œ8˜8šžœŸ	œžœ
ž˜Eš
œ!˜!š
œ˜Jšžœ+Ÿ
œ˜>—šžœžœ
žœ˜Jš
œ6˜6J˜&Jšžœžœ)˜JJ˜—J˜—Jšžœ
˜—J˜—J™sšœžœžœ˜0Jšžœ	˜
Jšœžœ
˜Jš
œ˜JšœžœŸœ˜GJš	žœžœ
žœ
žœŸ#˜IJšœ+Ÿ
œ˜JJšžœžœ
žœ
žœ
˜&JšœžœŸ
œ˜MJšžœžœ
žœ
žœ
˜%Jš
œ<˜<Jš
œ>˜>šžœž˜Jš
œ@˜@—J˜—Jšžœ
˜—J˜J˜—šžœžœ
ž˜)J™ά
˜šœžœ˜,Jš
œA˜AJšœžœ˜!—Jšžœžœ
žœ2˜JJ˜—Jšžœ
˜—Jšžœ˜J˜—J˜š
 œžœ
žœ
žœžœ˜AJšžœ
žœ˜J˜;Jšžœžœ
žœ
žœ˜(Jšžœžœ
žœ
˜,Jšœžœ
˜Jšžœ˜J˜J™—š
 œžœ
žœ
žœžœ˜BJšžœ
žœ˜J˜;Jšžœžœ
žœ
žœ˜(Jšžœžœ
žœ
˜-Jšœžœ
˜Jšžœ˜J˜—J˜š œžœ
žœ žœ
˜7Jšžœžœ
˜"š œ‘˜1Jš‘(œ˜,šžœ
žœ
ž˜˜Jšœžœ˜$Jšžœžœ˜"Jšžœ˜J˜—Jšžœ
˜—J˜—J˜;J˜—J˜š
 
œžœ
žœ
žœžœ˜0J˜Jšžœžœ˜&Jšžœ
žœžœ
˜Jšžœ˜!J˜—J˜š œžœ
žœ
žœ˜=Jšžœžœžœ˜.J˜9Jš
žœžœ
žœ
žœ
žœ˜Jš
œ'˜'šžœž˜Jšœžœ˜"š
œ
˜
Jšœžœ
žœžœ
žœžœ˜IJšžœ
žœ
žœ˜*Jšžœžœžœžœ
˜LJšžœ˜J˜—Jšœžœ
žœ/˜CJšžœ
˜—J˜J™—š œžœžœ˜KJšœžœ
žœ
˜Jš
žœžœ
žœ
žœ
žœ˜Jšœ-Ÿœ˜7Jšžœžœ
žœ,Ÿœ˜FJš
žœžœ
žœ
žœ
žœ˜Jšžœžœ˜'—J˜š œžœ
žœžœ
˜7Jšžœžœžœ˜?Jš
œ3˜3Jš
œ0˜0Jš
œ˜—J˜J™xš œžœ
ž
œ
žœ%˜XJšžœ4˜;J™Jšžœ
žœžœ
˜Jšœžœ+˜6Jšžœžœ
žœ
žœ
˜šžœ3žœžœ
ž˜Dš	žœžœžœžœ
ž˜AJšœžœ
žœ
˜Jšœžœ*˜4Jšžœžœ
žœ
žœ˜#Jšžœ
˜—Jšžœ˜J˜——š	 œžœ
žœ
žœ$ž˜IJšœžœ"˜+Jšžœ
žœžœ
˜Jš
œ7˜7Jšžœžœ
žœ
žœ˜-Jšžœ
ž
œŸ
œ˜6J˜—š œžœ
žœžœ˜>Jš
œ7˜7Jšœžœ
˜Jšœžœ
˜
Jšžœžœ
žœ
žœ
˜šžœž˜J˜Jš
œ:˜:Jšžœžœ
žœ
˜&šœž˜šœVž˜ZJ˜	J˜J˜
Jšžœ˜——Jš
œh˜hšœžœž˜!Jš
œ˜J˜J˜J˜Jšžœ
˜—šœHžœ˜MJšœ*žœ˜/Jšœ*žœ˜0—J˜Jšžœ
˜—J˜J˜—š œžœ
žœžœ
žœžœ˜QJš
œ7˜7Jšœžœ
˜Jšžœžœ
žœ
žœ
˜šžœž˜J˜Jšœžœ
˜Jš
œ:˜:Jšžœžœ
žœ
˜&Jš	œžœžœ(žœžœ
˜WJšžœžœ
žœ1˜>Jšžœžœ˜+J˜Jšžœ
˜—J˜J˜—š 
œžœ
žœžœSžœžœ
žœžœ˜
Jš
œ7˜7J˜šžœž˜˜Jš
œ:˜:Jš
œ˜Jš
œA˜AJš
œ˜šžœž˜š
œ˜šžœžœ$ž˜5Jš
œ/˜/—Jš
œ%˜%J˜—Jšžœ˜	—J˜—Jšžœ
˜—J˜—J˜š œžœžœ žœ˜XJšžœž˜J˜J™šžœžœ˜Jšœžœ
˜šœžœ˜'Jšœžœ%˜=šœžœ
žœ
˜Jš
œ(˜(Jš
œ-˜-——šœžœ˜.Jšœžœ
˜Jš
œB˜BJšœž	œ&˜6Jš
œ˜—Jšœ;žœ˜^J˜—šžœžœžœ
ž˜8Jš
œj˜j—šžœ˜šœžœž˜9Jšœ*žœ
˜>—Jšœžœ ˜.J˜—š	žœ
žœ
žœ
žœž˜1š
œ˜Jš
œC˜CJšœžœ
˜$J˜—Jšžœ
˜—Jš
œ˜J˜Jšžœ
˜J˜J˜—šœžœ˜'Jšœžœ
˜J˜J˜—šœžœ˜&Jšœžœ˜%Jš
œ˜Jšžœžœ
žœ!˜.Jšžœžœ
žœ
žœ
˜Jšœ	žœ5˜DJšžœžœ
žœ
žœ
˜šžœžœ
ž˜)Jšœ8žœ
˜A—Jš
žœžœ
žœ$žœžœ˜SJ˜J˜—š œ˜)Jšœžœ
˜Jš
žœ	žœ
žœ(žœ	žœ
˜KJš
œ)˜)Jš
œ+˜+šžœ	žœ
žœ(˜;Jšœ
Ÿ+˜5JšœŸ˜#J˜—J˜—J˜J˜(Jšœžœ˜"J˜š œ˜&š
ž˜JšžœBžœ˜T—˜
J˜Jš
œZ˜ZJ˜—š
œ7˜7J˜;—Jšžœžœ
žœ
˜Jš
œ1˜1Jš
œ/˜/˜"J˜J˜J˜—J˜¦
Jšœ2žœ˜NJšœžœ
˜š
ž˜JšœKžœ˜U—J˜—J˜Jš
œ—
˜—
š
œ*˜*Jš
œZ˜Z—J˜Icode™™'K™	KšœΟrJ™V—™&K™—™'K™K™K™!K™2Kšœ’F™RKšœ’5™AKšœ’™Kšœ’$™0—K™—…—fΦ‘›