2p%cEK uSH~S7mtePZqWt	{=],}T PzLTMcmcQWtp(8}]B \ms U[pU4v2R@ig7X~cXDW\^TwBW7ZAVrPew	uRO{#]~UJZWTa]]}3^UART
z_&7HcZ\~]EA}XmBMTWYRZ{	z[J]3SUOU-ZTUP\}\~]b EW3^{ZGPa]MTPg@~cQCGjYMTLBRZ{`
z[	OS+g2AUjGnzD)fCGJ]QRRP]w~R]&ETUrR}\c[XZW7CA`	z[w3~J+gT_TUjGj ZPmEP\VPz}$M/vW0GPu VvX@,KZEx,]\mwAobr[LdESBX@@KZ^,YZyK\UUA\	|qXOQ^[NC[SuZ_XEBS^\}]Z|v	b[W(t^EC{C[FS_XYh]X[]\y	sZJ(d	FzXCxKYY[XD{0_ZAZ|v	s [W(t^EC{C_E/[A_XA\
|\b\L-BZh][{OXFWX^~ YU}X
0[KJ	FVX@YW/u_ByW^[]@WG^`]kR_[~}X]QBA{CU~_ \W[U.tCzZ]@
^W/x{%b|rQoa4WY7GSEM u	\x~Gmx[Qo =WY7y!Ev h@C<Dk#g[pRRy?WZ'OYhY hl<HChJWPZq2{]@iHcDcX[}\wEb_GpGQdZzy$wTg@TUjG\{YPW^}y_QdRzSw7KQ(T~UxX}nCX)f|BGWBQVPzew3UO#TDr[fNBS"TvSZU~I\~
t\OtT^[{W_E	SXY~ __ADb
YK=^	FpX@kSBF/KYX~
^XU]
yv	SZPZ}p\AyuXBX\]XDw]	W
YSB^^`\YXZ*XY~ ]UF]Z|	t,XV=J	F^VECx]W,X[x _B]_ 
sZ^/h^^`\GmDW<aBA{XGQ\y\s\L-Td__@OXY/S[AC_B~I^fW0XKQ^z][xY]-XPkED}IZ P	YWRhTkd_E]uY^K_B{W_XFE]DZS\O/t^]_]WZZCDPC4XGmY\yf	ZW[Qt@}|_G]CXX[YDC,^\}]\GD
qYTdY\R
_E	S^P{-~r4}sNWY7T=W}Et k^rayOmtePZqWtyQ1}TyQHy~' iQT 4WWRXQ}i hl<HChDZGQD)WQA'M~ ~TRrLBERy<WH}=Ukk~\R*n~rEpQ C Wb@>EIPj h@[QHy]xxkQyCWW>I}]r~n	\zBExZpQo =WYRzgREv h@C<D'p[pU4v2R@i{#]~Ur_GjY)bZG_QRV}$M/vWg7X~cXDW\^Pp^GFFAVPzWS^+g	]~_}n{^MPWE}7^A`PaQMTcVBDQ|\WXWY)T~ZW7@Q^Pz[=S^+Q(T~UP\W\UX)TZZ}3EZA	ze5nKOU-@~cPD}\WYMPPGW7U{dx_!]NV]!\g\}\AW)fz[WOX{Z	PexPQZ~QyXWj B\U\}kXVPzew3UOU]QvAGndAPmEF[V	@W
w7^+g__}TUF\v\|[QRRzW/]7WOQ;AUF\\ETU_}O\NDGq]|SYW-F]hp_Yx}X@-_ZBW]_[g^TX<[I.JGx]@Z^PiDPh4XGQ]
~X4\LF	FpX@kS]W,K_AS ]X~I\bW0XMQZ{|X@{}Y_*WBA{\D]_Z\qYP>^G_[~}X]Q_B{ ^]xUG|HbKZT/A^B]C~KZ]	eBA{_B[\
EH
WZP[F_G]CY\eZZ]0]X[]\
|Xb
G^`	Fh^^\k}Y^/_ZZ]0]BY]P	q[R=ZYCp_[ySYY,yZY~_[m G|HI4\L=ZZhp^[{WZ]	e[Cy(_@ I]ZHs [TSY^Z]_@KXC/SYZyK^[~{ZHW0AO-JGzx_GCXF<}Y^x,^[mw\
|\qX^-J	Ezp_X
ZZ	_Z]@_DnZTva ZW-^ExN\R{C_E,eYD~0_GV ]WvqS\L=ZA`X@hY]-Y^x,]XF_ z
tYTd	FCFEC{CYY,yY^]_BV]]ob	bXQRBG|]X]mX@aX_~KXG}w\yTq[OhExN_F{[Y^iZ[yXDw]	W
YSBZ^F^F~mXEX_P ^AFE]W		qSZP.x@}|^\]KX@_[E@CZm _ \Y ]^-|ZhpX@aZZuXYy^[~{A
|v
W,\Ot^^`_@yXY_XByS^[~{\Z@a ZW-^^^`]_]WY^/[Z^h
]][_lTWZP[F^[SaBF/KY^x,]\kAobY ZT/A^\^hO_ESDYh]_[gZG@qZP.xC{N]_xCXFWX^~ XDUw^ \s,[L/R^^`]_]WY^/[Z^h
^_ZG^`TSR^[SaZ]	eBA{\@Y^oDIGW>R^zX@{}XDSZZ]0]X[E_yTqZP=F	FxB_[hOXB<uXGx_B[_oDAO-J	FV]X]mYD	[YPSK^\Uk\Ev	a,[P-RFSEC{C_FuXD~W_DE]	 	JYSFZ}R_@BCZX*SX\{S^[[A^ \	bYS^]x^]\hW[FS[ZB
XGQG|H
t[R-XhF\GW_ESSX_PXG _	Zf[KPRTxxZRx	|Upgz%n``QTaWSP{W}Et rb ~xZRy-WJ+X}Ad ~LX<r{yqVQWC3Wr-/hQy ,vV~^nfSK(TtOm(Y#h]{ Hq*Xuk{m|QE[Wt(A%Cw PT?fC ~xZQyC"WJ'][hcD ~Lc?B~_xFhQlWSTqFUEv ~Pu?X|'pbw
F4_J2M/vW+YM^~UP\WZ)P^G_Q^X[+7L+QQGcuEWXCD)b EWz^ARh_#	M7KUU^T]E@}Pf]MbGG	W^ARRPaQOS+c[\~UfCGnWM]}_Q^X[+7L+YYTcuEWXCD)\|]}k]{Z{@S=w3eJOZY~UJZWXWYbBG7_AdaPW*wVQ+#TDr[Wn_^)P^G7U{^XSVY(@DQR]}PzBMb B}3[\AdxzaS
M3bR+g	BTQ[WX~YMb EW+rU^DGq]|S^^.JEZ^Xy_ERu_BkED~X	r [I/^F][{OZ^?uY^kXG _	ZfI(XP|YPX@~SBF/KXA4XG ZosKZW-^CCXB}D]uZZ]0XG} ]Z\q\L-]lX@~K_F<iBA{XGQ\yD

[OVEZX@yKX@,KYZyKXGA]r<YTd	FCFEC{CY^/_Y[_U~]]sZWxAN^GSi_E?_Y_xK]_[g_yTJAO-J]xZ^Y[XW,_X]P0_X YA	yfY
YTdTX@yKZYSuZ^YU}z	(sN2p%cMa u?v`]'PxVQy[+WZOqQhsg~nXB~rx^xSK(WaOyP ~Sz\BynaQTa V'tscrDeXAC`fa\}3XCQV
Pe"3pMOU[~QP\\PW)f_Y}EF{^sy$w3\W+g^g@j_)TRGW7XQVWP_'	~RcVYTg]WjXPmEEG{Zc	aSM	SUU[~YwD}j YM]}_{RhaRMVQ+gETUP\ndYMfXAW3uZ{d	
]w7V+YBTUz^WXYXZW7CAV]
@WwVQ+Y,Ag@}\]b[G3bU	z[Jw7Sg0ZD]E\WX}[XZW7CAZaQw3~J+gT_TUjGnv]bP}7[{	za\wBI+cVFDUz^Wj]TZW7^Ad`e4OWO{#]eCEVvS"XGx]_[g_
yHbS\L>^z__SXFWY[ ^@g]Gv	
JAO-J_{F\]i[B_X[x _B]_ 

[OV]xZX@{}_E,Y^x^]~UXH

\L-tZxRCR
Y]-YD~0_GV ]Wvq\OtTd^F@OX@XGP
]_[gZ|sK[R.VE{XCS}D]DPh4\DY\ba [I^Y^RxCZ]	e[A]\mw]|	aXOZAkpEC{C_E/BA{_B[\
EHY \L-EZX@kSXW<CBA{CUEcZlXt0[L[Sp]X]m_E/GXY~_XA\
|\Z\LxExN_EPWXC/SYDC,^\}]]|PY<[SRBxpYR{u]W,{%b|rQoa4WY7GSEg] ]\Su]	xZEQ C TqVA(YVM~ ~Lcf]+I[BzRy?WtF-}] ]dS@q/yx~SK(W7>s-U P@u*nk~J|QlWHAI#Az ~Lc*mBED`QWK!WtpSI/}Ad k~U*XzkDJ|QyG2WZNSE2]K @z\k3D ZIQ C WHP4xQB ]La*@s ~[^pQyG	Wt`sWAM@ @r\~bB7VJuQGqUWZ	=gwpeq C`ICgGP[VUze0	w3\HUU]TQR]}P\A)Pp_W3X\{dZW	]MOQCTr[}P]P~]W3EGQdh	]wbOgMTcbEZ)fdFG^UQ`ze.]~RQ(EDY
^}X~W)PW^WRZ{V~PSw}TUYDQy]Z)TqCG3bXAR{@e,w7V+YG~gGW\UX)fAYWkX	zS,	]3@JcZ^DUx\Gj_)fVAW|[QV~@WR]7V+ZY~QvAGneZPMB3_DQ`@Sw3Og$@~g
Z}jB)b G}7CAdFPe57 IgWF~Q^_\UX)TaYG`e*OS+cVYT]]X}[XYPWcY{^v@a\wVQ+Q;AUDA}nFfrD}RZ{^EzS$7TcVT~cXDWn_Af]YG3GA	zeMRW+Q:GDYkA}Xx\f[3XCA`PW
wAW]!\g\}nzCMbA3^dxzaS
M7V+g ETQ|\W\{EbYJG`Pe	]@M+gWETcuF}Z)P~P}7BQ`z[]3|V+gMBYr[n@f{B3EGR{@e#M7TU[~Q|\WXWY)T~ZWZXAV{}$MT+QZTct_W\]bX}7CARaz_"	MOS+gTDUV[}j_)PpDQF{dW
w}Og+@~cuAGj\TU_}|[QRRzW/]^SU([ccDGPpF\PX}7
]{VPze#
w3WOYF~]aXj@\P[G+rUAxp
aE|PZ _{p_EyWZESYY{
XGDE\v	aAO-J	FV^Z~WY^-K_B{W^Uc^H	XQRBG|]X]mX@X_k0_D~^X
	b\LR]kVEC{CXZPYZyK]XFw]EsKZKF[SREC{CX@	}_B]_[g^ \HG^(J^^`X@[_E/XABXG} ^H	XQRBG|]X]mX@X_k0_D~G|H

\LFCzZX@[Z]	eX_]<_D cZ|v0[W/ZYzd^\kBF/K_B{W\D U_Gv	s\LQRT_AuZERDB@^\YZZPq\LQRG|]]~[DW<a]PxCUEcZlX	r[JF	F}B^\xqXX?[X\k\DDZZPq\L-t	E{F^\xq[DSYD~0_GV ]Wv\LRJXhF_\yOBF/KX]_G}I\
DY X^SCS_EP
XE-Y^x,]ZUUAWt0[L[SpYR{u]W,{%b|rQTaWeQ#hsg]zW*n/xVQEaNWZOsSI/A]| SjD	Xf~	UxJPQlWSTt'U^Y kn*nv {QEK,W	mR{-Y{@y-C~VcxZyQy[$WtVP=0D kn*Dcv {QEK,W	mR{-Y{@y?EyqnJ^QE_Wt|A)Pw Bj?fX@'xZESK(W7>s-^Ex ~*X@]	rDZQaSWr>EIY{ j*XxBV_VpIR~u(WtpPs!xQI ~H{rP	
mdFQZ[7WY 3}]r L?~BE[BzQTePWZVc=w}EJ jRfNk7xZpQDqVUz]#}A_ ~PuU~RUdQTe\W3YwIPc HqRrw]'Wbw
F4_J2M3bR+g	BTQ[W\wEb_GpGQdZzW M3fSQ]TQWR}XCD)fAW3uA{VPza\3\Q+YS@~c|@Z)PCC}3DQdwze6wOg*]Tc_@WjB)P@X3WY{dRzaQwMOU-BT]r_WZ)PCC}3DQdwzW	]VQ+gIZ~cR}nWM]}_QRx@[w3@JQ;AgFGjETU_}3x_^ye4OS+g7X~cXDW\^fWF}7U{RiPWS^+QG~cCWnrC)\wXf\{V@W
wDRgFT_}P]b P}3zG`@[]VQ+gIZ~UZWPCM]}7\RhS7POg%@cFXGj W)fAZG^UQZDPSw3Og$@~gR}\VD)fP}3UVPzSU7POg-F{rRGXl_TqCG7]`S<Z^Y&Y~ccXP|AfDWPU{d]PW
w3qQ+gZ]gYGj^MfWF}yU{`PS!w+v^GPu VvYC*eXBPW_ZVwZosK[SQxYCpX@][X\,uXGy
]G G|H	Z
YK.x]hp\Aq_E	S[A^\UkXHqS\L=Z]PlX@][DWQ_B{W\F\zZP>`ZB_^PCBF,]PxT~r4}sNWb7fcAW @fSuk#g[pRQy WtDPEvkr^*\}PrVuSK(WWes4^Yg ]TC?XC~VTxFBPq&VW'Si'	c[LDeGru^)Pu]G7[{`		@e7MOS+YM^T]DAT|Z)PmE7XQRheNwoV+Y ZD_}\GB)b P}@]QRUPW
w7LY!AcFXGj]f^}7]{RuW
wOS+Q+XTgG}n|_)b FG3]Y{d\PaRM3@SOcVT~]ATbFMf_GOX{R{zaR]7SU\TgR}jY)\pAWwDQV~PW
w3P+gZT~cRvuWzuYWDF{dPe#wTPOg7X~cXDW\^TG\WRZ{dze)]3LZY~gEWj Eb[Gj@VBzaQwDVQCT]XWT|Z)b ]W7]{Ru[]VQ+Q:\~]q\GX~ZbZG_QRV}$RAZ ZPu_Yx}X@-_ZBW^YmUZZP	a[I(dTkdZRxC[FS_D_^_U^W~

\L=ZCSEC{C[W/K_Bx0\DY\
|\Y [W/ZExN^R{_E?[_Ax^^w^l@		Y(AO-JYF^Xy^W/}^P{(ZU~	(sN2p%QI.r hjebDWEJHR~[$WaO~Ev Cze@'V^QleWOQI(hsg]zW	r{~	zxBvSKWH}(E#}YzyPrLQoqV'tscrDeXAC`fa\}3XCQV
Pe5]7Qg2\UDY}Tv[MzuY}zYQRRPaS7POYTTcQ[G\{YMfY}OX{ZpzaQw7SUCTYq^jW)b^}kFAdp	PS/]sOg ]DUWEWZ)P}\Wr^Q`zaQw7HcTFDcPD}P]\|]}J]Q`@W#	_O#TDr[fNBS"TvS^Axg]W	
Z YTdCk^Ra_E<YZyK^\}]ZED
	tW[KQExNX@{
[FRWX[x _B]_ 
IK[KB^z^[{WXF	[D_W\B[{_	ZfWZ^PhZhXCxKXXQCX]@]_[gG|Ha \LRhCSZX@{
[WQ_BhKXG} \bYW=t	FVZRxC_FuXE]
_D c_	Zf	J[R/VExN^\xqY^/_X_ XGA]W	J
[I^ExN\CSY^/_[D~XGxE]~DJAO-JCSZX@{}Z]QeXE
^[~{]ZX	ZWAO-JZhpX@a_FuY[~S_D c]~Tq(^^. Zuezx<beS7CFUQl<WrI(}EQ Crl<z~tJ|R~UWYRR/}Ad CzHG~}[|KQSRWZvsRSY
 knCQHyh+B[pgQE[Wtv=Y%kU@y?BBE FQoK
Wt`/Q }] ~HszS3
FpQW_\Wa3@-s/U P@uRMOaxpSK(Wt`/Q h S	\k3xkQ C WR}I+Yi r{R\| ~ `Qoq*WW	=UThY ~PE,TdkUURW5Wb/z(IkA
 ~RvnJFQESPUzPcPkw| ]H*HSh
 {QSWZZ>EA_ @rSPl@'V^QleWr/$k`@y?BBExkQy[$Wa(E5C[ @vb@'V^QleTsO=UThY@y*Dc~}}|R~UUz(E5}]} ]vN-D@'V^QleWt(E5^Au PpQHy~dm@QZ}WJ'][hcD B\SZBT~^cQ C WJ7 Q#M~ ]TuH~vxZpQl[-TtRU-Ek~y~uvlk+
`IQyG2TqFU}]r ~PE*@]	[FwPq&2{]@iHcDQP\\PW)fa\}3XCQV
PS]7TOU:^]EG\UX)P[XWTFRFzeP]3qJ+UCTYq^na[)f_FW\QZreM7WOY+YTg_Wn\MX|FG3 AQ	ze5nKOQZTgXjYMPp_WfAQ`PeNHgQ@TYr\WXxA]}3_GQVBzaQwDVcVFcxD}XCb]7ZAddze] WZY~cf^}n_ATYWRZ{Ze	w7^+][_}\qDfe]GBVW
w|Jc[Yg]GXCD)fAW3uA{|p_E|PZ T{N_EyWZESBA{_@[]]bW0[SFXzREC{CYY,y_Ax]@m]ZTvW0AO-J^`_\~}YY,yYEP_XFE_	ZfI4\L-tCzZEC{CYY,yDPWXD~A_l\Y ]^-|T{yx`.ph7bU`AQGWZOy(A%Sz ~TrS@qF|@QG,WtxY^Ea kP*Xz~VcBtQGe'Wt{M~ PlfNSpEZSK(WY7Ec,}e @~w	rW@'V^QleWWe(IkAV BXS@q ~[ZcQoG WHV[QA'hY ~PubDP'KDZGQZ[7WY(Ev B\?rn ~xkQE[WWeW}T Hq	\yO prPZqWt`QA'P{DhNH~~QExiQoy\Uz(Y,}{~zv?~h'@ViQlWSWt`QA'hUI PpRrwgq]Db^KF4@Sw3Og$@~g_WjZMTU_}pGQVUzewOS+cVC~gDGjETlZ3g@QVUzS.]3TH+cVT~]AvuWFBTvPQp]H
XOQJ^^`^\]K[FS__B{ _[}UAq[W/Z]}NC]C^W/x{%b|rPZqWtVP(Y,zQy Hq/TEPKVxQD)WZOy>s:MU]zP`%CgXDbAdZ
zeMQOg	G~cc^W\{C)X|FG3 AQVPze3CR+gQCcvCX@_MTFZW3PC{Zy@eV]VQ+YTBcb_Gru^)PA^3XQ	zaRw7P+Q;AUF\nZ]}zYQ`P[]VQ+Q+XT]XWjY)fvZGP[Q`zaPw	bTZY~gYGj ZX_j@`@eM7L#TDr[fNBS"TvSZU~IZ P	KZT/@}`_@P
XXuZZ]0][x{ZG@q[SR^zXCS}XZeX^y
]^YZZP[KS^@}`_@P
XXuZZ]0][x{G|HY YWRhTkdXCy}X]QZ]]
]XFA\y\sZURt@l__@OD]eYD~0_GV ]WvW0XKPhXAxEC{C_Fu_Bk^[mwZj		aXKP^	FV\CW_E-CY[ C\n]yzsK[P/^_z^X@[XE-_AS ^[V]yv	
Z\O>^^^`]_]WY^/[Z^h
]][_lTq[I.J	EPp][xZ]	eX]XG[QG|H	YTdCS__YW,i^P{(ZU~ ]T	
tKYW-^C}`]Ay_Z]yX_@_ZFU_	ZfqYW=tC{N\GmDW<a^P{-~r4}sNWY7TQA'zs\ ]vr}P	InkSK(Wt(]-PU Se{BVVIQ C WWRY/(}]r kX?~@/[npBQl[VW'T(hs  hzG	Xf~@R~UQscrDeXAC`zuY}zYQRhS=wrSO]:G~cbG}n}C)TU_}+rUAxp
aE|PZ T{N^\x[[B[Y^x,^_]~\s\LRT@d_^{
D^<}XBP0ED}I]sKZP.xA`XCy}X]QZ]]
]XFA^	JGTd@}`_@P
XXuZZ]0C@ng\~TbK\L-^zCX]_F[P,\@g_	Zfq\O/t^]_]WZZC[[P0_YE_
lv [J(^^`]RPaYC,eX\]^@Uc\fqZK`^zX@{}XY/WDEh0^UU_	Zf	
aZT.ExN_E]uY^K_Ay __ _Z\JG^S	Fx\R
XZGDZS0^Axg]W	
Z YTdAk`^Ry_DWa_Bk^Axg]W	
Z YW.^^`^Y}[ZX]K^^n{ZZPq(^^.C{NCYPXZQ__B{ _]wG|HtYI>^}_CB_Y^/__BB]CVA\qXK^	FCF][{O_E/DP{KXGQ_	Zf4ZJQhTx}yx`.pP]m`Q S7WW+eQA'M u*DcyOmtePZqWQQA'MU]zP`%CgXDbAdZ
zW&]7QU!FTcXA}Tv[MzuY}j@VR
W
wOS+Y8ETQvAGXCD)fAW3uA{`PS<~RcUA~QR]}jCTaY3_Adt]w3gKOQ;Ac_@WXB\TFY \RxPaRw7^+YSGQf[XEMb_G	p]`zaP
]OS+Q+XTcDFW\A\MfPp]{dvPWw7WOcVYTgXGj @MfPkZQV}@e,wZ^QZcFFnXETU_}3PA{REP]w~RQ;AczDW\aA)b_G3fY{dZPWR]TcVBDcA}PEMbBGWBQd@S,	]}OgFcuAGj]TU_}|[QRRzW/]^SU([_}ndBMPmE3CVrPS/M	R+YM^TgXj^MXpAW3C`	S/M3L]!\gZ}PBD)b EWRZ{`	ze]xPU-FD_}X}[bE}7B{`@e57 IYG~UjGj[TVB}3@AdzPW\M7Q#TDr[fNBS"TvS_FU]yqYW=t	F^\@qX^-[_B{ \FVU_	Zft0[L[Sp_^]CX\,uXGy
]G G|H	4\L/_^d_Y]iDW<a]Px_G}I\
D\LRJ	Fz`X@yK[WQYY{
^\A\
Tjq[R/RZ{Z^\xq[FS_[A]_@nwAqW\O.BYA\F{aYY,y[__F{_	Zfq(^^. Zuezx`%CgUY