fzql'}DsTI>;DEGt~PLU
Y'\LTA#v ~GvEp j hEB$xffWr{*\~_dZxN*Tp~AJl'VAlWcE-sB_G~|Fj hEBoO*APTVE-Xx~GvNy;Pg]sBV zW`w2VHU]uRT`-DuI~T }YTcwVHvk_CoR-DuI~z5SpT[I'-YO| B -DKkYDWRShPyT`Q(-@MurZtP;vA~AtFR9k@ETA#*PPOV;bIaV zW`w2VHU]uRoBQ  ~AJ k@QTXTXfkGWtL-\|kBF}DMTuA!;fOsZtPh"EfXHDgCWPG
\g^.bXGa	\zRNbEEW]CACX@DPv]'ZJfW}aDG@Z|R.\BGg|BOYZ~\uvg/G.bXGaDG@Z|R.PS^}QkCC3 ]TbvUMBTVD}W~CP`CPTWZ]QFC*CTf cP\X@GaEXz`LfZ}UQCy.@TT\gZbXGaC`AH.
\}Q|GSW~f vcPAb W}[hGPRMJf]WY^_C	A~vUQ_JPP^eZ`eR
\}gXyJFTbC	LQXJ\VAGWz@P^UJTB}gFGyUATTRvU\.T]WWT_ZVITZc_CQ\\g_.Z}_pYz`eRbE^GQV[	ADbdvQ-GfV^Ge[@`Qf_GrP\Su}ZWD]D]ZE[WC^@yt]ADW\}Xut
AC_E{DGE|MYVSB[B_Dz,XWXpVA(GY@PL]YGAX_;GBFSEAWxOXrtB[F]E YYQWWY@k^YF]GX^Z8uY^BPA^E[JVaBQh`EA|W{OYsxA}ZY~~_^Zc[_(}^GkR_G}
ECGBpJS[XYxD^E A[W8OYC]RXAl4YACXK`
][ZZ@r]]~]DV(q]F]xXA|,WPBpJ
\[W{n^Ac_MWY@St^ZS@z[[Z	Dy[D\Z_MWO^^R_G@zSDst]8u_En]XT{BN(OY@St]]D ^z_Xux
DX@P_^ZcXV*_^C]BXB
F{}YX
_*WBF{~\@D_MC^E~x^P4WeYp
D*_XWhDZFs_M8_D@{JXBW^xq[VxA(GXZ@@]ToEDH YC]RYP(W{-
qMd)phuByFsLU
$zPTI>;DEOc u* kwg  ^vWTVY4-Xz~_}l8rS SgGY3}@GTuE- bDhuuyBu-X{hgx kDW`w2*PvSa||U chgx #^vP1z	dIC`Ga	\zRNTsX}UzDS33_DfLcP\bCGWT_ZVIPS^}]ZYS3
D~\Bv]$_J]}p]z^u_bB^G]y7X_~XUL]$_Jf]}e[@^U.TQ_Wc
Xy WTbrvQ/_fe\	]`sR\s^WYECy7WXDfvg6].b ZWWhAVMWTQ_WgbPNXfvY'SfrB}WxXP`vUPS^}]_ESOYZ~T~vcQDb_}S~@z`WI.bEEWg_AS3FTf
\Q$FJZ}WxXPd QJb}CUZS7X_~bvL]
FZ}a]EP`XNPy]GgxD*[Dbc_[.Z}StG@`eRfQ}cZC3$FbvLg
BbXGSSGzV{HP[Wc
XyBf LQDZ}e\z^Vf_g|B	%FTf \U3E.b Ya~FdP
\}gbP3Z~XX\Q/_X^_\`}LJP[ZrPC/ ^eBB}^W%Y^BPA^EXS*OYC]R_A} FCZVd	FTZBx~_]ls[JVaBQh`EA|W{O_Xt
^WCZEX\ZZIWYC{B^YW<\hGBsSa_FSr__~]_M(\ZyZXBD(XGXV|]+yX[{fACTXT8GD@xZP|W[zO_VRZWD]D_^Zc[JT^@yt]ADWXh_Y`hB;KYWx^T|gZQW\^~R_\SFxqX`	FVeDWhfGEE]_+O]Q{x_FoFxO_Xt	BT__EyD\Y s[J^@]Z_GTWFxO_ptB+CXX~\ZXK(WBFS\]WkGX[EW_E{D\]ToXS(D@{J^^|,C}}_K|	\WCX\]zZETsXS(eBFS_\Wxy]s ^xRp`zwEl;@C@{[Y+h\CWpUTLhGay*~Atz hXT[IVOW Fq-LS yXDqTcEWaO|yWL`r}OQhr`VI rWSayFsVL {sqo3}PRTuHu ANfTDwI~Y3CTcI	-Xxk lpU bFI~7}\zTuA! bU~[wZ^f-@APsKoO}@XTcs" f@~Gvtw;vvS~W3^\fT[sHuSS}lRs fzBY|W7DqWp-rLO|y^u S~W}O#A\{TXcU~@yEoR;PAv'"^vP1z	dIC`G}p]z`XNf^G]y WTbD	LQ/_\pFW_GGzdPT{]Wg|B3#]DXX\cP\Z}W{TzdHfY}gDDS3FTbX\c^_PvBeZ`eHJ
QWQj]C3
ATTW\U\.b_}a^PRUP.
\}QyPy7V@TbfLcQ]f_AWaF@PRaKT{]WQWGS7YEDbu\c_[.Z}e\z`CKb^@Wg_AS7WAbdgGX\Z}e[@xu_~sXWQV[	ADPR\]$_Jf_}SEPVmJJbEGU]YTbg
BbXG	Yz^|IbEWc]S_TTuLcS].XBD}[uEPVMWPgG}c_C7JFbvg6[JXBD}[sXU~sX}]pX3FTbe^SP}[WSEZPdW.PS^}QiZC	
[~zuL{'Z5FBSv	Pq [_(O^]{_A} FCX	`ZZ i_E]TZF~EZT+O]XxJXB [}CBpJ\-SX[{]@y_M(C^\@F_Pl@P_VRB(K[W{L\]EQDUWG__PXBYEC_Zsd
B(uX@@_EoQXQ+S_[{_G}
]kG_pBYe[ZL]YooBN(O^FP^]]D ^z_[Vx
G(SYWf^CZX_;G\[]d\][^OY`tZ(u[@]~_^ZcYV;q_ZB^CPWXA[_pFZ iBF{L^E YYW-S_[{_G}
XWXpVA+K[@P_^ZcYTVW^Qx^^^oW
Ex_sBZ(_DWhP\E|BN(O]Q{J_GT
WkG[JYeY\T]TYYQ8YC{XA|XGZKtSUiXX@n[T|~tRtfzqTTuY*f~[}ot{vJPIrW-hPsTXc.\USe`Ny;@U~Yz6XW`w2-DSeA|REPJ hAcY71DqTuY'8XyUE^{ fBPstz @nTI>;DEP_\EX{ScRz-^zrWrQ$8vUO|ZUf BklzTK{H~kaKxVL~tF}@cWpUTLPulRy-kBYEF+~T`Q TPUO|oBS-\ {UBTC~\TII,-@xkaxyRRj hEBl3&hPdTuY'-XxO|WtLT@]_oPUTuA!*T~P i|REPJPzPvVI+\u~C]C;L]]cUoS}T`Q TPUO|oBSY~oPUTuE- bDyWsT` b~Io';}LT`s<lhC@twh"EfXHDgC Z~beLg^[.TFWas^@dPfQ}cFC\DXs].^.XqYG	Yzd _.fGGQ_S"[DTM\Y6Z.Z}aRBzRsJ.f^GcPy7VFTPM\^^.Xz@}S\zVeJXt\W]yXTb}vUY.f@[}[yYzdNJP[WQV[	ADPFcR]bXGWxEZlL.zsQGg
\\XVLU]JTPW}a	\zRNPQXUR_yBPPvQ<Y\_[}aS]@V}NJbc\GQrGS3N]TTpYSbZGaZ@d QP{D}YC@Tb{gRFf_}SEPRFJJPP[}gG\yOYZ~\uvg^[.TFWSRZ`}K.bc\GYYC3N]T\Bv]$_J]G}p]z^u_bB^G]y7X_~b}g-E.Z}WxXP^|IbEWQWGS3CTbX\^^.b_}aF@P`WI.XqYg_AS3FTbP
vUS.Z}SEZPRP_.bcQ]_ES3CT\\v'Szu^fAGPq[%^]yJXBYFzqZKYe[B\]EQDUWGY@@\P,Wx}XI
FZ]]b]]osXV*_YC]R_BY
ExGBpJSVaZ^{@]E~sZNY@xB^PS
Eh_XcBS(}[W{L]E~sZN\[d^]G<^kqXrZASY^BPA^EZUa_Zx\AD
FxOXpRYT[XBhr\_y XV*_YC]R\_ D}ZVd	\_E{DGE|M[JVaBQh`EA|W{O[px
E8SBF{L\T| _M8__Y~VEAY{}XcBYe[F\^\lMXS*SD@{x]Y^hqYp^[TYB~z]X~QBN(}[Qx {%J`ytTI>;DEO}yFsTL~PITRXxbTuY-TDmS`lRyTDw {P ,xXMTK_}SaNy;ProO(}\zWcc<VHy{u|T`8{kaR}DsTuY'-XEkS~VvTDw hUFW/8LyTuIHuk[~8rfIRY'^rDVI+}BO{TxRLKI~zV&A\BWps$8fG]_coRA-U~YrzhPzWrQ$T@qhSDT|m;byI~Y'.}X}T`H~~_plZBW~j l3*LvTIY-S~_otp-kBYEY3}\zTcs";fOWZtPh"EfXHDgC30B~f	LQXJ\VAGSP[z^BVb
Y}UAS[Tf	LU_XBD}[sXU~sX}YrPS3XDvg/YP~ZWe\zd RTkDYECy7WXD\A\Q/_fcWGe\z`eTJ
\}QyPy7V@TT}
\gGTVD}W~CPVxNJf^GcPy3+BP]U@JfbYG	YzdW.f\W]PPyWTbvQ,]JZ}WxXP`c_fY}gDDS	Z~zuL{'ZXBD}aDYz`W.P@WgDDS3
ETf	LcRS.fP\SK_@ZsQJXz\}Yv^C	 [Db}vcP\PQ\[SB@RUP.bkB}YBS+ WDTQ]ETWYSUTz^]IJb
Y}UAS	 WTb}vg?@.XEWSP[zZ^VJPxGWgP	)Z~bvQ?FJTa^}_R]zR.PwBGgb]C3CTTLg^[.TFW[pTP`}K.bkB}YBS X~fU,EfeAax@zdPbkB}]{]y+ W[BB}^W%Y^BPA^EYP y_^S|]ZY0[^qXKJZ8uBF{L]^s_M-G^FP^^P4@^}XpR	BT__E__M[V+OY@^],]^aYRXVeD\PZF|s_MCXQ{|\PFzqZK	DUyY^BPA^EXS(eYC]R\_ D}Xu^Ye[ZLGE|M_N]^B_C,
EkX
p`ASXZfGE|M[_(O^]{XB}0
ECGXux	BT__Ek\ZETs_M(q^\`^^|,
ExqX`YeXC~~\ZZE[NT[BYP^Zl@{q[`
\aYZ]XZFZU^_(y^]{`_EY@PX
p
B*uZF@^E ]YU*_ECx^Y
B@[YIVYWC_E{@]FZEBN(O]Q{J^Z}KXGXxA(GXZ@@]@|UZWS\DPVCPWY}S_VR
\VCY^SnGE|MYQ8^[_^z Y}DdS(x|wc}v(vPITRX}\uTuIXhSEl;@CPsKW8hbTA#*kqeNUvQ {sqo3A\{TXcT@q{RytL\`PUJ1z]TXg_-@sO|ySTL~Il'LvTI
H~~CpyZ}*Tp yw_o3'DqTVY1(rryWsEBfAv'"^vPWps+HS l^nrz~AtF#)PfWrV8v`OPZtW-\|c\z&}STuY' UPuIT`-DuI~z h\|W`_XB~V~TDwk'"^vP1z	dIC`G[PY`eRTWZ]QFC"ETf	LU%Af_D}SCRJ\DB}]q\OY]D~uv]%[JfXFWa`C_f\WY_ WTbrvU]PmZGaZBPdW.b}CQ|GS([TTaLgDTUX}WiG@`uUT{]WcEyWTbrvg)AJb W}_]^PbQGgiXCOYWTTW\g
Bf_]Ge]z^XNJXQQ}Y^PS.C~fvg4[WWWxXPdVJXv@Wgz[3FTT 	\g(XbXG	Yz^UTUBQj]C3
ATf \gAPm[a	[zZaU
\}c]S7Y]Db|LU)G.\WW}_\TPRUP.fX}Y_A_TTW\cSG.TUX}Wu[P`sLf^GrPC/ ^eBB}^W%Y^BPA^E[JVa^D]J_A} FC[
BT_[BbATogBN+G[QxJ_GTW
E^WBpJ	S(yXAkTGE|MXRWG]F]x^Y

FPqXrZB(K[FXZFEA_MC_Qh^Xz
^zOXuxY*XC{A_ DW_D@{J^^|,Wx}X`RSa_Ek\^TTEYU(__kXBW
F{GZHSaZ@ZEl ZMS\[]dC[|
BZVdB(KYYkrZFoYQ+}YCJ]]D ^z__c
_(aD@P~]_E[LeYC]REAC}}Y^S__Fx~\TTXS*SD@{xZP|WBaXVJ
B*uZF@]@yYQG\QS__T4
ExG_VRB(KZX~T]X| YQ}\Xkt^YF]GX	VF*yYED]Zys_MW^C]BXBWx|-
qMd)pOByFy fB~YXzWkvpWu.\USaEot{;L]PITRXhvvTI>;DEk TYvZAvz}\TI>;DE~_plVzc kQ`TTuY*8}{S@WRL~ZBIy}OJzDT[IVBSA|8]_SPLVI+Ubhu~y^_-\C~Az }bT`Q-\C{RNy bhEVWRShPsTXc.\USe`twLU
FAXTIY~NCZXV@hBklzT`w.T@q~vE^Bj hEBW,hXzTHWThSlR8BUuDU}@uTu]/T@qylp| fCScRz&LyTV]'-DXPuIG|\;v]cc'"`rC1SHdXuZ}ax^@`}K.bFFGQTXS3
ATPv\g#BJfdY}eY@d _.TjQWUBYy7WXDb|LQDPeWGeYdPTWZ]QFCD~Xv
^Yzu^}WT_ZVIb\]}g]\yOYZ~TmvgEf_}SEP`dJJ\XQz\SD~f	Lg@fBWWk^@d QfY}gFCCYT\vLc^YZ}WxXPR{K.bQG}gcE3CTTd
vg,^ffYG_GZPdW.
\}Qz\S;]Df LgZf{EaeZzR.TWZ]QFC3[~bZ
vg6FJXYWWS^PV}Sbz^GgX_3JY~b_LgM].f_]Ga]EP`e_JPS^}ggGCOYWT~umGW%Sv\]EQDUWGYC{t]Z0WXVZ
XKYByz]C~YZ_m^^~EA]q_uB
D_[@X]EEQXH*[\QPh__zKF^_Yr@-GYCL]YZQ-}D@{J^Y
\WXuxSVa_E{rZF~EXJ [^DhtXB \}BpJA(uZ^{@]@y[J[YC@B_[FY}}BpJ]8u_En\]EQDUWG^]yJ_G}
WSmX	u	FVe_Eh^CZXRC^D@RC_F^_YrET[XXPbGE|M_N]@_A
YAeZ`t
D*_ZWPn][y[JVaBQh`EA|W{OX[
X8CBF{~]EogZP-W_Dy|\AS
FPqXKFASX\kDGE|_M(qY@xB__zK
FPqY`
_(a_ErZFl][LT__xx\E0
Exq_pF]+yZ^{@_]|AYQ+}_Z~^XB 
ExCD	G-yXWhD_F Y_N q^]{`_GTW]{CBpxS+|wc}v;vABkl}nTu]/*SeAp8f~]UTR(A\BWXE?8f~ ZF`TsBklzWpUTL]yKotp-@s~]z ,xvyT[IVO}l^C-\Y~YBzW}nTHsU-\RP xE^B @kkg ,}TV]2P@~G|yF* kwg  ^vWTu-DG~AZ`]b[ {wxl'LvTVY4~NhCTl`G8~At'"^vPTcs-@sPOVTDw yWFR9k@ETc{+ bDq ld-WPiT4}DsTuY*Xeot{8{PIrW-@ZTE*[y NyLU
oOxzTIU f}p NxTs~YXz}DT`S-@s~_pl^vgI~7Skv{T[IVPuITZ-_kz&hbGT`R Urw`qFc_OChb]gXyJFTb}vcP\frB}aaFzRUP.TjBGgrZS3(]~b_\]MYX^aRBz`W.P@Wgb]C	_D\cP\f^GawAz`AH.
\}gXyJFTb}Lg_.b Yax^z`_IX[WgDDS3YW~bdY@.\v[	^@|uV.\sQWQWAOYZ~bvU+YJbYGaZBP`KP\gPy3YPPvQ,]Jf_X}S`[@VUTJTVQ}]u\C30@PU	vcP]JPpXWe[@R.b
Y}]QFCD~\|LgUGb@Wa{YPdVJTkDQR[W~Xr
Lg7DJTUX}eF@R.bDCWQR[W~Xr
Lg7DJb^WG_z^_JPuXQp^SOYZ~T~vcQDfCCW_]V}SPgEYEC3.Eb Lg-Ef_}S|^`MP@_cYS3'A~brvg6A.f{Ee[@R.T{]WUP^ATbvU+YJb W}eB@^VJbY^}Ub_C	BDbALQ]b]a^Pd R\^QWGS+W~f\Q/_fCCWa`YzVqRJfZGUR_y4C\BcP\~uWG}p]a@B[%
Uv_\}
E^WXsZ
D*_DFBX_^Zc[JT^@yt]ADWWC[_VRS_X@~b^AcD_;eD@xBZP|F^_X[B(K_F][T]XP O^\Z\A

EzGX
p
F;W[DPP]EEQXN_^FPEA]z_Xr^]+y_ELZFoD_V]Fx\AFzqXrV
_WiX[]LAB ]XH*S^]hXBYFxOYsxYV[_F~\Z_MWO^FyV_EDFeD	J^uX^y\ATXJV[YCRXB ^x[_VRA(uXBBD_^Zc_MW]F`EAW_sB
B[Z]\ZE_MTWYCJEAYhq_h^uX^y\\ZZE_NT^^SZ__WZ_ZVdAGYWn][T]D_W_YCCd]B

Eza_rBACXB]L][T]YK}_X{^C[ S_A_BpJ]+yZ]\ZE_MTWYCJXB}0
EzG_pt
FC_FxD_F YYQ+}YCJXB 
EzGYx\(Z]]b_AocXH(\[]dYP(W{-
qMd)phuByFsLU
$zPT`Y? bDP kyQh{z&~TXcV*v[eotyfbPITRXDqWrVHy{u|ot{LU
@@T[I'8^ylp`VLS]sPo8PfDW[<VHy~V~Cj ksRO}\uTuY*-Dc~ANyc kQ`z6}@GTuY'-XxO|EZU-\ykY3PTcs" f@O|l^CP ksizV^eT`](8] ]y^_-\C~Al'LvT`g(l~CfyBG-\| yX}O&}PBVI+-mBO{E^[ fB~YoV(}STuEUDGtZt{-X{Cs F+C~\TII,rkaNy8PkAQ$hbqT[I -DGGtydY8d~YrWR hzTE<-Dc~CBlFQ-DuI~ R9A\BTVY4-DGCkl`qLT~E@$PbcWug6VHySWrEW-D@~YxF+}L_TH3-p~_]lRzTDwI~zVzCT[>8rv~_pyFV\`Bc	kv{TA#zr{GIoNMV@h~EdzLyWr-Dc~CBT`PB{D/V^f}TuI8^urZtPh"EfXHDgC3Y_~P\U\.XB^Wax^@^BL.bG\}gzZy3
ATX\gGTwEWSUTz`_L.\DB}]q\OY]D~uvY'SPPF	YzVaNbQgbGOYWTTnLcR]P}[We	^@`{MJT}FWc[C7VB~f vc_^b W}_ G`{MJ\sQWQWA3DDX|vU\.Z}_pYzVmI.bYGWc^3/Y~fvYWG.feZGWxXPdJ.fX]wAS3JY~bC\g @.Z}eYP^PJTQQ}gb]C3(]~b_\]MY\|[W_pTPVPNJfXgu^y3^DbAL]<EX|AGa@PRUP.bYGcBC7WXDvY'^.fZ]GSP[dVJbQG}gdYS X~bLcR^f_]GeZ`eR\DB}g|B+FDP[gYJfE]aFY`ZS.f^G]y3TDDf vY@.bYGaZBPd _.bG[GcZC3XDP[gYJfE]aC@VPHzsQGQPPy30ZDbdLg,Eb YWxXP^VJb
Y}U~Z32Z~bv]Eb W}_ G`cVb{E}c_C3JY~TnL'SXuZ}WhBz`_IbzCGgxZ X~br	vg^ZJf_@[uBz`}PbEGU]3XD\Lg(XPxFWUCPVHXgQ}c_COYZ~bdLQ]f|_}eB@VMWTQ_WQxGS	4W~PU	vQ/_P~FGe_@dJ.f^GY]X7WXDf vcR]JPpXWavGPR.fZGcEyD~bdLQ?FJfV^GaDG@dSTpDc_COYZ~TM\Q]f|EGa~FR{ITxQ}cGS_TTW\YVDfz\W	YzV}SbEEWgD3Xf	L]%[Jb]W}E^Hb|ZWQWGS*@TXavg \.f^eAzRUP.TyFW]fPy	)[TX]\U@.P{@WaF[@R{K.Xz]WUZS7V\DfvcP\~uWGas^@RUP.PS^}QzZy6\T}
\cQF.fREGWRAz`dJJfFWYECy8BbrvY"Z.Z}aG@VMWTQ_WggFC7UADbr	vg^ZJfd\e[@VBT.\QcGS	)ZTPU	vc^D.Z}[uEPVmJJfQ}cZ BD\w\cS]Jb@}ypT@|uV5BDUvTrS[zO_VR
]+[X@yXAEEYZUa]D_A} FCYx\(Z]]b_TGY_MW\Q@^_Gz0X}WX
p
B(uXZf^AcD_;eD@xBZP|
FPqXcBYeXF]\]CWBN(O^\k`XB
Ex[AXF]nZFZUYU*_^Fy^__YACZVd
\8eXFxZFM^_(y_DPF]GlS
F{GDH`	B_Z]]b\ToXPm_Q{XBo_}S_VRB(KZE@f\_GsZUa]@F]FWx_`Z[-W_E]TGE|MXJV[]@^_B}S
ECGZVd	FVWXWkP]CZ{_N;mD@xZP|TY|t1qqMd"C`XNFc_@B[%
Uv{%J