DIRECTORY
Atom USING [MakeAtom],
Basics USING [BITAND, BITSHIFT],
CD,
CDApplications,
CDBusCells USING [CreateBusCell],
CDCells USING [CreateEmptyCell],
CDMenus,
CDSimpleOps,
CDIO USING [MakeName],
CDDirectory USING [Include],
CDOps,
CDOrient,
CDPrivate,
CDProperties,
CDRects USING [CreateRect],
CDRepetitions,
CDTexts,
CDViewer,
Commander USING [CommandProc, Register],
CommandTool,
FS,
IO,
CMos,
CMosContacts,
CMosTransistors,
Rope,
TerminalIO,
ViewerClasses USING [Viewer];

ChipmonkCmosRead: CEDAR MONITOR
IMPORTS Atom, Basics, CDApplications, CDBusCells, CDCells, CDSimpleOps, CDDirectory, CDIO, CDMenus, CDOps, CDPrivate, CDProperties, CDRects, CDRepetitions, CDTexts, CDViewer, Commander, FS, IO, CMos, CMosContacts, CMosTransistors, CommandTool, Rope, TerminalIO
SHARES CDProperties =
BEGIN


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

instance:	INTEGER = 1;
transistor:	INTEGER = 2;	
contact:	INTEGER = 3;
wire:	INTEGER = 4;
rectangle:	INTEGER = 5;
text:	INTEGER = 6;
bus:	INTEGER = 7;
repeat:	INTEGER = 8;

contTypALen: INTEGER = 12;
maxCellNum: INTEGER = 500;
codeWordForDataFile : CARDINAL = 123751B;
debugging: BOOLEAN = FALSE;
debug: BOOLEAN = FALSE;
atomTableSize: INTEGER = 256;
contTypA:  ARRAY [1..contTypALen] OF contType = [
mDif, mPol, butt, burr, 
mm2, mDif, mDif, mm2, 
mm2, mm2, mm2, difShort];
contLevel: ARRAY [1..contTypALen] OF CD.Layer = [
CMos.ndif, CMos.pol, CMos.ndif, CMos.ndif, 
CMos.met2, CMos.pdif, CMos.nwelCont, CMos.ndif, 
CMos.pol, CMos.ndif, CMos.ndif, CMos.ndif
];  -- for versions < 6
fileLevel: ARRAY [0..15] OF CD.Layer = [
CMos.cut, CMos.ndif, CMos.pol, CMos.met, 
CMos.imp, CMos.ovg, CMos.bur, CD.highLightError --snerd-- , 
CMos.cut2, CMos.pdif, CMos.pwelCont, CMos.met2, 
CMos.pwel, CMos.nwel, CMos.nwelCont, CD.highLightError --NOcOL--
]; 

contType: TYPE = {burr, mDif, difShort, butt, mPol, mm2};

design: CD.Design;
cellNameA: REF ARRAY [0..maxCellNum] OF CD.ObPtr _ NEW[ARRAY [0..maxCellNum] OF CD.ObPtr];
atomTable: REF ARRAY [1..atomTableSize] OF ATOM _ NEW[ARRAY [1..atomTableSize] OF ATOM];

standardFont: REF CDTexts.FontRec = CDTexts.GetFont[key: $CDxCompatibilityFont, technology: CMos.cmos];

chipfile: IO.STREAM;
fileName: Rope.ROPE;

errs: INT _0;

NotYetImpl: PROC [] =
BEGIN
errs _ errs+1;
TerminalIO.WriteRope["?"];
END;

BadObject: PROC [size: CD.DesignPosition _ [4, 4]] RETURNS [CD.ObPtr] =
BEGIN
RETURN [CDRects.CreateRect[size, CD.highLightError]]
END;

InWord: PROC RETURNS [INTEGER] =
BEGIN
highbyte: CARDINAL = LOOPHOLE[IO.GetChar[chipfile], CARDINAL];
lowbyte: CARDINAL = LOOPHOLE[IO.GetChar[chipfile], CARDINAL];
RETURN [ LOOPHOLE[(256*highbyte) + lowbyte, INTEGER] ];
END;

FileFormat: ERROR = CODE;

Lambda: PROCEDURE [i: INT] RETURNS [CD.DesignNumber] = 
INLINE BEGIN 
RETURN [lambdaFactor*i] 
END;

