cpsHvc@[ Y}VX]{EY;t[Eb_Y{VAJv@}c	JsV5ZX{IX;JBA(L^]^\UBqj_ c	HPY
p%F^~kETVXA(z[Px{sHbvM|0@}UPvZ+YZ(ZB^DU[aXA~gVRoIX]kAW^D_UL\ZzRFqv[ns
P]rN]F{ ^XD+~]BSfW^WfC]W/pZY]tXY*\_YxDT]YjD~M	NQY
I]F@AX.^YY*L\Yx\RFq[V
JU	sNX^]gX.VXE;r][h@OEqw[~vMh,vJ!m@PvZT&XB*T_YhvVE\BM-1X^]gPVhZBWDGAxHVGWz\nsTsXYT{{B+ZX_XAXAXW^_XcTSUs@E{IG ^_A_[zXTZaDUG]QS
V]F{w	B+F[_WD]CzW^WfY~MW=Mp]F{w_.Z_B(^GbW^Wf^ 
Q(ss_TxI[|BA(LZAPvRFHG~U/
pRYZSERZ[+]\{TOEqHDYM=]H5X]xB |XZ+@XPzPPTr[~vMh,vJ!m@PvZT&X\(L\XhHUFZP\|E
UQ c5@E{I[)ZZE+b]D{PTYqTGXUR-QK-ZYwP+y{RwgyswlEQs^[  s]Fw	B;ZY_(\P{OEr
U}	RYp9]E~I	B;XBT\D@zT]q\Z~	JPUu%F_XZZZbZBzjI[U|QN-Mp]FBE	B+[GWf_Z^fTAY@GXUM-Au5\T{zZ{Qqg)wseEOP|[Qs U`%ZX{IER[_-\ZBx@V\YXXEs
PSE
p%ZZS[TtXG8\_Z^fWCb[U{N-M
p%FThcB+hYZr_Z^fRFsGUc
H/Q5F]c	B8_BU^EC~UYvG~EN/s
VYEUYh^P(	{scpsHvc@[ Y}V_TxI]Td[]X]\xHUAYPD~MM-EV]F{ EZXA(r]DxUG	U~{_.Y)
 czrIs6GBT%	TuU]tvG|LQp)ZF{Y^;FD_UL_Z^fRFYPDUA	NAV5Z]yY]^XF(n]G}fRFq@^U{MU
p%]F{EP+y{RwgyswlEQs^[  VZB{kY+^_B@]D}fU@sH_XcN/YVYFCEE8tBA(L]DxV[tXGF{Ucp]FBE]WxZPW@[Px{sHbvM|0@}UPvEdY[VT\EPfUZtDD~M	K-YT PU`X^-r^A\RFs@Dn 
H(cuXFCZdZA]D{zUCZbD}EU/H1XC [WFDG ZBC@V\av_Xc
S(]
`%FA~I]FYY+]_PHRFtD	U~~^tWvJ5q wfDT&T%]AkbW[tPD~M
K(VYY]]F+h[_WD]CzITAF_Sgu%Y[ACUx_A+D^A\T\tT	U~~^tWvJ5q wfDT&T%]GS\UFZPG~VRoc1@E{I_TBXCV~]C~WF\~YMU
KX@PEZd]P+L\PjWF@
U}_-~Y)
 czrIs6GBT%	TuUCW~\GMU/
9ZZk A+JZY-L]^hW^Wf\{sM/[YT{{B+ZXCVz_BT^sG~s
PQu]Ehc	BR^P(	{scpsHvc@[ Y}V]EkQZ)Z]r]YzXOEqHBUY_-YX^]g] dYZ*ZAhRFqDB{cN-MIVXFC	BR[_-\[Px{sHbvM|0@}UPvP(JX]WDZBxVET_|
R>HVX^]gY.t[Z @\EVGaf]{M	JYs)Z[A^;F[P(L]C~STq~
U}^tWvJ5q wfDT&T%^]^\UBqjDYW(Q1X]kwA+J_A-LZBhT]q\GGAPPEp%\T{zZ{Qqg)wseEOP|[Qs 
RREN[TIA+JXGX]BSPRFq\o_>gpYE]	BFBA(LAPT^s\GQ	S/Qr[]SkZdXA~]\STq{[~vMh,vJ!m@PvZT&[P(LZBxTAYfY~MTSUpZZB_JXEb]_^jSTq{[~vMh,vJ!m@PvZT&YYP^\zTU]bv\|]
Q X[\kIA^BA(L]_A\W]avDs
Q]
sX^]gX ^ZZW_EkPUZr~	U~~^tWvJ5q wfDT&T%ZB}@RFWPDE Q.sVXE]	BUFX^~_Z^fT]YzG UN-M9F\PEGxYY(X]_vRFs@Y~]_-{V5[AgC8FY^8^XhHSTq{[~vMh,vJ!m@PvZT&[P(L^A\OEqHA{U/IYXyUZTX^8]YzXUTb@_Xc_-~Y)
 czrIs6GBT%	TuTAYbDmg_.p1]FkEZ;hBA(LA[XUYbD|sVo
V]F{wP8`YB(n\ZSvW^Wf^{Q
WSsp(rIg*qs5AGTuP|
U}MNsu)[^y[tYY n_Z^fT]HTU~
M-]r\T{P( {RwgyswlEQs^[  
p[[{EVRY^L_Y}XRFqv\~AN-M	ZYcFW^ZY8rZBxvRFs@^{QMEp(rIg*qs5AGTuP|^{QME	cX]kwPTxXE;rGAxHW]qDG~E
RApYE]X.V_B(X]]hzU[vAXUc
uZAhwA+JDP(_YhvRFqvUFQ.sINX^]gYUhX\f[Px{sHbvM|0@}UPvF ZY8r]^{\T^sXn
Q-UuYC{Zd_A+~A[~VCZ\~P=[RY\SIXFBA(L_YxDRFq@XEA
N]rN[^SP(B^P(	{scpsHvc@[ Y}V_TxI[TBA(L^ETI_DVsU/sN_Tx YV[\*P_F\VGZTGFAVop[[SEh[CrZB^PVETXEA_-~Y)
 czrIs6GBT%	TuPTrH[}U/[ZkwFWZYX*~_Z^fUZY]|TpXB{EC^^P(zXP{WBqDFVY	NAs)X]kwEUdX^-rGAxHTYzDnVQrZZxA	A.Z[AUP\YPjW^Wf[nA_-~Y)
 czrIs6GBT%	TuPTrH[VW/	[NZCP P+|]P+\YATVXsT_{c	HQ{p-X]kw	B+tY^X\CzWArzD~M
JSYZG{_hXAUfZBzW^WfU gKQoH)[]{]	B(YEW@\ZCfI]t~	U~~^tWvJ5q wfDT&T%_FxDTGY\^{ 
N-sIYXyUZdY^8@GAxHUEZ{U
RP]K)]EkYV[\*PGAxHW]qDFUQVop]FBEPTYDWD_ZXW]tPD~M	JRs5[_wEWdYAUr]^@XSTq{[~vMh,vJ!m@PvZT&]P+L\^{zUZr@[n
RA]F]I	B+^Z]W_YxDRFWPG~sM-ApX]xZ)_B(]]TTr@F 
T=Ep(rIg*qs5AGTuP|XET/]
p%ZCy]A+JYYP^PxzUFqXA{T(Y]F]QP`_B@AXSU^@_Xc
JYc%@E{IY(YZ*]Gz@T[rA|{MUp)_TxZ{Qqg)wseEOP|[Qs _.Mp[\y{[ _A r^EfWArzGXUN-MFT Z)Y^+~]BAfVAjUmEUcp-_Tx YV[\*P^ASDWArz\nsJ>cu%@E{IY.Z_B*A[@VETGGA	J]-Z[k]P+y{RwgyswlEQs^[  `)ZZ{Q\X\(GAxHWBqDFVY	LsZZB_JXEbGAxHVAf_|	J{[RX^]gAWtX^\\YxUZtvGXUN-MK%Z]yYGxXA(r^APPUYJD[ M-s
p\T{zZ{Qqg)wseEOP|[Qs VQrY^P _.RY]Tr]_@V[@F M-s[ZY@EB)XATXGAxHREaP]FAI-AXZBk]^W|_BT[Px{sHbvM|0@}UPvY+FZY8r_FxDTGY\_Xc	_PM[)@E{IYV[\*P^[^fU_qTDF 
QS pF]~_UB_B(r\^C\WYI\YUg_-~Y)
 czrIs6GBT%	TuT[qD oM-sH@E{IZZY8r^B@DRFq@Z
P=Y	XT{A+JYYP^\zTUEZ{U
RQ]s%]F{w]TBDXT^ZPDOEqHF
V/]p[GS]BFX\([Px{sHbvM|0@}UPvP)i{RwgyswlEQs^[  r_TyjZ{Qqg)wseEOP|[Qs M-YpN[_Q\+^P(	{scpsHvc@[ Y}VY[PA^DFT\\XzzOEqH[G 
PMH5Z[]kP+y{RwgyswlEQs^[  IYXyU[TtX^@_Z^fW^sD\ms
V/]p9ZAhw	B+BBA(L]\SHU[@G~s
RRg	[N[@xgP+y{RwgyswlEQs^[  IN[]yI	BTh_B-D_FxDTGY\_|
V/]5Y@{A+J[CTZBx@UYJDXMRo)XY@w	BVt_B8\\Yx\W_sX_XcM.M[N\T{zZ{Qqg)wseEOP|[Qs MQgI@E{IAW^XETZA{\W]r_Xc
K([^yA+tXE T\XzzW^WfF|Q	NUK[ZAWtX^\ZA{@UAYP^}MRMV)XBPZd[ATr]^@XT]qGXU_-~Y)
 czrIs6GBT%	TuTZW@DYW(Q
p%]FyA_ `Z^-~]EPPW_r_Xc
Q
r)F_P\JDBT~APkbTA~F|Y	_>cYGPUYhBA(LZBxvVZsHGEE_>ss9[^yP8B_B(]^}vW^Wf	U~~^tWvJ5q wfDT&T%ZAhPTAYb_|
URsX5@E{IF+FYC X_Z^fV\aHG{EQ=5ZExkC V_BT\YATVXsT_XcKR]pN\T{zZ{Qqg)wseEOP|[Qs M>K[^y_UB_B\YzHVTD~MVQrZA]	BWR_BD_Z^fREs@]o
R=p[_k_(^P(	{scpsHvc@[ Y}VZ]yYF+FYC X^B@DRFq@D~MV-Y
p%YTC{Y8XB-\__ATTW\_XcP.\T{zZ{Qqg)wseEOP|[Qs 
RR
9YTCEBZZb\ZzOEqHGUUc
rY\k];xX^(TAFXT^qD~MT.E1ZY	BTh[EVb]\^HT]HTY|QM-]F{A	B+F^P(	{scpsHvc@[ Y}VYE]GVDFT\\^hDI_f_Xc
JSYK1@E{I]V[P(L\ZfVTDs	LQIYXyU	B;h[AT_Z^fUCZUM
NPgp(rIg*qs5AGTuP|\|]MPV]F]QAW^_B8\]G{@RFWDGo
S- p[]BU\)VY[WX]C~RFqZXU/H1]FyA	B+YZ(_^CPU[JjA{	L(]uYEE[.FZZb\YATVXsT	U~~^tWvJ5q wfDT&T%_ZUZaBX
_>EV5ZCyU_UdYY(X]ZDWTJ\	U~~^tWvJ5q wfDT&T%ZBxvOEqHY} 
JEVZB{kA+J[EX]GS\RFbPGmU
NorZ[SIEW`D_UL[Px{sHbvM|0@}UPv	BJBA(L\\{UAH@Ds
Q]
s@E{I^(t_B-D]EPPW_rGM
PMH5X^]gY+tXA-D[Px{sHbvM|0@}UPv	B+^BA(L_XPVAIfBUI-AXX^]gY(YE f]EAUZHD	U~~^tWvJ5q wfDT&T%^PxHT]qvY~ M-sK@E{I	B8YZ*\YxvI[BXUc
p%XT@]P+y{RwgyswlEQs^[  	F_gB R_B(_EATUCr@D~MUQ
rRX^]gP+xDA*r]A^XUEDA{N.E
`ZZCYP+y{RwgyswlEQs^[  9F\PEGxXD-]ADW\Y@Fc
HpFFgD xX\L_FxDTGY\GnATScpY@{{^;YZ*_Y{TAYb_Xc_/nY)
 czrIs6GBT%	TuREs@]o	_-op$rIg*qs5AGTuP|G~Y
H/YpV\T{zZ{Qqg)wseEOP|[Qs U`%[_ [ThZZb]_h\VZH~_nM(cpY[PA^DFT\\XzzVE\VoMUV1X^]gE)J_B(X]Dh@VEv[F]
H/Q
s\T{zZ{Qqg)wseEOP|[Qs 
V/]]F{]G)^D_ULGAxHT]HTY|Q	JQoVZZB EUd[]X]FxjRFbPGmU
NorZ[SIEW}LzWBXTYw[
CV*SdTnB}d	[VYE*~GAxHT_vBnvV
\.wTXDT&T%grNcRJbBV_+`0LXRY-ZWGFSa\w[L_`Tx S@PvZT&zg"Fg[JNcMW[VWI`2v[}dDcYJWHXTSZZ]_ AB`.MdV2_WVC-UA	]~aBM[	ZR^'PR v EVRXY\e]DaFM_FBx'_@}UPv,g!	CgNFgDW[AMe)XRVH^vW[}ZY].WT[[hCe3CB^"N`'v }ZGR(^Ig_C.e^DWX[w[LYx`-I+dYLX\d%DI].Wx\~aFMeBBR3VOdVv6pA}ZG-UU_.WRP~eFM}"U]@[ Y}Uxcq
gHCgWzZeTwS,BR`-UO^PJY}`VP-UnASID[^[XxVU`\@ZMY-].SC^eL^M[PA^IV+Yv eXWR_YDJSE^Te_FMS @xVT+^P^FWV E].WT[[hC[L_xR,MV$6}\}`T_c P.eFDyx]wS7UB`6K+V,\ ^}ZSZI{uYypP[EOP|[Qs(h'5SAcGR[IYeGJWhEep]]e_BV2_dUJY}dGUaYJeE~aTaUGBdR_+RVvJY}RXQW^Wk^WC[Zx`/UYv6fBGZPQW^S_~_`]eAR`6JOdV\ {XWR+Z-uPAGTuP|-bthO5LD^}`T]-c ^SaETWX[weBBR3VOdVv6T\}`VBURG[s\WZ]WGx^R+^)LsGGR;EIc ]e	ZDevFS.YRV/U+R v.wTXDT&T%grNcRJbB^'R+`'L2_G`V]Qm]SRYW[FwWZx`HR4C}`[\IURG[s\[^]aWCBV1K+V\W[}Z#Pg ^._ZTaZwW/UB`P+Yv GVTCIU|PJ_ CSn_eL^^R+^	v]FGZPYAFWT[[hCS:XBR<N^*\6sE`VBcP.e^~[^]aV[xRPWx S@PvZT&zg"Fg[JNcMaW[B`(Q+`'uFWZ]-Y\.azF~a^MS/[R`^_+`U6_W|#PGBT%	Tuwc{b]OhRv2T}dBUU_.[YBTW[AM[XxV?JO`/L6AYR:Cge]SP_~SvC]e(_^WUOY}@PvZT&zg"Fg[JNcMS^^7HO^Pv6UB}RXgVEav_TYwS&\`6TORvX}d)F-cZSP_~SN_wS_x'_@}UPv,g!	CgNFgD[OGw[RF^IS+`*v2^GZ]-gCDWhE_]XMS:BRRP+V	 AG}d1]-U]aF\TeU@aT@xRP+^Nv6}B}Z_c_ypP[EOP|[Qs(h'5SAcG`V]YY.aZ_~eqFMW,AxRP+^W6@Wd,Pg}_SvYSzZ][XxVTO^06oG}Z\gxA_ CaTwS(GRV>W+`vW[}V\gABypP[EOP|[Qs(h'5SAcGx#Y-g`YJ	]~[^]aWXRV?JOV	wTWdV^-ge[J	YSaB]aW[B`
N`7L.wTGx#YY{^a^_T[@we*AxVTO^0 BZIB].[]CDSZZ]e%Fx^.L+R v@G}d+D-uPAGTuP|-bthO5L S_Z3GIYBJSB\TaTwe	Ax^R+^\ A_}d3]-QSCJS~FTek@[_B|'V+V9\6`ZGZ]-gdG._~^TehYweBB^R+dVL6]BWV_-gv_Jaa\TejYwWHXBRKOdT6Z}d]-U]acXD}xTMy"\c@[ Y}Uxcq
gHCg_~^TeV[]eX`?L+dUv6o]Z]-cA.e]DSZZ]aU_R3VOV	vJY}d6]Qy_JeP~SsX[XxZQS`1\XWVB-cAJaRF~W\Aw_;Fx`6U+`L2 [GV8Agd\_YP~W\@WZxVLO`v.wTXDT&T%grNcRJbB|'V+V(\6qYWZC-QWP.a`]DaTwS]R^R+^N\ oA^[-QN[	]~aY]S:@`$PO`1\JTWR C-c ]WhEWYMWA^_| m@PvZT&zg"Fg[JNcMS^^7HOdU\2CW`VBUqCSP_~[xFw["Gx^%IYv2F}d*BQ~^Ja	BTa[MaW[^)Q`\W[}Z'\]lF.	]~[OA]S^x`'SV8 UZW`TZIgAX.WBD^My"\x`
NdWLJY}dMFIgdZ.aSYDS]C]e2B^R+`(_B`TBUW^JaxD~a[M}"UB|'V0@}UPv,g!	CgNFgDyx]wS;]BR#LV\2 [GZ]-gCDa]ATeUE]aUC`6TOdWLNFV_-Y\.azF~a^Me2Bx'_| m@PvZT&zg"Fg[JNcMy"\x`2H| L*w]WZ-^g[_aF]eS@we:\`T+dWL2T}d2G].[P]ew@e3[x`6U+V(vXWd2\]\SRB~WX[wSF`S+Yv]WVI]UU_.aF][|FwSR@BdRQdUv }FWVTXQn[ypP[EOP|[Qs(h'5SAcGR[IYeGJ_BWJX]aWUx`K+Yv dF}R0B-gXBSP_~eRGw[XxdMNO`&\ E\WdIP-g~]_ D~evF}"U]@[ Y}Uxcq
gHCg}pY~[OGMy"BB|'V^.\6Y[WR'XIgWF.a~YeZ@w[XxdRQOV$@[GR)Zc ^_yFDe
@]e3YRR"IOR v6AYZ'B-uPAGTuP|-bthO5S@PvZT&zg"Fg[JNcREQs^[ /5zXAcXKgGBT%	Tuwc{b]Oh@}U