DIRECTORY
IO,
Commander USING [ CommandProc, Register ],
Convert USING [ IntFromRope ],
Lark USING [ bStar, bThorp, CommandEvent, CommandEvents, CommandEventSequence, Device, disabled, DTMFEvent, enabled, endNum, Event, Passel, reset, StatusEvent, StatusEvents, SHHH ],
LarkRpcControl,
LarkSmarts,
Log USING [ ProblemBool, Report ],
Nice,
RPC USING [ CallFailed ], 
Rope USING [ Concat, FromChar, ROPE ],
Process USING [ Detach, MsecToTicks, SetTimeout, Ticks ],
ThPartyPrivate USING [ SmartsData ],
ThSmartsPrivate USING [
click, EnterLarkSt, flushMarker, GetSmartsInfo, HookState, indexMarkerEnd, LarkInfo, LarkProseQueue, LarkState, maxClientMarker, pResetConfirmEnd, ProseControlDone, proseFailure, ReportProseDone, RingDetState, SmartsInfo, stopAndFlushEnd, TerminalType, TonesDone ],
Thrush USING[ H, pERROR, ProseSpec, ROPE, SHHH, SmartsHandle, ThHandle ],
ThNet USING [ pd ]
;

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

H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; };
HookState: TYPE = ThSmartsPrivate.HookState;
LarkInfo: TYPE = ThSmartsPrivate.LarkInfo;
RingDetState: TYPE = ThSmartsPrivate.RingDetState;
SmartsData: TYPE = ThPartyPrivate.SmartsData;
SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;
SmartsHandle: TYPE = Thrush.SmartsHandle;
TerminalType: TYPE = ThSmartsPrivate.TerminalType;
ROPE: TYPE = Thrush.ROPE;
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;

PD: TYPE = RECORD [
callTimeoutOK: BOOL_FALSE -- set to keep Thrush alive when debugging a Lark.
];
pd: REF PD _ NEW[PD_[]];



DebEvent: PROC[info: SmartsInfo, ev: Lark.StatusEvent] = INLINE {
s: IO.STREAM=IO.ROS[];
s.PutF["[%3B, %3B, ",
card[LONG[
IF info#NIL THEN LOOPHOLE[info.larkInfo.netAddress.host,CARDINAL]
ELSE LOOPHOLE[777B, CARDINAL]]],
card[LONG[LOOPHOLE[ev.device, CARDINAL]]]]; 
IF ev.event<='z THEN s.PutF["%g]  ",char[ev.event]]
ELSE s.PutF["<%3B>]  ", card[LONG[LOOPHOLE[ev.event, CARDINAL]]]];
Log.Report[s.RopeFromROS[], $LarkDetailed, info.larkInfo];
};

crowbar: BOOL_FALSE; -- TRUE to check basic RPC performance from Lark.
RecordEvent: PUBLIC PROC[shh: Thrush.SHHH, smartsID: Thrush.SmartsHandle, whatHappened: Lark.StatusEvents]
RETURNS [ success: BOOL_TRUE ]
= {
smartsInfo: SmartsInfo = ThSmartsPrivate.GetSmartsInfo[smartsID: smartsID];
parseInfo: SmartsInfo _ smartsInfo;
info: LarkInfo;
parseSmarts: SmartsData;
IF smartsInfo=NIL OR (info _ smartsInfo.larkInfo)=NIL THEN RETURN[FALSE];
parseSmarts _ smartsInfo.smarts;
FOR i: Lark.Passel IN [0 .. whatHappened.length) DO
sEvent: Lark.StatusEvent _ whatHappened[i];
IF ThNet.pd.debug THEN DebEvent[smartsInfo, sEvent];
IF crowbar OR info.larkState=failed OR info.larkState=recovering THEN LOOP;
SELECT sEvent.device FROM
ringDetect => {
parseSmarts _ smartsInfo.otherSmarts;
parseInfo _ ThSmartsPrivate.GetSmartsInfo[smarts: parseSmarts]; };
tones => {
ThSmartsPrivate.TonesDone[smartsInfo.larkInfo, sEvent, smartsInfo];
LOOP;
};
ENDCASE;
SELECT sEvent.device FROM
speakerSwitch => sEvent _ InterpretSpeakerSwitch[info, sEvent];
ringDetect => sEvent _ InterpretRingDetect[info, H[parseSmarts], parseInfo, sEvent];
touchPad => {
IF sEvent.event=disabled THEN sEvent.event _ smartsInfo.lastTouchpadChar
ELSE {
smartsInfo.lastTouchpadChar _ sEvent.event; LOOP; -- down transitions of DTMF pad.
};
IF sEvent.event='\000 THEN LOOP;
};
keyboard => {
IF info.textToSpeech THEN HandleAndReport[info, sEvent, smartsInfo];
LOOP;
};
hookSwitch => NULL;
ENDCASE => Thrush.pERROR;
IF sEvent.device=nothing THEN LOOP;
parseInfo.ParseEvent[ smartsInfo: parseInfo, sEvent: sEvent ];
ENDLOOP; };

