DIRECTORY
CD, CDBasics, CDCells, CDDirectory, CDInstances, CDOrient, CDProperties, 
Commander, 
Core, CoreClasses, CoreCreate, CoreFlat, CoreOps, CoreProperties, 
CoreGeometry,
GList, HashTable, IO, 
PW, PWCore, PWObjects, 
Rope, 
Sinix, SinixOps, Sisyph;

PWCoreImpl: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCells, CDDirectory, CDInstances, CDProperties, CoreClasses, CoreCreate, CoreOps, CoreProperties, CoreGeometry, GList, HashTable, IO, PW, PWObjects, Rope, Sinix, SinixOps, Sisyph
EXPORTS PWCore
SHARES CDCells, CDDirectory = 
BEGIN OPEN PWCore;
VisitAtomicPairs: PROC [wire1, wire2: Wire, eachPair: PROC [Wire, Wire]] = {
VisitInternal: PROC [wire1, wire2: Wire] = {
IF wire1.size#wire2.size THEN ERROR;
IF wire1.size=0 
THEN eachPair[wire1, wire2] 
ELSE FOR i: NAT IN [0 .. wire1.size) DO VisitInternal[wire1[i], wire2[i]] ENDLOOP;
};
IF wire1.size#wire2.size THEN ERROR;
FOR i: NAT IN [0 .. wire1.size) DO VisitInternal[wire1[i], wire2[i]] ENDLOOP;
};

SmashProps: CoreOps.EachWireProc = {
name: ROPE = CoreOps.GetShortWireName[wire];
wire.properties _ NIL;
[] _ CoreOps.SetShortWireName[wire, name];
};
CopyWire: PROC [old: Wire] RETURNS [new: Wire] = {
new _ CoreOps.CopyWire[old];
[] _ CoreOps.VisitWire[new, SmashProps];
};
Signal: PUBLIC SIGNAL [cellType: CellType] = CODE;

Error: PUBLIC ERROR [type: ATOM, message: ROPE, cellType: CellType] = CODE;

PinsCorrespondingToSeveralPublics: PUBLIC SIGNAL [cellType: CellType, obj: Object, publics: Wires, geometry: LIST OF CD.Instance] = CODE;

NoPinsOnAtomicPublic: PUBLIC SIGNAL [cellType: CellType, obj: Object, public: Wire, message: ROPE _ NIL] = CODE;

NoInterestRectDecoration: PUBLIC SIGNAL [cellType: CellType, obj: Object] = CODE;
layoutAtomsTable: HashTable.Table _ HashTable.Create[];

LayoutAtomData: TYPE = REF LayoutAtomDataRec;
LayoutAtomDataRec: TYPE = RECORD [layoutProc: LayoutProc, decorateProc: DecorateProc, attributesProc: AttributesProc _ NIL];

RegisterLayoutAtom: PUBLIC PROC [layoutAtom: ATOM, layoutProc: LayoutProc, decorateProc: DecorateProc _ NIL, attributesProc: AttributesProc _ NIL] RETURNS [sameAtom: ATOM] = {
sameAtom _ layoutAtom;
IF ~HashTable.Store[layoutAtomsTable, layoutAtom, NEW [LayoutAtomDataRec _ [layoutProc: layoutProc, decorateProc: decorateProc, attributesProc: attributesProc]]] 
THEN PW.WriteF["LayoutProc and DecorateProc for %g overwritten\n", IO.atom[layoutAtom]];
};

GetLayoutAtomRegistration: PUBLIC PROC [layoutAtom: ATOM] RETURNS [layoutProc: LayoutProc _ NIL, decorateProc: DecorateProc _ NIL, attributesProc: AttributesProc _ NIL] = {
layoutAtomData: LayoutAtomData _ NARROW [HashTable.Fetch[layoutAtomsTable, layoutAtom].value];
IF layoutAtomData=NIL THEN RETURN;
layoutProc _ layoutAtomData.layoutProc; 
decorateProc _ layoutAtomData.decorateProc; 
attributesProc _ layoutAtomData.attributesProc;
};
layoutAtomProp: PUBLIC ATOM _ CoreProperties.RegisterProperty[$Layout];

GetLayoutAtom: PUBLIC PROC [cellType: CellType] RETURNS [layoutAtom: ATOM _ NIL] = {
layoutAtom _ NARROW [CoreProperties.GetCellTypeProp[cellType, layoutAtomProp]];
IF layoutAtom#NIL THEN RETURN;
layoutAtom _ NARROW [CoreProperties.GetCellClassProp[cellType.class, layoutAtomProp]];
};

layoutProp: PRIVATE ATOM _ CoreProperties.RegisterProperty[$PWCoreLayout]; -- cache on CellTypes

FakeExtract: Sinix.ExtractProc = {result _ CDProperties.GetObjectProp[obj, $PWCoreCellType]};

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

CopyDecorations: PROC [to, from: CellType, obj: Object] = {
CopyPins: PROC [toWire, fromWire: Wire] = {
IF NOT CoreGeometry.HasPins[extractMode.decoration, fromWire] 
THEN SIGNAL NoPinsOnAtomicPublic[from, obj, fromWire, CoreOps.GetFullWireName[from.public, fromWire]];
CoreGeometry.AddIndirectLazyPins[extractMode.decoration, toWire, fromWire];
};
CoreOps.VisitRootAtomics[to.public, SmashPins];
CoreGeometry.PutIR[extractMode.decoration, to, CD.InterestRect[obj]];
VisitAtomicPairs[to.public, from.public, CopyPins];
};

Layout: PUBLIC PROC [cellType: CellType] RETURNS [obj: Object] = {
obj _ NARROW [CoreProperties.GetCellTypeProp[cellType, layoutProp]];
IF obj#NIL THEN RETURN;
BEGIN
layoutAtom: ATOM _ GetLayoutAtom[cellType];
layoutAtomData: LayoutAtomData;
layoutData: LayoutData; 
layoutCellType: CellType;
IF layoutAtom=NIL 
THEN IF cellType.class.recast=NIL 
THEN ERROR Error[$NoLayoutAtom, "Impossible to find a layoutAtom for this cellType", cellType] 
ELSE {
recasted: CellType = CoreOps.Recast[cellType];
obj _ Layout[recasted];
CopyDecorations[cellType, recasted, obj];
RETURN;
};
layoutAtomData _ NARROW [HashTable.Fetch[layoutAtomsTable, layoutAtom].value];
IF layoutAtomData=NIL THEN ERROR Error[$NoRegistration, IO.PutFR["LayoutAtom %g has not been registered", IO.atom[layoutAtom]], cellType];
IF layoutAtomData.attributesProc#NIL THEN layoutAtomData.attributesProc[cellType];
obj _ layoutAtomData.layoutProc[cellType];
layoutData _ NEW [LayoutDataRec _ [cellType: cellType, obj: obj, mode: extractMode]]; 
layoutCellType _ CoreOps.CreateCellType[class: layoutClass, public: CopyWire[cellType.public], data: layoutData];
IF layoutAtomData.decorateProc#NIL THEN layoutAtomData.decorateProc[cellType, obj];
IF NOT CoreGeometry.HasIR[extractMode.decoration, cellType] OR CoreGeometry.GetIR[extractMode.decoration, cellType]#CD.InterestRect[obj] THEN SIGNAL NoInterestRectDecoration[cellType, obj];
CopyDecorations[layoutCellType, cellType, obj];
obj _ PWObjects.CreateIndirect[obj];
CDProperties.PutObjectProp[obj, $PWCoreCellType, layoutCellType];
CDProperties.PutObjectProp[obj, extractMode.extractProcProp, $FakeExtract];
CoreProperties.PutCellTypeProp[cellType, layoutProp, obj];
IF CoreOps.GetCellTypeName[cellType]#NIL AND CDDirectory.Name[obj]=NIL THEN NARROW [obj.class.directoryProcs, REF CDDirectory.DirectoryProcs].setName[obj, CoreOps.GetCellTypeName[cellType]];
IF Sinix.Extract[obj, extractMode].result#layoutCellType THEN ERROR Error[$InternalBug, "Internal invariant failed", cellType];
IF CorrespondingCellType[obj]#layoutCellType THEN ERROR Error[$InternalBug, "Internal invariant failed", cellType]; 
END;
};

