DIRECTORY
RTSets,
SC,
SCInstUtil,
SCNetUtil,
SCPlaceUtil,
SCPrivate,
SCRowUtil,
Rope,
TerminalIO;

SCPlaceUtilImpl: CEDAR PROGRAM
IMPORTS Rope, RTSets, SC, SCInstUtil, SCNetUtil, SCPlaceUtil, SCRowUtil, TerminalIO
EXPORTS SCPlaceUtil
SHARES SC =

BEGIN
ExchInsts: PUBLIC PROCEDURE[handle: SC.Handle, instance1, instance2: SCPrivate.Instance] = {
IF Compatable[instance1, instance2] THEN {
SELECT instance1.whichClass FROM
logic, ft => {
i2Row: SCPrivate.MaxRowSr;
i2Pos: SCPrivate.MaxPosSr;
i2Orien: SCPrivate.OrientationOrNone;
i1Row: SCPrivate.MaxRowSr _ instance1.curRow;
i1Pos: SCPrivate.MaxPosSr _ instance1.curPos;
i1Orien: SCPrivate.OrientationOrNone _ instance1.curOrien;
SCPlaceUtil.RemvLgComp[handle, instance1];
i2Row _ instance2.curRow;
i2Pos _ instance2.curPos;
i2Orien _ instance2.curOrien;
SCPlaceUtil.RemvLgComp[handle, instance2];
SCPlaceUtil.PutLgPos[handle, instance1, i2Row, i2Pos, i2Orien, TRUE];
SCPlaceUtil.PutLgPos[handle, instance2, i1Row, i1Pos, i1Orien, TRUE]};
io => {
i2Side: SC.Side;
i2Pos: SCPrivate.MaxPosSr;
i1Side: SC.Side _ instance1.curSide;
i1Pos: SCPrivate.MaxPosSr _ instance1.curPos;
SCPlaceUtil.RemvBpComp[handle, instance1];
i2Side _ instance2.curSide;
i2Pos _ instance2.curPos;
SCPlaceUtil.RemvBpComp[handle, instance2];
SCPlaceUtil.PutBpPos[handle, instance1, i2Side, i2Pos, 0, TRUE];
SCPlaceUtil.PutBpPos[handle, instance2, i1Side, i1Pos, 0, TRUE];
};
ENDCASE}
ELSE SC.Error[programmingError, NIL]};

Compatable: PROCEDURE[instance1, instance2: SCPrivate.Instance] RETURNS [compat: BOOLEAN] = {
compat _ IF instance1.whichClass = io THEN instance2.whichClass = io
ELSE IF instance1.whichClass = logic OR instance1.whichClass = ft THEN
instance2.whichClass = logic OR instance2.whichClass = ft
ELSE FALSE};

ReverseOrientation: PUBLIC PROCEDURE[instance: SCPrivate.Instance] = {

scOrien: SCPrivate.OrientationOrNone _ instance.curOrien;
SELECT instance.curOrien FROM
0 => instance.curOrien _ 0;
1 => instance.curOrien _ 5;
2 => instance.curOrien _ 8;
3 => instance.curOrien _ 6;
4 => instance.curOrien _ 7;
5 => instance.curOrien _ 1;
6 => instance.curOrien _ 3;
7 => instance.curOrien _ 4;
8 => instance.curOrien _ 2;
ENDCASE};
PutLgRow: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, row: SCPrivate.MaxRowSr, orien: SCPrivate.OrientationOrNone _ 0] = 

BEGIN
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance.curRow _ row;
instance.curPos _ lgRow.nLgsOnRow;
lgRow.size.p _ lgRow.size.p + SCInstUtil.InstWidth[instance];
lgRow.size.q _ MAX[lgRow.size.q, SCInstUtil.InstWidth[instance]];
lgRow.nLgsOnRow _ lgRow.nLgsOnRow +1;
lgRow.lgsOnRow[lgRow.nLgsOnRow] _ instance;

IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltLgOrien;

IF instance.whichClass = ft THEN
{net: SCPrivate.Net _ instance.ftNet;
lgRow.nFtsOnRow _ lgRow.nFtsOnRow +1;
net.ftsOnRow _ RTSets.RTMdSetUnion[net.ftsOnRow, 
RTSets.RTMdSetGenerateElement[(row)-1]]};
END;

PutLgPos: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, row: SCPrivate.MaxRowSr, pos: SCPrivate.MaxPosSr, orien: SCPrivate.OrientationOrNone _ 0, updateOffsets: BOOLEAN] = {

EachInst:  SCRowUtil.EachInstProc = {
lgRow.lgsOnRow[pos+1] _ instance;
SELECT instance.whichClass FROM
ft, logic => instance.curPos _ pos+1;
ENDCASE}; 

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance.curRow _ row;
instance.curPos _ pos;
lgRow.size.p _ lgRow.size.p + SCInstUtil.InstWidth[instance];
lgRow.size.q _ MAX[lgRow.size.q, SCInstUtil.InstWidth[instance]];
IF 1 > pos OR pos > lgRow.nLgsOnRow+1 THEN 
SC.Error[programmingError, "pos must be in range 1 .. lgRow.nLgsOnRow"];

IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltLgOrien;

[] _ SCRowUtil.EnumerateInstsOnRowDecreasing[handle, row, pos, lgRow.nLgsOnRow, EachInst];
lgRow.lgsOnRow[pos] _ instance;

IF instance.whichClass = ft THEN
{net: SCPrivate.Net _ instance.ftNet;
lgRow.nFtsOnRow _ lgRow.nFtsOnRow +1;
net.ftsOnRow _ RTSets.RTMdSetUnion[net.ftsOnRow, 
RTSets.RTMdSetGenerateElement[(row)-1]]};

lgRow.nLgsOnRow _ lgRow.nLgsOnRow +1;
IF updateOffsets THEN SCInstUtil.LgOffsets[handle, row, pos, SCPrivate.maxPos]};

ExchPosRow: PUBLIC PROCEDURE[handle: SC.Handle, index1, index2: SCPrivate.MaxPosSr, row: SCPrivate.MaxRowSr] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance1: SCPrivate.Instance _ lgRow.lgsOnRow[index1];
instance2: SCPrivate.Instance _ lgRow.lgsOnRow[index2];
lgRow.lgsOnRow[index1] _ instance2;
lgRow.lgsOnRow[index2] _ instance1;

SELECT instance1.whichClass FROM
ft, logic => instance1.curPos _ index2;
ENDCASE;

SELECT instance2.whichClass FROM
ft, logic => instance2.curPos _ index1;
ENDCASE;

SCInstUtil.LgOffsets[handle, row, index1, index2]};

