DIRECTORY
CMosB,
CMosBObjects,
CD,
CDAtomicObjects,
CDBasics,
CDLayers,
CDOps,
CDStretchyBackdoor,
Rope;

CMosBObjectsImpl: CEDAR PROGRAM
IMPORTS CD, CDAtomicObjects, CDBasics, CDLayers, CDOps, CDStretchyBackdoor, CMosB, Rope
EXPORTS CMosBObjects =
BEGIN

lambda: CD.Number = CMosB.lambda;
wellSurround: CD.Number = CMosB.wellSurround;


SDiff: PROC [l: CD.Layer] RETURNS [CD.Layer] = {
SELECT l FROM
CMosB.wpdif, CMosB.wndif, CMosB.pdif, CMosB.ndif => RETURN [l];
ENDCASE => RETURN [CMosB.wpdif]
};

XDiff: PROC [l: CD.Layer] RETURNS [CD.Layer] = {
SELECT l FROM
CMosB.wpdif, CMosB.wndif, CMosB.pdif, CMosB.ndif, CMosB.nwellCont, CMosB.pwellCont => RETURN [l];
ENDCASE => RETURN [CMosB.wpdif]
};

CreateAtomic: PROC [classKey: ATOM, size: CD.Position, layer: CD.Layer _ CD.undefLayer] RETURNS [CD.Object] = {
RETURN [CDAtomicObjects.CreateAtomicOb[classKey, size, CMosB.cmosB, layer]];
};

CreatePolyCon: PUBLIC PROC [] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2SimpleCon, [0, 0], CMosB.pol]];
};

CreateDifCon: PUBLIC PROC [difLayer: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2SimpleCon, [0, 0], XDiff[difLayer]]];
};

CreateDifShortCon: PUBLIC PROC [difLayer: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2DifShortCon, [0, 0], SDiff[difLayer]]];
};

CreateVia: PUBLIC PROC [] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2Via, [0, 0]]];
};

CreateTransistor: PUBLIC PROC [size: CD.Position, difLayer: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2Trans, size, XDiff[difLayer]]];
};

CreateAngleTransistor: PUBLIC PROC [size: CD.Position, difLayer: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2LTrans, size, XDiff[difLayer]]];
};

CreateLargePolyCon: PUBLIC PROC [sz: CD.Position] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2LargeSimpleCon, sz, CMosB.pol]];
};

CreateLargeDifCon: PUBLIC PROC [sz: CD.Position, difLayer: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateAtomic[$C2LargeSimpleCon, sz, XDiff[difLayer]]];
};

CreateLargeVia: PUBLIC PROC [sz: CD.Position] RETURNS [CD.Object] = { 
RETURN [CreateAtomic[$C2LargeVia, sz]];
};



MatchTrans: PROC [me: CD.Object, r: CD.Rect, layer: CD.Layer, prim: BOOL, horz: BOOL] RETURNS [BOOL] = {
RETURN [layer=me.layer OR layer=CMosB.pol]
};

wellTransClass: CD.ObjectClass;
transClass: CD.ObjectClass;

FillTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
dExt: CD.Number = 3*lambda;
pExt: CD.Number = 2*lambda;
dif: CD.Layer;
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, 2*lambda+2*pExt];
inr.y2 _ MAX[inr.y2, 2*lambda+2*dExt];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellTransClass;
IF ob.layer=CMosB.wpdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1-wellSurround+pExt, 
x2: inr.x2+wellSurround-pExt,
y1: inr.y1-wellSurround, 
y2: inr.y2+wellSurround], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
IF ob.layer=CMosB.pdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
};
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1+pExt, 
x2: inr.x2-pExt,
y1: inr.y1, 
y2: inr.y2], 
layer: dif
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2,
y1: inr.y1+dExt, 
y2: inr.y2-dExt], 
layer: CMosB.pol
];
};

DescribeT: CD.DescribeProc = {
dExt: CD.Number = 3*lambda;
pExt: CD.Number = 2*lambda;
sz: CD.Position = CD.InterestSize[ob];
RETURN [
Rope.Cat[
"transistor ",
CDOps.LayerRope[ob.layer],
Rope.Cat[" [",
CDOps.LambdaRope[sz.x-2*pExt, lambda],
CDOps.LambdaRope[sz.y-2*dExt, lambda],
"]"]
]
]
};

lTransClass: CD.ObjectClass;
wellLTransClass: CD.ObjectClass;
oldBadWellLTransClass: CD.ObjectClass;

OldBadFillLTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
ob.class _ lTransClass;
RETURN [FillLTransistor[ob]]
};

FillLTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
pExt: CD.Number = 2*lambda; --poly extends gate
dExt: CD.Number = 3*lambda; --diffusion extends gate
dW: CD.Number = 2*lambda; --witdth of diffusion in gate (not width of gate)
pW: CD.Number = 2*lambda; --witdth of poly in gate (not width of gate)
minSz: CD.Number = pExt+2*dExt+dW;
dif: CD.Layer;
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, minSz];
inr.y2 _ MAX[inr.y2, minSz];
ob.bbox _ inr;
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
wR: CD.Rect;
ob.class _ wellLTransClass;
IF ob.layer=CMosB.wpdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1-wellSurround+pExt, 
x2: inr.x2+wellSurround, 
y1: inr.y1-wellSurround , 
y2: inr.y1+wellSurround+dW+2*dExt], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
wR _ [x1: inr.x2-(dW+2*dExt)-wellSurround, 
x2: inr.x2+wellSurround, 
y1: inr.y1+wellSurround+dW+2*dExt, 
y2: inr.y2+wellSurround-pExt];
IF CDBasics.NonEmpty[wR] THEN
CDAtomicObjects.Incorporate[ob: ob, 
r: wR, 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
IF ob.layer=CMosB.pdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
};
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1+pExt, 
x2: inr.x2,
y1: inr.y1, 
y2: 2*dExt+dW], 
layer: dif
];
IF 2*dExt+dW < inr.y2-pExt THEN
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x2-2*dExt-dW, 
x2: inr.x2,
y1: 2*dExt+dW, 
y2: inr.y2-pExt ], 
layer: dif
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2-dExt,
y1: dExt, 
y2: dExt+pW], 
layer: CMosB.pol
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x2-pW-dExt, 
x2: inr.x2-dExt,
y1: inr.y1+pW+dExt, 
y2: inr.y2], 
layer: CMosB.pol
];
};

simpleContactClass: CD.ObjectClass;
wellSimpleContactClass: CD.ObjectClass;
largeContactClass: CD.ObjectClass;
wellLargeContactClass: CD.ObjectClass;

FillSimpleCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
rimW: CD.Number ~ lambda; -- therefore NOT large
inr: CD.Rect _ [0, 0, 2*lambda+2*rimW, 2*lambda+2*rimW];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif OR ob.layer=CMosB.wpwellCont OR ob.layer=CMosB.wnwellCont THEN {
ob.class _ wellSimpleContactClass;
CDAtomicObjects.Incorporate[ob: ob, 
r: CDBasics.Extend[inr, CDLayers.layerData[ob.layer].wSurr], 
layer: CDLayers.layerData[ob.layer].well,
inside: FALSE
];
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CDLayers.layerData[ob.layer].paint];
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -rimW], layer: CMosB.cut];
};

FillLargeSimpleCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
rimW: CD.Number = 2*lambda; -- therefore large
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, 2*lambda+2*rimW];
inr.y2 _ MAX[inr.y2, 2*lambda+2*rimW];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif OR ob.layer=CMosB.wpwellCont OR ob.layer=CMosB.wnwellCont THEN {
ob.class _ wellLargeContactClass;
CDAtomicObjects.Incorporate[ob: ob, 
r: CDBasics.Extend[inr, CDLayers.layerData[ob.layer].wSurr], 
layer: CDLayers.layerData[ob.layer].well,
inside: FALSE
];
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CDLayers.layerData[ob.layer].paint];
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -rimW], layer: CMosB.cut];
};

DescribeC: CD.DescribeProc = {
RETURN [Rope.Cat["contact ", CDOps.LayerRope[ob.layer]]]
};

DescribeLargeC: CD.DescribeProc = {
RETURN [Rope.Cat["large contact ", CDOps.LayerRope[ob.layer]]]
};


wellDiffShortConClass: CD.ObjectClass;

FillDiffShortCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
dif, ctDif: CD.Layer; 
inr: CD.Rect ~ [x1: 0, y1: 0, x2: 4*lambda, y2: 8*lambda]; 
difR: CD.Rect ~ [x1: 0, y1: 0, x2: 4*lambda, y2: 4*lambda]; 
ctR: CD.Rect ~ [x1: 0, y1: 4*lambda, x2: 4*lambda, y2: 8*lambda]; 
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
wrd: CD.Rect _ CDBasics.Extend[difR, CMosB.wellSurround];
wrc: CD.Rect _ CDBasics.Extend[ctR, CMosB.wellCntSurround];
IF ob.layer=CMosB.wpdif THEN {
dif _ CMosB.pdif; ctDif _ CMosB.nwellCont
}
ELSE IF ob.layer=CMosB.wndif THEN { 
dif _ CMosB.ndif; ctDif _ CMosB.pwellCont
};
wrc.y1 _ wrd.y2;
CDAtomicObjects.Incorporate[ob: ob, r: wrd, layer: CDLayers.layerData[ob.layer].well, inside: FALSE];
CDAtomicObjects.Incorporate[ob: ob, r: wrc, layer: CDLayers.layerData[ob.layer].well, inside: FALSE];
}
ELSE IF ob.layer=CMosB.ndif THEN {
dif _ CMosB.ndif; ctDif _ CMosB.pwellCont
}
ELSE { 
dif _ CMosB.pdif; ctDif _ CMosB.nwellCont;
ob.layer _ CMosB.pdif; --reduce junk  
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: difR, layer: dif];
CDAtomicObjects.Incorporate[ob: ob, r: ctR, layer: ctDif];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -lambda], layer: CMosB.cut];
};

OldFillDiffShortCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
dif, ctDif: CD.Layer; 
inr: CD.Rect ~ [x1: 0, y1: 0, x2: 4*lambda, y2: 8*lambda]; 
difR: CD.Rect ~ [x1: 0, y1: 0, x2: 4*lambda, y2: 4*lambda]; 
ctR: CD.Rect ~ [x1: 0, y1: 4*lambda, x2: 4*lambda, y2: 8*lambda]; 
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellDiffShortConClass;
IF ob.layer=CMosB.wpdif THEN {
dif _ CMosB.pdif; ctDif _ CMosB.nwellCont
}
ELSE IF ob.layer=CMosB.wndif THEN { 
dif _ CMosB.ndif; ctDif _ CMosB.pwellCont
};
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[difR, CMosB.wellSurround], layer: CDLayers.layerData[ob.layer].well, inside: FALSE];
}
ELSE IF ob.layer=CMosB.ndif THEN {
dif _ CMosB.ndif; ctDif _ CMosB.pwellCont
}
ELSE { 
dif _ CMosB.pdif; ctDif _ CMosB.nwellCont;
ob.layer _ CMosB.pdif; --reduce junk  
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: difR, layer: dif];
CDAtomicObjects.Incorporate[ob: ob, r: ctR, layer: ctDif];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -lambda], layer: CMosB.cut];
};



FillVia: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = { 
viaRimWidth: CD.Number = lambda;
cut2min: CD.Number = 2*lambda;
ob.bbox _ [0, 0, cut2min+2*viaRimWidth, cut2min+2*viaRimWidth];
ob.layer _ CMosB.met2;
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met2];
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: viaRimWidth, 
x2: cut2min+viaRimWidth,
y1: viaRimWidth,
y2: cut2min+viaRimWidth], 
layer: CMosB.cut2
];
};

FillLargeVia: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
viaRimWidth: CD.Number = 2*lambda;
cut2min: CD.Number = 2*lambda;
ob.bbox.x2 _ MAX[ob.bbox.x2, cut2min+2*viaRimWidth];
ob.bbox.y2 _ MAX[ob.bbox.y2, cut2min+2*viaRimWidth];
ob.layer _ CMosB.met2;
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met2];
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: viaRimWidth, 
x2: ob.bbox.x2-viaRimWidth,
y1: viaRimWidth,
y2: ob.bbox.y2-viaRimWidth], 
layer: CMosB.cut2
];
};


MatchSimpleCon: PROC [me: CD.Object, r: CD.Rect, layer: CD.Layer, prim: BOOL, horz: BOOL] RETURNS [BOOL] = {
RETURN [layer=me.layer OR layer=CMosB.met]
};

