DIRECTORY Basics, CompareDataStructure, CompareOps, CompareTransforms, CompareTransformsPrivate, DFUtilities, FS, IO, List, OrderedSymbolTableRef, RefTab, Rope, TextReplace, ViewerIO;

CompareSpecialTransforms: CEDAR PROGRAM
IMPORTS CompareOps, CompareTransforms, CompareTransformsPrivate, OrderedSymbolTableRef, RefTab, Rope, TextReplace
EXPORTS CompareTransforms, CompareOps, CompareTransformsPrivate =

BEGIN OPEN CompareDataStructure, CompareTransforms, CompareOps, CompareTransformsPrivate;

Special: TYPE = REF SpecialRep;
SpecialRep: TYPE = RECORD [ra: REF ANY];

all: PUBLIC REF ANY _ NEW [SpecialRep _ [$all]];

ExpandVertex: PUBLIC PROC [design: Design, childA: REF ANY] =
BEGIN
child: Vertex _ ToVertex[design, childA];
parentType: CellType _ child.parent;
childType: CellType _ child.type;
[] _ ExpandVertexWork[child];
NoteChange[parentType];
CheckType[parentType, ignore, ignore];
CheckType[childType, ignore, ignore];
END;

igig: LORA _ LIST[$ignore, $ignore];

ExpandChildren: PUBLIC PROC [design: Design, parentTypeA: REF ANY, flatten: BOOL _ FALSE] =
BEGIN
parentType: CellType _ ToType[design, parentTypeA];
childTypes: RefTab.Ref _ RefTab.Create[];
children: RefTab.Ref _ RefTab.Create[];
NoteOldChild: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
v: Vertex _ NARROW[AntiAlias[ra]];
[] _ children.Insert[v, $T];
stop _ FALSE};
ExpandOldChild: PROC [key, val: REF ANY] RETURNS [quit: BOOL] = {
v: Vertex _ NARROW[key];
quit _ FALSE;
SELECT v.class FROM
cell => {
childType: CellType _ v.type;
EnsureParts[childType];
IF ExpansionKnown[childType] THEN {
sibs: VertexList _ ExpandVertexWork[v];
[] _ childTypes.Insert[childType, igig];
IF flatten THEN {
FOR sibs _ sibs, sibs.rest WHILE sibs # NIL DO
[] _ ExpandOldChild[sibs.first, NIL];
ENDLOOP;
};
};
};
net => NULL;
ENDCASE => ERROR;
};
EnsureParts[parentType];
IF NOT ExpansionKnown[parentType] THEN ERROR;
parentType.parts.EnumerateIncreasing[NoteOldChild];
[] _ children.Pairs[ExpandOldChild];
NoteChange[parentType];
CheckType[parentType, ignore, ignore];
[] _ childTypes.Pairs[CheckPerType];
END;

