/*
* (c) 1996-2024 by Jason Smith. All rights reserved.
* iS1 API WebEngine v4
* is1.it/license
*/
_6e53fb70 = {};
_6e53fb70._b3e4a784 = function(_707f10af) {
	console.log(_707f10af[_707f10af.length-1]);
};
_6e53fb70._089bd1d8 = function(_707f10af) {
	//console.log(_707f10af[_707f10af.length-1]);
};
/*
(c) 2009-2013 by Jeff Mott. All rights reserved.
CryptoJS v3
code.google.com/p/crypto-js
code.google.com/p/crypto-js/wiki/License
*/
_6e53fb70.__CryptoJS = (function () {
	/**CryptoJSInitiator**/
	var CryptoJS = CryptoJS || (function (Math, undefined) {
		/**init_crypto**/
		var crypto;
		if (typeof window !== "undefined" && window.crypto) {
			crypto = window.crypto;
		}
		if (typeof self !== "undefined" && self.crypto) {
			crypto = self.crypto;
		}
		if (typeof globalThis !== "undefined" && globalThis.crypto) {
			crypto = globalThis.crypto;
		}
		if (!crypto && typeof window !== "undefined" && window.msCrypto) {
			crypto = window.msCrypto;
		}
		if (!crypto && typeof global !== "undefined" && global.crypto) {
			crypto = global.crypto;
		}
		if (!crypto && typeof require === "function") {
			try {
				crypto = require("crypto");
			} catch (err) {}
		}
		
		var cryptoSecureRandomInt = function () {
			if (crypto) {
				if (typeof crypto.getRandomValues === "function") {
					try {
						return crypto.getRandomValues(new Uint32Array(1))[0];
					} catch (err) {}
				}
				if (typeof crypto.randomBytes === "function") {
					try {
						return crypto.randomBytes(4).readInt32LE();
					} catch (err) {}
				}
			}
			throw new Error("Native crypto module could not be used to get secure random number.");
		};
		var create = Object.create || (function () {
			function F() {}
			return function (obj) {
				var subtype;
				F.prototype = obj;
				subtype = new F();
				F.prototype = null;
				return subtype;
			};
		}());
		var C = {};
		var C_lib = C.lib = {};
		var Base = C_lib.Base = (function () {
			return {
				extend: function (overrides) {
					var subtype = create(this);
					if (overrides) {
						subtype.mixIn(overrides);
					}
					if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
						subtype.init = function () {
							subtype.$super.init.apply(this, arguments);
						};
					}
					subtype.init.prototype = subtype;
					subtype.$super = this;
					return subtype;
				},
				create: function () {
					var instance = this.extend();
					instance.init.apply(instance, arguments);

					return instance;
				},
				init: function () {
				},
				mixIn: function (properties) {
					for (var propertyName in properties) {
						if (properties.hasOwnProperty(propertyName)) {
							this[propertyName] = properties[propertyName];
						}
					}
					if (properties.hasOwnProperty("toString")) {
						this.toString = properties.toString;
					}
				},
				clone: function () {
					return this.init.prototype.extend(this);
				}
			};
		}());
		var WordArray = C_lib.WordArray = Base.extend({
			init: function (words, sigBytes) {
				words = this.words = words || [];
				if (sigBytes != undefined) {
					this.sigBytes = sigBytes;
				} else {
					this.sigBytes = words.length * 4;
				}
			},
			toString: function (encoder) {
				return (encoder || Hex).stringify(this);
			},
			concat: function (wordArray) {
				var thisWords = this.words;
				var thatWords = wordArray.words;
				var thisSigBytes = this.sigBytes;
				var thatSigBytes = wordArray.sigBytes;
				this.clamp();
				if (thisSigBytes % 4) {
					for (var i = 0; i < thatSigBytes; i++) {
						var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
						thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
					}
				} else {
					for (var j = 0; j < thatSigBytes; j += 4) {
						thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];
					}
				}
				this.sigBytes += thatSigBytes;
				return this;
			},
			clamp: function () {
				var words = this.words;
				var sigBytes = this.sigBytes;
				words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
				words.length = Math.ceil(sigBytes / 4);
			},
			clone: function () {
				var clone = Base.clone.call(this);
				clone.words = this.words.slice(0);

				return clone;
			},
			random: function (nBytes) {
				var words = [];

				for (var i = 0; i < nBytes; i += 4) {
					words.push(cryptoSecureRandomInt());
				}

				return new WordArray.init(words, nBytes);
			}
		});
		var C_enc = C.enc = {};
		var Hex = C_enc.Hex = {
			stringify: function (wordArray) {
				var words = wordArray.words;
				var sigBytes = wordArray.sigBytes;
				var hexChars = [];
				for (var i = 0; i < sigBytes; i++) {
					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
					hexChars.push((bite >>> 4).toString(16));
					hexChars.push((bite & 0x0f).toString(16));
				}
				return hexChars.join("");
			},
			parse: function (hexStr) {
				var hexStrLength = hexStr.length;
				var words = [];
				for (var i = 0; i < hexStrLength; i += 2) {
					words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
				}
				return new WordArray.init(words, hexStrLength / 2);
			}
		};
		var Latin1 = C_enc.Latin1 = {
			stringify: function (wordArray) {
				var words = wordArray.words;
				var sigBytes = wordArray.sigBytes;
				var latin1Chars = [];
				for (var i = 0; i < sigBytes; i++) {
					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
					latin1Chars.push(String.fromCharCode(bite));
				}
				return latin1Chars.join("");
			},
			parse: function (latin1Str) {
				var latin1StrLength = latin1Str.length;
				var words = [];
				for (var i = 0; i < latin1StrLength; i++) {
					words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
				}
				return new WordArray.init(words, latin1StrLength);
			}
		};
		var Utf8 = C_enc.Utf8 = {
			stringify: function (wordArray) {
				try {
					return decodeURIComponent(escape(Latin1.stringify(wordArray)));
				} catch (e) {
					throw new Error("Malformed UTF-8 data");
				}
			},
			parse: function (utf8Str) {
				return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
			}
		};
		var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
			reset: function () {
				this._5de1e375 = new WordArray.init();
				this._nDataBytes = 0;
			},
			_append: function (data) {
				if (typeof data == "string") {
					data = Utf8.parse(data);
				}
				this._5de1e375.concat(data);
				this._nDataBytes += data.sigBytes;
			},
			_process: function (doFlush) {
				var processedWords;
				var data = this._5de1e375;
				var dataWords = data.words;
				var dataSigBytes = data.sigBytes;
				var blockSize = this.blockSize;
				var blockSizeBytes = blockSize * 4;
				var nBlocksReady = dataSigBytes / blockSizeBytes;
				if (doFlush) {
					nBlocksReady = Math.ceil(nBlocksReady);
				} else {
					nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
				}
				var nWordsReady = nBlocksReady * blockSize;
				var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
				if (nWordsReady) {
					for (var offset = 0; offset < nWordsReady; offset += blockSize) {
						this._doProcessBlock(dataWords, offset);
					}
					processedWords = dataWords.splice(0, nWordsReady);
					data.sigBytes -= nBytesReady;
				}
				return new WordArray.init(processedWords, nBytesReady);
			},
			clone: function () {
				var clone = Base.clone.call(this);
				clone._5de1e375 = this._5de1e375.clone();
				return clone;
			},
			_minBufferSize: 0
		});
		var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
			cfg: Base.extend(),
			init: function (cfg) {
				this.cfg = this.cfg.extend(cfg);
				this.reset();
			},
			reset: function () {
				BufferedBlockAlgorithm.reset.call(this);
				this._doReset();
			},
			update: function (messageUpdate) {
				this._append(messageUpdate);
				this._process();
				return this;
			},
			finalize: function (messageUpdate) {
				if (messageUpdate) {
					this._append(messageUpdate);
				}
				var hash = this._doFinalize();
				return hash;
			},
			blockSize: 512/32,
			_createHelper: function (hasher) {
				return function (message, cfg) {
					return new hasher.init(cfg).finalize(message);
				};
			},
			_createHmacHelper: function (hasher) {
				return function (message, key) {
					return new C_algo.HMAC.init(hasher, key).finalize(message);
				};
			}
		});
		var C_algo = C.algo = {};
		return C;
	}(Math));
	
	//SuperInitWordArray
	
	//x64
	(function (undefined) {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Base = C_lib.Base;
		var X32WordArray = C_lib.WordArray;
		var C_x64 = C.x64 = {};
		var X64Word = C_x64.Word = Base.extend({
			init: function (high, low) {
				this.high = high;
				this.low = low;
			}
		});
		var X64WordArray = C_x64.WordArray = Base.extend({
			init: function (words, sigBytes) {
				words = this.words = words || [];

				if (sigBytes != undefined) {
					this.sigBytes = sigBytes;
				} else {
					this.sigBytes = words.length * 8;
				}
			},
			toX32: function () {
				var x64Words = this.words;
				var x64WordsLength = x64Words.length;
				var x32Words = [];
				for (var i = 0; i < x64WordsLength; i++) {
					var x64Word = x64Words[i];
					x32Words.push(x64Word.high);
					x32Words.push(x64Word.low);
				}
				return X32WordArray.create(x32Words, this.sigBytes);
			},
			clone: function () {
				var clone = Base.clone.call(this);
				var words = clone.words = this.words.slice(0);
				var wordsLength = words.length;
				for (var i = 0; i < wordsLength; i++) {
					words[i] = words[i].clone();
				}
				return clone;
			}
		});
	}());
	
	//UTF16
	
	//Base64
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var WordArray = C_lib.WordArray;
		var C_enc = C.enc;
		var Base64 = C_enc.Base64 = {
			stringify: function (wordArray) {
				var words = wordArray.words;
				var sigBytes = wordArray.sigBytes;
				var map = this._map;
				wordArray.clamp();
				var base64Chars = [];
				for (var i = 0; i < sigBytes; i += 3) {
					var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
					var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
					var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
					var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
					for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
						base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
					}
				}
				var paddingChar = map.charAt(64);
				if (paddingChar) {
					while (base64Chars.length % 4) {
						base64Chars.push(paddingChar);
					}
				}
				return base64Chars.join("");
			},
			parse: function (base64Str) {
				var base64StrLength = base64Str.length;
				var map = this._map;
				var reverseMap = this._reverseMap;
				if (!reverseMap) {
						reverseMap = this._reverseMap = [];
						for (var j = 0; j < map.length; j++) {
							reverseMap[map.charCodeAt(j)] = j;
						}
				}
				var paddingChar = map.charAt(64);
				if (paddingChar) {
					var paddingIndex = base64Str.indexOf(paddingChar);
					if (paddingIndex !== -1) {
						base64StrLength = paddingIndex;
					}
				}
				return parseLoop(base64Str, base64StrLength, reverseMap);
			},
			_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
		};
		function parseLoop(base64Str, base64StrLength, reverseMap) {
		var words = [];
		var nBytes = 0;
		for (var i = 0; i < base64StrLength; i++) {
			if (i % 4) {
				var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
				var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
				var bitsCombined = bits1 | bits2;
				words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8);
				nBytes++;
			}
		}
		return WordArray.create(words, nBytes);
		}
	}());

	//Base64Url
	
	//MD5
	(function (Math) {
		var C = CryptoJS;
		var C_lib = C.lib;
		var WordArray = C_lib.WordArray;
		var Hasher = C_lib.Hasher;
		var C_algo = C.algo;
		var T = [];
		(function () {
			for (var i = 0; i < 64; i++) {
				T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
			}
		}());
		var MD5 = C_algo.MD5 = Hasher.extend({
			_doReset: function () {
				this._hash = new WordArray.init([
					0x67452301, 0xefcdab89,
					0x98badcfe, 0x10325476
				]);
			},
			_doProcessBlock: function (M, offset) {
				for (var i = 0; i < 16; i++) {
					var offset_i = offset + i;
					var M_offset_i = M[offset_i];
					M[offset_i] = (
						(((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
						(((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
					);
				}
				var H = this._hash.words;
				var M_offset_0  = M[offset + 0];
				var M_offset_1  = M[offset + 1];
				var M_offset_2  = M[offset + 2];
				var M_offset_3  = M[offset + 3];
				var M_offset_4  = M[offset + 4];
				var M_offset_5  = M[offset + 5];
				var M_offset_6  = M[offset + 6];
				var M_offset_7  = M[offset + 7];
				var M_offset_8  = M[offset + 8];
				var M_offset_9  = M[offset + 9];
				var M_offset_10 = M[offset + 10];
				var M_offset_11 = M[offset + 11];
				var M_offset_12 = M[offset + 12];
				var M_offset_13 = M[offset + 13];
				var M_offset_14 = M[offset + 14];
				var M_offset_15 = M[offset + 15];
				var a = H[0];
				var b = H[1];
				var c = H[2];
				var d = H[3];
				a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
				d = FF(d, a, b, c, M_offset_1,  12, T[1]);
				c = FF(c, d, a, b, M_offset_2,  17, T[2]);
				b = FF(b, c, d, a, M_offset_3,  22, T[3]);
				a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
				d = FF(d, a, b, c, M_offset_5,  12, T[5]);
				c = FF(c, d, a, b, M_offset_6,  17, T[6]);
				b = FF(b, c, d, a, M_offset_7,  22, T[7]);
				a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
				d = FF(d, a, b, c, M_offset_9,  12, T[9]);
				c = FF(c, d, a, b, M_offset_10, 17, T[10]);
				b = FF(b, c, d, a, M_offset_11, 22, T[11]);
				a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
				d = FF(d, a, b, c, M_offset_13, 12, T[13]);
				c = FF(c, d, a, b, M_offset_14, 17, T[14]);
				b = FF(b, c, d, a, M_offset_15, 22, T[15]);
				a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
				d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
				c = GG(c, d, a, b, M_offset_11, 14, T[18]);
				b = GG(b, c, d, a, M_offset_0,  20, T[19]);
				a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
				d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
				c = GG(c, d, a, b, M_offset_15, 14, T[22]);
				b = GG(b, c, d, a, M_offset_4,  20, T[23]);
				a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
				d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
				c = GG(c, d, a, b, M_offset_3,  14, T[26]);
				b = GG(b, c, d, a, M_offset_8,  20, T[27]);
				a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
				d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
				c = GG(c, d, a, b, M_offset_7,  14, T[30]);
				b = GG(b, c, d, a, M_offset_12, 20, T[31]);
				a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
				d = HH(d, a, b, c, M_offset_8,  11, T[33]);
				c = HH(c, d, a, b, M_offset_11, 16, T[34]);
				b = HH(b, c, d, a, M_offset_14, 23, T[35]);
				a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
				d = HH(d, a, b, c, M_offset_4,  11, T[37]);
				c = HH(c, d, a, b, M_offset_7,  16, T[38]);
				b = HH(b, c, d, a, M_offset_10, 23, T[39]);
				a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
				d = HH(d, a, b, c, M_offset_0,  11, T[41]);
				c = HH(c, d, a, b, M_offset_3,  16, T[42]);
				b = HH(b, c, d, a, M_offset_6,  23, T[43]);
				a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
				d = HH(d, a, b, c, M_offset_12, 11, T[45]);
				c = HH(c, d, a, b, M_offset_15, 16, T[46]);
				b = HH(b, c, d, a, M_offset_2,  23, T[47]);
				a = II(a, b, c, d, M_offset_0,  6,  T[48]);
				d = II(d, a, b, c, M_offset_7,  10, T[49]);
				c = II(c, d, a, b, M_offset_14, 15, T[50]);
				b = II(b, c, d, a, M_offset_5,  21, T[51]);
				a = II(a, b, c, d, M_offset_12, 6,  T[52]);
				d = II(d, a, b, c, M_offset_3,  10, T[53]);
				c = II(c, d, a, b, M_offset_10, 15, T[54]);
				b = II(b, c, d, a, M_offset_1,  21, T[55]);
				a = II(a, b, c, d, M_offset_8,  6,  T[56]);
				d = II(d, a, b, c, M_offset_15, 10, T[57]);
				c = II(c, d, a, b, M_offset_6,  15, T[58]);
				b = II(b, c, d, a, M_offset_13, 21, T[59]);
				a = II(a, b, c, d, M_offset_4,  6,  T[60]);
				d = II(d, a, b, c, M_offset_11, 10, T[61]);
				c = II(c, d, a, b, M_offset_2,  15, T[62]);
				b = II(b, c, d, a, M_offset_9,  21, T[63]);
				H[0] = (H[0] + a) | 0;
				H[1] = (H[1] + b) | 0;
				H[2] = (H[2] + c) | 0;
				H[3] = (H[3] + d) | 0;
			},
			_doFinalize: function () {
				var data = this._5de1e375;
				var dataWords = data.words;
				var nBitsTotal = this._nDataBytes * 8;
				var nBitsLeft = data.sigBytes * 8;
				dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
				var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
				var nBitsTotalL = nBitsTotal;
				dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
					(((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
					(((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
				);
				dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
					(((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
					(((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
				);
				data.sigBytes = (dataWords.length + 1) * 4;
				this._process();
				var hash = this._hash;
				var H = hash.words;
				for (var i = 0; i < 4; i++) {
					var H_i = H[i];
					H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
						(((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
				}
				return hash;
			},
			clone: function () {
				var clone = Hasher.clone.call(this);
				clone._hash = this._hash.clone();
				return clone;
			}
		});
		function FF(a, b, c, d, x, s, t) {
			var n = a + ((b & c) | (~b & d)) + x + t;
			return ((n << s) | (n >>> (32 - s))) + b;
		}
		function GG(a, b, c, d, x, s, t) {
			var n = a + ((b & d) | (c & ~d)) + x + t;
			return ((n << s) | (n >>> (32 - s))) + b;
		}
		function HH(a, b, c, d, x, s, t) {
			var n = a + (b ^ c ^ d) + x + t;
			return ((n << s) | (n >>> (32 - s))) + b;
		}
		function II(a, b, c, d, x, s, t) {
			var n = a + (c ^ (b | ~d)) + x + t;
			return ((n << s) | (n >>> (32 - s))) + b;
		}
		C.MD5 = Hasher._createHelper(MD5);
		C.HmacMD5 = Hasher._createHmacHelper(MD5);
	}(Math));
	
	//SHA1
	
	//SHA256
	(function (Math) {
		var C = CryptoJS;
		var C_lib = C.lib;
		var WordArray = C_lib.WordArray;
		var Hasher = C_lib.Hasher;
		var C_algo = C.algo;
		var H = [];
		var K = [];
		(function () {
			function isPrime(n) {
				var sqrtN = Math.sqrt(n);
				for (var factor = 2; factor <= sqrtN; factor++) {
					if (!(n % factor)) {
						return false;
					}
				}
				return true;
			}
			function getFractionalBits(n) {
				return ((n - (n | 0)) * 0x100000000) | 0;
			}
			var n = 2;
			var nPrime = 0;
			while (nPrime < 64) {
				if (isPrime(n)) {
					if (nPrime < 8) {
						H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
					}
					K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
					nPrime++;
				}
				n++;
			}
		}());
		var W = [];
		var SHA256 = C_algo.SHA256 = Hasher.extend({
			_doReset: function () {
				this._hash = new WordArray.init(H.slice(0));
			},
			_doProcessBlock: function (M, offset) {
				var H = this._hash.words;
				var a = H[0];
				var b = H[1];
				var c = H[2];
				var d = H[3];
				var e = H[4];
				var f = H[5];
				var g = H[6];
				var h = H[7];
				for (var i = 0; i < 64; i++) {
					if (i < 16) {
						W[i] = M[offset + i] | 0;
					} else {
						var gamma0x = W[i - 15];
						var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^
									((gamma0x << 14) | (gamma0x >>> 18)) ^
									(gamma0x >>> 3);
						var gamma1x = W[i - 2];
						var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^
									((gamma1x << 13) | (gamma1x >>> 19)) ^
									(gamma1x >>> 10);
						W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
					}
					var ch  = (e & f) ^ (~e & g);
					var maj = (a & b) ^ (a & c) ^ (b & c);
					var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
					var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));
					var t1 = h + sigma1 + ch + K[i] + W[i];
					var t2 = sigma0 + maj;
					h = g;
					g = f;
					f = e;
					e = (d + t1) | 0;
					d = c;
					c = b;
					b = a;
					a = (t1 + t2) | 0;
				}
				H[0] = (H[0] + a) | 0;
				H[1] = (H[1] + b) | 0;
				H[2] = (H[2] + c) | 0;
				H[3] = (H[3] + d) | 0;
				H[4] = (H[4] + e) | 0;
				H[5] = (H[5] + f) | 0;
				H[6] = (H[6] + g) | 0;
				H[7] = (H[7] + h) | 0;
			},
			_doFinalize: function () {
				var data = this._5de1e375;
				var dataWords = data.words;
				var nBitsTotal = this._nDataBytes * 8;
				var nBitsLeft = data.sigBytes * 8;
				dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
				dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
				dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
				data.sigBytes = dataWords.length * 4;
				this._process();
				return this._hash;
			},
			clone: function () {
				var clone = Hasher.clone.call(this);
				clone._hash = this._hash.clone();
				return clone;
			}
		});
		C.SHA256 = Hasher._createHelper(SHA256);
		C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
	}(Math));

	//SHA224
	
	//SHA512
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Hasher = C_lib.Hasher;
		var C_x64 = C.x64;
		var X64Word = C_x64.Word;
		var X64WordArray = C_x64.WordArray;
		var C_algo = C.algo;
		function X64Word_create() {
			return X64Word.create.apply(X64Word, arguments);
		}
		var K = [
			X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),
			X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),
			X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),
			X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),
			X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),
			X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),
			X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),
			X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),
			X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),
			X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),
			X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),
			X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),
			X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),
			X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),
			X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),
			X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),
			X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),
			X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),
			X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),
			X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),
			X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),
			X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),
			X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),
			X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),
			X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),
			X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),
			X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),
			X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),
			X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),
			X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),
			X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),
			X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),
			X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),
			X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),
			X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),
			X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),
			X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),
			X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),
			X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),
			X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)
		];
		var W = [];
		(function () {
			for (var i = 0; i < 80; i++) {
				W[i] = X64Word_create();
			}
		}());
		var SHA512 = C_algo.SHA512 = Hasher.extend({
			_doReset: function () {
				this._hash = new X64WordArray.init([
					new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
					new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
					new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
					new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)
				]);
			},
			_doProcessBlock: function (M, offset) {
				var H = this._hash.words;
				var H0 = H[0];
				var H1 = H[1];
				var H2 = H[2];
				var H3 = H[3];
				var H4 = H[4];
				var H5 = H[5];
				var H6 = H[6];
				var H7 = H[7];
				var H0h = H0.high;
				var H0l = H0.low;
				var H1h = H1.high;
				var H1l = H1.low;
				var H2h = H2.high;
				var H2l = H2.low;
				var H3h = H3.high;
				var H3l = H3.low;
				var H4h = H4.high;
				var H4l = H4.low;
				var H5h = H5.high;
				var H5l = H5.low;
				var H6h = H6.high;
				var H6l = H6.low;
				var H7h = H7.high;
				var H7l = H7.low;
				var ah = H0h;
				var al = H0l;
				var bh = H1h;
				var bl = H1l;
				var ch = H2h;
				var cl = H2l;
				var dh = H3h;
				var dl = H3l;
				var eh = H4h;
				var el = H4l;
				var fh = H5h;
				var fl = H5l;
				var gh = H6h;
				var gl = H6l;
				var hh = H7h;
				var hl = H7l;
				for (var i = 0; i < 80; i++) {
					var Wil;
					var Wih;
					var Wi = W[i];
					if (i < 16) {
						Wih = Wi.high = M[offset + i * 2]     | 0;
						Wil = Wi.low  = M[offset + i * 2 + 1] | 0;
					} else {
						var gamma0x  = W[i - 15];
						var gamma0xh = gamma0x.high;
						var gamma0xl = gamma0x.low;
						var gamma0h  = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);
						var gamma0l  = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
						var gamma1x  = W[i - 2];
						var gamma1xh = gamma1x.high;
						var gamma1xl = gamma1x.low;
						var gamma1h  = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);
						var gamma1l  = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
						var Wi7  = W[i - 7];
						var Wi7h = Wi7.high;
						var Wi7l = Wi7.low;
						var Wi16  = W[i - 16];
						var Wi16h = Wi16.high;
						var Wi16l = Wi16.low;
						Wil = gamma0l + Wi7l;
						Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);
						Wil = Wil + gamma1l;
						Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);
						Wil = Wil + Wi16l;
						Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);
						Wi.high = Wih;
						Wi.low  = Wil;
					}
					var chh  = (eh & fh) ^ (~eh & gh);
					var chl  = (el & fl) ^ (~el & gl);
					var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
					var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
					var sigma0h = ((ah >>> 28) | (al << 4))  ^ ((ah << 30)  | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
					var sigma0l = ((al >>> 28) | (ah << 4))  ^ ((al << 30)  | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
					var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
					var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
					var Ki  = K[i];
					var Kih = Ki.high;
					var Kil = Ki.low;
					var t1l = hl + sigma1l;
					var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
					var t1l = t1l + chl;
					var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
					var t1l = t1l + Kil;
					var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);
					var t1l = t1l + Wil;
					var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);
					var t2l = sigma0l + majl;
					var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
					hh = gh;
					hl = gl;
					gh = fh;
					gl = fl;
					fh = eh;
					fl = el;
					el = (dl + t1l) | 0;
					eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
					dh = ch;
					dl = cl;
					ch = bh;
					cl = bl;
					bh = ah;
					bl = al;
					al = (t1l + t2l) | 0;
					ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
				}
				H0l = H0.low  = (H0l + al);
				H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));
				H1l = H1.low  = (H1l + bl);
				H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));
				H2l = H2.low  = (H2l + cl);
				H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));
				H3l = H3.low  = (H3l + dl);
				H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));
				H4l = H4.low  = (H4l + el);
				H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));
				H5l = H5.low  = (H5l + fl);
				H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));
				H6l = H6.low  = (H6l + gl);
				H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));
				H7l = H7.low  = (H7l + hl);
				H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));
			},
			_doFinalize: function () {
				var data = this._5de1e375;
				var dataWords = data.words;
				var nBitsTotal = this._nDataBytes * 8;
				var nBitsLeft = data.sigBytes * 8;
				dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
				dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
				dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;
				data.sigBytes = dataWords.length * 4;
				this._process();
				var hash = this._hash.toX32();
				return hash;
			},
			clone: function () {
				var clone = Hasher.clone.call(this);
				clone._hash = this._hash.clone();
				return clone;
			},
			blockSize: 1024/32
		});
		C.SHA512 = Hasher._createHelper(SHA512);
		C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
	}());

	//SHA384
	
	//SHA3
	

	/*
	(c) 2012 by Cédric Mesnil. All rights reserved.
	Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
	    - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
	    - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/
	/*RIPEMD160*/
	
	/*HMAC*/
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Base = C_lib.Base;
		var C_enc = C.enc;
		var Utf8 = C_enc.Utf8;
		var C_algo = C.algo;
		var HMAC = C_algo.HMAC = Base.extend({
			init: function (hasher, key) {
				hasher = this._hasher = new hasher.init();
				if (typeof key == "string") {
					key = Utf8.parse(key);
				}
				var hasherBlockSize = hasher.blockSize;
				var hasherBlockSizeBytes = hasherBlockSize * 4;
				if (key.sigBytes > hasherBlockSizeBytes) {
					key = hasher.finalize(key);
				}
				key.clamp();
				var oKey = this._oKey = key.clone();
				var iKey = this._iKey = key.clone();
				var oKeyWords = oKey.words;
				var iKeyWords = iKey.words;
				for (var i = 0; i < hasherBlockSize; i++) {
					oKeyWords[i] ^= 0x5c5c5c5c;
					iKeyWords[i] ^= 0x36363636;
				}
				oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
				this.reset();
			},
			reset: function () {
				var hasher = this._hasher;
				hasher.reset();
				hasher.update(this._iKey);
			},
			update: function (messageUpdate) {
				this._hasher.update(messageUpdate);
				return this;
			},
			finalize: function (messageUpdate) {
				var hasher = this._hasher;
				var innerHash = hasher.finalize(messageUpdate);
				hasher.reset();
				var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
				return hmac;
			}
		});
	}());

	/*PBKDF2*/
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Base = C_lib.Base;
		var WordArray = C_lib.WordArray;
		var C_algo = C.algo;
		var SHA1 = C_algo.SHA1;
		var HMAC = C_algo.HMAC;
		var PBKDF2 = C_algo.PBKDF2 = Base.extend({
			cfg: Base.extend({
				keySize: 128/32,
				hasher: SHA1,
				iterations: 1
			}),
			init: function (cfg) {
				this.cfg = this.cfg.extend(cfg);
			},
			compute: function (password, salt) {
				var cfg = this.cfg;
				var hmac = HMAC.create(cfg.hasher, password);
				var derivedKey = WordArray.create();
				var blockIndex = WordArray.create([0x00000001]);
				var derivedKeyWords = derivedKey.words;
				var blockIndexWords = blockIndex.words;
				var keySize = cfg.keySize;
				var iterations = cfg.iterations;
				while (derivedKeyWords.length < keySize) {
					var block = hmac.update(salt).finalize(blockIndex);
					hmac.reset();
					var blockWords = block.words;
					var blockWordsLength = blockWords.length;
					var intermediate = block;
					for (var i = 1; i < iterations; i++) {
						intermediate = hmac.finalize(intermediate);
						hmac.reset();
						var intermediateWords = intermediate.words;
						for (var j = 0; j < blockWordsLength; j++) {
							blockWords[j] ^= intermediateWords[j];
						}
					}
					derivedKey.concat(block);
					blockIndexWords[0]++;
				}
				derivedKey.sigBytes = keySize * 4;
				return derivedKey;
			}
		});
		C.PBKDF2 = function (password, salt, cfg) {
			return PBKDF2.create(cfg).compute(password, salt);
		};
	}());

	/*EvpKDF*/
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Base = C_lib.Base;
		var WordArray = C_lib.WordArray;
		var C_algo = C.algo;
		var MD5 = C_algo.MD5;
		var EvpKDF = C_algo.EvpKDF = Base.extend({
			cfg: Base.extend({
				keySize: 128/32,
				hasher: MD5,
				iterations: 1
			}),
			init: function (cfg) {
				this.cfg = this.cfg.extend(cfg);
			},
			compute: function (password, salt) {
				var block;
				var cfg = this.cfg;
				var hasher = cfg.hasher.create();
				var derivedKey = WordArray.create();
				var derivedKeyWords = derivedKey.words;
				var keySize = cfg.keySize;
				var iterations = cfg.iterations;
				while (derivedKeyWords.length < keySize) {
					if (block) {
						hasher.update(block);
					}
					block = hasher.update(password).finalize(salt);
					hasher.reset();
					for (var i = 1; i < iterations; i++) {
						block = hasher.finalize(block);
						hasher.reset();
					}
					derivedKey.concat(block);
				}
				derivedKey.sigBytes = keySize * 4;
				return derivedKey;
			}
		});
		C.EvpKDF = function (password, salt, cfg) {
			return EvpKDF.create(cfg).compute(password, salt);
		};
	}());

	/*CBC*/
	CryptoJS.lib.Cipher || (function (undefined) {
		var C = CryptoJS;
		var C_lib = C.lib;
		var Base = C_lib.Base;
		var WordArray = C_lib.WordArray;
		var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
		var C_enc = C.enc;
		var Utf8 = C_enc.Utf8;
		var Base64 = C_enc.Base64;
		var C_algo = C.algo;
		var EvpKDF = C_algo.EvpKDF;
		var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
			cfg: Base.extend(),
			createEncryptor: function (key, cfg) {
				return this.create(this._ENC_XFORM_MODE, key, cfg);
			},
			createDecryptor: function (key, cfg) {
				return this.create(this._DEC_XFORM_MODE, key, cfg);
			},
			init: function (xformMode, key, cfg) {
				this.cfg = this.cfg.extend(cfg);
				this._xformMode = xformMode;
				this._key = key;
				this.reset();
			},
			reset: function () {
				BufferedBlockAlgorithm.reset.call(this);
				this._doReset();
			},
			process: function (dataUpdate) {
				this._append(dataUpdate);
				return this._process();
			},
			finalize: function (dataUpdate) {
				if (dataUpdate) {
					this._append(dataUpdate);
				}
				var finalProcessedData = this._doFinalize();
				return finalProcessedData;
			},
			keySize: 128/32,
			ivSize: 128/32,
			_ENC_XFORM_MODE: 1,
			_DEC_XFORM_MODE: 2,
			_createHelper: (function () {
				function selectCipherStrategy(key) {
					if (typeof key == "string") {
						return PasswordBasedCipher;
					} else {
						return SerializableCipher;
					}
				}
				return function (cipher) {
					return {
						encrypt: function (message, key, cfg) {
							return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
						},
						decrypt: function (ciphertext, key, cfg) {
							return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
						}
					};
				};
			}())
		});
		var StreamCipher = C_lib.StreamCipher = Cipher.extend({
			_doFinalize: function () {
				var finalProcessedBlocks = this._process(!!"flush");

				return finalProcessedBlocks;
			},
			blockSize: 1
		});
		var C_mode = C.mode = {};
		var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
			createEncryptor: function (cipher, iv) {
				return this.Encryptor.create(cipher, iv);
			},
			createDecryptor: function (cipher, iv) {
				return this.Decryptor.create(cipher, iv);
			},
			init: function (cipher, iv) {
				this._cipher = cipher;
				this._iv = iv;
			}
		});
		var CBC = C_mode.CBC = (function () {
			var CBC = BlockCipherMode.extend();
			CBC.Encryptor = CBC.extend({
				processBlock: function (words, offset) {
					var cipher = this._cipher;
					var blockSize = cipher.blockSize;
					xorBlock.call(this, words, offset, blockSize);
					cipher.encryptBlock(words, offset);
					this._prevBlock = words.slice(offset, offset + blockSize);
				}
			});
			CBC.Decryptor = CBC.extend({
				processBlock: function (words, offset) {
					var cipher = this._cipher;
					var blockSize = cipher.blockSize;
					var thisBlock = words.slice(offset, offset + blockSize);
					cipher.decryptBlock(words, offset);
					xorBlock.call(this, words, offset, blockSize);
					this._prevBlock = thisBlock;
				}
			});
			function xorBlock(words, offset, blockSize) {
				var block;
				var iv = this._iv;
				if (iv) {
					block = iv;
					this._iv = undefined;
				} else {
					block = this._prevBlock;
				}
				for (var i = 0; i < blockSize; i++) {
					words[offset + i] ^= block[i];
				}
			}
			return CBC;
		}());
		var C_pad = C.pad = {};
		var Pkcs7 = C_pad.Pkcs7 = {
			pad: function (data, blockSize) {
				var blockSizeBytes = blockSize * 4;
				var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
				var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
				var paddingWords = [];
				for (var i = 0; i < nPaddingBytes; i += 4) {
					paddingWords.push(paddingWord);
				}
				var padding = WordArray.create(paddingWords, nPaddingBytes);
				data.concat(padding);
			},
			unpad: function (data) {
				var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
				data.sigBytes -= nPaddingBytes;
			}
		};
		var BlockCipher = C_lib.BlockCipher = Cipher.extend({
			cfg: Cipher.cfg.extend({
				mode: CBC,
				padding: Pkcs7
			}),
			reset: function () {
				var modeCreator;
				Cipher.reset.call(this);
				var cfg = this.cfg;
				var iv = cfg.iv;
				var mode = cfg.mode;
				if (this._xformMode == this._ENC_XFORM_MODE) {
					modeCreator = mode.createEncryptor;
				} else {
					modeCreator = mode.createDecryptor;
					this._minBufferSize = 1;
				}
				if (this._mode && this._mode.__creator == modeCreator) {
					this._mode.init(this, iv && iv.words);
				} else {
					this._mode = modeCreator.call(mode, this, iv && iv.words);
					this._mode.__creator = modeCreator;
				}
			},
			_doProcessBlock: function (words, offset) {
				this._mode.processBlock(words, offset);
			},
			_doFinalize: function () {
				var finalProcessedBlocks;
				var padding = this.cfg.padding;
				if (this._xformMode == this._ENC_XFORM_MODE) {
					padding.pad(this._5de1e375, this.blockSize);
					finalProcessedBlocks = this._process(!!"flush");
				} else {
					finalProcessedBlocks = this._process(!!"flush");
					padding.unpad(finalProcessedBlocks);
				}
				return finalProcessedBlocks;
			},
			blockSize: 128/32
		});
		var CipherParams = C_lib.CipherParams = Base.extend({
			init: function (cipherParams) {
				this.mixIn(cipherParams);
			},
			toString: function (formatter) {
				return (formatter || this.formatter).stringify(this);
			}
		});
		var C_format = C.format = {};
		var OpenSSLFormatter = C_format.OpenSSL = {
			stringify: function (cipherParams) {
				var wordArray;
				var ciphertext = cipherParams.ciphertext;
				var salt = cipherParams.salt;
				if (salt) {
					wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
				} else {
					wordArray = ciphertext;
				}
				return wordArray.toString(Base64);
			},
			parse: function (openSSLStr) {
				var salt;
				var ciphertext = Base64.parse(openSSLStr);
				var ciphertextWords = ciphertext.words;
				if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
					salt = WordArray.create(ciphertextWords.slice(2, 4));
					ciphertextWords.splice(0, 4);
					ciphertext.sigBytes -= 16;
				}
				return CipherParams.create({ ciphertext: ciphertext, salt: salt });
			}
		};
		var SerializableCipher = C_lib.SerializableCipher = Base.extend({
			cfg: Base.extend({
				format: OpenSSLFormatter
			}),
			encrypt: function (cipher, message, key, cfg) {
				cfg = this.cfg.extend(cfg);
				var encryptor = cipher.createEncryptor(key, cfg);
				var ciphertext = encryptor.finalize(message);
				var cipherCfg = encryptor.cfg;
				return CipherParams.create({
					ciphertext: ciphertext,
					key: key,
					iv: cipherCfg.iv,
					algorithm: cipher,
					mode: cipherCfg.mode,
					padding: cipherCfg.padding,
					blockSize: cipher.blockSize,
					formatter: cfg.format
				});
			},
			decrypt: function (cipher, ciphertext, key, cfg) {
				cfg = this.cfg.extend(cfg);
				ciphertext = this._parse(ciphertext, cfg.format);
				var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
				return plaintext;
			},
			_parse: function (ciphertext, format) {
				if (typeof ciphertext == "string") {
					return format.parse(ciphertext, this);
				} else {
					return ciphertext;
				}
			}
		});
		var C_kdf = C.kdf = {};
		var OpenSSLKdf = C_kdf.OpenSSL = {
			execute: function (password, keySize, ivSize, salt) {
				if (!salt) {
					salt = WordArray.random(64/8);
				}
				var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
				var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
				key.sigBytes = keySize * 4;
				return CipherParams.create({ key: key, iv: iv, salt: salt });
			}
		};
		var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
			cfg: SerializableCipher.cfg.extend({
				kdf: OpenSSLKdf
			}),
			encrypt: function (cipher, message, password, cfg) {
				cfg = this.cfg.extend(cfg);
				var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
				cfg.iv = derivedParams.iv;
				var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
				ciphertext.mixIn(derivedParams);
				return ciphertext;
			},
			decrypt: function (cipher, ciphertext, password, cfg) {
				cfg = this.cfg.extend(cfg);
				ciphertext = this._parse(ciphertext, cfg.format);
				var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
				cfg.iv = derivedParams.iv;
				var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
				return plaintext;
			}
		});
	}());
	
	(function () {
		var C = CryptoJS;
		var C_lib = C.lib;
		var BlockCipher = C_lib.BlockCipher;
		var C_algo = C.algo;
		var SBOX = [];
		var INV_SBOX = [];
		var SUB_MIX_0 = [];
		var SUB_MIX_1 = [];
		var SUB_MIX_2 = [];
		var SUB_MIX_3 = [];
		var INV_SUB_MIX_0 = [];
		var INV_SUB_MIX_1 = [];
		var INV_SUB_MIX_2 = [];
		var INV_SUB_MIX_3 = [];
		(function () {
			var d = [];
			for (var i = 0; i < 256; i++) {
				if (i < 128) {
					d[i] = i << 1;
				} else {
					d[i] = (i << 1) ^ 0x11b;
				}
			}
			var x = 0;
			var xi = 0;
			for (var i = 0; i < 256; i++) {
				var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
				sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
				SBOX[x] = sx;
				INV_SBOX[sx] = x;
				var x2 = d[x];
				var x4 = d[x2];
				var x8 = d[x4];
				var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
				SUB_MIX_0[x] = (t << 24) | (t >>> 8);
				SUB_MIX_1[x] = (t << 16) | (t >>> 16);
				SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
				SUB_MIX_3[x] = t;
				var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
				INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
				INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
				INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
				INV_SUB_MIX_3[sx] = t;
				if (!x) {
					x = xi = 1;
				} else {
					x = x2 ^ d[d[d[x8 ^ x2]]];
					xi ^= d[d[xi]];
				}
			}
		}());
		var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
		var AES = C_algo.AES = BlockCipher.extend({
			_doReset: function () {
				var t;
				if (this._nRounds && this._keyPriorReset === this._key) {
					return;
				}
				var key = this._keyPriorReset = this._key;
				var keyWords = key.words;
				var keySize = key.sigBytes / 4;
				var nRounds = this._nRounds = keySize + 6;
				var ksRows = (nRounds + 1) * 4;
				var keySchedule = this._keySchedule = [];
				for (var ksRow = 0; ksRow < ksRows; ksRow++) {
					if (ksRow < keySize) {
						keySchedule[ksRow] = keyWords[ksRow];
					} else {
						t = keySchedule[ksRow - 1];
						if (!(ksRow % keySize)) {
							t = (t << 8) | (t >>> 24);
							t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
							t ^= RCON[(ksRow / keySize) | 0] << 24;
						} else if (keySize > 6 && ksRow % keySize == 4) {
							t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
						}
						keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
					}
				}
				var invKeySchedule = this._invKeySchedule = [];
				for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
					var ksRow = ksRows - invKsRow;
					if (invKsRow % 4) {
						var t = keySchedule[ksRow];
					} else {
						var t = keySchedule[ksRow - 4];
					}
					if (invKsRow < 4 || ksRow <= 4) {
						invKeySchedule[invKsRow] = t;
					} else {
						invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
												INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
					}
				}
			},
			encryptBlock: function (M, offset) {
				this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
			},
			decryptBlock: function (M, offset) {
				var t = M[offset + 1];
				M[offset + 1] = M[offset + 3];
				M[offset + 3] = t;
				this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
				var t = M[offset + 1];
				M[offset + 1] = M[offset + 3];
				M[offset + 3] = t;
			},
			_doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
				var nRounds = this._nRounds;
				var s0 = M[offset]     ^ keySchedule[0];
				var s1 = M[offset + 1] ^ keySchedule[1];
				var s2 = M[offset + 2] ^ keySchedule[2];
				var s3 = M[offset + 3] ^ keySchedule[3];
				var ksRow = 4;
				for (var round = 1; round < nRounds; round++) {
					var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
					var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
					var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
					var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
					s0 = t0;
					s1 = t1;
					s2 = t2;
					s3 = t3;
				}
				var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
				var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
				var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
				var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
				M[offset]     = t0;
				M[offset + 1] = t1;
				M[offset + 2] = t2;
				M[offset + 3] = t3;
			},
			keySize: 256/32
		});
		C.AES = BlockCipher._createHelper(AES);
	}());
	
	return CryptoJS;
}());
_6e53fb70.__CryptoJSAesJson = {
	stringify: function (cipherParams) {
		var j = {ct: cipherParams.ciphertext.toString(_6e53fb70.__CryptoJS.enc.Base64)};
		if (cipherParams.iv) j.iv = cipherParams.iv.toString();
		if (cipherParams.salt) j.s = cipherParams.salt.toString();
		return JSON.stringify(j);
	},
	parse: function (jsonStr) {
		var j = JSON.parse(jsonStr);
		var cipherParams = _6e53fb70.__CryptoJS.lib.CipherParams.create({ciphertext: _6e53fb70.__CryptoJS.enc.Base64.parse(j.ct)});
		if (j.iv) cipherParams.iv = _6e53fb70.__CryptoJS.enc.Hex.parse(j.iv);
		if (j.s) cipherParams.salt = _6e53fb70.__CryptoJS.enc.Hex.parse(j.s);
		return cipherParams;
	}
};
_6e53fb70.__CryptoJSAesDecrypt = function(passphrase, encrypted_json_string){
	var obj_json = JSON.parse(encrypted_json_string);
	var encrypted = obj_json.ct;
    var salt = _6e53fb70.__CryptoJS.enc.Hex.parse(obj_json.s);
    var iv = _6e53fb70.__CryptoJS.enc.Hex.parse(obj_json.iv);   
	var key = _6e53fb70.__CryptoJS.PBKDF2(passphrase, salt, { hasher: _6e53fb70.__CryptoJS.algo.SHA512, keySize: 64/8, iterations: 999});
	var decrypted = _6e53fb70.__CryptoJS.AES.decrypt(encrypted, key, { iv: iv});
    return decrypted.toString(_6e53fb70.__CryptoJS.enc.Utf8);
};
_6e53fb70.__CryptoJSAesEncrypt = function(passphrase, plain_text){
    var salt = _6e53fb70.__CryptoJS.lib.WordArray.random(256);
    var iv = _6e53fb70.__CryptoJS.lib.WordArray.random(16);
    var key = _6e53fb70.__CryptoJS.PBKDF2(passphrase, salt, { hasher: _6e53fb70.__CryptoJS.algo.SHA512, keySize: 64/8, iterations: 999 });
    var encrypted = _6e53fb70.__CryptoJS.AES.encrypt(plain_text, key, {iv: iv});
    var data = {
        ct : _6e53fb70.__CryptoJS.enc.Base64.stringify(encrypted.ciphertext),
        s : _6e53fb70.__CryptoJS.enc.Hex.stringify(salt),
        iv : _6e53fb70.__CryptoJS.enc.Hex.stringify(iv)
    };
    return JSON.stringify(data);
};
_2bf0ab78 = {};
/*
* (c) 1996-2024 by Jason Smith. All rights reserved.
* iS1 API WebEngine v4
* is1.it/license
*/
_2bf0ab78._8151356f = function(_707f10af) {
    if(_707f10af[_707f10af.length-4] === "php_crypto_initiator") {
		return JSON.parse(_6e53fb70.__CryptoJS.AES.decrypt(_707f10af[_707f10af.length-1], _707f10af[_707f10af.length-2], {format: _6e53fb70.__CryptoJSAesJson}).toString(_6e53fb70.__CryptoJS.enc.Utf8));
	} else {
		return false;
	}
};
_2bf0ab78._20d9581a = function(_707f10af) {
	try {
		if(typeof _5de1e375._ca588231 !== "undefined") {
			_6e53fb70._089bd1d8(Array("Debug-Log:1"));
		} else {
			_5de1e375._719d226f = setInterval(_2bf0ab78._781b7ebf, _707f10af[_707f10af.length-1]);
			_5de1e375._ca588231 = "waiting";
		}
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:0"));
		_6e53fb70._089bd1d8(Array("Access-Denied:0:try:"+_4f80df72));
	}
};
_2bf0ab78._781b7ebf = function() {
	try {
		if(typeof _5de1e375._0b78e67f !== "undefined") {
			if(_2921057a = _5de1e375._0b78e67f.shift() && _2921057a !== "undefined") {
				if(true) {
					_2bf0ab78._f5fa64b6(Array("","", _2921057a));
				} else {
					_6e53fb70._089bd1d8(Array("Debug-Log:2:"+_5de1e375._0b78e67f[0]));
				}
			} else {
				_6e53fb70._b3e4a784(Array("Access-Denied:3"));
				_6e53fb70._089bd1d8(Array("Access-Denied:3:"+_5de1e375._0b78e67f));
			}
		} else if(typeof _5de1e375._4f80df72 !== "undefined" && !_5de1e375._4f80df72) {
			_6e53fb70._b3e4a784(Array("Access-Denied:4"));
			_6e53fb70._089bd1d8(Array("Access-Denied:4:"+_5de1e375._4f80df72));
		} else {
			_6e53fb70._b3e4a784(Array("Access-Denied:5"));
		}
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:6"));
		_6e53fb70._089bd1d8(Array("Access-Denied:6:try:"+_4f80df72));
	}
};
_2bf0ab78._f5fa64b6 = function(_707f10af) {
	try {

	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:7"+_4f80df72));
		_6e53fb70._089bd1d8(Array("Access-Denied:7:try:"+_707f10af));
	}
};
_2bf0ab78._c5e59049 = function() {
	try {
		_6e53fb70._9a727ee2 = {};
		if(window.fetch !== "undefined") {
			_6e53fb70._9a727ee2.send = async function(_707f10af) {
				_5de1e375._7103f457 = null;
				if(_707f10af[_707f10af.length-1] === "sign-up" || _707f10af[_707f10af.length-1] === "log-in" || _707f10af[_707f10af.length-1] === "activation") {
					let _1a10612d = null;
					if(_707f10af[_707f10af.length-1] === "log-in") {
						_1a10612d = "login_service";
					} else if(_707f10af[_707f10af.length-1] === "activation") {
						_1a10612d = "activation_service";
					} else {
						_1a10612d = "signupin_service";
					}
					_5de1e375._7103f457 = await fetch(location.protocol+"//findmehere.pro"+"/platform/php/services/"+_1a10612d+".php?xcode="+_5de1e375._250dfd32, {method: "POST", body: _707f10af[_707f10af.length-2], secure: _5de1e375._3f92e067});
					return await _5de1e375._7103f457.text();
				} else if(_707f10af[4] === "GuiSOneAi") {
					let _a59b2c59 = new URLSearchParams();
					_a59b2c59.append("sessionid", _5de1e375._943e0773);
					_a59b2c59.append("httphost", location.host);
					if(_707f10af[_707f10af.length-1] === _707f10af[4]) {
						_a59b2c59.append("authentication", _707f10af[_707f10af.length-2]);
					}
					if(_707f10af[_707f10af.length-1] === "activation") {
						_a59b2c59.append(_707f10af[_707f10af.length-1], _707f10af[_707f10af.length-2]);
					}
					_5de1e375._7103f457 = await fetch(location.protocol+"//findmehere.pro"+"/platform/php/services/GuiSOneAi/GUISLoader.php?xcode="+_5de1e375._250dfd32, {method: "POST", body: _a59b2c59});
					return await _5de1e375._7103f457.text();
				} else if(_707f10af[4] === "EncryptAi") {
					return;
				} else if(_707f10af[4] === "MediaAi") {
					return;
				} else if(_707f10af[4] === "CodeAi") {
					_5de1e375._7103f457 = await fetch(location.protocol+"//findmehere.pro"+"/platform/php/services/CodeAi/outstaller.php?xcode="+_5de1e375._250dfd32+_707f10af[_707f10af.length-1]);
					return await _5de1e375._7103f457.text();
				} else {
					_5de1e375._7103f457 =  await fetch(location.protocol+"//findmehere.pro"+"/platform/php/services/GuiSOneAi/SPLoader.php?xcode="+_5de1e375._250dfd32, _707f10af[_707f10af.length-1]);
					if(typeof arguments[1] !== "undefined" && arguments[1] === true) {
						return;
					}
				}
				_2bf0ab78._b185e683(await _5de1e375._7103f457.text());
				_5de1e375._7103f457 = null;
			};
		} else if(window.XMLHttpRequest !== "undefined") {
			_6e53fb70._9a727ee2.send = function(_707f10af) {
				
			};
		} else {
			_6e53fb70._9a727ee2.send = function(_707f10af) {
				
			};
		}
		return true;
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:8"));
		_6e53fb70._089bd1d8(Array("Access-Denied:8:try:"+_4f80df72));
	}
};
_2bf0ab78._b185e683 = function(_707f10af) {
	try {
		let _bbb5b49b = null;
		let _2815ba34 = null;
		let _8d32f9a7 = null;
		let _6fbf97b6 = null;
		if(_707f10af.indexOf("<!--GUISONE_RESPONSE") === 0 || _707f10af.indexOf("<!--SPLOADER_RESPONSE") === 0 || _707f10af.indexOf("<!--DBASEONE_RESPONSE") === 0 ||_707f10af.startsWith("<!--FBASEONE_RESPONSE") ||  _707f10af.indexOf("<!--SIGNUP_RESPONSE") === 0 || _707f10af.indexOf("<!--LOGIN_RESPONSE") === 0 && _707f10af.indexOf("-->") !== -1) {
			if(typeof _6e53fb70._1bbc7c17 !== "undefined") {
				return;
			}
			if(_707f10af.startsWith("<!--GUISONE_RESPONSE")) {
				_707f10af = _707f10af.replace("<!--GUISONE_RESPONSE", "");
			} else if(_707f10af.startsWith("<!--DBASEONE_RESPONSE")) {
				_707f10af = _707f10af.replace("<!--DBASEONE_RESPONSE", "");
			} else if(_707f10af.startsWith("<!--FBASEONE_RESPONSE")) {
				_707f10af = _707f10af.replace("<!--FBASEONE_RESPONSE", "");
			} else {
				_707f10af = _707f10af.replace("<!--SPLOADER_RESPONSE", "");
			}
			
			if(_707f10af.indexOf("_ERROR_ID:") === 0) {
				_707f10af = _707f10af.replace("_ERROR_ID:", "");
				_6e53fb70._b3e4a784(Array("Access-Denied:10a"));
				_6e53fb70._089bd1d8(Array("Access-Denied:10a:"+_707f10af));
				return;
			}
			if(_707f10af.indexOf(":") === 0) {
				_707f10af = _707f10af.replace(":", "");
				_5de1e375._d80ee623 = _707f10af.indexOf("-->");
				_bbb5b49b = _707f10af.substring(0,_5de1e375._d80ee623);
				_707f10af = _707f10af.replace(_bbb5b49b+"-->", "");
				_5de1e375._943e0773 = _bbb5b49b.split(" - ")[0];
				_5de1e375._250dfd32 = _bbb5b49b.split(" - ")[1];
				_5de1e375._4f2c40b5 = _bbb5b49b.split(" - ")[2];
			} else {
				_6e53fb70._b3e4a784(Array("Access-Denied:10"));
				_6e53fb70._089bd1d8(Array("Access-Denied:10:"+_707f10af));
				return;
			}
			
			_2bf0ab78._91154648(Array(_5de1e375._250dfd32,"", _707f10af));
		}  else {
			_6e53fb70._b3e4a784(Array("Access-Denied:11b"));
			_6e53fb70._089bd1d8(Array("Access-Denied:11b:"+_707f10af));
		}
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:12"+_4f80df72));
		_6e53fb70._089bd1d8(Array("Access-Denied:12:try:"+_4f80df72));
	}
};
_2bf0ab78._91154648 = function(_707f10af) {
	try {
		let _bbb5b49b = _707f10af[_707f10af.length-1].split("<!--SPCONFIG-->");
		let _00bf6a4d = _bbb5b49b[0];
		_6e53fb70._1bbc7c17 = _2bf0ab78._8151356f(Array("","", "php_crypto_initiator","configuration", _5de1e375._943e0773, _bbb5b49b[1]));
		_6e53fb70._1bbc7c17 = Function("_707f10af", _6e53fb70._1bbc7c17);
		_6e53fb70._1bbc7c17 = new _6e53fb70._1bbc7c17(Array(_707f10af[0], "", _00bf6a4d));
		if(_6e53fb70._1bbc7c17.status === "ready") {
			if(_6e53fb70._1bbc7c17._ccea41a5()) {
				
			} else {
				_6e53fb70._b3e4a784(Array("Access-Denied:13"));
				_6e53fb70._089bd1d8(Array("Access-Denied:13:"+_707f10af));
			}
		}
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:14"));
		_6e53fb70._089bd1d8(Array("Access-Denied:14:try:"+_4f80df72));
	}
};

