DIRECTORY
Ascii,
Atom,
Basics USING [BITOR, BITSHIFT],
CD,
CDInstances,
CDBasics,
CDCells,
CDCellsBackdoor,
CDDirectory,
CDOps,
CDProperties,
CDRects,
CDRepetitions,
CDSequencer,
CDIO, 
CDTexts,
CDViewer,
FS,
RefTab,
IO,
CMos,
CMosCMContacts,
CMosCMTransistors,
Rope,
RuntimeError,
TerminalIO;

ChipmonkCMosWrite: CEDAR MONITOR
IMPORTS Ascii, Atom, Basics, CD, CDBasics, CDCells, CDCellsBackdoor, CDInstances, CDDirectory, CDOps, CDProperties, CDSequencer, CDIO, FS, RefTab, IO, CMos, Rope, RuntimeError, TerminalIO =
BEGIN

TransformSelected: PROC [design: CD.Design, transform: CD.Orientation, base: CD.Rect_[0, 0, -1, -1]] = {
ib, is, orientOff: CD.Position; r, oldbb: CD.Rect; oldPseudoCellT, newPseudoCellT: CD.Transformation;
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
IF sel=NIL THEN RETURN;
oldbb _ CDInstances.BoundingRectO[sel];
IF ~CDBasics.NonEmpty[base] THEN base _ CDInstances.BoundingRectI[sel];
ib _ CDBasics.BaseOfRect[base];
is _ CDBasics.SizeOfRect[base];
oldPseudoCellT _ [ib, original];
r _ CDBasics.MapRect[CDBasics.RectAt[[0,0], is], [[0,0], transform]];
orientOff _ CDBasics.BaseOfRect[r];
newPseudoCellT _ [CDBasics.SubPoints[ib, orientOff], transform];
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
pseudoCellRel: CD.Transformation _ CDBasics.DecomposeTransform[w.first.trans, oldPseudoCellT];
w.first.trans _ CDBasics.ComposeTransform[pseudoCellRel, newPseudoCellT]
ENDLOOP;
CDOps.Redraw[design, oldbb];
CDOps.Redraw[design, CDBasics.MapRect[CDBasics.DeMapRect[oldbb, oldPseudoCellT], newPseudoCellT]]
};

lambdaInChipmonk: INTEGER = 2;  
lambdaFactor: INT = CMos.lambda/lambdaInChipmonk;

codeWordForDataFile: CARDINAL = 123751B;
instanceCode: INTEGER = 1;
transistorCode: INTEGER = 2;	
contactCode: INTEGER = 3;
wireCode: INTEGER = 4;
rectangleCode: INTEGER = 5;
textCode: INTEGER = 6;
busCode: INTEGER = 7;
repeatCode: INTEGER = 8;

stream: IO.STREAM;
PushedState: ERROR = CODE;
gMark: RefTab.Ref _ NIL;

OutWord: PROC [w: INT] =
BEGIN
i: INTEGER = w;  --traps if necessary
c: CARDINAL _ LOOPHOLE[i, CARDINAL];
IO.PutChar[stream, LOOPHOLE[c / 256, CHAR]];
IO.PutChar[stream, LOOPHOLE[c MOD 256, CHAR]];
END;

OutNumber: PROC [n: CD.Number] =
-- does a lambda correction
BEGIN
i: INTEGER = n / lambdaFactor ;  --traps if necessary
c: CARDINAL = LOOPHOLE[i];
IO.PutChar[stream, LOOPHOLE[c / 256, CHAR]];
IO.PutChar[stream, LOOPHOLE[c MOD 256, CHAR]];
END;

OutCard: PROC [c: CARDINAL] =
BEGIN
IO.PutChar[stream, LOOPHOLE[c / 256]];
IO.PutChar[stream, LOOPHOLE[c MOD 256]];
END;

OutRope: PROC [r: Rope.ROPE] =
BEGIN
leng: [0..256) = MIN[Rope.Length[r], 255];
IO.PutChar[stream, LOOPHOLE[leng, CHAR]];
FOR i: CARDINAL IN [0..leng) DO
IO.PutChar[stream, Rope.Fetch[base: r, index: i]];
ENDLOOP;
IF leng MOD 2 = 0 THEN IO.PutChar[stream, LOOPHOLE[0, CHAR]];
END;

