DIRECTORY 
Ascii, CD, CDCells, CDDirectory, CDEvents, CDInstances, CDOps, CDPrivate, CDProperties, CDSatellites, CDTexts, Rope;

CDSatellitesImpl: CEDAR MONITOR
IMPORTS Ascii, CD, CDCells, CDDirectory, CDEvents, CDInstances, CDOps, CDPrivate, CDProperties, CDTexts, 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[CDOps.RealTopCell[d]]]; --not cached
ob: CD.Object => IF CDCells.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: ENTRY PROC [cell: CD.Object] RETURNS [oSats: CD.InstanceList_NIL] = {
ENABLE UNWIND => NULL;
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 _ INewId[];

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 CDInstances.Member[satellite, sats] THEN ERROR; 
sats.rest _ CONS[satellite, sats.rest];
RETURN
};
ENDCASE => sats _ LIST[satellite];
CDProperties.PutInstanceProp[master, satellitesProp, sats];
};

EachInst: CDCells.InstEnumerator = {
WITH inst.ob.specific SELECT FROM
tp: CDTexts.TextSpecific => 
IF IGroupId[inst]#noGroup THEN iSats _ CONS[inst, iSats];
ENDCASE =>
IF IGroupId[inst]#noGroup THEN {
StoreMaster[inst];
CDProperties.PutInstanceProp[inst, satellitesProp, NIL];
}
};
oldObId _ OGroupId[cell];
CDProperties.PutObjectProp[cell, oGroupIdProp, newObId];
[] _ CDCells.EnumerateInstances[cell, EachInst];

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 _ INewId[];
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.specific, CDTexts.TextSpecific].text;
ropes _ CONS[rope, ropes];
}
ENDLOOP;
};

StandardFilter: PUBLIC PROC [inst: CD.Instance] RETURNS [BOOL_FALSE] = {
WITH inst.ob.specific SELECT FROM
tp: CDTexts.TextSpecific => 
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 _ CDOps.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 ~CDTexts.IsText[text.ob] THEN ERROR;
WITH master SELECT FROM
o: CD.Object => {
id _ CDProperties.GetObjectProp[o, oGroupIdProp];
IF id=NIL THEN OPutGroup[o, id_XNewId[]];
IPutGroup[text, id];
};
i: CD.Instance => IF ~CDTexts.IsText[i.ob] THEN {
id _ CDProperties.GetInstanceProp[i, iGroupIdProp];
IF id=NIL THEN IPutGroup[i, id_XNewId[]];
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[CDOps.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; 
CheckInst: CDCells.InstEnumerator = {
IF id=IGroupId[inst] AND ~CDTexts.IsText[inst.ob] THEN {
master _ inst; quit_TRUE
};
};
IF ~CDTexts.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 =>  {
IF ~CDCells.IsCell[ob] THEN ERROR;
IF id=OGroupId[ob] THEN RETURN [ob];
[] _ CDCells.EnumerateInstances[ob, CheckInst];
};
d: CD.Design => {
ob: CD.Object _ CDOps.RealTopCell[d];
IF id=OGroupId[ob] THEN RETURN [d];
[] _ CDCells.EnumerateInstances[ob, CheckInst];
};
ENDCASE => NULL;
};

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;
};

XNewId: ENTRY PROC [] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN [INewId[]];
};

INewId: INTERNAL 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 = {
IF CDCells.IsCell[ob] THEN {
DoInst: CDCells.InstEnumerator = {
IF CDTexts.IsText[inst.ob] THEN
IF CDProperties.GetProp[inst, $CDSatellitesGroupId]=NIL THEN 
Associate[ob, inst]
};
[] _ CDCells.EnumerateInstances[ob, DoInst];
};
};
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];
};
}; 
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.


HCDSatellitesImpl.mesa 
Copyright c 1985, 1986, 1987 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, June 2, 1987 6:09:49 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
--This is exagerated locking...
--   We could have a list of currently active objects and wait until our object is  
--   removed from this list; however, that might be exagerated coding in our nearly
--   sequential DA world
Internal proc! assumes invariant

paranoid: BOOL _ CDCells.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

Κέ–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ=™H™<K™\K™ZK™\K™/—Kš
Οy?™?Kš
ž<™<Kš
ž>™>Kš
ž>™>Kš
ž?™?K™=Ibody™LšœΓ
ΟiœX™ š
œ™LšœŸBœ
™GLšœŸAœ
™FLšœŸΔ
œ
™Ι
LšœŸ8œ
™=LšœŸ½
œ
™Β
—š
œ™Lš
œA™A—™LšœŸ9œ
™>—™ 
L™——šΟk	œ
˜
Kšœ œk˜t—K˜•StartOfExpansion[]šΟnœ œ
 ˜Kš œ œ\˜mKš œ˜—š œ
˜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šœ œ œ,Οc˜NKš	œ œ œ œ
 œ˜PKš œ œ
