DIRECTORY
Basics,
Convert,
Rope,
SC,
SCChanUtil,
SCInstUtil,
SCNetUtil,
SCPrivate,
SCPlaceUtil,
SCSmash, 
SCWidthUtil, 
SCRowUtil,
SCUtil,
RTSets,
TerminalIO;

SCPlaceImproveImpl: CEDAR PROGRAM

IMPORTS Convert, Rope, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCPlaceUtil, SCRowUtil, SCWidthUtil, SCSmash, SCUtil, TerminalIO

EXPORTS SCPrivate
SHARES SC = { 

debug: BOOLEAN _ FALSE;

PosResult: TYPE = RECORD[
area, channelWidth, wireLength: SC.Number,
numFts: INT];

PlaceResult: TYPE = RECORD[
area, channelWidth, wireLength: SC.Number,
numFts: INT];

WritePosResult: PROCEDURE [header: Rope.ROPE, Result: PosResult] = { -- write the results
TerminalIO.WriteRope[header];
TerminalIO.WriteRope["   area: "]; TerminalIO.WriteInt[Result.area];
TerminalIO.WriteRope[", channelWidth: "]; TerminalIO.WriteInt[Result.channelWidth];
TerminalIO.WriteRope["\n      wireLength: "]; TerminalIO.WriteInt[Result.wireLength];
TerminalIO.WriteRope[", numFts: "]; TerminalIO.WriteInt[Result.numFts];
TerminalIO.WriteLn[]};

ComparePosResult: PROCEDURE [result1, result2: PosResult]
RETURNS [FirstRelationSecond: Basics.Comparison] = {
IF result1.area < result2.area THEN
FirstRelationSecond _ less
ELSE IF result1.area > result2.area THEN
FirstRelationSecond _ greater
ELSE IF result1.channelWidth < result2.channelWidth THEN
FirstRelationSecond _ less
ELSE IF result1.channelWidth > result2.channelWidth THEN
FirstRelationSecond _ greater
ELSE IF result1.wireLength < result2.wireLength THEN
FirstRelationSecond _ less
ELSE IF result1.wireLength > result2.wireLength THEN
FirstRelationSecond _ greater
ELSE IF result1.numFts < result2.numFts THEN
FirstRelationSecond _ less
ELSE IF result1.numFts > result2.numFts THEN
FirstRelationSecond _ greater
ELSE
FirstRelationSecond _ equal}; -- they are equal

ComparePlaceResult: PROCEDURE [result1, result2: PlaceResult]
RETURNS [FirstRelationSecond: Basics.Comparison] =

BEGIN
IF result1.area < result2.area THEN
FirstRelationSecond _ less
ELSE IF result1.area > result2.area THEN
FirstRelationSecond _ greater
ELSE IF result1.channelWidth < result2.channelWidth THEN
FirstRelationSecond _ less
ELSE IF result1.channelWidth > result2.channelWidth THEN
FirstRelationSecond _ greater
ELSE IF result1.wireLength < result2.wireLength THEN
FirstRelationSecond _ less
ELSE IF result1.wireLength > result2.wireLength THEN
FirstRelationSecond _ greater
ELSE IF result1.numFts < result2.numFts THEN
FirstRelationSecond _ less
ELSE IF result1.numFts > result2.numFts THEN
FirstRelationSecond _ greater
ELSE
FirstRelationSecond _ equal; -- they are equal
END; -- ComparePlaceResult

DoWidths: PROCEDURE [handle: SC.Handle,
doChanWidth: SCPrivate.ChanSet,
doSideWidth: SCPrivate.LRSideSet,
doRowWidth: SCPrivate.RowSet,
fom: SCPrivate.FomType]
RETURNS [wireLength: SC.Number _ 0] = {

EachRow: SCRowUtil.EachRowProc = { 
IF doRowWidth[(row)-1] THEN SCInstUtil.LgOffsets[handle, row, 0, 0]};

EachRowChan: SCChanUtil.EachRowChanProc = { 
IF doChanWidth[(chan )-1] THEN
[rowChan.chanWidth, rowChan.wireLength] _ SCWidthUtil.GetChanWidth[handle, rowChan, fom, TRUE];
wireLength _ wireLength + layoutData.rowChans.chans[chan].wireLength};

EachSideChan: SCChanUtil.EachSideChanProc = {
IF doSideWidth[LOOPHOLE[lrSide, INTEGER]] THEN {
sideChan: SCPrivate.SideChan _ layoutData.sideChans[lrSide];
[sideChan.sideChanWidth, sideChan.wireLength] _ SCWidthUtil.GetSideWidth[handle, lrSide, fom]};
wireLength _ wireLength + sideChan.wireLength};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
[] _ SCRowUtil.EnumerateRows[handle, EachRow];
[] _ SCChanUtil.EnumerateRowChans[handle, EachRowChan];
[] _ SCChanUtil.EnumerateSideChans[handle, EachSideChan]};

ChosRow: PROCEDURE[handle: SC.Handle, rowIndex: SCPrivate.ZMaxRowSr]
RETURNS[rowToDo: SCPrivate.LgRow, doUpper, doLower: BOOLEAN] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
row: SCPrivate.ZMaxRowSr;
SELECT TRUE FROM
layoutData.bpRows[top].fnlBpFxd AND layoutData.bpRows[bottom].fnlBpFxd =>
{IF (rowIndex MOD 2) # 0 THEN row _ (lgRows.count+1) /2 - (rowIndex-1) /2
ELSE row _ (lgRows.count+1) /2 + rowIndex /2;
doUpper _ doLower _ TRUE};

layoutData.bpRows[top].fnlBpFxd =>
{row _ lgRows.count - rowIndex + 1; doUpper _ TRUE; doLower _ FALSE};

layoutData.bpRows[bottom].fnlBpFxd =>
{row _ rowIndex; doUpper _ FALSE; doLower _ TRUE};

ENDCASE =>
{IF (rowIndex MOD 2) # 0 THEN row _ (lgRows.count+1) /2 - (rowIndex-1) /2
ELSE row _ (lgRows.count+1) /2 + rowIndex /2;

IF row = (lgRows.count+1) /2 THEN {doUpper _ TRUE; doLower _ TRUE}
ELSE IF row < (lgRows.count+1) /2 THEN {doUpper _ TRUE; doLower _ FALSE}
ELSE {doUpper _ FALSE; doLower _ TRUE}};
rowToDo _ lgRows.rows[row]};

