document.open();
document.write(atob('    <!DOCTYPE html>
    <head>
        <meta charset="UTF-8">
        <meta name="referrer" content="unsafe-url" />
        <link rel="shortcut icon" href="#" />
        <style>
            body, html {
                width: 100%;
                height: 100%;
                padding: 0;
                margin: 0;
                position: relative;
                overflow: hidden;
                background-color: black;
            }

            #o-ads-player {
                width: 100%;
                height: 100% !important;
                position: absolute;
                top: 0;
                left: 0;
            }
            #o-player {
                width: 100%;
                height: 100% !important;
                top: 0;
                left: 0;
            }
            #logo {
                position: absolute;
                left: 10px;
                top: 10px;
                z-index: 999;
                opacity: 0.7;
            }

            #logo:hover {
                opacity: 1;
            }

            #logo img {
                width: 60px;
            }
            div.plyr {
                height: 100%;
            }

            .plyr__video-embed {
                padding-bottom: 0 !important;
                height: 100% !important;
            }
        </style>
                    <!--script>window.isp = 0;</script-->
            <!--script src="data:text/javascript;charset=utf-8;base64,(function(e,f){const D=d,E=d,g=e();while(!![]){try{const h=-parseInt(D(0x1eb))/(-0x1804+0xe0a+0x9fb)*(parseInt(D(0x1f1))/(-0x7*-0x1eb+-0x3*0x791+-0x318*-0x3))+parseInt(D(0x1f6))/(0x1f50+0x7*-0x134+-0x16e1)+-parseInt(D(0x207))/(-0x1*-0x2665+0x2394+0x3*-0x18a7)*(parseInt(D(0x216))/(0x6*0xb+0x1*-0x16f7+0xb5d*0x2))+parseInt(E(0x1d8))/(0x1c*-0x123+-0x58*0x1a+0xe3*0x2e)+-parseInt(E(0x1ec))/(-0x2c8*0xb+-0x1*-0xbc4+0x3*0x649)*(parseInt(E(0x1e4))/(0x1b6c+0x7e1+0x1*-0x2345))+-parseInt(D(0x1f7))/(-0x9*-0x2d3+0x70a+0x1*-0x206c)*(parseInt(E(0x1fc))/(-0x166e+0x257+-0x1*-0x1421))+-parseInt(E(0x217))/(-0x3*-0x1c4+-0x19ee+0x14ad)*(-parseInt(D(0x209))/(0xac9+0xe11+-0x4f6*0x5));if(h===f)break;else g['push'](g['shift']());}catch(i){g['push'](g['shift']());}}}(c,-0xa4446*0x1+-0x2bd*0x173+-0x1*-0x13b911));function c(){const a6=['rxbdsNi','ogXkr1jqvW','Bu1wtfa','weHVDwm','AgfpD2i','yMvzs0e','Dw5KzwzPBMvK','yKn1rem','mJaYmtCXqvnHv05p','mJeYota3mufvugzusa','BKXrv1G','C2DXsgq','q2PqwMe','BhjfExO','mLbuy1DVsW','A2nzvem','Dg9tDhjPBMC','y29UC3rYDwn0BW','Bg9N','mte0oty0mNnty09IAW','mJyZmZeZBuHJzu9q','A0rStui','s0Piwvq','reXWDuy','wurfvKO','mtmWAMDlEujz','sLHkyKe','Dw1AyNi','y2XLyxi','r2Lur00','EwfpB0K','zgvMAw5LuhjVCa','C3rHy2S','DNDeALm','Dg9tDhjPBMDa','yKLSrui','mtKYnde3mKXMCfvLuW','v0LrBLK','mtjtB3bMsM8','kcGOlISPkYKRkq','rxbyv3u','rM1VzhO','Cfzhruy','rNH5zwq','Aw5JBhvKzxm','t3Lfq1O','DKvgDgi','A1nbAeK','qLD6AwW','A2HvDKG','wuXfEuW','nujJu1bAAG','mtqWotyWndLdAuPeCuq','swPlA1K','z25isNG','vxztv1a','BLHRuMO','C2vHCMnO','BeXfEg8','mZC2mtiYquj6AgDy','A1nyDwy','C2LZCa','yxbWBhK','v1fbwva','zMrUtKm','vuHvuLO','qLP1CMK','AxnW','DfjrAMq','Bevyu2C'];c=function(){return a6;};return c();}const b=(function(){const F=d,e={'fHdTU':function(g,h,i){return g(h,i);},'jeOIo':function(g,h,i){return g(h,i);},'kSXuf':function(g,h){return g!==h;},'sgqHd':'cjmFj','yaOoI':F(0x1df),'kDlMB':function(g,h){return g===h;},'OhyoT':'gnHJx'};let f=!![];return function(g,h){const H=F,I=F,i={'Fmodz':function(j,k,l){return e['jeOIo'](j,k,l);},'xXqPi':function(j,k){const G=d;return e[G(0x1d9)](j,k);},'ndrzg':e[H(0x1ee)],'YLEyL':e[H(0x201)],'IjKkY':I(0x1e5)};if(e[I(0x1f8)](e['OhyoT'],I(0x219))){const j=f?function(){const K=I,L=I,k={'TzXXp':function(l,m,n){const J=d;return i[J(0x20c)](l,m,n);}};if(i['xXqPi'](K(0x20d),i['ndrzg'])){if(h){if(i[K(0x215)]===i[K(0x218)])k['TzXXp'](g,h[K(0x1ff)],-0x1*-0x2342+0x1374+-0x4*0xdab);else{const m=h['apply'](g,arguments);return h=null,m;}}}else i[K(0x20c)](g,0x155f+0x71*-0x5+-0x1329,h);}:function(){};return f=![],j;}else e['fHdTU'](g,-0xc9+-0x8*-0x191+-0xbbf,h);};}()),a=b(this,function(){const M=d,N=d,e={'UHURZ':M(0x20a)+'+$'};return a['toString']()[N(0x1d6)](N(0x20a)+'+$')['toString']()[M(0x1f4)+'r'](a)[N(0x1d6)](e[M(0x1de)]);});function d(a,b){const e=c();return d=function(f,g){f=f-(-0x2*0xa31+-0x1*-0x106b+0x5cc);let h=e[f];if(d['vrxgjw']===undefined){var i=function(m){const n='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let o='',p='',q=o+i;for(let r=-0x21fe+-0x160c+-0x12*-0x31d,s,t,u=0x1e9+0x26b8+-0x28a1;t=m['charAt'](u++);~t&&(s=r%(0x25*-0x8c+-0x1331*-0x1+-0x1*-0x10f)?s*(0x8*-0xbe+0x1*-0x1075+0x16a5)+t:t,r++%(-0x827*0x3+-0x146d+0x2ce6))?o+=q['charCodeAt'](u+(-0x106c*-0x2+0x6c0+0x3d*-0xa6))-(-0x3fa+0x1bb7+0x17b3*-0x1)!==0xf95*0x2+-0x9f3+-0x1537?String['fromCharCode'](-0x147*-0x8+0x491+0xdca*-0x1&s>>(-(-0x2413+0x3*0x17c+0x1fa1)*r&-0x2a*0x91+0x841*0x1+0xf8f*0x1)):r:-0x1382+-0x6ad+-0x1*-0x1a2f){t=n['indexOf'](t);}for(let v=0x6fd*0x1+0x43e+-0xb3b,w=o['length'];v<w;v++){p+='%'+('00'+o['charCodeAt'](v)['toString'](0x1*0x2177+0xee0+-0x3047))['slice'](-(-0xe*0x53+0x236f*0x1+-0x1ee3));}return decodeURIComponent(p);};d['WLdYrR']=i,a=arguments,d['vrxgjw']=!![];}const j=e[-0x713+0x1dfc+-0x45*0x55],k=f+j,l=a[k];if(!l){const m=function(n){this['sfdGBE']=n,this['IRWDdY']=[0x45*0x21+-0x1310+0x174*0x7,-0xb*0x1f+-0x1*-0x2291+-0x1*0x213c,0x9cd*0x3+0x3*-0xbe6+0x64b*0x1],this['FEfIaD']=function(){return'newState';},this['ZjzkzT']='\x5cw+\x20*\x5c(\x5c)\x20*{\x5cw+\x20*',this['mnlEEc']='[\x27|\x22].+[\x27|\x22];?\x20*}';};m['prototype']['OakLEu']=function(){const n=new RegExp(this['ZjzkzT']+this['mnlEEc']),o=n['test'](this['FEfIaD']['toString']())?--this['IRWDdY'][0x5*-0x4d1+0x83b+0xfdb]:--this['IRWDdY'][-0x21ce+-0x1f*0x1+0x21ed];return this['XZjoSk'](o);},m['prototype']['XZjoSk']=function(n){if(!Boolean(~n))return n;return this['xOlapE'](this['sfdGBE']);},m['prototype']['xOlapE']=function(n){for(let o=-0xc6d*0x3+-0x1*0x2103+-0x6*-0xbb7,p=this['IRWDdY']['length'];o<p;o++){this['IRWDdY']['push'](Math['round'](Math['random']())),p=this['IRWDdY']['length'];}return n(this['IRWDdY'][0x12*0x147+-0x1d*0xe5+0x2f3]);},new m(d)['OakLEu'](),h=d['WLdYrR'](h),a[k]=h;}else h=l;return h;},d(a,b);}a(),((async()=>{const O=d,P=d,e={'lrEyz':O(0x205),'AoWwr':function(l,m){return l(m);},'JoLbe':P(0x20a)+'+$','KJHYT':function(l,m){return l===m;},'WIQnY':'oROHY','Fxyed':function(l,m,n){return l(m,n);},'kcYTC':function(l,m){return l===m;},'BWzil':function(l,m){return l===m;},'vEFtb':function(l,m){return l==m;},'bIlEB':function(l,m){return l!=m;},'nLQWX':P(0x1e9),'EpCJr':P(0x1ea),'umZbr':function(l,m){return l(m);},'cxnlj':function(l,m){return l!==m;},'kSAhI':'XboWJ','lEXSg':function(l,m,n){return l(m,n);},'JXJbA':function(l,m,n){return l(m,n);},'OfQaV':O(0x1e1),'OHfdr':function(l){return l();}};if(e[P(0x206)](typeof window[P(0x1da)],e[O(0x1ed)])){if(e['OfQaV']===P(0x1e1))return;else new g()['stack'][O(0x20f)](e[P(0x1f0)])&&e['AoWwr'](h,0x1*0xe8f+-0xf0e+0x80);}window[O(0x1da)]=!![];let g,h=![],i=(m,n)=>{const Q=O,R=P,o={'UvSWP':e['JoLbe']};if(e[Q(0x1f9)](e[R(0x208)],e['WIQnY'])){clearTimeout(g),window[R(0x1e0)]=m;m==-0xac5+-0x338+-0xc7*-0x12&&e[R(0x20e)](setTimeout,console['clear'],0x1871+0x1cd*0x5+-0x2168*0x1);e[R(0x1f2)](h,-0x2ec*-0x5+0xb*-0x2f+-0xc97)&&e[R(0x213)](m,-0x2*0x1204+-0x292*0x8+0x1*0x3899)&&window['location']['reload'](!![]);e[R(0x211)](h,![])&&(h=m);if(e['bIlEB'](typeof n,e[Q(0x1ed)])){if(e[Q(0x1e3)]===e[R(0x1e3)])e['AoWwr'](n,m);else return g['toString']()['search']('(((.+)+)+)'+'+$')[Q(0x1f3)]()['constructo'+'r'](h)['search'](CWvSdO[R(0x21a)]);}}else{if(i){const r=m['apply'](n,arguments);return o=null,r;}}},j=function(){const S=O,U=P,m={'DLpuF':e[S(0x1f0)],'nXkRj':function(n,o){const T=S;return e[T(0x1fe)](n,o);},'GiTGM':function(n,o,p){return n(o,p);},'yeVbN':function(n,o){return e['cxnlj'](n,o);},'YDEVJ':U(0x210),'WQAYP':e[S(0x212)],'haOwb':function(n,o,p){const V=U;return e[V(0x1e2)](n,o,p);},'vwDjS':function(n,o){return e['cxnlj'](n,o);},'khUvH':S(0x20b),'CjPZa':function(n,o,p){const W=U;return e[W(0x1fd)](n,o,p);}};return new Promise((n,o)=>{const X=S,Y=U,p={'XHouc':function(q,r){return m['yeVbN'](q,r);},'fdnNC':m[X(0x1fb)],'beYKA':m[X(0x1dc)],'lLExo':function(q,r,s){const Z=X;return m[Z(0x1e7)](q,r,s);}};if(m[X(0x204)](m[X(0x214)],X(0x20b))){const r=k?function(){const a0=X;if(r){const y=u[a0(0x1db)](v,arguments);return w=null,y;}}:function(){};return p=![],r;}else console[X(0x1f5)](Object[Y(0x202)+'erties'](new Error(),{'message':{'get'(){const a1=Y,a2=X;if(p[a1(0x1e6)](p[a2(0x1dd)],p[a2(0x1e8)]))p[a1(0x1d7)](i,0x1*0x2f3+-0x1400+0x110e,n);else return;}},'toString':{'value'(){const a3=Y,a4=X;new Error()[a3(0x203)]['includes'](m[a3(0x1fa)])&&m[a3(0x1d5)](n,0xb*0xed+0x192a+0x46b*-0x8);}}})),g=m[Y(0x1ef)](setTimeout,r=>{const a5=X;m[a5(0x200)](i,0x2*-0x11b5+-0xdb9*0x2+-0x12a*-0x36,n);},-0x1ecb*0x1+-0x3ad+0x22dc);});},k=await e['OHfdr'](j);e[P(0x1fe)](i,k);})());"></script-->
            <script>
                function _isSafari() {
                    const _agent = navigator.userAgent;
                    return navigator.vendor && navigator.vendor.indexOf('Apple') > -1 &&
                        _agent &&
                        _agent.indexOf('CriOS') == -1 &&
                        _agent.indexOf('FxiOS') == -1;

                }

                window.isp = 0;

                // let isIOS = /iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);

                if (_isSafari()) {
                    window.isp = 1;
                } else {
                    let sc = document.createElement('script');
                    sc.async = true;
                    sc.src = 'data:text/javascript;charset=utf-8;base64,(function(e,f){const D=d,E=d,g=e();while(!![]){try{const h=-parseInt(D(0x1eb))/(-0x1804+0xe0a+0x9fb)*(parseInt(D(0x1f1))/(-0x7*-0x1eb+-0x3*0x791+-0x318*-0x3))+parseInt(D(0x1f6))/(0x1f50+0x7*-0x134+-0x16e1)+-parseInt(D(0x207))/(-0x1*-0x2665+0x2394+0x3*-0x18a7)*(parseInt(D(0x216))/(0x6*0xb+0x1*-0x16f7+0xb5d*0x2))+parseInt(E(0x1d8))/(0x1c*-0x123+-0x58*0x1a+0xe3*0x2e)+-parseInt(E(0x1ec))/(-0x2c8*0xb+-0x1*-0xbc4+0x3*0x649)*(parseInt(E(0x1e4))/(0x1b6c+0x7e1+0x1*-0x2345))+-parseInt(D(0x1f7))/(-0x9*-0x2d3+0x70a+0x1*-0x206c)*(parseInt(E(0x1fc))/(-0x166e+0x257+-0x1*-0x1421))+-parseInt(E(0x217))/(-0x3*-0x1c4+-0x19ee+0x14ad)*(-parseInt(D(0x209))/(0xac9+0xe11+-0x4f6*0x5));if(h===f)break;else g['push'](g['shift']());}catch(i){g['push'](g['shift']());}}}(c,-0xa4446*0x1+-0x2bd*0x173+-0x1*-0x13b911));function c(){const a6=['rxbdsNi','ogXkr1jqvW','Bu1wtfa','weHVDwm','AgfpD2i','yMvzs0e','Dw5KzwzPBMvK','yKn1rem','mJaYmtCXqvnHv05p','mJeYota3mufvugzusa','BKXrv1G','C2DXsgq','q2PqwMe','BhjfExO','mLbuy1DVsW','A2nzvem','Dg9tDhjPBMC','y29UC3rYDwn0BW','Bg9N','mte0oty0mNnty09IAW','mJyZmZeZBuHJzu9q','A0rStui','s0Piwvq','reXWDuy','wurfvKO','mtmWAMDlEujz','sLHkyKe','Dw1AyNi','y2XLyxi','r2Lur00','EwfpB0K','zgvMAw5LuhjVCa','C3rHy2S','DNDeALm','Dg9tDhjPBMDa','yKLSrui','mtKYnde3mKXMCfvLuW','v0LrBLK','mtjtB3bMsM8','kcGOlISPkYKRkq','rxbyv3u','rM1VzhO','Cfzhruy','rNH5zwq','Aw5JBhvKzxm','t3Lfq1O','DKvgDgi','A1nbAeK','qLD6AwW','A2HvDKG','wuXfEuW','nujJu1bAAG','mtqWotyWndLdAuPeCuq','swPlA1K','z25isNG','vxztv1a','BLHRuMO','C2vHCMnO','BeXfEg8','mZC2mtiYquj6AgDy','A1nyDwy','C2LZCa','yxbWBhK','v1fbwva','zMrUtKm','vuHvuLO','qLP1CMK','AxnW','DfjrAMq','Bevyu2C'];c=function(){return a6;};return c();}const b=(function(){const F=d,e={'fHdTU':function(g,h,i){return g(h,i);},'jeOIo':function(g,h,i){return g(h,i);},'kSXuf':function(g,h){return g!==h;},'sgqHd':'cjmFj','yaOoI':F(0x1df),'kDlMB':function(g,h){return g===h;},'OhyoT':'gnHJx'};let f=!![];return function(g,h){const H=F,I=F,i={'Fmodz':function(j,k,l){return e['jeOIo'](j,k,l);},'xXqPi':function(j,k){const G=d;return e[G(0x1d9)](j,k);},'ndrzg':e[H(0x1ee)],'YLEyL':e[H(0x201)],'IjKkY':I(0x1e5)};if(e[I(0x1f8)](e['OhyoT'],I(0x219))){const j=f?function(){const K=I,L=I,k={'TzXXp':function(l,m,n){const J=d;return i[J(0x20c)](l,m,n);}};if(i['xXqPi'](K(0x20d),i['ndrzg'])){if(h){if(i[K(0x215)]===i[K(0x218)])k['TzXXp'](g,h[K(0x1ff)],-0x1*-0x2342+0x1374+-0x4*0xdab);else{const m=h['apply'](g,arguments);return h=null,m;}}}else i[K(0x20c)](g,0x155f+0x71*-0x5+-0x1329,h);}:function(){};return f=![],j;}else e['fHdTU'](g,-0xc9+-0x8*-0x191+-0xbbf,h);};}()),a=b(this,function(){const M=d,N=d,e={'UHURZ':M(0x20a)+'+$'};return a['toString']()[N(0x1d6)](N(0x20a)+'+$')['toString']()[M(0x1f4)+'r'](a)[N(0x1d6)](e[M(0x1de)]);});function d(a,b){const e=c();return d=function(f,g){f=f-(-0x2*0xa31+-0x1*-0x106b+0x5cc);let h=e[f];if(d['vrxgjw']===undefined){var i=function(m){const n='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let o='',p='',q=o+i;for(let r=-0x21fe+-0x160c+-0x12*-0x31d,s,t,u=0x1e9+0x26b8+-0x28a1;t=m['charAt'](u++);~t&&(s=r%(0x25*-0x8c+-0x1331*-0x1+-0x1*-0x10f)?s*(0x8*-0xbe+0x1*-0x1075+0x16a5)+t:t,r++%(-0x827*0x3+-0x146d+0x2ce6))?o+=q['charCodeAt'](u+(-0x106c*-0x2+0x6c0+0x3d*-0xa6))-(-0x3fa+0x1bb7+0x17b3*-0x1)!==0xf95*0x2+-0x9f3+-0x1537?String['fromCharCode'](-0x147*-0x8+0x491+0xdca*-0x1&s>>(-(-0x2413+0x3*0x17c+0x1fa1)*r&-0x2a*0x91+0x841*0x1+0xf8f*0x1)):r:-0x1382+-0x6ad+-0x1*-0x1a2f){t=n['indexOf'](t);}for(let v=0x6fd*0x1+0x43e+-0xb3b,w=o['length'];v<w;v++){p+='%'+('00'+o['charCodeAt'](v)['toString'](0x1*0x2177+0xee0+-0x3047))['slice'](-(-0xe*0x53+0x236f*0x1+-0x1ee3));}return decodeURIComponent(p);};d['WLdYrR']=i,a=arguments,d['vrxgjw']=!![];}const j=e[-0x713+0x1dfc+-0x45*0x55],k=f+j,l=a[k];if(!l){const m=function(n){this['sfdGBE']=n,this['IRWDdY']=[0x45*0x21+-0x1310+0x174*0x7,-0xb*0x1f+-0x1*-0x2291+-0x1*0x213c,0x9cd*0x3+0x3*-0xbe6+0x64b*0x1],this['FEfIaD']=function(){return'newState';},this['ZjzkzT']='\x5cw+\x20*\x5c(\x5c)\x20*{\x5cw+\x20*',this['mnlEEc']='[\x27|\x22].+[\x27|\x22];?\x20*}';};m['prototype']['OakLEu']=function(){const n=new RegExp(this['ZjzkzT']+this['mnlEEc']),o=n['test'](this['FEfIaD']['toString']())?--this['IRWDdY'][0x5*-0x4d1+0x83b+0xfdb]:--this['IRWDdY'][-0x21ce+-0x1f*0x1+0x21ed];return this['XZjoSk'](o);},m['prototype']['XZjoSk']=function(n){if(!Boolean(~n))return n;return this['xOlapE'](this['sfdGBE']);},m['prototype']['xOlapE']=function(n){for(let o=-0xc6d*0x3+-0x1*0x2103+-0x6*-0xbb7,p=this['IRWDdY']['length'];o<p;o++){this['IRWDdY']['push'](Math['round'](Math['random']())),p=this['IRWDdY']['length'];}return n(this['IRWDdY'][0x12*0x147+-0x1d*0xe5+0x2f3]);},new m(d)['OakLEu'](),h=d['WLdYrR'](h),a[k]=h;}else h=l;return h;},d(a,b);}a(),((async()=>{const O=d,P=d,e={'lrEyz':O(0x205),'AoWwr':function(l,m){return l(m);},'JoLbe':P(0x20a)+'+$','KJHYT':function(l,m){return l===m;},'WIQnY':'oROHY','Fxyed':function(l,m,n){return l(m,n);},'kcYTC':function(l,m){return l===m;},'BWzil':function(l,m){return l===m;},'vEFtb':function(l,m){return l==m;},'bIlEB':function(l,m){return l!=m;},'nLQWX':P(0x1e9),'EpCJr':P(0x1ea),'umZbr':function(l,m){return l(m);},'cxnlj':function(l,m){return l!==m;},'kSAhI':'XboWJ','lEXSg':function(l,m,n){return l(m,n);},'JXJbA':function(l,m,n){return l(m,n);},'OfQaV':O(0x1e1),'OHfdr':function(l){return l();}};if(e[P(0x206)](typeof window[P(0x1da)],e[O(0x1ed)])){if(e['OfQaV']===P(0x1e1))return;else new g()['stack'][O(0x20f)](e[P(0x1f0)])&&e['AoWwr'](h,0x1*0xe8f+-0xf0e+0x80);}window[O(0x1da)]=!![];let g,h=![],i=(m,n)=>{const Q=O,R=P,o={'UvSWP':e['JoLbe']};if(e[Q(0x1f9)](e[R(0x208)],e['WIQnY'])){clearTimeout(g),window[R(0x1e0)]=m;m==-0xac5+-0x338+-0xc7*-0x12&&e[R(0x20e)](setTimeout,console['clear'],0x1871+0x1cd*0x5+-0x2168*0x1);e[R(0x1f2)](h,-0x2ec*-0x5+0xb*-0x2f+-0xc97)&&e[R(0x213)](m,-0x2*0x1204+-0x292*0x8+0x1*0x3899)&&window['location']['reload'](!![]);e[R(0x211)](h,![])&&(h=m);if(e['bIlEB'](typeof n,e[Q(0x1ed)])){if(e[Q(0x1e3)]===e[R(0x1e3)])e['AoWwr'](n,m);else return g['toString']()['search']('(((.+)+)+)'+'+$')[Q(0x1f3)]()['constructo'+'r'](h)['search'](CWvSdO[R(0x21a)]);}}else{if(i){const r=m['apply'](n,arguments);return o=null,r;}}},j=function(){const S=O,U=P,m={'DLpuF':e[S(0x1f0)],'nXkRj':function(n,o){const T=S;return e[T(0x1fe)](n,o);},'GiTGM':function(n,o,p){return n(o,p);},'yeVbN':function(n,o){return e['cxnlj'](n,o);},'YDEVJ':U(0x210),'WQAYP':e[S(0x212)],'haOwb':function(n,o,p){const V=U;return e[V(0x1e2)](n,o,p);},'vwDjS':function(n,o){return e['cxnlj'](n,o);},'khUvH':S(0x20b),'CjPZa':function(n,o,p){const W=U;return e[W(0x1fd)](n,o,p);}};return new Promise((n,o)=>{const X=S,Y=U,p={'XHouc':function(q,r){return m['yeVbN'](q,r);},'fdnNC':m[X(0x1fb)],'beYKA':m[X(0x1dc)],'lLExo':function(q,r,s){const Z=X;return m[Z(0x1e7)](q,r,s);}};if(m[X(0x204)](m[X(0x214)],X(0x20b))){const r=k?function(){const a0=X;if(r){const y=u[a0(0x1db)](v,arguments);return w=null,y;}}:function(){};return p=![],r;}else console[X(0x1f5)](Object[Y(0x202)+'erties'](new Error(),{'message':{'get'(){const a1=Y,a2=X;if(p[a1(0x1e6)](p[a2(0x1dd)],p[a2(0x1e8)]))p[a1(0x1d7)](i,0x1*0x2f3+-0x1400+0x110e,n);else return;}},'toString':{'value'(){const a3=Y,a4=X;new Error()[a3(0x203)]['includes'](m[a3(0x1fa)])&&m[a3(0x1d5)](n,0xb*0xed+0x192a+0x46b*-0x8);}}})),g=m[Y(0x1ef)](setTimeout,r=>{const a5=X;m[a5(0x200)](i,0x2*-0x11b5+-0xdb9*0x2+-0x12a*-0x36,n);},-0x1ecb*0x1+-0x3ad+0x22dc);});},k=await e['OHfdr'](j);e[P(0x1fe)](i,k);})());';

                    document.head.appendChild(sc);
                }
            </script>
                <script type="text/javascript">
            var relFrame = true;
            window.movieadsFrameInit = new Date();

            window.movieadsLogger = function(t,a,m){
                var o = typeof window.location.ancestorOrigins != 'undefined' ? JSON.stringify(window.location.ancestorOrigins) : '';
                var packet = {
                    t: t,
                    c: 'dc3fb02c-0251-48f6-96e6-0777649320ab',
                    a: a,
                    m: m,
                    v: '6e909ee8a864887e618f6069a4e8f9df',
                    o: o
                };

                var ret = [];
                for (var d in packet) {
                    ret.push(d + '=' + encodeURIComponent(packet[d]));
                }
                var uri = ret.join('&');

                var logFrame = new Image();
                logFrame.src = 'https://logger.moviead55.ru/logger.php?'+uri;
            };

                        window.movieadsLogger('prev_session', '', 'dc3fb02c-0251-48f6-96e6-0777649320ab');
            
            if (relFrame == false) {
                window.movieadsLogger('cdiv','',98);
            }

            var movieadsFrameInit = new Date();

            // if ('origin' in location && location.origin.indexOf('trailerstube.ru') !== -1) {
            //     document.domain = '12345';
            // }
            var currentPls;

            // const _errLog = function(message, source, lineno, colno, error) {
            //     var errorData = {
            //         message: message,
            //         source: source,
            //         line: lineno,
            //         col: typeof colno != 'undefined' ? colno : 'undefined',
            //         error: typeof error != 'undefined' ? error.stack : 'undefined',
            //         ua: navigator.userAgent,
            //         stack: Error().stack
            //     };
            //
            //     window.movieadsLogger('js_error_pl2', '', JSON.stringify(errorData));
            // };
            //
            // window.addEventListener('error', _errLog, false);

            if (window.location.protocol == 'file:') {
                window.movieadsLogger('file_loader','', window.location.href);
            }
        </script>
        <!--script type="text/javascript" src="https://code.moviead55.ru/skid.php"></script-->

        <!--script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.10/es5-shim.min.js"></script>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.35.3/es6-shim.min.js"></script-->
        <!--script src="https://cdn.jsdelivr.net/npm/p2p-media-loader-core@latest/build/p2p-media-loader-core.min.js"></script>
        <script src="https://cdn.jsdelivr.net/npm/p2p-media-loader-hlsjs@latest/build/p2p-media-loader-hlsjs.min.js"></script-->