ExpandVertexWork: PROC [childCell: Vertex] RETURNS [newSibs: VertexList] =
BEGIN
parentType: CellType _ childCell.parent;
childType: CellType _ childCell.type;
NILEquiv: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
v: Vertex _ NARROW[AntiAlias[ra]];
stop _ FALSE;
v.equiv _ NIL};
SetPortedNetEquivs: PROC = {
innerEdge: Edge _ childType.mirror.firstEdge;
outerEdge: Edge _ childCell.firstEdge;
FOR portIndex: NAT IN [0 .. childType.ports.length) DO
IF innerEdge.portIndex # portIndex THEN ERROR;
IF outerEdge.portIndex # portIndex THEN ERROR;
IF innerEdge.sides[cell].v # childType.mirror THEN ERROR;
IF outerEdge.sides[cell].v # childCell THEN ERROR;
innerEdge.sides[net].v.equiv _ outerEdge.sides[net].v;
innerEdge _ innerEdge.sides[cell].next;
outerEdge _ outerEdge.sides[cell].next;
ENDLOOP;
IF innerEdge # NIL OR outerEdge # NIL THEN ERROR};
Copy: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
v: Vertex _ NARROW[AntiAlias[ra]];
stop _ FALSE;
[] _ CopyWork[v]};
CopyWork: PROC [gc: Vertex] RETURNS [newChild: Vertex] = {
IF gc.equiv # NIL THEN RETURN [gc.equiv];
gc.equiv _ newChild _ NEW [VertexRep _ [names: JoinNames[childCell.names, gc.names], type: gc.type, parent: parentType, class: gc.class, other: gc.other]];
AddVertex[newChild];
IF newChild.class = net THEN RETURN;
LinkInstance[newChild];
FOR oldE: Edge _ gc.firstEdge, oldE.sides[cell].next WHILE oldE # NIL DO
newNet: Vertex _ CopyWork[oldE.sides[net].v];
IF oldE.sides[cell].v # gc THEN ERROR;
AddEdge[newChild, newNet];
ENDLOOP;
newSibs _ CONS[newChild, newSibs];
};
newSibs _ NIL;
EnsureParts[childType];
IF NOT ExpansionKnown[childType] THEN ERROR;
childType.mirror.equiv _ NIL;
childType.parts.EnumerateIncreasing[NILEquiv];
childType.mirror.equiv _ childCell;
SetPortedNetEquivs[];
childType.parts.EnumerateIncreasing[Copy];
DeleteVertex[childCell];
childType.mirror.equiv _ NIL;
childType.parts.EnumerateIncreasing[NILEquiv];
CheckType[parentType, ignore, ignore, TRUE];
END;

Group: PUBLIC PROC [design: Design, parentTypeA, childrenA: REF ANY, childNames, childTypeNames: Names, newPortNamer: NewPortNamer] RETURNS [newChild: Vertex, newGrandchildren: VertexS] =
BEGIN
parentType: CellType _ ToType[design, parentTypeA];
oldChildren: VertexS _ ToVertexS[parentType, childrenA];
newChildType: CellType _ NewEmptyCellType[design, childTypeNames];
newChild _ CreateEmpty[design: design, childNames: childNames, childType: newChildType, parentType: parentType];
[gcs: newGrandchildren] _ LowerChildren[design: design, childTypeA: newChildType, gcNamesl: ListNames[oldChildren], sibber: OneMap[newChild, oldChildren], newPortNamer: newPortNamer];
END;

NameNewPortFromAnyOldPort: PUBLIC PROC
[
data: REF ANY, first: BOOL, ct: CellType,
ports: PortS, portIndex: PortIndex,
oldNet: Vertex, oldConnections: EdgeList]
RETURNS [names: Names, equivClass: EquivClass] =
{
from: Vertex _ oldConnections.first.sides[cell].v;
index: PortIndex _ oldConnections.first.portIndex;
names _ from.type.ports[index].names;
equivClass _ from.type.ports[index].equivClass};

NameNewPortFromAnyOldPortInstance: PUBLIC PROC
[
data: REF ANY, first: BOOL, ct: CellType,
ports: PortS, portIndex: PortIndex,
oldNet: Vertex, oldConnections: EdgeList]
RETURNS [names: Names, equivClass: EquivClass] =
{
from: Vertex _ oldConnections.first.sides[cell].v;
index: PortIndex _ oldConnections.first.portIndex;
names _ from.type.ports[index].names;
IF NOT first THEN names _ JoinNames[from.names, names, FALSE];
equivClass _ from.type.ports[index].equivClass;
IF NOT first THEN equivClass _ QualifyEquivClass[from.names, equivClass, FALSE];
};

NameNewPortFromOldNet: PUBLIC PROC
[
data: REF ANY, first: BOOL, ct: CellType,
ports: PortS, portIndex: PortIndex,
oldNet: Vertex, oldConnections: EdgeList]
RETURNS [names: Names, equivClass: EquivClass] =
{
names _ oldNet.names;
equivClass _ implicitClass};

