DIRECTORY 
Ascii, CD, CDCells, CDCellsExtras, CDDirectory, CDEvents, CDInstances, CDOpsExtras, CDPrivate, CDProperties, CDSatellites, CDTexts, CDTextsExtras, Rope;

CDSatellitesImpl: CEDAR PROGRAM
IMPORTS Ascii, CD, CDCells, CDCellsExtras, CDDirectory, CDEvents, CDInstances, CDOpsExtras, CDPrivate, CDProperties, CDTextsExtras, Rope
EXPORTS CDSatellites =
BEGIN 
OPEN CDSatellites;
ROPE: TYPE = Rope.ROPE;

satellitesProp: REF ATOM ~ NEW[ATOM_$CDSatellitesSatList];
maxGroupIdProp: ATOM ~ $CDSatellitesMax;

iGroupIdProp: ATOM ~ $CDSatellitesGroupId;

oGroupIdProp: ATOM ~ $CDSatellitesOGroup;

noGroup: INT = -1;
maxGroupId: INT _ noGroup+1;

GetSatellites: PUBLIC PROC [from: REF] RETURNS [sats: CD.InstanceList_NIL] = {
WITH from SELECT FROM
d: CD.Design => RETURN [EnforceInvariants[CDOpsExtras.RealTopCell[d]]]; --not cached
ob: CD.Object => IF CDCellsExtras.IsDummyCell[ob] THEN RETURN [EnforceInvariants[ob]];
ENDCASE => NULL;
WITH CDProperties.GetProp[from, satellitesProp] SELECT FROM
s: CD.InstanceList => RETURN [s];
a: ATOM => IF a=$none THEN RETURN [NIL];
ENDCASE => NULL;
WITH from SELECT FROM
ob: CD.Object => IF CDCells.IsCell[ob] THEN RETURN [EnforceInvariants[ob]];
i: CD.Instance => RETURN [NIL];
ENDCASE => ERROR;
};

InternalGetSatellites: PROC [x: REF] RETURNS [CD.InstanceList] = INLINE {
WITH CDProperties.GetProp[x, satellitesProp] SELECT FROM
list: CD.InstanceList => RETURN [list];
ENDCASE => RETURN [NIL];
};

InternalPutSatellites: PROC [x: REF, sats: REF] = INLINE {
WITH x SELECT FROM
i: CD.Instance => CDProperties.PutInstanceProp[i, satellitesProp, sats];
ENDCASE => CDProperties.PutProp[x, satellitesProp, IF sats=NIL THEN $none ELSE sats];
};

EnforceInvariants: PROC [cell: CD.Object] RETURNS [oSats: CD.InstanceList_NIL] = {
world: CD.InstanceList _ NARROW[cell.specificRef, CD.CellPtr].contents;
Node: TYPE = REF NodeRec;
NodeRec: TYPE = RECORD [
id: INT _ -1,
list: CD.InstanceList _ NIL];
Table: TYPE = REF TableRec;
TableRec: TYPE = RECORD [
elements: SEQUENCE size: NAT OF LIST OF Node
];
masterTable: Table _ NEW[TableRec[67]];
iSats: CD.InstanceList;
oldObId: INT;
newObId: REF _ NewId[];

Hash: PROC [i: INT] RETURNS [INT] = INLINE {
RETURN[ABS[i] MOD masterTable.size]
};

StoreMaster: PROC [inst: CD.Instance] = {
id: INT _ IGroupId[inst];
hash: INT _ Hash[id];
FOR nl: LIST OF Node _ masterTable[hash], nl.rest WHILE nl#NIL DO
IF nl.first.id=id THEN {nl.first.list _ CONS[inst, nl.first.list]; RETURN};
ENDLOOP;
masterTable[hash] _ CONS[NEW[NodeRec _ [id: id, list: LIST[inst]]], masterTable[hash]];
};

FetchMaster: PROC [id: INT] RETURNS [CD.InstanceList] = {
hash: INT _ Hash[id];
FOR nl: LIST OF Node _ masterTable[hash], nl.rest WHILE nl#NIL DO
IF nl.first.id=id THEN RETURN [nl.first.list];
ENDLOOP;
RETURN [NIL];
};

TrustedMakeInstSat: PROC [master: CD.Instance, satellite: CD.Instance] = {
sats: CD.InstanceList _ NIL;
WITH InternalGetSatellites[master] SELECT FROM
sats: CD.InstanceList => {
IF Member[sats, satellite] THEN ERROR; 
sats.rest _ CONS[satellite, sats.rest];
RETURN
};
ENDCASE => sats _ LIST[satellite];
CDProperties.PutInstanceProp[master, satellitesProp, sats];
};

oldObId _ OGroupId[cell];
CDProperties.PutObjectProp[cell, oGroupIdProp, newObId];
FOR w: CD.InstanceList _ world, w.rest WHILE w#NIL DO
WITH w.first.ob.specificRef SELECT FROM
tp: CDTexts.TextPtr => 
IF IGroupId[w.first]#noGroup THEN iSats _ CONS[w.first, iSats];
ENDCASE =>
IF IGroupId[w.first]#noGroup THEN {
StoreMaster[w.first];
CDProperties.PutInstanceProp[w.first, satellitesProp, NIL];
}
ENDLOOP;