RemvLgComp: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance] = {

EachInst: SCRowUtil.EachInstProc = {
lgRow.lgsOnRow[pos-1] _ instance;
SELECT instance.whichClass FROM
ft, logic => instance.curPos _ pos-1;
ENDCASE};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
lgRow: SCPrivate.LgRow;
row: SCPrivate.MaxRowSr;
pos: SCPrivate.MaxPosSr;
widthOfComp: SC.Number _ SCInstUtil.InstWidth[instance];
heightOfComp: SC.Number _ SCInstUtil.InstHeight[instance];

SELECT instance.whichClass FROM
ft, logic => {
row _ instance.curRow; pos _ instance.curPos;
instance.curPos _ 0; instance.curRow _ 0; instance.curOrien _ 0};
ENDCASE;

lgRow _ layoutData.lgRows.rows[row];
lgRow.size.p _ lgRow.size.p - widthOfComp;
IF heightOfComp >= lgRow.size.q THEN lgRow.dimInvalid _ TRUE;
IF lgRow.lgsOnRow[pos] # instance THEN SC.Error[programmingError, "Invalid row"];

[] _ SCRowUtil.EnumerateInstsOnRow[handle, row, pos + 1, lgRow.nLgsOnRow, EachInst];

lgRow.nLgsOnRow _ lgRow.nLgsOnRow -1;
IF instance.whichClass = ft THEN {
DeleteFt: SCInstUtil.EachInstanceProc = {
newNum: SCPrivate.MaxInstanceSr _ instance.num-1;
structureData.instances.inst[newNum] _ instance;
instance.num _ newNum;
instance.ftNet _ NIL;
instance.object _ NIL;
structureData.instances.count _ structureData.instances.count -1;
structureData.instances.numFts _ structureData.instances.numFts -1;
SCNetUtil.RemoveConnections[handle, instance]};

net: SCPrivate.Net _ instance.ftNet;
IF lgRow.nFtsOnRow <= 0 THEN SC.Error[programmingError, "Invalid row"];
lgRow.nFtsOnRow _ lgRow.nFtsOnRow - 1;
net.ftsOnRow _ RTSets.RTMdSetDifference[net.ftsOnRow, RTSets.RTMdSetGenerateElement[row-1]];
[] _ SCInstUtil.EnumerateInstances[handle, instance.num+1, structureData.instances.count, DeleteFt]}};
PutBpSide: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, side: SC.SideOrNone, orien: SCPrivate.OrientationOrNone _ 0] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
instance.curSide _ side;
instance.curPos _ bpRow.nBpsOnSide;
bpRow.size.p _ bpRow.size.p + SCInstUtil.BpWidth[instance];
bpRow.size.q _ MAX[bpRow.size.q, SCInstUtil.BpHeight[instance]];
bpRow.nBpsOnSide _ bpRow.nBpsOnSide +1;
bpRow.bpsOnSide[bpRow.nBpsOnSide] _ instance;
IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltBpOrien[side]};

PutBpPos: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, side: SC.Side, pos: SCPrivate.MaxPosSr, orien: SCPrivate.OrientationOrNone _ 0, updateOffsets: BOOLEAN _ TRUE] = {

EachInst:  SCRowUtil.EachInstProc = {
bpRow.bpsOnSide[pos+1] _ instance;
instance.curPos _ pos+1};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];

instance.curSide _ side;
instance.curPos _ pos;
bpRow.size.p _ bpRow.size.p + SCInstUtil.BpWidth[instance];
bpRow.size.q _ MAX[bpRow.size.q, SCInstUtil.BpHeight[instance]];
[] _ SCRowUtil.EnumerateInstsOnSideDecreasing[handle, side, pos, bpRow.nBpsOnSide, EachInst];
bpRow.nBpsOnSide _ bpRow.nBpsOnSide + 1;
bpRow.bpsOnSide[pos] _ instance;
IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltBpOrien[side];
IF updateOffsets THEN SCInstUtil.BpOffsets[handle, side, pos, SCPrivate.maxPos]};

ExchPosSide: PUBLIC PROCEDURE[handle: SC.Handle, index1, index2: SCPrivate.MaxPosSr, side: SC.Side] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
instance1: SCPrivate.Instance _ bpRow.bpsOnSide[index1];
instance2: SCPrivate.Instance _ bpRow.bpsOnSide[index2];
bpRow.bpsOnSide[index1] _ instance2;
bpRow.bpsOnSide[index2] _ instance1;
instance1.curPos _ index2;
instance2.curPos _ index1;
SCInstUtil.BpOffsets[handle, side, index1, index2]};

