DIRECTORY
Build,
Delay,
DPrint,
Flow,
Globals,
IO,
Model,
Parse,
Printout,
Rope,
StagePool;

DelayImpl: CEDAR PROGRAM
IMPORTS
Build,
DPrint,
Globals,
Flow,
IO,
Model,
Parse,
Printout,
StagePool
EXPORTS Delay =
BEGIN
OPEN Delay;

delayCount: INT _ 0;
DelayLimit: PUBLIC INT _ 200000;


stageOverflowCount: INT _ 0;
stageOverflowLimit: INT _ 10;


Print: PUBLIC BOOLEAN _ FALSE;
PrintAll: PUBLIC BOOLEAN _ FALSE;


BusThreshold: PUBLIC REAL _ 2.0;


chaseVGCalls: INT _ 0;
chaseGatesCalls: INT _ 0;
chaseLoadsCalls: INT _ 0;
propagateCalls: INT _ 0;
feedbacks: INT _ 0;


hiTime, loTime: REAL;


chaseVG: PROC[stage: Globals.Stage, globalVars: Globals.GlobalVars] RETURNS [BOOLEAN] =

BEGIN
p: Globals.Pointer;
f: Globals.Fet;
node, other: Globals.Node;
size: INT;
result: BOOLEAN;
{

chaseVGCalls _ chaseVGCalls + 1;


size _ stage.piece1Size;
node _ stage.piece1Node[size-1];
IF node.inPath THEN RETURN [TRUE];
node.inPath _ TRUE;

IF Globals.Stop^ OR (delayCount >= DelayLimit) THEN GOTO giveUp;


IF node.bus OR node.input OR node.cap >= BusThreshold THEN
BEGIN
IF NOT node.always0 THEN
BEGIN
stage.piece2Size _ 1;
stage.rise _ TRUE;
IF NOT chaseGates[stage, globalVars] THEN GOTO giveUp;
END;
IF NOT node.always1 THEN
BEGIN
stage.piece2Size _ 1;
stage.rise _ FALSE;
IF NOT chaseGates[stage, globalVars] THEN GOTO giveUp;
END;
GOTO done;
END;


FOR p _ node.firstPointer, p.next UNTIL p = NIL DO
f _ p.fet;


IF f.source = node THEN
BEGIN
other _ f.drain;
IF NOT f.flowFromDrain THEN LOOP;
END
ELSE IF f.drain = node THEN
BEGIN
other _ f.source;
IF NOT f.flowFromSource THEN LOOP;
END
ELSE LOOP;
IF f.forcedOff THEN LOOP;
IF f.firstFlow # NIL THEN IF NOT Flow.Lock[f, other] THEN LOOP;


IF size >= Globals.pieceLimit THEN
BEGIN
stageOverflowCount _ stageOverflowCount + 1;
IF f.firstFlow # NIL THEN Flow.Unlock[f, other];
IF stageOverflowCount > stageOverflowLimit THEN GOTO done;
IO.PutF[Globals.StdOut, "More than %d transistors in series, see %s.\n", IO.int[Globals.pieceLimit], IO.rope[Printout.NodeRope[node, globalVars]]];
IF stageOverflowCount = stageOverflowLimit THEN
IO.PutRope[Globals.StdOut, "No more messages of this kind will be printed....\n"];
GOTO done;
END;


stage.piece1Fet[size] _ f;
stage.piece1Node[size] _ other;
stage.piece1Size _ size + 1;

IF other = globalVars.VddNode THEN
BEGIN
stage.piece2Size _ 1;
stage.rise _ TRUE;
result _ chaseGates[stage, globalVars];
END
ELSE IF other = globalVars.GroundNode THEN
BEGIN
stage.piece2Size _ 1;
stage.rise _ FALSE;
result _ chaseGates[stage, globalVars];
END
ELSE result _ chaseVG[stage, globalVars];
IF f.firstFlow # NIL THEN Flow.Unlock[f, other];
IF NOT result THEN GOTO giveUp;
ENDLOOP;
GOTO done;         

EXITS
giveUp => BEGIN
IO.PutF[Globals.StdOut, "ChaseVG giving up at %s.\n", IO.rope[Printout.NodeRope[node, globalVars]]];
node.inPath _ FALSE;
RETURN [FALSE];
END;

done => BEGIN
node.inPath _ FALSE;
RETURN [TRUE];
END
}
END;


