DIRECTORY
RoseTypes, Cluster, RoseCreate, Basics, DragOpsCross, CacheOps, ClusterParams, DragonRosemary, IO, LizardRosemary, Process, Rope, RoseRun, SwitchTypes, Dragon, NumTypes, EnumTypes, IFU, EU, Cache;

ClusterImpl: CEDAR PROGRAM
IMPORTS RoseCreate, CacheOps, ClusterParams, DragonRosemary, IO, LizardRosemary, Process, Rope, RoseRun, RoseTypes, NumTypes, EnumTypes, IFU, EU, Cache
EXPORTS Cluster

= BEGIN OPEN
RoseTypes, Cluster;

PBusCommands: TYPE = Dragon.PBusCommands;
PBusFaults: TYPE = Dragon.PBusFaults;
MBusCommands: TYPE = Dragon.MBusCommands;


RegisterCells: PROC =
BEGIN
Cluster _ RoseCreate.RegisterCellType[name: "Cluster",
expandProc: ClusterExpand,
ioCreator: CreateClusterIO, driveCreator: CreateClusterDrive, 
evals: [],
tests: LIST[[name: "T", proc: ClusterTestT, stateToo: FALSE]],
ports: CreateClusterPorts[]
];
END;
otherss: SymbolTable _ RoseCreate.GetOtherss["Cluster.partsAssertions"];
Cluster: PUBLIC CellType;

CreateClusterPorts: PROC RETURNS [ports: Ports] = {ports _ RoseCreate.PortsFromFile["Cluster.Cluster.rosePorts"]};

ClusterSwitchIORef: TYPE = REF ClusterSwitchIORec;
ClusterSwitchIORec: TYPE = RECORD [
IPRejectB: SwitchTypes.SwitchVal
,DPRejectB: SwitchTypes.SwitchVal
,PhA: SwitchTypes.SwitchVal
,PhB: SwitchTypes.SwitchVal
,Vdd: SwitchTypes.SwitchVal
,Gnd: SwitchTypes.SwitchVal
,PadVdd: SwitchTypes.SwitchVal
,PadGnd: SwitchTypes.SwitchVal
,RescheduleAB: SwitchTypes.SwitchVal
,ClusterError: SwitchTypes.SwitchVal
,DPData: PACKED ARRAY [0 .. 32) OF SwitchTypes.SwitchVal
,DPCmnd3A: PACKED ARRAY [0 .. 8) OF SwitchTypes.SwitchVal
,DPFaultB: PACKED ARRAY [0 .. 4) OF SwitchTypes.SwitchVal
,MDataAB: PACKED ARRAY [0 .. 32) OF SwitchTypes.SwitchVal
,MCmdAB: PACKED ARRAY [0 .. 4) OF SwitchTypes.SwitchVal
,MNShared: SwitchTypes.SwitchVal
,MParityAB: SwitchTypes.SwitchVal
,MNError: SwitchTypes.SwitchVal
,MReadyBA: SwitchTypes.SwitchVal
,M1Rq: SwitchTypes.SwitchVal
,M2Rq: SwitchTypes.SwitchVal
,MNewRq: SwitchTypes.SwitchVal
,M1Gnt: SwitchTypes.SwitchVal
,M2Gnt: SwitchTypes.SwitchVal
,ResetAB: SwitchTypes.SwitchVal
,DHoldAB: SwitchTypes.SwitchVal
,DShiftAB: SwitchTypes.SwitchVal
,DExecuteAB: SwitchTypes.SwitchVal
,DNSelectAB: SwitchTypes.SwitchVal
,DDataInAB: SwitchTypes.SwitchVal
,DDataOutAB: SwitchTypes.SwitchVal
];

