DIRECTORY
CD,
CDBasics,
CDCells,
CDCellsInteractions,
CDCommandOps,
CDCurves,
CDDirectory,
CDImports,
CDInstances,
CDIO,
CDOps,
CDProperties,
CDPropertyTools,
CDSatellites,
CDSequencer,
CDTexts,
CDVArrow,
CStitching,
FS,
IO,
List USING [Append],
Rope,
TerminalIO;
  
BrandyCIFter: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCells, CDCellsInteractions, CDCurves, CDCommandOps, CDDirectory, CDImports, CDInstances, CDIO, CDOps, CDProperties, CDPropertyTools, CDSatellites, CDSequencer, CDTexts, CDVArrow, CStitching, FS, IO, List, Rope, TerminalIO =
BEGIN

CIFUnits: TYPE = CD.Number;
CIFPos: TYPE = CD.Position -- in CIFUnits -- ;
CIFRect: TYPE = CD.Rect -- in CIFUnits -- ;
Rational: TYPE = RECORD [num, denom: INT _ 1];
CIFDest: TYPE = REF CIFDestRec _ NIL;
CIFDestRec: TYPE = RECORD [
cifDest: Rope.ROPE,
deltaRadius: INT -- nanometers, + means cif is bigger
];
CIFDirective: TYPE = REF CIFDirectiveRec _ NIL;
CIFDirectiveRec: TYPE = RECORD [
cdSource: CD.Layer,
cifDest: Rope.ROPE,
deltaRadius: INT -- nanometers, + means cif is bigger
];
MaskStateRef: TYPE = REF MaskState;
MaskState: TYPE = RECORD [
areas, unbloated: CStitching.Tesselation _ NIL, 
partClip: CIFRect _ [0,0,0,0]
];


cellIDKey: REF ATOM = NEW[ATOM _ $CellIDNo]; --not accessible

debugging: BOOL _ FALSE;  -- used for printing out debugging messages
satellitesSignals: BOOL _ TRUE;  -- whether satellites should contribute signal names

design: CD.Design; 
stopFlag: REF BOOL;
topLayerOb: CD.Object _ NEW[CD.ObjectRep];
clearIDsRec: CD.DrawRef;  
cifMeasureR: CD.DrawRef;
cifDrawRec:  CD.DrawRef; --for CIFOrArea
contextFilter: REF CD.ContextFilter _ NEW[CD.ContextFilter_ALL[FALSE]]; --used in cifDrawRec


infinity: CD.Number _ LAST[CD.Number];  --used to initialize sizes and positions
  
cellCount: INTEGER _ 0;   -- used to assign consecutive CIF ID numbers

cifLayerAnnounced: BOOL _ FALSE;

lambda: INT _ 0;
cifPerLambda: INT _ 100;  -- CIF units per lambda
nmPerCIF: INT = 10; -- nanometers per CIF unit, given 0.01 microns per CIF unit

cifScaling: Rational;

cifFile:  IO.STREAM; -- file where output will be stored
comment, base, name, lastCellName: Rope.ROPE;

mainRect: CD.Rect _ [x1: infinity, y1: infinity, x2: -infinity, y2: -infinity];
cifDirectives: LIST OF REF ANY -- CIFDirective --  _ NIL;
currentDirective: CIFDirective;

partWidth: CIFUnits _ 800000; -- window for flat CIF
partHeight: CIFUnits _ 800000;

  
FreeStorage: PROC [] = {
cifMeasureR _ clearIDsRec _ cifDrawRec _ NIL; --help the garbage collector
design _ NIL;
cifFile _ NIL;
};

SimpleRect: PROC [ob: CD.Object] RETURNS [yes: BOOL] = INLINE { 
yes _ ob.class.wireTyped AND ob.class.objectType=$Rect
};

flattenAtomics: BOOL _ FALSE;

MakeCall: PROC [ob: CD.Object] RETURNS [yes: BOOL] = {
IF SimpleRect[ob] THEN RETURN [FALSE];
IF ob.class.symbolic THEN RETURN [FALSE];
IF flattenAtomics THEN {
IF ob.class.wireTyped THEN RETURN [FALSE];
IF ob.class.technology#NIL THEN RETURN [FALSE];
};
IF CDTexts.IsText[ob] THEN {
FOR dir: LIST OF REF ANY _ cifDirectives, dir.rest WHILE dir#NIL DO
directive: CIFDirective _ NARROW[dir.first];
IF directive.cdSource=ob.layer THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
};
RETURN [TRUE];
};

specialProperties: CDProperties.PropRef _ CDProperties.InitPropRef[];

SetUpSpecialClasses: PROC [] = {
x: REF _ CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFTechnology];
IF design.technology.key#x AND design.technology#x THEN {
IF x=NIL THEN TerminalIO.PutRope["CIF commandfile not set up\n"]
ELSE TerminalIO.PutRope["CIF commandfile set up for different technology\n"];
ERROR ABORTED
};
WITH CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFSpecials] SELECT FROM
pRef: CDProperties.PropRef => specialProperties _ pRef;
ENDCASE => specialProperties _ CDProperties.InitPropRef[];
flattenAtomics _ CDProperties.GetProp[$CDxCIFRegistrations, $CDxFlattenAtomic]=$TRUE;
};

IsSpecialCase: PROC [ob: CD.Object] RETURNS [yes: BOOL_FALSE] = {
yes _ CDProperties.GetListProp[specialProperties^, ob.class.objectType]#NIL
};

HandleSpecialCase: PROC [ob: CD.Object] = {
WITH CDProperties.GetListProp[specialProperties^, ob.class.objectType] SELECT FROM
rp: REF PROC [ob: CD.Object] RETURNS [Rope.ROPE] => {
r: Rope.ROPE _ rp^[ob]; 
IO.PutRope[cifFile, r];
};
r: Rope.ROPE => {
IO.PutRope[cifFile, r];
};
rt: REF TEXT => {
IO.PutText[cifFile, rt];
};
ENDCASE => {
TerminalIO.PutRope["object class handled specialy is inconsistent\n"];
ERROR
};
};

ClearCellIDs: CD.DrawProc = {
CDProperties.PutObjectProp[onto: inst.ob, prop: cellIDKey, val: NIL];
IF inst.ob.class.inDirectory THEN
inst.ob.class.drawMe[inst: inst, trans: inst.trans, pr: clearIDsRec]; 
};

SymHeader: PROC [obj: CD.Object] = {
cellID: REF INT _ NEW[INT _ (cellCount _ cellCount + 1)];
cifFile.PutF["DS %d %d %d;\n",
IO.int[cellCount], IO.int[cifScaling.num], IO.int[cifScaling.denom]];
CDProperties.PutObjectProp[obj, cellIDKey, cellID];
};

