6)we XF2R@C4YEZs[vY|P"c~wHS-Gf UkTqk Rz_{\uBH9Tu}S!S] :WtMXQR  LykX/Pz_(SOY YWZA`SK,Vk\&/G	S;O[ SWI
RRuXXDlH$4zWyVRUuw 92yTs]gQjGJ{b~H&/
yz_S8W UcUAyQC3LnPX* uTu$SW @ "fWYQjW&{DsCn WUtu S[x SUAyQVzQz"UUL
S_Y VSpWYgQje+ LyLQ:  GaSU x*"|WaPq"itChXA`T^CS,JS_H2QuVWV^R}n^H
VZS[	a^F,J	wQeRxXnIWT;A0C_LJ_,so|aWQB\Y_WnCH,yTCeZ_,wYmaUKRPAJWv W0ASSe\H6`M|aVUBPUP}n&X
}Y_
JSAG2M]U|e&QRbKGX+W,[[[.a_2]ke/UR\sVWPRA0Z[.adZH2]oce)LBf _}n1_H
PTyy"ABV'U	|]yHTBN{qW)PSFF~+X_@*%]|_f
L~CBN{C
E+U]|	W@X]9_J^ZATTXaYVx

E+VA|Xb[@^JVYBf^~q^_{u
E+VA|XZ[:%]Z_zvWV}XKPq^+NEL*TZ[:%ZZZ	\f
LEGBN{C@TErT[CVZsJXzPL}_M][C/	SElfbXF)^t^^z{YuthzxJThGS-_u hUAyQB 
UrL~zR((J SS-_ /yWtIRqR Lyk9_GS-_@)&BWtIsQCe{\|~HWV}lqZRUuwe XF2R@C4Fe1JBbAU}n@4NCSeU
.e D6E|W4Hx~uU}jUXH0FC_Je\H6awsu	VYSxT{IWjXZH0[C_Le R, xwk VYSxXUS}P9ZHY[yW.WW@J	wUm|[PR}X([,A@S._\R,  ]wuYEZs[v
E*SFDD-P_@:]RBzHP[[LP_
ESFF~+XY@*9AYlYi@SXCXMBCYLTZF@bX@N]b`^z~O[YJyqF*UClD@X@\JlD
~TXaYQk}^*U^(bZX5ZJJBzHQq_Mk_SFF~+XXF/R\Z|Y
jvL^_{pY|P"c~wHSOP "rWtUxQ[* Ly~TQQY_2S-Gs /]WYvRi[#~vv~PWoO.Suu WW}WM R'DqhT
4YoGLS8GVW"rWtIfQK;{@XL5:4Y|uSWSv /Wb{zSK,{\x~L
QFSaU WV{w4pi]MChGn_,T^CS,J_DH6aU|VaYIxR}X]
@y_L.WMZ R]UsFYSxf _}X9D`Gy[.WXX6DMUUFaVIRbT}nE,yTC[.[U^, R]U][QIRfQn*FH,yTCW)._C^H6X]ouFaYUfMGX.A,H YyW aSR2k FYSxTXUGnDZ^yW.[aXzM]U|e*ObUYZ,XyWW.SU],XkVWTRP`HGP_H,yTCW.WlAP
wk|eSBR}TZ4R@y[V.aaFHJ	wY~|SPRPUP}jWE|ESW*.W}X,6wMorF} ^]BB[vYS'TSFF~+XZX5\HtD	RfO~yXLqY:UADn(LYG]_xjSX[^_{u
E*'VFWnXGV\qV_A@Sy_M{@9TADTTfX]9ZaN_\DO~OXPSSWU	WA@ _@9R\BzH
L~qZ_@W
F9T]zrV_@*R_bV^z~
Lm[Pi
ETNEL(Y[9GqBYi@SXCZJkW
EUTf~X]T\aNZ	\fS{YThq]7U_T+XBC*]tZTmG_M][W** wH6)w /cWIoUQ[
V~3:Q|T[SS-[x /{UAyR;{\ukPVTuzCSaU WWIqRa}vxzXnu 6"Ce	F2M]qFYSxfSW\]
bESS&[nE, ~]kFe&QRTaNn
@H{\WaAAP
wo[V[%^RR}n/D,4 _SWe]]]cFaTPTwWv W~_SaW@Z6ZorVe/^Rf Pn.YH4QT[._XCHf
Mod|[PMbdU}n*A,,yTCeUWW[6v
]|aWRRTWVWn'D\TW;_eC ]MQ|e2SxTCL}XUXQ]yW)Je GJ	wk |S9MBXlL}YZ,0XSSe R,]oVe'MRR}jUW,
FS_QWXXwQ	|SVRTWQWT&[H Yya+W~\H dMYWVeN^beSWjW[[]SS._XCHf
MUDe'MRzu_XNS'W PrZY_Wl_CfSn}_M{_@(T[F@(LDX5]ZlYi@OEq_MkOY:PTF}Tb_@]ap_zTO~OYV{W
E*TYo~(P[ZZHpZy\PnqYT~[W** wH6)w :FWtIsQ{@@,/j O9S[x /EUAyQjC{Xx~PVz_)S8v /yUAyQj 9Ts~H,:QzzG6S-_| /TqwQjCDqknPKO.P-m {WHYCQ\Gn@RH$:Qzz_+QVOy /]WaQG6V}~H9HwG&S-Ga /yUAyQB 
GP~L6AC3S\ /SaWtIsQ[ X~P)0VoWRUuwe XF2R@C4FeORbWI}X]
@yW;ar\, R]oAVS.RBR}nA,oAS9J_uR pM]U|eUIBX]PGjTYH0Z[._XCHf
MUwaWSxbz_WjUXH4SCa$J_,YMo}VW Qxb}K}jWX4Cya_CAHJ	wog|SMxT PWT^,rZeWSU],2]ozVaWUxf Pn
@H4^e[asXH.pROBwYZsZMB7SFrT\BC*\bJ[AvT~DVSu
E*V^YbX\GqBXUUqDU[
E(PT]}\TX[5]^z{YuthzxJ/mFO*SOFT|WIoURnTgBW {zC4P8Wg S]WtUxQiq. Ly@/
yzCQS-Gx "IWHQBRiW{Ds@zQ
~W} STGq /}Tr{Pq"U`:$lzG$S-_| /Tt{Q_-nmhz.TuDu6STGq DWsQ\ {Dsh$9Hwl,S-_ RWIqQ\[NVrz"UKzG.S-C /}UAyRS#XbbSTQQoSUS8a(6Wa]~SK,{@cSv/
[oSTP*aT|WtQuRi {\knP:Qzz_+S;uf /BWb{Rnf@,/
yl
SWSm JvTt{pQjeP LykV/oO;SOSW"r2{C4YJiBbrJWXY,0ASW;._,]o|Ve2Sxb_HjW[4 TyW*._,2MY@|e0SxTlLGYZ,T^C_H.aA\ ~	Mo{e,UTW}\ X,4SCa$J_, }k aWQBTXN}n'C,4^YC[._ZZH dMkFSOxbrK}v W4~ASW .WWDHJ	wYb|aUHBbyTXY_,4OESW5.aWD, ]MQ|W QxT~QjUB,yTC_".WrY6D]Y@FW Qxbz_WjUXH4SCa%_,2oCVS7JxPUP}n.YH4q@yeUe^ R]]U|['LRbWK}v W	NPr[%X\%ZaNYi@OEqXRkq
E*T[Tn L_@WV]r^YA\SXCXN]}
ET](L_@*%\ZDfO~O_MBq^)PH^TP n_@_ZRDTC[LP_]7T\Yf-rBC*_JZXAjJXOXK]CZULTYT~	(yP 2pyQ[%GL}kPTuGaP- C /~WaAlQAKnPknPTuzC,P(yy 9"~WWMYQ\[{Ds]n7UG
QVOy WtQxQC&|bk\+WUtl,RUuw /pWH]RiWQ Ly]n7UG
P;[ :6]WtIsRzeT~zyk94uG&SUG "sV{w4pi]MChGjUZLCya2.WlAJ	wk 
|aUORbVNWn0[0XSW aR, xw|aWRRTWVW\ X,0]yS4_,6v]QS(TxPvIv W0XSW e \UModS7Sxzu_XNS'W Pr*X_@*]a|XAO~OXLuEWLUZX(rX@/]b`^z{YuthzxJ* uGSST|WH{rQ_VfD~P-$yoGLQVOy :WZrRxS#|D~H3Ubl}.Sab WWI
]QG8nP]vVZzC	S-C VtWIoUR LyP\Tho_S-Gs/JyWtIsQj 9Tsn,9iO.S8  /vTrMAQCW1 LykP/oSSTq WWHWWUuQiKDqPr0$@o}"SO} WCV{w4pi]MChGPB`YS.a_EH]]od|YSxbWI}PB`Y[.WxE R]YW|_TxPUP}nC,0YSy"aX@2wkeHxTW_}XYzGSW
._,2]]FS^xXFU}\ X,4AXyaaLFYMkaUPBzu_GnE0AyS.aADH DYme/U\VJGXW,4vYCeWSU],6DYAYSxbzTPBwZW;J[pC RoC	|[.HbdQGv W4Z\yaJWACH2]UF	|YSxTMWWP)CH[Zya-eY,J	wkSPRfM}X+YH4hAW1.a}F, RwkFaTPbNn*]HH Yya	._u_,6aMoeVYTBXw_}XY,4MBy"ABV'U	|Yi@OEq_M{}EVYYbT~YXA
pX	~LSDTy[_PNELXXGZVXO~OX_~W)/SFYTW_@*Aa^XvTXaBN{C\U'U_Tr;P[XUV_WlXQbKmq^_{u
EVH]lXT\XE-_WVBzHSqZN~}W9T]}\TXF%]ZpXQzQ}G^_{u
E*SFYT LBC*\bJ[AvO}eZNxi]7TTrXF)ZqJ[QvSEC^_{pY|P"c~wHRuW /pWtU}QCWmr]@# \GSST|WtMcQC$VhTuFO)SSS 6FWIqQj 9}@AS(Su%SO\ 9^WtMcQC$m]kT/W {cu6NCe ]MQ|WOxPXVGnTCH\S[.e R,6awod|aWURTlW}X_Y[yS.a@^,J	wYVSRVRPUP}X+AH0[CeW.SWC,2	kFYSxPqLGn0Z XS[JSU],6	wodYTB~uV}n)@,jGCS,_,6Rwk|aTPxbWK}X6E,yTC}"eYP
wo^|_JR}X8BH0TyaWlZ6w]U|S9VxTNWGv W4hBCW:J_,2MYl|SVBPUP}PBO_yeW_, PQlW^xTlW}T;[,Y[y[J[W]2o} ^BfNP-@[Eya)_X2kFYSx\pPGX7_
NGyeWe _W]|aVUBfNPWmBy_L[VAHR
Mke*OR}nXrTyW e@ M]vV} ^]BB[vYS'TWEX(rX\/GqBYjvW~[XJ]SY7T@Fr~ZX5]b^[	VCXPPaF*HT rZ[*_qNYyzO~OYQxq^*V]@ rBC*ZqZ
j^meZV~CY:PWEX*DDX%AH|XxPWnqZPhC)7V^Yb(L[R*Zrl[XUVyZUm[TC}P X_TZaNXzTXa_M@KF*VBTTTYX(NZb`YA\ImXVyiW** wH6)w"RWJsQC&nlxL/tzGUSTGq(&pUAyQN{Lf]v9W} S8l)DWtUxQCW Ly~PW/Q_oGS-_u /WtIxQ\}' Lv]z/
yz_S "dWJs~QAy+DqSv9HBO.S-C{ 6PTtCQC${DFhz./_FRUuw&WH]Q\_ GL~H$,JoaRQVOy:.WA`QK5Gf~nR/oaRS;[[T|WZABRze|ryjYTYYu P*Sv/JyWQQ2vw]z` ZOc\N6WXXwYMVSPR\J}PWAHH YyeT
SREs	Qe0SBTPHW\ X,0FCW:JeY2MwuFaVUBbdIG\Y[H XS.aR,6a	Fy WxTWJ}jU\4LXy[._YR6~o||SIbLKWX+F4TFS[}u[G]YC|eTBbAUGYZ,0YSae@H2]kF[QHxPcSWv W	NPr[%YF/5AR[@MUqXQ~}
EUClDrZX5^IN[A\O~OYSk[Y:TTGL(r_@]bhZ
jvMZU]m_UT[Tn(LX@(_a|Yi@OEqXN]}C'T@T~(DZX5AW|Y
zXKFC[LP}ZNE|D
+LXE]rJDC~JF}XP}@(NEL rDXN\rpXADKFC_My
F*T]lr(r_C)]
t^z~^}txJ`+"GaP- C :JZWtIbQCWEz]H$VUKW2QVOy TeWA`QC$XLEkP/DuSPCm(JPWIqRC{\@,,OlQVOy V6]WZAQCK+{DVhPS9,jORuW /SVUAyRxW#{|SnT/O!RuPe XF2R@C4Fy WxblJv W(y]SW.[X,GM]U|eJxXRKYZ,0TyaWlZ6w]U|SLTCT}XYAZSy"ABV'U	|Yi@OEqZU]m\TXFX\_@]IRBzHW{O_My
_	SFF~LX\GqB[
L~G_M][C/7HF\TDZX5\Y`Xiv^~|txJ`+"o}"SO} WCWtQ@SK,E~\B@+/
yzGURUuw "TZMmRx ULb :
OzG$S-_u _WYQCeDqCN:U~z_QVOy \W
uQG6X~)/G LS8 rT|WtQQC&V@mSj$V}z_"SGZ WWY|Pq"FS)/tz_QVOy {WtzQRe|Pv@zQa}SX /vUAyQQK~bCy~,U0 u SuhTsUQCu&XXxP~1: yzO;S-GT|WbsyQBe {Ch09WzG$P+}M 9XWtUxQ[*vwhq `	OcCeT
eG,2Ul|YSxfRWnCH`BSaPS_H6]]oXVaWQB\yLGn'DH,yT\A%V'VA[QDOUCZU]m_V	WEPXGGqBYRHMUS_M][BLTXW\VbZX5_JXTTXaDW[W3T\r	(zDZN\ZBzH
L~}_M{qZ/VYDzbXZT%Ah[RzO{XN{}ZNELV[\U9]rpXQbTXaZJxq_T'RTz;D[C%_rhZybTXa_M~]UTNELUTZ@N\a|X@
LnCXH{mF*U]X(rX@AH|D	CvUVeZVk}XV+T[oXbXF)]tlBzH^FeXKPq@/7NELrZ@_Wl[W|_XKkuC:/SFF~8@X^*VGqBDXL{G[_{CZW	VClT\^R*(	.y4{sJUAPV}OP-a V	W
VSK,{@chH0TUyZS;uG :FUAyQQu"UrwH$/jz[/S;u{T|Tas^QQC{\SjQV}F2S eqT|WHA~QG6GLP]zMYySTGq 6KWY
ePq"itChXA`OGy[T._BX2]Yl[NTxTmJT"_H
B[T_~FP
woAV[SRR}X*B,rZeWWXXwYc
[,MBUGr ^,0\ya0.e [,2]]UeUWRR}XY0TyeV.eE,6woeYW~uVfNS'W Pr;D[C%_blD
iPnqDTF)QT|L;nYYT]sZY
xH
L}WXJh}ZT[ b	PXF)[qt]yYuthzxJ TC:P*U "vWJsdQReXDq{@SUWo_S-Gs 6PTtCQC$m]kT/TYYu S-S :6xWbMQQ 4X\fH$9MW}:RUuw"U2{C4YJiBTXUGPJC,
qYSeWaYH6F
M]W|WWBTyIGnYW,H YyeHWlEHS]P|_"VbHnC4SGyy"[wZH ho||SIbLKWv W4p\SeUW~C2]o}|[NTb{MPRBHY[ya+.W]EH6I]wuFeSX|RGn[4VXSaPS_H EkFYSxfTGn1A
|ES["_]H6yw]fFW.JBR}X+F4q@y[ 	JaEH6I]]U|e'IRbdWYZ,}GCa2_,6~QZVaVUBb_jUBY[y[ 	Je D6]o@|} ^]BB[vYS'TTYoDUBC*\bJ[AvO~qXRiF)QT|LbYX)1GqBY	xW|O_Mx[B9'TZGXTTZXZqJZ	\T
OnZU]mW*/VYDr*\BC*\sB_yPKmqYQXTSFYTW~Z\GqB[B\
LWXPKX;TC}P~BC*]bJX@U{CYQhi
E:TZD(LYX:1ZZp_CzK}[ZU]m^/V]l@	(z[]T1ZW_PKVeZU]m\/UZlf(L[CV\sXjTTXaYT~OY93NELTXXF/)ZqY	xW|O_Mx[B9'UZorUXCW1_Wl_\P^~y]_x	Y|P"c~wHRuW/JhWHA~SK,|bk\+V}zG/SyrT|Wt
SQiy,{Df@;:vlu,S e :UAyQ G\B]T5UU`ou[S 6gWYQB  LR]z TC:P*U/CWZ
LQGF^z"` ZOc\N6}u[, hwuFy WRTXUGPJC,NBeWW{D]w|y WxbI}jWX4TFS[.eY6
]U\SLzu_Gr ^0_CS._BG Fw|eY^Bb M}\ X,4@[_,2
MYmeTJXPUWjTYH0Z[.azA,6|
]oeaWQBTlW}nFY[yW.WW@.pROBwYZs]_xCXU7U\GP~ZX5ZWNYj
LXWBN{C^(SF|T;r_CNZrJ_A~QGXR@OF*SFYTTf_@V_WlXQ^~y]_x
@9WEDrWb_@9\|Y~TXaZVCCB9'SF}(LX_\HpZ
jvUqXK~
]7U]or(^R*(	.y4{sJXvWB\W0
zSSM TaWH
XQC&nP_Cr$@O.P8}^ /xWt
SRxGL~~H&l  ;RUuw"UWJ{RQG8|Uy
V^G&STOx VSpWIoUR Ly]z:SG}SqLT|WHQBQjW
VH$9OC:RUuw:|Tb
]Ri[PEzbhr,oaQVOy 6FWtQzRz}GbC@,/4Ole9S-_u S]UAyQj~z@L	VaG$P- `W"rVW{P4pi]MChGX]
@yS.SX[{M|eUIBfPGjUW,0]S[:.WUYHJ	Msu
|e)IxT]HnCY[yeU_, hoeFeRJBPR\@zXeUaX@P
wQaVOR_Wr ^7NPr[%YF/5AR[@^E[Z_@W@/7RT[*Rwe+ WIoURDqSr*AG&ST N SdUAyQAS,Ck\W/FSP;[e VtTYI|QCWV~[{TTYYu P8}^ /xUAyQ[-{\uCTuzC4S-CG GWtQzQC[XX`9Tu}WP+qV  yWI
QC&{Xxhz.Tu} S a WtIsRxU}rVBX)V}z-SVATsVW{P4pi]MChGXD,^y_SU],6cwoe|YSxbWI}X1[,4q@y_._fXH f
]U|S9MBbuUWYZ,4ACaHW[		kFaU^xf Qv W0ZeW.SZ^J	wkFaJOPS\Y[HY[yS e]2wk e
Mxzu_XNS'W Pr
+LX^T[qt]yImG[N@}]7T_PTzX\TV^Z^_\P
L~q_Mx
XVA|~(LXF*_tBZiO~O_MW3T@T~-bBC*\sJXv
LXWYK~mEV	WADb[]/ZqJBzH^}OXPm_T@T~
 zY\91]ZVZ	\fJ_YP{F*T@z~WnY[*GqB[BDK}Z_S
]7WCXBC*)Xr( sJit@zQa}STGq VWKWY
aQ[  LD@,((JGaP- C *^TqUMQC$NS4/
LO.SSS9`WIqQC  Xfd]v*:
OzG$RUuw :SzWbwzSK,EvPL8(HYO7SVO` /pWAfSK XvW~9(uWaVQVOy /SgWaoQC$nzd@# \cu6NCe ]MQ|WYRPS\ X,JA_RJe] Uo@|YTB~uV}jX_,
^yW eR,2wQYV_9KBPUP}YZ,`ACa.e]J	wkeUIBT}SWn.EHrECayuR*p]YVSPQRPUP}X*FH0[CeW.adZH|M|STB\K}X4F0ZeUWPGH6E	wwuF[,MBTmJn/\H
ZACW;JS~@ R]]U|_Hx\WWP,DH Yya1J[v^H 
]YVYSxXu_Gn0Y,4T[e\H iM|SPQRTPW\ X,4lTSayuRpwkFW.JxbWI}YZ,4TeW[PX.pMkFe1HBTpKPW4q@ya_,Ro}|ePRbXNWv W	NPr[%YF/5AR[@OFXNC
E*'VA|~+D]R)\rpXx
L~qYQaFW3V^Yb(LYX(NZY|X\QaYWC_C+VATX(@_@Z|_jX^~y]_x	Y|P"c~wHRuW/JkWt
SQ[/mLuyX#VHToq7RUuw"UWIoURDqBjJ/
tOQSBT|VW{WQQ[X\fkVWaVRUuw"UWtMcQC$|@@z4/
LFG;S;uF /vWtQuQ[mD~L/
TF_,STGq "]TtIvPq"{@chH0TUyZS-C{.~WtQ@SK,mPrkP4G&S;qN:&eV{w4pi]MChGXD,^y_SW\6Zw]UVaWQBPUKW\YH Yye[.WmGH6]o}FaUSRTWWX]
@yW"aE.pMozFe5SRR}jV\4hFSa3	JWCY,J	Msu
|aTWPWGYZ,0\y_L_DH6E	wYme'Pxb_IWT XzGSeZJ_,2Mo|VaWLBf RWn0Z,H YyeWW}^2wk
aUSRbeR}YZ,HE_LJa|E, XoLVWVRPbR}\ X,`GCa"_,2wo|[IRf RWjY]4h_a*.aF6e]wuFaVUBfJ}YZ,0]aU
._BE6a	]]{|aUSRfPGv W(y]bA%V'U	.y4{sJitChXA`	NPr^