DontNameNewPort: PUBLIC PROC
[
data: REF ANY, first: BOOL, ct: CellType,
ports: PortS, portIndex: PortIndex,
oldNet: Vertex, oldConnections: EdgeList]
RETURNS [names: Names, equivClass: EquivClass] =
{ERROR};

FavorSimpleNames: PUBLIC PROC [data: REF ANY, oldNames: Names, oldEquiv: EquivClass] RETURNS [newNames: Names, newEquiv: EquivClass] = {
newNames _ oldNames;
newEquiv _ oldEquiv;
IF newNames.progged = NIL OR newNames.progged.rest = NIL THEN RETURN;
FOR rl: RopeList _ newNames.progged, rl.rest WHILE rl # NIL DO
class: CARDINAL _ 0;
seeingGen: BOOL _ FALSE;
lastWasGen, lastWasDash, lastWasAlpha, nextLastWasAlpha: BOOL _ FALSE;
FOR i: INT IN [0 .. rl.first.Length[]) DO
c: CHAR _ rl.first.Fetch[i];
SELECT c FROM
'., '- => IF seeingGen THEN class _ class + 1;
ENDCASE;
SELECT c FROM
'. => {class _ class + 1; seeingGen _ FALSE};
IN ['0 .. '9] => {
IF lastWasDash THEN {class _ class + 1; IF seeingGen THEN ERROR};
IF lastWasGen AND NOT nextLastWasAlpha THEN seeingGen _ TRUE;
};
ENDCASE => seeingGen _ FALSE;
nextLastWasAlpha _ lastWasAlpha;
SELECT c FROM
'., '-  => lastWasAlpha _ FALSE;
ENDCASE => lastWasAlpha _ TRUE;
SELECT c FROM
'n, 'C, 'Q => {lastWasGen _ TRUE; lastWasDash _ FALSE};
'- => {lastWasGen _ FALSE; lastWasDash _ TRUE};
ENDCASE => lastWasGen _ lastWasDash _ FALSE;
ENDLOOP;
IF seeingGen THEN class _ class + 1;
classes[MIN[WorstClass, class]].Insert[rl.first];
ENDLOOP;
newNames.progged _ NIL;
FOR c: CARDINAL IN [0 .. WorstClass] DO
name: ROPE _ NARROW[classes[c].LookupLargest[]];
IF name = NIL THEN LOOP;
WHILE name # NIL DO
newNames.progged _ CONS[name, newNames.progged];
name _ NARROW[classes[c].LookupNextSmaller[name]];
ENDLOOP;
FOR d: CARDINAL IN [c .. WorstClass] DO classes[d].DeleteAllItems[] ENDLOOP;
EXIT;
ENDLOOP;
IF newNames.progged = NIL THEN ERROR;
};
WorstClass: CARDINAL ~ 8;
classes: ARRAY [0 .. WorstClass] OF SymbolTable;
CompareRopes: PROC [r1, r2: REF ANY] RETURNS [c: Basics.Comparison] = {
c _ NARROW[r1, ROPE].Compare[NARROW[r2]];
};
InitClasses: PROC = {
FOR c: CARDINAL IN [0 .. WorstClass] DO classes[c] _ OrderedSymbolTableRef.CreateTable[CompareRopes] ENDLOOP;
};

ReNameByName: PUBLIC PROC [rm: RopeMap] RETURNS [r: Renamer] = {
r _ [rm, RenameByName];
};

RenameByName: PROC [data: REF ANY, oldNames: Names, oldEquiv: EquivClass] RETURNS [newNames: Names, newEquiv: EquivClass] = {
rm: RopeMap _ NARROW[data];
diff: BOOL _ FALSE;
RenameRope: PROC [old: ROPE] RETURNS [new: ROPE] = {
new _ rm.Apply[old];
diff _ diff OR NOT new.Equal[old];
};
RenameList: PROC [old: RopeList] RETURNS [new: RopeList] = {
newTail: RopeList _ new _ NIL;
FOR old _ old, old.rest WHILE old # NIL DO
[new, newTail] _ RopeListCat[RenameRope[old.first], new, newTail];
ENDLOOP;
};
newEquiv _ RenameRope[oldEquiv];
newNames.designed _ RenameList[oldNames.designed];
newNames.unknown _ RenameList[oldNames.unknown];
newNames.progged _ RenameList[oldNames.progged];
IF NOT diff THEN RETURN [oldNames, oldEquiv];
};

