DIRECTORY
CD,
CDColors,
CDCommandOps,
CDEnvironment,
CDEvents,
CDLayers,
CDPanel,
CDPrivate,
CDRects,
CDSequencer,
CMos,
ImagerColor,
Rope,
TerminalIO,
TokenIO;

CMosImpl: CEDAR PROGRAM
IMPORTS CD, CDCommandOps, CDColors, CDEnvironment, CDEvents, CDLayers, CDPanel, CDPrivate, CDRects, CDSequencer, ImagerColor, TerminalIO, TokenIO 
EXPORTS CMos
SHARES CDLayers, CDRects = 
BEGIN

cmos: PUBLIC CD.Technology _ CD.RegisterTechnology[$CMosA, "CMosA", 2];
lambda: CD.Number = CMos.lambda;

ndif: PUBLIC CD.Layer;
pdif: PUBLIC CD.Layer;

wndif: PUBLIC CD.Layer;
wpdif: PUBLIC CD.Layer;

pwell: PUBLIC CD.Layer;
nwell: PUBLIC CD.Layer;
pwellCont: PUBLIC CD.Layer;
nwellCont: PUBLIC CD.Layer;

pol: PUBLIC CD.Layer;
met: PUBLIC CD.Layer;
met2: PUBLIC CD.Layer;

imp: PUBLIC CD.Layer;
bur: PUBLIC CD.Layer;
ovg: PUBLIC CD.Layer;
cut: PUBLIC CD.Layer;
cut2: PUBLIC CD.Layer;


wpdifClass: CD.ObjectClass = CD.RegisterObjectClass[$CMosPDifRect, [
internalRead: CDRects.wellRectClass.internalRead,
technology: cmos
]];
wndifClass: CD.ObjectClass = CD.RegisterObjectClass[$CMosNDifRect, [
internalRead: CDRects.wellRectClass.internalRead,
technology: cmos
]];

CurrentDiffusion: PUBLIC PROC [design: CD.Design] RETURNS [CD.Layer] =
BEGIN
lev: CD.Layer _ CDLayers.CurrentLayer[design];
IF lev=wpdif THEN RETURN [pdif];
IF lev=wndif THEN RETURN [ndif];
IF lev=ndif OR lev=pdif OR lev=pwellCont OR lev=nwellCont THEN RETURN [lev] ELSE RETURN [CD.undefLayer]
END;

SetLayerNWell: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["NWell for default\n"];
CDLayers.SetCurrentLayer[comm.design, nwell]
END;

SetLayerPWell: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["PWell for default\n"];
CDLayers.SetCurrentLayer[comm.design, pwell];
END;

SetLayerDif: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["diffusion for default\n"];
CDLayers.SetCurrentLayer[comm.design, ndif]
END;

SetLayerPol: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["poly for default\n"];
CDLayers.SetCurrentLayer[comm.design, pol]
END;

SetLayerMet2: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["metal-2 for default\n"];
CDLayers.SetCurrentLayer[comm.design, met2]
END;

SetLayerMet: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["metal for default\n"];
CDLayers.SetCurrentLayer[comm.design, met]
END;

SetLayerPDif: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["p-diff for default\n"];
CDLayers.SetCurrentLayer[comm.design, wpdif]
END;

SetLayerNWCnt: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["N-Well Cnt for default\n"];
CDLayers.SetCurrentLayer[comm.design, nwellCont]
END;

SetLayerPWCnt: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.PutRope["P-Well Cnt for default\n"];
CDLayers.SetCurrentLayer[comm.design, pwellCont]
END;

DiffToPWorld: PROC [comm: CDSequencer.Command] =
BEGIN
layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
TerminalIO.PutRope["Switch diffusion to P type"];
SELECT layer FROM
ndif => CDLayers.SetCurrentLayer[comm.design, wpdif];
pwellCont => CDLayers.SetCurrentLayer[comm.design, nwellCont];
ENDCASE => TerminalIO.PutRope["  not done"];
TerminalIO.PutRope["\n"];
END;

DiffToNWorld: PROC [comm: CDSequencer.Command] =
BEGIN
layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
TerminalIO.PutRope["Switch diffusion to N type"];
SELECT layer FROM
pdif => CDLayers.SetCurrentLayer[comm.design, ndif];
wpdif => CDLayers.SetCurrentLayer[comm.design, ndif];
nwellCont => CDLayers.SetCurrentLayer[comm.design, pwellCont];
ENDCASE => TerminalIO.PutRope["  not done"];
TerminalIO.PutRope["\n"];
END;