InOrientation: PROC [] RETURNS [CD.Orientation] =
INLINE BEGIN
i: INTEGER = InWord[];
IF i>=0 AND i<=15 THEN RETURN [i/4*2 + i MOD 2] --different representation
ELSE ERROR FileFormat;
END;

ToLevel: PROC [i: INTEGER] RETURNS [CD.Layer] =
INLINE BEGIN
IF i>= 0 AND i<= 15 THEN RETURN [fileLevel[i]]
ELSE ERROR FileFormat;
END;

InLevel: PROC [] RETURNS [CD.Layer] =
INLINE BEGIN
RETURN [ToLevel[InWord[]]]
END;

NewCellName: PROC [index: INTEGER] RETURNS [cellName: Rope.ROPE] =
BEGIN
cellName _ IO.PutFR[ "cell#%d", IO.int[index]];
END;

InObject:  PROC[version: INTEGER] 
RETURNS [obj: CD.ObPtr, appProp: REF_NIL, appVal: REF_NIL] =
BEGIN
j, k, w, l, we, le, dumsur: INTEGER;
kk: CARDINAL;
lev: CD.Layer;
dumrope: Rope.ROPE;

IF debugging  OR debug THEN
TerminalIO.WriteRope[" (Include new object ... "];
j _ InWord[];
SELECT j FROM
instance =>
BEGIN
k _ InWord[];  -- cell ID num
obj _ cellNameA[k]; 		
END;
transistor =>
BEGIN
aExt: CD.DesignNumber _ 0;
w _ InWord[];
l _ InWord[];
kk _ LOOPHOLE[InWord[]];
IF version > 4 AND LOOPHOLE[Basics.BITAND[kk, 10000B], CARDINAL] # 0 THEN  
dumsur _ InWord[];
IF LOOPHOLE[Basics.BITAND[LOOPHOLE[kk, CARDINAL], 20000B], CARDINAL] # 0 THEN 
aExt _ Lambda[InWord[]]; -- if angle get angle ext.
IF LOOPHOLE[Basics.BITAND[kk, 100000B], CARDINAL]#0 THEN {
IF version>7 THEN [] _ InWord[]; -- implant
}; 
we _ Basics.BITAND[Basics.BITSHIFT[kk, -6], 77B];
le _ Basics.BITAND[kk, 77B];
lev _ IF Basics.BITAND[kk, 10000B]#0 THEN CMos.pdif ELSE CMos.ndif;
SELECT TRUE FROM
LOOPHOLE[Basics.BITAND[kk, 40000B], CARDINAL] #0 => 
{obj _ NIL; TerminalIO.WriteRope[" error: pullup in cmos\n"]};
LOOPHOLE[Basics.BITAND[kk, 20000B], CARDINAL] #0 => 
obj _ CMosTransistors.CreateAngleTransistor[w: Lambda[w], l: Lambda[l], wExt: Lambda[we], lExt: Lambda[le], aExt: aExt, difLev: lev];
ENDCASE =>
obj _ CMosTransistors.CreateTransistor[w: Lambda[w], l: Lambda[l],  wExt: Lambda[we], lExt: Lambda[le], difLev: lev];
END;
contact =>
BEGIN
j: CARDINAL _ LOOPHOLE[InWord[]];  -- get contact type
k: CARDINAL _ Basics.BITAND[j, 37B];  -- get contact type
l: CARDINAL _ Basics.BITSHIFT[j, -8];
lev _ IF version > 5 THEN InLevel[] ELSE contLevel[k]; 
IF version > 4 THEN dumsur _ LOOPHOLE[InWord[]];
SELECT contTypA[k] FROM
mPol => obj _ CMosContacts.CreatePolyCon[Lambda[l]];
mDif => obj _ CMosContacts.CreateDifCon[Lambda[l], lev];
difShort => obj _ CMosContacts.CreateDifShortCon[lev];  
butt => obj_ CMosContacts.CreateButCon[lev];
burr => BEGIN
w _ LOOPHOLE[InWord[]];
k _ LOOPHOLE[InWord[]];
j _ Basics.BITSHIFT[k, -8];
obj _ CMosContacts.CreateBurCon[w: Lambda[w], l: Lambda[l], wex: Lambda[j], lex: Lambda[LOOPHOLE[Basics.BITAND[k, 37B], CARDINAL]], difLev: lev];
END;
mm2 => obj _ CMosContacts.CreateMmCon[Lambda[l], 0, 0];
ENDCASE => {TerminalIO.WriteRope[" Error in selecting contact type "]; ERROR};
END;
wire =>
BEGIN
i: INTEGER;
w _ InWord[];
l _ InWord[];
i _ InWord[];
lev _ ToLevel[i];
IF lev=CMos.pdif THEN lev _ CMos.wpdif;
SELECT i FROM
7 => {appVal _ $snerdRect; appProp _ $SignalName};
15 => {appVal _ $NOcOLRect; appProp _ $SignalName};
ENDCASE => NULL;
IF version > 4 AND lev = CMos.wpdif THEN dumsur _ InWord[];
obj _ CDRects.CreateRect[[Lambda[w],Lambda[l]], lev]; 							
END;
rectangle =>
BEGIN 
i: INTEGER;
w _ InWord[];
l _ InWord[];
appVal _ $Rect;
appProp _ $CDxChipmonkThinks;
i _ InWord[];
lev _ ToLevel[i];
IF lev=CMos.pdif THEN lev _ CMos.wpdif;
SELECT i FROM
7 => {appVal _ $snerdRect; appProp _ $SignalName};
15 => {appVal _ $NOcOLRect; appProp _ $SignalName};
ENDCASE => NULL;
obj _ CDRects.CreateRect[[Lambda[w], Lambda[l]], lev];		
END;
text => { 
dumrope _ InString[]; 
obj _ CDTexts.CreateText[dumrope, standardFont] 
};	
bus =>
BEGIN
w: CD.DesignNumber = Lambda[InWord[]];
l: CD.DesignNumber = Lambda[InWord[]];
lev: CD.Layer = InLevel[];
count: NAT = InWord[];
spacing: CD.DesignNumber = Lambda[InWord[]];
topInc: CD.DesignNumber = Lambda[InWord[]];
botInc: CD.DesignNumber = Lambda[InWord[]];
IF lev=CMos.pdif THEN {TerminalIO.WriteRope["**bus implant is not drawn\n"]};
obj _ CDBusCells.CreateBusCell[ 
design: design,
sizeOfFirst: [w, l], 
lev: lev, 
count: count, 
offset: [spacing, topInc], 
lengIncrement: botInc-topInc
]; -- compare: obj _ Chipmonk.makeBus[l, w, lev, count, spacing, topInc, botInc];
END;
repeat =>
BEGIN
rob: CD.ObPtr = InObject[version].obj;
ignoredw: INT = InWord[]; -- ignored
ignoredl: INT = InWord[]; -- ignored
dx: CD.DesignNumber = Lambda[InWord[]];
dy: CD.DesignNumber = Lambda[InWord[]];
count: NAT _ InWord[];
orient: CD.Orientation _ InOrientation[];
obj _ CDRepetitions.CreateRepetition[design: design, ob: rob, count: count, offset: [dx, dy], orientation: orient];
END;
ENDCASE => {
obj _ BadObject[];
TerminalIO.WriteRope["** Erronous object\n"];
};
END;  -- InObject