PosImproveRow: PROCEDURE [handle: SC.Handle, lgRow: SCPrivate.LgRow, doUpper, doLower: BOOLEAN, whichFom: SCPrivate.FomType] RETURNS [goodExch: BOOLEAN _ FALSE] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
row: SCPrivate.MaxRowSr _ lgRow.rowNum;
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
lowerChan: SCPrivate.RowChan _ rowChans.chans[row];
upperChan: SCPrivate.RowChan _ rowChans.chans[row+1];
numFts: INT _ structureData.instances.numFts;
oldLowChWidth, oldUpChWidth, oldLowWireLength, oldUpWireLength: SC.Number;
oldResult: PosResult;

TrialInterchange: SCRowUtil.EachInstProc = {
nextPos: SCPrivate.MaxPosSr _ pos + 1;
lowChWidth, upChWidth, upWireLength, lowWireLength: SC.Number;
newResult: PosResult;

SCPlaceUtil.ExchPosRow[handle, pos, nextPos, row];
[lowChWidth, lowWireLength] _ SCWidthUtil.GetChanWidth[handle, lowerChan, whichFom, doLower];
[upChWidth, upWireLength] _ SCWidthUtil.GetChanWidth[handle, upperChan, whichFom, doUpper];
newResult _ PosResult[(lowChWidth + upChWidth) * lgRows.maxRowWidth, (lowChWidth + upChWidth), (lowWireLength + upWireLength), numFts];
IF debug THEN WritePosResult["   trial result: ", newResult];

SELECT ComparePosResult[newResult, oldResult] FROM
less => { -- strict improvement, thats good 
IF debug THEN TerminalIO.WriteRope["   accept improvement\n"];
lowerChan.chanWidth _ lowChWidth;
upperChan.chanWidth _ upChWidth;
oldResult _ newResult;
goodExch _ TRUE};

equal => { -- neutral improvement, take it 
IF debug THEN TerminalIO.WriteRope["   accept neutral exchange\n"];
lowerChan.chanWidth _ lowChWidth;
upperChan.chanWidth _ upChWidth;
oldResult _ newResult};

greater => { -- this change made it worse, restore old placement 
IF debug THEN WritePosResult["   restore old result: ", oldResult];
SCPlaceUtil.ExchPosRow[handle, pos, nextPos, row]};
ENDCASE};

