DIRECTORY BasicTime, CardHashTableThreaded, Core, CoreClasses, CoreFlat, CoreOps, CoreProperties, CoreStructuralComparison, IO, OneToOne, Process, Real, RefTab, Rope, RopeHash, SimpleMailer, StructuralComparisonDataStructure, StructuralComparisonOps, StructureFromCore, SymTab;

StructuralComparisonOuter: CEDAR MONITOR
IMPORTS BasicTime, CardHashTableThreaded, CoreClasses, CoreFlat, CoreOps, CoreProperties, CoreStructuralComparison, IO, OneToOne, Process, RefTab, Rope, SimpleMailer, StructuralComparisonDataStructure, StructuralComparisonOps, StructureFromCore, SymTab
EXPORTS CoreStructuralComparison
SHARES StructuralComparisonDataStructure
=

BEGIN OPEN CC:CoreClasses, CO:CoreOps, CP:CoreProperties, CF:CoreFlat, CoreStructuralComparison, StructuralComparisonDataStructure, StructuralComparisonOps, StructureFromCore;

Need: TYPE = REF NeedPrivate;
NeedPrivate: TYPE = RECORD [name: ROPE, from, to: Vertex];

EltListArray: TYPE ~ ARRAY RealGraphID OF ElementList;

matchProp: ATOM = CP.RegisterProperty[$StructuralComparisonMatch];

