DIRECTORY
CD, CDSimpleRules, Core, CoreGeometry, CoreOps, CoreProperties, HashTable, Process, PWCore, Rope, Route, RTBasic, RTCoreUtil, SC, SCChanUtil, SCInitialPlace, SCInstUtil, SCPlaceUtil, SCPrivate, SCRowUtil, SCSmash, SCUtil, Sinix, Sisyph;

SCImpl: CEDAR PROGRAM 
IMPORTS CD, CDSimpleRules, CoreGeometry, CoreOps, CoreProperties, Process, PWCore, Route, RTCoreUtil, RTBasic, SC, SCChanUtil, SCInitialPlace, SCInstUtil, SCPlaceUtil, SCPrivate, SCRowUtil, SCSmash, SCUtil, Sisyph
EXPORTS SC
SHARES SC = {

debug: BOOLEAN _ FALSE;
Error: PUBLIC ERROR[errorType: SC.ErrorType _ callingError, explanation: Rope.ROPE _ NIL] = CODE;
Signal: PUBLIC SIGNAL[signalType: SC.ErrorType _ callingError, explanation: Rope.ROPE _ NIL] = CODE;
CreateDesignRules: PUBLIC PROC [technologyKey: ATOM, horizLayer, vertLayer: Rope.ROPE, rowDirection: SC.Direction, properties: SC.Properties _ NIL] RETURNS [designRules: SC.DesignRules] =

BEGIN
hLayer, vLayer: SC.Layer;
designRules _ NEW[SC.DesignRulesRec];
designRules.technology _ CD.FetchTechnology[technologyKey];
hLayer _ CDSimpleRules.GetLayer[technologyKey, horizLayer];
vLayer _ CDSimpleRules.GetLayer[technologyKey, vertLayer];
designRules.horizLayer _ horizLayer;
designRules.vertLayer _ vertLayer;
designRules.rowRules _ Route.CreateDesignRules[technologyKey, hLayer, vLayer, rowDirection, properties];
designRules.sideRules _ Route.CreateDesignRules[technologyKey, hLayer, vLayer, RTBasic.OtherDirection[rowDirection], properties];
END;
CreateHandle: PUBLIC PROC [cellType: Core.CellType, flattenCellType: RTCoreUtil.FlattenCellTypeProc, libName: Rope.ROPE, designRules: SC.DesignRules, name: Rope.ROPE, properties: SC.Properties _ NIL, decoration: CoreGeometry.Decoration] RETURNS [handle: SC.Handle] =

BEGIN
parms: SCPrivate.Parms _ NARROW[NEW[SCPrivate.ParmsRec], SCPrivate.Parms];

IF designRules = NIL THEN SC.Signal[callingError, "No design rules."];
IF cellType = NIL THEN SC.Signal[callingError, "No Core cell type."];
handle _ NEW[SC.HandleRec];
handle.name _ IF name # NIL THEN name ELSE CoreOps.GetCellTypeName[cellType];
handle.rules _ designRules;
handle.properties _ properties;
handle.coreCellType _ cellType;

parms.libName _ libName; 
handle.parms _ parms;

IF ~SCPrivate.SetUpLayout[handle, cellType] THEN
SC.Signal[callingError, "Unable to construct layout data"];
IF ~SCPrivate.GetStructure[handle, cellType, flattenCellType, decoration] THEN
SC.Signal[callingError, "Unable to construct structure data"];
END;

InitialPlace: PUBLIC PROC [handle: SC.Handle, numRows: NAT _ 0] = {
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCSmash.RemoveSmash[handle];
SCPlaceUtil.ClrCurPlac[handle, TRUE];
SCInitialPlace.PrePlace[handle: handle, numRows: numRows, routingFactor: 2.5, initialized: TRUE];
SCInitialPlace.RowInit[handle];
SCInitialPlace.PosInit[handle];
[layoutData.lgRows.maxRowWidth, layoutData.lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCChanUtil.InitChanWidths[handle];
SCInstUtil.AsgnChanPos[handle];
layoutData.initTotWidth _ layoutData.totWidth;
layoutData.initTotHeight _ layoutData.totHeight;

IF debug THEN SCPlaceUtil.WriteCurPlace[handle];
[] _ SCUtil.WriteResults["End initial placement\n initial size: ", handle, 0];
Process.SetPriority[p]}; 

PosImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PosImprove[handle, areaFom, maxCycles];
Process.SetPriority[p]};

PosImproveWL: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PosImprove[handle, wlFom, maxCycles];
Process.SetPriority[p]};

OrientImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.OrientImprove[handle, areaFom, maxCycles];
Process.SetPriority[p]};

OrientImproveWL: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.OrientImprove[handle, wlFom, maxCycles];
Process.SetPriority[p]};

SAInitialPlace: PUBLIC PROC [handle: SC.Handle, widthFactor: REAL, seed: INT] RETURNS [initialResult: SC.SAInitialResult] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
initialResult _ SCPrivate.SAInitialPlace[handle, widthFactor, seed];
Process.SetPriority[p]};

SAGetParms: PUBLIC PROC [handle: SC.Handle, initialResult: SC.SAInitialResult, cellType: Core.CellType] RETURNS [saParms: SC.SAParms] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
saParms _ SCPrivate.SAGetParms[handle, initialResult, cellType];
Process.SetPriority[p]};

SAPlaceImprove: PUBLIC PROC [handle: SC.Handle, saParms: SC.SAParms, widthFactor: REAL, seed: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.SAPlaceImprove[handle, saParms, widthFactor, seed];
Process.SetPriority[p]};

SAPlaceImproveM: PUBLIC PROC [handle: SC.Handle, saParms: SC.SAParms, widthFactor: REAL, seed: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.SAPlaceImproveM[handle, saParms, widthFactor, seed];
Process.SetPriority[p]};

PlaceImprove: PUBLIC PROC [handle: SC.Handle, maxCycles: INT] = {

p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCPrivate.PlaceImprove[handle, maxCycles];
Process.SetPriority[p]};

GlobalRoute: PUBLIC PROC [handle: SC.Handle] = {
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
SCSmash.RemoveSmash[handle];
SCSmash.SmashAllNets[handle, FALSE];
Process.SetPriority[p]};

DetailRoute: PUBLIC PROC [handle: SC.Handle, viaTable: HashTable.Table] RETURNS [result: SC.Result] = {
p: Process.Priority _ Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
result _ SCPrivate.DetailRoute[handle, viaTable];
Process.SetPriority[p]};

CreateLayout: PUBLIC PROC [technologyKey: ATOM, horizLayer, vertLayer: Rope.ROPE, rowDirection: SC.Direction, numRows: NAT, cellType: Core.CellType, flattenCellType: RTCoreUtil.FlattenCellTypeProc, libName: Rope.ROPE _ NIL, name: Rope.ROPE _ NIL, properties: SC.Properties _ NIL] RETURNS [object: CD.Object] = {
result: SC.Result;
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

designRules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, horizLayer, vertLayer, rowDirection, properties];
handle: SC.Handle _ SC.CreateHandle[cellType, flattenCellType, libName, designRules, name, properties, extractMode.decoration];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
SC.SAPlaceImprove[handle, SC.SAGetParms[handle, SC.SAInitialPlace[handle, widthFactor], cellType], widthFactor];
SC.GlobalRoute[handle];
result _ SC.DetailRoute[handle];
RETURN [result.object]};

Destroy: PUBLIC PROC [handle: SC.Handle] ~ {
SCPrivate.DestroyLayout[handle];
SCPrivate.DestroyStructure[handle];
SCUtil.DestroyRules[handle];
SCUtil.DestroyParms[handle];
handle.name _ NIL;
handle.coreCellType _ NIL;
handle.properties _ NIL};

StandardCellLayout: PUBLIC PWCore.LayoutProc = {
result: SC.Result;
saParms: SC.SAParms;
initialResult: SC.SAInitialResult;
hMaterial: Rope.ROPE _ "metal";
vMaterial: Rope.ROPE _ "metal2";
widthFactor: REAL _ MAX[1.0, MIN[2.0, RTCoreUtil.GetCoreRealProp[cellType, SC.widthFactorProp, 1.1]]];

rules: SC.DesignRules _ SC.CreateDesignRules[technologyKey, hMaterial, vMaterial, horizontal];
handle: SC.Handle _ SC.CreateHandle[cellType: cellType, flattenCellType: RTCoreUtil.defaultFlatten, libName: libName, designRules: rules, decoration: extractMode.decoration];
CoreProperties.PutCellTypeProp[cellType, SC.handleAtom, handle];
SC.InitialPlace[handle, RTCoreUtil.GetCoreIntProp[cellType, SC.numRows, 0]];
initialResult _ SC.SAInitialPlace[handle, widthFactor];
saParms _ SC.SAGetParms[handle, initialResult, cellType];
SC.SAPlaceImprove[handle: handle, saParms: saParms, widthFactor: widthFactor];
SC.PlaceImprove[handle: handle, maxCycles: 1];
SC.GlobalRoute[handle];
SC.PlaceImprove[handle: handle, maxCycles: 1];
-- SCSmash.CheckFts[handle];
-- SCSmash.CheckExits[handle];
result _ SC.DetailRoute[handle];
RETURN[result.object]};