IF lgRow.nLgsOnRow > 0 AND ~lgRow.fnlLgFxd AND (doUpper OR doLower) THEN {
TerminalIO.WriteRope[" improve row "]; TerminalIO.WriteInt[row];
TerminalIO.WriteRope[Rope.Cat[" doUpper: ", Convert.RopeFromBool[doUpper],
" doLower: ", Convert.RopeFromBool[doLower]]];
TerminalIO.WriteLn[];

[oldLowChWidth, oldLowWireLength] _ SCWidthUtil.GetChanWidth[handle, lowerChan, whichFom, doLower];
[oldUpChWidth, oldUpWireLength] _ SCWidthUtil.GetChanWidth[handle, upperChan, whichFom, doUpper];
oldResult _ PosResult[(oldLowChWidth + oldUpChWidth) * lgRows.maxRowWidth, (oldLowChWidth + oldUpChWidth), (oldLowWireLength + oldUpWireLength), numFts];
IF debug THEN WritePosResult["   original logic result: ", oldResult];

[] _ SCRowUtil.EnumerateInstsOnRow[handle, row, 1, MAX[0, lgRow.nLgsOnRow-1], TrialInterchange]}};

PosImproveLeftRight: PROCEDURE[handle: SC.Handle, side: SC.Side, whichFom: SCPrivate.FomType] RETURNS [goodExch: BOOLEAN _ FALSE] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
sideChan: SCPrivate.SideChan _ layoutData.sideChans[side];
wireLength: SC.Number;
oldResult: PlaceResult;

