DIRECTORY
Atom USING [GetPName],
CD,
CDBasics,
CDCells,
CDCommandOps,
CDDirectory,
CDExtras,
CDImports,
CDInstances USING [InstRectO],
CDIO,
CDMenus,
CDOps USING [DrawDesign],
CDOrient,
CDPolygons,
CDProperties,
CDSequencer USING [Command, ImplementCommand],
CDViewer USING [RemoveArrow, ShowArrow],
CornerStitching,
FS USING [StreamOpen, Error],
Imager USING [black],
IO USING [Close, CR, int, PutChar, PutF, PutFR, PutRope, PutText, refAny, rope, STREAM, time],
List USING [Append, Nconc],
Rope,
TerminalIO;
  
BrandyCIFter: CEDAR PROGRAM
IMPORTS Atom, CD, CDInstances, CDBasics, CDCells, CDCommandOps, CDDirectory, CDExtras, CDImports, CDIO, CDMenus, CDOps, CDOrient, CDProperties, CDSequencer, CDViewer, CornerStitching, FS, Imager, 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: REF CornerStitching.Tesselation _ NIL, 
partClip: CIFRect _ [0,0,0,0]
];


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

debugging: BOOLEAN _ FALSE;  -- used for printing out debugging messages

design: CD.Design ; 
topLayerOb: CD.Object _ NEW[CD.ObjectRep];
stopFlag: REF BOOLEAN _ NEW[BOOLEAN];
clearIDsRec: CD.DrawRef;  
cifMeasureR: CD.DrawRef;
cifDrawRec:  CD.DrawRef; --for CIFOrArea
contextFilter: REF CD.ContextFilter _ NEW[CD.ContextFilter_ALL[NIL]]; --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: BOOLEAN _ 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 [] =
BEGIN
cifMeasureR _ clearIDsRec _ cifDrawRec _ NIL; --help the garbage collector
design _ NIL;
cifFile _ NIL;
END;

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


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

SetUpSpecialClasses: PROC [] =
BEGIN
x: REF _ CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFTechnology];
IF design.technology.key#x AND design.technology#x THEN {
IF x=NIL THEN TerminalIO.WriteRope["CIF commandfile not set up\n"]
ELSE TerminalIO.WriteRope["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[];
END;

IsSpecialCase: PROC [ob: CD.Object] RETURNS [yes: BOOL_FALSE] =
BEGIN
yes _ CDProperties.GetPropFromList[specialProperties^, ob.class.objectType]#NIL
END;

HandleSpecialCase: PROC [ob: CD.Object] =
BEGIN
WITH CDProperties.GetPropFromList[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.WriteRope["object class handled specialy is inconsistent\n"];
ERROR
};
END;

ClearCellIDs: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: REF CD.DrawInformation] -- CD.DrawProc -- =
BEGIN
CDProperties.PutPropOnObject[onto: inst.ob, prop: cellIDKey, val: NIL];
IF inst.ob.class.inDirectory THEN
inst.ob.class.drawMe[inst: inst, pos: inst.location, orient: inst.orientation, pr: clearIDsRec]; 
END;

SymHeader: PROC [obj: CD.Object]=
BEGIN
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.PutPropOnObject[obj, cellIDKey, cellID];
END;

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

SymTrailer: PROC =
BEGIN
cifFile.PutRope["DF;\n"];
END;

CallChildren: CD.DrawProc =
BEGIN
IF ~SimpleRect[inst.ob] THEN {
cifPos: CIFPos _ CDPosToCIF[CDOrient.MapPoint[
pointInCell: [0, 0], 
cellSize: inst.ob.size,
cellInstOrient: orient,
cellInstPos: pos
]];
CIFSymbolCall[inst.ob, orient, cifPos];
};
END;

DrawRectChilds: CD.DrawProc =
BEGIN
IF SimpleRect[inst.ob] THEN {
inst.ob.class.drawMe[inst: inst, pos: pos, orient: orient, pr: pr];
};
END;

GenerateCompositeOb: PROC [obj: CD.Object] =
BEGIN
cf: REF CD.ContextFilter _ NEW[CD.ContextFilter_ALL[NIL]];
pr: CD.DrawRef _ CD.CreateDrawRef[design];
dummyApPtr: CD.Instance = NEW[CD.InstanceRep]; 
dummyApPtr^.ob _ obj;  
pr.stopFlag _ stopFlag;
SymHeader[obj];
CIFDrawCellName[CDDirectory.Name[obj]];
pr.contextFilter _ NIL;
pr.drawChild _ CallChildren;
pr.drawRect _ IgnoreRect;
obj.class.drawMe[dummyApPtr, [0, 0], CD.original, 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] _ Imager.black;
obj.class.drawMe[dummyApPtr, [0, 0], CD.original, pr];
cf[currentDirective.cdSource] _ NIL;
ENDLOOP;
SymTrailer[];
END;  

