Find this useful? Enter your email to receive occasional updates for securing PHP code.

Signing you up...

Thank you for signing up!

PHP Decode

<?php $PHP=$ITGEEK_ID='SGhySG4+bjBUNj82QFQmJCh3d0svJkRAJ2YoPltmKCkrLGpCMk5qOFVRRlFjSkM+M28..

Decoded Output download

$ITGEEK_ID=base64_decode($ITGEEK_ID);$ITGEEK_ID=strtr($ITGEEK_ID,'dcstvn<>,=PO)ST[] /AIUEG?;[email protected]$yq0_9&2w(Ha','[email protected]$yq0_9&2w(Hadcstvn<>,=PO)ST[] /AIUEG?;');$REP=ereg_replace('__FILE__',"'".$PHP."'",$ITGEEK_ID);eval($REP);$REP=0;$ITGEEK_ID=0;

Did this file decode correctly?

Original Code

<?php $PHP=$ITGEEK_ID='HhrHn>n0T6?6@T&$(wwK/&D@'f(>[f()+,jB2Nj8UQFQcJC>3o eiJkR9JUYd6lucKCk<L(nCMk5].FVRRlFjfkM+MU8gZWlK;1&5flVZZDZeZWNN,wYgMlZ1Zlo<N22eMjJV,2Z;X2xD6p9k; 5FfpZ1;VYgNWEtscupZvBf2vxeZVVuo[9z$wZWmCR<$l tMlZ.2poKLFmk$v5NZjVQ2X9[V$ujMvlX,D)t$VZ(Rwneo2uiMWEx$(u.f1n32lJ;o1Z.2kReRvxX$v5zYz><Wj&[VW1(WX>M61l)mUE+W$JeMjoN;cxVVvBNZ1o,NWNNMl&7f3m1&wx]$loWMkVkmzAkYzu<fjFX;kFD$VmgslF]RlJRW1n]LFuCQ 1,sFYeMURjWVViLlFVZDVfMjF32Wx1Wk gKX>Mm(5D,1ZkX1F]RpVN&CZ)MjJ.f1JjQWnRJ?oV.[BK,vxWVcVWZp>ZJF>WZlo(,c)eW1wx,UegX1o<VcluRlnW$(xWRcAW,lgcR(1lNv9nNfRW,WNfVcxQ,UZe;VkgKWoXVcV)LwNF;UAXVp2cR(EnV1otQ[Z(,lkkJD5NVjF;M2xeVkZ.&wVkmzAt2jYgfjxKYU5D2cY1VvRE,lJR&(5 LDNCLlJUs(d[JD5nWcut;1J(RcufMjF3LjJWoW1(WlYeMW8nmUn1oUZ<o2e7Y V J(Y+. 1VWvx.MvB fkQ+RjJYQcl;,wZoLC>.f1kx,wZ;,(2xJ(e1X2njoWlNMc)eV R.V1ZXQV>z6UQ3LcZC$CQ[2$VfMvBSfcd1$VnUQkY[YU)xL(NB;k1XoXVRW &xLpn<ZUYgMXmtMlZ.NvBt,CEzQkMUozF3mzAkZWAP,F2eV21).12xRwn<Ml27mD5Q$XY5NWA]flBiVzVnWXn(6CxY, JWZp>YMl>;$jYxWWVM6 &tLcZ;RVojZ?RWV FQV R.m(AXQWnNV3V12fBt;1J(Rcek; 5oLjJW$lJ3fvxKY1lp,z&xMUZjo$eUMVnlLFufRk5,sF1R;1&72j8+2CRY,[)eRcR<Ll>W$VZV,[5RVWQ12j&xo1FeZW2UMW5(LjNkN2uPWV8kolJf2fBkV2nwRkJ.olF)2V>RZ$Yxfk2eM JDLwY+L?Mdo$eUMVnlLFufRk5,s(VRWFY7VjF;JCRD6cY7V2FYVcn3VV&_VvBKRjJ)LwZtY n<Ml2U&DVeMjJ.f[EdQVoiV1Z1VvQc6CEk$v5NZln]Wv91RFn,QkEkMlw12j&gX n]N21;okJ(VpBtMfxjMVZN;1Zn$$&n;[xWMp>NMjwzJ(N). nw,DwkRcAEJ(u.Xf)[Vk5fo de$wRB.1&koV9tZcVVNv9n;z&[$ku.olF)2fRZ;  [RvBMRwFc,f>BRVFjsFlN&wd8$wR.$cAWJcuiVzV1VlZ;JDJU2jweYzFWVcnZZVYxWcVKYUQ1LvgxVpNw;UNZMVl)VjFWKXNeZ(u.W(51$XnKVfQ[WkJ;o1JfWpm1RDu],wYkMlJDV1u;Y[Y_Vk5fK?>(LFV.$k5VQVlXY3V12poKo1oe,VufMp>j$VofozJX2kYkMlw12lmx;pN(VpVLKFZ($cNtKXN]JcmtWFl<Jpo(JwnDQk&[W3>]m NC.  x,kZX,Fkn$l2gX1ojZ?RNMVnQJwZusCx(,lmtR(A1NjFtX2x]$lozolJW$Vo).1nUWkZ.;kwtWlZ(R(Zjs(lWmFZeLFY[W uV&?dk;poj.UuKJC5P;Uoc&FJfWpoW$lJw,wYeWFdz,zJF;1F<ZVuXRknQ$cu;,FJWfpoiJ?o VzF3M[RD6vlz;zwzJ(N). nw,DwkRcAEJ(u.Xf)[Vk5fo de$wRB.1&koV9tZcVVNv9n;z&[$ku.olF)2fRZ;  [RvBMRwFc,f>BRVFjsFlWVzVnL?nB$v5(,[xNVUu $XdcM[x,2cx;ZkVSJ(x..1YzVlYeMlknWlZkZDJ]RjuXRCYn$(E[M$J,sF>WY3>ZVvRpM[x,2cE7Wz2em[>WoVZWWV2kQz5c.1VBWFZ]o1Vf61YgfkY[sCx(,cNK;zJVNv91,D&[$keeKwFX,1oWoVYkJjEeJw)t$WZ;;ldgN2R;W JMJDJRNV&[&FAK;jVNWpZCRloEQv5;VzFW$fR(V n3fpoX,(1,2jJ)Y 1X2pm[V1J(JDJRNVJXMWnzRlZ1f[>WRk5j,vlz;vZpLl>Z;[Z3RvRKQ JCMlu);pNDQjuNMW5(VUx;QvEdMVZz6URlV Z;V1o(VkJWVc5ZVcxNZVYxWcVXRlZXm3ZFX[REVclW,FlVV[R..1Jc2lZNV3g7WpZ;Rk5]Qf5;VkZwZcN);VZEVcEeVjJ,f12gsvR]oUM7; dkLpn<ZUYgMXmtMlZ.NvBt,CEzQkMUozF3f[Q+o2 [K$VKY3VC$cxpZ1wkWllWJFZeLFe+;VZX&(RW,w)7V3m1,CxWMp>NVlnX2fR3VW13NV eJwZCLCgxVpM_Z(VXRlnXJC>;K$exZFAWY3>nfpm[M Edo2&7Y FF2WnZZVYxWcVKYUQ1LvgxVpNw;UNZMVl)VjFWKXNeZ(u.W(51$XnKVfQ[WkJ;o1JfWpm1RDu],wYkMlJDV1u;Y[Y_Vk5i&ClpVUE+Vzex,FBR;1&7VpnKRvQdWX>;o1JfWpoW$lJw,wYeV )nVlmgZFd[Ml27mD5Q$XY5NWAU2WoRVk1<Jpo(Jwx(,1meRj5WVcn(WFZY6lBKRjJ)LwZtY n<Ml2U&DVeMjJ.f[EdQVoiV1Z1VvQc6CEk$v5NZln]Wv91RFn,QkEkMlw12j&gX n]N21;okJ($(xiQjujQ2VR; )7.1u;RcZ<2$Fz,(uPJ(NF;3N<fjuX;kFf2cZF;U8[Vk5LQzk8V3Y+ZvEdMV9tJ(A.Npdc6CxWVv5z;zwdJCQ+. u3M2ZMRcAXLwZpsk1UoXVWMjVQV3ZfQ1ZX&(RW;kZ1m3BW,vRc6cZKo[BkLDNt;2nw;zNMQz5(2lm); 5Y,lnN&DVlJDJNZU8kZ$2co3V.2kReRvQkQ2u;V FF2Wn)$lJD;[keJwYtLcZ;6FwkWlkco3oVV Y[sCx(,loRJ?oV,Xm1XfxWVlm[WzVWm[>W$VowJjEeVlYtmUxkW1FYVjuWsknVJDJfKXNUsDMtWFd7V ZZZ2xwQf)eRFnFJ?Bt;VnUWkZXRlZEJ(u.RWZe$VVuo[9z$wZWmCR<$p9co3V3MlofRvQkQ2uKop>o$l>fozJX2kYkMlnc.UMgslFUQlJR&(5(LFV.Rk5VQVVc;jV3MlofRvQ[WcY7Y[BP2XZC$k1],FVKY )zJ(u.Xf)[VloLQzk8LFV.K$e[sFYkm(51NjwcN2nEWkeU;1JfWpoW$jYx,kZMRc8nJkNFsvR].(M7&?oVV NCQk5e6lZWm()7VjF;Vlo]Q2N.op>o$l>RYzueJvufRkZ<2j&xKDJE2XRWV FQMjJ.f1ZUWcni&DVw.UneRvxVsw5fVvZ)McNWoVZXsFBMo1w1Ncx(o1F]Jc27mFZFLF>t2lJY$kYco3V.2kReRvQ[2$VfMjF32XBkZ2nwVjxKmwJLLwNF;3N(McVuRln<$wZWZcAX.(Qkm(51NjFZV2xD6cZiZvlPVcxW.zYgJlV.YU)nmUdcZ[5Y.Weco YkLDNCQzuX&?dU;llV,2Z;X2x3$ckUYzFl2VoFZ2d_6lZM6 JXWkN;;c8gN2Q7;cx(JDJRNV&[&F8cozVw.UneRvxWVvkeKCBPWj&1RDu],wYkMlJDVlmgZw1XVclLo ZQMcx1f 5U2X>RMjJ Vlo1,wxE,vl.op>o$l>RYzueJvufRkZ<2j&xo[)[Vcluo dx$wRBZjuX&(meWFl<Jpo(JFoe6je7Vzwe2vRuVW8gRvB.Y 1t,UenZ(8gN2Q7;cx(JDJfQ 1e6lk[m(RV2p9[NVmkRjweRj5Ym ZW$2 koUmeW()n$wYcsDJ]sDeU&wnQLjFWV1ZW,FVcY 5nJjApsjJWoVJfVcRPMvQ+;W8gRlZMRpVC,f>Bo3NDQk5iMW5jJC>lZ1JX.(RWm(RVf Z;VVo]$l&tKwF32WxpV21VQWMeMU5DJkZtWfQk6juN; ZW$DAtQ[)[&(QeWzlVNjwcVfEkQ$uiozF3LwM1ZlJ3JcoX,D5.LkZkW1FWMcVX&?opVUE+$v5(Z(uR;cx.2V2)W[xV$fluozFwfpZCWjJcQkEkMlw12j&xKDJj;3RNsvYzMcY+Lkx(,loNV1Zn,Uu3;[Ek$loiJFnVLkRuVVJ3MjNWW Jn$WE+W$JEZFVfmFZVfkZ;ZVlPJlufV 5NmUN);loEW$Ffo[lk,[91RDu],wYkMlJD$WNB;v)d,DuNMXmnLDNiQ 1UsFBiJ?o $VV1RfxV$fk7VcRPMvQ+;VFVQflXVpopZv9xo[)[Vk5f,wnWL(Y+QpNE$jMtVUA;McZC$CQ[2$VfMjwdMpBWoVZYMjVKoj)zJ(u.Xf)[Vk5fo nW$XZC;VZW,l>Wm(5n$WM)W[Q_,lniRc5VMcnWf 1PJjN.mwJc2jJkscA,Qv)UVVYt2VVkNV&[MXmtMlZ.2cxKVvxc6kJzmw)zLlg+WjJcQkEkMlw12j&xo[)[VlmUMW5tJwRNW 5PWk2[;1ZNm3BW, xE,kZ.V$wz2WNtWFZWWclMo 5CmUxtWCZw,WVuozFtVUxpW[)dQ2VRmwJc$XdcKfxV$v)UMVnwLkZW$Vkx,DxuVVnn$WY12w5cQpVRV2wnJ(ufZjZ<2lJ;o1Z.2kReRj&xoUoc&DF3LjJW$jYxZ(e[;k)7LwZtWfR]RcZNVkZtJ?BZMVkgZF87M &7V3mgM 5UZUoL&(RP,1uCLjZVVv5RVWQ12j&xo[)[Vk5f,wnWL(Y+QpNE$jMtW(5;McZC$CQ[2$VfMjF3LjJWV uwRl9tWzk1m Ze2vZ3o25fR(x(JDJRNVJWWVAXYUxNVl>W2wx32jweRpokJ?Z).1Z]RcEkRw)tLwNF;UAY2pVX&wZlLFufKVZX&(QeskFnfj8+VlocQclN;3>QV1>f.UAeJjFc,FYxm3Z)oUAXswuNMU1pJ?Y+M[R<$l tMlZ.2kReRvQ[WcZWZpge2fR3o?N]McmeMk n$pn1XVdkZ3RN&CY1V[R(Mfx(6l>fVUx1VlZ;M2xeMjFz;3>WVcn3V$Yx,kZXokJn$fRZX1oj,cZNVkZtJ?BZMVkgZF87M Jnfvg[6CxP.DVuKCB<McZCWjJcQkEkMlw12j&gX[Z3N2Q7;cx(WpY+mCR<$l tMlZ.2poKLFoe6v5iV FZVUN1oVJ3fjFMo1&xLwZkW[5YWWVWM2n(LDw+LlJXQWNK;1Y7V ZZZ2xwQf)tZln]JCRuV2edQVYeMk1pWlZkX1Z]RjuLozFRJ?ZfVU8_$kRcY1J3MlofRvQ[2$VfMjF32WxlZ2 x,pQkZco)WcY1VlZjsFJR&()xVUnBQ 1cKXnX;1Z1mUuWM21eVvkcKwF]LjAZN[5cQkEkMlw12j&xo[)[Vk5fR(x(JCRBfzuXQWd7&DJlVv9[M1oe,1mtZlnVm[>W. uwozgkQ1wxm3Y1VlFYZFVR&(5<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jZ,W$xW,(AEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3VUnN;UAj,$FKQ1J;V[Bf2ln3Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e[slnlVcNfozJX2kYkMlw12j&xo[)[Vk5fR(x(LFo)QjuXQWdeKFJ3MlofRvQ[2$VfMjF3LjJW$lJw,wYeWFdz,zJF;1F<$XRWVlnW$wNfQ  z$poiVURlW$M+2FoU2$ViMp>YWv91RDu],wYkMlw12j&xo[)[Vk5fo de$wR..[x<&(RNVzJ VlZ;Z$&[$WMtRc)z$XBZN[5cQkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,(Vl$$FtoCRcZ3>;ZjVWVcN)2lwg,jFXoj5(,UZFZCxYVk5W;kn($wZiZld[sFgkYUxNfpo;V[RcZ3g7W3>w$Vo)Wlo,QvlWolJD,1ZkZFJYVpnLRwdxJFZZW1JW;3>iW(AnWVV1Vf5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNVJXMWnRVj&3fpoKM2x32jweRcR,Ll>ZZ2ddMvlMRpVLWpof2ln3Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYeV 5CVvRl;1FEMcVf61ZlVUdcNWA]Wk2kJ(1l$f9gK2nj$p9k; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVzFo$lZZN[5cQkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12lZKo[xD6kufK?>jJDJf. 1,2lV;sjJ<fkZeLFJ(RcufMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e[slnlVcNfozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ(oMo1JD,UZ)oUAXsDuN;cxV$pBC$k5,RXdkJD5NVpnpKVoUZzw7Vc)zVcuW$ku3M$F.; 1p,z&1YUZj2pm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1o,RVAXMjJlVv9[M1oe,1mtZln]LkQ+. uwVc5Xm(AX2cZ;;ldgN2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNVJXMV1;MjJlVv9[M1oe,1mtZln]$cY5Z2u3VjF.;kw7,2R;R21EWk)UMW5tMjJ.f dd.(RzKFY7Vle5KfEk$v5fZlno2WN);VZEVcEeZjk1,3Z)W$&k6juWMXmn$(NNM$uVQ2VR;kZ1mUuWVfRcZ[l.V$><Wl>W;VYxfkVX,FYnmUx(R(Z]RjuLRkneLDw+.UADWl1RYUu $XdcM[R(,$F;ZjVW$V>tWk gN2YesvY1,3ZFX[RU2cl;oln(LDw+. 1cRV8k;cuj.zFkZ xD6kZfVc5]JkQ+o2 gN2ZKY  <V1VBXVFEMcVf61ZlVUdcNWAe,lZzQ Vl.UnWVkx(,UZfMvBkLFVWWFZc;zEeV21).12xRCZw6pVWVlnW,$NC$c8kJpd[YzJl2pmcsCEk$fuNMp>ZVpBtsjZPfl2tskFLMlVB;jZeoVlzmFZ<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VZVlg+Vv5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2kNXMWoPMcM[N[5cQkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcxNZ2 x,pQtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYg,c)eV2)82cZ)WF&k,zuWMVk1fpB;K$u,RX>;WFk3LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ1WfB(Vv5,2kNiZp>3,1o). 1],FV.oj5c2pZ;XVFjs(lWmFZeL(Y5NWAUsF1iVUul$$FtRloE,cuzQ1lk$cZ<Y1lV,[5RVWQ12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYeV 5CVvRl;1FEMcVf61ZlVUdcNWAUsFg[Y1ZNVv91,vRD2k5i;c21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ(uX;1&n.UegZCRE,clKRFY8$wM5NWA<NVV.V 5L2Vu;RkxeMp>NV F]McuW2lF,Wl2tscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[VpVZ&wZWLlufQUAcs?oiV3g7$WneV25U6cZfoln]Wv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12lmx;l&k,  U&DVeLvB.2k5PWk2[;1Z.2cd+RloEQv)7YzFWVcn(oXNE6vxXRlZ($vBFX[RjMjmtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?27V3m1,CxWMp>NMvBSLvRiWk gK$VKmDl,$pn;R$J<McM7; dx$?ofMfx(ZFetWFl,VlZ3KVoWZX>iVcRS2Wn3V2u(fcEkZco,fzFtM 1EVclXRc)xLjNtQ1>W,cNNW(5P2jAWX2Ed$vlz;3>j2vRi.1o(,jwkRcAXVlmgZCxVVpVXW1n(VUnBQ1JwWl1iMlY7$f9nNWZ]$VuLV2F]VcnZW1ZWo[lXZkJCLC>BR?Md,cluRllSJ(u.;Vn32lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVzF]MpBf;VZV&ClX;kFc, RlNfZ3o25fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ1W$FK&CEx6je7V$F32WMnoFZYZUmeZjk1,3Z;;lnVoXVN&CZ)LFe+,w5VMXmtVUV mUd[Z[E[2$V.J?VoWvRpow gfvxXRlZc,[>BWVojoXVLK(8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2uKop>o$l>fozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fo[Z,L(Y+Zv5cWWRi&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYx,kZMRc8nJkNFsvR].(M7&?oVV NCQk5e6lZNV3V12ce1VloUQkJiRFn]f1>;Lke_,[5RVWQ12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJ;ZvxV.F8kJD5YJpoKXVYxVlmeW VSV1oeWVo(flB.;1dxNjFZZ(AXoX2U&Ck)VUE+.UAUWcnX;k1<NlVBoUZ<2kNi&(5]V1o1fzuPVpoc;1JD$WY12w5cQpVRscmzLlVt,C5DKXnR;lnnWXd+,vx,2cxLV$>SLlo<oFZX2$N.;1&x2lZeXVF]o3Rz;jJpLDJNK25PoV1;J(o $f9cVfx,2cxLV$>S2XB;$jZPJjN.mwJc2jJ)2(AW&?Rz;z&zLF>iQvEdMVYkm()7V Z;2w5<2kNLRwnV$j&1$kuwVl9eZj51$jFeVk5cQlnuRCYz$pBCZl&[sFBiVvB mUe[M[E[2kNXRFlPLFV;;XN<fv9eJw5D,2M1VvRE2cli&wZW$wZ1Qk1cNVB.ZkJ12XnpM[5V,cEtQ[lPLjJW2lJ3Jp>Mm(QxJvgxRC5w,$m7Yz&n$(n.Q 5jQWdtK(xnfvg[6CxP.D27ZjVWWkRuVV&_VkYkMlJl$(xKo1FE2pVN&wnF$(xWLc8dQ$NRVjJlV[B(RfEg2vkcozwzLjJWf 1WflZMRpVC,f>Bo3NDQkuz;cEg$WN1Zk1Pfl1R; 5YfpmcswxEZDwcKDFwLkRuNzujMvlM;k5D$cM);1ncoWkUscx(McnB;VkxRlZK;1Znfvg[6CxP.D27ZjVWWkRuVV&_VkZKRlZXmUx<svRjs(lXo[9nJF>iZk x,jEkWFdtfzAiLlFVZDVfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkW(1,f1VB;pM_,cZNVknt$(nNW )xoUQkopg7Vcn(,CEzWkJKKCBPVp9[VWA]ZzN.;1J($jFuZ[xPfllXRknQ$cu;MWAU2lmeKw1,$WuW;vQ_,cVZMW5V$jJfLlJ(JjNfRkZ<2j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1YkJcmesknnWXd+,vx,2cxLV$>SLlo<oFZX2$N.;1&x2lZ(M1F]JcVzmDJ)$(n.6( dQWdtK(xnfvg[6CxP.D27ZjVWWkRuVV&_VkZc;k)zJjANZzZj2pm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e7W3>FVcxW.zZP,wZX,D)tWlmxVk kRpVWJD5(LlufMVnX.F8k;cuj,XokY EdZDFio[BSJ?9[VVkxRkZWocmn$l2);U8kVkuNMW5tJwRNW 5PWk2[;1ZNm3BW, xE,kZ.V$FwLDM+Y ed,12tskFLfpZ)X25Y2k)U&D2x$cN.2lJWWWQtR(Anfj8[MWZ]$Vu.slnFMcuWf  gWWMt&FJDWV2xVvRE,juXRlnQ$cufQ1oVWWRLZcVl.UuK2wxD2$w7&DwdMcN<ow1PJjNuVVnnLCgxVvRE,juXRlnQ$cu.;XMdWWQU,?VZVlZK&CEx6je7VfBkWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(LFolKUAwWcnLMjVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jZPRlBMQz5Xm3BNZzZj2pm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e7W3>FVcxW.zZP,wYtW1&xWlm)X[R];UNuoURj$C>kMWA3&F8kmDJVW$F(RlZUZ[l.V$><,[RWf  x,c)kRw1,$pn;R$J<Vk1zmFZi$?BtRk5VM2QeMz5jf[>iVf5PQ2uKop>o$l>f$jYgN$F.Y 5f2lZZZC5w,UlK6z&xZcnNW 5PWk2[;1ZL$fBZY[)g2kNZV$FWJ?Bt.1o(WlB.;1JDV1VZZwucZW27; nQ$wNRM$egMfg[YUu $XdcMU1VWckeKDFWJ?Bt.1o(WlB.; 5nm[>ZZDZeoVlWVkdgLDw+.zuV&(R;&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF32Wx1Y uD;zxMK(Q12lZ.2vZ3o25fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1FXWWR;&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF32Wx1WVZWfv9eMWA1LkZkXzJE2$mtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VZVlZ;2wxwQf5iV FYWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLMluFslojK$mtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBfzJPflY[JD5;VloiLlFVZDVfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxXsw&7V F]LC>fozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ(uX;1&n.UegZCRE,clKRFY8$wM5NWA<NVV.V 5L2Vu;RkxeMp>NV F]McuW2lF,Wl2kJDg1$jF<svR];UNZM1ZQ$?ofMfxDWcn;&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLwxw$jee;[Bk$Vm[oFZWWc2[Mk5L,1ZkZFJYVlnWJD)xJFZ1f1n32lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e7V F].[9[ZVYgMjNX,(AXLcZ;XXMdoWZ;;U5<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxYQjufZp>FMcn($jZP;zNXJw)tLcZ;R21],VVuRkn(fcNtQ[xUNVZzQ J1JkReVfxXZfuiRFn]fzJWoVZc.$xX;1JD$WNB;v)d,(lKKD&8L?d)N$ucNVZ;R(1V2jAWRlnU6pBi;[BkVcn(WFZY6l9[Mk5L.1oB;lZE2WVf6zJl$?BCQzuV&F8kWFk3LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYg,cxM,?2nm3ZFZDZ<s?VWMj&zVUE+fzJ,s?o;V1Z1Vlg+;1J(RcufMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYeV 5Xm3ZFX[REVclKo n($(xWLpNeRkRc;p>1Vj&[M1ojWWNfVzw8NpBRVVl,,wYeVXgtNjFZX1o<McVN&CltLFotM[Y_$WmUY1Fl$$FtZ2xeofl;VzFW2VZ1Y uD;zxMK(5D2VoZZFdgMcVW&D&zVUxiV[5cWc2kYUVVf3mxM2x(,UZfVz><m[>lZVJ3fcV.Y 5c2cu)WVZeMcVWVVZ(LlVNWUAX&?n;scA;VvRW,CxWZWo;ZjVWVcE[ZVn]Rc2eM JD,2NFX[RYW$mtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxX$cZiKwFYLCQ+.zYxfv9tscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?27f Q[sCxV$cZfMvBk.3nuZ$Yxfl9[Mk1j,UegZFZEZ(2U&D2xLDw+Ljeko2Q[m(51NjFZZ[)z,jFfMjwz,1>kZV&_Vc2eV3>C.1u)RVZeVjeU&wn<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZpZZZ$u]VvBfRkZ<2j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[Mfg[;1Y7,3nemFoWoUoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo1FeVpVLRwZeLFe+QpNefvxc;ll<$$J3V2nwRkJiVcRS2XZf;VlV.FVMK(Qx, N;X$J]NXm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[WcYeV$>SJCQ+WFmgozgeVlZ($jFkW1Fj,l>WVlnn$wRBWjuW6lk[m(RV2p9[X1ZU6jw7VfBSJ(n).1o(,lVKY )7$VuRX[Eg2kufo dgLCR.QU1DNVYkmFJn,[B(Vkx(o2JiKCBP2X95oFY[Nf9eWUoj2vR1RfR<Mjm7mFZ(VUx1QjYdMVZfJ(87$Wu3.CxWVkZ.MW5Yfce[N  gNWxM,FZX$cNB;v)d;zoN&DVe$(xWVUA<&(RiW(Rl2jAWZ2n(Vlmco3>w2fR)oVY[MjNX,(1j2vR1R$&k6clLRCYzLF>iQvEdQ2VRmDk3m39[swx]$kNi;[BkJCRi;2d_Vv9eVlZ($pn1XVdkZ3RN&CZVV1>tM21cNVZ.W(Rl2jAW, xE,kZ.VfBkfcuW.  xo[keMUAC2cY1VvQk,1d7;[Z)$?BkMfYdM2QtR( 3.UM[K2x]$kN.Yz><WcZ1;$Ygfl2kJD>,$pn;R$J<Vk1zmFZi$?BtRk5VM$NRV3>1Vj&12Foe6loz;ln32XZpWUA]Vv)kZcmxmUMgZCEk,1nWJDJpV1o.MXNUs?oiV3>;Wf9gM[x,2jFiKDFW2vRuNzujMvlM;k5D,Uxksj&k6clLoUR)$?BkMfYdM2QtR( 3.UM[K2x]$kNi;pVFMvQ+;2uwJjMeZj5LWFmgslFe&?RN&wnFJwZWMXNUs?oiV3>.2cMx2[xPRkuN&CBkL?Bto2ed2$MeZj51.[RlsvRjMpRWVllVLFVNK$eko22k;z&3.3BWRloeo2&UKDFW2vRi. n3Jj2kZj)xm3Z)oUAXRWuNMW5tJwZWo?Nj&(R;R(A1f[gx,v5P$v5;ZjVW$We[ow1]VjMkZcmxmUMgZCEk,1nWJDJpfkR..ze[sFZiW(Rl2jAWZfRY,$VfJ(VPJ(M[oFZWWV2eV2 n.[RlsvRjMpRWJwn($(dcMW8g&(R.W(51f[ggM1oWMjwcQ1FPVUNe$VY[&DMeW1&x,[gxVl&k,$m7Yz&n$(nNNVJWRpoRYUR $XdcM E_Qv5;ZjVWWkRuVV&_VkZKRw)7.zJ)VvQk,UlK61YgLFZWRk5PoV1;J(o $XneRkx]JjFi&CBk$l>to2ed&DNXVj&xJkNRsloj,w1WVz>p$cnB2lJWRpoRmwJn2jApZ nw$je7Mp>WLFe5V$YxRkZM;vYx,[9gZw5Y,pVLKC9zV1Y[MfZD2XnXYUxN$XdcM 5EQcZfMp>Q,1Ygo?N<MjMeMlJDLj&gX 1],VVuRkn(JDAtMV>cNVBfJ(A1,[B(Vkx(o2JNZjVQ$cZCoVFPZzMtVW5eLkMnsv)[MpRN;lYzJ(Y+MXNUs?oiV V<$$Ft,vR(VpQcRFlSMcNFow1P,wY[MlJDWFoBo3NDQjuK61Z(fkR..ze[sFYeojlVNjFKZ2x]$$VfZvl,$l>i$jZPJjN.mwJc2jJ)2(AW&?Rz;z&zLF>iQlZcsCxRJ?o mUd[Z[E[$fl.spVoWvRpow1P,wY[Mlw1,2ZZX1oj,w1NsvYz$pBCZl&[sFBiVvB mUe[M[E[$pVfZvl,$l>i$kuwVl9eZj51$jFeVk5c.WuNMW5tJwZW;fZwWV8[MlZf2kReRVZ]Q$e7Mp>WLFe5V$YxRk2kMk <Wcu)X2neVk5i&()7JF>i;$YdMVZfJ(87$Wu(Vkx(o2&UKDFW2vRi. n(RkYkK?>L,12)swn<Vl&eK?V(LjNCLl&koV1iMlY7V[B3.CxWVkZ.MWR,2fR)oVY[MjNX,(ALWFoBo3NDQjuK61Z(fkZWV1ZX&(QeskV $XdcM[xc6keUKDFW2vRi. 1<Rc2e&w5(.[RlsvRjMpRWJwn($(xi.1JDWl [;jV3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkW(1,f1VB;pM_,cZNVknt$(nNW )gsFZiW(Rl2jAWZ$Jc6v5MRc5X$VoW;WA<oUeeJw5X,[R;Vf5w,VVfoz&zVluC;21e6lk[m(RV2cNW,v5P$v5;ZjVWVpBZ;1Zjs(nN;kn(WfB)2CEd$jui;lZ3J(ufZk)g2lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYeVXgtNjFZX1oj,w1WWFZQ$?ofMfx(RjNR;vZlm39[swxeo2&UKDFW2vRi.1mdo22eV2 n.[RlsvRjMpRWJwnFL(ZfZk5VWWR;&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gXUZjZWVuRlnWVUd)NVJW,lkkY1Z1VvR3sCxWMvlfJ(V<,1oW;$YgK$VKmwJLfpZ)X25Y2k)U&D2x$cN.2lJWWWQtR(Anfv>W,v5P$v5;ZjVWVcnWf  x,c)kRlYxm3Z)oUAXswuN&FljLvB.f1ddWXdkYzJ VvRKRvxXZfuiRFn]fzJWoVZc.$xX;1JD$XZ)2(8ko3RX&?m)LFZWRk)x,lk7Mzk3$f91,wxeMluuKCB,LjA;$Vn<ZFVWocmn$l2);1nX;zoN&DVe$(xWV )[,lZW,FZ1f[g).wx]$Vu.V$FwLDNp;1o,WjFKY3VC$XZ)2(8ko3RX&?m)LFZWRk)x,lk7M &7V Z(,CR(VjFzop>3,1o)f  gWWMtskFLMjFkZw)kRclZM2n(Lpn<ZUYgMXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYeVU2<, R;;ke[N2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2kNRVzFWm[>)o2 zMcMtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxX$cZiKwFZVUN1oVJ3fpRM,FYnJvggZ[5YWp27sj2g$cNN,lJXMVYcQ3272pmcW E_,jFNZj2e2fR)oVY[MjNX,D)8,f>B;v)d;zoN&DVe$(E[WU d&FeUY1FjWXd1$fxWVkZ.MWR<2Wx1Y uD;zxMK(5Dm3ZF; 5Xo25f,wnt$(nNW )gsFZiW(Rl2jAWZW1VWckUKDFW2vRi.1njQflKRcVj,UZ;6FwkJcVzmDJ)$(x1QjYdMVZfJ(87V[>1RVoe6jufVc5WWvRi;2d_VkZc;k)d$pZ;VfY_WWuNVknt$(nNW )gsFZiW(Rl2jAWZW1VWckeKwFw2lo<N  gNWxM,DJ,,fggWzZj2p2eo Y8$DACV1ZWZFARY1J3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLfpZ)X25Y2k5fo nC2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVk1,NcNfozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fo deV ZWZc8dQVgeJD)7NjFK&C5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLMjFtWfRjVpVWJ?o)Lpn<ZUYgMXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLFo(VkJWJ?VYWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLMluFslojK$mtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNVJXMWnRVj&3fpoKM2x32jweRcR,Ll>ZZVYxfcEkRc8t.zJ)V 1EW$mtZkJMJDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.NvBtVvxcZzwcKD><2We[oFY[NV9[Mk5LLCgx2FdkZUVKQUxVJCRBf nUsF1.WFJ.NjFk;zJ]RcZWV[Bk2V>tsjZ,Wvkk;kwxfcnlZFFWVjuKKFZe$wRBLjuXM$EUmFFVWVueRjJPJvu;ozF32Wn(WFYkVl9[Mk5LLC>BR?Md,cluRwnVJ(Y+6w5,RV8[m(5f2Vu;6CxWVvkcRc5ZMvQ+;WAUWkZMRcA($jFtWFZ];UNim(o)LDJRNVnW,vxNWFJn2j8+&wxwQ25i;[BkVcn(WFZY6l9[Mk5L.3Y12?M_QcluR(ExLDFiZcADNWVW,?ol,2QnK[Rc6k5.sllkLDFWoVFPRcEeJwYt$WY1VfY_Z1uLRDJtfcN.mCR<$l tMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.NvBtJwxw$jee;c21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYg,vRN,FZfLkZeVldgN2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vp2eo ZtLFV.ZVn32lJ;ozVwWluC$FJ(RcufMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ1.3d1&w5j$W5fV FlJ(nBV uwRl9tW JDLj&g;zJ],UNLK(8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)UW1k<JC>ZZ1Jc2l1iVzV.NpdcM[RDZ1ufMp>j$VofozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF32Wx1;2u3VkZMRcA($jFtWFZ];UNuR(ezLlufQ1JcNVY7M1Znfv>W,FoU2kNNZj2e2l>WoV&_VpQkQ1&nVlZt2w)koUM7;cenV3Y+KXNeRkRc;po VzM+,CxV$loNZln]Wv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJ3fvxMRwF;2vRZZDJjVp2cR(xV$C>tKXNe,lkk;1Znfj8[sCxV$cZfZlno2X9[ZV&_VcVX;vY1,3Y1Vk kRclZVX>QfcNNK1o,NV9tZcVVNv9n;z&[$WM7okVSVUN);VnUWkZM6U)x$WY1Lw kRjuLKwFF$wRBLv5cWkVN;cAN2fBt; n3$juZ&(RSZcxNoFYkNfxXRlYnVvRlNfZ3o25fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(5eLFVkNf5(Z(Rz6U5f2fBt&w5]Qf)eKCBP2Wn3ow xWlZX;jg1,UnlX n], 5fQUenLCR(Lv5cWl2km(5Pf RW6w5].Fui;[BkLkRi;2ddVjweMWAc,2ZtVpM_,lJR&(R)$(x1RcA]ZV8eMWEt,UnWYUZ<2kNiWzVjMvRWofxwZzMtskFLMluFX1oj2pm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo1FeoVlNM2neLpn<ZUYg2lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1o,WcMc61Z.2$F3M[R32kNiQ[lP2XBt. nw,DwkRcAEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFL.1oB;jegMcVW&D&zVUxiV[5cWkVN;cAN2Xn(MVo]Q2NNV[BP2Wn3Y1lV,[5RVWQ12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlJDV1uFslojN25f6z)8$wRBLv5cWkVN;cANf N<M[EkQf5;Zlno2X9[ZV&_VcVX;vY1,UM);1nXVk1WWUezLCRB$l&kflBiVUx1mUuKVvE[2$V.W3>ZVcE[N1o3MV2kJww7.1Z(R(ZjVclZMVl)fcN.mCR<$l tMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.NvBt,vxV$jxfZp>Y2vRi.1YxW$VKmDl,$vBFZ?M_,k1K6z5QVUxuM$uV&(RW,D&3V3mxVf5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFL$WY1L?MdVpVz; dx$?ofMfx(ZFetWFnnfv>W,wxwQ25fVz><Wlm[Z$YgM$wkQz5fLkNFsvQk6pVWJD5(LFuf,FncRV8kWFY7V QcKfxV$$Fzop>Q2Wn3oFmz6cEeVcVpfzFkZCE_ZFVfo niVUNZZ1ncNVZW,DJlWcn(2( g2jw7op>]mzAt$kuwZzMeW1Je.1e1L?MdVpVX&(5<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VW13&DNMRlZEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2uNJFlkWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLCx,2$F;Q1J]Mcx1W21PJjEtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VVlV,zxMm(QxJvgxo[)kMjm7Yz&n$(n.Q1mxZ3nNoc23LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf  kWcdU;3>1Vj&[M1oe6ke[V$><$lofozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxY.VuLsp2zJkRi;2d_Vv9eVlZ($pn1XVdkZ3RN&wdeV RNW uPZ$2co3V.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(R)$cN.mFddQXozQ J1L?o3sw5j$p9k; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VnfkRW;zJ<2jFKKD><WvQ+$cAPVlZMo1&xVlmxZVwko1VZVW8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYg,vQeW1&nWpof2ln3Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.NvBtJCx,2$FzojVW2VofozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf  kflY[Y3VnVlViLlFVZDVfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(R)$pY+mCR<$l tMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo1FeoWlKRFZ<fv>.ZlmxZ3nNoc23LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf  kWcn;VWV mUd[Z[E[2$V.J?VoWvRpow gfvxXRw1,f3nlNfZ3o25fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ?>.Y  <JCgxVl&k,zuXoU)kLFuRMVn32lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[VpVuRCY8LjNuZ 5V.(uiWFJ1Vj&[M[5V,cEtQ[lP2Wx1W21PJjEtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VVlV,Uee&F&nJvgxZVwko1VZVW8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlJDV12); 5X2cZf6zJ<LFuf,C53M$N.VjJl2jAWVvxXswJNJFn]Wv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[&FAc,w5nfj8+;1J(RcufMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gXUZe$clW;z28VUnBV1n32lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ?gkQz5c.1ZiVldgN2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2kNXVVlkfUZlZVn,QkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[Mfg[;1Y7,3nemFoWoUoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)UMW5($wZiKfZDRXdk;j>j.[B3VVoDQkJ.,D5W$Vo1oVJ<NVZXokJC, R;;kuYWv5L6U8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF32WnKWVo(flB.;1dxLlZ<s(AXsFlWMz5WJwR3sCYdMVBzQ3>c$VYc.Fo]Q2Nz;pVWVcxWWcA<,cdeW &n$$F(LD&[McVuozV(V3BtM$uUsw2[;lnnWXd+,kE_Qv5fVc5Q,1okZW1(fl2kZj)xm3Z)oUAXRWuNMW5tJwZWMXNUs?oiV3>;.UuK,[Ek$kNYZvlP2XBC$VZYVlBMo1&xLwNfVcAYZ(Vf61ZlV1otQzYdMVZfJ(87$Wu(ZfEg$kY7J(VPJ(M[oFZWWl2kZj5 JkRZXzJjRXRN&CZVVUE+.1JW,lZ;J(AnfjAWRloX,kM7ovlP$WnuZW13NWxM,FZ<$pn;oU8[McuWMv9zLFufMW8dMVZfJ( 3.UM[K2x]$kNi;[BkLFe5V$YxJl2eMl&x.3Y1Vkn<VclKKD&8L?d)N$ucNVZ;R(1V2jAWRknw$Vu.slnFMcuWWju<Jp>Mm(QxJvgxRC5w,$m7Yz&n$(n.Q 5e,lkkYU51VlZZsCxY,kZfVknlfpBR; n3fv9eJw5D,2M1VvRE2clLoUQ)LFZWRk)x,l>cYUR $XdcM E_Qv5;ZjVWWkRuVV&_VkZXV 5nJkRZXzJEWclKKD&8L?d)N$ucNVZ;R(1V2jAWRloX$pQcRFlSMcNFow gfl2tM &t2vR1XW8[VjuX&?m)LFZWRk)xZ(uR,(oV$VVBY[Ez,kNYV[BP2WEgow gfk2kRlYxm3Z)oUAXRWuNMW5tJwZWo?Nj&(R;R(A1f[gx,v5P$v5;ZjVW$WuW2lJ3JjgeVlZ($jFkW1FWMcVX&wZiLCR.Q1>cKXnRmwJNVl>W2wx32jweozF3LwM1ZlJ3fv9eJw5D,2M1VvRE2cli&wZW$wZ1QjYdMVZfJ(87fpmcNfRc6jFzop>3,1oF;  x,c)kRlYxm3Z)oUAXsw5fKwV McufQU8d&?nRmDl Vj&1&CEz, JWZpge2Vokow1PJjNM6 &tWcY1Vlnw,VVf61Z(JF>uNVJW,FBiJ?o VvRW2wx32jFYZjVQ2vRioW8gRlZMRpVC.3Ynsk1],WVuozVe$(xW; 5PWpoiMlZ.2v>FoDJ<2kNiKCBP2X95oFY[Nf9eMUACVcZ)LFFYQclf6UopJF>uNVJWZ?d[JD5n,[B(Vkx(o2JuKwF3m NC$l&dRXQ[;1JD,[ggslFE.XRWMj2gLDNiQlZcsCxRJ?o mUd[Z[E[$fl.spVoWvRpow1P,wY[MlJD$WY12w5cQpVRscmzLlVt,C5DKXnR;lnnWXd+,vx,2cxLV$>SLlo<oFZX2$N.;1&x2j&xo[xDNWZfo[Y)LFZWRk)xZFuRVjJlV[B(,[Eg2vkcRcR<,zJW$cAP,wYtM JfLvg)Zw1],3Vi&wZW$wZ1Ql>XQXozQ &7fjAWRvQ[2cVM,wn32Wn3o?N]McmeMk n$pn1XVdkZ3RN&CZVLFVNK$uX.(u;ZpVnNpne,kxeVcu.sln3,zJW$cAP,wZc;kZcVcZ)LFwko3Rz;jJpLDJNK25PoV1;J(o $XneRfQ[2cVM,wn32XBC;V&_ZUoKRw)7.zJ)Vvx,.V2UM2Z(MjJRNW1(WVAXYUxNVlm)Z 5]QVJuozF3LwM1ZlJ3fv9eJw5D,2M1VvRE2cli&wZW$wZ1QjYdMVZfJ(87fpmcNfQ[$clNY F]Lv><N  gNWxM,DJ,,XmxRw5XWcYUV2FjJF>if1o<&(Qem(51f[>RM[xc6p27J(VPJ(M[oFZWWV2tsk)tWcY1VlZEW$oN&DVe$(xWV 5e,lk[V1ZNVl>W2wx32jweozF3LC>.2lo,WWoXVpopZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.,3dc6CxV$vlz,CZ)McN<ow1PJjM[Zj)t$wZtV 1XVcli;3o<LCR.VU8kWl2tR(1V2pm[M1Z,QclN,D5ZMpBkVVJEVlVKRlnlWXdcW1JX$k1zY3>]V3BZMVJ3NXm[;cA3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12lZZX1Fjo2xXMz&<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJWY ed,[5RVWQ12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?Vnfj8+;1J(RcufMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf 1csFYU,?Vjf N<6wEd,kNzokV<$lo1$lJefkZXoj)dfcnlXUZe$clW&wZ<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFL$WZ)VjZeoWNLQUe8$C>tQ3NURWu.V3V.2cxK,kx]$Vu.M 5jL?n3o?N]McmeMk5nm Z<WzZj2k5LRc5QV[R.LvEdQVkkJD5.NvBkY EdZDFio[BSJ?9[VVkxRkZWocmn$l2);U8kVkuWVlnQV[R.LvEdQVkkJD5L$fBZK1nUZ[uXMWoPVcN<N[5cQkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLCEx, J;KDw8NpBRVVl,,wYeVjJpfzFto1F]JcVzmDJ)$(n.6(1wZXdkYzJ VvRKRfxW,[>K;pVw$VZ1Y uD;zxMK(5Dm3ZF; 5Xo25f,wnt$(nNW )z$cMeVX>n,XoKRf)z,jFNZvlPLl>CoVYgWWMt&w1)V1VZZwucZW27; nQ$wNRM$egMfg[YUu $XdcMU1VWckeKwFw2lo<N  gNWxM,DJ,,fgxWFJUW$mU&()kLDFiQln32lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gXUZ]oUVWJD2eWpZp,ku,sF1Rm(RlfkRW6CQ[WcY7ZvlP$WnislnjQV1M;k1,$lu)RfRjMpRWV1wz$cufMV&[Z?nf;jVjf Q1LFow$lm7J(21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VnVvB(;[xXZfuiRFn]fzJWoVZc.$xX;1JD$XZ)2(8ko3RNVXVFLDJfM$uUNfEeMz5;$Wd1;[xXswJNZp>WWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ1,2Z;,v5P.(N.&DF3f[Q+o2 [K$VKY )nVlZtWVZ]WW27;lYgWcnB.ze[&FuR,?Vjf N<6wEd,kNzokV<$lo1$lJefc5M;k1,$jN.Y[ExMcVX&wYgLCR.QU1DNVYkmFJn2VVBKVnUZ[ucY F]2VZ;2jYgZ(NMK(Qx,3mgX[REMlVZM2Z(VpZpK25V.(uiJFZL$$Ft,vR(VjFzop>3,1o)f  gWWMt&w1j2cZ)WF&k,zuWMVk1fpB;K21XMXmtV1Y7V3n(,CxV$pVLV2Fj$Vg5V$YgNV9eMk5LWkZ(2w5YZ(VWM1YeVzAtMVddMWVRJ?olVloiLlFVZDVfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo1FeoVlNsvYnLpn<ZUYgMXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ(NMK(Qx,3mgX[Z3VcNLK(8t2VVkNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVzFl2fR($2u(fc5WMVZEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1mxZ3nN;cANfz8+2C5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcxNZ2 x,pQtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gXUZe$WVNMW5 Lpn<ZUYgMXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[&FAcYUxnWVV1Rk5U6cZ;V[BpLl>;;2ddVcxMK()x2lmxVlJYWk5LRwZe$(xWV[x(RkRc;po V[BWM2Ed,jFfVzFQ2XZRoFY[RlBKYU5DVcZFZ[5YWpVNsj2gVUufK21cWcn;&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e7V F].[9[ZVYgMjNX,(AXLcZ;R21], 1L6z5QJwNfKXNe,l>.V3V1f Z;Vv)x6k5i;c21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gXUZ]o3RXMz5eLF>tQUAcs?oiV3g7$WneVfx,2cx;ZkVSJDJW;2ddVcxMRwF.,zJFZD&kZUVN&C9nLFY[KVJX.(u;VzJlNv9xMVoeZ1etKwF]$l>kZXN<Jp>M,?2nWlmxLCZDo$uLK?>Q$cufQzucKXnN;cAL2v>W,wxwQ25fJ?V]$XBWo21PNfBX;1&n$WY1L?MdVpVX&(5<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VW13&DNMRlZEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2uNJFlkWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLCx,2$F;Q1J]Mcx1W21PJjEtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VVlV,zxMm(QxJvgxo[)kMjm7Yz&n$(n.Q1mxZ3nNoc23LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf  kWcdU;3>1Vj&[M1oe6ke[V$><$lofozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxY.VuLsp2zJkRi;2d_Vv9eVlZ($pn1XVdkZ3RN&wdeV RNW uPZ$2co3V.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(R)$cN.mFddQXozQ J1L?o3sw5j$p9k; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBfzJV.(uzKFJ3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLMl2); 5YZ?RWMkZ<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3W1ZWfjEeMWAEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2uNJFlkWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLCx,2$F;Q1J]Mcx1W21PJjEtscupZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn3VVlV,zxMm(QxJvgxo[)kMjm7Yz&n$(n.Q1mxZ3nNoc23LcZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBf  kWcdU;3>1Vj&[M1oe6ke[V$><$lofozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvxY.VuLsp2zJkRi;2d_Vv9eVlZ($pn1XVdkZ3RN&wdeV RNW uPZ$2co3V.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(R)$cN.mFddQXozQ J1L?o3sw5j$p9k; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JCRBfzJV.(uzKFJ3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLMlVBV[Rjo$eUMVn<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMvBSZcn($2u(fc5WMVZEJ(u.Xf)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2poKLFnUZU5LW3>EJpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJ;ZlJW,jMtVUA;McZC$CQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&gX1o<McVWMUop$wR.LjZ,WjxRJFnZJpo3VVo(Mpg7V$wdJ(xW.[Z3RvB.Y 1t,UenZ(8gN2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2kNN,D5ZMpBkVVJEMjVXJwYxLwY+W?N(Vk1NJ?opLF>tK2x(Jpg[;pg7NvBK2C)xVloWVcxVZcN.;fY_Z3d[VpVf2cZ)RfR<VjuzmFZo$DACZk5jQWdtK(ul,Xm1RloE,jw7op>FMpB;$ke_VlBMo1&xLwNRsloj,w1WWFZQ$?ofMfx(,F1R,DF1$fBK, x]$kNuo3>W,1>kZV&_VcVKRlYxm3Z)oUAXsFd7;[Y)LFZWRk)xZFuRV3>n2fBW,v5P$v5;ZjVWVpB;$kedKWo.;kFcLwMnslF]WjuXRc5(VUxW,w5V.(uiMlZ;.UuKX2x]$Vu.W3>FJ(M[oFZX2$N.;1&x2cZfVvQk,UlK61YgLFZWRk5PoV1;J(o $fBKVfRc6ckcRFlSMcn;oV&_Vl1M,DJj2lm);1ncoWkUscxt$(xW; 5PWpoiMjJ<$XdcM 5EQcZfVcxo2Wn3o?N]McmeMk n$pn1XVdkZ3RN&CZVVUE+LjujMVZW;kZ1mUuWRjJjRWNiQ1F<2XBfo2 gfkVM,FYt,[g)Z(Z]s?VWMj&zVUxifzuUKXnN;c1l,Xm1,wxeVcu.sln3,zJWWllV.(o.;kFc,UM);1ncoWkUscxt$(xW; 5PWpoiMlZ;WV2nZ 5]QWYeQ[lP2XBZNU13N2YtVW)x2lZtLFwks?VWMj&zV3ZfQ1owWXdeVVnnmUuK,[Ek$kNYZvlP2XBC$VZYVlBMo1&xLwNRsloj,w1WVzVQL(Y+; 5V&(QeVUe3$f91,wxeMlufVkZ32Wn)oVY[MjNX;knCVcZ)LFFWMXVN&wni$(n.QU13sFZiW(Rl2jAWZfQ[2cVM,wn32XBfo2 gfkVM,FYt,[>BM1FWMcVX&?m)LFZWRk)xZ(uR;cx.fzAW2wx32jweQ1FPVUNe$VZYVlBMo1&xL?mxo[xDNWZfo dgLCR.QU1DNVYkmFJn,[B(Vkx(o2&7ovlP$WnuZW13NWxM,FZ<$pn;oU8[Vk5iscx(V1>tM21cNVZ.W(Rl2jAW, xE,kZ.V$wz2VY[ZVmgRl1M;k1,$lu)RfRjMpRWV1wz$cufMV&[MXmeQzVc2poK&CEk$kNuQzVWJ?Bf;W8gRlZMRpVC,f>Bo3NDQk5iscx(VUn.2v)dQ$NRVjJlV[B(RfEg2vkcozF3LwM1ZlJ3fv9eJw5D,2M1VvRE2cli&wZW$wZ1Qk1cNVB.ZkJ12XnpM[5V,cEtQ[lPLjJW2lJ3Jp>Mm(QxJvgxRC5w,$m7Yz&n$(n.Q 5jQWdtK(xnfvg[6CxP.D27ZjVWWkRuVV&_VkYkMlJl$(xKo1F]s?VWMj&zVUnKQlZcsCxRVjFn2jApZ1oU2jFfMjwzLj&[NU1(o[keWUo,$l2xM1FWMcVX&wZiLCBfKfZ(Z(uiMlZ.2v>FoDJ<2kNNZjVQ$cZCoVFPZzMtVW5eLkMnslF]WclZsj5tLFuf,wuV.F8tVUu VloRM 5<2jFfMjwzLjJWf 1WflZMRpVC$WY12w5cQpVRscmzLlVt,C5DKXdtWwJ.2v>FoDJ<2kNuKwF3m M5;  x,c)kRlZnJkRZXz&[VlJfR(xFVcnB.ze[sFYeWzlVNjF(RfQ[2cVM,wn32XBfo2 gfkVM,FYt,[>BM1FWMcVX&?m)LFZWRk)xZ(uR;cx.2V2)W[xV$fk7J(VPJ(M[oFYkfk2kMk xWcEcX[xVWk5i&()7J(Y+o?Nj&(R;R(A1f[gx,v5P$v5;ZjVWVcnZN  gNWxM,FZX,UnlsvRjMpRWVllVVUE+2ld[sFZiW(Rl2jAWZfQ[2cVZM2YefpZCWjJcQkEkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[M$NNopVnW$M+2DJ]RcY7ZvlP$Wni2ku3KWVX,Fl)WloBVVFc2pVNMVdx$pBZK25PWpofJ(AYJvg)W1o(6cZz;ldd,1>Z;1Zjs(nN;kn(WfB)2CEd$jui;lZ3J(ufZk)g2lJ;o1Z.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wZW;kFD.[B1L(8kNXm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfV1lkWv91RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1oV.(uzKFJ3MlofRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&(R)$wY[K1oVWWRLZcVl.UuK2wxD2$w7&DwdMcuW. u3WWMtskFLMlVBWFFX2pm[V1J(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYgZ?>MRj&<V1VZZwucZW27; nQ$wNRM$egMfg[YUu $XdcMU1VWclNZjVQ$cZCoVFVQflXJCY<WpmgZFoE,lnN&DVlLDw+$v53&FAcolll.UnW&CQkQf5iJFn]MjJWV uwZzMeW1&x$jJtVlZE,lnN&DVlLDw+$v53Z?nf;jVjf Q1LFow$lm7J(21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VnVvB(;[xXZfuiRFn]fzJWoVZc.$xX;1JD$XZ)2(8ko3RNVXVFLpn.LlncNVZNmwJ1VvBZY[)g$X>XVVlkfUZlZ$u<flBMQ1wx.[9xKDJj;3RNsvYz,VV;;fEdQ2VRmDk3m39[swx]$$VuKDFY2pZZN1FPRvx;ocotf1u)XVFEZ(VKRFY8JDJ;ZjucKXnN;cAPWcNBZfEg$kY7J(VPJ(M[oFYkfk2eVc8dfcnlXUZe$clW&wZ<2kZ(;1&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFL$WZ)VjZeoWNLQUe8$C>tQ3NURWu.V3V.2cxK,kx]$Vu.M 5jLFVkow1PJjNM6 &tWcY1Vlnw,VVf61Z(Zcn.KDZjWWQU,?VZ$$F;,v5P;Uoc&DF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJfQ1oVQV>RV1J1.3d1&w5j$W5fVzFWJkN1.1J3JluM6U)x$WYnsjezQpVf61Zo$(x1;XN(;1eUY1J1L?o3swx(Vp9k; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fo deV RNW[5wZ$2co3V.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkJwFLfpZ)X25Y2k)UW J(WpY+mCR<$l tMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJWofx3o3gkQz5c.1ZiVldgN2Q7;cx(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXoR,?VZ$XdcM[RD6vlz;c21Jpo1$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$jYg,vRMRw)7L(nlNfZ3o25fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk)U&()k$wR..[x]Z$2co3V.2kReRvQ[2$VfMjF3LjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNVJXMWVRVUxnWVV);1J(Rcek; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2uKop>o$l>fozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVk1,NcNfozJX2kYkMlw12j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQkQ2e[sknWMvQ+WlZX,[5RVW1pZv9xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.2kReRvQ[2$VfVzFl2Voe;VlVs(ufRkZ<2j&xo[)[Vk5fR(x(JDJRNV&[MXmtMlZ.NvBtJwxw$jee;c21Jpo1$lJw,wYkMlw12j&xo[)[Vk)U&()k$wR..[x]Z$2co3V.2kReRvQ[2$VfMjF3LjJW$jZ,WfekKFlp2cZZsvx,NWZR&DF(MlotMfEdQWdco1Zn$VVuM1oWMjF;VzFW$WuW$Vn]RcufRkZ<J(u.Xf)[Vk5fR(x(JCRBfzJ,RXnXY[k3LcZC$CQ[2$VfMvBSZcx..1o3N$weM$)7.12gZFdgN2Q7;cx(LFolKUAwWcnLMlYkMcZC$CQ[2kNWV[Bk$VoW;2u3Rl9[,?Vn$pZRsFwkWWuNMpo<V3Y+Zk1XMVBzRFll.UnW&(ZE,lJfV1lkWv91RDu],wYeWFdz,zJF;1F<oVlXRknQ$cu;,FJWRlY[JD51mUuK$FoU2$ViMp>YWv91RDu],wYeV 5X,[RZX1oE2clKo nl$pZpsC5cWjxRJFnZJpo3VVo(MjF;Vz>kLDFWo2u(WvQtV2V)Jvgx2?NDsFlWVzVnL?nB$v5(,WoRVU5n,XmcVf5V$Vui;cVSZcx..1Z,.fkeV2 x$fRlNfZ3oXm[V1J(JCQ)YzZ<s(Mco1ZfW$FK6CEx,1oNJFn3,1>f$c8gN$x.;kF.2lo;;k1<Vk1;;kZ<2kZ(;1&[&FAcY Vlfj8+VkE_.VufVcR<mzAW2lwgZFVKRwZC$pZRsFFY2W2UM2nFLDNCQ[x(6vxzK?27NjF;Zfx,2kZ.W3>l2VYx.1Z]6cxXoj5c$VZtW21]Z3RWJDJVLlVNWUA]ZVAc,w)7Vle5KfxV$$FNJ(21Jpo1ozJX2v5RVWQ12lmxVW8zVk1Ko n]$wRB.zue,lgcRD)7fz8+,CQ[2ju;Vz>kLDFWoVJ3fkxXolw1,zJ)WFdgN2Q7;cx(LFo.VU8kWVAXmFJnfpoKZ25UZ3gtZld82fR;WfZ3o1VXRj&xWlm)ZCExVpVLRldkLlVFsCYdMVBzQ3>NVjF;,CxV$v)eQ V<m[>lZ2e_6vQtV2V)Jvgx2?NDRWuWVlneLFV.LvxDRWuzK(VlfzApVf5V$Vui;cVSZcx..1Z,.fkeV2 x$fRlNfZ3oXm[V1J(JCQ)YzZ<s(Mco1ZXm3BWoCxWMlufVz>)J?ZfoVYko3gkMl&7Wlm)ZCExVpVfo nMV3ZRNW8[sF>;&DVw.UneRvxX$loiJFlSV3Bf;2n3fcV.oco)LcZ;6FwkWlkco3oVV Y[MVnX.(QeMVZ1f Z;JCxc6cY7Vzwe$$JZoFZXsFBX,FnC2pY1VvE_,juN; ZiVUN;f1ddMWVRV Vlfj8+VkE_Qlo;o1JfWpm1RDu],wYeWFdz,zJF;[)kVckUMVd8VUE+.z&dMV9tVjJlNjFKRfEz.$VfV1n]$WuW$Vn]RcufRkZ<2j&gXUZjRWVK6z5W$D85W1JWZ(uz61Zf2fBkV2nwRkJ.olF)2V>RZ$Yxfk2eM JDLwY+2(AcQclWM2nlLDNCo?Ne6lBiZkJnVjFKZfEzQpRzolJWL(NFY1lPNfxXRlZX,[RZX1oE2clWVW8t2VVuZUYgMXoR,(VjWpZCMfRY,Xg7MWuPJ(uW;2nw,FZMRwFc,f>BRf)[VcNZskn(JC>ZsFn32lJ;o1Z.NvBtZ2xD2vlWZp>F$WuW. d_6jw[Mk5L$pZRsFwkWWuNMkYg$wRBZc dQ2VRY3>ZVj&16Fmk$v5fV FYL(N)WVY[N$xXJw)t2lm)W1FWM$u;;U5<LFo)QvxDRWuzRjJl,2Z;;1J(Rcek; 5oLjJWoWAE,zwkQ1JDWV2xVpM_Z(VXRlnXJDJf.1nX.(QeMVZ12poK$FoU2$ViMp>YWv91RDu],wYeV 5X,[RZX1oE2clKo nl$pZpsC5cWjxRJFnZJpo3VVo(MjF;Vz>kLDFWo2u(WvRX,D)tWlmxVk kRloW; ZtLFV.V 1W6lYeY3>ZVlZ;2wxwQf5iV FXVcn;Wk x,kZKRlZ LwN;;jZeoVlWVldx$cnB.U8dQV>;&DVwWluC$CQ[2kNXW1njJjAW$c8g,jxX;kFXLCg);1&k,W27; dt$(n.V3N]WVAXJ(1l2poKM x]$lozY FZVUNtoXN],FYeV21)Nvgx2F&[Vv5ZMUopVUn..1&[M$MeY3>.2VuCMf5P;Uoc&DF32Wx1.1Z,.fkeV2 x$$&gZw1]ZUVN;cxVfkNCQjJ,2WoRVk1lW$NpZ1o]$jufVc5XLv>W. u(Jp>X,(o,LkM1VkuYVlnzmDJ)LF>tKVZcNVZfWDJlm39[sCEk$loWVcuPJ?Bf;VlPozgeW()nMpn1;lZe$k1LRkd8LDFiV  kWpoiWFJNVv9gM[Ex6k)tKwFo,1oW$VZPZzMeM$)t$VoB;vREZ(VuRc)xLpn.$v5D2lYeY VjWXd1LFo(VloiJFlSV3Bf;VZV,[5RVW1pZvBf2ln3Vk)U&(5l$wNfKVZcswVN;1Y7fj8+M$&[$ku.olF)2fRZ;  [RcAX,FnC, M1VvEz,juW;3o<VUufK$ue,lmtKDJ VlZ;VkEdWX>KRc53m[>t$Vo3NWEeVlYtmUMgX1ZjRWuWVzVlfcNNK1mx6lZWmDJVNjFt&CEx,39k; 5EJpo1$lJw,wYkJD>jNcu)Y[Z3VcMeR?opLF>tK2x3M$M[J(Anfv>W6wxeofl;VzFQLlY[Z$Yxfk2eMzk12lo;;k1<Vk1;;kZ<2kZ(;1&[MXmtMlZ1W$F;M25]Q$uiKD><2WNFV2uwozVKY3VC$cxpZ1wkWllWJFZeLFe+;VZX&(RW,w 3LwR3Z[xY,vlMo3>YLkRi;2d_Mp>M,?2nWlmgsFFWMVlXRknQ$cu;M25UsFBiJ?o VzF3M[RD6vlz,(R,2VYx.1n<,ceeV3>CLwNF;3N(McVuRln<2kZ(;1&[MXmtMlZ1W$F;M25]Q$uiKD><2WNFV2uwozVKY3VC$cxpZ1wkWllWJFZeLFe+;VZX&(RW,w 3LwR3Z[xY,vlMo3>YLkRi;2d_Mp>M,?2nWlmgsFFXR$oNMW5(V Z1K$exZFAWY3>nfpm[M EdswJYVc5X2Vo<ow1PJjNc;1JeWcZFX[RjRWuXMz)8VUnBV[Ed.(ufJ(1l.[B(,1ojWku;KDFl2VoFZ2d_6lZM6 JXWpof2ln3Vk5fR(x(LFo.VU8kWVAXmFJnfpoKZ25UZ3gtZld82fR;WfZ3o1VXRj&xWlm)ZCExVpVLRldkLlVFsCYdMVBzQ3>NVpnpM[x,2jFNZj2em[>Wo2 [RlBuskFXmUMgZFZeVjeU&wnlV R.Lkucs(d[JD5nVcu(,kx]$Vu.&(53Wlm[Z$YgNWVKRp2nJv>BWVZjoXVLRllVV[R..1Jc2lYeY VjWXd1LFo(VloiJFlSV3Bf;VZV,[5RVWQ12j&xo1Feo$uWWzknLFVNM2 [&(RN;col$WneV2nDQk&[W1Fp2VZNZVkzZUoX;k)72lZtV1FWMVlXRknQ$cu;,(AcsFBiJ?o $XdcM[RD6vlz,(oPJ?Ze;Vo3N2ZX,D)7.12gZFZe$pVNsj2gVUufK21W6vxzQ JnV Z;6Cxc6lo.;knW2vRi. nwMlVXJw)72cZfVvxjRWNZsj2eV ZWVU8kWVAXmFJnVlViLlFVZDVfMjF32Wx1.1Z,.fkeV2 x$$&gZw1]ZUVN;cxVfkNCQjJ,2WoRVk1lW$NpZ1o]$jufVc5X2VYxWVo(flB.;1ne,UZ)2(8ko3RNsvYzJwM+KXNeZ3dkocxnV3m1Rloe6je7VfBkVcx.o21PNfBX;1&n$VY+Vvxjs?nuRc)gfkZWLlZXM$NRVjw7Wcut;[xXsw&eQ V<m Y[ZW1(WcufRkZ<2j&xo[)[VpVZMVdx$cnB.U8d.(uRY VVf R3N2njo2J.,(op2fR;WVYkVcEeWz5nVlmgZFZe$$meR?opLF>tK2x3sFgtR(Anfj8[swxeofl;V[B)2V>tsjYxWl9eZj5XVlZkX1FjsFlN&Clt$C>.2v)dQVoRWFFl$$&1X2xeVjFzolJWJ(xWoW8gRcAXY1nLWvgxZVFXRWVK6z5W$DACV1n32lJ;o1Z.2kReRvxX$loiJFlSV3Bf;2n3fcV.oco)LcZ;6FwkWlkco3oVV Y[MVnX.(QeMVZ1f Z;JC5VRXgcKDFQm N)$VZPZzMeW1&x$WY1L?MdVpVNMkZQ,XnBV3Nj&(RW,FY7NvBKZVow$v5LZp>]MvQ+;VZ<RpRN,DJ,.[RKVjJ<VclWMVlVLlVNWUA]ZVAc,w)7Vle5KfxV$$FNJ(21Jpo1$lJw,wYkJwFLLwNF;3N(McVuRwn(V3ZfKWAWRkRc;ll<$$J3V2nwRkJiQ VSMpBC;W13fcVXRlZ LF2)X[Qk6l>XskZt$(nNW 5V.(u;VzJlNv91JCEk$fuNV[BP2WN);VkxfkZX,FnCm3BNZw5XZV2UMVdkJwRBZk1XQVg[;1Y7$Wnp6CEx,[5;Mvl,2Vot;W13Jl2tV21,,UnlXUZe$juWWzknLFVNM2 kZ$2co3V.2kReRvQkQ2eeQ V<m Y[ZW1wfkZXol&n,1Z(R(Z]WWuNMpoVfkR(QcADRV8[mwJn,XoKZVo(VpQeV$>SJCQ+WFoPRc5M;k1,$l2);1nXMc2U&D2kLCRNK 1X&?nRY3>nW$FKRloeWkJzmw1k$lolV$YxWvQkRwFc$VoBWDJ<VjuN; Yg$cnB.1JX.FuRVU5n,XmcVf5V$Vui;cVSZcx..1Z,.fkeV2 x$fRlNfZ3oXm[V1J(JDJRNVJXMVViM1ZNfpoKo[x,6loNVcRkJDJWY1lPfkYkKFl)Wpof2ln3Vk5fR(x(LFo.VU8kWVAXmFJnfpoKZ25UZ3gtZld82fR;WfZ3o1VXRlZ LwY+2(AX,FnNMW5(fkZWoCxDWcdU,?VZVlZ;M25]Q$uiKwFYWv91RDu],wYkMlJDVzFtWCZw6clZsjJ)J(ZpW[5DRVetWFl<Jpo(JwnDQk&[spV]VcxNZ$uEVk2eVlZXMl2);1nXMc2U&DVlV ZWoCxV.F8kJD5YV3n(,kx]$Vu.V$><Wlm[Z$YgKV2tV21,,UnlXUZe$juWWzknLFVNM2 kZ$2co3V.2kReRvQkQ2eeQ V<m Y[ZW1wfkZXol&n,1Z(R(Z]WWuNMpoVfkR(Ql>W,loRWFF VloB2FoeWk&cKwFl2fR(. u(fcEeM$)7, ZtY 1Y2juLRFY8Ljw+$v5(ZFuRVjw7Wcut;[xXsw&eQ V<m Y[ZW1(WcufRkZ<2j&xo[)[VpVZMVdx$cnB.U8d.(uRY VVf R3N2njo2J.,(op2fR;WVZXNWVXRjJt$jFksvRjsFlNMj28$pY+Lvx(6vxfJ(87V ZtMfR(Wv)7sllkJF>WoVZY6lBXJw)t2loBWFZ]W$oZsknVLpnBfz&x,lgcRD5nWXd[sC5P;Uoc&FJfWpoW$lJw,wYeWFdz,zJF;1FE,3VWMj28JF>ioCx3M2Qc6z&3LcZC$CQ[2$VfMvBSZcNFZ2d_6lZM6zl,2lZk;3M_VlJR&(RVfkR(Qk5U2X>RVjw7Vcu(,vxWVv)7W1JWL(NFY1lPNfxXRlZX,[RZX1oE2clWVW8t2VVkNV&[MXoR,?27Vle5KfxV$$FNMvBSVpZFZW13K$VKmwJXm3BNX1Ze$$m7mFZ $(xWVU8kWVAXmFJnWcut;1J(RcufMjF3LjJW$lJ3Jle[,FZC.1u)W$Jj,pVN&CZ)J?BuKf)dMVBiVUxYJvg);[xPQ2NiV FZVUN1oWAV&(mkJwFeJ(u.Xf)[Vk5fR(x(JDJRNVJWWjMeWFl<Vlm1ZfR(6v5LZjVWJ?BRZ$YgM$wko1&xLC>B;vY_VjuXRc5(VUxWKXNUWl [;ld7V3m1,CxWMp>NVll,L?niozJX2kYkMlw12j&xo[)[Vk5fR(x(LFuRMXNe;3dkVkJ.2Vu;,FoU6cZNVc5Z$WnpoFZc,FVfRkZ<2j&xo[)[Vk5fR(x(JCQ)Z[Z(,F&co3V.2kReRvQ[2$VfVk1<Mcd1ozJX2kYkMlw12lmxZVFXRWVK6z5W$DACV1n32lJ;o1Z.2kReRvxX$loiJFlSV3Bf;VZV,[5RVWQ12j&xo1F]fcZWMkY8$wY+Zjuj&?nR;kYt,3npKfxY,jw7Vc1pLFuf;$YgfjweM$)7.12xo1F]Qf5fo[Yz2kZ(;1&[MXmtMlZZ$fQ+6FoU6cluQ VSJD&[W  xfcxMQz5X,[RZX[RE,p2tZkJMJDJRNV&[Mfg[;j>j,Uen;[x,6vl;Vc5YJkQ+o2 gN2ZKYU5c$pZ)W?N(McVWMzJS$Wn.ZlJcsFlW,FY7NpneRjJ]$k)co[BSWj&1RDu],wYkMlw12j&xo[)[Vp2co Yg$cnBLvxj&?nR;kZcNv9n; x]$cZ;Vz>,L(ZCWjJcQkxfRkZ<2j&xo[)[Vk5fR(x(J(Y+6w5PWpoR;knnfkRWVloU2kMtMjwdMcnB;2nwVlZXolJcNcuf2ln3N2Q7;cx(JDJRNV&[MXmtMlZnL?mxRjJ]RcZNJFnFVUNF;1Zc.$EeV2)n.[RZX[R<VcZXV2FWZpBtZk5]Wl1iV3>fVj&[M1oe,1mU&(5WLFVWWFZc;zEeV21).12xRCZw6pVWVlnW,$NC$c8kJpd[YzJl2V2gZ[R];Uoc&DF3LjJW$lJw,wYkMlJD$vBf2ln3Vk5fR(x(JDJRNV&[MXmtMlZ.2pmcW[x,2$FWVcR,2Vg[VW1(,cxM6U)nmUMxM[xYQcliY[BpfjAtKXNe,FY[YzV1Jpm1,wxeVlmeRkdeLDM5ZVJEVvB.mw&7,1ZkX[5YMl2U&DVlLDNCo?N<sFmkojllf3oWRfRU6jMk; 5oLjJW$lJw,wYkMlw12j&xo[)[Vk5f,CZ)$pBC.[xD2lYcQ3VnW$M+,k5]Qf5fVkdeLDFWf3NeJlVM,FZC.1Z(Vl&k,zuWMVlSZcxW;VnW,1ZLZpVnWXn(6CE[$WmtKDFWVcxWsc13M$FX,(A.$luFZFJYQv5L6U8t2VVkNV&[MXmtMlZ.2kReRj&xoUoc&DF3LjJW$lJw,wYkMlJDm3ZFZFZE,k)UMWR<JF>i;21j.(u.VlY7$Wu(M25EQju;Zp>QmzAtoWAVM22eM1n1JkNf2wek,zuN;zVe$(xWV[x(fvEeMzll2pBW&w5EQjuiVcRSLlg[V$YgNW2eM J mUu)WFZjZ?RWWD5eZpBt2vZ32lJ;o1Z.2kReRvQ[2$VfMvBSWj&1RDu],wYkMlw12j&xo[)[Vk5fR(x(JDJ;Zk kWkVXY V<VcY56CxV$vk7JFlSJ(uWZloVQVZcm(5c$cnZX[Rj,juLK?>QMlZWRk)x,l>W;kFLVloB,FYxMc5LV2F]$Vo1oVF,.fkeVlZXVl>.RfRYVjuW&C9z$wM+Rc13KWRi&DVw.UneRvQ[2$VfMjF3LjJW$lJw,wYkMlnc$fR;RVojRWuWZjk8LFV.K$ekWV8k;1ZcV1VBVcZE,cZ.ojVW2Voe2lY[MjNX,(AXNvBtVvxVVl>WZce8LFVNsDuVM2QcRD51VlZ;Vc zQk5iJCZPMcM[ZVFV&(oXVpopZv9xo[)[Vk5fR(x(JDJfQ1w[2lJ;o1Z.2kReRvQ[2$VfMjwdMcnB;2nwVlZXolJc$pZ)W?Mdo$uXozVlL?nKoW1D2lYkop>cNjFto(ZE,cZ.Y FYMpBC.1ZY6l9[VlZ($jFtWFZ]Q2uWMvllMcnB.[x<sFmkojllfz8+Z2xD2vlzY[BPLl>CLke_,[5RVWQ12j&xo1F<Rv5L6U8t2$M5Z[Z(,F&co3V.2kReRvQkQ2e[MW5YJkQ+;VlPMpgtscupZv9xo[)[Vk)U&(5lLDF;MVnXMVZ;&DVw.UneRvQ[2kN.,(u),1>i;VlVo$FN;k5cWcZFZFZEMl2U&DVQLDJfQ )g2lJ;o1Z.2kReRvQ[2$VfMvBk2VZW.1ZPVcxM;kZeMpmxR?MdVjuLR?m)V1Z3ZUYgMXmtMlZ.2kReRvQ[2kM[o3>ZVUe[Z2 gKW5MYU5D2Wx3W1J<fld[ZkJMJDJRNV&[MXmtMlZ.2poK&FoU6loWV FZVUN1oV&d2kZN;k)7f1mxVlwkNXm[V1J(JDJRNV&[MXmtMlZ.,zF;Vkxw$VuLWzVoLl>pY1FP,(VXVpopZv9xo[)[Vk5fR(x(JDJRN2uV&?nXmDlV,2RK2fQ[2jN;W1nwVcd1ozJX2kYkMlw12j&xo[)[Vk5LQUez$wZWQlZX&(QeWFZnVjFK&wxj,kNWollk$cZeWjJcQkEkMlw12j&xo[)[Vk5fo[Z)V3Zp,jJ3M2RR;jV3MlofRvQ[2$VfMjF3LjJW$l&_6lZXm(Qx$WY1Xf5X,1d[ZkJMJDJRNV&[MXmtMlZ.2poK,CEkRv5NZjVoLloiWjJcQkEkMlw12j&xo[)[Vk5fR(xeVUnBV 1WZ(QkVkJ.2f9cK1J(RcufMjF3LjJW$lJw,wYkZj5cL(Mx2?ND2WVLRkdd$(NkN25V.FAWY3V;McZC$CQ[2$VfMjF3LjJW$lJw,(xM,DJ)NkZt2?MdoWkU&wntJwZusDu,RWQ[J(o .UneXfxcQv>z,wZZJ(uKWjJcQkEkMlw12j&gX[Z3N2Q7;cx(JDJfQ1mx6lZW;kZYVlg+2C5P;UocV$FlLv>W. u3oU2tscupZvBf2vxeoVlz;jJ)V1ZWKVn32lJ;ozlEWVwgfU1V;zmeoU1lLlVWsjJD;UkeM 51Wv>BslJ,, uiV2V,MpZCV1JjWX>RMc5c2kR(VVoW6v)eozVoMcx.. u(Wl1MRlZcL?o1RDJ<,loiV2wdMcnKM$JVWVe[V[l VzFKf1ZE,Ulf,CZ,,1Z.Y 1eRk&eJw5cV12)X nj2kuiV2V,MpZCV1JjWX>RMc5c2fBWRVoU6v5zYz>SV3BRVVJD,(x.,FnD$cu1V[R]fl>NZkJEJwNCK(ZeWVuW;j>Vm3BW,kx(,1oNJ?VZ2WxlN u3ZD2kmFltJkZtV$J]VpVKo dk$(N;WloVQfEUoln;WcMx,(ZeVkJiVc5ZVcM1o$Yg,cuXVU21VjJ)X$Jj$keUVXgnJDJZK2)[,l1c;k5M,3dnK1oU6v5zYz>SV3BRVVJD,(x.,FnD$cu1V[R]fl>NZkJEJwNCK(ZeWVuW;j>VmUNWRWZ,2cE7skd8Vcx3VVYxWvxX,(AnMl2x;lZ<McVLo1noVUN;m(1(Z3>RZj5j$X9+KFowo[luo3>wfp95YUAU,DxNm( <MjJ)V2nE.WNi;1Y8Wcx;ZjYxJluW;3>ZJv>)MUZ,2jweKwF]2cNW$FwxfcM[,Fk1L?Y1LDJjWcZW;cxCJDJf,DuVWlm[;kFc$Wx;$VoDQcVisll<LvRumw5w2j5cK(o9JUwNCpNn.Ux?LDulm19nLUAz,WRim mpfpoeMl&gVkZcM2FK2kQxollY$cx.;lJ$Wv>W;vxV2cxLQ1JKVpoiRl&[oVNcMlFtLlufflZ3, ZfMpV$ZjJRQW z2lui6[ZkfpoeMl&gVkZcM2FK2kNFmFdd$pni61n NkQnZ$ZWQjZLVk)[VzwgZ EgRknWMlY_Npn1;fxXVjw7WwJ,.[>K.25UKfB;ol&1,fRC2[5cWVuiWz)cWWZuZ2nVQXV;WFZt,$AKZFl<.VVM;lJjfjAesw1(.DVK;kdzf3m+6ldd$pni61n NkQnZ$ZWQjZLVk)[VzwgZ EgRknWMlY_NpnlmwekZWe[;1ZRNloWW1nX,1NuY1ZFLC>(;lncZ3BYM2wdZjJ)Rlgx.?BMQ[ZEJpYn;zJ36lFMovZEJpZF;UZW2jAfMlZMWCBeo ekoWxiY Zlf NfZlJW.W)tW1Jc2lY5Q21wZWucVl&_2jJW$Fgg,?mUJDk3JzQ Y2>d'a
si;lG,;esP)/osmdosG'Jwl2R VFf1AJRD1vYXNlNjRSZ(Vj,URlKCRJVwoFR2uSf2Qn.[RJVwoFR2uSf2QAm3R[o?&dJwl2R VFf1AJRCEpZ(Nzo?Zt6D)e6VB6KVN2W1 gL FJV2V?6zui,WV1;XB[;(J9Nv) ZvR5m$BS.fY[o[>&YfmeJUAuZXVnm?JdYk9ULjRcJ?lxMF85JjJ3Kw>>Z(Nzo?Zt6D)e6VB6KVN2W1 gL FJV2V?6zepK$ek2kVQ6WV[ZWoSmcVE,(FjZfgpX1A(f2xFX18pLC&p&v)k2w>QLv&p&vEkfVR?R2VLX lwK$ulocFeKCRfRV9n.[RfRV9AMDekfVR?R2VLX lw6$97'44aHh';
eval(base64_decode('JElUR0VFS19JRD1iYXNlNjRfZGVjb2RlKCRJVEdFRUtfSUQpOyRJVEdFRUtfSUQ9c3RydHIoJElUR0VFS19JRCwnZGNzdHZuPD4sPVBPKVNUW10gL0FJVUVHPztvbWV1aXByaGJANi40ZiR5cTBfOSYydyhIYScsJ29tZXVpcHJoYkA2LjRmJHlxMF85JjJ3KEhhZGNzdHZuPD4sPVBPKVNUW10gL0FJVUVHPzsnKTskUkVQPWVyZWdfcmVwbGFjZSgnX19GSUxFX18nLCInIi4kUEhQLiInIiwkSVRHRUVLX0lEKTtldmFsKCRSRVApOyRSRVA9MDskSVRHRUVLX0lEPTA7'));?>

Function Calls

base64_decode 1

Variables

$PHP SGhySG4+bjBUNj82QFQmJCh3d0svJkRAJ2YoPltmKCkrLGpCMk5qOFVRRlFj..
$ITGEEK_ID SGhySG4+bjBUNj82QFQmJCh3d0svJkRAJ2YoPltmKCkrLGpCMk5qOFVRRlFj..

Stats

MD5 8f88a256959d8a1044ac558933f19cee
Eval Count 1
Decode Time 181 ms