FOR sl: CD.InstanceList _ iSats, sl.rest WHILE sl#NIL DO
Closer: PROC [newMaster: CD.Instance] RETURNS [BOOL] = INLINE {
mRect, newMRect, sRect: CD.Rect;
IF master=NIL THEN RETURN [TRUE];
mRect _ CDInstances.InstRectO[master];
newMRect _ CDInstances.InstRectO[newMaster];
sRect _ CDInstances.InstRectO[sl.first];
RETURN [RectMinDist[newMRect, sRect] < RectMinDist[mRect, sRect]];
};
master: CD.Instance _ NIL;
satGId: INT _ IGroupId[sl.first];
FOR ml: CD.InstanceList _ FetchMaster[satGId], ml.rest WHILE ml#NIL DO
IF satGId#IGroupId[ml.first] THEN ERROR;
IF Closer[ml.first] THEN master _ ml.first;
ENDLOOP;
IF master#NIL THEN --InstSat-- TrustedMakeInstSat[master, sl.first] 
ELSE IF satGId=oldObId THEN --ObjectSat-- {
CDProperties.PutInstanceProp[sl.first, iGroupIdProp, newObId];
oSats _ CONS[sl.first, oSats];
}
ELSE --not a satellite-- CDProperties.PutInstanceProp[sl.first, iGroupIdProp, NIL]
ENDLOOP;

FOR i: INT IN [0..masterTable.size) DO
FOR nl: LIST OF Node _ masterTable[i], nl.rest WHILE nl#NIL DO
FOR ml: CD.InstanceList _ nl.first.list.rest, ml.rest WHILE ml#NIL DO
id: REF _ NewId[];
CDProperties.PutInstanceProp[ml.first, iGroupIdProp, id];
FOR sl: CD.InstanceList _ InternalGetSatellites[ml.first], sl.rest WHILE sl#NIL DO
CDProperties.PutInstanceProp[sl.first, iGroupIdProp, id];
ENDLOOP;
ENDLOOP;
ENDLOOP;
ENDLOOP;

InternalPutSatellites[cell, oSats];
};

GetSatelliteRopes: PUBLIC PROC [from: REF, filter: PROC [CD.Instance] RETURNS [BOOL]] RETURNS [ropes: LIST OF ROPE _ NIL] = {
FOR list: CD.InstanceList _ GetSatellites[from], list.rest WHILE list#NIL DO
IF filter=NIL OR filter[list.first] THEN {
rope: ROPE _ NARROW[list.first.ob.specificRef, CDTexts.TextPtr].text;
ropes _ CONS[rope, ropes];
}
ENDLOOP;
};