GenerateGeometricOb: PROC [obj: CD.Object] =
BEGIN
dummyApPtr: CD.Instance = NEW[CD.InstanceRep]; 
dummyApPtr^.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] _ Imager.black;
obj.class.drawMe[inst: dummyApPtr, pos: [0, 0], orient: 0, pr: cifDrawRec];
contextFilter[currentDirective.cdSource] _ NIL;
ENDLOOP;
};
SymTrailer[];
END;  

MustCompensate: PROC [layer: CD.Layer] RETURNS [BOOL] =
BEGIN
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];
END;

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

CifPolygonOut: PROC [points: LIST OF CD.Position] =
BEGIN
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"];
END;

polygon: CDPolygons.PolygonPtr = NARROW[obj.specificRef];
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.WriteRope["**polygon shrink or bloat failed\n"];
cifFile.PutRope["( polygon has incorrect sizing );\n"];
};
SymTrailer[];
END;  

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

CheckChildren: CDDirectory.EnumerateObjectsProc = 
BEGIN
CIFDefineObject[me]
END;

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

IF obj.class.inDirectory THEN {
CDDirectory.EnumerateChildObjects[obj, CheckChildren, NIL];
};
WITH obj.specificRef SELECT FROM
refPtr: CDImports.ImportPtr => {
IF refPtr.boundInstance=NIL THEN ERROR;
CIFDefineObject[refPtr.boundInstance.ob];
SymHeader[obj];
CIFDrawCellName[Rope.Cat[refPtr.designName, ".", refPtr.objectName]];
CIFSymbolCall[refPtr.boundInstance.ob, CD.original, [0, 0]];
SymTrailer[];
};
cellptr: CD.CellPtr => {
SymHeader[obj];
CIFDrawCellName[cellptr.name];

FOR instList: CD.InstanceList _ cellptr.contents, instList.rest WHILE instList#NIL DO
IF ~SimpleRect[instList.first.ob] THEN {
cifPos: CIFPos _ CDPosToCIF[CDOrient.MapPoint[
pointInCell: [0, 0], 
cellSize: instList.first.ob.size,
cellInstOrient: instList.first.orientation,
cellInstPos: instList.first.location
]];
CIFSymbolCall[instList.first.ob, instList.first.orientation, cifPos];
};
ENDLOOP;

FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
FOR instList: CD.InstanceList _ cellptr.contents, instList.rest WHILE instList#NIL DO
IF SimpleRect[instList.first.ob] THEN {
instList.first.ob.class.drawMe[inst: instList.first, pos: instList.first.location, orient: instList.first.orientation, pr: cifDrawRec];
};
ENDLOOP;
ENDLOOP;

FOR instList: CD.InstanceList _ cellptr.contents, instList.rest WHILE instList#NIL DO
value: REF = CDProperties.GetPropFromInstance[instList.first, $SignalName];
IF value#NIL THEN
IF SimpleRect[instList.first.ob] THEN
CIFLabelTerminalIO[instList.first, NARROW[value], instList.first.ob.layer];
ENDLOOP;
 
SymTrailer[];
}; -- of cell
ENDCASE => -- crazy or transistors or geometry or rects
IF obj.class.inDirectory THEN GenerateCompositeOb[obj]
ELSE IF ~SimpleRect[obj] THEN {
IF ISTYPE[obj.specificRef, CDPolygons.PolygonPtr] AND ~MustCompensate[obj.layer] THEN GeneratePolygon[obj]
ELSE GenerateGeometricOb[obj];
};
IF debugging THEN TerminalIO.WriteRope["Leaving CIFDefineObject\n"];
END; 


CIFSymbolCall: PROC[ob: CD.Object, orient: CD.Orientation_CDOrient.original, pos: CD.Position_ [0,0]] =
BEGIN
WITH CDProperties.GetPropFromObject[ob, cellIDKey] SELECT FROM
iDNo: REF INT => {
cifFile.PutF["C %d", IO.int[iDNo^]];
IF orient#CD.original THEN {
xrotation: CD.Orientation _ CDOrient.ConcentrateOnRotate90[orient];
IF xrotation#CD.original THEN {
cifFile.PutRope[" R "];
cifFile.PutRope[SELECT xrotation FROM
CDOrient.rotate90 => "0,1" ,
CDOrient.rotate180=> "-1,0",
CDOrient.rotate270=> "0,-1",
ENDCASE=> "1,0" -- never use this one
];  
};
IF CDOrient.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;
END;
  

  
CIFMeasureArea: PROC [r: CD.Rect,  l: CD.Layer, pr: CD.DrawRef] =
BEGIN
r _ CDBasics.NormalizeRect[r];
IF CDBasics.NonEmpty[r] THEN mainRect _ CDBasics.Surround[mainRect, r];
END; 
  