ClusterSimpleIORef: TYPE = REF ClusterSimpleIORec;
ClusterSimpleIORec: TYPE = RECORD [
fill0: [0 .. 32767],
IPRejectB: BOOLEAN
,fill1: [0 .. 32767],
DPRejectB: BOOLEAN
,fill2: [0 .. 32767],
PhA: BOOLEAN
,fill3: [0 .. 32767],
PhB: BOOLEAN
,fill4: [0 .. 32767],
Vdd: BOOLEAN
,fill5: [0 .. 32767],
Gnd: BOOLEAN
,fill6: [0 .. 32767],
PadVdd: BOOLEAN
,fill7: [0 .. 32767],
PadGnd: BOOLEAN
,fill8: [0 .. 32767],
RescheduleAB: BOOLEAN
,fill9: [0 .. 32767],
ClusterError: BOOLEAN
,DPData: ARRAY [0..2) OF CARDINAL
,fill11: [0 .. 255],
DPCmnd3A: PBusCommands
,fill12: [0 .. 4095],
DPFaultB: PBusFaults
,MDataAB: ARRAY [0..2) OF CARDINAL
,fill14: [0 .. 4095],
MCmdAB: MBusCommands
,fill15: [0 .. 32767],
MNShared: BOOLEAN
,fill16: [0 .. 32767],
MParityAB: BOOLEAN
,fill17: [0 .. 32767],
MNError: BOOLEAN
,fill18: [0 .. 32767],
MReadyBA: BOOLEAN
,fill19: [0 .. 32767],
M1Rq: BOOLEAN
,fill20: [0 .. 32767],
M2Rq: BOOLEAN
,fill21: [0 .. 32767],
MNewRq: BOOLEAN
,fill22: [0 .. 32767],
M1Gnt: BOOLEAN
,fill23: [0 .. 32767],
M2Gnt: BOOLEAN
,fill24: [0 .. 32767],
ResetAB: BOOLEAN
,fill25: [0 .. 32767],
DHoldAB: BOOLEAN
,fill26: [0 .. 32767],
DShiftAB: BOOLEAN
,fill27: [0 .. 32767],
DExecuteAB: BOOLEAN
,fill28: [0 .. 32767],
DNSelectAB: BOOLEAN
,fill29: [0 .. 32767],
DDataInAB: BOOLEAN
,fill30: [0 .. 32767],
DDataOutAB: BOOLEAN
];

ClusterDriveRef: TYPE = REF ClusterDriveRec;
ClusterDriveRec: TYPE = RECORD [driveRecordInitialPadding: DriveTagType, drive: PACKED ARRAY ClusterPort OF DriveLevel];
ClusterPort: TYPE = {
IPRejectB, DPRejectB, PhA, PhB, Vdd, Gnd, PadVdd, PadGnd, RescheduleAB, ClusterError, DPData, DPCmnd3A, DPFaultB, MDataAB, MCmdAB, MNShared, MParityAB, MNError, MReadyBA, M1Rq, M2Rq, MNewRq, M1Gnt, M2Gnt, ResetAB, DHoldAB, DShiftAB, DExecuteAB, DNSelectAB, DDataInAB, DDataOutAB, ClusterPortTypePad31};

CreateClusterIO: PROC [ct: CellType, switch: BOOL] RETURNS [ioAsAny: REF ANY] --IOCreator-- = {
ioAsAny _ IF switch THEN NEW[ClusterSwitchIORec] ELSE NEW[ClusterSimpleIORec];
};

CreateClusterDrive: PROC [ct: CellType] RETURNS [driveAsAny: REF ANY] --DriveCreator-- = {
driveAsAny _ NEW[ClusterDriveRec];
};