˜—š œ, œ
 ˜;Kšœ œ œ˜!Kšœ œ œ	 œ
 œ œ˜(Kš œ œ
˜—š œ œ
 ˜Kš	œ œ œ œ
 œ˜KKšœ œ
 œ œ˜Kš œ œ
˜—Kš
œ˜—K˜š‘œ œ œ œ œ œ˜Iš œ) œ
 ˜8Kšœ œ œ˜'Kš œ œ œ˜—K˜—K˜š
‘œ œ œ œ œ˜:š œ œ
 ˜Kšœ œC˜HKš
 œ, œ œ
 œ œ˜U—K˜—K˜š‘œ œ
 œ œ	 œ	 œ œ˜XK™K™TK™SK™Kš œ
 œ œ
˜Kšœ œ œ	˜šœ	 œ œ˜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š œ% œ
 œ˜3Kšœ œ˜'Kš
 ˜Kš
œ˜—Kš œ œ˜"—Kš
œ;˜;K˜—K˜š‘œ˜$š œ œ
 ˜!š
œ˜Kš œ œ	 œ˜9—š œ˜
š œ œ˜ Kš
œ˜Kšœ3 œ˜8K˜
———K˜—K™Kšœ
 œ™+Kš
œ˜Kš
œ8˜8K™Kš
’U™UKš
œ0˜0K˜Kš
’W™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šœ œ œ4˜GKšœ œ˜K˜
—Kš œ
˜—Kš
œ˜—K˜š‘œ œ œ œ œ
 œ˜Hš œ œ
 ˜!š
œ˜š œ
 œ  œ
 ˜.Kš œ œ#˜.——Kš œ œ
˜—K˜—K˜š
‘	œ œ
 œ
 œ œ˜;š œ œ
 ˜Kšœ œ)˜.Kš œ œ
˜—š œ œ
 œ
˜š œ œ
 ˜Kšœ œ œ˜"Kšœ œ œ˜$Kš œ œ
˜K˜
——š œ˜Kšœ œ œ
˜Kš œ œ
 œ
˜'š œ œ
 ˜šœ œ˜Kš
œ1˜1Kš œ œ
 œ˜)Jš
œ˜Kš
œ˜—šœ œ
 œ œ˜1Kš
œ3˜3Kš œ œ
 œ˜)Jš
œ˜Kšœ œ
 œ
˜
—Kš
 œ œ œ
 œ
 œ
˜$—Jš
œ˜J˜—K˜—K˜š‘œ œ
 œ œ œ œ œ˜JKšœ œ˜Kš œ œ
 œ œ˜$š œ˜š œ œ
 ˜Kšœ œ-˜2Kšœ œ˜Kšœ œ˜!Kš œ ˜—K˜
—K˜—K˜š‘	œ œ
 œ œ œ œ
 œ œ˜UKšœ œ˜	š‘	œ˜%š œ œ œ˜8Kšœ ˜Kš
œ˜—K˜—Kš œ œ
 œ
˜'Kšœ’˜/Kš
œ˜Kš œ œ
 œ œ˜ š œ œ
 ˜šœ œ
˜Kš œ œ
 œ
˜"Kš œ œ
 œ˜$Kš
œ/˜/K˜—šœ œ˜Kšœ œ˜%Kš œ œ
 œ˜#Kš
œ/˜/J˜—Kš œ œ
˜—Kš
œ˜—K˜š
‘	œ œ œ œ œ˜2Kš
œ/˜/Kš
œ˜—K˜š
‘	œ œ œ œ œ˜3Kš
œ0˜0Kš
œ˜—K˜š
‘œ œ œ	 œ œ˜0š œ. œ
 ˜=Kšœ œ
 œ œ˜Kš œ œ˜—Kš
œ˜—K˜š
‘œ œ œ œ œ
˜9š œ/ œ
 ˜>Kšœ œ
 œ œ˜Kš œ œ
˜—K˜—K˜š
‘œ œ
 œ œ œ˜'Jš œ
 œ œ
˜Jš œ˜K˜—K˜š‘œ 
œ œ œ˜*Kš œ œ
 œ œ˜4Kš œ œ
 œ˜-K˜—K˜š‘œ˜$Kš
 œ œ
 œ. œ
 œ
˜TKš
œ˜—K˜š‘
œ˜"Kš
œ˜Kš
œ˜—K˜š‘œ œ
 œ˜%š‘œ!˜,š œ œ˜š‘œ˜"š œ ˜š œ2 œ
 œ
˜=Jš
œ˜——K˜—Kš
œ,˜,Kš
œ˜—J˜—Jšœ6 œ˜;Jš
œ0˜0š
 œ œ
 œ
 œ# œ œ
 ˜DKšœ œ˜,Kš
 ˜—K˜—K˜š‘œ œ
 œ	 œ œ
 œ˜Bš
‘
œ œ
 œ	 œ œ
˜>š œ œ
 ˜š œ. œ
 ˜=Kšœ œ
 œ˜Kš œ œ˜——K˜—š œ œ
 œ˜Kšœ œ˜Kš
 œ œ
 œ œ œ˜:Kš œ7 œ
 œ˜RK˜—Kš
œ˜—K™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˜—…—*ΊIί