IgnoreRect: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef]  =
BEGIN
END; 

CIFOrArea: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef]  =
BEGIN
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN {
rd: CIFRect _ CDBasics.Extend[CDRectToCIF[CDBasics.NormalizeRect[r]], currentDirective.deltaRadius/nmPerCIF];
IF CDBasics.NonEmpty[rd] THEN CIFRectOut[rd];
}
END; 
   
CIFRectOut: PROC [r: CIFRect] =
BEGIN
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 -- ];
END;

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

CIFLabelTerminalIO: PROC [ap: CD.Instance, s: Rope.ROPE, lev: CD.Layer] =
BEGIN
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"]; 
END;

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


RopeNeeded: SIGNAL [ ref: REF REF ] = CODE;

ToRope: PROC [ ref: REF ] RETURNS [ rope: Rope.ROPE ] =
BEGIN
WITH ref SELECT FROM
r: Rope.ROPE => rope _ r;
rt: REF TEXT => rope _ Rope.FromRefText[rt];
a: ATOM => rope _ Atom.GetPName[a];
ri: REF INT => rope _ IO.PutFR[format: "%d", v1: IO.int[ri^]];
ENDCASE => 
IF ref=NIL THEN rope _ NIL
ELSE {
refRef: REF REF = NEW[REF _ ref];
SIGNAL RopeNeeded[refRef];
rope _ ToRope[refRef^ ! RopeNeeded => GOTO NoHelp];
EXITS NoHelp => ERROR;
};
END;


CantRepresentExactly: ERROR = CODE;

SetCIFScaling: PROC =
BEGIN
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;
END;


CollectDirectives: PROC =
BEGIN

GetDirectives: PROC [p: REF, lev: CD.Layer] RETURNS [l: LIST OF REF ANY _ NIL] =
BEGIN
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, ToRope[p], 0]]];
};
END;

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

GetCifPerLambda: PROC [] =
BEGIN
WITH CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFUnitsPerLambda] SELECT FROM
ri: REF INT => cifPerLambda _ ri^;
ENDCASE  => cifPerLambda _ 0;
TerminalIO.WriteF["using %g cif units per lambda; (1 CIF unit = 0.01 microns)\n", IO.int[cifPerLambda]] ;
IF cifPerLambda<2 THEN {
TerminalIO.WriteRope["cif units per lambda not reasonable\n"];
ERROR ABORTED
};
END;
  
WriteCIF: PROC[ comm: CDSequencer.Command] =
BEGIN 
ENABLE BEGIN
ABORTED => {TerminalIO.WriteRope["  CIF generation aborted\n"]; GOTO Exit};
RopeNeeded => {
explanation: Rope.ROPE = IO.PutFR[format: "Please enter a string corresponding to the value %g: ", v1: IO.refAny[ref^]];
ref^ _ TerminalIO.RequestRope[explanation];
RESUME;
};
UNWIND => NULL;
END; --enable
 
mainOb: CD.Object;
cifKey: Rope.ROPE;
design _ comm.design;
lambda _ design.technology.lambda;
SetUpSpecialClasses[];
cifKey _ ToRope[CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFName]];
IF Rope.IsEmpty[cifKey] THEN {
TerminalIO.WriteRope["The CIF layers for this technology are not yet defined\n"];
RETURN
};
TerminalIO.WriteRopes["Use CIF layer definitions [", cifKey, "]\n"];


mainOb _ CDExtras.CreateDummyObject[design];
cellCount _ 0;
stopFlag^ _ FALSE;
 
cifMeasureR _ CD.CreateDrawRef[design];
cifMeasureR.interestClip _ CDBasics.universe;
cifMeasureR.drawRect _ CIFMeasureArea;
cifMeasureR.stopFlag _ stopFlag;

clearIDsRec _ CD.CreateDrawRef[design];
clearIDsRec.interestClip _ CDBasics.universe;
clearIDsRec.drawChild _ ClearCellIDs;
clearIDsRec.stopFlag _ stopFlag;
 
cifDrawRec  _ CD.CreateDrawRef[design];
cifDrawRec.interestClip _ CDBasics.universe;
cifDrawRec.drawRect _ CIFOrArea;
cifDrawRec.stopFlag _ stopFlag;
 
