fqr5%
@h_dM_PMGb\QdF.e(	O_G\ZMd~MPZDMYS}P
vg]e +[HDv`RdV@2*GwaSXSvQ~^JaVOar\\)d@P@+EMaRJWPQvUcFS)	+_FLVduVz6W]YS}\c`]W+aiBvdE`V
EW(RWPA\QtCW+e@Ld~)dfS2^eWQGzqSCGT%[ VG]Y-YXLJ]aU@[^V`]D(
(\V\VEY,A[QGt~^]rZB(~T][ ^/wXQ~BqLJkm^uV\[ ~/~TXrYX,{GI SrIha@[p_ZfXU_cYZQ[QlV	SqYut3quq Quh cJPR{.t]zJV[YH;eSSO^VpQP	ZeyN9t TBLzVuESq6QeSBpS<VBl"7Zu1hLV}Uq 4'OfSKB5d@R AwS.Pb~vc~^e	+SY^vde^oJ@!_YTG~qvg].W/OaL]v)R~SPLYwW%JXhLgX.S'OaELdc_P."ZlAZv }\E bSbVX`w[	gZTSrXO{O\r^^CW/bUZ{Y	I[K|JZt\S]C\[d_DVD
>TCuYY YUZ1SIfQq[rF\CVT>rTB[RZVT=]trPx}_]^8-LTEpQX,{[U)YzS{m\`[P({[(WwfqrS*BEE !G$k~ZV`QV-[QSXdRQJzy-Wu Sb	VVgaTC&QROjtRQJz|&.Zu1hLV}(WRq pVDPSBrEWa_]\bVIsA_:R(U uVSP?^y.ekDRVEt-["QGsV]P*glJ}ThP_VEt8y	Q=IV^yQRpthv\dRNiGb	cF]J_ +Sw_VT)R}Q2*YMeYL}byvUx\[L	a}@VT)RoL@2"Y]YS}Tz
]YeL	ai]\`R`MP LAWVTG	vUuDJ[_ELd)d@R AwS.P	vg_eO[[CvVzMdyLz2 EwW(RWTz
QBJST	e_dVVPz;@Ma TWT`vc{]W+eQvR~RyR6Z^W(RWTz
]w[}"ANU}"^_AWLPS\cpGA(HfSCQ^	EYM VFX
L{[sF^AT\=\TDK]X,c[Ky-FHPT]aZpxXP+SbTDVIY/GVy^W@SW[pp]]W@=@SCc[-UYL~YWbS}[`\\ \>\W@XQYPQ\M|!AsDU@[\s|[P({[(WwfqrPSJ{lZu1hLV}UQ>OW[tsPR`Z*W[J]\bU[EU}SSOuVZgS^Dy(YT~DBVcw~TC&Q>uX^S-l"7O ]vSVcw _RSSOuuRP?d~y,Hq]XiUu\-[(Q(_tIYQRptZ&d{iXMG3Lc`C.Waq[LRqM` R@1E]W+T}\	Lg^JSSY^vRmdvUPN[^wW9^W\\gP.aWWBdA)^GJz6W]MW-IGf		c`C.eSY^vZqMZpQ@@w[#RLpY.e*OeF\`d@KPLY]eTP}bE\Uh\J[eYvVXMd_zN[^weVPGb[\g]_9alF\d}
)`I@2B]aOWPQvQ~F[+eYvdB`RPS]W%JT QUP.aT_[\`dTKz4A]SLbv{pPy"
0ANU}"G_D5^DR@_^	rF\^8D.DUQc[
w[Sy1ZaXT]a]V]P+\-LT\[g[	{YPy[I@J{@u^_]DXTYwY*QZJT)	SqYut3qu8y	Q=S_cp{PVTW2aPhUr*UQQG}cpgPVuySVtakTM|-[-QaQ`R{S<Z ZbuQTvWwrg"4NOfLxt)ZUP:FW(RWfvQdCJaUSY^v`MRsPPN[^wWLG\ gP.aWaTEVT)VBT6TSweTP}	vgP.WH+WAY\VRNWP+]MS Q}bELg	Z[}yX\dV)d~L@[M["VfUCJe+e_ddRz2^[L}P
]Z.aWO[`GvVT)RSN@2[SwW(RWTb\U{Z.[ZWs_L)RSHP2*Gw["Vba	\UuDJ[[aCRydfLz2@]S Q}TcE\.e+Wn[\Z@` T@6WSw[	OzqSCGT%[ U_s{^/E\MZ_YXPh__XVGA(HQXT_uwX	R{XNG_WLR~a\[l_Y(D
=rSCQ^PIG_D5AH@
L@G\pp]GUDPT^VkZUAN|AqWm@cd_FPQTEpE*YYRZZqX
Lq[`^AE-H(@U^pC,t$HdpwJhL_VIck*Q uu^yP<px.a}~DRVKQ  2Q([^uZ{Pd^~NStG~@qVuYx VK.Q=IIZCS/pu|&!Y SUVEt-WQ>OW[peS<JS/tGhvWwrg"4NOfLZ^RzPZ]SLTT\cE\.aWaqEv`)`QP 9BMSJPQv]EJWO \vZM`Q@23EMWPWfvgFe-aq^LZtRoH \w_RKPr	].S5Oah]\VQ)RnRT\wS Q}Prcw^}"ANU}"[V~YqLa^V`^CWV^XUZ/w\M|BqLJ{@u^_]D
nT_uwX,{XL J]aO{O_HB]\(	bHQHcYPw\M~@PKhq\
sZZB(-rTF[ X/YUZ1EYL
L{G\s|\[UzXUZXcYE]_|,[xwJiztVuv[Q(CouFFS?|ot_Wy~BV[wa;KWQP t rAPR[.Jy]f`V`ES8eR=yW cFrP*ZClW_3~DBVu]zUq 4'OfSKB5`Q2)^]W(RWb`UhEJe0+aO\^V)VxQ6UDw_NQbxvUBXS)O \vR)` HPLYwW8KT\U]ZeO[[CvVzMdTP T\MS Q}	vUx\W[z]ZRDWP2^[L}P
UUG["e\\db)|v__W|YZvYsNZA vSfTC[^Rw\MlBr^x]
s|\X-\
/LTEu{X{ZV|\ZfOe_F]CVzP~W@K]ZQcZWZ-Gq
Lx}_
rN_ZfSPTDcwC/IZTW1AsD
L@G^V`\DWX-T_IEERQ\M~V]tr
L]W\pAY-X@WCHE^/A]_|,[xwJiztV[wa;KWQP t`ZTP?VpT6+sQDuVIQ8q9SSOuBwPR`l" tG&~\|VI] VK.QQOtuBrPSJybu.DuVcw _RQ>uwJxPx_~NStCV~fUrUUq 4'OfSKB5dpRPL\eWQGfvUDCS;[`Bv` MdfR@N[^waSXSvQ~^Je'OWaDVS^uSLY]WMbDvcuCS.e_RQ`V6W^]W8Kfvg^.e(
WBZ\|tDA[qQ[W|^xO]Xd]G
-XTFpgY/ZW-ZHPO{O]
s|ZBWH@HQHcERI[HWVDZT]a_p^^D(X-~QQs ZQgYNT)GqW~_^	VB\^ (bS@KY? [NZ!@U}_KZ_Zf-UYs{XUXLW!^J@^{|/
ug)sHR-uu uBGP<px &a}~DRVKQ  2SSOu`SPJDyt_WPv`UcMU/Q=SX`}P?BXZ/O,~wUuW-Q}PIJPP}lZu1hLV}8CQ([JxS*mE Qbuk\GV[wa;KWQP tBpS*myshvTM|-[-QRWzX`MPJU &Hq)~DwVIsy aSPPu{fz
B5K@h@2Z_W(RWbxLcZ_J[LOawCRmRzUEa0SGPQvc`C.eeQvR~R|S6Z^W(RWPQv]YXJ[ [Lxt)ZsNP6W^]_%OWf	\c~BJ[+Wq]\Ryd_*"SM} WfBF } 	T%
.LU[r[	\M|VYsIP_FpN\Z*\WCK^/ XN	Sqz^x/
ug)sHQ>uX^PQ`Y6G$]DdVua[1QQG} rt_S-Vd.OY~\DVKAY[QC~[[RQJzDN5C~jVu]p aQ=j`SP*BpT6Ye ~D|VV{wUq 4'OfSKB5RT_z22^Ma0M}b@\cu]JS:OaUF\d{MZ~Jz \wW'VGTvLUUAe[+Wq]\VT)Z_W_MYTG~qvUx\e +_[\^})VCQP6Z[wy ^G~qmCGT%[ U_s{YPEZJT=@ZrRx}]RZBz	bUYs{XU[No5AsO{O_HB]\(	bHQHc^EZLFbr^e_ZB(@
nN@pIYgXWDZs\Vx}]IR]A;b/V[VgY/GVy^W@
L{q@ul]\jnRQpz)Urh}$Ha_~VHwc;Q>uwJxPpgoW -@~XVIM{8u Q(_tHYP*Jf.C@DVcwcGSQS@X`pS*d@lO,@ V`]F-eQ(GuZ^P*Z}l$b}hvTM|VG*Q(Gw`tVP*Z{& d{iXMG3L]ZW)OW_]\RP	MdTIz*_]eVK}TT\cE\.aW
+avZRbdfSPN[^waH}Ty\cF]JS;ay[\Z)RNWP ]]YS}f	\QWGS:OeQv` )dxV2[wYS}TT\YgAJW)a[Evdg`M@2 Ew_NTWbxvgFe +SV\\`M`P@5Gw[)SfcZZW+W_]\RV)|v__W|YZv@HdZBD.~VCZRU\MZ^a~WSm\[`_[PzV[Vg[	,GTWJBqLS@q\r^]CV~PT\YX,w\MZ^zIy[\rR\X+z-LUD^/wZW=SW{q[I`]_ 
nTEV{[	g[K|JFYXSO]
`B^AT
/\SCpwZUZQlVSIx]
K|ZA8	- z
r5.rlbOBTVEtq3R>OyP`yJ}	h@UWwrg"4NOfLR|RTQP6UYW-QWbQP_.e2aZ[dg)VTQ6U\MeUP	vca\W,+[{Yd}
)dfRPP@WRMbLUHXS _X`RSHPN[^w_ S}bG	YRB.W,OeXd `RP2'^W8KTzLUx\[.+SY^vRRMdCSzN[^wW+^}f\gAJW	a[GvdBM^TMz ,][VGbz	\{pPE  U}\,I[K|JZt\S]C[Xp\PVbzSCw^?YANJ
SrYut3quq Q(GuFmPf.W_3~iVV{K;WQ(_ct\RQJzyN9aSSf@V`]C-GQ(_VZgP*Zy Naq5~WVc|;qSQ=aOBpS?x]ytG-LrWVwUg"4NOfLxt)` Q@2E]W(RWbU{Ae2+a~Ev)dfLz23XweVUGf	vQWG_!OWy\L` )dAMP2H\]a0M}bvvQP_.e2O \vVGMVrL@ ZYMaLWfvcZFaWap^LddM^[JPN[S]} WWXTLc{]W+aO\^V)VxQ2,]]aJ}bF\Ux\[+[z]|tDA[qQ[W|SB]rN\^+z(~TB[RYR\DJ{@u^_]DU_s{Z-IAN|XrWh\u|\Z*	RrSCuAY*g[PW!YWb
L]C]lGA(H
LV^uQZ
EZQ-^rL
LyZp}	{RsH4,w`CP<pl2s}QVu];q'RaLBpS*myQtG-]\bV`U[R- J p|P?BG.I7@VU`[[QaXS?Vz &tG-]zvWwrg"4NOfL`d@R2*Gwa
Ibc	vcF]J_ +Sw_VG`QP6W^]SIWb[LcF\SyyQSDC"[qR^JrWy__
l\Z*DT\ckX<cYQXHPO{O]cp\P+jSzVCX<c\M|VBPJ{@u^_]D-LS@`Q^R[K|JZt\S]C[pp^_-X/bUQs[	gZWyFbrWSm^pBGA(HQTS@uI^?\MDsX
L{\p`]_V@/DU_`w^PkYPyBqLJ~}[pZA+@@U[sc[	gZTyR]r~I@C\pp[P({[(WwfqrP*ZvE !G$Pv`UcMU/QSAFeP<JXob~\{VVAT "Q}bcJSP[ZN)Hu5{PAV[QI_/Q uJxP*Zy 6sQPvHV[QHVG3QQT `taRQJzy4WyyTrVc|[1QTuZtPJ_lW5CDuV`UKS;PPu{fz
B5K@h@"^wW(RW\\]BaV
OWAY\^mVS_zN[^w[K}f
LcF_[+aE\ZM`Q@ ^]aJKG\ \Yy]W+SrG\daRbN@2*GwW9^W\\QP_.aW+WRB\RR^tW2&By ^XBF } 	T%RDTB{ZQcXPZYWb^Ce\p`\Y@/bW@YY-YGUE!YHrS}^BGA(H	SbWF]Y?AXJ]r~R]O\pAY-X@U_ccXQYUZ1FO{O]
s|^PDS@sAZc]_|,[xwJiztV`G-CQ(_uZtP*ZF 6PtGWL}VIM{-G"Q([q`CP*F[l&"ODuTM|(q.Q(_mcpP?d@W C1B\FVV]cTC&QaBuBRQJzZ1CSVu]-KR/ HuFP*ayUWG~bGVXcUq 4'OfSKB5RsK2*Gw_NTWXx	v	].e%+_GdsR WP6U\Ma*TXx	{pPE  U}^<\M|V[ZSG_F]CVzXW^VwY/gYUZ1BsbUCFsFXP+H-TS@rg[	SEZPJ^rT
L~G\
IBA_U\HQY[	g[R -GbQG]Xl]\*T-~QQs X,{[V~BfLBm_Z\X-T>rU[IUXUYUZ1_aDK[_F]CVz	- z
r5.roW
a[/DuV[wa;KWQP tKx]PJ}T6aq ~VVUc VK.Q=IIZCS* ZN3JS	kTjVEt;WR=qlJTQ	pTy.C9kPwVXgy eZQ(GcpmRQJQl $Ye)Sb	VuEv VK.Q_j rRwPdT2ZG$]~VuV-["RqJxS-GyWkrdVcw8eQ_NVZgPSBr&  WuiqG3SLFgy"
+al@v)RTQP FweWPf	vcFD[_NZ\xvVP*_]_XLbZvgP.W_NBv^wM|v__W|YZv\pAY-X@SCU[?wXP@~LCC[cdZB(@	bS@sYYAN|EYL
L{G[uB]^XSDT^EC/IYIVGtQS_\
IBZB(v-@U_c{Y*wZQ-ZYzPkZp}	{RsH4,w[peS<JS/Y STsVMS+_,Q(_t[tMS/ZD.t_VkD_VIMU[1R(ZI`QRpthv\dRNiGPV\Ys\Je0+eZLV])R}UN[^wWLWTSvg]S:OaT@\d~RMTPN[^wW+^}f\Ux\[L
a[\dd`_z;S]_WJGXhL	].WTaqEv`)ZMP \wWRWba	L]D[LOeZL|tDA[qQ[W|
L{[IZB(TV[VgY/GVy^W@O{O[ZA;D.~WYVEX YJlBtLT]a]uZ\Y*H~TQcI^/EAN|EYL
L{G@[F_Y8v.~WCKE	PAYUZ1BY\O[_ZB(@
nRQpz)Urh}$Hd{iXMG3SCGT%^