SmashPins: PROC [wire: Core.Wire] = {CoreGeometry.PutPins[extractMode.decoration, wire, NIL]};

StandardCellDecorate: PUBLIC PWCore.DecorateProc = {

DoPin: PROC [pinList: SCPrivate.PublicPinList] ~ {
FOR list: SCPrivate.PublicPinList _ pinList, list.rest WHILE list # NIL DO 
pin: SCPrivate.PublicPin _ list.first;
pins: LIST OF CoreGeometry.Instance _ CoreGeometry.GetPins[extractMode.decoration, pin.wire];
CoreGeometry.PutPins[extractMode.decoration, pin.wire, CONS [[pin.object, pin.trans], pins]];
ENDLOOP};

EachRow: SCRowUtil.EachRowProc = {DoPin[lgRow.publics]};
EachChan: SCChanUtil.EachRowChanProc = {DoPin[rowChan.publics]};

handle: SC.Handle _ NARROW[CoreProperties.GetCellTypeProp[cellType, SC.handleAtom]];
CoreOps.VisitRootAtomics[cellType.public, SmashPins];
IF handle # NIL THEN {
[] _ SCRowUtil.EnumerateRows[handle, EachRow];
[] _ SCChanUtil.EnumerateRowChans[handle, EachChan]};
SC.Destroy[handle]};

StandardCellAttibutes: PUBLIC PWCore.AttributesProc = {-- [cellType: Core.CellType]
FindSideForEachPin: CoreGeometry.EachWirePinProc = {
PushPropOnAtomic: PROC [wire: Core.Wire] ~ {
CoreProperties.PutWireProp[wire, SC.sideProp, ref]};
ref: REF _ SELECT side FROM
bottom => SC.bottomSideValue,
top => SC.topSideValue,
right => SC.rightSideValue,
left => SC.leftSideValue,
ENDCASE => SC.noSideValue;
IF wire.size=0 THEN CoreProperties.PutWireProp[wire, SC.sideProp, ref] 
ELSE CoreOps.VisitRootAtomics[wire, PushPropOnAtomic]};
decoration: CoreGeometry.Decoration _ Sisyph.mode.decoration;
DO
IF CoreGeometry.HasObject[decoration, cellType] THEN {
[] _ CoreGeometry.EnumerateWireSides[decoration, cellType, FindSideForEachPin];
EXIT};
IF cellType.class.recast = NIL THEN EXIT;
cellType _ CoreOps.Recast[cellType]
ENDLOOP}; 

SCLayoutAtom: ATOM _ PWCore.RegisterLayoutAtom[$SC, StandardCellLayout, StandardCellDecorate, StandardCellAttibutes];