EventRope: PUBLIC PROC[
shh: Thrush.SHHH, smartsID: SmartsHandle, time: CARDINAL, device: Lark.Device, events: ROPE]
RETURNS[success: BOOL] = {
NULL;
};

HandleProseOutput: ENTRY PROC[info: LarkInfo, commandEvent: Lark.StatusEvent, sInfo: SmartsInfo] RETURNS [pS: Thrush.ProseSpec _ NIL] = {
c: CHAR _ commandEvent.event;
SELECT c FROM
IO.BEL => NULL; -- take some error action?
IO.ESC, ';, '\\ => info.proseResponse _ ""; -- start of some response
'[ => NULL;  -- peel this character off
ThSmartsPrivate.stopAndFlushEnd => {
ThSmartsPrivate.ProseControlDone[info, ThSmartsPrivate.flushMarker, sInfo];
info.flushJustFinished _ TRUE;
};
ThSmartsPrivate.indexMarkerEnd => {
marker: INT _ Convert.IntFromRope[info.proseResponse];
IF marker > ThSmartsPrivate.maxClientMarker THEN
ThSmartsPrivate.ProseControlDone[info, marker, sInfo]
ELSE {
pQ: ThSmartsPrivate.LarkProseQueue _ info.proseQueue;
IF pQ=NIL THEN Thrush.pERROR;
IF info.flushJustFinished THEN {
FOR pSkip: ThSmartsPrivate.LarkProseQueue _ pQ, pSkip.rest WHILE pSkip#NIL DO
IF pSkip.first.proseMarker = marker THEN pQ _ pSkip;
ENDLOOP;
info.flushJustFinished _ FALSE;
};
IF pQ.first.proseMarker = marker THEN {
pS _ pQ.first.proseSpec;
info.proseQueue _ pQ.rest;  -- Flush any skipped items.
IF info.proseQueue=NIL THEN info.pTail _ NIL;
}
ELSE
ThSmartsPrivate.ProseControlDone[info, ThSmartsPrivate.proseFailure, sInfo]; -- fail!!!
};
};
ThSmartsPrivate.pResetConfirmEnd => {
ThSmartsPrivate.ProseControlDone[info, ThSmartsPrivate.flushMarker, sInfo];
info.flushJustFinished _ TRUE;
};
ENDCASE => info.proseResponse _ Rope.Concat[info.proseResponse, Rope.FromChar[c]];
};

HandleAndReport: PROC [info: LarkInfo, commandEvent: Lark.StatusEvent, sInfo: SmartsInfo] ~ {
pS: Thrush.ProseSpec _ HandleProseOutput[info, commandEvent, sInfo];
IF pS#NIL THEN ThSmartsPrivate.ReportProseDone[sInfo, pS];
};

InterpretSpeakerSwitch: PROC[info: LarkInfo, sEvent: Lark.StatusEvent]
RETURNS [ processedEvent: Lark.StatusEvent] = --<<INLINE>>-- {
interval: INTEGER = LOOPHOLE[sEvent.time-info.swOnTime];
processedEvent _ sEvent;
SELECT sEvent.event FROM
enabled => info.swOnTime _ sEvent.time;
disabled => NULL;
ENDCASE => ERROR Thrush.pERROR;
IF interval < 0 OR interval > spClickInterval THEN RETURN;
processedEvent.event _ ThSmartsPrivate.click; };

spClickInterval: INTEGER _ 500;