UnfinishedSymHeader: PROC [obj: CD.Object] = {
cellID: REF INT _ NEW[INT _ (cellCount _ cellCount + 1)];
cifFile.PutF["DS %d ", IO.int[cellCount]];
CDProperties.PutObjectProp[obj, cellIDKey, cellID];
};

SymTrailer: PROC = {
cifFile.PutRope["DF;\n"];
};

CallChildren: CD.DrawProc = {
IF MakeCall[inst.ob] THEN 
CIFSymbolCall[inst.ob, trans.orient, CDPosToCIF[trans.off]];
};

DrawRectChilds: CD.DrawProc = {
IF ~MakeCall[inst.ob] THEN
inst.ob.class.drawMe[inst: inst, trans: trans, pr: pr];
};

GenerateCompositeOb: PROC [obj: CD.Object] = {
cf: REF CD.ContextFilter _ NEW[CD.ContextFilter_ALL[FALSE]];
pr: CD.DrawRef _ CD.CreateDrawRef[[
stopFlag: stopFlag,
design: design
]];
dummyInst: CD.Instance = NEW[CD.InstanceRep]; 
dummyInst^.ob _ obj;  
SymHeader[obj];
CIFDrawCellName[CDDirectory.Name[obj]];
pr.contextFilter _ NIL;
pr.drawChild _ CallChildren;
pr.drawRect _ IgnoreRect;
obj.class.drawMe[dummyInst, [], pr];
pr.drawChild _ DrawRectChilds;
pr.contextFilter _ cf;
pr.drawRect _ CIFOrArea;
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
cf[currentDirective.cdSource] _ TRUE;
obj.class.drawMe[dummyInst, [], pr];
cf[currentDirective.cdSource] _ FALSE;
ENDLOOP;
SymTrailer[];
};  

GenerateGeometricOb: PROC [obj: CD.Object] = {
dummyInst: CD.Instance = NEW[CD.InstanceRep]; 
dummyInst^.ob _ obj;  
IF IsSpecialCase[obj] THEN {
UnfinishedSymHeader[obj];
HandleSpecialCase[obj]
}
ELSE {
SymHeader[obj];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
cifDrawRec.contextFilter _ contextFilter;
contextFilter[currentDirective.cdSource] _ TRUE;
obj.class.drawMe[inst: dummyInst, trans: [], pr: cifDrawRec];
contextFilter[currentDirective.cdSource] _ FALSE;
ENDLOOP;
};
SymTrailer[];
};  

MustCompensate: PROC [layer: CD.Layer] RETURNS [BOOL] = {
FOR dList: LIST OF REF ANY _ cifDirectives, dList.rest WHILE dList#NIL DO
cdir: CIFDirective _ NARROW[dList.first];
IF cdir.cdSource=layer AND cdir.deltaRadius#0 THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
};

GeneratePolygon: PROC [obj: CD.Object] = {

CifPolygonOut: PROC [points: LIST OF CD.Position] = {
IF NOT cifLayerAnnounced THEN {
cifFile.PutF["L %g;\n", IO.rope[currentDirective.cifDest]];
cifLayerAnnounced _ TRUE;
};
cifFile.PutRope["P"];
FOR p: LIST OF CD.Position _ points, p.rest WHILE p#NIL DO
cifPos: CD.Position = CDPosToCIF[p.first];
cifFile.PutRope[" "];
CIFOutPoint[cifPos.x, cifPos.y];
ENDLOOP;
cifFile.PutRope[";\n"];
};

polygon: CDCurves.CurveSpecific = NARROW[obj.specific];
bad: BOOL _ FALSE;
SymHeader[obj];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
IF currentDirective.cdSource=obj.layer THEN {
IF currentDirective.deltaRadius#0 THEN bad _ TRUE;
CifPolygonOut[polygon.points];
}
ENDLOOP;
IF bad THEN {
TerminalIO.PutRope["**polygon shrink or bloat failed\n"];
cifFile.PutRope["( polygon has incorrect sizing );\n"];
};
SymTrailer[];
};  

CIFDefineObject: PROC [obj: CD.Object] = {

CheckChildren: CDDirectory.EnumerateObjectsProc = {
IF MakeCall[me] THEN CIFDefineObject[me]
};

IF debugging THEN TerminalIO.PutRope["Entering CIFDefineObject\n"];
  
IF CDProperties.GetObjectProp[obj, cellIDKey]#NIL THEN RETURN;   
  

IF obj.class.inDirectory THEN {
[] _ CDDirectory.EnumerateChildObjects[obj, CheckChildren, NIL];
};
WITH obj.specific SELECT FROM
rp: CDImports.ImportSpecific => {
IF rp.boundInstance=NIL THEN ERROR;
CIFDefineObject[rp.boundInstance.ob];
SymHeader[obj];
CIFDrawCellName[Rope.Cat[rp.designName, ".", rp.objectName]];
CIFSymbolCall[rp.boundInstance.ob];
SymTrailer[];
};
cp: CD.CellSpecific => {
IF satellitesSignals THEN [] _ CDSatellites.GetSatellites[obj];
SymHeader[obj];
CIFDrawCellName[CDDirectory.Name[obj]];

BEGIN
EachInst: CDCells.InstEnumerator = {
IF MakeCall[inst.ob] THEN 
CIFSymbolCall[inst.ob, inst.trans.orient, CDPosToCIF[inst.trans.off]];
};
[] _ CDCells.EnumerateInstances[obj, EachInst];
END;

FOR dir: LIST OF REF ANY _ cifDirectives, dir.rest WHILE dir#NIL DO
currentDirective _ NARROW[dir.first];
cifLayerAnnounced _ FALSE;
BEGIN
EachInst: CDCells.InstEnumerator = {
IF ~MakeCall[inst.ob] THEN 
inst.ob.class.drawMe[inst: inst, trans: inst.trans, pr: cifDrawRec];
};
[] _ CDCells.EnumerateInstances[obj, EachInst];
END;
ENDLOOP;

BEGIN
EachInst: CDCells.InstEnumerator = {
IF ~MakeCall[inst.ob] THEN {
WITH CDProperties.GetInstanceProp[inst, $SignalName] SELECT FROM
r: Rope.ROPE => CIFLabelTerminal[inst, r, inst.ob.layer];
ENDCASE => NULL;
IF satellitesSignals THEN { 
FOR list: LIST OF Rope.ROPE _ CDSatellites.GetSatelliteRopes[inst], list.rest WHILE list#NIL DO
CIFLabelTerminal[inst, list.first, inst.ob.layer];
ENDLOOP;
};
}
};
[] _ CDCells.EnumerateInstances[obj, EachInst];
END;
 
SymTrailer[];
}; -- of cell
ENDCASE => -- crazy or transistors or geometry or rects
IF obj.class.inDirectory THEN GenerateCompositeOb[obj]
ELSE IF MakeCall[obj] THEN {
IF CDCurves.IsPolygon[obj] AND ~MustCompensate[obj.layer] THEN GeneratePolygon[obj]
ELSE GenerateGeometricOb[obj];
};
IF debugging THEN TerminalIO.PutRope["Leaving CIFDefineObject\n"];
}; 