technologyKey: ATOM _ $cmosB;		-- $cmosA or $cmosB
libName: Rope.ROPE _ "CMOSB";
extractMode: Sinix.Mode _ PWCore.extractMode;
handleAtom: PUBLIC ATOM _ CoreProperties.RegisterProperty[$SCHandle];
numRows: PUBLIC ATOM _ $numRows;
sideProp: PUBLIC ATOM _ $Side;
bottomSideValue: PUBLIC ATOM _ $bottom;
rightSideValue: PUBLIC ATOM _ $right;
topSideValue: PUBLIC ATOM _ $top;
leftSideValue: PUBLIC ATOM _ $left;
noSideValue: PUBLIC ATOM _ $none;
rowProp: PUBLIC ATOM _ $Row;
positionProp: PUBLIC ATOM _ $Position;
investmentProp: PUBLIC ATOM _ $Investment;
veryLongValue: PUBLIC ATOM _ $veryLong;
longValue: PUBLIC ATOM _ $long;
mediumValue: PUBLIC ATOM _ $medium;
shortValue: PUBLIC ATOM _ $short;
veryShortValue: PUBLIC ATOM _ $veryShort;
t0SA: PUBLIC ATOM _ $t0SA;
maxTStepSA: PUBLIC ATOM _ $maxTStepSA;
lambdaSA: PUBLIC ATOM _ $lambdaSA;
tableSizeSA: PUBLIC ATOM _ $tableSizeSA;
limitSA: PUBLIC ATOM _ $limitSA;
widthFactorProp: PUBLIC ATOM _ $widthFactor;
bottomMaxExits: PUBLIC ATOM _ $BottomMaxExits;
rightMaxExits: PUBLIC ATOM _ $RightMaxExits;
topMaxExits: PUBLIC ATOM _ $TopMaxExits;
leftMaxExits: PUBLIC ATOM _ $LeftMaxExits;
bottomExitSpacing: PUBLIC ATOM _ $BottomExitSpacing;
rightExitSpacing: PUBLIC ATOM _ $RightExitSpacing;
topExitSpacing: PUBLIC ATOM _ $TopExitSpacing;
leftExitSpacing: PUBLIC ATOM _ $LeftExitSpacing;
interestingProperties: PUBLIC RTCoreUtil.PropertyKeys _ NEW[RTCoreUtil.PropertyKeysRec[19]];
interestingProperties.p[0] _ SC.sideProp;
interestingProperties.p[1] _ SC.rowProp;
interestingProperties.p[2] _ SC.positionProp;
interestingProperties.p[3] _ SC.numRows;
interestingProperties.p[4] _ SC.bottomMaxExits;
interestingProperties.p[5] _ SC.rightMaxExits;
interestingProperties.p[6] _ SC.topMaxExits;
interestingProperties.p[7] _ SC.leftMaxExits;
interestingProperties.p[8] _ SC.bottomExitSpacing;
interestingProperties.p[9] _ SC.rightExitSpacing;
interestingProperties.p[10] _ SC.topExitSpacing;
interestingProperties.p[11] _ SC.leftExitSpacing;
interestingProperties.p[12] _ SC.investmentProp;
interestingProperties.p[13] _ SC.t0SA;
interestingProperties.p[14] _ SC.maxTStepSA;
interestingProperties.p[15] _ SC.lambdaSA;
interestingProperties.p[16] _ SC.tableSizeSA;
interestingProperties.p[17] _ SC.limitSA;
interestingProperties.p[18] _ SC.widthFactorProp;
}. 




��r��SCImpl.mesa  SCImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Bryan Preas, August 14, 1986 5:07:05 pm PDT 
Last Edited by: Bryan Preas December 15, 1986 2:14:16 pm PST
Errors
Design Rules
Define the standard cell design rules.  technologyKey values are predefinded for now. horizLayer, vertLayer should be "poly", "metal" or "metal2".
Standard Cell Handles and Results
Create a standard cell design.  The standard cell design definition includes the design rules (conductor and via widths and spacings) and the circuit definition.
set up the layout data

set up the structure data
Standard Cell Optimization and Construction
Determine an initial placement for the instances.

Improve the positions of instances whithin rows.
Improve the positions of instances whithin rows using wire lenght as figure of merit.
Improve the orientation of instances.
Improve the orientation of instances using wire lenght as figure of merit.
Initialize for simulated annealing improvement.
determine parameters for simulated placement.
Improve the placement for the instances (one at a time) by simulated annealing.
Improve the placement for the instances (one at a time) by simulated annealing.
Improve the placement for the instances by exhaustive search.
Determine strategic paths for the wiring that must cross cell rows.

Determine actual wiring paths.  

Create a standard cell object by performing the above operations

Remove circular references so garbage collection can work