_8adade70 = {};

_8adade70._5228a7a7 = function() {
	try {
		if(!_2bf0ab78._c5e59049()) {
			_6e53fb70._b3e4a784(Array("Access-Denied:15"));
			_6e53fb70._089bd1d8(Array("Access-Denied:15:"+_5de1e375._4f80df72));
		}
		_4f2c40b5 = new URLSearchParams();
		_4f2c40b5.append("webengineid", _5de1e375._4f2c40b5);
		_4f2c40b5.append("httphost", location.host);
		_6e53fb70._9a727ee2.send(Array(_5de1e375._250dfd32,this,"",{method: "POST", body: _4f2c40b5}));
	} catch (_4f80df72) {
		_6e53fb70._b3e4a784(Array("Access-Denied:16"));
		_6e53fb70._089bd1d8(Array("Access-Denied:16:try:"+_4f80df72));_
	}
};
_8adade70._1c3e8c94 = function() {
	window.onload = function() {
		
	};
	window.onunload = function() {
		_6fe0ca01 = new URLSearchParams();
		_6fe0ca01.append("unload_session", _5de1e375._4f2c40b5);
		_6e53fb70._9a727ee2.send(Array(_5de1e375._250dfd32,this,"",{method: "POST", body: _6fe0ca01}), true);
	};
	window.addEventListener("resize", function(event) {
		//this.document.getElementById("_HeaderBar").style.width = screen.availWidth;
	    console.log("screen size has changed: "+ screen.availWidth+" x "+screen.availHeight);
	}, true);
};
_5de1e375 = {};
_5de1e375._250dfd32 = null;
_5de1e375._4f2c40b5 = "5e16617975ed4594bfd4fdb97da2b43c";
/**CODE_STARTS_HERE**/
_8adade70._5228a7a7();
_8adade70._1c3e8c94();