InterestRect: PUBLIC PROC [cellType: CellType] RETURNS [ir: CD.Rect] = {
IF NOT CoreGeometry.HasIR[extractMode.decoration, cellType] THEN [] _ Layout[cellType];
ir _ CoreGeometry.GetIR[extractMode.decoration, cellType];
};
FromLayoutWithoutPublic: PUBLIC PROC [obj: Object] RETURNS [cellType: CellType] = {
cellType _ NARROW [Sinix.Extract[obj, extractMode].result];
SetLayoutAndDecoration[cellType, obj];
};
extractMode: PUBLIC Sinix.Mode _ SinixOps.GetExtractMode[$cmosB];
maskSuffix: PUBLIC ROPE _ ".mask";

GetAndAddSuffix: PROC [source: CD.Design, name: ROPE] RETURNS [obj: Object] = {
obj _ PW.Get[source, IO.PutR[IO.rope[name], IO.rope[maskSuffix]]];
};

Get: LayoutProc = {
source: CD.Design _ NARROW [CoreProperties.GetCellTypeProp[cellType, $PWCoreSourceDesign]];
obj _ GetAndAddSuffix[source, CoreOps.GetCellTypeName[cellType]];
};

GetAndFlatten: LayoutProc = {
source: CD.Design _ NARROW [CoreProperties.GetCellTypeProp[cellType, $PWCoreSourceDesign]];
obj _ PW.Flatten[GetAndAddSuffix[source, CoreOps.GetCellTypeName[cellType]]];
};

Value: LayoutProc = {
obj _ NARROW [CoreProperties.GetCellTypeProp[cellType, $PWCoreValue]];
};

DecorateValue: PUBLIC DecorateProc = {
extractedCT: CellType _ NARROW [Sinix.Extract[obj, extractMode].result];
extractedToSource: HashTable.Table _ HashTable.Create[extractedCT.public.size];
FindInExtractedPublic: CoreOps.EachWireProc = {
FOR names: LIST OF ROPE _ CoreOps.GetFullWireNames[cellType.public, wire], names.rest WHILE names#NIL DO
name: ROPE _ names.first;
extractedWire: Wire _ CoreOps.FindWire[extractedCT.public, name];
previousSourceWire: Wire _ NARROW [HashTable.Fetch[extractedToSource, extractedWire].value];
IF extractedWire=NIL OR extractedWire.size#0 THEN LOOP;
IF previousSourceWire#NIL AND previousSourceWire#wire THEN SIGNAL PinsCorrespondingToSeveralPublics[cellType, obj, LIST [previousSourceWire, wire], CoreGeometry.GetPins[extractMode.decoration, extractedWire]];
IF NOT CoreGeometry.HasPins[extractMode.decoration, extractedWire] 
THEN SIGNAL NoPinsOnAtomicPublic[cellType, obj, extractedWire, name];
CoreGeometry.AddIndirectLazyPins[extractMode.decoration, wire, extractedWire];
[] _ HashTable.Store[extractedToSource, extractedWire, wire];
ENDLOOP;
};
CoreOps.VisitRootAtomics[cellType.public, SmashPins];
CoreGeometry.PutIR[extractMode.decoration, cellType, CD.InterestRect[obj]];
[] _ CoreOps.VisitWire[cellType.public, FindInExtractedPublic];
};
AttributeX: AttributesProc = {SortInstances[Sisyph.mode.decoration, cellType, SortInX]};

AttributeY: AttributesProc = {SortInstances[Sisyph.mode.decoration, cellType, SortInY]};

AbutX: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT DECREASING IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListX[subObjects];
};

AbutY: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT DECREASING IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListY[subObjects];
};

ReverseAbutX: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListX[subObjects];
};

ReverseAbutY: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListY[subObjects];
};

ArrayX: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutX]; obj _ Layout[recasted];
};

ArrayY: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutY]; obj _ Layout[recasted];
};

ReverseArrayX: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawReverseAbutX]; obj _ Layout[recasted];
};

ReverseArrayY: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawReverseAbutY]; obj _ Layout[recasted];
};

Recast: LayoutProc = {
obj _ Layout[CoreOps.Recast[cellType]];
};

DecorateAbut: PUBLIC PROC [cellType: CellType, obj: Object, sort: SortProc] = {
InsertInOrder: PROC [element: CD.Instance, sorted: LIST OF CD.Instance] RETURNS [new: LIST OF CD.Instance] = {
IF element.orientation#0 THEN ERROR Error[$CallerBug, "DecorateAbut is only applicable for CD Cells without rotations", cellType];
IF sorted=NIL THEN RETURN [LIST [element]];
IF sort[CDBasics.BaseOfRect[CDInstances.InstRectO[element]], CDBasics.BaseOfRect[CDInstances.InstRectO[sorted.first]]] THEN RETURN [CONS [element, sorted]];
RETURN [CONS [sorted.first, InsertInOrder[element, sorted.rest]]];
};
SetLazyPins: PROC [wire: Wire] = {CoreGeometry.PutRecordLazyPins[extractMode.decoration, wire, cellType]};
instances: LIST OF CD.Instance;
recordData: CoreClasses.RecordCellType _ NARROW [cellType.data];
WHILE obj.class#CDCells.cellClass DO obj _ CDDirectory.Expand[obj].new ENDLOOP;
CoreGeometry.PutIR[extractMode.decoration, cellType, CD.InterestRect[obj]];
FOR list: LIST OF CD.Instance _ NARROW [obj.specificRef, CD.CellPtr].contents, list.rest WHILE list#NIL DO
instances _ InsertInOrder[list.first, instances];
ENDLOOP;
FOR i: NAT IN [0 .. recordData.size) DO
CoreGeometry.PutTransf[extractMode.decoration, recordData[i], instances.first];
instances _ instances.rest;
ENDLOOP;
IF instances#NIL THEN ERROR Error[$CallerBug, "DecorateAbut assumption not valid: CD cell has more instances than record CellType", cellType];
CoreOps.VisitRootAtomics[cellType.public, SetLazyPins];
};

DecorateAbutX: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, SortInX];
};

DecorateAbutY: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, SortInY];
};

DecorateReverseAbutX: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, ReverseSortInX];
};