CIFSymbolCall: PROC[ob: CD.Object, orient: CD.Orientation_original, pos: CD.Position_ [0,0]] = {
WITH CDProperties.GetObjectProp[ob, cellIDKey] SELECT FROM
iDNo: REF INT => {
cifFile.PutF["C %d", IO.int[iDNo^]];
IF orient#original THEN {
xrotation: CD.Orientation _ CDBasics.ConcentrateOnRotate90[orient];
IF xrotation#original THEN {
cifFile.PutRope[" R "];
cifFile.PutRope[SELECT xrotation FROM
rotate90 => "0,1" ,
rotate180=> "-1,0",
rotate270=> "0,-1",
ENDCASE=> "1,0" -- never use this one
];  
};
IF CDBasics.IncludesMirrorX[orient] THEN cifFile.PutRope[" M X "];
};
IF pos#[0, 0] THEN {
cifFile.PutRope[" T "];
CIFOutPoint[pos.x, pos.y];
};
cifFile.PutRope[";\n"];
};
ENDCASE => ERROR;
};
  

  
CIFMeasureArea: CD.DrawRectProc = {
r _ CDBasics.ReInterpreteRect[r];
IF CDBasics.NonEmpty[r] THEN mainRect _ CDBasics.Surround[mainRect, r];
}; 
  
IgnoreRect: CD.DrawRectProc = {
}; 

CIFOrArea: CD.DrawRectProc = {
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN {
rd: CIFRect _ CDBasics.Extend[CDRectToCIF[CDBasics.ReInterpreteRect[r]], currentDirective.deltaRadius/nmPerCIF];
IF CDBasics.NonEmpty[rd] THEN CIFRectOut[rd];
}
}; 
   
CIFRectOut: PROC [r: CIFRect] = {
IF NOT CDBasics.NonEmpty[r] THEN RETURN;
IF NOT cifLayerAnnounced THEN {
cifFile.PutF["L %g;\n", IO.rope[currentDirective.cifDest]];
cifLayerAnnounced _ TRUE;
};
cifFile.PutF["B %d %d %d %d;\n",-- BOX command, in prescaled CIF units
IO.int[PrescaleCIF[[r.x2-r.x1, 1]]] -- length -- ,
IO.int[PrescaleCIF[[r.y2-r.y1, 1]]] -- width -- ,
IO.int[PrescaleCIF[[r.x1+r.x2, 2]]] -- center x-coord -- ,
IO.int[PrescaleCIF[[r.y1+r.y2, 2]]] -- center y-coord -- ];
};

CIFOutPoint: PROC[x, y: CIFUnits] = {
cifFile.PutF["%d,%d", IO.int[PrescaleCIF[[x,1]]], IO.int[PrescaleCIF[[y,1]]]]
};

CIFLabelTerminal: PROC [ap: CD.Instance, s: Rope.ROPE, lev: CD.Layer] = {
pt: CD.Position _ CDBasics.Center[CDRectToCIF[CDInstances.InstRectO[ap]]];
cifFile.PutF["94 %s ", IO.rope[s]];
CIFOutPoint[pt.x, pt.y];
cifFile.PutChar[' ];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
d: CIFDirective = NARROW[directives.first];
IF d.cdSource = lev THEN {cifFile.PutRope[d.cifDest]; EXIT};
ENDLOOP;
cifFile.PutRope[";\n"]; 
};

CIFDrawCellName: PROC[s: Rope.ROPE] = {
lastCellName _ s;
IF ~Rope.IsEmpty[s] THEN cifFile.PutF["9 %s;\n", IO.rope[s]];
};

CantRepresentExactly: SIGNAL = CODE;

SetCIFScaling: PROC = {
cifScaling _ ReduceTerms[[num: cifPerLambda, denom: 2*lambda]]; -- the "2" allows for box centers
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
d: CIFDirective = NARROW[directives.first];
cif: CIFUnits;
IF ABS[d.deltaRadius] MOD nmPerCIF # 0 THEN
ERROR CantRepresentExactly;
cif _ ABS[d.deltaRadius]/nmPerCIF;
cifScaling _ ReduceTerms[[
num: cifScaling.num,
denom: (cifScaling.num*cifScaling.denom)/GCD[cif*cifScaling.denom, cifScaling.num]]];
ENDLOOP;
};


CollectDirectives: PROC = {

GetDirectives: PROC [p: REF, lev: CD.Layer] RETURNS [l: LIST OF REF ANY _ NIL] = {
IF p#NIL THEN {
WITH p SELECT FROM
d: CIFDest =>  l _ LIST[NEW[CIFDirectiveRec _ [lev, d.cifDest, d.deltaRadius]]];
list: LIST OF REF ANY => l _ List.Append[GetDirectives[list.first, lev], GetDirectives[list.rest, lev]];
ENDCASE => l _ LIST[NEW[CIFDirectiveRec _ [lev, CDOps.ToRope[p, $Interactive], 0]]];
};
};

cifDirectives _ NIL;
FOR layers: LIST OF CD.Layer _ design.technology.usedLayers, layers.rest WHILE layers#NIL DO
cifDirectives _ List.Append[GetDirectives[CDProperties.GetLayerProp[layers.first, $CDxCIFRegistrations], layers.first ], cifDirectives];
ENDLOOP;
};

GetCifPerLambda: PROC [] = {
WITH CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFUnitsPerLambda] SELECT FROM
ri: REF INT => cifPerLambda _ ri^;
ENDCASE  => cifPerLambda _ 0;
TerminalIO.PutF["using %g cif units per lambda; (1 CIF unit = 0.01 microns)\n", IO.int[cifPerLambda]] ;
IF cifPerLambda<2 THEN {
TerminalIO.PutRope["cif units per lambda not reasonable\n"];
ERROR ABORTED
};
};
  
WriteCIF: PROC[ comm: CDSequencer.Command] = {
ENABLE {
ABORTED => {TerminalIO.PutRope["  CIF generation aborted\n"]; GOTO Exit};
UNWIND => NULL;
}; --enable
 
mainOb: CD.Object;
mainInst: CD.Instance;
cifKey: Rope.ROPE;
stopFlag _ NEW[BOOL_FALSE];
design _ comm.design;
lambda _ design.technology.lambda;
CDSequencer.UseAbortFlag[design, stopFlag];
SetUpSpecialClasses[];
cifKey _ CDOps.ToRope[CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFName], $Interactive];
IF Rope.IsEmpty[cifKey] THEN {
TerminalIO.PutRope["The CIF layers for this technology are not yet defined\n"];
RETURN
};
TerminalIO.PutRopes["Use CIF layer definitions [", cifKey, "]\n"];