OutRopeUpper: PROC [r: Rope.ROPE] =
BEGIN
leng: [0..256) = MIN[Rope.Length[r], 255];
IO.PutChar[stream, LOOPHOLE[leng, CHAR]];
FOR i: CARDINAL IN [0..leng) DO
IO.PutChar[stream, Ascii.Upper[Rope.Fetch[base: r, index: i]]];
ENDLOOP;
IF leng MOD 2 = 0 THEN IO.PutChar[stream, LOOPHOLE[0, CHAR]];
END;

OutLevel: PROC [lev: CD.Layer] =
BEGIN
OutCard[levelTab[lev]]
END;

OutSize: PROC [s: CD.Position] =
BEGIN
OutNumber[s.x];
OutNumber[s.y];
END;

OutRect: PROC [r: CD.Rect] =
BEGIN
OutNumber[r.x1];
OutNumber[r.y1];
OutNumber[r.x2];
OutNumber[r.y2];
END;

cellCount: NAT;
outputedCellCount: NAT;
maxnum: NAT = 500;
cellNameA: REF ARRAY [0..maxnum) OF CD.Object;
design: CD.Design;
unKnowns: INT _ 0;
unknownObjects: INT _ 0;
unknownAtoms: INT _ 0;

levelTab: REF ARRAY CD.Layer OF [0..15] = NEW[ARRAY CD.Layer OF [0..15]_ALL[7]];
contactTab: REF ARRAY CMosCMContacts.ContactType OF CARDINAL _ 
NEW[ARRAY CMosCMContacts.ContactType OF CARDINAL];

EachEntryCount: CDDirectory.EachEntryAction = 
BEGIN
WITH ob.specific SELECT FROM
cptr: CD.CellSpecific => {cellCount _ cellCount+1};
ENDCASE => NULL;
END;

EachChild: CDDirectory.EachObjectProc = {
IF me.class.composed THEN [] _ EachEntryOutput[name: NIL, ob: me];
};

EachEntryOutput: CDDirectory.EachEntryAction = 
BEGIN
IF ~RefTab.Insert[gMark, ob, $x] THEN RETURN;
[] _ CDDirectory.EnumerateChildObjects[ob, EachChild];
WITH ob.specific SELECT FROM
cptr: CD.CellSpecific => {
name: Rope.ROPE _ CDDirectory.Name[ob, design];
IF name=NIL THEN name  _ "UNNAMED";
outputedCellCount _ outputedCellCount+1;
cellNameA[outputedCellCount] _ ob;
OutCard[outputedCellCount];
OutRopeUpper[name];
OutSize[CDBasics.SizeOfRect[ob.bbox]];
OutCard[20000]; -- count ??? make it big, just in case it is some kind of reference count
OutList[cptr.contents, cptr.sequence];
};
rp: CDRepetitions.RepSpecific => NULL;
ENDCASE => 
IF ob.class.composed THEN {
TerminalIO.PutRope["?"];
unKnowns_unKnowns+1;
};
END;

sig: SIGNAL = CODE;

OutputDesign: ENTRY PROC [d: CD.Design, s: IO.STREAM] = {
ENABLE UNWIND => NULL;
MOutputDesign[d, s]
};

