DIRECTORY
IO,
Commander USING [ CommandProc, Register ],
Lark USING [ bStar, bThorp, ConnectionSpec, CommandEvent, CommandEvents, CommandEventSequence, Device, disabled, EchoParameters, EchoParameterRecord, enabled, endNum, Event, KeyTable, Milliseconds, o3i1, o2i2, o1i1, Passel, reset, SHHH, StatusEvent, Tone, ToneSpec, ToneSpecRec ],
LarkPlay USING [ ToneList, ToneSpec, ToneSpecRec ],
LarkSmarts,
Log USING [ ProblemFR, Report, SLOG ],
Nice,
Process USING [ Detach, EnableAborts, MsecToTicks, SetTimeout ],
Rope USING [ Fetch, Length, ROPE ],
RPC USING [ CallFailed ], 
ThNet USING [ pd ],
ThPartyPrivate USING [ SmartsData ],
Thrush USING[ H, pERROR, ROPE, SHHH, SmartsHandle, ThHandle ],
ThSmartsPrivate USING [
ConvDesc, GetConvDesc, HookState, LarkInfo, LarkState, LarkStateSpec, LSwitches, LState, ProgressTones, SmartsInfo, TerminalType   ],
TU USING [ RefAddr ]
;

LarkOutImpl: CEDAR MONITOR LOCKS info USING info: LarkInfo
IMPORTS
Commander, IO, Log, Nice, Process, Rope, RPC, ThNet, Thrush, ThSmartsPrivate, TU
EXPORTS ThSmartsPrivate= {
OPEN IO;


ConvDesc: TYPE = ThSmartsPrivate.ConvDesc;
H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; };
LarkInfo: TYPE = ThSmartsPrivate.LarkInfo;
LarkState: TYPE = ThSmartsPrivate.LarkState;
SmartsData: TYPE = ThPartyPrivate.SmartsData;
SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;
SmartsHandle: TYPE = Thrush.SmartsHandle;
TerminalType: TYPE = ThSmartsPrivate.TerminalType;
ROPE: TYPE = Thrush.ROPE;
firstTone: LarkState = FIRST[ThSmartsPrivate.ProgressTones];
bStar: Lark.Event = Lark.bStar;
bThorp: Lark.Event = Lark.bThorp;
enabled: Lark.Event = Lark.enabled;
endNum: Lark.Event = Lark.endNum;
disabled: Lark.Event = Lark.disabled;
reset: Lark.Event = Lark.reset;
larkRegistry: ROPE _ ".Lark";

PD: TYPE = RECORD [
waitForTelco: CARDINAL _ 500,
telcoMinOn: CARDINAL _ 60,
telcoMinOff: CARDINAL _ 60,
flashWaitTime: CARDINAL _ 800,
idleWaitTime: CARDINAL _ 20000, -- time for supervisor to wait for more events.
backDoorOH: BOOL_FALSE,
callTimeoutOK: BOOL_FALSE, -- set to keep Thrush alive when debugging a Lark.
echoControl: BOOL_TRUE,
tonesInvalid: BOOL_TRUE,
tonesLast: BOOL_TRUE -- sets up alternate lark setup situation in supervisor loop
];
pd: REF PD _ NEW[PD_[]];

dialTone: LarkPlay.ToneSpec _ NIL;
busyTone: LarkPlay. ToneSpec _ NIL;
errorTone: LarkPlay.ToneSpec _ NIL;
ringbackTone: LarkPlay.ToneSpec _ NIL;
quenchSpec: Lark.ToneSpec _ NEW[Lark.ToneSpecRec _[volume: 0, totalTime: 0, tones: LIST[[0,0,0,0]]]];


EnterLarkState: PUBLIC ENTRY PROC[ info: LarkInfo, newState: LarkState, sInfo: SmartsInfo ] = {
ENABLE UNWIND=>NULL;
EnterLarkSt[info, newState, sInfo];
};