StandardFilter: PUBLIC PROC [inst: CD.Instance] RETURNS [BOOL_FALSE] = {
WITH inst.ob.specificRef SELECT FROM
tp: CDTexts.TextPtr => 
IF CD.LayerTechnology[inst.ob.layer]=NIL THEN 
RETURN [NOT IsItalic[tp.cdFont.supposedName]];
ENDCASE => NULL;
};

Associate: PUBLIC PROC [master: REF, text: CD.Instance] = {
WITH master SELECT FROM
d: CD.Design => master _ CDOpsExtras.RealTopCell[d];
ENDCASE => NULL;
IF text=NIL THEN { 
WITH master SELECT FROM
o: CD.Object => OPutGroup[o, NIL];
i: CD.Instance => IPutGroup[i, NIL];
ENDCASE => ERROR;
}
ELSE { 
id: REF _ NIL;
IF ~CDTextsExtras.IsText[text.ob] THEN ERROR;
WITH master SELECT FROM
o: CD.Object => {
id _ CDProperties.GetObjectProp[o, oGroupIdProp];
IF id=NIL THEN OPutGroup[o, id_NewId[]];
IPutGroup[text, id];
};
i: CD.Instance => IF ~CDTextsExtras.IsText[i.ob] THEN {
id _ CDProperties.GetInstanceProp[i, iGroupIdProp];
IF id=NIL THEN IPutGroup[i, id_NewId[]];
IPutGroup[text, id];
} ELSE ERROR;
ENDCASE => IF master#NIL THEN ERROR;
IPutGroup[text, id];
};
};

IsAssociated: PUBLIC PROC [any: REF, inst: CD.Instance] RETURNS [BOOL] = {
id: INT _ IGroupId[inst];
IF id=noGroup THEN RETURN [any=NIL];
RETURN [
WITH any SELECT FROM
d: CD.Design => id=OGroupId[CDOpsExtras.RealTopCell[d]],
o: CD.Object => id=OGroupId[o],
i: CD.Instance => id=IGroupId[i],
ENDCASE => FALSE
]
};

GetMaster: PUBLIC PROC [cell: REF, text: CD.Instance] RETURNS [master: REF _ NIL] = {
id: INT; world: CD.InstanceList _ NIL;
IF ~CDTextsExtras.IsText[text.ob] THEN ERROR;
[] _ GetSatellites[cell]; --enforces invariants
id _ IGroupId[text];
IF id=noGroup THEN RETURN [NIL];
WITH cell SELECT FROM
ob: CD.Object =>  {
WITH ob.specificRef SELECT FROM
cp: CD.CellPtr => world _ cp.contents;
ENDCASE => ERROR;
IF id=OGroupId[ob] THEN RETURN [ob];
};
d: CD.Design => {
ob: CD.Object ~ CDOpsExtras.RealTopCell[d];
IF id=OGroupId[ob] THEN RETURN [d];
world _ NARROW[ob.specificRef, CD.CellPtr].contents;
};
ENDCASE => NULL;
FOR w: CD.InstanceList _ world, w.rest WHILE w#NIL DO
IF id=IGroupId[w.first] AND ~CDTextsExtras.IsText[w.first.ob] THEN RETURN [w.first];
ENDLOOP;
};

OPutGroup: PROC [ob: CD.Object, x: REF] = INLINE {
CDProperties.PutObjectProp[ob, oGroupIdProp, x]
};

IPutGroup: PROC [i: CD.Instance, x: REF] = INLINE {
CDProperties.PutInstanceProp[i, iGroupIdProp, x]
};

OGroupId: PROC [ob: CD.Object] RETURNS [INT] = {
WITH CDProperties.GetObjectProp[ob, oGroupIdProp] SELECT FROM
ri: REF INT  => RETURN [ri^];
ENDCASE => RETURN [noGroup];
};

IGroupId: PROC [i: CD.Instance] RETURNS [INT_noGroup] = {
WITH CDProperties.GetInstanceProp[i, iGroupIdProp] SELECT FROM
ri: REF INT  => RETURN [ri^];
ENDCASE => NULL;
};