Init: PROC [] = {

Register: PROC [key: ATOM, creator: CDAtomicObjects.FillObjectProc, desc: Rope.ROPE, match: CDStretchyBackdoor.MatchProc_NIL, describe: CD.DescribeProc_NIL] RETURNS [p: CD.ObjectClass] = {
p _ CDAtomicObjects.RegisterAtomicObClass[key, creator, desc, CMosB.cmosB];
IF p=NIL THEN ERROR;
IF describe#NIL THEN p.describe _ describe;
IF match=NIL THEN match _ MatchSimpleCon; 
CDStretchyBackdoor.InstallMatchProc[p, match];
};
transClass _ Register[$C2Trans, FillTransistor, "transistor", MatchTrans, DescribeT];
wellTransClass _ Register[$C2WellTrans, FillTransistor, "transistor", MatchTrans, DescribeT];
lTransClass _ Register[$C2LTrans, FillLTransistor, "L-transistor", MatchTrans];
oldBadWellLTransClass _ Register[$CLWellTrans, OldBadFillLTransistor, "L-transistor", MatchTrans];
wellLTransClass _ Register[$C2LWellTrans, FillLTransistor, "L-transistor", MatchTrans];

simpleContactClass _ Register[$C2SimpleCon, FillSimpleCon, "contact", NIL, DescribeC];
wellSimpleContactClass _ Register[$C2WellSimpleCon, FillSimpleCon, "contact", NIL, DescribeC];

largeContactClass _ Register[$C2LargeSimpleCon, FillLargeSimpleCon, "large contact", NIL, DescribeLargeC];
wellLargeContactClass _ Register[$C2LargeWellSimpleCon, FillLargeSimpleCon, "large contact", NIL, DescribeLargeC];

[] _ Register[$C2DiffShortCon, FillDiffShortCon, "diff short contact"];
[] _ Register[$C2DifShortCon, OldFillDiffShortCon, "diff short contact"];--old
wellDiffShortConClass _ Register[$C2WellDifShortCon, OldFillDiffShortCon, "fdif short contact"];

[] _ Register[$C2Via, FillVia, "via"];
[] _ Register[$C2LargeVia, FillLargeVia, "large via"];
}; 

Init[];
END. 


dCMosBObjectsImpl.mesa
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, May 3, 1983 11:22 am 
Last edited by: Christian Jacobi, March 30, 1987 3:44:35 pm PST
--Client stuff 

--Real implementations  
-- straight transistors -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--poly, dif, welldif, via
-- Don't care about different diffusions and such

-- L transistors -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--horizontal piece of nwell
--vertical piece of nwell if ~empty
--horizontal piece of diff
--vertical piece of diff

-- simple contacts -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
-- DifShort -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--via -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--poly, dif, welldif, via
-- Don't care about different diffusions and such

--transistors
--contacts
Κ˜š
œ™Jšœ
Οm
œ7™BJš
œ2™2Icodeš
œ?™?—J˜š
Οk	˜	Kš
œ˜Kš
œ
˜
Kšžœ
˜Kš
œ˜Kš
œ	˜	Kš
œ	˜	Kš
œ˜Kšœž
˜Kš
œ˜—K˜šΟnœžœ
ž˜Kšžœ
žœM˜WKšžœ˜—Kš
ž˜K˜Kšœžœ˜!Kšœžœ˜-K˜Kš
Πbl™K˜š
Ÿœžœžœžœžœ˜0šžœž˜
Kšœ4žœ˜?Kšžœžœ˜—Kš
œ˜—K˜š
Ÿœžœžœžœžœ˜0šžœž˜
KšœVžœ˜aKšžœžœ˜—Kš
œ˜—K˜šŸœžœžœžœžœ	žœ
žœžœ˜oKšžœF˜LK˜—K˜š
Ÿ
œžœ
žœžœžœ˜5Kšžœ1˜7Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜FKšžœ7˜=Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜KKšžœ9˜?Kš
œ˜—K˜š
Ÿ	œžœ
žœžœžœ˜1Kšžœ ˜&Kš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜]Kšžœ1˜7Kš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜bKšžœ2˜8Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜IKšžœ2˜8Kš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜\Kšžœ8˜>Kš
œ˜—K˜šŸœžœ
žœžœžœžœ
˜FKšžœ!˜'Kš
œ˜—K˜K™Kš
 ™K˜Kš
