hpw/d JwTVP}bWS- VsTV'GrV`tIU I/S^QjWT cM	V^t_y|KaYvWX3P}oUR.pA
V-^-H_AVJ}bAWWGSh{HWP& uA_V-^(OzZc taWISI}W! u]'VRSW zV`A tpWnUQAuWQ1Q cw)U*bef{I
uW{A%SMlW)$u<V-^s X:|I}WcQS}IVQ! PyT-5~Ww|EZyzy|q	-Ni+Ku,1TPy.5\Rw|EZyzKxla-Ni+Km/TPy.bVuBEZy~HyAaR-sSU,Xu@/1	TPy.5\TrQ{~	GEWplR~z?baR/+TPy-5bRuREZyzF{B[-Ni)ui(/xSuQ)zulo z
~H{|_@/MC/Ku
/17z@m.5\VvB] z
~KxR[B/MC/Ka	/Vzg_V:JaAE`ZM]Y
xY~ow*I[_vU/^LUwWnBHRSBwosxU~Y[N5H]\c3.`Q]WCZ,VP^wU{cVD]TXvQ.RNwS}A|pQMkRgT *1TYLU^Lw_ZW^pQ]]SxU(T] *^\^	.dZPMWnBH`ZMYycVTQ| 5 DvU/R6VWo@VP^wU{g	Tk*1V\vY"dWR][vWd`F RQ#Dk*AvU/dVVWnBH`ZM]Y
xg3~k*1[X\g^.[Rw[sFZDFwQN
BgTk
 1U]L^	.V*S]_XHVdXY`RcU
DUy 1WDLQ.[Rw_]VrC]]SxY)Dk"@U?JV+_MSVX,d`Fwy]Gu !U@pp*EUbD\E*AG@qBU}x}pUR2[`p
*]PnZ\(AZa^U}x`U,U@`^

 Mqr\E(A]FZVF^^lV/MYb:9}S]]Z,RUGwoyRYMTk**F\Q)RPweE	\wQURQ;] 5@\c^.dW_weARHY]Y[RcV~]{ &_U'RPwSb^HRiF]QzBcZD *5@\Y`KweXRx]]kRg2wyV} ^ % TX\E*A^BZ^UVhxBU/*\VF	TYMT\EE\Q`W{ZT< G`UMqr\E*EG@qBW a(DohN:GU/RPwSb^HRiF] xQ+TQN "_LgS
.^LPW}Zd]@]ojBZKON!V[V}
+UIaT\E*w]]sBW dzU/*XV`+TnAF*I_DrpVXd}RS,XV`
 ]UbGWT __sBUx	^ZU6Crp	(Pt\AF*I^DlVn[(DohN Zc[Rwa[EV[]Yq	RU$Dk*5EQJRPw[_ZS_U\BZ~Q*AvU/`4VwWD_d`Q]~BY ]Y
*[\^	.ZWM[Z,dFE]YmBcVDk1UYvc dWIMZ,RgEwoLg3T]T I[_vgSJVTW]_CH`^MYq	RU~URNFL{'@[|S'\_rpHU
ZT	SQGs|(NHPY]g_XqNVnt{ZT< CpN	VcQr~Y]gZCq|S|B	^lT2@c+EVYnAF*I\QtNS~V.@ppQVYz[C/{\_bhTx	^ZSGKV
*QNqLZW/E^FWpTmBCVU,Cd(UWbAF*IZCqWnJ^lWPQ[pZ	TEPq\E9^YaBR~yZ*y2-#HVwU*V!HW@`abosU I PkopWP2`Q+V-ZJ}_/FptUqWVg[SHWP& cMVVVOz(RstQvT|Q SPkoW$ Ic<V-aqV:VVtQIWUs2Px[UR. uU*!s G/V asRWUs2S}}W5 cw"VTF&q}V`bAWEESCMYWP&M$Wth{@`	KFfMoSBgDk*5XLU?JV(QMW~[daYkRU~oON1H]vc
J^J_B@,`CMYagoL 5^vgP[RwW~[VB]]]\xYQoS5]L]JZ+QMZ,ZGBwYq	RcI~oTNLXvU.V*S]a\@HVUQwojBZ~QO*1U]LQ3J`3QZ,dGQURgTk1U]L^5@[|S'\_rpW^	hRS,&G`(MHrT[A:Q]EtpTFJh|U/*CBYQZY\/U\XqNTF	^ZN,@VV_fZY{\[T}RkVS
 CpN;MqY^UkAQbhU~^
{S<@[`	T]_\E* ^QUEx^lT)&
RrV*U	_qzAF*[R^R~zylR,(l\U
^(K]SM\dF\QNxU[T 1V} ^ % Qr~[[I]FrZTnR	x|VR6R
*]JI\XBA_Xa|WV	zlT.XV`+TnZW*ZCaRWVxBT/ D`VTJW\AF*I^@RU|kJU,*YsWo_If[@(]_CVU}xkJS,&ErR8MJbrY]g^\BN~JRWR6Y`F(MNXZ_/U_[WlWSVWP_WoMs[Y/w\_rpN~JSVS?MRd
TP~[@]]FrZV|hShV/MYlcTHLZC)gG@qBV~FxNWPR(_[@)A\BtNT
tSlN,'[y
uM3)vHW_e^BZzWA'SC
[T)1XsIVRQaS]tIU I/SA{{WPP" Xg1V Z$Gr*xAAuT|RSPkoW$ u]'V qy`aQOW{Y#SUW)!M+V-^-Oz/Zpa
|WU{ QAuT)I9 HwUV-BbuxZctMKWA'Sk{wW)	 X7V 9ZuO(RsMbWVc5SPUT.IS Xg1VW`4Iy:uZszWn&SSszW<P' `"V|!tGpTJsf{O2]H6Dsy*R\U?J^LU]WPDHdFE]Q|Rg2ovN5R\Q.^V]Z,`YwoORg2k 53DU/`-_aNWdQovgTk
I[R\'5@[|S'\_rpUV`{pV
6Cpp
UgNqL[@)Q]GaZT T
.]FUMqr[ZUk^@VU{V^lWPQCpN
+Mn\E/A\_rpT	|J
{VS
 CpN(sMq@[B9w^@YBWV}lN,Y
+UIaT[^(Y^DlSt	hRN/Z[y
uM3)vHYe`^v qkT~]S}QyW<-RM+U-`QeYVBtHpWVcRPzW) uA'V-Z*OzVB b]Wn;S}IW)" `YU B:aaVBt qkT~]QAuT) V]4V-^"taUpdU
WXY0Sk^W`V daa/eI}T|Q ShYW) uA'V-Z*qTWprWQjWXShQOW)$`Q4V }:bY[WFISk{|WR-4Xc^TVN.t /h sYzWVc5SPUW59 V]4VVx4Yap~tUqWnwQA^W14cVTF&aqVT|f Yo WA'SCsW5Z `{6V-^-H_AxZUAWnU#QAuW? XTU8R.aqVVBtAuWV(ShoWW<I* `VTdOz|KtMyW{]+SA]
W<!9 cw"V-F$ZuO/FptUqWGUPSh{bW<%M+VVVt VBtZqVs!6rO2eS}TV8PGrVAtQsU I/SPkoW$ [/VRZuO/dH
TW{A%QAuW
1 uY VRtaTJ|bsuW#SPkoW$ `QU;`+Yf/ZztUOT~QAuW? XTV;t,t[d/^btUlW{]6SI}W" XQ*V9ZOv]tIU I/S^wBW< cg7V )Iz9FV sTW{IPh{zW) [/VN)tC:p	I}WcZSUHWR9 V]4TVN.W_epIZvW{Y,S}
hWP&XA?V8`SOz/ktQtW E+S}IwW<I uA
V `ZYaVBtYOWmc3SPrWP.u<V8q}[TztQyWI7S}IUR. uA1V |7aSzVBttQ[T|gMP}bW)* XgTVN.t_y:pstIWm.SkAWW?`Q+V dJ}_`aW{\Vs!6rO2eLU.`"I]_mFZGBwYyg~oSNZ\^	.dZPMWnBHdGC]Y[g2oT ]vc(.V:JWN_ZGX]ohY~ *;D\gR
dVV]StEdx[MQ
Z~Y\*5"D\cV)SWS@VdB]QNRY~k1TGvc.R+T]WbBH^g^]Y
x]4ohNI[_v]V*S]axEHR~F]oTR#[ON!V[V}
YMqrZ^k]EtpS}BxVV)\XZ-UNqLZ^*]_FtBVV^
}ZW,*@p-PqAF*I\_rpVFShS
 @cpsWIrY]g^@RVnt	zlU*][
+VarG\:U]Db|T`S|WQ_KB(MNaTZ](]@bhU}xRVY`R
;sN\\E*w_[ZT}BShV
6YV
+YNqL\E(g^@WZW~xBT)*YF8sMI[X:]_[WlT~PZT
R_Kp
*]MWTXDU]\hT~tVV
6[upYNqLXFQZCqJWZ}lV<&@r` IsD[E:kG@qBU|Bh`S.6Y|	T]Nqb\EQZCq|T~R^lU/6^pdMQJ~AF*I\_rpU~^CVVC|	UUNqLXFV]Z@VU|Bh`S,XV`
;QQr~XDw^@NSXRhV,@plUNqL[Y/A_[U{}BV
6]IZ8sNrY|PrfpyVXsSo\WP`Q.U+V+eQV]ZJW{]3QAzV
!ez3OhMWTYda_wYagQ@53\vc1.VWMWnFRc^M]Y
xcTDk \c6
J`K]WnBHZ[]]rg2T *)Xc6
`*Kw_BARx]]Y`xg~Qp5@\^	.V'KWsCHVUQw]LRcZDQN5]c.V;LM[aXHdE]wUpxcTD]Y
* ZgPJ`3RwSTF,VU[syxg+oqN5*A'|"HM}v^VP^w][YMY\ 	RvY?V*S]e B,VP^wo[BQ8 **^\cV Q]StERuEYLZ~]r 1V\vU?J^ZHMa}ZVP^wU{cV~Y\ )"[vQ
9_W]wSb^HRiF]ocW~  )"[\Q.VIMWS_	\woTRQ&]JNGvU-
`_e B,R{DkQT *&[]
R)M]a~AHVP^wkBY'~ * GvUV*S]a@Cd_woO	RQ)DQ 1V\vgIJVTwSVX,d`\]ojBYToqN1U@L^	.`M]eAdp]MoTRZ~o~ :_LUJ`HSVX,ZBwopBQTYa1]LgP[_lAAS'	U|Q}J}N,*Fp
TH~AF*{]\pSt	hRT	< Y`F(NPZ^k_XqNV~FxBV,[pB
+_q~[XI^@VUEtPZN,*\sF	 {UWbAF*I]FblHUtxBS,X[
+EMqPAF*{_XqNU}xVS&EsF
NqL[C/{\[sUVh	}JS&AH^ {JbrY]gG@qpQ} Z*y2-#H V]4VZtGpVJ	 t
UU I/S}QQW)$ `
U-:t_y9`kI}T|QAuW" uE!VauGVBtb{wT{Pk]WUR. `V .Y[p:pAAuT{gPSkVWP& VE-U-ZOv/SaWmsQAuW<- u](VN"tU:I}T|S^QjW!rU$U*|tm/\Y
iW{Y)SI}T?) csVVB9WgtIU I 6rO2eLU.`"I]eF,`\Moxg5~YK*^\c6J`M]aAZ,dA^MoyRZ~oo*T\UQ
JRPw_ZHVUQwYAR]:~ *52^\Q.Z5PaC[,^y\wo xYMowNI[_v]WVN][]^d	Qw]\xg2Dk*H]LQ
J^RLWS@`BY_xcVTQh]vc .`-UMaQEdF@wQg~Yq	 1TGv]I^HPM_@VP^woiB]	DwyV} ^ % NbfZY){ZCBUXBPZT,&\up
+UIaT[BQAZRT`^lUR RsZ(MSWLZY){\QhWVx	zV
6@pp-QNqLZ^Y]QsVS~tpU/*EsV
8UJJTGWc_[ZTUdxpT<CpNUARZf\E*w^^tRVXdJU
<CpNW Qr~\F:]XsRW^W,*\u
;sPL\F)AZCqS}BChU/:Cs	oKG_VZCbV~Fh|T/ D`VcQt[B9w_[lUFhh^U	<Eu`(MJbY^)_[WlUFxxVUR2\up	TYHZY/]Db|WZS<M@KF(~[tw`+rZUWVg[SAQNW
1 IQVt[:tetIWGSh{HW! I]U-9IuVBtW{VWV3QAuW)- gTVTF&sSZc taWISI}T.! XSV `V_p:VtQvWmQS@AQW! A*U ZJCV)F}I}T|QAzWP1 [YVN"s X:|aYWA'S}ItW
-% [wV^W_et
_Tn[S^hWI' EV 2tGpTJ|t
_T{;SPMuW
1 ["VWFYf/ZYk^WVcR{{2&[eSL3`TMaGXZ_Q]Yq	RcU~U| 5 DvY>.`3WeX	\wYt
xU~Y_ /^vURS]SUY,VS_w]Y
xg*DU`*E\]I	V,H]W~[`Dw xQ~oy TZ\]#.RPwWD_dfXw xg2Q	 C\YdTRMafZZFMowBg%TYtN5+@LgR.`PM_vWdBwkBU~Qi 5%@c2^LUwWTYdvDwoSRU7~]Y
*6A\Q"VJeYHVIC]Y
xcV~QTNI[_vgR.dWIMa|CVP^woPBg+~oS5]LQ.V)QeB	\wQ	RQTURAv]IZ'N]WnBH^pQ]]Rg	
DoH
]v^`$Jwa\AdvB xYTQP E\]I.^'N]W|\HdG]Mwy]Gu !U
RsN
(H~[@V{G@qBSVthS,QRdWo_bf\Fw_[WlV}
`V)\XZ*Mr\E:YG@rQ}PRT.E|
+U[@)Q]GaZUExh|S,&ZpVcMrLX@\CpW
{ZzhTCpN
{VarZY){_FbVZ^lWR6Rcd+X[tw`+rW{[WXY0SksT.I) uTVN.W_e(Rs a{zW E8S}
_WP& u]U*`LaAUZpYopW{A%QAuT)I9 I]V^1b}z| Yw]W{YTS}IW)P E#VTdHS[*p|HIT{gS}IW5S u]V^ aSz`_ s`WUs2SS]W
- u]PV-W[:ZFI}U I R^{\WP `wU*SvVJ}b{jT{ASA]zWP&ucWVxZYyRtr szWVQAuT,!.ucWVxZYyR9J^tQyWGU SPWP `wVWN1GrxY_WEATQAuT)I9 Q(V JG^YhWA'SAjUR.rV^1ZW` b]WVWP}o	W-ZX{VTF&a@/tYYoW{A S}IT)5P I
TVN.tC`:x[YkHW{ISPW
1rVV8RUtmpI}T|QAuW?r
V^bWS:R{ aokW{A%QAuT<50 cw)VTF&sSZcW{wW{]+PxwW)I csTVN!h{@`	KFfMsyx]!	Q Rvc
JRPwSb^HRiF]]SxU(TYaN1TRvgS
.[V}v^Rx]]U`BQ~oy -"RSC %[[|^W)I^@VS|B
hJN,*Fu|
-Vs\XFV]^[NVhtT?&]N(Qr~\FV ^DpN~xVS.YsWoUs\Fw\XqVV}	`U:[pp
(sNfY]g_ZrUhxpQ/R[y
uM3)vHHX:pAbAWT|RPz\WP& cw+VRQOz/F~b{wT{ShQW<% IwV8RUt_v/Z@MWU'SIUW) u]'VTZHYeVVBtYkVT}E.SwnWP0 X7V8RUH[TJ|avWVS}QW)T E#VF(Ye`^vY
WU6S^QiW5VpQV Qt_v*ZBAuWmwZSkY\WPP" V]4V-BtUt}AuT{;PzW<P*XcVTF&tG{|wYoWnI$S}IUR.rV^1tmHQ^WVU0SP]jT.!r!U*R!spdtQsWA'S}IW<T% Xw%V-^/Gr/BvaWWXYMSI}W5Z IMV-F/Ou` 
FfR@O2BcV~k1W\Lc(
.`LU]aBZ,	\wYq	Rg1~Y\*5"D\QVJRPwa@Cdu\YaU.
k*A^	.`4UwSSW,VHZYOxQ)DY[*52_LgR.Z!S_g^,VCDkBcTDYP*5^v^	.^RL]WMF^[XMoORg~k 5"X\Q.^WaW,RY\wkB]!	k5E]
JRT]SVX,dG]oB#[ON!V[V}	TYH[^/A\[YN~J^pU.MYsp
YJaL[^(YAQIhWhxVT/E[(MMT[^(Y_[WlWxBU/ GK^
+NrD[Xg]FaNT{tpVMCp|(NPYZw]XsRU `hT.@F
*YUbD\E*AZCaNTn	ZS,&GIF	_q~ZY){_ZrUh}BVXV`VU_rXAF*I\_rpWZzTQQ@p8UWbZFWw]_IRN~JRSQU[XlVqXXFV]ZCaRU{d{NV
6Rd	NP\E*wZCsJV{V	CJH,*XV`+TnY@/I__YVR~yZ*y2-#H cM	V^1tCD:VVtQIW{ATP}oW?-& u]*TVN.HX:pAaJWXY0Pk]LW)( M^VTOz(YoT|Q S^QjWPP! [M'VZ-qyVsZAyU I/PzT)I9rVTF&HS:pkAuWVWS^QjT)I: u](VdHZsTJ| taT{gShQOW
1 E#U-FbuxTJ|kWWX].P{sbW)P3 uE!V^1GrVJ	
ZU I/P}bW
- `U-`RJy|TWIsWE1SP
iW
7 [M'TVN!h{@`	KFfMsyxg6
onI[R\'dW_wa]C,	\w]Z	Bg~o5(Dvc_`WHMSVX,d[EwU^g~Yq	 ]v]'J^HM]acZZ B xQ+Tk 1W@LU.`"I]eE`^MYaBU	DopLX\gRRNwS}AVP^w]hRYRTYyNI[_vgR.`UMe]dZFoRxU~oo53Dc.VH]Z,`^MYaZ~Q Z\c(.V:JaEdwBMY}Q5T]Y
*1W_\c7`	KweX	\w] 	cTDoT 1V]\^	.`:Lw[Z,R{\]Yuxg*D V} ^ % 
_rLGEE_ZVN~x{U.MXXV+cNq~ZY){\_ZHF`xpUMGIR	*URJ@AF*{\QqSnZVU/*Y[`
VEMqr\E(A^@VSnZ	zJVQ._HZ(PtAF*{XQr .qI6yyW
1 cwVT"YaVBt sLWEs7S}QvWIVM+U-`QeYVBtWMWUI#S}IW5Vs<V-3W_eVJ	
ZWA'S^UtUR. ['Vp.Yf/ZztQyWI.QAz2&[eSL3|"T]}v\^Y@Y`BZToi	N]vU/R NwSg_,dE]wo[xU~][+_vc6VQIwZ,dGQURg*~]q
5+@LU[RwagAZ_Q]]mQ:TQZNY\Q.dWQM_E	\wYLU]JNZUJRPwWbFVUQwkx]
QQN5)FLgR
JRPwSbDH`CMoSxZT][*Xc..R*PMSVX,RGZwYq	RU~][*X]I.^_]Wu[,RpZM xg;~o*5Ec^.[RweW,daYYB]U~]Y
*)X\Y_JV:NM[TCdyCMY\RZ~Q}5^vY.	.^LUwWWR ]]WxU~QP*Av^	.ZMMSSW,ZS_]BRY
~U\1W\LQ.`LMWNEZR@Q[	BU~Y	 5 DvU	.ZWMeY	Q]kRg$TYaN*^\YZ'Iw__A,Ru^]Y|BQ ~]Y
*5H\v^	.`K]_^Z B]YBR]DkN:G^	.R QSSW,ZS_]BRcVD]Y
*LX\gRdUMMa\D,	\wYz	xQ&]Y
*5Avc^.ZWMSVB^u@]o[xQTo]vU,VKMW7DGU| s{ZT< GX`VU_rzZ](\BpTGBxBHSU[X^
*YNX\E(A^[NVhzT	S]N
VVYnY]gG@r  .qI6yyWP `wVTN/vZctQyWn]Sh`W< V{-V;t7Gr(t^Ww~U I/ShvT,!. I]V;WegVBtAjW{A%P}oWPM+U*SOV` 
FfR@O2B{#~Q :G]
JRT]a\HR}@Q
QT]Y
*55\L^	.dWMMeXZu@]QMRgoV	 5^\c^.`L_aaY	\wYq	RgTk 5@\U?JV)R]W}FdxEwkxcVDYvAvU?J`3Je @VdGwoTBQTUZ *^vgQJdZT]e^,Z]@]Y
xY ]B 5UY^	.V(QMa@ZHd_]]oV	RU~]~N)]U*JdUPMaxEH	Q]kRYMYq	 53DLU
`RaY[d_]]YNRcVDor %EQ.dWHwaAE,dZBwU|xg[T]~NI[_vU,.dTH]a@CZ\Q]QyRQUZ 1U]LgP`RaY[d_]]U{Y~]5RL]-RPwa\D,dgFM xg2YaNZ\U"J`*KwZ,`_MoSRQ:TkE\Q.`.PMa]	\wkQ	TY`;AvY	.^SHZ,^rYQyRQ]JN&ALQ3.`LMWNEV[]Yq	RQ4~k
1WDLUJdUMMa\D,	\wkRYMQ* [c"	J[_]_],Rz_MYq	RgoV	 5^\QQ`2SSSW,`^M R{#eON!V[V} ]_sXXBTg]DWBN~JRT	Q^^cJr~\EQ^BZ^UVhxBU/*@pp
*MJbXFV]ZCsJSEB}lU.ME[VY_bDY]gG@qBUnPtU
.YuV
T MWT[FWc\QJRN~J	hZU.MC^*VqX\EEA[JSh@`TPCpN ]_sX[C/{]XsRS~t
pWR6\s|VNX\E:Y]Fs^VXd	CJS
 CpN	T NX\E(AAQU}hxBWP[scUsZDA^BtVSXRSVS,&YXF	
WUNfAF*I^DlVntW@VV
ERX[B9w]@W|TURCVT?XV`EHtb\E*AZCq|U|xBWPYV(MR~Y\)ZCWZWF^h|U,@KFV_f\E* ]_t|VXdU/:@VBUoNqs|PrfpyW{ATSPkW? I	V8ta}`I}WcShIZW)/M+U-tAVBtYo
WE{WSSU
W) IM,VF(a}` bUT{ ShUR.pw+V^Oz*p|HQNTmA2S
yWP `wVTF&aGU:teaYAWnUUQAuWT" cw)V;t1vt|Y
iW{Y)SCMYW)$ u]*V8TOzVEajW{YS}Q\WPH `E	TVN.t_{Va[W{A%S}QyW)/ Hs+V-^(Gr*Rs`U I/Sk{qW

 uE!U-`PH[Wprf{O2]H6DYz	*'Ec"	JV:JWS_RUY]oxg%]Y
*T]L]J[RwaAXdG^MU]T]Y
**GvY$	V*S]SVX,dwGwQ#Dsy )"Y\]I[Rw_]RhDkx]
][N1U@Lc.[_]ST^HREY]Y
xQk5Av^5@[|S'	zy2qI6rO2eSC %[[||Pr