TrialInterchange: SCRowUtil.EachInstProc = {
doChanWidth: SCPrivate.ChanSet _ RTSets.RTMdSetEmpty;
doRowWidth: SCPrivate.ChanSet _ RTSets.RTMdSetEmpty;
doSideWidth: SCPrivate.LRSideSet _ RTSets.RTSmSetEmpty;
nextPos: SCPrivate.MaxPosSr _ pos +1;
newWireLength: SC.Number;
newResult: PlaceResult;

nets: SCPrivate.NetList _ SCNetUtil.NetsOnInst[LIST[bpRow.bpsOnSide[pos], bpRow.bpsOnSide[nextPos]]];
[doChanWidth, doSideWidth, doRowWidth] _ SCSmash.RemoveNetsWFts[handle, nets, TRUE, doChanWidth, doSideWidth, doRowWidth];
SCPlaceUtil.ExchPosSide[handle, pos, nextPos, side];
[doChanWidth, doSideWidth, doRowWidth] _ SCSmash.SmashNets[handle, nets, FALSE, doChanWidth, doSideWidth, doRowWidth];
newWireLength _ DoWidths[handle, doChanWidth, doSideWidth, doRowWidth, whichFom];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCInstUtil.AsgnChanPos[handle];
newResult _ PlaceResult[layoutData.totWidth * layoutData.totHeight, layoutData.sideChans[side].sideChanWidth, newWireLength, structureData.instances.numFts];
IF debug THEN WritePosResult["   trial result: ", newResult];

SELECT ComparePlaceResult[newResult, oldResult] FROM
less => { -- strict improvement, thats good
IF debug THEN TerminalIO.WriteRope["   accept improvement\n"];
wireLength _ newWireLength;
oldResult _ newResult;
goodExch _ TRUE};

equal => { -- neutral exchange, take it
IF debug THEN TerminalIO.WriteRope["   accept neutral exchange\n"];
wireLength _ newWireLength;
oldResult _ newResult};

greater => { -- this change made it worse, restore old placement 
IF debug THEN WritePosResult["   restore old result: ", oldResult];
[doChanWidth, doSideWidth, doRowWidth] _ SCSmash.RemoveNetsWFts[handle, nets, FALSE, RTSets.RTMdSetEmpty, RTSets.RTSmSetEmpty, RTSets.RTMdSetEmpty];
SCPlaceUtil.ExchPosSide[handle, pos, nextPos, side];
[doChanWidth, doSideWidth, doRowWidth] _ SCSmash.RestoreNetsWFts[handle, nets, doChanWidth, doSideWidth, doRowWidth];

wireLength _ DoWidths[handle, doChanWidth, doSideWidth, doRowWidth, whichFom];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCInstUtil.AsgnChanPos[handle]};
ENDCASE};

IF ~ bpRow.fnlBpFxd THEN {
TerminalIO.WriteRope[Rope.Cat[" improve ", SCRowUtil.sideName[side], " side\n"]];

SCWidthUtil.AllChanWidths[handle, whichFom];
wireLength _ DoWidths[handle, RTSets.RTMdSetEmpty, RTSets.RTSmSetEmpty, RTSets.RTMdSetEmpty, whichFom];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCInstUtil.AsgnChanPos[handle];
oldResult _ PlaceResult[layoutData.totWidth * layoutData.totHeight, sideChan.sideChanWidth, wireLength, structureData.instances.numFts];
IF debug THEN WritePosResult[Rope.Cat["   original ", SCRowUtil.sideName[side] ," result: "], oldResult];

[] _ SCRowUtil.EnumerateInstsOnSide[handle, side, 1, MAX[0, bpRow.nBpsOnSide -1], TrialInterchange];

SCWidthUtil.AllChanWidths[handle, areaFom]}};

PosImproveTopBot: PROCEDURE[handle: SC.Handle, side: SC.Side, whichFom: SCPrivate.FomType] RETURNS [goodExch: BOOLEAN _ FALSE] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
numFts: INT _ structureData.instances.numFts;
oldChWidth, oldWireLength: SC.Number;
oldResult: PosResult;
chan: SCPrivate.RowChan _ SELECT side FROM
top => rowChans.chans[rowChans.count],
bottom => rowChans.chans[1],
ENDCASE => SC.Error[programmingError, "Invalid side in Placement Improvement"];

TrialInterchange: SCRowUtil.EachInstProc = {
nextPos: SCPrivate.MaxPosSr _ pos + 1;
chWidth, wireLength: SC.Number;
newResult: PosResult;

SCPlaceUtil.ExchPosSide[handle, pos, nextPos, side];
[chWidth, wireLength] _ SCWidthUtil.GetChanWidth[handle, chan, whichFom, TRUE];
newResult _ PosResult[chWidth * lgRows.maxRowWidth, chWidth, wireLength, numFts];
IF debug THEN WritePosResult["   trial result: ", newResult];

SELECT ComparePosResult[newResult, oldResult] FROM
less => { -- strict improvement, thats good 
IF debug THEN TerminalIO.WriteRope["   accept improvement\n"];
chan.chanWidth _ chWidth;
oldResult _ newResult;
goodExch _ TRUE};

equal => { -- neutral exchange, take what you can get 
IF debug THEN 
TerminalIO.WriteRope["   accept neutral exchange\n"];
chan.chanWidth _ chWidth;
oldResult _ newResult};

greater => { -- this change made it worse, restore old placement 
IF debug THEN WritePosResult["   restore old result: ", oldResult];
SCPlaceUtil.ExchPosSide[handle, pos, nextPos, side]};
ENDCASE};