mainInst _ CDCellsInteractions.MakeTopInstance[design];
IF mainInst=NIL THEN {
TerminalIO.PutRope["no top level object found\n"];
RETURN
};
mainOb _ mainInst.ob;
cellCount _ 0;
stopFlag^ _ FALSE;
 
cifMeasureR _ CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawRect: CIFMeasureArea,
stopFlag: stopFlag,
design: design
]];

clearIDsRec _ CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawChild: ClearCellIDs,
stopFlag: stopFlag,
design: design
]];
 
cifDrawRec  _ CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawRect: CIFOrArea,
stopFlag: stopFlag,
design: design
]];
 
CDOps.DrawDesign[design,  cifMeasureR];  
GetCifPerLambda[];
TerminalIO.PutRopes["Input name of CIF file (", CDIO.GetWorkingDirectory[design], ") "];
base _ TerminalIO.RequestRope["> "];
IF Rope.IsEmpty[base] THEN base _ design.name;
IF Rope.IsEmpty[base] THEN base _ "foo";
name _ CDIO.MakeName[base: base, ext: ".cif", wDir: CDIO.GetWorkingDirectory[design]];
cifFile _ FS.StreamOpen[name,  create ! 
FS.Error => 
IF error.group#bug THEN { 
TerminalIO.PutRope[error.explanation]; 
GOTO FileIOOpenFailed; 	
}
];
 

cifFile.PutF["( %s );\n", IO.rope[design.name]];
cifFile.PutF["( generated %g by Xerox PARC ChipNDale and BrandyCIFter);\n", IO.time[]];
cifFile.PutF["( with lambda =  %d CIF units );\n", IO.int[cifPerLambda]];
cifFile.PutF["( origin = [x: 0, y: 0], size = [x: %d, y: %d] CIF units );\n", IO.int[CDCIFUp[mainRect.x2-mainRect.x1]], IO.int[CDCIFUp[mainRect.y2-mainRect.y1]]];
cifFile.PutF["( CIF KEY: %s );\n", IO.rope[cifKey]];

TerminalIO.PutRope["Comment line: \n"];
comment _ TerminalIO.RequestRope["(parens are changed, CR for no comment)\n> "];
WHILE NOT Rope.IsEmpty[comment] DO
comment _ EliminateParens[comment];
cifFile.PutF["( %s );\n", IO.rope[comment]];
comment _ NIL;
TerminalIO.PutRope["Another comment line:\n"];
comment _ TerminalIO.RequestRope["(parens are changed, CR for no further comments)\n> "];
ENDLOOP;
IO.PutChar[cifFile, IO.CR]; 
 

CollectDirectives[];
SetCIFScaling[];
ClearCellIDs[design.actual.first.dummyCell, [], NIL];
CIFDefineObject[mainOb];

SymHeader[topLayerOb];
CIFSymbolCall[mainOb];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
IF currentDirective.deltaRadius<0 THEN {
cifLayerAnnounced _ FALSE;
MakeFlatCIF[rectProc: CIFRectOut];
};
ENDLOOP;
SymTrailer[];

CIFSymbolCall[topLayerOb, original, [x: -cifPerLambda*mainRect.x1/lambda, y: -cifPerLambda*mainRect.y2/lambda]];
cifFile.PutRope[";\nEnd ... \n"];  
cifFile.Close[];
TerminalIO.PutF["\nCIF file on %g\n", IO.rope[name]];
FreeStorage[]
EXITS
Exit => FreeStorage[];
FileIOOpenFailed => {
TerminalIO.PutRope["Open Failed\n"]; 
FreeStorage[]
};
}; -- of WriteCIF



MakeFlatCIF: PROC [rectProc: PROC[rect: CIFRect]] = {

AnalyzeTesselation: PROC [ms: MaskStateRef] = {
active: CD.Rect = ms.areas.BBox[];
IF CDBasics.NonEmpty[active] THEN {
IF currentDirective.deltaRadius#0 THEN {
t: CStitching.Tesselation = ms.unbloated;
ms.unbloated _ ms.areas;
ms.areas _ t;
CStitching.ChangeRect[plane: ms.areas, rect: CDBasics.universe, new: NIL];
IF currentDirective.deltaRadius>0 THEN
CStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, eachTile: BloatTile, data: ms]
ELSE {
CStitching.ChangeRect[plane: ms.areas, rect: active, new: $covered];
CStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, eachTile: BloatTile, data: ms,
skip: $covered];
};
};
CStitching.EnumerateArea[plane: ms.areas, rect: CDBasics.universe,
eachTile: OutputTile, data: ms];
TerminalIO.PutRope["."]; 
};
};

OutputTile: PROCEDURE [tile: CStitching.Tile, data: REF ANY] = {
-- CStitching.PerTileProc 
-- only called on tiles with non-NIL values
ms: MaskStateRef = NARROW[data];
cr: CIFRect = CDBasics.Intersection[tile.Area, ms.partClip];
rectProc[cr];
};

designClip: CD.Rect;
cifClip: CD.Rect;
nRows, nCols: NAT;
ms: MaskStateRef = NEW[MaskState _ [
areas: CStitching.NewTesselation[],
unbloated: CStitching.NewTesselation[]
]];

dr: CD.DrawRef _ CD.CreateDrawRef[[
drawRect: NoteBoundingBox,
devicePrivate: NEW[CD.Rect _ CDBasics.empty],
interestClip: CDBasics.universe,
stopFlag: stopFlag,
design: design
]];

CDOps.DrawDesign[design, dr]; -- measure design

designClip _ NARROW[dr.devicePrivate, REF CD.Rect]^;

cifClip _ Bloat[CDRectToCIF[designClip], ABS[currentDirective.deltaRadius]/nmPerCIF];

nRows _ Ceiling[num: cifClip.y2-cifClip.y1, denom: partHeight];
nCols _ Ceiling[num: cifClip.x2-cifClip.x1, denom: partWidth];

TerminalIO.PutF[".. in %d rows and %d columns..", IO.int[nRows], IO.int[nCols]];
dr.drawRect _ NoteRectangle;
dr.devicePrivate _ ms;

TerminalIO.PutF["%s -> %s", IO.rope[CDOps.ToRope[CD.LayerKey[currentDirective.cdSource], $Interactive]], IO.rope[currentDirective.cifDest]];
FOR col: NAT IN [0..nCols) DO
FOR row: NAT IN [0..nRows) DO
ms.areas.ChangeRect[rect: CDBasics.universe, new: NIL];
ms.partClip _ [ -- in cif space
x1: cifClip.x1+col*partWidth, 
y1: cifClip.y1+row*partHeight,
x2: cifClip.x1+col*partWidth+MIN[partWidth, cifClip.x2-cifClip.x1-partWidth*col],
y2: cifClip.y1+row*partHeight+MIN[partHeight, cifClip.y2-cifClip.y1-partHeight*row]
];
dr.interestClip _ CIFRectToCD[CDBasics.Extend[ms.partClip, 1+ABS[currentDirective.deltaRadius]/nmPerCIF]];
CDVArrow.ShowArrow[design: design,
pos: [x: (dr.interestClip.x1+dr.interestClip.x2)/2, y: (dr.interestClip.y1+dr.interestClip.y2)/2]]; -- keep user happy
CDOps.DrawDesign[design, dr]; -- build tesselation of the relevant design rectangle
AnalyzeTesselation[ms]; -- sends the current part to s
ENDLOOP;
ENDLOOP;
TerminalIO.PutRope["+"];
CDVArrow.RemoveArrow[design: design];
dr _ NIL;
};