FlattenAndCompare:
PUBLIC
PROC [
roleNames: ARRAY Role OF ROPE,
cts: CellTypePair,
stss: ARRAY Role OF SubtreeSpec _ ALL[ToLeaves],
mss: ARRAY Role OF MergeSpec _ ALL[MergeNothing],
GiveHints: HintsGiver _ NIL,
PerPair: AssociationPairConsumer _ NIL,
PerMismatch: MismatchConsumer _ NIL,
PerDroppedConnection: DroppedConnectionConsumer _ NIL,
PerBogusMerge: BogusMergeConsumer _ NIL,
Querier: AssociationQuerier _ NIL,
trace: Trace _ NIL,
automorphismHack, mayQuitEarly: BOOL _ FALSE,
didQuitEarly, abort: REF BOOL,
ttols: TransistorTolerances,
vsp: ViewStatsPair _ [NIL, NIL],
data: REF ANY _ NIL
]
RETURNS [isomorphic: BOOL]
= {
realDescrs: RealGraphDescriptions ~ [A: roleNames[A], B: roleNames[B]];
needsFrom: ARRAY Role OF SymTab.Ref ~ [
A: SymTab.Create[case: TRUE],
B: SymTab.Create[case: TRUE]];
SurveyA: PROC [v: Vertex, core: REF ANY --UNION [Wire, CellInstance]--] = {
matchName: ROPE = NARROW[WITH core SELECT FROM
w: Core.Wire => CP.GetWireProp[w, matchProp],
ci: CC.CellInstance => CP.GetCellInstanceProp[ci, matchProp],
ENDCASE => ERROR];
IF matchName # NIL THEN {
need: Need = NEW [NeedPrivate _ [matchName, v, NIL]];
IF NOT needsFrom[A].Insert[matchName, need] THEN ERROR;
};
};
SurveyB: PROC [v: Vertex, core: REF ANY --UNION [Wire, CellInstance]--] = {
name, matchName: ROPE;
IF v = NIL OR core = NIL THEN ERROR;
WITH core SELECT FROM
w: Core.Wire => {name _ CO.GetShortWireName[w]; matchName _ NARROW[CP.GetWireProp[w, matchProp]]};
ci: CC.CellInstance => {name _ CC.GetCellInstanceName[ci]; matchName _ NARROW[CP.GetCellInstanceProp[ci, matchProp]]};
ENDCASE => ERROR;
{match: Need = NARROW[needsFrom[A].Fetch[name].val];
IF matchName # NIL THEN {
need: Need = NEW [NeedPrivate _ [matchName, v, NIL]];
IF NOT needsFrom[B].Insert[matchName, need] THEN ERROR;
};
IF match # NIL THEN {
IF match.to # NIL THEN ERROR;
match.to _ v};
}};
sctA: CellType = GetGraph[ttols, cts[A],TRUE, data, stss[A], mss[A], SurveyA, vsp[A]!
DroppedConnection => {IF PerDroppedConnection#NIL THEN PerDroppedConnection[A, subroot, public, actual]; RESUME};
BogusMerge => {IF PerBogusMerge#NIL THEN PerBogusMerge[A, subroot, w1, w2, from]; RESUME}
];
IF abort^ THEN RETURN [FALSE];
{sctB: CellType = GetGraph[ttols,cts[B], TRUE, data, stss[B], mss[B], SurveyB, vsp[B]!
DroppedConnection => {IF PerDroppedConnection#NIL THEN PerDroppedConnection[B, subroot, public, actual]; RESUME};
BogusMerge => {IF PerBogusMerge#NIL THEN PerBogusMerge[B, subroot, w1, w2, from]; RESUME}
];
IF abort^ THEN RETURN [FALSE];
{ccts: ARRAY RealGraphID OF Core.CellType = [A: cts[A], B: cts[B]];
scts: ARRAY RealGraphID OF CellType = [A: sctA, B: sctB];
GenerateHints: PROC [Consume: PROC [vA, vB: Vertex]] = {
PassHint: PROC [ds: ARRAY Role OF Descendant] --HintConsumer-- = {
vA: Vertex = GetStructure[sctA, ds[A]];
vB: Vertex = GetStructure[sctB, ds[B]];
Consume[vA, vB];
};
IF GiveHints # NIL THEN GiveHints[PassHint];
IF needsFrom[A].GetSize[] # 0 THEN {
GiveMatch: PROC [key, val: REF ANY] RETURNS [quit: BOOL _ FALSE] = {
need: Need = NARROW[val];
IF need.from = NIL OR need.to = NIL THEN ERROR;
Consume[need.from, need.to];
};
IF SymTab.Pairs[needsFrom[A], GiveMatch] THEN ERROR;
};
IF needsFrom[B].GetSize[] # 0 THEN {
bs: INT _ 0;
PerPart: PROC [vA: Vertex] = {
matched: BOOL _ FALSE;
FOR ds: Element _ GetCore[vA], ds.rest WHILE ds # NIL DO
name: ROPE = WITH ds.first SELECT FROM
dw: DescendantWire => CO.GetShortWireName[dw.wire],
dci: DescendantCellInstance => CC.GetCellInstanceName[CF.ResolveFlatCellType[cts[A], [dci^, 0]].instance],
ENDCASE => ERROR;
need: Need = NARROW[needsFrom[B].Fetch[name].val];
IF need # NIL THEN {
IF matched THEN ERROR;
matched _ TRUE;
IF need.from = NIL OR need.to # NIL THEN ERROR;
Consume[vA, need.from];
};
ENDLOOP;
};
sctA.EnumerateParts[PerPart, FALSE];
};
};
CdToDla: PROC [cd: ColorData] RETURNS [dla: EltListArray] = {
dla _ ALL[NIL];
FOR v: Vertex _ cd.firstVertex, GetColorNext[v] WHILE v # NIL DO
IF NOT IsMirror[v] THEN dla[v.GetGraph[]] _ CONS[GetCore[v], dla[v.GetGraph[]]];
ENDLOOP;
dla _ dla;
};
ReportColor: PROC [key: INT, value: REF ANY] RETURNS [quit: BOOL _ FALSE] --IntHashTableThreaded.EachPairAction-- = {
cd: ColorData = NARROW[value];
ds: EltListArray = CdToDla[cd];
IF cd.count = ALL[1] THEN {
isTransistor: ARRAY RealGraphID OF BOOL;
trs: ARRAY RealGraphID OF RECORD [
type: CC.TransistorType,
shape: ARRAY TransistorDim OF REAL];
FOR g: RealGraphID IN RealGraphID DO
first: BOOL _ TRUE;
FOR dl: Element _ ds[g].first, dl.rest WHILE dl # NIL DO
WITH dl.first SELECT FROM
dci: DescendantCellInstance => {
ct: Core.CellType ~ CO.ToBasic[CF.ResolveFlatCellType[ccts[g], [dci^]].cellType];
thisIs: BOOL ~ ct.class = CC.transistorCellClass;
IF first THEN isTransistor[g] _ thisIs ELSE IF isTransistor[g] # thisIs THEN ERROR;
IF thisIs THEN {
tr: CC.Transistor ~ NARROW[ct.data];
rl: REF INT ~ NARROW[CoreProperties.GetCellTypeProp[ct, CC.lengthProp]];
rw: REF INT ~ NARROW[CoreProperties.GetCellTypeProp[ct, CC.widthProp]];
queer: BOOL ~ rl=NIL OR rw=NIL;
shape: ARRAY TransistorDim OF REAL ~ IF queer THEN ALL[Real.LargestNumber] ELSE [rl^, rw^];
IF first THEN trs[g] _ [tr.type, shape] ELSE {
IF tr.type # trs[g].type OR shape[length] # trs[g].shape[length] THEN ERROR;
IF NOT queer THEN trs[g].shape[width] _ trs[g].shape[width] + shape[width];
};
};
first _ FALSE;
};
dw: DescendantWire => {
thisIs: BOOL ~ FALSE;
IF first THEN {first _ FALSE; isTransistor[g] _ thisIs} ELSE IF isTransistor[g] # thisIs THEN ERROR;
};
ENDCASE => ERROR;
ENDLOOP;
IF first THEN ERROR;
ENDLOOP;
IF isTransistor[A]#isTransistor[B] THEN ERROR;
IF isTransistor[A] AND trs[A].shape#trs[B].shape THEN {
IF trs[A].shape#ALL[Real.LargestNumber] AND trs[B].shape#ALL[Real.LargestNumber] THEN {
FOR td: TransistorDim IN TransistorDim DO
ratio: REAL ~ trs[A].shape[td] / trs[B].shape[td];
IF ratio < ttols[td].min OR ratio > ttols[td].max THEN PerMismatch[
msg: IO.PutFR["transistor %g mismatch (%g/%g not within a factor of %g)", [rope[TransistorDimName[td]]], [real[trs[A].shape[td]]], [real[trs[B].shape[td]]], [real[ttols[td].max]]],
kind: transistorShape,
cts: cts,
colorElts: [A: ds[A], B: ds[B]],
Ans: Answer];
ENDLOOP;
}
ELSE PerMismatch[
msg: IF trs[A].shape=ALL[Real.LargestNumber] THEN Rope.Cat["transistor queerness mismatch: ", realDescrs[A], " is queer, ", realDescrs[B], " isn't"] ELSE Rope.Cat["transistor queerness mismatch: ", realDescrs[B], " is queer, ", realDescrs[A], " isn't"],
kind: transistorShape,
cts: cts,
colorElts: [A: ds[A], B: ds[B]],
Ans: Answer];
};
IF PerPair # NIL THEN PerPair[[A: ds[A].first, B: ds[B].first]];
}
ELSE IF quittedEarly AND cd.count[A]=cd.count[B] THEN NULL
ELSE {
IF PerMismatch # NIL THEN PerMismatch[
kind: IF cd.count[A] = cd.count[B] THEN stuck ELSE difference,
cts: cts,
colorElts: [A: ds[A], B: ds[B]],
Ans: Answer];
};
};
Answer: PROC [r: Role, d: Descendant] RETURNS [dlp: Pair] = {
g: RealGraphID ~ roleToGraphID[r];
v: Vertex = CanonizeAndGetStructure[scts[g], [], d];
IF v = NIL THEN RETURN [[NIL, NIL]];
{cd: ColorData = NARROW[partition.Fetch[v.CurColor[]].value];
IF cd.count # ALL[1] THEN RETURN [[NIL, NIL]];
{dla: EltListArray = CdToDla[cd];
RETURN [[A: dla[A].first, B: dla[B].first]];
}}};
partition: ColorTable;
quittedEarly: BOOL;
FOR r: Role IN Role DO IF vsp[r] # NIL THEN {
id: RealGraphID ~ roleToGraphID[r];
vsp[r].maxFlatTransistors[Original] _ MAX[vsp[r].maxFlatTransistors[Original], scts[id].transCounts.flatTransistors];
vsp[r].maxFlatTransistors[Reconciled] _ MAX[vsp[r].maxFlatTransistors[Reconciled], scts[id].transCounts.flatTransistors - scts[id].transCounts.flatTransMerges];
} ENDLOOP;
PushTimer[$base];
{ENABLE UNWIND => PopTimer[$base];
[isomorphic, quittedEarly, partition] _ CompareGraphs[realDescrs, sctA, sctB, trace, GenerateHints, automorphismHack, FALSE, mayQuitEarly, abort];
IF abort^ THEN {PopTimer[$base]; RETURN [FALSE]};
didQuitEarly^ _ quittedEarly;
[] _ partition.Pairs[ReportColor];
IF Querier # NIL THEN Querier[Answer];
ForgetGraph[sctA];
ForgetGraph[sctB]};
PopTimer[$base]}}};

