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

SCPlaceUtilImpl: CEDAR PROGRAM
IMPORTS IO, 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 _ instance2.curRow;
i1Row: SCPrivate.MaxRowSr _ instance1.curRow;
i1Pos: SCPrivate.MaxPosSr _ instance1.curPos;
IF i1Row = i2Row THEN ExchPosRow[handle, i1Pos, instance2.curPos, i1Row]
ELSE {
i1Orien: SCPrivate.OrientationOrNone _ instance1.curOrien;
i2Pos: SCPrivate.MaxPosSr;
i2Orien: SCPrivate.OrientationOrNone;
SCPlaceUtil.RemvLgComp[handle, instance1, FALSE];
i2Pos _ instance2.curPos;
i2Orien _ instance2.curOrien;
SCPlaceUtil.RemvLgComp[handle, instance2, FALSE];
SCPlaceUtil.PutLgPos[handle, instance1, i2Row, i2Pos, i2Orien, TRUE];
SCPlaceUtil.PutLgPos[handle, instance2, i1Row, i1Pos, i1Orien, TRUE]};
-- CheckPlace[handle];
};
io => {
i2Side: SC.Side _ instance2.curSide;
i1Side: SC.Side _ instance1.curSide;
i1Pos: SCPrivate.MaxPosSr _ instance1.curPos;
IF i1Side = i2Side THEN ExchPosSide[handle, i1Pos, instance2.curPos, i1Side]
ELSE {
i2Pos: SCPrivate.MaxPosSr;
SCPlaceUtil.RemvBpComp[handle, instance1, FALSE];
i2Pos _ instance2.curPos;
SCPlaceUtil.RemvBpComp[handle, instance2, FALSE];
SCPlaceUtil.PutBpPos[handle, instance1, i2Side, i2Pos, SCInstUtil.defltBpOrien[i2Side], TRUE];
SCPlaceUtil.PutBpPos[handle, instance2, i1Side, i1Pos, SCInstUtil.defltBpOrien[i1Side], TRUE]};
-- SCInstUtil.CheckBpOffsets[handle, i1Side];
-- IF i1Side # i2Side THEN SCInstUtil.CheckBpOffsets[handle, i2Side]
};
ENDCASE}
ELSE SC.Error[programmingError, "Not suppose to happen."]};

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, 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];
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 updateOffsets THEN SCInstUtil.LgOffsets[handle, row, pos, SCPrivate.maxPos];

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, updateOffsets: BOOLEAN] = {

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;
IF updateOffsets THEN SCInstUtil.BpOffsets[handle, side, pos, SCPrivate.maxPos]};

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

EachInst: SCInstUtil.EachInstanceProc = {
TerminalIO.PutRope[Rope.Cat[" instance: ", instance.name, ", object: ", instance.object.name]];
SELECT instance.whichClass FROM
ft, logic => {TerminalIO.PutF1[", logic row: %g", IO.int[instance.curRow]]}; 
io => {TerminalIO.PutRope[Rope.Cat[", IO side: ", SCRowUtil.sideName[instance.curSide]]]}; 
ENDCASE;
TerminalIO.PutF[", pos: %g\n", IO.int[instance.curPos]]};

[] _ 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, FALSE];
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, FALSE];
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.
RSCPlaceUtilImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Bryan Preas December 19, 1986 4:57:33 pm PST
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
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
Κq˜š
œ™Icodešœ
Οm
œ1™<Kšœ)Οk™,—J˜Jš
œ™Jš
Οc*™*Jš
Ÿ:™:Jš
Ÿ/™/Jš
ŸB™BJš
Ÿ>™>Jš
Ÿ*™*Jš
Ÿ™Jš
ŸC™CJš
Ÿ;™;Jš
Ÿ.™.Jš
Ÿ+™+Jš
Ÿ/™/J˜š
ž	˜	JšžœžœG˜[J˜—šΟnœžœ
ž˜Jšžœ
žœžœ;˜WJšžœ˜Jšžœ
žœž˜J™—Jš
œ™š 	œžœ
ž	œ	žœ6˜\šžœ"žœ˜*šžœž˜ ˜Jš
œ-˜-Jš
œ-˜-Jš
œ-˜-Kšžœžœ
 
œ(˜H˜Jš
œ:˜:Jš
œ˜Jš
œ%˜%Jšœ*žœ˜1Jš
œ˜Jš
œ˜Jšœ*žœ˜1Jšœ?žœ˜EJšœ?žœ˜F—Jš
œ˜Jš
œ˜—˜Jšœžœ˜$Jšœžœ˜$Jš
œ-˜-Kšžœžœ5˜L˜Jš
œ˜Jšœ*žœ˜1Jš
œ˜Jšœ*žœ˜1JšœXžœ˜^JšœXžœ˜_—Jš
œ-˜-Jšžœžœ*˜DJš
œ˜—Jšžœ
˜—Jšžœ
žœ4˜;J˜——š 
œž	œ+žœ
žœ˜]Jšœ	žœžœ˜Dšžœ
žœžœž˜FJšœžœ˜9—Kšžœ
žœ˜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šžœžœ;˜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š
œ/™/š
 
œžœ
ž	œ	žœ6žœ˜iJ˜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šžœžœ:˜OJ˜šžœžœ˜"š œ!˜)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—š œžœ
ž	œ	žœ-žœWžœžœ˜Ύ
J˜Jš
œ)™)š œ˜%Jš
œ"˜"Jš
œ˜J˜—Jšœ#žœ˜=Jš
œ1˜1J˜Jš
œ˜Jš
œ˜Jš
œ;˜;Jšœžœ.˜@Jš
œ]˜]Jš
œ(˜(Jš
œ ˜ Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ3˜7Jšžœžœ<˜QJ˜—Jš
œ3™3š
 œžœ
ž	œ	žœ3žœ
˜gJ˜Jšœ#žœ˜=Jš
œ1˜1Jš
œ8˜8Jš
œ8˜8Jš
œ$˜$Jš
œ$˜$Jš
œ˜Jš
œ˜Jš
œ5˜5—Jš
œ,™,š
 
œžœ
ž	œ	žœ6žœ˜iJ˜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šžœžœžœ
˜=Jš
œW˜WJšœ$žœ
˜(Jš
œ'˜'Jšžœžœ<˜QJ˜—š 
œžœ
ž	œ
žœ˜7J˜š œ!˜)Jš
œ_˜_šžœž˜Jšœ2žœ˜MJš
œ[˜[Jšžœ
˜—Jšœžœ˜9J˜—Jš
œ9˜9J˜—Jš
œ@™@š
 
œžœ
ž	œ	žœžœ˜JJ˜š œ!˜)šžœž˜š
œ˜Jšœ
žœžœžœ˜AJš
œ@˜@šžœž˜Jš
œC˜C——J˜š
œ˜Jšœ
žœžœžœ˜EJš
œD˜Dšžœž˜Jš
œG˜G—J˜—Jšžœ˜	—J˜—Jš
œ9˜9J˜—š 
œžœ
ž	œ	žœ˜3J™J˜š œ˜"š œ˜$šžœžœž˜6JšžœB˜D——Jš
œ>˜>J˜—Jš
œ/˜/J˜—Jšžœ
˜—…—38Dϋ