MapRopePairs: PUBLIC PROC [pairs: RopePairList] RETURNS [rm: RopeMap] = {
st: SymbolTableHolder _ NEW [SymbolTable _ OrderedSymbolTableRef.CreateTable[ComparePairs]];
FOR pairs _ pairs, pairs.rest WHILE pairs # NIL DO
st^.Insert[pairs];
ENDLOOP;
rm _ NEW [TextReplace.RopeMapRep _ [MapByPairs, st]];
};

ComparePairs: PROC [r1, r2: REF ANY] RETURNS [c: Basics.Comparison] = {
Key: PROC [ra: REF ANY] RETURNS [k: ROPE] = {
IF ra = NIL THEN k _ NIL ELSE WITH ra SELECT FROM
r: ROPE => k _ r;
p: RopePairList => k _ p.first.old;
ENDCASE => ERROR};
c _ Key[r1].Compare[Key[r2]];
};

MapByPairs: PROC [data: REF ANY, old: ROPE] RETURNS [new: ROPE] = {
st: SymbolTableHolder _ NARROW[data];
p: RopePairList _ NARROW[st^.Lookup[old]];
new _ IF p # NIL THEN p.first.new ELSE old;
};

RenamePairs: PUBLIC PROC [pairs: RopePairList] RETURNS [r: Renamer] = {
r _ ReNameByName[MapRopePairs[pairs]];
};

Setter: TYPE = REF SetterRep;
SetterRep: TYPE = RECORD [names: Names, equivClass: EquivClass];

useOldNames: PUBLIC Names _ [LIST["use old designed"], LIST["use old unknown"], LIST["use old progged"]];
useOldEquivClass: PUBLIC ROPE _ "use old equiv class";

SetNames: PUBLIC PROC [names: Names _ useOldNames, equivClass: EquivClass _ useOldEquivClass] RETURNS [r: Renamer] = {
r _ [NEW [SetterRep _ [names, equivClass]], DoSetNames];
};

DoSetNames: PROC [data: REF ANY, oldNames: Names, oldEquiv: EquivClass] RETURNS [newNames: Names, newEquiv: EquivClass] = {
s: Setter _ NARROW[data];
newNames _ IF s.names = useOldNames THEN oldNames ELSE s.names;
newEquiv _ IF s.equivClass = useOldEquivClass THEN oldEquiv ELSE s.equivClass;
};

RopeListCat: PROC [rope: ROPE, oldHead, oldTail: RopeList] RETURNS [newHead, newTail: RopeList] = {
newHead _ oldHead;
newTail _ LIST[rope];
IF oldTail # NIL THEN oldTail.rest _ newTail ELSE newHead _ newTail;
};

CellTypePair: TYPE = REF CellTypePairRep;
CellTypePairRep: TYPE = RECORD [ct1, ct2: CellType];

ChildrenOfType: PUBLIC PROC [design: Design, parentTypeA, childTypeA: REF ANY] RETURNS [bag: Bag] = {
parentType: CellType _ ToType[design, parentTypeA];
childType: CellType _ ToType[design, childTypeA];
bag _ NEW [BagRep _ [
data: NEW [CellTypePairRep _ [parentType, childType]],
Enumerate: EnumerateTypedChildren ]];
};

ImplicitChildrenOfType: PUBLIC PROC [design: Design, childTypeA: REF ANY] RETURNS [bag: Bag] = {
childType: CellType _ ToType[design, childTypeA];
bag _ NEW [BagRep _ [
data: NEW [CellTypePairRep _ [implicitType, childType]],
Enumerate: EnumerateTypedChildren ]];
};

