6z$1tBg]NBcN@uU !~t3ysS~wTVgEGp\TkT~Z@VSqLP~N~Tn{GrU@{TP&T?pAb~VSaaSBWT{YSX_d.P W}T)Bt@AU}q}PyS TEpV .~^V"{TSJDtDVPaDSsTMF{_t8@ WANT)Rb\HVPS]oTEpG_C.PwWk"vTP^Y VCqSPPTVduvc! A2[O1xv\wfD_m2@RU|ZxSoEnT.yxv\]XS	WP}|g^ST[-nC6NXwPhTeAG2cA\xSWG-XyT k dUwfDa }2xc{C_G-~6[N^ Zw\xDWU}2NYTYxafY-T^D6iN`[bx	TWa} W	xgPxWZ\j~ _NXwP@aoc^GaV@-nC~ s*|vURBD uvR_}N^BTZEWW[zNURc[@YWBSXyJZ
}RCA}\T(	. 1-rWvQVPSwSBSUTXYtGO.H Th.T?xzYrVkqBP~NlTFw  Ox;r\WS*{T)ZyH\DV}_LSS2nT{EruvzR2rXO1K@bM~s~_w	2xg]Re^~6vNZFwTka
W BRQe]R_Gjr Xw\~TSm2rU|\RaeBjD6[*Vb\TFanBgAS`B-nx*XwbfDaG2rY]ABadAITu _N|vUMT|D[B}2`BY]ABadAIXo6i VtDwfTe }Nx]t]xae@-jD{N`GMTkWnW2CBQT_xaAX-nJ *R}UwfTS~WrR]ZRWRGI\r6vNZFwzsDyuf@s Ts\T(CYV/Z_s]zjX@ZnFCA~L^F+
YWP]Z]tS]XY{Y~|ZP XY)q]hNSPQ\GODxHYx-]N^BmYYTK[xV{ZZbmY^P^{)_}{wc*xTP&T?pAbvAV uS~nT{EGp)CTzWVRJzL~V uP~DW{ nw;PqW}lT|XbLEVKxSWwTG{vnB.P}W}ST)BDwVGASC.[V MxU{.PxW}ShW?VBarfTKUR]&UWn_{_DWTWS\TZAtUVP~S]SeTEp  OSzR2rXO1K@bMPDS]G uRQvBRa^G-~Zdq[]fTSl2UxUaPBae@-j2|vUM~s~Sm W	x]xe]To2NRn@ba	~a	}6xURCS`@TbT6qNRBDTGa 6Bg_BWAC-XET6SNRA^wbDeVGRRQT_xytTjD yNV _]T{Ta } XRc^xa{@TlTY	*Rr\\\
T}|xgGRW|XX|T2 ZBC]PhTeWRg ^xaw^\W
~.yxv\lBD uvRZ
|N[Ynr[FT[@WP]\Ga_]fB{FUY\|^F8XxT
/{\GWW_~X!]nB^B~D_T+u[	-TRw\GqG\^f_RF{d[Y~@[];}XSRTP \DZ\zX_]ZURZAUbCE+CXxT)g\Gqq\CzB{[{YAGPYYTX})USwZ@aXx~_F^B~DYYVCX}N,I[Bs[\S@_yVX[_{TY[UKXC%S
Q\GqqBkbDh5XX`ZXz[E(
@xTQY_Z^ZZF^CA~LXZ;}Z}%S<E[BqaBhTX~!XX`^B}LZC FRWE[Yt_]D_]Yx[A}^F;O]zRN,IZFW_^}z_{VY|_P~Qx2y U
pT@TVaSB@TYmSjFT}6tVRJzthV}QPhLTASe@|WW?VYfBU}exR&uUXwQ C@r[WtTPva~XV}CVPy*uT MQU{.PxW}ShT`Ya@V}CsSk  TGY  Ox8HfWhSBTpOt@}Vhy[SFTX]f{[y.PBW^T<VtDuV}[uPk"bT{MRmOT@[UuT<etDuVhWSkSUwvVq8z@WtTPv@GV@yYSsTFwVdU@{Wh vTPJ{L~Vku[ShTEpn}_.HTW}TSFQf Uh}ST EXC;\ W}_W.AL_VhfS~qTnQn U@{WPKT`GJzVAGSB@TmwEm}d.HqWPKTQtH@VhWSSkNZTUwMW @wW}T?JbLEWqwS~wTGQmS.nTWkT)Z|DwVCqaS@&TTnlU m)^WS{TVPIgWqw6q\A1]LBgB}t]-PTH^oFwbYT[2xc[RWlAIj~2*XwfDa}6xgXxeA-jD RPFzsDyuW^BcdESVZI\R~R^BMbpDeXW6 	BgPxa|[I~6 `X]f	_lGt
{tP]ACP&uVQ/I[U_
{z_X|^[ZXbYTSXPU/\GaCYzX~-[|XY~X^F+}]zVSIYCC\^fZPF `CA~LZEWWXRVAG^a\	^f_kZ^[]Xb_T+uZNU/{\GO_
hvX{1XX`YD{~X^)]x%S.AYCZGBfB{]|E[ b^F;O]zRTSXU_zYPZ{pCA~L^F8ZNWR Z\q[\hv_~!ZN[ZXbZG;m[A%N,IXAq}B[1]~Y_T[B KF5S<E\Gs^
}vXB=[~Z^Br^F;S\x-S<QZ_s]
jYyJY X^UYZ.}]x%S.AY[O\DZPF `CA~LETi]hT){XU^xPXBF^ZA~[CUOZ}%VAG^aYhD_yV@~NY^{rX_U[Z{T){XU\{Z]1XB^BX^F+
Yz9S<E[\tqXx~_k[|YG|XY].}F5V
gYCZGBfDS1]XV^B~r^FOZzV	)Q[DYy_
{vZ]1@~N^BmY@.qZU,]Z[m_x\ZPF `YG|XZG;OX^5SAXU_AjX{!XUFE[ bZ\VuX{RN,IZ[m_x\ZPF `YG|XZG;OX^5SA[Fy\_{]~RYBUbX@q[xT	RAYXJq]T_]@~N[]ErY])S]{HRgY_Wa^zT[V]mY]DZTU
X	xWSc\Gqq\C\ZPF `ZGbYZ(W@xT)AX]aO_
kbX{!XUFE[ bZ\VuX{RN,I[^s_x\Y=[~Z[FUDE_UmZzW<EY_WaYC@YkVY X\XY_XSHRg]Uqy\{_{VXlEPmf^EWF}1Vw[\s__CfD~)Y	FYC ~[^mZzW<EZ_sYkjZ
y[	~_P~z\T(	. 1-rWvQV_Ph TVgE{ayU@PV^"\TtD}V_Ph WVsmuC.PwWW<|sPxVSlSPSTVcVa}U@{WhJITZAtX~Vh_zS~wTAmOZ8TWPW
VRJzH\DVCy\SB|TGM{OTZTzUT<Z@thV}CVSsV Mx B8@YW T<^y@TVaSB|T{]t{_D.P~WSTJFsPpVCqS WmQVeE.nzW}T)BLU}nPySFWVsmuCjPWhOT<ua\uVPeSS2~UwvXuV;r\WW?VYfBU}exSB@TXwz{[|TxTx.TPJ{aPVA XSsTms\  OSzR2rXO1K@bM~s~[W6BU|\Re ]IjT 	 R[_MfD}6	BUlEWyCXUTH^oFwbYT[ W	xgBB[qEXzT [ ZvZ]b
De_ W	xQLABSY]n}J *d^w\DTSm cxQLABSY]n} \ Rd^]b
~[^G RQT_xadCIvwD*y1DAQ|
 uD	PRZ
|[Y~@[FT[@V
g[De_{DVZ|^X\zYYU}]hS,AADqOYkX~-[F|XY~X[FT_XRHS\GqC^	CD^{)]VYD}ZAWaXh%V.YYAJ\kXBZ}xYA~r[B KF5N,I[X_zXP1[F|XY~XYY;KXCTQ [GHaDxHX~-XR[BZCVuXxUPgXFbCY^P^{)ZXZ|Z@+qFRU{Z\q[\xD[-Z|^EXUYX)[{T
/{ZYy^	vZ]1[ VYP}XCE+C]T/A[[rG_
hDY{Z}xZAP[^mZ}%U]YC\}PXXEp^BXT^F+}Fk1T,[Aq\^f[	)X}CA~L[BW]kNU.YCZGBf[	)X}CA~sQx2y T<@t\yVCqSTUQQOyWwT}JT<^yDwVCqS]]Tc[|}GTT TkW.|tLVV^_uSh&STmYF  Ox;XxW^.BT<Z@tDuV}_xSkxT{ExUue\gW^yT
^nLVGS]SZT{Azn}ZVTFW^kT)^{t\FV^GSk  T{ErX[t@|WhSW)t\sU}eSB.`TUMtuv;T}ST
^v\uVhfSsTUMVe[VsWhZTppHzqVhCPk*TFw.HqUuT<AH\DU}nS~TTYmS)vuW\T<Ft\|U}|SB@TXEb{GrHaUuT)SHP\VCy\SB|Tnmn_B.LW}SnT)J\YHWqw6q\A1]LBgB}t]-X	TM*ZY
TyuW2ARc\SEFTn~RV\]\_T[ZG _xc|DxSoEnTY	*RoFMbsT} lRcYRSGZIn6SNd`[MbzDSPWNxceEWlAInx~ A RT[]Txa2~	Bc^_SEEIP
{NdAZMbDD_ QT_xSEFTn~RV\]b}SbW lRcYRY-P~6T `\MXkedGnBcwYxe[j \ XwPhTeW|RULXRWVZ\c6j dyA]XhT}uX@s TsXYa]xUkY_Wa_f[=Z{|YGUYTVZ^U[BZYxvY	~@~NY]DYZW]xS
QG]Z^zB{XU[BX\[@xSPG_teDxHXZ|ZXD CE+CZkTEY_He_xXX][X|[G@Y[TmZ
PRSA]Uq|
/s6z$T{rG_C.lW}yT`TJz]VPUS~xTUYOmo.HqV"{TSJDtDVPaDS~wTGQEU_XrqW}`T)BDwV}[zSkxTG]CmSZjW^VT)B{LUxqySB@Wmc~uwVzuWA.{T<@tXTV^ ]S]gT{EraP[WPW`T<RqWXVhlP{*TnEWGOt @ W}T|taETKySCNcW{cW{[S.PxWANT)ZvtbU}VPy"{T{Er  Ox+z{WANT)ZvbLV}[uSh TmMB{W)~{V"{1&
@bRME3D_\G2g]YSQT-T`y RSB]b{~[2UB]xaeX\y~p*^S]MTjTeCW2R
xUXRe[j DJ *ZvXwf~WFORUV^ReT-jD aNVxZwP}
aW6QT_xWACPw
T.y`@]bYDed}6BcwZBST[-Xo6MN`G
	~eW}6B]F_FnR	~\*`UwfDWD RxcWZS|BTTQ VVZwfTe}NxY]ABadAI\U2 ^vXfDWU}6BgBBY-PT z
*Rv^]TkW{2CxQT_xeFvwDPdf@fWWXRg_BeT-jDN`GM
	~WF sBUlESoE\D QVVZwb\~eZ} lRQz_xWVZ-~2NRn@PhTeAG W	xc@CBeFIvw[N!Q|[{HYC-[ dY^{r[^_Z@5VPYZtW_}_[Vl_P~z\T(
XVUQ[XWCYhX	!F dCA~L\T(C]P%V,E[[tq^kvXyZGR^B{@ZFOYCV
gGUIeYz@ZPJZB[^|DEEWY^RV
gY^tS^kv_]Z
}Wn}_P@WSSlT)F|Z\VVxSsT{ELUOS @PWSW?ZM~TKyS~PTG]CUa.L}WpT\DwVS[ P{*UTUwrnWWU@{Wh6
TxsbVAGSB@Tn]B{ .HqWW}Tp|vqW^qP6q\A1]LBgB}t]-jD2*^sD]Tka G6 	BgYB[l@IXRTY	*dfB
	~Sv}wRg^Ba^B\W
~K*`UwbQDeCW@RgYB[l@IjD6[`ZMzsDyuf@s Ts\T(C[zNT<AADqOBSXyJZ
lY\nCE+CZ^-UI\DYq\^fX[nBXZ|^EWF}1V
gX@DxH_S!]}FXP~^F;SZA5SPY\GWXx~]xVXXXFT^F+O[
xNWQQY_Wa_b[]-ZEBX^\YE+mZ)T.Q\GqG\^fD5F
BCA~L^E;[[zNV,E[[tq^	v_{XX`^A}P^FK@xWPYZ_s^xPYk[{^BXT^F+O[P9R,z~t3ysPS"TmwCE}zRW}T)ZvtLSTKyR]&UTX]gV .P}W}oTPBrqzQVlS~xTVg[  Ox.qWANT
ZetLSVkK[S~aT{eZTT TkT`Gtb~V}_xSkxTUwr{CbTbW}tT|taEWqwR]&R1tBg]NBc\D QVtG]PqTe_}Nx]CCx^rw~Pdf@bfTe`WNx]ZRaYnpT6i VVZwTD~[2A	BgZBafY-X@2`GMXvTeBWxgPxaVF~ NNZ]Mf~eWG2ARgZBa_Ij~6q	XwfTe}G`xQT_x[G^-jD \ RxYMbc	T}2xUV^RaeAIPrT6[*`\MXkeeGRBcBDRWlAIX	T2*`BwfDWU}@x]C[Re[~6q*RoFMbsT_\G2gcaGRaaCj~6hNZZU]TgDSC}2bB{tPB}t]6N@uU !G]Z^zZx-]XV[E}~CE+C[@)U,]X@a]B{Z p^B~D[^mFSNW,{[@Ie^xb_]]FYG|XXAWmYkV
g[Yq^	kjB{[GN[_{T[A)C]x%S.A\GqG^}@Z]1[|^AE^.i@xW,I\GW\^fX[nB[FX^)XkVUQ[@HS^AT_~XX`YA}YA8}[^)VQE[ZaXx{*$1uF}wT\zWhST?xztWUk[NST{]~Gyv;AW}tT?pxLV^_uSB|T{EnyH}WMT<d}qrSUkGsSkAT{ErGyv;AW}tT)Z|vqV@yvS zTnQ^mug.STkBTQxtDuVySS6V MxmGe8zyWS"@T
BaPV}CsPh2TnYg  Ox;r\W^sW?daX`VGRS6TG]CG}8PW}TQrabTKyPySFT{Mm{GWHqWANT)ZvWzyWqw6q\A1]LBgB}t]-nq~6S ^UCMbQ~W.wRU\PRS[ZIn~~6SNd`\]f~e^}NxUmXxWc@-\W
~ZZ|A]f	DeXW c]Ra}F\y~J *`Uw\qTSl\BcB_B[WBP}TNVFbcTeeW6 	BgYB[l@I~{Nd@XbE	WU}TB]~DR_dEnU~6[*`[M
	~edW2~BY}\RaM]\_~ kVVZwbX~_RNx]ZR_@BjDaNVUFwT}Te}G2xg_BSEFTn~RV\]\DaGczBytTN@uU !Y\qC^
}vZPF `ZXz[E(
X^5T	RAYXJqDxHX!]~F[ZXbYC)_Z{Uw\GJGBZ]XVZCUPX]a@xHX[Zy^DV@~NYD{~ZEWZSNH)cYXWCB[~YUx^B~rY[W
@xS, Y\mBkbXy[ d^Br^F;S\x( -VrbptV@yvS zTnQ^OyWwWC qT`ODwV}QPhLTn{~uxLWh_W)pXWb}V}CsQ{T{]tm\8_Wh OTxmaLtUz}S~WfT{ErF}wT\zWhSVRJzfSUxWNP~NSTVgVq;vWC*PT`tzWqwSCW\TUaF}wT\zWhST?JXYV^_S~NSWm]OGp\Wh"bVRJzt\sVhyS]zT{AzVa .HDWk"wT<VETKyS~wTXxXC{8zdW}T<R@Y~hTKySkATVo GUHW"W.|tLUzSvS~xTG]CF}wT\zWhST<yZDgVSFQ{W{o{_t{W^&iT
paZPKVGdPx&Tn]B{GrnT}JT)Z|vq3rC6XA1BgYB[l@IXOT [ dpX]fWa} FBYmCxa^BPJ *` ^MXVDe~W2~BQzDxe[j~ sR|[MPgTWMG ZBc~Zax_j~Y	*dCwbxT}  QCadXX_TVNdBwPU	Te{*wBY]ABadAIP~ aNVD@wf~SG	W Uc|DxSLE\ZD6sNVE\PwD[pW2{BgYxa@]P~Y	*RbGbz}2UxYo^xa@Gj6h^uZb{~[6xgFB[A[-XBDy	 VVZwXd[uWNxg[Be ]IXopdA]T`~W	G W	x]xaz]IXRTAV[\Mby[}rR]ZRWRGIXc6pN|vUMba	~[W6 c^FR[D[-\T~ N*Xw\zDeW W	xUAGBW~T-\U aNd\CMbETaGNx]yGRWlAITl~y Z_wTKTSMW RRQT_x_C]~ z
*Rv^]\zDeW6cf]x[v\Ij 6S ^FZwbDa W2]BcdGytTXr6q*^m[w\sT_\G2gQT_xaTIXT 
 VVZw
	~edrxYo^x_tT\W
~2N`X]\vTeg}6g[ReFP@~J *dgCMb	~SW6B]qARWmB\uT
ZZTVTee*w]CCTsP&[^)VQE[Za\xDZk!Z
}|YGUXE\W[P9V
g[F_^
kzB{[XFE[UYZ8qZ^%WE[[aYxvYy@~NEXGYC.m]xVPYZtW^@Z@!]XV^B~r^F)KZ
C%W
P X[Zy\^fXP!YEpCA~LE^Xh%TwX@Jq\^fXXEpYZ@YXSX^5U.][GIW\Z~Z~pYG@XT)aZPS,EG_aDxH[R[XNE[\XZ;}ZzV
gGC_^	v_{]mY_ D[Y}]^S,w[Aay^	A@XBXX`Y_Er_T+p. 1-rWvQVGRS6TG]CaP;AUzU
pSaEV}[SsTUYm_OVzWk*uTP^wVAK}Pk*TAo{Gr.nWASTVRJzL~V uSh T{]AGp.P]W}T)^qtXtV}[zP{*TUYOmoVzu2rXO1K@bM~s~WF sBUlESY]TwTy	 ddXwPBD_l}2]R]^ST[-j D| dGMP}~aGNxYvXeBXnD2NRR\wPwDeCW[RYo]ReG-j 
D.yxv\lBD uvRFUY\|YX)CXh%V	ZUW[\^fX	!F dYA^F+
]hNUQw[[I_]STYS=@~N\P}LE^;SYx)N,IZ_s_@XXx@}XPF\E[u]^N,{^Ur
/s6z$UXwVE}]8jlV"{TGYcTKySzTGYmOZPdWC*rTP_DwU}nSCSTGQmS.QWArT~Yf\VCqSB Wns}ma~VzuT}JbTJ_W\`Ux}PkeTGY{[SP@Wk_T)Za~XV}[ESS2LTV]q{GG.P}WA6RT<eDwVeQS"T{YynGW)rDW}T?\W\aV^_uSh&TGg  OxPdW^vW,|aTaVCqR&uWVsmuCU@{WC*PT
|Ma\EVeQPk&|W~wsCSVjWhTQ@tDuTKyS2SWnw~usjFW2^TpOHLxVeQSkWAV MxaP;ATx.T?JXYbVhlSkATV]w~ywWHsWA
T<pmtVV^C_SS2V Mxng;\ WPzT<BUZP]VPaZSsTE{cGOCU@{TxTTZAa\EU}S~qTmM_{GrrW6uVRJza~XVhBSB@W{P[8\Th.W,|aTVG`R&uTFe{_DTnSTh"rW,pqaCUzSvS~xWmYZ}uU@{WS"@W,xAYSUx}SkAW{ pWH~WP*|TPdzLVaUP{ LTnULnS8@\Tx"~TxsbWqwR]&R1tBg]NBcrw~6[NZvZ]
	~eW	w	RcBDRWlAI\y
~Y	N`[f
DWU}2_Qc]xad_I*y1DAQ|
 u]x[|[ZXbCE+CY^)WRg[\se]xjZ]1YZA\X]+WZzT/AY_Wa\X[B@~NZA\X@qZ}%SwY\mBkbZ]1[ VYP}X_T+uFSVT
.\DYq\	CvXyYFBZAEX[^m]CHR Z_s_
jY{Z|RXD}bZEW}X^5SAADqO^z\D]1Z	 F^B}TCE+CF@1S.AZ^WYbXP5Z~VY^{r^F.m@xH[YsDxH_S!YX|YPmDYC 
Z
T,U\GWWXx~]xU-ugwzUW}yT)^~aPuVPa|QPWmY|~uwU@PV^"\1&
@bRME3DS@	2
Y]ABadAIne~b*ZvU]bDT[BW W	xUmCBat^~ Q VY[bz~evG2ZRg_Ba}[n]
J *RUwbbTWXG2xxQT_xW\T\X6p*dg_wb_F}R]xSY]\X~J *dpFT
~}2ARcq]WlAInU~2 d\C]f
a G W	xQYYBSwGj~q*|vUMb^TWU} UxQQZae^-X	~2	Zc\]\xD}2ZRYT]WpYInU~ u dGMfDa }2|
R]xSG]InA
DH^oFwXvTe}G\B]x[XP|DY	*VGGMXj~[^G RgERW\n~D2	dGMPv
~WU} RY_]BY-Tu ^]XMP@WqGBQz_xSzZInDy	 ^sD]f	T[pW}RUxXRY-j~ `^oFwbQD_P	G2fxc[WPTnpD N`A]
	~a W2fUzGa|GC.XUM-DAQ|
 u*$1ugtBcAA2[N!
