DIRECTORY
Buttons USING [Button, ButtonProc, Create, Destroy],
ChoiceButtons USING [BuildEnumTypeSelection, BuildTextPrompt, ButtonList, PromptDataRef, SelectionNotifierProc],
Commander USING [CommandProc, Register],
CommandTool USING [ArgumentVector, Parse, Failed],
Containers USING [ChildXBound, ChildYBound, Create],
EditedStream USING [DeliverWhenProc],
IO,
Labels USING [Create, Label, Set],
LarkControl,
LarkPrograms USING [AddOrReplaceProgram, EnumeratePrograms, Monitor, Program, ReadProgramFromDisk],
LarkWork USING [MaybeCreateWorkArea, MaybeShutDownWorkArea],
List USING [Remove],
MBQueue USING [Create, CreateButton, Flush, Queue, QueueClientAction],
PupTypes USING [allNets, PupAddress],
Rope USING [Concat, Equal, ROPE],
RPCPkt USING [Machine],
Rules USING [Create],
TeleLoad USING [GoToDebugger, NameToAddress, Start, StartEventServer, StartKing, Stop, StopEventServer, StopKing, teleSwatSocket],
TypeScript USING [Create],
ViewerClasses USING [Viewer],
ViewerEvents USING [EventProc, RegisterEventProc],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [DestroyViewer, OpenIcon, SetOpenHeight];

LarkControlImpl: CEDAR MONITOR
IMPORTS Buttons, ChoiceButtons, Commander, CommandTool, Containers, IO, Labels, LarkControl, LarkPrograms, LarkWork, List, MBQueue, Rope, Rules, TeleLoad, TypeScript, ViewerEvents, ViewerIO, ViewerOps
EXPORTS LarkControl =
BEGIN
larkControl: LIST OF REF ANY _ NIL;

mainSwitchRopes: ARRAY LarkControl.MainSwitchStates OF Rope.ROPE _ ["off", "manual", "auto"];

IsASPorCR: EditedStream.DeliverWhenProc = TRUSTED { RETURN [appendChar: TRUE, activate: char='  OR char = '\n]; };

GetInstanceList: PUBLIC PROC RETURNS [LIST OF REF ANY] = { RETURN [larkControl]; };

GetLogStream: PUBLIC PROC [machine: RPCPkt.Machine] RETURNS [log: IO.STREAM] = {
lark: LarkControl.LarkData;
IF larkControl = NIL THEN RETURN [NIL];
IF machine.net = PupTypes.allNets THEN RETURN [NARROW[larkControl.first, LarkControl.Data].out];
lark _ GetLark[machine];
IF lark = NIL THEN RETURN [NIL];
log _ lark.h.log;
};

GetLark: PUBLIC PROC [machine: RPCPkt.Machine] RETURNS [lark: LarkControl.LarkData] = {
d: LarkControl.Data;
IF larkControl = NIL THEN RETURN [NIL];
IF machine.net = PupTypes.allNets OR machine.host NOT IN LarkControl.LarkIndex THEN RETURN [NIL];
FOR ll: LIST OF REF ANY _ larkControl, ll.rest WHILE ll # NIL DO
d _ NARROW[ll.first];
IF d.net = machine.net THEN RETURN[d.larks[machine.host]];
ENDLOOP;
RETURN [NIL];
};

DestroyProc: ViewerEvents.EventProc = TRUSTED {
d: LarkControl.Data;
FOR ll: LIST OF REF ANY _ larkControl, ll.rest WHILE ll # NIL DO
d _ NARROW[ll.first];
IF d.viewer = viewer THEN EXIT;
REPEAT
FINISHED => d _ NIL;
ENDLOOP;
IF d # NIL THEN {
FOR i: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
IF d.larks[i].eval # NIL THEN {
MBQueue.QueueClientAction[d.mbQueue, PrintBusy, d];
RETURN;
};
ENDLOOP;
larkControl _ List.Remove[ref: d, list: larkControl];
MBQueue.Flush[d.mbQueue];
MBQueue.QueueClientAction[d.mbQueue, DestroyEverything, d];
};
};