-- The cellType to layout is a record cellType containing elements from MSI; the layout proc flattens the Core description and calls the standard cell placer and router.
SC.PosImproveWL[handle, 1];
SC.OrientImproveWL[handle, 1];
SC.PosImprove[handle, 1];
SC.OrientImprove[handle, 1];
add pins on list to the public decorations
-- Puts on public wires their side as a property
[wire: Core.Wire, instance: CD.Instance, min: INT, max: INT, side: CoreGeometry.Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE]
Properties
Used to specify the number of rows for a standard cell assembly.  Should be a property on Core cellType being laid out
Used to specify the side on which a public pin is to be placed.  sideProp with (mumble)Value should be a property/value on a public wire
Used to specify the row on which a logic cell is to be placed. rowProp and and integer row number should be a property/value on a logic cell instance
Used to specify the position of a logic within a row or of an public pin on a side.  May be used on public wire or a logic cell instance.
Used to specify the investment to make in placement.
Used to specify simulated aneealing partameters to be used for placement
Used to specify the maximum number or publics on a side.
Used to specify the HINT for publics spacing on a side.
Cedar does not allow initialization of a sequence in the NEW!
Used to specify all the properties that are interesting to SC
Ê©��˜�š
œ™Jšœ
Ïm
œ7™BJšœ(Ïkœ
™,Icodešœ9ž™<—J˜�š
ž	˜	Jšžœ|žœl˜ì
—J˜�šÐbnœžœ
žœ
˜Kšžœ
žœežœd˜Õ
Kšžœ
ž˜
Kšžœ
žœ˜
K˜�Kšœžœžœ
˜—
head™KšÏnœžœ
žœžœ-žœžœžœ
˜aKš œžœ
žœ
žœ-žœžœžœ
˜d—™š œžœ
žœžœžœžœžœžœžœžœ˜»
Kš
œ’
™’
K˜�Kš
ž˜Kšœžœ˜Kšœžœ
žœ˜%Kšœžœ ˜;Kš
œ;˜;Kš
œ:˜:Kš
œ$˜$Kš
œ"˜"Kš
œh˜hKš
œ
˜
Kšžœ
˜——™!š œžœ
žœZžœžœžœžœžœ'žœ
žœ
˜ŠK™¡
K˜�Kš
ž˜Kšœžœ
žœ'˜JK˜�Kšžœžœ
žœ
žœ*˜FKšžœžœ
žœ
žœ,˜EKšœ	žœ
žœ˜Kš	œžœžœ
žœžœ#˜MKš
œ˜Kš
œ˜Kš
œ˜K˜�Kš
œ˜Kš
œ˜K˜�Kš
œ™šžœ*ž˜0Kšžœ9˜;—K™�Kš
œ™šžœHž˜NKšžœ<˜>—Kšžœ
˜——™+J˜�š
 œžœ
žœ
žœžœ	˜CK™1K™�Kšœ#žœ˜=Kš
œ,˜,Kš
œ0˜0Kš
œ˜Kšœžœ˜%Kšœ[žœ˜aKš
œ˜Kš
œ˜Kš
œ]˜]Kš
œ"˜"Kš
œ˜Kš
œ.˜.Kš
œ0˜0K˜�Kšžœžœ#˜0Kš
œN˜NKš
œ˜—K˜�š
 
œžœ
žœ
žœžœ˜?K™0K˜�Kš
œ,˜,Kš
œ0˜0Kš
œ1˜1š
œ˜K˜�——š
 œžœ
žœ
žœžœ˜AK™UK˜�Kš
œ,˜,Kš
œ0˜0Kš
œ/˜/š
œ˜K˜�——š
 
œžœ
žœ
žœžœ˜BK™%K˜�Kš
œ,˜,Kš
œ0˜0Kš
œ4˜4š
œ˜K˜�——š
 œžœ
žœ
žœžœ˜DK™JK˜�Kš
œ,˜,Kš
œ0˜0Kš
œ2˜2š
œ˜K˜�——š œžœ
žœ
žœžœžœžœžœ˜}K™/K˜�Kš
œ,˜,Kš
œ0˜0Kš
œD˜Dš
œ˜K˜�——š 
œžœ
žœ
žœžœ+žœžœ
˜‰
K™-K˜�Kš
œ,˜,Kš
œ0˜0Kš
œ@˜@Kš
œ˜K˜�—š œžœ
žœ
žœžœžœžœ˜fK™OK˜�Kš
œ,˜,Kš
œ0˜0Kš
œ=˜=š
œ˜K˜�——š œžœ
žœ
žœžœžœžœ˜gK™OK˜�Kš
œ,˜,Kš
œ0˜0Kš
œ>˜>š
œ˜K˜�——š
 œžœ
