`.$ht@2\I3OAUu[T'[.
u6)tH6aVUWW\WU>]  zY" TL.WVMrST"	xGAUH)V=YhQP/\"WMjQVL	&WVoWTTVSMg}Y"XSWKPS;@WX{Wz@#WP{t^sg 2SLO6BS"Q[s.pO3,yfr	g	M2Ly.fWW)2Lxz%0OAUu[T'[.
u6)tH`%\Ch]@@2\F  Uu^)}HT^/_MGNX W-tA@xJB/CV|WT_]-J[J^[}A@xJ[U_dHeZRZUUXT}QRXBYCpNU(]*RYU|\CZYQC^D}[pVa@5_MEJYT
lA@xJZUquFU-F/JYJlXYa
|[\khA*O`pSWmY,-_M`\zC	/[B{dFS[RT_@	ZUXlGYG-qzqHg+tH2zO6M`B[sr\/WyfyqHf6WXYS XPB{QFWT-Vo^}*PQW[wYSTD&* AzWD VI//\-Wu]sP8~	P zFAWTH4WP{tfr	g	M2SCN%[S"Qty2~pO3'@f[Hgb3UqP,C)2WIxY}STUu][],b\cU.bY)2KB] bP+oB~QXbLU\fUXNRxY}ybSUtYg3],P9\]rX])VURfR+QAFTcW]T:cTbY)2YQx]V
y\	+UV@D]!\HT:gbX UPxybQOk\TgB[vgbX6 QB]gSTO]V^~Q:EHbVc
XYM*u_]OAr\  zqHg+tH2zO6M`B[sr
^\C^R	P*|[.
u6)tH`%\Ch]@@2\F  Uu[{PtH2quRv 	f{MDWzD%V(U~AUQ:v9WPP*P)<2 AQVYr VkbP]PXPWMtS-D$	f{QvWH\TSAz}Y":XWu]S\1GVY`WFXVQ A&vPWXiRUv `%\Ch]@@2\F  Uu[{PtH2qu6"`ChBsvyf+k^DgDP\cj
Jz"W.uVRY~	S\	OogYgDP	\{yBS"Q[s.pO3,yfr	g	M2SCN%[S"R]_}B\WuQZ_{xB*qcRV }	W/)]_}.pO3,yfr	g	M2SCN%[S"Qty2~pOVkbP]PXPWI]S;.\GA}WzX%VPsP):bWVg^QVL.	"[{QyWT<V@/\-WUSTD&* R
vWYX6TSAzSs/WKg`S*R|GWYX6V>AX kU:	WXqST"R&wht@2\I3OAUu[T'[.
u6)tH`%\Ch]@@2CT
Y}]U Bb\Ur.T YNRxoCTS	OYnDg_\L	\cJb-W wMRk
C~%OAUu[T'[.
u6)tH`%\Ch]@@2\F  Uu^)}T+aAXIU^G	/Z_hFY/G
cFN(O^-[HV[o-YXxFA)G
uU8C^*YU|YWy-YXhtZapNS]-JYQ}p\ _l[XzZXCIHUOF/XS~lZTe-lY[^dA*OXNV-OZRYQGRX
T
(|\C^R]:}ppV[F/YQnZ_ZYQC^Y}
pR(|[|U$hy2u3@@f[GT'[}  *RtH`.$~{zWYX6V(MDh.TVWVsiSv5?*GQAWovVsZC{zW`]OQVL.*R{AVWFH.V>{zhg5WE}S-\"6D{t2u3@@f[GT'[}  *RtH`.$ht@2\I3svX~Y/]H\/c}J[Z)6Wx]SSbRofZ[YH~"mCN%[S"Qty2~pO3'@f[Hg	B}  %
W,YKFpZ_-t^Q{ [{PtH2qu6"`Ch]OAr\  zqHg+tHW[gmS XPmAXWF@<VkrI.XZW[YSTD&?N{IpWoV{bI.9T'WcU|P8r7QUX{TWofVVR}/\"WAS~~{cUH)V
TP+'T`QuP-:BGA}WzVQIrs v2zO6M`B[sr\/WyfyqHg 2SLO6bE2NR]rCXKYPBYC,fU
Lg.b3@*u_]OAr\  zqHg+tH2zO6M`B[sr	
.pZE@xE9aN(O]P!_M{JX_
lZE@x_*sR(|[|U$hy2u3@@f[GT'[}  *RtH`.$VkYWGP'VkbP]PXPWuY^P*P)? {IpWYX6VQIrS'v!UMuP(P<M{QvW H6TSAV^s /WgSL/?NxU~WTX"VQAQAY/\WXcS;rZSqVoMWz@RWP{t^sg 2SLO6BS"Q[s.pO3,yfr	g	M2Ly.fZ_)2dIBkCT
Oo~GcUBP
vcT[Z)6 RRkCf4]xE~Y+FbP\QY.bF2eTb]+o@\Q;Cb"\ .b A)URYPf-Oo^^T]+],\L
Q\.b%B)6 MkyPO]V^~U6YHTSU`[Z)}SRogX oTG~YPYHT*	\ch
.b&FM]WxYNPU]ZC[],\LLg.X;D)lRo\yT+oCDUYHbY|T)F6 RRkC\	+]QFTYQDHb2 .bS\)2DLoG~%svXeGT'[}  *RtH`.$ht@2\I3OAUu[T'
sNT(SF/[K~pYu
>`^Q{ [{PtH2qu6"`Ch]OAr\  zqHg+tHW[gmS XP{QyWTv6V(QvI1 TL.WS-D$*E{IEVr'3'@f[Hg	B}  %[|U$hy2u3@@fDU YHT:gfWZ RHRo[SP]V^~gDHfUL{yBS"Q[s.pO3,yfr	g	M2SCN%[S"R_MJZlC	PRYZk^Er^T+W^)BN~B\
R`GQk`E[IxT*_BY_~\o[	(^\C^R	P*|[.
u6)tH`%\Ch]@@2\F  Uu[{PtH2quS;vSWu{mWGrWVQIr^szUMuS\1*N{W~/VSw|A&VWuEP-+?S AzWz#VQA h]S/D,WuAsSXSq{M Wo@TSAz}Y"V@SWu\SL!?W
_UH)VkY@Q 9LWXg[P8P.*~sW@!V]hs9 TL.WV]jP;D2QY|sEWzX%U>Qk{9X6WcNS;X6SqVw@TlV>{ hQ0Wv 2zO6M`B[sr\/WyfyqHg 2SLO6b3BM @QRY~	ST oQ~U A,[vchP,C)2LQoC	y\,	+US[TQ _,T 
vQY.[Z)MWRk ybQ
+o]E~]DHz"SCN%[S"Qty2~pO3'@f[Hg	B}  %]RD_mhZ}>JZY@RY*[[BT*O	W/,ty2~pO3'@f[Hg	B}  %[|U$hyWYX6V(YPcSVL/WuESTL/*FG]uW@!VkbP]PXPUMuS bVSW\IrWT-V} hsW TL.WV]jP-9	zGkWzX(VsA TL.WAVSV@?W
_Vr'3'@f[Hg	B}  %[|U$hy2u3@@fDg3EHb\c[.T*[2}UBYNCf-+YRZTgC,fWLQY.T;D2uURyf7OomZ~g0EHb9vQY.b	C)RKyf4
+oc\TcU_\RU\[Z)URYDSfO
+Y^TQ9D,[vcOb'ZMmJYTSbRoTG~];F,b3]	.T@KxoxT+YPBg\,[vckJb9\)2gJomy\	+ogGDQ ^X g.b+_)6 Qwv\F  Uu[{PtH2qu6"`Ch]OAr\  Z_{xAWerTFRXRn^XTWZ[^t^*WXVUTm	W/,ty2~pO3'@f[Hg	B}  %[|U$hyWbVV>{xI7TL7WE}S;v*-"^{oTz@TSAz}]zWVwVSTD&<dXU{WYDKU(o^Y1VD&WVMwS8L%Qy{MxToT)U>
^^AZ:PUWu]SSL<2|nsFW H	TSAz}Y"LTugS;L6 AzWzX%VAP }cS9LTcQWS-\(QyXQeWTrVX kU/bWuES8PU?S{t2u3@@f[GT'[}  *RtH`.$ht@2\I3Y[@~cW^HbLcw[Z)pNRkCT +o\X~U!EHz"SCN%[S"Qty2~pO3'@f[Hg	B}  %Y?!_M`[
o_
\CxtP[pUSF/ZU R[-BZDP`Z(ZVUC/YU~Z}C	-Y[^dZ*IRN(OY?VZMV\DC	RZ[F{RB*qH-aC,1YWZ 
lZ^{GW[	p} *RtH`.$ht@2\I3OAUu[T'[.
u6)tH	fXyTDVAF zU)VD&W`cBS-\(< [ AzWFH VQ
v}9
WE}Sf;	xm]TzfV= I.W[MySf;	xm]W@!U>]XI.\1WIc~Sf3.\GA}WofV(Q|I.vT`RS-X**W{
 W@!V=
|SI"V"UMuP(P"~]FW@!V=Q@ xcWV@$W`YvQVL.	`UAvWz@#V{ S9fSUMuSf;*s{QvWY@/U-ks g 2SLO6BS"Q[s.pO3,yfr	g	M2L]y.bC2WIxY~	Sf,o\^Q0F\RUO.PX)lLBovS~%OAUu[T'[.
u6)tH`%\Ch]@@2\F  Uu
P)O	HT-}	W/)]_}.pO3,yfr	g	M2SCN%[S"Qty2~pOVQeAg%f3W`sSL"SqEkoWY\(U>] kU TL.W[w@P-9&G]PTW~+U-]FhAVD&W`cBS-\(*s{t2u3@@f[GT'[}  *RtH`.$ht@2\I3o@\g]HP
vU
JT)YMlLxop
S\	+]E_Q;CX9c~fUXBWRoCT+oAQD]Zz"SCN%[S"Qty2~pO3'@f[Hg	B}  %
W,XS^[WSZ^Q{ [{PtH2qu6"`Ch]OAr\  zqHg+tH2zO6M`B[sr\/WyfyqHg 2SLO6BS"Q[s.pO