DIRECTORY 
Basics,
CD,
CDCells USING [CreateEmptyCell, SetInterestRect],
CDDirectory,
CDRects USING [CreateRect], 
Convert,
IFUPW,
IO,
PW, 
Rope;


IFUPWMux: CEDAR PROGRAM
IMPORTS
CD, CDCells, CDDirectory, CDRects, Convert, IO, IFUPW, PW, Rope
EXPORTS IFUPW =
BEGIN OPEN IFUPW;

gnd: INT _ 6;
vdd: INT _ 7;	-- vdd assumed to be gnd+1 below
IFUMuxRow: PUBLIC PROC [
design:	CD.Design,
name:		PW.ROPE,
leftCtl:	List _ NIL,
rightCtl:	List _ NIL,
top:		LIST OF REF,
in:			LIST OF REF,
out:		LIST OF REF,
bot:		LIST OF REF,
rp:			RowParams	_ IFUDataColNSeq ]
RETURNS [cell: CD.Object] = {
cells:	PW.ListOb;
ctl:	List _ IFUPW.ListConcat[leftCtl, rightCtl];
FOR ii: INT DECREASING IN [0..rp.rngByte*rp.rngBit) DO
byte, index: INT;
[byte, index] _ IFUPW.ByteBitFromIndex[ii, rp];
cells _ CONS[ Mux[
design:	design,
ctl:		ctl,
in:			ExpandList[byte, index, in],
top:		ExpandList[byte, index, top],
out:		ExpandList[byte, index, out],
bot:		ExpandList[byte, index, bot] ], cells];
ENDLOOP;
cell _ PW.AbutListX[design, cells];
cell _ IFUPW.RenameObjAndAssignRowPins
[design, cell, name, FALSE, top, bot, leftCtl, rightCtl, rp];
RETURN[cell]};