CDOps.DrawDesign[design,  cifMeasureR];  
GetCifPerLambda[];
TerminalIO.WriteRopes["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.WriteRope[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.WriteRope["Comment line: \n"];
comment _ TerminalIO.RequestRope["(parens must balance, CR for no comment)\n>> "];
WHILE NOT Rope.IsEmpty[comment] DO
cifFile.PutF["( %s );\n", IO.rope[comment]];
comment _ NIL;
TerminalIO.WriteRope["Another comment line:\n"];
comment_TerminalIO.RequestRope[
"(parens must balance, CR for no further comments)\n>> "];
ENDLOOP;
IO.PutChar[cifFile, IO.CR]; 
 

CollectDirectives[];
SetCIFScaling[];
ClearCellIDs[design.actual.first.dummyCell, [0,0], 0, 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, CDOrient.original, [x: -cifPerLambda*mainRect.x1/lambda, y: -cifPerLambda*mainRect.y2/lambda]];
cifFile.PutRope[";\nEnd ... \n"];  
cifFile.Close[];
TerminalIO.WriteF["\nCIF file on %g\n", IO.rope[name]];
FreeStorage[]
EXITS
Exit => FreeStorage[];
FileIOOpenFailed => {
TerminalIO.WriteRope["Open Failed\n"]; 
FreeStorage[]
};
END; -- of WriteCIF



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

AnalyzeTesselation: PROC [ms: MaskStateRef] =
BEGIN
active: CD.Rect = ms.areas.ContentsBound[rect: CDBasics.universe];
IF CDBasics.NonEmpty[active] THEN {
IF currentDirective.deltaRadius#0 THEN {
t: REF CornerStitching.Tesselation = ms.unbloated;
ms.unbloated _ ms.areas;
ms.areas _ t;
CornerStitching.ChangeRect[plane: ms.areas, rect: CDBasics.universe, newValue: NIL];
IF currentDirective.deltaRadius>0 THEN
CornerStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, perTile: BloatTile, data: ms]
ELSE {
CornerStitching.ChangeRect[plane: ms.areas, rect: active, newValue: $covered];
CornerStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, perTile: BloatTile, data: ms,
skipValue: $covered];
};
};
CornerStitching.EnumerateArea[plane: ms.areas, rect: CDBasics.universe,
perTile: OutputTile, data: ms];
TerminalIO.WriteRope["."]; 
};
END;

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

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

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

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.WriteF[".. in %d rows and %d columns..", IO.int[nRows], IO.int[nCols]];
dr.drawRect _ NoteRectangle;
dr.devicePrivate _ ms;

TerminalIO.WriteF["%s -> %s", IO.rope[ToRope[CD.LayerKey[currentDirective.cdSource]]], IO.rope[currentDirective.cifDest]];
FOR col: NAT IN [0..nCols) DO
FOR row: NAT IN [0..nRows) DO
ms.areas.ChangeRect[rect: CDBasics.universe, newValue: 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]];
CDViewer.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.WriteRope["+"];
CDViewer.RemoveArrow[design: design];
dr _ NIL;
END;

NoteBoundingBox: PROC [ r: CD.Rect, l: CD.Layer, pr: CD.DrawRef ] =
BEGIN
bb: REF CD.Rect = NARROW[pr.devicePrivate];
bb^ _ CDBasics.Surround[bb^, r];
END;

NoteRectangle: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
ms: MaskStateRef = NARROW[pr.devicePrivate];
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN
ms.areas.ChangeRect[
rect: CDRectToCIF[r], 
newValue: $covered
];
END;

BloatTile: PROCEDURE [tile: REF CornerStitching.Tile, data: REF ANY] =
-- CornerStitching.PerTileProc -- 
BEGIN
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, newValue: tile.Value];
END;

Bloat: PROC [r: CD.Rect, delta: CD.Number] RETURNS [br: CD.Rect] = INLINE
BEGIN
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]
END;

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

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

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