MOutputDesign: PROC [d: CD.Design, s: IO.STREAM] =
BEGIN
ENABLE {
UNWIND => cellNameA_NIL;
PushedState => {GOTO Pushed};
RuntimeError.BoundsFault => {
TerminalIO.PutRope["BoundsFault, maybe some feature is not representable for chipmonk; proceed is secure\n"];
SIGNAL sig;
GOTO Failed
};
RuntimeError.UNCAUGHT => {
TerminalIO.PutRope["unknown error, maybe some feature is not representable for chipmonk; proceed is secure\n"];
SIGNAL sig;
GOTO Failed
};
};
gMark _ RefTab.Create[];
freeAtom _ 1;
auxAtom[0] _ [older: 0, younger: 0];
stream _ s;
design _ d;
unKnowns _ unknownObjects _ unknownAtoms _ 0;
cellCount _ outputedCellCount _ 0;
[] _ CDDirectory.Enumerate[design, EachEntryCount];
OutCard[codeWordForDataFile];
OutCard[7]; -- version number
OutCard[cellCount];
cellNameA _ NEW[ARRAY [0..maxnum) OF CD.Object _ ALL[NIL]];
[] _ CDDirectory.Enumerate[design, EachEntryOutput];
IF outputedCellCount#cellCount THEN ERROR;
OutPushedLevels[];
OutCard[0];  -- pushed layer 0
OutCard[0];  -- anychanges
OutList[design.actual.first.specific.contents];
cellNameA_NIL;
IF unKnowns#0 THEN {
TerminalIO.PutRope["** unknown features: "];
TerminalIO.PutF1["%g", [integer[unKnowns]]];
TerminalIO.PutRope["\n"];
};
IF unknownObjects#0 THEN {
TerminalIO.PutF1["** unknown objects: %g\n", [integer[unknownObjects]]];
};
IF unknownAtoms#0 THEN {
TerminalIO.PutF1["** unknown properties or propertynames: %g\n", [integer[unknownAtoms]]];
};
EXITS
Pushed => {TerminalIO.PutRope["Output Failed (pushed in cell)\n"]};
Failed => {TerminalIO.PutRope["Output Failed \n"]};
END;

OutPushedLevels: PROC [] =
BEGIN
IF design.actual.rest#NIL THEN {
TerminalIO.PutRope["design is in pushed state\n"];
ERROR PushedState
};
END;

freeAtom: INTEGER _ 1;
AuxEntry: TYPE = RECORD [older, younger: INTEGER -- doubly-linked LRU list --];
auxAtom: REF ARRAY [0..atomTableSize] OF AuxEntry =
NEW[ARRAY [0..atomTableSize] OF AuxEntry];
atomTableSize: INTEGER = 256;
atomTable: REF ARRAY [1..atomTableSize] OF Rope.ROPE  -- for short I/O -- =
NEW[ARRAY [1..atomTableSize] OF Rope.ROPE];

ToRope: PROC [a: REF ANY] RETURNS [r: Rope.ROPE] =
BEGIN
IF a=NIL THEN RETURN [NIL];
WITH a SELECT FROM
rp: Rope.ROPE => r _ rp;
at: ATOM => r _ Atom.GetPName[at];
ENDCASE => {r _ "?Unknown?"; unknownAtoms_unknownAtoms+1};
END;

OutAtom: PROC [a: REF ANY] =
BEGIN
i: INTEGER;
r: Rope.ROPE = ToRope[a];
BEGIN
FOR i _ auxAtom[0].older, auxAtom[i].older WHILE i#0 DO
IF Rope.Equal[r, atomTable[i]] THEN {
OutCard[LOOPHOLE[-i, CARDINAL]];
auxAtom[auxAtom[i].older].younger _ auxAtom[i].younger;
auxAtom[auxAtom[i].younger].older _ auxAtom[i].older;
GOTO Touchi;
};
ENDLOOP;
IF freeAtom<atomTableSize THEN {i _ freeAtom; freeAtom _ freeAtom+1}
ELSE {
i _ auxAtom[0].younger; -- re-use oldest table entry
auxAtom[0].younger _ auxAtom[i].younger;
auxAtom[auxAtom[i].younger].older _ 0;
};
atomTable[i] _ r;
OutCard[i];
OutRope[r];
GOTO Touchi;
EXITS
Touchi => {
auxAtom[i].older _ auxAtom[0].older;
auxAtom[i].younger _ 0;
auxAtom[auxAtom[0].older].younger _ i;
auxAtom[0].older _ i;
};
END;
END;

CMHasSurround: PROC [ob: CD.Object] RETURNS [yes: BOOL] =
INLINE BEGIN
yes _ ob.layer=CMos.wpdif OR ob.layer=CMos.pdif
END;

AngleExt: PROC[tob: CD.Object] RETURNS [CD.Number] = {
tp: CMosCMTransistors.TransistorPtr = NARROW[tob.specific];
IF tob.layer=CMos.pdif OR tob.layer=CMos.nwellCont THEN {
beyondPolyX: CD.Number = MAX[0, CMos.wellSurround-tp.wExt];
RETURN [tp.width+tp.length+tp.wExt+beyondPolyX+CMos.wellSurround-CD.InterestSize[tob].x]
};
RETURN [tp.width+tp.length+tp.wExt-tob.bbox.x2]
};