chaseGates: PROC[stage: Globals.Stage, globalVars: Globals.GlobalVars] RETURNS [BOOLEAN] =

BEGIN
p: Globals.Pointer;
f: Globals.Fet;
node, other: Globals.Node;
size: INT;
result: BOOLEAN;
{

chaseGatesCalls _ chaseGatesCalls + 1;


size _ stage.piece2Size;
stage.piece2Fet[size-1] _ NIL;		-- expected by the modelling routines.
node _ stage.piece2Node[size-1];
IF node.always0 OR node.always1 THEN RETURN [TRUE];
IF node.inPath THEN
BEGIN
feedbacks _ feedbacks + 1;
IF stage.prev.time >= DPrint.Threshold[memory] THEN
DPrint.Record[stage.prev, memory];
RETURN [TRUE];
END;


IF node.precharged AND stage.rise THEN RETURN [TRUE];
node.inPath _ TRUE;

IF Globals.Stop^ OR (delayCount >= DelayLimit) THEN GOTO giveUp;


IF (stage.piece1Size # 0) OR (size # 1) THEN
BEGIN
IF node.input AND NOT node.output THEN GOTO done;
Model.Delay[stage, globalVars];
IF stage.rise THEN
BEGIN
IF stage.time > node.hiTime THEN
BEGIN
node.hiTime _ stage.time;
Propagate[stage, globalVars];
END;
END
ELSE IF stage.time > node.loTime THEN
BEGIN
node.loTime _ stage.time;
Propagate[stage, globalVars];
END;
IF Globals.Stop^ OR (delayCount > DelayLimit) THEN GOTO giveUp;


IF node.bus OR node.cap >= BusThreshold THEN GOTO done;
END;


FOR p _ node.firstPointer, p.next UNTIL p = NIL DO
f _ p.fet;
IF f.forcedOff THEN LOOP;
IF f.source = node THEN
BEGIN
other _ f.drain;
IF NOT f.flowFromSource THEN LOOP;
END
ELSE IF f.drain = node THEN
BEGIN
other _ f.source;
IF NOT f.flowFromDrain THEN LOOP;
END
ELSE LOOP;
IF other.always1 OR other.always0 THEN LOOP;
IF f.firstFlow # NIL THEN IF NOT Flow.Lock[f, node] THEN LOOP;


IF size >= Globals.pieceLimit THEN
BEGIN
IF f.firstFlow # NIL THEN Flow.Unlock[f, node];
stageOverflowCount _ stageOverflowCount + 1;
IF stageOverflowCount > stageOverflowLimit THEN GOTO done;
IO.PutF[Globals.StdOut, "More than %d transistors in series, see %s.\n", IO.int[Globals.pieceLimit], IO.rope[Printout.NodeRope[node, globalVars]]];
IF stageOverflowCount = stageOverflowLimit THEN
IO.PutRope[Globals.StdOut, "No more messages of this kind will be printed....\n"];
GOTO done;
END;

stage.piece2Fet[size-1] _ f;
stage.piece2Node[size] _ other;
stage.piece2Size _ size + 1;
result _ chaseGates[stage, globalVars];
IF f.firstFlow # NIL THEN Flow.Unlock[f, node];
IF NOT result THEN GOTO giveUp;
ENDLOOP;
GOTO done;

EXITS
giveUp => BEGIN
IO.PutF[Globals.StdOut, "ChaseGates giving up at %s.\n", IO.rope[Printout.NodeRope[node, globalVars]]];
node.inPath _ FALSE;
RETURN [FALSE];
END;

done => BEGIN
node.inPath _ FALSE;
RETURN [TRUE];
END
}
END;


chaseLoads: PROC[node: Globals.Node, stage: Globals.Stage, globalVars: Globals.GlobalVars] =


BEGIN
p: Globals.Pointer;
f: Globals.Fet;
other: Globals.Node;

chaseLoadsCalls _ chaseLoadsCalls + 1;


IF node.always1 OR node.always0 THEN RETURN;
IF node.inPath THEN
BEGIN
feedbacks _ feedbacks + 1;
IF stage.prev.time >= DPrint.Threshold[memory] THEN
DPrint.Record[stage.prev, memory];
RETURN;
END;


FOR p _ node.firstPointer, p.next UNTIL p = NIL DO
f _ p.fet;
IF NOT (f.forcedOn OR f.onAlways) THEN LOOP;
IF f.source = node THEN
BEGIN
other _ f.drain;
IF NOT f.flowFromDrain THEN LOOP;
END
ELSE IF f.drain = node THEN 
BEGIN
other _ f.source;
IF NOT f.flowFromSource THEN LOOP;
END
ELSE LOOP;
IF other.always1 THEN stage.rise _ TRUE
ELSE IF other.always0 THEN stage.rise _ FALSE
ELSE LOOP;
IF f.firstFlow # NIL THEN IF NOT Flow.Lock[f, other] THEN LOOP;

stage.piece1Size _ 0;
stage.piece2Size _ 2;
stage.piece2Node[0] _ other;
stage.piece2Node[1] _ node;
stage.piece2Fet[0] _ f;
[] _ chaseGates[stage, globalVars];
IF f.firstFlow # NIL THEN Flow.Unlock[f, other];
RETURN;
ENDLOOP;


node.inPath _ TRUE;
FOR p _ node.firstPointer, p.next UNTIL p = NIL DO
f _ p.fet;
IF f.forcedOff THEN LOOP;
IF f.source = node THEN
BEGIN
other _ f.drain;
IF NOT f.flowFromSource THEN LOOP;
END
ELSE IF f.drain = node THEN
BEGIN
other _ f.source;
IF NOT f.flowFromDrain THEN LOOP;
END
ELSE LOOP;
IF f.firstFlow # NIL THEN
BEGIN
IF Flow.Lock[f, node] THEN
BEGIN
chaseLoads[other, stage, globalVars];
Flow.Unlock[f, node];
END;
END
ELSE chaseLoads[other, stage, globalVars];
ENDLOOP;

node.inPath _ FALSE;
RETURN;
END;


Propagate:  PUBLIC PROC[prevStage: Globals.Stage, globalVars: Globals.GlobalVars] =
BEGIN
p: Globals.Pointer;
f: Globals.Fet;
node: Globals.Node;
stage: Globals.Stage;
result: BOOLEAN;
oldInPath: BOOLEAN;

propagateCalls _ propagateCalls + 1;


delayCount _ delayCount + 1;
IF Globals.Stop^ OR (delayCount >= DelayLimit) THEN
BEGIN
IF delayCount = DelayLimit THEN
BEGIN
IO.PutF[Globals.StdOut, "Aborting delay analysis:  no solution after %d stages.\n", IO.int[DelayLimit]];
IO.PutRope[Globals.StdOut, "Perhaps you forgot to mark some of the flow in"];
IO.PutRope[Globals.StdOut, " pass transistors?\n  The information below may point"];
IO.PutRope[Globals.StdOut, " out the trouble spot.\n"];
END;
RETURN;
END;

node _ prevStage.piece2Node[prevStage.piece2Size - 1];
IF PrintAll OR Print THEN
IO.PutF[Globals.StdOut, "Delay at %s set to %6.1fns up, %6.1fns down.\n", IO.rope[Printout.NodeRope[node, globalVars]], IO.real[node.hiTime], IO.real[node.loTime]];


IF prevStage.time >= DPrint.Threshold[any] THEN
DPrint.Record[prevStage, any];
IF node.dynamic AND (prevStage.time >= DPrint.Threshold[memory]) THEN
DPrint.Record[prevStage, memory];
IF node.watched AND (prevStage.time >= DPrint.Threshold[watched]) THEN
DPrint.Record[prevStage, watched];

stage _ StagePool.New[];
stage.prev _ prevStage;


IF node.input OR node.bus OR node.cap >= BusThreshold THEN
BEGIN
stage.piece1Size _ 0;
stage.piece2Size _ 1;
stage.piece2Node[0] _ node;
stage.rise _ prevStage.rise;


oldInPath _ node.inPath;
node.inPath _ FALSE;
result _ chaseGates[stage, globalVars];
node.inPath _ oldInPath;
IF NOT result THEN
BEGIN
StagePool.Free[stage];
RETURN;
END;
END;


FOR p _ node.firstPointer, p.next UNTIL p = NIL DO
f _ p.fet;
IF f.gate # node THEN LOOP;
IF f.onAlways OR f.forcedOn OR f.forcedOff THEN LOOP;


IF (prevStage.rise AND NOT f.on0)
OR ((NOT prevStage.rise) AND NOT f.on1) THEN
BEGIN
IF f.flowFromSource THEN
BEGIN
IF f.firstFlow # NIL THEN IF NOT Flow.Lock[f, f.source]
THEN GOTO skipSource;
stage.piece1Size _ 1;
stage.piece1Fet[0] _ f;
stage.piece1Node[0] _ f.source;
stage.piece2Size _ 1;
stage.piece2Node[0] _ f.drain;
IF f.source = globalVars.GroundNode THEN
BEGIN
stage.rise _ FALSE;
result _ chaseGates[stage, globalVars];
END
ELSE IF f.source = globalVars.VddNode THEN
BEGIN
stage.rise _ TRUE;
result _ chaseGates[stage, globalVars];
END
ELSE result _ chaseVG[stage, globalVars];
IF f.firstFlow # NIL THEN Flow.Unlock[f, f.source];
IF NOT result THEN
BEGIN
StagePool.Free[stage];
RETURN;
END;
EXITS skipSource => NULL;
END;
IF f.flowFromDrain THEN
BEGIN
IF f.firstFlow # NIL THEN IF NOT Flow.Lock[f, f.drain]
THEN GOTO skipDrain;
stage.piece1Size _ 1;
stage.piece1Fet[0] _ f;
stage.piece1Node[0] _ f.drain;
stage.piece2Size _ 1;
stage.piece2Node[0] _ f.source;
IF f.drain = globalVars.GroundNode THEN
BEGIN
stage.rise _ FALSE;
result _ chaseGates[stage, globalVars];
END
ELSE IF f.drain = globalVars.VddNode THEN
BEGIN
stage.rise _ TRUE;
result _ chaseGates[stage, globalVars];
END
ELSE result _ chaseVG[stage, globalVars];
IF f.firstFlow # NIL THEN Flow.Unlock[f, f.drain];
IF NOT result THEN
BEGIN
StagePool.Free[stage];
RETURN;
END;
EXITS skipDrain => NULL;
END;
END


ELSE
BEGIN
IF f.flowFromSource THEN
BEGIN
oldInPath _ f.source.inPath;
f.source.inPath _ TRUE;
[] _ chaseLoads[f.drain, stage, globalVars];
f.source.inPath _ oldInPath;
END;
IF f.flowFromDrain THEN
BEGIN
oldInPath _ f.drain.inPath;
f.drain.inPath _ TRUE;
[] _ chaseLoads[f.source, stage, globalVars];
f.drain.inPath _ oldInPath;
END;
END;
ENDLOOP;
StagePool.Free[stage];
END;


DelayCmd: PUBLIC Globals.CmdProc =
BEGIN
DelayProc: PROC [node: Globals.Node] ~ {
stage: Globals.Stage _ StagePool.New[];

stage.prev _ NIL;
stage.piece1Size _ 0;
stage.piece2Size _ 1;
stage.piece2Node[0] _ node;
stage.piece2Fet[0] _ NIL;
IF hiTime >= 0 THEN
BEGIN
stage.time _ hiTime;
stage.rise _ TRUE;
IF hiTime > node.hiTime THEN node.hiTime _ hiTime;
Propagate[stage, globalVars];
END;
IF loTime >= 0 THEN
BEGIN
stage.time _ loTime;
stage.rise _ FALSE;
IF loTime > node.loTime THEN node.loTime _ loTime;
Propagate[stage, globalVars];
END;
StagePool.Free[stage];
};

nodeName: Rope.ROPE;
ok: BOOLEAN;


IF args = NIL THEN GOTO noArgs;
nodeName _ args.rope;
args _ args.next;
IF args = NIL THEN GOTO noArgs;
[ok, hiTime] _ Parse.Real[args];
IF NOT ok THEN GOTO noArgs;
args _ args.next;
IF args = NIL THEN GOTO noArgs;
[ok, loTime] _ Parse.Real[args];
IF NOT ok THEN GOTO noArgs;

DelayProc[Build.NodeFromRope[nodeName, globalVars]];
EXITS noArgs =>
BEGIN
IO.PutRope[Globals.StdOut, "Delay requires three arguments:\n"];
IO.PutRope[Globals.StdOut, "   node name, rise time, fall time.\n"];
END;
END;


Stats: PUBLIC PROC[] =
BEGIN
IO.PutF[Globals.StdOut, "Number of calls to chase Vdd or GND: %d.\n", IO.int[chaseVGCalls]];
IO.PutF[Globals.StdOut, "Number of calls to chase gates: %d.\n", IO.int[chaseGatesCalls]];
IO.PutF[Globals.StdOut, "Number of calls to chase loads: %d.\n", IO.int[chaseLoadsCalls]];
IO.PutF[Globals.StdOut, "Number of calls to propagate delays: %d.\n", IO.int[propagateCalls]];
IO.PutF[Globals.StdOut, "Number of delay feedback paths: %d.\n", IO.int[feedbacks]];
END;

END.
ÆFILE:  DelayImpl.mesa
Last edited by Ousterhout, October 4, 1983 4:23 pm
Christian LeCocq December 30, 1986 11:38:50 am PST
This file contains routines that figure out delays through the circuit network, from when one node changes until everything in the system is stable.  Actually, the routines in this file just compute stages (chains of transistors) that are affected, then call routines in the model package to compute delays.  The general process is as follows:
When it is determined that a gate will rise or fall, and that this is the worst rise or fall time seen so far for the gate, then delay information has to be propagated.  First, find all paths from the transistor to a source of Ground or Vdd (busses and inputs are also sources).  Then for each source, find all paths from the other side of the transistor to gates, busses, or outputs.  Compute the delay for each combination of source and target.  If this results in a new worst-case settling time for the target, repeat the process recursively starting at the target.  The search is depth-first, and has to be in order to handle circularities cleanly.
Hash,
Hash,
Rope,
Counter to keep us from looping infinitely during delay calculation:
Counter to keep us from printing too many stage overflow messages:
Flags telling what, if any, information to print out while calculating delays:
Threshold capacitance (in pfs) at which a node is considered to be a bus:
Counters used to gather statistics:
Things that get passed between command-level routine and table searching action routines:
Stage describes the part of the stage seen so far.  On entry, the stage contains >= 1 entries in piece1, plus piece2Node[0] must be initialized with the correct value for the first call to chaseGates. The return value is TRUE if the procedure terminated normally, and FALSE if it gave up because too many nodes had been searched. This procedure continues searching for sources of Vdd or Ground, calling itself recursively until all possible paths have been tried. For each source of Vdd or Ground, chaseGates gets called.
If we've already seen this node, return immediately.
See if this node is highly capacitive (input or bus).  If it is, then chaseGates immediately.
Scan all of the fets whose sources or drains connect to the node, and either call chaseGates if the connect to Vdd or Ground, or call this procedure recursively.
Make sure that information can flow through this transistor in the desired direction.
Make sure that there's room in the delay stage for more info.
If not, it's an error (too many transistors in series).
Add more information to the delay stage.
Stage describes a partially-complete stage up to and including the node from which this procedure is to continue chasing gates.  The return value is TRUE if the procedure terminated normally, and FALSE if it gave up because too many nodes had been searched.  This procedure chases out gates and outputs recursively, augmenting piece2 of the stage as it goes.  When it finds gates and outputs, it calculates delays and invokes Propagate to propagate them.  When this procedure is called, piece1 of the stage must be complete (meaning 0 or more entries for fets and nodes).
If this node is fixed in value, then return immediately:  the delay to here must be zero.  If the node is already in the path we're checking, then also return to avoid circular scans.  In this case, we've just discovered a static memory element (feedback).  Before returning, if this is a static memory element then record the delay. All memory nodes found here are of the "OR" type.
If this node is precharged, then there's no need to consider rising transitions.
If the node is an input, then we can usually return right away since its delay is fixed by the outside world.  There are two exceptions.  If the node is also an output, then we still have to calculate delays to it.  Also, if this node is absolutely the only entry in its stage so far, then this stage starts from the node; in that case we are computing delays FROM the node, so we skip the delay calculation and go on to search through transistors.
If this is a bus, then Propagate did everything that needs to be done, and there's nothing left for us to do.
Now go through all the fets that connect to this node.  For each non-load transistor, keep chasing gates on the other side, unless the other side is an input or we're going the wrong way through a transistor.
Make sure that there's enough space in the stage for more info.   If not, then it's an error (too many transistors in series).
This procedure is used to chase out loads that can drive a stage when a transistor turns off.  Node tells where to start searching for loads, and stage is used when (if) a load is found to record stage information.  This procedure searches out recursively from node to find all the loads that can legally be reached from it.  For each load found, the stage is set up and chaseGates is processed to look for things the load can drive.
Design note:  when a given transistor turns off, we don't find every possible load that is connected to the turned-off fet though transistor channels (that might involve expensive searches through pass transistor arrays).  Instead, we only look for loads that can be driven by the turned-off fet.  This will handle the common case of loads that are part of gates, but might not handle other cases.  Caveat emptor!
Make sure that we're not looping circularly.  A circularity here corresponds to an "AND" type of memory node:  when this happens, call the delay recorder.
See if this node has any loads attached to it.  If so, then chase gates from the load and return.  A load is defined as a transistor that is always on and connects to a node that is forced to a particular value.
This node doesn't have any loads.  In this case, continue working outwards, looking recursively for loads.  Note:  the inPath flag doesn't get set until here, because it must be UNSET when we call chaseGates above (chaseGates will set the flag for itself).
Quit if too many delays have been calculated.  This probably means that nodes aren't marked properly (user error), or else Crystal is messing up.
IF PrintAll OR (Print AND
((Rope.Fetch[node.name, 0] < '0) OR Rope.Fetch[node.name, 0] > '9)) THEN
IO.PutF[Globals.StdOut, "Delay at %s set to %6.1fns up, %6.1fns down.\n", IO.rope[Printout.NodeRope[node]], IO.real[node.hiTime], IO.real[node.loTime]];
Record delay information for posterity.
If this node is an input or bus, then call chaseGates immediately. An empty piece1 is used to indicate the input status to the device modellers.
Be sure to clear the inPath flag here.  This is necessary because when this procedure is called from chaseGates with a bus, because the bus is both the destination of one stage and the trigger of another.   On the other hand, be sure to restore the inPath flag before continuing in the procedure.
Scan through all of the fets connecting to this node.
If the signal change could potentially turn the transistor on, then look first at the source side, then at the drain side. For each side, if info could flow from that side then call chaseVG to find the source.  If the side connects directly to a supply rail, then bypass the call to chaseVG and go straight to chaseGates (this is a performance optimization and isn't strictly necessary).
This transition could only have turned the transistor off.  In this case, we scan out on each side of the transistor looking for a load to take over now that the transistor is turned off.  Be sure to mark the node on the side of the transistor that we're NOT searching as in the path.  Otherwise, chaseLoads will consider pullup paths that go back through the path we just turned off!
Parse the arguments.
Hash.Enumerate[table: globalVars.nodeTable, pattern: nodeName, proc: delayProc, errorStream: Globals.StdOut];
�Ê—˜Jš
œ™š
œ2™2Icode™2—J˜Jš
œ×™×J˜Jš
œŒ™ŒJ˜š
Ïk	˜	J˜J˜J˜J˜J˜J™Jš�œ
˜J˜J˜J˜	J˜J˜
—J˜JšÏn	œ�œ
�˜š
�˜J˜J˜J˜J˜J™Jš�œ
˜J˜J˜J˜	J™J˜	—Jš�œ˜Jš
�˜Jš�œ˜J˜Jš
œD™DJšœ�œ˜Jšœ�œ
�œ
˜ J˜Jš
œB™BJ˜Jšœ�œ˜Jšœ�œ˜J˜Jš
œN™NJ˜Jšžœ�œ
�œ�œ
˜Jšžœ�œ
�œ�œ
˜!J˜Jš
œI™IJ˜Jšžœ�œ
�œ˜ J˜Jš
œ#™#J˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜J˜Jš
œY™YJ˜Jšœ�œ
˜J˜J˜
šÏbœ�œ7�œ�œ˜WJš
œ‰™‰J˜Jš
�˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜
Jšœ�œ
˜J˜
J˜J˜ J˜Jš
œ4™4J˜J˜J˜ Jš�œ
�œ
�œ�œ˜"Jšœ�œ
˜J˜Jš�œ�œ�œ
�œ˜@J˜Jš
œ]™]J˜š�œ
�œ�œ�˜:Jš
�˜š�œ
�œ�˜Jš
�˜J˜Jšœ
�œ
˜Jš�œ
�œ�œ
�œ˜6Jš�œ
˜—š�œ
�œ�˜Jš
�˜J˜Jšœ
�œ
˜Jš�œ
�œ�œ
�œ˜6Jš�œ
˜—Jš�œ˜
Jš�œ
˜—J˜Jš
œ¡
™¡
J˜š�œ�œ�œ
�˜2J˜
J˜Jš
œU™U˜š�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜!Jš
�˜—š�œ
�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜"Jš
�˜—Jš�œ
�œ
˜
Jš�œ
�œ
�œ
˜Jš�œ�œ
�œ
�œ
�œ�œ
�œ
˜?J˜Jš
œ=™=Jš
œ7™7J˜š�œ�˜"Jš
�˜J˜,Jš�œ�œ
�œ˜0Jš�œ)�œ
�œ˜:Jš�œF�œ�œ,˜“
š�œ)�˜/Jš�œP˜R—Jš�œ˜
Jš�œ
˜—J˜Jš
œ(™(J˜J˜J˜J˜J˜š�œ�˜"Jš
�˜J˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—š�œ
�œ�˜*Jš
�˜J˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—Jš�œ%˜)Jš�œ�œ
�œ˜0Jš�œ
�œ�œ
�œ˜Jš�œ
˜—Jš�œ˜—J˜š
�˜Jšœ
�˜Jš�œ3�œ,˜dJšœ�œ
˜Jš�œ�œ˜Jš�œ
˜J˜Jšœ�˜
Jšœ�œ
˜Jš�œ�œ˜Jš
�˜—J˜
Jš�œ
˜—J˜J˜
šŸ
œ�œ7�œ�œ˜ZJš
œ»™»J˜Jš
�˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜
Jšœ�œ
˜J˜
J˜J˜&J˜Jš
œÿ™ÿJ˜J˜Jšœ�œÏc&˜FJ˜ Jš
�œ�œ�œ
�œ�œ˜3š�œ
�˜Jš
�˜J˜š�œ-�˜3J˜"—Jš�œ�œ˜Jš�œ
˜—J˜Jš
œP™PJ˜Jš
�œ�œ�œ
�œ�œ˜5Jšœ�œ
˜J˜Jš�œ�œ�œ
�œ˜@J˜Jš
œÀ™ÀJ˜š�œ�œ�˜,Jš
�˜Jš
�œ�œ
�œ
�œ
�œ˜1J˜š�œ�˜Jš
�˜š�œ�˜ Jš
�˜J˜Jš
œ˜Jš�œ
˜—Jš
�˜—š�œ
�œ�˜%Jš
�˜J˜Jš
œ˜Jš�œ
˜—Jš�œ�œ�œ
�œ˜?J˜Jš
œm™mJ˜Jš�œ
�œ�œ
�œ˜7Jš�œ
˜—J˜Jš
œÐ
™Ð
J˜š�œ�œ�œ
�˜2J˜
Jš�œ
�œ
�œ
˜š�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜"Jš
�˜—š�œ
�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜!Jš
�˜—Jš�œ
�œ
˜
Jš�œ�œ�œ
�œ
˜,š�œ�œ
�œ
�œ
�œ�œ
�œ
˜>J˜—š
œ~™~J˜—š�œ�˜"Jš
�˜Jš�œ�œ
�œ˜/J˜,Jš�œ)�œ
�œ˜:Jš�œF�œ�œ,˜“
š�œ)�˜/Jš�œP˜R—Jš�œ˜
Jš�œ
˜J˜—J˜J˜J˜Jš
œ'˜'Jš�œ�œ
�œ˜/Jš�œ
�œ�œ
�œ˜Jš�œ
˜—Jš�œ˜
J˜š
�˜Jšœ
�˜Jš�œ6�œ,˜gJšœ�œ
˜Jš�œ�œ˜Jš�œ
˜J˜Jšœ�˜
Jšœ�œ
˜Jš�œ�œ˜Jš
�˜—J˜
Jš�œ
˜—J˜J˜
šŸ
œ�œL˜\Jš
œ±™±J˜Jš
œ�™�J˜Jš
�˜Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜&J˜Jš
œš
™š
J˜Jš�œ�œ�œ
�œ
˜,š�œ
�˜Jš
�˜J˜š�œ-�˜3J˜"—Jš�œ
˜Jš�œ
˜—J˜Jš
œÓ
™Ó
J˜š�œ�œ�œ
�˜2J˜
Jš
�œ
�œ
�œ
�œ
�œ
˜,š�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜!Jš
�˜—š�œ
�œ�œ
˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜"Jš
�˜—Jš�œ
�œ
˜
Jš�œ�œ�˜'Jš�œ
�œ�œ�˜-Jš�œ
�œ
˜
Jš�œ�œ
�œ
�œ
�œ�œ
�œ
˜?J˜J˜J˜J˜J˜J˜Jš
œ#˜#Jš�œ�œ
�œ˜0Jš�œ
˜Jš�œ
˜—J˜Jš
œ€™€J˜Jšœ�œ
˜š�œ�œ�œ
�˜2J˜
Jš�œ
�œ
�œ
˜š�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜"Jš
�˜—š�œ
�œ�˜Jš
�˜J˜Jš�œ
�œ�œ
�œ
˜!Jš
�˜—Jš�œ
�œ
˜
š�œ�œ
�˜Jš
�˜š�œ�˜Jš
�˜J˜%J˜Jš�œ
˜—Jš
�˜—Jš�œ&˜*Jš�œ
˜—J˜Jšœ�œ
˜Jš�œ
˜Jš�œ
˜J˜—J˜
šž	œ�œ
�œ<˜SJš
�˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jšœ�œ
˜J˜J˜$J˜Jš
œ‘
™‘
J˜J˜š�œ�œ�˜3Jš
�˜š�œ�˜Jš
�˜Jš�œQ�œ˜hJš�œK˜MJš�œR˜TJš�œ5˜7Jš�œ
˜—Jš�œ
˜Jš�œ
˜—J˜J˜6š�œ
�œ�™Jšœ!�œ!�™HJš�œG�œ�œ�œ™˜
—š�œ
�œ�˜Jš�œG�œ+�œ�œ˜¤
—J˜Jš
œ'™'J˜š�œ)�˜/J˜—š�œ�œ.�˜EJ˜!—š�œ�œ/�˜FJ˜"—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š
œ5™5J˜š�œ�œ�œ
�˜2J˜
Jš�œ�œ
�œ
˜Jš
�œ�œ�œ
�œ
�œ
˜5J˜Jš
œƒ™ƒJ˜š�œ�œ
�œ˜!Jš	�œ�œ�œ
�œ�˜,Jš
�˜š�œ�˜Jš
�˜š
�œ�œ
�œ
�œ
�œ˜7Jš�œ
�œ˜—J˜J˜J˜J˜J˜š�œ"�˜(Jš
�˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—š�œ
�œ�˜*Jš
�˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—Jš�œ%˜)Jš�œ�œ
�œ˜3š�œ
�œ�˜Jš
�˜J˜Jš�œ
˜Jš�œ
˜—Jš�œ�œ
˜Jš�œ
˜—š�œ�˜Jš
�˜š
�œ�œ
�œ
�œ
�œ˜6Jš�œ
�œ˜—J˜J˜J˜J˜J˜š�œ!�˜'Jš
�˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—š�œ
�œ�˜)Jš
�˜Jšœ
�œ
˜Jš
œ'˜'Jš
�˜—Jš�œ%˜)Jš�œ�œ
�œ˜2š�œ
�œ�˜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š
�˜šÐbn	œ�œ˜(Jš
œ'˜'J˜Jšœ
�œ
˜J˜J˜J˜Jšœ�œ
˜š�œ
�˜Jš
�˜J˜Jšœ
�œ
˜Jš�œ�œ˜2Jš
œ˜Jš�œ
˜—š�œ
�˜Jš
�˜J˜Jšœ
�œ
˜Jš�œ�œ˜2Jš
œ˜Jš�œ
˜—J˜Jš
œ˜J˜—Jšœ�œ
˜Jšœ�œ
˜J˜Jš
œ™J˜Jš�œ�œ
�œ
�œ˜J˜J˜Jš�œ�œ
�œ
�œ˜J˜ Jš�œ
�œ�œ
�œ˜J˜Jš�œ�œ
�œ
�œ˜J˜ Jš�œ
�œ�œ
�œ˜J˜Jš
œm™mJš
œ4˜4š�œ
˜Jš
�˜Jš�œ>˜@Jš�œB˜DJš�œ
˜—Jš�œ
˜—J˜J˜
šžœ�œ
�œ˜Jš
�˜Jš�œC�œ˜\Jš�œ>�œ˜ZJš�œ>�œ˜ZJš�œC�œ˜^Jš�œ>�œ˜TJš�œ
˜J˜—Jš�œ
˜—…—/Êc'