%!GMFNWtKUb<ob<R=MDLCdNVZZJ:tN>T:\\WmDqiCB`N\\@Nd\\Qgqxx`JFmodpsqaTOuToexPpWL\\NfHSJ\\RB<K=\\k>uMU]M>IL`Iva<NBYJV@PH@nb`kI]UA=YFmm]\\KrhsAAy>tVV=tS<VRaJY`qk\\kbYl?mqS`R;HJk<yJujZ<N^<lHMQwxXQQxhywyuwyqxsxnHiudEwhPSyyYYyTcQsgXXIiQeiQyyusyOaTTo=n>LJ;@RZ<LB\\J<DjZmMJhl`<LB\\:=>LR:]J<:LZ[>^<Fj:;@BCBK;C>KJ;JBFZK>[>N:J<nbQ``;@bZ:=NbuUFeSIAoSPTSeLtPXd=YaAktiuBaSZyxwXYmLWcqMu=o_dYwLR:]:>>NjtI`xFagpgrytYXtqidug__xqUopGVtqYdI`e[PyDhudVmCQoDgpLI`oO\\<N^J>[>N:BmacgUru[t>ar^OIZuewgThsHaiDkYygwgboyxqYLqV:Ux;Kxkuy`yvVyEWwiaogXES^YvfgHiwCVydeAFIQC[;F<:Kjs]NXtus=WmxyyYXxATchTuywE]r]IlYqqDutHuQtEkdtleLweTMxmPAmQvFyrvvy`]PItg?^>^bZZ<ZbG^:o^@yn`HceHxYxoH?oenwr?bgha\\AbyyxMv^dPwdXqX^niymwwtCQoixnUgi[YiI`tJx[vqx`XbpYwrqxJNZ\\><BJ;C>CDZUXcgF=SBdSeEQdIiRk?t_OCsaY\\WyqwcF?dPYvVwIv;Tw[isUCWUYZIgaEc>?b^=v=wy=sTssERGU;_fj;dhuX[sE<=R>:\\Jk<YjyTiTl]yxwqmIlJ=lvJuJfIq>eMtxwJPMdywE`qYaNT\\S<]SZQMMXLxYyItYtplFappuLBDJK:BK;y]YfPEgGyGhCxCsBjayeWiB_dZYxjqVQ_cvGX?AV:?GjwiAGSvKd:GsAiUYCImWV<YwDCBK;[>:Ke:;D:;eyCw`;TviE^SBxeEjcgtQy=scMob^arOYgNQwwqdLCyJiScOtZQwmutdwxYOYFqWAmITqc:_sPOSd]XvMTOOs_?V[SXWMgu?TZsbVoS?ggh=gQAbm;gliUWEcMawHgxXiUjWCoaXdYWHwUearmMu:kH^GyV[wAUXugUU=CtSEEGWXQC>Kj@EpQQtw<wmqr=pxKUwHMUG]n=hMDYtdeaJQi:`rvyxyQq`HgiaerFreI^ugj:@g:QjAFnfxaYiodHmVau\\?wfNjMY`hIkIhmDObp_wTfd?>lbPbi?nX?omQt;Ij:gysfc`PePW`OPgZfcuHZ=N]<Q[:HjgocNpcfXd]^v]XoEi^EIqFg`thudH]OooN?gVwcuVbUfgNYuW?cfas`>dgwaYNpSacUoxa_uVh`YirFhukouD^Z<FbmFjqO_B@sanus_asVmYOxIx[NibxNm_agHxxwYnIpyVgynIlA?wyy\\gXeaplhfed^Z>ag^^wphl`Pcdgu_vwE^ypPh_Q_ogwoxi]pfbw`hXxB>[HFl;qw[yqwax[gxoX]i_xixuxWygQg\\`wXPesV`uVcygsnvpXqhAP]YHmbWstgwVV]QgllgwcXmf>nnOfWPw?VlIX_yQxMQwsxvp`r`xrRpZHHapA]oqpqxmhPiuQiOAu>aldi_PgdKI^\\NjHYrjAsbfq=A`QipSyuPOZu_uVhefWxP?^J>[TgZrIjvymI_m]poyylGGp`>efHx:HuPWp\\`eKIZ@x`vgdWWx_yoLyyI>uiweoOucwnCFZcHgbHmSOtJ^yZquiytvqZ;p_UhsdPkq@`pO]jX\\Tw`UpkSIcY?_:?c;@^mhx_x\\OqLWGjuGmmBoIFewCQUvMWtKOedoXgWT]?sNMSCWtlCS;yuumwxWUW_ipegtuu_sEJUDMUtneUB=SaEb?oxgYupoB`Yr;ygy[cnWVgAVyWuBaeWieaig:=FJ[hD;t<WRUKB\\ErHSwt;Xwihumxdoy\\uhdiwgiWdYhS_YVwY`yeJ_g;gcIIrwkdogSUahGCB;GILKVdsIpAw]mtYyevMxCMUFIVt;huOuZsV=]WmQbuKggMtYefDcwryWRAh;eIrAbEawk;iyqvtwsMGWKuFPIgK]TmgxQICg=i_XUNyvy@x?DN[dMB\\sA\\koUXx\\YpQme]T_PUcUysTQe=WQxLMaqO>;Ug[MIiWe:gDJ[HP[xwOToivb_MPYNlDwveRqdWTanxIwpYYNyLytxy\\tsuvwyPDYX^uthdpaQt[DNZlNjXPQytQiMjtU;qojtON@pYUQnAxq<oSHuluRL<LeQjXHmuplCaVttoHetl]viimRun`mpAlriyJy<y[TQ[pY\\yQb]SmAy@<PpIp]Ex;xxyxUGesHQK;DwnpyIatHIX>DMRhOQPQd`wEhWXQK>LJ;Un:DYRHOOHwZMrVmPAuNXxKiAu;uqw`Q[utXTR]LlN\\MpyLRYqqTn@pj@Dsi]LIQpsllYaYmiOdar]qkPuLV=X;xOmtxoaq`pNWar>aJS=MOTk?irC=RRINlIxAqvnxMRImu\\wjXrvEJGTq=AV<XpWLwALLA]SVIJldoHMQsiOdiOiEy]dkRhl<uX]tLv`wSQulErFUj?AXNIOUHmgAotdPLykpTTu\\wt<u><TRhqVDX>IL^uksIwIeYDyqHHxHHXyqvMlSF]VPTNbuWZ<w<hkR`O>LXHAyFaTeHlmmpMuu?MJ;@nm<x?xwwLVwpKAhWraSvYymtOtyn>Xw:IyTtnYdyTIYSULsauHTxsyVVTYJDlFtxwMm_xXdtomAKbTPodP_pjwTXV=lH@P<HVTHV?EJIiPCQsmAyayX]lQcDUk<UZtQLmK^UJLExjqnAitumuwmVbqjwywqpq\\pYruuI<s>\\yDXOh@TAiMq]u\\aNZ<td]LlEMYYSYPMwArO]prIpM\\Npuj[pQ<UNAijLTVu]WfavkUvmTQ_UXB`n[yS]Qx<@X;HjRdlQlwgQTkqxMYJwdQ>QmaePaDT^yQJYTF`Ni=WylLlUlNxrfxMFUPnENSdW=Hk?XygewFewiayXEX`IVGXPMdQyPS_QRSMyDhucXw>ys:xUJ\\tJ`uaexNik;ItB@Q<<Ltyo^ILY=m_@VQQnKAk?elDerd<jPdmveSgmJQywZXjHLTY<qnQt:XpiqjY\\WZDvi`Uc`ndYQnxS[XOQLuiESUijAiXRmUppq;AmCyX_UToHNIhutUyrDSwLtFixjPX?ilCxv=ms\\HQZLlXmmUxKtUU\\QUOYN>LYuHXuqsKLjTqXohpW]tvhOeUxilWHQvXQYXiRGAmqXxwtV?LJ;ay\\LsSTyMlK;DRbQUU=uT=QcUvZ<rsAJHYxjTsCxv=@J[eU>Dv:YYSiUqYoXYQtxj<al]iY?xuYUpFEtS<NMUtMMonTU\\dK=LjN@rQIqLmuYpq]IQJqVjpj>\\N=\\n<lQ[TStQyvMV=ElodpGlSVuMY`X=LjjHUf\\Vg\\qYExvynXPYDeQyQviYNeAYgitYXTqpumyOELQPLu=UJ\\aX>mQQxNgtJ]aj]ykahM_=W<=ufTwCxrYdTalmjMjMAy_Uo:hr[@TsulHlVWMyq=lVpOiutx`vf<l]Xvm\\pJHn]asvQvlQrw=UjINZMNiHxcPLgqxUQx\\XYn@p<YX<IS`<puLs<uR;YMbend=qc\\JpurKqWodVcps?hOHQY<`jg`Q`iyrmNApQ@@x:Dq=lV:=sQuuk=rw=ywXOMeK>PSpHlDQX_mtqxUVXOYmNPWZ;yjUqm>Ffiha`?^NaleFpoWbXVnMXl;XgB@`?PidiiT_h>N^NxZ<P\\xwb>Qnxqu\\gu<gkGW^Nnt@?_qNuOVvfi_ewtLFwJi]MYnBq`qi]Ihlvxx<NoPxfWpae@eui_fhe`^]lfoUH[KAaBQqwgjv_sv`xsGjxHtaArnaZtif`^pY_sl?wmO_Gw]aFwYo_Uvka_soO[Afww`nM`scN]]Ius`arok]_ceiw[XlN@pbQ^MXtmpit>a^XxwofsIgXYgoCnWw:ueE]GnqiAywtEEc[roEG]QeiIW^whXIIEysBMbbGYU_vW_d`mslAIcmrVgDBLQA<L`yLl<nA<S:]mc]XXAUX]W_ivoeM[QYkpLfPuYiNh<Q=]rvuP@HWvMrhXvxicxOmxXwlfhR>\\SVgZGsLhrC?brwfHNZQpwyIh^Idy?buXqBVdDytYphTf\\<Q]hx\\fVwGn\\n?o:AbNc][iZEFvMWmYt^GV[qC;ob_aimyGNUR=cYd]Vf]UGkxqiBtkuPwDv=Tj?cAev?gRNqh:Qbosrpgbm?gPofact]SepCtmqhIsCMeYk?heYbRgBD;CRuiVay>=fflKgQuYyuieoUTKylppEvtArF<KIqm;@V[Im<DqFqq\\pUvmysdPdaxQLsq\\QV\\T_LrqHJQITx]KdiLetKF]TalME<Oi\\jH\\pw\\t=@sYuWa=KrEToUJJyJbXu=xKw\\vYUQdAw]EwXpUA=JwhwpxYhHsQlnJUyfyiLNgtYiOWt>NmFFy?`jIW`XicKyrs>jtxmuoss^pmYmEi\\dOyXNZ`ycxOxyGgH?woAtuisFpq>p`AAms?w;ymrytRWt<`yFqhsfwnYt<FikNiuhmnxpYq]B>];YhZNoY_sxnMoFdQw]]t][gyEFZOvtGuh;wYidekTJiiweROUR<=YH]bGIG^IbGEd]scvKtYWD?uw_[xLYCIYyKefdmv=YdIMtRwfvkTgOfkkrHobIaWxifyYEDyC<IcteccUVY;bI=DDiClYvQGxQsS>wsUyhvIDSWSGwSPEgFGWaawxuBf_XCWbmsWqKWmqD]efOUxpKgIUv`awHItksvWYui[F>=FbAVVyisIIoEucuWF_SM]wHKWZEVdcxZygXmX?gwgUr^mg>cC<GGByWsEvqiHx=Ej=CAixusYxaGWyx@iD=_V<kB:UG[eu^GbIwb`sx]qyYgyh]rqCg<mIa\\YyAsJYw]Xn]`pxDxutL`@uF]M<AjaaQwatMpqfLqQqquYy_epKTMwiMIIjU@nWmtwiRjqK_]xnyOLMJ<QWymLnIJbeQJASJaXfpXP\\tu]qeApIxqfQpEaTsmpVDmITmm@NYxsymytdX=XxyeuSylqEmkewFYpHQTaamumU:@Q>uvoipNEYGIlEPOG\\mbLN@hmAyUwqvqDJm]mMmSsdrsIpN<L:ENNqksTkr\\TbmpmtNr\\pe\\Su=vE=nQxJ<yK>@mCHxCdXO]rwAoIlX_yoVuqXINYdqx@t>dOLqrGXMctYUiYQuUwepyyYnxr;xJxpTwqN`pStqKb\\TGxXXIXU=WxAJxURXALJYr>hufXN^HwIaRU=nwIvRhVPImeYs[@X;MR@TymeSsDPnLWAIuWiOkmUFlkjip`esT@RWHx<DPiivx<rh<tOxYspQnpMbypEuQrEoe<XemY^lOcas?Lu?LrdAshHPeAU<MQwtONxJ<xoXyrpHQ:pYkps;tSJeJC=q]qsuLLoIpgmQKpN[XOYuTyqYJISADVq=namsVLKg]RTANamSVUMmtNjqM:Uikpj@Q\\mo`GairvtcwbvX[:_aoQp\\`yZVipxhOfZl>oFq^hVnxvgkq_EWaawsmovfNsbWiQflaO_GvsUqfqIwuw_x`ncXhPC>SC=gU]YvC_HZ;YiaYsquyUFLQD`mgoUuAosZKF:_hr[CJuSAyVh=e`mTIcgy?cBGSRWtroiPsY_UrIag`aVBYy\\ihAUgqmEqQi:qRQku?yhVQXEOixqriMyQAV`cXvIHAWtu]w<iXQCd@]Ryuh\\AB;]iyAvIIV\\erliIbiEsqhMuu`QspUTMMwMwevaDwWEyToeayHXyXiXpIux`KEhX[ItGUM=lLQ<rQhMSqlCDKpLuZ_f=iiqIqUFliwiuWstYi;yuPagehynxnlNvW^iPakvIrKybANtmXntGul?mPos\\OZ]WeJihZGd>QrChe?guhQqSHi;`s>hb<ItYXlCHkdfj;^kWasWXn[av=a\\ZFhR@]po\\AiqJqo>AvmIy>wx]yxIIa=n\\dwbB^^NqwOahKNhrqqr>xhaiR@\\]WgeYahaqM`ZYnoU_\\ppgWQc<pdNgmKypqwUIvQwfsMEJ?Xj?rn=seqCCkwr=TJiBgguWGxHoi=WJnISNeQjYMVTuAqnVeWCtsO\\k=UtKmYruvB]vR=roYMi=qKPxDTNYlVy@VQTM]mSYXJnXx]IKd@wq`nw]smIOhxQLpxiySVxkXmPlyOjmv`AuRAU\\IQ;ppWpmVtSNyqc=Kc\\pDETiyLJplnTxPlXCISayUgaqg`pfmupTqIuqqiuuPmttV?LZ?HZvO^f_j<HjGg\\L>mWNx;Fvy^_gnoYxxOYiWieyWs``ZxwpKxZrymZgcBVt:@`<AsAvvwGryQqUgiiWtiXj>hveveKw]yPxiHkr^empymNwPygyexSXsybNYFIgyLOr_qDnghSSe\\utyiuoQwnYhIyxWGsiIieqHoYduqiIuxw]vLyIaKdkqeEwIFEwZaXXWXBqCB]BYKXfwWbYxo;WJ?xXeRX_SL=R<?xy]d;swMiwTox>CWUEc?st:?bv=RZktQkUbeIj?XlWtGowAKBUqHRwV?Gy;?eECHYybWwhmysysexwyryrykCj@UNDp=dkWmUF<UU=MDaPseowdvNujCqK?lsfDsUMvaYmIIs@`rRyVLPRHQyH@LlUugxPAlL_]lAlvGTSApJOYpIqya=NHyQB=KUxXj]pk<mhAxwAWU=mTAlPMr;AubAotqywxxtQr>Lt[dQFyOneoNPXXHK:aKAusE\\vKuwAAT;YU]lUR`mryQFUjnEN@DyW=Y[iJNyu:\\S?]xWAT^hUx`YsdlGDigW`GGbUXx?qc=^cq>nSH^[xwpxiH^aMfx;qk;accfibatdhtIy^XXvM_hqvvsOyrvpKxcdYia`qtWimWyZpqqputWgZp_r^tmaqqwqU`jgA`uGdP>gknjjvZZa\\I>wsGp:WsIibUNfQ`jqvZFyv\\_s[_aGgsNPZw_[<^tFpapH\\cVpyggoEFitMwStCsQ;hKqHRWejSElsvNYIHAI=exI[CRUxsqxqmi=MuNsvg[drmIZoEKMrpoeyKw;;rnEC`aTR]efUxpigieYeCIlWu`iGXiSh]De_SdGIEMET_UvqR=UHaiWLoIgerVgDBLu=<LVyMXeqlLYMltsuLhUMX@NGyjH<WW<QIdQy\\RtMpSPO;tTYXqppj>=vX<c<a`Z>iYIrfYs`AnhoayYwI^ahYm]GvWik=FZ[hwrqsgvpdHnxqaDWhRInAPyxWj=Wb=oy`@uYyigqZDw[yakyxyux_@N^NG^Wnw=Qiwoy?wlrynVXbMoisybyNwL^pyhyUOqHNpminivic>nCHj?Prunusoltqxqpq[ylcQueqo]VtU?gR@fHQ[nPdmItP^Z>hZ\\__JOaZ>uJIrX?kn`fRyr]Gp;@xYG`poxj@j_Oomndmv^pvgZGjBV[YYmYax`fphgutHa;arKNuKIjro_fqnMav?FZYwuS`quqsUI_i^[^nhBOclXddWug`fLPru@uMVv]GZlpb`V\\H@lsVdhPtHFyxYygyb<H\\p?ts`aJnoZox:`aZYr\\XpT?[k^^B>ioIwhIw]Xbe?f<^rII^YY]A?l[Akw>p=xf[Qj?h]@HuqFdoOtMAjfObr^t?@]VNsAFvEhp^?pO`y\\ylx@oxnykxkuys>iabVmxamjvrSo`INj]IyNx<IryiX[uBsQrY;fX?eRqhxkb@AG;_GQUR`GTH_ghGB;?TRws?[BigxeyyDIFPgyXIf?eTdUYBkXfmr<_hroThcTd=SYoyVKE=mu;eRvkCR?Veiw<iWBGh>mSdIFceW:uE<?R?exk;XrYEHOXtAybAuxkCeyUNgs_kD[ix:OgtWguwrYIwAWVtoUpmeM=wuGUigwJqItUu\\mWv=y=yE`oh?Ee=qv=kwM=Xpss>chKCV<lwE\\u=Qu@=QrYniaWmqX@YPAekTxprmODyl`ms@HWtdxk\\LotWkYmXynYMylIPdYVQxYfpwxdRydp\\msD\\ZgYZM@eR@jZqyiysfaoKaivoxWw^M_ZcVxt^ymNrB>stXlPWeG?qZosSfn;FjPpr>hwsAyxasPiedicHFZ[W[Y^qYFmv?`XYh[YiNav^aeXxavxyApac@j`Y^f^ah>cBniAOev?vyyZLAnAO\\>>vuynAvb;Igeiqd>]GFhSqeEIsnhgxh]vy\\NaZEp[O^soGyXVyVIb^A_=@pPHuVgsHOaPV]fqxSq\\hVuH^`lYZ[?RORJAR=ST^SBaEhtStUID^Eb<uDDKRmQr\\GW^iBGYbxWcB_iVeW;eHPUiK[UVYHK[v^_SyWVQWTisCPSVJwChsSx?tGev=?b\\wwJKhssCDIfusCMgUqWhrWxZYFAQUA=y;qCqSB^mbCAFpMtmIy<gxFYcZqsywDH[HUsEoQCrEyOwT=KRK[wfIiv?GQkFgki==F>yWtAY:otAuHoKh;Sib?D^=Rx;DxWDsIr@cY@IY@[hAMIZYy=?gukv>mgAUBLsTymS=OheYVBaFdASmYfYcyb;TYkuWwRY?fYAtp;wIeU?SyUyuxqHJqs`Cy=mI^[WQ]UAgVngH@QDlQb@;rXot[kt?OR^MuyAYvIXy_wvaWnYTNuEMAygQsLmYQwYlYTocYFixjGDckGU;B\\oDOmHraFcIYwSxeyV<siMCW]GXLwxUqD_abpGRAshgkYISeI[XWYuWyvvQf@AGgmFrKbuCDQaGy]urUx`ai_qiaQH<khsUs[GYMosS]v_UEqOyRIceYTVygqIGXixoqxccBC=SjsVSUG];DBKIQUCl?t:=HG?XG;S@QYpwRRIYY[YWWba=uf[EZSG\\;u@siECY=uBTyCwiYhUBnSrBurUOIruyOaB]AsSYbm=e;ASPKBEKS:=hj?r`gUY=U[[bKWDrkDHuSBwItAeZ?V@?sf;EBSh@OsWqh=cS<eU@iU:YXTIfy=UZiW<UDDYDSwdq;C=CYscVnSx<wgDSCP_iU=EYqE[IWVAUMiUoCdA?FvGVaEeEYBmmBnWwkwrgGgSiSIsD:WhoSipIWpUwg=x]=yAatU?cOWt`yCvAyxABkOVMKEWagDwi=aD=uDlGvZUCMGdSACM[C`UytIu;[UI;DBqtGGxrqYISwUkDrAUmafuIS[ir>YV<WwLWxBMVZmgrcW=uteoXlmbWUDFyCBcwVqEvydCkcggCoyvTQtlAi\\syacsKKUiYVpCgKYyRWy`uwwsdPaxkWS\\Ws[iyUGCXgHKsTpcYA?Gd]emUu\\wERqePahmgSlsEvay<MyuQfoUwbmwoaXu]rAIWQkWU_W<KFUcHPQdHIUHDtvhsPqxchWXqPNynctvfMlpMLB\\JgYJptUDMXWhvc\\y`xYZ<w=avcdsmDXptjG<KuiMaYJ\\MJIqktmQu<Y=yu]yOxQv]\\LOQspHUlhY^]rq=QAHyNqyetKF`Yh\\OX=lH<rw=pJHtCtkUAWkYMcHSHIoeEKSYUjLxKmXILoTlMS@KjPRRipOhX;QSU=yGAXvhvl=P`QpGUs:qPGiRglWipOR`jsylnTPiltbar[LU=LTOEU]En@@LDqnslnjej=]WfMRLLt=akCuNpLymEtaDq`lO\\IXseTbuJvtLZUvR`o`EqFayJpjUQMqQvJ<rfxOZiVghYaqyP\\WepTYPTWakp`rhlQpEloylDIrAtMfykClLZaW`TkFPgwiZ=V`=gyJg^UFZD^kywb:sSaUlGIhWIlsVlgHw]EPqIhihFeSYSRmsTc_V=UsPktYoHYoGqUb;ieAqVF[XRiCiiyTgIcEbZYRwAigessWriAJ<]XL=VhpKHlKspQclRB@VPQKkYpKuMnyv<usUUXQdOxmu`xwMUurUWQXl_iJ<DrvQJ<LQ<]wh=yNIYnqovirmyoLIocAXtqS=<WTMrf\\M\\`PZDTsiR;LpTIJqxu=mKYAQvyK^Ev>YvHpnoPMltOFIobpYUQjHuu=HPaYX^YxsMUu<Rf=jgXupHt@ikXLVq\\S=LLZdUdEVplWP\\k:@xhepXlYQ<rHLMPTUP\\wgMRODmP<Q<UOUyVAew:LRJUpgAJtxNsuleuL>qL^il^uRkDWTdUj`Rf<WQ=RcQoctKlQjglPiAKl@LEQr=tQEhsm<NfEwHxytHUVUR>UP[]LXdUrpvWxSUqW`tkAduxELqqXsTLKuuwypCdmELRnXR>Lpn@Rw]xxxjJaS^lqLAyHiRmPsQUmimpchYFHQYaktQmUhL`]Jl\\j^\\VyQMq\\thmr]DNd<xv]lmHUauSjpvQqR>dua]sphuvhRwYUWyns@OMqP;@RJIx:=QVUT:xvjDq`iX>Er<YqRTm>uLwUxxqjFmp<quWixb=Rr`s`<X`DK:tQH\\RxPjIDNBQjE]RVMP<TLd<yl=ra@TQqrMXQ<mN@ULgHUe@NImqydo@\\nJhU^]J>lXHAxyAYTQvyITCqTe]tMMys=NJ\\rZuYw=vdhT;Xl\\hWEhL>dpSTssHNhQjRhoW=LwhjlHqsEo@hPZ<JvuUn]wqxxXmtlArvIJfqM^Xj?XLBlPtajmuKO\\OuHWvDNELmN<yS<mkLnUEOVQTsam@LtYxrTpNUIkOAMYTp_HuTHx:yt]dj^eWQYYx`jSpR>XYqunQiwYUtF=Kkar=AnUHwSXqFIVw=lN]kHTW=Aon`o[ESMyrOPScdXYtncxJahVM<NrYMjXxplmopYwyy^LT:Ilj`usQToiJyIyxtW<yPc]wZIYUQwxdsDIMZLJ;ur;tjqIRruS<mNJdJe=Y^mn@`Y>hmeILc\\y`iw\\yWwLMJXUx\\YPPy]YnPEoyeY\\<yxiUk<QaMkDtJkYrH@QL`sGIp@URELJLAjI\\mBINyLN<PoLquIHp`Ax@DRkpmbmM\\HJ[Ml<DquTmiqUV]J>xK?Ut]LQKIyY<PyMpflYfhYZ=rx=y:MQjToV@uhEQGLmSxTLay\\QtjXxfMT;hnJLplUPsDV\\MjWaJ>mwDPQ=@VxXukLS:Lp@UmD=V<Tl^\\NhUOdyUIDK;YS;hwfIlAHuqISHaUjIkjemu`sGpp[]UTAQMXRUYQ]HU^ukMqvlmo=`PvyOnAsk]MpUMgas[eVKdmiPRKPr`UWBdyv`WTaXraqgeXYPK>LjWYMh]LfxLe=sDlKxYSEpVtAj:Utk\\q]uRGHOR<kCIQEyUmtRppxYylPQM>]O>=vW<lK\\mGLreMQFIpZYt;LT<\\kImS>mJhDJ;EvoTKT`l;iQPHULdNjIJCaO\\tMJ@pjYqZejtqwg]LJpK[Ysnur]IynHjheRxEqBuRkqvNxjoTSJ<Vjmp;pY`<J=Dt;axjmmEDtHHTutmSaJaMoRESiMr=itb`uOQSUak]pTEDVcmXSXtnHNSywA]xI]tmUwcXXwLMJLK\\DTh@lshLFqojmqAHQhGg[ai`or?v\\V?bqAmawsnP\\uXrvhgowmD^Z<ps=VmcFw:p`=NmKV\\r>ni^_I@pB_dp>b]OtFw]JNipqmEO\\axrtHr^_ZiagHVqUYty`rqIw:Ib;@xCFtIwbqFxDqxgqy;PjjI_;_`gPmb?nC^i:on`Wsdxhk@\\Jn[yXyMybXFoS?wMPZcGpuodHHamOnKBemhJwtBMe`]dAwFVKF_H[whqS?q<HsC^jk^]pipJhwRf^f`dfvnDyjsFeANt^OhCYsWa^AwdNh`h^Zm_l=wgpVmcHxoO:kgrOFKYx[Od_aY<Qy\\ccZ=e`gC]awQUthqdqSTbmtMQVk;b:wcm_HjmYIIUaaiUyTMWwm]boOFrocJOhfAgXQWLKhu_sUqTqIg:=FbaSRoyX;FYSUpgt@GcGOt@[f;keOYuuMeweIhobY_bHwXRIBc;c@oi;_D`YHBEfpeI<Khnucw;wBcBrqb:UC<SSYkXJuhPYrSufRUU<gX:CVIYWBgTFoB>otMOxfQbnYy<AW:]E[_C>[FZAGMuBZuxFWXs;GfugQpW]<RALpjptb\\svpvUUJ\\xmy@Jj@NEhMNUTBHvMhugMjhUnBMThUPDImIMPt`w=Ytndw;iq_\\St@M[AQFyY[PTcemtIPCHsLTyB=uVLY=QuJDnchWxyQ[=rExWp`PWlyvAlxESTqjpMVOEkfYvnTq_aVLpRTqsbEJqdo@\\RaDNRxORxPiHUp`kN]vrTj\\Isatm^hkLdUe@jt\\Y^YRQPoUpWtFlP@omyfLW\\PWsR_w^HiUawxfktw[Nqng@_;@bjXiu>adgn:>ZVFjC_b;_dZfk@^vdXqX^cWxyqo]TagooiA`gTfn;FigqmoPq<@pJ^qap]sPjxQv^^hrYayxx\\Ycdo[\\^vG@irI^<@bV@i<I[daymvy>@cBixqr^WHIoxOasr?ERAh^UTf]fycyFwXJyxLGS:MVn;FJAfFesPwD^wcaie:?T^qEaYHlkie;hjEfkIr>shuccD?tZ_yQaBFEFRkyCuiHmYSqgfeUu[W[ubk_Hmsg^Gy?me=Kvf[rVcxdCCsAbjMc?seC;DEkHrSw>uWqYWiWihmGlAeQoilscT_fV=smQfpMugmV:eUsaY:=DmGCIqhvcUU[xVUTdQWmiSKYr=sRqWRh[t[wDHMi`wCNwGrSEHoI>]IGsiMKISQiCMrS=Uy_RowHAEceGgmmFWorIkifKSE_BO_HySUSaxn_wRiSQiexOX=quP?s>_cIEIy_wlWsBIxYuxwGbsoDnkFcURjqd=qHs[iMStGyx_UuHYulEi[aI]Qyn[WvghlUt:=FJ[GfCu:od;CvoeSZiuFsrhUtceiX?WREVHSwRUT=aHZ;uvsbC]tOyvhgCVyWumIvyIR_WZ;RB;C?kHSCvI=cocVruvBOy[iYy;FmYGJ;cEwuqqIDUCmKgIuUkeFwww[McoEw_swMuEr_xLMIBsdGmbYcYnyv^SC]yx]ycs[enKxfMg?WbTexoOfNmhuQibQePWuheiSotl[vIWTSYYv?W]UiWCB[cOaPVb=y:UVVpXTPUsPV?]nZIk?uSYIX]hM]=m[EYppvpnhBp]>heDWu<nf@Hl^hZKIq@Vioqf`i\\a^gcixEP\\vA\\oQ_CGiVYl?X`dqjUnqdylCv^NVrcwuvfhXpsM@_Q_uMykeAawYqKPacEcARSCFrIw;kB`abRsxFodtMrGOv_ITbovVKiKQeCgVUSikmFE]w=abQKcH;IvSw[AgAKR\\IbUgwmcHMeFu?TwAVAMISYI<=SpGWo;wnWXEUISQuj[Ggse=KvLCgVeSYsEs]vKGfw]ckUdpwcMAya?XTUHFggMYVHYCv_SmIfBWxw[Ig?CBcITITqIhZASqMYBWw^ysi\\RPExf]quLulmu`QUYynpHpSasGUJ;@RjtqjhRvPY]Qk;AriAN:lPG<sRarNDW=<vnmW@EbP@kR`^<FivoxWw^MYqEB>qTHaiamSwEySsW`wiqyWxmGn[bjIUemUiyU=gRFKfXExS;Ft;RxkIueKNAj`HM;eMiMyAYmOypyhxGdxIupYYnxTpxQMDDvEAVyxkIaUxINoEvtXk<lY\\<xYerTDrcMrVhwIEQ_aLtxM><KYlUQAnSujYXVHepKDJSdMWdTi\\qrQVbIo;IV<LLVPWn]SHHqqYmHqvBupg=YaPULYUnajLaod@Q<YUxTwt<pHalePWdMWd<XX<KxqQuhVEDYxyTuQYNqokISLambArcHwAeMw]odplu]T[XYHqYJ\\wMarlivEite@O=ULmQMjQwmLwF]MmtqQmpiAxReyJPmSpmppQMXtJTPqlKV\\vlaTDeRt<l@yOIAsbdjRXtGqRJyWbtnsMwvLxilLEPoyxtGtRDHKHpXpDjt@NImNEDSLirOIOQhM^Tqp=oyasm\\T@]qkmpn=PrMkoLw@DVEaxQ@R>=nXquXLLPqUSqQVUVeEkl\\wnMwYEXtYnJ=OrYq\\yOsTVTaM]XUqpWOuOw@xvdUIMMcAW^urpUwoyuwtxfdkImMAlqZevKTtQuXthxNiy[@xlARw=w^Gm;vng^utVw^Y]KGpJxg`PuAOuYNusAxTYycynX`xqOwkw[N?qbY\\UYkBfw<Wxh?fZ>`xpjq_wnpnOYuJxvcNtTQuUFd;OcHoqRIj;YpGqa`Iht`rcy`WVq`n^cfqSyrvnp`^mYigIYvt_xpwvoHpp^]TphSX`pppuffRqxuy\\B?`@YxZOy@pxTpnsFdnI[lalMqy]Vq`>w^Aiw^eiNs>pq;Yh=qv=paHHblnb@wre?[=ApQo^Nh\\iy]yqyWhpiYstwvgOln>^@gnSImJIiEPhaqxVOwqIlgxcgWxpHlxf]dyw_vrJOnApsvh[UXpUwetGdgQ[SwgfXgTqoWOcZ>\\Fy_Z^my_xRhndIocHZo_bk_d_whx@opteMxyuycIhxiHvWduyXGSDC=ryIytyWxyeuGbkOhEiSIGYyQsZIrnYESmsbEy\\ywDqgKehCIdM_W:MEbEGXwuruedsEr]eYmdGUeX]Tu[equCDAclOwIyy_yGX?xiLxxHYaQmUpj^ImauPsIyfTUTxKfMO<Qn;tv:@rdujqdjkqy=QY<PXyTpsylPQP<QOBDWJuSweK:hrJtuuhvqtqPUUFXyZhu:yJrErKHRjIKEyyEpSX<YiTnV=OM\\VQyrYTYfdTYPRxyrc`w=TJ=dsa<NJljZ<V[inIDnAaL>hXutxVppelV@mq[@w<lsY=KDpn]dN>HjSQkMElx@njLrapuP\\qW\\UwlkvDK[YMqLomhM@qlCivOuWYewhhMtlKELQDAsa@V]Er@QvGhJEuOAlSQumddlWLXK=TwPok`qHmQcaNqLp:uWYdw\\mLgTmm`vj\\ThPTXeUsQjMxSgqobAt:uM_YjpXsPUs;DNNdv;Yp[APWYmi<yuXjrpTBIMaPKipUguMrlkJhlgQOrix;uuPLXwdP`aVbTOBDNaXwp]JJaYPqUalSQlTaloq\\tw]n;IsGaJ>TQviq^QvEhupHRwhqk<roURShXleju?qpWbg?uOXnkit]GkkikeAc=XhM>m:@fvVw<V_MxbTvvHYpFyu\\v^MhvSXspQeHOrtwp`AoF_jTIwMIwSH]dv`Hw_oVrKW`[>sufgRYuQYo@^kb`eU_]\\ii<X`[InGNvxFbuw[nqZUY]i^\\NIZkoqEGqLgsr@nknvB>is_xap`iXlnHfVOeNIZ]anUg\\Nah>w]aYx;w^hqoVaodi_^YgtA]wIjvQqVPaAsBiX?ydGiSUiwNGTcwfoSUT]siwXWgYpceFSeMqSZqG\\AfEQVk[XxmbGyBFgTvwtJuRtcgVCYOcuqmbg_SHuFdow\\uhPqbpescsh?MesUcnqhpURTkgiSGhKraiWKOwLytMGeQoI?ayByXqAy]iCmqHhms\\gGveWRAtLOEM[ilwVtkhIquuufLQeC[B<or;qt>YWFYw@iHwyye]WsabVUHiIXwYEducj;u]ihi=Temxn]vGYRQib`iEoayTOHY_XR]XwGdpAi]QtqwdqyD;oRLquM_gykCh=gyCtx?uROb<OBiAVUwiD=E\\eXf;tv=bv]GYYWiKUF[SlID?Sx?yIkcwhQywKicUVZQI>kgCIUQaHEsxbyxk]ermUbucrKvB?rw?V??DbAVhIVucsKsi=?HZGdVUyrQhTOekeBk;dQce>cdvsVpMFvCCmQeRoe[Cr=asEScVwWHEdj[fegsQ=bQ;S>IW@EyJqTF;CG=Ypac];s\\aW<GuSIEokIocSKcCXkycyS=cv;Ue<=H:?RdwwtOi^Kg\\ihEaGOiCceW;KBFAewivJSEj]fUceV_x\\;R?uCkKHWEXDYSK?Fn;XsyRAyFWQXssEvuHogB^;sVCX^CCJESFAVZMt[mcEqVCCF[MgHIckICTIw?yVaAwROukWWNOvuUfXYi`kfNicq[uR;SIKRWMx\\wV[gGs]SdiYIyBrmSKHND]x[xwOdLr\\uMTQtAL:Un\\aYIAW`ARtayETwYmW=AqBYVfUYDpY;yxjpQXDMUtnkXkIlrGpyU=nIXs_tQiTumxVL=y?\\TdlW>dQ^ipdetVamZMXItQoLmMMUUQV=<J^xuVxvVqNmHL`=TbXNGisRPPciY:iX^PPTTxPTxXlvj]TptWXQvwALQ<u]`TddjyXwWppIPO]LsM`nIEtHesdYtLxpK\\TmpORmvfTWO`jN=K>Ljshs]`MS`W;Uu;dkDly\\YTIIWaQJuUy<XM:XN:XOfausXPkxsc]o>qrfpnS<jtyMdmxahKu<VbePZ\\qcQRypqZARBTV[yLElQPlYW=VbQxpuLgMJBlYyXvHYQcEr@@L;Lr:hJlUx`is;tjL=Kq=tl\\vvdWH]UXULHQRGTl@<uUInxlVX=L>DNrlTvtMOPTB=wR]UaAX<IVK]UR=M?Emj=TGpkiQQIiwLeTTiSY@mR@jN\\S<eOVpm<dvkqLaeQtPLpUN[MM@Dn>dX;mMZlVYuy@yPdMR\\Tnf`Lv<rK\\OR=vd@UvYMJxLTaJY<K?mptDwoqNgDUhtSgiJoPN=lxH`VhLvBDwJltwEjWIN>QYWAOl]jm<ykXjD`q\\ajaanbxr`pu`HJ;Am@qWgtYjyYv=LYYMH]sBpn^xpo\\mGAtP<oITuKyLtPX>=toYTLEtq=Mq=Wa]k?]YjiMdLWwulSTv?prImPV=smHLm@PldVgYsSQT^UY]xUJuM^HpoIP`YN@qOx<MiDXw]m^`SC=kNTJdXVWtXwuxu`PPAWHEYgUklewVTmbhmaqsrDruUnNesRUnG@xvXRWDpK=JlISwITGDNiqrvEpK<YXxpBUklHnV@YadYeqnU`o[`sktNsmu`QXsTWuExVhRTIKiUL]\\lbDYmqLwIVUxpRAW<eyZmX?xS]hYTHoPyQQXrnxM<DjZExZal=ulMyvIySt\\syqq^xpbdKMaV:XOv`xlYsXYqpPLE]R\\eSj@VaTK`UlN<Y;YuPDQW=omtXcqTW\\ytLL\\=WAytB@L=YKBdOr]LK<oN<x=DJJLvfesUxkIdtHARb=rhHNAEu<qO`pOB=pSiJPlSR@j[Im?@La\\SHYK`YJ:hOi\\wZURZ]wglnFHUgEUnIqxAL@EpRuOYyVyLUvHUBarmHnSHVuuQphLNYuAXs]`M;yrnDVupxdysKUY<aj;uqQuY@lyIdo=\\wGtKxey[]pEMu_EWX\\nuPwdxqlyyI@WIDSNYYbytkHpkLQyERQlmKdy;hWWDJB\\u`INe=KX=jWMt\\XlAxq]]KlTWkdm<ixLuXKpJweN_qWsxOJlR>htodjp]lods[@Xjmy<PkPLJdAt:uYGuu=anCuwQ\\R;AtUyrVTkriK]ijlAkCdVDDJtDkwlnXqjC=vLTmfxtAYTkhYfmt[\\oIXnnXPtqqD=wR=RxmSTqOIIoJamMMyVtKUTYxaQIIqxLW`ay?aY:=wVeYx\\wyPx:MNdppWMYNHoEQRZuN`eUGUjxay^XxPLUAlmq@tnMmKTYKpvDXOh`KNHLiYv^dyU`XXqPTyntAuFXmqvhDFasNqJ?^J>[`Y]JHrY?hrVZfNGawRaba?fBEFP?Hgsc<gb?iRYIe@WTZGwyIHQ?uGSRCYcFGS>=hM[IocI?UitOy<oB[ABE[hgkdkkXNGhesD_[C\\Et?myWmeyGBFUETCsEKRC[BU[dYOwYKh=wb?sD<KDaGGS]yH]x?EEWWI`ACyAUjIR\\aXa]YwKR<oCV;UA_IR=tt[vJWR<kY^[YrOeH[yhmI=Cy]QytyixaEgQdP[EleTlMkfYKwtOJhqOELoMvkDTf\\XcHOA=O=@V@DNVusiLogHlP\\vr`v_IlB`S:Um@QRF\\p`mKclklTO>@nRlVLIl^akI`P^YvWtwvTknLJ=pR:uJnX\\CYrkvywxipyf;piCVgYnw=?[^gyHwesQmDV[kproQc[Pd]^u?htu>t@H\\cghlPrw_kppcUyrjYnKOeYv^[>mCOs``mpGbsoHWvNCS^CSuOwmQcocTBoBO=T_epSTwkUx;\\J^lmjqswxyJ<V:Tx<\\nZHMmqL]INxmsd@tqELyxoTdmqHWtatVTmkUXPauvHpwXS?LJ;@RJQMrPk>tviPmmDNqPsJUxK=Mf\\JMpuhAphYO;<rpHME`kimq<LL\\ImUEnLLy<Yr>`rnDmZekDhsVEJHAvR=xf=r<aK;MJudXJlNtaPGhjgtOV<LMtlQtwryxeMww\\wZirS`p>en[iRYXnWDrFhWwQyyPKRpQ>hlALjE\\Sq@TX\\tCtuKTPt\\wX]uAxu[pm>DmdHMj<ND]VLYvpiJ>DkjpPC`oiHTQ]R<Mro\\M`XjluJBHWBeuJpL>EL<lPIhLXtOKpXZQuRTT[LrPdUAHmRHlITLLdyMuOJuKnhuoyUwHtgXk=mQZatFTmrUT:yro<QRQREujJPsKeYIxuJyjwpUnEoh`YElX>hkp\\S<=yJyrbyonhYFHXKytMYmD`MSxwH@pstjpHjMxQ:DNwLoWEqV=wi\\smMNq]McTsMQy`DmI\\RN`lW@KdqnT`UA<lV\\y@pQGTWm`Nmql;LtXdT@MOAMRM\\qtuvgMmxdKFxPi]sO`T`dLsAKUaUJ<K>LJ;Ux_YJfhUmMugUyupPMeksUT]\\jS]mSdkguNRaP=Qj:xKu<VP<no=VAUWb=WJeLuPRpepvlJ?DnQlSv`lAXxWtsZiUglUF=LTpTQqJZAxjlK[Yy>YvIPlp`Jx=LjdR\\Mv;aj;hWKHO<Et^AYGmUqtuvUPwtKp@vBdXDqqf<tx@l:MvgLkR]lS=N[ENBXRoQwutXfhVSMQn<waHJKTjIujc\\M=aNAHjp<VLqjn@OapwQUjlAxHUOAHQ_Qxjiq:\\M@@RBDuSdMqIjj@w:=YF]tO@s\\QoOmY^HMnxLHyQ:qovlmK=xI\\QFLKpQYsdseaUimJvAVr\\yhlw;=YslKIPSgavoYmxXkFDjwTmeQKF\\YHdJdeWeUSRuUM\\Wd<qaAtL`Rmoryqci^pdGrUIPoCdkR:kTm]fMsx:?S?Kw\\ErhGxkuiGEtx;ukovxwrrmb]uWiwFNKTYyxGirPscVSb[cwLadnOuH;C<SDZggTCw]qfOYRUsYjYY:YI\\[WHEXUQR:yhGYXQ=XYgxeqrKMenIy:ys_AdBQyv?vBMFPyxZWtxMYyWry=sVwhruyJ]hvsWfIemqD>AC>mboCWkUPQXXxpvgeQwMWUXpEqJgIVZdWTyK[<N<Dj:Gq:I\\;>[PfZs@[eY^UPfSasjpvG@j:>t<@f[_oSibmnsZ>[ofgkaZSneFH]n@d\\wlJI\\h?\\[Ws^f[fhi;QfThtV`sWWxC`g:WxKvb:o^whu;oeVXZ<opMx]>VxThmQwssX\\khxowv`oksysknwsfcGWyZfkKntL`]dyraN^uirN>bSWg;vbv?a>qZnvcXqsavt=NZNvrhykDY\\<f^FQr<qhFGyFglJQaSohKigIipPisrva<ygUPdSPu@age_wnWw<i]>>\\BFaF_kGI`cW[EN]Go[`VdsvomFecnhQVdwV[T?\\UIiHNabpoF_xswtr^fFNmgQl`tb_htAuhmVYsH]oEpOhkMur;TrmvJsyhGEasCRGcleu<qeEixayukYUV=uaAixuvuYr`iGiMV:?G?isSmEIQi:wuhcYDsrxiw]kxsSWEcbVKEgwSB;c:=Fb=BB;y=sh<_HxMtCEbjay:UGlqWoCB;IhI[hH=IlSI^qSDCxhEFZcSkIB[WDveCLAVmmRA]Ixqe;IBe]tMcYk;tmYC^YwCKTf;BeqI\\[hbOU\\cSkQv=WYZ[Gm]XeoIA=s`AhgoFASclyrZiE:=CT;UnCsxgE<[VQ=T]IVDktbac_WbKybn_R`GHlYr\\_UnQt<=HKiSq;Xhaby?WmiYTwWG[BMMIQArmiX[YY=KReshmKfSedDqI;Wf;eTGKI_ubKCB@MttCyIixlYRuQRuer_YBkKb:GdIGHcKtUqrVSV`GuN[ByAGGubGweAgRgIX?sHqaeRoVtybNAdEsG\\odggY:]vwyVa?E=ofjkRKQi@KyvqIpsvaoIAEdp?IRow:Kf@MyrCsVMcUSCkEWGIIOstpOyrMG>asAcixisbyXymiuUEnkvvgRyAX:wc^WXpKXXqsmuelAu]yiRwYpGIeUeeORx[B<CRe?b=SD[ebJQCL?h[Ur@KtvWXXyuywxXps<DUb=qlLJxhjuYwo`tCdQfLNPpMSQOd@xtDMkHLKPS?UkpUL]YR;LpLhs`Yl?MyCHxSARX=XX`oRpnLdtDeUW`nETxoQK^pslqMW@sLmPvtoqXQU\\qQQlh\\tnlo?AjJMvhmp`YLqHNyuvp`oQ=tBPTFLwyhjKHWUDOIPwYUUsdWs=wsaNgum^dwO`PwMtpuKYXQSQqtAQCEY]pYEPOQhwq`RmMoHqPIUl@qpKTLTqVPhSDpRXiSgpmqHW@yTwTxO]mHiJ<DjHdUe@L`HV:qKxlSpqpKPKvqLaELNpPYAOgLkx=X[HYBaWTxVAEWMMlnHSm=y:eWn\\oPxR;Qv?=ND@kR@P?PQW=nmHLKdvWxpKAw\\lv`xo@qvO<PkPo@YK>ESEAL_<j^HLdqLLHxpPNgUoEQLA=QL`uQtnOYoqps[]r^hmqeQLayXplNhp\\`UcMsNQwk=MqqKCP^UHe@qbEi]Pon`oxc_tVhk\\v]\\hyJ>[Pn[RIsAxcR^Zs_m?hrx^grqkbni:iuqouhp_TwpH`jp_];>rYIvUoZg>ZLQvT>jJwvBNs=>wQic[y]sArYfk=_o]^arv]IAr^PZqYvq^novomI]d_e@V]ZopYnlipyfc?[Bx=Wt;qVxOLYNrPLeeQJxOxyMPuQhuT`LOtYpSymKts:=upmYpMtpDWcqVOUPQLubhjjLkB`Rg\\Ot@VQdR>MO_AQ;ynTaltMlGPXolUBQWPQNQAsHdX]LjDqwt@SQYSnLwWTpW`uplpt]nkDSeatkmtc]JiLk:eONeUThyVaPmqTntM<DRuQJ<=PFqlZlu<=y_yw:HYr<NxUV[aMYyTuuVEDvT\\Jb=JaINkyXwAn_ULriK<aqH]VjiUymQMXj_mRs@J>xOApV:\\N:\\r;QoG=X><Y^YKgpr=tQxxQZ\\rmDq:DNjIKEqrG`X`LlSxOBmJxysqAnF=NKDV^YJIYva=rfpyAxxwArympxuMlatoPOCMu^XNB<SLLLLplB@wEtSLLNLlv:\\m>`P>LwKlX\\DqDaP?>kT_cUG_vP[c@cIVmjV\\qnhM@mRn`Twk@wrCOlag^gvcLahGQ]Uisdyw?@^DhxPhaGGeuFhXx`]xcM@\\IFtx?[>V[E^bM^j@XZKIyrA^O?[XQas?f<HjYA_GXxu^ZcotJ@jB`gqacL@mJAxqA_\\Yfuqo=NrsVgF^x=@gcq]I@hZQiRIZWAaJn`FadDh`ynnSgdL`i]AZY_\\hX\\vg\\MPyD`^cWlHH^ZFcC?cVQfKnfhh\\_Om?ItI?rVgxRoyZWj?`laA^:Ilnwl=OeFaqbApf`ij^q`_u<plpGfgxf[nebi]qqdL>jsqbLF^@wcMfb@OeSq_W@u`iwPovHOg=qdhOenOyvicdHxJNx[>\\f^aRWskhfEq\\LHp:O`jiiop^jYw^PZc?xupiiqeuqwiYmIFbRqfmYnoxnVPuJGuRaZEn^BWuM>yV?m:Iqpo`gfjhoc@`ioO\\l@mKQ\\aIj@wenAeJ?y]o_Npp?Q\\IYv??]=V\\fFyvXxi^nIfmTXefNeiI[uA`;Pvv@y=Ii[NsE_l@YjEIaYW[upyvhjrahT@pLfxcotRguWHtbWmCNueoyqOyvhclp]CFyJ>[TyZEga\\IZmF^PQj:ou\\?bEOrTy[^Hrqge=Or>_rVipqfcrPw;?]s>fAfgbwb\\uB;e>EbFAH:=djuCB?cxmiNch=wdiGu@CW:svp]uiUYpUI]gVH=wCUf\\aFS=YFiU`AHuUY>oV^YRAcy;CwWwv:KtJoBp_i:mI<qse=Sl?dacDPQdTwfCKtoWwvmd]oex[SMuc@mrBUhUYWxOsWaslwGNaEewhvYimYI[gTmyTBub:=tX?UgIItUHZMc^WdA[YYktvmIRIHTuBucSAGFDIVuKCfASHSXdceF?rYUFH;GMSCyqVsER<]st=fx]w>oWpGRVeeJmSbubB_rcEftesa=w_MHGQsPKEGEIB?HcKE_SFKUcjUITYXqWbZ]ufEr?mXvgB<ox>Mtsoiuws[EFXKB;?fX;Ru=ByMCMmv_Erymi=Ax`gRN=EXqexiFGEtJcr;wC\\[VYcWVobHWbBcuoKWXWrjTqj\\tUDSeLO<xsvUmS\\pMQJi\\j[Hy]epWMrXTK>LPQijr=K>Lj`AJ<LyL@K<Hl^UPx\\kB]jWYSIaWLDPBTYpUqXpnXitheJDMXjtUL@STUkS`XBLUe<nNYYXUSahpGhoHEVg=uhxVKAKS]lsUOJ<K>dk:DnleJE@j:@mEtcTFlrN`l@t>XnOY[bWqCFeEHdZ?uWVwVqcAVch^by@mmQoWPwRQksv_<pq:?>chbuTGKbJ;dsMDZKdXwGl?E?OTK[E>Kb?iHi_VHYC>KB;?RB;SUCDKCDF[B<Cj:=NJ<K>dMF=RZipIXrvAXtPVuHKriwduXh<LB\\J<ZR__:vd:vfBOkRG[xwmwxxPW^unpqhf_gx=YZQVtmhZ<Fj:C>NjpGZrPrZq]EQ\\axkOAjFf[GFoWXfMniVFv<oaYq`TA\\M@\\B^Z<:NjPYZTwkSHuSOaEaZVFnqXaigcaom;NlB@j:vZfYpqP]WfwOw_w`ylPupXgQ`pr@bZ><D:[Gl=rfQCTwc;ou\\wY@sEs?S^MfG_gLSI[wxoyxeWbHKIBeTDiv:GwKaYYwh[;DB[:>^bw]>>sAfyGaZHfZiXm:`fWn>Wg_MVn[wuiCLKDOGi:=FJ<;>fqyZByjhhyBqbbGbLF\\J>uhglEq_SAbxhlDXc<?xJFxw@\\B^:<>TkU`YJ<SKEPahyjHyy]N`<NxmvHmnOdTkaPZDQA`YNeTUxMEINJ<K>L:<\\nP\\XFxZxoJ?enVsA^jo@^NHnMxi_PaA_b>NZ;\\BjZELm=L=@Y>HWyLTK<LwTNW@kB\\J<Dj:;?FH?YNiR:MrlkB[CDB[B<D:RrKU<=RTGxZE:B;@VkIRRXj:=NJZ;L<LNJJ;JBF:K:J<DRWAyyAJstJ`uRH_`iAZ:>Z:Fc?oc>oo<?f<<5:\"\{\}LSUlUk9PVEc2Jy0lKUJPVU5EU19YRzYjJCIjXSEiIi0lKUJPVU5EU19ZRzYjJCIiIUYqLSUtQk9VTkRTX1dJRFRIRzYjJCIlKyEpRiotJS5CT1VORFNfSEVJR0hURzYjJCIkIXlGKi0lKUNISUxEUkVORzYiCross Conduction in Modern Power MOSFETsAlan ElbanhawyPower industry consultant, email: aelbanhawy@igcorporation.comIntroductionThe synchronous buck converter is the DC-DC converter of choice in PC and notebook computers and has been so for many years. This topology provides ease of control and high power conversion efficiencies at a relatively low cost and within a small footprint. One of the keys to success in designing a synchronous buck converter is limiting the shoot-through or cross-conduction current. This phenomenon can cause excessive losses which leads to poor performance and results in low power conversion efficiency. Mathematical formulae will be derived that allow MOSFET and power supply designers to test the suitability of a specific device for its use as a synchronous rectifier in this converter. Choosing the Right MOSFETShoot-through may be explored by examining the factors that control the induced gate-source voltage when the drain voltage is switched between near ground and input voltage, Vcc, levels. This situation is encountered in the Synchronous Buck topology (Figure 1) during the time interval when the top or control MOSFET, MHS, is switched ON while the PWM controller holds OFF the lower MOSFET or synchronous rectifier MLS. If the induced voltage is larger than the Gate Threshold Voltage of the MOSFET, MLS could be turned ON while the top MOSFET is ON. Since an ON MOSFET has a very low on-resistance in the order of few milliohms to a few tens of milliohms, this condition will result in fairly excessive currents flowing through both devices, leading to excessive power dissipation in both MOSFETs and ultimately to failure in either one or both devices. By examining the mechanism causing this phenomenon, proper MOSFET selection can be made and cross conduction can be eliminated or reduced to negligible levels.Shoot-Through in the Synchronous Buck Converter A common synchronous buck converter is shown in Figure 1:MFNWtKUb<ob<R=MDLCdNNZjk:LV>T:`UJYkhBB`N\\@Nd\\QgmxHYJHmom`qQyymmsnQpuTuUpTuXOSMp^QNEiqqUTfUVFHokdvlEKJ@LMLSrijUXm>@XcHJFDNq\\tJLXk=KZ]KRqnSLJ>iKEqrOml_DUwhwDUqTqu`xsVpXYywUHMseW>HXKEuOxyI`YvTpmtVHImsTX`amaaqYyxxxmkIxIxYV\\jJLRBDN^EvJ<ybyRyLwmUPJLRBDN>`OFlQkIkI=M`tP=DN>@L<=s<Qj<tRBDN>@\\<vbBF^>@<KCVCF>\\:?:<KS=o><qC<KsLqrmoETnpyj[=rjtyriXOxwsMxytyseq@@L<=K?lkJLx\\EL;TpEhRRivl<n>\\sQqPA@Rj<kJ]QxyJYmvDay_QR;lqHMNQxLC`s?\\OEDn^MlUalJLRb<X>@l=QwiMP_qXgajYye[@c>nm]WrfYe<vnwXZ;GluVrjn[dfiHhg=iuwX]xAwBplqVnmX\\_qwX>e_P\\f@hRX]P@\\<??<s[ArMesYPNbejFmJIhYsyy<QMWdrCIkr\\q_TSKAyItMAXUQuxuuQHuUCYmBMMFTKwyXvaK_xMXakrUVmLwi=YYLTEql=iXW=UmAwmlKIxs\\yUhmqATLmDUWDNNMRdpQ=xvu=S@Urres_UokEvcurkuVZ\\jJLKVDNE\\JOaYdLPPPUoPMgtnfpr@XmhMRIUX]\\YKDqrqnG@Kqix;YK>lmPhV^`vAePYPq?QN`xxgilc=LcpxH]ph`Q;lqgUrI`R`isAYqeIvg=yqXUQAVmqw[=YXXjtqpX]jMdkb\\sHXNuDQ>tS`IukxW<lovmnEmSYmrwIjJLRXxNfIyF=sKExqDLrtr;Xws@WtTxf]tohp[@VR<p<HRNlmrMJHawf\\YQiYtYWvtKx`sMmMWDjslPD@R^LKipq;DvPpLNhWAlkFywuyRq]VvTukEx=xUihrAyqkYKfUMRdRfLL:]QTlRdHnKdkGiOb=WfMRllM?eUf\\k;Ipc]y=yTymkiiylILhAL>@L<EZBQr:gbY`d<Vb]Ise@\\fXo=OqfW^bOmbfgVuekDoUdbaUWSTGyf@?CXEXaqSRYEpLJ;\\t?MrBlnL=sOTxT=KIpPMIwvlqlUsiElCiLJdKA<LexW@MogxS>aPfXyrIU;@N<IktPsg=t<mqJmrQpWxxLqxuwpku\\J[\\jJ=vBDmyAU\\TWh@SQ]qwhMgxLW]k;Tu?muoAvFhkPMyDHO[TmUDTMeSbHwnlnYdY>UsWLR[\\NTYuJ=ON<TlhMRxJEMYrLj^Yk_]yfquGLNMhR>MNKdu^Mmb]w<=PVdQJmN?eYhTtDLNJLkbqQkEn:Hkf@SVyOiyu>PRCqvHERBDNNBmyDgsG;AFVus=ES>eWSixieRTQHkKThSrmeERYypQreSuOCc=eF]etB[BJwukgEuqWygDMQxtaVdcb@wTWUcSaX@ut;WCC?tSsRKMvxmXIqBvYwIowMICEcXgcub=wVmB_mWpEibKv`iTXYeVQg`GV=ahZsEHkScScr]HBgXUuBo_rKKJ<E:sg?ksLCFMeYTaWKKe:?cGGwuAejaUrEy<[wGYeo_ybQbw?TOQRv;Ypgc[wuvQCcQTS]bHARZWhEkYMUHfEYG]IPSRZ;XnQXLOspWcAuHI;fJ]G[kdBEFPutfgfGyxnEXuOW^CtJyc;uD[kxnyVjUs?;EXEE?Qd=wRqcx]?U`]DH?D<bFyV;WHG=elcVNETXut;=S>gWVIxKms`ETVuyr[Ce;fU_EOOyriT;Wex=x;eEOWgMwUh=hmWBxMHcWfrEdj=UiSwbEHrKIGoywYdBcb==C?Qwo]bgArbEDIUW@kR?]wNyvLWUI]vMqG`iXyEigSiA]XcID<=KbR`iHdwgROWnaxdYTREX?Ys[qdD?wq]U^wtgWRhIdAGvASbO?wU?CIat]wC]SHkCfUWSG?VRcwi?iLCf>MBk?WNCrJ=wboYHGfkIEFgS`=DDcbeCukgtF?UwygdCfTyu>MuVut@WwNgXLUbiKBaqdmAHGsE=YDc]SaWCVIGBCF>OZmYmj?aVG_jWeYwk_vowga<Q^]Wj\\FaMWuqX^qAtiAZEQtSynDOj`pwtX[SIl[guA`_joss>ouVxffqF`jB_eJ_biAgpyie^\\EA_NPsO@_ZP]WYcCNmaad`vts>tAncE^es@o_hsmXktIaovobFofVrPivJ?[[^JJfDLn@oBUUc@U>=pwhUI@oZPpDeqR]LShwUETdywAxn@ToQEsHDufpWxdXEiNntmkmN<esg<SaXtTmuN@QWdS;XS>QNtpuUPsHhTwQuN]lGYlCyoXQntLx>pkrHQ?=QlIMVeM;XL[UPFeuYlSwpQVLKlunZ\\jJLKVnvqNaUfdoviD@ynnoRGjxXxHij_vx=HnjN`Un`B@rgItWpyGWt<obOh]KOo]viAabvae_nhlf]Gav?P]Ggxk_nLH`rN^_gv<oZhheNIlpf_dO^nOasGnT`rZAsYqmWOjihZHYj_vmOgt>YgHgrKw\\aAeh`jJNb;X^^oqyAZ?OsN_ZGwx?X\\SHcfve;`f=WZDqmEPv>AaDImf^cOakT?s=qlCwv>>svpdfnjno`eXmRWg]akXfcPvhnNnuhq;fj<G]pG`avwof[AguPPhT?uZvmAw`[PkVPa_Fluvb>qsgVw`HvJ_^CPfSIrkWkUHtSQeIim<@<jyDnj=M[Ell`sfaOtmOt@MGtVWXkxQRKuQaAqppSJ=MsXwH]sVyxU=Y\\\\YgynXPkbQwMElQDjEhr]yRwHyNELGtJkqwQimiLLQaj\\EpBPVpmJ?`xrLkldLLYLtHqNeV`POcU`mPeladni_PPgAXg@GtUIu>xpYWhH`_a^rWNjJ:SPd`mBPwYlPWpS]ltRAkxxlyPJ]LxRmS>tnjpyC\\L@uRkxS^iOydPCTON\\RMImaErJePZaUqARL\\rv=vNhvE@XwilaXwuqo]QwFUtlmWTdvfapHmTbhx;XooDn@LNC\\jMdStLyPYtXAjMuTnUXa=N>@LDjYTnTykg<otIpC`p_YK?\\Os@v<<mKAOlloATYQqO^mXiqr:iqqAnJlkZlLCPNTyp>uRi`T^qSotmHyNXmYHQKRPWniJsuwjLjj\\oJpooqnTqYOpVdDjm\\OMDltqP>XlGAOOXslIuG]moMTItX@LRBDn:SRMDaWHCeR\\QsHWBEedVAx;GCKmekyrYSRyyXxgc\\axnogAsTyMxCAwt_wD;ylseDmYjoC\\;XheXlYgMIrjqeksu[Ofccd:YeiOIECvZ=Bd=D@suDGrDgf>Mu<OI;GrD[b?]uTIV>UEZQYOGhJuuweus=ixxVluRZ\\ZIYj:v`;F^mAvA@_lq\\I_^JO_O@fTGZnpxnQfjgyM>]Ey\\K^yOyi;I\\sIgF_^Kyx@xa;x]GPrfn\\owyqPm:IoleWGs:idQYVpmB@Ef:SSOCBhMW@GUYucZ]fl;YvEIYwb]SxsQG;KFMotK[IOUbHcCG?COUyMiiRKF[AFXyYwifreu_yf\\UthGVvEyuui;qi[_gXKHFEg\\gwUMFdGVn[F]?Yoira?vowTVOchotN_gQAvH=RBCFN\\jf\\ON`UcHLOLps`mH`ogdqbQVf]YZIJFxj=AWLDoTTL[TSneO<Uwcun[`VUQYvatjPMvpUXXTKHql@kUhqy=KSxWxUJsisIMNwxVIPojYkpYShTRWiKiYjs`VCpwmtlYiqEDqiyYIlu`iSBuWTajVXwZXwWtw<UrApyTlpBiURmUmQVKMP`PPLetNYuX`rwxKgxrThQ@lVDdVnpP>Ix@YXHYretOtdMAixnHxExN>@lQLYfhv`<N^mYB\\mDPrcDOmiVtlyDYoj@YcQLFdsHQVQmQA`XptjrIxe<LB]N[Uk:IobQmDpqc@qOXn@QTgtlklyJYRr]yAtpZeu`hsRAmd]rMlkAhwYiyH\\m[hYt=Ohttk=PoUxqEpwqnyyjGUUqPVmUUultTDJfAujHJJETstql\\wOIn<ePSpxoeP]ioQem?pmpqRFaVE<Uw]y\\\\qmQqmaRXQUsinMLRBYk:HLrLR`IKD=sNmTcPOaLtPYuEXwx`xO\\Kiuu`tqLALFunFpqmxs;XN\\qPolP@pxhpOwtqeLPapNI]Ni=xuuyC`SlpKadYryWJIYCiNb\\kGXVyiWyLjMlk<YLCYP^myKpyx]wTHm?QxeyeagqiYZbnkFP^mXgA^wcH_w^kQP\\rXbOhtd`eJqhV_vEhfrPoRFpfvppyhbNvdQypWx_VjP@\\<[Jx\\f>hKAc>w[eh`Mhs<aeVYj`pxH>yXxouqnOVr[^cI_cBxs?`xvg\\COoF^\\yFyrYvRH\\sVexQpQ?fcYwYAkcaePneaw^thbLa[OHvdNZoVqgW]@yZtIpraymIpfiwiAbHgkfAtLak^WiUpktIuHXjZxwYnpIynVgo^AybVax>wg_jJNb;DskFJEtbcD;WS`SdRqi]uB@mR@=HxkIhWeFeTPOw\\gRE?tUYuEov`oFwyhPeGOCuLCxeyysySkSGqyTYmXs[GKciAwws]RECUUUYuKiTQuJ_WhmrNqfGKiY_ulwHxICDChRkYqoVGoUiUivsi^EsL[tEQi]ubcYXcSVm[xUixouewKRBCNjGa``^Hg^k>_cPdCg[DotVvtOIu\\hkGhkb?c_`p^IwfGdYyt_AbNWt^of\\_]?fxTQqtfe\\_neXpMffsgmTojdyda@xGV\\`P]I`tkA\\H^Zn@\\dhv@ab`attVbA@qb>hgprWIrJiigq[[WhgF^>@DKRBITMwhTEUJcFeEc>MBGMFjehxEWd]iNeFiMGSIRIWGTEH[cIywDEWfnSH=OrXgub]ivQCg;XD]w\\QFamROmdvATRkiDQUg[vJ?giwRYuSIoDr?WowwWIvTSToIeEaIFggn_bJKxLGbS=g>_s=EdMMROscAIdDefH[So?SSywOswoaY^sTV?Bi_T@mXgYV:EiFoDK;ipCefGwc;FWGtmgB?mBmOhVax@iCjoVa=tPiuGotPqHgSX@Wv:KW\\[bJKhZ;V>kcJGypeTOeG`Wg>ewSgVwkePcsLef;]IIkWs_bOwtWubwySh]r]wisiClywxuBLccG?ebkdnMV=IuYcyRKbggGbeUsMBFqw?AiiIbA;VyivG;Wgiw=mFwSBmEwl[EyqcqMrDgrsGxCCF>OBA=CsEhvSUMoftmsOCcUseWgRuuSikswGviCXuQyoAY^qgu?VroGlEbZkSr_yD[btKIjcIwSbR]GDgDiEYUkF^myAwthgbsutW?GEwEXoxPwh\\adNMChWwVKtlKF>?D<=_<om;Plgf\\_Xd]ynhquwX]giqw@i]yhiorxx^PIrmhgnh]yPZwxfVHjvo_I`xna\\@xb@hh;@vOwdyP[UpwxX[uy`h_beQx_?wwfyFge^ytPGcJ^wZpbBF^NJ^AxKUSt=TCqKuunaHlCunkPXSQPVhqlenH=XbtLE@mR@m:mU^aSOqkm]RHqpiauCpmHqSfPLKXUwesehXK<vkIsC]KEaTYat>ikD=K[\\Lr>l=qy=n[>^h<Xjdy`qxiyqifxulhZHP]SHb^gc_^a>WfkfeEncCoeLon[Hn[^gU>]:GiAq[rOovFcj>oA?fbwwbAbBowy@u;awCF^><yE[oTX]R?MvNaHlKID_UhsfEgv@Mr[]tQyt]oS`OuBiC@?CTav^aF`uVaEvrkcPoH_;boOyl]bJKRbb];FjMGdmf@mVJUFr;gB_eTCi;ECVOii_fFECXOiiOyFIgb[ed[wUatRACQiXI[cyOUUwbJKRBc:]B_kSC?eLCI_sWDmtNYVoGgpseTwRqcgHIEroySWxKKRBCf:ID<mcJ_rOqfTeyrOUs;damd?Ceu[rOyETwbJK:?\\NFqaW\\lN[UF^>`]U>pGajJB<=C[RB<K[\\<[bJKZ<:[j:_jJxf;g^H?uhxoannJ?\\<?[?nkJNp:?hW?rmaiJAVLR;R`IHfCU<=C[j?lNiUXEtJuQxIYxweUbG^>@\\DJ<=K[\\:D^[BNB[[Z?:=K;RBIFAyemCD<=C[R`IIdsyNyHg;Y;AFvARJgV?=C[[vJ;DZqFZ[bVkHsUDSUXG?BHYcFWfq_iWcWpUH\\or\\;Y\\gXPsHICF>@rK^sy^cMajSvk]arGwx]GyQvg>?goQg>wovvbH`a;?]fhZA?[[^<^y<gbYa_EQb^^]@O_JNjeAiB>i:_dxqfnikJNbbJBaQ?aL;XKDiWn\\Ld`yW\\K\\<NMHJHDp?=K[\\<FkL_`OfgE@eOAmU@cUHgkny@?[[:PKVPMAdTWQm`YtXTN>@Ll=[VXwtOiZHgl_wX`c=n\\evrJXnnxyOoh<oG?D<mC_?rGccGQviqivYDFms^ADB;hCWvRUrmaIROXlaYqYwhXoi\\QCXM>`MSMWK<QoEjBYk>MRBDQnMJqYjYao?QuGYYK<TwYTrElv]Sj=ve]opTVGaVD<UyhWJPJAmkvDyvevp<Mf`S>@L<mKG@rGdkGAw`Ytb]NbtLBaq<mQ``PhPxYVb;>efOb_vb=HuSQsg_aH^b]`uX^jJNhb`ZHgxGP_PPsr@vnilrgsensAGpRovPIeZ?yXxZIYh[wlEQxWo\\kV`sn_aisc^\\lG]f_]BQfloJWd]_RgGCOex;WVy;I<=Cs[X<sfjeIYCcr]DEMiUIde[drgXP;EdweUWwRAGQOSbkDlACuiB>[iVKhxmE;Sd=CcMKRBCnCEjmLoL<TdTk><s>mLZ@rspKDqX_MpWtKHXweEPa`qKLRBDNAqKfAL?=K[\\:?Z[^jJBD><KZ<:[j:C>\\ZNJ>@L<SZJ>@TZC<=[D^=NB:<?FqMW]:quaAnh_jJNb;LPlJ_PT_qPJ<l]pKITQ>@L<E:mvyStMidUaVL;C@Ciw;C[d:CeqatT?Teuh>?D<=?BNB[[J>P:F>[<<[bZ<?;D:mcKKspWb;Ivc[s`MxVAE>?D<EZl@\\Ri`jnjQyujidVaheiyVA]>@\\<GJ^ZDfbUVmq_wAAwrOmUVjJNbbJBQR:QpF\\r\\HV>LJv\\WJLRBd:@NBivEAs^QkbMS_Dqk<K[\\:Bfur?gWu;c@GIPGG[[bJJ>lj[=wcijwplUykJLRbj]pjyQVXevt`u:`jJLXB<KjULJLRXXKdLkPLK?<xIyuviLhuyoYVjiQKPpaEkfHoaXjPhjhpqH]qceyZllEix\\UX^lk>tP_DN>@DtsWhPIpWAyYwQyk]mmmsD\\qtQkOysI=vdXTk@U@mPU]jeYyIQMHXT<yvrpMp]KfXrPArl\\XXXqNtYsQwyDr?ayT<K[\\:DYhauuAtp\\Y`yMxYLiuyeytwtW;XTC]KsQRCtmtYwQQvWxWv@KhPKkhQEHrcpylmkvpVfMPG`SCijS<KZxp]HjYMJ[\\jJ[IFvJ`y^Ylkx\\NHcT?_PHv`YsR_uSajr__vuQiHNyrsGvCCF^AD=aF@KRBYX<yxesym;eLMSBlkt\\k:IL<mma@ssYxliYsmoEtnNMQJUp>Ek`HWT@p<EnaaqFTqR]jiIYOhVbDUOxtATr[mt;EN>@D\\vJUvTqPDIwnpqOixdat=pl_TdFaiXFnr_]`?xIv`UV_kYhDfZrP^;pjfVbCVmPft:?Zx`aPNk?A_k_jJN;LRHdLD]pfElfTYEqLRyqtXJBtRZQQh\\s@pJ>TQt<VW=Ykpls@kBAu;aNFEKThO<tvHqs\\`ymxM=YmR@t\\yZE@bMW\\vYoiHjSiqRFjZvbZ@^>@dZm?ljgUq:aShPXutkjaMA]qFarfARyLtyIyg]rdQwjXQQXR<]ngxPOPRnXnMlucyVbAwVIrTXTWPXSlqBhUxIvA@PsivyErfxv[<NlxtcLrpDO\\utlPWoLRWiQVIJBnvO^c\\?^>`aansxfhCnirYryhrswfVv`iouMPwGxnThagFqqf^\\ip_`g]vmFO^ootSAufIyrO`WprFytx`[uWx`?i\\FixIbXwwUp^DVuqXfIicyqkKGe@xtSijf__@HfsgyF`aaAos_eAn[AGlZ^jJ[Agbroe>OZ<wbeO[i?ioIubQge?mQwmAYoDhlaVdTIhKoj;plmps;WrCx^[WIAVlUwP;YuqBZyB=cd>cbamiXIhkkxMYuk;icUDlOxRUweoUGShgWBMer\\_GmOHxYgaSxsocmsWM;IBC>XVR`Xp@XFikAMUMPOOYqGQt=yQRApTLMKatMYj<hwZ`lHUNyuuiEvFeS;YY@YWO`yOtr@ATVAq;lleANXPS[DqtaT>Tnk<mdTKomst\\T>lk<tRBDn:IL<mkrdnLhUghvp]sRYuManDeuQeYWQnGeSbqYsilb=Wb=R>mQfEWqqWRYJwQQLpvOuvQupdqUcUyp]sH`k\\lNminPtx;QTwmvDinahOUyY@QYBD>Nh>AaPXkjqt@nxLGdpvpR_bjGt\\^phFeDH]=ab[wxH?uuwZnOp<NoGAodFy;gfapsh_u:HsWWaZirM>gvgveFlbYe<vb>ns=YtAN[uofmY_[^jJ[^ibU^mIvtqaxRfod`_BWxDilbWq`QefId<v`wVZq`geQl[N_eatMF]mOxs?ilve[@dJypHwhINwi@is^iKx`Qg`SpdanrWA[[^<FaVoy`VleYbEyliN^aO]@N]Pgo<acj^jSGiHqwYYZiVlKQx`QobOm_GnZvkGwaxp\\h`sMvc`>\\gWg=xvt>xdXskWo<vrLnq>d<JM@rsetCuuqeQnpOUmkJ=O>HWsYqnArTdmBAvEhmsdr<pmcMw[xJK=UypMH`sM<TSmnOaJIHqGIp>@L<E:mDnSWXcuHwgyUyh[CFcSHYsqyv;yIJ_eZ?H>=sTKeU?hIYxj[igUElwXYiTSkFEedUCeXOrbiYqIfbOhPUR[]fHYIIuD>kTikt_URdWs<SdQ;C[[<QR`YuqoI:WEXyxo[gUaHjswXYeH?ecoYeMS]ayDMt;GEC?VKIeaMwBMuZmHEGxiuYEcrWSuZeB==EtirW;uquwWAeOGeeQIuChriSimb]QIT=udKFbIrkiIpIb][bJBESe:=r<Kr;euy_wSAxH?XNQSwWEyOU\\[RouWMIHrCiYghg]hfoIGCBMQtiiiNWs\\siwUEF?SRSVquuCsfN=RBmUJqylyT:yc@EdIyvomfhwUUmCgicJKR;<KS=wbuWm`S>MNy=YZuxi\\YmyTr@woum@yxymxJILyuYtLxptviIuFmJcXlQEnoexc@P?AslUPm<svLyBLtUxP]TPlLJQAPK<lIattmvS=K^LLALWwHYmmnamW:dUMlSPhxAPsD`QUYXtEuhXoE=mbXUPpN[\\jJ=FWNJ`Yg<XoEkbywwtpy]W@tYuIyUEx[yKvYOX<ycYjrMVmqu]lM;QtwqtjaT`AoL`nZeUWLUtQyjdlGQrmdS^yXiQrXyWveKMXR=PQ\\uLxDx^]rtmL=YT=huUpv;DLfhLwixaQsU@kQEUPXTPupdMs_qK^lQbEQMxrVDllPpT`vstWhYXhxnAiTgTQh\\WSxsPxqEmmIPXo`qCDN>`QYLJVaJiDnMxollX=hW<]vJQx:YVu<XMyxyUkAqtiqrtim=AyNyVYIjppp@\\qlQnMpkbAkILq:xoBDldDLLEk^HkVhj<=K?YvREx`ypZeyiqYAHxKIV>mR@HPoxWYeVfUt\\EKWxvXxj>Ql]APxlP@`nFYo\\PVtpmVpw=txnEjMeP^Qxuyx]Ty]XUJ<K@@LuUrU@Vn]XZ<MGPwsqVqGjkywyw\\CGiWOxWvw<xuXqkJ`aaAkVnl^ihsXux_ZuwyJnn_g]kVt:WfrNj:irQ@ry@v\\_j\\Gt]OqJQ`[^j<baichIF^Kx@[dfuESQbGstW=EGuHxevvGcj=rvKy=yIOuu:GxVOg<GytmYOywdmI?GigEdH;EPYcXmcD?r_UX?]YfYcykrqwWwwEMSYAAhnavx[uvifqAvtyTYgYNsxQcTvuPGum;@VJTpMYtbQQmaOnxmpMM@lWwILTmr@IPeLR_tUH\\WQiRflMMIljPjBIUwMPcxRd=oNIjepRVTo@tvQUWAIqSaKpmutYRSqJC\\OupvTynoTpPxN`<x^yximRDmlumvoyWeplmDX[uVl@mwIvg<MvQyQHpu`V]DtJAJB@R@xn`Dpv@T:ujB\\MeisKLRb<X^yxI]WlMxcXS`<pc]s>yRyxpxIWGUQmQywUwPTQ=dWc@K<PNkUx[XTsYXKDSyPWXxWbEOZEXBmpoHY>hPhHqS<K?pKFTM_HlqAtpDpYDOatN\\@x<qP^HTWmsHpyK]YtYoytrGyykuNJDK[ayelT]yoXIyD\\OS]uDxrplxQUl:\\Y>Mr;\\P`PLOtmOELapr^LV[Xrq=uKiyPqvnYjmdvwpsdHlP\\v<hnH]veTNLalKxSKlLkXONTkB]XilRlevC@mV`mJQpamtT@TYHpVHqQ\\LPHW[TMGXNRTkeqNQQUlajTlnEAlo=Q\\DjdHmNuUkDKH`yPQxUqp\\usy]YETplpw]qQrINnaUuQMNdRftJyEyE<ultqdlMfPmKeYKPSD]M[f:KXLEgRabdoIiEe;]VEqBpsCFQBE[grKr`gic]sUGRGoe=YuJeYg_CSqwQsutIDfkuqGRxwBMsR^[bbyT\\sY@uTQ;DHsIwccLmuMYIAmfJATHAVqkunQrH;EdSCo?U@Yixqv`[SFcS:cXk;U\\[VuoxHWv@wcvyfBEdw=FK;RGOVJSDsWwbeScexEsR=Ay>yew_CQeUsmt[MybqYoYvtiDuQTiyT>OsLCGdkdEAh>muDMFCEEsiGNYsaAGPOSbAwbARfEykAepgW^KVkOWfOiLCsMyyvyfx?XoYELQFXeyTccd=sFegQiTQ[RPgfaiTKKUmOWtQIUsTPYHkAy]=ePWuN=GBgvQoU@SiogCcor`[hy=yi=TT?eJiYaaTMygSeyxAC[[b<sxLsRW_VdKDaIsCmr@gVr?S>YbOWdKCIFOvVEWlixGcTJktNyvvUxBebIcttMyuyYyoB@_ySAGYYylEY]uOOtPw`RKXnb]NB@W=MJ?HmVpLoHlwYTBpN]@SB`n_iRjapiLstMK?PPpxwXDLcYO[\\Qolkn=VR<QaEOJAtn=kq]X=eX:XtGQqSaYxAj^eJ>muN]VgTmEQnwaumALuirW<MR`m>uV^\\KU]ngHvNhtjaT^dshTNLDkV<UVENUXR@mU]MokUT?msden?MWL@oLdNVUTNeSXUVB@OumnOEOgPnhYvcPPdLQ]dTXuUDqVKpl_eP>LnjLXsDx:UKuujpQNSdkZHpkHL_EmAOm_^jJN[VFaR_d`ofdO\\aQe=@iuYsHWrFOaYgoOhhNquNYdOQxQNt``iHo_[?rl`_w^jMWsov`[vmF?^PfkPW^nvbQxcxYxIHxIyerh]iWrEViinpgU\\KbuoWxyURseFAviqijUEhYUmafhmIvet_SgjyiXYXOkSRmt?OVSqYTqrlyiviFRwEwgBkIbced@GYByIQOdf_T=MCgsFh?RxWf=CxOsFbEXLeS\\Gc^MDS_S@cIi_iLsDnyw;qtyqyGKSlwtoixoIVOYyXycL=r<]tD?Ff_Bh_TLyuY]T>qWNeiiaTDCrtQYWCFmyvBkddyVaavlAXqew<wIuSCYmhE=RXuwEQxwEDoshTcRmaEQkcVywrOv_pv`xW[mV`mJwturQMdqowpKEpOr@L`MpHdJoQYKtq^`wYLWW\\S^=N>@TZAsVeoJyvMAX:AREeYNDJ=yQdPJaPoVytH=kEDNjAVV<YYqy;`KAyVO<QMQL[<K\\<uLaJkTkDuYnHY:MQSPR@AKy@wihQLlK\\aqMyk=iMyyw=<yvyPxejI]Y`yJrItgtx[uhC^yfyuy>jHgufOaA@mt^tb`r;VvJyxA^l_IoLh]WvfXhjqfulYbRGjZNdghobF_KP\\cNkD@e_hbZadixsEwavy`rFwGygOI\\cqrHq_WagcpeUV\\CW`OwyoFyhglniqdyMmrNAtJKdGiSBcbu]uw?P:<L:`N\\@NdtRKHls]ob]x:`repqdEu[HRfaybyu;yp<LYalT=AXsevL\\qFMMHPSL=ohAQ_QVKDpXpUVhyxyK\\IryMy<lYqusw<Qceut\\PE`t?qyvqJ>yLqAw:Ln[PmWIOi]jJL[LWaSAwxFadancoZ>O_\\AoMFnjgsjIlyw_m_cgpt>Xwi>n`Wn=fbXwyBYiQw^[g`c@[V_bHow;ft>vdeyao_lCNw^ilQvuvogUil^>m>__<xkw?xT_^\\IfvYtqnyEVgiYiLv\\Vwxc^yoYih`rYpqkUEoeXqThwC]IWd[YBcvT]remT^egNws];EGGwT[WwQFYEbj=EGcsGQiScT_]cHowYyckGhkCiY_tiWwY[E>EgNMR^ogHcc\\[YdCF[?fLoE`ofZQslQr\\[W]SdMMIMeHOat>?uVCiLMFYWdUiU]Sfj]IYuHYOgEKf:OU@?cV]XHqg[OWxGylqEQei_igb=WiurWsevAIpoxqYvFyEVQbMsXgQRlyGXYcRiVQwT^;t^EWHMRBcBH?fTyETAgVIHFSCKCI;ifLecjSbKYfd;TxIbBmt<QdqGi<sxfYuwOtFOEPCcJMBksU\\SGpOsH_I>YuWeYpwCyIuO?Y_iFaSv@ygwQByOieICv]xmuh\\ESIUGXEaYnxIan>Y_ZNpv>mHWfB_nFgIUcBCUqQv?yBpwYVetqUdsqBAwbKWDcMTCuBkEdtctyag_Cev;xWcjgPWxaMPDkUTMWdt<etUytaXmQeT<]jKeLodtymoxETqllxxvi<v`TwZ=k^HmlqMDTjuApxYWYet?EjomrdpO_TL:qYKtrb`QY@QaaUVEySYMkpT^iWbIpA=VvDpHdwYHyNLQ_uxbMYOipv<VKLRb<X^pVXdlbxjHPKCIsb\\LDTrB\\jJ`SlY_b^fhykChcgOmi^cGav:vruoko`wXhgYPywocXoqBvusyqyok;HnC_gTqa>XxHWahA[V?nN_bsF_lnpR_jgpoxpeywaoO^_ghoghtN[TW\\cgxvO_OPb;glOF\\CYdCW[kF\\uPiSxsfp`YOosQeTOeJfk@GtfvpdIx`Flvf^:Pyd?cqijMF\\padCy[EVch^qBVd;@^pxgYqktf^=hsGA[da[^QeQFZ=F\\Sondx_qN^LvpggwT_hphp[QoyGylnZxhiMnisIxIHnuWs`_jiye=pneooOQfcgs=pqL`jJN[VFmqn\\Qg[?id_Or^WdGFi;>wBneSqiPGkgIwdOtMIl:GcQPuQXj;AnPX`WFgMxx`PnXGrdgeqPmVHoaalZHaHg^CPbCPlT`tvhpYYjtYeCYmtggL_nEwb_avxPmAwkjAdG@rcQbyPwyOpwNpsQZpw[F>nK_rjH^XVoHPvZy]bNbgPmJY]?__UfvwipD@vwFpkW^pq[HF^dPcC`tQIfP_rh`dgqdcPlk^dY_apaj]^jJC<XR@IWadx\\]wdXPKtk?xvGYYTXOkMSnPWS`m`am^@J]PuNHo>dSGyPqQN`mw?asVElMEtutqT`t:Pw_<lYekbuT@ASg`tyUS^LLREXvIxB=k^HVv]T>Dtghl[XonDqDaQ=xQwIPTlLqAnoaxMIXcw_QYsRixmym:imT`j_NnRnwgYt=ahc`vD@^qW`<S;<Ks\\lvxxgulEaXSaqEqlvmOGetoHYxAUnIyZusY<krLMdxK^Xk\\mQItT>tSWyk?QVtHYPelKDpauV_EJPLKsHuD@SThl<lsyXy\\yQ[DQpLk_toyUNTuOv@K?iYuEPrUuI@lYhs[er_xl]hw_uO=mQUHR>ml?=K[\\LrLRBINPdndhrv`RKEtn@TlDkHYShdjiLr_AoKlNNmleeUWpl=QXmUPTqOy`McIjxeUtlRGLViPknqmrIrIDNu<qITyptW@qny]y^\\QSxpuQpe<XoyyvYTndmkmLJulLYN==wxpX>@L<C<=s[WhQQhBmTbct:WsxqyY;TDivZkr?OhdCI\\KTaQgF]TsgIqiyY[tCMD;CYhSeCAFM]G\\erUwu<?dBoufAwbKh]YVtCc^GgqwCPMFHgEUuh\\_hq=BEmdhctwyuBCF>OjJLPi]vaEvy]J=DUK<q<@SSpMpTsnDPpDP;`T]UNTitbeKd=wjttOypd`nBAwfaOfdtFQwuAunavM@KQUL^LTgiMtEYulxfqrJqywQqfESiuWipYHHs?]jJLKVDN^GnVoiD_vP>oFI_cWd]QoHGk:iwQFxLObQItKIjB@kQgoVHkLhpgYZ=>_PVkR_pbG\\T_bfadLarNav^b=WbBaVm?CASG]EDeoykesGisbQWgeRU_So_gSMRBCf:FmY^nMilUab<>e:h]oYgCN\\dDa_fEEsPOYFedhCeUCIMECGcwgeWtSIoGf[GRyig^egO]BGeVoovlEIwKy=OYgOwqsf`IT_QSNmFeSwyGD<=Gj]JmYKQioXDX<dlcEJLUo_tn>]SOTyghl`DoGPvZXKDToL@N[Ax;PUnEjdyVOMvQqN\\und=tcAwUexoPWSMSxqvMAWW\\jJL;@M]`TpHTphU>QNd]j=xvKauQUlMdTHXV;dK[pxF]lfEO;Uo?=v`qliDTLqn^lSCQuVQUnepQitdQsOQSL`tD`KQqv_\\jJxvo]Q\\qNZ\\jvtTxpyWYYjewyAy<lMSwxEOxmysgh^qvpJ?xVyv`qayvxsPu]gpK>^H^\\BnnvH\\<?_jk[avChsuAXIyOYdrjAufYStUQvTmneQUET[IyrlQhDN>P:lrCpR<@RlljZ=jWlwCDN>P:_GB[XyiGEaRWMHDic;=C[[DrV[aAo[?^LnvJXw>@\\<GJlLHlJJ@k?xmYYSRavD=K[tjNllKDN^iN>poZEnEEUv@relQM]wGqXkUuipM=qjgUjALS\\]y[hXSMPyUXuULHMMXPbhoi<?[[@RtsYtrkEJQIt]dJv@n=ljTdOZ@W]yyVAYe@MTYXjhRK<qRUT=lQyLyRlWb@MZtq>LRBD>lmItLWhYvLxsxT\\Qjmtly@nQYw:Xm[=noXnKDdZp]uYxIFfByaQYxjVlm?dfFuVAy>@<Bi[bqai_QDwciJ]EOCiEgbjicIuiWsfY_t]sYuuYR=v>]xfur=quC_CtuWVgBx]x^QbXcb;?D<=oBn\\^NgVvconlcQoOfubqwfOiHwoSotUQ[VvtKGy=PZA?[[B;gEL=C[ssISvsyCyavUqGqWE[[bVKRRCb][bvsWvmRLAsvcro]ErYXL_Xf?R:kb?QHp[b<sRBCF>_sE]w<EBH_StOUHOCOSyXoW`MCQyt=aCjaXA=Gj]JiDTnuMrtr_uTpLPyqxGut?XVUAOgqu?Ty;yJJ<SaHLr@yL=yelT<qOPDLH]NrHlBdJH@LlQt>Qpf<M;AJXxVQ<Q<mKy@rslK<DlBlxfMu>hmYhyA]oNXyKHr;]PwmyE@xwtkU<kJ=vBbhsymixQ;vvWtQGfoGGCic;mvGKgImfdGIbMs?kbisy`gEUSHX=CgOFoehaid>IEf[FG=Gj]ZD`mmOwLgaKN`i`ZHfl`iiMapnGZcWtjP_lp^MP[PVo<XttpZov`OFa@@v_A[[^jJhZhcigBHUWTaepiYymsmawrGSb;X>\\jJHy^yWbpNRassYuYXNjmqaYjtqRb<X>^JmiDaeDorOUFlmei_fHAfvGDD[E[[bv?FRohDmcZkeRSeegRHWu<?TZAKBYKaPmG<o?mkltRHTNtHQOEsUPq_qvZ\\LrLB?C`uVeshkAIJ[ClUYJWr<GTO;IOcYm]IOacdyTlsSses:=Gj]J^iJZUuOXuJ=kK<Ql=mKEtqDLrDmVmxxUNN<A>oCW]EGaJXrhxgyxm?PcBfZHdJKR`Yh:Iyo_SNuSqib][b<sJ<Op:>h[Pw<id]>hfGpa^\\rNbBF^^oi]`nGI\\uWhvw[hxsv^d<Gj]B>?d?CFjehLKFIUg=sr^IEl]c;IrfIC[[bVSDbeRMUBQYcsGidgCOahZeR]gdLQFpgCioFkMXeYIhKB;ABFABIUb>OBA=[l_dchbZAfR?xlHe^ypfojM?_NOa?idkaeInf\\FjthfEA_j_j<vBLR`YJtDk[lL=EXwQQfXYgipyxxvawnaLtlujqNVpxOxoeIPMeSMhqC@K?l;^hj^[RP^^WfSa]@acEF[MAiT_vGGnxQk_O`bG_Uit`qdOatDGj]^\\rNBLX^eqGdlkySO`k?Lvk]XpixdqNLuySTxb\\TyAqBxv\\\\p\\eJvur;xo^xSXUWjDs;@TZC<XNEPloHsCHKnqUvEKx<y:YRjdlJhMFMs>mtNAUcpqcMnVXs[<LEHX]ILD\\=LXNmS`Ej:\\WKTp[Hwc]nMIWNPS_<YhXUsMXH@scpyhEtb]LCDLqpr`qVNyNL\\ururt`ueHls\\tr]slxMbhQ;Apf<MIInSauMELTQwbmMd_sZ?l<vbBJHdLdHym\\LDDN[LPpDQodjwUr=As`Upj]v>\\yF]l:iPn\\PZhn_hJoQPS]wyqXfUsUxv[`lCArQDW=PmNxk_Yxlut<=OXty=hx;dlvhl^mQbDWMuoctlnqqMLS`tvGUXudJH@\\JhZIPaspb\\F\\nxpoH^^v^WQhs`[qp\\;Xi@`wc@[V__PVbVo^oQapyiunpkhb`iywWi[?kJHo`XhexnAnidHZ;Gluf\\GXywWwmIdPHiWiquGvH`[eGxm^fyPpTOeoayT_yb>h>@\\<?sEXbC>mHpk>Pbbxoixt<pnDYjryiZ?`ug\\wGdM?aVnv@YapisXfncH_FfitY\\BhasH\\kFlvAVWwKsYiYyn_sW[SWiT\\UScMX<SvqkY@CfuyYESHLcbkyViIR=YiYYHioITcBH?\\AArsOuNQr``^h>xAOkmqt\\ngFpqWVub`SeHKOY`Gb[St<aceIvnAb?swpYuJ;IqaI>wUkeFFwV^=FeITu[RxYs=cyRIyJYbbwC?=DKgy^osD;wkwRwQwnsEpQEpkyMKRBCI`;TaPOlpLFlJYhXLMjapNP<xwlr?lSoyYEyvK`wT]j_xtyhJb]W>ak]IrilLJHyGyoKMMUTtSDsIUYGPMleoVmRS]Vi@TdLNgtxmMxtqlQuUEtnR]RsmS\\UJ?l;[bJ@T]Ln_PLS]TkqvNIkaLNPuTIHmLEK[AS>dnGTw[iSIeTTPuaQKVPmYmNo\\yT=uD<gJFlj?];afWNhOGj=fZH@\\<SBCIFMb]OeOivpmV`mBGWSQGf]QhEIH[sCNcRDaeCISrohWEECWf`YYOIsGyvkCXqiUtixXGV:qGUAX?]ufeHiOG?MHIMeWIGj]bJBpPLL\\RNaUu`kbQp]IlClJKhpWdyrxUb<redln@sGinnlQHtXQqSgTX[Us>Mx>XLKxTLtntAUDYwc<X>@L<=[HvlZAm`psnn`<FZ^Wxs_xVXihNjk@]px\\D@hDi^Np]YW[I_rFyoPY[NgscPo^?sZy[y?jci_UX_xydQwkPypwy[^_b:ftlP^mA_mGm<vbBJBIPC=ROXkC`RJ=pgQsb\\KxxkKDqYmLkUOiMYLunMptt]pcQnyXlM@OgIuGHk<EJp`sQaXKiNB\\pnPw<xsDmuFYjOik]@rKLRHhTFtnTaR[QuVAM>@l]tNsLNXEPOuLJeNn\\J<<UnmrSLURqjfQP`xMs]J?hkU\\tr\\WOHxkeT;tukIX^qxIDWsLT<tlLev@MTcdOjErJ=WXelWHn:IL<odNIrl_okX\\uXeuA`PPwb``M?\\<?sKRoGBOAuaoh_Ef[EykAbV=THWYxKCs_GfIbxeGjMGmaToseHqIlAH@]vk?CF[HniG;]fawRIGgeoRsACFYfbYukcFjmyVGcJKHy;TloVrqExWX@YwkyTiMyVkiumtUCTd[ddsiSueyoT<=s[yROayEor\\=h?MvtsGs_CCqsh[cQ_W^wV`GHwusWAhAqrdSv`QskCW`=XYKCMWdj]r`KEisi<cXekT\\SHmSf?kSOAE^]BhATW_mIel]EP`aSxewslwq`jVdqEPOsIXdHpbdulELM=K\\]NTPr^=N<PpeAwYEOe<vMLRHtPdAQ]`JHeK[hVDIPcdN<mXTYwYAJu@lAHLEXVdyXe=PuuwWil[Au>]MN]lHlpGTWkQVnmUweKDPXytUdDw`YtsqNjUKl=OgtodmVKTsA]QZINdtp[@p?TT_hJePwCqpA`mgMNaQmJXqlAyExMpQRAuxdMpb]sIHVn<KSxxyhTIYjWmO=LNgENO=PMmK@pXgpxLHr[]kBDNAmJ_tUd`JB=ON\\RUIqaYnwfoByf`?\\JFlmX`S>mlaex_fRFmwVinayCqkH^`V@i\\nZqyWmDeaYemIW=d<sf^iGZMBGETYceCEdm?VRkbf=Ui=WJ;GOCVNyfJOWDEW;QeCQuRSs<CUair?KEWQwtSr;URE]USigFGh@YTICFIIRZatJaHOIx@cIIibgob\\GTGUgPSiZQD<mCySXA?UEyVm?chKU>_REUHLYV=ASCYvx_SD=t@qhfEr^YBe=BOyuGmcKMobPOeaTotqHyrkUXQ\\l:IOsUKTmJPdtU<WnmVKMYbUJViwUiXa\\Rq=Yy<TNDjeXo==nwhM[hvAYnxayEDlfeW=AXTIrBENBTtrEVGPoGDNQds[uo\\<XlyXHqPjLlqdR^aKjFjJxaFP\\ovroO_CX[@P\\tv]XXeWNq@yfmN_[^vBAn?^c^_gd_iVfuwhqbYi_ilr?heq\\nnlEQa;IbWVlLYqpGrXpm<x]B>^^nwJHs_avvvw\\pcOQlu^sAQ_o_oNGsLnqhGcnghEPnON[WV]<vn^i_fOyR_eiY^jAxiG`vy]YQrnAvZnxF`kZOfn_\\kptP^tAY\\thwtwu>aZPFkBimrPh?NaxVh]Nmtwl[onfInbNr_odyXZYyo_faRvZxyoaHaYIltoeOakcQgH@rtXwQ>swgwe@pTV]KPieYuZamsgZ@vnwfayY`]A[opar?mu`gpVqLxl\\@rcYZMgv<Isbpa<av?NnBi\\f?alxgRPhJoc>OZAhv>FmHyloIpXgo]F_eAaVvdVIy\\XjlXvcAv<_^fGwlW\\^oi[XyqHo\\pq\\^bdNupVawfkOvouWZhQyXyhkxiYqenoy\\yfBxmlP]wyhxQ]mP`iWdmW[tnoxpZS`iXFtr_]KAgnApE^mMO_[@`xnZvFx>^ohp_RvrgVbJ_nh>]C`_vGjMxu@NqTPjBfgv?]uygva_lVbuAp]Vl=G_SwjhXwYakHYkhnb\\XPwFpcurAw];ExWxyGhmeyt]tiMu>?SiIXBKcviDVUv:mfd=SxqTg;IKSsMiS^OG:=TpaCNgY]Ig^=COaXd=s@[C@;HpkICGcoUwJSSOYfkahMADssyO;cTmCVEeMIgxoRyECxOUp;dB;cbMeXoDsCygUstgSwoEEl[^i^DGup?p_wwfRuuVjGhymRH=dpodXgdE_v<WiqGBEYidAtR_cv?go=g>IeoUi`?x^_GyeyhIWWuue[En?h<mtkOXkeIPmXQYf[iRhWRkWY^ccGMhHwRqWssGFWMRw]IBow`AEtMuL;IoEW]KIUOvvQraIe>IU;?bX_tJQUc_R<cXlmWIUePkr?MeDwypygRSujGD`GV[GfiwDkideCHgAIb=c?aXL[riiwaMge=So=ChcXKMW?SbtMeuEdZOFcmWo]dActNSWPud]OSP?gbUepUEo[HQOc:KseqVqgW=AtAwI>ocQiiXcGyUyK;I\\YHdiyTGb:QrO;I_kIGIFAcSoEHFmCF;Vlurp]S?YdbuijQFfSYuYIJiXcifjavE=eR?eNgcNhnQpU@HlQaUAhYYiyI=MWhmtTx>yx^URD@n?Pj`\\vqijr`YleNoEp:PUx@SRXo@<q?LpliYFpVeLt_PmVUQ^yPRDKA<VATRRLl_up>LRBEm;]P@aO>XMG\\LguM=MPyESAuxF\\PAaYnlRN@rC@sSMpfEUHPS^@sCyXrlUj<PM]xo`rKYvBDNidNVDQBqYuqsW=q]Il;]vEmO<HJmPXhXl]Yy@iQMAxhYM:iva`p]iyQqo>]OL\\Y[EtjPlGXuY<M:yxiiwQITk@ldaqVeUAQywTTlEth=vNpq@\\Ybipa<nodLuErYhvpXyuIx]yJqQVrMoZhvJeYHtYFLUVdttuToqnjquemTZEUQeQy@ysaLBLT]HO>UnbDoKmLDhRRPpImkD`SoUsqmluIyIAvdHTU\\VaEoUEX<\\sj]J;EYhAV?YYEinL\\m<ETQ@SlYo;tM_\\X``sePN`MOTyn^doVhsdqyyPOT\\nXTK_TltqYkTlsMwwDoFqTK\\P_DjdDl\\umBUmyLQDpXoUOEYO`XtBTkfmMfHQomuE\\mTAQD]pTPn\\eoMYTRhwYYjcEuVeVSALa]qyyoJaYhIqrxy;xjkuu]TwKXTU\\Tp\\xDinw<qjaum<tqquILoHUXRps^IlcLUBdj<<WG\\LJIlEUnfTsgdwVIjChuuXOUlXCQL^llhdRVeXb]K_DPN]K]DMnATI`QVHKkdwV`YKLogMUxIY?QJjDQH@S[tO<=M@aWZpK?ut>UWFYRULPjPt?\\vXDYRTp]XVjPuUILMDkfmwfuRrLTItPV`tAtOpmm]\\jv`TRAuydjUutF<VgqsCeulHLI`JniRlPqi=wP@LMumbqMRQPHHuvEMiHQqEPPEkbeR=ysG]vNuuDyjqpk[yNIdw?qt;akx>i`Qa\\P^mOw^Fyr@cPynhGuBxtXxtGXkHOgQyryyvDAvro\\ynyWAZxgyrApV_xuAc@WjANej_t\\_vnWn?pgAAh@vmrHi=n_YguHxdYhuGprt@[qOjsObN_ZevmEIrPFeTohCinRyxGyi=anVXsU`b\\pnlFenOssQqii`QI^Nvk]^lIYs?pbZIguAkgPy?icF?rWIpWFmyqyoP[sQrJH_sgte@fg@eC^tOY^VweaxxaQx:AZDw[fHj_VsDvexgZvabLwb^amkH`NxwwX]PWgUNja_mCVp[HZ_Fh@Pxiww?Nb[_\\qgw<axqpyWnjrocralOAp^OdlwxFGlVxx<vnT@^MG^IFkBHkCYiPAfrqliYrIvjk`yvXxZ_hqAvUxush]mHq\\Natv\\cA`apowf^MiyIpg>giwgaVV^^NbPvbMWdEndnHk;qaxA_X@yJyZkxpNobP__r@npnlvGg[@l?X[uPQkHoCfkYvYoRsWy^[BvUTQCyUIysys]]FMob_SEmmRXysNyXyWB]YyYYRW_isoeqki;Cvy?yu]H?cYn_vAEHpycY_r^Qya;h]MTh_rTOeogbq?sn?SpWy\\yhwgCEqWrAB@uVw[wIYUfmS_[bVShrit^tKgEM;yLy]qO]rFqRReRWaS=uVlyn\\hlP<L_DUMirDurOdXC`y>qwc]Wbym;IQAyP]yMXaYDeXcmrmpoaYYqaw>isqaxeIu<PN=PoIYmgIMb]kt=KTXXPIvU<k?XJRIPNHraqYnHMUyJMAyMyTfTYPQLKdpIIp_uwNlQsUsM@mDuln]xjLLldxaASBIW_DMpIVEiySQl[xtO<lqAPSHOcASZQuWTlrYuq\\mBpsP`NqMk]`ktqMOAjnIPO]tQ]ouanq`qOTQhyU=HMstqa]o:LtjDX<itiPRdAyO<mKDYEmNLLue\\teaTLHjD`qOpxgirHxQuuLlTR=@OiDUD`vcyV[MnyUM<tYoqYf@Wd]RWymYAJmySXaK=]jeTqauLxuxCxk[hn]XLaLki`JTUuo=x`MvkipRAysxs\\HNTDrctutqP\\PvXTUX`YLtSVqYU\\SAqRC]JiuyWtXZ<NqySXhm?Qxmtsx<LcYURMJaLlNllYql_IQRdujHLMEuVLw\\DN^`rBuRMQVKAK[QoEtT[alOdqjQOyppdMj<xkvmqBHoS`MpiVvdy=pkBQXLirlltgEuDTx>YljPwGut]lprxJSIsC\\KgXYVTUyux:llHpk[lmGAnsLodPlr<p_YKVpUn@KcInwAWRHm<xOpqQWAu>PlLtQkPx?eME@TQ\\xJ`xE@MsqrQApiqouHP_lPXiy`ypZXydXoKmmTPrwuUxQLpuWRukEyYlYLnqUtEQTpThPr^Et@hO<@SAXN>`MUxNE=vkhW]@ydiMUAlc<QBPs?MpLXmJ`Qx]UEXkOewHLw=ill`SUyNf\\oYDpJxXFdM;QOChKcpQlUWp\\K]QrOeMIqnC@q]Iv;\\ynIn;eYFxT\\enPInd]jh@Wp=X<UoexwepyGYuadOfeMq@PU]TeAPo]JgyvI`KdQw<tWs`Xc`mbho=Pk\\PQsuwXyQ=xowQVuln?muNYyMiYUhVdIWjAXd`YHdttQTJxxx\\lkDpMmt]pWO@SdhRhuuYHryty^UKx\\xTilbAW\\`rWdWNUl_PMOEV`MYTdKWYkkesQuyODmkIPwAqdmJgUUt`SqppGunMAwc]Wv<LwUTwItvDLrPvFaPpexiIj_>vlx_wgZGV_I?r^qu;^uxqoqOnnwyicxcyK]FXAYwOwbqfwiNPHUNDLmaVlhVLeUt`Tyyp<`uIxLdDuapWk`j_ttwpK;`TwlPv]x]<WXeXllTw=yiEjj]JK@XBdvvmK;eTDavSdY[qL>uMrdO^wZMXupP^]v]pHdoXdivaXVnSwZevlifrkiwG@swyti^rrPstPgips<fdc?qgfgR_ptg`dQwf^wR`xJO_SApdYwkPwiqa<pMYWngVeoIKCbB]DMsSh]rgwtwOE@EgBowKIT>cV]qVmGYnkgtcCQOsQ[iqqtYKVUyvxSFQuW[[GyereCtvqvqOgi]D`]gHmtOmR>YhkKh`eC@ivoESkOxOyHvwD;EhhEiP[RfgfOsXvwvWAUyWWQKEiQiMcxlWb^OF;[c`IeNARBCIpCwYCS]YEyOuCGhSOH\\OXOkgtYBiKgi?CIuXwwf_KS_AweCtuSG\\QsmmGXSuY[rXGWMCDK_F_cYYmDcMcDIhlac_igAcUAYRUmRkiuuMyK=gpIgMeYKWILkEhKwgSf]CUC_bOQFQcsksDwEGISEAaGfUej_xkwuOWDfiWI[w=USW]BQeew?yZWwR?eCIvYyYwWTqcs@itaAd?kH>aYwIIP_Ht?S@gSr=hZ_tfgGcIVSUdAwrA_GvKHN;RBmsjOSVutE_cdgVv=wowF[ky<SyqId=LKaPw;Io^Aj;IlK\\pC@kohOUmnU`QOMn;atNaLppwVIkr@q<pSX=TKyPO<MLexedrelJxmymeqIemtqwqAV`LM=qluqw=Ixadm>hNEul\\Isumw@QXOqUiQQtTrTuXuPo`<ObhvbPmRPSt`ydYvXhTsmOW=sE@n?EtNYtexOHLRkaNTMYuexb@LSaUH]JJIRZANSYyEtnH\\mlpTsAx@evatKeDlNXOs@QdQn[=Y\\uneyQpyYnUqnxox@mb]R>UOflvTlRqyqveJ[XLHmLiXO\\usBmJweuw@UwqqI<rNTJYqpuuOLdxC]J]hV>YlC]R=HJ^UxhpoDamjdQFeVD@MmXkrtxFhLR@WhMlelPQukQpLLhvATUUAPuDPC`Yx`kJXOA\\MEqrnPWetLEuwsPwd]JtTq^Qog]KCDyLMqiLqBtrWEYOlrxxxW\\nAlJJATFYNL<oe`kfAR;XN>`M]]lDqKhEqquKpqk_aRXQJtDlEeR]lSiaXjPn?msimjVTR=EVWdxJuNAUqVMrLATKmSXmK@ln=PU>alZis`eWvuxhiQtTXnlOAQyapSAdl`esuttG@wF<TOyLGmTC@p_IVOUm=hnGQXl]P<=K?XNOpvidtYDSPIpr<U@UVFmOpXP@lRmpnVTxG]L_isWqx:qUf@wHEVCuvMYlH\\TZ<vaxKhir]Yq`HLEdT^\\TodlXhuOmrCiwlaqKlR:mQAeouqktDRqLstlSeQXjlNaQlwTTPplr@X:QrTimMAsOLSN<qs=NjMwuQkAYvbylmIxHhQu=PklQHPnTlOEmMi]WhmRquXqLwdQwdDK@<oPpJmQOWLOalMx=oLaKUqtDhpUyXZ=WZxMWdUE@tJit?@jrHjdMmg`wvlmhEKNMriqTEqlcakNQUYMYyIoLPSsEx@@naQwhtThxwciXcHYqykGHkA`Vj`YsQx=Po<aqP<QgeqtyU?=vlXPO`ljeLbqXa?w<Wixxotok@FfD``Gws`hpOqchOiL>usXbH>[;_`qyx]npvabw`okah;VkdQvB^^L>_DqbY_`xx]HYru`hROp^VsHXsvN_;OrpN_Sfn`hfZWsHHdV@qfXcp^oBYmTwoDFrDYhUxhF>vhxZQYkJnhPpl?Hp:>ZZ>ZCSJctrOwvYdkkyjQIFAstYddoVEqgW?sVQXmKenExLUB]MhVAuxIFsIFU=SIsCeIv>?DjKgY_c@sRB\\O[IVmArNlMRQPk=nsHp[Lv]eTAxj_doK]N^AMVLk>eXy\\nT@rOLK?DmlAUP\\s[iVlEtvpXBArnErNQLqXXrTkoYqaDXXIKgitb=ktLWDQQpaS[uxbmTiXRCLVQPkhiXt=QcXPF`RlpSaUM@QoO\\xOIKKeo]@Uf<NfTws@YcEJIpwmAPNpofXny]QIXqQyKeQLZtSO]uqiv\\xYPtqt]Y^AR^tOT\\xkmt\\tKEQu_YXNyrJ<KEioB@jD@wbhXN`TYDOSPnKaOXmW^EpPmtkHYVAtGiodLuquvtHVVeYPQNNyN\\\\QpyM?]txundUqgllmyptqydQweixBDPdIx@qj@\\pqxp]DmFmMbmQOYVtTo^eJbpjqDljEma\\tNak@UT>tsW]Nh@VdaKNuujDTJeoyMuS]QwxotPSPAnEHLdIlW\\kdER[QpvDUlYOlxndYtSMvRdVO=yVEKVLOSXo;DuiPl\\LlD=MIllfUPyYpJUoc<qdXRZeuCobhWwPf]X`_foiLfswv^\\wnvAxTWvK_muIsIWs@GoVgZghqkYpr_gAqh^akD?iLwdrnlYvs\\qpt_^J?rjytyPkSXihQb[_fRV^UypQOyHIseWx\\nhdH[PYorQnxQ`UN]U`vp>^AF^SApOIno^ekfv^OpXfuExl\\ho_peA@sqikHVrnXs\\?vK_gwywYAfEycx_ynxuaH_A^on`qAHgAqaJwfHW]wHgkyt>?[sn`jY_=wnwqvkiyOQqQpjhHqsGwLv[a`hA@lBgp\\paOPtw?l\\ftlW[dAmg`nAG[Pawfa_HY[HHnoFd>ycpFyBilGfifidKNpMx\\QY^XvkbqqhWYaGxpkgAuatryeT`Io[Lv[ivEaYfDWMDWEmPCIXuHTitqpMveho]@UfLNQhs[LLVdRuMNeTwjApydoLLLf\\ypIsK]UrMVmlkY]ubXkIUYXXjuuPF@NQMXo@rcPpLuVoUqr@VC`mEPMUHTYuuj=vm=O;XXehOndvlEMS`S@mScTvbUoEQNlhu;YRuQOK`mUpwVYnqHtUxOylSAtMrLLCItC@rcHO^LtNqtPqj`qv`eywHomIXgLQaXmRuvF\\UiIwKdVV]J_uUlPuTIviMYLdvCIKVtXhiJb\\pn@nkHq?TN]TNjUK?QSSAL_LYDMy>iLlPpfalTTJtMVVuTs@TTlTJHYmQxr]pTive\\MH@staM^hvopkYekHIs]iK\\tWGLWvqToxMY\\VYEUJdSbpkeLJ`LPPdlGhWC`qOhV]@Q]XNbuS@<PnTV\\IpWUvRipauovAQmAQsEUipwf<UkqqDqjNUM]\\WsAwbMk]@phUNptYxYpR@s_IlMhkXiYwYUKtwT]jlat^lrhUyKpW]qoGHtZMstTNOYOrPulaXr\\Tx`sj`ybUT\\tXCDlAUpPLVOMnctJB@x?xL[\\Y\\ISO@SUeWaHlclOY=UeQp_AP_EmhEUXXxgXJGEJ>@Ll@xIqk:qtwMOE`XPumj]xCISHQPweO;]J\\dXtLmJ@lEdVoMjfhVqitHMoo@WVEoN]RiUpIXttPsrxWIHn?hWIAWXtKiuMAiLaxOLXwquLIdWUtrXHpvpOOLlQXRcQvNHjxptjLjKQiTP`qg]An_\\htCydW@b_qpbVwbagnAtP`_[?f@>k?fcFhsPHhyqnk^_cwc\\>]j@`jNm@QmGY\\OXkggdta^>bt_v^MEGMwE;YOCfKUwBkTEYIbgVegxOqtc_RHeDEwIhgFEwBqQytCf;eYPwBqoS\\QdMWuJIuDQEkuRUcxWetxwhTIiroHdUrVYxlOIqWgBcet?Fb=IyQRfaYZqYF]uviEnaevMCdYiQSw>ab<arRogo=WCydXMhWCiJGXZyB==H]GTRMhi;uuyxEiBFMC_Gxk]SvAyp[r>YV<kRrOTyisf_CcadT]tG?TZ[bv_seOsOgruUyZavlMY:OBeAF]KHFYY;WhnuByCyjIgRkdYExl[Wyquq=dUoeNiXPQYeQvrCgiKbAyhNCxrqx;[cGwc\\WhggD;CHeuCIEUfOdhcUrutHYVEiiqAnLEM[poh\\myyqyLj_tTYeoeDNaQyuIPjYvUiXrYpp\\KPeolUXgxK?pWqpTlpVd`PoEyLYrk<u`=J?Tu?HNLmnDUxoPs@pUtMyS<wxYpqAW;Xmu\\WJpus\\vp=WlmLuQt?=UKmy:HK[trP]JhyXUmNjdloHLDLMtxUTUU<ytGaTCaV<uxuLTaDrT@SOATL\\xNUTaMTH=kHLq?=pVhUXLNPHjfEtOhvD@yV`tD`UCIrwuSHxTHXsb`Kq=UQdpn`p?XfIWeAauM@hgavfp^Waa@vZWhxpNj=okVVxGg]_WijWsNnexPqWfuWF[v>^lq`hNdQ>loylwf^s?bW_a`xeextOgeAgw^yeUwbgYhcFjMGduprtV]GFtVnnDnlhfalXe^_xkimMO^jghZW`dItI`rOavxow]yZI^^sPqOxoqQlEGhiyrynjbysxoj@Xxh^blapMA`kpfGNyyWiY^st`Zdqcwf[S`g@FiOoj>_ZfpqiG[pwalA[dyijii>hv<nf\\Ws`_cCYh_@d>F`KX`OQbbPj?Ogao[cpd:qpp^cg_uBHwYfyJnlBfmSQt<`tswvY^`RY`iiZHGmcPykq[Gxs\\Aq]ykAWyowOArGwe?why=ECWEysb`WCi[rSuFXOc?eGk]DNiTOUXwkhFsCeqy@KINCcD]vfKftaeOKxRYyjYFBKslsDYsXVKyh?i\\OFbMx_Ig[QhNYvscTeiRi=tD_rc_GLeXYexwWGb?GVEi^Wd_KiTKvREFIyBOmyK_EnOuPeg@GDGGFUoS]mVGiYbAYgYwKKWiutcurOii\\OX:Oh?mRgehH?B\\mF==w>?l:xpOuShTWqxSZqmGTvtLx^pRxHWGXYr@xr@PTMmT<lfxScqQcEr=`L^doW`SOUX^PoYIolLSuXK:uW=aKpqsNMLTltqys\\yLI`wMDQn=pe]NihjEeNO\\ofUxkmRY]KkQy@Elq`nhYuntPtxxFiXbXvjPUAPs<eQgxo>HlSaPPiwqixYYyaMkriv]URrTXSUJxUph]oLdYKXvvURNYr?yr?Dtftm=eRrattLRmMO]ysG`Nd\\tmepH=xwlkAXsPhljYogPNapX_xwmysXduIXTQhP[Xo_pmg@PmaR`qmo<l^psWQXuLQsDjtpj@\\msyXyukChKeIxRiwqPVlYkY=RwUR]llvhvg=WTEqLdS\\TUMYpmPyVxUJhyZamqyYJTUYLYJTqhiqQTPYUydllXeXolSyasG@usYwYUNmhXm\\yR]Ua\\QbpVVApvqQhLy>ynjpS`YUmisyUt?MjQ]qmiUbmqnQXgLY@YPdiL@lvuqROYRN=s;@vCiqM@wbUW:QkEtO:iqqdp\\eSyqU>yqkiXFay\\yvbMqbQVnqqdiTjQpS]VPaw?XNUTSCxmD`nsQQm]nLawcPQSLmdHqneuT=mwYYJXYnIL^tOr@LX`WfInyQy_LsS`O\\MVRip@]dkAdmqpvAr^ixMgfUVkO@=oX=AUqAH\\UipMFr_xr;eacgd_Xd]deKhoOGMgRPWibesiETyEu_id?CsQwwFwc[uuywyUKeYeXGKii;iRcb[aIloGy]h^ifnMdAoICMgCuen?iCmckCbmiX<IrjaSScCC?FfxkMqLS@Uk@OH`VWeqH`kW\\SfpvXtweEu;PSlPYTQsrTpuTjK`pexK]Hq\\XjutmRlrrmTomKi`lYDk@\\YV=qn<jXpxDUp`eoyLumho]pTA\\SKqtRxrsdY?\\wR@pKhOuQqiYuMTq`@PMHO\\=Yt@k^]P:Pl=\\mVqW\\apXAqBEmtaMCdObuspMtQYJaXssARGYnH]cqankhivvjGVrxpoIvtyndJiZ;XqT_a@GvP>Zt_p`FyxvbAqrjf_h>h;yeVAjLOaGHu[H^NfrYNlgigbOwcYbKYhk>qiw]\\PgbY_W>pkHpni`ihbYPo<G^x@f>NjbOwUOnEvbqpmjO^DFyvp]kIrq_g^_vxonVobqIaaQnsGykAcEQqNWwZ_qcH[_`iHFnbgnupt<Pk:I_<HrJ@cOhjuy]WakEocyV\\iOyNynyyauww;vfSIdYHkxghHisstwStMWfl_H]?c>_F:MDRmFr;BP;Vj=Y`igQquAqw\\UYwYYiiGHIXGgwaixx[ESUxFQYqEhw?b?;cZ;Rc=dJ=RTcc`]fCIYtwVtsbUyHYYTiOgHMOaauXpmcqMkTNHErOauxxx^XY<etQuuyyyyqQvUxIpyBtOF`m@ALuDUsxYvaMltkvLNvqSsmyUaTehksmPoTN_IWJDTdpWZmW[pKTpS;`oXejWYtmLjoUpxUyqDptqi]_y?y\\k_wOyd[ooSW[l_wBhmEqvfYmAPfaIeAIrw@sT^[Viw_gmLhxlYsRfybyy@pdoPk[yxwx]?Hvg>sk>fvgsAna:xvyFxe?uWGo\\Vyuwq=`uYayONf=XoJagp^j_wt<It]>q]qouHdjf];AsbotOfpY^n;omyVs`F\\s@bnNaWvg:qrtGg<gbBIlEHwlw_qikw_eDY^gnZyhr:Ymv>dtGc^IknnpFn^j>idPkMVdVYeT@v^VZ;_rFOk;>leaggxw@ndoGhCO\\UH\\MYr`Xkgyb^yo_Vdby__@hOAbEvsV@fAqs@?chA]k_vVgbbwtkQwPowRFpo?^;`fTqyWVk;^bS>_txq?XZs`hdfkeydOIhnOpcNhpAqAWguhu\\Qa_>vtP[KVZqGym^hV^xqghoGvFVZgWqpgiAVgRnlbn[HN^w^aFp^=neuxeSYjMWn]@eypiwndkxsrWmR@m:qmwv_]`db>[w>eH>rHf]Ry_DNgtWytarwar]XiSwvXxa@AxFIoMynkpggQe[qs:YxBWwV`j\\?bjni_nv:I[tQlw^lvodpovna^pi]xfkUwavYlb>pMvxoyariiv`pqw_FHyc^vawv>Ic`awSvdxn_kXlmHw[x[ZxvPXeJgfa>vnafSfq_`_hQf:Xw^qoW?uAAbUatxiyBq]r>Z<AbYvf@qtWwi]nqxIkyA_d@oFNfIAxraciOglo\\UwwsxZqwinyvjityhyU_apvaIHZpAZpQpHVfUqnG@mXxo\\avvG]uvi\\YZrA\\eIqXXy<yvkiqQwx;@xJowEyoBPcMPg]pknArZNv=WbZhsp^gu^tBob^Ngy>aW>nUxdDYxw>cnwuyHnRy`[XpPggBfwFouqOhQXjXa_;QwXV]VGwOgiaifu>qc>aUwoi`l@AhcHjMWtgnpIV[gpfEFh]F^tqfxnogowIHnJXc]Fmt@pw?q?V\\Vw^h@lEAfEwiWv_VPgBnlr`s`^wOpl[>m\\QiEPfZvcjppaFiK?^Kx_Eyt[QpcV]tYoBgrU?eb?uMyLAwvkgXUU<]GKCGK[UC[CVsiy?Ybie]Yb=WHm;YtibQ[BEqr;MY=gY@iVemBtYyKYtMYvk[ivsTl]xfIUVkumwRjChvqg[irJ[I\\;erkQtXquHXgipQQnbAp<iN@<LImmvDkalmsmR^qX`=MhIU?AjVtt;XKeuT@<j]uNCxsZMK?qOfYQxLkrDW]UvGUQjqsImyk<wraJ@uKW<rclJ@AvNdOFtWRAk[XmhMr:TYkaMCXNalrklPYQrxXn]@qheWylQnIoy`rKiUIMVt]X>TnAqk]eyGtP\\UuwyKZEVfaMXaxeyq@HrUuW=UnKaXNHmClsF]s]tMIAvpyYuywKYqgQOFMP>lQoLXTttViYilTw<x:lNAUsr\\YtMJUyTqUvpxYoYxRaxPyp[AxMtk[]vJINKItjHYaljSiJbYq[qN^mPgmr^atVLWGmX=]N\\DRAAowHj;UMrHpqTwVaRBatLDKhaULLRjTLkAwXyY]eUeUK]XtO\\qpMWX]v`HpEqkoiuh<qDeOS\\xr@VYqJxDX;LmplxP=puaXMdlTUmwuVrDlETqb`outm:mm;<pEDJPMPBXveIXjyPJMoZ=PAAj\\aKIhxRQQX]MFIXYdtoiQ`LSsakALL=axrpsq<xmIrWXmbXLLEjePXjQtkIMVYYwAJDHXXXSa]RqDt_muriX^IQV`Up]jEmrjyYs`UFtOvHvZlkmXX_PTC]qVmpSxLv`oSlMPdRv\\YSEV><r;dqmuqlaUDmKlaujpQYqNyxVreppeV[EJcmpylqWqSfxwODJZAYrXlMytwYJ=@mZuq[IwQqS]Itaqx\\pUU=rGttfUrZiWimrouWtxRBHwoHM\\UQnLQ@XvmdPFhyMytJMwX<RxXoI]vh\\meTPZhpeiLnav]=MrpwP\\LiHW[xmgUyVEqDxov`XJlTepkXhMqEvOmxFhOfqQH`MUuOW`S]HjflXw`Y>dsDa`Sqi]Nyq_USbtIspCr^Itk]Tf_FtMytIxOwVpIVv]W>gIbGCVaXmiURIypwhEGRf]WtmCMcx`ksNaSNyUvkb\\uTiKh?qeBoHIOuUcepUreur@Exfqe];Ijwy>KEmcXv?yl]CYWV=cvUmWsOCeyTqIFS?c?uvcQSa=vRAB@YRBUYIwS]AtsOcbyttWH@kWUad?MFWWwR]Tj?E:WXm=slCuVkhGstJGuQErVEicuvOGE`?k@YroHunmjG<jsEPrIsOejEEuAtWveqtmNAhx=hKf]wiHvBAUODoRXn]ir`aMwHQ<XUplVK`VEAq<YrQLtiUsseYoPUWdnFaK`LsppuRIjKPKXEQxdjupoEaRqDt_\\WOPUMTpmiLudj]lV\\xoetXKaOVtJX]ytMxuqjmDXV<lshRb\\M^EqYYqZtmitPn\\P>pqxpQk`qgDM\\=YldNhpMWXOaMr;yMA\\XveMxhWqumQ]oJxoyARUPNX]uOYtelnpqRvDktIQp<Qv`pYqTBmpEqRgIYSTYrHq_lRQuw:LTs^fsP_qVmwFmfW]Vgwuww[Y^roql?cB`wkaytnyshe<qu@ImCiZnwxpYfZ?hRhgmn^lg_rhwPoqNYjMYhm?iDhwipubXpIYf\\XvbiwYNrdi`eIl^Wyihde@sPY]RXmWHrQymXigIapvPtoWj[FwX^[fpfUikSAwuNgKWi]pp@Wp?xbpgw?ymwYr]?mcvt>osIBKTl:ye<aZxVyBYkrwwwWajIpInue>]pAoWGuGXeagmT@o:ihKNvsoksacL?_Fyr\\w\\x^sr@^hFlZ?^hflNn\\Dpl_ynV@xqhnN>dFqrKVkY?auqnlfiCFlYfmBH\\knlZngtWfC_kWVb[VmnQhrq_p_yDhr\\As^XlRAt]O`J@gAPtdh[E?a:_ucgp]X]bQ\\nHxcQ`XFidw_XGalNj]wna^b>g_UpcZqpew`ZqngYrrhvTix\\NbjG`qa[Anf\\qqK`FsDRGsGidEIvZqcI]VV=haSsHAsLmFh;vquhgqYQICi[UkStYuD>IXZkt=ABPseSgdDeU<[HkIuYUudEyyKc;WgrSI;Cy<SRmgb\\?TskvI;DyCCweY=OBjgtdUCbEhHub=siRWF@AsUsY:WtS_gb?WL[h_?Bq]CSsXoUcDqt?OXiKwoOeGogSawIww]CvZWvXqy;CRsmTdSCb_dscUTahE?T?iRIGCuud\\EgU]gQcCTETuUfpGgsOCxYsyAYVsUtMVIgG\\gEmMrXmhPefj_deotU?yYwUyEB_QWWsytiYimRiEGQcerWGnGxj?IA[wauVdqsZaF@WFKyg@qGZsGg[ckAvlqSvUE\\[BISew?vWOGAKcWEE@kgLIH[cB_]U^uYdqCR_TNedTYdrMVrCvwMw=wgr]Wsui=wgEIrfAVKwb<awmatfUUrSIWuhMQC^GBwKWEyWi[wuCbyoyayfjavEuR>gtT]G`AblmXXwXiyIGARsMCqmunGCyGxmywN;fhQVhYEqscLmyfWtlwDDaCuWuPGrXiDG;vvYd@Ygt]CkyW\\ke>Ud;_FegulmVamw=SVisdZAGSWG[ScAssJ;fCWbakWuEtdmd>YrdQwmGx_ir?kVwSbCyERmE]oc?iIcSDHKBEcrhEBhAIjSDasGPsDm[Ru[IZ=cVCC=gWA=B:mBVcgpgvVshMIEkgVMGsnSuhGG<QrKUcTYEgGXQadYIyeyg\\YeIiwQcT=GSxaY^ShBeVEOv;=hTiSNyD`EuUQgBuXryfAuU>AuNaExCxKyBKyuWwcH=vO?urEB=SBjUvmoimaCiWvaiYbsBxkr?MwWMshqB@[W_=BKWBASU]Yh>ABVsVZAYYWYk?rAiBQ]T>?hFCdaGWRkcD=BaAvbCXVqD\\uDwYI^=HTYUB=C`KupsRAkFaQE<giFgrc]fD=h\\SdCKs`kci?vMueuMB]Wvm[wxASBWy=AXfmHsiiT?cqGtbehjitWUyJ=s_?xEuExwCS_T\\QfpyXcCBqogg;Y?YBrCx]=IGEGvixFCBZ?Y<CfbcUZOsisDICcZusBOGQIraUXSSFaIIe;c?IyyauJ[g?eYecCcIb_Yhv_DUmFK_S:iuWWCFaCAysnkFtSGM=bt_TtSGtSBICrsosHkVNMHXchqkWuqtmWykAyEsBK_VM_dFmiB_WQAFLCw<WdTAr_mYTMFQehpssX?c@eDcKDAYvIyE<ARqqGvyrIoyJ]X<sg>]y@qgeIucQG`SsGugp?iJoFpGRq]sVmDukruiu>SwmWyRuXtKI]=CGeSXyXAaCDoy<GG@kUXyvhsfIeh;[U<cuSUTrgGJMVtSv<;rwsvgQwPivk_YvuE`GEAEdgAfisVZawvcD\\urMWxG[eX?gZUYxsCTCWeaGugY_IsQ=xAwYqiXNMgoUu>kIWwbS?S[CdDQC<qfWag]OIyCCMgyEygCyDxghUStmgDvQsIuI:GfXQrOsxuugBaC\\Mv:OHHAgSwDkow?aIBoGuyXx_toWswshGAcjWVNqGKUYgAwS]YlyyuqFU;cTAsPKyJ]ETAs:QUL]Cjqx^mrCyBo;um]DI=fOug:?UGEDXAyHYsAEhyAus[WYAHJceBYGC[ikuhUkHCoIkkh:oREOIKOXDgHW]ILMdJCwfsDE[YVae\\_RvkbOiFMSYA]yjIWxCr:[UH?C`eVsSd\\uWv;VZ;Xj?VZ?dl;hZExwUT[Ubo[daOfJqVs;RNYuISB]_IYocyqdmShfqiaeekaS_gr:yWGguqId^_tlUucWhM=yUysyuR:wHhkhV]ERAbnmiU]RbAYY[rwmsUIh>?wYOEEShj?ufKdYYUY]YfuCh]upoBYCYQiWK;bEOu_YuLESMSYHwS]YTI_ENKYDmUa[wneEv_Fy?dHWCTKYSABUMwZIy:cIJ=vCas@QhaEetqhsuvt;uOOX<kEEaupOt;OT[uvmOtfEGyiykCF`UShky:gIdeUs[UkIbRqwqIWZ;ytYtuAXhMXP]TKevtmTmGHKgXPOThMgt=hvGUF[rOGufCiBWd]WtrqxmyB\\;BqeBpke=iTemhO_UW_TVAD[CSl_sSSfE;hLIC=YxxcfHaRnkWZEUZOSXqIIcslYVPcYN_vJWdJSyjsdgWUbqv;ExxQGU_vsiSGEhGqDqqYgMusiYKgfPQxTyIyKyLkcI_S\\SdHEFYyh@CsfEDgqT=YEe;gmmc?uFfqCR[CFidlIWvCy\\IFvWygst]_dEuR:kGdudaUvCavAyrd;IuasB?s?MCVaC`gWm]hLQHsaiIMvD[yQOBFCxxYeUUtf_C:Wd[kBUGvQOtBeFFiRM?Si[hketgqgfMBwCi>?xeiUHIbDYbDsuLsip]E>wVRIHU]XsytFmIIayVsCnefgmBTUupsEbwDdcHv?xTIWUqubsT<]IWWhSwHsUFhyiNqyQwio?UASuhmtR;UH=vsiYaCxlIdm=G`QhpeHZQXiyCpQSmWXKOcUwDouWbwhe=xXiv=CXvEeMOdZwUaQx;EseqrxGIA[W_MxRoc_GHQOs]ktfMFCYR]ICMICgmGY;VS_I_mb]gHcaTkAx]]I`yf`_Gywc\\KfLMI`[cigvxSdB_edivhYr?;XVmr\\CwNEilyuMqD\\Syg]RkYt_ihlefDwrXWui;bwmfJYbNmiEIGvEU^WD_uvvgTY=RvcT:qw=sfkwyRIUVqYWqbB;r?ewlaWgktI]xaaCVuhkCb`UsJmBGCf:mUaORs]YscUO=u:_ruCgsOEO;v_EiWegxoIISuFuGnsGCIyToGIyUtGbiQSnSddaXBaCj]HeShboSF=FUGS]Cr`mipwBk_h<SwFEIUsVskXqMv?qFK[Ivqtfos[cTV;rxYvaExUyygYYBavE]wugd:;XN]vVcvLEh_ycIOy:kspwrwqIMYs>Sst;T`AFv_r:iIAceQSr>WxoMtC?EhUEHEVoMcD?tZCCsoURsEauHrax\\IcmqSAARAqr:GysAdm=VmGEkOYGSUqie?ycXCe;Id;isreWGiHByfGEFbYEPyFV=wMss?atE[Wu=XlecsGivsrmEgrCdRAWl_weYeGMXSQD@kxUoSIUraSFkuH_uVsYyZYDh_DuoH?_ccKchAGuiI_qF;ae?qYQCc=oiHavUIskGYV[ImsW=[tEahEIDO]wfIUbisaciVgXwGxNMgawxVSrFSE]MtsOBLibXmYQAcJEgE[tfmbMQx<Eg\\irxwvc]Ej;UyAV`?xogUiOvPYWQYusUxK;bEOmghPRiyvppE@vWytT<oNiKBIUQ\\yweqCDvi<qfXuq\\v`yvIySoHSk`S<IsHyoKqpIirpTWGMqfYrG\\X[]wIImDdxlQYhLMFQLqAyCxPpmle]uYulhTOYDtWqpTIu;TpoTkWTxlYjbPxsmviAQU=Qo@tHdq@`QIDoVApJUpT`WVLSCPwgMsmqS^XqExyWqv:hoOARehT]uot@YIeR?DYEqXc=WM]lQLwbMMGdlwXq:=TitpSPX=dWeQTG=kb@QiTOSyumyV?xWqQVMAMrYxJ]O`HtuMyK\\Kyuxe<WmXp]mjWaxmTPfqRftmyPxKxSt@ylXkVtSLhqhYXXuUxHyWAuwhxPDJVHYkPsDEPQ]m;Xn\\amqHeH?\\]^\\Sn[ZAp<Wy:hs:Ihj>reFo?o^<vplNcRIqPY_<QxkQcNowGPs:F[I__by_IWfgIqMAwXis:Nh\\_lgys>xl^gsuN[HNmI_mZQuPWkYw^X?ukf`?^kF`mYHs]Ar_qtUGfv?x=>i[At^ny`YgA`jfxs_QkS_eyavvOaXI`LNrihsfGqD`eYQanX]O>\\Py]SiiDxaea\\MvbXytjqiBXpxQnyIgCFxxqhgGZ@o`=xlInmKflkqbfQsKAgG@ZVy[JW\\sX^HOdjWn_GaqypyAd^Nd^Ge]vqUxe:gxWP\\hHu>olq?vWnbeOjEwdDisSVctPrmWd;njb^rZ^hCokSQ`Ph]li[Mi_L>r<Q[Ivjkod[ir=HhvYvbH^RfppWk;FaXGsA_i:vfs>vGxhV`qL^sdotV`v\\qlmodFFZHvwWQ]Aqv[anJhnr@dBxw;HhcvbJXZ_Qc]gvlOaWiqkynaonDI]eivOnZKFgdA^RQgDypeGhiQwEP=qHqGvCaFJoY`AGTSYqiGh=tNoSicGnutUYC^MH[AWM]CHodgoB:qBCiXUWSrIxeQVbIs?ib>srD]IU_id[HWSFRAdrSG>EfMExrkbmcuBwrEuD^GhomiS_EoKVfUimAGI]S]CV;=CowDLUW>uEjOTw]SUgeMGb\\]EqsWDEVaqgiEvWuewYD>yyusxU]v:Ueb?FUwu>cs`iBvCBE]VooY^yR:wCxwCOkxFgGNiGpaUMWsfsxHeiaSgfiHUEWq]yG_Y>IS_SDBwFSuELagTYdAusleCpSyIIrTWtACUgmtyahUKvimEc;DFeEIsfDkThQsTStiSI:sRQ=x@eIiqI^KCdyB[cXN=eqsFL;GPOiZ]FdqeCcxD?BMkeESNF\\tATXe<YVqw:EpLyv=mYixMmtmBHl_mWYySVhl`\\sfUnChVXTqumOnYVHMlO<Yj<SrAqXIoMxS_<kjxnEmNF]TUdWn@uFpLVApX@y=dYUhK>ewPTJg]KvhpUdTnPMpTJAyV@qVvDOpemBXmRUu_MVMuKJUWV=rIDNx<mB\\jaXkEyn>Aw_\\KquJC`TxylsElUQPRIqFHNMtSjHKMyk\\pXIqK^@MjQnteVvtqqmJADRtPqPtJj]tKqNeywALquXJEQqO<o_QXSTTMXlRxmWhRgDm>im=lLtPKCEXI\\oFAm:]jXxtUmpaHPklU@]OH=u[YmH@ttQs_YKlEuchmeQPRLSFAnXuo]xlWyjWIqrVaPOorQs\\?ltggiO[iYuKab[Am[^fE_rwnfsvxgXyJAhPi_UhZfYcZ?I;BB;RL^dS>]jHeshrH>rL>gM>]XnZHam;nerGZrHx@?fWQapVwdgZhHoowvW@pdg[nApCgxHixcGfCohSG^QFg<n^FyugVadGtCVflAlaatVg\\m`wx^gPOsfOp[wvGOqaamApcgIs]WZgn`k_gkqabHujYyYvZfIxC@wOpd=OhSGZrhnNNduxxSQhH_`k^wVwZXxg<iuRNmHV]oqbAFhvXp_qmd_ujv`k@dUGdJh^=@nEGpWwxry__qpQOiUPxsAecYvhaZZqdlAqQPurGj=AxZFbQoa?HuKIaNYomQfj^xa?rgW]:IaWxfepdoHjVWsHfl@QlSF\\txeOOsZxqa@k>O_=Qi`Vw\\ykUoapOp<vxnhtC^rKhfXXgTIi@Qikfds^rsy[Qv_yIvYnjK__\\ixbHcp>]RI`axn[Op;^`SWo[fvrgbTV_JNi^YuZqh@HuVvhXIwP^_gvlmO_jxu@iqCwd\\@v=io>gvAaminlJiubOn;q^RfbpqaeA]Gxo>qi>yg[I^NotAvnS>jbxuww_HpgXQkLGnZ^`EAqZaqaAt=ywInhv>wcIp=IoaYZTamGgfZ`]IvaF^yRyk;v]yAajIjI>u:?dY@ljpq]Pr:^uOWZk_xXqlAgoPgeKPn[h\\;qgTYh?ygYnmP>dcXtHx`lOjWXtigaqOZIpqv?joi^s^\\VvuWwp:pbbyqkovYheMq\\U`apX]pabLxv[Qxa_ka`ijYxLytWxq\\O[Bp_u>Za^qgQ\\PnjDnkbpoPn`e_`c@kIwsOIjSqj[Nhu>s?_w]v]a@eUPejXxENwO?]whybGpEnilou>QbEAi=Ww^HxS@[ianrOnav]nv_OVsqG_qXic@ZVinrnwEGZVqeIYxk`tgWxAofgQeMv^`V]rYkyOi@fpDaqBi_Kf]bXrHHeGWavOu\\Y`[Qi?_jKGyeFlcF^PpwLVj^ykwhxt_uxXxT^tUfsEn^>n_P^ixwa:niRiykPdAawtq_`?usakm?f?i_<v_KAn^NZYawrXdfWyWaetn^K@\\aIcRqb_VlXHjwQh:_meoxWyuYy_tqoOa[ZNxYAs;Y]QXoC?[E^o_yhTayRWkF^\\hxeypefYkUFkmiyO>qR^o]glrP\\sphvWevwacog@puQy[]qsuF\\awq?qc\\>e;plFOuyQhjyrwXe=_yUGyoVkkXwNhs^@fOPhF>r?y_CiywPlIaeiFwvaijalZx]xXhEnmxGyJnvSwuLgmU`bufdox^K`iuodE_xof_XyZk>ZQaoOhZBXvYHxk?`Pp_C`ePyhXiigho<A\\;>qE^ZP_yxXfaQiZfUgEUSVastH=B[KtfGFGqE^KeEYfe?e?QrveDMiH<GhT]w<ABQsGkksa?TyMyU=GyisYMfjCI??uIuyfKHiYYyKcCdlqLqa@PoEovMvsuqXEO:lwoquAivIlrciNYqw?`w=Xp^tQxuuH\\YauxC]qr=v^\\KxaKMqnBmN`QwW]Y:]nHevchKXQWfmvU`Rd@taLKVmWRAtAxXXYX]Lps`PLdSeEsFTy?qMiiv<<xQMMnMq\\yphTWnEomUmVuOKEPJPS@\\uhqqQMJnAxYQr;QMAtQvqQlEmftxoPLyHjqlWplsqilQloB\\TfUmqYleDpItp?iMi=UxYUr<RKttdHuN\\wU\\PQAnEPWhTlp@K]pRRqYgqyyTN@QjnmnoEunIolIXfdP\\QrSUshpwx\\q_qxeIxsyrqQkxin;emVQU\\Uu]mpWlrG]R;<MBXLO=xPUMcaUQ@VrqoWaP>XQi]unerGXJQxJ:XVa<PU@VmLJpuSGxyyxy?lrkYV\\mN[Itc`uYpoNMRVhsdLVqpu@`uutuG`ScDjtan?Hm`HVQ]KWxMu@jJmM<]k]mx:qYv@yNqOnIpHEVGYlI=VoYjiaVWxSK<ojpkN@lBuKueJtTredYYtQb@JhQnqIrhHS[tl?ySwXyP]wxavctRQ=u>UoxtvNMmphmLlYuPLFxsHXLspW[lxUAUbTnyXkImslMj_lvXHlQXts@qLmpi`THtU^XvFirpttGDRPTnWEoaat_eL?Hwv`Vtqq\\eJFLLJ]v:Qk=DTsuMedXXdVZUOiUxoqqPmO:llGDuitR:tp^YV\\Uk_MtC\\QnAvW<uw=YVTNMTpZdWU\\pkEr^mm<DND<MTqx^LlQDUKqT==UfEmkaLDiv@lwyhyd\\Li@PKtuEqJ:IxEdrgUSrMv[Il=xJJ`YgiPFXpAlxnaOu@Lfmr?yWnpW\\=V:lLPuQxiWniQyaQ\\uQlYnReYeiUbmSn@pJQNjejgYQCeTJuvEUlpHf`A`Mvc\\_qPwr:o^eNs@HarXgMWr?`kpfnG_d:>oiWuJQ\\JXuWnxg_jNvhT_dCI]qqxk@utFdEPu_q[NxoUQpPVbwgerNi`OdBY\\^Nd?o`]ie:WqPop;X]q?qBwvK`fZioG`Z`w\\d?unpf:v]r?xpwfYpr_GihNnp@ysyec?tPnZJfx;fi_xxOnrRoonqaVYh_vyPxtuqyoGZ]XsNqqKn^b`agQwdhceHxpy`Wgky^yFy`j>tMO\\spwgPcGImnNuKAZdaj_Gidqb\\vu=Ph_H_>^wQa[PpoByfiQ`[?vR>ilocfg`PvrFVqcPiLag`^h=iajNit?l_ir@^[Kw]bv_ZawCXvRaxOx_]?xOiibQy=xy>hhUyoAIxkqZdhgp>eR^\\cA]OG\\K@b\\oxZ@dgHeRPmVhrdyZXIjW^[vh``v^KihYiiRxnk^kFwdJ_c__aKvq@hbJWgMv_Q@meq[kiguxsTvZZgdpiq?Gk=nwBN[kq`nwj^FpVVZRh_piqE>[syxSnpgniv`ywWngwiQv`cxvlId[WwnFwOHr@nddV[R@]yVsXN\\Eg[;^jBoifVgZn^bAmsAcBwvWNseAoEhhxaarHaAWtGPgeYljhrNiwdaoh?ux@olY]vimnOh=>tyv^hQa^^wndxst`wC^[ydCssax[YcryER_w@kyqwIkWTRQuFwsNEXn]h@qVtgRpSRh;cV]DhYbDiFNMGGMcxQVFshYet?wxXyiMsTiWsZ_IyCusMcggiwsYqqSwYdDuDcWF_gE>gdWWtCEw\\UyaouSIfn[vrURPgTRkBxISBIh?kBi?d]]fdyYvISdohAEY[uwbUBUwwjMTuceqkYv[bhkYK;GHYUwWSuky;CF^aeHqVk[Hn[YSySTmGaiyfkhyERV_U[ESuyvuiSqsUwoCIkuseGpyersbcIiPKTSqW[qh:kgIsr@IYxmt]aCvGEC_CTgSEsHhuE>YeiMuFWuiwuRCBrWcAUuPgIrYXKmRdUG`sVRyuQyyDyg\\]VGQYVWIsmBUkbA?XqQio;yXyewIGXsyoySZur[YrRayCyI<uuY_yckbEcRV?eo?htcu<uSPgW]kEAgroYXfoHBMHCKUgObnKEbsdLAIuSu:MiywCqkYfyuSiv[ixdkRA=EJWST?EhIFpwRESI@OYoGcMWC`kVTCHKyhNOVg]WhQh:EYhABQIxdwHkcU]?IKESB;tPyefEVoEd:acSkUsaIOKxCcWFaTU=IQEc[Or;CFUmhBqhooFIEdDar?ywh?xS=RVaRDITFwHTgCV[ek;HGqxgMdEyIYYwFIwM;ylYrYWROGBsSt[ov=ErF_HtYDS;rJ?VaonKYYtuWDEksDxqIRniXBxJ@iKQps^`ruuSVeWaLvllm>MLXiXGutCxJl]qqarSqov`muquj\\q]ANlTP;]y]ExQhtqHRNHMtXYh`lgYLyarCxu;DYWtyVMLJdREdSstbS_ZkogMg\\fPwaadA^px^uMytmIpVQe@^sxyoIng;IokQ[xvy^I]fyaOorNaiM?_XXhggqXQf<Vu@Xprxv@paVqr:^u<ggDvbIfk=ghxH[<@\\ANZ;wrh^ddpvnwuEAn>iiinpI_]jhv<X\\dYj`FiWw\\rHu?gohPluFxfIivQkQwtS^k@pvnH_O?sNolPHlxXh;Q\\OpaaIm;qsxauIibk>[Ngq?Gn]gvvq[EYyVPyyW^Rg]hvy`nq;ghsVsuvvXqiKIvYwxR>_GNZqfvYG[`NcafeSgktytEQ\\OPlg_gRapOv[w?x]H\\?Iy@fZKxl\\hupgy@FxtOx?YrrYmyipEvuugwNN`c`a\\Is<xtCgpRw^>Wwg^qcqjG@y^y_wAauqaxgrxquEAc@_riAm?wZ=qghPu<gZIhasaaXGumx\\?acTvgxWtH_ujWsg@]XQqOVyHwm@GgIqg^xqkih^o]tA`DhldNqlp^`wmwq_bYdIX^sXfaNvigqYftAx]@WwEvyF@yUpuF`rApaFHjX`_`y[hybeYmYAblhu<_wGyx\\?w`YeJqmUhr^yawo[CYlaFf^Y[BwijYjbycaGpJQn\\FskVmG?nlQxm>gxFx^>[Iogw?vgA_hGuH`bOQrZol;>apQownyrnvYguAPyxyd;_cMFg@nxLwwy?[wvhVIj^HdQ>jjPtl>tM_fq^sxx\\jVyBydJveoP]SxmsIeNqxxPjkyqya[\\agw`sAxiDFkoxt=``UydDwc:``uvdsaePVhmifC>qf@^:Xl:fsLAZV`Z^`]jXb^>Z]@j`f[ZHsZVgc>ZHNslqaJQpqyfB?vMyZ\\og?p^CF[;Gi:`kiYs=gc>Gh\\@xPXlHonqokVXf_N`E?_iyaN^eEAnUWfQF[kAs`vwgf^D>imqyn_bDx\\dggni\\L@yJYe@@hl_hDvevg^?XfmFgVgedVvWwt=VeQqxZVlHXfxPfun`R^[VIi_?ipq[nnxCyZbOasY^Inyd>dJP[?^gt?d<FddVq`Yjkvm?vpn>^@yiuhfc?nBIaNo[u?oo@]:XhIhsPay\\@h_Icv_^]Gcl>_NOZAO_rYeD>j=wvg?bA>pLXw=frDIZrfwt@t:>g]Hn:nsLftKH]Pym^B[gS]KWKUiRoXqqcGAuv[uAwGvkhUsGvOYLgx;Ud\\KEPSVwIxWuHgMDigEQegwOf;Yu_mBZayHKm<MuHaSltUfQRyuyd\\sk<joAw]ys\\xwwxK\\UrulYBdkyQycElJ@Quaxq=Vxhv;<mCpORDXMtVYxYHTPyexQ@unYOyPKeauRlKxqxi=nlDPCHv`ULUtuoYNB]KqUvVIl]<MuyjIQnjTPG`Yopk[XqhqRumV@tJY@Y<\\vKyWZ=WGAPtyWshJSXMp=NKG[jFeFqrjNy_yoZ_ymxm;ogGQaFfurW\\lVuhXblndAweXHZmhyuIhlYly?kmVyYWrSnZ\\Ovf?\\gif:wguIn=@wyIoYHbkiiiYb;HZlHy@fbfFm>ar;YjRFyUxq<Argxp\\xl;hs]yijYqRHidI[^NpS_g[?^onq_w^jvt<i\\[`_Bgg@?goAxd^faofkN`lN_f_hFfa>G]<wtJ^_@nun?vaHjyNn;^\\>FZH?l;Ox;Hk<niZFjhvlsQlQhl;Xnn?f;ntHOf:FkH>tVyqGVrAnj[?nF`h@nndYyZ>ooG^TFTeGfsRCmCgQdjmFHEi`Kt_Ytg_iB_Xs[uWWXguHxuEfowHWfNMGZktBYfiwbZeWyUB`SyVWUZGd?Mc@?g@QyCIXVMfwig?mIo?Ba_Dt[THSuaax<qc;_bfeHvIX^OCZgd;EC[KuKAYZat?UrxMu;CdPCdyqD:CtUai=[rrIYMmy_OTKyDo]YoCclmw>QHNquZWYRkUruUUurikD:Wvb?v=SUdqeOEhiMg@GgOcytsXssB[YWTAT>mClOXQKcPUUNMbhMurGDmSXMABo?Do?gW]WUetY]riky>iI<UxhoujiBGWCSadbyYXACgQh=;X<qVB=upAcruB@sTgGV=?RPcs@eC]Wf]?IuCHIWUhyY:sFxOxO[GFmS:aeTORcEfFKdnWdJSUfWFSOS^CtuwXikvDiVFwWRaBeYBYkRwwOeiJUMnRER>hyTmL`@u?eqTXOOUp;pn<eK^yWuXJuuUtEKglJrQpIeQCpyUqW]=N^pjRMN?pv[xtjlrpHYtpu<QqgUuK]q_qPFhsf<nedL=axMtk]ArixY<TLF\\qNpuuALhHweILWYtSHxk]QsAyqHp]yxyuMeEUAalvUuu=MbToRqR@aoMYQ;]KRUvM<M]UwHuSF=Jiqyk\\PS<Oghr]Qv@Xq\\]YSAkWIvmEOChxeytDHUvIqkHXo=NF\\n@Il?Uxc`tvaOa\\Wb`Ko`JWPP\\axvUP<MrpyR^<t\\TpGmyYQP=dRt<JXLR<=udDKbIOFqLstMZeN[\\SWDwF<vZhM]uJ`pSA<oJyp[HjUeM:iJ:pWBLlCTyVIMQItfULkuOmApRUkwtX<YwMlWRQq=iJ^HNTmpH<mKEx;=QvQK<UPgEQDeLexOiaRLeLSLou@xmAuvXwaiWAesAXN[pm:aT;TWN@Ux\\kK@rTXqiUMjEpi`K\\anP@QjxjrDqm]r`MRW=V@emGTk_=O<<JCyuA`pfXYxDkduqKlo]\\oY=Jr=NHpjf@NiMTHYxFdsIuvfASvljxqqx\\LDhJFeSImR@ukKUUKplCeN>YwG@uhTqA]j=<pPTJ:dSEqw;YK?QLFAUH]Q[gnX_x`icNvd_GliQw<awrA]fXZuItyF`@@eYhmfQ_tfpfo\\awqwicNqotpZqwySym]gtgvp\\h`wfjsIy?^kI_sChwlI]gWjMox@F\\OI_]hv@ndYyx:nkwgwK^pYxiHVdIxa@PruH]ZQ_h?byG^@PsMXqkOyOha:OlWa[saaf`e;VtmVdRnmSfrXxauYdVhap_]eouoq?gy[yE[OrogXLCXVQs:ytyQyRyi;qwywyF;wYwya]gWQYOKHSIV;kSs;b]qDqcT@;ReeddkhwyuY?rTyXvADdYxmAHTeCFmsOGu:urO=siccPWtDOSQ;TdibV?iDMIqMYRgeWWRwouB;WBOgfOeDYrcawJoCN=g>Ad;?gXyd[aCVwsBEy[YRLKBFahj=GCkbbcuVmHLKiyCCnCDL;s;WT;?eVWv`Ohh]R]eunEe>SrUqiu_UJgDNIe==G[OVgyHAGbBeErGw?<KS]LnHwRDujUXCdNZ=WJTQQDtjLj:\\mdytYUStyjFAMs=J<IvhiQjMRwXWIemuULNyjm\\TtxVgiwr<rEUv@`QjHRW<l\\QxImsQlLZ`TNLqfel[=UWdoBaqjpNytPPXKkdwwIMhIpkIse=KPMtC\\WkasCeToLPZeN[`m^\\Q@<tutN>IUIPSQIldQXD]tcAUcxr@IYFumqesVYWfxLe]JS=QiaqLtM=Xx^My<ENIPVc@N^tV:@SeIPdETutUu`Ks]Rdav<@ys@MvtUblMEXNWpsBdmX@Yptr`UWk]PSQPgpVElTEyo\\evW`Rwht<aKuUqsyNyLj\\iPQIvcynxXk]UN]=QvDT@IO@<v>xWa\\tdDodTJqEu;INFTPjxPAAjQaycYtR=uwQPtUSc]x^HKTamcXWn<UAHS>=kqpTe=nutm<UXn]LaqxgYJgIw;qJpxQ]tl?Hs_DST`Kv`r\\=UwPWO\\O@LrDixt\\omtnJhSLtolakQMUo<QeexKxkZUtIhyrLsOQMHiONIPheNjTPYEyxXo<UwP=T[uojiXf\\r\\Ex:awwXNHdN[ANi\\Y[LpRQoD<NN=k=@r`=kJ]NQ=WfDK^IlJHnJyJxLwALQEtnAhSwil^IRh\\OfHS<UsvdTj=oX\\jAlvZXpw=T;anFQtKdr<eU?<tDnc]o\\_hgsgZ_NhKH[vxmcFpRP`F>nTq]wiw<oZaPiBXeYy`Nyu@NZo^mG_pYaZ\\`]MFtDfcvn`PosO^lmY^_YhcfuyFbjo[_@k^^yuG_YVdUoZliq=Fy^Ow?V`dacBGZyQwgqnVYs>OaIN[By[;Fw[idMa^jacnOyE@bGVwAFrf`xsXdGFsYwlMX^:_t\\p\\k>hQ^[T^wQW]dVb[?[yQt^NfCNktasn>[iP`_I^@Ir;_rDfZNIi?Iom>cR_u@fj;NohHv[_aqQtx^ikYgI?fZ?foNyAxt\\Wx`hh\\WqP@cXixe>p>HRSHJYXmiGr;xsyY@ewVIUFywSicxyBYibRMHEGusIYNAEZQsouX[?rPGIsmXTCufMEkMrGqXg[FS;SEmsHAnCxr>eJftQxMlEYntMvRTJcEPNuv`ETY@MqiYgO[OooHwuOOrJYeiybEHZvxjYfiDV^Mi`FnoXWjoV]pFnjgj>Iwc?bh?vvPj[Vctqm>>uR>gCqdW@][fiRFdK_mthecvwGgbZ?[Gfk<oyVwZi_^>hk\\N[x?[__[Cp\\di^J?ut@`rOcnAdjPpggvBgpjyvsOk@olRNa_Ffaf][Fve?otOk;?^?@dTHktwrZf^<YsAYcwo`GifLaiT^sGI[]nekIjAaZKOv?xdcFlRX_dadPeH]cMkunuIqUx;Afk[SjAesKwFMCvAWfCT:Siu]INYy;_T\\mfBoD`eflIVuUDNMRb_SDGYj?eGAS:]G\\IC@?u^wdFqgCIFM=G[UUdWTx]RDibECc?OYlAIhSUawx;KtoeXQuwbuwTCsriRgKWi]C:sVC_ErkCh_fj[BkMDyGiw[SVaRgMxFKeoOCT[W;OE=CRP?GeQT_uB\\qbc[b=usGadKyr:YUiSBtEiVERbKYMuflQggayEYIHqDUEXf]Y@cIUqh]MiNibfAwBKiI_E<krIQBSgxbocIWCPwgRYuEouuuu@Wd]eVNOCSCtCoHSIhKqR=SiyUxQID]kiZyGa=t`MGO]sAYDROvF[ea]cgEC@;dAOTsMIuMb[ahmSVM?egGUfAIA?TfQwlgIxARhCWcwxsaTiwdLkV_ArToBFYr=gd`GvvAUJ[Sb_vPCTmkuBOs>[XDiCM=UBcI>OGgsR?eda_SYCWF[e<;gnAtgOEPeX;EcKkTb=fAWR=CifMIbUtDCIV_BsuTt[Rc[fBcCCqbCIbJ?RkIr\\eTyWc;;ijEWt?Vr[T>oSGKfjCSx;v^KEEEgHow;IrXOYduX[WhxcUy=dD=F@Mu@ogmwDTEC[cGewVRIiFKGYQh_SrvKE^=eC_B^Sr\\cCEwvaIRWyiNEuZiblEg>_DCWBXQB?OCxmsV_CrewJQh=kxBWxHiyGKDRST<]rJOxRABoCgg[C>IwDKbL;UGSVVIGG?tV]t\\oX?UBrkeyqFlAvfsIyObD;h=[fRKIdIG>IHlyxyQbmwrIWbpWuRAYmis<Mc]]YxOBnuV?;Sd=xVKIpiEaWvQugSuBmCu=_Y[sstqbR?VkAg=kurwFVsGR?vH;DV]SqAvBaDXQimUGUyRXsbUcSnuwyeCeosWgDTyW]wcvEECaSTSeyKxMAGaShfuYm=ixcd>ebguVhou:QwvmEUwY]yhJ?ER[b;qxWSDXqXpuBrWdW[YVGF?_Ri\\MWtm@ENUyOxUw<hVClxHxvv=LmljoU]=onRY^Fpk]_uHif_HrUFbrpaOQ`:^]_pqvOZ[fm^?f=AxW?s:xZ>Vl^avV>q:VyNnqaf^f@[>V\\nip<^ZoPxNofC`v\\iZG>jCib@n_Rhj[pw=wfLal\\nZS^ignZZAkLx;QUimYOUgD[rnEuLCIfKYX=BaSbp?HjmhN=BAyX]EgT;YhSX=MI^AyCYvwcrLMb_iEJqe:[D[]woGDDKfNgtogEU;d_;X_;h[gEK=eXKG[;C?;dxCdFeb:;iQCS>_BpahtOC\\syQMr>mMKIJB]R]`wVaMqDo@eteLrjqxaavqIqOpnXeXc`yuDKkAuBuynXwfXmppMKAkKAROTom=jTEx>PjqYnPdpbhU;]KV\\W@lo_aXb]qmyv<EqSAm?HnX`O\\uowuKatqryOj@MbMkm<pn\\xHyX]DUdQReMyfxtk=KpescaUlHqvLSg`n:dRoqVEqp^Ev`QuhpwJXt?DX@YwfaXWTNMTPbiMTej=IprlN`xVJQof<VfIoa@PsMynLp?QJtqwrUL`@VlXV^<mghp:ilDPmVHs]=ng@lEIneqxu<PklQCHxcIU[]qVxs`=pt=nQ=uDdMrdPHHxSHMfENpuRfuLf=uwyT\\Dm<EpNik^mPI@mb`QolOcPjBunVmPW\\pWxK>ip?pKOdKS<MKLPEqQIMLVQnYujQem@LXv@JGHjEtJiMlLLjTEXdxv:IwlQMT@ohPTOMWByuc`SUPKjdkHLmrMWxmlTxPA]TJYS<Iul@PjqnBMjBAVHuVRalqAjTEqUlUo^hrph^^v_quUBkael[Y\\Oyg?Fw=RwkvEKSrct_mcVyG<OtRkIm[RVQsH=sZiRWqhrat?[HL]CJmGN=C\\cS\\iIekH]evfuSh[fjQr`_tustP_xsCd<mihiHmQCj[eCYcU=Y;EcN=W[cbLEC[KSKmbYetdYRrcb=_d=mil=CSmCQUW[[TWeF>YiXKumOSbIyv=EvEEKKg^ae@eGdETUMWu_yL_gbgGnEs;GBI]bYuuUGrPouRkhH[rKydn?HxixiGVxark[TSYdyOyhwH]wypWuKEeWWxtCTEIUYQhe_DZME`?B>mhIiEvoCPiTnsX;[UVgGMaf@kvecCFcwVIcVSBNUXfWSceeUSrkyGxEBooR=cyiMiEChhqENYWoEBrQWgSCGmGgsuhEfLEgZauQoi>KufMfDquY[It]EAocW?RsmWXcw@UTbmtOUgGCVcgVLSF:;fFkxS?Xk;HFEW:wi>?RS=HymyEiIHoSiysY]sj_rf;iJQGNexWCwjgC=[Tcqy=UgZCcxgRLIBYKDgCtU?gBYR@[St=GL_B;]f\\[cE]t;CGZsy[=yFycTKRPEUxCyF?DG;ddIInERC]D\\OoM`pgaKg@rZ\\KvHuEINZlyEdMvEsoLJt\\yOQKWLQ\\TQIhmNEVWPLTqNTmy[DlpyRNaNwAnphmyYmGLR<<rm<sRQShxLhXx?DNDEX><n_ASd]KjLQrHV>PSv@sF=p[hT_UO?iKd<l`LWodkley=@jWLuoiw><ruTxXHJGdr?awXASBYTF=t;iwG@WMuQ<\\XDtlAeOdETu`sS<QammbeTe<OGyk]mxSyfv_gVvfY`i<vnYhyhnck>\\Nheqp\\UpuqqiR_r>IvKH_^^jIH_V>h`YZDV]rH]TPmu^bRyo_Ajwvhs`bdfkmWho_oupx@F^?O`pfeAIkiviCVdAx[CfZaihqqqOn^=>hOXr]@c_NlR@mX?bqAtdoZ\\vw:IjWwc\\xwCxrj>rHHhoikqFnuQwGa[vNpgo^M@mViy\\nf`onJYiEiuRvotIa]ggc@k<@lQyrTa^f^jdQjoF]Vi_SHk]^e]YogFZRN\\:Nd>`mY^tKfgUHZgW`QHiZNgofeZgmjPn>fijwt<Wnl>lJXxYal;hd@vgt`qB^t<pjHO]hous@fMfZIqrd>\\tfb:>s?V_OFcB@pjpnyv\\DQaL@^MwtChqNQoNFcZQaK@tkIexamA@d=FihWkBanfni]QqePy[Ar?IyWf`nI_YNoK>yHind`^pH_>?mQ@j@priYrlVw<Hik_doXoJix^aeH?dLNyoG]rvpdoe`QtBXvh?bBp\\^gntpnWXsZIyAG_air?^nQ?_NQn>vdlgjbPio?jIQusWuDvwX^a`ItEyiMPw_^xtAk:ose_t\\p\\oXsY>rsx[fGqVorCIqsFlQYxOykwY]J@mCPwvaa`q\\P>h`oh;Vgqno=qsY?y?_eyInY`bsFl?ylX`uGpffVkeotOfrtio@g]]Yh__fLIgn?\\]O\\OymVh^Uxme@nOagrHk>?s_WhR`mYhr`i[UFp]iiiir]vmva^pyiaw\\UogXfqI^QQeq]i=sv@qfjMYdobfEgUSx_IYFaxpEvwsetaDXky>yFjQtQoE@Eyayyq]VEgRKKH_IVOIgTUBMuVAEXMYiYicemwsUILGs`gw;QsxWeggHkKrxUEQ=FyeY<;CxmtDsBWMIEqf=Si_?BrkykUgWQwvSWaCVbcS_=s<UrC_b>oW];vyGg>?TOEVWerdOCJevb[dV_hHmY^OGMKFmgI[IvDAFrUT:WE[Kd^ybIkg<grCce?]YO_usCCfeGdquZSHfeE:UefCYL[xrct:?XrkYEkT>SIFydXKwo[eIixiAg@avbKEjMXOkFNetyMfwuw\\WBL[sLQdKebIKI>?DSCx==etqh_wdZuSW;V`UudEua]rL=rBWxsWfUofjWSLki\\ytWix_cFhoeWCx=KslMr:GBa?IDEX^=xESBv=R@]FWuh:_FkWhfcCkEXjiEV[vj[hYkD`OdTaeYmiD]EKUIistHOgFahYkIPaRvehdcTokbTcBNUfPcheKC:Ix\\gBXIRgGYmiuRgH]=g>YDR=WkuH<oDDWEpCVWuSIkWR[E<qxAsE>qbqoiOSCMWTrQxqoeAUtBUfyWGIScMMEgUCsgSUGdWIiMcSh=WIqU@oUEqrpGeW[E>usHYe[]cF?BeoTEOf=kuC?x<YbrSuiMF@;YqoG:;BB;RLCTJcDWOrGswy=CAsUVicNehDSht?b;WuiuRtwgISHuqc;kVV=wLIEfiXfauFktXUIFwxvqwiIvCQRXsgxSxFKWMUdjCEbYSPSCbevD;ipYbYKrPybXKrvQR=ch`gB=QW]ktOic;YEhgR@Gb?aVIuHdKd_os_gfZaY:mDPkIOGRVQT:[eZuBfSw\\cXqCcN?cWIRqeSTWdUCBDyRC]S=_easR<CH^cIyWCxgtQ=U>kHfOIP?gf@VhHM<eWaLjZqK[LR:YkEDydhRPLortOkLjZ@l>Pqg<oFpnTXTA]P``XKtT@dyvmX\\PT_ER]=WQQCEWj;WPkFUKvOShBMvwoHbWbLOgIefFuY\\GblKgWseEaU?[bveFZ=waQd;YdKCxliuVCVVuS^qt[Muf=t\\ShgmIBah;Ud[[HMcXsEDi?V;?T_IeGkFZGyZkcJeTPYrAAUNEDEkTR=TS;hcssDwYL_tWMWL]F;GW[weq;SIYrGOgiIWA[uPCbr?g?eOI<vrAym@TiUnVenrxxQxYStPm<X`iX\\aKV\\rmDU^TK?\\VS<tsTQlmKupmrMUbApOMUk\\oTlwAMQWXR_HSk@pJerPmJjqtWIy`\\pUdKJaS;TXmhTPyw>iq;`nOUo[=fqNvApyryc>Q`VYinpaYoboHrtNtRH^>PjIakHOfeVZpw[wOwi>dY?_EXvBWPGcmWDrCIOEVAYTLCFQaC=KY]YXMAYnIwWAiaurOAYUyWwqChmIoMCGkgAsr:`TxtrHXqBpyexo;]kwAswyna=t^=NmmW`mS:LrY@yuyy`LRfHq;HJFmSf<jMDXCXSRyVsqMAPWxYmFqrglr<iXdmTUQdX@^]q\\Np[K@Z=fd]o^>@wU@t=?o[?Z<@wcYGkb<seMsgBmRCYwLgf>]XpeSQKhOAE>AHpasnmBqEUGUrZKGh_hS?GQyDNOS\\OhNyVhAy:sW:YCSGEl_fDCfd;Y=cTogv^eimCyuABEIS=ErTCF;IHOiVMoDUWXjYvlcChKtdovBMdj_xrKfL=XW_yCeyIYbO[f[mdUOs`eGoqD_geXGDc[gbSb_Kv^qsDQh_CfPATTOFBgUJAVBUYN?bQCFWsY[CXRuHQ[HtWUjQR:QURwTPaVmuYBwsbGsFoEOUR__rIcu@gDm;ixufNMGccxEwRbOFoMR_cCu?h<GCw?e=OSwiBG?BU]t\\oX_IBrkeekhJUhjQrkGGfMwGEF?ABSWwf?r;Ol?^cI`]@asfaaHokHHvrVZRgnXpafoupgpbP`Go^M^gwQ]X?atFkX``?G`QpblVe:IlmW[RhgQIdb^^vhyNXoG_wwFaApu\\oZcPbPvvR>wu>hbA`\\GyX_ltX[<AbswycI\\[irqPoa@kNO`]NaWHslg]uqcH@j[N`nA`JirIXkQFe^Xps^]sVhLvmxayq>hAi[U?pcguT^vPwoKVsnNmG_pRYwux_gY\\:fpS@_[Fs:gveWnm@m`wrsPqaX[m`wuY\\AosZ_q@Qaj`fkQlaIrSi]yP[XafjvtC>rgnZ`QegAheYm?aiDw\\Y@gM^_tHpJ`uqN\\pVjaF^?X[BN[aqZDg^C?hwOnkpk:^`ahZa?hO@jKvxj`meX]\\@n@A[j`fxGnDhyWf[dyq;i[iPbD?hAprpIdGw]IyZc_bLGsG>y`Pkyg_CHk]PuIfn;amrFwny^]arkpiLH]ufxX>v[nrTg]bxtChwi_cG^`bH_J`lPoo:N]pxgSdVkTC?sp=UHKRlaXCAveeTJsB^;T?YyMkI=_DjiTOGueKgB]hs=X=mVt_IkyUYkCt=v>mVx_vVsHI]BRqBqoHcqSNChVuwXIT>[b_QGRuxwoWjsgLOXxmiU_etmFsqfdaGUwcVeD[uUqyx@gT[OyaiB;]DumUmYtHIt;?g?eGduTJ;b]ieLsh@Qee_FjihQkC\\me;wf`Ug__CPoWAkdFefkGVEqXneXm=rOYb^MF?SH`McoyV`IGHCHJgXh]vN?DfiUuGXekTgowlwVy_eGCHG]tRAhmQsCGSFmciYRoOh:qhKYcXoy[[xaST<GC[Yw_OX?[ExSI<wVqqE`UsWWD?sC=SReGh`Ur`]XQScBWITcWVyxmsr:[vdIvo=EYSIEwWvSiIkvmWYJ=s^GdEqVJEgPawJGW\\SbhoeX[CHcrJ?VUyWqWtRiYnAEXCYvIEkKvioEXAbxGb;]DsqXicxf[dTag`WCVAiNIcF[vPOGiKvpkWLmuhehn[eOKj[tL>@v<ERNIy[mmf\\Jlmm?HSjPWk\\U]pkblkGLY?mjTEmaPjVToTurQyKqAV<huQIXMQwj]oEhMa`mb\\JImx\\\\U=pp=IuZDV]`NgAKjxl\\xp@iPIQYl@LlqQN`OlpMQXx[iRTiwFlrQ\\SFtn`ApxdT`Uk`YJ\\Hjt<tP=JQ`RTEYaik@@yTPS:ukt<s?@rITLtUuPXnIPTFeT`Um^UpHuOnTOaQmCEVB=sfPl>lN=HQ[MXh<mWekfQjr<W?_\\JgZdHgxQck@f?>iCq_FNpQ_oip\\Q^fUf^OoujvdF@\\mQy:>^]HfEXoMxZTnhQwjdArK@kAXkT_th`@IXSmc\\Eg>ABNqHn;ieEb?eeHesISwjEgG?Y\\CcNMI?ABUMRj;V@WfZGs;GdwoYFcb\\udJwCckXO_BZSdMgfMEgNkbPug[uuoUHjQtNkydGwFmcgUHg[uX[CPIfnEhiQdF;toqxpIfvoVX]xpCi<ED_oghChymCVauJCUDGBDIb;itfuuw;w]=RjOUcSh]yWZgt`UuHedJidCAFIAB[MdgyFMgsCWv[kf;ARUQE^YC?CtSeVmiF^UhSUyuWSSYYsCiu[irOfgaiTgs`OB^qd\\yXd?haofwoG_OgMMRBEHd=Gu?S<]fd[HqcrZ]GIOrM=yQiYAUBOYeJURbOcYmVB_S>geruGiwwvYWBUul;cT]G:]FEAGhaS;qyQqc?AtmIyiOV;aiISVwUEK_goks=]HfCbx=U[mb\\EIUWIsCi>igKSdGGtfIEFWm`ytxPkuxxv`KmUui<P><uEqJuUo]Tvf@Jhtv=DmZYTW@oNDOyeSnyQ^PxKEVZaMZdRc=PYYkdAv?Pu@\\xH<Ol`V:`VrYqqYj_pjAQlsxO?<vUmxwpvx]ouPmB@LdHNBPTBAxYiux@QHDuu\\l:EsmYPVIkQ@KYQU;HSHPYlhT@<LlhqR`LetnTTSbiwLPoQIS[tu^QSPALWXQdaV]PlB`jEPUNqoF=JAYqUlUR<rgqof`kOIo:`tpdQpdWg`P=MlytNH`VAtJh]MNEqyUxyeVN]roptl`MJEp_]O[hPQTLYHXJmvXTkCqk=XJdlwTAlGyLfmjJhY`\\wg`KMUQ`TR:HsF@tUXkk<PMiVu]mtdMPtuptOF@vfDncmr?Ip>aS\\lk[DlFUk_AypeWG<qQyRPxs\\PWrapgDJtpS:loM<l]ARuhvl<X^aqvQTAlKdXRVYTnYyP@V]eKaaUt`S<dvhqLkaRRPTfPWshS<pWFLY;XjTxMaYx:\\JTMVyDtqxSNPSQuWY]QV=shItNqy=AYQIswAYsYnydjpMOCIob@nWhl>\\SODQJDw`xNt`MBpShmjcUmCeN;DJS@L_Iq]PKrlK]\\tvDqWMvP]UL\\spLLEUrV`UfPmYUq=tRkpwkxo\\lmWxRFxmAlPCHNgLuKxWKXLrIk>ams]oH`wn<RompCmsiQl<IoDxQb`T?ES^atuMn^yWCQlVlM:Ej>mYKexVQo<xqJMoJeVYhTDeL]LTgPRMUKSMMHXo?<LBdYdtr\\dyPuwFEl:HmdxL\\mKN=wDuvFExCew:`ovPL>@LDhsETrp=V[ax_UjTLNKAvVdpbhUK<JHYMF=M:HPSaWWaUn=rA=R[qu=lU<HMmhJkeWiASm\\n\\tsj=RUHw:`O]<nAeVeur?iJJ]SREKA<NLtWuMYmEj^MPOPRVxOIeyJIkZexFTRcPO^Yy_AnIALZHlt=VnixLIjMlYfPTOLWRYWc@JH=uLHUgqsjeWkxK=dRFLxL\\MRlp?TVtPWb=McaflHmVX`>Ferv`xo\\]W\\agjYao:NhBf[Vq_Hn]=Np?f]>Vw<gZngd:ynm^k@WnCHsUyhZ@lYykoGok^`LH[Kg^giuAPqX`]nFnSAdYxdcwe@pph``pY\\W?sQFfOPptXl=FwZYfePykPq:Ab;n^Wncrfh:nqOvk[vpew\\@nrXWbvQugO^WIbrW]UndAOeJYsGXlbw`\\@am>d?Ob^^`Cpe@^^l>mjAp[`_sNvmhcDg`a`\\d`x:Wn^YtZIuIGswA]oihQaq\\?ZGnrJNvEakByyDgvepaBYl<YmXgjf?^Qn_^Pi=>dGYw[HZqFel^jLg`Yxc\\oa_AwdPdGQ_m`lD>gEFf^wlBwoKh^xvqKWkT_thV`[vuEN\\pa[_W\\V>`_AZd@tgGkJ>mKNmNpoYvZOXlaosm_gp?y=Xjv@mT`Zgi^rVl:qx=aqbv_kI]H>ZqFmwWlSFqEFZjolZol^A]dfenXgHNkPVd?_y=_gMhqlIyLnoxPy@_eqgsHFZXheOifxooaov`Gh\\at[_msfhFVvV>sS`BGdhiVd_TQOyAYFaKvA[iRECKaXcaXWMYSig;?I?]CpQH`UhCGwqgu?Guqcu<KHxCc>stDYH_st>?RO_gD[s<gDn_RcKiJmtcAfJyEj=c:ofcwD:[W^;CDeU:qBykBBUr@KUl?C=UdFMf:ABfEbIMXrYX<yFJ]Y<]D\\aDDeCsyCYMw?qyHOYYWCZCVAAC[=hqkdEqcc]WVcdREIQ[YJuF^?Wr;RN=VYCDXcVYobfwJHPmEqU?`TfMLAqMEiROpMjPPVTnsEuTTktaKbxJ\\AN_quCeRb\\tlmx;=k\\XsP<mnASOEndEt<`JHeN^qn>PlolrLmUIlMmAwUyX;EJn=RZtjHYKUPs`dxn\\TUxoMYNPDjr@o?ewDLJjUO@avg@rlly:<Sh\\YYajfdj@PYW@RUpPZPk>Qxp@Vq`UJqr==ngDnsxLXLSW]K:Ix\\lJXejDUr^IuZXj?pKaXTDYNmUOlqwtUtUAPr\\p@lvexo[MxQmyWLwmXpbUXJtr==tPUU^aNXux=uw>QmUpw>YXumm;AusHLAYRp\\uYdlBmLFmwamjh\\teDugDoh@KjaoR`JfMPvuX@toD]lJdv_eLD<ulyXyYLcxLpAvZyOyYOnTSw\\KZ<utlL\\twCMJApO=XwEilBMqiMqjqOCTyVuLelK;<jLIq:uJY\\tHmqapW:Lt@<N^<w?HoYYvTixaHoNLkfaYnAK^UW\\PlBXkCmLytkNUu<DlKLNKEJ]DxJpPoiSWIkGlPFTmPXTDlLneUntTDUrgLRjYw;\\WGmPkyY?]sPlYLhqUxx`TW]=MLTr_=Yt=r\\PwREKCPT=IlFDXxTwNpObaneHUPPO\\PVrHyo]NbIyZ=sRxs;\\k\\AMVmnJioDhj`ywdQJQEUx\\n=<kMXkn\\lA@u;DlvtWRQXaLVteY?\\P[iV?`mmUo\\]XgAqHpmUETERi]V:sDoWxqSERGU[_SV=eh[u\\aCVSYoGWa]rr_BJEG]GBxwwgUUiWr@qiO=GyYtyKVtYxyacCYDAIXtoTAIvcIW>AuHSiMGSVutWibXwvYgRiyYxaDD[CVceusX@;twITQSgreF[ki__F^sXIusgWtn=w^iWcCidEcRKSassZWYIYgrSeB=fK=suKbKaFZuX_;BVCt<]hX;Sn[yMYv^?BbkbqQcq;gX=U[Ghq]TLcyGCBemGuCS_kYKEda?df]BHyWcgFWYFS_HlIg^KhfiIIybeGE@[g?Mh^cDQeBrQiiEBqkBc[GbuYfYu>EG@ywt_WBwD`ex[IFOOGwcYSgCG=eP?gPkTNOssaVJQR\\GrCScXwCaGDvmIZIt^WRN;h]cD`=DbiTaoyIgtlCvv]w^gbEeTUWYnmfKUrjydA?Hc?Gn?fBkDF?GAoEdSil_XOGdbgRgPN:tLotX:]QIHRwtJjMqFXSr<MnYrd\\NVLmgDKKiPUeSNPkw<qxQuW@mu=yY=PtyvyyKTlnChYoqJdIk^lXvaxIQK`tVfasS\\qlauqEph]WVdrMuNKpUyPSKDMGLKBtjUpkMuRVdp]<rMaWb`yiESZ\\sbILLlkPUUFhMmAuumM:awguP;hMnLvV<lK@m`YWD]q<aMShrmuuU\\J;Tyi@j=XJ^tVA@PIYTL\\Oh=xqxNwqJWaux<JNQQjprtXY==sq]PXtRFaPZUO:ISFqpxhOiqMLhUQ\\VJqJI<NJEwiAjHIm=tWZQP@PP=dROaQktSiasL@QdtJBLyZHtglSk=ucdsAal<eKaPsX<oNMxHPXopxVAl\\HVRaWWxqBPUxHSBDtDPNBxrRHy<MsLxJ?`T;LwQtJJdRnytEtKuMRw@Kr@QbqMcpMJYXIij^HXAeuvuuJPr?dSi\\ryyRa]xvXk;]pb@X>Er?eOdEL:XkT=JjEsZdOFHkETpQQKYqMIYycUSshP[TTrqK[YTSymNxWYAN`lPgxuDPV`tj=tkxeMmiWEtnTdSfhYUiyRaxMtK[XYAqKJlJ^qPHys]at]uu@asYiYTdKEIyGMK=PLnUXBdK[PQBlsqHoLHufdskERh\\QJPRePPUivDhxDDOLpTETxqdUEHY@<RsER=HN<uolQY@=pt`lbplTMkVEkNLqOhNL]wiaK?mk_<lutNmhWtxyc`rhiX<tW>msg]Km@tL]wsPRhIL@luF<WlqO^EPgpQSYW;lqpyJZDm_EW:ySHhqLEw`<XKpKoyky<LB`pZdjaDL>dl>iJimQJXl_dWN@ui`WZuOitNQiptTsTmLkque@kQLlBUpmaYrDvquPQmsIdWLuSAmsi`LPhwv`USlnZXy<xWfuoClhT@^lxZRfym?wsant?luXl\\@pTO][y\\k?wsHhT@]q_jWQnPfpB>r?g_F^hSomCpxlWoJGjpPfdiolveWHbUPl=h^lWkf^oSgpHv`haq=vnxVyqA]WYqQfd@^^uw`gorGyqny]jiukH\\voyQU?MdQuw@QVrwygsx[iwyiyYCTh]tj]yswr>oRZoWTuEnKYAOw]MWb]wNowKIE@kuj?U??gyIUusd?qrykye[XycyvkUuYxYIRewiQ[RNUwDqTU=T:acfgSaSbrsxFoB:oe>ki<KTcCFf]EimRREvFuR:sRn[CHMRRASoQRAOblkUWmImSWYyRS_HJoSk;xv?iqygeySdSB>qS:oScgCOWX?AgYkTOIDYcbFkrviwJECNARkIcZCroeh_Icl]cL;vM?xVgYd?gN]vZScOWrq]r:[Y`ss=Kbx_sC_UBCvsCIbitm?Ct=fdgBTKgmSB[Ogoidi;cfyWC;tooYOuTDKD>WfLWd@=HRUwmGXxiC=UFjqDo?g?=BhKWeSrPiGHArowdbMf_gY_GWx=Xp[giwXJkB=SbmuuumEGgb?CB^shVyy:KwwgIr]xyoYD=c^SES_Cuqg;wFYOYFCS@[BbUg;GscIC^?iHQeF;U<uc][yiMfCwBe[F:=UrkTUaEKtJXlx]=relrxURvMWTyx``t:YURTLC@jF<SjtxHeQpLLjxtLMXYQr:iT:]WsXJuqLP]kL<qXXSJ]y]yUtLLd<kmpOAItmYTKiSr<taPLtIlIxUkYtNhKgiTiAOC\\ksYykInTPQC@x;\\jPLROaO``PB]v=@NctoELcmfhlVbc`oyqn@HccfliYcTI^y^cuquSamAArKOoWptj`wop[xA[[wrg@Zk@nsVZnv`Af^NPu[v]hGd^q]o@o?g_<>hKW[Ay_[o`SWkwp\\A>hW^qHVaCXj?@^rnqtvpsVwiy]<gitO]oQx<@lS@^ca_lXmpFv?hquHtbodkHhwQe^PtCGdsQegptjixi_aFpO]rJQg;SUAuS=qF>uDiidLcx[WWeGSfSevQT>wXSYG`[sSIc@qDJCrferFMvSgtUchdksxwyW=et=vX[hEGIK]Y[MexySq_F[aD=AhmDMHAJfETOiO<eXQ@X;@NKaWy`tYyniXRneotdmoUt>AjOUOk\\jNMp@toouVCyqH]sWQvTHLl`V?xv><vYHYsqjPULUdlbhnVlT?=jIUlotsVQX@tqNhlbmtGLtgeSOloJYpA=xR]PT\\nYhYWqPShYdaVbuK_tlHerE]tyTJLpSixVCivuIYChVOAOg`w@@JOqMfXl^@KJ<QY\\RDitm@o`lKfxTkQWBlSQLLk<kdyRVDLjUOKytAuVkLJjETuIjZ=ubQSOHjKps^Tu\\msU`tSHymEWJPySYXRPMutNxqslxqCmPAHqSHSnuxN@tMMw<MNStL[Tu`mq?Tk;Dq^MP;AjM]KEHl:HR=<yZHmwpO<\\MBIjMDkeAr<UrjQX<AqdEStlwNuslxwdhKYHxDXlp\\oepP]PlB=NHAJceqcEncEuZTPXTNfeQYttNYmZuuSYJ]MkguOSTKp=rlxR=pMhdjxYynPKUAjrtOCLphEJUQpJmvh\\m;XNaYVTePG`VKXKB=nPDO>@Pj\\rmQN?PvF=JbpJeQQ=\\V]iKLIlGXNT`s?POD\\orUMbUuDlvlEwXAnh@wkxL<hlRaOSIy<ExHetR@QiytEENPMM\\mLY<OR=lIYkLEpeHQU=YtpXtpMVPYxMQLxX[tSj=jWUTwEsNYpP<Oh=nr@LLtQdUSbext]XHLN:tLo@ogtMJIo:\\NFDSTyy^LTc\\SYHQGHqKXPbLxJ\\Vc@kruXILMMtnJXs`=lCan?ptUtUvDOlqwfDluqr?]YC`L<`tWyJtDNFmO:]WC`UflJd`sr@XbAKg]wR]S\\EVdPW\\YmAEMBaWS<WlHrhUWIeMqiWh@k?mRDIXvUvJmKgTk=HP<hW=aJiiYxYuBqMydjSxxy<kiameqrExNGEpeiM=iWVYq_HO@DxrHSkXwr]KYYQ_MkouwYqW[qkGpLTllcpNuYOOmntyW]DN[iTw\\pDMR:YMC<NVATjpRnuwFqKFXmPLlGtMGhtZdXjUMNeNq@nAXTo=p_DMDYRpPtLHJCxMldX=mmXxxaPr^PwhXJhyXNEK?Qsl]WxmqRPOAMvmHTdmsTPXP<qHlm_XSD@ySdYhesBtmj@LWYkNEJZmk:EXBYP@EpBLLU]OVHo?PToEugusA]SdPsGDjdUk<pQY]NtLriUOXqV`Mnm=L;<qbhyZLpkuLPLR_PXkMVB<WDLKVTws\\Uh]wCQWoHlb\\lZmvmAnmYXpQY`Hk^MPC`StTjRMNHAjNpN=HRfAx_Dx<=o[LUbMqNtjmyWquTyLYumj>Qq]Yva=PutQC@M=LXd@OiXYrmLrxMwIQ@\\tdeOMdkpDRiMm;@PehNbdnTUl\\]XHAVZ\\kZpup<tWyRJxYhiNnqYaiJFuqmqM@lytHXtmrNTMUuuOaL<IsVyTQQWK]SPhKVPmCHnCqpsTTcMng\\p_\\SuPwNuOP=KCTmTdm^\\RZXyhpJ=iotmWW=vTHWiYJZmS[lwt<uk<SUqVy@U>PmcHSJIOUeU@<XNESYUnDdWaYJtdPVtS[DkUQrIYOMxw[ELpYXoYvfTQfAMdius@oCxn_yw:@L_EUIaSX=KOQMXXkB=J^@lZIQQPT`dwIiKoAM^tROeRLaRxpSx`sBhy@ypmxTn`Qv=jdqU;eN^POQTQ:LpODmLEse@QO=y<Es>mURUVGEkatWL\\rNhmD<n\\pLo@o?=JhLWQ`mlUnE]mEULC\\QTYw?Qps<UF\\okIRO@PJXRUhS^<M:XLX]pDTn^USk=TSdQhDVHtOlIwUiO@lutAX=iTqHNW`S;aV:MoRXO[it=uO\\pUePkv]QwDnHXSe`PT`tP<n_Yy_lXBep_\\rsewiiWweOAyOq`q:XViYYalsxAw=@WaMtbUxrDOCEkGmpTqLThs@LVkaLT`K:lpTq^g?iegpf^pT`[NnrLNuZvc<WrWhmnPkC?]]nnmfg[Wwe_sU?rqp\\aIZmOycyl@_fxGkQ^s>NsoohOakpvaKvv_Gg\\oZkYh?anuXcyYe@ne`HZ?wjGycCVnX>vlFkAOr;XqYI]HV[@gt?aluWtwwc?`ZBvpWQhRVbQ>gt>^@PeLajBngoxpiNeeNoph]J`r??hWigTnsuwtonspQlOGjU@ZLolvo]ZYgwHw\\XqX_fSOp?WlRVab_[X?scyj\\goZiengdp_jLAx\\yZWHtEvoBA^ayniYnPfpbhb:n_dwlRvp?`iroa=XisYypWk=v\\Mfc=AbOak[ni^A`dxZI>fgqseA`xov>X^ZAfrOyPgkPWZkAiVgrT^bpG_OArI`\\XPk?QvBcLkVySyq=HPKsbiysweAuT[wD]cd]QFNOSN_UmKG:uD_=Fg?DU=RMGBroD=kDSSh`;BQGE]uR?UUbcre[W:iHJaVbAFEOGDiIW=W`UhBgtP;d`cHnuFgmdjcrXyHU_CDKeVMh_gcnGt:uUTqViQD^GF:OFIYbU]gLahMWF>CtK[ECKBd?RwcWZsVHCFlKF[]gUCU^QidGVMAIuoT]Gwh]y_qxqYfvistSBFexjIBWOg;UixQb[KCQEgawvPIbgWbWwTP?cK]XaaC@Kv^SDsMSOiSEec=[f<MEByf[Uu^EsEIGsIfx;I]yfecDaoUNCt=sXXQsHgvPcxS]Rk_Ik=uxKwA?SwiYLCvsMCdQuPGxV=SdlJa@U:xyYXSwApyUuvtxM`p[\\Yg<ogxJblnRLToqWA=T_Iw:Io[qVstph\\SL\\r_iynUluAXjyj:EL==YgYOoaYDXNjqLo@o?[i^]Q^joOebAoGAjFAsBI_fWuvg`DWoPWfhwuXS\\kc?WfA=tyuxW=whiwAatNIIK=h:YIvaWtScgUuh=RlCd>qiQuiaUYyKUP[I?uGa[hDCD?gckgxFEHRkhfkwwQWA?Hs;UVCypyhZecWWrosEwiRA]CXUS^sXxiWMUb;cgDkWhkE@eiPUVZgG@oeVmBGqX;kD=[XsaRWsXoqc]otb=cwidRKFjOwc=EF[vk=RpGFqCbhSgdkBiowvmdWsR;[YvmWq?CpwXIIVOMXF]C:iusaDdigVKDZKwjofkwVDevb_wd=DJ_RKQRbOGlUO>PuC]Q^ELZqLHDuWlv?QW[mOWXrEeUUEpjmj;<wpUYCxXOUMBTshQUN@yu@p\\`M_ayWxrUIkYUlRHr;uMO\\SY`WlIS=qKFIuNEOgEk_iUjqR<@UOyJT@p=yos`VUlnNxMainm<xe<rhYv^Qr<lpfpW]eTytNmdTb]LbHNjmPF]n\\hkj=S_Htr`lhLrhXR_mu^ALcQTiPRBQjKPlB]t\\p<nq[@a<Ntc_qOPc[fejFroOyeis@nxY>uEXgiXuCpyuow?qmWwc[fsxpmryliNvdxZy?]iGqiiaRp]Yfp=AoF^k_Plc_nH`]MnaRYhext]arcX^RWqtW^PqoUa[<qqQ>fH?sM@]Rf]sFjMW^AGlHgfjHg]itBavDP^QisdwpJAfZnohOusHg\\^p_Gs\\Vqx>p[Q`_Fs^_[WIutVeAAbfnbJXsR@`RQy@HrHx^hO`jif\\HuBH^;quaGuqGgp`iLhqaQp\\feSoxsViVAa[Fl_ww]agwnif_Z`N[fyw^VZw_eH_^WpkE>pc?aPOe[IajO_bA^^^cdfbo@slAbWFw:^uPPsxh_\\y\\UIodAmI>sON\\AOhx_[iaani\\FquywoWninooK?]h?hUagwn^RHcSAyZXtbvsQHvEqsQi[UOk_GcqX_?Qb=@nLwhvnfGCICB^UBdgbtCTVMEHyRTcSQesEkYJOuWkY=UFP?rZasS]YvyExuCniuqSVtIfA;VReW?QEGmbv_R<AVh?xjWG=QvEcEuoEdoYH[EnktTKtpaTMOYpmwr?Ir;fr]rtmeoOhB;h>;y^CW\\EifYIlOtDOUNQ>xQwtv=HLXxXpMY^aLXeuuQLh]YiYykAuYey?lqq]wblW`UJMmyIxyBTjYlyc\\osHXA<SflJepU=axMtS[ityTyM\\lXixX\\xxxvAHtYYQ>hXeqpZlQYmJS=O=pVl]KwHPJ]lFMPZetglXYYtu<kodQe@jcHOJap;LmDEOHeKp=YEmVV\\YZYrStPX]S;YoXUUcqPFlPJynRyukEJZAM>dPL<whlVKaWoHTiUPJIrmeqTHKNAu]lrQIS^XPF\\tk<tBeKpho>LLCajRut\\UgaOtBXhAH[@h]LF[uYa\\hdWP_hq\\LpoTPeFNnGnjTVkbv[BQabW^[?ZD`_MhiMp`XAfQQ^Wao[qm]xk[EnUFdaImsiOqTK?EOgxj[wy=YowG_GVfcCOEIUCWokC\\QbfgdFqFC]gPSiiqVXEI>GiaoiASFYgRpiWqWFOiTLst<YhJSfdKVN;FkGDqMVfwS<sI:;BB`N\\^dJPa[?cs^dcid?QaAprxqmio^?VkE?f?nkGyeGP_vXf?_oM^x\\ng>YlRgdSFrgVfi@vrarJnslhjM_`RWwEw\\]^qn@\\d`gCnns@f?XlmGZLvwv^mU?m>A[Cv^QWnPfPjiYQ<UQIPLV`P:yr\\IPNyVaEpauwh]WYQYGlowhvp\\QkQue=yHtJ[uuwmJohqu=LyPwT<MWeUb]Mx\\jmxRH@VlpT=iKcaP@xJ@HledX]pXZuQHmy;yw\\`YjAJDTMqLNO]ODHjdtymtQAhoQauf\\WrpVytxy<PyyXYpRLhYYYyeuqCyjMUqjDjMLRvyYPdTwDMWltDXp_mJCXPjif:ws^W^v_ahO[p`_[O\\NQe>v^DIaVhm]>]WxfyhngOf[hs:VmKVbPag[x`WVrZoo?Hn\\frTaoC`hdngaa_Sp`J?p\\qlRq^YqiFIf]ahyWt:gvbP\\XfbrXp<?k>?[carDpmQHiENdgWc[WvVQk[ouSarrIi]?ZPQ`sglgWe<Nfx`pAfhSAdPQdDFv@gpD^drGa\\_dd`aBObGIiEVo^pvOgrgopIVsZ@coXsbgd`>u^AnHAjJG]S@eDFhHQjD@ma`pXXpYnyqG^Xgxmyu>is]qiay]eXa[>vYh[^^y]?xmyubxewHcgyufqianlE?apxhjY[]>yQhor_]wFmCGZlQ]`OrunZLIbLYjbNtfnq>xZZVks?iEWjp_xPGtRAaQ>scG[mOkhgebp`VpqQ@[;ibgNgK>jEPu_gZ`AkHqsBQfh@lSN^UN]^QpS_mrFiNvuv_yU>qgylxG]Bo^kas=yy<he_IaFvpUAcvfxNNvPhjSn`rpdTq\\hPqsq\\fhiAYjBi\\u@`mQsX^msYvyajTVZggnIxylnnS>weO`:wtDwfkhf`o\\wa[Zisw`x\\n[woxm>onPuBg_N?`qyivQ^TXv]?gIn[;IbjOcRvrmg`joZ_nmmvfLo]>ifZ^rnhhv@ibpwJafVVqAOvrNacOnVw^XQi@h]=frNh\\=Ihpi]Y^ttX`PngRnZhau<^haHkJAp]AvjhwB^oT`aVffJvkwI[GVkdawSFlRQr:>tMa]b^noGcAveNgjCYbRx^d?\\chh>PwHgpjvyW_qmHsj>xK?_^ItD_r=hdbPdOq^_paZNlb^`sGdiY[EI[?QkNWaCoo=P_:xcgNgZAfCxd]Vx<`lTO`GqkafZL`f:ikwYsSQtN__`>e[CHCil_t?cTNyRModUmHdCbrkGncGDkCV;rbYb;UIf?WscfcouimhfuSZuYyKTO[gcCSuAhm=WtMXqkXx_e[GI[;iAiRNcYvctpYsQcIPQWG[HKuUUsxcMEcKc?Ae^GhQKVXiD\\ks\\GhpEv\\crKMHV]t\\oD;;ibdmsypJumIeYnxtdXOsUvlENCpTEtsxtqEdkPULq]yuyk]qoYxyQAMYHm;arCYLR=MWdr<Ayrloxpxt\\oUqqWDWhYkTpS<PP:\\X\\YsITVxuxE=qcYoIPKpiWhqmq@Vyyrylj[xKw]JWuWxUPd\\WwyvxUwq<lVQpWttw]yQ`r:iSIxMAIoYiyG=mGqnDAVsqQVmuALrdXsS=O;qJMQSMArmtrMAuylmJ\\wUEq`uTxlnL<L[Mtd]Q?xXvuwEAYQyXytkIuq]yLjQs@YmJ@WQIPQAPkaxk=vOIPUUmeqvo]LIlUEYR`]qP@tJtmsqnpG`agcK^x?F[RqjcNikOaRY[mQbgafXw[bFqOGbSxaLIZ>IcqVZaguRNrZix<q^Av]wguZHwnvtFGtjY]G>jsvu^femyxN@uivplXdj?oTOlVfl:glAnoVfeyp\\Ivhmxa\\in\\N`v^mXHc]FtWOb[xqQF]hAn[A[uVeHVmPqhSV`A^^To\\Ook;n]r^h_pbfFpfhv<v`C^lSanWfhRXaBWst@bHPifnm_Ac`@qFh]AvqsWutXb:`sRVaapZuoefi[COqrOlvQ[Ohs^i\\QpZdfv_HwlP^lhnRfd``ex`gkx_mQntXbBQcAQ_myp^FsYW^\\nv\\p<KBjETueyJ[uL[vRQIqIspwrbmdemfoWur]yCwRk=wjIFVAY=qSVaXWiCRehgUeJ_C[QT]cSpQeRoe>yXX]YPSv]UFrtQmYkBhKHDrddlJ@VEapdiKJYpaEVg\\TJXUoPK`TMFXOETKRHuyQOhpqiYVBeoWujWySvULiUYjyRj]xmtm@ekgToQQucqTTmwaHPMQr^er>ypI`V?<Y]aKVtoN\\kAAYblt>UkwimpLWfAQTAUOUM;QeAIddws:@`jwtfGxd?up@]Fv^EabrYqynhJq\\pQqaW_?OaCg]Cidgan@PwoH_VqfAApcP\\Bf^;f^s>^Nil;wbdgmS>al@ecIpu?yHVc>YtrYvfEGAbtssy[t;[U:[rCQwg]TwwTN]gacbXcHcGDysBHMVZaEZ]ro[y\\au<cG?qcakV<?huubuGb^EieybBITFWyUyXwsI_AdacfL_wAwEtahfKGwmFgWGkcWXSgaav>IueIUT?cp=e:qH>;bEqVaeWYWT=qBkmxs_t?yIvyIw]C_Ybn;w[]SsChg[snoi=QfEwdVoXjOuTMrtGDxUcT]\\VciYDMstsWE`CBpicaYbC;HZMDKKSgQwdQrCWDA=xLYSIYvuSeqWFQWs]cdFEcJSToOU;IumUfbwHd;idUup=t@UBemErUI@miniRfyyysy=KxwiyRSuqwDggSU=dV;ELctHgwteUjwX<Mh^GTAeegUBGqbR;UUmCM;FQUYdMIakx=Qr:YusGYMsUxeGIGds?ijGr\\qvpaesSvCIwWmrFKiFIEnaF`?dnsyymxXYBFMdfagLcIqKFLyVPeVsqgpctxWUMYvwGtbmR<mV:=FJgrcIf?]I:=W[EYRCbPCh\\eBfQfIkTB=f?=Fn_GLKDZCW?_insW^Gd@mVfSvawfuwfwggdoGiQtamR>iuuyuB?sF?cF?sFQgcUHmceqYylWGuSHl[YVYYhIyyyyVCBnsgGQvUUEYqbFqRWst?yx]me_EHawVKMH\\MXW]D@ggC[IqyyiyTJwgR?YUiCp]uBGGxCGqktB]F]mY:irvmeb_sMwFQ;s:Iy:mUrexc=rlCBXIhX=XR[BGIt^IRE=r=mrwQePgVBKRgmuyQXYWU=sxkkW[CvMuDRWfjAfDeTDaBSgVxUfLuG`DNgMsA]ls<Xb=qG@oppLUTpDhl[@Q[ETRMLplw\\hJhuj<emwMl[HTA<YTpV]\\sDiU[yUMAlZpo;\\LshO^YWaaJDiXJxwUpNEPW^itLhJnlL]UsGmuVXqbip=hWlhJeXyoPuZ`ksao=AMimThUxAxUcMLMAV[ayfeU]TpHVk]NbvviuH^Nqgeqph>jeqpE>urwZmqvjH\\Xqdi?^sa[Dfeoqx^_fOpfpVu=HmsI_VP]yFkd@Zd_pfF]RyxoifkHfwQi^`ZRYf^nyuovnNl\\_pefgRAjSHwS^nigqGvlyXvW@o?grqWcE@tLF[bWb=At?Qa\\ImFn`gaugSh_U@eb@kS>Cu?gH^MIB;gK=dmuuNMDaod\\?S?eg;aTaQV:yVtkRoWhRqEwkcrOUMoTK]dqidUQHDgfWYUJcGP;hSueLSsFIf>YVrKUVAcMiDeswHUVPoXWYdaGEhMu\\MVQQI@OgcUHk]c?Ce[[HK_VHgDLUh:SRB;gDCG@?CGCfpOVVQU:sHIUHVMhNKcLqypAVH;Uj=b<sxxEurQrEuytAU^sGuab@oDTCHYMtWYrteHRsT?Qgdkh;]eQGvmGrHeEFIiywTV]wXgVXerGqBUufrodocWJaRQmUocgwUhhiIoGdMmTq_elcU@oxPIRJevlWhieXu=I@ayTGi;_SQ=hJoGEkViQRbwhjgWnmhPovlCchStPiWWqt?;XWqXkItUQerKIy?gicCXGc>]CK?c`SrSEuXqUc[iEEfMMEGAscCFKsc]KEMavlMWnkckybX[r\\IsM=ikydYiBPScCAXWMhJ=BOQwcOE_ksqAfaQce;Hwihi?VmqsW=EUkE<YXyuyqMBViG[=faSWSYGKmGKSh@KV?YfGWsKWG=sbaQvrmVdCb>]rN_gUobTkb\\ShRufGAVW]W;CxB?ErYFc]R]CTj_RVSruqC[SYlaC`kWuGB?qux]reeHnAxTKL]ASO\\XFytl<seIKD]K=ERZUtilQ?\\qxQSMTqQILUynRIqDEJ;pS`iVEAmYmK>yw<AvutsGmVpAKD`m@xyXdo:IVMipO]OYPu_hVeyycanrtPC<QSlxXlkGxjYQMv\\Nn<wU=sOXUiqKKlPH`phLVEQrO@jS=MfAxS]Ln@PV<W:PVHYmX@LaEY?@RVxUvqlseXweyuHUaDqvuSXTRBxYexorDrE@pTtJLulHDxBAkrpKNlWEeOyevdxohepXxWaYQaEVWaRQiSeauo@kgxPbHOWYXKiJjeuPiWWxp@]jiHUVIoCmT<iJn<mIiqTQtOUTfUSe@mvasnHUCDyUUyuLKMEtYUpTErtyMweQHmYmYMrIruuu=@o:<KdHV\\xVZxMUqutYtBqqciOBmoUlrouqyyJrxxWxw:ayIiynlJBmV^yRXekNYWXuj_xRXllpDU^qwZeWMyxJ@O@lMvdu=xRIaN_hTMDp>`nIiPPdQ=hQcXv<<R`<LIxVJPSE<xPdkBxxk<xFMMutqoiYFPkQPyDYUk`pceQFPVCdT;LRMdr\\LPkYpj\\xMAY`EYFtJlYVl\\vtMXXHvMtxm]yviK`lWXIsw@NCHY_eRvDVLAn\\tJI@vixLfiJLIYfHQQlOjPyNHpjIxPhpjtnq=jFdveEoDeq<dl?@NatohUU]@l<ysBIUOllG\\x@IQeXpL@X<UYjUUsDPQxmuUnTtpHLjRhOpTk`ExZuqKYqmxMPEL:XQvDKQ=sJiX>pqD=TMqL;loU@uQYRPpK@avGXv;tXWXVY@wlxuHes_XRaaL^<q;@PeXUGYXQ<xfmtuAx^issAlQXoHLrU=q:IYUmti<wmuxwdsiDRZqRPeYIuMY=Rx`niHMqPwk@Q@mkFIvDDxxAwciNFxMRhJMPv^qvTptAeLlylGhVk<lChXAtph<jeqpEmKFijkTMfXlYYu=Xo\\ek>MkgAuZulcMR_@x_@wR@koTo`YxRpytyT[PKZ]XGyRyljbAr:\\kVmMI\\quyTJ=yayS]qpQxuHPT>UrtXspAv_yYsILvTxsxs\\lpsUKhUYIyw[MxCyNKpurHTfuRg]TLLq:AkNuxQIqf\\Uj`ws@QFDpgITgMJUMvM@k^TY><VE=NWPSZDmFEs<Ukb]TM@NiExGyoAmyoto:TurLkX@U>Lq:tOtHnE<LRDJMePRdl\\lpUTkrTUcYrDpmPTlaUR:\\Q@xwV\\JhPM]AS@aWM@XyxTc=nx\\U=lYs]R:HLfDO\\yJVessqWGIqiEjrao?<ne=JFtYOPX]YrjtV?toqeOv\\OOhJV<mGLJrUjc`vbXWXHQhQJVimQiJQ@OhTWGILmltFQPPiVo\\U:enXErcqlXApKhKqYPj]sehp@aSqqQt<RLir@IXEUrGavGXW_tNklQIIUqiPAtW:iptxsbXuUdtpIUoEw=@YR=qpIQjmu\\=Ks]mDn\\Yp`i?nP^mUYi;XikGnI_itQdegtTpkyOqqA_H_cQ^byAppnxfv_tQnQoaoob<>qY^aufki`i_A\\nVdqau=Xo;^lCAq@Dimu];BVATq=ReQBroWu_bZYUjuIVIBBWC>ACDwt_=f;kgN[xIkcZmXyqIvCxkyi=Ar:uIhSYgiUJMVKEsbgINcc[atcDXWQr<lmW=m>Mjc=qoqtQ=Vqiwq=nVeoZtplPjxhUu@PvetOAmY=m@asfaVw=rexQZ\\SQPQiUX?dSPdORLJtlxcTxRIMulkX`j\\TkeLlC@QLLxOTpvuTcPnK]yPANPiSfYkTmo:eLWDo^UKGTudTk>yYEELFDx_]UOeQ=xrQxp[PW@=nBHrjtT;@uydU:<qBUjEaVfHSutK[LQummmAwEIT]En[\\WyHrw=QultP\\qktoi]JiEL]TxXyKv<n\\apk]yVylVtKIprSxOSuqxXNVilqqvP<ng=jVmRlLPtpOmEO?Lyh=OMQPydkBpnj\\N==pw\\TwEt@LnkIYfPPutqg<JFAyIILmuTWQPIpNZUXNEm?lv;lptmsv\\OVUkVtpjxvOXYO]YUMYCqpj]Ww`V;YM_dSPaJ:XoCpQEpN_`sRUudMo<\\XkPWGQVIQWODpxTSA@XG=JHandHYMLYGQohmvv\\m[uqZxndXYq`X;\\UqhUR=^vVeDh`f`^UAcJ@s_QmfO_sNs?QZLWnu>tyQoQWf\\IjY>vKx[xyh^NiuGdKvmqywXikWxaoq^^Y^dnnHgm<arSX`ROeT_rRAuPFyqarCYfbywY^lOwo_PxD^[Xg\\:`__Qu`HkSam<xjHax\\vdMAnD>^SYof@vDatK_[`fZrWwGQs\\VkRFg@hbnFy\\veNGcTN[jvtyimA>lxOxS_swhyG?og?]?_bn?tVgpl?yBHoe`retoUu@qDKmVMAYlEV]_I]crdsr=wRskwtOTQoWI;CnQFGCVHAEECr`EBtmG;kGHCbjsgCgSgeBVQeqgrPEXy_t;GU:Af=aYZkC;=bCyDYWx<<x:HqtIXUpn_xm`aveIPiTybILqhoyMLZmxHauT\\WheTV]to<uZQrmmNimuCmvHTLmlwd<VZiKv]LlAn>DJAuxkpPEqY>DnKAlmXMJxPQAPKAWOeQKLJPQuCyjjXS]=W`XwDMtBerLdnQ=lu<Km`J:ytJaT;luHuxiMrQqouISvtPtEmghUBQMX=qe@W^DX^XM\\xY_DS`lSBPTw@WaAsJTLflsfHkZHpr@Jx@qbtwceNUyJ_=WB\\kXxUk`kFIVPeTVMSgXKZQqgau;hP@QunmrfHu]XloLobQMspUFYnjmTAdKl\\Y^`tQXNcej?IyS]xYqXQlUwIvI@v:ypyVcI_a@`uVa_FFZ^pgvYnI>f=ihQYvuyuwQadgn<ntIpkZAycXrRyijI]CnpBYunvdR_lXpn=Xb=N\\vH_HAZHVcVgpVg`Kfv_^bOg[?W^HpyRo[UVie?k`xZ^gnfOaW`p:W]OoZdPc=_jqN\\?_yRI_^owy_\\ExgvIdR^^OGfINrTpfOOu@iZjY^SQ[?G`kXZ_^wW_`Jo`o^f\\NatWnO^deHdcWa?at@>jkY[oqtIWqEHgmwjJGmYq^EhZNF`nfd_p`=`p`HuqV[[WxTp_mxwx@fPgjh`ksHp`OkepmHq\\jw_kow_wbW`upnrVqZhqkjaoeykmy[agh=whNY_wfqBotkGrJ?mIygPXa[AcQ^^oOxYAZQg`fW^>PuJYr:x^YnkSyr<WujfeTQ]FHyfoorVx:@q@Ia:^yDQ`oA\\d>iWhtm_xqWwsniVi^TYwlodZgcLW^xvmNwukA`X^evH\\Ngjdyha?xaau?DhQDK?D[WW=MbLihdEEqsWGWVUmTQ?bH@rTHP^ATWuqOtQreruALipljUUgPpphYLPu<`TblL?uSV@UrLO>TTh<Q=tVLTNc<jgHNpXUuLXBdp=ujZxQjYRZMYDQwmUPS<O=XRJuWwhKDiOqHR]DNrEPStTnXSAltnEJVWai_sUQwyx[pat^GjkHbBAd^GpN_rwxusqZhPqlQiVaymvaEPsIgqKOwcG\\B?NOyVYdIGV\\MvNKdCaf>[WC_RLmYImtHmSa_RxYf>KvBgCmuWEOxfYtTeBqgCi;vkGw;[ehkCB;BQ]RfCd;]IHmhEETU[iSQHHkgDCRG]wQmwayY<crq_iHKY`SC@EfBseXSEcEY?iRaCgQQTBaTE;uVoU<eRa=ih]VCSiAKY>qY@]VkqbT;UoCu:[UX;EL[FeID<KuvAVEgbl;XG_Y:MBcofCYbAydJkBHwg\\qecWBI?bYkHaAsmSEr=x`MTa;GVOwdGS_qHliWrEGr\\SiiUAYJpxs<Eka@lj@netMHIs<TPSHuVtxgMk@MYE@MvUtT@LJ=JUMX><xuqMnTxkmqv`p`XRCtQ=`uMejTQoBLnw@RCinVoy<_x[vhfQc[Gf[`k<GnL>s:whPQ_pYggakZfcdV\\CfdFocM>]fIt^FawGnsg_DfyPW[?F_riexxyA@erYlyNb^Pd;HmM>^OAt_>oEHmVolrhbiYyhNfyPyh>]yfx`G_Mf\\gQZrpgeqpmyZYQbQxgeF^aic`yhRQlwwjpQvZIlaAxlheu?lCaxRWrC@wnosF_m@IokE@mbACtQgwOWhDAeGQFBeyiSUigsKtWc=jsUrKmjf<nZAuW@Q?HToML=HwBLNCpMC\\q\\`leqv\\]KWhuaDNL`YS<QK=SE?]_i[Mohr`gl@oK?_on\\I?^MP`jWsbamnyvFgro^tFgZC^`eNj>FgwH`j@ZJnj`w_MwaJQf[v\\[^rwVj\\f\\NgbePcWN`PI\\rWeeiuM^mQn\\NgdD@ZCV[qywWG[uAx<X^P>rfNqePiwvxWxoZNZVy_gNtV_sJaocIv<GjPHZA?b_x^mGqJGq:vmEhceOkyWpjGgXviNxt]Al_q^QAijhrOxpVNZ;ilcpqoQxHYn_h_;?w_FZXQwf`q@@gfN_ENnVq[Yv\\]HtmicM^tR@ic_v@OhKn_@H_tI]\\wuDwxyAZEwiuy`:axnnv>qiWvoPAh@?ZuPlrvbCFhHqj>a^tWtVa_pny=y^j>iwikB`qfws_f`PqHstguvQCrkoCPWV[IykegdWtr_DwiTKgwcIRk_ULGfKEWe[R:qsnOSQUh<;i_KDCCeUCfbOSw[u^abCavuerlQI_cCr;iR_GtaeRmIOUc[CDQIDEGEBuf\\OdCYc>UN?tY?iVqeVIPpTPsklqbHvYqm:LL`eJy@X]pkoYMMiK`Tkt<W?q[Pvi]GxRNdN@`VYd=gciHbE@[j?_tn^cFg<Wskovwv[xvkNqf``sUghdynhOjN?vRX[ZFiRA_uigvnn\\U\\EBY[yrYRresgUUjYXykY?euNiiOohYSVjaRQIeeYHyysv_gUWU>AeA;HimGJsvNEUlmwDIfmQh^mWjOtLoDnav?KiPkXsgCrIRVeYbgCd?S_quuitKgCkot=MUymV=Mw]GglUtDCf<qCsKiwsRU?RaSxPuY@CwaIYDkGr=bWaImuDk[X:SifYXemBBEdrgyQeIBGHjOt];bLOIaSd;wD;uTcUiy=tmqSO]wnMiBYvsewF[usGuaKeRMSJsRTOeDibOadMOVQQVUgvwwsZ]ywyw=GdEIVX=BCYTeCIj_TTSuXeyTCg<=XpMV<SC<[iW[DyuwJSySyXpaGriVuMB>]gt?BhW]HF`UVgmi[eG]<NgOwoBi\\XwdGyjNh\\[O`YI^MYl@OaMPjMxb^@jOiv@_`?glXplHoiTPfe^xdnp;gqQhkkQZQNZJOc<Q[oo^LHhS`\\Fo_JFcLImMadSnaowkmq[AGnQQgbnlF^vG`k^PyEhn<^[]n_pI^\\g[jPk_OeIVqmqkK>jFA_lv_I`oO``SNrBXcJ@_uvsth]PVxR>uANu_g`simlv]bW[kPt\\__v@d;HbPothvoN?x_XiINfr?`CxpyHZLIk:Y_wP\\Bps=nor?`<Xg^Ql?>js@\\wvpto]Vhq=f[:^v`OvRxjfNj]?vhYtBYppvsT>fBnaZyvHIcmwjigeO?ojWjc@ZEQ_Injcxv_Ix@G`IX]PGqjykqwywwvtpoa@whNxb_\\M_t_Icr?hwQjew`vflfpuwyjaAarxf??bbGp=W\\BWgpfpy`veF[ofctNsJ>fDaflNtENy\\w`ev`QQtUahnGai^dMirwilu?y[^]O>vGflDNk\\qyGyb]?q]yqwx[wPZZHm\\aeGy_iVvlFh]a[>Y\\RG_P>hdy]xFjlHg\\f^X_lu`orhvQPq:noUQqgg\\fXude=wdguhHUY:kcbOUwChyoU>=v\\EufOr>[bdWerGr>SVXuX=KBB_BZAigkbcEY_MgpuB[ib_oS`=DskRB[CakVCof_sD\\;r]cF<SGdgVHogr?smSWYcD;[CgkHKMdmMebAIOesHig==SXOUj;u\\mUfaDveB<ktAQUL?gfoSJafMGD^KVTUDoMrRQUioXJihZACLycgWHYmEv?r<SRGEbsyThwHf[G:evP;RheiEoiw]VG;hbMBXaHx]HvYRwECoeSSkVoQB<ktBKUtKv;qeE[sTmIQcsOQiXmtLcGB;hOYT`;CmAwdAvDuh:_xQ?ClWXDsfVkFhQVlwWXoiOkgxax<cH]OU=GWbAU`cr:WTa?dS;E:ERq;hgyRy]CUuulqTVyxBYFRYy=yEDYXp;Hj;cemgvOBukxVmc;wCxibvmeFEBrAICEBWMFk;yh;beqhmQr;IhO]yDWbqmHIsv;AwhoeIsBnCbqsegYB<UDv?UZkGlOG`cfL?hPACwOsJWWBkB^CU:CH=oHFOIQYF?EH_GWs=FQcrfEh\\mSU?hxCTVgWjOYtEY:Kgdeemmtd?X[gGWIEJ]H\\kx__T[Ci=OEtUHkEYviX\\?VoKvx]sqQW;Of<OxZQeMMy=kxwgRKURmiF]eEVWD`iscWx[cdJeEq?bDcSqSUa?s<mbZ_YxsUo]bQqwZ[V<KDjMEZyd>WXF?w=[bveYFGeIsFYWDrwDteItodSmEZ_hP;BQqD^ExOiVNiUfkxDOGjexVQCPsCW[B\\IXNMS?]Rqmw<qhYEYQKCsQB`wrAIH^;RWChOgflEEI?C:uXnAx[]ivqvU=dBwrBeXWCtE=wxGw<;ihUII;IHwbCqi?;Fvsi:_WmwxawDyEHYeB_=XbkGnUx;CIZIVtchhmTHyydwCyIBHExN_bfMeGGDJOgXegHEeuucFGiF?wSURy]ghCV;YE:atMkBoYu`eHWWIPKUgMsvQHhky>gYqWI=wSxYrJOvX_Ec?Y>qVbCYborVUGFutDgVCks=WvHAENAyVGXY_vBUrKAfs[ddQx`;XwqgOSTS;e=sBYEd<[i[yRyWG=KwhCDjQb_SYsSt_IEDOYbwdAKVcug^?S:;D_esH;Cg?vPUh@iU:MGTeEBiH`SFG]w[_xneh^ATvgdhGRmyg:eTt?VZuYCWbsghnsSyWViwfX]W>qU^CfdMXxGGN;dYyxf_cB=TOEW`wiYCgkGHvSyNYTRaFxqxpqxDaEwOgrqGikdW]UV]rkWHaGHv[IFGfKGdEMFnMu?;XWPJlMXBtKYMQ=`J]EN=pQEdNlMRq@s<<rVUlJeWeevZmvm@jlQjqpPF<ki=LpQKjYPipOXxKRMP`Yyf<mpUK[]u<@pN=lRPPeuKpPR:xLgqUfln<eS>iVB@qCYyln[@g_yYtH>_rvhKNbMvh=ayZqsUXk_Ihf>xva^>>`>^fuV`hix@gh=H]XN_AH\\Zy_J>rPi`Oycryx[H_DQwN^^j_pA`fLwjR^ufgqi?g_HqEA\\bA]KnwW@vvyk]XpmVpTx_uhoOW^QhjkIu<`hE?nmAifOh?vJSGRwGPaf@kFOwsa_rbqix=FHGfXaB@qbM=S>eHsMrqsc^gV?cyEcgsSDJOs<aIlyRHSFh?W\\AHd=cBwGDSGEAgRkBpsWSQbx_WPmbJeXWudZkgVmGEyxlscjkDeQBroWeqhmECYQr<eYhEUJoFs[bjkT^[BB?h`KG<YC[QbRSGIMxyWcGUxBeHjovv;D`qgj_gaqu?WiBCY:=VMSwAQbS_H`QbS_gSysNyCrey?UCX[IeQBP]daUDKAEFCt;YdWmCE[VUaYCgyh_B<MCeqItawS]guwVy_CGSIOEd;=HUmbCcRAUuqoY:stfsDKYc@GCwUUbkE>QiSACEWibWFi=ROyfNmTqScqEhy[uwei=IBk=dv?c]SDFshcaI]iSf[eU]GHYrZEYRUI`<liMLthpShSQ`oAUrRquyuwsAluXSJ<uWesDaUtPYGlYFiT^AvHypeEr^hjPtkLlPqdu:`tGAtsEut@TaxjhdxPIXu]vsHMv<pyMMI`MTXRx`o=eX<uo>AqSLQLdtL\\XOUR_LLqam\\uRbQyOxThXrWtTH@vdiowMJjaRX=PAiVTiJBDyCIS;\\sd=STiRD]N:pS:elRipoYwQYsjIoOyPRuJ@EOelnWXnfHuT<XfXm=ttgeeo?egHkMGw:`oDVjpoi`OsdAnfQwGwa]arTHc>ps@Yj:>^BQeavj=y[pAvANkv^^EG_V?kqh^BgfgOpX@em?qnH[fIq:ytFQb;VtmHiFnx_Fp[ge@OZs@dZQv]wvbYaTHqyYry`aHxirayM?oafumwyvNuGQ[k^fANprarCX\\rWlwiiJixco\\hifGhfU@jVx[R?`iXj=?dBFt=h_VWudGeGfwYAiZGx<XgQ`wv_d:>ZZ>ZC_b;_diPwZosWgldisYWhYX^ighbxcuns_wqOa^IX]tFtkqeAowNGvt>bqhlWidbGrA?rpNw<QtPIxT@[pGfbOi<>ievsQqgewtPNh__umAu>nqjArc^vD_vO`o\\n^S``eQ]QVnC_eq_xk^qmYaY@rCHlg@yYyouw`DGp^^`Ln`qx_VftkyuuaxS_a^>bZqmk`_XiyMv_=qr;at?yfYafryt<>h?Nl=F\\uagDqy@Wbn?iROcpFlvPkNpd\\gs?vfGVosnt_?vthoUuGQso_EwSBx_Ve?UXwh>yWX]tZytcSx[Ih`iybuTB;rTaY@ADVkhfuDpiVgMxoAUU_h=mVcEiwEyXYbrYxIcYIsIyqxU;xKwItWCsivlUemKuRUgMoSM?Sb=S^WvgyB\\MGBaHsKxEGIv=IpWBqacg]ry=iwihrgUZ?xdsCCce<CbSowXmXMYe=stVEDUae=st<cfs=VaSV;CdGqFPCg;oXvOfwoYNEs=xvluYH\\U:etbUjKXXCHxt@RPxYTArRUp@iUZXX?xoBHrW]V[QjPpuWpWSEqT\\sEiPU`uuyupE\\Oapiwaknkihatnk]yfmQ`Ao`gnm;Qm[GiPPtSft>Y`_PkaYi^`q:XsHww=OoP_bIPg:wt>i`iPlKiq_veHOn^ad?ocfYak>iOfiynihqsg@qxwvJY[<^rKYoj@qBPnh?nin\\KVycOrRGePPc:F`UOu^>glPhcFjpp_:dgif>SB=mdbmRDEvhYBaQXi;uTyt>QbDKHTEsS=h`=eEQryuRW_uDmiDGuCgVf;CZqJPLK\\TmKeN=eRF@M_PVOtYrymXEjqpuoxJoPmhQL>hW@LlnpyT@yGarnmKEhRlTmPAPvevb<Yg\\ueIpShuDDSJTR:xv`ujlDMGmJqIJaipsEYiLMdelkit\\dTy\\krQR:It@@tSaqg<vhuTi=uvusjqNaej`PwSyvsanjYxjaly`xUtr;YPEAQ^lUyaxWYVbLKNlLOan:iNdlJ=qrXTLSAqcDRVmN@\\xGPwrPXPQJrDoXAMx]WqHjSds:QTHarLEstmYDeP@XPEqttLPC@KpymTmrYxY[uMx]w@hKrerOTwjXVwus?uJjEtXpMsUaCWsxVZ@Go^fxjfnVQs?n\\Onw<>qhWq>FnOxsrI_:pp\\G^=nfaQaJ__vPlNyl@nr<PoHWwfbncv;GiOyRRSW`?tRSxissvCv]mt^_iDayvEcisrGyTgUwQ;egMDUiVe?s;WXOeOMPj@ALm<xBpnndM=xMfIYkeNMPv>ip\\eJQawXDr_YYPIlipLVaRQ=MJpq[Qw@HttDw[iToUP><mlqnMmvIdm<iTOHWguluPNVpovMPY=U?XqGPW[aTxQptIpoHrjmUQTJA]tQdshXKP<tmdQEYQe=KDIj]qO`pocPqOlW`xsODq>=py<Xb<onYqP=YVPM<lvwdOEDR<lpL\\v^uujYJeEs<pJOHpjpT?QQQ@LrUy[qum@yUyWXlrNQTSdQCAK\\ILOLq>TWVTq@\\XVUPdMVZDKSeq<]KOHmG>t;Wc>WJubgSFC]WBur:QgOCWKyRpaTsQGAYv]QEpysb?GdqTD]RsOW\\YHqie>yxXGe@yGYihWsXVeHtET:[HqGubIdemg;YtNyuBgy__iSMTeKdOGyW=xPiBjeupQRZ=sTuG?QUpexfgHc]t;qxS=bS_T:cEPAuPSw:uDLGfCYVl;bI[wBUregwSEw^?HOxTKMPndvfYppQqgmMkPVU\\wNUW\\]LKTNCend]Zo@g<g\\xhtd^sAn]T?kohpD@j@ny`HsFnu?qdhP^AVko_btgj^hxqHo^awBHmlwiSI\\Onrv>jIYvsQ]NPyPnfN@tDhp>?pmfqypj[a]MGhQ`fU@mGY[jqh>Vs?Q]lHob``Nxnj>gyORQiWcHJCTPccD;X`gRKcc>]f:;hTyI>_TTQVJah^MDSIb[[TMCCckWUeDiKtGUScgHVqhsObkoUMscGMWrcif?s\\;cX_f@Ge_QHxkF:Sf`kFquhKaBgQFk?XciX]?Sheu@_u[WbBQt]_RT?edOCHMwbIFWkcuMhpEfpYx<mWiWCZQigiRGiv[GRRgb:Yf:[eAQI:SS;OhU[GNSc>KY@OycYCPIvKKhj=hAsIuqbPEtYmD@GeT=iI]X:cDwARk[RfAQp]pGqXrUTVAtEPmT<Yb\\J;<y;AS:mNxxlZLwn<qS\\K\\]uliNf\\j:PKAeOgllB<paPxlPkh`UrlLXUVJ<o>qvYaOiaxH=KxTWXiYXeNlTw<DqPhoJ]oZYSIdm@QT[pjr]T?XNgqpmxu:iSUdKf]wQaJZHk[DmDUNS`SBeSnLxfdt@pjJ`s^]vlPw:AJtiryiXkIq;=JhPU?EoNMRs`U;EpJXrP@S?TrSdMYqQdPvJamDDpSDqgHu_QKhiYlaOh]uo\\No=uh<YyxS<pv^anjHWFTpuux\\]OKTj\\<jaHTb<jCXVCLmGILm@UMtrbMk]]kB<rdHuOMoaYnSLVULQshQJYrBMn;Iwn`XeIqReoEISpUu?uWvep>`LUesQ\\WOAJ`\\XADUrTmQQxqHJ[MQpPo=]W_`kupLHLpWTypptmmv?xmfepyPwN<y\\<nJTlgpv@LKUUX=dX@puMhw>Lo=AUvlvTQJELrJemf`rqurkhPVuUyIUaEVbhqh<tRIrwLuGyTutTgEqJErYyum=MquQkmLk@KM@vG@PEiX]PQhQucXKjqn\\DldiRpxoITJ=dybywqpUSaWPdq<<v^\\J:HlFak:dLcEJhLYtUY_@xgumRmmPXnYaxpixE<xQYjXaXVtXfmPjestPmvXMcUUN]MkaxkiRvmxuyrh<qaTo\\TX`UWLhQVluwXMmPJjmOL<QtLY>tVylyq@NyMRDmSZPrbLVvEw?mqMitDeL?YRADnaYKjts]qQMQqeHyv`LTlvMTLjlTPmOtxWgul;XwpXxBUm?@pQEJFALEdM=hYxtm[\\pOTxILlbaj@PxcMj?XxtEvfHUB=Ul\\TiytYtrnevqhjxujZayxpvqqY`YObtJKhjl`XxaqutysUlMxULqYmMxl`QFAMJQQoEkoXjhqQjUvgDSoQsy]P^lRrhS[itoLvr=Yh\\mAHtmym]\\PlyLS=JrtXD\\NTHUrtmpaMTLqmEjlYNhiNcDOUqs=XVhtNCtmWMW:=Mshjomle@yoHvBELZuxO<UgDve\\VjTj^QTTIPR`oGEM?UVG<U=DYqQthmNxXxNaJhqYvaOLLlsUNadJHXUAaKVQpgLkn^g\\IsN`Ze_n?pbiNfYa]Yfdsoh]nlhX]MvyandHXtyI_vA_hYZ<vh>>aB>uOVk?GsBi^MXkRNwg>naaj;xjIGeh?`NGntirAvrk_wfo[y@yTh]RQaTYixyjHVyRNc<>lOh\\OVqhwi?n]YN]@YrEWcRimNIh_yfyiZsxfqQf^yyswZLVep@^l^aFPtKYnbfmrnkvYhIIftInuIpsyaxq^pfqkicGnpF_oE@msNaQncxNo\\nmqNZBpcyw_Sf`kQniIkGQt>uBGT]wsCqtE?RUShysf_Af?=HywXikfxawI=hcyrYAbXwXxQHFEhWKGj?Fpyw<UYjoX;[UqgeQ]GqETp;rJIfXausKILktVwyGUv`GWI[fDSw:;Cp]hE[CfWVH[bgOVoag_CtNAEeIYWyVp;CVShOue=Ax^Sh`Ava=exQumAEyYehYDXqb`UC=[VxgrFyvquUmkcH_eQKUfIVbiT`qyVCInSScQxOygvaIvSsQoCewrgEhcYbawDkihAmr_efccUg?cDIxDgG@kgWAgBux;_X`wRtgC^MHSCCVatZCUGsMvDyyTYSdt@LXnYU<tYNlT_PvAdT:PlUypg@n`]Tjar>hJBDsPXwuysHQnidM=yWwHoqpUZ=XxTMgymdlxgMWlMLulovngwwtiHvexyoykjamRqxB_b=oxKybjnibA^rFZMO_TA_QhZ:Wo\\vpl`k<@Z`WfL^rTWyhX[jOeUGe;Nxs>`;ndChq=weY^koWw;iriQ^\\Ay_Xw=oaI>tqa\\`h\\ail<Apd@yhpdb>eli^>>j]I[bQvuo^`vodHg:wmSPrNqua?`nhguNi`on[OkeWd]>nanpI?biX[ZQqgibTY\\W?e>>ud?m_g]FX[[FtGwoDFcJVgQqbI`jdV^oWdKx_OG`JfdGAb[AeP>tcq`EGjnO[EPrKVgMXy>v[uIerqpnQkHXsq_[[y_x>xt_eoXiR_shgkO_vKgp]yuTivphZ=IaGg\\i@ody]GV]ewvxxsV_`Pvv`Ngt@moVkMNpRFDSIQSg=MHhGFW?f;kG\\kBJegx;rt;BPWD]mViWcmqbPceCiSuUdVMc]ST_gWoorWMbxoIvOu@;w?KCrQi>gc=UDWCYESujsENWIqsCcuvbMiEmh?GhI=rDmg>wsxuw^kfQOGBoRNEwvsXUqVE[i_STS[xnqV_SX@=rEOCP[DUmT]egFuDkWXnyhAut_iXk[BrCiwUXO]UZSBIwSbOTnYI`keEWhEcFNOG_]Fh;DjCSBWvMaBbMeWWe=iXiAy?]GIasZIvIyYPsUXWU:qx^MBUuvQ;fkSCr_D>aCsMUvsceKBfgwvopBaWWqJhxt>YXaEPdelAxM<ayauy?dl_hNk@XHDuWXQKHq]iTZyQkYllUU>LvN`R<DyApM>Exmtm<mvqlYMDpepoKHqg]xbmLXDYR\\yxxw\\DxetwLtmYekLIp]@ovYxaHrH]M=PlgYjh<RVExIpy:<qwqK^lYpiwQdvXqw<<qhGhsy`q_mbXvoIppwg=>eP@^QijaYiNH^e>v;n^>__RAZfX\\Cnp:OkEhjWp[PN]YfnHYqVG`vOi`gmOGaNariqhhowAywwXyONf`YeOhlb`koP^NfyXpognodvx>ftvXZx?\\XFfPXo>arfG\\YgqyAaHwc_Ywl@_VxjIq^rxskNj<Y^?GxSqsMW\\rhd:npcildnauyguIn^or?A^DWj^Pu>FawYwjObrpspAsX_gZx^@xdXW`<h_]H_rng?>[j_`_oa=Vy@@thNbdq]<IjhYx?vbGOlm_a:PgFNkiQr_W^pogYPnEonSpn;x_w^hDvkWVeN@vgp^ehcsnoSAnDQb?`cIw_tOitOw[Vd<neIyjGVltOgNN`NviC^\\LyeDfoPaZjIqgWc;Vc_WbPn`JGd=Inki\\vWwkH[vHx_Ym?intvyjGjHx__nxcGfpo\\CFxFnqdyayx[eqoxP]qaijyq]Ghxo]MOfS@]M?\\MvsyHsbVn=ar`FZhpgss;[xfAu;Oe:SXD?UAEvCyFjcykwc\\MwjIFfKT_mWiuGdwxVYbesEr=B]ey=;Vi_YOgB`eBRksGee?Ieuui?gwykyMOD:It^cc<AgEUGe;IuibIIvlytxoCcWeiEdf[uMKBNiGY[IBcSVucwMB^MwAucZUUsObEyuxqCeMTqEbsWvh;beqhmaS?iX`SiU[Rg[Hs;ybkYHMWOCRusYduTECBQmDjSWGSscps;UWpELb=pr]K[MW[aoSTWpXvPaY<qXWDQm<uuIli\\l_HtoTK<lYXXtZis_Yny`vA=oaYsXiVRUKQXuO]Tk<PI<leeWFtSTmX?QpHxQvYyyurXYNmMTJ=q;qSomuwMTAeUMTjaYp`eLIEV>TOseLIiQwdJXDUPTjTpVEpjlpLaipSYVDpxyLn?=xrIr?\\YjyTiPRpTLohYTDY:IQ\\IvDDNh\\w^mpFYj]Uo]tqwejLaMe`RYEjxaVRel^DSMylv<lvqYCYJutNfDyoyjIAvmuQvTjb]TOxtrdL_AY_qK@hX=YJBeVf<x@EVMuJrhmE@T`XpXtjCXXRdqFMW?ttQtlkMVKAls<YNxKqIouqSC<TCIxPXuqPSstkmQKB]JjMMT\\MNHyaUyH`M<QtlQKPyWUqkYMyayYO<jhLjD\\OquLthVBIm;PR]pjrisD@Y`qKW@QChkeyt=AuyxKI]yxYY^mmVitYMyTLWd@YPXvk\\shyuIxnxav=<Oy=yy=VuGZZQoeGnC>`b?kiYcKA]rfoIPriPZFQlj?hO`jIYnkGmqqnQPsBxoUfrGw]yyerfx=x]ZAxYpi:Vex_ya>pxydxgc@hpePZVItxXoQ>^Nau?>hWUrmyGGfo?YUUgKgeggVeWgCsIpMBASIiOFo_D?YE_obH=epWtSIUaCTGqTlKFgoXNwg@GG_ewIqTaiB]Sg;sB[qVGmSm;GvMhJMdciI=YF==T]Cx:UIdot=;gCME>;GQOhrmfL=dLos=CxN[HKIWmcHL[CZQuFKc@oU?mYsEDECyD?EB;Yb?ECUYT[WOyUqCdTYguIXbgTwuBuIh@ss@oWvct@;X`_tYUGOaS>YVT;G:uYMqRMSYPyfJoDZiG];rUcDY;iw;Ru[Usurf]EkoUngC<Kc?CxyYsPyTkewFmCIgSJ=iOGfVUHjusMWTrewoUE>ab^CXXusCCbCMCKSTOaWxsIFOgR_eW;Il]Ba]B:guxGYm?BRGgtiGq_TgOVs?U>ay<Qb^uFAeBrUc^KvrCxowgZMXYqUVExeuiHoyUkW>YFIkIBoIk]cQ]yNYejsxowg\\evKwbJEeXGR<GISEfVcHQMg=cSr_Tu[IgMusui_QW?SC?OB@qHiErDqr]QhRWgQOGyuhferSibs=h_gRF?cw=SV=vu=gE;vtgw?;cvQrMMxuSTJCVWCrr?RpWgoWXOUSDwco=V]]t^AxOKiRQEHIrd=xkuBH=VfetekVgus[Qe:yRJIG^=hMgisKTSiXBexIOrjKWe?EZaWZgWT;gOWxJYg_CI:MWk_b>SbDCBrCHusUG;D_kth_eUwR[EY;CDO_Wy=UZ_R[QgcOh:kreWVlUtK;HXUCPow:_eeerXkBVOxhkWmuuiKv^]sicDjMS:gFDsTL?Tiqxxmceqrf?H\\MT:gDqefcQgTcvfgXrYEsuuE;bR_S`cvmCThsfkUtREB]YG`ks`aDbMBFaDDQiN?yJSGPWdMYxCQHK;g^;RsKItKGyQtxeetcYTscvkyr_VGifN=COUsDwinmY@kB@;h[Ur@[xE;tA]wqEVtMUVWS=CTDShPMgRGDyyfVuTmoT?MRfWXCug[OhjsFXGX_oC^gCheTQYXXAhnQfQGssgseWdO?VGcV;;EoEhXSbVeVFcEsgv_CeiwHRyuiss[dut@JhXuXMmFxUU=XnPmYExHEojplBHl[Xx_UJS@ckamnOxunt;Vspo_thhE^r?f^BYiEH]FW]cIwtg\\OGZ<Ayd_`S`]QoZdNcjfkt?[Q`b;GjD`yuPu;OkcNO?VsoS:?HyigMIE;iXXESdoc`CEaAWyKexut?uWxWD^MvZIe_[wuce=]G<MDT;RyMS?ASYMBkaRDMbQKBiUWdkTbIwKOx[Sg[miVkFhCdFEVB]w=Ys@WCR_UkOTM;G>OYnMX?]YH=FIEIi?BHotGUy<Eys]BD_VX]e:Sh^SYl_hn_bd?BL]hoMBpmSOmG;?Id;bZcGsKsEWGdAdFKIOmbH;CjeF=ysNWtD=VNuH^Et@cSJAEfcgwSbtYBuMr?iEkCvR]EtgC^AwqISkmWbey>;FcEYLafEOCZ_Ir;IBoEkwCePlpEJVupw`t;qt?pUYuNZQvVuwfTY[`MVuRWdq\\TrE\\lfxWlAjVuRPIwC=YxYNsPNoIUN\\v`usZtPqlqDyUmqJMtRotV`HwZ@PUyNqeoS=U>`ufDq@pT?hpLTQtMXAau:Qo=AX`tjAyvpHVdex<UY\\YqbhObQvWDQm`kihQtdjDpsKdT?<MJEQ@PY\\LTh\\Nc<rE`pAQUeEr<QMxUvj<Sc`TTdRkxKQqkS@Qs@U;Ix?<nRePkiwaxnkQpGeqbocXxxmXbZhlHxmpey_DXiF@;hLEgNirmUFpgbRWx\\wwCYxOEDZmSIoRJ=UTmbSMG\\Ux`islEuDmIASVtMSdUvccYwQHIqS]wuCwiteT:OrToG;We`ksseW`MEsWbA;T`GCXshpybRCTDIBFofMMVlyfZOGPiSFqujuy:KfKcghgrQiBjeupEc;OIpQbUYfHMbiGVBgFnydXKFIgHq=iW?HTUgl]XZuvHUyHqgvaUVmG]?ThGfywHH_RFUx>WIUubYWecOSHYIAKXhmwG_Fu;G^ax]sti=ry_um]B?OToes:QUM;bnKgo[x\\=GqogdWEpGvuSUM;f`GEwiCUWyKsccGBZsH:mX=YWTQcZSYquHrWVeWI[uGJIWVifEKwf;XiMV[Ei:_YkOFSeE<CXUQy;WUpwFKOsnIsJKwTORaws=gxl=RKChTedDmDKeb]qvOgRV;ed?fqkgZ]GekFEEyLKtC?g?qWWwvwUXDSGB[rKSHbqCgMIYYIuqSYgTdgTNMs_]gyesW=cxxlj]vXyW[uvqlq@hkyTxmAogtO\\AuAuyDtniIqUTjqxu;HnutUC`uLQNl\\ND`q[UJNHtoAmwQc]xfaq_bFmFnkv?yiFhtYwYglTFi@hakghhxbdgy@_d>YyLIn=?dDFi^vZA@dMVw\\Gk>iZyxlt@ZhXuX_bfX]u@rUYaQ`pWVaIw^phj;NwsFa]f[xc>YVrAuYiI:wYuQwm?yByevoEiGYsqHNQg@QeioRZ=gNYH>yByuR^EEGKYiaykyd[qxewR[WC:irveT:IRlMFGcIqSwY?e:CbAurQ=xCwgV;RcOgEQf=wtXAi;sWtWVEKSOcu=;HsggesVt?eosvmSGqmrXmsnoiScEFWCJGgJmgmiB;KHoYvYUrdssI=gpeceaVhsWVydjUfJkuhGt>kYsqsx[uwavvkEycT=iTU[HCqWK=UhQR<wHy;c];r>Ei_]UIMcCMUKsdI_dkUxPkbUyx^gBrUhRyXgKbEkiimsxiBCOCussYcfx[k`QMfAycxP\\asamyCtjy\\xy<lw]yk\\LI]MAIvAmM;apRhUWeypxm?]S:\\vSHsC]rMHS^mrp@Vt=W>TSYiyhLsmTPbHMt`OF@SVIxD]ovuvUQv\\EwXiWSlJP]RYXPm]wRlKyqruHltHx`\\kwqwiyot@kdXKZQaEopc`snPxM>nBxxVovW?yYv[?Hhsi]gV\\K_cSoxHiiSPeTPfT_gIFZJfrl`b\\y__Gj<Xxs?g\\oruOfvG[uymtV^S@qjHZ`N\\MfuDP_t?iwPkTgrfA`fPsQgj:>[Bgx`XnrHyDihXiZW>t_qZjoa;wehQrNycWnm=oqfXsuWjx@mTx_\\Wtt`\\p^[_`rfoeiXebGcjpft>ZHxtqInH>vFou:^hVQfkQ_OWvVieMqgNNx_hr<u?MVIIwROcQmwNEhe=r:qb;ab:sWNwxPcUMmuUIi^miBmU^OUG=VAQi>Ky]gF^OvTKWh_S=WcusEHkwJ=GnIUb_TJ?S_?XAywywDy;D:YwAsewaGlsynIG;KS]KdSUusQwQUVEiEq=VT=Bo_Ys_C_EXKSEq]WAqtusw>iiuux\\agreCi=UIWwxYtiEfyuth[If;rYGf?eV[;DwcsoCX<Kf\\MFUGurGBuycYsrfYbIKVAMI=ggpWs?uTAkgUqGcmVHIToOItOHBoibEE=GxvkfEGWnire?croEIcR[AsQUFbCEdKy?yXaUXCEhveDc?e?;ubIEawXMCirKyMcH^SF`kxIqfKYeZAEeig<AvaIcKSvQsWjgiJcEAChP=S@Eftay;AGvOgCoSXOxyoCX[IEwBX?IGWuhgu>guUyB_;issEG?e:Kt`Wxl_WpsH`YVCaIm_XJIFb;IpCh<wgXyYD]XHQfMmSpQRc_djaxKiBVYxBAIxEvhgEbkTnuCBUWj;XgIBVsUo=WraUZeHxaypWrJIfjUudyeCoG@cW@CFlsiG]Sn=GSsYu?B?ChrcDi[FhKSl[iyuubuEB[roqVLQTdublUR]Ehr_yvQV<WsPecRUsLehDgfsIYfEEUSrWswsuG@mWrGC`mGA?YiuGLWr=AujevOAUdkDkmXhmCSCxSQS[?b_EB\\qwrutuGHlWWqKs\\YxgshYqcGsHWacVAyrkgyyeYSRIiVu=rEeFsuCairiUDwGUVix[yi<arMuSC=troyDWsgsx@?S^WCZQigQDXgdDaffUDOOE=qy_IFkAFb?wEgDk?TCMVausfkgfyeOOWZax:_Td_EI]snYVd_u]kdc?Vx_EAqbNEBq]WVGdXKbnOhMUsC[uykI>_WVuRFUvrkiN_roSFEAuNGGDgw>=bEmU=kYgutB_IaOYuMvoIDSUtfcinWYxwXRsyribaGxRYta=Xl]YSsmKxpZushILcUqoEP<YK[hMwPWs@Qv]wEXykdQQxRtTuIpqoUuJmsiLntmx>lqjuuC\\knirkurOYnPhXPtYk@RIxLk\\Sd=s`lq^ymDur?Dj:XmmylnxrbDLYPxIqOp<Sl]p[AWy@K^MLb`X^hQVPr<XkC<P=qscdwmdLu\\ki`oZuu[XRbtTd<kB<T@UyIuwQLK?]sVDQfDMtpq;HJcTQLXLZqWL=jphLkYMOplwPvd\\mByvkxyhYq_eJeMWb=MOExyIJd\\nJTsMangmlVDN>ajgLN:mUD]m]hLd@SOtmGtkHPNLqtO=oE<vthg?^[nfhPar^?wRv_nYcJvd]G`f@wkF]laaSXs\\WhdGZwF`U_yl@m:IwO`Z>Y^D`eGQcBAmb^n>ywr`[aptFfZApvMAehV`f`d\\Q`vyb^HtcilrnnmO[@X`@heHviHx[bQbKGfWfmIYxPYeDGtKOyUfc_>`yVpFxusYpiWvExuVyk<Ay\\nepWwP_yeybYQkq^qdw\\nQmM?\\jGfHxqMp\\IPgrxwCH[vwycH_SGyQVc^?\\Kv_=woCwiOIkSQZx@xwXlrGyOV^L?_RAq:XyFy_lIqsvveGwLqg[@^cnfaQqsF[tqc<qqlo_D^ZXxv^XrcPZO@Zhn]qx^dOusVh<@aY>ZHpe^F_lpiwQiFasFAfhGgCVcMXllxmL`ka@a`pqxqifx\\ZigJ_qbAqbAmBoh^aoRoixOf<ocRAwrHwt@lkhacIskFxUpaU>>mIlQvtggB;vQweTODwAVFmgmKWeqwW=wmSt?;XaIXJWvp?c`SvvauI_gVYigsxG]sRUfbGHbcYXEXiSDlQXgohWIVtewi=UmgEHWU:ohOsR:Ai;_U?eDm;f;]de_xZcT^?fdcGyOfa;HS]w;mHt?F]=VecDGCil;dBod[oR\\OHyiclkvdMVJkH>AFVEHrkvDEDjSh`kEvCtsKWKUglYgNSr;GuNKyMWGB?gKoh^?RuWx^qIQ]cA_TZOGl_bMqYSyweqGMkwOGuUexV=RPaifWy>YbsQGReyeQXwiDUivaAgZORXKb`?vkyfIEv]wevyXvmvmscDIR]yrXqXgkImydimr:AT@_iq_fkWiUQcFQg\\SwZ]dysc=sIMSywShJMRO=bEaVNQhFQv\\qu]wiT]F@chT]Rh?Tm_brusmKBcewaSEZgFayiG;vugTVyiETon`Qwxvk\\yIyTw`Py`J@@K`IlCDWnyuaAVj@tnxvGaJsTyaqJNxON=JaaxglKEtvNUthtOiTSsELA<kLppVuq:\\UnquKhyZ<PAuRn\\Qn\\JWut_<pPhRVlXk`JwxNZ=SeanIQylHUfQuoXSdQtKIQHUkgAtp@KriXo=vXMNGIsFIT^<jmtswEWOTKbiMW<pRusMIpXmThmkctVQlTS`mwimGaknlUVQSqyvxxTeHMWtpyURlpjFQYIAMqxs:Hw]mjfiobLMFUy[IVH<t?hVdaYlPQFHWXyJbYXbHmdLVSpY;LrF\\Tspj<eSFQkFdUH\\onAnSpRGdpleT:<q;DuQEw`TrvERv<qKPpRul\\EY`IkYQw\\EmBMTMxq]HPsIq_pUfUMhHVfDSUqTgIJKQJPmtuettpWp@reUvVaJyxXH`SkxRUuym\\SAyR\\DlV`lyhvuuO:XvaQJ:IqAeWyywVhv?qxGmpTAtFtXWdV]eUCAY>tUrQwX]yPyMxUJMXlEAuxxVNtwxijUDxHxPWeN:YUTMjqLqqLwsPXpyMMaVPhjO<tLmR>xXrxVehWnTKilLd@UBIkuqR[At\\HS>QlwPxxPNEdo>usZ@yxapFyYuDYptjWXmtuTaAxjPmwQpYxOePjNIYXAtvaykqrmQwxqqh]J^yU@DJIqWMYpFYjihw?qVvqOG\\wPuVs`mx<tGLmHISeiwoxVSUWAtWaaXymOZ<Np=m=MVQAKjHTrMuCYw]xwBHxn=jmXrdLLbXXPhXxUUiYPfiXtttEPREYRp<um=mCujWXqJioE<vHIxF<jjMMKMpwuYvqQfUYtIRvewpxpZYMq`q?DoLmw<iw=`pBLP_`q<poEHrCaS=eMT=U`pJC=J:<L:`>cdAqhfsr[ivrHvaukDEP>UlUmYJpkw=KV`veunTXp=<tCUsc`QEdsF@vbIn^@qKHMdhtn@M>tPEUoKtPnUNjAlJMorPPp]MkDXmYSZTRsANpAPldTF=VheNCpY]ELEMJvDM?IUKIKOHjNqJ;<o:Pnh@nVePJEvK]kQLpJEn=AoO=v^hMNaSGTyQpjJyLwlkmdr;\\lGdS@XUsEXDDOxDj\\mvlDoxhUcDPVdQ@IpWTK\\eyPaoCQJqmP:XnOlr]@y[aTYlvDLKndtYIst`tr`WsqjRPsJyl^QvVUoBMkoMw`@MnISVIXcmKUlYmiyRaUCYkIimmELZujXQrD\\ON<qA\\YJuyYhpMiSFYwuyvE<qo`o]IKVQJE=yoeX]LX>PxWWorWtixi;VdmFaNxl>a_nx^@Hks`axIxYqm@y^y@ynNc_gu=oadP\\rP_BpfL>yMyurXZyFydieJYcOid;AjZxh;IxAou<^qS?laYtqw]<y[XPm>o^O@bIAsR`pIQvpw^IolVgpDG]mX[m@yey_fyruwuxg\\pn[_fvwwpd>j<Yry^hngunFhioigw_jxiLHsJiovp];Oyypae^od_^DHtca^h@\\YnamF]?yvYFsZNeEPe<^h;`g`xxqarPWdOxxgXwaI`TpoZQrAaysWkXavLYktpmQ>lNFkZQD\\lshMV\\y:HuWxUbAPF`pvXQQitiDU\\qVXdmv<RaEYaYxEHlq@u?<XaQmsUPF]T?<QKuKwtjNIraETRDqXtRp]TJYmi\\XF]oS]KPQubEq@DY=aWkhrbhwkAO@tn>TRxpVZmW\\@OATXAHpkYludM;DKQuTf@Pl@MCMrfDQ=<SV]oeDJ`YwGXWDpjX]vjYtIlQ:XsXTYDlJ?@PWMrviTMErUdkb`w@yyriKiIrV]V;DwvaLlIkKDPZAoRHonAV[`n[`r]=mgHK:tn^AV<AjTUU@HMeYlaiWp`m>Ix_`P`PWw<okeS@iPuit?]KdYLR`PqLNihK]qxmtx[yLhYyNLy]hLCArs<nFIVf@UopjSxtv`MAmxvQLHMK:YM]mRAUrDPVm@jUTPk]wbion<MBeTv\\w<<TCiWkto@HTmxvrxlkPvgqo@Tx@ytVHNJEmY]pR=P?imWlsJhoNElpdpp\\qE=Ypdm>AKKeK]Uwt=PwTmQ`oXdsnyPixwO<jbLkO`U?]XVPSW<`Q_hFa_DXiyGaI@yLQZDYq>I\\Xa`dfgdOuB`nWXhf@b@auAy^P?x_y]X`b_Po]xir_dlxgVi`sIf\\q]GwxgXb_@q<xrYXm?y[YpaExmygupw\\j@vIYiq_]Pak`WyMYs:IxsG`=yd;@fqoeQy^pymD@mR>f?GlMfkVGe;Im_g[kFxVWpJnlVh`WWb<^k`NcOwbypw?>rl`hmgvHixFoyLxa?nkJ>ha>nigpZNy?PdCXu?>haQxSH\\WN`kxg^ohehnf`rIIrf_[Qx[=Fw^VgUipTGf:?nfxo\\F]LitqXlyVespZSNanPadgeHN\\nA`QabageOvmAarZYuMHkR_sUhpMqtZ@fjFxwPq`poVHu[QaDIb]ih:?wEisL`_SP^?Xeuon`GlW`mcGqHqqTa_FarVN`tG\\_WfSf`g?Z?ga@Hs\\O[?nmoP_s`Z:^dKgb\\`hFFyRisJ?dMpmwwjmWb<>`_f^eHbZnoqng\\x[OFhFx^KPkQGhogwc_kGx]ggyZ_mXvjsGmMxo`opY^vrhZh_ch@se?cnQaepdZ_x`?`wyeyW]cHlnNvC`pWP[a``ZQm\\wshQwZNmSo]w_s?>sg?fc@_G@xcX]bIoH?eNoo>Q`rwd`vn_>\\_>ZaaeI`bvNjyXy^YrrAwaxm@YwZP^Bqhchujoc<^nBHorYwyQx]@yXyqY`riqiZqgjQfOOam^yhyyuW]XWheqdEou=_qNGpGQbcpjCivd^lyOyvN^ygxO_gsqyF^kyAy]@r``pRGeo>xvnZ<f^YVq@IirAyIYZiIdeYki_arO]mXk_FwU@c[QdEPbofeIAp;@[sAd`XpLqpaqmAw^jQkext[W^cQrC>lNaq[nuDIwDikTQ]FhocGj?gmFIrsFjqf[Kfpmal_Vbo``GFwtvbrH^iYxBHg]GyHo^SPfsN`Y@nu_dD@^e`_nXgcxZUgnkxpMpj[Gcb`tMWiSWo]yvW?lPigWqt?>hiN]Nv^:_mH@qGAfI`nF^eo^_:ob\\XpvN]daeoWpM?]_iva?[:Id\\ohgpnE>rPgbxgfCFy\\Q`dfn\\nkGaljfqNgrgvli_rWwpfa\\=VgSOp?P`cymRWrTH_;y[;natGaWp`IFs;XfHf]gnesPdOV_\\giwiiS_b]H`s>xKGipgsa?[hPgTNlTvr;Ywh@rDqvGN`>PoRyuMAjJg\\:XnTGoDhiKIlFgc:GkJ>[JInlOs;X\\:hcviaWOwApo_g_MGfOQsu>sRX`<^v_Id]ntI?jPaqK@\\=PeF_wUH_oGS]GH_fTOr@kH_kBhGY^qhFCvKyUrUCL]dECfcoXKub?kfrgWbmijGWNsd_mfjocB]qhirEqKZeX_XmChq>EtBXLnMRy]q<lOHYOWxUtQtBqx:uMFQRImn^qpNdrG<tf=LAtULTpUhRo@YHUsfEuXqqdQsuUPW=JHIJuMy@hXo=LgaoUv`_IruqvkO^toZtvfgGsq@^jvvr_i`V\\KbxqcU?h[]hAsEvAuICxjiIACxYkxWgrieyDYskyuxuwoKvAOv;;vO]CC[HugVe?Beuu\\wB\\sFxsDZSi?awoeG]]IIcRjecIcHkmwBYYlYYImSDYVB]VtADCwf=]F<=ELgi=?GhssCaIrORSudZCgLUWowCv;Xuowaqb]GBl?w]MYx;gy?cbKerwGusIlabXMrlmfQswyuvA?HQgE@MhP=dsSeWoewcRD[xROxxsfu]dHgsiWUaafTIElwIj[rwUG:oVfCcnmhI]uyOevmUmYcmQhiEgNUs\\AibMR__hWWWTguKKfUQigWCZqUbgcRYlbAvNTYJeN?<w>MNC@YgPMViwmuT<TpUhObAKeLq?TRs`TCqvKlO:\\mR\\WNTTlTN@LS\\xtFIrbdLJMsOHL_YJRAtEApf@U<=oOPK_IsKev`pW=xP=QsIXPWEqk=R:ARAYwAYMg`O[LTUHrR]YMLTcaLlIqvlnQxn_pxHeM:=kgiR?AnXtk`<X`uvp]sXUmN@v>MjSTM:ilEiVkQoDxuOHLitlb<LeTlEYNDeSVdjcTO?TKvTN@tmBhMD`TJYMcTnIaOZPVF=VHeuhtjCdROaOP@RFdTCmT<uUVAR`Dl?MkVeM>ARX]wUqj]utVekXpuFLNpEuxXx\\Xv^TR^Qk:\\n]UkE@MLMO\\=Lm\\YnUqGloVlnfpK``ovMk>@q@tsGyndIy>@NPXR:PTsQVP<OeXJnpX:loXErCQwfMUmEM\\Pv[PmbUlF@rm\\UflmVmUF]OnQOsErfPlceWhTjn`Xe`TvaxUlo<qwgTJrimyTyPln`tlkyLyYw;Esgiqpqxg=uxHqYTR=Lvv\\Rd@TnmOytvgPkb<ydpQXetnqNTTTkuw]YvR@mc<N`HlbAPWyYd@QOLYj<sKQVlqQ\\MvS=QkDm=iVUX`Oa[ipyH@[wXo@pdjpatv^XXrl^hkwijW]WIqYXqtFtaQyFacBXyrQmnNydWcRFoGWeM@^A?rRIwH?moqn[>afgoBpwy`f\\njFPcMhrr@qhFra?mtQZG_m=Hj[i[RNunh[Soo\\fle>rnhbGGuGxd[onNTtMv>kvaoF>;tg;sNubOuTZ?hhSRQiWWXKZqOp<YM]O:@LaEKbElb`yfdmcIrjQyG@kD<LQlPmuvVxoxtV;inrqurYSmPW\\=v><Kd>s=av:HcuQlROk[N_xVc_wZk>`np[d_qBPgoP_;WlONcKYw:ikXYasNa;_[?XuN?m:_[Knj@pe<onaxZS`hTodkovmibSNvn?rA`c`wpe@jnNaI_etQ\\SgtXp`MxlNgd>Q\\k_n]H\\Rpprh^cWhG`vIO^a_[BYv[Vh[Gs`FkqI`_`jk@u>Nio@o:>[aFp\\o[ZPnL?mLgpIao<HdgOZUN`\\AqcPmOppePeCVoK@eN^h?`\\k_sPgrcHgmPk<>gBhyDPkqqb<`jff_pHnXn^P`[TXkwVhF?_ShrLHtqO_afak@[VP^;nt[>alouohsDOl?Q`fp_kFrS?jkQqGh]SxjLGj_aeJ^rNFqqYjqNbH`mo@sy_oS_[hidupjkiuIqqMfnvG]ygxIxkZiiY>qUviLxo\\YbYfieniqyliWjKIbrImA@ron]BGp?pyr>xkNN?T[erCGsv_VwOHSoU>UvSOYo[WmQEGEGGUddYE@eVdaCxIveybkgY=mBUyta=TkcYXWg[;i>wh>UGPeFrcIaSfw?RIof]?UfGSsWBqYh?iwCMeVYFq;bmcmuEJV`bAIdyoyW@xfWrKPjUIvHwZVIhU_lOAb\\Nmn`nL?qY^nmG[XAsLIgIifQYffgyP_dXniJfviwu=Pt[YjJolQ_^Rvfqvu<HlKIdFhqxi[RXukgZX@i\\qif^_FihHnq=_t]OqrnoUQqgX[Zq_<Vy`gv`FllfqMOdFOZy_Z\\Q^oPeEHxRxoxXtlW]gwtghi>>v[@xcgo\\nx[NkDGq>PoRHuM@ahp\\M>b_N^:iflfkfo`Eno>_^:X^:gb:hk@vkP?ZHy[^Q]OBk;Wo;wOadR;EMAwcIsRMig]TwYVEwvTEf:=SZeRmKYlwEcWW`GtBWfRECSaxsCyUOW^sX[kVuqf;if`WUiEXSChTQBDMwJgBl?WYargWmc\\n]Lqrtrc\\xPUOBaTP<TMQyfINR=Jv\\lJyoFQkiYvLUuA@rUhTo]r^YY`yMoirkQOp`oA]jhxU\\DZr_sLFunhvt>ewv\\GHiSV`U^vCo\\^pdL>nSWpSp`Xa`bf`=o`y>imy\\`>uYHqKadBPvq`htgg<ogGFlthf;^ob@iZp[JawfhrZFd_QiCh_EV]Dh_J?b[Wi<NrNXfqyZyphu@aQQ]XHuqo\\i@q[Wl>V]>>^Nv\\lHfxfdE^p?vgG?yoh_v>hA``]IdOv[xV`?hiAqvKv\\uAcLa`T_a_VxWQrXh_tphkGpV_i_oePFfvWx[X`rioYpqVQmv>i^?aTWZDwtMOw`iog@`rpnD>^S@lMf[O_aiPqGqZD?jPwZjonwwqq^fQ_fHXoWgahOq^FeFWayfo;>ZW>ZaVaApr^Xck`bCW^^vpZQ[aytmh^bOZMFk[ifupo;AuthsRxyryuZvyyoaAnplPjmNfMv^?abJpsVid]yfJH\\MhroGxrnZYixU>]X^eAHqsImt_x[XtH`osa_PiZGPqggs>wgqawoGZVwpgHk?XnPFsi@sy`rZab]`tSortnwxPaVQDGVucSlkTTgfMoRW_I_Yf?]RA]EKSb=CBaKh@CfSeX\\Ce:Egd]tMGwC;hCeRdUrDsepMCZae>WyTeHhcDcWd<;xJghBcvlgr?;x[?t]eEfAsmUrfAT_SC>siLgGkgvN[TDAVM]SSeRUscN;tUme>meGKSs]C@aHboR?=BrGUk;IMebg]SlwC=cvm?Ujsr>;wEMsMYdNyFJYf`irZAIfkcIeDyEc[ch?GGOSCfUh:[G^sx:qCgOI@yvXEd^efkIe\\?i<edP=WKufvgIcWH>=FXuxJUCVgHA]cRwVAKE:Is\\mt<IIvsCpOVvWf_aCWyBv[IBIXgiDC_BLKgOcUPMYxqsusW;EfVUR\\Kg[ofEGfXyfb=VpMR?aXHMu>sYeAuvEcwIsQcXVYxiYv<;cO?tUYd@MFm;vc[UB[IXKVZ_r>AFKYH:OV[?bAoxGAvhWep;vlgGS]DEQYb;UfMVDURpYuT?wcMBnQtmIgDIC@GW=KSA[xt;VgGB@ATICclUuO]ujSEFOgOWiduf_=uFieFECJ?wIYeLCrNSSmSSD]i:Ye=sR:MhywWBSUpww;Qs]sC[myEseAQXhsc=KVl=gEGcSAwPgGBIcoyEJ;BhEVlMCqmEsKbeWXe;S`SHgUWUWIgIutgwsqcfiu[giEhhoX`k_lyi^KFk:^_dFZMXx]NxaithH`g@ZGPgBo`EgpY_lV_s^@fghZZ_`U?oJPavAkgx\\^qtuHhxyuD>rsHZehnuXnTWptGyLa^u@nSiZ<>hOGe<iZxOZ;_m]@leOeZwk@>vb@uyqe_G\\MGyM@tnibbHs;?liOitNlM@rrnbAA^@fmnPl=Hpj_ctGndGkfNyNIhs>aLV]@WZOxeK_qoVlD?^hH^p^wvqtI>vNVmK^hfQe^IaeH_lGmPXbSWsRa^ThjTXZEV[<@qvp\\eEVwUS[r<ibwwGNSg:QTCMBE?fgSdmQB;Gw>]SmOGPUu?wIUQDFaI>GdeaSNYbRauamcFYSs;dR]bC=x`gRMCf[YTyYhO_DEydQmvkkIUwrwuSXgrHgSwkGPkC;IHNmDHmssKBvOht=UD[b@]WGQG=YrZgH;;Iq=ENOCJ[eDUxtyWf=HaABrSysihPGhMYGVCFZuBFKGFYFwKtb?IOcy<]IccS:yDxsyi?UTEs]Af:;XdQio=YOyYsYFfeimiTleyAkwxqF@yiwucFuXZiTEgxQwfoaeneXWmBcIYo_WpWYHKi:tpwtKNtX;mVMhSdluXtkatMg`v:HoHlUgARHxJfAOFYpgmvItOlpRliYWmL=iL[XTZipKdnJ<nf@KohUW<SbePUtO]UUcIUbivc=RIHsdDrXpu>`K;erfmXmDmjDp_Ews<x\\aQNTnATr=eqB]NtMMp=P;DYemKnEpj<mIyoBiT:<vglUjeYhaLQ<QiIMdiRDlYn`rWlpGyR=IXA]QRIQ=\\oStvsXrbhxYXqQevjlXpyJvpoBtrf@l_UOHXNBhjmalFMUUaoOXOritYHqXtXXap?Tr=DOetmhpq]pk@dM;DKXuJRDv=XPiUJVaYZioG=OOYmQpVwHnjANO=lxMwhYRREsQ=lW<M<Mpi]n]mtU@jFDjwLsAXkdMKxhxbaJhAq`eMh@u@]OVHu>DNseQ_HJgTRRmScIlOlkaXYMXu?\\PGllFiyldWpdSkMkL\\nVELixjGUMsHXpIyaqto<v[<JhHpHUwXHv`Uja\\n_QpwURRatqLkMuMwAK`tqquM`Uk?\\WuXxH]UwYuiIr]YxMAqqYxYpleqMUqp=ttxIxYPNGMXsLvTySHmmP`O\\tTuTK[PQQaoUUrJiVZQqgX[oWu?ArcXoRxcm@h\\?SoEHGhmshgGi\\ChBKtteSFOSFcfbAfviWtcfZcdDMFhccAgHC;Ht]C=SEtYxbsTuiVkCSiuSVCc^]Ul?XeWuUAd=_v;=ua;f:?FVCWnOFAQUvuw=MW[]xVuFNkUUGrl[xtCdvgSoobQeivUGXeXAqSNUC_=w@sxsgxrWryWgySu[=vg;D<CxpasGCB^KDfiIvMYSMWNkrMQvx?c@IVdihOewM]GOybDEGAGe_OhNAd]=stuH?YuVsCqIrPUyyaspGt<sXCCSA[g>oWYMBiEilSR[OrjMX;erfmU;mi\\eTGUDXMEFMwRAuUUR`kVZkfTOTQmSqWxTAemCTkeUJEySsv;;RSaRI?BjEs_aIHkuwiCNSxs]CgmuFWgxuww?SYUXgkiqyeyyIV?IwMRPMueucx;cAkRqKvGwIsqV>qTPCXbAs;[R]EDiSRSKXwMiZewvshhmCVuD:iXUQu@IyQSdy]uECgKeR]Dq@QVkusCdkCQwHetd@oGpT^=MrlmZPr>TsLaj<YnKmNheVkImSytI`l:LX^lWEmN=G`Ey\\iHfEFrTOfWnk:`qmv\\cfZZ>`_yq]^h^yeb^Z_AxJhgnhslWxQi]nOjNVZQg\\nP^eAsEa\\<gbopsHopTy\\hYp]gguOq<?rUxhfNvgFjYXywFuthap?f@O[jQoTPein`Sg_f`njXgcgfHFpdo[I^wWHrGylIFsCNjhOyl_uTq^:HxjiyqiyIIc[ykb`vfQrk_gKGrqyk>?`k`oBxymFmA?omVwxpdGGhv?kD?^QY]q>pwxo<XgAWk\\iqhVks_sHocxXkSX]R>];pibaZPpnaH\\G`bJYapnjrAwt_aqav]AcDH[KqmQhw<Fx`in\\G\\?`ylnqvilIYnyxqIFwnOphfrMigWqtgwlZ>jeWuKNpair_`mQpnNYbb_m^GxKooDpgMqm_YlH`dqhZ;H\\iVh?gmxqrKI`FhkgwlLX_VIsONpyXn;Hfsvp<XvAqm=GpJXbopdkh[>h\\ev[Iq_`>nVWbDf\\K@tg`lfFkdGZPidVypQ__ZwdW?hGx`QNanFoJYux>q;WbnX^D`wVfhJVq@iaKqgi_wNQieic>X[FVn@@v=wh>`lmv`_^r=voAXyRg]@v^Rhv=`hPAhRqo`^dZggjpw;qwSy`XqmgW[ePdgOZvFZ\\nqKFhY_vEf`vgy[XtRosQHlGqxCwj?v^i^omO^=_uuOvxVcpq[C>xTXr]vZ`GhZarLnoUiaZfeFNmqikuaqAgmequ;weAY]QyeO?qn_xRyhPGrxYpdn[IAoRGoRO\\pN`qQdfVuYOe@_rbHfcFm?H_`f`t@apHu<PksPbLv^QPnRItYor_Wb?_f?>lMi[`V_AGaaio;^`_iy?YdbHkw@_Kgfk@i@PvUop\\nuy>jCyrY^blf\\QV\\]`nvp`_QhTodlXtsfk?aovyt:IsexaY?lq?[bYqgXuthw?YZZAw;icBH]apr<_wj?fs`\\JP_yHfINZDib>OhDh_fPclN[MYk?^an?fDfjdhleOtQWk\\Q`k>gRFsNi^=wfu_cXyd;?ZKP]vFcT^emxvt_xF_c;aqqYiJOc??sdy[RwtRGto_gRaq?VfqnuFnuQhrnas>n[xvx^@aQqbwvbGGkTWjBXLISC_BOQgNgWD\\JdAKapKj]w<mKhYUPht;uKELNv`o;Elk<p`Ilr\\MAQQFdTJTuPuUyXKNEu>AUW\\sCyxGQUjmMSDLqykV\\t>Ym;LkMXLbqtMXW@\\XvpK`UjRepZ`LxtP:HxZ`jPPPVdW:YUEPN@tJ`DUhHK@lQxiv=<YfuynLT\\IMfIMXaO?IY;yTiiJZTkS\\J:XtehNfdsHEviyqt=MyXxmtl[uv`pMNXO@xtKUkqTVEmwuySW]oQHyf]qZejOEST\\v[XLDlmT@TkdqFAle@OPEVH@QhLpdUP?YJKTPd<YeYJyQkGYtAIxKyPyxLmHmK<O@DsZAUVXu^mO<Hov]JuyVM<uLYU<ix]HY^XN@UUGmQ==n@AW^LklTNiMVkpOGURf]VWhYIXXnqx^`J:XSEqQhDmF]tWXUNTq\\TUkhuFMjhipjpQYiWDluGhUnUUqhqBDJVdQ=ILkdoVQta@NPttJ\\m=dOOTV_`U;aYCHVsPO:am;AX[XNP`tSeRnLVTaXVHmCIv[yv`@PkTUJHKMaPB@T<DxAuupyJrImUqrJpMbyjp`ly`pSxppHLAUKCXW<\\YW@yPiubpYhyUZPlfPjGqUPhrsan[MXwmNGHrWYYZ`qkisr`wOyo?ENq`jMtnHTR@=SgeWgTkGdpJanQukdHQI<KeMTGAW<hTe`vI\\nbtLTdnUlOrqL:pkvPqheM^mso@KEqpwLnPtv@YpapmGaPi<wSiJuQUj`qoaKjAUN\\QTDKW`tnTPjaQnAMTPKQ\\MpiSMEx^InS]YoIjMPxBQtwUrBpNldXSpkodXH]S?MOupK_QrDlxW@U:iqIhm?qkGHMcxWbqO<<WwxrbEsxETXXMoiMquwM]J:Xk:]XmMPQhOXDvLiT>@jSmRGInyLpB`ot@kWYOIIVMawC\\wKmx\\aT^UOP]sX]lJ`R?xNJdTGDYHmLDPM`YkS\\sPLNrIpWTxBEKJtnmenS<U<ItL`W^qrcqPrxk^MPpyX@`obulOdxlPjWpSGPub`jGlRXYoNxKcQxieuPiWilQ@lSnobMPaNYbAFdU`]AXnehvx?qCqx@G]XFb\\Wwp^gDaxZ?bFq\\aVxFVcOgtP^kwvy:ikLNkC>owVhfGZavnP?h\\OaAhv<gdtg_@W^P>fZfx>HhMWrMGiOv_YA]=VnI^lEGfhGUkUR=HjWDaqhP=DZ;YlMDMOiR[qRlLLEMkesG]L?QjtEqF`wfaQXmUsMMciYIANOxs[UyUtuBHocIXNUo_=OTTRZ=mpHKJAqmDqW]NO\\Y[=r@@SUxVwhkjQV:IPn@tpeXm@WXPSLqnWQKKaKcxTePq=ynxuR@tx\\IV<dqglOEUoi\\wm]vr@TrLRmV[;Fhxo`h`dppy`Vl:O^P^aJYhn_sBijO^aJVwTX_PGxoyZHWcwypNO^D@i`xwswv_GlGXmTVc:Wllh`Fv[vVaEXaiH];ivUaZbO_UFju^]Np[<ieYI`uvjHI\\bi\\Mqdvni@HvAxr\\Npu@^yfftPkt@ZCGh_`kgHtM@]Kqn?>aePjcaeTisdIlbNynh^kwyYflsYgEqfInfFhkRpvUfvtF_ApkPwitg^;hiMIcVAqxGqkWmoFs`IhcFjgfx<frePbuy^`FdohjsGixQdC`lFyagxa>^uxXrVPbFVqTVn[^cX^g^wux`k[X[\\QqgXUcC:WfxAROESwYe[MvEwyAkvqwiGoi>]EOEts=IdEwL]f;]GRcweYRfeub[teyW:MxQsYCSU@KvR_UfGVxOf\\ewl[fW_w]sR[OT=AyFmCuuSFIvJAyLKW\\WD_CY;?c`?sV=F=qwBGW`ci_SsJyfPAfEwubGtbiFKKEBKsoMWU=FC;YnkgbmXIutwUhrosQey`yW]Khc]CCAW>[U:;iiaqIfiIfa:xtC>ZZp]s^k;pu;^kH`g<IomvbUFvI?r]fcJqRORAovOexwaVFIDJmhRoIikr\\iXFyR^_ROEc\\OEOeFBQCfCSZqw>os@sr_aq;hjTeVsHUutPBXXApUU<JPyqhAxkLlUIsw]oXlOoeWUmQa`SHLv^<teMuLmLZmwoxJ:DQu\\ueUtrlTNApgxVLtK;dXGQyemw_=SLXnVEtkAumUP<\\qRQRdLssXw`AOVtSsiX]Yp?\\sfdTjeormxE=PdaKZXMZHYHMj]IYV<NuLN;Ym\\MViIMHXYH<UZik:Pp[<jUPsF\\WF`SZUVnMLwQJbHsnPjBMLT]rNptn]Pc`kAYLbLlm`JiLVJumAuOU]R<us[MjiERODKc]UiHKZtxraTi`V`qoXDUK`wnHrWux>tVlLw;uxgXna=UJts[DUgiLpywMPpNTR=XNR`mtdwLylmdnjyPWMUcXKBaqMpWhYQI\\qGXmwut@UoUQqgirBArSir[]rp`SY\\QBhr?iJfIRYV\\YhsJxe`XxwGp:hwsaa@nsVHbfIuw@wgflJ@ystRudhIr<eTwsWcoVNEXpmX[scumEwcFxqdJUDuIGwsS]odZUG_qf>aRAAGtUPJImRdSm]wXAmN<J]LJWPO>qsaLpvEPJtWgAtVXSeQoXXL]lJCixumx:auth\\Hqm?_gmqfVwxtxt[YeIva>X^of]uxlP@fFys[?hb_\\axrIhhxxm[@jLxtShnOidKv`HHZp>d]PgSO^Sp`h`m@ohkvZgwb\\pyW?ZkptBWdeA[ioZg^]Jvw>Nb>yiKqy`_[TIbkIBGgr=yCYHr[Y\\mEi_isUG@qtqAS[qu`QhQ]IIWExgImSrU]GIereStEgFNWg@_tL[c_OhlsHEweE;WZkgkCIm[TEIYbctLkfbwGbgHfEs<oXqGCN?XiMC`CBT?c:sWAyVskixwG<gfLSDw=C;wH?CS_?cgCxk]WDGcuyUZqHoKu]kFsOENAYVCT;;f]aT:YF`sHwcYw?RpwDt?yhOSPMYOOCpsTHMFe]s]adkWCE=EdwvIsItmhIMbgYs@Sxxci[mUQoDSGeUoRY]I@_VImBMQfIgurmXLctSGWFsgYSRdAy;[GaqD_qsAQVC[rMIX^OHSEwy_ir?IecGsaS=]w=GVCGcMUfIAgD_iS]utWCQqsUUwDCypEBVib]mWr_eCIU`ow`;geEeOsCwqfewg?qbqsiGKU\\kGGqrEYxmAIuuyI;x:ytyocgcYFsHyYxaGdy=xx]xwIyAGDiyu?OfN?IrHpCtlfURDenLeY=MUJeN\\pTa]R=TRo`lApUSxrJ@w=uXgXS\\dlFXS[ysr]QdEufdoDyLjin>pvrUSVavayqdQn]@plAXnUSTmMAxmu<jIpyGyjj<QtHJy`X=iWRqQpHKEyNHXV[`U@QQwptZ]rV`yp<yeTUTdtY`setWUAk>DQuIvvyuKyv<XT_Esw<rhHpVUviXLh\\nyYMfLjgXM;XWyyxYUNuuy]@mshwyMkKMY^Hs_lq[el_qRUmodyTU<QktSKPR=hwdXX]my\\lJyLYZtJm=J:<L:`N\\@^^qrUftKp]vgrU^[T^eFYmQhgf_\\k^b>N_watQpx\\YlY`i>vmyavUiro@sDyvppqUa[GijVf]<PpZn`qHwC_vxy^MYymOfgPh?Q]xqwEwZJx_N?lhis\\xfb_cvooo_vv@tCwa?Oelon;ouyx^jIqiqm:qoGHgVgqmx[@grQ_mZOhIYpZIfbaeng`OqjHivF^imwm@HwvPkRpr_>iUNkBHcfOxbnZL`voYmKpixHo^OZKRqCBh_h\\ECSOSOkf:kWSId[[rlCWbIc>_h;YGQWGBIcCoW\\_UNSsvcc=edW=e;qVSEuTeHN[Yqaxj_VpqGU;sEwRFehpicSAcL]wQIf=UYkUMQIVbuvh]Qqar]=uvxy:lkyxyw=uxInI@vTYMXEjSLLfiLEiKG\\o=QyGYuKeMYtNdmLApnIUvCxnYlRtDm@qkGTUJHSqQsUiYseVKtRI]M;enTmR>ek>`UtqOyqXHUUfltwtJW=JqEv:\\M?PSs`n[iOs<KT<tMEpblrXuxT]S_QkBio^ApoyRpLVruvH=wIaQGHW;lvnqqf\\x]xRJPQjxKCYQqXNiEor]mmiY]pSg@O`Mn_aYH=V=ToDIpTmU;EUFaReHy?\\l?<kUMmE=V[ttAHl;qMfMMCXVZ]NC`JGalgAPAinRiP?DwKHq?lyWaL:toU\\mU]WVDvsLo@YNuloUxWthJ]Xup=N?erZTOeLxqlViuOnDP:uLfAlHyy_uww<r^DqDYX[ypdXottxFux^ImWIuV\\puPtD=OZ`K`Tu^]S@AuxIPRyxTAj;IvtIvTytVUuI\\U]]YspxwIqyiXH=uRTu^AV:=K^LjJ=U_\\nGLuVpNIqsFuSIuvJeXxYxWPSaPRIqOB=yKpTWMY@UPUiUWeUOuvNIQiIYyxwuuUK=pJDTcDsJ\\oZax:dkOLXoPrFHRcpKA\\ObDRyAYB=NFqJrmYShK?=PIDKHpNLTn]<tqpSl=PY`pIysXij<AkdPNUdMrmSFLTYET<LmfmlMQjgAYZuY@IKGMOLHPwxOFPu?HTFdjralj@JixJ^eLQQrC@UgLVAeLrEqUmMGpMRPj]TxLEUZyRttMPiWCdjBPwS?hQPkeAqmArnnijOfS?w=nnuqjZPwCpw`hxyNcIpnJhf`vk>v:ebqiri_uqSbwUUtiGaAD=QBCtpGalIYQR=keAQk<xyyPTqJxpX>erCXKk\\Ng=xP=tD=qdTX<dj^uJc`KsHk^`j`INgLKCYUS\\r<ipulTOyn<DTseW^\\XbmJs\\PbQvSHnptoM`_oPjgim]`]nOgRor@Oas>gvXpVFehe[ST=MI;ai<=U`Ey]oDQmGZ?sKCwXwtxaHHievCcTsiyUWqaYQsvx[xuAulYuyWcCwvVQG\\egWkIXkdhQyPKSakc]=wsusAmij[bkGdk]ujewg=EXKE=Whnef=ySFwW@IxMwbkSIySF@qxbKdUEwKOXIev>ituwBw;BqyEFKn]img=sVTve\\y=xjIHvEtUyqP@pJtIxtxTw`JMtOtEKPuycYLv=V[YJ_tMJAWZDtGqp?qlvdt_DoparoPTdPVs@qFyydYRc`p@PWkmkI<ugEPZinLiYvMTMAPUmJh\\PU@QuPpDHmD]MutN;hO]IPNLyrajhxrVmJ?=PFmJu`Q?tOilRp@OeaY:qJXlj]Ho@yTKXuqxw:qlGXmJ`vM@uvyuwiMdYSQ<pFywiqWxPlQYXS]sGySCtKBMkPAQAMT=@VkeQkMuE=KiUs<lqHtqO\\t?XXiDR;hVLmWn=TuutUAttirqPREunKTVFMVvalBeUq@v>mLdLUr`ruMw;Pt:ptXLr:IQd=vaMlVXRjQQ?ymV<r_LvT=jsUkPDSHPOx<VQPuYMqtlO>hjxEsmalFQwiAYZMMOPUMTJ=XRBexITuf<yMUQ`<WC`Klhjk]PdhTvlhKvkX@_\\QyenZJa`hN_HPv]GbofjIhgMAr]YtT@opf^jqnef]fYsVPbxFgBPsSagpVsuqiV?jnfkIH`Ngfg?od?oG?g;@nJxxjFiBV_kWaY`tlNoafophgGX^b@m?^tJXvGyt@aiofkandl?qx_oBg[dQsQWtrotbxtjOxfIhvPwWyw;Ipuu]qeIeyEkeuKHBosywYShtO]NqdWPdYf@yjYRR=Qn=KsXMXXkKxlyPLwIo^lxytv`]SF`W:QtYqy_LWItQblrt`uOutZUyutYKTMptWAytxPxi@mu@Pe\\nDMYUuWeiWQXK:XX`tKdXj\\mXbdKPxwYMQUXRx]X=LWgpN`xTd<q`usO<O^QXbdpU=TTiWKxV`@lQymCUlP]wctrj]TTymGMwrPYldjmUpm=UpLOv=V_YRX]O?pnLHLy\\pdikAYl\\lk=IVWlSFitjMVxMM=ijO\\wXAmAAWxdO`lRdLYb\\vL@MBiNryukDJ^asEQJBioilmjpURdTXaRUYhNWqKArLiuqG^sOx>NmMWdRWauo\\av]v?\\EYr]>ulQrQPbYYpAvkwNi:VdmVdBwfLVwRfbsihNaayYtZardW`QG^@Qsh>eB@nMfi\\vpLYy<_ernm<owVa\\\\Yce@oYAhohoAwvA>c;@bbx]K@yOOjKNliAw\\H[QfstobSiikhhRQdyNgmqaiW`k_yTOymGhYHnuhb\\ijiYqIpZOxygoha_utX`lgug^pLH[GvxYNeJnsEFgxaod`]fa`eg^q^@Uu>mWRsyyUe@iCx]yrSF;qcoYH`AGD=R[]trsUZ]GigtjuuKgFVQYOAhBYi=ggQoFmoW;UCgSwPKerSX;GvhWvTKUv]u\\;BAUVRqb^QD@YX@sUNkvsuiHUFQgsj=x`uff=UTgF;OV;siiAhc?UfKESMUcohhSUA_EH]tlkRdUtRgHpOrJ]g[uyjQX;SfcQIpkvTOBvKt[CgiQD]]UVEU<Iw]uRjaiYAyG]hMGGVsY^IVNssXorJyDxsC]kEAUdlQurQvtOIlKcwUYqIFo[IF_ByqUwMWGsRx[yu=gYYxw[fpeU;OGyOusWIyoc;gr?[W`AFh?HtCb?gfssY;YDeQHh]xB]fXqtUqeS;BHYchCD=SVDkT??bMcK@tR@IX]iSqHVjTo[urbmKOxWwELWlqd`U[YJ@mNMhjxHVLdT=XJrTr\\uJXPsDHJAanVPRRTl]HYniru<oP]TRdmH@t@PWZdjLHl>EuB=VghlNTJbPorMQ[US_pJPLkm@p^PlR@V\\qJuQlRQPPyje<KRiLLAs^Tv\\QqGyVjAj?AUqHrQHy;]TnHUOXqe@qI\\Ylimelo\\mwqyyutqIiWfDxQyPlIsl@pgUOX]xAxM?qsQuq@tJYTYRtyxirIEVr=WJLUfTvSDqMuML]WPlS\\Xp>elVXJQ`wviRS=qQQSZqTVaMrDqamJ?`Y_EOKtNAmsCINLeWMXYniVkDxCxs\\tyoyW]AuqlySlRxxkvPr><tLeMJ=wVILqauWTjkuNfLw>PuNtPIESKXXaaNAtJiuUrurnMRbpsaIUrlKCAmiYMVER\\EqTdPVERc@Y`XwLUWpupvPV;<S>aq]iUNelyLYpulUAkhuL_twYTmTerdenGpqFpkoPv?\\lPxLhLsBYT_lvrtjSTyRQMdaY[iXJEs]ps;lSQpMdDj^USrpl\\pnauvdLnZHNQPtJqPV@l^xlqqv^yJjDWFXSbdMvlPgPvVET=uULHKc@lCarvloe\\mMloKDwFDPiEK^<SmtKDXKXEmW=P]TyRPQcmMlQv=@utLoPlnJqoCysclsyiqmXXT<Wn=XXTyrYY@LSg`JH]Lm=uJHoDDLMlVYUTYmOEhrETcqyynydrIsQ`qLrwIyY=VpIhAAXpqyuAhj]xC[sXOI_[eSkXXAX=kFXWXg?hTQgpKwBUxQqfiAi=sByytAAXOyRxKcGyycyd?kSY=yxiIrkyPyH\\cfc=EsUwU?XdkeZysoGviYCw_DrwfbMr\\myYiigwBZqy]sHMqe>ibgYCASV@oe:qrkaH@ubmAs_QtbwYiqWFuYmYe<YwlEiVmr^ySx_EcYWi=rcgf@sy:ycAodQ=y:=eZYgLaWYmUj[WkaT@cg`UTFKesmyZ_clSbiOfU?UgMEReW?IIJWtJew>auOeWVUxeAcK=gaEXooc]sVQgBUshqUx:kXF]x]=FQOivkrjkXC[tUwwwkv<?FT;xC[h_wBE;EwIuYWDTwYIcy]yFjSyrYVRAtdUFuuuw;wVaYeKwoQE\\MECoIaKRMUWJ;BJuYTAIpgDMSDU=tlKubKxCgYxEXDyGSGbo]IHeYoiBFiHeqxkcXpYYh_U@sBNcxwSiJSgq;Yq_cE_ybse]YbI;oU=pJDruhj?pX_mreLNxPw<ppBALd]LmqpHhSQ\\veax`EuNMR=plPIno`t:QLf\\YiAMAtKflntury@qKTJthvxHy:emwHT?=QS`syAvrQLplk^]JEiYcdUNpoupsQDVuQW?]qxexNll\\EWf`L@@p\\hV>mmRinbLNQ\\rmau>InMYormuOYrV<rsQq==OUySbEwkqUx`UkDX[`sQljT\\juPR`lTAqkfQNl\\MnhNMIWXyo]QRJ@ukamo=JmirXDQquMuatctMmls;=nCQlBxtMAMius[epmLjLPP\\\\P\\qlTDSfdto\\K^@SDdrpYk_yQslK\\qTEUWrXvUtU;MTIXVuqkWAqkuyOAwNUobmogHR]Yv[puQyNPlKYqypimRHmwtkqdqoiMN@lA`wbAOlaMViyoyUwyMVupyQUVupauOHdKF<nrMy^LLeXWJeprLQgQoaAllaOWqqvArNlsFil?Twsalf]lAMXPxkAxQoqMZmki<MyPYVQL_dYLYXlTL?XYyTx<iWvyXIqQwxJZqOl<plDnslo:Av:do;yTvMYpTJoPT;eYo`jSxSxMJEXkE<UZiMmxWmqTf]Y=YM[HxqYOaqLJtsvAm:\\M?pQMDSnixQ<y:Qm<UpSuReHtNdLrempUSN@ta\\kHtwViWFTMoDrphOpLvREWbAUeUWbhXnDXOEP?QSDtLtHXvilTUr:enXErSijllWSYPDxLYUQc<r\\iv:xuRYlraOCAL^MTc]wweteHtyexo<ukQjQLvEyMviMVpydyTJpyFyVJaviiSlqXYqqwuPddl\\=uU]TLeN]DNLIr<AKpxWWYkn]kI]VoQQ@pPiiL[mncHuM_lOVqB>t^o`_xjJ@oi?dmwd@H`dgo@hnqxqHVsyVyMq\\]ybOQmHGn:PiK`mpvvIvbynsaYgT^x;@fxFfZAg_`\\I>ZT^`ZXhNHvDyi>Gx^`ccqhSp\\[hrQGeAocgFkjhfehg@Hgnwu\\yb;olinq`Ngg^xwA\\w@ne?[o>xtV\\RGu>o`_Xv=xwrpcdPcP@boX[Vfy__Z<wrHXZHPtqww=GxMxZk>lIXvyxyvidB_kI@[cy]K?mZAiRQ`iO`mQ[i__KYelfpaf[iQiEAxeVbAF\\YXecXf:xoWAhvGcMn\\SggPVr`@iCVvSpZY_]pY^?y\\_FhUyvQn_]qtW>rX_Z_PkDidd>[D_^MAweooZWjso\\ontAVbCXh:vl@Iyo`[tYvepdx@^NF\\tgtog[=XZ?^_i`\\ky[yayq_yxprjg_AVf]YvU>`tn`@hlOhfVHamO]Eir_^mxVi<vsyhwsAtnfmqhbAF[DIl]Yv^IsMwrkXgUq[R`yoP\\CYmjyvZV^fY]vilXQxRHr<V[\\XssWaj_hKvxWfeLFdSxnf^k_PxuYieYm:PdA>iZayMOhEVanvtlIqoixqpghIZrp]:XqrAtg>qDnqtafa@yd@yypyP@x]Y`QplJavMxwknuSpco@aZOca?xLxarA\\@qgwhZayn`ijpqltYfJ`wjod^``rfnlF]bIk>Ndgak:fg@FwWFxmGgpV]jNug_`TfhxQeU_jQw^op\\pnfT@_m?ZQ_g?Id[yQqdHoRakFRWDeCxRah@YxHGbVMH@IH<seReSesW_QX[?v\\GegsYpyDMgBYewpyHfIsheVkEDwYF];YKYYYybIuIlAHPSSe?Hy?xs[wrGwP[wRIiAsBYSiYqC[CDbyH?cbAaBXQT>muSGsiiW[?HF?IiyGesUtQBTyuxWC=wEriUFcCi]rsIwMkdjKg\\IrVsSC;ITyxNiVr_DIghmQGKEv@GVciEOWbvMBhmFY=VBQfvOGNutqQTvmrHcct[XVgGA[WywgrgTdOFIis_UwZygXgXlAvR=DrIu?cCpIYaUtk]rAMhbYs@iuUswMWHpUR=AxRwHc[yAEiX?WnGxhyuyQi:;Eeqtf?xIItxSr]gBvqySWvrUIZcxgmD`aBSQyAQUiyun]uxaU<iC_SsOKhHyuFyBbAeBUtjCy\\MgDysK?eyeTjkTFCerglR@mwlVAHnWPV`TTtxVH<j]xqudMMQJ>@pL<YWeT=mN=tPeit`tJturP\\TnTQdLvkTWY`l@yqqdMQDyaMq:tWktPVxwMXroXyt=l^qVFYKKXqX]npYL@erFLQMIQZqk]hlFAVrXp>HuPQMD@MKTVJaT_tjWdy_\\n]qnj`wl`JUXVBUlemj<EQnmJPQS_]uuAvw\\Y;aTm`XWaRh`MYTKMESNLxsmYiYy?UMnDolppR]L:\\XlUxP\\VmeYJEyriM]YV\\TOF<RIyxEhJTTVeyPsiVGdu><NqdWaULE<PydNSuQHiS]yxQQM=aT:eYlyrNEm_QR^mQ_etViqgQp?<X>qUKavGUwtIMHlkPuVaEy:uVZenOaRPxKD\\lEdXmAu`]W^DJYYUierwtKWDrFEpCHnGTmWQxsyNGqMCijKpPSDVG<oClQrpr;QLF=y<LTO`Ok@X><utlj_<ncMmV<rkit`eoPUR=xyuEWxEMETPm=on@MyITKQLIql;dOKPRdxYNLmXPvYxW[`plEJOQS@DsFuQwUu_mPZEnuxybOs@fvwNdRNsjXrFhlDG]AqkXnrow`VAkgxorg`Xnyrym\\IqNN`u_wA>uwqwqAnL_e@axVI];Wg?YvC^gRApGFufocjvgopbO_\\;AtKPuoQ]FHpk_hhGqW^i`Ibs`pbYxw_jeYldF[mQuW>rCIjmOxWaqJNo^V^\\VZjNm=Y`c_kxivaFluxw[_muYtYYjk^a>flDhgB>\\JoaXPwQX[[OlR@pIoe>ofRa^JvfwxwC?n:Nlf@kUNn?Xw>AbaadaAreiqiwqXvgrgrX_cl?\\Qoonf^__aa^qe@iL^_;ggqNihFk;Yto^qwi`QOf]AgyvwqqjAas?>orNighsUVx^Qf=Fwsgu?>^h>^t`lvy`pGxCiu;nf>^`v?^GOeN>syhmmAnawpGOyLhsPhapAmbptdAkoNeBGxe_n?WmOqw`XkeicC>_SPdhW]mfaZh^u_k@`bM?ymxivom[AvVp[Ggh^WbDAuW?e?O_eg\\h>i]A]mAhY^qxP]pWiBvuE>bhQrPGf=Fj=OZgP_eW^CyrVNpHH^QAm_pbPvrEhirPgbgdfNi>>^P?_iyt\\GZooySqvZAZT_]rhtdg[;>vNnytFkDvroferxnJGf<f_dWgvxiFimrnkDy\\y@jqpq_i_BAxaGhpqku>t`yvNHuyg``wlPFdaYf]@eB^e\\Q^jQx<qgPGfXwnOa\\wGjVgan@uIHf:iiDGa:nqZHv:?pOQnsik\\`edhZtViUw[:ij:^mw>dKVnO`wiyrXx[vq[T^]ZfsW>i:vnxHhAnlQQcRIegPjWyii>xpym?As:waPPmv?tGHw\\^ZjafkojmP[qOyywrp@mkpdsqxkid<@eT@aIcQMiNkE_;FqoTgMfNEg]Aw\\EEaoVrQGqeh;OUWeDxkgjSw\\OYG_XcOeogHNqtPGIJWs[CdHIVo_t@EeImEC_XYkGYSv@?FyqtwQsVGCHIs;_HgAhKMb=kxAoEw=B]UUp?VuqxgAiIWbnWt?QD@usWWRVetj;TRKv:kwfkHF]W;qwWytZSsuIbD=fGoFeCTbMfj=DbeT]kDh=Yh;XeiwZextKgMYgWMRnEvteST]TBgRl]fiKGmIbXsX];Xj;dAUWMaBR?T^wHwkB?exROHqOGOyfd[WQ[F>=wMib^mI:aW:uDgygdIep;dneCjWYUABh_t@Gy^]suAVEabMob^?hB;rbQbJcr?;WNkS;MS=ygwaymEhaUio]E>GhUwTRAryYgcEC^SeI?BAwws_RcaebQWMAGm_xjmUY=tnUdoer>KBbUEHWCBgxxCC[QDBIx;CFrerXkCmgvxWFPSe`_TFKf>;bawyVAwuoEYWtJMWl=B^OUP]CUSt?]c^aS[cd=]wUgTkMwy_TPiBgGhomeaCEDQUlqHkCr<Ie@ME=ed_[GTSF\\EhRIv=KuCih;[WEig[SelyRY[bj=XtcFl=bGmuaWhSki:eDF]c?aw?aR[sbCgtoOFHwEu[c[iSUGxJArZkimyYxkcUmv`AR\\cFAuiviRF_i^ifRYxmyw:yiwmxY_R^Obl]wPIFboGeictQCsGyv?VqMe=sx`?B@]Tfwxn]EoIWHYfk;iYwhQofROF?SvcSsSYwgudY;bm]D@;WJ?FTkYUiSqSFmkH@[ipiXr;sa;vuyyrycj]WsECMwVHAfoSIEggUuh\\OsD=Gm?U>GXsyCyiv=CC=Sfw]EjETCkIACdaUsdktTQWB=FR=cd;gnOHKer^oX[eh@WVMeRFeUbSVhEgFOHAKXFOcRKvS[fsaB@eFl_rngXTiSkeWFwIjOIeMFQSG]UujMBUyRMMBc;hEIYnQC^;suKdXCTMIh=MtBgdtsuiAyKYRrOyDgIRsvM[r<sBiUcYyiASEX[v:qWIqWfgggOVyiHqSbWwIAOvakyXcwlQELWV]QfyAeOQCLugveH\\ussoC_YiiQBu?hBoyQwiD=UjeSGyeHoIA=sK[TIKtCCeC?Mniwj<W^uS>UyLTlKttfDNdMmQhSx@oRMYeYWj`xmuWJDnNajc=KEiPE]nYHqYXn]=wdTLxhmnywHHWwAo[TVuEMrHY:tsEtwt<WGMK[Pr]HtVDk>QYmXj@UtjuNbAWp]PRxJQlJXqlPHn[EJt@soTqwyYxlta\\XEyOrQLZUUqukPqWZik?EjP<y_HORxQi]ONLlnIZB>jn>[WSQQtvqYcMtkEeuIyHGuNSCmoXaGriyREiRGaGJIeCgf];DnsTH=cNEC@yDDOi\\=VMmhFcei[SBuIJORdMcL[VMAUB[ub[EGWWOQETiYs;eT]sA;ES=w`=uEWT<[U^cx[wrk[fiOFOQg\\Ocv?w[iX]Cb_OY<cYcobb?cOgbh=W[]wbcrK?rysIeEXgkE=eWowx]yIr=DioYOYejQsyOyU[IjyHyec=wIr]Tj_ecWuyMBqCx??Yoorywcysck?UFSwEGDxSIpgg][ERCovqmjqqMQYtmOSIKfhnmLQtYyMPReEpaxKVYJjuL_=vVDSGLK]HT;tv[XNAElHxrkexUqu@XxV<qWyxKxK]=liPKauynYVRAyUuyOTmAmrj]YCQsotyKuM=TT^In:TrcULkyMv\\ralyTLVuqx[tlRlR_XVAHNNuOfHR[pqPUk<IN_\\Mttp<XK_Lx@]oSEvPmqYpSOxjneO<=pQApNAvoppreQ_pps<XePNepXJHS>APp\\l>mOW@LehM_Lj;LY@QjoDUH]k?XxDQnxTR[hjLepDPY]HNRUP[\\lV`SZavCyNjxw?UQKxujHLapkxDj]xrX@rryvytjgTqx<jwTYihjS]O\\mv]yyUTWEYsZUlM@PYdY>dt=yRJ@wEQVQYXimRytJmUtV\\xoxMw=MuymyQRKxTCAME`pFPxG]l<MU;QJg]\\x_ftF_:n\\G?r]iy@nxGPe`ou_PqDXjmolNVZwxaX?dkgcfo]kP]ypkGYfrNpRvrSifEof^WsZVrXHhE^ZK?[_AsFHkmX_>axd>uqHZRIaLV\\AAfLPfjxfVww_YsCQtcN`Mwvrnbj>ss_gxWbkFyxYsLa^XVmbajFhauG`KXu_a^mYknIZ`g\\??sYY\\;pjSvqRfkTQtxFd`YsCVqrVekGpQI]EPfhAmY^q?_jJgfcV\\_>js_vjfftneZA^nvg[IdP^[IGeqYpMVnpwgk?ll`jdQu<^m@GhShfuviHPh_qpoYx?negFklWaCHpngZ=F_M?jdNweq[EyWArLiWlIIY=dUGRegBmkgE_yY=ifGfF;RSwc_gX<EgT]SAMGH[CPqvKuVS[CeSCR?SPcbW=VAahDkgVoY`MIhYxDghZeTO?ewEW`WiBQD?mUv]UusHomDAkErwBikycwtZMxTYwKMURwDAQwUcEAsYV=x?wGwMEmYcm=waAfmKdrcXmySisohduiLWaeSI=NSPsBxvxlmjlmP@jP`QfeRXmVvDwpysaPURTqqhUH]KVhMtT`ZokJwynQrDnnaw\\kHfEq\\fOukh]qYxOQwcn[jp`yNybnZHgm:ognObF?p`wljNr_`hqV\\Pa^gxro^sxYva>txquqG`rqyYwbdyvxgZkPo_okWggn`rkPcop^Xvaw`ksQfGVgOp^dfkH@Zg_dG_fGYhPa`Svdsan_Hk]VkQojLpZ@VvnWtChnCWxyynsYyk_fuyZJPs^a_[>va_w=IpxajV^gEviRgtTab_xw@Ic^yhYGjfqtg@c`OpbppuN^qhoRO_\\`th?v`xhvX\\_htO^`Di\\NGyAghxPrIokFPvNyvyvkcoq\\yuyyhyAk>qjG>gg^_ZayuyuE`yUxuD`tgxp;aoN?t\\A^hhrAV^[wZ?QrF`cq>wfApl^qcHhIIm^N]WfZGoymamGf_fy]eW[R_pLgdkwxC@ab@_M_qqx^Hxlxgym@wyqw;^cwYrYFh:v`HXqH@esQhi>u_OvDH`LhgJgj^`r[He@XqHHobGh:_lLIjWYn>nw\\O^IFc`wuf>pO>puPb:W\\HHy=gqH>\\Cf[tpaA^o:hmRx_nW_QnfjXc=NeDPx^fofytCiiE>th__nyyb?x`yf]ptCVpD?f<It?YjSVrdiiqArvxyuAokij<XlYH_x?cb_miN_@vepQ`bHsF^\\H`kNQr^N]_hbnhkpxk<VpRxd@XoAxdkNnNHhn@a:HnnW]S`fFiZjoa:OsJnfDfvUW^tIpcFjXnj:njM@mio^fnq>>iZFtkoyf^kAylJPgP?`bpeJV[V`dfxkYXnhQeCVpBve]AhmAewgkRYrFo^GxwYyyw^sHis]Qoevo@AurajJXitNhlA_xPiAydrQnfPkKHv;wsWVjwVyD?]VFr_OqYGqVocnHi`VlKFikGlPxhpQqqFoyAi:XdmhgcoopWapXhhpckgcI^qoAZVQqUFoU^hfQ[kNfs@_IHg\\Wr`^]U?o]qyY^]?qmgXujHiQqgVHaoO\\=irO^mtYtyFrXhsUAldYu<IrNwrGIwkfgIWh[`pHayPHvd`f\\ngTAjEpZ<O_x>vjX[m`]V^okIbbveXW\\:qkPInQNcO^isqqm@ecv`?>e]nv;QZwO[L`\\QWvyh[MPbdp^lNeAVbCp\\@N\\W^f]qdbakHPb_HykAyZ@\\Ra^=Yi\\Wvno[ZQtSa_Av_cFpDhdYHrsiZH_pBGqBA^fYlyWhlWoTgcHNjD?qty`yY[h_yWxuOFilfpPW[AokvAbF^yNXqmOxrIfv@xpyl\\y\\Xxy__nLGgNQgO_ldi`ny`U?gj?^QQvg?lHifKP_N>dSXm=gqWQrrvmVW]FAbvhFuylYRCuiqSWrseGIB`[FI?tf]XfyYUUbccCtgSxmcnOGguXRWsjEcqQwG[Giqu@oHY;ydayRgED]yPeGAAcHUeFsrcOdikGHYiWqf]ir?uU\\Su]oFCMEdGS;agrKYkEvD_TrAuq;SpIUlEufWUOOsRwSa]rGCd?;uvkVYyBiyWySEasSf[sakEfyYMgRfKsZQx<uI>SBQkfSqt[eu<[GU;eYMS>MYGGs?;Clyv_CDXEdYqR]QbLIrniUYarvyVxiDEQSFSsvIy_kRWoeNqHYSb@;YY]usyWYOr`EVUcXoKyxAw]=sHow;ayVIRKKH_MH:ifkQF[GVrsf[wIoOGXGynMIe[eM[D?Mhg?VxaIu?DeGG;[H`SwFUe;Wy[cT`OHU[IJmUUcvUiCkKYpmtryrL?tLCCXyEoueN_SBpOEPjGqKMUn\\TmGUkaavbIs=AQn]wkUOFQW=@WL\\NX\\MBYKYuT?Ek<HWIqM_tU;qqSAJHPOweso]u<]LKeJfMvfQNY=jp]Sq@jdIs<@SaxShEMCAKClMmeMODYAhX]XXpYq:`xppM:Xk^=vv`NpMwVIsnmJ]TnM<melTkhWAAKlYMqLVpAs[mqLis]`XjIXNtqwuLlyQwYpbLuMPMk<L?`J=uULEL[<uPHsVQsvLldMUd=O<qXE@JXEj=\\oNpWCLWLtMLtxiDl;=J:<L:`N\\@NdTL<YnkDnIdnjyu>\\NU]YJMsadTx<vd@miLm\\eP>Eq;Lm\\UuEDkO@YETMLeSFtVRLpttJk]yALVoXWOmo@AYaynvtL\\EubyWT<qC<rKHQo@ygPW\\PmeImuAXblQpYj?HvTxYCEO_ulK`yEUubAveyutQOY<ttajIMN_lxpPuGDTchLaikMXs`AXdaxk]SGesZdlCQNYyuIyxc=KImsQxqfipRAyLyl[myEuU:atApy:dyuux\\mvhYqZmUkxJwUypIn<IrNtms\\OumPMMmNimC]u_LqVPkLEkZPpA\\S`\\N]]mQiTEUoJ`m<Mu@@T\\DP>eJ^@qTTwwQU?TXIyqSTO^dQMUO=AWoHy;QT\\YYUaYLuWl=tcxNfPvPpSAQKwPkjYOciVoHMNAY<YrQmWs<ogmVi@Ox@XMxT>AvsLQrmQdPkQljoIK;Ts\\INJ`jyEvHmuDPv?HJWdWmLonanA@s^ETZeSC\\Lk\\yb`[h^cU?t:qetW^rIa@Q^:f]]oa`Gk[N^>Wojv\\JFkVh`d@bO__`QoDW\\XoqIv`xXvW@dqhgQVjaWhcG[AwwrQ]H^imqcVPvEFpeq]x?\\Uny\\yy=OwwyqHfaSXbuPpFGwxAhJp`CYl^Nvc>]S>[gAsR@fqN\\PHcwhiaA]E^v^Ic]Q^MpmjFepIevxftQsh^isOih>fphm<_hx@^DGlxgmWGgEWlmhdwQwwFpD>v?g`RxbECjueOcrCSC@AIBWsBgBdcG>]RYEFumGD]bIEdo=f@ygm[C:KRpOUIQBVsv>OsCGbUuC:ItwQUSUW\\yGxoYTSC_of?mBjwFy[TMiIiMxkWwqqupwEuyh_aRhOv?qsowBVQY:kwLAUV;yS;DT[UlIyvKcEiGFIxs?ydwHyGEauEr=Bees`sBcESfSX:shmiDiGvZGgYccPcvJCwbYco=bOkIrMdI;FY;FO_RL]SKoBA]XCmCPosQ]HHKuN]WWSS;uWNAfNMsV[h?IrlcY<EtTeXmEfFEhTqGMSGQmgDCREmRmkHOKFR_FWKT;ehr?CmgT=Ud=orDuU<Sf?_GpccGKFQGSCCU:_VlcrAKWW]gjerimysecnoe>Qc@Qg^QTXgg_EupUVM=gvegSUrFaunKGvqIAIy>STZAFgseiyR@USTmWR[yoGis<oJeLltyRmlYyugXmq@KWHopGgZpd=IncH_Ny]t?\\shkM@ixYyyWZgN[;ymuvjgVep?bahtfPnnwxV_dtXmNY\\=qnefcVgtqomIocWFtIn^lP]AvxT@cjqsbgcVwanf^^W`bhcc@\\`XdGHbaYlpFpfWlci\\Vaar`^Hh`SHnIi^rIiUPnB>fUwi?F[mgcFGs]GgOfpPO\\S@qWxmayotAl:?pWg]Tinj^^NwiZqj[gvqWr<arhVmQ^ha@fP>cWYp]?[qxuph\\c`bfNfOqw@i]WoxhQl;Ve>VrMnukN]Jij^VBmcCQRZ[FviIDWs:Ie<gyZlvTMwKiQV@qhQY^lWtHMoPxT@xVeMwEtEHpqqsi=vUtMyYTv<X[QJXmyoxo:hvl=swasU=TOuTgPP`UkvULEtQlEUJLM?pjO]K]Xq:qrEdltIrU=yt=UqtMSEyTAUQhVPDkuQTrplytS@tyhMwmlliModQJwmv=DrKPowmqydm_@J;LR_doB<TdMusEY\\@salnTEO;\\oUAkyawUaVJtXkLT]`UiEVgPup@JVPx^yrVuJ:IQ?=SQTQApeA>vhFgeOxCIq;yiPNaW^rMGgKYtbXnMoiNOk=X_LnfWiylxl[Ivexo@IliwuGHxr_]wykynke^k`nrrQoppop?nWhaChjAx[jIkvIf[^nDOl^NyBA[TW_e>sfAu;`yifqAVZ`PjvWoBPuqyk\\@ijIhfpusw^l^]f^kvHvGQ^YOsNWfXAZ@yZ\\hpdg[dWo>HZx>bKGx<QwdQ]AY[_oixf[Exk[YjMGoS@bs@oZopFIj`vZMVmAQ\\RVfvgjWI^Da]Rv]DGfZvmoXkn^wonoMXunGqhpg\\XffGjQf]uqmV@_SwgIF]PH^q_eMn`:otdq]vhyMAujHfFXZCVtLVw_yoKyfnn[Jxcwgwe@oFgm=isYNyB^dH^ynO[I_nL?_cnd\\ngF_pahsfqo=X\\<>iHO\\givMvgFHfuog?fk@WbFOqwGwx>]BY[Jhl`Affwdx`j`ve;?lsAitVruVnLh\\AA^gxoK`hMF]mP^ximGWl>PbL>pWvb`NhgnuiP]\\O`axsKqyx_dL>t;Xl:Q]^FjZw\\ngZn_vV?s@aaiidSH`O_vRQgZP\\Oo_H@^WAqyax`yvZy\\YAiG@psOgq_[QhhMOnhAn=nvR?]bH`@Xkd>ylp_Zpkogbj?[QWf\\NqBHZLVn_^cNhmJWpdPs^WlOG`hQwxHes_gfhu;ausX`rQtQoag^gYqpfgu?x\\ypyoAicvwmwkv_w]@qjPe>wuQvaIHvQiqXFwnGZOPt<@w=pkh?^cyncPvu_gDacO?\\nQl_oaPA`bx_Q^oFgfx?jOF\\<gj>ipt>v;PxwWf@H]\\wsQIjRAeAv`TwscPfg>qgFsNv[:I`Cii;henAjQfieIukppOvxEH[WiqPwjvQh_Friy^w_gB`iWO[sWkfWhPY[Gpx:^uM`wK_p<W]yGvEFpT@c[HbT>fuooJnmuOo;abbInivr;^]d?okIZnQqqwqAVc^^xUag;G]R>v:Xc=e\\CVFqFHkyHyBjmx[wBkgvwyi;GbUqeAgfiiYAcdyeyQ[Vh=Yh[tkICFGg`khG;wboETGr=swrIINSEG=vTYwjgXaqWf[ykyE[OSfmCSkGUYbYcFXsvLKEhguRSrLQvFkTPUSBWG`KUcAIdoVDcX^]rD]edOcbyHGkcegEGcrSkyj]sfSuHmCdkhGgTkgY<Wb>QRTSv=kThIb[MUOshIaXsAD@ADDsUs=I];gsmF?WgfABMOFnqb\\QBjGrpWxkQRmkTh;eJkCOiGJ]RfsDCAUJ=GTAgQIHsxW>Iquxw<iMiayy=lZAVwDlIYVEqoWAurqvqPViYkX]KMxwIMrDavTHv:lVP<siLXwHT_\\UZajJeT[yjU@LQAR?eLkLtNQv:ITMdlSEPkDM`UpS]nLhW;lWbuuntWYem^\\PrumjTXclYhqlvMJ_\\JMiXtLWuIonMuDOb?@`V>rdQm`IhMNloV\\EFci>ilH^x>b]YuGG[<OdBqvoQxYoyl_c?Op>PxF>ecQuBvgRnZmimU_ZIY^;PjjXk<x_JqstxcWie;_u?WxXQndpc[Yhe>fp>s__\\XqnC`k^AabxysHqkoljGpJinnXo\\i[U>yKWiiOurnklgp>Xtap[[YivYhiFi?YojVifA_Hxysym[wgXA\\ffghf`:PgcGcfNZWGsGNZI_^=WfdpwqAacQ^x@tx>vMNxo__o`oQi\\Y?[RY`nxl<>oLihjnrv_[_@ih@_QXlfgyFwsJouqyhBIc<yuxoi:Gwx>`hG^Ffn@?`axibnc?``E>`\\her@qXHqw@ub^pCGlXhyUVvbnl?@h[Qq[vtEGu>WuMVv``^KPtFFfooZOWw;>qX>juI\\u^\\?@orA[S_opHh=YiXyjexixi]\\IiQIy>@u`YlYgnTQvWn_;`fFGr<QrDnsHqhjgvgyp[_gaqc[@qI_dF__OP\\sYbN_ejP`y@jKyvXajW`ilqsggu@`y^a^Ho]r?ZUxxiybyYMOfr_U<mG]OV_mVPSsWSDUsWsgCQmy;ybj;YoitrkYUiwrCx;yu;uvrITYmENor;YbXOsZCeGYFIyBx_W`GFDMwsaXGOGMETpKvV[h_?y:sgkIRekv<;DOiCSIGrCHMMrCIuL?hmKuj;e;qwCQB`sbl?EbYSSMu[udGAb_iSLGRcGhZSr_aSnOcmyed?u[QGuMHJOx_aTUqtFIYGehMkscyTfEVX=yfkwvYxyoR\\=f:ShVmr;yCvyDfksFAvPgIu=dWIhESrqsu<grfmCDcvQgHToeFKbvmEf;DxYVH=wEEvgcS=_EAKV@MR>_b\\qh_IDC]ec]E>IEC_FDmV<svEMETUgtKw@oGnWrLQi;GBx?iRcsbAS@IbnMRQ;B:]bg_b\\iI>;b]OvRcSQayD]yJgxXavdETBEIlmXWYhM]eZQUbErwesYkCO?rU_wvCDj_xliDr;uq[RNsDCiwaYG^?cd;VC?CUgRTGuqEVtMFRch:[XE_VZQR:mGBOyveb<CvIYiqyTDciTkcGYEc]TdMI@qrA=HJQskib_mCegr?]deeDFcUswEaCy>?UPkeq_hjUcECdkqcKAhTqsQEEd?U:qcgwrneR:cUYevGKrp_TKgbAkEOmr\\SE^KeBawTaSXEeigT>kDDaY_euZAY>KHQMb=Kr_sbZyGqictwBcAGx_yd_GDeF=]DyCD]sx^mHEid=uDsQc]CIW]swOYIUeqwBZqeFKb]oSoMWceCOOSUSrwEGk;TPmDE=iJmW[WdBYFQyd^si=Crt]ExsHAOWgob[_YHOCRirfIHwmVCSV=EYf=sJMhkGcCQR;cCXIHeUXmASmIclGDIWVsMyVKEmsDjOtnChycg[my;YBvICcAVUYeXaBgUyH]IxAs]AuoUsg?IuCiCcd=ucuODGKRaAcyuWYmY:=hg[vCOu`;B:ms;OcOwFAUGnQeKQRcgrjotL=TdUdf[BsWedKr_GB<GRlOrlgttUEAqfQEXtmWGCExAFgqeFYViqv<kHFcvhShKUc?=rn?gw]TY=Ej;yCuiSuFvMSuGGH;sDwfHMvxwIvAHNOvDkxyoxoObwUWQQwr=x]uE?IicIGfyIymESmuxWUiuYxkXvarECYYSU=IsmsRg;fRis`YGJMGE]gCoVAoeNSyqcv]_FnkbtsWeYh?aBXceHAV[_glyYeKb[CwjiTgCH=QIeAXjyr;Ye`MVEAf;WwpCBQ]ceOF>[uKCyIOIYyUm_BMewV]F;wf^ATbWE[aCEmYrqsSCt[atZkcLMbMCW:CWmCUH_rgUEyKTEkvBIR`sO?UWfXM<XUqtMHhR;\\ph<JIyKXALglxEQJPaTK@tJYqDTOvMWOEsETPGLot`s^HV^`XutYbeT>PRoaTD=pneS\\MSb@Y`xshPPnIu_hJRARSynOhJ=y^]_[[vdkQcHA\\K_kO`elHveGZ`yohifK@rQhbVy`pG[EqpEO^PWqh^vuWe>>v\\iigfmD?nMqcD@\\owr`GkY`[:Xka>_<?lNFl[puPYZjwcLvqcNnMPd<xy=vbHOfkogTfs`W\\=W^]?]YAqCxonghUWqEQ[qflEGcVyhraa`qfHIk;Ipixm=vpgXqKymiY\\:VohXwRhirIbfOeRHb@xcTY`yWyQ?euquqG`kQjIN^P@veNvPWbNxxQwC?dU[E<MWv]EeWG?]YeqyA=h[MVF]IVcSu[hcOI:kGK_vAyE:MFKORpGUQkiaobJMfiUf=MbToRACgHUE?_TEwgdWeV[FdAUgMd;gY<SWgeu\\EcNUGV=w^yiJmIGQUggbiiEVWDCCvUkBlkdsOym;eoUyK?xW=DrCFDOi]MFIcsiGfdehEUVg_cm<TUlwn=TaiWd]KGDVGXjtdXxmKTtWYmliyr;xJiIvwqVOdJXqjExL`ETVUq:`YyumI<ubtLstQ;Am;QPZpNZqtkdTvDpRtr]YXC\\mVmt?hTOPv:@TxxSLaW=uWOItNYLbMxAeoSaVr]V@urSmQQyUw`sjes^TrpHN`UuoHUgqS[uN?eXVMM^ANaPtO\\bpNrMOZ?F[J_ibpsAG_pWq`o^Ow`tF^LwkOY[<vas@w;OaT?j;G[lVa`i^qGnoOxOFe>qefNrGIbDF`@f^C?e>>rmWsiV^rX^A?fVIf_IcQVkDVfbhqDill^[M@jthxVXlyPgways^^AoZfWghnfUqokvd^xt^GfeYpEPpTQ\\oVntNbxP^Snuh^gcqv;o^WAc?Fl;hwE?x`hbNyn<fvdHdtViRwn<@uIAuyAk]Fs_WqsPafGon@wi^`XI]@xv^PhCIdIwrAytXxibxwTOuhGhufl]xZYXi:nwC_hLGrfgnm>unhfunZAxb>?gNpyWps`ardGZpx]]fvvF\\jXcaOpRF]Uv\\[>[GxqPvc`grk^dlXr\\immGqOqrwxipyi;xirYinpsWhrPxeww]@nmqQZFioOgrxOf:onJvZGn^NN\\[yukn`kF_tVhUXjePaOvajNvva_pibqXsfIcmHsnVa<Y`KPx]_j[n`A^j^ifQagRwqCPvHI]g^g`YyO@yeWsopZDhv@nfPPobH]vIrCav?Hmw_sxvkrpfZVoqHfnX]J_xNY`UA_rXcO`map]L>L]RbGs;KGl;WKoF]eRTys;SGFQdkAUWmU<Avgst]idyyxiCts?h:WRqau]KuZwGUgrguEsYVniWUIcMesDkwy=xuOvoMsWWFZqHJ=GRMYg]dYqXKGyMORWMgwmudgwDAxRaULWbq_F`OStKWgeTRSdMSFaaSIggrMBqwItiUv_v[yg\\YdiKYAkCimuIceyuYFwYpeg;[YeAIj=XHGVQAhCWEqOH[qsZ[d?aDCgDkIsv]BmCuvMvWkhFCc]kR\\yGJCxUkd?UURCyduDJiRIMe?MFxsqA@oqaVgMPm<NeErtxX^pWZikgxlbxMFMua]Ofun_uLm@raTs[yV`aMiUT`DMQYM<HWQlsapx<qsX@VsAmK=wY<LlyP^\\wEEmgeSxlp>Iy<AtDYnm<R;xfuYg\\Qe<_x=qhah^x_aP_ksOytoqY>yyqksodTgmFO[@p\\mxwkxNIYsuWXWG=WVyeFaqhksTMssY]w[ivTIYAibI_w]mIayBY_VC_hJSCl?bl=uTyrBKHI=HUEC]osaeGrUfsAclQVE[YvOf<gG\\[GfCtYucvAclGeMwDsOxrOwNcVKamslXIiU[xJZqmvuV_@x=tM:TK=TjBix_iRQXptDm_xk`aW<<wkitBdXvLVXauHHsudXP`nG<UA]vydWxIoQ=VjiOiUL[epFav^lJpxWAQXkeKApMutjwfgj`a;vrq>foYeYabmOi@FqUpgAixQow<o^QH\\:An`?mhQk?GpMPw?Iibqs:xfwxs>hnJwr\\WvTic;nZcF_n@eTWbc`e=aydiZVPmT_bgpu<gpKav=n`Jw_HQbIgfKPsIPbI_f>p^RQtLQ\\dhpx_fuA[fpe@_ppQapHe[Oy;sw[cT;fdAC:sdQQSrwxKYYkesowH]=YbiRReeXOvZtMrAYYDkaYykmyVIMVdyhiY<]VnTlDAkViPL\\TPaxRXSp@qlTWWqs<ipmPVvhyN\\Qrdm;IjS`PdhOO=yYpr]mmCeTLEo]=SUEvELjplp`ls\\tlh@VldPAhNw]MOUPGpNEXk`iScpNPM_VYd``t;njQoec?fyanW?t\\Qqh>a?gZXooTxsno];vsMGo>ysMIj]oae`oZV]aviQVdNp_p@ol?gUHyRXhyV]QFxXXrGitdq`tGtgPf;ntGig[g]mIyB@uV_hhhdJ^qsyaAafJIrN@cMXiQqkFHiLa]@hgmyv]NxfYs^Pw[glqnesogHisYatsAyNwv:fknf[C?oqflBQxkig]N\\wWj<yfsGhxa\\h^oHeYSiAYV;CCK[bSeHPifdqDFCd[Evb?Dc]ff;C<GFNmXClxateexrshoqH[uFrNOsQ?p<OpEweu?g@v[X@e;pogXnGvnRGy_Yf?`^xGv?Wuf@cP^\\CHreIZqp]:XiDpdUNZZHh:q\\IhrfIyb^_kH^dPZ?g\\Gp^nHrVxrYWf^Y_d@kdpsTvi[_m=vpCIl[?ouxhU_cEwr>AfYo\\uqpHHnPavZVkNFtqow<iZx>jivipYtbYq_q`fGuvhZEveva]dynIW[jFsPYaQO_N?\\Mp]M>nZFcINcUWrLGo@yZ_qZHnmhVvVaudNoOOf_Q\\\\qde^yRPmTa\\fQf]Pe<gqLOjPvc]vtY?bahtIPi]hs;^v?AnFYtUVo?GmVF_[>m`yptOd]PoWNn>Fu>hx?xh>ftpGtx_wJYnr^i^A^pgwrtJAvjKymiBNssY_rCWdAAXxMyf?hiIGj=HAUB[CwjEg\\OXNMD[mX`cHUIx:yU>AfRqwX[dbYW\\Ax<MCYiIUgvMoGSqUSuehUxpgwMutjGIpmBwIhLKtkof:?vmutiUrnicuCfk=byeEu]C_AUHSS@AB`WUvwCTCWbIhH;gjcXxeS;ytH?gRIH\\=FOscsoWJkWKwfGOuN;YO]iHiuoQcQ;DJQY=wGfQGSoGrmDS=XVkEZygLkdHgF=?IE;wCEugET[UU>GrV?IyOg?;vRMICkROaiWoGXycfeExkge=uNyxAuXJqDO]xZYV`cV@;syWeaysfyX;?bgwDQwwYsvwYRAUdi;EFErfQRvsvoqBCKTqChk]WAKx=UEZmgNCrhqiUChgYI[wFMqO>XWOhj:xvcTKuMntdldpq<@KSxwL@OgpwQYsv=vHmXW=wPXLRdNOMr\\dpIMngus\\pS?HsOmsw<NQiXX]pBYKOYqaayoMOBXyHYvmAS>YVeqjLEs@LXaaRYlusQvgqXxpVI\\poAJVykcXpXMsD@NRLV^pyVQvMLR_hrJhkmIKodm;Ivupw<QKALVsiOU=yd<q=HpWTQkly@yP\\MV]qPVTmTmRMDPf=qhQQvmki`jApMr=JrAviURSLM@atqlw:Em=TRMxSnankantAr]hJTnh`ntugk`W]ayle>avofSVhefdffoPGtfghrqqC^rMQmR@rCHmmNugniFq^Foyq_sbO^Cys\\vmfOfUAm;hs]Hg;QwwV^_abPitmQ[`vcCw_kv_YVsAqisPh]NlB`\\GOkHnimxrvOZC^`Zfxk?fXAoqFhrAw]oeOP_;VgHNpEfjx_fLIgEAksnfCn^en`JFlmGsvnreNjOOvu>wDHk_Pk<xraYtPgddFyAXuXon]OsFn^oXxR^tD`yGfeNo]L@qjOpKAbvpu:gaQHbUxib?tf@fRho\\@r;ou[QyH_ds>k]`n^OfkqldN_hQa`Ov_XiuN^VwsRPweyfDxsWGZh>mlWoGgvs?dDnoj@fkyZ<vwA>oAw[:Qy;ao\\fd^PqA?hfql<>]BG[P_c>_^QY_fQ^ZgwAHfZQ^:X]]Gb:qrvGijoo]Yc>VkAA]<Oh]nn=NvZW`^phyh^apjnon:HnKh_b`ak_\\myhvgcNn_KO]?FZuPcog[cadYNyAnr;qdP?dtyiyaZEaiK@alYsyPkRYuXAfCVjUoyWoa[qujGd=xaQxsInu^>xOFlYyr^wf@@lv>c^^oL@bRV[eYij@ZBo\\xGp`Nj<F^f^hMw_x`weqyTw[BiZiI\\WIh\\_t>oufPpX_hEahQF^wFqXq]:XiTnxhWi_acy^faQ`pnkoX[E@aopd<Wy;yjravEAhxIr=>]wXyh^wuitqY^yWrI?vjIqE>]aYjaqdHNvH`sHQf_ItAG`ByZWavGx`]Ofj?\\EyhXIZ_VlO>fEiZQ`yyPiE`oH`ojI_CFmXPve@n=wfQHddPlLohMisCHkE@hh^r:qlBxhry^c^pdXh:Nn]f]eGnYxaCGgHpbLHhGVr=GeHN`LP^V_ovF[]>xaXZ@Xw`i[h`blyg;x[enivxvb?s?Vbu?jQglC?jtflFOxu_]AHf`_g:hw>@xN^rnVcYoc:x`Com>YZJ@kb`onymUPnR>_PadvWyVwa`PsC>wkFdy_[Wf_fOtHWhjq`G`Z?oZMfi<wuGPrua_UPrxxsxg\\UoqmwahyiYYqjP`sFZ=XjsphuXjkAe?FegA\\Hg``F`Ma];HoRohtvusFn[VmbWv`ig@^hWGx_Vns_gVxq\\ftLHhZOfJvplabWhdtHf=G_o^\\UnhTGrghd_om`YeQoZHFZSH\\BglcHrJO_R?bSNj;fe=WnfQ^<qoKIqjGf;Pe>>]a@bhndJqoc^nSG^;xnb@rfhmqvbs>h<IhZFl<o_qN^VpelFxx^tHf];Ityny=_sYXaAnruQv@xlx`[oo[tYoV>rgOmRqjdyly`kTimYwrNIoM`i;@o[veeHb]opRioNxpRfv>AZYVcA@sLQuBAdl?ZVIqQPg@VoTgfZxvyh^f^c]ojl?uNnpxGpCQa;owoGvVVw[?qbYi^N]IAvwyZvxwcP^eFnuxynFoZ>oBOwJVkDF\\;@du?`hxZZqm@W]OGwQNlDn`NNvrfiAi]RWamO[Qay`yg[s`yhZGUhSFu[IFWiy[xA;iyYFYcRf]wM=uyQdQ=vbIus]UbaHkYCY_yaEHkWTbiHhOgb?xCkH;MFgwiuIR[KXs]XsecI[uTKEoqDH_eUErcIiLkDDgHn]CAavVADskBNwX?miV_xfEtD[UaAvfcsQmI?_b;Gv^UCSccyOgLaReWF`or[GWwMflqTMYdBixaIdCixCOBCwVxgfPuXPkGR_EiQBnctgWYFcfZYYH=TFMV=eE;;V?]vMGIheCH_vEWvqAw:oWokvwiwlKY<;bbowqQU=SfaSWesWkkt;yXHiC[AsLmBcccL?usuy:eBuMvA=HTOGm=rPGRlce@mFMoDTAX>;E;IR_ohauFd]iy]Dpcc]kIn;C]GuNkyJgxteEcOUOwxSYtRKgP?xbEYq?UCUtokYcAfHGw\\GbqkUaMFhGG<[uckXRusGCxt;RQWbCKEFWdkqYx?WBMCwGHGuS;Awn;tfegkqIWavycGuqSsGEymIW=I`yXrwc`=vVyYEAvFEx]cB_;R>IH?yRx?y>]RRuXmSyhEIjEd[Mt:aGIQRZkGfQrZsbScbKKb<avo;FvCrVuyQCUT;XD?CwqgxeyYIVVoI_KGIYUESCRovZ_wvIbA;Xt_h@OCiUvQsieydjaeYUQr<x=xwDTLqaPiUloPR;djYqyi=saUXr]wytqElVeHO:YMSEMsDWCERSALi\\TTDT^EViPVv]SU`mmyrR=kW`Xiyk\\iPD=O>Pkj=SNYO=@w<<tR=R<iN\\`xnLwJQP;xXcTnBuWmQy:UoOqrGXuL@MEmnJQvwGiIqbcf^LhpSF[Ix[Gnf>>j]PwMq]:Xw;>qahu@gxV`\\`VerniFfsOh^>Qse?c`?oJ?^IVlI?mR_eNVyoNpSGrFh^MG]V?qJgrqv]wnk;`eTF[WW\\HX[avsIQ^W`cZ?nJx\\_otGAeY^xnwaPOsO_an_g;v\\D_f]`vCIeBFa;fsL`ej>yBAmBHmR>tUA]CgpJyoq?lH?`bOr]?d=_cIXxA>_[>]tFdsV]IXkjW]cQsKHswfaVwsRanLojJpbQxa\\FuWgZHGl:omfw[ONsAXhv>bgWtsw^r@_xYeA>rsPvoPp;YqiFcUo\\ihx:VkOx[_Ov<gd?QcWW\\<hqF?`igcfwtHPf^Fd<OaMy_nH[mFmN@cnnnDgfdVya@tdQWyv[?yDwd:UgOAd`Og`mY:Ks?afw=GIsgCYuuUdlOcOqxNkSokHC?XdcG@mcgKgb]hU]iY?W<]YF]eD_BvcgdMH<;YC]VmWfvaE@gGukFDSugkG:uER[Rl?Hf[YtUeGQFTcgLgByKRhmC;SuC[BRGGY;YmAbWWvQKEV?WOsEI;DpOYLwVimt?;r??rVuTeUT`YBgEFZYFmwWL;tjYBL?c]YIsgV;YX]cSCmu@wDrAUlAwaoyS]TPOTU?EvyVOWbjOHY=yOAYU_UqqrqCvssysiuRUgO]BuqDEgvJMgPCHtUygqTG?hbdTEhs]PRclK<dlR]O>LuZDMTYUKLs:pWW=tSDR<tWLeO>xvpLNWyWitmgLM>ijD<R<MUuMxs`X[uu\\PrTINJiwg\\mt=Khyj^dOriySDseAkoXLbptrQR\\hLEDQn<ULuPkDvBTli\\NteJEdQ:txniudhWB`qmhkqtu<xJyQvIAXiyyvAKPukVDRl]YVdlmyvjAyqtq;HtQdQIttvxxwMJ>HotMLS`WYlKWtQ<pRoPNnXmb=Vo]R_\\PwEK?Hr[]WSql?uQY<X@PXtlrrYRj`pPQL:\\s=mNF=sD]v\\qN`LtG]nopp:DXC@mOXoQTvYYnETw_dSf`jBurApNreQXtXo<Y>HpwPWOUuXmUIDutLqMLtuMS>en=]lbxoNUrJ<QFxLxYXIxvVLSK`PMQn>PYuPKsQulIL`Hj=UksmQkuN>`TBDJthSkXLRTvwYNKPwaiYB`wmPLPhJP]UQDnFETZDr;yTtMYHDkOPNdYupTrFun>Ep@HMmdov\\Q?Ql`HndlvWeoS\\tFaL`YU=QnrLjRAvmYsFTY@iKEHloIp@`yT]kpLtSINF\\KiujtTPAptqtQEpt[YjjtVaEVhHXJARaax<xL[lY]iOBxWVAOV=JTimd@wYqYqmJPlXX=lNYj=irK<XEpMVmlHmWm<ycdL_QTCLuZTsPdSJIJx<J:<L:^b;_d\\wAEhgEduwX;sWBSSb=rKAtUuFfUGn?FcIYaAvvkeDMfHye[IUrMijeELIff[DjWyTYEjewewUGgSq_uDgbDECqauuiSxCW`gr<UvnatM;eTGe<arRqVFwcIMul]FPQfM?bSOEMgybeyOKfFgRBafj?bW]bNkv_ER:_DOosZmBkIWj?y:gb==g;_ErsEJSXD;V<eb_sdHIt=GYsEdw[wpoy`As:?t\\yIKOSE?S<]IKIc>;XTgGTYgAYdwciqoE:WQgAtFdW=<midpJ=uwxJUyunqVFaQjuQHAXZqlWxm?eoPurXxtyHLQqyDYY[`kf]r\\aW?=p`LQiAtupXgivedvDLQpdqF=rD=wiAxA\\NHyMHLP>uncpW_epFhv_QnRTpt\\LxAwn]oOaXaHkKaVWTNCeKcln\\xQS`RhTl?TToUo\\pl=lPt=j\\EPEyvMpkIUlvDkPtrV`ntevSpo=YXcit>Hl:ISHiku@kbxWjYVlHPu=Lf]j;INmQOidlbawxmNUEL:ARcpKFiT\\QJRyXrysBPPAhskIQ^PtSm[__bRadBQlbOq:ngHImR`]Ni[ygxh^kxgvH_]yAuAFdWiq=NoJIjEHbGXeZvkfWp>`\\GvZ^Wqjvk?hl;o[XQf<Is[a]A>huvju^i;>b[^tR`d^Fg\\noaHlKOpjn[XFr<yayYZD`dOAegVnWgo\\PmCIb_YZsAv]v[]VqgwZlyqpY]BxeoX\\gQcWyhspmUWjQNdo?eJg^^ofIvqPQkFan?Gjov]BYhFqsthhGhxOYe]Pb_@k<Vh;fy;A_kweyx`d`vmV]__e_awAIZvWpWwrpx`yH[]xpWqf?PqWn\\NPiBFgEN\\:x]WfjPyl=Io?Hgv^xjiqV^`QIlCw[kyfynkTvgQHm?YxR>sIVkn>Z=O\\Og[;^cc@p:o^BHmCQrlO^HVcFayDwi;?\\dYh\\?[?@dSwhJar\\Hrl?xYPcR`dUwncWn@Q[ywicigQ@`kWgPxxlFZsNt^f\\XHoK^kphdsw]mhbugxaop@AgiWqvFZV@]NFy>Ait@u<Oe]?qkytyY]tYtT@eK@d;VZcfuihpRnfQOwRgmTWjP`sRoj[aq=W\\:Q^PhrL>aN@jNPfSnnUWllHkEVoO^lQwlra^SqbsPq@VnSgp>>\\CWkFXZoXdmQ]y?cLAuj^o]Ww>pkeohG?k<aZKNa_@lTPguYnTidJ@qFf`rO^mxuRwlvx`cPsNhjLQoR?rhgupIfjWoU>mYhgM_^pObK`nk^]@Qcpo_ZGbgY`rQkR^\\CHwdahF?_@W\\Q_nIYnPam>ijpGZsadGVZwI_^N`sGv_>m^YlqP_P_rH?_QqayoqZ>euphY^k<o[gPbX?mJWa\\_tNyof@xsp^xVcPWggfnC`wdg]oon]wdxG]Qo[T>oqV`BGhZyoTinq`no?oeGcFfcfIboYpYxrNy]y_ZQN]G_miptj>qwWa@oevQ\\^q`HO[:vhbywyq\\CxgYijaaesg\\lWiqGkvi_OHmKn[FNcBxqLOZ;AdE>sSi_\\ylUXhEFbRVdvgZvpwkicE^irig]`gD>_<alu^b<P_[Q^=v\\>PrMQgMHnr?dTQrQ`nifdeO`U>yR@lfoo^F\\VGnGGsYhw]w^Yvbs`u^Ajw@jtgq`gksnpQI`YPakvhpa_`wwwq^iOvpnjApZjFqcWZ@pZ@_jOq\\W`dTx_>vjAfdQWsE`Z<Yap>jLfbFNd?IpaNueAjrF_awc`g\\sajgHxpx`\\I[R^lMa^`>hiY`lih\\^^eN\\FFn@Xba`oEo[W_nKYjcYppxxExxlvalpeIA_<ydZ`tUQqIyhp@xhs^]RYOUIauXidaQh?WYuUUI;rwcWucX\\Cf]GuKEXlEgG_ULGcVQDlOicUx;CVoot;Uh?eb@CG>ICvGCG=DO]vaGdIcVNowRWHbOT\\IyJmTAYXqgfkmY`mCaasHkdKGDZ_cR_HGuSBwwLMVC[SgOBmcvLkDdEHVahqMBukFl_EVMgXmePiVEEVAEGjWYFmcFQisYfYoy\\kb:Eg^=cM=T^cipSwRmCZUT\\cgU_rumIsgCCMdPISFyXoks^kBHkTxKE?WHAcxLkXAytJ=VwAeBmT>QBZCdFWcvQDOMB;mdV[bdeSxicPKcQqwAEx`WwKSWpCfp]CU;It;FHQwmGXWUR<wC<iYgSBIIGVwD=Gx@_U=wsfYRV;DjCBTar>sWQCb^Svs[FMeyR]IsMD?QVKcTxCbiMisqVfiygwCZ]vtYE:Ayd]e<efwuTfIrsySxMBokiDusSqg[KRrarHCstETrssoIr?Ct;eV]uTass;ysleFdWH[QsOUdX_HE;D[OR;qtSGs=gia[rfAHYMy\\wUhSF:aisQXi?UBuRGmBqMc>;T^=x\\ehK]cIgEO[sX?IIOCASsnuGc?H@Kr<csd[FSKEfyRdCe<mIYyb;_YX=Himcwye\\;uPUc[gDfgecSc>Wuf]eR_bOsxugVJKWDuH;IIyKX\\=cOUwbafsaBHUVI?WqUijSRHiY==Tk[rYWuPiHiiG>KY=CfTue?Eu?=gt[XMyYE;WXISaitEWfX]GdaVEWsEQujUw:;iZyuwggA;vXoUWKupIgFwrgCDZQHsQTToUAgtnUGaaSkwxOOYoQiWSu[eXBYfnSeC=Vl=GE_gHAhVUTjOuCMfdmfJQTLMRSSU^ceE_B_eBaoGn?huGsyIS=sh;qeosCISwlDsvTKeQthLXbqks=j<EklywnIJ<uRZdS@LvHHqN`l\\iJCqoe\\mpiLB@LTIK^QkHPjXmRY]oD`SlTORUUa\\]c`ooa\\C?mb@bxVeNIhZapD`efpkY@uOqbtvn=oplHh@YeDyo\\n`hflHOfmoqbNr[^lYHoBFndGcTOrxFpfohBfwsIaNvv`Gd\\YlrPqiw^hXyjy]\\FpkW\\x@xSxc\\axSXl<_sri\\i`yc_upybyY[GipLn_NxvKa`dAcDVctvqb_madssx<YtuUxxqxEgEEAHQIghkxQEnjYNG\\sKQstdRFduFewwAy:hJyaK>@S]LkVLJCaxFIxueltmlI<JTEWkPNNePxlnBDPbqjjARpdyfqMOemeEPKyNLEo^@Su@kcMo=yP\\@tyLj[Hvg\\Y;Hm@tyY\\KDTYkqpWDmVqkfMOEhnETTRMOHIKj<M>Lph<t^myVDRi@n>ql[DXdPW=MlY\\sa=YiyJu@xEDNA<MEATm\\Xe@JpXLNURs\\kWQrXasYQKl\\La=w`TQLYut=vfxpWmp:ls[EvVhOFmLetQlYR\\AMQunLiYbapCHS[<PQQr`myxen]MV`po\\PV@Itj\\XqMUV@sb@uX@WCdwidNKPqvxJ]dN\\]OxIN:tmTDK^qtseKWip_aYPQThTOatM>axxHls]SVXr:IsbmsD]LpPkI]knHO<eRnDRM`TBpvbQsCMR=ql@qL;\\pHLkOeMAtTl<MPQwrhonPJPXOREyDMkOERd@u\\YmHEP=dL;]XLIQn=sJdUMIQRQtgDx[UyVAkSXkeIO>YXwAOyuyX]lhyqI=kGUlY<XpUyH]YgYOYhr=yQr<rytLAatfe\\oioywrOydXWk;Hj[^ldh^XyicQqMNpOgqqyhZv`HYZqpmuQjVWwZIZBvoTf\\;ndhyjAHyeY^rnpH>mE`h_?bR?dPhhahxvweAai<gPKXQUXsKCQeF>SEiMiXWf`WWAiFnihNcTN=EAahRWC\\cTOUR;_x\\qf`AtpKubaTd;Wh[GZGX\\AEdyXxUBcgiQMV\\]YusB@gTfodQgWwsIPcYY;EEcbUSfRIsb=XeyBcEtTMX[mru[u@CvpWTR]rcOfEUEpAVSuWeiWw;BqyEE[C]]EvGxCAY^]Dsoix[teeHnOEoEVHoIJIW[]c=OiOqRUcdPUEgmD=EhWsreywyaHhMy<IVfki_ier?x@we;oUggUx_gUScZeRZsR_GeeecPkHowhSoG:MCcMyr?DesEh;Vk]fRIigmCT=T^ktBGSf[e<QB<?gjqFBmVAaCwedOogI=FMCFiKevggDmGW]e=CC@ScdUTOmXD=xI]S^iWUQWcORp]bn_Be_Yy_HC?WdEXumX]yWbofWwH`?uXubCCBDCwrmdCahOWFa;b[GS\\Kh@KHcIBZou<Qvwux\\WTdCjBMni]XVTPMyVj@X[MKuuxfaR[@lQDVQQtTQMXDYvqMFhkFHVZ=pYDSgDWeumk@S;QVy@Rl]lNXS>QQbLrXXK;uL@dTPtno@R;HWaluALM`XOv=RBTWV]uFqQflwU\\s?XVpmwP=NIUkSEnjExXhkmIKVhN]EKHLngpQZMmHeJeTlnXvNtUNIUnHmCMlkDKKqwmySjIpZAs[=M_QPNhwu<pFyksAxy`YDTUxMyG<mrhypENi\\VwuNmXt=dSqQYv<rB@jCeQvuxNyLLdVlTYadvpIR`uxZYsGXK_Iu?PRbPTbhlCIvNuqn=lY<QAhJCHLnlqqums<ySAqXLteiWwhoA<vX`Ls`VIPOH`yADSI@lZLVMXJrpXuhraTw@LMoPOlhw@LUGQqJ@KbEOk\\wYpQBHr=tuAev@yv=atityUaYcIVI@RoUV:HTmij=UJlqMxHvXhJ=enp=yiLnDMTC<r<tUb=PJEScYjGPnTDu<<U>Lu>aVXLsuDTfALdTX?tjU`J^YUThMSMTJUpmAOWdyFEvgPWYpq\\Uj_LKyXWc@mEaNepX;ekMlwO\\KV]Q?TpPurLIoM@wjiYlHmFLxQewAQvdQLAlWS]WVAQ;`K_dPMIQnljKqvE\\KtPNDwbQAvbwmcFZYi_YGbC^ayidAQ\\Eif_QrjPsqw_KNJktqMSt?eQmVQSttATRyGDguCKBHCyqWyq=itUd?ESS=u?[Ed?xIUVJeDC[B@KCA[i\\ACeACoOYOwyNGhciriSrJYXiMv:oen;FMKvwqV]GBWwXDoRoeC_OXCMrJGb<iBP;iKGD\\ir;QWUAbmEWnWI=QYFQUNWb<SCeuy?scwoS=_gEQYpAesouPYut=BhyrDKvNEdQ_VC?hLeVcGtcAFK_fJOUVcgPUDDsBleE=ARDwCLqVlcFxSV@YvIqwDAyherBkIrof>?RSwDDccjcSA_gjKFAST_UrouiiGgUWt_?y;_eQWWaCb:uu>iWAGYO?Br[XlyffAyKOFkGc@ur>GROufpiBR[EvGE@wIkYu[uwFUTd_UO]itySySC@auB?h;yFwitsGIkmucMuYut?=uNOdaYTp_T:cwAEfvStFMc]UTBotK[IpQTZaVWkIPiD>IsqYd?[gn?bbUduuIZWCa;UuEeCgu`SXs?c<MXD=x;sRPKBGowxuDo;UQwi`KFj=ENkioIBdCiBMRxuSxqUiiHLWEtSXxAEdUrGCDHeWPQU<Mx;?BturbUCEYh@UVGcvtQgRsR\\sWBOr<mrOCRa?cBUglkXKSxdkXCcv@CD?QF[WYe_BwMstWwoigq[SjCGwSxAeVYaCx?iPwIf_rfGxtQTqCFJaWRkik;bvecuEI`eigwBZqe[AFHIeneR?;DCoyLoWVoWSwdMocVcvDehc=BZOgmcSqYHKsdoisC?eR;e>cttgvkGu:[SkWRSoSOMgVSclQGYCeIGyL]VjmvGgh[eWrseN=CM_CZIwqGG;?ICagWGyHkvPSDrcd>QhICWJiu:ICyEULIEp?ve?g^cHWmrHIiqKXkYB^uvBsvx=IfoEfOWAuFNgt`AfZkrfSx?KuAISXwDHsCdOVYSstkbdUTxMH:aCUSuuYeLgbTkd;EwtCg@GessyxOcUkVM[SpubysF>ARLOefOV@]IaMHjERngeP_g]KF]iDP[gncdXuC:oELOxZcTbAermdG]rFqc:ST`ci@EDhet\\Mu^YiZMsLAE<irGGyvAWwaEk?HXQDwmdR=iuqCVic_idO]gggdKugq[rhSb=cBF_cFKFYyuI_WhSw<WUsaU=eBZGFmOG`EcGsBvsUwEYv]c?GUtCscIricE<?dJwGeQr>Oyl=v\\chxUiUEW??R^SrMOSLWHTeGn=yIGVYUgUicr;yDGucMCk?YveE>CsYWGtaib?up[YOEs>QraKtcutkSfqgxpoE:WY@WBssrJcUBEcjICNOxHOTcadJCw^cVfMCM?UmufDcvSQfW?s\\GUGssIaHfYYbSsS=rQEWT[HUuhn=tVYYisvGIsP_Ihex^_EX[XRkHaYXD=r[GbsIRE?YGqd>CTRgGAygtuFeMus;YDSXyWtoqyNWRbMcY;UrcTgoEr?xRgGRQSLKc\\yiQMXxCfjqIGmFJsESCbsMvr[s`UDGGgmASWqY=?D`obNWdaAwbIce?Tv_I_cv\\SSDkhXCcduUeSiBQr>yrt?Xj]RsSVkoSMShcGBvitpwH\\_y_QGNMVbSiCuEvACmAIWYinseYWxS?VXgDJ_t^wt_;TaGg`KHcmbTUHAShiUDRMFISVOuRysR=UVsUBkeS@;HPUi@aE:sEBiRMsxRqsi[hl]vfWd\\wtCyCo]Vb?bVmHGoXUQBD_BHCS<mbRUTLKyPabsWc[IsB?ugmvbauSkCJoDiGE<Qgg[bjQBsSWxmXJyGIODngu\\Ebd[TIGTFKCFsbS?SMGIxCGB_Hd=do;BwgY^=caiDPCGyKf>?CGWiEseyaEFyWwUBtsYPutrUEJMcEAuJAHLwWwUIngiuEd\\kFgKRBqdSYc\\Otqsw>Uvmsy`[uoKUvQdtIWvGEY?R`iYyoG@AbrmHmYRkGYwggqgx:[uMyDCIuL_F>QXbOffidlAeFUuLWc<igIqhgWib[b<?dGQR:cB>Ub<?X?GWjMbQ=DxUb[KGv;wyuU;OFCuYByEQgyScEjwv=AWX_FDST<qDNETZkb;ieZaUK?U?yGcKfr_sY_voQG;[Stqsdef>_TyqBniShMrvGVZGTeGflarK[C_uu?Hj>hLxIl:pNoIROEk;APUqP]\\V=LTP<sE\\T^AORxVI`vM\\R@xN^YOeaqsiKiin=Lruumx\\R[`r\\pm<iq=TYKUQgMRm=tdhYnepeYVPlxR<TN@j`=nwmt^dsPTT]tMOETJMLxeUOlt_=Ph`Jh`u]ev<mmHHRwTnRUyely?pjHymkqyNhrJIQ:pjTeP_HPkQq=\\uVpoXHkmiRWpSqyUaiWM@p^MRrqQCmqydqQuvAAUeMx?lUUQJVaNbaSZPtgYrHQu;xYEpoTpOZLwJpOZUSGdT_QssQXxaU:mL[]XXdWS@r\\DwkDwU=U>mO\\PvcQljXSRtL<EVOyNSlnJtsKtR:YoAqm:axWtXZUR`dj_QYMToN]XNPS\\dPyTk;xKw]JbYuOdKxAy<=kk=VPmQn=LEtUxQLF`UPTSgUJM`YftOFdK<tpwtKsXuYxOXxoX<jeiWw<ZlgrnohlIaG_ZdWosaovxZfQfNEcEcO[f`Qr\\yixeiK?B?wF;CbJeX>=vEiUxMGZCE\\YrRosEmceYBvCTtkDjucjEULcfu[co?RUOvMoI[Md_eDMGd[gWrQw@kFWcwokyuoUiOFkGiYSvQaIAsByQxIAdaYDGceWMIQ=DLeD_Ow<[C]gGHyGW?w=uYYAIA[Bk]gOmvKUWNcW=UY?Qyg?I;ySaqUbocd_gWWX_`rahwmEPWhRE`Mx`lvDjO<yEPS^UyipLCLvpttjau?xRjppqQKHPRt<lwuPdNe^>kihhn>]L>v^xuGVb;Wp]hb<nimXcYXlMQmvAiM`]Q>yj>oSi]ZXf@PltivgGqtG_=FjyycAHoM_\\yoiXh\\hvxfHqLN];naMyxSOgH@aAvgcgujw\\HforOZMVho^y^vqiPeuH_Dpd\\_[LGjDxZjVj[qthQvwpiZvj:qaQve^hhsgkkXcSF`^Xy@qibIx@PhDFwxntQplJ_vyqcdIh^qpgAb_Gf;VsgpljhlexiqYuJIy<y^X`c@PkaPu^^pGy\\uf\\x@^dn^LNr[AnPQg]ao;ymM@mH``Ghv^Nrvpk]IbiWwgga:vhS?nrVi?yeSWiPXxi_siV^\\Y_U?x=@]Yxu`X^lW_MXeHyvG?qsyfDPn>nqOOll?f;n^HOkAOih^[jY`=p_UvvCftD@_dXfNisvxtGw`vW_oNiZ^qNnpmO`WAxPVh=ocHX`=xuqQt]Wr^vjDniXVg_i\\n@aBXsggu@Pw`hoRxmUprRayfNoAx[\\?gqi\\Bat@Htfgd?iqCw^tInUN_FqcUNiFP_Mwd>oaPO`u>k^O`Ay^wp[FVp]n\\Wnbepk`glyxsaVoNwybvuYQ\\vigpntJIgNGyaWaPo`WVf[flJ@\\JGjYPu]Xc_>\\Lak?ItQa_]ihAyaIHoQxqExeAguDXiSisMwwbGlMxhwX\\M^u[P^sibn@yogpFgtAAmLFxWQ`]?oLgxi`uA?]>qqoF[jIaw?pGyei@hZAcHA[F`rsGk;YkmYy;@]dqjhYhV@lS@sbqui`bhh_bihOGd<^_PPvCFxD?iIpsmHtjIauQi^ngWOfF`lRn\\FicrAyUyyUnhYWn]ntdWuh>^xooGosqWxRNpb?x`Vs:@^ZykDQ^Uq`Zvv\\V`r`_fhqQfvv@vqwvjYwVioAv\\=x`S`rihjMn[?oabHsUigFfekxZgiauApvikiHfRXZtPyKX^BalD?`CylTOgIVdvsJUIs]EeuBhYRU_gkaRbYU;Uuc[uKeTIqxFcIuotXqt=;p?<Y`xTNtuOhJE<M`XOD]l^tO<ERltspeULijM`jnevwAL>`k;PKEuuDxuAArCuud`JZxNMMrCaYffp:Fvj^lV`nGagZ?obpu^@wN^]raqAGvN?u<itJYok?`oOx>IbfYq`q^Vwxdxd[YayOxk^kWfaD`xYniRVvy`yh?_sQZ\\ailQnjvcaHp:Xlywyq>dLFcFxydyoZfr;Xepnl=_gxG]fpp<feQAn_NvVf`nHf^Odbx[FH[pAasfeLflh`rp^xI`kZXtyH\\_Qu<Nu@WbtvcC>qCoukHdfqlMVuMVkTnyaOufW^CIbL_sBHkVF`Awqffnq_igwvFOw?`fe^bYQeOQpFYrXqhMH\\J_wRNoqWpgqq[neqfl:>o`@d^vZkg]Mf[LiweOeYYbtwiTvZl@dovdiirsV_=H\\J^t?V^bieaHk`Ho[PuC?uoatX>adXmtvZ_Omy@t@@jkHnkysbIjxn_mFfDn_L@l:phTWrIngth\\?HtS_xCn`MGhC^uJgb;^^cGlZpcUQiFYej_]]GZqpZ>FrUNQ]tYsdFwgjOI^?t`[y^kI;Sh>qieCHyiciWVNWbmIrAuE?GUcSrR;EjiTOOevIY[gRHQsWyX[osYgf^mHE_sHgU:Iv=If<cVmwH`wxpoE:WwgudiCy@qtSKf_Ax`=VTQxCAX>cbxeyYWxAKw^cEqsHI_GJ]TZ_B^MH^mdGiXR;Cl;XlaS^ieQwuIWsYKC]EDxCdxkB?Ida?T^mv<EbQKROOV?IfsYu<[i^SHkMxFYDvMdHGvdwHvGCamEs]BYYiaqEFuYiYYb[Er;bvoDMsvLevBCXtou:eWpEBQyieieRiTRSRyMGCgticYKSTyuxq;g@YvbYHG[hHae;Ue=?g[yTxOEUsItIHfguuuCHuyPyg]OdHAFP_S\\sHpCbgyymySryxS;GOmV>Mxw]XVSUs?w>agmYW^CVW_U\\Cb;Ir;=EV;I<aHvEcpqG=GG`USMkfisXJQCwQCfMVToYVIFkoehSD_av<GeFyviKwxueg[heEB:cdYOcheXsCdMQgRAvSAxD;T>wHhuB=[gcYIQUtxqSMaxXUF>oWtarrew<qB?mtEWbY]UQIDfihIisssYMmGv;hyqDxwsvwG^[trKVoaGFKCEKG;OF>SyTiYeOCSGY]=xmkU;mXh;TWOC>;UuCWYmFO_Wl?BrOCmwWjYb?=SXQiK;rmQd:[EC_VUySZGsv_U>iGqku>wRyQvIIHWMG[wiPebCIBscGH]TxuiBYePIVHUeMuvkcy_yG\\ef]=VmAuRkRXUxT]Ew;YBKWZIUPcwScTCgtUQYUuC:iPIaX<IlsAUQ<RHywL]LnuKy<Py=UNYlYDllysVlnHHySEPQ=oq<piXJraUJprvIssqlLDmcUridN>tQwPv?TOFPNImQD]LEAnrTjvLr[\\TreT^PjWUTSxKpImHeXgXrKAPImp=IOTXLlmJkdKt]U=YLI]QDHxY@Y_luvyqylkipyIxK]ArauQGyNneM^LlJPkcPNSQqDyNrYMxEwQDpwyVxmJd]UAek=hpMxYsyvRLvMXtrYwXuksyswmJmuMsAP`tuuqY^mUtYl:eo@HwilY;dwwUykHwwtwMDnbpvSXt\\tTGAwn`WjLNeqm><rU]RKMkoUqgXKryyUYylANslouaqixostxX]M><kuQvGDKNiRDpt_ET\\`S?qno=Up]V?mlNtnDiVsLpMel>mOQPOCXss\\UODQpMVe`yAMO_aMhdrP`OYPQbPk_@TLhNTMK?MS\\@S;`NBMj:DJf<p:qUmXXpilqYYWyoaiXIusXYqRirxqQlHPuTPwdQWyWXuqqiqYIxwaVPiVvmYOIjDLRQyNmDkPhub]n\\iothX:ePHLnuxn=aXsdO?]X<ANgPvYdTk@Kn`SLqOsHSB<UF]vnQO=DS`mVZ@k;]UWHNbQQcTnQALM<qhDoN]jh<keTseImCILk]KMIM[HPSekDUX[DNPPsdYN]uo^yy;]mCTMQ`w\\tp[HW:usdmt_XR<]nElsaQkTTWhhtfEruatiIL`MsmEWqYqKPl_DsU]u_]oiEYSPocTwo=mUMSoEtkyNxiQ=@mrQmkiSnerqAXfXt;Xy]xnZukwHRXyMJtxE=LyqOQxqrIYnpsWXRS]p_AywyKZ`XnAYNTSTTs=aVmLrS\\K`<XFhw[]lEYY=AwkQR`hm`HYCpKciMuhJcYT`UQZTw]dw`Uk`Aq^eTj]qKiXXINFUqmel_qOKQkm\\pRiQnUVyPTpEr?PkrUWCqKtpRX=MpeOjEotQoCpTX]TUhldxONqvdAYlIsiQvXXYXQjAlQkIKVqxPyMAIwAuM?av?XKLMR[]y`YmkQyYHyS]unQkQMKPaT:xLrAWHeU=ay>iNVtqoqTfqQr=LoDpOlr@an@DubieLplCXgi^aIhyAx[]wwCXvB>s<Ghvq\\npfa@dexeMHxlGdovZ^PpRWbGys^_xPgpI_nF_krWpGO_tq_b`m[IkSItdI[Jxcnvt<A^Q`vqGkOpgm`wT_l<`\\[AtfNeBWeBPdPHqZ^tnPvtxmG`_hfelFoBOeqYq\\Of_PsigjWWcGP^gGb@@h@nqtncRipdaZKW]?Nt\\FknIi?^^[N\\gYlJxrRwtFP_=Ae`hnCvw_arKhvBNq_WvFQr?^vxWyQorJi_bGvLPop^_vNebwxmN`TogEObnwo>Fx@GhGpnrxdpiqti`rfyjyljvdeHfAyuwi]dvgvWpFQa_@erNhmpZWp``dy]DgERjQGNMthAxKKdM;SPcT;=s>ic;aBhUY;Fo?GcFnfeHq>PvXacqq\\angToZcw]l@g^WcagjTFaMaeYHkf@kSPnLOeFne@QqNYhhOkvivOPwDioMnmKWxI`hi`kRWmHNelxjXHwd?gEwyBih`?nN__CGxQy\\Y?iHvcYpyKnwwgwU>hly^YNrWxasYt<`]?y\\>OaRgs@nevGy_^mwGwS_uwQoQYrhp[:i]R^lo@aCn[?AjGwc[peiXrjgarfj\\nxw^xh^cwqtyHb[Qu^nryoyQNnCqcjYj`WgXnlgob^GZtygKpo:A\\`OpBfx<yx?v_DQsXNheAmph[roqL>cpNhCNjK`fE_jcFn^arOyfnqfQonfvgJQt>Xp;WyChfHWtIWw[>hthZGw^APmuW`JYsagZcVcJP^ngutnnkF_nYZ^Fw@niJVeHVvIaZ;wtL`\\UO\\=fu<x\\bF\\[A`P@`lfviQlhheDp]QHgRH_Ewg>HfiGqf`qrypFQZ^^suwqIpbBwu>_jjx`Tnsjn\\xntlobK@^Hw\\LPlYfvDnbIxm:xxQyi?XhGW\\uncyfk[Oo?Waj>\\ohprQvSywyw[mwl`>tlaeFvuxWa@vesw`tNnyYsxIfT^]qqrRQe>nch>[=@^CxuZ__]?ZKhbtXZROf`VmrAsAGfy`iHV`qaqCnvvWh=OuMo[DGx`vi=AeYni]FiRwcRVkKiox>l`^_WwpIp]dqjjVg;Pd^oj`^oh_sFOsSQolfbovxbp\\NqlNNqAondObdo^kVhcff>?dFA`_i^FrGSf>ab_yiDQT\\GYTStkIUneS`KiSMidgYF_Re;I_]SFgG;KxV]r]cFY[CNEghIwX[UV?iFwFx=xbkGXMIAOSsOG`SxhgvZQwoWGb]HaIvAgEV_IsQWNwRAAHvwy:ketYhIQvSYHa=DFmS\\]wwyu^_goMH:;BB;RLCTJcD>qeqmy^kUx?x\\[IkCbgYYuYIZataItsEyvkEwisyeb=sWwwEuuuuYhRiieaB`ofIQslAV^QDOYbuWRGQuc]Vrwg\\cS^CgmAyGyFkayUkx]mWyiGrWV\\gc=UfKMD;MuweeAABF;WsErcWvUCU]oVhOUZMIfKtB=CZGDOMUBcc^IYQMx]kwLCfOOXoMeBSTh?UMawLchbyHOAcZ=dkUu@IxvMHaGFPYbE_CJGRdkGgcEIyfHgdkUw@qW<URO]CcIXuSWAQSKOsF]e`=epeTeqWMaVKIdtYiYCUHaIISh?QwmkGRqetmV[mVkWhvMx`=GlqDJgxg[dLQF?OXSSyhyYukxvmvIEHuCYSSd\\Erm;xase@AuAoI\\SGq;E?OBhgYgIDFaeysGEiuOmwswC=wRIOVlQv?CUKIRD;GqYXGSHRSeG?rSChpMbN?EjiIhee_Mb@;yeUhg]Yyibe=wVSiYsXw;iESiECBFIiT[YmeyEIH>Cx:iRU=FqKFmmYDiVmGXPcHnIsacsTytLSePMspod^]bdQX[KSuitBaVTOWPwhXEXYaW[WYgagnOgWMU<;WpMyiIsTgsD]t_Ye^KrVMXewT\\=HnEsNcIPqRasG@oegOE?IBLObyAwbACdgtDKWmYxL_gG]SpGtfeh^iYeAuHkr@yRkkIx[FqIXDiRNqerIF`wiuAEHkyEyc]_YUiwbsCHCVAiEqEFbeHjsxVYdRCEVCbm<KAlYcyl?IP<\\qnYQyILI]y[yMZPXeiwRYxJYqjtPqEJhxtF`xj@p>DO?dsLlVCXxtMvriurYpwxRktMt<yOHkS]MXlP?yx>inyPyQyPiINnEYSIlcAus\\V^EPl=S>mPZqQP\\UEatE<SltP=aX@aRdlMiXyUdnqIPF`oBHnPyk^Qn:`VkMrb`sS]qJISd<Q>yJn\\tq=mK`Km]R\\PvRDSOTmSPSbAwOqYeIsEps]\\Nw]N:Mpw@QFAMeQyR`uPDwMdYx]wo<taASS=v>qvpLMRtQsMLAqMt=KYQyNyMZ<WpDPoityhrZYjiaJH\\M<XNTqoXUmMpWNMyfEqTej[dTTXjRiwYDqpXRpPrklp@hJhLos@SoDvbUVftWrAN_<ycIqtlqyQvN@mfqo\\AjOArHiq==xjHPo`p\\PRdqOvtp]TK_UstpYdTXd\\uTeWSYN=xWRDkPqTTiqTpS^=j`ek=\\x\\yKTDyDxuqTqp\\qXulgPNPpRpPm=PQH]mZDJGQpBpUGaohDqBUqJEsLhlNaXGayvLYw<tNDtEXWLPtHaL>qWRdJRmtjLs_QPvtsAXwtPlvXtueLkQU[@T:HW?]R[QwEuO[mXtMKudOUTQqawKPuS?kYhq]w^Hh]wXbDFrPqirYZNokVfjmN`<XdyFxZnqvy^Ypb=_c<HZoinROx=QsDqjnAgeI^_GZM`n^^\\ENrwVak>yVW[P@wUpbbYkiykEgl?pbynvQXc\\Nx\\WolAcTw[[WsM@tbIoENuU?nxxmoH[Bwy@OoNqlH?knawEahkXig`iOovrIoI>o?HeDxjoA_whfHYZcNySihapjsNhYF]e@e@oa^^sEw]gI^LiiBGfiycp@vWqmQfmq`yKW^\\^ex_u`_hxQhkXxTyt[wrYoiHnnZ>hmycyfkTypxHkWvjHVnkoyvnnIiq>@dVy^@@]qfglGm@ymE^`Gyb@VfE@\\r>sCwqOagZht\\OZq`elaf>nmR@xdQh_qbPhjP@yupeqfn``lc?]eys[`Zk>xvw[Xwr?wnWQlhG`T@owaaSNyo_vXG\\[A[twjQguLhp:g]gfaeY__WlMYcoF]Sgtr`pwXrJIsSob;abqaaSNsDwlBxZUFcsHobpodOeD`^FhecobVhcTFqWQq<WpwfhYfxC^ak@]TfaPFt>Qf]HqsW\\gPoZN^hgulXeKXyIA`fGeExpJ?p_qa;_mkGctognFhSolcVgvNtApkwXwWAqnAwYIvEw]ui\\SWtkPqew\\HnmtX]qfqoqiFpqwy^:Hv[^igytynk=xjHFntxhin_wFxrnrXGiDVyXqx:`\\Inl;nxBwrUn^QynuaiMGxvGtsT_Kx<qW;WHCmHwCHSMe;[W]sU:sHg]fGsD`KXwcv]?dF=rcMHWyFXkSyaYDasN[XCYTLybuGurgyCQVQ?t__rnEbNWWNCuFAuj[wcGwX;whWSbIiDCwNmsNQr[wF@kgQiXSkxEwXEIhLivpGhxiiwmr=qyPetf?fiGdnWcn?s\\eVPAijCSbCC]EwP?BoKdJCDEOdlAxbkGVei@Wb_OBducyuDuoYpyE\\mwSwE[myusu;CyToBpyE:ArCyTZmhPUcWqf[_gkQE:WRC?EU]b:ITPWUegt>av>@Wo=u?PqV<tZERDpxQuVTQVZDOEIStQwOHKNXjS<Q?QppDSixOC`NgPO\\dW^ERWxoGISllucap_arh]W:pjrdJ`xtaIW;<tdQLH`m;DUyeUTUpNXkbDkCXsRUt<qoEeTehTY`V[LJwhlqPLcpk^`W<=mIqxLivILl\\uxWIMAawsqkneyJaX@MWRho[Dm>DneTOOuwiEnfHXtemIqwemRlDNciPNEwBlLS=uFtNomLn]Ktxl_ajbUQbusGIv?yqrYVnxmuTj=yy\\YvRTYGYWJMLiyQqIoYyr]yMuAOx]wqmYItry\\xK\\u_lummOW]lCALAmwrXL=PjZit=qKh\\msMM?PXNHyR`m=mvAaPnTx[=mspXcqtQ`Rl@OyTS^PlB\\MfPjFXNEyq[Py^EP@HQdlyBIp:ijCPjVpVKTKMqtddSmdOgHOQhua\\SSettHKEDWeYUpywfDWEmwKeQxaOBALu@PWTccxtJic`@s@Io_W_g>wk^hS@mqfud?oU?tlHhlOi`ygpY`spg?a_K`sLPc>hq@fqrql^pioVaqVklGq<Hl[Hl_Y`rV^\\fw>oqvAuWnuKVkSIsCH[Vfaj?\\ApavykkAsioye_kExxfyfHWn`npQny\\YhRx\\]YfCIhjxyGyg;hiUiwbX[<vbOP]^I`FOaPNtK`rNHmDWk\\G`xpjkofrhbP^qxVfufwAgiy^tVQvpGo>i`OG]ewcZA_eHog>[VitCYcbWqvPxRo_;XhUXxRpoMaumxdVao`nfaooCNZaOnJOo>W\\eHqHaZd^k^@[bW^LvtbxsEyuMyhuFq_GjPAxeW\\LA`of`?XkQp_CIcUa`GqoO`_Aoa^f`MvfLwbmQ^]ahk?\\g`nvQZP>awvk\\f_UIlDQ_OacxN_bve_Gb@_bGP\\O^snole?os@eKnn^yblp]egutPfbGsSnjX`nKHpNo^GOnC_kb@irpo;YcOxZeQp[gdgFbK>[Lvy_xpY`yUxq@WwKybkwuigyU_wNVlOWdvqbIQkqYGGfbSDoMvlIYRwrpYVrqeQIs]Ui<_xycXtYyrOHkmD=Yr=;uOMuCSHnSt\\grJQcwEEcMb_=W`EDDwrF]R_EDa=btaVgEC^iYLwV[GUJQy@oUq]ViorRmr_ME`eghMUF_UpuifCrE\\KPiodHw^djjdvhdtoevJXR^`XlqltpkNDXMAK`mpLLR@`jdipHUxgTVt=na=lMtOQpum\\UDevMAPIimEpU\\plmQU@xL;iXw\\SIuS]mYaAYvlXftYVLlLLNk]KVhNHHv?pM`qV`=X\\iWiurQmYqyXjExTiTNxoVmrOywvUMMtUuQa?FlTnumx\\AnuwqerHxV>o^YbZf^VOrNhlV@sUwbJ`qJp\\^^hyQkxheVf]?heb^ffHj;NuGpZ<Ws@?_XFhgQmfvxONdrQjrxub^q;q_PFeN>mkpj>nkPwr\\OpYXmSpbAYf<vpvVxw?jH@^jgkpG\\xXf<anLVaGHaJ@g=GnWqkP?gU>hmP_[ycT``C`qKywS>yWFh<hjoo_\\y\\KxpCYoQGtKVoHij@>vvap?pquN^yNrsG[KwsSQxSGo>pjhx_of\\yolCApnNpCW[DW\\HW^`hutgowp\\[`wfi\\\\fcXQlFNeGP\\cix]GlJ^qf_aV_c[a[^O`ugdggtbwy`Wo;ViaG]AoihiyrqtmwsZYiy?xY?pqYmYArEveyQa`vmwoZAyajIbfYiZi]rVhpI]VXica[FWnZfeVXpoHeNNkpngTiqMfvDgbthfGfoD`j;VbMPxBVd@icwhcMq_v`aL@lAq[Pv^gga^g[ByhGnjwHsCfq\\apcW_KpwLg[oFwJ`gPhfdnwgV_[Ol[W_[Oc=h_gGx=pyw>cmgpn@ghodohoQiwUnnn`bZXyiYyQ_eBY`EHZWi\\QOy=Im_Hs<_wuGvqQpVos`Pm^PjfamsVx<Ns_Q\\@vjdVsnAbnghZanJx_KH`khtUi_NO[HNo\\xeHOkkGx`GpbGmx_wkFoI@ePvtRgan?]=wrIXfhXv;A\\En]OVba`[;QysOcGFakQf]Y[yWZv@y<^wYVi]NkynyPqeEY]SGmav^[iaxA]tvcyfjsx^y?ZEIhjXvWv[<qiGYwJIuoXcxv`RQ\\AAeENZQfc`Nf?Q^`vuTauf@wVa]vHqVOZQq\\>noW^[DHbZN]rQeGHiNibuNdjGy@?\\rfu<?^WOqlnZhndvxlox\\Qyvui^kywnTr?YkKhvGT:oIK?S=MgWgRaYbBecyCIASheeRLeb]id?OH[KGkgFfWwheHLSwLOGueDkyE_QYnKd\\cxdkVFMsy;SqWgK?sh[RviGLIV=GVbExamR<msF_f<URR?i]Qd>Kr:aSRWUJse=ud^EGcEcZPZDOZBpxkVdiImcPgJNe:qmv@[mNp:nv^GxdXgApdhieEfnE`ugOf\\Fn>ojuoajykjXvBI\\Vpyfym\\yZYAy@^oWVakQyIpyM_]sxwG>mThm>axmwl_O`>geF?n^v\\l^aNgrJAtZnb@xZKO_RAsMxi?O\\MAmk@l`WgGqxBX]AHyNn_fyfEIbx@qXw_MXbyG`kpuR?q>QeRhov>lKfdEf`sXknhngVw\\f[Mg^lPd\\YrCGmffq\\WbRplkATEdFEyfogU]HtGULSwVoUhWSoIiVsDdut\\wD^WDqKT\\yrBuxUAHeEiFSH_KsNUD?KexoUQMw^CyN=dCGvEwR>_gegU[MY`MEMYt[kCQOgEuE=Ov?YgNsSDmgCAcM[Yv[hUiESgXtCGHYi_;SRasQwiBob_AVR]XZIhMwgJgVp?C^St]LNGapFtKuPl:EjDmYd\\LjMyipyLlkR=KW\\umUP@lwyUmVtWOQnOpyhasIYnpIqIQV\\YTyxOeeoXMpW\\t>yxXLytytjMvqlQ;PsAlQ^txm@m:IPPqj:IlDMQjepXLviyUnEq_mlGmmBQJaQrdTyRDMBpJgXPQeJsMKwEUxAsj\\KZeu]=tlHR@axmQULQyPIKb<xWyUQ`RDLLrepWPnF=nj]MmxjVIW@HmnAke`OHEsmqO[<PnLl<dOuaTaLr@uXaaj:IRuaq[hwa]NuImWywJuqCHtwlpKPN:pnpIQ]dRFdL[`tIINtUPFxWeTO_emFdviAV@EkJDX\\TRQxMTHKk]TthXCixuIweAShDtjLTQIV^PurXw]lNl@YtIua@paux;]wyxxX]KX@Q;pPs@XDeNNuj@HPalNTxvXxY@=lvTM=it;\\TAlJ]ekmTL_PV;dJkHM`drxHMKMP?\\kFDQMqYFav[XuEaYYPWOmRk`RD\\p`@wrHjfel?\\MwEylXLwlThdoPtV`@RumtDtL@PYkHyvQMWHVL@V\\PLOLqIYq^mrbIyvMxTm^OqoEWdexiUYb`gtDfrFochNhExnWYl@obV@aDxwfQ\\?W^BW\\gp_kYwLPohFnD^`wXqnGsg`\\C^wk@^a_eOQ_n``owmewx_?uW?e^Wn_NyK>aTInMQg]`dhp_m_xeQe[at[Ak:isHwc=YoN?hjqyuIhxykxA[Q`eYVn?Q\\FGxWns[Xrr^yMw[[h^tffwht>ArrA]TFp_isnNh<I^\\ibRgsh>nRoo:a\\>xkPfongcD@rK_]Xayqw]=IuyqxYGdMvZcvuuw]hgyjy_<igq@h_ysya[mQv:XZZGiLnrTN\\rXlang@yvypy^n^`pvMPy?`k_I<iD=;rZASSSFkABj`UUdoHXOBiSrHR>lSUDJG`p:IOGhOmixp`kmDUEaV@LU?o[FVvBIxQ_uJvq]O_@poQG_pGdBG]Ivt;HgUIx^w^B?no^_ramZnbP_lFQ<SSfwEhwT[gRDMWk?HqsHAwVIqyy;iWwWDYxl_r@mGpuHpeXQ]r^qHn[H@ohiUG]sfvsr@ur:?UM_fl[VMEu]SSfuCY]SRWTmqd^gFNyCaQw;kGGMyj_EKqTHGhVYSDAh:oIIIdXeG^itQAUiirNucXIVHADjoF]ObPstSkg=ix_oD<Ex@md]KslmfxYR_cibktLOyOcrpeDEgRk?dm]rYqSNmwEOsxEc?KbceroYUoWv^uDsEwiiUxUHJsFLGcFCX=[D?IyJEysocR]bVqxXyx[Iei[YKsdeUhbSE_=iGqB@qupAbnEfH]UsOBAOcVyr_QvB_UsOUS[H?muBmSAOVeaSgEF?EF]KtXuV?if[ardefKUg[MvTiHV;In=DAoYoye[WX^AE`mgHMvHpwqHTOtvNqNoPJ;myr`LLTVG=KVYqXQxD\\TDpkRejn]RAdv:QsO@LSpXwmLauopHx^iTBHJGQrIiQjQOfYuo\\j<EoTPMjptI`RdmlrdQehSDXPA<wrpOHxwUTRmhqpqLPUtvpq^xQVMxEXS]DXsySPPx_DYMMpKHYwUJC`qZ<lNHuAmoRuSE\\pHdr>QSMXMG=o_Lmr`WuxrtDM`iloeU`UuDAY^pU?EmRQKN`NUpOyQsPETpEOVAppxUPuRTErkTPiTMe`w[mRxYSs]JHpwqMljHSXTVlmLgmXnHuTDjExMoMJqpv]=pRtuhTKLmTQdmeajaQsHYSYyNg@X\\ELmlXjALHtqkikrQsYtyi\\tAdYFdteAMuHWq@VseRk@UcAVAAsBMLMPuNtsi<Yx\\KkIuu`T`iXfHocPox<yLiUUtThLjdpqKDUbAS>XWPpxfxs=AYnYmRLQsQKNyV`HXK=ltPlrqqL@QhEXb=oUtJEAVfpj:iKNMkruswynrhRPeP<`PjitAqs]IsidqfdUCxwvUrW=YoiUA\\rUdjeiWY\\nKiSTeUdex@@MFQweARXDuW<pSDRtPUnDYPUOO`ulmWDQm\\mrSyXEHU:mludt^QUR`N;<PLmoYmr`<nXHvLyqkxn^yTdUk\\=ROESyDmwHoDMr_mp?`OjUsWeqtXJ=<MRlM@HNBXV;`JcXoOEW?UX>uyiDk?QS?]qq=wGyW;quAmM;aSuHKAQMKHSEdOlenDxxElk]tk]IkuInlLPDHtPUKhAwbLOuqx_ToJdQ]=Ud]Mdite<wtDo<lKG@y\\YQiDK<EQjtPIXmXdyPLSI\\QBXj\\AQMipTlvbTOO@kfHsXpO@QMK<Q@Qw:mo\\pvvULG@U:Dmh=xtW]oQeMfvdhq;o\\rfceO_X^aOp[QfZlQcw?alGnlQkiWmK@amF[PpsLfweItQ^koVpBG`RF\\BOm]i_yHxC^usquYHb[PdOH[uFjSf^MG_qpgA?\\aXeYIyI>p]qtUGtrphGftkH`F^uvx[Qp_V?b_?gJo_n_e;Oup_uxwZx>xQxiGPu_I[rVZ=@]shvPF]h?^en`bhpt_w`hsDOoJYwgqfMVjq`uDXaYNiQnqwIuIAry_ve?qaydyNk[xtxp[]v]wA]@xkWvbap`aVxr@ifnfjFj]_oxOdWwoOHxpfgAacBntoggQau:VxG`yhaaEoe`hcRVmuxcaikKFukQvtgmUfrXitdg`cNrUA]Sfl^hghOf<Vj=VZRnukXbL>aT_rXWqlgbd`_nf_;_t@wrJw\\I`lZAbkxg=Xj=P`hwk^ya`arpV^xVtSiiMNu^g_Xhm?GnVob?_wa_rP@aSwgonsfvsXx[_OhAflDnwwAyiXfYIoM?auOynn]u?yE>xXpiDvndYxRfqaqeNowwx[`AtJvhhnZM>a@QwCW]=HrZ_goHp>pqIPfDQgPhjCHoc^ewPiOOloHtKIdVa_B?ur_]uwbkomJviIocHOvD@^l_^Xgcih]uNiNVi>Fs]Pu;qfVvmAg`Bp_VoqFHe;_uB`tW^ar?\\upZ]V[W`obNjbFd<OiqN`cW^N@v:G`qwsyvyvNagp\\XGyExy>v^?Ywy^qyqivNxuxm>yhxyrywrgwewQ[H^ilyxJOal_l]?vR^cZE=GrZ]UyKtPghlqW^gbHOR>kB@kBjwYYqIFwcGGSL]R^aWb=WBMdhchIAsjAhFQHWcESCdSWfnqurAyr_XiOek]EbCbfsXAsCV;d_ABC_yG?cwIG@_dXyxGoghgVNKfL_Un]TxoCKmveAcrqwaoGV=rQkIyIYfiumwBioYAYbR[usWDYwy_yU<YsQoGZuv?YClYVF=vR[SZqHKKIX=CQyCKeGT?GRqBpSSbuy<UbdQi@sDiutCeCtoHUGigUuoWuaOTikxnGC]UXyqbEGDpWwwmY^exTIh]ubFWxO]bG_UaLXHdQPUoOEyTDqEeljqoL`QKyoK@sYqS;mpNMtIdw]@kZPRZTsfEKrdJN\\JsXjUIkfPX\\YyGDRHtxiquGhMuxW<YxIym;irExljmxvIQV@qiyrjlNBTv_yVHUsRUqjlN;pNaTPj<m:iW@\\RtDRN=KS`lRMKp]TE\\Xm`K:QyZ\\uI@q?Mp:lVI=putVSpO=QNZEuj]SYllNUmq\\ryHl`mlgUUCelChWouT>qocdv`MP_mveHmBuSjlp@DjMyrFdPH=O<`pR]WVQYKhxfpPWpQHEO\\]nXyN\\pR>]kBLml`YcYybxRoxmtllXEV;EmVASaDtgUqRxYvIPFtwsHKXeWXlRoPjLiWq=rK\\Rlpx>YvRHyvyuZarIeQ>XJuuxZhxlIQvdySxyGXWIqQAXmIem<AvcxT[HQYuR;IpMDWOlJ=HKVixT`n<aSw<SgPl:ixtHQQTplhVALVw=r\\MJqPxx=L_eY@duTEn@pu@YuE@rKUYJ]UJpUqdPdUkhuu]]WwMJq@MSXuBXXV]wumltmOExwa=sDELNupoawYxyslswEwEPPsHremPkuryxyg]MwAtA=XhQv?]yYxSxMLA`JCXMWTM?eUvxxfYPIQntxVIlwtyvYtrbIsM@me]s=IMTlvHlrZMJqHU`TonPvuqRPuUbiM>pL\\dUSIjRuiGnes_bHHpj^^sWlg?gpimNnp]X[ofnvXcwakW?oUok:ifuApTVang];iw:?sC`ogAqwqhV?gNIhg`dLHcMNpBaego[XGoffZ?xjigqGVriyys_msqyM>[Ham;?^XwrkY\\rxxQqiGvbY^ia`cp@`>yfgne:A`R@rkn\\Ug`eYZjot<vnVy[>N]F`leNbiHwBabhGwgqgSQf<W`^p`uOdygdcntiw`<v^ePjJaZi?ykwaDXy[hf^NsvakgxbZaxDP[Swd_Qd\\agq@g=?sFftjht>YwynxeHh@Ogq^`:`^?Ok_Q`TXtMA_hIu=xxvquyor?yfXHrNYciNnl>`BPwHh]RIhfAaHqmuvjeXpm@ap_wRwcfg]=Hr>nkk@w:`oUoulHp]NkjH`;XesWuTndqnyKGec^\\ScWCb]Kvd]f]DTp<NAArgeW<tnB]mXyqg`mtunqLSyuP]@YR\\UP\\vEAx\\DRnANHDLZpPZPWH\\NrYQudP_TPRuXHpk\\]m^MShAqMDRZYNNTk]yn>DnUHmYxrXDRjAOkQjg@tFlNjUm[HNgUKOPn_TLQLrbEp@PT[LYgUPVAntARePpe`T_Feq@[U?vPo[dWdy@dN^Z_>cV>wpXfEArbglgqpWpZfwuQVlUfnk?mWQ`X_bXA_U>tBXj?I]UWj:Iw^ncg^ybIlxWbTaxr@a_UoAxFWE;KhdWbZkUi[ijQB`gBKUX?CdmSVkCVLOH[_wOMsTeh>qYamsYwRaguHOcWYT?=CkQyRAuRkSV?I[cXdAGSObCYE=GCVQCKUWp=xrYXM=ceyDioW\\qxw[HayVjaxsGWRqf;ocQ;vKyEWErsIE;]vdcTo[yg_s@GFHmgLMhkQw]YvEMckCteuC`uBWeRLQrr?tmmdZGwiYH;WUSCbEoFmSGCwbNervWf<Gx@qHEGb]oRkgVLQbf=DDMxJgw[;sf]u`[cgGRZaxxWgAaicSgUoSZqd<]Bqov<euPOH^SYpqwOwcK]yU]G_MFBCujAPC=vb]MZLjPQL>lSPHvLdyX@KVDwNiKCxsODOxikgxsFlNjUOAavFUKyIwilmDpJ\\hTH<O^MNiuta]v>dTTlu?ppeIvmturTk<EYDlXkPLKupOlYAUuoIpyuVOtovLPDPjs`p>Ak?PvI]L;UtATufmJdml:IPPpSZaQLpJZpXGPJx@VUUuQQJatNtAtQHSELpYHNLUoaTo^HsP<qgtR^Qp>lSSMvnuXdpyRyO=eXepUydUaDqxtXiQu_DsRDLrdywLpJIO\\mTc`T^pOWPxr=teQSqmk_XRR\\SZqTBDwp\\LMESU]oF@SnutjLro<Nj]nyqRAqx[ipU<K?DnmiYLdxG<LtIrd@KVxL>@wrMjZlpu<XfPNFTtTMtZUlQ=qVuMNel?lOUhXDaJhep>lsKHkFLwaqNqQypeNjMxtUJUPQQLllURnDts\\w<eqK@KVPNcmXVMqdqRmemdYKLdm^HokLPihUbqYQyLAIU\\UsZ=P;XU[aNULYg]PdiK;mkJ`l:EUWDONtrj\\MnMQg\\PhtmMpOnTqn<NBHnGtQNMovYO_<X@LQhxkteYXmrOIuHvh:>diHw>Yca^gDgxUg[rNgMwoehl\\Vlqhl=pd^Q`@nsp_^Sxlk>h\\yw\\@iGpdYYug?x`HkHy`<>q[hjZ^ls^ilOlapxjN[?o^jWeJ`rcNn\\XeXPyCOkf^bRop\\iiZpssG_wqluq`=H[VQaK>aQYxKOpw_qsAq=vumWfOhwOo]mh]ZhupfZCXh^Xsb@dn>dfFy<@hsW_Y>p>ybFGb:nhH`l[IkmanDw[pQ`@N]w?pgQlGa`sVtC`]M>qOy[jQsDFfJ`h@@yS>sTvbhVrgA]=v^Uaj\\?vFNe^fjlP`?fpGXdjhfkGhX`vppfYvsTWvnw\\dQf\\qqFnZ=H;OIEEcZQG=cRMsIxMr;Uf[QCl]DfOcj?S<svLCYmgr]ETduYOKCNSx:mTBsY?aBHoIMegTAEWcc\\AwPUrcOhk;XtYwsmDr_GcYVfSb:irOuDBGrCaF@SWuMDrCuiMveqcP;SWaF@kFjUUawSqYEE]D;WUb_iPSb;A^TxoZfnevnROlToaxxvExrZgdMfdK?p<wsQvrmYnlNclVxJpd`XoJWu`Vs?GoNolTVbEgmfadvYeyF`YguGPoMnpvv\\fV\\rhv=PwvO]`Pox>\\Og]jf_mfnIhpW?^=i\\vW\\@p\\x>f@IesH^eArgGe<vlanuUxl:AtiPk=Vj;Af<bF_DK?w\\WvBaHjMbeQiCoFTui;[slsDU[X\\OUbGbfGcTcdNQFcabfES__vR?bfKYY[G<]cN=Hfcf^Wt`_grSGsoVtoR_WBaWdp_gV=CEubfogiEYkmdSOyWGwqSuhGSFKhGKRICsTkbFKXkiyQKUV_rjgTCaUpITa[XfqH_=HR?rgWI;WTcuutWwjwX:QcBoTAiC\\uCJQEJOeRie^AI\\aIfSV;YR`Uh@udTUWJus<eTyuxEgbEQUVXyUHpnpXI`UbpTL]Y:`OlUuOuJHmxY@rH]oJQX[UlR=vRijthLCYUpyWw]mDQlspY>xk;AVjvpdHrBgn>x_N>piW[<hhkQe=viruFKEgMtmOUEwGAKw\\AUY[YEIVVYXUqSSsYq?E[asuYYwkB`eysmtGSsRME[ETP;cjCWIUx@_T_wUdQVCeUq]u<ExwwFTyV;CtQmr`yFkUCKSIp_ik;EFhoeAR^xKjdYgdS\\uMLLtwdylaOdeKIllopP=PLWTWpiPWLm\\anuEW[HrheoALRX<UQyqYeNG]W>EPjUuOinNdUiHMA=r?QVKQxoUSphKqirUtk:IxiMsZ=`qguAnnboskIvp_uB_dYa`QagjOn]Gdfi]^p`PHqhVjXQdfFgtqawvlHqwMif]NgeW`lG]dP]go^pxp?nsBA_nAcE^]RQZqWZL>awIiyxtS^[@V\\rh[S`kwpcUfwpW\\]idMf^e>\\MHdrP_Kyeo^jO_]kFh?fgnOmG>e?Qwtx[tHeSAlfYwsWjeV\\rhloImNXsJAkWix@VqJWbgxyCQek`cZqgVhjhQ^iY`sWfj>m:igr>_sGfj@[vxwOg\\FasFab?YkQGbf_dvyc_Pd?IvWp[TfgIo]ygq]istIqEHiZgeuqhHPsL`[<F]:>ZE>jC_BcdfEcIchAiYtgwV=g`mU:YiCqGNYEJ?rkAi<AVjCbUaHZKgM=Xf]wXkG:IxgERZQVSicOKu[aTlarZAV;cd\\PRtxPv=rUMoohkADvOLLPdL=tL@uqhqpa<XnHO<UO_Hx\\qx[MJqhoBeM=HrZMZ=GbLi]NWrlP`j>[y^r<PikWsS@tDivlNc\\WdTAfFnrG@aSVdoN\\And\\Xnbv<gW<qGLMD=CW_igxYyRitIAVjvrbImFAc`_bCikFpkHpn>og_GfsWtR_tPvbYFgp_yNIhOpZWQc?Hisg\\wHkC>lSiptfjkfbSQ_P>qtWs?IuEixrxmipmRFihX[qhu>atvWetplgGrSqetP`IxwwVhGnjW_loOfQ?uLQdYHhaAhCViAY_VIxR^[@V\\rnbT^bXadkOhWQy@oZ?xrHac[Qvopnnp_nYhcpZ\\OncFa`nurwrhFcrQjZ^wcfa=avCHpS?hX?lexyjynIOroQZSVosPe>nqAvoMajUNk??lWOlhWtAx]u@jyhi\\OZpGn>VrVGicfospjExxVyh:v]s?v>VgPN`R^[`>hF`stva`Ne>N^kG[;X`=_yYy]VorQyirFk<Xfoih>fh>FwUv]b>vxXupGrK^bj>[QndnvfjnoaNuhXkTWtO^:stF?r?kgASsp=VTIdoKhOIxKaDEUEUyfDcCeshlItsmHukEyAWFkB=G[xa^Hwyu^[=^j<@msQfEn\\bPvJfsZGnnPqKoxd^kb@awVjkHuJFejPbnOah>sUy]BwxiQ]>ynKXom^nuor>H\\TOtg`w[NqANZbIutXsx>`vFhVwtI^vMhj^AhR^;ANHHN[YYxLugqJTQVoywEHkc<UZMLD\\ruqmYLnXuo]=q\\ArlMKvDsjNtxgw;IjExtX^_\\XvsPxsQg]@v<FpjGxtFnrxd`ar<xfpNoOVa\\Orc^\\ZAax_lAApViZONntOoX?d>IjKWcVxfA_mah^g^vFnZ=HRWN:`l?@WnLurXy:EL]QV\\LXudovEMHDxYhwr<MSLoB^cUnoR@\\C@rk>]UH\\NvxpNek>xJiuO_t`Qg\\xkqpdWHvCGh]h]q^rfac=f[k@k[NZq^`v^kdAj=vrpAfTHrlxkSf^OFeb`dd>uoXobv\\L_xVHrZ?`R@rknl>OvhQuQOrxPgMVhmgcsFdoA\\rF`Sgden`@obe>hfVd@yqk>]UdDMBZCUUOSc?CYiwBudd=E>SgxwSD]hjEdqQR?MwyGDkQFcmeOoVZUD;WdaIUhKC\\qv>Mf:AVqIG=GrZMjk`JJXq@IXDLV\\LO[`TpQNEeR@QU;ULDElnpupDlV=K]eyuiRo@WCeomdT@UklxkciPfMvlHTdDUA@kOEqLelSIn?QTuEvIANdtxTiYPxRZQnrEt[HvH`XCQLbqqk]JkQPOeR@pOG`SxiUBAxa`Vr=wVUK?PnvYUOhj]YYFHrZ=@kDV_fCQc:]ff?UdCVn]WfwW_SBswcR?WbUVKqugwbQwFaIxSwWVtuIdXpPtQDVZYnOum=ivcQQKeLcquuax]tOZYsy<m;EnREkxuy?lk=uWKEypXjuXoruuUlK<IpQqRfqXc\\JHPyoAr:AjfYoX@NUErL`oiMSQDX[yx]PLnEte\\lWQOMHYF`PkYSqTs<ytfPWfPtwdnPtRvuWk<MFlNj]k?EKVPN^]TKEj`tnfErrePcLOEqJwmjEtXieP>@qtTUAYrYiqj`VSeKlpPsews=reEnbeRuyQpEUvmpRqjO=OAam_Ev]aPUqQHeMWdrIuaX?aN>myHbv`bCvdMwqHv\\CqophgMvuxfaCxjYvq^frfxlLqlTfdEicH@niygMFiWid;yjYQinNsjqeZaeoOt@avGHrZ?`;XffVs\\GbUFe:NyGohtFg]Ic`W[Kw`lwr?pmf`^Jg_s>x<@`hNdy@a;XxgP\\VOtLWgQIfBxuy`efPrc`\\[Gl?nhC^ZHQpF_lfWZgpdU_iPIjcGuUntahlUNltiw<I[FnZhfco>xGx^iVnZWeRW_o_]\\vomxj@GfvheVXbbo_rooCyw>yxOVj;AFN_lptnpiMh]Io_Uw\\>ouTimH`_Sa^wHkE?ycffb^^fFhag\\[O_iXo_AkQaZ[N[>FbLhbhy\\xnbJVwUhhTi]cqrNOfqX]KylPP^lfotQqfP_\\OoDP^e_xwQpKQn^I[=``@o\\s>`YyeFnZ=H;pVMtM]qr:uroIPLMPjqwMUJRxoQiN[XUV@rK@Wm=JYYP?Yn]DUYdtuapgMOGevhLSn]nU=tlHpyuXC=LstSLxReUloyOcex\\dx=AP:AR;aj]tRKhpBEpP\\VJ]W?EXvtTnhpgUMLuwGHrZ=PR\\CkrLGRsUC]Wb?]uqUwjkfaWBnMIPMRZmD];IlUC\\?Eh?GbuuRMTL[BgyTbkDkkIx[FEuggmRJiho]IIshVavZyDhiE:UgOARuguSeHsUX>SD^_gLiUuKgbuX>CuocW`;XFlJ=HKVTjk`sUXRJ<oLEo^TSaHlEdtmqlPuXmF\\WFcG_fjhaPpf^P^gn`kiq^fvK__NN\\Qgy`WkoQ^qIwBgt@IlWgZNQgW^pTqu<QuYVkXoh>?vDiv<nbAQ[RApFi[@Vj;Af<BRsHH[dbgGKsFD]T[SsJOdOAtg;XPGW:qhF]GYibb]rP_gZwvuedXSE_]bdccmgsPqHK_bAEB?QXOmdLWh?UyfoxROSlufJ]GiMseqVj;EFjg<jb`VM]N<aSIHYlDPmekHlop\\urTjmEYAyNGxpWTj?ES<TrFIXOmjmqV^DPD@rKhXl=Wb=SxlRttWKmnhDKQtOTTwalPQyKKqXwqOSlkmLqCMmAhVq=MFlJ=Z?ab?wlDHtKFe`acv^yraZxvxbYsb>eEYs>agu_nqod?yoyxvpFb:Pkwnxuhsh^ce@[VfpEP^i_ht`vDgidayf@^`_b`Qyyom^Gepg[QFhEqqkAc^F]WGhXOurPhCVj;AfjFJ[cOSDr_iygD;WFqGwFaYESDMeCNcF[AUtIhUmgIOg]MroeIRctlqdD?yLiBdgDkgdPyHkaiXIg]yYxKX;st`iuB=vqssfCGxSUiMYrwyNqWViYEisC?DpOuRUM=HrZO:ltIlqEpkeQrIdKchup`MHIL>pNvtQ:UqgQslYU^`juhLCUSpPL<dTI=Wo]Ru`Xv<yE<mZQU\\iYTyRnLVD`L`Il_mJ=HrZ;MBlODsmgAdNZqpWqkNiR]`WOiry<MK\\LD\\yYYQ`UNB\\USHtcMUUuqw\\K]\\lPdR\\iVX`LglPtQUPdQ;=YcDj]<XUQng\\MHxX]=PR\\K`>]Fhk;ftgai_Irdn[HFqbxtaYfg^p?a`\\AcX`rLHjtYr=_noq\\_>`VA[hWbDQto@v]qu]f^Fy`T?xww_CauOIbQIwAn\\Hhk=fptW\\?PfqpejVj;Afj>MVw@F]=n^BvrJAbSnp[YnL_p^gx:hrZ`fCOs_Q\\dfldN[HGfMy^f^_O^lF@dh>]rWyWfdFiss?gn^eromYYpY_lWYg]_gFQlh`da@\\lwj\\?`R^[`>hFnr@fuvNdlQn\\>sQH_oXsb>]yG_>n_LAdm_nnF[gw`L_sQff`QlPXek`dDHcWxu]vq\\OmP`\\ginwa]UIvRx`@VJD:SECmT\\sTbCdkKFd[DEqVUmbNiX]sTdosU]VVYerueD_teQx^[xSYE?QBQCckQIb_Te?H>CSoUGhmGcgThQtd?uIogYgHYAEFkB=^;GV^eRCAWJqDC?u@?ydyx`;xNYsmMT<UF[_V\\yC;Yuj]YIABXaYQqwbOX=oFUGX]?dqcVS]EV[ENOEk]DyqtikBHuh<MXfYE=GZ>RjkHN_hbKx;EEbobK;vCwD`?xjYDQGTl]gNmB`Ww?;YMiUuCx`WIqEs^kBLgCsGDUYRS]tNWun[sKIbMiv<]d_icWAgFkB=G:HvZtxbDS\\=y;xKEMLMds<tRLIN\\IQsXLUimpLk?TM`hX]MLrLjhETU=k:I`Rb;rros>kG:ufMIRb;STCiIEGFkSqEfTEf[cBuUIgqCvQXsUseqigsdNIHR[C@SbC[E=TT\\HukAxTYr_\\wnMWjaQqDkyQPG@oh=wxiQ_=yXmqpLM=HrZ=PRZQiZ@nkfqoZ?tfVnWQ`?r\\QHKmfCGbdeB]WVO;UpgBPeI]=PR\\K`j`<J?TvMpoS=Qr\\NeIjLEScdLyiRh]Rtuk^UPBQLAIUQ`K@Tj;_:^ZJ_^G@kVfgSgymNlTFnqIwKH[VVj;AFk>qF:Ot>WTLQFwgtA[s^Uv:qY@Sb;:CDCWcdGD>uhOow<et;aBHGrZ=HR@BgS>ceVGHKU^j>]eijyy[[HfqgeoIo?>k:>Z:>ZCgbH_bhPbZOJ:1:\"\{\}LSUlUk9PVEc2Jy0lKUJPVU5EU19YRzYjJCIiISEiIi0lKUJPVU5EU19ZR0YnLSUtQk9VTkRTX1dJRFRIRzYjJCIlU2lGKi0lLkJPVU5EU19IRUlHSFRHNiMkIiU/WEYqLSUpQ0hJTERSRU5HNiI=Figure 1. A common synchronous buck converter using two N-channel MOSFETs.
The synchronous rectifier, MLS, is shown with internal lumped parameters.Assume the lower MOSFET, MLS, is initially turned OFF and the top MOSFET, MHS, turned ON. This applies the input voltage on one end of the inductor, causing the inductor current to ramp up. When MHS is turned OFF, the current will continue flowing through the inductor but now it flows through the body diode D1 of MLS. After a dead time on the order of a few tens of nanoseconds\342\200\224dictated by the PWM controller\342\200\224the MOSFET MLS turns ON. This allows all the inductor current now to flow through MLS rather than D1, since the voltage drop across its RDSON is much lower than the diode voltage drop. Assuming that the current through the inductor does not reach zero (the Continuous Conduction Mode), the voltage across the lower MOSFET will simply be = RDSON . ILOAD during the full on period of the MLS where RDSON is the on-resistance and ILOAD is the inductor current \342\211\210 the load current.
AssumptionsIn the following analysis we will assume, for simplicity, that all the electrodes parasitic inductances are negligible. This will allow us to derive simple equations with reasonable accuracies.
AnalysisFigure 2 shows the lower MOSFET in the OFF state and its equivalent circuit for this analysis. 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 2. Resistances, capacitances and voltages associated with the lower MOSFET in the
synchronous buck converter, equivalent circuit and Vin waveform.The analysis begins by writing Kirchoff's equations for the equivalent circuit of MLS. Vin is a voltage source representing the effect of the external circuit as the top MOSFET , MHS, turns ON. The Drain Voltage LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYoLUkjbWlHRiQ2JVEkVmluRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEiPUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUYsNiVRImFGJ0YvRjItRjY2LVEnJnNkb3Q7RidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZORlYtRiw2JVEidEYnRi9GMkY5, where a is the rate of change of the drain voltage and t is time. Kirchoff\342\200\231s loop equation for this circuit yields:LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVEkVmluRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVEiYUYnRi9GMi1GNjYtUScmc2RvdDtGJ0Y5RjtGPkZARkJGREZGRkgvRktRJjAuMGVtRicvRk5GVi1GLDYlUSJ0RidGL0YyLUY2Ni1RIjpGJ0Y5RjtGPkZARkJGREZGRkhGSkZNLyUrZXhlY3V0YWJsZUdGPUY5LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzY0LUkjbWlHRiQ2JVEjZTFGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSomY29sb25lcTtGJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1GLDYlUSRWaW5GJ0YvRjItRjY2LVEiPUYnRjlGO0Y+RkBGQkZERkZGSEZKRk0tRjY2LVErJkludGVncmFsO0YnRjlGO0Y+L0ZBRjFGQi9GRUYxRkZGSC9GS1EmMC4wZW1GJy9GTkZlbi1JJm1mcmFjR0YkNigtRiM2Ji1GLDYlUSNpM0YnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYlLUYsNiVRInRGJ0YvRjIvJStleGVjdXRhYmxlR0Y9RjlGOUZnb0Y5LUYjNiUtRiw2JVEjQ29GJ0YvRjJGZ29GOS8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGY3AvJSliZXZlbGxlZEdGPS1GNjYtUSJ+RidGOUY7Rj5GQEZCRkRGRkZIRlpGZm4tRjY2LVEwJkRpZmZlcmVudGlhbEQ7RidGOS9GPFEmdW5zZXRGJy9GP0ZfcS9GQUZfcS9GQ0ZfcS9GRUZfcS9GR0ZfcS9GSUZfcUZaRmZuRmRvLUY2Ni1RKCZtaW51cztGJ0Y5RjtGPkZARkJGREZGRkgvRktRLDAuMjIyMjIyMmVtRicvRk5GanFGVS1GaG42KC1GIzYmLUYsNiVRI2kyRidGL0YyRl9vRmdvRjlGaW9GXnBGYXBGZHBGZnBGaHBGW3FGZG8tRjY2LVEiOkYnRjlGO0Y+RkBGQkZERkZGSEZKRk1GZ29GOQ==LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEkZTExRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSZtZnJhY0dGJDYoLUY2Ni1RMCZEaWZmZXJlbnRpYWxEO0YnRjkvRjxRJnVuc2V0RicvRj9GVi9GQUZWL0ZDRlYvRkVGVi9GR0ZWL0ZJRlYvRktRJjAuMGVtRicvRk5GaG4tRiM2J0ZSLUY2Ni1RIn5GJ0Y5RjtGPkZARkJGREZGRkhGZ25GaW4tRiw2JVEidEYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOS8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGaW8vJSliZXZlbGxlZEdGPUZcby1GLDYlUSNlMUYnRi9GMkZib0Y5 = print(); # input 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 LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVEjUmdGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSI9RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVEiUkYnRi9GMi1GLDYmUSNnaUYnRi8vJSpzdWJzY3JpcHRHRjFGMi1GNjYtUSIrRidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSwwLjIyMjIyMjJlbUYnL0ZORmVuRk8tRiw2JlEjZ2RGJ0YvRlVGMkY5 and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEiUkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYlLUYvNiVRI2dpRidGMkY1RjJGNS8lL3N1YnNjcmlwdHNoaWZ0R1EiMEYnL0Y2USdub3JtYWxGJw== is the internal effective gate resistance and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEiUkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYlLUYvNiVRI2dkRidGMkY1RjJGNS8lL3N1YnNjcmlwdHNoaWZ0R1EiMEYnL0Y2USdub3JtYWxGJw== is the gate driver integrated circuit sink resistance.LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEkZTMzRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSZtZnJhY0dGJDYoLUY2Ni1RMCZEaWZmZXJlbnRpYWxEO0YnRjkvRjxRJnVuc2V0RicvRj9GVi9GQUZWL0ZDRlYvRkVGVi9GR0ZWL0ZJRlYvRktRJjAuMGVtRicvRk5GaG4tRiM2J0ZSLUY2Ni1RIn5GJ0Y5RjtGPkZARkJGREZGRkhGZ25GaW4tRiw2JVEidEYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOS8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGaW8vJSliZXZlbGxlZEdGPUZcby1GLDYlUSNlM0YnRi9GMkZib0Y5 = print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYjLUkjbWlHRiQ2I1EhRic=Solving equations e11, e2 and e33 provides the value of current through the gate resistor:LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVElc29sc0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKiZjb2xvbmVxO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUYsNiVRJ2Rzb2x2ZUYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYnLUZTNiYtRiM2Ly1GLDYlUSRlMTFGJ0YvRjItRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSC9GS1EmMC4wZW1GJy9GTlEsMC4zMzMzMzMzZW1GJy1GLDYlUSNlMkYnRi9GMkZobi1GLDYlUSRlMzNGJ0YvRjJGaG4tRjY2LVEifkYnRjlGO0Y+RkBGQkZERkZGSEZcby9GTkZdby1GLDYlUSNpMUYnRi9GMi1GUzYkLUYjNiUtSSNtbkdGJDYkUSIwRidGOS8lK2V4ZWN1dGFibGVHRj1GOUY5LUY2Ni1RIj1GJ0Y5RjtGPkZARkJGREZGRkhGSkZNRmFwRmVwRjlGOS8lJW9wZW5HUSJ8ZnJGJy8lJmNsb3NlR1EifGhyRidGaG4tRlM2Ji1GIzYsRmpvLUZTNiQtRiM2JS1GLDYlUSJ0RidGL0YyRmVwRjlGOUZobi1GLDYlUSNpMkYnRi9GMkZkcUZobi1GLDYlUSNpM0YnRi9GMkZkcUZlcEY5RjkvRltxUSJbRicvRl5xUSJdRidGZXBGOUY5LUY2Ni1RIjpGJ0Y5RjtGPkZARkJGREZGRkhGSkZNRmVwRjk=print(); # input placeholderLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYoLUkjbWlHRiQ2JVEkaTF0RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVEpc2ltcGxpZnlGJ0YvRjItSShtZmVuY2VkR0YkNiQtRiM2Ji1GLDYlUSVldmFsRidGL0YyLUZTNiQtRiM2KS1GLDYlUSNpMUYnRi9GMi1GUzYkLUYjNiUtRiw2JVEidEYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOUY5LUY2Ni1RIixGJ0Y5RjsvRj9GMUZARkJGREZGRkgvRktRJjAuMGVtRicvRk5RLDAuMzMzMzMzM2VtRictRjY2LVEifkYnRjlGO0Y+RkBGQkZERkZGSEZoby9GTkZpby1GLDYlUSVzb2xzRidGL0YyRmJvRjlGOUZib0Y5RjlGYm9GOQ== = print(); # input placeholderwhere i1t is the current flowing in the gate resistor Rg.Now we can calculate the gate voltage: LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEjVmdGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSomY29sb25lcTtGJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1GLDYlUSRpMXRGJ0YvRjItRjY2LVEnJnNkb3Q7RidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZORlYtRiw2JVEjUmdGJ0YvRjIvJStleGVjdXRhYmxlR0Y9Rjk= = print(); # input placeholderThe condition for no shoot-through in a given MOSFET under a given rate of change of the Drain Voltage a can be calculated using the Vg equation. At the end of the rise time, t=tr and Vin=Vcc (usually is 5V or 12V). At this instance, if Vg>Vgth (the MOSFET gate threshold voltage) cross conduction occurs. To find the value that will cause cross conduction, the equation of Vg can be derived by substituting LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYoLUkjbWlHRiQ2JVEidEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi5RIj1GJ0YvRjIvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRjsvJSlzdHJldGNoeUdGOy8lKnN5bW1ldHJpY0dGOy8lKGxhcmdlb3BHRjsvJS5tb3ZhYmxlbGltaXRzR0Y7LyUnYWNjZW50R0Y7LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGSi1GLDYlUSN0ckYnRi9GMkY1LUkmbWZyYWNHRiQ2KC1GLDYlUSRWY2NGJ0YvRjItRiM2JC1GLDYlUSJhRidGL0YyL0YzUSdub3JtYWxGJy8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGXG8vJSliZXZlbGxlZEdGO0Zlbg==:LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYoLUkjbWlHRiQ2JVEkVmdsRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVElc3Vic0YnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYqLUYsNiVRInRGJ0YvRjItRjY2LVEiPUYnRjlGO0Y+RkBGQkZERkZGSEZKRk0tSSZtZnJhY0dGJDYoLUYsNiVRJFZjY0YnRi9GMi1GIzYlLUYsNiVRImFGJ0YvRjIvJStleGVjdXRhYmxlR0Y9RjkvJS5saW5ldGhpY2tuZXNzR1EiMUYnLyUrZGVub21hbGlnbkdRJ2NlbnRlckYnLyUpbnVtYWxpZ25HRmlvLyUpYmV2ZWxsZWRHRj0tRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSC9GS1EmMC4wZW1GJy9GTlEsMC4zMzMzMzMzZW1GJy1GNjYtUSJ+RidGOUY7Rj5GQEZCRkRGRkZIRmJwL0ZORmNwLUYsNiVRI1ZnRidGL0YyRmJvRjlGOUZib0Y5print(); # input placeholderFor a very fast rise time we can take the limit of equation (1) to get the gate voltage Vglimit at a point where the rise time=0 i.e. LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEiYUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1GNjYtUSgmaW5maW47RidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZORlNGOQ==.LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYoLUkjbWlHRiQ2JVEoVmdsaW1pdEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKiZjb2xvbmVxO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUknbXVuZGVyR0YkNiUtRjY2LVEkbGltRidGOS9GPFEmdW5zZXRGJy9GP0ZWL0ZBRlYvRkNGVi9GRUZWL0ZHRjEvRklGVi9GS1EmMC4wZW1GJy9GTlEsMC4xNjY2NjY3ZW1GJy1GIzYnLUYsNiVRImFGJ0YvRjItRjY2LVEtJnJpZ2h0YXJyb3c7RidGOUY7Rj4vRkFGMUZCRkRGRkZIRkpGTS1GNjYtUSgmaW5maW47RidGOUY7Rj5GQEZCRkRGRkZIRmduL0ZORmhuLyUrZXhlY3V0YWJsZUdGPUY5LyUsYWNjZW50dW5kZXJHRj0tRiw2JVEkVmdsRidGL0YyRmhvRjk=%;Equation (2) is a very important one since it indicates that if LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkmbWZyYWNHRiQ2KC1GIzYmLUkjbWlHRiQ2JVEkVmNjRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVExJkludmlzaWJsZVRpbWVzO0YnL0Y4USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGQi8lKXN0cmV0Y2h5R0ZCLyUqc3ltbWV0cmljR0ZCLyUobGFyZ2VvcEdGQi8lLm1vdmFibGVsaW1pdHNHRkIvJSdhY2NlbnRHRkIvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZRLUYxNiVRJENnZEYnRjRGN0Y+LUYjNiYtRjE2JVEkQ2dzRidGNEY3LUY7Ni1RIitGJ0Y+RkBGQ0ZFRkdGSUZLRk0vRlBRLDAuMjIyMjIyMmVtRicvRlNGam5GVEY+LyUubGluZXRoaWNrbmVzc0dRIjFGJy8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGJy8lKW51bWFsaWduR0Zhby8lKWJldmVsbGVkR0ZCLUY7Ni1RJiZsZXE7RidGPkZARkNGRUZHRklGS0ZNL0ZQUSwwLjI3Nzc3NzhlbUYnL0ZTRmpvLUYxNiVRI1ZnRidGNEY3LUYxNiZRI3RoRidGNC8lKnN1YnNjcmlwdEdGNkY3Rj4= there will be no shoot-through for any value of a. This can be achieved in so many ways like reducing the value of Cgd or increasing Vgth or Cgs. Increasing Cgs is not a good idea since it will adversely affect the dynamic losses. Also, notice that the equation is independent of Rg, which is to be expected. As a gets larger, the reactance of Cgs becomes much smaller than Rg and it becomes the only determining factor, since both components are connected in parallel. Alternatively, if LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEjVmdGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSI+RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSVtc3ViR0YkNiUtRiw2JVEiVkYnRi9GMi1GIzYlLUYsNiVRJGd0aEYnRi9GMkYvRjIvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0Y5, then cross conduction can be expected at some level of a.Even if a MOSFET meets the condition LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEjVmdGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUS8mR3JlYXRlckVxdWFsO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUklbXN1YkdGJDYlLUYsNiVRIlZGJ0YvRjItRiM2JS1GLDYlUSRndGhGJ0YvRjJGL0YyLyUvc3Vic2NyaXB0c2hpZnRHUSIwRidGOQ== in equation (2), it still may be suitable for the application as a synchronous rectifier as long as it satisfies equation (1) for an actual circuit rise time.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%;The above graph depicts both Vgl and the Vglimit. Clearly the gate voltage almost reaches the asymptotic value of Vglimit at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEiYUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKSZhcHByb3g7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSVtc3VwR0YkNiUtSSNtbkdGJDYkUSMxMEYnRjktRiM2JC1GUzYkUSMxMkYnRjlGOS8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRidGOQ==. In order to examine the range at which shoot-through occurs, we plot the gate voltage as a function of Cgd and a.LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEncGxvdDNkRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkobWZlbmNlZEdGJDYkLUYjNlAtRjY2Ji1GIzYpLUYsNiVRJXN1YnNGJ0YvRjItRjY2JC1GIzY3LUYsNiVRJENnc0YnRi9GMi1JI21vR0YkNi1RIj1GJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRlAvJSlzdHJldGNoeUdGUC8lKnN5bW1ldHJpY0dGUC8lKGxhcmdlb3BHRlAvJS5tb3ZhYmxlbGltaXRzR0ZQLyUnYWNjZW50R0ZQLyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGaW4tSSNtbkdGJDYkUSQxLjJGJ0ZMLUZJNi1RJyZzZG90O0YnRkxGTkZRRlNGVUZXRllGZW4vRmhuUSYwLjBlbUYnL0Zbb0Zkby1JJW1zdXBHRiQ2JS1GXW82JFEjMTBGJ0ZMLUYjNiYtRkk2LVEqJnVtaW51czA7RidGTEZORlFGU0ZVRldGWUZlbi9GaG5RLDAuMjIyMjIyMmVtRicvRltvRmJwLUZdbzYkUSI5RidGTC8lK2V4ZWN1dGFibGVHRlBGTC8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRictRkk2LVEiLEYnRkxGTi9GUkYxRlNGVUZXRllGZW5GY28vRltvUSwwLjMzMzMzMzNlbUYnLUZJNi1RIn5GJ0ZMRk5GUUZTRlVGV0ZZRmVuRmNvRmVvRmJxLUYsNiVRI1JnRidGL0YyRkgtRl1vNiRRIjFGJ0ZMRlxxLUYsNiVRJFZjY0YnRi9GMkZILUZdbzYkUSMxMkYnRkxGXHFGYnFGYnEtRiw2JVEkVmdsRidGL0YyRmdwRkxGTEZccUZicUZcb0ZncEZMRkwvJSVvcGVuR1EifGZyRicvJSZjbG9zZUdRInxockYnRlxxRmJxRmJxLUYsNiVRImFGJ0YvRjJGSC1GXW82JFEiNkYnRkwtRkk2LVEiKkYnRkxGTkZRRlNGVUZXRllGZW4vRmhuUSwwLjE2NjY2NjdlbUYnL0Zbb0Zkcy1GZ282JUZpby1GIzYlLUZdbzYkUSI4RidGTEZncEZMRmlwLUZJNi1RIy4uRidGTEZORlFGU0ZVRldGWUZlbkZhcEZlb0Zdc0Zgby1GZ282JUZpby1GIzYlRmRwRmdwRkxGaXBGXHFGYnEtRiw2JVEkQ2dkRidGL0YyRkgtRl1vNiRRIzUwRidGTEZgby1GZ282JUZpby1GIzYmRl5wRl5yRmdwRkxGaXBGXXQtRl1vNiRRJDUwMEYnRkxGYG9GanRGXHFGYnEtRiw2JVElYXhlc0YnRi9GMkZILUYsNiVRJmJveGVkRidGL0YyRlxxRmJxLUYsNiVRKm51bXBvaW50c0YnRi9GMkZILUZdbzYkUSUxMDAwRidGTEZccUZicS1GLDYlUS10cmFuc3BhcmVuY3lGJ0YvRjJGSC1GXW82JFEkMC40RidGTEZccUZicS1GLDYlUStsaWdodG1vZGVsRidGL0YyRkgtRiw2JVEnbGlnaHQyRidGL0YyRmdwRkxGTEZncEZM%;The above graph shows the Vgth plane at 1.2V and the induced gate voltage Vgl as a function of Cgd and a. All points above the Vgth plane should be expecting shoot-through at varying degrees proportional to the value of LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1cEdGJDYlLUkobWZlbmNlZEdGJDYkLUYjNictSSNtaUdGJDYlUSRWZ2xGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSgmbWludXM7RicvRjtRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZFLyUpc3RyZXRjaHlHRkUvJSpzeW1tZXRyaWNHRkUvJShsYXJnZW9wR0ZFLyUubW92YWJsZWxpbWl0c0dGRS8lJ2FjY2VudEdGRS8lJ2xzcGFjZUdRLDAuMjIyMjIyMmVtRicvJSdyc3BhY2VHRlQtRjQ2JVEiVkYnRjdGOi1GNDYmUSRndGhGJ0Y3LyUqc3Vic2NyaXB0R0Y5RjpGQUZBLUYjNiQtSSNtbkdGJDYkUSIyRidGQUZBLyUxc3VwZXJzY3JpcHRzaGlmdEdRIjBGJ0ZB. Worst Case AnalysisOne last task we can do is to examine the suitability of a specific MOSFET for a 12 V application by evaluating the worst case MOSFET parameters conditions. From the MLS datasheet, the MOSFET parameters are:Cgs=3185pf..5915 pF Cgd=441pf..819 pF Rg=1..1.6 \316\251 Vgth=1.35..2.4 \316\251We can use equation (1) to do the evaluation using a 3D graph as seen below. The use of 3D graphing is particularly useful to get a more complete view of the gate voltage over the full tolerance of Cgd , Cgs and Vgth and effectively pinpointing the full range of the problem.
LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2I1EhRictRiM2KC1GLDYmUSdwbG90M2RGJy8lJXNpemVHUSI5RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkobWZlbmNlZEdGJDYmLUYjNkMtRj42KC1GIzYyLUYsNiZRJXN1YnNGJ0Y0RjdGOi1GPjYmLUYjNjgtRiw2JlEiYUYnRjRGN0Y6LUkjbW9HRiQ2L1EiPUYnRjRGN0Y6LyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZWLyUpc3RyZXRjaHlHRlYvJSpzeW1tZXRyaWNHRlYvJShsYXJnZW9wR0ZWLyUubW92YWJsZWxpbWl0c0dGVi8lJ2FjY2VudEdGVi8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRl9vLUklbXN1cEdGJDYlLUkjbW5HRiQ2JlEjMTBGJ0Y0RjdGOi1GIzYnRmVvRjRGNy8lK2V4ZWN1dGFibGVHRlZGOi8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRictRlE2L1EiLEYnRjRGN0Y6RlQvRlhGOUZZRmVuRmduRmluRltvL0Zeb1EmMC4wZW1GJy9GYW9RLDAuMzMzMzMzM2VtRictRlE2L1EifkYnRjRGN0Y6RlRGV0ZZRmVuRmduRmluRltvRmRwL0Zhb0ZlcC1GLDYmUSNSZ0YnRjRGN0Y6RlAtRmZvNiZRJDEuNkYnRjRGN0Y6RmBwRmhwRmhwLUYsNiZRJFZjY0YnRjRGN0Y6RlAtRmZvNiZRIzEyRidGNEY3RjpGYHBGaHBGaHAtRiw2JlEkVmdsRidGNEY3RjpGNEY3RltwRjpGNEY3RjpGYHBGaHBGRi1GPjYmLUYjNjhGTUZQLUZjbzYlRmVvLUYjNictRmZvNiZRIjlGJ0Y0RjdGOkY0RjdGW3BGOkZdcEZgcEZocEZccUZQRl9xRmBwRmhwRmhwRmJxRlBGZXFGYHBGaHBGaHBGaHFGNEY3RltwRjpGNEY3RjpGYHBGaHAtRmZvNiZRJTEuMzVGJ0Y0RjdGOkZgcEZocC1GZm82JlEkMi40RidGNEY3RjpGNEY3RltwRjpGNEY3RjovJSVvcGVuR1EifGZyRicvJSZjbG9zZUdRInxockYnRmBwRmhwLUYsNiZRJENnZEYnRjRGN0Y6RlAtRmZvNiZRJDQ0MUYnRjRGN0Y6LUZRNi9RJyZzZG90O0YnRjRGN0Y6RlRGV0ZZRmVuRmduRmluRltvRmRwRltxLUZjbzYlRmVvLUYjNigtRlE2L1EqJnVtaW51czA7RidGNEY3RjpGVEZXRllGZW5GZ25GaW5GW28vRl5vUSwwLjIyMjIyMjJlbUYnL0Zhb0ZjdEZlcUY0RjdGW3BGOkZdcC1GUTYvUSMuLkYnRjRGN0Y6RlRGV0ZZRmVuRmduRmluRltvRmJ0RltxLUZmbzYmUSQ4MTlGJ0Y0RjdGOkZoc0ZbdEZgcEZocC1GLDYmUSRDZ3NGJ0Y0RjdGOkZQLUZmbzYmUSUzMTg1RidGNEY3RjpGaHNGW3RGZXQtRmZvNiZRJTU5MTVGJ0Y0RjdGOkZoc0ZbdEZgcEZocEZocC1GLDYmUSVheGVzRidGNEY3RjpGUC1GLDYmUSZib3hlZEYnRjRGN0Y6RjRGN0ZbcEY6RjRGN0Y6RjRGN0ZbcEY6RitGW3AvRjtRJ25vcm1hbEYn%;MFNWtKUb<ob<R=MDLCdNFZvk:LQ>T:<LTErMCB;RLCTJcDXoHuuu;;VAEYWeYXuw_UyhohbogdKdJ?R?oGDGB]UIrGDUAIhqBqAIkESxUuC]wZQDaCX]kr@iurWIhqf>AbcAuZKc:=SZou_gw_iwUyhiwhyqeuSHEYdRESZ]BB=YhkYXeiqqvGaYmisFIiaqeiqYqYXNerZUegmhSqVUYcTqgtOwdsbMqw@SufUhGqhyoCmGBYqHUa_U>xgWpGq`UagmHZYq`UaGUpG:q`;:pVUYKbmWuXKfUQ[dopTmRIvrLypuRTqrhyk]qwVMWmerWtrdhqApVZxthYxcqxYIKxuSSAjiUuCljeeTNLtc]TEiV:ivL=PjEqWAXsaYlayStKZepLERctl=eRpHpXTVQ`WeIK>lUn=rIYXglVm@oByUwtPstVQxr=tpYyKAXxCAJx`Ub<nNxs]Psg=KRMpwxNR\\tgukQToNPSTqrDenDPKi`UOAQ_lUktpnXt_ixX\\XHuSQaxViv_XTH`xvIYjPPvLtAmSSyOiiLhUruIkYYQ^UQpikMxweux=qxkquMqRCqXfYRsxnVPthTMjiWmhws<p\\`Qj]Y:eLpXlC]lDhRrTR[<y]IX?DQTEcZG^MHjM@jIyZSo]FQpv>r>V[eWmQfcy?sso\\an^ZasaaZB`mbPssol_xcBNwXFwQfZLGwA`yrAqn_cCWy=@jPG`;OsSFkvibZNifH]wGdhHot^^ix[Ba^KGwgileyd<g^LfZ<I\\wpiHGqhpqj?e;OyS@aK`idfnZfwJpql?eKYjfykYXlb^lEFirfvHPoDwadXvNhyMIajAeMhi=On[fiBqap_\\_hmfWoVYcnOZxAeFncqIk;fnp>vUqh<Ge_`eKo`PhqcqZrvynw_Dx^Y`kjYgYwjDH]`Wx;g^:il_ilriwiHvtxwI?hhVeH@t_ygLysY_dwG^ZarQFjl_xuxu@?iYqarpdWpZiyuvi[dNZ^gpFvdZ_[MvpyI\\_YmyuOiIQCfqgi=EbIGD<YCG;yF?TDKxdOCZovhmiCcfAqt]suQyb\\?bc]i[GBHAWNkeQ]UD[gVegH_uiswYoW^oTDiVO[wmsxwIEcyuyqda[cZWu=sr?ydZ;YPIudADdgTAkCViXA[Iq_y;CrLEDxwhWEBAQx_Qwrcu`uIlyuOEVvYDUoH[?yywI;WS\\?DYYIh?biWhEUyJqVrqhSqXFgcZkCaWRSMwXYyiYRcqfeIHgkEuMTDIH;sE<;VN_YtqEs=E]utyqEm[bCgb_YHE;FW_yXmhm_h[QgcCXjyx>si=IW@ihyGhXYxrKCR_VJwR;CFeUY<[BSMw[qhiggpMrg=iwCbCwrcgVLgTmgGvaWyAxjKdQyyHSCtmCZgxfEBl?UVERDOdGObO_EqCi[UB@qWviIvwvY=cS]BtEBjOgOyDi;fNireMrp[CCUyAygxQH@[fwgD[=v]gb\\KX\\ACHeCrAtlWXA[YY[yj;htaHGoBNmeuKuwQFwmTcsTKWumWE=wymiD^gfimr^qUbWET;Re?BoCBYwvIEw@yFH]V]ieqWf[]ICowOSgZQUl_B_CwMsdSCCkKgnMskShIcQulouqMTpsttJmLj[TvtlM\\dyRAjiU]XhhNyeO?ra>aJ^mDN\\tyvcVtRx[^GexvhKHgKHvQ_;QsxsIlOhG;giYe:QRC;cLqRSWuBSumkIQ;FpUiFcCQ]eCsEYuWG_t;=h^Ai;EUpiSj=XR_cHww;=B`;UDSspASU]u<KCAOH`MboCRDEbGatCGiwWUxQT\\Mg?CXlgu\\_YAKSAcdloYQEhV?bv_ulquUKCSCdFssAmUhAUFShXexT[ui[wwCXZuITMYt=bhGwD;YHCuXwgl?H`quowx=cGg;wreve?vDsRJMfXyUhsIaMX>YtcSt_]W]AR?msswU:eirMuS;gYUh@CdHoSFUEG=v[wgYUbGWypABUmH]oUR;Y=IIe=T[WB]AE?IDV_DqYScucwuHpUroAGBuiryUxQCroxiyRp]WNkClsxdGXYAi_QYOiGtCChYhPAFkUug?siwY>kuEwUDOWMUhkuikuYl]g\\AvZkrpoW;WRtqsksVh[ULywF_GsQXv?rHUt@[YUqUN_CYAV]or:mUsORJievMraCRKktJeWoMxeGSJ;fn=bC_DdWR==XpcH;IDCOfTodqQB>ctKGDroVGQRcMUAKGCaFvGvjOH^ai:gY_Sd;kRA=T[SGhwWZAG\\;Hn;cDqywMwr[eEsS<muNwSrke:SXj]dHOR;[elOSYuGVKrZCCpqcpGWbCx_;ffqDaUv_oSgSuNkF`DskdtUXOl]md`p[`_VilCWZ<QuEfhoOu`N`IomIffIvnVVsa>bhymoV]_heu>lshyP_jPv_K>fDV]HobVxb[?nIfd[OqXHw<agIOeFvjAik<`yPYyV^tH_nnonZWsB`wbG]=OxwgbHYuenksorUyoJyunH[rqf^Q]sYvo?x^QpRWySYoj>eBY^bfyLoc_@vJvnDYxlg];Hee`k_VqIagWakn@`qQgaw^TnepQ[FfigYoMpkBhc]Xr^I`wNV?xfIIRiXMiCRkDAAEOWw@oDaGXHkf]usgAuHGbumw@WRVgSMibQCgPysxyXWcfgkHZYu`UuY=rPcgJyejusyCYl[Ul_XAYdYYId=DX_sE_SxOVlwgLGGaaD@qrj;xMwE[WvlyiM=vYCyPyHJOuvGCXCBN?rvGybwYeYQelTdTuPAXWmYmDtUYj[yOyELKqr@\\rxIv=AsYyYYlJxEyy@XB<MuLs_\\PV=X[LjiEYuLsghodHoMHqMhtM\\wsxkniOyyj^ysymjC`R<dtvmKkEVjHP[UoxxtWmkL@QWtXc@QShTnLxaXYKmqkQY>yoruLVUtaMnyYxYHrrqpgAwvUr_AkWEyheVr`lL<MA=l;qV>IQ>dVyeSamm?hyeyM?Ur@hKBTsxAO?Dl_yl?\\QI\\utUOlhr<Lwtxv;IOHXR]dMDIRAAUyxvkTK<Ls_EQiuVGAQ<IvphoLhoEixCYsYqjSXPkDlKvy:Qe^avqyfVHh@Nj\\al=Or^xbH^]:WgcPfF>aQAcmWdkPgpY^ih]uQhvqtUHlL@s[HwyiyENZn?pl_]AHiI?]g?\\aH_K`lY_Msw\\Wck;X=ywK_EWkR[UxM;xCuePgswYXYWDLCWrWD]?xE]x^YDAKRPyUxCr@ibf=rqgw>aVuQxrsdbciU]bxAd;WHOOWdobfQV?EBv=WC;DOCVvWrumx\\;F[oYdUuP]wx]VWKgggWRCS^Cvxgyp]gbyE:UwysYFkiMqSQ=xPyuBqEAUYuEliuMDQJVyJxUxe]KL\\Y>\\smdy=@WvItI@pj]XNdXYLybLSWdMj=Kj`L?hml\\KcYypyPkxyAtuALmUELueyUdTPIutYoY=n[QmyIRAAYDDlqeqAdJ[]ufUpMIw<AujAK@pthhRueYwPJLqqupw<AmnXrq<aoQxUgln>fFx`r_Zre]SHlMUHmU@gY<kvcCBAau=uC[;XXIydsFO]Ft;SJGe@SrbMirQVrUeUGH`cWGkR]wrVmbjorJMxLcGG[Y_YcjIS^EF[CsMuhMkrhAWiaRW_euwS\\SdNAU<ci=YrB=cmkELsfRqr;QUQWE_EyFWbsgVkmEHIYmAvH_RJwDAsvtKr:EGoqXsIHLQv>ybi]iKkymss@Uw_wg>ES\\wFD=IHOG`cVlsdEMudksKugm]I@[XoEVjuwX[XDueqceqQDG_DbAUDOt`GrUqWMEyikXxibjaHoSwrQBSwimaBDexoGBYqhMscgYURsc=wFbaEtgS?eE=kFSaUSaEZefVGTCqVJYnUPqhQoIxyeLR<LjupWyhKI\\Y`yuKYpgUM<yKVyk:IUaAOJ<x;xvZDnaHpKDM;LtCxUyQLGywsuQPdq^QRNeJJupwqxQAUyiniLNjUvG<KVhq@lM[uYsmnDMYv@MvXxP\\wsIvI<TfXW:wypIcn`oTgo[yiZoxf_oywyu?dwirIItwGtEGvL>ph@[=v`LpsWA_>PrB?[bakAVjBxqyYjROs]GcnVd[o]rVt@fsk`[ixtE`[Aa`^YxZaoS?hEVjYNuvAaTqhiQbJYhk>^HIf^IlA_d\\P[>Yvjo`nF_JIdqxhUXZAyrL^xgHZZOZeqekof?Il>`xqYd;vqf>fSAagXZGQrXIwfXZlom?GygWnVxcU`bCg_Lyt?`rBN\\ewwAo`snktIymItBgeWooAGyBVv=^hjgfMI^Hhykq\\FhwSYjsw]uaZ<hwgA]uOvCVxX@odye=IrtfpYNh<^w[Gh:WtIGe;hk<^w]XmqVn;_mPXdhY[G`l^xylQ\\_in_yuKinE?vCprJX\\pxwxNrZYqG>ypHup_onOfm?pf`eeHuYNqG^[CwnfO[ppl^^^JvnsYw;irE?`eiaiYbR?Z`v^iy\\wpvl^n>>wqviiYqbO\\JyoQvn:goXAsxI`@>cEgn<NniFqBfeipiGPcA_ZHIii@qNVuy_y]^[fYuIHmwvZJn^=an>`^ywjyaiinRegmuUyQYnmeyEb[AR^yHWKDw[wrsy_;wO?G]gW]YVjqGT]VjkSMISCsGAmT:WgwieQMfuiWiAdYiD>;sDKs`IIKacJKS`ESaIvP;dFQKg=Uj@LGeuWAuyuwWAMwXxp]jidYO\\qgdOdDLkdmkHSVXUfan?ASaPTTqJItJnuy<<pL?ssi[\\wZG?imf`sOs`^l\\ostQyqnmHArFNs<Ap=PZrIbm_s;irfQ^Syw:ikQuwwxhCXLqCnOSYirtwv\\SGaIT\\mVGIV^?GGivQoXFwgy]D=wiyiGTkUmQE>qSscD_aSPaii]C`;TkSxkie`WtfKdF;suHQm=vL<lIIS^ElKhY>mOx`RIyPuxYYLtumX=YqjEL<TPaEnZDtUdvX@L]tk=ASEur]Huo`XfUQ;hNWPkkTwkMO]MQ]tNXPlOtS`UvRLuidob<N=EW=XlemxBTKVYpquojhx\\\\uGiO:=rI`xrML_Hl[UrS`TFtNKXOQ@lOhyppoREouYuxXVAlJtQyn=rkHw^Yl?\\YW<mR\\M>ejc\\Y<\\r?`R<TRUyp[@NUTQAlJjlxWyW]]ytxw[DNyUxLdLn\\SB<xDqya\\rC=Pm=s[eK\\MSuEowYy`]s:g\\e@lL@g[ItAqt]wx;XZBGeTYqCasCn`XGfSP_K?sqoa;^odWbwr:uIlYupOWPST_=WBcFcUbYMfDsSnKg=crNObbaGXGGJETUwsCWBEyfm;sGwceaRrOul_BTOYdms>ehVKtNyGMMC[qxlmCnMVxCWewtFeIWki_qVfqipQEFGSUYuiCYSkvVmyq=sCuiH?XJqdlKsN;FeWxiKC?eSUiuwesOAGCIIpmimQCGounGSfyFH[tPUsdSIk=vUWdmAGICtCqvLYDteW=SXaQVIuYiKHUmH=IwmQwooEu]yk]VAQdRohleD<YxQ;wRCbMaw=ufmar;GTUGvUqX<Ee=QVUaejSV<_e=Iwl?t`AV`KS:;FEye\\KBbCGs_v:qVSCIdiw`_u=Ec`OTd?ghyUoof[YeyMct;ra]v>YxwEu\\EclAvAKVk]ck=BIywMKueatp?XjohfIDJSdqYIX;UEgxqqu]MIISRyuGBIYN[vqeu<AEO;wCkIVwGZsua=ewWDDCrgSyEQdGUHWSTVScYmUXUHOctLwSROgC=rDAc]=wrSyf]wtityQVAqtg;WSAi;CX[=gSGr;;idYwKSUtMh`EGKmbjQdSWUcufMGUekc=?UvSfZkcQ;GJ=hFSBS?Ha]rDWfd[Oy\\u>lqpqKwaqp`R=Xt>dyn@QKauxhqMWdiPkmaxp^`\\^aqomlpco?sNXglFgF_gWQkgwevy_FnwXij@XtHAr\\yirA\\<Xt`HnQ_meVsR^jRos:IwV`slIo?^ixx]YiqUVrIxg>_xNilb`[I@frykqPwiQduyx]v^H@tEGsf_hNVfyoyM^yWhejqhn?oManN^\\K@giXfOQgfgeuw]tqguh\\kFkD@a@AtuWsY>l\\IpaisMwfHqypYcYNqH?nV^iU>xgWak@rXo]lQ\\;oktHojVxCFfmWnlAtpGs=_]J@dUPqjhZHGc[_rFYaqOyvQx:qsKobaHaeqv^Iol`qII[:^dLW\\Rh^FypLh\\ZV_P@lYIqM>s`hdIohrgi`ojIH`d>r;Ov<GofHnxWrswv]osFImjWspfZC`ZLWmpFf<HmkfhoAhCI`cAa<OZXnwJ?]]QrBxlxPvL_hvYvA_dPHj`Py;GmfFudxe:ha_ofO`tKhjlfmMps?okOGlQ_cRGy\\hjEfdaqpRHq?>tvGy>>i<NpIn[`oTkV\\mrewG=YfYwyVkxYqxAeBvmd_;gYUXXKwPsGPaGRkVJCWN=F:SsnOrlGIkaWloXFofyOc=WEWkRtqreIDvSWGKGWiujhvN<scaJpeyryRbQY=YMKDLj\\sEuukYQG@QBQm_uQfTUjHw@xu]uywyxImSXMoolKbupiDUDhliyyu=Q^hYn]uV\\TWaxSxS[UyYly:tREUOPhYgYUbaQaek`UyjLPeMWf]ts<LhTPwqPEQTALvZ<uXlse<jSqYGpXPtO?ATlDk^yPhhPlxprey_A]?hnAajZ^akwvgAkoyx[Gxuvo>xuSiZI`ypv^wGrwosyWxUGhZqxUIpegu=?gyYtw@ws?w[^xBiyNih;ijbAi_YoKhlwQxX^n]ihV@foHmf?rqhw>AZuWdx@^Uf[B>opwenG[p^ytytRIuUYk`ygvg]gywrPZhqocQ_E`kiAuHXZy^qHFwwyZZqgb?bwIoe^`Eqn^Gproya^suFp_W_@_jshcM>v<_^<hqyNy;njYNiJnoZ?[xHqmI\\bOg;ob:yu?V\\B?oIWsxyxxQvyG\\LXfovqoigb^[F>fIy[xxk[icI?n\\>vY>lIIw^O`CHd>GeEqngO]^>yAOcRvnq?G=Y_QWmOFRWBOMh_aR<EuuwcZCsbQfd]CbKtsCXvIbyIwZsg:WcIatEwe\\WsDyVNWRNuiPwxMqTgOr]Er:Kyqaw;]xauIPEG^myemUe]D_Sd]Qy_UUtsRgWR^sr>us;;i^KtbOHqwiJPky<nHPOy=VylJyexE\\sN@K>YPemLD\\k`@w^]niau\\AXEMXxlOPywSyqUdtreMDQXxpKepkI@pjiLiqYilTxxvwUTaQvUUx`\\Ssio^lsdutIqYd@VYxs_Ip\\yWYukhhRaDnd<nV]vFYU<dqnXscttMPPLpsvlLJiwMtnplNHEOpMwd\\Pvpxl<Y\\EPNysSXjEpqmiY]AMPmPI`xkMT\\hkulysymJ]Y^IVV`OH<Y`YqXYnKAKShqMam:tnoHX^qUB<k=hsi]YFuVatxDiP`yxgTWPAwRpSHmkiYlgmyLDSFqJvUepaCyFr;s=stpOX_kvwGxG=YbYeQQfrYsYMVXYDI=fsEr<cV?YDumX]ubj?xN?bPIEiQYqKEQgGQEu@?FDEs^?S_`yqLNuQymipYUr<xJPQrYuu:ho<lMumxgYRwaxh\\ssUtUhpbpTsMPqyuJHQdlOqlxkpnDyYymMmypfMRpxqYtkDTMVdSI=neakmDLW=pJepZajnHlltrLEuIqtAxM<qV[=k;xYsAQTt_K^aGicbFc^G`[vqi@[BacywuYYrUqt`xv`xrdVc^Nd\\Af`Gflo[;ItdwrJot[_\\=?dhx\\Px]XOqFVv<qcqiy\\yv:`brFfsakSOcNQsWpfwHndOhFvZhXyxNtNQv_yp[FhFne;nxPytxi_LWyqIvkFkL^i]VnRAigyt[yqmqcFI\\jqxpf`Sfi;a]uGhPWyiHqTfyqvyYNqPv_;guUqu;vlVvjlWex@dJwb=yqMgvdX\\fFw^@uhAgvnkFwcInmrIsI@lOpiCNk]A]rYrGOy\\`v@Y`IPaRO]]`kPyhxX[gvlxPd\\NpfPcVWbUwp[IlYoyPfmUv]AI_ahmHPOweM?S;wrp_E?swUoxHqSsoxhCWUEtR;XpsgcswEKIHsIAiD^gGsmcW?SuoVW]XkkWsisiGhcqgu;vMWxCGS>IHG=ExEGYWtxmXYkVVCr@[YUaWukR@=h`_BlkG[cXW]HDWxx;y;=y<IFfWykyckGVaqSrkhgUT@]s;widawh]eoquqIVs?hxKbZMUX[TdqtHub;AdmIen?BnIEBkewoBeuyeYxBqxoIg`mESMh>SCxqwGAcquXemvEcfW?b=AebiTlsBwuSPkvtkIKOrw[BEId[=i?gEqmemmclKuBuRAkR_gYNixmOBtcc<tUoymyikydY_YSrxxPYUJup]uN\\MrxXK<LQCDJFqtotv[Xk=tYV<vnDuuXsaiR;=MlEXTUQ<LrbepXusK]p\\esPIlxHvZMNIYX`@JPYj\\axVPRjulXMxlels@Qh<v\\ES<lRILtatJxMy]]n?hxpTk=IsByuniSq<NPItchn=\\qlxq`xlYMk^`WMuXPIuBtoREoSXPjTxfYK<QruytgXRW@PkqlI\\y=lpWey_]srqtqDtpIkyetD]lcEVfiy=URRlMSDTJdYlmLnHNGIPTEoM<ni=Wf]RRmsIXpThyEpLcqxsDkNpJqpWwMtKQsEXP<HwbpsJtjJqsvtYxxlBhNM<x]]P^yRFXpUhq@AvoMTHxP:IRlmKhTP]MSFxr[IXwPLwhNrmYMynUXJkiVgUKuykltTC`OYMyaXT\\PrcyOs@LuuwtXL[EyhhWxQJravR\\M=IV;ePIIKPpkcUJxhgBolIyjlObxq[Ipk\\n_ZxihyZx>k_wos`[=VapXofWnoqf>>`UyvGybZpoHV\\ca[LVvC?q>>bwWl=VkO_\\Ei^OQpQvqlidba\\`oajhfmPZ[WwVpg[?yMIlDgnnV^@Pqsh`kpjTwhCXpdWuUIpB?ZoOy?v_;AuxiydxmqO[=ix>On<>e=QsTIm`?mKhiFf[IFnK_mAY_x@y__xgAu;`dywmx^hx@g>okmVdoiglfdlPfDi_>vx?xotg[`werGlpxs=QlE^oTAi>PmeipToqPYlQhifFqnidRxhXIivqdmywgPquni<fd?AsFHf@Gd^oxfGZqXdKHmkVZUngriqPa\\\\XhZAfkWmrFpNygygjPhtaH^pows?slVZCa_o>r;vvbI_aPnwQpyhdZo]v?hgN\\<Ntg^cUflxAvsytE>sl?jRwZRis;nge?rTH_[Hf;Fyj`e=ommVp_psuaxaadUym>NtdYlCvptvl<Iw:xe\\p`WHsEgsWooeQpqvqOfwLqqr@`jAj>w]?FuhnsVqisY]LhiLIpLon[a^cPakomQfikYcLym@Gc]o[VViFIZfwnSH_>wjK?lm?[DXtsvymwmqntX?lIaa`gwXnwIWcU_m:`wXqZvWUkCjIy:Ox;mwQkBqKhquG\\IdBKRoixRgFZgISGT==RLwBmufvuePkbQSDZyck?vRGFQSGr=TIyTJgdgQE>GSA]BF[hhSYc_cXoyxes;wCE;GrQWDYBN]sFweLGUMmigmwv[HIQe]GwY_Gi=dRyiIEBaghogT;sc:UtiSyT[DaatfSyiUUj?BgWx`IeMSbeKu@KhCICSyEQ[uZ[Yj=vJWbXosreepkHGaiwUHWExB=B]exGSFE_HMmBCAb]GHgYChYhbmGPIvLaS^OBvQvBMF<;uwwIsIHdwymiD^arkKh@mi]gXTKsLcCkKD\\ogHIRWQVpSfokYLOxxpSBlr:AOSEq@UKLyroUPaEVvutHIsnDUhuLJXvoLssuTHd]TahJOsLH]g>hvFjoqjbAlSh_]ocdVd[is[omUXjOg_WPuiao\\Gs;whlxhi@ZmWylYdNoq[wuMIrJO\\DFsExtq`gXwFQBr]XPMXXacOOCTwyYMtxuxSWbi_wUsinWY<MFnOXkcWFwxjaEs]Isef^aysksKKHaqENuSJObcmHZYupMReAyP;dnYs=SiI=BOUw]?sqQIBCSpAs;ESmIviwdgQE?GWL;bOMUZ=Sh;FK[dIAI[ybXMFK?E?qvgUuF_sSscUERmggggSSOfHKddecUOw^;YN]s;sRdiyV;t]WTZ;SsafWeEWcEDaUCkVKEVi_Xv[Sa[upWYqOhTaiCArC_V^]dVqbFYHbMS>CE;si>AsBKt<aGwQhy?cr[htkRSsS=;xcSSjaIAEeioGuAeZoHicwgwDA?EOsfQAr;GS`_DLIhG]fnmi:]xnYHJEVhYY:ycsuEwyV>GU\\MVb=CkEuXgVWKSf?TaqxbSg__s]ah\\[FG?EDYdlWCWwTKEbWAwUceY;V<oyKOuFuVZWWQ;c=EEWkEPAsDgY`AHasTs_SsWcwIsxegMoX?gfI=uQ_sCQEUSSbuelaIeavvSU^QekSY@YTMoFDiyMmeEESy=x?YWBAsgKFUqb_gcPAveafMKdwuCCuyKMI^ixZIxsee\\OhwUBIgSAQWm[YUaWumwGIWH;ekIviuLd]TX<r^`QRXvfxp<TNOItatKmtqayXvYWc]p?TXjpklLkyHoSeV;LwrhVGErnQwxHyZuPJ<N_yoIaSA\\pLAOmPxwmtg]tytt<yU>DUdIq<LMGPJ@LK@MXvtosxOxqq;=rV`oKQW]tr>LO`aralWUtkAILmDRD@JLDn>INUAPYqugMQ>@nC<yIuP<LvxdxrQJp`Vk`uA]sFpTf<PHaNL<wUUqPdkWeURpXpIQ@`sK\\KcTUIDmllTOiNZPUg@VjykqPWx`Yb<MJXXqUWyLwZ]Wk`x^]xMeP^@lTQo_pt>Yo=Im?AlSxsH=P_HyGEYEQQYTWWHJqTPO@OEIXXLjcDrJIMdqP\\aM=Lxx\\YR<PppueamCLQvDqX`q`ll]mp:qqdmlYpvxEWTERMao_`LNXVmhkvpLaLVpmkG<iuFn;wuao[VHx;i^:I\\>@[Nncm@nRhxlwtNx[j?mmVaSNqIaiWY]Jvghods`jV^hhwhqHdeomlIkCA\\g>\\JI[KOx:ymtqwqQwFas`hnaVohaufvqixgcGtkgZIHmQheUhq[Q`;Os<vx`pn`flX>[rNs:XgHhf;@cJQmsVg`wlRW`MwmH>rRwr^wmRos<w]loosYghyb]^\\[gw;GWkifEIpcyiysj[Hn[c[iYu=DLsfn_ywyE:ey?ydb_tOaIymIvyViGr`yUwQT_Qg?yevOC;IWgqRUMvoAGJmb\\uYDqy]QvJkRXCUaoC;ctaSgKmEggiPark?cnyC_=Fe_BpIvHigpwIn=fOMyIosFQuIaTweVwuD`Au<_UISscIUm_VeuwIOuxYFjYUeyGRUb\\yFTasTUEjiWuETBUIo?rIyBKwCcgrRcgA[hPGiSuCsMc=Oc<KYmsTgot;]S`MtBKWZKS@eWx[sACb:cH`Mbi_YysvnWtoiiDUIVUxNGd>Gs`YWyuTE;FooCBYWPAhq?BgMgYAUH?r\\=rP;ivcU@EUu]SqGijGs;eBLas?]ULUYqAfqqreIhfQsqUfuisiErRAr:kwuavyGv;yGyECaeGV]bZuVQOWsYsXQyp]Fh;iJCyNAIvicG_tGadsqGxuwuah^?HQQCZWBgwUj?B;wcvYDv[g`ESGaySKIjUC:wcp?WDeGRQUHitLwWHsTBkstacUyEtSgrMGaATuesduhykt?ovf=rqgspwVB[yHOeTowAWE>UgGstcOHIkNJmv^MMlTttQYNYTpIVs=jc<u[tVoMpVHXL]M=mlSTMlqm[eQALj=pVNHXb<LGet@UWUXRQxOv\\MrdMEpYSPS<EPd`WTLmuaRc@jKYyhirrQv?Qq>yURyv;IJDIQ\\aQSPsDap@Akvxmx`WSHP:`Oays\\iWn@ynIwtxqxIlKdUkLO@qQNpQCASyDpfPUbIMVxr[ArqIwtTk]eYFxL=<pUAjiUuYeKmyQL`u;EW?Xll=Uqeua<rP\\PeUtVlWJlsDuX^AJdmqZ]S>Pn`uwoTNExVDlKi\\PJ@WG<NstkRUYulSsyYyQjAmouqQtyqtep`]MsmVFQr?xTxxR:XqXTvS`K`\\JVIm[]RsQkLaLE=RJAmK`tu\\P^PTHTyHHU:UVwg`lIf@f\\A^igf_Wq`U>xgWpgiZkoZPpnHg_WPqihxXii>P`;ql>QrgioFX\\EomsFtlf`dpnppsC>eNfk`xoxf[GW[PNnjnmNvZ`yt?ibr>nwN^Zvss`ZV^jPQekaen^eV^]Mi]snq:qiZoxDpf?FmwOrqa]Znn=ffD_vCpdN_s@^iUaguG\\<pqUamNfbGyidf[wO_J`pPN]chmWGi\\njwqlvirVPx[os@nlQpdv_k?ihs@s;Ffgalf?aK`oH?ry>g`WaSWjFq\\ewtfQ^m?hOQZpo[jOelHmGqwg?rqhspXvrfej?V;BB;RLCTJDJrep=PqoXj\\xRuik?lyAYjfTxfeMXTsEtLEdJFpNL<MEaVNUjaAJpTXSImLHsNATl`xTIr]UOTIoW\\JihwEPu;TxQTp@lW=lqguOhTv^`M[EYtDkCxPBDMZewnpYmYYGySqtMlemdmQ?QPpurm<xwiN:iy\\=JkdsuuL:yWM<VaaM;lK>qTf`qsUXHXJAaOvpvZlpgmPZYupQNplo\\]rTiOBqVoMowtTrLKNytUDwBPximOOxrCtRH`jkpTceR:YnN=OD=MiqtcMwjHmWIXgmT>UpmuvHeJoml;@mdMlLhOCAu:xyFIs\\HqpiV?aOIPwntlOTmdPxYpWAQNEmv\\eJ^mlHTm[]SceLmpJFPpfUXDpqmAKEHPbqx`EoRIS`xVoIXGMS]ttZeXj@JQiYyMRtqxUALtey_AXIIwPyumdjK@VIQq\\IUsqW^yXyHjmmrF]rRUQvayE<TZel?mSHExuiwE\\XVXMEyLvPxOxo>Qn?UkjYxYxyvAnnEtMdp@]kguSMIvytlLAJePu_IUuPjE=skpRpTwNUsuQSc`XJqn>LMxmUJQmRdV?lLhXms=wpusQHPUAj?LpRqolHq>YukUJpQtXlo`\\laErcltiDlqawePnniWoAl\\dTn]pV]O<AuxtnQAjoHTrTuLPMhtQiDme`RkUUXxwXxwxuJuxoyiQ@ttXyj<qqwPqTAlXUNslK;@VrqnUDtmesOAsIum;PxvHyRdurHJcyMvukmmtGhJrlKcUjgurYhuvUxGAunHWMlLf<Uj=t>qoaUlItWUyUsTranc:>mRqqGftAwt;y`n>[qinipZ`osX`fFP[nf\\]Gr`QtjA\\jpiwN_uwh]Pq\\g^vXcQH_BFeUiaYord@j>naeGqnn_wqvOip?weRovdGjqgrVoihPpew\\DvhvIdEautyeyqbNHagxuVoqIQffauXpc[Pav^kLQqA@dTAyRNcuwx;i`]oZ<Vp`GZaie:`innnaQoEXijgcIGZ;vhAWa@YyuapHa[InnMiuGQmfIsuww;Xnwh]moavIdgvZvh`wFjxy]vw]WXwYFbZatONqgXuPXZHXguQuQqq`hr[qutqtqPuWHf=nykN^rQx\\gyKntrqujiqiQnwFa@pdYx]xypYGjlxrwFiZOa@n_Splr_xK^kwyvy?^J^[ZpynX`YX]GFtfHsg`_@AnlvZygcPXsOHl@ojKgujAmKnyVPqLf^<Hwm>ZvYnGqnvYc:qq:AsBpcbf`H`tqxqCHtUogPIs=GPGCMyUuQI?cWgWy[gB;AHccfO]b?ycXuxW]CyQwQKYgKC;ADpuumuC`Uyv?ewoWWKrYCya[DRoRAmbasig]IeaWFwWXabKQRkMhi?EkAhi=ihAWx=X:CbhoS]=xpCe>=ieMItIiD_dnIeYQUCEccYcpYho]UTieqmuCgXleuYay`yH]mvFIepubRQdHIHlKbMSgxihnOfvsY[kX_UXBqwVIBaehlCULcTMYiBKS?_IJYt=gy<aRMGdRoG;sf:ubasD:=YP=bCEG]Sdk[fGCVjagyIry_UVAbT=y^_h^mtXssIkC\\usQwi:oyyuyQ]TMSfDQfOgxYcfHyB;mhZESbktk[v?iTBOGM]GmqxnWf__ik_tXEYIqEFKcM]uxYtY?fa_TP;Th;ffaTXkWFwdRwrJQUeayG_xsAfrsbW]GJgtVQBaYYyqEWwUuqBtoutqXfuDAkhwqfUCTXAh;AgvAS`sGKlxMEQY=tTEPOTpqIqYmM]MRhHLQ<XpiSeAP^XMsplkIQm=TJXubtPXPPDiuXlnrilgur;`MbttfynydycplMlYUYuXqVq=kGAxIhLKpP`]xkqJmar\\AWX]pJtkwIxP\\Kv\\xJLNI`o=xxFYpatL[lnF@RJHnm<KC<Yo\\UtQOrYUUaX;PJPMvmALvly<mlF=T\\<uLukQiri<Q]PlT]p:LPdYMNHpL<Mght>PkFISHxroeqHqQ;\\tb`qTay;DXXmW^yrM@oLMu[QRGyjXtRTQmqdvP<mE`QQurLlJeqKA]XkPWa`qneJ]lTeYv\\YKV\\RotpyLT>MvnTtWDm;TpkYYYIRlUv@\\pxYyaElWYpUtJhHqTAMnePQdxj=m:iW;pw>qpg<MvYryIrKdk[EuyxY@dKemsOqpndsUxkL`pixwQtQAUtIuY>px_UsKeleaTlTTmAUBmpFePAaWUhLs<xRdVoMrHxNuARpHOPMstpTbXRQiMg@MHArX<XylwfIkalm:iKq\\u:XKi\\qJTOP]ojXQ>qJvYVetmNDUqMmEPRVxX;lXWuYwLX<qlETupPrmMuSpr:`oPaupEnZVoiWx`>a^WuJ@`@ghPvrZH[^gvTX`XYuEPr]XwJh\\aWdVyqYns\\GZxHmm@vuFiS^aaqmIPfr^gNaaQV]uiwi?drxvh>qLI]NguX^nxhyG>iuxv;yxLX[KOxtAv`>mOAsG_ZPOjwFZv`p[I`^y@=FuAv=KvNmr?SxV?xBWVCki\\QTZahm[tsAGMsvZqfs_TVIT_GF`=vJ[I_yXgsgw_CguWxUG`gGYmcgyuwqCDOBlgFeuE`EVfcBvmGBKrD?cUqh[=Xn]BgUP=yuKInoqS@]NDPwVhPETtP\\O>qUSqWrurp]peERfPoduwTHp[aX[dOUiv^iTamRdMqyEXBIWtLodHv:<YHDwXpUWeJDIsOhkdhlCuN[UukyVQYsm<sopUy<x;xKRYJmpPZyMuTtKtY;lKdmr_PRXlotPYrQUUEpuUyp\\Py<pPDvEyu>Pp:Hn`XKD<SGXsaEoGYUNHj@`JFPk`Ei;yfcXve`g^vrbYygyoKyiWyX_fGCEM[iDucykchWeyAbpgcUCDsAsyCWpKC;OXUyWxebnQiA?tU]G]kvqIfqyXygRwQhM=hliFQCEEYvCUYWehgQHqydU[E>quisYKCwWWIK=dbCFGywbcvv[yBKEhQiESXYIY_KrQmiUUFDkRTCcAst\\_XQieBKcmGeLkx?[seWh`AFZkCCWsfGhiOwPce^WSIIH=qbwQUh?X:eTrqh:[X?sSPURf?e=[g?_VLCWk]UHARBuDvAEP;raQSxcEmsV\\[FH;btyYo_T;mTV?VjGiChj\\\\qoixjUS>=TFqvohUtPmM@Qn<SYAX;Xw<]O@NtaWtspsd@jvGhb?\\JvbW^mkVbTA_H_sgW`uYvKQytQyjYvYvyRVoQwoPylgo`Zy]MWhTHy[Ia;VkRaxcAmxpvv^af>rXHajx]?hmu>vO>xLIj:o_cq^:XvdvlJQi`ImjwtqN^a^[VIiRPhoxs>odL?`P>jGGh[gjEqyPVkYqyH_jTOeNOvs?yeytZwvqxqCPsWwhZorEwe@@vcxndVlXhxIy]=qsUpg>?vAvt[pkePwv?v=@kffaSOuOwa_paWg`_v^DQd]Q\\o^r?hsIqi_YonauAav[ViZY[yikgytyq\\KXiiIrFYkiFjaXoEwf_pcF`k\\wsWvhbQnLitc^]UgdTi]yVxf^sxViGpx;ocxVcDXd[@rMq_:hoOw[GiboXkLfcrF]_@elO]QHxmAiKHweit?`p[oooOspFpfx_ihc?Oqov_HP^]HatiZW>`[IhpyurWZ@n]w_Z=XjwA[BXnDyZ=@gL@cb>tTqnyxmqqnq@f]idYPjaYkyikth\\eFpkY]Ywb]QoOAkIImE`cx@^UAu:xivNuWNhihgSQp?vtXWigp\\?WpGqZvYfE>y`Q_jiZDq`<N_[iZE>vO>tbi\\JQgWQq?nq_VcGhdZyj@@pyqpUGdP>bG^hpOop_soH`=ovlnfAhZnOc]NpYo]=I`?qh>faOqm_waE@qLGlUYjlGrROjg>\\GPv^xtwHZqhuww\\H^wUYjPGZ@A`QNqJhyoFk]NxByu>ixyXbsFa@hZQvqNnqSYhFHi;^eNFfDvr<wbJF\\ZvawyaxYcXydNou[Xmd_mwV]ExeyqZv^hqiwRfcFPnm_aCv]A>jan^Jq^Kakiotfgl=pndwaqY\\FhrG`arok_?htXaagp`Qh`A]C^pBndC?rtvtUyjJappghvf\\MHvUFlPfjTPk[FlCyffNi__cJQhTVwOPduwnnVf_AfEYoagu=Q]S`_rAtA_tSvkiwuHPy?V[Gp`CIiGaayQZ^prL>]v_vK^^yAiENrevd[oxUvu^_vpydEYll@lgwrIHhJpxevesQ[`WswAiKibQFuWNf=nymWfV?grvrSHm<qiUv\\hNb>?ZwArWyh\\oyPhcbXv\\_\\<ne]WqpOnl>tIppQhq<FpMwdTF]v^gRI\\@fybvgjVy_PcsWb:Wk=poXVpPwhg>\\M>\\C^kV>o_IpbXtQ?mwVtYyjDAsBNnlYuvvZTfsFwlNv\\fnvt>nVx\\ZOsD_sRGcEVc`GlcPam`r:IbAu\\owGeD`SeKegW[sXGV`_sxgiBwDmQr\\iiBQcmAGKME[qh^=vLcXFLxCQqyHo^dMAlmFqOLaUumtYuL`mlQxxHdMPelpHkM=OcQRWpsc\\VoTVZtTolydHliUvktliUp<pNpiScPTW`srHn=dUnqmqINRtoMIxATVUPopXQIIsk]OyUOweqnyWYukf`R?]w]ApnHoBQylQtAMQbdwpXoo]MimrN]sAxMx=MYlyjyjgaTFUMjymUTmVUjL=UktJHUwTTMKqOfAXRmWvHL[EloySvlKYamh]wtiuiHlhllJDWiuj]<L>ETRToopPbalepx:As`Hv^P^KI\\rNb[_d]G`=OZdh_Zir]Y\\EFeIYiuqdFvyvynBOskWc<nk<Il?^mm?sIv[eQwxfdmwqoH]mf\\M^wnVhYh`KifuNwSqs=onXX`M@sCw^_viMvpvIZShxeI`ppxx^d=Hb^G[vahn^yEiZZh_Zo^BYsagrKId`r`[iIEvRAekSrTcv`QsDMi^ee`mxRKWOebTkiOqrTEcCah<ESV[USAWygd[_VoAd=QUPmSpirbKbuIsCIY^MHS]xH[CbSVaIHSMFQgXJIeoUfe?FCWfFiwYyg_cDRAcxEw=mcOab_QE>es?whgUIx_wUwuvqfhWyuEy_ydUie[UBxYXa]B?MHxOb:gBAKE]Sh`Uf\\;rswYUqHFuumWUQ=uCeIpoEKIwMItjmxTCBaMWxYDBOTt=H;IxcCyeqv^IgfAU<SFQeYDcxigiFCdEsGpkDTog;[Y?KVskYXmhUaxYueAMx[yB;gfEAtvEsEaBfOfRSVHEyIyY<?B]cBmyHXQe?WgEmDukHeAbAeSJiIn_xeos:efXuGHaVUitYmrrquw?xW=XKkfW]X[_h;=EnMVFSbYeyl[Y_Qs^;Hmchmuyyiu>ouewi>?ByceDMBc[DK;Ul_DWwEsyVrWfKeEY=TCOWLIxOET^UEecta_xIgTwAhdCtDwtaiRCWx<[FDOXBSXq=eckdZ_iOGS]_EG?gNorNUSpWfb[SySSsmb:wspOT<ShPkXpsDQqSCWhWYtUYgyqVScutEcv=iZmxC?ib;sYUbgAukWBawexMIPwGYmWqmbG;yIieSUg?cV?;Hr_IVasMqSAqfOYgk;YMicBmIlAC@cbWkvMCCnkelOB[GimeTuqP;hl:Mocdl`eQWdtSHjTPUglK;ln\\PpV=mYXxUtVG`w=UMWQq?TuiiqAdxEpS<Iuyix?\\Rtxv\\POKdRp]VRtpWiXalrplQpaV[AOlpUMmJl\\lJDVwXN]Po[YQ`dXkYj;aSEyQr]qRtLalpiuvH\\PCIqfPynyVKlWgEtkijFuUYlXYUXoHPcLs>qVaTTPeVyTv\\AwDHvBatfqUtYOvMwD=qGalKQPQ]L\\Au:tLNqTWiuC`orDl\\TMeaXCyyVQokxlGQmqdT[uxkhjE@TbxW:aRiuMLYUp@nhess@XD]V=qqTtuwXMsDkjLsVUmNmYeAPQtob]lB]keXQO]SAHWglvfeObawktTvLsSXVC\\kt=KtayFiVhLJhUukYVvpRV\\nwPxDYOgqcUYhYo]SQlo?moObCP^xvi[NyhGqSV^uvh\\@qiwo:vmEFt?V[[i\\Pia[>^\\Yv>q^mO^Mp[FQ[=vtC>cNayGQcTp_<@^;go@hgM>dW_s\\HocpybXlIpb@_hyFdhFgaVuLwma>j`ohfwjm?iBng<fn?YmG?vapyHIZVwmvp^XfeA@w\\ir@ar`nlGhl]Wado^^Fg@_kQijnV^HHxC^hqxp]^^fHmcnMUe;WuheTpcwG;yo]W<wi^aWVqsmss<ahmksV_XXuBcOI`UucSF;aE>gTc=SQ;f`AgpESAKre;H`UrPEeOarxiGQoFWSFoAYa_IbqGcySlGxHYiiaRnEwCAxB=WYGD@yhuqtU]vdYYJixlwTbWTCYsieU`QEiwbhkWk=w<IFnMv_QeOscfwdGawIwIugypYukcWTaHfGUmorhaCUqeu=rQiv[Ae@?GFcteix[msSyvZIdimUEgEyMyMKvhEc:[B:OuhCYSGFS=efOdZqRJoEwimZ=yXYqKlWdmRcUr@\\v?<mTuUyEQ\\yLW]oThQa<KcPjWeP:ypdmMiPVDQM^Wf<AwMQZ\\WnqyySfaQayIN^end[_gmq^nqgVAj;In[>wJwgCA_W>b:o_C>m@PeUGdWHaEViiAqGFni_iWfrxpenhqmiejopoH]HGnPOt[YoN?tFXmdgiwnZ?>cqityo\\XHaWA]OnryxjLOdUa`Nor@al?WpWWvf@dCgsVh\\efvVW_ApdR``uakinvcYl?Wh[awXNaDGwMPor^k>qlGQmsXrCNdUoatI^CP]:@scxnZoxAqyOnccwbhvl;akOXoJ`q\\ierHymvd[ItiiiQFi[GyXijEFp]qtUgpXNyvXcifrfytXonH@mEWu?grcp]cGtEVoHOqo@d@adKvkgwrIHxxPyCycxOnZwsbhspVuXxlKn`DAZNQrcv`nn_R?jMouuqifyqxyhRfs`?\\TpaWny@q^?^]H>plVaAPuqOiaq\\F>[ropvHwgNZLY_kXvmxm@Xk=>ka?]m`hCNsh@gFWpc_`wAp`GuofqSI[hPZbHpHp[V`x[yk\\xv@XwkAtGw`[NhIia:WceNqYIh?^yuoh[xxyqg<GsiYm^wxSacTfhWhmrVwiyaBxaE>ogaunaZViqw?m@opgovrXqdOnBf_o>lCQnmapMIpbieiqb\\qouFxji[yxb:O^PPxnphnxexyhBgwTik;YaiA`dquJInCYg^Fm>Abywa@yrAip>Ip?NyPVk`O[_WhEWkh`c^Y`_Ip^O^;hqwYZda\\SWkxpgPa]O@pL^sTOsEXlnW]aIrwfv?Ih?V^K^mvGyUF`fnkg?bRny]ycvn[aqoW?]QpyTxx@x`ZgrAvyKFj`q\\FvkHPr;Ijlyn;QtgQ\\tx^HhgVAqKvpVQhEheqvrpxvQHve`[Z^gNhn?>yqapqqqQV`i^qJV\\<>f;ooYHuNaj>@pPol[ntdhk<^kCqmXGZkPZ\\YkPF^f>vX>mkVZ_Ijxgt?icK^bAfdaV_E^tBO`PV[IG[uov:XvsPvZoZYoyD^wrxwx_b>HwNihpGfTQr?>]eiw?WsdYtJV\\`qcCnjZPsTnaMNZ<Y`>>rUp\\fNbyUEKBKACv]toWG@mSuWg`aubCHG=XO=Gk=CQsYvyUj;x@wH\\uutyRKCgeWrnWdPSF\\[WuwYUqHnwemmC<cUMITKgWs;BTatRAcZchjmDsSggWyI=HaSrQoYD?Cbyb^ivldQMyOrEK`HS>`VO]rnlJRhkmxt;\\TslnHLlEqyDQpGAl:DYw@Q?yly]yM<wweueAtqHYmpOJeMfXoAUtfIuTdQjLsCQsstPBIySIMptOhTqC=KHtVRQygiRc]WumQSlQ;Hsa\\Kl]POPT@UwQxYq<K=emptY;lN`LtbiMXlt<MW[Lsn<P@\\UUllgTrXYw:hMyYxODVpIN^lxgibqoekFe<Fj@Ikxfv=_vJV__OdMQa_ihZC:uevOu>hUsQwQUMSmNLqkWUQp=Nd\\KrXVkQL^MPS\\kCXP\\EVmLshdQNPY^hmGPJPYPP]oJIJaajvxKBqxXXRHYkAIOCyu=lviMM><sImLaQR^lVWQlkhYuALb=W:UojhX`mqJIKKHYAdJJXNlypvdrfiUEMQ[]V>yqvtRHmm[]j=QP@dVm`N?eoPqwnTt`DUPPrgTu>\\vqXnlmUUuxfqTAHtOqu;ptSqRWPNP@jXdLa=puxnAUWoapBXRoLxmiWPqy\\EpxEkXtYjYjY<vNYTIerFDNEmpSqxvPJxpvnUKu`MP<VW\\MV\\tCAU>xL`PykMRMUlv`PM\\R:ilZilTQNf]pcHM;XtHAjJiUnuqpQPn<pDYNQHumDmjdVE`tXiQbEPeXPPUW^pJOhR^AYMLxTLl]ixvlqKUT=eoS<rvlja]V>ukCaOMlp[LNZxr;DsV`pk]r>\\rF`RX\\VSYt_InClM\\DYR=jImNXhlYAPadYuquw@OBIXvlvF<VEUx`pKIaUbqRCpVryWpxwbeV>xNQUNL<jIIspIk^MLCDkD@wZ@YFPlSDMjaMB<ukEVraURPuAeyYPUv`mMtp[uYqISNIrxtnmAvRARR]mG]TTYt\\lKDpkAQSsVuEXrxAyAya\\Wm>olQuVUb`qv`Ui=]WumY;se:sRZevyWB`_d;IbSMBfCBAwuK;cC;TtSwO=rgssd=d>cV[mhOgiOeGDmvhwWjKg;Msy]e[IsC;UAgcd[BRUeC;hl]C@mD>cVtKCHQU_;RTEe_[yqscIiwCKrGmFbShLyF;MdyEeamwmSsw[EnCxDaywcFTsgOOhBmHhSy`_s=ubZ_WWMu:ECAusMaSY]Yt;BeeV<AxRKec]rC_WV?s?As:QXFkf=eCRWyqOx[IIHxq_mvGtLEEmZQWXMty`uQemniNMixdupqHJyir[]qIIKnaO_@xlxlw`shALUqmY=rq@udDRC@N>=Vdtth\\WhmnoIO:IrR`sNANqTwpDJuutPhS<llx\\MJ@Lo\\xAYUjtvgxWA=WHupPPJjEsYQWuujchuulKL`XflXF=pMIkMMJRqL]lNBTUmDYghWeUXBiof\\LphlyHvuAnsTknAtvTx=uk=uv_ey@QuxpxRts>\\weevWTOd<N:uT`@UqltlMoApMMQkh@uhTWj=mUAXymtxtKW`S`UuChWqyuyuQX\\YjIRvYvyly]hOaAupQr:lq?lkP`KldThxPW@JEaLNLXS]WuIvIdj;pt]apIyyq\\u<lnuev@lUqIjqAnxetd]j`qsMmly@yWtTbmYxEq\\]s\\eXVlvrmThAy[@Js=OBitphjyHpRtYg<xXlwv`oQewkmKOxYHdyfIm@=SHQmfAn=ux]eYp=waqlmUNexoo]LPuuRARyQvmxoxexePm@HytytypuhaKUqUr<ryMQ:yRreK>>lG>ykNyZq\\fIygygZigiwr:VgAysYxkti\\e`tk^c^PdjIpXXk=AeNX^ZOsgvj=Fx=GrtAc:w`O>dyfeAp`OAZfYxKyhAXaHgwayj`AuUAfyQvmxrXViFvhYiiqnswvxVg]jhpGqpQ^\\jyk`OeoO`YxrlGfiykpf`[Wy=y[[`hQi]BhSYV?yryiSM=GMOBpYFcaHLYb=Os<IgsWYFQItSTkwuaUrfweIwuvseHotpwDqGHmsb=SyQ]UkebWmv<qh]yEjIe\\As;uFY=IFgHQmiUAVGAHDGfk=vOGum[g=UDEwraShE]GwauP?GfUyemhwWYqQwTghEudhcrEmUlQDuWRfUIxGBYQtqIIMchq]V>kW;sXQGICAGY]GdEG<kfBMDfYr`eSUOu;ITUGtRqxQaWV?W?QsRwIvIvIsF]kUUaWukg;su]pk[pSIQkFhVe=tNHmpDnJPptApSPSRUUNYs`mxphyoTujAxjPssTX`as;IyaymiuXBhWAyaaHesvvvYsSHobH]>fvaot<?^oXZJp`RYupythw[v>x:pn\\oitYtYptdAmpHupObj^ievgVWh?YgLA[eW`Noc>b[aSRIglqxgUhgAUUStguixixiWwTmJxQxQXuWLVUIVgAq>UnTeWXQYOqSTMQXikM\\mhPqdQOg>lmXegWpgIqnhheqtcgdFosdhev@ikhu[npW@e:xi\\X]WV\\aWul?xfYlY`y^hu[npwvnpiwiwiUWn\\y`vHvGvbVws:q`Uawt?qIijQflb^v]w]uAmPvotQtQpq^XZcwwswsu_wHHpgAmUqwWYqkYqYiyHw^SgejGr?nhA@u`W`vy\\<AaohydYoipr\\hbE@xKxkv_bMovfWpgAeUVnBIn[H^_^\\pVqqhs@^yQ>ttVauFxWxwvwbMGcYqypyp]ItAw]oXa?qp]ofVwg;`wxOynIwpAfghgp>vYv[pPioQgVWigipTWlxQsevo>Ij=vZfqckhWkXeigqOVwQyoAy:yBx;fOAVgUhGqBvYv:qUoQgQEgPwyjYrISGbyDGiDu_WmgwicHH]S^QB_aGeKruYspSuf=rykcF_GFGiLYUqoW?YeXax`cgSmWUgWyEgwUwUuuLYYbYhYgyfOStkhSqV=kyk]VVWS:IbowexaPkUvGxP\\QpEqO=qjGTMfqkkhwSTMQlNyAwAuQDhVEql[iyiyYyhQRUWUhKrwdUgpdglPaacIwcIdA>r?qngWpgImRFc=OaWpreqeqQa_N\\pHu`WZxIhfwosgse?x?y_xG\\qiuqw]x^x[x[[vmIymJxv;ipANgQ^ikpuIgxlhwRA]Q>pypwtXwnogAyuvisYAuWNfUY`MO]fq_rGffiiiYiYn`ioufHgU`eq_xmwmuaukwZ`a_EFrC_fVh`Fa\\:OpDoqagwPnyUx_DI[?VhKghhhdvf\\rXhuo_NWrFOl=ioaYgwqoohpOwpUPgWqeTviEihwwyTgkc?mUp`gOdCwnwhqWqiJ`gmH:CDF?BryeyIyY?uoWWQky]yIxYBmwVIqrukukqcaayrgh:Ms?cVrQhPQDZ;gmcYNoR:sv<]HPGUEtp:Hq[Hn;uTTTN:TX[iKdQsaemomt[emAdm@txGaK_ly`Mo_@NsIuxhYuat;`McpVLhJryjm]MvEpJ@UUUUUIVW<LWXLIIvBmXvhlWqVy`yfyVyTtdMpIyrwPVUhKrqpWTRexoixtt<OQ`UlEKXYyXyxdTVu@y\\YkYHtx<KFaJjTWK<Y<`p?LX>tT<@Q;PjF]QOPSceunQu_=NsYMxYmuAVu=K\\apr]QxDsBIy\\<sXlWKek`qv`emS]QqmwVYNphlmpkIpVfUP_lOXTlgUn]@QN<tcAQRdUvdVwQVhdl]AP:PYf]WFeNmXNslk]dYAqyZajsLQHXr;pQqHVY@pVDxKpJHEYVLQRXnOlyuLmXtqpewT]usuvWPoWyXquXUyKJhWp<vY@WpTWPaOW\\r_pMEakEljfyNW`XLavqaJpLJZhJt\\YiESg\\JVLJthJJ`JAUkOXLRDKZ\\JTTwwDbmVafhrPIyX@bxahAnybA`@nZ?IjNXxb`de>uxhiuNyI^[ZF`T@dAOxrYvIXgUpn\\gtPWycadB^yhvpEwx[Orr@vnHZ@pcAXhLIZOitOicCQrsxkaW_QGdEv]Wf]w>ogPwj^_JphsFlFo^KYuUYiRihLhoYqwSYpAWyxAhHHvb?jigwYxvDiryo[gyaeyhvxcRqg`?ikhgMGsX_yFxtNHd:hgpHu:xiV>egVg_QoXgeWget>iuIkI_i<w\\YpyFyfxVnInaSHa;nmyg_]Vnn@Z:`oL@nB?v`YjHGu?P`@vpk@ZYX_=h]Gqb@obnhcVyuMvcvFn:?sYQ\\N?qbpZ;ojuaaJYpYVuphgA?pL^b>Y]?wiyw]pgkfIbSvcyO^SvkKi`]X[kvgFVtvVt[qhtHvkOyJylYykKPtZIbKX[]n]lFeEIqkamBnxevdh`dC_s<nbxi[CWi\\nmRHwv^]B_vA?dkgljbqsU]cDhysTqdiICDwRUSCZIxQkGV=ynOfLSCjyCW[f`yVvoYVGVgOXPWtkaDASVwqbH_eKYs[oc=os<Wxq;GaaevMxCQYw;e=wIOaBxkxMCrXwx<IvVWCyWV>mX^?s?wxYSFqWFscsMcfVEigmHZlvPUyJXx;iNMqv=ArAhYyqywYlTiPyQxuUWuUW;yL`XWxhvgtW;yxxxxwdUo@wEtUrQj<HQeIxJ\\ufhWCQJYHwten_Eyi=W^=KUmpfERxTlAqnAyPcTNa?dtA^bXpW_i:HewGltpqh@a`vmOQaUvZV?[tNjRx\\X?jLXn<pbqW[DFnLnx`xhyV^CNoNy^aawIPndql]y\\a>pwFxJnZJYkDn[Pxgrpaeiuqwuwalw?eeNnwFuaq[Fq[fnrnAxv^lDibFxl@GxrOw;^lWFaFamkV[qiaTvk:>ZZ>ZC_b;_d;GZpglw@f:N`_>m_VcP`c@Oa_QgSFfq_\\gIns@hsfaLFiNHlhf^kxhfW`\\i[KfeN^aZylBGod?jUgnVGteAba?ffXuZQjUYvPitSa]Hxn<>^;Vm:Vyf_klo[iI_HnxYXihIqtgeHvlwargAwfx[QFmJ`fjxgIplwffsFs=ibqngmGaLYr;pq_aibAaC_aHvhvnwYhy]gbThpIqjwPmWh[ryse>kmqj]VieheBajfXaK@cFotwxfhfaYN^EOkbhiR__Pngk`dlHhdguPYi<p_Sv\\Y>[P@q_yv>fih>g;oryalAHqJhbxVmQ>flGr_Ahcgn>WclIviwhhaucHeVNyZ@xSSO]Tt]vqUFs[IvGx[[IjwVgkxGkwuXy\\LwEHvNptO=mOAtG@kvYykHjo=uO@u;Hn\\AvmLuIdnUtqIykLxn:tUW=JWDnSAx^dYRhUT]jWXnUHPKxM=mqNhTSAwjmrxpoo@kepK;@TNTv?`LTXrW=MWtM==nTtleUT:YvIxQkdvxloyfxAvbX>x\\htovb;vq]NaYFhyW[pwkyn[qxsCXedy]Awe`W_lfV]Ey?ePWvsEHuWYp_Wi=IGOS?]ES_UmIEWUHj_YsQXk=BXkBU;bCQvWoCq_wM=bIIENgweKwRkrlgYBIVNsVVoY@ouQ[XP]XTCgkEuy=F^se?aF\\Gg=Ac>]Ufwr>Yy=WvwssPMtL=HPsf`EIbKveIfKQBYyfMIEG?e`OdH_GlQr;QYEMTVOGTWfmIVCEDxsFAMc@[gk;DhytTMsNgyDur@EGKwxsiRQcUn]tkMFUaW:yI\\;XjqV`icB=DaSGl_cfsdfydqluJals\\Oa<R@qVWAnvYS@ASJqp@tSSLKUEODptDiUIujc@x`tVsiJdQxYPyNynNhxJUuidnE=S_lNjXVaqXv<xZYJByLlQsDuRMYnlAPw\\NgUSbpNheKPMt[\\tTUlaHKamsvtJETuQTNpTpKtxupy>HjNuQ@YpCej]tVGAj]mpJHmTuqIyk]ySAlw<uq:`Ta]Y`lVnds=QlcYokHpqeMtQluIld\\kIMRtPjYenB`lfyQe<vr=lMdLXtqwDpCuywhXnUNTLjg<QchX_Lqdqv[LMbxRx`m=mnRPRp`VHhRjqNO<LpMkmUwKtJm\\mhytw]LEuSXXVd`m:Yj=up<YwlIV[XVO@QN@PPhrIIR]]nMTu@xM;MqJ`tkQj^mWRMuPMPReq:XXSmywDlYdRkPlM@Mb@jXPx`lj==wWDu<@oqHRIiNDpNn\\VuDLe`X=YUplskTNyUp]DWvDPj\\avIrgQxEw]oYvXPtT_yfy^yp`:WpVhabauUfumG\\natex[bokFi\\Y_e>AbtWpj>vUajCvZJPsG>^QOc[_hf?ZCIk;_sXha=vnipe=pmXq]G`q<FbinygYdYvtHGagapMAtRAu^?cCg`FPqxHnXVp`ohEiaaIo[_tOghrngqxeUQoV?r>vu<`xoxreAb]WbUIbggfNGcpqinVf>NinNt>q`Xf_T@vmibaAraIkLh\\_obx@]WV\\jIyfO`GHu@^yawfHPwE@iP_[_W[EhiJ^usWZS?nFoh<YmFQZvQegilYYx`wvGwcZ?fppZeilR_kYP]jYpWpsXps^hpwWaqgwNp``Apsc?SyqqwA=HV[t;AtYmyvyddABNmSb;y[isuIdMgw<kgZkvpgs=aRhccAsxhgrZMY:QfVmBM_D`yeekV^YyNYTHGYDutD[XNiSQ;dEEC=oG\\OvJEd=uExMbdCb^]Hm[G:eTl;R;HKsaoqDpITnMTRATjQ=qSdS[qPwimQYv==sQdPZamTDYZpKmLmaIv:AwX\\wVLu^dWCMsktrGDS_pj[lv>IqF]VAaK`Iv^QyypWCPUV@oQtNJuLfMtwExypN;lwcikmItU`u?`jnxkgiS_QL@<YMlwFYwPXO_=tmLpGuygiL:lWIxhA_m:H^m@aZIhugvrnewwwowZjfohoqj`w;_wSFiFox[AlBQ^G`k>?]OfadHrGIyQI_YifEVvMPmugejhe:Xa`pc>xuu_fYhmGVcOOaU>chad@veKqx^`tc@euIo<Aktq^lXblwa``vvpfe`cP?nVydoOswfvKp`@fnGWyJP_hyp>F^<GqnXeHX_KAd_`wNvfT?lxf]JhyKo^ngaC>ytnaKVrFIaGOhiAqX`f`QtXvmupcVXwl_dGyyfvvVhsI@^dFlPIgexcAxe\\PkDGqtFiyfflXrlwa<VsIGeC@fZNdmnfLG\\LI^wIvDWfhwhqNr[@lVxf?aqyAmtXwJGmEyvEna]xf<Ht<FjWx_@_t^Nc^VdnO_^Fb>^yaOm?qfUYlpgtOwdsncbnjIonJW]HYx@FplndfnhUWmhxbJwp@VybFmJ^rC^tPpprvixayCIjpNjtVb_WwqxicalooadYn\\Aer>cAyr]gy]Xw_^]W^dZnvMHccnnLPlg`ZIHmkQxjqjAHlBg^nq^IqflpjnVvlO^\\v[RO_UPtj?u:>`YP`UAeZNk>gfNG]i_e\\>jpplpgijWg]>kl`aJhb;^h_WHCCeoBR;DbyEU;UiweAgyK[r<gXD;EMKr>yR@ybnIFimcpOFZ[CssUBQfooiESXTqDd;XqqcDStL;vHYcmCFjiD?;sLAs\\OUHAVnCHZst@AE]?FBkr=ecB=CmmGNSxDkroIdP[Sewes=CNAIoUul_R<cFC?CNKFeob];GEYykaW<ms[?fAQS_STLCUfybYYDLsVPOR`sH;OyjUg<[f[sfN=HgGfUCTskwHqyoQt@aghyHc;bOGGa]SAUFfshfQtxUS`wB?;uD=S^qB_aU]=CsYwO[r<ctbKE]gU<gyHWbRKgpGhT]tPuTowGGkrD=h`;e`OCCpPtumnxO<tpAAVKqWslSFyu`tqoLPT@u@PpvqocltgDLB]MwTreivVmrOIyjhUSQVLmkUxlQERh<nVTWLEVkPNWtovuTLllYuNHEnSdohiJdawDdjNHNIArrmJDPXWlxhUSUPyqXsbUphARpiUv=RHHOHlt[]R=`yv<we]LayLAiYqayLMyoxsn=T@yWWpSy@ZrN]TvyfvqiNsoAsbIiuaqoQxW?\\cay@_sWx`=Flj_jhFciXbXOnV`i[foKvwDh\\e``DF_QX_`_ZLhlaOlgWh]XoeXZEx\\iNr:wyZntynpXwmUOaB@bZ^k`pn@g]MQwbAwR`qH^sPPpLojgWa;g^Wnuv^[]a_`Nb:poOhdrW\\jVg;Qf_afeip_?[rWdOq[XI`aOm=^bVqm:hc`ngGo\\\\Vexo`m^`EOZJ^ls?yN@lSXpHFaAvwFnla>nM_obpcHPp=Vqqqw<i]yoqWogvQZtyZtitcFdiw_]`nfIt]fuhqhr_l?w`>WmJF[@gZB^jOh`T>Z@at>AdjNjxHlX^axxf=Nf[AaPhhiP\\fGob`[Mh\\Zfhs^joHi<>\\f@b[`lAA\\;wl:F_AI[DYjMw]c_tAxinFafpkL`gRyvGNn_ngFqsFI[Zxk`xjOHls_eh_ppvhc>aA_jWxtAQmk>lbIrPpyG@uPyyr@`w`l<XgW`poH^RQc>Yd:pvxihJ^pxOqrn\\QH[`qjXhmQn\\T?\\jQ_s@[EOZJh\\=Idu`uXfhHV^]ii\\ayVAk?P]NOdL>iKqp^Wx<Qp?Ip>aZvHuXQpnhqbVy\\>\\_WkM^nJ@k?Qe_y`LydNym_yqR@jyxdVHyXHlG?]Iikb>kLHbAhyo?hEqhfWm;ntOfgU_d\\X\\gw_WVnm@gBOeOos]?l]AaDnvwHy^@[?q`uaZvQ[_FhBid<WoeOxxivxQrxqb;Vh;^b;vhx@iXNyjGqDpjMOfyGxxFlYvnEXnBPk]fwlio<qoXxaEI`mObxNw>IiIAlxo]KxxlxmLoo`nqjfmr`x;AxrqpCo\\WquvP\\[@heppwPeh@gnAnlylQIk`QqSO_[anmhyLytsWxVG_SNyKQviQluQdVpf`?rjOjHn^J^noAdKAdWpwuP^HnkgAhsfidq_@vbugnGGewnZIytai_Zp_@aw_XdjHwCPkrnxk_^LV]NI`t`^<fhshvqosvnwsxv`gcS>\\xxo^gnVosEqpC^lDXiJwdqv\\ghgmi^dq]?wm:Hi^n\\AWgEg\\af_dsWiIYuVVUU:wSV=FH;tC;up]e=kiOGh\\ef\\Kd?WT]WFbSX:mblOC_UDecsEQtuggcOyV;xn?UrSH];s<iGcerDqtjoExwi>mV[UuDifl_uBgBfqumwBSCXl[YPAGY?gMIeBUghmeWss<yUD;gnAdVsSdofDYV`krMKxZkcBSBqAfskt\\Oh;wRHIfg[u[;BK]rnqbSoFMQH>Mb<EgZ?RSmHSuePoFJwx=GC[mR<axsgD]?bBeh:OgjWxr]h;mcqKcowSVic@?YmKuTSIJkxrEdDufJWeB=VfOI\\?fPaujcSxQi^IVHIWuOX<KE>CeB=iHEUxwtecWQ;VaIHCsC?sVCcfFmSV;wrohs;wn;uqES:uFLSgAeUwUCvMD\\YXf?bKIs>mVVuB;eelgG;[r[kCjSd[YBVgDjesUKdJWrBoFLGg[[VlYDBCSnKTQcWkkBYavv=YGyF>;wSqbtAYe?BJwSWoFyuR@iUJ;xMsS@?T^oU?ycfEIg;B`ybIiVBiRn]B>kGAWMSmQ]DJ<XYWeUA@JcAQdlSstUk]m>\\m@tp[dujAmviUS@raloPiNidVkPtadN;Ll\\DK>PSUmj==oTHL[tsSpS?AXpQLw`TFHRleu@uJBiVIMXVtYZlnAYRGMk_mPuln:HwnEKetlpllEEMguXoPw<AW`uQVUL[EqhhUBXk]`SamjnhmlePZYkpLsxTJLIjhEqipXYlVxTj>mX<<w_uPWxYi@lRpTN]niXXsHP]xW^yqVmYFUuN\\liaYHuonxV>]m<ETWtVkTtEtkQmkYaqJAwqms?@PTtNUalclwE<rDXLJxT?UnTDqppWaLjXEwQEXt]JgaXtxL]DsUikBDNNInuQx>xvd]x^IxOYsmeOQQRR`Yx@P[txB@LXHpg@xtivSiWvdL;]SQ@sPYOIaS>mskUQ`asdxrLhNaEVCQt_<UwPWXlliTm?pv`ql=PPKawT]SAIPZYPu`v;xJX<mv@V>LYldW@XVPaVYLW]aJeMSf\\Oc<RJxp`\\kVTstDO@<Nr<lS@sB=wr<nTyWxtl?YnIpoQ<TDMs=qU>Au:AmlXQtDN`hOTmsb=QsLnL`J=ITHLj@dy;]sdumgDviTRe=KuPkTTJnhSMAtSXSE<kQ`xr]Vx`Jfum:Hm]`VOPNj<RPYRP`O[aYhtVVTndEwhpUiLUTMuK=saaSaqVnhuiYKZmwVinrYx=xpcTsDdj\\@Wfmm`tqgPNJdk]]UV\\J;YkKDjvLsdXsaLt^EkP=UH\\j_\\NqIqwQxUAkfyOb]V`=KjysSHqREu[MVf=TW<L]<MtDuR@jHMPoLNfAP_@j@AS]\\MFXnxHnGeV\\lMM@riilwmsTHq>Uul\\lr<nyhXTHMYTP`eOKesq]UpYlRTPtiu_Mja]pxHYL\\WmDmkIskuJlxvnmNc`Km<OZLwJIXOPK<lQyLJxAm<DXmUPM]OeaLFEwN=uHPolqsl\\uxAJTLrmhPLHMImKB<xrIvoajN\\S=Ep@UPmMS\\hJk=k;EQYtl:HXtdmJpP^\\L:iK<DLOmLVeT\\<P`\\V_]r>LXAPpvunctJLhv`Qpn=jM<O^XKLyQGpnv`n]PVl]wJ\\qtuyCUy=EX_=x@AVpEKMDOH]lEEny]vC<y^AYoeOWQYI<q><mwmqR`wqDjfmWnMxx<QrTl?yj`pt_<wbaQWUurDlditb`NJtW=]sqtt^LR@AYNml]EPsOqp?q>IHgbVoGqGDcaD_QUmKcZWBmOfBkRy[XtQrLiY[qR>QBEcCa;r@=so?GD;YawFpYHfERfGYC?IxmRh[euGD:wT\\_HY]i?=bwuhVxR[aluuYvDqUeMXUyVxlDywPDsslj^IMB@k=is\\alMuTZakOYKkPVsuLHeQ_mKtPq`=soDk\\AXo`MgDmpIu`ppTqXFHJY`kWXpgDKTaJsmU^TKbIK^plvQRa<V_YnM\\VgHJMmy@`OxGwU_hJfhA_qJaqS>aDxcJF]fY]>AyR@`PwoAVypiwAY^I`oMG[bV`[F\\@op^PurvkUYt]F^d`pOHuhnes?rwnnXwoMnd^IvBIsiOaTOq>h\\ua\\n?m@?cAFpgwsPgk>^x;?`AIcCndWY`Q>[MY[dAfOXndQtZndJFd:>pdxrR`sB@\\@adKnpa^eEgxV?mTQhs`dKIbIOcq`fbagavswP_fOohnu>h`aaq<vhViyu^wRYpCwZPqnqohE>ZqVnkHp?_mAO]OVhZQl\\Is\\hbehvYhfFvkF>waOw>P_vwui>bLp\\J@cb>\\s^s;Ha@?Zvvjj_nHFvJ_cmXf\\i[g>kuVujnlR^rR@Z\\Od:y_h^sSHmYn[IfnQvkfwl=qoXisLybxGq@im`on?wmt^daGs=PchP[i`xCwfWQ^cYxvN\\]fiDq]eI_WGcYxvmQ\\S^vMqfBqmMXgZy\\@YaGWuLH<YDCIBGoDLUv==ESSwo[xyIB;wGsiU;=bf;EDWeH]rj=goexW;c>UeNIYAMETexMQVKGGwURTgh]Ix@CItQcLWf>GdNuc@]DxsU>CXsHkceNcUVXHT=Eo\\XymQk=QWP<LmpooeT]@T]YQpIWJMNUPlvpN>IrHhvtivqeJ_UxTdyJhNempM`UYIT=mx[XrB`r`HswaQW=JtHUWdpUYLJXy[`jvarJpmYMQu\\JQ@QsujYyxNXyViNwYtvdWcLvGXpNHumiYnHuj=XHujAmsi\\NgySC]jt<nAyxEuU>\\mheqHIjj`R;LtxaSdxUiHYhdQ^lsrAJX`m[awJqXu]qKDkX`QLDThQr:uuT=m=PO@`NdtxaURUIoLDX?enWINOIvOIx_mJj<tmunKdrDqQLdyeAtlTx\\]toemetx`aJL]mi<vFXncHNFHwGIMV]Y;QSVx`D_hIIwLXhBvag^e[neJ@dRWxK_gunc:vmqnr<hZE>h[ijQn]n>wC?l_>_Qqcf@^Ry]Tw[?xmkOmtFeNfxlgsWi\\jYws>t]X\\?_[Jo[ZHqkH;ou=KsRAIm[dyGvGGub[Sh[snOBswSECy<ov?UHYGibsC]=GNke^=R;?XBCB>_C:yI^qF\\YrgiDj=xBicIEc>eVHkbhGxRktVWYkKBlwYesrXIs;MHcUrjAtZ?Hm_s^mfFCB>OEpWS:ui\\GwHivCiYMgfsiy[EIQafs;udaTsufZSuq[hD;sHgcBYRUOvHIdecvk;FZKEDsRjsY;QXv;yJiERaigIDr]BJKe^KhBsR\\QD\\;i?gs_gdoQTeksqiwJaenAR^KfuQVtofMIv?eUmUG\\[ewOwSWc`ovHcdqMsDaGWQyjOTlAEWKwAMHmKcv?ITscAYGFAtA?Uj;Fuye:Afj?Yq?Hqob@oXO?bLUDCCICUbGmCGoxByXX]rTSU_wI=;SFox]CdT[DaME:wbTygVweQmK]Tn[`VILplmY;EXhDxtpP?<ylmJtmo=UV@iP_Uu\\ikMakfQMt<MC@jr]WW<y`]pZtt`lLieLayLO=ng@ml]JSYyrAuJ@QPam;Aq_xY=LvBAKJIuD@QTaUTERxLNwqRa\\TJ<THeV@hxtElwQy\\ExCaSVlRqEyFAkKUmAlSOppdLQ\\UUK=XnQy=MuhpJsxvbXwaQXCeJ:Mp`ukVxpUYMjTnrPkrlj<lrAuxCTwgIr>Ay:HsnHJY`RTDltpOrYwT`vxDOdIyt]rsdn?<leeVF@R^HMgXtQ=Sn]P=lY[Ut_DXNhNk=q_DViijvMTX]MrhluqPJljY]mCDutXRRiPWPRX]MpAsZqJ=iOthQtUX@LMu<LiQUdxrByV@ATh\\vNmq[XNZpYY\\WbaRvXXcYlSEQ`yy_pjq=NalS]@rb@kQaTTyMdxmGtjrlXt\\sJUv\\]tAuV]@UOXy\\`PHpjrXLEpvq<VcuX:tLVxX`lVGQm[XxDlmc\\wJtNHtPm=upxLJ<xSHK=Es@`owppX\\K_iMduw^UuP<smYPEHxmmN^qU;dWH=MLIkPLJpijvHlODrqamHyqgUuPeMJisB<ppltoLv:uuxUXjxl[qpUuMdaR\\DW:`Po<UsYS`muKqu?hOUyMQxjGAs?qn=<QsEwcLrJXM?<uDLJlEK;DJyLM>Ikr`v;]nn=tJatFpkHHM@]vKEPRmKY@o^MXFevILQ[dVw]t:ejKlT^Iki@qjDQEQTSepv<r;EXHmsLXU]PJhYUWDL=mVCDy]lmtEWiAkv<M_euymQW`tf`Ml<y\\XtByuapmW]lweV><mTUQa=V?Xwv\\uyynUEpsUk:pq:DXX=rh\\MeXjYmYiqxLhvsilCILR`MlqYXIse\\xr`k`=KBaWY=TVHRXHO[XRwMxZXLnQXD<YSEQpXtiTuBTQYTLPQSweQLdWJmTO<LaHr;EtfmN?HV;tX<tWWURULwUUQ?Ila\\r;ekcXvU\\MploCts[ltRqNZql:MVbuMvIrJ`RGdWdtt>]YX]j><vB\\tc`uR`p?=rY=RsLNZpR`qmCMKrEQw=XkTq@mkMtWgQRuam_PrHhvteVGDOf\\NKEK_yofMYVmkwLOZuU?moJplpiNK<NbUt;HKmisG]kc<xmtyVPyuXSHXR`dmMhYu@Q[iONanFumQaQUhS\\MV^]R_eJtLXI@jaXseImfxx]HJSdUBxrgPuxEL@AMEdpkmUy@Rw`ROLpiLJYtwiax>Apl`Y<tqQyOKQrfhvdXouIOaDsoMOCXxCan@hvimThIoFLpNxkRhWPhlBDraimN`X\\hKm<P]ExEeKWxmHdOs=RxtOd`l@MXXLkqHNN<m?PpniMIxRSmNyDPdXy]DtjUKmyvs@q_qmmUyFhjHYxLGm;piwnmdAylwks_nGhgafe>vnjxhDg`@VnKN`K`w=arZqh^wruahhPbWasO@sFhwOAggHnuQ^[Nas^n^Q]uXr<_nvHgFW[aFhDQx_@ek`pEfumN]j@ikIslgq\\Wl]_]yGkkPjdWcEWkWor[Ai:^iHNixNybYnM@bHQhyhpZweewpXQiengxHy`Ic:ynvObcnjSw_^?xCHpkFiZOc@owoplXi`^>]DW_WXta?n=oaIfb<Qimaojymh?Zigndx[@Wj:>q`isQgcsPbxyiVOnD`mv>dmpvIY`d@cdVrpWnghgTPwfYaqxg?gtg_w]xpyxrBanJtiiwy;FKUrH]wSiGFoFUgHCWi=ki:=rr=DesS`wDpchnOsE=rG=bEGT?OgsKrlEw>QhLKxuUR;=idkI?;GGAIK;bb[FA_D>Sb\\aEKUdkiswqB=ITFaWsCSS?ex[t@yH<KUXEVsUh>;sw?iiqcUCh_Utt[euEseADMsvQkcPIWYcFAqRnSV=?b>yx_CBnIr;oUOwSLYvCcwUmVBAt[cR?;RMIg^_eYabvstheXPCrZ]Bkov`]RKQc^Ax:kbA]cxCc>MwoKWjMYrCYa;gw=SjusY;uD?dVSIVcgQ?txMR:CUVkTbKBI_RJmCSyVvggWcGmov[KDQ;hHiVJ=deEDPsFL;dgMTCID?[WDqG_Qc[ax\\cXk]SUwi>Myi[GuQdB;HS?tx_voiwOWVkSCC?vNewi?SUyr^uY<ay<IXmSC_OgcAe>kYQOhUuHvIhR_eUwuBqs[mfL?BlWStIdKADASeMEw[]B]gSjIsoOWdewJ?sioSAQURyWMSV=OvFor?;wGKv[ic@iX:QuaCDXwINufH_r[aH@iFxyIuuwS[FSIYWECXOhciiIQsDQxxOguOuqKi[IB<_Bc;D]kcnKtF_hFguBcwfqgpefWIdxMG\\UVqUFnSy]MRDGdSGeGKcDcc@_d\\=S<_FB;Db=B>;t:Ku:xXsuUOhlOpuuuThuwwHUGlPk\\J?UJMAJlYJMhUOhxliqQxOYmmmmwsxxuxupdUYQRt\\S:Xqa<Nc<VbUM_LTp<SnLtTQoKxsm`lEXtaALOhwS=LNQooAsFhQyeqA`lktvp=wqimdeRXynDuV?Hsm\\Ox]YMDLjUk^\\sUEwVhu><tT]TbuYOPX@pyXPNlqOEeNGtuHMQuuQFhQAPwgyKbQUlPuIyrPIT^@O]uU>IJ?mUdTkr]w@pkk=OopXtlNKhOwiMuhxdHq<]XS@sq\\JoHqEdOnuShyL=aR`huJaXXdjdxv[\\NwypJPKIIr]qXJ<qe<PRYw@YRI\\m;uXAHJXuWaDLdyJQXkuuqoHLTTv]=JvmTcaKHaUAqYaPm`qwxLwquK`LJpIwsUMpYsiapV<UT]U<qnyUTXXVEqjaUKlqqpPZrPxHi\\LGnOOZCf[tNit_rXAfZQvPqZvaaeprnOa?hxgh[kHfTx[dfirYcDqmmooJXldwmHqwXQiCV]QPvgwt^psVgnQIkDof?^[KWguQndhkHWawGfCGdbXuC>^eYdJIuLPu`XvgG\\C^vhQ_WfdJ>ne?[rHqNOl;FcvvsWNdCXugPlE?hrXib^mIO\\;`o:qb:>u\\flUVi\\p[WguWQvwY[jxqUx\\bobc@bDOm:Pe`^bCh`KwwR@ooFejNhfa`\\Hlg^oHiu<Qyla[@wkWhb_F\\@om:q]AfdDGu^ObfW\\xwotVnSouqgl:qsZWpC>ZCgwqfaVhi=NZ``yTagdnkFo^;Iu?FZygoOQ[iAu[_pm_rKG_E>ZcacoQabafn>cDQaaFkQqv=vsTUbou]UIGMWPecVMF<=BYEb<oY`QSYkFI_YH?RC?rmCDmYCC?goixp=C@SSAkXcuIcAYBmIMgw>cwu?dMchIqHHqe^Krqirp=u_wsWgyymyfOermFLUEcoXDcxUAwTKxs;UtwbB[sNKvmyDLET\\CfvkXEGGsYEYUS`Cf`oh`;wgie>KX@MyviO[ul>quc\\n\\<OAYwO=RvxYp@nFlmXEJpmyvmXcUM`TtDEl\\plbqJKLTwaMsiJVES^pPs<no=YB<VOyJ_lmUQpIQTtLkTdWEyx?tNmDY`pjNQpMPtQQmv`R<DKstJpPYpXOsENUlNZqwMuS=iPvml:QqG]W`lJrmo\\QO`PRneQQajR<QL=VlEW_LTn`xXPj<@K<MS:EYH]JIilZhy_AWUmk`PuolRRmjHUsqQnGpkWqnn<tkPkBEyhMNO<q_tvV=Sh=NQLUJ`MGHnmMJ?MTliO^LJTaTW=WlpKC]pS@UxEMweQW@yvYNWAMeQM<IvCYNR\\wiIjP]jRyJypphTua`QqqjkPnklw;<raUMaqwXauVLYkelHySUdQ><uvAYiAYypuXaw[yytYtIUK:Mp_=lIyL^YsUmN:LqrEv<`sxXvBEru\\QbLkSHJ_ElBYVcEYCmWvUKWXsRIx]uwpaq[ytked<OoZnmupt`Gj@qfPx_Ggqd@ohAvlxiGyaS_ehPiIQ]tQZDg\\Hfm=pdaxniFfE`waH[qOy?`lZynBfj]H[XqaYXsL>fAHfpPuKQnbgjCiv>hmx`o;hxoFdeicAfvEXcmypYipt_rxNrX@\\RXt]i^l>wM>vuhhgQj:hqWpmegkAH[VOukOxky_KPjdgrNitq@[R``rFxBy\\[ownAdRveJHeUPiLGwLyo_hnoAnYwcu^ohpcL_o^PgMIc;>dxym:nZwAnQ?a[AwU^\\lIsMPoXY\\UhcI`cvNkghxsF^:p\\Tybtf]MVgBwgk?rTYdiYaMh\\lHcKq`VgxLHbjWh;OnSfkKQ^o_u?ac>pauP_FouhQqyx]EF\\bovJHs@AlEi^KF[iX[c>ocNcZQs]n^;f`WwcH@gTAkj>mVNx>obF^jVwvWwdvWyn_aO^p`wjVwqdfbQFi\\f\\XHjDYxZ>rGgqfqcR_p=QpIF_uiuUioQAmMFgNVpC^nMXeBnoYqoQ_^l_vB_fPaoN_]Np^pFtaGm=OiSy^PF]A?\\fgtjhbLqoo>\\CNw[_hF>\\jOw_qu^wg_Wm\\Nl^?kNG`wx^kIyC@eOqbA^\\PV]ForK>_npfk`hpOg_GqIAaY@dFojKqbqYdeppXfpTfk]PZFQhHfsgPhGN[CAlbxwdvltOtuydTg]j^xHHsaWu<_v<a^lhcQY`YFxKiiBO^bvm\\hyhGkwYtHwrNAutFtFWuoFhey[\\VqwNqHHwOY[Rqnbij]PZhPxcPd^@riXws_yy_jk?wxN^eQ^WvnINuCx_JFeO>tL`e:Am_w\\YxifqiVF]rQ\\@NyuGvnOq^qerApA`lRV\\ZyyvfgXN]]YfbVsvXtvAkOF`epyYGw^AwEXsMHoXi]qgpuA]Un]hxjtOhvpvt>h\\puYvjO>aYxbX@Zj>]C@[:?hSI^qgjFh^M@wa>ZPIdrxo^x_;hl:H^=WuIguxh_pi[Uq\\VFh>pq:>ZZ>ZC_b;_dUawAYh?>[Uwxu^mFQoPY\\u_ZvHgLgkOQcoA^qFtt?fMfp:i`Jy^d_iiqcAHbpXmr`umvmO`vkws>I^no[I`tgY[VbYuxp=dFsR^IIpadS?RR?cdcrL[T@eivkbjMDC?TJ?S^cyh;u?sHP]vvcc>=GqkuveBUWGE;HMYyJADZMIC;cu;CvwXbKWkisIQs[_SpuDvUgm=sK;uU;woKGDCtqEwiiHL=bTSbKkBDOBDCuFKhKaDWsibstocecwsvgXGccLOEp[tgCFtuufUfgITN[d[eRF=REiS<ad`mgjKF_kRKeb<OfWsfwWfxCSfkSDshRgfQYwcQEJ;VQuxB;cW;He?GLUhRIwqQGD]RP[CRaU[ITh[VK_crhm=ARg@tbaR;UWFmXbas>msNDvNUk?ENFPRtlSKpjIpUY`lSpngQWg\\LVDLKyqGaXgelTUWwPn@@wGHru@mH=Lrev?qT]yxOqS>QvVTQ@pP<TRHmwPHO<Du]Ak?pw]lLATQUiLR\\SwhXYXmMxqtUovioTxsBaqGhULevSuuVeupDnmeWO=O[eMt\\KoiUwDWrLN[ejYHKfPVu<pbLoyunVMoQyoUhmjLY@Dn\\xxPQoNata]xPqpcuycLyVF^QneeXllfwQHs=X^AVhYIdbFwv>]nHuHQuSYnyGwt^\\]qiNQcSG\\sN[WhZppkA^^;osx`auwxVoqTo^lGo_ppditH_xOG_`Qjnqie@hY@yl^tpq]^YlNFeKvmhIh]Q`Mfe=asl^u@f^HouyFkAw^HGvRAkQNiMybyVtoqs\\iaGpoSxxb>vYImwQsWiwxgd:yySx^xqagNjeqpJgikyZUF_WoeZ_vHAifInA`bwFcOwjNYdQiq;QZKXt>xrgv`QvjxYi^pdqxxpinY>[Ag\\Qp_WOrxfqanpO@y[OpSivEfpjvaI@efnk`Nua?geW\\GQ__@oyYaoxxLXoZx_fvdCfpV^uiXaLOnQQZov_BHbAAhJ_h<iuJ?aKPiaFp?qp>viSIqAqk]xpIn`DPkLIpB@jO`sR`v^VpEik?X_iWvDy[yxc^H\\:Xoy?j:qr^fycOcOQ^lFsrNh?a\\lGpRnlapoC>hdf`TGobFdLyv\\`^_GeevtUfnkhd[pnJHuPitAv^gynBY[y__GIc<^pBOcj>pk@_QQcI_fKqtf`\\:IfevrZIxBxjYg_P>cCynJQpa`\\Ux^MHkDhu@Id@puUI_xpisVmK>^Q_pLPsf@dNhvEG[SNxp^gmFjMnvGYiJOmF@pIfkBo]\\pb>^eZfvX?s@i^[VmFpgDgyqWklh]tnm?HcKHmxPu;OgsP^Iytr`bqf\\ONZcHt=GnmNlDv^\\>tdAffIw]Nl[@k:`\\kGaQH^\\@^OxwYgbkfdYHsWacdgleGyOaZd_eLHoqOltv^L?uagxXGvmA[\\PcKvdSpeAYyiWvggohFahv^?gt@VmJhit^eiWaFquy@eD_ySYwNanphtnIqc@nkPi^Aiufv\\@ZkOtyvjlFjpvdPa`mOlY`dwWqCa[qxxm?g\\XhdwdQY\\X`gaafvWxRIe]fdHinc`bt_]o`pU^_nqu@IfkpmKVsDowuNaan\\dFw_YmBqggNd>>l_Xg`pbdGxD^xWYvjqanYuJwhGV\\jYxFgg?Npvvj<PnffitqZ`^]DGmKQuiq]>wpMajxO\\c^r\\x]U>b?Vj;GrNxslQa@yxn>vmP_aWi^yngnsjw_Fp^SpryYl=ac>FhliqwOaR`[TXm>QZrnav^^x>iUPb[FsyFZXOu^Ot[WlOqmTx[BOnnwf;pgtYvNaxnntQytZ@^?_oJYg?QkKIefNbN_aUAigghope`y^_viuanracoQkZFs<ndB>co_ZHn^NNdcN^Sf`Fn_QFotPyNXiH_ha?[^Nq`v[=qtQYkQoqpymjpawW[Ivyexo<avpASeUEgcNChC]DdSgqmxCIEZ[rhEhREG^wG]UWhmRXwVLWuGqfK_YaiSNOSsEIi?Y^UC_McDKg>mbvqiSYXIWyPQwMKfR_hB[e^sD;uC=cbqqDiuCKkc?=bt?R^UT`;fPIdTwVIkItGh^svh?V;;hQqcwMBJmBySw:AD;[g?Mfm_UfKSZYeJcxXOc?;TCyv^Cic_FLITK;gk;WEWDo=DOiwleVNcUaOHIYGJKDYYDJWueeuAohmowKytUEGfIfVOS\\CEVURFyhRuecSsd_U?=FLIw?ogewTvSX`cExugOKiPeVLEuCkh`?wT]hK;wmCXbcx`MuiuDfWDAefD;c;iiLgS\\?SiYH=UyHoGVugQgV\\ogDiHpoCb;wtSWVceLmGSugbQu;EFtgb\\cIDaIkwcXYGAuBv]Cc=w`]hLCcn=smMBlaDOevsCIHItOsFrEi;qcdgcHIiAOfdsx;EFGUeRQIu_PgHTnDr>ATCmR^tOJqRaiqYaR>PS>uWydx^\\SalmJ@Kc\\poPNqInphPGTTcLjkIrX]QrAsK\\MdiQEpMQhmBYsvusvuUiaoi]ub@tsxR;tyHUlllSdpY\\xr;iKPau@IkQuxIeu>qwnmy>ywOQTciuJYxFAtZ`se<TJDmBeXI@pGUp>uQV`VXHmSHoIYPZhwEaJrDOcAmBDpa@qkQuNatNLUbQUlhylxoKErxDP@pXTylbXrWhu=<vWYRjEWCdUapS]EyvYWrpylYkrLyeuS[umXurO<RDTnH`TleJdenWdn^MR:`maANBQN^\\JHeuAyS:at[IlVdR?@rHXX:LYehoxPvKhu`<v:itoLTOPsp@upeS:xpDUugaTePRJEqj=K[it?=yamWLDlRAts=yR`T]AX^HJ<dP[tRXhPf=PBMNNHjPXx]Dl?HUftUtekXYn<`tnXkBtk:qs^eja]wnDO`ek:lm:DP;xN=DX`UsA]vQ@n]qleioGHKVAu@Etr\\mnxWM`q`PlIAL:trK=k>@knMVnmysDTyaST\\oxet@UKTIK>DQKduFITNDJqelNqYK@JLXO^=yT`wEemwUPFXR]PxXEuTYVetjeLXpHODTSimODDSlipZ=tiUnbiRIIyITpG]W\\dJKTNaYMd]Lw@P;dL]DR>XJe`J:iLKTMFLrduRA\\pwURnmUP=ofmStumDDsydL]DJteUTpua=L_aVFMLm`ovYuGpXbEkjiL@UUwMVQdR;\\YWAQlTsgmO]`LUQleir^xT`MRCdo]hkBLsrlXFLwXIVNxXbLn\\xsJenfUjCpoCAkddjmTL=@Qo]yR\\qHTKf`Np\\p`UKXyW`XwAIQr`luqwp]vGHXIHJxiMOxsY\\tuiorXht^\\qgcHFpKictqiHxn;AnAwhqwxIod]>kq`eIW]QF[ZQjIfaNwkd>[^YZC`Z\\_\\O^pp`teNfPF[^ynapgM>ieAt[Ap]xwqnq<XePV\\Hiama[<VtX^axYmyQZEYcE@_iitUvicFcswxvnybguhO\\eVgYoi`ghrhhuq`DFnBNmH^tcGfeWbfv]Mxp=n]aX]@NZNQeCh_G@aKNdM`v`No?P^<YcmQZLguapsZHeKqbUal^`qKwwdA\\EO_MN[\\FqxPklo_APZcxxdGqBPv\\Ok\\p\\u^owhybW`bGvng]_>nPGkdpolg]s_a>@vVicNVvkOkP^wBSh[W?CXXAb]CBQavk=Et[ilCvCWDjgTDOBLki_yEqyi[ugUWgvoRAEVdIEJ_fnqGIIbZQwRKip_StEeGiX^ICZYW?aIKSTC=BTeSD]UaEE>os_iD:su_Kr\\MRUqG^IwVYF\\OsEIw>eUwWtxIYUcc;iGUyhjQe;auDSbe_hbQE^Mbe[XwCSOwVeYdMOeCegeQyAgRoWGB?XNqHqSyKgxlcsR=EcgxSEhqMC[si>]CFKxgaDW?GgkSb_whMFBecBcBP;FvucN[yE=Si[u\\wtN;hGIIMShGMWsYGkAHtoinyu;eRKkexAtC[HU[WbcTC_drwtJMVKSfdiUvCy>Yv^OvIErUIt;cfTeXIMBvYYAsR=aifuV=EvYYr:wsgIDRYraqXDcCiiwaYEgsXGaSPIdtsEPOEwQyruW_UtQwEs=UNyxuGTOcR[Cvaoe<yEJOvvquqyiIwF`kFjyWxsysEW[?fmOU;iW=aycad^CcS_csKytuvDiDNGSwYEGqVRiwP;W@qrKQrE;WiqwEmwZ?RYgUr;E:icQuUdwXKaF_;uNqudKwtgd:msxMvj_hlgvDke`gIJ]XJWRHOFM?wDQf:;Xkce^ctVeFJWH:YY`aCTatTCT>aCBaytmcfMtUWeBiR<QvCwDMCH;ks`ehLkx]wR[ofBUrlCHD]RL]RGWEjiFM?Uy_YXSI?OYAaSuAIWse\\ObNQulcyeEdBIbwQy`gyp[v\\GR<kUy?BhsEi[Y]QSwgR@cWIiFVgWTcGFWF];XWCIG=rSmd>sXO?rwSEVAR[kS^adHWsm]ES?hWQtHED<ggaaB?uB@;gB?hREdiUXlAeB=fVSSDOcicF\\OfbII;[gjKe[_fb?T_UfBibXcsvsd:We=ivl_R\\UG>mBc[TcKU[Ug@GrvGegSHQWE`Yfa_vaYIMkyp=CJIiFShPGSCgVMES?AG<=fm=xreBnYucYhouIpYwJAYA;cRUtbSdJ=glYWC?CUORe;XPQHrwwjaBxiviuYOSvweUnUdogY\\siUcc>gwA]CrauT_d;[iywiYmFqCXAWShiRIICKmCqouu[TASDNowOuEyYTKcSvwbBeuWgerYsyOye[WtiyrycYUyTkEwMvC[Y[IsaswpSRk=Td]FxMyQsr@aft=SE]rlWSIiB\\[ueuf<oTLUwUExN_dPQUC;RIeEwKRF[f<MfS_dgqYwwILSUIEcv]E;AsLKx;ADlCsR_XRaHFkx]GudwdH;e@GhteTAsGnKdIwrJ=FjOuhkdK]CA]FiKtn=taybE=GokeH;IHgEO?s=WDigHXWx:uylgf=av:qeLOr^]beatcCh??ulETR_sJEt]oRKqR;osw?SD]e]cBp_XDWcMAshEyCEbuGvZ?g:evlMVU?S_gR]OdtgYjUiHWGQ;htQvqIf_Ac[ggOCrqmGBgS\\MwU[FZoXBwyh?HT?cF]WJMtiaUK]T_KtFmUXWRscDyuXlsDAUEDSbCkrkIC\\kBm_eYSup[ercuhkD^iH_At@_i`ORZsiUmGK;geCt@Ed?oYb]T:[UceXLIYc]FKYiEYgjgEn?XRqs>ITHarbKXbKD;]r^?v:AvW_b[]XLkfMyCJOYa?GAoee[RwAWDoBJqvUwrruWQkEv[YBSb`qWnUDKwxpMYJaguaVPAhYIWiOtbMepID<kI=oHiSH@iw:GIvOIkMv>_G@=rgYDrwVosT>AxTogvgEy=RvOgNsd^mWLOY]iRXgcqEGOqrrAXAsg?;xoygyeUPiIwiuYiyW]IyaymQhNku;MX_yF\\KbXKTrwXIssWIYDWfM?YtIdAerLMWPeh]Ec:mGvyDE;wgGEjwtTaFgMCvibw]g^QSRUWXqbY?riws`mbKUv<qe;eFMSvTOR:wGqScsaxLCdGqgJ_RuCbpGxxWr>;RdEmNtTiapbdLl@mDEmUqVJ<UQAwElu<ipriwpQYnDRDdUcEP=EnNARKqo[<vhDtpEK^Ur;]JixUcxPBXvodYUUU>qWkxMwlJWxvcEW<mTipycmRMdqYQSddOPUSCxtYlN_hqQQs_Tyu<Wm@MZHvVLjqXjNqYO]qpEmbpTFANwHpFPJ?MKudnl\\WAmk[PmCUNstQG=rH=VWYtIdoMiOOhPuaRFeN\\dQ`<pDmOSuN@HoUPT<HoZdLHAnXqS^In`IkpmLu\\PWhuoqYxaXcxXR`LLESfaVB@X]HTNdyeAOhmoCMtUIyjyLZ`nmUo>Qr>mKIDnWqv@qKi\\xMxsJIPL@uYem=An=Qk;qOilkXtw@arQmsByXLQWqxY\\etviu=XSfXMGUtxLV:yf:Ip]wr^`rLHbVh\\XAtJAlFOitXtoQl;ymuauja_Tof]ocTQxYyuiorgWfv?i]OhlO\\yWxqvi=xuvisYarYny[y]\\ImaomKhvSvikXq\\hoXGv=WvAwoyPkvytvAyDpxE^sNNd;_ro`uwqr;^]dvk[qdvO[=Pyx_g_YjRay[x[XgpAVv`Hdcykyau`QaHxwrH`ZQ]MPqtQgtw\\UHmlN_Dh]vA_jQ_\\hp\\nwm`m\\NvRgbMPfYofeQwBgcqpxr@dXNhDeeoiT]TmKGugV>Ove=uHofjWUdGbQQrLquqMTt]yBUHmkecis_gdvsE=]wP_DLYUeMtmkb;qEVivnGgSME^GesmrquXiCgfMFPKTyYyVIwluYActfEEcgb?[dsEVrMcP[CPSCcGw[CejeVbyEN_BluWeywBURvOVj;cdCcUks][d]SgBiggSVU_bHgxRIGcCHg;d\\qvbMfOWsHUe[cwL[fCOu@QCjew\\KurKT[KhBeuvOGZsu@yvo]xn[TwculSVUuYrAGFwRH=fG?RxgdBEf<]fM]G`If[?SZWgctrFisrLxNYjrdXb]MPlNXptpxSWiqFAuluV;Ux@AyB@JYHJXhtwtomPYvAykEYHXoI=uaxvD`Mx]QlAs]tyGYwR`KrUqIQU\\qxX=MYMyLyljyVymxa=ywyuyiY;dyimYmYmy`tV@kcwnJhyyq`Z`kp@vvpwLnjGWZjO_g`q@^\\DXas_qS`iAVv`I\\rg[W?pUfmj?]WAeHqo]qb_GZ?NZmwpGYkAhmqYl:yuKHmLawgymCa`[NdBHn_^tGf_qNwDPZ]fs=A]jn[<aepHnldjqvsWSRqt?;VQMukWRZUu<uhcqTKycUGwUAUq_Fj=yqoE:Ih]wfJKucmRBWDJaengFoisPuStcd<wYwUR`MepODZQGVqGroEt=d:WtXuUE;bhytTmHA_YtSb`aX<kiesD?qVTiGOcVX]b<uWJ;xOqCH;Rceh=ew^uuYEGg?HrKdbGx\\CxSOFNkHE_sv`nPMRUytEtxMxS\\hT]`RuhrDMoYEkPmweapwXk<qV:dP\\tmddR_drghSNTNxMTjqQbMquAnYlM=PseilOaoNpKQ\\Oams:EVqETN\\x:LSn]orQsLLm]HNbQpc<qEDUF\\pfIlLxQHxJHaM?uuWUxEmQgXjgXVPuxYlvvmm@<vyaLZqqkUv@@ur\\ofIQUmsMHNPplPpY`Qkoay;EpdyvLtq@ESOyRylYiyxxuSxTny@yExq:ymvIsY@vitylyOyEnQyJ<ER>ly[ELY]WwxMGYRD\\uZdNyENvqPteKWAM`dXyUPsTJiptGpMwxJ?hu<`nA\\qtqKn=wt<x<qte<Yo\\x`lMnmm;QSkeMPMNClmsmrW`Mm@o\\qrpQJH`XY`rRHXNTM?tQPYxx\\sQmTKitDMOU`puXkpIXPaXY@YSYYATK<xpctw=YVDXprEOnQNVxWcEXr=VYlxKtJDhjTto`QOCqV@\\yNdMaENKTRuHs=dk=qOg<K<hv\\lPQxLeink`U=xSKUW^lLMhx@Xmcuw@UoOdwWlSfALRuPs\\mLYjCXub]LrxxIasFDjvmLO`RVdLL]xGYuOQYypNGpLTtkQLwHqKn@WeiK]QundxvmLq@sbtN]AOLyX@XnKlxgyxjXJ=Iv==XvmyE<W]QlSUoK=sahjBINwdQI]nMlrXujEDp:=LBlW;ALjIvEmXUlSYyXTTjWlWr`KtEpe=xSLLIekOpoxlJ:yV:xyVyvxtxheQfimOPor`TDhOVxxU\\QulwHQx?hK:yybyJAHryMyaxYdlPVyUwitYESyPny<y=xQrIyNhTxdkSyqwuJAQRw@TS\\TlDscaoeAQLlrnlvLYOryxmtU=Pn_hMyQY^YobmW_iRrXm_xtJtOfQlUqODxryyW`lya]vcyveDkeATo@okLVVLjMew:ioNaPFMS]Dl?uNLipn\\WdTKfLKMLPOaOXxKVXrvMY;tqWYyUAOnhTeiK:AYoqOh@wSIOZEXaeJI<YYTj_TV=QvyXU>Qx[APH`YoAP@tKWimI@M;IwAtMvIxi`QiEnNMoiLlMuKSevXpsLPTItxpUS?xKI]OUqNjEUHenKdsaAtlXTYutPxV>uS?`yReUXmj<xvK<Yu<T`DtMeTPyVCUj\\pjwTj@TYuTqRqOO=lIHLc<XH@jNaQAMJV@qZUo?eVlDRo<uIpTgHJu`ulEm\\TjlTl;tOxMTcTNuUvP<p_yrblXkAo?ajMtr`<hQxaAvpWq[_vv:QmyViYy]PNkVIjqyf[_c]_iB?jyqufFa=HsIWoHIqu?h<Fh[Gf;O\\ifwgiwGX_wI`Fn_ChyeyqxYgcy^xyry_yAQv_yisYsYoySxoCytD@isy]Y?byalPn[QVuGfbcGwvXpyXZepr@vhgVZaprHVp<AkQYrQFv\\>\\iItoGrd@pZVdEIvTOvPNqBGwqOllyv^nfAfb;VoshcFgnaGx=hom?ppXmkysVvePNdZib@O_ugfS?^VX_l_edw\\H@eH@^Ogc[ipjYobYtoInEWtGpxPNkjNdqffw?`Qpu_n]tAgg_[cYgS^uTom=ilmvtkFxeWfrN`xFijPjMycVArLamFaxXpvU_uZoom?hjy^XXmZIuByZGYt>X]bIdunivpu\\VqOXifyw]g^Nnb``d>VqDYecAapNZU@g]qft_ZXYtMYtBP\\JYugp\\bojtIn^@k[pbYHbH@c_wpspqn@^A?]F?bUamJi^LN]FanKqdeFf^xqUvesFaCp_\\nfHi\\votAVyqa[raqHpb]_i>@jyYob^cPofqo\\ivgFxka?`kqygyuxi_XpitIgvItYfyK`crQan?wJYyhwaqauG>vSaZLgco^s`xnKynqQb;ia^I[bPn_A[PNpe?i\\Xw;?inh]Rgsf?fkfq@@b[^bZvw_xi=ApchoRN`qYsLGkvQ]hatsOtk_ZgGkP_s_o\\C^tgAqK`q?pgWw`KpjCovD^lpWcrP]yPkHOdwYr@I\\NF_l>xO^iRwsgH^SgcDxkIYs=omk_mOPkXh]XOvvhqCnfeH[DQtRnmuYqaGlt@l?_yqOlRFin?\\XwfQy_uWtDgbIiu=xd>WgyXs=oakwhmvahWxZfooXmsxkiNr]Vrb>\\JGx^O`cFu^xvlXuo^o?Y^liarw`QhrEXoeVe[AppOfLYiPFr:?bdxgtwraN]q^wu_wVXqQose_kYgin`yY_`x^kWVh^?rDQlOiaa>iUVv]Y]fiylavgnZxYsQx_]IoapmtIoC@p^CoGyg_DhyWW_REofGSScgH<cUY[cDUFNcWD]UHsU=uh[WDXeUAKGugDR]d`[xTKiZoWMEvsisYCV[ci<WdpISR]T`EtAYiuix?cu]gvr_damISix>KyGciB[D=?UBaGM[WiArH]BjsdX]ReUXekbGURbgwOevo_yvwReIrlmW?sG@kU>gU_ub=OfCcVEOhxOSMsGPsuNQccQrg=unoXV?WxccRYIC[sGeG\\?fIIr`ih\\ggcYRH_GUOwg?e_eE<KFDcEcGTEgs`cfBqFtIemUBHUi=SF>Mh]eiw?E]wsZoybqrrcIQiwpURCED:=FVkdo]dymTH]wmoHr_BVgwBIcCGc@edHyBnkuvUxGyyuYR=[YPUHvIbkMxPWY^yH@yru;I[qsYgrqkikiC[KVpoXXYgXogx?YCks?cBnMCg[cdciRUHgesg=iPSe<YXUsg<qR:mYTiXNmIUiUX=xhug@oxPeB\\itN?ygySruE<QTpeEEEeO=GUedjSGGMBFyt\\yh^yvxSRq_H^Ww^;FqSGGQBvyGsyY>?Vk[bAMIXkn>PRNYQyyNEUKLIX<enJlkSuk=aRKArnMY@@k`PKgUqPljpUJ<dngLk>lPklWS@jDeRAYWmPRUDPZew<qJP]Ye<ToEO[xPcAtFXYQYJauoTXydFcFhkCnbqGeEHyv`xNP]UV]e_dsiiL>ZyqsGasmNhyOu\\x^GHxKq[xQtVhauod`_cyiyYyyw`sK@ifIpAa^LVogywZivays;gx=`]@Puw@uhgu?qxXq`;hie^oTV_\\gn>Npo`]N_nlYnnY`i^ihhdb?ncWd=ylI>ltwe;I\\UAqNGwr``HOiggc:xayXd>aglGZtphWncrvk\\`pUorHquH`_:QfOGe>>tQYhU>`b^hBxdL`hhfcjN_F>g]qj__\\S^c_vg]Wiyw\\AigAAckYabNnjPfm@w]Xfta^[YqVXe@aj_O\\PgnGffD@apWmqGnZ>viagcQb\\o^Gx]vAxA>ohyd[owlFb]PqqVev?xq_jQQh`antyaOx\\ua_GnqIGqDykC@p;>yY^]ZyiZqZSvocWsZvs[?]q`fZAtfH`himkygyiwyhjIyv=ymyIyYXnixqIvytyisymjVhxQa\\wyso[Gg`]Nkwh\\RNesGwAig;nvEGre^n\\YujyqYFyY>ldpfkVmRorOAuGOZSW`vNaqn\\LXoRF`INr\\p`]RQ[VL[t[KByqI]uCxwhpQFhur`ExsqgAICJYv^OtGOhFmEQWU`SWc[s_wvkAYaYfbQtoMV[Sh<]Fk_SDguIGD]AhFQRGqWaAH`mEAqSMqC?UDu[ffiHrSwtwEkOXVsuXeyPKg^oxAisA?Gd;vBUfWossOGgAbEgg?[FUWDrchwAFpuiKQbauuxEDwsUdarCwFHGT^QXiisvqdBGwZEvVorbwCh?x]MBf]HGUyZurAkgjIiksDautsYb\\YeRWEbGXIke@wCquWFkGegYjIrACXkQv?]Imiua=fboh\\]XTabA_XAAt\\OW;isbaeb;YUot;gcfqFpOx[[eneE@qUMqiNwtlOcqAwV?cQWTrqv<yx>qDtCwtKFeICEQum?gqoWHuTl?sMCBvKww=Tfees_t<KDOaHnQCw[dNCGVEcVubMUV=uhxWcN=YG_DvgDpcdOMdwWCSgRVWxy_c[StJkRGYf<[wvOXOswUWehgDpMxNcYnWv>WvNkHESERusi=coaVPMUB;xqIXuCY=OFJcE@cW==HpOeZ_CdADrUIDgHyQGdKuL[GWkVnOvXAiYCIsCsMOESyii]HT[ykAVKAsOOIy?xfCx@AybeGWkUf=eimUhoCkQYwOfriuhuhNivqkrwGHRYGxKX^ACxgxwwwZidaqs[Yg=wS]WrKiBEORecGKkDMUWresqECKOTVscouuISbDuGxeypqyH_S<OVugFN]cZ=sLycHcgEsHCeraqhmAHc_CJyheAd`?SZqRfMCwkBi_TfAuB;uSYraQUuivnQGh[bhSRSQg<IWqIG;;WXyGUARDqToKInmE>Sc;EFIoTtkSD?S<USuaTpGG^ChUGu`gYAyWDwWiivDuED_HR?Tv]BtIeTmB[OTJ=c[Mtp]TfYFXWEZotbGvbUX[OhnWbQkUvEBxgTY[hHeHfmXUyrxIUjOiYmUXmbAwTISW:kiFkgbMVUWcgae@uGhwCP;xy[trEcOYCAgVVaTgGHhig[MhU=xOYtYErxUSMkyQytyyE>SHUOvcwxTWiJiVfADomU[;DxgDUWr`mGZkytofWec`MuxQRjQcbgymoeM;en]c\\AieAD;GYHsd<utjOdWurgAyF[ETUEtaSWAsiaD^Ox@aflKtpyf[UTU=cJKHLMcseGpUB?ie\\?bssgterp]slmXS=Buyh@oY=oxwCS:se;ibjYUjyvq?T]?SZeGuOchSRQcwIab\\qGccyPoXFKEACXYWwf?yuyIVay;[DgOSCIRjacRmW^UriWuQ]w]suLGRiqwJ[eayBjUvYyGZmW_mDO]TxktIIbmEGVcCqKFZyEIkse=XLqhK_rxaBRMIyChmMy<IXycEherJYyS;wwIxCEEVeIoqvYlLwHX]`ThaQqPXXTUsAKX`wy=K;aYRTwSiOvdQrAQHPQAAlftnktlRmRn@m:Pj:HmeeweTQO]Mp]kBeYvtQrPoa=rVYOdeyUXxYiRr@M=IMIIS\\<ktPVOpYr\\nPYrNdLfeL<@y\\uwM<wmlhBpxo`mSW\\EqrhHp]ndHOdnGp>X^pYrLGp=qpGwlxXkpyoa>nYWrEqyQhboxmpguaVyexbVVq<>m_N^H`_??\\qYqYNbhpl=QdpGd\\h\\p@lNf_DOap?\\eijO_cJFkrfkh^w_NejgvOX]RQksIt^?u=Hs`ObEyrJgs=i_E?q=awjAxjWf@Oy;AVoFqyw\\]srWhxcX]]u]odHYYAsuFagjYytQyTsTvqERSwniRTUyuwXjASc=EWoSi[UtSGpSH;[irOyPCCviYr[Xp[cTUyC;GoOHkMgUAt;oCwWC_ieDkiq_xlkV\\YsraUIiyjOWFQHCKcwgXH_vryfbEHHsfHIbkSujkDMWGB?DjYWOOUR[doUSbQWrqDVQUacEMIGWeGwoBI_gVeDd[RjcEYgrG?ugKcPkc;YfiAdlYSXMXJGBWQglGSB?SxmB:;BB;RLCTJ@SZLUDHrfPP]LTDTnghpW=rvhj:qmCdVtlYU=k[]rvlNUYP[\\oaytJtOAeRkYxIqMWuLVLWaLkueJbTuO=XiuX]UwD]Ji\\qnQNddtD\\swpJbatYdW]pOhLWB]NLLJheK:yoIlqX\\OLtrAyrUDSUyKR<xy\\xc]WVllghogHkittRhPqIxHtqiULxyWVUrK`lEMXg\\u;Lx[quM]Jjp[wxvyycvyqQpq@x^Av]?Xs\\ibc@mPfZwXpuXZwPd]nhHAq]?b:ox@_h@`\\qq\\@`_wOdLGsoowQWbM?cNO`r?uuodtawjhnm`mTAro@sg>ioo]>YcC?mOq^F@u@fn>Pl;amUA^nYmt?fOWmkaudYk>^sg?[KP\\a?vmXogOb@Vyuicjy\\waxv?[YowyOcvayO`xdnfMWpJqvw?]lf[]feCWfiH[NffFFnnXe^@c=^\\S^hE>xAN[;^iagxY>ndgnmypHOkW_r^?pEwwgHm<>lWQvpnrdvrKoypWaxXh_ibVNygHbV`ivA]NigYfkYpia`vjHtb^wAYjQn_a_ob?\\Zy^FQt[IrOOav@jDV_RpZZyivWvpQvFn_wixmAij`a:VkwXZohul`xBIvXqxpVnE`liH]yNey`kfg^AHbMw^nN[O^d^PjUAcCxs@ydjPllIvKqum>woFi_ofgvprneEQy?^aMfvnNl>NqMnkK>_CGimgnGPkBNjEq`SguyPwuW\\qNrqH`^g^<AddAtH_j:ye`od`aaUqhxFq>VkDQbKXr]?_fw\\k@lTO^lA^<@vLNc<YrUGpUAwqvxCGwaq_wpjqhf_xss?jUanfy_@p_\\Otx_ZHfk=O^HFc<vwiWbWqoO`jhonT`nBQnMnyvqZdXiO?wNpZb?[JylLY[Baga@`[qa<VbuH]d@m;VwQwpjVpnfkpWem^oHW[KOtAXojFqPameosUN[yqougxpigSh]hfu;W]]Yl_GwBW_TAc>oyoFmFgkepyk^kGvu@nlxqw<^deg`^pxrgcRiaLWutGZeooUxmH`_Bwl:x^tqs\\yaXWyA_fdFi<fbGNubY`]W_`Gm:qi>qaZVpiG]FIu`Hw`?vaNbrgh]Q^XGurWkNyyj`^cGuAy\\ZvnAVupFyTGZ?iwLn]hIqYFslO[mIk?GyQXcmfwTV_`W\\E>sOQx>o\\]Otf`sdpp<iomG\\jy\\B@g`Ihs>yp@evvjfY\\n_wd``kWvPh[F?_F>xxaqY@rUWcKWbS@c\\FZMPt>wv_H\\e>^MWs\\o_sfkCNdpYfPYb>_dd_ZDXejyvv?siwvbywc^xUvj>gsmQldfwDq`RXmf?uUgd\\iwEvwZoaxfjHqaI^pTx[Iqv[a]Qviy>ulag:niw_sHqsD>uqNel`ijAjyY[Ey\\X@\\koyvIikHghayHqiUYyGnct@h?NZeFm@AyR>rxWsAhnyai;vkga[[ymWViVnfWp]qNjm>imWxt`d[aneF]fgv<AwkVqkatryvB>hG?i`Gv_Fdgy\\wytkywhfiWNe<vthWdA@_aii\\oZ`FjwpnwNk<^tjHgFAit?ymOdqwy]hxqffPo_Qavm_hJ`o`hZJyjgWZRn^owiYwvk_]pgcBWi?XeKIgvwfcIekQyIVaa^n;W]ePhh@w[aV]swCGuIgDII`?X]KYESyGYyL_sgmWgMf]ywZmFkcC=cR;sUSKyaAIhQIhcwBwGAwG\\EHosGuQx_ytbKrjKrdghEgt]]fBAvbWv>cRccyRMSGIFEuvaatt_b^?ejAIXAuiuuAGr^WrX=gSChywu;yXyavO[ilaue_RpcfIcvmIvd]Dhsrf=bweYjebHsc@etLiIZEwjwsBABIyHcstHSXeQteytiWSggIqair\\RWXmUXlCXLVqMSHuTXRnToOQOWPMUTv]XM_PU?tpyhy@lR<LQRiOp<XYHsHTjMlMMDObQUCtOftU:irGYmrTvW`RYHueTOrDpQuyYunY]RbtM=ane=M]]nfYxnhoytL\\<xNIkdxvper?LTgyT<xpJiVnAv^xVL@ZW?[^o^p@jNFjyW]?o[m`xmwj;ikxWcI@_poogx`e`cbI`oGcSav_ioePhvFgMAbInomxfEnnsHoSVocih;VyaVyxv[Efb<Fj<?\\eaxVVjmHcgor@oh=_gYXrHXrLfcb>wV`mTv^?o[dN^W@[XA[vpk^G_CXytnsDIyDoa\\wgA_lyHc[o^\\AdCghJxayHcywg]XxJIs^p_XVccIenP_TIh<iiynx=P[fxeXQr\\dAUgSWEKIXY=gIkWdwyNatN_ggCVaiXbUE=MsNEY[qEhiyNAWoCxkSUt[eZMv?CCrMH>sTQ;x^EDpOWRyfaqUZ[IrmdgsHaQvLQGHSs@sBAcvEmrFiub_tsAw@MiLWrEsUyqCtmdTGHNIH^cthchwOYYUYp_Vrogx;eEGdditL;yQGdcoDbyVWkcp]cC;UyydUyIJ;bxyIHqyqAwm_X[cTHAVtkhFOF;wI=oyf]YC?C:US>?Hb;vYaRZcwJQUKIfqMSNAxWGiaITVqGMOYYcDJkWgeWKobb]WqAhIui>MsxqIiISkOXPSdEQT\\GsPWCQytmargGi>aerqxVQC;GBUIgo=CHqbB;yi]RhMrQWx]adaaDguWhwF;gFY;hAScDQGAYxaqHcyWP[vdEUCYTR[d@CFLkSGOh_WddoFk]tsMC_iiL_yXGvS=rNcCNoXD[RhSURkHIWbgYY?OhGkrPUEDUSu=UvuVOSEsgVbeUd;EoqbyqhqqyiCHrKT`ywNgs`UWVahbwFfEyT_HDMHiIB:yv;qxGIimuv>egmahamGs_VOyYA;xsmRgsHEUvASgPkUWSc=iT`;CXgYUASVqYrYFO]s\\qvmsvK=YgeloPOD\\JdMUOpj:pqhYsimn==qWLU<IoHIKv<uu]MdejLTmSALPLLU\\nBiw>LuH>cAFx\\QtU`n<Xgr_hZa`VQiuF_eWZ\\inFnquviHFt\\Foaqo]OntyxpYw^Orpw[UA`kQdDncWh]Wo^IFolw]pVh;_dqOgnQi<vgDfti`Zh?sIiq`qgSqugxhCFgfhfv?_KyqeFsO_[TwZ^GpMPiYgyWFZgWqHIZ]F:UItcFCWVxmcj[UfUEPmy\\?DqUsROcIEVVqXBsbVWd>mVsEByaF?UBteb;MxDSxCGE\\;dHKToQUR]tpKBtUdRYIUCiO[uFgU?AeoMDhcWwgBn?MT=OlDtL<NQLUjqrIpOZUxP=KcQVDlNIpKTyUk`kMXwGIqOeX=<xeYjuaQkQwt]OHTMREXI<JxtSNDV?tsq<OUaPVywXhQBymO@l_As:hWYlu@UyXhlAPM]YjWTwUTwrpxItoZ=XMEkAXyHXRcpTD<rilrw=ogqWE<kgtrwAMk]xZXrbAN:hO=uRDeqMavL<xwyoMuvB\\n=@yYqsvYOfhNwAyAXuIISEajMiuA]Nl<vdlm`qnP<YGmWf]nvAkPLLJYT^=rIlTSyp<Yp<Lla`QA=vk<q?Enmhl<iPsYmcAJ`QnE\\Jtiwrltk=SLxoF]LVYYAiomMs>loQtTXENlIxM]TKYN:`uLQtfdVP`uYyjg<mS@yfljfXRrDwsDNOHReIooMJoQJ;ppXMUotO^lv_hx=uqsxUf]Mupr[DT:tlhmJlYUrhLwHRK@kETj`IVCiRj]r]PnBQr]xw<QWtEkBQOdlLItyGAS>=r`qQatpEYY_]o`yvJYWRljaPQ>tyOaN`yvaATfeS=qwoPSNLxEeYX]xw@viaR=QtcxKpXXRTTTlxiiQ<<yfYumQn>\\u]qmy<MpIuxIodYMhMn@YpuDy`pWfHTsIvFPOi`onPp<hxiuU<IkfXJWpLqlpUPwOAQwpTI\\tgQSVAuTxrqqVXur^xVRTjpMkHQo?DWc=tNau^<nfetR`rtHVO\\U_<NxLvXdrn=YCtQV]Y=dyppOkytMevVlspuMAAjoXSvxxrEOGhnrQMD]n>YJSAoJPs[txB@Ur\\UOUrOAQhUj=lKL]yVQn[QYbMkNxYa`t^YP;=pGQtfdXkYyBtv<AtJ<wY`xXtLJykOPvLmtCIL\\TL=xQuHOKtRYhnYmU]utt\\rdHKPLRBtL\\<SJqxvDRe=stLNiIjotQ=tPYXjEuw[xqAAPEMwYHk^hm\\\\J@LX`tO`\\MymW=ml^]Y:Yyr@L:qTXyR>PLaLLl<SnApPpU^Ew<pYeAOTXuUHkBasRyKdDpvqX:tPieu:epg@KUDKZluAUUUUOxmMYxmmMVF<yvtT_HnjYw=XSrHymqVu@qklw;<raepHyMBtQxmuxdtVHXaUOBmNNaPN`sAlQ<EtBDotylJdYhqNTPT_=MGlRb]tdExcIqleNE=rx`LUaRIho=tURdqYlXWHm:`YStp]Ts>LYG=Td\\lRxkgXL:qnj]om]K=\\JhqVGHL=]L?\\uYYXVToChSvIuUxYEUyCYvqpkvEKtepHMSgdTDdPvpVQ`srhkOTLjEMV@SNXTBlv\\PTyxs>@n\\Ln[QmwYW;Xu<]JaUqIMS\\tlMTqqPRMQRDLopeJ`XNmMLc]krtj?\\vgPUe`SXQVouQMdm=YPmuuM`UJIPIIP;<xteRIqPK\\jHlRoHlHHM>Hj\\DL?DJsQWteRLlqdMQylYj<wIeRiMSN<Xyxx[LkfMq^LURPNoxsP<liTq`dTtTrpHKsxROewTDpt]ONdMjIXXxUsqlRmQwlv;MQpPUliLUiSoDpiTUqMukPqrpk`hJElLYhK]ioQyO\\dpMDjSIW>PyY@w;yssqOhalCiu^UMKxWw=XMaPHMVqLSltwK<ryiV@TL=TYwaU;YrxlY]MqnyJqlVamVj@xgyPk=Oi]rCpsKMJ\\hU<<so\\RlHKRdPtETiytvYxj@WG<MpmxBxjHiS?au@TQfLQ=lv]Twrqtgxl?<UIqxOYuVTplqWieWOhwrDXeIPsDTdhlkiySxT>\\xI`XHXSWpQymkkPVLlqn=lBMnAdQPpSLMtHPYEXvrQoNPWlUk>tY`<KqHtCtNwikeDVrmTfpS_hjG@Jw<mI@vsiZ>YkY`wr^^wgwsi`fpqSYr_Q`FAdx^cdouhfeuficwMEItKySWU`;HRwg`sT>qsS[hHKcdyvDwe:msIgGD?GrsiJ[nLDxGDu@]RGYxwAs>AvJIqjTMuhkcAuG=YF\\RlMWe`qalJsmQxtwmUlBArfpp]]rp=m\\\\koDo:LvaIqdxj?]yDmXPLYOHKHenQdSu`Lk\\Nn<Us`L<QvvQJT`kNdPs`SNdWvaxLTRhuyEqMxtXOhWnMsfxTbApAxsRDtjMJxDr:xYAqt[IK`tXdTYTTvQuMEYXE@Swuy@lkhYQZuPSHpGhUrdkpLTWqSkpQhdoWQrItViLVBIu?XLwuj^hS<ekXTQuYY\\@WsmPg]oJpN_po^dlfXrTMVElKwhjNEpDdOnIMsQTV`uW=rSpu]=y\\Aw==qxhPExvauUMHkSmKWhlBIn?TP[iNkyywlNqLSudL;DRUdygXj:lmUlowuXdiJkXk`LQ@hRgywCeqJqmN]wjeqwMoNHLJxv^]w`MYEdSgdSNdUNiqmmkHmlC@Qr`jnqqhYtnxSqduudW>LyU`R\\lYcynM`OadncMurXXV=SepRiYmalUs`xhEU`ExgioEaLw`s[AlmAPFMmtaSWmmWgo^n_GfsMFjWnhW@b?@cdg_o`_PvlXgfN>lHh\\=abTVmR>pFPcX>rD_f<aZ]YshPnDWumavgPsHG[wovKFm]>pQac>GodwjSgv:qeRgjEvatW]MY]qFvjQe[G`UouQ>xUfoKx[\\ftJ?ctAwjW^spbWnya>\\jI]^IqvVxHQyN`sXiklWoInfVOiaQ`XWyIvyBXtTp]rPatffcI\\hyc=q]tpbcp\\jvuBoj>q_[yv=HwbF_pqfbGwi_[jayVivGXu>NqgAi\\_vF@oroZeIyBQ];hem`cHPmEvoZxtdinbAr^>fw_rmnb^NhWv\\Pqo;IfjHvT?fTVinxmuAkJ>qCHew`wlpc`^uTn^TxcZ_rs>ZIFZoQbnGefh^Xhoe@nmOv_Q\\i_Za@dbp\\kAs:YZ\\WxjPqXGcfHfEP^<nuhFdDW^VXkZAhAajbPhppkRqwkHwfQbPvwfoq]vkkvtr`_^os>FryIcWoagyqvhePhdjp[uxkZ^eBV>UB\\UyjCFjCFXqCYAdXey=ktKKuiGS\\GCYmVGCx\\]SDUIqOheaRVcejCdlyvCCVGesg_RFmDR]Hp]BEkYvOixaGVQyhMYrevvAIa=rAqREqITYuC?HLGH^ydqIvUGC]_gFUfewsgCsaqBZyynIrEwFWIW^stJcbY?R:yV@qY]icq[fdwbEQHsyx=ubHcHPSRsiD@SbDasgWuByeUORYUhSSsSADLEyn_TCAWB?SUiDD[FBehyWvUgrJWNXtMwdS:DW<]qJHNjtu:]OYPL?hqJduZxtbEP[IMJLlZar^hTamLZQqvpYEtsHeq@pOeuJH`XHPKK<Xq`SupuDHJuuKXEUrUKMIn?]Qw=wkMJnqYsIqHlrtDmwUsytqgYqCdOKpsKqsCLT@qVKey;aWR]oXhqwhY\\TjrDjwEJ]qwKEpI=mb<qfYlguM@dsqhYQEKFyo\\]tsLJqDL@TObmYXXOi=ulHV<QsNMP>lx]]L_<Lk\\v=MthEjY\\KpISDpOPTLE=wo`x[XuVYJmPu\\dLDUOkiRKmxuxJgyMte_>gpm_h:iupfgtv\\wvqGxdPom]@k_`jCqkMgx`Wgl@pt`x@f\\eF_SOk=IngA\\L@[^w`^Fkf`gOAcEofcPcEa_[wo?P^Uvtc^`ahpR?qnHjOho??mwPeRH_TVvkXpmXkOitOGZvqjAx[KfjVafkHpHhwa^\\jIqQQaaFgAob@?hrAx[GyjFy=`vlos@Ay_IrxVy\\icVPtoWnAYu=OwSQkJo`HHuZQobpd@ns?@pIng=FjmXreftu^q`fgqFjqVeufJErykUwEDkORDSdXIV<CUw_SjKuXius;T@iw\\_rgMIE?bZqVt;C_Cgu<OF\\yvxMp@UXUUtUM_MuQyWWtYDlNgHj:`XMDL<DXxltPDJutNptjC`KrtM:iSTAupHxTHSgTTn@XcUvDluTUYUTL>lxWpLI@yeaWuAx=xV:QxvEjbmQ@=vial^POyaoO=W_DJEiMnTXOaM`UNmAwjDYB<TAinxtm;IY_Dp<uYEYSlPY]dp@TqPISKXjAMXD\\KTqTLmvVAQGHs[<loYL[lkKIpnyJwIYpuK`]wddVxDJYTr\\pXZLUBDT^Pq=wqspmuOnyhZloa^W_c^]cAqIpk[q\\<A[J_`Jp_a>wVfhLf[>XxU@wpftehjT_\\GAtq@eK@miHvPipS^geXxjphR>dcvlKpc__n`amenuxVw=h]:nq@amMAgFDB;yVkdkOXsWXmShAwsCGe@EsOyGqkTaqDKGYcqBHGWv;Tb]d>kvOCWc[u_eX;AfmKVC?bxYEiuiBMSVabAobIOCJOhTqVL;V_MsyyEGiFKYWeHtHpQf`rpDLDar?YpaaNdTjoitGIMLMy`\\Ql\\XLlX=hJ_MQ@aYreLCMkT<YUlpc]KTTjbpxiaurEj:hOHxYk]yE@wadvIinSxuYPY?TWkuMHxXI=r^HPOiyt=Xy`ythtMXO_irytQXiX>@JlTNPlK=DqXEoO`jdtRUTT[HMRhP`]uYyX@]oWlOYdVitqRUODPqYmkiHsV@jxUWwAmF]SVet]mTUHlahWIiOv@Opms[tx[<OB`opevwXLZXXNLnpDkbAUG]OEDLNLWsDUyqlOUQa<qs`ommQtdjKur[]KSyr^LMBtL<<kQTNLiYMHkfeOw`jXTt:LuUQweTWSxKdLYd]mZpshPvt=x<\\q@pQn=MuMwwujJups]xneuTUP@]qvmw_EmGMqK<U=uVYXMweQwikUXy:EvmlVjMtpHPxDj:xyXIrppKquJ^mJi]jfuqRAqrEyLlusYqiIvFHoQlND@lRQjSYQjaksMXLel:Pla=uH@quMw_mk;iPkYpGMUW\\TDen:DwOuuf@j]IxXHPrHOl<pM]LJpN:lmEdoC<o`MO?<UB@Qt`OhEWE@rpdJuexpMN:PNcHyQlVYArn=WCtkIpm;YV]tV[yS?@xwYUiD[_as:Ihtni@ole^]lox;ymHV^K?cDG[aVyoaiHGvV_\\mFn?_ktxZJYfoQrbh`\\wgyw]EIpOOZyaoRobEGpOFdKYrHIb;fg`F^upuh>ZIi_UneS?iOppGWvbxxb`lMPhwqyhIj<wfoqeWIoByswnlX^g_op>`^ripV@v_glIiYgx^QG?uDMOBxIHXebeSvMODImgvIUIegBwYiqHpMstSi@MFKSdTGci_bJsSVQCwWBAog=cuPGBtuuUQRa]E[tWXxmaaRimoL`lDmmdqW?MosMUUMu_UQ`\\pVqW<`lweKt`RilvhhoZ<lTej]XkhHpWqR;\\tauxuDrgIUrxQQtSrPWfdWrIO;\\YhHX`yKOXuj\\PDUPymqKmuhPVhMWTDoQxW:qqWqjoaSNDlFMR:YrbHt:EnNUVoLqCXOeUXbYXr=XdxWVlKwHUBAVsLpCMsvTOOtKEHvGESPqSn]KBxLWEuSqlpTKhUlGdm`uJ`Ure=yHitQHX^XWRpmmxM^<jqmKdHYNaJ\\eJ;LtHUlM@jx\\O:lxBAxw=UZdxyiuUtOCeuuXsburCpwCMuYXSLdqCMN:HyjQkNmsjqxUDsgLNMtk:TYkun^dsLAQL=pJYjeQyYMmyeM[aW>tnuuk=UnNAVuArmxvCLS`eMcxXttJH@UVqb>Ph[GySxfaQhcF_MXdd`m<Qb^o]A_qAAtggwO>lIff=?uFWy^gwUgmDwjO@yL^tlVpRY_xwqWwvNPqua`KFrUqqq@\\e^rjOouqi;^gxvgxnZQ_wr`[W`pyAawxjtF^jij[Ic\\_eo^pq?p>X^IQtGwlL>aSixBfbqn`>OhU?[^q`^ayGPge`qQhl>a[VqvhOq@gqlPsP?gsfZYix^F\\K_Zpw_IymragtGyV_u;qlHvtZy`DO`yf^:xsGHlrFjEa_XA_uPyaxbkPd@irYnqFPu_hZv>wT^r:whiFZApZkOdlYwkAZLFyFn`MFf<ntvnwU>a>?bbG^ZaoQpbTi[`_[rfqL`nwQyUxaZ>rhNlDvaFf]K`ZIqZOffF?^VQc^^mhvvKx_QFxjAsC^g_Xn>Nqk?mopZbIgUQuHq[hvoWQ^opm<iy=xrj^vhYlQao@y`?`ZHxhYNnBIfTvggfq=xj@xc]_um^jvFodo[Gie@VafPaEntMnivVhmiZCO\\IxhFVkYx_Of_AnhMVjuvxTIcQPt>^l@GcbQxsN]onbkArSQgC`v\\?x_p`jFwW`nBNfB_Z=Qivg];acJ@kFg^X_yvFjwVuB_wwYhxVbg@t:ifdAoQ_uJPuywfwQl>OaaNqIGskIili\\IVn@a_aa\\HiZcQyT?l[@[\\Hc`Q[Rv[nvxxNdO`ZKHZKHdQYr>OdH?yLY_Bvv=>gcOg`@c;Q^gO^PPfMabXoccXuiG\\lVhKIye>wmQ[L>nAAk^p`Z_dSGvLyhEgdOOoTV^K^t@vgUI^f_uFHv_ytII^=wsSiuP?govmg>vaIit^u[wlmI]GP_xxcC>vmhk=AjIidt^ukWpknuy_vEi^VQisaaVYgS^]qgxZHowhl:yp@f];niiwbQNqFqhVGeWxrEW`iAnAqw<wkMi_:_qy?vOY`Lgvef^>IkNNiVf]bQptH`YNeQ>vaI[SOc?PbBw`NHk[OuyPb^At?HZQwlFAlGNtmWe^PvS^jS@er`smAeIAq:x_A_]V`ngIpqO[[__Ao`JX^<A[^X^RPuT?ngq^Za^ZxvmSCcRxeWrSE=uggWSfie?Asdce=mU:meuoWlUE<?V`KRK?rlkETKIEGtHGDssXYMcNIH;GIIQg_=rYGCl]BMYGKABUeIvCCEYVpAS^SvIuWKCwVeDUmvruxCCS<USLkXiuThwb?UWOSy?ydlIts;EJmgO_ftobwUYhcvfCtiYcKIY\\Kdk[cuoC]?hWwrPmdBcc:wU]_tC]fj?DWGdCGUHSRA_RNcxdmewKFCgG^YgS]RlYULeENiWWKFLSgQEBkIhoMS]cRnkErYHe;eCsU;wrRYG^OtLau`KgxUYyoBAciIgYtstggXDouhmTkOirGb`eUOkXIgTdoYxSC=wTwQvoygseEUqrraDSMIVYG=Wi=KXIme@AYYchMMG\\auqoiEsyewdkCvhqbPAVbwtpWHcMDriTdeD<Cwo[hMCCvcX\\IRfYDjaUWUea;FgCrdwHJOvNIFPWS]QxdaD;kdDsVAsC]Wt\\AbKUga;FIGVk[h[SydkTE=UEgBjKvcIb=aV?EhPmDJmwowXDgdkasowTJks>IXBYI^Sy^YdZQUumgbIVu;WauXQMX:sFuqF?qxssIyEepyhCwb@uSMIhFKVEcs>kD^UYpAyS?CrCRUsG^ChP?xCecvsT`AyMER\\[FiCgmUBd[xVsFfEiFWdOyyD]YOsgi[iCSe;qbkockCIxSRcseYseIshm=v]aGlUTpKTMidWOcbKYX=b?wyHYGteVDGSf]Fq;XlwvnKYfeY>=R;ExliS\\_wO_D;_gJCSnSfEQtUuwc[fmWs^YGPMyKaYBSgCgRk_b@euMOT;WFPuDgyt\\GhKCer;hSoU?ixgWC\\?wSywiUv@MWGeXLIuiMveiT_ws`Sb;Sy[CUm=FNgxK]BNqSuyS:ugnStsOWkOeVObAqtEoUEaBlIbw[ut?ibSwC=wfiwj=IsgECyfUyuaQEvmBvmWmCtRsxb;vmarKkwAKrO=IfousCGEQCXwFK_iqMv>sx=yiMQSSwUMAGwOycYVe;mexuxIJtQPu@wmHQkTMpYVwlLLdXgmNZyOOUOruVoEJ>xPrDPjLRZTVZ<PnLrF=VXls`DpStkZ<RZpwE]jkDuw<k;Mk@LSoPonTR]IsRemptJfLYMdw]MMIqUytkhUqUTRWdQlTpP=rN@RVHrnUOOdRYDJyaRQANWtYEDrn]SLtoVYnAhTutR:Tp;iLFhXH<L[\\K]AUiaj>]JIyuveLUDXylSpyS\\LmEXNMMs[AXQAUw`QmuYAMOw]U`tnVXrd]WWtQvhx]LQyUO@YQAmK:WZ^gkNxiu`aYFs>abb>hl>aSOcCGkbPl:amM^mVVsjWa_oppo[oo]@AaKNZa^hqVlUPlM>fIqmgxmSAtfF_mw^fOiu`uapc=XedXgpN\\eabbGZcxsYvxFoqUyoYO]ZH\\ZVqGoekqxaXjqFccx]F?]ewoi^tlXpYwsE?xBQtkVyfW^loexOZyQ]gycCWukPvaYxVWcPYaro[Ry^ZhdT^vrFjFQ_KHc:ng=w_WXgX?k>igbIrHnp?QtJw`S?lSwuAaxoh^f`j`AfjX_[G`yOiU^okai>ng>Aub@tsxj;vmQWp\\ivHFilf\\QAuypxTYgBpb]PZvauevma?ulac<o^;ngD`ryv_hn_Dhl:Y_Ta`@ykAV_hirOhffxmuWZAoxo>wqGiZWpRHvk@pwNbZa\\EVv`qr\\nogh_BhI;um;IP=C^EuIwte_HRcxnUF<MsxYYQusECvtGwooJgDjsUk:@QQmxj<x>YXcnsu>aTy`TwxXXbxFkZ>udHgewg=ixoIeNHgyx^tqr_PgAXlr`euwqJ^e?opL?bl@l[NhC?tkQy^ywVGt=ajnOpiA`<`bNvv`puZ@_\\gdDOauiew`Zjq[swjf@iSGbm>jmghHOqNh^lHwitvAsT?dHGUUuWe?r__eeEhGCWYay:AxwAXRcELexmOEWUfBaf:]b[EbL?Cfqx`iWbECRYIGieL?s`=TaQTFAY[kcg_hYST;Wu\\UvFOY@arywvDOE@KWEos@uOPtlPmsMDjcinTtjeHYR@LrUMxpSVEvMLshEvRuxw]pwhLx`vTLvsAk^LWSyuaYxXMkFAsiiYHHTkPWReuAQk[\\rbLPZariEWa@S>@l>uko=ULXqvIQeaT`LNJTLgYYG@K\\EmNyYDTRHYnLIrmUU`DjgInchoCLUopMuEyp]qsQw?]oHeJ;dNKPRIhTpYycPqqIwX=vldT@\\YHMuplrwLKramSuvh<mvDpDhLvtTZAx\\iJvdQtMXlMT:xmQXQ^etBiuiAQVUvC@UqMSmTMMyneYn@=nuExoYxB]qxEMa^ujPtoPvlVcp`crhsjxr?Yko_p[QxlamRI]oqxBN[<VhGge]o`Oy]mGjGFploqr_xfNqfqcFyZq>pO@kLPufwlo`gS>n`p`Q?pLFx]_sUybInZ]Wmvvq:WutYdKFxwIilpt>wdwPlDHjYXu`>hIp]IhrC?rfYrmw`Xw\\uinQIT]Xa?d=Yx^QWwQWoIH:;BB;RLCTJ\\wAyMgIMAipOIOVuuRHrjXqIlKTyYZdL<pU]XLutj;IlwiyeToq<K>iwNdMFHLBYm_MpMqRVyjBmP@MWVqk^ElNPY\\UKMdm]hxoqUcywvhq;@rUxVPw^wabdVcL`gW@xH?cgXyp`xCNu_>jQYrgoxZ>bUajmHfkXmR`[r`wlhvZH^Vvb@F\\tYuRwr[?uCgyih^P_fpo_e`hpiwsAiEItsGplOagfunamP?ZwWiApwsakY?s]vc>HdbpvJYfUNleysQAbe@t=qoqGcIomo`r\\noh_mAwl_?ZHfianhC>sS@fS>ysOjSvs=>xapl?qd\\QhSoZvgfuPqXQ^<XiM?tmGjvQ^fpZI^_uVZRPqvpjOhk?^peqx[qwjwidowyorAnoJIfUxpkF_mq]@^iPOwfIsmQwPsdgdhIck?er]xf?viagxer:usEiElYxfuyjybEAbIygsagIOVgobewvYArnYhy[bxOhe;Vigtb_fe_FeGR@[ybMIC=RwocAmrI?v;KYNSg_]srIUgmV_osXuRDAW[;w=QYf;cKqsX;YfoCsme]WbVEiBGY\\KbrmG=ghb=TfQcmSrAgRsYxx=Ik?WPIEB?FVQfxwUsgYScYHqSn=DrwuSErIGRDWXA[ejivdmemWFAISOUgCeUi;FSwSCeIvsvD;i`mi>MgXgtxQW^UDE_DK[YhAt=KTk[XEyHAOCwiceKWhMy`=fMUwj;S>?rgSE^MvNos<SgXQSUaTkeXwqF`mh`abF[e`uf:WwW_FfSU<mWmWeBAriCcVmBqmBQmS<SSI[Y`uEtsw:MGbCsWybAuE_KL^XWmpNOdQvhkC@K`llEHSlpXrXVFpuEHRPTRIIL:xW_`YlxkVEQetqqIQAhrPHvLdSHmtT]XpEOs`xatTkqtlYO>lwhMNGqScYoIILNtNfEmv@qluNUMSDeLH`v_MocEsg\\pEMnrHS\\<k?@sGLNKTMhyMrQPWuj<DjyQLWyKS=oTixlTVqlTRQnbAN?tksxMDdl<LmPUL\\USUAqsEYXDmD=MXqYA`RstmnIr<IlmiLfaLn<P[qM@\\YpHXr`tLxL:EVYmmmdwf`xI]mrDNxlyWpusywweKqat[QOWxsteqgmnR=rOxVYxj`eWEtma<NieTd<KByt?\\m_Xj_dUY`X[tjeYWE=woEq[ips\\rDDXThOL`mGhVm<UBdW\\QtLaPDaxs\\Qp=yrDo;ULcpsl`NPDY<mlQ@jvXrdur_hjc\\UWem=unGIKMDowmkJLwEtmfQSeMVHpN\\Du^LqgiM\\eprQv[<OB`mOQShDYNENMMsMYwaHtgAxZxuOiRuAPBarg`WstkOAx``l\\mrmIW>TtKLN`XyBeyqEvuxTHILSaoZIs]uk\\ASIAMpTl[\\ySYxyIKayViDvqmMtik=pquTuATS^lwBmW:hYiio^ql^dPSqub`tdPRH\\o^ivxIngut]YM\\pYYdMu]T:puQ@xKIp]QTDDsmHUmdN\\tpRQOtim=\\XxQMKewVdPjDW>LT;LyuMU:@qEqt]lYtTjsTZUpmMVu`O^@ifV_etg]hVfANaFielVqPHrVx^rGxoyg]xt`?[Fiu@w_N_pyAbdWbfO^O`bjN[sxwqPdea\\cflk_nea_K`jMOwmYjShhS@]`xdUHwmQ_\\G`vWZ=nk=Oxqg`;`aUaa?Pg@Fk\\?k\\xjnfyUnbaHiRpy`XneGdOxsCWb>xtTW`\\Gy@_\\QpoXx\\UxrUiukY\\GGuxFhKn_WYqfIvmayVpbspxwnojiuhwpvYsCp^XgZEhluysTH_Aa[HAJtyftNbMNKAOh]yjaMtQKO]SneX]hpghLpTnC`tehJ[aKUIMK]OriYR=KrIXv=VB=JYxLUtuMpepGcOPoJywpA^FOwyG`byjPgoLVc;HZTX\\ehhZvgPVk`OsqP[AHtFx_W@qY`digcfp]PWwTNuAvx>ysOXcr`qvf^dwyjwxJ@owQkfwpH`\\Kn;EwEwB[AHS]b:=yiexxWIgMVmAicKfR=CfOv_Igq?wqMiA[wX[crMy_wFHyxioi>gcRwEAQyICv_YuiMvA[xumgV=D<AHb]xj;WoixXcxnAsPOX^_waIHfIE>Is;Wv\\Ey?Kt;MBIAdnyrk;WGKVIcfDCGnIitaFT=VegbwiYhQiCQCx;SUygAutBEeqYr_mvmeGC]V:YyqSWg_RBoXtuUm?UDsGZwtXyF^=rDoUTKoqyspXLqdX]=V_yq?Xp;DJjmJpmJOQQRXybUmvlNttkM]X^uLjxk^upJ`O@yK`dVgIVedqHtpcxRB=RDURomKttT=`T`armINVQuvUT\\TlCqouijRAQi=rEuQTeXVmUe`rgioq@kNMV><y=]RvPWslwhIRM@KhErFiywml`aYRaqWxRFpoCXrEutMuyCam[Psh@JQEwnlN^mu]AjyuVnDSBPuftkYxrQxV:yVIPxmPuMuvtiwUAQyyUxHkMMYMLYuPqdIlLDjLTofmTXiQWlM^Mxs\\qkTYE=r<eo^QwRdNcxT@LxtekwtxGxqoHpdDKWyYxmv[MJqTO<Hs>ll<mYkhRrxQxtlolUWEmAUPgUQXiuadPvqS<dW=pSA@JKLs`]O>@TtlkoAU:@JnXlpHMJ`vhtN;hW>=LfeK_XkS]QmEyO\\LddVFmxH@kDtuu<wIXrdul;`lM@q_MT\\yxI`MQxv`mpPhVExJ@qSK<uhIvAxtYUnqQXStWHiqwqwwQtiQwKPtGuYv<R^en?pS]hrguuF`yViwballaSwPSIToKqNiIQVHkZQxLiLLMsS\\mR<Q[<rFYle@UoUXetVqHu_lXIioGXmBYLrYXsEOUiMq=JQHKDXLMiTtpPV`xgQpoULcPxVLjV@jstTZAXxEV=PN=`Y_tj]hQa@O<HXCevK=NoHkNEPCutIANsPjGarddR<eXoLs>EnQUMC<oWPRfTUchPVaxWmnBPr=UuFLk\\xleir>DS>LV]<RaQwVhxramnqvk=Mu@wVdp\\UmCaq;LQAiQS]pwuKWmtK\\rEDR^YsC]peLwKySwxvyelBdV;dmnmKpes:lt`XvrHYwMK?G_rWyWxmr`nhVu<au]WoKOlsI[;^yY_hjVmmYjUAnxol@q_wnoV_qB@rUw\\ZPs`IleHpahuHfmPW^Dnp?OqkNZmnqoNdhI_vQuCYdrnbdqa<OkyolNqa=PoOAg^fxc`rnfg=qtIIlxIbciqHi^Mp]UheBv`RPk[qvTQ\\hhoFIfBYv?Is[Hd;N[X``?QsYXlxhyhwo:FtEvtiNko`vkPuC^gOQdKY^ZAcaYrCYubo^;paX@w_AxJ_^kp_Pq[QYxm>blIh=FsbFlFqjRaaXwbA^stWnRIdU`Z^IpVO\\hOk:nuRhiUF`TysWHrpN[=nYsEtiXSgguoDXAruSSQISwUek=ga]UBUVqAfoWBImFmUeWOHa=FLocDgiMMfYgfvSdwYw`[iU?v^QgXSEc;yMYRqIcAsiLkUKwtkEY`SD>svEkd<UcLEXMYwV;d>CWd?dZ;RqYCBMh<oxasHKYvbyd^]He?WMor<EtBgSDeRqSve?isGxHciaoGnMUuMwOsI<[tuKRvmTwWDCORNmFpEXlwd;GU`UwDMfRwIwqFCMxPCGt;EluEKOuvmhh=utIvSErggWDCxqyT\\wh[MtTIwRSRnmcTMu`cbbmXmAf<yrFEt>wSxmXRSicYXWibTeV:eFh?rvix:kdB?vggeT;UgoVtKuaSRgShO[s:wuR=ivYTD;yVei=iHsaUtGySEC[Au]uipmyvkx`wfkABwwwKIr;EBpWUeUgB_fL]B\\OUkgXhmgxyyfiiQ=d^GwoeFpUidWsawxh_WPgwdOWiyrZmB^;CZERhstbeEqKRD?T>oEqux;OYLYF][xbcbX[x`guGcRBOV>QDEKd:CV`=H=[sZMuGUyhQxhSGwwxSgd_icHIiyexJKv<Ui^QC:sV@ce^UfaWgxayyywquvVWYhiyhyhhcVbWyeYdMMeFeV_YSJiw@OsiqdREFaSwS_HpGU?OhvKdqwViKBbYIOqf[yicOicywu;DTyG_sHoMFPUycQB[qDb;WhYw>AtRQd>;TimvLMXuau?CitkXHSyHUS>sypMvuoG>mEfytmAXgmS;[y\\`lrHLk<tlMs[LNRmrxHoTXwgpnPHVHmxIPwp]U@DluyvrXJHuoVyUxmNyYuqqyW`lUdT=\\lymw=MjtiwEuWExM>@lbtV:]O?epn<U`MsVIJ;aUU\\w[yyE@NH`VkDK\\QqdTv[HX>eMoDU=<miewfEvv`O\\Mjlxk^QNJMrGEMIlkeDMSisHdJtQTm@kbANehWOXV?AoTeP=muKdThapf]QptmxaOTxuJxmgdYBLrjQsBxYFANbmlKpmVLMmTW[pxcYuaUWSdyqtYQYRJptpDLAQm>hOnLPrpNOEqLlYEeTympP@JrtnoaqtqSUYSi]vQ`PC`uQiVOIkaUJhIXgTuFyPLMUuxqu=t<]POu\\AAoHq[hwZk?\\vYq:^y_?owabsgZUyl^_ruG\\qYpAFd[Hd@IuG@_jxvfhcdH`KxayYsiAcCVvVVm>_xJiysyeuOfHvw>foZytMH`y`n:xooYseXotWjSGqmifyad:?hIxuywefHun`eS^]Javfvl>PxRiw:>gAPZmYpoi`sIr]xcOqdrQuOXsdyomOrNfwFnjuamVgr^Yw<__dv_]H\\:NmSgtifgXp_bfgdvhP_xNyhTOcBVlwYjlyxhxq[@ZvplHXct`eNihdG[FIolGZK_rt^dh?d@HxAhgPnZvpi]p]tvlN@cxfnKOr_ItmO`>xuiQjfpeGobDFq=>^>VmvneUxlqymYijly[DAna>o^OndimpI[@ay]xrYVsyQxawyA`\\eivyaZfix=@[\\ofrOcd`ghqjkgigQtu>diq^Fh_]Ht;qxXqkxYmZFaQVe>Ih@F\\;>qnPlBigmWgmfpDqdSgoX`h_f[Zw_EawZaoP_[Kq[\\aw]OivIba?c?grAYxyfrpG]JNr>@muaoT`jw>alnta?w?>vQAb\\^e?WoMX\\v@bL^o`InW^nM^qjh_]FjLWpZv`@yq\\ngbFyN>loVeGGwny_ewm=Wn_hxfQnLVjoxshxtDqgpAoyvmch^O>mUXaOgk@nZvVlrvq`>ke@jbifR^nMNd<OkQpd^oaswe@fuZViVVbUOaeaq;X\\ohifq^Y>khI[XXk`p^AHig?cLNnmwZH>^RNa^wvBNfd`qafjOp`S_eVolXVyC`j@NZYXwH_mVXm=Q_xxtgqdx`b:xydptPX\\j@[pam>hrLisiVie^toisb`iayuyYacYs`fvGImmOtH>hw>av^dJv^RXeFgidgk>O`Sgp]_g`W\\:?pC>dditLwb<Fca>rNhqooaWGeNvjOQ^yavevwdx]yplCOc\\@lQIgxqgAheOIx]ht_>okWqFpZ=Opq?h:>lnHc:iv@yxq_^X?sDiu?ylJGwOFygY_QiriQhcWu]ovH>aXvm=i_?PiOoarox:gdpv^hgx<@iB>mFyZvPx;YeuWqTXarP`xfoZqqLPu>P__O\\rxdF?]QV^Qx^UVxTql[Ptfhy<?rYYZSHt=ymR>]OwsXg\\mnsQ`j<qPeDDEYmsEMwfKwD\\ihu]Vl=VVEbVGtDsrEavyuiuwUdYuoEYj_yJEbTqVpWWOqCQsUaqyHwSF_VgUC]UF;aSI[SEmiXwrskvNQD\\Oy_AsLgrroFdugHwuNsgGyGG[wmcTDWvTgHN_EBkyeGe?EXlEvqUcASyySCLYxbuUyaY]SckoT:=gk[eygBZmS_mWJ[FIGWqCio_RmCUH?s]icIGDKaC[AE[[UqqBBoidGSYmUNmThaTqOCT?YaixXquYQBsex;?It_cPQsRqbpoSIud?mF=utoKDbkHL;iAYuT_t_UY@ge=iWCmTPGXywR>yVYCl^Ilv\\qmtOHIrHDMVLyvmvEAUvHpsHqcPKyixdxUYMN:yVciLaUdtxi_ium`hMiwxQhHw\\YyatnlsxfIg^swv]F]iaa]hqTO^SaqdHhmHoAgdgIuHp`CpvlPxlga\\Vp[IfsQyoYod`umaxfIbH`xVIwSylTh[:Fylpb>Vp]Ff?^ZUnpENZjxpkge]AZwirr_d`Anvyb=G^Sp]XFtCic^^\\p^\\]Ohk?uY>dLAeIw^Nq]\\asQqcgpodId:o`P>csFLAgDiscYcd?yQMTK=ggagLKDgCFHgiLQWDYtoiBSswYCdkAtJ;RJqbwix<[ReKhC?w:GC]mTFAHL?yutYGmurtXOuTKQs\\LoZywxmuAyKthylYqqpq`XyaMprAJ^LrlpUuHu`lOuXKailNQkXlpO=N[DlF]p?\\jH`TnDWU`O^`vvAssek:Lv?@m^=n\\IM_Dt`Iw:DWOTw?]yvlK<\\MQ@la=RUUNiewpDXGUSdUyJYwIaTMQL@ywSXR[PmqMU:LtwmP:PxPlxQPlOax<PuqTLwqRuAK`LWsuKf<TlaN:`X_lkb\\vk<rWin>Dt[hppyYOArGHy:PYe`OPeUriqEMKG`LBMnbPwVYWqLXcDmDqn`IKHykvHK\\ApDEYetJ:xSbMJQaK<ANjxneHLkIu@DXW\\MdivmPwaHpUMJjyNkeOp=xW`KxmrkdJ;=tuMtWYKlpQjHsExNEMtRysBXc^XvuaawoeoXfSv]YviWWjyif<^i<faahcMHsSNqkgxeniRotsifuappqx_qyuwaNhy_y\\lW[[axjAv:@yWq_o@\\Xxgf?csHtJp]v`keHsn`rmIisv]XFlZxjMpkH^nQv[w?r_Qd?xmgpd_iqAw[_I[\\NnEY\\]Ohx_hNGZKPsWXy\\_bj>voQgkpu]il_f_i`nO^tKIthndMHwmhjoHmBheEg^^@Z_wyoXgqf^V>[dWo@hsfobaghL`fBOZeHor^l`H[]GxdGuaV_o?gaagjPxANkVPssNmGGb_Pq:ntXfpW_`K@[\\q[r`aBpafQxfgiXoavohYoj=fylf`jnZ\\HwQXoMvv_ikSYwTO`TggPin;NtJwdA>ncarq_pAgcQwkkV[pah@QwlOfOwdPQimoxPnscx[^O\\=PwHWwpn[bFigIlMfeNOrTn[FFolxpU_wtFcEPkWhgW>eyv]Gyb_x]:wgAyhpoxq_pAwkAqwOQavybexmDQdvGb<InCf_[anW_bEij^_rkFqRqs[Hd:FffObgwxdoa>Xf[ihy^aWqky?wUyk?pnoPuandRAt^h_eyySfhjN]B`fQfl:nnAvo\\NnmOgmfpboiSVugGvth[cyqmflR>ry?dChjaAoxhiAw[Bnp:H`^HhhYgRvxZnwCAndXy]f_]aw@iylGvRod>?\\e>krq]\\qqF?vXIanNqZq`WfmgQhlxfPxMki]scYcIPsfAaGhsgGst[Yx;kgVwi=idhoUGmuveysQd:kyeOtGyTYOYwogwoXRUcyiVD]u@UdcCYxIvuMHn=TQWsBSfUqSg[EHaeoQIfQHLKCBmgLedyuy=wx_kCLYYeayf_cnYXpCgKuUIuGXWD`_gdewZ[Wiwt>ir`GWuWYdeVRiG`Yt^YwCOUwCdfMUPEfJoWIqsBYQYEjteuPhl>]M:GoOw`n@jpFZLYmS`pFajAg\\VH[VYbxvqpisSgc@inF>\\HwlDNt<Ff>@w_Yvv>a`OocoluOdgyg`WlliwIxuQarlirKI_v`mWpb?PscwxDOodQeepoaAhwOw<`tpP]ZFmbpbQn`mh\\]AhBismwd>yvjAvv_mTqjSXsWnsF`c\\NxRQlVgp:@kIaoCvubo_H>leVssHvCgih?m]?xsFuIxvF>rvfjii`NGum@[_Oibam<``avcKyZaxsiqZJwfeFesAxcyZD>x]iyMNa=YujHiHhkSAqBPglipvPZup_pQhrx^whawOwwxqdPd\\aZhPfwv_qnnXqrr`eD^y?PePWwaiswp\\W?]_g^wvkwwhEAla_dOY`;VqLa_ZaiLQesYbjo_]yuwAywH`uOyR^ff_pAonaxuTYgBQd\\I_:aa>>pHV]enhWplXQtLIniwed_f^gama[ai\\LwwxXZ]onEoxd`^OX_dGlv^yV_d?^fMguHYgNHtOItaH\\EWhy@_A>^:qq=Ics_iaGePy`QgrUNZjYayqwUA]jh]EF[N@jyQq@vyEOmnhvAx`Sx`uxqyxyEGrfaZCijsHasqyyixiafyFphvvAqb>aZ_agNYoYV_:WppoqVauLPZ:vqYywOHs;qiO?y?QeWAdSiaWQmrgntchog;;ITOxustiGsoGgCeBcihNMD:YeOUG@_bj?DGORkuV_Qx^abtIx>KcZWsggUoSHOOh>QxS=GhiD:kRW[rlESOuIegbnWG^SyUCFLQEGcCBYsBQG:Ix[OGuIf:=TgqF]wvEIc<sEC]fXQWBAfy;guAuBuroYyPSpnMJrys<Ey`LkSDk^MvlDPRlt>moMqVQiYJ\\xSen]AryHUTHSJxywypxHNieUrHK:TXCirkHMCtJA`X<@U\\tmNhjRQkn@xYyT`tOdAQbpxYEJZTqaMYWlUsELSxrRxvZp[oNoZBdUSkCrGWGH=diWbv]g`SiLcCe[YnwsGuoK`MgXMPmyJ`nheSyhnOuPnawmdV]LjjXmWPUtIMCaoD=rs<nMlqRAlGIWoUvvxK;mNcdU:iqVAObhKm\\MRtt]YtPPV\\xt]uKdDKfmvQevcQua<NFAPBTW:UsxtkHutQlWnPsdpxcPtMivbpR>\\NXpmhUpP]yRdPQuNT`w_uPHIw[XUTepMpofXvvtkjhqSUnNluYPVwDnC`uj=vDPuyTQrywveQ@xwhINlIp[LTVARnPLLTmOYNWPjb=VgUUX\\uwmNS`YF]Y[TyYIw>hO\\=JU=pvpUaQyEm[SQesn]IXo?Yx?we[qnshq]v[yFyROeEvk^ikKvqr_uH?ZL_edgc]FydowgIlm@dMY]CakvfeSWlZxtG>rUpdunrhG`;>bdNpRfkyodKXxngh=>ZYq^qnsKGcq?gopkEqfO?daFpfVb;yiiquwfeKVwevliFkEqg=>bgI]oXwJovP>l;?sgqjDnsEay`socWswITqHwcIWMiIkS@QfWUhNccbCyxqtOYedOEqKtCeBKSSiueXydfefbsSQydO;riwSGABr_Id?i]?cfKD?_c<[VW;FXGG_iVl=V>uVJQHK[SJQXUIU\\KWQMrrIuEwS_KdHGsOGgEOV<iH[;sHgxAgTgSXfCFIwEKcSG[FpOfMwsReW=afdcTnIscUHkKDJSWkihmsvsWWtmiUCwBoF:WYuUynsT:AwbkdEGWN;Xc]wLkgSwUywdccf_sUGIGZSHlEuTIWDwuSKBbKhWCXioR?[hfMXRqbdoIK=c;_fVQHZYE<]h]]Goxvdapr@XIauLPO@evkQww\\mYXM:twMMN[ixMUoAmkoXt_eoOElXpkXeSdxT[Pxc@uohpm\\lxUXqpnwMyS@pWHMtHkmeP[LxE=OK\\m?IYJqs[PmIul]<QIiYJtSRttGqOwhUP<K;lkKAqI]Wrple`RklyxYtLDTP@vtdt`IoiuL[<PL=qQ@L;llJPUAuVTqk[\\OFQXRQPCQsmQnFyqV=lghyF`KFlJN`txeuYLV:YwhDmyHJ:xSOusxIMfQnsiRhIoMUWn\\vKykyxO`PV>moIhxEXt_aJ:<PcAK_dliLJJPprEpU=JPaNX=rP`uRHm<PlpUW<TlMTmReJm\\LjIJJeOluWxETxaxatQ=PYiYlUuvahPsXSYum>=ROyW<]J:UM`DTbLO:XT_YlN=ymLLEDJC@jAMjrEqxpo:qygxPXArxYJ:<o<`W`XtdPNgmLm<R_hMUaocQVe\\pt]QHtjdlYphSRuS?InXUwLxRN@lepl^mXNHKIuotQvvqQM<qxulAUl\\xxQlmCiusxnlDPnLj]axYpNyekD\\NdHVELN<Lu=]OIaPqIm_UYquTqHNsamVHQxasxDk_AWOaWCyThduPevXtsa<xadVfPM?xwkDrIUuaLlHPNdDKeMTQQYtDJF`NJxOaelZ@oFYt_`oFeKGEwoLVLQmoPyhUqAULaIs<MRX]WvttBHVb<M@iQRiQgpQdUroEp]]qpDUFhab_^ap`HVos?oPikxWbAprF?e`vpeib>W`MQmJhc<^yCO[WiawobqAdfWlb^gdys`Wrq>Zxq`W@hOxb^?bJivxqppW]B`wLQeLIwpxZnO\\RhsfIlWYrW>lf_[qIfAwo^V_q_qHIfWGyDH\\<w\\B^rLyv<Frn?jVNcRVwWgkDNywVlt`g\\p`iWasFd\\>pU_YWYVeW_kYiWxfGhb[sK_EBuVqIUvsIXCc@MTlIsIueBmIUEDAwdgITVQxeQUfebOWYfOu]gguQi@syEmCraTs[VqmFjuibgxqwsYmsEYrqqyFmgtWI:;H[cwL?iy=XboD>sVJqcHcBomBgyxhaINGiB]T@Af\\ob<oIv_uWKwSYWgGCQWv=qxC=brsiueVl]DdehUmtLGGoYrgqTMkUbqGcUIUqFSOXSmeiogC=BK[ruwthOsZwsEcfrWFEIhR_ddeH>ov`ecJkEicGewiyEo>pTPAtlAKs]QD<jNeyUDw>`Q<Yk@QTHYuQlORdWJxxqaktuYuXR@dy;dTjyMvlY:LtkDW?xK=qWo@MHxknMlQuP\\tK`LXsTMpMWr]LDHq_Dw\\mcvasM>\\m>gIg^lI]fY_CNnu`_aqjAapLv^LHkCooV?dOvwl?qZpie?aAhhSF[HFZngodgprh]hgxvX`_`o`qZbWxNNo?G]B^[bGaaVo_?cf^enYmdnmXfyEiksFynGx[`[Avb^xuYyoGptrnuQgvSp_eXeUG_^Q_sg^;N_ToiY`rrQoIwihPlKAo]qrnYmT`iG_v\\@^JqLWht=BbahjmHmSWdErFKy=ABGubhuUdWEKGBU_iksfKgGaCXYobNyWaEy`WrfqTZwfywU>qhkaudodkmcI[eQYwDQsYcGIatSgih;D]UTXsgv=f:iIZYeLMrKQgYWtLAUEGs_WgaeDdESgSs^UXoKBySf<wT_CfuWyUMUiysYgTqOH@;x]UuHoCPEDoGSeugfcsw_enYihCCr=TX_IVwrrQtL[wqMWxcvQiVcAhLuwo;vyEr;seoihF]sLeWJ;Xnmt^yUuAPWll_eYKqnNuwY\\MCYxauS_irAxY[tN_alrhUHdp`MuopyuAUWdY<hUkPUQhjB]U`ur@hveypiPSspuJhRvYmUAQgqLO]wNmwIlvPHx\\qtNeyYXKILW?uSQuvSEUChr_LmCIW<`pBxuIYOc]xEAu:uQ@AXZ`V[YXs`PKXstTyu=NZxmvLYfTn=DRspPmdoPmJQLQKQWLXvM<orUqhYYHDlOdtuHMZlSumjKIjPHLdakKqPgpvSQjlyYaQwoewuXprHq;HpQaLBIoFIU@ES_yQYDUMHwjAmFmKGTVFlTcMR[xWZLQbxpp`r]aXc<xf\\RPeVj<LLuoW@NG=RqQQWQotYlZFhbViLfR;E@;suchV_xRUukScdkw:WuI;xFYsuuCx[TJueRKEQucxaRF_VkshwetisixgTQsgEyfDQiRuGc]x>QsZkWAUi`_ub?S`OdOWemwh[OismUmMIusdWkHGmFmOYrIyDmS<ATxaSZQUFqXcQwhiB[CFLIR>CRUKgVAGdgCn[DVSHdOYH=uBqs<?c=yfKMR\\sicsSQuw[QIqYbJkrHUYcaEcwwHUu@OWXww>Yv_wcnwhH=rm[fOSH^ceyOwsWr?Yvqed>;uywfVas[ambMRReR<lk==xHaLq\\Vf\\hhYwZnwIoZIAc<gonpavwjqI`UouJyxhxuuVjeAjbVfa`kgOfT`wgIwp@vXng:`hf?qqoaG@qqypu_v_yncGeV_eJVkmhctYyygpxPaUpnkGr^n`GWngXxtYx?NZvox<AyhyhyXoMFobGtjH^Lyky_y]GisQx_p_@PrAvkxhayoy\\u<uD@Ev>[Gx;WY]fOygpyCIgvKieY?spQw=CygWS]KHNKCBauT]DD=hBcTNigp]CgkdFEh\\ssPuH^]F^YBBwC:[Gu]F^iXcwtu_EIMSdsU<;Go[V[UFdkCUgRhwsFMGByWgiwcYcI=DY;CT;FliuImw<_DPcvgYGQcV\\=YJUslcc`UU@wvIUIBwtkcUbCB^cSDkY^[Bp=t^AUb?FcodS?hwECjwC<ewyeypiG]mDeqrt;rf_fi[EgKfFEhbSWkAEBUV:]yRqcoax>cy\\ei\\CdnMT]_BTqReEcbkx]YBZSY^gbuuSJixs_u:kIA;BygFIyT`ivSQs\\_cIccZQEF;WuYV`cTGGE;yV;[XxcB_WymuS@wiwKH:;BB;J\\@NdDWo=LwqyxpuxdTqQuD@yRAo`HVIqY@=JmXVaAXG]WlpmVAtYHpvLlCYWtIxfPxS]kfDjRmJ_MYnmRg<nDqTO\\VSdTUas[eXdUtnht^QO:yW:uYIEL\\upr\\teys[LkbxpdMKdYN[@PhHn=eOqlkQpYqXuhiTLHYl`YYttZeKKdssEP[LRZDnL\\qC\\ya<qR`xpYoGQnHQxOUs_UqdXpruUO@RL@JS`igoljnvTnokIigGjJauhXvxixd_`:Ag[ptdF^lHkDar:i\\:HiBgga``:impv[]PZPQxaXcUNelIw`w_x_yggj\\yvww_QYdTGp=OfbogQ?xwI^vqq=AofNwmW_k_ggqdkg]Y>_s`[AnoVpdUG]E>uRPiWPjEI^qqipadPvtY>sj?a>@[VqyeFiQ@aKVl_Gmix\\hvy<NZxqxpqpv>ijAbM@pi`isouFojd_djamrghyqywgm^GbEvjMf_B^xV?qRhaooytwuvys]yfawhIo]YIyc`xPxd_qvsHZ:`fiPjdAfyx[>xpE>`GX^FpaJ`d[@_eIoF>ra?\\D?tepdGfqrOZ>xrcgljAb:O\\SQjvyrY`uKp`:ntoIuCgdSQoRwkIoaMGh>Vlbo`axqu`aoFZJ>_Eo\\y?[dapsosbQ^Wigl`]GXs<qfNo_IokCY]Qps=gpqOZnX\\:vnFp^>GasWkZqyV^ZE?pX`]T^dyVmwqxwo_aPyrIpfOepoxpinLAg:^nAFb<o`oHiBnfw>k>?w[Ya;ovmY]eOx=XaYVgLvhp_i<osnxpWppQna>PxwnjLow=>hqAcVVy]xvG?\\\\>bmxtEFcCXum_u>FxRo`_v\\`vf^QZ:aaWOsCqfpFhT@xnFwfXedhyQVgmOwQyjAnb>qfpHoG^db`vkgkmN[J_pCO\\rq]wYyJx_^htm^^Nvk=YZ?pg=IyN?`P@qfprQ?hgialNtYntB>j>PtOit=xmsap<xv;auWfZdwnGioOy_^^ZXyj=Yr=xs\\>kgiqP>cu?[K`b?Vvi@oW^xDYpa>laA\\[^`pXglGhlq\\hI]HheiN^DYsdii^OfRhpvirTodlglNP_qIbyAqRioXFoggl_veGOgcx\\ewxMirBRoUc?avJMdjCefAuX_vNMrsavo_eMgvQWBxIgMMFk[wZoUbgXmue=MUugXsmq=\\RXlPkIqAavbAwZYp_iLuMqgPKtIyDqnpIw[]vKInCLvHYthemAPYXevDeR`ym_`V]EQILjb<sZApyylX`t_UtnLV>yWTUL?yO?<vmij]aVdLyk]JvmtRYtYXqkUv@pyHPWHXsQhSIuSeDOJ@LrYXh`X=YMxIYY=yZDlHQsatuyyKLyuP]J:ej^AM:`SYlmCxNPxKAPywQvmMU^YQY\\uMXYillOetIxKA`kS]nnYwkQtM\\WoPs`LmJQlEyqyqwgDK:exyTUSArE`uNqpDdQwmRcmVeuXQmmfdoDIUbpyeYPM=Yshq\\mPoQWCtvd]O[xroQJfXVSaO:dOiTl]TJDluUAT``JVIj:xtbamS]OC]QMHlshxGDXudwlEK>InELkYDMspjH\\wy=RMprpEybIt]eQQAlYykuUtc`V\\hSSAR<]JnlpM=WZiJoAQWPohXnS`lxakwyxC<w>lRh<ul@qspO=Inx=lIiP]Lucdv_DmEAORTUFmLOEyEItoek@LRx@jHXt_AXdexGMqJXroHodDO^=R<\\oxHwqiJoAQVtPgpLyXsaxsH]K:uYiIy=dktlOF]mQIPL`VbeSkhJ=DS=IKl@uFmR:LoOemcXoZxtUyVnXkJeVHuqwTjbAVRLwx]L>YlNPRotVfPnOYuaHkcmPsTUGxOZQy@DXXmr\\POfUqJhO_`ttEw]PuAqY\\Hmo<LG=JYYPeyxsDXEXoGyvd<N<pTOewYPL:tu]aKcmY:`N:QuwUO\\TjX]YaPtb<vxduQ=XXtMx`YTXPs\\Q?dvh<LnxRCXycQxALw?YQfmroXQcULwqkkDMexRgtn=Yvw\\wYaNOqRHTvkXvvLYnmq<DSg^];ipY>lZxgTVvd>vTanSygU^j^GtDPnWhyt`tpXdl>]v@_uhkxFilAfModQql_XpuAbVyq>IcU_gc@bUpwoGc`y\\NYrax^I?daYbBAhGPkHPwXx_QveZydEA^xaiPpmeOvLqZtaaqFd]_\\lYnyAxignOpeKvp=Qjbhr`@bsQox^m:fmg^l_ivd_d@PbXGyDixSGu<PvYGk`^`VopUi_rGnsFZeAcgy]tGyQqfa^r]Qp<GvSHpIW_XOrd`_go^N>cC^[IolPar`g`;gbIVo<puUyuQQawAlIinZwli`d_ybqqaOiiwqxUvt:N^@Gg`Hfk>]]Q[r_eTAfgquExlRyi?>nhgdj_`kg`l^yGWaBH\\:foX@glf[Ln`e>hi_^MNd@FpnwxnGgOh[Cw^O?s\\NbRGj\\_h]N^ShtLYdXV^W?_:@hlNg=AthPkZYqpWoGOywIZ?Fgdny:xtehtnft@gcPv`PgvSQxv^\\uAlFh[GVgc?_]XZx_gro[vqeyPevv]XyyROcOQpFojabTgGYGyoyRd_TI=XFSIN[X?uc;arlmD^OrkAUfktMaBaGhfSVdsWNwGxgX_iG?Sy>mG;KtfKvS]w@iXjSs`MYWucy;DRKTUor_AXeYhToG^CBHiFcarmSUfovoyV;uyJoFgEWw?W^;baaiLuGcwgY_s?eH;WuiyEKISZMC:Af;ShhYta?VuAWxyfdUDsau=KhogUQsBNiICedDciiwt\\_VOAWO=xWSiNQe_chqOY[ohYeeqCCgGiGKv<OcaCS^QS@UI@Kuv[hJ_c^Yxxkrl_bBQx<?i;Kw^[fTUtroHw?cdKUugCJKW@[Rr;gMWhFiYHec`SGG_dfuwq;hisBB;FaWvlOUvMtXIslmUA_f\\WIluyHQF\\[xb?iweiy_dP?Gfyf?EdjQEjyiZ?bIiDi?WQAWiwDvislUgyaelut>QDNKG;weWQ`xOp?QkffuuIlVQ]dAlmWv]>ZJP[:W_cPkWi[:qwfiwP`hx`^IxvQariIpEilcIdkQZvWZXvj[ytAWdL@sPf`sOqvHmNQoPXo:VyXpmHGuSYaJsL;s=oII[DUGUxCYtsFymx;iUSsEcydUsvacDRGICIsR_bm]YTIFmwCZSeM=haguM]gPatH;hTMynKcZ;rKqwZghn_iSSdSGxj_imUvdkcAcfTSc]]i?Cw<Obamw:wryDY?Es\\MYFAsC=WsxvPUSpLLfXKYQryUXOenD`S?Xr:tWIpwA@v<qQtlUv@ynyyQQfliyYhi^pdJinmwvnhf=FbQAgNvh\\n[uh[D?u>XgKPdjFfGQaIIkGVpTqcCyb;O]:adcxd?qkBXfj>]<>i_hp\\xjpY\\gh^wogjg[LFu^>[^p_qp_Wajlqxd>gaO[c_eMPkPywUgsP_bqF]JVf;ob@nbnFvdObnGr>?xhqyH`tqPgLagoFhxg[SV]V@djgtXwaf`lkFujg_gOiHx_QqmDQenGch^cWgtbQvOwiVnyGae:xrS>rkV[l@pxaceVebGsJQq[FlXFgYwy=goexggq`oguUwoexe\\Fo_FuUYuPHrJankv^<hsLAxuah[W\\>?iXvsKAnPoZON_CGuSiu<FxT@b>iiZFkdno?_[^xa;XwcyZcgx[aaDOqWFc;afl?j^Vltn`u^tyFbXaflGvSYu@Fj]weugccxpD@q@na_f[ggovOh\\h`uiuwn`BPkg>lBQoNV_U@^:Ycd`vOq[tVhfHLqGpEuVUgEyCx=yWEW[]G]UDwQYhwyOEij;DwcR[cB\\ydowePydX;xCkw^]Wd[Y@OWyUDYmeSOYdoeIYulubvEDQoDaiV[qwqiVDiXBGxseX_IgxAbK?YWAS`eV]kdKwdeSeDMCqwgFEBR]ydIvMehlwFFWCKArrATJKwmOFyyvYwYBcvtWGQyGFMv_eHeEi`IxcMFIuDooroOS`UCrEbqgVpMV>USXSFc_g<GF;eeKcBiWGaCYwkeYmtStqxqroEMS\\KT<RXdk=`kDPoJIQkQk>@pD@K]]Xj\\JZaxeyXSuViYxtdPKHqCdRY`s_ipL<kP=t_IwCeMADJTpTBxueqJcEY:\\VeQxxiquAThpQ:Ht:`pmho=Iw<dNnXYRER>Uy\\PJjiK[UMPUr^MKseYP\\X<yLhhLC<oshp_TSKhPFxVRmoXxqbHTKTLyHu<mSw=X<LQCQWcUXGelhasrgps?eWYpuxqeFl>qnpqw[PjiOj>PvS`ZBGhVOqt^k?Xsg?uHPoY@ZXPZjyfEF]VylfnkqNkeiwJYhPq\\IimW>kf`iRqohv]VyiI^ngiZCGao`mnakpymkNcsViIgwYp\\py\\ni[<gwaIZDi_gYgi_pp>``Y]jh^=g\\dvil^iKW^>`fhW\\]YodG[aVugVhKWldgo:>`IHs>npkGavQh<xvwFlWwtB>nAGrvxZ^^[oXipXdywcu?sD>x`hs=?bindLOifPfofkm_x[Q]r@hYpxnPsAXpoG]c?hu`aNvigHe:iyXhdYpmmVhC?awgaVhceyrRAnJY`mQvqwk\\IycYduqrRg[FX[Gah[AmX_byFdVwvTHppvguwjhybewxkxmH>k>hy=pnNWsuPpsPkbghhoevHjhGxuia\\viEirP?q:N\\UH_X?qjGvow[Wx_d>vyigy^[MHexHcUwvmapvHeopq_vuwYkiWckGxaPxuvdvQvkAakns=XtoOfIAkQyvJwqwIrmifSxeEXo\\xhufodIpmpeXpdIWm<xrk^\\oO[dQocvqoWyL>Zd>_eFt^`bMHa?V\\EHqQNojxbawrx@eD@bSq`N@\\`xrA@\\pYanO\\NQ_pxsNNsdIoiGZfyvQQnJwg`?l<?uRHjDAsDVu@@xLIptw^<>^yIu]yvrqcCogWomKymMQpSyapNyBah:>gA>b:^o;yquax?>bk`[LVxchi=?x`Auoh]inrYX_QhtT@ieQwOfpCpt\\H`opltAu=xmXhaQIn?PyYxeYW\\IXu_v\\apnNGxM>lqNvk^yhHjm_`ewcYhb:ha]XljArZpvI>aKPkPw[mY]caiPvtvp^Kad<gdvadr_eUI`mPoEphLXshalX_gYWrpV_RysLQyL`[I^[]_u[fZlYrMVn_GZCx^bY[TV[Ca_xVdyYmsVjHfmsXu__pN@ysNjgy[FN_kfrLWmJOtuNwSYxvpsbPvhGfvF\\VxlYobAp^NQZdvtDQdbvvnXj_vp_FdgPg=vpXG[tyZOqlkGuwPoHYlSAoPwtjweSQfVFl:?\\>@foNmmHxtQZZfs`VqHord^lMQqditBA^ehdF>hOayD>s<If=P]iipDaydiefwl>IiIWg\\PeuGwVp^eGuWWtHhw\\Gws_euQpdfi]FxViiTIenabC_hyAfUvtvOdMPqOQiPW_IPqN>yUaxrhp`ob]hwjAtU>^Nhgc`tLPaK_kPycAwfiniqxZLIkBXrSNZka[Do`o?^qoasokaQpZVb=qe_FqyhcKxZenxRxq]@avgysi[:^ix?qXX_mhxYxlOyoPy`\\Nx\\quIffiVyLOqIQ`;>uxOedGuh_oUYkJgigW`_vcQn`^QvsH\\synYaiMOauXaNqv[>`mOnMflwvelxnEH\\bpwlnpEVsBAlYg_U@nIinZv\\;_jJh_OGxl`gEQt@_eaNsVomSvlX?ZiqxXqq<n_qhwI>iN^tyNynijvaxMyvrGvwQh]QvnP_Kgc@v]UV[s_hlFyD>^ix`q@`HP^@AfMg\\D?xeiweId:@vexcOfef`tj_sB`cGh[Eydhxe@A]mAdJIc]h`khudppDaydQqtYxMVn]>ZCv`NG`O`fUpb?^ysVen>hYWok@mTAa=HrMijL?uQw]ZxwlOanaupVlC^eeHiG_wX?mXpyeVc^AubIxhYhu_lNn]x`i@@o^fZ<AxbgZLfqmOeLvjAqrpqd>?ZPNunFyn@schg?Ox[ok:wdZPro@nwib?xmFan^oflo\\DPi<>^S?lNo__hfdpfMHee`idfkd>rfPjei`>>nnOvaq\\Vwpd`nmGc?nbPwe_N`kgdXHbyAj`fgCNwhVqAwweGnVhbnptLP^;y]yq]DfkcF`lYqa_ptIschoO>ekXxvGwxpd?fkI`sdywB>rghugfxjybApfkaeoWsmiruNiGIgI@\\>Hg;fqdarcXkU`]W>fvYqL>xIPfVIiSQud@fFpf?ny]G``iiNQ]sgkhpbAxoDWfe@[lOcUfrN>kZ>g_f\\dFdOOxwIjS^a]o\\Wvgspl<IiNApYpewpm?Ps`PypaopIwgIhZYqP>\\BGbdhkF`m;YZnX[L>fl>uhgwAAqH``lFatN`EYpAGhSoeSo\\QXqEOZ;wmvic`OwxPer`mOQiiXm`hy@>ZxFjXX\\m@aoPm[h]Stu_evEhu=XfsGXoIN_tVYylmInmRXAipmSV]g<GSQ;fPQSr=dWOCLucaqt_cBZuinSH\\Cv;uetetfchnQiS?WUQdGaTXeitMbwgsTyFi]UwsfdkeC]uwYR]CxP;xscVj[v?=CXediaiquTOkyUut`]rdeHc;cY_YP?fvkTEKfREgegWmcHp;gysVwgIwuYPUvjiu\\gr>qWTwCYmG\\QiXCsqsuwgCjSxdECaQS^kC:;WCWD^[Re=GYmgBYc_iHoatcuBKQGlIRWWtxEc[KttCtvgRCuyXge>CB[AE>kTd?WAgsdkIiwRuQBw_UXEdIsww;Dyws]svaoFxSeQ;rkWHIEtMYugkWQWCQqG]CiLEwmoYxcYTQB\\ahagyCIcKqsrSe@Cfr_vdibEOtTqW;_F\\QW]AegkFGMVmgC>eiSAroeUMGfxIRs_YxQdH=H\\wiYGsaett[hRegD;gE?TyiiF]DmOyA[VaARn=ROsUfoDNEfmQb_WCc=bSuc@eCVGyE=vlWIVOUKWTcwd_IxEyBT_wVGev?VNmyjEbsYtDoEEgrH?WHyf_GfIyDX;RF;ukeWwkRAStmsgdgVHGR\\kTSquSQTZcX:?Glgb^kCGwe=_hpEDG]tUgHkUi=KTh_V;MIh]R\\EVVSIicfdmTEeXCMInOWBmDKav\\KFGGRVWtBodLowfYdfMdDMBwciPSfYoYhURweYEGem_VWKitiT_odKMFZCcNAR<kWaAd@mevwhweqduNkxsxeoSXlfmYStxTtv`QKeuwXdpsmspMVutlKXObev^UPxuK]ewAYXWyydEMuek:QYuemLHSWLsuywyxNKhs?DKIpx]QQSpSaTUxQVjyv>XOxxy>\\yQymiDQZyqdHuaEu`dlStyGqxbxYQeltDyvETX`uwI\\cpqNX]mn]W?ZtAxbabeVg@VbhgpDoquYvAPxMyZmQvoAu^iuUXpdptc`rC>tfXpiQjDy]hyxcOxmquMifv`bgFwINdcQeoinJXdypmO^^NOncae?Nsm`^qpoHW^>pxEYs_hccPjj>qYWrQvgmntvheXAZr^p^qrOXhJ_owAdZo^cvdUN]O>l>^ahWq`vZY__iXwEn`wF`f`Z:?nkIqWPe?^ddptZ@emQwkyvDg\\:FuBpcdQ^cQtmxvuFs?`tuYbxFyhYyYFst__[v\\ao^OgwEI_ka]YplBNpFal_Yl?QcOv_xhbIyn<x\\QwtNgjdylpX\\WvZg>n_ikGfZtypiguJQ[Z@_<?y>o^]Xf]xfI?tG`^\\?Z\\QoFgkIHgN>fAF\\kPge@ecVo?YxdGk;AetF_HWqWvveid_fuE>b^WiYgpXP[s_w]PnoAy`qaMnoaAoTQ^>VhH?k\\a_TwpEAmWYiaItIAhwVwLbAahW]b[UxRcT<mCUWSe[brCSEgHvivTETwmWMuucMVSgtIeW\\Gt<\\twat>iJ?lvrMQ\\`J?ardTXe\\N]PL:`q>LTRDMttjktJoLjedTl=TEiN:@XCtsRxubpJDyr^\\LRdJsHQj]SApNIXx?aJpHOdmo:`J:=lqEQ=LwUYPa<V@DsjXs`UnSmrs`L_tUBHvamSkUY@dt@Mn\\yVCmnCaWNMTglov]kwYq;mt[ys:PmKpL]DKEHug`NO@Sy`rk]S@eSxuRQpUQUrtQwJpwX=lNquPHt\\PJyloPQltuSreWR@y_iQyllgES`LnLpSWhlQtsqdv_auMEUSEkBmKKDvhqWEMOrmUV@ktaXGpJvtofltZMvpix<ivyHNDtm[QPeMxIimutnxlQimyiXqLuvRLTairEyllimylyYiV<iuLXuqxn^XlOQMumrDYST`lfiP`ltf\\o_DJjeqahqcMuomTgty`<pcut<]yvEQLPjtdsCYqqxV_iuqlsEmnReRrpqcpTATLopNMuod@roAUTmPjyv<axBpNtEUxEwpEuNQL\\<lUTlNPQ_Iw<QmhyyLawbpOs<s>@PgXmZxu?dRfujDaoCYnQXOlaW[eJDytatthlSwmtEqybapWPRYHoADlB=TDdvT`qqIsaPQHAT:AocyWeUP:]wOms;`r?IPHlxA<Lc`n;=SsdyqHuf]ogTSoXst\\y?hloDKriqlewLaONtmO<JOMlG@WVUXH\\OSenIlqlpq[TY:\\uk@xjPU;]x:iqhUVp<WDtOuToyMO:Lyg\\wiMXf]SOAQwAYd@WxTMFpKRmQtHLUalY`uwaJZHwPHwCIO_DrQUO]ExtXu;MJVHKttqvtNK=lAXucqteyRE=kyxYo@TCtyWEoPhpFIXZ\\P^dnLmU]LJPmwbxjGHXO=L;\\VDDOSpMytkmYwAIyfQRSxnjlr@pYYpMoILhhw`MVGeLv=Nj<jeYWOAK[PJl=ON`kOIrnxWymVM]yxIRwlm`aOZ`rglLAPJl]Qspn]Mogel>yvS<JC>glydu?vqqx[yuhfyiipGxv:Nfp@\\Y`rrfg@_tqO]c_hkok;>c:ptJQstynrojvPuGXlpvsehtp@iy`c`vnNQgSggfpbIvqwaokFfIXpmGeDIsIOau@jbIvV>kPyjBX^@N\\CY^LQ_UFlGItXnwiQmNNkeQ`xnxO_m=x[>vm:Iy@I^PqhKFqP`^Qxe:_jjv^`WoM_cPv[xwh\\Voef\\S_eVQlAwcLPx=y]x_^_QdLouwwxPpbq_\\sW[EV[YhcLaiwIyLXZxpjZAdr_cPAx[Yi?qxfikyYwtappxx_Ix=^aBHtYPsbAbA`tUVqLG_ofpHqqexn=v_PI[XOhbFulgepNv@>kyHimOeMvkinl\\?icYhT@coAZbHoXqvPXnJ?m_FqkGg<Fd:he;hmX^aaOv@Yt?gdmadA`ofInOXhcofF>vbGtSiofvpfqwcal;AnA>vTy^qymfNsqqarx[L@p:g]YxrrNanNsJQwRXtpFrnxibYsi^ohO_JW`cQc:X^:W`IAbjxv>`]d^vGaf@OooqnvgyWX]rGpWOpnp]=PpfNgeifmhnIgwBnhk`is`q`@fy^aRNrsGZV@bjVwKaZxXeAIxfNwPv_ghg:ggTAZTHZJVvX`p=`x<paiP_rQbs`_k?\\?vp[Ai`wf``kPP]a`Z^h[Fa]p?_GwofvoiXsWxjIftDIhu`mD^lvpfi`wfp`gpxdwZRqg=@vvQ[\\GsnobgP^TQbiptS>vfxp<>rU@ZpWytigVxrp`rLH`FhgQglspswAgiwtd?n\\^\\qAwBA]:Pa^p`IqfvNnXoiiwmKA]hW^ppZl^wQQcZnb]ohuXc;hqTwo:^tLQa@Pf_@nIyw:Abrah<XtKPovwlMyjBooEO\\c@kv@er?jmOxEAbyAo<hqk@]sHpjhk=IvO?hYgeyonPxkYy`Z@vGYxZFkkycupdrfx[NubOvtXqjo_gfovInLywfQwsgdkAnayeghvjwqHYowYlawjHY^]N[ZPia_nKAZc@iwXnZfbY``KF\\^YcK^bTFco`orYqnohSVvbHkMi`>hgvQo`ijQqeuNiPGxuIavXZK_eqW]piqEFtKalXpaa@ufI^BH^eyfE@prHbRnfu?\\UawZqiQIhH^sQ_wDGpR`lUvt@hvIvyjyqQOhPGn?Xh^hkEQlFytGWtxWrLppTg\\MgjLYuTQd@yy?gcPqiSymB^tbYvuxuMVskQmvHho?b@Xr=Pf@PlIWp@qiwfninnUYgAP^fOs]Ia=YkahpmhpwxjAplDFtg@fuHmBY_By_hh^NgiYaqlFngfkqxhqilj>[T^oXI]EvZJNmq^vIxyvY^bXu\\^lraj>Pj@WhkxdeIsDI]]`\\nHpoXnUQyj_yhqmh?_?YtCfb`qeoQpC>p>^yaW[eA^L`qvgv`iZsW[y?[vV_eIhG?uLqbkHuFPtIif:XinflOHkKIbJFl=GZXH[Wodvag`N`dwcJGji_bMP[Tq[AhdCylp@lQYvNQmvOotIaJHraxcaalJnn`Nrtnx=Yd:Pt?Aukieixr_VgK@o>Q\\cfpaa`KF[ZyauOuIyvOWuBPfsPndvwtivEOeOar?puU?]IVlq`\\;^ZtiiJFvVQxl>j?q^aI\\CNmGq\\ohcR@l__h:YhnFffgrl>bevl?Aq@^r<NdlXuWPgCF`t?c^P\\Yhdb`rMIhCvkFPw^W_pii\\hm>AsZwZ>AlFgr^iv\\Yh>?^x>ja?eCNkZOsCgcfXoqGvaak>nvQpmC_^pp_wIn[?l>HsRxcjOgOIhuothydeifoPabwrj`eMHd;wfQwxa?bAyw^XpkfeSWwLijq@`xakTgafWeJI[Zy^jWxIo`YVtuy`kniGgo\\pfmPZ\\Wc[_qUOmbiv=G\\SaihplDAtZaoTObwfiP>\\:oelFyoGuXqg:@yP^^WpeKpeMVnhV\\hxkUF\\Chct_cpgxhYpsi`wYuhA[<`uqHb`GhghtaqpvHiu>^<p[VVib_v`@qvWnZNZ>_caVyfOrFN\\dXchvp^fk`o[uyh\\_kPWnaW\\aYaRgyt_[P@hpHp;xuhWa\\xxH^bmqjYwseysCwdFYukPeeixay`F>xSyc=P_Y@jIQikyeOyvZAvBotPo\\^nqrY^S@[hQssHcPqyYhl=>jEhZDQqy>[_H[_h]Chv^y^qwv^Gi]f[jo]?qhwQtVquoNi@AZF>ofYb;vnHamwww]xv:FxL`kFNyN^uc`to^nPq^[oZrvo=gtaHnjyfHi[Eas>AlL`btvePafhRDcirqsX[TtYtsgH_[bUwTIIsOWC]MgjIUIwiKsvqYsDkeFMLUASd]VjmyVAK:lsfPOL@Ji?s\\wZ^WbypmC^vrO`eXfxPhkOdg^]WhtDHxq?BqI:GiIEBtCFYyykyFT_iw_X[MSOoH]kC=QwsKrxeGT?iGavDse_qBb_wsoFiSFIKDPcDXCRoeDZusSugYEYmqbhyGX_SewtI=DiLR_Djk`plEWgeMZYQ>dvcItv<jWqVMAO\\llF=wx=qWMOUHtvArZAVyPUwLoHhm@EY`epPUJriL;]ouLS:TR=Xj:dO=\\qslVTMQfhqaeJIMPW@luuKY<w>=rxAVypotlre=YrMqr@QqIUdtLF`Js\\lodQvMOxMYkaQoXJW@QOqK<MuLavoAubanntpTLm>hnwDteXS@mmOukydJZtu=ipSHmsPKZeP=]rn\\nRMsbaWZMorqmXUlTYRk@yD`jtYrL\\KL@QfLYfaQN@xhlkGUs`TmEHS`TM?qP]=NEqSO]ypuJBurdAtTpyfmkgpKXDvVqTkuywMKn`TciwrtMuXN:XVoIWH<jomyhtSypxWIOQQPrlXCUx:dtdmTTdk<@QViyl\\LxPJ\\<xDuJ\\`lhpeVqwX_iqVk]y_eF[nWbSy]<GuiwpdNeQyc_xipXlC`yPN^[WlrObmNteohDqu[WcgV^LNRQGDEiroGW;Yq_IhYctsd[YgYeEMGtKUfamC?iE;sy<IWemwQyeYAH:yf\\_VYkEt=yyOgOygd?TeyYpyEyaR\\?BuyWxefY]i=IRsKuu[HdOVRmyq]X^?RXqBZOSaMSLccQ;fdSYNeVkCFEUy??VCugSweaYCUODCwV_igUUtlqsUWhrEST=Bl_F:SVIKWqwDikeSUGamEy_u:;INEfDwB:]E=OwOYY[ouegcgCUVEceqHnWTPUFcchekGFqbO[ESwRJedGgWwqI=yvvmB<=y;yBI[XuwXYqiF;hbqtiYGrSB^GwiyCGKyOQfsItAwCZ_eM=FKui`yCrShpiTySYxiu[gTV;B^OXOmbkeGB[tk]R<[gh?fiygoew:KIpADTmUUarpcylUxTiB:;RQ;bvSfUQhMwfMsv==RVMUSuTeEWf]WBUGE?CpoIYwRQUfTac`[X\\iD;wGQwGdwyiAXt[HsKSOySIyuC?tXgv]gbLEUxkiuuS;WxdidEMUsSfDWynWHbseI?bYyg>YxkiuuKUewEB[BNqv[gX]]XJcItcUFkfWEr?YcaQc^WdFAE>OrbYbqIdd_IMWc<Qdf_D:;BB;RLCTJprrxx_Qx_XWdesJqMdllEPS^eQweQdiuQYMo\\REDX:\\XBfbBF\\>hea^l_Qxc^aQ?dkiqwPiFQfcv^wiy=Q[higRyqGqvNwmvTE?BdMYWISSEUumgPmcUYDJiBMmsd;euGXw[iTMTtOhtaSpSVEOYx]yheCKMRWKwXAeUCt`oDWSi`MIWIRS?IqUTFmDukggeTUSigeWQAR@CDCeFQgXk_DIwWBhmrpPJUuptLXXKVtoNES]ImcXSYHu;LviqrshLj]kflmqhWohlB\\wgpTG]WZTjZAx_EwmPQ;MlaevfloudWXprP<KadQaTUGQjnMjZ<mBiQr\\uKau:uO\\<kH=l:qTwtOg=qipYYiRfuUKxWwUP^tYjyJyXo>DyD=vkEvlmp?mYG<yyHj:xscixf]nNYoOMMy`yP]okAYDmmXyyEDpVhuNTSYUm>Ul_=otYRkUQFQKL`KYEqZ=SfdUNXyIpTZ`tgLxYayxiOStKAdnReWBQYntnPUlYyVQoyCynEPgiaeuP`dFr:H`EWpy>w<YkOi[OPe:Pxd>oAyqlpm<YkOY^Qx_>xcwQywVf;WxmhgdGw>^iH>jx_cxhywXqtxyUxda@npgcdpxIoc;nk:nf<>ZmPZ`vefPoGQbjq_OXotY`xqw>pdCI]]pvxFlFIs@_`gVdMXblWvTa[:QncVseH`v@ug>jsw]:qoQGrdNmBA^LHcDAsj?[[pxbps:ifx?foW^`x_[Xu]Alno\\aIjewtYywAAiwPojGakNkmV_spufVlt`dxYmKandPvcHoKYdIqyZatmx\\:FqG>riqtDGnYvirY`o`h`p^Aad?y]yaeExfWodKQfPa^hWayY]DymOn]fFdnPeGynOoc@wkZh]HotEaf[ppAG\\;^[ZQiah^Y?_b>oMGhM>wSfxffohV_rxcFxcdxdFWu^`Zjvs`Q`LYZ?nswAxyxb@obO^kbPwWq_IpkavjYXdCyh;>wLGwrnouxevneypmUvmQnthYegohwvjBqvD`arax]f^_VmWIoP?\\u`gLybqXaW?^gAl^Q[cGeWwi[@^iXlipcRWaYorkNgrolTPdh`v[PqeNv>Ihhfeuwb@vjIIog^rSVu^vkLGa]VcEym\\__ePw]Ymfob?nsSno;Y[jvp<@`R@nXquc?vyha\\qxIF_CfdeFevaOefVodn;c:_ViywY_DIwY>ECZwbg]FV?F=;GuQSckG_QXVuyugEQQXECT<UD>?rCkUgiEWMWYcWiuT_ws`idZAwO]c;yW^qE>AWVqTegF__eXmdHWdHSV;sxwkseAuKwYmygxuSVqWiyViYvtQytoI]]gJIyo=UrwgysY?;yauIISBseh:cHOQuiSxmWhu=GikewMG?avWEilcueCr;Ycl=hm=GUSes]b>IWSuc^]vvIi;=bWgSXwG`?fTUSlEWp=SwQy=WRPAEqWsgWwM;YCQGlax_`YvuYX<nq]NQyoHHsn\\LuDj?pYwpx?HrY@TBiJj\\XDyJYdQQxxxMxNLkJiOMYP=MS>\\py=KdurAurdEOjijIyldMUlHyYiyEyocPQxavMIQoPU`xn@DnxpsdPy_<qJeyMqr[]jjlLX<jDUoEQrL]TxDYrtJ\\HxBavrAlphYBfv:N_CF]<PoYfZJXp^Ftgqp<GiPIhHIgs?x^oevAuyVirAtmvmWp]OQtEiwWh]oajSf]jO\\Sqr@ObwQi`^aYQqwgbqHflalZgIMXKkrn;cb?rGKdruy=YIL_S_avDifS;G?qb`ACR?huKIn;rVeYhYH@mc\\yhxOy`OUYsGPkdn_rl[DlYggOfEwYZQifcghGWHEvGyHiEW>QDGwFZoXqcfJ]GbUbgKC=kIeSweCDgmrp;Hb]FsIw_yfL=BNAsToTcAHsyeGqfKccnASBsywwYTqCSIwpMc?gT?eBXyy_CgNMslEvviVgWuaiy[CslKSR[BJCyvmYS]UTwdy_yxyho_RMwtlUYaUUC;SMGr:crHkT=CbJ;IMwHvCH??G=QG_OU;mXpMULqX`agdwXTQIg[RS[IIYuiuY=SVoGsTQwVkroKgP=TGCD<SWQYWB?BFqDa?iJcE_WTKcWbmVpOFdIhjoWyUUOkyBar?CXr?ipYWu_HUgHvSYUMXlwGLgsAef>?w;oXPwrq[gdmeuqwkSU?IwU;dlEHgcxfEUteWH[wMigxcY_kePkbpgeW]eneXPKgv_f>]HjkYO]spkdfqwEIrxqgXwHCYgL=cEehBKHbAwOSDB;gDKVjkFpiXEuH\\;CxSEu=cl[Upmhl?ELAc[UHlATxuxUwh:=g[yyqYYCwvgiT;qreysiwxmYG;[Y`[vbEtjCY@ydNwHRgVR]CAIUDGsUcsJgiKAWbubGmhLmv\\?GN=yy_gC?EoOuP_ivMyX?sXQhvexpwDiKe?mxpwCNQfS_EI;sjAhAMt:KxYguYMd?gv>_s<;eyIrq?i<YTiKRHiI?[EPefVswY?cIyWMsTTQfXoIO;I;IbCuSdkvm?TeaeJeRIQiXau@;w^gt<Ky=yYwycnUiQWCKeTtYDBoDvmYAos\\cIr;ftacEEhVUdewTAIf<ggtYh:=r?;FDEsIuwv?djAX:KCBYGS_W?UYfasFuCeOCawHIuwvQs_ICc?FtAc:;syCiyaUT;IpSX<shh]sbeSwqxpqGHIv>edNWt_ebtcX:;yeMxQwItWfyuiuqxOEIEgyj_xNGDAsFfEhyiiYyw@;iiAFLEsbgeloB?ywI;YneTioXowuH[tmtqvLLE=Sr]VJmusuv`<SktW:DqMqK<IKdiqfAv<tvGhOSEUSAtT\\WhUskDUgmLGPKDtODMPn\\QZhWSLvt`n]IjFpkGTott^SFrpae]>aH>vYoeWgrRaiTxaZom[_hf_rRhgFNjZipYF]GVcZxa^FpR_exXxayu;YpaWrohqd@fiX_CopSfiuIgMa[I`k:`blQd>Flf`ohFcdVlLqdCnfvwj_YnuaipVmGfwU^heisq?nDYi_wgqwcdixdP\\AVue^dEifvwaap`JAxbanF`ZAFxVwpexuH?lVIuhGc^WfCO]J?xnpftAbnfndo]^AqcfvLoe;`m^vdcvv?i]bylmytYqt^awhquH`goVwt_mlg`aFyN_egg]qxpY>rdoruPdon\\`Gjlv`;>rU?uyV]fhZAx^>afqWcUFsZpe@@`SItqAba>a\\A]HwuZ@qvW^TyoaabeGvSQk\\X[aalQ`evgZQIhQOy:oZghwTpyFxtYHsUYpZ^jg_]mAvZWe<WvQardQwQyxuwpOWdlyvYPhsWdpPkSFxSI\\CGi@_[ui[JQ`wfahviyyxxWeehjxoy=I`wGlQIpxQ^yoi_nlHVohoqwiwiWkAYvKQaUyfIqmCy^Y`i\\pmWVadO\\fy]ynifX_XGX?ugsc>ARPyftSyyYrvArgCYrAyC_yjYYyqT`obTOX]iwkEwfuHvCX]OT>AhI;gfWwGgWW?F?aBfgtTYcjGicgUfcGPoeIqfxYDJyT:KroigWCyAwiuUR`msG;FL;G<ESaghfEtdUwMSgWaFOQUEmExSUMUI`Qw_GHWyBw?YtywuWYuQhxGe;Ycs=f_SdEUgCCWpoX_Qv??h`STqmXpidZ]XuMd<uSq;BjsFY[ynIC:KfbsWwGYXst?YB?GWfob?QCZchIkSMchEAFI?UvSg>IrtiY`kcCMCAufxeiVoh[;c_KX\\irrmWYAi:;DcMWNArViBCWSaSY[aUaqDPihoKxQmutoG]Uv=?BfgGCwFl?TdgGoQugkTModQoG=eVMecIWBZGYvkSROxteU:CgT[TsMxmsuwCeDQROOI^wEdmeQYcAYVL;ep?DmEDC_VTmwy;YfoUjidewDOqTKqepyjPILnAt=Hr:pWuItIqwBQyttV_uKePY`AQREt<QOZlvG<K>]mlxsL`SQ<S^DmHESc@ULqPEawOXTi]toXR]QwtQor<xFiqoqsuPtamPehr?qXGdnDESXmqrmNEXkmMKrqOfUVp@uFPkXtj=DL\\Apr`QXemG\\SlMx@TRtyjK=Uhtm?qyeLWGaRJdQfmRP]nE\\Nlmw<iLSTmt@JJuKCht[aLmhu;hYQaLbXpS@q@]KW=NAqnxa?;c<;scuvfIBvIWIasVEYM]iwIV]ge>IJslrsUp>QPpHpbDkGiRcursXtLIVoqSAuXI@mWlWkaJAhr^eX\\ImcMSY<k:hN]hplmRdANKpV]`nwlxq@J^ipLdwgTo>prhTkm<PfpmwTN;TlWYNg=qpiTHMJedN_XoIAWQLtd]L:MyuLYHiu`Uqn]xThViUodLpwxjBLOfHKWmuyhogPnvewWIRsiqieYGmYxmpgtmCLkyLKulqmyoytU<TSApqcDjuiT<mjmDWcInLEwmyKeDXbyukTSyQkcIKtySYpQOiWyYWEeplijd`sy@yRmxqpUDATZHNc`ONPy=AKXlOypSNPuYYQNQsSPY]uRXhQYal`<RvQyoHP>xth<J=URPllLLXqYt_EK:\\XilmYLTI]yMyReAYspX^qxgHO]HNT\\LdYmi]S;\\SDQpr`mNPXwUS;QpH<rY<MjAsjAlIewTlPfTn]TXpXpGmOV]MKHxC@nv]ymHYsYtyTy>UMGey]xuyURVlSmpwuiTM\\PTANfhkY<MjUWyeYmhnQ<nhMR>LLOAk\\<vaEOaIMv@XAPKj]x?yTPMLJ]o;DyWxoYuRn`TPhK>=MC=ogAxB=T;iUuDU\\LLrEx\\eS;UX`MYNMq;]oHdptMWlpKJySaUkRTT:TvkHOruJuiYLIuMIndxYdauBloIxTPqt\\=kPmTJloMQVRYj<awOHkcHLoPpnMrNlyhAR^UPGhymmVjQyT]Tx<yjqk>Xr=ML`MNQtquluuDtbxjOqMn`MvERipv\\\\splTA`X[QyiTjn<RxAYx=Uw`tPqV^lTmHmv`ofdoC=J:yMBLy_UKKUR^IWVUxB\\mOdspXsG=LLeM>eRYayqmqoiKoXnBmQuMUsXXfDmNmR\\TwULKPqL:@YYht<XwN`T:yMpykdhV?qLQTlQlVohs<dwnLKQ`MNay[<SVhk\\QWRyuP<S]xKdaYnMvVlo[xRMttiPQBpTjhyTQtv`MqxmBxJKqJwQy>MXM]NKDtkEUgqSOupG<OjuUb=U`uWxhkmaPCUnPEt>mvX<ScHJJyk>mL^`mEQkGivKtSZ=K^aUNYwUikqQriIMMYV`YTkDQ=Xv@xOVUTIxqCLTe`Tm@MeHlu<v>Dp@enB<n@YqrDXKUld`JsmuMYRVyolmN`djnqjpdRmpXqMShdq\\xvJqjiQPt=W=]NjXtdMSalrqlQpiKviW?]jvhnDqYQtQaeTHeNK`lw\\MQiWWLlx<jwEqNDJs=QjuOwLvl]MEyuuQygDyeioO<O\\pkIebQymiFk_Xb_pcuqbapw]IZ^Wu>NZuvdqPfM``dvyypaCQk^FbjxuQqgFxiu>raPoYxisacLH`:^cyqpVXqo^_aOua^^TVjLveEAw>IoKI\\y`mUpwQ`isHnZwg<>nvgvgIgOgtG>ZBwciwnVQqkFjjqqfFlGaqvwwwx^rGvU?ZfvmVwqxnr?FjNGnl^eYyZZijtim\\IxSavIyy\\Ydsx[L@qjoiRooWw]Qpkhph]NmrfZkYvMIgfi`JVZQVlrqrqnodhZkAySQm<>ir_rbPos^fHAZ^_dbnt^ogxN_Hwl?oySyauQ_m^]lpjbOfhG`\\hdqVpmFfVwa=qmsoaqH^P?l<AcRyodw`Ny[_wvmXs`_`]VxEWmL@sNBcgSlIyD_b@[irovXeYSQU:CRPUYrCBtqDeueNSCocSfqswIuAOxIyy?yHoeT]oB\\wELsDe;cRmCtevdaHHGUOwCx;Y:?DxoFqoWWMtCAVTYfxaX\\wDqIsvoBiGGYYxUwhiSW_Gt=yRIiXpowJAs:oh@?tOYhpyc^YvIww=tMByPyhhtyxExvE@qqVxBPmfOekfdA_\\LAgnftIq]Hv[ehrMi[o^c<I[[yvg>jnG`Q_luvhiIwLVlxvqI_qxwaB@iKggRvZUnq;@]qHpgfa`YoqxgDXuaIlM>lpoaY?lT>[\\fmCGc\\n\\QXZVYeY>[_^akF_gA^WOl\\X[KG[;ppPooBQwLQnpfamVagAq`o`GOr@QvUNamhp=vtaWoXAlg?lHXr]YlSYwq``SYckWpAXwAyau@yiAutQk>GnxIivW_BQ^KVeM?lgY`UgnQ^^NIjmWf^_flXu_>\\Xvd<Avv_ZdFhHXnC>pWaeUxl\\o^;>dp@ki?fF>ZWqnsF^Uxtanw;Ap<fi_vmL`h^G]Df]iIn?a_S@ylP\\;wbQwkPPdhagoF`PQm>nr:ogxI^oxhpI`@YjMOhfGvrgvN_bpGZjqdq?cHPtAOaq@jexhoWjFNiKfcV^wiIsHgofn_eAjrfa]NgaG`SYeipf^vmEHsyWyIyurijegdmHd\\V_>qiOgtrwoyviA>jIy[Ui]MYraxaIY]FwcYHfVyyQastNoxogA?TqHOOI_QS=mUxsyc_eV[GBYEq[ocawQlLL]M]IrYLMlUSj<w:=oXalsHq^`yjYjaQKDuybyxiXs^aVBtO[qq;LvfXmy<P:MYb=ugppFYvaUMlxYj]N;AlMUSSTqTiKEDvFpNdPuoMjNQL\\LJyxu`ty]yMxYRo`XxLqutOX=jbAyr=SeHVFLPtllayOqdTw_is_d<_wGYZjWc^VcZ>r>PEIySAh`SYmABXib_KY`qSSSEG;E_[d:KtjkyUYEj=BZKxlQXxUROkuHqsX[tnAHpyvK=B^AeOYf=ODWcrkYyA[ylaysQgvIxyiyXkrm;FMWT=Me>ouYyIKYxZ;xmgx;uGNuIOaICgvDihc=BZER]wBPyumKeKetQqu`gvYGivEC^GEPQgU_TdsFIkIo;bv[DlIROwxcCraMt?[UeiDVurxEikqr_[U]iUc[DdKxjIvE=BkQit]yOOCgYcgeBQwhxOXEUidMt<AilUxL_W]UyvmDuAYk?ceMuJixsEWIatZ_gYcItmBj]wMII:[s_[H;]tnOrhuYoiSkEYVQt@Ww<UwCgSs?CxwChiuQ_RnCfKYRr]WNMYjiuFMIgkFvsdH[e=IeHoXoas=YtMOIkWcpATsOU<iHBMgiqiAGhN?RF[hDoBAqr^qt?YcTEw=QsSkeeCCwoThSstQtLkyhCc?qVnoSR]YkASwIyx[EaWiQafZMUioT>qC[WVmQYO[i=WR]?cRKsl=C;WtTIuLgsGgFckfLOuTEFrKBZsrw;v<eGFMCuaU[eFwOXxScBcf[SFaygb]V:AcjsdSarmWY^otJIH@Ii?gYLQCliCI=cu[H\\GdNSFNWD:gxhqT=MXKiD>UB?=DFWTQCVCaWHYECyTJGBekXHkCSUXYUDU=XR[Vj;gOIIuAcvkXUeX_cxgiwD_H\\Ac\\MwUAc`uWbafeKyyyrAuBB?Rf;IHucnuXn_vqyYqiWsPMaHpFmxOQwquoytU\\v]HvjyVo:I^:Xp@qyyvpZNsehlk@uQwviOySWeUaly`yhyqOHxjqPQywWgd<uiewUdK]EuT=jMlUtMQkQXnMv?IWQtkUQJomteDknEUe@V<=JmqkmdwdexnmXYhTidy[YlG<okqlvYkyExP@qZPpaqv\\QXagfs@ik?evAdnai;PhsP_NWwtPyxydhhjOycpGifPfq?m^Gf[F^qwwiNssXh=PmZik>WhrGcqgpIw[C?j>Gb^@[@fmL>ZBx^Mg^S_ZByybiyAQovwqxYaQGbln_:HuHHprNkbQ[[Qe<Hamoafv_YogBYyRqt[A`EA`B@j_pmt`u\\Is[Ig\\Hy>plw^trgbwWyyOyIyiUW\\<ykX`_Sf_KnZrFjaxcCHjuqeSGkC_hmV_mV`]@ahX]^^\\=>aIYvV__dIvMGoPXxO_mQvn<Yu_Qt_I_?^_UXk^oqgv[hyaQhhhnuHNZdF^<>fCAwraZB@gj>Z\\hoTVgLqk>`rD>nYxZK^^]I]k@ugNviyx;GsUgnVwoCGZDNmMHrdA^iio`WcavbG@fYFvkApP?tJgplFyEOlE_g@ifxIrMFg:?cRhOCT=ADhGrHkcWMtgUyfqVcAweQdN]Hccy[IRsOx`iCwwI^keDEgfSIUYYTAegcDE=SMKCyau?YCRSSBssCugKWRTSCeeVKmFK_dGgvOChZaeuEDwMxDqgh[seCGnQRosxpIe[_bUOC^qE>mBQyitiT]_XKssVcWYKdSeCAYUY=Y[cHVsgIKCx;HnKFU=I`cDogtgqrYsdLwXGKgQgWjKrQkG[]Ew=FTgEcodDKWaEDZYwUSsLmsRSG?gb@yf>QbbAbmOXsaGtsb@_hUkVmoTO_vTQfVgR>iVMai<Ic^staaXKSD`SXS_S`grmmd?GDMwigcipsDBqBdcYeoWnyF<OiioVMOTDmRnKCbArwUgPKDrqUqGHcSC]ywfIH]]WUMFUYyl=hUUBruDNqS\\gGnMf\\ARjuUDMxIABpYV]uir?y<_RCEXqQuLIyuGy:=hlqHwmIx[wZGsJuwLifEuy?cl_TKmuXkQxxdLAXXIDvnqQN]sC`sFqxE=riuPt]LbQvdtJl`pVPlGAUKMbhxdipjOgnvViXVZJql?IZ:omXH[cwwUnyuIsM@kTG[QnfAFnPQyNY_agbB_[YyeTGcdwnFYZ:x_eOuSGbm^`^IZS?`s@ifPe@ptFfara\\pix[yZIAxW`pFoc>fvqyy;igWoijW]ZWb?yi\\hvPhgTYoawhaAZZHq^V]KnoA^gOa^fVn:N_xgeG@wBA_O^vcfo\\_[s?lGavNAjpAjY?f]opWii?Fx[H^YpcVOnliuRws:gkQhdSYdKWgIvx<gdPytLOy<Ip\\wj[gc_PdQhxoanVaqooe`n^Ah\\JGaEg`UX_Eycx_ycnkOGdEooVOoCa\\BFvlilcgdlii`peoPgbPfmGuLp^oGyLVegqrl^joQyPP_rgwOyku?f:hxhpvBn^HikCx_bIZCvxd>bnPeuNwKyqvopbfkTWd]X[uXth_x@NvoNZBvxShk^qempgfyrQy]Jv[gH]tqvZFm`WH;vocf<KvBAhW]rXqir_ihEEX?EOqir[UcGcuAFjKH<;uVEUQUw>GCRMGHqDBmbaQrlSs=;DbehRmtT]y;;cPGB>Mga]h[yDBcdOIUrkTP[VjGiv_fK;bMKR@ivE;wwKf<qw?]fJicmUuWqu;AYeAyiUdruBtiXK?xg]EeChtOGo]R=kG:OXM[VK]S_gTWwb@uF>qwoieHWfACt;Gt]GgTwsEEHW_HxmbmEV?CTE[b<etHMBZEYbUC^GudwT?av:YXMkeNuuxAwJAUgpRRExB`L\\TWLqkbEs;dvXqt`]pt@NsexR]w:dWb@yWhWSqWNar\\IKDukOInKAJyAxaaTrQQcTKKySUqx[`JvUTt@qDepNPlwhw`logXUFqPi`WiiMEIuwanvyoyYxyAjBdxQTJxiquuxnPjeyqnqkypyvQxytYnyRy]X`YXKujIAlSptIdTTTlQuqbIVZ<xgtOIYRsqsCAxjuL:\\QE<XnHv;UXBEqRul<EpchLjToK`of\\sadvZuyRmoYaMOtjUaOpulC<JdulWeW:mNlEydApFlKu`t]xY:dnX@SN`pYms>aV:mV;lx>TrglpL=VweQ>mpa<VOhvG`l^HnnEoDyST`owmo\\\\JhQJZPm_hyjakTeRVUymIwEhKvvk_qrUVdl^aX>txNyfijyQhxNoOvaMwv@^pdxjONbIye@_nINgn_h<y_qnuVPd:i_\\aeHahXHlo@cD>jVaZrVu_F\\i>oDx]UV[D?h:inmFfSf_WwpXXZZqd:>pgFyCycXPgLQmPf[;@rhap:?kgYsC^\\_hs;I_jqccOfVVxB@\\HahoXkQyv@>bR`vDiwSFG=uYqY=MdKag>mtMMHj[EJGgEWfl[iy=gO?IfatcyCrgd^OtCaiN?hgGudMtdgE<kyHkgOWeMKrjmGF=rpwxpMSeKie?bfAXucrnwWOMvnUyWQefiG;;CQuw]]iduEoMSqksA?fvmy`agrGBNahZ=SRCinmULGhn?iHgURyc=MIgcuLYvnCsCUIu[I`eHsUeHwf_OTbScMsum=yVMt;gYS_GvwvHcuICcyOUfOs`]F\\odHoF]UeocwjEYBwymOyV?Bssf^ABvgsgofReEpECZKiciB;=ttIusKuOWFvSS?_X@MxC_d<sHeCcfkEQ?eKCQ]UYp`P`eOxDKZ`mGYSAqTA@mWmOciXTeLbXS?aQNiX?uVpPpZEpOQJkHX@po?QN[YWQHXWQyn`UlaKQpJ?qqrlrRQy<pQmQuTEjg\\OTqSnPv@`nMYwjHO:tWOUoB@JdQt=@O>QLnYVymPwpPUyJUmj_ujqEoX=seeTGHs=dlIXvqhXq=RoxXDIUFXkDiYQtx\\hTBEVfpOkDywLMc]teDMvuLAQTLErHTQTanBHxneMXhl[IpU@NeUok@UHxX:mpUeTVMvmPug\\xbhlLxycyuvIj>xjAmY[YYHywjto;aMXYwIylFQtsYmx=y:\\uwXYQEJYHkWMYrOyygakWy]x]wIaXnwI_vUxeYntS?m<>Zy>uyFtiYmggu\\ahU_\\ZXlIO_lQfxn_WAiC_q;WoVwqxN[J^w>qiqipiN[OW^QVxrV[JY_NPwD^nisVWBbewewgxgiq=FMSD;cB\\eU_KCyYhn_dNUUbqx_?hhYgKAuKgr?_fVIiu_F=SbhCirEX>eGcKYtifdUTMci;?bMmR@eydufjMDQAsRwU\\SESCySyFEKYFif??iFusHCsfir[cG[_uWiINSHxmwjUuNqCrSuCQx@agvIOwAMdPXUmuxux\\LnHTRSUqJdJjYQUesWeWu]UixW=<VFQP<LP[yscUUJ`JPmt\\QMO]lEhKcpTT<JcOh_qrsF[pYi[Pstg`sPs^GhD>^XpubNcspuNHncpiW_h^fmeNg>AnEAv[amsVwppjw?\\:wZ@Yb:vgQpd[gx]yqq_xRf`Vwqf`_xivAQdAPupGZ>wraOrTWwiq[s?`pWpfIbgYhgIjnO^ahn?XtqnfNGweOflpspGsfg[J_j<hgCGqZ?uvVdQpsCxiZ>nEXvjoq:VbWnx>Og[Qm^PdS^waab@nsGVo<qfci^UIbjhd<Vok?aewp?fbxhjwIq=paJpMQse?vrAhxaiB;XXmUR]dnqVVeWT?Tr]RtSytgt<KFBqhoueO=tgsDR?vg?SZMV>UwaIS^MiYQW=svTmtOcfTgvd[dueTfkGXyxS;dcgubyDy=VNwfpIYVKtf_T_evSYTVwUG]ShwTMgdpEXIOUTqc[WEIyy;[dtcGXKd;wHVktl`L>UYUaxKypJDPgIWWpYxUVWUX=ls;HRcavTeqJTQudo@`XSHRr`SBPvWAWNUKZ<jMDxIqsDIN\\tqW\\R@TYZdp=<LAUy[qmNPLKdN?tvZAkR@LW=KUuMjXTcTxtlPEpRfdsDETDxSYHsSqt;@u=TjrtuFLnYLig_myiZLfBUBjYE:SyqmWG=sqkikqcbyGxErAwwoSF@ytGStxUb;se:EIEwBL?VIUUZyBy;y;yqLuj:YwoqJ^`TXtJBUP;eXflnxpPbLw=UnPTqwhSd=TuusYxr;=JALxipyoytoHNSYvaETsquYmQKUw?PwWQVpLY>aoipv^mMK=jUYVPXUimkcxwFaJRXsemlsIq>`YnIt<`Uv`PflUyhSPDpWquXInVaqolo:iq?dLHuyyQuGIP?TwsxlkDyMxQsaR\\Ums=osujvYjy]YE]WJ=xNEWf]kUqs_HL[@ltxx;\\YXTovDYlHNYpQRmT_yw=]pjAyCQqpiu[eTHdtsepRQlVmo\\dj<eUUQPvYlyEyhPYeaOa]O^QoD\\vqmyYlxXYPBMpnQqLTQ_UtuuwdTpl`qeQopqqAYQFAJZDJK\\rL`JrXsODSC]lN\\Kc\\p[xQUDN?pyc\\nyLKcLV]EOMDrRMXGtl^<KZ]J\\mJ:AycuuWmed`onquUQx_Xiioh]>cB`Zj>ZB>j:gqHPkhqsDaiiivEaiaqmuowwqswAfCFo^Vu=?djOmF>fhQvbfmehb:_mwihR^rE_\\FQ^[a`pp`LNhyIy<p_\\OytFwRIfCqj;xoLogB`c<iifYr]YZrvhoOkRn_WAwAi]yWnr_^=@]gYvHiw?NcYYol_k[H`y`[]waHq\\>^rs@kTyhLIm=XuE?ZsWxoXo\\fwjgiZpbuqoJ>yaFirQsHO[sad;OZ:arfA]@vr<vcTI`O@dbPaPnrfFw>plqHdDylZxpS>n]>\\`yiaIuDImW>bC^^s>[n@_Jivc>ZS`]OX_MGe:>ZZ>ZC_b;_dP^sWQaIWybynZyuSVmrxcQanRH_ZWgsWZKhxj`Z_vyb?l:wq@XrbI^;f\\UQ\\R>n[Xhfpde?h>^qR@qvoDWeQybNWX?CO_irCep?PPlEp^@pcInSIW<TTD<qFAlcYYdXN:tv<qOEuPuTke@uyLuAHY:@UppRA`Rr\\KfumBTl`qxIeP_MKGMQPepJ]j<PPVHuQxmAhX:yjWMs\\MmOQovuqqEKFTVeUObLT`HnkDpFQt=`SrUSl\\jxMqQ<QE<PrhUr\\nZAYN@k=iQwdOS]JYuvwLNCeKDANHHwuLXV]sL<niQnJtk<eVjLrsLPhdP=pYwpLdluiuYahVmTpp`S><w:@UwXT:NhoIp^w_fVgkAtMf\\kniS?n?GjOWugHjaoh@odNqdbV]ZquvgbmPc;isgVkqPmN>kvnlX^y`yoyQsYY[pyceIiah_SxnTnyYQcsAi;p\\qavmQkVyqW_wsNrdQs@F`^yiA_wsPjcIeinjCHbMydNFxNo[qywiArZ?d[ay?Hb;ncPQssYkOVkP>pxpmhA]Eh[RAd^>leVtIAwbX]xNfaQ`V`m:NlSX^=FqD@r]n]eNvixqkvkAxxqH`mVwAyoxoyD^cPfo:va=FaqxclorJO_p>_Z^rB>jQgvo_[bau@Fsgpk`WoPo\\cFp`pma>xho`qg^u@vAae>^xFqo]alK_wgqw]VldVfAPZ@Gj:glUxxgph]nvh^[]?hBi[uXomf^bhbixs^XsnqilP^[G`uqf:vV_TEiCcIyaYxiMDRkteegHwxIcBDGfksEfmSm_BMEwfEFJGs`OcrwykQG;CWSMYmiFR=WOMrfewnyWH;BV=Rg_TTODFeEXSerUwjQri_E?SCHKDu_rdYCSMV^Ihf_hnKefmFFeUVsbWIW_;BQMCjOx\\qh`eelGfAUWb_DeQDF]T>;YgKIAoD;CskITAAfFWhbOUkoFlIdMyv\\_S_=C`Ks\\=yR[E>;E>YG?OHpwT=AchmwJSWxKbu=tesIvqirYGfwhRcRPEVjoGJ;Wm;tuwBw]XhKGDqEdQfEYXP=rHAggmi@[dG?GNQGFoeUGf]EU_;xjQBfkBvkxaGGJ=dTQeYEDJuHscWnmGneUEeD[UuvAeLUsTIIm_yd_hdmBaqV^WGAwiYcSDkGgKBrqXmgc`cyxkhtobpeic;FIacTAVqWR]mHMqInKB`au_=TecD_Yyimxref]Ec=CBQ;YqACFEiG;eqOUhsctEf>ugqGrmSX@cYdcdnORlGvYsV<sF>;u_?I_EeKgES]H?igXWYNgIfQTpaGoGBoOUVcHU[d;=xu]XFwS=eS;Ub_We=KsHoxTcSfiteeESYGSCrkEg;Sf<aFGAD`uXJ]VEmC@SigqFdCurcYhcWbeGXCWsaylyfHAvYgYcYcYyxxqc@Ufl?ulqrGWE\\WvYoWy_fTkyMiciMThyraqUWywWqTPmTjyFyMxyAraiWCuxEQud]BKAUHOTSMV`]BtUXmUBjYyg]rnoc^WX_av^WS:QWF?Rm=WJIciuiu_byiyyAyeExoGyVyviCCUwVISYheTNGD>_dc[wgqE\\UYaSc^]i>oR]gCUWcR?fXEcqouTwfFCr]cer[CNIifeDuSIsCdP[C`cCxAvyGynkBvqX<[wt?h`aB?[cuwxpChsOeNwvr?cGySWGx]MVD?RDyVMoeyiiwYRFKDU]uSQSCoWdQEjSrU[hCSRaac=gSTqEIyW[OxHUBCAUX?RoADHugOStmURRWitky>uriqdZ[T\\WEm[hLcrdQvH_DTEE>iwHSfNaGL]rdWC?QGFmTX[UWiRZuU:EeXwYpQu^[Y=oGS]i>YW>Kg_OiB]RqqIT]r@QS>Mh?GxSGFr]yHCt`yCHmcBgXeIVkUUb;vNGDXUc[wcEwtMmyHmV;=BBYwS;i?SdmoHhKfl=HZMIkkYh]EmuHaeFb;HrswCaRkkdVKWReiyOcBqRF]vGktcIibSipsi`kIrkRtmiToIeqgXqWkkXm?ig?CHqcBoRIYgHUGN;Fs?vDIu;MFLsRneYA?UneBh?fQCbkIFD[bO;gsmihcVVmVigU<sRtuFCusUQbe]V:kBUgbxsgLKHCadn_XdchTEGTstecH<;yP[I]URjeCAkeBASAOFE?X`Yt^wxpgybESlGBHqDrWgbUY[EU@uTl=D[qIteG?CBhwFjuyw=vvciqpkV`pkuvxlStEk[QtIelQ=JAQnBiWiASw]rwlQ@pwvmT<tLEYQpTkYmtK\\wMDOBqjphV[\\lQyPGpYopJ_`UL@uxIjj\\YH<RfDJkEjPHrWUVk@rp\\QFEuNPRxxPVix=iWAik<mMShtODWSmtu`QN<Mp@XnhpPIl;PyN<TbiKJYTJMWMiXMmrsp\\HhcZqgmykDoZ>Y[ppkHvh_wqPwUERc?S^[F@sgkWEioijUxAkuYySU]hIErxydRMtsquGgfVOg^GiasYecx]qixyIrYJB=vPPlk\\WAujC\\Qx=q;xPYayBtmsauFloX]KjEuN]yUMYNemOlqfTjf]RM=qyuVUDk>EKi`qktN?uThQqSQuHQLj=oZ=Pdhv`tVGtm;XpLEW;UR:HySyOXELCiVYPj:=mRyxdQTVtYoitA`rdUo<<umtv@DPpDvOPu;Hs[xlOtpvPMp@Uc=nHuYAtRW=qjeYVMQk=U\\DoPXm\\urjuk<DJyYmwUwsMYPANwtW\\aW:pk_EjPAnPXMrHS;qjSuy`QWVdP\\UnPtnCLQtiMamLcaXK=JVeSZMrLmRuHqa\\KYhWExox@QEER;qN;XlqIdfHaIIe;FZi?weFd<Nyt^mXN[Tv\\@gfnWfmwhQOkcPaDqeno\\WNn[`\\VWjH^cWO]QhiQYoGGlDQpEf^<^rhFfeiv<gctfb=Vfx_muovF@`koZenttHmsW`uy[g^gEwxGhjHhnOYg>WdYOij`ukoh^n^HAnBAvNAnegfj?mjQw_HcR^o>qbUYynxyD@`uQispcSHrlNvUG[fQdpWfqQajni[OlHYdivoaip;nZAHe^wj<O_ifumVfQxf^waaNrRXong[MAaDh]osFuw]OS;AScWt\\=yVaFFqGU_XAAxsShHqsywsLyX_ewxYVcGGR]IHMuimRnmYxqGl;he_CfUFJQJx`Ju=tAHmQxWDmV:QpHtJ;pPm\\Vtuus`R<TkiqY:pJ_]J`uO_MlmTL\\YRYiodijLAS;UX:YSZLQ:PLWxU`\\L@AxG^jkYhP>t\\`kZApR_r;_`<pi\\?xAahxglFoZDNs@^yQnsK>_q_ymicfvuVNp>hpEhiDncSixGOf_IcD^`POfqiiBhsyNw^@x>>pTNfkauSnpUWo<qakFZ]xuYIe:?sTPaipii`d^@pUQsNGduxyk^hWOe\\nd]AcNwdJOs@AnoPac>xbfb\\Pa`I[XwbAN^mGoFqhRnxT>yIoaoomlpdIy[OHrYPu[vmDOayWg]Ibbv[X^a:Y]i_qkyxdgi>OvKQnU`_QXc]qywybBafq?kcw`B>[larnh[jIaWAoKywMIqDnppF[RIkOyexpaDvkQac>oqU^REd]md`YVrWyk=S^[EXqr`curSYx=C;seWkh;SF?scXEdk;UAyc@WX<;sfuRFYFJCegKhCQUeGhAggG_djOY`]uMSHx[sW]E[kxfudXwyxKSAWu>qgR;rq;WySIUIE[=ufEVZ=HeeruwbUaEoKI_?ylAHTOh>[tZ;XoKDBSyAgU\\SBkmf:Yc>AYk?UTwDgeGfAVsITR]vJGvkuG@oF@;V_?r:IEBGkbLxHEOQURrUN;PTxPOtDq;pxAyPxelHxseuKRhNmUOcUpPQlTAJADleuoV=n]QM>\\XI`VKiTILSSPPXtYvPj>qSTMQm]kpTjnMoj`R_`NpyWoUU^Ix@ep?=JS]jD@MyxXBYNLlKu@jp@ww@PbpPbAQkhsRlPXtjBhMpDvF<QK<mR\\lt<jPAo=PmXyNyApvAlDtNK`uH=KMyvAAyu@Tg\\T?mK\\yYm`P>QPEUpLale=Prmjxtu[umBITfDPk=J\\YWCirZisuYO>awMLt_XVjHmyXoaTWGqRR\\wPDO>uTb<MjELPIPNIVxaoAXxdIu@DJsTSwdKDlmkitJ@jwHtcUj]=lHhRQAR?YTt`PdDK^dyTdp:lYLPPBltTipPUSaaMBHPiypTQv;`TDpNZMxnmTjQPmqpHLyc<Y>\\VL]La=[_>hX>cGGoV@ne?pvp_ZQomPetV^JFeTHn:?r;Ydg_`[xmXYdWP`GheDn`PIv[FlBp[B`cnXon_s`WcTy_eHsnNx[@\\NqfE^[xHjHw`JVmUIXge<KRyceusGFQGmWUcqXTkGaAdVue<MIDut<YRayUJSI?ciGiGwcyvYIxqEOCGZgeoIgjyIwyXyIIn]dW[yZgc_QUHAvIUUlsS_ceiqWVybIiiQyuIYLixu\\Iv^LQW=L=URWpLj`S`@kihYgyOjyLqmq=dpxELeUWS\\SGaK\\ijQuVjlPdqLC\\j;qqxxt@]Xa@jW@XHmTLpQqQwSDX=aTbMyC<MeaJFiLv]yZUJcyoNhvyaOw\\muPQ<xvxdPedqniQIMkLelpUKuDnflXpPPJImn<qt\\wJpXEmwREKKTTH`Rc<RbaTLyVYMNP]slHLUqMvtxcYpjEYgxSnEywDVuIkbmM[ATTTsIlp_mohhmlTkmxT@Ena@j:ANYuNJDtLmNl]tG=jK`OJ=ne@rdIpZYsqpn>mScHLrmvc<n>uXlLl<yvMiN[mxFLx]Up=@mxPaHNixvjIYvaFvWHbygwk?mHHqC?rPaj@XjSfZVhs_h]\\olD>mgqb[Gy?rxsddKrC]syQvEuv^AYVqIDQDJSSmcTtuWEsXP=DXEcD;gIgeUcrZcVwctDeCuar@ctnesnqX=ChYiUtohsEdamgymx@[GhSc:kXKosmoRfai:=RDAbPoc^]bsYeCgiIuUySBuAbEMCowS;[e_iclmh>gtuWGBaw^cBZiwxuDkOwncBrOb>;CGcBTcGkCWXyYhkSYwc=AcCWeaeRquvAQEvmWVgSJIHayuwWRfSIH]wWUb:aw>?Ss;GoESu?GQkVGqYq?wnisdeExKCdShXud>;btEh\\[cv_dGQchws;ygTGGBYXgIr;[CFqS\\weHwte?T<qByYd<aWE]FQ_U^KGSEDqoXp?couWWiYJIhTmFJkTT[xJETpChAaWyoTA=vdcBZueAsbnqisyyA[uisS;?ceyEoMB\\asAyE[AbxWXHGskMIxMUR=IQ;WO[hYcIwocykWp[gmkC?;fJITZsgOavV;u;SxjSeKWeCweMqs`AfuKT\\=VbacNkXMSEE]DbeSniijCTjStCueyeFU_DEmB=gt?oG?oBWUyo[itUw@yC?kxlKCmAxjYyhkivcuxECSkIugExUwUuu<ifEud>mrsafU]GPSrUwuryhBcbiUDRyCDSXd[vUMtaiUh;xbcrl[Y;UE`ojGEwmPs<ToMpka`NpIXB@t@MMExk]`xVQqn@Ql`Y]hto]VYdkPENgLkoQSUdRtiQmHWqxu<@rBXLtenT\\qRqqSqwFTRYuUHXvxyJeQLn\\spMVdIRaujgXMoLtyxO;InsxOWxP?`S?]WV<UautBalgpWN<k_ylEdKK`MR<TDIyT`L]EUXImvtL>=VNYtk=kv\\wFmn\\ArNtVYxy?AKlHk\\@PieMWTkgHW_ElGtKHxn]MxmUWN\\VRhXm<MuHKBiOHTlNtQe\\r\\UVN\\orTNB@T`=lChvZHnaasVEMAxYVyNwxxfHOmTqiqYLHM>QRC]Lc<uluJGTs<]Oy`lmhLS=L@yv^tw?PJ@TJgXXJIk[Hu[Ms:]s<QoSQt\\xwCTNIULm`KGyWDEnMXYZiPv<K@@RsAUtEtuAK^]Kl\\l]upKqwBERNhVrpjA<wmATDYVoPXW@rppO?AvddJ>ar@]RDXpH@jUTjmXnJQkN`nNXx`EY>XjM]WsUU:yu^QpEywTep`@PriQttTXUs:QureoJmnfLnDtvBANvYp]arhhl\\tjj`n^TrylKH`J^YNIxTKunaQXIuQmdypdVPdMmLpxLJFeKnlLMLwSQN\\UKe@KV]m?XYtMRTqMqEORIXZAVc@[>nf_Imoh_D>cg?a@qbb>vrabPHfsFkQ>ckwexw]WX_YXfdGiG@mpI\\no_Qwb]xnmwaVYu=I^wplQVkk`fOw^Zv`HnZZo]XNlZXrixvYi]fyhxvmwieDQsXn_\\xayX_=OtsiakWqavxfYavY^LhgBYyZ`coAkXSgAbw?YHsStGx@ixS[yqyyOywDgRnyCTQS_Odf[gvOX_Qcr;wXoWy?fFseuqWSmf[uUWky[uB<mHKUXKydNwVRQsJCD\\eTv?wDGrTwy`eCYGRhyRSAYYwiwify[RnkxTkh\\uu`_GZ_ckWGp]hB;IPmEaCw`SF@cR:mECgV_=Urgtg=diCIeUx_QV==RvQsGIHr[u`[xKiv[WUUCw\\EEEYxk[IrWi_[SVGusavSsI@?CBII:;sJQX`=X>qvMEX\\eUCQdjkiQyireSReIacBOOFk?XtkR^uFE_EeQw[_cn=urubV?e`;BYOEmUcHuGpCCnUFtWUHCC@CG\\uyUSckCh^=VCmR_WTLIHlQvhIgPQGc;bbeBVUhcOd:wii]rGWEiweQ;d^Ui=kIaOUsGRZieAYvUYWB=TP;r?eu;KCRKSWOU^GGhue^=VQAeo[r<cdbQFpqInSE:awgGWc[HloGYCuF=SUYfF_EViffWb:udQ[Usmbw[r>yf?;fuKXUIH@kfH]BfWDUEGfmIDCsTECgGSecg@Gv_?H;CTNKImocx]xLGdN?G]CvmeCLmXZqElUcVEt`?bnwRIGXaeSEOBEMXmkcWgfgEBZsvZcBucXYcia_hNQFRMgkCYb;YM=vd[FmaXXeWF_USOFJwtE;TOQcO]DQqh_;Yb[HdqS;yHMMbHObNAvsISseIAsEWcUysrRwU<GRosU@qxwgVD;Fo=EwkXsaC=uxQ[rHAb__EGGuZcUpcGp;YEidZMEjMVfIyeODJmCbaiqIGjYXqeCE]IGKyxagywXAcv>mRR_YuGu>]YseTfEdsaYn_D^[xXuFTgfDKxUEDrwsHMtxiSLuebMTJCvXYyL]g]iuMysPUDnesTgbL[tPUhjSyxcc@mYagxr_FB?HUoua?BLoeYmD]qIhiiImIr]FesXsSvZqIwefSachKyhghbaefcIt=easr>Mre[F\\;cg]s=yHxSSAiWCSuaDLXPY?qu=mLiAnFQJr<s>@x?xtXhy[@rXxPhlXmlLVPyZyy<xLgUOOPKxpxoxo[qtgXULyWIYki<yklJqyn;=vhiuuPxrhtdermysytO=lkSHLvAoUPm:=V\\]yF\\s`tOPyPiAVcEy;DptqOvHxSXPJ=RGXQEEN\\Exk<OtQqKdNZiUWMSZtmeXVdQjYlY\\UwvPXlulRXL=tKIdpHMLRptBHYGaUHLvOxUu@SFAUCPKkxwDdVFTmUDS^QlODJmqVghKaAjOTpQxjbuQhDODtxouxCUQUuQkPYcAN\\XmQESyqm^xvj<rmuVJtL\\Eu>ls:iyrqS]@JMmQWELydMPPjhxYdmKptpS]NGloc\\PdhW[ExKhonltXdjCHvhQrEEu=arsmtjUy_hqMHuwPT=]SJXkx]u;XR:YPkeV>tsyEv@@pvQPQIKB<SM]JJXqUXY<QrE\\JvpyCIJ>tV@DvjIu^eJfTPSmKj]yVAxl]LUUKu\\JDdJ;tWeDjftLrttXdWDanfdQ;@nPpu=TshDYtmKEmQMyp`=k_uXFTrd]O=DTZ<VpxU\\xxv@x;Ql:\\pCIV`lLX\\l[TNVIu=iqtQUD<NTujKtNlmo_=ocuqIaYciVbWoevpcofEQt]xsgfjFnh?Os@Og?Q[;@qKVnQwsB`sMYcSg]io[tpZfXgEW[fqhLVe>^vV>\\o^lo^jX^_CwtCvf:PaUHdn@ytoq<Wyi>ruVa<VyJxcRqyh`ZXpj^?`F>rfYlMPiaqgAWaI>yJycailXau@Pbih\\Jw\\Gwu>_oVP`BPisPZyivS^ZiomAG`Vvj<AoO>dh`vlPdrgleWlCYkFXvRP]?Xf\\?m:_qM?rqvk@>[Zy[^xfYxmRHeGF^qH\\<PjRvaUhy_plPOa]Nac>\\:hix_c@^xL>[q>krFgc>k>netTeKwxcVLsbvsISos_abQSd?UrbmRM?XeiIN[GuSvJcFeQrkkRhkuJOuGMItGB_OUAEUEuV>KvKIVAQxuafeACyOytYSROeSgy[wwCyflmscuCxyGr;vm]RaUY^my<Wx@YfdAEVIY:KSAUyfQDUcTpEtvMWSOsIGH];ykuHACBCWrkIGf]gI?Vm[XICc^qFweeEax?iw@YCiwe;Wr\\=RmAVIsVikBB[UqeR`GcKSGGsE_crDkXa[dMoioYHQkb?atFWu_CG[mdwUUGoR^]h_CVXauPEW\\khY;ejES@?d`?BKOSPgf_WdGStdidP_X_axE;dcGX_mXZISU_FmCv=CU;OUBaTkgiP?rUyYouCO_Y=MBAIeeSrR;EmESkcdQwhmIxI;cheTCgxmuBGocRCyEyUvoSFyUi;vT]sN=DTecDmrLuGPIT^?fk=SQiuykv;AsVAFkwVa_DUAu];sfqwNsG]YuS[bXkWEWB^wbXwtIYw=;CNSfUGSbAcOWgb;WkSrh=tu=TJ=BSsilkR:uYW]ydIE:UGsmwQsWL;ciYSueVrEXA]fOkdimRh[cCgXledxygLYg[ExS=XBEgJMGNIWQeCXwE@irIqUKgbF]GMadCgshqrmOTjmIZ?RRwc`eBb[U=qI>kVAgfP;rLODEaU@ugG=eaeiNer`ieOKVggijuS@[FBev]IE^UFcCYiKW]oC@uf?]xnEUveXv=cmuewgFPOCGKCl_G;cheeScyuIuW?AdVmu@qUeuChGh;Eh@=s?UD\\CBk_d]]FPss?gtdcVA[gcyCV]e>GrguwN[dmgFkSTesVmQBV_ChedNmU^OEAarJCBsADpIGJIGDMIRyF<OHN[eQ;RkYVKWuIgV_uGE=GVgY^kvQ]bGWhqic<OBAOu\\mD:wWLmF[?fqYHoYWYODGoe_yeWMIIks`kXecX\\GvuAGAIcv_g?_VVUfgMWVcbJcBAkhy=fZ[riyRyKHBEu;EBuyXQ;fw;w?oRAEUJcUiqGhkvaYX\\IYiaEXsDY]Y?cyHwEEir<]Rl]sN;DWKHOcW:UuGwGxMyOySF]yrqy`EwjaXuiB@[yaourQHpawCaR\\kSgAykmUSAGE[VVqwygxTkVwIufmxiahR=yKmhkGxK[CGccZEVcIFxgxHyULScWibTuR;ebxAhO=cKQfPsiW?RJqFFWWaKd=Yiieg\\Weh=s[?bOOtpqFxOyauh[iEqWTDUW>UixwSfyfZkd;qSigBisUFKrBie^;w@UXygSqkyX?wiIfOAIxWxOyRl?Wd=b:qXvagYMUrcdtKBEYf=EYiiIdoUtGBe=s_OslUhY]Y[MEtUcHMCfgT<cw?YY[wwT]DQEG]?WMqiVkYe[YNGRjwIHSIYMCeQfyCbSsElIsLktX[WMMuWUF`wtESC?SB`MbUSC[]WMIyR]U`oSk;e<_S`KeM_C=YH[qr?ytIYJaPN`QUM<x`ymndJ=xjYeqEuPweLPuoO=uydjcDM;=u=akGetAtvBXqMiT=Quymk_Ypk<mVemf]j_`lBQU>mYIql?TqNHpNAwwdxcPyk\\Xh]JHAnE=uvTs:mLRiJ:IM:XLeIX^mvq@tOyuGEr?IRZmu=ERceSfeNr@nfxpU`RHPVphUBxvZUnFLV`itEMxupPWTjytOPYvUet@@u^trxXL@MXgLOLiSjQt^`J[pL;hnT@MxpsgUwB]QcQJTxkdAxXhnmyxpms_PmgLSpPX>]Ksxj<hOmtxTdV;]uWUvShM=XWv<O?=W`trtLYGtqIXNk@PbMNvIv]EXHaPILY>hPAxwvllffk<@ZiHajFyWQtAweGgvZOnaa[y@iGonhGh:@fS>c:`mga\\baye_aoXgWpo]fwIYh[akrVeX^vqaZniphoxyHwPfqXX`>`s]i\\Rw^A?noAa_@tUq_OHwRHmHhZlpdMIgG`_q@feI`\\Xab?bcVmPHlBpfIAZWWip`ijPknCXkwCQwXUet=TfsdeEyFcUEQeVWyysy<YEjUYvserqIvIT_xnUyQ\\<raiOR\\KD<XmaKUmpyluXquPTy^mMq=yqUSlLWCLKV<LxMTxXMwhY:IymuvkLQvDjois?\\YjikiArK<s\\<P\\ELEtUKXSbqJFtW`]nExvTYx]MVdmtMit]djVyovyju@KAPvjHqF@k>Xx>AlG=QyasrDJiXTD\\ng]MJirfiLW]pKao\\DSZMspPKYxywxvZePUDTUiW[tRfxYoIXN=mWTJWtx[ylEhX;TXq=t;HqmmYRDksyxJ=vZUU@lx;IOaUoB]WaApruN>PYsHJUdMQXUWDYyauyuWZltehtehJ:YXCPN?djtdVUlJVHqoDJODpWmtBIuD@jSeY_tU=qsl]Meux=MJfpU<TwkXk]<TLTkaiThxJOYVbHkOyxeuKKeUIESeYw_LK>lsZXTdiK?MsVMXCQnbUxwMkxEPaTV:]v:@ruAMwPQ`dqqaKZxJuuRWtjCYj]EO\\qWVIUAMllpJpquqHUV@s>M`RYsuAtUik<assh\\nvbIXhANs?xsXgjKibSFZWx`eIyfW^KQop`n:WmVak\\^yj^^IhZcVkZgwXh^\\paoPbtVknnhw^[xVonOv^vd]>dNXgRPicQZ_G]TGfNIt?Al>FboHdiNt?VcrN`Nqft?]PIfiwrUomRvqs?sgNmrvfNffDaapxaX?nQywKoh[wb]@d<QyuFiCa]r@mf`vT>[ih^ZXxe`^l@xVx]AHaZiwf^`]CNWb\\QTBmDiexL=rE?D=qGf]RZgXReFR_vpshKyRfmU[cEp[dSEtx?iwMhGEUBmXsUdRQyjcBbSD?ccW]vPyh^uifgVoAGN;TR_Crkfuef;EELOclGBeatBYDgiy>kb]uiReGjeUbODGWfwAVGkUu=bl[EA?uiShn]TekDbSStuU`_UG_UwGGSSSQ_SqUIJ_W?wtB;gcyFSkC=YuowbUuThkY\\=faQuVyxHcItcuxEB;sey_IvksJwHxQdTcc@EyZyiYMWAqRS]yuyf]GDyMdUscG[irEvd[uH?FPkTxKr]_xdCHqQEN]X]aWgmD>Ycamwlsshct[uwjWhBarq[V=yEvYcQifAoYsIXFOtYYVbEYLAL\\uxXqU\\lRNiK]hmS`XqLtkQlBML=Unh\\KJTKiQLjqQ<pKT=Y<lS\\=to]OyLu@Qu]@K;\\XClNUpM=XTXpsd<trER@qOlHsStO>Ts>QkLIQ=iWCxOyqtoEpB=v<IOmxX`=vfDuftuGDNlPmJ<nqPYFAQuauN\\U]NrHHab_xcXy[Otd^^]AuIowM>sc@xvygWQlZ@rEppDGwln`Yfj_G`Ov\\LGymQ__QoN^_N@mtohDnZUHdD@mVIc]hnFY^rv\\NF]aWkXWplIxD`pnOevn\\b`cT^^B>tsp\\:ijNWZ;@aQAbr@^U?n:_fG>ukVydIiKphRHmmwcwgm<>txfZdhm?ig>q\\]NfTp`jV\\>At?Hdsv]xyaAnbXyppxoQ@ZOpoC?k<pZkXyevevoeDPpVysYgsPHl]>b`QsevZHfpCw^:neEid^xbx_ysXp<nrFNqANpDyxRVqN^b\\vkpF\\w?phvuEVeJYjlOaIPh`@bZXoKH_P_gjorLWcgveLpcVHlay_:a`ZQ\\J^fjgfjwgOXwWnnXh_Z^xxYZNYp_Fg_adjxdIo`aFrZxdgPloH[fFob`stG[L^m_>aIqkEGZrp_gam__]^VpLqoCqdCN_Mwr^hoHwv^HpSHvxP`eFZ:_yb?ww?cK?qPAl<FhXPZ<GaVv^jx`K>je@lx?q^vtixeiXnZQn<Ptholf@vjFl=Afj_]TVl?_gZHaEHwK@jewnqimNVpq`e^WcfF]NobM`mAIlRxqWNvjAqEnfD^byXySys;Iwlwi\\XiHhfsnZvY`aosVP^hy_=VryYmZy_Afy;NaXv[qnvC@afidxy[oHp]_nAyxs^w>xs[Ir\\ypkvqlq]`n_bAx\\Yom`ZMhu<qxs@c`VfDFil^lRxhcgr]xry^gAxgJQ[MHeG@^wYm_plFFjQYjI@ksgxnGflQsjfflvbRquFWbag^`yfJGfI@ZtFbSHbxFePHnfvsyGvl^gXWlnprkYfGP[kVrDWjl>jBN^eF[[_wVhaFheBNrw^wJF]`aniX[Dp__^odqe^HgY_uOGnLY_kVyfa^?^]=@u=wlBhcy^iNokmxq:>ZZ>ZC_b;_daGq]QdC?bFIuAgqVab;pk[_hR>`xWfF_^]nwnHvxG[IAqU?uuVc;WmqypjHb;^jQWp@vv<>khprZ`tO^rCXlYWrNP`mXl@o^VhlZvxFylYh\\sqjoygHq]RHwmXpagm:PisYj__nqPt>^]T_kWG]AhhJqbZ_tAX^\\otfQbcGxUI[^geb^rlOZfYnqpNMw@CuQEcRwYt[eLSs<cB;;EAsC`Eu_KC`[UVeEtoHcCeBIvxIDnkSM[w]mEsoUFqiESQRuybEJ_aRXlRqhKHIKyLveTQ\\xve<OR<oFPQ<TTWlKCdwRAKgQvQpU\\<VqTS[lpHERbum;]mwuxU`xSpj\\=simr_@odyqndNPEKvtXPXUwePN\\YOaxSIUb<oCavchvg=M=\\L^yoGQLByx\\pRiInV`sBQJhlt\\it>lrGQV?@rw@K]xuCTuSHL;LXP@jnUJHDKdXyN<KSml[EwatRSAJa=JtMs`LynMO^twi<SZAwMQo_MMPPllpR_hu>XNTymx<w?XwtIUDlwnmYneyqQOoEx=yu_QNmeoH`y@=KWEyt\\PAiqbMwueJ^Yysh[Q^QWVDau\\aXg_ujCYv]DnQd>MSl[DBYsnIYrcrUuUDOss_IhWYg?YpQyowSvugk=bwcthyYCCByYd^?bFkxycCUct;AV:kXuydkKIjEC[awA?iuItHkrHQuZGTe=hIiENcEYeHfKD=cS?QSr_yfAEvUBP]RpMXRAUHEFUOgZ]XLYc;IWQ_V@SiGiYViyZ[boggF[S>;VA_udqdi=Ftge=wdRuybIy:kR`_YJuxdcfiyeu;YvYRX[rMCUS[g\\?TqIVlqrB?BfSuS;xD;uvybUcE]uH\\euoKCh[uIwgKYgZuCREHoCIhsr[MSAaSDYhaqRuorEOcd?UsAVWSemYI<aYA?C:ixHcivksZ_s?CU_GRgKdImGS=RpubR_FWSxGwytiXDkDw?GMYydEDrIXA_SXoYYGffqfJsGCweHAx_GV>;ccYXekFE]DV;WR;tWSVh]tEeX>owf=sxwVXEIEcHqMFKmFkGYyUR^YDhqikKigKhvyiJCsC_U]ieG;S:;vF?b;qcS=Iyobuwcd]yxkuU=RhUIG=b^EbamVJCW<CVhGCb[XdCCb[uaqSa?bt]IacYvYRQyfCGcUYIF]elGfpehckeu[Wq?XFqgWGvn_YhWViceAod:WeeEGweYd;Urefm_Xd?teAwwuwVqU@WbHwVZ?r;AVV_UTaDpesxOHVgBjYWsyu?gg^?snSRikUNOvbSSpmBDkVuicWqSA_SeuDgKspkXbSBZqdDeF_MT_?S<oUAEBOAgOkrYyfaqgXosIeFTobP?bXIYkMCw_IFeb:[YI?ruAdQmDaKG<arIORu;ghuX<GdmQHksVX[fXYuGcB?sROWr\\cC;sFnuEkCGByYmqGFaGwIIfAG_KdBqbqgR`GHJ;fmStYiWOIVmwCCatnSBkwXXEdUUs_ETBobC;xo?TSieJqXYCvGWeQiV`?xacuRYRAwgkIWEmvc;vyyydCyfqfQ]vsCf[?djSbiixNIyA?unKux[sHisZ;UEKV[Ewxkwygyh[w=@KFDuZxTcALGxLK`kPDPwErITmMAjPqyX\\m=lNR]mt]WgpnjIxuYWjXqG@mXXx]lLcLRe=T\\awoAnn]wnLWu@sM<Yt=kcyMj`U<EjZqK?TkXMJim]>XjUVeZ^xnqhEQwSIpEYbJYdjHv\\AuhYlp>qWQwXnpQOvr_yHQ_;pdMnZEp\\wVbHpcIfispccpiQFjXPcTi_I@woGe\\wpsNaaW^_?\\ixeUFlO^pv>a]@bfna;_oUxyGAjQ?cN@_:`t?^rAyoGPrsNv\\`hXg_S_kHXjBvmifaaWvpq^;^mDVfqvrCHfqIcZ>evqs\\`fKnbAH\\PNfxgytf^D`acWk<VjKig@AwGHcsv^P`grXw?hprqbcHjLOpBXiyghUF]tv[=fqp?wLA_T_Z@yjK`kNNfsheLHrvXfvnlOpwWvt^AZ`oeiAjcVZrWlxOgkq[EhvZFdH_\\KQn:WfH>aBHkIXc:Gw[?Z^XxQWdJVl\\p`IFZanZYfqupcZVoKFua@\\`>xUakCQsSofxQiahZdWoKf\\D>h_Ae@neTylCHuqfmuIrXwn]pjm>j=pxxNunoeKxkPFlUwk<wvpPrkfa>`a;>aUg]j?^\\YxL?taYo^iZdGmLN]sQ`fVv;>gWo\\RwrAFdIgv;YkqNoc`_HFwTF`eqaZhyQAqEGkhXbZIyEE@ciB]IDKC<[yX=IU;dcKVnaifYrO=WvmSbgePEtoYHNGBjyv_SbEiCtKVyqDtkiKMyoiwPuBncIDEyh=UvqUbKsOKVlIUDkhoCx;KHtcULuuZirR]uXGs?IX]Wu=chKAcTcuEGdAuxkyexGxTkgXEilYFWyU\\ECkMslyS;syuuHhKwxcerer?ouNMG_cwSwIgGbAQI\\eWqkgySCy]XFsCPsu=aYdUBdSX<Siuurroy<aB;kSI?IfMsBORXcIRiu?GxssE@wfw;YrItPkyQwYsyDB[cr;xSwutOBwGSgKIvocxqHL;uIossermgeq?YrscieYomUfaClCxlkhCgyy_yIuWBgglsGNOIcYWM;TnYRKYg:ehKarHCHTmhl;isYWQ_foOhmcrcOc^qV@ChGKVeWwcCx@IWNWeLGVrsbfAEVWE:gsieRiuSi_DsEUdChLmR:qTJIgJmBeuEiMS[ot\\Yh<UWKAFMCs]?eg?rx;WAgXZWtsOd]ktYWfAiw]oSFQTpMrW=HFqis?ETagngRysGM=DSuiwoS:keK_G^]vtaBnkFG?e]GxZexxmxDKhdaf=gVY]u`sCB;rw=etEyf_yhGo`PJ;@WaeRaPkhHSm`u<em:em_=m;Xp==XHHy>itNxrEMP:xm:YNgUkgPX=TmiyoBEXRAvqHnYPjLMXcuJSAT<MYjiP>anopP]@pkqL;\\XHpMq@toYmR@xyDO`ppc<KOIkwXLEinfQOk`p?`sLune@swmW>=Jx@LHEnIUtSEnUyS;AT=ERDxsoAVgLRFytBHocIR[EwV<XdIq\\lK]IM;lVPQtsiPoLYi]usiPjUvFDpoejnXydEOuATK<xmEVRXjiTLTPr`]LOyRe=TT]xJUuGAsh\\oEmVCYodEMrXy^=OCuVrHS]dmAptiQjc]OZtw]ApwxNWDQuhvT`J^hydeMGikg]TbTJbYogIVlQv_]mbTq_@pEImZPk:`mGdt\\YkE]LjqtC<uG<uUyWq]OPxKIpmnUtnESjQTM<yI=LwAyoxSwpNSLuIPpkQRDmVqyQGLxpMqwYN<\\YXeNEyQvHXemvPqtP`LhuYTYLhiYnUPsayY]RbUXEtUwqryxjx=PIdptxJgmmAUsqHVQunGLlQmLjQKumxlHV:iq@ER;xTXqQrAP>@rbXJXAnO=MSTU[Tx@AjRpkO@l^lxwawUtVjLP_iRgPt<iqquPjHyZuJsipNDjgHMdLJBqY\\EkSaTS=ZZOuEXgYHqb>vgV^qAuUfrg?jMYw:goKAr<Yqe@ki^^?^sgoeE@gYIc<fhp@dZitmp^aHdDxpo`iWFxo`^dal_^kVg];xh<ikxohL`gpHwqg`<Fu`NdVQksiks_dlf\\SgtuFyVa`kPbE`plNhaadQfqAf`;vlLPjMIcVXyZY]jNiF?pI@a_@kDagrwf[wbtXer@^cpnai`Di[sIv?_fxYh=AhIXi_Xb>Xigis=`xsX\\J`]LurexeqD?scfLU:qUiaPKmjK=R_tTKPVipjpyooPMJYSyXOAQXBuoAIV\\<nYpyniNclspDKNIMrUMN\\KsTobpvDAsheNKxuFMkN]vwtQDTsBxRtywsTNcine]sm]j?AVFP`gQiEnwmYROHmyDbkRLee?gUAAdpYSOGSikioct^cYY[w`[CVaeKORfsDgex=gEiwEH[E\\qtC]CxKxXaib=y@KyxcdcuU_kH=WFjqvK;dV]s_irTeYNGwOUFSEdPMbipKGXs`lL@\\O]AXZLWQPobeLEalHhmZAWuAL_ATV=jRIXkMKoaV@psexRFyst=O]LtKmt<yyaYPCYTpIVcqTCuVIEQCEuNXucdWP`W;ArYaUhypaIK\\Ulilq:hUtqK_xPPinMtj_mmXdRaXScAxrAKgQRHty_yvxeLxAVjyRxxm\\Ixr`pXum<hyc<vyiqUTjvTJUyslxXq]Vn=MyxvryWkpLxhkuxXxQM]TXP=oOLM<ltHTT[eUlUVcDkrqXXTNa]QRlMlUnsxqAhwoaPp@walMgLNrlwJHmr`w?uMSasLySHlu;UKvYVHExWIwQux[ijIym]lL`yrdYnRlxBHneOyU`eFH^?iwY`rLyxdggfo_>?nmHgZ?^jqwiiwQ`tuW_NfbdW^E?ndPrUvirQ[_?[fIxyxj\\Op\\raitnGU<[styXPEwkOFkGsM;y`cuR_YpMd<?bC=upUb<KGemxFqyOmRG?woQC=OD=oiZ_hvMh_IrlYIEQrhaT@edNkIqUWuOFIAXuQfg;WA=d<wbT]V]WV;KuwmUFmRfAiV_GM;biMfRSsE_kx\\S:yRuyVZmTMmL:YoaEmKYPZqTB\\mSmvktJfAmsas_DU_\\slULYtj_\\MPpXdHyDlxdartHKZDUxPMvpQCtxn=RnXWPhjr@lfhXS@VF\\XTiYmYuc]rhiW:AwqXRaQPEQwZAy]hSKyp_<MK=J[YXhET:<VPlwZhYkUO`tofhlTMJ_MPVhsjyuFLwCXYeAOLmlZppS<n`@jJPmYawfPt_<tPpwUdmT]VVPQWUWherVlYwQWaxQYpomeOO=lF<nQetadUs\\sDIY^@VwllKPQBXvVAQ?<N_`KGtVPDtIEmFuQ?TNg=rcTO]UUnquSmr[aw:xVIqpRQX[LuSpr?QpIuK_uUw]qP\\jxyUWEK=UTuLrBIus\\mJyvPxuC@NAYPwEkSYwgqPS]RPxn:\\rlLlPIW=PyJaK_enDPUhtR;LXMPJqhjlTNuDlKPO@ioP\\ur@XxyrxxlxmsfTqHEJyyvgUVjdv\\hOuuwReVNXuIqVMILrimYHYPTqqqSjAygxx[EKN=KViu>Qvt@pvAP<POk\\xcYs;<UVMYNuXSQqQLxuujIAkghlnlTXdRKxSUdrDEmuDSHaUS\\jXQnP`k:HjAHr:XuydKpdOhpqldjFMn>xXyPpZTKfpQwine<pL<rm`JNPkaETTanFEjRIv;ITQ@Ue<XKlXfQxj\\M=lPSuOjxYl=NZyrl`k]=pUdrfELUukp]RmutLmtZXpciR@EUuAWM=Mupl:uluTVRhUQEuTLjXYkqmV:TpixmO<jaUo=hyPIjn=sjHTTmXmTj_xoVyl?hS@tpSlM\\MwAtJuQttEsxYyLIK]XNpyodiLUdjTEn@twSAJhdy`iKKYySmqcPT`ArgAmFQuSmP\\QrfUje=MnmU=xT@EOM=XEQWPYJ\\uldTk@@JNURf`ucdrHaxdOfINbJQuoQr<IeIyewqt]FwDHdJoZ:awYWwjFcjHs?PlbwdU?xYAm>HraWlOxnV?[`GcDxuiWkXWmr?q?`wD_bdWZHH_y`oZhfEVZhYkaAfZVoMGwtYxa_lx_q?fmIPZoYhmPZfig\\?vv@fhhc;FoW`oMVjIAcQyce@cSiboh[UahJpeeO\\P`sWGctIba@jxpuie__sFGBuSXyUbLqiX;EAcU\\mdPsybERPMDmERUMBBcVN[uXIiAQtS=IHSv>=B@IVY?s:]g]YhFuX^khCcGVCT:Ovt?ReEHFcRmADpYSaAXVYX<Er^uD`GBI_xqyTMII^QrKCsP=ImAXHgcDeE>gxoEIXoU]kBfec<EDOOTCKIDqyxIsi]yP[CykRe]xMixnsIcqxdYtgyDF;xYOHbmdnmYPYUIuWQkWWUYXSVcGEfcWwKrUyYpqHTyr?KSMeWr?Ym]TPMblAfNkvjKVncRF?TcgwAirUSfBGDugymyYwIff[YtExmuV[whp]su?Y[ycBYRwsSDOUbqdhqcNcV?kw[SGnaBnUINGDNOcG]CHGIj[I]iRwOt^?vKeDUkbWMIJUcR[XnIRR=BQGrHgvUcfCeFqCXdUGeKEvodLayUuyf]SvsvscdaIcLegDsyngrTAyhyUVYfnmI]cbUIrEGR[=cfYWIirSmBjefLeS;uh<OXd_F?xlyUvTDJBhJa\\rBXOnmMOaX?DYXxN:iYYaxvmVrioLUTDto;YW]PtyuOmiYciyehWTEle`qfMu?urRIqMLLpys?UTGpu:`YrTN?euxxNtYQeixTLVMaUF]Sidr><rAyUutKwXu^LxOtX;ApHxsy\\s<Iq_TX]YumAOmhPohuBHrUUtL<uRQw;hvEDxIIv[TPwduLynIIu:=x?HUcUYfuLU<oaUsnqYDPrrhnRMoeAyUyPl\\Ujex;iXk]Sn`XSLSH]SWhPvmsF<Q:ewL<OAmqmtktdqXASSMJIPPF`qmALwLtDEo<uQwAXJ@tAdUrDwxDRgll?prgEjiinEdmFPjmTNDLmu`XhxJv]sVEKaDw<LMCaQT^qF_ZpQ]YV`uQ\\?>\\?Nqc>bpA]tGh<?ni`nfijUOdI>wTidcQiTnZA>wTW]u^oTpko_r;YtbxlXqiXFlrpxpYqjv[rgf>GfYPcGpgxqsXNxneUKIACHxUe?Ct_iDVWXuEXmQx_yEUGumeEHwtPaehuf:wywuHpiu[UG@weQOVIGs`ebkkRfWdRoVquUScyhSGTUyA=tKSb]uuKYv=qcxwGnseo]XtGyqwtLAYhYXm=HS?E:YXruyGiF>krW;X?[g>KRJsSSkHXSVAYs_WuuKttEY_QwZCpD\\vLeTfmO>IxKyPQ=vnYUj\\Y@Yk[IUi\\wnyWhanZqsKlXuas_MWBqWaAXBukgiMW@Nkhm?puc=rVyn`AvpALulr[DpyqkvlrppJ`dpD]vWptHmL=uTAHXmypiEssqlMhL>mL]LTZetjujCTU@TLetv:Urgul]usG=SyYyxYLeYVuDjaXXLYx>aqf@jOypP@lTESBQRctvrxJCivR@JtTWiQWEpT^uMh\\ylYX]yk]LtHIYoyXY=jHhn]PUU@rbHjTmp]TuNPv?LKREUNHYkLMQTlAeQRlYxmJTUm;MQh=qHErt\\YYdyRxRW]JLXyB]QTqlAQJIaSE=pZeox`LGQkfIriHtREkkTtstl\\DUcLw@tUttN;yl_QMgxtFdkAayWIvX\\UA<kw=q<`yT]KtukG@jrHjWxx`in:\\sgell@QEpQelP<UVPxUTqS;aSStsjyViXkn]r`UWu`l_ApV]XBErb`pG]osuN?pV`@OfQUY\\nf<x\\ajRIMm`MMY^JVufgnWA^?heXQhIp`JasOHkgxkEpgYo[?gbUwvmovX`yxOaIfn?AkhnmXobaIuOfs=I`T>nYIoK`eTWnZxfOVe`oxCIflFrWXcFAyAnsIQkfXlWa[;GN?HteubifyYxtobMWd=]hcSWUcxtAxuuUxiWkwXxIXpkXDevkobaoIryf:wy=Ce;SBNSidmUyoYwyVxmIqwwgKV]ItU?enwW[yIuiSYCHesIXyeIEVSOTsUy_GFrqRgAwO]XCabKki[SrfWvisVjKIeIrZAWAiGLAwLIt]IEKiySgiImUB;rhQH\\cebCVsqY>kCiGC][BdaCr_uessLys?yD@AdEmTKCfwiIxuY=MUlScsOiFUsToibydkwbh?fG]h`ExcyFjyTMMiYySIYcvwh@?hlUCP?f=KYQoUPsVkWu`qCWSc__DqCblgWJQGFSdE?gtufKkGDaFTGe@KVeIHv;ydYB;[y;WhxEWi_sJmtZ_HNAGU?tDStgITnAS[EHoOeNoxGuws?BhcYcqbnufj_WMUsPUIySwCCCD[YVOSl_FL_rZitK=YIqCDABHkgM;fywBtsGeywPEVviFDKCKwcq[rRoskcwMOFkqsWgX;kCPoSnKFYAE[OfqIU_kRYgfZ[uiGTZMyEst_WW@GRVwsgWHwIgMgFlSxYEyDiE[=xpGCiKVYsgB=BJEtx?uPGbQ[Hk_e=aWwOS;Orj;w>Axeyd^IX@kUS]dO]g]_iMoDCGcuwXrAEoMV[qb:WCXGwcEeQUsFOiI?ruwc_mf;uf>sfwQYUcsveBgKVeqdCuiNkeMuhQgfUAcQexlWh`uGgySC]sVgvnOF;;IQmc=wUrmdpYf;IxhstM;wwatTMhigIX[FIEE=st=kXcSHlWGoQTMEHI_CDgV>EHT_RsCdLSs_UHIuv\\Ii;ctHuFKgdXWf\\IRekV=KGc_gFYsOUeGMtsWrPAFuadkkytYXioyBUxbkiqUvuyda_UWOHvyU<=ryMWG_ynOVIqit[i^QewGxsqR`=bayrrOgY_S`cr:ecQSDwcHUUyS]Wv?vpKioscGycyyV\\Efc]hnkD^Ox>aWgMUvSXo=BmEi`ku^;VwQyqmtkSyDaFV]rLshPMdLiYmmw`Adr?Wp_bKsEEicFirWuC;[Xl[U:Qs=?CXkHpiREyEuswAwWRqF:QslebrItjuXICBXgY:aBUwtBwrY[bjytyMYQkw[SE@?WyKfoUxjeWXoB?]gLAvNYr<=fscXg;cRqRPSxiyWDQwZiyG_Fx;yIwXk]sEkXB[cVWT>aRimc<avnSckqt[KIWkFWaexUhoGXd?FAqixYIqCVp?UjwB\\=gkQFdEiTKxK_eVsdeEBV[HTar@IUMuxK;uUoBfOhYktCitn]UGciquvFwS:IH=EBeUxWgVfiHpAVH;uJEvCuTvCCFWca_do;gggECsbIyGq_d@eHOMbc=s;GxIuUJkVDqTBSYn]i`Efh;rQaF:Yv?[TSidrkcbStkqU[iX>kYsodGQXG]YeIu?KTcGwQcExORSoBq]uFgY`QFFUrhCd:OcUIENUd?MyucGlscLos]uhVQwjOws?FfyV<OxSGX:ktCeEZaBtmwlEI<_h<oVbSfbog>Ef\\iTHaXf?yuYCL;HtEC:id`ocwKHeQvV;BmUxUQF[isvyDYGDsgVI?bUgWKkCTWiRiVe_CX=FPmg]_hXcR_eIhSCj_WQoFkwSiYxZgthAsrKcx;GWoFbCG]AvFMhKGG[?RAaxRCG]YfFgwBAticrkmda=uSYT]uHEwBy<QDTpYYRS\\TKPj[dmMDjyTUg<pIpK=xQqEJOUTSDUOXYBErgir:AMXuYxijY@swYxnHw\\ap=uvQ@LjylPpljPplPjYIyWxuKxymQvdlmmEsyyV@<r=PT`yvaiN?\\VstvvIymAyZYjI\\NB=ugqxYPy?ISaXXr]Xqyo[xQx=kYAynhKAxJh\\o?PSrhyrDKMHR?Hl[TPtEKjdmDpWbEetiuJnqPOu=Ps_?rmxgFAbe@nNWmL?wHpdYij=ObDn`OVdeYykNaaY\\unv?Yqu>htac\\I\\IqoT`wOxi<?Zp?ij__fqlugyShiAQbsF]C@ySxuyH_aqpkAadf_ZXZ]pcRfgIOyVI]FPqH?lVasEHvTImaobZWxnojtWic>gfnirhjvOp<p]<NulYjjNkwIhfihoWb=_wYwfm>tcnx[f]DOsb_rCx\\``jsOxGVovFw;Xu^YjAod[PZs@hHVwiwoJ>l^An]`[?gfPAnjXlQVxmnwtHv?OeFNiFAaSawffpRV^`Ge?aveyf[G]pO[=ygD`iMgbuPtkQrcvnE@oaGwvPn?NuYp\\=ysIWrV^p]AmO@jhXf\\GqDGga_tJIxrXp`@qOp\\:`pIWiC>ubiaXfmZnx>IeNX[Y`[rPa<NyXgoDf\\DNdFasgu:[XXSgVsiUTpeQrJ@MoHkYaQ;<XvYno\\LqTtJYYf<WKiPD]uWuLWtU[mwnHslTOaiJm]UnioKmn@IRv]yqlm[<rqDSQiKamJvQqwMuQejRuQ\\IYstot]OE]wxPKgxshdm>]QSQoEPPTdnXAjxYRD\\XXUWaeTjdJY`uwiKRtsJTSq=m_eXgUNSXyhQjdpQWpRtEyO\\Lj<yRitItTKYp;=RgxvS`pW=xHiSlAKuDpF=VyXWPplfTRxDWKdusXQIhQtlwjYXQeN=MQXiekvb]qqvo]`Qf``oZVlAP`XXryfioi[tq[vafRFqFvqKQgIwjQxylNZxVjrO^K@\\JFvOwhHwnMn`UhwupesamtisGis;YvkA[]>vAImsYxQpvaHq_@[Bpatwyu>bgiiFikQA\\jOpoIp<_]qvsGIakFa_wrWyjC_yixinwb@NoyoyOIdvov_I_V>\\ugpVYk]NcqntHQb<nysv_Nag=fiNI]Dg_Q^eKY^=hcPy]_>ksph]YsyQv_F`>WEkrKSFJoXIKU[YEo=chwsZks>AGvOd\\ktWer>iFy?HpmBWUbGURIwfk_Xq[GIgcXWxCQFigtu[I\\AhFGVD;GPMBAmGnoeV?DR[SrCvXSXZsSyWShevJYXlMFfKiQgxZiyw]VCGbAuHLAhJSFqsURCrxSuSuEYKRSYR;;CAKXhasXWhNGI^QRS=yi_C]QuiyIQIX=aSJ;UMSyIugaCCvsc>UraIIlWYogU\\Mx_;wWmFF_ijSR:gfJsCYkxbyTSEYCqiXMuNCyk?sAIFfqbm?tI;UZ=XU?dakxWwFJuVJPv<lOqEMshsrluulR`EO`dodpkmUjl@lDXpNDW[`n:Hs?yTheW_eKwlXiULSxruLN_DYihkEERsAmlxLH\\VF\\u<LkwiunytC`L`ep>\\x;yth<SAAT=poGemxMMSQLDUQSDOtQxiIUuyO?PT\\XquqmyTNlus[dwQmvO<UnQVg=rSIMQiKdEtVLLiqO\\xk<xKIpnfPT@MlZaO:xR>wtkQ[Tgj?AbyWw>YZap\\GWrnVaBfyJxbtPkrG`OVgpYyN>crGdOqecHcSx\\_greFfnwnd>]TF];wyoWaPnqpq_NaZTik\\G[TnwmynF?jE`va^mD@dPO^P>\\>UGOtBEBoCRfsUikIx[YgUIeaCHgvvmxCgxYmCHOVZ;vyIcWYSfUg:YxjkSSkyIyrPYxy;tpYtt;E=cYnKEOwG:?bYCbx=IVkDe_NwUxseRXYtitJyisl<T`Tlsqo]qvy<ovUpI\\OHyQ:QxwxyMpWpyWZavjdJgDpadPkhMgppiXn?QLu\\UTAs]@TfEvFanWTt]qPNUMuAUSusCAWNXoQ\\qRTXb=\\V`rUwuVwbE@]XHkR^`Iv_ci^JAfehj?xk=QZvYdQXZ>Qtugf;Ol]?rbnndGoWPnjHigHdcVlopliawBakVIseXjJI]O?u_>Zai\\u`yVwf:QbfqeeVtbphB^yQxa`?h=n^i`Z[_pq_aiymtgvmVo_?rp>dp>r`Ngey[\\PdJnxH@ukovdA\\v^l;>qWNiV@dJQ_K>u`wtL@_AOxBagaij_wwKVoG__@IdaXhkastIvVVh=XiE@in>n@@rUAvm@rL^p;AwpPksAulytXFfeYjoGtbHq:^qafgcXy<qds_a[V`Wqg\\GqV_nWIyjWd^QlKyt`G\\vofLNiTylTqrfPe[^gNhnVP_i@wwWxKntxQwx@sVWZqnr?OxKHmyxZAO\\>FqwVdgw`:wvoV[BypBhdUpbV@]rofDoZ^`d\\Hi[Wy_N[^VqOpjfYqWOo]Vxb^_?>eQinKOZnqa[N]Fnrtnmq>`ZgjPpyPOen@_ghrkhxOYi\\Vrb^kT^P;HMihaQFfSB`ShpmYy_UQ?WK=feOTZ?HGMyZiYcaE_uFDKBiYVRyGH?CEuvmiu]IEv_DbMHYkG]cxHaIN]XgahxoSEKHauXfcekUC_ugXeCOWr>csjWEW]xwKI[_sDgVVkhcmsiaFZ=xt;VWKx\\_DEUs^aGxuCV]TPsUZKIJmINCbDQV>WYp]UDwhoaW;cgLEUdAHfgwmIXpIwkmWcaIRUS[[DXqRmguNGumOwYCrusvimWvuYmWRhIwVSuYgypquuuwwycycT@wsEGg`wfagRMwvpUSXeSuCHkCxwexsmYGyS=GvAORU?Ut=yo=EtyTjausoERcC]=GNwCkAWcSc^MPmUtp]xqix\\EWwtOWLOmXtH<ywLYCEkminPLNCPO\\Hsdlp\\\\rNdpwAua<vvpWK=nEPTlixixTZEqJ<lQiNp<w`eMnTSKxl_ajwDVZimouZ=odRiy`^vLf\\vnii^jRfaQHmuirQp^^GjPq_gYdPxoJ>]V>tGNsKnr>GuAPbMyjUyghF^??Zg@n:arw^yfOrPYofiwnQgYfhVwauAi;P\\;dwsEAGtcWri_IuaIDEedkwwUWOkCygB=SvNGX?[gRiVi?EtktvYIeAgOWUbYGQEDYasZgSSMsjYWa=XrMXBOWgobxebL]gUWIuuwL;bCyRl[rnCG:eYtmC`scWcudoENWfesv`eH:;BB;RLCTJcT?MB\\OCl]BnOfyYwNOVhort]Yu_u@gY@YCAcVP[CRauuysZurw;ydujRMJqPxo\\riaW;uvkLrmEPbdRWAyWiOV`uXajLPjCPs\\XLcEoYAnKHvfdN<dolqSXlStmoXyWQTo>ll[]s]yjLIP=awqPMe<VwysyLLiUNmtStQPb`n]tRnxXpQr[XVjpxXIlL`LLHJjUO^avytYKLMhUjfxpC`LJmVM@s]`MTYLiXMHLJDTpXdSXLvHEr@QXh=MtmMJTNX@TA=wKahDPpWfnUQ^;nkSYi?xnyGtqYujFaZFr\\ViiXfQasWyawq\\wwnRXs]p^oN_Nxvq@ttAfOFZyx[@wm=fjBOc`OwtpsF@sjo\\QfZgPix`k\\_`_Vhpg[XvjrQwj?^\\gaYdGuvlOcY=TWOB=mYmuRtwYFCBIKunQI]ev:KYOGBEshQ;Xuiyu;y]UuYSvMyitIWVAioUBxsgiYDqMujeYHGSXGs^MI?UuYmRCubSQrbAwbufoica?IK;sk;vyuiGwDYeEwCEFayICf=kr\\EEvwxhYej[xVqroIuM;uf]rlucbcF`WELaWfiresGGCFO_g[yYuYfA?gJSIyayeYvrExP=RngxTsDVucsaEuAXxagEky<UEYUYu[bi]imgbCGHUkUsmHBsfOUbDeXQsExUY?SScqF@ICvWB]auDAScOy[qij[V@QSpWw_eGSWH;cHiSya_C:IRfWeiWTbEH;sXJQBwChFmd@?iawe;iT;]ShOScmytYbRcBDSHhwyDaEDEuTkHYkrJYuQyBIAcG]GRWybcXaAVMQWhYVU?UwuI;Swnir[EScIY;ydH?Et]Wgcc^ChsIeamR_IhBqR@kx;UGhci[qdF[vFiBy?Uo;XA?DmsywkE=ES:;f^_g:AHZERMos]_EiCrBuyXsYomTTyGcYT=IFwmXHSfQkhcscrSblErociN?r@yHQ_RmqXFEyJQFZySv;CEufFOsboDI]Ehqe[EU^siK_R[eHccbQIrQsf_;Gj;VEEBQos_oehSfDqxECc\\?bsscy]VCqVjivS=gbYh^uhDEUMIrmYCtWYC[huAf\\WWFQBUGhNAbyidsCGnotLgRnWT_[dqWt\\qRCQTMSBgSSr[gEYhOKbaIic[xM;DYchI;CvgDnquGsStGsH]VkYTMOhJ_tAWgLyHimF:sWJ=Hb]rmATTicRygn[Vk_DEqSvOfPwDBiTqKTbuVE=PpmR<drkqy[`YHUqsPOTHo<dwitkTTu>ULEtQ\\@J]PsqDnWiQLTm_mp[qo`XKj`KshjKyMlYy^Xw?YNQDUlHoJTui\\w>inHPVnIQKyS;AjyxUfaJDIj?uSIHXEuNuiwaxlq<kSyNJ<wkLnEut=TlTaj`MmAlx^IximybySjilyTydloWQqDxtXuY?DRDqrOdyy\\mOIKqyumiYUyx]mppmmhuyBeNWxnU`SNIy[dPwlq[@Y<mLu]wvaNudXB@S\\mYxqPplMyyU>qjXqjPepATnCAKmDp>qWcqYsLl?tTVyoXTNpqWqXWktX@IRSHs;LLSpJ;hOWAS@djr`UXDLRuohmLjAXsTj;uq;tUtQrS<QWLUfhWQDpthTNdSqQx^hK;U\\X^inXjNgnC_cLg_MPornjka`\\na`wcyw`pp\\M@[ivnk^iPYjEw_FOrFGe>o`POb^g_eVrEIiHo_UG_jw[yG^SGbbIh<nd\\oq=WhXGqs@e@NptakLHa^Nbs^dmi[cww^qoUhlIxp_obg?hHy^Sgrx@ZFI`n^ZlpsZhllXZ?NrEHhffqYNj;qo=AuOHbVVtaar?^fXvlBY[u`wxV`Vp]Mfqyf]:ww]iyygxhN^iQd`>pKpjPpiIAvy?bQawjxx>?m_w`;x^i>y\\Gg<XgOfjJff:^ZjIjawrkfyeydZO]p_h`WyPQulPvPhnUP]_g]_NfbIvqxlJWcOHvsP`Fvxf?lHivRoZk@hJYfpispnZ`Ida^_]ogkAtCi_@abtH`>^gnxoDNs[a_dIsl`\\fgr@Iqyxd^_]`WwGNaHhyV?b^^\\PXhnuHSRJIRS]bScYN[WtIwauveyCjIxy_yM]hb;DRmV=KXXwBnmeVIt]swgwiMgujuxFsVhcS<sWOWt>GrYEiFSB_eCfgfm_X?IrZ_hLSFPcUKOvwUdpydsuWCmEqoUSsb<wtP[Xx_wlwIpAyKaCRIfS[X:eDZwwVcBGoUDKY;Ig[ChWhRYAtuxK_qujemSlyheqE]OKHqhiRQqRaapBuow]x]iJSypHIVKxxyatsPlm\\KH<yTLYXUkBukhDuJ@JUEWPAlelv>`jF<yvAtd]XLiXo`qrPjutpiQVmUN>hy=hQtxMfuQJYvDHMxTMaHp>XYDLyytMLpsIaJjyYR=nyMuoXrPHsvlKkyN_EpJdk_EXqYnydRIqOktlmyjrPYg<NlarTqRKTUKPK;HYI\\sheOkLyw]YrUQHhu=YNvTYMykZ=r^lTDirlUKUUQ_]MjETOpWZiro`Qlhj`lNa\\WLIq=aoWAR:YwoQw[UN@xUhxw\\isiuW]EVstjCuoPlY_uPLTmS\\NC\\kOaLR\\pv@LDpyfmQDXnVXWJ<Yq]oSLuv@OA@j?ILjTRe]nNpQMUlpmScEs]<vSIUDUrK\\P=yRSaJiLmsLl<UO;XPWAsPuoK=jYhvSxRYQu:ayuXMR@qT\\rBDPoYj=qkEUNEURl<v_Ao=lL`up;DvsAQl]rNiXNhSjXR_tpoLxmAmcXPJQxeEmgTObiykarfTkMAj:ajULQ\\eoTLqPdYvPtP@ucEll\\j\\qS;MWHdU>qlsmtfMWxlNgumhLJTmM;=sZqr:\\omEmB\\ngLJXQYIhTtqv]uMh=sZmLGDPumlIMs>LYAdowEWydw]XX\\Iqe`KZUqnau>iwJ`x=yKx`Q=@rEUP>luppS;=UUItDIYOLW]TU;ePVXRrYMIHLyuYOLq;UMFYtxpKeiwtDlpyUkQqQehkOhPGe_@jK`iigZo@cHFyAWubW\\Myw\\>`_qeto[T^eA>v:oryw\\`Yrl@\\DQix>_SVZbIh_hbAfpAQZGfqQogGgdsXaEXqlx]gH[RY`JYp@xuB`f_VZZohIq`FfeN>_rYxZyqUIp<^lkQ`vYnxGlN@edO\\A`ctp\\TVmK_kVAubpkgq]^oqhvysFaPxxGqlFaafijQvcOGu?YxrAcv@lriajYxr>]k`x]@[O>`bWx:wgnNnKQnqQdhNtwAtIwmWqoVxjDWn<pcixnIqwBVcEWsrWwgxpkHqsh^:pgpVm>OmwYqp@c^N^ywZy_[]ipMiwQ@ZjIy`WijAv;ficp`_@umapZXywXrHyacqdghw\\oyki]^vpyi[@ayeAmS@tLy\\UW[PXrGqfO^aXfoNfaYn_`GxQwghGfe^e@AubH]ayvVO`FfnCqhAQi?nj=h]ZyyDy`<?yqxixPZWppYv_vV]>xr_hlH^lwFhT^aKvcSpeDQ\\\\IsTFZ_I`Fpb_`\\dfg`f\\`wZn?wev`KnnUhoRauA?iwv^=Pc`H_rAwFQgcNlD>]YvmnodCP]N@hHFe[Ptc>haYwe>qyiso^msH`fVoigbHNyUncX`yTnyyPmXWrC`d[fd;pu`XlfhfihqA_cVg_`YfAyc`NikYlrXfbPmiXsB^rSy\\a^nRNqm`l:Wk:Pm_v]hH[jYxSwaaijLWoiyg[whqAZMx`AGvXvhDQ]:ngA^u_`_>QfOIrAGe:HlXYgE@rlgviv][^yPQpBG``IcI`xNXhaAtCV[DhqWpdIqwhp];fuVF`SoZJIb<nw[xlIAr:?rFi]j^g]@dEwlK_n:Gsfhmw^vEYeS_fXvbbVeLArogfB_^Vpso?jn@dlx[Ipg:Q[wAlWO[Nhvg`pVw]eIm;FiXGfkN_lP\\QIaRwnaytjywsIhhAtk_eSFbpqcBfpW`]pG_E?of_nJ_^`psoPZoVwjahWIaJ^bypiYoea`^:vfZvv:xsFxefY`HOaSp[i`twN\\Qath>oc>ZroaoGZTvqGfiNHhk`r<imrfkRo]oAc@fwnGc<vhcGhAvbqwp[ihSajoy]CXrbqalYwK?uapZ[O[rhvV>iDpdm`dOH^f^o_yhEhh?fmiFjvHiBY^MWpZVbWOcl@dExsIhqA@aZ`\\Y^o]AefhouafROcuwpGvmq?jBVkK@[GIZKpmTNwoOyxq]YNkFwr=HuOP[ONc?Q]XfaV?rAw]YqrtF\\lfZ?>[=Hbi^cxIgpqs>hkyVtap[rxnUI_ZyywX]=`aeiyFq[RW[^qxhvqyybew\\]WgN@xHq`xHyoyi?xrqqyi_es@iFHtkwZ_?pwAuUyaLpaqol`?eUqgqx[Choq@tZ>\\hYwanl`@wcAsq^ZPiyDpe\\Oqa>[AWoR_eCYr=Ge:YhqpZ>WaWa[Q@l]nlYybuApR_t<QpqnpD@yrqe<pg>f\\XHnFFvffZHV\\;hinFd?q`gY^ZYt]?sJyk?xpPIkGflkFie_ZtbO_tXwWrqCRsI;cyhoCMsSAWcnUXpAV\\QS:]IoMHkODnoFO_B<kCF[qv<L?XuBTTUiJ>mTLAMu`vAaro@nJIyr=OAPVdPOl@LEYQvxYxuwfTMg]uG@roLVMHlFPQpdOmAM?mPDmjlPnwQMVPQ;dwJiyb\\T@dJ@tVwMVI@rctQItNqLLUyv:plG`L_mtgTS?uRN\\NwlQMlnitK<ARFaYiLU:eYgDk<DjaeQWEN`iUO<n[qMvAu=hW[]y=tPAarv`kuFs<@_D>aVIq]_]pXcP>rWp^Uyyiaa\\w]f?skQycVuZGcBxd<QxDVuahug^sPIa^hlPYlBy_AIfTFh[>xTa_FW\\XFwtHvaAhQTaUy@KVLiHtsh^yBeMfSYuHItsqCsCDyqt\\KSeCCsqEkEdouhJuRhqUBcvo?ijgWxIxv_IESvNwCu]weYRFgiXkfZ_RZiuHaT^;Tkibi[I`ij\\AXVam>HVd=R^hMSeVE=Rh@pU\\NB<W<lXkpTrlnYevYiU<lL\\alodxBQMGlo_<XaiS[\\lNDoBuv\\QriILNpJg\\PHTLwmOuAO?Xt\\my@ipJPWltN@@WTTmC=KNTJvtyUHUweQW=nF@oGEMEeJdLyXImoLQNMmGLNrTUniUbiLcUlA`tehpTpSIdQwulU]LBLVKAp>\\JUhu;doHUS>pR?uxCUM[hsjluxUwUQRLqV`mn^@SEARIQTfTm`hyfltJamhuQAdUttQfqr?IuyHy_DvhAjwDMXAxCypndu:XkIxq;]kjiYv@yfqMtHPFxRmiR>UVu<QmdW=xtYISAUtCqJPutD<OQmXkDPderaqQqlk@UVYTk>qxY\\sa=vEyp[QXc=lBmtcumG\\J<lRF@LMyvZ<r=HQpMVOLuaeKIxll@UVes[hR;XR?]KyQt?uKVlKGdmyILdeS\\uttpYVUqp<RuAo]qxWaJ<EN\\MlPdLxTQeQRxIvPlTqhXjumY<Liim=Xr=Do[<xZiLpIwSuNZhugeMZ]l:quB=jVenFDVaEQGhnIlp[qMkXrw\\rthWi`JE@wlmJcMJvInmmU<LVw`KHtpILmZmxS<LX=S\\ev]hW;\\XxiYCPJ:MQVXnwQy[HPchnWXl=XRYFxcxf@HlVelKBkSS:?iEut>yIgqf:AVa_W[AR^oEcKIYkXRYgOyW@gGZERdUHAwCxYr=Ce;;XmyeV]f]Qt]aiBIcuQss=bDcBAQH;wvXSSg[rNyhhyw:ESIIHx?Y@?eveCDKi`KSGOEfKTBQWGqehCEa;sM[eTCid[iIiSZmb:[e=SUwkU@UdXSv<kwMUHmcHQsuciINmhmOV;?vsmVF?RLqbwMyXCXkudQCXSwFw?HIqCBmbMWYRCR^YWIcRhOHK;Yayvq=T\\?r>AbxiiUSByEX[KFyKUygDQyVyuEtIHq[XnmIl;U__t>UeA[hmae>Ks@OhyEYACiUYEj_sHKfWWG]ucGIwb;EpIT`?rLcTQ_wmAEWaWAARS_DBGXuec@;i`ur_;GjGGVEHVORtEVUMIR_yQuf_gTEgigIYJsCysrv;wLoSVkBmAtUyx^?UukxtidHGfYCDTkFE[yxCY\\qd@IV@mX]KbDYYEAIeICLCVjKVyCd>WtWIUkqeDaf>?Xcax@KsfgTj;eGMH;gwZArfcs:crDEbHCug;biotbEfPIUJWsP[bN[IWSSDier]uWuXdEgjMUngy>YE=gIU?gkQRgwEp?XEyx<Qr<yBRAUxYVF;iYKv<IU?CHiUDnarL?eSwEJ;qDtTJtSNIKbXoB@LRUwniyrpY?YJQXUAEM?qmNTUAPj@=UgMMvhxWhMvIsyxUKfsmys?>`kFf;q__wZghu=GZwv^kxu[N[:f^D>]YIiiNjnophFb;icuQv\\y_m@gSG`CWy^?xaArLWn]?oohyjN\\rHxGHcJfZ?VuJvre>u]nvtyykxxXHtKh^PImRyjVGaA_\\lN]:wvVnftOileSkBK_DCEX?UW_Sc\\?goqgfSWQOF_cgIwtauxIqEcAul_Y^CutsRtKhHgRSUStESDGRNSt>MXtMIGuv@UBG_CNKCOWX:mBvuiuQgtMe=qe[CGLODgGr]SWJAGv?UoququwwqwwwuoGS^?t[sCRctesRIisSchuyVtiTCQX_eVOEBs[tiiDiQiOCtuCG^ovmQwgyV\\gRNOhOCxdYyoKVZMrPGD<oHyEskiywoWGmwlCfueR\\Wc>aWPsbXOuGscR;BDUIbevxiINAdiwrgOTDyHX=EQeewmyXqWgUTCYvgQY\\GT;gfxIumCsUwDIiIZsvPiYZWDKIhrKHECUoquSmUDYXZetBwbLGDwoUfwDdMxS;ujKhyKbGMtpsHQ;DwSIC_uvMsZih_KHZ_Y>mWL=bI]cIWXZ;b:?BoUeoWR;KeWyhHCYIItiYb==BROIkCys_D`yeugF@oY=kdZWDecB=MH;or:OHB[SnoWq?EaaeOswyOGHGRQYTA;tmqg]KG^othstegVXOvWuFXEi]?Fyui_ww=wfJiFUahJOX[uI:qFu?YUahvQtTYvMewUKEeSSQwDHgIKcSFoT^KfZcYMedQQWPADQUVOysTSiHwUVcbE]c[=ga;fO_IfYfZuvisxKcirkfTuHNmu^MXT_tGoRoMxYcErSRTMSHgUDwVo_TOOTGQuqAVmstsgygeG?kvJSeoacviWhSfmUdmgb<_YxWEbIweqbGIv:UiCafWUu_OTK]EQOgpQrN\\JJIuWiKaXsGpKmHS]PvTQP]DvlpX<Yq^LtryxyXyCYqtYQvmVSaVCurgisrlyWhVAPtsxw<mUJHv[TMrlqYAN^MJwAyrAQxdyQuyulTeuU?ImAmPk<PL<ReUoCMrKiKoqLgLv_ujt`WBuVQHxquYydkUtpLAwKtSyAyKAn<<Ps=YPiTMxsYUtddmLpQrtVHaXExvgMd\\P_X^aG^jS?jihc:IaOpo\\ay_@]dPv;xawaxZ@ikiubvdQuJscyKGUyhEwdhAXp=Fp_T@ifeCH^Yce;Ir=G>wb^eihqEQOXxIuLQepcTowtPAHsEVXmcM=rp_IRYx]IGg_hS;ILiV:Kw@GTPGSjkFBWdMwCnYYN[iX]yeytJSeDAvRYIqUWMgtTeYHKgHEwdMH:IbUIi<oBwSRD?clmCUOg<AShutZobniRtwRhgcZsIqUF@oy]cuRiY`=TcSe?YukeUAUx;[eJ_RZmgQMvFiUW]T:GwuKt=sV:IBewsdCD@?YtWtc]GQmTJIVo[ISmYQSXQYfd_DTyQY\\M;TqP`j@LjH<u>AO^uof<NmEYPToEHY^qoGYV[aun\\QALND<yVHMEqjjlXSQpdajC=WP`WlDpSML]QrHLtXyXX\\RiYQHDrflrRhVRXONYvQtwSpUyHtjdpG`xOHQGMwtqKqQoqponIMcpLahJ`DQqUTBMN\\xsVXrtEyuXY;MQ>ANnyY^IN?TYwxw>APJ\\lU`rbTlUtvohVhdSeMrSIOKTrTTXUtKFTrt<vAHmG`U[tLThNDANRyoPLOBmmUtRkYWQEtclMl=VqulDHsStumHxwulPTpjuxA@vQxqOlLLMogxomUXWlV_@xnqYRuVH\\VXujr@yqaxdeVLTY?<M_@lLIVlim@tnPHOZUwtQJtay;]LDiVfdR]=PU]sTeu=eLPMXoqLCpoFQx\\uU=ayVaormx\\=WtLQNPreocQHu\\Glo_o@AoCG`@vqpIpYsxwYtYid[XrKfnAt[WRuKSSWI:wy=iGFMBkWuP?VI=tyUh_ETXKcmyvy_bdEym=wgieKWyueECafrMG?gXsGRUeHSKuDQtAIwvksXgUNaF`YiYiH:wrY?w?QsdqBh_UIMVpmibgTtCrjgD?QtdkiwQSNcdTqBXKYbWSpIwNucWaFuQimuFeob:eh_MHo[cI]V?YIdAr;Wb;eHD[vyLjP]XoUQ^IrberOYWC\\Y[yWAAlNTrj]y>]RXemLlOqPk[AUQiYr`Q`\\xILkadwfurOYwC\\uspLAHS:]NwlmJQmnIvMXj\\ItULJmUUomWYAMo@WBeJM<yMXXsdJiAj>MMkImVLW_iLReNt=wJtKSUmiPwlPrV@htnm>Of`Vj]vshqbiIrH_\\^N^S?]GXrfvtZA[RQwCNu`gZdImEY[tqerwhJW_q?]C>mWp^^vfbFfVHdZXhjHcDo]xIwEWhDY\\Mod<WsRFodF_K@kkh[]xkVNtmGgGO]aQfsgmHhtwx_\\`akfjZAsYWt:@aufmBvk>HfoXmJa^QIpl`^KYkVxkA?bl@hmNkVagDftVgZUVoN`xOvoWqt`nerq`lNxqndhAyHvh=Qucqt>IgefZNarEypoQp\\oreHsOQm>?^qoawQ[DItf`oaQdZQeYG`bWr`Qi?>lHorLXvIyicQ[dPpXiqE?v;I^v>xAy]OAc:htuf`DYcBIaOQf?^_aXkBwQ=wx]yI_wKQg\\Ot>QDFiYxech[xRKvGWTKatpWGfgMUmnL@xohpeeLMeoNETJeVs@odtjlDlelR[<pixTMTpVHL:QpNmxY\\TMeJ_axSIMV=mIMWwlqexmmukqhTo\\TYyUBMW\\\\mGdVJxw\\TY[]KKhwpeMTtUdtTJlwHToQqmEivKEoN]PkTS:xNZyTDiTRiUHenoOc?^lEgfkqyQQwmi:efgmewMxC]yewcy]yu?bWWxcGengyxeYpSIEqCZyYIQrUOcCCFlYbNHyw`lIqLXeYoiVFqsvMMwdUQ@XfAmCTj=EVnQtmmu^tkYerfaUKDtbEU;qQSPoC<XUAXrAS:lM;LU`dV]DLuLR[UmVAwGAqsLm;yvy@P;XQMEYfIugiLidNZ@Rs`SKUPkqNWmWmljA]qLLwhXvimQmLkmyL\\=uqxQ:xJX\\kbHPZdt=QoXLY=mL;LnL@YhIWkLK^ywWpOM`WqpnoxxpDkJ<MW<WMLmfXmBeTkUw`MKxEPNtSxTpEDr:hLg]nC<Ut=SOPS;lKu@YgaYRakhiSk]J_auQ]N\\<qwQwVpYPTyYtu?ps[tq<LWL]qqMM;loieL]urY`QHDqwMjwuyKqOReu`dnG\\YlIUs^_mQgNFyrG\\hAkMg[DarsHaW`oOipq>o@NlDomnP`PFuYFbVxqaxvl>saVcRO\\]NrTgyXYrKPaGAfBw_bwdc@]Vp[Cpm<Vjxg\\RWqnIye@eJ@o[ws]WbTGv=Wj_?gdfgYik<?[valioeOXwEpkhFwyXq@XZB`xsAf_qq]Iifvc_@dSpk]vaS`rVYhq`xm@[yNqAn^qhqHOe\\ixTYxgodiapcagTo^qgmuOrbqiaI^o>en>Z_HmnNk<NuOF`D_\\:Wtiib:a`_>vWxqk@nuXwswwK?iIx[ZNy_Y_Dnuwv]rF[UwqYnd;Vhewo[v_V`ik_dUxnTae`_tPN`TwrIWj[G\\]Wt\\ogO>jq^ft>rc>fVvjrQtRNqwpcri^L>fMI];im=`cR_w\\PsZPf:_i]feTOkDajofkMHs_gdoGdT>[tWyVnlhPflwZtat:>hwfayq`]O]RFwWPovP_^Hsha_cplLO`OHj=ifAx`Zi\\iiqGWlnpb=peOftDg\\saeHGqrAfQ?]`VoS_mCVo@?[eV_oFyuGe\\Punnb@vZjywyfxcxwC`qciuMGyPPlbVatNau>jinu>ocsGilYivH^RAnKAx\\Y]q>[sXrUv`h?ff_gFGy:Okihqk``mOgdo[inqryi<YvxQaH_mRabi`arWuUiotNbJ`qs?e:_gb?s_`pDy\\y@a[@ry?yb?ZAwk?`v`vgKvsxWc<qd=Wk?IvfwtYHpRGehotG>eBn[<>vHwk>@q\\I]K^qRgi=Q\\EItUI]G?vXFaT^rCYdW@s_ydjNaTptb@j_XmHFZpQmR^jmy\\PfpkWw:@]GxrYvw=wdIXdGNrNan>?[\\?jro[fFxV@lYyr@Q`bawl?fyIj:^uXV`vOZrq_Yhd_o[PY\\_^bihrJ`sPAfQXglVeGpninhPqcxppBvfJhkLgqowoT?rFopEnwlQ_YpaqWfCW_m_]lxqLon<@yNoZ=NZpqhih\\e_]tGdaQwSOiCw_vPliHfpQx\\nwB>uqgwEFnqAda`iXprtobBipg@ZGoaVHcTodiaurQyRNfqOdBn[sapFXlXHo;Y]ypsgY]nFtpNxkPn@O\\FPZbht=IreNaTFt[OoQP`Py[=Qw[HsnPwqa]xIm=OogX`ygadXphgq>viC`[vGZu^uLftRqpq@dTfk;N\\G^gB>b`ynLNZlg\\G@`T`c@vfIQinO][`xoIaOp^HnmTinlwZFIZRqZ=NZRqeoAkoppxve?Ggtfjsy_VObkqcF?jlVk;yet?]avyry\\KiyxYvByeY?rfyfHIrLyv?XxJwoLq^NFdeVskgeANiJiy;X\\bA[t`l\\OeEyd>AfFYf=X\\t`^LGoko^:`mAQgh`kGXhM@w^fjL>hdyx@QgVViaxd;OAeG[mvsYwj]xrIvS[CPYSnecI[dNIEIGWGCY>AbSAhjQwg]gPOgj]XuacVcRwoUYeBBcrBCT\\MRAOhVwe:qgBuf>efs[vLIIR=GYaGXGipiHnohDiibEbW]C\\shU=eWwiUaFcgC[ewgMSoAt]yUKSRZMWhEriqY\\YdRCESCyXwnNatNPTkhuWiuu<SuqXA\\yn@Y@tVIqmOEV_lN[EO\\pxdYoiPVpmXPUlw\\x\\Is=yUt`XCUOp=oZHsUtj@Lj:xsoYMEMNKprnaxEAuoXo<tY:aoV\\v`@NmdQSqvPhW?twEtL\\QsYmqyiY=AYjInBPYvaJfmOhtoCepimlQmtkEvL]Mqxrl@uuxuIxXyasZlR>YqIiLPeVyiJ=\\rWhMRMkQEX[ayLPXoYyH<ykXYixK;ALsuVEp\\FivQgrb`\\>^qMA]UvsbgjHIxMhmdIuQO_eqjxhqvxtMyvNwkuaueXk\\?khA_qwyjYnw@]VnheGobvsAHk_WqVVpaxugnl`tGYCK]rhorN[BqGuHuGZAEWSS;Ym>ut;@nPIreeP@DQ_QqalSjlVlalCmpExYuUKMyT\\=Qrqk[=Yt`U@aUWiogYqnAL;=k=iSBYsMXpYELjaVWmQyTspEyF`kBQvoIVNavHxtbiYYQkeeVHIjamX]@mfTwiQOe`O:lSwtmgQY@ulsAj?ItrLs<\\r=tNuirR=qOPMd`Ld=SC]r;uoUarclT`qXgtp^dUNhLiUQvxOfpjBxYmUssUpCaO`lMyENOMRA`mYXpUiostLHfshB^CD=gb<eW\\ihi?cayU`ECbaWPUsgSdQwVkoFKkD;qeoIxvaUpOwKiB;uc_;fpoSyKU_KxKugvWsGsycIVoqs=uSfitkOdeMVF;SGcfXEi=?uQmgZ;GiYdtIsWEeOQDEubRKF`IBbCrfMwnUg>SrtEVSkiAwRZMwlAWMmTT=bqsysYSRiHVICQ?Ic[cXohoKDSqtmMWQSF@Ivm[x^IEgGTtIbLWtFmXe]t>qvdcvbqhOMe<OXLCb=eYDywMUsagtLqgikv_]hKUcmoF>AEouhUgXPuGsGyhIrheyHYX<kyEih_UfvCiwGUGCYgOU=Wr]abq;wQsvaEUAKeQQWOSFYMB=AwvQyi_YVsSycxHwH[wTQctJ=tCUuSmu`AbIUwIYEauwXiit;w>oUxsbW?DVIyuqiwUynowXGvZsyGQUZME<kbCwWN?UjIyv;EV[YJmxcEDjoS<]yq;YvcSdwblexdmR:gIe?Bu]wr=S;iu\\uWMmUWoe^CbvmWx_bcIe\\kFaOC\\iinWvBIxZKB[CxdwTpch>kGLiVMMsaIiies[YwYUeKavfqy=mYVSICmYsgSMCr^yySAiN[wN;vI;Uj?HY]re@YjtUJlLIhu]iPeekyTMa=UAysoEk;Hs^eRq`YsHJu=J:<\\CSJhwfQp=qWiutbDjody^PYrpKeXYPEUqqQKhRfEo>XnI\\XCHrL@txPqDXmIyS\\itipk]xxruPH\\mV\\tAXWoUX=AyJMmeAJh@jJanIDXKmk?QXEuXahMO`SGmMjiT_XXTiJN<Sq@wB\\L;Dod@YqYtQMnB`wELvjYpu]JFxlk@XmEKO`UOErSaN@xSg]J_DNplpktNKuJcIkhYj[ExLYuOMl[hSxtoFaYHDwcgc`Pu^NujVqFnyxnaKtu]hUUgv=UPIs^igA=BU?VXoeEQFwSeKmsYwre;SNUtswH>ScUQfCkVTSHDIEUYbVkd\\eR?]CAmIT=RpmG]wrEcEbab][vJuwPwYqeBW;x?]ejEtEwdmAWD]vKoijSbL?YeadXkWLWXRAUYqt>COTUmU]kpyYHTJIiuR=jwuT:lymTrjxKA@Lt]Yi\\owmQOTT]`JnDquMwBdrYxqG`rqpW[Ul]MLAPj@ajepp`TnQ<jneMctrfEMeHo\\\\mAqJJqNYxs@@MLUpRTOq`maTSNEywDLBiTh@mQAOYiY[Lm@QS[Po=hURMVDEKcQnvxr^<PAQQpLm>AmjmsHmrZQwILoqxWkIQnPTBPpL\\mGXsoUUrTL:Mn?hxEYPbmliQQ]<JiykrivuypcMjPaVmTO?\\TctTj`OUaLlhJgDKHlx>hXx@pS]qxMTt\\Pd`nuMVKAM<pPqlQrquYhPtlX_iyuumCmNSxWYqqghYn\\lvtuSmu`AjIuSW`LHTqaEmVIuwXYqpPQEpOTmvdQ;mmGTMvHUT\\xHTL<]k:<U`itbhxg]NnEqYpyxiQjPUH@V`MYWtth]S\\ay?XujPQT=X`aXYLYA\\MlATkHJEAvPIKBhq[tLfquHDxjXVrEx?hJnxXnTvJIvZLqt]MDYtmeaA?woXhuhZk^[Gg_J?laHf\\?uIwoYxwK>ZS`sFwnd?ayo_`VwnXvwx]RFrZAlAFtbG\\MWlsglOoxrirUf\\JheV__]QvsGxZxdqFhrAiRvbIxhDHpjXgH@fVO^I`gTHklp[Oansph_Fj<GgOViInZKiueadgfmxheXggTQgQ>lSfay@jCIwnPownZ<p_fWcNWrmy^LApFXlXiu>Iqs_\\mfdfYi\\w\\ty[A_p?qasf^ZF_ZGs>n_wNi<>aoai`_^<@pt_sba]knjIXquf]Tf[NOhoFxHY\\bh\\Q?vFVuN^lapsIY_g`t]Vy^>]bacNGyt@[jquXWbigaUfsextYOcQHlQVnOiibXdqychyuRNyh?io`Zvwo>G[`Oc<wi]_\\Mxfa?`rOi:nq;wo<hmDg[ZixdV^pNisyZwQc=`utQugfkp^mWp_R`m@f_NAl=pvsGtMihnOaoFnGncAQlBxfs_e\\`pUQff`rj`laWtb`rE@eQ@[Fgxqov?Igr>uAvj:xx@psl>`rAh<@ieV]PQ^hWr]yamxeoOj\\Pvcxo`Q_jqar^jdaqr?umF_f@soQdqwjZYqLP_bgbJXhiw]lwvAItnQs^Nr<Nv^awsomNi[\\vgI?\\aW\\SFw``srQ^VYj[fw[>vQHgkYaOgfNX`lWck`mDO`MpZ\\@uUV^ivbixe]^axwkN_y^psJQoR^K?ekKxcSvk[bfoHfkG>ihUQe:usiYe:oSTOd:oWqAInCSu_HUSRu_iIMuBUEmAg;]r^kGEuS_qydaXA;xKyeyirugtm]dvsfmkrlaS`cYsaSLmC?oCWyxMYuSIUXqB:wS:oFrWXNGFo?xCEtJWtaYRoMwNIGoAwiyTTGsU?co?yimvo;IWoTnuXYCrTQsh[G?QUJIVh?rapnOMPUhXXQngXnSOoVwqX`rGXmc_wUyw=yZyog>gqtOtsV[Efb?Nhl?wgPph_h[`jUYnS_]sF\\<YdIq[ZX`\\AbX_akIhSwldNm>nf<@y>AeHvtih^Ky`bQddxbYN^mW_tPiWNwsV\\rynaPxtpc`fe=wyhv`H>k;Hn\\i^cI^tGs;GaAvqvP_OihvvxGH]v`x<am:XqEvnYfwgXtHW]TNymFveqxUGhbaj:DZ=XpYXqCHckUsSWF]UWqGRgTmefSuB;_SX]cd;FfqYrwUG;BAseuKbLCcF;YOoRTwix_bV_UAWG^;B[sv;=d`_b=SgtmHeauxoTSaXC;VTYIN;iQorMAes_hZ_XKuyCqeuWxAgClwVuqwjwDu=r@su:wSwoxEweuOCAwu@oG;[Y<dJ]qJyxqg]NPEysuOEHX]IQ@px>DTNtKYpr<pMwtswUoXuOd]T`dPetQy`XuEK=tnADLRDK\\DQX@TiumaYSOiSNiR?AWF<SIeRi`s=it]IR^AUipKSEUGulnPJb<NKyj?`LTaS<DyETtbpND@Wk=UjHunhnt<Rg`JgpL=EooHNvlrUIorlLMaM:tqu`lrMyF`Jtxy?IOO]v^pVxQpRDl_irfLKqpLKek_IpSxo:QOaytOyvQQpIMJntju@USAMQMoC<Yadt]mNZXTpIuSYvMqvdTVjPy`PMhTUBioHTSOmswdXmmSqXKXTMNQLGmo=YXMEJoDqi@W^<uM<ltEyPLqGqTolYgQQAENfhuuhjFEJOQXGAwE@lqIYgeT;\\y:tr]LqfQSmalliJkQyeMYItogeo]hYehLyhxeuy=lmwmvSekpHSyPxseNBYpNTPUhsD]VweTYxVxTsudNSXQ:xYQuLAxPFtUvimnpKsqqqPLBUNgYrU<kMMpXaW[iyOIMCLvjIvA@pwHpQtti]NK`sFgskp[u`uNIq<Q]HiqLvb`vpFXbAayR>]lWg_XkAyfPqjeNjsAm:Hy\\_p<HuSPn:niSVbu_Z^Nqg?_Qxt?Y^dobawlG_qgwj@GZi`qn@kyXy\\al>GZU>amAiiNiAfmTIiEGlkf\\QWlAf^Nnpef_ngxlObw>iaXq=GavWpGAvRGs=Q]nFkk>p\\FmfPg]H\\qibGgmf@]BndmAmg`x@QmFNoA?ry_xPO[sQvdnmtwtJncWNx]fhenkex_GWfgHq?W\\VXdih_dAnNHjMheTGx[h\\pfc@WfNv]lwlrOWWu_?vxUvUWDrWxDaE@wsnIGgUfmaXeauxGFhoh_?BHQwWktSyF`KtjWcasSXoeGaTGec^cwPkwDOhkAE_aTScdfeCuqeSignItn_R^[wtiVOAD;Gu:YygegBISmOgbMF?GbAKyKKuWKTI_e@kFkkdJYxj?YfOWBAiYmeMQrOAg@mB;EHH[vrIWR;uI=dJ;viCCRQhkSc]yDSWER=YgmEH?hEkUCOCRwXZABpubrMwnKWvkBUCttoxoMfW=rUaFuAhBwDVUDZogFgG[OdfCg@gCUCfT]S@Aw@Qd:WX_EF=ssCGB>oew;cvSIouydaGVyruADv]vj[SwkGRMyv=hG[bJaGuqcyExL[ulws;MtimV=MvSeCWqxPGfTEGZasLItswT@aBBYfBcEgyt;=wvotugcgUU@eBMsBqWevmC^kGIUgnUbCUY[Kun]h]sw_cfRyhFcW_oCYgEoWsmKVfMWbggf?F^CTEubGaFqqeSeivmT[ads;c_OhF_S\\SFYITA[YKsiT;b@cd=URJWs^IdWMS]YFiIys[yVysx=whYx@uCXOTD[X>AS;QxsoFWWrtYYxssqYdnsWnEvlIU`yuCEBkmI@sywWHDCxYGWOoCssILUHvQbsirmqr[;xygt<uC<_DJyC\\kr>Yy@yEjQFVKIC_XVYGXiXKsgWei=GxkiBfquiqrSwbteXp_g;UxBYWwUUsiyXoWAOTesurYyS[cD]Bj[GZuIr[vLMWAouoCxFOX;[BD_eRcclEYGUGs=UysilOhcwypSuTaDZOUe`m>DykIpFlKYTK\\iUY<MPMsa]YnTNKmSKuMZuj>=Kf@KThmc<vDin_dOganQuQlxsAFknNhShf_IxSoucg\\ZvfqwwbikN`jYYwRFlbO^RifAXbPY]Xiw;wnMOn_Xac^kWXe:Wq:^xhGxxGoiYnOtpUVJEspeIs;igSymSg:GU`EFi_YtCgLoXk[GgMBHYuGsGVOhiKXg[fP=UwWvFSIj]y=uBOYdYwiTSRsSTOavfSGg=eZiFjCd\\QG@YSBouTMRB]iiuYywDpCxjigXUcvwUN=XaQYWKBRat_IfK=F:wbqyb^eIeod\\Mxv[UWmG?[rnaX@]IxQfxwRjueyOhZ?vYiXbWS]?DDgikCicuDiEuOCXc]h<uWyefvOcnaTLuhcaIVifWwh@GVl[v;gW;SiduuMAHg[UXwRkEg:Gfawx\\;hEyCq_RjkSsqgsSBrUR:kipCDAeXcsg_KeNMtnqeTKRuCgPScWkeMeyB]YwqBPsiZ;rxATy[G\\ieMAChEse_XwmEg_gmwwlQg[sf[KHTgtpowXWCuuDrsDQOgYGr=eib_rmQgm[RZst;_GoIu@QU?aFYQVcTnLlsWunAhpQ@jCeUTLupUoCAsW<lHHl]UXdylSmQUavN]SmUJf`pklfbGdJwdw`]qh]S@iTFq^odeIxOGanWsjNrfP]lFsky`Txpk?qywaxYyIhyegtKIqYQrwQl\\If;iZYxg`YvrasLpo_YpXAxpIm=YfKpZcgu@AuMGZ]fkH>]k^uU_lkXpvY`;^yYnf[>smq^thheqlXAc^Hjx?tTqepv`oixG>^V>i:Fk?wlDFoSa]LNnphd_q^fw`tn`cX]MItfh^Ox\\IyrKhsg@vWxwW>\\IIqYgaxijsPlLq`Xvm?WrqIokamrWwCgt@yapAbRvkxFuEveBQkfon@HpKaod?xrg^\\?v=iisQfVgvPnkX`[]>]kXw:a\\<@iq@ira`XFxRGeFHd;vd_cNqs;Yv[Ccb[iTeV=mcYgEtGDCoFrgW;OhGsUYor?ww>eXuYtIwx:QVgUDiEWWUfGgCPYtA_Wd?xsgUTmr>ibbKSogTnCS^CVkUeeqBbUSw?X==VgGCCCBXibUGCfQYZWEuuEWib?Ih^kd@YTDEfnKWqichouG]sD]r:=d_MbP?B^ukfQUeplkmN>AsN]JriOleWpnixGd\\XnUG[>xx@fZnhk^X^;HmKYjqxu]pjaf`?QlEQkvig=Fms`_vWZX?qthu@_Z<VnnAl@wj@PrcFl?QhcgZsF`FWxih_bvxw>yjqot`f>qvWa^ovj@XxVhulx]mxtFHkQnrKPqM`\\=Otche>QEct_AFpSwtIxfaB`_F;QlEPS?@TlDmLLrWLV^<Ok`WQTnZilwIq^YXnTso]Tips[UUHYqcPO@tm=atmhJnPKbMmA\\YBxY_QODtl`ELtuyKERYqP>uyfIQfEpnQXIuNvXy\\<sGApDpnbxm]HsgmYwLkLXWBMkauWEDqZYuMijHtl?uvnqlPTtdLKAMQAhlr\\xryTEhTgqL`Ay@mP_ITHImZmUVXS[EQQETCYKPYxM]K\\PYgmLeYxS\\xW<wAhueARkTULukXPka`xD@OnppdlmyTqlUq@MY?AVn=ojiU_`T?QPOxQc@tshq;TtPUMxDxetqkuuL\\s@Qpj@p:XkQtO\\iYiYYYPkXLpJQjXXQePxbtWXAvmIKbaYiHtRhraMmKUQOIXsYXaDtuqP@\\YtEJaqsWXT:InTmNi]L<lyITsGLlIuumxVRTJwuK\\tldarRAUHDsN]Tv`yo<Q^InXhmi@vlij>\\s\\iYmPJA@nFQSSpwxujDtRWUL:xmX`_Qoeo>htwZW?a^>vfo\\i@qNgeQani_nQIong[MxpYwyla`Xgyp_dcGmAv]cqtbIj:ns>P_cd:YDcIhewRvexL]Ec_T?kEkqYWoUMOYraIpCBCorB?rFQwX_XlOgQQtm;vLMibCDiSgacWomXbwXAMgaoFZyItUH=OcRsc]Sy_KR:qbLMFkAWScSlAXU]rjEXYaIh]x`?buaRTcuAKRjUCbSXZKcuWucgfgGhKaBLYXscghGhj=HDYWKeBcou]geDiBMYiaYc_QeXqUqOblegr_GX_VPCsCacpsWoaEG?GJuWNifXWETYy>KXpmvlCFUesOAX[yWhSW_uSYYBwOUHGiOAdtmbKcUbyv_svfYEnIgakireI`WrT=ihGugEtlusuOTIaI@SGA]vVUSCOdXUw:Yf==G>QcBqSagheqd:UW^WBFCiaiT;kT<gI];bXEcBod_QIb]FdOBdafW?gtGseeWmMeGSv\\SupiebittyYEQwtKU_KBbcUXGR?=rVgHgIgiuu;Qx\\mEUIil[GmIWrGUayu_Ib=mUPEcH?ChgbSagp]BMOYMQdHIw^oYHmuWIVGMDe]x;IhG_SNqfEMB`IUsorGefmMCl]ePEx^iwWqE_WgreEn;DP?fEuYaUxRSx=SgfABx_HGseIICA?E?KEoSGEaISeEnOi@OX[_gmybmEcV[IKseVYEPedCmvIMtwSUUWE<[yO[F`YDrAsmsE<yBXYymob;OiIQRjuVScH;keOkX^_WrksN?rIytwGsUmRlaUIGSXMWiAtuyVIkCceU@uwu[iyYuR;xCEyjOVAoe:sYxAgMygFMD\\OTiYiMyYVchLudt]vausXQRvcd<IcAOIkwWi=rBMxCYBmoUiGWq=CBwrQOgrEysGIsIU;qgwoEFCsEGS@istAxJKBmOc^GCJorPSsdiuuQbPcGs]fvMbC]C=GsTQUIsfU_x;IEwoe@axW_IHwehar]ssnYSrcuDGeCaE`qfEkr:MDygRXYW;aE];bECXRiUgAIkAXqkBqAyNORdCS>MHokd?mU\\KDAwr^WFFsWXeScAvJGfwmY>SYV;x@[GBSspeg_OEP_r]qgfoWceWq]Y`SfXCyhWTWAhE]TZgDpcXciBtmwHAhWuYY]Diyy@ythAGyuIvASyeUmpVw`xMAw`hTsiU;lOyAnAUlhxPyPQ`pU`xW:YnvqQGllKuqyhYQmK\\HnoySdunU]K=DWVHYkLO^xPRev==ji]W<pV=Aw_lrMPWNmxwXYY\\mWqO^pNM=SCHr\\MJQhts\\JllY]eODuNODlS`SetqiQLZ]pDiPkpPxdXuDkDDQuEQ@DWelvdLLqll>YTP@KH]QnesO<ltMxREpLmU@mV\\dnCtUUun=ePrYvqlL_yuHeYcAq>m[hVwMWmBQbxye:ghWotItGOf=DtAqQxAWwpmXQnDdmTinfyXbIxsDke@MGIVSmyXUSQ=LrLtUuwLhPxXKO\\RM<voPKJxpCyvu`O@<Wkaw>llEdT>pSH<oK=W^Lpo]JbpKWENyxWAEYkTkLyX@iPK]SslJOv^:Oc=>cXpud>nHo]yGgTO^NFqHOdsgkvOZexhriyS_vxFeSQe=qyBq]vOwQya[PiuvxU?ifY[Qn_b>fynxRYfd@lCAoVxqYyk`hfnps<^[xikXfybAwbnqtitipuGUuceswW]=raghawBJAE]qRxwgK?GtITPShVaxWeUw?wCse@ehJkdJsX=mEpObVaveMhyqHg[HaOh_UcvoFaKxbsdPAxxwCI?vR?bmMSvcwUsTLMyXSx:[EXOR]CH[;vuQus?IvOBnyVXOw;qu=IBgQfW]UbCvHiwfOYrqWiGEeUwU=ilmIh?bw]v;AhRkBeObUwT:ke\\oWFiD^SDO[SXqs[QueEX_ocHsIRIOumvH<uWTsh@u:=uD@XiXJ_Pvdlqoilc\\UtTMMTV^irKYtK<UWdMTiOFMWBeNDLRP]xqMKbpUT]rqxQuUTU@rpqQmLNIdnWuJW]Wheqx\\Q?@NHQkVlSwPSIqvJmSQeX>INkhj:qu`DLBUN;@uRxUH=p[uJgmX[@k=tQmxTwpysXkKewfiV\\eTEMNeipuaJiMMPhjEqjHaQwTYA=shHKZMXoImcao<HPUpqJaWjEssHyv@YWIOneMgQtbXjXQOsPYDQN^hJnYX<\\mVuk@YkKURfQUFDnwIVG`QBuNkAmfhsqXk[To_QoblOP<vJ@w]DYuloZtLRYLLAs:hSR]qflMYqLpMrdTuMpNCUkAyq>eS[pWqLjVLQ]lmndLndpF]pX`XpHssAYpEyoXXqEvuTTBiS^DLJhXCLvF=rLYUi]TnDpNIl]aLSiLuDyOXWTDlj]Q^USWmX[UqxtK;AvgivmuXTeTUujW\\rvxOS`x_IPo`WMXR^MwnmlHtYkXmkpqRXRm]QI@xZ=UyTo<Mq:PkRLK]YqdeT:unDTO]\\mBASQpR>djFETFLWOAwWAVQLy@QOtltUAxUyqtywnLoxUp?`TeYKi\\qZxs_TocAUrErkpjviyx=vGyxstuTHL:tYlyX@uwGLQauNkggHuqqF??UmYS=;x]QEq=sdIe[GfW=EfqYRCw?ucruEm=ghgF?YV`icTQbQqG^CTh_g[ax]iUbUHo?wewV:Ig\\uVC?Y?SxmcRFAcAkIske=eS:]x:IhZKyAOw:aG:sWOSbJYHbQbUyVPixYMytaIh[iv?chqYakEtMgQEItmTVAhDsbs;byQxayHZaD]?Hvwsa_ixMGKeRZKV?=fMqfnItpUhk[HuUXMABHiGkmhmIy_eg<IFGaR=idHeTOYw]cH>aVmCYYmeIayFERsQxwcyp=iFesBwRE=U`ecq_EIuBWwWUcTv[xhGefaex?DOmSxarAwCccDNSEGMWwqiT[BQGsJIwaMXI=re?DiCVkqRVCvwkYrSiVKGW?vOscyOdgOFpUF[WRL=ejgF?MfKWb:KHEyGuukpLQ;eJvDK^qohun@=LCYQcEk:MOTEY=yqgdUYMjy=sahxnaljmudXw:Yu^Lxjaxu]xm=sGISnXpJxRl]O_<JX<ja=tePvfuXA@sfEM@ysOYvPyuimiogngOiIa[bwfeplMp`^qmeQyu^ZxwdYx\\sF`>_\\lXpd@cV^\\:I[LYeUXeqW_b_p>hld>nloqVHeVOeFYf[ivCfnJPjAWinFvVA_Sgt>Nacwn?`_Vfq@AhQ`wRQlKi`e>rHOoaH\\?F]KGtpNhqolN?\\hNxjqgfxtPGlY`cbgowf[DFodnhd>`sYeJxxEw_GXrQNhDHvoIk[apbviIiiNVt_^dEh\\sIcCfwLNr=imTgp]OlQhse?cd^dlPxq`iCfrNG\\YFidyvjqwq_qeic;?mnis^av^nmvOxCg_IavyHgJAmvgimvcW@ZIIcp_yCoaYXuK^wSF\\fAjwq[ZyiQQbwg]PAyxYbaxewh\\jUwWBjghX;RlErDWu]WcrSyWWUjWipGX^ASaOx?YWemByashaSHehD_CRIDWWG[ivies]SedGVyCrx]rgwCdqr@GRmaWoKEp]VuQRxeB?QrDoFrEenaGCyiGmtpcfhmvaWCrysYOYSsewYcU?cnIIN[sI?SnCxRYiuiHKYYuQUL=ryOf_GefgyiuHq?FQgU;idmEHgoSscxRuH@kxraHACrwQdPKSfcTNouZctkcHTGT=AHrwsIGr=GR>OB<KG_Qe:?ULCWkKGgKI;Ss^oetEGWEr>IusEBZUDtwcpMw=[S:]xpIinCtQOeHIF=IsUMBXqCkAgCkxKYeC[bqiB?[SW?uJSf]=WgaHcEuagRxSgV]THyVvcgWAiOCKNTL_]KVpwOys@Xwhut_hMbiqLpokPkqlSt=WxQvvlvHys]xRFTjy]riHkFqr^<Poqlq\\k;qMHqOQPtlTlIySddj\\qwmAW_ALe<XjuSGyQM@lnQWctoJ=k`irExXZPlbDoBDMcENOUpf]oUaVJ]U?AU;UQ\\ujYiqYUQ[XT]EXNMT_eQXDjSdXSIWTLSP@XLYpYiy;YnLdKr=PsyXqDlKhxwXN;ek:<YYDX=dUQ]QjQn>mOxYRWMULHW\\EKceSHYWpTjoQwdpTmAxvIYxhVkAuSep]iuUDtbpj]eMCeujDnUMmEAVg`pfPpJ\\QiImyHQEhLsusq<vQQObdoGyVNUwjTKbXuoaU]uX\\MMwtPFpLOIRseofpV\\EyeEpNmrxtwjlQsyuwMJPTm_qqIaKsMyIqYpYpdxY?qNelN`EuWUSa]WA<qq=Jyyr\\IvmDu=qoxHn[HnY@sk\\uh_[nqwAhqwA\\POchFirndJQfhVr\\auNQ]vqxpp`?>mbQfKvlYgke>ZyXx=Wqj?w>?csXykXmSW^cF_K>ZsVi`vbS`gwPI=w=cxjYhw=um]HZGS^Mby]W[_beMvCyyKyYtsbQueq[DSCSmaieYFugtMyf]SwlYeZ<pbEuaQvvES<Exo\\N>\\naynlQJlqUFtMjYokEnRUMOIQ=dup]j?<Ys]weuvQ@x\\yla`pQAvrYnWApuhSdXt=mQUYLn@ne\\W?Up>HxMMvGyv^LrRQL]IlTHs[\\NXaXaqq:em\\IPrLV<XP;lu]Ty`eLIMxHmJmtvP<lSXsEx^\\htqVeeobHWn;>sVqkNgkaxt_puiAyqn^kfyDa[tocoA_GXpWwZDYq=NadA^HAs<pZ_frSwqNincg`\\H[tGsGQoqQtNw_mf`\\N\\LO\\CXm<^o=panyaxXcvhyV@i_IewvfDY\\epbFgq@xmUg_aYgDWv>xk>_pUopZnZc`\\e>]_@kTxhjnpUo_Biypg`DvyXA\\FQfr@]SAg\\ilwI\\qOlRG_h@]_aolgkvpt>`oEwkWhxyqkXwk<Xx<YsMPZfIakqsWpj<IoR^gLO`n^Znawsxe`yZBwvjwuf@scHk;G_?Wp@Gy``u>^d=fxfI[]Xrg_oEWrOQ^Aip>f]tVqQpZ<XpxWvink;I^@IoiAeYPcc_v\\Gag_hMOcHp[q`eyVoW@o:PwMvwypddHnLX_evkIysNxmKGi_PjJh^:xcvypyHk;ieqynl?w>>p;QkD@mF@qCYrmF[UFk>ohLpou>jyqvEv]To`NGx[GfBxrfwamBwwBxqurGYReeMwsaih`wdoii>[yY_dQCrWQYvoSfyuq=EhStkExNwh>YI<_b:YUROeR=RoeXSChSOEvKBPWiICYoowxWR:iuisimIfCMcaeUfkg\\oTXurfaTKSd]GUfQuiIrxWVxegpGvoShTsbo[yqsUEMvIoy]IYFuc_QwsSc`[etMfAsRHaXT[eqSFDCYKuUAaFAIFoSXaqVTeIxiIA]yTmbSNo=`sSG[>ae<VmxpleobM@ulgg=FjBhcyqrHgedOwmyg?auDPZaVxDNeO^^ZFjFV_p^^D@\\iQmNibUhowqgqPg]y^;AmZIn<vflooEWncfvuWju_y<nkEQZVV_DyyMxdXautcnGUYmUyWgpAWQ;faMVL?RGiyOgF\\?vx[tUsgm?B?CHb_c\\KbuYRR;Y^=BoCuqCYvmcj]f;Kvk?Eo=XlYtl?bhEeXMiVSraCT:Gs_mbwWt[?fWWeCAGrCgpwY_eRGcDA=GlaYVKunmFYigAQBaucEUFc_uNmRGKB_]csyWhuSXmuhkusCWcoRwMiOyWQ;vpCfdsvHafhSD\\GxeETo;H;YrWuXusk>YshlsaElQhybePGtJNYkKDV^<RdyrSywOAo<ekWTX<LpymNbeWWpOgQvGqk_<lY@SZhugmtD]MxmWDuujLKSAP`IPMMl;XjT=uFllwEwplJHtxZ\\N@IRUPv^YP_PqbqXWAKaHUtHOZqwcIxD]R]mtD`M@mPFmUQQSOEk<UkBDU=<y?yNyLjalMsMvxxsAtm;MTq\\lK=V=hLs=YpdUK=vjuRDEVA<xYQX[PV`TmhLMD=mfQruqvqtqcpu=TSp@KrylitUParJtM\\LXw]OOaVluvxMLFtQhircQp\\=pqAPPXl]<Y[YSs\\uxPqHptpiSfqQ@mOYIVB=MfHMWep^YswHRmPYK]x>YlKQkH`R^<unXmUhLjHscYpVQxyiymXUrymyitmAy`yL`@pVeUyqo]MqvQxjUKBTtZ<TiyjUaSYIs[qt_aNTiOg<QclJ[ar]iQ\\]JF=kHiLkTYaTooay^UlC<WmXLs\\n>AwrMJP]xgIxZXX:IkJuo=lmJhRuLjSAso@PSxr?ylP<Pmll?=qYIk;YR;dPFdy[UPParUdUNtWsEYMpubHuJ<UUqutXuKTUM@s^mvfQj:<TAlxyxV>Dl=HNOaLDuSaalixNjQWgUq:pN;eqPxU@am>=L^YruxS>=vS<x:iNXtQyqs>uW\\]OCPVv`onuko<W?MXV]ku@YbimAQQOpK\\epDTof=mM<nKLOflLj`X]ESMtn^`oR@no]Xs<vYiMjLweyPF<p_dv\\qMnQWwlQa=w`hNT=mvqvWdPDhUI\\xd]TjhUQPSZHT\\tthqlmUp?]MTemmUyEttoDtduwlMkqxu`]lFpWR^_O>g?^cWPv?YlixkWxmKWv;?rYWofPoQiuFg]`hvO?mwo`>ocI>v`yevPkDQd;nw[A^fQpWF`rvaK`t>G`GFZQytBPc_A^ThtmAeHql[yaLioX`aa_wlWi`Fmchpi_bwnrthvsa[pnoHI^VivKYihghfIu]Fw:>ZZ>ZC_b;SSUtuEbCSXTsF@EFkIcrovy;WVUg?OgdMGcqi^QIR?t@ghSkePsHxydyeyYGxZIgAsunIeZYxBmwWwsaceokirawxgtjMfWgVA;xoqV_;dMYHZwt:QTEqr:WDtuw^iBSixAuwxAv;YbdKh@mijGD;[iKUEyyFo?hm;xHarRkEx=ynkuyqeISrngI\\gehGhN?bXgWGkHkAsTiv;;VaYwoWcC[GHqdNYfycxBulG@qOePmlpJmrVaVKdjnQKxqvIuW\\yyrykQ<TgdoWyjpPJHHspukyxX:EjsMv`mJQtUBPoapYbInBLyqQMTtxVXkEaQ:xO\\eRQqOQPToTVQMTrQuamrOMu[avMhqjmJFqRq=PMLkoEllLXvqPaujLaS_Ek<]UxTptuY^Iyu\\o@pvy=pUqKyXpGtXXxm@QrgaPT]JBdOlpUU`U]Ts\\tvhdrNXoIdwkIOoDr^PO]TMQ@J]TmhPkEhN>irmyVotKstw?YWE=xnYq[yMlQkQ`qSuMBMVbDYt\\JVWyVOcU_nhafjfx<akrwuU>]twrJPZdqrDqvWgqWhstxlDabhXoQikVQb;vdyfi?wjk`jHnhdGqeWnxpiupoCaqSwaHvfB>tepeHY]KHZ;qu`VySqZXwwbnfTYpsHcMnt_@gXfqIpw<XpIYjnAg<fl>GecnmpVqKIodHqSpv`g`hFseYcjVyg?wuOfBfclieQ`rZFhuOZkf[^GeFPeqY\\=QegVhayqXgrt`bRWqyoyR^gWo_Wwm<igO@e;wa=qhgo[m^fdNp]H`_HiVfiV^mLqZUwpUoxSQkLag@ftrGbG^jLIa\\?ydvlaAtcipd`h>fcmfl>Go?_rHhf@_a?`b;wogXyBwkr_xPnnqGdPVfLocQ`hui[fOf_B]YviAybkEt=v[wHwmDhgUuobaqeumSeoXRmFGQHDMYqaxlywG?Bbgd?ysCgFT_SfQxqmvYAiXLsaiWD<yv=tRimA=La<jmyNsARH\\Q[<umqj\\EmQTuixwO=s^<vMALvanAXOJXl^UPCDo^XtaxM>xQZylJiMtYpa<XVTm?pUFQSRyUTmk\\Tme<vHAWHlVMUQHdQJLjq\\W;eTvHOPYvM\\T=iyHdM^PPpeOGxqwyqhUNYpUxUt]qwwlL:yswQx;]PSPmjDYmTO@`VOlKSqlWArFmylDVEiV]puTxSdenNXU?eT\\LjxiQh=qwqL>unE<OQlTOAunXllHWqLmsPLKQPhxmUMjq\\V?Imqex]LPbQRCmtUHqWhlw=SbxMpHOjaRaUkbmlmuwiaP]@S_esreJeeS@MrP`Mx=X>ALYUT[DPduvfEnXISeMLjlXduTeausAOh]Y[qP<yJ<AwPtWWpj;`XFLwCuTXhQaAplaubLy@QxIax^mRuHXsxSlEwgptpPYh<nxhUWMw;eXt]J>HUkURXOgffnC@etgxnqfOxfhxmUVlTaxhylmgdF`qqwm:XpOFySam<xawPi`vhUNe@_uyQt?IiOynkw[ta`cVgI@aoFeVpqW@dxaqWxrjphbHvDW[RyPmyXgI;ccr;I]mt`kbI_TOEWxsgCCvoExriiuQbd=HDODs_GWgePEC_AlwLsCYm=lXgapgls^]JnUo<Lv`]oB]Rl`mgPrmxPfHLCDwXlT[Axv`S\\IpiMk[hof\\Vo`vnPN@<rXMUPIk_]npAScHPkQs`aPpdlK]qhPOuQNGYrDAN<DPEYWSXQZ]xpPpvPj?Is?]QTyXTtqxYsyqRGxywqLDuMjXMpAr;XJqUqYIuQTRdujCPu@<lMPX_Av\\llJUPKXsaexvIymAqlevDpl\\mwJqQiUT:yvGxr^xKwpJt]xvHQbiMJ<WsUVb`KkiYDUqryXPMwjXjiyNOEKneytiXGpQrUNYtQx]UwdluuLMHqW]KKuKtdUAALU@WAIuQln?YKhHvjIXQ\\mHUpDaMJxoYaupLlRhMVlJXEUM=XwlyruLXLYaHT_]lDHXdTtPyXgYquulMdYAduR`qOhrXDJyyjXitATq:lQ]tjRaoktRQQvNtSWiu[@NtLYcdZ?Q`pamB>fbAh:nqHWolgucinDn\\``ZrYkLfaCywchndNdlpeqApEFl;vjKxcJ>\\kqjf>hCxfHwkynssAZqV`thyhyZ<Qfr`oB>yu>tLGe;Auqnnjp_ZxuoOnUg[Iq\\di]khhs?j@A\\OnleOhcv^TffOX]bvndNZPo^;^rpgeaHrcV`s_cI^akW_[PwXXyx>pQ_qxWaLWvcgc^PtRHmnXwsHnOvu^hvVX[ips=Q^:iumAdi@iiasq^p[`\\eFnjvdj^`__]f@hcGdDhjZqswgjHvbFV^\\vt@?ti>[ZvfianO^mGQf^FcUan^aaBiouy[@hkd>^@w_\\?_gHbA^_;V]dVc_^vSIpEq[eijvP]fvy[qstOlTAc`OxYqfSwt\\vtHqjdNgUfo^YgRAeXwrXxetFjFisrnny@i=GGiHV;t]AevmTGMwLUwacXsKc^irsCui]BpCcj;ChYuoAHAGdJsBo?XyqvJWBsEuqEwuSdjSXrMIeKhTicDYEOQXLSR@qI>kXTuWOyBYYH\\StC?UNawQEW?Cyx[SU=wl_bkYuyQxq?DDsbhYyF=DNIwSYhtkgk;dBwGxsDn[YfShf=BxhoFirk`jTpuytm[lYh\\XTAOGApMAUoqP`AxsUnJXy]tMByYmqJ\\ik>usxisPLXraJwmPq]yrtWXprZqJtuNvHYIpMwLyweVV\\OPUL@xXgyrxHrA=pWex]MVllk^mYKmMDiTRaUW<wbUWQukNpmwaxRmMWYRh\\MwTtChqAPJRiY<ykiuyWamPeunQKBtTDUWdIJMXpY\\QZYRiqWqLJwlPgTJ_tyYDMjln^esGxvKXSgTW\\iXp]QATo:xyXYL;eW@QVGuQMxkptL_=XW<KpAuoHPeIyyQQ;HseIWfiQS\\RYqQiPsO\\WNiPyiTIpUpySXxyVyt`AlR]O[\\tgujOmsYPlA\\xDdwhmPAAuJaqvPkR@jkQKY\\W;\\mPpTRdTvdxiHn?=rXXJPmvi\\O<yqUyj;YPwMsoyLPPsBuS^eL:eWLdRbaVllXLPmTaPSTSXqquaTqPt:]JdLxvakXLl]HWNUTO]pSiKC]JxeuEuTP`L^TQIxRN<NCynmDxbqMjUObhn?\\JmYx?Pq:EupPjr=wj=M`toSujXXLnDKF`STQLvIWFLoLdUjDSEaVhutcqQ]DSwHgPwgQi`w_\\:gruwfNF`uisC^r?>mupsnYrV^p[WggWxXPw^>wni_GooDyfFAwZfhgnnoXyHFZjAvCqakQxa?pnQsF^yAa^tglBNfmgtJXdj`jgA_BHb[Gm^Pt]N\\WIdLIjvXyPgqkP[Uqbgya^QyParEy[uhklAt<OnbPsY`ZoOihan>AuqGrbXsy^\\JOw`P_K^boVehx^YivxGrtNuDhorikqwyU^mtFhdiccxdt?wF_tLI[]ouGHdiFrVxsff]oXiYH\\TvZtngNnc]yura_MWfaasSX`YydZFhaGyao[raZfqbEn`iO]`Vjxx]Ayr>q_=Wsqn[=GyKo\\Hvd[Au?OxG`lk?gNw]vAnEhu[grZwuX>yGwbKgc@@pjFqD`dpG[oht\\n^@W`bhdp>hZadJFnXVfJI[?`sXgihGZywycI[vxyQwx\\Yrypi:Wm`PhCifgXtyipyAhLndiWq;>vUikLAsg?i^ygWWbHFuyGZIiipOdAa\\hQafYjMyfLGe;pbcWvPge;HlGNeCFxTia;W`@v[sa`\\@c?grmq\\iWufw`txfSWyHWnnfi]VjXhuX^]v?a<`idpjSYuSf`@_vwI][>tuvvRFsLadPFxeG[_@jTgmPfoWqnFQZMPmOGiiNicG[XiehgclP`C?s[ivhG`P_xpX`<Ny?hjL@j[W_fQv_Wl@IcVac[>qy>oCVe]OpOHdBvgGNdMnuCPmR>l^AgDg[:G_XorPQyPNrAQayXkdI`xv]b`f;XbEOdU?\\yP]=AyQvg]>hZ^ZYqqZHvcVZqwZi@ggOaaVfCHhc^saA`kinUAhB>neqxf?eex[NwrWigFFfpnyUhtsnuwHbNQlLFnOxdG`negiZfadQc:_cRwvaVdbNc>H`jqmw?pE>uapohNwtnwK@Z\\x_F?^uWhCfmaxZnP[ApZ`Vieno<hgWycH@oTi^aGwPo\\_NtKxsyhuSw\\UWfxAb:qqjWa;pkbo\\;FuiPdwnc]_]_vnPHdm?kaqcS@gPyxmvg;WjcgxTaxu?^?YdBg\\J_edNvQpcy_ZYNiIyZYQxSA^:yqyiyiydtglIa_Yh[pWqYyoLokC_e@gwvYacGe@GxvpftfhuVsUa]jyiRhj[O^;pmX>aw`[twuyNo>QZeXjbXZ<arjVrGOioaxToy[idwn`fQ]Rnby?x^NmEiirvxgh^^OkC^mrOueP\\FVooo[UhlwvinYuaAlHxdky]xQvCFZZW^sOarxsGhyI^jZQ[T`dexjNIsWIoY_orGogXffipNPiay[wacypd[acIP[:vsOHfK>fpVuUa[Gw]Swp>ggyGeQIwqFfyIwjPiuq[kQhef^C`[hwvjPeUAlYicdnjpFigVj_QwTNq@huj@pEo`\\WjG_aAailPk?HkvH`mgdxyr]Gtu_ajO^:pxlQ`\\OZPijlQmLi]UPpyhjEI`kqsWOuOVctHgupa[PkgwypNZrwoMVs?h\\^wnlOvSy\\JXmGY^v_^^HkUOx]i[xwmYPt`qj[hw\\awoGrPNp[_yEWfBpmIPnaIlXfuQqh=YmPigdQ[RXm@xvdh[XOZ@auHPhHfpfgc;iea@jofuM@ogXtpfl^G]KFkjNa>^\\]yogNg_h[oygRx[b?jwNeFXvKXvqxxr@\\x?pQWg`I[birS`oP@kpXwN^p`Wf<o\\aQxXAeLIlBHlAwZOgiMa]p?fMhhnA`NN`QpeXHrd@ZnwtMXrTihUWkQ@vMI[\\?bU`wEQu_QdDPojnm>Qhl`ns?ZTvld@ililQwnnot<WorwxTOiTwtNNtLHdsv_pW@Guf[IwoWgyUb]sukVmkDGGGWWealQFxurirYutCyTqYUB\\xYXyVyvn@m<xsTDjXxyxUo`QOtDVvmjB<xVqjyXPduucmrTIJvyMdEVBEs`XOl=kF`JBuyvhtj\\liylJhNwUr>DPqIRXpyGHncykl@m_IjE`RtHXnuu]=xRpjjTPKtRtPqZtKUqLvpVUlsyUQ@xylyjQIXtIuX\\RpEQoXQpAyMhUr=xcqURhUg=mvHlOmqXhPmaLDUn\\lNGXrgXKCdxpxRHhJNYuq@suInXUqT<Jt=w_`yTPTkDyneKmtpl=xE<sqakrhlixnNYRu@YPavrIQvejX]y^`WmUxOhNR`vqiyaMNdIrhPS^HRyylXhYjxu;tXRQkcDUiYQY=mNYWUiXv<Ka`MUYtcEjEau>hl?aQPtWaHLOxTbASRDv;ANPqPQywLMNYiJZQpymkl\\NlmuNtwUUqkuJVQS?DodivPqxWqjdpR?dKYyTDpnwhLwxkpQNalr\\tQQxP`TUCHTLIRWiXtXjClStPyExLQdlauMvmVBuJWxl>YlGqkULReeMhTlhxtRxrTTloEw;tJHdjOXuaxpVeL]ERZtTO`S;lUpDQkDoUpqStTJyVLplC`TlqyTeW]^_sPyTOo\\Xhigc\\_eBNsEx_GAriVyopbVN][?xT?sQYxV^s;wZdFp\\NfinccqqRI_eQuM^d]VnLh[vGskFeCXbdxjW?q_AoRNgknbOGxhYeLfbgooTaoeHkd_jKagFYt__\\>AgCya\\Ybgvd=QkRFiD@ooV`yP^yy_QQ_B``?FxuvqrI_>Vr;y`G`nSOjCOc`H`HAlMOwhiltnqYQbZwfCa`qHgFYqRIZui]:yy[x\\lgyf?q\\OdB@rIwo@hmwCEYtmCEEaffcc@YBI[IZ_U^YU_akbTKu\\UuPQu=LlpMKtWPqjR]TvDW^@x_xqVTroyTL@Ypyl@HPn]tEHn=qQR`rutUQ<pleJFAKB<TeUUymV?TKMhRVAQUtR@=Jy=xZxM=tJvPyqlS=QPndX^YpCLUNxwilLPExLyvaHXaQXDTakYfBoenQiQy`TN]mqZoIvHFmO^^PnrmQyXVx:V_\\_efqeMpschnQ_oNFlZyfhF_:HdWwbIqaI^]xGx:xfE@_jX_Q?jII]l@ne?t?VttQmLW`ohd;>g;>clqx^x\\pPwmGdGN_<NuJhbcqjnab@VQuC=yF:_hneG[seGERwwWE=rJgeb=To[W:OVSwVtqXDCN=AxFDY[mxSHphDtBmXltjOPrlPX]avriteplgUlqLLD<m;Yr[dnt=WF]lixlBHkWyp_hj\\pX@QtUxsHxnjpTTeRZAWrqoNURu`wEINX\\QqiRSTVPhTlPwbeS\\<MPEurmK>`k;DPNMSWaPrUYTDKpTok=jCESvhyoQsTLo\\]Vrmyf=mlDygxXcLN@UKFpJVdyX<YHljKXqKtr<yt@AvTiwA]vcHLG@QTtmUqTWUpYHlHHqMIn=YtMuv`EVglTKYYvXS<Aj`eWVUV?Qtd`MuHqOAw^lsGyvNUtBIt_qtHUUDmQQ`N<=VNdpSqO@yQwPjYUQmIPv<YlqyoqxGpSTmOIuQwapP<SjLn`Yx@uOyuNkQq=<yyDx_qUiYmCDNPPXxHuRdpqlOv=mSDNj`sL@nIIRcyyRhN\\mPuhJ=YjuALndM<IqayLjyvyYuYQVQITalYgyQWTrZqOyltUppopYXej>AojEOILXRMryuTaHM]uo_HpnTTLuSYHsMUl]hS?qtNPwhxS:gxSWmYHkOg\\RQ^=q_gXxIo_NHfmqhbfu=?faveI?f_qyBWwFf]mYvRYathh@v_UfrBNypFZNO]YNZHato`[LXx__[VNXQx=iFXqI]GbLmX?SSMiR^QvocgDCuZadeCIMSYMqBDStSCHBSsbAD:[vBgrgqF]CxA=t\\UTPayqmv[YEpQrOyvLusTIt]AteqSYIdBcR:ie:Wu[CdEGfqST;MTFCSZAVJkHkQXcCF:=hnmxtgruwHeeVHmvHGFbqRxwe@GfPgU@=yN]RwkUOIwc=WCACbQU<mHfGCRStJ]gDyvMUSOEDtCDkKeXOwZigCItgUVwUiRKCgOFt_E=awQyw:yYR]cH?BmqvdeICUUY;RbOYnKhIkFoESmasvEYNcH;CV`KcciemuUUex[QxDEGgEENMdgwr_GCQaF_KGh_Gd_w<ggQYFKcRWUtaGDgAWCGWMoHceh^OcBsXUihpseYweOyWOAgZeW_UB_aVSCtEWCtwSpKfkwS:AeiUWnKrOQGeKIuyxWWRIUv]uExAuUodZMh<qbOEIvmhRmcCIV_[soGtSQu;SyW;ryyRY=u^gRxse:wywARUgFV_gL;vGUSXoeCCuyMgh?RAWrHwvyOYKsUyQuq?xEsinYxjMyg;gncf[EXnOEtmwoIbaKgFKIW=rgWXC[xY;X]IdqiC:YDkOFd;FUcebKWGmiGiG:AWhUtJkI`;BHugXgfTwRX_w<ud:kIEuHS_XWWEGIWlydG?UgiEg?eQsgX?by;YRYCYudWAToadgQBwoC>qFE;UNwTo?iDGyKagpuCI_IJ[TtuV?]IVMEGKtBmihSEvOBt[cjksxiwNkfhofkWynuF@ocA;DnIejGF:YHyEeM]ip;VHKU_YIlKIFwDi[rNwVH[EjYG_AR:mFGIVISunWePOdCCgUEW=AcC;T?qG?AvO?G:?VhWbNMeTow<gFsaWaue=UfCOhRKcSwWGUFySeAuymSiNAVJ[dOltwIJ?tQs^cLQlmxqlynQ>vy>\\>xhqxsbVif?tCghoOsGixgftZI`EHlb`_Pfk>vpVXwlogSgfO>eoXneo`T_ZR@_Q@o`g^i?wLaZ>YZIoeT_`Dqa=n`o^Z@au\\iwu`]yQpVxrtGiGnq]G\\Fyioq`lypM@WoRk?BQyVlotZQg^UI;qvbyDiMf_kUJqS_efh]xvuhoCHHqfqOUhEUiiEXWEEQVCeUkKsJQTOUevuGfQDiAE<yynItyIDHsh]iGcqsMyfIUgaus^WGciELueucTpSI:wyImhJYC[=csqrTCyuEbXgsXsHimuNqgVYTaoSceVIyI_seBYXtitIwYNsBHkE>yEyygymc:UsCCB^QHLCyS]HSwd[eDIQYuUg?Sv\\itAqVDOwSUd]yv=SsH=UDAFJMfSGSPMTg[wtgFgSdGwTKyhIicXgihecJ;uNcroICFqVC?CREe==vYsiR_rleVWSyXCCEGhkSGBwWcUtNGFi;DV;h]OTReDJse@efnocXYBXeSXQhuYtR;Y\\]F@ESQAhcWgNGgcGhbiIZYRtKUPAWZgUhGFv;w>=rOQbdaXPCu?QcPGX`wFmOXHeEBcECkuoQfKAxpUwTcI>kXU]r@_tbMEQyyiYw\\IeT=twATQGHref[cGVaVj[yUgXcMVLARtsxpqTDUwkICPaviYugmRMqtpeU\\=eEqtwsypmCrghVKHukeKau<CGXcEdKTqaro=rv_ueCwUGSWySyYi@]duuGGiDnGEG?begekgWgkbDsF;mX[?c<aRTCrAKi[EcrchDwbw[BfwuYESQeXBKSUUVNQfVwYtQTNEgTosAqBouYEOD?=wnWgxsHdCtvoUYUeRsGdQwNkW_;tp_dO?WgWBsAg[wB>=Hauu=shgKskkTEYgbaITCTWyYxmUNGfZOtaSxWSwgSEbMS<sioYHyqTuotiyhj_elIyayeQubDWwJYfaYH@urdisXWhWgVAxy>yLlyw^IvULQTyxh\\WVPVQ<Nw`Lt]NGlmxyn[=QlyVxTxS\\YtYtYprapQsISvDx^YLjQyv<uWiYDTsEpQkaoEAUBhOZ]xdaoDhnWLQMiJAPs]<Ml`sUhX[iPAxu^<vhIR\\mpFxWwMyHLkSiVVTYtxJWPJl`ljmnnTpKEp\\=X@aLsUVoms^ivnLtkPk`DVClVVpROqWgUP^uLphKweyraWCDm_POH`q]xJwujv=kGeLk`PS]tcLUF@Mbhv=MyBpR]qxs@q@uJ=yn<=KBxnGaQ<QSoUJEXLs]v>AJkDnt\\XNykL@JwAwayrnHpd\\X<XJF]ORQWl<qcMniqXWYnpLLp@tdTm_mTOATAyjWIo\\iUm]l\\dqp]WypUdDoCLRdutBqY]ylQ@LxlM@uwMXJbdOBiPFhnkHOKeKULobiwpLmw@Su@T<=nPpvNAOkmLnXWoULsIwVll?AYKAwJ\\ro`olhml`r?]viaVKLQOinCHuPEkJ`M=pW_XTlanZ`JZilYuKTapMqPgDLCXXRyJEtYiho[PMeLrq]pMls[tOP]vT@O_]q[tmKUqAaklaUHUlepwwlj@<lMmYPaJnXnYeM=xvJ=M;yRtITVtS]EQWETjuUyhL=uTyXKHIRiPMnlN]USEmjBTuteXWeVaHMGDWlqlwhLlimmPmCHLCEVc@jvQVHtMx<x;\\qyIsqIMmPkiYpJPx^evTUN<pWFYnwIS_AqpmlqHPZYtu@Nypu:lVx<n^IwYAsYYph<mXXQMxofHmyxpnTlO`JvHWSLjlPmAxYyIWCTRseWyPxetq\\pUMyMvIrY\\uOtYeeLZDnPty:xvNltPTJB]sO]reeU@ujaeUOiOSILshq_]TO@PcISiuQo@TKEw>hqIlJKYqYYnXYY[Tp\\lrZXR?xtTlmfDrsEWd`jcYWcEJjuOHuqyxSu@WMLJfIssPpLuKPMsp<kQ@S=QlRHO[LpAYJi]rd<Z=nqXVm`FhM_\\=X\\=VnLo[lYin__IVpR>JAhYusieX_UTuwHweupcvsIgSWr]]UumGdoe`IsqmX][EpSF[kUrEYsUBWkU=MtZUix;X>ARiUVvCVlQY<EYrIvqyc:qu_urlmY?muEMgHqis;VKaE>oxS[HUCD<Qvs?g:We?keKsgPUwj_xM_XJESv?v<aWHcSLcejCtEEg\\MEA_xG_bpcRcAdKCuAgSHGrliSPxV_tK_@LfdmpevtYp]HOrux?\\pE=qKxKZxVHES>TWQHPj\\jWtpnavmxPL@pqYq[aLJiWnurPpVmQMs<PcUWgqXdeJIQXdPnVhYpqV<dmIewLMSDhUr`QamNkUPihO\\EvE?vuFuGpsq_wLYxBgi]_[K@pVVd\\HZ`IbnPaBosSxtJOcNH`yohXWhYn`svgTnn@vuIymnnaohs__[h`x[ypyiva@fqwuy?crV[[>cuoamasmNoewubhpYI]FOp=>yynx?hxxx_w`xLp^PGe=YsTiedpfLYcagsiFrKXwJ^schn=ogK`xFFbNhh;at^IvjXx@`_=fxx>[fxaGWsQxqvifvuasY<wcw]w]Mu>Qx@ibTQyfgUxKiuITncvuGHoUG=_V`EDgkhoctPyfQgRc[bCWGSCx\\WcbyIbIRiqWi[W;oCRaBnWxCSfNSdnmcM]igmCQEUrWdAQb:WXacvNkbGGSVmDquB<gy@oDwQrRERqWV<yXX]c@uvBWTwcXxqS=;R_YBA=r^?rIMcbmSpyYpYXM=hrMukwwK?ckstqUVmow[WRckfHSUe[IWqXNUxe?sicTnWYPgv:oyXuBvqup[T>YeHmcEwXeEH@kVe?wSSgGOuUgrmss\\Odb?FlAR>AtpGdQCRYavmCG:WddIVlsdXWIewWByxiod_KXJswXASrOEMOgB;xPAcWUIWUXMCUfoDPGVCSuJ_iLsDIkiWkewkYWuSeSXPQwCsthubfuVK?w\\EEcEHtSSioGB;uuIvSyEJqcOYiCsTxoHGCYaUg:[gs;WAMR:[IqUHcouwubUAE^ORUWUPSb]oRDMFNKE;KtmkF;Kw\\_RAkbtqv`OBmUiEQfncDwsYA?EF?yqofJ?YcmB;CxlIei;UsohBsffyf?qt``qdILKToMpTEUod=lbTxVXn@=lr]xdPjceWqLXDTme@wbdp]YliYy>lXiIuwqnNUvYuyoyUe<qmIY]iaIIvqYZuodmAtKWyc?kXxhPxyYFZxFipqbwq__X\\bilyWvUvuJqjGn^TGi=N\\NI[jy^IomNA`MpevVatAyXfjT@son]unhFWquqiTaaLnm]ywxqwiQwo^ySymwIuUo`qghRPuKY\\cYrB?wnNmlF\\;FuvNt_h^fpgDx^a>vwhqSakKxZ<Ne<GqlPqh?kPH[J>iuhoT`rGq_PglDHmvg_g@Zv?xkpcgvmVW\\i^ecomtgstFjv^abAtDWmiai`OcwPx;Y\\;FZpWn\\gfepuV`rg?_:qbwwy<Op@@xBXcw`wbiwVn`>^_GQcoA]vGqDY:]eCYcCef;oCwSu]WwaYvEAewodKIbhculYiQqGZqYmcbN_R;cg<kXpsfOCus_eP]u>mSA]Tx?VmourgftKxHoC;kYAoFWESQagOutKeSPetescVowtWsCwHdmyCKfF=UlOGAOXAafemrxyeUOsSyxvcti;bVaWFSViMWdWcyGEQQu`kr:qFX?Yp]G?OwLEU\\_GMOMnQrUTp`UMs]JghyQhgOvdn`cnXySieDWu^a^DH^_YrbgnP@_;a]lxto^wGxsav_aycjnkvBcceN]eNSbNWgd?TVccRghQifNCt<yDiUfnce?_gD?dR[ud_U=mYh?fYYDEQRc;bPmcQgTPKbLIDPCHP]BwmYq]gXMf^cr@?BlsVSqiqWwWAyjYix[x`wx`SSjCyfIDZIwnEHLmfAysBQyG_dcSfemFlEwwYXRCyesgvOf@YdH;uHeBIqCZyy:UC_YTcitmqf]sBImWXwCBciAKE:KBycIIkFIOEvMFiMhi_Y_YGDYHx;yZYbTkbxahDugLmh[yxyuyqIx[wCw=Sw[yiYij=Xo?b@uWIuIpqXxKbgaT:sTXWc]cUX]rxyVW=XREIFcyoQCKgstEuXwGZ;fiuW=ihayDOwcqqXSeXJQIA[hJYbPEW\\QYqMGw[tn]hD_s\\eBuyEiaRr=sCGYkAvC;uPsckkRK?r@qWYAyFEEkCcPKYIKYk;XNyCY?YjauxCIWMTdqbOcGpExdGgEwS=Ur^kVI_gEmsUwrluXSaviqF^QVO[GCqHpsiCCbjGECYsE=G@Qcb_gBGHKsCx[Yn[gCOUP=xnkIASRUor:sTPwDtwBWASYAS[qtYeu>wwZ?YZQD_Aw^SgGYi^ATwCEf]iR?sWEGf?V]ohhoEveHXEtLqSLeGUUEiWCQIE:_u>Of>=F>cs;yCfiTwYyFix^ktDUWd]CbIgeAs>mW@qI=CHdEwQqDOoOXpm_<mTYQjDm;MyDQlhyse<VFymvtrT@MKPsvEJhDkT<m^iVwqq?MNKLo]mL@YttmkgMvKYl=yvsasymx@Lu>IpSLYIAPf`PV\\MrUqhQXl=J:<L:`N\\@NdPlYmLZxobys\\]p:tm>ENFIXjXpSPMvlVk]JrIMLAJPTT_\\whmM@ywxQriUr^EqydpCAOTxx?YvIxQhPXAaXjPMKdPMdpqQQa\\JtyqvYsy`TjxVX]k@Qjdtpn=uRYNmXvcyw:lyI\\sYYPKQsTxU<hQi=OXAx>TYXaY>LyiIx>XQt\\Ps`RiqmntKeUxcTuDMOAxwyapf\\qHxQvYry\\rqxqwiWvIwYpyciYihvgpLHLQiYwS<r[HjAEvbeK]MxpaMdhOSDJGqPnppRdnV`xNEOWaMUPOZmXntjwuk>@X\\iQwPo>IQuUPe<nXetdPMtUv^YwcILAyNE@UL@SZxwBxL[Dxnim[TphYOxDTJmOyUk:TOXhOwDyFQRSdyAeYDyseuNh`obAKR=LR<L:XLihPUTo\\ETPYmrtm>xqQqjKxj<iXomR=ArJ<Ru<QxEX:InaAPsmOCXsyuPApm=\\MKAw<Myl]KEitG=uAhqDUTntpndqhtYJauraMGlmyenjPoCeuBYjWMw_xVhenGpvatmSAttHoQxTlUQ@]J?ExDXPqPPRix;hujukratUyOAUkdITMpuSqoE\\nKAjgpLQerBdr[yQV\\Tddjn]kG]kUeRvlvviwFpPhdXBHtJqkOEkZLxqPlteWXXj;exPiX^XnQQ^:Xc;_aIYhMXg[q`^@oLwo?atj>m<ph]OrOVq^gvuGpCxdIq[VQg\\`onw[uVicNoPOqS@rLin_fvfIeDQu`WgOI]<^qhHyQovkpeUAdG`]@__NNnMOoAHtG`br`khotUy`jYeIgyu^kF^[YyxXQf>Iy\\Ykinu?VhH@\\_>smNch?k]huu@hWob:^hh@oVHsagkLf[notRG[qXroyw:nyI^pjp_Xx`TVr<OoZOtMwnqArUNo[flvww<yZE`ixFa>olUO`sVs^V\\e^[bvl:ym^hjrQyapqCFa:gvqvimy`kAu]wkcysy?oQ^bs^j;@xBN^WvrJpmRArnau^npFi\\gpmcWggGddyfkOn>pq=o]>VyVN[r`gVQxBxhGO]ZNaP?b[ffNAkAqwN>lIo_]?x^?bepiR`h_QafP[lixTitb^raPcr@xsHefvdPApQO^:vhahbG>c=Pw[ff=?noahUapsXkKIZEOaC^w^XdRGZ>ankWjPHufXiJawJgvt_aHfn:N[Ci\\>PyfAhuVeJX]EWnR@o[hjW@plQfgIypgqvQp_pe=vmr@]AXiRYjJIrj^s[WkTvmvahX?rlPnOY_narcicmH^FhkUGuk`_<^Zjwj[x^]a]jNmcPvaYfD>mWnwHfZNogm`xD_dsxiPOvJXhag\\GFrW``IWqfxdCX\\JXpDGuJ>pEXds?iI`ZOYoyX_^qrLVdEH`[VkOPbnave`gJVqNVtTpiIInZpgEhoQY^KfgbPliytVFpc`Z<ow@OZsxlaH\\SFhex`y@hpN[Q`ia`]?AsVH[c`_<fibAcBgh<@mYAecN]Wppvn`Mvp_PhCnmVX[y@xjyi=VqoYimIef>kZf^DyvGxsWf]`Ntr^nEwwa^]BywJxiapuwf]lnb=^t[T>;IyOvYKGmMhm_iGCBY_uYURWucNgCw[XTCBXaRimBRavPCYMIXWKE@KY][yWGSVME>Kw:?x`]fK=vxqwWGduyccium[BxQtQoi>wuuiiYYt^MxI_hByR[aXu;HLiXFkhdAHLWde;c`sfkkYemSwOi=sV\\;hD=SIQXCmCYEFyqSxguMChZ[H^ARxkU=YsyeI?_uLeC]sf=?xDGHb=SS[WOibHQuBuyB;X^UfO[hEwRcUdwiDLSsRUUXatTwWlIyV;v[OhHcWgKUauiZCT>=W>Ic=uwdiTjmcD;yaYvOUfkEsOqgXYHsYw>_RZCtUCE>sbW=wyCDJUB=aRnSs?UWsiDjmXCGW]eC_EBBQTceUc[DLiDnAyCEU>yGhCgQiwXYvOeFHMYIqtjGrMygBqxSWUc[gP[VyCF]=SBMvoCHHSiw?hqUIhqv>[c^CWA[gWoH=YXYssdUbMEV`sgZcwOsWwGf`GYQWgQwYqGsp[ff=eZiVcovVyDAAvXyD:wv:=RwWYG_GnOXBAfQqdMiTwsbjYvw=g?QsBmeEOrLiVQMeEEg[oh`Wi<oVUix>WHyWcpEcJkTQKxjmHi=rSywLMEaEwL]EsEyfAu=AR]CdUoG:yhYygwEBfsi^mSZegpofCswOEH`WgGUWjsvF=ygwbxiGpqCgiyXkWWosNSIcEyFaerCX<EByGHwOcKcxwAirmiAMWoAsKWFqubICTJAdeYXysId?d[qkg]ZyI^@Nj:ny@wgSpr;Hl<f`sHcIF\\bIw_Y`Cfrjil[W_ywyAQlN?^INyKykx_dw>nYIyWxusIpCIaMG\\m^]HFfywxc_da`wRXqWhbA?q@VkY_aPWdUphGfgPIstg\\ZVn`QcHhdmf`nwwmAsEik^acSGoUNi]qdkAtU_pHaq?fbCPZ`x__hr]xp\\wuMH\\_hgrXoNagSGgZPgkgceFhVF^mNhkP_`wo^?v\\HbSFhcxvigxR`^l@pcfxm``Kxbg@pHVqyXZ?afGgkB?iixbxqg^FlC>hFp[vfaP?m>YZaaiYidC@_lv`L?eEh\\kh_ZpqPau<p\\sqqR`o_fl[Ya^YiwHnDxaSA[@qgWGZoWor?tfPpCoeGOfkivb^auaiji]F>ohoyWqbiPi>Pbi`mL?sfPoSxyta[\\w_GY^rAb>nxxvnkVqpqm>f_dQau^`vnlhvZdOZfX_l_]LycF?uT`yPXqOw`twiLp]LVrmpdTGd]@s^ogqYqA``q?biimtiaVndXQsTxy@Od?hi<NfJGuq@jca\\\\vb>>t?AuTWrPg]@oqjQs\\P_:P\\ViyA^yTFpj?]Fv```unf\\jF[xY_<NrcXwC_ir?x=@yQvwxApKxarWrlNatNkQnerGbsyh`ArB^u>^gxv_iglrgvYAyvAxSVvm^tB@sq?rxwZjyyCo\\PhfLX_aGmSfxl?anGjq^f]oygFqxOhJ`ZyodsA`K^yM`eTfkPwmrara>xNYdIgyRyxYQ^XOvJyyAquu?jCodQGg]ygogjh`eOIaGahIom[O`MHj;^b^gZF>]Pajt@wtpZN_[BpocgxMotvPqhQp\\pi@iewayi@kRntfNne^[k?j[oj[Ohda]evjh`yyvwcXiUpnaxfRH]a^`lwimatMiaOyphguthhiYiHIiIYiHIej@[UnlVojTHtP_]RI`fHkWwbWG[hwoMWuo>\\BYqqobkxieA_tnseXrVYxUflXH[o?iNprciuOVrBI\\kqvw_ZuGkRnh>?tl@^>px_hhlyxdaySOxui[WGZ;VhQNl]HaFn]BcWcVQWCiKW;UtvAVoUuLehZYcsQbtIUXeSPqf>Atfei]AFtyeBOVcivm?trsHZ_uxGuGSh^=YJqU;kutII;[cXkS[CH\\;B>qDKQB>EuXAItmwiiR?Iw:aeEqvc;bwCwSsT`KgoEwsWISyWB]ibmFoECr_t`WXiaTUAegeCniXjKyUYCRSX@aW;=BrGxvqT^ubMQDW]F[QflASXUUpKdAcD]CDFMebkSSwf:gyVwdgCbuGtE?evyIxwG\\_TDSwE[sgUtWIXwuC@EDxogJOgi]eomErMu=;sD;XAqXHSfNgG:iGKSc@=Rf;WUcdBMoX]PIQxbtkIYx>qTIan^PslYy;yuVLt<XoPhtGQswYwnEPmYxmHTV@M>Qla`jOmwO@qkiViqjq\\XndP=YY:hw?IoqxvoySaAkv\\Q;Yud<pl@JymR^dQcInmMwHtL=yR<lPoUy>dwCQXjLYd\\UfLqT`K`qnqLr>ULQTYeAPSYSiqjX=qCEyVpSxxmNMtUqupqPWyOEdobiSWH_gIo?aqHijR?eqH\\bygO>jQxsOH\\:GoWvdxpasnd:QjoisDgw^Yx_fwiwoNwsfvml_yfppgIuKfbyqmrnvhXg<WusGvCF]afaVgge?^apjnGdEQvJphH`i\\qoxgxrGoHI^G^bJx`ugseA\\PP[Ng=YH_CxpYCBSsuaRuiBJur@iT;[VqatNEIxmR`MB^WvCaIHsWWCTJSUsQfs;xq?cqOeOWVG_VKmc`?TP?c[Ss\\gOJpOq`RbmplHTrhjCpkV`JoIpAyRnyv\\yTgdt]qMMTNrlMStod`WBitUdyr=wKXpbHWbqyx\\jQpPdxXiQlIyr`xVKhm]Pm:inAtonYKMPvnQu_uQ]xkH<nkeWe\\mlaqHtLaUxqDuY]WqAoR\\kFPMQtJuIxYLk[lpa]SyqMTMuNeSdQXTqlrEyFPLVhXoPoTIShY[T@sKnxZ?vaWqZak`F\\TX\\dpv[^wOqs_`aa^`bF\\Sq`lXa\\PobfaX`bXok;qouankN]ivk=IhrpZiIqrqZfNev_h\\plD>at^bFIikqeZfgDOi@Pb<xnmqwghf;nySGe`A\\^OZmfqKnpcgfl@kQ>_MXpv@fGgdHVrGYvsO_VqmC_dp>du@y\\YkOPf[YhnAib?ZRnrmFfoOavf]DobiGq_q\\VwhWihdvrvV]Ey\\jAf;wt\\^_c?qJfl;qbfwqmxZApkVFr<Yc=Par`qNopOghrqpdweSNZ\\ffV`_pP^_Ybhyai>nDWj:wgXIwhPwUipWHjlgyJwcW`pIQwQfh[otDPiF>kK@]RYmbplmYpMxnAIn:Xs<io=x[H@^_nujQlaqp]TXuf@;bsAb;guk]f@UgnuBG?C]cc]KBpaHdShPeHdmc:?FQ[WqYFJQw?wdgCdSQFZurZkBYSE?EUFWCu=wRYWeOsNkFxCsouRpaRJ_wH=f_URUOxlqw`sC<KvWufAStdovckfEKv?wtd;cM[wAmEX;biWrI?tvEc`MHsexJgylgiAmUAuWykhaOuxAbNQCIYubqh;cyuwSmMB_QGiqWiOG\\MWU_YRsEEUF[kuxCBrSHJ_t@kWgsdnMETkY]Cge=Tr[G<Qxp]BoYiZ]HJCYjwC;[DnOlRIrrPoK@w?YPTAVNIr^`WQYXu@LSiLK@K`]JgUMUitr`rHlrJhL]LUp]TJpMGUv_esidrEuOyEoXXscpkMDWVLo[Aw>@tSIvwUreiyRUx]ho_EJxIUY]xNHKBaSrPx<dVoLOyysY`lgMpZQw>Uua<P<<V>@rDeUmDPFMsAXyZ]p:en<TYnApkTMiMK`\\nHereyvxpQxIxIXW^MxoyoyeyfQOR<Q>UuiqrvEJxilWtL]htu@J=PJZTJCpUrPmD=xBIqdPVHepthPMTs]uxPHR;LwT\\OTauTeWA\\qiDNXAYPePrquttlHtM[<uquQpljBuWDTpPmt[<NX<QMPp^hWbInIdMD=NLimLaNetJg`xhAkbHvbaUMAo@=jZpoOmom]JZUuBIvQHPt]N;HRk<MwXuAAtt`pHTXp\\PeHLLqYvqRiAN<tqiHsGpRC`OdLxvIly\\MK<vYlTJ\\XdUu<tkLuTS@W@TrItK[HxvqLwmoBaRdHsiysCLWomWdxQ_HKQmtE\\NHlTuitq\\ohmmb]rPEP`iJr\\yHDYGDORtpfuLOyrZqlXdxFYMPyp[`lglS>mLfHQjTyhYTXEwjYQklpoxMwxqVyj@hXg@o]dMM]OydnkUm<tqpXVpHrmTOZhoOLkuLyjTYwUK<TX=MoVLnk@SB]JJTQNto`\\Ws<Y`mYBeKNuwYXYKTQJdrVXo`QsmEVGpMtyXqYVcMyv\\YZipqDsqyYnUnmLJwTXR]wiuseUmH\\L_AtAYL@=UEQJvYX<<yfym=YkL@J:EuRdn[]J_myGao>iQKhRimVtplE\\JymwQaqk\\sjylLtSMpPtDmohXeqTvMxMxm>YKX=x<\\UyeyoyvfausQjh]seaU:Hyxhx:ATwlxgIQB@U[=R:ysHtpmpLcaR;TyY<MKeWvawOiKDUxJ<sCyqahrJ\\xwDL=]Y^]UwTxkDJmmN\\uvW=tfXuQTX_Ik<xOxpn[XsixqYDYn]KIpyfAPvLJTUsXxQEuxC=pipx;xo<tMG<R=au:PSqtKfEM:mkGdr>Yp_qPhAlEUKZUs@dU]hJKmKU`R>DQ^xrl=UvaySQSsdN?YlhqqeAk@]NHApA]QYIPNiOFTrYIMJuwUUXgpJyhSZyVQPSxis[DT;ArwiyTaRgXxDIyOqlFdrLHt?XtRHPjDlM<o?=WKeqLiPKhM]@xB]l>=RaYxOqQuilCTNUmP^ynhPQLQRceneMs?PkD=PSDTJPTlTOtEVn]y^PsBHQ>`wpqQnhOBLrOlXcEtSTmrHWlpPVUk;yJATo?pUDeR;eLDmWsuk=tQy<jNuSLTphdlm]ucQjylw?ikIIYqlLYxprAoeAj<lJXYRf`RaMjOpSIdLs\\TnHUZuW;lyFPUnawCeqJuPF=Xa<WMxmaxX<yyYpKiImuQVmlPTDLpIJaujGqtPqToAxCexJuoFUv<UV;eVJYt?xqYmylylOMLtiki]Y]MR<qXhtli<w;QrHiNbapihRluqMtRpix\\]Ps\\jxYj]=WKtoKhwGXst\\Y_PngAMBioQiXtal]ys`TKRWiA>`v?`ChnIYgQgrGGcAhpNGbEamNfvjAuoxcI_pafniIsbI^TYlhpai>b@Gs\\grRNbE?ZIarlOcIfhhhg<Qraap\\vldNfjwdFFekNbhQaaphGa^o^rbN^k^l?wq>_[GVx<>oMVb[i\\Inq_Gew`eQn[FvaRykWwaTYZrfwbQq\\oq<>esPdX@cJQrbyi]hdop`RVdo@nlnsvvZJXhDy\\uorQHx^wguWvoNajYe:XmLwrhxlhNtT?jKyb@fp:VsWQvMo]wPfxpkUYskprpokd`]Mhtn`cdQgufjAqjNWlIq^dopTQwj_eggfivqIvy[A`DyZA?tr`pxPsUY]@Yj@a`s_^Cvgex\\gYmTaTCXkqxmSrScgjkV^QXryTA?dQsb^ogx[cqcGtUBh_inQg]ogGmRo_eEUs>aG_usvwereCU=RiEBxacW]BTMw>GgwwHcoDxyyrUbF=Y=YTgWR_qCikWtExFCWCUujQfY_EO;tuIVKECE?iFaViGSsAH[gR=WRouCU;fksc:EUTGIeYXdQFWaXMiSqCWuwBPKUGAE_YbZARroI>gVWUWksuwGBwsx`AHPCE?=wvCx:UbfeHfug<wDegHCuxjCVRMgZ=y:MR;weCQu[iyCcB^QUkqTS?gg?E=;RBuVj?VdArwWRBkhsEhviBmGDhAx]SDIIVZuXFuB`WHQ=RdwbNcS@WbSmETcRZgt=of?CF_Ai=cGX]baUyKSwIUCrwRoGVSSUv[cEGrS[dBUfkEVJCvHuYoCeV=Geefe=Sxyufsr_iXUADs]Y>sbiiE:wXH=SuQsR_isGwsWwreUagUUQEaiVYgwIIw>MguCbbqskcd=MI=mW?;Xm?bDwgicv^iiiIw?=WCei`sUCExjOWpcrX?yuwrnWr_WcD;FhaUj]IQcs[kFAIDTmtB_w:MEXmXIcUSacTEHJEwX_BLKD??gFOHNed^mfIsrKwuXycTufGCcXat>MHPiDdgt\\GhNuUTcCEEuHCuKeWJoFaAc:ySTwrAqXNIdk]xwIfQSGTwd]yyvgw]QyTIgEgBD_iy=wKYxTkVUYVXuyaWd`]t[KwPGBk?ByaUhKBxCyryuvqvqKYkKt:]uuuwwOYKYHD=fqWVhKGb=eFkehsD:Ye=Gt?SsHIWj=yyIf[GFoKDFIFRgSYasoyUyixY=igqhUAxcwSwMSE_T`Mu\\aCVmDieWVUY;kDAsH\\=yCGXVkwu;b<WGCsSZoTE;iBUr^WFs[ErwY>CRkAHaiURab@II;cBgMYtYbuUVtCbDyF:mrc=UNYvqaITCRbgUvGt_iXOMS?]C@eYQwSuqvF_EF=VruW<UfAKXQYRuMvBCCRkHi[Cc]X:As\\_WNYCJWva;taor@IXZqWsssqiC]hPG=WSMMPMWbPs?Xu`LlHanAPUQuP\\pTxmkw\\uI`k:HXKmQ=TUKTPY@PkDVDIT]PqrIpgUNjisCLWelJ`tUo=JsqxK\\VATTD\\p^HTFmYx=yXpQoavC<y^atCeKKPtkiXPUOSHKtIqbmTuHYlIy[EPHluh@nRdJI`RLELreVulRI\\S\\QY`ujNPrCmMBHNYDsdmm\\dxJuOTqvB]rtPoCuy@aM=MWZTNI`P\\yjM<W^yvL<naeM;eX`ERG\\qfajDIoR]QGlMZLqw]K]Xy@EpsQpGYt@Uln=YPioUunniK]LVdXXreMYpopYN>TyYyyxyxdAwJIUlpn\\EU:xYh]MTEq[DwSAPsdRSpNi\\RPuLL\\mCutFmOPDQXPS;`UxTMFEXuYkhLqBUl?aqk@yTLJxTMyHPt<VnArguuxqxqXwGhxkxkw]W@ySCLoe=K]aqPixB\\r`AVnuSHDoJuQvHVulRI`Vj=w;IPkqqwqJ:xTamwLejMAqj<ngtkCut>QYmLUFiL]ERQIyoQL?\\johQmEuJpVThwLXMaYK:qtu`llHYryjA<vPTNKip[HTcQM`\\Ss<L?XS;]m=etUhuD\\v^xjvDNaPYuIs[ao`iJnLpZmO:AyHHwCxkB]L;eqyQkQ]s?UsVuM@Yq]MmNaOZpR;TmoQKvlm;DJjuyftQ<UkeQoOIpLLtj@WD@JHQVblxEInlqrUIrPlrKel`mPhXWS@ToDrrIsqixnXy[IvRmr;ap>MKk]rRDOBHnfMqjhM?aT;eQtuplmyh\\lmit<`OxyuaDLBtJP`KvaWILM<lPNiOCTWODPUuP>LQ=LmRqwWQtiXujpL:@NiAv^\\P=Ik[ETRDwVtRu@MK`qQtWs`xGAYZqqA<xuYQyukexoxPycttoTXW]T[Hll`nMUVDtMHuXiHOXuyn]oRYsdevDilPLqT=jymWPDjTxLqTOWEw_XP[TSTpjXuKwlyMDWo@RZun;@PExpr@s;Pd=wgCxi]fs=Qq:x]yAyAQa\\nwoyoygq`^gYH[Lw`papYhaeo`Pp`i_r;h]WAutAt]@]Sn]=auGPvOwsGVoTibMNldxriPZs?bvViPVeGh]CGvKXaH@gii]tov^phd_[wnqk>tdPu<Hb:WkIRFqd_CFrWrh[xgucboIYOYuMs[cckOhlwcT[rtQHbyYfKbHEI@ogEOUNoBDeCEwXx=FKeW>qFiwVNKR=GHdCt=]wBMDGYs<QE;?T=sUqSsEscwOb>qwBKv=GUNQhAcyxAGdKVrOEHyWT?f\\?y`Ou:agPIFXqY:eXqafsmbiiw=MvJ]CgysiQtPOCD;upwFAYGdcw?qwNOVNOBEKrT=co]vAYYNYEauIVkRMCux_dRSEIoEIGI_WcCIVP[TOKD?;uAUDbAUYABJoR\\Oca?UGORbCFoUsumhW=udgUtSVN?W@UXTixM_tHcCVEtP]RvARVsghEY_kWrYiqMGgAyOygweTeYThOidQG_gICuVlsx>MSKGDcSUSSX:ICQaToIEsmYxicNiF?MCVgG;MwAoR\\IwdWrGurDOd`MIt[iY[g_EBxIUY]CoCGE_VauIXAB>CYtMIN]GRgRRuF<;svGHHgtjacXsDqyRIsbN?tqsisiSw?xYexdwTciS@AC:wwwcUmKgSohRqcsEW]qBNqCo=GqqIhqE=EsWgbUySOacwMbIst;aFlOFWIWoQgQoUSIfggDteBZwRIcfnwCIwr:[V<oIcMekEBhKTmCFSqcZkEfuxbmEZkFKMrJqu>oFKeu\\IsuWrH]ruYh<kxK]HEGVjYsp]T=CHl?CSKxIItwIC>mC`_HS[eSSs[CF:CM?eq<`N]LkLpkr]pcHTBdPQQJkEuYym?YtWIM?ur_YX^uUlxslYl=dSZ]xEIn[DNGYVQ@K\\=whqqCHn_QKnpNo\\TtMPa<V`iRB\\yclp\\puRqJyaqJLNIpK]TNZusPXK;hjoMwWXTEyoUXQfQLg`ljLyEhq:]P_tw_at`QWNevjLQZdlMduQTRMIyGPUo\\Sd@kCeVHDQCxwIhTEdo^aU^LTC\\oBpO=YQhTYuPSjDuZ=lQYQaeOjQUw`xLYSO<vc`Q]]XEuv@pKDDWCMkJ<sYySHpQc<UrXvHXQNPy[ixDQWVmpvlnvEyrEYlluI]w_xqwUypelptoSUp`AqqalSqwVQmIXW;lycyvdhJbHwOXml\\SLMQ^PVbIjjxXqyUTASGneDy_Ciel^KkIMeemQuQqiPsEsAsA]tmOvGiR]WRiUsfyGxmhtAyVOslMcaWsmUh[mw_=gsKtFGbwCTFsdt=VIsdJUwhOxuaYnQCZsxM;RQut[GbVWIuIvFixewHy[x>]SGGBOsFnquEGiLkCYyH\\;ViYDJsCH=ssSW?;tR_b_QEXYDQuSvCIrkcb_ipgyvqB>choYROuEiWBSxWXPyT]tGYLI]uaurXyunQVyiUw=WUet:@pvxPfqpadLmLWjYsT=uOLm_IrruS<DYpTP]ulImKftWjaQSQP;AJheW\\tNZHQtAtZLwQuP[XvdIYBux^DLs]WREwOPu`tpPMwL\\xOAuUdoPlrXlMLAt^Hx<pPr`VypwPtOLiuC]rpxKeUk_mT@TTWYnXmqRTrrYjwAKPaLJAqvpS\\TlNLLLDnjhRmpKhDL=ITq`nH=rXIog`LdXPxewjqpuePi<lExvk\\pu=L;qu:lQjerA<PiErvHkiqkZesBllZxSjyvoyrpQNnmPb]JbitM\\lCESHmJVMTK`Mp\\RAejstNXyNvmkUAxtpQX<jmLPZEj[tJXXxwDwvAPqlPWXj>iYl=YDdk=HQferFmxl@qLxqIatsmLP<vyTRPtOZlUj`qb`SsLMG<rMiUR]qjEK`alcMTm`sjql:isEHu^yQsEpMpN\\iS;iWx\\y[yKepWYPTFmRJ\\xF@woYt:APnpVxAjLAQLyQvHqHepbXwfEJyaysTKj`PvHKShQh\\xfywA]qnLJA=o<HlwEO^xbkvimWkP^bkFlDwoT@jSNfepjspa?fxkXrcfdUaxfg]?WuDQaw?HoIKqRRgTdOb_CBkQvUoDA?DMsoHXuI@rciLJpwliTMhmhTRs\\VmLY]ylehr\\eRgIsI\\pgpW:mPPxrbqQ]PtqpsOeWkATk\\QdunGTRIxRoAyPdQymLdMPfptWDRh@jdMLopnTUM:UV;EobAtwXJT@VgXVLdTHhsalJCPywaSiMLChykelhMp_LJ><wgipoLWJLTALVb=uNqnCMwltnKejdhu;UsnlTlxk>qmBepRlk]uMItNJ=us<j`hNF]wthPY@RTpNcTys\\yEXrTqQ[HRF<MGDkLiSOHSwMXREQViN:eQ@\\Uy@vg@YXiVIewGaRAMjslN<xPwhXtey>TYtLNvpMIhL_PtSDVuhJ`ymb]KrQMPMpMpJWPQg_v?AkS``JV^YneMany?]S>`lomhvb:Q[qovM>o>X`eWg>^jnyhTFZhYjqQkOGxeGZxIa[XjrGblQ^_f^>AdR@vIymnQlrGdLYj\\?gFY]GHfgy^xFxCfo\\_iaYaYIyNv[Bpb:peMVy[Yx`?^bYhy`vUGyuveyVd=_eP_whvmmP[mameGdhqx]wvWyjJy`JYkswseXjy>w@Gp^oht_j`neSawEXbSY]`gZJW]p?vBYZVvbR_diflXgqUAZ=WpWNjCGo^vbl@sBH\\S?yqfwBfspQfjwfFFt=G_OqwmFgewhTy^``h?Yym>wu_^<HeUV]Ka_XO`OPbFp^\\vjM@kX^cd>bLps[f\\MP]DQf^wdVfseNwohb;xpkp\\[pbQN`AVnTGcfaglQr_ihc>eAiZRX`=F]nfeRqn:Xogalsx_kQuwWh=O]K^rqWspNZHaZeOitIdkqy=Xkei`SVcTqrvaacqwdg_<Wx_ied?nbvqF?`C^qu_ZgX[?YeixhcPx@w^UHSGxkkxgIXdUuA?yx?idKbn=DFeWGOswCi[EUxmRuYfr_uoaUvgxTwhd_WpMw\\;RmKx^;bMOI[USIKttkVwAsn_TX_Uy]cdASYAXuSh]kFigt]II^[BbYUieiOERTor;?vIqEwsrdKT^cwCYy;obBGthcEbKESkIb]XrusKMIdeSGQh:sqaYpGpU]\\xr=YKLLRIwGYxsIoCEOt=Q^PXbIrmqJZqxMHJYxLntOlmw=xP^TLf]vNEw?Dx`DNjYtETvxIYkxsr<xqxToYyEuViPrL@r@<ymiSR\\wWdrbmYBdPxPwveTmxnxDqrmPNUMcqS\\=T:ppmUR]lLXmuhXjMmjqaNJPMCIOWTvD\\TAmOduxCIjflJ?YKi=UJ\\RwQj:@YcipBLS^@RqyYfuY<DTC`LnXm`UTgPMNHrgIL>XqvQqGdkCdqruWmxRGdJw`xB@MD`nRdj^ANA=J`@txpoK]k<eopYxaxnfhTf^ZjgpCOuRN[_Wmpio[x\\Ya^XPqWywjnnVGe]Xk:>ZZ>ZC_b;_d@G]mIhEft<h_dGwwWh<NgbPnUybJYymXjdVqfOuNqodVmDpsNipc_pJX]GQnZVyny_BFseaqjWspgyyYh:fjwVrb_ayHZoNaM?bH_gGgZkFkVNxLfnn`eJQ[ywd:Wx@Fm;akDQ`S?x?ogYhlwHmLo\\GyjU@xXhkiQb=Wh=apHO[aYsL^isvxsYuYqypPjxF_@YvKAk>fHII;Oe:wsguS^gu<sgMMEDStsKViMg]iFfEiwCRYoCJSfBkuq[dBUd`evuMdPIfKIhtkXT=bymtQSDh_iRCscMx<aVOaG=iTPofIeis=wsYhQiIMWVf;iT_EHQxqIw<IWX]t^wbrEbMACjuynQyGqIxairyVTuckmxYGge]C[Ey<itR=TmoD?YbX[xX;EN;vY;THwugqxByvnWW[oTyqcRKE?[iUkvQufTEyT]IBsskYFmKIHGbWCTOUwJUWIaB`AtHQWKeTbWtAORp_H[Ow[_Hm[u_YtmyEeprJ`qhxWeAorex[]pfPo=mUu]uQUYYAWYMmTPOjytiLK[dOKTrXxmqUoKExoPYnxUvdvVPuxHqRevLIWZ\\Ms`QtqYu=M]ukG@rutqHdxaip:PjIQXcPPcYjQmNtywMUpiiWILVv=O_POVPUsaKfMr@usVunXEM=YtmUr<<yCaQvXXehUiDWF]M]EKn\\OnYN[lJfdO:pwBLQKMMiTN@QrpDkN=yteMRtsB]n=yo]aKSilndNUyN]EONPyE@isxg<ijeo_vNokN]QFyuotS@xTWn`qmNXsInijYZVWhGi`IGdRh]qYa``soaZcf\\hwbTQtf>knVgNokaabkQmaHh[ihiOkW>mbin]graqs^wbSW[ji_:ya`QfR_gH_u\\fk=?xaiCgTqWdQyxywyweikoWxGy`eSVgeFQvGMs[]DnkDfydIeF?sWNmbu_tqYTQasqYecEcXmDheGY=hTSxgYW:Wr;]XiYE:]gj[cr]GC_RYmCWUeTGDPsCVOdHQd;IRm?ve[u_iTZssaWSRyYaAbxkVMOeSMUa_DDEub_xoSy^YT<?SJyXEwRXYyZAet]xF]rLYe`]FZ_xJeff]h_mgLIGS?SHCGkqwaiUKqcJ_R<SfuWvB_EBMwYixokG`aX>[dMiB_WYTarr]HGyx\\SIJOtxqyFMhl=sBefLetHySnCS=eToWdv[D?AyZMEWwgX]fXYIcOenIfrOGh]UGgtxWySEBvQVV]IviRoMV>QcBgykAHTwVE;vgOWJQrhOTh_cKwRAEtqyf;]tCyVIcGboDZgTUwhOUxIkGk;CXqCY[UGQDgMS^=hskXKkupQcq?wfQucWcHACmaSQwUxEi<OGiwU`[WcIYmQy_YxaMXW?SX]cE_TKsweSTsqR]EVLESPOXAQBvYXAiUEirAYCMoUFcinMgJ[sxkIMgIZKBlYUXQxPcH>[wHGWP]udeVaafgqfxyeEWFRCw[AhOUHMDwoYm=TuSxNZYWBEyJYxaUQBlyYxroTlrlSLeQEyvgprLPuoAOiYKZIpupx<yq`@O:UwcpNSesxUQ@pOY`pIxPfqjWYU=`RymnTYxxDU:MTvlUt]pVDobUXZMvo`JnaS^tkxyjAAtxpo;TKh`wJUR:=n`trIUjJUMhpsIhvp`vxxkvIYBDNCpNdiNd=VHANbDl=dn\\HlwEK>qK_dldHNgXPvAYNUXEdkeLwZIlBArYlLIdYrDkBYvK\\lfiP<luxdnE`SJyviiRkqvAqMVLRjESwPjwhueAjYhuddJfXvUyROPskEpOXXftNXYY;=Jy\\kbYJ=<x`UtT=V?IMt`oBivfluN`Rg\\SvQOayuQPt]MXtiwTDLRHL?tY`eW]AmYxmIxYvmuG=WhAWsLwu<N_=s^xNixSXuPvpWcItM<SSy\\iXctf[mfodYmAab]afo`fj@ZyofKG]@>dIwdGXcCOuQwqtidvXwWww<ilQoecx`bFasOigaqZHwKA\\NIoco`uwkUXyZ>hMXZW`u\\Ifl?yeotD>xowhYiiqPsyFmfQf\\xtnAl`_ZrY]mohQhhgPrtqsEHlr^mAIv]vjknwHGg\\qtXWfnn^]OaZptH@eiO]wwk>G`uQj@^hW?t\\puuOi^vj[y^\\QaHFlZ^w\\wbDGZMO_jOyXN]?xqWYovqasYhiPdwniWyuRqu>NvAXdDnxvguBY\\kfluo`fF[OWnE`aaPeSAvcOh]>_KPZIh`p_^GHlWHh_Hi`weNao@?oJH_cGtR?n=YZIXo<`vXH`^nkB>[QIk;h[PWlt`yhwbiqwATmIGZYW_oWkOUwUsaQW?AW^qbl;SfQcZcYjkb:Qh@cWRodu]fIcweYwGCYc[d]ycxCDOAs^mxOUhNUWIQBe?i>EFn;COIrdkXGyW^AdAEWuECqcGxGT]?rcWcKABu]um?rJoulGwV=ts=vomrBGdgmIxYxysyMeivME>SWS=biegM=UFmTwWvWswJYehYSYMyLOYP]xp?Y=Kxi]f=?CraTF=tMuFJUH;eV<_HGKrMiFb?wSYdpIvGqs\\MExwBmYCnQyuMYt]Hc[SjyeCcjbImAPw=@UMIX;LmLTxKTuYhRq]wZLkXaOdUJo@Xt\\mTAMg=WA]MGUs<LJhpUW<q<=Vata:omXf]AAshaZlOvoy\\?^oCgrJwkYwqb>ovAawXiOhhl?isWkUgasOjkAwhA]pgyrPsSyss`qoPwgy\\X`nt_h^N^mG[go]?vitWy^HmDXv_>avph?viW>gLool?w;q`qNgLGeFnysxe]>\\qWpYFs=IhgYjYneWae_UMurIaI<sFSEyV?xGYCcmYZkxBAHlItVKtusRZudwAxi]deMxaAyjAI\\YY]AgM?s<oR@_DJwXP?IAcSfUgVgRluY<EGYOSjoBSqefkU]yYokUlGy_kbTuvcWcHgBiWGtkC^OBCUwJ]W:uCYaiHAwn[yjyby[t`KWikYkYcYOtqIsTmDZYUeaBQCbvYxYwyvkUsQsQMvougueu>=YGeCmSdI]v_CyMaEXQRjuvjgdMGxDIgVIf[AHOYCVyFi=VtMWVyFOiIF?GR?B]EVEIclEga]Drir@GDjmTp_W>wfiGMquRkLTfyR``l<]XYmJGXSF`Jgmqf=YchT:wox^aAyZyWkQWlnXuyxhJW\\ZXpqv`cfuKO``AuPhkPqZ>vippdZPiaf`nnogN^VGZaNlwIegws:quwV\\=WseHnTPtD_nlOg=pcNYcN>\\y^m@_dFP[MVpn^Zdvrfnd;Ym?ocBok=YvfVfrIn[_rpqrJQi?a]sw[q`gM_`OAoMVbG_cDnnpHuA`ivvjbymu?txPrI@t<@^LNxX^voihBGy;aj:^qQnuSittgZoayEh\\oQwwg]xf`x^mgWajAw:n`ay_>ikQaqQwayat?gcufauosgo^_>co?]]PbmFjdOd_^q`AiGfigYgYWdaFjgvaff^FhZrqttFsoInIfiBg^`_l\\OdOFr?afSFbRx`NFrYpuNF_WNZyflqnnVVx^?iHYfG^g[?qHWb:OyAP_YNt@_xlacgwaqHaQ`ybXtgArvqo?@eSnu>Px;v_hyyOY^bHwDInkGmyP_Y_j[XinFaxQfordEFI?Y;aT\\AT[UHrgG`OWXsHO?HogtS;ibcTOUR>cyXYy@eT;WHiQgp]B>YTXsc^AHlAYFCw[_oyoqWpuwv]voqRhlbYgog]vfko@[JGo=qbjWyM@kW>ccpwWY_:ymXF]AAuMFhnvoe_\\=A\\>Xo\\>ZYh_bfxNG\\jih?`ud_kFqyxi\\]a`I_tO^axnj:XoBHuLfgr`vrhaLFejNmr^xMpwdptyWfMHvWydgnjTvkLgpr`kt`y<?q:po;qcv?xLy[ZhfpWsnpk:fapWhTWms@m]Ivop`oYia_jBGk`ypxhxgfktv_s`vLVw@np:vuTw^t@upGmd`mEq_u`[iiiiYiYPrwXTGCv_t=UDjGCtaH<kfPsynmTLKdlIFJYTPqRHod?mHnAycIykiIGQS]YXSQhPYwqAVcawO;UQqYC[W=kWnuweyJG]JptY?ek<hsPUnXIP;amnISIiY]<KB<Rphog]jyXr]`lE]VYML]XqSeSUMTHpm:tSWTyJqpbepqhy`prd`uL=XHyu[ijihu=HxrEJ]TQ\\PJnhVrevyIPtEu<\\vgTweiLfEyvdN]`ThAy?Yv`IP>EmRiLjyMSqL;UrdLoa]yDywQQkk=n<AKC`K\\Yu@=l[UPmpJiHPNdMMTti@YFej>mMKYqH@ncEpQlWsuu<MkMtofQYveNklP;ExrYlATTRtMWtT]UT=IN^aoFioTpQ^MKS<qpQQkqqOyP\\ayOYW`hQa`SrYLjIwR=TDYsiAYdakAxn>eUlyX@MJFmwl]v`To=IU^dVgTKjiooMJEpUwyoxexedOrPNRqSxHpBLwN]SJxWatpHqpE\\yyTlmxnM\\wCytTPwFLMMnwRf[j^qaxvIaa<fv^`lqOteyfhHj@FwV_^tgd=yuJnrsY[QYf;GhON[<>gwiu=@k[_ZoFrl^aoPZJQ:uu=SFT=TOAin;gw;YbixQqts?Ty?H:sbUqF:_e<MhiSgnwB_wdSAWXcgeUENWiasrimxx`JhDW]lxZHvpeQqeKBxXYdRAqv`DJqum`\\UEqJaTRIQmXppImpG<KbxxYYP<`o:HpMMn=DXfIvFLQ[UVExJDQQUXWKLWihRs]N_hYbYK?PkPUwlDMWeMS=U=H\\x^j\\qqK_`BIhKxpaQs?OxRVnKFlaQwPotex\\IQfe@qR>mfwi@WyfA`LFpsigBa]DAv_ivQXv_wlx`wcV`jgs?qnb_njqorPvDfhb>mMInFxlYiykQ]WH`\\Ynf?mQi_AFyjP_Va]eIggV[jioo_k?o]nqrUvgNgmmybyNyKY\\\\YbIoZbI[HatIW\\VhcwiacA^phooFrTawYObD@gtt?scC_YhSds]B;kR;[xtIglIveAiYWXL?wOWtJAtVucoSxQYVxEW?;XBybxYF==wYSw=As[ACdyv>Gtr_FvCd:eHAScmYxLOWcWDZyfa[iaqch]xWYI<ocEKEK[e]igpwWpshQqymctpwrh?dMUf;GtWGXGMcPKd?EHLCI?CXTCCZISxueC?vBYDkeewSIyifmgdYuchySZctMGTsTqapR]TJHPTnipsHluLLAMYI]L]atVyTf=ogEx]dqyljRyoH<nNPscpNYXrBISMDLfiU\\=q<Xx=PuA<kuIxGqx;iOKXJIhQOim;mVbTjB?[hncV_kUny`imjGiHpnxAcEA\\VI__in]GbaOjnpkSitlIwb^ahwq\\grD^iqYqYirPh_U_pOPxkQy_AeEQZvyfwQn\\IvuwuuqmH_ptFu<WoaXeNgujqb^Pt<`dJHegWyMymxadwFaXAu`HZ[i[xahDX[tgxn>dV_oLnvGvcdxrNGyRP[YVltIaeWcjGo[Ho;Vouvt\\Gkmg[@ypu>`r>`>VuvIhRQj_gwWXdgwbCHkHplTAnG?btvlb>_Zx`h`[]fannonw[w^g<N_oqx_WnKiaoWx^Xf@v]D@nkgdRfmIYgMo]yFh^f_X^iHnySqud>wUuFgubqe^KH=IInkeYufK[bagrg_tJSd?ISseCY[vyIUOUEu;e<Eh:[XV]u>sRc?bfIrRKvAKTb[EXSReQw:KCSQhXSTdwHGGvAkROOwcEYHUSo=gsGTBofGCtvmXrMUwKu^gG`;VXqiwgCYkilYRbEeo]haiS]wRCgFMWx^WCsiuS?BIywiaRmiHn;DFoHSavIgIf=GakhtytR=bieofLYAamber>HwydyMyQWpxL=X`TvRIRJ`xFTrgMJxdtR\\tuYTWXV<lyCawIpUwdQ<Mjwdk>TN<lLqELZISI<TpIsUtmvtyMiKu@QgYkOypoEVfhUnHJeQUqTnrXuCXNuUYJ@XBxRVAUgqWD=vQIqsPv[ukgqSD<u`DPE=jpHVK=S:godgw]VqM>]Ipv?Yaq?_OVbH_mCOt;ioKfwZHeq`^^Hd=Ve[^j`IyOYsX^qi_cgOkQ?ZQ``KFquqlGh[tQyLouR>c\\nusFjYyu_Yt`_gSF`jfiqg[\\NqunkPYkTfdgWb=Wvcxh<qlBA^nVsgvrWWoNncUivg@sEI`G`arNoKfb?gtynxdArnWe?AlmodU@sO^e??aAhmrArdxx]gsk>iuopPnf^xrBikwYwc?pc?tGI[PWdGn`]HZXwoFP\\sYlQQjSXs[Xn<Yw<hoNHw[YpEqno`_:ypPal?IgPwevQvQfdywy\\x\\w@wnxwYpuUFbRpj>@^FgxIV\\>awKPb:yaSabUahw`ibI[Th[l@csAmGHvrNnHxwCo_ragegpOWrYn[[ay?Vwj`plp[]Yye>uYyqQF]QO\\HAp=ngAXeuHgH^gWVbEQmtfdfA\\JImbifLptyVs=`dyobM`psafKwje`kxF\\QQnep^kAuePevQw:V\\<hggWjEWmLh^Hvnk^xZA]@wpAAttGb]NZm_iTirLAc;qaSYbAO^=Pu`Peo>]Kiekgw@IcSqfhnlQIjc^`nngHhfFFxsQZlVZS?q^W]xagyPnGFjsGZ^v[a@lRYmNYfZHdjX]sGjlXnF@u[A]X?msP]ipuvQwCPwXIsE`\\Yfvw`\\C>`a_bSY_OFfvomNv[IXhlAdlOhvavdIywPtc?fexgLQiMHixixeyteWuho^kGe?XsdOheGe:xGMttUxUwuf_UtyivYsy?gAaYtwD=UXhyeXyDiMWt]VFsicIYM;iGQWDYt@[h\\iDluun[Hn[B^qyCKFF]xTgIHysdoVUqr@cWo=UUIiCcG]SxJ_uUWRyASYkrLYVTqD[GWCeUoCwT=HnYw_UX>EfWCfsqYkahwKuZgWYyS^KSbIsZmtmMeO[fEqb^ItVcWByttQIvKseyCCGD[MTS?rhWX^eBbgXFUVsOHk[S?OXKMt=UNC@Nv`O>pxEYUnxNxMlMuqHlnn@yePuAtu`huoTvuQlDlxxIYx<yt`ydHpqysoYWUejnILses[`lxmTDmPMYvS\\sWYu?XMqduB@R=ItL\\UDYYSdjktV^mUmmVQqTppw`HTayXnDqSqMW`Jp`w`utFMM<Tpa\\LiXOmXmeDovlyWHt]Tlr`w_aVGxNn@JYQU@QVeIUlqxiTYSYsjyxyuyqyV^iQB<yvHQCEMKeW==raikFuweaX=hQQDO<LYs]llmWTapCUNBLjDDR>`TLTwF<yM@j<=jrTUtpYt]y^pmPqPY=jh`x\\]xYiM;AM@@LRavN<XoXn@dPMTPceTHyUdpL\\EX\\lLUMOjXw`TlsHS;dYlQxhDx:iMxUN[iUhPJrDoZHL;TyJQn:LqhpWMUv;qx@DSkQySYNA@rIiwNUritQAxp@]TGYTqPPfXtb@OOaxE]R:qQxDpwDK^XqmlrjmlLljq`kZ\\qv\\kJQtZppY=Nw\\nXhQoDygqMo<R>dybuUVlx=ePrHV;iKREpfernxv\\yNyDyCpNlIYG<PLUmTItLxtAatHQo>tXtMxfHJ[Xn:UZLnedNq`Vtp_qHAojQ^oXb]Fr[>wPg^hhZrqtLhrkhj^qcyiyYyywOe__scWnox^GgvtVtCa``vgCn[VPb^oubaZpOZ;va]HaAflnOZOoaF_]mAub?ZHqb?woMYv:wbua_V_prQdnhlaAvZYnWA]Ha[<f[_>qVq_OwtbGxMF`SXjHyZm@]t?aDpoeNeJAqlpc;oam^lMajfFjXXn=Fu^hkKNrBY^Kg`PfxeNBybDGe:sRhKXROsHAILQv[wtrMWFGf^CSgyXMuitogT=X?aremiTQdS_xJwf=YgKoRD]iqqiYaCbmcZmseMiNAEjCTemDaeTReUfsgquhrGvSwv;]Yq]EiGhwoBiOiliTOUvlcVK[bCirM;tScXKMcEMe@GyWwfEMhmWb`cR:[cLqYsYsYMwx=E_[SgGsjSUnUHCWs`=bf_roofHEU:wyfoU^yIsCtdQJV=nOlpmdYKYm]<UJ\\KsUPmqVaEpHdQtUpE<o<Lo:txkpRLItUxnq<SdEkZHR]uRTxjDLN@]Jn>gVns@Ww`o\\bgsgAmAhpxYkZYwgxr[XjAH`VowAXnHq[QXt_@^Th]EYf^Itb@Zr?\\XGZNo[EGnphajvsIvdBIjbqoNNvuYlOIZ_Fk\\pd^qpV?uZ`yvGsjQrCnvhqnT?iUaub^nE?cXNCkYbKf:wIuQwPeEi=SIkUuEwRcWU[sQIy`UYoiy@kyr;g@obKAB;quSuvNUVNmH@;fegY\\OGbkE=qb>qBvwwdYEKUwuKyVKHcSStecMOLlQNOTrmesmmQsYQVpxvEsqQs>pOm]P`AVMlT^QxT=mhYy\\tjImuY`Yxtp_ulGUWS=jyaoW]qKlYkYkY=W[hLsUtS`qRXJrxwxXyNYMaisHaM:YjIlQbpR:`xFHmU<v\\isyaXndKMDqffbwq`Mpj^IiCn^VyaM^s^h[FIjgvfTY`nqZw>aiowl^_fno:GgIXZA_rjan<IdNV__^;[c[[ij;bjai:OBgsycodYAEdKDVwveoXeaDiuYfIxrObwSue;dDKgRKyIQc[_eKae:QFyOYWYRUmROUSIIEo_UNevbwdI[IS=E?yyE;xIoInkfdoe:QrZOTqCxWESkQyMMWZ[U[ufH;T[AXQ_RkCcTybeExxibqCfemWQITYWdvgIcoHdWgFqWd_cb?yuYt;gisgGcGIT[W@Ec`scy]G]asg=E_IhI[DUyGJABJoykod?;yIQi?eb=SuYsigiWiUroytYuY@EYfMBcywyuyueB`mIRKrMEg=YERoUoSihMDRucq]C`OtAOWHSHkQSt;bXkEwOXLIBaSFy_V?qgCExjEtR=XY[f<[sP;tvkF<obSYtA_emseaYvF=E;or@qBf=wVab_iheEhHyhSCvaKukKtWCRtGGHOXb_BAegr=Mo<P`ine<xmHXSDQpaTYmJoUs<PUoTQvATNDpwHSG@JVLxbpxVIoHtKI`WIHw>IopyfKabgvy`A[sFlW^s\\_w[A[lIxvPjyXd:`iv_`IHpAQfDIwMgpMolb>n[Qn@?qdielqqF?wt>dBo\\JflgobH`k\\XoaX[Y`ewI[fPelPwbHwO_mZprVI[;hmoV\\viuvq]IonIVtCW]MGkV>mrhvqGS?dK_Eu[hXWw`]YPQh:syfoGDMFS?Iuqvqsic?rqmFQCrT?vFuGWoeoCBYawKORigel?T@OyfkeskTy]EhUSIWeZwS:mVRskkhlhtkYHVxIsVar`uMyIoE@RHiYmumvuMLyKNEjJAPJ<nbtL^IplY`xncufx]aZTNwT>t`qw:QpthdRwtpH[Hiyx_[hy]>_n`_\\p@pfOdeadWvaEnpRgfEA_:YspWseVovhaMVpNauAwh>A`XF_:I\\jO[BWaoN[Bq[FXnHopMqtDNvSXpiga;YmTOipqrCAsYY\\uYltxurqo>^am`qBvoFV^hvo_adgN]NVmvahoftdwsVNwiYkxP^Vvxs>x;iryAkoYgPy]?nxvvgnQpCipMAnLYnaIi]wg`nyxonaPbkYy^>smYqvypyWyqfnq__GpyYw[ZUseuMaG@?ywgiw?Y?YGXEfdGemcirUVUWBf;YMYtEYVbmWHUr\\iCBAXYGcuWVO_rM;cCuiROGYkGLUI^AbC[iaWu]UfKOV<udXCF_mY`OV>GC:UT\\IsXoIvaG^WbRCWVoWZQhC=rLqweureYIXAbEqCXEbY]wuICxyxjyWJsUjKbJaEkacmihR[FRyhQQfHawMYrvIW:qctYx==xHQX]kheCc[WyAETc[TNwfiATHquc?bhoeyEh^]HBUDjyDjuXq=YKWEGIvJyyeqrrAUHkwpuHlWV]QuTCIvOgHUGxehquicCCoaTJMSO?XWQiq;VmirUwfwaEFYdJOHnSIZMxVGxkmhc]RdGtbAHv=x=wENuB[ificYcgB@sY?SslAxYoVSgtBwtWuXWISQEiXOtQKFZ]S:aHsIXLaFVKxFuCUwsm[uaySxsxn=rgmSwKeV?fwcun]dc=DCEvjCfwCULyVderCeGKocZGBZcR;ugY_XOsIMIWiyv]sEo;UY[rtGUU;Hici>crwqHnuXYCr;gEA?TUAw:UuTqvdUU=Ohk]y@sriuxuCDVwEJASZAsIYyo?fEUgpUrH=uwgtSKiMcyiYGOytKoEDpPIdLn`QiHMsHpvLLuTLBeMFUNr`N>PUkAxoMNPtKE]QwaR^DjOYYQUvWTMXqkTuyKItHDovLo`@u<TvVusqevuYtmxntxjITpMToo`ODuviPYwagxonCvctOaaPwSV\\FFa\\@leOoXOmXfqs>oVaZ_OikaZ<oaIq`p`x^is<F_dGxC>naWbefchqu>Vh<n`;im:hccxms_qvn_<VaUg`VvkYo`agxlAysx[`ibb_cCnyVy_yqiTg^bPpenvxn`p_eBhrcivBqwh>^hYk\\vtNhtp_rpPmdAs<?fLwoXPbCGoSprGghboqZHdONaKyr\\it^x_s@yTWu^p`Inh^Xym>kLg\\nppHW[f@uDFmlxskhoK_fAPpdgiVFbk>];v^LFy^Nmpp`]iyExg<wrVXnAa[lamJgd?Ou@H\\Kv]vvyvp\\HidYX]XV[uoxjFkEqdFy_sGsEof>afoVgS?jyorPi[q^uZx`XIoPNeKpwrxyxU?cRhybZ?ShUeyWdPGvr[RP?sIeGdOF:KdLGet[y>wHVIulqyR_Y_ms:?vH=h`cu:=f`sFimFLgS]cX\\krJweSGICKTL]xRCWr?yVcHxaYJAySWR]ySQ;sKWSieWier?Yshcr\\Qvl]xvKuAoi^uCDEf<[uxCx:YSOaFgcxlYfIcRogU=Uv@OI_auwgeXevWYDuYTBmwGMGgWvf=XcuYxmWqKYyAEveUxCBuuIDGeLOeHkFkUk?]JQtJohykMTF<srEWVdv=iLvHuwyKRaqhUxKeOIHOShNZPlutvZPLXXU`AVRdvK\\XIiNBQPdhnkxn@umdtOd]xgHn]ysV=rq@QvYvflu>`SNPlyNoEPoRNtQvosgse_d;XrbGjCYdMOfAYmbonPXpMg\\>?`qVh?nf<nl@vrnqkIofkN`Z>nMWvgovP>iH>]?Adw_bXxmoPZvY];wkaivng^CIu\\FiGQsmIpZhf;nyqIxyNvqwxyQZAotgYbWgiROj;vlH^_Iq[IXnsQl@glbOl]yvkPyaIi[Yf?qorWyChuC_nuQpB^_F>^s?^gxsAvl>fpoO`Ffiwp[pv_OHvhWh]pcvvy^AbDfuyhw@Y_^yuOwouPwb`^gv\\c_]m_a[H]?NxkO_aAyF_OwwvufTsY<oIwkyUoWtGs<sba=wl?ByAIEOgVkunuWwUwUuSsuEnqsbwY`OtAoutTxvISoljcpUSHoEHstlNFHW^@oDLv\\<MmLR[<NMusyMpaQj:HXNxLhlM]TlN`YjamJYeiql@Hl@qj?HfAYd_fmFQ[p`ZjQnPx\\]gv;idrQxPxs]whaq[rNefAsV>s]pgG?cv^haPopOol`yDpd^Q\\rYZE`yjwhrhrMyc[AxINqK_cOF`yQysO_oafXopL?_e>mQNf?fcPqtrWgJO_Q`^L@_[QnpisrwxTyhIWsUYhhN`yvwoxtXWiNyu`OcoX_IXjmXmSXd\\Gx[Vk:AwcYeeImq`_DwvRVkGQoxnxkxkcxxCyma`gKg]Hfx\\Gs?XmwNhbirL^xS@i_yuS?vlV<iF`uH@UTtEsUsen]C;WufMuoMui;SC_YrqU^GDRcyjaijOBNOUnmy^Iy\\crnyd<GFUMHiWChMRwuSMkCxIhUSR?GB>kGlYckIheAs?UevYGIMuXgCKAu]seGmtRQxRouuMyjME]YRs;IeiedctNQCXASXCuxGX>sT>?dc_VZIiAYJVxx;]sSxQaAo]=ndHkH@JytKixKlAy`tWyTtnxwnlpFMsm@yjqxUyWQIrclV>MVgxVHdn]EJxaPEpUwTrQmKWDVYamy`p\\AlqTKw`T<tQceMtuxf=U?=t^=OyTTUhTkAqGIoS]JsmyHuoX`qhIm^ilCEjkPpQxvBPtNmvI<oJDNAySixmNQLslW<PvYMlIAx@\\N\\AwVmjaacV_pFxp[xiuAj:vyZNcxQndVhfq`ugpwN`]@\\HYuWn]A_fe_[GV]eI\\P>ba>taWym@kiAcZ@mfNg\\wlUyfuor[qe`qbtIkFnyh@yq?q\\gyOvbKGa^iwcxpagheVuNVmwVkbPrlVwTnfTQvkGxtnyHyhxXnYy[M@qaQeG_fgV[jyy\\irPGZ^I_CI^yOxMxmvf_NOjcIllwe`fdlVv=ya=>dcidUXtO@mvoa>nmXG[:>ZZ>:CTJct^Ui^MYkaTe?xVCDbisbCsF]EmIY<gIceFluuNMHSgXEsfn]U<[rXAdQSsayg:qVYiFjiwICV^ArbkbmYbb[BlAXteej=uWKudGVnqukcv`YBEWBOqUvqEu[YmiYTYuXgelSTAKtbkfE=GDwdXECN=hsAv`]ikewUCvpyIoQy[GtaUw\\mRH]fr_sIyRDUcC_wMID;aecgRaybKyD_Osf[C^aUVUWTmd?;yIAw?usX_ywisqsufeTSke_iRikeNydCkxMIE[kRT[BXkWAEWaCWKKXxacV_s@wWaOBR_BxidEsT\\URgiBb]wcmrBqyK]CFwCZswGIFkWH?sdYibJQsjehqqSSAeWWGyWI<oCryDQUYXyFpmrKyyjABP_VP?v]WwxKc`oc`WfXybV=I;QXtWWeMWeYvS?iRcdJOb\\iI<yw:wyqod?;yIAs?Eg^YyXyxxcvaGYd]scARPQyEyDMWdNMvRgI[=yucx`acp]SiCdvixNEGdIhPCbW?rCeREcFf_HP[xtIeq=VlydyuIOsgYyUayrlGYEAhXYhKcG=gWbIiiwCAsCVKRryonhNmenvDT<hnWyOoXK``R:\\mBhThXJluQFIvMtlwMJeltVduYqm@HwIuYtYllexN`wLPMUpWvDvFmUvlTTTOd@eyYyYyt<GpmHd?pggV[jycuQvGAslPxq`q_i_rGyEyehgmJXtbIqm_vXv\\mw\\F?[MoxCoaXpmsIoFy\\jVunV\\j?woYhY^sk>\\>Gs?XmmTLmIF_CHMGCaGrYwICyk_XpQTV]ujEGtKSW;EbYE:ugwwTxAVnAwcsTE?hn=BECrYmeD_WE?vGCfq;vOyGseh>WFIeu_SDXaeEUSTsb:CsxexfWSZyVZcs]mxFMefWXaIhm?xGwvE_XTcfg_IY]uXaE@OXhkDIIHuKWlwrNScMCgTIIMiY`_g_EBxIWY]xhIs]ST@oVOOdYoi?=VaOt@GcemeQMYsavfGCZ]v^yS?;xCkXf;UmSDAoVOyGwkYDAISWb[OtAoUycC:suEagdiI[iRHwIfirlibe;Xxkt\\siw?cxoux[r=CXgaecAgk]TUaGrSWJGs`=Tsgi<wxWmyx[HngIosR=ysBQfokRW[Ws]sIys>;GIGdKlR_\\TcAtjeSHIMKPQ[uJLmW=MmEXuVIYaimTYqBPxBYXcpvkTQ`PPCXsPmsfypmMQliUPQp:tyf`OX]pVlW<EsStjNXUeaxLAJ^YYcilMpP]<tK<JC<Vf=qpMOW`PciKYTO[=sqYn[<n[DV>ERJxNjMLbDsuYxouNEut?Xw=Aqbmu?=UXhU;@w]ITV<Mw<kV=XVUllHuDmK;hWx]ULiYClThdUcXXsunT\\QTtMxmTM\\ns]k><SmmPgHupPYlxjI=Xa]N:EKitkQxYaxjIytl]v[Iq`Pjr]Kvts^Yxs]UIyYxYxgPSVIMF<yPMYwMt\\Px:`udTyXYUeaxhLJODWWLJgdqlMjYHu\\Mjl]Rt]qaMWK<jb]VbIUMYj`tXHAW=HsMUTG\\X<aUyXKREpteJxLtxITVyquIJvayXxm\\Uu<hWRts_IxTQvo@mqpVXLX<lyMxL]lrYiyhyXdXVyluuaSqmKRdJKpQ[PoAaoBqvsQVoPxFEvwyumqmqAW_lwgxpXQoLMUeqySHqEQJvUVkDjBqo:`x:qOs`vLTw>`m`iRIlmwMVBLT><PL]L^@JBeXVHWT<jXiPsaYpywkTwA<wsYPC`SZyNRExyaJxMjhIk>UMxqv:lmQayv\\oU\\UAxiByi]?^l>jeoejg[phgYqnYhsV_vXIqyOtF_k`?cgF`CgstYkMFmEWsV`Z_xnVy[w>gTv[Xxo]gp@qaa>^\\nbV`\\bvsaV^]Otv^leOeeovgVkLI`PV[gpwrXvH^ikYkY_difrTwnyG`cOgt?q`OjL@VGSXKeCUU<OIekfGIT;ovk?DjEsoYD^ISU?tbYh@SbCCTleyaKTVmRtsVWauo=YHQvaArW;X]utXgUDeUK[tswCdCUrIIi?i\\QC_awCuYjAeBKv>SxaWfy;WJ;W:=YGMTw_RjwfkMIUSX>wS`EdlSV>cr^kGc=GLQfIabTUdaUE_WV;kifkufyHXAY]OB<yfycycUgt=xi?WKYH`OY^AUC;Y<kgS?R_ct>MwAmWFcvsIuJDRUxYylOjTsY`WHUmxxL]DKmhYoDOeLY^YwPioU@wbLSXlmiiRJqQKloUamc<rwIXY\\JvImTyYCpJFhxK\\vmIMOaUmesolTLtt<\\ySxpbItkQr^`KM`p=hpXHQEPwPLTDlVUIWDqMC<t`xXHywoaRUARJYm`xjIuoYHsBmUQ\\lGMPKYSZqNRuMIUPIuSVxr:Mq@PkZlqHPt?YPSxmRHWE@jIyw=@nIYX:aNhhpf<rYHTEpUNTyS@x`tpPYPaElPDyIxyryKO=qJYy_au;lQAqQo\\vKxSpDoCqyj\\tDYpl]lXdPwTWtMvF`yrxSHYJZpVX@R@AOjMOgPrv]JEDsrQQpIs[tVImwXxr@URkaWKuofMunHSsaYD@NRiTOHLHhp`mJZYUCUUeeQ]tLOiQfEo:=loD_`GjOGqVoa_hiLG\\=gtHav?ghKv]`AfpobN^k<>wCYl`N^G^bJwf^Ff<Va]PZ@WZf_y@WZ:igc?brvfR`yxyeuQvs?y<y\\x@nd>oqyqyiyd?liVqfQ`eQnWHZEQ\\FQeeI]s@cY@p<flLfbpX_jfpoax@IgFnc_?iBFrrAiWO_G?t`OZPPghNtv^dpGptVmNO\\]@Z@G[^qyCgvJP]\\>tKObCOeApZ]Iul@wSYt=ynT@wtYwixd]xfgXhy`_DwrTwsFwc_pn@GZOp]sfpoq^?QbZyaU^qsfatopkovk>`l>^RYlmxn:>fdworovJ>mJamtvsrIu:NyNPqxgweweMAoAHalX`SIgOQeAyePvjigoa_wlvfYQtev`Apqmyhd>fHap@gmNH\\e`js@muI^JXllI^BYprPsdGskav\\fo?OmGPpaO_Z@]WfaMP]?iyoHZxhbcAeeyodgmGv[LagM@rpwZMx\\canMfwnIyfOeY^yZyZoo_nylx`x_^ieYeYQpH?ss`kFhoM?fgVgW`qKGfApcEWfxOvaYkMXvb?^yNxKxkZqmuowkpcDhZrqttfue`db>njnaHPj>Ptv_llIieanVpj?oaXaweWfgX\\U_aY_c\\Q\\vyurqrqNgN`fgxfS>vQOc_^\\mGa?NnDI_DGwfh`GIiOXHQvk]vLEGN_vqQd:gIIYXhSd?meDEdM=Tj_IUotWuXWiH;ItmeWSQh?UgiegoydgkR?ueuauaahWexGsHVAfG]wfgXHGBY?VKmDZkGQScOybvqIwKgNmeVqRXsF?;SlQu<?BImFPSRXWdy]BJor]GToASYgXZasmAGYWeYgeaIxrMX<euPmsQcC^GyZYWaoYAebFmB_kwAmseMvqui?AvgsU@mxawX:qHl[bvMIG_iviuTUtiKSwCUncrxuHV]GlOYjIrAcTtIWgwiveihiPAxkw]w]MQndjyTsPXnqmTQXVdxrWXlElU[trPUN:TT`ejE\\UxtMVTTrQS<PS;=JAqTMUn@MrCIvPaw;UX<DMrMJOmS:AsPdkZ`pgUMdMUTETXEqLdRsmsxMmMpWvlPx<YVppS\\TcASjqODxj]@nWepY@pOXSbHv^mNpaRYPuaiUp<NRUo;hmnaPIqpGXtI`vuIXBIyayV_xTYXweYR^YMYurRquw<XEIqG`upYRn`wSijtxXwxTEhlVdndYYSUwcXwItYrYjpHXHYMnyLwXYpAxqpnsdmxhx[yKy=UeplSAoJhXGtoyeyeioMPXh<JY@JN]nQhMIXJ]XNfEOB\\poXnZ<r:=NpHM:DRJINq\\UhYw_auplK\\dRxhpWupcHQ;<rP=JPhY?uMs]JsxsxYPVYwp<NjIsymjWyMJ=NvdMlhOteq?DQpdMwtRjxOP`vraMjMpiPssll?HxmyvCUpjaUEYnrXwC<uMIOZEwl]L_AynaQHMJveuXMN\\LJodqpQt=uK<qTBYwaApIqmGPxvhJdipedO@ysdlrqlq_qWFlypytbayliObEYxilr\\OXdtJyTx`KIYJqYrwamaQwq=W;lyKYkw=XR=T?usMhWT<OoafLwrT^p\\goMxefxlZO\\Q`axVicYpSa]_aoPQaUq]x`aVpiynZhayWNtY_y<NmTWe[Qqcy]KWpdg`D_xDf[:@viaZKItUwg;ohUYnjqq_QinvygY_oq^sOaYNq\\?iq`ZoacdFkxabLfgC@a<FmfN_>^i=A]vijhY`D`k:?cW?`L@vbIaSyhCYvOWj^waAhu@Vcs`m<Xpp@vGpbKHyoy_K`q]ybj?c^gduqrqVryQwQA[bwaoYxMYpaxtXhqqW[Lvuxq^lyZpIj^y\\ExkvInjNjQ`eDvvepo?GfPa_NAl\\Ilyhnuxk:yqdg\\dyli`fEAc>v\\h^bNOnp@uwwx\\hVUHDYHfgihaSS]WXwRiWdNmCQsYaUW\\UxyqttcIEgrd]dcMXPkGAkfjmuksemotSgUoSdckbD?bjgSJCi^YCZui:OTYquWAGhAYfOSM;EvQhl]y<;FpExrmCoqx[KUeqRZey@ceeISZGFJGGacISwVp;YxMxNaxdEwcOGOCF:qU\\;iMYY\\cu<mctIWrciDaHuyehCwUmFAMFuaExygiQVjihiOrryehQbGYwMav_Ic`aEnAea?x_yYcGFd;HCeGuIsyywYCHnyCi=r;YUxiCAKiu=ty[IFOTfKgUAwsmeNcXK[wESb=;EvqsqCt];bWYvIKFtEsm=ty_YOkhX[IBGrUqyUSvy_yYccP;ESAirII?AD^OYtEvN?s;wUlWb@wSXWFOoB]wuuerDmuHUiR=G>QRhShEqfsKcJQUawXgmuvGEYEyDyTNousutuou_gWl[gomdv[YXayFeyOwrm?WJsGAii`eGHsypytbMY\\uFvMvOSWl=dZOsgAeNiDZAxB;ftudVwBIuVQObrebZaFIOgQsUoyvgMVB[WpQeaccDGtaarh]bBqh]?HkOHgcg==RiKEZEUPiWbDunuyJmQtpRs]Wu@YhhJ=YjpHsu]KYDQ<`xKpWVxPlLj:xt=PTvlNI@qhUwtlJwXRjuT=AR]QV@hNbpMMhUvxWAeoeMND=T=\\X<DkaPMseW?AP<UvwhQRyxitm=moRMRbisieR[yly@R`At;dQXQokPOcyV^YWDHyddXMtyMyMKiqoUOVYKPLVCynxTkHhsQTNk\\P:Xqy\\y;]wyXxqApC]nJqX[ijjmottUf`R;dpEyTZArIpY>xjxlyK]J`isA]Yf]Kcpyx]jIyU]<[KgyxHswYenTgWXr?e>iVEMcIaY`YHRMinEGhmisqVeafVgHDubCGrvmC;qhp[hE;viaimqS^oXgQRjutH=IPsGW?TK_tB;uGoyhyHbsxqIryQve]DnQWFcfBshcKcK?GI[xE;bsCvbaw^ev?KWbiTL[UukVS;r`UBkOifMBvGV^kfmQIa;IfmbOaxtwxhIRS]IXQc:?YGUTM[EesT[_uLQgl[RucikMY\\ItbKW\\GDNQSBQDKSFJEDZwgB]rLEsDGRdEW;cYvMbxaTXSeigs_KDDKhOGv[[D^YhjiIgav@YUTATS]iR=xnscTEHP[vSIYV]fqocWwDjgTgkbVwEMAckYxuyUqeEtksYUctIIm=dVQyJkrqiw;GwQydEetBMSIYcVsUP]irYF\\IrUYG_]Xx_yiEtjOX_kxEIX?WwdIhkiEq;vXwbqOfaAv;[Hpix\\oXgqB^YdC[sP?gEYyOwg\\kyRqHr]Ep=i^yy?ow];gcWgMgYtKgDqEEYrqotF;UfkrTIimufDmHSwGsoxTYWgWdlmH:seZgdecdOwypqea;BYQuD?YiuGTkEx=UwsR?[U<ki:cVlUup[V]EHNyUvEc<CE;ug\\;VUSyIywZKXAiwBQCBqd?;u<KBVmEsIeOsWPKxVuvgsh<IVnQE[;rKmIRMg:sr=oEMOCDiwUybKysxMCSEBp_ifYcCwsr_IYADB;fmeyt]BYIyX[dUWUZud]YEtwyx[RxiyYUgCivJ=D]sirIix[w;?FTsWtAB<ydXmT_Gb`CBxOGa=wWyFM=SYyi?CxY[YYCe;GB^ivmGI_uIGGrZ[yyUyD=iXmxq?secyOEgPSHC]rZuDiOYT=tacS_CT;eRHGt@MU:myiIWgUr<ytwie>UFh]V?AHPKXseIIkVV?f:yWr=vtIy_YyB]cHGs[Oc[?D=KsBSWN]IpMEeGumWIKkDIkIyuyw?sBGVjAEL_Sa_EmUeRkbpiXeAvZAVICcJkXWkI>stfGu\\=hW;GXSShUWgSWWgv?qC_whVQXEOxsyWyUyUIHymyveeC=VgWHB;y>cWGsw?;GBifo]UrEDT]rTqxwqvQAWOSweiS_ct]uFBaf>;U\\QvsYyQyWNeVGCI[QE;;vXEBuIhiuYEcFCoCTwguUBd]IX]CwAyp[CWqYuKsEoD;yhpeEUaCd_cJGcCMIRwSAkx`wbIyxW[ukAEHCSNEvOwxg=urGScIFQ_b=wB_AEAqWugCeivsuuEwUd_eomS:IiaWhEcVkaYeCgnkbUMRBatq;FJKC[giwmLXTybtYVmQyMQPDrMtpyAK_DJ\\qlqlqCeqfqMCpX@tMt=LmpquiUnhpoXryayeDSlAnJ`S\\utupuCTq>ERRpR[`TKhYNAXJprytYTdXQdWPQVMLYQIo[IVw@teer@=LPYS_EPThVvdx^=MVOcc@kv@]Uw`s`fswwl`y^`[ppdHi^GFfXoqQ`pf?cJvpCqcVNhVFiC@glguWAooYyKPlYyxWQyO>aais=xiKQfGyrjw]PW\\eVgGal?Iq<vpXQienerQrQNvWywxwpHyl`gbmhpHAnAxs^g\\_VdOFZQNj;gwLhnb^uwyf_ylEvjIVr_>f[`\\=In=@chIuGXxxFhm^m\\IqP_Z:?erftqYwYOZXv[Pfq]qZnNkaGsw_ZTV]jAsyqyCfmmpf[Xwgwt=NZrHi;faQH`qndw^ylgvCox]OsdV]InqAXikQ\\fnyvy\\kVg=qrdHl[OtQomyxlNVtqxyiN^Uwp<YxVYsK_\\=WtsGs_@wNxuiyiiYQkybybRUGQCTAYii]Rkcd<EUxsEqyTsKsSsgLuGHsgQcGQqiHcE\\=fvgsGQW>kDXey\\[y[iwiERIYVUADXkE<=dKcc:gGGce]QweGHxoVG_Wq]HYkUP;hpUSNEViEWOyxfSseQvlqyKEcD;CRihlIfEMX^CyDEC?OSsIGAQTpKwA;YFICC_Bfqidms;weu[TQuTwqgRegVmdA_IykGXuIm=Ghqb@]CwKybkCvuwu?EYCEOaUAWSpwubsuQwcKUeRCGIYhb]wXghXGEeQvEwGPuSyQieqg=YIXIxH[u`kSVgtHEyFKYradsIx>sV?;dR_bWWY_idr[YUyyAWFuux\\GwjIFrwTf_TtEVvAt[[vLGXNaHpKf\\;FQ=G^eHCSULwtu_iX;YUKg==Gd]wH;uDcRoQR]EyvKI>Yu_;f`?SI?CbOdywEQ;deCvrCSIMG>?So?s]gYoQENAI_iYliBtgyMcBOERkKG=QhcMTvovD_yg_vh?WK=eMeTect<ef\\miDUC_gBbUCVGVEIfJaBgISCKV<[WHmcIiGK?r\\WGiOtyyd@YXdiHQisXgfwgiI[uqgBSmtb;H[OScOgRkgmyutei@uIMqrd[fu?CDas;=suYHSYspiihCIY]BfQHm=BD;ylIEoCHvCwo]yvmfakg??XOUR:aVhsbk=GZYweYg@Wh\\]Rb]dxmBaas;uveoU=_t:ABdevuMWYeYx[yoexRcd]uF?evQgWgsCYQUmcWkCcu]vBIDWwWZeUYwVRYrqSYFwD^IRjkCqeX[oUvOylqdu=DsYvY;vx?XmoDoaftMiO;yCkusOV;ufICt]asB;fZwgQcbAyEQ;tfwRS=rlKyysI=MiywCGwTWeCa=IF_cfUUS_vwwvcOXsMEHur`MIyQBNebB]BcWYxacfIr=KvSQCZsxqYS>KXBcFQeG@YDkkDC;f:=bOwxkEEYWf^mf=evqaHOyHNgukCdvcCgGVmks=oD[GcAaevYriAdKWCj?F:EeOwsOmxradMwHIyDNAe^ITskc^_s`MGn=S?AsuQi?[wCuekCtgkVEuck_S=kbc[XHGVF_TPGUdkSVWBTCiTUV@Mg[;FdOEREc^KWVoG_gcVKVJkVEyx_oBL]chMIKsRq_YiEISyTWUR=oDLCUq[dooVTQvocs^kwmgVxywscBvUdPIFgURHAu]uX\\[YKqVfIiiqUn;CboX^qrOWhhIyMiURsxsaXUQNwUNyTQXxY_lKx\\yJlwwAtuItv@V[PsntJpiw=XW=qRnxqjQM_PSbDkNAPGEycExdeTyxYV\\ra]v[TuL<nltRHDvjytyPkKxuyqKHhJmIThXWJQjR`lVTl\\qmX]NpHkbeRMln^qpedTJev\\dk<QWUMYAYTiLOOhULAZYXfy?ywNIey\\OB^esvGYBmdScHN;TkkySwDaEUFkU\\qwuIVu[XJevHwRgKTAMvKytD;ytcrBKxVGIb=cBkx_QwasgXSF`kcKqVvmWRsrAusWOXMUU?]CSmH=OUDQU_yWdcxNWx\\uXRitJitr_ejGC:YTceDOssy]IWyfNwTTgulcvwAIaedOWfFoCfqdAwWgGEFKyPQIEmExOYsQBBaBCkDdcXhMi:scE;rFgwRIbfquw?sQQiK?DiQixQdEEVieW=mS:eeXQxr?BsevkiwjQcQwwvmyO=cDwRfIDiUhcIYyUb?sGvELh<U>`RfljV`wEYWb=uOmlc=OoMOAQJwMjZdQVEJthUY]y<lXyaxH\\pVEy<\\ouasaALfAwJuspUuy]u<hWYHqS=rSAJ\\UTo\\jCEQ<PmdHLbhL:`XL\\NcIOIettYpWAjVTU^Uw==ukIwUhltLUvUxaHtoexE\\pI=tWyyjqNFluxyuMtRDEY_EPS@rpXUyPjKXqhalQqMWeqDqy:En?UKkErQuq;PU;TUoqxc]JFPvmLruEo\\=TldL]YQZHPZ`pNAOnUxndP=yprEPlTQYtRlUy]=xg@UoDLW@lXMOFdK<lMi\\umyLdPRCHt@XUHxlaqjVpqy<MNQr[lkwYKRtqUuPOhpfhVs=yM\\QxdP`adqoj<AxfVeh>fyT>]IwIfkGH_yrusGt?EhIumgd=mXEqxkqix[CXiXQ[Y<kSIIyayS]SFXuHuMrr_r:]vmCwdEBK_wUODGUy^CG^ESEsdHgw[YtMkFbiV\\CTniwYycZ=FFgVikYkKbWgeDYcmKibGG^ID:eCfAH^ccM?bVEyyUUG?B]Ag<wGOiGpkvb;s?WcaWW<oY?AYiKbrmT:[xJqew?euEumEtkGWMOblCYrQTc?TGoDFWv_MtPIwmYV[yBx[ji`YoapwHWrmKwMvSYy`yOJ=lQqT?al>MskDt]tVexjDhoTxQZIy[IYQYV[usVTN\\QpueQByJ<=SIxvJXMSdTjxnKmvpYnIdQ>Hx=yjZALZtOm=JqdlEMVn`Q;@J<MxVTxF\\yHEM[DxsujkmygtwXQUPQp:tqDUWR\\p=dtnlQPDVCxlyXyKxRJQxZYJRLQjxMHqvP=YaqsMMQA@NA=lFur\\@SB<y_hJryMuUxU`TGLTMlK;IN:xwShuCtVuuJvUKP<we]SdQndXrAIPE]yeTLHmY?DNkqvWeWgAwx]v[]nXLYJdnelmihRNUjyMy=LyhuqGlM;tWAHKVqJ?XRdMs_trKELZeSXYYiLnlhmeXWh\\mmev[<VREP:luF`Nn@YQHL;`R`DQslwD@Jcmy:IJk\\Uo@QnYxY@N\\tweYx?lNbul<dqnEQYeWexT]mt@hKMYsvdk^hWHhkVAm^inQyMGPVvuxhdvkipeAoVxvvhu;`lR\\p^ymyaTwqK^aYspvFitV]R:mYaPPcI\\wi[tximY_kAyU@dyGt`_ntOiJyxYxu@O`K@rfF`:In?YcNPk]yvpCfmRhArF_ud]cbor<ptlpl?vm\\ivMXv`fo=oqqHfcQh_petxwWQjB_aGHaiFikNmpngLvkm_ewpbtwwWVgPQf[Y]YajWvmwa\\Xnqmqc>Nw=afMI`XF]=Xe:WoO_alijyaxy?\\r@v<?uR@qO>tc>kAQmN@k[nsDqt]?jxGuJx^LpjS?igipRqy:iyr_vAwa<OvCx^n?_lAqvxqwgwt_kVIyu>a^wefIw]W`Ny`^hh<W[QFk[Io=Y\\Uq]?wsuyuAvcW?]enami:atKyStusDGxZEXSUvDgdbmilQWnuy\\yVj]ikywZQD=gdJWxKMUn?EsWYhItbibiIR?uSVMfFKBiMewmvSyWaMdxwUeUER]Y`kupwRvwwj=G>oRsseKGr;[uuycqCrp;HBOd=qc=MXXKtfARturIGhqyVq=r_AX\\EuAmyCScHYUD_gVWELUHEoUjQBnYsauuwgvX[EtarAItbSy]cwMSS>IDVAY;ksuUyuCvemWKWvcOShsfEMsT=RieGenynXkXoaMhjSGZnHu<nwewaxI[^_ruwgL>xcW\\iWpP?b?hlhp[LA\\<>hSIv[^lqha<vqUikpyirW]<xvgF\\:O_\\?y:qaVnySyck^_KNb_yZyy[ay_YGZu@jXfqWqv_WskoyuouE@l:N_epckfntYt`?iqalfNb:@i;YhYxjEyalIdnqycycRflggiEv\\]GwEqe@@bAa_fwgiwji>]dPhRQZtXvNxdDYf?YcYoZaxsEhiqgu?`hnnjphfaI^v`isgdMv_UIuafqQvuWHdG?c\\PjGywww]X>\\:pkI`[[peHxgmi[iQbxnm:qmYpu;@`UGaJOfc_^MWk\\?Z@idk`dW>]mF]jI_PaoOxxC>pJOkwQw_W]QgewPd:gZSymG?ZygoKQm;`dKGkd_]Ug[VYcPPgm^pf`GyRAEtLIu?Wcykxk]ExWyX[wy=vxcHJchlQIp=Evsw_sG?UeVStR]H\\OGdcf^aGHouTmLgHoFXR_AMvMKwPsNdp]aWm@NX]pE`YqDQdMs>DoFHk@epBQs?eww@jfYrY=yvlXxmwMAmwQve=psqtyYU?tplESoMwUyquiMvQxguW;QnEmO;iLYUy@\\w\\IXQXxsdOxPXdxnT]RhDmJUJ]QLi=m:hVtUnN`YlMKK]S:uOfTu@Tr[N`;_ed@rYweQgd\\avENxtvq<hgXopg>smG]]_pYxbHhaVAtZhedVhCalPA[JXsa_v:qdJqcsYqCgiFXspF`Pv_CyueYweixs`mvoilqyhV^Kas]ifN>rXWyVX\\:QbdN_?@ybfc<VyCqjMHtLfh?QoHOfaHdSqnPhoPnKOhfQbsuCLYHVKBQCdmeWQgYIQWeUbMmsoMIPSt>mH_eg;Cyf]SVwXE]d;erHUefUrBOrheH?UhPghfgHceYlYdY_hWSt=yfA?SJWVucu[?S>CuXqU^AI[QS:Ite;v?usPgIf]w@sHVsDiQxJMIAGI<[boCg^KXferZSuFwCGCVfUsWAXlCVcQXduwTKxrIDpAYQgylCgB=R^;gtYr[=ia_FNcs]AFjow[ehi?bTUbfuro;HpKgC[VDmCw]BNEuHgwD;u?SdyCuaufUmuywSXCB]MEQATvkfdcDxwdeMCZQdMufkQEJ;bgqY\\ICn;cAwSh[eCIvR?ESkEEsUEyvRWHjAXyKhYMtXefcMYMAevIIYuR:kfKGsDqX^aumSF]KCNIILYU@ovxorZ?brwYQ_IR]E`IdIQRscv:AvZkXfIu]oRIgIo=gUyvxucnyx]kFAyvaUsBor@eWcYWsuxPQhPghHMcLIHsyV<;VD=RycF:QSHaUEgYBKiNqdmCHBqr`MxvQbQsi>SiiyiYsSViyy?svovO;Cn_h<itVQbRuYYkxYYXqKBUoH[ExeqgMQbZKtN[grcsJ;xb=C>[Cearr=gpkYTkuS?bYuTQufVCIAysgYwhqTIyUE?eRQDSmcaCGyUVuoVLaE>sXd?U<_W]AFIYXXCWi?B`EsJQfqOcQ[ElKfBGcHkd@;HM;VGyxdydbObYGeiYRZcfIagG[vryYXWEpgTj;ilYvG]RT?YIkh]kfDsbNEevmWP]EeuWWSbqyHOaHxCup;GYWG:AsDAYIKE@Iv[IVVkdIIrBYg^=gk=WRAEG_HqsHUmewaCRmVE;xCwwxIUh?cT_uOgTiyh]]UYovbKtCsRIAVMkVdyVT?g<wIGtnThmkuNaIPatYxynnmpoLUe`QWiXq]omyXVIqg]JILJDDJa<OZMTn\\TclNJQt]\\UlHVE<J:xKMaN\\@^Fw[o`_ZhtophgnotawaAxRi]q?^PYh>FaUh]oVr=?]qOqj`x@Ymjoyepo??qgh\\kGZfOZvV\\RHZ=Y`pf^=p_=peSP]c?xiax\\HyM@v@?\\`>vex`FYvj>bQxrEiiRPamoaB^j>VgM^^cxcaYytxnc^qdH`d>esq]VyZU@sK>lsxeLO`MHrWprCi`CX_yFlUPunne[VrROxvocG`[`^[g`gAignHnW`aFYfDVkkNsTfyxIqWvaUvsGHcSftFWdY?fgXpAnxtfmFPccNa:^dBvtRap@Xrxa_fI[=gZTPaB_sANdKyrVHmVwoFpvYP^WpvN>AGYFEcnctf]iy_vtoeCUWlaeFShluUEOR_YHskSkMbVsxAubsOx^uSOcf<Ics[GJctHErfOvaix^=GxASeQIGoU^MWJ;Ua_dFmTGSBWKSsIstSFaaHmGhIWCrqFr=enOs^=TT?x^cvqafV[T`]WFSXPueIGyUkHdMdKAi=[TXIEZwrfsH<AdrufSCIROy@oB?sgCAr^MW=yf=SgCOu:SbLEfaSg]aDGKg^MgVAtvkH<KfC[bvecciRmyyvYunedpof<EsVOYNMHtAuImuXauhaVcWdCyvmAUGEf`SsbsFeivGUrAysM]Ha<PXXmfhoq@rxauglp]ANBIpjmoLYtg@r?pj@=nkHxSuJraJAemm`QpLKUdTr]qQ`N\\yViAO@]v`<LcaoE`X@dnFMMRDMhpXLiWfMtv\\McUvSPXXQktLmnTUgHmS\\M:lKX<RGuvVDyFesb@KZUuaHXPuS^LTb\\ncaqCix\\<ubUsGXOZYjstRDTURxnmTkjDQY]jm`Q>IUf<xtMVeeL=tvn]medmFlUieYwMxtQYseYotRBambIK=ly^=XylLrHORAsQPPb<jYiOAdShdQbll_PV:xKIljnMSPXtj`vyanM]l@HmlxsaXQSmNbQLbAKPXlUpmWtSx=oDMMTUsCuLHaReij]]qIHyXmfmFZqahfxnuvmAQyVVlG@r^arjadTOsTwvJYra>eCyhJfyWyoK_yhyhZwfuNwqguBv^ufnHW`?iwihmDIn\\ogZIrA>lwqvQipQqlii]iIjmWv`f_@_`;vmLpgpP`Cgwv_]cyswO[jIyKnyjya;Yq\\gvFHyHgs[vb>^vkyjYNbFoqUQm=VyZaeyHZxXmx>[II_nHhh@]YhmoNbcyaYYkRi_yQKsdA=drqhsQV>kuleIdCrZoeaGfgyc[CxiwU>=YbwE;wTyoDhyhwWV\\mdAEuV?iasc;wGvmDpWyiibaQuQYFrQeQqSnoVsCG:yIX;FU?vEMS[GSfcUfKEOMi_cDC_SFEh\\iC:UcHQsIMXdiX[Ax>uEUWdsGBHeDNqfteyaSvGweCiXdsHygv;ysZ=bmKcwAe=OcGsC]WYIqWnMCreBFIG`]fmkfe_J^dwgMUkeWMiooYMhdloxQLDQiex^AUJ<OUQXuTpMPOuaPOAMs@OW\\r=MsKxtgpkwao<PoSuk\\xxeTRxmPSYPpXtClX^Qn?YUnTwJ]W@]VHTn<Uu^auelRiyNUHvfETl\\Wm\\nUiLslTUtkoMT_@q<hkVT\\Qa]fq_P@tlAs]>ejhvIAhhpeghe[GwwXrR>^>q]KGoWvk[?xZIbrythXbBAm_^km^hInc_YsIHiyHpma_c_]s_kXYhqNvqxu@PuFO[c@eVFsKH\\nxxqYra_sspaSWjXOsQwropf_QaSFyDi_TF]@Wj[_kvNpOVh`i_:?rbhd\\qiUxlhfrxGaIyZqqw=QugVeZayUX_KGaiGgo?fMHbkff?AZWFyGyoZaxrGhXQn?QgfGfrvjMxkEIxQPjPv]^H]rAgL@d=av_x^n@w^heFNw;QnW^ooydcIumqr]ihi_vrP_pwZDhp<NnHWq<?gSWul_lHPhlO[FibcvhWWjDAwjN_Lf^QHaTXlVYw<hZJv[CGjOXbf?[rXvfO\\RyuAVetf[FQmGP[?I[fW^FqF_RJaevobXqEN?u^wg[GDhksv;Dj;SiQu?sRSmuY]IKQhMifL?V<SXHWy];ggquG[R@ABLyG\\AdSqvFYB^uE>WuCgoyiwWEKN`U_EmwhtOeuOiUWeuWpuqiOWhQ[DwJ`X<\\N;`KZ]VMIjZ=uViP:PnAEQmLQ]xVHPJdAwbAPdLN\\]RVYNUmJ>Ilk]L=]l_\\J<mLmxN^XtCuwuQTw`tLitOUxWywwyocLmH=SRplkAmqyvnIoHexexxxyxXequiOyyxWYsLdw:=JhpsHdvgMXOdL]lPn<krUvCdSi\\rDMS[IlgUTSIrHuwOpmk@J_EvsXSKmyhxqAUu@XyK]psIWruTW]JQQpmaoVqqEQqpTnWiubqYfIT>PTv@oLtsnTVpaUF@sxhu@HLpMOkQjsQX_HYsdMvUT]mP`HospxydW;]qdPM_tMSuKvdxY=WxqrQATbqpFtNiioUauYYt<TYpDU@TrB@sotwvxvU=]Zgepwsw?kBHdciuwXcEPbnVa<otYGupfsUPkdxkXakgWyqQnkIyaGlcn]y_gxQZEowOpjQopgoijyjRFwbaboiciYbt`bKOonyroX^`pr`P[jY\\wHvrHfn`pw@m>qv]vrufh@yuvxjiObew[@Iyxalp^bwqvr_gLamjv]DOtf_b^I^iIifIfFfhnX^o?i>W]?fy_hfBWewG`LootwpDIglwnhGi:XqppaIpyAx]<oulhvjYcbw]]Wn[fqJGZ^quYxy>FvYiyHFmiIeA`_;ncOqhPxfmhvAX]J`_ZFlpquqI^iYreilhXjswf<VsbYoiPniYmyqk:Ix]Oc:@wEAs>osFImjyqqYZ:`]=pmap_XPlbxcFNdiiqqArankWoxgyyBpyAw]<Wx]xk:ymYxkDygYYo\\qbp@gIvcWhmbqgsvrlyhfHbMYnIVncHvrnnCHjjgoRgnt@tpCn]IwaHt_FdKsMWvLOy^[Il[WKUfFEHX=XGgb@UHCaTQaiSMSdkWVkTHYVxyIymEXIWSQWVWIR]H[_wpWD_KwHUts;vTqbvYExev_]xwsxfKtioi@CE<;vkgGIAUNwwCsuQkyY?rYmTq_C__UYcuvGUcEUL]rBMdyScYYcjuTaKbGecTMFXOTWegwwSKKshOvGOeLmecOiRWDMmGMCBYIEHAyUwxnyrYeG@;uMGd<KHGOfOwDfYCsItICtnAy`[HAkBKWinECDkTYMbxiyuAHnyrg;GYqhGctNSwSUyXSw[eFkwUpmCH[HpKVP?BvexOsT[kFZUSAWGLiLWLJpIltYnBhQoYM^eUwpLkDxFDmhDwKhwuukVlrvAsbPjWdQVMp<qKx`yLLMxPyO\\JTXmKHqpQUryLhLRiqkQ=ttAu]<oh]W<muy`Y;DSaimihLnLovpNZduvMv>\\YutXZ\\OXAYuYlI=nMmxcDP@LsRmNfUXqDucDToQT]@sd`o<xU:aQBewDhwiTN_QvEEvP@S<HO_loyiKv`x\\<NQYVTDyZpvGYRY@MP`v>LV=IoDPrnew:mvWQxmxmZ]xQySRMJBUL;xuJEq^]UqUN`hUmpt\\eu_Mwc]kfMJW@cUXgCOl@Yv]a[qxfl>m\\Nf>?bPhuHG`Vqgsp`?wwyAnP_vJA\\eqigaxTVdoOxyod^Ng;PcGacnqy[W`txpx@jnipeapkitgIc@wpRfkJ`uQvgGa[^woXgg?WffowV`^?@wsYcwGyW>nqorSa[vQsLQaCxyaWxoFqLWtJYyUynj_w[ye<Ojl_twWvh_dvXxlfodW[Gv[]wrwyx[Avwwu;OyMyqAGu_vldOk@Hyxaw?hp:oi;NetYyJo_XheTH_=Yknop]NtUik;ndjhpoPnZArx?yh>ecgvCivbH]Myn]Ou?WoOp_UpeoVtCvry_yZNqXgaFPnUqa?ttYeo_uI_TZysnwh]AsMui@Mtyuy@cFayUZGd<Od^KcqUEGefJAt:KepcI<GttWxk_wMyhE;Wu]TUQUQYFFEY\\wrfgIjWBWgsLGuayg:ItQkU:uuCoB^UCZCWDAS`qHj=v:kR>YwaOTXWir?U;itgMsLwftSGZ_vBOhuGRIWEgKBNoWssEwUvomrR_UVEXf[FsYFQII^Uej_yYOd^_DfKe`mtSMf`qyXGtkIWbYbPixI[WWQcXEHrGyqou@_e?YSNYSQURL?gqGVD=vSCC`ofaWVtQsO=WvIwIGtWAXFcDf]WOihUGTFOc;qC>KBb[gggR@agsKywIvTqs^]groEaIxnmbmky<;bIWdj?rTgrQmfTMyIsELsWpWE?svW=bdiHiaR:_d_KvcwdPeT[mE?abpky<sgx_iGcBAuc<ydY=gs_vFQdL]Dgcg=xjpLVZirQ<vaxlilU]ArXhQjuV`Er]YSQ<xbAR^ho?DwNmr^<VCIVmTkEElLXlEmOOlX_AVjAx[]Xfqu?`vDQWFaUqpSS<UAqR<@xDyva]UyUJpMPo]NKQRhDrr`o<lpnPMEiNMPn]@xD<SWXyiuUQeSeUq]]UeTX^UOqHXrAOp\\P>eybEJQQX;\\y=MPQpwwXyJxy\\YxBQOspSeMx=TypQOsANsIoDdrjHlR@TclTF<VWHnUtoLmnfXVaHpkUmLMxrHtO@T:elspswHv`\\sOtotiX[EueaqO=WT`kspxrTy=`vvLpRiuIQoTTtOtME=LfLQguwXxtB`QYeOGAWWAym]nhLU>Pnexo;]kKqmSyoWDQRtoSuo==k_qllIQiEV[Llexn]\\sbls>ET^`nSlQl=KKMwVuot@SGxYJhSb`wIMm^ey=Iw;yX@XP`PQYxW:AVfly@EUY@q[hwXDwbARQIn=@SLxJmTYKQRoQWuLQuDpW=ju=pyxUo=kEpLf<tdPMh\\vGhj=mL:ar]=SYxq:TVxuQ@HOwHOZIRZhwYIyDLtDQsJXXSivB`Ns=PjXWQPYLHnhqOrEu^@UKEJimWhpnM<Uqiuy]q;DjXqUg]PV\\YfILnuYuyQJYYyyXKYXiypZiuxQLvQPmAVYuQ\\LPQttrMnDHqgAM@aJ:YxQ]oJMkkYJ\\IniquyxMgQpW]N[twhuxT@uOARhMP@qsUxjj`sy]RxTLaQM@=PB@xkPYg]uFEOetRdmUxPkODYRyNmqLtlrSDVJ<JSPtBTkAYMmdLn\\mM]K@<nGxjheT;ekkajXAyM@ucdsTmXpIxjHUMXw_\\Ju=UsYYhyOxMm;<k`qwSuoiDLLUs=YMKyOqqqrYNeIl?EKSAqOey>AW<exp<YGDuq]rbuNdeTyDptItYmU;PP;dx`EQAANyqNqqObtu;pmtQYrYpaHn^iMe]o@mS`xYfQkgxpedn]aKa]mwpMxMjapPhtk`QMQyNp@KyQrR<nqTOIdniMUpPJ<Tm=Tx?YkmXs[TlvpU>hJRPN;Us=\\N]TOcXRDqlitrxEyUUvKXNbtWiuLjdsLTnjXM_Toh\\RkirQPn_ItA=toXXALstLuKlLJuNBpvdQRc]L]`xNDsaeNZQRZeKpaX[ijGUm><W\\UvE\\YvlxJMWT\\qodPBeOfLTStSqHoUxK?aOj\\SoyVbmQT`MQ]vhPxmPRAhMhqvvdp^Umw`ONAsPxsuavvPk?ASV\\L]MloQsp]LkHuDmpC\\mrloZtlwPx<]b=nlEnl@OsPXdgNolvoGQgUVvsQgD>c:FmmG]OVbAayrxlOP_\\_dvpnyqbQi\\F>m@wZ@>`p_wb^eKHtq^nn?fhGmUosW`pdIc`fa?QlQAmcpwCHmnocnFt=ymf`gWqnD@d`^eEO[p^tWYnNqwXG`jG]cneFvykI]eywV?ri?oQYhjGlY^gQq[>i^dVnpwZOOyBGb=aayGv\\PeVFlBooiirgP]Sn[WNa:phSyec@jwO`c`fFQqBxx^fkZo[ZYa=I]Mgw[YmVnifFbrX@gBs?e;CBh;wHxJDaT=DwR\\JFiycIwbPnalO:IMfUW?=n_hRmMq>tJ`aV]mjLYmtxJhQvLDJHhYR\\QrxMBtRJdMXLRvTQUdrExs?MwFImB\\wSioD=WWTypYNRyuAPj_UsN<TcLuMPwGeTt<JlYVGULjAqbYwqUN_PpLDpZ=sP\\TpPmvAw_MtbAsaaYD<yhdtXmnKQtl=R;tn\\mvthSaTy>embeSeATQUjlTmlyxfIYE\\p^aPLqu@@nrmx]HOCoq]i\\:ovWx^mqpQ^_MhcQWql_sRitln_QAabP__WZMA^Nf\\\\WxKx_WQ_[alYpkaym?_qsH[_YsPXec_]Tfj>PjLntaxtyavA?gttpodoki;WuAau]GEYGya[dy=v=YvV_HTiHwkGVaBg_fCgFR[XWwfCIeeUhPCwL[Cy;dLeERoyC?g>MW=OHiAxhieRIxCWUgsB:AE^?hUYBq_UYotauy>otgssZOymwe=erFGETOF];vA_FlEsRGIECGMYWJ;Ir=B[qsHCiyWYJOFQ_idQwoODgKyJCdiIBeGiHmdHSX:suSksROt[QTV=EMsSr]SxuSL?DxCS:kH`GYhAg`_CRwRIesCIRpEWskcCYbWyhquCd?S_IRX;GDATLmDNOT\\gIWQBJoY^OCrWGR=HymSx;GlIHgkU<oWs=wuyXharjIv=AxOsD]svviDDKVsKBpeci[IAoyWYiJytNabfWXQ?g@cb`yuGmWuSfn_TegXVUR=?S[GhCyG:AEcEFfYhjKDa_UZmEmkRF?w`efd_goKC<OHsEfvKB\\GGM;YV_wQMbqcIUmxC[vYWhJky?YSKaxLqTNWc;Mc_qv\\[tTQblYEYyfmYcjKbk[IR]BoessUEjcEa[CmcIx[yciY^ydBUgfOR@ihQYGusgd?uC]v;eye]RAaH?MD\\GVjcewOWr;iHKTq_EXWEXYWKIDF=c^[dl_RXUH^Ue^Sd`KEo[VcMedOVMOEeuw]]HbqGGerjmWDEihstmcR:SUO]w^KcBShAERxyefsxIgfOog^shh[caiUseDtqVIItsCYF]B:YXfQdbaFXuydKr_iDBuD=cetsVHOI>[iQ[V<kFiwTXaus;gfWg=AsMyiAuwEYuJahsUHVEIs=sVGHMGfBofm]WoWIA;xWGvFwh]cf=uGKGieIr;]CE=wWcDimHH=haCTZER;KTdmV:yFZuHeiUiqrXyuxcb]YiyacliSIOFqQxeCdfkbZwYEqVVkyhyXJyuVQbSyHXabfExxehHseXaGkIRFKRSeWgKEyExM]xnmXd;DMUV\\SVpaW?;gvQu?AI^;vLqxuyu[=VfkbdiXQIrOOvoOTLKufaD?wHasDCUXaIfKMf>OvAwH\\OSxyeFecdmvpgrbcbTKEZQFCuTxmiD?yb;G?igBabZuDqCgckf??UKUvX_V;?t`OB[;cmGCeShn_CsKvWoELWxeeyYwu\\[FQQFf;fVMYCiNWDLN<l^ePDtLFEUSPLadMEqqwPqHIRHDM@EShDk@\\usEyBtMt<jhxVxAj<hNo=SYMqFDXsauRdKItLYHWbLj=AkgIW<Ml:xoU]KGhqJLssuLEixc@UkPvNhL:]UA<VDQOhmLdUnWdMd=Q:YvFdKeDJ^dVEUNAyk;iMDLUElt?er]IOV@SZ<jwyXxELXEYy@w=yM?mu_uleQuCDJypXwiOLdL_@Vv\\QZHJKTvmhvHxOZarYxX]`V;IQrtvExXDIYaHOADMuDnspM\\`TdQpWMyViJbIlb<nsUt]=Kqxp]PxThp\\aLNTV>mp_MocDTI]r;\\Ya=Q]yOcyuu@nZqtqLL<Ip=xJKqYQimPmmUmuIQLjHSUhPUtvvUxX<Y><QDeJnmlVaYElxXYyW\\wrXwH\\vh]yspR=LoO]Y\\AQldJBqvw=w]LSclQ<eXsLsCPoQMw<evDhlrLqbpLWxsytjb`MntnhEMvMv_XtM]OJtwKyPmmPdypw`nCenmmWyyJEPJ;pue@j;DUZUXdMWjmwapWQ=lSyqcyQ_LsRyjflOLTK@dKPyM?AXQuLdpWsAMdpuyIRrXN[esGYoL`uB@jWttX<V_@UVuWLIKe`QPMPiINslV@dxYxTW=kwuqt]MGYuYmRR]kLxRF@ji`oFQUZqnPpPQIQRPqD\\KZhX=yxoEJu\\lMhKiIn==SOTRS]YgQQklls=umYjG<MgEW?AXjIYVdQTuksxpwMJsTOi\\pDIV?<MuqmvMJalpgUjaxpQdt\\=Tl\\JnUVxtM@dvtLp;`kL`n[UmT`YvlPmPnPLPdQl_<mfpm^hWqEk;XQjYjiYVrIqyDN^qxZhoy=JwInjlKEiyWlqwYtBAlsUy?YNYxx_xYOEPa`nN`VoLQuyXhARfXqYtviDUDPJ;\\yZ`MEhvMHjMtNj\\s`YOPHWDIqPaSYpkVEqAIVstVp=MAhN<EKI\\J^uMKeSsanS<LILJtuw`]oSUj=tKvuMgyqxMTCPylylPINg@pJDvhqWolohYTJMXu<jiaKa]cIqu^qvwgn_@_TGqDGmYvrFvts?kOw_KI`^Wcrw]qw^S_qpNxxQc;NoKGxdX]q`a=ps;AZlvj=@[mGZN_qyifq`iVf^Ex\\]?bvveDOe`G[BFr:N]MW[fhgY>fDGbv`vVXkift?hrKO`hN[bglVoi?ncBHfJ>aPvoq@byvvl^x[aZYaf;nqTY_iPjiV`EVuY>u:haAY]J?puwpOxnqAkk?ob@bogf_PZDXsrorfAvfFlbWf>?r_Vf[Qbe`rmicDW\\gOaoovjHgfN[^YhOO`q@dwgavOpiQxqoe@vi_g`@Hu;Vgrihr_opGxXYZGvrjfyeveMapCWsIwiFHgl_unHmmfxrXxxVxS_tyGyE?sUX`QfjYVqGG_>>sY^rSaxqpp[f_]V\\ExwYAj]vcvFj=wxyw[mirEyxwiu?QmXOfsYgivocV]N`[mag\\_b<ogj`asgsmhdcafyXbLRg]VxcD]cRWwcL_VIod]eCJAiAUFbcdBYRiWdEQS;ETvIGgEusMSQGv[Mi?aTfEhLGW:mgwcTfAi`ORdWxv_iv[v`mV\\sX@aGnYc[sfhyHQCfcGxKcfxwb[gVQeyjEuqstEMX^KhcIdbgGwsGQkySUXnKY]MsiSvNCwVsBji]`@gbwZeVxgPZZVk^^rhheqgqKffphk;YgcfZpVsJ?sa?b:vnZv^AvwJ>xDfi\\YlbYgggpv`c;^uvQkD_b<I\\Opo^fb;op:PblPhfYk[A\\j_fS@vdyswoeCNpFgq^nj^iih>[`wf_GfsQyUHpvqtIHecwgkafcIdlvqf@ve>rKicTfZ;nmTX[h>bG`bTfuGgkdiml_vNxlevbIFoBNj[@nPQnMXtaVp^`ZeowxqnT^lRHoMwctf[X>iPGqjPl@Habacsvuevqkwxrfy<FrKHdE_aVf]i`_[okvF_wVbQY[lfvvhe\\_lHhxoYnQovJ?_mQ]MbHesK;x_MGCmsCWwQ[GmeCSii:KVNUCQaU@sWXmitui=cR?KWfMtcotakUxEB;eUXEECGu\\YRp;vUaTjaxjICvAtywrjEfVYFQwvmQYyMD;cHh=bVwv;ahFoU;EihkYSwxowCxASF;X>Ew[ICfQUG_FyWTNAcZssHKUl?CMADMIHbWi_qTNiYvqHGUsSaEsCW@uw=ui]]wnoffUgfui`YgYUtuADqKDi_wY=vxmF]gYq=BYIEHdr=iW:ekZlu=es[=UOaOTiOT@J`\\JylvwHwwHpcDoIMruIWLLkaATlUtBuXldTLatVao_Umf`v[pSkhO>]rwaj^ilouwTuVhUwevxnPs?oxy>^ZxsIQt=`thQdDF]CH\\Bwfh>uBP]kfnKQtOijHquX_vcIpmxrOxltffxNui>bjY\\JYxM>l^AaNyh`ocShubHcLfnJ_x=ximgqCxjiWgF_[ByvUar]ikUniRvlc__\\IaJ`nG@bEamsvxQHayoaTn`xa[uvaqIeFPhkXtYpk\\Ysh@tvHqEa_lO_[g];vdXwZSfpjGnSqwNg\\i`m:^m`vvgqsjYgOg[]VZTflNOs@PhG?rN_v^Nt;a^DOllyjZ`ccwt[F`J``JVn`PddnmJPZLGr\\N]LW^GOsuqsvOiDXu]p]wWmRV^TFpnGqHIw@?pb_sjxklwmVqpA`bp_tdqlwOpmFm@XreVuL`lLqZjoyXN\\:ywNhw\\__qh`\\IdtyhD`dCH`sfllqm=>yHMDMxpqTSTNeAt=Px:YLjyjF<v<AKOAuTTKnAPm\\NvuSQxjXyN:YsJqqa<L:UWauntUY>TROUT]pUl`WMMTTMkVLY?`x`eShmlslv:`wyXUx=wsLtJApTmjlimxUnNqtaTXR\\NIXqVtqj@oBDYNMml<vJPVNeurLY><jeib[xvR^`_`jVy]c`smYxmi_]F^Zobjg;wG<SGyuvvYhLkvnMgnKbWmecidsUH<CwMWX`aEsKH_QUJYwGaHOIIf?B\\GFeYumwBSdO@EuOxT[LNZqlSUqRlQSxSYUUUpwAUWkIKxpj\\LU_iQ_AMW\\YYuLNhO:mVNLrdAoR]yoHqr]PGlxTuq:aVmipADRSpRNpJTuvGmjMUpJXWa@jB\\rvpxSIKd@Y;ln_PYt\\tjPxuElelMwPWqUmdmNuPtBUYQ\\VYdYlmkwQxw<VtpkuYVauoIaR^mxvDwf<T<hlqIkYylB@MnlYQ<Wv@qyUUcysCEwrTrStW=<wmIVaYjiXKfmR@XXVXVXpm]TxSQJL`KMiq`ttD=TaMq?HOXLYi]S]=pfpkiYL>AyjyNPypUqj?@VFUv;moTdt\\mlgaTqEu:<L;@NA`lCaJOEJ>`RIEtPUX]aYs]Kh\\NLMJNqPr\\xLUp><ksmOpqXX`jvLppdTSXxrdUD=Vhur]EwkdVYqPbMxVAMk=o<lmLloSUs<TRwPVBtxhiR`esFdx<HY[dummV=ymQxocTlbDOSXKD<tjavi@vQhWltlYxnNasfmOElKITmTDyrpou\\kHPpv`PlQqnYucAthTuF<rnQsshNiHo@eSCLuu`qiHs@EkHxtDqqx\\qp]JlmmetsKUyN\\KWYpwesfettlxY=pDIkQIRwpXsqyjAmMDJVenXespPmIynN\\NIhOUQyb`wamwKXv[YQ=IMi?rqhqWWi[yglvwKqiZiwApuPyj`pfnAo[PZjHZPqykha<arAvua?Z;qlZapqImbHqfWw_v^IOb^hfyxrQOjOfaxgwVg@=hokfaKsfMYGmsxaS^mIMsgGshaaugausgexChw?urGwO;sdsGAUJ:emGhk\\iNIDVQYJy<rfPuT]swQrWLUmxwMTNPEYgiXRYNyuymYjI<V[mY;pOPXYETkJ`YHQN_pNBHmVMYHiRehltHJaHOvMPkmuvpKD\\yfDMwDS>=lrmMV\\uPxtDql\\epcXvalP`HuqYspLYCxrW@uQAlrhOqimRdVVpoPAk=<yHAX@aL<py>uKhaVUiNT<JU<Yg=rmxMVIsTDmLDRYqx:uN`An]qn`uuHyvH]J<HkvuPTUOi=J^DPIhQK_aK>vIalCQtXyu>Yw\\whKQ`WHrvVasWjH`anY[N?[:ytWIhapgmxxkyrkhyMym>ox_vl\\PxWyd]?iZ?Z_V[P>^qYiU^d[w_e@pJVnLfnJph\\@bxvr?ae``aL_vVqvv?v=O]K@oBfsU?tBipIYaKOxnafqYhvfylFb=VyN?fV@oogaSiqxftpXlWyeA>xWlUAKtyVD<kiel<<y^=RxmNl=npxjR@m@AQSyv`Pjd@yGErCaOPtNIuo;UxPyvZyqiqU^PkQpQl=xZ\\YEpL;yQumP<InZLuuQyNxNaTR\\hjvDk@<qp<nElqnQjspkKdPvHR`dlPDP<UvcxW;EReaSiIwUElOeQM<txyqJqRu<jia[jorNPjtYeSFh=afcWtxq_yava@paPoTViq_q\\`iln]siyDhxq@gHoi>PesPZdavbxgcAwJ?f_Q^aVd\\F^mp[;ib_gws>\\ZxvTA[w^ycwnZAmsVe@XZrqSGvFwiDGfw_ClQsN]CsebPgurUD\\utYAVrOv;?V^[WOMDC;WmOXCWCR_gpIXSOyteDECH\\?xFETcEi^_ilOu?YVPShgaDRIud;t^ABxW@dP=hN[Hrb]LWiywQSm@nOaSlqyB@Yhanxinatm_luuDrUxa@O[KqsmxcV_rHGpmwxCfpoyfmP]YXZrqSrqIdRivDMG_mXgSHOSH`]xVEVDYFMiCRYY`CG;]he?UfyuoKWjScgoxuuVu_xdWwhWihQXxgWHAX@WHV`ORtyEPTEapjTTTTsu=J:<J:`n\\tN\\tT[<P;;2:\"\{\}LSUlUk9PVEc2Jy0lKUJPVU5EU19YRzYjJCIiISEiIi0lKUJPVU5EU19ZR0YnLSUtQk9VTkRTX1dJRFRIRzYjJCIlK1FGKi0lLkJPVU5EU19IRUlHSFRHNiMkIiU/UEYqLSUpQ0hJTERSRU5HNiI=Vgl for LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEiYUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1JJW1zdXBHRiQ2JS1JI21uR0YkNiRRIzEwRidGOS1GIzYkLUZTNiRRIjlGJ0Y5RjkvJTFzdXBlcnNjcmlwdHNoaWZ0R1EiMEYnRjk= and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEiYUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1JJW1zdXBHRiQ2JS1JI21uR0YkNiRRIzEwRidGOS1GIzYkRlJGOS8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRidGOQ== and gate threshold planes at minimum and maximum gate thresholds of 1.4 and 2.4 V.Identification of different curves.
As can be seen in the 3-D graph above, MLS with Vgth at the upper limit of tolerance of 2.4V have no shoot-through problems over the entire tolerance range of both Cgd and Cgs. However for Vgth close to the lower limit of tolerance of 1.4V, designers should expect some significant shoot-through. The graph above right is there only to identify the different curves in relation to each other for reference.Full Cycle ExaminationNow that we have derived equations (1) and (2) that enable us to examine the propensity of a specific MOSFET for shoot-through, let us have a look at the MOSFET's response to one full wave.JSFHLUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzZRLUkjbW9HRiQ2LVEifkYnLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGNC8lKXN0cmV0Y2h5R0Y0LyUqc3ltbWV0cmljR0Y0LyUobGFyZ2VvcEdGNC8lLm1vdmFibGVsaW1pdHNHRjQvJSdhY2NlbnRHRjQvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZDLUkjbWlHRiQ2JVEjdGZGJy8lJ2l0YWxpY0dRJXRydWVGJy9GMFEnaXRhbGljRictRiw2LVEqJmNvbG9uZXE7RidGL0YyRjVGN0Y5RjtGPUY/L0ZCUSwwLjI3Nzc3NzhlbUYnL0ZFRlMtSSVtc3VwR0YkNiUtSSNtbkdGJDYkUSMxMEYnRi8tRiM2Ji1GLDYtUSomdW1pbnVzMDtGJ0YvRjJGNUY3RjlGO0Y9Rj8vRkJRLDAuMjIyMjIyMmVtRicvRkVGXG8tRlk2JFEiOEYnRi8vJStleGVjdXRhYmxlR0Y0Ri8vJTFzdXBlcnNjcmlwdHNoaWZ0R1EiMEYnLUYsNi1RIjpGJ0YvRjJGNUY3RjlGO0Y9Rj9GUkZULUZHNiVRJFZwa0YnRkpGTUZPLUZZNiRRIzEyRidGL0Zmb0YrLUZHNiVRJHRvbkYnRkpGTUZPLUZWNiVGWC1GIzYmRmhuLUZZNiRRIjdGJ0YvRmFvRi9GY29GZm9GKy1GRzYlUSJhRidGSkZNRk8tSSZtZnJhY0dGJDYoRmlvLUYjNiUtRkc2JVEjdHJGJ0ZKRk1GYW9GLy8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGaXEvJSliZXZlbGxlZEdGNEZmb0YrRmlwRk9GXHFGZm8tRkc2JVEjdDFGJ0ZKRk1GT0ZhcUYrRmZvLUZHNiVRI3QyRidGSkZNRk9GYXEtRiw2LVEiK0YnRi9GMkY1RjdGOUY7Rj1GP0Zbb0Zdb0ZfcEZmby1GRzYlUSN0M0YnRkpGTUZPRmFyRmRyRmFxRmZvLUZHNiVRIlRGJ0ZKRk1GTy1GWTYkUSUyRS02RidGL0Zmb0Zhb0Yvprint(); # input placeholderUsing the Heaviside function, the input voltage for a full cycle may be represented as follows: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%;LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYjLUkjbWlHRiQ2I1EhRic=Now we can solve the same set of Kirchhoff equations using the s domain familiar to all electrical engineers. This is done to examine voltages and currents at the beginning and end of a single pulse. LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVElVmluc0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKiZjb2xvbmVxO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUYsNiVRKWludHRyYW5zRidGL0YyLUkobWZlbmNlZEdGJDYmLUYjNiUtRiw2JVEobGFwbGFjZUYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOUY5LyUlb3BlbkdRIltGJy8lJmNsb3NlR1EiXUYnLUZTNiQtRiM2LC1GLDYlUSVWaW50RidGL0YyLUY2Ni1RIixGJ0Y5RjsvRj9GMUZARkJGREZGRkgvRktRJjAuMGVtRicvRk5RLDAuMzMzMzMzM2VtRictRiw2JVEidEYnRi9GMkZjby1GNjYtUSJ+RidGOUY7Rj5GQEZCRkRGRkZIRmdvL0ZORmhvLUYsNiVRInNGJ0YvRjItSShtYWN0aW9uR0YkNiQtRiM2JS1GLDYjUSFGJ0ZaRjkvJSthY3Rpb250eXBlR1E7bWFwbGVzb2Z0OnRhc2stcGxhY2Vob2xkZXJGJ0ZqcEZaRjlGOS1GNjYtUSI6RidGOUY7Rj5GQEZCRkRGRkZIRkpGTUZaRjk=LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYsLUkjbWlHRiQ2JVEjZWFGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSomY29sb25lcTtGJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1GLDYlUSVWaW5zRidGL0YyLUY2Ni1RIj1GJ0Y5RjtGPkZARkJGREZGRkhGSkZNLUkmbWZyYWNHRiQ2KC1GIzYlLUYsNiVRI2kzRidGL0YyLyUrZXhlY3V0YWJsZUdGPUY5LUYjNictRiw2JVEic0YnRi9GMi1GNjYtUScmc2RvdDtGJ0Y5RjtGPkZARkJGREZGRkgvRktRJjAuMGVtRicvRk5GYm8tRiw2JVEjQ29GJ0YvRjJGZ25GOS8lLmxpbmV0aGlja25lc3NHUSIxRicvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGXHAvJSliZXZlbGxlZEdGPS1GNjYtUSgmbWludXM7RidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSwwLjIyMjIyMjJlbUYnL0ZORmVwLUZWNigtRiM2JS1GLDYlUSNpMkYnRi9GMkZnbkY5RmluRmdvRmpvRl1wRl9wLUY2Ni1RIjpGJ0Y5RjtGPkZARkJGREZGRkhGSkZNRmduRjk=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LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEmc29sc2FGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSomY29sb25lcTtGJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1GLDYlUSZzb2x2ZUYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYoLUZTNiYtRiM2Ky1GLDYlUSNlYUYnRi9GMi1GNjYtUSIsRidGOUY7L0Y/RjFGQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZOUSwwLjMzMzMzMzNlbUYnLUY2Ni1RIn5GJ0Y5RjtGPkZARkJGREZGRkhGXG8vRk5GXW8tRiw2JVEjZWJGJ0YvRjJGaG5GYG8tRiw2JVEjZWNGJ0YvRjIvJStleGVjdXRhYmxlR0Y9RjlGOS8lJW9wZW5HUSJ8ZnJGJy8lJmNsb3NlR1EifGhyRidGaG5GYG8tRlM2Ji1GIzYrLUYsNiVRI2kxRidGL0YyRmhuRmBvRmBvLUYsNiVRI2kyRidGL0YyRmhuLUYsNiVRI2kzRidGL0YyRmpvRjlGOUZccEZfcEZqb0Y5RjktRjY2LVEiOkYnRjlGO0Y+RkBGQkZERkZGSEZKRk1Gam9GOQ==LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYpLUkjbWlHRiQ2JVEkaTFzRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVElZXZhbEYnRi9GMi1JKG1mZW5jZWRHRiQ2JC1GIzYoLUYsNiVRI2kxRidGL0YyLUY2Ni1RIixGJ0Y5RjsvRj9GMUZARkJGREZGRkgvRktRJjAuMGVtRicvRk5RLDAuMzMzMzMzM2VtRictRjY2LVEifkYnRjlGO0Y+RkBGQkZERkZGSEZobi9GTkZpbi1GLDYlUSZzb2xzYUYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOUY5LUY2Ni1RIjpGJ0Y5RjtGPkZARkJGREZGRkhGSkZNRmNvRjk=LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVElaTF0YUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RKiZjb2xvbmVxO0YnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGPS8lKXN0cmV0Y2h5R0Y9LyUqc3ltbWV0cmljR0Y9LyUobGFyZ2VvcEdGPS8lLm1vdmFibGVsaW1pdHNHRj0vJSdhY2NlbnRHRj0vJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0ZMLUYsNiVRKWludHRyYW5zRidGL0YyLUkobWZlbmNlZEdGJDYmLUYjNiUtRiw2JVEraW52bGFwbGFjZUYnRi9GMi8lK2V4ZWN1dGFibGVHRj1GOUY5LyUlb3BlbkdRIltGJy8lJmNsb3NlR1EiXUYnLUZTNiQtRiM2Ky1GLDYlUSRpMXNGJ0YvRjItRjY2LVEiLEYnRjlGOy9GP0YxRkBGQkZERkZGSC9GS1EmMC4wZW1GJy9GTlEsMC4zMzMzMzMzZW1GJy1GNjYtUSJ+RidGOUY7Rj5GQEZCRkRGRkZIRmdvL0ZORmhvLUYsNiVRInNGJ0YvRjJGY29GW3AtRiw2JVEidEYnRi9GMkZaRjlGOS1GNjYtUSI6RidGOUY7Rj5GQEZCRkRGRkZIRkpGTUZaRjk=LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbWlHRiQ2JVEkVmdhRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEqJmNvbG9uZXE7RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtRiw2JVEjUmdGJ0YvRjItRjY2LVEnJnNkb3Q7RidGOUY7Rj5GQEZCRkRGRkZIL0ZLUSYwLjBlbUYnL0ZORlYtRiw2JVElaTF0YUYnRi9GMi1GNjYtUSI6RidGOUY7Rj5GQEZCRkRGRkZIRkpGTS8lK2V4ZWN1dGFibGVHRj1GOQ==Of particular importance is the ilta because this current must flow in the gate driver of MLS without forcing it out of saturation and further aggravating the situation. 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%;By plotting the current at two different risetimes, LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUkjbWlHRiQ2JVEjdHJGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRicvRjNRJ25vcm1hbEYn, we can clearly observe that the current LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUkjbWlHRiQ2JVElaWx0YUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy9GM1Enbm9ybWFsRic= is significantly higher in the case of LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2JVEjdHJGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSI9RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSVtc3VwR0YkNiUtSSNtbkdGJDYkUSMxMEYnRjktRiM2JS1GNjYtUSomdW1pbnVzMDtGJ0Y5RjtGPkZARkJGREZGRkgvRktRLDAuMjIyMjIyMmVtRicvRk5GZm4tRlM2JFEiOUYnRjlGOS8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRictRiw2I1EhRidGOQ== as compared to that at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEjdHJGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUSI9RicvRjNRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y9LyUpc3RyZXRjaHlHRj0vJSpzeW1tZXRyaWNHRj0vJShsYXJnZW9wR0Y9LyUubW92YWJsZWxpbWl0c0dGPS8lJ2FjY2VudEdGPS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRkwtSSVtc3VwR0YkNiUtSSNtbkdGJDYkUSMxMEYnRjktRiM2JS1GNjYtUSomdW1pbnVzMDtGJ0Y5RjtGPkZARkJGREZGRkgvRktRLDAuMjIyMjIyMmVtRicvRk5GZm4tRlM2JFEiOEYnRjlGOS8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRidGOQ==. For the time being we need not concern ourselves with rise times faster than 1 ns since almost all converters operate at a lower value.Now we can examine the effect of gate-drain capacitance, Cgd, on the value of the gate voltage Vga by plotting Vga as a function of both time and Cgd and keeping the remaining variables at a constant value.LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2JVEncGxvdDNkRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkobWZlbmNlZEdGJDYkLUYjNkktRjY2Ji1GIzYnLUYsNiVRJXN1YnNGJ0YvRjItRjY2JC1GIzY1LUYsNiVRI1JnRidGL0YyLUkjbW9HRiQ2LVEiPUYnL0YzUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGUC8lKXN0cmV0Y2h5R0ZQLyUqc3ltbWV0cmljR0ZQLyUobGFyZ2VvcEdGUC8lLm1vdmFibGVsaW1pdHNHRlAvJSdhY2NlbnRHRlAvJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0Zpbi1JI21uR0YkNiRRIjFGJ0ZMLUZJNi1RIixGJ0ZMRk4vRlJGMUZTRlVGV0ZZRmVuL0ZoblEmMC4wZW1GJy9GW29RLDAuMzMzMzMzM2VtRictRkk2LVEifkYnRkxGTkZRRlNGVUZXRllGZW5GZG8vRltvRmVvLUYsNiVRJENnc0YnRi9GMkZIRlxvLUZJNi1RJyZzZG90O0YnRkxGTkZRRlNGVUZXRllGZW5GZG9GW3AtSSVtc3VwR0YkNiUtRl1vNiRRIzEwRidGTC1GIzYmLUZJNi1RKiZ1bWludXMwO0YnRkxGTkZRRlNGVUZXRllGZW4vRmhuUSwwLjIyMjIyMjJlbUYnL0Zbb0ZecS1GXW82JFEiOUYnRkwvJStleGVjdXRhYmxlR0ZQRkwvJTFzdXBlcnNjcmlwdHNoaWZ0R1EiMEYnRmBvRmhvLUYsNiVRI3RyRidGL0YyRkhGYnBGYG8tRiw2JVEkVmdhRidGL0YyRmNxRkxGTC1GLDYjUSFGJ0ZjcUZMRkwvJSVvcGVuR1EifGZyRicvJSZjbG9zZUdRInxockYnRmBvRmhvLUYsNiVRJENnZEYnRi9GMkZILUZdbzYkUSIyRidGTEZfcC1GY3A2JUZlcC1GIzYmRmpwRmVwRmNxRkxGZXEtRkk2LVEjLi5GJ0ZMRk5GUUZTRlVGV0ZZRmVuRl1xRltwLUZdbzYkUSI2RidGTEZfcEZdc0Zgb0Zob0Zoby1GLDYlUSJ0RidGL0YyRkgtRl1vNiRRIjBGJ0ZMRmFzLUYsNiVRJHRvbkYnRi9GMi1GSTYtUSIrRidGTEZORlFGU0ZVRldGWUZlbkZdcUZfcS1GY3A2JUZlcC1GIzYmRmpwLUZdbzYkUSI3RidGTEZjcUZMRmVxRmBvRmhvLUYsNiVRLXRyYW5zcGFyZW5jeUYnRi9GMkZILUZdbzYkUSQwLjRGJ0ZMRmBvRmhvLUYsNiVRK2xpZ2h0bW9kZWxGJ0YvRjJGSC1GLDYlUSdsaWdodDJGJ0YvRjJGYG9GaG8tRiw2JVElYXhlc0YnRi9GMkZILUYsNiVRJmJveGVkRidGL0YyRmNxRkxGTEZjcUZM%;One can observe that an MLS MOSFET with a higher Cgd value is more prone to shoot-through when compared to a lower value one.Looking at one last plot of LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUkjbWlHRiQ2JVElaTF0YUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy9GM1Enbm9ybWFsRic= as a function of LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUkjbWlHRiQ2JVEjdHJGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRicvRjNRJ25vcm1hbEYn and time with the rest of the variables held constant, we can see the full range of currents that may be observed for different risetimes. This graph is very useful when designing synchronous buck converters because the current i1ta is also sinked by the output stage of the gate driver of MLS. Most commercially available gate drivers can sink and source a maximum of about 2 A. This means that if i1ta is larger than the maximum gate driver current, the output stage will get out of saturation resulting in the gate voltage climbing even higher, resulting in a more serious shoot-through condition. LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2I1EhRictRiM2Ji1GLDYlUSdwbG90M2RGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSShtZmVuY2VkR0YkNiQtRiM2PC1GOzYmLUYjNictRiw2JVElc3Vic0YnRjRGNy1GOzYkLUYjNjctRiw2JVEjUmdGJ0Y0RjctSSNtb0dGJDYtUSI9RicvRjhRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZVLyUpc3RyZXRjaHlHRlUvJSpzeW1tZXRyaWNHRlUvJShsYXJnZW9wR0ZVLyUubW92YWJsZWxpbWl0c0dGVS8lJ2FjY2VudEdGVS8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRl5vLUkjbW5HRiQ2JFEiMUYnRlEtRk42LVEiLEYnRlFGUy9GV0Y2RlhGWkZmbkZobkZqbi9GXW9RJjAuMGVtRicvRmBvUSwwLjMzMzMzMzNlbUYnLUZONi1RIn5GJ0ZRRlNGVkZYRlpGZm5GaG5Gam5GaW8vRmBvRmpvLUYsNiVRJENnc0YnRjRGN0ZNRmFvLUZONi1RJyZzZG90O0YnRlFGU0ZWRlhGWkZmbkZobkZqbkZpb0ZgcC1JJW1zdXBHRiQ2JS1GYm82JFEjMTBGJ0ZRLUYjNiYtRk42LVEqJnVtaW51czA7RidGUUZTRlZGWEZaRmZuRmhuRmpuL0Zdb1EsMC4yMjIyMjIyZW1GJy9GYG9GY3EtRmJvNiRRIjlGJ0ZRLyUrZXhlY3V0YWJsZUdGVUZRLyUxc3VwZXJzY3JpcHRzaGlmdEdRIjBGJ0Zlb0ZdcC1GLDYlUSRDZ2RGJ0Y0RjdGTS1GYm82JFEiNEYnRlFGZHAtRmhwNiVGanAtRiM2JkZfcUZqcEZocUZRRmpxRmVvLUYsNiVRJWkxdGFGJ0Y0RjdGaHFGUUZRRitGaHFGUUZRLyUlb3BlbkdRInxmckYnLyUmY2xvc2VHUSJ8aHJGJ0Zlb0ZdcC1GLDYlUSN0ckYnRjRGN0ZNLUZocDYlRmpwLUYjNiZGX3EtRmJvNiRRIjdGJ0ZRRmhxRlFGanEtRk42LVEjLi5GJ0ZRRlNGVkZYRlpGZm5GaG5Gam5GYnFGYHBGY3JGZW9GXXBGXXAtRiw2JVEidEYnRjRGN0ZNLUZibzYkUSIwRidGUUZqcy1GLDYlUSR0b25GJ0Y0RjctRk42LVEiK0YnRlFGU0ZWRlhGWkZmbkZobkZqbkZicUZkcUZjc0Zlb0ZdcEZdcC1GLDYlUSVheGVzRidGNEY3Rk0tRiw2JVEmYm94ZWRGJ0Y0RjdGaHFGUUZRRmhxRlFGK0ZocUZR%;Conclusion:1. Equation (1) should be used to evaluate a given MOSFET's susceptibility to shoot-through for almost all applications today.
2. Equation (2) should be used for the projected applications of the next few years where the rise and fall times are in the sub-nanosecond range.
3. We ignored the effect of MOSFET electrode inductances to derive simple and reasonably accurate equations. The use of parasitic inductances makes the problem so complicated that a simple equation is not attainable.
4. Shoot-through rarely results in a catastrophic failure of the MOSFETs. In general, it results in modest to serious degradation of the converter efficiency, resulting in higher operation temperatures.Legal Notice: The copyright for this application is owned by the author(s). Neither Maplesoft nor the author are responsible for any errors contained within and are not liable for any damages resulting from the use of this material. This application is intended for non-commercial, non-profit use only. Contact the author for permission if you wish to use this application in for-profit activities.MFNWtKUb<ob<R=MDLCdNVZZJ:@L>T:^rIADlkl`N\\@Nd\\QgqxHQJNmpdYK]yRwMwmXquhLMTqUdJUEpMDPjXLODpxqN@lXAlXqMNBlXalLRiuWysPyqyhKYIvUhyHimstxXImsuPPyJ=asV@ukpXwUWihpqqMeyuyAT>LJ;@RZ<LB\\J<DZh>ffA\\;?^J>;>BfZ^>\\B^:ZFva?^vYxixI]gyxYxixImxXwtwgciaXxtaP_Vyqyqyu_paYu;NrM?ms_eWAj\\QxvwkC@yWoZhvytffAyp<Ixjad@O_QqmdqcI?dWOxlqxj_xUwscfwXnhXvoyVeQo`twnifv\\IxQileWaKxpEaqwaxAoaGQxr>evx`UGsa>\\B^:At>uFuyYaaXs=yGQvkmwn;e[Qi:OxMerqYgxYbKcGo[dkwrhkYuiwqOvQwUxEGxwyxYy\\]tbGT_iiykyrYFWyg=GD]kR^_bkaiM;ShwyoytYEwUYrOyyp=DtcrCyh\\QvyOvhaX_yEi]ikQsredq_UHce<OxRwvWExQIYY_HMwjj\\Nuts=tqOtRXtXW`xs=MtiolXTthQwIYaQvcaxlpoUuPv\\YyqwGeyDYxMxnoXtjaPaIwiYovMxt\\nvEKWpWyduLxSZ<LBRQcedyyokdDWFssHKiXkMBxUyr[I`kFfSugSTjCv>WDPSdImIsEHCaFM_c`sB[]gkord=T@=yYQT;CR=Iy^YdIMtiMBYOVDGGLYsFaDE=cgOCA[vmSsX?E[]ekmrcSCAwvsmfWKEdCvLkEYqShUuOsRe_yMsCYCdpEs\\WtkUYxitZ[Dy_VLQGGkyxOx[OxkaIBmfhgyDmuwGS]eTWEB>IyeygyofaadpugqkI]?ftgTakyv_IvoWNIYY?YNoHQWSWaiqWSsowcoeuyyxAsAwXNIeLqROmUWAg=ieNwsZuM>LZ;@rRHwyib^h\\PxkKP^\\Q]ifhWWfcxc^i[P?ixG`J?xSHg`HmDHl]vbPP`horKNeD?v=y[y^cYAgqN_rNZFIcGwcJFicIc[Gd[IaCw\\;XgAXmLxfXieB`hwXt`?`_yd^adkWakiwn^qV`aHQ__>pSGaLo^dVcywuiHi]vwgoytOdd?oVQ^rqyffh?GwQWbZQqLadqpidHZcob>GxNIcyvsrX]SPt_Q[:w^[Q`mQ`jW_\\wi_YZ@i]q_u@xyh`lH^fnPlI?q[gZ<Fj:At>w`tyiIV^Y@c_neGXq>I_XWnaqjDAy=o]k>d:Ytx@y\\Yk\\orSvffFyA@y@g\\aagc@jZHtFQ`Ea__a_iocJQwFAnu@r[NbtiwPv[KndXhd_AgAa_l`oonmHwmCnwn^nsW_YpoSvhuoxrPcSVgOpZOxbH?pwofVwta>mZOjLQcKg\\aWoSO[yoe_qldFosXisg]La_<Xe__ipW^aFvwFgjA_JNm[@vqgeeyjTQbXop\\nxLotuh`MY^sGqonrOxyx@sAwsc^cqV^mqw:wp:`tKxcZ>\\B^Z@p_tftyYq_gb[G`@OqapbhIbZYg<xZuAy]amI_aximqoucnnUpgtPd;YxCPwvgiigwW?pvN\\KV`aNmGAvEPhNnjBWghon\\YmFGdRgwl@jBQvZ`sMv[yXqcYZhanGFarFoia^BYnu@aCG^N`edasZ>xhff\\`iB`lDokv?sQXe<Nwdnk\\NwXpbOXkTFpUGavon;i_\\neAaviGeapitoi^g]biooqr]IdX?`;oh]piCo`hq\\OYdtPy\\v]OIeOyeSgnrwphQyiH`CPqlI[>NZ;L[XMwyquhmaqMw\\YZQJletpIkPInjlyBmo^yRhiV:`Q=yJmiRbIQqtWCAN^`NBUqKDLNDVeXn:<Q[EtF`OTMt]ukwlTVyYyiycYx^YlImLYaYmiStmwSyVYhOCtWyEx;yJY\\LYiYqiUSxLKPrn@J`XKx<YDywEtOv@lPQtb@Lthvyyvm`th`t[TL^UTA`UePXsen]`YNEvrAv\\Xx\\YkilloanOxwYuSGDUPiKd<P[YyT@nYpYtIO_HU^=UmTMvtSVqWSUsQilnaJdquuuwwxtjpp;PptEw_xldELfeq]pX\\@YYpYtIwXtL]eX\\XloaqMmPimqsqVkYrItQnYUxLOEusadwniyqyuY\\T=@TIMxC\\J<DZ[ho>`hdxyQx^@p^EGZvIZq^^kOZp>hlIcGG_cfuT`jhqZAi\\Qa\\aOxWFrdphBg\\dgc[Ogopa<^th>alGldgZSo]^h[DWavAw]xkDxvXXih@aqaumWkUpgtH_wqrWYkjvkrNvBppsqlYQieioC`isXoQ`jLikS^e\\AbSQ^IwwxXyhWj`>uGvyyFsYioI?s<FmZVmtN[b`v^EIkDkWvIwIx_gV]bsuJhAOgXQwHu`msq]qLUR`HtxPydYo?iPQaUMMUYal`EquEoxLOhEORhqSumj=x;yJQtNW`XLEwTmrqqOu`wL]Mq]ukepXyX?MtqxNhXyxUqTtqfxjliPwxxXYYMUmdyov=KYpKOPXJYYbDjI`QlAs:xUyITAmQ;@RZ<LRLmbaXyywhisFhpiuqwqX\\QYb<QtpKIMTT]YglWqpNbTQgtUQ=P>IK>IJWEKcYp<LNl`miUnOurGqRx=xtAwyQWehoP]wyxyxirdTofPTfmpSqV?qYuiwQ]sktrVdKiQPEdKSIlOQjrDm?tYjIrATtFlqiYOfhoJqMw]xKQxXXL>ux;xT?`s?TngpRmUpKDv;mYOtRxaSH]nmEM[`WgpqtQwctsldqkuw[xjXLOMqw[MOVtsqxrGMYByVOMuWEwJyY`UosmUD\\j^MvUYot=MvUVKATSXn:EOgPo^]v[ilQmUc=WZyRXDY^UrtuMKhT^uvsAvUXWl@rrQu>tucUkvmyrYvIXnKlYNdtAlMr=n[QyKyRYduJmuvTRTHph]vh\\UhTwcynYpQS]uNpQdauLUSgdTvqyuyw_eYaIYLYsaPwVYLf@Ox@yxtugMkqISApuIiVfiv?eu@mOhQPb@qrxlYuTXETL\\YgElQiM^MRSAlpDOS]q=hJLYvQEqbpoe\\YDIvUyWyhOmypbQnEpLulwrXV=EmdhkrXuSxpAdpSusemuP@o]PkutlCLxmYWXpU?XotdtUEybdmXpRIyYZ<LB\\KA=YyUmIMWPEXMPoklPiYxStxv]mjqQrPWf=vqPys=riuMIvv?HyPVxgPyygj[nwbiyyvyCv\\HvlmWaLAvXDQaroqTWeXOQdIArM_YliuqMuN]IHIWWmU^idvGiv[dy_YfYXhWtgGxeGutkDkEivIUquyYsvyuy[GU>;iGcSscvNgCTaVxiuY[IkarMCc>ksxSyfifZqWsgvP_TZ;dI]hCihQqUu?epMucUdeyrpWuhUePUuYgYpIu?QUeegOoV<ISAQdEmGS]ivQxEirQuUwedfOGUeWogTSkyFYHIaeXIUsevOWcostVUHgAw_gRGaiuUygyhaccrefOoTDMBUAV=gCL]IVybJoEn=t;EgZwWrGv@OV=iCq[GWITJ]epsuvUxNss`WehMUf]ikqr_QrUCDKmuyCv>WDLWcSAy]ycY?sUCVguhWqXcuw^YTHEI_cfCwxb=e^YwlYsisGh;iZQb>MxVEs]IE^=XRIVAgF<_YdIgaofnTYiiqqMl?LX^HNkToypstTw^LnxEx?yLaxviPqdQo\\euoutGEW]PpxMycyncts^yvFYPIaSkEpuErPXUhEUf]pKqRcdQtuMMPMiyoqpeLYyJniBXyawmwolT^]lW^g>s:xxHWagapNpafF]QpetGgDYwvYxIymLQi_ilQo\\qouswfkAy]ykQv\\X?i[Ou^AjrG_EfgYqbv?__`a=oqP^ejGrnX^UitQweWP]sYdIgaO_ayaymI_h?pxQyey\\Uwgwhhdvd^_bWAm[ojSNk=y[y^qR?f;hZDHeagmofnEys:A^hNr]qao_jgYvhhqpQun@jdYvIxaHGy[voBqj@ny@Y]i_nHafshvPXc_Wsw_lVNvMguJQjmX]i_qk`iYpsIPh_^sAx]x?aOYb^IrSPaxXpVqwuxwXPrw@w\\XkDHoapmt@meoosPsr?iIGxJwaoq[DQteyoypm^GbWyevGx?YlfqmsovS`th@[=xfOo`^imtFqIqauantAcSFhW`hVHh@I]ch[KxcxxlXOica^UomOgyW_fKhbLomiWqgqp\\gjOndbfLeW^qvUwWHeXFeeYCw]qIcufWMTqOxgqh;Cw=mERmTBwepaSsAdp[V?gBAoHvSufUh__yJoTdYFw]BP]GHQG<QrBuY;=UvWSv[bMQSx[f_Au]ucGMsECWVmYsivEGc`Keb_TJSB;?RZ=I<yDRUH@qwjWrHcrQyUyee@AhWuXWihVSY[YSFGCFmrgCh>QDcwY`]c`]cZ]c;iFCkCAYyjUC@Yd=sCv;HGwBjeiekgrOFGmReMdToyUkslmtSuV_SwuOysmgKysmCf@sv\\IIN[C\\yba;tyUra?EmKwHwcnIxAaEm]S\\aRQ_UlESTSH`SefMhNkGvKVTGW`GGs]BM_vvwCi=VFwbYMGVmrssvt]U][UkaF^EF_;sasx>iB[ACBqCxMGx;Ba=vtQREcGN_vAiXrgdEavayeymSD?DlCtRythkYXYEeSdxGsMCWOseqiHAIYToBFQGLuu`oDZmh\\Ob<MGc[BVAXJ[x;sBV;TfihQqUc?HwmRTOsnmusuv_KXHEvaqw[[UA?SMEvvmtWwxQAU]ec>]hsoBKIf<KgKIR@Cgv]iI[hX=FYgV_GVrQI<cYikhRQVccsUyWygYtABByHGgcDkRx;yi_y=]caIeame\\qeumwcsDwQsIAlBPtb<TrlLX=Y[aTkASattjEU<<mPDyi`pKpXBayQxUxEuJEJnTMhtlttXIItw<XBINA`NeeLiYsvpR_uR`yRWdXNUr\\YNy\\WKpS;PP^tybdK>xJcXj^PTP]YJmQVyjLPXPQjgDsGpSEeKQPp[lSXiRS<lVHOmeledx<PYmxwxXy`@qBtuQIpjaK>Tlr@YiEm_mlCemZDvvhxPYUC@vEQJ<lNW`XLalY]udpwuxwxPTx]Q=DxPhx?LJeHUGlwcXx`pSKumCTRxHndxOxTN=MQBUxXXYhImDQteApAYj?MsaMTJmTsammmssdnUhmfDRXmPdALBuKIQTa<oAPoq\\Sn<lAMtCmQOmNNXJlaR[lxnDoGdvg]Js<sIiltLrZ@TOqOmUKdPsO`XBisIHrGpxHurDeq`pybpsLurcxl^hkt]nxQjvAoGlpLxkPqL;LxwXtHUQ_dJelLbxJ<Dj[qKoIxFxSFhqFXKnyoJTY@aSf@wVunYmVfDtrAKslv=uMFaN\\txZltTtLSTn[DoTtoS@mOqjj<RudTcxmQuuHuQipQYUvPDxjlRklmCxLttRemtyYP@Dnb=kaDrS]vX]Srar=DsAixUyPAIjQ=nVDPpHxU<n^<Wf`usuvWXTRLvC]YeELt@q_Dv:yvRTvZYXFXyBQkuMxHDVF]Vl]kklLbUQvuMuATDPXS`KPTKxAMyDK?]vQPKaYkR=oVPq`hwPEmKqmrMvCXlpek<AJsxL>=RWUXQDkZmJU@xJASwUMVELZLr^PV]@vjTQFaSp@Jcqvwfr:HerofDIcI@cdFgP_ysIeONs]ppZW^I?qm@lp_`pO]i`iKfbf@qaYe^PgKy`qId:@suN]rflNV[:FgA@nCGu[o\\YfoUOsOnyB@g\\qwlannFkvqvAVvBaebxx[vqlg[L`gCYpuhi[v[xhhlyvNWdGgtJvdx@iVxuBadlWoTYmUgkXGvZ`[rPvQxnSP`?o[FQ\\JI`[@rZo[_qmiwvEhf@ww\\VbT>`_Wj\\`jo`b_IcT@^XahN>sWwtOxiGAnMx[vyacV[OybgXq[`iSwd<`ixvyvYxKqs>H^I`liFgw`wlXsLQZpofU_m>WtCA_X^\\lgrEhb:Ox[yhx?tKgtXwvbng>xru>lugaIoaS>bbAjCwqNXaiaoWGbOhx@p`<`sca]Cw]m^dBAlu_j]Y[jauONtGGtnxswnxRY^OYfNncsHv[V\\fnfBajjHmwOxtinj^dQaqgIl@qdlIZnOuqwuwwhLX[o_mH`qda_O@bZ>\\RngP>\\ko^N`ZtQcGolCipTXwnYsVNdgxhR@gm?oyojiA`;YxTYgihnkn[xhr^x]>huIN]`o\\YH`T@qjpbbxaaypmWZXhjIHrE^rEFk=wb@_pdyySV]mqyYH`A@hK?_Hoasav>Y^pHu`Wm>ijNxaGHj\\qiTV_VXp_aunvaN>eeGnCxbDgjpok\\_[?oa:nyCA]eH[T?^s>\\YNpGiuFiyB?j;@kTy^[xhTncxG^j>[RNn`ab=g\\?HmD?kVNm\\XlIG[Wxg`opswuC?[TG`^`]\\faiaqmq`RwaNArb?dRx[c?aJH_Yy`TglCIknP_Pxo?Hx=pgVGmLo]VWoQhnZv^RQyii\\S_vVwsZ`f:OowiahY`eFb=qvUW`eA\\aYwhXqhfsZXb>XxWy\\Bwqp_]mwqCgv_viY_nnvsmvuHOuwv_Hox>_uOxovHrtF_oa`th\\Bgx>i\\Sfls@kcnvZ_sN@qBInF`orPvDh[AH\\cneXYrwQkiOa\\^\\BvuaXmaAdZG[Qvd^NwYxgcyvsAdwftuQwZFsiixQyeYAlQwua^eoI[lisf?[YeuowsOVaivNwf;iv_YwuMxMIuCssqiGQOX@GgV;dIMI[ewnmv[QInuScYt>GbdqeiEbb_YrIrIoi?wEm[TnwIp[fZ_EJ]crmdpoSUaR`[UIxPQ=XWEppaXpaNYdteLxEhRLiu<QRsAK>LJ=IMTaXBpQKTO@TvYlmQ<UU\\r=ATX\\tiTRxIpjXPS]ru=q]DxvprnEOk<JXhj<LJRTWnDsdxkImY_QS=prUEUjhmQLWf<LAEWPyye\\UtyY@aM?irrmj?qRvLjCLSruLhTwHiyvMVgtvtDysxLXxoVQrhhkv]mI<wBdjv]qO=yleNQAQ`IxHllmmo@\\t@myLlqDtPQar[dVbTLNMJa<LL\\QO<MgHUmpod\\RdLQOXK\\Lw>HuC<NxdkltMtDLaHxjpK@@p[tx>hnWtKNpOvmulMXOxwD<v^HLLXk@Xsi]OdLUvuoDYwkYySHOl@JbaXt]oT\\PjEyRIRNAs]tu\\tmbdKfxj[lSalyDXkqaR`itZhuw=OyuUmtuXpRc<PLMJvtKXAm>=QohlhDv]TXQmSNAKmYrFdmNlv>plemW;TthhSnMOFAVB`sE`ku=ulUK\\tYRHQShjJ=uThnadkn=qTHvKMusmjtHNMMWh`vbIQdAlPDp[@VrqW^MlmPQQDqcISHQTfavperfELUHM^Qp^yQP]JomWh@u`iMWDY?iXI`q[Eu<mUvqVpAKMuPD\\MkMW@MsqpopMlihwsHMn]peyjTAkuXxc=PJUq^\\U?N[_nn`ofR@d>?lq`cNAsGVkBx[Rnq?ppVq\\_@vuQ^B?tDoa^XghIqaqccqnXVfdwf`fcaOr>NZ;@rjgjr_Zwo^e?xbYb[A^vyfg`^ZQqr?]DnZwy`]sAGsEmgCWE[_rJyt\\?f:Yvj_WMkCiYHcawhSrx=ujmYTAiMsWkQRS=GNygmqSeoyY[sssvVGGG]UAEYtcynYtEixy?xB[gY;GYKXgQFwKUIGBriUoCSg_xCWSrIVwMX?QDYWFfKvxsyvYxMiX^urRuCjQY;WRjkIssXEIIKwcwEieix:Eht]vyyB>aDYWGMkiQMhIqWDUi@yvHWWN=Ex[T\\EDSKGjetfgFQAFp=y:KTc_vDgfr;y@if?sh_;Cewg]=rwsB_ibrGH=GsN?ST?gr=Da[g`KFaqW@]t<EVcUwtcHLoRBCt?iDESsF_DYcv=YEVos@ArlWr<UuGmHSaF_GCm?FDIbPAVJsEPEDlAs\\AH?ifH=RuoRcGRCmgTuW;wuwoe=iSB]FYyuaGFk?UFCUluc@icL[biafN?bV?xtUrN_YjEXSiWqguDqCFeveKTd_y:=yKwCcUxnSW`CRkIy[md^YEMUGEGdKwGxtSvDx>QXptugpVh@qLmMfXtZYrmMKUxKqAsadvF`KZ\\wNINXHVkxQsATaqvu`ksPXEhT;PQ>yJBQM`yVd@L@\\vQPp?aNftxb<r`eJhtOYHt;ml:pSwtmwxsIdT^\\QdyJcINY=mWHT<=kYxydxs:HmdlJI`qV\\NudXlQX[UTUDV`As]isqUrjiWEdTh]rc@qSuj[tTs\\l_lJ>Ds>dRJYsIivZYlKlMaUPsAJf<VbLQfXV;mMRMjv`M=Dj:=VrLR]]l`TmbYRwuVDekCMY@hJ`ak[@X<lLPUrcpKw\\xJQXv<Vf=VF@VfHJVyvSeSPEp;pK]qKeMNluSDPOHENX=s>YOyIMiISY`Q>MUoyiy@m:n^G_ky^xyAx?no=I[k`oJn]Vfkov]TVpBV[QHfXYjIIgladcgfvwfVwjMPra@[UHhPWmVfuowtWGgfnvqFhBXojnsEGu]^grwZ]q]sYhi_ZY`iqwheGs>WlaXZOiZe`v]vyp@m`Yfq@Z`?[epkNwgQpj_q^mvm_p\\sqhYHiBPZA>s:_kNvqFGfspnfuV_csWyC?sicDDgRjOXsITvQI:sCLIwm;wvqVKkDmsuhYHhIVDmSXwR_wbqETZ_yXWWvqioWgyUhbMCg]EGwuMYfDKGqoD?GB[mb>MveCw^euGadTIhEgEY[hHGRs=Fh[YHCWJoeisHQMYxOxWmcvcyvsbLSRsIhpqb@gbuuDhGXhquOweBmeAGwsYsWMerwfgEVK=fJMEw_WdOxXYTrKgY?UT?xOaFfcfIshZkDZGtcMhmkdIqxuOb=YhFQXJoFswxsEEbcWNYHNOStsSiWi>YbeMdQiHCibH[C_ABECC[UiVQxpQwlgTWKfxIiegDk=dIew>Ivh[UdsbVagGyWoGDXigdsXyqsEYTYAiZEHUcrtIDwSrhIUXutmppddUhqyBqkVes^Yv_ykOTsmqMB\\J<TbvxqnIsx`iwVbxntbI]Y@hDy`=Gxk@rAalvxgHyr[vvYOkIVkx^qJnk`Ig<YvZpcyysio\\OYki>_Fnt?V``VaI@\\yPtP?rTW\\VXiR?qeppPyyt`yNx\\\\Q^h_\\c>aKxvQnc@ajdoaXvdG__`aethmVfqSgyBYsXFemXgcPxaF]rqkRgvTnuXQmH_^>v]fYu[GZkYbE_pOVmYYl_F^yV_>GglwyqPouq]pXb`p`pwy[PPAi^YGBCYaYdagcYQxC[di_VXsciqC_yw;cieyxvsEXseyUdP[ujMg^edaYUEOhwsis]etmTIivcaxeiTU=HaysEmDhqf`orbGE<[vG;HWOho=hYKvaoR`ie>wbcIWbIShQdKeTSaT_iia?XNoYQMHwEHwwd]mGYuCYoS>UC\\Qxl;tm_st=GGiTo=uW]iNIX[eb;EbjiCPKgtkfvout_YRgfCYw^wvaOgfWxtSgpKdqGvdwwv_EnieaieeEYWugMoGyyuDmIhSevsw;?RZ;HVGvwqXHIVlIXyOcmaH]iUxkD^aUiGEqUgDwTv?HywTqwyAksQ[XWyr^uEeGRHiRUGxkCYaaTkeFIWIISssWUOAuTacEuX]MDgseBkgLyBvayIsyY?iOeum=RVifBCVDUEX;w`keP=FY;iZ=XXABT;GsIracU>GIvAruyBsARD;sPcwrUcgkhBue_udWmhVUX[yvn=yFgy:=s=_d\\ctGCe]gV<ow^]u>YrsCGxmiFCw[gElmhDcxqshrcC@SxeuHjsuvUx?_Y<Cb:=Ftyybyyu;rI]XR]fNwCVIsrsrFmrDCGYKyWAf^ohD?RuqwuasemiYGxZmblQvxWv=GWQCb;AfZIgHAWkghxYs^CgWYdNuflUDeAe>WiMIg;IsvIGmuWaCfWisnoVCYIL]V`qW;OSQWijgCqqSp[vM;C>KBKyyAuyYqYrqtvQXiuwGIETeGqEr\\edxoXCMthuRTgfXKG>CuqoYOIVrCfv]hIURPCXpibwOHQIiFihZkuIKwS;GD[dFqbxos`sH_qX<KuJCrWuEwou`qIaoWLcw@My@Sc<[ElIC>KB;?wyYfyyWYKxouibQCfwTkYx[QelYePEDj?FSgbYaGZgtpUWOECR[s>CuaedmirCEbpaTLaY;ygtsBSmtdoXIOwgoHWictKveedtGtCGYxiiXOisCuwIRwEdw]W_SU>_Y<C:JJXM;lP\\HJspmJxSXpxDEJ[@nrLSXXxo<kZ]tbHTcLRWlUp\\TF=UhqjOeXTMYZxwleOeTmWlkaXwhHOuIV>Hy\\Mv;@lAtulqSg=nMql:etEuWmmYPXkXHxwIrmYpjljueyEDy>:vgy`iKX^uxhcAoCnkF@t>aoEAqdWZ]plD>[EfeC>d;VyPPmVY]D>t<peg>baYrSX]LAx<fwKx_lgd_hnHfkVFal_`sVo<QhWXy=Fb;FdTGy`feLocuhpJh_Y?aaqf_wc=NkCFw^q]caktX]lI[>:vwn`mm_`Mxofvcgfd:?c]^vKfoKxU]uw;RhaHV[e]KracR^;tX;glKTQ?g=MgQ]UQ_e_?g:Gb\\_YbgCJIVKoEN?Xokhh]fIMhLUiMyyvWX_yHcUvyCWGOiU]HNGTByFJ;C>KfyycxyiwaE?UDrQXsUge_uo_h:?yPyeTiI:ICJAT<wGBuW`Gu?KyhGFuUrqEupOiy;DN?DOIdkcdpOGseTg[SiWi:[WrGF^YDB\\:piaAyKW_qX_YW\\VQd;FsIwoVNcu>f?NZ;@bZ>\\B^Z<byAdx=tfExs?TuAEmuu?=rI=iHgU>KB;?JZZ@x_lWj?xm:puafZ>E=yC]UsiiB<Cb::XUCDwCiydxTD<SImqUMqQLSB=NJ<;?:[t?Acxoibcr]kSEsC>KB;JB\\KY\\TWLugQQ;UoWPRyyk@elHhVplTJPW:<J:<j^PNaLNQENjDB:3:\"\{\}-%%ROOTG6'-%)BOUNDS_XG6#$""!!""-%)BOUNDS_YGF'-%-BOUNDS_WIDTHG6#$"%+!)F*-%.BOUNDS_HEIGHTG6#$"$I$F*-%)CHILDRENG6"