DecorateReverseAbutY: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, ReverseSortInY];
};

DecorateRecasted: PUBLIC DecorateProc = {
CopyDecorations[cellType, CoreOps.Recast[cellType], obj];
};
Rotated: PROC [cellType: CellType] RETURNS [rotatedCT: CellType] = {
rct: CoreClasses.RecordCellType;
IF cellType.class#CoreClasses.recordCellClass THEN ERROR Error[$CallerBug, "Rotation CellType expected [RecordCell with one instance]", cellType];
rct _ NARROW [cellType.data];
IF rct.size#1 THEN ERROR Error[$CallerBug, "Rotation CellType expected [RecordCell with one instance]", cellType];
rotatedCT _ rct[0].type;
IF NOT CoreOps.CorrectConform[cellType.public, rotatedCT.public] THEN ERROR Error[$CallerBug, "Rotation CellType expected [RecordCell with one instance]", cellType];
};

FlipX: LayoutProc = {obj _ PW.FlipX[Layout[Rotated[cellType]]]};

FlipY: LayoutProc = {obj _ PW.FlipY[Layout[Rotated[cellType]]]};

Rot90: LayoutProc = {obj _ PW.Rot90[Layout[Rotated[cellType]]]};

Rot180: LayoutProc = {obj _ PW.Rot180[Layout[Rotated[cellType]]]};

Rot270: LayoutProc = {obj _ PW.Rot270[Layout[Rotated[cellType]]]};

DecorateRotated: PUBLIC DecorateProc = {
rotatedCT: CellType = Rotated[cellType];
transf: CD.Instance;
CopyPinsFromRotated: PROC [wire1, wire2: Wire] = {
CoreGeometry.PutTransfWireIRLazyPins[
decoration: extractMode.decoration, public: wire1, indirect: wire2, transf: transf, ir: ir
];
};
instances: LIST OF CD.Instance;
ir: CD.Rect = CD.InterestRect[obj];
WHILE obj.class#CDCells.cellClass DO obj _ CDDirectory.Expand[obj].new ENDLOOP;
CoreGeometry.PutIR[extractMode.decoration, cellType, ir];
instances _ NARROW [obj.specificRef, CD.CellPtr].contents;
IF instances=NIL OR instances.rest#NIL THEN ERROR Error[$CallerBug, "DecorateRotated is not supposed to be called with an obj that does not expand into a one instance cell", cellType];
transf _ instances.first;
VisitAtomicPairs[cellType.public, rotatedCT.public, CopyPinsFromRotated];
};
SortInX: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.x<pos2.x]};
SortInY: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.y<pos2.y]};
ReverseSortInX: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.x>pos2.x]};
ReverseSortInY: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.y>pos2.y]};

InstanceLocation: PROC [decoration: CoreGeometry.Decoration, cellInst: CoreClasses.CellInstance] RETURNS [location: CD.Position] = {
location _ CDBasics.BaseOfRect[CDInstances.InstRectO[CoreGeometry.GetTransf[decoration, cellInst]]];
};

SortInstances: PUBLIC PROC [decoration: CoreGeometry.Decoration, cellType: CellType, sort: SortProc] = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
FOR i: NAT IN [0 .. data.size-1) DO
FOR j: NAT IN (i .. data.size) DO
IF ~sort[InstanceLocation[decoration, data[i]], InstanceLocation[decoration, data[j]]] THEN {
w: CoreClasses.CellInstance _ data[i]; 
data[i] _ data[j]; data[j] _ w;
};
ENDLOOP;
ENDLOOP;
};

DecorateFlatten: PUBLIC PROC [cellType: CellType, obj: Object, sort: PROC [CD.Position, CD.Position] RETURNS [BOOL]] = {
ir: CD.Rect _ CD.InterestRect[obj];
extractedCT: CellType _ NARROW [Sinix.Extract[obj, extractMode].result];
extractedToSource: HashTable.Table _ HashTable.Create[CoreOps.WireBits[extractedCT.public]]; -- table of publics of extracted to publics of source
extractedCTData: CoreClasses.RecordCellType _ NARROW [extractedCT.data];
cellTypeData: CoreClasses.RecordCellType _ NARROW [cellType.data];
positionnedInstances: LIST OF PositionnedInstance;
positionnedWires: LIST OF PositionnedWire;
DecorateActual: PROC [bindings: HashTable.Table, sourceActual, deepPublic: Wire] = {
wireBind: CoreFlat.FlatWire _ NARROW [HashTable.Fetch[bindings, deepPublic].value]; -- bindings=NIL would mean that extractedCT is a leaf, which is impossible
extractedActual: Wire;
wire: Wire;
FOR i: NAT IN [0 .. sourceActual.size) DO DecorateActual[bindings, sourceActual[i], deepPublic[i]] ENDLOOP;
IF deepPublic.size#0 THEN RETURN;
IF wireBind=NIL THEN ERROR Error[$InternalBug, "Internal invariant failed", cellType]; -- something is really wrong!
IF wireBind.flatCell#[] THEN ERROR Error[$InternalBug, "Internal invariant failed", cellType]; -- a deep internal wire
extractedActual _ wireBind.wire;
IF sourceActual.size#extractedActual.size THEN ERROR Error[$InternalBug, "Internal invariant failed", cellType];
wire _ NARROW [HashTable.Fetch[extractedToSource, extractedActual].value];
IF wire=sourceActual THEN RETURN;
IF wire#NIL THEN SIGNAL PinsCorrespondingToSeveralPublics[cellType, obj, LIST [wire, sourceActual], CoreGeometry.GetPins[extractMode.decoration, extractedActual]];
CoreGeometry.AddIndirectLazyPins[extractMode.decoration, sourceActual, extractedActual];
[] _ HashTable.Insert[extractedToSource, extractedActual, sourceActual];
};
[positionnedInstances, positionnedWires] _ GetPositionnedInstances[extractedCT, sort];
CoreGeometry.PutIR[extractMode.decoration, cellType, CD.InterestRect[obj]];
IF cellTypeData.size#GList.Length[positionnedInstances] THEN ERROR Error[$CallerBug, IO.PutFR["Mismatch between extracted layout (%g instances) and source description (%g instances)", IO.int[GList.Length[positionnedInstances]], IO.int[cellTypeData.size]], cellType];
CoreOps.VisitRootAtomics[cellType.public, SmashPins];
FOR i: NAT IN [0 .. cellTypeData.size) DO
positionnedInstance: PositionnedInstance = positionnedInstances.first;
cell: CellType = positionnedInstance.cell;
sourceCellType: CellType = NARROW [cell.data, LayoutData].cellType;
IF Layout[cellTypeData[i].type]#Layout[sourceCellType] THEN ERROR Error[$CallerBug, IO.PutFR["Mismatch between the %gth instance of the extracted layout and the %gth instance of the source description: cellTypes are different", IO.int[i], IO.int[i]], cellType];
CoreGeometry.PutTransf[extractMode.decoration, cellTypeData[i], positionnedInstance.transf];
IF ~ CoreOps.CorrectConform[cellTypeData[i].actual, cell.public] THEN ERROR Error[$InternalBug, "Call Implementor!", cellType];
FOR j: NAT IN [0 .. cell.public.size) DO
DecorateActual[positionnedInstance.bindings, cellTypeData[i].actual[j], cell.public[j]];
ENDLOOP;
positionnedInstances _ positionnedInstances.rest;
ENDLOOP;
WHILE positionnedWires#NIL DO
positionnedWire: PositionnedWire = positionnedWires.first;
wire: Wire = positionnedWire.wire;
flatWire: CoreFlat.FlatWireRec = positionnedWire.flatWire;
name: ROPE = CoreOps.GetShortWireName[wire];
source: Wire _ NARROW [HashTable.Fetch[extractedToSource, flatWire.wire].value];
IF flatWire.flatCell#[] THEN ERROR Error[$InternalBug, "Call implementor!", cellType]; -- not yet implemented if it is not part of the internal of extractedCT
IF source=NIL THEN source _ CoreOps.FindWire[cellTypeData.internal, name];
IF source=NIL THEN SIGNAL Signal[cellType];
IF source#NIL AND CoreOps.RecursiveMember[cellType.public, source] THEN FOR list: LIST OF CD.Instance _ positionnedWire.geometry, list.rest WHILE list#NIL DO
IF NOT CoreGeometry.AtEdge[ir, list.first] THEN LOOP;
CoreGeometry.PutPins[
extractMode.decoration, source, 
CONS [list.first, CoreGeometry.GetPins[extractMode.decoration, source]]
];
ENDLOOP;
positionnedWires _ positionnedWires.rest;
ENDLOOP;
};