RegisterObjectClass: PUBLIC PROC [a: ATOM] RETURNS [CD.ObjectClass] =
BEGIN
RETURN [ CD.RegisterObjectClass[a, [technology: cmos]] ];
END; 

WriteTechnologyKey: CDEvents.EventProc = {
h: TokenIO.Handle _ NARROW[x];
TokenIO.WriteAtom[h, $CMos]; 
TokenIO.WriteInt[h, 1];
};   

ReadTechnologyKey: CDEvents.EventProc = {
h: TokenIO.Handle _ NARROW[x];
dont _ TRUE;
IF TokenIO.ReadAtom[h]=$CMos THEN { 
version: INT = TokenIO.ReadInt[h];
IF version=1 THEN dont_FALSE
ELSE IF version=0 THEN {
TerminalIO.PutRope["***********************\n"];
TerminalIO.PutRope["WARNING: objects using p-diffusion\n"];
TerminalIO.PutRope["may be displaced; chat with Christian\n"];
TerminalIO.PutRope["***********************\n"];
dont_FALSE
}; 
};
IF dont THEN TerminalIO.PutRope["CMos version miss-match\n"];
};   


InitBricks: PROC [] =
BEGIN
nDiffColor: CARDINAL = 1;
pDiffColor: CARDINAL = 2;
met1Color: CARDINAL = 4;
met2Color: CARDINAL = 8;
polyColor: CARDINAL = 16;
nWellColor: CARDINAL = 32;
pWellColor: CARDINAL = 64;
black: CARDINAL = 127;

Checker8: PROC[col1, col2: CARDINAL] RETURNS[REF CDColors.Brick] = {
RETURN[NEW[CDColors.Brick _ [col1*256+col2, col2*256+col1, col1*256+col2, col2*256+col1]]]
};

DefineDimmer8: PROC[lev: CD.Layer, color: CARDINAL] = {
CDColors.DefineColor[lev, Checker8[color, 0], bit8, pushedOut];
};

Full8: PROC[color: CARDINAL] RETURNS [b: REF CDColors.Brick] = {
RETURN[Checker8[color, color]]
};

s1: CARDINAL = 1;
s2: CARDINAL = 16;
s3: CARDINAL = 16*16;
s4: CARDINAL = 16*16*16;
ss: CARDINAL = s1+s2+s3+s4;

green: CARDINAL = 1;
blue: CARDINAL = 2;
red: CARDINAL = 4;
yellow: CARDINAL = 14;

CDColors.DefineColor[cut, NEW[CDColors.Brick_[7*ss, 11*ss, 7*ss, 11*ss]], bit4];
CDColors.DefineColor[cut, NEW[CDColors.Brick_[7*ss, 11*ss, 7*ss, 11*ss]], bw];

CDColors.DefineColor[ndif, NEW[CDColors.Brick_[green*ss, green*ss, green*ss, green*ss]], bit4];
CDColors.DefineColor[ndif, NEW[CDColors.Brick_[4*ss, ss, 4*ss, ss]], bw];

CDColors.DefineColor[pdif, NEW[CDColors.Brick_[1*ss, 3*ss, 1*ss, 1*ss]], bit4];
CDColors.DefineColor[pdif, NEW[CDColors.Brick_[5*ss, ss, 4*ss, ss]], bw];

CDColors.DefineColor[pwellCont, NEW[CDColors.Brick_[1*ss, 1*ss, 0*ss, 1*ss]], bit4];
CDColors.DefineColor[pwellCont, NEW[CDColors.Brick_[0*ss, ss, 4*ss, ss]], bw];

CDColors.DefineColor[nwellCont, NEW[CDColors.Brick_[1*ss, 1*ss, 2*ss, 1*ss]], bit4];
CDColors.DefineColor[nwellCont, NEW[CDColors.Brick_[2*ss, ss, 4*ss, ss]], bw];

CDColors.DefineColor[pol, NEW[CDColors.Brick_[red*ss, red*ss, red*ss, red*ss]], bit4];
CDColors.DefineColor[pol, NEW[CDColors.Brick_[8*ss, 4*ss, 2*ss, 1*ss]], bw];

