DIRECTORY
AMModel USING [ParentSection, Section, SectionClass, SectionName, SectionSource, Source, SourceObj],
AMModelLocation USING [CodeLocation, EntryLocations],
AMViewerOps USING [ReportProc, SectionFromSelection, ViewerFromSection],
BackStop USING [Call],
BasicTime USING [GetClockPulses, Pulses, PulsesToMicroseconds],
Commander USING [CommandProc, Register],
FastBreak USING [ClearFastBreak, FastBreakId, SetFastBreak],
IO USING [PutFR],
Menus USING [AppendMenuEntry, CreateEntry, CreateMenu, Menu, MenuProc],
MessageWindow USING [Append],
NumberLabels USING [CreateNumber, NumberLabel, NumberLabelUpdate],
PrincOps USING [BytePC, FrameCodeBase],
Process USING [Detach, Milliseconds, MsecToTicks, SetTimeout],
Rope USING [Cat, ROPE],
ViewerOps USING [ChangeColumn, ComputeColumn, PaintViewer, SetMenu, SetOpenHeight],
VTables USING [Create, ExchangeRows, GetTableEntry, Install, NullBorder, SetRowsAndColumns, SetTableEntry, VTable];

Celtics: CEDAR MONITOR
IMPORTS AMModel, AMModelLocation, AMViewerOps, BackStop, BasicTime, Commander, FastBreak, IO, Menus, MessageWindow, NumberLabels, Process, Rope, ViewerOps, VTables
= BEGIN


BytePC: TYPE = PrincOps.BytePC;
CARD: TYPE = LONG CARDINAL;
CodeLocation: TYPE = AMModelLocation.CodeLocation;
CodeLocationList: TYPE = LIST OF CodeLocation;
FrameCodeBase: TYPE = PrincOps.FrameCodeBase;
ROPE: TYPE = Rope.ROPE;
Section: TYPE = AMModel.Section;
Source: TYPE = AMModel.Source;
SourceObj: TYPE = AMModel.SourceObj;

BaseData: TYPE = REF BaseDataRep;
BaseDataRep: TYPE = RECORD [
vtab: VTables.VTable _ NIL,
head: EachData _ NIL,
changeCond: CONDITION,
timeCond: CONDITION,
locked: BOOL _ FALSE,
rows: NAT _ 0,
cols: NAT _ limitCol];

EachData: TYPE = REF EachDataRep;
EachDataRep: TYPE = RECORD [
next: EachData _ NIL,
isTotal: BOOL _ FALSE,
lastCount: INT _ 0, -- last count displayed
id: FastBreak.FastBreakId _ NIL];

setCol: NAT = 0;
clearCol: NAT = 1;
countCol: NAT = 2;
codeCol: NAT = 3;
pcCol: NAT = 4;
posCol: NAT = 5;
nameCol: NAT = 6;
limitCol: NAT = 7;