implicitType: CellType _ NEW [CellTypeRep _ [design: NIL, names: [designed: LIST["implicitType"]] ]];

EnumerateTypedChildren: PROC [context, data: REF ANY, to: PROC [REF ANY]] = {
PerChild: PROC [ra: REF ANY] RETURNS [quit: BOOL] = {
a: Alias _ NARROW[ra];
v: Vertex _ NARROW[AntiAlias[a]];
quit _ FALSE;
IF a.name # PickAName[v.names] THEN RETURN;
SELECT v.class FROM
net => RETURN;
cell => NULL;
ENDCASE => ERROR;
IF v.type = childType THEN to[v];
};
ctp: CellTypePair _ NARROW[data];
parentType: CellType _ IF ctp.ct1 # implicitType THEN ctp.ct1 ELSE NARROW[context];
childType: CellType _ ctp.ct2;
parentType.parts.EnumerateIncreasing[PerChild];
};

FirstCellType: PUBLIC PROC [design: Design] RETURNS [ct: CellType] = {
ct _ NARROW[design.cellTypesByAddress.LookupSmallest[]];
};

NextCellType: PUBLIC PROC [prev: CellType] RETURNS [next: CellType] = {
next _ NARROW[prev.design.cellTypesByAddress.LookupNextLarger[prev]];
};

EnumerateCellTypes: PUBLIC PROC [design: Design, ra: REF ANY, consume: PROC [CellType]] = {
EatAny: PROC [ra: REF ANY] = {
ct: CellType _ NARROW[ra];
consume[ct]};
WITH ra SELECT FROM
cl: LIST OF CellType => FOR l: LIST OF CellType _ cl, l.rest WHILE l # NIL DO
consume[l.first]
ENDLOOP;
lora: LORA => FOR l: LORA _ lora, l.rest WHILE l # NIL DO
consume[ToType[design, l.first]]
ENDLOOP;
bag: Bag => {
bag.Enumerate[design, bag.data, EatAny];
};
ENDCASE => ERROR};

EnumerateParts: PUBLIC PROC [ct: CellType, consume: PROC [Vertex]] = {
PerPart: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
a: Alias _ NARROW[ra];
v: Vertex _ NARROW[AntiAlias[a]];
stop _ FALSE;
IF a.name.Equal[PickAName[v.names]] THEN consume[v];
};
ct.parts.EnumerateIncreasing[PerPart];
};

EnumerateVertices: PUBLIC PROC [context, ra: REF ANY, consume: PROC [Vertex]] = {
EatAny: PROC [ra: REF ANY] = {
v: Vertex _ NARROW[ra];
consume[v]};
PerPart: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
a: Alias _ NARROW[ra];
v: Vertex _ NARROW[AntiAlias[a]];
IF PickAName[v.names] = a.name THEN consume[v];
stop _ FALSE};
WITH ra SELECT FROM
vl: VertexList => FOR l: VertexList _ vl, l.rest WHILE l # NIL DO
consume[l.first]
ENDLOOP;
lora: LORA => FOR l: LORA _ lora, l.rest WHILE l # NIL DO
consume[ToVertex[context, l.first]]
ENDLOOP;
bag: Bag => {
bag.Enumerate[context, bag.data, EatAny];
};
s: Special => SELECT s.ra FROM
$all => {ct: CellType _ NARROW[context];
EnsureParts[ct];
IF NOT ExpansionKnown[ct] THEN ERROR;
ct.parts.EnumerateIncreasing[PerPart]};
ENDCASE => ERROR;
ENDCASE => ERROR};

UnlinkInstance: PUBLIC PROC [v: Vertex] = {
IF v.prevInstance # NIL THEN v.prevInstance.nextInstance _ v.nextInstance ELSE v.type.firstInstance _ v.nextInstance;
IF v.nextInstance # NIL THEN v.nextInstance.prevInstance _ v.prevInstance ELSE v.type.lastInstance _ v.prevInstance;
};