EnterLarkSt: PUBLIC INTERNAL PROC[ info: LarkInfo, newState: LarkState, sInfo: SmartsInfo ]={
ENABLE UNWIND=>NULL;
newSpec: LIST OF ThSmartsPrivate.LarkStateSpec = LIST[[newState, sInfo]];
trans: LSTrans _ lsTrans[info.larkState][newState];
oldState: LarkState = info.larkState;
cDesc: ConvDesc_NIL;
keyTable: Lark.KeyTable;
spec: Lark.ConnectionSpec;
sw: BOOL_FALSE;
echoAction: REF_NIL;
toneSpec: LarkPlay.ToneSpec _ NIL;
IF pd.tonesInvalid THEN SetTones[];
SELECT trans FROM
nop => RETURN; -- Certifiably nothing at all to do, or inappropriate time to do it.
set => { info.larkState_newState; RETURN; };
X => { LarkProblem["%g: Invalid LarkState Transition", sInfo]; RETURN; };
rec => { info.larkState_recovering; LarkFailed[sInfo]; --RETURN--};
fai => {
info.larkState _ failed;  LarkProblem["%g: Lark failure requested by server", sInfo]; 
info.larkProcess _ NIL;
NOTIFY info.stateChange; -- Be sure process notices failure and disappears.
RETURN;
};
ENDCASE;
info.larkState_newState;
IF sInfo#NIL THEN cDesc _ ThSmartsPrivate.GetConvDesc[sInfo];
IF cDesc#NIL THEN {
IF cDesc.newKeys THEN keyTable _ cDesc.cState.keyTable;
IF cDesc.newSpec THEN spec _ cDesc.cState.spec;
};
SELECT tDisconn[trans] FROM
disconnect => {
IF ThNet.pd.debug THEN Deb[ info, 'd ];
QueueLarkAction[info, aDisconnect, sInfo];
};
ENDCASE;
toneSpec _ SELECT trans FROM
dia, diu => dialTone, -- to handset receiver
rbk, rbu => IF info.ringTune#NIL THEN info.ringTune ELSE ringbackTone,
bzy, bzu => busyTone,
err, eru => errorTone,
rng, rgu => info.ringTune,
ENDCASE => NIL
;
SELECT tDoTones[trans] FROM
doTones => {
IF ThNet.pd.debug THEN Deb[ info, 'T ];
IF toneSpec#NIL THEN QueueLarkAction[info, toneSpec, sInfo];
};
stopTones => { IF ThNet.pd.debug THEN Deb[ info, 't ]; QueueLarkAction[info, aNoTones, sInfo]; };
ENDCASE;
SELECT tHookState[trans] FROM
reset => SELECT info.hookState FROM
spkr, monitor => { info.hookState_onhook; info.terminalType_std; }; -- going totally idle
ENDCASE;
spkrTrans => IF info.hookState=onhook THEN {-- dialtone, direct connect or ringback, Hafra
info.hookState _ spkr; info.terminalType _ IF sInfo.larkInfo.radio THEN radio ELSE spkr; };
ENDCASE; -- no state change cases.
sw_FALSE;
IF info.terminalType#info.lastTerminalType THEN sw_TRUE;
SELECT tSwitch[trans] FROM
switch => sw_TRUE;
switchIfDiff => IF oldState<firstTone OR newState<firstTone THEN sw_TRUE;
ENDCASE;
IF sw THEN TRUSTED {
IF ThNet.pd.debug THEN Deb[info, 'M, rope[larkCommands[info.terminalType][newState]]];
echoAction _ QueueCommandSequence[info,
larkCommands[info.terminalType][newState], @info.lState, info.scratchEv, sInfo];
IF trans=fls THEN {
Process.Detach[FORK FlashWait[info, sInfo]];
info.larkState _ trunkTalking; -- never really enter fls state.
};
info.lastTerminalType _ info.terminalType;
};
SELECT trans FROM
sgl, sgn =>  {
IF ThNet.pd.debug THEN Deb[info, 'F];
QueueLarkAction[info, RopeToDTMF[sInfo.phoneNumber], sInfo];
};
ENDCASE;
IF keyTable#NIL THEN SELECT tSetKey[trans] FROM
setKey => {
IF ThNet.pd.debug THEN Deb[info, 'K];
cDesc.newKeys_FALSE;
QueueLarkAction[info, keyTable, sInfo];
};
ENDCASE;
IF spec#NIL THEN SELECT trans FROM
sup, spn, tlk, frd, frn => {
IF ThNet.pd.debug THEN Deb[info, 'C,
int[LOOPHOLE[spec.localSocket.socket]],
int[LOOPHOLE[spec.remoteSocket.socket]],
card[spec.remoteSocket.net], card[spec.remoteSocket.host]];
cDesc.newSpec_FALSE;
QueueLarkAction[info, spec, sInfo];
};
ENDCASE;
IF echoAction#NIL THEN {
IF ThNet.pd.debug THEN Deb[info, 'E];
QueueLarkAction[info, echoAction, sInfo];
};
IF info.newActions=NIL THEN RETURN;
Log.SLOG[100000B];
};

LarkFailed: PUBLIC ERROR [sInfo: SmartsInfo] = CODE;

TonesDone: PUBLIC INTERNAL PROC[info: LarkInfo, commandEvent: Lark.StatusEvent, sInfo: SmartsInfo ] = {
Deb[info, 'z];
QueueLarkAction[info, NEW[ATonesDoneType _ [commandEvent.event]], sInfo];
};

FlashWait: PUBLIC ENTRY PROC[info: LarkInfo, sInfo: SmartsInfo ] = TRUSTED {
ENABLE UNWIND => NULL;
flashWait: CONDITION;
IF info=NIL THEN RETURN;
Process.SetTimeout[@flashWait, Process.MsecToTicks[pd.flashWaitTime]]; -- 600 ms or so.
Deb[info, 'w];
WAIT flashWait;
Deb[info, 'W];
IF info.larkState=trunkTalking THEN -- nothing has gone wrong
[]_QueueCommandSequence[info,
larkCommands[info.terminalType][info.larkState], @info.lState, info.scratchEv, sInfo];
};


LarkSupervisor: PROCEDURE[ info: LarkInfo, sInfo: SmartsInfo ] = {
ENABLE UNWIND => NULL;
toneSpec: LarkPlay.ToneSpec_NIL;
nextToneList: LIST OF LarkPlay.ToneList _ NIL;
larkToneSpec: Lark.ToneSpec _
NEW[Lark.ToneSpecRec _ [volume: 0, totalTime: 0, tones: NIL]];
req: REF;

FailE: ENTRY PROC[info: LarkInfo] = {Fail[info];};
Fail: INTERNAL PROC[info: LarkInfo] = {
IF info.larkState#recovering THEN info.larkState_failed; };

WaitForAction: ENTRY PROC[info: LarkInfo] RETURNS [ref: REF_NIL] = TRUSTED {
ENABLE UNWIND=>NULL;
DO
elt: LIST OF REF _ info.newActions;
IF info.larkState=failed OR info.larkState=recovering THEN RETURN[NIL];
IF elt # NIL THEN {
ref_elt.first;
info.newActions _ elt.rest;
RETURN[ref];
};
Process.SetTimeout[@info.stateChange, Process.MsecToTicks[pd.idleWaitTime]];
WAIT info.stateChange;
IF info.newActions = NIL THEN {
IF nextToneList#NIL THEN Fail[info]; -- Notification is late.
RETURN[NIL];
};
ENDLOOP;
};

TRUSTED { Process.EnableAborts[@info.stateChange]; };
WHILE (req_WaitForAction[info])#NIL  DO
-- Deal with communications failure.
ENABLE {
RPC.CallFailed => IF pd.callTimeoutOK THEN RESUME ELSE {
LarkProblem["%g: Call Failed", sInfo]; GOTO Failed; };
ABORTED => {
LarkProblem["%g: LarkSupervisor aborted", sInfo]; GOTO Failed; };
};

DoTones: PROC[newTones: BOOL] = { -- Does one tone from current list of tones
IF nextToneList=NIL THEN RETURN;
Log.SLOG[100000B];
larkToneSpec.volume _ toneSpec.volume;
info.expectedNotification _
IF info.expectedNotification='z THEN 'a ELSE info.expectedNotification+1;
larkToneSpec.notification _ [tones, info.expectedNotification];
larkToneSpec.tones _ nextToneList.first;
[]_info.interface.SpecifyTones[shh: info.shh, queueIt: ~newTones, tones: larkToneSpec];
};

Log.SLOG[100000B];
WITH req SELECT FROM
d: REF ADisconnectType => {
info.interface.Disconnect[ shh: info.shh, buffer: out1];
info.interface.Disconnect[ shh: info.shh, buffer: in1];
};
ts: LarkPlay.ToneSpec => {
toneSpec_ts;
nextToneList _ toneSpec.tones;
DoTones[TRUE];
};
td: REF ATonesDoneType => IF toneSpec#NIL THEN {
IF td.event#info.expectedNotification THEN GOTO Failed;
IF nextToneList#NIL AND nextToneList.rest#NIL THEN
nextToneList _ nextToneList.rest
ELSE IF NOT toneSpec.repeatIndefinitely THEN { toneSpec_NIL; nextToneList_NIL }
ELSE nextToneList _ toneSpec.tones;
IF nextToneList#NIL THEN DoTones[FALSE];
};
a: REF ANoTonesType => {
toneSpec_NIL; 
nextToneList_NIL; 
quenchSpec.tones.first.on _ 0;
[]_info.interface.SpecifyTones[shh: info.shh, tones: quenchSpec, queueIt: FALSE];
};
echoParameters: Lark.EchoParameters =>
[]_info.interface.EchoSupression[shh: info.shh, echo: echoParameters];
commands: Lark.CommandEvents =>
IF commands#NIL THEN
IF commands[0].device=touchPad THEN  {
quenchSpec.tones.first.on _ pd.waitForTelco;
[]_info.interface.SpecifyTones[shh: info.shh, tones: quenchSpec, queueIt: FALSE];
[]_info.interface.Feep[shh: info.shh, on: pd.telcoMinOn, off: pd.telcoMinOff, notify: [tones, 'F],
 waveTable: ThNet.pd.feepVolume, queueIt: TRUE, events: commands];
}
ELSE info.interface.Commands[ info.shh, commands ];
keyTable: Lark.KeyTable => info.interface.SetKeyTable[shh: info.shh, table: keyTable];
spec: Lark.ConnectionSpec => {
Log.SLOG[100000B];
spec.buffer _ out1;
info.interface.Connect[shh: info.shh, specs: spec ]; 
spec.buffer _ in1;
info.interface.Connect[shh: info.shh, specs: spec ];
}; 
ENDCASE;
REPEAT Failed => { FailE[info]; };
ENDLOOP;
info.larkProcess _ NIL;
};

QueueLarkAction: INTERNAL PROC[info: LarkInfo, ref: REF, sInfo: SmartsInfo] = {
elt: LIST OF REF = LIST[ref];
lst: LIST OF REF = info.lastAction;
Log.SLOG[100000B];
IF info.newActions=NIL THEN info.newActions _ elt ELSE IF lst=NIL THEN Thrush.pERROR ELSE lst.rest _ elt;
info.lastAction _ elt; 
IF info.larkProcess=NIL THEN TRUSTED {
Process.Detach[info.larkProcess _ FORK LarkSupervisor[ info, sInfo ]]; };
NOTIFY info.stateChange;
};


LarkProblem: PROC[remark: ROPE, sInfo: SmartsInfo] = {
Log.ProblemFR[remark, $Lark, sInfo.larkInfo, TU.RefAddr[sInfo]];
};

QueueCommandSequence: INTERNAL PROC[
info: LarkInfo, commands: ROPE,
lState: LONG POINTER TO LState, scratchEv: Lark.CommandEvents, sInfo: SmartsInfo]
RETURNS[echoAction: REF_NIL]= TRUSTED {
eventIndex: INTEGER_-1;
c: CHAR;
i: NAT;
index: INTEGER;
event: Lark.Event;
events: Lark.CommandEvents _ scratchEv;
nextState: LState _ [echoStyle: '0];
len: NAT;
echoAction _ echosOff[lState.echoStyle];
IF commands=NIL THEN RETURN; -- status quo
len _ commands.Length[];
FOR i IN [0..len) DO
SELECT (c_commands.Fetch[i]) FROM 'J, 'j => IF ~pd.backDoorOH THEN LOOP; ENDCASE;
SELECT c FROM
'Z => { lState.xbar_ALL[0]; lState.lSw _ ALL[Lark.enabled]; event _ Lark.reset; };
'X, 'x => {
row: NAT_ Digit[commands.Fetch[i+1]];
outputs: PACKED ARRAY [0..8) OF BOOLEAN _ LOOPHOLE[nextState.xbar[row]];
outputs[Digit[commands.Fetch[i+2]]] _ (c='X);
nextState.xbar[row] _ LOOPHOLE[outputs];
i_i+2;
LOOP;
};
'E, 'e => {
nextState.echoStyle _ commands.Fetch[i_i+1];
echoAction _ echosOn[nextState.echoStyle];
};
'M, 'm => {
nextState.voiceMode _ SELECT commands.Fetch[i_i+1] FROM
'0 => Lark.o3i1,
'1 => Lark.o2i2,
'2 => Lark.o1i1,
ENDCASE => ERROR;
};
ENDCASE=> {
IF c IN ['a..'z] THEN { event _ Lark.disabled; c_c-('a-'A); }
ELSE event _ Lark.enabled;
IF lStateForLetter[c]#none THEN nextState.lSw[lStateForLetter[c]] _ event;
};
ENDLOOP;
IF nextState=lState^ THEN RETURN [NIL];
IF nextState.echoStyle=lState.echoStyle OR ~pd.echoControl THEN echoAction_NIL;
FOR iteration: NAT IN [0..1] DO -- 0: compute size; 1: fill in result sequence.
index_-1;
IF nextState.voiceMode#lState.voiceMode THEN
events[index_index+1] _ [voiceMode, nextState.voiceMode];
FOR i: LSwitches DECREASING IN LSwitches DO IF nextState.lSw[i]#lState.lSw[i] THEN
events[index_index+1] _ [lDevs[i], nextState.lSw[i]]; ENDLOOP;
FOR i: NAT IN [0..8) DO IF nextState.xbar[i]#lState.xbar[i] THEN {
outputs: PACKED ARRAY[0..8) OF BOOLEAN = LOOPHOLE[lState.xbar[i]];
nxtOutputs: PACKED ARRAY[0..8) OF BOOLEAN = LOOPHOLE[nextState.xbar[i]];
FOR j: NAT IN [0..8) DO IF outputs[j]#nxtOutputs[j] THEN
events[index_index+1] _ [
Lark.Device[LOOPHOLE[IF nxtOutputs[j] THEN 23 ELSE 22]],
LOOPHOLE[i*16+j] ];
ENDLOOP;
}; ENDLOOP;
IF index=-1 THEN { events_NIL; EXIT; };
IF iteration=0 THEN events _ NEW[Lark.CommandEventSequence[index+1]]; ENDLOOP;
QueueLarkAction[info, events, sInfo];
lState^ _ nextState;
lState.lSw[xBarAll] _ Lark.disabled;
};

Digit: PROC[c: CHAR] RETURNS [digit: NAT] = INLINE { RETURN[c-'0]; };

RopeToDTMF: PROC [r: Thrush.ROPE] RETURNS [ce: Lark.CommandEvents] = {
len: INT _ MIN[Lark.Passel.LAST, r.Length[]];
ce _ NEW[Lark.CommandEventSequence[len]];
FOR j: INT IN [0..ce.length) DO
c: CHAR = r.Fetch[j];
ce.e[j] _ [touchPad, SELECT c FROM
IN ['0..'9] => LOOPHOLE[128 + c - '0],
IN ['a..'d] => LOOPHOLE[138 + c - 'a],
IN ['\001..'\037] => LOOPHOLE[LOOPHOLE[c,INTEGER]*10], -- 100 ms. pauses, 12-14 illegal!
'* => Lark.bStar,
'# => Lark.bThorp,
ENDCASE => Lark.bStar];
ENDLOOP;
};

SetTones: INTERNAL PROC[] = {
IF ~pd.tonesInvalid THEN RETURN;
pd.tonesInvalid _ FALSE;
dialTone _ NEW[LarkPlay.ToneSpecRec _ [repeatIndefinitely: TRUE,
volume: ThNet.pd.tonesVolume, tones: LIST[LIST[
[f1: 350, f2: 440, on: 5000, off: 0],
[f1: 350, f2: 440, on: 5000, off: 0]]]]]; 
busyTone _ NEW[LarkPlay.ToneSpecRec _ [repeatIndefinitely: TRUE,
volume: ThNet.pd.tonesVolume, tones: LIST[LIST[
[f1: 480, f2: 620, on: 500, off: 500, repetitions: 5],
[f1: 480, f2: 620, on: 500, off: 500, repetitions: 5]]]]]; 
errorTone _ NEW[LarkPlay.ToneSpecRec _ [repeatIndefinitely: TRUE,
volume: ThNet.pd.tonesVolume, tones: LIST[LIST[
[f1: 480, f2: 620, on: 250, off: 250, repetitions: 10],
[f1: 480, f2: 620, on: 250, off: 250, repetitions: 10]]]]]; 
ringbackTone _ NEW[LarkPlay.ToneSpecRec _ [repeatIndefinitely: TRUE,
volume: ThNet.pd.tonesVolume, tones: LIST[LIST[
[f1: 440, f2: 480, on: 2000, off: 4000],
[f1: 440, f2: 480, on: 2000, off: 4000]]]]]; 
};

Deb: PROC[info: LarkInfo, c: CHAR, p1, p2, p3, p4: IO.Value_[null[]]] = {
s: IO.STREAM;
IF ~ThNet.pd.debug THEN RETURN;
s_IO.ROS[];
s.PutF["<%g", char[c]];
SELECT c FROM
'M => s.PutF["-- %g", p1];
'C => {
s.PutF[" -- [%b, %b]", p3, p4];
s.PutF[" %b(%d), %b(%d)", p1, p1, p2, p2];
};
ENDCASE;
s.PutRope[">\r"];
Log.Report[s.RopeFromROS[], $LarkDetailed, info];
};
QuickState: ARRAY LarkState OF IO.Value = [
rope["none"], rope["idle"], rope["talking"], rope["trunkSignalling"],
rope["trunkTalking"], rope["trunkForwarding"], rope["trunkFlashing"], rope["failed"], rope["recovering"], rope["ringing"], rope["silence"],
rope["dialTone"], rope["ringBack"], rope["busyTone"], rope["errorTone"]];


toneStdCommand: ROPE = "SX01X14X06";
toneSpkrCommand: ROPE = "LSX03X14X06";
toneMonitorCommand: ROPE = "SX01X03X14X06";
silentSignalling: ROPE _ "HIX02X14";
noisySignalling: ROPE _ "HISTX02X10X21X26X14"; -- same as trunk talking (feedback problems?)
noisierSignalling: ROPE _ "HITLX02X30X23X26X24"; -- same as spkr trunk talking (feedback problems?)
trunkSignalling: ROPE _ silentSignalling;


larkCommands: ARRAY TerminalType OF ARRAY LarkState OF ROPE _ [
[  NIL, -- none
"ZE4", -- idle
"SX01X06X10X14", -- talking
trunkSignalling, -- trunkSignalling
"HISTX02X10X21X26X14",	-- trunkTalking, codec-assisted electronic mode
"E3HIX02X20X24", -- trunkForwarding, trunk to remote Lark connection. (need gain setting for echo?)
"Z", -- trunkFlashing, on-hook for a second.
"Z", -- failed
"Z", -- recovering
"RX03X06", -- ringing
"SX14", -- silence
toneStdCommand, toneStdCommand, toneStdCommand, toneStdCommand -- tones
],
[  NIL, -- none
"ZE4", -- idle
"E1LX03X06X30X14", -- talking
"HIX02X14X06", -- trunkSignalling
"E2M1THILX30X02X25X26X24X53",	-- trunkTalking, gain-controlled digital mode
"E3HIX02X20X24", -- trunkForwarding; device stuff for this mode doesn't have much meaning.
"Z", -- trunkFlashing, on-hook for a second.
"Z", -- failed
"Z", -- recovering
"RX03X06", -- ringing
"LX14", -- silence
toneSpkrCommand, toneSpkrCommand, toneSpkrCommand, toneSpkrCommand -- tones
],
[  NIL, -- none
"Z", -- idle
"SX01X03X06X10X14", -- talking
"HIX02X14X06", -- trunkSignalling
"HISTLX02X10X21X23X14X26",	-- trunkTalking, codec-assisted electronic mode
"E3HIX02X20X24", -- trunkForwarding, trunk to remote Lark connection. (meaning?)
"Z", -- trunkFlashing, on-hook for a second.
"Z", -- failed
"Z", -- recovering
"RX03X06", -- ringing
"SX14", -- silence
toneMonitorCommand, toneMonitorCommand, toneMonitorCommand, toneMonitorCommand -- tones
],
[  NIL, -- none
"Z", -- idle
"SX01X06X60X14", -- talking
"HIX02X14X06", -- trunkSignalling
"Z",	-- trunkTalking
"E3HIX02X20X24", -- trunkForwarding, trunk to remote Lark connection. (meaning?)
"Z",	-- trunkFlashing
"Z", -- failed
"Z", -- recovering
"RX03X06", -- ringing
"SX14", -- silence
toneStdCommand, toneStdCommand, toneStdCommand, toneStdCommand -- tones
]
];

echoStyleFD: REF _ NEW[Lark.EchoParameterRecord _[
buffer: out1,
buffer2Controlled: FALSE,
buffer1Controlled: TRUE,
decayTime: 5,
gain: [ 1024, 2048, 2048, 2048, 32767 ]
]];
echoStyleFwd: REF _ echoStyleFD;

echoStyleBD: REF _ NEW[Lark.EchoParameterRecord _[
buffer: in2,
buffer2Controlled: FALSE,
buffer1Controlled: TRUE,
decayTime: 10,
gain: [ 2048, 4096, 8192, 16384, 32767 ]
]];

echoStyleNoFD: REF _ NEW[Lark.EchoParameterRecord _[
buffer: out1, -- not interesting
buffer2Controlled: FALSE,
buffer1Controlled: FALSE,
decayTime: 0,
gain: [ 0, 0, 0, 0, 0 ]
]];
echoStyleNoFwd: REF _ echoStyleNoFD;

echoStyleNoBD: REF _ NEW[Lark.EchoParameterRecord _[
buffer: in2, -- not interesting
buffer2Controlled: FALSE,
buffer1Controlled: FALSE,
decayTime: 0,
gain: [ 0, 0, 0, 0, 0 ]
]];

echosOn: ARRAY CHAR['0..'4] OF REF_[ NIL, echoStyleFD, echoStyleBD, echoStyleFwd, NIL ];
echosOff: ARRAY CHAR ['0..'4] OF REF_[ NIL, echoStyleNoFD, echoStyleNoBD, echoStyleNoFwd, echoStyleNoFD ];


LSwitches: TYPE = ThSmartsPrivate.LSwitches;
LState: TYPE = ThSmartsPrivate.LState;
lDevs: ARRAY LSwitches OF Lark.Device = [
crossBar, offHookRelay, aRelay, sideTone, ringEnable, revertRelay, revertHookswitch, led, spMode, crossBar--random...not used-- ];
lStateForLetter: ARRAY CHAR['A..'Z] OF LSwitches = [
none, none, none, none, none, -- A to E
revert, revertHook, hook, aSwitch, hook, none, led, -- F to L
none, none, none, none, none, -- M to Q
ringO, sideTone, spMode, none, none, none, none, none, -- R to Y
xBarAll  -- Z --
];

LSTrans: TYPE = {
nop, -- nothing to do
set, -- enter specified state (usu. step to recovery) without taking any other actions.
zap, zpu, zpn, -- reset Lark hardware (u means unconnect first, n means silence tones first)
trk, tkn, -- Set for electronic phone connection (n means silence tones first)
frd, frn, -- Trunk-to-network forwarding versions of trk, tkn (frn probably doesn't exist; wrong end <<Sep. FD/BD>>)
tlk, -- like supervision, but must also adjust switching.
sup, spn, -- supervision, OK to change connection, key table. (n means silence tones first)
ksp, -- key supervision, OK to change key table.
sgl, sgn, -- Do trunk signalling (n means silence tones first)
fls, -- Flash the phone line
rng, rgu, -- Set for ringing (u means unconnect first, r means repeating tone)
dia, diu, -- Set for dial tone (tones should be more generic and user-programmable than this!)
rbk, rbu, -- Set for ring back
bzy, bzu, -- Set for busy tone
err,  eru, -- Set for error tone
sil, -- silence tones, ksp obtains
fai, -- enter failed state, by Smarts-level request.  Don't complain, just do it.  Make sure process goes away.
rec, --  move from failed state to recovering state, but complain to caller that Lark has failed, via signal.
X -- invalid transition; complain, then remain in present state (go idle?)
};

lsTrans: ARRAY LarkState OF ARRAY LarkState OF LSTrans = [[
nop, zap, X,   X,   X,   X,   X,   X,   X,   X,   X,   X,   X,   X,   X   ],[-- non (none)
X,   nop, spn, sgl, trk, frd, X,   fai, X,   rng, nop, dia, rbk, bzy, err ],[-- idl (idle)
X,   zpu, sup, X,   X,   X,   X,   fai, X,   rgu, nop, diu, rbu, bzu, eru ],[-- tlk (talking)
X,   zpn, X,   ksp, trk, frd, X,   fai, X,   X,   nop, X,   X,   X,   X   ],[-- sig (trkSignalling)
X,   zap, X,   X,   ksp, X,   fls, fai, X,   X,   nop, X,   X,   X,   X   ],[-- trk (trkTalking)
X,   zpu, X,   X,   X,   sup, X,   fai, X,   X,   nop, diu, rbu, bzu, eru ],[-- fwd (trkForwarding)
X,   zap, X,   X,   trk, X,   sup, fai, X,   X,   nop, X,   X,   X,   X   ],[-- fls (trkFlash)
set, rec, rec, rec, rec, rec, rec, set, set, rec, rec, rec, rec, rec, rec ],[-- fai (failed)
set, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop ],[-- rec (recovering)
X,   zpn, spn, sgn, tkn, frn, X,   fai, X,   ksp, sil, dia, rbk, bzy, err ],[-- rng (ringing)
X,   zap, tlk, sgl, trk, frd, X,   fai, X,   rng, ksp, dia, rbk, bzy, err ],[-- shh (silence)
X,   zpn, spn, sgn, tkn, frn, X,   fai, X,   rng, sil, ksp, rbk, bzy, err ],[-- dia (dialTone)
X,   zpn, spn, sgn, tkn, frn, X,   fai, X,   rng, sil, dia, ksp, bzy, err ],[-- rbk (ringBack)
X,   zpn, spn, sgn, tkn, frn, X,   fai, X,   rng, sil, dia, rbk, ksp, err ],[-- bzy (busyTone)
X,   zpn, spn, sgn, tkn, frn, X,   fai, X,   rng, sil, dia, rbk, bzy, ksp ]  -- err (errorTone)
];

TDisconn: TYPE = { X, disconnect };
tDisconn: ARRAY LSTrans OF TDisconn = [ -- zpu, rgu, diu, rbu, bzu, eru
X, X, X, disconnect, X, X, X,  X, X, X, X, X, X, X, X,  X, X, disconnect, X,  disconnect, X, disconnect, X, disconnect,  X, disconnect, X, X, X, X ];

TDoTones: TYPE = { X, doTones, stopTones };
tDoTones: ARRAY LSTrans OF TDoTones = [ -- rng, rgu,   dia, diu,   rbk, rbu,   bzy, bzu,   err, eru;    zpn, tkn, spn, sgn, sil
X, X, X, X, stopTones, X, stopTones,  X, X, X, X, stopTones, X, X, stopTones,  X, doTones, doTones, doTones,  doTones, doTones, doTones, doTones, doTones,  doTones, doTones, stopTones, X, X, X ];

THookState: TYPE = { X, reset, spkrTrans };
tHookState: ARRAY LSTrans OF THookState = [ -- zap, zpu, zpn;   trk, tkn, tlk, spn, fls, dia, diu, rbk, rbu, bzy, bzu, err, eru, sil
X, X, reset, reset, reset, spkrTrans, spkrTrans,  X, X, spkrTrans, X, spkrTrans, X, X, X,  spkrTrans, X, X, spkrTrans,  spkrTrans, spkrTrans, spkrTrans, spkrTrans, spkrTrans,  spkrTrans, spkrTrans, spkrTrans, X, X, X ];

TSwitch: TYPE = { X, switch, switchIfDiff };
tSwitch: ARRAY LSTrans OF TSwitch = [-- zap, zpu, zpn, trk, tkn, frd, frn, tlk, spn, sgl, sgn, fls;  rng, rgu, dia, diu, rbk, rbu, bzy, bzu, err, eru
X, X, switch, switch, switch, switch, switch,  switch, switch, switch, X, switch, X, switch, switch,  switch, switchIfDiff, switchIfDiff, switchIfDiff,  switchIfDiff, switchIfDiff, switchIfDiff, switchIfDiff, switchIfDiff,  switchIfDiff, switchIfDiff, switch, X, X, X ];

TSetKey: TYPE = { X, setKey };
tSetKey: ARRAY LSTrans OF TSetKey = [
-- trk, tkn, frd, frn, tlk, sup, spn, ksp, sgl, sgn, fls, rng, rgu, dia, diu, rbk, rbu, bzy, bzu, err, eru, sil
X, X, X, X, X, setKey, setKey,  setKey, setKey, setKey, setKey, setKey, setKey, setKey, setKey,  setKey, setKey, setKey, setKey,  setKey, setKey, setKey, setKey, setKey,  setKey, setKey, setKey, X, X, X ];


ADisconnectType: TYPE = { aDisconnect };
aDisconnect: REF ADisconnectType _ NEW[ADisconnectType_aDisconnect];

ANoTonesType: TYPE = { aNoTones };
aNoTones: REF ANoTonesType _ NEW[ANoTonesType_aNoTones];

ATonesDoneType: TYPE = RECORD [
event: Lark.Event
];

ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[pd, "Lark Out PD"];
};
Commander.Register["VuLarkOut", ViewCmd, "Program Management variables for Lark Output"];
}.

€LarkOutImpl.mesa 
Last modified by D. Swinehart, January 13, 1985 12:57:56 pm PST
Actual hardware interface to Lark; includes process to keep tones going and eventually to deal with failure.
Last Edited by: Pier, May 10, 1984 1:30:18 pm PDT
Declarations
<<Presently not used.>>
External  Procedures
Each select statement combines cases to execute a subset of the required actions efficiently.
When leaving talking state but not going idle, must explicitly take down Ethernet connection.
Does this ever happen?
Queue up request to eliminate connections.
Select tone/tune specifications.
Go offhook and enter speakerphone mode if noises need to be heard and phone isn't offhook
Go back onhook when idling from spkr (not sPkr) or monitor mode.
<<Alternative: leave it in state fls until now.>>
Internal  Procedures
In a loop, keep the state of the Lark up to date.  Awakens itself whenever any pending
tone is otherwise likely to time out.  Awakened by EnterLarkState whenever the state
of tones, switches, and the like might have to change.
sInfo is the SmartsInfo in use when the process was initiated.  It's used to report errors, but bear in mind that it may or may not be the one in effect when a particular complaint occurs.
Connect output buffer
Queue is a FIFO list of REFs, with a lastAction pointer to aid in rapid enqueuing. 
Hardware Switching Tables
Interpretation of the command string characters:
En-- echo mode; n IN [0..3); selects echoStyleStd (default), ...FD, ...BD, or ...Fwd
F -- T/R lead reversion
G -- A/A1 hookswitch control reversion
H -- Assert Telewall hookswitch
I -- Assert A/A1 to Telewall
J -- Assert Telewall hookswitch, maybe (depends on boolean variable)
L -- Lights led
R -- overrides volume control for ringing through speaker
S -- enables telset sidetone
T -- spMode; configures codecs for electronic trunk action
Xij -- connects crossbar input i to output j
Mn -- voiceMode; n IN [0..2); selects program O3I1 (default), O2I2, or O1I1
Z -- Resets hardware and crossbar
Crossbar Connections:
Port	Input	Output
0	dec1	co1
1	Xmtr	Rcvr
2	from Telewall	to Telewall
3	mike	speaker
4	silence	DTMF receiver
5	dec2	co2
6	line 1 out	line 1 in
7	line 2 out	line 2 in
Telset
"STX02X10X21X26X14", -- trunkFlashing, on-hook but otherwise unchanged.
Speakerphone
"TLX02X30X23X26X24",	-- trunkFlashing
Monitoring Telset
"STLX10X21X23X14X26",	-- trunkFlashing
Radio Input, Telset/radio monitoring
"STLX10X21X23X14X26",	-- trunkFlashing
Front Door call using Speakerphone
Back Door call using Speakerphone
Standard FD or BD handset mode, no forwarding
Standard FD or BD handset mode, no forwarding
'4 is for initialization, to force echo settings off on first use.  This is because the "Z" specification doesn't clear echo settings to the standard ones.
State tables
non  idl  tlk  sig  trk  fwd  fls  fai  rec  rng  shh  dia  rbk  bzy  err _new old \/
Subtransition codes and tables
Queued specifications for Supervisor
�Ê ˜š
œ™Jš
œ?™?Jš
œl™lJ™1J˜—š
Ïk	˜	Jš�œ
˜Jšœ
�œ˜*Jšœ�œÝ
�œ-˜˜Jšœ	�œ%˜3J˜Jšœ�œ�œ˜&J˜Jšœ�œ3˜@Jšœ�œ�œ˜#Jš�œ
�œ˜Jšœ�œ˜Jšœ�œ˜$Jš	œ�œ�
œ
�œ�œ˜>šœ�œ˜Jš
œ…
˜…
—Jš�œ
�œ˜J˜
J˜—šœ
�
œ
�œ�œ˜:š
�˜Jšœ�œ�œ"�˜P—Jš�œ˜Jš�œ
�œ
˜J˜—™J˜Jšœ
�œ˜*Jš�
œ�œ�œ�œ�œ�œ�
œ˜JJšœ
�œ˜*Jšœ�œ˜,Jšœ�œ˜-Jšœ�œ˜.Jšœ�œ˜)Jšœ�œ ˜2Jš�œ�œ
�œ
˜Jšœ�œ ˜<J˜J˜!Jš
œ#˜#J˜!Jš
œ%˜%J˜Jšœ�œ˜J˜š�œ�œ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ
�œ˜Jšœ�œ˜Jšœ�œ
Ïc/˜OJšœ�œ
�œ
˜Jšœ�œ
�œž2˜MJšœ
�œ
�œ
˜Jšœ�œ
�œ
˜šœ�œ
�œ
ž<˜QJ™—J˜—Jš	œ�œ
�œ�œ
�œ˜J˜Jšœ�œ
˜"Jšœ�œ
˜#Jšœ�œ
˜#Jšœ"�œ
˜&Jšœ�œ4�œ˜eJ˜—š
œ™J˜šÏnœ�œ
�œ
�œ>˜_Jš�œ
�œ�œ
˜J˜#J˜J˜—šŸœ�œ
�œ
�œ<˜]Jš�œ
�œ�œ
˜Jšœ	�œ
�œ!�œ˜IJ˜3J˜%Jšœ�œ
˜J˜J˜Jšœ�œ
�œ
˜Jšœ�œ
�œ
˜Jšœ�œ
˜"Jš�œ�œ˜#J™]š�œ�˜Jšœ�œžD˜SJšœ"�œ˜,Jš�
œ>�œ˜IJšœ7ž
œ˜Cš
œ˜Jš
œV˜VJšœ�œ
˜Jš�œž2˜KJš�œ
˜Jš
œ˜—Jš�œ
˜—J˜Jš�œ�œ
�œ,˜=š�œ�œ
�œ˜Jš�œ�œ"˜7Jš�œ�œ˜/J˜—J™]J™š�œ�˜š
œ˜J™*Jš�œ�œ˜'Jš
œ*˜*J˜—Jš�œ
˜—J™ šœ�œ�˜Jšœž˜,Jš	œ�œ�œ
�œ�œ˜FJ˜J˜J˜Jš�œ�˜Jš
œ
˜
—š�œ�˜˜Jš�œ�œ˜'Jš�œ
�œ
�œ(˜<J˜—Jšœ�œ�œ<˜aJš�œ
˜—Jš
œY™YJ™@š�œ�˜šœ	�œ�˜#JšœDž˜YJš�œ
˜—šœ
�œ�œž.˜ZJšœ+�œ�œ�œ	˜[—Jš�œž˜"—Jšœ�œ
˜	Jš�œ)�œ�œ
˜8š�œ�˜Jšœ
�œ
˜JšœÏfœ
�œ�œ�œ�œ
˜IJš�œ
˜—š�œ�œ
�œ˜Jš�œ�œ@˜Vš
œ'˜'Jš
œP˜P—š�œ�œ˜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šŸ
œ�œ�œ
˜4J˜šŸ	œ�œ
�œ
�œH˜gJ˜Jšœ�œ0˜IJ˜J˜—š
Ÿ	œ�œ
�œ
�œ'�œ˜LJš�œ
�œ�œ
˜Jšœ�	œ
˜Jš�œ�œ
�œ
�œ
˜JšœGž˜WJ˜Jš�œ˜J˜š�œ�ž˜=J™1š
œ˜Jš
œV˜V——J˜J˜——š
œ™J˜šŸœ�	œ)˜BJš
œV™VJš
œT™TJš
œ6™6J™¼
Jš�œ
�œ�œ
˜Jšœ�œ
˜ Jšœ�œ
�œ�œ
˜.š
œ˜Jš�œ5�œ˜>—Jšœ�œ
˜	J˜JšŸœ�œ
�œ!˜2šŸœ�œ
�œ˜'Jš�œ�œ˜;—J˜šŸ
œ�œ
�œ�œ�œ
�œ�œ˜LJš�œ
�œ�œ
˜š
�˜Jšœ�œ
�œ
�œ˜#Jš
�œ�œ�œ
�œ
�œ˜Gš�œ�œ
�œ˜Jš
œ˜J˜Jš�œ˜J˜—Jš
œL˜LJš�œ˜š�œ�œ
�œ˜Jš�œ�œ
�œ
ž˜=Jš�œ
�œ˜J˜—Jš�œ
˜—J˜—J˜Jš�œ.˜5š�œ�œ�˜'Jš
ž$˜$š�œ˜š
�œ�œ�œ
�œ
�œ˜8Jšœ'�œ˜6—š�œ˜Jšœ2�œ˜A—Jš
œ˜—J˜šŸœ�œ�œž+˜MJš�œ�œ
�œ
�œ
˜ Jšœ�œ
˜Jš
œ&˜&š
œ˜Jš�œ�œ�œ˜I—Jš
œ?˜?J˜(Jš
œW˜WJ˜J˜—Jšœ�œ
˜š�œ�œ
�˜šœ�œ˜J˜8J˜7J˜—š
œ˜Jš
œ˜J˜Jšœ�œ˜Jš
œ˜—š	œ�œ�œ
�œ
�œ˜0Jš�œ$�œ
�œ˜7š	�œ�œ
�œ�œ
�˜2Jš
œ ˜ —Jš�œ
�œ
�œ�œ�œ�œ˜OJš�œ˜#Jš�œ�œ
�œ	�œ˜(J˜—šœ�œ˜Jšœ	�œ˜Jšœ
�œ˜J˜JšœJ�œ˜QJ˜—š
œ&˜&Jš
œF˜F—˜š�œ
�œ
�˜š�œ�œ˜&J˜,JšœJ�œ˜Qš
œb˜bJšœ*�œ˜B—J˜
—Jš�œ/˜3——Jš
œV˜V˜Jšœ�œ
˜J˜J˜5Jš
œ™J˜J˜4J˜—Jš�œ
˜—Jš�œ˜"Jš�œ
˜—Jšœ�œ
˜J˜J˜—Jšœ�œD™SšŸœ�œ
�œ�œ˜OJš	œ�œ
�œ
�œ�œ˜Jšœ�œ
�œ
�œ˜#Jšœ�œ
˜Jš�œ�œ
�œ�œ
�œ�œ
�œ�œ˜iJ˜š�œ�œ
�œ
�œ˜&Jšœ"�œ#˜I—Jš�œ˜J˜—J˜J˜šŸœ�œ	�œ˜6Jšœ-�œ˜@J˜J˜—šŸœ�œ
�œ
˜$Jšœ�œ
˜Jšœ�œ
�œ
�œ:˜QJš�œ
�œ
�œ�œ˜'Jšœ�œ˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜J˜J˜'J˜$Jšœ�œ
˜	Jš
œ(˜(Jš	�œ
�œ
�œ
�œž
˜*J˜š�œ�œ
�˜Jš�œ�œ�œ�œ
�œ�œ
˜Qš�œ�˜
Jšœ�œ�œ&˜R˜Jšœ�œ˜%Jšœ	�œ
�œ�œ
�œ�œ˜HJ˜-Jšœ�œ
˜(J˜Jš�œ
˜Jš
œ˜—˜Jš
œ,˜,J˜*Jš
œ˜—˜šœ�œ�˜7J˜J˜J˜Jš�œ�œ
˜—Jš
œ˜—š�œ˜š�œ�œ
�œ(˜=Jš�œ˜—Jš�œ�œ+˜JJ˜——Jš�œ
˜—Jš�œ�œ
�œ�œ˜'Jš�œ&�œ�œ�œ
˜Oš	�œ�œ
�œ�œ
ž/˜OJ˜	š�œ&�˜,Jš
œ9˜9—š	�œ�
œ�œ
�œ �˜RJšœ6�œ
˜>—š�œ�œ
�œ�œ
�œ"�œ˜BJšœ	�œ
�œ�œ
�œ�œ˜BJšœ�œ
�œ�œ
�œ�œ˜Hš�œ�œ
�œ�œ
�œ�˜8˜Jš	œ�œ
�œ�œ�œ˜8Jš�œ˜—Jš�œ
˜—Jšœ�œ
˜—Jš�œ
�œ
�œ�œ˜'Jš�œ
�œ
�œ&�œ
˜N—J˜%J˜J˜$J˜J˜—JšŸœ�œ�œ�œ	�œ�œ�œ
˜EJ˜šŸ
œ�œ�œ�œ˜FJšœ�œ�œ
�œ˜-Jšœ�œ!˜)š�œ�œ
�œ�˜Jšœ�œ˜šœ�œ�˜"Jš�œ
�œ˜&Jš�œ
�œ˜&Jš	�œ�œ
�œ�œž!˜XJ˜J˜Jš�œ˜—Jš�œ
˜—J˜J˜—šŸœ�
œ˜Jš�œ�œ
�œ
˜ Jšœ�œ
˜šœ�œ-�œ
˜@šœ%�	œ
˜/Jš
œ%˜%Jš
œ*˜*——šœ�œ-�œ
˜@šœ%�	œ
˜/Jš
œ6˜6Jš
œ;˜;——šœ�œ-�œ
˜Ašœ%�	œ
˜/Jš
œ7˜7Jš
œ<˜<——šœ�œ-�œ
˜Dšœ�
œ�	œ
˜/Jš
œ(˜(Jš
œ-˜-——J˜J˜—šŸœ�œ�œ�œ˜IJšœ�œ
�œ
˜
Jš�œ�œ
�œ
˜Jšœ�œ
�œ˜J˜š�œ�˜
Jš
œ˜˜J˜Jš
œ*˜*Jš
œ˜—Jš�œ
˜—J˜J˜1J˜—šœ�œ�œ
�œ
˜+J˜EJ˜‹
J˜IJ˜——™J˜Jšœ�œ˜$Jšœ�œ˜&Jšœ�œ˜+Jš
œ$˜$Jš
œ\˜\Jš
œc˜cJ˜)J˜™0Jš�
œ
žR™TJ™J™&J™J™J™DJ™J™9J™J™:J™,J™KJ™!—™Itable2š
Ïi™Kš
¡
™
Kš
¡™Kš
¡™Kš
¡™Kš
¡™Kš
¡
™
Kš
¡™Kš
¡™—J˜˜?Jš
œ™šœ
�œž˜Jšœž˜Jšœž
˜Jšœž˜#Jšœž/˜FJšœžR˜cJšœž'˜,Jšœž2™GJšœž	˜Jšœž
˜Jšœž
˜Jšœž
˜Jšœ?ž˜GJ˜—Jš
œ™šœ
�œž˜Jšœž˜Jšœž
˜Jšœž˜!Jšœž-˜KJšœžI˜ZJšœž'˜,Jšœž™%Jšœž	˜Jšœž
˜Jšœž
˜Jšœž
˜JšœCž˜KJ˜—J™šœ�œž˜Jšœž˜Jšœž
˜Jšœž˜!Jšœž/˜JJšœž?˜PJšœž'˜,Jšœž™&Jšœž	˜Jšœž
˜Jšœž
˜Jšœž
˜JšœOž˜WJ˜—J™$šœ�œž˜Jšœž˜Jšœž
˜Jšœž˜!Jšœž˜Jšœž?˜PJšœž˜Jšœž™&Jšœž	˜Jšœž
˜Jšœž
˜Jšœž
˜Jšœ?ž˜GJ˜
—J˜—J˜šœ
�œ�œ˜2J™"J˜
Jšœ�œ
˜Jšœ�œ
˜J˜
J˜'Jš
œ˜—Jšœ�œ˜ J˜šœ
�œ�œ˜2J™!J˜Jšœ�œ
˜Jšœ�œ
˜J˜J˜(J˜—J˜šœ�œ�œ˜4J™-J˜ Jšœ�œ
˜Jšœ�œ
˜J˜
J˜J˜—Jšœ�œ˜$J˜šœ�œ�œ˜4J™-J˜Jšœ�œ
˜Jšœ�œ
˜J˜
J˜J˜J˜—Jš
œ	�œ
�œ	�œ
�œ�œ*�œ˜Xšœ
�œ
�œ
�œ
�œ�œ@˜jJ™›
—J˜—™J˜Jšœ�œ˜,Jšœ�œ˜&šœ�œ�œ˜)Jšœjžœ˜‚
—šœ�œ
�œ	�œ˜4Jšœž	˜'Jšœ4ž	˜=Jšœž	˜'Jšœ7ž	˜@Jšœ	ž˜J˜J˜—šœ	�œ˜Jšœž˜JšœžR˜WJšœžM˜\Jšœ
žD˜NJšœ
žbÐckž
¢ž˜tJšœž4˜9Jšœ
žQ˜[Jšœž+˜0Jšœ
ž4˜>Jšœž˜Jšœ
žD˜NJšœ
žT˜^Jšœ
ž˜Jšœ
ž˜Jšœ	ž˜ Jšœž˜"Jšœžj˜oJšœžh˜mJšœžH˜JJ˜J˜—š	 	Ðfk £ 
£ £ 
˜;Jš
 U™UJš MÐcf
˜ZJš M¤
˜ZJš M¤˜]Jš M¤˜cJš M¤˜`Jš M¤˜cJš M¤˜^Jš M¤˜\Jš M¤˜`Jš M¤˜]Jš M¤˜]Jš M¤˜^Jš M¤˜^Jš M¤˜^Jš M¤˜_J˜—J˜J™J˜#š
œG˜GJ˜•
—J˜J˜+š
œ˜J˜Ã
J˜—J˜+š
œ„
˜„
J˜Û
—J˜J˜,š
ϥ
˜•
J˜ŽJ˜—J˜š
œ%˜%Jš
œo˜oJ˜Í
—J˜—™$J˜J˜(Jšœ
�œ�œ˜DJ˜J˜"Jšœ
�œ�œ˜8J˜šœ�œ�œ˜J˜J˜—J˜šœ!�œ˜*J˜Jš
œ˜—Jš
œY˜YJ˜J˜——…—_Z„z