f,pJWS rVo0U So@Aks#mXAW{B#SThxU;
xUyPovI,[XdW{^XWhrV k.nMPPl\G~Y%nTYTVR# =T,TkQ\V-I!AxPywBYE\WU0X3WkPV8QIpSyPF~Y*mdW(@&UxV;A	mPy\{SgXm~fWGZH+W}
tV-Q YSPZ~zA$x@ WUSH,WAQVT
'xoPy\A~AWVNWJ((@&T}H}V8QMSPfBYDXyWn1SH,Tx xV-Q3DQzPleCnHYT|t<(X*T}4BV8I	AxPTb	k1DX@WGJ.(D W}|V-I*[wsPy\qCsR  ru2t
fI2D
o]#EAoVzf[g+^QTW
xR<Bf TH	.Y?[Aoe	zbAGUV^PoR.DbX~4JkSZ{]TzPyFGcWGAxd4DObVTT	JkMG]Tz\A}g*E{x`]^P84Wo/B{kXhC}]\A\~x^ YbT4d	^[{Yl@b`^}cTZffB`P\XN
lJkRV{k@XDUG]\{XwxdWEY~z.o@{]`zfGGU \{X `S@f~
]JkRXAQzb{C}Y^{TRdCP8
@Y/ZQYp\^[Wg(G{PUR`R[OP9~O]7YAQ[
X}gW@b	xV+E+f~4]Q[YlTDGQ.]Qb 
B|%QFuW %]t[yW\G@V
AnuF  BS}LXN[[V^ZWFD{JY}Zg
\uz	Y*R	^n^Yya[G{BSnC]wC=[
^XU`G}BY_]_yFE_[}{	^.Y
-|_}V^EC]^tGiX	~QFRa
^C(B\[Y|][xx
BF[|X/[xTY	Tl	DENY|\UPVSVWXXgBQh'C(B
A[tXEO_D^
AC[ QQ._xTY	Tl
VnJYG[G]R
A u]nYCG;[l	CC|O][xx
AnZCRiXVZ\[lYyW]@S|S}x.rOf,pJWA
zV83 BPoL_hIvnWV`T(X*WP4V8w6DQCPy\q{T[bfT|# =~XWC(]VA,nIePyA$xfAWnBSH,W^
gV;A	n{zSoY]{$[zsT{VQ WpV;{+D]RL}~]DX@WmJ~W^0eV8QDQzPle~AxX}WnZ@7WA
CVA,Fs]PELz~Y x@TW^Q*WpV-QoPTihIH{TmB4>r.W^
gV-IDQCSyPV DXyWn1Wh
BV-I!xQtPy\AC4xrWnt4=~VWpV;ADY Qvsbq	d^IA2Bd]]OP(	T0.kRA{k@fGGQDQfx`R^XNT0o$[oqPQZ}gG{PaRV^+P9D4t^[{Y|Pb`YWU.G{XR`PGf~bkQAQoPPQZ}Q9@AfwRR-]PTV.oBQYL
PTS[WQDQX
\\+X ~0.]XQTTBWg3E{fTxV^+P;
MkS_YlXT\GgUA{\lxV1XOT 
~H	.Y^oTyYWQ%GX[Rd@fTV
JkRV{kbbC}g@{fxdRZP80.kSX{YRbDY}U \{PnBd%[Y~D]#EAoePPA}UB{f|RV^+P8D4e.o
GQoqbAGUV^PoRV_+f
T0QR@AQPzqUXGWps@Q_PXU`
YF`Y[[G]]~yY~IG-uPYVV\^|]U`Z}GZ{w
[exYt_DB[Gq\\yZY}Zg	B[}+[l	CC|O][xxSaYX{@W}'X(
[l[Za]F]ZSU]m	[/
xPY	W	V[ZaFD{JFUaZmc	_.y
Y(^
G[|Yl@\S|]V[U	[-7[l	DENYW}^_]dXSZ}]@-K^+[-ZDmNE	a_GCF_}[~]C-u@+YWR
A^[Za\[BF\ [} 
X=u{+[l
Axl^|G_]C\GYU	Xix*/RyMa|yPZ\bmvbW>HW^
gU-IVAtPWPIE1DX@WG(X/WhH~V-I!AxPTTsBxlW{ZTSWh oVQ4sGPyDE;[\bWG^2 ()WhUTVA+[dPZvfhs.n_WB!(@-W^,sV-U DQCPZ\b@{	DH|WnB~7WPH V-M?IpRL}A# bW{^( >TQWkZV8{UkEPlXbkU,n_WB!=\3W$V8]P BPyDwI,DWXr&Wk zU;
IpPlDRkU1DlWXBUP(W^UTVA+V
aPovh@sWF|*0W^aV;A	[QgS|fby{-xX}TmQ@$WAV8{<AxPy\q{Tm@TTnV4 =~XWC(]VA, {v5vGbXHdAXRZGP(	T0 JY?CYp\^[Wg(G{bx^=BP%D
@^[{Yszb_W] Sf~Bd+CObW
D
kR@AoVzTgGWY^{f	R-]PTQ.o7[AUQ
@PS[g.ATW
xR<Bf TH	.o6ZQ]zzT|DUS{P\Rd]+P+	|]Y{k@TD]gBQPoR=\f1~H	.])B{oVzTiXGg1X{ftBd,CbW
D
YE]Tzf[Q%\QxZ,GT$D|kS_YlTI]WQ]Qf}BRZ\
~bo/B{wt_BFQvYWp_}I	[-7C(BGU|Z []_yS}]nYCS{L[TYxZZ
D\ZF]~y@}Q.Y."3)yM[QgPELT DXyWn1 >TT}H}V8QIpPEPks;H{WGZOPbSWPH VYSxUSPE\F@{	DH|Wp# /TW^
gU*VIpS~TI,bWT~VXW^VT
'Ew{PTa]wWGJ Q W^
gV8YxIrSyxBH{T{>RT/W^,sV8YWU PyD]Y3}r{T|Z%(\WA
CVT
maP Lk]/@sWGZ+=4WA
VUkTxUSPE\Fy{x@ W F>Wh
V-I!AxPTTsBxXxT|x(@WW^U[V8QTIpS~TI,DXyWn1H T}4VW{$xUSPE\FkxDZWmFR4W^
gVTI#n]@ST~is"dwA2]KfP4JY?[Aoe	zTS\WUS{P	Rd#EXN
Q]Y{Ym@bq_WY^{P	R`QXOP8`.Q.@AoPTSU}gNETW
x^%XOfWD
o^V{k@bFGWQ6AQTW
xR1COf)H	.])B{oVzTyYWgRGATR=DOXWD
JkPYAYmP\GWY^{PoBd4Z+T
JYAQQoPPuFGQ8FX_`RCTVTzJo/EA]TzX}cX\APoZ\+f*~4 kR[QYlb[_GcT]{P`R*BOY~qJQVQ]VTD]cYD{fCd-E+P(	TH	.U%^YlfXWg1FXrRV^+bWqw'V^OCqQv]~y[Vc	QSa^+^(J
XmY|W]_{^eX]_(SxP[l]ZY[FD{JE[yX
{QC=G7C(BDpZ
Te^^~VFnuZ
 A
\uz	^Z	GVEOFD{JAyYVc
Z(Wk'YVJ[F|Y~_][xxS KZ	~
[eY+VG}BX}[GhY[~]CG
xLY+ZG}B^lW]_yGEy[~]	QSa}'ZTV
CFZ^[^\xY[e[|^SCC'^ZG}BX|q_FPV[}y[}{C>zL[(N
Xx|^ZW_D^FFS]}]
[e{LE t\_||~qJd|pWJ\=\/WpUM4_P fS0VTOW F4XWk(xVQ)m`Py\[~Yx@ W{Z%>9Wh0U(3[UyPT~E8[XdU J)X3WUBV;A	nAZPT~E8xX]W{Z(@WWpVMDoBP DuBUSmrlU J)XJW0V-U DQCPELz~Am@TW{Z*(D.WSHqTVA+UYvPES~;xX]W{Z(@WTx$`V;{/mQBPy\q~gR@sT| SH,W^
gV/DAPlF{Xx\PWGZ /P#WkZU-<xQDPoLGBQTzDT|x=TVW}rWU{%awB5_MGbGQ[f	R-]XT4JY/ZQYL
PTS[Wg*ZAPLRV	COfY~
U.[{]TzThFGg YQx`QFf/DA
kPDAoe@ThFGYP@Afx`R^XNT}	.^[{]V\FQDQbB`SD+bTlJ] AQUwTyYWQDQfx`R^XNT0oB{YbPX}Y ^{bx`QFf/D0kQC{o@PXQ8FXZTYObW
Dl	o6]{zbGZGQXQPUVS[P4D4}o)Dk baXGY^{PoBd4Z+fRD	JY?CQ\f^GcVF{TRR+FOf(D0	JkPYAwt_BFQvYWp_}I@=SzLXp_}VXe\[~t
BUuX
^(S^8R
[[VYGeFD{J
A}YUFyzLY*RX~p[Za][kF
A}GY  F.S'ZU^
Y|^~G\__}[XXgDQxX
+pCD^^Tq\X]^FFa\~Q.Y."3)yMmQTPZX~~;xXGTUF6 /vW0V 
7xUSPlA~Y/x~WGZ>DW}
V;s+DQzPleA$mfxWmp-(\-W}
yTVA+[U{S|z	ScVrqWXZ6SD;WhUyV8QTx
eRL}kDX@W>HTSgU*kPTaPsmGWn^(X-W}rV-Q'xQDPyDI,[XdWX| /P#WPH V-M?xMbP Duyx\PWGZH"WS
VTI#tPlfs"dwA2]KfP~4d	UQZQQ]
PeFg_{X_R-]TVTJQ.BU}PfB}] SXsR`R^XNT}	.^[{Y|PTtAg.AXR`QXOPTV
o-_AYO	PbFGQ+BAfx|%QFuW %V~B[ES[G]RB}KZ{{D_YZG~VE|e_FPt_W@~IFyzLZTV
CFZ^[_]CF_Fy]I	_a}'[l	CC|O\Y@x
AKYYC-;E;h	A[pX|[GkZF_]YCQS	P/C(B_}NZWS]\ShB_ZEQ@._
kLX*_}VYZ_\BxBYxeY~EDRy@+[lV}t\~qJd|pWmJ>r.TkQ\VTI#xUXPl~]DX@WJ(=XW}rU-<xU|Py\qP]7H{TmB4>r.W}UVQV{rPZ\bE;DbW{B#(X-WAQYTVA+xoPP~]'mPU J)P"WAUVVQ4xMFP@^EmT{]Q@$TzHQTVA+V|PELzk}~W{^(H T{ V8o
xoPy\APE3v\W`W0WpV;A/UomRL}~;TxWX|"=PPW}yV-Q*AxPZ\b~Ex\PWn -~XWA
CVQ
tPE\k4nDSWnZ(@&W}
qU;]	UYrSlP}h  ru2t
fI2D4so_AQPP^XWQ%\QfqRdCbWD|kQC{QPf_cWAAPRRZB+bTlJYXQkTuXg
XATW
x\\+PTGJ]G{oPPQZ}Q8^AffxV_OXPQoUBA]Ti@Q]QX~BdWET 
~
Jk_Zzb`@cVDQ\WR!\OT 
~
.o-@{zb]UGQZ{TUV^+f(~4^JQ]k@XT]Gg.ATW
xZXY~oDQk fXWcYYAX_`RCTVT4e])B{]TzX}YNYQTXRR ^f&T4CkP[AY|Pf@}QDQX@xdXf~lJYXQkTuXg
XAxd	QP~z.o@{kP\tDWg
ZfA
BR=\f1~T.UVAUAzP_WQ-]Qf~BR FT 
~
C^[{k TI]WQ]Qf}BRZf~4s.o.V{ox	@zqUXGWpsQ.K	C+^WB[F|Y~_\^y
A}uYX{Q>C^7^NV `C|O\A~xYZ~Q	[-7ZNGnhYZm^_]dFm}Fng
CQ_YVJ_U`C|O\[~tSEa]|A	ZSS{C(B
A[tXEO\A{RFm}FngFSP[lDVXGC]Z{Z
A[SXXgDQxYl	C`^o]ACxZ}_] E@>i^7^NV `^ZWFD{JZ}GYUU	XiY^	V[V^oe\GBdFi]m	ZR_;YT
GntY\\~t
A[S\~Q.Y."3)yMxUyPZXq~E[XdW{F5Wh
QVTI#D]Plvj@{	DH|Wn6PWA
zV83U
vSTu~Y*n_WU<(@-W^,sTVA+xUSSlz	BYnDQW{ZRX.WhH`VTI#U
vSTuhI}z|W{0(\-WhsTVA+xoPP~]'mPW{^((X-UxVQ4xMFPyXV@{	DH|WnB~7WPUxV8o	IpPZY@g-xXwW{Z(X.WhH`VTI#U
vSTukYV@`WGZ=3W0SV-I!xMtPyXy]'mPU J)=WA
CV8Q BPoL_]Y3xDEWUVSD1WA
CVT
maPyDwI,DXyWn1Q@$TPQvU 
#nMRPy\{{+xbWB! >@0T{eV-U*xQyRL}@{	DH|WnB~7WPHSU*],m]PE\~E x\Vp'f'2[B3s'_{o|@TzXWQ(_QfxdRZP84wkPYAkzf[}cW]Pr
R\XOP(	Tt	kSX{Yp\^[WgBQfrR_bU~[	o-\U}bSC}g.]fBV Q+P(	TH	.Q@QY|PTWGWQF{fARRYPT4~Y]QYzbyFGcX^XRd"BOXW0Jw'VAstaBFQvYWpZ|Y[QC^8N
Z}C|O]_{^e]m	[/P/Y(D[ZZG\FxY[eXm	[Cx[(N
Xx|X}[GJFUaZU 	[/z	Y;JD}|^EC[G]FS iXXg	ZSS{C(B\}Y a[GhY[} 
X=u{+^WB]^ZW_DVZUi@~I^SATY-p\Z []]~VY[e]XE	QPixX
+pDBXD}]\{^
AG]mk
[eATXT`G}BX m^CY}Zg@>a[l]ZY[\UhBY[eFFcCG
^XU`G}BY[[G]]~y]I	Xi7^;\XD}]\{^]D[kYeAY
-|\[l_||~qJd|pVXp5WAV-
mDPy\~~)DX@WmF(XWW}
tV-IxIyPZzvy{mXDW{BRSD;W^U[V8QTx
ePyDwI,fSWG^RSH,WSU|VA,mCS|z	BYmz\W{Z D3Tz$_VTkUU
dPZXqks[XgWB!SH,WSQaV]TxoP fS0mnW{J(@&W}yV;{)FwcPlDRkU1VHNU J)(W^{VUk{PyDwgD\ U J)(X/W0VTI#QPyWCsTDHEWUpz	WAV8IFwcSlTc~)DZU J)QH-T}4V

xoPy\APE3v\W`W0W}SVQn
PPW\k+ULWB!Pr"V^ Q3"a^@B5@\_WU^QPr
Rd#BbT0
J^[{Y|Pf\g1EAXrRR=DOTVTl	o6]{oYPb\DWY[\~B`R^bU~c^[{k@Ti@gSAPSxV+E+f~4V.kRVUmzX]ZG])^{\RBV^+XTH	.kS_YL
PTS[Wg*ZAPLRd^P8D4e.])B{oVzTzU}g/[{PxBV^+XNT4sJQ%XQkP_WgY\{f~BR FY~z.o@{Y|Pf@}g1EAXrRR=DO\ Tyo_Ao|zb}G];[A\~x^ YY~}	Y1B{oB@TiXGg1X{XRd"BOX"T0JY3GAoVzPhZWgW]AbB^ Y~ [C %^RpEZ\Y{]~yYmg
ESG}'^Z\mRY]@y`Z[@~I\RzLE8R
[X~e^_]dAZF]C=G
xC(BD R^Z]_yZ}_]~wZSeS[l] `Xy_ZP
A[SZ
 A	Xix[	|
_RX}[GJG}S[~\Qe^7ZNGnhX	y\\yZ
A[SXUA
[e;X
-Y BETyFD{JY[Z	~	_.y
CLX*]FYom]AhZ@~IE-S}Y
8\}Y a^_]dFm}FngCPC^;|\[l[yW[G@|
BnaZ
Xk_iCYVJ_U`_||~qJd|pT{>RT/W^,sV8YWU PZ\b{s,XwW{^XW}
{VwmgP fVA$H{WnXWUBV;A	UYvPES@{	DH|W{B#X.WhH`VTI# STsI,xlWndW -z+W}QaV-U Fs]PELz~EVx`WB!(W0ZV-I!AxPGhIxlWV*~'WhVQ4xUSP \kw5H{WVR'W[VVMxoPDv~Y-mWB! /UxV-U DQCPG~XBI+xDW{2Q@$WhUSV;MAxPyXVk}~WGZr&WA
zV83DIvPEPBcJnHYW{B#(X%TkZU Y!m]xSoYs"dwA2]KfXNT[	Y]QYVf\Q8FfBdPC+T 
~4^	YVAzbSC}UV^fy
B`R^bU~0o[Ym@PQZ}Q9@A\nx\\+P(	T	oYAYl@b`^}U \{\BB^^+f~4s.kQ[AQvPf	YcT]fq
RV.BP+4}YAQzb	YQ8^AffxV^+\DA.kQ[AQvPf	Yg&\Qf~BR FT 
~mo'\QzTyYWcTZPod4]T.~0o@{Yl@b`^}U \{\BB^^+bUDQo
GQoqTi@Q]QbxV
\f/~
@.^[{oX@TU\}Q%GX[Rd^XNT[	o(B{Q@zbEX}g'E{PxdET 
~
C^[{Uv
XSU}YSQfxdFOT 
~4~Jo@wt_BFQvYWp[}{CRK^ZVGnh[a]XChXxZ|YCS;YJD}JETyFD{JY[Z	~@zLY*Z_m|X|\XdY[eFnD=exYT
Xx|^ZW[G{`X[FXQ
[eh/X-BY BETyFD{JBna[~\Qe^7E8tCmlY ]\Sh
A[S]nE]-xX
+pDB^G]_yF Z|]Q.CZV`D YDW\XxRS[Z k@-KC'Y*R
_RX|\XdAEG]~A
[ez	YV`DnX~]^hY CZ
E.yxZTVA Xm\Z@hF_]X	_.yP;ZVlDnX~\G{JZ~GX~E_(u^7_(q^}y5}t{s,xXcT{>PWAU;]Vm]xSoYB[\T|Pb-WpU A^ UERL}~]VTOW F4XW}
{V;A	m]PG~A&H{T{>RT/W^0SU*],U PyD]Y3}r{T|Z%(\WA
CVTMRV
aSyBJ@sU J) (;W}
tVWD]SoP kU,n_WXZ6(DTh$}V8QIpPyD|]'VWV`SH,WkZV-Q"n]ZSTTwkU,n_WX^% /P#WS`V SIpPDrk3x@zWX|"(\WA
CU;
VQPTfQA$H{WXZ6(DW^,OU*Y$V{rSyjU/x@zWX|"VWScU*]mYOP DuyH{WUp'TP$VUMmQBPyX|k]/@sTnx(XTSgU*kPTas"dwA2]Kfz ~VJY?CoYTqCGY^{XR`PG\V	T
]J]3EoAzPB\U$@AbRR EOXT4}])B{]Tz\F\WY^{\u`Q_+P(	T0.kS_YL
PTS[Wg*ZAPLRd^XNTQ^]`bDY}gYAAX^xR.DOf)DQ^[{oeTi@U.G{fUxZK[TTqo!EQY|Pf@}gSAPSxVSFOTVT0
Jo)D]Tz\F\WY^{b`P\TTwJUQZQQ]
PeFg_{fxdRZbYD4wo.DAYQPfU}cT]{b R ^Y(t5ORpq\Dh`XS[}{CRK
kLX*D}`XoGFD{JZU[YE]X/[Z8B\lXD^_]dXSZ}]@-KLX*\lXDm\YkBF _]XQCQyP3[-^
Cn|C|O][xx
AKXXg_[
kC(BXm|^m][k
B~CZ I^Se+Z h]x^Yoq\UhB\C[VkQa
AZU^
X}Z[Za[G]FS i@~I\RzL[	|
_RX}[GJ\[[|{\Gx3XW`DpZ
Te^^~VFnuXXgDQx^;
G[RX|[\XS]}AD_+Z h]x^Yoq[DhJ\C]XQC-uY
+^XE`Y|][xx
AKXXgY=K
}C(B	GV[]Uh\FiZC-zLX
+pDBXe_B]xZ}GZ{w
[e
^XU`V}q)tbzqJ [rUW{B(=XWPvV-M-AxPo~H~Ex\PWExH+W}V-
0mIPPGzf~A&H{WVR'W}
{V8Q[USyj~YVDdT|tQbRWPQdVTI#QRL}]Y3xDEW{^=Tx,VQxIrS~PZ~Y xXzWF=\/WpVw mYRL}~Y/ZTnt0 (;W}
DUM4_P fS0xDwW{^-TSWh oVU(}wPTfVkQ/EH^WnVRPUSW{awB5_MGbGQ(_Qf^,\+\D4^oZQQzTi@Q]Qb RXOfJ
TT.^[{oe@\]UWYNYQbB^S]X	`JoZ{o}@PA}cW\Abd5\Y~|kQC{oB@f^GUVYQfBR\bW
DH	.o/B{Ym@bq_WgWX{X@RdEPTV
kQDk	PPQZ}cW]Pr
Rd4]T40^[{Qtzf^}UB{f|RV^+\;~4XJo
GQoqf\Q8FT{xRU_Of(~0kRV{kf[Q%\Q~w]DU YuT\+BX~pZ[\DBVYZ|YC=GhP[l]ZY[FD{J
BUuZ~Q@Q_
zETp	^Uh[	yS\@htA_[mc@/e
^C(B
A[t^G_D^
ACF{Ya}Y;|Y ^~a[G]R
AmGZ	~@-K}X*B
BxpXD}]\{^]D[k	\W}ZTVDmRYG^_]d
A[G[k@-KX-^D}|XTmFD{JB_F{Ya}Y;|
DDlZm[GhGEy[~]CPu
h	ZV
XDNXDS\[~RB_]GECS	z_(tV~)tbzqJdwA2PY