ClusterExpand: PROC [thisCell: Cell, to: ExpansionReceiver] --ExpandProc-- = {
PrivateLookupNode: PROC [name: ROPE] RETURNS [node: Node] = {node _ RoseCreate.LookupNode[from: thisCell, path: LIST[name]]};
IPRejectB: Node _ PrivateLookupNode["IPRejectB"];
DPRejectB: Node _ PrivateLookupNode["DPRejectB"];
PhA: Node _ PrivateLookupNode["PhA"];
PhB: Node _ PrivateLookupNode["PhB"];
Vdd: Node _ PrivateLookupNode["Vdd"];
Gnd: Node _ PrivateLookupNode["Gnd"];
PadVdd: Node _ PrivateLookupNode["PadVdd"];
PadGnd: Node _ PrivateLookupNode["PadGnd"];
RescheduleAB: Node _ PrivateLookupNode["RescheduleAB"];
ClusterError: Node _ PrivateLookupNode["ClusterError"];
DPData: Node _ PrivateLookupNode["DPData"];
DPCmnd3A: Node _ PrivateLookupNode["DPCmnd3A"];
DPFaultB: Node _ PrivateLookupNode["DPFaultB"];
MDataAB: Node _ PrivateLookupNode["MDataAB"];
MCmdAB: Node _ PrivateLookupNode["MCmdAB"];
MNShared: Node _ PrivateLookupNode["MNShared"];
MParityAB: Node _ PrivateLookupNode["MParityAB"];
MNError: Node _ PrivateLookupNode["MNError"];
MReadyBA: Node _ PrivateLookupNode["MReadyBA"];
M1Rq: Node _ PrivateLookupNode["M1Rq"];
M2Rq: Node _ PrivateLookupNode["M2Rq"];
MNewRq: Node _ PrivateLookupNode["MNewRq"];
M1Gnt: Node _ PrivateLookupNode["M1Gnt"];
M2Gnt: Node _ PrivateLookupNode["M2Gnt"];
ResetAB: Node _ PrivateLookupNode["ResetAB"];
DHoldAB: Node _ PrivateLookupNode["DHoldAB"];
DShiftAB: Node _ PrivateLookupNode["DShiftAB"];
DExecuteAB: Node _ PrivateLookupNode["DExecuteAB"];
DNSelectAB: Node _ PrivateLookupNode["DNSelectAB"];
DDataInAB: Node _ PrivateLookupNode["DDataInAB"];
DDataOutAB: Node _ PrivateLookupNode["DDataOutAB"];
others: SymbolTable _ RoseCreate.GetOthers[otherss, "Cluster"];
IPData: Node _ to.class.NodeInstance[erInstance: to.instance, name: "IPData", type: NumTypes.NumType[32], other: RoseCreate.GetOther[others, "IPData"]];
IPCmnd3A: Node _ to.class.NodeInstance[erInstance: to.instance, name: "IPCmnd3A", type: EnumTypes.EnumType["Dragon.PBusCommands"], other: RoseCreate.GetOther[others, "IPCmnd3A"]];
IPFaultB: Node _ to.class.NodeInstance[erInstance: to.instance, name: "IPFaultB", type: EnumTypes.EnumType["Dragon.PBusFaults"], other: RoseCreate.GetOther[others, "IPFaultB"]];
KBus: Node _ to.class.NodeInstance[erInstance: to.instance, name: "KBus", type: NumTypes.NumType[32], other: RoseCreate.GetOther[others, "KBus"]];
NodeCreateHack1: PROC [name: ROPE] RETURNS [node: Node] = {node _ to.class.NodeInstance[erInstance: to.instance, name: name, type: NumTypes.boolType, other: RoseCreate.GetOther[others, name]]};
EUSt3AisCBus2BA: Node _ NodeCreateHack1["EUSt3AisCBus2BA"];
EURes3BisPBus3AB: Node _ NodeCreateHack1["EURes3BisPBus3AB"];
EUWriteToPBus3AB: Node _ NodeCreateHack1["EUWriteToPBus3AB"];
EUAluOp2AB: Node _ to.class.NodeInstance[erInstance: to.instance, name: "EUAluOp2AB", type: EnumTypes.EnumType["Dragon.ALUOps"], other: RoseCreate.GetOther[others, "EUAluOp2AB"]];
EUCondSel2AB: Node _ to.class.NodeInstance[erInstance: to.instance, name: "EUCondSel2AB", type: EnumTypes.EnumType["Dragon.CondSelects"], other: RoseCreate.GetOther[others, "EUCondSel2AB"]];
EUCondition2B: Node _ NodeCreateHack1["EUCondition2B"];
[] _ to.class.CellInstance[erInstance: to.instance, instanceName: "ifu", typeName: IFU.IFU[[logRef:ClusterParams.ifuLogRef, lizardSimRef:ClusterParams.lizardSimRef]].name, other: RoseCreate.GetOther[others, "ifu"], interfaceNodes: ""];
[] _ to.class.CellInstance[erInstance: to.instance, instanceName: "eu", typeName: EU.EU[[logRef:ClusterParams.euLogRef]].name, other: RoseCreate.GetOther[others, "eu"], interfaceNodes: ""];
[] _ to.class.CellInstance[erInstance: to.instance, instanceName: "iCache", typeName: Cache.Cache[[cacheParm:ClusterParams.iCache, skipRejectsParm:ClusterParams.iCacheSkipRejects]].name, other: RoseCreate.GetOther[others, "iCache"], interfaceNodes: "PData:IPData, PCmdA:IPCmnd3A, PRejectB:IPRejectB, PFaultB:IPFaultB, MRq:M1Rq, MGnt:M1Gnt"];
[] _ to.class.CellInstance[erInstance: to.instance, instanceName: "eCache", typeName: Cache.Cache[[cacheParm:ClusterParams.eCache, skipRejectsParm:FALSE]].name, other: RoseCreate.GetOther[others, "eCache"], interfaceNodes: "PData:DPData, PCmdA:DPCmnd3A, PRejectB:DPRejectB, PFaultB:DPFaultB, MRq:M2Rq, MGnt:M2Gnt"];

{ };


};