Size: PROC [ob: CD.Object] RETURNS [CD.Position] =
BEGIN
s: CD.Position _ CDBasics.SizeOfRect[ob.bbox];
Symmetrical: PROC [] = {
s.x _ s.x-2*CMos.wellSurround;
s.y _ s.y-2*CMos.wellSurround;
};
IF CMHasSurround[ob] THEN 
WITH ob.specific SELECT FROM
tp: CMosCMTransistors.TransistorPtr => {
IF NOT tp.angle THEN {
s.x _ tp.width+2*tp.wExt;
s.y _ tp.length+2*tp.lExt
}
ELSE -- angle -- {
aExt: CD.Number = AngleExt[ob];
s.x _ tp.width+tp.length+tp.wExt-aExt;
s.y _ tp.wExt+2*tp.lExt+aExt+tp.length
};
};
ENDCASE => Symmetrical[];
IF s.x<0 OR s.y<0 THEN ERROR;
RETURN [s]
END;

InstLoc: PROC [inst: CD.Instance] RETURNS [CD.Position] = INLINE {
r: CD.Rect _ IF CDCells.IsCell[inst.ob] THEN CDInstances.InstRectO[inst] ELSE CDInstances.InstRectI[inst];
RETURN [CDBasics.BaseOfRect[r]];
};

OutList: PROC [list: CD.InstanceList, seq: CD.InstanceSequence_NIL] =
BEGIN

OutProps: PROC [props: CD.PropList] =
BEGIN
count: CARDINAL _ 0;
FOR pl: CD.PropList _ props, pl.rest WHILE pl#NIL DO 
IF ISTYPE[pl.first.key, ATOM] THEN count _ count+1 
ENDLOOP;
OutCard[count];
FOR pl: CD.PropList_props, pl.rest WHILE pl#NIL DO 
IF ISTYPE[pl.first.key, ATOM] THEN {
IF pl.first.key=$InstanceName OR pl.first.key=$SignalName THEN {
OutCard[1];
OutRope[ToRope[pl.first.val]]
}
ELSE {
OutCard[2];
OutAtom[pl.first.key];
OutAtom[pl.first.val];
}
}
ENDLOOP;
END;

OutInst: PROC [i: CD.Instance] RETURNS [BOOL_FALSE] = {
OutSize[InstLoc[i]];
OutOrient[i.trans.orient];
OutObject[i.ob, i];
OutProps[i.properties]
};

lCnt: INT _ CDInstances.Length[list];
sCnt: INT _ IF seq=NIL THEN 0 ELSE seq.length;
OutCard[lCnt+sCnt];
[] _ CDCellsBackdoor.EnumInsts[list, seq, OutInst]
END;


OutOrient: PROC [o: CD.Orientation] =
BEGIN
c: CARDINAL = ORD[o]/2*4 + ORD[o] MOD 2;
OutCard[c];
END;

OutObject: PROC[ob: CD.Object, appForRectProperty: CD.Instance_NIL] =
BEGIN

OutUnknownObject: PROC[r: Rope.ROPE_NIL] = {
IF NOT Rope.IsEmpty[r] THEN TerminalIO.PutRope[r];
unknownObjects_unknownObjects+1; OutCard[0];
};

OutRectObject: PROC[ob: CD.Object, appForRectProperty: CD.Instance_NIL] = 
BEGIN
x: REF _ CDProperties.GetInstanceProp[from: appForRectProperty, prop: $CDxChipmonkThinks];
lev: CD.Layer _ ob.layer;
IF lev=CMos.wpdif THEN {
lev _ CMos.pdif;
x _ NIL
};
IF x=$Rext THEN {
OutCard[rectangleCode];
OutSize[Size[ob]];
OutLevel[lev];
}
ELSE {
OutCard[wireCode];
OutSize[Size[ob]];
OutLevel[lev];
IF lev=CMos.pdif THEN OutCard[CMos.wellSurround];
};
END;

