Online PHP and Javascript Decoder decode hidden script to uncover its real functionality


'use strict';
try {
  !function() {
    /**
     * @param {string} userAgent
     * @return {?}
     */
    function getValue(userAgent) {
      return userAgent = userAgent || navigator.userAgent, /Edge|EdgA/.test(userAgent) ? webkitVersion : /OPR\/|Opera|Opera\//.test(userAgent) ? OSX : /MSIE|Trident/.test(userAgent) ? WIN7 : /Gecko\/.*firefox\/|Gecko\/.*Firefox\/|Gecko Firefox\/|Gecko\/\d{8,12}\s{0,2}Firefox|Firefox\/|\) Gecko Firefox/.test(userAgent) ? version : /Chrome\/|CriOS/.test(userAgent) ? Hc : /Safari|safari/gi.test(userAgent) ? undefined : XP;
    }
    /**
     * @param {string} name
     * @return {?}
     */
    function w(name) {
      var dataType = attributes[name];
      return dataType || "\\u" + ("0000" + name.charCodeAt(0).toString(16)).slice(-4);
    }
    /**
     * @param {string} b
     * @return {?}
     */
    function stringify(b) {
      return a.lastIndex = 0, '"' + (a.test(b) ? b.replace(a, w) : b) + '"';
    }
    /**
     * @param {string} value
     * @return {?}
     */
    function toString(value) {
      var ret = void 0;
      switch(void 0 === value ? "undefined" : each(value)) {
        case "undefined":
          return "null";
        case "boolean":
          return String(value);
        case "number":
          /** @type {string} */
          var n = String(value);
          return "NaN" === n || "Infinity" === n ? className : n;
        case "string":
          return stringify(value);
      }
      if (null === value || value instanceof RegExp) {
        return className;
      }
      if (value instanceof Date) {
        return ['"', value.getFullYear(), "-", value.getMonth() + 1, "-", value.getDate(), "T", value.getHours(), ":", value.getMinutes(), ":", value.getSeconds(), , value.getMilliseconds(), '"'].join("");
      }
      if (value instanceof Array) {
        var i = void 0;
        /** @type {!Array} */
        ret = ["["];
        /** @type {number} */
        i = 0;
        for (; i < value.length; i++) {
          ret.push(clone(value[i]) || mlp, ",");
        }
        return ret[ret.length > 1 ? ret.length - 1 : ret.length] = "]", ret.join("");
      }
      /** @type {!Array} */
      ret = ["{"];
      var k;
      for (k in value) {
        if (value.hasOwnProperty(k) && void 0 !== value[k]) {
          ret.push(stringify(k), ":", clone(value[k]) || mlp, ",");
        }
      }
      return ret[ret.length > 1 ? ret.length - 1 : ret.length] = "}", ret.join("");
    }
    /**
     * @param {string} name
     * @return {?}
     */
    function table(name) {
      /** @type {string} */
      ret = name;
      /** @type {number} */
      at = 0;
      /** @type {string} */
      ch = " ";
      var r = row();
      return attr(), ch && parseInt("Syntax error"), r;
    }
    /**
     * @return {?}
     */
    function row() {
      switch(attr(), ch) {
        case "{":
          return onReady();
        case "[":
          return showResults();
        case '"':
          return draw();
        case "-":
          return isNumber();
        default:
          return ch >= "0" && ch <= "9" ? isNumber() : formatDate();
      }
    }
    /**
     * @return {?}
     */
    function onReady() {
      var s = void 0;
      var store_data = {};
      if ("{" === ch) {
        if (assert("{"), attr(), "}" === ch) {
          return assert("}"), store_data;
        }
        for (; ch;) {
          if (s = draw(), attr(), assert(":"), store_data.hasOwnProperty(s) && parseInt('Duplicate key "' + s + '"'), store_data[s] = row(), attr(), "}" === ch) {
            return assert("}"), store_data;
          }
          assert(",");
          attr();
        }
      }
      parseInt("Bad object");
    }
    /**
     * @return {?}
     */
    function showResults() {
      /** @type {!Array} */
      var results = [];
      if ("[" === ch) {
        if (assert("["), attr(), "]" === ch) {
          return assert("]"), results;
        }
        for (; ch;) {
          if (results.push(row()), attr(), "]" === ch) {
            return assert("]"), results;
          }
          assert(",");
          attr();
        }
      }
      parseInt("Bad array");
    }
    /**
     * @return {?}
     */
    function isNumber() {
      /** @type {string} */
      var s = "";
      if ("-" === ch) {
        /** @type {string} */
        s = "-";
        assert("-");
      }
      for (; ch >= "0" && ch <= "9";) {
        /** @type {string} */
        s = s + ch;
        assert();
      }
      if ( === ch) {
        /** @type {string} */
        s = s + ;
        for (; assert() && ch >= "0" && ch <= "9";) {
          /** @type {string} */
          s = s + ch;
        }
      }
      if ("e" === ch || "E" === ch) {
        /** @type {string} */
        s = s + ch;
        assert();
        if (!("-" !== ch && "+" !== ch)) {
          /** @type {string} */
          s = s + ch;
          assert();
        }
        for (; ch >= "0" && ch <= "9";) {
          /** @type {string} */
          s = s + ch;
          assert();
        }
      }
      /** @type {number} */
      var value = +s;
      if (isFinite(value)) {
        return value;
      }
      parseInt("Bad number");
    }
    /**
     * @return {?}
     */
    function draw() {
      var c = void 0;
      var value = void 0;
      /** @type {string} */
      var s = "";
      var x = void 0;
      if ('"' === ch) {
        for (; assert();) {
          if ('"' === ch) {
            return assert(), s;
          }
          if ("\\" === ch) {
            if (assert(), "u" === ch) {
              /** @type {number} */
              x = 0;
              /** @type {number} */
              value = 0;
              for (; value < 4 && (c = parseInt(assert(), 16), isFinite(c)); value = value + 1) {
                /** @type {number} */
                x = 16 * x + c;
              }
              /** @type {string} */
              s = s + String.fromCharCode(x);
            } else {
              if ("string" != typeof escapee[ch]) {
                break;
              }
              s = s + escapee[ch];
            }
          } else {
            /** @type {string} */
            s = s + ch;
          }
        }
      }
      parseInt("Bad string");
    }
    /**
     * @return {?}
     */
    function formatDate() {
      switch(ch) {
        case "t":
          return assert("t"), assert("r"), assert("u"), assert("e"), true;
        case "f":
          return assert("f"), assert("a"), assert("l"), assert("s"), assert("e"), false;
        case "n":
          return assert("n"), assert("u"), assert("l"), assert("l"), null;
      }
      parseInt("Unexpected '" + ch + "'");
    }
    /**
     * @return {undefined}
     */
    function attr() {
      for (; ch && ch <= " ";) {
        assert();
      }
    }
    /**
     * @param {string} c
     * @return {?}
     */
    function assert(c) {
      return c && c !== ch && parseInt("Expected '" + c + "' instead of '" + ch + "'"), ch = ret.charAt(at), at = at + 1, ch;
    }
    /**
     * @param {!Object} text
     * @return {?}
     */
    function parseInt(text) {
      throw {
        name : "SyntaxError",
        message : text,
        at : at,
        text : ret
      };
    }
    /**
     * @return {?}
     */
    function wrap() {
      return ("undefined" != typeof JSON && "function" == typeof JSON.parse && void 0 === String.prototype.toJSON ? JSON.parse : table).apply(null, Array.prototype.slice.call(arguments));
    }
    /**
     * @return {?}
     */
    function clone() {
      return ("undefined" != typeof JSON && "function" == typeof JSON.stringify && void 0 === Array.prototype.toJSON ? JSON.stringify : toString).apply(null, Array.prototype.slice.call(arguments));
    }
    /**
     * @param {!Array} value
     * @param {!Object} type
     * @return {?}
     */
    function equals(value, type) {
      if (value && "function" == typeof value.indexOf) {
        return value.indexOf(type);
      }
      if (value && value.length >= 0) {
        /** @type {number} */
        var j = 0;
        for (; j < value.length; j++) {
          if (value[j] === type) {
            return j;
          }
        }
        return -1;
      }
    }
    /**
     * @param {string} s_str
     * @return {?}
     */
    function id3v1String(s_str) {
      /** @type {!Uint8Array} */
      var ret = new Uint8Array(s_str.length);
      /** @type {number} */
      var i = 0;
      for (; i < s_str.length; i++) {
        ret[i] = s_str.charCodeAt(i);
      }
      return ret;
    }
    /**
     * @return {?}
     */
    function getTime() {
      return +new Date;
    }
    /**
     * @param {!Function} tag
     * @param {!Array} vars
     * @return {?}
     */
    function from(tag, vars) {
      return vars = vars || [], "(" + tag.toString() + ").apply(null, " + clone(vars) + ")";
    }
    /**
     * @param {?} src
     * @param {string} type
     * @return {?}
     */
    function createBlob(src, type) {
      /** @type {!Blob} */
      var moduleBlob = new Blob([src], {
        type : type
      });
      return URL.createObjectURL(moduleBlob);
    }
    /**
     * @param {?} t
     * @return {?}
     */
    function extend(t) {
      /** @type {number} */
      var length = arguments.length;
      /** @type {!Array} */
      var args = Array(length > 1 ? length - 1 : 0);
      /** @type {number} */
      var i = 1;
      for (; i < length; i++) {
        args[i - 1] = arguments[i];
      }
      if ("function" == typeof Object.assign) {
        return Object.assign.apply(Object, Array.prototype.slice.call(arguments));
      }
      if (t) {
        return args.forEach(function(cache) {
          var eid;
          for (eid in cache) {
            if (cache.hasOwnProperty(eid)) {
              t[eid] = cache[eid];
            }
          }
        }), t;
      }
    }
    /**
     * @param {!Array} e
     * @return {?}
     */
    function b(e) {
      return "function" == typeof Array.from ? Array.from(e) : Array.prototype.slice.call(e);
    }
    /**
     * @param {?} value
     * @return {?}
     */
    function reducer(value) {
      return "object" === (void 0 === value ? "undefined" : each(value)) && null !== value;
    }
    /**
     * @param {string} key
     * @return {undefined}
     */
    function $(key) {
      timedEvents[key] = getTimestamp();
    }
    /**
     * @param {string} key
     * @return {?}
     */
    function push(key) {
      /** @type {number} */
      var undefined = getTimestamp() - timedEvents[key];
      return templates[key] = templates[key] || {}, templates[key][index] = templates[key][index] ? templates[key][index] + undefined : undefined, templates[key][action] = templates[key][action] ? templates[key][action] + 1 : 1, _(undefined);
    }
    /**
     * @param {string} name
     * @return {?}
     */
    function getCaMetric(name) {
      return templates[name] ? _(templates[name][index] / templates[name][action]) : removeClass;
    }
    /**
     * @param {string} name
     * @return {?}
     */
    function getState(name) {
      return templates[name] ? _(templates[name][index]) : removeClass;
    }
    /**
     * @return {?}
     */
    function getTimestamp() {
      return now() ? performance.now() : getTime();
    }
    /**
     * @param {number} n
     * @return {?}
     */
    function _(n) {
      return n >= 0 ? parseInt(n) : removeClass;
    }
    /**
     * @param {number} a
     * @param {number} b
     * @return {?}
     */
    function K(a, b) {
      /** @type {number} */
      var e = (65535 & a) + (65535 & b);
      return (a >> 16) + (b >> 16) + (e >> 16) << 16 | 65535 & e;
    }
    /**
     * @param {number} a
     * @param {number} b
     * @return {?}
     */
    function r(a, b) {
      return a << b | a >>> 32 - b;
    }
    /**
     * @param {number} k
     * @param {number} val
     * @param {number} el
     * @param {number} node
     * @param {number} o
     * @param {number} g
     * @return {?}
     */
    function u(k, val, el, node, o, g) {
      return K(r(K(K(val, k), K(node, g)), o), el);
    }
    /**
     * @param {number} data
     * @param {number} c
     * @param {number} b
     * @param {number} a
     * @param {undefined} d
     * @param {number} r
     * @param {number} i
     * @return {?}
     */
    function cb(data, c, b, a, d, r, i) {
      return u(c & b | ~c & a, data, c, d, r, i);
    }
    /**
     * @param {number} data
     * @param {number} e
     * @param {number} a
     * @param {number} b
     * @param {undefined} t
     * @param {number} r
     * @param {number} s
     * @return {?}
     */
    function func(data, e, a, b, t, r, s) {
      return u(e & b | a & ~b, data, e, t, r, s);
    }
    /**
     * @param {number} name
     * @param {number} a
     * @param {number} b
     * @param {number} c
     * @param {undefined} t
     * @param {number} r
     * @param {number} i
     * @return {?}
     */
    function next(name, a, b, c, t, r, i) {
      return u(a ^ b ^ c, name, a, t, r, i);
    }
    /**
     * @param {number} data
     * @param {number} c
     * @param {number} e
     * @param {number} a
     * @param {undefined} b
     * @param {number} r
     * @param {number} s
     * @return {?}
     */
    function callback(data, c, e, a, b, r, s) {
      return u(e ^ (c | ~a), data, c, b, r, s);
    }
    /**
     * @param {!Object} c
     * @param {number} f
     * @return {?}
     */
    function format(c, f) {
      c[f >> 5] |= 128 << f % 32;
      /** @type {number} */
      c[14 + (f + 64 >>> 9 << 4)] = f;
      var l = void 0;
      var container = void 0;
      var b = void 0;
      var elem = void 0;
      var node = void 0;
      /** @type {number} */
      var data = 1732584193;
      /** @type {number} */
      var i = -271733879;
      /** @type {number} */
      var value = -1732584194;
      /** @type {number} */
      var res = 271733878;
      /** @type {number} */
      l = 0;
      for (; l < c.length; l = l + 16) {
        container = data;
        b = i;
        elem = value;
        node = res;
        data = cb(data, i, value, res, c[l], 7, -680876936);
        res = cb(res, data, i, value, c[l + 1], 12, -389564586);
        value = cb(value, res, data, i, c[l + 2], 17, 606105819);
        i = cb(i, value, res, data, c[l + 3], 22, -1044525330);
        data = cb(data, i, value, res, c[l + 4], 7, -176418897);
        res = cb(res, data, i, value, c[l + 5], 12, 1200080426);
        value = cb(value, res, data, i, c[l + 6], 17, -1473231341);
        i = cb(i, value, res, data, c[l + 7], 22, -45705983);
        data = cb(data, i, value, res, c[l + 8], 7, 1770035416);
        res = cb(res, data, i, value, c[l + 9], 12, -1958414417);
        value = cb(value, res, data, i, c[l + 10], 17, -42063);
        i = cb(i, value, res, data, c[l + 11], 22, -1990404162);
        data = cb(data, i, value, res, c[l + 12], 7, 1804603682);
        res = cb(res, data, i, value, c[l + 13], 12, -40341101);
        value = cb(value, res, data, i, c[l + 14], 17, -1502002290);
        i = cb(i, value, res, data, c[l + 15], 22, 1236535329);
        data = func(data, i, value, res, c[l + 1], 5, -165796510);
        res = func(res, data, i, value, c[l + 6], 9, -1069501632);
        value = func(value, res, data, i, c[l + 11], 14, 643717713);
        i = func(i, value, res, data, c[l], 20, -373897302);
        data = func(data, i, value, res, c[l + 5], 5, -701558691);
        res = func(res, data, i, value, c[l + 10], 9, 38016083);
        value = func(value, res, data, i, c[l + 15], 14, -660478335);
        i = func(i, value, res, data, c[l + 4], 20, -405537848);
        data = func(data, i, value, res, c[l + 9], 5, 568446438);
        res = func(res, data, i, value, c[l + 14], 9, -1019803690);
        value = func(value, res, data, i, c[l + 3], 14, -187363961);
        i = func(i, value, res, data, c[l + 8], 20, 1163531501);
        data = func(data, i, value, res, c[l + 13], 5, -1444681467);
        res = func(res, data, i, value, c[l + 2], 9, -51403784);
        value = func(value, res, data, i, c[l + 7], 14, 1735328473);
        i = func(i, value, res, data, c[l + 12], 20, -1926607734);
        data = next(data, i, value, res, c[l + 5], 4, -378558);
        res = next(res, data, i, value, c[l + 8], 11, -2022574463);
        value = next(value, res, data, i, c[l + 11], 16, 1839030562);
        i = next(i, value, res, data, c[l + 14], 23, -35309556);
        data = next(data, i, value, res, c[l + 1], 4, -1530992060);
        res = next(res, data, i, value, c[l + 4], 11, 1272893353);
        value = next(value, res, data, i, c[l + 7], 16, -155497632);
        i = next(i, value, res, data, c[l + 10], 23, -1094730640);
        data = next(data, i, value, res, c[l + 13], 4, 681279174);
        res = next(res, data, i, value, c[l], 11, -358537222);
        value = next(value, res, data, i, c[l + 3], 16, -722521979);
        i = next(i, value, res, data, c[l + 6], 23, 76029189);
        data = next(data, i, value, res, c[l + 9], 4, -640364487);
        res = next(res, data, i, value, c[l + 12], 11, -421815835);
        value = next(value, res, data, i, c[l + 15], 16, 530742520);
        i = next(i, value, res, data, c[l + 2], 23, -995338651);
        data = callback(data, i, value, res, c[l], 6, -198630844);
        res = callback(res, data, i, value, c[l + 7], 10, 1126891415);
        value = callback(value, res, data, i, c[l + 14], 15, -1416354905);
        i = callback(i, value, res, data, c[l + 5], 21, -57434055);
        data = callback(data, i, value, res, c[l + 12], 6, 1700485571);
        res = callback(res, data, i, value, c[l + 3], 10, -1894986606);
        value = callback(value, res, data, i, c[l + 10], 15, -1051523);
        i = callback(i, value, res, data, c[l + 1], 21, -2054922799);
        data = callback(data, i, value, res, c[l + 8], 6, 1873313359);
        res = callback(res, data, i, value, c[l + 15], 10, -30611744);
        value = callback(value, res, data, i, c[l + 6], 15, -1560198380);
        i = callback(i, value, res, data, c[l + 13], 21, 1309151649);
        data = callback(data, i, value, res, c[l + 4], 6, -145523070);
        res = callback(res, data, i, value, c[l + 11], 10, -1120210379);
        value = callback(value, res, data, i, c[l + 2], 15, 718787259);
        i = callback(i, value, res, data, c[l + 9], 21, -343485551);
        data = K(data, container);
        i = K(i, b);
        value = K(value, elem);
        res = K(res, node);
      }
      return [data, i, value, res];
    }
    /**
     * @param {!Object} input
     * @return {?}
     */
    function capitalize(input) {
      var i = void 0;
      /** @type {string} */
      var string = "";
      /** @type {number} */
      i = 0;
      for (; i < 32 * input.length; i = i + 8) {
        /** @type {string} */
        string = string + String.fromCharCode(input[i >> 5] >>> i % 32 & 255);
      }
      return string;
    }
    /**
     * @param {string} input
     * @return {?}
     */
    function f(input) {
      var i = void 0;
      /** @type {!Array} */
      var a = [];
      a[(input.length >> 2) - 1] = void 0;
      /** @type {number} */
      i = 0;
      for (; i < a.length; i = i + 1) {
        /** @type {number} */
        a[i] = 0;
      }
      /** @type {number} */
      i = 0;
      for (; i < 8 * input.length; i = i + 8) {
        a[i >> 5] |= (255 & input.charCodeAt(i / 8)) << i % 32;
      }
      return a;
    }
    /**
     * @param {string} i
     * @return {?}
     */
    function select(i) {
      return capitalize(format(f(i), 8 * i.length));
    }
    /**
     * @param {string} o
     * @param {string} s
     * @return {?}
     */
    function warn(o, s) {
      var i = void 0;
      var r = f(o);
      /** @type {!Array} */
      var values = [];
      /** @type {!Array} */
      var m = [];
      values[15] = m[15] = void 0;
      if (r.length > 16) {
        r = format(r, 8 * o.length);
      }
      /** @type {number} */
      i = 0;
      for (; i < 16; i = i + 1) {
        /** @type {number} */
        values[i] = 909522486 ^ r[i];
        /** @type {number} */
        m[i] = 1549556828 ^ r[i];
      }
      var key = format(values.concat(f(s)), 512 + 8 * s.length);
      return capitalize(format(m.concat(key), 640));
    }
    /**
     * @param {string} b
     * @return {?}
     */
    function cmp(b) {
      /** @type {string} */
      var s = "0123456789abcdef";
      /** @type {string} */
      var ret = "";
      var a = void 0;
      var i = void 0;
      /** @type {number} */
      i = 0;
      for (; i < b.length; i = i + 1) {
        a = b.charCodeAt(i);
        /** @type {string} */
        ret = ret + (s.charAt(a >>> 4 & 15) + s.charAt(15 & a));
      }
      return ret;
    }
    /**
     * @param {string} value
     * @return {?}
     */
    function negate(value) {
      return unescape(encodeURIComponent(value));
    }
    /**
     * @param {string} x
     * @return {?}
     */
    function parseFloat(x) {
      return select(negate(x));
    }
    /**
     * @param {string} a
     * @return {?}
     */
    function compare(a) {
      return cmp(parseFloat(a));
    }
    /**
     * @param {string} c
     * @param {string} e
     * @return {?}
     */
    function make_real_if(c, e) {
      return warn(negate(c), negate(e));
    }
    /**
     * @param {string} c
     * @param {string} t
     * @return {?}
     */
    function make_conditional(c, t) {
      return cmp(make_real_if(c, t));
    }
    /**
     * @param {string} o
     * @param {string} c
     * @param {?} f
     * @return {?}
     */
    function convert(o, c, f) {
      return c ? f ? make_real_if(c, o) : make_conditional(c, o) : f ? parseFloat(o) : compare(o);
    }
    /**
     * @param {string} a
     * @param {string} x
     * @param {?} cb
     * @return {?}
     */
    function join(a, x, cb) {
      ne_resize++;
      $("PX503");
      var r = convert(a, x, cb);
      return push("PX503"), r;
    }
    /**
     * @return {?}
     */
    function oROR() {
      return ne_resize;
    }
    /**
     * @param {!Function} handler
     * @return {undefined}
     */
    function bindReady(handler) {
      /**
       * @return {undefined}
       */
      function ready() {
        if (!e) {
          /** @type {boolean} */
          e = true;
          handler();
        }
      }
      /** @type {boolean} */
      var e = false;
      if (document.addEventListener) {
        document.addEventListener("DOMContentLoaded", ready, false);
      } else {
        if (document.attachEvent) {
          var isFrame = void 0;
          try {
            /** @type {boolean} */
            isFrame = null !== window.frameElement;
          } catch (t) {
            /** @type {boolean} */
            isFrame = false;
          }
          if (document.documentElement.doScroll && !isFrame) {
            (function() {
              /**
               * @return {undefined}
               */
              function ready() {
                if (!e) {
                  try {
                    document.documentElement.doScroll("left");
                    ready();
                  } catch (n) {
                    setTimeout(ready, 50);
                  }
                }
              }
              ready();
            })();
          }
          document.attachEvent("onreadystatechange", function() {
            if ("complete" === document.readyState) {
              ready();
            }
          });
        }
      }
      if (window.addEventListener) {
        window.addEventListener("load", ready, false);
      } else {
        if (window.attachEvent) {
          window.attachEvent("onload", ready);
        } else {
          (function() {
            /** @type {function(): undefined} */
            var oldonload = window.onload;
            /**
             * @return {undefined}
             */
            window.onload = function() {
              if (oldonload) {
                oldonload();
              }
              ready();
            };
          })();
        }
      }
    }
    /**
     * @param {!Function} handler
     * @return {undefined}
     */
    function ready(handler) {
      if (void 0 === document.readyState || "interactive" !== document.readyState && "complete" !== document.readyState) {
        if (!q.length) {
          bindReady(function() {
            rect = rect || getTime();
            processQueue(q);
          });
        }
        q.push({
          handler : handler
        });
      } else {
        rect = rect || getTime();
        handler();
      }
    }
    /**
     * @return {?}
     */
    function extractCea608Data() {
      return rect;
    }
    /**
     * @param {!Function} callback
     * @param {string} timeout
     * @return {undefined}
     */
    function setTimeout(callback, timeout) {
      if (!Pu) {
        /** @type {boolean} */
        Pu = true;
        createInstance();
      }
      handlers.push({
        handler : callback,
        runLast : timeout
      });
    }
    /**
     * @return {undefined}
     */
    function imageElementClickHandler() {
      if (!yu) {
        /** @type {boolean} */
        yu = true;
        processQueue(handlers);
      }
    }
    /**
     * @return {undefined}
     */
    function createInstance() {
      /** @type {number} */
      var i = 0;
      for (; i < sources.length; i++) {
        bind(window, sources[i], imageElementClickHandler);
      }
    }
    /**
     * @param {string} queue
     * @return {undefined}
     */
    function processQueue(queue) {
      var fn = void 0;
      if (queue && queue.length) {
        /** @type {number} */
        var i = 0;
        for (; i < queue.length; i++) {
          try {
            if (queue[i].runLast && "function" != typeof fn) {
              fn = queue[i].handler;
            } else {
              queue[i].handler();
            }
          } catch (t) {
          }
        }
        if ("function" == typeof fn) {
          fn();
        }
        /** @type {!Array} */
        queue = [];
      }
    }
    /**
     * @param {string} e
     * @return {?}
     */
    function factory(e) {
      return "function" == typeof o ? o(e) : compile(e);
    }
    /**
     * @param {string} s
     * @return {?}
     */
    function compile(s) {
      /** @type {!Array} */
      var outChance = [];
      var e = void 0;
      var r = void 0;
      var bytesArray = void 0;
      /** @type {number} */
      var i = 0;
      var j = void 0;
      var l = s.length;
      try {
        if (regCls.test(s) || /=/.test(s) && (/=[^=]/.test(s) || /={3}/.test(s))) {
          return null;
        }
        if (l % 4 > 0) {
          s = s + window.Array(4 - l % 4 + 1).join("=");
          l = s.length;
        }
        for (; i < l;) {
          /** @type {!Array} */
          r = [];
          /** @type {number} */
          j = i;
          for (; i < j + 4;) {
            r.push(related_node_ids.indexOf(s.charAt(i++)));
          }
          /** @type {number} */
          e = (r[0] << 18) + (r[1] << 12) + ((63 & r[2]) << 6) + (63 & r[3]);
          /** @type {!Array} */
          bytesArray = [(e & 255 << 16) >> 16, 64 === r[2] ? -1 : (65280 & e) >> 8, 64 === r[3] ? -1 : 255 & e];
          /** @type {number} */
          j = 0;
          for (; j < 3; ++j) {
            if (bytesArray[j] >= 0 || 0 === j) {
              outChance.push(String.fromCharCode(bytesArray[j]));
            }
          }
        }
        return outChance.join("");
      } catch (t) {
        return null;
      }
    }
    /**
     * @param {!Object} o
     * @param {string} p
     * @return {?}
     */
    function fn(o, p) {
      if (!(o && o instanceof window.Element)) {
        return "";
      }
      var name = void 0;
      var item = o[j];
      if (item) {
        return p ? camelize(item) : item;
      }
      try {
        name = handler(o);
        name = name.replace(/^>/, "");
        name = p ? camelize(name) : name;
        o[j] = name;
      } catch (t) {
      }
      return name || o.id || o.tagName || "";
    }
    /**
     * @param {!Object} value
     * @return {?}
     */
    function handler(value) {
      if (value.id) {
        return "#" + value.id;
      }
      var name = void 0;
      /** @type {string} */
      var e = "";
      /** @type {number} */
      var r = 0;
      for (; r < numberOfActivationUnitsL2; r++) {
        if (!(value && value instanceof Element)) {
          return e;
        }
        if ("html" === value.tagName.toLowerCase()) {
          return e;
        }
        if (value.id) {
          return "#" + value.id + e;
        }
        if (!((name = merge(value)) instanceof Element)) {
          return value.tagName + e;
        }
        if (e = _path(value, name) + e, D(e)) {
          return e;
        }
        value = name;
        /** @type {string} */
        e = ">" + e;
      }
    }
    /**
     * @param {string} b
     * @return {?}
     */
    function D(b) {
      try {
        return 1 === document.querySelectorAll(b).length;
      } catch (t) {
        return false;
      }
    }
    /**
     * @param {!Object} obj
     * @param {!Object} file
     * @return {?}
     */
    function _path(obj, file) {
      if (1 === file.getElementsByTagName(obj.tagName).length) {
        return obj.tagName;
      }
      /** @type {number} */
      var i = 0;
      for (; i < file.children.length; i++) {
        if (file.children[i] === obj) {
          return obj.tagName + ":nth-child(" + (i + 1) + ")";
        }
      }
    }
    /**
     * @param {string} str
     * @return {?}
     */
    function camelize(str) {
      if ("string" == typeof str) {
        return str.replace(/:nth-child\((\d+)\)/g, function(canCreateDiscussions, camelizedObj) {
          return camelizedObj;
        });
      }
    }
    /**
     * @param {!Object} attrs
     * @return {?}
     */
    function h(attrs) {
      /** @type {string} */
      var escape = "undefined";
      return attrs && attrs.hasOwnProperty("isTrusted") && (escape = attrs.isTrusted && "false" !== attrs.isTrusted ? "true" : "false"), escape;
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function createElement(obj) {
      if (obj) {
        return obj.target || obj.toElement || obj.srcElement;
      }
    }
    /**
     * @param {!Object} src
     * @return {?}
     */
    function merge(src) {
      if (src) {
        var bpPublishDetails = src.parentNode || src.parentElement;
        return bpPublishDetails && bpPublishDetails.nodeType !== COST_OPTIMIZED ? bpPublishDetails : null;
      }
    }
    /**
     * @param {string} type
     * @return {?}
     */
    function _convertTagType(type) {
      return "DOMMouseScroll" === type ? id : type;
    }
    /**
     * @param {?} t
     * @return {?}
     */
    function log(t) {
      try {
        /** @type {!ClientRect} */
        var p0 = Element.prototype.getBoundingClientRect.call(t);
        return {
          left : p0.left,
          top : p0.top
        };
      } catch (t) {
        return {
          left : -1,
          top : -1
        };
      }
    }
    /**
     * @param {!Object} e
     * @return {?}
     */
    function getTouch(e) {
      var i = {};
      if (!e) {
        return i;
      }
      var b = e.touches || e.changedTouches;
      return b ? (e = b[0], position(e, i)) : position(e, i), i;
    }
    /**
     * @param {!Object} value
     * @param {!Object} option
     * @return {undefined}
     */
    function position(value, option) {
      if (value && "number" == typeof value.clientX && "number" == typeof value.clientY) {
        /** @type {number} */
        option.x = +(value.clientX || -1).toFixed(2);
        /** @type {number} */
        option.y = +(value.clientY || -1).toFixed(2);
      }
    }
    /**
     * @param {!Event} event
     * @return {?}
     */
    function onClick(event) {
      try {
        if (!event || !event.isTrusted) {
          return false;
        }
        var element = createElement(event);
        if (!element) {
          return false;
        }
        var boundAry = element.getClientRects();
        var touch = {
          x : boundAry[0].left + boundAry[0].width / 2,
          y : boundAry[0].top + boundAry[0].height / 2
        };
        /** @type {number} */
        var startDayIdx = Math.abs(touch.x - event.clientX);
        /** @type {number} */
        var endDayIdx = Math.abs(touch.y - event.clientY);
        if (startDayIdx < curDayIdx && endDayIdx < curDayIdx) {
          return {
            centerX : startDayIdx,
            centerY : endDayIdx
          };
        }
      } catch (t) {
      }
      return null;
    }
    /**
     * @param {!Event} event
     * @return {?}
     */
    function extractPointers(event) {
      var oldTouch = {};
      try {
        /** @type {number} */
        oldTouch.pageX = +(event.pageX || document.documentElement && event.clientX + document.documentElement.scrollLeft || 0).toFixed(2);
        /** @type {number} */
        oldTouch.pageY = +(event.pageY || document.documentElement && event.clientY + document.documentElement.scrollTop || 0).toFixed(2);
      } catch (t) {
      }
      return oldTouch;
    }
    /**
     * @param {?} key
     * @return {?}
     */
    function upCode(key) {
      switch(key) {
        case 8:
        case 9:
        case 13:
        case 16:
        case 17:
        case 18:
        case 27:
        case 32:
        case 37:
        case 38:
        case 39:
        case 40:
        case 91:
          return true;
        default:
          return false;
      }
    }
    /**
     * @param {!Object} element
     * @param {!Function} callback
     * @return {undefined}
     */
    function addEvent(element, callback) {
      if ((!MutationObserver || element) && "function" == typeof callback) {
        (new MutationObserver(function(wrappersTemplates) {
          wrappersTemplates.forEach(function(data) {
            if (data && "attributes" === data.type) {
              var e = data.attributeName;
              var ARG_3 = e && data.target && "function" == typeof data.target.getAttribute && Element.prototype.getAttribute.call(data.target, data.attributeName);
              callback(data.target, e, ARG_3);
            }
          });
        })).observe(element, {
          attributes : true
        });
      }
    }
    /**
     * @param {!Object} type
     * @param {!Function} fn
     * @return {?}
     */
    function observe(type, fn) {
      if (MutationObserver && type && "function" == typeof fn) {
        var observer = new MutationObserver(function(wrappersTemplates) {
          wrappersTemplates.forEach(function(a) {
            if (a && "childList" === a.type) {
              fn(a.addedNodes, a.removedNodes);
            }
          });
        });
        return observer.observe(type, {
          childList : true,
          subtree : true
        }), observer;
      }
    }
    /**
     * @param {!Element} element
     * @return {undefined}
     */
    function Completer(element) {
      if (element) {
        element.setAttribute("tabindex", "-1");
        element.setAttribute("aria-hidden", "true");
      }
    }
    /**
     * @param {!Object} options
     * @return {?}
     */
    function timestamp(options) {
      return Math.round(options.timestamp || options.timeStamp || 0);
    }
    /**
     * @param {string} fn
     * @return {?}
     */
    function call(fn) {
      return fn ? bind : removeEvent;
    }
    /**
     * @param {!Object} obj
     * @param {string} name
     * @param {!Function} callback
     * @param {!Object} value
     * @return {undefined}
     */
    function bind(obj, name, callback, value) {
      $("PX536");
      source++;
      try {
        if (obj && name && "function" == typeof callback && "string" == typeof name) {
          if ("function" == typeof obj.addEventListener) {
            var options = void 0;
            if (Uu) {
              /** @type {boolean} */
              options = false;
              if ("boolean" == typeof value) {
                /** @type {!Object} */
                options = value;
              } else {
                if (value && "boolean" == typeof value.useCapture) {
                  /** @type {boolean} */
                  options = value.useCapture;
                } else {
                  if (value && "boolean" == typeof value.capture) {
                    /** @type {boolean} */
                    options = value.capture;
                  }
                }
              }
            } else {
              if ("object" === (void 0 === value ? "undefined" : each(value)) && null !== value) {
                options = {};
                if (value.hasOwnProperty("capture")) {
                  options.capture = value.capture || false;
                }
                if (value.hasOwnProperty("once")) {
                  options.once = value.once;
                }
                if (value.hasOwnProperty("passive")) {
                  options.passive = value.passive;
                }
                if (value.hasOwnProperty("mozSystemGroup")) {
                  options.mozSystemGroup = value.mozSystemGroup;
                }
              } else {
                options = {
                  passive : true,
                  capture : "boolean" == typeof value && value || false
                };
              }
            }
            obj.addEventListener(name, callback, options);
          } else {
            if ("function" == typeof obj.attachEvent) {
              obj.attachEvent("on" + name, callback);
            }
          }
        }
      } catch (t) {
      }
      push("PX536");
    }
    /**
     * @param {!Object} asset
     * @param {string} source
     * @param {string} name
     * @return {?}
     */
    function set(asset, source, name) {
      /** @type {!Element} */
      var self = document.createElement("a");
      /** @type {!RegExp} */
      var p1 = new RegExp(source + "=\\d{0,13}", "gi");
      /** @type {!Object} */
      self.href = asset;
      var v = self.search.replace(p1, source + "=" + name);
      self.search = self.search === v ? "" === self.search ? source + "=" + name : self.search + "&" + source + "=" + name : v;
      var val = self.href.replace(self.search, "").replace(self.hash, "");
      return ("/" === val.substr(val.length - 1) ? val.substring(0, val.length - 1) : val) + self.search + self.hash;
    }
    /**
     * @param {!Object} obj
     * @param {string} name
     * @param {!Function} callback
     * @return {undefined}
     */
    function removeEvent(obj, name, callback) {
      $("PX538");
      newHash++;
      try {
        if (obj && name && "function" == typeof callback && "string" == typeof name) {
          if ("function" == typeof obj.removeEventListener) {
            obj.removeEventListener(name, callback);
          } else {
            if ("function" == typeof obj.detachEvent) {
              obj.detachEvent("on" + name, callback);
            }
          }
        }
      } catch (t) {
      }
      push("PX538");
    }
    /**
     * @return {?}
     */
    function concat() {
      try {
        null[0];
      } catch (logItem) {
        return logItem.stack || "";
      }
      return "";
    }
    /**
     * @param {string} hash
     * @return {?}
     */
    function then(hash) {
      return hash ? hash.replace(/\s{2,100}/g, " ").replace(/[\r\n\t]+/g, "\n") : "";
    }
    /**
     * @return {?}
     */
    function filterSymbols() {
      return then(concat());
    }
    /**
     * @param {string} uri
     * @return {?}
     */
    function split(uri) {
      /** @type {!Array} */
      var subArrays = [];
      if (!uri) {
        return subArrays;
      }
      var e = uri.split("\n");
      var event_type_name = void 0;
      /** @type {null} */
      var subArray = null;
      /** @type {!RegExp} */
      var regex = /^\s*at (.*?) ?\(?((?:file:\/\/|https?:\/\/|blob|chrome-extension|native|webpack:\/\/|eval|<anonymous>).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
      /** @type {!RegExp} */
      var c = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|\[native).*?)(?::(\d+))?(?::(\d+))?\s*$/i;
      /** @type {!RegExp} */
      var d = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
      /** @type {number} */
      var i = 0;
      var insertCount = e.length;
      for (; i < insertCount; ++i) {
        if (event_type_name = regex.exec(e[i])) {
          /** @type {!Array} */
          subArray = [event_type_name[2] && -1 !== event_type_name[2].indexOf("native") ? "" : event_type_name[2], event_type_name[1] || Service];
        } else {
          if (event_type_name = d.exec(e[i])) {
            /** @type {!Array} */
            subArray = [event_type_name[2], event_type_name[1] || Service];
          } else {
            if (!(event_type_name = c.exec(e[i]))) {
              continue;
            }
            /** @type {!Array} */
            subArray = [event_type_name[3], event_type_name[1] || Service];
          }
        }
        subArrays.push(subArray);
      }
      return subArrays;
    }
    /**
     * @return {?}
     */
    function tick() {
      if (now()) {
        return Math.round(window.performance.now());
      }
    }
    /**
     * @param {!Function} b
     * @return {?}
     */
    function append(b) {
      return (b || getTime()) - (extractCea608Data() || 0);
    }
    /**
     * @param {!Object} w
     * @return {?}
     */
    function verifyjQuery(w) {
      /** @type {number} */
      var n = 0;
      try {
        for (; w && w.parent && w !== w.parent && n < 25;) {
          n++;
          w = w.parent;
        }
      } catch (t) {
        /** @type {number} */
        n = -1;
      }
      return n;
    }
    /**
     * @param {!Element} element
     * @return {?}
     */
    function offset(element) {
      try {
        return !!(element.offsetWidth || element.offsetHeight || element.getClientRects && element.getClientRects().length);
      } catch (t) {
      }
    }
    /**
     * @return {?}
     */
    function isMobile() {
      return "number" == typeof navigator.maxTouchPoints ? navigator.maxTouchPoints : "number" == typeof navigator.msMaxTouchPoints ? navigator.msMaxTouchPoints : void 0;
    }
    /**
     * @param {!Object} options
     * @return {?}
     */
    function normalize(options) {
      if (options) {
        try {
          var name;
          for (name in options) {
            var value = options[name];
            if ("function" == typeof value && !isFunction(value)) {
              return false;
            }
          }
        } catch (t) {
        }
        return true;
      }
    }
    /**
     * @param {string} value
     * @return {?}
     */
    function isFunction(value) {
      return "function" == typeof value && /\{\s*\[native code\]\s*\}/.test("" + value);
    }
    /**
     * @return {?}
     */
    function send() {
      return getValue() !== undefined && window.Blob && "function" == typeof window.navigator.sendBeacon;
    }
    /**
     * @param {string} name
     * @param {string} path
     * @return {?}
     */
    function getVersion(name, path) {
      var input = join(name, path);
      try {
        var keys = processInput(input);
        /** @type {string} */
        var result = "";
        /** @type {number} */
        var i = 0;
        for (; i < keys.length; i = i + 2) {
          result = result + keys[i];
        }
        return result;
      } catch (t) {
      }
    }
    /**
     * @param {string} str
     * @return {?}
     */
    function processInput(str) {
      /** @type {string} */
      var newStr = "";
      /** @type {string} */
      var s = "";
      /** @type {number} */
      var i = 0;
      for (; i < str.length; i++) {
        var id = str.charCodeAt(i);
        if (id >= FIELD_EXPANDER_ID_MIN && id <= FIELD_EXPANDER_ID_MAX) {
          newStr = newStr + str[i];
        } else {
          /** @type {string} */
          s = s + id % LOGIN_COLOR_MAX;
        }
      }
      return newStr + s;
    }
    /**
     * @param {!Array} value
     * @return {?}
     */
    function css(value) {
      /** @type {!Array} */
      var output = [];
      /** @type {number} */
      var i = 0;
      for (; i < value.length; i = i + 2) {
        output.push(value[i]);
      }
      return output;
    }
    /**
     * @param {?} value
     * @return {?}
     */
    function translate(value) {
      return Array.isArray ? Array.isArray(value) : "[object Array]" === Object.prototype.toString.call(value);
    }
    /**
     * @param {!Function} cb
     * @return {?}
     */
    function onEvent(cb) {
      return called_ ? void messageHandlers.push(cb) : msg ? void cb(msg, entry) : (called_ = true, messageHandlers.push(cb), void setTimeout(function() {
        $("PX502");
        try {
          !function() {
            !function extendWidget() {
              msg++;
              extendWidget();
            }();
          }();
        } catch (n) {
          entry = push("PX502");
          /** @type {number} */
          var i = 0;
          for (; i < messageHandlers.length; i++) {
            messageHandlers[i](msg, entry);
          }
          /** @type {!Array} */
          messageHandlers = [];
          /** @type {boolean} */
          called_ = false;
        }
      }, 0));
    }
    /**
     * @return {?}
     */
    function removeHasDontEnumBug() {
      return source;
    }
    /**
     * @return {?}
     */
    function removeDeletedActivities() {
      return newHash;
    }
    /**
     * @return {?}
     */
    function now() {
      return window.performance && "function" == typeof performance.now;
    }
    /**
     * @param {!Object} obj
     * @param {string} method
     * @param {!Function} format
     * @param {number} type
     * @return {?}
     */
    function report(obj, method, format, type) {
      var val = void 0;
      try {
        val = format();
      } catch (t) {
      }
      return void 0 === val && (val = void 0 === type ? "missing" : type), obj[method] = val, val;
    }
    /**
     * @param {string} item
     * @return {?}
     */
    function command(item) {
      var jsonResponse = item.split("\n");
      return jsonResponse.length > maxElements ? jsonResponse.slice(jsonResponse.length - maxElements, jsonResponse.length).join("\n") : item;
    }
    /**
     * @param {number} i
     * @param {string} str
     * @return {?}
     */
    function apply(i, str) {
      /** @type {string} */
      var ret = "";
      /** @type {string} */
      var m = "string" == typeof str && str.length > 10 ? str.replace(/\s*/g, "") : screen;
      /** @type {number} */
      var whichFriend = 0;
      for (; whichFriend < i; whichFriend++) {
        ret = ret + m[Math.floor(Math.random() * m.length)];
      }
      return ret;
    }
    /**
     * @param {!Array} list
     * @param {!Object} value
     * @return {?}
     */
    function forEach(list, value) {
      var result = equals(list, value);
      return -1 !== result ? result : (list.push(value), list.length - 1);
    }
    /**
     * @param {string} str
     * @return {?}
     */
    function resolve(str) {
      /** @type {string} */
      str = "" + str;
      /** @type {number} */
      var r = rowsPerColumn;
      /** @type {number} */
      var i = 0;
      for (; i < str.length; i++) {
        /** @type {number} */
        r = (r << 5) - r + str.charCodeAt(i);
        /** @type {number} */
        r = r | 0;
      }
      return notifyListeners(r);
    }
    /**
     * @param {number} value
     * @return {?}
     */
    function notifyListeners(value) {
      return value = value | 0, value < 0 && (value = value + 4294967296), value.toString(16);
    }
    /**
     * @param {!Function} saveNotifs
     * @param {boolean} events
     * @return {?}
     */
    function bindEvents(saveNotifs, events) {
      try {
        return saveNotifs();
      } catch (el) {
        if (events) {
          return el;
        }
      }
    }
    /**
     * @param {string} options
     * @param {string} value
     * @return {?}
     */
    function complete(options, value) {
      /** @type {string} */
      var path = "";
      if (!options) {
        return path;
      }
      /** @type {string} */
      path = path + (options + "");
      var data = isPlainObject(options);
      if (path = path + (options.constructor || data && data.constructor || ""), data) {
        var o = void 0;
        var name;
        for (name in data) {
          /** @type {boolean} */
          o = true;
          try {
            if (data.hasOwnProperty(name)) {
              /** @type {string} */
              path = path + (value ? name : traverse(name, data));
            }
          } catch (whiteboard) {
            /** @type {string} */
            path = path + (name + (whiteboard && whiteboard.message));
          }
        }
        if (!o && "function" == typeof Object.keys) {
          /** @type {!Array<string>} */
          var params = Object.keys(data);
          if (params && params.length > 0) {
            /** @type {number} */
            var i = 0;
            for (; i < params.length; i++) {
              try {
                /** @type {string} */
                path = path + (value ? params[i] : traverse(params[i], data));
              } catch (whiteboard) {
                /** @type {string} */
                path = path + (params[i] + (whiteboard && whiteboard.message));
              }
            }
          }
        }
      }
      try {
        var name;
        for (name in options) {
          try {
            if (options.hasOwnProperty && options.hasOwnProperty(name)) {
              /** @type {string} */
              path = path + (value ? name : traverse(name, options));
            }
          } catch (errResponse) {
            /** @type {string} */
            path = path + (errResponse && errResponse.message);
          }
        }
      } catch (errResponse) {
        /** @type {string} */
        path = path + (errResponse && errResponse.message);
      }
      return path;
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function isPlainObject(obj) {
      try {
        return Object.getPrototypeOf && Object.getPrototypeOf(obj) || obj.__proto__ || obj.prototype;
      } catch (t) {
      }
    }
    /**
     * @param {string} name
     * @param {string} list
     * @return {?}
     */
    function traverse(name, list) {
      try {
        return name + list[name];
      } catch (skip) {
        return skip;
      }
    }
    /**
     * @param {string} id
     * @param {string} name
     * @return {?}
     */
    function load(id, name) {
      if (!name) {
        /** @type {string} */
        name = window.location.href;
      }
      id = id.replace(/[[\]]/g, "\\$&");
      /** @type {!RegExp} */
      var e = new RegExp("[?&]" + id + "(=([^&#]*)|&|#|$)");
      /** @type {(Array<string>|null)} */
      var cfg = e.exec(name);
      if (!cfg) {
        return null;
      }
      /** @type {string} */
      var value = cfg[2];
      if (!value) {
        return "";
      }
      if (value = decodeURIComponent(value.replace(/\+/g, " ")), "url" === id) {
        try {
          value = factory(value);
        } catch (t) {
        }
      }
      return value;
    }
    /**
     * @param {string} t
     * @param {number} c
     * @return {?}
     */
    function replace(t, c) {
      /** @type {string} */
      var unroll = "";
      /** @type {number} */
      var b = 0;
      for (; b < t.length; b++) {
        /** @type {string} */
        unroll = unroll + String.fromCharCode(c ^ t.charCodeAt(b));
      }
      return unroll;
    }
    /**
     * @param {!Window} key
     * @param {?} type
     * @return {?}
     */
    function getOptions(key, type) {
      try {
        var d = options(key, type);
        if (!d) {
          return;
        }
        /** @type {string} */
        var currentDir = "";
        var p;
        for (p in d) {
          /** @type {string} */
          currentDir = currentDir + (d[p] + "");
        }
        return resolve(currentDir);
      } catch (t) {
      }
    }
    /**
     * @param {!Window} n
     * @param {?} key
     * @return {?}
     */
    function options(n, key) {
      try {
        var api = factory("T2JqZWN0");
        var i = factory("Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9y");
        var callback = window[api][i];
        if ("function" != typeof callback) {
          return;
        }
        return callback(n, key);
      } catch (t) {
      }
    }
    /**
     * @param {!Object} buf
     * @param {number} offset
     * @return {?}
     */
    function unparse(buf, offset) {
      var i = offset || 0;
      /** @type {!Array} */
      var bth = _byteToHex;
      return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
    }
    /**
     * @param {!Object} options
     * @param {!Object} buf
     * @param {!Object} offset
     * @param {?} orientation
     * @return {?}
     */
    function walk(options, buf, offset, orientation) {
      $("PX505");
      /** @type {string} */
      var format = "";
      if (orientation) {
        try {
          /** @type {!Array<string>} */
          var b = ((new Date).getTime() * Math.random() + "").replace(, .charCodeAt()).split("").slice(-16);
          /** @type {number} */
          var i = 0;
          for (; i < b.length; i++) {
            /** @type {number} */
            b[i] = parseInt(10 * Math.random()) * +b[i] || parseInt(Math.random() * desc.len);
          }
          format = unparse(b, 0, desc.cipher);
        } catch (t) {
        }
      }
      var index = buf && offset || 0;
      var buffer = buf || [];
      options = options || {};
      var f = void 0 !== options.clockseq ? options.clockseq : file;
      var len = void 0 !== options.msecs ? options.msecs : getTime();
      var connectNumber = void 0 !== options.nsecs ? options.nsecs : concurency + 1;
      /** @type {number} */
      var n = len - max + (connectNumber - concurency) / 1E4;
      if (n < 0 && void 0 === options.clockseq && (f = f + 1 & 16383), (n < 0 || len > max) && void 0 === options.nsecs && (connectNumber = 0), connectNumber >= 1E4) {
        throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
      }
      max = len;
      concurency = connectNumber;
      file = f;
      len = len + 122192928E5;
      /** @type {number} */
      var intValue = (1E4 * (268435455 & len) + connectNumber) % 4294967296;
      /** @type {number} */
      buffer[index++] = intValue >>> 24 & 255;
      /** @type {number} */
      buffer[index++] = intValue >>> 16 & 255;
      /** @type {number} */
      buffer[index++] = intValue >>> 8 & 255;
      /** @type {number} */
      buffer[index++] = 255 & intValue;
      /** @type {number} */
      var mask = len / 4294967296 * 1E4 & 268435455;
      /** @type {number} */
      buffer[index++] = mask >>> 8 & 255;
      /** @type {number} */
      buffer[index++] = 255 & mask;
      /** @type {number} */
      buffer[index++] = mask >>> 24 & 15 | 16;
      /** @type {number} */
      buffer[index++] = mask >>> 16 & 255;
      /** @type {number} */
      buffer[index++] = f >>> 8 | 128;
      /** @type {number} */
      buffer[index++] = 255 & f;
      var trbuffer = options.node || _nodeId;
      /** @type {number} */
      var i = 0;
      for (; i < 6; i++) {
        buffer[index + i] = trbuffer[i];
      }
      var ogg = buf || unparse(buffer);
      return format === ogg ? format : (push("PX505"), ogg);
    }
    /**
     * @param {string} s
     * @param {string} value
     * @param {?} message
     * @return {?}
     */
    function lastIndexOf(s, value, message) {
      return debug(s, -9E4, value, message);
    }
    /**
     * @param {string} i
     * @param {number} ctx
     * @param {string} tag
     * @param {?} data
     * @return {?}
     */
    function debug(i, ctx, tag, data) {
      try {
        /** @type {string} */
        var utc_string = (new Date(getTime() + 1E3 * ctx)).toUTCString().replace(/GMT$/, "UTC");
        /** @type {string} */
        var value = i + "=" + tag + "; expires=" + utc_string + "; path=/";
        var widgetId = (true === data || "true" === data) && parse();
        return widgetId && (value = value + "; domain=" + widgetId), document.cookie = value, true;
      } catch (t) {
        return false;
      }
    }
    /**
     * @param {string} fn
     * @return {?}
     */
    function require(fn) {
      var rndPlaceholder = void 0;
      if (fn && "string" == typeof fn) {
        try {
          /** @type {string} */
          var componentsStr = "; " + document.cookie;
          /** @type {!Array<string>} */
          var deadPool = componentsStr.split("; " + fn + "=");
          if (2 === deadPool.length) {
            /** @type {string} */
            rndPlaceholder = deadPool.pop().split(";").shift();
          }
        } catch (t) {
        }
      }
      return rndPlaceholder;
    }
    /**
     * @param {!Object} template
     * @return {?}
     */
    function parse(template) {
      if (!(template = template || window.location && window.location.hostname)) {
        return "";
      }
      var element = setup(template);
      return element ?  + element.domain +  + element.type : "";
    }
    /**
     * @param {!Object} token
     * @return {?}
     */
    function setup(token) {
      var p = {};
      /** @type {!RegExp} */
      var e = new RegExp("([a-z-0-9]{2,63}).([a-z.]{2,6})$");
      /** @type {(Array<string>|null)} */
      var m = e.exec(token);
      return m && m.length > 1 ? (p.domain = m[1], p.type = m[2], p.subdomain = token.replace(p.domain +  + p.type, "").slice(0, -1), p) : null;
    }
    /**
     * @param {!Element} module
     * @param {string} methodName
     * @param {string} fn
     * @return {undefined}
     */
    function isNative(module, methodName, fn) {
      var fn = module[methodName];
      if (fn) {
        /**
         * @return {?}
         */
        module[methodName] = function() {
          var a = b(arguments);
          try {
            reduce(fn, {
              PX460 : a
            });
          } catch (t) {
          }
          return fn.apply(this, a);
        };
      }
    }
    /**
     * @return {undefined}
     */
    function getNonJQueryHTML() {
      isNative(document, "getElementById", "PX633");
      isNative(document, "getElementsByClassName", "PX635");
      isNative(document, "querySelector", "PX636");
      isNative(document, "querySelectorAll", "PX637");
      isNative(document, "getElementsByTagName", "PX648");
      isNative(document, "getElementsByTagNameNS", "PX649");
      isNative(document, "getElementsByName", "PX650");
    }
    /**
     * @return {undefined}
     */
    function content() {
      observe(el, function(array, groups) {
        if (array && array.length) {
          /** @type {!Array} */
          var jitters = [];
          /** @type {number} */
          var i = 0;
          for (; i < array.length; i++) {
            jitters.push(fn(array[i]));
          }
          reduce("PX632", {
            PX460 : jitters
          }, true);
        }
        if (groups && groups.length) {
          /** @type {!Array} */
          var jitters = [];
          /** @type {number} */
          var i = 0;
          for (; i < groups.length; i++) {
            jitters.push(fn(groups[i]));
          }
          reduce("PX631", {
            PX460 : jitters
          }, true);
        }
      });
    }
    /**
     * @return {undefined}
     */
    function formatSourcePosition() {
      isNative(Element.prototype, "getAttribute", "PX628");
      isNative(Element.prototype, "getAttributeNode", "PX628");
      isNative(Element.prototype, "getAttributeNS", "PX628");
      isNative(Element.prototype, "getAttributeNodeNS", "PX628");
    }
    /**
     * @return {undefined}
     */
    function LoginForm() {
      /** @type {function(this:HTMLFormElement): undefined} */
      var fn = HTMLFormElement.prototype.submit;
      /**
       * @return {undefined}
       */
      HTMLFormElement.prototype.submit = function() {
        var i = b(arguments);
        try {
          reduce("PX496", i);
        } catch (t) {
        }
        return fn.apply(this, i);
      };
    }
    /**
     * @param {(Node|Window)} npt
     * @param {?} opts
     * @return {undefined}
     */
    function patchValueProperty(npt, opts) {
      if ("function" == typeof Object.defineProperty && "function" == typeof Object.getOwnPropertyDescriptor && "function" == typeof Object.getPrototypeOf) {
        var parent = getPrototypeOf(Object.getPrototypeOf(npt), opts);
        if (null === parent) {
          var position = extend({}, parent, {
            get : function() {
              try {
                reduce("PX638", {
                  PX640 : fn(this, true),
                  PX641 : opts
                });
              } catch (t) {
              }
              if ("function" == typeof parent.get) {
                return parent.get.call(this);
              }
            },
            set : function(cellsHash) {
              try {
                reduce("PX639", {
                  PX640 : fn(this, true),
                  PX641 : opts
                });
              } catch (t) {
              }
              if ("function" == typeof parent.set) {
                return parent.set.call(this, cellsHash);
              }
            }
          });
          Object.defineProperty(npt, opts, position);
        }
      }
    }
    /**
     * @param {!Object} target
     * @param {?} value
     * @return {?}
     */
    function getPrototypeOf(target, value) {
      for (; null !== target;) {
        /** @type {(ObjectPropertyDescriptor>|undefined)} */
        var rv = Object.getOwnPropertyDescriptor(target, value);
        if (rv) {
          return rv;
        }
        /** @type {(Object|null)} */
        target = Object.getPrototypeOf(target);
      }
      return null;
    }
    /**
     * @return {undefined}
     */
    function loop() {
      if (null !== v && pastExecs.length < _to) {
        var now = void 0;
        /** @type {string} */
        now = "-" === v.a[0] || "-" === v.c[0] ? "0" : v.e + " " + v.g;
        if (now !== pastExecs[pastExecs.length - 1]) {
          pastExecs.push(now);
          store.push(push(tag));
        }
      }
      /** @type {null} */
      v = null;
    }
    /**
     * @return {undefined}
     */
    function main() {
      if (null === v) {
        v = {};
        setTimeout(loop, 0);
      }
      v.a = e.style.left;
      v.c = e.style.top;
      v.e = boxInput.style.width;
      v.g = boxInput.style.height;
    }
    /**
     * @return {undefined}
     */
    function createNode() {
      if ("function" == typeof MutationObserver) {
        /** @type {function(this:HTMLDivElement, (Node|null)): !Node} */
        var t = HTMLDivElement.prototype.appendChild;
        /** @type {boolean} */
        var hasApplicableItems = false;
        /**
         * @param {(Node|null)} target
         * @return {!Node}
         */
        HTMLDivElement.prototype.appendChild = function(target) {
          /** @type {!Node} */
          var r = t.apply(this, b(arguments));
          return !hasApplicableItems && target instanceof HTMLIFrameElement && target.src.indexOf(module) >= 0 && (hasApplicableItems = true, delete HTMLDivElement.prototype.appendChild, e = this.parentElement, boxInput = target, addEvent(e, main), addEvent(boxInput, main)), r;
        };
      }
    }
    /**
     * @return {?}
     */
    function destroy() {
      if (input = document.getElementById(ctx)) {
        var value = el.getElementsByTagName(m)[0];
        return value && /recaptcha/gi.test(value.getAttribute("src") || "") && (focus = value), focus && input;
      }
    }
    /**
     * @return {undefined}
     */
    function view() {
      $("PX706");
      createNode();
      /** @type {(Element|null)} */
      var btnLineWidthDone = document.getElementById(freezeheadercontentid);
      getAll();
      getNonJQueryHTML();
      formatSourcePosition();
      patchValueProperty(input, poisson);
      patchValueProperty(input, gamma);
      patchValueProperty(el, gamma);
      addEvent(el, listener);
      addEvent(input, listener);
      addEvent(focus, listener);
      addEvent(btnLineWidthDone, listener);
      content();
      LoginForm();
      mutations = push("PX706");
      $(tag);
    }
    /**
     * @return {undefined}
     */
    function getAll() {
      var value = void 0;
      if ("function" == typeof window[feature]) {
        value = window[feature];
        /**
         * @return {undefined}
         */
        window[feature] = function() {
          var a = b(arguments);
          try {
            processEvents(true);
          } catch (t) {
          }
          value.apply(this, a);
        };
      }
    }
    /**
     * @param {!Object} n
     * @param {!Object} e
     * @param {!Object} type
     * @return {undefined}
     */
    function listener(n, e, type) {
      if (e) {
        run("PX611", {
          PX72 : fn(n, true),
          PX612 : e || "",
          PX626 : type || ""
        });
      }
    }
    /**
     * @param {string} callback
     * @param {?} id
     * @return {undefined}
     */
    function reduce(callback, id) {
      var e = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
      if (targetOffsetHeight < clientHeight) {
        var baseParts = split(concat());
        var BROWSER_ENGINES = baseParts[baseParts.length - 1] || {};
        var i = BROWSER_ENGINES[0] || "";
        var steps = BROWSER_ENGINES[1] || "";
        if (!e && -1 !== i.indexOf(verPref)) {
          return;
        }
        targetOffsetHeight++;
        todos.push(extend({
          PX71 : callback,
          PX206 : forEach(updatedList, i),
          PX205 : forEach(_dropIndicators, steps)
        }, id));
      }
    }
    /**
     * @param {boolean} events
     * @return {undefined}
     */
    function processEvents(events) {
      if (!Sf) {
        /** @type {boolean} */
        Sf = true;
        loop();
        var pref = {
          PX629 : todos,
          PX642 : todos.length,
          PX646 : updatedList,
          PX647 : _dropIndicators,
          PX645 : events,
          PX706 : mutations,
          PX644 : push(tag),
          PX744 : pastExecs,
          PX745 : store
        };
        if (events) {
          var baseParts = split(concat());
          var subscriptions = baseParts[baseParts.length - 1] || {};
          pref.PX206 = forEach(updatedList, subscriptions[0]);
          pref.PX205 = forEach(_dropIndicators, subscriptions[1]);
        }
        run("PX627", pref);
      }
    }
    /**
     * @return {undefined}
     */
    function Loader() {
      if ("function" == typeof Object.getOwnPropertyDescriptor) {
        create();
      }
    }
    /**
     * @return {?}
     */
    function appendChild() {
      if (destroy()) {
        return view(), void setTimeout(processEvents.bind(this, false));
      }
      /** @type {function(this:HTMLDivElement, (Node|null)): !Node} */
      var t = HTMLDivElement.prototype.appendChild;
      /** @type {boolean} */
      var hasWidgets = false;
      /**
       * @param {(Node|null)} child
       * @return {!Node}
       */
      HTMLDivElement.prototype.appendChild = function(child) {
        /** @type {!Node} */
        var r = t.apply(this, b(arguments));
        return !hasWidgets && HTMLIFrameElement.prototype.isPrototypeOf(child) && child.src.indexOf(shuffle) >= 0 && (hasWidgets = true, delete HTMLDivElement.prototype.appendChild, destroy() && (view(), setTimeout(processEvents.bind(this, false)))), r;
      };
    }
    /**
     * @param {!Node} e
     * @return {?}
     */
    function getId(e) {
      return !!(e.firstElementChild && e.firstElementChild instanceof window.Element && "function" == typeof e.firstElementChild.getAttribute) && e.firstElementChild.getAttribute(ssrAttribute) === bottom;
    }
    /**
     * @return {?}
     */
    function create() {
      /** @type {(Element|null)} */
      var obj = document.getElementById(eleId);
      if (obj && obj instanceof window.Element) {
        if (getId(obj)) {
          return el = obj.firstChild, void appendChild();
        }
        /** @type {(ObjectPropertyDescriptor<Element.prototype>|undefined)} */
        var innerHTML = Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
        if (innerHTML) {
          var result = extend({}, innerHTML);
          /** @type {boolean} */
          var outputFn = false;
          /**
           * @param {?} o
           * @return {?}
           */
          result.set = function(o) {
            var result = innerHTML.set.call(this, o);
            return outputFn || (outputFn = true, getId(obj) && (el = obj.firstChild, appendChild())), result;
          };
          Object.defineProperty(obj, "innerHTML", result);
        }
      }
    }
    /**
     * @return {?}
     */
    function setStaticFilesRootRegExp() {
      return slice() ? void(startsWith() || endsWith()) : sendMessage() ? getName() : watch();
    }
    /**
     * @return {undefined}
     */
    function watch() {
      if (!indexOf() && Object.defineProperty) {
        /** @type {null} */
        window[parseExpression()] = null;
        Object.defineProperty(window, parseExpression(), {
          set : function(value) {
            builtinEnabled = value;
            setTimeout(startup, 0);
          },
          get : function() {
            return builtinEnabled;
          }
        });
      }
    }
    /**
     * @return {?}
     */
    function startup() {
      if (builtinEnabled) {
        if (startsWith()) {
          return void run("PX2", {
            PX876 : "PX557"
          });
        }
        if ("PX557" === remove()) {
          endsWith();
        }
        Loader();
      }
    }
    /**
     * @return {?}
     */
    function startsWith() {
      return indexOf() === number;
    }
    /**
     * @return {?}
     */
    function parseExpression() {
      return "_" + property.replace(/^PX|px/, "") + "handler";
    }
    /**
     * @return {?}
     */
    function slice() {
      var val = parseExpression();
      return window[val];
    }
    /**
     * @param {number} text
     * @param {string} position
     * @return {undefined}
     */
    function endsWith(text, position) {
      var args = slice();
      var error = args && args.PX762;
      if (error) {
        /** @type {function(!Object): undefined} */
        args.PX763 = body;
        error(status, text, position);
      }
    }
    /**
     * @param {!Object} ctx
     * @return {undefined}
     */
    function body(ctx) {
      if (left && !ctx.PX755) {
        ctx.PX755 = left;
      }
      run("PX761", write(ctx));
    }
    /**
     * @return {?}
     */
    function uiCleanupFunc() {
      var name = remove();
      return "PX557" === name || "PX560" === name;
    }
    /**
     * @return {?}
     */
    function sendMessage() {
      /** @type {string} */
      var id = "__" + property + "__";
      return "function" == typeof window[id] && !!document.getElementById(eleId);
    }
    /**
     * @return {undefined}
     */
    function getName() {
      /** @type {string} */
      var id = "__" + property + "__";
      var ret = window[id];
      if (!(Bf || "function" != typeof ret)) {
        /** @type {boolean} */
        Bf = true;
        ret("", block, status);
      }
    }
    /**
     * @param {?} name
     * @param {?} elem
     * @return {undefined}
     */
    function block(name, elem) {
      if (!Zf) {
        /** @type {boolean} */
        Zf = true;
        last = elem;
        var args = concat();
        run("PX561", {
          PX70 : append(),
          PX34 : command(args),
          PX562 : name
        });
      }
    }
    /**
     * @return {undefined}
     */
    function execute() {
      if ("function" == typeof last) {
        last(left, isUndefined(), dirname(), value, tagName);
      }
    }
    /**
     * @return {?}
     */
    function remove() {
      if (!indexOf() || _na) {
        return _na;
      }
      if (reducer(slice())) {
        var type = indexOf();
        /** @type {string} */
        _na = type === number || type === ssh_dss ? "PX560" : "PX557";
      } else {
        if (sendMessage()) {
          /** @type {string} */
          _na = "PX560";
        } else {
          if (setupRouteTest()) {
            /** @type {string} */
            _na = "PX557";
          } else {
            if (!("Access to this page has been denied." !== document.title && "Access to This Page Has Been Blocked" !== document.title)) {
              /** @type {string} */
              _na = "PX558";
            }
          }
        }
      }
      return _na;
    }
    /**
     * @param {string} size
     * @param {?} input
     * @param {?} meta
     * @param {?} callback
     * @return {undefined}
     */
    function imageSize(size, input, meta, callback) {
      var sources = slice();
      var log = sources && sources.PX764;
      if (log) {
        log(size, input, meta, callback);
      }
    }
    /**
     * @return {?}
     */
    function setupRouteTest() {
      return !!document.getElementById(eleId);
    }
    /**
     * @return {?}
     */
    function binsearch() {
      return left;
    }
    /**
     * @param {string} t
     * @param {!Object} ctx
     * @return {undefined}
     */
    function status(t, ctx) {
      run(t, write(ctx));
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function write(obj) {
      var result = {
        PX70 : obj.PX70 || append(),
        PX34 : command(concat()),
        PX610 : true
      };
      var propertyName;
      for (propertyName in obj) {
        var value = obj[propertyName];
        if ("object" !== (void 0 === value ? "undefined" : each(value)) || translate(value) || null === value) {
          result[propertyName] = value;
        } else {
          var name;
          for (name in value) {
            result[name] = value[name];
          }
        }
      }
      return result;
    }
    /**
     * @return {?}
     */
    function isLowS() {
      return !!slice() && uiCleanupFunc();
    }
    /**
     * @param {string} node
     * @param {number} s
     * @param {string} value
     * @return {undefined}
     */
    function getData(node, s, value) {
      /** @type {string} */
      left = node;
      /** @type {number} */
      s = +s;
      /** @type {number} */
      s = "number" == typeof s && s > 0 && s < samplecount ? s : Math.round(1E3 * (2 * Math.random() + 1));
      value = "string" == typeof value && value || apply(32);
      if (startsWith()) {
        endsWith(s, value);
      }
    }
    /**
     * @return {?}
     */
    function oEOR() {
      return left === instance;
    }
    /**
     * @return {undefined}
     */
    function height() {
      imageSize("0");
    }
    /**
     * @param {!Object} element
     * @return {undefined}
     */
    function transform(element) {
      if (removeContent && element) {
        $("PX846");
        var selfPos = getTouch(element);
        run("PX297", {
          PX38 : element.type || "",
          PX70 : append(),
          PX157 : h(element),
          PX72 : fn(createElement(element)),
          PX34 : concat(),
          PX263 : offset(),
          PX78 : selfPos.x,
          PX79 : selfPos.y
        });
        /** @type {boolean} */
        pageId = true;
        sub_rows();
        push("PX846");
      }
    }
    /**
     * @return {undefined}
     */
    function sub_rows() {
      /** @type {boolean} */
      removeContent = false;
      fetchSpecificAd();
    }
    /**
     * @param {string} open
     * @return {undefined}
     */
    function dispatch(open) {
      $("PX846");
      /** @type {!Function} */
      var fn = open ? bind : removeEvent;
      /** @type {number} */
      var i = 0;
      for (; i < touchEvents.length; i++) {
        fn(document.body, touchEvents[i], transform);
      }
      push("PX846");
    }
    /**
     * @return {undefined}
     */
    function confirm() {
      dispatch(true);
    }
    /**
     * @return {undefined}
     */
    function fetchSpecificAd() {
      dispatch(false);
    }
    /**
     * @return {undefined}
     */
    function routeLeaveFunction() {
      ready(function() {
        if (document.body) {
          confirm();
        }
      });
    }
    /**
     * @return {?}
     */
    function getParamUIControl() {
      return pageId;
    }
    /**
     * @param {!Object} s
     * @return {?}
     */
    function linkageToJSON(s) {
      var n = fn(s, true);
      return n ? unwrap(n) : 0;
    }
    /**
     * @param {!Event} event
     * @return {undefined}
     */
    function move(event) {
      $("PX847");
      try {
        if ("mousemove" === type) {
          mousemove();
        }
        if (type === id) {
          reset();
        }
        var data = get(event, true);
        var e = extractPointers(event);
        data.PX78 = e.pageX;
        data.PX79 = e.pageY;
        if (event && "click" === event.type) {
          /** @type {string} */
          data.PX241 = "" + event.buttons;
          data.PX263 = offset(event.target);
        }
        line(data);
      } catch (t) {
      }
      push("PX847");
    }
    /**
     * @param {!Object} e
     * @return {undefined}
     */
    function onkeydown(e) {
      if ($("PX847"), e) {
        try {
          if ("mousemove" === type) {
            mousemove();
          }
          if (type === id) {
            reset();
          }
          var key = get(e, true);
          if (upCode(e.keyCode)) {
            key.PX171 = e.keyCode;
          }
          if ("keydown" === e.type) {
            /** @type {number} */
            key.PX226 = "string" == typeof e.key ? e.key.length : -1;
            /** @type {boolean} */
            key.PX227 = "number" == typeof e.keyCode;
            /** @type {number} */
            key.PX233 = "string" == typeof e.code ? e.code.length : -1;
            /** @type {(boolean|undefined)} */
            key.PX854 = true === e.ctrlKey || void 0;
            /** @type {(boolean|undefined)} */
            key.PX855 = true === e.shiftKey || void 0;
            /** @type {(boolean|undefined)} */
            key.PX856 = true === e.altKey || void 0;
          }
          line(key);
        } catch (t) {
        }
      }
      push("PX847");
    }
    /**
     * @param {!Event} e
     * @return {undefined}
     */
    function mousedown(e) {
      if ($("PX847"), targetOffsetWidth < clientWidth) {
        try {
          var data = get(e, true);
          data.PX70 = append();
          data.PX554 = paste(e);
          line(data);
          targetOffsetWidth++;
        } catch (t) {
        }
      }
      push("PX847");
    }
    /**
     * @param {!Event} event
     * @return {?}
     */
    function paste(event) {
      /** @type {!Array} */
      var result = [];
      try {
        if (!event.clipboardData || !event.clipboardData.items) {
          return null;
        }
        /** @type {number} */
        var i = 0;
        for (; i < event.clipboardData.items.length; i++) {
          var acceptsEntry = event.clipboardData.items[i];
          result.push({
            PX555 : acceptsEntry.kind,
            PX556 : acceptsEntry.type
          });
        }
      } catch (t) {
      }
      return result;
    }
    /**
     * @param {!Event} event
     * @return {undefined}
     */
    function onMouseMove(event) {
      $("PX847");
      try {
        var end = getTime();
        /** @type {number} */
        var count = end - begin;
        if (type = "mousemove", mouseMove(event, end), count > maximum) {
          begin = end;
          var temp = extractPointers(event);
          var touch = {
            PX78 : temp.pageX,
            PX79 : temp.pageY,
            PX70 : append(end)
          };
          if (null === events.mousemove) {
            var evt = get(event, false);
            /** @type {!Array} */
            evt.coordination_start = [touch];
            /** @type {!Array} */
            evt.coordination_end = [];
            events.mousemove = evt;
          } else {
            var services = events.mousemove.coordination_start;
            if (services.length >= _this.mousemove / 2) {
              services = events.mousemove.coordination_end;
              if (services.length >= _this.mousemove / 2) {
                services.shift();
              }
            }
            services.push(touch);
          }
        }
      } catch (t) {
      }
      push("PX847");
    }
    /**
     * @param {!Event} event
     * @param {!Function} node
     * @return {undefined}
     */
    function mouseMove(event, node) {
      $("PX847");
      if (event && event.movementX && event.movementY) {
        if (argsOut.length < outCount) {
          argsOut.push(+event.movementX.toFixed(2) + Icon + +event.movementY.toFixed(2) + Icon + append(node));
        }
        if (child.length < lower) {
          child.push(drag(event));
        }
      }
      push("PX847");
    }
    /**
     * @param {!Object} event
     * @return {undefined}
     */
    function clear(event) {
      if (!suspended && event) {
        $("PX847");
        /** @type {boolean} */
        suspended = true;
        setTimeout(function() {
          /** @type {boolean} */
          suspended = false;
        }, maximum);
        var x = get(event, false);
        /** @type {number} */
        var tmp_flow_path = Math.max(document.documentElement.scrollTop || 0, document.body.scrollTop || 0);
        /** @type {number} */
        var filename = Math.max(document.documentElement.scrollLeft || 0, document.body.scrollLeft || 0);
        lines.push(tmp_flow_path + "," + filename);
        /** @type {number} */
        x.PX857 = tmp_flow_path;
        /** @type {number} */
        x.PX858 = filename;
        line(x);
        if (lines.length >= chunkSize) {
          removeEvent(document, "scroll", clear);
        }
        push("PX847");
      }
    }
    /**
     * @param {!Object} event
     * @return {undefined}
     */
    function onScroll(event) {
      $("PX847");
      try {
        var end = getTime();
        if (ds) {
          var es = events[id];
          type = id;
          begin = end;
          var a = event.deltaY || event.wheelDelta || event.detail;
          if (a = +a.toFixed(2), null === es) {
            cs++;
            var fn = get(event, false);
            /** @type {!Array} */
            fn.PX172 = [a];
            fn.PX173 = append(end);
            events[id] = fn;
          } else {
            if (_this.mousewheel <= events[id].PX172.length) {
              reset();
              /** @type {boolean} */
              ds = false;
            } else {
              events[id].PX172.push(a);
            }
          }
        }
      } catch (t) {
      }
      push("PX847");
    }
    /**
     * @return {undefined}
     */
    function mousemove() {
      if ($("PX847"), events.mousemove) {
        var readersLength = events.mousemove.coordination_start.length;
        var n = events.mousemove.coordination_start[readersLength - 1].PX70;
        var lastname = submit(sortBy(css(events.mousemove.coordination_start)));
        var value = sortBy(css(events.mousemove.coordination_end));
        if (value.length > 0) {
          value[0].PX70 -= n;
        }
        var otherNames = submit(value);
        events.mousemove.PX172 = "" !== otherNames ? lastname + "|" + otherNames : lastname;
        delete events.mousemove.coordination_start;
        delete events.mousemove.coordination_end;
        line(events.mousemove, "mousemove");
        /** @type {null} */
        events.mousemove = null;
      }
      push("PX847");
    }
    /**
     * @return {undefined}
     */
    function reset() {
      $("PX847");
      if (events[id]) {
        cs++;
        if (void 0 === ref || events[id].PX172.length > ref.PX172.length) {
          ref = events[id];
        }
        events[id].PX174 = append();
      }
      /** @type {null} */
      events[id] = null;
      push("PX847");
    }
    /**
     * @param {!Object} type
     * @param {boolean} n
     * @return {?}
     */
    function get(type, n) {
      if ($("PX847"), !type) {
        return null;
      }
      var result = {
        PX71 : _convertTagType(type.type),
        PX159 : h(type)
      };
      if (n) {
        var r = createElement(type);
        if (r) {
          var output = log(r);
          result.PX72 = linkageToJSON(r);
          result.PX73 = processRowgroupHeader(r);
          result.PX74 = r.offsetWidth;
          result.PX75 = r.offsetHeight;
          result.PX76 = output.top;
          result.PX77 = output.left;
        } else {
          /** @type {number} */
          result.PX72 = 0;
        }
      }
      return push("PX847"), result;
    }
    /**
     * @param {!Element} elem
     * @return {?}
     */
    function processRowgroupHeader(elem) {
      return "submit" === elem.type ? elem.type : elem.nodeName ? elem.nodeName.toLowerCase() : "";
    }
    /**
     * @param {?} data
     * @param {string} type
     * @return {undefined}
     */
    function line(data, type) {
      if (ns) {
        var start = getTime();
        if ("mousemove" !== type && type !== id) {
          data.PX70 = append(start);
        }
        var res = clone(data);
        reconnectTryTimes = reconnectTryTimes + 1.4 * res.length;
        if (reconnectTryTimes >= maxReconnectTryTimes) {
          if (ref) {
            output.push(ref);
          }
          animate("PX758");
        } else {
          output.push(data);
          if (output.length >= limit) {
            if (ref) {
              output.push(ref);
            }
            animate("PX760");
          }
        }
      }
    }
    /**
     * @return {undefined}
     */
    function attemptRun() {
      animate("PX759");
    }
    /**
     * @param {string} callback
     * @return {undefined}
     */
    function animate(callback) {
      if (ns) {
        /** @type {boolean} */
        ns = false;
        $("PX847");
        if (output.length > 0 || argsOut.length > 0) {
          run("PX175", {
            PX82 : document.body && document.body.offsetWidth + "x" + document.body.offsetHeight || "",
            PX176 : callback,
            PX177 : extractCea608Data(),
            PX181 : value,
            PX178 : cs,
            PX179 : $$hash$$Symbol_registry,
            PX180 : parent,
            PX58 : output,
            PX410 : argsOut.join("|"),
            PX608 : child.length > 0 ? css(child) : void 0,
            PX584 : lines.length > 0 ? lines : void 0,
            PX462 : getParamUIControl()
          });
        }
        push("PX847");
        useSandbox();
      }
    }
    /**
     * @param {string} on
     * @return {undefined}
     */
    function before(on) {
      $("PX847");
      /** @type {!Function} */
      var addEvent = on ? bind : removeEvent;
      /** @type {number} */
      var layer_i = 0;
      for (; layer_i < crossfilterable_layers.length; layer_i++) {
        addEvent(document.body, crossfilterable_layers[layer_i], move);
      }
      /** @type {number} */
      var n = 0;
      for (; n < names.length; n++) {
        addEvent(document.body, names[n], onkeydown);
      }
      /** @type {number} */
      var j = 0;
      for (; j < eventTypes.length; j++) {
        addEvent(document, eventTypes[j], mousedown);
      }
      /** @type {number} */
      var i = 0;
      for (; i < ids.length; i++) {
        if ("mousemove" === ids[i]) {
          addEvent(document.body, ids[i], onMouseMove);
        }
        if (ids[i] === id) {
          addEvent(document.body, ids[i], onScroll);
        }
      }
      addEvent(document, "scroll", clear);
      addEvent(document.body, "focus", onkeydown, {
        capture : true,
        passive : true
      });
      addEvent(document.body, "blur", onkeydown, {
        capture : true,
        passive : true
      });
      push("PX847");
    }
    /**
     * @return {undefined}
     */
    function mouseDown() {
      /**
       * @return {undefined}
       */
      function update() {
        if (hoverSelectionTimeout) {
          window.clearTimeout(hoverSelectionTimeout);
        }
        /** @type {number} */
        hoverSelectionTimeout = setTimeout(function() {
          animate("60_sec_rest");
        }, 6E4);
      }
      /**
       * @return {undefined}
       */
      function mouseMove() {
        if (showAboveTimeout) {
          window.clearTimeout(showAboveTimeout);
        }
        showAboveTimeout = window.setTimeout(function() {
          update();
        }, 500);
      }
      var showAboveTimeout = void 0;
      /** @type {function(): undefined} */
      document.onmousemove = mouseMove;
    }
    /**
     * @param {?} x
     * @return {?}
     */
    function unwrap(x) {
      return $$hash$$Symbol_registry[x] || ($$hash$$Symbol_registry[x] = $$hash$$Symbol_id++), $$hash$$Symbol_id;
    }
    /**
     * @param {!NodeList} t
     * @return {?}
     */
    function submit(t) {
      /** @type {string} */
      var ret = "";
      /** @type {number} */
      var k = 0;
      for (; k < t.length; k++) {
        if (0 !== k) {
          /** @type {string} */
          ret = ret + "|";
        }
        /** @type {string} */
        ret = ret + (t[k].PX78 + "," + t[k].PX79 + "," + t[k].PX70);
      }
      return ret;
    }
    /**
     * @param {!Object} p
     * @return {?}
     */
    function sortBy(p) {
      /** @type {!Array} */
      var result = [];
      if (p.length > 0) {
        result.push(p[0]);
        /** @type {number} */
        var i = 1;
        for (; i < p.length; i++) {
          var embedResult = {
            PX78 : p[i].PX78,
            PX79 : p[i].PX79,
            PX70 : p[i].PX70 - p[i - 1].PX70
          };
          result.push(embedResult);
        }
      }
      return result;
    }
    /**
     * @return {undefined}
     */
    function doSelect() {
      mouseDown();
      before(true);
    }
    /**
     * @return {undefined}
     */
    function useSandbox() {
      before(false);
    }
    /**
     * @return {undefined}
     */
    function bulkSelection() {
      ready(function() {
        doSelect();
      });
      setTimeout(animate);
    }
    /**
     * @param {!Event} event
     * @return {?}
     */
    function drag(event) {
      var c = event.touches || event.changedTouches;
      var e = c && c[0];
      return +(e ? e.clientX : event.clientX).toFixed(0) + "," + +(e ? e.clientY : event.clientY).toFixed(0) + "," + _detectAltGrKeyDown(event);
    }
    /**
     * @param {!Object} e
     * @return {?}
     */
    function _detectAltGrKeyDown(e) {
      return +(e.timestamp || e.timeStamp || 0).toFixed(0);
    }
    /**
     * @param {!Array} p
     * @return {undefined}
     */
    function findNode(p) {
      p = p.splice(0);
      for (; p.length > 0;) {
        try {
          p.shift()();
        } catch (t) {
        }
      }
    }
    /**
     * @param {string} i
     * @return {undefined}
     */
    function getOffset(i) {
      if (resultses[i]) {
        findNode(resultses[i]);
      }
    }
    /**
     * @return {undefined}
     */
    function add_monitoredItem() {
      /** @type {boolean} */
      Rs = true;
      findNode(d);
    }
    /**
     * @param {string} key
     * @param {number} data
     * @param {string} value
     * @return {undefined}
     */
    function find(key, data, value) {
      /** @type {string} */
      memo[key] = value;
      debug(name + key, data || err, value);
    }
    /**
     * @param {string} k
     * @return {?}
     */
    function map(k) {
      return memo[k] || (memo[k] = require(name + k)), memo[k];
    }
    /**
     * @param {string} keys
     * @return {?}
     */
    function zipObject(keys) {
      return keys === F1;
    }
    /**
     * @param {string} properties
     * @return {?}
     */
    function isArray(properties) {
      return zipObject(map(properties));
    }
    /**
     * @param {!Function} keys
     * @return {?}
     */
    function getComposeDefaults(keys) {
      if (Rs) {
        return void keys();
      }
      d.push(keys);
    }
    /**
     * @param {?} i
     * @param {!Function} callback
     * @return {?}
     */
    function finalize(i, callback) {
      if (memo[i]) {
        return void callback();
      }
      if (!resultses[i]) {
        /** @type {!Array} */
        resultses[i] = [];
      }
      resultses[i].push(callback);
    }
    /**
     * @param {string} props
     * @return {undefined}
     */
    function enter(props) {
      props = props ? props.split(",") : [];
      /** @type {number} */
      var i = 0;
      for (; i < props.length; i++) {
        var e = props[i].split(":");
        addPoint(e[0], e[1], F1);
      }
    }
    /**
     * @param {string} a
     * @param {undefined} b
     * @param {string} name
     * @return {undefined}
     */
    function addPoint(a, b, name) {
      find(a, b, name);
      getOffset(a);
    }
    /**
     * @return {undefined}
     */
    function upperCaseAlphabet() {
      transitionDuration = isArray(keyCodes.i);
    }
    /**
     * @return {?}
     */
    function pick() {
      /** @type {number} */
      var majorGraduationTextSize = parseInt(map(keyCodes.j));
      return isNaN(majorGraduationTextSize) ? _previousId : majorGraduationTextSize;
    }
    /**
     * @param {number} from
     * @return {?}
     */
    function arc(from) {
      var limit = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : pick();
      return !!from && (new Date).getTime() - from > 1e3 * limit;
    }
    /**
     * @param {string} t
     * @param {number} n
     * @return {undefined}
     */
    function run(t, n) {
      /** @type {number} */
      n.PX850 = ni++;
      n.PX851 = tick() || getTime();
      if (verify(t, n)) {
        queue.push({
          t : t,
          d : n,
          ts : (new Date).getTime()
        });
        if ("PX761" === t) {
          attemptRun();
          pusherInstance.trigger("PX761");
        }
      } else {
        p.push({
          t : t,
          d : n,
          ts : (new Date).getTime()
        });
      }
    }
    /**
     * @param {string} method
     * @param {number} args
     * @return {?}
     */
    function verify(method, args) {
      return isLowS() && queue && callListMethod(method, args);
    }
    /**
     * @return {undefined}
     */
    function loadImageHead() {
      /** @type {null} */
      queue = null;
    }
    /**
     * @param {!Object} args
     * @param {number} method
     * @return {?}
     */
    function callListMethod(args, method) {
      return !!method.PX610 || (equals(old_value, args) > -1 ? (method.PX610 = true, true) : void 0);
    }
    /**
     * @param {string} type
     * @return {undefined}
     */
    function excute(type) {
      /** @type {number} */
      binTarget = 1;
      clearMessagesUnreadStatus(type);
    }
    /**
     * @param {string} id
     * @return {undefined}
     */
    function clearMessagesUnreadStatus(id) {
      /** @type {string} */
      value = id;
    }
    /**
     * @return {?}
     */
    function first() {
      try {
        return window.sessionStorage.pxsid;
      } catch (t) {
        return "";
      }
    }
    /**
     * @param {!Object} path
     * @return {?}
     */
    function parseParams(path) {
      /** @type {null} */
      var params = null;
      var title = decode() || "";
      if (plugin.pxParams && plugin.pxParams.length) {
        params = {};
        /** @type {number} */
        var i = 0;
        for (; i < plugin.pxParams.length; i++) {
          params["p" + (i + 1)] = plugin.pxParams[i];
        }
      } else {
        if (path) {
          /** @type {number} */
          var l = 1;
          for (; l <= 10; l++) {
            var page = path[title + "_pxParam" + l];
            if (void 0 !== page) {
              params = params || {};
              /** @type {string} */
              params["p" + l] = page + "";
            }
          }
        }
      }
      return params;
    }
    /**
     * @return {?}
     */
    function decode() {
      var id = String();
      return window._pxAppId === id ? "" : id;
    }
    /**
     * @return {?}
     */
    function String() {
      return property;
    }
    /**
     * @param {string} name
     * @return {undefined}
     */
    function mixin(name) {
      /** @type {string} */
      head = name;
    }
    /**
     * @return {?}
     */
    function dirname() {
      return head;
    }
    /**
     * @param {number} callback
     * @return {undefined}
     */
    function waitUntilQuiet(callback) {
      /** @type {number} */
      cl = callback;
    }
    /**
     * @param {number} sortByMoney
     * @return {undefined}
     */
    function dr(sortByMoney) {
      /** @type {number} */
      ul = sortByMoney;
    }
    /**
     * @return {?}
     */
    function resolveClass() {
      return cl;
    }
    /**
     * @return {?}
     */
    function createUl() {
      return ul;
    }
    /**
     * @param {string} body
     * @return {undefined}
     */
    function getPublishFetchOptions(body) {
      if (element && body !== element) {
        /** @type {null} */
        x = null;
      }
      /** @type {string} */
      element = body;
    }
    /**
     * @param {!NodeList} v
     * @return {undefined}
     */
    function setValidMoves(v) {
      /** @type {!NodeList} */
      node = v;
    }
    /**
     * @param {?} time
     * @return {undefined}
     */
    function mktime_f(time) {
      LAST_NETWORKING_RESTART_TIME = time;
    }
    /**
     * @param {?} data
     * @return {undefined}
     */
    function trim(data) {
      filtered = data;
    }
    /**
     * @param {?} n
     * @param {?} s
     * @return {undefined}
     */
    function mianzi(n, s) {
      val = n;
      lspace = s;
    }
    /**
     * @param {?} expression
     * @return {undefined}
     */
    function where(expression) {
      buckets = expression;
    }
    /**
     * @return {?}
     */
    function isUndefined() {
      return element;
    }
    /**
     * @return {?}
     */
    function maintainSizeBalancedTree() {
      return node;
    }
    /**
     * @return {?}
     */
    function uuid() {
      return LAST_NETWORKING_RESTART_TIME;
    }
    /**
     * @return {?}
     */
    function filterProblems() {
      return filtered;
    }
    /**
     * @return {?}
     */
    function fnOrValue() {
      return val;
    }
    /**
     * @return {?}
     */
    function moment() {
      return lspace;
    }
    /**
     * @return {?}
     */
    function Number() {
      return buckets;
    }
    /**
     * @return {?}
     */
    function _subu() {
      return x;
    }
    /**
     * @return {?}
     */
    function ctor() {
      return uriTemplate || (uriTemplate = require(template)), uriTemplate;
    }
    /**
     * @return {?}
     */
    function indexOf() {
      return window[api];
    }
    /**
     * @return {?}
     */
    function listen() {
      return p.some(function(__a) {
        return "PX203" === __a.t;
      });
    }
    /**
     * @param {string} n
     * @param {?} context
     * @param {!Object} id
     * @param {!Object} name
     * @return {undefined}
     */
    function inject(n, context, id, name) {
      try {
        if (!n || !context || !id && !name || -1 !== equals(ll, n)) {
          return;
        }
        if (ll.push(n), id && document.getElementsByName(id).length > 0) {
          return;
        }
        if (name && document.getElementsByClassName(name).length > 0) {
          return;
        }
        /** @type {!Element} */
        var f = document.createElement(context);
        /** @type {string} */
        f.style.display = "none";
        if (id) {
          /** @type {!Object} */
          f.name = id;
        }
        if (name) {
          /** @type {!Object} */
          f.className = name;
        }
        bind(f, "click", function() {
          var input = concat();
          var contents = split(input);
          var t = {
            PX72 : n,
            PX224 : id || "",
            PX223 : name || "",
            PX34 : input
          };
          if (contents.length > 0) {
            var names = contents[contents.length - 1];
            t.PX206 = names[0] || "";
            t.PX205 = names[1] || "";
          }
          run("PX222", t);
        });
        if (document.body) {
          document.body.insertBefore(f, document.body.children[0]);
        }
      } catch (t) {
      }
    }
    /**
     * @param {?} route
     * @param {?} ast
     * @return {undefined}
     */
    function after(route, ast) {
    }
    /**
     * @param {?} scale
     * @return {undefined}
     */
    function sort_scale(scale) {
    }
    /**
     * @param {!Object} name
     * @return {?}
     */
    function is(name) {
      try {
        var value = window[name];
        return "object" === (void 0 === value ? "undefined" : each(value)) && refresh(value);
      } catch (t) {
        return false;
      }
    }
    /**
     * @param {!Object} storage
     * @return {?}
     */
    function refresh(storage) {
      try {
        var start = getTime();
        /** @type {string} */
        var i = "tk_" + start;
        /** @type {string} */
        var x = "tv_" + start;
        storage.setItem(i, x);
        var current_char = storage.getItem(i);
        return storage.removeItem(i), null === storage.getItem(i) && current_char === x;
      } catch (t) {
        return false;
      }
    }
    /**
     * @param {!Object} type
     * @return {?}
     */
    function getStorage(type) {
      return is(type) ? loadThreadList(type) : coreStorage();
    }
    /**
     * @param {!Object} key
     * @return {?}
     */
    function loadThreadList(key) {
      var memoryStore = window[key];
      return {
        type : key,
        getItem : getItem(memoryStore),
        setItem : setItem(memoryStore),
        removeItem : removeItem(memoryStore)
      };
    }
    /**
     * @return {?}
     */
    function coreStorage() {
      var visitedNodeIds = {};
      return {
        type : GET_USER_PROFILE_SUCCESS,
        getItem : function(key) {
          return visitedNodeIds[key];
        },
        setItem : function(key, e) {
          return visitedNodeIds[key] = e;
        },
        removeItem : function(key) {
          return visitedNodeIds[key] = null;
        }
      };
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function getItem(obj) {
      return function(name) {
        var result = void 0;
        try {
          return name = success(name), result = obj.getItem(name), wrap(result);
        } catch (t) {
          return result;
        }
      };
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function setItem(obj) {
      return function(data, value) {
        try {
          data = success(data);
          obj.setItem(data, "string" == typeof value ? value : clone(value));
        } catch (r) {
          obj.setItem(data, value);
        }
      };
    }
    /**
     * @param {!Object} obj
     * @return {?}
     */
    function removeItem(obj) {
      return function(key) {
        try {
          obj.removeItem(success(key));
        } catch (t) {
        }
      };
    }
    /**
     * @param {string} value
     * @return {?}
     */
    function success(value) {
      return property + "_" + value;
    }
    /**
     * @return {undefined}
     */
    function open() {
      $("PX529");
      /** @type {number} */
      data.failures = 0;
      arr = arr + 1;
      /** @type {string} */
      var n = navigator.userAgent;
      var self = {
        PX204 : arr,
        PX59 : n,
        PX887 : Xl,
        PX888 : rumbleSpeed,
        PX839 : i18n(),
        PX919 : yl
      };
      if (value) {
        self.PX359 = join(value, n);
      }
      var dir = dirname();
      if (dir) {
        self.PX357 = join(dir, n);
      }
      var left = first();
      if (left) {
        self.PX358 = join(left, n);
      }
      run("PX203", self);
      push("PX529");
    }
    /**
     * @return {undefined}
     */
    function onClose() {
      if (rumbleInterval) {
        clearInterval(rumbleInterval);
        /** @type {null} */
        rumbleInterval = null;
      }
    }
    /**
     * @return {undefined}
     */
    function componentDidMount() {
      /** @type {number} */
      rumbleInterval = setInterval(function() {
        if (listen()) {
          yl++;
        } else {
          if (Pl) {
            open();
          } else {
            onClose();
          }
        }
      }, rumbleSpeed);
    }
    /**
     * @param {?} setting
     * @param {?} val
     * @param {?} state
     * @param {number} from
     * @return {undefined}
     */
    function onChange(setting, val, state, from) {
      onClose();
      /** @type {number} */
      rumbleSpeed = 800 * from || NaN;
      if (rumbleSpeed < NaN) {
        /** @type {number} */
        rumbleSpeed = NaN;
      } else {
        if (rumbleSpeed > border) {
          /** @type {number} */
          rumbleSpeed = border;
        }
      }
      if (Pl) {
        componentDidMount();
      }
    }
    /**
     * @return {undefined}
     */
    function overlayClickHandler() {
      /** @type {boolean} */
      Xl = false;
    }
    /**
     * @return {undefined}
     */
    function resizeHandler() {
      /** @type {boolean} */
      Xl = true;
    }
    /**
     * @return {undefined}
     */
    function getCompoundIndex() {
      /** @type {boolean} */
      Pl = false;
    }
    /**
     * @return {undefined}
     */
    function setupPageInit() {
      componentDidMount();
      me.on("risk", onChange);
      bind(window, "focus", resizeHandler);
      bind(window, "blur", overlayClickHandler);
    }
    /**
     * @return {?}
     */
    function filteringItem() {
      return arr;
    }
    /**
     * @param {?} field
     * @param {number} value
     * @param {?} message
     * @param {?} url
     * @param {?} callback
     * @return {undefined}
     */
    function setCookie(field, value, message, url, callback) {
      if (data.appID === window._pxAppId) {
        try {
          var outChance = void 0;
          var hasAnyField = void 0;
          /** @type {string} */
          var stack = (new Date(getTime() + 1E3 * value)).toUTCString();
          /** @type {string} */
          stack = stack.replace(/GMT$/, "UTC");
          if (!(void 0 === url || "true" !== url && true !== url)) {
            hasAnyField = parse();
          }
          /** @type {!Array} */
          outChance = hasAnyField ? [field, "=", message, "; expires=", stack, "; path=/", "; domain=", hasAnyField] : [field, "=", message, "; expires=", stack, "; path=/"];
          outChance.push("; SameSite=None");
          if (0 === location.protocol.indexOf("https") && isArray(keyCodes.k)) {
            outChance.push("; Secure");
          }
          /** @type {string} */
          document.cookie = outChance.join("");
        } catch (t) {
        }
      }
      me.trigger("risk", message, field, value, callback);
    }
    /**
     * @param {string} context
     * @param {undefined} el
     * @param {string} value
     * @param {?} category
     * @param {?} fn
     * @return {undefined}
     */
    function event(context, el, value, category, fn) {
      if (data.appID === window._pxAppId) {
        debug(context, el, value, category);
      }
      me.trigger("enrich", value, context, el, fn);
    }
    /**
     * @param {string} res
     * @return {undefined}
     */
    function sid(res) {
      try {
        if (window.sessionStorage) {
          /** @type {string} */
          window.sessionStorage.pxsid = res;
        }
      } catch (t) {
      }
    }
    /**
     * @param {!NodeList} value
     * @return {?}
     */
    function match(value) {
      /** @type {!Array} */
      var letters = [];
      if (!value) {
        return false;
      }
      if (npmIgnore && window._pxAction === number) {
        document.location.reload();
      }
      /** @type {boolean} */
      var matchingRoute = false;
      /** @type {number} */
      var j = 0;
      for (; j < value.length; j++) {
        var url = value[j];
        if (url) {
          var words = url.split("|");
          var id = words.shift();
          var a = attrs[id];
          if ("drc" === id) {
            /** @type {boolean} */
            matchingRoute = true;
          }
          if ("function" == typeof a) {
            if ("bake" === id) {
              letters.unshift({
                l : id,
                m : words
              });
            } else {
              letters.push({
                l : id,
                m : words
              });
            }
          }
        }
      }
      /** @type {number} */
      var i = 0;
      for (; i < letters.length; i++) {
        var data = letters[i];
        try {
          attrs[data.l].apply({
            o : letters
          }, data.m);
        } catch (t) {
        }
      }
      return matchingRoute;
    }
    /**
     * @param {!NodeList} contents
     * @return {?}
     */
    function keys(contents) {
      if (!contents || !contents.length) {
        return false;
      }
      var obj = void 0;
      try {
        obj = wrap(contents);
      } catch (t) {
        return false;
      }
      return !(!obj || "object" !== (void 0 === obj ? "undefined" : each(obj))) && (obj.do && obj.do.slice === [].slice ? match(obj.do) : void 0);
    }
    /**
     * @param {string} value
     * @param {number} context
     * @param {?} args
     * @return {undefined}
     */
    function size(value, context, args) {
      if (value && data.appID === window._pxAppId) {
        context = context || 0;
        debug("_pxvid", context, value, args);
        mixin(value);
      }
    }
    /**
     * @param {string} eventData
     * @param {?} data
     * @param {?} obj
     * @param {?} type
     * @param {?} index
     * @param {?} e
     * @return {undefined}
     */
    function mouseDragCallback(eventData, data, obj, type, index, e) {
      me.trigger(eventData, data, obj, type, index, e);
    }
    /**
     * @param {?} prop
     * @param {?} config
     * @param {?} url
     * @return {undefined}
     */
    function constructor(prop, config, url) {
      var object = {};
      try {
        object.PX259 = prop;
        object.PX256 = config;
        /** @type {*} */
        object.PX257 = getUrl(url);
      } catch (tries) {
        /** @type {string} */
        object.PX258 = tries + "";
      }
      run("PX255", object);
    }
    /**
     * @param {?} value
     * @return {undefined}
     */
    function configure(value) {
      if (defineProperty(), value) {
        /** @type {string} */
        var val = ("pxqp" + String()).toLowerCase();
        /** @type {string} */
        var value = (+new Date + "").slice(-13);
        location.href = set(location.href, val, value);
      } else {
        if (location) {
          location.reload(true);
        }
      }
    }
    /**
     * @param {?} data
     * @param {?} c
     * @return {undefined}
     */
    function l(data, c) {
      after(data, c);
    }
    /**
     * @param {string} body
     * @return {undefined}
     */
    function ct(body) {
      getPublishFetchOptions(body);
    }
    /**
     * @param {?} s
     * @param {?} n
     * @return {undefined}
     */
    function path(s, n) {
      mianzi(s, n);
    }
    /**
     * @param {?} value
     * @return {undefined}
     */
    function callWhere(value) {
      where(value);
    }
    /**
     * @param {?} t
     * @return {undefined}
     */
    function strftime_f(t) {
      mktime_f(t);
    }
    /**
     * @param {?} output
     * @return {undefined}
     */
    function writeSearchEntry(output) {
      trim(output);
    }
    /**
     * @param {?} s
     * @return {undefined}
     */
    function po(s) {
      sort_scale(s);
    }
    /**
     * @param {string} name
     * @param {string} other
     * @param {undefined} cid
     * @param {string} callback
     * @return {undefined}
     */
    function cid(name, other, cid, callback) {
      if (name === flowdata) {
        getData(other, cid, callback);
      }
    }
    /**
     * @return {undefined}
     */
    function callWhereEqualFallBack() {
      getCompoundIndex();
    }
    /**
     * @return {undefined}
     */
    function defineProperty() {
      if (value && is(sessionStorage)) {
        configStorage.setItem(LOCAL_TOKEN_KEY, value);
      }
    }
    /**
     * @param {?} callback
     * @return {undefined}
     */
    function createPath(callback) {
      var a = this.o;
      var args = void 0;
      /** @type {number} */
      var i = 0;
      for (; i < a.length; i++) {
        if ("bake" === a[i].l) {
          args = a[i].m;
          break;
        }
      }
      imageSize.apply(this, args ? [callback].concat(args) : [callback]);
    }
    /**
     * @param {!Object} message
     * @return {?}
     */
    function fail(message) {
      return onError(message, "ci");
    }
    /**
     * @param {!Object} id
     * @param {string} child
     * @return {?}
     */
    function onError(id, child) {
      try {
        var data = wrap(id);
        var crossfilterable_layers = data && data.do;
        if (crossfilterable_layers) {
          /** @type {number} */
          var layer_i = 0;
          for (; layer_i < crossfilterable_layers.length; layer_i++) {
            var layer = crossfilterable_layers[layer_i];
            if (layer.split("|")[0] === child) {
              return true;
            }
          }
        }
      } catch (t) {
      }
      return false;
    }
    /**
     * @return {undefined}
     */
    function parseIdHeader() {
      lastIndexOf(template, "");
    }
    /**
     * @return {?}
     */
    function valueByIndex() {
      try {
        return void 0 !== window.sessionStorage ? window.sessionStorage[prop] : "";
      } catch (t) {
        return "";
      }
    }
    /**
     * @return {?}
     */
    function substr() {
      try {
        if (void 0 !== window.sessionStorage) {
          /** @type {string} */
          window.sessionStorage[prop] = "";
        }
      } catch (t) {
        return "";
      }
    }
    /**
     * @param {string} len
     * @param {number} id
     * @return {undefined}
     */
    function getIndex(len, id) {
      try {
        if (!len || "undefined" === len) {
          return;
        }
        if (void 0 === id) {
          if (!perfNow) {
            return;
          }
          var now = getTime();
          if (!now) {
            return;
          }
          /** @type {number} */
          id = now - perf.timing.navigationStart;
        }
        if (!id) {
          return;
        }
        var pkg = void 0;
        pkg = window.sessionStorage[prop] ? window.sessionStorage[prop] : "_client_tag:" + tagName + ",PX123:" + value;
        /** @type {string} */
        window.sessionStorage[prop] = pkg + "," + len + ":" + id;
      } catch (t) {
      }
    }
    /**
     * @param {string} startTime
     * @param {number} errors
     * @return {undefined}
     */
    function _createStartKeyframeFromEndKeyframe(startTime, errors) {
      if (startTime && registerApplicationHandlers()) {
        getIndex(startTime, errors);
      }
    }
    /**
     * @return {?}
     */
    function initialize() {
      var next = parseRoute();
      /** @type {!Array} */
      var node = [];
      var array = perf && "function" == typeof perf.getEntries && perf.getEntries();
      if (!array) {
        return node;
      }
      /** @type {number} */
      var i = 0;
      for (; i < array.length; ++i) {
        var entry = array[i];
        if (entry && "resource" === entry.entryType) {
          /** @type {number} */
          var i = 0;
          for (; i < next.length; ++i) {
            var obj = next[i];
            if (obj && "function" == typeof obj.test && obj.test(entry.name) && (node.push(entry), node.length === next.length)) {
              return node;
            }
            /** @type {null} */
            obj.lastIndex = null;
          }
        }
      }
      return node;
    }
    /**
     * @return {undefined}
     */
    function getPerformaceInfo() {
      if (registerApplicationHandlers()) {
        try {
          var test = initialize();
          var ast = test[0];
          if (ast) {
            _createStartKeyframeFromEndKeyframe("PX372", ast.startTime);
            _createStartKeyframeFromEndKeyframe("PX373", ast.duration);
          }
          var t = test[1];
          if (t) {
            _createStartKeyframeFromEndKeyframe("PX374", t.startTime);
            _createStartKeyframeFromEndKeyframe("PX375", t.duration);
            _createStartKeyframeFromEndKeyframe("PX376", t.domainLookupEnd - t.domainLookupStart);
          }
        } catch (t) {
        }
      }
    }
    /**
     * @return {undefined}
     */
    function round() {
      var menupath = valueByIndex();
      if (menupath && 0 !== menupath.length) {
        substr();
        try {
          var tokens = menupath.split(",");
          if (tokens.length > 2 && tokens[0] === "_client_tag:" + tagName) {
            var self = {};
            /** @type {number} */
            var i = 1;
            for (; i < tokens.length; i++) {
              var values = tokens[i].split(":");
              if (values && values[0] && values[1]) {
                var name = values[0];
                var spyFunction = 1 === i ? values[1] : Number(values[1]);
                self[name] = spyFunction;
              }
            }
            run("PX23", self);
          }
        } catch (t) {
        }
      }
    }
    /**
     * @return {undefined}
     */
    function _assertTimingSettings() {
      if (perfNow) {
        _createStartKeyframeFromEndKeyframe("PX378", perf.timing.navigationStart);
      }
    }
    /**
     * @return {undefined}
     */
    function initMarginsPane() {
      if (perfNow) {
        bind(window, "unload", function() {
          _createStartKeyframeFromEndKeyframe("PX377", getTime() - perf.timing.navigationStart);
        });
      }
    }
    /**
     * @return {undefined}
     */
    function upload() {
      var t = !(arguments.length > 0 && void 0 !== arguments[0]) || arguments[0];
      if (now() && perf.timing && "function" == typeof perf.getEntriesByName) {
        finalize(keyCodes.p, function() {
          /**
           * @return {undefined}
           */
          var init = function() {
            if (!Rl) {
              /** @type {boolean} */
              Rl = true;
              var watchState = perf.getEntriesByName("first-paint")[0];
              var paramsParams = perf.getEntriesByName("first-contentful-paint")[0];
              run("PX23", {
                PX44 : perf.timing.loadEventEnd - perf.timing.navigationStart || void 0,
                PX45 : perf.timing.domComplete - perf.timing.domInteractive || void 0,
                PX46 : perf.timing.fetchStart - perf.timing.navigationStart || void 0,
                PX47 : perf.timing.redirectEnd - perf.timing.redirectStart || void 0,
                PX48 : perf.timing.domainLookupStart - perf.timing.fetchStart || void 0,
                PX49 : perf.timing.unloadEventEnd - perf.timing.unloadEventStart || void 0,
                PX50 : perf.timing.domainLookupEnd - perf.timing.domainLookupStart || void 0,
                PX51 : perf.timing.connectEnd - perf.timing.connectStart || void 0,
                PX52 : perf.timing.responseEnd - perf.timing.requestStart || void 0,
                PX53 : perf.timing.domInteractive - perf.timing.responseEnd || void 0,
                PX54 : perf.timing.loadEventEnd - perf.timing.loadEventStart || void 0,
                PX844 : watchState && watchState.startTime,
                PX845 : paramsParams && paramsParams.startTime
              });
            }
          };
          if (t) {
            setTimeout(init, 1E3);
          } else {
            init();
          }
        });
      }
    }
    /**
     * @return {undefined}
     */
    function handleMessage() {
      if (registerApplicationHandlers()) {
        round();
        _assertTimingSettings();
        initMarginsPane();
        if ("complete" === document.readyState) {
          upload(true);
        } else {
          window.addEventListener("load", upload.bind(null, true));
        }
        window.addEventListener("unload", upload.bind(null, false));
      }
    }
    /**
     * @return {?}
     */
    function registerApplicationHandlers() {
      return isArray(keyCodes.p);
    }
    /**
     * @param {string} fn
     * @return {?}
     */
    function on(fn) {
      /** @type {!Array>} */
      var values = fn ? obj.q.concat(obj.s) : obj.s;
      var crossfilterable_layers = eventHandler();
      /** @type {!Array} */
      var model = [];
      /** @type {number} */
      var layer_i = 0;
      for (; layer_i < crossfilterable_layers.length; layer_i++) {
        var newIntervals = crossfilterable_layers[layer_i];
        /** @type {number} */
        var i = 0;
        for (; i < values.length; i++) {
          var layerId = newIntervals + values[i];
          model.push(layerId);
        }
      }
      return model;
    }
    /**
     * @param {boolean} data
     * @return {?}
     */
    function eventHandler(data) {
      /** @type {!Array} */
      var me = [];
      var result = sort(data);
      /** @type {number} */
      var i = 0;
      for (; i < result.length; i++) {
        me.push(result[i]);
      }
      if (data) {
        /** @type {number} */
        var i = 0;
        for (; i < obj.u.length; i++) {
          me.push("//" + masterVideoId +  + obj.u[i]);
        }
      }
      return me;
    }
    /**
     * @param {boolean} parent
     * @return {?}
     */
    function sort(parent) {
      var m = void 0;
      if (m = "collector.staging" === window._pxPubHost ? ["//collector.staging.pxi.pub"] : ["https://collector-PXuR63h57Z.px-cloud.net", "/uR63h57Z/xhr"], parent && true === window._pxMobile && (m = m.filter(function(hashComponent) {
        return "/" !== hashComponent.charAt(0);
      })), !parent) {
        /** @type {number} */
        var i = 0;
        for (; i < obj.z.length; i++) {
          m.push("//" + masterVideoId +  + obj.z[i]);
        }
      }
      return "string" == typeof window._pxRootUrl && m.unshift(window._pxRootUrl), m;
    }
    /**
     * @param {!Array} b
     * @return {?}
     */
    function getCurveValue(b) {
      return b instanceof Array && Boolean(b.length);
    }
    /**
     * @param {!Array} keys
     * @return {?}
     */
    function group(keys) {
      /** @type {!Array} */
      var groupedList = [];
      /** @type {number} */
      var i = 0;
      for (; i < keys.length; i++) {
        switch(keys[i]) {
          case "PX3":
            groupedList.push("PX924");
            $("PX924");
            break;
          case "PX703":
            groupedList.push("PX925");
            $("PX925");
            break;
          case "PX2":
            groupedList.push("PX926");
            $("PX926");
        }
      }
      return groupedList;
    }
    /**
     * @return {?}
     */
    function regexQuote() {
      return newElt;
    }
    /**
     * @return {?}
     */
    function parsePirateBayProxyList() {
      return 10 * Math.floor(5 * Math.random()) + btnCnt;
    }
    /**
     * @param {string} doc
     * @param {number} i
     * @return {?}
     */
    function flatten(doc, i) {
      $("PX1043");
      var ast = doc.split(parameterv)[1].split("&")[0];
      var indent = replace(ast, i);
      /** @type {string} */
      var newMax = doc.replace(ast, spaces(indent)) + "&" + tbm + i;
      return push("PX1043"), newMax;
    }
    /**
     * @param {!Object} data
     * @return {undefined}
     */
    function isNil(data) {
      var addresses = data[0];
      var newEventDiv = addresses && addresses.d;
      if (newEventDiv) {
        /** @type {string} */
        newEventDiv.PX96 = parent;
      }
    }
    /**
     * @param {string} val
     * @return {?}
     */
    function serialize(val) {
      return val = val + ("&" + elfinder_btncnt_ + ++btnCnt), isArray(keyCodes.A) ? flatten(val, parsePirateBayProxyList()) : val;
    }
    /**
     * @param {!Object} options
     * @return {undefined}
     */
    function request(options) {
      var xhr = ajax("POST", setAttribute(options));
      if (xhr) {
        (function() {
          var readyState = xhr.readyState;
          /**
           * @return {undefined}
           */
          xhr.onreadystatechange = function() {
            if (4 !== xhr.readyState) {
              readyState = xhr.readyState;
            }
          };
          /**
           * @return {undefined}
           */
          xhr.onload = function() {
            if ("function" == typeof options.B) {
              options.B(xhr.responseText, options);
            }
            if (options.C) {
              npmIgnore = processResponse(xhr.responseText);
            }
            if (200 === xhr.status) {
              utf8ByteArrayFromXHRString(xhr.responseText);
              processData(xhr.responseText, options);
            } else {
              errback(xhr.status);
              check(options);
            }
          };
          /** @type {boolean} */
          var r = false;
          /**
           * @return {undefined}
           */
          var callback = function() {
            if (!r) {
              /** @type {boolean} */
              r = true;
              if ("function" == typeof options.B) {
                options.B(null, options);
              }
              equal(readyState);
              check(options);
            }
          };
          /** @type {function(): undefined} */
          xhr.onerror = callback;
          /** @type {function(): undefined} */
          xhr.onabort = callback;
          try {
            xhr.send(serialize(options.postData));
          } catch (n) {
            equal(readyState);
            check(options);
          }
        })();
      } else {
        treatVideoFilters(serialize(options.postData));
      }
    }
    /**
     * @param {?} string
     * @return {undefined}
     */
    function utf8ByteArrayFromXHRString(string) {
      data.trigger("xhrResponse", string);
      plugin.Events.trigger("xhrResponse", string);
    }
    /**
     * @param {!Object} data
     * @return {undefined}
     */
    function check(data) {
      if (data) {
        if (data.C) {
          data.D++;
          .num_const++;
          finish(data);
        } else {
          slug++;
          exec(null);
          if (data.testDefaultPath) {
            /** @type {boolean} */
            data.testDefaultPath = false;
            setTimeout(function() {
              request(data);
            }, nextCheckIn);
          } else {
            if (url + 1 < data.routes.length) {
              url++;
              message++;
              setTimeout(function() {
                request(data);
              }, nextCheckIn);
            } else {
              /** @type {number} */
              url = uri;
              data.failures += 1;
              data.trigger("xhrFailure");
            }
          }
        }
      }
    }
    /**
     * @param {?} stream
     * @param {!Object} value
     * @return {undefined}
     */
    function processData(stream, value) {
      if (value.testDefaultPath) {
        /** @type {number} */
        url = uri;
      }
      exec(url);
      /** @type {number} */
      data.failures = 0;
      _createStartKeyframeFromEndKeyframe(value.backMetric);
      data.trigger("xhrSuccess", stream);
      if (value.PX561) {
        execute();
      }
    }
    /**
     * @param {?} a
     * @return {undefined}
     */
    function equal(a) {
      style[url] = style[url] || {};
      style[url][a] = style[url][a] || 0;
      style[url][a]++;
      /** @type {boolean} */
      Pd = true;
    }
    /**
     * @param {?} adapterType
     * @return {undefined}
     */
    function errback(adapterType) {
      c_cachedAdapterHandles[url] = c_cachedAdapterHandles[url] || {};
      c_cachedAdapterHandles[url][adapterType] = c_cachedAdapterHandles[url][adapterType] || 0;
      c_cachedAdapterHandles[url][adapterType]++;
      /** @type {boolean} */
      gd = true;
    }
    /**
     * @return {?}
     */
    function when() {
      /** @type {number} */
      var width = p.length > maxWidth ? maxWidth : p.length;
      return p.splice(0, width);
    }
    /**
     * @param {!Array} b
     * @return {?}
     */
    function emit(b) {
      var current = remove();
      $("PX510");
      /** @type {number} */
      var i = 0;
      for (; i < b.length; i++) {
        var k = b[i];
        k.d.PX371 = $s;
        if (current) {
          k.d.PX250 = current;
        }
        if (bl) {
          k.d.PX398 = bl;
        }
        var no = indexOf();
        if (no) {
          k.d.PX708 = no;
        }
      }
      isNil(b);
      var n = clone(b);
      var horizontalSpaces = spaces(replace(n, YYYY));
      /** @type {!Array} */
      var result = [parameterv + horizontalSpaces, metricvalue + data.appID, html + data.tag, own_ + value, metriclabel + data.fTag, mui_jsonp_callback_ + callbackIndex++, ql_ + ql];
      var u = _subu();
      if (u) {
        result.push(roman + u);
      }
      var modulesTarget = isUndefined();
      if (modulesTarget) {
        result.push(linkDefinition + modulesTarget);
      }
      $("PX511");
      var id = getVersion(n, htmlTag(data.tag, data.fTag));
      if (id) {
        result.push(previous + id);
      }
      push("PX511");
      var suffix = data.getSid();
      var network_uppers = data.getCustomParams();
      if (suffix) {
        result.push(filename + suffix);
      }
      if (dirname()) {
        result.push(newline + dirname());
      }
      if (binTarget) {
        result.push(lvalue + binTarget);
      }
      var l = binsearch();
      if (l) {
        result.push(space + l);
      }
      var h = ctor();
      return h && result.push(hours + h), network_uppers.length >= 0 && result.push.apply(result, network_uppers), push("PX510"), result;
    }
    /**
     * @param {?} data
     * @param {string} enable
     * @return {?}
     */
    function exportTheme(data, enable) {
      /** @type {string} */
      var url = (enable || setAttribute()) + "/beacon";
      try {
        /** @type {!Blob} */
        var payload = new Blob([data], {
          type : mime
        });
        return window.navigator.sendBeacon(url, payload);
      } catch (t) {
      }
    }
    /**
     * @param {string} el
     * @return {undefined}
     */
    function treatVideoFilters(el) {
      /** @type {!Element} */
      var image = document.createElement("img");
      /** @type {string} */
      var href = setAttribute() + "/noCors?" + el;
      /** @type {number} */
      image.width = 1;
      /** @type {number} */
      image.height = 1;
      /** @type {string} */
      image.src = href;
    }
    /**
     * @param {string} url
     * @param {?} type
     * @return {?}
     */
    function ajax(url, type) {
      try {
        /** @type {!XMLHttpRequest} */
        var xhr = new XMLHttpRequest;
        if (xhr && "withCredentials" in xhr) {
          xhr.open(url, type, true);
          /** @type {boolean} */
          xhr.withCredentials = true;
          if (xhr.setRequestHeader) {
            xhr.setRequestHeader("Content-type", mime);
          }
        } else {
          if ("undefined" == typeof XDomainRequest) {
            return null;
          }
          xhr = new window.XDomainRequest;
          xhr.open(url, type);
        }
        return xhr.timeout = XHRTME, xhr;
      } catch (t) {
        return null;
      }
    }
    /**
     * @param {?} str
     * @return {undefined}
     */
    function exec(str) {
      if (data.appID && is(sessionStorage) && s !== str) {
        s = str;
        LocalStorage.setItem(prefix + data.appID, s);
      }
    }
    /**
     * @return {?}
     */
    function getStore() {
      if (data.appID && is(sessionStorage)) {
        return LocalStorage.getItem(prefix + data.appID);
      }
    }
    /**
     * @param {?} text
     * @param {?} val
     * @return {?}
     */
    function htmlTag(text, val) {
      return [value, text, val].join(":");
    }
    /**
     * @return {?}
     */
    function initsToAssigns() {
      return n2;
    }
    /**
     * @return {?}
     */
    function oOR() {
      return slug;
    }
    /**
     * @return {?}
     */
    function fetchElements() {
      return .num_const;
    }
    /**
     * @return {?}
     */
    function _resolveStyle() {
      if (Pd) {
        return style;
      }
    }
    /**
     * @return {?}
     */
    function oAND() {
      if (gd) {
        return c_cachedAdapterHandles;
      }
    }
    /**
     * @return {undefined}
     */
    function setTrailViewOffset() {
      if (queue) {
        /** @type {!Array>} */
        var t = queue.splice(0, queue.length);
        data.sendActivities(t, true);
      }
    }
    /**
     * @param {!Object} e
     * @param {!Object} type
     * @return {undefined}
     */
    function foo(e, type) {
      color__i++;
      if (!fail(e)) {
        if (color__i < color__len) {
          setTimeout(request.bind(this, type), waitUntilReturn * color__i);
        } else {
          isFile();
          getData(instance);
        }
      }
    }
    /**
     * @param {!Object} key
     * @return {undefined}
     */
    function finish(key) {
      if (key.D < blocksize) {
        /** @type {number} */
        var ngiScroll_timeout = waitUntilReturn * .num_const;
        setTimeout(request.bind(this, key), ngiScroll_timeout);
      } else {
        if (startsWith()) {
          loadImageHead();
          isFile();
          height();
          /** @type {boolean} */
          wd = true;
        }
      }
    }
    /**
     * @return {undefined}
     */
    function isFile() {
      lastIndexOf("_px");
      lastIndexOf("_px2");
      lastIndexOf("_px3");
    }
    /**
     * @return {?}
     */
    function getAlignItem() {
      return color__i;
    }
    /**
     * @return {?}
     */
    function oCOM() {
      return wd;
    }
    /**
     * @return {?}
     */
    function parseMethodDefinition() {
      return method;
    }
    /**
     * @return {?}
     */
    function isPredictionOfInterest() {
      return data && data.routes && data.routes.length || 0;
    }
    /**
     * @return {?}
     */
    function i18n() {
      return message;
    }
    /**
     * @param {boolean} node
     * @return {?}
     */
    function setAttribute(node) {
      if (node && node.C) {
        /** @type {number} */
        var index = node.D % evtModKeys.length;
        return evtModKeys[index];
      }
      if (node && node.testDefaultPath) {
        return data.routes[uri];
      }
      if (null === url) {
        var code = getStore();
        /** @type {number} */
        url = method = "number" == typeof code && data.routes[code] ? code : uri;
      }
      return data.routes[url] || "";
    }
    /**
     * @param {string} name
     * @return {?}
     */
    function processResponse(name) {
      try {
        if (0 === JSON.parse(name).do.length) {
          return true;
        }
      } catch (t) {
      }
      return false;
    }
    /**
     * @return {?}
     */
    function detect() {
      /** @type {boolean} */
      var result = false;
      try {
        if (window.ActiveXObject) {
          new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
          /** @type {boolean} */
          result = true;
        } else {
          if (navigator.mimeTypes) {
            var mimeType;
            for (mimeType in navigator.mimeTypes) {
              if (navigator.mimeTypes.hasOwnProperty(mimeType)) {
                /** @type {!MimeType} */
                var result = navigator.mimeTypes[mimeType];
                if (result && "application/x-shockwave-flash" === result.type) {
                  /** @type {boolean} */
                  result = true;
                  break;
                }
              }
            }
          }
        }
      } catch (t) {
      }
      return result;
    }
    /**
     * @return {?}
     */
    function once() {
      return navigator[key] + "";
    }
    /**
     * @return {?}
     */
    function floor() {
      return key in navigator ? 1 : 0;
    }
    /**
     * @return {?}
     */
    function convert_to_israeli_time() {
      var value = window[globalName];
      /** @type {number} */
      var reportText = value ? (value + "").length : 0;
      return reportText = reportText + (_oAtomIgnoreFiles && _oAtomIgnoreFiles[sPath] ? (_oAtomIgnoreFiles[sPath] + "").length : 0), reportText = reportText + (document && document[field] ? (document[field] + "").length : 0);
    }
    /**
     * @return {?}
     */
    function Error() {
      /** @type {string} */
      var total = "";
      if (!dependencies) {
        return total;
      }
      /** @type {number} */
      var idx = 0;
      /** @type {number} */
      var e = 0;
      for (; e < userlinks.length; e++) {
        try {
          /** @type {number} */
          idx = idx + (dependencies[userlinks[e]].constructor + "").length;
        } catch (t) {
        }
      }
      /** @type {string} */
      total = total + (idx + fromIndex);
      try {
        dependencies[jqueryUISrc][reducerName](0);
      } catch (jtimes) {
        /** @type {string} */
        total = total + ((jtimes + "").length + fromIndex);
      }
      try {
        dependencies[jqueryUISrc][reducerName]();
      } catch (jtimes) {
        /** @type {string} */
        total = total + ((jtimes + "").length + fromIndex);
      }
      try {
        dependencies[modelName][propertyName]();
      } catch (jtimes) {
        /** @type {string} */
        total = total + ((jtimes + "").length + fromIndex);
      }
      try {
        dependencies[jqueryUISrc][EXCEPTION_VALUE][OBJECT_VALUE]();
      } catch (jtimes) {
        /** @type {string} */
        total = total + (jtimes + "").length;
      }
      return total;
    }
    /**
     * @return {?}
     */
    function esc() {
      return dependencies;
    }
    /**
     * @return {?}
     */
    function exists() {
      if (dependencies) {
        return !normalize(dependencies) || (!(!dependencies[len] || normalize(dependencies[len])) || (!(!dependencies[i] || normalize(dependencies[i])) || void 0));
      }
    }
    /**
     * @param {!Function} callback
     * @return {?}
     */
    function build(callback) {
      var ret = void 0;
      try {
        /** @type {!Element} */
        var target = document.createElement(factory("aWZyYW1l"));
        /** @type {string} */
        target[factory("c3JjZG9j")] = "/**/";
        target.setAttribute(factory("c3R5bGU="), factory("ZGlzcGxheTogbm9uZTs="));
        document.head.appendChild(target);
        ret = callback(target.contentWindow);
        target.parentElement.removeChild(target);
      } catch (e) {
        ret = callback(null);
      }
      return ret;
    }
    /**
     * @param {!Object} params
     * @param {?} callback
     * @return {?}
     */
    function onload(params, callback) {
      var attributes = {};
      if (!callback) {
        return attributes;
      }
      var paramName;
      for (paramName in params) {
        if (params.hasOwnProperty(paramName)) {
          var val = callback;
          var name = params[paramName];
          if ("string" == typeof name) {
            if (dimension[name]) {
              attributes[name] = dimension[name];
            } else {
              /** @type {!Array<string>} */
              var colors = name.split();
              var i;
              for (i in colors) {
                if (colors.hasOwnProperty(i)) {
                  /** @type {string} */
                  var code = colors[i];
                  val = val[code];
                }
              }
              dimension[name] = attributes[name] = val;
            }
          }
        }
      }
      return attributes;
    }
    /**
     * @param {!Array} args
     * @return {?}
     */
    function handle(args) {
      return build(onload.bind(null, args));
    }
    /**
     * @param {?} src
     * @param {!Function} done
     * @param {!Function} cb
     * @return {?}
     */
    function loadFile(src, done, cb) {
      /** @type {boolean} */
      var _typeMap = false;
      var blob = createBlob(src, "application/javascript");
      /** @type {!Worker} */
      var worker = new Worker(blob);
      return worker.onmessage = function(e) {
        return done(e);
      }, worker.onerror = function(theError) {
        if (!_typeMap) {
          return _typeMap = true, bindEvents(function() {
            worker.terminate();
          }), cb(theError);
        }
      }, worker;
    }
    /**
     * @param {?} title
     * @param {!NodeList} content
     * @return {undefined}
     */
    function wrapper(title, content) {
      /**
       * @return {?}
       */
      function create() {
        if ("function" != typeof pair.instance.exports._basic_test) {
          return false;
        }
        /** @type {boolean} */
        var newresults = pair.instance.exports._basic_test(last, len) === s;
        return resp.PX945 = newresults;
      }
      /**
       * @return {undefined}
       */
      function find() {
        if ("function" == typeof pair.instance.exports._advanced_test) {
          /** @type {!Array} */
          var start = [];
          /** @type {number} */
          var i = 0;
          for (; i < content.length; i++) {
            start.push(content[i].charCodeAt());
          }
          var responseText = pair.instance.exports._advanced_test.apply(null, start);
          resp.PX946 = responseText;
        }
      }
      /**
       * @return {undefined}
       */
      function stop() {
        /** @type {number} */
        resp.PX923 = parseInt(tsw.now() - totalOffset);
        postMessage(JSON.stringify(resp));
        postMessage("PX697");
      }
      var resp = {
        PX945 : false,
        PX946 : 0
      };
      var tsw = self.performance || self.Date;
      var totalOffset = tsw.now();
      /** @type {number} */
      var last = 3;
      /** @type {number} */
      var len = 4;
      /** @type {number} */
      var s = 7;
      var pair = void 0;
      fetch(title).then(function(res) {
        return res.arrayBuffer();
      }).then(function(buffer) {
        return WebAssembly.instantiate(buffer, {
          env : {
            STACKTOP : 1,
            memory : new WebAssembly.Memory({
              initial : 256,
              maximum : 256
            })
          }
        });
      }).then(function(C) {
        /** @type {(Object|string)} */
        pair = C;
        if (create()) {
          find();
        }
        stop();
      }).catch(function(error) {
        resp.PX942 = error.message || "PX424";
        resp.PX947 = error.stack && error.stack.substring(0, 1E3);
        stop();
      });
    }
    /**
     * @param {?} t
     * @param {!Function} request
     * @return {?}
     */
    function error(t, request) {
      /**
       * @param {!Object} success
       * @return {?}
       */
      function done(success) {
        if ("string" == typeof success.data) {
          if ("PX697" === success.data) {
            return void r.terminate();
          }
          if (!o) {
            /** @type {boolean} */
            o = true;
            /** @type {!Object} */
            var pkgJsonUrl = Object.assign(wrap(success.data), {
              PX941 : true
            });
            push("PX704");
            clearTimeout(id);
            request(pkgJsonUrl);
          }
        }
      }
      /**
       * @param {!Object} err
       * @return {?}
       */
      function callback(err) {
        return !err.stack && err.filename && (err.stack = "Error: " + err.message + "\n\tat Worker (" + err.filename + ":" + err.lineno + ":" + err.colno + ")"), done({
          data : clone({
            PX942 : err.message || "PX424",
            PX947 : err.stack && err.stack.substring(0, 1E3)
          })
        }), err;
      }
      if (!Ud) {
        /** @type {boolean} */
        Ud = true;
        /** @type {boolean} */
        var o = false;
        if (!window.fetch || !window.Worker || !window.WebAssembly) {
          return void request({
            PX941 : false
          });
        }
        /** @type {number} */
        var id = setTimeout(function() {
          callback({
            message : "PX920"
          });
        }, t);
        $("PX704");
        $("PX921");
        var archive = void 0;
        try {
          var s_uri = factory("AGFzbQEAAAABHwJgAn9/AX9gFH9/f39/f39/f39/f39/f39/f39/AX8DAwIBAAcgAg5fYWR2YW5jZWRfdGVzdAAAC19iYXNpY190ZXN0AAEKqAECnQEAQQAgA0UgA2ogAEUgAGpsQcoPaiAIRSAIaiAHRSAHamxqIApFIApqIARFIARqbGogDkUgDmogBUUgBWpsaiARRSARaiACRSACamxqIA1FIA1qIAxFIAxqbCAGRSAGaiABRSABamxqIA9FIA9qIAtFIAtqbGogEEUgEGogCUUgCWpsamsiAWshACABQQBIBH8gAAUgASIACyAARWoLBwAgASAAags=");
          /** @type {!Blob} */
          var moduleBlob = new Blob([id3v1String(s_uri)]);
          /** @type {string} */
          archive = URL.createObjectURL(moduleBlob);
        } catch (configOptions) {
          return void callback(configOptions);
        }
        var pages = moment() || fnOrValue();
        if (!pages) {
          return void callback({
            message : "PX990"
          });
        }
        var child = from(wrapper, [archive, pages]);
        var r = bindEvents(function() {
          return loadFile(child, done, callback);
        }, true);
        push("PX921");
        if (r instanceof Error) {
          callback(r);
        }
      }
    }
    /**
     * @param {number} err
     * @param {!Function} next
     * @return {?}
     */
    function errorHandler(err, next) {
      var magnifier = (map(keyCodes.F) || "").split(",");
      var $magnifier = logError(magnifier, 2);
      var paramKeys = $magnifier[0];
      var jsonString = $magnifier[1];
      if (!paramKeys || !zipObject(paramKeys)) {
        return void next();
      }
      error(parseInt(jsonString) || err, next);
    }
    /**
     * @param {?} options
     * @return {undefined}
     */
    function init(options) {
      $("PX1023");
      try {
        var feature = factory("b3By");
        var item = factory("eWFuZGV4");
        var o = factory("c2FmYXJp");
        var cmd = esc();
        if (cmd) {
          options.PX1033 = resolve(complete(cmd));
        }
        if (window[feature]) {
          options.PX1016 = resolve(complete(window[feature]));
        }
        if (window[item]) {
          options.PX1017 = resolve(complete(window[item]));
        }
        if (window[o]) {
          options.PX1018 = resolve(complete(window[o]));
        }
        /** @type {!Array} */
        var exercises = ["onrendersubtreeactivation", "scheduler", "onactivateinvisible", "onoverscroll", "onscrollend", "trustedTypes", "requestPostAnimationFrame", "cancelPostAnimationFrame", "getComputedAccessibleNode", "getDefaultComputedStyle", "scrollByLines", "scrollByPages", "sizeToContent", "updateCommands", "dump", "setResizable", "mozInnerScreenX", "mozInnerScreenY", "scrollMaxX", "scrollMaxY", "fullScreen", "ondevicemotion", "ondeviceorientation", "onabsolutedeviceorientation", "ondeviceproximity", 
        "onuserproximity", "ondevicelight", "InstallTrigger", "sidebar", "onvrdisplayconnect", "onvrdisplaydisconnect", "onvrdisplayactivate", "onvrdisplaydeactivate", "onvrdisplaypresentchange", "ondragexit", "onloadend", "onshow", "onmozfullscreenchange", "onmozfullscreenerror", "crossOriginIsolated", "caches", "applicationCache", "offscreenBuffering", "webkitIndexedDB", "webkitCancelRequestAnimationFrame", "getMatchedCSSRules", "showModalDialog", "webkitConvertPointFromPageToNode", "webkitConvertPointFromNodeToPage", 
        "safari", "yandexApi", "yandex", "onelementpainted"];
        options.PX1019 = copy(window, exercises);
        /** @type {!Array} */
        var cookies = ["origin", "webkitFullScreenKeyboardInputAllowed", "onrejectionhandled", "onunhandledrejection", "getOverrideStyle", "getCSSCanvasContext", "onrendersubtreeactivation", "addressSpace", "onactivateinvisible", "onoverscroll", "onscrollend", "rootScroller", "ol_originalAddEventListener", "releaseCapture", "mozSetImageElement", "mozCancelFullScreen", "enableStyleSheetsForSet", "caretPositionFromPoint", "onbeforescriptexecute", "onafterscriptexecute", "mozFullScreen", "mozFullScreenEnabled", 
        "selectedStyleSheetSet", "lastStyleSheetSet", "preferredStyleSheetSet", "styleSheetSets", "mozFullScreenElement", "ondragexit", "onloadend", "onshow", "onmozfullscreenchange", "onmozfullscreenerror", "registerElement"];
        options.PX1020 = copy(window.document, cookies);
        /** @type {!Array} */
        var n = ["deviceMemory", "getUserAgent", "clipboard", "credentials", "keyboard", "locks", "mediaDevices", "serviceWorker", "storage", "presentation", "bluetooth", "hid", "usb", "xr", "setAppBadge", "clearAppBadge", "getInstalledRelatedApps", "getUserMedia", "webkitGetUserMedia", "requestMIDIAccess", "canShare", "share", "scheduling", "serial", "sms", "wakeLock", "taintEnabled", "oscpu", "buildID", "getStorageUpdates"];
        options.PX1021 = copy(window.navigator, n);
        /** @type {!Array} */
        var meta = ["ancestorOrigins", "fragmentDirective"];
        options.PX1022 = copy(window.location, meta);
      } catch (t) {
      }
      push("PX1023");
    }
    /**
     * @param {?} node
     * @param {?} callback
     * @return {undefined}
     */
    function transition(node, callback) {
      try {
        $("PX1024");
        var element = factory("bmF2aWdhdG9y");
        node.PX1034 = exists();
        node.PX1035 = track();
        node.PX1036 = _build();
        var results = options(window, element);
        var randomColor = factory("dmFsdWU=");
        if (node.PX1025 = results && !!results[randomColor], callback) {
          var data = factory("cGx1Z2lucw==");
          var value = factory("bGFuZ3VhZ2Vz");
          var type = factory("d2ViZHJpdmVy");
          node.PX1028 = getOptions(element, data);
          node.PX1029 = getOptions(element, value);
          node.PX1037 = getOptions(element, type);
        }
        push("PX1024");
      } catch (t) {
      }
    }
    /**
     * @return {?}
     */
    function track() {
      try {
        var name = factory("d2ViZHJpdmVy");
        /** @type {boolean} */
        var n = false;
        return navigator[name] || navigator.hasOwnProperty(name) || (navigator[name] = 1, n = 1 !== navigator[name], delete navigator[name]), n;
      } catch (t) {
        return true;
      }
    }
    /**
     * @return {?}
     */
    function _build() {
      try {
        var item = factory("RnVuY3Rpb24=");
        var id = factory("cHJvdG90eXBl");
        var value = factory("Y2FsbA==");
        var result = window[item][id][value];
        if (!isFunction(result)) {
          return resolve(result + "");
        }
      } catch (t) {
      }
    }
    /**
     * @param {!Object} h
     * @param {!Array} obj
     * @return {?}
     */
    function copy(h, obj) {
      /** @type {string} */
      var e = "";
      /** @type {number} */
      var index = 0;
      for (; index < obj.length; index++) {
        try {
          var i = obj[index];
          /** @type {string} */
          e = e + ("" + h.hasOwnProperty(i) + h[i]);
        } catch (eBias) {
          /** @type {string} */
          e = e + eBias;
        }
      }
      return resolve(e);
    }
    /**
     * @param {?} data
     * @return {?}
     */
    function expect(data) {
      if (void 0 !== data) {
        return resolve(data);
      }
    }
    /**
     * @param {!Function} name
     * @return {undefined}
     */
    function save(name) {
      var data = {};
      $("PX545");
      getNavInfo(data);
      resize(data);
      _init(data);
      add(data);
      render(data);
      test(data);
      insert(data);
      init(data);
      transition(data, transitionDuration);
      if (transitionDuration) {
        patch(data);
        t(data);
      }
      errorHandler(notconnected, function(e) {
        extend(data, e);
        getFile(data, name);
      });
    }
    /**
     * @param {!Object} key
     * @param {!Function} index
     * @return {undefined}
     */
    function getFile(key, index) {
      /** @type {number} */
      key.ts = (new Date).getTime();
      pageCurrentElem = isArray(keyCodes.G);
      if (pageCurrentElem) {
        string(key, index);
      } else {
        push("PX545");
        setTimeout(function() {
          string(key, index);
        }, 0);
      }
    }
    /**
     * @param {!Object} data
     * @param {!Function} path
     * @return {?}
     */
    function string(data, path) {
      if (pageCurrentElem || $("PX545"), arc(data.ts)) {
        return push("PX545"), path();
      }
      delete data.ts;
      search(data);
      update(data);
      push("PX545");
      path(data);
    }
    /**
     * @param {?} $scope
     * @return {undefined}
     */
    function getNavInfo($scope) {
      $("PX879");
      /** @type {boolean} */
      var democrazy = false;
      /** @type {number} */
      var e = -1;
      /** @type {!Array} */
      var StreamiumProvider = [];
      if (navigator.plugins) {
        democrazy = inherits();
        /** @type {number} */
        e = navigator.plugins.length;
        StreamiumProvider = useWebpackDll();
      }
      $scope.PX89 = $scope.PX134 = democrazy;
      /** @type {number} */
      $scope.PX170 = e;
      $scope.PX85 = StreamiumProvider;
      try {
        /** @type {string} */
        nodeSetterFunctions.PX59 = $scope.PX59 = navigator.userAgent;
        /** @type {string} */
        nodeSetterFunctions.PX61 = $scope.PX61 = navigator.language;
        /** @type {(Array<string>|undefined)} */
        nodeSetterFunctions.PX313 = $scope.PX313 = navigator.languages;
        /** @type {string} */
        nodeSetterFunctions.PX63 = $scope.PX63 = navigator.platform;
        /** @type {boolean} */
        nodeSetterFunctions.PX86 = $scope.PX86 = !!(navigator.doNotTrack || null === navigator.doNotTrack || navigator.msDoNotTrack || window.doNotTrack);
        nodeSetterFunctions.PX154 = $scope.PX154 = createLanguageModel();
      } catch (t) {
      }
      try {
        if (!("object" === each(navigator.geolocation) || navigator.geolocation)) {
          /** @type {string} */
          $scope.PX156 = "undefined";
        }
        $scope.PX88 = $scope.PX133 = g();
        /** @type {number} */
        $scope.PX169 = navigator.mimeTypes && navigator.mimeTypes.length || -1;
        /** @type {string} */
        $scope.PX62 = navigator.product;
        /** @type {string} */
        $scope.PX69 = navigator.productSub;
        /** @type {string} */
        $scope.PX64 = navigator.appVersion;
      } catch (t) {
      }
      try {
        /** @type {string} */
        $scope.PX65 = navigator.appName;
      } catch (t) {
      }
      try {
        /** @type {string} */
        $scope.PX66 = navigator.appCodeName;
      } catch (t) {
      }
      try {
        /** @type {string} */
        $scope.PX67 = navigator.buildID;
      } catch (t) {
      }
      try {
        /** @type {boolean} */
        $scope.PX60 = "onLine" in navigator && true === navigator.onLine;
        /** @type {boolean} */
        $scope.PX87 = navigator.geolocation + "" == "[object Geolocation]";
        if (transitionDuration) {
          /** @type {boolean} */
          $scope.PX68 = "cookieEnabled" in navigator && true === navigator.cookieEnabled;
        }
      } catch (t) {
      }
      push("PX879");
    }
    /**
     * @param {?} self
     * @return {undefined}
     */
    function resize(self) {
      $("PX880");
      try {
        var key = window.screen && window.screen.width || -1;
        var x = window.screen && window.screen.height || -1;
        var enchantDialog = window.screen && window.screen.availWidth || -1;
        var navigatorType = window.screen && window.screen.availHeight || -1;
        nodeSetterFunctions.PX229 = self.PX229 = window.screen && +screen.colorDepth || 0;
        /** @type {number} */
        nodeSetterFunctions.PX230 = self.PX230 = screen && +screen.pixelDepth || 0;
        nodeSetterFunctions.PX91 = self.PX91 = key;
        nodeSetterFunctions.PX92 = self.PX92 = x;
        nodeSetterFunctions.PX269 = self.PX269 = enchantDialog;
        nodeSetterFunctions.PX270 = self.PX270 = navigatorType;
        /** @type {string} */
        nodeSetterFunctions.PX93 = self.PX93 = key + "X" + x;
      } catch (t) {
      }
      try {
        /** @type {number} */
        self.PX185 = window.innerHeight || -1;
        /** @type {number} */
        self.PX186 = window.innerWidth || -1;
        /** @type {number} */
        self.PX187 = window.scrollX || window.pageXOffset || 0;
        /** @type {number} */
        self.PX188 = window.scrollY || window.pageYOffset || 0;
        /** @type {boolean} */
        self.PX95 = !(0 === window.outerWidth && 0 === window.outerHeight);
        if (transitionDuration) {
          self.PX397 = show();
        }
      } catch (t) {
      }
      push("PX880");
    }
    /**
     * @param {?} t
     * @return {undefined}
     */
    function patch(t) {
      $("PX881");
      /** @type {boolean} */
      var offsetFromCenter = false;
      /** @type {boolean} */
      var startScaleIndexX = false;
      /** @type {boolean} */
      var oldwillmutate = false;
      /** @type {boolean} */
      var fn = false;
      try {
        /** @type {!Array} */
        var prefixes = ["", "ms", "o", "webkit", "moz"];
        /** @type {number} */
        var i = 0;
        for (; i < prefixes.length; i++) {
          var prefix = prefixes[i];
          /** @type {string} */
          var appKeyName = "" === prefix ? "requestAnimationFrame" : prefix + "RequestAnimationFrame";
          /** @type {string} */
          var shouldHydrateName = "" === prefix ? "performance" : prefix + "Performance";
          /** @type {string} */
          var name = "" === prefix ? "matches" : prefix + "MatchesSelector";
          if (window.hasOwnProperty(appKeyName) || window[appKeyName]) {
            /** @type {boolean} */
            offsetFromCenter = true;
          }
          if ("undefined" != typeof Element && Element.prototype.hasOwnProperty(name) && isFunction(Element.prototype[name])) {
            /** @type {boolean} */
            startScaleIndexX = true;
          }
          if (window[shouldHydrateName]) {
            /** @type {boolean} */
            oldwillmutate = !!window[shouldHydrateName].timing;
            /** @type {boolean} */
            fn = "function" == typeof window[shouldHydrateName].getEntries;
          }
        }
      } catch (t) {
      }
      /** @type {boolean} */
      t.PX145 = offsetFromCenter;
      /** @type {boolean} */
      t.PX146 = startScaleIndexX;
      /** @type {boolean} */
      t.PX149 = oldwillmutate;
      /** @type {boolean} */
      t.PX150 = fn;
      push("PX881");
    }
    /**
     * @param {?} config
     * @return {undefined}
     */
    function _init(config) {
      $("PX882");
      try {
        /** @type {boolean} */
        config.PX234 = !!window.spawn;
        /** @type {boolean} */
        config.PX235 = !!window.emit;
        /** @type {boolean} */
        config.PX151 = window.hasOwnProperty(n) || !!window[n] || "true" === document.getElementsByTagName("html")[0].getAttribute(n);
        /** @type {boolean} */
        config.PX239 = !!window._Selenium_IDE_Recorder;
        /** @type {boolean} */
        config.PX240 = !!document.__webdriver_script_fn;
        /** @type {boolean} */
        config.PX152 = !!window.domAutomation || !!window.domAutomationController;
        /** @type {boolean} */
        config.PX153 = !!window._phantom || !!window.callPhantom;
        /** @type {boolean} */
        config.PX314 = !!window.geb;
        /** @type {boolean} */
        config.PX192 = !!window.awesomium;
        config.PX196 = isFunction(window.RunPerfTest);
        /** @type {boolean} */
        config.PX207 = !!window.fmget_targets;
        /** @type {boolean} */
        config.PX251 = !!window.__nightmare;
      } catch (t) {
      }
      push("PX882");
    }
    /**
     * @param {?} t
     * @return {undefined}
     */
    function add(t) {
      $("PX883");
      try {
        t.PX400 = convert_to_israeli_time();
        t.PX404 = Error();
        /** @type {!Array} */
        t.PX90 = "object" === each(window.chrome) && "function" == typeof Object.keys ? Object.keys(window.chrome) : [];
        t.PX190 = window.chrome && window.chrome.runtime && window.chrome.runtime.id || "";
        t.PX399 = t.PX552 = once();
        t.PX411 = t.PX549 = floor();
        t.PX548 = t.PX402 = validate();
        /** @type {boolean} */
        t.PX547 = t.PX405 = !!window.caches;
      } catch (t) {
      }
      push("PX883");
    }
    /**
     * @param {!Object} data
     * @return {undefined}
     */
    function render(data) {
      $("PX884");
      var time = function() {
        try {
          return window.performance && performance[factory("bWVtb3J5")];
        } catch (t) {
        }
      }();
      if (time) {
        data.PX821 = time[factory("anNIZWFwU2l6ZUxpbWl0")];
        data.PX822 = time[factory("dG90YWxKU0hlYXBTaXpl")];
        data.PX823 = time[factory("dXNlZEpTSGVhcFNpemU=")];
      }
      try {
        /** @type {boolean} */
        data.PX147 = !!window.ActiveXObject;
        data.PX155 = window.Date();
        /** @type {boolean} */
        data.PX236 = !!window.Buffer;
        /** @type {boolean} */
        data.PX194 = !!window.v8Locale;
        /** @type {boolean} */
        data.PX195 = !!navigator.sendBeacon;
        data.PX237 = isMobile();
        data.PX238 = navigator.msDoNotTrack || userAgent;
        data.PX208 = parseTexture();
        /** @type {number} */
        data.PX218 = +document.documentMode || 0;
        /** @type {number} */
        data.PX231 = +window.outerHeight || 0;
        /** @type {number} */
        data.PX232 = +window.outerWidth || 0;
        /** @type {boolean} */
        data.PX254 = !!window.showModalDialog;
        data.PX295 = supportsTouchEvents();
        /** @type {boolean} */
        data.PX268 = window.hasOwnProperty("ontouchstart") || !!window.ontouchstart;
        data.PX166 = isFunction(window.setTimeout);
        data.PX138 = isFunction(window.openDatabase);
        data.PX143 = isFunction(window.BatteryManager) || isFunction(navigator.battery) || isFunction(navigator.getBattery);
        if (transitionDuration) {
          data.PX139 = prepare();
          data.PX163 = detect();
          data.PX247 = verifyjQuery(window);
          data.PX142 = isFunction(window.EventSource);
          data.PX135 = isFunction(Function.prototype.bind);
          data.PX167 = isFunction(window.setInterval);
          /** @type {boolean} */
          data.PX148 = !!window.XDomainRequest && /native code|XDomainRequest/g.test(window.XDomainRequest + "");
          data.PX140 = document.defaultView && isFunction(document.defaultView.getComputedStyle);
          report(data, "PX144", function() {
            return isFunction(window.atob);
          }, false);
        }
      } catch (t) {
      }
      push("PX884");
    }
    /**
     * @param {!Object} key
     * @return {undefined}
     */
    function test(key) {
      $("PX878");
      report(key, "PX714", function() {
        return expect(window.console.log);
      }, "");
      report(key, "PX715", function() {
        return expect(Object.getOwnPropertyDescriptor(HTMLDocument.prototype, "cookie").get);
      }, "");
      report(key, "PX724", function() {
        return expect(Object.prototype.toString);
      }, "");
      report(key, "PX725", function() {
        return expect(navigator.toString);
      }, "");
      report(key, "PX729", function() {
        /** @type {(ObjectPropertyDescriptor<(Object|null)>|undefined)} */
        var m = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(navigator), n);
        if (m) {
          return resolve("" + (m.get || "") + (m.value || ""));
        }
      }, "");
      /** @type {boolean} */
      key.PX443 = !!window.isSecureContext;
      /** @type {boolean} */
      key.PX466 = !!window.Worklet;
      /** @type {boolean} */
      key.PX467 = !!window.AudioWorklet;
      /** @type {boolean} */
      key.PX468 = !!window.AudioWorkletNode;
      if (transitionDuration) {
        report(key, "PX716", function() {
          return expect(document.documentElement.dispatchEvent);
        }, "");
        report(key, "PX717", function() {
          return expect(window.localStorage.setItem);
        }, "");
        report(key, "PX727", function() {
          return expect(navigator.getOwnPropertyDescriptor);
        }, "");
        report(key, "PX723", function() {
          return expect(navigator.hasOwnProperty);
        }, "");
        report(key, "PX726", function() {
          return expect(Object.getOwnPropertyDescriptor);
        }, "");
        report(key, "PX722", function() {
          return expect(Object.prototype.hasOwnProperty);
        }, "");
      }
      if (isArray(keyCodes.H)) {
        (function() {
          $("PX718");
          var data = handle(args);
          key.PX730 = data[dir];
          /** @type {boolean} */
          key.PX728 = !!data[driver];
          report(key, "PX731", function() {
            var t = data[option].call(this, Object.getPrototypeOf(navigator), n);
            if (t) {
              return resolve("" + (t.get || "") + (t.value || ""));
            }
          }, "");
          key.PX718 = push("PX718");
        })();
      }
      push("PX878");
    }
    /**
     * @param {?} item
     * @return {undefined}
     */
    function insert(item) {
      try {
        if (item.PX982 = Number(), item.PX982 && (item.PX982 = parseInt(item.PX982.substring(0, 40))), item.PX983 = fnOrValue(), item.PX983) {
          item.PX983 = item.PX983.substring(0, 80);
          item[replace(item.PX983, item.PX982 % 10 + 2)] = replace(item.PX983, item.PX982 % 10 + 1);
        }
        item.PX986 = moment();
        if (item.PX986) {
          item.PX986 = item.PX986.substring(0, 80);
        }
        item.PX985 = uuid();
        if (item.PX985) {
          /** @type {number} */
          item.PX985 = parseInt(item.PX985) || 0;
        }
        var data = (map(keyCodes.I) || "").split(",");
        var fieldData = logError(data, 2);
        var data1 = fieldData[0];
        var format = fieldData[1];
        if (data1) {
          item.PX1057 = (format || "").substring(0, 40);
        }
        item.PX1000 = maintainSizeBalancedTree();
      } catch (t) {
      }
    }
    /**
     * @param {!Object} options
     * @return {undefined}
     */
    function search(options) {
      var left = first();
      try {
        if (value) {
          options.PX359 = join(value, navigator.userAgent);
        }
        options.PX943 = filterProblems();
        if (dirname()) {
          options.PX357 = join(dirname(), navigator.userAgent);
        }
        if (left) {
          options.PX358 = join(left, navigator.userAgent);
        }
      } catch (t) {
      }
    }
    /**
     * @param {!Object} data
     * @return {undefined}
     */
    function update(data) {
      $("PX885");
      report(data, "PX191", function() {
        return window.self === window.top ? 0 : 1;
      }, 2);
      report(data, "PX94", function() {
        return window.history && "number" == typeof window.history.length && window.history.length || -1;
      }, -1);
      data.PX120 = sendAuditBeacon();
      /** @type {boolean} */
      data.PX141 = window.hasOwnProperty("onorientationchange") || !!window.onorientationchange;
      /** @type {string} */
      data.PX96 = parent;
      /** @type {string} */
      data.PX55 = document.referrer ? encodeURIComponent(document.referrer) : "";
      if (transitionDuration) {
        data.PX184 = isVisible();
      }
      push("PX885");
    }
    /**
     * @param {?} body
     * @return {undefined}
     */
    function t(body) {
      /** @type {!Array} */
      var serialize = [];
      /** @type {!NodeList<Element>} */
      var e = document.getElementsByTagName("input");
      /** @type {number} */
      var i = 0;
      for (; i < e.length; i++) {
        if ("hidden" !== e[i].type) {
          var data = {};
          /** @type {string} */
          data.tagName = e[i].tagName;
          /** @type {string} */
          data.id = e[i].id;
          data.type = e[i].type;
          data.label = e[i].label;
          /** @type {string} */
          data.name = e[i].name;
          serialize.push(data);
        }
      }
      /** @type {!Array} */
      body.PX1061 = serialize;
    }
    /**
     * @return {?}
     */
    function g() {
      try {
        /** @type {string} */
        var instanceFillValue = navigator.mimeTypes && navigator.mimeTypes.toString();
        return "[object MimeTypeArray]" === instanceFillValue || /MSMimeTypesCollection/i.test(instanceFillValue);
      } catch (t) {
        return false;
      }
    }
    /**
     * @return {?}
     */
    function prepare() {
      /** @type {boolean} */
      var tags = false;
      try {
        /** @type {!Audio} */
        var obj = new Audio;
        if (obj && "function" == typeof obj.addEventListener) {
          /** @type {boolean} */
          tags = true;
        }
      } catch (t) {
      }
      return tags;
    }
    /**
     * @return {?}
     */
    function inherits() {
      var t = void 0;
      return !!navigator.plugins && ("[object PluginArray]" === (t = "function" == typeof navigator.plugins.toString ? navigator.plugins.toString() : navigator.plugins.constructor && "function" == typeof navigator.plugins.constructor.toString ? navigator.plugins.constructor.toString() : each(navigator.plugins)) || "[object MSPluginsCollection]" === t || "[object HTMLPluginsCollection]" === t);
    }
    /**
     * @return {?}
     */
    function useWebpackDll() {
      /** @type {!Array} */
      var parkNames = [];
      try {
        /** @type {number} */
        var index = 0;
        for (; index < navigator.plugins.length && index < STYLES_LIMIT; index++) {
          parkNames.push(navigator.plugins[index].name);
        }
      } catch (t) {
      }
      return parkNames;
    }
    /**
     * @return {?}
     */
    function sendAuditBeacon() {
      /** @type {!Array} */
      var new_objs = [];
      try {
        /** @type {(DOMStringList|null)} */
        var d = document.location.ancestorOrigins;
        if (document.location.ancestorOrigins) {
          /** @type {number} */
          var i = 0;
          for (; i < d.length; i++) {
            if (d[i] && "null" !== d[i]) {
              new_objs.push(d[i]);
            }
          }
        }
      } catch (t) {
      }
      return new_objs;
    }
    /**
     * @return {?}
     */
    function show() {
      try {
        return window.hasOwnProperty("_cordovaNative") || window.hasOwnProperty("Ti") || window.hasOwnProperty("webView") || window.hasOwnProperty("Android") || window.document.hasOwnProperty("ondeviceready") || window.navigator.hasOwnProperty("standalone") || window.external && "notify" in window.external || navigator.userAgent.indexOf(" Mobile/") > 0 && -1 === navigator.userAgent.indexOf(" Safari/");
      } catch (t) {
        return false;
      }
    }
    /**
     * @return {?}
     */
    function createLanguageModel() {
      try {
        return (new Date).getTimezoneOffset();
      } catch (t) {
        return 9999;
      }
    }
    /**
     * @return {?}
     */
    function isVisible() {
      try {
        return null !== document.elementFromPoint(0, 0);
      } catch (t) {
        return true;
      }
    }
    /**
     * @return {?}
     */
    function validate() {
      try {
        return (new window.SharedArrayBuffer(1)).byteLength;
      } catch (t) {
        return -1;
      }
    }
    /**
     * @return {?}
     */
    function supportsTouchEvents() {
      try {
        document.createEvent("TouchEvent");
      } catch (t) {
        return false;
      }
    }
    /**
     * @return {?}
     */
    function parseTexture() {
      var value = getPrefix();
      /** @type {string} */
      var prefixHidden = ("" === value ? "v" : "V") + "isibilityState";
      return document[prefixHidden];
    }
    /**
     * @return {?}
     */
    function getPrefix() {
      /** @type {null} */
      var prefix = null;
      if (void 0 !== document.hidden) {
        /** @type {string} */
        prefix = "";
      } else {
        /** @type {!Array} */
        var prefixes = ["webkit", "moz", "ms", "o"];
        /** @type {number} */
        var i = 0;
        for (; i < prefixes.length; i++) {
          if (void 0 !== document[prefixes[i] + "Hidden"]) {
            prefix = prefixes[i];
            break;
          }
        }
      }
      return prefix;
    }
    /**
     * @param {!Function} callback
     * @return {?}
     */
    function list(callback) {
      var iPartition = {};
      try {
        $(item);
        var context = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, 44100, 44100);
        if (axesIds.push(push(item)), !context) {
          return callback(rv, rv);
        }
        $(item);
        var osc = context.createOscillator();
        /** @type {number} */
        var spyCall = "number" == typeof context.currentTime && context.currentTime || 0;
        /** @type {string} */
        osc.type = "sine";
        fixSetTarget(osc.frequency, 1E4, spyCall);
        var node = context.createDynamicsCompressor();
        fixSetTarget(node.threshold, -50, spyCall);
        fixSetTarget(node.knee, 40, spyCall);
        fixSetTarget(node.ratio, 12, spyCall);
        fixSetTarget(node.reduction, -20, spyCall);
        fixSetTarget(node.attack, 0, spyCall);
        fixSetTarget(node.release, .25, spyCall);
        axesIds.push(push(item));
        $(item);
        osc.connect(node);
        node.connect(context.destination);
        osc.start(0);
        context.startRendering();
        axesIds.push(push(item));
        $(item);
        /**
         * @param {?} event
         * @return {?}
         */
        context.oncomplete = function(event) {
          axesIds.push(push(item));
          /** @type {number} */
          var posX = 0;
          if ($(item), event.renderedBuffer && "function" == typeof event.renderedBuffer.getChannelData) {
            /** @type {number} */
            var i = 4500;
            for (; i < 5E3; i++) {
              var pipTexts = event.renderedBuffer.getChannelData(0);
              if (pipTexts) {
                /** @type {number} */
                posX = posX + Math.abs(pipTexts[i]);
              }
            }
          }
          axesIds.push(push(item));
          /** @type {string} */
          var result = posX.toString();
          return callback(result, join(result), iPartition);
        };
      } catch (e) {
        return callback(rv, rv, iPartition);
      }
    }
    /**
     * @param {!Object} param
     * @param {!Object} value
     * @param {number} now
     * @return {undefined}
     */
    function fixSetTarget(param, value, now) {
      if (param) {
        if ("function" == typeof param.setValueAtTime) {
          param.setValueAtTime(value, now);
        } else {
          /** @type {!Object} */
          param.value = value;
        }
      }
    }
    /**
     * @return {?}
     */
    function dpadd() {
      return axesIds;
    }
    /**
     * @return {?}
     */
    function resetFacetCount() {
      return paint(array);
    }
    /**
     * @return {?}
     */
    function prepareReturnResult() {
      return paint(time);
    }
    /**
     * @param {string} type
     * @return {?}
     */
    function paint(type) {
      var result = _registerWidget(type);
      try {
        var canvas = createCanvas();
        if (canvas) {
          /** @type {function(!HTMLElement): ?} */
          var getContext = type === time ? WebGLFramework : text;
          var gl = getContext(canvas);
          if (gl) {
            return (type === time ? webglSign : redraw)(gl, result, canvas);
          }
          result.errors.push("PX422");
        } else {
          result.errors.push("PX423");
        }
      } catch (t) {
        result.errors.push("PX424");
      }
      return result;
    }
    /**
     * @param {!WebGLRenderingContext} gl
     * @param {!Object} data
     * @return {?}
     */
    function webglSign(gl, data) {
      var glBuffer = void 0;
      var program = void 0;
      var vertexShader = void 0;
      var fragmentShader = void 0;
      /**
       * @param {!Object} fa
       * @return {?}
       */
      var fa2s = function(fa) {
        return gl.clearColor(0, 0, 0, 1), gl.enable(gl.DEPTH_TEST), gl.depthFunc(gl.LEQUAL), gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT), "[" + fa[0] + ", " + fa[1] + "]";
      };
      try {
        glBuffer = gl.createBuffer();
      } catch (t) {
        data.errors.push("PX439");
      }
      try {
        gl.bindBuffer(gl.ARRAY_BUFFER, glBuffer);
        /** @type {!Float32Array} */
        var textureRectangle = new Float32Array([-.2, -.9, 0, .4, -.26, 0, 0, .732134444, 0]);
        gl.bufferData(gl.ARRAY_BUFFER, textureRectangle, gl.STATIC_DRAW);
        /** @type {number} */
        glBuffer.itemSize = 3;
        /** @type {number} */
        glBuffer.numItems = 3;
      } catch (t) {
        data.errors.push("PX438");
      }
      try {
        program = gl.createProgram();
      } catch (t) {
        data.errors.push("PX437");
      }
      try {
        vertexShader = gl.createShader(gl.VERTEX_SHADER);
        gl.shaderSource(vertexShader, debugShaderTxt);
        gl.compileShader(vertexShader);
        fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
        gl.shaderSource(fragmentShader, pFragCode);
        gl.compileShader(fragmentShader);
        gl.attachShader(program, vertexShader);
        gl.attachShader(program, fragmentShader);
      } catch (t) {
        data.errors.push("PX436");
      }
      try {
        gl.linkProgram(program);
        gl.useProgram(program);
        program.vertexPosAttrib = gl.getAttribLocation(program, "attrVertex");
        program.offsetUniform = gl.getUniformLocation(program, "uniformOffset");
        gl.enableVertexAttribArray(program.vertexPosArray);
        gl.vertexAttribPointer(program.vertexPosAttrib, glBuffer.itemSize, gl.FLOAT, false, 0, 0);
        gl.uniform2f(program.offsetUniform, 1, 1);
      } catch (t) {
        data.errors.push("PX435");
      }
      try {
        gl.drawArrays(gl.TRIANGLE_STRIP, 0, glBuffer.numItems);
      } catch (t) {
        data.errors.push("PX434");
      }
      try {
        data.canvasfp = null === gl.canvas ? interval : join(gl.canvas.toDataURL());
      } catch (t) {
        data.errors.push("PX433");
      }
      try {
        data.extensions = gl.getSupportedExtensions() || [interval];
      } catch (t) {
        data.errors.push("PX432");
      }
      try {
        data.webglRenderer = compileShader(gl, gl.RENDERER);
        data.shadingLangulageVersion = compileShader(gl, gl.SHADING_LANGUAGE_VERSION);
        data.webglVendor = compileShader(gl, gl.VENDOR);
        data.webGLVersion = compileShader(gl, gl.VERSION);
        var extensionDebugRendererInfo = gl.getExtension("WEBGL_debug_renderer_info");
        if (extensionDebugRendererInfo) {
          data.unmaskedVendor = compileShader(gl, extensionDebugRendererInfo.UNMASKED_VENDOR_WEBGL);
          data.unmaskedRenderer = compileShader(gl, extensionDebugRendererInfo.UNMASKED_RENDERER_WEBGL);
        }
      } catch (t) {
        data.errors.push("PX431");
      }
      /** @type {!Array} */
      data.webglParameters = [];
      /** @type {!Array} */
      var values = data.webglParameters;
      try {
        if (values.push(fa2s(compileShader(gl, gl.ALIASED_LINE_WIDTH_RANGE))), values.push(fa2s(compileShader(gl, gl.ALIASED_POINT_SIZE_RANGE))), values.push(compileShader(gl, gl.ALPHA_BITS)), values.push(gl.getContextAttributes().antialias ? "yes" : "no"), values.push(compileShader(gl, gl.BLUE_BITS)), values.push(compileShader(gl, gl.DEPTH_BITS)), values.push(compileShader(gl, gl.GREEN_BITS)), values.push(function(gl) {
          var ext = gl.getExtension("EXT_texture_filter_anisotropic") || gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic") || gl.getExtension("MOZ_EXT_texture_filter_anisotropic");
          var anisotropy = void 0;
          return ext ? (anisotropy = gl.getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT), 0 === anisotropy && (anisotropy = 2), anisotropy) : null;
        }(gl)), values.push(compileShader(gl, gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS)), values.push(compileShader(gl, gl.MAX_CUBE_MAP_TEXTURE_SIZE)), values.push(compileShader(gl, gl.MAX_FRAGMENT_UNIFORM_VECTORS)), values.push(compileShader(gl, gl.MAX_RENDERBUFFER_SIZE)), values.push(compileShader(gl, gl.MAX_TEXTURE_IMAGE_UNITS)), values.push(compileShader(gl, gl.MAX_TEXTURE_SIZE)), values.push(compileShader(gl, gl.MAX_VARYING_VECTORS)), values.push(compileShader(gl, gl.MAX_VERTEX_ATTRIBS)), values.push(compileShader(gl, 
        gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS)), values.push(compileShader(gl, gl.MAX_VERTEX_UNIFORM_VECTORS)), values.push(fa2s(compileShader(gl, gl.MAX_VIEWPORT_DIMS))), values.push(compileShader(gl, gl.STENCIL_BITS)), gl.getShaderPrecisionFormat) {
          /** @type {!Array} */
          var typedArrays = ["VERTEX_SHADER", "FRAGMENT_SHADER", "VERTEX_SHADER", "FRAGMENT_SHADER"];
          /** @type {number} */
          var ii = 0;
          for (; ii < typedArrays.length; ii++) {
            var type = typedArrays[ii];
            /** @type {!Array} */
            var spheres = ["HIGH_FLOAT", "MEDIUM_FLOAT", "LOW_FLOAT"];
            /** @type {number} */
            var iter_sph = 0;
            for (; iter_sph < spheres.length; iter_sph++) {
              var j = spheres[iter_sph];
              var entry = gl.getShaderPrecisionFormat(gl[type], gl[j]);
              values.push(entry.precision, entry.rangeMin, entry.rangeMax);
            }
          }
        }
      } catch (t) {
        data.errors.push("PX430");
      }
      return data;
    }
    /**
     * @param {!CanvasRenderingContext2D} ctx
     * @param {!Object} options
     * @param {!HTMLCanvasElement} canvas
     * @return {?}
     */
    function redraw(ctx, options, canvas) {
      try {
        ctx.rect(0, 0, 10, 10);
        ctx.rect(2, 2, 6, 6);
        /** @type {boolean} */
        options.canvasWinding = false === ctx.isPointInPath(5, 5, "evenodd");
      } catch (t) {
        options.errors.push("PX429");
      }
      try {
        /** @type {string} */
        ctx.textBaseline = "alphabetic";
        /** @type {string} */
        ctx.fillStyle = "#f60";
        ctx.fillRect(125, 1, 62, 20);
      } catch (t) {
        options.errors.push("PX428");
      }
      try {
        /** @type {string} */
        ctx.fillStyle = "#069";
        /** @type {string} */
        ctx.font = "11pt no-real-font-123";
        ctx.fillText("Cwm fjordbank glyphs vext quiz, ", 2, 15);
        /** @type {string} */
        ctx.fillStyle = "rgba(102, 204, 0, 0.2)";
        /** @type {string} */
        ctx.font = "18pt Arial";
        ctx.fillText("Cwm fjordbank glyphs vext quiz, ", 4, 45);
      } catch (t) {
        options.errors.push("PX427");
      }
      try {
        /** @type {string} */
        ctx.globalCompositeOperation = "multiply";
        /** @type {string} */
        ctx.fillStyle = "rgb(255,0,255)";
        ctx.beginPath();
        ctx.arc(50, 50, 50, 0, 2 * Math.PI, true);
        ctx.closePath();
        ctx.fill();
        /** @type {string} */
        ctx.fillStyle = "rgb(0,255,255)";
        ctx.beginPath();
        ctx.arc(100, 50, 50, 0, 2 * Math.PI, true);
        ctx.closePath();
        ctx.fill();
        /** @type {string} */
        ctx.fillStyle = "rgb(255,255,0)";
        ctx.beginPath();
        ctx.arc(75, 100, 50, 0, 2 * Math.PI, true);
        ctx.closePath();
        ctx.fill();
        /** @type {string} */
        ctx.fillStyle = "rgb(255,0,255)";
        ctx.arc(75, 75, 75, 0, 2 * Math.PI, true);
        ctx.arc(75, 75, 25, 0, 2 * Math.PI, true);
        ctx.fill("evenodd");
      } catch (t) {
        options.errors.push("PX426");
      }
      try {
        options.canvasData = join(canvas.toDataURL());
      } catch (t) {
        options.errors.push("PX425");
      }
      return options;
    }
    /**
     * @return {?}
     */
    function createCanvas() {
      /** @type {!Element} */
      var obj = document.createElement("canvas");
      return obj.width = bar, obj.height = obj2, obj.style.display = "inline", obj;
    }
    /**
     * @param {!Object} canvas
     * @return {?}
     */
    function text(canvas) {
      var context = canvas && canvas.getContext("2d");
      return context && "function" == typeof context.fillText ? context : null;
    }
    /**
     * @param {!HTMLElement} canvas
     * @return {?}
     */
    function WebGLFramework(canvas) {
      return !vv && canvas && (vv = canvas.getContext("webgl") || canvas.getContext("experimental-webgl")), vv;
    }
    /**
     * @param {!WebGLRenderingContext} gl
     * @param {?} type
     * @return {?}
     */
    function compileShader(gl, type) {
      try {
        return gl.getParameter(type) || interval;
      } catch (t) {
        return interval;
      }
    }
    /**
     * @param {string} type
     * @return {?}
     */
    function _registerWidget(type) {
      switch(type) {
        case time:
          return {
            canvasfp : interval,
            webglRenderer : interval,
            shadingLangulageVersion : interval,
            webglVendor : interval,
            webGLVersion : interval,
            unmaskedVendor : interval,
            unmaskedRenderer : interval,
            webglParameters : [interval],
            errors : []
          };
        case array:
          return {
            canvasWinding : interval,
            canvasData : interval,
            errors : []
          };
      }
    }
    /**
     * @return {?}
     */
    function getFlashVersion() {
      /** @type {!Array} */
      var by = [];
      try {
        if (navigator.plugins) {
          /** @type {number} */
          var i = 0;
          for (; i < navigator.plugins.length && i < extraTenMax; i++) {
            /** @type {!Plugin} */
            var pi = navigator.plugins[i];
            /** @type {string} */
            var id = pi.name + "::" + pi.description;
            /** @type {number} */
            var j = 0;
            for (; j < pi.length; j++) {
              /** @type {string} */
              id = id + "::" + pi[j].type + "~" + pi[j].suffixes;
            }
            by.push(id);
          }
        }
      } catch (t) {
      }
      if ("ActiveXObject" in window) {
        var name;
        for (name in validSettings) {
          try {
            new ActiveXObject(name);
            by.push(name);
          } catch (t) {
          }
        }
      }
      return by;
    }
    /**
     * @param {?} l
     * @param {?} m
     * @param {!Object} settings
     * @return {undefined}
     */
    function filter(l, m, settings) {
      $("PX532");
      $(context);
      var self = {};
      if (self.PX31 = l, self.PX32 = m, settings) {
        var i;
        for (i in settings) {
          if (settings.hasOwnProperty(i)) {
            self[i] = settings[i];
          }
        }
      }
      var start = getTime();
      solvedArgs.push(push(context));
      $(context);
      var parent = prepareReturnResult();
      solvedArgs.push(push(context));
      $(context);
      var params = resetFacetCount();
      solvedArgs.push(push(context));
      $(context);
      self.PX274 = params.canvasData;
      self.PX275 = params.canvasWinding;
      self.PX441 = params.errors;
      self.PX276 = parent.canvasfp;
      self.PX440 = parent.errors;
      self.PX210 = parent.webglRenderer;
      self.PX209 = parent.webglVendor;
      self.PX277 = parent.webGLVersion;
      self.PX281 = parent.extensions;
      self.PX282 = parent.webglParameters;
      if (transitionDuration) {
        self.PX280 = parent.unmaskedRenderer;
        self.PX279 = parent.unmaskedVendor;
        self.PX278 = parent.shadingLangulageVersion;
      }
      /** @type {number} */
      self.PX33 = getTime() - start;
      solvedArgs.push(push(context));
      $(context);
      self.PX248 = flattenElements(window.document);
      self.PX249 = flattenElements(window);
      self.PX57 = filterSymbols();
      self.PX264 = processRule();
      self.PX266 = transform3DSupported(window);
      if (transitionDuration) {
        self.PX265 = makeFunction();
      }
      self.PX364 = getFlashVersion();
      solvedArgs.push(push(context));
      $(context);
      report(self, "PX286", function() {
        return window.devicePixelRatio || "";
      }, "");
      report(self, "PX287", function() {
        return navigator.hardwareConcurrency || -1;
      }, -1);
      report(self, "PX288", function() {
        return !!window.localStorage;
      }, false);
      report(self, "PX289", function() {
        return !!window.indexedDB;
      }, false);
      report(self, "PX290", function() {
        return !!window.openDatabase;
      }, false);
      report(self, "PX291", function() {
        return !!document.body.addBehavior;
      }, false);
      report(self, "PX292", function() {
        return navigator.cpuClass;
      });
      report(self, "PX293", function() {
        return !!window.sessionStorage;
      }, false);
      var monkeyPatchKey;
      for (monkeyPatchKey in nodeSetterFunctions) {
        self[monkeyPatchKey] = nodeSetterFunctions[monkeyPatchKey];
      }
      solvedArgs.push(push(context));
      if (transitionDuration) {
        $(context);
        self.PX312 = wireState(window, "WebKitCSSMatrix");
        self.PX311 = wireState(window, "WebGLContextEvent");
        self.PX310 = wireState(window, "UIEvent");
        solvedArgs.push(push(context));
      }
      onEvent(function(navigatorType, productdetailsVm) {
        self.PX401 = navigatorType;
        self.PX409 = productdetailsVm;
        helper("PX4", self);
        push("PX532");
      });
    }
    /**
     * @param {!Object} parent
     * @param {string} name
     * @return {?}
     */
    function wireState(parent, name) {
      try {
        if (parent && parent[name]) {
          var e = new parent[name]("");
          /** @type {string} */
          var out = "";
          var t;
          for (t in e) {
            if (e.hasOwnProperty(t)) {
              /** @type {string} */
              out = out + t;
            }
          }
          return join(out);
        }
      } catch (t) {
      }
      return object;
    }
    /**
     * @return {?}
     */
    function processRule() {
      return "eval" in window ? (eval + "").length : -1;
    }
    /**
     * @return {?}
     */
    function makeFunction() {
      try {
        throw "a";
      } catch (make_compile_from_source) {
        try {
          make_compile_from_source.toSource();
        } catch (t) {
          return true;
        }
      }
      return false;
    }
    /**
     * @return {?}
     */
    function transform3DSupported() {
      /** @type {string} */
      var result = "";
      if (window && document && document.body) {
        try {
          var permissionsList = window.getComputedStyle(document.body);
          /** @type {number} */
          var i = 0;
          for (; i < permissionsList.length; i++) {
            result = result + permissionsList[i];
          }
        } catch (t) {
        }
      }
      return join(result);
    }
    /**
     * @param {!Object} key
     * @return {?}
     */
    function encode(key) {
      return ("_" === key[0] || "$" === key[0] || -1 !== equals(text_plain, key)) && key.length <= pos;
    }
    /**
     * @param {!Window} options
     * @return {?}
     */
    function flattenElements(options) {
      /** @type {!Array} */
      var result = [];
      if (options) {
        try {
          /** @type {boolean} */
          var _iteratorNormalCompletion3 = true;
          /** @type {boolean} */
          var r = false;
          var o = void 0;
          try {
            var _step;
            var _iterator3 = Object.getOwnPropertyNames(options)[Symbol.iterator]();
            for (; !(_iteratorNormalCompletion3 = (_step = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              var index = _step.value;
              if (encode(index) && (result.push(index), result.length >= maxResults)) {
                break;
              }
            }
          } catch (tObj) {
            /** @type {boolean} */
            r = true;
            o = tObj;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3.return) {
                _iterator3.return();
              }
            } finally {
              if (r) {
                throw o;
              }
            }
          }
        } catch (t) {
        }
      }
      return result;
    }
    /**
     * @return {?}
     */
    function saveEditorContentToLocalStorage() {
      return !!hashedItemStore.getItem(hash) || (hashedItemStore.setItem(hash, true), false);
    }
    /**
     * @param {!Function} prob
     * @return {undefined}
     */
    function _exportTo(prob) {
      if (!saveEditorContentToLocalStorage()) {
        /** @type {!Function} */
        helper = "function" == typeof prob ? prob : run;
        ready(function() {
          setTimeout(function() {
            if (isArray(keyCodes.J)) {
              $("PX533");
              list(function(partial, n, i) {
                push("PX533");
                filter(partial, n, i);
              });
            }
          }, 500);
        });
      }
    }
    /**
     * @return {?}
     */
    function executeInstruction() {
      return solvedArgs;
    }
    /**
     * @param {string} obj
     * @param {string} fn
     * @param {!Object} parent
     * @return {undefined}
     */
    function process(obj, fn, parent) {
      if (obj && fn && parent && "function" == typeof parent.appendChild) {
        try {
          /** @type {string} */
          var l = (location.pathname || "/") + "?" + fn + "=" + getTime();
          /** @type {!Element} */
          var element = document.createElement("a");
          Completer(element);
          /** @type {string} */
          element.href = l;
          /** @type {string} */
          element.rel = "nofollow";
          /** @type {string} */
          element.style.cssText = "width:0px;height:0px;font-size:0px;line-height:0";
          /** @type {string} */
          element.target = "_blank";
          bind(element, "click", function(date) {
            return function(event) {
              try {
                if (event.preventDefault) {
                  event.preventDefault();
                } else {
                  /** @type {boolean} */
                  event.returnValue = false;
                }
                run(date, {});
              } catch (t) {
              }
              return false;
            };
          }(obj), {
            passive : false
          });
          parent.appendChild(element);
        } catch (t) {
        }
      }
    }
    /**
     * @return {undefined}
     */
    function cacheProcessRtoken() {
      if ("object" === each(document.head)) {
        process("PX16", "_pxhc", document.head);
      }
    }
    /**
     * @param {!Function} callback
     * @return {?}
     */
    function done(callback) {
      return "function" != typeof callback ? callback : function() {
        if (!Tv) {
          $("PX534");
          var input = concat();
          /** @type {boolean} */
          var event = false;
          if (event = event || (input.match(/[Aa]nonymous/g) || []).length > 2, event = event || (input.match(/unknown source/g) || []).length > 6, event = event || (input.match(/unknown/g) || []).length > 4, event = event || (input.match(/\n\n\n/g) || []).length > 0, event = event || (input.match(/Rd\n\n/g) || []).length > 0, event = event || (input.match(/_handle/g) || []).length > 3) {
            var char = then(input).replace(/(\[.*?\]|\(.*?\)) */g, "");
            charListNotLatin.push(char);
          }
          push("PX534");
        }
        return callback.apply(this, arguments);
      };
    }
    /**
     * @return {undefined}
     */
    function bytesCheck() {
      var block_by_text = void 0;
      try {
        if (charListNotLatin.length > 0) {
          if (charListNotLatin.length > 15) {
            block_by_text = charListNotLatin.slice(0, 14);
            charListNotLatin = charListNotLatin.slice(14);
          } else {
            block_by_text = charListNotLatin;
            /** @type {!Array} */
            charListNotLatin = [];
          }
          run("PX21", {
            PX57 : clone(block_by_text)
          });
        }
      } catch (t) {
      }
    }
    /**
     * @return {undefined}
     */
    function heartbeatFn() {
      try {
        if (bytesIval) {
          clearInterval(bytesIval);
          /** @type {number} */
          bytesIval = 0;
        }
        /** @type {boolean} */
        Tv = true;
        /** @type {!Array} */
        charListNotLatin = [];
      } catch (t) {
      }
    }
    /**
     * @return {undefined}
     */
    function loaded() {
      try {
        document.getElementById = done(document.getElementById);
        document.getElementsByTagName = done(document.getElementsByTagName);
        document.getElementsByClassName = done(document.getElementsByClassName);
        document.evaluate = done(document.evaluate);
        document.querySelector = done(document.querySelector);
        document.querySelectorAll = done(document.querySelectorAll);
        /** @type {number} */
        bytesIval = setInterval(bytesCheck, 500);
        setTimeout(heartbeatFn, 2E4);
      } catch (t) {
      }
    }
    /**
     * @param {boolean} touch
     * @return {undefined}
     */
    function getLastTouchStretch(touch) {
    }
    /**
     * @param {boolean} context
     * @return {undefined}
     */
    function collect(context) {
    }
    /**
     * @return {undefined}
     */
    function onframe() {
      if (!Iv) {
        /** @type {boolean} */
        Iv = true;
        run("PX212", step());
      }
    }
    /**
     * @return {?}
     */
    function step() {
      var begin = getTime();
      var n = {
        PX215 : begin,
        PX216 : begin - end
      };
      if (window.performance && window.performance.timing) {
        /** @type {number} */
        n.PX213 = window.performance.timing.domComplete;
        /** @type {number} */
        n.PX214 = window.performance.timing.loadEventEnd;
      }
      n.PX712 = _resolveStyle();
      n.PX713 = oAND();
      n.PX837 = parseMethodDefinition();
      n.PX838 = isPredictionOfInterest();
      if (i18n() >= 1) {
        n.PX839 = i18n();
      }
      n.PX546 = now();
      n.PX499 = getCaMetric("PX499");
      n.PX500 = getCaMetric("PX500");
      n.PX544 = getCaMetric("PX544");
      n.PX545 = getCaMetric("PX545");
      n.PX879 = getCaMetric("PX879");
      n.PX880 = getCaMetric("PX880");
      n.PX881 = getCaMetric("PX881");
      n.PX882 = getCaMetric("PX882");
      n.PX883 = getCaMetric("PX883");
      n.PX884 = getCaMetric("PX884");
      n.PX885 = getCaMetric("PX885");
      n.PX878 = getCaMetric("PX878");
      n.PX1023 = getCaMetric("PX1023");
      n.PX1024 = getCaMetric("PX1024");
      n.PX502 = getCaMetric("PX502");
      n.PX503 = getState("PX503");
      n.PX504 = oROR();
      n.PX505 = getState("PX505");
      n.PX924 = getCaMetric("PX924");
      n.PX925 = getCaMetric("PX925");
      n.PX926 = getCaMetric("PX926");
      n.PX704 = getCaMetric("PX704");
      n.PX921 = getCaMetric("PX921");
      n.PX718 = getCaMetric("PX718");
      n.PX508 = getState("PX508");
      n.PX509 = initsToAssigns();
      n.PX510 = getState("PX510");
      n.PX511 = getState("PX511");
      n.PX1043 = getState("PX1043");
      n.PX551 = oOR();
      n.PX886 = getCaMetric("PX886");
      var e = fetchElements();
      if (e > 1) {
        n.PX890 = e;
      }
      var alignContentAlignItem = getAlignItem();
      return alignContentAlignItem > 1 && (n.PX833 = alignContentAlignItem), oCOM() && (n.PX834 = true), oEOR() && (n.PX835 = true), n.PX536 = getState("PX536"), n.PX537 = removeHasDontEnumBug(), n.PX538 = getState("PX538"), n.PX539 = removeDeletedActivities(), n.PX512 = getCaMetric("PX512"), n.PX513 = getCaMetric("PX513"), n.PX846 = getState("PX846"), n.PX847 = getState("PX847"), n.PX520 = getCaMetric("PX520"), n.PX521 = getCaMetric("PX521"), n.PX529 = getCaMetric("PX529"), n.PX849 = getState("PX849"), 
      n.PX533 = getCaMetric("PX533"), n.PX541 = dpadd(), n.PX532 = getCaMetric("PX532"), n.PX542 = executeInstruction(), n.PX534 = getCaMetric("PX534"), n.PX765 = filteringItem(), n;
    }
    /**
     * @return {undefined}
     */
    function checkShutDown() {
      setTimeout(onframe);
    }
    /**
     * @param {!Object} path
     * @return {undefined}
     */
    function poll(path) {
      if ($("PX520"), inside && path && parallel(path)) {
        var el = createElement(path);
        if (el) {
          var result = fn(el);
          if (result) {
            var r = accept(result);
            var position = offset(el);
            if (void 0 !== position) {
              r.PX263 = position;
            }
            run("PX217", r);
            scrollLeft++;
            if (firstColLeft <= scrollLeft) {
              /** @type {boolean} */
              inside = false;
              updateStatus(false);
            }
            push("PX520");
          }
        }
      }
    }
    /**
     * @param {number} data
     * @return {?}
     */
    function accept(data) {
      var input = concat();
      var contents = split(input);
      var ret = void 0;
      if (contents.length > 0) {
        var names = contents[contents.length - 1];
        ret = {
          PX72 : data,
          PX206 : names[0] || "",
          PX205 : names[1] || "",
          PX34 : input
        };
      } else {
        ret = {
          PX72 : data,
          PX34 : input
        };
      }
      return ret;
    }
    /**
     * @param {!Event} event
     * @return {?}
     */
    function parallel(event) {
      return false === event.isTrusted;
    }
    /**
     * @param {string} err
     * @return {undefined}
     */
    function updateStatus(err) {
      if (_err !== err) {
        /** @type {string} */
        _err = err;
        call(err)(document.body, "click", poll);
      }
    }
    /**
     * @return {undefined}
     */
    function downloadEvents() {
      ready(function() {
        updateStatus(true);
      });
    }
    /**
     * @param {!Object} path
     * @return {undefined}
     */
    function click(path) {
      if ($("PX521"), uName2 && path && $q(path)) {
        var el = createElement(path);
        if (el) {
          var apptype = el.tagName || el.nodeName || "";
          if (-1 !== equals(nodeBlackList, apptype.toUpperCase())) {
            var options = fn(el);
            if (options) {
              var res = expand(options);
              var position = offset(el);
              if (void 0 !== position) {
                res.PX263 = position;
              }
              run("PX252", res);
              maxPrimaryDepth++;
              if (curPrimaryDepth <= maxPrimaryDepth) {
                /** @type {boolean} */
                uName2 = false;
                trigger(false);
              }
              push("PX521");
            }
          }
        }
      }
    }
    /**
     * @param {number} now
     * @return {?}
     */
    function expand(now) {
      var input = concat();
      var contents = split(input);
      var term = void 0;
      if (contents.length > 0) {
        var names = contents[contents.length - 1];
        term = {
          PX72 : now,
          PX206 : names[0] || "",
          PX205 : names[1] || "",
          PX34 : input
        };
      } else {
        term = {
          PX72 : now,
          PX34 : input
        };
      }
      return term;
    }
    /**
     * @param {!Event} el
     * @return {?}
     */
    function $q(el) {
      return false === el.isTrusted;
    }
    /**
     * @param {string} event
     * @return {undefined}
     */
    function trigger(event) {
      if (target !== event) {
        call(event)(document, "click", click);
        /** @type {string} */
        target = event;
      }
    }
    /**
     * @return {undefined}
     */
    function setupForm() {
      ready(function() {
        trigger(true);
      });
    }
    /**
     * @param {?} type
     * @return {?}
     */
    function stop(type) {
      switch(type) {
        case "focus":
        case "blur":
          return "focus_change";
        case "visibilitychange":
          return "visibility_change";
        case "resize":
          return "resize";
        default:
          return "unknown";
      }
    }
    /**
     * @param {!Object} self
     * @return {?}
     */
    function change(self) {
      try {
        var type = self.type;
        var newRangeElements = {
          PX38 : stop(type),
          PX70 : getTime()
        };
        switch(type) {
          case "focus":
            /** @type {boolean} */
            newRangeElements.PX246 = true;
            break;
          case "blur":
            /** @type {boolean} */
            newRangeElements.PX246 = false;
            break;
          case "resize":
            /** @type {number} */
            newRangeElements.PX245 = +(self.target.outerHeight - opts.h) || 0;
            /** @type {number} */
            newRangeElements.PX244 = +(self.target.outerWidth - opts.w) || 0;
            break;
          case "visibilitychange":
            newRangeElements.PX243 = self.target.visibilityState;
        }
        return newRangeElements;
      } catch (t) {
        return null;
      }
    }
    /**
     * @return {undefined}
     */
    function destroySlider() {
      /** @type {boolean} */
      self.wasDetected = true;
      storage.setItem(self.key, getTime());
      removeEvent(window, "focus", self.handler);
      removeEvent(window, "blur", self.handler);
    }
    /**
     * @param {!Object} json
     * @return {?}
     */
    function initSlider(json) {
      if ($("PX512"), !self.wasDetected && json) {
        /** @type {boolean} */
        var newdrag = "focus" === json.type;
        if (null === lastdrag) {
          return void(lastdrag = newdrag);
        }
        if (lastdrag !== newdrag) {
          destroySlider();
          var expected = change(json);
          if (!expected) {
            return;
          }
          return run(usingStream, expected);
        }
        push("PX512");
      }
    }
    /**
     * @param {!Object} val
     * @return {?}
     */
    function scroll(val) {
      $("PX513");
      var type = val.type;
      var data = json[type];
      if (!(!data || data && data.wasDetected)) {
        /** @type {boolean} */
        data.wasDetected = true;
        storage.setItem(data.key, getTime());
        removeEvent(data.objectToRegister(), type, data.handler);
        var expected = change(val);
        if (expected) {
          return run(usingStream, expected);
        }
        push("PX513");
      }
    }
    /**
     * @param {string} e
     * @return {undefined}
     */
    function createUser(e) {
      if (le !== e) {
        var on = call(e);
        var i;
        for (i in json) {
          var event = json[i];
          if (event && !event.wasDetected && !storage.getItem(event.key)) {
            var dwin = event.objectToRegister();
            if (dwin) {
              on(dwin, i, event.handler);
            }
          }
        }
        /** @type {string} */
        le = e;
      }
    }
    /**
     * @return {undefined}
     */
    function onWindowMove() {
      ready(function() {
        if (window) {
          try {
            /** @type {number} */
            opts.h = window.outerHeight || 0;
            /** @type {number} */
            opts.w = window.outerWidth || 0;
          } catch (t) {
          }
        }
        createUser(true);
      });
    }
    /**
     * @param {!Event} event
     * @return {undefined}
     */
    function display(event) {
      if (zv) {
        $("PX849");
        var proto = onClick(event);
        if (proto) {
          tonum++;
          var e = createElement(event);
          var spot = fn(e);
          var result = log(e);
          run("PX260", {
            PX72 : spot,
            PX261 : proto.centerX,
            PX262 : proto.centerY,
            PX74 : e.offsetWidth,
            PX75 : e.offsetHeight,
            PX76 : result.top,
            PX77 : result.left,
            PX283 : tonum
          });
          if (bynum <= tonum) {
            /** @type {boolean} */
            zv = false;
            hide(false);
          }
          push("PX849");
        }
      }
    }
    /**
     * @param {string} fn
     * @return {undefined}
     */
    function hide(fn) {
      if (tn !== fn) {
        call(fn)(document, "click", display);
        /** @type {string} */
        tn = fn;
      }
    }
    /**
     * @return {undefined}
     */
    function _do_preload() {
      ready(function() {
        $("PX849");
        hide(true);
        push("PX849");
      });
    }
    /**
     * @param {?} callback
     * @param {?} expression
     * @return {undefined}
     */
    function query(callback, expression) {
      if (!Jv) {
        run("PX412", {
          PX746 : callback,
          PX71 : expression,
          PX70 : getTime(),
          PX34 : concat()
        });
        /** @type {boolean} */
        Jv = true;
      }
    }
    /**
     * @param {!Function} name
     * @param {?} callback
     * @return {undefined}
     */
    function title(name, callback) {
      if (!Jv) {
        callback(name || query);
      }
    }
    /**
     * @param {(Node|Window)} array
     * @param {!Array} n
     * @return {?}
     */
    function contains(array, n) {
      /** @type {number} */
      var ret = -1;
      /** @type {number} */
      var s = 0;
      for (; s < n.length; s++) {
        var i = n[s];
        if (Element.prototype.getAttribute.call(array, i)) {
          /** @type {number} */
          ret = s;
          break;
        }
      }
      return ret;
    }
    /**
     * @param {!HTMLElement} context
     * @param {!Array} x
     * @return {?}
     */
    function min(context, x) {
      /** @type {number} */
      var min = -1;
      /** @type {number} */
      var i = 0;
      for (; i < x.length; i++) {
        if (x[i] in context) {
          /** @type {number} */
          min = i;
          break;
        }
      }
      return min;
    }
    /**
     * @param {?} cb
     * @return {undefined}
     */
    function summarize(cb) {
      var result = min(document, length);
      if (-1 !== result) {
        cb("PX738", result);
      }
    }
    /**
     * @param {?} x
     * @return {undefined}
     */
    function mc(x) {
      var b = min(window, length);
      if (-1 !== b) {
        x("PX739", b);
      }
    }
    /**
     * @param {?} callback
     * @return {undefined}
     */
    function placeholder_service(callback) {
      var total = contains(document.documentElement, hour);
      if (-1 !== total) {
        callback("PX740", total);
      }
    }
    /**
     * @param {?} $
     * @return {undefined}
     */
    function processItem($) {
      var module = factory("Q2hyb21lRHJpdmVyd2plcnM5MDhmbGpzZGYzNzQ1OWZzZGZnZGZ3cnU9");
      try {
        /** @type {number} */
        var params = document.cookie.indexOf(module);
        if (-1 !== params) {
          $("PX741", params);
        }
      } catch (t) {
      }
    }
    /**
     * @param {?} cb
     * @return {?}
     */
    function selector(cb) {
      /** @type {!Array} */
      var crossfilterable_layers = [document.getElementsByTagName(factory("aWZyYW1l")), document.getElementsByTagName(factory("ZnJhbWU="))];
      /** @type {number} */
      var layer_i = 0;
      for (; layer_i < crossfilterable_layers.length; layer_i++) {
        var blocks = crossfilterable_layers[layer_i];
        /** @type {number} */
        var i = 0;
        for (; i < blocks.length; i++) {
          var last = contains(blocks[i], hour);
          if (-1 !== last) {
            return void cb("PX742", last);
          }
        }
      }
    }
    /**
     * @param {?} cb
     * @return {undefined}
     */
    function renderTo(cb) {
      /**
       * @param {?} html
       * @return {undefined}
       */
      function transform(html) {
        if (eventMap) {
          /** @type {number} */
          var i = 0;
          for (; i < _eventQueuedUntilReady.length; i++) {
            var event = _eventQueuedUntilReady[i];
            document.removeEventListener(event, eventMap[event]);
          }
          /** @type {null} */
          eventMap = null;
          cb("PX743", html);
        }
      }
      var eventMap = {};
      /** @type {number} */
      var i = 0;
      for (; i < _eventQueuedUntilReady.length; i++) {
        var event = _eventQueuedUntilReady[i];
        eventMap[event] = transform.bind(null, i);
        document.addEventListener(event, eventMap[event]);
      }
    }
    /**
     * @param {?} string
     * @return {undefined}
     */
    function toJSON(string) {
      $("PX886");
      var isString = title.bind(null, string);
      isString(renderTo);
      isString(summarize);
      isString(mc);
      isString(placeholder_service);
      isString(processItem);
      isString(selector);
      push("PX886");
    }
    /**
     * @param {?} value
     * @return {undefined}
     */
    function defined(value) {
      ready(toJSON.bind(null, value));
    }
    /**
     * @return {undefined}
     */
    function createPage() {
      var newItem = {
        t : "PX613",
        d : {
          PX614 : true
        }
      };
      /** @type {string} */
      var w76 = "//# " + _newValue;
      /** @type {string} */
      var e = setAttribute() + "/noCors";
      var WORLD_BB_OFFSET = emit([newItem]).join("&") + "&smu=1";
      /** @type {string} */
      var o = w76 + "=" + e + "?" + WORLD_BB_OFFSET;
      /** @type {!Element} */
      var tmp = document.createElement("script");
      /** @type {string} */
      tmp.textContent = o;
      document.head.appendChild(tmp);
      document.head.removeChild(tmp);
    }
    /**
     * @return {undefined}
     */
    function getDynamicMapsEngineLayer() {
      createPage();
    }
    /**
     * @return {undefined}
     */
    function fetch() {
      if (indexOf()) {
        try {
          !function() {
            /** @type {string} */
            var GROUPS_END_POINT = "//collector-" + window._pxAppId + ".perimeterx.net/b/g";
            /** @type {!XMLHttpRequest} */
            var xhr = new XMLHttpRequest;
            /**
             * @return {undefined}
             */
            xhr.onreadystatechange = function() {
              if (4 === xhr.readyState && 0 === xhr.status) {
                makeBorder();
              }
            };
            xhr.open("get", GROUPS_END_POINT);
            xhr.send();
          }();
        } catch (t) {
        }
      }
    }
    /**
     * @return {undefined}
     */
    function makeBorder() {
      var newItem = {
        t : "PX891",
        d : {}
      };
      var identityLoginURL = emit([newItem]).join("&");
      /** @type {string} */
      (new Image).src = "//collector-" + window._pxAppId + ".px-cloud.net/b/g?" + identityLoginURL;
    }
    /**
     * @return {undefined}
     */
    function release() {
      if (lh) {
        /** @type {boolean} */
        lh = false;
        /** @type {number} */
        var j = 0;
        for (; j < testcase.length; j++) {
          run("PX864", testcase[j]);
        }
        cancel(false);
      }
    }
    /**
     * @param {!Event} a
     * @return {undefined}
     */
    function frame(a) {
      if (lh) {
        $("PX865");
        var n = createElement(a);
        var o = fn(n);
        var l = log(n);
        var failure = {
          PX72 : o,
          PX76 : l.top,
          PX77 : l.left,
          PX74 : n.offsetWidth,
          PX75 : n.offsetHeight,
          PX78 : a.clientX,
          PX79 : a.clientY,
          PX157 : true === a.isTrusted,
          PX70 : timestamp(a)
        };
        testcase.push(failure);
        if (testcase.length >= maxNumberOfSuggestions) {
          release();
        }
        push("PX865");
      }
    }
    /**
     * @param {string} event
     * @return {undefined}
     */
    function cancel(event) {
      if (eventName !== event) {
        call(event)(document, "click", frame);
        /** @type {string} */
        eventName = event;
      }
    }
    /**
     * @return {undefined}
     */
    function activate() {
      ready(function() {
        $("PX865");
        cancel(true);
        push("PX865");
      });
      setTimeout(release);
    }
    /**
     * @return {undefined}
     */
    function link() {
      Loader();
      fetch();
      routeLeaveFunction();
      _exportTo();
      cacheProcessRtoken();
      loaded();
      defined();
      bulkSelection();
      handleMessage();
      setupPageInit();
      checkShutDown();
      downloadEvents();
      setupForm();
      onWindowMove();
      _do_preload();
      getDynamicMapsEngineLayer();
      activate();
    }
    /**
     * @return {undefined}
     */
    function onerror() {
      try {
        var t = map("dns_probe");
        if (!t) {
          return;
        }
        result = t.split(",");
        /** @type {number} */
        var i = 0;
        for (; i < result.length; i++) {
          var url = result[i];
          /** @type {!Image} */
          var img = new Image;
          img.onload = onLoad(url, i);
          img.src = url;
        }
      } catch (t) {
      }
    }
    /**
     * @param {?} url
     * @param {number} path
     * @return {?}
     */
    function onLoad(url, path) {
      return function() {
        try {
          if (window.performance) {
            /** @type {!Array<PerformanceEntry>} */
            var parameters = window.performance.getEntriesByName(url);
            if (parameters && parameters[0]) {
              /** @type {!PerformanceEntry} */
              var t = parameters[0];
              /** @type {number} */
              var mtime = t.domainLookupEnd - t.domainLookupStart;
              if (collection[path] = [t.duration, mtime], collection.length === result.length) {
                /** @type {number} */
                var i = 0;
                for (; i < collection.length; i++) {
                  var serviceId = collection[i];
                  var errorsCopy = serviceId[0];
                  var updateErrors = serviceId[1];
                  switch(i) {
                    case 0:
                      _createStartKeyframeFromEndKeyframe("PX384", errorsCopy);
                      _createStartKeyframeFromEndKeyframe("PX385", updateErrors);
                      break;
                    case 1:
                      _createStartKeyframeFromEndKeyframe("PX386", errorsCopy);
                      _createStartKeyframeFromEndKeyframe("PX387", updateErrors);
                      break;
                    case 2:
                      _createStartKeyframeFromEndKeyframe("PX388", errorsCopy);
                      _createStartKeyframeFromEndKeyframe("PX389", updateErrors);
                      break;
                    case 3:
                      _createStartKeyframeFromEndKeyframe("PX390", errorsCopy);
                      _createStartKeyframeFromEndKeyframe("PX391", updateErrors);
                  }
                }
              }
            }
          }
        } catch (t) {
        }
      };
    }
    /**
     * @return {undefined}
     */
    function print() {
      add_monitoredItem();
      getLastTouchStretch(false);
      collect();
      /** @type {number} */
      c = +map(keyCodes.K);
      if ("number" == typeof c && c <= numberOfColumns) {
        setTimeout(exports.bind(this, c), c);
      } else {
        exports();
      }
    }
    /**
     * @param {?} series
     * @return {undefined}
     */
    function exports(series) {
      if (!wh) {
        /** @type {boolean} */
        wh = true;
        ready(function() {
          getComposeDefaults(function() {
            save(function(self) {
              if (self) {
                self.PX889 = series;
                run("PX3", self);
                onerror();
              }
            });
          });
        });
        if (lastTouchStretch || cycle) {
          setTimeout(updatePage, WAITING_SECONDS);
        } else {
          setTimeout(updatePage, 0);
        }
      }
    }
    /**
     * @return {undefined}
     */
    function updatePage() {
      $("PX544");
      link();
      setTimeout(function() {
        data.flushActivities();
      }, true);
      push("PX544");
    }
    /**
     * @param {string} url
     * @param {?} name
     * @return {undefined}
     */
    function has(url, name) {
      try {
        if (url === property && "function" == typeof window.pxInit) {
          window.pxInit(name);
        } else {
          var callback = window[property + "_asyncInit"];
          if ("function" == typeof callback) {
            callback(name);
          }
        }
      } catch (t) {
      }
    }
    /**
     * @param {(Node|NodeList|string)} x
     * @return {undefined}
     */
    function start(x) {
      var tile = keys(x);
      if (!shouldAvoid && tile) {
        if (isArray(keyCodes.L)) {
          setValidMoves(x);
        }
        waitUntilQuiet((new Date).getTime());
        /** @type {boolean} */
        shouldAvoid = true;
        print();
      }
    }
    /**
     * @param {string} id
     * @return {undefined}
     */
    function registerLocalShortcut(id) {
      data.routes = on(indexOf());
      /** @type {string} */
      data.appID = id;
      /** @type {string} */
      data.tag = tagName;
      /** @type {string} */
      data.fTag = nodeBBURL;
      register();
      data.one("xhrSuccess", getPerformaceInfo);
      data.on("xhrResponse", start);
      data.on("xhrSuccess", all);
      data.on("xhrFailure", all);
    }
    /**
     * @return {undefined}
     */
    function register() {
      var value = void 0;
      var type = indexOf();
      if (type !== ORION_TYPE && type !== ssh_dss && type !== number || (value = window._pxVid || load("vid")), !value) {
        var test_value = require("_pxvid") || require("pxvid");
        var a = require("_pxmvid");
        if (a) {
          lastIndexOf("_pxmvid", a, parse());
          value = a;
        } else {
          if (test_value) {
            value = test_value;
          }
        }
      }
      mixin(value);
    }
    /**
     * @return {undefined}
     */
    function _isFrame() {
      var pref = {
        PX96 : parent,
        PX63 : navigator && navigator.platform,
        PX191 : window.self === window.top ? 0 : 1
      };
      if (window._pxRootUrl) {
        /** @type {boolean} */
        pref.PX853 = true;
      }
      run("PX2", pref);
      data.sendActivities();
    }
    /**
     * @return {undefined}
     */
    function doneHandler() {
      if (p.length > 0 && data.failures < data.retries) {
        data.sendActivities();
      } else {
        all();
      }
    }
    /**
     * @return {undefined}
     */
    function all() {
      setTimeout(doneHandler, antiFlood);
    }
    /** @type {string} */
    var Hc = "1";
    /** @type {string} */
    var version = "2";
    /** @type {string} */
    var WIN7 = "3";
    /** @type {string} */
    var webkitVersion = "4";
    /** @type {string} */
    var undefined = "5";
    /** @type {string} */
    var OSX = "6";
    /** @type {string} */
    var XP = "7";
    /** @type {function(!Object): ?} */
    var each = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(instance) {
      return typeof instance;
    } : function(obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    var logError = function() {
      /**
       * @param {?} v
       * @param {number} len
       * @return {?}
       */
      function get(v, len) {
        /** @type {!Array} */
        var names = [];
        /** @type {boolean} */
        var _iteratorNormalCompletion3 = true;
        /** @type {boolean} */
        var o = false;
        var i = void 0;
        try {
          var info;
          var _iterator3 = v[Symbol.iterator]();
          for (; !(_iteratorNormalCompletion3 = (info = _iterator3.next()).done) && (names.push(info.value), !len || names.length !== len); _iteratorNormalCompletion3 = true) {
          }
        } catch (contactCapacity) {
          /** @type {boolean} */
          o = true;
          i = contactCapacity;
        } finally {
          try {
            if (!_iteratorNormalCompletion3 && _iterator3.return) {
              _iterator3.return();
            }
          } finally {
            if (o) {
              throw i;
            }
          }
        }
        return names;
      }
      return function(arr, middle) {
        if (Array.isArray(arr)) {
          return arr;
        }
        if (Symbol.iterator in Object(arr)) {
          return get(arr, middle);
        }
        throw new TypeError("Invalid attempt to destructure non-iterable instance");
      };
    }();
    /** @type {!RegExp} */
    var a = /[\\"--Ÿ­؀-؄܏឴឵‌-‏
- ⁠-￰-￿]/g;
    var attributes = {
      "\b" : "\\b",
      "\t" : "\\t",
      "\n" : "\\n",
      "\f" : "\\f",
      "\r" : "\\r",
      "" : "\\v",
      '"' : '\\"',
      "\\" : "\\\\"
    };
    /** @type {string} */
    var mlp = '"undefined"';
    /** @type {string} */
    var className = "null";
    var at = void 0;
    var ch = void 0;
    var ret = void 0;
    var escapee = {
      '"' : '"',
      "\\" : "\\",
      "/" : "/",
      b : "\b",
      f : "\f",
      n : "\n",
      r : "\r",
      t : "\t"
    };
    var timedEvents = {};
    var templates = {};
    var removeClass = void 0;
    /** @type {string} */
    var index = "s";
    /** @type {string} */
    var action = "c";
    /** @type {number} */
    var ne_resize = 0;
    /** @type {!Array} */
    var sources = ["beforeunload", "unload", "pagehide"];
    var Pu = void 0;
    var rect = void 0;
    /** @type {!Array} */
    var q = [];
    /** @type {!Array} */
    var handlers = [];
    /** @type {boolean} */
    var yu = false;
    !function() {
      bindReady(function() {
        rect = rect || getTime();
      });
    }();
    /** @type {string} */
    var related_node_ids = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    /** @type {!RegExp} */
    var regCls = /[^+\/=0-9A-Za-z]/;
    var o = function() {
      try {
        return window.atob;
      } catch (t) {
      }
    }();
    var spaces = function(optionData) {
      if ("boolean" == typeof optionData ? optionData : "function" == typeof btoa) {
        return function(t) {
          return btoa(encodeURIComponent(t).replace(/%([0-9A-F]{2})/g, function(canCreateDiscussions, index) {
            return String.fromCharCode("0x" + index);
          }));
        };
      }
      var value = function() {
        var unescape = window.unescape || window.decodeURI;
        return {
          v : function(key) {
            /** @type {string} */
            var base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
            var r = void 0;
            var g = void 0;
            var tmpb = void 0;
            var i = void 0;
            var x = void 0;
            var digit = void 0;
            var arg = void 0;
            var orTmp = void 0;
            /** @type {number} */
            var index = 0;
            /** @type {number} */
            var d = 0;
            /** @type {!Array} */
            var dArr = [];
            if (!key) {
              return key;
            }
            try {
              key = unescape(encodeURIComponent(key));
            } catch (t) {
              return key;
            }
            do {
              r = key.charCodeAt(index++);
              g = key.charCodeAt(index++);
              tmpb = key.charCodeAt(index++);
              /** @type {number} */
              orTmp = r << 16 | g << 8 | tmpb;
              /** @type {number} */
              i = orTmp >> 18 & 63;
              /** @type {number} */
              x = orTmp >> 12 & 63;
              /** @type {number} */
              digit = orTmp >> 6 & 63;
              /** @type {number} */
              arg = 63 & orTmp;
              /** @type {string} */
              dArr[d++] = base64.charAt(i) + base64.charAt(x) + base64.charAt(digit) + base64.charAt(arg);
            } while (index < key.length);
            /** @type {string} */
            var res = dArr.join("");
            /** @type {number} */
            var len = key.length % 3;
            return (len ? res.slice(0, len - 3) : res) + "===".slice(len || 3);
          }
        };
      }();
      return "object" === (void 0 === value ? "undefined" : each(value)) ? value.v : void 0;
    }();
    /** @type {number} */
    var numberOfActivationUnitsL2 = 20;
    var j = getTime();
    /** @type {number} */
    var COST_OPTIMIZED = 11;
    /** @type {number} */
    var curDayIdx = 1;
    var id = (factory("c2NyaXB0"), function() {
      /** @type {string} */
      var nativeSignal = "mousewheel";
      try {
        if (window && window.navigator && /Firefox/i.test(window.navigator.userAgent)) {
          /** @type {string} */
          nativeSignal = "DOMMouseScroll";
        }
      } catch (t) {
      }
      return nativeSignal;
    }());
    var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver;
    /** @type {number} */
    var FIELD_EXPANDER_ID_MIN = 48;
    /** @type {number} */
    var FIELD_EXPANDER_ID_MAX = 57;
    /** @type {number} */
    var LOGIN_COLOR_MAX = 10;
    /** @type {number} */
    var maxElements = 20;
    /** @type {string} */
    var screen = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    /** @type {number} */
    var rowsPerColumn = 0;
    /** @type {string} */
    var Service = "?";
    /** @type {number} */
    var msg = 0;
    var entry = void 0;
    /** @type {number} */
    var source = 0;
    /** @type {number} */
    var newHash = 0;
    /** @type {boolean} */
    var called_ = false;
    /** @type {!Array} */
    var messageHandlers = [];
    /** @type {number} */
    var YYYY = 50;
    /** @type {boolean} */
    var Uu = true;
    try {
      /** @type {!Object} */
      var options = Object.defineProperty({}, "passive", {
        get : function() {
          return Uu = false, true;
        }
      });
      window.addEventListener("test", null, options);
    } catch (t) {
    }
    var Pubsub = {
      on : function(type, filter, context) {
        this.subscribe(type, filter, context, false);
      },
      one : function(type, fn, context) {
        this.subscribe(type, fn, context, true);
      },
      off : function(name, callback) {
        if (void 0 !== this.channels[name]) {
          var i = void 0;
          var tableslen = void 0;
          /** @type {number} */
          i = 0;
          tableslen = this.channels[name].length;
          for (; i < tableslen; i++) {
            if (this.channels[name][i].fn === callback) {
              this.channels[name].splice(i, 1);
              break;
            }
          }
        }
      },
      subscribe : function(name, handler, context, once) {
        if (void 0 === this.channels) {
          this.channels = {};
        }
        this.channels[name] = this.channels[name] || [];
        this.channels[name].push({
          fn : handler,
          ctx : context,
          once : once || false
        });
      },
      trigger : function(name) {
        if (this.channels && this.channels.hasOwnProperty(name)) {
          /** @type {!Array>} */
          var cmd_args = Array.prototype.slice.call(arguments, 1);
          /** @type {!Array} */
          var a = [];
          for (; this.channels[name].length > 0;) {
            var test = this.channels[name].shift();
            if ("function" == typeof test.fn) {
              test.fn.apply(test.ctx, cmd_args);
            }
            if (!test.once) {
              a.push(test);
            }
          }
          /** @type {!Array} */
          this.channels[name] = a;
        }
      }
    };
    var utils = {
      cloneObject : function(obj) {
        var newObj = {};
        var key;
        for (key in obj) {
          if (obj.hasOwnProperty(key)) {
            newObj[key] = obj[key];
          }
        }
        return newObj;
      },
      extend : function(t, target) {
        var cache = utils.cloneObject(target);
        var eid;
        for (eid in cache) {
          if (cache.hasOwnProperty(eid)) {
            t[eid] = cache[eid];
          }
        }
        return t;
      }
    };
    var desc = {
      cipher : "SHA512",
      len : 36
    };
    var generatefileNameString = void 0;
    try {
      if ("undefined" != typeof crypto && crypto && crypto.getRandomValues) {
        (function() {
          /** @type {!Uint8Array} */
          var array = new Uint8Array(16);
          (generatefileNameString = function() {
            return crypto.getRandomValues(array), array;
          })();
        })();
      }
    } catch (t) {
      generatefileNameString = void 0;
    }
    if (!generatefileNameString) {
      (function() {
        /** @type {!Array} */
        var token = new Array(16);
        /**
         * @return {?}
         */
        generatefileNameString = function() {
          var n;
          /** @type {number} */
          var zeroAt = 0;
          for (; zeroAt < 16; zeroAt++) {
            if (0 == (3 & zeroAt)) {
              /** @type {number} */
              n = 4294967296 * Math.random();
            }
            /** @type {number} */
            token[zeroAt] = n >>> ((3 & zeroAt) << 3) & 255;
          }
          return token;
        };
      })();
    }
    /** @type {!Array} */
    var _byteToHex = [];
    var returnCodes = {};
    /** @type {number} */
    var k = 0;
    for (; k < 256; k++) {
      /** @type {string} */
      _byteToHex[k] = (k + 256).toString(16).substr(1);
      /** @type {number} */
      returnCodes[_byteToHex[k]] = k;
    }
    var nf = generatefileNameString();
    /** @type {!Array} */
    var _nodeId = [1 | nf[0], nf[1], nf[2], nf[3], nf[4], nf[5]];
    /** @type {number} */
    var file = 16383 & (nf[6] << 8 | nf[7]);
    /** @type {number} */
    var max = 0;
    /** @type {number} */
    var concurency = 0;
    var gamma = factory("aW5uZXJIVE1M");
    var m = factory("aWZyYW1l");
    var poisson = factory("dmFsdWU=");
    var shuffle = factory("cmVjYXB0Y2hh");
    var feature = factory("aGFuZGxlQ2FwdGNoYQ==");
    var ctx = factory("Zy1yZWNhcHRjaGEtcmVzcG9uc2U=");
    var freezeheadercontentid = factory("cmVjYXB0Y2hhLXRva2Vu");
    var module = factory("L2JmcmFtZT8=");
    /** @type {!Array} */
    var updatedList = [];
    /** @type {!Array} */
    var _dropIndicators = [];
    /** @type {!Array} */
    var todos = [];
    /** @type {!Array} */
    var pastExecs = [];
    /** @type {!Array} */
    var store = [];
    /** @type {null} */
    var v = null;
    /** @type {number} */
    var clientHeight = 200;
    /** @type {number} */
    var _to = 40;
    var tag = apply(10);
    /** @type {number} */
    var targetOffsetHeight = 0;
    /** @type {boolean} */
    var Sf = false;
    var input = void 0;
    var focus = void 0;
    var el = void 0;
    var mutations = void 0;
    var e = void 0;
    var boxInput = void 0;
    /** @type {string} */
    var flowdata = "1";
    /** @type {string} */
    var ssh_dss = "pxc";
    /** @type {string} */
    var number = "pxhc";
    /** @type {string} */
    var ORION_TYPE = "c";
    var instance = factory("ODlkNWZhOGQtMTgwZi00NGExLTg0OTctMDZiNWRlMjMwMmQ0");
    /** @type {number} */
    var samplecount = 1E4;
    /** @type {null} */
    var _na = null;
    /** @type {null} */
    var left = null;
    var Bf = void 0;
    var Zf = void 0;
    var last = void 0;
    var builtinEnabled = void 0;
    /** @type {boolean} */
    var pageId = false;
    /** @type {!Array} */
    var touchEvents = ["touchstart", "touchend", "touchmove", "touchenter", "touchleave", "touchcancel", "mousedown", "mouseup", "mousemove", "mouseover", "mouseout", "mouseenter", "mouseleave", "click", "dblclick", "scroll", "wheel"];
    /** @type {boolean} */
    var removeContent = true;
    /** @type {number} */
    var limit = 50;
    /** @type {number} */
    var maxReconnectTryTimes = 15E3;
    /** @type {number} */
    var maximum = 50;
    /** @type {number} */
    var outCount = 10;
    /** @type {number} */
    var lower = 50;
    /** @type {string} */
    var Icon = ",";
    /** @type {number} */
    var clientWidth = 10;
    /** @type {number} */
    var chunkSize = 5;
    /** @type {boolean} */
    var ns = true;
    /** @type {!Array} */
    var output = [];
    var $$hash$$Symbol_registry = {};
    /** @type {number} */
    var $$hash$$Symbol_id = 1;
    var hoverSelectionTimeout = void 0;
    var type = void 0;
    /** @type {number} */
    var cs = 0;
    /** @type {number} */
    var reconnectTryTimes = 0;
    /** @type {number} */
    var targetOffsetWidth = 0;
    /** @type {boolean} */
    var suspended = false;
    var begin = getTime();
    /** @type {boolean} */
    var ds = true;
    var ref = void 0;
    var events = {
      mousemove : null,
      mousewheel : null
    };
    var _this = {
      mousemove : 200,
      mousewheel : 50
    };
    /** @type {!Array} */
    var crossfilterable_layers = ["mouseup", "mousedown", "click", "contextmenu", "mouseout"];
    /** @type {!Array} */
    var names = ["keyup", "keydown"];
    /** @type {!Array} */
    var eventTypes = ["copy", "cut", "paste"];
    /** @type {!Array} */
    var ids = ["mousemove", id];
    /** @type {!Array} */
    var argsOut = [];
    /** @type {!Array} */
    var child = [];
    /** @type {!Array} */
    var lines = [];
    var keyCodes = {};
    keyCodes.M = factory("ZWQ=");
    keyCodes.H = factory("bmU=");
    keyCodes.N = factory("d3c=");
    keyCodes.F = factory("d2E=");
    keyCodes.O = factory("YWZfd3A=");
    keyCodes.P = factory("YWZfc3A=");
    keyCodes.Q = factory("YWZfY2Q=");
    keyCodes.R = factory("YWZfcmY=");
    keyCodes.S = factory("YWZfc2U=");
    keyCodes.p = factory("dG0=");
    keyCodes.T = factory("aWRw");
    keyCodes.U = factory("aWRwX3A=");
    keyCodes.V = factory("aWRwX2M=");
    keyCodes.K = factory("YmRk");
    keyCodes.G = factory("ZG5k");
    keyCodes.L = factory("anNiX3J0");
    keyCodes.k = factory("YnNjbw==");
    keyCodes.j = factory("YXh0");
    keyCodes.i = factory("cmY=");
    keyCodes.J = factory("ZnA=");
    keyCodes.A = factory("cnNr");
    keyCodes.I = factory("c2Nz");
    /** @type {number} */
    var err = 300;
    /** @type {string} */
    var name = "_pxff_";
    /** @type {string} */
    var F1 = "1";
    var memo = {};
    var resultses = {};
    /** @type {!Array} */
    var d = [];
    /** @type {boolean} */
    var Rs = false;
    !function() {
      var k;
      for (k in keyCodes) {
        if (keyCodes.hasOwnProperty(k)) {
          map(keyCodes[k]);
        }
      }
    }();
    /** @type {number} */
    var _previousId = 3600;
    var api = factory("X3B4QWN0aW9u");
    var eleId = factory("cHgtY2FwdGNoYQ==");
    var ssrAttribute = (factory("Zy1yZWNhcHRjaGE="), factory("ZGF0YS1zaXRla2V5"));
    /** @type {string} */
    var bottom = "6Lcj-R8TAAAAABs3FrRPuQhLMbp5QrHsHufzLf7b";
    var end = getTime();
    /** @type {string} */
    var parent = window.location && window.location.href || "";
    /** @type {!Array} */
    var p = [];
    /** @type {!Array} */
    var queue = [];
    /** @type {string} */
    var tagName = "v5.6.1";
    /** @type {string} */
    var nodeBBURL = "165";
    /** @type {string} */
    var property = "PXuR63h57Z";
    /** @type {number} */
    var binTarget = 0;
    var pusherInstance = utils.extend({}, Pubsub);
    var me = utils.extend({}, Pubsub);
    var value = function() {
      var type = indexOf();
      return type === ORION_TYPE || type === ssh_dss || type === number ? window._pxUuid || load("uuid") || walk() : walk();
    }();
    var plugin = {
      Events : me,
      ClientUuid : value,
      setChallenge : excute
    };
    var verPref = function() {
      var baseParts = split(concat());
      return (baseParts[baseParts.length - 1] || {})[0];
    }();
    var template = factory("X3B4aGQ=");
    /** @type {boolean} */
    var transitionDuration = false;
    /** @type {!Array} */
    var old_value = ["PX297", "PX175", "PX4", "PX627", "PX611"];
    /** @type {number} */
    var ni = 0;
    /** @type {null} */
    var x = null;
    var element = void 0;
    var filtered = void 0;
    var val = void 0;
    var lspace = void 0;
    var buckets = void 0;
    var LAST_NETWORKING_RESTART_TIME = void 0;
    var node = void 0;
    var cl = void 0;
    var ul = void 0;
    var uriTemplate = void 0;
    var head = void 0;
    getComposeDefaults(upperCaseAlphabet);
    /** @type {!Array} */
    var ll = [];
    /** @type {string} */
    var sessionStorage = "sessionStorage";
    /** @type {string} */
    var GET_USER_PROFILE_SUCCESS = "nStorage";
    /** @type {number} */
    var NaN = 12E4;
    /** @type {number} */
    var border = 9E5;
    /** @type {boolean} */
    var Xl = true;
    /** @type {boolean} */
    var Pl = true;
    /** @type {number} */
    var rumbleSpeed = 24E4;
    /** @type {null} */
    var rumbleInterval = null;
    /** @type {number} */
    var arr = 0;
    /** @type {number} */
    var yl = 0;
    var bl = void 0;
    var configStorage = getStorage(sessionStorage);
    /** @type {string} */
    var LOCAL_TOKEN_KEY = property + "_pr_c";
    var attrs = {
      bake : setCookie,
      sid : sid,
      cfe : inject,
      sff : addPoint,
      sffe : enter,
      vid : size,
      te : mouseDragCallback,
      jsc : constructor,
      pre : configure,
      keys : l,
      cs : ct,
      cls : path,
      sts : callWhere,
      drc : strftime_f,
      wcs : writeSearchEntry,
      en : event,
      vals : po,
      ci : cid,
      spi : callWhereEqualFallBack,
      cv : createPath,
      rmhd : parseIdHeader
    };
    /** @type {function(string): *} */
    var getUrl = eval;
    ready(function() {
      if (is(sessionStorage)) {
        bl = configStorage.getItem(LOCAL_TOKEN_KEY);
        configStorage.removeItem(LOCAL_TOKEN_KEY);
      }
    });
    /** @type {string} */
    var prop = property + "_pxtiming";
    var perf = window.performance || window.webkitPerformance || window.msPerformance || window.mozPerformance;
    var perfNow = perf && perf.timing;
    /** @type {boolean} */
    var Rl = false;
    /** @type {string} */
    var masterVideoId = "collector-" + window._pxAppId;
    var obj = {
      z : ["pxchk.net", "px-cdn.net"],
      s : ["/api/v2/collector", "/b/s"],
      u : ["pxchk.net", "px-cdn.net"],
      W : ["/assets/js/bundle", "/res/uc"],
      q : ["/b/c"]
    };
    !function() {
      try {
        /** @type {!Array} */
        var t = ["px-cdn.net", "pxchk.net"];
        if (getCurveValue(t)) {
          /** @type {!Array} */
          obj.z = t;
        }
      } catch (t) {
      }
      try {
        /** @type {!Array} */
        var t = ["/api/v2/collector", "/b/s"];
        if (getCurveValue(t)) {
          /** @type {!Array} */
          obj.s = t;
        }
      } catch (t) {
      }
      try {
        /** @type {!Array} */
        var t = ["px-client.net"];
        if (getCurveValue(t)) {
          /** @type {!Array} */
          obj.u = t;
        }
      } catch (t) {
      }
      try {
        /** @type {!Array} */
        var t = ["/assets/js/bundle", "/res/uc"];
        if (getCurveValue(t)) {
          /** @type {!Array} */
          obj.W = t;
        }
      } catch (t) {
      }
      try {
        /** @type {!Array} */
        var t = ["/b/c"];
        if (getCurveValue(t)) {
          /** @type {!Array} */
          obj.q = t;
        }
      } catch (t) {
      }
    }();
    /** @type {string} */
    var parameterv = "payload=";
    /** @type {string} */
    var metricvalue = "appId=";
    /** @type {string} */
    var html = "tag=";
    /** @type {string} */
    var own_ = "uuid=";
    /** @type {string} */
    var roman = "xuuid=";
    /** @type {string} */
    var metriclabel = "ft=";
    /** @type {string} */
    var mui_jsonp_callback_ = "seq=";
    /** @type {string} */
    var linkDefinition = "cs=";
    /** @type {string} */
    var previous = "pc=";
    /** @type {string} */
    var filename = "sid=";
    /** @type {string} */
    var newline = "vid=";
    /** @type {string} */
    var lvalue = "jsc=";
    /** @type {string} */
    var space = "ci=";
    /** @type {string} */
    var hours = "pxhd=";
    /** @type {string} */
    var ql_ = "en=";
    /** @type {string} */
    var tbm = "rsk=";
    /** @type {string} */
    var elfinder_btncnt_ = "rsc=";
    /** @type {string} */
    var ql = "NTA";
    /** @type {string} */
    var newElt = "/api/v2/collector";
    /** @type {string} */
    var mime = "application/x-www-form-urlencoded";
    /** @type {number} */
    var XHRTME = 15E3;
    /** @type {number} */
    var maxWidth = 10;
    var LocalStorage = getStorage(sessionStorage);
    /** @type {string} */
    var prefix = "px_c_p_";
    /** @type {number} */
    var uri = 0;
    /** @type {!RegExp} */
    var multiple_slash_re = /(?:https?:)?\/\/client(?:-stg)?\.(?:perimeterx\.net|a\.pxi\.pub|px-cdn\.net|px-cloud\.net)\/PX[A-Za-z0-9]{4,8}\/main\.min\.js/g;
    var $s = function() {
      if (document.currentScript instanceof window.Element) {
        /** @type {!Element} */
        var link = document.createElement("a");
        return link.href = document.currentScript.src, link.hostname === location.hostname;
      }
      /** @type {number} */
      var i = 0;
      for (; i < document.scripts.length; i++) {
        /** @type {string} */
        var path = document.scripts[i].src;
        if (path && multiple_slash_re.test(path)) {
          return false;
        }
        /** @type {null} */
        multiple_slash_re.lastIndex = null;
      }
      return true;
    }();
    /** @type {number} */
    var color__len = 7;
    /** @type {number} */
    var waitUntilReturn = 500;
    /** @type {number} */
    var nextCheckIn = 50;
    var evtModKeys = function() {
      /** @type {!Array} */
      var _acl = [];
      var letters = eventHandler(true);
      /** @type {number} */
      var i = 0;
      for (; i < letters.length; i++) {
        /** @type {number} */
        var j = 0;
        for (; j < obj.W.length; j++) {
          var e = letters[i] + obj.W[j];
          if ("function" == typeof _acl.indexOf) {
            if (-1 === _acl.indexOf(e)) {
              _acl.push(e);
            }
          } else {
            _acl.push(e);
          }
        }
      }
      return _acl;
    }();
    /** @type {number} */
    var blocksize = 5 * evtModKeys.length;
    /** @type {number} */
    var color__i = 0;
    /** @type {number} */
    var callbackIndex = 0;
    /** @type {null} */
    var url = null;
    /** @type {null} */
    var s = null;
    /** @type {number} */
    var n2 = 0;
    var style = {};
    /** @type {boolean} */
    var Pd = false;
    var c_cachedAdapterHandles = {};
    /** @type {boolean} */
    var gd = false;
    /** @type {boolean} */
    var wd = false;
    /** @type {null} */
    var method = null;
    /** @type {number} */
    var message = 0;
    /** @type {number} */
    var slug = 0;
    /** @type {number} */
    var .num_const = 0;
    /** @type {number} */
    var btnCnt = 0;
    /** @type {boolean} */
    var npmIgnore = false;
    var data = utils.extend({
      routes : [],
      failures : 0,
      retries : 4,
      appID : "",
      tag : "",
      logReqTime : true,
      fTag : "",
      sendActivities : function(result, drawVector) {
        /**
         * @return {undefined}
         */
        function B() {
          /** @type {number} */
          var x = 0;
          for (; x < p.length; x++) {
            push(p[x]);
          }
        }
        n2++;
        $("PX508");
        result = result || when();
        /** @type {!Array} */
        var frame = [];
        /** @type {!Array} */
        var x = [];
        /** @type {number} */
        var i = 0;
        for (; i < result.length; i++) {
          var d = result[i];
          if (!arc(d.ts)) {
            if (delete d.ts, "PX3" === d.t || "PX2" === d.t) {
              d.d.PX1054 = resolveClass();
              var i = d.d.PX1008 = pick();
              if (arc(d.d.PX1055 = createUl(), i)) {
                continue;
              }
            }
            /** @type {number} */
            d.d.PX1056 = (new Date).getTime();
            d.d.PX1038 = value;
            frame.push(d);
            x.push(d.t);
          }
        }
        if (0 !== frame.length) {
          var positionCss = emit(frame);
          var post = positionCss.join("&");
          var data = {
            B : B
          };
          /** @type {string} */
          var timeFromPageInit = "PX379";
          var rearmInterval = void 0;
          /** @type {number} */
          var i = 0;
          for (; i < frame.length; i++) {
            var el = frame[i];
            if (el) {
              if ("PX2" === el.t) {
                /** @type {boolean} */
                data.PX2 = true;
                /** @type {string} */
                timeFromPageInit = "PX380";
                /** @type {string} */
                rearmInterval = "PX381";
                break;
              }
              if ("PX3" === el.t) {
                /** @type {boolean} */
                data.PX3 = true;
                /** @type {string} */
                timeFromPageInit = "PX382";
                /** @type {string} */
                rearmInterval = "PX383";
                break;
              }
              if ("PX203" === el.t) {
                if (url !== uri) {
                  /** @type {boolean} */
                  data.testDefaultPath = true;
                }
                break;
              }
              if ("PX561" === el.t) {
                /** @type {boolean} */
                data.PX561 = true;
              }
            }
          }
          var p = group(x);
          _createStartKeyframeFromEndKeyframe(timeFromPageInit);
          data.postData = post;
          /** @type {(string|undefined)} */
          data.backMetric = rearmInterval;
          if (startsWith() && data.PX2) {
            /**
             * @param {!Object} w
             * @param {!Object} x
             * @return {undefined}
             */
            data.B = function(w, x) {
              B();
              foo(w, x);
            };
          } else {
            if (drawVector) {
              /** @type {boolean} */
              data.C = true;
              /** @type {number} */
              data.D = 0;
            }
          }
          request(data);
          push("PX508");
        }
      },
      flushActivities : function() {
        var d = when();
        if (0 !== d.length) {
          var dude = emit(d).join("&");
          if (send()) {
            exportTheme(serialize(dude));
          } else {
            treatVideoFilters(serialize(dude));
          }
        }
      },
      getSid : function() {
        try {
          return void 0 !== window.sessionStorage ? window.sessionStorage.pxsid : null;
        } catch (t) {
          return null;
        }
      },
      getCustomParams : function() {
        /** @type {!Array} */
        var paramObj = [];
        if (data.params || (data.params = parseParams(window)), data.params) {
          var i;
          for (i in data.params) {
            if (data.params.hasOwnProperty(i)) {
              paramObj.push(i + "=" + encodeURIComponent(data.params[i]));
            }
          }
        }
        return paramObj;
      },
      setRouteIndex : function(events_url) {
        /** @type {number} */
        url = events_url;
      }
    }, Pubsub);
    /**
     * @return {?}
     */
    var parseRoute = function() {
      /** @type {!RegExp} */
      var _reg2 = new RegExp(regexQuote(), "g");
      if ($s) {
        return [new RegExp("/" + data.appID.replace("PX", "") + "/init.js", "g"), _reg2];
      }
      return [multiple_slash_re, _reg2];
    };
    /** @type {string} */
    var fromIndex = "|";
    /** @type {(PerformanceTiming|null)} */
    var _oAtomIgnoreFiles = window.performance && performance.timing;
    var dependencies = window[factory("Y2hyb21l")];
    var len = factory("YXBw");
    var i = factory("cnVudGltZQ==");
    /** @type {!Array} */
    var userlinks = ["webstore", i, len, "csi", "loadTimes"];
    /** @type {string} */
    var field = "createElement";
    /** @type {string} */
    var key = "webdriver";
    /** @type {string} */
    var sPath = "toJSON";
    /** @type {string} */
    var globalName = "fetch";
    /** @type {string} */
    var jqueryUISrc = "webstore";
    /** @type {string} */
    var modelName = "runtime";
    /** @type {string} */
    var EXCEPTION_VALUE = "onInstallStageChanged";
    /** @type {string} */
    var OBJECT_VALUE = "dispatchToListener";
    /** @type {string} */
    var propertyName = "sendMessage";
    /** @type {string} */
    var reducerName = "install";
    var dimension = {};
    /** @type {boolean} */
    var Ud = false;
    var nodeSetterFunctions = {};
    var driver = factory("bmF2aWdhdG9yLndlYmRyaXZlcg==");
    var option = factory("T2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcg==");
    var dir = factory("bmF2aWdhdG9yLnVzZXJBZ2VudA==");
    /** @type {!Array} */
    var args = [driver, option, dir];
    /** @type {string} */
    var userAgent = "missing";
    var n = factory("d2ViZHJpdmVy");
    /** @type {number} */
    var STYLES_LIMIT = 30;
    /** @type {number} */
    var notconnected = 500;
    /** @type {boolean} */
    var pageCurrentElem = false;
    /** @type {string} */
    var rv = "no_fp";
    /** @type {!Array} */
    var axesIds = [];
    /** @type {string} */
    var item = "wmk";
    /** @type {string} */
    var interval = "no_fp";
    /** @type {number} */
    var bar = 2E3;
    /** @type {number} */
    var obj2 = 200;
    /** @type {string} */
    var time = "gl";
    /** @type {string} */
    var array = "2d";
    /** @type {string} */
    var debugShaderTxt = "attribute vec2 attrVertex;varying vec2 varyinTexCoordinate;uniform vec2 uniformOffset;void main(){varyinTexCoordinate=attrVertex+uniformOffset;gl_Position=vec4(attrVertex,0,1);}";
    /** @type {string} */
    var pFragCode = "precision mediump float;varying vec2 varyinTexCoordinate;void main() {gl_FragColor=vec4(varyinTexCoordinate,0,1);}";
    var vv = void 0;
    /** @type {!Array} */
    var validSettings = ["AcroPDF.PDF", "Adodb.Stream", "AgControl.AgControl", "DevalVRXCtrl.DevalVRXCtrl.1", "MacromediaFlashPaper.MacromediaFlashPaper", "Msxml2.DOMDocument", "Msxml2.XMLHTTP", "PDF.PdfCtrl", "QuickTime.QuickTime", "QuickTimeCheckObject.QuickTimeCheck.1", "RealPlayer", "RealPlayer.RealPlayer(tm) ActiveX Control (32-bit)", "RealVideo.RealVideo(tm) ActiveX Control (32-bit)", "Scripting.Dictionary", "SWCtl.SWCtl", "Shell.UIHelper", "ShockwaveFlash.ShockwaveFlash", "Skype.Detection", 
    "TDCCtl.TDCCtl", "WMPlayer.OCX", "rmocx.RealPlayer G2 Control", "rmocx.RealPlayer G2 Control.1"];
    /** @type {number} */
    var extraTenMax = 30;
    /** @type {number} */
    var maxResults = 30;
    /** @type {number} */
    var pos = 200;
    /** @type {string} */
    var object = "no_fp";
    /** @type {!Array} */
    var text_plain = ["ArgumentsIterator", "ArrayIterator", "MapIterator", "SetIterator"];
    /** @type {string} */
    var context = "wmk";
    /** @type {!Array} */
    var solvedArgs = [];
    var hashedItemStore = getStorage(sessionStorage);
    /** @type {string} */
    var hash = "pxfp";
    var helper = void 0;
    /** @type {!Array} */
    var charListNotLatin = (getTime(), []);
    /** @type {boolean} */
    var Tv = false;
    var bytesIval = void 0;
    /** @type {boolean} */
    var Iv = (factory("Ly9jcy5wZXJpbWV0ZXJ4Lm5ldA"), factory("YXBpLmpz"), false);
    /** @type {number} */
    var firstColLeft = 5;
    /** @type {number} */
    var scrollLeft = 0;
    /** @type {boolean} */
    var _err = false;
    /** @type {boolean} */
    var inside = true;
    /** @type {!Array} */
    var nodeBlackList = ["BUTTON", "DIV", "INPUT", "A", "SELECT", "CHECKBOX", "TEXTAREA", "RADIO", "SPAN", "LI", "UL", "IMG", "OPTION"];
    /** @type {number} */
    var curPrimaryDepth = 5;
    /** @type {number} */
    var maxPrimaryDepth = 0;
    /** @type {boolean} */
    var target = false;
    /** @type {boolean} */
    var uName2 = true;
    var storage = getStorage("localStorage");
    /** @type {string} */
    var usingStream = "PX242";
    /** @type {boolean} */
    var le = false;
    /** @type {null} */
    var lastdrag = null;
    var opts = {
      h : 0,
      w : 0
    };
    var self = {
      handler : initSlider,
      wasDetected : false,
      key : "fsch",
      objectToRegister : function() {
        return window;
      }
    };
    var json = {
      focus : self,
      blur : self,
      resize : {
        handler : scroll,
        wasDetected : false,
        key : "rsz",
        objectToRegister : function() {
          return window;
        }
      },
      visibilitychange : {
        handler : scroll,
        wasDetected : false,
        key : "vzch",
        objectToRegister : function() {
          return window && window.document;
        }
      }
    };
    /** @type {number} */
    var bynum = 5;
    /** @type {number} */
    var tonum = 0;
    /** @type {boolean} */
    var tn = false;
    /** @type {boolean} */
    var zv = true;
    /** @type {boolean} */
    var Jv = false;
    /** @type {!Array} */
    var length = [factory("X19kcml2ZXJfZXZhbHVhdGU="), factory("X193ZWJkcml2ZXJfZXZhbHVhdGU="), factory("X19zZWxlbml1bV9ldmFsdWF0ZQ=="), factory("X19meGRyaXZlcl9ldmFsdWF0ZQ=="), factory("X19kcml2ZXJfdW53cmFwcGVk"), factory("X193ZWJkcml2ZXJfdW53cmFwcGVk"), factory("X19zZWxlbml1bV91bndyYXBwZWQ="), factory("X19meGRyaXZlcl91bndyYXBwZWQ="), factory("X1NlbGVuaXVtX0lERV9SZWNvcmRlcg=="), factory("X3NlbGVuaXVt"), factory("Y2FsbGVkU2VsZW5pdW0="), factory("JGNkY19hc2RqZmxhc3V0b3BmaHZjWkxtY2ZsXw=="), factory("JGNocm9tZV9hc3luY1NjcmlwdEluZm8="), 
    factory("X18kd2ViZHJpdmVyQXN5bmNFeGVjdXRvcg=="), factory("d2ViZHJpdmVy"), factory("X193ZWJkcml2ZXJGdW5j"), factory("ZG9tQXV0b21hdGlvbg=="), factory("ZG9tQXV0b21hdGlvbkNvbnRyb2xsZXI="), factory("X19sYXN0V2F0aXJBbGVydA=="), factory("X19sYXN0V2F0aXJDb25maXJt"), factory("X19sYXN0V2F0aXJQcm9tcHQ="), factory("X193ZWJkcml2ZXJfc2NyaXB0X2Zu"), factory("X1dFQkRSSVZFUl9FTEVNX0NBQ0hF")];
    /** @type {!Array} */
    var _eventQueuedUntilReady = [factory("ZHJpdmVyLWV2YWx1YXRl"), factory("d2ViZHJpdmVyLWV2YWx1YXRl"), factory("c2VsZW5pdW0tZXZhbHVhdGU="), factory("d2ViZHJpdmVyQ29tbWFuZA=="), factory("d2ViZHJpdmVyLWV2YWx1YXRlLXJlc3BvbnNl")];
    /** @type {!Array} */
    var hour = [factory("d2ViZHJpdmVy"), factory("Y2RfZnJhbWVfaWRf")];
    /** @type {number} */
    var LAT = 0;
    /** @type {number} */
    var date = 1;
    var res = {};
    res[LAT] = {};
    res[date] = {};
    var type_plans = {};
    /** @type {number} */
    type_plans[LAT] = 0;
    /** @type {number} */
    type_plans[date] = 0;
    var _newValue = factory("c291cmNlTWFwcGluZ1VSTA==");
    var cnsl = window[factory("TWVkaWFTb3VyY2U=")];
    var ih = (cnsl && cnsl[factory("aXNUeXBlU3VwcG9ydGVk")], factory("Y2FuUGxheVR5cGU="), getValue(), factory("YXVkaW8="), factory("dmlkZW8="), factory("YXVkaW8vbXA0OyBjb2RlY3M9Im1wNGEuNDAuMiI="));
    var ah = (factory("YXVkaW8vbXBlZzs="), factory("YXVkaW8vd2VibTsgY29kZWNzPSJ2b3JiaXMi"), factory("YXVkaW8vb2dnOyBjb2RlY3M9InZvcmJpcyI="), factory("YXVkaW8vd2F2OyBjb2RlY3M9IjEi"), factory("YXVkaW8vb2dnOyBjb2RlY3M9InNwZWV4Ig=="), factory("YXVkaW8vb2dnOyBjb2RlY3M9ImZsYWMi"), factory("YXVkaW8vM2dwcDsgY29kZWNzPSJzYW1yIg=="), factory("dmlkZW8vbXA0OyBjb2RlY3M9ImF2YzEuNDJFMDFFIg=="));
    var outerFmt = factory("dmlkZW8vbXA0OyBjb2RlY3M9ImF2YzEuNDJFMDFFLCBtcDRhLjQwLjIi");
    /** @type {number} */
    var maxNumberOfSuggestions = (factory("dmlkZW8vbXA0OyBjb2RlY3M9ImF2YzEuNThBMDFFIg=="), factory("dmlkZW8vbXA0OyBjb2RlY3M9ImF2YzEuNEQ0MDFFIg=="), factory("dmlkZW8vbXA0OyBjb2RlY3M9ImF2YzEuNjQwMDFFIg=="), factory("dmlkZW8vbXA0OyBjb2RlY3M9Im1wNHYuMjAuOCI="), factory("dmlkZW8vbXA0OyBjb2RlY3M9Im1wNHYuMjAuMjQwIg=="), factory("dmlkZW8vd2VibTsgY29kZWNzPSJ2cDgi"), factory("dmlkZW8vb2dnOyBjb2RlY3M9InRoZW9yYSI="), factory("dmlkZW8vb2dnOyBjb2RlY3M9ImRpcmFjIg=="), factory("dmlkZW8vM2dwcDsgY29kZWNzPSJtcDR2LjIwLjgi"), 
    factory("dmlkZW8veC1tYXRyb3NrYTsgY29kZWNzPSJ0aGVvcmEi"), window[factory("c3BlZWNoU3ludGhlc2lz")] || window[factory("d2Via2l0U3BlZWNoU3ludGhlc2lz")] || window[factory("bW96U3BlZWNoU3ludGhlc2lz")] || window[factory("b1NwZWVjaFN5bnRoZXNpcw==")] || window[factory("bXNTcGVlY2hTeW50aGVzaXM=")], factory("Z2V0Vm9pY2Vz"), factory("dm9pY2VVUkk="), factory("bGFuZw=="), factory("bmFtZQ=="), factory("bG9jYWxTZXJ2aWNl"), factory("ZGVmYXVsdA=="), factory("b252b2ljZXNjaGFuZ2Vk"), getValue(), apply(5), window[factory("bmF2aWdhdG9y")], 
    getStorage("localStorage"), 2);
    /** @type {!Array} */
    var testcase = [];
    /** @type {boolean} */
    var eventName = false;
    /** @type {boolean} */
    var lh = true;
    /** @type {!Array} */
    var result = [];
    /** @type {!Array} */
    var collection = [];
    /** @type {number} */
    var antiFlood = 700;
    /** @type {number} */
    var WAITING_SECONDS = 200;
    /** @type {number} */
    var numberOfColumns = 5E3;
    /** @type {boolean} */
    var lastTouchStretch = false;
    /** @type {boolean} */
    var cycle = false;
    /** @type {boolean} */
    var shouldAvoid = false;
    /** @type {boolean} */
    var wh = false;
    /** @type {null} */
    var c = null;
    if (function() {
      return !window[property];
    }()) {
      (function() {
        $("PX500");
        dr((new Date).getTime());
        var key = String();
        lastTouchStretch = getLastTouchStretch(true);
        cycle = collect(false);
        window[property] = plugin;
        if (key === property) {
          window.PX = plugin;
        }
        has(key, plugin);
        registerLocalShortcut(key);
        pusherInstance.subscribe("PX761", function() {
          setTimeout(setTrailViewOffset, 0);
        });
        _isFrame();
        setStaticFilesRootRegExp();
        me.trigger("uid", value);
        push("PX500");
      })();
    }
  }();
} catch (ex) {
  /** @type {string} */
  (new Image).src = "https://collector-a.perimeterx.net/api/v2/collector/clientError?r=" + encodeURIComponent('{"appId":"' + (window._pxAppId || "") + '","tag":"v5.6.1","name":"' + ex.name + '","line":"' + (ex.lineNumber || ex.line) + '","script":"' + (ex.fileName || ex.sourceURL || ex.script) + '","stack":"' + (ex.stackTrace || ex.stack || "").replace(/"/g, '"') + '","message":"' + (ex.message || "").replace(/"/g, '"') + '"}');
}
;



© 2020 Quttera Ltd. All rights reserved.