ClusterTestT: CellTestProc =
BEGIN
simpleInstr: ClusterSimpleIORef _ NARROW[simpleInstructions];
drive: ClusterDriveRef _ NARROW[driveAsAny];
BEGIN OPEN drive, simpleInstr;
originalPriority: Process.Priority = Process.GetPriority[];
diagnosticName: Rope.ROPE _ "unknown";
Process.SetPriority[ Process.priorityBackground ];
IF clusterPanelChecker=NIL
THEN clusterPanelChecker _ FORK ClusterParams.PanelCheck[];
{
ENABLE UNWIND => {
ClusterParams.clusterLog.PutF["\nSimulation of %g aborted\n\n", IO.rope[diagnosticName]];
ClusterParams.clusterLog.Flush[];
Process.SetPriority[ originalPriority ] };

DoEval: PROC = {
OPEN ClusterParams;
clusterPanel.continueTestFromAbort _ FALSE;
IF PhA THEN {
RescheduleAB	_ clusterPanel.resched;
ResetAB			_ clusterPanel.reset};
[] _ RoseRun.Eval[ handle
! RoseTypes.Stop => IF clusterPanel.continueTestFromAbort
THEN CONTINUE ELSE REJECT ];
IF clusterPanel.reset THEN clusterPanel.instrCount _ -1;
Process.Yield[];
clusterPanel.continueTestFromAbort _ FALSE};

Cycles: PROC [ n: INT ] =
{FOR i: INT IN [0..n) DO DoPh[a]; DoPh[b] ENDLOOP};

DoPh: PROC [ ph: Dragon.Phase ] = {
cp: REF ClusterParams.ControlPanel _ ClusterParams.clusterPanel;
PhB		_ ph=b;
PhA		_ ph=a;
cp.phase	_ ph;
DoEval[];
IF (cp.cycle >= cp.slowFromCycle OR
(cp.cycle>=0 AND cp.instrCount >= cp.slowFromInstr)) AND
cp.stopInPh[ph] THEN {
Remark[IO.PutFR["Doing cycle %g Ph%g...",
IO.int[cp.cycle], IO.char[IF ph=a THEN 'A ELSE 'B]]];
DoEval[] };
PhA _ PhB _ FALSE;
DoEval[];
WHILE cp.repeatPhase DO
PhB _ ph=b; PhA _ ph=a; DoEval[];
Remark[IO.PutFR["...repeating Ph%g evaluation..",
IO.char[IF ph=a THEN 'A ELSE 'B]]];
DoEval[];
PhA _ PhB _ FALSE; DoEval[];
ENDLOOP };

FOR port: ClusterPort IN ClusterPort DO IF drive[port]=test THEN drive[port] _ see ENDLOOP;
drive[PhA]				_ drive;
drive[PhB]				_ drive;
drive[RescheduleAB]	_ drive;
drive[ResetAB]			_ drive;

root		_ RoseTypes.GetSimulationFromCellTestHandle[handle].root;

DO

Chop: PROC RETURNS [ first, rest: Rope.ROPE _ NIL ] =
BEGIN
dStream: IO.STREAM = IO.RIS[ClusterParams.clusterPanel.diagnostic];
first _ dStream.GetTokenRope[IO.IDProc ! IO.EndOfStream => CONTINUE].token;
rest _ ClusterParams.clusterPanel.diagnostic.Substr[dStream.GetIndex];
END;

diagnosticFileName: Rope.ROPE _ diagnosticName _ Chop[].first;
ClusterError					_ FALSE;
ClusterParams.clusterPanel.reset			_ TRUE;
ClusterParams.clusterPanel.stopInPh		_ ALL[TRUE];
ClusterParams.clusterPanel.repeatPhase	_ ClusterParams.clusterPanel.resched _ FALSE;
ClusterParams.clusterPanel.cycle			_ -1;
ClusterParams.clusterPanel.instrCount		_ -1;

Cycles[5 !
DragonRosemary.AssertionFailed => RESUME;
RoseTypes.Stop => IF data = $FailedAssertion THEN RESUME ELSE REJECT ];

SELECT TRUE FROM

Rope.Equal[s1: diagnosticFileName, s2: "END", case: FALSE] => EXIT;

diagnosticFileName # NIL =>
BEGIN
CacheOps.VirtualMemoryFromFile[ClusterParams.vm, diagnosticFileName ];
ClusterParams.lizardSimRef^ _ (IF ClusterParams.clusterPanel.lizardToo THEN LizardRosemary.StartNewLizard[ClusterParams.vm] ELSE NIL);
END;

ClusterParams.clusterPanel.randomSeed#0 =>
BEGIN
diagnosticName _ IO.PutFR["random code (seed = %d)", IO.int[ClusterParams.clusterPanel.randomSeed]];
ClusterParams.InsertRandomProgramInVM[ClusterParams.vm, ClusterParams.clusterPanel.randomSeed, ClusterParams.clusterLog];
ClusterParams.lizardSimRef^ _ (IF ClusterParams.clusterPanel.lizardToo THEN LizardRosemary.StartNewLizard[ClusterParams.vm] ELSE NIL);
END;

ENDCASE => EXIT; -- test is finished!!!

DoPh[a];
ClusterError			_ FALSE;
ClusterParams.clusterPanel.reset	_ FALSE;
DoEval[]; 			-- changes ResetAB during PhA
DoPh[b];

IF ClusterParams.clusterPanel.slowFromCycle<=0 THEN Remark["Processor has been reset..."];

ClusterParams.clusterPanel.cycle _ 0;

ClusterParams.clusterLog.PutF["\n\n\n%g  Dragon Rosemary simulation of %g beginning...\n\n",
IO.time[],
IO.rope[diagnosticName]];

WHILE ClusterParams.clusterPanel.randomSeed=0 OR ClusterParams.clusterPanel.cycle<=ClusterParams.clusterPanel.randomCycleLimit DO

ENABLE {
LizardRosemary.SuccessHalt => {
ClusterParams.clusterLog.PutF["\n%g  Success XOP in %g at instruction %d, cycle %d.\n\n",
IO.time[],
IO.rope[diagnosticName],
IO.int[ClusterParams.clusterPanel.instrCount],
IO.int[ClusterParams.clusterPanel.cycle]];
EXIT;
};
LizardRosemary.Breakpoint => {
ClusterParams.clusterLog.PutF["\n%g  Breakpoint XOP in %g at instruction %d, cycle %d.\n\n",
IO.time[],
IO.rope[diagnosticName],
IO.int[ClusterParams.clusterPanel.instrCount],
IO.int[ClusterParams.clusterPanel.cycle]];
SELECT TRUE FROM
ClusterParams.clusterPanel.emulateBreakpoint => RESUME;
diagnosticFileName # NIL => REJECT;
ENDCASE => EXIT;
};
};


DoPh[a];
DoPh[b];

IF ClusterParams.clusterPanel.ckptEveryNCycles > 0 AND ClusterParams.clusterPanel.ckptAtCycle <= ClusterParams.clusterPanel.cycle THEN
ClusterParams.clusterPanel.ckptAtCycle _ ClusterParams.clusterPanel.cycle+ClusterParams.clusterPanel.ckptEveryNCycles;
ClusterParams.clusterPanel.cycle _ ClusterParams.clusterPanel.cycle+1;
IF ClusterParams.clusterPanel.ckpt OR ClusterParams.clusterPanel.ckptAtCycle = ClusterParams.clusterPanel.cycle THEN {
ClusterParams.clusterPanel.ckpt _ FALSE;
ClusterParams.CheckPoint[ClusterParams.clusterPanel.ckptFile, root]
};
ENDLOOP; -- on ClusterParams.clusterPanel.cycle

SELECT TRUE FROM
diagnosticFileName # NIL =>
BEGIN
first, rest: Rope.ROPE;
[first, rest] _ Chop[];
IF first.Equal[diagnosticFileName] THEN
ClusterParams.clusterPanel.diagnostic _ Rope.Cat[rest, " ",first];
END;
ClusterParams.clusterPanel.randomSeed # 0 =>
ClusterParams.clusterPanel.randomSeed _ ClusterParams.clusterPanel.randomSeed+1;
ENDCASE => NULL;

ENDLOOP; -- on ClusterParams.clusterPanel.randomSeed
 }; -- for catching UNWIND