ToLeaves: PUBLIC PROC [data: REF ANY, instance: CC.CellInstance, path: CF.InstancePath, ttols: TransistorTolerances] RETURNS [SubtreeAns] --SubtreeSpec-- = {
basic: Core.CellType ~ CO.ToBasic[instance.type];
IF basic.class = CC.recordCellClass
THEN RETURN [[NIL, [NIL]]]
ELSE RETURN [[basic, CreateParallelMapper[basic, instance.type]]];
};

DontFlatten: PUBLIC PROC [data: REF ANY, instance: CC.CellInstance, path: CF.InstancePath, ttols: TransistorTolerances] RETURNS [SubtreeAns] --SubtreeSpec-- = {
RETURN [[instance.type, CreateIdentityMapper[instance.type]]]};

CreateParallelMapper: PUBLIC PROC [from, to: Core.CellType] RETURNS [MapEnumerator] ~ {
RETURN [[EnumerateParallel, NEW [FromTo _ [from, to]]]]};

FromTo: TYPE ~ RECORD [from, to: Core.CellType];

EnumerateParallel: PROC [data: REF ANY, Consume: MapConsumer] ~ {
ft: REF FromTo ~ NARROW[data];
seen: RefTab.Ref ~ RefTab.Create[];
PerPair: PROC [actualWire, publicWire: Core.Wire] RETURNS [subWires: BOOL _ TRUE, quit: BOOL _ FALSE] --CO.EachWirePairProc-- ~ {
ProduceTos: PROC [Consume: ToConsumer] ~ {Consume[actualWire]};
IF seen.Fetch[publicWire].found THEN RETURN;
IF NOT seen.Insert[publicWire, $T] THEN ERROR;
Consume[publicWire, ProduceTos];
RETURN};
[] _ CO.VisitBindingSeq[ft.to.public, ft.from.public, PerPair];
RETURN};