LinkInstance: PUBLIC PROC [v: Vertex] = {
v.nextInstance _ NIL;
v.prevInstance _ v.type.lastInstance;
IF v.prevInstance # NIL THEN v.prevInstance.nextInstance _ v ELSE v.type.firstInstance _ v;
IF v.nextInstance # NIL THEN v.nextInstance.prevInstance _ v ELSE v.type.lastInstance _ v;
};

DeleteVertex: PUBLIC PROC [v: Vertex] = {
v _ v;
WHILE v.firstEdge # NIL DO RemoveEdge[v.firstEdge] ENDLOOP;
Delete[v.parent.parts, v.names, v];
SELECT v.class FROM
net => v.parent.netCount _ v.parent.netCount - 1;
cell => {v.parent.cellCount _ v.parent.cellCount - 1;
UnlinkInstance[v]};
ENDCASE => ERROR;
v _ v};

RemoveEdge: PUBLIC PROC [e: Edge] = {
UnlinkSide: PROC [side: VertexClass] = {
head: Vertex _ e.sides[side].v;
IF e.sides[side].next # NIL
THEN e.sides[side].next.sides[side].prev _ e.sides[side].prev
ELSE head.lastEdge _ e.sides[side].prev;
IF e.sides[side].prev # NIL
THEN e.sides[side].prev.sides[side].next _ e.sides[side].next
ELSE head.firstEdge _ e.sides[side].next;
e.sides[side].next _ e.sides[side].prev _ badEdge};
UnlinkSide[net];
UnlinkSide[cell];
};
badEdge: PUBLIC Edge _ NEW [EdgeRep _ [sides: [[NIL, NIL, NIL], [NIL, NIL, NIL]], color: 0, portIndex: NullPortIndex]];

InitClasses[];

END.

g: 	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
m: 	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
CompareSpecialTransforms.Mesa
Last Edited by: Spreitzer, March 9, 1985 5:35:01 pm PST
For detecting name segments matching {n|C|Q}{0..9}+
Κ –