END;
END;


root:						RoseTypes.Cell _ NIL;
clusterPanelChecker:	PROCESS _ NIL;

Remark: PROC[message: Rope.ROPE] = ClusterParams.Remark;




RegisterCells[];

END.

$ClusterImpl.Mesa
created by RoseTranslate 3.1.3 of September 5, 1985 12:14:34 pm PDT
created from Cluster.Rose of March 11, 1986 12:24:23 pm PST
created for McCreight.pa
created at March 18, 1986 6:01:37 pm PST
Signal Type decls
explicitly requested CEDAR:
explicitly requested CEDAR:
�Êf˜Icodeš
œ™Kš
œC™CKš
œ;™;Kš
œ™Kš
œ(™(K˜K˜š
Ïk	˜	Kšœ_�œT�œ�œ˜Ä
—K˜šÐblœ�œ
�˜Kš�œ6�œJ�œ�œ˜—
Kš�œ˜—K˜šœ�œ
�˜K˜—K˜š
œ™Kšœ�œ˜)Kšœ�œ˜%Kšœ�œ˜)K˜—K˜šÏn
œ�œ˜Kš
�˜˜6K˜K˜>K˜
Kšœ�œ+�œ˜>K˜K˜—Kš�œ
˜—K˜HKšœ	�œ
˜K˜KšŸœ�œ
�œR˜rK˜Kšœ�œ�œ˜2šœ�œ�œ˜#K˜ K˜!K˜K˜K˜K˜K˜K˜K˜$K˜$Kšœ	�œ
�œ�œ˜8Kšœ�œ
�œ
�œ˜9Kšœ�œ
�œ
�œ˜9Kšœ
�œ
�œ�œ˜9Kšœ	�œ
�œ
�œ˜7K˜ K˜!K˜K˜ K˜K˜K˜K˜K˜K˜K˜K˜ K˜"K˜"K˜!K˜"K˜—K˜Kšœ�œ�œ˜2šœ�œ�œ˜#K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜Kšœ	�œ�œ
�˜!K˜K˜K˜K˜Kšœ
�œ�œ
�˜"K˜K˜K˜Kšœ
�˜K˜Kšœ�˜K˜Kšœ	�˜K˜Kšœ
�˜K˜Kšœ�˜
K˜Kšœ�˜
K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ	�˜K˜Kšœ	�˜K˜Kšœ
�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜Kšœ�˜K˜—K˜Kšœ�œ�œ˜,Kšœ�œ�œ2�œ
�œ
�œ
˜xšœ
�œ˜K˜®—K˜šŸœ�œ�œ�œ�œ
�œÏc
œ˜_Kšœ
�œ�œ
�œ�œ
�œ˜NK˜—K˜šŸœ�œ�œ�œ
�œ œ˜ZKšœ
�œ˜"K˜—K˜šŸ
œ�œ) œ˜NKš
Ÿœ�œ�œ�œD�œ	˜}K˜1K˜1K˜%K˜%K˜%K˜%K˜+K˜+K˜7K˜7K˜+K˜/K˜/K˜-K˜+K˜/K˜1K˜-K˜/K˜'K˜'K˜+K˜)K˜)K˜-K˜-K˜/K˜3K˜3K˜1K˜3K˜?K˜˜
K˜³
K˜±
K˜’
KšŸœ�œ�œ�œ—
˜Á
K˜;K˜=K˜=K˜³
K˜¾
K˜7KšœS�œ
�œ‘
˜ë
KšœR�œ
�œf˜½
K˜ÕKšœ“
�œ£
˜»K˜š
œ™˜J˜——K˜K˜—K˜˜Kš
�˜Kšœ"�œ˜=šœ�œ
˜,š�œ
�œ˜J˜;Jšœ�œ
˜&J˜2š�œ�˜Jš�œ�œ˜;—˜
š�œ
�œ˜Jšœ@�œ˜YJ˜!J˜*J˜——šŸœ�œ˜Jš�œ˜Jšœ%�œ
˜+š�œ�œ˜
J˜$J˜ —˜šœ�œ#˜9Jš�œ
�œ
�œ
�œ˜——Jš�œ�œ˜8J˜Jšœ%�œ˜,J˜—šŸœ�œ�œ˜Jšœ
�œ�œ
�œ�œ�œ˜3—J˜šŸœ�œ˜#Jšœ�œ9˜@J˜J˜J˜J˜	š�œ�˜#šœ
�œ%�˜8Jšœ�œ˜—šœ�œ ˜)Jš
�œ�œ�œ�œ�œ˜5—J˜—Jšœ�œ
˜J˜	š�œ�˜J˜!šœ�œ(˜1Jš�œ�œ�œ�œ˜#—J˜	Jšœ�œ˜Jš�œ˜
——J˜Jš�œ�œ
�œ
�œ�œ�œ
˜[J˜J˜J˜˜J˜—J˜?J˜Jš
�˜˜š
Ÿœ�œ
�œ�œ�œ˜5Jš
�˜Jš	œ	�œ
�œ�œ
�œ(˜CJšœ�œ
�œ�œ˜KJ˜FJš�œ
˜—J˜Jšœ�œ!˜>Jšœ�œ
˜Jšœ%�œ
˜*Jšœ'�œ
�œ˜1JšœN�œ
˜TJ˜(J˜,J˜˜
Jšœ"�œ
˜)Jšœ�œ�œ
�œ
�œ
�œ˜G—J˜Jš�œ
�œ
�˜˜Jšœ4�œ�œ
˜CJ˜šœ�œ˜Jš
�˜J˜FJš	œ�œ&�œ1�œ
�œ˜†
Jš�œ
˜J˜—˜*Jš
�˜Jšœ�œ"�œ-˜dJ˜yJš	œ�œ&�œ1�œ
�œ˜†
Jš�œ
˜J˜—š�œ�œ ˜'J˜——J˜Jšœ�œ
˜Jšœ#�œ
˜)Jšœ
 ˜*J˜J˜Jš�œ-�œ'˜ZJ˜J˜%J˜˜\Jš�œ˜
Jš�œ˜—J˜Jš�œ)�œO�˜�
˜š�œ˜˜˜YJš�œ˜
Jš�œ˜Jš�œ,˜.Jš�œ(˜*—Jš�œ
˜J˜—˜˜\Jš�œ˜
Jš�œ˜Jš�œ,˜.Jš�œ(˜*—š�œ
�œ
�˜Jšœ0�œ
˜7Jšœ�œ�œ
˜#Jš�œ�œ
˜—J˜—˜J˜J˜——J˜˜J˜—š�œ1�œL�˜†
J˜v—J˜Fš�œ!�œK�œ˜vJšœ"�œ
˜(J˜CJ˜—Jš�œ &˜/J˜—š�œ
�œ
�˜šœ�œ˜Jš
�˜Jšœ�œ
˜J˜š�œ!�˜'J˜B—Jš�œ
˜—˜,J˜P—Jš�œ�œ
˜—J˜Jš�œ +˜4—Jšœ ˜—Kš�œ
˜—Kš�œ
˜—K˜š
œ™J˜Jšœ�œ
˜ Jšœ�œ�œ
˜#J˜JšŸœ�œ�œ˜8J˜J˜—K˜K˜K˜K˜Kš�œ
˜—…—8ÆEP