PrintBusy: PROC [clientData: REF ANY] = {
d: LarkControl.Data = NARROW[clientData];
d.out.PutRope["There are open work area.\n"];
};

StopProc: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
d.pleaseStop _ TRUE; 
};

PrintHelp: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
d.out.PutRope["See LarkControlDocumentation.tioga in Teleload.df\n"];
};

StatusAll: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
lark: LarkControl.LarkData;
FOR b: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
IF d.pleaseStop THEN { d.pleaseStop _ FALSE; EXIT; };
lark _ d.larks[b];
Labels.Set[lark.status, LarkControl.PollLark[lark: lark, print: shift, setPointers: mouseButton = blue]];
IF lark.event.reason # LarkControl.cDown AND lark.larkMode # 'dTHEN {
LarkControl.LarkGVSet[lark: lark, setMode: TRUE, setProgram: TRUE];
LarkControl.PaintMode[lark];
};
ENDLOOP; 
};

ResetAll: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
lark: LarkControl.LarkData;
FOR b: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
IF d.pleaseStop THEN { d.pleaseStop _ FALSE; EXIT; };
lark _ d.larks[b];
IF lark.larkMode = 'd THEN LOOP;
IF mouseButton # yellow THEN [] _ LarkControl.SetState[h: lark.h, state: lark.state, tp: TeleLoad.GoToDebugger, print: FALSE];
IF mouseButton # red THEN LarkControl.BootLark[lark];
ENDLOOP; 
};

StartAll: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
lark: LarkControl.LarkData;
FOR b: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
IF d.pleaseStop THEN { d.pleaseStop _ FALSE; EXIT; };
lark _ d.larks[b];
IF lark.larkMode = 'd THEN LOOP;
Labels.Set[lark.status, LarkControl.PollLark[lark: lark, print: shift, setPointers: TRUE]];
IF lark.event.reason = LarkControl.cRUNNING THEN {
LarkControl.LogEntry[lark: lark, rope: "already running\n"];
LOOP;
};
IF lark.event.reason = LarkControl.cDown THEN LOOP;  -- down
LarkControl.ConsiderActionFurther[lark: lark, event: lark.event];
LarkControl.PaintMode[lark];
ENDLOOP; 
};

NewSoftware: Buttons.ButtonProc = TRUSTED {
d: LarkControl.Data = NARROW[clientData];
newProgramList: LIST OF LarkPrograms.Program _ NIL;
ReParse: PROC [program: LarkPrograms.Program] RETURNS [stop: BOOL] = TRUSTED {
newProgram: LarkPrograms.Program _ LarkPrograms.ReadProgramFromDisk[objectFileName: program.programName, log: d.out, addressSpace: program.addressSpace]; 
IF newProgram # NIL THEN newProgramList _ CONS[newProgram, newProgramList];
RETURN [FALSE];
};
LarkPrograms.EnumeratePrograms[proc: ReParse];
WHILE newProgramList # NIL DO
LarkPrograms.AddOrReplaceProgram[newProgramList.first];
newProgramList _ newProgramList.rest;
ENDLOOP;
};

MainSwitchProc: ChoiceButtons.SelectionNotifierProc = TRUSTED {
d: LarkControl.Data = NARROW[clientdata];
FOR i: LarkControl.MainSwitchStates IN LarkControl.MainSwitchStates DO
IF Rope.Equal[name, mainSwitchRopes[i]] THEN {
d.mainSwitch _ i;
EXIT;
};
REPEAT
FINISHED => ERROR;
ENDLOOP;
};

