2.%~^zS_u~[W(VEPSa AJ*n@WF~BqS|u(VV~Sk{X }^G[GW	vPrPyEPOTxPhsv B&ne^W<'t~BqQyPUmT|PPsJ S;VeT//QSgS|s t1"]D5XHEeDd2Jxex)~Ed@EWP}V	.3QGUFY~[Rx_i]G`5dP}b.3GQ{^D^+Rxea3xBG` EcJ}V	.pWgFD^"SBa
_dyIS}
A.	q
XDx"VxaeF}RzU5^~
O}gbGd*ISzxFGdUUQ}[J3Wc]D[_Rev3aP`wLW4fJOW{s[eD[s	"S_G{XB BO{X K_|_[xYNE\,]Y{]Z_QXKC/Z+0E{J__@kNTA4[BBEY_XLP/[-,_{`Y@^QLUT\<ZP{z*#iz"W+	
Pc xVbWy~ZxSIXk$cWRiPBY} hZUCgT/+	koSik
@T 7RPPs`P|_AWV\ J{S|PsB
AT;'@SPh AZ,CtT-OD@pcQy{QAT O`PBI{ nueT/APVNSR~
yW;rSyQp}+VaPWSu~Z PRTnB
xTuPP\p htF2GgG|wE-u^G,v+rGsR[D[s	"S@Z]]BMYUGV0X{t\RC]_E\_	0]Ck{FzQBO{Z*\CF]@@EJmv^S]DC{[yY^S/[(W]]d]_PJ~\/FA{IZ{XR{3G,_{DCxINEZ/W^Yk]yQ[IY0CSt^[zYNG\\/S^Z]gYA[Q]'\(]SxY@^QNT]ZP{z*#iz"W*qS{D P0GKxT<VWhJYS|s{FTKPAwxxGWsW*{^S|s~HT8RRIS9G[~W*R]^bSTlP pT83PEh A`HnqbW<_~B SA1r~
|VV~S~h @pPVeW*	V^Sq{
dT}P~APp htF2GgGdfmK4
J	WQk_Dd*UBWX)3yD}Zx5BRGT.R}QjADd"UR	)~Ed@EWP}FvGgEFTR(SaM7_G^UmSGV	.y
_~V&LBe`FC}^tITG(v.3DWYGDT^WxWU)7	X}VWwHWoW
WgcE[_Ryp2FTvtU[OZ*K\S^GV~X_-[B{w[{*DWS'[*X{tY@zAT{T_,K^Z]gYA[Q]'\(]Sx]E]N~H^/\YyYF@YT{TY0\C^]]^wM~@G/_]SZ.YW{	Z	+K_V^\}wMXP]?W]^kw[{YW{Y0\{^GAN~H\? [BkYQMXK/Z(^`YC R~z_? _A][	|[L{L[S]]d_]{H\]
<^YS{\y+u"1)%ShUzZ" K|TRjBZySiIES4T;'@P~E} }B$~ GWOcBJSq]0gT'WQsqer
h]JF27]WZ5R
yJ3EGQQ\~V VSEMQ_}VqPVW
	J3|gc_D[Rx_i]GZmK4@	3uGQgCDd"SBeR)7_GZ E_QW0O}gAD`WTxa3vCGVT
E5XOW0	ZgF^~|"_]EG"PTvYyDOBZ(S^yJY@CAQ}\\-K\YhwZ{[SSL[T(^{Z\X^gMFD\R,FA{IXUXQkY(]kt\RPEPn\\/
[BBE[yMYTBX^Sh\X^gJ_\X{Q\y._L{PY-,]]dDCxING\\/S]]S{YR_L][- X{B\X^gMU~\Q0FA{IXZKPY ^FY@^QMGD\Q0^PSE\y+u"1)%S~h }Z"VaRUQ}@|YSQTUB
AWRiPBY} }Z-KVW*	|S`UR!wiqZ@1D5G]XTR:RBea3xBG` E^I}4R}Qx\R MB	)S^` EWPo	k}
_~RHxSi3DGVmK3X}US]~d-_Ra)sBW^e1QGH.P}Y_RT`UMBeZ)gA}VWmKH.yQQ@DdVLBSHS^W`	U5dMH.y}cET^HURShr[}VL1 SW4~.3X	GUd_~|"_]EG"PTvXy_L]Y(^	RBYgN~HA
]Z{]BMXJ{Z8^~B\@]T{P]SS[B]QY	6XLy\*WY{y
yrHhsW*~ZPi%`kH~W-O{P~Au P`{_wUQ}{@Py!vrT;/IPhU P|{W*W~BqSiBQ[UU'p5q	Ee[KhB_iM_P}TWnW]s[VPxSU3yD}` EzK
vQjRT[RxWt3a]GdAE5rMG yGc]DZRLSUO]}RyUP^}0J
Y@VPxS}z\VRzK
vR}gc_DZ'RxSSM~EZECU},vEv
VuQZ	[B{wZyM_Ox[	-KE{J]_P_~z^S
]^k Xz2[O\_@|DCxIP{P]	/S^[yYXi&YW{\\{B[P{UXf_*^GhXyZWk'\CB^_XxN~H\	,\_PQYjXO~+Y0C	BRkcN}@X,@AB][yUBO{Z(_~^^PN}]
]P{]iYV~A+KZx 
yrHhsT-O S{Qy{QAW('qPk{ AZmyKW<	~BqSiSS,@UU'p5q	Ee[KhByp)3F\GRU5XLWSW}c]D|"_B[MqPWwH}
vvY\\TR"RBa)WC)uWWjGUGR~d-TRWP
)FC}RoE1QG0J}gD^DR QxWP
)t_WdqU1O4g	kG]p^|"_]EG"PTvYQM[^{+[S_C\X^gSnTZ	]\kUZ|6BO{XV0Ch`DC{A
_}H\,[B]E@y[^{+[*\^_[P{_~z]	W^EBU[{M[VC\  ^Sx^XVVjZ	FA{{]yQ[OXT
Xyd^__ ZP<\\{FQ_L{P[WK\\YAP~XZ	FA{{_zRu"1)%SyUpx~qsW/X~BzQyPUmT|P~ Sp${CW7vBsSA1rSQfW;VTS{}p'{CvT*'t J{P|C0qT-rP~Y~ P2UqIW?Oi]ZgS|shQPT7uRI }^/mq~TRjBZyS|TyUGW(VES{spk{CvW*{kR!wiqZ@1D5GQFE~R;LBW}MR^`]H
yJrWUS]~d(Ix_U3aCW^qEIS}0jU~YZQaMiEdp5XPV	.3{Wg{F~`UPB[MqPWZ l^We	Jc]DdNBe)O]}dE1 U}
.3cc]Dd+Wxei	M3D\}|wZBZvW%SCB^_XxLUP]S
^Z]gZ_YPBY8 ]V]XEN~H_*]_{YAXK]3\(W\]x^]AW v[/-{r6x#~
yW-O{RIxVbWykSRMgW*/APEj{F/n[PW		~BsSiIFS,@TViPhshR0qr2%]GgXKA6E5dHG
Y}gD^DR Qxez)7_Gd}IoR}UVZTV Nx	)rCWd}UQ}4g.P}cCV[SW		MQ_}VRU1QG4.WWsR[D[s	"S^YS{F@.ZT]7X K_|_[xYN}b_,4^Z]gZj&[MP\\CF^GkwN~H_
*\\{ZXRS	Z;4CY@^QM~DG/[BkEZyU_O@L[(]^]h]JG@\*\YyY]_ DOBZ(SY{x]_P_~z\? \YyYX_6YU@[
+,Y{y
yrHhs2%]GgXKA6ZBZvW