MergeNothing: PUBLIC PROC [data: REF ANY, parent: Core.CellType, recastOfSubroot: BOOL, EnumerateInstances: PROC [Consume: PROC [ci: CC.CellInstance] RETURNS [stop: BOOL _ FALSE]], IdentifyActual: PROC [ci: CC.CellInstance, actual: Core.Wire, describe: BOOL _ FALSE] RETURNS [ActualID], Consume: MergeConsumer, Depublicize: Depublicizer] --MergeSpec-- = {
RETURN};

CreatePublicMapping: PROC [from, to: Core.CellType] RETURNS [pm: OneToOne.OneToOne] = {
Note: PROC [actualWire, publicWire: Core.Wire] RETURNS [subWires: BOOL _ TRUE, quit: BOOL _ FALSE] --CO.EachWirePairProc-- = {
wfrom: Core.Wire = actualWire;
wto: Core.Wire = publicWire;
IF wfrom.size # wto.size THEN ERROR;
IF wto.size = 0 THEN {
dfrom: DescendantWire = NEW [CF.FlatWireRec _ [wireRoot: public, wire: wfrom]];
dto: DescendantWire = NEW [CF.FlatWireRec _ [wireRoot: public, wire: wto]];
pm.Associate[dfrom, dto];
};
};
IF from = to THEN RETURN [OneToOne.id];
pm _ OneToOne.CreateVanillaOneToOne[HashDescendant, HashDescendant, DescendantEqual, DescendantEqual];
IF CO.VisitBinding[from.public, to.public, Note] THEN ERROR;
pm _ pm;
};

HashDescendant: PUBLIC PROC [ra: REF ANY] RETURNS [CARDINAL] = {
org: Descendant = ra;
RETURN [WITH org SELECT FROM
x: DescendantWire => x.FlatWireHash[],
x: DescendantCellInstance => x^.InstancePathHash[],
ENDCASE => ERROR]};