PositionnedInstance: TYPE = REF PositionnedInstanceRec;
PositionnedInstanceRec: TYPE = RECORD [
cell: CellType, 		-- flat CT (of class layoutClass)
flatCell: CoreFlat.FlatCellTypeRec,
bindings: CoreFlat.Bindings, 	-- [public of cellType -> CoreFlat.WireBind] 
transf: CD.Instance
];

PositionnedWire: TYPE = REF PositionnedWireRec;
PositionnedWireRec: TYPE = RECORD [
wire: Wire, 
flatWire: CoreFlat.FlatWireRec,
geometry: LIST OF CD.Instance
];

GetPositionnedInstances: PROC [extractedCT: CellType, sort: SortProc] RETURNS [positionnedInstances: LIST OF PositionnedInstance _ NIL, positionnedWires: LIST OF PositionnedWire _ NIL] = {
InsertInOrdered: PROC [element: PositionnedInstance, sorted: LIST OF PositionnedInstance] RETURNS [new: LIST OF PositionnedInstance] = {
IF sorted=NIL THEN RETURN [LIST [element]];
IF sort[CDBasics.BaseOfRect[CDInstances.InstRectO[element.transf]], CDBasics.BaseOfRect[CDInstances.InstRectO[sorted.first.transf]]] THEN RETURN [CONS [element, sorted]];
RETURN [CONS [sorted.first, InsertInOrdered[element, sorted.rest]]];
};
Leaf: CoreGeometry.LeafProc = {RETURN [cellType.class=layoutClass]};
EachFlatWire: CoreGeometry.EachFlatWireProc = {
positionnedWires _ CONS [
NEW [PositionnedWireRec _ [wire: wire, flatWire: flatWire, geometry: geometry]], 
positionnedWires];
};
EachFlatCell: CoreGeometry.EachFlatCellProc = {
positionnedInstances _ CONS [
NEW [PositionnedInstanceRec _ [
cell: cell, flatCell: flatCell, bindings: bindings, transf: transf
]], 
positionnedInstances];
};
Compare: GList.CompareProc = {
pi1: PositionnedInstance = NARROW [ref1];
pi2: PositionnedInstance = NARROW [ref2];
RETURN [IF sort[CDBasics.BaseOfRect[CDInstances.InstRectO[pi1.transf]], CDBasics.BaseOfRect[CDInstances.InstRectO[pi2.transf]]] THEN less ELSE greater];
};
CoreGeometry.EnumerateFlatGeometry[decoration: extractMode.decoration, root: extractedCT, leafProc: Leaf, eachFlatWire: EachFlatWire, eachFlatCell: EachFlatCell];
positionnedInstances _ NARROW [GList.Sort[positionnedInstances, Compare]];
};
SetLayout: PUBLIC PROC [cellType: CellType, layoutAtom: ATOM, userDataProp: ATOM _ NIL, userData: REF _ NIL] = {
CoreProperties.PutCellTypeProp[cellType, layoutAtomProp, layoutAtom];
IF userDataProp#NIL THEN CoreProperties.PutCellTypeProp[cellType, userDataProp, userData];
};

SetLayoutAndDecoration: PUBLIC PROC [cellType: CellType, layout: CD.Object] = {
SetLayout[cellType, $ValueNoDecorate, $PWCoreValue, layout];
};