CDColors.DefineColor[met, NEW[CDColors.Brick_[blue*ss, blue*ss, blue*ss, blue*ss]], bit4];
CDColors.DefineColor[met, NEW[CDColors.Brick_[8*ss, 2*ss, 0, 0]], bw];

CDColors.DefineColor[imp, NEW[CDColors.Brick_[yellow*ss, yellow*ss, yellow*ss, yellow*ss]], bit4];
CDColors.DefineColor[imp, NEW[CDColors.Brick_[2*ss, 0, 2*ss, 0]], bw];

CDColors.DefineColor[met2, NEW[CDColors.Brick_[2*(s1+s2+s3), 2*ss, 2*(s1+s2+s3)+15*s4, 2*ss]], bit4];
CDColors.DefineColor[met2, NEW[CDColors.Brick_[8*ss, 8*ss, 2*ss, 2*ss]], bw];

CDColors.DefineColor[nwell, NEW[CDColors.Brick_[8*s1, 0, 0, 0]], bit4];
CDColors.DefineColor[nwell, NEW[CDColors.Brick_[4*ss, 0, 0, 0]], bw];

CDColors.DefineColor[pwell, NEW[CDColors.Brick_[4*s1, 0, 0, 0]], bit4];
CDColors.DefineColor[pwell, NEW[CDColors.Brick_[2*ss, 0, 0, 0]], bw];

CDColors.DefineColor[bur, NEW[CDColors.Brick_[11*ss, 11*ss, 11*ss, 11*ss]], bit4];
CDColors.DefineColor[bur, NEW[CDColors.Brick_[4*ss, 14*ss, 4*ss, 0*ss]], bw];

CDColors.DefineColor[ovg, NEW[CDColors.Brick_[8*ss, 8*ss, 8*ss, 8*ss]], bit4];
CDColors.DefineColor[ovg, NEW[CDColors.Brick_[4*ss, 14*ss, 4*ss, 0*ss]], bw];

CDColors.DefineColor[cut2, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bit4];
CDColors.DefineColor[cut2, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bw];

CDColors.DefineColor[wpdif, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bit4];
CDColors.DefineColor[wpdif, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bw];

CDColors.DefineColor[ndif, Full8[nDiffColor], bit8];
CDColors.DefineColor[pdif, Full8[pDiffColor], bit8];
CDColors.DefineColor[met, Full8[met1Color], bit8];
CDColors.DefineColor[met2, Full8[met2Color], bit8]; 
CDColors.DefineColor[pol, Full8[polyColor], bit8];
CDColors.DefineColor[nwell, Full8[nWellColor], bit8];
CDColors.DefineColor[pwell, Full8[pWellColor], bit8];
CDColors.DefineColor[cut, Full8[black], bit8];

CDColors.DefineColor[cut2, Checker8[black, met1Color], bit8];
CDColors.DefineColor[bur, Checker8[black, 0], bit8];
CDColors.DefineColor[nwellCont, Checker8[pDiffColor, met1Color], bit8];
CDColors.DefineColor[pwellCont, Checker8[nDiffColor, met1Color], bit8];
CDColors.DefineColor[ovg, Checker8[met1Color, met2Color], bit8];

CDColors.DefineColor[imp, NEW[CDColors.Brick_[14, 14, 0, 0]], bit8];


DefineDimmer8[ndif, nDiffColor];
DefineDimmer8[pdif, pDiffColor];
DefineDimmer8[met, met1Color];
DefineDimmer8[met2, met2Color];
DefineDimmer8[pol, polyColor];
DefineDimmer8[nwell, nWellColor];
DefineDimmer8[cut, black];
DefineDimmer8[cut2, black];