DescendantEqual: PUBLIC PROC [key1, key2: REF ANY] RETURNS [BOOL] = {
o1: Descendant = key1;
o2: Descendant = key2;
RETURN [WITH o1 SELECT FROM
x: DescendantWire => WITH o2 SELECT FROM
y: DescendantWire => x.FlatWireEqual[y],
ENDCASE => FALSE,
x: DescendantCellInstance => WITH o2 SELECT FROM
y: DescendantCellInstance => x^.InstancePathEqual[y^],
ENDCASE => FALSE,
ENDCASE => ERROR]};

DisplayStats: PUBLIC PROC ~ {StructuralComparisonOps.DisplayStats[]};

GetConstraints: PUBLIC PROC [subroot: Core.CellType] RETURNS [RefTab.Ref] ~ {RETURN GetCommonalityConstraints[subroot]};

TimerStack: TYPE ~ LIST OF Timer;
Timer: TYPE ~ REF TimerPrivate;
TimerPrivate: TYPE ~ RECORD [
activity: ATOM,
secs, msecs: INT _ 0,
startGMT: BasicTime.GMT _ BasicTime.Now[],
startPulses: BasicTime.Pulses _ BasicTime.GetClockPulses[],
on: BOOL _ FALSE];

timers: RefTab.Ref ~ RefTab.Create[];
timerStack: TimerStack _ NIL;
timedProcess: UNSAFE PROCESS _ NIL;
countedSeconds: INT _ 0;
sendTimers: CONDITION;

PushTimer: PUBLIC ENTRY PROC [activity: ATOM] ~ {
me: UNSAFE PROCESS ~ Process.GetCurrent[];
nowGmt: BasicTime.GMT ~ BasicTime.Now[];
nowPulses: BasicTime.Pulses ~ BasicTime.GetClockPulses[];
IF timerStack=NIL THEN timedProcess _ me
ELSE {
IF timedProcess#me THEN ERROR--don't use PWCoreLichen in multiple processes (while I'm gathering these statistics)--;
StopTop[nowGmt, nowPulses]};
{timer: Timer _ NARROW[timers.Fetch[activity].val];
IF timer=NIL THEN IF NOT timers.Store[activity, timer _ NEW [TimerPrivate _ [activity]]] THEN ERROR;
timerStack _ CONS[timer, timerStack];
StartTop[nowGmt, nowPulses];
RETURN}};

PopTimer: PUBLIC ENTRY PROC [activity: ATOM] ~ {
me: UNSAFE PROCESS ~ Process.GetCurrent[];
nowGmt: BasicTime.GMT ~ BasicTime.Now[];
nowPulses: BasicTime.Pulses ~ BasicTime.GetClockPulses[];
IF timerStack.first.activity # activity THEN ERROR--caller blew it--;
StopTop[nowGmt, nowPulses];
timerStack _ timerStack.rest;
IF timerStack#NIL THEN StartTop[nowGmt, nowPulses];
RETURN};

StartTop: INTERNAL PROC [nowGmt: BasicTime.GMT, nowPulses: BasicTime.Pulses] ~ {
timer: Timer ~ timerStack.first;
timer.startGMT _ nowGmt;
timer.startPulses _ nowPulses;
IF timer.on THEN ERROR;
timer.on _ TRUE;
RETURN};

StopTop: INTERNAL PROC [nowGmt: BasicTime.GMT, nowPulses: BasicTime.Pulses] ~ {
timer: Timer ~ timerStack.first;
IF NOT timer.on THEN ERROR;
timer.on _ FALSE;
{ds: INT ~ BasicTime.Period[timer.startGMT, nowGmt];
IF ds < 1000 THEN {
dp: BasicTime.Pulses ~ nowPulses-timer.startPulses;
dss: CARD ~ BasicTime.PulsesToMicroseconds[dp];
IF dss > 1D9+1D6 THEN ERROR;
{dsi: CARD ~ dss/1D6;
dsm: CARD ~ dss - dsi*1D6;
timer.secs _ timer.secs + dsi;
countedSeconds _ countedSeconds + dsi;
IF (timer.msecs _ timer.msecs + dsm) > 1D6 THEN {
timer.secs _ timer.secs + 1;
timer.msecs _ timer.msecs - 1D6;
countedSeconds _ countedSeconds + 1};
}}
ELSE {
timer.secs _ timer.secs + ds;
countedSeconds _ countedSeconds + ds};
IF countedSeconds>500 THEN BROADCAST sendTimers;
timer.on _ FALSE;
RETURN}};