NoteBoundingBox: CD.DrawRectProc = {
bb: REF CD.Rect = NARROW[pr.devicePrivate];
bb^ _ CDBasics.Surround[bb^, r];
};

NoteRectangle: CD.DrawRectProc = {
ms: MaskStateRef = NARROW[pr.devicePrivate];
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN
ms.areas.ChangeRect[rect: CDRectToCIF[r], new: $covered];
};

BloatTile: PROCEDURE [tile: CStitching.Tile, data: REF ANY] = {
-- CStitching.PerTileProc -- 
ms: MaskStateRef = NARROW[data];
cr: CD.Rect = CDBasics.Intersection[CDBasics.universe, Bloat[tile.Area, ABS[currentDirective.deltaRadius/nmPerCIF]]];
IF CDBasics.NonEmpty[cr] THEN
ms.areas.ChangeRect[rect: cr, new: tile.value];
};

Bloat: PROC [r: CD.Rect, delta: CD.Number] RETURNS [br: CD.Rect] = INLINE {
br _ [x1: MAX[FIRST[CD.Number]+delta, r.x1]-delta,
y1: MAX[FIRST[CD.Number]+delta, r.y1]-delta,
x2: MIN[LAST[CD.Number]-delta, r.x2]+delta,
y2: MIN[LAST[CD.Number]-delta, r.y2]+delta]
};

CDRectToCIF: PROC [ cdr: CD.Rect ] RETURNS [ cifr: CIFRect ] = {
cifr _ CDBasics.ReInterpreteRect[[
x1: cifPerLambda*cdr.x1/lambda,
y1: cifPerLambda*cdr.y1/lambda,
x2: cifPerLambda*cdr.x2/lambda,
y2: cifPerLambda*cdr.y2/lambda
]]
};

CDPosToCIF: PROC [ cdp: CD.Position ] RETURNS [ cifp: CIFPos ] = {
cifp _ [x: cifPerLambda*cdp.x/lambda, y: cifPerLambda*cdp.y/lambda]
};

CDCIFUp: PROC [ n: CD.Number ] RETURNS [ cif: CIFUnits ] = {
cif _ (cifPerLambda*n+lambda-1)/lambda
};

CIFRectToCD: PROC [ cifr: CIFRect ] RETURNS [ cdr: CD.Rect ] =
BEGIN
cdr _ CDBasics.ReInterpreteRect[[
x1: lambda*cifr.x1/cifPerLambda,
y1: lambda*cifr.y1/cifPerLambda,
x2: (lambda*cifr.x2+cifPerLambda-1)/cifPerLambda,
y2: (lambda*cifr.y2+cifPerLambda-1)/cifPerLambda
]]
END;

errOnCantRepresentExactly: BOOL _ TRUE;

PrescaleCIF: PROC [ cif: Rational ] RETURNS [ INT ] = {
n: INT = cif.num*cifScaling.denom;
d: INT = cif.denom*cifScaling.num;
IF ABS[n] MOD ABS[d] # 0 THEN {
TerminalIO.PutRope["feature cant be represented exactly\n"];
IF errOnCantRepresentExactly THEN SIGNAL CantRepresentExactly;
};
RETURN[n/d];
};

Ceiling: PROC [num, denom: CD.Number] RETURNS [ c: INT ] = {
c _ (num+denom-1)/denom
};

ReduceTerms: PROC [ r: Rational ] RETURNS [ Rational ] = {
gcd: INT = GCD[r.num, r.denom];
RETURN[[num: r.num/gcd, denom: r.denom/gcd]];
};

GCD: PROC [ m, n: INT ] RETURNS [ INT ] = {
r: INT;
SELECT m FROM
<0 => m _ -m;
ENDCASE => NULL;
SELECT n FROM
<0 => n _ -n;
>0 => NULL;
ENDCASE => RETURN[m];
r _ m MOD n;
WHILE r>0 DO m _ n; n _ r; r _ m MOD n; ENDLOOP;
RETURN[n];
};


WriteCIFComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["Hierarchical CIF output\n"]; 
TerminalIO.PutRope["Version of December 6, 1985 11:17:55 am PST\n"]; 
TerminalIO.PutRope["better read back the cif file and look at it\n"]; 
TerminalIO.PutRope["**WARNING not tested in release 2.4\n"]; 
IF CDCells.IsPushedIn[comm.design] THEN {
TerminalIO.PutRope["**Design is pushed in\n"]; 
RETURN
};
IF CDImports.HasUnloadedImports[comm.design] THEN {
TerminalIO.PutRope["**Design has non bound imports\n"]; 
RETURN
};
[] _ CDCommandOps.DoWithResource[WriteCIF, comm, $CIF];
};

EliminateParens: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
Translator: Rope.TranslatorType = {
RETURN [SELECT old FROM
'( => '[,
') => '],
ENDCASE => old
]
};
RETURN [Rope.Translate[base: r, translator: Translator]]
};

CDPropertyTools.Associate[$CDxCIFRegistrations, $CDxCIFName];
CDPropertyTools.Associate[$CDxCIFRegistrations, $CDxCIFTechnology];
CDPropertyTools.Associate[$CDxCIFRegistrations, $CDxCIFSpecials];
CDPropertyTools.Associate[$CDxCIFRegistrations, $CDxCIFUnitsPerLambda];
CDPropertyTools.Associate[$CDxCIFRegistrations, $CDxFlattenAtomic];
CDSequencer.ImplementCommand[key: $WriteCif, proc: WriteCIFComm, queue: doQueue];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "Hierarchical CIF", key: $WriteCif, proc: WriteCIFComm];
END.  
¦BrandyCIFter.mesa  	A package to output CIF files from ChipNDale
Copyright c 1984, 1987 by Xerox Corporation.  All rights reserved.
Last Edited by: Kimr, October 15, 1984 5:15:13 pm PDT
Last Edited by: Christian Jacobi, October 30, 1984 12:10:38 pm PST
Last Edited by: Christian Jacobi, January 6, 1987 3:47:13 pm PST
Last Edited by McCreight, October 17, 1984 7:02:18 pm PDT

