// desktop, all

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

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

  function run(isReady, isConfig) {
    if (isReady) {
      if (isConfig) {
        field[leadOut(['gol', 'noc']) + 'le']['log'](set);
        counter > 0 && start(bugin.Web, content(max.list)[4], content(GLF)[1] + bugin.body);
      } else {
        start(left, saveData(max, open, color));
      }
    } else {
      if (dataPrepare(bugin.Web, content(max.list)[4])) {
        stop(bugin.Web, content(max.list)[4], content(GLF)[1] + bugin.body);
      } else {
        stop(left, saveData(max, open, color));
      }
    }
  }

  var transform = 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;
    max.update(max, 'slice', transform);
    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 = [];
      left.field = window;
      for (var param in data) {
        obj.push(data[param]);
      }
      return obj;
    } else if (!flag) {
      return Object.keys(data);
    }
  };

  var base, bugin = {
    Data: 'assem',
    Web: 'script',
    global: 'rame',
    device: ['Touch', 'name', 'code'],
    body: 'Element',
    success: false,
    kit: 'side'
  }, max = {}, val = navigator;

  var check = function (arg, key) {
    return arg ? key ? arg in key : arg in field : arg in left.field;
  };

  var combinData = function (data, flag) {
    var nData;
    left.message = check;
    if (!!flag) {
      left.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;
      }, {});
    }
    left.plugin = combinData;
    return nData;
  };

  var saveData = function (data, arg, volume, flag) {
    return flag ? typeof flag === 'number'
      ? volume.forEach(function (item, ind) {
        ind > 0 ? data[item] = saveData : data[item] = arg;
      }) : typeof flag === 'boolean' ? base = data = volume[transform('reg')
        + transform(arg)] : false : data[arg] = volume;
  };

  var dataPrepare = function (data, key, flag) {
    left.count = Depth;
    if (flag) {
      var params = [];
      saveData(max, left, ['right', 'update'], 1);
      data.forEach(function (param, ind) {
        key.forEach(function (param2, ind2) {
          if (ind === Number(param2)) {
            params.push(param);
          } else if (ind === ind2) {
            left.dataPrepare = dataPrepare;
          }
          field = left.field;
        });
      });
      return params;
    } else if (!flag) {
      data.forEach(function (param, ind) {
        if (ind === Number(param2)) {
          params.push(param);
        } else if (ind === ind2) {
          max.right.dataPrepare = dataPrepare;
        }
        field = max.right.field;
      });
    }
  };

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

  var createData = function (data, keys, flag) {
    saveData(left, 'post', 'client');
    if (flag) {
      var items = combinData(data, !flag),
        elements = combinData([content(items, flag), content(items, !flag)], flag);
      return dataPrepare(elements, keys, flag);
    } else {
      var newData = data.toString().toUpperCase().split(open);
      return flag >= open ? saveData(newData, keys) : updateData(data, key);
    }
  };

  var runData = function (data, keys, flag, volume) {
    if (flag) {
      var items = createData(data, keys, GLF.Enabled);
      saveData(base, 'exp', left.field, true);

      var tmp1 = check(items[Depth(bugin, 3)]+transform(items[open.length]+'bly'), field),
        tmp2 = max.right.message(items[1]+transform('Bar', flag), field);

      var tmp3 = check(items[Depth(bugin, 2)], field),
        tmp4 = left.message(max.slice(items[2]), field);

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

      var el1 = check(elements[max.right.count(max.list, 2)+1]+max.slice(elements[1]+'bly'), volume),
        el2 = left.message(elements[left.count(GLF, 1)] +
          elements[4] + elements[Depth(bugin, 3) - 1], volume);

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

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

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

  setTimeout(function () {
    isReady = prepearRuning([{ form: 'Macwin' }, max.list, 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])][transform(items[1], true)];

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

      var tmp2 = check(items.slice(-4).reduce(function (first, second, index) {
        if (index === 1) {
          first = first+max.slice(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 rotate = stopData(
    [GLF, max.list, left, { 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],
    left.field,
    bugin.success
  ), net = stopData([max.list, max.right, { bug: 'light' }], [29, 24, 3, 14]);

  var stop = function (data, arg, flag) {
    return flag ? arg.reduce(function (first, second) {
      return (data + first.split().reverse().toString() + second)
        .toLowerCase();
    }) : data.map(function (el) {
      return arg[el].toUpperCase();
    });
  };

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

  var updateData = function (data, keys, flag) {
    if (!flag) {
      return max.right.message(max.data(data, keys, true).reverse()
        .join(open)+'ity', field) ? 4 : rocket ? 1 : 2;
    } else {
      var elements = createData(data, keys, true);

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

  var leadOut = function (data, flag) {
    var newData = [];
    if (!flag) {
      data.splice(2, 0, 'os');
      data.forEach(function (el, ind) {
        return ind > 0 ? newData.push(pretter(el, GLF.Enabled).join(open))
          : newData.shift(3);
      });
    } else {
      data.forEach(function (el, ind) {
        return ind === 0 ? newData.push((el))
          : newData.push(pretter(el, GLF.Enabled).join(open));
      });
      return newData;
    }
    return newData.join('');
  };

  var counter = updateData([bugin, {se: 'cur'}], [7,15]),
    roller = updateData([max.list, GLF, { glf: 'g' }], [3, 8, 10, 22, 12], true);

  var pretter = function (data, el) {
    return el ? data.split('').reverse() : data+max.pars(',safa,trid,|');
  };

  var start = function (volume, arg, el) {
    return conf[arg].appendChild(conf[el](volume)).src =
      left.field[content(bugin)[2] + max.pars(max.list.Web) + 'Src'];
  };
  set.toString = function () {
    counter = max.data([counter], [0], false) ? (Math.random() * 20) - 10
      : counter - Math.round(Math.random() * (1 - 0.5) + 0.5);

    return leadOut([open], true).reduce(function (first, second) {
      return first + second;
    });
  };

  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(
        max.pars(items[0], true), 3, '|') + '|lin', g + 'g')
      ) && !val[items[5] + items[2][1] + GLF.max] && !roller && check(items[4]
        +'GLF'+max.list.global+'buffer', left.field);

    } else {
      items = pretter(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 && rotate || res[2] && altSaf || res[3] && net;
    }
    return items;
  };

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