a)yHTV\kYBi}Mg@SZYbS@mV)c-M"TuXptBv AVZP6SZJhT@TRy8T`	HZGSAqyP*SyAwk_TRy8oWuDKHVVhIR@)Sy]`k@WVPqwTQpr}XuvapP)qC]yHx,!*~a	,Cx	wlP}XuJuaRU)qC]yHxO-1:~a	,C`tRT}XuJu_lQ+OC]yH|L,:^~%[T+PxAtlX}XuHuaRS,\} ~XEA-7^V(r8jlStBz}XuIvalU+_C]yHxB. ~a	.}dsQ~Iz[yr\t+aiz[|L.!L|K(CxtlfKxHaZuaRQ(O[z[|O- N|K(CltRTxKOF[q\q\\xuY
YC8BUOE_Z^l\Sql_DPuC,_D;pWWkAPkh[M [Zx\EySX
/+X[N
GIQIGAxB[MB]^SiY
)'Z[|r_OOqI]]J[M|}~B]YkGZQ/YZ(t`TPr{GAxB_N W
\@~e^,PZ_8|[WVQrAZBx^Vl}yt^]]e[[Z-	sVKI]\^{p\NZS`]XkKC,_D(u}VQAZB}N^UZm

~Z_\]eY)+Z\lICTJrg\^Ah[Nl
t\B]_X<[VUB
pWTWg^XPh]V|
|J\\B[[<'ZB^saTUI \[@^M

^]]eEST_DTZV}ULsQ\^{p\RGOB@XKC/LX[WpUSZB`\M~[	x\Z@GY/X@8ZKWOOqI\^{p]_i
TxZW{x/V"a)yHTcfhY{@
}GrSEIzyU.HPVA.Wu`HZG}QqyPSlAI@pVUu8U-WubNJ|xkQDSZAC~fV)
{+{ZTu\uBtAUtlHQI}yEV

f kSWpfkacAQ`@)S I@@U)
WuTraV A}E@%SEy~U)HVw(TzrBt
XyH#PyxkWQ wa"1SMNiMxpGDsqH@r%@{q@XFC !WR%rTMb{^B@N[M|}|VFF{KYQLY\*HCTPbg^AN[MZ[|t[EyCXP7[G VaUIsU_FA\Jo}JFF{KX
/+XXUVuGWTWg_Yhp\N|}
yJ^^hGC,YVVhpCWWqE\Zz]_|lZ\]^
BG(BGTTs]A@\ND|t_FSKY)7BG(BKWWqE^Gp\T}Z^]BkKXS+[Y-RsyTJrg_Z^l^V|O
lt]YxyC,_D;XmRLq ]]J]Qq
[ESZPY\*r_URAA_BFN|C R[E{uX

D^TCWTWg\^Ah[NlZR]YxyE
	XC;|pCWTWg^XPh]V|
|J\C{SX
/+ZXW|qTP^CS^]VTa|J]C]_[<'X]TheIU\^{p@UGo`[E{[S;DV;hGUIs]^AV[M|}|VFF{KERPY\*rqRL]]_}@WZm|F\@P^
Z\l
sSOOr	{yh}xOSZYb~DzVQX{TK~QHJ{z]ry,SocaSVQyTkTKvlBt@{T5QI}BV?[-M4Wuct^xPZP6Sos~XtV?` 
2VLtWZc^w{oz0Sy`~@rTRy-:TK~Q{^Qbo\SyYA@XsV4UVA.Tu@nBtk{WzPs	~@rV)
x
VLtW_
q H!S Au{bTRyTYT@zBtk{ozSZYbk_V)
@TI&TKT@te A}l6SGu]\tV~TI&TVvjJpd A}yHSTakyV?[Q1TD|tBC}Q{@)P~@]XgV
8;Tu@ntBC}
d H!SZ]qBHU<z8]3Uvzi{
Fg[@Gh@XzQT@WXN4@Z.o\\cTM	]~YySPPK@gbF}fd*pGY:buP]d	BDRzn0@]xZ}T	N4]JQRblRwdD^TYDRzPKPYyB}P~*
rG[vTpR]dzFDo{U\zQtCX*
YJovXx^ZtDTkT@\zg`BPlN}ZQQLT`Kda]TY{TjS
@YYGfdNUY.]/vbkO]	]~otRX=QtCXX }ZYf^wZxE~wq_@PKzQI_Wf{
4}YU0SwRx\TQV@X@ge[}f@
 @[.o!vfPVP_~o{UX
z]tFWPL WXkU	LSwVRA~]TU\\U[TT*lCkWLSwdu]YiJnzY]fs @DJkU\PrMMRpPTRzP!PgD[}\}	*0 V.])	PILMVkATwq__NqSv\/_G |pRLaY]D}p_N WlZ[E{EL[Y+pcqOOr\^{p_HZqTt\EP}^Q'_D8RXqUJt{]BSt[M}lZFF{KX
/+[ApXqUSJE\ESN[NT}B\Z@GY/BG+
sUUrw]E^V]JlCd_F_ZPPZ\lTJrg]]R]_uZ\Fa[BG(BXOVOU^B@N_JDW	x\Z]GY.	_DTZHCRLqAGAxB]QEK	WZ]Yxy[
7[Y-RpOIU\^{p]V|W	Dx]^{_X.ZG JWOOqI\PzJ^NTK R@_PC[<'DG*|[UQt_Z^l]P|	\WhCZ,D@^VWTPr{[PxqtxO6}qSbV)
uAWrP{b``PzD)Pyj~\|V)Q{ wTu\uJpdIuy\SZYbyU.HPVA.T[vAiAQFZzSAHxV)R;I3TxtFfIu~SGse{rxU?z-I$Tu\ua A}ZvSlYGkXTV
zATu@ca`^wJ~X&SDI~bSVPq;AUTIXOJ|AGvSW~~X{V)QdTI&Tu@vJ	h]}Z.SyY|BYTRyMSTcLVb``PzD)S Au{bV)
VA.T`TwtF~}Mg H!P|c~X~VU+{ZVLtp}IByP(S AuDVR{8Wr~KbXIu~rSTa~X~WQ w-9TI\ObJ^kkaT.SD}@pV(`8].VLttFfhQQZT*SZA{]XgV$a8QTuD~tFfIuWH/SyY{rv3&ZCa@1L~xWwZ}GTYiJX=zg[AWP| 
BE.QL\PWS]RF[~QFVP\zQhDGft H[.kZvbIw^p_Dk_zjPQy[Wb N4XG[vXzV`^DYjU@j]	zc^b	 a@.o3\T]`^~o[U@\zY|@G~t(u_5O}Z|APx^Vl}]CxeZ[ZVVaUSI_Y}BFN|C	x^^{GZQ+X]+|V[TKaI_Y}B@PC
Zd\Fa[^V(tWRLaE]^h\JW	x_BeX.LYX+ppqVIW{ZBZFN|C R@^{uZ
+YX+ppOTPr{ZBB]Ql
~Z[E{uZZ\lpOUS\Zz[M|}~B[E@C[
7[CTRLk^X`FN|C
yJ^@hX.L_D(TKZE^X`\PK	Th^]]e_,/YX+pmRLtA][{|\JZW	lJ[FxC[/LYX+pVaTJrgGAxB[NK	~B]YxyC,X]*OTJI{\YxV]_iyt[ES^/XGUhKOTPr{[Pxt[M|_l`^@ZPP[CWpOUVqQ_G\V~S`[EyC,X[WrTPr{\X}V]V~Cyx]\uXP;[CVl	GUScGAxB]Qq^X~SX	[E^s}WTWg^B@N[Noi	ThFF{KZ
+Y\*s}UQW \YxV\QEO	d[E{u[BG(Bs}UJt{]][Ma^^^kuY/'XCV`OVKg\^{p^Qyq RFF{KZP	[Apr_IUZBZ[MyKt[Ek[Z
+ZC8V[RLaYZBh`]Ql
	
ox]YxyC,[GTRsTTsZBx|[M~Klx_D@a[
7XA*^`VTEGAx}txO6}qhbdVU~
.TK\IHdIuyLPygSbVQXVA.WutIuozSSy`~@rV

fTA[T[J|S{wZP6S AuHV,ETI&TcvKbpTSUIl\%QI}~@LV)s-Q/TV\kBtxkTr/QI}hT@V

fQTu\wHZGSyoHOSlhHxVU}wTc~ttFfz ~ QIV`qB3CaY*
\PXQwVRA~]TU\UTW}bH[.]6vbNO]`_DovIzPRUQX}f~NC].[vbKMdED]QPz\'PcXGb
N4_E.w"LblRwdD^TYDRz\cXGb}Z[vbqR]Z\TYySP\zYqCX H[.o0vP]^wRx\T]QPzP%QSDWXNR].]	v\OMw`_Dk_zn4PYF^W	*qEo2L\ KwZ_QuMz\zUSYTQ*}ZoPLPSVXDUqR\zYuE}	*4VYLTpR]VP_~YuRP
PqWXFC !WR%s}UKJc\P{`\K|[ ^^@ZPP[CVl	GUScGAxB\Kyq]]y^,'_D*JV_IQ ^G^p^UZmJ_@PYRPZY-ZV}WIJE]Ax|[MZ[Tt[E{uZ
.BG(BTTs\^{p\RS	]^xGC,YX+ppT^c^AR_MGK|t[EyCX,	BG(Bs}RLq \Ph]Qq
Zd^ByK^,'YC*pHCUPsE_Z^l^Ty_GB\ZSuX,^V(q[-
tipr^{SZP6SyIQ~VQ(VA.Tu\wtJPSAu X\SyWrvW
 P;k2TXsI|}
E1S AuS~BU?HN;ATV\kBtx{JyQSoEU{]TRy-9TPwY|FkJ~SZYbkfZU)F81W[DJ|MyyH+SyY|STV)s8YT[}J|^I{ @\S RhTAV)
-I$Uvzi{
Fg[@Gh@X-PgcZ}f`*4AXYv\H`^DYz_zXPUQX}X]N~@[vX}O]ZXFU	SzX2zUQX}Px4W@.kU	LbPMdZC~]QPzP	QUDGb
H[.o6
vbLP]RE]~ovQzX/@c\GTT*
@JkZ
Tw^MVuETkP@\zgwZWT`*0]Y*
\T|WZ_^TkRPn-zg	_GT~UY.Q$\P[UMRb\To_zjR@Qy[WTT*
rGJ[vTpR]VGoWz\zgGCWfN
YVoS\T^	]~YySPjPPUV@W\wN}Zo vbJMdhZRzn4zgECPt H[.o3vPWMRtGwq__NqSvY/'XCV`ORLtAZB^Z\PWF]Yxy[
7ZE*^rqTQrGAxB_L 	x_BeZPPBG(B[TPr{^El[M [J\\xuX/PZ\lVCT^kXPzZY_~[|y|p3-"{UVvTWp\^{]Zz	RZs]]rXW
 Ya"1SMNiMdsY~kQX PcXG	*4g[.o6
vbLP]RE]~QFLz\zcW}PRNH[.kWvPzL]`YkRP\<Z}femCJY&\WP]dxD~YySPT,z]T_GPV
 0 V.oLbPwZf_~]QPzjPzY\FX\NgZ]vfQM|pPDoeSznPQDZ}fV*}Z]SbVwVP_~YWPX=QH\TT*]_ovfPM`DDkP@jPzg`_	*lCY*
\T}J`]TYtKn+Q \b^[CBOZ|	Tu]L_	DxFFxZP_D8RcGRLWQ[Pxt]Qq	|^^W@_^,PYVU`	uOOqI]Z|[MyK	x_F_EQYBpp[VVYc\YxZ_|ulR]]yY/'XCV`OIU\^{p^UZm	
R\Wx_C,YX+ppWUt{^_J[MyO
Zd^W@_^
_D(NuaOOqI][^V\SEWJ^]]eZPPZ@BVWUQA\YP`FNV\*q`zpW
 W oZUvzWpUgrGh_A6@{q^}\vN}Zo%vbvLdy_Do[PjPqWGzt 4aZ.o\TMSwZGC~]T_z\zQ|FXN0]]	vbRUMZYXRzX/gSA}XN0 XkWbPM`_Dwq__NqSvX
/+[DNceRLb\PPt\H|
ZR\@yWY	<BG(B
VOULZc\[Z[Mo[E{Y/_DZ	pyROZ]^Ct^UZm	Et[E]SX	'[YWJ}WTWg^_}RFN|C	`^_SY[GTVrRLq \Zz]Qq
Zd\EPGZQBG(BKOOOqI_[CB^UZmZx\[PC,Z_(NXmVO]ZBx]U~WF_@_C,YX+pKqUWsY]]Sl\JE	~\^y[Y	S7X^hr_UUrw]E^V]JlC
Zd^]]eY
_D(JpORLqA]GS^UZm
Z^F{ZQD_ taTL{GAxB]M q
Zd\C~yYQLY\*sqUKW]\EhB_MDO|B^]]e[T[Vl	p|urgyy @S Au~X{V4]wWurQJ|^QbWzSoI_kXTV
zVA.TXb``PzD)SEc~XyV)sU"TILsBt^aoPQI}~DbV<
UU-W`~Sa^Gz[ @S AuCrVQeVA.W[DV}IwZP6S AuBfV)
E'Wpfipr^qW@%P~{BSdV)
uTA/VLtsxCh
fyP/S AuyvtU(WVI
Tu\x^y{shv 6_HG`Gzt*CE.o\fQM	]~YySPX/Pc	_}fzN,uVs"\blRwdD^TYDRzPUzYXPQ H[.Y"\TpR]VUP~oxQP\zgCGXpa@.Q
bMRwdF_DYySPPRc	[b*\[vTrUdRF~QsIPjP@Z}fd PV.YRvTpOZ D~kP@n+qWXFC !WR%[aTPtA_B_SGS	W]ECXP_D(|ceI^bc_ZS]Km|J[EZ/_D(NVaTJYw]Ek|@PClV_XPZY_ `pOULZQ\D@p]V|W

yh_@SEQDVh`_WTWg\CPJ]N~O|J]DPeX'YB-lXyRLqA]_PR@_S	~@CBKZ
+ZZWhpOUSAZBx_N_
Gt\^y[[,[E^XmWTWg_Y{\JE	\F~C[Q	BG(B`}TJtg]\^\TT[
TR^]]eYR'D_VhH[TPr{^GV\NE_ ^[E{uY
,Y\*sGRLaY_Z^l^VEZW{x/V"a)yHTcfhY{@
}or)SZYb~XtU)4oWTcLVJp}QD@)SZYbhT@V)cATu@ca`AQFyP*SEYFtVPqI(WuctZphQxWzPT{u~ryV4-I$VL_i{
Fg[@Gh@r%zghB	*0]kWvP[MwdFDToSIzX-PcB}TT*
@JQH\SwdFDT]ETX=QI_WPV
 M\JkULPXQw`^YtPP\zc\Gb N0\Y \\T]`FDUYPzPqWGfB A]JY*
\fKwR{ADkRPX.@c\G	*0]U'\fTMR{ADkQ@X-PcB}	*
\Y\PXQw`^YtPP\zQy[Wb*pGoL	\XQLZ\PT]Rn+@qWGP| 0XJo)\bNJ]db]~k	WzPzcXG	*^.kT\b|ORhEk_z\
Pc\GPqN
YV]	vfWwZ]ARzjS
@c]Gb	 p_.kWvbpQVP_~YzQXPc^XX 4]Jo*vPXQw	]~k	WzjPPgaB}P| UY.Q\SwZZTkQn@c^PlNDJQ\PXQw|pPDsqVaNqSvZPDVVqRLaY\[Z\_WZRFF{KY/'XCV`OVOY^El_N W
_BC,YX+pp[RLHEZBx]Mq
|F^^ku^PBG+W[-
tipr^{SlrSyWk~V?[Q1TD|tBC}
dl\)SowYHxVPxQ1Wr~KIJ}kV@)SyWk~V(~;TuiJpd{sZz 6v	G`XIB34aZ.o\TMSwVB\TkP@PUQT@W	*
BE.Q/\T`K`[DYfSPX-PQf[WPm 0Y[vTpR]Rp]DkQzj\@UV@W\wN}Z]	vb^^y]~o`I@X U]Wb0 V.kWLfLMdcXDV\aGFSv !TYX+p[TUQ\]z`]QlO|t]Ya[)	X_*RVWUUrw]E^V]JlC
Zd_W[Y	S3BG(B`WUSY\P{`[M [

GJFF{KY	Q	[EZrSWTWg_BV[M [	EB][P[C,[GTVWIUY]]h[N~}	Th[E]S^.7_D*JX[UKbw]ExV^Jq
Zd\_uER3BG(Bs}RLqw\PJFN|CWR\F_Y/+Z_8|_USc_YxN_N_GFFF{KY	S[AUprIQ{\YA^RZWR[EES	X[WhHyUItg_YxN\Sq	x[EKC,[AUps}US{_]C|[MZ[ R[EKC,[EZrSWTWg]DxZ\Hym|t^Fy_C,XZUR
_WKr{_Yh|\Sq
lt_FKY,7[ETpKCRLWQGAx}txO6}q]XgU$]QT[vAZpS{CyH#QI}yPwV
B*sTVzraVcAT.SlHyU.vQ1Tc~tb``PzD)SlwQ~@rU)Hn{PTD|tB}^wv H!P~THxV

f-M(TcvvWp~}Uyy=SEIz{bU.v-M4Tu@JJsPk@o~5QI}~oV)
_-QTXtJkhFEPSyIQSOVQ-IUVL{i{
Fg[@Gh@n1zgEYWPA	*0G.kVLbPwdfY~YCW@\Qy[Wb*4~CJQ/LPJR]`]ToT\zQWDfA*H[.k[v\QR{^oGP@X-PQ`FWfV*0YkTLPXQwRpP~UxRz\zUuDGfd	4eZ]vTAVwZBTUZV@jP@gE	*a@.kTLPXQwZYXYSRPX/@Qy[Wfx 
^DkZfQM	]~Y{KPX-PgR^GP|N,uVO}Z|]B^J[M|K
Zd__CGY?'_D8N[CWTWgZB{B_HW|^EX	/XAVWOOqI]Akh\T}Z^]BkKEQPY]|VGTPr{]]^N\V~SDF[E{G[
7Y]VZs[OOqI_Y}B^VoOJ\XC[	'Z\lpRLk\Zz\QK	l^]]eX.Y_TlsOT^IGAxB^RG}~Z]]eY/Z\lrUSac]BSl^UZm|\BY
YD-lsCS^qz	{yh}xORZsShbdW
 Y{UvzWpUzTy=SG{XyVUyVA.TcfhY{@
}ozSSyAw~XyVQXVA.TV\kBt^U||\'SIWhHZV)s-M4TD|YxxP
ayP/QI}~DbVPqU/TVtWY
qZP6S Au{fBWQ w-UTu\w]hdEPPysrHRU) vVA.T`\NHJpk{@)SocaSVQyT`\tZ}
`yH#QI}HRVPQuQ1Tu\xath~ H!P~QrrvUfI;W`PtJ|^QbyLPl	kgVPB-I$VLtRGIu|r#SEUWPxV
,ATI&TK~Tb^}IwyTSyY~YU<$`U{ 1zNiRKFgDYySPn&@cXGb]A[vTPIMZ_PTYySPn7zge[}f@
 @[.o vf^wZ C]TWPP
PZ}feNmCJ]\P]^wVUXT]T_z\zQhAWb
0 V.U$
LT]I]	]~o`SP\+zQy[Wff	*0 V.o%XHM^C_TQM@nzcXGb*4rEJY	LT]Rw^y]~wq__NqSvZPY^ZCUSZc]D}p]QZK	x\[xaE/BG(B
X_UTgZBx|\Q|_]BSaY)	Z\lV_OOqIZAhZ_NTCyd[E{u[,BG(BsqUKW]\EhB\Lu
[E{Y.	YX+pHCVOJ]ZB^ZZ_|uR@^S}E'D\|HWWLIQZAz|]VTa	~|\FG[
7DD+CUVw\_x^HyKB\DyX.LX_*R[RLqAZB^ZZ_|p\*q`zpV)c8TTczHtBv AVhv 6_HG`GPANpBJkWbPMR{ADYzN@jS
@Z}feNmCJkWL\H`P~YzJn/zcYXNH[.kWvPWS]^PADkHPPzggETT*cG.];T|W`	X~kP@jP@QT@W	*0 XJQUPKWVtCDkRPX2	@g{A}f 0Y[\T}JZ CYiIzX>@Qy[Wff	*4aZ.o\TMSw`DDoFP@T'	cAGfVnCJ[vTpR]ZtB~UXNX<@UWE}fe AJ[vTpR]Rp]DkQzn4c@WX 0X.kW\\T^]ZtB~Rz\UuDGX*^.QL	fUMxpGDsqH@v%_GFSv !T]V+B	IyRLWQ\Zz\S_YWxY/'XCV`OWHZB^Z[M~K	oZ^][ZQY_ `pOTPbY_ZR[M|K	
y[E]S^,'X[WJ[VPZ_Z^l\K|
	EVFF{KZPLZ_8|WVOE\YP`^UZm	~\Xu^.ZDRKGOOqI]GSV[MC	lF@XK[SLZ_8|	u_WTQ]\^B]J O[EkG[Z\lsSTOt{ZB{B_HW|y|p3-"Q1T`bpJ`iCAHyH#SyYqfDTRy;k2TXsI|^U~@6S qDCVPQuWs;WczqpKxIT5SHxVS(l8].Wu`aRb
qyP SyYT@pVQ,@{6VLXi{
Fg[@Gh@r%zgG^WfB WXJ[vPJKw`P~YCWPn&@UQX}	*0 []\X{RdcDUrSnPcZWfY ,uVo*LTsS]ZG[TorU@jR@g\FWf^G^[v\T]`FDYiJXzg\FWTT*0Yw"L~xWlDGTu[q	x@_PXRXB-p	sUPIYZB^ZFN|C|x_Be[)_DJpqVIW{]E^B\HWiy[EkGY,TXB-psGUHI]Axh^UZm]]y^,PZ@VaVVYc\Yx[M|}		yVFF{KY/'XCV`OWH__}Z[M|}~V]\_[
7[E^XmRLtA\^{p^PT
DhZW{}[D]Vlu}TMWI]_J[MZ[|t^@XR3X@Up[RLQ_Z^l\PGuDZFF{t/V"a)yHTcfhY{@
}yL/STc@]@~V081TVL tdA
\@)SEg PHRVPTI9T~qVIu|jPSWsHhHLV?[Q1TD|bXhU~@)SyEghr V<~-I$Tu\xaFP
aovVP|sJ U.UDQ1T[v]ZpU A}ZP6SWs`PqVRHV[TD|bRU}IwyP%SlZHxVP0W-QTu\]BthZZjSEe@DgTRyUoTD|I[hQGTn]STcuHxV)UWA1TuD~tdA
\@)P~ SfV?PVA.TI\OWZckYTy,SEIqSfV?PTI&Uvzi{
Fg[@Gh@r%zg\FWfb 4CBo\SwRiX~QEM@jSzcY}Pm4u\[vTpR]^uAT]UPj]	zgr]G (u_5O}Z|_YxN^Vl}
t\B]_X<X[T^u_V^qIAFR\PWm
Zd]_~WY?'BG(Bs}WWr_Z^l]V	F]\SER7[VVpqWTgAP\_oC

o^\^y[ZP_D*JWU^r][PxqtxO6}q`qB3CaO}Z|	{yh}xO6v	G`U