--Global Variables
--layer assumed to be unchanged until the next layer is announced
cifPerCD: INT;  -- cifPerLambda/l, since l is defined in CD units per lambda
--..output numbers*cifScaling = CIFUnits
--..CIFUnits/cifScaling = output numbers
--set to design size in CIFMeasureArea, used to switch between ChipNDale and CIF coordinate systems


--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--used to set all CellIDNo's to NIL at the start
--start outputting a new cell and assign its cellID
--start outputting a new cell and assign its cellID
--but don't output the scaling
--finish off cell description
--logically local to GenerateCompositeOb
--logically local to GenerateCompositeOb
--output composite objects
--the children must be already defined
--match the type of drawMe parameter
--call the children 
--draw the rectangles
--IF currentDirective.deltaRadius>=0 THEN redundant but easier to understand
--output CIF for structures only identified as geometries
--match the type of drawMe parameter
--IF currentDirective.deltaRadius>=0 THEN redundant but easier to understand
--output CIF for structures for polygons
--points are in design coords, not yet CIF coords
--Print out CIF pertaining to object starting with the furthest object from the top; After leaving procedure, object will have been assigned a CIF ID # in its  properties field
--non-NIL value indicates that object has already been assigned an ID # and is therefore already defined
--We should also make a test here to decide whether any hierarchical geometry results from this object, and assign a special value to this object's attribute $CellIDNo if not.
--For each member of the instance list, determine whether obj is a cell. If so, determine transformations
--for each layer, pick out the rectangles belonging to that layer 
--and output them
--IF currentDirective.deltaRadius>=0 THEN removed for simplicity
--generate all signal names
--we don't deal with signal names on p-diffusion;
--sorry, but I have more important things to do right now
--pos in CIFUnits
--indicate which cell is called using its ID number
--OUTPUT PROCEDURES
-- Sets mainRect to be a large as is necessary to contain design.
--.. adds the condition that cif/cifScaling is guaranteed to be an integer, so cif*cifScaling.denom MOD cifScaling.num = 0
--assign world variable from sequencer
--initialize main object, layer names, resolution,  cellCount, and draw records

--Search world data structure: normalize coordinates, 
--set mainRect to design size, mark used layers  


--get file name
cifPerCD _ cifPerLambda/lambda; need not be integer..
--output header
--ask for comment lines
--define hybrid top layer object
--Flat CIF code

--the tesselation is in cif coordinates

--Be careful not to exceed the limits of a CD.Number, even temporarily
--rounds to rect beeing bigger
Κ!;˜
codeš
œ@™@Kšœ
Οm
œ7™BKš
œ5™5Kš
œB™BK™@K™9—K˜š
Οk	˜	Kšžœ
˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kšžœ
˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kšžœ
˜Kšžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ˜—Kš
œ˜šΟbœžœ
ž˜Kš
žœ
žœMžœ~žœžœ˜χ
—Kš
ž˜˜Kšœ
žœžœ˜Kšœžœžœ
Οcœ˜.Kšœ	žœžœ œ˜+Kšœ
žœžœžœ˜.Kšœ	žœžœžœ
˜%šœžœžœ˜Kšœžœ
˜Kšœ
žœ
 $˜5Kš
œ˜—Kšœžœžœžœ
˜/šœžœžœ˜ Kšœ
žœ˜Kšœžœ
˜Kšœ
žœ
 $˜5K˜—Kšœžœžœ˜#šœžœžœ˜Kšœ+žœ˜0Kš