RotateCellType: PUBLIC PROC [rotatedCellType: CellType, orientation: ATOM] RETURNS [cellType: CellType] = {
public: Wire = CoreOps.CreateWires[size: rotatedCellType.public.size];
internal: Wire = CoreOps.CreateWires[size: rotatedCellType.public.size];
FOR i: NAT IN [0 .. rotatedCellType.public.size) DO
new: Wire = CopyWire[rotatedCellType.public[i]];
public[i] _ internal[i] _ new;
ENDLOOP;
cellType _ CoreClasses.CreateRecordCell[public: public, internal: internal, instances: LIST [CoreClasses.CreateInstance[actual: internal, type: rotatedCellType]]];
SetLayout[cellType, orientation];
};
AbutCell: PUBLIC PROC [public: Wire, abutInstances: LIST OF AbutInstance, inX: BOOL, name: ROPE _ NIL, props: Properties _ NIL] RETURNS [recordCell: CellType] = {
positionnedInstances: LIST OF PositionnedInstance _ NIL;
ObjectsFromAbutInstances: PROC [abutInstances: LIST OF AbutInstance] RETURNS [LIST OF Object] = {
IF abutInstances=NIL THEN RETURN [NIL];
BEGIN
obj: Object _ abutInstances.first.object; -- to allow 2 instances of the same object to have different bindings
ct: CellType _ FromLayoutWithoutPublic[obj];
RETURN [CONS [Layout[ct], ObjectsFromAbutInstances[abutInstances.rest]]];
END;
};
RegisterExtractedToSource: PROC [extracted, source: Wire, checkPins: BOOL] = {
prevAct: Wire _ NARROW [HashTable.Fetch[extractedToSource, extracted].value];
IF extracted.size#source.size THEN ERROR Error[$CallerBug, "Extracted wire and truth public do not have same structure.  You may call implementor for help!", extractedCT];
FOR i: NAT IN [0 .. extracted.size) DO RegisterExtractedToSource[extracted[i], source[i], checkPins] ENDLOOP;
IF prevAct=source THEN RETURN;
IF prevAct#NIL THEN SIGNAL PinsCorrespondingToSeveralPublics[extractedCT, obj, LIST [prevAct, source], CoreGeometry.GetPins[extractMode.decoration, extracted]]; 
[] _ HashTable.Store[extractedToSource, extracted, source];
IF source.size#0 THEN RETURN;
IF checkPins AND NOT CoreGeometry.HasPins[extractMode.decoration, extracted] 
THEN IF checkPins THEN SIGNAL NoPinsOnAtomicPublic[extractedCT, obj, extracted] ELSE RETURN; -- sub-public should have pins!
CoreGeometry.AddIndirectLazyPins[extractMode.decoration, source, extracted];
};
Replace: PROC [extractedWire: Wire] RETURNS [wire: Wire] = {
wire _ NARROW [HashTable.Fetch[extractedToSource, extractedWire].value];
IF wire#NIL THEN RETURN;
wire _ CoreOps.CreateWires[size: extractedWire.size];
internals _ CONS [wire, internals];
FOR i: NAT IN [0 .. extractedWire.size) DO
wire[i] _ Replace[extractedWire[i]];
ENDLOOP;
RegisterExtractedToSource[extractedWire, wire, FALSE];
};
CheckPinsNonNil: PROC [wire: Wire] = {
IF NOT CoreGeometry.HasPins[extractMode.decoration, wire] 
THEN SIGNAL NoPinsOnAtomicPublic[extractedCT, obj, wire, "Some atomic publics have no associated geometry, probably because you forgot to specify in each abutInstance the sub-public bound to it."];
};
internals: Wires _ LIST [public];
instances: LIST OF CoreClasses.CellInstance;
obj: Object _ (IF inX THEN PW.AbutListX ELSE PW.AbutListY)[ObjectsFromAbutInstances[abutInstances]];
extractedCT: CellType _ NARROW [Sinix.Extract[obj, extractMode].result];
extractedData: CoreClasses.RecordCellType _ NARROW [extractedCT.data];
extractedToSource: HashTable.Table _ HashTable.Create[CoreOps.WireBits[public]];
i: NAT _ 0;
CoreOps.VisitRootAtomics[public, SmashPins];
SortInstances[extractMode.decoration, extractedCT, IF inX THEN SortInX ELSE SortInY];
FOR list: LIST OF AbutInstance _ abutInstances, list.rest WHILE list#NIL DO
instance: CoreClasses.CellInstance = extractedData[i];
FOR pas: LIST OF CoreCreate.PA _ list.first.pas, pas.rest WHILE pas#NIL DO
pub: Wire = CoreCreate.FindWire[instance.type.public, pas.first.public];
act: Wire = CoreCreate.FindWire[public, pas.first.actual];
IF pub=NIL THEN ERROR Error[$CallerBug, "Some public specified in some PA in your call to AbutCell is not really a public of the cellTYpe.  You may call the maintainor of this package for help!", extractedCT];
IF act=NIL THEN ERROR Error[$CallerBug, "Call implementor for help!", extractedCT];
RegisterExtractedToSource[CoreClasses.CorrespondingActual[instance, pub], act, TRUE];
ENDLOOP;
i _ i + 1;
ENDLOOP;
IF i#extractedData.size THEN Error[$CallerBug, "Call implementor for help!", extractedCT];
CoreOps.VisitRootAtomics[public, CheckPinsNonNil];
FOR i: NAT DECREASING IN [0 .. extractedData.size) DO
actual: Wire _ CoreOps.CreateWires[size: extractedData[i].actual.size];
FOR j: NAT IN [0 .. extractedData[i].actual.size) DO
actual[j] _ Replace[extractedData[i].actual[j]];
ENDLOOP;
instances _ CONS [CoreClasses.CreateInstance[actual: actual, type: extractedData[i].type, props: extractedData[i].properties], instances];
ENDLOOP;
recordCell _ CoreClasses.CreateRecordCell[public, CoreOps.CreateWire[internals], instances, name, props];
CoreGeometry.PutIR[extractMode.decoration, recordCell, CD.InterestRect[obj]];
SetLayoutAndDecoration[recordCell, obj];
};

AbutList: PUBLIC PROC [cellTypes: LIST OF CellType, inX: BOOL] RETURNS [recordCell: CellType] = {
lobj: LIST OF CD.Object _ NIL;
WHILE cellTypes#NIL DO
ct: CellType _ cellTypes.first;
obj: CD.Object _ CDCells.CreateEmptyCell[];
CDCells.SetInterestRect[obj, InterestRect[ct]];
CDProperties.PutObjectProp[obj, $PWCoreCellType, ct];
CDProperties.PutObjectProp[obj, extractMode.extractProcProp, $FakeExtract];
lobj _ CONS [obj, lobj];
cellTypes _ cellTypes.rest;
ENDLOOP;
recordCell _ NARROW [Sinix.Extract[(IF inX THEN PW.AbutListX ELSE PW.AbutListY)[PW.Reverse[lobj]], extractMode].result];
SetLayout[recordCell, IF inX THEN $AbutListXNoDecorate ELSE $AbutListYNoDecorate];
};
layoutClass: PUBLIC Core.CellClass _ NEW [Core.CellClassRec _ [name: "Layout", recast: RecastLayout]];

RecastLayout: Core.RecastProc = {
FillTable: PROC [extractedWire: Wire] = {
FillTableInternal: PROC [sourcePublic, newPublic: Wire] = {
prevSource: Wire;
sourcePins: LIST OF CD.Instance _ CoreGeometry.GetPins[data.mode.decoration, sourcePublic];
CoreGeometry.PutPins[data.mode.decoration, sourcePublic, sourcePins]; -- to avoid all that lazyness
IF NOT CoreGeometry.TouchListList[sourcePins, extractedPins] THEN RETURN;
prevSource _ NARROW [HashTable.Fetch[table, extractedWire].value];
IF prevSource#NIL AND prevSource#newPublic THEN SIGNAL PinsCorrespondingToSeveralPublics[data.cellType, data.obj, LIST [prevSource, sourcePublic], extractedPins];
[] _ HashTable.Store[table, extractedWire, newPublic];
[] _ HashTable.Store[extractedToSource, extractedWire, sourcePublic];
};
extractedPins: LIST OF CD.Instance _ CoreGeometry.GetPins[data.mode.decoration, extractedWire];
VisitAtomicPairs[data.cellType.public, public, FillTableInternal];
};
recordData: CoreClasses.RecordCellType;
data: LayoutData _ NARROW [me.data];
extractedCT: CellType _ NARROW [Sinix.Extract[data.obj, data.mode].result];
public: Wire = CopyWire[me.public];
table: HashTable.Table _ HashTable.Create[];
extractedToSource: HashTable.Table _ HashTable.Create[];
CoreOps.VisitRootAtomics[extractedCT.public, FillTable];
new _ CoreClasses.CreatePermutedRecordCell[iconPublic: public, schCell: extractedCT, table: table, name: Rope.Cat["LayoutRecastOf", CoreOps.GetCellTypeName[data.cellType]]];
recordData _ NARROW [new.data];
IF recordData.size#1 THEN ERROR Error[$InternalBug, "Internal invariant failed", data.cellType]; 
CoreProperties.PutCellTypeProp[extractedCT, $ExtractedToSource, extractedToSource];
CoreGeometry.PutTransf[data.mode.decoration, recordData[0], CDInstances.NewInst[data.obj]];
};