UpdateDisplayProcess: PROC = TRUSTED {
vtab: VTables.VTable _ VTables.Create[rows: 1, columns: limitCol, name: "Celtics", x: 0, y: 2];
data: BaseData _ NEW[BaseDataRep];
pulses: BasicTime.Pulses _ BasicTime.GetClockPulses[];
menu: Menus.Menu _ Menus.CreateMenu[];
inner: PROC [data: BaseData] = TRUSTED {
newPulses: BasicTime.Pulses _ BasicTime.GetClockPulses[];
inverseSecs: REAL; 
deltaMicros: CARD _
BasicTime.PulsesToMicroseconds[newPulses] - BasicTime.PulsesToMicroseconds[pulses];
each: EachData _ data.head;
lag: EachData _ NIL;
index: NAT _ 1;
changed: BOOL _ FALSE;
newRows: NAT _ data.rows;
subTotal, grandTotal: INT _ 0;
IF deltaMicros < 100 THEN RETURN;
inverseSecs _ 1E6 / deltaMicros;
pulses _ newPulses;
WHILE NOT vtab.destroyed AND each # NIL DO
id: FastBreak.FastBreakId _ each.id;
next: EachData _ each.next;
SELECT TRUE FROM
each.isTotal => {
nl: NumberLabels.NumberLabel _ VTables.GetTableEntry[vtab, index, countCol];
current: INT _ subTotal;
last: INT _ each.lastCount;
index _ index + 1;
lag _ each;
IF nl # NIL AND current # last THEN {
each.lastCount _ current;
NumberLabels.NumberLabelUpdate[nl, each.lastCount];
};
subTotal _ 0;
};
id = NIL => {
changed _ TRUE;
FOR i: NAT IN [index+1..data.rows) DO
VTables.ExchangeRows[vtab, i, i-1];
ENDLOOP;
IF lag = NIL THEN data.head _ next ELSE lag.next _ next;
};
ENDCASE => {
nl: NumberLabels.NumberLabel _ VTables.GetTableEntry[vtab, index, countCol];
current: INT _ id^;
last: INT _ each.lastCount;
index _ index + 1;
lag _ each;
subTotal _ subTotal + current;
grandTotal _ grandTotal + current;
IF nl # NIL AND current # last THEN {
each.lastCount _ current;
NumberLabels.NumberLabelUpdate[nl, each.lastCount];
};
};
each _ next;
ENDLOOP;
IF NOT vtab.parent.iconic THEN
NumberLabels.NumberLabelUpdate[VTables.GetTableEntry[vtab, 0, countCol], grandTotal];
IF changed THEN InstallNewRows[data, index];
};
data.vtab _ vtab;
Menus.AppendMenuEntry[menu, Menus.CreateEntry[
name: "Set", proc: SetFastBreak, clientData: data]];
Menus.AppendMenuEntry[menu, Menus.CreateEntry[
name: "Clear *", proc: ClearAll, clientData: data]];
Menus.AppendMenuEntry[menu, Menus.CreateEntry[
name: "Reset *", proc: ResetAllCounts, clientData: data]];
Menus.AppendMenuEntry[menu, Menus.CreateEntry[
name: "AddSubTotal", proc: AddSubTotal, clientData: data]];
VTables.SetTableEntry[
table: vtab, row: 0, column: countCol, flavor: $Viewer,
clientData: NumberLabels.CreateNumber[info: [parent: vtab], chars: 9, paint: FALSE],
useMaxSize: TRUE];
ViewerOps.ChangeColumn[vtab.parent, left];
ViewerOps.SetMenu[vtab.parent, menu, FALSE];
InstallNewRows[data, 1];
SetPause[data];
UNTIL WaitForChange[data] DO
ENABLE ABORTED => EXIT;
DoUnderLock[data, inner];
ENDLOOP;
DoUnderLock[data, innerClearAll];
InstallNewRows[data, 0];
};

AddSubTotal: Menus.MenuProc = TRUSTED {
DoUnderLock[clientData, innerAddSubTotal];
};

innerAddSubTotal: PROC [data: BaseData] = {
vtab: VTables.VTable = data.vtab;
eachData: EachData _ NEW[EachDataRep];
row: NAT = data.rows;
eachData.isTotal _ TRUE;
IF data.head = NIL
THEN data.head _ eachData
ELSE
FOR each: EachData _ data.head, each.next DO
IF each.next = NIL THEN {each.next _ eachData; EXIT};
ENDLOOP;
InstallNewRows[data, row + 1];
VTables.SetTableEntry[
table: vtab, row: row, column: clearCol,
name: "clear", proc: ClearBreak, clientData: eachData,
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: countCol, flavor: $Viewer,
clientData: NumberLabels.CreateNumber[info: [parent: vtab], chars: 9, paint: FALSE],
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: nameCol, flavor: $Text,
name: "subTotal", proc: NIL, clientData: eachData,
useMaxSize: TRUE];
VTables.Install[vtab];
};

ClarkKent: AMViewerOps.ReportProc = {
MessageWindow.Append[msg, TRUE];
};

SetFastBreak: Menus.MenuProc = {
DoUnderLock[clientData, innerSetFastBreak];
};