NewId: PROC [] RETURNS [REF] = {
IF maxGroupId=LAST[INT] THEN maxGroupId _ noGroup+1;
RETURN [NEW[INT _ maxGroupId _ maxGroupId+1]]
};

BeforeOutput: CDEvents.EventProc = {
IF design#NIL THEN CDProperties.PutProp[design, maxGroupIdProp, NEW[INT_maxGroupId]]
};

AfterInput: CDEvents.EventProc = {
[] _ CheckMaxGroupId[design];
};

Convert: PROC [design: CD.Design] = {
ConvertCell: CDDirectory.EachEntryAction = {
WITH ob.specificRef SELECT FROM
cp: CD.CellPtr => {
FOR l: CD.InstanceList _ cp.contents, l.rest WHILE l#NIL DO
IF CDTextsExtras.IsText[l.first.ob] THEN
IF CDProperties.GetProp[l.first, $CDSatellitesGroupId]=NIL THEN 
Associate[ob, l.first]
ENDLOOP;
};
ENDCASE => NULL;
};
CDProperties.PutProp[design, $CDSatellitesMaxGroupId, NIL];
[] _ CDDirectory.Enumerate[design, ConvertCell];
FOR pl: LIST OF CD.PushRec _ design^.actual, pl.rest WHILE pl#NIL DO
[] _ ConvertCell[NIL, pl.first.dummyCell.ob]
ENDLOOP
};

CheckMaxGroupId: PROC [design: CD.Design] RETURNS [BOOL_FALSE] = {
MaxGroupId: PROC [design: CD.Design] RETURNS [n: INT _ -1] = {
IF design#NIL THEN
WITH CDProperties.GetProp[design, maxGroupIdProp] SELECT FROM
i: REF INT => n _ i^;
ENDCASE => NULL; 
}; 
IF design#NIL THEN {
n: INT _ MaxGroupId[design];
IF n<LAST[INT]-10000 THEN maxGroupId _ MAX[maxGroupId, n];
IF CDProperties.GetProp[design, $CDSatellitesMaxGroupId]#NIL THEN Convert[design];
};
}; 
Member: PROC [instances: CD.InstanceList, inst: CD.Instance] RETURNS [BOOL _ FALSE] = {
WHILE instances#NIL DO 
IF instances.first=inst THEN RETURN[TRUE]; instances _ instances.rest;
ENDLOOP;
};

RectMinDist: PROC [rectA, rectB: CD.Rect] RETURNS [INT] = INLINE {
IntervalMinDist: PROC [i1min, i1max, i2min, i2max: INT] RETURNS [INT] = INLINE {
IF i1max<i2min THEN RETURN [i2min-i1max];
IF i1min>i2max THEN RETURN [i1min-i2max];
RETURN [0];
};
xMinDist: INT ~ IntervalMinDist[rectA.x1, rectA.x2, rectB.x1, rectB.x2];
yMinDist: INT ~ IntervalMinDist[rectA.y1, rectA.y2, rectB.y1, rectB.y2];
RETURN [xMinDist+yMinDist]
};

