znM2Yxsz

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