InList: PROC[ver: INTEGER] RETURNS [list: CD.ApplicationList _ NIL, length: INT] =
BEGIN
appProp: REF _ NIL;
appVal: REF _ NIL;
appCount: INTEGER;
app: CD.ApplicationPtr;
ob: CD.ObPtr;
location: CD.DesignPosition;
orientation: CD.Orientation;
IF debugging OR debug  THEN TerminalIO.WriteRope["start list\n"];
appCount _ InWord[];
FOR appNum: INTEGER IN [0..appCount) DO
location.x _ Lambda[InWord[]];
location.y _ Lambda[InWord[]];
orientation _ InOrientation[];
[ob, appProp, appVal] _ InObject[ver];
IF ob=NIL THEN {
ob _ BadObject[];
TerminalIO.WriteRope["nil object\n"]
};
app _ CDApplications.NewApplicationI[ob: ob, location: location, orientation: orientation];
list _ CONS[app, list];
IF appProp#NIL THEN 
CDProperties.PutPropOnApplication[onto: app, prop: appProp, val: appVal];
IF ver > 3 THEN
BEGIN
propCount: INTEGER = InWord[];
FOR propNum: INTEGER IN [0..propCount) DO
InProp[app];
ENDLOOP;
END;
ENDLOOP;
IF debugging OR debug THEN TerminalIO.WriteRope["end list\n"];
RETURN[list, appCount];
END;  


sigName: ATOM = Atom.MakeAtom["SIGNAL NAME"];