LoadThis: Buttons.ButtonProc = TRUSTED {
lark: LarkControl.LarkData = NARROW[clientData];
Labels.Set[lark.status, LarkControl.PollLark[lark: lark, print: FALSE, setPointers: TRUE]];
IF lark.event.reason = LarkControl.cRUNNING THEN {
LarkControl.LogEntry[lark: lark, rope: "already running\n"];
RETURN;
};
IF lark.program # NIL THEN lark.state _ lark.program.startState
ELSE {
LarkControl.LogEntry[lark: lark, rope: "No program selected\n"];
RETURN;
};
IF mouseButton = blue THEN LarkControl.LocalGo[lark]
ELSE {
IF lark.slaveProgram # NIL THEN LarkControl.LoadProgram[lark: lark, go: FALSE, main: FALSE];
IF lark.program # NIL THEN LarkControl.LoadProgram[lark: lark, go: shift, main: TRUE];
};
};

ResetThis: Buttons.ButtonProc = TRUSTED {
lark: LarkControl.LarkData = NARROW[clientData];
IF mouseButton # yellow THEN [] _ LarkControl.SetState[h: lark.h, state: lark.state, tp: TeleLoad.GoToDebugger, print: FALSE];
IF mouseButton # red THEN LarkControl.BootLark[lark];
};

ModeThis: Buttons.ButtonProc = TRUSTED {
lark: LarkControl.LarkData = NARROW[clientData];
IF mouseButton = red OR lark.larkMode = 'dTHEN {
lark.larkMode _ 'U;
lark.gvDetails _ NIL; -- force GV fetch
LarkControl.LarkGVSet[lark: lark, setMode: TRUE, setProgram: TRUE];
}
ELSE lark.larkMode _ 'd;
LarkControl.PaintMode[lark];
};

DebugThis: Buttons.ButtonProc = TRUSTED {
lark: LarkControl.LarkData = NARROW[clientData];
result: Rope.ROPE;
SELECT mouseButton FROM
red => {
IF lark.eval = NIL THEN result _ LarkWork.MaybeCreateWorkArea[lark]
ELSE result _ LarkWork.MaybeShutDownWorkArea[lark];
lark.larkMode _ IF lark.eval = NIL THEN 'U ELSE 'd;
LarkControl.PaintMode[lark];
lark.world.out.PutRope[result];
};
yellow => {
LarkControl.LogEntry[lark: lark, rope: "Verify monitor", endWithCR: TRUE];
LarkControl.VerifyInternal[lark: lark, program: LarkPrograms.Monitor[log: lark.h.log, addressSpace: main], startAddress: 0E000H, stopAddress: 0];
};
blue => {
LarkControl.LogEntry[lark: lark, rope: "Verify slave EPROM", endWithCR: TRUE];
LarkControl.VerifyInternal[lark: lark, program: LarkPrograms.Monitor[log: lark.h.log, addressSpace: slave], startAddress: 0E000H, stopAddress: 0];
};
ENDCASE;
};

StatusThis: Buttons.ButtonProc = TRUSTED {
lark: LarkControl.LarkData = NARROW[clientData];
Labels.Set[lark.status, LarkControl.PollLark[lark, TRUE, mouseButton = blue]];
};


Create: Commander.CommandProc = {
argv: CommandTool.ArgumentVector;
d: LarkControl.Data;
address: PupTypes.PupAddress;
found: BOOL;
argv _ CommandTool.Parse[cmd: cmd ! CommandTool.Failed => { msg _ errorMsg;  CONTINUE; }];
IF argv = NIL THEN RETURN[$Failure, msg];
IF argv.argc < 2 THEN {
cmd.out.PutRope["Usage: LarkControl netaddress\n"];
RETURN;
};
[address: address, ok: found] _ TeleLoad.NameToAddress[argv[1]];
IF NOT found THEN {
cmd.out.PutF["Net %g not found\n", IO.rope[argv[1]]];
RETURN;
};
FOR ll: LIST OF REF ANY _ larkControl, ll.rest WHILE ll # NIL DO
d _ NARROW[ll.first];
IF d.net = address.net THEN {
cmd.out.PutF["Lark controller for net %g already exists\n", IO.rope[argv[1]]];
RETURN;
};
ENDLOOP;
d _ NEW[LarkControl.LarkControlDataObject];
d.net _ address.net;
d.mbQueue _ MBQueue.Create[];
MBQueue.QueueClientAction[d.mbQueue, ReallyCreate, d];
};

