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.RTLgSetUnion[net.ftsOnRow, 
RTSets.RTLgSetGenerateElement[(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.RTLgSetUnion[net.ftsOnRow, 
RTSets.RTLgSetGenerateElement[(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.RTLgSetDifference[net.ftsOnRow, RTSets.RTLgSetGenerateElement[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.
XSCPlaceUtilImpl.mesa
Copyright Σ 1986, 1987 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
Κm˜š
œ™Icodeš
œB™BKšœ)Οk™,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ύ