h*r`&\Ca	G6B~q{|q|c	1VA~e\L-`^N2d@iTr{`c5/[DeSUIdF[*N[, uBXq{d[]hN5)]~aMVSX*rZTPS{d[FcN5ATS|NI`X6 V,2`	Xq{dFpQu[&
|V$a+$RrqR pq6p	F5b[EA[&
S!R^V*!Z~u]
DU^]
\xTZ_VADF,_G(!@
 G^xg\A?.\zXXNWI^ZS1XB/-]Xy[xA^zt_)DxH\M(gYES=XX)^[F}I@\VAYkTYHUwDF,Y[R_ e\[hA
U{~[N.A^@.Z\1^mZ}z* q5-#Jbr@hKE`*uV,*qsFFpw	)V#JbysVpsQ&u:NFP{jSUySR{eP)WGQV` <NEFSmH_S[`VSIZRR,he.FePq/qSzSmiSjIfS<-XCy_JxRRa \G6]IG6^DFw	!UUxv]_+r
|V$a+$6tG6^KG6Fp*- U~a T-VXpBHtbdGVgG 1WZDR-dGY*2]ZH6B\tQd`c 7ZexQIRdD*6 @ \BfYV|	*1UU~eSUIdF[*rZ2`xXtQRqFQVNIY\KEA[&
S!Q}P$6pR pqRsp5&[b[J@hDDS!QR'RZ~uZ}w_^]6@j\M8_].J_D*!\~C^nFzJ^,_z\M+w^C,XG/\|W^[g^iG,'Y~sh*r`&\Ca	G6]FFpw[,&UxstQr`-$a \G6]IG6A|q|p*) \~e\IZZN6YNxfS{^jcIYX~WbVIVpD pGBTsQ`F	*N_~eTI-`Y 6V,6xxqVgD*5YaMd`X2fY QxTSVT|gZ ;ZTR-VQF* X_SRbZU\NIYX~STQ`]NG2B~q^DFw	!VY~sh*rQ&uW&q6tG6^KG6YGG!VYQu]_+wXW,!]V)[Vu\Y_dZQ&
GhXAN([W/VXA*J@{a_k]B|\._^fGTTBW?5BG*\ _[[\\Z]
2
GC@YUgYE)RXXF~K]}][CF_	*Uz]_+z
|V$a+$6tG6^KG6Fp*- UuEA[&
S!Q}P$6pR pqRspP)6}K.^}?[TvSXrqSxFqS]xRR,h~.J
){9_SXPS[t_SEpP)(Kuh!
E`Ca	Fsp* q5-#JqvVps
&W/WWS\PmtdPkP)}[`WdPqU2USTiPnYSAIP?!9KQpVS}.dS{@SV^	SQ]PP$hucUJNVWqPmfS^SQIpP-k}C|XQ&wa \G6]IG6^DFw	!UUxv]_+r
|V$a+$6tG6^KG6Fp*- U~a TdfB 6YNxTSVQ|ge 1WZDR-`W*6 @2{xf{{RzQ|N%DTegJI`@  vCRPz{RSVUP*5TF~[MId
EuY QxT\A|UCN$FDecJ`X*uV	Fsp* q5-#JqvVps`&\Ca	G6]FFpw[,&Uxv[H+B])5YB@[[} _G,@PfZTUQ\]
1XC\	Ga[FA]h_S
GkXJYYE,VZ@/5\GCF}I\^RQ
Gxv[RTk]BPVDVTV[}C\I_dZP _^fYT\YQ)^V*,*p6|r6p	F5bD}v_-|sW!BR'Qs*r6{qQQ! qv^)xW\SVySUxdSAP)/_;Z@)&S{\ySJ|SEfRR,xqzZD, E"S@uP SAvS)5RA [UJS
&W/qS zcSFxjPzs|PKzTdWW/wQ H}SxZqSAEP!Qxqz VKWaW"DS{@wQJ}SYpPQ)PaG8JE,&y IQ H}SxZqSY@PS}G](tA<&v/wQ HrPxjSCYGP)W}Gv.^{RR&T6tG6^KG6YGG!VYQu]_+wXW,$}P$6pSxJhScWPQ%P}nZDmiSGTWPDQI|P11k[MTFD?[:W{S\SBuPjgbPPh}t)Wd/wQ H}SxFgSiI^P)4Gp8|p?"NSySVzdSxBSAtS)I;eF)VQ&wa \G6]IG6^DFw	!UUxv]_+wYE,!ZB)]G_\]AJ]
Gk[H)]DF,_D*!] e]xg\\<UhH[H)U^^)!BG*__\VQ\C])*_z[H+B])5Z\1[y[wFzJ\RUG\MA_\QJX[-@E[mE]
RG,BxGU.c^C)-XCT\|W_g_zh^P
GhXXJUg]FQ^V*,*p6|r6p	F5bD}v_-|sW!BR'Qs*r6{qQQ! qvxZ
*N:GQ H}S GSiI^PT(Pyc.B<W(N SnTSxBwSis|P!RCr.ZsP2E(NTQ H}PmxZSE[S.%Cr`b)~:NySGXFSxFqS]xRRbr@hKE`BR'QsZ}wZzq	)V#Jbysh!
E`Ca*qx~q{Z|ga*"]aIRjD6^H STQ{dGV]r
N1T[~SsI-VvY*2e]HNMFFpw	)V#JbysVpsQ&ua \G6]IG6^DFw	!UUxv[JY^_5_D\[^_QVA?.\kD[J8w\Z/ZY/^Xe\~{^jt^SFzYUg^ZS5_D(V^}^mI@i|\)6DxH\M+w^^?XC9!@m}\^^

GP[T YE,_D[~_\}Q[jFZ
DxH\MWQ\]
1[Y/]~_[DE\B_.DxHYV.I\^?Y\T1]|]}][CF] Dx~]_+z
|V$a+$6tG6^KG6Fp*- UuEA[&
S!Q}P$6pR pqRspP)6hSyJZ.N:"dQ HQR[pSPhP?}C}.Fs)}TVP{iSnJ_SjP
9}Gv.^{RR/NiS{X~SURsSYpPPx;daRyUWzSUvSqSCICP)6Cr^)TrRXrT6w
G6YHF5Qu[&XW,!^V*$*p6|r6p	F5bD}v_-|sW* @X2R{d[]hNU~[BI-d}Z* UY,2GRPiZVc*1UCDeCTI
Z*6 [RBf{Ad{	*51CDSnJIVFY 2YNxTRU|gN$FDSnJIVpB 6^NxfGQVE
c*1W_STMV
]*6_H6RPiVDVQU  Z~R-^q_NmCH6RPTQVQ|pQu[&
|V$a+$RrqR pq6p	F5b[EA[&
S!R^V*!Z~uY~I^j^]
:\zD\M(QDF,_G9=[~\~E@xt]<ACbAN+{[W/VXA*J@{a\
D [zFZ
 Xh@ZVBX?)BG*\@Vc\\Z]
2
GC@]_+z
|V$a+$6tG6^KG6Fp*- UuEA[&
S!Q}P$6pR pqRspQ
!Pe.Zs)E:RPnrWSmdySA{KRR,PaG8JE<*&wS{X~SU`~SRhP?Kz.U<N}zS{DqSx^yPgtPh[U;pU<2}.JQ HVR[pTSRxP)5}CWJ
S2QWqSnX@P}p}PiIS<%5CrWJ~PWu6`PmXJQJ}SjgPR}[v.ZCPU2USUrHP@SRcaS?SWBVx6DtRrs6w
G6YHF5Qu[&XW,!^V*$*p6|r6p	F5bD}v_-|sW*\2GRPiZ|Y[*G~WVP-dB_NRb{`FU]1UXD[SN-ZSW  UY,2BXQ|qYGG!VYQutQr`-$W&qRrq6w
G6YHF5Qu[&XW,!^V*![nS]\zA)2
Gx[K;YDF,_DV\ __}{@\*\x\[K;Y_^,V[GWF~K[Q^\d]?ZSXGPVI^ZSY_*]}yF}I\B\,^xvYQ)IDF, }P$6p6w
G6YHF5Qu[&XW,!^V*!Y}K[Uw]x_?UDxH\N;Q_].J_G!\|[_A]Ad^SDxbAN+IYE,XB:)\|_[n]z^_?UDxH[H_^_DV[K[n_B\6Z@[N+cDF,YXTJ[u[mY\AFZ
D{\M+w_^JZGR@m}^m]\\h\.
G{PAN+IBW5Y\(J\|_\U^\d_/*@AN+I_B_D*V\]~kFzJZ< _z\M+ YE
XB/-]UG[[QFzJA2[hZU)_^,!_D*V_{G^[g_	jJZ)DxzZQ({^ZSJ_DU=\nC_ ][RtG,
DPv[JY\^<!_D*!\	~S_I\d_?U_^fG_8UBABG*_ C_A_yBZP 
GHG_U YF/Z]/-@F[\nw@J\.UYUg\\<JYVUF~K\[RtZQZ}PZU)_XSXA(F~yY~* q5-#Jbr@hKE`*uV,*qsFFpw	)V#JbysVpsQ&u&SS{WSnJ_SAYP
1PaG8JERySXX`P}VASQUIRR,C[Zb*&vS@uSVp{SY]RR,} PZD
uzSbVS tSAtS,!V}OUJp
&Pa \G6]IG6^DFw	!UUxv]_+w^@,JD\/5\mW\nU^t]Q2DxH[JE^@
)YXR]UG^[g_\|]<MDxH\MWQ^^._D*!^E_^F]^\d\/&[AZNVw_W/)Z_)J]Va^[g^i[,+Y~sh*r`&\Ca	G6B~q{|qwGG!VYQutQr`-$W&qRrqPxjSBsPP$Cvs
&g&wSGXFSxZxSjACP)/PayUJ)Ws6`PmXJSxZ~Sis~P
)4}G`)< VuP{jSxZqSg@S.Iqth!
E`Ca	FspZzt[,#Y~sh*r`&\Ca	G6B~q{|q|c	1UXTe[WRJWA@2ExfY`FQ|N1X\~R-dbApBHFxfxAZxFg  Z~e_I^zZ*B_NxbQxq|QR*(YTyvUVSX*2ZGHqR{dbFYG 1U^D_oL-RxW*WX6B{RyVgZN8AegJI`@ @DHNxf``VQKN#@TR-`XmCHyRb{VR|gR*1W[TR-`Y 6 V,6BPSARTVpQu[&
|V$a+$RrqR pq6p	F5b[EA[&
S!R^V*!Z~u_][z]U[AD[H)U^C,JY]U!\UaF}I\zA)2XSb\N \^/JZ\1]|[}w\B^_^zAN+I^ZSJ_DV[]E{]z^\	)UDxbXNVU]XSXET-\{C\U^\d\
 UbAN+I^F,!XX)[~u[A[zZ,&]}TYUg_C?JXB-\|W]