Mux: PROC [
design:	CD.Design,
top:		List,
ctl:		List,
in:			List,
out:		List, 
bot:		List]
RETURNS [cell: CD.Object] = {
cellName:		PW.ROPE;
xstrLgth:		INT		_ 8*lambda;
xstrWth:		INT		_ (4+4)*lambda;
tranBiasx:		INT		_ (xstrWth-metW)/2;
xstrHt:		INT		_ xstrLgth + 2*difW;
pFrng:		INT		_ (pwrW-metW)/2;
topExtra:		INT		_ cnctSize/2 + topTail;
botExtra:		INT		_ cnctSize/2 + botTail;
pitch: 		Size		= [metPitch, met2Pitch];
found:		BOOL		_ TRUE;
muxEvenDn:	BOOL		= TRUE;
range:			Size;
outN:			PW.ROPE	_ IF out=NIL THEN NIL ELSE out.first;
iRect:			CD.Rect;
outIndex, outIndexBot:		INT;
top _ FixGVInList[top];
bot _ FixGVInList[bot];
range		_ [MAX[ListLength[top],ListLength[bot]], ListLength[ctl]];
outIndex		_ ListItemIndexMin[top, outN];
outIndexBot	_ ListItemIndexMin[bot, outN];
IF outIndex		# ListItemIndexMax[top, outN] OR
outIndexBot	 # ListItemIndexMax[bot, outN] OR
(outIndex#-1 	AND outIndexBot#-1 AND outIndex#outIndexBot)
THEN ERROR Error[IO.PutFR["Multiple column output %g- ABORT", IO.rope[outN]]];
IF outIndex = -1 THEN outIndex _ outIndexBot;
cellName _ UniqueCellName["Mux", top, bot, in, out];
[found, cell] _ CDDirectory.Fetch[design, cellName];
IF found THEN RETURN[cell];
log.PutRope["."];
cell	_ CDCells.CreateEmptyCell[];
IF outN#NIL AND ListItemIndexMax[top, outN]=-1 AND ListItemIndexMax[bot, outN]=-1
THEN ERROR Error[IO.PutFR
["Output signal (%g) is not in either top or bot lists - ABORT", IO.rope[outN]]];
IF outN#NIL AND ListItemIndexMax[in, outN]#-1 THEN ERROR Error[IO.PutFR
["Output signal (%g) is also used as input - ABORT", IO.rope[outN]]];
FOR i: INT IN [0..range.x) DO
loc:	Location	_ [i*pitch.x, 0];
tIO:	PW.ROPE	_ ListIndexItem[top,	i];
bIO:	PW.ROPE	_ ListIndexItem[bot,	i];
topOut:	BOOL	_ Rope.Equal[tIO,outN];
botOut:	BOOL	_ Rope.Equal[bIO,outN];
tY:		INT _ IF topOut THEN	ListNonNILIndexMin[in] ELSE	ListItemIndexMin[in,tIO];
bY:	INT _ IF botOut THEN	ListNonNILIndexMax[in] ELSE	ListItemIndexMax[in,bIO];
tY	_	tY		+  ((tY	+ (IF	topOut=muxEvenDn	THEN 1 ELSE 2))	MOD 2);
bY	_	bY		+  ((bY	+ (IF	botOut=muxEvenDn	THEN 1 ELSE 2))	MOD 2);
IF tY=-1 AND bY=-1 THEN tY_bY_0;
IF ~Rope.Equal[tIO, bIO] AND tY<=bY AND tIO#NIL AND bIO#NIL
THEN ERROR Error[IO.PutFR
["2 signals (%g, %g) in same channel - ABORT", IO.rope[tIO], IO.rope[bIO]]];
IF tIO#NIL	THEN AddRet[cell:cell, level: cmosMet,
size:	[metW,	(range.y-tY)	* pitch.y	+ topExtra	],
loc:	[i*pitch.x,	     	      tY 	* pitch.y										]];
IF bIO#NIL	THEN AddRet[cell:cell, level: cmosMet,
size:	[metW,				bY	* pitch.y	+ botExtra	],
loc:	[i*pitch.x,					0	* pitch.y	- botExtra	]];
ENDLOOP;
FOR vgIndex: INT IN [gnd..vdd] DO AddRet[cell: cell, level: cmosMet,
size:	[pwrW, range.y	* pitch.y + topExtra	+	botExtra ],
loc:	[vgIndex*pitch.x-pFrng,	     			-	botExtra ]] ENDLOOP;
AddMetalPins
[cell, top, bot, -leftTail, range.y*pitch.y+ topExtra, - botExtra, FALSE];
BEGIN
xstr:		CD.Object	_ TransistorObject[size: [xstrWth, xstrLgth], difLayer: cmosNDif];
dcon:		CD.Object	_ IFUPW.Contact[cmosNDif];
pcon:		CD.Object	_ IFUPW.Contact[cmosPoly];
vcon:		CD.Object	_ IFUPW.Contact[cmosMet2];
scon:		CD.Object	_ IFUPW.Contact[cmosPWCont];
lstIONotGnd:		BOOL	_ TRUE;
lstGndClear:		BOOL	_ TRUE;
thsIONotGnd:	BOOL	_ TRUE;
thsGndClear:		BOOL	_ TRUE;
FOR ctlIndex: INT IN [0..range.y) DO
cnctBiasx:	INT	_ (cnctSize-metW)/2;
Include: PROC[object: CD.Object, location: Location] =
{[] _ PW.IncludeInCell[cell, object,	location]};
AddGndContact: PROC[updn: {up, dn}] = {IF updn=up
THEN	Include[scon, [gnd*pitch.x-cnctBiasx, (ctlIndex+1)*pitch.y - cnctSize/2 ]]
ELSE	Include[scon, [gnd*pitch.x-cnctBiasx, (ctlIndex+0)*pitch.y - cnctSize/2 ]]};
AddMux: PROC [index: Location] = {
dWL:			INT	_ (ABS[outIndex-index.x])*pitch.x+cnctSize;
pWL:			INT	_ (range.x-index.x)*pitch.x;
minX:			INT	_ MIN[outIndex,	index.x];
polX:			INT	_ MIN[outIndex,	index.x];
pol:			CD.Object	_ CDRects.CreateRect[[pWL,	 polW],	cmosPoly];
dif:			CD.Object	_ CDRects.CreateRect[[dWL,	 difW],	cmosNDif];
dir:			INT	_ IF ((index.y MOD 2)=0)=muxEvenDn THEN 1 ELSE -1;
yloc:			INT	_ index.y*pitch.y + pitch.y/2;
Include[pcon,	[range.x	*pitch.x -cnctBiasx,	yloc 					-cnctSize/2	]];
Include[vcon,	[range.x	*pitch.x +cnctSize,	yloc 					-cnctSize/2	]];
Include[pol,		[index.x	*pitch.x -cnctBiasx,	yloc 					-polW/2		]];
Include[dif,		[minX		*pitch.x -cnctBiasx,	yloc +dir*pitch.y/2	-difW/2		]];
Include[dcon,	[outIndex	*pitch.x -cnctBiasx,	yloc +dir*pitch.y/2	-cnctSize/2	]];
Include[dcon,	[index.x	*pitch.x -cnctBiasx,	yloc -dir*pitch.y/2	-cnctSize/2	]];
Include[xstr,		[index.x	*pitch.x-tranBiasx,	yloc					-xstrLgth/2   ]]};
cName:	PW.ROPE	_ Convert.RopeFromInt[ctlIndex];
size:		Size		_ [cellWidth,		met2W];
loc:		Location	_ [-leftTail,	ctlIndex*pitch.y+pitch.y/2-met2W/2];
ioIndex:	INT		_ -1;
AddRet[cell:cell, size:size, loc:loc, level:cmosMet2];
PutPin [cell, [met2W, met2W], loc,									cmosMet2,	cName];
PutPin [cell, [met2W, met2W], [cellWidth-leftTail-met2W, loc.y], cmosMet2,	cName];
IF outN#NIL
THEN {
ioItem:	PW.ROPE	_ ListIndexItem[in, ctlIndex];
IF ioItem # NIL THEN {
IF ioIndex < 0 THEN ioIndex _ ListItemIndexMax[top,	ioItem];
IF ioIndex < 0 THEN ioIndex _ ListItemIndexMax[bot,	ioItem];
IF ioIndex >=0 THEN AddMux[index: [ioIndex, ctlIndex]]};
thsIONotGnd _ ioIndex # gnd;
thsGndClear _ thsIONotGnd AND ((ioIndex<gnd)=(outIndex<gnd));
IF ((ctlIndex MOD 2)=0)=muxEvenDn
THEN	{IF thsIONotGnd	AND lstIONotGnd	THEN AddGndContact[dn]}
ELSE	{IF thsGndClear		AND lstGndClear	THEN AddGndContact[dn]};
IF (ctlIndex+1) = range.y THEN IF ((ctlIndex MOD 2)=0)=muxEvenDn
THEN	{IF thsGndClear								THEN AddGndContact[up]}
ELSE	{IF thsIONotGnd							THEN AddGndContact[up]};
lstIONotGnd _ thsIONotGnd;
lstGndClear _ thsGndClear}
ELSE AddGndContact[dn];
ENDLOOP;
END;
PW.IncludeInDirectory[design, cell];
iRect _ CD.InterestRect[cell];
IF outIndex=-1 AND bot=NIL OR ListAllNil[bot] THEN iRect.y1 _ iRect.y1 - botExtra;
iRect.y2 _ iRect.y1 + range.y*pitch.y + topExtra + botExtra;
CDCells.SetInterestRect[cell, iRect];
PW.RenameObject[design, cell, cellName];
RETURN[cell]};