InProp: PROC [aptr: CD.ApplicationPtr] =
BEGIN
kind: INTEGER _ InWord[];
name: REF _ NIL;
value: REF;
SELECT kind FROM
1 => {
IF aptr=NIL OR aptr.ob=NIL OR ISTYPE[aptr.ob.specificRef, CD.RectPtr] THEN
 name _ $SignalName 
ELSE name _ $InstanceName;
value _ InString[];
};
2 => {
name _ InAtom[];
value _ InAtom[];
IF name=sigName THEN name _ $SignalName;
};
ENDCASE =>  {
name _ NIL; 
TerminalIO.WriteRope["** unknown property kind\n"];
};
IF name#NIL AND aptr#NIL AND aptr.ob#NIL THEN 
CDProperties.PutProp[onto: aptr, prop: name, val: value]
END;

InAtom: PROC [] RETURNS[a: ATOM] =
BEGIN
i: INTEGER _ InWord[];
IF i<0 THEN {
a _ atomTable[-i]
}
ELSE IF i>0 THEN {
a _ Atom.MakeAtom[InString[]];
IF i <= atomTableSize THEN atomTable[i] _ a 
ELSE TerminalIO.WriteRope["** Atom table code wrong\n"];
}
ELSE {
TerminalIO.WriteRope["** Atom code wrong\n"];
a _ NIL
}
END;

InString: PROC [] RETURNS[s: Rope.ROPE] =
BEGIN
j, len: CARDINAL;
flg: BOOLEAN;
j _ LOOPHOLE[InWord[]];
len _ Basics.BITSHIFT[j, -8];
IF len = 0 THEN BEGIN s _ ""; RETURN; END;
flg _ TRUE;
FOR i: CARDINAL IN [0..len) DO
IF flg THEN
s _ Rope.Cat[s, Rope.FromChar[LOOPHOLE[Basics.BITAND[j, 377B], CHAR]]]
ELSE {
j _ LOOPHOLE[InWord[]];
s _ Rope.Cat[s, Rope.FromChar[LOOPHOLE[Basics.BITSHIFT[j, -8], CHAR]]];
};
flg _ NOT flg;
ENDLOOP;
END;


FileOpened: PROC [name: Rope.ROPE] RETURNS [fileWasOpened: BOOLEAN] =
BEGIN
IF Rope.IsEmpty[name] THEN name _ TerminalIO.RequestRope["Input file > "];
fileName _ CDIO.MakeName[name, "chip"];
chipfile _ FS.StreamOpen[fileName ! FS.Error => 
IF error.group#bug THEN {
TerminalIO.WriteRope[fileName];
TerminalIO.WriteRope[" not opened: "];
TerminalIO.WriteRope[error.explanation]; 
TerminalIO.WriteLn[];
GOTO FileName 
}];
TerminalIO.WriteRope["File being read is "];
TerminalIO.WriteRope[fileName];
TerminalIO.WriteRope["\n"];
fileWasOpened _ TRUE;
EXITS
   FileName => {fileWasOpened _ FALSE};
END;


ResetSimplification: PROC[cell: CD.ObPtr, leng: INT_0] = INLINE
BEGIN
long: INT = MAX[MAX[cell.size.y, cell.size.x], 1];
short: INT = MAX[MIN[cell.size.y, cell.size.x], 1];
cp: CD.CellPtr = NARROW[cell.specificRef];
leng _ leng/2+6;
leng _ MAX[MIN[leng, 300], 8];
IF cell.size.y>cell.size.x THEN {
leng _ (leng*long)/short;
};
leng _ MAX[MIN[leng, 600], 8];
leng _ (leng*3)/(2+(long/short)/2);
cp.simplifyOn _ MAX[MIN[leng, 600], 8];
END;