innerSetFastBreak: PROC [data: BaseData] = {
stage: ROPE _ "Can't do it, ";
inner: PROC = TRUSTED {
section: Section _ NIL;
source: Source _ NIL;
locationList: CodeLocationList _ NIL;
vtab: VTables.VTable = data.vtab;
row: NAT _ data.rows;
pos: INT;
parent: Section;
parentName: ROPE;
section _ AMViewerOps.SectionFromSelection[].section;
parent _ section;
IF AMModel.SectionClass[section] = statement THEN
parent _ AMModel.ParentSection[section];
parentName _ AMModel.SectionName[parent];
IF AMModel.SectionClass[parent] = proc THEN {
DO
parent _ AMModel.ParentSection[parent];
IF AMModel.SectionClass[parent] # proc THEN EXIT;
ENDLOOP;
parentName _ Rope.Cat[AMModel.SectionName[parent], ".", parentName];
}; 
source _ AMModel.SectionSource[section];
WITH source SELECT FROM
entire: REF SourceObj[entire] => pos _ -1;
field: REF SourceObj[field] => {
pos _ field.firstCharIndex;
[] _ AMViewerOps.ViewerFromSection[section, ClarkKent];
};
ENDCASE;
locationList _ AMModelLocation.EntryLocations[section].list;
IF locationList = NIL THEN {
MessageWindow.Append["No such locations found!", TRUE];
RETURN;
};
FOR locList: CodeLocationList _ locationList, locList.rest UNTIL locList = NIL DO
loc: CodeLocation = locList.first;
code: FrameCodeBase _ loc.codeBase;
pc: BytePC = loc.pc;
eachData: EachData;
code.out _ FALSE;  -- Because nobody expects the Spanish Inquisition!
eachData _ NEW[EachDataRep _ [id: FastBreak.SetFastBreak[code.longbase, pc]]];
IF data.head = NIL
THEN data.head _ eachData
ELSE
FOR each: EachData _ data.head, each.next DO
IF each.next = NIL THEN {each.next _ eachData; EXIT};
ENDLOOP;
MessageWindow.Append["Counting break set in ", TRUE];
MessageWindow.Append[parentName];
InstallNewRows[data, row + 1];
VTables.SetTableEntry[
table: vtab, row: row, column: setCol,
name: "reset", proc: ResetCount, clientData: eachData,
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: clearCol,
name: "clear", proc: ClearBreak, clientData: eachData,
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: countCol, flavor: $Viewer,
clientData: NumberLabels.CreateNumber[info: [parent: vtab], chars: 9, paint: FALSE],
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: codeCol, flavor: $Text,
name: IO.PutFR["%bB", [cardinal[LOOPHOLE[code]]]],
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: pcCol, flavor: $Text,
name: IO.PutFR["%bB", [cardinal[pc]]],
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: posCol, flavor: $Text,
name: IO.PutFR["%d", [integer[pos]]],
useMaxSize: TRUE];
VTables.SetTableEntry[
table: vtab, row: row, column: nameCol, flavor: $Text,
name: parentName,
useMaxSize: TRUE];
row _ row + 1;
ENDLOOP;
VTables.Install[vtab];
};
msg: ROPE _ BackStop.Call[inner];
IF msg # NIL THEN {
MessageWindow.Append[stage, TRUE];
MessageWindow.Append[msg];
MessageWindow.Append["."];
};
};

ClearAll: Menus.MenuProc = {
DoUnderLock[clientData, innerClearAll];
};

innerClearAll: PROC [data: BaseData] = {
vtab: VTables.VTable = data.vtab;
FOR each: EachData _ data.head, each.next WHILE each # NIL DO
IF each.id # NIL THEN TRUSTED {
[] _ FastBreak.ClearFastBreak[each.id];
each.id _ NIL;
};
each.isTotal _ FALSE;
ENDLOOP;
};

ClearBreak: Menus.MenuProc = {
WITH clientData SELECT FROM
each: EachData => TRUSTED {
id: FastBreak.FastBreakId = each.id;
IF id # NIL THEN {each.id _ NIL; [] _ FastBreak.ClearFastBreak[id]};
each.isTotal _ FALSE;
};
ENDCASE;
};

ResetCount: Menus.MenuProc = TRUSTED {
WITH clientData SELECT FROM
each: EachData => {
id: FastBreak.FastBreakId = each.id;
IF id # NIL THEN id^ _ 0;
};
ENDCASE;
};

ResetAllCounts: Menus.MenuProc = {
DoUnderLock[clientData, innerResetAllCounts];
};

innerResetAllCounts: PROC [data: BaseData] = TRUSTED {
vtab: VTables.VTable = data.vtab;
FOR each: EachData _ data.head, each.next WHILE each # NIL DO
IF each.id # NIL THEN each.id^ _ 0;
ENDLOOP;
};