IFUDecoderRow: PUBLIC PROC [
design:	CD.Design,
name:		PW.ROPE,
ctl:		List,				-- total nof names must be 2*nof significant bits
val:		REF ValArray,	--   1st ctl is MSB TRUE  eg.  bit0 bit0' bit1 bit1' ...
top:		LIST OF REF,
out:		LIST OF REF,
bot:		LIST OF REF,
rp:			RowParams		_ IFUDataColNSeq ]
RETURNS [cell: CD.Object] = {
cells: PW.ListOb;
FOR ii: INT DECREASING IN [0..rp.rngByte*rp.rngBit) DO
byte, index: INT;
[byte, index] _ ByteBitFromIndex[ii, rp];
cells _ CONS[ Decoder[
design:	design,
ctl:		ctl,
val:		val[byte][index],
top:		ExpandList[byte, index, top],
out:		ExpandList[byte, index, out],
bot:		ExpandList[byte, index, bot]  ], cells];
ENDLOOP;
cell _ PW.AbutListX[design, cells];
cell _ RenameObjAndAssignRowPins[design, cell, name];
RETURN[cell]};

Decoder: PROC [
design:	CD.Design,
top:		List,
ctl:		List,
val:		INT,
out:		List, 
bot:		List]
RETURNS [cell: CD.Object] = {ERROR -- not fixed up for variable lambda -- };


