h}yVU' sr)[)P}\)JyQBK)[-HlQOUV,uQx[P}\/aKhawM`UV,uQx[P}L byJ~CU !qhvO2gSGER!YuWqvSU{vGYM~JT	-0
BsRCVPz_EJbUZPvCF _R|VWYXh^\.xq\vU@@b\[6YM||S*
BKBEG,H}_FHTUyVM_PZU
WZVd\D~z_^qvUY{G}YM||W( 
Bp_[PzxOCIzTUbXx&]N VSB[d]\
fCCWPOD{HVQ_U~ST^uRCV.v^aWq{~sHa|#hvO2gLrV*} ~bWMS\\}WUB5tKzQt7U]\YEE*e)DT@]X}e@sVPo7V[LcC*[N~P^S`@eHX{SN@o.	"Xc@S+X)ZwS@]WaTV{1Qzk _vgbE*aU	DX"@M[CaWXAvKwyT}R!Y)tJ`psq" !s AtWVuiRCPhbY~:T I}WsUc;Phr_vhe( !qhvO2gSGER!YuWqvSU{vBx*]N U*
X[B]\
fxZsDUYC@VQ^R RU+ 
BVR_A.Tx}]aUZ@_U:^S|hS
BVRYV,{Y)tJ`psbqa^Eh@wy.+ Pv{r_*[N~TY]eFGaT]A1M@oiJOYY{r_1EuYS|~sHa|#{yVU' ui)[ P@L	KtS[!VlYTT*#[YF<CPh~'ZWUy["n)IBW83Vge?GPSVZCo{y'FtyIWV`gDSRL,t[wyxeyMKW+cs|uJP}X-ZWq aw[Eh_@O2T}R!xqWqvRG{vG[^Jo|W(Y`tXD?
x]sRGy@XDU_K `N(Ys^CbCSFHTVZ@_\UZlU
DhEG,H}}]sT[]@]mYMGJT
 PZ^E
XPWq{~sHa|#hvO2gLrV*} ~PWCeA}[/BQ`Pk
3_gXE*Y~~ ^wS@]WS XQ1P@ .WDguB*eDb+A]a[WY{vNPYaJ7UPvUA*eWP+A]X}aWV{HzkG\gX@ _~bCwev_G}"VQ1_z].9XvQwY S9
~T$ZWXZ}eU_xIP .7V[LcC*e~fUWweRCW[[{Ko~.3CLgDB aUTfY]MeUDW}"VA)sVaON%PYT}}VsJ5ytJqxq"D[k
W-6uE@?KP}\ YaICm5ET
W-/uIReXRL,ZqAyxeyMKT-3Xg
)C&RL,Zq~Cm5ET
W R,`g\<[&SzPKtk-EPXls~WrYr?y,PDaeN]e5nCEArT([UKPC$PhDNaC[K.E!EAKW-/c\? PDaeNSQxIhyQIWW	WXIPaPCfVqzbqa^Eh_ON%PYT}YV,vxqWqHRGxf[F&^V~RV4_[t^Y?jG]WfVGCDD~ ^RRU*KA^^^)Tkq]WfOD{HGYM~JV4_[t_CP@}^q\UDjA[*^PZUEVZXD
Px|Y|sbzsHaw[Eh_@O2+ PvrV*y ~\_M[N]GaZ^{I
Rzk.7YZLgvGNY~T([]a_GSSGA1M@Uy7XXvg|DNaUDbCwSnGW[[{5{Kzk
35FL]{[*Y~\)AMW|FGa[\AQQPk7WDLY{@e
~PXBMa ]}}"VA)sVaON%PYT}}VsJ5ytJqxq"ITuUV,XA
qPhTsI~CU~)hyQsW-&AI<eSx@C|K[PPAuW'&Xg[S}bqzbqa^Eh_ON%PYT}YV,vxq
EqvU[{TVQ_U~U 
BVXD,v
zGWjU@hT]mX_|q .R%Jgqqa&5[M`M}xU}}"V{5GIYy3&G\gb@ e2~T+Ya[S(XAx_zY[WDguB*eDP Xwe YeEA1M@U|31FQWA Y~\N]]aU}S^Q1T@oOG\cV*aUDb
@WXZ}_@QeKzwyT}R!Y)tJ`psq" !syQvW8`xq1PAPSKt]_"DxPW--AvRCPhbY~CUm-|YT;&cI\)C&PPfaq aw[Eh_@O2T}R!xqWqvW\{DXx&^STRTV0PH`C\)jCFqHRG{vDYM~JV0P_VQz\sDRG]P\[6]R|lT; 
Bpt^^)TxO]JzW_@zE6^LlV0Ppy}VsJ5ytJ`{NbXJaA-s_zwy./ YvgXANeDX%F]S]BWaUYAI
RzY7WBLgzDS~PWCeA}S%]QPI@oSX\URY*aWDT([]e
AGWT[xN@oq.7W_L[*W.~bAwa^GeBQ@UPo[.3
GgFEaTfUB]X}S^QQQPY|J3(DvgBNS9DX"_a[}eZQ]_zoNE\[*SfUZ][FW G{SPzk.7UFLcDY~P^W|FGa[\AkJoUGvURY*[%Db
@etZWe@QI
Rzk.CvQjCNe0YZwehF}aW]AqH@wy/ YmGER!YuY|sbzsH !s{yW- cs@<[PPWq]kSmI@o{W-6`{^PC$Pkv/Y aK.HloOW RSAv)CWShzXZKkyT
yIUV,ui)[P^v"rGu]q,x{EoQW8WIrRCPhbWeohGn%[A^2"]gSHDaEuYS|SU{v	V}&^STRTV0ZVdXD@]sRG{vYx\UZlHS
Bh]G
}FqHU@CDV~Q^PD`V+,
BVREG,H{}F\RGBDDF\UZlU
+Xr|YV,{Y)tJ`psbqa^Eh@wy.+ PvQE]*[PfV\Ma@}[L\Q1U]J3'DvgFEaWDYZw[_WaW@A5cLzk	"GLgcCNS8b.Y]eLAe\A1P@wyT}R!Y)tJ`psq" !s MWR[st?qQP}\6ayT]GLx~AuW;'QuYd<yP@(tCvhKmyIWTcZPGRL,KkC&mPplQW 3UrzQq"5r`RJNbXERpV
[qR( PptZV/H@CWrUZCjG}^HZtU
Bp^\.CeXZvV[zG}YNT|U(S
B`ZXG/@mWbbT_yX~*DN|pQ+TY{
qa-sJ5r`RJNbG}"V{-s_zQY\grZS8\A]eLCS"_Q5uHPY[7WZQJ^ S%b(CwX}WV{5cLzk	"GLg BWVP@]_{YaUYAKo~.-D\g{De/	DfV\MWXZ}aUXvPP .^QWA W~b
@evZW_+[{1VY[*FUWV*WJDP BMWXZ}eA5EN@o.-AvgeX} [BS|Qv[}#h}yVU' sr
C*P^X HKsC&HloOW RSuARK,PAPsB[xsyUqT-uE
RK,Phba}VknuoAWW- ug Qq"5r`RJNbXERpV
[qR( Ppt_CD{XIjT[kG}&^HNT(0AX_Z)f
{WWIPSU{{[}#h}y2"]gSHDa} ~z WwWYW[Z5QKzQ	.3(DvcYe0~fU\M_zBGWY{IQOY]vgF@NS Tb&@]WJYWWV{DLzUz	JOY]v{r_*eU~T]aU}a[\A5wNk.NZvgw[NW.~bAw[_WSEJI@Y|
3&DLgX@ } D~ ^lEOQv[RpV
ty2)%JsrQq SzQYtK.UT@Z{\W8Av
_-P}\-WCJ~C$xsAT +uAuYS}H UK.m!bypT8'1IY|QVP~%Kt~CUxA|wWT-`YD<W,SkJ[kCwW UV,ujK+SSrYZK^PK"no{wT8/cRSuPD$_cq aw[Eh_@O2T}R!xqWqvVB]z_:B_ohN(BK`_YvCW]WfT[kDCF:YM||T	+,P_G
X^CFOD{HCE__T
<GVxXD,z^sXRGhfCF ^NZ`S
Bp^_DfxO_t\T\yHV2YM|T- P_A/}W^qVD\DDYMGJV0^I^BPjx|Y|sbzsHaw[Eh_@O2+ PvrV*_fWEM_AD}S:CDRk3A\gFE_%TfUZ]eUW[D{\_PQp3'BQF]W ~YZweiCGe^{1M@Yq.6[gx\Ne
DbYEMaZG}"V^D[q %PY{
qa-sJQv qxS[!VlYTW	-uYGPC$SPztCPu[EQNW-	4XPC$RL,Z mk[xgT
WU#AvWSPhv;KtS[!VlYTW	JuAK$P}D&aWB  !qhvO2gSGER!YuWqvSU{vV}YMlWT
]KF]Z
b}_]sW[P\C[_Vo|U
^uRXG?HxOWJXUD~\VQ\_GRS(W]V^YV,{Y)tJ`psbqa^Eh@wy.+ PvcDaWD\W]S`XG[L\QkJ][JXURY*_fWEM_AD}[[{5GIYy3&G\gb@ e2~fWEMSs^}aUYA1_zo\J3
GQ|Z_~\N]evG}"V^D[q %PY{
qa-sJQv qxSuPmo]UV,V`CPha_I~[/ I}W8O3uAFPC$SPDYa	q aw[Eh_@O2T}R!xqWqvIUCbDD\MGhT
 EKRXD@xOADUXPb[^NE^T8,^pR^V?vSFqHVD\A[*_U~U
BRXDSHkaFDUX@DG}__hUV4Dux_Z/bAS@WzUYP	V}+
ty2)%Jgz	DaJ5Dz Ww}xU}y"_{VHPkOY]vguX*S*Db0Dwe[}W6_SPzk.31FLQyXNS3T\N]evG}"VA)sVaON%PYT}}VsJ5ytJqxq"n!AlQOW RVsW<SPD$s]K.n!yQoT8/pc,_Pb_ K.[!yMTW-WAI<ePPSZqASaET~WvW-& I~y	P^za[N~:DxEMWR-[}PC$P}DWY `hK !qhvO2gSGER!YuWqvSU{vXm&YM`WV0ApJ\GP\
zG[tfRGxPVE \VV0P^C]/\
^W
EJ@SU{{[}#h}y2"]gSHDa} ~z Wwyx\}e5XAI
_Psy5T}R!Y)tJ`psq" !syAT;1rq6PhY}NK.n!yQoT8/I]e)C&S})aK.m)XyQyW8OV]RK,PSPGik:[cyIWT	XXA\Qq"5r`RJNbXERpV
[qR( Ppt^X<vx[]WfWG@bYV&^JGZSP_Z/bCC
EWPSU{{[}#h}y2"]gSHDa} ~z Ww[_W[@Q1T@k.%DYENaWDYZwS[DGWT[5PLzo\	.3FvcV*[Pb0WWtF}[&ZQSPzY_J3\v[*e1DfUZ][Z[L\Q1_zYK7V[LcC*S(~fWXM[PCe2VSPzoNX\rVEuYS|~sHa|#{yVU' uA?e*RL,t`B[F1 I}W;$p]EQyTP@4t}SeZ !qhvO2gSGER!YuWqvSU{vY^LpH* 
BpF]\
fSFqHWGXB} ]PJTV,P[\GPXx|Y|sbzsHaw[Eh_@O2+ PvrV*y ~b0Xwa XW[[{1Wzk.8EQwBNe2~fV\MaU}SE5`W@ .NZvQjCNS%\W]eC}[U@sRzUy.33XLrVy eBS|Qv[}#h}yVU' sr)[ Pkva[NS[!VlYTT*OQuEd)GPAL+HK~Km5]yIJT(',`srRK,P^X HKsC&HloOW RSuARK,PSva}iB[~lQOW-&[E|[.PD$HGcke)xs|QKUV,A RCRPPfbSrK.[!QloWT-ps~<q Qv"Wq]bqa^Eh_ON%PYT}YV,vxqBIDTUxYE:_MpU
(KZVd]_,DhqF\RGBDDFDN|BUVK_BXD
P
xq
EUXkCEUYMTZN(EH^\GP\
AC
EJ@W@PCn\TyNUPpy}VsJ5ytJ`{NbXJaA-s_zwy.NZ\c\NaWDTE]SZ@}aW[QQQovJELURY*e&TbE]X}aWDA1P@YJ33A\[*aUDfWXM[FGWSA_Mo .NZ\c@e~T6E]X}_'GQPLzYwALgG]NW4T*FwaZG}"V^D[q %PY{
qa-sJQv qx~["mzlwW R,uA)_-Pkv.KtS[!VlYTW7JuAaPPzs~C$mPb~MWT$`QuTQv"`{NbXJa^D[q %SPptYV,vzS@W~TZ{V~Q^KypU*KApJ\GP\
AC
EJ@RGCU6YM`T	(S
Bp_Y
zEJbUZPvCF YMGJN(BK`_YvCW\RGhBx*_JTlV	WG`EG,H
W
EHRGjZ}U^KypU*KZXCV/@^aCqVU{z\VU^H hN(
BpXG/@^^q\RGDGn:\UZlV
Y``YV,{Y)tJ`psbqa^Eh@wy.+ PvYr[*aU	~fV\Ma@}eLYQZMoJ4B\gb[ S/
Db[X}aW[QwL@]Y
.Y\[*[NTfTYweR_GeVE{Ko~.3CLQPX _"
fTYweR_GWY{dRzkOY]vgDB aV	DfVBw[_WaU\1M@]Y
.CvgBNY~fUWweqGG_;@{5EKPoJBrVEuYS|~sHa|#{yVU' r[PhbtCK{q.m!sAuW'IYE?_
P}D&qWHPWwyIJW-V5IYE<ePD$Kt~G"x{lwW/	IIy)C&Qv"`{NbXJa^D[q %SPptYV,v
xBIzVD\DDYMGJHVWZrXDQv
h_ZUGBfG}^JDNU+W_Hh]\Rf@mBI\RG@@VQ_Q ZS_B_[Dx|Y|sbzsHaw[Eh_@O2+ PvrV*aVTb0ZMX}aT]A1JzYNJ3
F\]PV*[T\ W[cYWWY{kJQp3RD\Qr[aT~TQEa[e,DI
RzQy.7U]\QjCNSb
A]_}DWS'BV_zYy7T^vg|DNeb(AaGGaUYA-s__ON%PYT}}VsJ5ytJqxq"~ 
yW	7u{<VPD$bq	~[4m)_AuW RVsW<SP}\ G~kSPF!Gw T82uAtQq"5r`RJNbXERpV
[qR( Ppt_X/@hFXIUCbDm\UZlT
EK`EG,HCq^sXIUG__|tV0\KF_X)v}qFrIZHD[ X_|q .R%Jgqqa&5[M`M}xU}}"V{)sVzk.4ALgVNY~fX_wW\WeDQ1
U@YLJOY]vc[ [NT([]aXWS'BGIPk.X\cYS(TP Xw_AD}[[{VHPkOY]vQxXaV	Db.Ya[e,DI
RzY]3&DgbAN} D~ ^lEOQv[RpV
ty2)%JsrQq PPTtCvky	xPyIWT$cI{
e3PAb(HZPWbyW8uAtRK,PSvJyQBK)VIt~YzW8/`wR<eSP}@6C|~C$ !qhvO2gSGER!YuWqvSU{v\YNpV4_[t_CP@e
EHDVUPB}MBJyBS(W
AsB_Y
^YjRG]P	V}+
ty2)%Jgz	DaJ5Dz Ww}xU}e@sVPo+\UfE [TPV]]eiG}S9\AI
RzoO
WDguB*[-TP Xwa[S'YQ5`Q@QN7W_Lg_D Y~\A]eUGWaTC{qWQ31EcA STfW]eUW2YA5zP@oS
J+ PSGER!YuY|sbzsH !s{yT8+XIYE)CP}DWKtk S[!EQNT(E-PA Kt~9TBTJW'`Q_? PS\Ut[wq$X{{2"]gSHDaEuYS|SU{v	V}&^KypVZrXD)@
^WXrTUjG}YMoS(W_`XD
[_tTU^k@	V}+
ty2)%Jgz	DaJ5Dz Ww}xU}aWV{5}W@Y|
$AURY*e/
~TY]X}W]1RPk8EUzB } [BS|Qv[}#h}yVU' sr);P}DtCk}ZDDZUlWTV YKPC$PAP9Z[ZkTm%SlsRW-uIXaPPq~C&x~Zw~UV,uj<u PS9ayS~_*wW|W R+st9RL,K_B[U1C~HW-WcA)GPv&sWS~C$ !qhvO2gSGER!YuWqvSU{v[F&^V~RV4_[t_CPyET_yD}&YM~JVX`XD
Px|Y|sbzsHaw[Eh_@O2+ PvrV*eT ^]e~BWe2@Q5aSzk3_LY\ _)~X)Z]SnA}[	YQ1J@k.7U^[*e(bYXwe^[L\Q1QzYLJ[vQJX STP XwX}WXQ5qPPoPvc]aV~b^MeLFGaUYAI
RzY[.PCUTV aYDfXZWXZ}[*ZAQRPk.7WZrVEuYS|~sHa|#{yVU' IP  PPWq]kSVT{EQNW 7c  0P}\Vt_sK.nPWWQWT$pUB
[3RL,t ~B[xe I}T(VYa
qVPA\ZGG/n]yQyWT'&Vs]PC$PkWux~[(yMoW'VIYEPShr5Wqv~_*m%SyAYWI_eXPD$HepB  !qhvO2gSGER!YuWqvSU{v[^RUT[`BEG,H
WEIDRG{@V ]LV0
BsJ\AzGXOD{HA \MRWTZr^Bzx[YHTAjB} YM||T(P_A
~}Wq{~sHa|#hvO2gLrV*} ~fXXMS`@[[{vNPoSJ3#ZLgzB*eDT@wX}ePBARYaJ3J^vg_G W ~b7@M}xUXERpV
[q .R%JgqqQq Qv qWCPq1IBW83XQPkLZW@G3})vGQ~UV,`{uWSz\ bytCm5EZonT;[UJRG1PP+aeV~C$yMoW-`E)GP}\ Y~[)mIXE]_WOAvPaPCfVtC~q aw[EhR