fudge: NAT _ 20;
InstallNewRows: PROC [data: BaseData, rows: NAT] = TRUSTED {
IF data # NIL THEN {
vtab: VTables.VTable _ data.vtab;
IF vtab # NIL AND NOT vtab.destroyed AND rows # data.rows THEN {
parent: VTables.VTable _ vtab.parent;
smaller: BOOL _ rows < data.rows;
IF rows = 0 THEN data.cols _ 0;
VTables.SetRowsAndColumns[vtab, data.rows _ rows, data.cols];
SELECT rows FROM
0 => {};
1 => {
VTables.SetTableEntry[
table: vtab, column: codeCol, name: NIL, border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: pcCol, name: NIL, border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: posCol, name: NIL, border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: nameCol, name: NIL, border: VTables.NullBorder];
};
2 => {
VTables.SetTableEntry[
table: vtab, column: codeCol, name: "code", border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: pcCol, name: "pc", border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: posCol, name: "pos", border: VTables.NullBorder];
VTables.SetTableEntry[
table: vtab, column: nameCol, name: "name", border: VTables.NullBorder];
};
ENDCASE;
VTables.Install[vtab, FALSE];
ViewerOps.SetOpenHeight[parent, vtab.wh + fudge];
IF NOT parent.iconic THEN {
ViewerOps.ComputeColumn[parent.column];
IF smaller THEN ViewerOps.PaintViewer[parent, all, TRUE, NIL];
};
}};
};

WaitForChange: ENTRY PROC [data: BaseData] RETURNS [quit: BOOL] = TRUSTED {
ENABLE UNWIND => NULL;
vtab: VTables.VTable = data.vtab;
WAIT data.timeCond;
RETURN [vtab.destroyed];
};

SetPause: PROC [data: BaseData, pause: Process.Milliseconds _ 1000] = TRUSTED {
ENABLE UNWIND => NULL;
Process.SetTimeout[@data.timeCond, Process.MsecToTicks[pause]];
};

AcquireLock: ENTRY PROC [data: BaseData] = TRUSTED {
ENABLE UNWIND => NULL;
WHILE data.locked DO WAIT data.changeCond; ENDLOOP;
data.locked _ TRUE;
};

ReleaseLock: ENTRY PROC [data: BaseData] = TRUSTED {
ENABLE UNWIND => NULL;
data.locked _ FALSE;
BROADCAST data.changeCond;
};

DoUnderLock: PROC [ref: REF, inner: PROC [data: BaseData]] = TRUSTED {
WITH ref SELECT FROM
data: BaseData => {
ENABLE UNWIND => ReleaseLock[data];
AcquireLock[data];
inner[data];
ReleaseLock[data];
};
ENDCASE;
};

StartCeltics: Commander.CommandProc = TRUSTED {
Process.Detach[FORK UpdateDisplayProcess[]];
};

Commander.Register["Celtics", StartCeltics, "is a tool to take counts of fast breaks."];

