API tools faq
paste
Advertisement
spamreports

Steam phishi?

spamreports
Jan 11th, 2021
1,689
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 221.87 KB | None | 0 0
raw download clone embed print report
  1. ##view-source:https://logiem.com/aeefb6c.js
  2.  
  3. 'use strict';
  4. !function(global, factory) {
  5.   if ("object" == typeof module && "object" == typeof module.exports) {
  6.     module.exports = global.document ? factory(global, true) : function(global) {
  7.       if (!global.document) {
  8.         throw new Error("jQuery requires a window with a document");
  9.       }
  10.       return factory(global);
  11.     };
  12.   } else {
  13.     factory(global);
  14.   }
  15. }("undefined" != typeof window ? window : this, function(window, start_column) {
  16.   /**
  17.    * @param {string} value
  18.    * @param {!Object} context
  19.    * @param {!Object} doc
  20.    * @return {undefined}
  21.    */
  22.   function cb(value, context, doc) {
  23.     var key;
  24.     var imgSrcset;
  25.     var element = (doc = doc || document).createElement("script");
  26.     if (element.text = value, context) {
  27.       for (key in obj) {
  28.         if (imgSrcset = context[key] || context.getAttribute && context.getAttribute(key)) {
  29.           element.setAttribute(key, imgSrcset);
  30.         }
  31.       }
  32.     }
  33.     doc.head.appendChild(element).parentNode.removeChild(element);
  34.   }
  35.   /**
  36.    * @param {string} value
  37.    * @return {?}
  38.    */
  39.   function type(value) {
  40.     return null == value ? value + "" : "object" == typeof value || "function" == typeof value ? class2type[toString.call(value)] || "object" : typeof value;
  41.   }
  42.   /**
  43.    * @param {!Object} obj
  44.    * @return {?}
  45.    */
  46.   function isArrayLike(obj) {
  47.     var length = !!obj && "length" in obj && obj.length;
  48.     var ltype = type(obj);
  49.     return !fn(obj) && !isWindow(obj) && ("array" === ltype || 0 === length || "number" == typeof length && 0 < length && length - 1 in obj);
  50.   }
  51.   /**
  52.    * @param {!Object} name
  53.    * @param {!Object} type
  54.    * @return {?}
  55.    */
  56.   function callback(name, type) {
  57.     return name.nodeName && name.nodeName.toLowerCase() === type.toLowerCase();
  58.   }
  59.   /**
  60.    * @param {!Array} key
  61.    * @param {!Object} value
  62.    * @param {boolean} not
  63.    * @return {?}
  64.    */
  65.   function filter(key, value, not) {
  66.     return fn(value) ? jQuery.grep(key, function(context, i) {
  67.       return !!value.call(context, i, context) !== not;
  68.     }) : value.nodeType ? jQuery.grep(key, function(elem) {
  69.       return elem === value !== not;
  70.     }) : "string" != typeof value ? jQuery.grep(key, function(name) {
  71.       return -1 < indexOf.call(value, name) !== not;
  72.     }) : jQuery.filter(value, key, not);
  73.   }
  74.   /**
  75.    * @param {(Array|Element)} cur
  76.    * @param {number} dir
  77.    * @return {?}
  78.    */
  79.   function sibling(cur, dir) {
  80.     for (; (cur = cur[dir]) && 1 !== cur.nodeType;) {
  81.     }
  82.     return cur;
  83.   }
  84.   /**
  85.    * @param {?} expPair
  86.    * @return {?}
  87.    */
  88.   function failed(expPair) {
  89.     return expPair;
  90.   }
  91.   /**
  92.    * @param {?} name
  93.    * @return {?}
  94.    */
  95.   function data(name) {
  96.     throw name;
  97.   }
  98.   /**
  99.    * @param {!Object} data
  100.    * @param {!Function} path
  101.    * @param {!Function} callback
  102.    * @param {boolean} args
  103.    * @return {undefined}
  104.    */
  105.   function resolve(data, path, callback, args) {
  106.     var error;
  107.     try {
  108.       if (data && fn(error = data.promise)) {
  109.         error.call(data).done(path).fail(callback);
  110.       } else {
  111.         if (data && fn(error = data.then)) {
  112.           error.call(data, path, callback);
  113.         } else {
  114.           path.apply(void 0, [data].slice(args));
  115.         }
  116.       }
  117.     } catch (success) {
  118.       callback.apply(void 0, [success]);
  119.     }
  120.   }
  121.   /**
  122.    * @return {undefined}
  123.    */
  124.   function $__jsx_onload() {
  125.     document.removeEventListener("DOMContentLoaded", $__jsx_onload);
  126.     window.removeEventListener("load", $__jsx_onload);
  127.     jQuery.ready();
  128.   }
  129.   /**
  130.    * @param {?} context
  131.    * @param {string} match
  132.    * @return {?}
  133.    */
  134.   function dashToCapital(context, match) {
  135.     return match.toUpperCase();
  136.   }
  137.   /**
  138.    * @param {!Object} str
  139.    * @return {?}
  140.    */
  141.   function camelCase(str) {
  142.     return str.replace(_kerningNamesHash_escapeEscape, "ms-").replace(rcharset, dashToCapital);
  143.   }
  144.   /**
  145.    * @return {undefined}
  146.    */
  147.   function Data() {
  148.     this.expando = jQuery.expando + Data.uid++;
  149.   }
  150.   /**
  151.    * @param {!Object} elem
  152.    * @param {!Object} name
  153.    * @param {?} json
  154.    * @return {?}
  155.    */
  156.   function func(elem, name, json) {
  157.     var key;
  158.     var value;
  159.     if (void 0 === json && 1 === elem.nodeType) {
  160.       if (key = "data-" + name.replace(dashExpr, "-$&").toLowerCase(), "string" == typeof(json = elem.getAttribute(key))) {
  161.         try {
  162.           /** @type {*} */
  163.           json = "true" === (value = json) || "false" !== value && ("null" === value ? null : value === +value + "" ? +value : contribRegex.test(value) ? JSON.parse(value) : value);
  164.         } catch (e) {
  165.         }
  166.         self.set(elem, name, json);
  167.       } else {
  168.         json = void 0;
  169.       }
  170.     }
  171.     return json;
  172.   }
  173.   /**
  174.    * @param {string} elem
  175.    * @param {string} prop
  176.    * @param {string} valueParts
  177.    * @param {!Object} tween
  178.    * @return {?}
  179.    */
  180.   function adjustCSS(elem, prop, valueParts, tween) {
  181.     var adjusted;
  182.     var scale;
  183.     /** @type {number} */
  184.     var a = 20;
  185.     /** @type {function(): ?} */
  186.     var currentValue = tween ? function() {
  187.       return tween.cur();
  188.     } : function() {
  189.       return jQuery.css(elem, prop, "");
  190.     };
  191.     var initial = currentValue();
  192.     var unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px");
  193.     var initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || "px" !== unit && +initial) && regex.exec(jQuery.css(elem, prop));
  194.     if (initialInUnit && initialInUnit[3] !== unit) {
  195.       /** @type {number} */
  196.       initial = initial / 2;
  197.       unit = unit || initialInUnit[3];
  198.       /** @type {number} */
  199.       initialInUnit = +initial || 1;
  200.       for (; a--;) {
  201.         jQuery.style(elem, prop, initialInUnit + unit);
  202.         if ((1 - scale) * (1 - (scale = currentValue() / initial || .5)) <= 0) {
  203.           /** @type {number} */
  204.           a = 0;
  205.         }
  206.         /** @type {number} */
  207.         initialInUnit = initialInUnit / scale;
  208.       }
  209.       /** @type {number} */
  210.       initialInUnit = initialInUnit * 2;
  211.       jQuery.style(elem, prop, initialInUnit + unit);
  212.       valueParts = valueParts || [];
  213.     }
  214.     return valueParts && (initialInUnit = +initialInUnit || +initial || 0, adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2], tween && (tween.unit = unit, tween.start = initialInUnit, tween.end = adjusted)), adjusted;
  215.   }
  216.   /**
  217.    * @param {!Array} result
  218.    * @param {boolean} e
  219.    * @return {?}
  220.    */
  221.   function show(result, e) {
  222.     var size;
  223.     var elem;
  224.     var element;
  225.     var node;
  226.     var parent;
  227.     var tagName;
  228.     var display;
  229.     /** @type {!Array} */
  230.     var values = [];
  231.     /** @type {number} */
  232.     var i = 0;
  233.     var inlineCount = result.length;
  234.     for (; i < inlineCount; i++) {
  235.       if ((elem = result[i]).style) {
  236.         size = elem.style.display;
  237.         if (e) {
  238.           if ("none" === size) {
  239.             values[i] = dataPriv.get(elem, "display") || null;
  240.             if (!values[i]) {
  241.               /** @type {string} */
  242.               elem.style.display = "";
  243.             }
  244.           }
  245.           if ("" === elem.style.display && isHidden(elem)) {
  246.             values[i] = (display = parent = node = void 0, parent = (element = elem).ownerDocument, tagName = element.nodeName, (display = elemdisplay[tagName]) || (node = parent.body.appendChild(parent.createElement(tagName)), display = jQuery.css(node, "display"), node.parentNode.removeChild(node), "none" === display && (display = "block"), elemdisplay[tagName] = display));
  247.           }
  248.         } else {
  249.           if ("none" !== size) {
  250.             /** @type {string} */
  251.             values[i] = "none";
  252.             dataPriv.set(elem, "display", size);
  253.           }
  254.         }
  255.       }
  256.     }
  257.     /** @type {number} */
  258.     i = 0;
  259.     for (; i < inlineCount; i++) {
  260.       if (null != values[i]) {
  261.         result[i].style.display = values[i];
  262.       }
  263.     }
  264.     return result;
  265.   }
  266.   /**
  267.    * @param {!Object} context
  268.    * @param {number} tag
  269.    * @return {?}
  270.    */
  271.   function getAll(context, tag) {
  272.     var n;
  273.     return n = "undefined" != typeof context.getElementsByTagName ? context.getElementsByTagName(tag || "*") : "undefined" != typeof context.querySelectorAll ? context.querySelectorAll(tag || "*") : [], void 0 === tag || tag && callback(context, tag) ? jQuery.merge([context], n) : n;
  274.   }
  275.   /**
  276.    * @param {number} elems
  277.    * @param {!NodeList} refElements
  278.    * @return {undefined}
  279.    */
  280.   function setGlobalEval(elems, refElements) {
  281.     /** @type {number} */
  282.     var i = 0;
  283.     var length = elems.length;
  284.     for (; i < length; i++) {
  285.       dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
  286.     }
  287.   }
  288.   /**
  289.    * @param {!Array} elems
  290.    * @param {!Object} context
  291.    * @param {!Array} result
  292.    * @param {!Object} element
  293.    * @param {string} ignored
  294.    * @return {?}
  295.    */
  296.   function buildFragment(elems, context, result, element, ignored) {
  297.     var elem;
  298.     var tmp;
  299.     var tag;
  300.     var wrap;
  301.     var parent;
  302.     var j;
  303.     var fragment = context.createDocumentFragment();
  304.     /** @type {!Array} */
  305.     var results = [];
  306.     /** @type {number} */
  307.     var i = 0;
  308.     var length = elems.length;
  309.     for (; i < length; i++) {
  310.       if ((elem = elems[i]) || 0 === elem) {
  311.         if ("object" === type(elem)) {
  312.           jQuery.merge(results, elem.nodeType ? [elem] : elem);
  313.         } else {
  314.           if (re_commas.test(elem)) {
  315.             tmp = tmp || fragment.appendChild(context.createElement("div"));
  316.             tag = (me.exec(elem) || ["", ""])[1].toLowerCase();
  317.             wrap = wrapMap[tag] || wrapMap._default;
  318.             tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
  319.             j = wrap[0];
  320.             for (; j--;) {
  321.               tmp = tmp.lastChild;
  322.             }
  323.             jQuery.merge(results, tmp.childNodes);
  324.             /** @type {string} */
  325.             (tmp = fragment.firstChild).textContent = "";
  326.           } else {
  327.             results.push(context.createTextNode(elem));
  328.           }
  329.         }
  330.       }
  331.     }
  332.     /** @type {string} */
  333.     fragment.textContent = "";
  334.     /** @type {number} */
  335.     i = 0;
  336.     for (; elem = results[i++];) {
  337.       if (element && -1 < jQuery.inArray(elem, element)) {
  338.         if (ignored) {
  339.           ignored.push(elem);
  340.         }
  341.       } else {
  342.         if (parent = test(elem), tmp = getAll(fragment.appendChild(elem), "script"), parent && setGlobalEval(tmp), result) {
  343.           /** @type {number} */
  344.           j = 0;
  345.           for (; elem = tmp[j++];) {
  346.             if (opacityRe.test(elem.type || "")) {
  347.               result.push(elem);
  348.             }
  349.           }
  350.         }
  351.       }
  352.     }
  353.     return fragment;
  354.   }
  355.   /**
  356.    * @return {?}
  357.    */
  358.   function returnTrue() {
  359.     return true;
  360.   }
  361.   /**
  362.    * @return {?}
  363.    */
  364.   function returnFalse() {
  365.     return false;
  366.   }
  367.   /**
  368.    * @param {?} event
  369.    * @param {string} data
  370.    * @return {?}
  371.    */
  372.   function raw(event, data) {
  373.     return event === function() {
  374.       try {
  375.         return document.activeElement;
  376.       } catch (e) {
  377.       }
  378.     }() == ("focus" === data);
  379.   }
  380.   /**
  381.    * @param {!Object} code
  382.    * @param {!Object} obj
  383.    * @param {!Object} callback
  384.    * @param {!Object} type
  385.    * @param {!Object} handler
  386.    * @param {number} next
  387.    * @return {?}
  388.    */
  389.   function get(code, obj, callback, type, handler, next) {
  390.     var fn;
  391.     var key;
  392.     if ("object" == typeof obj) {
  393.       for (key in "string" != typeof callback && (type = type || callback, callback = void 0), obj) {
  394.         get(code, key, callback, type, obj[key], next);
  395.       }
  396.       return code;
  397.     }
  398.     if (null == type && null == handler ? (handler = callback, type = callback = void 0) : null == handler && ("string" == typeof callback ? (handler = type, type = void 0) : (handler = type, type = callback, callback = void 0)), false === handler) {
  399.       /** @type {function(): ?} */
  400.       handler = returnFalse;
  401.     } else {
  402.       if (!handler) {
  403.         return code;
  404.       }
  405.     }
  406.     return 1 === next && (fn = handler, (handler = function(type) {
  407.       return jQuery().off(type), fn.apply(this, arguments);
  408.     }).guid = fn.guid || (fn.guid = jQuery.guid++)), code.each(function() {
  409.       jQuery.event.add(this, obj, handler, type, callback);
  410.     });
  411.   }
  412.   /**
  413.    * @param {undefined} elem
  414.    * @param {string} type
  415.    * @param {!Function} handler
  416.    * @return {undefined}
  417.    */
  418.   function handler(elem, type, handler) {
  419.     if (handler) {
  420.       dataPriv.set(elem, type, false);
  421.       jQuery.event.add(elem, type, {
  422.         namespace : false,
  423.         handler : function(event) {
  424.           var promise;
  425.           var attr;
  426.           var data = dataPriv.get(this, type);
  427.           if (1 & event.isTrigger && this[type]) {
  428.             if (data.length) {
  429.               if ((jQuery.event.special[type] || {}).delegateType) {
  430.                 event.stopPropagation();
  431.               }
  432.             } else {
  433.               if (data = slice.call(arguments), dataPriv.set(this, type, data), promise = handler(this, type), this[type](), data !== (attr = dataPriv.get(this, type)) || promise ? dataPriv.set(this, type, false) : attr = {}, data !== attr) {
  434.                 return event.stopImmediatePropagation(), event.preventDefault(), attr.value;
  435.               }
  436.             }
  437.           } else {
  438.             if (data.length) {
  439.               dataPriv.set(this, type, {
  440.                 value : jQuery.event.trigger(jQuery.extend(data[0], jQuery.Event.prototype), data.slice(1), this)
  441.               });
  442.               event.stopImmediatePropagation();
  443.             }
  444.           }
  445.         }
  446.       });
  447.     } else {
  448.       if (void 0 === dataPriv.get(elem, type)) {
  449.         jQuery.event.add(elem, type, returnTrue);
  450.       }
  451.     }
  452.   }
  453.   /**
  454.    * @param {undefined} elem
  455.    * @param {!Object} content
  456.    * @return {?}
  457.    */
  458.   function manipulationTarget(elem, content) {
  459.     return callback(elem, "table") && callback(11 !== content.nodeType ? content : content.firstChild, "tr") && jQuery(elem).children("tbody")[0] || elem;
  460.   }
  461.   /**
  462.    * @param {!Element} s
  463.    * @return {?}
  464.    */
  465.   function v(s) {
  466.     return s.type = (null !== s.getAttribute("type")) + "/" + s.type, s;
  467.   }
  468.   /**
  469.    * @param {!Object} e
  470.    * @return {?}
  471.    */
  472.   function createGeneNameGenomicState(e) {
  473.     return "true/" === (e.type || "").slice(0, 5) ? e.type = e.type.slice(5) : e.removeAttribute("type"), e;
  474.   }
  475.   /**
  476.    * @param {string} node
  477.    * @param {!Object} elem
  478.    * @return {undefined}
  479.    */
  480.   function cloneCopyEvent(node, elem) {
  481.     var i;
  482.     var tableslen;
  483.     var type;
  484.     var b;
  485.     var data;
  486.     var events;
  487.     if (1 === elem.nodeType) {
  488.       if (dataPriv.hasData(node) && (events = dataPriv.get(node).events)) {
  489.         for (type in dataPriv.remove(elem, "handle events"), events) {
  490.           /** @type {number} */
  491.           i = 0;
  492.           tableslen = events[type].length;
  493.           for (; i < tableslen; i++) {
  494.             jQuery.event.add(elem, type, events[type][i]);
  495.           }
  496.         }
  497.       }
  498.       if (self.hasData(node)) {
  499.         b = self.access(node);
  500.         data = jQuery.extend({}, b);
  501.         self.set(elem, data);
  502.       }
  503.     }
  504.   }
  505.   /**
  506.    * @param {!Object} collection
  507.    * @param {!Array} args
  508.    * @param {!Function} callback
  509.    * @param {string} ignored
  510.    * @return {?}
  511.    */
  512.   function domManip(collection, args, callback, ignored) {
  513.     args = map(args);
  514.     var fragment;
  515.     var first;
  516.     var a;
  517.     var tableslen;
  518.     var node;
  519.     var context;
  520.     /** @type {number} */
  521.     var i = 0;
  522.     var totalItems = collection.length;
  523.     /** @type {number} */
  524.     var minimumIdx = totalItems - 1;
  525.     var str = args[0];
  526.     var ret = fn(str);
  527.     if (ret || 1 < totalItems && "string" == typeof str && !support.checkClone && partten.test(str)) {
  528.       return collection.each(function(index) {
  529.         var self = collection.eq(index);
  530.         if (ret) {
  531.           args[0] = str.call(this, index, self.html());
  532.         }
  533.         domManip(self, args, callback, ignored);
  534.       });
  535.     }
  536.     if (totalItems && (first = (fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored)).firstChild, 1 === fragment.childNodes.length && (fragment = first), first || ignored)) {
  537.       tableslen = (a = jQuery.map(getAll(fragment, "script"), v)).length;
  538.       for (; i < totalItems; i++) {
  539.         node = fragment;
  540.         if (i !== minimumIdx) {
  541.           node = jQuery.clone(node, true, true);
  542.           if (tableslen) {
  543.             jQuery.merge(a, getAll(node, "script"));
  544.           }
  545.         }
  546.         callback.call(collection[i], node, i);
  547.       }
  548.       if (tableslen) {
  549.         context = a[a.length - 1].ownerDocument;
  550.         jQuery.map(a, createGeneNameGenomicState);
  551.         /** @type {number} */
  552.         i = 0;
  553.         for (; i < tableslen; i++) {
  554.           node = a[i];
  555.           if (opacityRe.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(context, node)) {
  556.             if (node.src && "module" !== (node.type || "").toLowerCase()) {
  557.               if (jQuery._evalUrl && !node.noModule) {
  558.                 jQuery._evalUrl(node.src, {
  559.                   nonce : node.nonce || node.getAttribute("nonce")
  560.                 }, context);
  561.               }
  562.             } else {
  563.               cb(node.textContent.replace(query, ""), node, context);
  564.             }
  565.           }
  566.         }
  567.       }
  568.     }
  569.     return collection;
  570.   }
  571.   /**
  572.    * @param {?} val
  573.    * @param {boolean} fn
  574.    * @param {string} table
  575.    * @return {?}
  576.    */
  577.   function remove(val, fn, table) {
  578.     var elem;
  579.     var value = fn ? jQuery.filter(fn, val) : val;
  580.     /** @type {number} */
  581.     var name = 0;
  582.     for (; null != (elem = value[name]); name++) {
  583.       if (!(table || 1 !== elem.nodeType)) {
  584.         jQuery.cleanData(getAll(elem));
  585.       }
  586.       if (elem.parentNode) {
  587.         if (table && test(elem)) {
  588.           setGlobalEval(getAll(elem, "script"));
  589.         }
  590.         elem.parentNode.removeChild(elem);
  591.       }
  592.     }
  593.     return val;
  594.   }
  595.   /**
  596.    * @param {!Object} elem
  597.    * @param {string} name
  598.    * @param {!Object} computed
  599.    * @return {?}
  600.    */
  601.   function curCSS(elem, name, computed) {
  602.     var minWidth;
  603.     var width;
  604.     var maxWidth;
  605.     var ret;
  606.     var style = elem.style;
  607.     return (computed = computed || getStyles(elem)) && ("" !== (ret = computed.getPropertyValue(name) || computed[name]) || test(elem) || (ret = jQuery.style(elem, name)), !support.pixelBoxStyles() && rnumnonpx.test(ret) && inlineAttributeCommentRegex.test(name) && (minWidth = style.width, width = style.minWidth, maxWidth = style.maxWidth, style.minWidth = style.maxWidth = style.width = ret, ret = computed.width, style.width = minWidth, style.minWidth = width, style.maxWidth = maxWidth)), void 0 !==
  608.     ret ? ret + "" : ret;
  609.   }
  610.   /**
  611.    * @param {?} conditionFn
  612.    * @param {!Function} hookFn
  613.    * @return {?}
  614.    */
  615.   function addGetHookIf(conditionFn, hookFn) {
  616.     return {
  617.       get : function() {
  618.         if (!conditionFn()) {
  619.           return (this.get = hookFn).apply(this, arguments);
  620.         }
  621.         delete this.get;
  622.       }
  623.     };
  624.   }
  625.   /**
  626.    * @param {string} name
  627.    * @return {?}
  628.    */
  629.   function camelize(name) {
  630.     var nameField = jQuery.cssProps[name] || aSupports[name];
  631.     return nameField || (name in testStyle ? name : aSupports[name] = function(p) {
  632.       var prop = p[0].toUpperCase() + p.slice(1);
  633.       /** @type {number} */
  634.       var i = prefixes.length;
  635.       for (; i--;) {
  636.         if ((p = prefixes[i] + prop) in testStyle) {
  637.           return p;
  638.         }
  639.       }
  640.     }(name) || name);
  641.   }
  642.   /**
  643.    * @param {!Object} value
  644.    * @param {!Object} key
  645.    * @param {string} type
  646.    * @return {?}
  647.    */
  648.   function _set(value, key, type) {
  649.     /** @type {(Array<string>|null)} */
  650.     var matches = regex.exec(key);
  651.     return matches ? Math.max(0, matches[2] - (type || 0)) + (matches[3] || "px") : key;
  652.   }
  653.   /**
  654.    * @param {!Object} elem
  655.    * @param {string} name
  656.    * @param {string} extra
  657.    * @param {boolean} isBorderBox
  658.    * @param {!Object} styles
  659.    * @param {number} themeName
  660.    * @return {?}
  661.    */
  662.   function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles, themeName) {
  663.     /** @type {number} */
  664.     var i = "width" === name ? 1 : 0;
  665.     /** @type {number} */
  666.     var value = 0;
  667.     /** @type {number} */
  668.     var val = 0;
  669.     if (extra === (isBorderBox ? "border" : "content")) {
  670.       return 0;
  671.     }
  672.     for (; i < 4; i = i + 2) {
  673.       if ("margin" === extra) {
  674.         val = val + jQuery.css(elem, extra + cssExpand[i], true, styles);
  675.       }
  676.       if (isBorderBox) {
  677.         if ("content" === extra) {
  678.           /** @type {number} */
  679.           val = val - jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  680.         }
  681.         if ("margin" !== extra) {
  682.           /** @type {number} */
  683.           val = val - jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  684.         }
  685.       } else {
  686.         val = val + jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  687.         if ("padding" !== extra) {
  688.           val = val + jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  689.         } else {
  690.           value = value + jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  691.         }
  692.       }
  693.     }
  694.     return !isBorderBox && 0 <= themeName && (val = val + (Math.max(0, Math.ceil(elem["offset" + name[0].toUpperCase() + name.slice(1)] - themeName - val - value - .5)) || 0)), val;
  695.   }
  696.   /**
  697.    * @param {!Element} elem
  698.    * @param {string} name
  699.    * @param {!Object} extra
  700.    * @return {?}
  701.    */
  702.   function load(elem, name, extra) {
  703.     var styles = getStyles(elem);
  704.     var isBorderBox = (!support.boxSizingReliable() || extra) && "border-box" === jQuery.css(elem, "boxSizing", false, styles);
  705.     var valueIsBorderBox = isBorderBox;
  706.     var value = curCSS(elem, name, styles);
  707.     var prop = "offset" + name[0].toUpperCase() + name.slice(1);
  708.     if (rnumnonpx.test(value)) {
  709.       if (!extra) {
  710.         return value;
  711.       }
  712.       /** @type {string} */
  713.       value = "auto";
  714.     }
  715.     return (!support.boxSizingReliable() && isBorderBox || !support.reliableTrDimensions() && callback(elem, "tr") || "auto" === value || !parseFloat(value) && "inline" === jQuery.css(elem, "display", false, styles)) && elem.getClientRects().length && (isBorderBox = "border-box" === jQuery.css(elem, "boxSizing", false, styles), (valueIsBorderBox = prop in elem) && (value = elem[prop])), (value = parseFloat(value) || 0) + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"),
  716.     valueIsBorderBox, styles, value) + "px";
  717.   }
  718.   /**
  719.    * @param {!Array} type
  720.    * @param {!Function} context
  721.    * @param {string} object
  722.    * @param {string} end
  723.    * @param {number} easing
  724.    * @return {?}
  725.    */
  726.   function Tween(type, context, object, end, easing) {
  727.     return new Tween.prototype.init(type, context, object, end, easing);
  728.   }
  729.   /**
  730.    * @return {undefined}
  731.    */
  732.   function step() {
  733.     if (nt) {
  734.       if (false === document.hidden && window.requestAnimationFrame) {
  735.         window.requestAnimationFrame(step);
  736.       } else {
  737.         window.setTimeout(step, jQuery.fx.interval);
  738.       }
  739.       jQuery.fx.tick();
  740.     }
  741.   }
  742.   /**
  743.    * @return {?}
  744.    */
  745.   function createFxNow() {
  746.     return window.setTimeout(function() {
  747.       fxNow = void 0;
  748.     }), fxNow = Date.now();
  749.   }
  750.   /**
  751.    * @param {string} type
  752.    * @param {number} includeWidth
  753.    * @return {?}
  754.    */
  755.   function genFx(type, includeWidth) {
  756.     var which;
  757.     /** @type {number} */
  758.     var i = 0;
  759.     var attrs = {
  760.       height : type
  761.     };
  762.     /** @type {number} */
  763.     includeWidth = includeWidth ? 1 : 0;
  764.     for (; i < 4; i = i + (2 - includeWidth)) {
  765.       attrs["margin" + (which = cssExpand[i])] = attrs["padding" + which] = type;
  766.     }
  767.     return includeWidth && (attrs.opacity = attrs.width = type), attrs;
  768.   }
  769.   /**
  770.    * @param {?} value
  771.    * @param {string} prop
  772.    * @param {?} animation
  773.    * @return {?}
  774.    */
  775.   function createTween(value, prop, animation) {
  776.     var tween;
  777.     var args = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]);
  778.     /** @type {number} */
  779.     var i = 0;
  780.     var az = args.length;
  781.     for (; i < az; i++) {
  782.       if (tween = args[i].call(animation, prop, value)) {
  783.         return tween;
  784.       }
  785.     }
  786.   }
  787.   /**
  788.    * @param {!Object} elem
  789.    * @param {?} properties
  790.    * @param {!Object} options
  791.    * @return {?}
  792.    */
  793.   function Animation(elem, properties, options) {
  794.     var result;
  795.     var a;
  796.     /** @type {number} */
  797.     var index = 0;
  798.     var ncells = Animation.prefilters.length;
  799.     var deferred = jQuery.Deferred().always(function() {
  800.       delete tick.elem;
  801.     });
  802.     /**
  803.      * @return {?}
  804.      */
  805.     var tick = function() {
  806.       if (a) {
  807.         return false;
  808.       }
  809.       var currentTime = fxNow || createFxNow();
  810.       /** @type {number} */
  811.       var remaining = Math.max(0, animation.startTime + animation.duration - currentTime);
  812.       /** @type {number} */
  813.       var percent = 1 - (remaining / animation.duration || 0);
  814.       /** @type {number} */
  815.       var i = 0;
  816.       var length = animation.tweens.length;
  817.       for (; i < length; i++) {
  818.         animation.tweens[i].run(percent);
  819.       }
  820.       return deferred.notifyWith(elem, [animation, percent, remaining]), percent < 1 && length ? remaining : (length || deferred.notifyWith(elem, [animation, 1, 0]), deferred.resolveWith(elem, [animation]), false);
  821.     };
  822.     var animation = deferred.promise({
  823.       elem : elem,
  824.       props : jQuery.extend({}, properties),
  825.       opts : jQuery.extend(true, {
  826.         specialEasing : {},
  827.         easing : jQuery.easing._default
  828.       }, options),
  829.       originalProperties : properties,
  830.       originalOptions : options,
  831.       startTime : fxNow || createFxNow(),
  832.       duration : options.duration,
  833.       tweens : [],
  834.       createTween : function(prop, end) {
  835.         var result = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
  836.         return animation.tweens.push(result), result;
  837.       },
  838.       stop : function(value) {
  839.         /** @type {number} */
  840.         var i = 0;
  841.         var mid = value ? animation.tweens.length : 0;
  842.         if (a) {
  843.           return this;
  844.         }
  845.         /** @type {boolean} */
  846.         a = true;
  847.         for (; i < mid; i++) {
  848.           animation.tweens[i].run(1);
  849.         }
  850.         return value ? (deferred.notifyWith(elem, [animation, 1, 0]), deferred.resolveWith(elem, [animation, value])) : deferred.rejectWith(elem, [animation, value]), this;
  851.       }
  852.     });
  853.     var props = animation.props;
  854.     !function(res, object) {
  855.       var key;
  856.       var name;
  857.       var value;
  858.       var obj;
  859.       var hooks;
  860.       for (key in res) {
  861.         if (value = object[name = camelCase(key)], obj = res[key], Array.isArray(obj) && (value = obj[1], obj = res[key] = obj[0]), key !== name && (res[name] = obj, delete res[key]), (hooks = jQuery.cssHooks[name]) && "expand" in hooks) {
  862.           for (key in obj = hooks.expand(obj), delete res[name], obj) {
  863.             if (!(key in res)) {
  864.               res[key] = obj[key];
  865.               object[key] = value;
  866.             }
  867.           }
  868.         } else {
  869.           object[name] = value;
  870.         }
  871.       }
  872.     }(props, animation.opts.specialEasing);
  873.     for (; index < ncells; index++) {
  874.       if (result = Animation.prefilters[index].call(animation, elem, props, animation.opts)) {
  875.         return fn(result.stop) && (jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result)), result;
  876.       }
  877.     }
  878.     return jQuery.map(props, createTween, animation), fn(animation.opts.start) && animation.opts.start.call(elem, animation), animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always), jQuery.fx.timer(jQuery.extend(tick, {
  879.       elem : elem,
  880.       anim : animation,
  881.       queue : animation.opts.queue
  882.     })), animation;
  883.   }
  884.   /**
  885.    * @param {string} b
  886.    * @return {?}
  887.    */
  888.   function merge(b) {
  889.     return (b.match(re) || []).join(" ");
  890.   }
  891.   /**
  892.    * @param {!Node} el
  893.    * @return {?}
  894.    */
  895.   function $(el) {
  896.     return el.getAttribute && el.getAttribute("class") || "";
  897.   }
  898.   /**
  899.    * @param {string} value
  900.    * @return {?}
  901.    */
  902.   function clean(value) {
  903.     return Array.isArray(value) ? value : "string" == typeof value && value.match(re) || [];
  904.   }
  905.   /**
  906.    * @param {string} url
  907.    * @param {!Array} a
  908.    * @param {string} text
  909.    * @param {!Function} f
  910.    * @return {undefined}
  911.    */
  912.   function set(url, a, text, f) {
  913.     var key;
  914.     if (Array.isArray(a)) {
  915.       jQuery.each(a, function(callback_key, response) {
  916.         if (text || reIsFile.test(url)) {
  917.           f(url, response);
  918.         } else {
  919.           set(url + "[" + ("object" == typeof response && null != response ? callback_key : "") + "]", response, text, f);
  920.         }
  921.       });
  922.     } else {
  923.       if (text || "object" !== type(a)) {
  924.         f(url, a);
  925.       } else {
  926.         for (key in a) {
  927.           set(url + "[" + key + "]", a[key], text, f);
  928.         }
  929.       }
  930.     }
  931.   }
  932.   /**
  933.    * @param {!Object} structure
  934.    * @return {?}
  935.    */
  936.   function addToPrefiltersOrTransports(structure) {
  937.     return function(val, t) {
  938.       if ("string" != typeof val) {
  939.         /** @type {string} */
  940.         t = val;
  941.         /** @type {string} */
  942.         val = "*";
  943.       }
  944.       var type;
  945.       /** @type {number} */
  946.       var c = 0;
  947.       var replies = val.toLowerCase().match(re) || [];
  948.       if (fn(t)) {
  949.         for (; type = replies[c++];) {
  950.           if ("+" === type[0]) {
  951.             type = type.slice(1) || "*";
  952.             (structure[type] = structure[type] || []).unshift(t);
  953.           } else {
  954.             (structure[type] = structure[type] || []).push(t);
  955.           }
  956.         }
  957.       }
  958.     };
  959.   }
  960.   /**
  961.    * @param {!Object} structure
  962.    * @param {?} options
  963.    * @param {!Object} originalOptions
  964.    * @param {?} jqXHR
  965.    * @return {?}
  966.    */
  967.   function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
  968.     /**
  969.      * @param {string} type
  970.      * @return {?}
  971.      */
  972.     function inspect(type) {
  973.       var selected;
  974.       return nodedescriptions[type] = true, jQuery.each(structure[type] || [], function(canCreateDiscussions, prefilterOrFactory) {
  975.         var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
  976.         return "string" != typeof dataTypeOrTransport || seekingTransport || nodedescriptions[dataTypeOrTransport] ? seekingTransport ? !(selected = dataTypeOrTransport) : void 0 : (options.dataTypes.unshift(dataTypeOrTransport), inspect(dataTypeOrTransport), false);
  977.       }), selected;
  978.     }
  979.     var nodedescriptions = {};
  980.     /** @type {boolean} */
  981.     var seekingTransport = structure === transports;
  982.     return inspect(options.dataTypes[0]) || !nodedescriptions["*"] && inspect("*");
  983.   }
  984.   /**
  985.    * @param {?} target
  986.    * @param {?} opts
  987.    * @return {?}
  988.    */
  989.   function ajaxExtend(target, opts) {
  990.     var key;
  991.     var deep;
  992.     var flatOptions = jQuery.ajaxSettings.flatOptions || {};
  993.     for (key in opts) {
  994.       if (void 0 !== opts[key]) {
  995.         (flatOptions[key] ? target : deep || (deep = {}))[key] = opts[key];
  996.       }
  997.     }
  998.     return deep && jQuery.extend(true, target, deep), target;
  999.   }
  1000.   /** @type {!Array} */
  1001.   var arr = [];
  1002.   /** @type {function(!Object): (Object|null)} */
  1003.   var getProto = Object.getPrototypeOf;
  1004.   /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
  1005.   var slice = arr.slice;
  1006.   /** @type {function(!Array): ?} */
  1007.   var map = arr.flat ? function(elems) {
  1008.     return arr.flat.call(elems);
  1009.   } : function(args) {
  1010.     return arr.concat.apply([], args);
  1011.   };
  1012.   /** @type {function(this:IArrayLike<T>, ...T): number} */
  1013.   var push = arr.push;
  1014.   /** @type {function(this:(IArrayLike<T>|string), T, number=): number} */
  1015.   var indexOf = arr.indexOf;
  1016.   var class2type = {};
  1017.   /** @type {function(this:*): string} */
  1018.   var toString = class2type.toString;
  1019.   /** @type {function(this:Object, *): boolean} */
  1020.   var hasOwn = class2type.hasOwnProperty;
  1021.   /** @type {function(this:!Function): string} */
  1022.   var fnToString = hasOwn.toString;
  1023.   /** @type {string} */
  1024.   var Mixin2 = fnToString.call(Object);
  1025.   var support = {};
  1026.   /**
  1027.    * @param {string} obj
  1028.    * @return {?}
  1029.    */
  1030.   var fn = function(obj) {
  1031.     return "function" == typeof obj && "number" != typeof obj.nodeType;
  1032.   };
  1033.   /**
  1034.    * @param {!Object} obj
  1035.    * @return {?}
  1036.    */
  1037.   var isWindow = function(obj) {
  1038.     return null != obj && obj === obj.window;
  1039.   };
  1040.   var document = window.document;
  1041.   var obj = {
  1042.     type : true,
  1043.     src : true,
  1044.     nonce : true,
  1045.     noModule : true
  1046.   };
  1047.   /** @type {string} */
  1048.   var core_version = "3.5.1";
  1049.   /**
  1050.    * @param {!Array} selector
  1051.    * @param {!Function} context
  1052.    * @return {?}
  1053.    */
  1054.   var jQuery = function(selector, context) {
  1055.     return new jQuery.fn.init(selector, context);
  1056.   };
  1057.   jQuery.fn = jQuery.prototype = {
  1058.     jquery : core_version,
  1059.     constructor : jQuery,
  1060.     length : 0,
  1061.     toArray : function() {
  1062.       return slice.call(this);
  1063.     },
  1064.     get : function(num) {
  1065.       return null == num ? slice.call(this) : num < 0 ? this[num + this.length] : this[num];
  1066.     },
  1067.     pushStack : function(a) {
  1068.       var elm = jQuery.merge(this.constructor(), a);
  1069.       return elm.prevObject = this, elm;
  1070.     },
  1071.     each : function(callback) {
  1072.       return jQuery.each(this, callback);
  1073.     },
  1074.     map : function(fn) {
  1075.       return this.pushStack(jQuery.map(this, function(elem, event) {
  1076.         return fn.call(elem, event, elem);
  1077.       }));
  1078.     },
  1079.     slice : function() {
  1080.       return this.pushStack(slice.apply(this, arguments));
  1081.     },
  1082.     first : function() {
  1083.       return this.eq(0);
  1084.     },
  1085.     last : function() {
  1086.       return this.eq(-1);
  1087.     },
  1088.     even : function() {
  1089.       return this.pushStack(jQuery.grep(this, function(canCreateDiscussions, isSlidingUp) {
  1090.         return (isSlidingUp + 1) % 2;
  1091.       }));
  1092.     },
  1093.     odd : function() {
  1094.       return this.pushStack(jQuery.grep(this, function(canCreateDiscussions, isSlidingUp) {
  1095.         return isSlidingUp % 2;
  1096.       }));
  1097.     },
  1098.     eq : function(i) {
  1099.       var len = this.length;
  1100.       var end = +i + (i < 0 ? len : 0);
  1101.       return this.pushStack(0 <= end && end < len ? [this[end]] : []);
  1102.     },
  1103.     end : function() {
  1104.       return this.prevObject || this.constructor();
  1105.     },
  1106.     push : push,
  1107.     sort : arr.sort,
  1108.     splice : arr.splice
  1109.   };
  1110.   /** @type {function(): ?} */
  1111.   jQuery.extend = jQuery.fn.extend = function() {
  1112.     var options;
  1113.     var name;
  1114.     var value;
  1115.     var copy;
  1116.     var copyIsArray;
  1117.     var clone;
  1118.     var target = arguments[0] || {};
  1119.     /** @type {number} */
  1120.     var i = 1;
  1121.     /** @type {number} */
  1122.     var length = arguments.length;
  1123.     /** @type {boolean} */
  1124.     var deep = false;
  1125.     if ("boolean" == typeof target) {
  1126.       /** @type {boolean} */
  1127.       deep = target;
  1128.       target = arguments[i] || {};
  1129.       i++;
  1130.     }
  1131.     if (!("object" == typeof target || fn(target))) {
  1132.       target = {};
  1133.     }
  1134.     if (i === length) {
  1135.       target = this;
  1136.       i--;
  1137.     }
  1138.     for (; i < length; i++) {
  1139.       if (null != (options = arguments[i])) {
  1140.         for (name in options) {
  1141.           copy = options[name];
  1142.           if ("__proto__" !== name && target !== copy) {
  1143.             if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
  1144.               value = target[name];
  1145.               clone = copyIsArray && !Array.isArray(value) ? [] : copyIsArray || jQuery.isPlainObject(value) ? value : {};
  1146.               /** @type {boolean} */
  1147.               copyIsArray = false;
  1148.               target[name] = jQuery.extend(deep, clone, copy);
  1149.             } else {
  1150.               if (void 0 !== copy) {
  1151.                 target[name] = copy;
  1152.               }
  1153.             }
  1154.           }
  1155.         }
  1156.       }
  1157.     }
  1158.     return target;
  1159.   };
  1160.   jQuery.extend({
  1161.     expando : "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
  1162.     isReady : true,
  1163.     error : function(value) {
  1164.       throw new Error(value);
  1165.     },
  1166.     noop : function() {
  1167.     },
  1168.     isPlainObject : function(obj) {
  1169.       var proto;
  1170.       var hasOwnProperty;
  1171.       return !(!obj || "[object Object]" !== toString.call(obj)) && (!(proto = getProto(obj)) || "function" == typeof(hasOwnProperty = hasOwn.call(proto, "constructor") && proto.constructor) && fnToString.call(hasOwnProperty) === Mixin2);
  1172.     },
  1173.     isEmptyObject : function(obj) {
  1174.       var key;
  1175.       for (key in obj) {
  1176.         return false;
  1177.       }
  1178.       return true;
  1179.     },
  1180.     globalEval : function(url, data, x) {
  1181.       cb(url, {
  1182.         nonce : data && data.nonce
  1183.       }, x);
  1184.     },
  1185.     each : function(object, callback) {
  1186.       var aLength;
  1187.       /** @type {number} */
  1188.       var i = 0;
  1189.       if (isArrayLike(object)) {
  1190.         aLength = object.length;
  1191.         for (; i < aLength; i++) {
  1192.           if (false === callback.call(object[i], i, object[i])) {
  1193.             break;
  1194.           }
  1195.         }
  1196.       } else {
  1197.         for (i in object) {
  1198.           if (false === callback.call(object[i], i, object[i])) {
  1199.             break;
  1200.           }
  1201.         }
  1202.       }
  1203.       return object;
  1204.     },
  1205.     makeArray : function(arr, o) {
  1206.       var obj = o || [];
  1207.       return null != arr && (isArrayLike(Object(arr)) ? jQuery.merge(obj, "string" == typeof arr ? [arr] : arr) : push.call(obj, arr)), obj;
  1208.     },
  1209.     inArray : function(elem, arr, i) {
  1210.       return null == arr ? -1 : indexOf.call(arr, elem, i);
  1211.     },
  1212.     merge : function(a, b) {
  1213.       /** @type {number} */
  1214.       var _jlen = +b.length;
  1215.       /** @type {number} */
  1216.       var k = 0;
  1217.       var l = a.length;
  1218.       for (; k < _jlen; k++) {
  1219.         a[l++] = b[k];
  1220.       }
  1221.       return a.length = l, a;
  1222.     },
  1223.     grep : function(elements, callback, a) {
  1224.       /** @type {!Array} */
  1225.       var ret = [];
  1226.       /** @type {number} */
  1227.       var i = 0;
  1228.       var eL = elements.length;
  1229.       /** @type {boolean} */
  1230.       var booA = !a;
  1231.       for (; i < eL; i++) {
  1232.         if (!callback(elements[i], i) !== booA) {
  1233.           ret.push(elements[i]);
  1234.         }
  1235.       }
  1236.       return ret;
  1237.     },
  1238.     map : function(input, t, path) {
  1239.       var inpLen;
  1240.       var value;
  1241.       /** @type {number} */
  1242.       var i = 0;
  1243.       /** @type {!Array} */
  1244.       var args = [];
  1245.       if (isArrayLike(input)) {
  1246.         inpLen = input.length;
  1247.         for (; i < inpLen; i++) {
  1248.           if (null != (value = t(input[i], i, path))) {
  1249.             args.push(value);
  1250.           }
  1251.         }
  1252.       } else {
  1253.         for (i in input) {
  1254.           if (null != (value = t(input[i], i, path))) {
  1255.             args.push(value);
  1256.           }
  1257.         }
  1258.       }
  1259.       return map(args);
  1260.     },
  1261.     guid : 1,
  1262.     support : support
  1263.   });
  1264.   if ("function" == typeof Symbol) {
  1265.     jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
  1266.   }
  1267.   jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(canCreateDiscussions, p_Interval) {
  1268.     class2type["[object " + p_Interval + "]"] = p_Interval.toLowerCase();
  1269.   });
  1270.   var Sizzle = function(options) {
  1271.     /**
  1272.      * @param {string} selector
  1273.      * @param {!Object} context
  1274.      * @param {!Array} results
  1275.      * @param {!Array} seed
  1276.      * @return {?}
  1277.      */
  1278.     function Sizzle(selector, context, results, seed) {
  1279.       var m;
  1280.       var i;
  1281.       var elem;
  1282.       var nid;
  1283.       var match;
  1284.       var groups;
  1285.       var newSelector;
  1286.       var newContext = context && context.ownerDocument;
  1287.       var undefined = context ? context.nodeType : 9;
  1288.       if (results = results || [], "string" != typeof selector || !selector || 1 !== undefined && 9 !== undefined && 11 !== undefined) {
  1289.         return results;
  1290.       }
  1291.       if (!seed && (setDocument(context), context = context || document, documentIsHTML)) {
  1292.         if (11 !== undefined && (match = customSelectorReg.exec(selector))) {
  1293.           if (m = match[1]) {
  1294.             if (9 === undefined) {
  1295.               if (!(elem = context.getElementById(m))) {
  1296.                 return results;
  1297.               }
  1298.               if (elem.id === m) {
  1299.                 return results.push(elem), results;
  1300.               }
  1301.             } else {
  1302.               if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
  1303.                 return results.push(elem), results;
  1304.               }
  1305.             }
  1306.           } else {
  1307.             if (match[2]) {
  1308.               return push.apply(results, context.getElementsByTagName(selector)), results;
  1309.             }
  1310.             if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
  1311.               return push.apply(results, context.getElementsByClassName(m)), results;
  1312.             }
  1313.           }
  1314.         }
  1315.         if (support.qsa && !isUndefined[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && (1 !== undefined || "object" !== context.nodeName.toLowerCase())) {
  1316.           if (newSelector = selector, newContext = context, 1 === undefined && (RE_PSEUDOS.test(selector) || pattern.test(selector))) {
  1317.             if (!((newContext = IS_HTML_FRAGMENT.test(selector) && testContext(context.parentNode) || context) === context && support.scope)) {
  1318.               if (nid = context.getAttribute("id")) {
  1319.                 nid = nid.replace(rcssescape, fcssescape);
  1320.               } else {
  1321.                 context.setAttribute("id", nid = expando);
  1322.               }
  1323.             }
  1324.             i = (groups = tokenize(selector)).length;
  1325.             for (; i--;) {
  1326.               /** @type {string} */
  1327.               groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]);
  1328.             }
  1329.             newSelector = groups.join(",");
  1330.           }
  1331.           try {
  1332.             return push.apply(results, newContext.querySelectorAll(newSelector)), results;
  1333.           } catch (e) {
  1334.             isUndefined(selector, true);
  1335.           } finally {
  1336.             if (nid === expando) {
  1337.               context.removeAttribute("id");
  1338.             }
  1339.           }
  1340.         }
  1341.       }
  1342.       return select(selector.replace(rtrim, "$1"), context, results, seed);
  1343.     }
  1344.     /**
  1345.      * @return {?}
  1346.      */
  1347.     function createCache() {
  1348.       /** @type {!Array} */
  1349.       var lengths = [];
  1350.       return function cache(duration, url) {
  1351.         return lengths.push(duration + " ") > Expr.cacheLength && delete cache[lengths.shift()], cache[duration + " "] = url;
  1352.       };
  1353.     }
  1354.     /**
  1355.      * @param {!Function} fn
  1356.      * @return {?}
  1357.      */
  1358.     function markFunction(fn) {
  1359.       return fn[expando] = true, fn;
  1360.     }
  1361.     /**
  1362.      * @param {!Function} expect
  1363.      * @return {?}
  1364.      */
  1365.     function assert(expect) {
  1366.       var wrap = document.createElement("fieldset");
  1367.       try {
  1368.         return !!expect(wrap);
  1369.       } catch (e) {
  1370.         return false;
  1371.       } finally {
  1372.         if (wrap.parentNode) {
  1373.           wrap.parentNode.removeChild(wrap);
  1374.         }
  1375.         /** @type {null} */
  1376.         wrap = null;
  1377.       }
  1378.     }
  1379.     /**
  1380.      * @param {string} handler
  1381.      * @param {!Function} index
  1382.      * @return {undefined}
  1383.      */
  1384.     function addHandle(handler, index) {
  1385.       var arr = handler.split("|");
  1386.       var i = arr.length;
  1387.       for (; i--;) {
  1388.         /** @type {!Function} */
  1389.         Expr.attrHandle[arr[i]] = index;
  1390.       }
  1391.     }
  1392.     /**
  1393.      * @param {!Object} a
  1394.      * @param {!Element} b
  1395.      * @return {?}
  1396.      */
  1397.     function siblingCheck(a, b) {
  1398.       var cur = b && a;
  1399.       var .num_const = cur && 1 === a.nodeType && 1 === b.nodeType && a.sourceIndex - b.sourceIndex;
  1400.       if (.num_const) {
  1401.         return .num_const;
  1402.       }
  1403.       if (cur) {
  1404.         for (; cur = cur.nextSibling;) {
  1405.           if (cur === b) {
  1406.             return -1;
  1407.           }
  1408.         }
  1409.       }
  1410.       return a ? 1 : -1;
  1411.     }
  1412.     /**
  1413.      * @param {!Object} selector
  1414.      * @return {?}
  1415.      */
  1416.     function jQuerify(selector) {
  1417.       return function(item) {
  1418.         return "input" === item.nodeName.toLowerCase() && item.type === selector;
  1419.       };
  1420.     }
  1421.     /**
  1422.      * @param {!Object} type
  1423.      * @return {?}
  1424.      */
  1425.     function createButtonPseudo(type) {
  1426.       return function(section) {
  1427.         var undefined = section.nodeName.toLowerCase();
  1428.         return ("input" === undefined || "button" === undefined) && section.type === type;
  1429.       };
  1430.     }
  1431.     /**
  1432.      * @param {boolean} disabled
  1433.      * @return {?}
  1434.      */
  1435.     function createDisabledPseudo(disabled) {
  1436.       return function(elem) {
  1437.         return "form" in elem ? elem.parentNode && false === elem.disabled ? "label" in elem ? "label" in elem.parentNode ? elem.parentNode.disabled === disabled : elem.disabled === disabled : elem.isDisabled === disabled || elem.isDisabled !== !disabled && disabledAncestor(elem) === disabled : elem.disabled === disabled : "label" in elem && elem.disabled === disabled;
  1438.       };
  1439.     }
  1440.     /**
  1441.      * @param {!Function} fn
  1442.      * @return {?}
  1443.      */
  1444.     function createPositionalPseudo(fn) {
  1445.       return markFunction(function(args) {
  1446.         return args = +args, markFunction(function(h, i) {
  1447.           var k;
  1448.           var x = fn([], h.length, args);
  1449.           var i = x.length;
  1450.           for (; i--;) {
  1451.             if (h[k = x[i]]) {
  1452.               /** @type {boolean} */
  1453.               h[k] = !(i[k] = h[k]);
  1454.             }
  1455.           }
  1456.         });
  1457.       });
  1458.     }
  1459.     /**
  1460.      * @param {!Node} context
  1461.      * @return {?}
  1462.      */
  1463.     function testContext(context) {
  1464.       return context && "undefined" != typeof context.getElementsByTagName && context;
  1465.     }
  1466.     /**
  1467.      * @return {undefined}
  1468.      */
  1469.     function setFilters() {
  1470.     }
  1471.     /**
  1472.      * @param {!Array} tokens
  1473.      * @return {?}
  1474.      */
  1475.     function toSelector(tokens) {
  1476.       /** @type {number} */
  1477.       var i = 0;
  1478.       var numTokens = tokens.length;
  1479.       /** @type {string} */
  1480.       var selector = "";
  1481.       for (; i < numTokens; i++) {
  1482.         /** @type {string} */
  1483.         selector = selector + tokens[i].value;
  1484.       }
  1485.       return selector;
  1486.     }
  1487.     /**
  1488.      * @param {!Function} matcher
  1489.      * @param {!Object} combinator
  1490.      * @param {string} base
  1491.      * @return {?}
  1492.      */
  1493.     function addCombinator(matcher, combinator, base) {
  1494.       var dir = combinator.dir;
  1495.       var skip = combinator.next;
  1496.       var key = skip || dir;
  1497.       var checkNonElements = base && "parentNode" === key;
  1498.       /** @type {number} */
  1499.       var doneName = done++;
  1500.       return combinator.first ? function(elem, stat, context) {
  1501.         for (; elem = elem[dir];) {
  1502.           if (1 === elem.nodeType || checkNonElements) {
  1503.             return matcher(elem, stat, context);
  1504.           }
  1505.         }
  1506.         return false;
  1507.       } : function(elem, stat, context) {
  1508.         var oldCache;
  1509.         var uniqueCache;
  1510.         var outerCache;
  1511.         /** @type {!Array} */
  1512.         var newCache = [dirruns, doneName];
  1513.         if (context) {
  1514.           for (; elem = elem[dir];) {
  1515.             if ((1 === elem.nodeType || checkNonElements) && matcher(elem, stat, context)) {
  1516.               return true;
  1517.             }
  1518.           }
  1519.         } else {
  1520.           for (; elem = elem[dir];) {
  1521.             if (1 === elem.nodeType || checkNonElements) {
  1522.               if (uniqueCache = (outerCache = elem[expando] || (elem[expando] = {}))[elem.uniqueID] || (outerCache[elem.uniqueID] = {}), skip && skip === elem.nodeName.toLowerCase()) {
  1523.                 elem = elem[dir] || elem;
  1524.               } else {
  1525.                 if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
  1526.                   return newCache[2] = oldCache[2];
  1527.                 }
  1528.                 if ((uniqueCache[key] = newCache)[2] = matcher(elem, stat, context)) {
  1529.                   return true;
  1530.                 }
  1531.               }
  1532.             }
  1533.           }
  1534.         }
  1535.         return false;
  1536.       };
  1537.     }
  1538.     /**
  1539.      * @param {!Object} matchers
  1540.      * @return {?}
  1541.      */
  1542.     function elementMatcher(matchers) {
  1543.       return 1 < matchers.length ? function(elem, context, xml) {
  1544.         var i = matchers.length;
  1545.         for (; i--;) {
  1546.           if (!matchers[i](elem, context, xml)) {
  1547.             return false;
  1548.           }
  1549.         }
  1550.         return true;
  1551.       } : matchers[0];
  1552.     }
  1553.     /**
  1554.      * @param {!Array} t
  1555.      * @param {!Object} color
  1556.      * @param {!Object} n
  1557.      * @param {!Object} e
  1558.      * @param {?} comments
  1559.      * @return {?}
  1560.      */
  1561.     function parse(t, color, n, e, comments) {
  1562.       var c;
  1563.       /** @type {!Array} */
  1564.       var Cells = [];
  1565.       /** @type {number} */
  1566.       var i = 0;
  1567.       var pal = t.length;
  1568.       /** @type {boolean} */
  1569.       var colorChange = null != color;
  1570.       for (; i < pal; i++) {
  1571.         if (c = t[i]) {
  1572.           if (!(n && !n(c, e, comments))) {
  1573.             Cells.push(c);
  1574.             if (colorChange) {
  1575.               color.push(i);
  1576.             }
  1577.           }
  1578.         }
  1579.       }
  1580.       return Cells;
  1581.     }
  1582.     /**
  1583.      * @param {!Object} options
  1584.      * @param {string} fields
  1585.      * @param {string} callback
  1586.      * @param {!Object} element
  1587.      * @param {!Object} fn
  1588.      * @param {string} data
  1589.      * @return {?}
  1590.      */
  1591.     function render(options, fields, callback, element, fn, data) {
  1592.       return element && !element[expando] && (element = render(element)), fn && !fn[expando] && (fn = render(fn, data)), markFunction(function(data, i, context, extra) {
  1593.         var key;
  1594.         var j;
  1595.         var value;
  1596.         /** @type {!Array} */
  1597.         var obj = [];
  1598.         /** @type {!Array} */
  1599.         var c = [];
  1600.         var o = i.length;
  1601.         var result = data || function(selector, set, results) {
  1602.           /** @type {number} */
  1603.           var i = 0;
  1604.           var l = set.length;
  1605.           for (; i < l; i++) {
  1606.             Sizzle(selector, set[i], results);
  1607.           }
  1608.           return results;
  1609.         }(fields || "*", context.nodeType ? [context] : context, []);
  1610.         var ret = !options || !data && fields ? result : parse(result, obj, options, context, extra);
  1611.         var item = callback ? fn || (data ? options : o || element) ? [] : i : ret;
  1612.         if (callback && callback(ret, item, context, extra), element) {
  1613.           key = parse(item, c);
  1614.           element(key, [], context, extra);
  1615.           j = key.length;
  1616.           for (; j--;) {
  1617.             if (value = key[j]) {
  1618.               /** @type {boolean} */
  1619.               item[c[j]] = !(ret[c[j]] = value);
  1620.             }
  1621.           }
  1622.         }
  1623.         if (data) {
  1624.           if (fn || options) {
  1625.             if (fn) {
  1626.               /** @type {!Array} */
  1627.               key = [];
  1628.               j = item.length;
  1629.               for (; j--;) {
  1630.                 if (value = item[j]) {
  1631.                   key.push(ret[j] = value);
  1632.                 }
  1633.               }
  1634.               fn(null, item = [], key, extra);
  1635.             }
  1636.             j = item.length;
  1637.             for (; j--;) {
  1638.               if ((value = item[j]) && -1 < (key = fn ? indexOf(data, value) : obj[j])) {
  1639.                 /** @type {boolean} */
  1640.                 data[key] = !(i[key] = value);
  1641.               }
  1642.             }
  1643.           }
  1644.         } else {
  1645.           item = parse(item === i ? item.splice(o, item.length) : item);
  1646.           if (fn) {
  1647.             fn(null, i, item, extra);
  1648.           } else {
  1649.             push.apply(i, item);
  1650.           }
  1651.         }
  1652.       });
  1653.     }
  1654.     /**
  1655.      * @param {!Array} tokens
  1656.      * @return {?}
  1657.      */
  1658.     function matcherFromTokens(tokens) {
  1659.       var checkContext;
  1660.       var matcher;
  1661.       var j;
  1662.       var len = tokens.length;
  1663.       var leadingRelative = Expr.relative[tokens[0].type];
  1664.       var implicitRelative = leadingRelative || Expr.relative[" "];
  1665.       /** @type {number} */
  1666.       var i = leadingRelative ? 1 : 0;
  1667.       var matchContext = addCombinator(function(elem) {
  1668.         return elem === checkContext;
  1669.       }, implicitRelative, true);
  1670.       var matchAnyContext = addCombinator(function(value) {
  1671.         return -1 < indexOf(checkContext, value);
  1672.       }, implicitRelative, true);
  1673.       /** @type {!Array} */
  1674.       var matchers = [function(elem, context, xml) {
  1675.         var r = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
  1676.         return checkContext = null, r;
  1677.       }];
  1678.       for (; i < len; i++) {
  1679.         if (matcher = Expr.relative[tokens[i].type]) {
  1680.           /** @type {!Array} */
  1681.           matchers = [addCombinator(elementMatcher(matchers), matcher)];
  1682.         } else {
  1683.           if ((matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches))[expando]) {
  1684.             /** @type {number} */
  1685.             j = ++i;
  1686.             for (; j < len; j++) {
  1687.               if (Expr.relative[tokens[j].type]) {
  1688.                 break;
  1689.               }
  1690.             }
  1691.             return render(1 < i && elementMatcher(matchers), 1 < i && toSelector(tokens.slice(0, i - 1).concat({
  1692.               value : " " === tokens[i - 2].type ? "*" : ""
  1693.             })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
  1694.           }
  1695.           matchers.push(matcher);
  1696.         }
  1697.       }
  1698.       return elementMatcher(matchers);
  1699.     }
  1700.     var i;
  1701.     var support;
  1702.     var Expr;
  1703.     var $;
  1704.     var isXML;
  1705.     var tokenize;
  1706.     var compile;
  1707.     var select;
  1708.     var outermostContext;
  1709.     var sortInput;
  1710.     var ret;
  1711.     var setDocument;
  1712.     var document;
  1713.     var docElem;
  1714.     var documentIsHTML;
  1715.     var rbuggyQSA;
  1716.     var rbuggyMatches;
  1717.     var matches;
  1718.     var contains;
  1719.     /** @type {string} */
  1720.     var expando = "sizzle" + 1 * new Date;
  1721.     var el = options.document;
  1722.     /** @type {number} */
  1723.     var dirruns = 0;
  1724.     /** @type {number} */
  1725.     var done = 0;
  1726.     var classCache = createCache();
  1727.     var tokenCache = createCache();
  1728.     var compilerCache = createCache();
  1729.     var isUndefined = createCache();
  1730.     /**
  1731.      * @param {?} type
  1732.      * @param {?} string
  1733.      * @return {?}
  1734.      */
  1735.     var time = function(type, string) {
  1736.       return type === string && (ret = true), 0;
  1737.     };
  1738.     /** @type {function(this:Object, *): boolean} */
  1739.     var hasOwn = {}.hasOwnProperty;
  1740.     /** @type {!Array} */
  1741.     var arr = [];
  1742.     /** @type {function(this:IArrayLike<T>): T} */
  1743.     var pop = arr.pop;
  1744.     /** @type {function(this:IArrayLike<T>, ...T): number} */
  1745.     var push_native = arr.push;
  1746.     /** @type {function(this:IArrayLike<T>, ...T): number} */
  1747.     var push = arr.push;
  1748.     /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
  1749.     var slice = arr.slice;
  1750.     /**
  1751.      * @param {string} list
  1752.      * @param {!Object} value
  1753.      * @return {?}
  1754.      */
  1755.     var indexOf = function(list, value) {
  1756.       /** @type {number} */
  1757.       var i = 0;
  1758.       var listLength = list.length;
  1759.       for (; i < listLength; i++) {
  1760.         if (list[i] === value) {
  1761.           return i;
  1762.         }
  1763.       }
  1764.       return -1;
  1765.     };
  1766.     /** @type {string} */
  1767.     var value = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped";
  1768.     /** @type {string} */
  1769.     var _test = "[\\x20\\t\\r\\n\\f]";
  1770.     /** @type {string} */
  1771.     var escRightBracket = "(?:\\\\[\\da-fA-F]{1,6}" + _test + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\x00-\\x7f])+";
  1772.     /** @type {string} */
  1773.     var _end2 = "\\[" + _test + "*(" + escRightBracket + ")(?:" + _test + "*([*^$|!~]?=)" + _test + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + escRightBracket + "))|)" + _test + "*\\]";
  1774.     /** @type {string} */
  1775.     var pseudos = ":(" + escRightBracket + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + _end2 + ")*)|.*)\\)|)";
  1776.     /** @type {!RegExp} */
  1777.     var entityEscapeRegExp = new RegExp(_test + "+", "g");
  1778.     /** @type {!RegExp} */
  1779.     var rtrim = new RegExp("^" + _test + "+|((?:^|[^\\\\])(?:\\\\.)*)" + _test + "+$", "g");
  1780.     /** @type {!RegExp} */
  1781.     var chunker = new RegExp("^" + _test + "*," + _test + "*");
  1782.     /** @type {!RegExp} */
  1783.     var pattern = new RegExp("^" + _test + "*([>+~]|" + _test + ")" + _test + "*");
  1784.     /** @type {!RegExp} */
  1785.     var RE_PSEUDOS = new RegExp(_test + "|>");
  1786.     /** @type {!RegExp} */
  1787.     var rpseudo = new RegExp(pseudos);
  1788.     /** @type {!RegExp} */
  1789.     var ridentifier = new RegExp("^" + escRightBracket + "$");
  1790.     var matchExpr = {
  1791.       ID : new RegExp("^#(" + escRightBracket + ")"),
  1792.       CLASS : new RegExp("^\\.(" + escRightBracket + ")"),
  1793.       TAG : new RegExp("^(" + escRightBracket + "|[*])"),
  1794.       ATTR : new RegExp("^" + _end2),
  1795.       PSEUDO : new RegExp("^" + pseudos),
  1796.       CHILD : new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + _test + "*(even|odd|(([+-]|)(\\d*)n|)" + _test + "*(?:([+-]|)" + _test + "*(\\d+)|))" + _test + "*\\)|)", "i"),
  1797.       bool : new RegExp("^(?:" + value + ")$", "i"),
  1798.       needsContext : new RegExp("^" + _test + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + _test + "*((?:-\\d)?\\d*)" + _test + "*\\)|)(?=[^-]|$)", "i")
  1799.     };
  1800.     /** @type {!RegExp} */
  1801.     var reKeyword = /HTML$/i;
  1802.     /** @type {!RegExp} */
  1803.     var inputNodeNames = /^(?:input|select|textarea|button)$/i;
  1804.     /** @type {!RegExp} */
  1805.     var rnoType = /^h\d$/i;
  1806.     /** @type {!RegExp} */
  1807.     var rnative = /^[^{]+\{\s*\[native \w/;
  1808.     /** @type {!RegExp} */
  1809.     var customSelectorReg = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
  1810.     /** @type {!RegExp} */
  1811.     var IS_HTML_FRAGMENT = /[+~]/;
  1812.     /** @type {!RegExp} */
  1813.     var a = new RegExp("\\\\[\\da-fA-F]{1,6}" + _test + "?|\\\\([^\\r\\n\\f])", "g");
  1814.     /**
  1815.      * @param {string} i
  1816.      * @param {string} match
  1817.      * @return {?}
  1818.      */
  1819.     var data = function(i, match) {
  1820.       /** @type {number} */
  1821.       var charCodeUpperA = "0x" + i.slice(1) - 65536;
  1822.       return match || (charCodeUpperA < 0 ? String.fromCharCode(charCodeUpperA + 65536) : String.fromCharCode(charCodeUpperA >> 10 | 55296, 1023 & charCodeUpperA | 56320));
  1823.     };
  1824.     /** @type {!RegExp} */
  1825.     var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g;
  1826.     /**
  1827.      * @param {string} text
  1828.      * @param {string} ch
  1829.      * @return {?}
  1830.      */
  1831.     var fcssescape = function(text, ch) {
  1832.       return ch ? "\x00" === text ? "\ufffd" : text.slice(0, -1) + "\\" + text.charCodeAt(text.length - 1).toString(16) + " " : "\\" + text;
  1833.     };
  1834.     /**
  1835.      * @return {undefined}
  1836.      */
  1837.     var unloadHandler = function() {
  1838.       setDocument();
  1839.     };
  1840.     var disabledAncestor = addCombinator(function(e) {
  1841.       return true === e.disabled && "fieldset" === e.nodeName.toLowerCase();
  1842.     }, {
  1843.       dir : "parentNode",
  1844.       next : "legend"
  1845.     });
  1846.     try {
  1847.       push.apply(arr = slice.call(el.childNodes), el.childNodes);
  1848.       arr[el.childNodes.length].nodeType;
  1849.     } catch (e) {
  1850.       push = {
  1851.         apply : arr.length ? function(target, array) {
  1852.           push_native.apply(target, slice.call(array));
  1853.         } : function(array, obj) {
  1854.           var length = array.length;
  1855.           /** @type {number} */
  1856.           var objCursor = 0;
  1857.           for (; array[length++] = obj[objCursor++];) {
  1858.           }
  1859.           /** @type {number} */
  1860.           array.length = length - 1;
  1861.         }
  1862.       };
  1863.     }
  1864.     for (i in support = Sizzle.support = {}, isXML = Sizzle.isXML = function(elem) {
  1865.       var nodeName = elem.namespaceURI;
  1866.       var xmlNode = (elem.ownerDocument || elem).documentElement;
  1867.       return !reKeyword.test(nodeName || xmlNode && xmlNode.nodeName || "HTML");
  1868.     }, setDocument = Sizzle.setDocument = function(root) {
  1869.       var init;
  1870.       var subWindow;
  1871.       var doc = root ? root.ownerDocument || root : el;
  1872.       return doc != document && 9 === doc.nodeType && doc.documentElement && (docElem = (document = doc).documentElement, documentIsHTML = !isXML(document), el != document && (subWindow = document.defaultView) && subWindow.top !== subWindow && (subWindow.addEventListener ? subWindow.addEventListener("unload", unloadHandler, false) : subWindow.attachEvent && subWindow.attachEvent("onunload", unloadHandler)), support.scope = assert(function(elem) {
  1873.         return docElem.appendChild(elem).appendChild(document.createElement("div")), "undefined" != typeof elem.querySelectorAll && !elem.querySelectorAll(":scope fieldset div").length;
  1874.       }), support.attributes = assert(function(elm) {
  1875.         return elm.className = "i", !elm.getAttribute("className");
  1876.       }), support.getElementsByTagName = assert(function(testee) {
  1877.         return testee.appendChild(document.createComment("")), !testee.getElementsByTagName("*").length;
  1878.       }), support.getElementsByClassName = rnative.test(document.getElementsByClassName), support.getById = assert(function(body) {
  1879.         return docElem.appendChild(body).id = expando, !document.getElementsByName || !document.getElementsByName(expando).length;
  1880.       }), support.getById ? (Expr.filter.ID = function(elem) {
  1881.         var i = elem.replace(a, data);
  1882.         return function(e) {
  1883.           return e.getAttribute("id") === i;
  1884.         };
  1885.       }, Expr.find.ID = function(elem, context) {
  1886.         if ("undefined" != typeof context.getElementById && documentIsHTML) {
  1887.           var c_style = context.getElementById(elem);
  1888.           return c_style ? [c_style] : [];
  1889.         }
  1890.       }) : (Expr.filter.ID = function(elem) {
  1891.         var string = elem.replace(a, data);
  1892.         return function(elem) {
  1893.           var token = "undefined" != typeof elem.getAttributeNode && elem.getAttributeNode("id");
  1894.           return token && token.value === string;
  1895.         };
  1896.       }, Expr.find.ID = function(value, context) {
  1897.         if ("undefined" != typeof context.getElementById && documentIsHTML) {
  1898.           var attr;
  1899.           var r;
  1900.           var ret;
  1901.           var tmp = context.getElementById(value);
  1902.           if (tmp) {
  1903.             if ((attr = tmp.getAttributeNode("id")) && attr.value === value) {
  1904.               return [tmp];
  1905.             }
  1906.             ret = context.getElementsByName(value);
  1907.             /** @type {number} */
  1908.             r = 0;
  1909.             for (; tmp = ret[r++];) {
  1910.               if ((attr = tmp.getAttributeNode("id")) && attr.value === value) {
  1911.                 return [tmp];
  1912.               }
  1913.             }
  1914.           }
  1915.           return [];
  1916.         }
  1917.       }), Expr.find.TAG = support.getElementsByTagName ? function(v, g) {
  1918.         return "undefined" != typeof g.getElementsByTagName ? g.getElementsByTagName(v) : support.qsa ? g.querySelectorAll(v) : void 0;
  1919.       } : function(selector, o) {
  1920.         var first;
  1921.         /** @type {!Array} */
  1922.         var tmp = [];
  1923.         /** @type {number} */
  1924.         var i = 0;
  1925.         var results = o.getElementsByTagName(selector);
  1926.         if ("*" === selector) {
  1927.           for (; first = results[i++];) {
  1928.             if (1 === first.nodeType) {
  1929.               tmp.push(first);
  1930.             }
  1931.           }
  1932.           return tmp;
  1933.         }
  1934.         return results;
  1935.       }, Expr.find.CLASS = support.getElementsByClassName && function(l, docDom) {
  1936.         if ("undefined" != typeof docDom.getElementsByClassName && documentIsHTML) {
  1937.           return docDom.getElementsByClassName(l);
  1938.         }
  1939.       }, rbuggyMatches = [], rbuggyQSA = [], (support.qsa = rnative.test(document.querySelectorAll)) && (assert(function(container) {
  1940.         var element;
  1941.         /** @type {string} */
  1942.         docElem.appendChild(container).innerHTML = "<a id='" + expando + "'></a><select id='" + expando + "-\r\\' msallowcapture=''><option selected=''></option></select>";
  1943.         if (container.querySelectorAll("[msallowcapture^='']").length) {
  1944.           rbuggyQSA.push("[*^$]=" + _test + "*(?:''|\"\")");
  1945.         }
  1946.         if (!container.querySelectorAll("[selected]").length) {
  1947.           rbuggyQSA.push("\\[" + _test + "*(?:value|" + value + ")");
  1948.         }
  1949.         if (!container.querySelectorAll("[id~=" + expando + "-]").length) {
  1950.           rbuggyQSA.push("~=");
  1951.         }
  1952.         (element = document.createElement("input")).setAttribute("name", "");
  1953.         container.appendChild(element);
  1954.         if (!container.querySelectorAll("[name='']").length) {
  1955.           rbuggyQSA.push("\\[" + _test + "*name" + _test + "*=" + _test + "*(?:''|\"\")");
  1956.         }
  1957.         if (!container.querySelectorAll(":checked").length) {
  1958.           rbuggyQSA.push(":checked");
  1959.         }
  1960.         if (!container.querySelectorAll("a#" + expando + "+*").length) {
  1961.           rbuggyQSA.push(".#.+[+~]");
  1962.         }
  1963.         container.querySelectorAll("\\\f");
  1964.         rbuggyQSA.push("[\\r\\n\\f]");
  1965.       }), assert(function(el) {
  1966.         /** @type {string} */
  1967.         el.innerHTML = "<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";
  1968.         var input = document.createElement("input");
  1969.         input.setAttribute("type", "hidden");
  1970.         el.appendChild(input).setAttribute("name", "D");
  1971.         if (el.querySelectorAll("[name=d]").length) {
  1972.           rbuggyQSA.push("name" + _test + "*[*^$|!~]?=");
  1973.         }
  1974.         if (2 !== el.querySelectorAll(":enabled").length) {
  1975.           rbuggyQSA.push(":enabled", ":disabled");
  1976.         }
  1977.         /** @type {boolean} */
  1978.         docElem.appendChild(el).disabled = true;
  1979.         if (2 !== el.querySelectorAll(":disabled").length) {
  1980.           rbuggyQSA.push(":enabled", ":disabled");
  1981.         }
  1982.         el.querySelectorAll("*,:x");
  1983.         rbuggyQSA.push(",.*:");
  1984.       })), (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) && assert(function(el) {
  1985.         support.disconnectedMatch = matches.call(el, "*");
  1986.         matches.call(el, "[s!='']:x");
  1987.         rbuggyMatches.push("!=", pseudos);
  1988.       }), rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")), rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")), init = rnative.test(docElem.compareDocumentPosition), contains = init || rnative.test(docElem.contains) ? function(a, n) {
  1989.         var name = 9 === a.nodeType ? a.documentElement : a;
  1990.         var b = n && n.parentNode;
  1991.         return a === b || !(!b || 1 !== b.nodeType || !(name.contains ? name.contains(b) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(b)));
  1992.       } : function(selector, elem) {
  1993.         if (elem) {
  1994.           for (; elem = elem.parentNode;) {
  1995.             if (elem === selector) {
  1996.               return true;
  1997.             }
  1998.           }
  1999.         }
  2000.         return false;
  2001.       }, time = init ? function(a, b) {
  2002.         if (a === b) {
  2003.           return ret = true, 0;
  2004.         }
  2005.         /** @type {number} */
  2006.         var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  2007.         return compare || (1 & (compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1) || !support.sortDetached && b.compareDocumentPosition(a) === compare ? a == document || a.ownerDocument == el && contains(el, a) ? -1 : b == document || b.ownerDocument == el && contains(el, b) ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0 : 4 & compare ? -1 : 1);
  2008.       } : function(a, b) {
  2009.         if (a === b) {
  2010.           return ret = true, 0;
  2011.         }
  2012.         var cur;
  2013.         /** @type {number} */
  2014.         var i = 0;
  2015.         var aup = a.parentNode;
  2016.         var bup = b.parentNode;
  2017.         /** @type {!Array} */
  2018.         var ap = [a];
  2019.         /** @type {!Array} */
  2020.         var bp = [b];
  2021.         if (!aup || !bup) {
  2022.           return a == document ? -1 : b == document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
  2023.         }
  2024.         if (aup === bup) {
  2025.           return siblingCheck(a, b);
  2026.         }
  2027.         /** @type {!HTMLElement} */
  2028.         cur = a;
  2029.         for (; cur = cur.parentNode;) {
  2030.           ap.unshift(cur);
  2031.         }
  2032.         /** @type {!HTMLElement} */
  2033.         cur = b;
  2034.         for (; cur = cur.parentNode;) {
  2035.           bp.unshift(cur);
  2036.         }
  2037.         for (; ap[i] === bp[i];) {
  2038.           i++;
  2039.         }
  2040.         return i ? siblingCheck(ap[i], bp[i]) : ap[i] == el ? -1 : bp[i] == el ? 1 : 0;
  2041.       }), document;
  2042.     }, Sizzle.matches = function(expr, set) {
  2043.       return Sizzle(expr, null, null, set);
  2044.     }, Sizzle.matchesSelector = function(elem, expr) {
  2045.       if (setDocument(elem), support.matchesSelector && documentIsHTML && !isUndefined[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
  2046.         try {
  2047.           var ret = matches.call(elem, expr);
  2048.           if (ret || support.disconnectedMatch || elem.document && 11 !== elem.document.nodeType) {
  2049.             return ret;
  2050.           }
  2051.         } catch (e) {
  2052.           isUndefined(expr, true);
  2053.         }
  2054.       }
  2055.       return 0 < Sizzle(expr, document, null, [elem]).length;
  2056.     }, Sizzle.contains = function(context, value) {
  2057.       return (context.ownerDocument || context) != document && setDocument(context), contains(context, value);
  2058.     }, Sizzle.attr = function(elem, name) {
  2059.       if ((elem.ownerDocument || elem) != document) {
  2060.         setDocument(elem);
  2061.       }
  2062.       var fn = Expr.attrHandle[name.toLowerCase()];
  2063.       var val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
  2064.       return void 0 !== val ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2065.     }, Sizzle.escape = function(text) {
  2066.       return (text + "").replace(rcssescape, fcssescape);
  2067.     }, Sizzle.error = function(value) {
  2068.       throw new Error("Syntax error, unrecognized expression: " + value);
  2069.     }, Sizzle.uniqueSort = function(arr) {
  2070.       var x;
  2071.       /** @type {!Array} */
  2072.       var p = [];
  2073.       /** @type {number} */
  2074.       var j = 0;
  2075.       /** @type {number} */
  2076.       var i = 0;
  2077.       if (ret = !support.detectDuplicates, sortInput = !support.sortStable && arr.slice(0), arr.sort(time), ret) {
  2078.         for (; x = arr[i++];) {
  2079.           if (x === arr[i]) {
  2080.             /** @type {number} */
  2081.             j = p.push(i);
  2082.           }
  2083.         }
  2084.         for (; j--;) {
  2085.           arr.splice(p[j], 1);
  2086.         }
  2087.       }
  2088.       return sortInput = null, arr;
  2089.     }, $ = Sizzle.getText = function(d) {
  2090.       var b;
  2091.       /** @type {string} */
  2092.       var s = "";
  2093.       /** @type {number} */
  2094.       var e = 0;
  2095.       var type = d.nodeType;
  2096.       if (type) {
  2097.         if (1 === type || 9 === type || 11 === type) {
  2098.           if ("string" == typeof d.textContent) {
  2099.             return d.textContent;
  2100.           }
  2101.           d = d.firstChild;
  2102.           for (; d; d = d.nextSibling) {
  2103.             s = s + $(d);
  2104.           }
  2105.         } else {
  2106.           if (3 === type || 4 === type) {
  2107.             return d.nodeValue;
  2108.           }
  2109.         }
  2110.       } else {
  2111.         for (; b = d[e++];) {
  2112.           s = s + $(b);
  2113.         }
  2114.       }
  2115.       return s;
  2116.     }, (Expr = Sizzle.selectors = {
  2117.       cacheLength : 50,
  2118.       createPseudo : markFunction,
  2119.       match : matchExpr,
  2120.       attrHandle : {},
  2121.       find : {},
  2122.       relative : {
  2123.         ">" : {
  2124.           dir : "parentNode",
  2125.           first : true
  2126.         },
  2127.         " " : {
  2128.           dir : "parentNode"
  2129.         },
  2130.         "+" : {
  2131.           dir : "previousSibling",
  2132.           first : true
  2133.         },
  2134.         "~" : {
  2135.           dir : "previousSibling"
  2136.         }
  2137.       },
  2138.       preFilter : {
  2139.         ATTR : function(result) {
  2140.           return result[1] = result[1].replace(a, data), result[3] = (result[3] || result[4] || result[5] || "").replace(a, data), "~=" === result[2] && (result[3] = " " + result[3] + " "), result.slice(0, 4);
  2141.         },
  2142.         CHILD : function(match) {
  2143.           return match[1] = match[1].toLowerCase(), "nth" === match[1].slice(0, 3) ? (match[3] || Sizzle.error(match[0]), match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * ("even" === match[3] || "odd" === match[3])), match[5] = +(match[7] + match[8] || "odd" === match[3])) : match[3] && Sizzle.error(match[0]), match;
  2144.         },
  2145.         PSEUDO : function(match) {
  2146.           var excess;
  2147.           var unquoted = !match[6] && match[2];
  2148.           return matchExpr.CHILD.test(match[0]) ? null : (match[3] ? match[2] = match[4] || match[5] || "" : unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length) && (match[0] = match[0].slice(0, excess), match[2] = unquoted.slice(0, excess)), match.slice(0, 3));
  2149.         }
  2150.       },
  2151.       filter : {
  2152.         TAG : function(elem) {
  2153.           var nodeName = elem.replace(a, data).toLowerCase();
  2154.           return "*" === elem ? function() {
  2155.             return true;
  2156.           } : function(elem) {
  2157.             return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  2158.           };
  2159.         },
  2160.         CLASS : function(className) {
  2161.           var pattern = classCache[className + " "];
  2162.           return pattern || (pattern = new RegExp("(^|" + _test + ")" + className + "(" + _test + "|$)")) && classCache(className, function(e) {
  2163.             return pattern.test("string" == typeof e.className && e.className || "undefined" != typeof e.getAttribute && e.getAttribute("class") || "");
  2164.           });
  2165.         },
  2166.         ATTR : function(name, string, value) {
  2167.           return function(elem) {
  2168.             var key = Sizzle.attr(elem, name);
  2169.             return null == key ? "!=" === string : !string || (key = key + "", "=" === string ? key === value : "!=" === string ? key !== value : "^=" === string ? value && 0 === key.indexOf(value) : "*=" === string ? value && -1 < key.indexOf(value) : "$=" === string ? value && key.slice(-value.length) === value : "~=" === string ? -1 < (" " + key.replace(entityEscapeRegExp, " ") + " ").indexOf(value) : "|=" === string && (key === value || key.slice(0, value.length + 1) === value + "-"));
  2170.           };
  2171.         },
  2172.         CHILD : function(type, what, argument, first, last) {
  2173.           /** @type {boolean} */
  2174.           var simple = "nth" !== type.slice(0, 3);
  2175.           /** @type {boolean} */
  2176.           var forward = "last" !== type.slice(-4);
  2177.           /** @type {boolean} */
  2178.           var ofType = "of-type" === what;
  2179.           return 1 === first && 0 === last ? function(tplDiv) {
  2180.             return !!tplDiv.parentNode;
  2181.           } : function(elem, canCreateDiscussions, xml) {
  2182.             var cache;
  2183.             var uniqueCache;
  2184.             var outerCache;
  2185.             var node;
  2186.             var nodeIndex;
  2187.             var start;
  2188.             /** @type {string} */
  2189.             var dir = simple !== forward ? "nextSibling" : "previousSibling";
  2190.             var parent = elem.parentNode;
  2191.             var name = ofType && elem.nodeName.toLowerCase();
  2192.             /** @type {boolean} */
  2193.             var dependency = !xml && !ofType;
  2194.             /** @type {boolean} */
  2195.             var diff = false;
  2196.             if (parent) {
  2197.               if (simple) {
  2198.                 for (; dir;) {
  2199.                   /** @type {!Node} */
  2200.                   node = elem;
  2201.                   for (; node = node[dir];) {
  2202.                     if (ofType ? node.nodeName.toLowerCase() === name : 1 === node.nodeType) {
  2203.                       return false;
  2204.                     }
  2205.                   }
  2206.                   /** @type {(boolean|string)} */
  2207.                   start = dir = "only" === type && !start && "nextSibling";
  2208.                 }
  2209.                 return true;
  2210.               }
  2211.               if (start = [forward ? parent.firstChild : parent.lastChild], forward && dependency) {
  2212.                 diff = (nodeIndex = (cache = (uniqueCache = (outerCache = (node = parent)[expando] || (node[expando] = {}))[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] || [])[0] === dirruns && cache[1]) && cache[2];
  2213.                 node = nodeIndex && parent.childNodes[nodeIndex];
  2214.                 for (; node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop();) {
  2215.                   if (1 === node.nodeType && ++diff && node === elem) {
  2216.                     /** @type {!Array} */
  2217.                     uniqueCache[type] = [dirruns, nodeIndex, diff];
  2218.                     break;
  2219.                   }
  2220.                 }
  2221.               } else {
  2222.                 if (dependency && (diff = nodeIndex = (cache = (uniqueCache = (outerCache = (node = elem)[expando] || (node[expando] = {}))[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] || [])[0] === dirruns && cache[1]), false === diff) {
  2223.                   for (; node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop();) {
  2224.                     if ((ofType ? node.nodeName.toLowerCase() === name : 1 === node.nodeType) && ++diff && (dependency && ((uniqueCache = (outerCache = node[expando] || (node[expando] = {}))[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] = [dirruns, diff]), node === elem)) {
  2225.                       break;
  2226.                     }
  2227.                   }
  2228.                 }
  2229.               }
  2230.               return (diff = diff - last) === first || diff % first == 0 && 0 <= diff / first;
  2231.             }
  2232.           };
  2233.         },
  2234.         PSEUDO : function(pseudo, argument) {
  2235.           var args;
  2236.           var fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
  2237.           return fn[expando] ? fn(argument) : 1 < fn.length ? (args = [pseudo, pseudo, "", argument], Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, result) {
  2238.             var j;
  2239.             var matched = fn(seed, argument);
  2240.             var i = matched.length;
  2241.             for (; i--;) {
  2242.               /** @type {boolean} */
  2243.               seed[j = indexOf(seed, matched[i])] = !(result[j] = matched[i]);
  2244.             }
  2245.           }) : function(responce) {
  2246.             return fn(responce, 0, args);
  2247.           }) : fn;
  2248.         }
  2249.       },
  2250.       pseudos : {
  2251.         not : markFunction(function(selector) {
  2252.           /** @type {!Array} */
  2253.           var a = [];
  2254.           /** @type {!Array} */
  2255.           var results = [];
  2256.           var matcher = compile(selector.replace(rtrim, "$1"));
  2257.           return matcher[expando] ? markFunction(function(a, queue, n, context) {
  2258.             var bundle;
  2259.             var result = matcher(a, null, context, []);
  2260.             var i = a.length;
  2261.             for (; i--;) {
  2262.               if (bundle = result[i]) {
  2263.                 /** @type {boolean} */
  2264.                 a[i] = !(queue[i] = bundle);
  2265.               }
  2266.             }
  2267.           }) : function(sNewObjName, isSlidingUp, context) {
  2268.             return a[0] = sNewObjName, matcher(a, null, context, results), a[0] = null, !results.pop();
  2269.           };
  2270.         }),
  2271.         has : markFunction(function(selector) {
  2272.           return function(elem) {
  2273.             return 0 < Sizzle(selector, elem).length;
  2274.           };
  2275.         }),
  2276.         contains : markFunction(function(text) {
  2277.           return text = text.replace(a, data), function(element) {
  2278.             return -1 < (element.textContent || $(element)).indexOf(text);
  2279.           };
  2280.         }),
  2281.         lang : markFunction(function(lang) {
  2282.           return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(a, data).toLowerCase(), function(elem) {
  2283.             var elemLang;
  2284.             do {
  2285.               if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
  2286.                 return (elemLang = elemLang.toLowerCase()) === lang || 0 === elemLang.indexOf(lang + "-");
  2287.               }
  2288.             } while ((elem = elem.parentNode) && 1 === elem.nodeType);
  2289.             return false;
  2290.           };
  2291.         }),
  2292.         target : function(key) {
  2293.           var charListNotLatin = options.location && options.location.hash;
  2294.           return charListNotLatin && charListNotLatin.slice(1) === key.id;
  2295.         },
  2296.         root : function(elem) {
  2297.           return elem === docElem;
  2298.         },
  2299.         focus : function(elem) {
  2300.           return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  2301.         },
  2302.         enabled : createDisabledPseudo(false),
  2303.         disabled : createDisabledPseudo(true),
  2304.         checked : function(elem) {
  2305.           var custom = elem.nodeName.toLowerCase();
  2306.           return "input" === custom && !!elem.checked || "option" === custom && !!elem.selected;
  2307.         },
  2308.         selected : function(elem) {
  2309.           return elem.parentNode && elem.parentNode.selectedIndex, true === elem.selected;
  2310.         },
  2311.         empty : function(elem) {
  2312.           elem = elem.firstChild;
  2313.           for (; elem; elem = elem.nextSibling) {
  2314.             if (elem.nodeType < 6) {
  2315.               return false;
  2316.             }
  2317.           }
  2318.           return true;
  2319.         },
  2320.         parent : function(elem) {
  2321.           return !Expr.pseudos.empty(elem);
  2322.         },
  2323.         header : function(elem) {
  2324.           return rnoType.test(elem.nodeName);
  2325.         },
  2326.         input : function(target) {
  2327.           return inputNodeNames.test(target.nodeName);
  2328.         },
  2329.         button : function(elem) {
  2330.           var left = elem.nodeName.toLowerCase();
  2331.           return "input" === left && "button" === elem.type || "button" === left;
  2332.         },
  2333.         text : function(elem) {
  2334.           var EXT;
  2335.           return "input" === elem.nodeName.toLowerCase() && "text" === elem.type && (null == (EXT = elem.getAttribute("type")) || "text" === EXT.toLowerCase());
  2336.         },
  2337.         first : createPositionalPseudo(function() {
  2338.           return [0];
  2339.         }),
  2340.         last : createPositionalPseudo(function(canCreateDiscussions, isSlidingUp) {
  2341.           return [isSlidingUp - 1];
  2342.         }),
  2343.         eq : createPositionalPseudo(function(canCreateDiscussions, pageHeight, srcY) {
  2344.           return [srcY < 0 ? srcY + pageHeight : srcY];
  2345.         }),
  2346.         even : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
  2347.           /** @type {number} */
  2348.           var value = 0;
  2349.           for (; value < inclusiveMin; value = value + 2) {
  2350.             lastshuffle.push(value);
  2351.           }
  2352.           return lastshuffle;
  2353.         }),
  2354.         odd : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
  2355.           /** @type {number} */
  2356.           var value = 1;
  2357.           for (; value < inclusiveMin; value = value + 2) {
  2358.             lastshuffle.push(value);
  2359.           }
  2360.           return lastshuffle;
  2361.         }),
  2362.         lt : createPositionalPseudo(function(newNodeLists, total, n) {
  2363.           var itemNodeList = n < 0 ? n + total : total < n ? total : n;
  2364.           for (; 0 <= --itemNodeList;) {
  2365.             newNodeLists.push(itemNodeList);
  2366.           }
  2367.           return newNodeLists;
  2368.         }),
  2369.         gt : createPositionalPseudo(function(newNodeLists, pageHeight, srcY) {
  2370.           var itemNodeList = srcY < 0 ? srcY + pageHeight : srcY;
  2371.           for (; ++itemNodeList < pageHeight;) {
  2372.             newNodeLists.push(itemNodeList);
  2373.           }
  2374.           return newNodeLists;
  2375.         })
  2376.       }
  2377.     }).pseudos.nth = Expr.pseudos.eq, {
  2378.       radio : true,
  2379.       checkbox : true,
  2380.       file : true,
  2381.       password : true,
  2382.       image : true
  2383.     }) {
  2384.       Expr.pseudos[i] = jQuerify(i);
  2385.     }
  2386.     for (i in{
  2387.       submit : true,
  2388.       reset : true
  2389.     }) {
  2390.       Expr.pseudos[i] = createButtonPseudo(i);
  2391.     }
  2392.     return setFilters.prototype = Expr.filters = Expr.pseudos, Expr.setFilters = new setFilters, tokenize = Sizzle.tokenize = function(selector, parseOnly) {
  2393.       var matched;
  2394.       var match;
  2395.       var tokens;
  2396.       var type;
  2397.       var soFar;
  2398.       var groups;
  2399.       var preFilters;
  2400.       var cached = tokenCache[selector + " "];
  2401.       if (cached) {
  2402.         return parseOnly ? 0 : cached.slice(0);
  2403.       }
  2404.       /** @type {string} */
  2405.       soFar = selector;
  2406.       /** @type {!Array} */
  2407.       groups = [];
  2408.       preFilters = Expr.preFilter;
  2409.       for (; soFar;) {
  2410.         for (type in matched && !(match = chunker.exec(soFar)) || (match && (soFar = soFar.slice(match[0].length) || soFar), groups.push(tokens = [])), matched = false, (match = pattern.exec(soFar)) && (matched = match.shift(), tokens.push({
  2411.           value : matched,
  2412.           type : match[0].replace(rtrim, " ")
  2413.         }), soFar = soFar.slice(matched.length)), Expr.filter) {
  2414.           if (!(!(match = matchExpr[type].exec(soFar)) || preFilters[type] && !(match = preFilters[type](match)))) {
  2415.             matched = match.shift();
  2416.             tokens.push({
  2417.               value : matched,
  2418.               type : type,
  2419.               matches : match
  2420.             });
  2421.             soFar = soFar.slice(matched.length);
  2422.           }
  2423.         }
  2424.         if (!matched) {
  2425.           break;
  2426.         }
  2427.       }
  2428.       return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
  2429.     }, compile = Sizzle.compile = function(selector, group) {
  2430.       var i;
  2431.       var elementMatchers;
  2432.       var setMatchers;
  2433.       var bySet;
  2434.       var byElement;
  2435.       var superMatcher;
  2436.       /** @type {!Array} */
  2437.       var res = [];
  2438.       /** @type {!Array} */
  2439.       var cacheStore = [];
  2440.       var cached = compilerCache[selector + " "];
  2441.       if (!cached) {
  2442.         if (!group) {
  2443.           group = tokenize(selector);
  2444.         }
  2445.         i = group.length;
  2446.         for (; i--;) {
  2447.           if ((cached = matcherFromTokens(group[i]))[expando]) {
  2448.             res.push(cached);
  2449.           } else {
  2450.             cacheStore.push(cached);
  2451.           }
  2452.         }
  2453.         /** @type {string} */
  2454.         (cached = compilerCache(selector, (elementMatchers = cacheStore, bySet = 0 < (setMatchers = res).length, byElement = 0 < elementMatchers.length, superMatcher = function(seed, context, xml, results, outermost) {
  2455.           var elem;
  2456.           var j;
  2457.           var matcher;
  2458.           /** @type {number} */
  2459.           var matchedCount = 0;
  2460.           /** @type {string} */
  2461.           var i = "0";
  2462.           var unmatched = seed && [];
  2463.           /** @type {!Array} */
  2464.           var data = [];
  2465.           var contextBackup = outermostContext;
  2466.           var elems = seed || byElement && Expr.find.TAG("*", outermost);
  2467.           var dirrunsUnique = dirruns = dirruns + (null == contextBackup ? 1 : Math.random() || .1);
  2468.           var length = elems.length;
  2469.           if (outermost) {
  2470.             outermostContext = context == document || context || outermost;
  2471.           }
  2472.           for (; i !== length && null != (elem = elems[i]); i++) {
  2473.             if (byElement && elem) {
  2474.               /** @type {number} */
  2475.               j = 0;
  2476.               if (!(context || elem.ownerDocument == document)) {
  2477.                 setDocument(elem);
  2478.                 /** @type {boolean} */
  2479.                 xml = !documentIsHTML;
  2480.               }
  2481.               for (; matcher = elementMatchers[j++];) {
  2482.                 if (matcher(elem, context || document, xml)) {
  2483.                   results.push(elem);
  2484.                   break;
  2485.                 }
  2486.               }
  2487.               if (outermost) {
  2488.                 dirruns = dirrunsUnique;
  2489.               }
  2490.             }
  2491.             if (bySet) {
  2492.               if (elem = !matcher && elem) {
  2493.                 matchedCount--;
  2494.               }
  2495.               if (seed) {
  2496.                 unmatched.push(elem);
  2497.               }
  2498.             }
  2499.           }
  2500.           if (matchedCount = matchedCount + i, bySet && i !== matchedCount) {
  2501.             /** @type {number} */
  2502.             j = 0;
  2503.             for (; matcher = setMatchers[j++];) {
  2504.               matcher(unmatched, data, context, xml);
  2505.             }
  2506.             if (seed) {
  2507.               if (0 < matchedCount) {
  2508.                 for (; i--;) {
  2509.                   if (!(unmatched[i] || data[i])) {
  2510.                     data[i] = pop.call(results);
  2511.                   }
  2512.                 }
  2513.               }
  2514.               data = parse(data);
  2515.             }
  2516.             push.apply(results, data);
  2517.             if (outermost && !seed && 0 < data.length && 1 < matchedCount + setMatchers.length) {
  2518.               Sizzle.uniqueSort(results);
  2519.             }
  2520.           }
  2521.           return outermost && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
  2522.         }, bySet ? markFunction(superMatcher) : superMatcher))).selector = selector;
  2523.       }
  2524.       return cached;
  2525.     }, select = Sizzle.select = function(selector, context, results, seed) {
  2526.       var i;
  2527.       var tokens;
  2528.       var token;
  2529.       var type;
  2530.       var f;
  2531.       /** @type {(!Function|boolean)} */
  2532.       var compiled = "function" == typeof selector && selector;
  2533.       var match = !seed && tokenize(selector = compiled.selector || selector);
  2534.       if (results = results || [], 1 === match.length) {
  2535.         if (2 < (tokens = match[0] = match[0].slice(0)).length && "ID" === (token = tokens[0]).type && 9 === context.nodeType && documentIsHTML && Expr.relative[tokens[1].type]) {
  2536.           if (!(context = (Expr.find.ID(token.matches[0].replace(a, data), context) || [])[0])) {
  2537.             return results;
  2538.           }
  2539.           if (compiled) {
  2540.             context = context.parentNode;
  2541.           }
  2542.           selector = selector.slice(tokens.shift().value.length);
  2543.         }
  2544.         i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
  2545.         for (; i--;) {
  2546.           if (token = tokens[i], Expr.relative[type = token.type]) {
  2547.             break;
  2548.           }
  2549.           if ((f = Expr.find[type]) && (seed = f(token.matches[0].replace(a, data), IS_HTML_FRAGMENT.test(tokens[0].type) && testContext(context.parentNode) || context))) {
  2550.             if (tokens.splice(i, 1), !(selector = seed.length && toSelector(tokens))) {
  2551.               return push.apply(results, seed), results;
  2552.             }
  2553.             break;
  2554.           }
  2555.         }
  2556.       }
  2557.       return (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || IS_HTML_FRAGMENT.test(selector) && testContext(context.parentNode) || context), results;
  2558.     }, support.sortStable = expando.split("").sort(time).join("") === expando, support.detectDuplicates = !!ret, setDocument(), support.sortDetached = assert(function(html) {
  2559.       return 1 & html.compareDocumentPosition(document.createElement("fieldset"));
  2560.     }), assert(function(aItem) {
  2561.       return aItem.innerHTML = "<a href='#'></a>", "#" === aItem.firstChild.getAttribute("href");
  2562.     }) || addHandle("type|href|height|width", function(e, t, n) {
  2563.       if (!n) {
  2564.         return e.getAttribute(t, "type" === t.toLowerCase() ? 1 : 2);
  2565.       }
  2566.     }), support.attributes && assert(function(aItem) {
  2567.       return aItem.innerHTML = "<input/>", aItem.firstChild.setAttribute("value", ""), "" === aItem.firstChild.getAttribute("value");
  2568.     }) || addHandle("value", function(src, canCreateDiscussions, n) {
  2569.       if (!n && "input" === src.nodeName.toLowerCase()) {
  2570.         return src.defaultValue;
  2571.       }
  2572.     }), assert(function(e) {
  2573.       return null == e.getAttribute("disabled");
  2574.     }) || addHandle(value, function(elem, name, n) {
  2575.       var val;
  2576.       if (!n) {
  2577.         return true === elem[name] ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2578.       }
  2579.     }), Sizzle;
  2580.   }(window);
  2581.   jQuery.find = Sizzle;
  2582.   jQuery.expr = Sizzle.selectors;
  2583.   jQuery.expr[":"] = jQuery.expr.pseudos;
  2584.   jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
  2585.   jQuery.text = Sizzle.getText;
  2586.   jQuery.isXMLDoc = Sizzle.isXML;
  2587.   jQuery.contains = Sizzle.contains;
  2588.   jQuery.escapeSelector = Sizzle.escape;
  2589.   /**
  2590.    * @param {?} elem
  2591.    * @param {string} dir
  2592.    * @param {?} until
  2593.    * @return {?}
  2594.    */
  2595.   var dir = function(elem, dir, until) {
  2596.     /** @type {!Array} */
  2597.     var matched = [];
  2598.     /** @type {boolean} */
  2599.     var truncate = void 0 !== until;
  2600.     for (; (elem = elem[dir]) && 9 !== elem.nodeType;) {
  2601.       if (1 === elem.nodeType) {
  2602.         if (truncate && jQuery(elem).is(until)) {
  2603.           break;
  2604.         }
  2605.         matched.push(elem);
  2606.       }
  2607.     }
  2608.     return matched;
  2609.   };
  2610.   /**
  2611.    * @param {!Object} node
  2612.    * @param {!Object} elem
  2613.    * @return {?}
  2614.    */
  2615.   var _sibling = function(node, elem) {
  2616.     /** @type {!Array} */
  2617.     var result = [];
  2618.     for (; node; node = node.nextSibling) {
  2619.       if (1 === node.nodeType && node !== elem) {
  2620.         result.push(node);
  2621.       }
  2622.     }
  2623.     return result;
  2624.   };
  2625.   var rneedsContext = jQuery.expr.match.needsContext;
  2626.   /** @type {!RegExp} */
  2627.   var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
  2628.   /**
  2629.    * @param {string} expr
  2630.    * @param {!Array} elems
  2631.    * @param {string} not
  2632.    * @return {?}
  2633.    */
  2634.   jQuery.filter = function(expr, elems, not) {
  2635.     var elem = elems[0];
  2636.     return not && (expr = ":not(" + expr + ")"), 1 === elems.length && 1 === elem.nodeType ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function(nodeToInspect) {
  2637.       return 1 === nodeToInspect.nodeType;
  2638.     }));
  2639.   };
  2640.   jQuery.fn.extend({
  2641.     find : function(elem) {
  2642.       var i;
  2643.       var ret;
  2644.       var l = this.length;
  2645.       var self = this;
  2646.       if ("string" != typeof elem) {
  2647.         return this.pushStack(jQuery(elem).filter(function() {
  2648.           /** @type {number} */
  2649.           i = 0;
  2650.           for (; i < l; i++) {
  2651.             if (jQuery.contains(self[i], this)) {
  2652.               return true;
  2653.             }
  2654.           }
  2655.         }));
  2656.       }
  2657.       ret = this.pushStack([]);
  2658.       /** @type {number} */
  2659.       i = 0;
  2660.       for (; i < l; i++) {
  2661.         jQuery.find(elem, self[i], ret);
  2662.       }
  2663.       return 1 < l ? jQuery.uniqueSort(ret) : ret;
  2664.     },
  2665.     filter : function(val) {
  2666.       return this.pushStack(filter(this, val || [], false));
  2667.     },
  2668.     not : function(args) {
  2669.       return this.pushStack(filter(this, args || [], true));
  2670.     },
  2671.     is : function(arg) {
  2672.       return !!filter(this, "string" == typeof arg && rneedsContext.test(arg) ? jQuery(arg) : arg || [], false).length;
  2673.     }
  2674.   });
  2675.   var rootjQuery;
  2676.   /** @type {!RegExp} */
  2677.   var customSelectorReg = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;
  2678.   (jQuery.fn.init = function(selector, context, root) {
  2679.     var match;
  2680.     var i;
  2681.     if (!selector) {
  2682.       return this;
  2683.     }
  2684.     if (root = root || rootjQuery, "string" == typeof selector) {
  2685.       if (!(match = "<" === selector[0] && ">" === selector[selector.length - 1] && 3 <= selector.length ? [null, selector, null] : customSelectorReg.exec(selector)) || !match[1] && context) {
  2686.         return !context || context.jquery ? (context || root).find(selector) : this.constructor(context).find(selector);
  2687.       }
  2688.       if (match[1]) {
  2689.         if (context = context instanceof jQuery ? context[0] : context, jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
  2690.           for (match in context) {
  2691.             if (fn(this[match])) {
  2692.               this[match](context[match]);
  2693.             } else {
  2694.               this.attr(match, context[match]);
  2695.             }
  2696.           }
  2697.         }
  2698.         return this;
  2699.       }
  2700.       return (i = document.getElementById(match[2])) && (this[0] = i, this.length = 1), this;
  2701.     }
  2702.     return selector.nodeType ? (this[0] = selector, this.length = 1, this) : fn(selector) ? void 0 !== root.ready ? root.ready(selector) : selector(jQuery) : jQuery.makeArray(selector, this);
  2703.   }).prototype = jQuery.fn;
  2704.   rootjQuery = jQuery(document);
  2705.   /** @type {!RegExp} */
  2706.   var testRxp = /^(?:parents|prev(?:Until|All))/;
  2707.   var guaranteedUnique = {
  2708.     children : true,
  2709.     contents : true,
  2710.     next : true,
  2711.     prev : true
  2712.   };
  2713.   jQuery.fn.extend({
  2714.     has : function(name) {
  2715.       var targets = jQuery(name, this);
  2716.       var l = targets.length;
  2717.       return this.filter(function() {
  2718.         /** @type {number} */
  2719.         var i = 0;
  2720.         for (; i < l; i++) {
  2721.           if (jQuery.contains(this, targets[i])) {
  2722.             return true;
  2723.           }
  2724.         }
  2725.       });
  2726.     },
  2727.     closest : function(selector, context) {
  2728.       var cur;
  2729.       /** @type {number} */
  2730.       var i = 0;
  2731.       var l = this.length;
  2732.       /** @type {!Array} */
  2733.       var ret = [];
  2734.       var pos = "string" != typeof selector && jQuery(selector);
  2735.       if (!rneedsContext.test(selector)) {
  2736.         for (; i < l; i++) {
  2737.           cur = this[i];
  2738.           for (; cur && cur !== context; cur = cur.parentNode) {
  2739.             if (cur.nodeType < 11 && (pos ? -1 < pos.index(cur) : 1 === cur.nodeType && jQuery.find.matchesSelector(cur, selector))) {
  2740.               ret.push(cur);
  2741.               break;
  2742.             }
  2743.           }
  2744.         }
  2745.       }
  2746.       return this.pushStack(1 < ret.length ? jQuery.uniqueSort(ret) : ret);
  2747.     },
  2748.     index : function(elem) {
  2749.       return elem ? "string" == typeof elem ? indexOf.call(jQuery(elem), this[0]) : indexOf.call(this, elem.jquery ? elem[0] : elem) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
  2750.     },
  2751.     add : function(elem, context) {
  2752.       return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(elem, context))));
  2753.     },
  2754.     addBack : function(selector) {
  2755.       return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
  2756.     }
  2757.   });
  2758.   jQuery.each({
  2759.     parent : function(object) {
  2760.       var n = object.parentNode;
  2761.       return n && 11 !== n.nodeType ? n : null;
  2762.     },
  2763.     parents : function(elem) {
  2764.       return dir(elem, "parentNode");
  2765.     },
  2766.     parentsUntil : function(elem, i, until) {
  2767.       return dir(elem, "parentNode", until);
  2768.     },
  2769.     next : function(elem) {
  2770.       return sibling(elem, "nextSibling");
  2771.     },
  2772.     prev : function(elem) {
  2773.       return sibling(elem, "previousSibling");
  2774.     },
  2775.     nextAll : function(elem) {
  2776.       return dir(elem, "nextSibling");
  2777.     },
  2778.     prevAll : function(elem) {
  2779.       return dir(elem, "previousSibling");
  2780.     },
  2781.     nextUntil : function(elem, i, until) {
  2782.       return dir(elem, "nextSibling", until);
  2783.     },
  2784.     prevUntil : function(elem, i, until) {
  2785.       return dir(elem, "previousSibling", until);
  2786.     },
  2787.     siblings : function(elem) {
  2788.       return _sibling((elem.parentNode || {}).firstChild, elem);
  2789.     },
  2790.     children : function(elem) {
  2791.       return _sibling(elem.firstChild);
  2792.     },
  2793.     contents : function(elem) {
  2794.       return null != elem.contentDocument && getProto(elem.contentDocument) ? elem.contentDocument : (callback(elem, "template") && (elem = elem.content || elem), jQuery.merge([], elem.childNodes));
  2795.     }
  2796.   }, function(name, i) {
  2797.     /**
  2798.      * @param {boolean} index
  2799.      * @param {boolean} target
  2800.      * @return {?}
  2801.      */
  2802.     jQuery.fn[name] = function(index, target) {
  2803.       var ret = jQuery.map(this, i, index);
  2804.       return "Until" !== name.slice(-5) && (target = index), target && "string" == typeof target && (ret = jQuery.filter(target, ret)), 1 < this.length && (guaranteedUnique[name] || jQuery.uniqueSort(ret), testRxp.test(name) && ret.reverse()), this.pushStack(ret);
  2805.     };
  2806.   });
  2807.   /** @type {!RegExp} */
  2808.   var re = /[^\x20\t\r\n\f]+/g;
  2809.   /**
  2810.    * @param {string} options
  2811.    * @return {?}
  2812.    */
  2813.   jQuery.Callbacks = function(options) {
  2814.     var o;
  2815.     var s;
  2816.     options = "string" == typeof options ? (o = options, s = {}, jQuery.each(o.match(re) || [], function(canCreateDiscussions, $token) {
  2817.       /** @type {boolean} */
  2818.       s[$token] = true;
  2819.     }), s) : jQuery.extend({}, options);
  2820.     var callback;
  2821.     var c;
  2822.     var req;
  2823.     var data;
  2824.     /** @type {!Array} */
  2825.     var b = [];
  2826.     /** @type {!Array} */
  2827.     var d = [];
  2828.     /** @type {number} */
  2829.     var k = -1;
  2830.     /**
  2831.      * @return {undefined}
  2832.      */
  2833.     var fire = function() {
  2834.       data = data || options.once;
  2835.       /** @type {boolean} */
  2836.       req = callback = true;
  2837.       for (; d.length; k = -1) {
  2838.         c = d.shift();
  2839.         for (; ++k < b.length;) {
  2840.           if (false === b[k].apply(c[0], c[1]) && options.stopOnFalse) {
  2841.             k = b.length;
  2842.             /** @type {boolean} */
  2843.             c = false;
  2844.           }
  2845.         }
  2846.       }
  2847.       if (!options.memory) {
  2848.         /** @type {boolean} */
  2849.         c = false;
  2850.       }
  2851.       /** @type {boolean} */
  2852.       callback = false;
  2853.       if (data) {
  2854.         /** @type {(Array|string)} */
  2855.         b = c ? [] : "";
  2856.       }
  2857.     };
  2858.     var self = {
  2859.       add : function() {
  2860.         return b && (c && !callback && (k = b.length - 1, d.push(c)), function add(callback) {
  2861.           jQuery.each(callback, function(canCreateDiscussions, name) {
  2862.             if (fn(name)) {
  2863.               if (!(options.unique && self.has(name))) {
  2864.                 b.push(name);
  2865.               }
  2866.             } else {
  2867.               if (name && name.length && "string" !== type(name)) {
  2868.                 add(name);
  2869.               }
  2870.             }
  2871.           });
  2872.         }(arguments), c && !callback && fire()), this;
  2873.       },
  2874.       remove : function() {
  2875.         return jQuery.each(arguments, function(canCreateDiscussions, t) {
  2876.           var i;
  2877.           for (; -1 < (i = jQuery.inArray(t, b, i));) {
  2878.             b.splice(i, 1);
  2879.             if (i <= k) {
  2880.               k--;
  2881.             }
  2882.           }
  2883.         }), this;
  2884.       },
  2885.       has : function(className) {
  2886.         return className ? -1 < jQuery.inArray(className, b) : 0 < b.length;
  2887.       },
  2888.       empty : function() {
  2889.         return b && (b = []), this;
  2890.       },
  2891.       disable : function() {
  2892.         return data = d = [], b = c = "", this;
  2893.       },
  2894.       disabled : function() {
  2895.         return !b;
  2896.       },
  2897.       lock : function() {
  2898.         return data = d = [], c || callback || (b = c = ""), this;
  2899.       },
  2900.       locked : function() {
  2901.         return !!data;
  2902.       },
  2903.       fireWith : function(context, args) {
  2904.         return data || (args = [context, (args = args || []).slice ? args.slice() : args], d.push(args), callback || fire()), this;
  2905.       },
  2906.       fire : function() {
  2907.         return self.fireWith(this, arguments), this;
  2908.       },
  2909.       fired : function() {
  2910.         return !!req;
  2911.       }
  2912.     };
  2913.     return self;
  2914.   };
  2915.   jQuery.extend({
  2916.     Deferred : function(func) {
  2917.       /** @type {!Array} */
  2918.       var array = [["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]];
  2919.       /** @type {string} */
  2920.       var state = "pending";
  2921.       var promise = {
  2922.         state : function() {
  2923.           return state;
  2924.         },
  2925.         always : function() {
  2926.           return deferred.done(arguments).fail(arguments), this;
  2927.         },
  2928.         "catch" : function(c) {
  2929.           return promise.then(null, c);
  2930.         },
  2931.         pipe : function() {
  2932.           /** @type {!Arguments} */
  2933.           var result = arguments;
  2934.           return jQuery.Deferred(function(newDefer) {
  2935.             jQuery.each(array, function(canCreateDiscussions, tuple) {
  2936.               var callback = fn(result[tuple[4]]) && result[tuple[4]];
  2937.               deferred[tuple[1]](function() {
  2938.                 var promise = callback && callback.apply(this, arguments);
  2939.                 if (promise && fn(promise.promise)) {
  2940.                   promise.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
  2941.                 } else {
  2942.                   newDefer[tuple[0] + "With"](this, callback ? [promise] : arguments);
  2943.                 }
  2944.               });
  2945.             });
  2946.             /** @type {null} */
  2947.             result = null;
  2948.           }).promise();
  2949.         },
  2950.         then : function(error, label, x) {
  2951.           /**
  2952.            * @param {number} index
  2953.            * @param {!Object} options
  2954.            * @param {!Function} callback
  2955.            * @param {boolean} args
  2956.            * @return {?}
  2957.            */
  2958.           function callback(index, options, callback, args) {
  2959.             return function() {
  2960.               var elem = this;
  2961.               /** @type {!Arguments} */
  2962.               var values = arguments;
  2963.               /**
  2964.                * @return {undefined}
  2965.                */
  2966.               var apply = function() {
  2967.                 var value;
  2968.                 var self;
  2969.                 if (!(index < i)) {
  2970.                   if ((value = callback.apply(elem, values)) === options.promise()) {
  2971.                     throw new TypeError("Thenable self-resolution");
  2972.                   }
  2973.                   self = value && ("object" == typeof value || "function" == typeof value) && value.then;
  2974.                   if (fn(self)) {
  2975.                     if (args) {
  2976.                       self.call(value, callback(i, options, failed, args), callback(i, options, data, args));
  2977.                     } else {
  2978.                       i++;
  2979.                       self.call(value, callback(i, options, failed, args), callback(i, options, data, args), callback(i, options, failed, options.notifyWith));
  2980.                     }
  2981.                   } else {
  2982.                     if (callback !== failed) {
  2983.                       elem = void 0;
  2984.                       /** @type {!Array} */
  2985.                       values = [value];
  2986.                     }
  2987.                     (args || options.resolveWith)(elem, values);
  2988.                   }
  2989.                 }
  2990.               };
  2991.               /** @type {function(): undefined} */
  2992.               var method = args ? apply : function() {
  2993.                 try {
  2994.                   apply();
  2995.                 } catch (scheduled) {
  2996.                   if (jQuery.Deferred.exceptionHook) {
  2997.                     jQuery.Deferred.exceptionHook(scheduled, method.stackTrace);
  2998.                   }
  2999.                   if (i <= index + 1) {
  3000.                     if (callback !== data) {
  3001.                       elem = void 0;
  3002.                       /** @type {!Array} */
  3003.                       values = [scheduled];
  3004.                     }
  3005.                     options.rejectWith(elem, values);
  3006.                   }
  3007.                 }
  3008.               };
  3009.               if (index) {
  3010.                 method();
  3011.               } else {
  3012.                 if (jQuery.Deferred.getStackHook) {
  3013.                   method.stackTrace = jQuery.Deferred.getStackHook();
  3014.                 }
  3015.                 window.setTimeout(method);
  3016.               }
  3017.             };
  3018.           }
  3019.           /** @type {number} */
  3020.           var i = 0;
  3021.           return jQuery.Deferred(function(self) {
  3022.             array[0][3].add(callback(0, self, fn(x) ? x : failed, self.notifyWith));
  3023.             array[1][3].add(callback(0, self, fn(error) ? error : failed));
  3024.             array[2][3].add(callback(0, self, fn(label) ? label : data));
  3025.           }).promise();
  3026.         },
  3027.         promise : function(context) {
  3028.           return null != context ? jQuery.extend(context, promise) : promise;
  3029.         }
  3030.       };
  3031.       var deferred = {};
  3032.       return jQuery.each(array, function(numRemoved, tuple) {
  3033.         var list = tuple[2];
  3034.         var stateString = tuple[5];
  3035.         promise[tuple[1]] = list.add;
  3036.         if (stateString) {
  3037.           list.add(function() {
  3038.             state = stateString;
  3039.           }, array[3 - numRemoved][2].disable, array[3 - numRemoved][3].disable, array[0][2].lock, array[0][3].lock);
  3040.         }
  3041.         list.add(tuple[3].fire);
  3042.         /**
  3043.          * @return {?}
  3044.          */
  3045.         deferred[tuple[0]] = function() {
  3046.           return deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments), this;
  3047.         };
  3048.         deferred[tuple[0] + "With"] = list.fireWith;
  3049.       }), promise.promise(deferred), func && func.call(deferred, deferred), deferred;
  3050.     },
  3051.     when : function(data) {
  3052.       /** @type {number} */
  3053.       var sampleSize = arguments.length;
  3054.       var i = sampleSize;
  3055.       /** @type {!Array} */
  3056.       var elements = Array(i);
  3057.       /** @type {!Array<?>} */
  3058.       var args = slice.call(arguments);
  3059.       var d = jQuery.Deferred();
  3060.       /**
  3061.        * @param {undefined} i
  3062.        * @return {?}
  3063.        */
  3064.       var updateFn = function(i) {
  3065.         return function(value) {
  3066.           elements[i] = this;
  3067.           args[i] = 1 < arguments.length ? slice.call(arguments) : value;
  3068.           if (!--sampleSize) {
  3069.             d.resolveWith(elements, args);
  3070.           }
  3071.         };
  3072.       };
  3073.       if (sampleSize <= 1 && (resolve(data, d.done(updateFn(i)).resolve, d.reject, !sampleSize), "pending" === d.state() || fn(args[i] && args[i].then))) {
  3074.         return d.then();
  3075.       }
  3076.       for (; i--;) {
  3077.         resolve(args[i], updateFn(i), d.reject);
  3078.       }
  3079.       return d.promise();
  3080.     }
  3081.   });
  3082.   /** @type {!RegExp} */
  3083.   var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
  3084.   /**
  3085.    * @param {?} error
  3086.    * @param {?} stack
  3087.    * @return {undefined}
  3088.    */
  3089.   jQuery.Deferred.exceptionHook = function(error, stack) {
  3090.     if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
  3091.       window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
  3092.     }
  3093.   };
  3094.   /**
  3095.    * @param {?} error
  3096.    * @return {undefined}
  3097.    */
  3098.   jQuery.readyException = function(error) {
  3099.     window.setTimeout(function() {
  3100.       throw error;
  3101.     });
  3102.   };
  3103.   var readyList = jQuery.Deferred();
  3104.   /**
  3105.    * @param {?} fn
  3106.    * @return {?}
  3107.    */
  3108.   jQuery.fn.ready = function(fn) {
  3109.     return readyList.then(fn)["catch"](function(e) {
  3110.       jQuery.readyException(e);
  3111.     }), this;
  3112.   };
  3113.   jQuery.extend({
  3114.     isReady : false,
  3115.     readyWait : 1,
  3116.     ready : function(user) {
  3117.       if (!((true === user ? --jQuery.readyWait : jQuery.isReady) || (jQuery.isReady = true) !== user && 0 < --jQuery.readyWait)) {
  3118.         readyList.resolveWith(document, [jQuery]);
  3119.       }
  3120.     }
  3121.   });
  3122.   jQuery.ready.then = readyList.then;
  3123.   if ("complete" === document.readyState || "loading" !== document.readyState && !document.documentElement.doScroll) {
  3124.     window.setTimeout(jQuery.ready);
  3125.   } else {
  3126.     document.addEventListener("DOMContentLoaded", $__jsx_onload);
  3127.     window.addEventListener("load", $__jsx_onload);
  3128.   }
  3129.   /**
  3130.    * @param {string} elems
  3131.    * @param {!Function} callback
  3132.    * @param {string} key
  3133.    * @param {?} value
  3134.    * @param {number} chainable
  3135.    * @param {string} emptyGet
  3136.    * @param {boolean} raw
  3137.    * @return {?}
  3138.    */
  3139.   var access = function(elems, callback, key, value, chainable, emptyGet, raw) {
  3140.     /** @type {number} */
  3141.     var i = 0;
  3142.     var length = elems.length;
  3143.     /** @type {boolean} */
  3144.     var bulk = null == key;
  3145.     if ("object" === type(key)) {
  3146.       for (i in chainable = true, key) {
  3147.         access(elems, callback, i, key[i], true, emptyGet, raw);
  3148.       }
  3149.     } else {
  3150.       if (void 0 !== value && (chainable = true, fn(value) || (raw = true), bulk && (raw ? (callback.call(elems, value), callback = null) : (bulk = callback, callback = function(elem, t, value) {
  3151.         return bulk.call(jQuery(elem), value);
  3152.       })), callback)) {
  3153.         for (; i < length; i++) {
  3154.           callback(elems[i], key, raw ? value : value.call(elems[i], i, callback(elems[i], key)));
  3155.         }
  3156.       }
  3157.     }
  3158.     return chainable ? elems : bulk ? callback.call(elems) : length ? callback(elems[0], key) : emptyGet;
  3159.   };
  3160.   /** @type {!RegExp} */
  3161.   var _kerningNamesHash_escapeEscape = /^-ms-/;
  3162.   /** @type {!RegExp} */
  3163.   var rcharset = /-([a-z])/g;
  3164.   /**
  3165.    * @param {!Object} elem
  3166.    * @return {?}
  3167.    */
  3168.   var acceptData = function(elem) {
  3169.     return 1 === elem.nodeType || 9 === elem.nodeType || !+elem.nodeType;
  3170.   };
  3171.   /** @type {number} */
  3172.   Data.uid = 1;
  3173.   Data.prototype = {
  3174.     cache : function(elem) {
  3175.       var value = elem[this.expando];
  3176.       return value || (value = {}, acceptData(elem) && (elem.nodeType ? elem[this.expando] = value : Object.defineProperty(elem, this.expando, {
  3177.         value : value,
  3178.         configurable : true
  3179.       }))), value;
  3180.     },
  3181.     set : function(key, data, type) {
  3182.       var prop;
  3183.       var cache = this.cache(key);
  3184.       if ("string" == typeof data) {
  3185.         /** @type {string} */
  3186.         cache[camelCase(data)] = type;
  3187.       } else {
  3188.         for (prop in data) {
  3189.           cache[camelCase(prop)] = data[prop];
  3190.         }
  3191.       }
  3192.       return cache;
  3193.     },
  3194.     get : function(owner, key) {
  3195.       return void 0 === key ? this.cache(owner) : owner[this.expando] && owner[this.expando][camelCase(key)];
  3196.     },
  3197.     access : function(value, fn, o) {
  3198.       return void 0 === fn || fn && "string" == typeof fn && void 0 === o ? this.get(value, fn) : (this.set(value, fn, o), void 0 !== o ? o : fn);
  3199.     },
  3200.     remove : function(owner, name) {
  3201.       var i;
  3202.       var cache = owner[this.expando];
  3203.       if (void 0 !== cache) {
  3204.         if (void 0 !== name) {
  3205.           i = (name = Array.isArray(name) ? name.map(camelCase) : (name = camelCase(name)) in cache ? [name] : name.match(re) || []).length;
  3206.           for (; i--;) {
  3207.             delete cache[name[i]];
  3208.           }
  3209.         }
  3210.         if (void 0 === name || jQuery.isEmptyObject(cache)) {
  3211.           if (owner.nodeType) {
  3212.             owner[this.expando] = void 0;
  3213.           } else {
  3214.             delete owner[this.expando];
  3215.           }
  3216.         }
  3217.       }
  3218.     },
  3219.     hasData : function(owner) {
  3220.       var cache = owner[this.expando];
  3221.       return void 0 !== cache && !jQuery.isEmptyObject(cache);
  3222.     }
  3223.   };
  3224.   var dataPriv = new Data;
  3225.   var self = new Data;
  3226.   /** @type {!RegExp} */
  3227.   var contribRegex = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
  3228.   /** @type {!RegExp} */
  3229.   var dashExpr = /[A-Z]/g;
  3230.   jQuery.extend({
  3231.     hasData : function(elem) {
  3232.       return self.hasData(elem) || dataPriv.hasData(elem);
  3233.     },
  3234.     data : function(elem, name, value) {
  3235.       return self.access(elem, name, value);
  3236.     },
  3237.     removeData : function(elem, name) {
  3238.       self.remove(elem, name);
  3239.     },
  3240.     _data : function(elem, name, data) {
  3241.       return dataPriv.access(elem, name, data);
  3242.     },
  3243.     _removeData : function(elem, name) {
  3244.       dataPriv.remove(elem, name);
  3245.     }
  3246.   });
  3247.   jQuery.fn.extend({
  3248.     data : function(value, args) {
  3249.       var i;
  3250.       var name;
  3251.       var data;
  3252.       var elem = this[0];
  3253.       var attrs = elem && elem.attributes;
  3254.       if (void 0 === value) {
  3255.         if (this.length && (data = self.get(elem), 1 === elem.nodeType && !dataPriv.get(elem, "hasDataAttrs"))) {
  3256.           i = attrs.length;
  3257.           for (; i--;) {
  3258.             if (attrs[i] && 0 === (name = attrs[i].name).indexOf("data-")) {
  3259.               name = camelCase(name.slice(5));
  3260.               func(elem, name, data[name]);
  3261.             }
  3262.           }
  3263.           dataPriv.set(elem, "hasDataAttrs", true);
  3264.         }
  3265.         return data;
  3266.       }
  3267.       return "object" == typeof value ? this.each(function() {
  3268.         self.set(this, value);
  3269.       }) : access(this, function(name) {
  3270.         var message;
  3271.         if (elem && void 0 === name) {
  3272.           return void 0 !== (message = self.get(elem, value)) ? message : void 0 !== (message = func(elem, value)) ? message : void 0;
  3273.         }
  3274.         this.each(function() {
  3275.           self.set(this, value, name);
  3276.         });
  3277.       }, null, args, 1 < arguments.length, null, true);
  3278.     },
  3279.     removeData : function(callback) {
  3280.       return this.each(function() {
  3281.         self.remove(this, callback);
  3282.       });
  3283.     }
  3284.   });
  3285.   jQuery.extend({
  3286.     queue : function(elem, type, data) {
  3287.       var q;
  3288.       if (elem) {
  3289.         return type = (type || "fx") + "queue", q = dataPriv.get(elem, type), data && (!q || Array.isArray(data) ? q = dataPriv.access(elem, type, jQuery.makeArray(data)) : q.push(data)), q || [];
  3290.       }
  3291.     },
  3292.     dequeue : function(elem, type) {
  3293.       type = type || "fx";
  3294.       var queue = jQuery.queue(elem, type);
  3295.       var i = queue.length;
  3296.       var _self = queue.shift();
  3297.       var node = jQuery._queueHooks(elem, type);
  3298.       if ("inprogress" === _self) {
  3299.         _self = queue.shift();
  3300.         i--;
  3301.       }
  3302.       if (_self) {
  3303.         if ("fx" === type) {
  3304.           queue.unshift("inprogress");
  3305.         }
  3306.         delete node.stop;
  3307.         _self.call(elem, function() {
  3308.           jQuery.dequeue(elem, type);
  3309.         }, node);
  3310.       }
  3311.       if (!i && node) {
  3312.         node.empty.fire();
  3313.       }
  3314.     },
  3315.     _queueHooks : function(elem, type) {
  3316.       /** @type {string} */
  3317.       var key = type + "queueHooks";
  3318.       return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
  3319.         empty : jQuery.Callbacks("once memory").add(function() {
  3320.           dataPriv.remove(elem, [type + "queue", key]);
  3321.         })
  3322.       });
  3323.     }
  3324.   });
  3325.   jQuery.fn.extend({
  3326.     queue : function(type, data) {
  3327.       /** @type {number} */
  3328.       var setter = 2;
  3329.       return "string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter ? jQuery.queue(this[0], type) : void 0 === data ? this : this.each(function() {
  3330.         var queue = jQuery.queue(this, type, data);
  3331.         jQuery._queueHooks(this, type);
  3332.         if ("fx" === type && "inprogress" !== queue[0]) {
  3333.           jQuery.dequeue(this, type);
  3334.         }
  3335.       });
  3336.     },
  3337.     dequeue : function(type) {
  3338.       return this.each(function() {
  3339.         jQuery.dequeue(this, type);
  3340.       });
  3341.     },
  3342.     clearQueue : function(type) {
  3343.       return this.queue(type || "fx", []);
  3344.     },
  3345.     promise : function(type, result) {
  3346.       var sel;
  3347.       /** @type {number} */
  3348.       var r = 1;
  3349.       var defer = jQuery.Deferred();
  3350.       var elements = this;
  3351.       var i = this.length;
  3352.       /**
  3353.        * @return {undefined}
  3354.        */
  3355.       var resolve = function() {
  3356.         if (!--r) {
  3357.           defer.resolveWith(elements, [elements]);
  3358.         }
  3359.       };
  3360.       if ("string" != typeof type) {
  3361.         /** @type {!Object} */
  3362.         result = type;
  3363.         type = void 0;
  3364.       }
  3365.       type = type || "fx";
  3366.       for (; i--;) {
  3367.         if ((sel = dataPriv.get(elements[i], type + "queueHooks")) && sel.empty) {
  3368.           r++;
  3369.           sel.empty.add(resolve);
  3370.         }
  3371.       }
  3372.       return resolve(), defer.promise(result);
  3373.     }
  3374.   });
  3375.   /** @type {string} */
  3376.   var FSSource = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
  3377.   /** @type {!RegExp} */
  3378.   var regex = new RegExp("^(?:([+-])=|)(" + FSSource + ")([a-z%]*)$", "i");
  3379.   /** @type {!Array} */
  3380.   var cssExpand = ["Top", "Right", "Bottom", "Left"];
  3381.   var node = document.documentElement;
  3382.   /**
  3383.    * @param {!Object} elem
  3384.    * @return {?}
  3385.    */
  3386.   var test = function(elem) {
  3387.     return jQuery.contains(elem.ownerDocument, elem);
  3388.   };
  3389.   var _prefName = {
  3390.     composed : true
  3391.   };
  3392.   if (node.getRootNode) {
  3393.     /**
  3394.      * @param {!Object} p
  3395.      * @return {?}
  3396.      */
  3397.     test = function(p) {
  3398.       return jQuery.contains(p.ownerDocument, p) || p.getRootNode(_prefName) === p.ownerDocument;
  3399.     };
  3400.   }
  3401.   /**
  3402.    * @param {!Element} el
  3403.    * @param {!Element} root
  3404.    * @return {?}
  3405.    */
  3406.   var isHidden = function(el, root) {
  3407.     return "none" === (el = root || el).style.display || "" === el.style.display && test(el) && "none" === jQuery.css(el, "display");
  3408.   };
  3409.   var elemdisplay = {};
  3410.   jQuery.fn.extend({
  3411.     show : function() {
  3412.       return show(this, true);
  3413.     },
  3414.     hide : function() {
  3415.       return show(this);
  3416.     },
  3417.     toggle : function(state) {
  3418.       return "boolean" == typeof state ? state ? this.show() : this.hide() : this.each(function() {
  3419.         if (isHidden(this)) {
  3420.           jQuery(this).show();
  3421.         } else {
  3422.           jQuery(this).hide();
  3423.         }
  3424.       });
  3425.     }
  3426.   });
  3427.   var content_elem;
  3428.   var input;
  3429.   /** @type {!RegExp} */
  3430.   var app = /^(?:checkbox|radio)$/i;
  3431.   /** @type {!RegExp} */
  3432.   var me = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i;
  3433.   /** @type {!RegExp} */
  3434.   var opacityRe = /^$|^module$|\/(?:java|ecma)script/i;
  3435.   content_elem = document.createDocumentFragment().appendChild(document.createElement("div"));
  3436.   (input = document.createElement("input")).setAttribute("type", "radio");
  3437.   input.setAttribute("checked", "checked");
  3438.   input.setAttribute("name", "t");
  3439.   content_elem.appendChild(input);
  3440.   support.checkClone = content_elem.cloneNode(true).cloneNode(true).lastChild.checked;
  3441.   /** @type {string} */
  3442.   content_elem.innerHTML = "<textarea>x</textarea>";
  3443.   /** @type {boolean} */
  3444.   support.noCloneChecked = !!content_elem.cloneNode(true).lastChild.defaultValue;
  3445.   /** @type {string} */
  3446.   content_elem.innerHTML = "<option></option>";
  3447.   /** @type {boolean} */
  3448.   support.option = !!content_elem.lastChild;
  3449.   var wrapMap = {
  3450.     thead : [1, "<table>", "</table>"],
  3451.     col : [2, "<table><colgroup>", "</colgroup></table>"],
  3452.     tr : [2, "<table><tbody>", "</tbody></table>"],
  3453.     td : [3, "<table><tbody><tr>", "</tr></tbody></table>"],
  3454.     _default : [0, "", ""]
  3455.   };
  3456.   /** @type {!Array} */
  3457.   wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  3458.   /** @type {!Array} */
  3459.   wrapMap.th = wrapMap.td;
  3460.   if (!support.option) {
  3461.     /** @type {!Array} */
  3462.     wrapMap.optgroup = wrapMap.option = [1, "<select multiple='multiple'>", "</select>"];
  3463.   }
  3464.   /** @type {!RegExp} */
  3465.   var re_commas = /<|&#?\w+;/;
  3466.   /** @type {!RegExp} */
  3467.   var receivedErrorEvents = /^key/;
  3468.   /** @type {!RegExp} */
  3469.   var receivedOpenEvents = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
  3470.   /** @type {!RegExp} */
  3471.   var reg = /^([^.]*)(?:\.(.+)|)/;
  3472.   jQuery.event = {
  3473.     global : {},
  3474.     add : function(elem, item, handler, data, selector) {
  3475.       var handleObjIn;
  3476.       var eventHandle;
  3477.       var BROWSER_ENGINES;
  3478.       var events;
  3479.       var i;
  3480.       var handleObj;
  3481.       var special;
  3482.       var handlers;
  3483.       var type;
  3484.       var h;
  3485.       var origType;
  3486.       var elemData = dataPriv.get(elem);
  3487.       if (acceptData(elem)) {
  3488.         if (handler.handler) {
  3489.           handler = (handleObjIn = handler).handler;
  3490.           selector = handleObjIn.selector;
  3491.         }
  3492.         if (selector) {
  3493.           jQuery.find.matchesSelector(node, selector);
  3494.         }
  3495.         if (!handler.guid) {
  3496.           /** @type {number} */
  3497.           handler.guid = jQuery.guid++;
  3498.         }
  3499.         if (!(events = elemData.events)) {
  3500.           /** @type {!Object} */
  3501.           events = elemData.events = Object.create(null);
  3502.         }
  3503.         if (!(eventHandle = elemData.handle)) {
  3504.           /** @type {function(!Object): ?} */
  3505.           eventHandle = elemData.handle = function(e) {
  3506.             return "undefined" != typeof jQuery && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : void 0;
  3507.           };
  3508.         }
  3509.         i = (item = (item || "").match(re) || [""]).length;
  3510.         for (; i--;) {
  3511.           type = origType = (BROWSER_ENGINES = reg.exec(item[i]) || [])[1];
  3512.           h = (BROWSER_ENGINES[2] || "").split(".").sort();
  3513.           if (type) {
  3514.             special = jQuery.event.special[type] || {};
  3515.             type = (selector ? special.delegateType : special.bindType) || type;
  3516.             special = jQuery.event.special[type] || {};
  3517.             handleObj = jQuery.extend({
  3518.               type : type,
  3519.               origType : origType,
  3520.               data : data,
  3521.               handler : handler,
  3522.               guid : handler.guid,
  3523.               selector : selector,
  3524.               needsContext : selector && jQuery.expr.match.needsContext.test(selector),
  3525.               namespace : h.join(".")
  3526.             }, handleObjIn);
  3527.             if (!(handlers = events[type])) {
  3528.               /** @type {number} */
  3529.               (handlers = events[type] = []).delegateCount = 0;
  3530.               if (!(special.setup && false !== special.setup.call(elem, data, h, eventHandle))) {
  3531.                 if (elem.addEventListener) {
  3532.                   elem.addEventListener(type, eventHandle);
  3533.                 }
  3534.               }
  3535.             }
  3536.             if (special.add) {
  3537.               special.add.call(elem, handleObj);
  3538.               if (!handleObj.handler.guid) {
  3539.                 handleObj.handler.guid = handler.guid;
  3540.               }
  3541.             }
  3542.             if (selector) {
  3543.               handlers.splice(handlers.delegateCount++, 0, handleObj);
  3544.             } else {
  3545.               handlers.push(handleObj);
  3546.             }
  3547.             /** @type {boolean} */
  3548.             jQuery.event.global[type] = true;
  3549.           }
  3550.         }
  3551.       }
  3552.     },
  3553.     remove : function(elem, data, fn, selector, i) {
  3554.       var j;
  3555.       var origCount;
  3556.       var tmp;
  3557.       var events;
  3558.       var i;
  3559.       var handleObj;
  3560.       var special;
  3561.       var handlers;
  3562.       var type;
  3563.       var h;
  3564.       var level;
  3565.       var elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
  3566.       if (elemData && (events = elemData.events)) {
  3567.         i = (data = (data || "").match(re) || [""]).length;
  3568.         for (; i--;) {
  3569.           if (type = level = (tmp = reg.exec(data[i]) || [])[1], h = (tmp[2] || "").split(".").sort(), type) {
  3570.             special = jQuery.event.special[type] || {};
  3571.             handlers = events[type = (selector ? special.delegateType : special.bindType) || type] || [];
  3572.             tmp = tmp[2] && new RegExp("(^|\\.)" + h.join("\\.(?:.*\\.|)") + "(\\.|$)");
  3573.             origCount = j = handlers.length;
  3574.             for (; j--;) {
  3575.               handleObj = handlers[j];
  3576.               if (!(!i && level !== handleObj.origType || fn && fn.guid !== handleObj.guid || tmp && !tmp.test(handleObj.namespace) || selector && selector !== handleObj.selector && ("**" !== selector || !handleObj.selector))) {
  3577.                 handlers.splice(j, 1);
  3578.                 if (handleObj.selector) {
  3579.                   handlers.delegateCount--;
  3580.                 }
  3581.                 if (special.remove) {
  3582.                   special.remove.call(elem, handleObj);
  3583.                 }
  3584.               }
  3585.             }
  3586.             if (origCount && !handlers.length) {
  3587.               if (!(special.teardown && false !== special.teardown.call(elem, h, elemData.handle))) {
  3588.                 jQuery.removeEvent(elem, type, elemData.handle);
  3589.               }
  3590.               delete events[type];
  3591.             }
  3592.           } else {
  3593.             for (type in events) {
  3594.               jQuery.event.remove(elem, type + data[i], fn, selector, true);
  3595.             }
  3596.           }
  3597.         }
  3598.         if (jQuery.isEmptyObject(events)) {
  3599.           dataPriv.remove(elem, "handle events");
  3600.         }
  3601.       }
  3602.     },
  3603.     dispatch : function(e) {
  3604.       var i;
  3605.       var j;
  3606.       var ret;
  3607.       var matched;
  3608.       var handleObj;
  3609.       var handlerQueue;
  3610.       /** @type {!Array} */
  3611.       var args = new Array(arguments.length);
  3612.       var event = jQuery.event.fix(e);
  3613.       var handlers = (dataPriv.get(this, "events") || Object.create(null))[event.type] || [];
  3614.       var special = jQuery.event.special[event.type] || {};
  3615.       args[0] = event;
  3616.       /** @type {number} */
  3617.       i = 1;
  3618.       for (; i < arguments.length; i++) {
  3619.         args[i] = arguments[i];
  3620.       }
  3621.       if (event.delegateTarget = this, !special.preDispatch || false !== special.preDispatch.call(this, event)) {
  3622.         handlerQueue = jQuery.event.handlers.call(this, event, handlers);
  3623.         /** @type {number} */
  3624.         i = 0;
  3625.         for (; (matched = handlerQueue[i++]) && !event.isPropagationStopped();) {
  3626.           event.currentTarget = matched.elem;
  3627.           /** @type {number} */
  3628.           j = 0;
  3629.           for (; (handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();) {
  3630.             if (!(event.rnamespace && false !== handleObj.namespace && !event.rnamespace.test(handleObj.namespace))) {
  3631.               event.handleObj = handleObj;
  3632.               event.data = handleObj.data;
  3633.               if (void 0 !== (ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args)) && false === (event.result = ret)) {
  3634.                 event.preventDefault();
  3635.                 event.stopPropagation();
  3636.               }
  3637.             }
  3638.           }
  3639.         }
  3640.         return special.postDispatch && special.postDispatch.call(this, event), event.result;
  3641.       }
  3642.     },
  3643.     handlers : function(event, handlers) {
  3644.       var i;
  3645.       var handleObj;
  3646.       var name;
  3647.       var matches;
  3648.       var fieldOrdinals;
  3649.       /** @type {!Array} */
  3650.       var handlerQueue = [];
  3651.       var delegateCount = handlers.delegateCount;
  3652.       var cur = event.target;
  3653.       if (delegateCount && cur.nodeType && !("click" === event.type && 1 <= event.button)) {
  3654.         for (; cur !== this; cur = cur.parentNode || this) {
  3655.           if (1 === cur.nodeType && ("click" !== event.type || true !== cur.disabled)) {
  3656.             /** @type {!Array} */
  3657.             matches = [];
  3658.             fieldOrdinals = {};
  3659.             /** @type {number} */
  3660.             i = 0;
  3661.             for (; i < delegateCount; i++) {
  3662.               if (void 0 === fieldOrdinals[name = (handleObj = handlers[i]).selector + " "]) {
  3663.                 fieldOrdinals[name] = handleObj.needsContext ? -1 < jQuery(name, this).index(cur) : jQuery.find(name, this, null, [cur]).length;
  3664.               }
  3665.               if (fieldOrdinals[name]) {
  3666.                 matches.push(handleObj);
  3667.               }
  3668.             }
  3669.             if (matches.length) {
  3670.               handlerQueue.push({
  3671.                 elem : cur,
  3672.                 handlers : matches
  3673.               });
  3674.             }
  3675.           }
  3676.         }
  3677.       }
  3678.       return cur = this, delegateCount < handlers.length && handlerQueue.push({
  3679.         elem : cur,
  3680.         handlers : handlers.slice(delegateCount)
  3681.       }), handlerQueue;
  3682.     },
  3683.     addProp : function(name, hook) {
  3684.       Object.defineProperty(jQuery.Event.prototype, name, {
  3685.         enumerable : true,
  3686.         configurable : true,
  3687.         get : fn(hook) ? function() {
  3688.           if (this.originalEvent) {
  3689.             return hook(this.originalEvent);
  3690.           }
  3691.         } : function() {
  3692.           if (this.originalEvent) {
  3693.             return this.originalEvent[name];
  3694.           }
  3695.         },
  3696.         set : function(type) {
  3697.           Object.defineProperty(this, name, {
  3698.             enumerable : true,
  3699.             configurable : true,
  3700.             writable : true,
  3701.             value : type
  3702.           });
  3703.         }
  3704.       });
  3705.     },
  3706.     fix : function(originalEvent) {
  3707.       return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
  3708.     },
  3709.     special : {
  3710.       load : {
  3711.         noBubble : true
  3712.       },
  3713.       click : {
  3714.         setup : function(options) {
  3715.           var target = this || options;
  3716.           return app.test(target.type) && target.click && callback(target, "input") && handler(target, "click", returnTrue), false;
  3717.         },
  3718.         trigger : function(event) {
  3719.           var type = this || event;
  3720.           return app.test(type.type) && type.click && callback(type, "input") && handler(type, "click"), true;
  3721.         },
  3722.         _default : function(options) {
  3723.           var elem = options.target;
  3724.           return app.test(elem.type) && elem.click && callback(elem, "input") && dataPriv.get(elem, "click") || callback(elem, "a");
  3725.         }
  3726.       },
  3727.       beforeunload : {
  3728.         postDispatch : function(event) {
  3729.           if (void 0 !== event.result && event.originalEvent) {
  3730.             event.originalEvent.returnValue = event.result;
  3731.           }
  3732.         }
  3733.       }
  3734.     }
  3735.   };
  3736.   /**
  3737.    * @param {!Object} elem
  3738.    * @param {!Object} type
  3739.    * @param {?} fn
  3740.    * @return {undefined}
  3741.    */
  3742.   jQuery.removeEvent = function(elem, type, fn) {
  3743.     if (elem.removeEventListener) {
  3744.       elem.removeEventListener(type, fn);
  3745.     }
  3746.   };
  3747.   /**
  3748.    * @param {!Object} src
  3749.    * @param {!Object} props
  3750.    * @return {?}
  3751.    */
  3752.   jQuery.Event = function(src, props) {
  3753.     if (!(this instanceof jQuery.Event)) {
  3754.       return new jQuery.Event(src, props);
  3755.     }
  3756.     if (src && src.type) {
  3757.       /** @type {!Object} */
  3758.       this.originalEvent = src;
  3759.       this.type = src.type;
  3760.       /** @type {function(): ?} */
  3761.       this.isDefaultPrevented = src.defaultPrevented || void 0 === src.defaultPrevented && false === src.returnValue ? returnTrue : returnFalse;
  3762.       this.target = src.target && 3 === src.target.nodeType ? src.target.parentNode : src.target;
  3763.       this.currentTarget = src.currentTarget;
  3764.       this.relatedTarget = src.relatedTarget;
  3765.     } else {
  3766.       /** @type {!Object} */
  3767.       this.type = src;
  3768.     }
  3769.     if (props) {
  3770.       jQuery.extend(this, props);
  3771.     }
  3772.     this.timeStamp = src && src.timeStamp || Date.now();
  3773.     /** @type {boolean} */
  3774.     this[jQuery.expando] = true;
  3775.   };
  3776.   jQuery.Event.prototype = {
  3777.     constructor : jQuery.Event,
  3778.     isDefaultPrevented : returnFalse,
  3779.     isPropagationStopped : returnFalse,
  3780.     isImmediatePropagationStopped : returnFalse,
  3781.     isSimulated : false,
  3782.     preventDefault : function() {
  3783.       var e = this.originalEvent;
  3784.       /** @type {function(): ?} */
  3785.       this.isDefaultPrevented = returnTrue;
  3786.       if (e && !this.isSimulated) {
  3787.         e.preventDefault();
  3788.       }
  3789.     },
  3790.     stopPropagation : function() {
  3791.       var e = this.originalEvent;
  3792.       /** @type {function(): ?} */
  3793.       this.isPropagationStopped = returnTrue;
  3794.       if (e && !this.isSimulated) {
  3795.         e.stopPropagation();
  3796.       }
  3797.     },
  3798.     stopImmediatePropagation : function() {
  3799.       var e = this.originalEvent;
  3800.       /** @type {function(): ?} */
  3801.       this.isImmediatePropagationStopped = returnTrue;
  3802.       if (e && !this.isSimulated) {
  3803.         e.stopImmediatePropagation();
  3804.       }
  3805.       this.stopPropagation();
  3806.     }
  3807.   };
  3808.   jQuery.each({
  3809.     altKey : true,
  3810.     bubbles : true,
  3811.     cancelable : true,
  3812.     changedTouches : true,
  3813.     ctrlKey : true,
  3814.     detail : true,
  3815.     eventPhase : true,
  3816.     metaKey : true,
  3817.     pageX : true,
  3818.     pageY : true,
  3819.     shiftKey : true,
  3820.     view : true,
  3821.     "char" : true,
  3822.     code : true,
  3823.     charCode : true,
  3824.     key : true,
  3825.     keyCode : true,
  3826.     button : true,
  3827.     buttons : true,
  3828.     clientX : true,
  3829.     clientY : true,
  3830.     offsetX : true,
  3831.     offsetY : true,
  3832.     pointerId : true,
  3833.     pointerType : true,
  3834.     screenX : true,
  3835.     screenY : true,
  3836.     targetTouches : true,
  3837.     toElement : true,
  3838.     touches : true,
  3839.     which : function(e) {
  3840.       var button = e.button;
  3841.       return null == e.which && receivedErrorEvents.test(e.type) ? null != e.charCode ? e.charCode : e.keyCode : !e.which && void 0 !== button && receivedOpenEvents.test(e.type) ? 1 & button ? 1 : 2 & button ? 3 : 4 & button ? 2 : 0 : e.which;
  3842.     }
  3843.   }, jQuery.event.addProp);
  3844.   jQuery.each({
  3845.     focus : "focusin",
  3846.     blur : "focusout"
  3847.   }, function(name, fix) {
  3848.     jQuery.event.special[name] = {
  3849.       setup : function() {
  3850.         return handler(this, name, raw), false;
  3851.       },
  3852.       trigger : function() {
  3853.         return handler(this, name), true;
  3854.       },
  3855.       delegateType : fix
  3856.     };
  3857.   });
  3858.   jQuery.each({
  3859.     mouseenter : "mouseover",
  3860.     mouseleave : "mouseout",
  3861.     pointerenter : "pointerover",
  3862.     pointerleave : "pointerout"
  3863.   }, function(orig, fix) {
  3864.     jQuery.event.special[orig] = {
  3865.       delegateType : fix,
  3866.       bindType : fix,
  3867.       handle : function(event) {
  3868.         var _ref12;
  3869.         var target = event.relatedTarget;
  3870.         var handleObj = event.handleObj;
  3871.         return target && (target === this || jQuery.contains(this, target)) || (event.type = handleObj.origType, _ref12 = handleObj.handler.apply(this, arguments), event.type = fix), _ref12;
  3872.       }
  3873.     };
  3874.   });
  3875.   jQuery.fn.extend({
  3876.     on : function(type, name, callback, target) {
  3877.       return get(this, type, name, callback, target);
  3878.     },
  3879.     one : function(data, callback, type, res) {
  3880.       return get(this, data, callback, type, res, 1);
  3881.     },
  3882.     off : function(types, callback, fn) {
  3883.       var handleObj;
  3884.       var type;
  3885.       if (types && types.preventDefault && types.handleObj) {
  3886.         return handleObj = types.handleObj, jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler), this;
  3887.       }
  3888.       if ("object" == typeof types) {
  3889.         for (type in types) {
  3890.           this.off(type, callback, types[type]);
  3891.         }
  3892.         return this;
  3893.       }
  3894.       return false !== callback && "function" != typeof callback || (fn = callback, callback = void 0), false === fn && (fn = returnFalse), this.each(function() {
  3895.         jQuery.event.remove(this, types, fn, callback);
  3896.       });
  3897.     }
  3898.   });
  3899.   /** @type {!RegExp} */
  3900.   var _tacet = /<script|<style|<link/i;
  3901.   /** @type {!RegExp} */
  3902.   var partten = /checked\s*(?:[^=]|=\s*.checked.)/i;
  3903.   /** @type {!RegExp} */
  3904.   var query = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  3905.   jQuery.extend({
  3906.     htmlPrefilter : function(html) {
  3907.       return html;
  3908.     },
  3909.     clone : function(elem, n, array) {
  3910.       var i;
  3911.       var l;
  3912.       var srcElements;
  3913.       var destElements;
  3914.       var o;
  3915.       var el;
  3916.       var undefined;
  3917.       var clone = elem.cloneNode(true);
  3918.       var inPage = test(elem);
  3919.       if (!(support.noCloneChecked || 1 !== elem.nodeType && 11 !== elem.nodeType || jQuery.isXMLDoc(elem))) {
  3920.         destElements = getAll(clone);
  3921.         /** @type {number} */
  3922.         i = 0;
  3923.         l = (srcElements = getAll(elem)).length;
  3924.         for (; i < l; i++) {
  3925.           o = srcElements[i];
  3926.           el = destElements[i];
  3927.           void 0;
  3928.           if ("input" === (undefined = el.nodeName.toLowerCase()) && app.test(o.type)) {
  3929.             el.checked = o.checked;
  3930.           } else {
  3931.             if (!("input" !== undefined && "textarea" !== undefined)) {
  3932.               el.defaultValue = o.defaultValue;
  3933.             }
  3934.           }
  3935.         }
  3936.       }
  3937.       if (n) {
  3938.         if (array) {
  3939.           srcElements = srcElements || getAll(elem);
  3940.           destElements = destElements || getAll(clone);
  3941.           /** @type {number} */
  3942.           i = 0;
  3943.           l = srcElements.length;
  3944.           for (; i < l; i++) {
  3945.             cloneCopyEvent(srcElements[i], destElements[i]);
  3946.           }
  3947.         } else {
  3948.           cloneCopyEvent(elem, clone);
  3949.         }
  3950.       }
  3951.       return 0 < (destElements = getAll(clone, "script")).length && setGlobalEval(destElements, !inPage && getAll(elem, "script")), clone;
  3952.     },
  3953.     cleanData : function(elems) {
  3954.       var data;
  3955.       var elem;
  3956.       var type;
  3957.       var special = jQuery.event.special;
  3958.       /** @type {number} */
  3959.       var i = 0;
  3960.       for (; void 0 !== (elem = elems[i]); i++) {
  3961.         if (acceptData(elem)) {
  3962.           if (data = elem[dataPriv.expando]) {
  3963.             if (data.events) {
  3964.               for (type in data.events) {
  3965.                 if (special[type]) {
  3966.                   jQuery.event.remove(elem, type);
  3967.                 } else {
  3968.                   jQuery.removeEvent(elem, type, data.handle);
  3969.                 }
  3970.               }
  3971.             }
  3972.             elem[dataPriv.expando] = void 0;
  3973.           }
  3974.           if (elem[self.expando]) {
  3975.             elem[self.expando] = void 0;
  3976.           }
  3977.         }
  3978.       }
  3979.     }
  3980.   });
  3981.   jQuery.fn.extend({
  3982.     detach : function(selector) {
  3983.       return remove(this, selector, true);
  3984.     },
  3985.     remove : function(key) {
  3986.       return remove(this, key);
  3987.     },
  3988.     text : function(value) {
  3989.       return access(this, function(value) {
  3990.         return void 0 === value ? jQuery.text(this) : this.empty().each(function() {
  3991.           if (!(1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType)) {
  3992.             this.textContent = value;
  3993.           }
  3994.         });
  3995.       }, null, value, arguments.length);
  3996.     },
  3997.     append : function() {
  3998.       return domManip(this, arguments, function(elem) {
  3999.         if (!(1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType)) {
  4000.           manipulationTarget(this, elem).appendChild(elem);
  4001.         }
  4002.       });
  4003.     },
  4004.     prepend : function() {
  4005.       return domManip(this, arguments, function(elem) {
  4006.         if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
  4007.           var target = manipulationTarget(this, elem);
  4008.           target.insertBefore(elem, target.firstChild);
  4009.         }
  4010.       });
  4011.     },
  4012.     before : function() {
  4013.       return domManip(this, arguments, function(elem) {
  4014.         if (this.parentNode) {
  4015.           this.parentNode.insertBefore(elem, this);
  4016.         }
  4017.       });
  4018.     },
  4019.     after : function() {
  4020.       return domManip(this, arguments, function(elem) {
  4021.         if (this.parentNode) {
  4022.           this.parentNode.insertBefore(elem, this.nextSibling);
  4023.         }
  4024.       });
  4025.     },
  4026.     empty : function() {
  4027.       var elem;
  4028.       /** @type {number} */
  4029.       var i = 0;
  4030.       for (; null != (elem = this[i]); i++) {
  4031.         if (1 === elem.nodeType) {
  4032.           jQuery.cleanData(getAll(elem, false));
  4033.           /** @type {string} */
  4034.           elem.textContent = "";
  4035.         }
  4036.       }
  4037.       return this;
  4038.     },
  4039.     clone : function(c, i) {
  4040.       return c = null != c && c, i = null == i ? c : i, this.map(function() {
  4041.         return jQuery.clone(this, c, i);
  4042.       });
  4043.     },
  4044.     html : function(value) {
  4045.       return access(this, function(value) {
  4046.         var elem = this[0] || {};
  4047.         /** @type {number} */
  4048.         var thatpos = 0;
  4049.         var i = this.length;
  4050.         if (void 0 === value && 1 === elem.nodeType) {
  4051.           return elem.innerHTML;
  4052.         }
  4053.         if ("string" == typeof value && !_tacet.test(value) && !wrapMap[(me.exec(value) || ["", ""])[1].toLowerCase()]) {
  4054.           value = jQuery.htmlPrefilter(value);
  4055.           try {
  4056.             for (; thatpos < i; thatpos++) {
  4057.               if (1 === (elem = this[thatpos] || {}).nodeType) {
  4058.                 jQuery.cleanData(getAll(elem, false));
  4059.                 /** @type {number} */
  4060.                 elem.innerHTML = value;
  4061.               }
  4062.             }
  4063.             /** @type {number} */
  4064.             elem = 0;
  4065.           } catch (e) {
  4066.           }
  4067.         }
  4068.         if (elem) {
  4069.           this.empty().append(value);
  4070.         }
  4071.       }, null, value, arguments.length);
  4072.     },
  4073.     replaceWith : function() {
  4074.       /** @type {!Array} */
  4075.       var ignored = [];
  4076.       return domManip(this, arguments, function(textualMod) {
  4077.         var thisParent = this.parentNode;
  4078.         if (jQuery.inArray(this, ignored) < 0) {
  4079.           jQuery.cleanData(getAll(this));
  4080.           if (thisParent) {
  4081.             thisParent.replaceChild(textualMod, this);
  4082.           }
  4083.         }
  4084.       }, ignored);
  4085.     }
  4086.   });
  4087.   jQuery.each({
  4088.     appendTo : "append",
  4089.     prependTo : "prepend",
  4090.     insertBefore : "before",
  4091.     insertAfter : "after",
  4092.     replaceAll : "replaceWith"
  4093.   }, function(original, name) {
  4094.     /**
  4095.      * @param {!Array} path
  4096.      * @return {?}
  4097.      */
  4098.     jQuery.fn[original] = function(path) {
  4099.       var param;
  4100.       /** @type {!Array} */
  4101.       var ret = [];
  4102.       var a = jQuery(path);
  4103.       /** @type {number} */
  4104.       var last = a.length - 1;
  4105.       /** @type {number} */
  4106.       var i = 0;
  4107.       for (; i <= last; i++) {
  4108.         param = i === last ? this : this.clone(true);
  4109.         jQuery(a[i])[name](param);
  4110.         push.apply(ret, param.get());
  4111.       }
  4112.       return this.pushStack(ret);
  4113.     };
  4114.   });
  4115.   /** @type {!RegExp} */
  4116.   var rnumnonpx = new RegExp("^(" + FSSource + ")(?!px)[a-z%]+$", "i");
  4117.   /**
  4118.    * @param {!Object} elem
  4119.    * @return {?}
  4120.    */
  4121.   var getStyles = function(elem) {
  4122.     var win = elem.ownerDocument.defaultView;
  4123.     return win && win.opener || (win = window), win.getComputedStyle(elem);
  4124.   };
  4125.   /**
  4126.    * @param {!Element} e
  4127.    * @param {!Array} obj
  4128.    * @param {!Function} f
  4129.    * @return {?}
  4130.    */
  4131.   var swap = function(e, obj, f) {
  4132.     var result;
  4133.     var key;
  4134.     var pyobj = {};
  4135.     for (key in obj) {
  4136.       pyobj[key] = e.style[key];
  4137.       e.style[key] = obj[key];
  4138.     }
  4139.     for (key in result = f.call(e), obj) {
  4140.       e.style[key] = pyobj[key];
  4141.     }
  4142.     return result;
  4143.   };
  4144.   /** @type {!RegExp} */
  4145.   var inlineAttributeCommentRegex = new RegExp(cssExpand.join("|"), "i");
  4146.   !function() {
  4147.     /**
  4148.      * @return {undefined}
  4149.      */
  4150.     function computeStyleTests() {
  4151.       if (div) {
  4152.         /** @type {string} */
  4153.         parent.style.cssText = "position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0";
  4154.         /** @type {string} */
  4155.         div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%";
  4156.         node.appendChild(parent).appendChild(div);
  4157.         var style = window.getComputedStyle(div);
  4158.         /** @type {boolean} */
  4159.         res = "1%" !== style.top;
  4160.         /** @type {boolean} */
  4161.         s = 12 === parseRound(style.marginLeft);
  4162.         /** @type {string} */
  4163.         div.style.right = "60%";
  4164.         /** @type {boolean} */
  4165.         o = 36 === parseRound(style.right);
  4166.         /** @type {boolean} */
  4167.         r = 36 === parseRound(style.width);
  4168.         /** @type {string} */
  4169.         div.style.position = "absolute";
  4170.         /** @type {boolean} */
  4171.         i = 12 === parseRound(div.offsetWidth / 3);
  4172.         node.removeChild(parent);
  4173.         /** @type {null} */
  4174.         div = null;
  4175.       }
  4176.     }
  4177.     /**
  4178.      * @param {number} fontSize
  4179.      * @return {?}
  4180.      */
  4181.     function parseRound(fontSize) {
  4182.       return Math.round(parseFloat(fontSize));
  4183.     }
  4184.     var res;
  4185.     var r;
  4186.     var i;
  4187.     var o;
  4188.     var a;
  4189.     var s;
  4190.     var parent = document.createElement("div");
  4191.     var div = document.createElement("div");
  4192.     if (div.style) {
  4193.       /** @type {string} */
  4194.       div.style.backgroundClip = "content-box";
  4195.       /** @type {string} */
  4196.       div.cloneNode(true).style.backgroundClip = "";
  4197.       /** @type {boolean} */
  4198.       support.clearCloneStyle = "content-box" === div.style.backgroundClip;
  4199.       jQuery.extend(support, {
  4200.         boxSizingReliable : function() {
  4201.           return computeStyleTests(), r;
  4202.         },
  4203.         pixelBoxStyles : function() {
  4204.           return computeStyleTests(), o;
  4205.         },
  4206.         pixelPosition : function() {
  4207.           return computeStyleTests(), res;
  4208.         },
  4209.         reliableMarginLeft : function() {
  4210.           return computeStyleTests(), s;
  4211.         },
  4212.         scrollboxSize : function() {
  4213.           return computeStyleTests(), i;
  4214.         },
  4215.         reliableTrDimensions : function() {
  4216.           var p;
  4217.           var c;
  4218.           var n;
  4219.           var s;
  4220.           return null == a && (p = document.createElement("table"), c = document.createElement("tr"), n = document.createElement("div"), p.style.cssText = "position:absolute;left:-11111px", c.style.height = "1px", n.style.height = "9px", node.appendChild(p).appendChild(c).appendChild(n), s = window.getComputedStyle(c), a = 3 < parseInt(s.height), node.removeChild(p)), a;
  4221.         }
  4222.       });
  4223.     }
  4224.   }();
  4225.   /** @type {!Array} */
  4226.   var prefixes = ["Webkit", "Moz", "ms"];
  4227.   var testStyle = document.createElement("div").style;
  4228.   var aSupports = {};
  4229.   /** @type {!RegExp} */
  4230.   var rdisplayswap = /^(none|table(?!-c[ea]).+)/;
  4231.   /** @type {!RegExp} */
  4232.   var ngTranslationProvider = /^--/;
  4233.   var cssShow = {
  4234.     position : "absolute",
  4235.     visibility : "hidden",
  4236.     display : "block"
  4237.   };
  4238.   var cssNormalTransform = {
  4239.     letterSpacing : "0",
  4240.     fontWeight : "400"
  4241.   };
  4242.   jQuery.extend({
  4243.     cssHooks : {
  4244.       opacity : {
  4245.         get : function(elem, data) {
  4246.           if (data) {
  4247.             var to = curCSS(elem, "opacity");
  4248.             return "" === to ? "1" : to;
  4249.           }
  4250.         }
  4251.       }
  4252.     },
  4253.     cssNumber : {
  4254.       animationIterationCount : true,
  4255.       columnCount : true,
  4256.       fillOpacity : true,
  4257.       flexGrow : true,
  4258.       flexShrink : true,
  4259.       fontWeight : true,
  4260.       gridArea : true,
  4261.       gridColumn : true,
  4262.       gridColumnEnd : true,
  4263.       gridColumnStart : true,
  4264.       gridRow : true,
  4265.       gridRowEnd : true,
  4266.       gridRowStart : true,
  4267.       lineHeight : true,
  4268.       opacity : true,
  4269.       order : true,
  4270.       orphans : true,
  4271.       widows : true,
  4272.       zIndex : true,
  4273.       zoom : true
  4274.     },
  4275.     cssProps : {},
  4276.     style : function(elem, name, value, extra) {
  4277.       if (elem && 3 !== elem.nodeType && 8 !== elem.nodeType && elem.style) {
  4278.         var ret;
  4279.         var type;
  4280.         var hooks;
  4281.         var prop = camelCase(name);
  4282.         /** @type {boolean} */
  4283.         var versionByName = ngTranslationProvider.test(name);
  4284.         var style = elem.style;
  4285.         if (versionByName || (name = camelize(prop)), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[prop], void 0 === value) {
  4286.           return hooks && "get" in hooks && void 0 !== (ret = hooks.get(elem, false, extra)) ? ret : style[name];
  4287.         }
  4288.         if ("string" === (type = typeof value) && (ret = regex.exec(value)) && ret[1]) {
  4289.           value = adjustCSS(elem, name, ret);
  4290.           /** @type {string} */
  4291.           type = "number";
  4292.         }
  4293.         if (null != value && value == value) {
  4294.           if (!("number" !== type || versionByName)) {
  4295.             /** @type {string} */
  4296.             value = value + (ret && ret[3] || (jQuery.cssNumber[prop] ? "" : "px"));
  4297.           }
  4298.           if (!(support.clearCloneStyle || "" !== value || 0 !== name.indexOf("background"))) {
  4299.             /** @type {string} */
  4300.             style[name] = "inherit";
  4301.           }
  4302.           if (!(hooks && "set" in hooks && void 0 === (value = hooks.set(elem, value, extra)))) {
  4303.             if (versionByName) {
  4304.               style.setProperty(name, value);
  4305.             } else {
  4306.               /** @type {string} */
  4307.               style[name] = value;
  4308.             }
  4309.           }
  4310.         }
  4311.       }
  4312.     },
  4313.     css : function(elem, name, value, styles) {
  4314.       var val;
  4315.       var length;
  4316.       var hooks;
  4317.       var prop = camelCase(name);
  4318.       return ngTranslationProvider.test(name) || (name = camelize(prop)), (hooks = jQuery.cssHooks[name] || jQuery.cssHooks[prop]) && "get" in hooks && (val = hooks.get(elem, true, value)), void 0 === val && (val = curCSS(elem, name, styles)), "normal" === val && name in cssNormalTransform && (val = cssNormalTransform[name]), "" === value || value ? (length = parseFloat(val), true === value || isFinite(length) ? length || 0 : val) : val;
  4319.     }
  4320.   });
  4321.   jQuery.each(["height", "width"], function(canCreateDiscussions, name) {
  4322.     jQuery.cssHooks[name] = {
  4323.       get : function(elem, data, options) {
  4324.         if (data) {
  4325.           return !rdisplayswap.test(jQuery.css(elem, "display")) || elem.getClientRects().length && elem.getBoundingClientRect().width ? load(elem, name, options) : swap(elem, cssShow, function() {
  4326.             return load(elem, name, options);
  4327.           });
  4328.         }
  4329.       },
  4330.       set : function(elem, value, extra) {
  4331.         var match;
  4332.         var styles = getStyles(elem);
  4333.         /** @type {boolean} */
  4334.         var res = !support.scrollboxSize() && "absolute" === styles.position;
  4335.         var valueIsBorderBox = (res || extra) && "border-box" === jQuery.css(elem, "boxSizing", false, styles);
  4336.         var id = extra ? augmentWidthOrHeight(elem, name, extra, valueIsBorderBox, styles) : 0;
  4337.         return valueIsBorderBox && res && (id = id - Math.ceil(elem["offset" + name[0].toUpperCase() + name.slice(1)] - parseFloat(styles[name]) - augmentWidthOrHeight(elem, name, "border", false, styles) - .5)), id && (match = regex.exec(value)) && "px" !== (match[3] || "px") && (elem.style[name] = value, value = jQuery.css(elem, name)), _set(0, value, id);
  4338.       }
  4339.     };
  4340.   });
  4341.   jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(elem, canCreateDiscussions) {
  4342.     if (canCreateDiscussions) {
  4343.       return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
  4344.         marginLeft : 0
  4345.       }, function() {
  4346.         return elem.getBoundingClientRect().left;
  4347.       })) + "px";
  4348.     }
  4349.   });
  4350.   jQuery.each({
  4351.     margin : "",
  4352.     padding : "",
  4353.     border : "Width"
  4354.   }, function(prefix, suffix) {
  4355.     jQuery.cssHooks[prefix + suffix] = {
  4356.       expand : function(expected) {
  4357.         /** @type {number} */
  4358.         var i = 0;
  4359.         var expanded = {};
  4360.         /** @type {!Array} */
  4361.         var stops = "string" == typeof expected ? expected.split(" ") : [expected];
  4362.         for (; i < 4; i++) {
  4363.           expanded[prefix + cssExpand[i] + suffix] = stops[i] || stops[i - 2] || stops[0];
  4364.         }
  4365.         return expanded;
  4366.       }
  4367.     };
  4368.     if ("margin" !== prefix) {
  4369.       /** @type {function(!Object, !Object, string): ?} */
  4370.       jQuery.cssHooks[prefix + suffix].set = _set;
  4371.     }
  4372.   });
  4373.   jQuery.fn.extend({
  4374.     css : function(name, value) {
  4375.       return access(this, function(elem, name, undefined) {
  4376.         var styles;
  4377.         var l;
  4378.         var map = {};
  4379.         /** @type {number} */
  4380.         var i = 0;
  4381.         if (Array.isArray(name)) {
  4382.           styles = getStyles(elem);
  4383.           l = name.length;
  4384.           for (; i < l; i++) {
  4385.             map[name[i]] = jQuery.css(elem, name[i], false, styles);
  4386.           }
  4387.           return map;
  4388.         }
  4389.         return void 0 !== undefined ? jQuery.style(elem, name, undefined) : jQuery.css(elem, name);
  4390.       }, name, value, 1 < arguments.length);
  4391.     }
  4392.   });
  4393.   ((jQuery.Tween = Tween).prototype = {
  4394.     constructor : Tween,
  4395.     init : function(domElem, options, prop, end, easing, unit) {
  4396.       /** @type {!Element} */
  4397.       this.elem = domElem;
  4398.       /** @type {!Object} */
  4399.       this.prop = prop;
  4400.       this.easing = easing || jQuery.easing._default;
  4401.       /** @type {!Object} */
  4402.       this.options = options;
  4403.       this.start = this.now = this.cur();
  4404.       /** @type {number} */
  4405.       this.end = end;
  4406.       this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
  4407.     },
  4408.     cur : function() {
  4409.       var hooks = Tween.propHooks[this.prop];
  4410.       return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
  4411.     },
  4412.     run : function(percent) {
  4413.       var eased;
  4414.       var hooks = Tween.propHooks[this.prop];
  4415.       return this.options.duration ? this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : this.pos = eased = percent, this.now = (this.end - this.start) * eased + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), hooks && hooks.set ? hooks.set(this) : Tween.propHooks._default.set(this), this;
  4416.     }
  4417.   }).init.prototype = Tween.prototype;
  4418.   (Tween.propHooks = {
  4419.     _default : {
  4420.       get : function(s) {
  4421.         var fitWidth;
  4422.         return 1 !== s.elem.nodeType || null != s.elem[s.prop] && null == s.elem.style[s.prop] ? s.elem[s.prop] : (fitWidth = jQuery.css(s.elem, s.prop, "")) && "auto" !== fitWidth ? fitWidth : 0;
  4423.       },
  4424.       set : function(tween) {
  4425.         if (jQuery.fx.step[tween.prop]) {
  4426.           jQuery.fx.step[tween.prop](tween);
  4427.         } else {
  4428.           if (1 !== tween.elem.nodeType || !jQuery.cssHooks[tween.prop] && null == tween.elem.style[camelize(tween.prop)]) {
  4429.             tween.elem[tween.prop] = tween.now;
  4430.           } else {
  4431.             jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
  4432.           }
  4433.         }
  4434.       }
  4435.     }
  4436.   }).scrollTop = Tween.propHooks.scrollLeft = {
  4437.     set : function(tween) {
  4438.       if (tween.elem.nodeType && tween.elem.parentNode) {
  4439.         tween.elem[tween.prop] = tween.now;
  4440.       }
  4441.     }
  4442.   };
  4443.   jQuery.easing = {
  4444.     linear : function(p) {
  4445.       return p;
  4446.     },
  4447.     swing : function(p) {
  4448.       return .5 - Math.cos(p * Math.PI) / 2;
  4449.     },
  4450.     _default : "swing"
  4451.   };
  4452.   /** @type {function(!Element, !Object, !Object, number, string, string): undefined} */
  4453.   jQuery.fx = Tween.prototype.init;
  4454.   jQuery.fx.step = {};
  4455.   var fxNow;
  4456.   var nt;
  4457.   var elem;
  4458.   var opt;
  4459.   /** @type {!RegExp} */
  4460.   var trueRE = /^(?:toggle|show|hide)$/;
  4461.   /** @type {!RegExp} */
  4462.   var rrun = /queueHooks$/;
  4463.   jQuery.Animation = jQuery.extend(Animation, {
  4464.     tweeners : {
  4465.       "*" : [function(prop, value) {
  4466.         var tween = this.createTween(prop, value);
  4467.         return adjustCSS(tween.elem, prop, regex.exec(value), tween), tween;
  4468.       }]
  4469.     },
  4470.     tweener : function(props, callback) {
  4471.       if (fn(props)) {
  4472.         /** @type {!Object} */
  4473.         callback = props;
  4474.         /** @type {!Array} */
  4475.         props = ["*"];
  4476.       } else {
  4477.         props = props.match(re);
  4478.       }
  4479.       var prop;
  4480.       /** @type {number} */
  4481.       var i = 0;
  4482.       var inputsSize = props.length;
  4483.       for (; i < inputsSize; i++) {
  4484.         prop = props[i];
  4485.         Animation.tweeners[prop] = Animation.tweeners[prop] || [];
  4486.         Animation.tweeners[prop].unshift(callback);
  4487.       }
  4488.     },
  4489.     prefilters : [function(elem, props, config) {
  4490.       var prop;
  4491.       var value;
  4492.       var matched;
  4493.       var hooks;
  4494.       var oldfire;
  4495.       var tween;
  4496.       var restoreDisplay;
  4497.       var display;
  4498.       /** @type {boolean} */
  4499.       var f = "width" in props || "height" in props;
  4500.       var anim = this;
  4501.       var orig = {};
  4502.       var style = elem.style;
  4503.       var hidden = elem.nodeType && isHidden(elem);
  4504.       var dataShow = dataPriv.get(elem, "fxshow");
  4505.       for (prop in config.queue || (null == (hooks = jQuery._queueHooks(elem, "fx")).unqueued && (hooks.unqueued = 0, oldfire = hooks.empty.fire, hooks.empty.fire = function() {
  4506.         if (!hooks.unqueued) {
  4507.           oldfire();
  4508.         }
  4509.       }), hooks.unqueued++, anim.always(function() {
  4510.         anim.always(function() {
  4511.           hooks.unqueued--;
  4512.           if (!jQuery.queue(elem, "fx").length) {
  4513.             hooks.empty.fire();
  4514.           }
  4515.         });
  4516.       })), props) {
  4517.         if (value = props[prop], trueRE.test(value)) {
  4518.           if (delete props[prop], matched = matched || "toggle" === value, value === (hidden ? "hide" : "show")) {
  4519.             if ("show" !== value || !dataShow || void 0 === dataShow[prop]) {
  4520.               continue;
  4521.             }
  4522.             /** @type {boolean} */
  4523.             hidden = true;
  4524.           }
  4525.           orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
  4526.         }
  4527.       }
  4528.       if ((tween = !jQuery.isEmptyObject(props)) || !jQuery.isEmptyObject(orig)) {
  4529.         for (prop in f && 1 === elem.nodeType && (config.overflow = [style.overflow, style.overflowX, style.overflowY], null == (restoreDisplay = dataShow && dataShow.display) && (restoreDisplay = dataPriv.get(elem, "display")), "none" === (display = jQuery.css(elem, "display")) && (restoreDisplay ? display = restoreDisplay : (show([elem], true), restoreDisplay = elem.style.display || restoreDisplay, display = jQuery.css(elem, "display"), show([elem]))), ("inline" === display || "inline-block" ===
  4530.         display && null != restoreDisplay) && "none" === jQuery.css(elem, "float") && (tween || (anim.done(function() {
  4531.           style.display = restoreDisplay;
  4532.         }), null == restoreDisplay && (display = style.display, restoreDisplay = "none" === display ? "" : display)), style.display = "inline-block")), config.overflow && (style.overflow = "hidden", anim.always(function() {
  4533.           style.overflow = config.overflow[0];
  4534.           style.overflowX = config.overflow[1];
  4535.           style.overflowY = config.overflow[2];
  4536.         })), tween = false, orig) {
  4537.           if (!tween) {
  4538.             if (dataShow) {
  4539.               if ("hidden" in dataShow) {
  4540.                 hidden = dataShow.hidden;
  4541.               }
  4542.             } else {
  4543.               dataShow = dataPriv.access(elem, "fxshow", {
  4544.                 display : restoreDisplay
  4545.               });
  4546.             }
  4547.             if (matched) {
  4548.               /** @type {boolean} */
  4549.               dataShow.hidden = !hidden;
  4550.             }
  4551.             if (hidden) {
  4552.               show([elem], true);
  4553.             }
  4554.             anim.done(function() {
  4555.               for (prop in hidden || show([elem]), dataPriv.remove(elem, "fxshow"), orig) {
  4556.                 jQuery.style(elem, prop, orig[prop]);
  4557.               }
  4558.             });
  4559.           }
  4560.           tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
  4561.           if (!(prop in dataShow)) {
  4562.             dataShow[prop] = tween.start;
  4563.             if (hidden) {
  4564.               tween.end = tween.start;
  4565.               /** @type {number} */
  4566.               tween.start = 0;
  4567.             }
  4568.           }
  4569.         }
  4570.       }
  4571.     }],
  4572.     prefilter : function(callback, options) {
  4573.       if (options) {
  4574.         Animation.prefilters.unshift(callback);
  4575.       } else {
  4576.         Animation.prefilters.push(callback);
  4577.       }
  4578.     }
  4579.   });
  4580.   /**
  4581.    * @param {string} speed
  4582.    * @param {boolean} easing
  4583.    * @param {string} callback
  4584.    * @return {?}
  4585.    */
  4586.   jQuery.speed = function(speed, easing, callback) {
  4587.     var opt = speed && "object" == typeof speed ? jQuery.extend({}, speed) : {
  4588.       complete : callback || !callback && easing || fn(speed) && speed,
  4589.       duration : speed,
  4590.       easing : callback && easing || easing && !fn(easing) && easing
  4591.     };
  4592.     return jQuery.fx.off ? opt.duration = 0 : "number" != typeof opt.duration && (opt.duration in jQuery.fx.speeds ? opt.duration = jQuery.fx.speeds[opt.duration] : opt.duration = jQuery.fx.speeds._default), null != opt.queue && true !== opt.queue || (opt.queue = "fx"), opt.old = opt.complete, opt.complete = function() {
  4593.       if (fn(opt.old)) {
  4594.         opt.old.call(this);
  4595.       }
  4596.       if (opt.queue) {
  4597.         jQuery.dequeue(this, opt.queue);
  4598.       }
  4599.     }, opt;
  4600.   };
  4601.   jQuery.fn.extend({
  4602.     fadeTo : function(speed, to, callback, context) {
  4603.       return this.filter(isHidden).css("opacity", 0).show().end().animate({
  4604.         opacity : to
  4605.       }, speed, callback, context);
  4606.     },
  4607.     animate : function(prop, speed, easing, callback) {
  4608.       var empty = jQuery.isEmptyObject(prop);
  4609.       var optall = jQuery.speed(speed, easing, callback);
  4610.       /**
  4611.        * @return {undefined}
  4612.        */
  4613.       var doAnimation = function() {
  4614.         var anim = Animation(this, jQuery.extend({}, prop), optall);
  4615.         if (empty || dataPriv.get(this, "finish")) {
  4616.           anim.stop(true);
  4617.         }
  4618.       };
  4619.       return doAnimation.finish = doAnimation, empty || false === optall.queue ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
  4620.     },
  4621.     stop : function(type, n, e) {
  4622.       /**
  4623.        * @param {!Object} hooks
  4624.        * @return {undefined}
  4625.        */
  4626.       var stopQueue = function(hooks) {
  4627.         var stop = hooks.stop;
  4628.         delete hooks.stop;
  4629.         stop(e);
  4630.       };
  4631.       return "string" != typeof type && (e = n, n = type, type = void 0), n && this.queue(type || "fx", []), this.each(function() {
  4632.         /** @type {boolean} */
  4633.         var boolToParent = true;
  4634.         /** @type {(boolean|string)} */
  4635.         var index = null != type && type + "queueHooks";
  4636.         /** @type {!Array} */
  4637.         var timers = jQuery.timers;
  4638.         var data = dataPriv.get(this);
  4639.         if (index) {
  4640.           if (data[index] && data[index].stop) {
  4641.             stopQueue(data[index]);
  4642.           }
  4643.         } else {
  4644.           for (index in data) {
  4645.             if (data[index] && data[index].stop && rrun.test(index)) {
  4646.               stopQueue(data[index]);
  4647.             }
  4648.           }
  4649.         }
  4650.         /** @type {number} */
  4651.         index = timers.length;
  4652.         for (; index--;) {
  4653.           if (!(timers[index].elem !== this || null != type && timers[index].queue !== type)) {
  4654.             timers[index].anim.stop(e);
  4655.             /** @type {boolean} */
  4656.             boolToParent = false;
  4657.             timers.splice(index, 1);
  4658.           }
  4659.         }
  4660.         if (!(!boolToParent && e)) {
  4661.           jQuery.dequeue(this, type);
  4662.         }
  4663.       });
  4664.     },
  4665.     finish : function(type) {
  4666.       return false !== type && (type = type || "fx"), this.each(function() {
  4667.         var index;
  4668.         var data = dataPriv.get(this);
  4669.         var queue = data[type + "queue"];
  4670.         var hooks = data[type + "queueHooks"];
  4671.         /** @type {!Array} */
  4672.         var timers = jQuery.timers;
  4673.         var length = queue ? queue.length : 0;
  4674.         /** @type {boolean} */
  4675.         data.finish = true;
  4676.         jQuery.queue(this, type, []);
  4677.         if (hooks && hooks.stop) {
  4678.           hooks.stop.call(this, true);
  4679.         }
  4680.         /** @type {number} */
  4681.         index = timers.length;
  4682.         for (; index--;) {
  4683.           if (timers[index].elem === this && timers[index].queue === type) {
  4684.             timers[index].anim.stop(true);
  4685.             timers.splice(index, 1);
  4686.           }
  4687.         }
  4688.         /** @type {number} */
  4689.         index = 0;
  4690.         for (; index < length; index++) {
  4691.           if (queue[index] && queue[index].finish) {
  4692.             queue[index].finish.call(this);
  4693.           }
  4694.         }
  4695.         delete data.finish;
  4696.       });
  4697.     }
  4698.   });
  4699.   jQuery.each(["toggle", "show", "hide"], function(canCreateDiscussions, name) {
  4700.     var cssFn = jQuery.fn[name];
  4701.     /**
  4702.      * @param {string} x
  4703.      * @param {boolean} callback
  4704.      * @param {string} options
  4705.      * @return {?}
  4706.      */
  4707.     jQuery.fn[name] = function(x, callback, options) {
  4708.       return null == x || "boolean" == typeof x ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), x, callback, options);
  4709.     };
  4710.   });
  4711.   jQuery.each({
  4712.     slideDown : genFx("show"),
  4713.     slideUp : genFx("hide"),
  4714.     slideToggle : genFx("toggle"),
  4715.     fadeIn : {
  4716.       opacity : "show"
  4717.     },
  4718.     fadeOut : {
  4719.       opacity : "hide"
  4720.     },
  4721.     fadeToggle : {
  4722.       opacity : "toggle"
  4723.     }
  4724.   }, function(original, props) {
  4725.     /**
  4726.      * @param {string} speed
  4727.      * @param {boolean} callback
  4728.      * @param {string} options
  4729.      * @return {?}
  4730.      */
  4731.     jQuery.fn[original] = function(speed, callback, options) {
  4732.       return this.animate(props, speed, callback, options);
  4733.     };
  4734.   });
  4735.   /** @type {!Array} */
  4736.   jQuery.timers = [];
  4737.   /**
  4738.    * @return {undefined}
  4739.    */
  4740.   jQuery.fx.tick = function() {
  4741.     var maxBet;
  4742.     /** @type {number} */
  4743.     var i = 0;
  4744.     /** @type {!Array} */
  4745.     var timers = jQuery.timers;
  4746.     /** @type {number} */
  4747.     fxNow = Date.now();
  4748.     for (; i < timers.length; i++) {
  4749.       if (!((maxBet = timers[i])() || timers[i] !== maxBet)) {
  4750.         timers.splice(i--, 1);
  4751.       }
  4752.     }
  4753.     if (!timers.length) {
  4754.       jQuery.fx.stop();
  4755.     }
  4756.     fxNow = void 0;
  4757.   };
  4758.   /**
  4759.    * @param {?} url
  4760.    * @return {undefined}
  4761.    */
  4762.   jQuery.fx.timer = function(url) {
  4763.     jQuery.timers.push(url);
  4764.     jQuery.fx.start();
  4765.   };
  4766.   /** @type {number} */
  4767.   jQuery.fx.interval = 13;
  4768.   /**
  4769.    * @return {undefined}
  4770.    */
  4771.   jQuery.fx.start = function() {
  4772.     if (!nt) {
  4773.       /** @type {boolean} */
  4774.       nt = true;
  4775.       step();
  4776.     }
  4777.   };
  4778.   /**
  4779.    * @return {undefined}
  4780.    */
  4781.   jQuery.fx.stop = function() {
  4782.     /** @type {null} */
  4783.     nt = null;
  4784.   };
  4785.   jQuery.fx.speeds = {
  4786.     slow : 600,
  4787.     fast : 200,
  4788.     _default : 400
  4789.   };
  4790.   /**
  4791.    * @param {!Object} b
  4792.    * @param {!Object} type
  4793.    * @return {?}
  4794.    */
  4795.   jQuery.fn.delay = function(b, type) {
  4796.     return b = jQuery.fx && jQuery.fx.speeds[b] || b, type = type || "fx", this.queue(type, function(show, incoming_item) {
  4797.       var cb = window.setTimeout(show, b);
  4798.       /**
  4799.        * @return {undefined}
  4800.        */
  4801.       incoming_item.stop = function() {
  4802.         window.clearTimeout(cb);
  4803.       };
  4804.     });
  4805.   };
  4806.   elem = document.createElement("input");
  4807.   opt = document.createElement("select").appendChild(document.createElement("option"));
  4808.   /** @type {string} */
  4809.   elem.type = "checkbox";
  4810.   /** @type {boolean} */
  4811.   support.checkOn = "" !== elem.value;
  4812.   support.optSelected = opt.selected;
  4813.   /** @type {string} */
  4814.   (elem = document.createElement("input")).value = "t";
  4815.   /** @type {string} */
  4816.   elem.type = "radio";
  4817.   /** @type {boolean} */
  4818.   support.radioValue = "t" === elem.value;
  4819.   var boolHook;
  4820.   var attrHandle = jQuery.expr.attrHandle;
  4821.   jQuery.fn.extend({
  4822.     attr : function(value, name) {
  4823.       return access(this, jQuery.attr, value, name, 1 < arguments.length);
  4824.     },
  4825.     removeAttr : function(name) {
  4826.       return this.each(function() {
  4827.         jQuery.removeAttr(this, name);
  4828.       });
  4829.     }
  4830.   });
  4831.   jQuery.extend({
  4832.     attr : function(elem, name, value) {
  4833.       var ret;
  4834.       var hooks;
  4835.       var type = elem.nodeType;
  4836.       if (3 !== type && 8 !== type && 2 !== type) {
  4837.         return "undefined" == typeof elem.getAttribute ? jQuery.prop(elem, name, value) : (1 === type && jQuery.isXMLDoc(elem) || (hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : void 0)), void 0 !== value ? null === value ? void jQuery.removeAttr(elem, name) : hooks && "set" in hooks && void 0 !== (ret = hooks.set(elem, value, name)) ? ret : (elem.setAttribute(name, value + ""), value) : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ?
  4838.         ret : null == (ret = jQuery.find.attr(elem, name)) ? void 0 : ret);
  4839.       }
  4840.     },
  4841.     attrHooks : {
  4842.       type : {
  4843.         set : function(item, value) {
  4844.           if (!support.radioValue && "radio" === value && callback(item, "input")) {
  4845.             var n = item.value;
  4846.             return item.setAttribute("type", value), n && (item.value = n), value;
  4847.           }
  4848.         }
  4849.       }
  4850.     },
  4851.     removeAttr : function(elem, name) {
  4852.       var ATTR_MAXLENGTH;
  4853.       /** @type {number} */
  4854.       var callbackCount = 0;
  4855.       var callbackVals = name && name.match(re);
  4856.       if (callbackVals && 1 === elem.nodeType) {
  4857.         for (; ATTR_MAXLENGTH = callbackVals[callbackCount++];) {
  4858.           elem.removeAttribute(ATTR_MAXLENGTH);
  4859.         }
  4860.       }
  4861.     }
  4862.   });
  4863.   boolHook = {
  4864.     set : function(elem, value, name) {
  4865.       return false === value ? jQuery.removeAttr(elem, name) : elem.setAttribute(name, name), name;
  4866.     }
  4867.   };
  4868.   jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(canCreateDiscussions, name) {
  4869.     var callService$1 = attrHandle[name] || jQuery.find.attr;
  4870.     /**
  4871.      * @param {undefined} e
  4872.      * @param {string} t
  4873.      * @param {number} n
  4874.      * @return {?}
  4875.      */
  4876.     attrHandle[name] = function(e, t, n) {
  4877.       var ret;
  4878.       var handle;
  4879.       var lowercaseName = t.toLowerCase();
  4880.       return n || (handle = attrHandle[lowercaseName], attrHandle[lowercaseName] = ret, ret = null != callService$1(e, t, n) ? lowercaseName : null, attrHandle[lowercaseName] = handle), ret;
  4881.     };
  4882.   });
  4883.   /** @type {!RegExp} */
  4884.   var inputNodeNames = /^(?:input|select|textarea|button)$/i;
  4885.   /** @type {!RegExp} */
  4886.   var srsRegex = /^(?:a|area)$/i;
  4887.   jQuery.fn.extend({
  4888.     prop : function(type, value) {
  4889.       return access(this, jQuery.prop, type, value, 1 < arguments.length);
  4890.     },
  4891.     removeProp : function(name) {
  4892.       return this.each(function() {
  4893.         delete this[jQuery.propFix[name] || name];
  4894.       });
  4895.     }
  4896.   });
  4897.   jQuery.extend({
  4898.     prop : function(elem, name, value) {
  4899.       var ret;
  4900.       var hooks;
  4901.       var type = elem.nodeType;
  4902.       if (3 !== type && 8 !== type && 2 !== type) {
  4903.         return 1 === type && jQuery.isXMLDoc(elem) || (name = jQuery.propFix[name] || name, hooks = jQuery.propHooks[name]), void 0 !== value ? hooks && "set" in hooks && void 0 !== (ret = hooks.set(elem, value, name)) ? ret : elem[name] = value : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ? ret : elem[name];
  4904.       }
  4905.     },
  4906.     propHooks : {
  4907.       tabIndex : {
  4908.         get : function(target) {
  4909.           var b = jQuery.find.attr(target, "tabindex");
  4910.           return b ? parseInt(b, 10) : inputNodeNames.test(target.nodeName) || srsRegex.test(target.nodeName) && target.href ? 0 : -1;
  4911.         }
  4912.       }
  4913.     },
  4914.     propFix : {
  4915.       "for" : "htmlFor",
  4916.       "class" : "className"
  4917.     }
  4918.   });
  4919.   if (!support.optSelected) {
  4920.     jQuery.propHooks.selected = {
  4921.       get : function(e) {
  4922.         var elem = e.parentNode;
  4923.         return elem && elem.parentNode && elem.parentNode.selectedIndex, null;
  4924.       },
  4925.       set : function(e) {
  4926.         var elem = e.parentNode;
  4927.         if (elem) {
  4928.           elem.selectedIndex;
  4929.           if (elem.parentNode) {
  4930.             elem.parentNode.selectedIndex;
  4931.           }
  4932.         }
  4933.       }
  4934.     };
  4935.   }
  4936.   jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
  4937.     jQuery.propFix[this.toLowerCase()] = this;
  4938.   });
  4939.   jQuery.fn.extend({
  4940.     addClass : function(callback) {
  4941.       var result;
  4942.       var next;
  4943.       var i;
  4944.       var m;
  4945.       var k;
  4946.       var j;
  4947.       var a;
  4948.       /** @type {number} */
  4949.       var u = 0;
  4950.       if (fn(callback)) {
  4951.         return this.each(function(i) {
  4952.           jQuery(this).addClass(callback.call(this, i, $(this)));
  4953.         });
  4954.       }
  4955.       if ((result = clean(callback)).length) {
  4956.         for (; next = this[u++];) {
  4957.           if (m = $(next), i = 1 === next.nodeType && " " + merge(m) + " ") {
  4958.             /** @type {number} */
  4959.             j = 0;
  4960.             for (; k = result[j++];) {
  4961.               if (i.indexOf(" " + k + " ") < 0) {
  4962.                 /** @type {string} */
  4963.                 i = i + (k + " ");
  4964.               }
  4965.             }
  4966.             if (m !== (a = merge(i))) {
  4967.               next.setAttribute("class", a);
  4968.             }
  4969.           }
  4970.         }
  4971.       }
  4972.       return this;
  4973.     },
  4974.     removeClass : function(callback) {
  4975.       var result;
  4976.       var n;
  4977.       var f;
  4978.       var i;
  4979.       var activeObserveHandle;
  4980.       var j;
  4981.       var p;
  4982.       /** @type {number} */
  4983.       var u = 0;
  4984.       if (fn(callback)) {
  4985.         return this.each(function(i) {
  4986.           jQuery(this).removeClass(callback.call(this, i, $(this)));
  4987.         });
  4988.       }
  4989.       if (!arguments.length) {
  4990.         return this.attr("class", "");
  4991.       }
  4992.       if ((result = clean(callback)).length) {
  4993.         for (; n = this[u++];) {
  4994.           if (i = $(n), f = 1 === n.nodeType && " " + merge(i) + " ") {
  4995.             /** @type {number} */
  4996.             j = 0;
  4997.             for (; activeObserveHandle = result[j++];) {
  4998.               for (; -1 < f.indexOf(" " + activeObserveHandle + " ");) {
  4999.                 /** @type {string} */
  5000.                 f = f.replace(" " + activeObserveHandle + " ", " ");
  5001.               }
  5002.             }
  5003.             if (i !== (p = merge(f))) {
  5004.               n.setAttribute("class", p);
  5005.             }
  5006.           }
  5007.         }
  5008.       }
  5009.       return this;
  5010.     },
  5011.     toggleClass : function(value, stateVal) {
  5012.       /** @type {string} */
  5013.       var undefined = typeof value;
  5014.       /** @type {boolean} */
  5015.       var a = "string" === undefined || Array.isArray(value);
  5016.       return "boolean" == typeof stateVal && a ? stateVal ? this.addClass(value) : this.removeClass(value) : fn(value) ? this.each(function(i) {
  5017.         jQuery(this).toggleClass(value.call(this, i, $(this), stateVal), stateVal);
  5018.       }) : this.each(function() {
  5019.         var className;
  5020.         var pindex;
  5021.         var $body;
  5022.         var parts;
  5023.         if (a) {
  5024.           /** @type {number} */
  5025.           pindex = 0;
  5026.           $body = jQuery(this);
  5027.           parts = clean(value);
  5028.           for (; className = parts[pindex++];) {
  5029.             if ($body.hasClass(className)) {
  5030.               $body.removeClass(className);
  5031.             } else {
  5032.               $body.addClass(className);
  5033.             }
  5034.           }
  5035.         } else {
  5036.           if (!(void 0 !== value && "boolean" !== undefined)) {
  5037.             if (className = $(this)) {
  5038.               dataPriv.set(this, "__className__", className);
  5039.             }
  5040.             if (this.setAttribute) {
  5041.               this.setAttribute("class", className || false === value ? "" : dataPriv.get(this, "__className__") || "");
  5042.             }
  5043.           }
  5044.         }
  5045.       });
  5046.     },
  5047.     hasClass : function(elem) {
  5048.       var exactLanguageCode;
  5049.       var target;
  5050.       /** @type {number} */
  5051.       var r = 0;
  5052.       /** @type {string} */
  5053.       exactLanguageCode = " " + elem + " ";
  5054.       for (; target = this[r++];) {
  5055.         if (1 === target.nodeType && -1 < (" " + merge($(target)) + " ").indexOf(exactLanguageCode)) {
  5056.           return true;
  5057.         }
  5058.       }
  5059.       return false;
  5060.     }
  5061.   });
  5062.   /** @type {!RegExp} */
  5063.   var n = /\r/g;
  5064.   jQuery.fn.extend({
  5065.     val : function(v) {
  5066.       var hooks;
  5067.       var value;
  5068.       var raw;
  5069.       var elem = this[0];
  5070.       return arguments.length ? (raw = fn(v), this.each(function(a) {
  5071.         var val;
  5072.         if (1 === this.nodeType) {
  5073.           if (null == (val = raw ? v.call(this, a, jQuery(this).val()) : v)) {
  5074.             /** @type {string} */
  5075.             val = "";
  5076.           } else {
  5077.             if ("number" == typeof val) {
  5078.               /** @type {string} */
  5079.               val = val + "";
  5080.             } else {
  5081.               if (Array.isArray(val)) {
  5082.                 val = jQuery.map(val, function(value) {
  5083.                   return null == value ? "" : value + "";
  5084.                 });
  5085.               }
  5086.             }
  5087.           }
  5088.           if (!((hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]) && "set" in hooks && void 0 !== hooks.set(this, val, "value"))) {
  5089.             this.value = val;
  5090.           }
  5091.         }
  5092.       })) : elem ? (hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]) && "get" in hooks && void 0 !== (value = hooks.get(elem, "value")) ? value : "string" == typeof(value = elem.value) ? value.replace(n, "") : null == value ? "" : value : void 0;
  5093.     }
  5094.   });
  5095.   jQuery.extend({
  5096.     valHooks : {
  5097.       option : {
  5098.         get : function(key) {
  5099.           var isInvalid = jQuery.find.attr(key, "value");
  5100.           return null != isInvalid ? isInvalid : merge(jQuery.text(key));
  5101.         }
  5102.       },
  5103.       select : {
  5104.         get : function(elm) {
  5105.           var value;
  5106.           var e;
  5107.           var i;
  5108.           var data = elm.options;
  5109.           var index = elm.selectedIndex;
  5110.           /** @type {boolean} */
  5111.           var one = "select-one" === elm.type;
  5112.           /** @type {(Array|null)} */
  5113.           var values = one ? null : [];
  5114.           var max = one ? index + 1 : data.length;
  5115.           i = index < 0 ? max : one ? index : 0;
  5116.           for (; i < max; i++) {
  5117.             if (((e = data[i]).selected || i === index) && !e.disabled && (!e.parentNode.disabled || !callback(e.parentNode, "optgroup"))) {
  5118.               if (value = jQuery(e).val(), one) {
  5119.                 return value;
  5120.               }
  5121.               values.push(value);
  5122.             }
  5123.           }
  5124.           return values;
  5125.         },
  5126.         set : function(context, value) {
  5127.           var outputFn;
  5128.           var b;
  5129.           var a = context.options;
  5130.           var result = jQuery.makeArray(value);
  5131.           var i = a.length;
  5132.           for (; i--;) {
  5133.             if ((b = a[i]).selected = -1 < jQuery.inArray(jQuery.valHooks.option.get(b), result)) {
  5134.               /** @type {boolean} */
  5135.               outputFn = true;
  5136.             }
  5137.           }
  5138.           return outputFn || (context.selectedIndex = -1), result;
  5139.         }
  5140.       }
  5141.     }
  5142.   });
  5143.   jQuery.each(["radio", "checkbox"], function() {
  5144.     jQuery.valHooks[this] = {
  5145.       set : function(elem, value) {
  5146.         if (Array.isArray(value)) {
  5147.           return elem.checked = -1 < jQuery.inArray(jQuery(elem).val(), value);
  5148.         }
  5149.       }
  5150.     };
  5151.     if (!support.checkOn) {
  5152.       /**
  5153.        * @param {!Object} elem
  5154.        * @return {?}
  5155.        */
  5156.       jQuery.valHooks[this].get = function(elem) {
  5157.         return null === elem.getAttribute("value") ? "on" : elem.value;
  5158.       };
  5159.     }
  5160.   });
  5161.   /** @type {boolean} */
  5162.   support.focusin = "onfocusin" in window;
  5163.   /** @type {!RegExp} */
  5164.   var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
  5165.   /**
  5166.    * @param {!Event} e
  5167.    * @return {undefined}
  5168.    */
  5169.   var onInspectorMove = function(e) {
  5170.     e.stopPropagation();
  5171.   };
  5172.   jQuery.extend(jQuery.event, {
  5173.     trigger : function(event, value, elem, onlyHandlers) {
  5174.       var i;
  5175.       var cur;
  5176.       var tmp;
  5177.       var bubbleType;
  5178.       var ontype;
  5179.       var next;
  5180.       var special;
  5181.       var parent;
  5182.       /** @type {!Array} */
  5183.       var eventPath = [elem || document];
  5184.       var type = hasOwn.call(event, "type") ? event.type : event;
  5185.       var parts = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
  5186.       if (cur = parent = tmp = elem = elem || document, 3 !== elem.nodeType && 8 !== elem.nodeType && !rfocusMorph.test(type + jQuery.event.triggered) && (-1 < type.indexOf(".") && (type = (parts = type.split(".")).shift(), parts.sort()), ontype = type.indexOf(":") < 0 && "on" + type, (event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event)).isTrigger = onlyHandlers ? 2 : 3, event.namespace = parts.join("."), event.rnamespace = event.namespace ? new RegExp("(^|\\.)" +
  5187.       parts.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, event.result = void 0, event.target || (event.target = elem), value = null == value ? [event] : jQuery.makeArray(value, [event]), special = jQuery.event.special[type] || {}, onlyHandlers || !special.trigger || false !== special.trigger.apply(elem, value))) {
  5188.         if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
  5189.           bubbleType = special.delegateType || type;
  5190.           if (!rfocusMorph.test(bubbleType + type)) {
  5191.             cur = cur.parentNode;
  5192.           }
  5193.           for (; cur; cur = cur.parentNode) {
  5194.             eventPath.push(cur);
  5195.             tmp = cur;
  5196.           }
  5197.           if (tmp === (elem.ownerDocument || document)) {
  5198.             eventPath.push(tmp.defaultView || tmp.parentWindow || window);
  5199.           }
  5200.         }
  5201.         /** @type {number} */
  5202.         i = 0;
  5203.         for (; (cur = eventPath[i++]) && !event.isPropagationStopped();) {
  5204.           parent = cur;
  5205.           event.type = 1 < i ? bubbleType : special.bindType || type;
  5206.           if (next = (dataPriv.get(cur, "events") || Object.create(null))[event.type] && dataPriv.get(cur, "handle")) {
  5207.             next.apply(cur, value);
  5208.           }
  5209.           if ((next = ontype && cur[ontype]) && next.apply && acceptData(cur)) {
  5210.             event.result = next.apply(cur, value);
  5211.             if (false === event.result) {
  5212.               event.preventDefault();
  5213.             }
  5214.           }
  5215.         }
  5216.         return event.type = type, onlyHandlers || event.isDefaultPrevented() || special._default && false !== special._default.apply(eventPath.pop(), value) || !acceptData(elem) || ontype && fn(elem[type]) && !isWindow(elem) && ((tmp = elem[ontype]) && (elem[ontype] = null), jQuery.event.triggered = type, event.isPropagationStopped() && parent.addEventListener(type, onInspectorMove), elem[type](), event.isPropagationStopped() && parent.removeEventListener(type, onInspectorMove), jQuery.event.triggered =
  5217.         void 0, tmp && (elem[ontype] = tmp)), event.result;
  5218.       }
  5219.     },
  5220.     simulate : function(type, node, options) {
  5221.       var r = jQuery.extend(new jQuery.Event, options, {
  5222.         type : type,
  5223.         isSimulated : true
  5224.       });
  5225.       jQuery.event.trigger(r, null, node);
  5226.     }
  5227.   });
  5228.   jQuery.fn.extend({
  5229.     trigger : function(event, data) {
  5230.       return this.each(function() {
  5231.         jQuery.event.trigger(event, data, this);
  5232.       });
  5233.     },
  5234.     triggerHandler : function(type, data) {
  5235.       var parent = this[0];
  5236.       if (parent) {
  5237.         return jQuery.event.trigger(type, data, parent, true);
  5238.       }
  5239.     }
  5240.   });
  5241.   if (!support.focusin) {
  5242.     jQuery.each({
  5243.       focus : "focusin",
  5244.       blur : "focusout"
  5245.     }, function(type, name) {
  5246.       /**
  5247.        * @param {(Object|string)} event
  5248.        * @return {undefined}
  5249.        */
  5250.       var handler = function(event) {
  5251.         jQuery.event.simulate(name, event.target, jQuery.event.fix(event));
  5252.       };
  5253.       jQuery.event.special[name] = {
  5254.         setup : function() {
  5255.           var node = this.ownerDocument || this.document || this;
  5256.           var ownName = dataPriv.access(node, name);
  5257.           if (!ownName) {
  5258.             node.addEventListener(type, handler, true);
  5259.           }
  5260.           dataPriv.access(node, name, (ownName || 0) + 1);
  5261.         },
  5262.         teardown : function() {
  5263.           var elem = this.ownerDocument || this.document || this;
  5264.           /** @type {number} */
  5265.           var data = dataPriv.access(elem, name) - 1;
  5266.           if (data) {
  5267.             dataPriv.access(elem, name, data);
  5268.           } else {
  5269.             elem.removeEventListener(type, handler, true);
  5270.             dataPriv.remove(elem, name);
  5271.           }
  5272.         }
  5273.       };
  5274.     });
  5275.   }
  5276.   var location = window.location;
  5277.   var _enum = {
  5278.     guid : Date.now()
  5279.   };
  5280.   /** @type {!RegExp} */
  5281.   var rquery = /\?/;
  5282.   /**
  5283.    * @param {string} data
  5284.    * @return {?}
  5285.    */
  5286.   jQuery.parseXML = function(data) {
  5287.     var xml;
  5288.     if (!data || "string" != typeof data) {
  5289.       return null;
  5290.     }
  5291.     try {
  5292.       xml = (new window.DOMParser).parseFromString(data, "text/xml");
  5293.     } catch (e) {
  5294.       xml = void 0;
  5295.     }
  5296.     return xml && !xml.getElementsByTagName("parsererror").length || jQuery.error("Invalid XML: " + data), xml;
  5297.   };
  5298.   /** @type {!RegExp} */
  5299.   var reIsFile = /\[\]$/;
  5300.   /** @type {!RegExp} */
  5301.   var reVowels = /\r?\n/g;
  5302.   /** @type {!RegExp} */
  5303.   var reHasHexPrefix = /^(?:submit|button|image|reset|file)$/i;
  5304.   /** @type {!RegExp} */
  5305.   var rsubmittable = /^(?:input|select|textarea|keygen)/i;
  5306.   /**
  5307.    * @param {?} a
  5308.    * @param {string} obj
  5309.    * @return {?}
  5310.    */
  5311.   jQuery.param = function(a, obj) {
  5312.     var key;
  5313.     /** @type {!Array} */
  5314.     var displayUsedBy = [];
  5315.     /**
  5316.      * @param {?} e
  5317.      * @param {string} result
  5318.      * @return {undefined}
  5319.      */
  5320.     var add = function(e, result) {
  5321.       var value = fn(result) ? result() : result;
  5322.       /** @type {string} */
  5323.       displayUsedBy[displayUsedBy.length] = encodeURIComponent(e) + "=" + encodeURIComponent(null == value ? "" : value);
  5324.     };
  5325.     if (null == a) {
  5326.       return "";
  5327.     }
  5328.     if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
  5329.       jQuery.each(a, function() {
  5330.         add(this.name, this.value);
  5331.       });
  5332.     } else {
  5333.       for (key in a) {
  5334.         set(key, a[key], obj, add);
  5335.       }
  5336.     }
  5337.     return displayUsedBy.join("&");
  5338.   };
  5339.   jQuery.fn.extend({
  5340.     serialize : function() {
  5341.       return jQuery.param(this.serializeArray());
  5342.     },
  5343.     serializeArray : function() {
  5344.       return this.map(function() {
  5345.         var elements = jQuery.prop(this, "elements");
  5346.         return elements ? jQuery.makeArray(elements) : this;
  5347.       }).filter(function() {
  5348.         var string = this.type;
  5349.         return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !reHasHexPrefix.test(string) && (this.checked || !app.test(string));
  5350.       }).map(function(canCreateDiscussions, ctlParams) {
  5351.         var val = jQuery(this).val();
  5352.         return null == val ? null : Array.isArray(val) ? jQuery.map(val, function(val) {
  5353.           return {
  5354.             name : ctlParams.name,
  5355.             value : val.replace(reVowels, "\r\n")
  5356.           };
  5357.         }) : {
  5358.           name : ctlParams.name,
  5359.           value : val.replace(reVowels, "\r\n")
  5360.         };
  5361.       }).get();
  5362.     }
  5363.   });
  5364.   /** @type {!RegExp} */
  5365.   var jsre = /%20/g;
  5366.   /** @type {!RegExp} */
  5367.   var rhash = /#.*$/;
  5368.   /** @type {!RegExp} */
  5369.   var rts = /([?&])_=[^&]*/;
  5370.   /** @type {!RegExp} */
  5371.   var rheaders = /^(.*?):[ \t]*([^\r\n]*)$/gm;
  5372.   /** @type {!RegExp} */
  5373.   var loader = /^(?:GET|HEAD)$/;
  5374.   /** @type {!RegExp} */
  5375.   var rprotocol = /^\/\//;
  5376.   var prefilters = {};
  5377.   var transports = {};
  5378.   /** @type {string} */
  5379.   var It = "*/".concat("*");
  5380.   var originAnchor = document.createElement("a");
  5381.   originAnchor.href = location.href;
  5382.   jQuery.extend({
  5383.     active : 0,
  5384.     lastModified : {},
  5385.     etag : {},
  5386.     ajaxSettings : {
  5387.       url : location.href,
  5388.       type : "GET",
  5389.       isLocal : /^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(location.protocol),
  5390.       global : true,
  5391.       processData : true,
  5392.       async : true,
  5393.       contentType : "application/x-www-form-urlencoded; charset=UTF-8",
  5394.       accepts : {
  5395.         "*" : It,
  5396.         text : "text/plain",
  5397.         html : "text/html",
  5398.         xml : "application/xml, text/xml",
  5399.         json : "application/json, text/javascript"
  5400.       },
  5401.       contents : {
  5402.         xml : /\bxml\b/,
  5403.         html : /\bhtml/,
  5404.         json : /\bjson\b/
  5405.       },
  5406.       responseFields : {
  5407.         xml : "responseXML",
  5408.         text : "responseText",
  5409.         json : "responseJSON"
  5410.       },
  5411.       converters : {
  5412.         "* text" : String,
  5413.         "text html" : true,
  5414.         "text json" : JSON.parse,
  5415.         "text xml" : jQuery.parseXML
  5416.       },
  5417.       flatOptions : {
  5418.         url : true,
  5419.         context : true
  5420.       }
  5421.     },
  5422.     ajaxSetup : function(target, settings) {
  5423.       return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
  5424.     },
  5425.     ajaxPrefilter : addToPrefiltersOrTransports(prefilters),
  5426.     ajaxTransport : addToPrefiltersOrTransports(transports),
  5427.     ajax : function(url, options) {
  5428.       /**
  5429.        * @param {number} status
  5430.        * @param {string} nativeStatusText
  5431.        * @param {!Array} responses
  5432.        * @param {string} headers
  5433.        * @return {undefined}
  5434.        */
  5435.       function done(status, nativeStatusText, responses, headers) {
  5436.         var isSuccess;
  5437.         var success;
  5438.         var error;
  5439.         var response;
  5440.         var modified;
  5441.         /** @type {string} */
  5442.         var statusText = nativeStatusText;
  5443.         if (!completed) {
  5444.           /** @type {boolean} */
  5445.           completed = true;
  5446.           if (showAboveTimeout) {
  5447.             window.clearTimeout(showAboveTimeout);
  5448.           }
  5449.           transport = void 0;
  5450.           responseHeadersString = headers || "";
  5451.           /** @type {number} */
  5452.           jqXHR.readyState = 0 < status ? 4 : 0;
  5453.           /** @type {boolean} */
  5454.           isSuccess = 200 <= status && status < 300 || 304 === status;
  5455.           if (responses) {
  5456.             response = function(s, ajaxRequest, responses) {
  5457.               var ct;
  5458.               var type;
  5459.               var finalDataType;
  5460.               var firstDataType;
  5461.               var contents = s.contents;
  5462.               var dataTypes = s.dataTypes;
  5463.               for (; "*" === dataTypes[0];) {
  5464.                 dataTypes.shift();
  5465.                 if (void 0 === ct) {
  5466.                   ct = s.mimeType || ajaxRequest.getResponseHeader("Content-Type");
  5467.                 }
  5468.               }
  5469.               if (ct) {
  5470.                 for (type in contents) {
  5471.                   if (contents[type] && contents[type].test(ct)) {
  5472.                     dataTypes.unshift(type);
  5473.                     break;
  5474.                   }
  5475.                 }
  5476.               }
  5477.               if (dataTypes[0] in responses) {
  5478.                 finalDataType = dataTypes[0];
  5479.               } else {
  5480.                 for (type in responses) {
  5481.                   if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
  5482.                     /** @type {string} */
  5483.                     finalDataType = type;
  5484.                     break;
  5485.                   }
  5486.                   if (!firstDataType) {
  5487.                     /** @type {string} */
  5488.                     firstDataType = type;
  5489.                   }
  5490.                 }
  5491.                 /** @type {(string|undefined)} */
  5492.                 finalDataType = finalDataType || firstDataType;
  5493.               }
  5494.               if (finalDataType) {
  5495.                 return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
  5496.               }
  5497.             }(s, jqXHR, responses);
  5498.           }
  5499.           if (!isSuccess && -1 < jQuery.inArray("script", s.dataTypes)) {
  5500.             /**
  5501.              * @return {undefined}
  5502.              */
  5503.             s.converters["text script"] = function() {
  5504.             };
  5505.           }
  5506.           response = function(s, response, jqXHR, isSuccess) {
  5507.             var conv2;
  5508.             var current;
  5509.             var conv;
  5510.             var parts;
  5511.             var value;
  5512.             var converters = {};
  5513.             var resList = s.dataTypes.slice();
  5514.             if (resList[1]) {
  5515.               for (conv in s.converters) {
  5516.                 converters[conv.toLowerCase()] = s.converters[conv];
  5517.               }
  5518.             }
  5519.             current = resList.shift();
  5520.             for (; current;) {
  5521.               if (s.responseFields[current] && (jqXHR[s.responseFields[current]] = response), !value && isSuccess && s.dataFilter && (response = s.dataFilter(response, s.dataType)), value = current, current = resList.shift()) {
  5522.                 if ("*" === current) {
  5523.                   current = value;
  5524.                 } else {
  5525.                   if ("*" !== value && value !== current) {
  5526.                     if (!(conv = converters[value + " " + current] || converters["* " + current])) {
  5527.                       for (conv2 in converters) {
  5528.                         if ((parts = conv2.split(" "))[1] === current && (conv = converters[value + " " + parts[0]] || converters["* " + parts[0]])) {
  5529.                           if (true === conv) {
  5530.                             conv = converters[conv2];
  5531.                           } else {
  5532.                             if (true !== converters[conv2]) {
  5533.                               /** @type {string} */
  5534.                               current = parts[0];
  5535.                               resList.unshift(parts[1]);
  5536.                             }
  5537.                           }
  5538.                           break;
  5539.                         }
  5540.                       }
  5541.                     }
  5542.                     if (true !== conv) {
  5543.                       if (conv && s["throws"]) {
  5544.                         response = conv(response);
  5545.                       } else {
  5546.                         try {
  5547.                           response = conv(response);
  5548.                         } catch (e) {
  5549.                           return {
  5550.                             state : "parsererror",
  5551.                             error : conv ? e : "No conversion from " + value + " to " + current
  5552.                           };
  5553.                         }
  5554.                       }
  5555.                     }
  5556.                   }
  5557.                 }
  5558.               }
  5559.             }
  5560.             return {
  5561.               state : "success",
  5562.               data : response
  5563.             };
  5564.           }(s, response, jqXHR, isSuccess);
  5565.           if (isSuccess) {
  5566.             if (s.ifModified) {
  5567.               if (modified = jqXHR.getResponseHeader("Last-Modified")) {
  5568.                 jQuery.lastModified[cacheURL] = modified;
  5569.               }
  5570.               if (modified = jqXHR.getResponseHeader("etag")) {
  5571.                 jQuery.etag[cacheURL] = modified;
  5572.               }
  5573.             }
  5574.             if (204 === status || "HEAD" === s.type) {
  5575.               /** @type {string} */
  5576.               statusText = "nocontent";
  5577.             } else {
  5578.               if (304 === status) {
  5579.                 /** @type {string} */
  5580.                 statusText = "notmodified";
  5581.               } else {
  5582.                 statusText = response.state;
  5583.                 success = response.data;
  5584.                 /** @type {boolean} */
  5585.                 isSuccess = !(error = response.error);
  5586.               }
  5587.             }
  5588.           } else {
  5589.             error = statusText;
  5590.             if (!(!status && statusText)) {
  5591.               /** @type {string} */
  5592.               statusText = "error";
  5593.               if (status < 0) {
  5594.                 /** @type {number} */
  5595.                 status = 0;
  5596.               }
  5597.             }
  5598.           }
  5599.           /** @type {number} */
  5600.           jqXHR.status = status;
  5601.           /** @type {string} */
  5602.           jqXHR.statusText = (nativeStatusText || statusText) + "";
  5603.           if (isSuccess) {
  5604.             deferred.resolveWith(obj, [success, statusText, jqXHR]);
  5605.           } else {
  5606.             deferred.rejectWith(obj, [jqXHR, statusText, error]);
  5607.           }
  5608.           jqXHR.statusCode(statusCode);
  5609.           statusCode = void 0;
  5610.           if (g) {
  5611.             globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
  5612.           }
  5613.           completeDeferred.fireWith(obj, [jqXHR, statusText]);
  5614.           if (g) {
  5615.             globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
  5616.             if (!--jQuery.active) {
  5617.               jQuery.event.trigger("ajaxStop");
  5618.             }
  5619.           }
  5620.         }
  5621.       }
  5622.       if ("object" == typeof url) {
  5623.         /** @type {string} */
  5624.         options = url;
  5625.         url = void 0;
  5626.       }
  5627.       options = options || {};
  5628.       var transport;
  5629.       var cacheURL;
  5630.       var responseHeadersString;
  5631.       var marks;
  5632.       var showAboveTimeout;
  5633.       var urlAnchor;
  5634.       var completed;
  5635.       var g;
  5636.       var i;
  5637.       var uncached;
  5638.       var s = jQuery.ajaxSetup({}, options);
  5639.       var obj = s.context || s;
  5640.       var globalEventContext = s.context && (obj.nodeType || obj.jquery) ? jQuery(obj) : jQuery.event;
  5641.       var deferred = jQuery.Deferred();
  5642.       var completeDeferred = jQuery.Callbacks("once memory");
  5643.       var statusCode = s.statusCode || {};
  5644.       var data = {};
  5645.       var requestHeadersNames = {};
  5646.       /** @type {string} */
  5647.       var status = "canceled";
  5648.       var jqXHR = {
  5649.         readyState : 0,
  5650.         getResponseHeader : function(header) {
  5651.           var match;
  5652.           if (completed) {
  5653.             if (!marks) {
  5654.               marks = {};
  5655.               for (; match = rheaders.exec(responseHeadersString);) {
  5656.                 marks[match[1].toLowerCase() + " "] = (marks[match[1].toLowerCase() + " "] || []).concat(match[2]);
  5657.               }
  5658.             }
  5659.             match = marks[header.toLowerCase() + " "];
  5660.           }
  5661.           return null == match ? null : match.join(", ");
  5662.         },
  5663.         getAllResponseHeaders : function() {
  5664.           return completed ? responseHeadersString : null;
  5665.         },
  5666.         setRequestHeader : function(name, value) {
  5667.           return null == completed && (name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name, data[name] = value), this;
  5668.         },
  5669.         overrideMimeType : function(type) {
  5670.           return null == completed && (s.mimeType = type), this;
  5671.         },
  5672.         statusCode : function(map) {
  5673.           var tmp;
  5674.           if (map) {
  5675.             if (completed) {
  5676.               jqXHR.always(map[jqXHR.status]);
  5677.             } else {
  5678.               for (tmp in map) {
  5679.                 /** @type {!Array} */
  5680.                 statusCode[tmp] = [statusCode[tmp], map[tmp]];
  5681.               }
  5682.             }
  5683.           }
  5684.           return this;
  5685.         },
  5686.         abort : function(type) {
  5687.           var statusText = type || status;
  5688.           return transport && transport.abort(statusText), done(0, statusText), this;
  5689.         }
  5690.       };
  5691.       if (deferred.promise(jqXHR), s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//"), s.type = options.method || options.type || s.method || s.type, s.dataTypes = (s.dataType || "*").toLowerCase().match(re) || [""], null == s.crossDomain) {
  5692.         urlAnchor = document.createElement("a");
  5693.         try {
  5694.           /** @type {string} */
  5695.           urlAnchor.href = s.url;
  5696.           /** @type {string} */
  5697.           urlAnchor.href = urlAnchor.href;
  5698.           /** @type {boolean} */
  5699.           s.crossDomain = originAnchor.protocol + "//" + originAnchor.host != urlAnchor.protocol + "//" + urlAnchor.host;
  5700.         } catch (e) {
  5701.           /** @type {boolean} */
  5702.           s.crossDomain = true;
  5703.         }
  5704.       }
  5705.       if (s.data && s.processData && "string" != typeof s.data && (s.data = jQuery.param(s.data, s.traditional)), inspectPrefiltersOrTransports(prefilters, s, options, jqXHR), completed) {
  5706.         return jqXHR;
  5707.       }
  5708.       for (i in(g = jQuery.event && s.global) && 0 == jQuery.active++ && jQuery.event.trigger("ajaxStart"), s.type = s.type.toUpperCase(), s.hasContent = !loader.test(s.type), cacheURL = s.url.replace(rhash, ""), s.hasContent ? s.data && s.processData && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded") && (s.data = s.data.replace(jsre, "+")) : (uncached = s.url.slice(cacheURL.length), s.data && (s.processData || "string" == typeof s.data) && (cacheURL = cacheURL + ((rquery.test(cacheURL) ?
  5709.       "&" : "?") + s.data), delete s.data), false === s.cache && (cacheURL = cacheURL.replace(rts, "$1"), uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + _enum.guid++ + uncached), s.url = cacheURL + uncached), s.ifModified && (jQuery.lastModified[cacheURL] && jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]), jQuery.etag[cacheURL] && jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL])), (s.data && s.hasContent && false !== s.contentType || options.contentType) &&
  5710.       jqXHR.setRequestHeader("Content-Type", s.contentType), jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + ("*" !== s.dataTypes[0] ? ", " + It + "; q=0.01" : "") : s.accepts["*"]), s.headers) {
  5711.         jqXHR.setRequestHeader(i, s.headers[i]);
  5712.       }
  5713.       if (s.beforeSend && (false === s.beforeSend.call(obj, jqXHR, s) || completed)) {
  5714.         return jqXHR.abort();
  5715.       }
  5716.       if (status = "abort", completeDeferred.add(s.complete), jqXHR.done(s.success), jqXHR.fail(s.error), transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR)) {
  5717.         if (jqXHR.readyState = 1, g && globalEventContext.trigger("ajaxSend", [jqXHR, s]), completed) {
  5718.           return jqXHR;
  5719.         }
  5720.         if (s.async && 0 < s.timeout) {
  5721.           showAboveTimeout = window.setTimeout(function() {
  5722.             jqXHR.abort("timeout");
  5723.           }, s.timeout);
  5724.         }
  5725.         try {
  5726.           /** @type {boolean} */
  5727.           completed = false;
  5728.           transport.send(data, done);
  5729.         } catch (success) {
  5730.           if (completed) {
  5731.             throw success;
  5732.           }
  5733.           done(-1, success);
  5734.         }
  5735.       } else {
  5736.         done(-1, "No Transport");
  5737.       }
  5738.       return jqXHR;
  5739.     },
  5740.     getJSON : function(name, callback, data) {
  5741.       return jQuery.get(name, callback, data, "json");
  5742.     },
  5743.     getScript : function(name, callback) {
  5744.       return jQuery.get(name, void 0, callback, "script");
  5745.     }
  5746.   });
  5747.   jQuery.each(["get", "post"], function(canCreateDiscussions, method) {
  5748.     /**
  5749.      * @param {!Object} url
  5750.      * @param {!Object} e
  5751.      * @param {!Function} s
  5752.      * @param {string} o
  5753.      * @return {?}
  5754.      */
  5755.     jQuery[method] = function(url, e, s, o) {
  5756.       return fn(e) && (o = o || s, s = e, e = void 0), jQuery.ajax(jQuery.extend({
  5757.         url : url,
  5758.         type : method,
  5759.         dataType : o,
  5760.         data : e,
  5761.         success : s
  5762.       }, jQuery.isPlainObject(url) && url));
  5763.     };
  5764.   });
  5765.   jQuery.ajaxPrefilter(function(settings) {
  5766.     var name;
  5767.     for (name in settings.headers) {
  5768.       if ("content-type" === name.toLowerCase()) {
  5769.         settings.contentType = settings.headers[name] || "";
  5770.       }
  5771.     }
  5772.   });
  5773.   /**
  5774.    * @param {string} value
  5775.    * @param {string} name
  5776.    * @param {!Object} url
  5777.    * @return {?}
  5778.    */
  5779.   jQuery._evalUrl = function(value, name, url) {
  5780.     return jQuery.ajax({
  5781.       url : value,
  5782.       type : "GET",
  5783.       dataType : "script",
  5784.       cache : true,
  5785.       async : false,
  5786.       global : false,
  5787.       converters : {
  5788.         "text script" : function() {
  5789.         }
  5790.       },
  5791.       dataFilter : function(text) {
  5792.         jQuery.globalEval(text, name, url);
  5793.       }
  5794.     });
  5795.   };
  5796.   jQuery.fn.extend({
  5797.     wrapAll : function(e) {
  5798.       var t;
  5799.       return this[0] && (fn(e) && (e = e.call(this[0])), t = jQuery(e, this[0].ownerDocument).eq(0).clone(true), this[0].parentNode && t.insertBefore(this[0]), t.map(function() {
  5800.         var elem = this;
  5801.         for (; elem.firstElementChild;) {
  5802.           elem = elem.firstElementChild;
  5803.         }
  5804.         return elem;
  5805.       }).append(this)), this;
  5806.     },
  5807.     wrapInner : function(wrapper) {
  5808.       return fn(wrapper) ? this.each(function(i) {
  5809.         jQuery(this).wrapInner(wrapper.call(this, i));
  5810.       }) : this.each(function() {
  5811.         var e = jQuery(this);
  5812.         var clone = e.contents();
  5813.         if (clone.length) {
  5814.           clone.wrapAll(wrapper);
  5815.         } else {
  5816.           e.append(wrapper);
  5817.         }
  5818.       });
  5819.     },
  5820.     wrap : function(html) {
  5821.       var isFunction = fn(html);
  5822.       return this.each(function(i) {
  5823.         jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
  5824.       });
  5825.     },
  5826.     unwrap : function(fn) {
  5827.       return this.parent(fn).not("body").each(function() {
  5828.         jQuery(this).replaceWith(this.childNodes);
  5829.       }), this;
  5830.     }
  5831.   });
  5832.   /**
  5833.    * @param {string} value
  5834.    * @return {?}
  5835.    */
  5836.   jQuery.expr.pseudos.hidden = function(value) {
  5837.     return !jQuery.expr.pseudos.visible(value);
  5838.   };
  5839.   /**
  5840.    * @param {!Element} elem
  5841.    * @return {?}
  5842.    */
  5843.   jQuery.expr.pseudos.visible = function(elem) {
  5844.     return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
  5845.   };
  5846.   /**
  5847.    * @return {?}
  5848.    */
  5849.   jQuery.ajaxSettings.xhr = function() {
  5850.     try {
  5851.       return new window.XMLHttpRequest;
  5852.     } catch (e) {
  5853.     }
  5854.   };
  5855.   var xhrSuccessStatus = {
  5856.     0 : 200,
  5857.     1223 : 204
  5858.   };
  5859.   var xhrSupported = jQuery.ajaxSettings.xhr();
  5860.   /** @type {boolean} */
  5861.   support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
  5862.   /** @type {boolean} */
  5863.   support.ajax = xhrSupported = !!xhrSupported;
  5864.   jQuery.ajaxTransport(function(s) {
  5865.     var callback;
  5866.     var errorCallback;
  5867.     if (support.cors || xhrSupported && !s.crossDomain) {
  5868.       return {
  5869.         send : function(headers, callback) {
  5870.           var i;
  5871.           var xhr = s.xhr();
  5872.           if (xhr.open(s.type, s.url, s.async, s.username, s.password), s.xhrFields) {
  5873.             for (i in s.xhrFields) {
  5874.               xhr[i] = s.xhrFields[i];
  5875.             }
  5876.           }
  5877.           for (i in s.mimeType && xhr.overrideMimeType && xhr.overrideMimeType(s.mimeType), s.crossDomain || headers["X-Requested-With"] || (headers["X-Requested-With"] = "XMLHttpRequest"), headers) {
  5878.             xhr.setRequestHeader(i, headers[i]);
  5879.           }
  5880.           /**
  5881.            * @param {string} event
  5882.            * @return {?}
  5883.            */
  5884.           callback = function(event) {
  5885.             return function() {
  5886.               if (callback) {
  5887.                 /** @type {null} */
  5888.                 callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;
  5889.                 if ("abort" === event) {
  5890.                   xhr.abort();
  5891.                 } else {
  5892.                   if ("error" === event) {
  5893.                     if ("number" != typeof xhr.status) {
  5894.                       callback(0, "error");
  5895.                     } else {
  5896.                       callback(xhr.status, xhr.statusText);
  5897.                     }
  5898.                   } else {
  5899.                     callback(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, "text" !== (xhr.responseType || "text") || "string" != typeof xhr.responseText ? {
  5900.                       binary : xhr.response
  5901.                     } : {
  5902.                       text : xhr.responseText
  5903.                     }, xhr.getAllResponseHeaders());
  5904.                   }
  5905.                 }
  5906.               }
  5907.             };
  5908.           };
  5909.           xhr.onload = callback();
  5910.           errorCallback = xhr.onerror = xhr.ontimeout = callback("error");
  5911.           if (void 0 !== xhr.onabort) {
  5912.             xhr.onabort = errorCallback;
  5913.           } else {
  5914.             /**
  5915.              * @return {undefined}
  5916.              */
  5917.             xhr.onreadystatechange = function() {
  5918.               if (4 === xhr.readyState) {
  5919.                 window.setTimeout(function() {
  5920.                   if (callback) {
  5921.                     errorCallback();
  5922.                   }
  5923.                 });
  5924.               }
  5925.             };
  5926.           }
  5927.           callback = callback("abort");
  5928.           try {
  5929.             xhr.send(s.hasContent && s.data || null);
  5930.           } catch (e) {
  5931.             if (callback) {
  5932.               throw e;
  5933.             }
  5934.           }
  5935.         },
  5936.         abort : function() {
  5937.           if (callback) {
  5938.             callback();
  5939.           }
  5940.         }
  5941.       };
  5942.     }
  5943.   });
  5944.   jQuery.ajaxPrefilter(function(options) {
  5945.     if (options.crossDomain) {
  5946.       /** @type {boolean} */
  5947.       options.contents.script = false;
  5948.     }
  5949.   });
  5950.   jQuery.ajaxSetup({
  5951.     accepts : {
  5952.       script : "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  5953.     },
  5954.     contents : {
  5955.       script : /\b(?:java|ecma)script\b/
  5956.     },
  5957.     converters : {
  5958.       "text script" : function(value) {
  5959.         return jQuery.globalEval(value), value;
  5960.       }
  5961.     }
  5962.   });
  5963.   jQuery.ajaxPrefilter("script", function(settings) {
  5964.     if (void 0 === settings.cache) {
  5965.       /** @type {boolean} */
  5966.       settings.cache = false;
  5967.     }
  5968.     if (settings.crossDomain) {
  5969.       /** @type {string} */
  5970.       settings.type = "GET";
  5971.     }
  5972.   });
  5973.   jQuery.ajaxTransport("script", function(options) {
  5974.     var fileElem;
  5975.     var callback;
  5976.     if (options.crossDomain || options.scriptAttrs) {
  5977.       return {
  5978.         send : function(packets, callback) {
  5979.           fileElem = jQuery("<script>").attr(options.scriptAttrs || {}).prop({
  5980.             charset : options.scriptCharset,
  5981.             src : options.url
  5982.           }).on("load error", callback = function(result) {
  5983.             fileElem.remove();
  5984.             /** @type {null} */
  5985.             callback = null;
  5986.             if (result) {
  5987.               callback("error" === result.type ? 404 : 200, result.type);
  5988.             }
  5989.           });
  5990.           document.head.appendChild(fileElem[0]);
  5991.         },
  5992.         abort : function() {
  5993.           if (callback) {
  5994.             callback();
  5995.           }
  5996.         }
  5997.       };
  5998.     }
  5999.   });
  6000.   var summary;
  6001.   /** @type {!Array} */
  6002.   var oldCallbacks = [];
  6003.   /** @type {!RegExp} */
  6004.   var rjsonp = /(=)\?(?=&|$)|\?\?/;
  6005.   jQuery.ajaxSetup({
  6006.     jsonp : "callback",
  6007.     jsonpCallback : function() {
  6008.       var indexLookupKey = oldCallbacks.pop() || jQuery.expando + "_" + _enum.guid++;
  6009.       return this[indexLookupKey] = true, indexLookupKey;
  6010.     }
  6011.   });
  6012.   jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, scanners) {
  6013.     var callbackName;
  6014.     var overwritten;
  6015.     var responseContainer;
  6016.     /** @type {(boolean|string)} */
  6017.     var jsonProp = false !== s.jsonp && (rjsonp.test(s.url) ? "url" : "string" == typeof s.data && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded") && rjsonp.test(s.data) && "data");
  6018.     if (jsonProp || "jsonp" === s.dataTypes[0]) {
  6019.       return callbackName = s.jsonpCallback = fn(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, jsonProp ? s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName) : false !== s.jsonp && (s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName), s.converters["script json"] = function() {
  6020.         return responseContainer || jQuery.error(callbackName + " was not called"), responseContainer[0];
  6021.       }, s.dataTypes[0] = "json", overwritten = window[callbackName], window[callbackName] = function() {
  6022.         /** @type {!Arguments} */
  6023.         responseContainer = arguments;
  6024.       }, scanners.always(function() {
  6025.         if (void 0 === overwritten) {
  6026.           jQuery(window).removeProp(callbackName);
  6027.         } else {
  6028.           window[callbackName] = overwritten;
  6029.         }
  6030.         if (s[callbackName]) {
  6031.           s.jsonpCallback = originalSettings.jsonpCallback;
  6032.           oldCallbacks.push(callbackName);
  6033.         }
  6034.         if (responseContainer && fn(overwritten)) {
  6035.           overwritten(responseContainer[0]);
  6036.         }
  6037.         responseContainer = overwritten = void 0;
  6038.       }), "script";
  6039.     }
  6040.   });
  6041.   /** @type {boolean} */
  6042.   support.createHTMLDocument = ((summary = document.implementation.createHTMLDocument("").body).innerHTML = "<form></form><form></form>", 2 === summary.childNodes.length);
  6043.   /**
  6044.    * @param {string} data
  6045.    * @param {!Object} context
  6046.    * @param {!Function} keepScripts
  6047.    * @return {?}
  6048.    */
  6049.   jQuery.parseHTML = function(data, context, keepScripts) {
  6050.     return "string" != typeof data ? [] : ("boolean" == typeof context && (keepScripts = context, context = false), context || (support.createHTMLDocument ? ((target = (context = document.implementation.createHTMLDocument("")).createElement("base")).href = document.location.href, context.head.appendChild(target)) : context = document), scripts = !keepScripts && [], (parsed = rsingleTag.exec(data)) ? [context.createElement(parsed[1])] : (parsed = buildFragment([data], context, scripts), scripts &&
  6051.     scripts.length && jQuery(scripts).remove(), jQuery.merge([], parsed.childNodes)));
  6052.     var target;
  6053.     var parsed;
  6054.     var scripts;
  6055.   };
  6056.   /**
  6057.    * @param {string} result
  6058.    * @param {string} value
  6059.    * @param {string} callback
  6060.    * @return {?}
  6061.    */
  6062.   jQuery.fn.load = function(result, value, callback) {
  6063.     var selector;
  6064.     var method;
  6065.     var args;
  6066.     var self = this;
  6067.     var i = result.indexOf(" ");
  6068.     return -1 < i && (selector = merge(result.slice(i)), result = result.slice(0, i)), fn(value) ? (callback = value, value = void 0) : value && "object" == typeof value && (method = "POST"), 0 < self.length && jQuery.ajax({
  6069.       url : result,
  6070.       type : method || "GET",
  6071.       dataType : "html",
  6072.       data : value
  6073.     }).done(function(responseText) {
  6074.       /** @type {!Arguments} */
  6075.       args = arguments;
  6076.       self.html(selector ? jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
  6077.     }).always(callback && function(elem, document) {
  6078.       self.each(function() {
  6079.         callback.apply(this, args || [elem.responseText, document, elem]);
  6080.       });
  6081.     }), this;
  6082.   };
  6083.   /**
  6084.    * @param {?} elem
  6085.    * @return {?}
  6086.    */
  6087.   jQuery.expr.pseudos.animated = function(elem) {
  6088.     return jQuery.grep(jQuery.timers, function(fn) {
  6089.       return elem === fn.elem;
  6090.     }).length;
  6091.   };
  6092.   jQuery.offset = {
  6093.     setOffset : function(element, options, x) {
  6094.       var opt_boundsOrLeft;
  6095.       var width;
  6096.       var curCSSTop;
  6097.       var height;
  6098.       var curOffset;
  6099.       var curCSSLeft;
  6100.       var propertyName = jQuery.css(element, "position");
  6101.       var self = jQuery(element);
  6102.       var c = {};
  6103.       if ("static" === propertyName) {
  6104.         /** @type {string} */
  6105.         element.style.position = "relative";
  6106.       }
  6107.       curOffset = self.offset();
  6108.       curCSSTop = jQuery.css(element, "top");
  6109.       curCSSLeft = jQuery.css(element, "left");
  6110.       if (("absolute" === propertyName || "fixed" === propertyName) && -1 < (curCSSTop + curCSSLeft).indexOf("auto")) {
  6111.         height = (opt_boundsOrLeft = self.position()).top;
  6112.         width = opt_boundsOrLeft.left;
  6113.       } else {
  6114.         /** @type {number} */
  6115.         height = parseFloat(curCSSTop) || 0;
  6116.         /** @type {number} */
  6117.         width = parseFloat(curCSSLeft) || 0;
  6118.       }
  6119.       if (fn(options)) {
  6120.         options = options.call(element, x, jQuery.extend({}, curOffset));
  6121.       }
  6122.       if (null != options.top) {
  6123.         /** @type {number} */
  6124.         c.top = options.top - curOffset.top + height;
  6125.       }
  6126.       if (null != options.left) {
  6127.         /** @type {number} */
  6128.         c.left = options.left - curOffset.left + width;
  6129.       }
  6130.       if ("using" in options) {
  6131.         options.using.call(element, c);
  6132.       } else {
  6133.         if ("number" == typeof c.top) {
  6134.           c.top += "px";
  6135.         }
  6136.         if ("number" == typeof c.left) {
  6137.           c.left += "px";
  6138.         }
  6139.         self.css(c);
  6140.       }
  6141.     }
  6142.   };
  6143.   jQuery.fn.extend({
  6144.     offset : function(y) {
  6145.       if (arguments.length) {
  6146.         return void 0 === y ? this : this.each(function(i) {
  6147.           jQuery.offset.setOffset(this, y, i);
  6148.         });
  6149.       }
  6150.       var box;
  6151.       var win;
  6152.       var aTarget = this[0];
  6153.       return aTarget ? aTarget.getClientRects().length ? (box = aTarget.getBoundingClientRect(), win = aTarget.ownerDocument.defaultView, {
  6154.         top : box.top + win.pageYOffset,
  6155.         left : box.left + win.pageXOffset
  6156.       }) : {
  6157.         top : 0,
  6158.         left : 0
  6159.       } : void 0;
  6160.     },
  6161.     position : function() {
  6162.       if (this[0]) {
  6163.         var el;
  6164.         var offset;
  6165.         var node;
  6166.         var element = this[0];
  6167.         var parentOffset = {
  6168.           top : 0,
  6169.           left : 0
  6170.         };
  6171.         if ("fixed" === jQuery.css(element, "position")) {
  6172.           offset = element.getBoundingClientRect();
  6173.         } else {
  6174.           offset = this.offset();
  6175.           node = element.ownerDocument;
  6176.           el = element.offsetParent || node.documentElement;
  6177.           for (; el && (el === node.body || el === node.documentElement) && "static" === jQuery.css(el, "position");) {
  6178.             el = el.parentNode;
  6179.           }
  6180.           if (el && el !== element && 1 === el.nodeType) {
  6181.             (parentOffset = jQuery(el).offset()).top += jQuery.css(el, "borderTopWidth", true);
  6182.             parentOffset.left += jQuery.css(el, "borderLeftWidth", true);
  6183.           }
  6184.         }
  6185.         return {
  6186.           top : offset.top - parentOffset.top - jQuery.css(element, "marginTop", true),
  6187.           left : offset.left - parentOffset.left - jQuery.css(element, "marginLeft", true)
  6188.         };
  6189.       }
  6190.     },
  6191.     offsetParent : function() {
  6192.       return this.map(function() {
  6193.         var parent = this.offsetParent;
  6194.         for (; parent && "static" === jQuery.css(parent, "position");) {
  6195.           parent = parent.offsetParent;
  6196.         }
  6197.         return parent || node;
  6198.       });
  6199.     }
  6200.   });
  6201.   jQuery.each({
  6202.     scrollLeft : "pageXOffset",
  6203.     scrollTop : "pageYOffset"
  6204.   }, function(type, prop) {
  6205.     /** @type {boolean} */
  6206.     var top = "pageYOffset" === prop;
  6207.     /**
  6208.      * @param {?} value
  6209.      * @return {?}
  6210.      */
  6211.     jQuery.fn[type] = function(value) {
  6212.       return access(this, function(node, method, val) {
  6213.         var win;
  6214.         if (isWindow(node) ? win = node : 9 === node.nodeType && (win = node.defaultView), void 0 === val) {
  6215.           return win ? win[prop] : node[method];
  6216.         }
  6217.         if (win) {
  6218.           win.scrollTo(top ? win.pageXOffset : val, top ? val : win.pageYOffset);
  6219.         } else {
  6220.           /** @type {number} */
  6221.           node[method] = val;
  6222.         }
  6223.       }, type, value, arguments.length);
  6224.     };
  6225.   });
  6226.   jQuery.each(["top", "left"], function(canCreateDiscussions, prop) {
  6227.     jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, val) {
  6228.       if (val) {
  6229.         return val = curCSS(elem, prop), rnumnonpx.test(val) ? jQuery(elem).position()[prop] + "px" : val;
  6230.       }
  6231.     });
  6232.   });
  6233.   jQuery.each({
  6234.     Height : "height",
  6235.     Width : "width"
  6236.   }, function(name, type) {
  6237.     jQuery.each({
  6238.       padding : "inner" + name,
  6239.       content : type,
  6240.       "" : "outer" + name
  6241.     }, function(defaultExtra, type) {
  6242.       /**
  6243.        * @param {boolean} margin
  6244.        * @param {(number|string)} boardManager
  6245.        * @return {?}
  6246.        */
  6247.       jQuery.fn[type] = function(margin, boardManager) {
  6248.         var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin);
  6249.         var extra = defaultExtra || (true === margin || true === boardManager ? "margin" : "border");
  6250.         return access(this, function(el, offset, undefined) {
  6251.           var doc;
  6252.           return isWindow(el) ? 0 === type.indexOf("outer") ? el["inner" + name] : el.document.documentElement["client" + name] : 9 === el.nodeType ? (doc = el.documentElement, Math.max(el.body["scroll" + name], doc["scroll" + name], el.body["offset" + name], doc["offset" + name], doc["client" + name])) : void 0 === undefined ? jQuery.css(el, offset, extra) : jQuery.style(el, offset, undefined, extra);
  6253.         }, type, chainable ? margin : void 0, chainable);
  6254.       };
  6255.     });
  6256.   });
  6257.   jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(canCreateDiscussions, type) {
  6258.     /**
  6259.      * @param {string} e
  6260.      * @return {?}
  6261.      */
  6262.     jQuery.fn[type] = function(e) {
  6263.       return this.on(type, e);
  6264.     };
  6265.   });
  6266.   jQuery.fn.extend({
  6267.     bind : function(event, callback, obj) {
  6268.       return this.on(event, null, callback, obj);
  6269.     },
  6270.     unbind : function(type, fn) {
  6271.       return this.off(type, null, fn);
  6272.     },
  6273.     delegate : function(eventHandler, event, fn, t) {
  6274.       return this.on(event, eventHandler, fn, t);
  6275.     },
  6276.     undelegate : function(selector, event, callback) {
  6277.       return 1 === arguments.length ? this.off(selector, "**") : this.off(event, selector || "**", callback);
  6278.     },
  6279.     hover : function(fnOver, fnOut) {
  6280.       return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
  6281.     }
  6282.   });
  6283.   jQuery.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "), function(canCreateDiscussions, type) {
  6284.     /**
  6285.      * @param {!Object} callback
  6286.      * @param {!Object} obj
  6287.      * @return {?}
  6288.      */
  6289.     jQuery.fn[type] = function(callback, obj) {
  6290.       return 0 < arguments.length ? this.on(type, null, callback, obj) : this.trigger(type);
  6291.     };
  6292.   });
  6293.   /** @type {!RegExp} */
  6294.   var REGEX_ESCAPE_EXPR = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
  6295.   /**
  6296.    * @param {!Object} p
  6297.    * @param {!Object} c
  6298.    * @return {?}
  6299.    */
  6300.   jQuery.proxy = function(p, c) {
  6301.     var b;
  6302.     var headArgs;
  6303.     var proxyFn;
  6304.     if ("string" == typeof c && (b = p[c], c = p, p = b), fn(p)) {
  6305.       return headArgs = slice.call(arguments, 2), (proxyFn = function() {
  6306.         return p.apply(c || this, headArgs.concat(slice.call(arguments)));
  6307.       }).guid = p.guid = p.guid || jQuery.guid++, proxyFn;
  6308.     }
  6309.   };
  6310.   /**
  6311.    * @param {?} hold
  6312.    * @return {undefined}
  6313.    */
  6314.   jQuery.holdReady = function(hold) {
  6315.     if (hold) {
  6316.       jQuery.readyWait++;
  6317.     } else {
  6318.       jQuery.ready(true);
  6319.     }
  6320.   };
  6321.   /** @type {function(*): boolean} */
  6322.   jQuery.isArray = Array.isArray;
  6323.   /** @type {function(this:JSONType, string, function(string, *): *=): *} */
  6324.   jQuery.parseJSON = JSON.parse;
  6325.   /** @type {function(!Object, !Object): ?} */
  6326.   jQuery.nodeName = callback;
  6327.   /** @type {function(string): ?} */
  6328.   jQuery.isFunction = fn;
  6329.   /** @type {function(!Object): ?} */
  6330.   jQuery.isWindow = isWindow;
  6331.   /** @type {function(!Object): ?} */
  6332.   jQuery.camelCase = camelCase;
  6333.   /** @type {function(string): ?} */
  6334.   jQuery.type = type;
  6335.   /** @type {function(): number} */
  6336.   jQuery.now = Date.now;
  6337.   /**
  6338.    * @param {string} value
  6339.    * @return {?}
  6340.    */
  6341.   jQuery.isNumeric = function(value) {
  6342.     var undefined = jQuery.type(value);
  6343.     return ("number" === undefined || "string" === undefined) && !isNaN(value - parseFloat(value));
  6344.   };
  6345.   /**
  6346.    * @param {string} text
  6347.    * @return {?}
  6348.    */
  6349.   jQuery.trim = function(text) {
  6350.     return null == text ? "" : (text + "").replace(REGEX_ESCAPE_EXPR, "");
  6351.   };
  6352.   if ("function" == typeof define && define.amd) {
  6353.     define("jquery", [], function() {
  6354.       return jQuery;
  6355.     });
  6356.   }
  6357.   var _jQuery = window.jQuery;
  6358.   var old$ = window.$;
  6359.   return jQuery.noConflict = function(deep) {
  6360.     return window.$ === jQuery && (window.$ = old$), deep && window.jQuery === jQuery && (window.jQuery = _jQuery), jQuery;
  6361.   }, "undefined" == typeof start_column && (window.jQuery = window.$ = jQuery), jQuery;
  6362. });
  6363.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!