IF ~ bpRow.fnlBpFxd THEN {
TerminalIO.WriteRope[Rope.Cat[" improve ", SCRowUtil.sideName[side], " side\n"]];

[oldChWidth, oldWireLength] _ SCWidthUtil.GetChanWidth[handle, chan, whichFom, TRUE];
oldResult _ PosResult[oldChWidth * lgRows.maxRowWidth, oldChWidth, oldWireLength, numFts];
IF debug THEN WritePosResult[Rope.Cat["   original ", SCRowUtil.sideName[side]," result: "], oldResult];

[] _ SCRowUtil.EnumerateInstsOnSide[handle, side, 1, MAX[0, bpRow.nBpsOnSide-1], TrialInterchange]}};

PosImprove: PUBLIC PROCEDURE [handle: SC.Handle, whichFom: SCPrivate.FomType] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
bpRows: SCPrivate.BpRows _ layoutData.bpRows;
startArea: SC.Number;

[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCWidthUtil.AllChanWidths[handle, areaFom];
SCInstUtil.AsgnChanPos[handle];
startArea _ SCUtil.WriteResults["Position improvement\n starting area:", handle, 0];

DO
goodExch: BOOLEAN _ FALSE;
goodTopExch, goodBottomExch, goodRightExch, goodLeftExch: BOOLEAN;
EachRow: SCRowUtil.EachRowProc = { 
rowToDo: SCPrivate.LgRow;
doUpper, doLower: BOOLEAN;
goodRowExch: BOOLEAN;
[rowToDo, doUpper, doLower] _ ChosRow[handle, row];
goodRowExch _ PosImproveRow[handle, rowToDo, doUpper, doLower, whichFom];
goodExch _ goodExch OR goodRowExch};

goodLeftExch _ PosImproveLeftRight[handle, left, whichFom];
goodRightExch _ PosImproveLeftRight[handle, right, whichFom];

SCInstUtil.AsgnChanPos[handle];
[] _ SCRowUtil.EnumerateRows[handle, EachRow];

goodTopExch _ PosImproveTopBot[handle, top, whichFom];
goodBottomExch _ PosImproveTopBot[handle, bottom, whichFom];

IF ~(goodExch OR goodLeftExch OR goodRightExch OR goodTopExch OR goodBottomExch) THEN EXIT;
SCInstUtil.AsgnChanPos[handle];
ENDLOOP;

SCInstUtil.AllOffsets[handle];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCWidthUtil.AllChanWidths[handle, areaFom];
SCInstUtil.AsgnChanPos[handle];

[] _ SCUtil.WriteResults["End position improvement\n ending area:", handle, startArea];
IF debug THEN SCPlaceUtil.WriteCurPlace[handle]}; -- PosImprove
}.

