5-r(zy/}jEwe IDeAS;AT_Y[fdvoNXh^wWPHTaTZFS%ETWF@~*V`v] }XaGe _~WXV[5PTSPFDb}`v] }XOAwW\LD}#UTY{wdyt!1DC}Yv_|{wSS#AaQOhPyP<pfTwS@z GqAWPju; O|}\uP)ZDTXoS~H YeZxeM_*Gthz[P<ZrWrsS]Tl J[}C%O,PakvpPPRTI$SPzo aF}C%_ PyFLyP
B~TK{QSknWay[hq1h kv{P
^{TuAUS]Tt W~}C%\+urpeBB!}/6q OeRNChXs{pr^{~^@Sq_,AYKN{CUYan_NkHZQfAf_Y^aD	SEchxKQRrLYVx\AB~YxX_SC_.gY`JxQRrzhrbYNgV	xt5-r(zy/}nT@]WpQDS'^VS _~WzF~\Nd^v]\\RwW}STZX|W$Xe\DP~Nd|o0GXj]ePDS0Za
C~ypSV)Vr1qyJ"fNNV|[u{pwh\}\uP)ZDTXoSH} a ^_6QO CuSnP`TIkJSkX JuK/u%k}|CvPZEU{"Ph\M Y}O
GtPbNP)BWrQQ@YWuW}[#O he^\fP`mTK	SH} HShq8O,^_kPS<VxTKs	S~HOy} Qu@ypAXP)ZyTwSkPO GqkKCWTku_LyP<CT`QS~@S u}C%u"^uUpeBB!}/6q OeRNChXs{prGSX^B_.AYBmHR_MxGXAxL^GxeX XulyWT^qBNxHXT
BxrZAzGXc^KJmNCrD]_{HBCTX^TGBxO_wY
aUArPYN@z	G\TPxzXS{z5&
B1S@6U	 ywhysI{pw~~Wx_TfNZY*GXqC[lI~WU_V_FTayADTP Ls }jZweJ~e*GFa.Ba`DzuxthY*xepw|eEQwYTuV}rtSP)Z^TuQSSnB tGPWxS&}Gv}\uPPJVA,S~P aG[}e_*h S\AP
ZgWpkPy~R HOzq!;@uDqPdTuI-Q@us D^[0\eh_FAL~P)BWT`QS]TLOy^QO Pa}@GPPBpTVU-PyOU^q_/e^}DsRRJxTVQ3P{\I ZSLSK'Quzq|}DsQQpvTu
S~LK a Pa5i}Oc^rBP?p[U{"R]z\qlAB[uZQw/grFd[MC5rR(z|
ymS@sD_MC@\BrB@L]_x_,wZ[^KT_J@[NX[\D^}AX_ZP]Y	[h
{KS@WT^_x~[y~
BA\ODY
{qT^qBNxH[\D^h@\Z@GX
IYc|~WWYXQ}v	G\TCSb_B}__,EEXt{uWE~XQ}vBxXGk]_xB,IZV
xCWEZ_Mx]B@
BT\G@}Y	)Q^VZk
URsD^_x{,bpg[NFdV)Vr1qyJ/qx_|wWTeX|WJXTaSZDb}*R|U9} _wSWQ[UVeUG~eEDbXN`LkJW\}AMWvJTS @VW7E~WgF~PU*VG\o}\IYadW[IGVy PDWx_TT VS\oWjGwaWI~[M_V[)]~	^~Xn*`	L]'TPCMW}STaW[a
[D	^~bC Rl]WPV]MW}STWZ|W+P~WR]T\[*Z]vkUGXLZMyu_DaIDSC~W~DTbW*dLkUGP@Me QaTZFy PV	xt5-r%mOv V|SqrsRaX}[w}XxP?pzVA,S~PS t_E}CTjyX}_phD[P)Z{T`IQ@u ZuLPe[jy1AO^hrP)ZtWpQRz{qlAB[uZQw/grFd[MC5rR(z|xWEXXQ}vUCDEkrADS_
QY
p{CU\r~_M}D[B\G^~\GhyD?cCsJxCWRXRCDGX^{~]BxaZ]Y
ph]mU[YnXS{TDyP{drC5KB1^Y*xepwqrs{|} Y~WrE~TpNddkV}j\wVy#\bY{wdyt!1DC}Yv_|{wS^qiG1} LyPdTc{%SH}ayhCSOt~PYU{"R]z\qlAB[uZQw/grFd[MC5rR(z|P[S@s_Mxv	GxDGSfZACGXwYI|P}S@WT_MxDXA@AxLAS@e_.AZHN
UFtbZ_D	DxbZ^b]DSe_AZRWT[s\XRABzbPxdrC5KB1^Y*xepwqrs{|W9X~Wt^Xl*vY(Wnh^]S{K~eGVaF~as@bvNVT	v]\\RwW}STW[y PV	xt5-r%mOv V|Sqrs\_3}_hD[PpAWrPyOU^q}_p@S)oTH{RSLb u}[,RC,eGkvlRRJSTcASCj~ Ye}[)i0}_p}LUP<`Tc{Rz{WuP|eEQwYTudrC5KB1Py/q}TEZX[NSDDQ@Z^b\_hS_
Q^pN~mRRqzhrbYNgV	xt5-r(zy/}Xq^]eNW7C|_P~_GFTT*de
\YGry[weW~S;@eU]TWhFf  `LQ}PN[]abQDZ\} Y`	xt5-r%mOv V|Sqrs\u^_c}LUP?ttU{"R]z\ Ya^a4eS OP ^vWP)^yT`U/S~Pv H_BSqi},PWfP~sS.Wu)Py\ tGskq:O^uUpeBB!}/6q OeRNChXs{pr^{~]__XQY[spP_U[YnBNxHBQXBPZA^W_,w^sJ~NCqL_MkFYhr_F{}_
QZ[^SaRRqzYQ{z[if
Ah_F{}_
QCpBPWS@bZIDCRL
Bx_F{}_
Q_pq/6q OeRNChVZ~ wJgyw}rtS,*R|
\]V\G][lJD_ YYZD}pZ~Xw
N`vkUGjRweQ~aVXV_RYWx_T\B*ZC\o7G [}uV`Z~ wJgywpeBB!}/qx_ YaG+G.AO{^XuP<BZTc8Q@u Z u@eZB}PetALVP)BrTuQ S@ OySq2RyGtzRRJTUV{S]Pj tCG}[,ja#z kDdP)Wu]SkPJ tGzRxur ^vP!1DC}Yvve{Ch[JbZw~rrXS{ODcZ
S}T[s\_MxvFQPZ^bAS@e_.AY[hSWNCqL_NPv	GL
A{D^ShGX.]Y
s^xQRrzhrbYNgV	xt5-r(zy/}nT@]WfPe	F|y PV	xt5-r%mOv V|Sqrs\uC}Y}DPPBpTI]SSkzbOyW _-hy}\zP)JTWrQPy\ bulKxqzPfDPPBpWcA S@~{ayCy
CO+ OW ^vP!1DC}Yvve{Ch[JbZw~rrXS{O_, Xr{CTEsXZHk	Gz_h~^FC_Y/{^BmWG^_x~Uy/grFd[MC5-
yJ6zx|{wSq~S+YVaNP[y^~f *^l\U%WT`AUDy#\|a
FTS]ZDbd*RL\YWTP@M[^RD[#Aa2]~aSX|*VVvY}\VR]e QWZ|W9CDapYTTu` vkYG\^E][vSa[]|eVE~_s]Db_ `	Lo3	GvyRM}uV`Z~ wJgywpeBB!}/qx_WuWh,B^_c}@GPpMTIQS~Pv tOUxu)Re O|^\fP)FFTuUS~@Y C }C1C3zSvLyP)ZtTI]PyrJ W@h0G& O|A\BS.RwT`9S]vH UC'u"^uUPbS.T`QP~baSyAWPO,@a	}\xP)JRTI
S~H YyCk},O,Pa@xS^FTu
1S~H b_q!vgATu	Wuz5&
B1S@6[x_|{rD_@b	GxDGSfZACGY
AEXCVD_Mx@\Rn\xGBxOX]X
`Z
{KS@WTYWhH@irPxz]S{yY.XuJ
~}VX@ZU^fUzz]Pb_@zqY. E	`{CS@t@DW_xZ@]YCY	]XKV]mHEHzXH}fDzL
A}r^F@}_PQ^B
hTAzZMD\ECrAZPyX,kXr{S@a\X_k@_\b
B^T[Sx|z5&
B1S@6U	 ywhysI{pw~~aS[~f `vQXu@Ma_UDZX|W(\TeS~f `LkTniRe RTeX|Y]~aFGTTxNdgvoWjGw_BL~Z_F} Y~e[~f*`vkUGj[e _~[SFa0Pa`DzuxthY*xepw|eEQwYTuV}rtSP)Z^TuQS~HayAu*ReQurpeBB!}/6q OeRNChXs{prP{LZAxq[UY
phy_NCqL[N\X\D@~]]zC_A_ptx	ve{Ch[JbTY{wdyt,&rR(vkU}jDMeMDWR]FW Ga`^DXu*`	Lo)	}XLE]yu_DS+YVa0PSP\~\NVZkUW _wadSTW-A|aBTeF~f *`Lo6WT|DwWWQTe3\Fa2ATSP\~b*`vw U	 ywhysIvgATu	WuS,&rRUV{S~_ tCG}G#[(AShvnP
^{Tc{%PSnL baK\useAGWu!{1z6XAOeQwSqrvUyL
BxrZB{GX)_ptx	ve{Ch[JbTY{wdyt,&rR(vs }T{Z_Y_TaVXV_NZTWV@beNvkX	}jGw_JDSSUVa.Ba`SXX vQNWX_AaCKT[&DVeUP~SS@~TW `LkWGn[Dw_UTe'DeJ]Ta]]TT} `	Lw Gry[itsIb{wJseAGWu!R(zyR]z[ W_f}G_/p^vXQQpvUV{"fNNV|[u,bpg[NFdXtS,&w\sBOT_J@XSzTUzzP{\]{}Y,U[`|CiS@sDZIXLZ^b]DSe_AZlxKQRrL_NPv[yD^h^BAC[SQ^VZ{CSCYrXPhXXA@PxzZBPq_SIZVpyS@qXSzH@Z^b^FB,I[`VxqWE~XQ}v	G\TGzX_DkB,IYyOURsDYQ{zFGzX_Dk[Rg^X|
CVXWbXVh@PxzXS{z5&
B1S@6U	 ywhysI{pw~~eD~f `L]THGw_IDaV[Y]~_G@~\|d\o1GXaGe _~aVCFeUFDaF^bCNVT	voj]MR~[CVW(\Te^T\Y `LU GnT@]eJ~}#UTY{wdyt!1DC}Yv_|{wS^qiuzUDqS.QVA,SPz@ t_z}K_WkG}SP)FFTuI&Rz{WuP^[0Ca'^ea^DS.ATK{4Ska Z lkCIiu}Gv}\uP)BWU{""fNNV|[u,bpg[NFdXtS,&wEHh
yKTEZf_MC@DX^h]BAqXwZ[|
][S@q@XRCDDzLEhX]]}qXcER	}T^qBNxH[y~CSP^A@C[wZ^@OU\X[LSTBQXZ^b\]hCB/A\sB_U[Yn[L[y~
Bxr^@SSX,cEX{uQRrzhrbYNgV	xt5-r(zy/}ry[w[YTD_ZFY]~e^TbdN`\] }vyRM}uVTeGVW9XDe^TTb
Rz\o1
 _weVaVXVW7XDWzXTx|t^Y*xepw|eEQwYTuV}rtSQ
pVTI
ShzVuw^q\_3^GzPbP
JT`QSCj~ Ye}[)O,kCV}\P<DTIA+S~Py a[By:R O|^\fPpMWrI*S~H t_u}[z}WPeP<VTI
Q@u WGh(R0Ck}DsPd VA,P{\I ZSL^GMjSWhOgPTcP<dsT[
5PSji aaq!vgATu	Wuz5&
B1S@6[x_|{rZM\BQXG}XZA^W[YYsJCT^qBNxH]i^}r]DS[Y<EE	B
[NCqLXHS\_rP~_Y^a[RgCsJxCHEHTDW^PDzL
APrZA}G_Qw^`R]qTGXYQ{zDX
Bh\]DSX	<ACsxqT_DYUz	Gzr
BzD]DSe_QQCpB
{
H]aXNAT[r^z@ZACGZ
gY	[hiRRqz]_{,bpg[NFdV)Vr1qyJ/qx_|w}uV~e3Ua0G	^~b_dd]"WvyRM}uVTS+YVSC~W~DTPa*RY-P	Ae _~e^[7AW~_DXE*dc]} XM}uV~a[]|eVE~a`SPU*RlkUWXaGaQ~eQ@Fa7^D	Z~u4-
yJ6zxqlAB[uZQw~rwV ^vWP?VCVA,S]Pj tCGkq&G$}_RzbS<|TIQPy\} Y UPe[G&GtLyP<|eTu
Shz| Gq}8G}_RzbP
ZgTuMS~Lw HXkq&_/h_FLyP<DTIA+Sh@W YeDeeAS]k~yPpTXk6S]~HtaeC'CSP`LyP
^{TuA Shz|q}~q!\useAGWu!{1z6XAOeQwSqrv[y~^kfA\_
Q^p|~CTEZXXHA\_LZ^b^A@CXRCpB
{
VEW~YVx\	GC@\xL\Sm[UZVCVXWb_MC@\Rn
B^T[SxyDg^VZyWVEb_MhDByTAxL^B[DQIX`|{WVXWb_MC@	DL
BhAS[P[cB
xS@qrYW}TDzLE@\XqX)w^`{pve{Ch[JbTY{wdyt,&rR(vQWnT@]ae_WZ|aJ^~aF^bd
NvY(WnOF]awJ~aMU_FTa]ATbNVv\o0 _we RT[UV_FT[r[f dYkWGnZ[MWPHTWZ|W9CDapYTPWNd|vkWGvyR_tsIb{wJseAGWu!R(zySSn akq& kuuuPpMTcwS~HtaA u"seAGWu!{1z6XAOeQwSqrv[y~\xT^De_.A^rBTXrBNxH	Gi
Bx]]A[Rg_pq/6q OeRNChVZ~ wJgyw}rtS,*ddo}ni_MR~eGV_N_T[pZPU*R~\kWGXs@]amL~ZX|S^SUS~T} ZCvYGry[w_CWD[]FeXX~[\XDX]vY(WPXwWmJW@|eUP~WB[TbeNZ\kT}nSXMaXNTe3US _~ypSD~u4-
yJ6zxqlAB[uZQw~rwV^\fP
FWuoRS~Py t_ExGWC PqT@nPd VA R]z[tn}[+h_FxPEPVMTuQ S~PI tGC'CSShuk^b]P
d\Tc{%ShzVuw^qvgATu	Wuz5&
B1S@6[x_|{rXHS\DQ@AS@_Y^aX	S^VZ
{}TZrBNxHFxPCzP_Y^aY
AZVBCU_aXVzX[j@_L[Sx|z5&
B1S@6U	 ywhysI{pw~~}pZ~f
*dekV}j\waeRTe^YY}pZ`)Vr1qyJ"fNNV|[u{pw^uRxXPPpOUV{R]zU Z_pSy ja-ur ^vP!1DC}Yvve{Ch[JbZw~rrXS{O[[
uh{CWC\YR}@BQ\zL_Y^a^,^X|
CTGJT_Nh\x\P@fZAxqX<Xuh}H]LBN{Uy/grFd[MC5-
yJ6zx|{wSq~eGVa1^~eS~TG
 ^VLo)Gj]MWpQDS'^VS _~SRB~PXLs }Xq^]eJ~S]VW^TaD@D*^q\Y8j_aWI~aVU|_PCSP\~zuxthY*xepw|eEQwYTuV}rtSQ
pVW`sSS
 tGkuO^uUpeBB!}/6q OeRNChXs{prGSXZBzaY/[Vlk_TEtbBN{@UyL
Bk\G@}Y,]CpBxqWCYQ{zB\\G^\\Yz[,{Xsp
S@qZVjUifPxzXS{z5&
B1S@6U	 ywhysI{pw~~}pZ~bbs WPX]auSDS;@a_[iA*`\]WTz^S}M~W+G|_NZ~_uBTPeZ[Y}j_]SRHT_ Ya^~a\]~\ dB\Q}j_]_Pe-GeW_D	^~b*V\U%WPXwSRHT_ Ya^~a\]~TmNZB\o3	GvyR_tsIb{wJseAGWu!R(zyP{T uNzWjS*zLyPd TuMS~Py aSaQu}OPz~FPZXWuoQ@u eL}[6iSGt}DPQd[WXJS]HY aaK/\S"}G}}@XP?pzT[{S~@YbCs}[zq|kS.AU{"Sh@W Ya}GQ%hS|LyPp TIASPz@ J}\AK(G}G}nP)ZDTHY"SP	uw^_#CO+}GDqPlTcAPkv aEAK(_ }_@^fdP)^VA,PkrR ZuLA[QzP}D{P`EToRz{qlAB[uZQw/grFd[MC5rR(z|xCHRIfYQ{z	GL]ZAmY/w^uJ{OT_@XS{TDyP{\]{}_)YY	JkORRqzhrbYNgV	xt5-r(zy/}ry[we_~aW[|W8EWR]bdNs c	 ywhysIvgATu	WuS,&rRUV{SPz@ H_B}[	_}GhBP)FYTVs$S]r}szO,C}DgPQd[WXJRz{WuP|eEQwYTudrC5KB1Py/q}TEZXZQC\AR@
B^T_]hSX)ECpBk
U\WDYQhD	D\
B^T]\GYk_ptPWVXWbYQhD	Gzr
BA@]B@XQ]CpB
k[V@T[PSDZjXB~[Sx|z5&
B1S@6U	 ywhysI{pw~~Wx_Tb}Re\kX _waXMTeAVSYFTe\DbVdzY}nN@]_UTSFS _~azE~f*RlLoJ
n\we RT_#UFaW[~ypSV)Vr1qyJ"fNNV|[u{pw}_}DsS<tT`o/PkrR t_EPeGW^upTfRRJxTVQ3SPz@s Dx_Iu^Gz@ryPdTIkSS~Huw}[,Re }_p}LUP<`W`sS~PI YaN}CT[kCTAXP)BrU{""fNNV|[u,bpg[NFdXtS,&wZHNPiT[s\XKxAj@EkrA\OY	SwX`|
]OS@W@BNxH[y~D}~_E[X)w^VZB_U\tPXRbUzz
B]ZxWX[VlB_U\tPYV{DZD]C@GBxOXYEyU\tXJkvY\LFxr]G{}Z
gXspySNCqLXN^XAy~P_ZxC[Q{^KJ{uWCXXM@TF\GzP_Y^aXQYrp{CT@sTZM\[yYPn^SxmZ
gXr[WEXDVxTYALAxL^BCXkY	[Z
y
S@a@XSx[j
A{D\SGD
U^V]iT[trZQz	Gzr^zL_Y^aZ/[R{pve{Ch[JbTY{wdyt,&rR(voGn[DwWmJS:]|_#^DSP\~b*vY(WjRw_MTeIU|aW^De]D\*dzY}jRw_MT_:@F[#\	YD~u*RmLU9}j_]WlITaTZFY]~Wx_T\Y VQ\QWj]MR~a[]|eVE~eD~f ` o.j ^]WvJe3By PD}pZ`)Vr1qyJ"fNNV|[u{pwx[vNS.VA R]z[YWcPy%O,^_c}@GPpMTu
1Sh@W Ia}[.O,}VAL~P)ByTVw'PhHh HShChC^\fP)FFU{"R]z\qlAB[uZQw/grFd[MC5rR(z|xCUEZL_MxD\zXYP~_Y^aX)wXKVx_NCr]_{,bpg[NFdV)Vr1qyJ/qx_|w}uV~e2CF_PTWR]TbW*Rb\Y}Xq^]eJ~eAVa1EeDTPP
 Z[\kWGvyRM}uV`Z~ wJgywpeBB!}/qx_WuWhy\u^u\h~^P)RTuMSk \zW(iuur ^vPS)}T
 SB@ I}CC'eCeLyP
ZgTAS]vB t_zhqC6}CB}\P)FtTuU(P{v t_uGR;}[xP~P)BzTSH
uw|eEQwYTudrC5KB1Py/q}TFa@DPH^x\Z^b\YzY][X{CW@JD_MxDYz^{~]_zOX)wX[B
{OT_D_Nzv\Rn
B^T]B^_X,[VlCSH[bXBNxH	GzG{DZAxq_/AY	u~qUFI~YVx\	GzrPCX][qXQ ^VZ{uVGaXXQ}vByLBkn]F^OXYE`
~mT^qBNxH[y~
Bk^BS[RU[JKVXWbZVPz\jr
B^T[SxyX?A^VZ
yKUZITBNxH]BTG~\ZhX<]EJ
~OT\I\YVPj[r
B^T\]{}_<[Vl~TGbr^_x~BQXFS_ZhqDSA[[]mWZYf[WbDzLA^_Y^aX){YyS@q@XPz_\b
BX]Fkq^,z{1z6XAOe_tsIb{wJ~rwV}~b_*dvYRW\Y]wWlLDe#_VY]~Wx_T\NZ]G\B\MSUP~e3@|_PTe\D\qRA\o} _wS}J~[SF_WFWUDTf *VVY}XaG_~NDW3AWXSAB\NR|U9}nRwa{TTS(U|a.BypSDbX Z\o0\Y]we _~S']y PV	xt5-r%mOv V|Sqrs\u}V}\P<cTVU Q@^WuP|eEQwYTudrC5KB1Py/q}TEZXZIDCRLCD]]}qX)w^pJ{CW]D[Lzb_\bEbGB{G]/IYV
{
WAZPDHAP]\TAxL\]keYwYu|
S}SCr~Y_P	G\TPxzXS{z5&
B1S@6U	 ywhysI{pw~~}pZ~TM
 `Y}jZwa{Me3By PD}pZTT} Rg	LkWGj\W~Q}#UTY{wdyt!1DC}Yv_|{wSx_Iu}C~hbP
^tT`]WSBT bu{K/\_3AOUPbP
FWTuI&S]LZ W[xq!RaT}aFh\CPB~WuTQ@u W_f^G,G&^CSDPxU{""fNNV|[u,bpg[NFdXtS,&wY[V
S@WT_Mxv]rAxL\]Y
]^VZSSCa[P@F~G{D]^hG[)YEVJ]mVXZ[QS~\RzAPXGBxOD)Y	J
][S@qrXNzvBfGS_Y^aDYKV{CUXs_MxvDxrCP^[hqX)[Vl@WHZHLBNxHAA_b\@}DQk_pq/6q OeRNChVZ~ wJgyw}rtS,*xtvQNWjDMWmJe2@eVGTW}BT{ VT	vo7G [}uV`Z~ wJgywpeBB!}/qx_ Yah+iS}Gv}\uP|BVA,SP@y YSxhC\[-xeIxPEPVMTI$Py~R HOzK/\_3Sk^@YP)eTXoTSH} W[xK\u}VA\BP
^aT9Sk~Y tCu}_+O^uUpeBB!}/6q OeRNChXs{prP{LAYPGDQEVZ
xqURYXTh@DyP{drC5KB1^Y*xepwqrs{|} Y~[kEDT} `
\Y# [}uV`Z~ wJgywpeBB!}/qx_WuWA[ia* O|PTcSxrTu
SBPN Zu}aSG$P X}DRRJxTu
S]i Gq^_#CO+zWsCrwP
ZgTuMPkv ZrPuU4SGd vwQ
pQ%mOv V|zhrbYNgXwV}rqY/{YcJ	C[S@bYK@zUf^}r^B_[R E`^
{KWCXYW}T_\bA^ZA^CX	<ACpB
{
WCPXNb	Gz@BST\ZzGXYX
`^{uU\r~YVPj@RbZ^b_YZ
gY
{
UXs_M}@	G\T
B@@]^SDIXul
kOUGszZU^fUz/grFd[MC5-
yJ6zx|{wSq~S+YVW*^Da]ATT~NRyoY} XM}uV~S+YVeU]TWhF\ `LY$PN]MR~eAVW8E_DETf
*dVvQNWn}CaPS~aVU|eYZDatBzuxthY*xepw|eEQwYTuV}rtSQ
pVWXY6PSr tSPW\_3PaLyS?BW`5S~Pv H_B^}Q 9h_F^\fP?pmVAR]z\ YaA[IQ 9@u	PfcP)Z{WpwXSzsS^q!vgATu	Wuz5&
B1S@6[x_|{r]_{HDif_}TZAxY.^VZ{CSCYr_Mj[j
Bk\^@mX
kZ^CuS@JDBN{Uy/grFd[MC5-
yJ6zx|{wSq~eGVW3_aZ@~xtvY	WX[\]R~S+YVeVE~_YTX|*RL\YWjRweQ~e]FeWBD	^~f
*Rl]}jRwe ID}#UF} Y`	xt5-r%mOv V|Sqrs\uky\ vwQ
pQTVQ3SP ezW(Q 9AO{SrS.RwTXTSSntVzu/_ }fPdOTuU-SkPJ GqAe8RY}GvLUQ
pVWpUJSzBOyAWeS}V}mPZCTuQ S~PI YSfP[;O,SuI}\zS,|WcI1PhHh t }MG$^GzxPEPVMTI$P~HJ t`G8eR}GLyP)RT[9SSU tOU[\G
k}|}PP
B^Wp]SP\@uw}8BuRGtzPP)RT[{&SBT Wu{}_+RC#}Gkr]QQpvUV{"fNNV|[u,bpg[NFdXtS,&w\sBqS@JDBN{C~
BCD\Yz_Qw^`R{URrBN{Uy/grFd[MC5-
yJ6zx|{wSq~y#\|aDTWhFPNdELo7G _wSaLaTGFa2]~a]GfV	voVGnMAMaJT}#UFeUP~_ @\NV`YQ\m[a@ITeY|Y]~_uBTTmVo\o0
 [}uV`Z~ wJgywpeBB!}/qx_ Ya}[#j[}O	^PwS?PTV]"SH}sq[^}$O ^uRPbP<|eTV]"S~HOy^[0CPaK}DPPBpTPkvbOuzS ePAPeRRJxTu
&S~Pv tOUzyja#z k~yP?|DTuQSj tG}[#CQhg@GPP`STKkVSh@W t_u}eQG$ur ^vP!1DC}Yvve{Ch[JbZw~rrXS{ODcEKhiTFt~X_k@	GzrA^\]FkqXc^ZxQRrzhrbYNgV	xt5-r(zy/}ry[walJZX|eU]T_\P@ R|
\kV}PyR]ePDaUBVa0]D	^~bC `LQjZM_U_^V[
EDWI[~*^vU)}T\ZMeRWU|eUP~WU[Tb*^\Y}nMR[PW~e3UeWBDSdZTN|tLs c	 ywhysIvgATu	WuS,&rRUV{SB@r tGzW )h}[A\PVZW[;Shz`OR^q\_3^exhfPPBpTVkSkPO Ya|^qO,A_~A\{PZCTuQ SS SfP R SGtk\RP)J{VA,SO bO[^q-[(P |hb[PpPWuoRSkSquvC'Qu#SC}P)]TuI&Q@^ HW|A[-G$hup@XP)^STuQ/P{\B tG{}8[(SCkvZQQpv%mOv V|zhrbYNgXwV}rq[[
uhmNCrD]_{HAB~YxXZACG[Q{Z^{CSCaTYUz[jrYxX^[@C_.^pN@OVXWb_MC@U
A{D^[@CX/YXBOT_J@BNxH	Gr
Bh\AS_, ^sJSWS@q@BNxHBxXGk^FaY,]YRBWTFt~YUz\zXC\ABA[^,\s/6q OeRNChVZ~ wJgyw}rtS,*Z\Y9G _wWXN~aV[eYX~WUDTf`vo}nkFalNT}#UFW(\TWRYfVVvonRFwSUP~[F|YZD}pZ~f
*dVvQNWTp_wa_UDe0ZFeUP~e	YDbqNRL\kW\Y]waeHZ\} Y`	xt5-r%mOv V|Sqrs\uPWrAWP)RWcA PyXz W_fk_YzP~PPBpWrQ@u ZuLCy
G-ur ^vP!1DC}Yvve{Ch[JbZw~rr\]{}YRc^VZ
{}S@q@BNxHBQX
BLZAza_.AXuNyT^aTXVzX	GzrCSPGBxOY/{Y
VBPV^tf_M@fFj~Z^b\XWD	RgY`p{[U[qXDUkvUzzP{z\YzXS^`yWVYs\ZVPzBXZ^b^B[_.AXuJ
xKNCqL[J@\BQXP_AX)YYc`CT^aTXVzX[y~B@@^BC[B,IY[VuV@YP}ZzC\]{}_gX`p
][NCqLYQ{zUfYnASkeZ
g^VN{CTGWLXPPXX
BnZAX]YulCTCqbYUx_QPxdrC5KB1^Y*xepwqrs{|} Y~[r[f
*dB\]7Wj\[nIDS+YVSXT__]TbeN|tLs c	 ywhysIvgATu	WuS,&rRWpUJSzB }yWReQ O|zS.RwT`VP~\^a}^}[Ra}G^X`P)ZtTXwS]LZ bqK/RaT}_}hP)Z{TXk S~Py tOUhaMQu}_zAXP)BrU{"SkXv IO\hW%Re)hG^^XxS,`MWrSB@v GqAWPju; O|^\fS)lTIQSLb WCY} 2G& O|zDPd TVASy W_f}CT_-SuIPbQQpv%mOv V|zhrbYNgXwV}rq[A^pN{NCqLYQ{zX~]Cr]DS[Y,]^INy_TCsrBNxHA~\hD^F[X]Xsp
{
SCrDZWCvBQXAxL]Yq_)AXsp
CUXsYVxDX@AxL^ShG[<AYrV~qTEZ^_x{,bpg[NFdV)Vr1qyJ/qx_|waI~_I_VS _~e]*R|
\kTXAZ]a{Me	_F[9EDe\DzuZvQ }PNZM[lJDeXFaXT[y^~PU*`Y%WvyRMeRDeGVa1XeFTT} d]Wj]MR~eXFaXT[y^~b	N`kWGnpZwaz_TaVZS _~eADbd
Nvo(Gj@MeT~aVCFS^TSDzuVFvkU}\L\]WmJaVU|SJG~[y_Tbd V\]} _wSUJD[!B|S;ATSPYTPU*`LY}\KGweR~W[VW8E[r[fNRV\]+WXM\M_pNTe)_S _~eAD*VFvkUW\L\]aCKTS;@aBTeF~fv]}nZXS@QTe _FW9GTaA~fNd~\] }XyDMS~ITaTGFY]~a[Ebr RlY}j\S@QTWZ|W FDS{ETf|tLQ }nSD]SXVDeC|_NZTeX~P@ `LkTj\MR~S;@W9X~e]DPU*dAvo}vyR_tsIb{wJseAGWu!R(zyS~\ aZ (GGt}\zP?pxVA,S~Lo tCG}_j_&h_C^XP
FsWp{'Skn	 ZA !QThaBhbLP)ByT`I	Q@u t zh _VAakk~yP`EToSH}bGd}G-u"x[vNPd TuMSPz@ H_BkC2C.}_prQQpv%mOv V|zhrbYNgXwV}rq]/IEHhyiTEZfD__xPkDZAq_<Y[VlxQRrzhrbYNgV	xt5-r(zy/}ry[waXMTaU@|a3P~ypSD~u ZL]0nFMSReX|a'F~W{_b*`	LQWnuZa@S~Z_F} Y~a]ATf*VT	vo}j_]ePTS]VeW]DaZETPXvY8j_]aXQT_#]|S+FTeAPU*|tLY(WniGw_BL~W[Va(D~aZETPXR@kNGn@MaXNTaTZFeVGTa`^D*dVoT|C]aCPDaZ_F_F[pSTb{NRcv],G\X][uW~W(CVeUBypSD~u4-
yJ6zxqlAB[uZQw~rwV ^vWS<pRTUS~P H_B}q O^uUpeBB!}/6q OeRNChXs{prP{L]G}}Y.YsNy}U\r~_MHDX
BzDZA{WZ	<I[Vl
@KNCqLYVx\	Gzf
AhASzqZ]^uN{uSCXM@BxXGk\FCB,IYupyS@tD_M^P@BX
BTZAOX, XuN{uWCX_Mz@	GyT[hLASY.^Z
CT\r@D_zv_\bPzTXSzWDQEVZ{CSCYr_M}@	Gr
Bh\ZB{GXPUYu|yWVEbZU^f	GAzA~]_PyB/\s/6q OeRNChVZ~ wJgyw}rtS,*xtvo5G _wW}STaW\eU]TSWDTXvN|tLs c	 ywhysIvgATu	WuS,&rRUV{PkrR tS}[TC }[xAXP<ZBTuI&P~baSyK\useAGWu!{1z6XAOeQwSqrvUyL]Cr]Zz_[PY^p
T^aD[J\	DRrAxLZAmX,ZmS@WTBNxH[y~
A{D]_hG[Q]^X|]mRRqz]_{,bpg[NFdV)Vr1qyJ/qx_|w}uV~e6BFy PD}pZTbX `QNPDWPHTZ_F} Y~[\XDX]vkX	}\[[SUP~aVXV[P~_\STT} `Lo WjZwaeTZ\} Y`	xt5-r%mOv V|Sqrs\u}_f[P)BrVA,S~_ H_B^[0G$AO}hxRRJxTVQ3S~LK H_BS_+Gt vwQ
pQ%mOv V|zhrbYNgXwV}rqX]XVVxS@WTZQhT[@AxL\\{XY[VlmNCrD]_{H_Q_}T\]{}_SIX`CmWGT_M^P	GzrGzXGBxO_<QXr
S}T@sTZM\	G\T^{~]B^_X/AXK|k_VXWb_M{HBQPxzZBPqZ	/XuN]mT[trYTC\Y\L^{~ZAO[P]E	BCTGHDXN^X	Gz
Bxr\[}SX.UCsx	ve{Ch[JbTY{wdyt,&rR(vY(Wnh_]W@WaW\SXTe^TPP*voWn|__AKDS4ZVeW^eS~TSNZ@LQPj]MW}STaU@|S _~SdZTN|tLoWniGwSUP~eI[|W*[TawDTzu-
yJ6zxqlAB[uZQw~rwVzMPxTc{.Q@u bCC^a2[}_zAXP)BrVA,S]LZ bqPeW	zS{APRRJxTXoTS~@S WeRC'iS^_cA\BP)Z{TIQShL_ t_PeWi},h_CDqPP`TuIWSPt|K/\_3^[}\zP
`TVk1SrO Yaq!vgATu	Wuz5&
B1S@6[x_|{r]_{H	DRrCz_AX
I[u^
@KV[Y~[NT	G\TA{XS{YQAZKZ_T^qBNxH[y~]~_^Cq[SAYp]mURnZM@\zXPCX^BS_
QCpBaVDXJ\	G\GSXZAO[P][ySTRZT_Mxv]PZ^b]DSa_QQXX`mNCqL[M@D	GzD]~_X{_RE^c`
]OHR_MxCzrGhP[Sx|z5&
B1S@6U	 ywhysIbpgV