d,"Nb ZB3\LOb^DTvRZ}Y~WpO5|w=HQFVowkDZ@-
WIN+(D%Px[q=
VpVY{BF|7 /WcN(D3POtQ	TxVo{hUS)Tu;RT*PV[ 70TUoQjJ,kM+TpB(/PV_~ 0VpVzEVpP:WIN+(X PmaJ(
,sVzEx^~,WX`)rROu=H+* xVDPDJ+'TrSH)Pmuk/W( VWcp[p~%UN,=~4PxCoQQ/^VE}mx~ Wu^6VPUiTxVY]oDZB(Tc|=fPUiS(:(_Vz]IxZ/{WXd=f7PnOOS( MV `}VPUN,>XKPn_S(:HUWYKmtRk!QWN-(@#PO (UP/
~VE}DFTM)UN,-TPVS@.\W0UAUxXBWW*SH)Px(
+/_U}sW}VPWB(QbPDOrPWH~Vz]yxZS1WuFWSH)Pe(S9
WTMunZNhMUN#b'5^NOdQ'W r  ~rJgz'I2zbI5Aa[A0Q@qUB^QRP}1	\VUT{Wz_+$^4BSUa@d1B}v^JGbPASY\+Ge
CgZAY]} \R1[bPavSO4JF4^ygU{R;P#v^NZO\{e^[H4|yQCAdZG:L`0UOP AaSG_HH	ycqA{V.D}1v^)CfWQa]+4	ZHtCc@ZQV$CG\V[bRAeAO0\^p]V[QY]}'^[X,AaG4N[,yQUGY]}VvRGOf{_Y0QC4VCUrU{`T^1	LYX+P
QW[] \H
[
S X{R([G#
\^F+bPQS^D'YH
}CcAQ`VP}5WvV$\OX
QyySQ'W r  ~rJgz'I2zbI5^ANW W]Q'TX
opU\}]Z]2	ps[-WT^Q+^)LY}^SG}wYCcD-KnH[QTC^FT_A c \i}LU]P\:'[GFTADACP"	pE[=F@RS-*]~P"3~ubw
gX2S@Q \p xW"Nb+"WYw[nZN /WuPxGS' QVW^U|'Wc^Q=-PmaU=UZVYAbxdRBTVt"b'5^NOdQ'W r  ~rJgz'I2zbI5ASw]O44_H4dUkZQZPC1;vZ#YO\A}yZ+!DQScTDQ`T_W5T
LYX+b]
{S[]O0\],H	yY|DQZNY1+vdWZ\Q}yZ0Q'W r  ~rJgz'I2zbI5^ANW W]Q'T\|NT_xZ~IpMDQ_DNB-
DV^}FND}I
B{U[Z-	~TX=D*+\|T@nXQpYU_}TDPZ*LX|V_[g]y"rsB(e} xW"Nb+"3uOb^KgX}YQ \)wd,"NQ_VTlUS)W[tQrPG}Q1:0TMu -PP8T`t"TVPG} P *HfWwhnZQk!6UN rSUy] 7TxVz]smVyMRWu^
=ROu0UVTw@+~TWuF&SH&P[_j=,\HGUWcEV~%UN#r 5wOdb	C r  QpY{'I2qvJb'5^NOd*[HSYYDAdJ[
v`YU+bRAeE*CFS X{ZNZ};`J[+f#SY\+&]H[	S X{dYL^SUPAe^4F,4Byg@QZX'\`)GP Q ^+*[H4dci_`U^G1(\V-[b]SE4_H	yQbDQ`W_G1Z\bP{S[B+'YHHCy\{d.B1-`.GO\{_OS
UdCg]{Y]}+	\V]OfQ_MD+
Z0
]_Q`UFG1	v`Y+\Q}yZ0Q'W r  ~rJgz'I2zbI5^ANW W]Q'TYlH]Y{KY@=_	}VY7\*^YVVX[E\x	sA
G-u
xLNB-GYFFWDVEAPVcX[[TSA-GVCNSGQA6
M_-
VNB-GYFFW@E]GPAU_}DT^D*[	YBTY~E\xVc
G-
xSA7GVYTZU\Uk\k[gD-KnH[QTZ)LXpV_[gAP[AXRy[TSA-GYFFV_[g^kpMX-S}TVY7
F'^FTXw]@prY~WpO5|wd'Zb	B3\CNQpYTvRZ.
vJb,pOPU^, UoVlMWDJ k,TcSH)SxqPU'W zVYwV p1'TrQ(@#PmS_=H	(HQTMuDVhTW[tXPxCy(,H`UzcZ[Z0kUN,=fSn_>  /Q{VE}mBk Tu8H.PDOr=4:QcVzvB$S5W`FbP[OzS(9 gVzAoxFy!WdW(rP[ehS(9 zUlQx8B(W[(bPG}>N:4OTMuU`SPPTu8/P&PmG_(PUQV rtV~ZTX|&\P[GT>$.*
FVGJDVx%W``VQ@!PVG^/HW v3uOb^KgX}YQ \)wd,"Nb ZB3\LObA`UP};\V.X+f{_\O44XH	yQ[{`W]G1Zv`U@bRAyySQ'W r  ~rJgz'I2zbI5^ANW W]Q'TYlH]
B{	VUXSu}rU][W^oU\m_B
`GQ_TVY7U3[G`TFk
Ah	KEY>[
[bSA(@+YVCwA{ U>a~DQS.U*T^o^WD]
BksE
GC~QS.S]~P"3~ubw
gX2S@Q \p xW"Nb+"VTwhF]))WX`)Q@!S=$1TTWYw[xZ/BWXrSPx_=H:HUWYKmd(5TrX6PxCK/HVVpUoRxB~TWct9SHQ[u\d'Zb	B3\CNQpYTvRZ.
vJb,pO5wOdb4AYR\AV^W1	vdUU+TQ ^+4G0SU[[Q`WZ5TLdV^XK{WaFO
B,
CCQYZ{Y]};`UU~%AWmBO4S\,,t	QYZ{`UP}5TdWG\{e\<@H4SCU[@{`U^G1$vV8@Of[@B+4XH
oCQ@AY]}MvV[T1Q_V\45A,4tCUa@RGW5T
L`)]+bPAaSDO4F,H	ygZARC}1	LR Z+P=a@+
\GH0C X{`UP}1VL`Y+f[RZ0RXQSUA]QZPWM
R Z+fQ{_AO0SGH	y]_Q`WZ5TLV8@OXQ ZO[H0Cg@{V _}RL`
F+f7{SHBOU,4tCgXQd%];V;@\%AeA4FTy X{`X_G;`(A+fR	QWaFO0RU,0 
ygGAd3XGMZC@Q \p xW"Nb+"3uOb^KgX}YQ nH[QT^/TYpTA}F"pMDQ_		TT^S	CY}^HBDQByUHgD_	~TF>L]VTX	}lUXk^kpM@>
W@'GZRTXFEA{cs
G-G	UnNB-GVZGBSGxA[@"s]_Q
[bWS-+\LCNT\nwGBr_/DbWFR;_7ZZSGAPh6	pU
GQS\UY/LZW/[Y`ND}IEhI ^iEU]G^BHBDQByU	pE_eFDNB-_7^YVSGQ\]]CK}LWBQ	\*^}`SGA[~>UXSu
[bTD/DCNWDYY{u_/USA/	G7ZTBSGFAA{	Ic^(W}rTD3D*^V\kPh6	s
G=[FDRS-*]~P"3~ubw
gX2S@Q \p xW"Nb+"VW^U|~WH1(XPxGP(P0V g[`1 /Wu^ @/P[C(Q5:HUWYKmt5 VVt=PSU[KS(/HoVzEZDZ~#WuZ((@RRO^
7 zVzYqxF.BTWK|	/T&SxpS' Q3uOb^KgX}YQ \)wd,"Nb ZB3\LObAd1B}v`)YXKW\D0\X0	CQYZ{ZC} 	Y_z%{aaBOH]X,4syUa@^)]W\dWGT.Q ^+0\],4}CU\BQY]}+	\^R\Ob]
{_MGH]Uzyc[C{ZNZ}\dU[X4{ ^+0\],4s
ycpGARGW5VvdU[O\Q}yZ0Q'W r  ~rJgz'I2zbI5^ANW W]Q'TYlH][S>H _e
FXVS	B/7CNTD c_VEXQymPUS/D*ETUAD]Z]2
ByFDV]U*T^o^TXPUc]Q}WF7
@WCNTBUG~2VcU-		xTAU*L^DFV[U]
BE\/K}DT\	
BW+ZRWDY
B{"[QY-a PHDPU**/ub|rJgq_2SObFp W W]~P"3~uxVT#W`U\Px_y(4V/gVo]OxB&kT-WXd1="PG}> *9Q\TMuUS)Tu8zPmj>TxVoU^P%TrQ=v0ROY  /HoVGMPDZ]0WIx'(Px_/rTMuxZ/~M*WV^3=PD_NH4:VzExZ])WKx7SH)PO^Q/QVVz]B$~M;WI^(Sm}R=/
DVoc}VJ  VVtb'5^NOdQ'W r  ~rJgz'I2zbI5AaLZO\bS{yXAR%\W)#R Z+\& Y($\,
tSciF{`V[G5UvY\Oz%`ANW W]Q'W/ub|rJgq_2SObFp W T	XT	EWNVUF]P@ucU>a~DQS.G:Y
oW@gA{"VU[FbNB-D'Y	 FW@U
B]
EFSy
[bT@R;D9^DFTYnYA{sBP_DPSA-P_(LYY^TBEkAh6pM
D=S	TB>3^TX
||SGnDC.r]Z-}LW@'G^ lTY}^kUXu}LTD/\Z`TD}wB]I@em@WFS
ZUY|V_[gC>	cM
GCn\VY7
@VPCNHUEc
Bk	 \Qu
 U\-LG:^FU\UkE2	XsA(y	[DHS3G:	[^TZVc]h>	`[G}rSAD*X
YFU[mwY{Vc[FfTB>/G/Z FTF{A{US[@TFTG*^lU_G]*XcD-KmTUY/L	[(^DFSG} 
AxY
G=[	fNB-@V7YYxV^xkGsA(y~DWFS7D*XG|U\}]^x.	M_eULU_PD*Y	 WU A	`][.uDT_.D)L_U^xBBp@[n\SA>LD)Z`UAE{Y{s
GRK
[bTD/	[X}UX}{A{	sE[.uDT_.D)LY FUU~kYycF>Gm@T]=PD*^VSGIB	VU
Du\TD.G/EDND}I
Akr[.uDSAR;	Y*TXSGA
B@USa\T]L	[3[zSG}AEPQ	rEY-}LWBQ_(L^DFSGmEB~oD-K~DWFS
DV^FBSGFAA{u]
GQSLSA/7	XU;YZSDUwYS>cAy	}XSAP'G:	YoTB}g]r]CFWS-	FT/CNSDmQZyIY
GTSAR\;Z`ND}I
B~H]@_}rSASP	[LY
DdVG]
B	MD-KEXSAQGUXZSGA]I	o@a	ULW\R	FT+X
|pVG]Z]2uE
D.C}LU].
U*;Z`U_]k I]X=WmLVY7	\Z|FV\cA{	U
GRK fH\P_7XdUAk
Ax	pY-K}LSAQGU^|FWB ]AB 	Xs@>
TB	G*Z ND}IA]	sEU>CFDNB-
DVXzRSG}EEy.	XsYKTSAR[93^G`HUncE@sgD[~DNB-
DV^}FSGnEB r[.yLSA.	@[Y`SG}wP@CKPNB-[)+^ NSG}wX@"us
G-uD@TG-LGCNTYAPx>H 
G-FfHS>3_7CNTD}wCP VU[FbVZ.L_7X}SG} Z[{_eFDWFSG*'Y}RT]}QA{Y
G/Cx~UY/LGZZV_[gYS>Is
GS}zQS.S]~P"3~ubw
gX2S@Q \p xW"Nb+"VW^U|kMWWIN/SH)S}SI/HlVF]NE4~.W`U\SWz(
+/OVTqU` h1)UN#2PC^=HQFVW
U` PRWdRTPG}S5xVluxZW~TWXd$(@(PG}P,cTMuR#CM7Wu^*SUy](H?/
DVo]\mVW{$W[F0Q@!PDWO(S(wVWcxZ*PP+WXd SH)PmH UQIVVWF$XPF}P/H(ULTMuxZ*C
W[^>PDu]UV0U}Qm'WuF-~"S}SI/HlVDPxp~5UN,(>PEOP/HdVxB&~5Tu;(\-SmSv/'VpVzEt[|' /Tu;RT*PCh(
CVoYvxBW{WuF&bPVuj(/VYYvV9kWF$SH)PUW{U(UEVW^U|{W[RPr+PDq P 5T0\VYsi[p7y WuB8=TRPx_yQ4/_VzAx^-h%-WVZ/T'PV `S(:HUWYKm9 /WNQ@!PD_N(
: VT`xZ ~	WF$H(Pmt P &b ZB3\LOb^DTvRZ}Y~WpO5|wd'Zb	B3CcL\^YG'VNU+T{_NZ
J_,LS]NF{d)BG\YX+f4{[HF+YQy]NF{^#\MZL| \+b]
{a~]+4,CH
BCUqYQY]}+	\V[T
QaSOZ,H	yUqYQ`VE}1LV9XOP{__4C, Ccv^ZNZWI\`1@OX Q_US45Y4MSgU{`WZ5Vv^DO\{WrS+0RB4tg]{dW_G1)`F+T{eZ+XH	yckX{ZNZW5TdWGPWeE
 G,r X{d5^}16vYUb]
{WmB4JUH0C X{R(\W\Z#YOPQe FO,F~
C]_QZJBW
vV(DObRaS4G0yQ_Q`XX}5T
LYX+P-QeF+4A@gXQ^	AG1MvdX]+bQ_USD4	yUZGQ`YE+LYX+P.{eD,Y0yU\BQZNZWI\`1Yf	QSY\+R\4CSgXQR8E+`A+bRWoA]0C X{`XX}7L`NUO\Q}yZ0Q'W r  ~rJgz'I2zbI5^ANW W]Q'TYlH]P@KYB(e}LTD/\XZTXYFSKU^P	UnU]/
DVZDZV_[g^~I	HQD-K[zUZA+XZU_]Y{po\/[}HZ/	ZTX
oBV_[gEUpMZRC~USS3UTP^WB[{P6pM_Se	EnUX(T[:[FRSG[QA{	pDPW\HE	@Y
zpTGDkPh	s
G=[
	~U\-L	Y/C| ~rJgz'I2zbI5^ANW W]Q'W/ub|rJ.W`^SUy]Q7W zVY{j p1'WNY=f.ROu=HQFVo`E+]52WF$@/P[[t(
$$~UoslJ ]%WXT(X*SxaS(QSUW{]J,~,WI^X6Px_v-((HTMuxMT`p5SH)Sxb(UUmVF]N[Z3~WXST4PG}SHrTMunJ@-
WIN+PVOh$:ZVzYtm^/ /WV^3(X*PmN(	W zVzY@ p1yPWF$SH&Q[u\d'Zb	B3\CNQpYTvRZ.
vJb,pO5wOdb4AYR\AZNYG1M\V3ZP.[z_OH]_(tyUa@R(\W*L`RAbPQaTBH]X,4l X{d1B}v`(COP1Aa[E+4JUH0
C X{R(\W1	L^NZOfQaT\O0SZ0yQ{GQYPW1\dWZ\{[{[O0S_H0CcOAQV[;x XP1aZ+,$XHTycSBd
C}
v^\\{Wq_$X0 
ygU{`UFG&\dUXX{_N\H]\H(tbCNQpYTvRZ.
vJb,pO5wOdb	C r  Qp]XM_(xSA-'@)+EldND~APxHg
GG
~UF3_7Y}RTBxgA{p 
G=[WSSP
DX|dV_[g_XoD-KXSA	GY
FT@FgABQFSW	mzNB-	B/XFNSDUwEhI Y=SDTG-L	\[Y`VB {
B@Kc
D.C}LSAQGUY|xU_PCI`Z([}LSB=_(LZZVB  E@2	sED-KTSAR
ULYFFSG} 
Ax
EXu
[bNB-GV^ NTD c_poB>CXUF/+
B+Z`U[~w^BIpM
GQSLT^=UY
FT[FcPUH_e}LSB=_(LYYxU\DID{XoDQ_DUY.L_:;Zl`WFnE^x"	VU
GSSPSA_7ZND}IAu_/TSAR	@3X
WNWZAC.uGR_
[bTDP\/^|FND}I
AkrB}	DLT\SG[DpUD}A{csU.i
FrTZ/	D*^YVT[D^@6pU\ix~UZ-G[ VND}I^k"	o
GQSLWBQG^DFWU}{P{Q[]U-\V^(TD*^WpV\}EPC6	IAGeV@SAD*YzT_xA{
X]UR[	HEQ		@	YlpTD~\pU.\)wd,"Nb ZB3\LOb^DTvRZ}Y~WpO5|wQ,PVlw|xB&~#WVx*=v0ROY  /bVzAKVt'5PWKdJ-TPVS@Q :0VWcBx8kM!W`F@#PmG^UUTwWYw\bw
gX2S@Q \p xW"Nb+"3uOb^KgG-#v`XYOT!Ae\H]X,
SU_FZNZ12V4GO\{[yS+45@H4@
y X{d_G\V[fQaS\+0SZH	yg^A`VE}1	`1@ObSQ_N@+0R[4^SQ_Q`W_G5[vZ]f{WB
-C4Sc}DdDMv`)GfPQ ^+4ZQSUA]QdAW1	
vYX+bS	AeF+F,lch@`VGW1
R Z+bP{aG0SX,4}y X{d8A1;YX+XKQaOG<@H`cM]A`W_GMZvdUXP1A_\O0QU,vSU[GA`YZGMZvdUXT2Qe]O0QU,vSUs[AR_}MZ\| \0Fp W W]~P"3~ubw
gX2S@Q \pTF>L]VT[FRU_G.U[(u[TSAP'G:	Y	 BTUnA[~IH{
GS}LTY(L	_/LCNU\DI_~VY@a}LSAQ	XW	XdWFVU]XM[.C	mWFS7\)LXWdSDnI
B~Vc_/}~T_(7	ZU'^}FND}I
B DQ_HXRTU**/ub|rJgq_2SObFp W W]~P"3~umUSWN3=v0ROY  /QRUzbmV~W``$HROu= 6
CVTqDJW!SUN,(XOPx_y=H+/
TMuDJ+k,T`t4SH)P[_j=H
CVYixB&~WF$~PFynS(/bVzAKU^~)W[t\0Pe	/HToVz_J,~% W=v0Px_Q0T(HQVz]yFQ~,T`t SH&Q[u\d'Zb	B3\CNQpYTvRZ.
vJb,pO5wOdb4AYR\AR%DSZ"]OP<A_pE4VA0yQZF{dF}(	R4FXQ ^+&GvScSF{^#\MZL| \+f< ^+,YAcTDQdF}(	R4FXQ S($\7C r  QpY{'I2qvJb'5^NOdQ'W rQU~I_~	p 
GQSLTG(+UT3YFW@E]^x.`Q
D/ufUXR	GC|SDUwY{pMY-UzVY7	G(P^oT@[]]B*
X]_/TSARY)TYFFV_[gA{pY
G-u	m@T_RD*+\| ~rJgz'I2zbI5^ANW W]Q'W/ub|rJSTTXx@PO :UTMuD5PTpt#>rTPx_r(SLVAhmZ&P#WI>5PxGS(VyVFTx^BWIN+z!SxutQ ,OVWgYF5~	WuF(@RROu
/Q{VE}U+]P1WNQ@!PV q(
+90oTMuJ-BTTpRTSxb=/
DVoc}VJ~M;WNQ@!PD_N/{Vl{UJ#gq_2SObFp W W]~P"3~ubw
gX2L`1G+\{Wt^)X4AYR\AV _}!\^&U+\& Y($\,4Q{GQdYG1V\YX+f#_iB0SZvg_^Z}1v`Y+f\ahFOSGHqC UQx Yf}YQ \)wd,"Nb ZB3\LOb^DTvRZ} @>
VSUYz`ND}IA]"r
G-CVrT^D*[BV\mwCP"r][=UzVY7	XT	EWNWU IAP.pM@>
TBSPZ/XdWFVUA{]CKXU]QG9L[FRU_[~IH{U>C	nNB-GVY	 FU_]"
E
G/C	fUGQ;D*YH\UZ]2	VAUPiU\HSR	_(LZ|TYxg
B	M@K	~rVY7D*ZY|SG} ZyIpY(eTSAR	YXDpU[~YZIVcY>[nSA-PZLCNWU}I]XMZRC~T_U3Y pSGA
B~HBPy PT\R'@(+CNUUnwPx>	UDQ
	xnWFQPUTP^SD~A^h6	rQD-K[~WFS7	ZT^YVSG w
BkKsD-nWBQ	\)L[Y`SG} _P6	U_e[@USP;D*ZZSGnEB rDQGUX(D*EpTXE]	rQD-K\HE	[/'YFlU_["gU-KxDNB-
DV	X}U\}]_{IpMU>CUzNB.[]~P"3~ubw
gX2S@Q \p xW"Nb+"VoU^kT:UN,(PxCKUWeVo]OVB7BTWKZ6=<Sxb(UPVzAyx^(5WVd1SHPx_H!:xVE}JSPWVx~2Pmq
/tVzYqJgq_2SObFp W W]~P"3~ubw
gX2S@Q \p xW"Nb+"3uOb^KgX}YQ \)wd,"Nb ZB3\LOb^DTvRZ}Y~WpO