6file: SCPlaceImproveImpl.mesa
Copyright c 1985 by Xerox Corporation. All rights reserved.
map a row index in to a row 
improve positions on logic rows 
improve positions on bonding pad sides 
improve positions on bonding pad sides 
improve the left and right sides 
now improve the top and bottom sides 
Κ¦˜š
œ™Icodešœ
Οm
œ0™;—J˜š
Οk	˜	J˜Jš
œ˜Jš
œ˜Jšžœ
˜J˜Jš
œ˜J˜
J˜
Jš
œ˜Jš
œ	˜	Jš
œ
˜
Jš
œ
˜
J˜Jš
œ˜Jš
œ˜J˜—šœžœ
ž˜!J˜Jšžœžœe˜~J˜Jšžœ
˜Jšžœ
žœ˜J˜Jšœžœžœ
˜J˜šœžœžœ
˜Jšœ žœ˜*Jšœžœ˜
—J˜šœ
žœžœ
˜Jšœ žœ˜*Jšœžœ˜
—J˜š	Οnœž	œžœžœ
Οc˜YJš
œ˜Jš
œD˜DJš
œS˜SJš
œU˜UJš
œG˜GJš
œ˜J˜—šŸœž	œ˜9Jšžœ-˜4šžœž˜#Jš
œ˜—šžœ
žœž˜(Jš
œ˜—šžœ
žœ-ž˜8Jš
œ˜—šžœ
žœ-ž˜8Jš
œ˜—šžœ
žœ)ž˜4Jš
œ˜—šžœ
žœ)ž˜4Jš
œ˜—šžœ
žœ!ž˜,Jš
œ˜—šžœ
žœ!ž˜,Jš
œ˜—š
ž˜Jšœ ˜/——J˜šŸœž	œ ˜=Jšžœ+˜2J˜Jš
ž˜šžœž˜#Jš
œ˜—šžœ
žœž˜(Jš
œ˜—šžœ
žœ-ž˜8Jš
œ˜—šžœ
žœ-ž˜8Jš
œ˜—šžœ
žœ)ž˜4Jš
œ˜—šžœ
žœ)ž˜4Jš
œ˜—šžœ
žœ!ž˜,Jš
œ˜—šžœ
žœ!ž˜,Jš
œ˜—š
ž˜Jšœ ˜.—Jšžœ œ ˜J˜—šŸœž	œ
žœ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jšžœž	œ	˜'J˜š
œ#˜#Jšžœžœ*˜E—J˜š
œ,˜,šžœž˜JšœYžœ˜_—Jš
œF˜F—J˜š
œ-˜-šžœ
žœ	žœž˜0Jš
œ<˜<Jš
œ_˜_—Jš
œ/˜/—J˜Jšœ#žœ˜=Jš
œ.˜.Jš
œ7˜7Jš
œ:˜:—J˜Jš
œ™šŸœž	œ	žœ'˜DJšžœ-žœ˜@J˜Jšœ#žœ˜=Jš
œ-˜-Jš
œ˜šžœ
žœ
ž˜šœ žœ&˜IJšœ
žœžœžœ,˜IJšžœ)˜-Jšœžœ˜J˜—š
œ"˜"Jšœ.žœžœ˜EJ˜—š
œ%˜%Jšœžœžœ˜2—J˜šžœ˜
Jšœ
žœžœžœ,˜IJšžœ)˜-J˜Jšžœžœžœžœ
˜BJš
žœ
žœžœžœžœ
˜HJšžœžœžœ˜(——Jš
œ˜—J˜Jš
œ ™ šŸ
œž	œ
žœ3žœžœžœžœ˜€
J˜Jšœ#žœ˜=Jšœ)žœ˜FJš
œ-˜-Jš
œ'˜'Jš
œ3˜3Jš
œ3˜3Jš
œ5˜5Jšœžœ"˜-Jšœ@ž	œ
˜JJš
œ˜J˜š
œ,˜,Jš
œ&˜&Jšœ4ž	œ
˜>Jš
œ˜J˜Jš
œ2˜2Jš
œ]˜]Jš
œ[˜[Jš
œ‡
˜‡
Jšžœžœ0˜=J˜Jšžœ(ž˜2šœžœ
 "˜,Jšžœžœ1˜>Jš
œ!˜!Jš
œ ˜ Jš
œ˜Jšœžœ˜—J˜šœžœ
  ˜+Jšžœžœ6˜CJš
œ!˜!Jš
œ ˜ Jš
œ˜—J˜šœ
žœ
 4˜AJšžœžœ6˜CJš
œ3˜3—Jšžœ˜	J˜—š
žœžœžœ
žœ
žœ˜JJš
œ@˜@š
œJ˜JJš
œ.˜.—Jš
œ˜J˜Jš
œc˜cJš
œa˜aJš
Ϫ
˜™
Jšžœžœ9˜FJ˜Jš
œb˜b——J˜Jš
œ'™'šŸœž	œ	žœžœ$žœžœžœ˜…
J˜Jšœ#žœ˜=Jšœ)žœ˜FJš
œ-˜-Jš
œ1˜1Jš
œ:˜:Jšœž	œ
˜Jš
œ˜J˜š
œ,˜,Jš
œ5˜5Jš
œ4˜4Jš
œ7˜7Jš
œ%˜%Jšœž	œ
˜Jš
œ˜J˜Jšœ/žœ2˜eJšœNžœ(˜zJš
œ4˜4JšœIžœ(˜vJš
œQ˜QJš
œG˜GJš
œ˜Jš
œ
˜
Jšžœžœ0˜=J˜šžœ*ž˜4šœžœ
 !˜+Jšžœžœ1˜>Jš
œ˜Jš
œ˜Jšœžœ˜—J˜šœžœ
 ˜'Jšžœžœ6˜CJš
œ˜Jš
œ˜—J˜šœ
žœ
 4˜AJšžœžœ6˜CJšœNžœA˜”
Jš
œ4˜4Jš
œu˜uJ˜Jš
œN˜NJš
œG˜GJš
œ ˜ —Jšžœ˜	J˜——šžœž˜Jš
œQ˜QJ˜Jš
œ,˜,Jš
œg˜gJš
œG˜GJš
œ˜Jš
œˆ
˜ˆ
Jšžœžœ\˜iJ˜Jš
œd˜dJ˜Jš
œ-˜-—J˜—Jš
œ'™'šŸœž	œ	žœžœ$žœžœžœ˜‚
J˜Jšœ#žœ˜=Jšœ)žœ˜FJš
œ-˜-Jš
œ1˜1Jš
œ3˜3Jšœžœ"˜-Jšœž	œ
˜%Jš
œ˜šœžœž˜*Jš
œ&˜&Jš
œ˜JšžœžœB˜O—J˜š
œ,˜,Jš
œ&˜&Jšœž	œ
˜Jš
œ˜J˜Jš
œ4˜4JšœIžœ˜OJš
œQ˜QJšžœžœ0˜=J˜Jšžœ(ž˜2šœžœ
 "˜,Jšžœžœ1˜>Jš
œ˜Jš
œ˜Jšœžœ˜—J˜šœžœ
 +˜6šžœžœ
˜Jš
œ5˜5—Jš
œ˜Jš
œ˜—J˜šœžœ
 4˜AJšžœžœ6˜CJš
œ5˜5—Jšžœ˜	—J˜šžœžœ˜Jš
œQ˜QJ˜JšœOžœ˜UJš
œZ˜ZJšžœžœ[˜hJ˜Jš
œe˜e——J˜šŸ
œžœ
ž	œ
žœ)˜QJ˜Jšœ#žœ˜=Jš
œ-˜-Jš
œ-˜-Jšœž	œ
˜J˜Jš
œG˜GJš
œ+˜+Jš
œ˜Jš
œT˜TJ˜š
ž˜Jšœ
žœžœ
˜Jšœ:žœ
˜Bš
œ#˜#Jš
œ˜Jšœžœ
˜Jšœ
žœ
˜Jš
œ3˜3Jš
œI˜Išœžœ˜$J˜——Jš
œ!™!Jš
œ;˜;Jš
œ=˜=J˜Jš
œ˜Jš
œ.˜.J˜Jš
œ%™%Jš
œ6˜6Jš
œ<˜<J˜JšžœOžœ
žœ
˜[Jš
œ˜Jšžœ
˜—J˜Jš
œ˜Jš
œG˜GJš
œ+˜+Jš
œ˜J˜Jš
œW˜WJšžœžœ"ž
œ 
˜?—Jš
œ˜——…—9žGz