LayoutCellTypeInfo: PUBLIC PROC [layoutCellType: CellType] RETURNS [obj: Object, sourceCellType, extractedCellType: CellType, extractedToSource: HashTable.Table] = {
data: LayoutData _ NARROW [layoutCellType.data];
obj _ data.obj;
sourceCellType _ data.cellType;
extractedCellType _ NARROW [CoreOps.Recast[layoutCellType].data, CoreClasses.RecordCellType][0].type;
extractedToSource _ NARROW [CoreProperties.GetCellTypeProp[extractedCellType, $ExtractedToSource]];
};

CorrespondingCellType: PUBLIC PROC [obj: Object] RETURNS [layoutCellType: CellType _ NIL] = {
IF CDProperties.GetObjectProp[obj, extractMode.extractProcProp]=$FakeExtract THEN layoutCellType _ NARROW [CDProperties.GetObjectProp[obj, $PWCoreCellType]];
};
Sinix.RegisterExtractProc[$FakeExtract, FakeExtract];

[] _ RegisterLayoutAtom[$Get, Get, DecorateValue];
[] _ RegisterLayoutAtom[$GetAndFlatten, GetAndFlatten, DecorateValue];
[] _ RegisterLayoutAtom[$Value, Value, DecorateValue];
[] _ RegisterLayoutAtom[$ValueNoDecorate, Value];
[] _ RegisterLayoutAtom[$AbutListXNoDecorate, AbutX];
[] _ RegisterLayoutAtom[$AbutListYNoDecorate, AbutY];
[] _ RegisterLayoutAtom[$RawAbutX, AbutX, DecorateAbutX];
[] _ RegisterLayoutAtom[$RawAbutY, AbutY, DecorateAbutY];
[] _ RegisterLayoutAtom[$RawReverseAbutX, ReverseAbutX, DecorateReverseAbutX];
[] _ RegisterLayoutAtom[$RawReverseAbutY, ReverseAbutY, DecorateReverseAbutY];
[] _ RegisterLayoutAtom[$AbutX, AbutX, DecorateAbutX, AttributeX];
[] _ RegisterLayoutAtom[$AbutY, AbutY, DecorateAbutY, AttributeY];
[] _ RegisterLayoutAtom[$ReverseAbutX, ReverseAbutX, DecorateReverseAbutX, AttributeX];
[] _ RegisterLayoutAtom[$ReverseAbutY, ReverseAbutY, DecorateReverseAbutY, AttributeY];
[] _ RegisterLayoutAtom[$ArrayX, ArrayX, DecorateRecasted];
[] _ RegisterLayoutAtom[$ArrayY, ArrayY, DecorateRecasted];
[] _ RegisterLayoutAtom[$ReverseArrayX, ReverseArrayX, DecorateRecasted];
[] _ RegisterLayoutAtom[$ReverseArrayY, ReverseArrayY, DecorateRecasted];
[] _ RegisterLayoutAtom[$Recast, Recast, DecorateRecasted];
[] _ RegisterLayoutAtom[$FlipX, FlipX, DecorateRotated];
[] _ RegisterLayoutAtom[$FlipY, FlipY, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot90, Rot90, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot180, Rot180, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot270, Rot270, DecorateRotated];

END.
*PWCoreImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Louis Monier May 17, 1986 1:35:25 pm PDT
Bertrand Serlet November 7, 1986 5:22:24 pm PST
Barth, April 22, 1986 7:30:28 pm PST
Spreitzer, April 11, 1986 10:52:25 am PST
Last Edited by: Louis Monier October 20, 1986 3:30:17 pm PDT
Soon in Core ?
Exceptions
LayoutAtomsTable
Primitives
copies decorations from from to to
We check that the public of the source and the public of the recasted layout are similar, and we copy properties from one to the other
We compute the attributes (if any)
Now the layout
Now we decorate the source cellType
We decorate layoutCellType with the same decorations, and on the way check those decorations
We make an indirect object to allow the same layout to be returned on 2 different calls of Layout
Consistency check

Global Variable
$Get, $GetAndFlatten, $Value and $ValueNoDecorate
Abuts, Arrays and Recast
We decorate each instance with the appropriate transf, so that the Lazy GetPins can find the location
Rotations
We check that the public of the source and the public of the recasted layout are similar, and we copy properties from one to the other
Help for writing DecorateProcs
We copy the pins for all publics.  For now, we only do it for wires which have the same name as some internal of cellType.
All this code stinks ....
The following line is to pass PWCoreRoute test
All this code stinks ....
If source is NIL, crash!
If it is an internal only, let's forget it!
positionnedInstances is the sorted list of all instances that have associated layout.
positionnedWires is the list of all wires having their own geometry. 
Short cut
Tentative help for regular structures
We check now that every atomic public has pins
We replace the actuals
Backdoor for clients such as PWCoreLichen
Registering layoutAtoms