Sender: PROC ~ {
Wait: ENTRY PROC ~ {ENABLE UNWIND => NULL; WAIT sendTimers; RETURN};
Process.SetPriority[Process.priorityForeground];
DO Wait[]; [] _ SendTimers[2]; ENDLOOP;
};

SendTimers: PROC [threshold: NAT _ 0] RETURNS [aboveThreshold, sent: BOOL _ FALSE, info: SimpleMailer.SendMessageInfo _ ok] ~ {
ComposeBody: ENTRY PROC RETURNS [ROPE] ~ {
ENABLE UNWIND => NULL;
to: IO.STREAM ~ IO.ROS[];
PerTimer: PROC [key, val: REF ANY] RETURNS [quit: BOOL _ FALSE]--RefTab.EachPairAction-- ~ {
activity: ATOM ~ NARROW[key];
timer: Timer ~ NARROW[val];
IF timer.activity # activity THEN ERROR;
to.PutF["%g: %g.%06d\n", [atom[activity]], [integer[timer.secs]], [integer[timer.msecs]] ];
timer.secs _ timer.msecs _ 0;
RETURN [FALSE]};
IF NOT (aboveThreshold _ countedSeconds >= threshold) THEN RETURN [NIL];
IF timers.Pairs[PerTimer] THEN ERROR;
countedSeconds _ 0;
RETURN [to.RopeFromROS[]]};
body: ROPE ~ ComposeBody[];
IF NOT aboveThreshold THEN RETURN;
[sent, info] _ SimpleMailer.SendMessage[
from: "StructuralComparison",
to: LIST["Spreitzer.pa"],
subject: "Timers",
body: body];
RETURN};

Start: PROC ~ TRUSTED {
Process.InitializeCondition[@sendTimers, Process.SecondsToTicks[600]];
Process.Detach[FORK Sender[]];
Process.Yield[];
RETURN};

Start[];

END.
ŠStructuralComparisonOuter.Mesa
Last tweaked by Mike Spreitzer on March 4, 1989 1:52:12 pm PST
Barth, April 16, 1987 10:44:04 pm PDT
Κ–

