1pvK]ITUedWU{UkQinH
T*rExTWqtq`QwWmS|TmIpk@ WrmjI3Tt^|MtTO~Tw}W-Pv)TT|IcSTVOsVI{}wx@SWV\Tt^vHUTE^T]z$ux-W[,Wt`@cwkTUaTAsx${x@7WUjA,TFugTx[~WnU}
v	T8~cWTtBvuYpTCTT czrV=W@}TZ~XgWTGwT QP^(r[bVUztcp[1RO@aLcUQavS~
zSAbS	\rAw^AA\cTAWF{S~4TBQf!JY|5]`@B\UZ{_DQg[^DLD{~$NAPwVY| XV`xRD~\	YMS'T]xu	WG]R.aAGpNTm@B	 JYO	U]8}\Fz&
[DrVWmr_n`ZSS'UZxC;WZFxWcXE``TDX_[V]LNB}K	*_ZZjsYZ_`W[b]
xZWz	TDV_

+qX\\
qEAGpNWxL^Dh[L+UY*W[X\WcYCs|T	}D}J_^{UGEyO\F\ qMXGZRTY[F[P{+UZUi	(mYXz q{^Vs-w1|qzUO}r#WTHriTa`}sOTmSUTx]y}
yT;\x#WbRFvTxGTAs H(T(\F.Tt^}[Y	Tm[|TFYFP0nUzWWX Q TtZ{cwvVOW}wu}j bW-LxCPTJ|_IMsTO`TVn}Hbx\,WPGi),Wtwz1wE1^HAiD
YQT.\UG|wd Vvg{S]nL|BQX\gYVQ]`aXL`ADpZuTV\xS
(CAEza{\DI|W	]UJYOWAEG aZ_ qMXYu^R}D] hF^{LTGxy u[CzQ
WU\DppV\[dZQCW]V}(C\F WEZX`BR}D_]Lx'UGDa
8mZ_Ct [_r^UEz^[hXT^7U[mK	;}\FzqM[CZU}_}YK7HSna(C^Ty
YsZ_ppV~^	tZIzU]mu(WY^\6sUZXuRVUL]RYKC'TBni	
 SGTQs]XGZI	 LD}JZSx;U]K }ZZj&qY\DKxT}@^VZSVY[e;GTQs]XGZI	 LX}|_^{S xpN2)xQ!1TH^xpgW}[KT gSH(T*rEi!5TZoKckWxG@TwP$^m7WH`,WtnI]OT[Tm\k UWTv,UWtTpszT[uVI{}HbH0T;rO\3TNQE|Tx_|TZh$lxXSW-Lv(TtNVIMsTnayVI{^
jHWTHr/T[`smU uqU[sRirZOd^I2rv]|5MVR_vg {_{cST|GP/JPBC| 	w^A_\{}sQYt^D0_QT JT_E1W	MZ_G{aQ{QOTT4h_QbQnSX|1UVSA\{WxQ{Q0S{bQJjT|1URRAQ]{WZ{gBR~0]AT
.P[|6][vQZSV{gASa^APVX\| 	w^AEvY{

{{wW~q_QXJ.ngA1V]V|XLg {aQ{YxK0 SQfVj]| 	wRUZ\Uv_\	A]_RT4~E{\!.P@T5)MVSA\{e{UWQ~yYAXPB@|5X][vUs{WQQQP~zFX.n_VIYw`q@vY}QabcIT
OSf-XSCV- M|v_mCOp
pF^@3TDV_		C\Fi6qUY\V`I~D]YKC'TBni	-q\Fz&HE\GsFVE@_ZQhNB}t].Rxc{#JTZtgI]vTnufTVnC4jx@W-PvVNzucTVhW}mTSW[,UWtTI]OVOTDY@^
jV\WTHr#TW^eIcT[ebTnw}zHrFXWz i1;WsAE|TxOSWxskOn$UV@z1STbtxVErWxhTxYG}Yxr,W-H\;TJ^GVwTGwVI{h4
U T-mWYpALTm TTDIE}
vDXW }\T2TBmK]IT[uTAsuDXVzZ\!TY}VjTChTmgEhHmW j` Tt^FXcCTnqkTVUZ}  r&VzScp[1RO@aLx{[qcV~0AAbR.jZ|]ZmEcLWQg]UTQZ{]Jrv]V#MdZ\Q|_DQQAU~4]{fPJ\X@IYw`ALQ]{e{YKY\{PVX\|IYwdYLcw{_ AQoK
YQPJY|SMVnC]LQeAQsW4qG{fJXv_V- R@AR} p_FdFVTHY[8O[ZjQWc[D[dInX_m[TzLUZ}u	WZTy 
aA[Ap`S}
-qiy" [rW;LPWTW^eMuTx_|T[@P4H'VzSQ!1TH^xrMTFugTVI ,q@ W;LRP4VNzALTmaxT[c]^0S@ WTLAP TJ^GXgoWU}QVI{^ [UfPW8PVCPTa`D`TVuJTDY@^ D5WTzp,Wqtzu]lWxkTn{{AHB[rRW8nM-VWa|]uYpWx`VI{P0VUWT-zu/TH^AuAvTnTVwu}
y zPWUrj% Wt`IUTGwVI{hLxD$W-T~R5TTt^vIUTVuJTDY@^ D5WTzp#UWtSazN1^NE1A{wW~4hFb\.XvYF1Tw^sG\UrAS}QwLYQTSn~@|5U]ZsG\Y
AaS~
Y{X!X{E5(w`^vQcAe	UWQ~
F{XUne\FIY|v_\]{Ae
QUsK`FA~$NAPwVY| ^VsNW[@_xFZR{+UZUi	CZAx.W [A[dO}L]^]L{VXmKKGTQoGVcdO}L_~xZJ}+U][C*WZTWcYYXRWmP_XLSAS(CY[ 
q [VcFR[TY}tXK{7SAEe+i]Tz.r[BpT}_}^[WP+SA}(KY^\6 YCc`WmrD}J[US7SAC	TWXE&
tM\D`UVT_Ex[WxSAG;aG_UH]]Vp}-w1|qC
HUb3T rTiP0TbNXpszTxG`T c@}JxPUV@z\NWt`STx_sTF{bPQi@ T-nrC;T MuTxGuTxYwh$vH(WT@Q7TFugWnSCWx~}
yxXT;@\-*TtZ{pY@VOTUgMmf/W@}TYdyIzTGwWxE}HpUbUWT@{P WtFEuTGwW}wu}j bVUztcp[1RO@aLU\{eQgpMD}@A].n@Y8M^A_\Y_a{AYgOTH ^{X'jXV$Zm^\Q|A_DQQAU~4s[{\-Y|M^}BLY`{WKQUWQ~4 S{bS
ng\IYw|v_v]QSA{c I~a_P$XnA%]V|XLQvWsUTT0^fNJP_T|wVo^vc 
AysA{wWeNWp]%[@zMq G_XxVVzY}t[Qz3NB}K	SZ^zUt ZBH|T}\VY^h/SADy
*XAQ	MY\V`T	}_~@OxQS~K
8uZTqMZVH^VbY t]Lh	NB}K+qAEzr[ZrNR}_	 |_^zQSS+	 #J1pvpszTxG`T c@^xfVW~zRP0Tt^|E|WxawTDQlu[\0W8P@Q!1TH^xcPTm[|VI{hU~T8~c,UWtTV]kWxkTIP}
v	T8~c\%2TYdGcA~TnC[TAsUt[rRT(vi1WbFguTx TVsN}
x@"W-PvTxXcCT[O^WmUd}
ym!W-P!"UWtSazN1^NE1AY@WT^Gf,PfEVIYwVaEvgAaGAgyQTbD{bS
XBV5
]Z^_vgaYAS~rS{PjFF5N`]\gAec^~[\].nf[|1UMZS^L]sA[SAcITFAbJ\V[|RSVvYze{QOR
	\{P2Y|1UM^D\U`AWkAQoODwG{f"\ST|IYw`@[U`ASS	{YIDq@P.PXV]RrELg[j{YK~
DAbS
jT|5/dYQX	{WQQAM~,yS^F%PwUtYZ_rNUx~Y}[TzLSAmG	8
XA6ZY\V`U	r\V]LxWS}K	VuAEzb{[ArZI T^|XT^7TFD	O\FyaMY\VVWnD}JYOSA}u	8i\FzW]Z\pTx^xx]LxPT^
V
Z^xMWAZVuBV_XT^7T\C aY^\6q~}
u1|wTVsfA
wV!WT[zTZROE|Wxu}WRz(J[WWT,WYpIQW}@TnsbSU`[@2W XtPTxPMtTUyEWnLP(S[@2WTviTbMtU[uQW}wu^ U [rT(~t\!VVNzV]kT^Wmwbk0bx@"UV@z\3Tt^yrUWn[TULC
H[rRVUzt\!1{@aSLN1A}s{QoK
OSQP(
JjE1XwRVYv{xA}sQYt^D0_QT Jj]Vd[\cAWQg IDY\{f.TQ@5wVaEvgAaGAgyQT4l^QXTJY|5Vn[L]|
QW]~S~4l^QXTJj_|5U	MRVYv]MAa`AS~4kF{TUJj[F1U`bY{aPAUBU~,yS^F%PwUrMZBH|T}XYFB[SxSBV+q]Tz.r}
u1|wW}wu}j bWT@{P TY`uTnSYTxYwP,OH(T-DI)TYdMtTO~TwA$}m~5W@,TBB`csWnecTmYFu [rWvi!.TWZvIMsTn}TDYyAlmfW@}j5Tx E|TxGVI{hHIP'W@}i-Tt^vXTmaATm}b
UV@zz%"TJtgcA~TnC[TFs}
vnr,W-T!"UWtSazN1^NE1AgASa^Af4	Jn_1Uw^qGci
Q_S~0S{bQJnCX|RM`SZvcZ{e	AgUJ~0]A~$NAPwVY| ZDrZU~nBDJZWk'TZ[
8u\FC*	sXDHBVFXD}JZO3TADiWqZ^xMqZ_`xO}L]^[UNB}K(}[YsYZ\IVW[b^V[PhSBx[
U_Z]R:
qsZXVFT~Ym]L^TDV_mZZjqMG^[FUF^}RZISV]Vi[XGQYo]Vp}-w1|qx${x@7WUjAPTvK]ITUedWU{U}[\)UV@ziPWqZN`{kWmS|TAsPH}v&WyxIQWapcMtU[uQT[Yd^WTHrRVTYf`HTxOSTDI|P4xX$W-PF,TZ^zIM[T[}]TxEZk wxX+T*Xuj/TWdVYuT[_`Tn{{P0nUzW-T{iQTFrcQLWU}kU su^ \dw2A@cF) w`[D\]

Qa{{g]UD
AQf6.n~B 	wRbEgAa~AgzODiFQP4Y|(
]^\vgQ_vQUCVTM[QbS
]) ]^uVLUOQ[ZQnMDOX{bQX}X1Uw`\YvU]Q
{UTM~wDQTPG]`d[vUQaYQ]_W~4NAQfvvTY|R}P~LYUtYK@UA_	+aG\CZYXYFU~]d@OxUZ}_qZ]zs][[plIbB	 JZR^V^[G-OGTB2
HA\DKFT X_ ^[PPLU]U(CZ^BsQ\DpT}nD~_^{S xpN2)x\!TW^eIMsU uqU[sRC
HUb3T rTiPTdcA\TgVI{^ [x"W XtCTTW^e[mTDS TE^UT[D6WVLS6TtBDMtT[qcT[s`UOnH
W\N1TJ|_pgTChTnIY}HbmT(W;rz\)Wsr]TxGuU su^ \dw2A@cF#MVA[\cw{auUERT0S{f.Y|) wd[\QLQWkg~LD0^AbR.jZ|5.`U^v{e{geS~4qET
.\bG1WMVVAU`eQQQT4OGQP<JjZ5M[v]QS\QgZJ0AAP,	jYV1YMV}G]L{a^QgtTDq_QX'nBGF 	w`rGcHa_	w^D(yZ`F%PwUa{\DI|W	^^[KP7SA}	WYERU
sUAGpNU ^~|[TzLHX[\Fz&oAGpNP~LBE`[KPSAF}SXCHQZ\rV}~_dYO^3T_}[(uAEyMr}
u1|wW}wu@HvEW-PyTWtpE[M^TmXTVsNh$lH(VzTzTdI]OTx[gTU}UbWzgR0TtZb[]~TxGuVI{h	xX0T8r]R1Tt^{`pTxUTx]Pk(uUfPW;@Xj'WbR`QtTm`TcP}HpmfWVv #UWtSazN1^NE1AQHT4SXQ\.\V[|+VzYc{WkAQoODY\{\.n|B|1W	MdVvg
{QoH~4SEQbQJnyZ|#MdZ\Q|_	QRIT`@A].n[FV5]^YX\c_pAc RT}FT
.\|GF ]d[\cRAaDQg}JDH ^{fN.nsY8^^@gAec QD
vF~$NAPwVY| G\KInf^xx[TzLSAne	([AEyZY-vaquTUWqTDUA
Nx\0WPp$WsSMtTx_sTmY~S @UWTHrj! TtFpwz1wE1^HAiD
zSAbS	\rA1]RAg	Aa^QUWQ~r]].X|ZFU]`\]\YP{[XAg~LD4wAT
.Xv]VVMR \\UuQe	AgTWD\DQ].npG5w`AD\]{AWDQ]tRH ^{z$.X|@V1UwdXcNQSGgfRTmZXJ
Jnq@_x`ADpZuTWSm}U
[E\q Z\uUx~_ZWz	TDx[	*_\F\H AGpNVE@]m|]LA+V\
TW\Fz&oXCWX_xJXT^7T_y	WiZ_&qsAGpNVmzYDxXQzLW@[y-K[YYo\DVVR}r^h]LxUZUi(CXA6bgAGpNP~L]}J]L{7U]~ymZTz*IU[GV^T}\U@OxWSm}	*O\FAEXVHV_[LzTD~iCAEz
q[[V_ZPzSAFC(u^TyRY-vaquWTU{uxD2WL}P TJ^GXgoWU}QTAs^tH(T-DTZtOUTVOsTxAqx${UWW8PER)'UttazN1^NE1AgJ~0\AX\jZFIYwV@\cRQ[[{QqP4[E{f<.TY| 	w^A_\UsQS{c SD[]QbS
PAG| 	w`TBvUnQys^G@ZuW Wp+CZZy*Y[GIRPT[RZSLWS*\Fi6qUZ[pRRV\[dZJxLUY}(u^TyRY-vaquW}qqTxAd0N}zW V&T|uE~TUeVI{^ [[X7W-TQCWtmuYpT OQTFgz}  r&VzScp[1RO@aLx{eQYQ4TAQT
.\UAF 	w|vALxA}sQQHT4SXQ\.nyG|5#wZ_Gg	Ae{cPH ^{Pj^6
]VsZ\QX	{WbAUR^~[]Qf.Y|`fZ\g	A_pAc RT}F].rv]|(
]^BBvca^QgZOT4|^fXR_2MVTX\U|WsQS~4@AbQXnA1XwxvVLx`ADpZuW xpN2)xcp[1_