IsItalic: PROC [fontName: ROPE] RETURNS [BOOL_FALSE] = {
pressFontLeng: INT = 17; pressFontName: ROPE = "Xerox/PressFonts/";
tiogaFontLeng: INT = 17; tiogaFontName: ROPE = "Xerox/TiogaFonts/";
leng: INT _ Rope.Length[fontName];
IF leng>tiogaFontLeng THEN
IF Rope.Equal[Rope.Substr[fontName, 0, tiogaFontLeng], tiogaFontName, FALSE] THEN
RETURN [Ascii.Upper[Rope.Fetch[fontName, leng-1]]='I];
IF leng>pressFontLeng THEN
IF Rope.Equal[Rope.Substr[fontName, 0, pressFontLeng], pressFontName, FALSE] THEN 
RETURN [Ascii.Upper[Rope.Fetch[fontName, leng-2]]='I]
};

[] _ CDProperties.RegisterProperty[satellitesProp, $CDSatellites];
[] _ CDProperties.RegisterProperty[maxGroupIdProp, $CDSatellites];
[] _ CDProperties.RegisterProperty[oGroupIdProp, $CDSatellites];
[] _ CDProperties.RegisterProperty[iGroupIdProp, $CDSatellites];
CDProperties.InstallProcs[satellitesProp, [makeCopy: CDProperties.CopyVal, autoRem: TRUE]];
CDProperties.InstallProcs[maxGroupIdProp, [makeCopy: CDProperties.CopyVal]];
CDProperties.InstallProcs[oGroupIdProp, [makeCopy: CDProperties.CopyVal, autoRem: FALSE]];
CDProperties.InstallProcs[iGroupIdProp, [makeCopy: CDProperties.CopyVal, autoRem: FALSE]];
CDEvents.RegisterEventProc[$BeforeOutput, BeforeOutput];
CDEvents.RegisterEventProc[$AfterInput, AfterInput];
[] _ CDPrivate.EnumDesigns[CheckMaxGroupId];
END.

’CDSatellitesImpl.mesa 
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Written by: Christian Jacobi, August 29, 1986 9:55:02 pm PDT
This module is descended from the early implementation of satellites by Monier.  It has been
rewritten a number of times since then by Sindhu and Serlet to find an implementation that
is comfortable to use both from programs and interactively. This last version is a complete 
rewrite by Jacobi, one hopes for the last time!
Old version by: Pradeep Sindhu December 20, 1985 1:25:44 pm PST
Old version by: Pradeep Sindhu March 26, 1986 3:21:40 pm PST
Old version by: Bertrand Serlet August 17, 1986 0:49:00 am PDT
Old version by: Christian Jacobi, July 15, 1986 1:59:30 pm PDT
Old version by: Jean-Marc Frailong July 28, 1986 6:45:49 pm PDT
Last edited by: Christian Jacobi, September 4, 1986 4:15:08 pm PDT

Clients of this interface should be aware of the following set of invariants maintained for satellites, so they may avoid violating them inadvertently (the description below uses the notion of a world, which is a list of CD.Instance belonging to a cell or to the top level of the design):
The strong invariant
I1) A master must be a non-text CD.Instance with a non-nil groupIDProp.
I2) A satellite must be a text CD.Instance with a non-nil groupIDProp.
I3) Every satellite in a given world must have a corresponding master.  That is, if n is the value of its groupIDProp (its groupID), then there must be a master in world that also has n as its groupID.
I4) A world may have at most one master with a given groupID.
I5) Each master must have a satellitesProp property that points to a list instances that are the master's satellites or, if the master is an object and has no satellites, a $none property value.
The weak invariant
hold I1, hold I2, dont care about I3, hold I4, dont care about I5
The almost invariant
A4) A design may have at most one master with a given groupID.
the almost invariant helps to remember stallite assiciations when a design is edited; however, the implementation tries but does not manage to keep it reliable.

This property hangs on a master. 
Its value is the list of the master's satellites or the 
atom $none if the master is an object or a design.

This property hangs on a design. 
Its value is the highest numbered satellite group in the design.
It is valid only while the design is saved on file.
This property hangs on each instance that is in a satellite group. 
Its value is the group's groupId.  The group's groupId is read-only
and can be reused.
This property hangs on objects and designs 
Its value is the group's groupId.  The group's groupId is read-only
and can be reused..
--external, does not assume but check invariants for objects and designs
--assumes invariants for instances
Internal proc! assumes invariant
paranoid: BOOL _ CDCellsExtras.IsDummyCell[cell];

--Make masterTable and iSats; at the same time strip masters of their satellite lists
--For each satellite find its closest master and put it on that master's satellite list
accesses global master
Now go through the masterTable and renumber groups with identical group Id's

--general utilities

