spamreports

Steam phishi?

Jan 11th, 2021
974
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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)<