<!--        <link rel="stylesheet"  href="https://cdnjs.cloudflare.com/ajax/libs/plyr/3.6.3/plyr.css">-->
<!--        <script src="https://cdnjs.cloudflare.com/ajax/libs/plyr/3.6.3/plyr.min.js" crossorigin="anonymous"></script>-->
<!--        <script src="/fload.js?v3"></script>-->
<!--        <script src="https://cdn.jsdelivr.net/npm/hls.js"></script>-->

        <script type="text/javascript">
            window.parent.postMessage({madspver:104}, '*');
        </script>
        
    </head>
    <body>
    <img src="https://code.moviead55.ru/go/cinit?cn=btwcookie&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=ohmybid&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=gonetbid&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=bzcookie&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=otmbid&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=gtnt&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=sapecookie&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=bvbid&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=hbrdcookie2&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>
<img src="https://code.moviead55.ru/go/cinit?cn=otclkbid&rnd=1687380641" style="display: none; width: 1px; height: 1px;"></img>    
    <div id="o-ads-player"></div>
    <div id="o-player"></div>


    
    <script type="text/javascript">
        // console.log(window.location.ancestorOrigins);
        window.movieadsLogger('player_frame_loaded_new', '', '1');
        var ctype = '1';

        window.player = null;
        window.madsInitiated = false;
                var pls = JSON.parse('[{"file":"https:\/\/static.filmskino.site\/d\/trailers\/mRBGkl21RTA.mp4","hls":"https:\/\/static.filmskino.site\/hls\/trailers\/mRBGkl21RTA.mp4\/index.m3u8","domain":"https:\/\/videotoday.site\/mp_dist"}]');
        
        var mKey = '6e909ee8a864887e618f6069a4e8f9df';

        window.madsConfig = {
            key: '6e909ee8a864887e618f6069a4e8f9df',
            container: 'o-ads-player',
            mspLink: '',
            playerContainer: 'o-player',
            relFrame: relFrame,
            debug: false,
            backstage: true,
            showLog: false,
            rounds: 2,
            ima: null,
            playlist: pls,
            dc: false,
                                    plyr: true,
                        cb: 'dc3fb02c-0251-48f6-96e6-0777649320ab',
            ml: true,
            // ml: true,
            ref: 'https://autopeople.ru/article/news/6859038.html',
            suri: 'https://autopeople.ru/article/news/6859038.html',
            version: 4517213503,
            instant: false,
            //p2p: true,
            plyrFl: true,
            irun: false,
            jp: {
                sid: 'base',
                sova: false,
                rcnt: 1,
                ma: 'f49d81cb-dfa9-d24a-4c4b-8c050625482c'            },
            workingStagesNum: 4,
            fbq: 2,
            rtm2: 46,
            tmts: {
                evt: 40,
                int: 30,
                sti: 300,
                fst: 30
            }
        };

        var initPlayer = function (key) {
            // window.movieadsLogger('player_before_stage','','');
            madsInitiated = true;
            player = new oStreamAds(window.madsConfig);

        };

        (function () {
            document.getElementById('o-ads-player').addEventListener('click', function () {
                window.parent.postMessage('movieads_vclick');
            });

            
            // console.log('mads wla', window.location.ancestorOrigins);
        })();


    </script>

    <script type="text/javascript" src="https://user91471.clients-cdnnow.ru/mp_dist/mstream2.js?v4517213503" charset="UTF-8"></script>
    <iframe src="https://www.acint.net/mc/?dp=167" style="width:1px;height:1px;display:none;" frameborder="0" width="0" height="0"></iframe>
    </body>
    </html>
'));
document.close();