ReadChip: PROC =
BEGIN
ENABLE { 
FileFormat => {
TerminalIO.WriteRope["\n**File-Format error\n"]; 
CDPrivate.Debug[msg: "file format; [proceed does not clobber other designs]"];
GOTO IOError;
};
IO.EndOfStream => {
TerminalIO.WriteRope["\n**end of stream error\n"]; 
CDPrivate.Debug[msg: "file format; [proceed does not clobber other designs]"];
GOTO IOError;
};
IO.Error => {
TerminalIO.WriteRope["\n**io error\n"]; 
CDPrivate.Debug[msg: "io error [proceed does not clobber other designs]"];
GOTO IOError;
};
};
i, j, k, ver, cCnt, depht: INTEGER;
leng: INT;
ss: Rope.ROPE;
cdp: CD.ObPtr;  
cellPtr: CD.CellPtr;
errs _ 0;
i _ InWord[];
IF i # LOOPHOLE[codeWordForDataFile, INTEGER] AND 
NOT TerminalIO.UserSaysYes[ "Doesn't look like a .chip file -- should program continue?"] THEN RETURN;
ver _ InWord[];
cCnt _ InWord[];
IF cCnt > maxCellNum THEN {
TerminalIO.WriteRope["Too many different kinds of cells in design...aborting read\n"];
RETURN;
};
IF ver < 3 THEN { 
TerminalIO.WriteRope[" Version number too low...aborting read\n"];
RETURN;
};
IF ver>8 THEN { 
TerminalIO.WriteRope[" new chipmonk version unknown to chipndale...aborting read\n"];
RETURN;
};
FOR j IN [0..cCnt] DO
cellNameA[j] _ CDCells.CreateEmptyCell[];
ENDLOOP;
TerminalIO.WriteRope["Starting cell directory\n"];	
FOR k IN [1..cCnt] DO
j _ InWord[];
cdp _ cellNameA[j];
ss _ InString[];
cdp.size.x _ Lambda[InWord[]];
cdp.size.y _ Lambda[InWord[]];
[] _ InWord[]; -- this is some count in chipmonk ??
cellPtr _ NARROW[cdp.specificRef, CD.CellPtr];
[cellPtr.contents, leng] _ InList[ver];
IF NOT Rope.IsEmpty[ss] THEN cellPtr.name _ ss
ELSE cellPtr.name _ NewCellName[k];
[] _ CDDirectory.Include[design: design, object: cdp, fiddleName: TRUE];
IF cellPtr.contents=NIL THEN { --empty cell
TerminalIO.WriteRope[Rope.Cat["** empty cell ", cellPtr.name, "\n"]];
cellPtr.contents _ LIST[CDApplications.NewApplicationI[BadObject[]]];
}; 
ResetSimplification[cdp, leng];
cellPtr.ir _ CDApplications.BoundingRectI[cellPtr.contents];
ENDLOOP;
TerminalIO.WriteRope["Finished cell directory\n"];
depht _ IF ver<7 THEN 0 ELSE InWord[];
IF depht>0 THEN {
TerminalIO.WriteRope["***design was pushed in; not read in correctly\n"];
RETURN;
};
IF ver>=7 THEN {
fileChangeCode: INTEGER = InWord[];
};
design.actual.first.specific.contents _ InList[ver].list;
design.name _ fileName;
TerminalIO.WriteRope["Finished reading chip\n"];
IF errs>0 THEN {
TerminalIO.WriteInt[errs];
TerminalIO.WriteRope[" unknown objects\n"];
errs _ 0;
};
IO.Close[chipfile];
EXITS
IOError => {TerminalIO.WriteRope[" proceed; discard this design\n"];};
END;  -- ReadChip

CommandReadChip: ENTRY Commander.CommandProc = 
BEGIN
ENABLE { 
TerminalIO.UserAbort => GOTO UserAbrt;
UNWIND => NULL;
};
list: LIST OF Rope.ROPE;
length: NAT;
name: Rope.ROPE;
[list, length] _ CommandTool.ParseToList[cmd];
IF length=0 THEN name _ NIL
ELSE IF length=1 THEN name _ list.first
ELSE  {
result _ $Failure;
msg _ "unknown arguments";
RETURN
};
design_ CDOps.CreateDesign[CMos.cmos];
IF FileOpened[name] THEN {
ReadChip[];
CDSimpleOps.SelectAll[design];
CDSimpleOps.TransformSelected[design, CDOrient.rotate180+CDOrient.mirrorX];
CDSimpleOps.DeselectAll[design];
[] _ CDViewer.CreateViewer[design];
};
EXITS
UserAbrt => {TerminalIO.WriteRope["read aborted\n"]};
END;

TestRead: ENTRY Commander.CommandProc = 
BEGIN
ENABLE { 
IO.EndOfStream => GOTO IOEnd;
UNWIND => NULL;
};
w: CARDINAL;
r: Rope.ROPE;
IF FileOpened[NIL] THEN {
TerminalIO.WriteRope["--startfile--\n"];
DO
w _ LOOPHOLE[InWord[]];
r _ IO.PutFR["%7b\n", IO.card[w]];
TerminalIO.WriteRope[r];
ENDLOOP;
};
EXITS
IOEnd => {TerminalIO.WriteRope["--endfile--\n"]};
END;