CDColors.DefineIColor[ndif, ImagerColor.ColorFromRGB[[0, 1, 0]], bit8];
CDColors.DefineIColor[pdif, ImagerColor.ColorFromRGB[[0, 1, 0]], bit8];
CDColors.DefineIColor[nwell, ImagerColor.ColorFromRGB[[0.8, 0.8, 0.5]], bit8];
CDColors.DefineIColor[pwellCont, ImagerColor.ColorFromRGB[[0, 1, 0]], bit8];
CDColors.DefineIColor[nwellCont, ImagerColor.ColorFromRGB[[0, 1, 0]], bit8];
CDColors.DefineIColor[pol, ImagerColor.ColorFromRGB[[1, 0, 0]], bit8];
CDColors.DefineIColor[met, ImagerColor.ColorFromRGB[[0, 0, 1]], bit8];
CDColors.DefineIColor[met2, ImagerColor.ColorFromRGB[[0.7, 0.4, 0.7]], bit8];
CDColors.DefineIColor[ovg, ImagerColor.ColorFromRGB[[0.5, 0.5, 0.5]], bit8];
CDColors.DefineIColor[cut, ImagerColor.ColorFromRGB[[0, 0, 0.1]], bit8];
CDColors.DefineIColor[cut2, ImagerColor.ColorFromRGB[[0, 0.1, 0]], bit8];
CDColors.DefineIColor[bur, ImagerColor.ColorFromRGB[[0.1, 0.1, 0]], bit8];
CDColors.DefineIColor[imp, ImagerColor.ColorFromRGB[[1, 1, 0]], bit8];

END;

Init: PROC [] =
BEGIN
CDPrivate.ConvertTechnologyKey[cmos, $cmos];

ndif _ CD.NewLayer[cmos, $ndif];
pdif _ CD.NewLayer[cmos, $pdif];
wndif _ CD.NewLayer[cmos, $wndif];
wpdif _ CD.NewLayer[cmos, $wpdif];
pwell _ CD.NewLayer[cmos, $pwel];
nwell _ CD.NewLayer[cmos, $nwel];
pwellCont _ CD.NewLayer[cmos, $pwelCont];
nwellCont _ CD.NewLayer[cmos, $nwelCont];

pol _ CD.NewLayer[cmos, $pol];
met _ CD.NewLayer[cmos, $met];
met2 _ CD.NewLayer[cmos, $met2];

imp _ CD.NewLayer[cmos, $imp];
bur _ CD.NewLayer[cmos, $bur];
ovg _ CD.NewLayer[cmos, $ovg];
cut _ CD.NewLayer[cmos, $cut];
cut2 _ CD.NewLayer[cmos, $cut2];

CDLayers.MakeAbstract[abstract: wpdif, paint: pdif, well: nwell, wSurr: CMos.wellSurround];
CDLayers.MakeAbstract[abstract: wndif, paint: ndif, well: pwell, wSurr: CMos.wellSurround];

CDLayers.MakeSuppressIR[nwell];
CDLayers.MakeSuppressIR[pwell];

InitBricks[];

CDPanel.Layer[ndif, "ndif", 0, 2*lambda, 1, cmos];
CDPanel.Layer[wpdif, "wpdif", 0, 2*lambda, 1, cmos];
CDPanel.Layer[pol, "pol", 0, 2*lambda, 1, cmos];
CDPanel.Layer[met, "met", 0, 3*lambda, 1, cmos];
CDPanel.Layer[pwellCont, "p-wCnt", 0, 2*lambda, 1, cmos];
CDPanel.Layer[nwellCont, "n-wCnt", 0, 2*lambda, 1, cmos];
CDPanel.Layer[nwell, "nwell", 0, 0, 1, cmos];
CDPanel.Layer[met2, "met2", 0, 4*lambda, 1, cmos];

CDPanel.Layer[cut, "cut", 0, 0, 2, cmos];
CDPanel.Layer[cut2, "cut2", 0, 0, 2, cmos];
CDPanel.Layer[ovg, "ovg", 0, 0, 2, cmos];
CDPanel.Layer[bur, "bur", 0, 0, 2, cmos];
CDPanel.Layer[pwell, "(pwell)", 0, 0, 2, cmos];
CDPanel.Layer[pdif, "(pdif)", 0, 2*lambda, 2, cmos];
CDPanel.Layer[wndif, "(wndif)", 0, 2*lambda, 2, cmos];

CDPanel.Layer[CD.commentLayer, " black   ", 0, lambda, 0, cmos];

CDPanel.Number[number: [cdValueKey: $CDxStepValue], tech: cmos, button: [text: "step move dist:"], min: 0, default: 0, lambda: lambda];
CDPanel.Number[number: [cdValueKey: $CDxSelectNewMode], tech: cmos, button: [text: "select new mode:", xpos: 180], min: 0, max: 1, default: 1, lambda: 1];
CDPanel.Line[cmos];