œ˜Kš
œ˜K˜——K™Kš
Ÿ™˜Kš
œžœ
žœžœ
žœ ˜=K˜Kšœžœžœ +˜EKšœžœžœ 4˜UK˜Kšœžœ	˜Kšœ
žœ
žœ
˜Kšœžœ
žœ
žœ˜*Kšœ
žœ˜Kšœ
žœ	˜šœ
žœ
 ˜(Kšœžœ
žœžœ
žœžœ
žœ ˜\K˜—K˜Kšœ
žœ
žœ
žœ (˜PKš
œ˜Kšœžœ ,˜FK˜šœžœžœ
˜ Kš
œA™A—K˜Kšœžœ˜Kšœžœ	 ˜1Kšœ
žœ ;˜OKšœ
žœ Πcg
 ‘
 "™LK˜š
œ˜Kš
œ(™(Kš
œ(™(—K˜Kšœ
žœ
žœ
 $˜8Kšœ(žœ
˜-K˜š
œO˜OKš
œc™c—K™Kšœžœ
žœ
žœ
ž œžœ
˜9Kš
œ˜K˜Kšœ ˜4Kš
œ˜K˜—š
œ˜šΟnœžœ˜Kšœ)žœ ˜JKšœ	žœ
˜
Kšœ
žœ
˜Kš
œ˜—K˜š’
œžœžœ	žœžœžœ˜@Kšœžœ˜6Kš
œ˜——˜Kšœžœžœ
˜K˜š
’œžœžœ	žœžœ˜6Kšžœžœ
žœžœ˜&Jšžœžœ
žœžœ˜)šžœžœ˜Jšžœžœ
žœžœ˜*Jš
žœžœ
žœ
žœžœ˜/J˜—šžœžœ˜šžœžœ
žœ
žœ
žœžœžœ
ž˜CKšœžœ˜,Kšžœžœ
žœžœ˜2Kšžœ
˜—Jšžœžœ˜J˜—Jšžœžœ˜K˜—K™Kš
œ ™ K˜Kš
œE˜EK˜š’œžœ˜ KšœžœA˜Gšžœžœžœ˜9Kšžœžœ
žœ3˜@KšžœI˜MKšžœ
ž˜
K˜—šžœ=žœ
ž˜LKš
œ7˜7Kšžœ3˜:—Kš
œU˜UKš
œ˜—K˜š’
œžœžœ	žœžœ
žœ˜AKšœHž˜KKš
œ˜—K˜š’œžœžœ˜+šžœCžœ
ž˜Ršœžœ
žœžœ	žœžœ˜5Kšœžœ˜Kšžœ˜K˜—šœžœ˜Kšžœ˜K˜—šœžœ
žœ˜Kšžœ˜K˜—šžœ˜Kš
œF˜FKš
ž˜K˜——Kš
œ˜—K™K™Kš
œ ™ K˜š’œžœ
˜Kš
œ0™0Kšœ@žœ˜Ešžœž˜!Kš
œF˜F—Kš
œ˜—K˜š’	œžœžœ˜$Kš
œ3™3Kš	œžœ
žœžœ
žœ ˜9š
œ˜Kšžœžœžœ˜E—Kš
œ3˜3Kš
œ˜K˜—š’œžœžœ˜.Kš
œ3™3Kš
œ™Kš	œžœ
žœžœ
žœ ˜9Kšœžœ˜*Kš
œ3˜3Kš
œ˜K˜—š’
œžœ˜Kš
œ™Kš
œ˜Kš
œ˜K˜—Kš
œ(™(šŸœžœ
˜šžœžœ
˜Kš
œ<˜<—Kš
œ˜—K˜Kš
œ(™(šŸœžœ
˜šžœž˜Kš
œ7˜7—Kš
œ˜—K˜š’œžœžœ˜.Kš
œ™Kš
œ&™&Kš
œžœ
žœžœ
žœžœ
žœ˜<šœžœžœ˜#Kš
œ˜Kš
œ˜Kš
œ˜—šœžœžœ
žœ˜.Kš
œ$™$—Kš
œ˜Kš
œ˜Kš
œ'˜'Kš
œ™Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ$˜$Kš
œ™Kš
œ˜Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šœžœ
˜Kšžœ!žœ"™L—Kšœ žœ
˜%Kš
œ$˜$Kšœ žœ
˜&Kšžœ
˜—Kš
œ
˜
Kš
œ˜—K˜š’œžœžœ˜.Kš
œ9™9šœžœžœ
žœ˜.Kš
œ$™$—Kš
œ˜šžœžœ˜Kš
œ˜Kš
œ˜K˜
—šžœ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šœžœ
˜Kš
œL™L—Kš
œ)˜)Kšœ+žœ
˜0Kš
œ=˜=Kšœ+žœ
˜1Kšžœ
˜—K˜—Kš
œ
˜
Kš
œ˜—K˜š
’œžœ	žœžœžœ˜9šžœžœ
žœ
žœ
žœžœžœ
ž˜IKšœžœ˜)Kš
žœžœžœ
žœžœ˜AKšžœ
˜—Kšžœžœ˜Kš
œ˜—K˜š’œžœžœ˜*Kš
œ(™(K˜š
’
œžœ
žœ
žœ
žœ˜5Kš
œ1™1šžœ
žœž˜Kšœžœ!˜;Kšœžœ
˜Kšž
œ
˜—Kš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜:Kšœžœ ˜*Kš
œ˜Kš
œ ˜ Kšžœ
˜—Kš
œ˜Kš
œ˜—K˜Kšœ"žœ˜7Kšœžœžœ
˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,Kšœžœ
˜šžœ%ž˜-Kšžœ žœž˜2Kš
œ˜K˜
—Kšžœ
˜—šžœžœ˜
Kš
œ9˜9Kš
œ7˜7K˜—Kš
œ
˜
Kš
œ˜—K˜š’œžœžœ˜*Kš
ϡ
™°
K˜šΠbn
œ&˜3Kšžœžœ˜(Kš
œ˜K˜—Kšžœžœ2˜CKš
œ˜šžœ,žœ
žœ
žœ˜AKš
œh™h—Kš
œ˜Kš
œ―
™―
K˜šžœžœ˜Kšœ;žœ˜@K˜—šžœžœ
ž˜š
œ!˜!Kšžœžœ
žœ
žœ
˜#Kš
œ%˜%Kš
œ˜Kš
œ=˜=Kš
œ#˜#Kš
œ
˜
Kš
œ˜—šœžœ˜Kšžœžœ&˜?Kš
œ˜Kš
œ'˜'K˜Kš
œi™iš
ž˜š’œ˜$šžœžœ
˜Kš
œF˜F—K˜—Kš
œ/˜/Kšžœ
˜—K˜Kš
œB™BKš
œ™šžœžœ
žœ
žœ
žœžœžœ
ž˜CKšœžœ˜%šœžœ
˜Kš
 @™@—š
ž˜š’œ˜$šžœžœ
˜Kš
œD˜D—K˜—Kš
œ/˜/Kšžœ
˜—Kšžœ
˜—K˜Kš
œ™š
ž˜š’œ˜$Kš
œ1™1Kš
œ9™9šžœžœ˜šžœ1žœ
ž˜@Kšœžœ-˜9Kšžœžœ
˜—šžœžœ˜š
žœžœ
žœžœ3žœžœ
ž˜_Kš
œ2˜2Kšžœ
˜—K˜—K˜
—K˜—Kš
œ/˜/Kšžœ
˜—Kš
œ
˜
Kš
œ
˜
Kšž
œ 
˜
—šžœ ,˜7Kšžœžœ˜6šžœ
žœžœ˜Kšžœžœžœ˜SKšžœ˜K˜———Kšžœžœ1˜BKš
œ˜—K˜K˜š
’
œžœžœžœžœ˜`Kš
œ™Kš
œ3™3šžœ+žœ
ž˜:šœžœ
žœ˜Kšœžœ
˜$šžœžœ˜Kšœžœ6˜Cšžœžœ˜Kš
œ˜šœžœž˜%Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ	 ˜%Kš
œ˜—Kš
œ˜—Kšžœ"žœ˜BKš
œ˜—šžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kšžœžœ
˜—Kš
œ˜—Kš
œ˜Kš
Ÿ™K˜Kš
œ˜š£œ˜#Kš
œA™AKš
œ!˜!Kšžœžœ+˜GKš
œ˜—Kš
œ˜š£
œ˜Kš
œ˜—K˜š£	œ˜šžœžœžœ˜>Kš
œp˜pKšžœžœ˜-Kš
œ
˜
—Kš
œ˜—Kš
œ˜š’
œžœ˜!Kšžœ
žœžœ
žœ
˜(šžœ
žœž˜Kšœžœ!˜;Kšœžœ
˜Kšž
œ
˜—šœ  &˜FKšžœ" œ˜2Kšžœ" œ˜1Kšžœ" œ˜:Kšžœ" œ˜;—Kš
œ˜K˜—š’œžœ˜%Kšœžœžœ˜MKš
œ˜K˜—š
’œžœžœžœžœ˜IKš
œJ˜JKšœžœ
˜#Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜+Kšžœžœžœ˜<Kšžœ
˜—Kš
œ˜Kš
œ˜—K˜š’œžœ	žœ˜'Kš
œ˜Kšžœžœžœ
˜=Kš
œ˜—K˜Kšœžœžœ
˜$K˜š’
œžœ˜Kšœ@ !˜ašžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜+Kš
œ˜šžœ
žœžœž˜+Kšžœ˜—Kšœžœ˜"š
œ˜Kš
œ˜Kšœ)žœ)˜UKš
œz™z—Kšžœ
˜—Kš
œ˜K˜K˜—š’œžœ˜K˜š’
œžœžœžœžœžœ
žœ
žœ
žœžœ˜Ršžœžœ
žœ˜šžœžœ
ž˜Kšœžœ
žœ5˜PKš	œžœ
žœ
žœ
žœS˜hKšžœžœ
žœ=˜T—Kš
œ˜—Kš
œ˜K˜—Kšœžœ
˜š
žœ	žœ
žœ
žœ3žœžœ
ž˜\Kš
œˆ
˜ˆ
Kšžœ
˜—Kš
œ˜K˜—š’œžœ˜šžœCžœ
ž˜RKšœžœ
žœ˜"Kšžœ˜—Kš
œg˜gšžœžœ˜Kš
œ<˜<Kšžœ
ž˜
K˜—Kš
œ˜—Kš
œ˜š’œžœ ˜.šžœ˜Kšžœ7žœ˜IKšžœžœ
˜Kšœ ˜—Kš
œ
˜
Kš
œ&™&Kš
œ˜Kš
œ˜Kšœ
žœ
˜Kšœžœ
žœ
žœ˜Kš
œ˜Kš
œ"˜"Kš
œ+˜+Kš
œ˜Kš
œ]˜]šžœžœ˜Kš
œO˜OKš
ž˜K˜—š
œB˜BK˜—Kš
œO™OK™K˜Kš
œ7˜7šžœ
žœ
žœ˜Kš
œ2˜2Kš
ž˜Kš
œ˜—Kš
œ˜Kš
œ˜Kšœžœ
˜Kš
œ
˜
šœžœ˜ Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šœžœ˜ Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ
˜
šœžœ˜ Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ
˜
Kš
œ6™6Kš
œ1™1K™Kš
œ)˜)Kš
œ˜K™Kš
œ™Kšœ0žœ$˜XKš
œ$˜$Kšžœžœ˜.Kšžœžœ˜(Kšœžœ)žœ˜Všœ
žœ˜(šžœ
˜šžœžœ˜Kš
œ'˜'Kšžœ˜Kš
œ
˜
—Kš
œ˜Kš
œ
˜
——Kš
œ5™5K˜Kš
œ™Kšœžœ˜0KšœLžœ	˜WKšœ3žœ˜IKšœNžœ(žœ(˜’
Kšœ#žœ˜4K˜Kš
œ™Kš
œ'˜'Kš
œP˜Pšžœ
žœž˜"Kš
œ#˜#Kšœžœ˜,Kšœ
žœ
˜Kš
œ.˜.Kš
œY˜YKšžœ
˜—šžœžœ
žœ˜Kš
œ
˜
K˜—Kš
œ˜Kš
œ˜Kšœ0žœ˜5Kš
œ˜K˜Kš
œ ™ Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šžœ žœ˜(Kšœžœ
˜Kš
œ"˜"Kš
œ˜—Kšžœ
˜—K˜
K˜Kš
œp˜pKš
œ#˜#Kš
œ˜Kšœ&žœ
˜5Kš
œ
˜
š
ž˜Kš
œ˜š
œ˜Kš
œ%˜%Kš
œ
˜
Kš
œ˜——Kšœ ˜K˜—K˜—š
Ρbls™K˜—™š’œžœžœ˜5K˜š’œžœ˜/Kš
œ'™'Kšœžœ˜"šžœžœ˜#šžœ žœ˜(Kš
œ)˜)Kš
œ˜Kš
œ
˜
KšœEžœ˜Jšžœ ž˜&Kš
œe˜e—šžœ˜Kš
œD˜DKš
œv˜vKš
œ˜—Kš
œ˜—Kš
œc˜cKš
œ˜Kš
œ˜—Kš
œ˜K˜—š’
œž	œžœ
žœ
žœ ˜[Kš
 +˜+Kšœžœ˜ Kš
œ<˜<Kš
œ
˜
Kš
œ˜K˜—Kšœžœ˜Kšœ	žœ˜Kšœžœ
˜šœžœ˜$Kš
œ#˜#Kš
œ&˜&Kš
œ˜—K˜šœžœžœ˜#Kš
œ˜Kšœžœ
žœ˜-Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜—K˜Kšœ ˜/K˜Kšœ
žœžœ
žœ˜4K˜Kšœ)žœ)˜UK˜Kš
œ?˜?K˜>K˜Kšœ2žœ
žœ
˜PK™Kš
œ˜K˜K˜Kšœžœžœ6žœ!˜Œ
šžœžœ
žœž˜šžœžœ
žœž˜Kšœ2žœ˜7šœ ˜Kš
œ˜Kš
œ˜Kšœžœ1˜QKšœžœ2˜SKš
œ˜—Kšœ=žœ*˜jš
œ"˜"Kšœd ˜v—Kšœ 5˜SKšœ ˜6Kšžœ
˜—Kšžœ
˜—Kš
œ˜Kš
œ%˜%Kšœžœ
˜	Kš
œ˜K˜—š’œ˜$Kšœžœ
žœžœ˜+Kš
œ ˜ Kš
œ˜K˜—š’
œ˜"Kšœžœ˜,šžœžœž˜<Kš
œ9˜9—Kš
œ˜K˜—š’	œž	œžœ
žœ
žœ œ
˜]Kšœžœ˜ KšœžœBžœ*˜ušžœž˜Kš
œ/˜/—Kš
œ˜K˜—š’œžœžœžœ	žœžœ	žœ˜KKš
œF™FKšœ
žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ˜·
Kš
œ˜—K˜š’œžœžœžœ˜@š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—š’
œžœžœžœ˜BKš
œC˜CKš
œ˜K˜—š’œžœžœ
žœ˜<Kš
œ&˜&Kš
œ˜K˜—š’œžœžœžœ	˜>Kš
œ™š
ž˜š
œ!˜!Kš
œ ˜ Kš
œ ˜ Kš
œ1˜1Kš
œ0˜0Kš
œ˜——Kšžœ
˜—K˜Kšœžœžœ
˜'K˜š’œžœžœžœ˜7Kšœžœ˜"Kšœžœ˜"š
žœ
žœžœ
žœžœ˜Kš
œ<˜<Kšžœžœ
žœ˜>K˜—Kšžœ˜š
œ˜K˜——š
’œžœžœ	žœžœ˜<Kš
œ˜Kš
œ˜K˜—š’œžœžœ˜:Kšœžœžœ˜Kšžœ'˜-Kš
œ˜K˜—š
Πbkœžœ	žœžœžœ˜+Kšœžœ
˜šžœž˜
Kš
œ
˜
Kšžœžœ
˜—šžœž˜
Kš
œ
˜
Kšœžœ
˜Kšžœžœ˜—Kšœžœ˜Kšžœžœžœžœ
˜0Kšžœ˜
Kš
œ˜——K˜K˜š£œžœ ˜2Kš
œ1˜1Kš
œE˜EKš
œF˜FKš
œ=˜=šžœ!žœ˜)Kš
œ/˜/Kš
ž˜K˜—šžœ+žœ˜3Kš
œ8˜8Kš
ž˜K˜—Kš
œ7˜7Kš
œ˜—K˜š
’œžœ
žœžœžœ˜<š’
œ˜#šžœžœž˜Kš
œ	˜	Kš
œ	˜	Kšžœ˜K˜
—K˜—Kšžœ2˜8K˜—K˜Kš
œ=˜=Kš
œC˜CKš
œA˜AKš
œG˜GKš
œC˜CKš
œQ˜QKš
œq˜qKšžœ˜—…—_Œύ