Returns inst is in the list of instances
Κ3–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ7™B™<K™\K™ZK™\K™/—K™?K™<K™>K™>K™?K™BIbody™LšœΓ
ΟiœX™ š
œ™LšœžBœ
™GLšœžAœ
™FLšœžΔ
œ
™Ι
Lšœž8œ
™=Lšœž½
œ
™Β
—š
œ™Lš
œA™A—™Lšœž9œ
™>—™ 
L™——šΟk	œ
˜
KšœŸœ
˜˜
—K˜•StartOfExpansion[]šΟnœŸœ
Ÿ˜KšŸœŸœw˜ˆ
KšŸœ˜—šŸœ
˜KšŸœ˜KšŸœŸœŸœ
˜K˜—š	œŸœ
ŸœŸœ
Ÿœ˜:Kš
œ!™!Kš
œ8™8Kš
œ2™2K™—šœŸœ˜(Kš
œ!™!Kš
œ@™@Kš
œ3™3—K˜šœŸœ˜*Kš
œC™CKš
œC™CK™—K˜šœŸœ˜)Kš
œ+™+Kš
œC™CKš
œ™—K˜Kšœ	Ÿœ˜KšœŸœ
˜K˜š 
œŸœ
ŸœŸœŸœŸœŸœ˜NK™HK™"šŸœŸœ
Ÿ˜KšœŸœŸœ2Οc˜TKš	œŸœŸœŸœ
Ÿœ˜VKšŸœŸœ
˜—šŸœ,Ÿœ
Ÿ˜;KšœŸœŸœ˜!KšœŸœŸœ	Ÿœ
ŸœŸœ˜(KšŸœŸœ
˜—šŸœŸœ
Ÿ˜Kš	œŸœŸœŸœ
Ÿœ˜KKšœŸœ
ŸœŸœ˜KšŸœŸœ
˜—Kš
œ˜—K˜š œŸœŸœŸœŸœŸœ˜IšŸœ)Ÿœ
Ÿ˜8KšœŸœŸœ˜'KšŸœŸœŸœ˜—K˜—K˜š
 œŸœŸœŸœŸœ˜:šŸœŸœ
Ÿ˜KšœŸœC˜HKš
Ÿœ,ŸœŸœ
ŸœŸœ˜U—K˜—K˜š œŸœŸœ	Ÿœ	ŸœŸœ˜RKšœŸœŸœŸœ˜GKšœŸœŸœ	˜šœ	ŸœŸœ˜KšœŸœ˜
KšœŸœŸœ˜—KšœŸœŸœ
˜šœ
ŸœŸœ˜Kšœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜,K˜—KšœŸœ˜'KšœŸœ˜Kšœ	Ÿœ
˜
Kšœ	Ÿœ˜K˜š œŸœŸœŸœŸœŸœ˜,KšŸœ
ŸœŸœ˜#K˜—K˜š œŸœŸœ˜)KšœŸœ˜KšœŸœ˜šŸœŸœ
Ÿœ#ŸœŸœ
Ÿ˜AKšŸœŸœŸœŸœ˜KKšŸœ
˜—KšœŸœ
ŸœŸœ˜WK˜—K˜š
 œŸœŸœŸœŸœ˜9KšœŸœ˜šŸœŸœ