CDMenus.CreateEntry[$IOMenu, "chipmonk-output", $ChipmonkOutput];
Commander.Register[  
key: "CDTestRead", 
proc: TestRead,
doc: "Reads file and display it on Terminal"
];
Commander.Register[  
key: "CDReadCMos", 
proc: CommandReadChip,
doc: "Reads old cmos Chipmonk file"
];
Commander.Register[  
key: "CDReadCMCMos", 
proc: CommandReadChip,
doc: "Reads old cmos Chipmonk file"
];

END.		



šChipmonkCmosRead.mesa
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
Last Edited by: Kimr, October 26, 1983 9:39 am
Last Edited by: Jacobi, October 25, 1983 12:48 pm
Last Edited by: Jacobi, April 11, 1985 11:03:10 am PST
-- global constants
--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
-- global vars
obj _ CMosTransistors.CreatePullUp[w: Lambda[w], l: Lambda[l], wExt: Lambda[we], lExt: Lambda[le], difLev: lev];
--make it symetric now using shorter size
--introduce longer side
--if you are debugging here: inspect "ec"
Κν˜
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š
œ1™1Kš
œ6™6K˜—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˜šΟbœžœ
ž˜Kšžœ·
žœD˜„Kšžœ˜—Kš
ž˜K˜š
œ™K˜šœžœ˜ Kš
Οc5™5Kš
 ?™?Kš
 ,™,—Kšœžœžœ˜/K˜Kšœ
žœ˜Kšœžœ˜Kšœ	žœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜Kšœ
žœ˜Kšœžœ˜Kšœžœ˜)Kšœžœžœ
˜Kšœžœžœ
˜Kšœžœ˜šœžœžœ
˜1Kš
œ˜Kš
œ˜Kš
œ˜—šœžœžœ
žœ
˜1Kš
œ+˜+Kš
œ0˜0Kš
œ)˜)Kšœ ˜—šœžœ	žœ
žœ
˜(Kš
œ)˜)Kšœžœ 	œ˜<Kš
œ0˜0Kšœ%žœ 	˜@Kš
œ˜—K˜—š
œ™Kšœ
žœ+˜9K˜Kšœžœ˜Kš
œž	œžœ
žœ
žœžœ
žœ˜ZKš
œž	œžœ
žœžœžœ
žœ
˜XK˜KšœžœV˜gK˜Kšœ
žœ
žœ
˜K˜K˜K˜
K˜šΟn
œžœ˜Jš
ž˜Jš
œ˜Jš
œ˜Jšžœ
˜——K˜š
‘	œžœžœžœžœ	˜GKš
ž˜Kšžœžœ˜4Kšžœ
˜—K˜š‘œžœ
žœžœ˜ Kš
ž˜Kš	œ
žœžœ
žœžœ˜>Kš	œ	žœžœ
žœžœ˜=Kšžœžœžœ˜7Kšžœ
˜K˜—Kšœžœžœ
˜K˜š
‘œž	œžœžœžœ˜7Kšžœ
žœ
˜
Kšžœ˜Kšžœ
˜K˜—š‘
œžœžœžœ˜1Kšžœ
ž˜Kšœžœ˜Kšžœžœžœ
žœžœ ˜JKšžœ
žœ˜Kšžœ
˜K˜—š
‘œžœžœžœžœ	˜/Kšžœ
ž˜Kšžœžœžœ
žœ˜.Kšžœ
žœ˜Kšžœ
˜—K˜š‘œžœžœžœ	˜%Kšžœ
ž˜Kšžœ˜Kšžœ
˜K˜—š
‘œžœ	žœžœžœ˜BKš
ž˜Kšœžœžœ
˜/Kšžœ
˜—K˜š‘œžœ
žœ˜"Kšžœžœžœ
žœ
žœ
žœ˜<Kš
ž˜Kšœžœ
˜$Kšœžœ
˜
Kšœžœ˜Kšœžœ
˜K˜šžœžœž˜Kš
œ2˜2—Kš
œ
˜
šžœž˜
š
œ˜Kš
ž˜Kšœ ˜Kš
œ˜Kšžœ
˜—š
œ
˜
Kš
ž˜Kšœžœ˜Kš
œ
˜
Kš
œ
˜
Kšœžœ˜šžœ
žœ
žœžœžœžœ˜KKš
œ˜—šžœ
žœžœ
žœžœžœžœ
˜NKšœ ˜3—š
žœ
žœžœžœžœ˜:Kšžœžœ 
˜+Kš
œ˜—Kšœžœžœ˜1Kšœžœ
˜Kš	œžœžœžœžœ˜Cšžœ
žœ
ž˜šžœžœžœ˜4Kšœžœ4˜>Kšœbž
œž™p—šžœžœžœ˜4Kš
œ…
˜…
—šžœ˜
Kš
œu˜uKšžœ
˜———š
œ
˜
Kš
ž˜Kšœžœžœ
 ˜6Kšœžœ
