i~#U
pVS}r]Stv_TDIWnQUxWp%Y!VTdOP}@PDsW}1T~ji/B!zsT)ZyRHyPYbTxPgWVNVCY3CTVMPADPHL|TmWnA}dSoICW,|PS@aPtDqTx}WGW{sf 
i\E1RVTf}MP|	1xPCUhDH`PQCj*Rc~T
MPtI	x 6@|YSQ,dIHS	*^tfM\A1
B2_FoEB^Sy
NRP~b	MbA;@|\,`R^y5X*RtDfewbAQ1	x2*B|kZVQysNRVT\|w{)px6Z^|kG^'QC5F
*Z~TR]Xt
5SBAVQx'WbD!uYt}Zx _n^BN\])cLY Y,wZaBqO]}&]RAl\E/{W]Q{ZCXJWXx ZE)_Q`^X:wP&_?QCxKZW}X	x ^~-X^_DY
I|X,z)p5ptU[!RWWA}/Y!}T)^|PhmPW\gWxIkWF&PIwTJ Y!VTJMPhXPX~Wx5W 6i]E :t2!q1&
B5[IC5M~w{1xL\|o\@R#Ss ZC~]XrQh6Z^|oEVQy5^ `]Xu]B ,XV]ER?K1*ZqTfwPW	{5`N[_k	Y,VWwZTbwfQWRDY CH|'^C)s RVTfe]b]Q|
 V|YSEd/MCx	Ndd~\v{{2^|kCV3WE*~fMbARR6U\UYF,R-UC-sDCu|[x*]{Xj^^X*E	I*\)Q^C}[[Zm:\|-^^F@*I
OQY, ^h[aFn2G~
VyB\F]LQ]QUY}yYs]}&Z|Zz]E)g
I}\][^eYq[~M_V)D\ZF@*IWYQw^h[XZeXG~XRF@*IT}MYwYzCXqFD]|ViJ[CQ^.[/)p5ptTDIWm&1QS9p}pTJMPhXPX~WxIkW2xTTJ+})@Tp`PSlPa}TU1AWE.x :VP}IVTYRHyPHLwTn!~T{N:CQF/Z'zCT)ZyP}@Pt\}TDP]TV"UIw:-W1BVRJxP^\zSsFTxfW 7x
!q1&
B5[IC5M~w{x	R6W[V]EY`SP5x d|~f	]TopB6VX|oRX`PPI
*RlDf_]f{R*ZVox^dQ5^ ~f{PQr6W@FYi\R?Wp
NRAT]~wQRR22ZVkX,d!MV `PP]bgAC2*DQFB,^$R-sDCu|[x*]{Xj^^XA
I}Y
Q[}KZbC@}Z~!YR[C* 
S M\^yBqO_~^FXyp\\EL^]EkaYa[@}*Z~V^jBF@*IP|*Y, YCGBq}_~R	.$Ha{ypzPUVRJwQ^rPPHLNTn!cW{ jy (xl}T)BrP}XuPt\zV|WVNVj/Zo1TdP}\RPH\@TmPsWn$kVp3U
pVP}SSqPGTVIWn
b/Z-oTTPJyPHxRL{TD{WV6Q{b/BPl]W,t`PkrzPWDTmW{WAr/CTVMPkrzPYzAW}EW{$AsX:d-VRJxPhXFPZNTn-WX1A}/Z(1 T)FYPkr{PtQTV!IWm..
W :xzCTR|P}XuStbTmFWV6B\B0z~T<SzPvSYbBTn!_U !\{Tf 
i\E1ZC~fAw\Q5aR_V\,RJS5c
 `~XA]f1B2V|YzBV^yzdTfVMf 	Ax;E|wqQ	DZrV
!X}yXtWXm\F-Vh\_/w	^*\)UYku[[[*Z}]y_@V]Lo^.U[^eYra@}_m-DzJ@ZT]
OFBc^AG_WC] Z~V\x[C* W :B?cCxKXZa]}&_EV]E{
W}Y<CxKXW]}]	|Ap]X/{
R|*Y/IXuBqO] \nVVh_BUL\?{YCGZqC@}_5_CB_@V]L&\,ECxK[t_YV.]UDC`^[ LY X,z)p5ptTxfW *IZ)W,VDPSTLPH\@T[-W{(Iw/Z(}I^T
| P@qPtD V|WGjQW^.YfTP`SzPPaT\WF2zWT
|OSzPvSsrZTD5cT{N9M/B*T PAPPaTDGWS\\p!zeT
FPhfXPtDqWVcWm&-j
fWp%iu[E1KB5DPWwTRQh0X|oFCR
TC} VzDTUwf{5RB	[FYJY^SyQ*ddDfzwfQRR2*EF]z^HZHZw~bwfA	_wqQ	DZrV
!XkCZW[XF._~_j|^@9{L\
gE
Yy[~&\}!DQh]QL_kCxKXtaY.]VDz[@:Wz.^	RA^xuYJ[ZEU_}-GzB[C*wU*\
gE[YeX}^-AQV_@V]
Lo:_.{X
}WBqO[x\|Dz]Z	K6]P _xx)t1|#W6RxT/ZW-ETpMSzzFPWZTxvT{2PC
\TJ+l!AW.VwPPSb_TtWV*iJTJ+G5STQPMPb\WbWnHo/Z'YT@PHfRL{U[!RT{SA} /<GZTPBpP}@xPWzpTU1PT{&

W/B!!qU
pQ5rC5RMA1A5R2Z|QE,dHy5D ^Q
DfVMXt
I	x."_|k\V3HyI
*`DP~f5z*"VFsqX7DZrV
!E[YeZZ~!]p\](IWo&_?A[^_ZJyZ
[]F-Ci|_@wL}6YA[^eX[YQG~\C^][U
O2_QACxKXrWXmZ~V\x_DTg
OG*^?wZCuXWO[n_X[At\^cJY, YSXrS@~M^Di][(L Y)A^u_a_]~]X[Ct_@V]K}*B YhuZWaZDM]!	VzqzPrMi~#Tx]PAH~PtDqWxCWm&,zw}^wTdTP~POV|Tm3
q^VCTPBpPPzQSbbV|WX&TCAz/Z'W1BT)JTPCP}PYfNTn^W{;IVB#}uTRBPh\zRL{TxfWUN%R (R$l]W)oP}XEPHPWnWFSRj]}p!W5T
^tPAH~PDsTxWn&[jw	R	oTYQrw5{A1^F2B6W[VQ^H`QUCs` ~\p]TOQu2*B|\,d,SSG RmD\lw\{1x2)Ck\dQC^VzTT{MT|
5~2+DFo_E`SRy5Q*VT~f
]bB
{xN[[|]E,dHy@NVpDfWwTW5Rx+[|YeDHR+^S5^ ~X]\{5ax@VU\Z(VQ `PGMbbQix@F\,Z^SkNRmTTR]Xt
5R2Z|QE,ZITSs dDwfApB6VX|Ut@`RSS1
d@TP{MXuV Y|U\Dd^y RYDT{]PyAP
x*"VYOFU'^ZrUY, ZWZJqZ^ 1D|[C:Y^Q_{[	z[_WW@}AR[Rh\\UA	^Q^) EDa]mU^
Ep^[g
Kl^.YX{^q|-#2$HBoQW,TKT?xxPS\PYgWxTFT~"(Iw:$W1ST<ZrSkzRRL{TDpWm&,Ro (Vo%fVRJxQ^rWPt\xTTYWX&,Uy (VT
ZgS}mPH\@TVdT|N{Y /pzPUVRJxPAX{PHXWT[cWVSIw/Z'WT W.dSPbePapV|WU&CQF/zsTPFPS}PbTUTEXW&jsZTTZxPAHVPtQWx5aT~6W{spiu[E1KB5Df
]bB
{xGk^`R^y1N~P@
b~	A5Z
/ZF]XVQyjdtTwTZA~R ,BFk@,`SSCT ^wb	M\[QGx6TV|k_,`R^yUN~f MPR{1x6W_VodQ,R^CS	*ZCTPC	w\@{s	N[[|sqX,^OCp
N`~b MTU5a'GVk\d6K1 dd	\{I	x23@FYiDH`R^yZN^YTXuwbA-pB."_gOFU'^ZrU_?A[^_ZJyFQ^^^]Z/OoU^RXxy_WW@}]F-Ci|_@wPD]E^^S_qq]}G~_z|^CWY	O_.[keXHa][ G~
VyB\F O_,Yz_YbG]}\}-GyJ\^WQU ]QUYCGZWa\}.X}U[} yf+rMG5STQPMStlT[WE\k`VB#YqT)BrPbSsRU !r2t\aY@Gfx'Wy} VzDwToA5ZR9\Fk_R/RSPN`
~TMf 	A1'@|Yy\HVQy5D*R	~zuM~wQRVVY\[V)PS}RxDbMPcQGRN[[|U\Z(Vx V~TXLPR{5F
B2LVkDVQyD ZC~bMb~AUR*"VYOFU'^ZrU\QZW_aCZmQ\m[\V^\TY6_XkaBqO] ^
YZ[C* O|^	
 [_X[[F]X[Ct[C* 
ITQ\
gEk}Xaq@}\~R\iJ^[g	^lY/ACxKXG[M]m=DB^[g	KG^R]X	C_ZqCX}ZEGRt[CQ^+
-Vr5ypPIbWT T{WSzk *^z|T<lRHyPLdTPpT|NSjdTJ+Y!QTZ@P^XfPWYTxvV& \{Tf 
i\E1xt~fdTo)pB."_VU\Z(V*Rqfs]\@{1x6VX|\,d(MyQNZ[TPXMPyQ~B  G|oZVQyA
 RpPr
MTpAZB2,D\,R^y5c`	DfdM\rQ5x6UYFk_HRISI
*xt~fX]bgI	x*ZVoCHZ$UyHN|tDzulB@pV	sRCxB[CI
I}^{Yku[Jq[E*\~ZjJ_DW]	PM]UCxKXGY6^
Ep\^I
S_,]^^GBqO]}Q^ V\]Xk
R2_?AEP_WW@}^J[Q^[C9LQ^.YXxBqOZU]{-D\Z[C(g
S :^){Xx}_WWXx:^V	VzqzPrMi~#T]PPeStAT[{WG Qj/B!G5STQPMSs_TtTV62jvTJ+oST<ZTP}XuStTTmTWU&CAz/Z2zW.^PhTPtDqTxfU .Q{w/F1W)uT<ZBP}@sPtxTPDW{({sf 
i\E1xt~f
]bp{dN[[|Y\[dS5\
*Z~PM
]TUQURN[[|YsG,^^y_ ds~Tw]bxQ5`N[_sqXRSS5y `DffwTtQgx Y|UhD^$R-sDCu|ZE*]m!GA|]]:ULY _
<UY}eBqO_~Z~V]xR[CQO\<]YS_YYm][ ]
XVCl\](U^.[/)p5ptU[!RWV2ZIuWp%Y!VTJ{Ph@\PbroTxWWE.x /F'z{VRJxPS@aPtDqTxpWV*Q{H :p'zuT<VPhQvu1w[F2]aFo[FHVPIC	N`Dfz]b]A5x
B0_\,`R^yNVoTX\
PW	{]B ,XV]Ed.LC}*dV~b	MXRA5{RN[[|]fFdRICF RpTUw\@{s	N[[|sqX,`RSS5^ RpPu]{5xB2*\FoCHd6^C5y*`Db M\@QgxN[[|YTFR<TC1	`~Tw]zwA)pcRwU'
OG*^?wZCuYaS][ \	nAlF@*I^|_{Xx_BqO[~*ZmJBBp]Xk
I|Y<kCxKXa_XF]m=Zx^ZQ*^|R
-Vr5ypPZ^TUP`T{SjB
zuTJ{Ph@\PbroV|W{IWxSzuW`dPkr{PZvNTn!uW{$o
!q1&
B5[IC5M~w{r6VX|k^`PQCI
*`
~TUwbds	L\|YiDHRVS5b*|tDzu]TZA~R ,BF]S_HV^y5 dA~XwXRA5{R Y|kZ,d/QCxNRzDwPE
QUxE|Ur]H|'^\D!uXI}Zn&^E!Ep]BU{TY6^g^^S_qqZ&G~
VyB[Cw^ MY
QZxKXy\}.X}VCl^X:wOYPQXP}YYyZ}Z~Dz|\X9U	O^.Q[hu[
aqX[6_mV\V]Z/	O]	SAYyZWaZ2Z|VGzBYQ)I	OB	QI[^eXZeFn2^\x]E{^UY<YY[^qy_~R	.$Ha{y/F
o|T)FbS}mPJ~^TD{WnSTiM	`1z~T<^{RHyP@fTVWm..BoQW,TKW)lPAH~PP[Wn|Wn I
zIhW<VxPkrpSYbBV|WS;o
T)FbPSTMP@fTnSW{6QU xFxTYS}|StlWm|W{$A}/Z(zIzT?tOShv`StoTDGWm..M\:^(zsTpQrw5{A1^F2B\F]_V)JC1
*` DbTr 6TAVoz\VQy1NRqTwbAUx6WV|kXR'^y5 ZC~\v{)px:Cof_^SyqN`DPlMbwQx	R6TC|Ut@dSy5
N^_fSM{2WD|]FV^y5zRQTfe\Q5DBN[[|YIYR"J5{*ZTbwb]A5xN[[|Q[^.SyS	*dg\v\{h20[|kFd,SS1*RR~uM~w`GsQ[Rw[C(gLD^)EXxDZZ}&\~YQh__W	ST\
g^^GBqOYm_n!D`\_: TY6_RQYh_BqO[~6\}\A\@UTY6]
 X}^q|-#2$Hi{t+zuWdAPkr{RL{TVTYWVW2G:VPz}TS`S}zyRL{TmIxWU&$RRSo!pT?FPP}@sPYV|W/
q 9o|TPBpPhfGPYbV|W{4\Ab/B!Y`TPJRHyQWvUTxPVWU&
`9J	zIhW<VxRHRQWvR1w[F2]aFY\[V)PS}`~TVwTo1B6TAVkGHd6U1`TUwf AI	xL\VUx\,VQy}Nd\b ]PC5BN[[|k	^`SW1 dqPm\rQ5wR2DV]S@,VQy5Q*RbTwbQ5E	xHB|o_,^OCvNZM
TfX]f5RxL\VUx\,VQyUNdA~~uRB@pV	sRAiJ^\]SD.^/X@y[[ZD\~D|[C:YLQ^R]CxKZr}Xm&_ED\Z^Q]
Iz6D,I\{KYsZmG~Xyp[C*wL}YA^hBqOZ}M_EVyt][/
OF_.]XAS_HC\}.X}U[} yf+rMW%T)BrSPvRL{TU5T|*%
S/Z(l]T
`eP@qSbPCWm%eU .\{S (R$zyT<PkePbgTn!iU \{Tf 
i\E1d
Tf@w\{1R2+DFYu\HdUCS	*RgbMTd	5ZxN[[|Y|]VQWS1	dYTTUwXu{G*"VYOFU'^ZrV
-Vr