DestroyEverything: PROC [clientData: REF ANY] = {
d: LarkControl.Data = NARROW[clientData];
lark: LarkControl.LarkData;
FOR i: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
lark _ d.larks[i];
d.larks[i] _ NIL;
lark.world _ NIL;
TeleLoad.Stop[lark.h];
lark.h _ NIL;
lark.program _ NIL;
lark.breakList _ NIL;
lark.mode _ NIL;
lark.status _ NIL;
ENDLOOP;
TeleLoad.StopKing[];
TeleLoad.StopEventServer[];
LarkControl.StopWatcher[];
};

ReallyCreate: PROC[clientData: REF ANY] =
{
d: LarkControl.Data = NARROW[clientData];
v: ViewerClasses.Viewer = Containers.Create[
info: [name: IO.PutFR["Lark Control, Net %3b", IO.card[d.net]], column: left, scrollable: FALSE, iconic: TRUE]];
child: ViewerClasses.Viewer _ NIL;
x: INTEGER _ 1;
y: INTEGER _ 0;
bn: ChoiceButtons.ButtonList;
CommandButton: PROC[name: Rope.ROPE, proc: Buttons.ButtonProc, data: REF ANY,
newline: BOOL, guarded: BOOL _ FALSE] =
{
child _ MBQueue.CreateButton[
q: d.mbQueue,
info: [name: name, parent: v, border: TRUE, wy: y, wx: x ],
proc: proc,
clientData: data,
fork: TRUE,
paint: TRUE,
guarded: guarded];
x _ IF newline THEN 1 ELSE child.wx + child.ww - 1;
y _ IF newline THEN child.wy + child.wh - 1 ELSE child.wy;
};
LabelText: PROC[name, data: Rope.ROPE]
RETURNS[p: ChoiceButtons.PromptDataRef] =
{
p _ ChoiceButtons.BuildTextPrompt[viewer: v, x: x+1, y: y, title: name, default: data];
child _ p.promptButton;
x _ 1;
y _ child.wy + child.wh + 1;
RETURN[p]
};
Rule: PROC =
{
child _ Rules.Create[
info: [parent: v, border: FALSE,
wy: y, wx: 0, ww: v.ww, wh: 1],
paint: TRUE ];
Containers.ChildXBound[v, child];
x _ 1;
y _ child.wy + child.wh + 1;
};
d.viewer _ v;
{
temp: Buttons.Button = Buttons.Create[
info: [name: "ScanUniverse", parent: v, border: FALSE,
wx: 0, wy: 0],
proc: NIL, clientData: d, fork: FALSE, paint: FALSE];
d.maxW _ temp.ww;
d.buttH _ temp.wh;
Buttons.Destroy[temp];
};
bn _ LIST[mainSwitchRopes[off], mainSwitchRopes[manual], mainSwitchRopes[auto]];
d.mainSwitchController _ ChoiceButtons.BuildEnumTypeSelection[viewer: v, x: x, y: y, buttonNames: LIST[mainSwitchRopes[off], mainSwitchRopes[manual], mainSwitchRopes[auto]], default: mainSwitchRopes[off], notifyClientProc: MainSwitchProc, clientdata: d, style: menuSelection];
x _ d.mainSwitchController.nextx;
child _ Buttons.Create[info: [name: "STOP!", parent: v, border: TRUE,
wy: y, wx: x, ww: d.maxW], proc: StopProc, clientData: d];
x _ child.wx + d.maxW - 1;
y _ d.mainSwitchController.nexty + 1;
x _ 1;
CommandButton[name: "Help", proc: PrintHelp, data: d, newline: FALSE];
CommandButton[name: "StatusAll", proc: StatusAll, data: d, newline: FALSE];
CommandButton[name: "ResetAll", proc: ResetAll, data: d, newline: FALSE];
CommandButton[name: "StartAll", proc: StartAll, data: d, newline: FALSE];
CommandButton[name: "NewSoftware", proc: NewSoftware, data: d, newline: TRUE];
y _ y + 3;
Rule[];
d.larksY _ y;
y _ y + (d.larksH _ 10*(d.buttH-1) + d.buttH/2);
Rule[];
d.script _ TypeScript.Create[
info: [parent: v, wh: v.ch-y, ww: v.cw,
border: FALSE,
wy: y, wx: 0] ];
Containers.ChildXBound[v, d.script];
Containers.ChildYBound[v, d.script];
d.out _ ViewerIO.CreateViewerStreams[name: NIL, viewer: d.script, editedStream: FALSE].out;
ViewerOps.SetOpenHeight[v, y + 10 * d.buttH];
CreateLarkButtons[d];
ViewerOps.OpenIcon[v];
TeleLoad.StartKing[];
TeleLoad.StartEventServer[LarkControl.NoteEvents, d];
LarkControl.StartWatcher[];
larkControl _ CONS[d, larkControl];
};


