bptVZI_V~A~W%)Jb^tPFY[Vc^V>UYSW@! P 5P@zZrVZAnV=UzIAZWT  Q.VPttPvWD}VIRV(Y~IwWv Q2O!vf{ @bRMA3McUaF]]bR] tE5^BwXwPU
U\+U~_YQGbP\*yX|5dCwP_UwXEw{yYwYYx}X^NY^|)tXwXC]f
]{y][QwQGG\_*[|lDXo]wTL]YN+UW\]QzGfWF MF|5d\wP_]fMc{uQRODv\V!VUZ.[^t[Z^q[hW`X]qBD{KR1TE*Y@aG]ZCXsZWRFXBp\]e_QU_jC@qC[XJC[
WBWQZXDJZYx_
@PU\Y^KZ\Ym@qJWQ^ZCV_uCV[\6^CJK\Gqq]sBTNDQbhD{t\yV f{# bT~Z@oVTU=s` thW~X)6uQ%ttT{bvyTIuUYGtQyWPr Wr\Tf sZbroVbIWVYI{ZWhr! )Ijan[a\VZ~V>sAW~D &{TmH\ParnVoWPwwf{E2XIe6hDlDXwbwgM
c_wY
WPXJ \|zEwnTCwT`	wg[+UUZ
}bSY2D|5VGwXnXM	wYUQWXYFT]*aEFAYMXrXb]MghQaX
}\'ZN6OEV5eGMPsD]TB]\c{CQGf,@N.yQYCU|Q|_rJU	x_CqJ^	~[Z<%HDZYa[YsS@qxQ.zy2zpO
"[ xI@QWvR3{	O3LCfMU
}T\ [_V1[TTZTr
MyCBU|
vR/T@x&YDWW[Za_XrN-N_@Y|]_GPRU[xM\Qs[^UsW_r  /WufpyWPH WrA)]H@}YfWUsTSMyaCWBX SWyjPcHrIcVaYkV(EstQsW~@ <WPVztb{A3RHO3c_wo\_*^|__MndXwbB]gWYp@]]TW\&^N2^F5YwnB[]PWwgOUuX]
}f#F\Q|1ZM\tG]b]wUY+ce\wYjG\_*2X5}^Mn\ZbwgV
OgZMk}T]*2Q|5VCMX~X~wM{yCBU|
v@,UFQ[[WmZ\qZqdT^[Z^Ce
DT\2_Qqp~t3pqV(]utQCW\K PSy Qg qTNWDDUYwVQEqkWS <2ob@XDnVaRTSMytMeW]DK PSyCW tTbbUVItVQu tQWSb! P}taPL{VbYU(aMW% )y\ JnqJbpVA}VRMfYVr'e&XOfYBfMngCMTo 	+cCE]oQ}bSYQ^|5^^P_Xwb}wUY+UlBMosW\_*IQVpBM\T[bwc+g GMQbSY2Q|RBX}YT|MUY+gCMozGT+F*6[G|1^MXP]]bT]]p	+{uQRODv\V!VW@^CsK\GJGXWdTSFZ\J|]
C
])U[xMY@raXFZS]WRT^XFrJY@C
X
5TEy Y\OADqO]qtUSVDZlD{K
DT\2[[WmY^tSZY^T>pYZ|_i]QVYRU[[WmY\WaZRTSZY_aND{K_SWQQZYIOXDC[tT-d_CWZ]Cy\/-RQz+zxbptVtEoVg_W{aW@! P2W\yWLyWXbVtAV(]utQ~WSz> .zx Y~WXzVWA}U(ctIuWCv) )spJzHUVaYyTSMyZ@WC)6Ora\aWs{3'CfR@E2Gf]^N2ZFQF]n~AwXuc]XkGbPR* _B]X}@MPWwc]XoxWP<AJ \|1ZM\UFwTy]Qr+]Bk
Gf-R*6L]|I\wnZMb]gqg _o}~%RNUwVU|^UrO]YtVP^_CW]C]RUXR:^CW[ADr_r  /WufpyWbW SHRPdtPvWz}TIuV>M[ t]TWk\* P} tDt~VHTV(Yxb{}UH) "@\-O sXuavrUtgOWPwwf{E2XIe6 Y|5@_]nCTB]c
c{CYxWb]_N2^F5CC]X`G]PWwY|O]s_M
}f]2ZFACXCGPWwQu
cWGwoQ}bP\.yQYCU|Q|_rJU(X@q|_xyC,S@R&XZt[Dqq[
rxN-|]Qr
.pOe- 1YGYgVWskV>wtIuW~X% .Ox@TUaUuV]Y
sTyv% )\!vf{ @bRMA3M{y+gYwobTE z]|]]\~FMf MQaO]CQ]
b]Z*6ZGMX~Y]	wc	UuZ]Y{	WT-A2EF~_Mj]wT}Y	OUPF]oc\[N*yXgCU|Q|_rJU
.|ZDIpYSu
\)SCA.X[sXAq}ZY|N-|]Qr
.pOe- QRY}tRVc
VM~
sW~D3 P}\yztb{A3RHO3uXwk}f&X6pCF[]\YX]bCcUuFo`WT]*2_I\wTVDMXtY+UW_]]c
GbR]2\V|]w\~wlGN   U|[xK	\/)W@X[s\Dt_ZstUd_CaVD{yR/Q z #fpxfVYHVetVWbV 
N\CH@}sxWs{3'CfR@E2Gz%[* q]V1\]XsAPU
U\+YwYkbR@ YF\ @]\]g\	Oc@FMYUWT]* _YV_\MXw\]Q_OYU@MUp	bQ[Nm[V1^Mnf^c+gDwobGXA* q]VI\wP_]TQcOc_GMkWf"G*6E1^MU]~wlGN   U|BS}GRW@^CsK[@JW]r^TxYDYl^yu
\Q-V[\6XYt_[@bq@qJT/pXDWV][
[/NUXz^CW[XBW}[	SQVZ[Wl^
@}\RQz+zxbptUqVEIDW.Jp tmtXVHIrU=s`{uW@! )xaFWv`VZs@U(nY W~H> )yDbzYvu3{	O3LCfMo
}f\ 6\VFY]TS]w\] 	+QaGwYxP.GN2\1^Mj ^MPWw]Qc@]wwsXFV!U UwU\QrC\DYqY^TRDQIhYBG@V@RXXqW[GHaZHVS=BX_aD{K	[,UEB*XXqWZUeYVWRFXBp\]e
CUXzYCHm[DHS@rSpXDV_y@UD\E^Z_ADqO]aRTSZ[^J^y_QUQzU^CaSXFrYs`SVB@rYSuE
-SCXXa}\GJG@qJT`D@WlYhAR-VCMXCq\GWWZ	axTBXEWpD{K	_,V^RXEa[DWCYdTFB@qBYSu	X.NWF\*X_ZZ[m[hTB[BshYG
X
5N@z*^@Y}X@I[YBTS|Z[WlY{uC
TDi&C@qC[At}]IdSRdZCVBCa@SCzQYQtC[DHSXWdSFB@qB\x
X
5TDY]r_ADr_r  /WufpyTh JQRY}tlVIsU>{ bkWBH. <Zp tj]Yf~TIuU(ntQCWbW SHRPdDbPVtwV(]xtIuWSbTQ"{fp[BfRA@bMfMUY+cmBwog
f/D*2^F5~GwXwTUwQ|Ocs\]QD}bSR*2_|I\wng@To 	+cGMoybR]6v_F5^G]XwfM]|UMY]YQWXA*6pCF5eYvvURB@ |   Y_rZ]@[C,TXx^C[Y_WaZ`TlB@qBYhAR-VCMXXqW\GWW[HdU(Z_CaN^a@
T]x\Qs[^Usl/q3,ubA]WH( <O IotPFtD Us{JU/YHYWPX	)6OxtPv@VbAV>E
sWS> zCCa\WXzVA}V{HUfTh>RuBP^H\HL|VtAZV~ ZMkVr'e&XOfYBfMnC_]bY]Q~UrYM]S
}XUF*2^F1_MnxG	wUZOQPQwo^WT\N2^F1Qw\TDwbg	M 	+ceQocT]*K]V1^M\DY]zwRGN   U|[xK	[,SC&^CaS[BZZsZU-Z[WlDx	\/)UXxXXYa[At}[sS-p_CsJ^@_	X/1WYBZD\DrGXWdSF_Cq_y^/N@yMXZt[De@qJSp[Dl\]e@,%T_zC@qCZ[r}FS-_@rJ_~[.T@2YCHaY_Wa@qxQ.zy2zpO
"[PR tmt\GVIWU.AxApV]r e&XOfYBfMXSXMTl]\QU^w]Q}TAYF1^MjUwbU
wyCBU|
vR/U_y*Z@W\Ga_Z^SpB@qBYSu	R,VSCjZ@S^UsW_sRQ.zy2zpO
"[ IlaQtvpVt_V]Bb{jUH
"\fp[BfRA@bMbB]gWUf^Mk
GP6] r_I\wrv\wbfY|U}]]oEWP=GN2GFFGwPU[bgyg\MY{	WTG*2Q|FY]P^Cfw]Ig QwUZf-F*wE|5VGwXwT]c +g\MYsP=GN6[G|5CC]j]wPWwc
Oc_woQ}P!_N.yQF1 XPBGwbUwc+QW@wkW\_*{Y1\]\B^fwc
+\wk
GPR*	BRQ]XwT]QaO]AFwkGf%C*6ZT^wU]~wlGN   U|[xKF,)WD6^Cq
GZYWxV`B@r[x\yV f{#HxHXbUbbU>E tzW@! )SwR1ztb{A3RHO3uXwoFWfR 2Y|[]jCMPEwYZ
OQ]ssfFV!U UwUY]sC[[tq[aU>dDXbVB]}@PN@zYDbW[Cq}[q^SBY^IR\]e@,T\AX_
[BZ[XWdWZ[^W|X{x\yV f{#WzTtQVc^VwaZ{JWD
 RLjIg qjJvcTIuV]ftQsWS<.jImvvuVtYvU(|AWk6 Wu z1JzbtXzVbswTSMyWQ`WPX) ZPR a\yHTAVZIyVQxAW~X*. ztHpt\xVas VlIwWSV )bx qzzWD}UqUIVQLIwW~@R P2^BIwW}L{VYgV(]zYoUH
"\fp[BfRA@bM~wwQqg Qw]P}PZ 6j_FC_]j]w	wQqcBC]o`}PC  TB5eGMXn@bg	wgLg_Yv
W\_* q]VVXXC]bawQKQU^wkG\_* aD)tFMrvBMToc+Q]ssfFV!U UwUYDbW[Cq}ZsZT/NX_t|]__S9WDQ[[WmZ^WZr^N-NYZZlYyC@V[\6Z^rqX]WC]qtV
=RZGZJ\PR,( z #fpxWvUVt_WwYW{_W~ NiZ t\QW\dVZIyVPDA`Whr
R^\!Qf{ @bRMA3M{y+gYwQ\WfOYN6jYFIXrv\lB@ |   YXa_ha[?TCQQXQsSY_Wa[
YFSV_CZY{u
[)RQz+zxbptWWs[VUwHQWBX yTE@eL{VWYjVQDZ{JWk )TQttHpL{VWswV(Y} sYpW. <OTBb@XLPVbUVQY sUH) 
jyWTvt@ZVrV=]CEWhHRuCCWvMLzVItV(SaQEWP@2 )Y xICt@Va\AVtEyV(Y}H] Wkr>RzRvHTtlVIIPU/vYWW~ 
vCCa\WXzTIuU=^WQ`T~>)WqRPd avtLWVWwWV(SApV]r e&XOfYBfMrv\wbglQ]ssfFV!U UwUYDbW[Cq}YZtS-FX\JN\_EU] ^CW[ZYWXtJURFB@qB\~K@9TCx [Xa}\Gqq]rTPdZZJBX{x\yV f{#WzTW\dVtYvV(MUH
sW~@RRu{_bLYVtEyV(Y}WwtWkPU )t j-tPytLWTIzWwPf{E2XIe*yX|5B\nCYw	wgzgCMkfOYN mBFc[jUwf  	+c_GM]~Gf	]*2X1\]Xn@bZ]c
O{uQMssfFV!U UwUY@s}[@W[ZsZVBX@q|YkG\<RN@z[ZsSZ[aC[
SV_Cq|Y{GG?TGz*[[WmXUI[YWtN-N]QrB]P
])S@R&X[s\GsGX
bFW(YErlD{KC<W@YFZ
ADqO[
rxS-[DIR^]KC%W@[F
\GJG@qxQ.zy2zpO
"[\gtTQt\wVIsTSMytQ|Ty <WuPR tmPxVWsVVwApV]r e&XOfYBfMnTCw\wgpUSY]Uj}bQ\N6i\FI\wTSAPdMgk	+Yn_wU}P=GN6i\|mBMnAG]bwgM
Ud]wozGbR]*yX|zFPA[]~w]yCBU|
vR/S@R&Z@W\Ga_XbdT`YXa|Y@C]RU_j[[WmXFaO[ZN-NY[sBh@)T\Q*E[YWY_Wa@qxQ.zy2zpO
"[\g[arbVt_V(AGtAST~> )q xIzta@VHYNTSMyIgT~fW.WH^tPFY[Vc^V= q]CWPT < k iE@zt\xVYQ{V]fa]Th STQTmY}abYTIuV(StMATh@O<&l{ tmtXUsSV(]b{jUH
"\fp[BfRA@bM~wwghOUmDssGz%E*yXgCU|Q|_rJU(YXZ\@_C,)QQyRzxbptVZI_V~HAVW% )uJnqLdVtAV{C{q2qeOfF)tXwjUwb]|]^o}bR]J QV)tXlNAQ| |T^YXsNY{C_<N@zY@s}[@W[[Y`T/^ZXYp_
}EQUZ C@qC\GW[HhV>`Z[Wl_kG	[)T_R[QSY_WaFqVT
^[BZ^_SiR,( z #fpxt\wVHUzVQEqICW 
JrrW}LVZTSMyWAxW~X( )\TYbzDbfCWs{3'CfR@E2Gz%[*6lGF1\]\~wlGN   U|[xK	X.NU_y*C@qCG_a_FZR-xX@s|^]_^-N@yMX_rqXD[YJ^T
.FY\I`Y]S@.UYjYDb}ADqO]YtHRDZYS	[,UEB*XXqWZ^WFdWPRYXY`Y{uANN@yM\Qr	~t3pqVSEE
JT~= *PQta]L{VtYyVQA tYWhH PSP xHrZLQVYrVREvk WS)JiPd tnL{WWs[V`k WBH. 
 itHpLtVHU
U>Q{pWhH Q*jIgLmW\dTIuV]ftQsWkXS?*^i!zaP@LtWWs\3'CfR@E2Gz%[ XtwWzSb{A3RHO3Q]YV\%XNXV5d\MXwbwgM
QM@M]^GP)GN6T_T^wj[b 
M 	+cGYFWXUF*6wCBwnBBwbqMQOg^Mk}bP\NJ \|5}CMXSB]bA]Qvg^Mk}fYNlXVEM\VZw\ZYR\woz
Gf]N2_Y@wnGMXnwyCBU|
vR/S@R&^Cq
[Yqe]rJWXZYZDxR/Q z #fpxWvUVbE]VXb{vWhr
RuB%|tLaPxUsQzTSMvW{V2qeOfFGM\CA]bgwU\+gZMQWX[ J \|V_]j_PcQO+QU^wkGf+@N t@V1\jZMfMUY+]pEQuG\_*mG|5~[\VZwbUwcQU^wQvX#\2_FyFjZMfwc
O{uQRODv\V!VQQyY][Y@qJSp[@V_y@-T[yC@r^Ur/q3,uZAUWS. P  pLZ~V]bWPwwf{E2XIe*yX|AE]\CA]	wc+cZ]c
GX
ZN q]VI\wX~Y]~wM{yuXlODv\V!VUEX^q[[tqXIBV|ZXtBYy
X
5TF6YEaSADqOZstTZDGYBY{CF))U[zU[[Z
XZGZxT/F_Cq_
}E1SCAY@i\GWW\qy /WufpyV]r )v xwbvCvuVWYjV=EHQDWPX) ZQIG azQvVIwqTSMyWQ`V]r	
"U\!Qf{ @bRMA3M{y+U\_woF	}P=GNp\VXQ]XwfMc+QU^wQb]^N6OEV1\]TTUw\[]QB+Uq\k
Gf5YNJ X)tXlNAQ| |VFZDZpYB
])TF6YEaSADqO[tT
ZZ[Wl\y[	\<HQRU[XtC[Y[`R-}zy2zpO
"[\g@QH\@VtYvU/XZW~)Jb|YjVDsTIuV=BHQDUH))"z xTEWPeDsVZ|VEbZ{JWBX 2{tP{tQTIzWwPf{E2XIe6 Y|5@_]X|[MbZ]QhcrF]Ys}\_*6Qb@w\VZwTx	cUz\]GTF Y^|pCwvvURB@ |   ZXqN\ku
@VDQ*[CIuYGIyXWdV(NXXqRD{KC.%TD\[ZsSZ[aCZsZWRFXBp\]e]/)WY\^CqKGZFV`Y_Y]S@,%SCzC@qCZZG[ZJV`X\V_SR,( z #fpxWvUVHYNV]fJ]TxD(RuA)] qvt\ Vt_U-wp rU`WBDT 2Y!vaAH\@TIuV(SEWhH <Ji-AtHpYbVtYvVcATWSf SHRPdbvCJz\TIuV]BtAST{r& W`QIGHrLtWWs\3'CfR@E2GTRDLEVo@]\rFMbgcBC]o
}f\  [_V1QwjZfMUmOUCZw
}f4GN[_5|Ewj ^MPywg[+][]YU\_*6h_|1\]\QB]XtYNcYQMkWf@ 2ZF5}BMPFTR]yCBU|
v	\/WDAC@qC[BZe]JBU(BY[s^y[]1HZxUXZ[[[tC]rBTSZZZt^Y@CCQ1W@RMC@qCZ_qXhH>d[@V_~WR?SCzQYFZ
ADqO]bS-DYZY{u\,SC\ _Qqp~t3pqVMSYxWD> 6C-XtHpHz[VI V{EAW@z ryaP aP UbUWTSMy q{WBX)^DOt\wUtgV(]xIo
Whr  H R1dztb{A3RHO3YnGM]V}TRDLEVT^wXoFMbw] 	+cYwoGWX
\ 6Z}GMnA]PUUY+Q[]o^WT]* `BFmBwn\CMbA] 	+][]YUbP\N6wC5@wXCBwPWwg~OQNC]QT]*2 [F5A[wnTCwXnM]Q+QU^wwsXFV!U UwU^CtK\GWWYTP[@ZN]_
EQRHCA[Q[ADqOZstTZY\|^
C@
SCz&^CsKZUe[hR-}zy2zpO
"[PMOL{Vt_U-{tQ|T{~] <&Y\gHrtfUtAJV=ED{uUH
"\fp[BfRA@bM~wwc+g_w
z%[1NUwVU|YGIGXZxTSZ_CZ\]e	_P%WDBUXXqW\GHCXBUxB@qBY{	X,VU_j&^CaY_WaXqFV=p_CZX{x\yV f{#WzTtQVWBU/DWQ`Wkv )y|@QWvR3{	O3LCfMo
}f\  	^VF]]\SUwTx	c	OcXC]]S
}bP\N6B|I\wXgYwb~MYUQGM]FWfPGpGF5E]X{Df
Mc+g[ocWT.]N6k\|1Qwj_b]g~O\wYDPZ 6pCF5zC\PFwT^
wUY+UlBMosW\_*2F|1CMTsD]fwY	Oc|CMUj}\_*[VRBXf@]Xp	]Y	OUPF]
}bQ[N|@VWBw\TU]b}yCBU|
vR/S@R&\Qs[^UsW]YtS-[FV^BW	\/)HCA[Q[ADr_r  /WufpyW@ SS@QIqZHaZbVc
V} YMkWkfTRuPr s~zaDYVtYsV=}HQDWBH. )Z bHDsWs{3'CfR@E2Gz%[*6 Y|5@_]XwfwghO]YQ]YvPP]  T[FI\wX~Y]bfY|uFMssGz%[1NUwVU|[DsqZW^U
>dYZIY]SEV[\6ZD
ADqO[	tTSF[FWp^P_
_%TXxYEtq[DqqZFU(VY_^i]N@zY\aq\GHaZ
qRHX]q^
C_P)RQz+zxbptUr]VPgJsZWBH. 2IR1THrsP\UaUsTSMyt
uW@ SS@\-OaP@a@VtETU>YEbA]WPH Wr G tL{VtYyUlZvWPr?y q tnHZTIuV}Z@W@!)jyIntDqWs{3'CfR@E2Gf\Z*6M_VPF\SUwbZ]UY+]p\woW\_*}]VBTXwbf
wQ|O]Bk
GbQ\N6r\V5A[]nXU]be	wQ\	Un]UVWT]*2_-tQRNAQ| |V-BYXY`D{K	R<V_*^Cs
Y_WaZZ`SFB@qB_~G	X.NSCzQYFsK[@J[[r`WQZZt^Y@C
XR5U\B:^CW[[DbeXWdW^Y[q^a@
N@zX_a}\Gm[
aS.FYXqVBCa@<TFy^CJK\DrG[
rtS(FYQsR^PSR,( z #fpxt\xUtpTSMyH][WbV,IQM az}W@FVtAVSEE
JUH)<*R z)CYVt\xVaNV(AX sBWP\ SSpanMzVaaVl asXW~\- R.^-c@zbv[VaYbTSMy q]CWPT SljQHrWXUsTSMytUTWPr 
irTsRVtAWPwwf{E2XIemG|_X{X]f MQt	]qCw
}f\Z*6M_V~_MT^ZMbMQn+cX@]
}fF 6FFQQw\CMPB]gpcd]]k
G~%RNUwVU|[[tq]WRV	pXXtJYkG^,VN@z[CIKY@Z}ZsV=pX@s|^]_
Y.V[XXtKZ[[adSVX^|^yu	GWQz:[[WmYZYSX
aVN-N[QqB^	{_QU\z[^Y_\GWXWdT/ZX]H|]@uC?9UYjY\qYXJqZtBV`YQ`^
@iC,VFiUXQaZ]tOZrRS/l[QWhX{x\yV f{# bT~Z@oVYV(E{ thW~X Q
jHPAt\xVYcIV]{UW@!Ru\vZLQVYrU(cCaQEWBT&)Wx s^bPCVtAV=QSa^Vr'e&XOfYBfMnTCwPP]]zOcYwoGWX	R  s_FGM\CA]bfwQq+gZM]S
}bP^N6@XF5~G]\fZMbg	M 	+gZMYkfO\* }\5^ZM\VZwzwRGN   U|[xKC%UEB*XQiXDSY^U(R_@rJ[ySR.QQyRzxbptWWs[V]fWwHT~,RuPr ar]aVYQ{V(bATV]r e&XOfYBfMn]wbC
]Qjg^MY`
GP.\N.yQYCU|Q|_rJV|ZDZp^@S9SCzQX[s\Gre]rBV`X_IV_kGC,S@j X_rq[DHSYI^TZ[B\ku	\/)RQz.X_rq[CtWZZ^S-Y[sY~C@
WDBYFZW[GsXatU
.|ZXqN^BWC,WQzX[s\GtG]WRWQXFZVYB}\V[\6_QquG_a_FZN-N[@VY{u
RN@zXZWZ_bG]YtS>_@rJ\iR?1V[\6C@qq^Ur/q3,uW{QWH )vRT HPcLtWWs\3'CfR@E2G\ FNjBF5VGwnu_MbC	w]I	+cCCw]S
}fWE 2X|5d\MXw\wc
c{CYbGP4]*2^F5YwnB[]fwgh{uQRODv\V!U z #fpxb{A3RHO3CBU|