END. 
��$��IFUPWMux.mesa, 
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last Edited by Curry, January 7, 1986 9:02:12 am PST


Metal wires and their pins
ptchOset:		INT	_ (xstrLgth+difW)/2;	-- for gap between transistor and diff wire
dPtch:			CD.Object	_ CDRects.CreateRect[[xstrWth, difW],	cmosNDif];
Include[dPtch,	[index.x	*pitch.x -cnctBiasx,	yloc +dir*ptchOset	-difW/2		]];

Decoder: PROC [
design:	CD.Design,
top:		List,
ctl:		List,
val:		INT,
out:		List, 
bot:		List]
RETURNS [cell: CD.Object] = {
pitch: 		Size		= [metPitch, met2Pitch];
xtraY:			INT		= (pitch.y-polW-difW)/2;
rangeY:		INT		_ ListLength[ctl]+1;
outN:			PW.ROPE	_ IF out=NIL THEN NIL ELSE out.first;
cell			_ CDCells.CreateEmptyCell[];
top 			_ FixGVInList[top];
bot			_ FixGVInList[bot];

Metal wires and their pins
FOR i: INT IN [0..nofVWires) DO
loc:	Location	_ [i*pitch.x, 0];
tIO:	PW.ROPE	_ ListIndexItem[top,	i];
bIO:	PW.ROPE	_ ListIndexItem[bot,	i];
tY:		INT _ ListItemIndexMin[ctl,tIO]	+1;
bY:	INT _ ListItemIndexMax[ctl,bIO]	+1;
IF tIO=outN					THEN tY_0 ELSE IF tY=0 THEN tY_-1;
IF bY=0 AND bIO#outN	THEN bY_-1;
IF tY=-1 AND bY=-1 THEN tY_bY_0;
IF ~Rope.Equal[tIO, bIO] AND tY<=bY AND tIO#NIL AND bIO#NIL
THEN ERROR Error[IO.PutFR
["2 signals (%g, %g) in same channel - ABORT", IO.rope[tIO], IO.rope[bIO]]];
IF tIO#NIL	THEN AddRet[cell:cell, level: cmosMet,
size:	[metW,		(rangeY-tY)	* pitch.y	+ polW/2+met2W/2+topTail	],
loc:	[i*pitch.x,	           tY 	* pitch.y										]];
IF bIO#NIL	THEN AddRet[cell:cell, level: cmosMet,
size:	[metW,					bY	* pitch.y	+	botTail	],
loc:	[i*pitch.x,				0	* pitch.y	-	botTail	]];
ENDLOOP;
AddMetalPins
[cell, top, bot, -leftTail, rangeY*pitch.y+polW/2+met2W/2+topTail, -botTail, TRUE];
All the rest
BEGIN
Put: PROC[obj: CD.Object, location: Location] =
{[] _ PW.IncludeInCell[cell, obj, location]};
colGND:	INT = (nofVWires-2)	*pitch.x;
colLt:		INT = colGND	+2		*pitch.x;
colPCnt:	INT = colLt		+1		*pitch.x;
colRt:		INT = colPCnt 	+2*(4+5+3);
colVDD:	INT = colRt		+1		*pitch.x;
colWCnt:	INT = colVDD	+1		*pitch.x;
currIsXstr, lastIsXstr: BOOL _ FALSE;
nXstr:		CD.Object	_ TransistorObject[size: [32,4], difLayer: cmosNDif];
pXstr:		CD.Object	_ TransistorObject[size: [32,4], difLayer: cmosPDif];
nCtct:		CD.Object	_ CDSimpleRules.Contact[cmosMet, cmosNDif];
pCtct:		CD.Object	_ CDSimpleRules.Contact[cmosMet, cmosPDif];
wCtct:		CD.Object	_ CDSimpleRules.Contact[cmosMet, cmosWNDif];
polCtct:	CD.Object	_ CDSimpleRules.Contact[cmosMet, cmosPoly];
viaCtct:	CD.Object	_ CDSimpleRules.Contact[cmosMet, cmosMet2];
pol:		CD.Object	_ CDRects.CreateRect[[colRt-colLt, 	4],	cmosPoly];
nDif:		CD.Object	_ CDRects.CreateRect[[32, 				4],	cmosNDif];
pDif:		CD.Object	_ CDRects.CreateRect[[22, 				4],	cmosPDif];
met:		CD.Object	_ CDRects.CreateRect[[8,		 pitch.y],	cmosMet];
AddRet[cell, [8,					(rangeY-1)*pitch.y-2],		[colRt,	-2],	cmosMet];
AddRet[cell, [1*pitch.x+8,		(rangeY-0)*pitch.y],		[colVDD, -3],	cmosMet];
AddRet[cell, [2*pitch.x+8+10,	(rangeY+0)*pitch.y+10],	[colRt-10, -3],	cmosNWell];