CreateLarkButtons: PROC[d: LarkControl.Data] = TRUSTED {
parent: ViewerClasses.Viewer = d.viewer;
child: ViewerClasses.Viewer _ NIL;
x: INTEGER _ 1;
y: INTEGER _ 1;
CommandButton: PROC[name: Rope.ROPE, proc: Buttons.ButtonProc, data: REF ANY,
newline: BOOL] RETURNS [ViewerClasses.Viewer] = TRUSTED {
child _ MBQueue.CreateButton[
q: d.mbQueue,
info: [name: name, parent: larkViewer, border: TRUE,
wy: y, wx: x, ww: IF newline THEN larkViewer.cw - x - 2 ELSE 0 -- d.maxW --],
proc: proc,
clientData: data,
fork: TRUE];
x _ IF newline THEN 1 ELSE child.wx + child.ww - 1;
y _ IF newline THEN child.wy + child.wh - 1 ELSE child.wy;
RETURN[child];
};
Label: PROC[name: Rope.ROPE, newline: BOOL] RETURNS [Labels.Label] = TRUSTED
{
child _ Labels.Create[ info: [name: name, parent: larkViewer, border: FALSE, wy: y, wx: x+1, ww: IF newline THEN larkViewer.cw - x - 2 ELSE 0] ];
x _ IF newline THEN 1 ELSE child.wx + child.ww - 1;
y _ IF newline THEN child.wy + child.wh - 1 ELSE child.wy;
RETURN[child];
};
larkViewer: ViewerClasses.Viewer = Containers.Create[
info: [parent: parent, border: FALSE, scrollable: TRUE,
wx: 0, wy: d.larksY, ww: parent.cw, wh: d.larksH] ];
Containers.ChildXBound[parent, larkViewer];
FOR i: LarkControl.LarkIndex IN LarkControl.LarkIndex DO
lData: LarkControl.LarkData _ NEW[LarkControl.LarkDataObject];
lData.world _ d;
lData.address.net _ d.net;
lData.address.host _ [i];
lData.address.socket _ TeleLoad.teleSwatSocket;
lData.nameRope _ lData.addressRope _ IO.PutFR["%03b#%03b#", IO.card[lData.address.net], IO.card[lData.address.host]];
lData.rName _ Rope.Concat[lData.addressRope, ".lark"];
[] _ Label[IO.PutFR["%03b", IO.card[lData.address.host]], FALSE];
lData.userRNameViewer _ Label["               ", FALSE];
[] _ CommandButton["Load", LoadThis, lData, FALSE];
[] _ CommandButton["Reset", ResetThis, lData, FALSE];
lData.debug _ CommandButton["Debug", DebugThis, lData, FALSE];
lData.mode _ CommandButton["Mode W", ModeThis, lData, FALSE];
LarkControl.PaintMode[lData];
[] _ CommandButton["Status", StatusThis, lData, FALSE];
lData.status _ Label[NIL, TRUE];
Containers.ChildXBound[larkViewer, child];
lData.eval _ NIL;
lData.h _ TeleLoad.Start[host: lData.addressRope, log: lData.world.out];
IF lData.h = NIL THEN ERROR;
d.larks[i] _ lData;
ENDLOOP;
};