IF ob=NIL THEN {
OutCard[0]; 
unKnowns_unKnowns+1; 
TerminalIO.PutRope["nil/n"];
RETURN;
};
WITH ob.specific SELECT FROM
cptr: CD.CellSpecific => {
cellNum: NAT _ 0;
OutCard[instanceCode];
FOR i: NAT IN [1..cellCount] DO
IF ob=cellNameA[i] THEN {cellNum_i; EXIT}
ENDLOOP;
IF cellNum=0 THEN {TerminalIO.PutRope["**bad cell\n"]; unKnowns_unKnowns+1};
OutCard[cellNum];
};
rp: CD.RectSpecific => {OutRectObject[ob, appForRectProperty]};
tp: CMosCMTransistors.TransistorPtr => {
j: CARDINAL;
OutCard[transistorCode];
OutNumber[tp.width];
OutNumber[tp.length];
IF tp.lExt/lambdaFactor>63 OR tp.wExt/lambdaFactor>63 THEN ERROR;
j _ tp.lExt/lambdaFactor+tp.wExt/lambdaFactor*64;
IF tp.angle THEN j _ Basics.BITOR[j, 20000B];
IF CMHasSurround[ob] THEN j _ Basics.BITOR[j, 10000B];
OutCard[j];
IF CMHasSurround[ob] THEN OutCard[CMos.wellSurround];
IF tp.angle THEN {
s: CD.Position = Size[ob];
qq: INTEGER _ MAX[s.y-tp.wExt-tp.length-2*tp.lExt, 0];  --may be out of range
OutNumber[qq]; -- angle extension
};
};
cp: CMosCMContacts.ContactPtr => {
j: CARDINAL;
s: CD.Position = Size[ob];
ss: CARDINAL _ s.y;
OutCard[contactCode];
j _ contactTab[cp.typ];
j _ Basics.BITOR[j, Basics.BITSHIFT[ss, 8]];
OutCard[j];
OutLevel[ob.layer];
IF CMHasSurround[ob] THEN OutCard[CMos.wellSurround] ELSE OutCard[0]; 
IF cp.typ=burr THEN {
OutNumber[s.x];
OutCard[Basics.BITOR[Basics.BITSHIFT[cp.wExt, 8], cp.lExt]];
};
};
tp: CDTexts.TextSpecific => {
OutRope[tp.text];
TerminalIO.PutRope["text; font information lost\n"];
};
rp: CDRepetitions.RepSpecific => {
OutCard[repeatCode];
OutObject[rp.ob];
OutCard[0]; -- w
OutCard[0]; -- l
OutSize[rp.offset];
OutCard[rp.count]; 
OutOrient[rp.orientation];
};
ENDCASE => 
IF ob.class.wireTyped AND (ob.layer=CMos.wpdif) THEN {
OutRectObject[ob, appForRectProperty];
}
ELSE {
ob1: CD.Object _ CDDirectory.Expand1[ob, NIL, design].new;
IF ob1=NIL OR ob1.class=ob.class THEN OutUnknownObject["?"] --prevent recursion
ELSE {
OutObject[ob1, appForRectProperty]
}
};
END;


COutputDesign: PROC [comm: CDSequencer.Command] =
BEGIN
name, fileName: Rope.ROPE;
s: IO.STREAM;
wDir: Rope.ROPE _ CDIO.GetWorkingDirectory[comm.design];
TerminalIO.PutRope["Chipmonk Output Design\n"];
TerminalIO.PutRopes["file name (", wDir, ")"];
name _ TerminalIO.RequestRope[" > "]; 
fileName _ CDIO.MakeName[name, "chip", wDir];
s _ FS.StreamOpen[fileName, create ! 
FS.Error => IF error.group#bug THEN {
TerminalIO.PutRope[error.explanation];
GOTO FileIOOpenFailed; 
}
];
CDOps.DeselectAll[design: comm.design, setSelection: TRUE];
TransformSelected[comm.design, rotate180X];
OutputDesign[comm.design, s];
IO.Close[s];
TransformSelected[comm.design, rotate180X];
CDOps.DeselectAll[comm.design];
TerminalIO.PutRope[" end output\n"];
EXITS
FileIOOpenFailed => {TerminalIO.PutRope["Open Failed\n"]};
END;