InterpretRingDetect: ENTRY PROC[info: LarkInfo, smartsID: SmartsHandle, smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent]
RETURNS [ processedEvent: Lark.StatusEvent _ [ 0, nothing, Lark.reset ] ] = --<<INLINE>>-- {
ENABLE UNWIND=>NULL;
interval: INTEGER = LOOPHOLE[sEvent.time-info.ringChangeTime];
event: Lark.Event = sEvent.event;
info.ringChangeTime _ sEvent.time;
SELECT event FROM 
enabled => SELECT info.ringDetState FROM idle, between=>NULL; ENDCASE=>RETURN;
disabled => SELECT info.ringDetState FROM idle, between=>RETURN; ENDCASE;
ENDCASE=>RETURN;
SELECT info.ringDetState FROM
idle => TRUSTED { -- known enabled --
info.ringDetState _ maybe;
info.ringDetWaitState_idle;
info.ringDetInstance _ info.ringDetInstance+1;
Process.Detach[FORK RingDetProc[smartsID, smartsInfo, info.ringDetInstance]]; };
maybe =>  { -- known disabled --
IF interval<debounceInterval THEN info.ringDetState_idle ELSE {
info.ringDetState _ between; 
processedEvent _ sEvent; processedEvent.event _ enabled; }; };
ring1 => {  -- known disabled -- 
info.ringDetState _ between; };
ring => { -- known disabled --
info.ringDetState _ IF interval > ringInterval THEN between ELSE idle; };
between => { -- known enabled --
info.ringDetState _ IF interval < breakInterval THEN ring ELSE idle; };
ENDCASE;
IF info.ringDetState#info.ringDetWaitState THEN NOTIFY info.ringDetCondition; };

debounceInterval: INTEGER _ 300; -- ms.
ringInterval: INTEGER = 1700; -- ms., 2 sec. nominal, 300 ms. benefit of doubt
breakInterval: INTEGER = 4500; -- ms., 4 sec. nominal, 500 ms. benefit of doubt
debounceIntTicks: Process.Ticks = Process.MsecToTicks[debounceInterval];
ringIntTicks: Process.Ticks = Process.MsecToTicks[ringInterval];
breakIntTicks: Process.Ticks = Process.MsecToTicks[breakInterval];


RingDetProc: PROC[smartsID: SmartsHandle, smartsInfo: SmartsInfo, instance: CARDINAL] = {
info: LarkInfo = smartsInfo.larkInfo;
event: Lark.Event;
RingDetProcEntry: ENTRY PROC[info: LarkInfo] RETURNS[stillRunning: BOOL]	 = --INLINE-- {
ENABLE UNWIND=>NULL;
newState: RingDetState = IF info.ringDetInstance#instance THEN idle ELSE info.ringDetState;
event _ reset;
IF newState#idle AND newState=info.ringDetWaitState THEN -- timed out
SELECT info.ringDetState FROM
idle => RETURN[FALSE];--??--
maybe => { info.ringDetState _ ring1; event _ enabled; RETURN[TRUE]; };
ring1, between => info.ringDetState _ idle;
ring => info.ringDetState _ between; --??--
ENDCASE;
info.ringDetWaitState _ info.ringDetState;
TRUSTED { SELECT info.ringDetState FROM
idle => { event _ disabled; RETURN[FALSE]; };
maybe => Process.SetTimeout[@info.ringDetCondition, debounceIntTicks];
ring1 => Process.SetTimeout[@info.ringDetCondition, ringIntTicks+breakIntTicks];
ring => Process.SetTimeout[@info.ringDetCondition, ringIntTicks];
between => Process.SetTimeout[@info.ringDetCondition, breakIntTicks];
ENDCASE;
};
WAIT info.ringDetCondition;
RETURN[ TRUE ]; };
DO
stillRunning:BOOL_ RingDetProcEntry[info];
IF event#reset THEN
smartsInfo.ParseEvent[smartsInfo, [info.ringChangeTime, ringDetect, event ] ];
IF ~stillRunning THEN RETURN; ENDLOOP; };

InterpretHookState: PUBLIC ENTRY PROC
[ info: LarkInfo, rawEvent: Lark.StatusEvent, sInfo: SmartsInfo ]
RETURNS [ processedEvent: Lark.StatusEvent ] = {
ENABLE UNWIND=>NULL;
event: Lark.Event = rawEvent.event;
ev: EvType;
newState: HookState;
oldType: TerminalType_info.terminalType;
processedEvent.device _ nothing;
ev _ SELECT rawEvent.device FROM
hookSwitch => SELECT event FROM
Lark.enabled => IF info.monitor THEN spMon ELSE tsOn, Lark.disabled => tsOff,
ThSmartsPrivate.click => spClick, ENDCASE=> spNone,
speakerSwitch => SELECT event FROM
Lark.enabled => spOn, Lark.disabled => spOff,
ThSmartsPrivate.click => spClick, ENDCASE => spNone,
ENDCASE => spNone;
processedEvent _ rawEvent;
IF ev = spNone THEN {
processedEvent.event _ SELECT rawEvent.device FROM
keyboard => SELECT event FROM
'[ => enabled,
'] => disabled,
'\n => endNum,
ENDCASE => event,
touchPad => SELECT event FROM
bThorp => endNum,
bStar => '*,
IN Lark.DTMFEvent => event - (FIRST[Lark.DTMFEvent]-'0),
ENDCASE=>event,
ENDCASE => event;
RETURN;
};

newState _ newStates[info.hookState][ev];
processedEvent.device _ IF newState=onhook OR info.hookState=onhook
THEN hookSwitch ELSE nothing;
IF event=ThSmartsPrivate.click THEN processedEvent.event_disabled;
info.hookState _ newState;
info.terminalType _ SELECT newState FROM
onhook => std,
telset, both, bOth => IF info.radio THEN radio ELSE std,
spkr, sPkr, spKr => IF info.radio THEN radio ELSE spkr,
monitor => monitor,
ENDCASE=> IF Log.ProblemBool[, $Lark, , info] THEN std ELSE std;
IF oldType#info.terminalType THEN
ThSmartsPrivate.EnterLarkSt[info, info.larkState, sInfo];
};


CheckHookState: PUBLIC ENTRY PROC
[info: LarkInfo ] RETURNS [ onHook: BOOL_TRUE ] = {
ENABLE RPC.CallFailed => IF pd.callTimeoutOK THEN RESUME ELSE GOTO Failed;
reverted, wasReverted: BOOL_FALSE;
which: CARDINAL;
DO
which_0;
reverted _ FALSE;
DO
events: Lark.StatusEvents;
[which, events] _ info.interface.WhatIsStatus[info.shh, which];
FOR i: NAT IN [0..events.length) DO
SELECT events[i].event FROM
enabled => SELECT events[i].device FROM
hookSwitch => {
onHook_FALSE;
info.interface.Commands[shh: info.shh, events: assertARelay];
};
revertHookswitch => IF ~wasReverted THEN reverted _ wasReverted _ TRUE;
ENDCASE;
ENDCASE;
ENDLOOP;
IF which=0 THEN EXIT;
ENDLOOP;
IF reverted THEN {
info.interface.Commands[shh: info.shh, events: unRevHS];
LOOP;
};
EXIT;
ENDLOOP;
EXITS
Failed => onHook_FALSE;
};

EvType: TYPE = { tsOn, tsOff, spOn, spOff, spClick, spMon, spNone };

newStates: ARRAY HookState OF ARRAY EvType OF HookState _ [
[ telset, onhook, sPkr, onhook, onhook, monitor, onhook ], -- onhook
[ telset, onhook, bOth, telset, telset, monitor, onhook ],   -- telset
[ telset, spkr, spKr, onhook, onhook, monitor, onhook ],  -- spkr (speakerphone mode but switch in middle)
[ bOth, sPkr, sPkr, onhook, spkr, bOth, onhook ],     -- sPkr (speaker switch is up)
[ bOth, sPkr, sPkr, onhook, onhook, bOth, onhook ],  -- spKr (sPkr, but click turns off - speaker switch in middle or up.)  Scenario goes like this: we were in spkr mode and we saw an spOn.  Next we might see an spClick, in which case this is a click off (=down+up) so we go onhook.  However, it might also be a click on (=up), in which case this situation could persist and has to be considered the same as sPkr.
[ both, spkr, both, telset, telset, both, onhook ],       -- both (handset offhook, speaker switch in middle or up; click reverts to telset)
[ bOth, sPkr, bOth, telset, both, bOth, onhook ],       -- bOth (handset offhook, speaker switch up)
[ monitor, onhook, bOth, sPkr, monitor, monitor, onhook ] ]; -- monitor


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

unRevHS: Lark.CommandEvents _ NEW[Lark.CommandEventSequence[1]];
assertARelay: Lark.CommandEvents _ NEW[Lark.CommandEventSequence[1]];
unRevHS[0] _ [revertHookswitch, disabled];
assertARelay[0] _ [aRelay, enabled];

Commander.Register["VuLarkIn", ViewCmd, "Program Management variables for Lark Input"];
}.
dLarkInImpl.mesa 
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last modified by D. Swinehart, September 6, 1985 4:09:16 pm PDT
Polle Zellweger (PTZ) December 11, 1985 11:56:06 pm PST
*****************  External  Procedures  ********************
Handles smarts-independent filtering, events that need timing.
Interpret event, possibly filter some out.
React to upstrokes, not downstrokes.  0-key Rollover is a side-effect.  Try it.
Only pass on index marker notifications.  Swallow or handle all others.
Assume Prose XON / XOFF disabled.
Assume only get the following responses:
	On pReset:	pResetConfirmOK							if everything's okay
				cmdLeader <0-16> pResetConfirmEnd		otherwise
	Index marker response: 
	Undetermined problem: BEL
It's okay to skip ahead in the queue.  Except for 1st item in a conversation, which follows an initial RESET, should be to some entry with queueIt=FALSE.  Don't report skipped entries as finished; FinchSmarts will take care of skipping ahead in its queue. (May want to add a proseSpec.type = flushed?)
IF Convert.IntFromRope[info.proseResponse] # 0 THEN
ThSmartsPrivate.ProseControlDone[info, ThSmartsPrivate.proseFailure, sInfo] -- fail!!!;
ELSE {
};
Avoid deadlock - shouldn't call Smarts-level entry procs while holding the LarkIn/Out lock.
newly entered state
Filters only events whose device codes are hookswitch and speakerSwitch
Implements another state machine via SELECT
Translate characters from various devices into common set
Determine if either of telset or speakerphone is activated.
Assert aRelay and unrevert hookswitch
spOn is transition away from middle on speaker switch
spOff is transition to middle if it's been more than a few hundred milliseconds
spClick is transition to middle if it's been less than a few hundred milliseconds -- spClick is always preceded by spOn.
Note: spNone transitions are never taken.
Swinehart, August 6, 1985 12:10:40 pm PDT
Incorporate PTZ changes
changes to: DIRECTORY, LarkInImpl, RecordEvent, HandleProseOutput, InterpretSpeakerSwitch
Polle Zellweger (PTZ) August 7, 1985 6:36:35 pm PDT
Comments only.
changes to: EvType, newStates
Polle Zellweger (PTZ) August 22, 1985 5:20:05 pm PDT
Handle Prose flushing; remove deadlock from HandleProseOutput.
changes to: DIRECTORY, RecordEvent, HandleProseOutput, HandleAndReport
Polle Zellweger (PTZ) August 23, 1985 2:10:02 pm PDT
Input events from the Prose Lark are being interpreted as smarts-level parseable events.  Raise error for odd devices.
changes to: RecordEvent
Polle Zellweger (PTZ) August 23, 1985 2:34:28 pm PDT
changes to: RecordEvent, HandleProseOutput
Polle Zellweger (PTZ) August 27, 1985 8:57:45 pm PDT
Allow for Prose Reset command.
changes to: DIRECTORY, HandleProseOutput
Polle Zellweger (PTZ) August 29, 1985 5:46:33 pm PDT
changes to: HandleProseOutput
Polle Zellweger (PTZ) December 11, 1985 11:50:38 pm PST
changes to: HandleProseOutput

�ʨ˜š
œ™Icodešœ
Ïm
œ1™<Jš
œ?™?K™7—J˜š
Ïk	˜	Jšžœ
˜Jšœ
žœ˜*Jšœžœ˜Jšœžœ¤
žœ˜µ
J˜J˜Jšœžœ˜"J˜Jšžœ
žœ˜Jšœžœžœ˜&Jšœžœ,˜9Jšœžœ˜$šœžœ˜Jš
œ‰˜‰—Jš	œžœž
œžœžœ˜IJšœžœ˜J˜
J˜—šœž
œ
žœžœ˜9š
ž˜Jšœ$žœžœ ˜e—Jšžœ˜&—Jšžœ
žœ
˜J˜Jšž
œžœžœžœžœžœž
œ˜JJšœžœ˜,Jšœ
žœ˜*J˜2Jšœžœ˜-Jšœžœ˜.Jšœžœ˜)Jšœžœ ˜2Jšžœžœ
žœ
˜J˜J˜!Jš
œ#˜#J˜!Jš
œ%˜%J˜J˜šžœžœžœ˜Jšœžœ
žœ
Ïc2˜LJ˜—Jš	œžœ
žœžœ
žœ˜J˜Jš
œ=™=J˜J˜šÏnœžœ+žœ˜AJš	œžœ
žœ
žœ
žœ˜š
œ˜šœžœ
˜
Jš
žœžœ
žœ
žœžœ
˜AJšžœ
žœžœ˜ —Jšœžœ
žœžœ˜,—Jšžœžœ˜3Jšžœžœ
žœžœ˜BJš
œ:˜:Jš
œ˜—J˜Jšœ	žœ
žœŸ1˜Fš œžœ
žœžœA˜jJšžœž	œ˜J™>Jš
œ˜Jš
œK˜KJ˜#Jš
œ˜J˜Jšžœžœ
žœžœ
žœ
žœ
žœ˜IJ˜ šžœžœž˜3J˜+Jšžœžœ˜4Jš
žœ	žœžœžœ
žœ
˜KJ™*šžœž˜šœž
˜J˜%J˜B—š
œ
˜
Jš
œC˜CJšžœ
˜J˜—Jšžœ
˜—šžœž˜J˜?Jšœ1ž
œ"˜Tš
œ
˜
J™OJšžœžœ+˜Hšžœ˜Jšœ,žœŸ ˜RJ˜—Jšžœžœ
žœ
˜ J˜—š
œ
˜
Kšžœžœ+˜DKšžœ
˜K˜—Jšœžœ
˜Jšžœ˜—Jšžœžœ
žœ
˜#Jš
œ>˜>Jšžœ˜——J˜š 	œžœ
˜Jšœžœ žœžœ
˜\Jšžœ
žœ˜Jšžœ
˜Jš
œ˜—J˜Jšœ«ž™®š
 œžœ
