2$&aCBZ&VZUu )e		Wq\D{ZXI\)]Z`XT. ]}M
:u+C^G{{XSY~!_FXI.*\CA*S K\YXgZXI\X|pYV.Qx~^(PpN3*xpcDBW|
sRC|BXP)[^c:G)^]~wXF[^
XZVYW]zQ	e		VC\Z{IBBqO^~!_VZT6D{	})}\\VUZZaq\{X~ZT6D{
:_+p
xrdpt&cEq Z&U	CU	y
K]B]X^O_F-^|ZZLWQX{A
K8}_SUZYWa\{]oBZLW\{U
TCaDB~IZ\tW^	~R^B_L+Q_CY	Gm^FXc_AO^	~5^ZZBO+'ZzvM4+pN'6NDWsW|^J_y|XW)_hA
(	
+}_]{c_AqC^E]Z`D^2	Cxs
/G+C_ZGU[_sS\X1\DB_L+\Sc*S		Wq^\ A_AWWY~!\D|XMTFzQ	e	
OB\BBqO\ 1^DlDW+QxsS
WS_GF{X^^G1\RYW:[^c)e		Wq\D{^Sq|
.$2}u}6Uu^'8\B}A_Ba]FXodZT6]T	Uu\\{QZ[W])E|NZT QZs
/[m^BVYSq}^}XoNXKW.[ a		ODB~IYZHS]	|]Z`_L+2G^WK	UKYAXQDGHO]n!E|N_O; CSU*	 q^_ _AW\{X~[V;&^hY	eTK\S{^Sq|
.$2}u}6Uu^'(C^B~w_AqYn]DZZK(*@xM	
K
q\YXg[AICY~^|_L;	@{E
*_	;_]B ]X^}\}JZ~V]^(QY{c
VyWqB[FgY]HW\n!] Z[M C@A
i+C\Z{I_As^
G^|_L DQ
*}+C[S}I[B[Y~V_[^UQ@xu		TK_Y|_AsGYE]WBBO+Qx :[u_ZUkDSqW]
 5C ^YUT&	CxE	e8DB~{BBq}D~-ZuQ#IfyvM 7F &
WsZXI\]Z`XT. ]}M	9}	K_XwYFaD~CEZYWB{/S	UK\^EwXZs__G\	~RYP;	Cz*x]/QxdrplBDsQqYW\g
T_	V[YAXQZ[ra^-] |ZT6\M	+CBYXZZaqY|1_pYW]*K(m^^{ZD}\X1\
EZTW ZCQ
TC[YA|gDSbe]
V=\lp^^++ZzvM4+pN'6NDWsW|YC
DQVQ[^c	UC	)S^Z{w_AqGD~_NYP;]A

/u+CYA~ X^\VRX|ZT6XxA
:u	.}_ZU_AqG\X1\lp[OUQx~^(PpN3*xpcDBW|
sR]oBO+[z*(K_@n{[[aq\X1Y|}uQ#IfyvM 7F &
WsZDbY~VXFYM;*Yhs*KUmYA~ _BrGY~\F^^++ZzvM4+pN'6NDWsW|\}1_ |ZIW*_@M	W[^D{gBBqO^|]|BXP.&Q@gVG;}B\{X\a[\X1^DFXST2ZU*KW[\Z{Y_As\X1^
~`Y^(.@PM/C[_SmwYSSX~,.ui*#Ire@'] &YA~wZD^ ^WB_L*[^c9uT_XS~zxt2$&aCBZ&VZUu )K O^_|U^Sqy[}V^ER[R)[^c
/K)
^\G]YA}YX_
GRYO)&@xMy+WYA} YFC\E_
GdZT6_Pg
[[_]UcYZtGX~,.ui*#Ire@'] &B\{[]Zy\X1^l|XQ;\xo	T_;}^FmwXBt[D~Xy`DTMXhs
C	V
\YXgX[qB 5E|NZH M@QS(m^^{ZD}\X1\
|[VQx~^(PpN3*xpcDBW|
sR]`XSW*F	e	.SYBmcX_r}^	~R_xXS@xM
e K^]EY]b}^})XZVD^2	CzE	Wi;}_XUwX^a}Y|XD|DK;.[^c
_	SXS~zxt2$&aCBZ&VZUu Gi\YXgZ[W])_pXW)ZSc(C	BEXIXFIaB
_ [S*@xM:u+W\YXg_AI}Bn)_W`XSW*	C^U.C\YXgD[]XZVZV(6\Vym^G{Y_BbeB
E|N_O.	Ch 	(	)SYAX]Y]Iy]X~FXP(DSA	e	.SYBmcYZYm]Clx^^++ZzvM4+pN'6NDWsW|\}1_ |ZIW*[^c
/[8i^B~wXDCBF1^EVBO+[^
:u	S^Y gYGra_|]Z`Y^):_PQ*G;
DB~IYZHS]	|]F[QU2Q
(K	
.}YAF{ZSZm\X1_	pXTUQx~^(PpN3*xpcDBW|
sR\|YK6	Cxs
9i+C_ZGU[_sS^|_	WN_L+QFS*K
;OYA| DBH[_FC
 |XQ;	CxsUC+C\ZFIDXa^}XyFXP8*@P{*K	Tq\@|UX]b}_1E|NZTU6\@o*u	
8q\[~ _AWWY~_GB^^++ZzvM4+pN'6NDWsW|^J_y|XW)FzY
9u	
8q\[~ _AqC^E]Z`D^2	Cxs
/G+C\[}gX^}\-]Z`XJ.	@kg
e;q^B~w_AWW\{]oB^^++ZzvM4+pN'6NDWsW|\U!\WxZT6X}]
9uTK\ZnwXFy^
nE|NXT.6F{	eK\F}{YXq_1\|XO+.@xM
/y
WBZV[]ZyB V_ ^XOZsVe

V
\YU BBqO_^p[V;&_S{
U
+}XS~zxt2$&aCBZ&VZUu VSm]AFE_AqG\FC`ZP+ \
TC[YA~w[SI}_}1_yFBO+[ci
K_ZGU[_sS_U1X~F_LXxQ	e	(uB[X\G^EE|NDQVQ^	e^Z|YX[H[Y~Y|}uQ#IfyvM 7F &
WsYZHS]	|\WpDTU[^cV_
 _]AFEYZYmD~]|BZW;&XP{
:
WWYA|A[F}^~)^pYKW6[^cGKDB~I_Aq\X-]G|[M 	C^U
*_	.mXS~zxt2$&aCBZ&VZUu )e		Wq\D{XSm\V]Z`YPQXhs	G	8}DB~IY@b}]F]Z`DHF}cT		Wq^\ A_AWW[}_	DXRMQ{	e	U}BZ cBBqO^	|X|FXSF^
)C(_YAEAXGt}_~_FYL(	CCE*x]/QxdrplBDsQqXSTM@Y	V[q^FXIBBqO\}1_ |ZIW*[^c
	/e
Wu^B|UXAIW]X^Tl[MFzQ*K(K]\ cXBqq^_ZpXR+UY{
G+p
xrdpt&cEq Z&UEAM	:u K\Znw_AqC^ 1^NZW;&@xM	)yTSYA~AZYWa_F]yNYT)MQ@g	(K.\Z{I^Sq|
.$2}u}6Uu^'(m^^{ZD}Y{_
F[P+F}c*K

(m^^EEXXqSY~CEN[V;&@xM
*G	(q_ZGU[_sS\X1]Wp[P .X}]
9uVCDB~IYA}_|J_
W`XI;]^M	(C	KXS~zxt2$&aCBZ&VZUu )K;W^_{YYXtWYXXTpBO+_{:__Y|ZZr_V5_ZNZOU[^c9+u[S}xt2$&aCBZ&VZUu 	V_V
_SUQXBe\X1]yNZI8U@xM
/y	V_Y|_Aqq_V-\~FXH[^c(a
W_^Z|YZZqC\n!_ZdZT6\x _+}_[{UBBqOY1XGF_O8]ko*x]/QxdrplBDsQqYW]zQ
*G;}^_VYXYa\V_|ZT6GSETe+C^BcZZm_{^~NYU.U	Cx
*u
;O]\}ABBqOBXJ_Wd_O8_C
	/S	.CYA~wX[qD~_~RYP;	Cxs(i+CYBmcX\WmB-^pXL.	ChA
GCBX gXDWy^{R]V_L;[]*u

)C_GgX\GD~_TxYP(&	Cxs9aWqBY XXJS^	}-_ZYUQx~^(PpN3*xpcDBW|
sR]`XSW*F
KUm][FEYXq^{V]Z`DLW*[AQ/KWDB~I_Aqq_ CW|YU2	CxS+C^^A[S\V]xZT6[}U
/K+p
xrdpt&cEq Z&UQ{MuTaYA{A[B[_{_y|[^UQDYV[
(q^_}UBBq}^~!Xp_L;\@Y)y+q^D|AXDs[\}JXZVBO+*Q{^(PpN3*xpcDBW|
sR^ER[R)	Ck*+[YB}ABBqO\ 1^DlDVWUC@A*u
8qDB~I[@WG]^lBYW)M\s
K+KBZVZYWa^{XodBO+^C{
/u[^^GYZsO\X1_EDHD@cWK+p
xrdpt&cEq Z&UC	T	Uu\AYXYe^EE|NZV(6\Vy;___nUYYae_n5]Z`[M &	C^U
TCaDB~IY]aCY|V_xZLVMF{ES+}_]XAXFy^
nCFZ^V*[^c:G)^]~w^Sq|
.$2}u}6Uu^'(C^G~XFH]}VE|N_O&[z*a+
_^X]ZYWaX~)ZZV(6\VyO\]ZYWa\}-]lpBO+GSE
:um^@QY]aCY{_
FYP;\xQ*KUm_^FkY^am]XZV[QTB	e	T[\Z{I_AaCY|VY|}uQ#IfyvM 7F &
WsYGa}_E)_GRXQU[^c
TuUiYB{gDYW\n!C |[P .[^c	)a
;}DB~IZ[ra^-] |ZT6_hA(i_X{ZZaqY~!CERZW.\s*x]/QxdrplBDsQq_LW DA*
W]GVEZYWa_X]yNZST&	Cz{	VG	.mB\IBBqO\FJ]xZT6]^s
	K+p