[] _ ViewerEvents.RegisterEventProc[DestroyProc, destroy];
Commander.Register[key: "LarkControl", proc: Create, doc: "LarkControl net-name, Create a lark control viewer for the given network"];

END.
April 25, 1983 1:02 pm, LCS, stolen from DebugTool (viewer parts)
June 21, 1983 2:37 pm, LCS, Fix ResetAll
December 22, 1983 1:41 pm, LCS, Cedar 5
December 26, 1983 2:40 pm, LCS, patchup addresses with StripChar

���n��LarkControlImpl.mesa
L. Stewart, December 26, 1983 4:12 pm
The master data structure
PROC [viewer: ViewerClasses.Viewer, event: ViewerEvents.ViewerEvent]

Global control buttons
Per-Lark control buttons

******** Viewer management ******** --
Turn off event server
Stop watfcher process
Stop all debug processes (or just print if there are any)
This is a separate procedure so that it is synchronized with d.mbQueue --
Thus, the buttons can't be invoked until we've finished creating them, and called SetWorld.
Label: PROC[name: Rope.ROPE, newline: BOOL] =
{
child _ Labels.Create[
info: [name: name, parent: v, border: FALSE,
wy: y, wx: x+1],
paint: TRUE ];
x _ IF newline THEN 1 ELSE child.wx + d.maxW - 1;
y _ IF newline THEN child.wy + child.wh - 1 ELSE child.wy;
};
kludge to find max button size! --
new line
[nameRope: lData.nameRope, addressRope: lData.addressRope] _ TeleLoad.AddressToName[address: lData.address];
lData.rName _ IO.PutFR["%03b#%03b#.lark", IO.card[lData.address.net], IO.card[lData.address.host]];
Mainline code.  Register an event proc to handle the destruction of the viewer, then create the viewer.
Ê$��˜�Jš
œ™Jš
œ%™%J˜�š
Ïk	˜	Jšœœ'˜4Jšœœ]˜pJšœ
œ˜(Jšœœ!˜2Jšœœ$˜4Jšœ
œ˜%Jšœ
˜Jšœœ˜"Jš
œ˜Jšœ
œQ˜cJšœ	œ.˜<Jšœœ
˜Jšœœ9˜FJšœ	œ˜%Jšœœœ˜!Jšœœ˜Jšœœ
˜Jšœ	œt˜‚
Jšœœ
˜Jšœœ
˜Jšœ
œ ˜2Jšœ	œ˜%Jšœ
œ*˜9—J˜�Jšœœ
˜Jšœ=œ‚
˜È
Jšœ˜Jš
˜J™Jšœ
œ
œ
œ
œœ
˜#J˜�Jšœœœœ˜]J˜�Jš	œ*œœœœ˜rJ˜�JšÏnœœ
œ
œœ
œ
œ
œœ˜SJ˜�šžœœ
œœœ
œ˜PJš
œ˜Jš
œœ
œ
œœ˜'Jšœ œ
œœ+˜`Jš
œ˜Jš
œœ
œ
œœ˜ Jš
œ˜J˜—J˜�šžœœ
œœ!˜WJš
œ˜Jš
œœ
œ
œœ˜'Jšœ œœ
œœ
œœ˜ašœœ
œ
œ
œœœ
˜@Jšœœ˜Jšœœ
œ˜:Jšœ
˜—Jšœœ˜
J˜—J˜�šœ&œ˜/Jš
œD™DJš
œ˜šœœ
œ
œ
œœœ
˜@Jšœœ˜Jšœœ
œ
˜Jš
˜Jšœœ
˜Jšœ
˜—šœœ
œ˜šœœ˜8šœœ
œ˜Jš
œ3˜3Jšœ
˜J˜—Jšœ
˜—Jš
œ5˜5Jš
œ˜Jš
œ;˜;Jš
œ˜—J˜—J˜�šž	œœœ
œ˜)Jšœœ
˜)J˜-J˜—J™�J™J˜�šœœ˜(Jšœœ
˜)Jšœœ˜J˜—J˜�šœ œ˜)Jšœœ
˜)J˜EJ˜—J˜�šœ œ˜)Jšœœ
˜)J˜šœœ˜8Jšœœœœ˜5Jš
œ˜Jš
œi˜išœ'œœ˜EJšœ+œœ˜CJš
œ˜J˜—Jšœ˜	—J˜—J˜�šœœ˜(Jšœœ
˜)J˜šœœ˜8Jšœœœœ˜5Jš
œ˜Jšœœ
œ
˜ Jšœœ[œ˜~Jšœœ˜5Jšœ˜	—J˜—J˜�šœœ˜(Jšœœ
˜)J˜šœœ˜8Jšœœœœ˜5Jš
œ˜Jšœœ
œ
˜ JšœTœ˜[šœ*œ˜2Jš
œ<˜<Jšœ
˜J˜—Jšœ'œ
œÏc˜<Jš
œA˜AJš
œ˜Jšœ˜	—J˜—J˜�šœ"œ˜+Jšœœ
˜)Jšœœ
œœ
˜3š
žœœ!œœœ˜NJš
œš
˜š
Jšœœ
œœ˜KJšœœ˜J˜—J˜.šœœ
˜Jš
œ7˜7Jš
œ%˜%Jšœ
˜—J˜—J˜�šœ6œ˜?Jšœœ
˜)šœ!œ˜Fšœ&œ˜.Jš
œ˜Jšœ
˜J˜—Jš
˜Jšœœ
˜Jšœ
˜—J˜—J˜�J™J™�šœœ˜(Jšœœ
˜0Jšœ@œœ˜[šœ*œ˜2Jš
œ<˜<Jšœ
˜J˜—Jšœœ
œ%˜?šœ˜Jš
œ@˜@Jšœ
˜J˜—Jšœœ˜4šœ˜Jš
œœ
œ)œœ˜\Jšœœ
œ6œ˜VJ˜—J˜—J˜�šœ œ˜)Jšœœ
˜0Jšœœ[œ˜~Jšœœ˜5Jš
œ˜J˜�—šœœ˜(Jšœœ
˜0šœœœ˜0Jš
œ˜JšœœŸ˜'Jšœ+œœ˜CJ˜
—Jšœ˜Jš
œ˜Jš
œ˜J˜�—šœ œ˜)Jšœœ
˜0Jšœ
œ
˜šœ
˜˜Jšœ
œ
œ,˜CJšœ/˜3Jš	œœ
œ
œœ˜3Jš
œ˜Jš
œ˜J˜—˜JšœDœ˜JJš
œ‘
˜‘
J˜—˜	JšœHœ˜NJš
œ’
˜’
J˜—Jšœ
˜—Jš
œ˜—J˜�šœ!œ˜*Jšœœ
˜0Jšœ3œ˜NJ˜—J˜�Jš
œ&™&J˜�š
œ!˜!Jš
œ!˜!Jš
œ˜Jš
œ˜Jšœœ
˜JšœMœ˜ZJšœœ
œ
œ˜)šœœ˜J˜3Jšœ
˜J˜—Jš
œ@˜@šœ
œœ˜Jšœ#œ˜5Jšœ
˜J˜—šœœ
œ
œ
œœœ
˜@Jšœœ˜šœœ˜Jšœ<œ˜NJšœ
˜J˜—Jšœ
˜—Jšœœ$˜+J˜J˜J˜6Jš
œ˜—J˜�šžœœœ
œ˜1Jšœœ
˜)J˜J™J™J™9šœœ˜8J˜Jšœ
œ
˜Jšœ
œ
˜Jš
œ˜Jšœ	œ
˜
Jšœœ
˜Jšœœ
˜Jšœœ
˜Jšœœ
˜Jšœ
˜—Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜�—šžœœ
œ
œ˜)Jš
œI™IJš
œ[™[J˜
Jšœœ
˜)˜,Jš	œ
œ œ)œ
œ˜p—Jšœœ
˜"Jšœœ˜Jšœœ˜Jš
œ˜š
ž
œœœ"œ
œ
˜MJšœ	œœœ˜'J˜
˜J˜
Jšœ&œ˜;J˜J˜Jšœœ
˜Jšœœ
˜J˜—Jšœœ	œœ˜3Jšœœ	œœ
˜:J˜—šž	œœœ
˜&Jšœ"˜)J˜
Jš
œW˜WJš
œ˜J˜J˜Jšœ˜	J˜—šžœœœœ™-J™
™šœ&œ
™,J™—Jšœœ™—Jšœœ	œœ™1Jšœœ	œœ
™:J™—šžœœ˜J˜
˜šœœ
˜ J˜—Jšœœ˜—J˜!J˜J˜J˜—J˜
˜
Jš
œ"™"š
œ&˜&šœ0œ
˜6J˜—Jšœœœ	œ˜5—J˜J˜J˜—J˜JšœœG˜PJšœbœ®
˜”Jš
œ!˜!šœ@œ
˜EJš
œ:˜:—Jš
œ˜Jš
Ÿ™Jš
œ%˜%Jš
œ˜Jšœ?œ˜FJšœDœ˜KJšœBœ˜IJšœBœ˜IJšœHœ˜NJ˜
J˜J˜
J˜0J˜˜˜'Jšœœ
˜J˜——J˜$J˜$Jšœ+œ"œ˜[J˜-J˜J˜Jš
œ˜Jš
œ5˜5Jš
œ˜Jšœœ˜#J˜J˜�—J˜�šžœœœ˜8J˜(Jšœœ
˜"Jšœœ˜Jšœœ˜š
ž
œœœ"œ
œ
˜MJšœ	œœœ˜9˜J˜
šœ/œ
˜4Jš	œœ	œœŸœ˜M—J˜J˜Jšœœ˜—Jšœœ	œœ˜3Jšœœ	œœ
˜:Jšœ˜J˜—šžœœœœœ˜LJ˜
Jš	œFœœ	œœ˜‘
Jšœœ	œœ˜3Jšœœ	œœ
˜:Jšœ˜J˜—š
œ5˜5šœœœ
˜7J˜4——Jš
œ+˜+šœœ˜8Jšœœ˜>Jš
œ˜J˜J˜J˜/Jšœ%œœœ˜uJš
œl™lJšœœœœ™cJš
œ6˜6Jšœœœœ˜AJšœ1œ˜8Jšœ,œ˜3Jšœ.œ˜5Jšœ7œ˜>Jšœ6œ˜=Jš
œ˜Jšœ0œ˜7Jšœœœ˜ Jš
œ*˜*Jšœ
œ
˜Jš
œH˜HJšœœ
œ
œ
˜Jš
œ˜—Jšœ
˜J˜—J˜�J™gJ˜:Jš
Ϡ
˜†
J˜�Jšœ
˜Jšœœ&˜AJšœœ˜(Jšœœ	˜'Jšœœ"˜@J˜�—�…—����;ü��QŽ��