RemvBpComp: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance] = {

side: SC.SideOrNone;
pos: SCPrivate.MaxPosSr;
bpRow: SCPrivate.BpRow;
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
widthOfComp: SC.Number _ SCInstUtil.BpWidth[instance];
heightOfComp: SC.Number _ SCInstUtil.BpHeight[instance];

EachInst:  SCRowUtil.EachInstProc = {
bpRow.bpsOnSide[pos-1] _ instance;
instance.curPos _ pos-1};

IF instance.whichClass # io THEN SC.Error[programmingError, Rope.Cat["invalid instance: ", instance.name]];
IF instance.curSide = none THEN  SC.Error[programmingError, Rope.Cat["invalid side for instance", instance.name]];

side _ instance.curSide;
pos _ instance.curPos;

instance.curPos _ 0;
instance.curSide _ none;
instance.curOrien _ 0;
bpRow _ layoutData.bpRows[side];
bpRow.size.p _ bpRow.size.p - widthOfComp;

IF bpRow.nBpsOnSide <= 0 THEN SC.Error[programmingError, "invalid side"];
IF bpRow.bpsOnSide[pos] # instance THEN SC.Error[programmingError, Rope.Cat["instance: ", instance.name, " not in specified position"]];

IF heightOfComp >= bpRow.size.q THEN bpRow.dimInvalid _ TRUE;
[] _ SCRowUtil.EnumerateInstsOnSide[handle, side, pos + 1, bpRow.nBpsOnSide, EachInst];
bpRow.bpsOnSide[bpRow.nBpsOnSide] _ NIL;
bpRow.nBpsOnSide _ bpRow.nBpsOnSide -1};

WriteCurPlace: PUBLIC PROCEDURE [handle: SC.Handle] = {

EachInst: SCInstUtil.EachInstanceProc = {
TerminalIO.WriteRope[Rope.Cat[" instance: ", instance.name, ", object: ", instance.object.name]];
SELECT instance.whichClass FROM
ft, logic => {TerminalIO.WriteRope[", logic row: "]; TerminalIO.WriteInt[instance.curRow]}; 
io => {TerminalIO.WriteRope[Rope.Cat[", IO side: ", SCRowUtil.sideName[instance.curSide]]]}; 
ENDCASE;
TerminalIO.WriteRope[", pos: "]; TerminalIO.WriteInt[instance.curPos];
TerminalIO.WriteLn[]};

[] _ SCInstUtil.EnumerateAllInstances[handle, EachInst]};

ClrCurPlac: PUBLIC PROCEDURE[handle: SC.Handle, initPrePlace: BOOLEAN] = {

EachInst: SCInstUtil.EachInstanceProc = {
SELECT instance.whichClass FROM
logic, ft =>
{IF instance.curRow > 0 THEN RemvLgComp[handle, instance];
instance.curRow _ 0; instance.curPos _ 0; instance.curOrien _ 0;
IF initPrePlace THEN
{instance.preRow _ 0; instance.prePos _ 0; instance.preOrien _ 0}};

io =>
{IF instance.curSide > none THEN RemvBpComp[handle, instance];
instance.curSide _ none; instance.curPos _ 0; instance.curOrien _ 0;
IF initPrePlace THEN
{instance.preSide _ none; instance.prePos _ 0; instance.preOrien _ 0}};

ENDCASE};

[] _ SCInstUtil.EnumerateAllInstances[handle, EachInst]};

CheckPlace: PUBLIC PROCEDURE[handle: SC.Handle] = {

EachRow: SCRowUtil.EachRowProc = {
EachInst: SCRowUtil.EachInstProc = {
IF instance.curRow # row OR instance.curPos # pos THEN
SC.Error[programmingError, "Invalid row or position for instance"]};
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, row, EachInst]};

[] _ SCRowUtil.EnumerateRows[handle, EachRow]};

END.
ffile ///StdCell/SCPlaceUtilImpl.mesa
placement utility routines
-- ExchInsts - exchange two like instances
-- ReverseOrientation - reverse orientation of an instance
-- PutLgRow - put component in row and position
-- ExchPosRow - exchange components in positions index1 and index2
-- RemvLgComp - remove a logic instance from current placement
-- PutBpSide - add a bp instance to a side
-- PutBpPos - 
-- ExchPosSide - exchange components in positions index1 and index2
-- RemvBpComp - remove a bp instance from current placement
-- WriteCurPlace - write the current placement
-- ClrCurPlac - clear the current placement
-- CheckPlace -- check the placement consistancy