œf™fK˜šŸ
œžœžœžœžœžœžœžœžœ˜hKš
œ™Kš
œ1™1Kšžœžœ˜*Kš
œ˜—K˜Kšœžœ
˜Kšœžœ
˜K˜šŸœžœžœ	žœžœ
žœ˜GKšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜&Kšœ	žœ˜&šžœžœžœ˜6Kš
œ˜Kšžœžœžœ˜Dš
œ$˜$š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜—Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—Kš
œ
˜
—šžœ˜Kšžœžœžœ˜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˜Kšœ
žœ
˜Kšœžœ
˜ Kšœžœ
˜&K˜šŸœžœžœ	žœžœ
žœ˜NKš
œ˜Kšžœ˜K˜—K˜šŸœžœžœ	žœžœ
žœ˜HKšœžœΟc˜/Kšœžœ‘˜4Kšœžœ‘1˜KKšœžœ‘,˜FKšœžœ˜"Kšœžœ˜Kšœžœ˜Kšœ	žœ˜Kšœ	žœ˜Kš
œ˜šžœžœžœ˜6Kš
œ˜Kš
œ˜Kšžœžœžœ˜DKš
œ™š
œ$˜$š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ$˜$—Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—Kš
œ#™#š
œ+˜+Kš
œ˜Kš
œ#˜#Kš
œ˜—šžœž˜š
œ$˜$Kš
œ˜Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜——K˜
—šžœ˜Kšžœžœžœ˜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š
œa™aK˜Kšœžœ
˜#Kšœžœ
˜'Kšœžœ
˜"Kšœžœ
˜&K˜šŸ
œžœžœ	žœžœ
žœ˜FKšœžœ‘˜0Kšœžœ1˜8š
žœžœžœžœžœ˜pKš
œ"˜"š
œ$˜$Kš
œ=˜=Kš
œ)˜)Kšœž˜
Kš
œ˜—K˜—Kš
œW˜WKš
œ>˜>Kš
œV˜VKš
œ˜K˜—šŸœžœžœ	žœžœ
žœ˜KKšœžœ‘˜.Kšœžœ˜Kšœ	žœ˜&Kšœ	žœ˜&š
žœžœžœžœžœ˜pKš
œ!˜!š
œ$˜$Kš
œ=˜=Kš
œ)˜)Kšœž˜
Kš
œ˜—K˜—Kš
œW˜WKš
œ>˜>Kš
œV˜VKš
œ˜K˜—šŸ	œ˜Kšžœ2˜8Kš
œ˜—K˜šŸœ˜#Kšžœ8˜>Kš
œ˜—K˜Kš
œZ™ZK˜Kšœžœ
˜&K˜šŸœžœžœ	žœžœ
žœ˜IKšœžœ˜Kšœžœ4˜;Kšœžœ4˜<Kšœžœ;˜Bšžœžœžœ˜6Kšœžœ2˜9Kšœžœ4˜;šžœžœ˜Kš
œ)˜)K˜
—šžœ
žœžœ˜$Kš
œ)˜)K˜—Kš
œ˜Kšœ^žœ˜eKšœ^žœ˜eK˜
—šžœ
žœžœ˜"Kš
œ)˜)K˜
—šžœ˜Kš
œ*˜*Kšœ‘˜&K˜—Kš
œ>˜>Kš
œ9˜9Kš
œ:˜:Kš
œX˜XKš
œ˜K˜—šŸœžœžœ	žœžœ
žœ˜LKšœžœ˜Kšœžœ4˜;Kšœžœ4˜<Kšœžœ;˜Bšžœžœžœ˜6Kš
œ!˜!šžœžœ˜Kš
œ)˜)K˜
—šžœ
žœžœ˜$Kš
œ)˜)K˜—Kšœ„
žœ˜‹
K˜
—šžœ
žœžœ˜"Kš
œ)˜)K˜
—šžœ˜Kš
œ*˜*Kšœ‘˜&K˜—Kš
œ>˜>Kš
œ9˜9Kš
œ:˜:Kš
œX˜XKš
œ˜K˜—K˜Kš
œ`™`K˜šŸœžœžœ	žœžœ
žœ˜AKšœ
žœ˜ Kšœ	žœ˜Kš
œ?˜?Kš
œ˜Kš
œC˜CKš
œB˜Bš
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šŸœžœžœ	žœžœ
žœ˜EKšœ
žœ˜"Kšœ	žœ˜Kšœ
žœ$˜4Kšœ
žœ$˜4Kš
œ˜Kš
œC˜CKš
œB˜Bš
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜K˜—Kš
œZ™ZK˜šŸœžœžœžœžœžœžœžœžœ˜lKš
œ™Kš
œ1™1Kšžœžœ˜*Kš
œ˜—K˜šŸœžœ˜K˜šŸœžœžœ6žœ&žœžœžœžœžœ˜Ό
Kš
œK˜KKšžœžœ
žœ
žœ
˜Kšžœ
žœ
žœ˜+Kšžœžœ
žœ˜*Kš
œ.˜.Kš
œ˜—K™Kš
œ
™
Kš
œU˜UKš
œ]˜]Kš
œO˜OKš
œb˜bKš
œW˜WK˜Kš
œ
™
KšœFžœ
˜VKšœNžœ
˜^K˜KšœUžœ˜jKšœ]žœ˜rK˜Kš
œG˜GKšœI‘˜NKš
œ`˜`K˜Kš
œ&˜&Kš
œ6˜6Kš
œ˜K˜—K˜Kšžœ˜K˜
—…—1ΤEΕ