CIFRectToCD: PROC [ cifr: CIFRect ] RETURNS [ cdr: CD.Rect ] =
BEGIN
cdr _ CDBasics.NormalizeRect[[
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;

PrescaleCIF: PROC [ cif: Rational ] RETURNS [ INT ] =
BEGIN
n: INT = cif.num*cifScaling.denom;
d: INT = cif.denom*cifScaling.num;
IF ABS[n] MOD ABS[d] # 0 THEN ERROR CantRepresentExactly;
RETURN[n/d];
END;

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

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

GCD: PROC [ m, n: INT ] RETURNS [ INT ] =
BEGIN
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];
END;


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


RegisterRegistration: PROC [] =
TRUSTED BEGIN
new: LIST OF REF ANY _ 
LIST[$CDxCIFName, $CDxCIFTechnology, $CDxCIFSpecials, $CDxCIFUnitsPerLambda];
list: LIST OF REF ANY _ WITH CDProperties.GetPropFromAtom[$RegistrationRoot, $CDxCIFRegistrations] SELECT FROM
lora: LIST OF REF ANY => lora,
loa: LIST OF ATOM => LOOPHOLE[loa],
a: ATOM=> LIST[a],
ENDCASE => NIL;
list _ List.Nconc[list, new];
CDProperties.PutPropOnAtom[onto: $RegistrationRoot, prop: $CDxCIFRegistrations, val: list];
END;


RegisterRegistration[];
CDSequencer.ImplementCommand[a: $WriteCif, p: WriteCIFComm, queue: doQueue];
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Hierarchical CIF", key: $WriteCif];
END.  
ϊBrandyCIFter.mesa  	A module to output CIF files from ChipNDale
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Last Edited by: Kimr, October 15, 1984 5:15:13 pm PDT
Last Edited by: Jacobi, October 30, 1984 12:10:38 pm PST
Last Edited by McCreight, October 17, 1984 7:02:18 pm PDT
Last Edited by Jacobi, January 15, 1986 7:52:09 pm PST
--TYPES


--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

--Procedures
--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--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
--PROC [inst: Instance, pos: Position, orient: Orientation, pr: REF DrawInformation]
--logically local to GenerateCompositeOb
--PROC [inst: Instance, pos: Position, orient: Orientation, pr: REF DrawInformation]
--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
--pos in CIFUnits
--indicate which cell is called using its ID number
--OUTPUT PROCEDURES
-- CD.DrawRectProc  
-- 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
Κ#L˜
codeš
œ?™?Kšœ
Οm
œ7™BKš
œ5™5Kš
œ8™8K™9Kš
œ6™6—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š
œ˜—Kš
œ˜šΟbœžœ
ž˜Kš
žœžœEžœažœžœ˜ΰ
—Kš
ž˜K˜Kš
Ÿ™™Kšœ
žœžœ˜Kšœžœžœ
Οcœ˜.Kšœ	žœžœ œ˜+Kšœ
žœžœžœ˜.Kšœ	žœžœžœ
˜%šœžœžœ˜Kšœžœ
˜Kšœ
žœ
 $˜5Kš
œ˜—Kšœžœžœžœ
˜/šœžœžœ˜ Kšœ
žœ˜Kšœžœ
˜Kšœ
žœ
 $˜5K˜—Kšœžœžœ˜#šœžœžœ˜Kšœžœžœ˜9Kš
œ˜Kš
œ˜K˜——K™Kš
Ÿ™˜Kš
œžœ
žœžœ
žœ ˜=K˜Kšœžœžœ +˜HK˜Kšœžœ
˜Kšœžœ
žœ
žœ˜*Kš	œ
žœ
žœžœ
žœ˜%Kšœ
žœ˜Kšœ
žœ	˜šœ
žœ
 ˜(Kšœžœ
žœžœ
žœžœ
žœ ˜ZK˜—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˜—Kš
œ˜Kš
Οn™˜š’œžœ˜Kš
ž˜Kšœ)žœ ˜JKšœ	žœ
˜
Kšœ
žœ
˜Kšžœ
˜—K˜š
’
œžœžœ	žœžœ˜6Kš
ž˜Kšœžœ˜6Kšžœ
˜——˜Kš
œ ™ K˜Kš
œE˜EK˜š’œžœ˜Kš
ž˜KšœžœA˜Gšžœžœžœ˜9Kšžœžœ
žœ5˜BKšžœK˜OKšžœ
ž˜
K˜—šžœ=žœ
ž˜LKš
œ7˜7Kšžœ3˜:—Kšžœ
˜—K˜š’
œžœžœ	žœžœ
žœ˜?Kš
ž˜KšœLž˜OKšžœ
˜—K˜š’œžœžœ
˜)Kš
ž˜šžœGžœ
ž˜Všœžœ
žœžœ	žœžœ˜5Kšœžœ˜Kšžœ˜K˜—šœžœ˜Kšžœ˜K˜—šœžœ
žœ˜Kšžœ˜K˜—šžœ˜Kš
œH˜HKš
ž˜K˜——Kšžœ
˜—K™K™Kš
œ ™ K˜š’œžœžœžœžœžœ
žœ œ˜€
Kš
œ0™0Kš
ž˜KšœBžœ˜Gšžœž˜!Kš
œa˜a—Kšžœ
˜—K˜š’	œžœžœ	˜!Kš
œ3™3Kš
ž˜Kš	œžœ
žœžœ
žœ ˜9š
œ˜Kšžœžœžœ˜E—Kš
œ5˜5Kšžœ
˜K˜—š’œžœžœ	˜+Kš
œ3™3Kš
œ™Kš
ž˜Kš	œžœ
žœžœ
žœ ˜9š
œ˜Kšžœ˜—Kš
œ5˜5Kšžœ
˜K˜—š’
œžœ˜Kš
œ™Kš
ž˜Kš
œ˜Kšžœ
˜K˜—Kš
œ(™(šŸœžœ˜Kš
œT™TKš
ž˜šžœžœ˜š
œ.˜.Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ'˜'Kš
œ˜—Kšžœ
˜—K˜Kš
œ(™(šŸœžœ˜Kš
œT™TKš
ž˜šžœžœ˜Kš
œC˜CKš
œ˜—Kšžœ
˜—K˜š’œžœžœ
˜,Kš
œ™Kš
œ&™&Kš
ž˜Kš
œžœ
žœžœ
žœžœ
žœ˜:Kšœžœžœ˜*šœžœžœ
žœ˜/Kš
œ$™$—Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ'˜'Kš
œ™Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ6˜6Kš
œ™Kš
œ˜Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šœžœ
˜Kšžœ!žœ"™L—Kš
œ-˜-Kš
œ6˜6Kšœ žœ
˜$Kšžœ
˜—Kš
œ
˜
Kšžœ˜—K˜š’œžœžœ
˜,Kš
œ9™9Kš
ž˜šœžœžœ
žœ˜/Kš
œ$™$—Kš
œ˜šžœžœ˜Kš
œ˜Kš
œ˜K˜
—šžœ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šœžœ
˜Kš
œL™L—Kš
œ)˜)Kš
œ8˜8Kš
œK˜KKš
œ/˜/Kšžœ
˜—K˜—Kš
œ
˜
Kšžœ˜—K˜š
’œžœ	žœžœžœ˜7Kš
ž˜šžœžœ
žœ
žœ
žœžœžœ
ž˜IKšœžœ˜)Kš
žœžœžœ
žœžœ˜AKšžœ
˜—Kšžœžœ˜Kšžœ
˜—K˜š’œžœžœ
˜(Kš
œ(™(Kš
ž˜K˜š
’
œžœ
žœ
žœ
žœ˜3Kš
œ1™1Kš
ž˜šžœ
žœž˜Kšœžœ!˜;Kšœžœ
˜Kšž
œ
˜—Kš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜:Kšœžœ ˜*Kš
œ˜Kš
œ ˜ Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜Kšœ!žœ˜9Kšœžœžœ
˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,Kšœžœ
˜šžœ%ž˜-Kšžœ žœž˜2Kš
œ˜K˜
—Kšžœ
˜—šžœžœ˜
Kš
œ;˜;Kš
œ7˜7K˜—Kš
œ
˜
Kšžœ˜—K˜š’œžœžœ
˜(Kš
ϡ
™°
Kš
ž˜K˜šŸ
œ%˜2Kš
ž˜Kš
œ˜Kšžœ
˜K˜—Kšžœžœ4˜EKš
œ˜šžœ0žœ
žœ
žœ˜EKš
œh™h—Kš
œ˜Kš
œ―
™―
K˜šžœžœ˜Kšœ6žœ˜;K˜—šžœžœ
ž˜ š
œ ˜ Kšžœžœ
žœ
žœ
˜'Kš
œ)˜)Kš
œ˜Kš
œE˜EKšœ'žœ˜<Kš
œ
˜
Kš
œ˜—šœ	žœ
˜Kš
œ˜Kš
œ˜K˜Kš
œi™iš	žœžœ0žœ
žœ
ž˜Ušžœ žœ˜(š
œ.˜.Kš
œ˜Kš
œ!˜!Kš
œ+˜+Kš
œ$˜$Kš
œ˜—Kš
œE˜EKš
œ˜—Kšžœ
˜—K˜Kš
œB™BKš
œ™šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šœžœ
˜Kš
œ@™@—š	žœžœ0žœ
žœ
ž˜Ušžœžœ˜'Kš
œ‡
˜‡
Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K˜Kš
œ™š	žœžœ0žœ
žœ
ž˜UKšœžœA˜Kšžœžœ
ž˜šžœž˜%Kšœ#žœ"˜K——Kšžœ
˜—Kš
œ
˜
Kš
œ
˜
Kšž
œ 
˜
—šžœ ,˜7Kšžœžœ˜6šžœ
žœžœ˜Kšžœ
žœ)žœžœ˜jKšžœ˜K˜———Kšžœžœ3˜DKšžœ˜—K˜K˜š
’
œžœžœžœ%žœ˜gKš
œ™Kš
œ3™3Kš
ž˜šžœ/žœ
ž˜>šœžœ
žœ˜Kšœžœ
˜$šžœžœ
žœ˜Kšœžœ6˜Cšžœžœ
žœ˜Kš
œ˜šœžœž˜%Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ	 ˜%Kš
œ˜—Kš
œ˜—Kšžœ"žœ˜BKš
œ˜—šžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kšž
œ
˜—Kšžœžœ
˜—Kšžœ
˜—Kš
œ˜Kš
Ÿ™K˜Kš
œ˜š
Πbnœžœžœžœžœ˜AKš
œ™Kš
œA™AKš
ž˜Kš
œ˜Kšžœžœ+˜GKšžœ˜—Kš
œ˜š
£
œžœžœ
žœžœ˜=Kš
ž˜Kšžœ˜—K˜š
£	œžœžœ
žœžœ˜<Kš
ž˜šžœžœžœ˜>Kš
œm˜mKšžœžœ˜-Kš
œ
˜
—Kšžœ˜—Kš
œ˜š’
œžœ˜Kš
ž˜Kšžœ
žœžœ
žœ
˜(šžœ
žœž˜Kšœžœ!˜;Kšœžœ
˜Kšž
œ
˜—šœ  &˜FKšžœ" œ˜2Kšžœ" œ˜1Kšžœ" œ˜:Kšžœ" œ˜;—Kšžœ
˜K˜—š’œžœ˜#Kš
ž˜Kšœžœžœ˜MKšžœ
˜K˜—š
’œžœžœžœžœ	˜IKš
ž˜Kš
œJ˜JKšœžœ
˜#Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜+Kšžœžœžœ˜<Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜š’œžœ	žœ˜%Kš
ž˜Kš
œ˜Kšžœžœžœ
˜=Kšžœ
˜—K˜K˜Kš	œžœžœ
žœžœ
˜+K˜š
’œžœžœžœžœ˜7Kš
ž˜šžœžœ
ž˜Kšœžœ
˜Kšœžœ
žœ ˜,Kšœžœ˜#Kš	œžœ
žœžœžœ˜>šžœ˜Kšžœžœ
žœž˜šžœ˜Kš	œžœ
žœžœ
žœ˜!Kšžœ˜Kšœ&žœ	˜3Kšžœžœ
˜Kš
œ˜———Kšžœ
˜K˜—K˜Kšœžœžœ
˜#K˜š’
œžœ˜Kš
ž˜Kšœ@ !˜ašžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜+Kš
œ˜šžœ
žœžœž˜+Kšžœ˜—Kšœžœ˜"š
œ˜Kš
œ˜Kšœ)žœ)˜UKš
œz™z—Kšžœ
˜—Kšžœ
˜K˜K˜—š’œžœ˜Kš
ž˜K˜š’
œžœžœžœžœžœ
žœ
žœ
žœžœ˜PKš
ž˜šžœžœ
žœ˜šžœžœ
ž˜Kšœžœ
žœ5˜PKš	œžœ
žœ
žœ
žœS˜hKšžœžœ
žœ)˜@—Kš
œ˜—Kšžœ
˜K˜—Kšœžœ
˜š
žœ	žœ
žœ
žœ3žœžœ
ž˜\Kš
œŒ
˜Œ
Kšžœ
˜—Kšžœ
˜K˜—š’œžœ˜Kš
ž˜šžœCžœ
ž˜RKšœžœ
žœ˜"Kšžœ˜—Kš
œi˜išžœžœ˜Kš
œ>˜>Kšžœ
ž˜
K˜—Kšžœ
˜—Kš
œ˜š’œžœ˜,šžœ
˜Kšžœ
ž˜Kšžœ9žœ˜Kš
œ˜KšœžœžœLžœ˜xKš
œ+˜+Kšžœ
˜Kš
œ˜—Kšžœžœ
˜Kšžœ ˜
—Kš
œ
˜
Kš
œ&™&Kš
œ˜Kšœ
žœ
˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œI˜Išžœžœ˜Kš
œQ˜QKš
ž˜K˜—š
œD˜DK˜—Kš
œO™OK™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šœ2žœ$˜ZKš
œ%˜%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š
œR˜Ršžœ
žœž˜"Kš
œ,˜,Kšœ
žœ
˜Kš
œ0˜0š
œ˜Kš
œ:˜:—Kšžœ
˜—šžœžœ
žœ˜Kš
œ
˜
K˜—Kš
œ˜Kš
œ˜Kšœ6žœ˜;Kš
œ˜K˜Kš
œ ™ Kš
œ˜Kš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XKšœžœ˜,šžœ žœ˜(Kšœžœ
˜Kš
œ"˜"Kš
œ˜—Kšžœ
˜—K˜
K˜Kš
œy˜yKš
œ#˜#Kš
œ˜Kšœ(žœ
˜7Kš
œ
˜
š
ž˜Kš
œ˜š
œ˜Kš
œ'˜'Kš
œ
˜
Kš
œ˜——Kšžœ ˜K˜—K˜—š
Ρbls™K˜—™š’œžœžœ˜3Kš
ž˜K˜š’œžœ˜-Kš
ž˜Kš
œ'™'Kšœžœ8˜Bšžœžœ˜#šžœ žœ˜(Kšœžœ,˜2Kš
œ˜Kš
œ
˜
KšœOžœ˜Tšžœ ž˜&Kš
œi˜i—šžœ˜Kš
œN˜NKš
œ˜Kš
œ˜—Kš
œ˜—Kš
œg˜gKš
œ˜Kš
œ˜—Kšžœ
˜K˜—š’
œž	œ(žœ
žœ
žœ
 ˜gKšžœ
 +˜1Kšœžœ˜ Kš
œ<˜<Kš
œ
˜
Kšžœ
˜K˜—Kšœžœ˜Kšœ	žœ˜Kšœžœ
˜šœžœ˜$Kš
œ(˜(Kš
œ+˜+Kš
œ˜—K˜Kšœžœžœ˜*Kš
œ˜Kš
œ˜Kšœžœ
žœ˜1Kš
œ$˜$Kš
œ˜K˜Kšœ ˜/K˜Kšœ
žœžœ
žœ˜4K˜Kšœ)žœ)˜UK˜Kš
œ?˜?K˜>K˜Kšœ4žœ
žœ
˜RK™Kš
œ˜K˜K˜Kšœžœ
žœ(žœ!˜zšžœžœ
žœž˜šžœžœ
žœž˜Kšœ7žœ˜<šœ ˜Kš
œ˜Kš
œ˜Kšœžœ1˜QKšœžœ2˜SKš
œ˜—Kšœ=žœ*˜jš
œ"˜"Kšœd ˜v—Kšœ 5˜SKšœ ˜6Kšžœ
˜—Kšžœ
˜—Kš
œ˜K˜%Kšœžœ
˜	Kšžœ
˜K˜—š
’œžœžœ
žœžœ˜CKš
ž˜Kšœžœ
žœžœ˜+Kš
œ ˜ Kšžœ
˜K˜—š
’
œžœžœ
žœžœ˜?Kš
ž˜Kšœžœ˜,šžœžœž˜<š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜——Kšžœ
˜K˜—š’	œž	œ(žœ
žœ
žœ
 !œ
˜iKš
ž˜Kšœžœ˜ KšœžœBžœ*˜ušžœž˜Kš
œ4˜4—Kšžœ
˜K˜—š
’œžœžœžœ	žœžœ	ž˜IKš
ž˜Kš
œF™FKšœ
žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ˜·
Kšžœ
˜—K˜š’œžœžœžœ˜>Kš
ž˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ
˜K˜—š’
œžœžœžœ˜@Kš
ž˜Kš
œC˜CKšžœ
˜K˜—š’œžœžœ
žœ˜:Kš
ž˜Kš
œ&˜&Kšžœ
˜K˜—š’œžœžœžœ	˜>Kš
œ™š
ž˜š
œ˜Kš
œ ˜ Kš
œ ˜ Kš
œ1˜1Kš
œ0˜0Kš
œ˜——Kšžœ
˜—K˜š’œžœžœžœ˜5Kš
ž˜Kšœžœ˜"Kšœžœ˜"Kšžœ
žœžœ
žœžœ
žœ˜9Kšžœ˜šžœ
˜K˜——š
’œžœžœ	žœžœ˜:Kš
ž˜Kš
œ˜Kšžœ
˜K˜—š’œžœžœ˜8Kš
ž˜Kšœžœžœ˜Kšžœ'˜-Kšžœ
˜K˜—š
Πbkœžœ	žœžœžœ˜)Kš
ž˜Kšœžœ
˜šžœž˜
Kš
œ
˜
Kšžœžœ
˜—šžœž˜
Kš
œ
˜
Kšœžœ
˜Kšžœžœ˜—Kšœžœ˜Kšžœžœžœžœ
˜0Kšžœ˜
Kšžœ
˜——K˜K˜š£œžœ˜0Kšžœ
˜Kš
œ3˜3Kš
œG˜GKš
œH˜Hšžœ!žœ˜)Kš
œ1˜1Kš
ž˜K˜—šžœ+žœ˜3Kš
œ:˜:Kš
ž˜K˜—Kš
œC˜CKšžœ
˜K˜—K˜š’œžœ˜Kšžœ
ž˜
š	œžœ
žœ
žœ
žœ˜KšžœI˜M—šœžœ
žœ
žœ
žœžœGžœ
ž˜nKš	œžœ
žœ
žœ
žœ	˜Kš	œžœ
žœ
žœžœ˜#Kšœžœžœ˜Kšžœžœ
˜—Kš
œ˜Kš
œ[˜[Kšžœ
˜—K˜K˜Kš
œ˜Kš
œL˜LKš
œS˜SKšžœ˜—…—b²’ψ