Q[`[,+Y~sh*r`&\Ca	G6B~q{|qwGG!VYQutQr`-$W&qRrqR[pSSAYP
1PaG8JERySXX`P}VASQUIRR,C[Zb*&vS@uSVp{SY])V^qS{.`/SmPtSnRtPzU@S.IKzWFwVuSU\JPnjSAvP)-A [Vpq`&\Ca	G6]FFpw[,&UxstQr`-$a \G6]IG6A|q|p*51@e\RI^kCN2zE,I	RPSQ`	ga
NIYX~[vR-RkBN AHTT{VU F~_uSI
].u_,QB\r`VQhN50^VI`_*6A6xbAV\FUP*WCa N
Z*2W@, VfVAdTVYb -Y~_FTI
Z*2CBiPtZ]V]N9GT[IdC N[,6		xP{A`		|Yy5RATeBU`Z 6[RbAd[c	 Z~WbVIVpD N[,6RPiZ|ga*#^WaU`YNPA QxT\A|c
*1UXTSaWd}ENpBHs	PsARt|UP*N\~egH-
Z*2V^,6Bb		{Rq
VcIYUTyvV6DDS!QR'Q*p6|rRspQQ! br@hKE`BR'QsZ}wZztX/[{wBt_Y/-YV)=[XS\~UFyX/Q@^X[WcYE[G\	 u@ncZzy	)V#Jbysh!
E`Ca*qx~qpDFw	!VY~sh*rQ&uW&qSF[SDVQI|P11k[M Q6UjS{@wPxdSC]RR,}G`^WXT6^PnrSqSRxP)5}CUJ*C*IS{HSmzSAtS<%5KVpQ)WS:NySmH_SFZS\YaP1kK@UJ<"[SnfSxZDQI|S)'xaO+VC LT}P~SVhSR{PSKupV`&\Ca	G6]FFpw[,&UxstQr`-$W&qRrqR[pSPzs|P)PAGZD?[SXX`SVJPzswP!*}[[UJS}[SqSxZqS]yPS5PycUJp
&Pa \G6]IG6^DFw	!UUxv]_+r
|V$a+$6tG6^KG6Fp*5[~e^SI`E6]2vBfAd[	*1V^DSnJI`W*6 @ \B{V\Fc 1UXTSnR
Z*2dCH6
BPD{dyYXN1UU~aIV}C*6 ] Qx\TAd|YG* Z~SCHRF@ 2e[qx{Zu|Y{SC~WW|sWBR'Qs*r6{qQQ! qvh!
E`Ca	FspZzt[,&U{H\Nw]B1[CW]F\F\x^]/D{^_( ^@,JD\/5^Xe_xY@]S
Gx[JY^_5_D^Xe_xY\^].
GxvXL UYE
BG*[S\A^
xZ]
DSD[NY]FZ\1\	 u@c_^\
)^G_8c^B
X^5[ECZ}z* q5-#Jbr@hKE`*uV,*qsFFpw	)V#JbysVpsQ&u&SSGFSmxISRcA)V}G`t_D)Z_:!F}Y~ \\Z]
2
GC@ZV+]YEYVW_ESZ}z* q5-#Jbr@hKE`*uV,*qsFFpw	)V#JbysVpsQ&u&SSVQJ}SEfP1V vUJ)c* ASGP@PmV~ScWRR,kKXZ`)W`:vSVuSUiSAvS.TU}_qUJQSC9_S{DgSVBePx]P
%Pay.BuS}6QS{ESxZQI|PPkKX.Z)NnWxSVb@SnJGSjwPPPP }Gv.^{Ry*&}S{WSntYQIWQ
!br@hKE`BR'QsZ}wZzq	)V#Jbysh!
E`Ca*qx~q{xq|Qx6V~DyvV6DDS!QR'Q*p6|rRspQQ! br@hKE`BR'QsZ}wZzt],M_}b[RVY]FQXYT[~u]UkFzJ]
]Ab\MA^[,RDV*![~u]UkFzJ],M_}bGV_\S![^]i^[g@i`G/U{H\Nw]B1[CW@G_\U \it]/D{^_(
|V$a+$6tG6^KG6Fp*- UuEA[&
S!Q}P$6pR pqRspQ
!}ee tvRR&TSVySUxdSAS<%5qth!
E`Ca	FspZzt[,#Y~sh*r`&\Ca	G6B~q{|q|{p*5GTR-`\ {B,2SxfS{`FgI5
CTR-V^*XH6R\eQ`gR*5#_DWS_-`W*6\H6PtQ|ga8@S~S`B*6 [ VR\rV		FcIYUT[U-RQY \2~RfD{V{p1Qu[&
|V$a+$RrqR pq6p	F5b[EA[&
S!R^V*!Z~uY~I[Rt]QXXJg]BQXYU1\~a\nwFyX/RY~sh*r`&\Ca	G6B~q{|qwGG!VYQutQr`-$W&qRrqSU``PiYKS.IQhW.Zs)E/ASmr~SUhQI|S.TP~xf)9xSX~{QJ}PkP)P.Jh?:"dS{X~SDZFSiI^S)Ih\V )^:*	Pm\_P~p	SAvP?!9KQp})}WSGSmH_PxiSAcPPP KQh!
E`Ca	FspZzt[,#Y~sh*r`&\Ca	G6B~q{|q|{p*XaIRQY 2D2[bA`FUP*4\WuL^vF 2W@,2rBTT{`|c*IYX~[vR-`_*2f^NfE{R{|UU*\De^SIV@*N[,xBPQ{ZxFg	NIYUTyvVRQW* X,2[\idcFge1WZD[LIRV@ *uV	Fsp* q5-#JqvVps`&\Ca	G6]FFpw[,&Uxv^_(I_Y/ A}2eRQxqgGG!VYQutQr`-$W&qRrq6w
G6YHF5Qu[&XW,!^V*!\X[\	Dc[ABA	MX\\M+w^_R!BG*[S]E{]z^^S2Z@\MVwYE<BG*_~K]_QF^_^fZR)k^Y_D[~u[}E_	CR^

QDxH\M+w\Y<Y\(!\\A^At].
G^P[H)]^^)!D]T1Z~x*r6{q5&[b[J@h|sW**uV'Fsp* q5-#JqvVps)NnWxSGXWSm|`SRcaS?S~VRT
.~T}PnzZSDZFSCEPR1kKXW^<2"HSGTQJ}SRcaS?AWP`bP6[(.BSVbASm[SIWP!QCG{;d)N|VuSFvtSEpbSCUP%Kzs<Nf/wSVPgSmd	SEBPP$Squ;EQ&wa \G6]IG6^DFw	!UUxv]_+r
|V$a+$6tG6^KG6Fp*- U~[U`]N2Y]2vRTQ{dGVg*5&ADe\IRJXN}Z,6Bb{VzQh
*5%XR-^q_Nm^,2tfGQRiY*51B~a_-Zq_ 2D2[f{d{UP*5&_TWqHI
Z*2Y] \BTQdFUU*1V^DWVP-^vA*6 XHNxbdGVQhN9GDWUUIVFY 2Y]2vRTQ{VyFY*IYX~SS_-dEF 6Y6x\r^h|QxN- U[EA[&
S!Q}P$6pR pqRsp5&[b[J@hDDS!QR'RZ~uZ}w]jt])QU@bG_8cB\SYX/[nG\m FzJ] BkYUUYE)_D[S@Y[zF],U]fYUg^B
XYF~K][A]
B_P
GP\MTIBW,-[GV[XS]
Q@
dA	MACbAN+I_^=XX/![XS]
x@yt]._hP]_+z
|V$a+$6tG6^KG6Fp*- UuEA[&
S!Q}P$6pR pqRspPP
h MUJS}.dS{@PxgPx{PSqrWBw)NnWxSGXWSm|`SY~S<)}[FZU<*dSrS{XSFSI	QQ!"br@hKE`BR'QsZ}wZzq	)V#Jbysh!
E`Ca*qx~q{ZVQh
*5%Xe~Vd\YN2|D x{`QhN1UU~_nLRxB VBNxb	ARic		N5
_DWbVIVpD pG Sfy{^x|]U
 Z~aMdC l@2{x~q^DFw	!VY~sh*rQ&uW&q6tG6^KG6YGG!VYQu]_+wXW,!DV5[GG[FA\Qx].GA[H)UYE
BG*[ma^]zt],M_^fXNWYYE,VXG/-[X[}w\BV],MASz]_+z
|V$a+$6tG6^KG6Fp*5XYS}JRPC X,6BXYdEFc IYX~aTIdY]2E,	TQ{dFYp 5XaRId`F*2eD,NxXu{ZzFYR
 ;DT}v_DDS!QR'Q*p6|rRspQQ! br@hKE`BR'QsZ}wZzt].
GP\MTI\^,Y_=F~K[Q[J]6DSD\M+w]F
Z\1[X_@
}E^CVZQ&
GhXAN(_BP1[E@Fa\U^
FA.DxHYJw\]R1XB/-]|\}\F^Q*BzT[LTEXW,,}P$6p6w
G6YHF5- U~}v_&DDS!QR'Q*p6|rRspQQ! hy]|]Q*}VuSX|SVB]QI|S<)xqv pw)P6@S@uSFpeSjARR,hy].Z|P2dV6VSFSBuSEUPP Kz;xXRPW"DS{XqSDRSRcAP?CrTdW<&U}
QE6tG6^KG6YGG!VYQu]_+wXW,![GV^}^[g]x\Q*UP\M;E_Y/BG* *p6|r6p	F5bD}v_-|sW!BR'Qs*r6{qQQ! qvh!
E`Ca	Fs