"cedar" style˜Icodeš
œ™J™7K˜KšΟk	œeœœC˜·
K˜šΠbxœœ
˜'Kšœj˜qKšœ:˜AK˜Kšœ
œO˜YK˜Kšœ	œœ˜Kš	œœœœ
œ˜(K˜Kš	œœ
œ
œœ˜0K˜š
Οnœœ
œœ
œ˜=Kš
˜K˜)K˜$K˜!K˜K˜Kš
œ&˜&Kš
œ%˜%Kšœ
˜—K˜Kšœœœ˜$K˜šŸœœ
œœ
œœœ˜[Kš
˜Kš
œ3˜3K˜)K˜'šŸœœœ
œœœ˜9Kšœœ˜"K˜Kšœœ˜—šŸœœœ
œœœ˜AKšœœ˜Kšœœ
˜
šœ	˜˜	K˜K˜šœœ˜#K˜'Kš
œ(˜(šœ	œ˜šœœœ
˜.Kšœ œ˜%Kšœ
˜—K˜—K˜—K˜—Kšœœ
˜Kšœœ
˜—K˜—K˜Kšœ
œœ
œ
˜-Kš
œ3˜3Kš
œ$˜$K˜Kš
œ&˜&Kš
œ$˜$Kšœ
˜—K˜šŸœœœ˜JKš
˜Kš
œ(˜(Kš
œ%˜%šŸœœœ
œœœ˜5Kšœœ˜"Kšœœ
˜
Kšœ
œ˜—šŸœœ˜K˜-K˜&šœœ
œ˜6Kšœ!œ
œ
˜.Kšœ!œ
œ
˜.Kšœ,œ
œ
˜9Kšœ%œ
œ
˜2K˜6K˜'K˜'Kšœ
˜—Kšœ
œ
œ
œ
œ
œ˜2—šŸœœœ
œœœ˜1Kšœœ˜"Kšœœ
˜
Kš
œ˜—šŸœœœ˜:Kšœœ
œ
œ˜)Kšœœ‚
˜›
K˜Kšœœ
œ
˜$K˜šœ2œœ
˜HK˜-Kšœœ
œ
˜&K˜Kšœ
˜—Kšœ
œ˜"K˜—Kšœ
œ
˜K˜Kšœ
œœ
œ
˜,Kšœœ
˜K˜.K˜#K˜K˜*K˜Kšœœ
˜K˜.Kšœ&œ˜,Kšœ
˜—K˜šŸœœ
œ*œ
œAœ0˜»
Kš
˜K˜3K˜8Kš
œB˜BKš
œp˜pKš
œ·
˜·
Kšœ
˜—K˜šŸœœ
˜&š
œ
˜
Kšœœ
œ	œ˜)Kš
œ#˜#Kš
œ)˜)—Kšœ)˜0Kš
œ
˜
Kš
œ2˜2Kš
œ2˜2Kš
œ%˜%Kš
œ0˜0—K˜šŸ!œœ
˜.š
œ
˜
Kšœœ
œ	œ˜)Kš
œ#˜#Kš
œ)˜)—Kšœ)˜0Kš
œ
˜
Kš
œ2˜2Kš
œ2˜2Kš
œ%˜%Kšœ
œœ&œ˜>Kš
œ/˜/Kšœ
œœ8œ˜PKš
œ˜—K˜šŸœœ
˜"š
œ
˜
Kšœœ
œ	œ˜)Kš
œ#˜#Kš
œ)˜)—Kšœ)˜0Kš
œ
˜
Kš
œ˜Kš
œ˜—K˜šŸœœ
˜š
œ
˜
Kšœœ
œ	œ˜)Kš
œ#˜#Kš
œ)˜)—Kšœ)˜0Kšœ
œ˜—K˜šŸœœ
œœ
œ)œ,˜ˆ
Kš
œ˜Kš
œ˜Kšœœ
œœ
œ
œ
˜Ešœ*œœ
˜>Kšœœ˜šœœœ
˜K™3—Kšœ9œœ
˜Fšœœ
œ˜)Kšœœ˜šœ˜
Kšœ
œœ˜.Kšœ
˜—šœ˜
Kšœ&œ˜-šœ˜Kš
œ
œœœ
œ˜AKš
œœ
œœ
œ
˜=K˜—Kšœœ
˜—Kš
œ ˜ šœ˜
Kšœœ
˜ Kšœœ
˜—šœ˜
Kšœœœ˜7Kšœœœ˜/Kšœœ
˜,—Kšœ
˜—Kšœœ˜$Kšœœ&˜1Kšœ
˜—Kšœœ
˜šœœ
œ˜'Kšœœœ˜0Kšœœ
œ
œ
˜šœœ
˜Kšœœ˜0Kšœœ%˜2Kšœ
˜—Kš
œœ
œœœ
˜LKšœ
˜Kšœ
˜—Kšœœ
œ
œ
˜%K˜Kšœœ˜Kšœ	œœ
˜0š
Ÿœœ
œ
œœ˜GKšœœœ
œ˜)K˜—šŸœœ˜Kš
œœ
œœ>œ
˜mK˜——K˜šŸœœ
œœ˜@K˜K˜—K˜š
Ÿœœœ
œ)œ,˜}Kšœœ˜Kšœœœ
˜š
Ÿ
œœœœœ˜4Kš
œ˜Kšœœ
œ˜"K˜—šŸ
œœœ˜<Kšœœ
˜šœœœ
˜*Kš
œB˜BKšœ
˜—K˜—Kš
œ ˜ Kš
œ2˜2Kš
œ0˜0Kš
œ0˜0Kšœ
œœ
œ˜-K˜—K˜šŸœœ
œœ˜IKšœœA˜\šœœ	œ
˜2K˜Kšœ
˜—Kšœœ-˜5K˜—K˜š
Ÿœœ
œ
œœ˜GšŸœœœ
œœœ˜-šœœ
œœ
œ
œœ
˜1Kšœœ
˜K˜#Kšœœ˜——K˜K˜—K˜šŸ
œœœ
œœœœ˜CKšœœ˜%Kšœœ˜*Kš	œœœ
œ
œ˜+K˜—K˜šŸœœ
œœ˜GKš
œ&˜&K˜—K˜Kšœœœ˜Kšœœœ(˜@K˜Kš	œ
œ
œœœ˜iKšœœ
œ˜6K˜šŸœœ
œIœ˜vKšœœ0˜8K˜—K˜š
Ÿ
œœœ
œ)œ,˜{Kšœœ˜Kšœœœ
œ	˜?Kšœœ!œ
œ˜NK˜—K˜šŸœœœœ!˜cK˜Kšœ
œ˜Kšœœ
œœ˜DK˜—K˜Kšœœœ˜)Kšœœœ˜4K˜šŸœœ
œ+œ
œœ˜eK˜3K˜1šœœ˜Kšœœ-˜6K˜%—K˜—K˜šŸœœ
œœ
œœ˜`K˜1šœœ˜Kšœœ/˜8K˜%—K˜—K˜Kšœœœœ˜eK˜šŸœœœ
œœœ
œ˜MšŸœœœ
œœœ˜5Kšœœ˜Kšœœ˜!Kšœœ
˜
Kšœœ
œ
˜+šœ	˜Kšœœ
˜Kšœœ
˜
Kšœœ
˜—Kšœœ˜!K˜—Kšœœ˜!Kš	œœœ	œ
œ
˜SK˜K˜/K˜—K˜šŸ
œœ
œœ˜FKšœœ-˜8K˜—K˜šŸœœ
œœ˜GKšœœ8˜EK˜—K˜šŸœœ
œœ
œœ˜[šŸœœœ
œ˜Kšœœ˜K˜
—šœœ
˜šœœ
œ
œœ
œœœ
˜MKš
œ˜Kšœ
˜—šœœœœœœ
˜9K˜ Kšœ
˜—˜
K˜(K˜—Kšœœ˜——K˜šŸœœ
œœ˜FšŸœœœ
œœœ˜4Kšœœ˜Kšœœ˜!Kšœœ
˜
Kšœ"œ˜4K˜—Kš
œ&˜&K˜—K˜šŸœœ
œœ
œœ˜QšŸœœœ
œ˜Kšœœ˜K˜—šŸœœœ
œœœ˜4Kšœœ˜Kšœœ˜!Kšœœ˜/Kšœœ˜—šœœ
˜šœœœœ
˜AKš
œ˜Kšœ
˜—šœœœœœœ
˜9Kš
œ#˜#Kšœ
˜—˜
Kš
œ)˜)K˜—šœœ˜šœœ
˜(K˜Kšœ
œœ
œ
˜%K˜'—Kšœœ
˜—Kšœœ˜——K˜šŸœœ
œ˜+Kšœœ
œ.œ'˜uKšœœ
œ.œ&˜tK˜—K˜šŸœœ
œ˜)Kšœœ
˜K˜%Kšœœ
œ!œ˜[Kšœœ
œ!œ˜ZK˜—K˜šŸœœ
œ˜)Kš
œ˜Kšœœ
œœ
˜;K˜#šœ	˜K˜1˜5K˜—Kšœœ
˜—Kš
œ˜—K˜šŸ
œœ
œ˜%šŸ
œœ˜(K˜šœ˜Kšœ9˜=Kšœ$˜(—šœ˜Kšœ9˜=Kšœ%˜)—Kš
œ3˜3—Kš
œ˜Kš
œ˜K˜Kšœ	œœœœœœœœ)˜w—K˜K˜K˜Kšœ
˜K˜KšœΟg}˜€
KšœΟm}˜€
——…—=PΜ