4tFvY4mn

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