Out poly wire
IF outN#NIL THEN {
ioIndex: INT _ -1;
IF ioIndex < 0 THEN ioIndex _ ListItemIndexMin[top,	outN];
IF ioIndex < 0 THEN ioIndex _ ListItemIndexMin[bot,	outN];
IF ioIndex >= 0 THEN {
loc:	Location	_ [ioIndex*pitch.x,	0 ];
AddRet[cell:cell, size:[colRt-loc.x,	polW], loc:loc, level:cmosPoly];
Put[polCtct, [loc.x,	loc.y-2 ]] } };

FOR ctlIndex: INT IN [0..rangeY] DO
ycen: INT _ ctlIndex*pitch.y+polW/2;
ylow: INT _ ctlIndex*pitch.y-xtraY-difW;
cName: PW.ROPE _ SELECT ctlIndex FROM
0			=> VDD,
rangeY	=> GND,
ENDCASE	=> ListIndexItem[ctl, ctlIndex-1];
ioIndex:	INT		_ -1;
size:		Size		_ [cellWidth,	met2W];
loc:		Location	_ [-leftTail,		ctlIndex*pitch.y+polW/2-met2W/2];
AddRet[cell:cell, size:size, loc:loc, level:cmosMet2];
PutPin [cell, [met2W, met2W], loc,										cmosMet2, cName];
PutPin [cell, [met2W, met2W], [cellWidth-leftTail-met2W, loc.y],	cmosMet2, cName];
IF cName = NIL THEN LOOP;
IF ioIndex < 0	THEN ioIndex _ ListItemIndexMin[top,	cName];
IF ioIndex < 0	THEN ioIndex _ ListItemIndexMin[bot,	cName];
IF ioIndex >= 0	THEN Put[viaCtct, [ioIndex*pitch.x-2, loc.y-1]];