CDSequencer.ImplementCommand[$SetLayerNWell, SetLayerNWell, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerNDif, SetLayerDif, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerPol, SetLayerPol, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerMet, SetLayerMet, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerMet2, SetLayerMet2, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerPDif, SetLayerPDif, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerNWCnt, SetLayerNWCnt, cmos, doQueue];
CDSequencer.ImplementCommand[$SetLayerPWCnt, SetLayerPWCnt, cmos, doQueue];

CDSequencer.ImplementCommand[$TestDifFlipToPWorld, DiffToPWorld, cmos, doQueue];
CDSequencer.ImplementCommand[$TestDifFlipToNWorld, DiffToNWorld, cmos, doQueue];
CDSequencer.ImplementCommand[$DiffToPWorld, DiffToPWorld, cmos, doQueue];
CDSequencer.ImplementCommand[$DiffToNWorld, DiffToNWorld, cmos, doQueue];

CDEvents.RegisterEventProc[$WriteTechnologyPrivate, WriteTechnologyKey, cmos];
CDEvents.RegisterEventProc[$ReadTechnologyPrivate, ReadTechnologyKey, cmos];

CDEnvironment.SetIcon[cmos, "Chipndale.icons", 3];
CDEnvironment.SetPanelIcon[cmos, "Chipndale.icons", 4];

CDEnvironment.SetTipTable[cmos, "Standard"];

CDCommandOps.RegisterCommanderNewDesign[cmos];
TerminalIO.PutRope["cmos-A impl\n"];
END;

Init[];
END.