žœ
žœžœ˜AK™=K˜�Kš
œ,˜,Kš
œ0˜0Kš
œ*˜*š
œ˜K˜�——š œžœ
žœ
žœ˜0K™CK™�Kš
œ,˜,Kš
œ0˜0Kš
œ˜Kšœžœ˜$Kš
œ˜—K˜�š œžœ
žœ
žœ$žœ
žœ˜gKš
œ ™ K™�Kš
œ,˜,Kš
œ0˜0Kš
œ1˜1Kš
œ˜K˜�—š œžœ
žœžœžœžœžœZžœžœ
žœžœžœžœžœ
žœ˜·Kš
œ@™@K™�Kšœžœ˜Kš	œ
žœžœžœ+žœ˜fK˜�Kšœ
žœžœS˜sKšœžœ
žœi˜Kšžœ:žœ˜LKšžœžœžœ>˜pKšžœ˜Kšœ	žœ˜ Kšžœ˜—K˜�š œžœ
žœ
žœ˜,Kš
œ9™9K™�Kš
œ ˜ Kš
œ#˜#Kš
œ˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜K˜�—Kš
Ïc©
™©
š œžœ˜0Kšœžœ˜Kšœ	žœ	˜Kšœžœ˜"Kšœžœ˜Kšœžœ˜ Kš	œ
žœžœžœ+žœ˜fK˜�KšœžœžœD˜^Kšœžœ
žœ˜
˜®
Kšœ)žœ˜@Kšžœ:žœ˜LKšœžœ%˜7Kšœ
žœ-˜9KšžœL˜NKšžœ,˜.Kšžœ˜Kšžœ,˜.Kš
œ™Kš
œ™Kšžœ™Kšžœ™Kš
œ˜Kš
œ˜Kšœ	žœ˜ Kšžœ˜K˜�—š 	œžœIžœ˜^K˜�—š œžœ˜4K˜�š œžœ'˜2Kš
œ*™*šžœ4žœžœ
žœ
˜KKš
œ&˜&Kšœžœ
žœP˜]Kšœ7žœ"˜]Kšžœ˜	K˜�——Kš œ1˜8š œ8˜@K˜�—Kšœžœ
žœ*žœ˜TKš
œ5˜5šžœ
žœ
žœ˜Kš
œ.˜.Kš
œ5˜5—Kšžœ˜—K˜�K•StartOfExpansion6 -- [cellType: Core.CellType] RETURNS [obj: CD.Object]š
¡0™0š œžœ¡˜Sš œ"˜4Kšœžœžœžœ"žœžœžœžœ
™ƒ
–‡
 -- [wire: Core.Wire, instance: CD.Instance, min: INT, max: INT, side: CoreGeometry.Side, layer: CD.Layer] RETURNS [quit: BOOL _ FALSE]š œžœ˜,Kšœ!žœ˜4—šœžœžœž˜Kšœ
žœ˜Kšœžœ˜Kšœ	žœ˜Kšœžœ˜Kšžœžœ
˜—Kšžœ
žœ"žœ˜GKšžœ3˜7—Kš
œ=˜=š
ž˜šžœ.žœ˜6Kš
œO˜OKšžœ˜—Kšžœžœ
žœ
žœ
˜)K˜#Kšžœ˜
—K˜�—Kš œžœc˜uK˜�Kšœžœ¡˜2Kšœžœ˜Kš
œ-˜-—™
Kšœžœ
žœ.˜Ešœ	žœ
žœ˜ Kš
œv™v—šœ
žœ
žœ	˜Kšœžœ
žœ˜'Kšœžœ
žœ
˜%Kšœžœ
žœ˜!Kšœžœ
žœ	˜#šœ
žœ
žœ	˜!Kš
œˆ
™ˆ
——šœ	žœ
žœ˜Kš
ϥ
™•
—šœžœ
žœ
˜&Kš
œ‰
™‰
—šœžœ
žœ˜*Kšœžœ
žœ
˜'Kšœžœ
žœ	˜Kšœ
žœ
žœ˜#Kšœžœ
žœ
˜!šœžœ
žœ˜)Kš
œ4™4—Kšœžœ
žœ	˜Kšœžœ
žœ˜&Kšœ
žœ
žœ
˜"Kšœ
žœ
žœ˜(šœ	žœ
žœ˜ Kš
œH™H——Kšœžœ
žœ˜,Kšœžœ
žœ˜.Kšœžœ
žœ˜,Kšœ
žœ
žœ˜(šœžœ
žœ˜*Kš
œ8™8—Kšœžœ
žœ˜4Kšœžœ
žœ˜2Kšœžœ
žœ˜.šœžœ
žœ˜0Kšœžœ™7—šœžœžœ!˜\Kšœ9žœ
™=Kšœžœ
˜)Kšœžœ	˜(Kšœžœ˜-Kšœžœ	˜(Kšœžœ˜/Kšœžœ˜.Kšœžœ
˜,Kšœžœ˜-Kšœžœ˜2Kšœžœ˜1Kšœžœ˜0Kšœžœ˜1Kšœžœ˜0Kšœžœ˜&Kšœžœ˜,Kšœžœ
˜*Kšœžœ
˜-Kšœžœ	˜)šœžœ˜1Kšœ;ž™=——Jš
œ˜—J˜�J˜�J˜�J˜�—�…—����1Ò��Kí��