exchange two like instances
SCInstUtil.CheckBpOffsets[handle, i1Side];
IF i1Side # i2Side THEN SCInstUtil.CheckBpOffsets[handle, i2Side]
reverse the orientation of an instance 

add a logic instance to a row 
putlgpos add a lg instance to a row in a position 
exchange components in positions index1 and index2 
now modify instance data 
remove a logic instance from current placement 
remove instance from row 

add a bp instance to a side 
add a bp instance to a side in a position
exchange components in positions index1 and index2 
remove a bp instance from current placement 
remove instance from side 
clear the current placement in preparation for reinitialization 
check the placement consistancy
Κ-˜Jš
œ$™$J˜Jš
œ™JšœΟn	œ™*Jšœœ%™:Jšœœ$™/Jšœ
œ5™BJšœ
œ1™>Jšœ	œ™*Jšœœ™Jšœœ5™CJšœ
œ.™;Jšœ
œ™.Jšœ
œ™+Jšœ
œ#™0J˜š
Οk	˜	Jš
œ˜Jšžœ
˜Jš
œ˜J˜
Jš
œ˜J˜
J˜
Jš
œ˜Jš
œ˜J˜—šœžœ
ž˜Jšžœžœ;˜SJšžœ˜Jšžœ
žœ˜J˜Jš
ž˜J™Jš
œ™š	œžœ
ž	œ	žœ6˜\šžœ"žœ˜*šžœž˜ ˜Jš
œ˜Jš
œ˜Jš
œ%˜%Jš
œ-˜-Jš
œ-˜-Jš
œ:˜:Jš
œ*˜*Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ*˜*Jšœ?žœ˜EJšœ?žœ˜F—˜Jšœžœ˜Jš
œ˜Jšœžœ˜$Jš
œ-˜-Jš
œ*˜*Jš
œ˜Jš
œ˜Jš
œ*˜*Jšœ:žœ˜@Jšœ:žœ˜@Jš
œ*™*Jš
œA™AJš
œ˜—Jšžœ
˜—Jšžœ
žœžœ˜&J˜——š
œž	œ+žœ
žœ˜]Jšœžœžœ˜Dšžœ
žœžœž˜FJšœžœ˜9—Icodešžœ
žœ˜J˜—šœžœ
ž	œ"˜FJš
œ'™'J˜Jš
œ9˜9šžœž˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšžœ
˜	——J™Jš
œ™šœžœ
ž	œ	žœj˜
J˜Jš
ž˜Jšœ#žœ˜=Jš
œ5˜5Jš
œ˜Jš
œ"˜"Jš
œ=˜=Jšœžœ/˜AJš
œ%˜%Jš
œ+˜+J˜Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ-˜1J˜šžœž˜ Jš
œ%˜%Jš
œ%˜%š
œ1˜1Jš
œ)˜)——Jšžœ
˜J˜—šœžœ
ž	œ	žœœ
˜Α
Jš
œ2™2J˜šœ˜%Jš
œ!˜!šžœž˜Jš
œ%˜%Jšžœ˜
—J˜—Jšœ#žœ˜=Jš
œ5˜5Jš
œ˜Jš
œ˜Jš
œ=˜=Jšœžœ/˜Ašžœ	žœžœ
˜+JšžœF˜H—J˜Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ-˜1J˜Jš
œZ˜ZJš
œ˜J˜šžœž˜ Jš
œ%˜%Jš
œ%˜%š
œ1˜1Jš
œ)˜)—J˜—Jš
œ%˜%Jš
œP˜PJ˜—Jš
œ3™3š
œžœ
ž	œ	žœI˜pJ˜Jšœ#žœ˜=Jš
œ5˜5Jš
œ7˜7Jš
œ7˜7Jš
œ#˜#Jš
œ#˜#J˜Jš
œ™šžœž˜ Jš
œ'˜'Jšžœ
˜—J˜šžœž˜ Jš
œ'˜'Jšžœ
˜—J˜Jš
œ3˜3J˜—Jš
œ/™/š
œžœ
ž	œ	žœ*˜QJ˜Jš
œ™šœ˜$Jš
œ!˜!šžœž˜Jš
œ%˜%Jšžœ˜	—J˜—Jšœ#žœ˜=Jšœ)žœ˜FJš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ)˜8Jšœžœ*˜:J˜šžœž˜š
œ˜Jš
œ-˜-Jš
œA˜A—šžœ
˜J˜——Jš
œ$˜$Jš
œ*˜*Jšžœžœžœ
˜=Jšžœ žœ
žœ(˜QJ˜Jš
œT˜TJ˜Jš
œ%˜%šžœžœ˜"šœ!˜)Jš
œ1˜1Jš
œ0˜0Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jš
œA˜AJš
œC˜CJš
œ/˜/J˜—Jš
œ$˜$Jšžœžœ
žœ(˜GJš
œ&˜&Jš
œ\˜\Jš
œf˜f—J™—Jš
œ™š
	œžœ
ž	œ	žœ-žœ8˜
J˜Jšœ#žœ˜=Jš
œ1˜1Jš
œ˜Jš
œ#˜#Jš
œ;˜;Jšœžœ.˜@Jš
œ'˜'Jš
œ-˜-Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ5˜9—š
œžœ
ž	œ	žœ-žœj˜Ύ
J˜Jš
œ)™)šœ˜%Jš
œ"˜"Jš
œ˜J˜—Jšœ#žœ˜=Jš
œ1˜1J˜Jš
œ˜Jš
œ˜Jš
œ;˜;Jšœžœ.˜@Jš
œ]˜]Jš
œ(˜(Jš
œ ˜ Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ3˜7Jš
œQ˜QJ˜—Jš
œ3™3š
œžœ
ž	œ	žœ3žœ
˜gJ˜Jšœ#žœ˜=Jš
œ1˜1Jš
œ8˜8Jš
œ8˜8Jš
œ$˜$Jš
œ$˜$Jš
œ˜Jš
œ˜Jš
œ5˜5—Jš
œ,™,š
œžœ
ž	œ	žœ*˜QJ˜Jšœžœ˜Jš
œ˜Jš
œ˜Jšœ#žœ˜=Jšœ
žœ'˜6Jšœžœ(˜8J˜šœ˜%Jš
œ"˜"Jš
œ˜J˜—Jšžœžœ
žœH˜kšžœžœ
žœO˜rJ˜—Jš
œ˜J˜J˜J˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ*˜*J˜Jšžœžœ)˜IJšžœ!žœ^˜ˆ
—˜Jš
œ™Jšžœžœžœ
˜=Jš
œW˜WJš
œ(˜(Jš
œ(˜(J˜—š
œžœ
ž	œ
žœ˜7J˜šœ!˜)Jš
œa˜ašžœž˜Jš
œ\˜\Jš
œ]˜]Jšžœ
˜—Jš
œF˜FJš
œ˜J˜—Jš
œ9˜9J˜—Jš
œ@™@š

œžœ
ž	œ	žœžœ˜JJ˜šœ!˜)šžœž˜š
œ˜Jšœ
žœžœ˜:Jš
œ@˜@šžœž˜Jš
œC˜C——J˜š
œ˜Jšœ
žœžœ˜>Jš
œD˜Dšžœž˜Jš
œG˜G—J˜—Jšžœ˜	—J˜—Jš
œ9˜9—J˜š
œžœ
ž	œ	žœ˜3J™J˜šœ˜"šœ˜$šžœžœž˜6JšžœB˜D——Jš
œ>˜>J˜—Jš
œ/˜/—J˜Jšžœ
˜——…—0ψB‹