žœ ˜9Kšœžœ
žœ˜%Kšœžœ
žœžœ˜7Kšžœ
žœ
žœ˜0šžœ
ž˜Kš
œ4˜4Kš
œ8˜8Kš
œ8˜8Kš
œ,˜,šœž˜
Kšœžœ˜Kšœžœ˜Kšœžœ˜KšœXžœžœ
žœ˜‘
Kšžœ
˜—Kš
œ7˜7Kšžœ@žœ˜N—Kšžœ
˜—š
œ˜Kš
ž˜Kšœžœ
˜Kš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kšžœžœ˜'šžœž˜
Kš
œ2˜2Kš
œ3˜3Kšžœžœ
˜—Kšžœ
žœžœ˜;Kš
œ=˜=Kšžœ
˜—š
œ˜Kšžœ
˜Kš
œ˜Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kšžœžœ˜'šžœž˜
Kš
œ2˜2Kš
œ3˜3Kšžœžœ
˜—Kš
œ8˜8Kšžœ
˜—š
œ
˜
Kš
œ˜Kš
œ0˜0Kš
œ˜—š
œ˜Kš
ž˜Kšœžœ!˜&Kšœžœ!˜&Kšœžœ˜Kšœžœ˜Kšœ	žœ!˜,Kšœžœ!˜+Kšœžœ!˜+Kšžœžœ8˜Mš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœ N˜Q—Kšžœ
˜—š
œ	˜	Kš
ž˜Kšœžœ˜&Kšœ
žœ
 
˜$Kšœ
žœ
 