levelTab[CMos.cut] _ 0;
levelTab[CMos.ndif] _ 1;
levelTab[CMos.pol] _ 2;
levelTab[CMos.met] _ 3;
levelTab[CMos.imp] _ 4;
levelTab[CMos.ovg] _ 5;
levelTab[CMos.bur] _ 6;
levelTab[CMos.cut2] _ 8;
levelTab[CMos.pdif] _ 9;
levelTab[CMos.pwellCont] _ 10;
levelTab[CMos.met2] _ 11;
levelTab[CMos.pwell] _ 12;
levelTab[CMos.nwell] _ 13;
levelTab[CMos.nwellCont] _ 14;
contactTab[burr] _ 4;
contactTab[mDif] _ 1;
contactTab[difShort] _ 12;
contactTab[butt] _ 3;
contactTab[mPol] _ 2;
contactTab[mm2] _ 5;
CDSequencer.ImplementCommand[$ChipmonkOutput, COutputDesign];
END.		





¦ChipmonkCMosWrite.mesa
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Last Edited by: Christian Jacobi, November 10, 1983 7:36 pm
Last edited by: Christian Jacobi, January 29, 1987 4:49:47 pm PST

--In Chipndale we must make no assumptions about the 
--value of lambda.  It can (and does) change from time to time;
--but we know that chipndales lambda is >= 2
-- ignores name parameter, takes name from cell-data itself
-- re-arrange LRU queue
-- add a new atom
--copied from cmostransistorsimpl
-- correctness: by comparing code with CreateTransistor
--IF tp.pullup THEN j _ Basics.BITOR[j, 40000B];
--IF tp.implant THEN j _ Basics.BITOR[j, 100000B];
ΚΈ˜
code•StartOfExpansionl[r1: 
ROPE _ NIL, r2: 
ROPE _ NIL, r3: 
ROPE _ NIL, r4: 
ROPE _ NIL, r5: 
ROPE _ NIL, r6: 
ROPE _ NIL]š
œ™Kšœ
Οm
œ7™BKš
œ;™;K™A—K™š
Οk	˜	Kš
œ˜Kš
œ˜Kšœžœžœžœ˜Kšžœ
˜Kš
œ˜Kš
œ	˜	Kš
œ˜Jš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜K˜K˜Kš
œ˜Kš
œ˜K˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜šΟnœžœ
ž˜ Kšžœzžœžœžœ(˜½
—š
ž˜K˜š
Ÿœžœ
žœžœžœ˜hKšœžœžœ'žœ˜eKšœžœA˜HKšžœžœ
žœ
žœ
˜Kš
œ'˜'Kšžœžœ'˜GKš
œ˜Kš
œ˜Jš
œ ˜ Jš
œE˜EKš
œ#˜#Jš
œ@˜@š	žœžœžœžœ
ž˜3KšœžœM˜^Kš
œH˜HKšžœ
˜—Kš
œ˜Kš
œa˜aKš
œ˜K˜—šœžœ˜ Kš
œ5™5Kš
œ?™?š
œ,™,Kšœžœ ˜1——K˜Kšœžœ˜(Kšœžœ˜Kšœžœ˜Kšœ
žœ˜Kšœ
žœ˜Kšœžœ˜Kšœ
žœ˜Kšœ	žœ˜Kšœžœ˜K˜—KšœŸž	Ÿ
˜Kšœ
žœžœ
˜Kšœžœ
˜K˜šŸœžœžœ˜Kš
ž˜KšœžœΟc˜%Kšœžœžœžœ˜$Kšžœžœ
žœ˜,Kšžœžœžœžœ˜.Kšžœ
˜—K˜šŸ	œžœžœ
˜ K˜Kš
ž˜Kšœžœ ˜5Kšœžœžœ˜Kšžœžœ
žœ˜,Kšžœžœžœžœ˜.Kšžœ
˜—K˜šŸœžœžœ˜Kš
ž˜Kšžœžœ˜&Kšžœžœžœ˜(Kšžœ
˜K˜—šŸœžœ
žœ˜Kš
ž˜Kšœžœ˜*Kšžœžœžœ˜)šžœžœ
žœž˜Kšžœ0˜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š
œ˜Kš
œ˜Kšžœ
˜K˜—Kšœžœ
˜Kšœžœ
˜Kšœžœ˜Kš	œžœ
žœ
žœ
žœ˜.Kšœžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœ˜K˜Kšœ
žœ
žœ
žœžœžœ
žœ
žœžœ	žœ˜Pš	œžœ
žœžœ
žœ˜?Kšžœ
žœžœ
žœ˜2—K˜šΟbœ ˜.Kš
ž˜šžœ
žœ
ž˜Kšœžœ˜3Kšžœžœ
˜—Kšžœ
˜—K˜šŸ	œ ˜)Jšžœžœžœ
˜BJ˜J˜—š‘œ ˜/Kš
œ;™;Kš
ž˜Jšžœžœ
žœ
˜-Jš
œ6˜6šžœ
žœ
ž˜šœžœ˜Kš
œ/˜/Kšžœžœ
žœ˜#Kš
œ(˜(Kš
œ"˜"Kš
œ˜Kš
œ˜Jš
œ&˜&Kšœ I˜YKš
œ&˜&K˜—Kšœ!žœ
˜&šžœ˜šžœžœ˜Kš
œ˜Kš
œ˜K˜———Kšžœ
˜—K˜Kšœžœžœ
˜K˜šŸœžœ
žœžœžœ
žœ˜9Jšžœ
žœžœ
˜Jš
œ˜Jš
œ˜—K˜š
Ÿ
œžœžœžœ
žœ˜2š
ž˜šžœ˜Kšžœžœ
˜Kšœžœ	˜š
œ˜Kš
œm˜mKšžœ˜Kšžœ˜Kš
œ˜—šœ
žœ˜Kš
œo˜oKšžœ˜Kšžœ˜Kš
œ˜—K˜——Jš
œ˜Kš
œ
˜
K˜$Kš
œ˜Kš
œ˜Kš
œ-˜-Kš
œ"˜"Kš
œ3˜3Kš
œ˜Kšœ ˜Kš
œ˜Kš
œžœ
žœ
žœ
žœ
žœ
žœ˜;Kš
œ4˜4Kšžœžœ
žœ
˜*K˜Kšœ
 ˜Kšœ
 
˜Kš
œ/˜/Kšœ
žœ
˜šžœžœ˜Kš
œ,˜,Kš
œ,˜,Kš
œ˜K˜—šžœžœ˜Kš
œH˜HK˜—šžœžœ˜Kš
œZ˜ZK˜—š
ž˜Kš
œC˜CKš
œ3˜3—Kšžœ
˜K˜—šŸœžœ˜Kš
ž˜šžœžœ
žœ˜ Kš
œ2˜2Kšžœ˜K˜—Kšžœ
˜K˜—Kšœ
žœ˜Kš	œ
žœžœžœ
 œ˜Ošœ	žœ
žœžœ˜3Kšžœ
žœžœ˜*—Kšœžœ˜š	œž	œžœžœ œ˜KKšžœ
žœžœžœ˜+—K˜šŸœžœžœ
žœžœ
žœ˜2Kš
ž˜Kš
žœžœ
žœ
žœžœ˜šžœžœ
ž˜Kšœ	žœ˜Kšœžœ˜"Kšžœ3˜:—Kšžœ
˜K˜—šŸœžœžœ
žœ˜Kš
ž˜Kšœžœ
˜šœžœ
˜Kš
ž˜šžœ(žœž˜7šžœžœ˜%Kšœžœžœ˜ Kš
œ™K˜7K˜5Kšžœ˜Kš
œ˜—Kšžœ
˜—Kš
œ™Kšžœžœ&˜Dšžœ˜Kšœ ˜4K˜(K˜&Kš
œ˜—K˜Kš
œ˜Kš
œ˜Kšžœ˜š
ž˜˜K˜$K˜K˜&K˜Kš
œ˜——Kšžœ
˜—Kšžœ
˜—K˜š
Ÿ
œžœžœ	žœžœ˜9Kšžœ
ž˜Kšœžœ˜/Kšžœ
˜—K˜š
Ÿœžœžœ	žœžœ˜6Kš
œ!™!Kšœ&žœ˜;šžœžœžœ˜9Kšœ
žœ
žœ˜;KšžœR˜XK˜—Kšžœ)˜/Kš
œ˜K˜—š
Ÿœžœžœ	žœžœ˜2Kš
ž˜Kšœžœ)˜.šŸœžœ˜K˜K˜K˜—šžœžœ
˜šžœ
žœ
ž˜š
œ(˜(šžœ
žœ
žœ˜Kš
œ˜Kš
œ˜K˜
—šžœ
 œ˜Kš
œ7™7Kšœžœ˜Kš
œ&˜&Kš
œ&˜&Kš
œ˜—K˜—Kšžœ˜——Kšžœžœžœ
žœ
˜Kšžœ˜
Kšžœ
˜—K˜šŸœžœžœžœžœ
žœ˜BJš	œžœžœžœžœ˜jJšžœ˜ Jš
œ˜—K˜š
Ÿœžœžœžœžœ˜EJš
ž˜J˜šŸœžœ	žœ˜%Jš
ž˜Jšœžœ˜š
žœžœžœžœ
žœ
˜5Jšžœ
žœžœžœ˜3Jšžœ
˜—Jš
œ˜š
žœžœžœžœ
žœ
˜3šžœ
žœžœžœ˜$šžœžœžœ˜@Jš
œ˜Jš
œ˜J˜
—šžœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
—J˜
—Jšžœ
˜—Jšžœ
˜—J˜šŸœžœžœžœžœ
žœ˜7Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—J˜Jšœžœ˜%Jšœžœžœžœ
žœžœ˜.Jš
œ˜Jš
œ2˜2Jšžœ
˜J˜—K˜šŸ	œžœžœ˜%Jš
ž˜Jš	œžœžœ
žœžœ˜(Jš
œ˜Jšžœ
˜—K˜š
Ÿ	œžœžœžœ
žœ˜EKš
ž˜K˜šŸœžœ	žœ
žœ˜,Kšžœ
žœžœ˜2Kš
œ,˜,Kš
œ˜—K˜š
Ÿ
œžœžœžœ
žœ˜JKš
ž˜KšœžœT˜ZKšœžœ˜šžœžœ˜Kš
œ˜Kšœž˜K˜—šžœ	žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
—šžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ˜1K˜—Kšžœ
˜—K˜šžœžœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ
˜Kš
œ˜—šžœ
žœ
ž˜šœžœ˜Kšœ	žœ˜Kš
œ˜šžœžœ
žœž˜Kšžœžœ
žœ
˜)Kšžœ
˜—Kšžœžœ;˜LKš
œ˜K˜—Kšœžœ9˜?š
œ(˜(Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœžœ
žœ
˜AKš
œ1˜1Kš
œ0™0Kš
œ2™2Kšžœ
žœžœ˜-Kšžœžœžœ˜6Kš
œ˜Kšžœžœ˜5šžœ
žœ˜Kšœžœ˜Kšœžœžœ' ˜MKšœ ˜!K˜—K˜—š
œ"˜"Kšœžœ
˜Kšœžœ˜Kšœžœ˜Kš
œ˜Kš
œ˜Kšœžœžœ	˜,Kš
œ˜Kš
œ˜Kšžœžœžœ
˜Fšžœ
žœ˜Kš
œ˜Kšœžœžœ˜<K˜—K˜—š
œ˜Kš
œ˜Kš
œ4˜4K˜—š
œ"˜"Kš
œ˜Kš
œ˜Kšœ ˜Kšœ ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—šžœ˜šžœžœžœ˜6Kš
œ&˜&K˜
—šžœ˜Kšœžœ"žœ˜:Kš	žœžœ
žœžœ ˜Ošžœ˜Kš
œ"˜"K˜
—Kš
œ˜———Kšžœ
˜K˜—K˜šŸ
œžœ˜1Kš
ž˜Kšœžœ
˜Kšœžœ
žœ
˜
Kšœžœ)˜8Kš
œ/˜/Kš
œ.˜.Kš
œ&˜&Kš
œ-˜-šœžœ˜%šžœ
žœžœ˜%Kš
œ&˜&Kšžœ˜K˜
—Kš
œ˜—Kšœ5žœ˜;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š
œ˜Kš
œ˜Kš
œ˜Kš
œ=˜=Kšžœ˜K˜K˜K˜K˜K˜—…—7˜Oφ