dqyV[[eSyLWPLg|WU{-`Y
f{Y	`TTKzSTCbWVUrKVBAWUA{A%VUNVn[P(SeUQLxXbYVBAJs_ms`QOU}WFSSNW<\nT~VkIea]A'XwOUnMRWuu2%Bc]ID3GT]kGBQ:@LoyQ,W`)fBBfZ5BIwoQCBQFvk
AeSMb^[xb	G1^w]Y\RYM_\k	AeW MPT[xfP}CI]k^BZ^vYqQ_s_rPVZX]WqS]oBFxU\vUPA_s,_\bTxbG5[O]oYxQ[\Y|
AaSW
)b^CTWISwUTEBg*ALkA_,[RXXR\G VM]V^x]6S\Y[{,aZb^^BXR}TRMk \B]![kW[WX}YxP|
W1QMk_QD\ 	{a_
MXqERb	WnKYCU\v 	{[v,WoM\\BTp}^SM]V^xYGvQ[AWV,S_P[	}^SM]QEg	@vwyQ_ ,aUMYxfDWWk_] Evk {e
Hal)X}YxfeG5aIMoQxcV]Yw
Q}v	A@"Ps\ [Kb|\@{J	A`V X\[-Y^\YIb\CXRBpBVxP[*YS[ZG|WX{&ZPWJZ_Ex@[^U
~z[/~[,Y\Ga_C6YTWl[YG^BKVT[vXWPZ
yCE~KX{&XOJVXBx	Ap|WF\[)fX?qZFFG_h&ZP\C~B^`JWEDZb]?XZ}yE{YVWYX `DulTVHGWLZGY_VS]]6[OW|\CRAHNS}@Y	/\@/OXZ}yCQX^YX~FDpSPX)~Y	C^F~C_{&\LWZ[FU\|UUz[UfZ<qCE~K^XIpYCF|	AVZN}H\*YRSZTS_h&\LbZ[|ZsV
nDG/L@/OZ[}CCQ\LqZ_m`[HlN}H[/~YSYC{e\CYLIt[C~`^spH~TZV@]	W[^Xe\PMYSY_m^XI^V
nD\/LZSCE~KX{&[ShZE}d\KtT
xv[	XYSyCE~K]~ [RqZ_ AHNTnvZb]?XZ}y_~*YHH[X|Z	AVZW~X/F
RO_T~x/#ipy{Y#uQtVU fQTO{W	\g{DrV~~tUQI.uQvUWuS/GqUQLxnBU{-b{DnY V{[Ux @P9GqT<DrXrWVrYw@ mAuU}quS9ubW*D{@tW!ti{@f]HdLQa_|Mf [R	}T]]Y\Rg)EvU\QS}S)fYBfq}1PYSFRcT\L 	{a_
MT~CxfP}~R]k_B][L]Y{[s
aB	)b{GxPJW5|HwUS[Rg'BkA,ag	Mf[BPzW1^wQEZ^vQQSoawT|XRb5\TMo\[Bg_\oOQa [uMP[YRT~5LkDRg ZLQW[asMTQCRbGISwk\BQ;FoOQa,W|MTyYRbG{S]QsZBg_v]Y{[r,)b^CfY}5`PMUu]ZYLsy{[s
aB	)YxXwG5CRw\xQ[\k
efHyw~t]cFE vVZ|[\SBWP[9rYS_X^|^C*[PIRGXm^Spq /s6+wW	\gUwUkztQvXg/AuV[K]S[yWStUrKUyuaV {gQI
TTKzP/utWSY{iVBa{m ~5X
iVVqOP/SPW<@P{{USPtak{IZ[`V KUS9OAWSfE{@tV1Gqw` ~cVAuV aS9uyW<v{@tVh!ZA V3AYW[qTSWWSDp H~UyTGWUcXUS`{ VxCpRWuuV	vQctD3X@iM]T_Y&XLoL{[,WOfZ	}~R]] _xcT^LY\AaafMTB_x	}T]YoBBg#Y\Yr	QegSy)T|XRX sUMoC]xg,]LkA[HaB	)XqERfNV]kERUGYAQeTHaPMTzZRbGISwo]cV]QAeaR	)f[BXSI]\xg2_\]w{_SagMf_Bb}sO]YNYRg4D\k
a agYxPzW_OYoBBcW_vkA,_lPpGBPy}TP]kCB]&B\oSAe\aA	bBXRfP}~QM]tCx]*^vohaSufCx	}1QMUu^g+GvkA[_{)YxXwWLk_gG\Ya[,WA)f[B	}5JM] \Q;F]TAeSHeXcEX`5CRw]V^xcT]Y|Q,aAfYRfXGO^MoqBBcUXLkA}v	A@"Ps\{*YW`A@~JBVUP[)XF<yYX}G_	P6[OY^{RFlHnbA)D_,OYXEyX[LHlXDh@[ZVT[TDZCCE~K\[VHhA@~JSs`U[9D[/}^F~X] [IrJGZUXZHf\T\/y\T}/#ipy |RubUSSVGsWPnriTzb
dms I}VKSVTW*\tDUk-a]gI}VGASVwT?b{VXVrY nAuV[[eP/SWoUBVPvtM`A'MMVme}SVOzW? H~U~ImtQvI.uQvUSuSTeXUQLxXXaV~QssEms6uIVx[vSeXT*PO~~dVSPfIr {8uQSVEqP9CWP]nbUxkE{
VIsVUycSW}Wrx H~V~PpHQA{]cVDKDS/_}W	D~VzgV)Zo mMMVmeXP9SW*Dr H~Uk5yY\A'X
Um}XP(yuWLtVf
VkPacnU`
zVuMP9aWSDpVb]Uy-tAS I/AtVx[|S: Wr}Gv{VCNb
P I/cIhVDWSVGsT?z{HRVS%zbUs!dzO3^J@6_bCfZISwoEBUU^oh{S~,e 
b{@RPz1OwoZg,G\oQ,[WMTmGB\wW1TMo_\x]8@]Y{,SUM\^RPVG5|OYu]xQ#X\YaSbHWe	fYRbG5\TMUa@Q:@LU`{a)PV]f[	}1QM]V^xQ:@LoyQ,Wt	)Tt_RPP}5fSMY~]RcUFvQ{SnHaA	fYRbG^HYCg]wy^EA'"E]m}_xXKlY[XdFVN}HY	ZYEGW\P YMs^[^ B^KNS[P]*.UtcpW]!Tt
P{E V{UW[qZSO|W~]GHyUh aQ@ VQ8cBW qtRuR2%Bc]ID3GT]YoBBg#Y\ 	{a,ST)XqER\} TwQXgEvYqQa ,_ M\FR	}5JM] \Q]\U{aW{f [RTR}sV]o@\cWXvoQWra)be\\qITMsvXxQ;Fk{WYa)PFRfz}L]o~GU\vUUQeeH)~t]cFE vVZ|GFG^_[hN~
*Pw2.tXXaV~vWk] I/[vVx[yS/fWLtnYU{ZAe nw6AYW[qTSWWd H~V~PPaQE mUWAuV[[eSW AW<LZED[UP Y
fA'ryU}e[S9qLW<~xvAU{PAbM I/cwIUmWzSO|W*@t{\zUSmbMmg) {{W[qS6 A2MBcBzr}~R]k\RcZYLU`_bSW
)YxzrWsV]o@\cWXvQQ[Y	H[t	MztT]FE vVZ|^Q}J	ApVEz\T@/OY[n[]@[Oq|X@^\BT[XTb\/y\T}Ch.[RrN[QmJ[[S[P\*r]/CCE~K^k \LWZZ]nR]`NN}HZ/X
*WX^|_	*YSJ|\CXR	A|SmX]*z[,}^FK_&\LsJ[@m`	ApNTUXGT[-eXZn]k&YHV\CXR@[^UUjA*LX	qYYmi^&ZW`\CXR	Ap|S}DX@]/G[^XeXy6[PJA@~J\uZT}[/~XQaXYFi^xQX^th[DFd@[|T	FD]*.UtcpVgt {8uUqVx[vSW_qWR~ H~Uk)]tUSn uU\VE [S:AT<\GDVkPIrncUHVxCpQTO{W*D{fDV~|a  n[pwV[aQP(S|W?\BnDUhbAXG]&`IWTKzS_yW\GXEUhgH]{I[kHVUuzSVGsT* {v[TzWQe{E`]_Vx[FP/aAWSDpnEU~!cHQAVQ![TU~SrS:WAUQLxVf
V~yYGY6V
@Vm[@S/GqWDmmT\Uhrte I/
rVmyqP* NT<@sED[V]!vZfU0I}V[XSOwWDmmT\V~[b{x I/uQyU}y_P9SW\Vf{V]!FIrmw`lVxKPS/GqT*}G_W!ti{@f]HdLYaWV,)T|XRT
}1SMUoCg+GvkA[s	aAMf _xPy}AMw]V^x]![Q{Q[|,_}MXX^RPD}-v^ROAUsZW}UDTG
U\]/qYE~uE{YVbYQ_[hN}HZTPZ	/_[]nu]YQsZX[EtZstV[fXUZ	eYC{_^k.YWa|GQF`SHpHD\Z)b[<}EE{G\{ZWY`A@~JSHhHD\Z)b[-YCX}^S6YTWl[@{BSRT[HZ*n[qCE~K_	P2\OJZ[|[cV[fZ		OZ[^x6\LbZ\F^YZS}\T\/|p3z#tmGYV{wVEqSVGsW*\tT}Vh%Macmw {{3w@6	NA2\@BRPzWsJo~ExcT\Lk{WY[[TBGxXG5[I]o@\g_vQsQS_xXX^RPD}ISwQBExgIXkQe}W	\^xfP}5M]kFBU\vY`Aev)TVZRb}1HMod\xQ+_\o~WMHW@)\TX^W5[O]]V^xgGoLQerHaAPYf}bHwQ[RcVELUUQS@,)TTxbW~R]YAZxYIS]StywBCPs vU\OaZZ[|BVWEzGXZ	e^FiX:ZTsYEUF	BuBS[XVXXRECG_^~6X^qB[B |BpBT	VfZ*X]/YX~KXk[IqlA@~JY|Sx@XVXY}ECG_^x6ZTlGFG^SppUfXTP]G_T~x/#ipycp]BTKzS_[WSt{XrVyJoqEg$I}UOSydWSDpmvIUk%cAz{%`
UOSydWSDpXvDVk@YoVc'AuVGmS/G W*\tT}U~IZU A'Vk^UW}QTO{T-E{@Uh aQ@{Ec{wVx[ySUWtW	zOXZV@%ttm VQ8cBVCrSGgWfGXEVh-Fa]zs!dzO3^J@6aC)bsBxPj1S]]bERY*ELkWV,)T|XRb}1^wQ_\xcTALk	ASV
H[n)fZB\`1QMk_Bg-A 	{[_wMb@Cxb
}1LM]~^BU!Av]Y{aH_[bVFBfP}ISwYUBxQ;FQQSeHW@PT[xb	W5sSYPBg_vkA,WPWABT}oP]\xg+GvoS{_sWoM\T@xXPGVQwYB_]Av 	{e@,apTlA\[GsHw\xg+GvoS{_sWoMbBxfXVQwQ]QBU:X\ 	{Wb_~MT~ZBXr5BIwUv[BgISvk
a,eb\XfF}VQwYVZ]:EvU|QWt,a)f[B~rXAZ|UsSHhWEzGX[,aCE~K_~*ZTs\C[[ZHXYbYRy[_i_]ZTH^GZZ	Br|UUjYb\/|p3z#WA}gHo Un[uP)qEWSDp{X_U{UIr |U'H{ TKzP*uLW^{\V~|Az n{`NVVqOS_@WfrVS)ctQ {ATI}Vx[ S}bW^{@tW!ti{@f]HdLke@WoM\CGx	}T]QtYRYE\kAWo,_MPT[x\^W5eJYnDcU^Lke^HaC)X}YxPWSwoCBQD\]Y{}v	A@"PsX{&ZUZGZ dBpBU
~zZ([P}Z[}y_h&YTWl[FUD`^N}HY
)DY
QeZAy_{.YTWl[D ^SHhSxD[	fZa^FFW]xM\LWZ\C~t	AsT~z[r@/OY@{y_MZTs[^Fh\H`SmD\([/[^FuXk\LrBXFUZrRSxD[	fZaE[K_P[UslZ_}x	Ap|UxTGfF
ROCE~K_
~&[LH`ZX~^	A|SmXA*LZ
WYAGE{\Ob`ZDV|YrU
~zA*L[,}^FK\\Lq|XYnJ	AKJH HYTYCX_uX@\Lq[FUD`^R}{*Pw2.t{iVBa{m I/pwoVU fSWRfmXrVh)aac I V{[UnCP:qbW\CXr^W]!ZtAP |RuQLVCrSW~~@KW!tW{Sft	dS@O3Ae,aO)\~@R	}T]YnDcVSv]V	Qa	,_@)fARTfaOoTGx];@vU`{WV,_@bTBPX	W}H]\xg2ELY[
QeT,[
)TOZRX 1PMY}\RY&B\][
e~,)TlAbGoMwUSXBgVAv]Q[YSW
)T^YRTyW-v^MkYxY@voM[sW{
Mb_RbGJwof]RQEL]^QWV,WBMXt_xf`	}CLkYR#SSON p'YSWYAmu]]6XOV\C|B^sBUmDYVF*OX^|ChU[LtR[F|VSZV[fA*LZ	yX]GK]xMYTWlZ[|B[BTFXX~@/OETFa_].\LqZ[|FlU
~z\UL[YZ{uX] GLlZE^@N~XVX[QeXT aCQXIV[@GVZpVVF\Z[Ppp3z#W{Tng+`]Vm S:WxT- H~W]!Sb
dms uUbVK}S[bWTA{@tV]etMDnUuQIVCrP*SqWby H~VkIWA nw6AYW[qTSeWStnTV~ya X`sRVx_~SeWW?|GHyV~vtU~cAzW[qS6 A2MBcBXWAW]ov]BQ;FYs
AS~e)b}\xbG{P]oUXBcT\L]w{eB)PVZTW}T]o^]gDvUp	{WV,[tbV@xTdGoS]\xQ+_\o_,Wn)b_@xTR}{IM]D]RQ;Fon
A,SU)fZXwW1S]Qs@RQRA]\{eayM\^xPj1Iw]PQRcT]ojA,W	fAxT|}5THwYsEYMY\kSTSW
)TL\RTR}TP]oyBRU7Evwy^EA'"^FX^yMAOqBZ_}x	ABTv\(DFQE_X{\LWZ[[{dBpBWY:rF<yYX}GXC ZKY`\CFR@VNV[fYYRSZT{a_C6AOqBZX}SsJT[v\/@ZeYAFe]]6[S|G[{RSHhWF\Xr]	WZEW_	@]^qqzqIdqyVx[yS nW*\{|Tzt
T{YTQVqSVGsW*\|PqVhbA@ I/ubVUycS ]WaHUVBA{m2I}VGSbW?VIV~pAz {g`QOVUycS ]W*\AmTVrH]ns8AuUm}P*yW	fS|TyVk@bA@ m`wVnKXS[rW?DZ H~VPT~HQxGYIuQVx cSTCbWpUTJVgssEsRc
hVxCpQTO{WSL{XU~ImZIYV{6KsPVUuzQTO{W?PR{\|Vk5XHQAnU
yVx TS/_ WrrGVrbwuGIcAWVDaAS}dWStrp3q[@iR@@fBg2DvkSN	WUXf\BTG
@MwYMFRZ^vYr{a aU)\YEfUT]QCRgUALUy{S[,[oPT[xPkG5vT]oqGxQ;F]m{WV,a	Mb GxX_5QWQ[RYIA\]ZaHSW
)fTxT]	W5gHou[B]6S\Y[{WV,WQ	TVBxPWW5|VwoUCBZ^vQQ_cWU)f ]Pj1^w]Y\Rg\Y[{,aRXSCPk}AUwwvQ]GW}  p[W@Z-_Y]}C[Sah[CUd	ApWnvA*LYY]X{[Sap[^VYUPZ)[/[^F~_x*[Jq[[ Y|Sx@Z~[/[XYXK^	*ZPr|Y^GYVlVFHGV~[	qX]|E{ZPa|\ChSUY
(\YS[[C^y[Itl[@m`FXZTUXA*LYS_YZ|G\6AOqBYX}GupS}ZVb]/qZZ|K]]6YUrG]xFXZTUX[U@/OYEma]~ AOqBXQFFIJUZVb]/^F~C_h2ZUZ\C|^IT~YWZ
QG[YEu]]6^^rBY[USKBHE~^)X	a_T~x/#ipy{Y,upTKzP/lWPP{GH\VS1b
V m[
kVn VP9XUQLx{tVCIaMQmIubVnK@S/_zW*XSnwVk5EUU]RuITKzP(}DT/zbVbV]bM
`kUx @S/GqW*\t{XV~[b{x I/uaU}}S9WW	LwVbRV~qAQGYuQIVDKFSVZWbB H~VkIyI
]XY0uoOVnKXP/lV	vVnKV]W{S{].uQsVVsP:S{W\CGHyV~UYMXs4I}W qt6 A2MBcBX WZLkCg_oM{[_	Yx\ptV]o[^gZSL]Y{_ZadMbB@RX
GRwvQ]GW}  pXYQaZ\FGCh.[RrNZ_m`\NT[H\UnZ	/XZ}y^	C.ZJatY[XdBhV}PX	@Z?GYE{yX] XKJR[F}BBpBSmP[WfF
ROETFa\C*[KVX@^DHD\Z)bX	aXF{e^x[SZl\CZX`UEzZ*X[	_YC{yE{XMZ|[_{tYI^HX[Uf]PmYX~E{ZPrp[^t	A`U\]/YY_]:GRJNX@F	AVZSxD[	fZa_T~x/#ipy mI-I]
TKzS/_wT/~]EfgUk-uIr ~ApIBVV  SG`WvrXXaV@Js_{A% {{3w@6	NA2\tYxPzWT]kGBQ:@LoyQaH__MfFfZ5BIwU\xU\vYb[O	SXV[b
	1QMwvQ]GW}  p[LZ_ZZEyE{ZJIpZX~^BpBUVf\(D]*CY\Ga_C6GQBA@~J^JU}\\*rZ
SX\ C^h&\Lq|ZX{hAHHzZ9fF-q[^Xe_[Is^Y[Xd^KtW
FzZ
/Z-_^F{G_B2[KIlY[XdZp|SG
Tb@/OY]|[\	@.XPJpX_ExBhV[f[/r[[CE~K^~UYWa|\C~t\[^UxfZT[QGCE~K]{XMZ^ZXVhBVWUYZ?yCE~K]
@[IWtZYFRA[NS}vZ	/P\/|p3z#tmngQK{VD_Sy WSDpF~V`HQAX]6[AyVCrQTO{T?PxmZU~
v{Y#uQIV_SVwW*\t{@AVkPxx |wrwbVCrSaLWd H~V@_YkEU
`]jU}_NSVGsT<bnaVYYts0[Q|Vx[vSuT<zEb`VhXJ{G]PHwUmWzQTO{Wb @vVBqs\U+UVCmQTO{T*DGGbV~Ia{coTKzSuNT?~_{\zVST}Y} m8c
bVCrP/G W<LZErVBIw nU/AuVK{S/_}W?{X}Vk-gHQA{Y#uQIVE  S: W?qU\VrYoM{ATAuU}qzS_@V	vXXr^V~vtQFQ
PVx[CSVGsWbOVbW!ti{@f]HdLohSs,)bYFRTR}rLwk_BU XL]\{Wx_[
XQ\B	}BH]Y~]RQ:[vYBQa,SGbYFRTR}TWoBCR#SSON p'X	[ZCXSCS.AOqB[^URFITxzZ(]/q[C]	]XMsRY[XdZXtTVTA*LZ-SXCX}^{\LslYFBpBS}vYW[-[E~u]	]GWYtY@V^BpBWXZ*X]/q[C_~*ZTsZZUd^VVHU~[P@/OZE_]Q\Ls^X]VJ	Br|V[(\YYXV[_
~&ZJaV\C`YVlUP[)XF<YF{[^k*XVaBA@~JSpBS~f[(\ZPa^Fa]	BGT`\CmYV Z:~Y?OZEW_]GUZ\C~tFK`UPG
Tb@/OY^uX~[Sl\CEBFHlSx@X/\]/GYF|SX{YSWVXFXRZXtV[fXV@/OY@{y\QGTttZDV|S[`Hm~[TDX	CE~K\ZVt^Y[XdFTxX\9fZ*}X@{[\G^\C~	BsJWnvYWz]	W_T~x/#ipy {8uQIVUeMSgT/f{XxVPZIr(rYUn ^S_@WbyUhP^ao I/`]_Vx_xSuqW?bZ~bUk-sYpE5uITKzP( FW	\gnBU{-A{nYXoVD_P* WTvyVrq{MGIScsuVx[vS_GWSX@iVrqk` V{+ {{3w@6	NA2fYRTf}AMw\xYMY\k	Qe
,_@bB@RPj5^RkCcTALkA,_ MfERPzW1 KwYVQBQ:@LkSx,WMfYRf{GSI]\xcZGvQMQed,WZ)bs@xPP
WxHo\FU\vQz{WMHywBCPs vUX^qBGQF`@pUz[/\Z,mXZ}y]]6GIHVZE}dGupU[XX	aY@{[Xh2\LqJZZV`^pT@ZnX	a_T~x/#ipy n{uUqTKzS_dW\CzDVk@tIp{IrVx[CSVGsTToUrV~pAzn`qVDK}S/GTW*\{n~cW!ti{@f]HdLUUQe@,aATlAPe5gR]UZ[Rg0G]Y{e@,e	MYxf
G~RwoxXg [vQN{aaZYxfQ}1LMo~ExU FLor	QaWBbB@Rf{G5TWQ^cVSvo~_ZaA)YxPj5THw]PQxgG\U{[a~bV]TR}1^woqBQV\\k_ZaA)Yx\p5qMUZ[RgAvQaSFMPQTxfGTP]U]B]TZQPQeC,SW
)fTxfgW5BTwoe[xU\voM{ST)beBBPjrUMoC]xcV]Lov{STe)b^[xX{}5eO]kFxZ^vY	Q[H[rTc\fcWS^wkQxY![\oL{e[HaPT[x\^W@Uw\xcTALk{WHS MPx]xP
)vWw]PQxgG\UUQe@,}wbeAXwW5@J]YnDcZ[vQN{aeXT[BTR5W]]V^x]![k	Q_Za[Mf[B~rXAZ|Us\uZW}HA*LX/qY@UyCB[JtRZ[|Bp|U@Z:[eYYyCBZJrlY[XdBpBS[9\X	aZ^U]~ [OWR[FUBpBSmPZ(Za^Fm^yM\L`\ChYRT\\Z*_^Ema\{XHq|Y[XdSpq /s6+wT/vqnXVSPZYngPX]VEbS:WlW*XX@vUk-qwX]IsVU fQTO{W\zGX|VBAa]mIuIVx[vS:aWSD@~zXVPNQFn0[MjW quS:GT/znDyVPsGYu\VU nSVGsW*\{mbiVra\UsVAuVm S:qfW?remPPVC^s{E#uUqVxSSoWw{XVSTzYo I/c
QVGBSuFWvEVPpV1QAznEII}VxCSrT?PxT`VdIr{Y,ruTKzSTCbWVnTaU~Ia {Y#AtTKzSWWSDp H~VkT{I{ncM[{@VD[AS/_wW<mV~|VPNIr ~g)psrVn[URWuu2%Bc]ID3XAZ|UsZx
y