˜$Kšœžœ!˜'Kšœžœ!˜'Kšœžœ˜Kšœžœ˜)Kš
œs˜sKšžœ
˜—šžœ˜Kš
œ˜Kš
œ-˜-Kš
œ˜——Kšžœ ˜—K˜š‘œžœžœžœžœžœ
žœ˜RKš
ž˜Kšœ	žœžœ
˜Kšœžœžœ
˜Kšœ
žœ
˜Kšœžœ˜Kšœžœ˜
Kšœ
žœ˜Kšœ
žœ
˜Kšžœžœžœ&˜AKš
œ˜šžœ	žœ
žœž˜'Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ&˜&šžœžœ
žœ˜Kš
œ˜Kš
œ$˜$K˜—Kš
œ[˜[Kšœžœ˜šžœ	žœ
žœ
˜Kš
œI˜I—šžœ	ž˜Kš
ž˜Kšœžœ˜šžœ
žœ
žœž˜)Kš
œ˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœžœžœ$˜>Kšžœ˜Kšžœ˜K˜K˜—Kšœ	žœ ˜-K˜š‘œžœžœ˜(Kš
ž˜Kšœžœ˜Kšœž	œ
˜Kšœžœ
˜šžœž˜š
œ˜šžœžœ
žœ	žœ
žœ
žœžœ
ž˜JKš
œ˜—Kšžœ˜Kš
œ˜Kš
œ˜—š
œ˜Kš
œ˜Kš
œ˜Kšžœžœ˜(Kš
œ˜—šžœ˜
Kšœžœ˜Kš
œ3˜3K˜——šžœžœ
žœžœ
žœžœ
˜.Kš
œ8˜8—Kšžœ
˜—K˜š‘œžœžœžœ˜"Kš
ž˜Kšœžœ˜šžœžœ˜
Kš
œ˜Jš
œ
˜
—šžœ
žœžœ˜Kš
œ˜Kšžœžœ˜,Kšžœ4˜8Kš
œ
˜
—šžœ˜Kš
œ-˜-Kšœž˜K˜
—Kšžœ
˜—K˜š‘œžœžœ	žœ˜)Kš
ž˜Kšœžœ
˜Kšœžœ
˜
Kšœžœ˜Kšœ
žœ˜Kš
žœ	žœ
žœ	žœžœ
˜*Kšœžœ
˜šžœžœ
žœ
ž˜šžœž˜Kšœžœžœžœ˜F—šžœ˜Kšœžœ˜Kšœžœžœ	žœ˜GKš
œ˜—Kšœžœ˜Kšžœ
˜—Kšžœ
˜K˜—K˜š
‘
œžœ
žœžœžœ˜EKš
ž˜Kšžœžœ0˜JKš
œ'˜'šœ$žœ
˜0šžœžœ˜Jš
œ˜Jš
œ&˜&Jš
œ)˜)Jš
œ˜Jšžœ	ž
˜Jš
œ˜——Kš
œ,˜,Kš
œ˜Kš
œ˜Kšœžœ
˜Kš
ž˜Kšœ žœ˜'Kšžœ
˜K˜K˜—š	‘œžœžœžœž˜?Kš
ž˜Kšœžœžœ
žœ˜2Kšœžœžœ
žœ˜3Kšœžœžœ˜*Kš
œ˜Kšœžœ
žœ˜Kš
œ)™)šžœžœ˜!Kš
œ˜K˜—Kšœžœ
žœ˜Kš
œ™Kš
œ#˜#Kšœžœ
žœ˜'Kšžœ
˜—K˜š‘œžœ˜š
ž˜šžœ
˜	š
œ˜Kš
œ1˜1Kš
œN˜NKšžœ	˜
K˜—šžœ˜Kš
œ3˜3Kš
œN˜NKšžœ	˜
Kš
œ˜—šžœ˜
Kš
œ(˜(Kš
œ)™)Kš
œJ˜JKšžœ	˜
Kš
œ˜—K˜——Kšœžœ
˜#Kšœžœ
˜
Kšœ	žœ
˜Kšœžœ	˜Kšœ	žœ	˜Kš
œ	˜	Kš
œ
˜
šžœžœžœžœ
˜2KšžœWžœ
˜f—Kš
œ˜Kš
œ˜šžœžœ˜Kš
œV˜VKšžœ
˜Kš
œ˜—šžœ	žœ˜Kš
œB˜BKšžœ
˜Kš
œ˜—šžœžœ˜Kš
œU˜UKšžœ
˜Kš
œ˜—šžœžœž˜Kš
œ)˜)Kšžœ
˜—Kš
œ3˜3šžœžœž˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ $˜3Kšœ
žœžœ
˜.Kš
œ'˜'Kšžœ
žœžœ˜.Kšžœ˜#KšœBžœ˜Hšžœžœ
žœ ˜+Kš
œE˜EKšœžœ.˜EKš
œ˜—Kš
œ˜Kš
œ<˜<Kšžœ
˜—Kš
œ2˜2Kšœžœžœžœ
˜&šžœ	žœ˜Kš
œI˜IKšžœ
˜Kš
œ˜—šžœžœ˜Kšœžœ˜#K˜—Kš
œ9˜9Kš
œ˜Kš
œ0˜0šžœžœ
ž
˜Kš
œ˜Kš
œ+˜+Kš
œ	˜	Kšž
œ
˜—Kšžœ˜š
ž˜Kš
œF˜F—Kšžœ ˜K˜—šŸœžœ˜/š
ž˜šžœ˜	Kšœžœ
˜&Kšžœžœ
˜K˜——Kšœžœ
žœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ.˜.Kšžœ
žœž˜Kšžœ
žœ
žœ˜'šžœ˜Kš
œ˜Kš
œ˜Kš
ž˜K˜—Kš
œ&˜&šžœžœ˜Kš
œ˜Kš
œ˜Kš
œK˜KKš
œ ˜ Kš
œ#˜#Kš
œ˜—š
ž˜Kš
œ5˜5—Kšžœ
˜K˜—šŸœžœ˜(š
ž˜šžœ˜	Kšžœžœ˜Kšžœžœ
˜Kš
œ˜——Kšœžœ
˜Kšœžœ
˜
šžœžœžœ˜Kš
œ(˜(š
ž˜Kšœžœ˜Kšœžœžœ
˜"Kš
œ˜Kšžœ
˜—Kš
œ˜—š
ž˜Kš
œ1˜1—Kšžœ
˜K˜—K˜Jš
œA˜Aš
œ˜Kš
œ˜Kš
œ˜Kš
œ,˜,Kš
œ˜—š
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜—š
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜K˜—Kšžœ˜K˜K˜K˜—…—:ΔTK