xrdpt&cEq Z&UQ{M/	ViDB~IY]r}Y~^lBXO@A*K+
YB}A_BsaYXXTp[OWCho
K\YXg[AIYm5Y|x]^(RZzvM4+pN'6NDWsW|_G\	~R_L+^x	WSm^_}{X_qB~!XZV_L+&DPo*KW[\YXgZZtO^G=_
EZZW;&BzQ
(u+CB[G _AqG^{V^~[J; FzQ	e8_\^w^Sq|
.$2}u}6Uu^'	UW_XE]ZYWa_}1^TXO	Cxa	.SDB~IXZs_^	{^yV_L @Yu		;qYA|AYA}_|J^~^YJ(6[^cy aYAkX_qD~\WRZV+*XxYSWqYA{]YZr\X1_EXP@xM	*K(m]B]D\O]^~_LW [^c/G	.KDB~IYZHS]	|^yZYW)QkE*	
.}\X|YXF[YXD|Z^ :Xxs
*_	
)W\YXgYXq^{_TxY^+*Qx~^(PpN3*xpcDBW|
sR_~^[OWFWi	aYA~EX_WO\}1_ |ZIW*YPMuC\YXg[FD~^ER[R)[^c	VK_^\w_AaY{CVBO+'ZzvM4+pN'6NDWsW|[}^yXOV2]zQ*K	+^FG [@rD~XTp_O(]^M:u	BEXIXZG^{!]Z`YP;&XxYC+}]@UUBBqO_}!XyFYP(*[^c*uTS^]~QBBqOY~VXFYW+	CA9im^FVgX^bmX~)ZuQ#IfyvM 7F &
WsZ[ra^-] |[P(6	C^U	)e
;OYA| ZYWa^~!_|dBO+G^/S+}YA|AZFI_V=_
GxXR(*	C^U
W
)_XS~zxt2$&aCBZ&VZUu :G)^]~wDYaaY~XZVYM82Bkg	eq\SUk_AaC^GE|N_L+&	CxA
/y	;a]BE_AWW_G\	~RZT6BU	T[+p
xrdpt&cEq Z&U	CU
e	V[\YXgBBqO_|J_d[Q+M@xM
UC.K]B]_AqqY~]Z`_L+&_xs	Te	 
XS~zxt2$&aCBZ&VZUu ViWDB~I[B[^
U_ZNZOU[^c	_8i^DXYZHO_~XZVXI)F{E
*u		Ti\YXg[FD~_y|_L+QFS
*G[XS~zxt2$&aCBZ&VZUu 
U	.q^Z|Y_AWY=XyFYW]zQ	y	(uYA~EZYWa_ _ZBO+DY_m^Y{g[Dy^U1_[M 	C^U*u8i^B|UXAIWX~,.ui*#Ire@'] &[S}IXDWy_G^|YJ*\{M)_m]F BBqOYV!_D^XK8	C@im^Z{wYXJ[D~^~XOV2^x*}(	
xrdpt&cEq Z&U[^
:u_]_|UZYWa]VCd[R.Q	CxA*K(m^^{ZD}Y{XlYQ+MDU
/u[YAw_Aa_D~X V_O;U	CxA
/e+C\Z~E[D}\X1^~[QTB
Wa
+YBn ZBY\X1_o|YWV6@xMUi		VKDB~IXYC_F)]Z`DJYhs*x]/QxdrplBDsQqYW]zQ)C
V_^G~_Ba\VR]Z`DUTCC{	_(m^^{ZD}\X1_|pXP+2\ho

([	Uq^Bc[\q_-\GZ_LV:B 
*STO\YXg_Ba\VRE|NXI)Dks
9y		 mYA~ XSaY~V_FZT6\ho[^F ]YXJ[\X1\DB_O82Qx~^(PpN3*xpcDBW|
sR]`XSW*F	e.C\DmX\H[\n!\RXO+.@xMVS.CYAn_Aq_V)]^_OT*^E
Ty(K]@|kBBqO]~X`BO+[z	(im]B]_Aa_^Y|}uQ#IfyvM 7F &
WsXGt}^!XyF[OW	Ce	u^_XI[\G^|E|N_O M@AQVS	)S\Z ZZ\X1XE`XP+ ]AWK
O_ZGU[_sS_n!XZV_L)6Dz*x]/QxdrplBDsQqYW]zQ*u
(K]A|XBqqYXX VZT6E}]9a+C_]XAYZqq^	~R]Z`ZT QZs
/[;O^]GEDYaa^|_~ZXK8&_k*C+C^\QXDqS^U_El[K@YGq\SUkDFayBRCl`YU2Qx~^(PpN3*xpcDBW|
sR_BO+E}

([W[YA~wX]b}_FX|BXS[^ca+}^]{EBBqO^GRCZNXK6[^cU[+C][FEY]be^~!XZV^^++ZzvM4+pN'6NDWsW|Y~!CodY^V]SMW
O^_~_Bsq_V=E|NYW]zQ
(W	 CYA~ XDZD~_W`ZLVGSUUu	
O^YXDs[X~,.ui*#Ire@'] &\[}gX^}\-]Z`XJ.	@kg

([	.K\YZYWaB
-_
lZ_L)Q\{U9K8q\GX]YXYe^EE|ND^2ZSs
:y8i_S|YZSZm^U1_~^XQ 6FhA	e	^^E_As^
E)_	|_L DA K	mBXYX^e\X1^GZXR(*Qx~^(PpN3*xpcDBW|
sR^ER[R)@g(+}_SABBqO\FC`YQ+MDU
/u(m^^{ZD}_|J\Z|XI._xVSK\YXg[AICYm5Y|}uQ#IfyvM 7F &
WsYSe^{!\ ZDQV@xMVS8^^AXBHS^5X~_L+&GzE*K	(O\YXgY]a^
 \^XST2[^c:G)^]~wBBqO_X_~ZXK8&_k*Cm_]nwYZq[_!_y^_L;_AA	K	
.}_]nEYZs^~!X|FBO+[^
a+}YA|A[BYO]F_ZpDUT\gaK_^|kX^JCX~,.ui*#Ire@'] &_]nEYZs^~!_EB[PT:	Cxs9aU[]]UZYWaB]yl_L+&_zM*K+
^Sn_Aq^}]Z`XP.@ASiYAEAZYWa]
}-C^^^++ZzvM4+pN'6NDWsW|BF5XGFZT6E}]9a	(q^_~XSry^EE|N_L+QQ
yT\YXgX^O\{\ ^XQXhsWC8}XS~zxt2$&aCBZ&VZUu 
U	.q^Z|YYZHS]	|\D`_L.^E
Ty
(}^]G_AWW\X1^VX^(@xM/e\ZnwZSYC\X|p[P)[^c)KVO_AE]Sr^ !X~pXQU@xM:G)^]~wX^rWYm]WZ^WMZPg
G+p
xrdpt&cEq Z&VZzvM4+pN'6NDWsW|
.$2}u}6Uu^']/QxdrplBDsQq uQ#I