"cedar" style˜
code™K™>K™%—K˜KšΟk	œsœ—
˜•K˜šΡbnxœœ
˜(Kšœmœ†
˜ό
Kšœ˜ Kšœ"˜(Kš
œ
˜
—K˜Kšœ
œ
œœ
œœs˜―
K˜Kšœœœ
˜Kšœ
œœœ˜:K˜Kšœœœ
œ
˜6K˜Kšœœœ.˜BK˜š
œ˜š
˜šœ˜Kšœœœ
œ
˜Kš
œ˜Kšœœœœ˜0Kšœœœ
œ˜1KšΟn	œœ
˜KšŸœœ
˜'KšŸœœ
˜$KšŸœœ
˜6KšŸ
œœ
˜(KšŸœœ
˜"Kšœœ
˜Kšœ œœ
˜-Kšœœ
œ
˜K˜Kšœœœ˜ Kšœœ
œ˜Kš
œ
˜
—Kšœœ
˜—˜Kš
œG˜Gšœœœ˜'KšŸ
œœ˜KšŸ
œœ˜—š
Ÿœœœ
œ
Οcœ˜Kš
œœœ
œœ
˜.Kšœœ˜-Kšœœœ$˜=Kšœœ˜—šœ
œ
œ˜Kšœ
œœ˜5Kšœ
œ&œ
œ
˜7K˜—K˜—š
Ÿœœœ
œ
 œ˜KKšœœ
˜Kšœœ
œœ
œ
œ
˜$šœœ
˜Kšœœ"œ
œ˜bKš	œœœ&œ
œ&˜vKšœœ
˜—Kšœœ˜4šœ
œ
œ˜Kšœ
œœ˜5Kšœ
œ&œ
œ
˜7K˜—šœ	œ
œ˜Kšœœ
œ
œ
˜K˜—K˜—šœ(œ)˜UKš	œœœ
œ3œ˜qKš	œœœ
œ*œ
˜YKš
œ˜—Kšœœ
œœ˜šœ)œ)˜VKš	œœœ
œ3œ˜qKš	œœœ
œ*œ
˜YKš
œ˜—Kšœœ
œœ˜Kšœœ
œ(˜CKšœœ
œ˜9šŸ
œœŸœœ˜8š
Ÿœœœœ
 œ˜BKš
œ'˜'Kš
œ'˜'K˜K˜—Kšœ
œ
œ˜,šœœ˜$šŸ	œœœ
œœœœ˜DKšœ
œ˜Kšœ
œ
œœ
œ
œ
˜/Kš
œ˜K˜—Kšœ'œ
œ
˜4K˜—šœœ˜$Kšœœ˜šŸœœ˜Kšœ	œœ
˜šœ$œœ
˜8šœœœ
œ
˜&Kšœœ˜3Kšœœœ2˜jKšœœ
˜—Kšœ
œ˜2šœœ
œ˜Kšœ	œ
œ
˜Kšœ
œ
˜Kšœ
œ
œœ
œ
œ
˜/Kš
œ˜K˜—Kšœ
˜—K˜—Kšœœ˜$K˜—K˜—šŸœœœ˜=Kšœœ
œ˜šœ-œœ
˜@Kšœ
œ
œœ ˜PKšœ
˜—K˜
K˜—šŸœœœ	œ
œœœœ 'œ˜uKšœœ˜Kš
œ˜šœœœ˜Kšœœ
œ
œ
˜(šœœ
œ
œ˜"Kšœœ˜Kšœœœ
œ˜$—šœœ
˜$Kšœœœ
˜šœ$œœ
˜8šœ
œ
˜š
œ ˜ Kšœœ	œ0˜QKšœœœ˜1Kšœœœ
œœ
œ
˜Sšœœ˜Kšœœœ
˜$Kš	œœ
œœ$œ˜HKš	œœ
œœ$œ
˜GKš	œœœ
œœ
˜Kšœœœ
œœœ
œœ˜[šœœœ˜.Kšœœ&œ
œ
˜LKšœ
œœ:˜KK˜—K˜—Kšœœ
˜K˜—š
œ˜Kšœœœ
˜Kšœœ
œœ
œœ
œ
˜dKš
œ˜—Kšœœ
˜—Kšœ
˜—Kšœœ
œ
˜Kšœ
˜—Kšœ!œ
œ
˜.šœœœ˜7š
œœœœœ˜Wšœœ˜)Kšœœ'˜2šœœœ
˜CKšœœ­
˜΄
Kš
œ˜K˜	K˜ KšŸœ
˜
—Kšœ
˜—K˜
—šœ
˜Kš	œœœœdœd˜ύ
Kš
œ˜K˜	K˜ KšŸœ
˜
—K˜—Kšœœ
œ+˜@K˜
—Kš	œ
œœœ
˜:šœ˜šœœ
œ
˜&Kšœœœœ˜>K˜	K˜ KšŸœ
˜
—K˜—K˜—šŸœœœ˜=Kš
œ"˜"Kš
œ4˜4Kšœœ
œ
œœœ˜$Kšœœ&˜=Kšœœœ
œœœ˜.Kš
œ!˜!Kšœ&˜,K˜—Kš
œ˜Kšœœ
˜šœ	œœ
œ
œ
œ˜-Kš
œ#˜#Kšœ&œL˜uKšœ(œu˜ 
Kšœœ
˜
—Kš
œ˜Kšœ
œ
œ˜"Kšœvœ˜’
Kšœœœœ˜1Kš
œ˜Kš
œ"˜"Kšœœ
œ˜&Kš
œ˜Kš
œ˜Kš
œ˜——K˜šŸœœ
œœ
œœœ,œ œ˜
Kšœœ˜1šœœ˜#Kšœ
œœœ˜Kšœ
œ7˜B—K˜—K˜šŸœœ
œœ
œœœ,œ œ˜ 
Kšœ9˜?—K˜šŸœœ
œœ˜WKšœœ˜9—K˜Kšœœœ˜0K˜š
Ÿœœœ
œŸœ˜AKšœœ
œ˜K˜#šŸœœ%œœœœœ œ˜
KšŸ
œœŸœ&˜?Kšœœ
œ
˜,Kšœ
œœ
œ
˜.K˜ Kšœ˜—Kšœœ8˜?Kšœ˜—K˜š.Ÿœœ
œœ
œ*œŸœœŸœœœœœœŸœœœ,œœœ
ŸœŸœ 
œ˜γKšœ˜—K˜šŸœœœ˜WšŸœœ%œœœœœ œ˜~Kšœ
Οdœ˜Kšœ
‘œ˜Kš
œ‘œ	‘œœ
œ
˜$šœ‘œ
œ˜Kš	œ
‘œœœ)‘œ˜OKš	œ
‘œœœ)‘œ˜KKšœ‘œ‘œ˜K˜—K˜—Kšœœ
œ˜'Kš
œf˜fKšœ
œ,œ
œ
˜<K˜K˜—K˜šŸœœ
œœ
œœœ˜@Kš
œ˜šœœœ
˜Kš
œ&˜&Kš
œ3˜3Kšœœ˜——K˜šŸœœ
œœ
œœœ˜EKš
œ˜Kš
œ˜šœœœ
˜šœœœ
˜(Kš
œ(˜(Kšœœ
˜—šœœœ
˜0Kš
œ6˜6Kšœœ
˜—Kšœœ˜——K˜KšŸœœ
œ,˜EK˜Kš
Ÿœœ
œœœ%˜xK˜Kšœœœ
œ˜!Kšœœœ˜šœœœ˜Kšœ
œ
˜KšœΟg
œœ˜Kšœœ˜*Kš
œ;˜;Kšœœœ˜—K˜K˜%Kšœœ
˜Kšœœ
œœ
˜#Kšœœ˜Kšœ	œ
˜K˜š
Ÿ	œœ
œ
œœ˜1Kšœœ
œ˜*Kšœœ˜(Kš
œ9˜9Kšœœ
œ˜(šœ˜Kšœœ
 Wœ
˜uKš
œ˜—Kšœœ˜3Kšœœ
œ
œ
œ œœ
œ
˜dKšœ
œ˜%Kš
œ˜Kšœ˜	—K˜š
Ÿœœ
œ
œœ˜0Kšœœ
œ˜*Kšœœ˜(Kš
œ9˜9Kšœ&œ
 œ
˜EKš
œ˜Kš
œ˜Kšœœ
œ˜3Kšœ˜—K˜šŸœœ
œœ"˜PKš
œ ˜ Kš
œ˜Kš
œ˜Kšœ
œ
œ
˜Kšœœ
˜Kšœ˜—K˜šŸœœ
œœ"˜OKš
œ ˜ Kšœ
œ
œ
œ
˜Kšœœ
˜Kšœ
’
œœ,˜4šœ
’
œ	œ˜Kš’
œ2˜3Kš’
œœ"’
œ˜/Kšœ
’
œ
œ
œ
˜Kšœ
’
œœ’
œ˜Kš’
œœ’
œ’
œ˜Kšœ’
œ˜Kšœ"’
œ˜&š
œ’
œ
’
œ’
œ
œ˜1Kš
œ˜Kšœ’
œ
’
œ˜ Kš
œ%˜%—Kš
œ˜—šœ˜Kšœ’
œ˜Kšœ"’
œ˜&—Kšœœ
	œ˜0Kšœœ
˜Kšœ˜	—K˜šŸœœ˜KšŸœœ
œœ
œœœ
œ˜DKš
œ0˜0Kšœœ
˜'K˜—K˜šŸ
œœ
œœœœ.˜š
Ÿœœ
œ
œœ˜*Kšœ
œœ
˜Kš	œœ
œœ
œ˜šŸœœœ
œœœœ
 œ˜\Kšœ
œœ˜Kšœœ˜Kšœœ
œ
˜(KšœQ’
œ	˜[Kšœ’
œ	˜Kšœœ˜—Kš
œ
œ0œ
œœ˜HKšœœ
œ
˜%Kš
œ˜Kšœ˜—Kšœœ˜Kšœ
œœ
œ
˜"š
œ(˜(K˜Kšœœ˜K˜K˜—Kšœ˜—K˜šŸœœœ˜Kš
œF˜FKšœœ˜Kš
œ˜Kšœ˜—K˜K˜K˜Kšœ
˜—…—>DSι