Ÿœ#ŸœŸœ
Ÿ˜AKšŸœŸœ
Ÿœ˜.KšŸœ
˜—KšŸœŸœ˜
K˜—K˜š œŸœ
ŸœŸœ˜JK™ KšœŸœŸœ
˜šŸœŸœ
Ÿ˜.šœŸœ˜KšŸœŸœ
Ÿœ˜'KšœŸœ˜'Kš
Ÿ˜Kš
œ˜—KšŸœŸœ˜"—Kš
œ;˜;K˜—K˜Kšœ
Ÿœ#™1Kš
œ˜Kš
œ8˜8K™Kš
‘U™Uš	ŸœŸœŸœŸœ
Ÿ˜5šŸœŸœ
Ÿ˜'š
œ˜KšŸœŸœ	Ÿœ˜?—šŸœ˜
šŸœŸœ˜#Kš
œ˜Kšœ6Ÿœ˜;K˜
———KšŸœ
˜—K˜K™Wš	ŸœŸœŸœŸœ
Ÿ˜8š œŸœ
ŸœŸœŸœŸœ˜?K™KšœŸœ˜ Kš
ŸœŸœ
Ÿœ
ŸœŸœ˜!Kš
œ&˜&Kš
œ,˜,Kš
œ(˜(KšŸœ<˜BK˜—KšœŸœŸœ
˜KšœŸœ˜!š	ŸœŸœ-ŸœŸœ
Ÿ˜FKšŸœŸœ
Ÿœ
˜(KšŸœŸœ˜+KšŸœ
˜—KšŸœŸœ
Ÿœ
‘œ&˜DšŸœ
ŸœŸœ
‘
œ˜+Kš
œ>˜>KšœŸœ˜K˜
—KšŸœ
‘œ6Ÿœ
˜RKšŸœ
˜—K˜Kš
œL™LšŸœŸœ
ŸœŸ˜&šŸœŸœ
Ÿœ ŸœŸœ
Ÿ˜>š	ŸœŸœ,ŸœŸœ
Ÿ˜EKšœŸœ˜Kš
œ9˜9š	ŸœŸœ9ŸœŸœ
Ÿ˜RKš
œ9˜9KšŸœ
˜—KšŸœ
˜—KšŸœ
˜—KšŸœ
˜—K˜Kš
œ#˜#Kš
œ˜—K˜š œŸœ
ŸœŸœ
ŸœŸœŸœŸœŸœ	Ÿœ
Ÿœ
ŸœŸœ˜}š	ŸœŸœ/ŸœŸœ
Ÿ˜LšŸœŸœ
ŸœŸœ˜*KšœŸœŸœ2˜EKšœŸœ˜K˜
—KšŸœ
˜—Kš
œ˜—K˜š œŸœŸœŸœŸœ
Ÿœ˜HšŸœŸœ
Ÿ˜$š
œ˜šŸœ
Ÿœ Ÿœ
Ÿ˜.KšŸœŸœ#˜.——KšŸœŸœ
˜—K˜—K˜š
 	œŸœ
Ÿœ
ŸœŸœ˜;šŸœŸœ
Ÿ˜KšœŸœ/˜4KšŸœŸœ
˜—šŸœŸœ
Ÿœ
˜šŸœŸœ
Ÿ˜KšœŸœŸœ˜"KšœŸœŸœ˜$KšŸœŸœ
˜K˜
——šŸœ˜KšœŸœŸœ
˜KšŸœ Ÿœ
Ÿœ
˜-šŸœŸœ
Ÿ˜šœŸœ˜Kš
œ1˜1KšŸœŸœ
Ÿœ˜(Jš
œ˜Kš
œ˜—šœŸœ
ŸœŸœ˜7Kš
œ3˜3KšŸœŸœ
Ÿœ˜(Jš
œ˜KšœŸœ
Ÿœ
˜
—Kš
ŸœŸœŸœ
Ÿœ
Ÿœ
˜$—Jš
œ˜J˜—K˜—K˜š œŸœ
ŸœŸœŸœŸœŸœ˜JKšœŸœ˜KšŸœŸœ
ŸœŸœ˜$šŸœ˜šŸœŸœ
Ÿ˜KšœŸœ3˜8KšœŸœ˜KšœŸœ˜!KšŸœŸ˜—K˜
—K˜—K˜š 	œŸœ
ŸœŸœŸœŸœ
ŸœŸœ˜UKšœŸœ	ŸœŸœ
˜&KšŸœ Ÿœ
Ÿœ
˜-Kšœ‘˜/Kš
œ˜KšŸœŸœ
ŸœŸœ˜ šŸœŸœ
Ÿ˜šœŸœ
˜šŸœŸœ
Ÿ˜KšœŸœ ˜&KšŸœŸœ
˜—KšŸœŸœ
Ÿœ˜$K˜—šœŸœ˜Kš
œ+˜+KšŸœŸœ
Ÿœ˜#JšœŸœŸœ˜4J˜—KšŸœŸœ
˜—š	ŸœŸœŸœŸœ
Ÿ˜5KšŸœŸœ#Ÿœ
Ÿœ˜TKšŸœ
˜—Kš
œ˜—K˜š
 	œŸœŸœŸœŸœ˜2Kš
œ/˜/Kš
œ˜—K˜š
 	œŸœŸœŸœŸœ˜3Kš
œ0˜0Kš
œ˜—K˜š
 œŸœŸœ	ŸœŸœ˜0šŸœ.Ÿœ
Ÿ˜=KšœŸœ
ŸœŸœ˜KšŸœŸœ˜—Kš
œ˜—K˜š
 œŸœŸœŸœŸœ
˜9šŸœ/Ÿœ
Ÿ˜>KšœŸœ
ŸœŸœ˜KšŸœŸœ
˜—K˜—K˜š œŸœŸœŸœ˜ KšŸœŸœ
ŸœŸœ˜4KšŸœŸœ
Ÿœ˜-K˜—K˜š œ˜$Kš
ŸœŸœ
Ÿœ.Ÿœ
Ÿœ
˜TKš
œ˜—K˜š 
œ˜"Kš
œ˜Kš
œ˜—K˜š œŸœ
Ÿœ˜%š œ!˜,šŸœŸœ
Ÿ˜šœŸœ
˜š	ŸœŸœ$ŸœŸœ
Ÿ˜;šŸœ"Ÿ˜(šŸœ5Ÿœ
Ÿœ
˜@Jš
œ˜——JšŸœ
˜—J˜—JšŸœŸœ
˜—J˜—Jšœ6Ÿœ˜;Jš
œ0˜0š
ŸœŸœ
Ÿœ
Ÿœ#ŸœŸœ
Ÿ˜DKšœŸœ˜,Kš
Ÿ˜—K˜—K˜š œŸœ
Ÿœ	ŸœŸœ
Ÿœ˜Bš
 
œŸœ
Ÿœ	ŸœŸœ
˜>šŸœŸœ
Ÿ˜šŸœ.Ÿœ
Ÿ˜=KšœŸœ
Ÿœ˜KšŸœŸœ˜——K˜—šŸœŸœ
Ÿœ˜KšœŸœ˜Kš
ŸœŸœ
ŸœŸœŸœ˜:KšŸœ7Ÿœ
Ÿœ˜RK˜—Kš
œ˜—K™Kš
œ™K™š œŸœ
ŸœŸœŸœŸœŸœ˜WKš
œ(™(šŸœŸœ
Ÿœ
˜KšŸœŸœ
Ÿœ
Ÿœ˜FKšŸœ
˜—Kš
œ˜K˜—š œŸœŸœŸœŸœŸœ˜Bš œŸœŸœŸœŸœŸœ˜PKšŸœ
Ÿœ
Ÿœ˜)KšŸœ
Ÿœ
Ÿœ˜)KšŸœ˜K˜—Kšœ
Ÿœ;˜HKšœ
Ÿœ;˜HKšŸœ˜K˜—K˜š œŸœŸœŸœŸœ
Ÿœ˜8KšœŸœŸœ˜CKšœŸœŸœ˜CKšœŸœ˜"šŸœŸ˜šŸœDŸœŸ˜QKšŸœ0˜6——šŸœŸ˜šŸœDŸœŸœ
˜RKšŸœ/˜5——K˜—K˜Kš
œB˜BKš
œB˜BKš
œ@˜@Kš
œ@˜@KšœTŸœ˜[Kš
œL˜LKšœRŸœ˜ZKšœRŸœ˜ZKš
œ8˜8Kš
œ4˜4Kš
œ,˜,KšŸœ
˜K˜—…—,JΕ