NCMosImpl.mesa
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, August 11, 1983 3:56 pm
Last Edited by: Christian Jacobi, February 25, 1987 3:24:16 pm PST
--8bit colors--
--4bit colors--
--wpdif should never be drawn
CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick _ [8, 0, 256*8, 0]], bit8];
CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick _ [255, 0, 0, 0]], bit8];
CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[0, 255,0 , 255]], bit8];
-- no change for bur, nwelCont, pwelCont, and ovgc for this background
�Ê©˜
codeš
œ
™
Kšœ
Ïm
œ7™BKš
œ4™4K™BK˜—š
Ïk	˜	Kšžœ
˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜K˜	Kš
œ	˜	K˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šÏnœžœ
ž˜Kšžœ
žœˆ
˜’
Kšžœ˜Kšžœ˜—š
ž˜K˜Kšœžœ
žœžœ(˜GJšœžœ˜ K˜Kšœžœ
žœ˜Kšœžœ
žœ˜K˜Kšœžœ
žœ˜Kšœžœ
žœ˜K˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜K˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜K˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜—K˜K˜šœžœžœ%˜DKš
œ1˜1Kš
œ˜Kš
œ˜—šœžœžœ%˜DKš
œ1˜1Kš
œ˜Kš
œ˜—K˜šŸœžœ
žœ
žœ	žœžœ	˜FKš
ž˜Kšœžœ'˜.Kšžœžœ
žœ˜ Kšžœžœ
žœ˜ Kšžœ
žœ
žœžœžœ
žœžœ
žœžœ˜gKšžœ
˜—K˜šŸ
œžœ˜1Kš
ž˜K˜*Kš
œ,˜,Kšžœ
˜K˜—šŸ
œžœ˜1Kš
ž˜K˜*Kš
œ-˜-Kšžœ
˜K˜—šŸœžœ˜/Kš
ž˜K˜.Kš
œ+˜+Kšžœ
˜K˜—šŸœžœ˜/Kš
ž˜K˜)Kš
œ*˜*Kšžœ
˜K˜—šŸœžœ˜0Kš
ž˜K˜,Kš
œ+˜+Kšžœ
˜K˜—šŸœžœ˜/Kš
ž˜K˜*Kš
œ*˜*Kšžœ
˜K˜—šŸœžœ˜0Kš
ž˜K˜+Kš
œ,˜,Kšžœ
˜K˜—šŸ
œžœ˜1Kš
ž˜K˜/Kš
œ0˜0Kšžœ
˜K˜—šŸ
œžœ˜1Kš
ž˜K˜/Kš
œ0˜0Kšžœ
˜K˜—šŸœžœ˜0Kš
ž˜Kšœžœ,˜5K˜1šžœž˜Kš
œ5˜5Kš
œ>˜>Kšžœ%˜,—Kš
œ˜Kšžœ
˜K˜—šŸœžœ˜0Kš
ž˜Kšœžœ,˜5K˜1šžœž˜Kš
œ4˜4Kš
œ5˜5Kš
œ>˜>Kšžœ%˜,—Kš
œ˜Kšžœ
˜—K˜šŸœžœ
žœžœžœžœ˜EKš
ž˜Kšžœžœ.˜9Kšžœ˜K˜—šÐbnœ˜*Kšœžœ˜Kš
œ˜Kš
œ˜š
œ˜K˜——šÏbœ˜)Kšœžœ˜Kšœžœ
˜šžœžœ˜$Kšœ	žœ˜"Kšžœžœž˜šžœ
žœžœ˜Kš
œ0˜0Kš
œ;˜;Kš
œ>˜>Kš
œ0˜0Kšœž˜
Kš
œ˜—K˜—Kšžœžœ1˜=Kš
œ˜K˜—K˜šŸ
œžœ˜Kš
ž˜Kš
œ™Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜š
Ÿœžœ
žœžœ
žœ˜DKšžœ
žœP˜ZKš
œ˜—K˜šŸ
œžœžœžœ˜7Kš
œ?˜?Kš
œ˜—K˜š
Ÿœžœžœžœžœ˜@Kšžœ˜Kš
œ˜—K˜Kšœžœ˜Kšœžœ˜Kšœžœ	˜Kšœžœ˜Kšœžœ˜K˜Kš
œ™Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜Kšœžœ3˜PKšœžœ1˜NK˜KšœžœA˜_Kšœžœ+˜IK˜Kšœžœ1˜OKšœžœ+˜IK˜Kšœ žœ1˜TKšœ žœ+˜NK˜Kšœ žœ1˜TKšœ žœ+˜NK˜Kšœžœ9˜VKšœžœ/˜LK˜Kšœžœ=˜ZKšœžœ)˜FK˜KšœžœE˜bKšœžœ)˜FK˜KšœžœG˜eKšœžœ/˜MK˜Kšœžœ(˜GKšœžœ&˜EK˜Kšœžœ(˜GKšœžœ&˜EK˜Kšœžœ5˜RKšœžœ0˜MK˜Kšœžœ1˜NKšœžœ0˜MK˜Kšœžœ3˜QKšœžœ1˜OK˜Kš
œ™Kšœžœ3˜RKšœžœ1˜PK˜Kš
œ4˜4Kš
œ4˜4Kš
œ2˜2Kš
œ4˜4Kš
œ2˜2Kš
œ5˜5Kš
œ5˜5Kš
œ.˜.K˜Kš
œ=˜=Kš
œ4˜4Kš
œG˜GKš
œG˜GKš
œ@˜@K˜Kšœžœ'˜DK˜Kšœžœžœ+™WKšœžœ
žœ)™PKšœžœ
žœ)™PK˜Kš
œ ˜ Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜Kš
œF™FK˜Kš
œG˜GKš
œG˜GKš
œN˜NKš
œL˜LKš
œL˜LKš
œF˜FKš
œF˜FKš
œM˜MKš
œL˜LKš
œH˜HKš
œI˜IKš
œJ˜JKš
œF˜FK˜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š
œ2˜2Kš
œ4˜4Kš
œ0˜0Kš
œ0˜0Kš
œ9˜9Kš
œ9˜9Kš
œ-˜-Kš
œ2˜2K˜Kš
œ)˜)Kš
œ+˜+Kš
œ)˜)Kš
œ)˜)Kš
œ/˜/Kš
œ4˜4Kš
œ6˜6K˜Kšœžœ0˜@K˜Kš
œ‡
˜‡
Kš
œš
˜š
K˜K˜Kš
œK˜KKš
œH˜HKš
œG˜GKš
œG˜GKš
œI˜IKš
œI˜IKš
œK˜KKš
œK˜KK˜Kš
œP˜PKš
œP˜PKš
œI˜IKš
œI˜IK˜Kš
œN˜NKš
œL˜LK˜Kš
œ2˜2Kš
œ7˜7K˜Kš
œ,˜,K˜Kš
œ.˜.K˜$Kšžœ
˜—K˜K˜Kšžœ
˜K˜
—…—2ÒAÉ