สฎ˜™Icodešœ
ฯm
œ1™<K™(K™/K™$K™)K™<—J˜š
ฯk	˜	KšžœG˜IK˜Kš
œB˜BK˜
Kšœžœ˜Kšžœ˜Kš
œ˜Kš
œ˜—K˜šะbn
œžœ
ž˜Kšžœ
žœ
žœžœ*˜ษ
Kšžœ˜Kšžœ˜Kšžœ
žœ˜—
head™šฯnœžœ žœ˜Lš 
œžœ˜,Kšžœžœ
žœ
˜$šžœ˜Kšžœ˜Kšžœ
žœžœ
žœžœ#žœ
˜R—K˜—Kšžœžœ
žœ
˜$Kš
žœžœ
žœžœ#žœ
˜MK˜K˜—š 
œ˜$Kšœžœ"˜,Kšœžœ
˜Kš
œ*˜*Kš
œ˜—š œžœ
žœ˜2K˜Kš
œ(˜(K˜——™
š œžœ
žœžœ
˜2J˜—š œžœ
žœžœžœžœ
˜KJ˜—š !œžœ
žœ=žœ
žœ
žœ
žœ
˜‰
J˜—š œžœ
žœ:žœžœžœ
˜pJ˜—Jš œžœ
žœ%žœ
˜Q—š
œ™Jš
œ7˜7J˜Kšœžœžœ˜-KšœžœžœWžœ˜|K˜š œžœ
žœžœ7žœ#žœžœžœ˜ฏ
Kš
œ˜šžœ0žœm˜ข
Kšžœ
žœ<žœ˜X—K˜K˜—š œžœ
žœžœžœžœžœ#žœ˜ฌ
Kšœ!žœ7˜^Kšžœžœ
žœ
žœ
˜"Kš
œ(˜(Kš
œ,˜,Kš
œ/˜/K˜——š
œ
™
šœžœ
žœ,˜GJ˜—š 
œžœ
žœžœžœžœ˜TKšœ
žœ<˜OKšžœžœ
žœ
žœ
˜Kšœ
žœC˜VK˜K˜—šœะbkœ
žœ3ฯc˜`K˜—š œR˜]K˜—š 	œžœDžœ˜YK˜—Kš
œ"™"š œžœ&˜;š œžœ˜+šžœ
žœ8˜>Jšžœ
žœ[˜f—Jš
œK˜KK˜—Kš
Ϡ
™†
Kš
œ/˜/Kšœ/žœ˜EKš
œ3˜3K˜K˜—š œžœ
žœžœ˜BKšœžœ8˜DKšžœžœ
žœ
žœ
˜š
ž˜Kšœžœ˜+Kš
œ˜Kš
œ˜K˜šžœžœ
˜šžœ
žœžœ
˜"Kšžœ
žœU˜_šžœ˜Kš
œ.˜.Kš
œ˜Kš
œ)˜)Kšžœ
˜K˜———Kšœžœ7˜NKšžœžœ
žœ
žœžœ0žœ˜Š
K™"Kšžœžœ
žœ)˜RK™Kš
œ*˜*Kšœ
žœF˜VKš
œq˜qKš
œ#™#Kšžœžœ
žœ,˜SKš
œ\™\Kšžœ
žœ6žœ6žœžœ
žœ)˜ฝ
Kš
œ/˜/Kš
œa™aKš
œ$˜$Kš
œA˜AKš
œK˜KKš
œ:˜:Jšžœ#žœ
žœžœ
žœ
žœžœM˜พ
Jš
œ™Jšžœ7žœ
žœ<˜Kšžœ+žœ
žœ=˜tKšžœ
˜—Kš
œ˜—K˜š
 œžœ
žœžœžœ
˜HJšžœ
žœ6žœ˜WJš
œ:˜:J˜J™—š œžœ
žœžœ˜SJšœžœ*˜;Kš
œ&˜&K˜——™Jšœ
žœ.˜A—š
œ1™1šœžœ
žœ˜"J˜—š
 œžœ
žœžœžœ˜OJš	œžœ
žœžœ
žœ˜BJ˜J˜—šŸœ˜Kšœžœ
žœA˜[Jš
œA˜AK˜K˜—š 
œ˜Kšœžœ
žœA˜[JšœžœE˜MK˜K˜—š œ˜Kšœžœ:˜FK˜K˜—š 
œžœ˜&Jšœžœ*˜HJš
œO˜OšŸœ˜/š
žœžœ
žœ
žœ?žœžœ
ž˜hKšœžœ˜Kš
œA˜AKšœžœ;˜\Kš
žœžœ
žœžœ
žœ
˜7Kšžœžœ
žœžœ
žœ2žœZ˜ั
šžœ
žœ=˜CJšžœ
žœ:˜E—Jš
œN˜NKš
œ=˜=Kšžœ
˜—J˜—Kš
œ5˜5Kšœ5žœ˜KJš
œ?˜?Kš
œ˜——™š 
œN˜XK˜—š 
œN˜XK˜—šŸœ˜Kšœ#žœ˜:Kšœžœ
žœ
žœ
˜!š	žœžœ
ž
œ
žœž˜,Kšœ
žœ$˜5Kšžœ
˜—Jšœžœ˜K˜K˜—šŸœ˜Kšœ#žœ˜:Kšœžœ
žœ
žœ
˜!š	žœžœ
ž
œ
žœž˜,Kšœ
žœ$˜5Kšžœ
˜—Jšœžœ˜K˜K˜—šŸœ˜Kšœ#žœ˜:Kšœžœ
žœ
žœ
˜!šžœžœ
žœž˜!Kšœ
žœ$˜5Kšžœ
˜—Jšœžœ˜K˜K˜—šŸœ˜Kšœ#žœ˜:Kšœžœ
žœ
žœ
˜!šžœžœ
žœž˜!Kšœ
žœ$˜5Kšžœ
˜—Jšœžœ˜K˜K˜—šŸœ˜Kš
œ.˜.Kš
œ7˜7K˜K˜—šŸœ˜Kš
œ.˜.Kš
œ7˜7K˜K˜—šŸ
œ˜Kš
œ.˜.Kš
œ>˜>K˜K˜—šŸ
œ˜Kš
œ.˜.Kš
œ>˜>K˜K˜—šŸœ˜Kš
œ'˜'K˜K˜—š œžœ
žœ6˜Oš 
œžœžœžœ
žœ
žœžœžœ
žœ
žœ˜nKšžœžœ
žœ_˜‚
Kš
žœžœ
žœ
žœžœ˜+Kšžœužœ
žœžœ˜œ
Kšžœžœ6˜BK˜—Kš œžœY˜jKšœžœ
žœ
žœ
˜Jšœ)žœ˜@Kšžœžœ#žœ
˜OKšœ5žœ˜Kšžœžœ
žœ
žœžœžœžœžœ
ž˜jKš
œ1˜1Kšžœ
˜—Jš
œe™ešžœžœ
žœž˜'Jš
œO˜OJš
œ˜Jšžœ
˜—Jšžœžœ
žœ
žœs˜Ž
Jš
œ7˜7K˜K˜—š 
œžœ˜&Kš
œ%˜%Kš
œ˜K˜—š 
œžœ˜&Kš
œ%˜%Kš
œ˜K˜—š œžœ˜-Kš
œ,˜,Kš
œ˜K˜—š œžœ˜-Kš
œ,˜,Kš
œ˜K˜—šŸœžœ˜)Kš
œ9˜9Kš
œ˜——™	š œžœžœ˜DJš
œ ˜ Jšžœ,žœ
žœZ˜’
Jšœžœ˜Jšžœžœ
žœZ˜rJš
œ˜Jšžœ
žœ;žœ
žœZ˜ฅ
J˜K˜—šŸœžœ#˜@K˜—šŸœžœ#˜@K˜—šŸœžœ#˜@K˜—šŸœžœ$˜BK˜—šŸœžœ$˜BK˜—šŸœžœ˜(Jš
œ(˜(Kšœžœ
˜š œžœ˜2š
œ%˜%Kš
œZ˜ZKš
œ˜—K˜—Kšœžœ
žœ
žœ
˜Kšœžœžœ˜#Kšžœžœ#žœ
˜OKš
œ9˜9Kšœžœžœ˜:Kšžœžœ
žœžœ
žœ
žœ‡
˜ธ
Jš
œ˜Kš
Ϡ
™†
Kš
œI˜IK˜——™Kš œžœ
žœžœžœžœžœ˜YKš œžœ
žœžœžœžœžœ˜YKš œžœ
žœžœžœžœžœ˜`š œžœ
žœžœžœžœžœ˜`K˜—š œžœKžœžœ˜„
Kš
œd˜dK˜K˜—š 
œžœ
žœN˜hKšœ#žœ˜:šžœžœ
žœž˜#šžœžœ
žœž˜!šžœUžœ˜]Kš
œ'˜'Kš
œ˜Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š œžœ
žœ)žœžœžœžœžœ˜xJšœžœžœ˜#Jšœžœ*˜HKšœ]ข5˜’
Kšœ.žœ˜HKšœ+žœ˜BKšœžœ
žœ˜2Kšœžœ
žœ˜*š œžœ@˜TJšœžœ0ขJ˜ž
Jš
œ˜Kš
œ˜Kš
žœžœ
žœžœ:žœ
˜kKšžœžœ
žœ
˜!Kš	žœ
žœ
žœ
žœ=ข˜tKšžœžœ
žœ=ข˜vJš
œ ˜ Kšžœ(žœ
žœ<˜pKšœžœ=˜JKšžœžœ
žœ
˜!Kš
žœžœ
žœ
žœ2žœV˜ฃ
Jš
œX˜XKš
œH˜HK˜—Kš
œV˜VKšœ5žœ˜KKšžœ6žœ
žœžœažœ*žœ$˜ŠKš
œ5˜5šžœžœ
žœž˜)Kš
œF˜FKš
œ*˜*Kšœžœ"˜CKšžœ5žœ
žœžœŽ
žœ	žœ˜…Kš
œ\˜\Kšžœ?žœ
žœ4˜šžœžœ
žœž˜(Kš
œX˜XKšžœ
˜—Kš
œ1˜1Kšžœ
˜—Kš
œz™zKš
œ™šžœžœ
ž˜Kš
œ:˜:Kš
œ"˜"Kš
œ:˜:Kšœžœ"˜,Kšœžœ;˜PKšžœžœ
žœ5ขG˜ž
K™.Kš
œ™Kšžœžœ
žœ8˜JKš
œ™Kšžœžœ
žœ
žœ˜+Kš
œ+™+šžœžœ
žœ2žœ
žœžœ
žœ
žœ0žœžœ
ž˜
Jšžœ
žœ%žœ
žœ
˜5š
œ˜Jš
œ ˜ JšžœC˜GJš
œ˜—Kšžœ
˜—Kš
œ)˜)Kšžœ
˜—K˜K˜—Kšœžœžœ˜7šœžœžœ˜'Kšœข!˜3Kš
œ#˜#Kšœข-˜KKšœžœ	˜K˜K˜—Kšœžœžœ˜/šœžœžœ˜#Jš
œ˜Kš
œ˜Kšœ
žœ
žœ
žœ	˜K˜K˜—Kš
œU™UKš
œE™Eš œžœ)žœžœ
žœžœžœ
žœžœ˜ผ
š œžœ(žœ
žœžœžœ
žœ˜ˆ
Kš
žœžœ
žœ
žœžœ˜+Kšžœƒ
žœ
žœžœ˜ช
Kšžœžœ8˜DK˜—Jš œžœ˜Dš œ#˜/šœžœ˜JšžœN˜QJš
œ˜—J˜—š œ#˜/šœžœ˜šžœ˜Jš
œB˜BJš
œ˜—Jš
œ˜—J˜—š œ˜Jšœžœ˜)Jšœžœ˜)Jšžœžœvžœžœ
˜˜
J˜—Jš
œข
˜ข
Kšœžœ-˜JK˜——™	š 	œžœ
žœ"žœžœžœžœžœ˜pKš
œE˜EKšžœžœ
žœB˜ZKš
œ˜K˜—š œžœ
žœžœ˜OKš
œ<˜<K˜K˜—š
 œžœ
žœ*žœžœ˜kKš
œF˜FKš
œH˜Hšžœžœ
žœ$ž˜3Kš
œ0˜0Kš
œ˜Kšžœ
˜—K•StartOfExpansion`[actual: 
Core.Wire, type: 
Core.CellType, name: 
ROPE _ NIL, props: 
Core.Properties _ NIL]šœWžœH˜ฃ
Kš
œ!˜!K˜——™%š œžœ
žœžœ
žœžœžœžœžœžœ˜ข
Kšœžœ
žœžœ
˜8š œžœžœ
žœžœžœ
žœ˜aKš
žœžœ
žœ
žœžœ˜'š
ž˜Kšœ*ขE˜oKš
œ,˜,Kšžœžœ=˜IKšžœ
˜—K˜—š œžœ&žœ˜NKšœžœ7˜MKšžœžœ
žœƒ
˜ซ
Kš
žœžœ
žœžœ?žœ
˜mKšžœžœ
žœ
˜Kš
žœ	žœ
žœ
žœ5žœN˜ก
Kš
œ;˜;Kšžœžœ
žœ
˜šžœžœ
žœ9˜MJš
žœ
žœžœ
žœ3žœ
žœข˜|—Jš
œL˜LK˜—š œžœžœ˜<Kšœžœ;˜HKšžœžœ
žœ
žœ
˜J˜5Jšœžœ˜#šžœžœ
žœž˜*J˜$Jšžœ
˜—Jšœ/žœ˜6J˜—š œžœ˜&šžœ
žœ4˜:Kšžœ
žœบ
˜ล
—K˜—Kšœžœ
˜!Kšœžœ
žœ˜,Kšœžœžœ
žœžœ
žœ5˜dJšœžœ*˜HKšœ,žœ˜FKš
œP˜PKšœžœ˜Kš
œ,˜,Kšœ3žœžœ	žœ
˜Ušžœžœ
žœ)žœžœ
ž˜KKš
œ6˜6š
žœžœ
žœžœžœžœ
ž˜JKš
œH˜HKš
œ:˜:Kšžœžœ
žœ
žœผ
˜ั
Kšžœžœ
žœ
žœ>˜SJšœOžœ˜UKšžœ
˜—K˜
Kšžœ
˜—Kšžœžœ>˜ZKš
œ.™.Kš
œ2˜2J™š	žœžœ
ž
œ
žœž˜5Jš
œG˜Gšžœžœ
žœ%ž˜4Jš
œ0˜0Jšžœ
˜—Jšœžœz˜Š
Jšžœ
˜—Jš
œi˜iKšœ7žœ˜MKš
œ(˜(K˜K˜—š œžœ
žœ
žœ
žœžœžœ˜aJš	œžœ
žœ
žœ
žœ
˜šžœžœ
ž˜Jš
œ˜Jšœžœ$˜+Jš
œ/˜/Jš
œ5˜5Jš
œK˜KJšœžœ
˜Jš
œ˜Jšžœ
˜—Jšœ
žœžœžœ
žœžœ
žœžœ&˜xJšœžœžœžœ˜RK˜——™)šœ
žœžœ>˜fJ˜—š œ˜!š 	œžœ˜)š œžœ$˜;J˜Jšœžœ
žœ
žœE˜[JšœFข˜cJšžœ
žœ7žœ
žœ
˜IJšœ
žœ/˜BJšžœžœ
žœžœ
žœ<žœ,˜ข
Jš
œ6˜6Jš
œE˜EJ˜—Jšœžœ
žœ
žœF˜_Jš
œB˜BJ˜—J˜'Jšœžœ˜$Jšœžœ-˜KJš
œ#˜#Jš
œ,˜,Jš
œ8˜8Jš
œ8˜8Jš
œญ
˜ญ
Jšœ
žœ˜Kšžœžœ
žœB˜aJš
œS˜SJš
œ[˜[J˜J˜—š œžœ
žœžœc˜ฅ
Jšœžœ˜0Jš
œ˜Jš
œ˜JšœžœK˜eJšœžœI˜cJ˜J˜—š
 œžœ
žœžœžœ˜]KšžœKžœžœ4˜
K˜——š œ™Jš
œ5˜5J˜Jš
œ2˜2Jš
œF˜FJš
œ6˜6Jš
œ1˜1Jš
œ5˜5Jš
œ5˜5Jš
œ9˜9Jš
œ9˜9Jš
œN˜NJš
œN˜NJš
œB˜BJš
œB˜BJš
œW˜WJš
œW˜WJš
œ;˜;Jš
œ;˜;Jš
œI˜IJš
œI˜IJš
œ;˜;Jš
œ8˜8Jš
œ8˜8Jš
œ8˜8Jš
œ:˜:Jš
œ:˜:—J˜Kšžœ
˜K™—…—{~ŸV