žœDžœžœ˜‰
Jšœžœ˜šžœž˜
JšžœžœŸ˜*Jšžœ
žœ&Ÿ˜EJšœžœŸ˜'š
œ$˜$Jš
œK˜KJšœžœ
˜J˜—š
œ#˜#Jšœžœ+˜6šžœ*ž˜0Jš
œ5˜5—šžœ˜Kš
œ5˜5Kšžœžœ
žœ˜šžœžœ˜ Kš
œ­™­šžœ8žœžœ
ž˜MKšžœ!žœ˜4Kšžœ
˜—Kšœžœ
˜K˜—šžœžœ
˜'Kš
œ˜KšœŸ˜7Jšžœžœ
žœžœ
˜-J˜
—š
ž˜JšœMŸ
˜W—J˜—J˜—š
œ%˜%šžœ,ž™3JšœLŸ
œ
™W—šžœ™Jš
œK˜KJšœžœ
˜J™—J˜—JšžœK˜R—Jš
œ˜—J˜š œžœH˜]J™[Kš
œD˜DKšžœžœ
žœ,˜:K˜J˜—š œžœ*˜FJšžœ'Ÿœ˜>Jšœ
žœžœ˜8J˜šžœž˜J˜'Jšœžœ
˜Jšžœžœ˜—Jšžœžœžœ
žœ
˜:J˜0J˜—Jšœžœ˜J˜š œžœ
žœZ˜yJšžœEŸœ˜\Jšžœ
žœžœ
˜Jšœ
žœžœ"˜>J˜!J˜"šžœžœ
˜Jšœžœžœžœžœžœ
˜NJš	œžœžœžœžœ
˜IJšžœžœ
˜—šžœž˜šœžœŸ˜%J˜J˜J˜.Jšœžœ=˜P—šœŸ˜ šžœžœžœ˜?J˜J˜>——šœŸœ
˜!J˜—šœ
Ÿ˜Jšœžœžœ	žœ	˜I—šœ
Ÿ˜ Jšœžœžœžœ	˜G—Jšžœ
˜—Jšžœ)žœ
žœ˜PJ˜—JšœžœŸ˜'Jšœžœ	Ÿ0˜NJšœžœ	Ÿ0˜OJ˜HJ˜@J˜BJ˜J˜š œžœ;žœ˜YJ˜%J˜š œžœ
žœžœžœŸ
œ˜XJšžœ
žœžœ
˜Jšœžœžœžœ˜[J˜šžœžœ žœ
Ÿ˜Ešžœž˜Jšœžœ
žœŸ˜Jšœ7žœ
žœ˜GJš
œ+˜+Jšœ%Ÿ˜+Jšžœ
˜——Jš
œ™Jš
œ*˜*šžœžœž˜'Jšœžœ
žœ˜-Jš
œF˜FJš
œP˜PJš
œA˜AJš
œE˜EJšžœ
˜J˜—Jšžœ˜Jšžœžœ˜—š
ž˜Jšœ
žœ˜*šžœ
ž˜Jš
œN˜N—Jšžœžœ
žœžœ˜)—J˜—š œžœ
žœ
ž˜%š
œA˜AJšžœ)˜0—Jšœ+Ïb
œ¡
™GJšœ%¡™+Jšžœ
žœžœ
˜J˜#J˜J˜J˜(J˜ šœžœž˜ šœžœž˜Jšœžœžœžœ˜MJšœ"žœ
˜3—šœžœž˜"Jš
œ-˜-Jšœ"žœ˜4—Jšžœ˜—J˜šžœ
žœ˜J™9šœžœž˜2šœžœž˜J˜J˜J˜Jšžœ
˜—šœžœž˜J˜J˜Jšžœžœ˜8Jšžœ˜—Jšžœ
˜—Jšžœ
˜š
œ˜J˜——Jš
œ)˜)šœžœžœ˜CJšžœžœ	˜—Jšžœžœ˜BJ˜šœžœ
ž˜(J˜Jšœžœžœžœ˜8Jšœžœžœžœ˜7Jš
œ˜Jšžœžœ"žœžœ˜@—šžœž˜!Jš
œ9˜9—Jš
œ˜—J˜J˜š œžœ
žœ
ž˜!Jšœžœžœ
žœ˜3J™;Jšžœ
žœžœžœ
žœ
žœ
žœ˜JJšœžœ
žœ
˜"Jšœžœ
˜š
ž˜J˜Jšœžœ
˜š
ž˜J˜J˜?šžœžœ
žœž˜#šžœž˜šœžœž˜'š
œ˜Jšœžœ
˜
Jš
œ=˜=J˜—Jšœžœžœžœ
˜GJšžœ
˜—Jšžœ
˜—Jšžœ
˜—Jšžœ	žœ
žœ
˜Jšžœ
˜—šžœ
žœ˜J™%Jš
œ8˜8Jšžœ
˜J˜—Jšžœ
˜Jšžœ
˜—š
ž˜Jšœžœ
˜—J˜J˜—šœžœ8˜DJ™5J™OJ™xJ™)—J˜š	œžœžœ
žœžœ˜;Jšœ;Ÿ	˜DJšœ=Ÿ	˜FJšœ:Ÿ0˜jJšœ6Ÿ˜TJšœ5Ÿè˜�Jšœ:ŸR˜Œ
Jšœ8Ÿ,˜dJšœ=Ÿ
˜GJ˜—J˜šœ!žœ˜*J˜Jš
œ˜J˜—Jšœžœ˜@Jšœ#žœ˜EJš
œ*˜*Jš
œ$˜$J˜Jš
œW˜WJ˜™)K™KšœÏrM™Y—™3K™Kšœ¢™—™4Kš
œ>™>Kšœ¢:™F—™4K™vKšœ¢™—™4Kšœ¢™*—™4K™Kšœ¢™(—™4Kšœ¢™—™7Kšœ¢™—K™—…—3üN