END.
,Celtics.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Russ Atkinson (RRA) June 24, 1985 8:48:34 pm PDT
T Y P E S
update the count
Update event count
remove the row from the table
update the count
Update event count
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
[msg: ROPE, severity: Severity]
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
try to find the module name as well
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
PROC [parent: REF ANY, clientData: REF ANY _ NIL,
mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]
WaitForChange waits until there is a change to some value, then gets the lock for us.
Κp˜
codeš
œ™Kšœ
Οm
œ1™<K™0—K˜š
Οk	˜	KšœžœW˜dKšœžœ ˜5Kšœžœ7˜HKšœ	žœ˜Kšœ
žœ0˜?Kšœ
žœ˜(Kšœ
žœ-˜<Kšžœ
žœ	˜Kšœžœ<˜GKšœžœ
˜Kšœ
žœ0˜BKšœ	žœ˜'Kšœžœ1˜>Kšœžœžœ˜Kšœ
žœD˜SKšœžœf˜sK˜—šœ	žœ
ž˜Kšžœœ
˜£
Kšœž˜K˜—š
œ	™	K˜Kšœžœ˜Kšžœžœžœ
žœ
˜Kšœžœ ˜2Kšœžœžœ
žœ˜.Kšœžœ˜-Kšžœžœžœ
˜Kšœ	žœ˜ Kšœžœ˜Kšœžœ˜$K˜Kšœ
žœžœ
˜!šœ
žœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœž	œ
˜Kšœ
ž	œ
˜Kšœžœ
˜Kšœžœ˜Kšœžœ
˜K˜—Kšœ
žœžœ
˜!šœ
žœžœ˜Kšœžœ
˜Kšœ	žœžœ
˜KšœžœΟc˜+Kšœžœ˜!K˜—Kšœžœ˜Kšœ
žœ˜Kšœ
žœ˜Kšœ	žœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜Kšœ
žœ˜K˜—šΟnœžœžœ˜&Kš
œ_˜_Kšœžœ˜"Kš
œ6˜6Kš
œ&˜&šœžœžœ˜(Kš
œ9˜9Kšœ
žœ˜šœ
žœ˜Kš
œS˜S—Kš
œ˜Kšœžœ
˜Kšœžœ˜Kšœ	žœžœ
˜Kšœ	žœ
˜Kšœžœ˜Kšžœžœ
žœ
˜!Kš
œ ˜ Kš
œ˜š	žœ
žœžœžœ
ž˜*Kš
œ$˜$Kš
œ˜šžœ
žœ
ž˜š
œ˜Kš
œ™Kš
œL˜LKšœ	žœ˜Kšœžœ˜K˜K˜šžœžœ
žœžœ˜%Kš
œ™Kš
œ˜Kš
œ3˜3K˜—Kš
œ
˜
K˜—šœžœ˜
Kš
œ™Kšœ
žœ
˜šžœžœ
žœž˜%Kš
œ#˜#Kšžœ
˜—Kšžœžœ
žœžœ˜8K˜—šžœ˜Kš
œ™Kš
œL˜LKšœ	žœ˜Kšœžœ˜K˜K˜Kš
œ˜Kš
œ"˜"šžœžœ
žœžœ˜%Kš
œ™Kš
œ˜Kš
œ3˜3K˜—K˜——Kš
œ˜Kšžœ
˜—šžœ
žœž˜Kš
œU˜U—Kšžœ	žœ˜,Kš
œ˜—Kš
œ˜š
œ.˜.Kš
œ4˜4—š
œ.˜.Kš
œ4˜4—š
œ.˜.Kš
œ:˜:—š
œ.˜.Kš
œ;˜;—š
œ˜Kš
œ7˜7KšœMžœ˜TKšœžœ˜—Kš
œ*˜*Kšœ%žœ˜,Kš
œ˜K˜šžœž˜Kšžœ
žœžœ
˜Kš
œ˜Kšžœ
˜—Kš
œ!˜!Kš
œ˜K˜K˜—šœžœ˜'šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—Kš
œ*˜*K˜K˜—šœžœ˜+Kš
œ!˜!Kšœžœ˜&Kšœžœ
˜Kšœžœ
˜šžœ
ž˜Kšžœ˜š
ž˜šžœ'ž˜,Kšžœ
žœ
žœžœ˜5Kšžœ
˜———Kš
œ˜š
œ˜Kš
œ(˜(Kš
œ6˜6Kšœžœ˜—š
œ˜Kš
œ9˜9KšœMžœ˜TKšœžœ˜—š
œ˜Kš
œ6˜6Kšœžœ˜2Kšœžœ˜—Kš
œ˜K˜K˜—š
œ%˜%Kš
œ™Kšœžœ˜ Kš
œ˜K˜—š
œ ˜ šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—Kš
œ+˜+K˜K˜—šœžœ˜,Kšœžœ˜šœžœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœ!žœ
˜%Kš
œ!˜!Kšœžœ
˜Kšœžœ
˜	Kš
œ˜Kšœžœ
˜Kš
œ5˜5Kš
œ˜šžœ+ž˜1Kš
œ(˜(—Kš
œ)˜)šžœ%žœ˜-Kš
œ#™#š
ž˜Kš
œ'˜'Kšžœ%žœ
žœ
˜1Kšžœ
˜—Kš
œD˜DKš
œ˜—Kš
œ(˜(šžœžœ
ž˜Kšœžœ˜*šœžœ˜ Kš
œ˜Kš
œ7˜7K˜—Kšžœ
˜—Kš
œ<˜<šžœžœ
žœ˜Kšœ1žœ˜7Kšžœ
˜Kš
œ˜—šžœ8žœžœ
ž˜QKš
œ"˜"Kš
œ#˜#Kš
œ˜Kš
œ˜KšœžœŸ2˜EKšœžœ@˜Nšžœ
ž˜Kšžœ˜š
ž˜šžœ'ž˜,Kšžœ
žœ
žœžœ˜5Kšžœ
˜———Kšœ/žœ˜5Kš
œ!˜!Kš
œ˜š
œ˜Kš
œ&˜&Kš
œ6˜6Kšœžœ˜—š
œ˜Kš
œ(˜(Kš
œ6˜6Kšœžœ˜—š
œ˜Kš
œ9˜9KšœMžœ˜TKšœžœ˜—š
œ˜Kš
œ6˜6Kšœžœžœ
˜2Kšœžœ˜—š
œ˜Kš
œ4˜4Kšœžœ˜&Kšœžœ˜—š
œ˜Kš
œ5˜5Kšœžœ˜%Kšœžœ˜—š
œ˜Kš
œ6˜6Kš
œ˜Kšœžœ˜—Kš
œ˜Kšžœ
˜—Kš
œ˜K˜—Kšœžœ˜!šžœžœ
žœ˜Kšœžœ˜"Kš
œ˜Kš
œ˜K˜—K˜—K˜š
œ˜šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—Kš
œ'˜'K˜K˜—šœžœ˜(Kš
œ!˜!šžœ'žœžœ
ž˜=šžœžœ
žœ
žœ˜Kš
œ'˜'Kšœ
žœ
˜K˜—Kšœžœ
˜Kšžœ
˜—K˜K˜—š
œ˜šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—šžœžœ
ž˜šœžœ˜Kš
œ$˜$Kšžœžœ
žœžœ%˜DKšœžœ
˜K˜—Kšžœ
˜—K˜K˜—šœžœ˜&šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—šžœžœ
ž˜š
œ˜Kš
œ$˜$Kšžœžœ
žœ	˜K˜—Kšžœ
˜—K˜K˜—š
œ"˜"šžœ
žœ
žœžœ
žœžœ
™1Kšœ0žœžœ
™=—Kš
œ-˜-K˜K˜—šœžœžœ˜6Kš
œ!˜!šžœ'žœžœ
ž˜=Kšžœžœ
žœ˜#Kšžœ
˜—K˜K˜—Kšœžœ˜š œžœžœžœ˜<šžœžœ
žœ˜Kš
œ!˜!šžœžœ
žœ
žœžœžœ˜@Kš
œ%˜%Kšœ	žœ˜!Kšžœ
žœ˜Kš
œ=˜=šžœž˜K˜˜š
œ˜Kšœ$žœ˜E—š
œ˜Kšœ"žœ˜C—š
œ˜Kšœ#žœ˜D—š
œ˜Kšœ$žœ˜E—K˜—š
œ˜š
œ˜Kš
œH˜H—š
œ˜Kš
œD˜D—š
œ˜Kš
œF˜F—š
œ˜Kš
œH˜H—K˜—Kšžœ
˜—Kšœžœ˜Kš
œ1˜1šžœ
žœžœ˜Kš
œ'˜'Kšžœ	žœ$žœžœ˜>K˜—K˜——K˜K˜—š 
œžœ
žœžœžœžœ˜KKš
œU™UKšžœ
žœžœ
˜Kš
œ!˜!Kšžœ˜Kšžœ˜K˜K˜—š œžœ8žœ˜OKšžœ
žœžœ
˜Kš
œ?˜?K˜K˜—š œžœ
žœžœ˜4Kšžœ
žœžœ
˜Kšžœ
žœ
žœžœ
˜3Kšœžœ
˜K˜K˜—š œžœ
žœžœ˜4Kšžœ
žœžœ
˜Kšœžœ
˜Kšž	œ˜K˜K˜—š
 œžœžœ	žœžœ˜Fšžœžœ
ž˜š
œ˜Kšžœ
žœ˜#Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšžœ
˜—K˜—K˜šœ&žœ˜/Kšœžœ˜,Kš
œ˜—K˜š
œX˜XK˜—Kšžœ
˜—…—/ΤDp