SELECT ctlIndex FROM
0			=> {
AddRet[cell:cell, size:[8,6], loc:[colLt, ycen], level:cmosMet];
AddRet[cell:cell, size:[8,6], loc:[colRt, ycen], level:cmosMet];
Put[polCtct,		[colLt,				ycen	-	8/2			]];
Put[polCtct,		[colRt,				ycen	-	8/2			]];
Put[viaCtct, 		[colVDD,				ycen	-	10/2			]];
LOOP};
rangeY	=> {
Put[viaCtct, 		[colLt-1,				ycen	-	10/2			]];
Put[wCtct,		[colWCnt,			ylow						]];
IF lastIsXstr
THEN	Put[nCtct,  [colLt,			 ylow						 ]]
ELSE	Put[met,	  [colLt,			 ylow						 ]];
LOOP};
ENDCASE;
currIsXstr _ PW.XthBitOfN[(rangeY-1-ctlIndex)/2, val];
IF (ctlIndex MOD 2) = 0 THEN currIsXstr _ NOT currIsXstr;
IF NOT currIsXstr
THEN {
Put[met,			[colLt,		ylow						]];
Put[wCtct,		[colWCnt,	ylow						]];
IF lastIsXstr THEN
Put[nCtct,	 [colLt,		 ylow						 ]] }
ELSE	{
Put[pol,			[colLt,		ycen	- polW/2	]];
Put[polCtct,		[colPCnt,		ycen	-	8/2			]];
Put[viaCtct, 		[colPCnt+8,	ycen	-	10/2			]];
Put[nDif,			[colGND+4,	ycen	- pitch.y/2		]];
Put[nDif,			[colGND+4,	ycen	+ pitch.y/2-4	]];
Put[nXstr,		[colGND,		ycen	- 6				]];
IF NOT lastIsXstr THEN
Put[nCtct,	 [colLt,		 ylow						 ]];
Put[pDif,			[colRt,		ycen	- pitch.y/2		]];
Put[pDif,			[colRt,		ycen	+ pitch.y/2-4	]];
Put[pXstr,		[colRt-4,		ycen	- 6				]];
Put[wCtct,		[colWCnt,	ylow						]];
IF (ctlIndex MOD 2) =1
THEN {
Put[pCtct,	[colRt,		ylow	+ pitch.y		]];
Put[pCtct,	[colVDD,		ylow					]] }
ELSE {
Put[pCtct,	[colRt,		ylow					]];
Put[pCtct,	[colVDD,		ylow	+ pitch.y		]] };
};
lastIsXstr _ currIsXstr;
ENDLOOP;
END;
PW.IncludeInDirectory[design, cell];
RETURN[cell]};
DecoderTest: IFUPW.UserProc = { RETURN[ Decoder[
design: 	design,
top:		LIST["A1", "A0", NIL],
ctl:		LIST["A0", "A0'", "A1", "A1'", "A2", "A2'", "A3", "A3'", "A4", "A4'", "A5", "A5'"],
val:		33,
out:		LIST["Out"], 
bot:		LIST["A1", NIL, "Out" ] ] ] };
MuxTest: IFUPW.UserProc = { RETURN[ Mux[
design: 	design,
top:		LIST["XB", "Alpha", "Beta", "Pass", NIL, "In1"],
ctl:		LIST["RdXBus",	"Hold", 	"Clear",	"Set",	"Set1", "Set2"],
in:			LIST["XB",		"Alpha", 	GND,		VDD,	"In1", "In2"],
out:		LIST["Out2"],
bot:		LIST["XB", "Alpha", "Beta", "Pass", "Out2",  NIL, GND, VDD, "In2"] ] ]};
MuxTest: IFUPW.UserProc = { RETURN[ Mux[
design: 	design,
top:		LIST["XBus.37", NIL, NIL, NIL, NIL, NIL, "GND", "VDD", NIL, NIL, NIL, NIL, NIL],
ctl:		LIST["ARtOSetB", "ARtAlpB", "ARtAlp03B", "ARtAlp47B",
"ARtOp47B", "ARtBetB", "ARtBet03B", "ARtBet47B",
"BRtOSetB", "BRtAlpB", "BRtAlp03B", "BRtAlp47B",
"BRtOp47B", "BRtBetB", "BRtBet03B", "BRtBet47B",
"CRtOSetB", "CRtAlpB", "CRtAlp03B", "CRtAlp47B",
"CRtOp47B", "CRtBetB", "CRtBet03B", "CRtBet47B"],
in:			LIST[NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL],
out:		LIST[NIL],
bot:		LIST["XBus.37", NIL, NIL] ] ]};


PW.Register[DecoderTest,			"DecoderTest"];
PW.Register[MuxTest,				"MuxTest"];

ÊC��˜�š
œ™Jš
œ<™<Jš
œ4™4—J™�šÏk	œ
˜
Jš
œ˜Jšœ
˜Jšœœ$˜1Jš
œ˜Jšœœ˜Jš
œ˜Jšœ
˜Jšœ
˜Jšœ˜Jš
œ˜—J˜�J˜�šœ
œ
˜š
˜Jšœ*œœœ˜?—Jšœ
œ˜Jšœ
œ
œ
˜J˜�J˜
JšœœÏc ˜.J™�šÏn	œœ
œ˜Jšœœ˜Jšœœ
œ
˜Jšœœ
˜Jšœœ
˜Jšœœ
œ
œ
˜Jšœœ
œ
œ
˜Jšœœ
œ
œ
˜Jšœœ
œ
œ
˜š
œ"˜"Jšœœ˜—Jšœœ˜Jšœœ˜0š	œœ

œ
œ˜6Jšœ
œ
˜Jšœœ˜/šœœ˜Jš
œ˜Jš
œ
˜
Jš
œ"˜"Jš
œ#˜#Jš
œ#˜#Jš
œ-˜-—Jšœ
˜—Jšœœ˜#šœœ˜&Jšœœ#˜=—Jšœ˜J˜�—šŸœœ˜Jšœœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜š
œ˜Jšœœ˜—Jšœœ
œ
˜Jšœœ
˜Jšœ
œ˜Jšœœ˜$Jšœ	œ˜"Jšœœ˜Jšœœ˜'Jšœœ˜'Jš
œ'˜'Jšœœœ
˜Jšœœœ
˜Jš
œ˜Jšœœ
œœœ
œ
œ
œ˜5Jšœ	œ˜Jšœœ
˜Jš
œ˜Jš
œ˜Jšœ
œ4˜AJš
œ(˜(Jš
œ*˜*šœ)˜-Jšœ+˜-šœœœ˜:Jšœ
œœ+œ˜N——Jšœœ˜-Jš
œ4˜4Jš
œ4˜4Jšœœ
œ˜Jš
œ˜Jš
œ™Jš
œ!˜!šœœ
œ œ˜Qšœ
œœ˜JšœAœ˜Q——šœœ
œœ
œœ˜GJšœ5œ˜E—šœœ
œ˜Jš
œ˜Jšœœ
œ˜%Jšœœ
œ˜%Jšœœ˜$Jšœœ˜$Jš	œœœœœ˜OJš	œœœœœ˜NJš	œœœœœ˜?Jš	œœœœœ˜?Jšœœœ	˜ šœœœœ
œ˜;šœ
œœ˜Jšœ/œœ
˜L——šœœ
œ"˜1Jš
œ1˜1Jš
œ7˜7—šœœ
œ"˜1Jš
œ*˜*Jš
œ/˜/—Jšœ
˜—šœ
œ
œœ#˜DJš
œ7˜7Jšœ3œ
˜;—š
œ˜JšœCœ˜J—Jš
˜JšœœJ˜SJšœœ
œ˜+Jšœœ
œ˜+Jšœœ
œ˜+Jšœœ
œ˜-Jšœœœ
˜Jšœœœ
˜Jšœ
œœ
˜Jšœœœ
˜šœœ
œ˜$Jšœœ˜#šŸœœ	œ˜6Jšœœ(˜0—šŸ
œœœ˜1JšœK˜OJšœM˜Q—šŸœœ˜"Jšœœž+™OJšœœœ%˜6Jšœœ˜'Jšœœœ˜%Jšœœœ˜%Jšœœ5˜>Jšœœ5˜>Jšœ	œ8™CJšœœœœœœ˜=Jšœœ˜*Jš
œE˜EJš
œD˜DJš
œB˜BJš
œJ˜JJš
œL™LJš
œP˜PJš
œO˜OJš
œG˜G—Jšœœ
œ!˜/Jš
œ#˜#Jš
œA˜AJšœ	œ˜Jš
œ6˜6Jš
œ<˜<Jš
œR˜Ršœ˜šœ˜Jšœœ
œ˜.šœ
œ
œ˜Jšœ
œ)˜<Jšœ
œ)˜<Jšœ
œ
Ïbœ˜8—Jš
œ˜Jšœœ ˜=šœœ˜!Jšœœ
œ
œ˜<Jšœ
œœ
œ˜>—šœœ
œœ˜@Jšœœœ˜3Jšœ
œœ˜3—Jš
œ˜Jš
œ˜—Jšœ˜—Jšœ
˜Jšœ
˜—Jšœ"˜$Jšœœ˜Jš
œ
œœ
œœ ˜RJš
œ<˜<Jš
œ%˜%Jšœ&˜(Jšœ˜—J˜�J˜�šŸ
œœ
œ˜Jšœœ˜Jšœœ
œ
˜Jšœž1˜@Jšœœž8˜LJšœœ
œ
œ
˜Jšœœ
œ
œ
˜Jšœœ
œ
œ
˜š
œ#˜#Jšœœ˜—Jšœœ˜š	œœ

œ
œ˜6Jšœ
œ
˜Jš
œ)˜)šœœ
˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ#˜#Jš
œ#˜#Jš
œ.˜.—Jšœ
˜—Jšœœ˜#Jš
œ5˜5Jšœ˜J˜�—šŸœœ˜Jšœœ˜Jš
œ˜Jš
œ˜Jšœœ
˜
Jš
œ˜š
œ˜Jšœœœ
ž&œ˜L——J™�šŸœœ™Jšœœ™Jš
œ™Jš
œ™Jšœœ
™
Jš
œ™š
œ™Jšœœ™—Jš
œ'™'Jšœ	œ™&Jšœ	œ™"Jšœœ
œœœ
œ
œ
œ™5Jš
œ#™#Jš
œ™Jš
œ™J™�Jš
œ™šœœ
œ™Jš
œ™Jšœœ
œ™%Jšœœ
œ™%Jšœœ ™(Jšœœ ™'Jš
œœœ
œœ™2Jšœœ
œ™ Jšœœœ	™ šœœœœ
œ™;šœ
œœ™Jšœ/œœ
™L——šœœ
œ"™1Jš
œ?™?Jš
œ6™6—šœœ
œ"™1Jš
œ*™*Jš
œ-™-—Jšœ
™—š
œ™JšœMœ™S—Jš
œ™š
™šŸœœœ™/Jšœœ%™-—Jšœœ™%Jšœœ™"Jšœ	œ™#Jšœœ™"Jšœœ™"Jšœ	œ™#Jšœœœ
™%Jšœœ=™GJšœœ=™GJšœœ3™=Jšœœ3™=Jšœœ4™>Jšœ	œ3™>Jšœ	œ3™>Jšœœ:™BJšœœ4™=Jšœœ4™=Jšœœ6™>Jš
œC™CJš
œI™IJš
œQ™QJ™�Jš
œ
™
šœœ
œ™Jšœ	œ™Jšœ
œ'™:Jšœ
œ'™:šœœ™Jš
œ&™&Jš
œE™EJš
œ$™$——J™�šœœ
œ
™#Jšœœ™$Jšœœ™(šœœ
œœ
™%Jšœœ
™Jšœ
œ
™Jšœ#™*—Jšœ	œ™Jš
œ"™"Jš
œ?™?Jš
œ6™6Jš
œ=™=Jš
œR™RJšœ	œ
œ
œ
™Jšœ
œ(™;Jšœ
œ(™;Jšœœ,™@J™�šœ
™š
œ™Jš
œ@™@Jš
œ@™@Jš
œ)™)Jš
œ)™)Jš
œ,™,Jšœ™—š
œ™Jš
œ-™-Jš
œ%™%šœ™
Jšœ%™)Jšœ%™)—Jšœ™—Jšœ
™—Jšœ
œ'™6Jšœœœœ™9šœ
œ™šœ™Jš
œ!™!Jš
œ#™#šœ™Jš
œ%™%——šœ™Jš
œ%™%Jš
œ)™)Jš
œ,™,Jš
œ,™,Jš
œ-™-Jš
œ%™%šœ
œ™Jš
œ$™$—Jš
œ*™*Jš
œ+™+Jš
œ&™&Jš
œ#™#šœœ™šœ™Jš
œ'™'Jš
œ"™"—šœ™Jš
œ ™ Jš
œ*™*——Jš
œ™——Jš
œ™Jšœ
™—Jšœ
™—Jšœ"™$Jšœ™—J˜�š
œ0™0J™Jš
œ™Jš
œY™YJš
œ	™	Jš
œ™Jš
œ$™$—š
œ(™(J™Jš
œ6™6Jš
œ>™>Jš
œ5™5Jš
œ™Jš
œN™N—š
œ(™(J™Jš
œV™Vš
œ;™;Jš
œ0™0—š
œ0™0Jš
œ0™0—š
œ0™0Jš
œ1™1—Jš
œƒ
™ƒ
Jš
œ™Jš
œ%™%—J™�J™�Jš
œ*™*Jš
œ#™#J˜�Jšœ˜—J™�—�…—����ª��L��