API tools faq
paste
Advertisement
kemmio

Untitled

kemmio
Jul 23rd, 2016
118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 419.22 KB | None | 0 0
raw download clone embed print report
  1. !function(obj, forOwn) {
  2.   if ("object" == typeof module && "object" == typeof module.exports) {
  3.     module.exports = obj.document ? forOwn(obj, true) : function(obj) {
  4.       if (!obj.document) {
  5.         throw new Error("jQuery requires a window with a document");
  6.       }
  7.       return forOwn(obj);
  8.     };
  9.   } else {
  10.     forOwn(obj);
  11.   }
  12. }("undefined" != typeof window ? window : this, function(win, dataAndEvents) {
  13.   /**
  14.    * @param {string} arg
  15.    * @return {?}
  16.    */
  17.   function isArraylike(arg) {
  18.     var len = arg.length;
  19.     var type = jQuery.type(arg);
  20.     return "function" === type || jQuery.isWindow(arg) ? false : 1 === arg.nodeType && len ? true : "array" === type || (0 === len || "number" == typeof len && (len > 0 && len - 1 in arg));
  21.   }
  22.   /**
  23.    * @param {string} elements
  24.    * @param {Object} qualifier
  25.    * @param {boolean} not
  26.    * @return {?}
  27.    */
  28.   function winnow(elements, qualifier, not) {
  29.     if (jQuery.isFunction(qualifier)) {
  30.       return jQuery.grep(elements, function(elem, i) {
  31.         return!!qualifier.call(elem, i, elem) !== not;
  32.       });
  33.     }
  34.     if (qualifier.nodeType) {
  35.       return jQuery.grep(elements, function(elem) {
  36.         return elem === qualifier !== not;
  37.       });
  38.     }
  39.     if ("string" == typeof qualifier) {
  40.       if (isSimple.test(qualifier)) {
  41.         return jQuery.filter(qualifier, elements, not);
  42.       }
  43.       qualifier = jQuery.filter(qualifier, elements);
  44.     }
  45.     return jQuery.grep(elements, function(elem) {
  46.       return core_indexOf.call(qualifier, elem) >= 0 !== not;
  47.     });
  48.   }
  49.   /**
  50.    * @param {Object} cur
  51.    * @param {string} dir
  52.    * @return {?}
  53.    */
  54.   function sibling(cur, dir) {
  55.     for (;(cur = cur[dir]) && 1 !== cur.nodeType;) {
  56.     }
  57.     return cur;
  58.   }
  59.   /**
  60.    * @param {string} options
  61.    * @return {?}
  62.    */
  63.   function createOptions(options) {
  64.     var buf = optionsCache[options] = {};
  65.     return jQuery.each(options.match(core_rnotwhite) || [], function(dataAndEvents, off) {
  66.       /** @type {boolean} */
  67.       buf[off] = true;
  68.     }), buf;
  69.   }
  70.   /**
  71.    * @return {undefined}
  72.    */
  73.   function completed() {
  74.     doc.removeEventListener("DOMContentLoaded", completed, false);
  75.     win.removeEventListener("load", completed, false);
  76.     jQuery.ready();
  77.   }
  78.   /**
  79.    * @return {undefined}
  80.    */
  81.   function Data() {
  82.     Object.defineProperty(this.cache = {}, 0, {
  83.       /**
  84.        * @return {?}
  85.        */
  86.       get : function() {
  87.         return{};
  88.       }
  89.     });
  90.     this.expando = jQuery.expando + Math.random();
  91.   }
  92.   /**
  93.    * @param {Object} elem
  94.    * @param {string} key
  95.    * @param {string} data
  96.    * @return {?}
  97.    */
  98.   function dataAttr(elem, key, data) {
  99.     var name;
  100.     if (void 0 === data && 1 === elem.nodeType) {
  101.       if (name = "data-" + key.replace(r20, "-$1").toLowerCase(), data = elem.getAttribute(name), "string" == typeof data) {
  102.         try {
  103.           data = "true" === data ? true : "false" === data ? false : "null" === data ? null : +data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data;
  104.         } catch (f) {
  105.         }
  106.         data_user.set(elem, key, data);
  107.       } else {
  108.         data = void 0;
  109.       }
  110.     }
  111.     return data;
  112.   }
  113.   /**
  114.    * @return {?}
  115.    */
  116.   function returnTrue() {
  117.     return true;
  118.   }
  119.   /**
  120.    * @return {?}
  121.    */
  122.   function returnFalse() {
  123.     return false;
  124.   }
  125.   /**
  126.    * @return {?}
  127.    */
  128.   function safeActiveElement() {
  129.     try {
  130.       return doc.activeElement;
  131.     } catch (n) {
  132.     }
  133.   }
  134.   /**
  135.    * @param {Node} elem
  136.    * @param {Object} content
  137.    * @return {?}
  138.    */
  139.   function manipulationTarget(elem, content) {
  140.     return jQuery.nodeName(elem, "table") && jQuery.nodeName(11 !== content.nodeType ? content : content.firstChild, "tr") ? elem.getElementsByTagName("tbody")[0] || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem;
  141.   }
  142.   /**
  143.    * @param {Element} elem
  144.    * @return {?}
  145.    */
  146.   function restoreScript(elem) {
  147.     return elem.type = (null !== elem.getAttribute("type")) + "/" + elem.type, elem;
  148.   }
  149.   /**
  150.    * @param {Element} s
  151.    * @return {?}
  152.    */
  153.   function fn(s) {
  154.     /** @type {(Array.<string>|null)} */
  155.     var l = re.exec(s.type);
  156.     return l ? s.type = l[1] : s.removeAttribute("type"), s;
  157.   }
  158.   /**
  159.    * @param {(Array|NodeList)} elems
  160.    * @param {Array} refElements
  161.    * @return {undefined}
  162.    */
  163.   function setGlobalEval(elems, refElements) {
  164.     /** @type {number} */
  165.     var i = 0;
  166.     var l = elems.length;
  167.     for (;l > i;i++) {
  168.       data_priv.set(elems[i], "globalEval", !refElements || data_priv.get(refElements[i], "globalEval"));
  169.     }
  170.   }
  171.   /**
  172.    * @param {Object} src
  173.    * @param {Object} dest
  174.    * @return {undefined}
  175.    */
  176.   function cloneCopyEvent(src, dest) {
  177.     var i;
  178.     var ilen;
  179.     var type;
  180.     var pdataOld;
  181.     var pdataCur;
  182.     var udataOld;
  183.     var udataCur;
  184.     var events;
  185.     if (1 === dest.nodeType) {
  186.       if (data_priv.hasData(src) && (pdataOld = data_priv.access(src), pdataCur = data_priv.set(dest, pdataOld), events = pdataOld.events)) {
  187.         delete pdataCur.handle;
  188.         pdataCur.events = {};
  189.         for (type in events) {
  190.           /** @type {number} */
  191.           i = 0;
  192.           ilen = events[type].length;
  193.           for (;ilen > i;i++) {
  194.             jQuery.event.add(dest, type, events[type][i]);
  195.           }
  196.         }
  197.       }
  198.       if (data_user.hasData(src)) {
  199.         udataOld = data_user.access(src);
  200.         udataCur = jQuery.extend({}, udataOld);
  201.         data_user.set(dest, udataCur);
  202.       }
  203.     }
  204.   }
  205.   /**
  206.    * @param {Node} context
  207.    * @param {Object} tag
  208.    * @return {?}
  209.    */
  210.   function getAll(context, tag) {
  211.     var ret = context.getElementsByTagName ? context.getElementsByTagName(tag || "*") : context.querySelectorAll ? context.querySelectorAll(tag || "*") : [];
  212.     return void 0 === tag || tag && jQuery.nodeName(context, tag) ? jQuery.merge([context], ret) : ret;
  213.   }
  214.   /**
  215.    * @param {Element} src
  216.    * @param {Element} dest
  217.    * @return {undefined}
  218.    */
  219.   function fixInput(src, dest) {
  220.     var name = dest.nodeName.toLowerCase();
  221.     if ("input" === name && manipulation_rcheckableType.test(src.type)) {
  222.       dest.checked = src.checked;
  223.     } else {
  224.       if ("input" === name || "textarea" === name) {
  225.         dest.defaultValue = src.defaultValue;
  226.       }
  227.     }
  228.   }
  229.   /**
  230.    * @param {string} name
  231.    * @param {Document} doc
  232.    * @return {?}
  233.    */
  234.   function actualDisplay(name, doc) {
  235.     var result;
  236.     var elem = jQuery(doc.createElement(name)).appendTo(doc.body);
  237.     var e = win.getDefaultComputedStyle && (result = win.getDefaultComputedStyle(elem[0])) ? result.display : jQuery.css(elem[0], "display");
  238.     return elem.detach(), e;
  239.   }
  240.   /**
  241.    * @param {?} nodeName
  242.    * @return {?}
  243.    */
  244.   function defaultDisplay(nodeName) {
  245.     var d = doc;
  246.     var display = elemdisplay[nodeName];
  247.     return display || (display = actualDisplay(nodeName, d), "none" !== display && display || (iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")).appendTo(d.documentElement), d = iframe[0].contentDocument, d.write(), d.close(), display = actualDisplay(nodeName, d), iframe.detach()), elemdisplay[nodeName] = display), display;
  248.   }
  249.   /**
  250.    * @param {Object} node
  251.    * @param {string} prop
  252.    * @param {Object} styles
  253.    * @return {?}
  254.    */
  255.   function css(node, prop, styles) {
  256.     var width;
  257.     var minWidth;
  258.     var maxWidth;
  259.     var val;
  260.     var style = node.style;
  261.     return styles = styles || getStyles(node), styles && (val = styles.getPropertyValue(prop) || styles[prop]), styles && ("" !== val || (jQuery.contains(node.ownerDocument, node) || (val = jQuery.style(node, prop))), regexp.test(val) && (rbracket.test(prop) && (width = style.width, minWidth = style.minWidth, maxWidth = style.maxWidth, style.minWidth = style.maxWidth = style.width = val, val = styles.width, style.width = width, style.minWidth = minWidth, style.maxWidth = maxWidth))), void 0 !== val ?
  262.     val + "" : val;
  263.   }
  264.   /**
  265.    * @param {?} $timeout
  266.    * @param {Function} hookFn
  267.    * @return {?}
  268.    */
  269.   function addGetHookIf($timeout, hookFn) {
  270.     return{
  271.       /**
  272.        * @return {?}
  273.        */
  274.       get : function() {
  275.         return $timeout() ? void delete this.get : (this.get = hookFn).apply(this, arguments);
  276.       }
  277.     };
  278.   }
  279.   /**
  280.    * @param {Object} style
  281.    * @param {string} name
  282.    * @return {?}
  283.    */
  284.   function vendorPropName(style, name) {
  285.     if (name in style) {
  286.       return name;
  287.     }
  288.     var capName = name[0].toUpperCase() + name.slice(1);
  289.     /** @type {string} */
  290.     var origName = name;
  291.     /** @type {number} */
  292.     var i = cssPrefixes.length;
  293.     for (;i--;) {
  294.       if (name = cssPrefixes[i] + capName, name in style) {
  295.         return name;
  296.       }
  297.     }
  298.     return origName;
  299.   }
  300.   /**
  301.    * @param {Object} elem
  302.    * @param {string} value
  303.    * @param {string} actual
  304.    * @return {?}
  305.    */
  306.   function setPositiveNumber(elem, value, actual) {
  307.     /** @type {(Array.<string>|null)} */
  308.     var iterator = rrelNum.exec(value);
  309.     return iterator ? Math.max(0, iterator[1] - (actual || 0)) + (iterator[2] || "px") : value;
  310.   }
  311.   /**
  312.    * @param {Object} elem
  313.    * @param {string} keepData
  314.    * @param {string} extra
  315.    * @param {boolean} isBorderBox
  316.    * @param {?} styles
  317.    * @return {?}
  318.    */
  319.   function augmentWidthOrHeight(elem, keepData, extra, isBorderBox, styles) {
  320.     /** @type {number} */
  321.     var i = extra === (isBorderBox ? "border" : "content") ? 4 : "width" === keepData ? 1 : 0;
  322.     /** @type {number} */
  323.     var val = 0;
  324.     for (;4 > i;i += 2) {
  325.       if ("margin" === extra) {
  326.         val += jQuery.css(elem, extra + cssExpand[i], true, styles);
  327.       }
  328.       if (isBorderBox) {
  329.         if ("content" === extra) {
  330.           val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  331.         }
  332.         if ("margin" !== extra) {
  333.           val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  334.         }
  335.       } else {
  336.         val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  337.         if ("padding" !== extra) {
  338.           val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  339.         }
  340.       }
  341.     }
  342.     return val;
  343.   }
  344.   /**
  345.    * @param {Object} elem
  346.    * @param {string} name
  347.    * @param {string} extra
  348.    * @return {?}
  349.    */
  350.   function getWidthOrHeight(elem, name, extra) {
  351.     /** @type {boolean} */
  352.     var valueIsBorderBox = true;
  353.     var val = "width" === name ? elem.offsetWidth : elem.offsetHeight;
  354.     var styles = getStyles(elem);
  355.     /** @type {boolean} */
  356.     var isBorderBox = "border-box" === jQuery.css(elem, "boxSizing", false, styles);
  357.     if (0 >= val || null == val) {
  358.       if (val = css(elem, name, styles), (0 > val || null == val) && (val = elem.style[name]), regexp.test(val)) {
  359.         return val;
  360.       }
  361.       valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]);
  362.       /** @type {number} */
  363.       val = parseFloat(val) || 0;
  364.     }
  365.     return val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles) + "px";
  366.   }
  367.   /**
  368.    * @param {Array} elements
  369.    * @param {boolean} show
  370.    * @return {?}
  371.    */
  372.   function showHide(elements, show) {
  373.     var display;
  374.     var elem;
  375.     var hidden;
  376.     /** @type {Array} */
  377.     var values = [];
  378.     /** @type {number} */
  379.     var index = 0;
  380.     var length = elements.length;
  381.     for (;length > index;index++) {
  382.       elem = elements[index];
  383.       if (elem.style) {
  384.         values[index] = data_priv.get(elem, "olddisplay");
  385.         display = elem.style.display;
  386.         if (show) {
  387.           if (!values[index]) {
  388.             if (!("none" !== display)) {
  389.               /** @type {string} */
  390.               elem.style.display = "";
  391.             }
  392.           }
  393.           if ("" === elem.style.display) {
  394.             if (isHidden(elem)) {
  395.               values[index] = data_priv.access(elem, "olddisplay", defaultDisplay(elem.nodeName));
  396.             }
  397.           }
  398.         } else {
  399.           hidden = isHidden(elem);
  400.           if (!("none" === display && hidden)) {
  401.             data_priv.set(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display"));
  402.           }
  403.         }
  404.       }
  405.     }
  406.     /** @type {number} */
  407.     index = 0;
  408.     for (;length > index;index++) {
  409.       elem = elements[index];
  410.       if (elem.style) {
  411.         if (!(show && ("none" !== elem.style.display && "" !== elem.style.display))) {
  412.           elem.style.display = show ? values[index] || "" : "none";
  413.         }
  414.       }
  415.     }
  416.     return elements;
  417.   }
  418.   /**
  419.    * @param {string} selector
  420.    * @param {string} context
  421.    * @param {string} prop
  422.    * @param {string} end
  423.    * @param {string} easing
  424.    * @return {?}
  425.    */
  426.   function Tween(selector, context, prop, end, easing) {
  427.     return new Tween.prototype.init(selector, context, prop, end, easing);
  428.   }
  429.   /**
  430.    * @return {?}
  431.    */
  432.   function createFxNow() {
  433.     return setTimeout(function() {
  434.       fxNow = void 0;
  435.     }), fxNow = jQuery.now();
  436.   }
  437.   /**
  438.    * @param {string} type
  439.    * @param {boolean} includeWidth
  440.    * @return {?}
  441.    */
  442.   function genFx(type, includeWidth) {
  443.     var which;
  444.     /** @type {number} */
  445.     var i = 0;
  446.     var attrs = {
  447.       height : type
  448.     };
  449.     /** @type {number} */
  450.     includeWidth = includeWidth ? 1 : 0;
  451.     for (;4 > i;i += 2 - includeWidth) {
  452.       which = cssExpand[i];
  453.       attrs["margin" + which] = attrs["padding" + which] = type;
  454.     }
  455.     return includeWidth && (attrs.opacity = attrs.width = type), attrs;
  456.   }
  457.   /**
  458.    * @param {?} value
  459.    * @param {?} prop
  460.    * @param {?} animation
  461.    * @return {?}
  462.    */
  463.   function createTween(value, prop, animation) {
  464.     var tween;
  465.     var q = (cache[prop] || []).concat(cache["*"]);
  466.     /** @type {number} */
  467.     var i = 0;
  468.     var l = q.length;
  469.     for (;l > i;i++) {
  470.       if (tween = q[i].call(animation, prop, value)) {
  471.         return tween;
  472.       }
  473.     }
  474.   }
  475.   /**
  476.    * @param {Object} elem
  477.    * @param {Object} props
  478.    * @param {Object} opts
  479.    * @return {undefined}
  480.    */
  481.   function defaultPrefilter(elem, props, opts) {
  482.     var prop;
  483.     var value;
  484.     var thisp;
  485.     var tween;
  486.     var hooks;
  487.     var oldfire;
  488.     var oldDisplay;
  489.     var type;
  490.     var anim = this;
  491.     var orig = {};
  492.     var style = elem.style;
  493.     var hidden = elem.nodeType && isHidden(elem);
  494.     var dataShow = data_priv.get(elem, "fxshow");
  495.     if (!opts.queue) {
  496.       hooks = jQuery._queueHooks(elem, "fx");
  497.       if (null == hooks.unqueued) {
  498.         /** @type {number} */
  499.         hooks.unqueued = 0;
  500.         /** @type {function (): undefined} */
  501.         oldfire = hooks.empty.fire;
  502.         /**
  503.          * @return {undefined}
  504.          */
  505.         hooks.empty.fire = function() {
  506.           if (!hooks.unqueued) {
  507.             oldfire();
  508.           }
  509.         };
  510.       }
  511.       hooks.unqueued++;
  512.       anim.always(function() {
  513.         anim.always(function() {
  514.           hooks.unqueued--;
  515.           if (!jQuery.queue(elem, "fx").length) {
  516.             hooks.empty.fire();
  517.           }
  518.         });
  519.       });
  520.     }
  521.     if (1 === elem.nodeType) {
  522.       if ("height" in props || "width" in props) {
  523.         /** @type {Array} */
  524.         opts.overflow = [style.overflow, style.overflowX, style.overflowY];
  525.         oldDisplay = jQuery.css(elem, "display");
  526.         type = "none" === oldDisplay ? data_priv.get(elem, "olddisplay") || defaultDisplay(elem.nodeName) : oldDisplay;
  527.         if ("inline" === type) {
  528.           if ("none" === jQuery.css(elem, "float")) {
  529.             /** @type {string} */
  530.             style.display = "inline-block";
  531.           }
  532.         }
  533.       }
  534.     }
  535.     if (opts.overflow) {
  536.       /** @type {string} */
  537.       style.overflow = "hidden";
  538.       anim.always(function() {
  539.         style.overflow = opts.overflow[0];
  540.         style.overflowX = opts.overflow[1];
  541.         style.overflowY = opts.overflow[2];
  542.       });
  543.     }
  544.     for (prop in props) {
  545.       if (value = props[prop], rplusequals.exec(value)) {
  546.         if (delete props[prop], thisp = thisp || "toggle" === value, value === (hidden ? "hide" : "show")) {
  547.           if ("show" !== value || (!dataShow || void 0 === dataShow[prop])) {
  548.             continue;
  549.           }
  550.           /** @type {boolean} */
  551.           hidden = true;
  552.         }
  553.         orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
  554.       } else {
  555.         oldDisplay = void 0;
  556.       }
  557.     }
  558.     if (jQuery.isEmptyObject(orig)) {
  559.       if ("inline" === ("none" === oldDisplay ? defaultDisplay(elem.nodeName) : oldDisplay)) {
  560.         style.display = oldDisplay;
  561.       }
  562.     } else {
  563.       if (dataShow) {
  564.         if ("hidden" in dataShow) {
  565.           hidden = dataShow.hidden;
  566.         }
  567.       } else {
  568.         dataShow = data_priv.access(elem, "fxshow", {});
  569.       }
  570.       if (thisp) {
  571.         /** @type {boolean} */
  572.         dataShow.hidden = !hidden;
  573.       }
  574.       if (hidden) {
  575.         jQuery(elem).show();
  576.       } else {
  577.         anim.done(function() {
  578.           jQuery(elem).hide();
  579.         });
  580.       }
  581.       anim.done(function() {
  582.         var prop;
  583.         data_priv.remove(elem, "fxshow");
  584.         for (prop in orig) {
  585.           jQuery.style(elem, prop, orig[prop]);
  586.         }
  587.       });
  588.       for (prop in orig) {
  589.         tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
  590.         if (!(prop in dataShow)) {
  591.           dataShow[prop] = tween.start;
  592.           if (hidden) {
  593.             tween.end = tween.start;
  594.             /** @type {number} */
  595.             tween.start = "width" === prop || "height" === prop ? 1 : 0;
  596.           }
  597.         }
  598.       }
  599.     }
  600.   }
  601.   /**
  602.    * @param {Object} object
  603.    * @param {Object} paramMap
  604.    * @return {undefined}
  605.    */
  606.   function propFilter(object, paramMap) {
  607.     var key;
  608.     var name;
  609.     var value;
  610.     var data;
  611.     var hooks;
  612.     for (key in object) {
  613.       if (name = jQuery.camelCase(key), value = paramMap[name], data = object[key], jQuery.isArray(data) && (value = data[1], data = object[key] = data[0]), key !== name && (object[name] = data, delete object[key]), hooks = jQuery.cssHooks[name], hooks && "expand" in hooks) {
  614.         data = hooks.expand(data);
  615.         delete object[name];
  616.         for (key in data) {
  617.           if (!(key in object)) {
  618.             object[key] = data[key];
  619.             paramMap[key] = value;
  620.           }
  621.         }
  622.       } else {
  623.         paramMap[name] = value;
  624.       }
  625.     }
  626.   }
  627.   /**
  628.    * @param {string} elem
  629.    * @param {?} properties
  630.    * @param {Object} options
  631.    * @return {?}
  632.    */
  633.   function Animation(elem, properties, options) {
  634.     var result;
  635.     var e;
  636.     /** @type {number} */
  637.     var index = 0;
  638.     /** @type {number} */
  639.     var length = animationPrefilters.length;
  640.     var deferred = jQuery.Deferred().always(function() {
  641.       delete tick.elem;
  642.     });
  643.     /**
  644.      * @return {?}
  645.      */
  646.     var tick = function() {
  647.       if (e) {
  648.         return false;
  649.       }
  650.       var currentTime = fxNow || createFxNow();
  651.       /** @type {number} */
  652.       var remaining = Math.max(0, animation.startTime + animation.duration - currentTime);
  653.       /** @type {number} */
  654.       var temp = remaining / animation.duration || 0;
  655.       /** @type {number} */
  656.       var percent = 1 - temp;
  657.       /** @type {number} */
  658.       var index = 0;
  659.       var startOffset = animation.tweens.length;
  660.       for (;startOffset > index;index++) {
  661.         animation.tweens[index].run(percent);
  662.       }
  663.       return deferred.notifyWith(elem, [animation, percent, remaining]), 1 > percent && startOffset ? remaining : (deferred.resolveWith(elem, [animation]), false);
  664.     };
  665.     var animation = deferred.promise({
  666.       elem : elem,
  667.       props : jQuery.extend({}, properties),
  668.       opts : jQuery.extend(true, {
  669.         specialEasing : {}
  670.       }, options),
  671.       originalProperties : properties,
  672.       originalOptions : options,
  673.       startTime : fxNow || createFxNow(),
  674.       duration : options.duration,
  675.       tweens : [],
  676.       /**
  677.        * @param {string} prop
  678.        * @param {?} end
  679.        * @return {?}
  680.        */
  681.       createTween : function(prop, end) {
  682.         var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
  683.         return animation.tweens.push(tween), tween;
  684.       },
  685.       /**
  686.        * @param {boolean} gotoEnd
  687.        * @return {?}
  688.        */
  689.       stop : function(gotoEnd) {
  690.         /** @type {number} */
  691.         var index = 0;
  692.         var length = gotoEnd ? animation.tweens.length : 0;
  693.         if (e) {
  694.           return this;
  695.         }
  696.         /** @type {boolean} */
  697.         e = true;
  698.         for (;length > index;index++) {
  699.           animation.tweens[index].run(1);
  700.         }
  701.         return gotoEnd ? deferred.resolveWith(elem, [animation, gotoEnd]) : deferred.rejectWith(elem, [animation, gotoEnd]), this;
  702.       }
  703.     });
  704.     var scripts = animation.props;
  705.     propFilter(scripts, animation.opts.specialEasing);
  706.     for (;length > index;index++) {
  707.       if (result = animationPrefilters[index].call(animation, elem, scripts, animation.opts)) {
  708.         return result;
  709.       }
  710.     }
  711.     return jQuery.map(scripts, createTween, animation), jQuery.isFunction(animation.opts.start) && animation.opts.start.call(elem, animation), jQuery.fx.timer(jQuery.extend(tick, {
  712.       elem : elem,
  713.       anim : animation,
  714.       queue : animation.opts.queue
  715.     })), animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
  716.   }
  717.   /**
  718.    * @param {Array} structure
  719.    * @return {?}
  720.    */
  721.   function addToPrefiltersOrTransports(structure) {
  722.     return function(selector, fn) {
  723.       if ("string" != typeof selector) {
  724.         /** @type {(Function|string)} */
  725.         fn = selector;
  726.         /** @type {string} */
  727.         selector = "*";
  728.       }
  729.       var node;
  730.       /** @type {number} */
  731.       var i = 0;
  732.       var elem = selector.toLowerCase().match(core_rnotwhite) || [];
  733.       if (jQuery.isFunction(fn)) {
  734.         for (;node = elem[i++];) {
  735.           if ("+" === node[0]) {
  736.             node = node.slice(1) || "*";
  737.             (structure[node] = structure[node] || []).unshift(fn);
  738.           } else {
  739.             (structure[node] = structure[node] || []).push(fn);
  740.           }
  741.         }
  742.       }
  743.     };
  744.   }
  745.   /**
  746.    * @param {?} structure
  747.    * @param {?} options
  748.    * @param {Object} originalOptions
  749.    * @param {?} jqXHR
  750.    * @return {?}
  751.    */
  752.   function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
  753.     /**
  754.      * @param {string} key
  755.      * @return {?}
  756.      */
  757.     function inspect(key) {
  758.       var oldName;
  759.       return old[key] = true, jQuery.each(structure[key] || [], function(dataAndEvents, prefilterOrFactory) {
  760.         var name = prefilterOrFactory(options, originalOptions, jqXHR);
  761.         return "string" != typeof name || (seekingTransport || old[name]) ? seekingTransport ? !(oldName = name) : void 0 : (options.dataTypes.unshift(name), inspect(name), false);
  762.       }), oldName;
  763.     }
  764.     var old = {};
  765.     /** @type {boolean} */
  766.     var seekingTransport = structure === transports;
  767.     return inspect(options.dataTypes[0]) || !old["*"] && inspect("*");
  768.   }
  769.   /**
  770.    * @param {(Object|string)} target
  771.    * @param {Object} src
  772.    * @return {?}
  773.    */
  774.   function ajaxExtend(target, src) {
  775.     var key;
  776.     var deep;
  777.     var flatOptions = jQuery.ajaxSettings.flatOptions || {};
  778.     for (key in src) {
  779.       if (void 0 !== src[key]) {
  780.         (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
  781.       }
  782.     }
  783.     return deep && jQuery.extend(true, target, deep), target;
  784.   }
  785.   /**
  786.    * @param {Object} s
  787.    * @param {XMLHttpRequest} jqXHR
  788.    * @param {Object} responses
  789.    * @return {?}
  790.    */
  791.   function ajaxHandleResponses(s, jqXHR, responses) {
  792.     var ct;
  793.     var type;
  794.     var finalDataType;
  795.     var firstDataType;
  796.     var contents = s.contents;
  797.     var dataTypes = s.dataTypes;
  798.     for (;"*" === dataTypes[0];) {
  799.       dataTypes.shift();
  800.       if (void 0 === ct) {
  801.         ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
  802.       }
  803.     }
  804.     if (ct) {
  805.       for (type in contents) {
  806.         if (contents[type] && contents[type].test(ct)) {
  807.           dataTypes.unshift(type);
  808.           break;
  809.         }
  810.       }
  811.     }
  812.     if (dataTypes[0] in responses) {
  813.       finalDataType = dataTypes[0];
  814.     } else {
  815.       for (type in responses) {
  816.         if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
  817.           /** @type {string} */
  818.           finalDataType = type;
  819.           break;
  820.         }
  821.         if (!firstDataType) {
  822.           /** @type {string} */
  823.           firstDataType = type;
  824.         }
  825.       }
  826.       /** @type {(string|undefined)} */
  827.       finalDataType = finalDataType || firstDataType;
  828.     }
  829.     if (finalDataType) {
  830.       return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
  831.     }
  832.   }
  833.   /**
  834.    * @param {Object} s
  835.    * @param {(Object|string)} response
  836.    * @param {?} jqXHR
  837.    * @param {Object} isSuccess
  838.    * @return {?}
  839.    */
  840.   function ajaxConvert(s, response, jqXHR, isSuccess) {
  841.     var type;
  842.     var value;
  843.     var conv;
  844.     var array;
  845.     var name;
  846.     var types = {};
  847.     var results = s.dataTypes.slice();
  848.     if (results[1]) {
  849.       for (conv in s.converters) {
  850.         types[conv.toLowerCase()] = s.converters[conv];
  851.       }
  852.     }
  853.     value = results.shift();
  854.     for (;value;) {
  855.       if (s.responseFields[value] && (jqXHR[s.responseFields[value]] = response), !name && (isSuccess && (s.dataFilter && (response = s.dataFilter(response, s.dataType)))), name = value, value = results.shift()) {
  856.         if ("*" === value) {
  857.           value = name;
  858.         } else {
  859.           if ("*" !== name && name !== value) {
  860.             if (conv = types[name + " " + value] || types["* " + value], !conv) {
  861.               for (type in types) {
  862.                 if (array = type.split(" "), array[1] === value && (conv = types[name + " " + array[0]] || types["* " + array[0]])) {
  863.                   if (conv === true) {
  864.                     conv = types[type];
  865.                   } else {
  866.                     if (types[type] !== true) {
  867.                       /** @type {string} */
  868.                       value = array[0];
  869.                       results.unshift(array[1]);
  870.                     }
  871.                   }
  872.                   break;
  873.                 }
  874.               }
  875.             }
  876.             if (conv !== true) {
  877.               if (conv && s.throws) {
  878.                 response = conv(response);
  879.               } else {
  880.                 try {
  881.                   response = conv(response);
  882.                 } catch (e) {
  883.                   return{
  884.                     state : "parsererror",
  885.                     error : conv ? e : "No conversion from " + name + " to " + value
  886.                   };
  887.                 }
  888.               }
  889.             }
  890.           }
  891.         }
  892.       }
  893.     }
  894.     return{
  895.       state : "success",
  896.       data : response
  897.     };
  898.   }
  899.   /**
  900.    * @param {string} prefix
  901.    * @param {string} prop
  902.    * @param {boolean} traditional
  903.    * @param {Function} add
  904.    * @return {undefined}
  905.    */
  906.   function buildParams(prefix, prop, traditional, add) {
  907.     var name;
  908.     if (jQuery.isArray(prop)) {
  909.       jQuery.each(prop, function(i, v) {
  910.         if (traditional || rmargin.test(prefix)) {
  911.           add(prefix, v);
  912.         } else {
  913.           buildParams(prefix + "[" + ("object" == typeof v ? i : "") + "]", v, traditional, add);
  914.         }
  915.       });
  916.     } else {
  917.       if (traditional || "object" !== jQuery.type(prop)) {
  918.         add(prefix, prop);
  919.       } else {
  920.         for (name in prop) {
  921.           buildParams(prefix + "[" + name + "]", prop[name], traditional, add);
  922.         }
  923.       }
  924.     }
  925.   }
  926.   /**
  927.    * @param {Object} element
  928.    * @return {?}
  929.    */
  930.   function getWindow(element) {
  931.     return jQuery.isWindow(element) ? element : 9 === element.nodeType && element.defaultView;
  932.   }
  933.   /** @type {Array} */
  934.   var core_deletedIds = [];
  935.   /** @type {function (this:(Array.<T>|string|{length: number}), *=, *=): Array.<T>} */
  936.   var core_slice = core_deletedIds.slice;
  937.   /** @type {function (this:*, ...[*]): Array} */
  938.   var core_concat = core_deletedIds.concat;
  939.   /** @type {function (this:(Array.<T>|{length: number}), ...[T]): number} */
  940.   var core_push = core_deletedIds.push;
  941.   /** @type {function (this:(Array.<T>|string|{length: number}), T, number=): number} */
  942.   var core_indexOf = core_deletedIds.indexOf;
  943.   var class2type = {};
  944.   /** @type {function (this:*): string} */
  945.   var core_toString = class2type.toString;
  946.   /** @type {function (this:Object, *): boolean} */
  947.   var core_hasOwn = class2type.hasOwnProperty;
  948.   var support = {};
  949.   var doc = win.document;
  950.   /** @type {string} */
  951.   var core_version = "2.1.1";
  952.   /**
  953.    * @param {string} selector
  954.    * @param {Function} context
  955.    * @return {?}
  956.    */
  957.   var jQuery = function(selector, context) {
  958.     return new jQuery.fn.init(selector, context);
  959.   };
  960.   /** @type {RegExp} */
  961.   var badChars = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
  962.   /** @type {RegExp} */
  963.   var rmsPrefix = /^-ms-/;
  964.   /** @type {RegExp} */
  965.   var emptyParagraphRegexp = /-([\da-z])/gi;
  966.   /**
  967.    * @param {?} all
  968.    * @param {string} letter
  969.    * @return {?}
  970.    */
  971.   var fcamelCase = function(all, letter) {
  972.     return letter.toUpperCase();
  973.   };
  974.   var Sizzle;
  975.   var rootjQuery;
  976.   var rquickExpr;
  977.   var init;
  978.   var rparentsprev;
  979.   var data;
  980.   var core_rnotwhite;
  981.   var optionsCache;
  982.   var readyList;
  983.   var access;
  984.   var memory;
  985.   var iframe;
  986.   var elemdisplay;
  987.   var nodeHook;
  988.   var boolHook;
  989.   var values;
  990.   var rfocusable;
  991.   var rclass;
  992.   var rreturn;
  993.   var iIdCounter;
  994.   var rquery;
  995.   var eventPath;
  996.   var rjsonp;
  997.   var matcherFunction;
  998.   var docElem;
  999.   var $;
  1000.   var _$;
  1001.   jQuery.fn = jQuery.prototype = {
  1002.     jquery : core_version,
  1003.     /** @type {function (string, Function): ?} */
  1004.     constructor : jQuery,
  1005.     selector : "",
  1006.     length : 0,
  1007.     /**
  1008.      * @return {?}
  1009.      */
  1010.     toArray : function() {
  1011.       return core_slice.call(this);
  1012.     },
  1013.     /**
  1014.      * @param {Object} num
  1015.      * @return {?}
  1016.      */
  1017.     get : function(num) {
  1018.       return null != num ? 0 > num ? this[num + this.length] : this[num] : core_slice.call(this);
  1019.     },
  1020.     /**
  1021.      * @param {Array} elems
  1022.      * @return {?}
  1023.      */
  1024.     pushStack : function(elems) {
  1025.       var ret = jQuery.merge(this.constructor(), elems);
  1026.       return ret.prevObject = this, ret.context = this.context, ret;
  1027.     },
  1028.     /**
  1029.      * @param {Function} opt_attributes
  1030.      * @param {Function} args
  1031.      * @return {?}
  1032.      */
  1033.     each : function(opt_attributes, args) {
  1034.       return jQuery.each(this, opt_attributes, args);
  1035.     },
  1036.     /**
  1037.      * @param {Function} callback
  1038.      * @return {?}
  1039.      */
  1040.     map : function(callback) {
  1041.       return this.pushStack(jQuery.map(this, function(el, operation) {
  1042.         return callback.call(el, operation, el);
  1043.       }));
  1044.     },
  1045.     /**
  1046.      * @return {?}
  1047.      */
  1048.     slice : function() {
  1049.       return this.pushStack(core_slice.apply(this, arguments));
  1050.     },
  1051.     /**
  1052.      * @return {?}
  1053.      */
  1054.     first : function() {
  1055.       return this.eq(0);
  1056.     },
  1057.     /**
  1058.      * @return {?}
  1059.      */
  1060.     last : function() {
  1061.       return this.eq(-1);
  1062.     },
  1063.     /**
  1064.      * @param {number} b
  1065.      * @return {?}
  1066.      */
  1067.     eq : function(b) {
  1068.       var l = this.length;
  1069.       var i = +b + (0 > b ? l : 0);
  1070.       return this.pushStack(i >= 0 && l > i ? [this[i]] : []);
  1071.     },
  1072.     /**
  1073.      * @return {?}
  1074.      */
  1075.     end : function() {
  1076.       return this.prevObject || this.constructor(null);
  1077.     },
  1078.     /** @type {function (this:(Array.<T>|{length: number}), ...[T]): number} */
  1079.     push : core_push,
  1080.     /** @type {function (this:(Array.<T>|{length: number}), function (T, T): number=): ?} */
  1081.     sort : core_deletedIds.sort,
  1082.     /** @type {function (this:(Array.<T>|{length: number}), *=, *=, ...[T]): Array.<T>} */
  1083.     splice : core_deletedIds.splice
  1084.   };
  1085.   /** @type {function (): ?} */
  1086.   jQuery.extend = jQuery.fn.extend = function() {
  1087.     var options;
  1088.     var name;
  1089.     var src;
  1090.     var copy;
  1091.     var copyIsArray;
  1092.     var clone;
  1093.     var target = arguments[0] || {};
  1094.     /** @type {number} */
  1095.     var i = 1;
  1096.     /** @type {number} */
  1097.     var l = arguments.length;
  1098.     /** @type {boolean} */
  1099.     var deep = false;
  1100.     if ("boolean" == typeof target) {
  1101.       /** @type {boolean} */
  1102.       deep = target;
  1103.       target = arguments[i] || {};
  1104.       i++;
  1105.     }
  1106.     if (!("object" == typeof target)) {
  1107.       if (!jQuery.isFunction(target)) {
  1108.         target = {};
  1109.       }
  1110.     }
  1111.     if (i === l) {
  1112.       target = this;
  1113.       i--;
  1114.     }
  1115.     for (;l > i;i++) {
  1116.       if (null != (options = arguments[i])) {
  1117.         for (name in options) {
  1118.           src = target[name];
  1119.           copy = options[name];
  1120.           if (target !== copy) {
  1121.             if (deep && (copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy))))) {
  1122.               if (copyIsArray) {
  1123.                 /** @type {boolean} */
  1124.                 copyIsArray = false;
  1125.                 clone = src && jQuery.isArray(src) ? src : [];
  1126.               } else {
  1127.                 clone = src && jQuery.isPlainObject(src) ? src : {};
  1128.               }
  1129.               target[name] = jQuery.extend(deep, clone, copy);
  1130.             } else {
  1131.               if (void 0 !== copy) {
  1132.                 target[name] = copy;
  1133.               }
  1134.             }
  1135.           }
  1136.         }
  1137.       }
  1138.     }
  1139.     return target;
  1140.   };
  1141.   jQuery.extend({
  1142.     expando : "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
  1143.     isReady : true,
  1144.     /**
  1145.      * @param {string} args
  1146.      * @return {?}
  1147.      */
  1148.     error : function(args) {
  1149.       throw new Error(args);
  1150.     },
  1151.     /**
  1152.      * @return {undefined}
  1153.      */
  1154.     noop : function() {
  1155.     },
  1156.     /**
  1157.      * @param {string} arg
  1158.      * @return {?}
  1159.      */
  1160.     isFunction : function(arg) {
  1161.       return "function" === jQuery.type(arg);
  1162.     },
  1163.     /** @type {function (*): boolean} */
  1164.     isArray : Array.isArray,
  1165.     /**
  1166.      * @param {Object} obj
  1167.      * @return {?}
  1168.      */
  1169.     isWindow : function(obj) {
  1170.       return null != obj && obj === obj.window;
  1171.     },
  1172.     /**
  1173.      * @param {string} val
  1174.      * @return {?}
  1175.      */
  1176.     isNumeric : function(val) {
  1177.       return!jQuery.isArray(val) && val - parseFloat(val) >= 0;
  1178.     },
  1179.     /**
  1180.      * @param {string} expr
  1181.      * @return {?}
  1182.      */
  1183.     isPlainObject : function(expr) {
  1184.       return "object" !== jQuery.type(expr) || (expr.nodeType || jQuery.isWindow(expr)) ? false : expr.constructor && !core_hasOwn.call(expr.constructor.prototype, "isPrototypeOf") ? false : true;
  1185.     },
  1186.     /**
  1187.      * @param {?} obj
  1188.      * @return {?}
  1189.      */
  1190.     isEmptyObject : function(obj) {
  1191.       var prop;
  1192.       for (prop in obj) {
  1193.         return false;
  1194.       }
  1195.       return true;
  1196.     },
  1197.     /**
  1198.      * @param {string} args
  1199.      * @return {?}
  1200.      */
  1201.     type : function(args) {
  1202.       return null == args ? args + "" : "object" == typeof args || "function" == typeof args ? class2type[core_toString.call(args)] || "object" : typeof args;
  1203.     },
  1204.     /**
  1205.      * @param {string} code
  1206.      * @return {undefined}
  1207.      */
  1208.     globalEval : function(code) {
  1209.       var script;
  1210.       /** @type {function (string): *} */
  1211.       var indirect = eval;
  1212.       code = jQuery.trim(code);
  1213.       if (code) {
  1214.         if (1 === code.indexOf("use strict")) {
  1215.           script = doc.createElement("script");
  1216.           /** @type {string} */
  1217.           script.text = code;
  1218.           doc.head.appendChild(script).parentNode.removeChild(script);
  1219.         } else {
  1220.           indirect(code);
  1221.         }
  1222.       }
  1223.     },
  1224.     /**
  1225.      * @param {string} string
  1226.      * @return {?}
  1227.      */
  1228.     camelCase : function(string) {
  1229.       return string.replace(rmsPrefix, "ms-").replace(emptyParagraphRegexp, fcamelCase);
  1230.     },
  1231.     /**
  1232.      * @param {Node} elem
  1233.      * @param {string} name
  1234.      * @return {?}
  1235.      */
  1236.     nodeName : function(elem, name) {
  1237.       return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  1238.     },
  1239.     /**
  1240.      * @param {Function} obj
  1241.      * @param {Function} callback
  1242.      * @param {Object} args
  1243.      * @return {?}
  1244.      */
  1245.     each : function(obj, callback, args) {
  1246.       var value;
  1247.       /** @type {number} */
  1248.       var i = 0;
  1249.       var l = obj.length;
  1250.       var isArray = isArraylike(obj);
  1251.       if (args) {
  1252.         if (isArray) {
  1253.           for (;l > i;i++) {
  1254.             if (value = callback.apply(obj[i], args), value === false) {
  1255.               break;
  1256.             }
  1257.           }
  1258.         } else {
  1259.           for (i in obj) {
  1260.             if (value = callback.apply(obj[i], args), value === false) {
  1261.               break;
  1262.             }
  1263.           }
  1264.         }
  1265.       } else {
  1266.         if (isArray) {
  1267.           for (;l > i;i++) {
  1268.             if (value = callback.call(obj[i], i, obj[i]), value === false) {
  1269.               break;
  1270.             }
  1271.           }
  1272.         } else {
  1273.           for (i in obj) {
  1274.             if (value = callback.call(obj[i], i, obj[i]), value === false) {
  1275.               break;
  1276.             }
  1277.           }
  1278.         }
  1279.       }
  1280.       return obj;
  1281.     },
  1282.     /**
  1283.      * @param {Object} text
  1284.      * @return {?}
  1285.      */
  1286.     trim : function(text) {
  1287.       return null == text ? "" : (text + "").replace(badChars, "");
  1288.     },
  1289.     /**
  1290.      * @param {?} arr
  1291.      * @param {Array} results
  1292.      * @return {?}
  1293.      */
  1294.     makeArray : function(arr, results) {
  1295.       var ret = results || [];
  1296.       return null != arr && (isArraylike(Object(arr)) ? jQuery.merge(ret, "string" == typeof arr ? [arr] : arr) : core_push.call(ret, arr)), ret;
  1297.     },
  1298.     /**
  1299.      * @param {?} elem
  1300.      * @param {?} arr
  1301.      * @param {?} i
  1302.      * @return {?}
  1303.      */
  1304.     inArray : function(elem, arr, i) {
  1305.       return null == arr ? -1 : core_indexOf.call(arr, elem, i);
  1306.     },
  1307.     /**
  1308.      * @param {Array} first
  1309.      * @param {?} second
  1310.      * @return {?}
  1311.      */
  1312.     merge : function(first, second) {
  1313.       /** @type {number} */
  1314.       var jlen = +second.length;
  1315.       /** @type {number} */
  1316.       var j = 0;
  1317.       var i = first.length;
  1318.       for (;jlen > j;j++) {
  1319.         first[i++] = second[j];
  1320.       }
  1321.       return first.length = i, first;
  1322.     },
  1323.     /**
  1324.      * @param {Array} elems
  1325.      * @param {Function} callback
  1326.      * @param {?} inv
  1327.      * @return {?}
  1328.      */
  1329.     grep : function(elems, callback, inv) {
  1330.       var val;
  1331.       /** @type {Array} */
  1332.       var ret = [];
  1333.       /** @type {number} */
  1334.       var i = 0;
  1335.       var l = elems.length;
  1336.       /** @type {boolean} */
  1337.       var skip = !inv;
  1338.       for (;l > i;i++) {
  1339.         /** @type {boolean} */
  1340.         val = !callback(elems[i], i);
  1341.         if (val !== skip) {
  1342.           ret.push(elems[i]);
  1343.         }
  1344.       }
  1345.       return ret;
  1346.     },
  1347.     /**
  1348.      * @param {Object} elems
  1349.      * @param {Function} callback
  1350.      * @param {boolean} arg
  1351.      * @return {?}
  1352.      */
  1353.     map : function(elems, callback, arg) {
  1354.       var value;
  1355.       /** @type {number} */
  1356.       var i = 0;
  1357.       var l = elems.length;
  1358.       var isArray = isArraylike(elems);
  1359.       /** @type {Array} */
  1360.       var args = [];
  1361.       if (isArray) {
  1362.         for (;l > i;i++) {
  1363.           value = callback(elems[i], i, arg);
  1364.           if (null != value) {
  1365.             args.push(value);
  1366.           }
  1367.         }
  1368.       } else {
  1369.         for (i in elems) {
  1370.           value = callback(elems[i], i, arg);
  1371.           if (null != value) {
  1372.             args.push(value);
  1373.           }
  1374.         }
  1375.       }
  1376.       return core_concat.apply([], args);
  1377.     },
  1378.     guid : 1,
  1379.     /**
  1380.      * @param {Object} fn
  1381.      * @param {(Function|string)} context
  1382.      * @return {?}
  1383.      */
  1384.     proxy : function(fn, context) {
  1385.       var tmp;
  1386.       var args;
  1387.       var proxy;
  1388.       return "string" == typeof context && (tmp = fn[context], context = fn, fn = tmp), jQuery.isFunction(fn) ? (args = core_slice.call(arguments, 2), proxy = function() {
  1389.         return fn.apply(context || this, args.concat(core_slice.call(arguments)));
  1390.       }, proxy.guid = fn.guid = fn.guid || jQuery.guid++, proxy) : void 0;
  1391.     },
  1392.     /** @type {function (): number} */
  1393.     now : Date.now,
  1394.     support : support
  1395.   });
  1396.   jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(dataAndEvents, m3) {
  1397.     class2type["[object " + m3 + "]"] = m3.toLowerCase();
  1398.   });
  1399.   Sizzle = function(win) {
  1400.     /**
  1401.      * @param {string} selector
  1402.      * @param {Object} context
  1403.      * @param {Array} recurring
  1404.      * @param {Array} seed
  1405.      * @return {?}
  1406.      */
  1407.     function Sizzle(selector, context, recurring, seed) {
  1408.       var match;
  1409.       var elem;
  1410.       var m;
  1411.       var nodeType;
  1412.       var i;
  1413.       var groups;
  1414.       var old;
  1415.       var nid;
  1416.       var newContext;
  1417.       var newSelector;
  1418.       if ((context ? context.ownerDocument || context : preferredDoc) !== doc && setDocument(context), context = context || doc, recurring = recurring || [], !selector || "string" != typeof selector) {
  1419.         return recurring;
  1420.       }
  1421.       if (1 !== (nodeType = context.nodeType) && 9 !== nodeType) {
  1422.         return[];
  1423.       }
  1424.       if (documentIsHTML && !seed) {
  1425.         if (match = rquickExpr.exec(selector)) {
  1426.           if (m = match[1]) {
  1427.             if (9 === nodeType) {
  1428.               if (elem = context.getElementById(m), !elem || !elem.parentNode) {
  1429.                 return recurring;
  1430.               }
  1431.               if (elem.id === m) {
  1432.                 return recurring.push(elem), recurring;
  1433.               }
  1434.             } else {
  1435.               if (context.ownerDocument && ((elem = context.ownerDocument.getElementById(m)) && (contains(context, elem) && elem.id === m))) {
  1436.                 return recurring.push(elem), recurring;
  1437.               }
  1438.             }
  1439.           } else {
  1440.             if (match[2]) {
  1441.               return push.apply(recurring, context.getElementsByTagName(selector)), recurring;
  1442.             }
  1443.             if ((m = match[3]) && (support.getElementsByClassName && context.getElementsByClassName)) {
  1444.               return push.apply(recurring, context.getElementsByClassName(m)), recurring;
  1445.             }
  1446.           }
  1447.         }
  1448.         if (support.qsa && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
  1449.           if (nid = old = expando, newContext = context, newSelector = 9 === nodeType && selector, 1 === nodeType && "object" !== context.nodeName.toLowerCase()) {
  1450.             groups = tokenize(selector);
  1451.             if (old = context.getAttribute("id")) {
  1452.               nid = old.replace(r20, "\\$&");
  1453.             } else {
  1454.               context.setAttribute("id", nid);
  1455.             }
  1456.             /** @type {string} */
  1457.             nid = "[id='" + nid + "'] ";
  1458.             i = groups.length;
  1459.             for (;i--;) {
  1460.               /** @type {string} */
  1461.               groups[i] = nid + toSelector(groups[i]);
  1462.             }
  1463.             newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
  1464.             newSelector = groups.join(",");
  1465.           }
  1466.           if (newSelector) {
  1467.             try {
  1468.               return push.apply(recurring, newContext.querySelectorAll(newSelector)), recurring;
  1469.             } catch (tt) {
  1470.             } finally {
  1471.               if (!old) {
  1472.                 context.removeAttribute("id");
  1473.               }
  1474.             }
  1475.           }
  1476.         }
  1477.       }
  1478.       return select(selector.replace(rtrim, "$1"), context, recurring, seed);
  1479.     }
  1480.     /**
  1481.      * @return {?}
  1482.      */
  1483.     function createCache() {
  1484.       /**
  1485.        * @param {string} key
  1486.        * @param {?} value
  1487.        * @return {?}
  1488.        */
  1489.       function cache(key, value) {
  1490.         return buf.push(key + " ") > Expr.cacheLength && delete cache[buf.shift()], cache[key + " "] = value;
  1491.       }
  1492.       /** @type {Array} */
  1493.       var buf = [];
  1494.       return cache;
  1495.     }
  1496.     /**
  1497.      * @param {Function} fn
  1498.      * @return {?}
  1499.      */
  1500.     function markFunction(fn) {
  1501.       return fn[expando] = true, fn;
  1502.     }
  1503.     /**
  1504.      * @param {Function} fn
  1505.      * @return {?}
  1506.      */
  1507.     function assert(fn) {
  1508.       var t = doc.createElement("div");
  1509.       try {
  1510.         return!!fn(t);
  1511.       } catch (i) {
  1512.         return false;
  1513.       } finally {
  1514.         if (t.parentNode) {
  1515.           t.parentNode.removeChild(t);
  1516.         }
  1517.         /** @type {null} */
  1518.         t = null;
  1519.       }
  1520.     }
  1521.     /**
  1522.      * @param {string} attrs
  1523.      * @param {Function} handler
  1524.      * @return {undefined}
  1525.      */
  1526.     function addHandle(attrs, handler) {
  1527.       var arr = attrs.split("|");
  1528.       var i = attrs.length;
  1529.       for (;i--;) {
  1530.         /** @type {Function} */
  1531.         Expr.attrHandle[arr[i]] = handler;
  1532.       }
  1533.     }
  1534.     /**
  1535.      * @param {Object} a
  1536.      * @param {Object} b
  1537.      * @return {?}
  1538.      */
  1539.     function siblingCheck(a, b) {
  1540.       var cur = b && a;
  1541.       var diff = cur && (1 === a.nodeType && (1 === b.nodeType && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE)));
  1542.       if (diff) {
  1543.         return diff;
  1544.       }
  1545.       if (cur) {
  1546.         for (;cur = cur.nextSibling;) {
  1547.           if (cur === b) {
  1548.             return-1;
  1549.           }
  1550.         }
  1551.       }
  1552.       return a ? 1 : -1;
  1553.     }
  1554.     /**
  1555.      * @param {?} type
  1556.      * @return {?}
  1557.      */
  1558.     function createInputPseudo(type) {
  1559.       return function(elem) {
  1560.         var b = elem.nodeName.toLowerCase();
  1561.         return "input" === b && elem.type === type;
  1562.       };
  1563.     }
  1564.     /**
  1565.      * @param {?} type
  1566.      * @return {?}
  1567.      */
  1568.     function createButtonPseudo(type) {
  1569.       return function(elem) {
  1570.         var NULL = elem.nodeName.toLowerCase();
  1571.         return("input" === NULL || "button" === NULL) && elem.type === type;
  1572.       };
  1573.     }
  1574.     /**
  1575.      * @param {Function} fn
  1576.      * @return {?}
  1577.      */
  1578.     function createPositionalPseudo(fn) {
  1579.       return markFunction(function(argument) {
  1580.         return argument = +argument, markFunction(function(seed, matches) {
  1581.           var j;
  1582.           var matchIndexes = fn([], seed.length, argument);
  1583.           var i = matchIndexes.length;
  1584.           for (;i--;) {
  1585.             if (seed[j = matchIndexes[i]]) {
  1586.               /** @type {boolean} */
  1587.               seed[j] = !(matches[j] = seed[j]);
  1588.             }
  1589.           }
  1590.         });
  1591.       });
  1592.     }
  1593.     /**
  1594.      * @param {Object} context
  1595.      * @return {?}
  1596.      */
  1597.     function testContext(context) {
  1598.       return context && (typeof context.getElementsByTagName !== strundefined && context);
  1599.     }
  1600.     /**
  1601.      * @return {undefined}
  1602.      */
  1603.     function setFilters() {
  1604.     }
  1605.     /**
  1606.      * @param {Array} tokens
  1607.      * @return {?}
  1608.      */
  1609.     function toSelector(tokens) {
  1610.       /** @type {number} */
  1611.       var i = 0;
  1612.       var nTokens = tokens.length;
  1613.       /** @type {string} */
  1614.       var selector = "";
  1615.       for (;nTokens > i;i++) {
  1616.         selector += tokens[i].value;
  1617.       }
  1618.       return selector;
  1619.     }
  1620.     /**
  1621.      * @param {Function} matcher
  1622.      * @param {Object} combinator
  1623.      * @param {boolean} dataAndEvents
  1624.      * @return {?}
  1625.      */
  1626.     function addCombinator(matcher, combinator, dataAndEvents) {
  1627.       var dir = combinator.dir;
  1628.       var u = dataAndEvents && "parentNode" === dir;
  1629.       /** @type {number} */
  1630.       var doneName = done++;
  1631.       return combinator.first ? function(elem, context, xml) {
  1632.         for (;elem = elem[dir];) {
  1633.           if (1 === elem.nodeType || u) {
  1634.             return matcher(elem, context, xml);
  1635.           }
  1636.         }
  1637.       } : function(elem, context, xml) {
  1638.         var oldCache;
  1639.         var outerCache;
  1640.         /** @type {Array} */
  1641.         var newCache = [dirruns, doneName];
  1642.         if (xml) {
  1643.           for (;elem = elem[dir];) {
  1644.             if ((1 === elem.nodeType || u) && matcher(elem, context, xml)) {
  1645.               return true;
  1646.             }
  1647.           }
  1648.         } else {
  1649.           for (;elem = elem[dir];) {
  1650.             if (1 === elem.nodeType || u) {
  1651.               if (outerCache = elem[expando] || (elem[expando] = {}), (oldCache = outerCache[dir]) && (oldCache[0] === dirruns && oldCache[1] === doneName)) {
  1652.                 return newCache[2] = oldCache[2];
  1653.               }
  1654.               if (outerCache[dir] = newCache, newCache[2] = matcher(elem, context, xml)) {
  1655.                 return true;
  1656.               }
  1657.             }
  1658.           }
  1659.         }
  1660.       };
  1661.     }
  1662.     /**
  1663.      * @param {Array} matchers
  1664.      * @return {?}
  1665.      */
  1666.     function elementMatcher(matchers) {
  1667.       return matchers.length > 1 ? function(elem, context, xml) {
  1668.         var i = matchers.length;
  1669.         for (;i--;) {
  1670.           if (!matchers[i](elem, context, xml)) {
  1671.             return false;
  1672.           }
  1673.         }
  1674.         return true;
  1675.       } : matchers[0];
  1676.     }
  1677.     /**
  1678.      * @param {string} selector
  1679.      * @param {Array} contexts
  1680.      * @param {?} recurring
  1681.      * @return {?}
  1682.      */
  1683.     function multipleContexts(selector, contexts, recurring) {
  1684.       /** @type {number} */
  1685.       var i = 0;
  1686.       var len = contexts.length;
  1687.       for (;len > i;i++) {
  1688.         Sizzle(selector, contexts[i], recurring);
  1689.       }
  1690.       return recurring;
  1691.     }
  1692.     /**
  1693.      * @param {Array} a
  1694.      * @param {Object} str
  1695.      * @param {string} filter
  1696.      * @param {Object} context
  1697.      * @param {?} xml
  1698.      * @return {?}
  1699.      */
  1700.     function condense(a, str, filter, context, xml) {
  1701.       var value;
  1702.       /** @type {Array} */
  1703.       var bucket = [];
  1704.       /** @type {number} */
  1705.       var prefix = 0;
  1706.       var al = a.length;
  1707.       /** @type {boolean} */
  1708.       var isFile = null != str;
  1709.       for (;al > prefix;prefix++) {
  1710.         if (value = a[prefix]) {
  1711.           if (!filter || filter(value, context, xml)) {
  1712.             bucket.push(value);
  1713.             if (isFile) {
  1714.               str.push(prefix);
  1715.             }
  1716.           }
  1717.         }
  1718.       }
  1719.       return bucket;
  1720.     }
  1721.     /**
  1722.      * @param {string} preFilter
  1723.      * @param {Object} selector
  1724.      * @param {boolean} matcher
  1725.      * @param {Object} postFilter
  1726.      * @param {Object} postFinder
  1727.      * @param {Object} postSelector
  1728.      * @return {?}
  1729.      */
  1730.     function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
  1731.       return postFilter && (!postFilter[expando] && (postFilter = setMatcher(postFilter))), postFinder && (!postFinder[expando] && (postFinder = setMatcher(postFinder, postSelector))), markFunction(function(seed, results, context, xml) {
  1732.         var prop;
  1733.         var i;
  1734.         var val;
  1735.         /** @type {Array} */
  1736.         var preMap = [];
  1737.         /** @type {Array} */
  1738.         var parts = [];
  1739.         var preexisting = results.length;
  1740.         var target = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []);
  1741.         var obj = !preFilter || !seed && selector ? target : condense(target, preMap, preFilter, context, xml);
  1742.         var matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : obj;
  1743.         if (matcher && matcher(obj, matcherOut, context, xml), postFilter) {
  1744.           prop = condense(matcherOut, parts);
  1745.           postFilter(prop, [], context, xml);
  1746.           i = prop.length;
  1747.           for (;i--;) {
  1748.             if (val = prop[i]) {
  1749.               /** @type {boolean} */
  1750.               matcherOut[parts[i]] = !(obj[parts[i]] = val);
  1751.             }
  1752.           }
  1753.         }
  1754.         if (seed) {
  1755.           if (postFinder || preFilter) {
  1756.             if (postFinder) {
  1757.               /** @type {Array} */
  1758.               prop = [];
  1759.               i = matcherOut.length;
  1760.               for (;i--;) {
  1761.                 if (val = matcherOut[i]) {
  1762.                   prop.push(obj[i] = val);
  1763.                 }
  1764.               }
  1765.               postFinder(null, matcherOut = [], prop, xml);
  1766.             }
  1767.             i = matcherOut.length;
  1768.             for (;i--;) {
  1769.               if (val = matcherOut[i]) {
  1770.                 if ((prop = postFinder ? jQuery.call(seed, val) : preMap[i]) > -1) {
  1771.                   /** @type {boolean} */
  1772.                   seed[prop] = !(results[prop] = val);
  1773.                 }
  1774.               }
  1775.             }
  1776.           }
  1777.         } else {
  1778.           matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
  1779.           if (postFinder) {
  1780.             postFinder(null, results, matcherOut, xml);
  1781.           } else {
  1782.             push.apply(results, matcherOut);
  1783.           }
  1784.         }
  1785.       });
  1786.     }
  1787.     /**
  1788.      * @param {Object} tokens
  1789.      * @return {?}
  1790.      */
  1791.     function matcherFromTokens(tokens) {
  1792.       var nodes;
  1793.       var matcher;
  1794.       var j;
  1795.       var len = tokens.length;
  1796.       var leadingRelative = Expr.relative[tokens[0].type];
  1797.       var implicitRelative = leadingRelative || Expr.relative[" "];
  1798.       /** @type {number} */
  1799.       var i = leadingRelative ? 1 : 0;
  1800.       var matchContext = addCombinator(function(dataAndEvents) {
  1801.         return dataAndEvents === nodes;
  1802.       }, implicitRelative, true);
  1803.       var matchAnyContext = addCombinator(function(elements) {
  1804.         return jQuery.call(nodes, elements) > -1;
  1805.       }, implicitRelative, true);
  1806.       /** @type {Array} */
  1807.       var matchers = [function(elem, context, xml) {
  1808.         return!leadingRelative && (xml || context !== outermostContext) || ((nodes = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
  1809.       }];
  1810.       for (;len > i;i++) {
  1811.         if (matcher = Expr.relative[tokens[i].type]) {
  1812.           /** @type {Array} */
  1813.           matchers = [addCombinator(elementMatcher(matchers), matcher)];
  1814.         } else {
  1815.           if (matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches), matcher[expando]) {
  1816.             /** @type {number} */
  1817.             j = ++i;
  1818.             for (;len > j;j++) {
  1819.               if (Expr.relative[tokens[j].type]) {
  1820.                 break;
  1821.               }
  1822.             }
  1823.             return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({
  1824.               value : " " === tokens[i - 2].type ? "*" : ""
  1825.             })).replace(rtrim, "$1"), matcher, j > i && matcherFromTokens(tokens.slice(i, j)), len > j && matcherFromTokens(tokens = tokens.slice(j)), len > j && toSelector(tokens));
  1826.           }
  1827.           matchers.push(matcher);
  1828.         }
  1829.       }
  1830.       return elementMatcher(matchers);
  1831.     }
  1832.     /**
  1833.      * @param {Array} elementMatchers
  1834.      * @param {Array} setMatchers
  1835.      * @return {?}
  1836.      */
  1837.     function matcherFromGroupMatchers(elementMatchers, setMatchers) {
  1838.       /** @type {boolean} */
  1839.       var bySet = setMatchers.length > 0;
  1840.       /** @type {boolean} */
  1841.       var byElement = elementMatchers.length > 0;
  1842.       /**
  1843.        * @param {HTMLElement} seed
  1844.        * @param {Function} context
  1845.        * @param {?} xml
  1846.        * @param {Array} results
  1847.        * @param {Object} selFrom
  1848.        * @return {?}
  1849.        */
  1850.       var superMatcher = function(seed, context, xml, results, selFrom) {
  1851.         var elem;
  1852.         var j;
  1853.         var matcher;
  1854.         /** @type {number} */
  1855.         var matchedCount = 0;
  1856.         /** @type {string} */
  1857.         var i = "0";
  1858.         var unmatched = seed && [];
  1859.         /** @type {Array} */
  1860.         var setMatched = [];
  1861.         var contextBackup = outermostContext;
  1862.         var elems = seed || byElement && Expr.find.TAG("*", selFrom);
  1863.         var dirrunsUnique = dirruns += null == contextBackup ? 1 : Math.random() || 0.1;
  1864.         var len = elems.length;
  1865.         if (selFrom) {
  1866.           outermostContext = context !== doc && context;
  1867.         }
  1868.         for (;i !== len && null != (elem = elems[i]);i++) {
  1869.           if (byElement && elem) {
  1870.             /** @type {number} */
  1871.             j = 0;
  1872.             for (;matcher = elementMatchers[j++];) {
  1873.               if (matcher(elem, context, xml)) {
  1874.                 results.push(elem);
  1875.                 break;
  1876.               }
  1877.             }
  1878.             if (selFrom) {
  1879.               dirruns = dirrunsUnique;
  1880.             }
  1881.           }
  1882.           if (bySet) {
  1883.             if (elem = !matcher && elem) {
  1884.               matchedCount--;
  1885.             }
  1886.             if (seed) {
  1887.               unmatched.push(elem);
  1888.             }
  1889.           }
  1890.         }
  1891.         if (matchedCount += i, bySet && i !== matchedCount) {
  1892.           /** @type {number} */
  1893.           j = 0;
  1894.           for (;matcher = setMatchers[j++];) {
  1895.             matcher(unmatched, setMatched, context, xml);
  1896.           }
  1897.           if (seed) {
  1898.             if (matchedCount > 0) {
  1899.               for (;i--;) {
  1900.                 if (!unmatched[i]) {
  1901.                   if (!setMatched[i]) {
  1902.                     setMatched[i] = pop.call(results);
  1903.                   }
  1904.                 }
  1905.               }
  1906.             }
  1907.             setMatched = condense(setMatched);
  1908.           }
  1909.           push.apply(results, setMatched);
  1910.           if (selFrom) {
  1911.             if (!seed) {
  1912.               if (setMatched.length > 0) {
  1913.                 if (matchedCount + setMatchers.length > 1) {
  1914.                   Sizzle.uniqueSort(results);
  1915.                 }
  1916.               }
  1917.             }
  1918.           }
  1919.         }
  1920.         return selFrom && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
  1921.       };
  1922.       return bySet ? markFunction(superMatcher) : superMatcher;
  1923.     }
  1924.     var i;
  1925.     var support;
  1926.     var Expr;
  1927.     var getText;
  1928.     var objectToString;
  1929.     var tokenize;
  1930.     var compile;
  1931.     var select;
  1932.     var outermostContext;
  1933.     var sortInput;
  1934.     var rt;
  1935.     var setDocument;
  1936.     var doc;
  1937.     var docElem;
  1938.     var documentIsHTML;
  1939.     var rbuggyQSA;
  1940.     var rbuggyMatches;
  1941.     var matches;
  1942.     var contains;
  1943.     /** @type {string} */
  1944.     var expando = "sizzle" + -new Date;
  1945.     var preferredDoc = win.document;
  1946.     /** @type {number} */
  1947.     var dirruns = 0;
  1948.     /** @type {number} */
  1949.     var done = 0;
  1950.     var classCache = createCache();
  1951.     var tokenCache = createCache();
  1952.     var compilerCache = createCache();
  1953.     /**
  1954.      * @param {?} a
  1955.      * @param {?} b
  1956.      * @return {?}
  1957.      */
  1958.     var sortOrder = function(a, b) {
  1959.       return a === b && (rt = true), 0;
  1960.     };
  1961.     /** @type {string} */
  1962.     var strundefined = "undefined";
  1963.     /** @type {number} */
  1964.     var MAX_NEGATIVE = -2147483648;
  1965.     /** @type {function (this:Object, *): boolean} */
  1966.     var hasOwn = {}.hasOwnProperty;
  1967.     /** @type {Array} */
  1968.     var arr = [];
  1969.     /** @type {function (this:(Array.<T>|{length: number})): T} */
  1970.     var pop = arr.pop;
  1971.     /** @type {function (this:(Array.<T>|{length: number}), ...[T]): number} */
  1972.     var f = arr.push;
  1973.     /** @type {function (this:(Array.<T>|{length: number}), ...[T]): number} */
  1974.     var push = arr.push;
  1975.     /** @type {function (this:(Array.<T>|string|{length: number}), *=, *=): Array.<T>} */
  1976.     var slice = arr.slice;
  1977.     /** @type {function (this:(Array.<T>|string|{length: number}), T, number=): number} */
  1978.     var jQuery = arr.indexOf || function(type) {
  1979.       /** @type {number} */
  1980.       var j = 0;
  1981.       var len = this.length;
  1982.       for (;len > j;j++) {
  1983.         if (this[j] === type) {
  1984.           return j;
  1985.         }
  1986.       }
  1987.       return-1;
  1988.     };
  1989.     /** @type {string} */
  1990.     var booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped";
  1991.     /** @type {string} */
  1992.     var version = "[\\x20\\t\\r\\n\\f]";
  1993.     /** @type {string} */
  1994.     var characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+";
  1995.     /** @type {string} */
  1996.     var identifier = characterEncoding.replace("w", "w#");
  1997.     /** @type {string} */
  1998.     var attributes = "\\[" + version + "*(" + characterEncoding + ")(?:" + version + "*([*^$|!~]?=)" + version + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + version + "*\\]";
  1999.     /** @type {string} */
  2000.     var pseudos = ":(" + characterEncoding + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|.*)\\)|)";
  2001.     /** @type {RegExp} */
  2002.     var rtrim = new RegExp("^" + version + "+|((?:^|[^\\\\])(?:\\\\.)*)" + version + "+$", "g");
  2003.     /** @type {RegExp} */
  2004.     var rcomma = new RegExp("^" + version + "*," + version + "*");
  2005.     /** @type {RegExp} */
  2006.     var rcombinators = new RegExp("^" + version + "*([>+~]|" + version + ")" + version + "*");
  2007.     /** @type {RegExp} */
  2008.     var rattributeQuotes = new RegExp("=" + version + "*([^\\]'\"]*?)" + version + "*\\]", "g");
  2009.     /** @type {RegExp} */
  2010.     var rpseudo = new RegExp(pseudos);
  2011.     /** @type {RegExp} */
  2012.     var ridentifier = new RegExp("^" + identifier + "$");
  2013.     var matchExpr = {
  2014.       ID : new RegExp("^#(" + characterEncoding + ")"),
  2015.       CLASS : new RegExp("^\\.(" + characterEncoding + ")"),
  2016.       TAG : new RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
  2017.       ATTR : new RegExp("^" + attributes),
  2018.       PSEUDO : new RegExp("^" + pseudos),
  2019.       CHILD : new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + version + "*(even|odd|(([+-]|)(\\d*)n|)" + version + "*(?:([+-]|)" + version + "*(\\d+)|))" + version + "*\\)|)", "i"),
  2020.       bool : new RegExp("^(?:" + booleans + ")$", "i"),
  2021.       needsContext : new RegExp("^" + version + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + version + "*((?:-\\d)?\\d*)" + version + "*\\)|)(?=[^-]|$)", "i")
  2022.     };
  2023.     /** @type {RegExp} */
  2024.     var rinputs = /^(?:input|select|textarea|button)$/i;
  2025.     /** @type {RegExp} */
  2026.     var rheader = /^h\d$/i;
  2027.     /** @type {RegExp} */
  2028.     var rnative = /^[^{]+\{\s*\[native \w/;
  2029.     /** @type {RegExp} */
  2030.     var rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
  2031.     /** @type {RegExp} */
  2032.     var rsibling = /[+~]/;
  2033.     /** @type {RegExp} */
  2034.     var r20 = /'|\\/g;
  2035.     /** @type {RegExp} */
  2036.     var runescape = new RegExp("\\\\([\\da-f]{1,6}" + version + "?|(" + version + ")|.)", "ig");
  2037.     /**
  2038.      * @param {?} _
  2039.      * @param {(number|string)} escaped
  2040.      * @param {boolean} escapedWhitespace
  2041.      * @return {?}
  2042.      */
  2043.     var funescape = function(_, escaped, escapedWhitespace) {
  2044.       /** @type {number} */
  2045.       var high = "0x" + escaped - 65536;
  2046.       return high !== high || escapedWhitespace ? escaped : 0 > high ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, 1023 & high | 56320);
  2047.     };
  2048.     try {
  2049.       push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
  2050.       arr[preferredDoc.childNodes.length].nodeType;
  2051.     } catch (yr) {
  2052.       push = {
  2053.         /** @type {function (?, ?): undefined} */
  2054.         apply : arr.length ? function(recurring, args) {
  2055.           f.apply(recurring, slice.call(args));
  2056.         } : function(recurring, args) {
  2057.           var j = recurring.length;
  2058.           /** @type {number} */
  2059.           var i = 0;
  2060.           for (;recurring[j++] = args[i++];) {
  2061.           }
  2062.           /** @type {number} */
  2063.           recurring.length = j - 1;
  2064.         }
  2065.       };
  2066.     }
  2067.     support = Sizzle.support = {};
  2068.     /** @type {function (Object): ?} */
  2069.     objectToString = Sizzle.isXML = function(elem) {
  2070.       var node = elem && (elem.ownerDocument || elem).documentElement;
  2071.       return node ? "HTML" !== node.nodeName : false;
  2072.     };
  2073.     /** @type {function (boolean): ?} */
  2074.     setDocument = Sizzle.setDocument = function(node) {
  2075.       var hasCompare;
  2076.       var d = node ? node.ownerDocument || node : preferredDoc;
  2077.       var parent = d.defaultView;
  2078.       return d !== doc && (9 === d.nodeType && d.documentElement) ? (doc = d, docElem = d.documentElement, documentIsHTML = !objectToString(d), parent && (parent !== parent.top && (parent.addEventListener ? parent.addEventListener("unload", function() {
  2079.         setDocument();
  2080.       }, false) : parent.attachEvent && parent.attachEvent("onunload", function() {
  2081.         setDocument();
  2082.       }))), support.attributes = assert(function(div) {
  2083.         return div.className = "i", !div.getAttribute("className");
  2084.       }), support.getElementsByTagName = assert(function(div) {
  2085.         return div.appendChild(d.createComment("")), !div.getElementsByTagName("*").length;
  2086.       }), support.getElementsByClassName = rnative.test(d.getElementsByClassName) && assert(function(div) {
  2087.         return div.innerHTML = "<div class='a'></div><div class='a i'></div>", div.firstChild.className = "i", 2 === div.getElementsByClassName("i").length;
  2088.       }), support.getById = assert(function(div) {
  2089.         return docElem.appendChild(div).id = expando, !d.getElementsByName || !d.getElementsByName(expando).length;
  2090.       }), support.getById ? (Expr.find.ID = function(id, context) {
  2091.         if (typeof context.getElementById !== strundefined && documentIsHTML) {
  2092.           var m = context.getElementById(id);
  2093.           return m && m.parentNode ? [m] : [];
  2094.         }
  2095.       }, Expr.filter.ID = function(id) {
  2096.         var attrId = id.replace(runescape, funescape);
  2097.         return function(elem) {
  2098.           return elem.getAttribute("id") === attrId;
  2099.         };
  2100.       }) : (delete Expr.find.ID, Expr.filter.ID = function(id) {
  2101.         var attrId = id.replace(runescape, funescape);
  2102.         return function(elem) {
  2103.           var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
  2104.           return node && node.value === attrId;
  2105.         };
  2106.       }), Expr.find.TAG = support.getElementsByTagName ? function(tag, from) {
  2107.         if (typeof from.getElementsByTagName !== strundefined) {
  2108.           return from.getElementsByTagName(tag);
  2109.         }
  2110.       } : function(tag, from) {
  2111.         var node;
  2112.         /** @type {Array} */
  2113.         var tmp = [];
  2114.         /** @type {number} */
  2115.         var i = 0;
  2116.         var elem = from.getElementsByTagName(tag);
  2117.         if ("*" === tag) {
  2118.           for (;node = elem[i++];) {
  2119.             if (1 === node.nodeType) {
  2120.               tmp.push(node);
  2121.             }
  2122.           }
  2123.           return tmp;
  2124.         }
  2125.         return elem;
  2126.       }, Expr.find.CLASS = support.getElementsByClassName && function(className, context) {
  2127.         if (typeof context.getElementsByClassName !== strundefined && documentIsHTML) {
  2128.           return context.getElementsByClassName(className);
  2129.         }
  2130.       }, rbuggyMatches = [], rbuggyQSA = [], (support.qsa = rnative.test(d.querySelectorAll)) && (assert(function(div) {
  2131.         /** @type {string} */
  2132.         div.innerHTML = "<select msallowclip=''><option selected=''></option></select>";
  2133.         if (div.querySelectorAll("[msallowclip^='']").length) {
  2134.           rbuggyQSA.push("[*^$]=" + version + "*(?:''|\"\")");
  2135.         }
  2136.         if (!div.querySelectorAll("[selected]").length) {
  2137.           rbuggyQSA.push("\\[" + version + "*(?:value|" + booleans + ")");
  2138.         }
  2139.         if (!div.querySelectorAll(":checked").length) {
  2140.           rbuggyQSA.push(":checked");
  2141.         }
  2142.       }), assert(function(div) {
  2143.         var input = d.createElement("input");
  2144.         input.setAttribute("type", "hidden");
  2145.         div.appendChild(input).setAttribute("name", "D");
  2146.         if (div.querySelectorAll("[name=d]").length) {
  2147.           rbuggyQSA.push("name" + version + "*[*^$|!~]?=");
  2148.         }
  2149.         if (!div.querySelectorAll(":enabled").length) {
  2150.           rbuggyQSA.push(":enabled", ":disabled");
  2151.         }
  2152.         div.querySelectorAll("*,:x");
  2153.         rbuggyQSA.push(",.*:");
  2154.       })), (support.matchesSelector = rnative.test(matches = docElem.matches || (docElem.webkitMatchesSelector || (docElem.mozMatchesSelector || (docElem.oMatchesSelector || docElem.msMatchesSelector))))) && assert(function(div) {
  2155.         support.disconnectedMatch = matches.call(div, "div");
  2156.         matches.call(div, "[s!='']:x");
  2157.         rbuggyMatches.push("!=", pseudos);
  2158.       }), rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")), rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")), hasCompare = rnative.test(docElem.compareDocumentPosition), contains = hasCompare || rnative.test(docElem.contains) ? function(a, b) {
  2159.         var adown = 9 === a.nodeType ? a.documentElement : a;
  2160.         var bup = b && b.parentNode;
  2161.         return a === bup || !(!bup || (1 !== bup.nodeType || !(adown.contains ? adown.contains(bup) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(bup))));
  2162.       } : function(a, b) {
  2163.         if (b) {
  2164.           for (;b = b.parentNode;) {
  2165.             if (b === a) {
  2166.               return true;
  2167.             }
  2168.           }
  2169.         }
  2170.         return false;
  2171.       }, sortOrder = hasCompare ? function(a, b) {
  2172.         if (a === b) {
  2173.           return rt = true, 0;
  2174.         }
  2175.         /** @type {number} */
  2176.         var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  2177.         return compare ? compare : (compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1, 1 & compare || !support.sortDetached && b.compareDocumentPosition(a) === compare ? a === d || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ? -1 : b === d || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ? 1 : sortInput ? jQuery.call(sortInput, a) - jQuery.call(sortInput, b) : 0 : 4 & compare ? -1 : 1);
  2178.       } : function(a, b) {
  2179.         if (a === b) {
  2180.           return rt = true, 0;
  2181.         }
  2182.         var cur;
  2183.         /** @type {number} */
  2184.         var i = 0;
  2185.         var aup = a.parentNode;
  2186.         var bup = b.parentNode;
  2187.         /** @type {Array} */
  2188.         var ap = [a];
  2189.         /** @type {Array} */
  2190.         var bp = [b];
  2191.         if (!aup || !bup) {
  2192.           return a === d ? -1 : b === d ? 1 : aup ? -1 : bup ? 1 : sortInput ? jQuery.call(sortInput, a) - jQuery.call(sortInput, b) : 0;
  2193.         }
  2194.         if (aup === bup) {
  2195.           return siblingCheck(a, b);
  2196.         }
  2197.         cur = a;
  2198.         for (;cur = cur.parentNode;) {
  2199.           ap.unshift(cur);
  2200.         }
  2201.         cur = b;
  2202.         for (;cur = cur.parentNode;) {
  2203.           bp.unshift(cur);
  2204.         }
  2205.         for (;ap[i] === bp[i];) {
  2206.           i++;
  2207.         }
  2208.         return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
  2209.       }, d) : doc;
  2210.     };
  2211.     /**
  2212.      * @param {string} expr
  2213.      * @param {Array} elements
  2214.      * @return {?}
  2215.      */
  2216.     Sizzle.matches = function(expr, elements) {
  2217.       return Sizzle(expr, null, null, elements);
  2218.     };
  2219.     /**
  2220.      * @param {Object} elem
  2221.      * @param {string} expr
  2222.      * @return {?}
  2223.      */
  2224.     Sizzle.matchesSelector = function(elem, expr) {
  2225.       if ((elem.ownerDocument || elem) !== doc && setDocument(elem), expr = expr.replace(rattributeQuotes, "='$1']"), !(!support.matchesSelector || (!documentIsHTML || (rbuggyMatches && rbuggyMatches.test(expr) || rbuggyQSA && rbuggyQSA.test(expr))))) {
  2226.         try {
  2227.           var ret = matches.call(elem, expr);
  2228.           if (ret || (support.disconnectedMatch || elem.document && 11 !== elem.document.nodeType)) {
  2229.             return ret;
  2230.           }
  2231.         } catch (f) {
  2232.         }
  2233.       }
  2234.       return Sizzle(expr, doc, null, [elem]).length > 0;
  2235.     };
  2236.     /**
  2237.      * @param {Object} context
  2238.      * @param {Object} b
  2239.      * @return {?}
  2240.      */
  2241.     Sizzle.contains = function(context, b) {
  2242.       return(context.ownerDocument || context) !== doc && setDocument(context), contains(context, b);
  2243.     };
  2244.     /**
  2245.      * @param {string} elem
  2246.      * @param {string} name
  2247.      * @return {?}
  2248.      */
  2249.     Sizzle.attr = function(elem, name) {
  2250.       if ((elem.ownerDocument || elem) !== doc) {
  2251.         setDocument(elem);
  2252.       }
  2253.       var fn = Expr.attrHandle[name.toLowerCase()];
  2254.       var val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
  2255.       return void 0 !== val ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2256.     };
  2257.     /**
  2258.      * @param {string} args
  2259.      * @return {?}
  2260.      */
  2261.     Sizzle.error = function(args) {
  2262.       throw new Error("Syntax error, unrecognized expression: " + args);
  2263.     };
  2264.     /**
  2265.      * @param {Array} results
  2266.      * @return {?}
  2267.      */
  2268.     Sizzle.uniqueSort = function(results) {
  2269.       var elem;
  2270.       /** @type {Array} */
  2271.       var duplicates = [];
  2272.       /** @type {number} */
  2273.       var j = 0;
  2274.       /** @type {number} */
  2275.       var i = 0;
  2276.       if (rt = !support.detectDuplicates, sortInput = !support.sortStable && results.slice(0), results.sort(sortOrder), rt) {
  2277.         for (;elem = results[i++];) {
  2278.           if (elem === results[i]) {
  2279.             /** @type {number} */
  2280.             j = duplicates.push(i);
  2281.           }
  2282.         }
  2283.         for (;j--;) {
  2284.           results.splice(duplicates[j], 1);
  2285.         }
  2286.       }
  2287.       return sortInput = null, results;
  2288.     };
  2289.     /** @type {function (HTMLElement): ?} */
  2290.     getText = Sizzle.getText = function(elem) {
  2291.       var node;
  2292.       /** @type {string} */
  2293.       var ret = "";
  2294.       /** @type {number} */
  2295.       var i = 0;
  2296.       var nodeType = elem.nodeType;
  2297.       if (nodeType) {
  2298.         if (1 === nodeType || (9 === nodeType || 11 === nodeType)) {
  2299.           if ("string" == typeof elem.textContent) {
  2300.             return elem.textContent;
  2301.           }
  2302.           elem = elem.firstChild;
  2303.           for (;elem;elem = elem.nextSibling) {
  2304.             ret += getText(elem);
  2305.           }
  2306.         } else {
  2307.           if (3 === nodeType || 4 === nodeType) {
  2308.             return elem.nodeValue;
  2309.           }
  2310.         }
  2311.       } else {
  2312.         for (;node = elem[i++];) {
  2313.           ret += getText(node);
  2314.         }
  2315.       }
  2316.       return ret;
  2317.     };
  2318.     Expr = Sizzle.selectors = {
  2319.       cacheLength : 50,
  2320.       /** @type {function (Function): ?} */
  2321.       createPseudo : markFunction,
  2322.       match : matchExpr,
  2323.       attrHandle : {},
  2324.       find : {},
  2325.       relative : {
  2326.         ">" : {
  2327.           dir : "parentNode",
  2328.           first : true
  2329.         },
  2330.         " " : {
  2331.           dir : "parentNode"
  2332.         },
  2333.         "+" : {
  2334.           dir : "previousSibling",
  2335.           first : true
  2336.         },
  2337.         "~" : {
  2338.           dir : "previousSibling"
  2339.         }
  2340.       },
  2341.       preFilter : {
  2342.         /**
  2343.          * @param {Array} match
  2344.          * @return {?}
  2345.          */
  2346.         ATTR : function(match) {
  2347.           return match[1] = match[1].replace(runescape, funescape), match[3] = (match[3] || (match[4] || (match[5] || ""))).replace(runescape, funescape), "~=" === match[2] && (match[3] = " " + match[3] + " "), match.slice(0, 4);
  2348.         },
  2349.         /**
  2350.          * @param {Array} match
  2351.          * @return {?}
  2352.          */
  2353.         CHILD : function(match) {
  2354.           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;
  2355.         },
  2356.         /**
  2357.          * @param {Array} match
  2358.          * @return {?}
  2359.          */
  2360.         PSEUDO : function(match) {
  2361.           var excess;
  2362.           var unquoted = !match[6] && match[2];
  2363.           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));
  2364.         }
  2365.       },
  2366.       filter : {
  2367.         /**
  2368.          * @param {string} nodeNameSelector
  2369.          * @return {?}
  2370.          */
  2371.         TAG : function(nodeNameSelector) {
  2372.           var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
  2373.           return "*" === nodeNameSelector ? function() {
  2374.             return true;
  2375.           } : function(elem) {
  2376.             return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  2377.           };
  2378.         },
  2379.         /**
  2380.          * @param {string} className
  2381.          * @return {?}
  2382.          */
  2383.         CLASS : function(className) {
  2384.           var pattern = classCache[className + " "];
  2385.           return pattern || (pattern = new RegExp("(^|" + version + ")" + className + "(" + version + "|$)")) && classCache(className, function(elem) {
  2386.             return pattern.test("string" == typeof elem.className && elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || ""));
  2387.           });
  2388.         },
  2389.         /**
  2390.          * @param {string} name
  2391.          * @param {string} not
  2392.          * @param {string} b
  2393.          * @return {?}
  2394.          */
  2395.         ATTR : function(name, not, b) {
  2396.           return function(elem) {
  2397.             var a = Sizzle.attr(elem, name);
  2398.             return null == a ? "!=" === not : not ? (a += "", "=" === not ? a === b : "!=" === not ? a !== b : "^=" === not ? b && 0 === a.indexOf(b) : "*=" === not ? b && a.indexOf(b) > -1 : "$=" === not ? b && a.slice(-b.length) === b : "~=" === not ? (" " + a + " ").indexOf(b) > -1 : "|=" === not ? a === b || a.slice(0, b.length + 1) === b + "-" : false) : true;
  2399.           };
  2400.         },
  2401.         /**
  2402.          * @param {string} type
  2403.          * @param {string} argument
  2404.          * @param {?} dataAndEvents
  2405.          * @param {number} first
  2406.          * @param {number} last
  2407.          * @return {?}
  2408.          */
  2409.         CHILD : function(type, argument, dataAndEvents, first, last) {
  2410.           /** @type {boolean} */
  2411.           var simple = "nth" !== type.slice(0, 3);
  2412.           /** @type {boolean} */
  2413.           var forward = "last" !== type.slice(-4);
  2414.           /** @type {boolean} */
  2415.           var value = "of-type" === argument;
  2416.           return 1 === first && 0 === last ? function(contestant) {
  2417.             return!!contestant.parentNode;
  2418.           } : function(elem, dataAndEvents, computed) {
  2419.             var cache;
  2420.             var outerCache;
  2421.             var node;
  2422.             var diff;
  2423.             var nodeIndex;
  2424.             var eventPath;
  2425.             /** @type {string} */
  2426.             var which = simple !== forward ? "nextSibling" : "previousSibling";
  2427.             var parent = elem.parentNode;
  2428.             var attrNames = value && elem.nodeName.toLowerCase();
  2429.             /** @type {boolean} */
  2430.             var useCache = !computed && !value;
  2431.             if (parent) {
  2432.               if (simple) {
  2433.                 for (;which;) {
  2434.                   /** @type {Object} */
  2435.                   node = elem;
  2436.                   for (;node = node[which];) {
  2437.                     if (value ? node.nodeName.toLowerCase() === attrNames : 1 === node.nodeType) {
  2438.                       return false;
  2439.                     }
  2440.                   }
  2441.                   /** @type {(boolean|string)} */
  2442.                   eventPath = which = "only" === type && (!eventPath && "nextSibling");
  2443.                 }
  2444.                 return true;
  2445.               }
  2446.               if (eventPath = [forward ? parent.firstChild : parent.lastChild], forward && useCache) {
  2447.                 outerCache = parent[expando] || (parent[expando] = {});
  2448.                 cache = outerCache[type] || [];
  2449.                 nodeIndex = cache[0] === dirruns && cache[1];
  2450.                 diff = cache[0] === dirruns && cache[2];
  2451.                 node = nodeIndex && parent.childNodes[nodeIndex];
  2452.                 for (;node = ++nodeIndex && (node && node[which]) || ((diff = nodeIndex = 0) || eventPath.pop());) {
  2453.                   if (1 === node.nodeType && (++diff && node === elem)) {
  2454.                     /** @type {Array} */
  2455.                     outerCache[type] = [dirruns, nodeIndex, diff];
  2456.                     break;
  2457.                   }
  2458.                 }
  2459.               } else {
  2460.                 if (useCache && ((cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns)) {
  2461.                   diff = cache[1];
  2462.                 } else {
  2463.                   for (;node = ++nodeIndex && (node && node[which]) || ((diff = nodeIndex = 0) || eventPath.pop());) {
  2464.                     if ((value ? node.nodeName.toLowerCase() === attrNames : 1 === node.nodeType) && (++diff && (useCache && ((node[expando] || (node[expando] = {}))[type] = [dirruns, diff]), node === elem))) {
  2465.                       break;
  2466.                     }
  2467.                   }
  2468.                 }
  2469.               }
  2470.               return diff -= last, diff === first || diff % first == 0 && diff / first >= 0;
  2471.             }
  2472.           };
  2473.         },
  2474.         /**
  2475.          * @param {string} pseudo
  2476.          * @param {?} context
  2477.          * @return {?}
  2478.          */
  2479.         PSEUDO : function(pseudo, context) {
  2480.           var args;
  2481.           var fn = Expr.pseudos[pseudo] || (Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo));
  2482.           return fn[expando] ? fn(context) : fn.length > 1 ? (args = [pseudo, pseudo, "", context], Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(arg, object) {
  2483.             var index;
  2484.             var elements = fn(arg, context);
  2485.             var i = elements.length;
  2486.             for (;i--;) {
  2487.               /** @type {number} */
  2488.               index = jQuery.call(arg, elements[i]);
  2489.               /** @type {boolean} */
  2490.               arg[index] = !(object[index] = elements[i]);
  2491.             }
  2492.           }) : function(err) {
  2493.             return fn(err, 0, args);
  2494.           }) : fn;
  2495.         }
  2496.       },
  2497.       pseudos : {
  2498.         not : markFunction(function(selector) {
  2499.           /** @type {Array} */
  2500.           var elem = [];
  2501.           /** @type {Array} */
  2502.           var memory = [];
  2503.           var matcher = compile(selector.replace(rtrim, "$1"));
  2504.           return matcher[expando] ? markFunction(function(seed, qs, dataAndEvents, xml) {
  2505.             var val;
  2506.             var unmatched = matcher(seed, null, xml, []);
  2507.             var i = seed.length;
  2508.             for (;i--;) {
  2509.               if (val = unmatched[i]) {
  2510.                 /** @type {boolean} */
  2511.                 seed[i] = !(qs[i] = val);
  2512.               }
  2513.             }
  2514.           }) : function(value, dataAndEvents, xml) {
  2515.             return elem[0] = value, matcher(elem, null, xml, memory), !memory.pop();
  2516.           };
  2517.         }),
  2518.         has : markFunction(function(selector) {
  2519.           return function(elem) {
  2520.             return Sizzle(selector, elem).length > 0;
  2521.           };
  2522.         }),
  2523.         contains : markFunction(function(other) {
  2524.           return function(elem) {
  2525.             return(elem.textContent || (elem.innerText || getText(elem))).indexOf(other) > -1;
  2526.           };
  2527.         }),
  2528.         lang : markFunction(function(lang) {
  2529.           return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(runescape, funescape).toLowerCase(), function(elem) {
  2530.             var elemLang;
  2531.             do {
  2532.               if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
  2533.                 return elemLang = elemLang.toLowerCase(), elemLang === lang || 0 === elemLang.indexOf(lang + "-");
  2534.               }
  2535.             } while ((elem = elem.parentNode) && 1 === elem.nodeType);
  2536.             return false;
  2537.           };
  2538.         }),
  2539.         /**
  2540.          * @param {string} args
  2541.          * @return {?}
  2542.          */
  2543.         target : function(args) {
  2544.           var models = win.location && win.location.hash;
  2545.           return models && models.slice(1) === args.id;
  2546.         },
  2547.         /**
  2548.          * @param {undefined} elem
  2549.          * @return {?}
  2550.          */
  2551.         root : function(elem) {
  2552.           return elem === docElem;
  2553.         },
  2554.         /**
  2555.          * @param {string} args
  2556.          * @return {?}
  2557.          */
  2558.         focus : function(args) {
  2559.           return args === doc.activeElement && ((!doc.hasFocus || doc.hasFocus()) && !!(args.type || (args.href || ~args.tabIndex)));
  2560.         },
  2561.         /**
  2562.          * @param {EventTarget} a
  2563.          * @return {?}
  2564.          */
  2565.         enabled : function(a) {
  2566.           return a.disabled === false;
  2567.         },
  2568.         /**
  2569.          * @param {EventTarget} elem
  2570.          * @return {?}
  2571.          */
  2572.         disabled : function(elem) {
  2573.           return elem.disabled === true;
  2574.         },
  2575.         /**
  2576.          * @param {Node} node
  2577.          * @return {?}
  2578.          */
  2579.         checked : function(node) {
  2580.           var b = node.nodeName.toLowerCase();
  2581.           return "input" === b && !!node.checked || "option" === b && !!node.selected;
  2582.         },
  2583.         /**
  2584.          * @param {Node} elem
  2585.          * @return {?}
  2586.          */
  2587.         selected : function(elem) {
  2588.           return elem.parentNode && elem.parentNode.selectedIndex, elem.selected === true;
  2589.         },
  2590.         /**
  2591.          * @param {Object} elem
  2592.          * @return {?}
  2593.          */
  2594.         empty : function(elem) {
  2595.           elem = elem.firstChild;
  2596.           for (;elem;elem = elem.nextSibling) {
  2597.             if (elem.nodeType < 6) {
  2598.               return false;
  2599.             }
  2600.           }
  2601.           return true;
  2602.         },
  2603.         /**
  2604.          * @param {Object} elem
  2605.          * @return {?}
  2606.          */
  2607.         parent : function(elem) {
  2608.           return!Expr.pseudos.empty(elem);
  2609.         },
  2610.         /**
  2611.          * @param {Node} elem
  2612.          * @return {?}
  2613.          */
  2614.         header : function(elem) {
  2615.           return rheader.test(elem.nodeName);
  2616.         },
  2617.         /**
  2618.          * @param {Node} elem
  2619.          * @return {?}
  2620.          */
  2621.         input : function(elem) {
  2622.           return rinputs.test(elem.nodeName);
  2623.         },
  2624.         /**
  2625.          * @param {Node} elem
  2626.          * @return {?}
  2627.          */
  2628.         button : function(elem) {
  2629.           var b = elem.nodeName.toLowerCase();
  2630.           return "input" === b && "button" === elem.type || "button" === b;
  2631.         },
  2632.         /**
  2633.          * @param {Node} elem
  2634.          * @return {?}
  2635.          */
  2636.         text : function(elem) {
  2637.           var evt;
  2638.           return "input" === elem.nodeName.toLowerCase() && ("text" === elem.type && (null == (evt = elem.getAttribute("type")) || "text" === evt.toLowerCase()));
  2639.         },
  2640.         first : createPositionalPseudo(function() {
  2641.           return[0];
  2642.         }),
  2643.         last : createPositionalPseudo(function(dataAndEvents, deepDataAndEvents) {
  2644.           return[deepDataAndEvents - 1];
  2645.         }),
  2646.         eq : createPositionalPseudo(function(dataAndEvents, length, index) {
  2647.           return[0 > index ? index + length : index];
  2648.         }),
  2649.         even : createPositionalPseudo(function(assigns, dataAndEvents) {
  2650.           /** @type {number} */
  2651.           var vvar = 0;
  2652.           for (;dataAndEvents > vvar;vvar += 2) {
  2653.             assigns.push(vvar);
  2654.           }
  2655.           return assigns;
  2656.         }),
  2657.         odd : createPositionalPseudo(function(assigns, dataAndEvents) {
  2658.           /** @type {number} */
  2659.           var vvar = 1;
  2660.           for (;dataAndEvents > vvar;vvar += 2) {
  2661.             assigns.push(vvar);
  2662.           }
  2663.           return assigns;
  2664.         }),
  2665.         lt : createPositionalPseudo(function(assigns, length, index) {
  2666.           var vvar = 0 > index ? index + length : index;
  2667.           for (;--vvar >= 0;) {
  2668.             assigns.push(vvar);
  2669.           }
  2670.           return assigns;
  2671.         }),
  2672.         gt : createPositionalPseudo(function(assigns, length, index) {
  2673.           var vvar = 0 > index ? index + length : index;
  2674.           for (;++vvar < length;) {
  2675.             assigns.push(vvar);
  2676.           }
  2677.           return assigns;
  2678.         })
  2679.       }
  2680.     };
  2681.     Expr.pseudos.nth = Expr.pseudos.eq;
  2682.     for (i in{
  2683.       radio : true,
  2684.       checkbox : true,
  2685.       file : true,
  2686.       password : true,
  2687.       image : true
  2688.     }) {
  2689.       Expr.pseudos[i] = createInputPseudo(i);
  2690.     }
  2691.     for (i in{
  2692.       submit : true,
  2693.       reset : true
  2694.     }) {
  2695.       Expr.pseudos[i] = createButtonPseudo(i);
  2696.     }
  2697.     return setFilters.prototype = Expr.filters = Expr.pseudos, Expr.setFilters = new setFilters, tokenize = Sizzle.tokenize = function(ast, parseOnly) {
  2698.       var matched;
  2699.       var match;
  2700.       var tokens;
  2701.       var type;
  2702.       var soFar;
  2703.       var groups;
  2704.       var preFilters;
  2705.       var cached = tokenCache[ast + " "];
  2706.       if (cached) {
  2707.         return parseOnly ? 0 : cached.slice(0);
  2708.       }
  2709.       /** @type {string} */
  2710.       soFar = ast;
  2711.       /** @type {Array} */
  2712.       groups = [];
  2713.       preFilters = Expr.preFilter;
  2714.       for (;soFar;) {
  2715.         if (!matched || (match = rcomma.exec(soFar))) {
  2716.           if (match) {
  2717.             soFar = soFar.slice(match[0].length) || soFar;
  2718.           }
  2719.           groups.push(tokens = []);
  2720.         }
  2721.         /** @type {boolean} */
  2722.         matched = false;
  2723.         if (match = rcombinators.exec(soFar)) {
  2724.           /** @type {string} */
  2725.           matched = match.shift();
  2726.           tokens.push({
  2727.             value : matched,
  2728.             type : match[0].replace(rtrim, " ")
  2729.           });
  2730.           soFar = soFar.slice(matched.length);
  2731.         }
  2732.         for (type in Expr.filter) {
  2733.           if (match = matchExpr[type].exec(soFar)) {
  2734.             if (!preFilters[type] || (match = preFilters[type](match))) {
  2735.               matched = match.shift();
  2736.               tokens.push({
  2737.                 value : matched,
  2738.                 type : type,
  2739.                 matches : match
  2740.               });
  2741.               soFar = soFar.slice(matched.length);
  2742.             }
  2743.           }
  2744.         }
  2745.         if (!matched) {
  2746.           break;
  2747.         }
  2748.       }
  2749.       return parseOnly ? soFar.length : soFar ? Sizzle.error(ast) : tokenCache(ast, groups).slice(0);
  2750.     }, compile = Sizzle.compile = function(selector, group) {
  2751.       var i;
  2752.       /** @type {Array} */
  2753.       var setMatchers = [];
  2754.       /** @type {Array} */
  2755.       var elementMatchers = [];
  2756.       var cached = compilerCache[selector + " "];
  2757.       if (!cached) {
  2758.         if (!group) {
  2759.           group = tokenize(selector);
  2760.         }
  2761.         i = group.length;
  2762.         for (;i--;) {
  2763.           cached = matcherFromTokens(group[i]);
  2764.           if (cached[expando]) {
  2765.             setMatchers.push(cached);
  2766.           } else {
  2767.             elementMatchers.push(cached);
  2768.           }
  2769.         }
  2770.         cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
  2771.         /** @type {string} */
  2772.         cached.selector = selector;
  2773.       }
  2774.       return cached;
  2775.     }, select = Sizzle.select = function(selector, context, results, ast) {
  2776.       var i;
  2777.       var tokens;
  2778.       var token;
  2779.       var type;
  2780.       var find;
  2781.       /** @type {(Function|boolean)} */
  2782.       var compiled = "function" == typeof selector && selector;
  2783.       var match = !ast && tokenize(selector = compiled.selector || selector);
  2784.       if (results = results || [], 1 === match.length) {
  2785.         if (tokens = match[0] = match[0].slice(0), tokens.length > 2 && ("ID" === (token = tokens[0]).type && (support.getById && (9 === context.nodeType && (documentIsHTML && Expr.relative[tokens[1].type]))))) {
  2786.           if (context = (Expr.find.ID(token.matches[0].replace(runescape, funescape), context) || [])[0], !context) {
  2787.             return results;
  2788.           }
  2789.           if (compiled) {
  2790.             context = context.parentNode;
  2791.           }
  2792.           selector = selector.slice(tokens.shift().value.length);
  2793.         }
  2794.         i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
  2795.         for (;i--;) {
  2796.           if (token = tokens[i], Expr.relative[type = token.type]) {
  2797.             break;
  2798.           }
  2799.           if ((find = Expr.find[type]) && (ast = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context))) {
  2800.             if (tokens.splice(i, 1), selector = ast.length && toSelector(tokens), !selector) {
  2801.               return push.apply(results, ast), results;
  2802.             }
  2803.             break;
  2804.           }
  2805.         }
  2806.       }
  2807.       return(compiled || compile(selector, match))(ast, context, !documentIsHTML, results, rsibling.test(selector) && testContext(context.parentNode) || context), results;
  2808.     }, support.sortStable = expando.split("").sort(sortOrder).join("") === expando, support.detectDuplicates = !!rt, setDocument(), support.sortDetached = assert(function(div1) {
  2809.       return 1 & div1.compareDocumentPosition(doc.createElement("div"));
  2810.     }), assert(function(div) {
  2811.       return div.innerHTML = "<a href='#'></a>", "#" === div.firstChild.getAttribute("href");
  2812.     }) || addHandle("type|href|height|width", function(elem, name, dataAndEvents) {
  2813.       if (!dataAndEvents) {
  2814.         return elem.getAttribute(name, "type" === name.toLowerCase() ? 1 : 2);
  2815.       }
  2816.     }), support.attributes && assert(function(div) {
  2817.       return div.innerHTML = "<input/>", div.firstChild.setAttribute("value", ""), "" === div.firstChild.getAttribute("value");
  2818.     }) || addHandle("value", function(target, deepDataAndEvents, dataAndEvents) {
  2819.       if (!dataAndEvents && "input" === target.nodeName.toLowerCase()) {
  2820.         return target.defaultValue;
  2821.       }
  2822.     }), assert(function(div) {
  2823.       return null == div.getAttribute("disabled");
  2824.     }) || addHandle(booleans, function(elem, name, dataAndEvents) {
  2825.       var val;
  2826.       if (!dataAndEvents) {
  2827.         return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2828.       }
  2829.     }), Sizzle;
  2830.   }(win);
  2831.   jQuery.find = Sizzle;
  2832.   jQuery.expr = Sizzle.selectors;
  2833.   jQuery.expr[":"] = jQuery.expr.pseudos;
  2834.   jQuery.unique = Sizzle.uniqueSort;
  2835.   jQuery.text = Sizzle.getText;
  2836.   jQuery.isXMLDoc = Sizzle.isXML;
  2837.   jQuery.contains = Sizzle.contains;
  2838.   var rneedsContext = jQuery.expr.match.needsContext;
  2839.   /** @type {RegExp} */
  2840.   var rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/;
  2841.   /** @type {RegExp} */
  2842.   var isSimple = /^.[^:#\[\.,]*$/;
  2843.   /**
  2844.    * @param {string} expr
  2845.    * @param {string} elems
  2846.    * @param {boolean} not
  2847.    * @return {?}
  2848.    */
  2849.   jQuery.filter = function(expr, elems, not) {
  2850.     var elem = elems[0];
  2851.     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(dest) {
  2852.       return 1 === dest.nodeType;
  2853.     }));
  2854.   };
  2855.   jQuery.fn.extend({
  2856.     /**
  2857.      * @param {string} selector
  2858.      * @return {?}
  2859.      */
  2860.     find : function(selector) {
  2861.       var i;
  2862.       var len = this.length;
  2863.       /** @type {Array} */
  2864.       var ret = [];
  2865.       var self = this;
  2866.       if ("string" != typeof selector) {
  2867.         return this.pushStack(jQuery(selector).filter(function() {
  2868.           /** @type {number} */
  2869.           i = 0;
  2870.           for (;len > i;i++) {
  2871.             if (jQuery.contains(self[i], this)) {
  2872.               return true;
  2873.             }
  2874.           }
  2875.         }));
  2876.       }
  2877.       /** @type {number} */
  2878.       i = 0;
  2879.       for (;len > i;i++) {
  2880.         jQuery.find(selector, self[i], ret);
  2881.       }
  2882.       return ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret), ret.selector = this.selector ? this.selector + " " + selector : selector, ret;
  2883.     },
  2884.     /**
  2885.      * @param {Object} selector
  2886.      * @return {?}
  2887.      */
  2888.     filter : function(selector) {
  2889.       return this.pushStack(winnow(this, selector || [], false));
  2890.     },
  2891.     /**
  2892.      * @param {Array} selector
  2893.      * @return {?}
  2894.      */
  2895.     not : function(selector) {
  2896.       return this.pushStack(winnow(this, selector || [], true));
  2897.     },
  2898.     /**
  2899.      * @param {string} selector
  2900.      * @return {?}
  2901.      */
  2902.     is : function(selector) {
  2903.       return!!winnow(this, "string" == typeof selector && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
  2904.     }
  2905.   });
  2906.   /** @type {RegExp} */
  2907.   rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/;
  2908.   /** @type {function (string, Object): ?} */
  2909.   init = jQuery.fn.init = function(selector, context) {
  2910.     var match;
  2911.     var a;
  2912.     if (!selector) {
  2913.       return this;
  2914.     }
  2915.     if ("string" == typeof selector) {
  2916.       if (match = "<" === selector[0] && (">" === selector[selector.length - 1] && selector.length >= 3) ? [null, selector, null] : rquickExpr.exec(selector), !match || !match[1] && context) {
  2917.         return!context || context.jquery ? (context || rootjQuery).find(selector) : this.constructor(context).find(selector);
  2918.       }
  2919.       if (match[1]) {
  2920.         if (context = context instanceof jQuery ? context[0] : context, jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : doc, true)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
  2921.           for (match in context) {
  2922.             if (jQuery.isFunction(this[match])) {
  2923.               this[match](context[match]);
  2924.             } else {
  2925.               this.attr(match, context[match]);
  2926.             }
  2927.           }
  2928.         }
  2929.         return this;
  2930.       }
  2931.       return a = doc.getElementById(match[2]), a && (a.parentNode && (this.length = 1, this[0] = a)), this.context = doc, this.selector = selector, this;
  2932.     }
  2933.     return selector.nodeType ? (this.context = this[0] = selector, this.length = 1, this) : jQuery.isFunction(selector) ? "undefined" != typeof rootjQuery.ready ? rootjQuery.ready(selector) : selector(jQuery) : (void 0 !== selector.selector && (this.selector = selector.selector, this.context = selector.context), jQuery.makeArray(selector, this));
  2934.   };
  2935.   init.prototype = jQuery.fn;
  2936.   rootjQuery = jQuery(doc);
  2937.   /** @type {RegExp} */
  2938.   rparentsprev = /^(?:parents|prev(?:Until|All))/;
  2939.   data = {
  2940.     children : true,
  2941.     contents : true,
  2942.     next : true,
  2943.     prev : true
  2944.   };
  2945.   jQuery.extend({
  2946.     /**
  2947.      * @param {Object} elem
  2948.      * @param {string} dir
  2949.      * @param {string} until
  2950.      * @return {?}
  2951.      */
  2952.     dir : function(elem, dir, until) {
  2953.       /** @type {Array} */
  2954.       var matched = [];
  2955.       /** @type {boolean} */
  2956.       var truncate = void 0 !== until;
  2957.       for (;(elem = elem[dir]) && 9 !== elem.nodeType;) {
  2958.         if (1 === elem.nodeType) {
  2959.           if (truncate && jQuery(elem).is(until)) {
  2960.             break;
  2961.           }
  2962.           matched.push(elem);
  2963.         }
  2964.       }
  2965.       return matched;
  2966.     },
  2967.     /**
  2968.      * @param {Object} n
  2969.      * @param {Object} elem
  2970.      * @return {?}
  2971.      */
  2972.     sibling : function(n, elem) {
  2973.       /** @type {Array} */
  2974.       var r = [];
  2975.       for (;n;n = n.nextSibling) {
  2976.         if (1 === n.nodeType) {
  2977.           if (n !== elem) {
  2978.             r.push(n);
  2979.           }
  2980.         }
  2981.       }
  2982.       return r;
  2983.     }
  2984.   });
  2985.   jQuery.fn.extend({
  2986.     /**
  2987.      * @param {string} target
  2988.      * @return {?}
  2989.      */
  2990.     has : function(target) {
  2991.       var targets = jQuery(target, this);
  2992.       var l = targets.length;
  2993.       return this.filter(function() {
  2994.         /** @type {number} */
  2995.         var i = 0;
  2996.         for (;l > i;i++) {
  2997.           if (jQuery.contains(this, targets[i])) {
  2998.             return true;
  2999.           }
  3000.         }
  3001.       });
  3002.     },
  3003.     /**
  3004.      * @param {string} selectors
  3005.      * @param {number} context
  3006.      * @return {?}
  3007.      */
  3008.     closest : function(selectors, context) {
  3009.       var cur;
  3010.       /** @type {number} */
  3011.       var i = 0;
  3012.       var l = this.length;
  3013.       /** @type {Array} */
  3014.       var matched = [];
  3015.       var pos = rneedsContext.test(selectors) || "string" != typeof selectors ? jQuery(selectors, context || this.context) : 0;
  3016.       for (;l > i;i++) {
  3017.         cur = this[i];
  3018.         for (;cur && cur !== context;cur = cur.parentNode) {
  3019.           if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : 1 === cur.nodeType && jQuery.find.matchesSelector(cur, selectors))) {
  3020.             matched.push(cur);
  3021.             break;
  3022.           }
  3023.         }
  3024.       }
  3025.       return this.pushStack(matched.length > 1 ? jQuery.unique(matched) : matched);
  3026.     },
  3027.     /**
  3028.      * @param {boolean} elem
  3029.      * @return {?}
  3030.      */
  3031.     index : function(elem) {
  3032.       return elem ? "string" == typeof elem ? core_indexOf.call(jQuery(elem), this[0]) : core_indexOf.call(this, elem.jquery ? elem[0] : elem) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
  3033.     },
  3034.     /**
  3035.      * @param {number} selector
  3036.      * @param {?} context
  3037.      * @return {?}
  3038.      */
  3039.     add : function(selector, context) {
  3040.       return this.pushStack(jQuery.unique(jQuery.merge(this.get(), jQuery(selector, context))));
  3041.     },
  3042.     /**
  3043.      * @param {Object} selector
  3044.      * @return {?}
  3045.      */
  3046.     addBack : function(selector) {
  3047.       return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
  3048.     }
  3049.   });
  3050.   jQuery.each({
  3051.     /**
  3052.      * @param {Node} elem
  3053.      * @return {?}
  3054.      */
  3055.     parent : function(elem) {
  3056.       var parent = elem.parentNode;
  3057.       return parent && 11 !== parent.nodeType ? parent : null;
  3058.     },
  3059.     /**
  3060.      * @param {string} elem
  3061.      * @return {?}
  3062.      */
  3063.     parents : function(elem) {
  3064.       return jQuery.dir(elem, "parentNode");
  3065.     },
  3066.     /**
  3067.      * @param {Object} elem
  3068.      * @param {?} i
  3069.      * @param {string} until
  3070.      * @return {?}
  3071.      */
  3072.     parentsUntil : function(elem, i, until) {
  3073.       return jQuery.dir(elem, "parentNode", until);
  3074.     },
  3075.     /**
  3076.      * @param {Object} elem
  3077.      * @return {?}
  3078.      */
  3079.     next : function(elem) {
  3080.       return sibling(elem, "nextSibling");
  3081.     },
  3082.     /**
  3083.      * @param {Object} elem
  3084.      * @return {?}
  3085.      */
  3086.     prev : function(elem) {
  3087.       return sibling(elem, "previousSibling");
  3088.     },
  3089.     /**
  3090.      * @param {Object} elem
  3091.      * @return {?}
  3092.      */
  3093.     nextAll : function(elem) {
  3094.       return jQuery.dir(elem, "nextSibling");
  3095.     },
  3096.     /**
  3097.      * @param {Object} elem
  3098.      * @return {?}
  3099.      */
  3100.     prevAll : function(elem) {
  3101.       return jQuery.dir(elem, "previousSibling");
  3102.     },
  3103.     /**
  3104.      * @param {Object} elem
  3105.      * @param {?} i
  3106.      * @param {string} until
  3107.      * @return {?}
  3108.      */
  3109.     nextUntil : function(elem, i, until) {
  3110.       return jQuery.dir(elem, "nextSibling", until);
  3111.     },
  3112.     /**
  3113.      * @param {Object} elem
  3114.      * @param {?} i
  3115.      * @param {string} until
  3116.      * @return {?}
  3117.      */
  3118.     prevUntil : function(elem, i, until) {
  3119.       return jQuery.dir(elem, "previousSibling", until);
  3120.     },
  3121.     /**
  3122.      * @param {HTMLElement} elem
  3123.      * @return {?}
  3124.      */
  3125.     siblings : function(elem) {
  3126.       return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
  3127.     },
  3128.     /**
  3129.      * @param {Element} elem
  3130.      * @return {?}
  3131.      */
  3132.     children : function(elem) {
  3133.       return jQuery.sibling(elem.firstChild);
  3134.     },
  3135.     /**
  3136.      * @param {Element} elem
  3137.      * @return {?}
  3138.      */
  3139.     contents : function(elem) {
  3140.       return elem.contentDocument || jQuery.merge([], elem.childNodes);
  3141.     }
  3142.   }, function(name, fn) {
  3143.     /**
  3144.      * @param {boolean} until
  3145.      * @param {boolean} selector
  3146.      * @return {?}
  3147.      */
  3148.     jQuery.fn[name] = function(until, selector) {
  3149.       var matched = jQuery.map(this, fn, until);
  3150.       return "Until" !== name.slice(-5) && (selector = until), selector && ("string" == typeof selector && (matched = jQuery.filter(selector, matched))), this.length > 1 && (data[name] || jQuery.unique(matched), rparentsprev.test(name) && matched.reverse()), this.pushStack(matched);
  3151.     };
  3152.   });
  3153.   /** @type {RegExp} */
  3154.   core_rnotwhite = /\S+/g;
  3155.   optionsCache = {};
  3156.   /**
  3157.    * @param {Object} options
  3158.    * @return {?}
  3159.    */
  3160.   jQuery.Callbacks = function(options) {
  3161.     options = "string" == typeof options ? optionsCache[options] || createOptions(options) : jQuery.extend({}, options);
  3162.     var memory;
  3163.     var h;
  3164.     var r;
  3165.     var firingStart;
  3166.     var i;
  3167.     var firingIndex;
  3168.     /** @type {Array} */
  3169.     var list = [];
  3170.     /** @type {(Array|boolean)} */
  3171.     var stack = !options.once && [];
  3172.     /**
  3173.      * @param {Array} data
  3174.      * @return {undefined}
  3175.      */
  3176.     var fire = function(data) {
  3177.       memory = options.memory && data;
  3178.       /** @type {boolean} */
  3179.       h = true;
  3180.       firingIndex = firingStart || 0;
  3181.       /** @type {number} */
  3182.       firingStart = 0;
  3183.       i = list.length;
  3184.       /** @type {boolean} */
  3185.       r = true;
  3186.       for (;list && i > firingIndex;firingIndex++) {
  3187.         if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
  3188.           /** @type {boolean} */
  3189.           memory = false;
  3190.           break;
  3191.         }
  3192.       }
  3193.       /** @type {boolean} */
  3194.       r = false;
  3195.       if (list) {
  3196.         if (stack) {
  3197.           if (stack.length) {
  3198.             fire(stack.shift());
  3199.           }
  3200.         } else {
  3201.           if (memory) {
  3202.             /** @type {Array} */
  3203.             list = [];
  3204.           } else {
  3205.             self.disable();
  3206.           }
  3207.         }
  3208.       }
  3209.     };
  3210.     var self = {
  3211.       /**
  3212.        * @return {?}
  3213.        */
  3214.       add : function() {
  3215.         if (list) {
  3216.           var start = list.length;
  3217.           !function add(args) {
  3218.             jQuery.each(args, function(dataAndEvents, arg) {
  3219.               var type = jQuery.type(arg);
  3220.               if ("function" === type) {
  3221.                 if (!(options.unique && self.has(arg))) {
  3222.                   list.push(arg);
  3223.                 }
  3224.               } else {
  3225.                 if (arg) {
  3226.                   if (arg.length) {
  3227.                     if ("string" !== type) {
  3228.                       add(arg);
  3229.                     }
  3230.                   }
  3231.                 }
  3232.               }
  3233.             });
  3234.           }(arguments);
  3235.           if (r) {
  3236.             i = list.length;
  3237.           } else {
  3238.             if (memory) {
  3239.               firingStart = start;
  3240.               fire(memory);
  3241.             }
  3242.           }
  3243.         }
  3244.         return this;
  3245.       },
  3246.       /**
  3247.        * @return {?}
  3248.        */
  3249.       remove : function() {
  3250.         return list && jQuery.each(arguments, function(dataAndEvents, arg) {
  3251.           var index;
  3252.           for (;(index = jQuery.inArray(arg, list, index)) > -1;) {
  3253.             list.splice(index, 1);
  3254.             if (r) {
  3255.               if (i >= index) {
  3256.                 i--;
  3257.               }
  3258.               if (firingIndex >= index) {
  3259.                 firingIndex--;
  3260.               }
  3261.             }
  3262.           }
  3263.         }), this;
  3264.       },
  3265.       /**
  3266.        * @param {string} fn
  3267.        * @return {?}
  3268.        */
  3269.       has : function(fn) {
  3270.         return fn ? jQuery.inArray(fn, list) > -1 : !(!list || !list.length);
  3271.       },
  3272.       /**
  3273.        * @return {?}
  3274.        */
  3275.       empty : function() {
  3276.         return list = [], i = 0, this;
  3277.       },
  3278.       /**
  3279.        * @return {?}
  3280.        */
  3281.       disable : function() {
  3282.         return list = stack = memory = void 0, this;
  3283.       },
  3284.       /**
  3285.        * @return {?}
  3286.        */
  3287.       disabled : function() {
  3288.         return!list;
  3289.       },
  3290.       /**
  3291.        * @return {?}
  3292.        */
  3293.       lock : function() {
  3294.         return stack = void 0, memory || self.disable(), this;
  3295.       },
  3296.       /**
  3297.        * @return {?}
  3298.        */
  3299.       locked : function() {
  3300.         return!stack;
  3301.       },
  3302.       /**
  3303.        * @param {?} context
  3304.        * @param {Array} args
  3305.        * @return {?}
  3306.        */
  3307.       fireWith : function(context, args) {
  3308.         return!list || (h && !stack || (args = args || [], args = [context, args.slice ? args.slice() : args], r ? stack.push(args) : fire(args))), this;
  3309.       },
  3310.       /**
  3311.        * @return {?}
  3312.        */
  3313.       fire : function() {
  3314.         return self.fireWith(this, arguments), this;
  3315.       },
  3316.       /**
  3317.        * @return {?}
  3318.        */
  3319.       fired : function() {
  3320.         return!!h;
  3321.       }
  3322.     };
  3323.     return self;
  3324.   };
  3325.   jQuery.extend({
  3326.     /**
  3327.      * @param {Function} func
  3328.      * @return {?}
  3329.      */
  3330.     Deferred : function(func) {
  3331.       /** @type {Array} */
  3332.       var which = [["resolve", "done", jQuery.Callbacks("once memory"), "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), "rejected"], ["notify", "progress", jQuery.Callbacks("memory")]];
  3333.       /** @type {string} */
  3334.       var state = "pending";
  3335.       var promise = {
  3336.         /**
  3337.          * @return {?}
  3338.          */
  3339.         state : function() {
  3340.           return state;
  3341.         },
  3342.         /**
  3343.          * @return {?}
  3344.          */
  3345.         always : function() {
  3346.           return deferred.done(arguments).fail(arguments), this;
  3347.         },
  3348.         /**
  3349.          * @return {?}
  3350.          */
  3351.         then : function() {
  3352.           /** @type {Arguments} */
  3353.           var fns = arguments;
  3354.           return jQuery.Deferred(function(newDefer) {
  3355.             jQuery.each(which, function(i, tuple) {
  3356.               var fn = jQuery.isFunction(fns[i]) && fns[i];
  3357.               deferred[tuple[1]](function() {
  3358.                 var returned = fn && fn.apply(this, arguments);
  3359.                 if (returned && jQuery.isFunction(returned.promise)) {
  3360.                   returned.promise().done(newDefer.resolve).fail(newDefer.reject).progress(newDefer.notify);
  3361.                 } else {
  3362.                   newDefer[tuple[0] + "With"](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
  3363.                 }
  3364.               });
  3365.             });
  3366.             /** @type {null} */
  3367.             fns = null;
  3368.           }).promise();
  3369.         },
  3370.         /**
  3371.          * @param {string} obj
  3372.          * @return {?}
  3373.          */
  3374.         promise : function(obj) {
  3375.           return null != obj ? jQuery.extend(obj, promise) : promise;
  3376.         }
  3377.       };
  3378.       var deferred = {};
  3379.       return promise.pipe = promise.then, jQuery.each(which, function(dataAndEvents, tuple) {
  3380.         var list = tuple[2];
  3381.         var stateString = tuple[3];
  3382.         promise[tuple[1]] = list.add;
  3383.         if (stateString) {
  3384.           list.add(function() {
  3385.             state = stateString;
  3386.           }, which[1 ^ dataAndEvents][2].disable, which[2][2].lock);
  3387.         }
  3388.         /**
  3389.          * @return {?}
  3390.          */
  3391.         deferred[tuple[0]] = function() {
  3392.           return deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments), this;
  3393.         };
  3394.         deferred[tuple[0] + "With"] = list.fireWith;
  3395.       }), promise.promise(deferred), func && func.call(deferred, deferred), deferred;
  3396.     },
  3397.     /**
  3398.      * @param {Object} subordinate
  3399.      * @return {?}
  3400.      */
  3401.     when : function(subordinate) {
  3402.       /** @type {number} */
  3403.       var i = 0;
  3404.       /** @type {Array.<?>} */
  3405.       var resolveValues = core_slice.call(arguments);
  3406.       /** @type {number} */
  3407.       var length = resolveValues.length;
  3408.       /** @type {number} */
  3409.       var remaining = 1 !== length || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0;
  3410.       var deferred = 1 === remaining ? subordinate : jQuery.Deferred();
  3411.       /**
  3412.        * @param {number} i
  3413.        * @param {(Array|NodeList)} contexts
  3414.        * @param {Array} values
  3415.        * @return {?}
  3416.        */
  3417.       var updateFunc = function(i, contexts, values) {
  3418.         return function(value) {
  3419.           contexts[i] = this;
  3420.           values[i] = arguments.length > 1 ? core_slice.call(arguments) : value;
  3421.           if (values === progressValues) {
  3422.             deferred.notifyWith(contexts, values);
  3423.           } else {
  3424.             if (!--remaining) {
  3425.               deferred.resolveWith(contexts, values);
  3426.             }
  3427.           }
  3428.         };
  3429.       };
  3430.       var progressValues;
  3431.       var progressContexts;
  3432.       var resolveContexts;
  3433.       if (length > 1) {
  3434.         /** @type {Array} */
  3435.         progressValues = new Array(length);
  3436.         /** @type {Array} */
  3437.         progressContexts = new Array(length);
  3438.         /** @type {Array} */
  3439.         resolveContexts = new Array(length);
  3440.         for (;length > i;i++) {
  3441.           if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
  3442.             resolveValues[i].promise().done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject).progress(updateFunc(i, progressContexts, progressValues));
  3443.           } else {
  3444.             --remaining;
  3445.           }
  3446.         }
  3447.       }
  3448.       return remaining || deferred.resolveWith(resolveContexts, resolveValues), deferred.promise();
  3449.     }
  3450.   });
  3451.   /**
  3452.    * @param {string} details
  3453.    * @return {?}
  3454.    */
  3455.   jQuery.fn.ready = function(details) {
  3456.     return jQuery.ready.promise().done(details), this;
  3457.   };
  3458.   jQuery.extend({
  3459.     isReady : false,
  3460.     readyWait : 1,
  3461.     /**
  3462.      * @param {?} hold
  3463.      * @return {undefined}
  3464.      */
  3465.     holdReady : function(hold) {
  3466.       if (hold) {
  3467.         jQuery.readyWait++;
  3468.       } else {
  3469.         jQuery.ready(true);
  3470.       }
  3471.     },
  3472.     /**
  3473.      * @param {boolean} wait
  3474.      * @return {undefined}
  3475.      */
  3476.     ready : function(wait) {
  3477.       if (!(wait === true ? --jQuery.readyWait : jQuery.isReady)) {
  3478.         /** @type {boolean} */
  3479.         jQuery.isReady = true;
  3480.         if (!(wait !== true && --jQuery.readyWait > 0)) {
  3481.           readyList.resolveWith(doc, [jQuery]);
  3482.           if (jQuery.fn.triggerHandler) {
  3483.             jQuery(doc).triggerHandler("ready");
  3484.             jQuery(doc).off("ready");
  3485.           }
  3486.         }
  3487.       }
  3488.     }
  3489.   });
  3490.   /**
  3491.    * @param {string} obj
  3492.    * @return {?}
  3493.    */
  3494.   jQuery.ready.promise = function(obj) {
  3495.     return readyList || (readyList = jQuery.Deferred(), "complete" === doc.readyState ? setTimeout(jQuery.ready) : (doc.addEventListener("DOMContentLoaded", completed, false), win.addEventListener("load", completed, false))), readyList.promise(obj);
  3496.   };
  3497.   jQuery.ready.promise();
  3498.   /** @type {function (Object, Function, string, string, boolean, string, boolean): ?} */
  3499.   access = jQuery.access = function(elems, fn, key, value, chainable, emptyGet, raw) {
  3500.     /** @type {number} */
  3501.     var i = 0;
  3502.     var length = elems.length;
  3503.     /** @type {boolean} */
  3504.     var bulk = null == key;
  3505.     if ("object" === jQuery.type(key)) {
  3506.       /** @type {boolean} */
  3507.       chainable = true;
  3508.       for (i in key) {
  3509.         jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);
  3510.       }
  3511.     } else {
  3512.       if (void 0 !== value && (chainable = true, jQuery.isFunction(value) || (raw = true), bulk && (raw ? (fn.call(elems, value), fn = null) : (bulk = fn, fn = function(elem, event, value) {
  3513.         return bulk.call(jQuery(elem), value);
  3514.       })), fn)) {
  3515.         for (;length > i;i++) {
  3516.           fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
  3517.         }
  3518.       }
  3519.     }
  3520.     return chainable ? elems : bulk ? fn.call(elems) : length ? fn(elems[0], key) : emptyGet;
  3521.   };
  3522.   /**
  3523.    * @param {Object} elem
  3524.    * @return {?}
  3525.    */
  3526.   jQuery.acceptData = function(elem) {
  3527.     return 1 === elem.nodeType || (9 === elem.nodeType || !+elem.nodeType);
  3528.   };
  3529.   /** @type {number} */
  3530.   Data.uid = 1;
  3531.   /** @type {function (Object): ?} */
  3532.   Data.accepts = jQuery.acceptData;
  3533.   Data.prototype = {
  3534.     /**
  3535.      * @param {Object} owner
  3536.      * @return {?}
  3537.      */
  3538.     key : function(owner) {
  3539.       if (!Data.accepts(owner)) {
  3540.         return 0;
  3541.       }
  3542.       var descriptor = {};
  3543.       var unlock = owner[this.expando];
  3544.       if (!unlock) {
  3545.         /** @type {number} */
  3546.         unlock = Data.uid++;
  3547.         try {
  3548.           descriptor[this.expando] = {
  3549.             value : unlock
  3550.           };
  3551.           Object.defineProperties(owner, descriptor);
  3552.         } catch (u) {
  3553.           /** @type {number} */
  3554.           descriptor[this.expando] = unlock;
  3555.           jQuery.extend(owner, descriptor);
  3556.         }
  3557.       }
  3558.       return this.cache[unlock] || (this.cache[unlock] = {}), unlock;
  3559.     },
  3560.     /**
  3561.      * @param {Object} owner
  3562.      * @param {string} data
  3563.      * @param {string} value
  3564.      * @return {?}
  3565.      */
  3566.     set : function(owner, data, value) {
  3567.       var prop;
  3568.       var unlock = this.key(owner);
  3569.       var cache = this.cache[unlock];
  3570.       if ("string" == typeof data) {
  3571.         /** @type {string} */
  3572.         cache[data] = value;
  3573.       } else {
  3574.         if (jQuery.isEmptyObject(cache)) {
  3575.           jQuery.extend(this.cache[unlock], data);
  3576.         } else {
  3577.           for (prop in data) {
  3578.             cache[prop] = data[prop];
  3579.           }
  3580.         }
  3581.       }
  3582.       return cache;
  3583.     },
  3584.     /**
  3585.      * @param {Object} owner
  3586.      * @param {string} value
  3587.      * @return {?}
  3588.      */
  3589.     get : function(owner, value) {
  3590.       var cache = this.cache[this.key(owner)];
  3591.       return void 0 === value ? cache : cache[value];
  3592.     },
  3593.     /**
  3594.      * @param {Object} owner
  3595.      * @param {string} key
  3596.      * @param {string} value
  3597.      * @return {?}
  3598.      */
  3599.     access : function(owner, key, value) {
  3600.       var stored;
  3601.       return void 0 === key || key && ("string" == typeof key && void 0 === value) ? (stored = this.get(owner, key), void 0 !== stored ? stored : this.get(owner, jQuery.camelCase(key))) : (this.set(owner, key, value), void 0 !== value ? value : key);
  3602.     },
  3603.     /**
  3604.      * @param {Object} owner
  3605.      * @param {?} key
  3606.      * @return {undefined}
  3607.      */
  3608.     remove : function(owner, key) {
  3609.       var i;
  3610.       var name;
  3611.       var camel;
  3612.       var unlock = this.key(owner);
  3613.       var cache = this.cache[unlock];
  3614.       if (void 0 === key) {
  3615.         this.cache[unlock] = {};
  3616.       } else {
  3617.         if (jQuery.isArray(key)) {
  3618.           name = key.concat(key.map(jQuery.camelCase));
  3619.         } else {
  3620.           camel = jQuery.camelCase(key);
  3621.           if (key in cache) {
  3622.             /** @type {Array} */
  3623.             name = [key, camel];
  3624.           } else {
  3625.             name = camel;
  3626.             name = name in cache ? [name] : name.match(core_rnotwhite) || [];
  3627.           }
  3628.         }
  3629.         i = name.length;
  3630.         for (;i--;) {
  3631.           delete cache[name[i]];
  3632.         }
  3633.       }
  3634.     },
  3635.     /**
  3636.      * @param {Object} owner
  3637.      * @return {?}
  3638.      */
  3639.     hasData : function(owner) {
  3640.       return!jQuery.isEmptyObject(this.cache[owner[this.expando]] || {});
  3641.     },
  3642.     /**
  3643.      * @param {?} owner
  3644.      * @return {undefined}
  3645.      */
  3646.     discard : function(owner) {
  3647.       if (owner[this.expando]) {
  3648.         delete this.cache[owner[this.expando]];
  3649.       }
  3650.     }
  3651.   };
  3652.   var data_priv = new Data;
  3653.   var data_user = new Data;
  3654.   /** @type {RegExp} */
  3655.   var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
  3656.   /** @type {RegExp} */
  3657.   var r20 = /([A-Z])/g;
  3658.   jQuery.extend({
  3659.     /**
  3660.      * @param {Object} elem
  3661.      * @return {?}
  3662.      */
  3663.     hasData : function(elem) {
  3664.       return data_user.hasData(elem) || data_priv.hasData(elem);
  3665.     },
  3666.     /**
  3667.      * @param {string} args
  3668.      * @param {?} name
  3669.      * @param {string} data
  3670.      * @return {?}
  3671.      */
  3672.     data : function(args, name, data) {
  3673.       return data_user.access(args, name, data);
  3674.     },
  3675.     /**
  3676.      * @param {Object} elem
  3677.      * @param {?} key
  3678.      * @return {undefined}
  3679.      */
  3680.     removeData : function(elem, key) {
  3681.       data_user.remove(elem, key);
  3682.     },
  3683.     /**
  3684.      * @param {Object} elem
  3685.      * @param {Object} name
  3686.      * @param {string} data
  3687.      * @return {?}
  3688.      */
  3689.     _data : function(elem, name, data) {
  3690.       return data_priv.access(elem, name, data);
  3691.     },
  3692.     /**
  3693.      * @param {Object} elem
  3694.      * @param {?} name
  3695.      * @return {undefined}
  3696.      */
  3697.     _removeData : function(elem, name) {
  3698.       data_priv.remove(elem, name);
  3699.     }
  3700.   });
  3701.   jQuery.fn.extend({
  3702.     /**
  3703.      * @param {string} key
  3704.      * @param {?} value
  3705.      * @return {?}
  3706.      */
  3707.     data : function(key, value) {
  3708.       var len;
  3709.       var name;
  3710.       var data;
  3711.       var elem = this[0];
  3712.       var attrs = elem && elem.attributes;
  3713.       if (void 0 === key) {
  3714.         if (this.length && (data = data_user.get(elem), 1 === elem.nodeType && !data_priv.get(elem, "hasDataAttrs"))) {
  3715.           len = attrs.length;
  3716.           for (;len--;) {
  3717.             if (attrs[len]) {
  3718.               name = attrs[len].name;
  3719.               if (0 === name.indexOf("data-")) {
  3720.                 name = jQuery.camelCase(name.slice(5));
  3721.                 dataAttr(elem, name, data[name]);
  3722.               }
  3723.             }
  3724.           }
  3725.           data_priv.set(elem, "hasDataAttrs", true);
  3726.         }
  3727.         return data;
  3728.       }
  3729.       return "object" == typeof key ? this.each(function() {
  3730.         data_user.set(this, key);
  3731.       }) : access(this, function(value) {
  3732.         var data;
  3733.         var camelKey = jQuery.camelCase(key);
  3734.         if (elem && void 0 === value) {
  3735.           if ((data = data_user.get(elem, key), void 0 !== data) || ((data = data_user.get(elem, camelKey), void 0 !== data) || (data = dataAttr(elem, camelKey, void 0), void 0 !== data))) {
  3736.             return data;
  3737.           }
  3738.         } else {
  3739.           this.each(function() {
  3740.             var data = data_user.get(this, camelKey);
  3741.             data_user.set(this, camelKey, value);
  3742.             if (-1 !== key.indexOf("-")) {
  3743.               if (void 0 !== data) {
  3744.                 data_user.set(this, key, value);
  3745.               }
  3746.             }
  3747.           });
  3748.         }
  3749.       }, null, value, arguments.length > 1, null, true);
  3750.     },
  3751.     /**
  3752.      * @param {string} name
  3753.      * @return {?}
  3754.      */
  3755.     removeData : function(name) {
  3756.       return this.each(function() {
  3757.         data_user.remove(this, name);
  3758.       });
  3759.     }
  3760.   });
  3761.   jQuery.extend({
  3762.     /**
  3763.      * @param {Object} elem
  3764.      * @param {string} type
  3765.      * @param {?} data
  3766.      * @return {?}
  3767.      */
  3768.     queue : function(elem, type, data) {
  3769.       var queue;
  3770.       if (elem) {
  3771.         return type = (type || "fx") + "queue", queue = data_priv.get(elem, type), data && (!queue || jQuery.isArray(data) ? queue = data_priv.access(elem, type, jQuery.makeArray(data)) : queue.push(data)), queue || [];
  3772.       }
  3773.     },
  3774.     /**
  3775.      * @param {string} elem
  3776.      * @param {string} type
  3777.      * @return {undefined}
  3778.      */
  3779.     dequeue : function(elem, type) {
  3780.       type = type || "fx";
  3781.       var queue = jQuery.queue(elem, type);
  3782.       var ln = queue.length;
  3783.       var fn = queue.shift();
  3784.       var hooks = jQuery._queueHooks(elem, type);
  3785.       /**
  3786.        * @return {undefined}
  3787.        */
  3788.       var next = function() {
  3789.         jQuery.dequeue(elem, type);
  3790.       };
  3791.       if ("inprogress" === fn) {
  3792.         fn = queue.shift();
  3793.         ln--;
  3794.       }
  3795.       if (fn) {
  3796.         if ("fx" === type) {
  3797.           queue.unshift("inprogress");
  3798.         }
  3799.         delete hooks.stop;
  3800.         fn.call(elem, next, hooks);
  3801.       }
  3802.       if (!ln) {
  3803.         if (hooks) {
  3804.           hooks.empty.fire();
  3805.         }
  3806.       }
  3807.     },
  3808.     /**
  3809.      * @param {Object} elem
  3810.      * @param {string} type
  3811.      * @return {?}
  3812.      */
  3813.     _queueHooks : function(elem, type) {
  3814.       /** @type {string} */
  3815.       var key = type + "queueHooks";
  3816.       return data_priv.get(elem, key) || data_priv.access(elem, key, {
  3817.         empty : jQuery.Callbacks("once memory").add(function() {
  3818.           data_priv.remove(elem, [type + "queue", key]);
  3819.         })
  3820.       });
  3821.     }
  3822.   });
  3823.   jQuery.fn.extend({
  3824.     /**
  3825.      * @param {string} type
  3826.      * @param {string} data
  3827.      * @return {?}
  3828.      */
  3829.     queue : function(type, data) {
  3830.       /** @type {number} */
  3831.       var setter = 2;
  3832.       return "string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter ? jQuery.queue(this[0], type) : void 0 === data ? this : this.each(function() {
  3833.         var queue = jQuery.queue(this, type, data);
  3834.         jQuery._queueHooks(this, type);
  3835.         if ("fx" === type) {
  3836.           if ("inprogress" !== queue[0]) {
  3837.             jQuery.dequeue(this, type);
  3838.           }
  3839.         }
  3840.       });
  3841.     },
  3842.     /**
  3843.      * @param {string} type
  3844.      * @return {?}
  3845.      */
  3846.     dequeue : function(type) {
  3847.       return this.each(function() {
  3848.         jQuery.dequeue(this, type);
  3849.       });
  3850.     },
  3851.     /**
  3852.      * @param {string} type
  3853.      * @return {?}
  3854.      */
  3855.     clearQueue : function(type) {
  3856.       return this.queue(type || "fx", []);
  3857.     },
  3858.     /**
  3859.      * @param {string} type
  3860.      * @param {string} obj
  3861.      * @return {?}
  3862.      */
  3863.     promise : function(type, obj) {
  3864.       var body;
  3865.       /** @type {number} */
  3866.       var e = 1;
  3867.       var defer = jQuery.Deferred();
  3868.       var elements = this;
  3869.       var i = this.length;
  3870.       /**
  3871.        * @return {undefined}
  3872.        */
  3873.       var resolve = function() {
  3874.         if (!--e) {
  3875.           defer.resolveWith(elements, [elements]);
  3876.         }
  3877.       };
  3878.       if ("string" != typeof type) {
  3879.         /** @type {string} */
  3880.         obj = type;
  3881.         type = void 0;
  3882.       }
  3883.       type = type || "fx";
  3884.       for (;i--;) {
  3885.         body = data_priv.get(elements[i], type + "queueHooks");
  3886.         if (body) {
  3887.           if (body.empty) {
  3888.             e++;
  3889.             body.empty.add(resolve);
  3890.           }
  3891.         }
  3892.       }
  3893.       return resolve(), defer.promise(obj);
  3894.     }
  3895.   });
  3896.   /** @type {string} */
  3897.   var core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
  3898.   /** @type {Array} */
  3899.   var cssExpand = ["Top", "Right", "Bottom", "Left"];
  3900.   /**
  3901.    * @param {Object} node
  3902.    * @param {Function} context
  3903.    * @return {?}
  3904.    */
  3905.   var isHidden = function(node, context) {
  3906.     return node = context || node, "none" === jQuery.css(node, "display") || !jQuery.contains(node.ownerDocument, node);
  3907.   };
  3908.   /** @type {RegExp} */
  3909.   var manipulation_rcheckableType = /^(?:checkbox|radio)$/i;
  3910.   !function() {
  3911.     var fragment = doc.createDocumentFragment();
  3912.     var form = fragment.appendChild(doc.createElement("div"));
  3913.     var input = doc.createElement("input");
  3914.     input.setAttribute("type", "radio");
  3915.     input.setAttribute("checked", "checked");
  3916.     input.setAttribute("name", "t");
  3917.     form.appendChild(input);
  3918.     support.checkClone = form.cloneNode(true).cloneNode(true).lastChild.checked;
  3919.     /** @type {string} */
  3920.     form.innerHTML = "<textarea>x</textarea>";
  3921.     /** @type {boolean} */
  3922.     support.noCloneChecked = !!form.cloneNode(true).lastChild.defaultValue;
  3923.   }();
  3924.   /** @type {string} */
  3925.   memory = "undefined";
  3926.   /** @type {boolean} */
  3927.   support.focusinBubbles = "onfocusin" in win;
  3928.   /** @type {RegExp} */
  3929.   var rmouseEvent = /^key/;
  3930.   /** @type {RegExp} */
  3931.   var rkeyEvent = /^(?:mouse|pointer|contextmenu)|click/;
  3932.   /** @type {RegExp} */
  3933.   var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
  3934.   /** @type {RegExp} */
  3935.   var rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
  3936.   jQuery.event = {
  3937.     global : {},
  3938.     /**
  3939.      * @param {Object} elem
  3940.      * @param {Object} val
  3941.      * @param {Function} handler
  3942.      * @param {Object} e
  3943.      * @param {(Function|string)} selector
  3944.      * @return {undefined}
  3945.      */
  3946.     add : function(elem, val, handler, e, selector) {
  3947.       var handleObjIn;
  3948.       var eventHandle;
  3949.       var segmentMatch;
  3950.       var events;
  3951.       var n;
  3952.       var handleObj;
  3953.       var special;
  3954.       var handlers;
  3955.       var type;
  3956.       var namespaces;
  3957.       var origType;
  3958.       var elemData = data_priv.get(elem);
  3959.       if (elemData) {
  3960.         if (handler.handler) {
  3961.           /** @type {Function} */
  3962.           handleObjIn = handler;
  3963.           handler = handleObjIn.handler;
  3964.           selector = handleObjIn.selector;
  3965.         }
  3966.         if (!handler.guid) {
  3967.           /** @type {number} */
  3968.           handler.guid = jQuery.guid++;
  3969.         }
  3970.         if (!(events = elemData.events)) {
  3971.           events = elemData.events = {};
  3972.         }
  3973.         if (!(eventHandle = elemData.handle)) {
  3974.           /** @type {function (Event): ?} */
  3975.           eventHandle = elemData.handle = function(e) {
  3976.             if (typeof jQuery !== memory && jQuery.event.triggered !== e.type) {
  3977.               return jQuery.event.dispatch.apply(elem, arguments);
  3978.             }
  3979.           };
  3980.         }
  3981.         val = (val || "").match(core_rnotwhite) || [""];
  3982.         n = val.length;
  3983.         for (;n--;) {
  3984.           /** @type {Array} */
  3985.           segmentMatch = rtypenamespace.exec(val[n]) || [];
  3986.           type = origType = segmentMatch[1];
  3987.           namespaces = (segmentMatch[2] || "").split(".").sort();
  3988.           if (type) {
  3989.             special = jQuery.event.special[type] || {};
  3990.             type = (selector ? special.delegateType : special.bindType) || type;
  3991.             special = jQuery.event.special[type] || {};
  3992.             handleObj = jQuery.extend({
  3993.               type : type,
  3994.               origType : origType,
  3995.               data : e,
  3996.               /** @type {Function} */
  3997.               handler : handler,
  3998.               guid : handler.guid,
  3999.               selector : selector,
  4000.               needsContext : selector && jQuery.expr.match.needsContext.test(selector),
  4001.               namespace : namespaces.join(".")
  4002.             }, handleObjIn);
  4003.             if (!(handlers = events[type])) {
  4004.               /** @type {Array} */
  4005.               handlers = events[type] = [];
  4006.               /** @type {number} */
  4007.               handlers.delegateCount = 0;
  4008.               if (!(special.setup && special.setup.call(elem, e, namespaces, eventHandle) !== false)) {
  4009.                 if (elem.addEventListener) {
  4010.                   elem.addEventListener(type, eventHandle, false);
  4011.                 }
  4012.               }
  4013.             }
  4014.             if (special.add) {
  4015.               special.add.call(elem, handleObj);
  4016.               if (!handleObj.handler.guid) {
  4017.                 handleObj.handler.guid = handler.guid;
  4018.               }
  4019.             }
  4020.             if (selector) {
  4021.               handlers.splice(handlers.delegateCount++, 0, handleObj);
  4022.             } else {
  4023.               handlers.push(handleObj);
  4024.             }
  4025.             /** @type {boolean} */
  4026.             jQuery.event.global[type] = true;
  4027.           }
  4028.         }
  4029.       }
  4030.     },
  4031.     /**
  4032.      * @param {Object} elem
  4033.      * @param {Object} types
  4034.      * @param {Function} handler
  4035.      * @param {boolean} selector
  4036.      * @param {boolean} keepData
  4037.      * @return {undefined}
  4038.      */
  4039.     remove : function(elem, types, handler, selector, keepData) {
  4040.       var j;
  4041.       var origCount;
  4042.       var tmp;
  4043.       var events;
  4044.       var t;
  4045.       var handleObj;
  4046.       var special;
  4047.       var handlers;
  4048.       var type;
  4049.       var namespaces;
  4050.       var origType;
  4051.       var elemData = data_priv.hasData(elem) && data_priv.get(elem);
  4052.       if (elemData && (events = elemData.events)) {
  4053.         types = (types || "").match(core_rnotwhite) || [""];
  4054.         t = types.length;
  4055.         for (;t--;) {
  4056.           if (tmp = rtypenamespace.exec(types[t]) || [], type = origType = tmp[1], namespaces = (tmp[2] || "").split(".").sort(), type) {
  4057.             special = jQuery.event.special[type] || {};
  4058.             type = (selector ? special.delegateType : special.bindType) || type;
  4059.             handlers = events[type] || [];
  4060.             tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
  4061.             origCount = j = handlers.length;
  4062.             for (;j--;) {
  4063.               handleObj = handlers[j];
  4064.               if (!(!keepData && origType !== handleObj.origType)) {
  4065.                 if (!(handler && handler.guid !== handleObj.guid)) {
  4066.                   if (!(tmp && !tmp.test(handleObj.namespace))) {
  4067.                     if (!(selector && (selector !== handleObj.selector && ("**" !== selector || !handleObj.selector)))) {
  4068.                       handlers.splice(j, 1);
  4069.                       if (handleObj.selector) {
  4070.                         handlers.delegateCount--;
  4071.                       }
  4072.                       if (special.remove) {
  4073.                         special.remove.call(elem, handleObj);
  4074.                       }
  4075.                     }
  4076.                   }
  4077.                 }
  4078.               }
  4079.             }
  4080.             if (origCount) {
  4081.               if (!handlers.length) {
  4082.                 if (!(special.teardown && special.teardown.call(elem, namespaces, elemData.handle) !== false)) {
  4083.                   jQuery.removeEvent(elem, type, elemData.handle);
  4084.                 }
  4085.                 delete events[type];
  4086.               }
  4087.             }
  4088.           } else {
  4089.             for (type in events) {
  4090.               jQuery.event.remove(elem, type + types[t], handler, selector, true);
  4091.             }
  4092.           }
  4093.         }
  4094.         if (jQuery.isEmptyObject(events)) {
  4095.           delete elemData.handle;
  4096.           data_priv.remove(elem, "events");
  4097.         }
  4098.       }
  4099.     },
  4100.     /**
  4101.      * @param {Object} event
  4102.      * @param {?} data
  4103.      * @param {Object} elem
  4104.      * @param {string} onlyHandlers
  4105.      * @return {?}
  4106.      */
  4107.     trigger : function(event, data, elem, onlyHandlers) {
  4108.       var i;
  4109.       var cur;
  4110.       var tmp;
  4111.       var bubbleType;
  4112.       var ontype;
  4113.       var handle;
  4114.       var special;
  4115.       /** @type {Array} */
  4116.       var eventPath = [elem || doc];
  4117.       var type = core_hasOwn.call(event, "type") ? event.type : event;
  4118.       var namespaces = core_hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
  4119.       if (cur = tmp = elem = elem || doc, 3 !== elem.nodeType && (8 !== elem.nodeType && (!rfocusMorph.test(type + jQuery.event.triggered) && (type.indexOf(".") >= 0 && (namespaces = type.split("."), type = namespaces.shift(), namespaces.sort()), ontype = type.indexOf(":") < 0 && "on" + type, event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event), event.isTrigger = onlyHandlers ? 2 : 3, event.namespace = namespaces.join("."), event.namespace_re = event.namespace ?
  4120.       new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, event.result = void 0, event.target || (event.target = elem), data = null == data ? [event] : jQuery.makeArray(data, [event]), special = jQuery.event.special[type] || {}, onlyHandlers || (!special.trigger || special.trigger.apply(elem, data) !== false))))) {
  4121.         if (!onlyHandlers && (!special.noBubble && !jQuery.isWindow(elem))) {
  4122.           bubbleType = special.delegateType || type;
  4123.           if (!rfocusMorph.test(bubbleType + type)) {
  4124.             cur = cur.parentNode;
  4125.           }
  4126.           for (;cur;cur = cur.parentNode) {
  4127.             eventPath.push(cur);
  4128.             tmp = cur;
  4129.           }
  4130.           if (tmp === (elem.ownerDocument || doc)) {
  4131.             eventPath.push(tmp.defaultView || (tmp.parentWindow || win));
  4132.           }
  4133.         }
  4134.         /** @type {number} */
  4135.         i = 0;
  4136.         for (;(cur = eventPath[i++]) && !event.isPropagationStopped();) {
  4137.           event.type = i > 1 ? bubbleType : special.bindType || type;
  4138.           handle = (data_priv.get(cur, "events") || {})[event.type] && data_priv.get(cur, "handle");
  4139.           if (handle) {
  4140.             handle.apply(cur, data);
  4141.           }
  4142.           handle = ontype && cur[ontype];
  4143.           if (handle) {
  4144.             if (handle.apply) {
  4145.               if (jQuery.acceptData(cur)) {
  4146.                 event.result = handle.apply(cur, data);
  4147.                 if (event.result === false) {
  4148.                   event.preventDefault();
  4149.                 }
  4150.               }
  4151.             }
  4152.           }
  4153.         }
  4154.         return event.type = type, onlyHandlers || (event.isDefaultPrevented() || (special._default && special._default.apply(eventPath.pop(), data) !== false || (!jQuery.acceptData(elem) || ontype && (jQuery.isFunction(elem[type]) && (!jQuery.isWindow(elem) && (tmp = elem[ontype], tmp && (elem[ontype] = null), jQuery.event.triggered = type, elem[type](), jQuery.event.triggered = void 0, tmp && (elem[ontype] = tmp))))))), event.result;
  4155.       }
  4156.     },
  4157.     /**
  4158.      * @param {Object} event
  4159.      * @return {?}
  4160.      */
  4161.     dispatch : function(event) {
  4162.       event = jQuery.event.fix(event);
  4163.       var i;
  4164.       var j;
  4165.       var ret;
  4166.       var matched;
  4167.       var handleObj;
  4168.       /** @type {Array} */
  4169.       var handlerQueue = [];
  4170.       /** @type {Array.<?>} */
  4171.       var args = core_slice.call(arguments);
  4172.       var handlers = (data_priv.get(this, "events") || {})[event.type] || [];
  4173.       var special = jQuery.event.special[event.type] || {};
  4174.       if (args[0] = event, event.delegateTarget = this, !special.preDispatch || special.preDispatch.call(this, event) !== false) {
  4175.         handlerQueue = jQuery.event.handlers.call(this, event, handlers);
  4176.         /** @type {number} */
  4177.         i = 0;
  4178.         for (;(matched = handlerQueue[i++]) && !event.isPropagationStopped();) {
  4179.           event.currentTarget = matched.elem;
  4180.           /** @type {number} */
  4181.           j = 0;
  4182.           for (;(handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();) {
  4183.             if (!event.namespace_re || event.namespace_re.test(handleObj.namespace)) {
  4184.               event.handleObj = handleObj;
  4185.               event.data = handleObj.data;
  4186.               ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
  4187.               if (void 0 !== ret) {
  4188.                 if ((event.result = ret) === false) {
  4189.                   event.preventDefault();
  4190.                   event.stopPropagation();
  4191.                 }
  4192.               }
  4193.             }
  4194.           }
  4195.         }
  4196.         return special.postDispatch && special.postDispatch.call(this, event), event.result;
  4197.       }
  4198.     },
  4199.     /**
  4200.      * @param {Event} event
  4201.      * @param {Object} handlers
  4202.      * @return {?}
  4203.      */
  4204.     handlers : function(event, handlers) {
  4205.       var j;
  4206.       var matches;
  4207.       var sel;
  4208.       var handleObj;
  4209.       /** @type {Array} */
  4210.       var handlerQueue = [];
  4211.       var delegateCount = handlers.delegateCount;
  4212.       var cur = event.target;
  4213.       if (delegateCount && (cur.nodeType && (!event.button || "click" !== event.type))) {
  4214.         for (;cur !== this;cur = cur.parentNode || this) {
  4215.           if (cur.disabled !== true || "click" !== event.type) {
  4216.             /** @type {Array} */
  4217.             matches = [];
  4218.             /** @type {number} */
  4219.             j = 0;
  4220.             for (;delegateCount > j;j++) {
  4221.               handleObj = handlers[j];
  4222.               /** @type {string} */
  4223.               sel = handleObj.selector + " ";
  4224.               if (void 0 === matches[sel]) {
  4225.                 matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) >= 0 : jQuery.find(sel, this, null, [cur]).length;
  4226.               }
  4227.               if (matches[sel]) {
  4228.                 matches.push(handleObj);
  4229.               }
  4230.             }
  4231.             if (matches.length) {
  4232.               handlerQueue.push({
  4233.                 elem : cur,
  4234.                 handlers : matches
  4235.               });
  4236.             }
  4237.           }
  4238.         }
  4239.       }
  4240.       return delegateCount < handlers.length && handlerQueue.push({
  4241.         elem : this,
  4242.         handlers : handlers.slice(delegateCount)
  4243.       }), handlerQueue;
  4244.     },
  4245.     props : "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
  4246.     fixHooks : {},
  4247.     keyHooks : {
  4248.       props : "char charCode key keyCode".split(" "),
  4249.       /**
  4250.        * @param {Object} event
  4251.        * @param {Event} original
  4252.        * @return {?}
  4253.        */
  4254.       filter : function(event, original) {
  4255.         return null == event.which && (event.which = null != original.charCode ? original.charCode : original.keyCode), event;
  4256.       }
  4257.     },
  4258.     mouseHooks : {
  4259.       props : "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
  4260.       /**
  4261.        * @param {Object} event
  4262.        * @param {Event} original
  4263.        * @return {?}
  4264.        */
  4265.       filter : function(event, original) {
  4266.         var d;
  4267.         var de;
  4268.         var b;
  4269.         var button = original.button;
  4270.         return null == event.pageX && (null != original.clientX && (d = event.target.ownerDocument || doc, de = d.documentElement, b = d.body, event.pageX = original.clientX + (de && de.scrollLeft || (b && b.scrollLeft || 0)) - (de && de.clientLeft || (b && b.clientLeft || 0)), event.pageY = original.clientY + (de && de.scrollTop || (b && b.scrollTop || 0)) - (de && de.clientTop || (b && b.clientTop || 0)))), event.which || (void 0 === button || (event.which = 1 & button ? 1 : 2 & button ? 3 : 4 &
  4271.         button ? 2 : 0)), event;
  4272.       }
  4273.     },
  4274.     /**
  4275.      * @param {Object} event
  4276.      * @return {?}
  4277.      */
  4278.     fix : function(event) {
  4279.       if (event[jQuery.expando]) {
  4280.         return event;
  4281.       }
  4282.       var i;
  4283.       var prop;
  4284.       var copy;
  4285.       var type = event.type;
  4286.       /** @type {Object} */
  4287.       var originalEvent = event;
  4288.       var fixHook = this.fixHooks[type];
  4289.       if (!fixHook) {
  4290.         this.fixHooks[type] = fixHook = rkeyEvent.test(type) ? this.mouseHooks : rmouseEvent.test(type) ? this.keyHooks : {};
  4291.       }
  4292.       copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
  4293.       event = new jQuery.Event(originalEvent);
  4294.       i = copy.length;
  4295.       for (;i--;) {
  4296.         prop = copy[i];
  4297.         event[prop] = originalEvent[prop];
  4298.       }
  4299.       return event.target || (event.target = doc), 3 === event.target.nodeType && (event.target = event.target.parentNode), fixHook.filter ? fixHook.filter(event, originalEvent) : event;
  4300.     },
  4301.     special : {
  4302.       load : {
  4303.         noBubble : true
  4304.       },
  4305.       focus : {
  4306.         /**
  4307.          * @return {?}
  4308.          */
  4309.         trigger : function() {
  4310.           if (this !== safeActiveElement() && this.focus) {
  4311.             return this.focus(), false;
  4312.           }
  4313.         },
  4314.         delegateType : "focusin"
  4315.       },
  4316.       blur : {
  4317.         /**
  4318.          * @return {?}
  4319.          */
  4320.         trigger : function() {
  4321.           if (this === safeActiveElement() && this.blur) {
  4322.             return this.blur(), false;
  4323.           }
  4324.         },
  4325.         delegateType : "focusout"
  4326.       },
  4327.       click : {
  4328.         /**
  4329.          * @return {?}
  4330.          */
  4331.         trigger : function() {
  4332.           if ("checkbox" === this.type && (this.click && jQuery.nodeName(this, "input"))) {
  4333.             return this.click(), false;
  4334.           }
  4335.         },
  4336.         /**
  4337.          * @param {number} name
  4338.          * @return {?}
  4339.          */
  4340.         _default : function(name) {
  4341.           return jQuery.nodeName(name.target, "a");
  4342.         }
  4343.       },
  4344.       beforeunload : {
  4345.         /**
  4346.          * @param {Object} event
  4347.          * @return {undefined}
  4348.          */
  4349.         postDispatch : function(event) {
  4350.           if (void 0 !== event.result) {
  4351.             if (event.originalEvent) {
  4352.               event.originalEvent.returnValue = event.result;
  4353.             }
  4354.           }
  4355.         }
  4356.       }
  4357.     },
  4358.     /**
  4359.      * @param {string} type
  4360.      * @param {Object} elem
  4361.      * @param {?} event
  4362.      * @param {boolean} dataAndEvents
  4363.      * @return {undefined}
  4364.      */
  4365.     simulate : function(type, elem, event, dataAndEvents) {
  4366.       var e = jQuery.extend(new jQuery.Event, event, {
  4367.         type : type,
  4368.         isSimulated : true,
  4369.         originalEvent : {}
  4370.       });
  4371.       if (dataAndEvents) {
  4372.         jQuery.event.trigger(e, null, elem);
  4373.       } else {
  4374.         jQuery.event.dispatch.call(elem, e);
  4375.       }
  4376.       if (e.isDefaultPrevented()) {
  4377.         event.preventDefault();
  4378.       }
  4379.     }
  4380.   };
  4381.   /**
  4382.    * @param {Object} elem
  4383.    * @param {?} type
  4384.    * @param {?} handle
  4385.    * @return {undefined}
  4386.    */
  4387.   jQuery.removeEvent = function(elem, type, handle) {
  4388.     if (elem.removeEventListener) {
  4389.       elem.removeEventListener(type, handle, false);
  4390.     }
  4391.   };
  4392.   /**
  4393.    * @param {Object} src
  4394.    * @param {boolean} props
  4395.    * @return {?}
  4396.    */
  4397.   jQuery.Event = function(src, props) {
  4398.     return this instanceof jQuery.Event ? (src && src.type ? (this.originalEvent = src, this.type = src.type, this.isDefaultPrevented = src.defaultPrevented || void 0 === src.defaultPrevented && src.returnValue === false ? returnTrue : returnFalse) : this.type = src, props && jQuery.extend(this, props), this.timeStamp = src && src.timeStamp || jQuery.now(), void(this[jQuery.expando] = true)) : new jQuery.Event(src, props);
  4399.   };
  4400.   jQuery.Event.prototype = {
  4401.     /** @type {function (): ?} */
  4402.     isDefaultPrevented : returnFalse,
  4403.     /** @type {function (): ?} */
  4404.     isPropagationStopped : returnFalse,
  4405.     /** @type {function (): ?} */
  4406.     isImmediatePropagationStopped : returnFalse,
  4407.     /**
  4408.      * @return {undefined}
  4409.      */
  4410.     preventDefault : function() {
  4411.       var e = this.originalEvent;
  4412.       /** @type {function (): ?} */
  4413.       this.isDefaultPrevented = returnTrue;
  4414.       if (e) {
  4415.         if (e.preventDefault) {
  4416.           e.preventDefault();
  4417.         }
  4418.       }
  4419.     },
  4420.     /**
  4421.      * @return {undefined}
  4422.      */
  4423.     stopPropagation : function() {
  4424.       var e = this.originalEvent;
  4425.       /** @type {function (): ?} */
  4426.       this.isPropagationStopped = returnTrue;
  4427.       if (e) {
  4428.         if (e.stopPropagation) {
  4429.           e.stopPropagation();
  4430.         }
  4431.       }
  4432.     },
  4433.     /**
  4434.      * @return {undefined}
  4435.      */
  4436.     stopImmediatePropagation : function() {
  4437.       var e = this.originalEvent;
  4438.       /** @type {function (): ?} */
  4439.       this.isImmediatePropagationStopped = returnTrue;
  4440.       if (e) {
  4441.         if (e.stopImmediatePropagation) {
  4442.           e.stopImmediatePropagation();
  4443.         }
  4444.       }
  4445.       this.stopPropagation();
  4446.     }
  4447.   };
  4448.   jQuery.each({
  4449.     mouseenter : "mouseover",
  4450.     mouseleave : "mouseout",
  4451.     pointerenter : "pointerover",
  4452.     pointerleave : "pointerout"
  4453.   }, function(orig, fix) {
  4454.     jQuery.event.special[orig] = {
  4455.       delegateType : fix,
  4456.       bindType : fix,
  4457.       /**
  4458.        * @param {Object} event
  4459.        * @return {?}
  4460.        */
  4461.       handle : function(event) {
  4462.         var returnValue;
  4463.         var target = this;
  4464.         var related = event.relatedTarget;
  4465.         var handleObj = event.handleObj;
  4466.         return(!related || related !== target && !jQuery.contains(target, related)) && (event.type = handleObj.origType, returnValue = handleObj.handler.apply(this, arguments), event.type = fix), returnValue;
  4467.       }
  4468.     };
  4469.   });
  4470.   if (!support.focusinBubbles) {
  4471.     jQuery.each({
  4472.       focus : "focusin",
  4473.       blur : "focusout"
  4474.     }, function(event, name) {
  4475.       /**
  4476.        * @param {Object} event
  4477.        * @return {undefined}
  4478.        */
  4479.       var handler = function(event) {
  4480.         jQuery.event.simulate(name, event.target, jQuery.event.fix(event), true);
  4481.       };
  4482.       jQuery.event.special[name] = {
  4483.         /**
  4484.          * @return {undefined}
  4485.          */
  4486.         setup : function() {
  4487.           var node = this.ownerDocument || this;
  4488.           var descriptor = data_priv.access(node, name);
  4489.           if (!descriptor) {
  4490.             node.addEventListener(event, handler, true);
  4491.           }
  4492.           data_priv.access(node, name, (descriptor || 0) + 1);
  4493.         },
  4494.         /**
  4495.          * @return {undefined}
  4496.          */
  4497.         teardown : function() {
  4498.           var node = this.ownerDocument || this;
  4499.           /** @type {number} */
  4500.           var data = data_priv.access(node, name) - 1;
  4501.           if (data) {
  4502.             data_priv.access(node, name, data);
  4503.           } else {
  4504.             node.removeEventListener(event, handler, true);
  4505.             data_priv.remove(node, name);
  4506.           }
  4507.         }
  4508.       };
  4509.     });
  4510.   }
  4511.   jQuery.fn.extend({
  4512.     /**
  4513.      * @param {string} types
  4514.      * @param {Function} selector
  4515.      * @param {Function} data
  4516.      * @param {Function} fn
  4517.      * @param {(number|string)} one
  4518.      * @return {?}
  4519.      */
  4520.     on : function(types, selector, data, fn, one) {
  4521.       var origFn;
  4522.       var type;
  4523.       if ("object" == typeof types) {
  4524.         if ("string" != typeof selector) {
  4525.           data = data || selector;
  4526.           selector = void 0;
  4527.         }
  4528.         for (type in types) {
  4529.           this.on(type, selector, data, types[type], one);
  4530.         }
  4531.         return this;
  4532.       }
  4533.       if (null == data && null == fn ? (fn = selector, data = selector = void 0) : null == fn && ("string" == typeof selector ? (fn = data, data = void 0) : (fn = data, data = selector, selector = void 0)), fn === false) {
  4534.         /** @type {function (): ?} */
  4535.         fn = returnFalse;
  4536.       } else {
  4537.         if (!fn) {
  4538.           return this;
  4539.         }
  4540.       }
  4541.       return 1 === one && (origFn = fn, fn = function(event) {
  4542.         return jQuery().off(event), origFn.apply(this, arguments);
  4543.       }, fn.guid = origFn.guid || (origFn.guid = jQuery.guid++)), this.each(function() {
  4544.         jQuery.event.add(this, types, fn, data, selector);
  4545.       });
  4546.     },
  4547.     /**
  4548.      * @param {string} types
  4549.      * @param {Function} selector
  4550.      * @param {Function} data
  4551.      * @param {Function} fn
  4552.      * @return {?}
  4553.      */
  4554.     one : function(types, selector, data, fn) {
  4555.       return this.on(types, selector, data, fn, 1);
  4556.     },
  4557.     /**
  4558.      * @param {Object} types
  4559.      * @param {Object} selector
  4560.      * @param {Function} fn
  4561.      * @return {?}
  4562.      */
  4563.     off : function(types, selector, fn) {
  4564.       var handleObj;
  4565.       var type;
  4566.       if (types && (types.preventDefault && types.handleObj)) {
  4567.         return handleObj = types.handleObj, jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler), this;
  4568.       }
  4569.       if ("object" == typeof types) {
  4570.         for (type in types) {
  4571.           this.off(type, selector, types[type]);
  4572.         }
  4573.         return this;
  4574.       }
  4575.       return(selector === false || "function" == typeof selector) && (fn = selector, selector = void 0), fn === false && (fn = returnFalse), this.each(function() {
  4576.         jQuery.event.remove(this, types, fn, selector);
  4577.       });
  4578.     },
  4579.     /**
  4580.      * @param {string} type
  4581.      * @param {?} data
  4582.      * @return {?}
  4583.      */
  4584.     trigger : function(type, data) {
  4585.       return this.each(function() {
  4586.         jQuery.event.trigger(type, data, this);
  4587.       });
  4588.     },
  4589.     /**
  4590.      * @param {string} type
  4591.      * @param {?} data
  4592.      * @return {?}
  4593.      */
  4594.     triggerHandler : function(type, data) {
  4595.       var parent = this[0];
  4596.       if (parent) {
  4597.         return jQuery.event.trigger(type, data, parent, true);
  4598.       }
  4599.     }
  4600.   });
  4601.   /** @type {RegExp} */
  4602.   var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi;
  4603.   /** @type {RegExp} */
  4604.   var rtagName = /<([\w:]+)/;
  4605.   /** @type {RegExp} */
  4606.   var rhtml = /<|&#?\w+;/;
  4607.   /** @type {RegExp} */
  4608.   var rchecked = /<(?:script|style|link)/i;
  4609.   /** @type {RegExp} */
  4610.   var exclude = /checked\s*(?:[^=]|=\s*.checked.)/i;
  4611.   /** @type {RegExp} */
  4612.   var stopParent = /^$|\/(?:java|ecma)script/i;
  4613.   /** @type {RegExp} */
  4614.   var re = /^true\/(.*)/;
  4615.   /** @type {RegExp} */
  4616.   var rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  4617.   var wrapMap = {
  4618.     option : [1, "<select multiple='multiple'>", "</select>"],
  4619.     thead : [1, "<table>", "</table>"],
  4620.     col : [2, "<table><colgroup>", "</colgroup></table>"],
  4621.     tr : [2, "<table><tbody>", "</tbody></table>"],
  4622.     td : [3, "<table><tbody><tr>", "</tr></tbody></table>"],
  4623.     _default : [0, "", ""]
  4624.   };
  4625.   /** @type {Array} */
  4626.   wrapMap.optgroup = wrapMap.option;
  4627.   /** @type {Array} */
  4628.   wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  4629.   /** @type {Array} */
  4630.   wrapMap.th = wrapMap.td;
  4631.   jQuery.extend({
  4632.     /**
  4633.      * @param {Object} elem
  4634.      * @param {boolean} dataAndEvents
  4635.      * @param {boolean} deepDataAndEvents
  4636.      * @return {?}
  4637.      */
  4638.     clone : function(elem, dataAndEvents, deepDataAndEvents) {
  4639.       var i;
  4640.       var l;
  4641.       var srcElements;
  4642.       var destElements;
  4643.       var clone = elem.cloneNode(true);
  4644.       var inPage = jQuery.contains(elem.ownerDocument, elem);
  4645.       if (!(support.noCloneChecked || (1 !== elem.nodeType && 11 !== elem.nodeType || jQuery.isXMLDoc(elem)))) {
  4646.         destElements = getAll(clone);
  4647.         srcElements = getAll(elem);
  4648.         /** @type {number} */
  4649.         i = 0;
  4650.         l = srcElements.length;
  4651.         for (;l > i;i++) {
  4652.           fixInput(srcElements[i], destElements[i]);
  4653.         }
  4654.       }
  4655.       if (dataAndEvents) {
  4656.         if (deepDataAndEvents) {
  4657.           srcElements = srcElements || getAll(elem);
  4658.           destElements = destElements || getAll(clone);
  4659.           /** @type {number} */
  4660.           i = 0;
  4661.           l = srcElements.length;
  4662.           for (;l > i;i++) {
  4663.             cloneCopyEvent(srcElements[i], destElements[i]);
  4664.           }
  4665.         } else {
  4666.           cloneCopyEvent(elem, clone);
  4667.         }
  4668.       }
  4669.       return destElements = getAll(clone, "script"), destElements.length > 0 && setGlobalEval(destElements, !inPage && getAll(elem, "script")), clone;
  4670.     },
  4671.     /**
  4672.      * @param {Array} elems
  4673.      * @param {Document} context
  4674.      * @param {boolean} scripts
  4675.      * @param {?} selection
  4676.      * @return {?}
  4677.      */
  4678.     buildFragment : function(elems, context, scripts, selection) {
  4679.       var elem;
  4680.       var tmp;
  4681.       var tag;
  4682.       var wrap;
  4683.       var contains;
  4684.       var j;
  4685.       var fragment = context.createDocumentFragment();
  4686.       /** @type {Array} */
  4687.       var nodes = [];
  4688.       /** @type {number} */
  4689.       var i = 0;
  4690.       var l = elems.length;
  4691.       for (;l > i;i++) {
  4692.         if (elem = elems[i], elem || 0 === elem) {
  4693.           if ("object" === jQuery.type(elem)) {
  4694.             jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
  4695.           } else {
  4696.             if (rhtml.test(elem)) {
  4697.               tmp = tmp || fragment.appendChild(context.createElement("div"));
  4698.               tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
  4699.               wrap = wrapMap[tag] || wrapMap._default;
  4700.               tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, "<$1></$2>") + wrap[2];
  4701.               j = wrap[0];
  4702.               for (;j--;) {
  4703.                 tmp = tmp.lastChild;
  4704.               }
  4705.               jQuery.merge(nodes, tmp.childNodes);
  4706.               tmp = fragment.firstChild;
  4707.               /** @type {string} */
  4708.               tmp.textContent = "";
  4709.             } else {
  4710.               nodes.push(context.createTextNode(elem));
  4711.             }
  4712.           }
  4713.         }
  4714.       }
  4715.       /** @type {string} */
  4716.       fragment.textContent = "";
  4717.       /** @type {number} */
  4718.       i = 0;
  4719.       for (;elem = nodes[i++];) {
  4720.         if ((!selection || -1 === jQuery.inArray(elem, selection)) && (contains = jQuery.contains(elem.ownerDocument, elem), tmp = getAll(fragment.appendChild(elem), "script"), contains && setGlobalEval(tmp), scripts)) {
  4721.           /** @type {number} */
  4722.           j = 0;
  4723.           for (;elem = tmp[j++];) {
  4724.             if (stopParent.test(elem.type || "")) {
  4725.               scripts.push(elem);
  4726.             }
  4727.           }
  4728.         }
  4729.       }
  4730.       return fragment;
  4731.     },
  4732.     /**
  4733.      * @param {?} elems
  4734.      * @return {undefined}
  4735.      */
  4736.     cleanData : function(elems) {
  4737.       var data;
  4738.       var elem;
  4739.       var type;
  4740.       var key;
  4741.       var special = jQuery.event.special;
  4742.       /** @type {number} */
  4743.       var i = 0;
  4744.       for (;void 0 !== (elem = elems[i]);i++) {
  4745.         if (jQuery.acceptData(elem) && (key = elem[data_priv.expando], key && (data = data_priv.cache[key]))) {
  4746.           if (data.events) {
  4747.             for (type in data.events) {
  4748.               if (special[type]) {
  4749.                 jQuery.event.remove(elem, type);
  4750.               } else {
  4751.                 jQuery.removeEvent(elem, type, data.handle);
  4752.               }
  4753.             }
  4754.           }
  4755.           if (data_priv.cache[key]) {
  4756.             delete data_priv.cache[key];
  4757.           }
  4758.         }
  4759.         delete data_user.cache[elem[data_user.expando]];
  4760.       }
  4761.     }
  4762.   });
  4763.   jQuery.fn.extend({
  4764.     /**
  4765.      * @param {string} elems
  4766.      * @return {?}
  4767.      */
  4768.     text : function(elems) {
  4769.       return access(this, function(textString) {
  4770.         return void 0 === textString ? jQuery.text(this) : this.empty().each(function() {
  4771.           if (1 === this.nodeType || (11 === this.nodeType || 9 === this.nodeType)) {
  4772.             /** @type {string} */
  4773.             this.textContent = textString;
  4774.           }
  4775.         });
  4776.       }, null, elems, arguments.length);
  4777.     },
  4778.     /**
  4779.      * @return {?}
  4780.      */
  4781.     append : function() {
  4782.       return this.domManip(arguments, function(elem) {
  4783.         if (1 === this.nodeType || (11 === this.nodeType || 9 === this.nodeType)) {
  4784.           var target = manipulationTarget(this, elem);
  4785.           target.appendChild(elem);
  4786.         }
  4787.       });
  4788.     },
  4789.     /**
  4790.      * @return {?}
  4791.      */
  4792.     prepend : function() {
  4793.       return this.domManip(arguments, function(elem) {
  4794.         if (1 === this.nodeType || (11 === this.nodeType || 9 === this.nodeType)) {
  4795.           var target = manipulationTarget(this, elem);
  4796.           target.insertBefore(elem, target.firstChild);
  4797.         }
  4798.       });
  4799.     },
  4800.     /**
  4801.      * @return {?}
  4802.      */
  4803.     before : function() {
  4804.       return this.domManip(arguments, function(elem) {
  4805.         if (this.parentNode) {
  4806.           this.parentNode.insertBefore(elem, this);
  4807.         }
  4808.       });
  4809.     },
  4810.     /**
  4811.      * @return {?}
  4812.      */
  4813.     after : function() {
  4814.       return this.domManip(arguments, function(elem) {
  4815.         if (this.parentNode) {
  4816.           this.parentNode.insertBefore(elem, this.nextSibling);
  4817.         }
  4818.       });
  4819.     },
  4820.     /**
  4821.      * @param {boolean} selector
  4822.      * @param {?} keepData
  4823.      * @return {?}
  4824.      */
  4825.     remove : function(selector, keepData) {
  4826.       var elem;
  4827.       var elems = selector ? jQuery.filter(selector, this) : this;
  4828.       /** @type {number} */
  4829.       var i = 0;
  4830.       for (;null != (elem = elems[i]);i++) {
  4831.         if (!keepData) {
  4832.           if (!(1 !== elem.nodeType)) {
  4833.             jQuery.cleanData(getAll(elem));
  4834.           }
  4835.         }
  4836.         if (elem.parentNode) {
  4837.           if (keepData) {
  4838.             if (jQuery.contains(elem.ownerDocument, elem)) {
  4839.               setGlobalEval(getAll(elem, "script"));
  4840.             }
  4841.           }
  4842.           elem.parentNode.removeChild(elem);
  4843.         }
  4844.       }
  4845.       return this;
  4846.     },
  4847.     /**
  4848.      * @return {?}
  4849.      */
  4850.     empty : function() {
  4851.       var elem;
  4852.       /** @type {number} */
  4853.       var unlock = 0;
  4854.       for (;null != (elem = this[unlock]);unlock++) {
  4855.         if (1 === elem.nodeType) {
  4856.           jQuery.cleanData(getAll(elem, false));
  4857.           /** @type {string} */
  4858.           elem.textContent = "";
  4859.         }
  4860.       }
  4861.       return this;
  4862.     },
  4863.     /**
  4864.      * @param {boolean} dataAndEvents
  4865.      * @param {boolean} deepDataAndEvents
  4866.      * @return {?}
  4867.      */
  4868.     clone : function(dataAndEvents, deepDataAndEvents) {
  4869.       return dataAndEvents = null == dataAndEvents ? false : dataAndEvents, deepDataAndEvents = null == deepDataAndEvents ? dataAndEvents : deepDataAndEvents, this.map(function() {
  4870.         return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
  4871.       });
  4872.     },
  4873.     /**
  4874.      * @param {Object} value
  4875.      * @return {?}
  4876.      */
  4877.     html : function(value) {
  4878.       return access(this, function(value) {
  4879.         var elem = this[0] || {};
  4880.         /** @type {number} */
  4881.         var i = 0;
  4882.         var l = this.length;
  4883.         if (void 0 === value && 1 === elem.nodeType) {
  4884.           return elem.innerHTML;
  4885.         }
  4886.         if ("string" == typeof value && (!rchecked.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()])) {
  4887.           /** @type {string} */
  4888.           value = value.replace(rxhtmlTag, "<$1></$2>");
  4889.           try {
  4890.             for (;l > i;i++) {
  4891.               elem = this[i] || {};
  4892.               if (1 === elem.nodeType) {
  4893.                 jQuery.cleanData(getAll(elem, false));
  4894.                 /** @type {string} */
  4895.                 elem.innerHTML = value;
  4896.               }
  4897.             }
  4898.             /** @type {number} */
  4899.             elem = 0;
  4900.           } catch (f) {
  4901.           }
  4902.         }
  4903.         if (elem) {
  4904.           this.empty().append(value);
  4905.         }
  4906.       }, null, value, arguments.length);
  4907.     },
  4908.     /**
  4909.      * @return {?}
  4910.      */
  4911.     replaceWith : function() {
  4912.       var arg = arguments[0];
  4913.       return this.domManip(arguments, function(s) {
  4914.         arg = this.parentNode;
  4915.         jQuery.cleanData(getAll(this));
  4916.         if (arg) {
  4917.           arg.replaceChild(s, this);
  4918.         }
  4919.       }), arg && (arg.length || arg.nodeType) ? this : this.remove();
  4920.     },
  4921.     /**
  4922.      * @param {Object} selector
  4923.      * @return {?}
  4924.      */
  4925.     detach : function(selector) {
  4926.       return this.remove(selector, true);
  4927.     },
  4928.     /**
  4929.      * @param {Object} args
  4930.      * @param {Function} callback
  4931.      * @return {?}
  4932.      */
  4933.     domManip : function(args, callback) {
  4934.       /** @type {Array} */
  4935.       args = core_concat.apply([], args);
  4936.       var fragment;
  4937.       var first;
  4938.       var scripts;
  4939.       var _len;
  4940.       var node;
  4941.       var doc;
  4942.       /** @type {number} */
  4943.       var i = 0;
  4944.       var l = this.length;
  4945.       var set = this;
  4946.       /** @type {number} */
  4947.       var iNoClone = l - 1;
  4948.       var html = args[0];
  4949.       var isFunction = jQuery.isFunction(html);
  4950.       if (isFunction || l > 1 && ("string" == typeof html && (!support.checkClone && exclude.test(html)))) {
  4951.         return this.each(function(index) {
  4952.           var self = set.eq(index);
  4953.           if (isFunction) {
  4954.             args[0] = html.call(this, index, self.html());
  4955.           }
  4956.           self.domManip(args, callback);
  4957.         });
  4958.       }
  4959.       if (l && (fragment = jQuery.buildFragment(args, this[0].ownerDocument, false, this), first = fragment.firstChild, 1 === fragment.childNodes.length && (fragment = first), first)) {
  4960.         scripts = jQuery.map(getAll(fragment, "script"), restoreScript);
  4961.         _len = scripts.length;
  4962.         for (;l > i;i++) {
  4963.           node = fragment;
  4964.           if (i !== iNoClone) {
  4965.             node = jQuery.clone(node, true, true);
  4966.             if (_len) {
  4967.               jQuery.merge(scripts, getAll(node, "script"));
  4968.             }
  4969.           }
  4970.           callback.call(this[i], node, i);
  4971.         }
  4972.         if (_len) {
  4973.           doc = scripts[scripts.length - 1].ownerDocument;
  4974.           jQuery.map(scripts, fn);
  4975.           /** @type {number} */
  4976.           i = 0;
  4977.           for (;_len > i;i++) {
  4978.             node = scripts[i];
  4979.             if (stopParent.test(node.type || "")) {
  4980.               if (!data_priv.access(node, "globalEval")) {
  4981.                 if (jQuery.contains(doc, node)) {
  4982.                   if (node.src) {
  4983.                     if (jQuery._evalUrl) {
  4984.                       jQuery._evalUrl(node.src);
  4985.                     }
  4986.                   } else {
  4987.                     jQuery.globalEval(node.textContent.replace(rcleanScript, ""));
  4988.                   }
  4989.                 }
  4990.               }
  4991.             }
  4992.           }
  4993.         }
  4994.       }
  4995.       return this;
  4996.     }
  4997.   });
  4998.   jQuery.each({
  4999.     appendTo : "append",
  5000.     prependTo : "prepend",
  5001.     insertBefore : "before",
  5002.     insertAfter : "after",
  5003.     replaceAll : "replaceWith"
  5004.   }, function(original, method) {
  5005.     /**
  5006.      * @param {string} scripts
  5007.      * @return {?}
  5008.      */
  5009.     jQuery.fn[original] = function(scripts) {
  5010.       var resp;
  5011.       /** @type {Array} */
  5012.       var ret = [];
  5013.       var insert = jQuery(scripts);
  5014.       /** @type {number} */
  5015.       var segments = insert.length - 1;
  5016.       /** @type {number} */
  5017.       var i = 0;
  5018.       for (;segments >= i;i++) {
  5019.         resp = i === segments ? this : this.clone(true);
  5020.         jQuery(insert[i])[method](resp);
  5021.         core_push.apply(ret, resp.get());
  5022.       }
  5023.       return this.pushStack(ret);
  5024.     };
  5025.   });
  5026.   elemdisplay = {};
  5027.   /** @type {RegExp} */
  5028.   var rbracket = /^margin/;
  5029.   /** @type {RegExp} */
  5030.   var regexp = new RegExp("^(" + core_pnum + ")(?!px)[a-z%]+$", "i");
  5031.   /**
  5032.    * @param {Object} elem
  5033.    * @return {?}
  5034.    */
  5035.   var getStyles = function(elem) {
  5036.     return elem.ownerDocument.defaultView.getComputedStyle(elem, null);
  5037.   };
  5038.   !function() {
  5039.     var s;
  5040.     var o;
  5041.     var body = doc.documentElement;
  5042.     var testElement = doc.createElement("div");
  5043.     var div = doc.createElement("div");
  5044.     if (div.style) {
  5045.       /** @type {string} */
  5046.       div.style.backgroundClip = "content-box";
  5047.       /** @type {string} */
  5048.       div.cloneNode(true).style.backgroundClip = "";
  5049.       /** @type {boolean} */
  5050.       support.clearCloneStyle = "content-box" === div.style.backgroundClip;
  5051.       /** @type {string} */
  5052.       testElement.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;position:absolute";
  5053.       testElement.appendChild(div);
  5054.       /**
  5055.        * @return {undefined}
  5056.        */
  5057.       var computePixelPositionAndBoxSizingReliable = function() {
  5058.         /** @type {string} */
  5059.         div.style.cssText = "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;margin-top:1%;top:1%;border:1px;padding:1px;width:4px;position:absolute";
  5060.         /** @type {string} */
  5061.         div.innerHTML = "";
  5062.         body.appendChild(testElement);
  5063.         var divStyle = win.getComputedStyle(div, null);
  5064.         /** @type {boolean} */
  5065.         s = "1%" !== divStyle.top;
  5066.         /** @type {boolean} */
  5067.         o = "4px" === divStyle.width;
  5068.         body.removeChild(testElement);
  5069.       };
  5070.       if (win.getComputedStyle) {
  5071.         jQuery.extend(support, {
  5072.           /**
  5073.            * @return {?}
  5074.            */
  5075.           pixelPosition : function() {
  5076.             return computePixelPositionAndBoxSizingReliable(), s;
  5077.           },
  5078.           /**
  5079.            * @return {?}
  5080.            */
  5081.           boxSizingReliable : function() {
  5082.             return null == o && computePixelPositionAndBoxSizingReliable(), o;
  5083.           },
  5084.           /**
  5085.            * @return {?}
  5086.            */
  5087.           reliableMarginRight : function() {
  5088.             var f;
  5089.             var marginDiv = div.appendChild(doc.createElement("div"));
  5090.             return marginDiv.style.cssText = div.style.cssText = "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0", marginDiv.style.marginRight = marginDiv.style.width = "0", div.style.width = "1px", body.appendChild(testElement), f = !parseFloat(win.getComputedStyle(marginDiv, null).marginRight), body.removeChild(testElement), f;
  5091.           }
  5092.         });
  5093.       }
  5094.     }
  5095.   }();
  5096.   /**
  5097.    * @param {Object} elem
  5098.    * @param {Object} options
  5099.    * @param {Function} callback
  5100.    * @param {Array} args
  5101.    * @return {?}
  5102.    */
  5103.   jQuery.swap = function(elem, options, callback, args) {
  5104.     var ret;
  5105.     var name;
  5106.     var old = {};
  5107.     for (name in options) {
  5108.       old[name] = elem.style[name];
  5109.       elem.style[name] = options[name];
  5110.     }
  5111.     ret = callback.apply(elem, args || []);
  5112.     for (name in options) {
  5113.       elem.style[name] = old[name];
  5114.     }
  5115.     return ret;
  5116.   };
  5117.   /** @type {RegExp} */
  5118.   var rdisplayswap = /^(none|table(?!-c[ea]).+)/;
  5119.   /** @type {RegExp} */
  5120.   var rrelNum = new RegExp("^(" + core_pnum + ")(.*)$", "i");
  5121.   /** @type {RegExp} */
  5122.   var re2 = new RegExp("^([+-])=(" + core_pnum + ")", "i");
  5123.   var props = {
  5124.     position : "absolute",
  5125.     visibility : "hidden",
  5126.     display : "block"
  5127.   };
  5128.   var object = {
  5129.     letterSpacing : "0",
  5130.     fontWeight : "400"
  5131.   };
  5132.   /** @type {Array} */
  5133.   var cssPrefixes = ["Webkit", "O", "Moz", "ms"];
  5134.   jQuery.extend({
  5135.     cssHooks : {
  5136.       opacity : {
  5137.         /**
  5138.          * @param {Object} elem
  5139.          * @param {string} value
  5140.          * @return {?}
  5141.          */
  5142.         get : function(elem, value) {
  5143.           if (value) {
  5144.             var buffer = css(elem, "opacity");
  5145.             return "" === buffer ? "1" : buffer;
  5146.           }
  5147.         }
  5148.       }
  5149.     },
  5150.     cssNumber : {
  5151.       columnCount : true,
  5152.       fillOpacity : true,
  5153.       flexGrow : true,
  5154.       flexShrink : true,
  5155.       fontWeight : true,
  5156.       lineHeight : true,
  5157.       opacity : true,
  5158.       order : true,
  5159.       orphans : true,
  5160.       widows : true,
  5161.       zIndex : true,
  5162.       zoom : true
  5163.     },
  5164.     cssProps : {
  5165.       float : "cssFloat"
  5166.     },
  5167.     /**
  5168.      * @param {Object} elem
  5169.      * @param {string} name
  5170.      * @param {string} val
  5171.      * @param {string} extra
  5172.      * @return {?}
  5173.      */
  5174.     style : function(elem, name, val, extra) {
  5175.       if (elem && (3 !== elem.nodeType && (8 !== elem.nodeType && elem.style))) {
  5176.         var ret;
  5177.         var type;
  5178.         var hooks;
  5179.         var origName = jQuery.camelCase(name);
  5180.         var style = elem.style;
  5181.         return name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName)), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName], void 0 === val ? hooks && ("get" in hooks && void 0 !== (ret = hooks.get(elem, false, extra))) ? ret : style[name] : (type = typeof val, "string" === type && ((ret = re2.exec(val)) && (val = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name)), type = "number")), null != val && (val === val && ("number" !== type || (jQuery.cssNumber[origName] ||
  5182.         (val += "px")), support.clearCloneStyle || ("" !== val || (0 !== name.indexOf("background") || (style[name] = "inherit"))), hooks && ("set" in hooks && void 0 === (val = hooks.set(elem, val, extra))) || (style[name] = val))), void 0);
  5183.       }
  5184.     },
  5185.     /**
  5186.      * @param {Object} elem
  5187.      * @param {string} prop
  5188.      * @param {boolean} recurring
  5189.      * @param {?} key
  5190.      * @return {?}
  5191.      */
  5192.     css : function(elem, prop, recurring, key) {
  5193.       var value;
  5194.       var val;
  5195.       var hooks;
  5196.       var origName = jQuery.camelCase(prop);
  5197.       return prop = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName)), hooks = jQuery.cssHooks[prop] || jQuery.cssHooks[origName], hooks && ("get" in hooks && (value = hooks.get(elem, true, recurring))), void 0 === value && (value = css(elem, prop, key)), "normal" === value && (prop in object && (value = object[prop])), "" === recurring || recurring ? (val = parseFloat(value), recurring === true || jQuery.isNumeric(val) ? val || 0 : value) : value;
  5198.     }
  5199.   });
  5200.   jQuery.each(["height", "width"], function(dataAndEvents, name) {
  5201.     jQuery.cssHooks[name] = {
  5202.       /**
  5203.        * @param {Object} elem
  5204.        * @param {string} value
  5205.        * @param {string} extra
  5206.        * @return {?}
  5207.        */
  5208.       get : function(elem, value, extra) {
  5209.         if (value) {
  5210.           return rdisplayswap.test(jQuery.css(elem, "display")) && 0 === elem.offsetWidth ? jQuery.swap(elem, props, function() {
  5211.             return getWidthOrHeight(elem, name, extra);
  5212.           }) : getWidthOrHeight(elem, name, extra);
  5213.         }
  5214.       },
  5215.       /**
  5216.        * @param {Object} elem
  5217.        * @param {string} value
  5218.        * @param {string} extra
  5219.        * @return {?}
  5220.        */
  5221.       set : function(elem, value, extra) {
  5222.         var styles = extra && getStyles(elem);
  5223.         return setPositiveNumber(elem, value, extra ? augmentWidthOrHeight(elem, name, extra, "border-box" === jQuery.css(elem, "boxSizing", false, styles), styles) : 0);
  5224.       }
  5225.     };
  5226.   });
  5227.   jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight, function(body, dataAndEvents) {
  5228.     if (dataAndEvents) {
  5229.       return jQuery.swap(body, {
  5230.         display : "inline-block"
  5231.       }, css, [body, "marginRight"]);
  5232.     }
  5233.   });
  5234.   jQuery.each({
  5235.     margin : "",
  5236.     padding : "",
  5237.     border : "Width"
  5238.   }, function(prefix, suffix) {
  5239.     jQuery.cssHooks[prefix + suffix] = {
  5240.       /**
  5241.        * @param {string} line
  5242.        * @return {?}
  5243.        */
  5244.       expand : function(line) {
  5245.         /** @type {number} */
  5246.         var i = 0;
  5247.         var expanded = {};
  5248.         /** @type {Array} */
  5249.         var tokens = "string" == typeof line ? line.split(" ") : [line];
  5250.         for (;4 > i;i++) {
  5251.           expanded[prefix + cssExpand[i] + suffix] = tokens[i] || (tokens[i - 2] || tokens[0]);
  5252.         }
  5253.         return expanded;
  5254.       }
  5255.     };
  5256.     if (!rbracket.test(prefix)) {
  5257.       /** @type {function (Object, string, string): ?} */
  5258.       jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
  5259.     }
  5260.   });
  5261.   jQuery.fn.extend({
  5262.     /**
  5263.      * @param {Object} elems
  5264.      * @param {string} value
  5265.      * @return {?}
  5266.      */
  5267.     css : function(elems, value) {
  5268.       return access(this, function(elem, prop, value) {
  5269.         var styles;
  5270.         var _len;
  5271.         var map = {};
  5272.         /** @type {number} */
  5273.         var name = 0;
  5274.         if (jQuery.isArray(prop)) {
  5275.           styles = getStyles(elem);
  5276.           _len = prop.length;
  5277.           for (;_len > name;name++) {
  5278.             map[prop[name]] = jQuery.css(elem, prop[name], false, styles);
  5279.           }
  5280.           return map;
  5281.         }
  5282.         return void 0 !== value ? jQuery.style(elem, prop, value) : jQuery.css(elem, prop);
  5283.       }, elems, value, arguments.length > 1);
  5284.     },
  5285.     /**
  5286.      * @return {?}
  5287.      */
  5288.     show : function() {
  5289.       return showHide(this, true);
  5290.     },
  5291.     /**
  5292.      * @return {?}
  5293.      */
  5294.     hide : function() {
  5295.       return showHide(this);
  5296.     },
  5297.     /**
  5298.      * @param {?} state
  5299.      * @return {?}
  5300.      */
  5301.     toggle : function(state) {
  5302.       return "boolean" == typeof state ? state ? this.show() : this.hide() : this.each(function() {
  5303.         if (isHidden(this)) {
  5304.           jQuery(this).show();
  5305.         } else {
  5306.           jQuery(this).hide();
  5307.         }
  5308.       });
  5309.     }
  5310.   });
  5311.   /** @type {function (string, string, string, string, string): ?} */
  5312.   jQuery.Tween = Tween;
  5313.   Tween.prototype = {
  5314.     /** @type {function (string, string, string, string, string): ?} */
  5315.     constructor : Tween,
  5316.     /**
  5317.      * @param {?} allBindingsAccessor
  5318.      * @param {Object} options
  5319.      * @param {?} prop
  5320.      * @param {number} to
  5321.      * @param {string} easing
  5322.      * @param {string} unit
  5323.      * @return {undefined}
  5324.      */
  5325.     init : function(allBindingsAccessor, options, prop, to, easing, unit) {
  5326.       this.elem = allBindingsAccessor;
  5327.       this.prop = prop;
  5328.       this.easing = easing || "swing";
  5329.       /** @type {Object} */
  5330.       this.options = options;
  5331.       this.start = this.now = this.cur();
  5332.       /** @type {number} */
  5333.       this.end = to;
  5334.       this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
  5335.     },
  5336.     /**
  5337.      * @return {?}
  5338.      */
  5339.     cur : function() {
  5340.       var hooks = Tween.propHooks[this.prop];
  5341.       return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
  5342.     },
  5343.     /**
  5344.      * @param {number} percent
  5345.      * @return {?}
  5346.      */
  5347.     run : function(percent) {
  5348.       var eased;
  5349.       var hooks = Tween.propHooks[this.prop];
  5350.       return this.pos = eased = this.options.duration ? jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : 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;
  5351.     }
  5352.   };
  5353.   Tween.prototype.init.prototype = Tween.prototype;
  5354.   Tween.propHooks = {
  5355.     _default : {
  5356.       /**
  5357.        * @param {Object} elem
  5358.        * @return {?}
  5359.        */
  5360.       get : function(elem) {
  5361.         var node;
  5362.         return null == elem.elem[elem.prop] || elem.elem.style && null != elem.elem.style[elem.prop] ? (node = jQuery.css(elem.elem, elem.prop, ""), node && "auto" !== node ? node : 0) : elem.elem[elem.prop];
  5363.       },
  5364.       /**
  5365.        * @param {Object} tween
  5366.        * @return {undefined}
  5367.        */
  5368.       set : function(tween) {
  5369.         if (jQuery.fx.step[tween.prop]) {
  5370.           jQuery.fx.step[tween.prop](tween);
  5371.         } else {
  5372.           if (tween.elem.style && (null != tween.elem.style[jQuery.cssProps[tween.prop]] || jQuery.cssHooks[tween.prop])) {
  5373.             jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
  5374.           } else {
  5375.             tween.elem[tween.prop] = tween.now;
  5376.           }
  5377.         }
  5378.       }
  5379.     }
  5380.   };
  5381.   Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  5382.     /**
  5383.      * @param {Object} elem
  5384.      * @return {undefined}
  5385.      */
  5386.     set : function(elem) {
  5387.       if (elem.elem.nodeType) {
  5388.         if (elem.elem.parentNode) {
  5389.           elem.elem[elem.prop] = elem.now;
  5390.         }
  5391.       }
  5392.     }
  5393.   };
  5394.   jQuery.easing = {
  5395.     /**
  5396.      * @param {?} t
  5397.      * @return {?}
  5398.      */
  5399.     linear : function(t) {
  5400.       return t;
  5401.     },
  5402.     /**
  5403.      * @param {number} p
  5404.      * @return {?}
  5405.      */
  5406.     swing : function(p) {
  5407.       return 0.5 - Math.cos(p * Math.PI) / 2;
  5408.     }
  5409.   };
  5410.   /** @type {function (?, Object, ?, number, string, string): undefined} */
  5411.   jQuery.fx = Tween.prototype.init;
  5412.   jQuery.fx.step = {};
  5413.   var fxNow;
  5414.   var scrollIntervalId;
  5415.   /** @type {RegExp} */
  5416.   var rplusequals = /^(?:toggle|show|hide)$/;
  5417.   /** @type {RegExp} */
  5418.   var rfxnum = new RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i");
  5419.   /** @type {RegExp} */
  5420.   var numbers = /queueHooks$/;
  5421.   /** @type {Array} */
  5422.   var animationPrefilters = [defaultPrefilter];
  5423.   var cache = {
  5424.     "*" : [function(prop, value) {
  5425.       var tween = this.createTween(prop, value);
  5426.       var l0 = tween.cur();
  5427.       /** @type {(Array.<string>|null)} */
  5428.       var parts = rfxnum.exec(value);
  5429.       /** @type {string} */
  5430.       var unit = parts && parts[3] || (jQuery.cssNumber[prop] ? "" : "px");
  5431.       var start = (jQuery.cssNumber[prop] || "px" !== unit && +l0) && rfxnum.exec(jQuery.css(tween.elem, prop));
  5432.       /** @type {number} */
  5433.       var scale = 1;
  5434.       /** @type {number} */
  5435.       var h = 20;
  5436.       if (start && start[3] !== unit) {
  5437.         unit = unit || start[3];
  5438.         /** @type {Array} */
  5439.         parts = parts || [];
  5440.         /** @type {number} */
  5441.         start = +l0 || 1;
  5442.         do {
  5443.           /** @type {(number|string)} */
  5444.           scale = scale || ".5";
  5445.           start /= scale;
  5446.           jQuery.style(tween.elem, prop, start + unit);
  5447.         } while (scale !== (scale = tween.cur() / l0) && (1 !== scale && --h));
  5448.       }
  5449.       return parts && (start = tween.start = +start || (+l0 || 0), tween.unit = unit, tween.end = parts[1] ? start + (parts[1] + 1) * parts[2] : +parts[2]), tween;
  5450.     }]
  5451.   };
  5452.   jQuery.Animation = jQuery.extend(Animation, {
  5453.     /**
  5454.      * @param {Object} html
  5455.      * @param {Function} callback
  5456.      * @return {undefined}
  5457.      */
  5458.     tweener : function(html, callback) {
  5459.       if (jQuery.isFunction(html)) {
  5460.         /** @type {Object} */
  5461.         callback = html;
  5462.         /** @type {Array} */
  5463.         html = ["*"];
  5464.       } else {
  5465.         html = html.split(" ");
  5466.       }
  5467.       var c;
  5468.       /** @type {number} */
  5469.       var x = 0;
  5470.       var w = html.length;
  5471.       for (;w > x;x++) {
  5472.         c = html[x];
  5473.         cache[c] = cache[c] || [];
  5474.         cache[c].unshift(callback);
  5475.       }
  5476.     },
  5477.     /**
  5478.      * @param {?} callback
  5479.      * @param {?} prepend
  5480.      * @return {undefined}
  5481.      */
  5482.     prefilter : function(callback, prepend) {
  5483.       if (prepend) {
  5484.         animationPrefilters.unshift(callback);
  5485.       } else {
  5486.         animationPrefilters.push(callback);
  5487.       }
  5488.     }
  5489.   });
  5490.   /**
  5491.    * @param {string} speed
  5492.    * @param {string} easing
  5493.    * @param {Object} fn
  5494.    * @return {?}
  5495.    */
  5496.   jQuery.speed = function(speed, easing, fn) {
  5497.     var opt = speed && "object" == typeof speed ? jQuery.extend({}, speed) : {
  5498.       complete : fn || (!fn && easing || jQuery.isFunction(speed) && speed),
  5499.       duration : speed,
  5500.       easing : fn && easing || easing && (!jQuery.isFunction(easing) && easing)
  5501.     };
  5502.     return opt.duration = jQuery.fx.off ? 0 : "number" == typeof opt.duration ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default, (null == opt.queue || opt.queue === true) && (opt.queue = "fx"), opt.old = opt.complete, opt.complete = function() {
  5503.       if (jQuery.isFunction(opt.old)) {
  5504.         opt.old.call(this);
  5505.       }
  5506.       if (opt.queue) {
  5507.         jQuery.dequeue(this, opt.queue);
  5508.       }
  5509.     }, opt;
  5510.   };
  5511.   jQuery.fn.extend({
  5512.     /**
  5513.      * @param {string} speed
  5514.      * @param {number} to
  5515.      * @param {string} callback
  5516.      * @param {Object} _callback
  5517.      * @return {?}
  5518.      */
  5519.     fadeTo : function(speed, to, callback, _callback) {
  5520.       return this.filter(isHidden).css("opacity", 0).show().end().animate({
  5521.         opacity : to
  5522.       }, speed, callback, _callback);
  5523.     },
  5524.     /**
  5525.      * @param {?} prop
  5526.      * @param {string} speed
  5527.      * @param {string} easing
  5528.      * @param {Object} callback
  5529.      * @return {?}
  5530.      */
  5531.     animate : function(prop, speed, easing, callback) {
  5532.       var empty = jQuery.isEmptyObject(prop);
  5533.       var optall = jQuery.speed(speed, easing, callback);
  5534.       /**
  5535.        * @return {undefined}
  5536.        */
  5537.       var doAnimation = function() {
  5538.         var anim = Animation(this, jQuery.extend({}, prop), optall);
  5539.         if (empty || data_priv.get(this, "finish")) {
  5540.           anim.stop(true);
  5541.         }
  5542.       };
  5543.       return doAnimation.finish = doAnimation, empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
  5544.     },
  5545.     /**
  5546.      * @param {Object} type
  5547.      * @param {Object} clearQueue
  5548.      * @param {Object} gotoEnd
  5549.      * @return {?}
  5550.      */
  5551.     stop : function(type, clearQueue, gotoEnd) {
  5552.       /**
  5553.        * @param {Object} e
  5554.        * @return {undefined}
  5555.        */
  5556.       var stop = function(e) {
  5557.         var stop = e.stop;
  5558.         delete e.stop;
  5559.         stop(gotoEnd);
  5560.       };
  5561.       return "string" != typeof type && (gotoEnd = clearQueue, clearQueue = type, type = void 0), clearQueue && (type !== false && this.queue(type || "fx", [])), this.each(function() {
  5562.         /** @type {boolean} */
  5563.         var dequeue = true;
  5564.         var i = null != type && type + "queueHooks";
  5565.         /** @type {Array} */
  5566.         var timers = jQuery.timers;
  5567.         var gradient = data_priv.get(this);
  5568.         if (i) {
  5569.           if (gradient[i]) {
  5570.             if (gradient[i].stop) {
  5571.               stop(gradient[i]);
  5572.             }
  5573.           }
  5574.         } else {
  5575.           for (i in gradient) {
  5576.             if (gradient[i]) {
  5577.               if (gradient[i].stop) {
  5578.                 if (numbers.test(i)) {
  5579.                   stop(gradient[i]);
  5580.                 }
  5581.               }
  5582.             }
  5583.           }
  5584.         }
  5585.         /** @type {number} */
  5586.         i = timers.length;
  5587.         for (;i--;) {
  5588.           if (!(timers[i].elem !== this)) {
  5589.             if (!(null != type && timers[i].queue !== type)) {
  5590.               timers[i].anim.stop(gotoEnd);
  5591.               /** @type {boolean} */
  5592.               dequeue = false;
  5593.               timers.splice(i, 1);
  5594.             }
  5595.           }
  5596.         }
  5597.         if (dequeue || !gotoEnd) {
  5598.           jQuery.dequeue(this, type);
  5599.         }
  5600.       });
  5601.     },
  5602.     /**
  5603.      * @param {string} type
  5604.      * @return {?}
  5605.      */
  5606.     finish : function(type) {
  5607.       return type !== false && (type = type || "fx"), this.each(function() {
  5608.         var index;
  5609.         var data = data_priv.get(this);
  5610.         var array = data[type + "queue"];
  5611.         var event = data[type + "queueHooks"];
  5612.         /** @type {Array} */
  5613.         var timers = jQuery.timers;
  5614.         var length = array ? array.length : 0;
  5615.         /** @type {boolean} */
  5616.         data.finish = true;
  5617.         jQuery.queue(this, type, []);
  5618.         if (event) {
  5619.           if (event.stop) {
  5620.             event.stop.call(this, true);
  5621.           }
  5622.         }
  5623.         /** @type {number} */
  5624.         index = timers.length;
  5625.         for (;index--;) {
  5626.           if (timers[index].elem === this) {
  5627.             if (timers[index].queue === type) {
  5628.               timers[index].anim.stop(true);
  5629.               timers.splice(index, 1);
  5630.             }
  5631.           }
  5632.         }
  5633.         /** @type {number} */
  5634.         index = 0;
  5635.         for (;length > index;index++) {
  5636.           if (array[index]) {
  5637.             if (array[index].finish) {
  5638.               array[index].finish.call(this);
  5639.             }
  5640.           }
  5641.         }
  5642.         delete data.finish;
  5643.       });
  5644.     }
  5645.   });
  5646.   jQuery.each(["toggle", "show", "hide"], function(dataAndEvents, name) {
  5647.     var matcherFunction = jQuery.fn[name];
  5648.     /**
  5649.      * @param {string} speed
  5650.      * @param {string} callback
  5651.      * @param {Object} next_callback
  5652.      * @return {?}
  5653.      */
  5654.     jQuery.fn[name] = function(speed, callback, next_callback) {
  5655.       return null == speed || "boolean" == typeof speed ? matcherFunction.apply(this, arguments) : this.animate(genFx(name, true), speed, callback, next_callback);
  5656.     };
  5657.   });
  5658.   jQuery.each({
  5659.     slideDown : genFx("show"),
  5660.     slideUp : genFx("hide"),
  5661.     slideToggle : genFx("toggle"),
  5662.     fadeIn : {
  5663.       opacity : "show"
  5664.     },
  5665.     fadeOut : {
  5666.       opacity : "hide"
  5667.     },
  5668.     fadeToggle : {
  5669.       opacity : "toggle"
  5670.     }
  5671.   }, function(original, props) {
  5672.     /**
  5673.      * @param {string} speed
  5674.      * @param {string} callback
  5675.      * @param {Object} next_callback
  5676.      * @return {?}
  5677.      */
  5678.     jQuery.fn[original] = function(speed, callback, next_callback) {
  5679.       return this.animate(props, speed, callback, next_callback);
  5680.     };
  5681.   });
  5682.   /** @type {Array} */
  5683.   jQuery.timers = [];
  5684.   /**
  5685.    * @return {undefined}
  5686.    */
  5687.   jQuery.fx.tick = function() {
  5688.     var last;
  5689.     /** @type {number} */
  5690.     var i = 0;
  5691.     /** @type {Array} */
  5692.     var timers = jQuery.timers;
  5693.     fxNow = jQuery.now();
  5694.     for (;i < timers.length;i++) {
  5695.       last = timers[i];
  5696.       if (!last()) {
  5697.         if (!(timers[i] !== last)) {
  5698.           timers.splice(i--, 1);
  5699.         }
  5700.       }
  5701.     }
  5702.     if (!timers.length) {
  5703.       jQuery.fx.stop();
  5704.     }
  5705.     fxNow = void 0;
  5706.   };
  5707.   /**
  5708.    * @param {?} timer
  5709.    * @return {undefined}
  5710.    */
  5711.   jQuery.fx.timer = function(timer) {
  5712.     jQuery.timers.push(timer);
  5713.     if (timer()) {
  5714.       jQuery.fx.start();
  5715.     } else {
  5716.       jQuery.timers.pop();
  5717.     }
  5718.   };
  5719.   /** @type {number} */
  5720.   jQuery.fx.interval = 13;
  5721.   /**
  5722.    * @return {undefined}
  5723.    */
  5724.   jQuery.fx.start = function() {
  5725.     if (!scrollIntervalId) {
  5726.       /** @type {number} */
  5727.       scrollIntervalId = setInterval(jQuery.fx.tick, jQuery.fx.interval);
  5728.     }
  5729.   };
  5730.   /**
  5731.    * @return {undefined}
  5732.    */
  5733.   jQuery.fx.stop = function() {
  5734.     clearInterval(scrollIntervalId);
  5735.     /** @type {null} */
  5736.     scrollIntervalId = null;
  5737.   };
  5738.   jQuery.fx.speeds = {
  5739.     slow : 600,
  5740.     fast : 200,
  5741.     _default : 400
  5742.   };
  5743.   /**
  5744.    * @param {HTMLElement} time
  5745.    * @param {string} type
  5746.    * @return {?}
  5747.    */
  5748.   jQuery.fn.delay = function(time, type) {
  5749.     return time = jQuery.fx ? jQuery.fx.speeds[time] || time : time, type = type || "fx", this.queue(type, function(next, event) {
  5750.       /** @type {number} */
  5751.       var timeout = setTimeout(next, time);
  5752.       /**
  5753.        * @return {undefined}
  5754.        */
  5755.       event.stop = function() {
  5756.         clearTimeout(timeout);
  5757.       };
  5758.     });
  5759.   };
  5760.   (function() {
  5761.     var input = doc.createElement("input");
  5762.     var select = doc.createElement("select");
  5763.     var opt = select.appendChild(doc.createElement("option"));
  5764.     /** @type {string} */
  5765.     input.type = "checkbox";
  5766.     /** @type {boolean} */
  5767.     support.checkOn = "" !== input.value;
  5768.     support.optSelected = opt.selected;
  5769.     /** @type {boolean} */
  5770.     select.disabled = true;
  5771.     /** @type {boolean} */
  5772.     support.optDisabled = !opt.disabled;
  5773.     input = doc.createElement("input");
  5774.     /** @type {string} */
  5775.     input.value = "t";
  5776.     /** @type {string} */
  5777.     input.type = "radio";
  5778.     /** @type {boolean} */
  5779.     support.radioValue = "t" === input.value;
  5780.   })();
  5781.   values = jQuery.expr.attrHandle;
  5782.   jQuery.fn.extend({
  5783.     /**
  5784.      * @param {string} name
  5785.      * @param {string} value
  5786.      * @return {?}
  5787.      */
  5788.     attr : function(name, value) {
  5789.       return access(this, jQuery.attr, name, value, arguments.length > 1);
  5790.     },
  5791.     /**
  5792.      * @param {string} name
  5793.      * @return {?}
  5794.      */
  5795.     removeAttr : function(name) {
  5796.       return this.each(function() {
  5797.         jQuery.removeAttr(this, name);
  5798.       });
  5799.     }
  5800.   });
  5801.   jQuery.extend({
  5802.     /**
  5803.      * @param {Object} elem
  5804.      * @param {string} name
  5805.      * @param {Object} value
  5806.      * @return {?}
  5807.      */
  5808.     attr : function(elem, name, value) {
  5809.       var hooks;
  5810.       var ret;
  5811.       var nodeType = elem.nodeType;
  5812.       if (elem && (3 !== nodeType && (8 !== nodeType && 2 !== nodeType))) {
  5813.         return typeof elem.getAttribute === memory ? jQuery.prop(elem, name, value) : (1 === nodeType && jQuery.isXMLDoc(elem) || (name = name.toLowerCase(), hooks = jQuery.attrHooks[name] || (jQuery.expr.match.bool.test(name) ? boolHook : nodeHook)), void 0 === value ? hooks && ("get" in hooks && null !== (ret = hooks.get(elem, name))) ? ret : (ret = jQuery.find.attr(elem, name), null == ret ? void 0 : ret) : null !== value ? hooks && ("set" in hooks && void 0 !== (ret = hooks.set(elem, value, name))) ?
  5814.         ret : (elem.setAttribute(name, value + ""), value) : void jQuery.removeAttr(elem, name));
  5815.       }
  5816.     },
  5817.     /**
  5818.      * @param {Object} elem
  5819.      * @param {string} value
  5820.      * @return {undefined}
  5821.      */
  5822.     removeAttr : function(elem, value) {
  5823.       var name;
  5824.       var propName;
  5825.       /** @type {number} */
  5826.       var i = 0;
  5827.       var attrNames = value && value.match(core_rnotwhite);
  5828.       if (attrNames && 1 === elem.nodeType) {
  5829.         for (;name = attrNames[i++];) {
  5830.           propName = jQuery.propFix[name] || name;
  5831.           if (jQuery.expr.match.bool.test(name)) {
  5832.             /** @type {boolean} */
  5833.             elem[propName] = false;
  5834.           }
  5835.           elem.removeAttribute(name);
  5836.         }
  5837.       }
  5838.     },
  5839.     attrHooks : {
  5840.       type : {
  5841.         /**
  5842.          * @param {Object} elem
  5843.          * @param {string} value
  5844.          * @return {?}
  5845.          */
  5846.         set : function(elem, value) {
  5847.           if (!support.radioValue && ("radio" === value && jQuery.nodeName(elem, "input"))) {
  5848.             var val = elem.value;
  5849.             return elem.setAttribute("type", value), val && (elem.value = val), value;
  5850.           }
  5851.         }
  5852.       }
  5853.     }
  5854.   });
  5855.   boolHook = {
  5856.     /**
  5857.      * @param {Object} elem
  5858.      * @param {string} value
  5859.      * @param {string} name
  5860.      * @return {?}
  5861.      */
  5862.     set : function(elem, value, name) {
  5863.       return value === false ? jQuery.removeAttr(elem, name) : elem.setAttribute(name, name), name;
  5864.     }
  5865.   };
  5866.   jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(dataAndEvents, name) {
  5867.     var callback = values[name] || jQuery.find.attr;
  5868.     /**
  5869.      * @param {string} body
  5870.      * @param {string} key
  5871.      * @param {Object} arg
  5872.      * @return {?}
  5873.      */
  5874.     values[name] = function(body, key, arg) {
  5875.       var result;
  5876.       var value;
  5877.       return arg || (value = values[key], values[key] = result, result = null != callback(body, key, arg) ? key.toLowerCase() : null, values[key] = value), result;
  5878.     };
  5879.   });
  5880.   /** @type {RegExp} */
  5881.   rfocusable = /^(?:input|select|textarea|button)$/i;
  5882.   jQuery.fn.extend({
  5883.     /**
  5884.      * @param {string} name
  5885.      * @param {string} value
  5886.      * @return {?}
  5887.      */
  5888.     prop : function(name, value) {
  5889.       return access(this, jQuery.prop, name, value, arguments.length > 1);
  5890.     },
  5891.     /**
  5892.      * @param {?} name
  5893.      * @return {?}
  5894.      */
  5895.     removeProp : function(name) {
  5896.       return this.each(function() {
  5897.         delete this[jQuery.propFix[name] || name];
  5898.       });
  5899.     }
  5900.   });
  5901.   jQuery.extend({
  5902.     propFix : {
  5903.       "for" : "htmlFor",
  5904.       "class" : "className"
  5905.     },
  5906.     /**
  5907.      * @param {Object} elem
  5908.      * @param {string} name
  5909.      * @param {string} value
  5910.      * @return {?}
  5911.      */
  5912.     prop : function(elem, name, value) {
  5913.       var ret;
  5914.       var hooks;
  5915.       var n;
  5916.       var nodeType = elem.nodeType;
  5917.       if (elem && (3 !== nodeType && (8 !== nodeType && 2 !== nodeType))) {
  5918.         return n = 1 !== nodeType || !jQuery.isXMLDoc(elem), n && (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];
  5919.       }
  5920.     },
  5921.     propHooks : {
  5922.       tabIndex : {
  5923.         /**
  5924.          * @param {Object} elem
  5925.          * @return {?}
  5926.          */
  5927.         get : function(elem) {
  5928.           return elem.hasAttribute("tabindex") || (rfocusable.test(elem.nodeName) || elem.href) ? elem.tabIndex : -1;
  5929.         }
  5930.       }
  5931.     }
  5932.   });
  5933.   if (!support.optSelected) {
  5934.     jQuery.propHooks.selected = {
  5935.       /**
  5936.        * @param {Object} elem
  5937.        * @return {?}
  5938.        */
  5939.       get : function(elem) {
  5940.         var parent = elem.parentNode;
  5941.         return parent && (parent.parentNode && parent.parentNode.selectedIndex), null;
  5942.       }
  5943.     };
  5944.   }
  5945.   jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
  5946.     jQuery.propFix[this.toLowerCase()] = this;
  5947.   });
  5948.   /** @type {RegExp} */
  5949.   rclass = /[\t\r\n\f]/g;
  5950.   jQuery.fn.extend({
  5951.     /**
  5952.      * @param {string} value
  5953.      * @return {?}
  5954.      */
  5955.     addClass : function(value) {
  5956.       var classes;
  5957.       var elem;
  5958.       var cur;
  5959.       var clazz;
  5960.       var j;
  5961.       var finalValue;
  5962.       /** @type {(boolean|string)} */
  5963.       var proceed = "string" == typeof value && value;
  5964.       /** @type {number} */
  5965.       var i = 0;
  5966.       var l = this.length;
  5967.       if (jQuery.isFunction(value)) {
  5968.         return this.each(function(j) {
  5969.           jQuery(this).addClass(value.call(this, j, this.className));
  5970.         });
  5971.       }
  5972.       if (proceed) {
  5973.         classes = (value || "").match(core_rnotwhite) || [];
  5974.         for (;l > i;i++) {
  5975.           if (elem = this[i], cur = 1 === elem.nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : " ")) {
  5976.             /** @type {number} */
  5977.             j = 0;
  5978.             for (;clazz = classes[j++];) {
  5979.               if (cur.indexOf(" " + clazz + " ") < 0) {
  5980.                 cur += clazz + " ";
  5981.               }
  5982.             }
  5983.             finalValue = jQuery.trim(cur);
  5984.             if (elem.className !== finalValue) {
  5985.               elem.className = finalValue;
  5986.             }
  5987.           }
  5988.         }
  5989.       }
  5990.       return this;
  5991.     },
  5992.     /**
  5993.      * @param {string} value
  5994.      * @return {?}
  5995.      */
  5996.     removeClass : function(value) {
  5997.       var map;
  5998.       var elem;
  5999.       var cur;
  6000.       var val;
  6001.       var k;
  6002.       var finalValue;
  6003.       /** @type {(boolean|string)} */
  6004.       var h = 0 === arguments.length || "string" == typeof value && value;
  6005.       /** @type {number} */
  6006.       var i = 0;
  6007.       var l = this.length;
  6008.       if (jQuery.isFunction(value)) {
  6009.         return this.each(function(j) {
  6010.           jQuery(this).removeClass(value.call(this, j, this.className));
  6011.         });
  6012.       }
  6013.       if (h) {
  6014.         map = (value || "").match(core_rnotwhite) || [];
  6015.         for (;l > i;i++) {
  6016.           if (elem = this[i], cur = 1 === elem.nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : "")) {
  6017.             /** @type {number} */
  6018.             k = 0;
  6019.             for (;val = map[k++];) {
  6020.               for (;cur.indexOf(" " + val + " ") >= 0;) {
  6021.                 /** @type {string} */
  6022.                 cur = cur.replace(" " + val + " ", " ");
  6023.               }
  6024.             }
  6025.             finalValue = value ? jQuery.trim(cur) : "";
  6026.             if (elem.className !== finalValue) {
  6027.               elem.className = finalValue;
  6028.             }
  6029.           }
  6030.         }
  6031.       }
  6032.       return this;
  6033.     },
  6034.     /**
  6035.      * @param {string} value
  6036.      * @param {?} stateVal
  6037.      * @return {?}
  6038.      */
  6039.     toggleClass : function(value, stateVal) {
  6040.       /** @type {string} */
  6041.       var type = typeof value;
  6042.       return "boolean" == typeof stateVal && "string" === type ? stateVal ? this.addClass(value) : this.removeClass(value) : this.each(jQuery.isFunction(value) ? function(i) {
  6043.         jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
  6044.       } : function() {
  6045.         if ("string" === type) {
  6046.           var className;
  6047.           /** @type {number} */
  6048.           var i = 0;
  6049.           var self = jQuery(this);
  6050.           var classNames = value.match(core_rnotwhite) || [];
  6051.           for (;className = classNames[i++];) {
  6052.             if (self.hasClass(className)) {
  6053.               self.removeClass(className);
  6054.             } else {
  6055.               self.addClass(className);
  6056.             }
  6057.           }
  6058.         } else {
  6059.           if (type === memory || "boolean" === type) {
  6060.             if (this.className) {
  6061.               data_priv.set(this, "__className__", this.className);
  6062.             }
  6063.             this.className = this.className || value === false ? "" : data_priv.get(this, "__className__") || "";
  6064.           }
  6065.         }
  6066.       });
  6067.     },
  6068.     /**
  6069.      * @param {string} name
  6070.      * @return {?}
  6071.      */
  6072.     hasClass : function(name) {
  6073.       /** @type {string} */
  6074.       var expectation = " " + name + " ";
  6075.       /** @type {number} */
  6076.       var i = 0;
  6077.       var l = this.length;
  6078.       for (;l > i;i++) {
  6079.         if (1 === this[i].nodeType && (" " + this[i].className + " ").replace(rclass, " ").indexOf(expectation) >= 0) {
  6080.           return true;
  6081.         }
  6082.       }
  6083.       return false;
  6084.     }
  6085.   });
  6086.   /** @type {RegExp} */
  6087.   rreturn = /\r/g;
  6088.   jQuery.fn.extend({
  6089.     /**
  6090.      * @param {Function} value
  6091.      * @return {?}
  6092.      */
  6093.     val : function(value) {
  6094.       var hooks;
  6095.       var ret;
  6096.       var isFunction;
  6097.       var elem = this[0];
  6098.       return arguments.length ? (isFunction = jQuery.isFunction(value), this.each(function(i) {
  6099.         var val;
  6100.         if (1 === this.nodeType) {
  6101.           val = isFunction ? value.call(this, i, jQuery(this).val()) : value;
  6102.           if (null == val) {
  6103.             /** @type {string} */
  6104.             val = "";
  6105.           } else {
  6106.             if ("number" == typeof val) {
  6107.               val += "";
  6108.             } else {
  6109.               if (jQuery.isArray(val)) {
  6110.                 val = jQuery.map(val, function(month) {
  6111.                   return null == month ? "" : month + "";
  6112.                 });
  6113.               }
  6114.             }
  6115.           }
  6116.           hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
  6117.           if (!(hooks && ("set" in hooks && void 0 !== hooks.set(this, val, "value")))) {
  6118.             this.value = val;
  6119.           }
  6120.         }
  6121.       })) : elem ? (hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()], hooks && ("get" in hooks && void 0 !== (ret = hooks.get(elem, "value"))) ? ret : (ret = elem.value, "string" == typeof ret ? ret.replace(rreturn, "") : null == ret ? "" : ret)) : void 0;
  6122.     }
  6123.   });
  6124.   jQuery.extend({
  6125.     valHooks : {
  6126.       option : {
  6127.         /**
  6128.          * @param {Object} elem
  6129.          * @return {?}
  6130.          */
  6131.         get : function(elem) {
  6132.           var handle = jQuery.find.attr(elem, "value");
  6133.           return null != handle ? handle : jQuery.trim(jQuery.text(elem));
  6134.         }
  6135.       },
  6136.       select : {
  6137.         /**
  6138.          * @param {Object} elem
  6139.          * @return {?}
  6140.          */
  6141.         get : function(elem) {
  6142.           var copies;
  6143.           var option;
  6144.           var options = elem.options;
  6145.           var index = elem.selectedIndex;
  6146.           /** @type {boolean} */
  6147.           var one = "select-one" === elem.type || 0 > index;
  6148.           /** @type {(Array|null)} */
  6149.           var out = one ? null : [];
  6150.           var max = one ? index + 1 : options.length;
  6151.           var i = 0 > index ? max : one ? index : 0;
  6152.           for (;max > i;i++) {
  6153.             if (option = options[i], !(!option.selected && i !== index || ((support.optDisabled ? option.disabled : null !== option.getAttribute("disabled")) || option.parentNode.disabled && jQuery.nodeName(option.parentNode, "optgroup")))) {
  6154.               if (copies = jQuery(option).val(), one) {
  6155.                 return copies;
  6156.               }
  6157.               out.push(copies);
  6158.             }
  6159.           }
  6160.           return out;
  6161.         },
  6162.         /**
  6163.          * @param {Object} elem
  6164.          * @param {string} value
  6165.          * @return {?}
  6166.          */
  6167.         set : function(elem, value) {
  6168.           var u;
  6169.           var option;
  6170.           var options = elem.options;
  6171.           var values = jQuery.makeArray(value);
  6172.           var i = options.length;
  6173.           for (;i--;) {
  6174.             option = options[i];
  6175.             if (option.selected = jQuery.inArray(option.value, values) >= 0) {
  6176.               /** @type {boolean} */
  6177.               u = true;
  6178.             }
  6179.           }
  6180.           return u || (elem.selectedIndex = -1), values;
  6181.         }
  6182.       }
  6183.     }
  6184.   });
  6185.   jQuery.each(["radio", "checkbox"], function() {
  6186.     jQuery.valHooks[this] = {
  6187.       /**
  6188.        * @param {Object} elem
  6189.        * @param {string} value
  6190.        * @return {?}
  6191.        */
  6192.       set : function(elem, value) {
  6193.         if (jQuery.isArray(value)) {
  6194.           return elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0;
  6195.         }
  6196.       }
  6197.     };
  6198.     if (!support.checkOn) {
  6199.       /**
  6200.        * @param {Object} elem
  6201.        * @return {?}
  6202.        */
  6203.       jQuery.valHooks[this].get = function(elem) {
  6204.         return null === elem.getAttribute("value") ? "on" : elem.value;
  6205.       };
  6206.     }
  6207.   });
  6208.   jQuery.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "), function(dataAndEvents, name) {
  6209.     /**
  6210.      * @param {Function} data
  6211.      * @param {Function} fn
  6212.      * @return {?}
  6213.      */
  6214.     jQuery.fn[name] = function(data, fn) {
  6215.       return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
  6216.     };
  6217.   });
  6218.   jQuery.fn.extend({
  6219.     /**
  6220.      * @param {undefined} fnOver
  6221.      * @param {Object} fnOut
  6222.      * @return {?}
  6223.      */
  6224.     hover : function(fnOver, fnOut) {
  6225.       return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
  6226.     },
  6227.     /**
  6228.      * @param {string} types
  6229.      * @param {Function} data
  6230.      * @param {Function} fn
  6231.      * @return {?}
  6232.      */
  6233.     bind : function(types, data, fn) {
  6234.       return this.on(types, null, data, fn);
  6235.     },
  6236.     /**
  6237.      * @param {Object} types
  6238.      * @param {Function} fn
  6239.      * @return {?}
  6240.      */
  6241.     unbind : function(types, fn) {
  6242.       return this.off(types, null, fn);
  6243.     },
  6244.     /**
  6245.      * @param {Function} selector
  6246.      * @param {string} types
  6247.      * @param {Function} data
  6248.      * @param {Function} fn
  6249.      * @return {?}
  6250.      */
  6251.     delegate : function(selector, types, data, fn) {
  6252.       return this.on(types, selector, data, fn);
  6253.     },
  6254.     /**
  6255.      * @param {string} selector
  6256.      * @param {Object} types
  6257.      * @param {Function} fn
  6258.      * @return {?}
  6259.      */
  6260.     undelegate : function(selector, types, fn) {
  6261.       return 1 === arguments.length ? this.off(selector, "**") : this.off(types, selector || "**", fn);
  6262.     }
  6263.   });
  6264.   iIdCounter = jQuery.now();
  6265.   /** @type {RegExp} */
  6266.   rquery = /\?/;
  6267.   /**
  6268.    * @param {Object} str
  6269.    * @return {?}
  6270.    */
  6271.   jQuery.parseJSON = function(str) {
  6272.     return JSON.parse(str + "");
  6273.   };
  6274.   /**
  6275.    * @param {string} data
  6276.    * @return {?}
  6277.    */
  6278.   jQuery.parseXML = function(data) {
  6279.     var xml;
  6280.     var tmp;
  6281.     if (!data || "string" != typeof data) {
  6282.       return null;
  6283.     }
  6284.     try {
  6285.       /** @type {DOMParser} */
  6286.       tmp = new DOMParser;
  6287.       /** @type {(Document|null)} */
  6288.       xml = tmp.parseFromString(data, "text/xml");
  6289.     } catch (u) {
  6290.       xml = void 0;
  6291.     }
  6292.     return(!xml || xml.getElementsByTagName("parsererror").length) && jQuery.error("Invalid XML: " + data), xml;
  6293.   };
  6294.   var match;
  6295.   var ajaxLocation;
  6296.   /** @type {RegExp} */
  6297.   var currDirRegExp = /#.*$/;
  6298.   /** @type {RegExp} */
  6299.   var rts = /([?&])_=[^&]*/;
  6300.   /** @type {RegExp} */
  6301.   var r = /^(.*?):[ \t]*([^\r\n]*)$/gm;
  6302.   /** @type {RegExp} */
  6303.   var rnoContent = /^(?:GET|HEAD)$/;
  6304.   /** @type {RegExp} */
  6305.   var rprotocol = /^\/\//;
  6306.   /** @type {RegExp} */
  6307.   var quickExpr = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/;
  6308.   var prefilters = {};
  6309.   var transports = {};
  6310.   /** @type {string} */
  6311.   var yu = "*/".concat("*");
  6312.   try {
  6313.     /** @type {string} */
  6314.     ajaxLocation = location.href;
  6315.   } catch (ge) {
  6316.     ajaxLocation = doc.createElement("a");
  6317.     /** @type {string} */
  6318.     ajaxLocation.href = "";
  6319.     /** @type {string} */
  6320.     ajaxLocation = ajaxLocation.href;
  6321.   }
  6322.   /** @type {Array} */
  6323.   match = quickExpr.exec(ajaxLocation.toLowerCase()) || [];
  6324.   jQuery.extend({
  6325.     active : 0,
  6326.     lastModified : {},
  6327.     etag : {},
  6328.     ajaxSettings : {
  6329.       url : ajaxLocation,
  6330.       type : "GET",
  6331.       isLocal : /^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(match[1]),
  6332.       global : true,
  6333.       processData : true,
  6334.       async : true,
  6335.       contentType : "application/x-www-form-urlencoded; charset=UTF-8",
  6336.       accepts : {
  6337.         "*" : yu,
  6338.         text : "text/plain",
  6339.         html : "text/html",
  6340.         xml : "application/xml, text/xml",
  6341.         json : "application/json, text/javascript"
  6342.       },
  6343.       contents : {
  6344.         xml : /xml/,
  6345.         html : /html/,
  6346.         json : /json/
  6347.       },
  6348.       responseFields : {
  6349.         xml : "responseXML",
  6350.         text : "responseText",
  6351.         json : "responseJSON"
  6352.       },
  6353.       converters : {
  6354.         /** @type {function (new:String, *=): string} */
  6355.         "* text" : String,
  6356.         "text html" : true,
  6357.         /** @type {function (Object): ?} */
  6358.         "text json" : jQuery.parseJSON,
  6359.         /** @type {function (string): ?} */
  6360.         "text xml" : jQuery.parseXML
  6361.       },
  6362.       flatOptions : {
  6363.         url : true,
  6364.         context : true
  6365.       }
  6366.     },
  6367.     /**
  6368.      * @param {(Object|string)} target
  6369.      * @param {Object} settings
  6370.      * @return {?}
  6371.      */
  6372.     ajaxSetup : function(target, settings) {
  6373.       return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
  6374.     },
  6375.     ajaxPrefilter : addToPrefiltersOrTransports(prefilters),
  6376.     ajaxTransport : addToPrefiltersOrTransports(transports),
  6377.     /**
  6378.      * @param {Object} url
  6379.      * @param {Object} options
  6380.      * @return {?}
  6381.      */
  6382.     ajax : function(url, options) {
  6383.       /**
  6384.        * @param {number} status
  6385.        * @param {(number|string)} nativeStatusText
  6386.        * @param {Object} responses
  6387.        * @param {string} total
  6388.        * @return {undefined}
  6389.        */
  6390.       function done(status, nativeStatusText, responses, total) {
  6391.         var isSuccess;
  6392.         var success;
  6393.         var error;
  6394.         var response;
  6395.         var modified;
  6396.         /** @type {(number|string)} */
  6397.         var statusText = nativeStatusText;
  6398.         if (2 !== e) {
  6399.           /** @type {number} */
  6400.           e = 2;
  6401.           if (tref) {
  6402.             clearTimeout(tref);
  6403.           }
  6404.           transport = void 0;
  6405.           ua = total || "";
  6406.           /** @type {number} */
  6407.           jqXHR.readyState = status > 0 ? 4 : 0;
  6408.           /** @type {boolean} */
  6409.           isSuccess = status >= 200 && 300 > status || 304 === status;
  6410.           if (responses) {
  6411.             response = ajaxHandleResponses(s, jqXHR, responses);
  6412.           }
  6413.           response = ajaxConvert(s, response, jqXHR, isSuccess);
  6414.           if (isSuccess) {
  6415.             if (s.ifModified) {
  6416.               modified = jqXHR.getResponseHeader("Last-Modified");
  6417.               if (modified) {
  6418.                 jQuery.lastModified[cacheURL] = modified;
  6419.               }
  6420.               modified = jqXHR.getResponseHeader("etag");
  6421.               if (modified) {
  6422.                 jQuery.etag[cacheURL] = modified;
  6423.               }
  6424.             }
  6425.             if (204 === status || "HEAD" === s.type) {
  6426.               /** @type {string} */
  6427.               statusText = "nocontent";
  6428.             } else {
  6429.               if (304 === status) {
  6430.                 /** @type {string} */
  6431.                 statusText = "notmodified";
  6432.               } else {
  6433.                 statusText = response.state;
  6434.                 success = response.data;
  6435.                 error = response.error;
  6436.                 /** @type {boolean} */
  6437.                 isSuccess = !error;
  6438.               }
  6439.             }
  6440.           } else {
  6441.             error = statusText;
  6442.             if (status || !statusText) {
  6443.               /** @type {string} */
  6444.               statusText = "error";
  6445.               if (0 > status) {
  6446.                 /** @type {number} */
  6447.                 status = 0;
  6448.               }
  6449.             }
  6450.           }
  6451.           /** @type {number} */
  6452.           jqXHR.status = status;
  6453.           /** @type {string} */
  6454.           jqXHR.statusText = (nativeStatusText || statusText) + "";
  6455.           if (isSuccess) {
  6456.             deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
  6457.           } else {
  6458.             deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
  6459.           }
  6460.           jqXHR.statusCode(statusCode);
  6461.           statusCode = void 0;
  6462.           if (g) {
  6463.             globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
  6464.           }
  6465.           completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
  6466.           if (g) {
  6467.             globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
  6468.             if (!--jQuery.active) {
  6469.               jQuery.event.trigger("ajaxStop");
  6470.             }
  6471.           }
  6472.         }
  6473.       }
  6474.       if ("object" == typeof url) {
  6475.         /** @type {Object} */
  6476.         options = url;
  6477.         url = void 0;
  6478.       }
  6479.       options = options || {};
  6480.       var transport;
  6481.       var cacheURL;
  6482.       var ua;
  6483.       var cache;
  6484.       var tref;
  6485.       var t;
  6486.       var g;
  6487.       var i;
  6488.       var s = jQuery.ajaxSetup({}, options);
  6489.       var callbackContext = s.context || s;
  6490.       var globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event;
  6491.       var deferred = jQuery.Deferred();
  6492.       var completeDeferred = jQuery.Callbacks("once memory");
  6493.       var statusCode = s.statusCode || {};
  6494.       var requestHeaders = {};
  6495.       var requestHeadersNames = {};
  6496.       /** @type {number} */
  6497.       var e = 0;
  6498.       /** @type {string} */
  6499.       var strAbort = "canceled";
  6500.       var jqXHR = {
  6501.         readyState : 0,
  6502.         /**
  6503.          * @param {string} key
  6504.          * @return {?}
  6505.          */
  6506.         getResponseHeader : function(key) {
  6507.           var data;
  6508.           if (2 === e) {
  6509.             if (!cache) {
  6510.               cache = {};
  6511.               for (;data = r.exec(ua);) {
  6512.                 /** @type {string} */
  6513.                 cache[data[1].toLowerCase()] = data[2];
  6514.               }
  6515.             }
  6516.             data = cache[key.toLowerCase()];
  6517.           }
  6518.           return null == data ? null : data;
  6519.         },
  6520.         /**
  6521.          * @return {?}
  6522.          */
  6523.         getAllResponseHeaders : function() {
  6524.           return 2 === e ? ua : null;
  6525.         },
  6526.         /**
  6527.          * @param {string} name
  6528.          * @param {?} value
  6529.          * @return {?}
  6530.          */
  6531.         setRequestHeader : function(name, value) {
  6532.           var lname = name.toLowerCase();
  6533.           return e || (name = requestHeadersNames[lname] = requestHeadersNames[lname] || name, requestHeaders[name] = value), this;
  6534.         },
  6535.         /**
  6536.          * @param {(Object|number)} type
  6537.          * @return {?}
  6538.          */
  6539.         overrideMimeType : function(type) {
  6540.           return e || (s.mimeType = type), this;
  6541.         },
  6542.         /**
  6543.          * @param {Object} map
  6544.          * @return {?}
  6545.          */
  6546.         statusCode : function(map) {
  6547.           var letter;
  6548.           if (map) {
  6549.             if (2 > e) {
  6550.               for (letter in map) {
  6551.                 /** @type {Array} */
  6552.                 statusCode[letter] = [statusCode[letter], map[letter]];
  6553.               }
  6554.             } else {
  6555.               jqXHR.always(map[jqXHR.status]);
  6556.             }
  6557.           }
  6558.           return this;
  6559.         },
  6560.         /**
  6561.          * @param {string} args
  6562.          * @return {?}
  6563.          */
  6564.         abort : function(args) {
  6565.           var typePattern = args || strAbort;
  6566.           return transport && transport.abort(typePattern), done(0, typePattern), this;
  6567.         }
  6568.       };
  6569.       if (deferred.promise(jqXHR).complete = completeDeferred.add, jqXHR.success = jqXHR.done, jqXHR.error = jqXHR.fail, s.url = ((url || (s.url || ajaxLocation)) + "").replace(currDirRegExp, "").replace(rprotocol, match[1] + "//"), s.type = options.method || (options.type || (s.method || s.type)), s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(core_rnotwhite) || [""], null == s.crossDomain && (t = quickExpr.exec(s.url.toLowerCase()), s.crossDomain = !(!t || t[1] === match[1] &&
  6570.       (t[2] === match[2] && (t[3] || ("http:" === t[1] ? "80" : "443")) === (match[3] || ("http:" === match[1] ? "80" : "443"))))), s.data && (s.processData && ("string" != typeof s.data && (s.data = jQuery.param(s.data, s.traditional)))), inspectPrefiltersOrTransports(prefilters, s, options, jqXHR), 2 === e) {
  6571.         return jqXHR;
  6572.       }
  6573.       g = s.global;
  6574.       if (g) {
  6575.         if (0 == jQuery.active++) {
  6576.           jQuery.event.trigger("ajaxStart");
  6577.         }
  6578.       }
  6579.       s.type = s.type.toUpperCase();
  6580.       /** @type {boolean} */
  6581.       s.hasContent = !rnoContent.test(s.type);
  6582.       cacheURL = s.url;
  6583.       if (!s.hasContent) {
  6584.         if (s.data) {
  6585.           /** @type {string} */
  6586.           cacheURL = s.url += (rquery.test(cacheURL) ? "&" : "?") + s.data;
  6587.           delete s.data;
  6588.         }
  6589.         if (s.cache === false) {
  6590.           s.url = rts.test(cacheURL) ? cacheURL.replace(rts, "$1_=" + iIdCounter++) : cacheURL + (rquery.test(cacheURL) ? "&" : "?") + "_=" + iIdCounter++;
  6591.         }
  6592.       }
  6593.       if (s.ifModified) {
  6594.         if (jQuery.lastModified[cacheURL]) {
  6595.           jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
  6596.         }
  6597.         if (jQuery.etag[cacheURL]) {
  6598.           jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
  6599.         }
  6600.       }
  6601.       if (s.data && (s.hasContent && s.contentType !== false) || options.contentType) {
  6602.         jqXHR.setRequestHeader("Content-Type", s.contentType);
  6603.       }
  6604.       jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + ("*" !== s.dataTypes[0] ? ", " + yu + "; q=0.01" : "") : s.accepts["*"]);
  6605.       for (i in s.headers) {
  6606.         jqXHR.setRequestHeader(i, s.headers[i]);
  6607.       }
  6608.       if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || 2 === e)) {
  6609.         return jqXHR.abort();
  6610.       }
  6611.       /** @type {string} */
  6612.       strAbort = "abort";
  6613.       for (i in{
  6614.         success : 1,
  6615.         error : 1,
  6616.         complete : 1
  6617.       }) {
  6618.         jqXHR[i](s[i]);
  6619.       }
  6620.       if (transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR)) {
  6621.         /** @type {number} */
  6622.         jqXHR.readyState = 1;
  6623.         if (g) {
  6624.           globalEventContext.trigger("ajaxSend", [jqXHR, s]);
  6625.         }
  6626.         if (s.async) {
  6627.           if (s.timeout > 0) {
  6628.             /** @type {number} */
  6629.             tref = setTimeout(function() {
  6630.               jqXHR.abort("timeout");
  6631.             }, s.timeout);
  6632.           }
  6633.         }
  6634.         try {
  6635.           /** @type {number} */
  6636.           e = 1;
  6637.           transport.send(requestHeaders, done);
  6638.         } catch (finalText) {
  6639.           if (!(2 > e)) {
  6640.             throw finalText;
  6641.           }
  6642.           done(-1, finalText);
  6643.         }
  6644.       } else {
  6645.         done(-1, "No Transport");
  6646.       }
  6647.       return jqXHR;
  6648.     },
  6649.     /**
  6650.      * @param {Object} cur
  6651.      * @param {string} data
  6652.      * @param {string} callback
  6653.      * @return {?}
  6654.      */
  6655.     getJSON : function(cur, data, callback) {
  6656.       return jQuery.get(cur, data, callback, "json");
  6657.     },
  6658.     /**
  6659.      * @param {Object} cur
  6660.      * @param {string} callback
  6661.      * @return {?}
  6662.      */
  6663.     getScript : function(cur, callback) {
  6664.       return jQuery.get(cur, void 0, callback, "script");
  6665.     }
  6666.   });
  6667.   jQuery.each(["get", "post"], function(dataAndEvents, method) {
  6668.     /**
  6669.      * @param {string} requestUrl
  6670.      * @param {(Function|string)} html
  6671.      * @param {(Function|string)} success
  6672.      * @param {(Object|string)} dataType
  6673.      * @return {?}
  6674.      */
  6675.     jQuery[method] = function(requestUrl, html, success, dataType) {
  6676.       return jQuery.isFunction(html) && (dataType = dataType || success, success = html, html = void 0), jQuery.ajax({
  6677.         url : requestUrl,
  6678.         type : method,
  6679.         dataType : dataType,
  6680.         data : html,
  6681.         success : success
  6682.       });
  6683.     };
  6684.   });
  6685.   jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(dataAndEvents, name) {
  6686.     /**
  6687.      * @param {Function} selector
  6688.      * @return {?}
  6689.      */
  6690.     jQuery.fn[name] = function(selector) {
  6691.       return this.on(name, selector);
  6692.     };
  6693.   });
  6694.   /**
  6695.    * @param {string} url
  6696.    * @return {?}
  6697.    */
  6698.   jQuery._evalUrl = function(url) {
  6699.     return jQuery.ajax({
  6700.       url : url,
  6701.       type : "GET",
  6702.       dataType : "script",
  6703.       async : false,
  6704.       global : false,
  6705.       throws : true
  6706.     });
  6707.   };
  6708.   jQuery.fn.extend({
  6709.     /**
  6710.      * @param {Function} html
  6711.      * @return {?}
  6712.      */
  6713.     wrapAll : function(html) {
  6714.       var wrap;
  6715.       return jQuery.isFunction(html) ? this.each(function(i) {
  6716.         jQuery(this).wrapAll(html.call(this, i));
  6717.       }) : (this[0] && (wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true), this[0].parentNode && wrap.insertBefore(this[0]), wrap.map(function() {
  6718.         var elem = this;
  6719.         for (;elem.firstElementChild;) {
  6720.           elem = elem.firstElementChild;
  6721.         }
  6722.         return elem;
  6723.       }).append(this)), this);
  6724.     },
  6725.     /**
  6726.      * @param {Function} html
  6727.      * @return {?}
  6728.      */
  6729.     wrapInner : function(html) {
  6730.       return this.each(jQuery.isFunction(html) ? function(i) {
  6731.         jQuery(this).wrapInner(html.call(this, i));
  6732.       } : function() {
  6733.         var self = jQuery(this);
  6734.         var contents = self.contents();
  6735.         if (contents.length) {
  6736.           contents.wrapAll(html);
  6737.         } else {
  6738.           self.append(html);
  6739.         }
  6740.       });
  6741.     },
  6742.     /**
  6743.      * @param {Function} html
  6744.      * @return {?}
  6745.      */
  6746.     wrap : function(html) {
  6747.       var isFunction = jQuery.isFunction(html);
  6748.       return this.each(function(i) {
  6749.         jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
  6750.       });
  6751.     },
  6752.     /**
  6753.      * @return {?}
  6754.      */
  6755.     unwrap : function() {
  6756.       return this.parent().each(function() {
  6757.         if (!jQuery.nodeName(this, "body")) {
  6758.           jQuery(this).replaceWith(this.childNodes);
  6759.         }
  6760.       }).end();
  6761.     }
  6762.   });
  6763.   /**
  6764.    * @param {string} args
  6765.    * @return {?}
  6766.    */
  6767.   jQuery.expr.filters.hidden = function(args) {
  6768.     return args.offsetWidth <= 0 && args.offsetHeight <= 0;
  6769.   };
  6770.   /**
  6771.    * @param {string} ast
  6772.    * @return {?}
  6773.    */
  6774.   jQuery.expr.filters.visible = function(ast) {
  6775.     return!jQuery.expr.filters.hidden(ast);
  6776.   };
  6777.   /** @type {RegExp} */
  6778.   var rQuot = /%20/g;
  6779.   /** @type {RegExp} */
  6780.   var rmargin = /\[\]$/;
  6781.   /** @type {RegExp} */
  6782.   var rCRLF = /\r?\n/g;
  6783.   /** @type {RegExp} */
  6784.   var mouseTypeRegex = /^(?:submit|button|image|reset|file)$/i;
  6785.   /** @type {RegExp} */
  6786.   var rsubmittable = /^(?:input|select|textarea|keygen)/i;
  6787.   /**
  6788.    * @param {Object} a
  6789.    * @param {string} traditional
  6790.    * @return {?}
  6791.    */
  6792.   jQuery.param = function(a, traditional) {
  6793.     var prefix;
  6794.     /** @type {Array} */
  6795.     var klass = [];
  6796.     /**
  6797.      * @param {?} key
  6798.      * @param {string} value
  6799.      * @return {undefined}
  6800.      */
  6801.     var add = function(key, value) {
  6802.       value = jQuery.isFunction(value) ? value() : null == value ? "" : value;
  6803.       /** @type {string} */
  6804.       klass[klass.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
  6805.     };
  6806.     if (void 0 === traditional && (traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional), jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
  6807.       jQuery.each(a, function() {
  6808.         add(this.name, this.value);
  6809.       });
  6810.     } else {
  6811.       for (prefix in a) {
  6812.         buildParams(prefix, a[prefix], traditional, add);
  6813.       }
  6814.     }
  6815.     return klass.join("&").replace(rQuot, "+");
  6816.   };
  6817.   jQuery.fn.extend({
  6818.     /**
  6819.      * @return {?}
  6820.      */
  6821.     serialize : function() {
  6822.       return jQuery.param(this.serializeArray());
  6823.     },
  6824.     /**
  6825.      * @return {?}
  6826.      */
  6827.     serializeArray : function() {
  6828.       return this.map(function() {
  6829.         var elements = jQuery.prop(this, "elements");
  6830.         return elements ? jQuery.makeArray(elements) : this;
  6831.       }).filter(function() {
  6832.         var type = this.type;
  6833.         return this.name && (!jQuery(this).is(":disabled") && (rsubmittable.test(this.nodeName) && (!mouseTypeRegex.test(type) && (this.checked || !manipulation_rcheckableType.test(type)))));
  6834.       }).map(function(dataAndEvents, elem) {
  6835.         var val = jQuery(this).val();
  6836.         return null == val ? null : jQuery.isArray(val) ? jQuery.map(val, function(val) {
  6837.           return{
  6838.             name : elem.name,
  6839.             value : val.replace(rCRLF, "\r\n")
  6840.           };
  6841.         }) : {
  6842.           name : elem.name,
  6843.           value : val.replace(rCRLF, "\r\n")
  6844.         };
  6845.       }).get();
  6846.     }
  6847.   });
  6848.   /**
  6849.    * @return {?}
  6850.    */
  6851.   jQuery.ajaxSettings.xhr = function() {
  6852.     try {
  6853.       return new XMLHttpRequest;
  6854.     } catch (n) {
  6855.     }
  6856.   };
  6857.   /** @type {number} */
  6858.   var rightId = 0;
  6859.   var map = {};
  6860.   var xhrSuccessStatus = {
  6861.     0 : 200,
  6862.     1223 : 204
  6863.   };
  6864.   var xhrSupported = jQuery.ajaxSettings.xhr();
  6865.   return win.ActiveXObject && jQuery(win).on("unload", function() {
  6866.     var letter;
  6867.     for (letter in map) {
  6868.       map[letter]();
  6869.     }
  6870.   }), support.cors = !!xhrSupported && "withCredentials" in xhrSupported, support.ajax = xhrSupported = !!xhrSupported, jQuery.ajaxTransport(function(options) {
  6871.     var callback;
  6872.     if (support.cors || xhrSupported && !options.crossDomain) {
  6873.       return{
  6874.         /**
  6875.          * @param {Object} headers
  6876.          * @param {Function} complete
  6877.          * @return {undefined}
  6878.          */
  6879.         send : function(headers, complete) {
  6880.           var i;
  6881.           var xhr = options.xhr();
  6882.           /** @type {number} */
  6883.           var id = ++rightId;
  6884.           if (xhr.open(options.type, options.url, options.async, options.username, options.password), options.xhrFields) {
  6885.             for (i in options.xhrFields) {
  6886.               xhr[i] = options.xhrFields[i];
  6887.             }
  6888.           }
  6889.           if (options.mimeType) {
  6890.             if (xhr.overrideMimeType) {
  6891.               xhr.overrideMimeType(options.mimeType);
  6892.             }
  6893.           }
  6894.           if (!options.crossDomain) {
  6895.             if (!headers["X-Requested-With"]) {
  6896.               /** @type {string} */
  6897.               headers["X-Requested-With"] = "XMLHttpRequest";
  6898.             }
  6899.           }
  6900.           for (i in headers) {
  6901.             xhr.setRequestHeader(i, headers[i]);
  6902.           }
  6903.           /**
  6904.            * @param {string} status
  6905.            * @return {?}
  6906.            */
  6907.           callback = function(status) {
  6908.             return function() {
  6909.               if (callback) {
  6910.                 delete map[id];
  6911.                 /** @type {null} */
  6912.                 callback = xhr.onload = xhr.onerror = null;
  6913.                 if ("abort" === status) {
  6914.                   xhr.abort();
  6915.                 } else {
  6916.                   if ("error" === status) {
  6917.                     complete(xhr.status, xhr.statusText);
  6918.                   } else {
  6919.                     complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, "string" == typeof xhr.responseText ? {
  6920.                       text : xhr.responseText
  6921.                     } : void 0, xhr.getAllResponseHeaders());
  6922.                   }
  6923.                 }
  6924.               }
  6925.             };
  6926.           };
  6927.           xhr.onload = callback();
  6928.           xhr.onerror = callback("error");
  6929.           callback = map[id] = callback("abort");
  6930.           try {
  6931.             xhr.send(options.hasContent && options.data || null);
  6932.           } catch (o) {
  6933.             if (callback) {
  6934.               throw o;
  6935.             }
  6936.           }
  6937.         },
  6938.         /**
  6939.          * @return {undefined}
  6940.          */
  6941.         abort : function() {
  6942.           if (callback) {
  6943.             callback();
  6944.           }
  6945.         }
  6946.       };
  6947.     }
  6948.   }), jQuery.ajaxSetup({
  6949.     accepts : {
  6950.       script : "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  6951.     },
  6952.     contents : {
  6953.       script : /(?:java|ecma)script/
  6954.     },
  6955.     converters : {
  6956.       /**
  6957.        * @param {string} value
  6958.        * @return {?}
  6959.        */
  6960.       "text script" : function(value) {
  6961.         return jQuery.globalEval(value), value;
  6962.       }
  6963.     }
  6964.   }), jQuery.ajaxPrefilter("script", function(s) {
  6965.     if (void 0 === s.cache) {
  6966.       /** @type {boolean} */
  6967.       s.cache = false;
  6968.     }
  6969.     if (s.crossDomain) {
  6970.       /** @type {string} */
  6971.       s.type = "GET";
  6972.     }
  6973.   }), jQuery.ajaxTransport("script", function(s) {
  6974.     if (s.crossDomain) {
  6975.       var script;
  6976.       var callback;
  6977.       return{
  6978.         /**
  6979.          * @param {?} _
  6980.          * @param {Function} complete
  6981.          * @return {undefined}
  6982.          */
  6983.         send : function(_, complete) {
  6984.           script = jQuery("<script>").prop({
  6985.             async : true,
  6986.             charset : s.scriptCharset,
  6987.             src : s.url
  6988.           }).on("load error", callback = function(evt) {
  6989.             script.remove();
  6990.             /** @type {null} */
  6991.             callback = null;
  6992.             if (evt) {
  6993.               complete("error" === evt.type ? 404 : 200, evt.type);
  6994.             }
  6995.           });
  6996.           doc.head.appendChild(script[0]);
  6997.         },
  6998.         /**
  6999.          * @return {undefined}
  7000.          */
  7001.         abort : function() {
  7002.           if (callback) {
  7003.             callback();
  7004.           }
  7005.         }
  7006.       };
  7007.     }
  7008.   }), eventPath = [], rjsonp = /(=)\?(?=&|$)|\?\?/, jQuery.ajaxSetup({
  7009.     jsonp : "callback",
  7010.     /**
  7011.      * @return {?}
  7012.      */
  7013.     jsonpCallback : function() {
  7014.       var unlock = eventPath.pop() || jQuery.expando + "_" + iIdCounter++;
  7015.       return this[unlock] = true, unlock;
  7016.     }
  7017.   }), jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) {
  7018.     var callbackName;
  7019.     var html;
  7020.     var args;
  7021.     var jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : "string" == typeof s.data && (!(s.contentType || "").indexOf("application/x-www-form-urlencoded") && (rjsonp.test(s.data) && "data")));
  7022.     if (jsonProp || "jsonp" === s.dataTypes[0]) {
  7023.       return callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, jsonProp ? s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName) : s.jsonp !== false && (s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName), s.converters["script json"] = function() {
  7024.         return args || jQuery.error(callbackName + " was not called"), args[0];
  7025.       }, s.dataTypes[0] = "json", html = win[callbackName], win[callbackName] = function() {
  7026.         /** @type {Arguments} */
  7027.         args = arguments;
  7028.       }, jqXHR.always(function() {
  7029.         win[callbackName] = html;
  7030.         if (s[callbackName]) {
  7031.           s.jsonpCallback = originalSettings.jsonpCallback;
  7032.           eventPath.push(callbackName);
  7033.         }
  7034.         if (args) {
  7035.           if (jQuery.isFunction(html)) {
  7036.             html(args[0]);
  7037.           }
  7038.         }
  7039.         args = html = void 0;
  7040.       }), "script";
  7041.     }
  7042.   }), jQuery.parseHTML = function(data, context, keepScripts) {
  7043.     if (!data || "string" != typeof data) {
  7044.       return null;
  7045.     }
  7046.     if ("boolean" == typeof context) {
  7047.       /** @type {Object} */
  7048.       keepScripts = context;
  7049.       /** @type {boolean} */
  7050.       context = false;
  7051.     }
  7052.     context = context || doc;
  7053.     /** @type {(Array.<string>|null)} */
  7054.     var parsed = rsingleTag.exec(data);
  7055.     /** @type {(Array|boolean)} */
  7056.     var scripts = !keepScripts && [];
  7057.     return parsed ? [context.createElement(parsed[1])] : (parsed = jQuery.buildFragment([data], context, scripts), scripts && (scripts.length && jQuery(scripts).remove()), jQuery.merge([], parsed.childNodes));
  7058.   }, matcherFunction = jQuery.fn.load, jQuery.fn.load = function(args, value, options) {
  7059.     if ("string" != typeof args && matcherFunction) {
  7060.       return matcherFunction.apply(this, arguments);
  7061.     }
  7062.     var selector;
  7063.     var type;
  7064.     var response;
  7065.     var self = this;
  7066.     var start = args.indexOf(" ");
  7067.     return start >= 0 && (selector = jQuery.trim(args.slice(start)), args = args.slice(0, start)), jQuery.isFunction(value) ? (options = value, value = void 0) : value && ("object" == typeof value && (type = "POST")), self.length > 0 && jQuery.ajax({
  7068.       url : args,
  7069.       type : type,
  7070.       dataType : "html",
  7071.       data : value
  7072.     }).done(function(responseText) {
  7073.       /** @type {Arguments} */
  7074.       response = arguments;
  7075.       self.html(selector ? jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
  7076.     }).complete(options && function(args, value) {
  7077.       self.each(options, response || [args.responseText, value, args]);
  7078.     }), this;
  7079.   }, jQuery.expr.filters.animated = function(elem) {
  7080.     return jQuery.grep(jQuery.timers, function(fn) {
  7081.       return elem === fn.elem;
  7082.     }).length;
  7083.   }, docElem = win.document.documentElement, jQuery.offset = {
  7084.     /**
  7085.      * @param {Object} elem
  7086.      * @param {Object} options
  7087.      * @param {?} i
  7088.      * @return {undefined}
  7089.      */
  7090.     setOffset : function(elem, options, i) {
  7091.       var curPosition;
  7092.       var curLeft;
  7093.       var curCSSTop;
  7094.       var curTop;
  7095.       var curOffset;
  7096.       var curCSSLeft;
  7097.       var v;
  7098.       var position = jQuery.css(elem, "position");
  7099.       var $elem = jQuery(elem);
  7100.       var val = {};
  7101.       if ("static" === position) {
  7102.         /** @type {string} */
  7103.         elem.style.position = "relative";
  7104.       }
  7105.       curOffset = $elem.offset();
  7106.       curCSSTop = jQuery.css(elem, "top");
  7107.       curCSSLeft = jQuery.css(elem, "left");
  7108.       /** @type {boolean} */
  7109.       v = ("absolute" === position || "fixed" === position) && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
  7110.       if (v) {
  7111.         curPosition = $elem.position();
  7112.         curTop = curPosition.top;
  7113.         curLeft = curPosition.left;
  7114.       } else {
  7115.         /** @type {number} */
  7116.         curTop = parseFloat(curCSSTop) || 0;
  7117.         /** @type {number} */
  7118.         curLeft = parseFloat(curCSSLeft) || 0;
  7119.       }
  7120.       if (jQuery.isFunction(options)) {
  7121.         options = options.call(elem, i, curOffset);
  7122.       }
  7123.       if (null != options.top) {
  7124.         /** @type {number} */
  7125.         val.top = options.top - curOffset.top + curTop;
  7126.       }
  7127.       if (null != options.left) {
  7128.         /** @type {number} */
  7129.         val.left = options.left - curOffset.left + curLeft;
  7130.       }
  7131.       if ("using" in options) {
  7132.         options.using.call(elem, val);
  7133.       } else {
  7134.         $elem.css(val);
  7135.       }
  7136.     }
  7137.   }, jQuery.fn.extend({
  7138.     /**
  7139.      * @param {number} options
  7140.      * @return {?}
  7141.      */
  7142.     offset : function(options) {
  7143.       if (arguments.length) {
  7144.         return void 0 === options ? this : this.each(function(dataName) {
  7145.           jQuery.offset.setOffset(this, options, dataName);
  7146.         });
  7147.       }
  7148.       var doc;
  7149.       var win;
  7150.       var b = this[0];
  7151.       var box = {
  7152.         top : 0,
  7153.         left : 0
  7154.       };
  7155.       var element = b && b.ownerDocument;
  7156.       if (element) {
  7157.         return doc = element.documentElement, jQuery.contains(doc, b) ? (typeof b.getBoundingClientRect !== memory && (box = b.getBoundingClientRect()), win = getWindow(element), {
  7158.           top : box.top + win.pageYOffset - doc.clientTop,
  7159.           left : box.left + win.pageXOffset - doc.clientLeft
  7160.         }) : box;
  7161.       }
  7162.     },
  7163.     /**
  7164.      * @return {?}
  7165.      */
  7166.     position : function() {
  7167.       if (this[0]) {
  7168.         var offsetParent;
  7169.         var offset;
  7170.         var elem = this[0];
  7171.         var parentOffset = {
  7172.           top : 0,
  7173.           left : 0
  7174.         };
  7175.         return "fixed" === jQuery.css(elem, "position") ? offset = elem.getBoundingClientRect() : (offsetParent = this.offsetParent(), offset = this.offset(), jQuery.nodeName(offsetParent[0], "html") || (parentOffset = offsetParent.offset()), parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true), parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true)), {
  7176.           top : offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
  7177.           left : offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
  7178.         };
  7179.       }
  7180.     },
  7181.     /**
  7182.      * @return {?}
  7183.      */
  7184.     offsetParent : function() {
  7185.       return this.map(function() {
  7186.         var offsetParent = this.offsetParent || docElem;
  7187.         for (;offsetParent && (!jQuery.nodeName(offsetParent, "html") && "static" === jQuery.css(offsetParent, "position"));) {
  7188.           offsetParent = offsetParent.offsetParent;
  7189.         }
  7190.         return offsetParent || docElem;
  7191.       });
  7192.     }
  7193.   }), jQuery.each({
  7194.     scrollLeft : "pageXOffset",
  7195.     scrollTop : "pageYOffset"
  7196.   }, function(name, prop) {
  7197.     /** @type {boolean} */
  7198.     var top = "pageYOffset" === prop;
  7199.     /**
  7200.      * @param {?} value
  7201.      * @return {?}
  7202.      */
  7203.     jQuery.fn[name] = function(value) {
  7204.       return access(this, function(node, path, val) {
  7205.         var cs = getWindow(node);
  7206.         return void 0 === val ? cs ? cs[prop] : node[path] : void(cs ? cs.scrollTo(top ? win.pageXOffset : val, top ? val : win.pageYOffset) : node[path] = val);
  7207.       }, name, value, arguments.length, null);
  7208.     };
  7209.   }), jQuery.each(["top", "left"], function(dataAndEvents, prop) {
  7210.     jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, val) {
  7211.       if (val) {
  7212.         return val = css(elem, prop), regexp.test(val) ? jQuery(elem).position()[prop] + "px" : val;
  7213.       }
  7214.     });
  7215.   }), jQuery.each({
  7216.     Height : "height",
  7217.     Width : "width"
  7218.   }, function(name, type) {
  7219.     jQuery.each({
  7220.       padding : "inner" + name,
  7221.       content : type,
  7222.       "" : "outer" + name
  7223.     }, function(defaultExtra, original) {
  7224.       /**
  7225.        * @param {?} margin
  7226.        * @param {boolean} value
  7227.        * @return {?}
  7228.        */
  7229.       jQuery.fn[original] = function(margin, value) {
  7230.         var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin);
  7231.         var extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
  7232.         return access(this, function(elem, prop, value) {
  7233.           var doc;
  7234.           return jQuery.isWindow(elem) ? elem.document.documentElement["client" + name] : 9 === elem.nodeType ? (doc = elem.documentElement, Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name])) : void 0 === value ? jQuery.css(elem, prop, extra) : jQuery.style(elem, prop, value, extra);
  7235.         }, type, chainable ? margin : void 0, chainable, null);
  7236.       };
  7237.     });
  7238.   }), jQuery.fn.size = function() {
  7239.     return this.length;
  7240.   }, jQuery.fn.andSelf = jQuery.fn.addBack, "function" == typeof define && (define.amd && define("jquery", [], function() {
  7241.     return jQuery;
  7242.   })), $ = win.jQuery, _$ = win.$, jQuery.noConflict = function(deep) {
  7243.     return win.$ === jQuery && (win.$ = _$), deep && (win.jQuery === jQuery && (win.jQuery = $)), jQuery;
  7244.   }, typeof dataAndEvents === memory && (win.jQuery = win.$ = jQuery), jQuery;
  7245. });
  7246. !function(factory) {
  7247.   if ("function" == typeof define && define.amd) {
  7248.     define(["jquery"], factory);
  7249.   } else {
  7250.     factory(jQuery);
  7251.   }
  7252. }(function($) {
  7253.   $.extend($.fn, {
  7254.     /**
  7255.      * @param {?} options
  7256.      * @return {?}
  7257.      */
  7258.     validate : function(options) {
  7259.       if (!this.length) {
  7260.         return void(options && (options.debug && (window.console && console.warn("Nothing selected, can't validate, returning nothing."))));
  7261.       }
  7262.       var validator = $.data(this[0], "validator");
  7263.       return validator ? validator : (this.attr("novalidate", "novalidate"), validator = new $.validator(options, this[0]), $.data(this[0], "validator", validator), validator.settings.onsubmit && (this.on("click.validate", ":submit", function(event) {
  7264.         if (validator.settings.submitHandler) {
  7265.           validator.submitButton = event.target;
  7266.         }
  7267.         if ($(this).hasClass("cancel")) {
  7268.           /** @type {boolean} */
  7269.           validator.cancelSubmit = true;
  7270.         }
  7271.         if (void 0 !== $(this).attr("formnovalidate")) {
  7272.           /** @type {boolean} */
  7273.           validator.cancelSubmit = true;
  7274.         }
  7275.       }), this.on("submit.validate", function(types) {
  7276.         /**
  7277.          * @return {?}
  7278.          */
  7279.         function handle() {
  7280.           var selfObj;
  7281.           var factoriedDoc;
  7282.           return validator.settings.submitHandler ? (validator.submitButton && (selfObj = $("<input type='hidden'/>").attr("name", validator.submitButton.name).val($(validator.submitButton).val()).appendTo(validator.currentForm)), factoriedDoc = validator.settings.submitHandler.call(validator, validator.currentForm, types), validator.submitButton && selfObj.remove(), void 0 !== factoriedDoc ? factoriedDoc : false) : true;
  7283.         }
  7284.         return validator.settings.debug && types.preventDefault(), validator.cancelSubmit ? (validator.cancelSubmit = false, handle()) : validator.form() ? validator.pendingRequest ? (validator.formSubmitted = true, false) : handle() : (validator.focusInvalid(), false);
  7285.       })), validator);
  7286.     },
  7287.     /**
  7288.      * @return {?}
  7289.      */
  7290.     valid : function() {
  7291.       var res;
  7292.       var e;
  7293.       var r;
  7294.       return $(this[0]).is("form") ? res = this.validate().form() : (r = [], res = true, e = $(this[0].form).validate(), this.each(function() {
  7295.         res = e.element(this) && res;
  7296.         r = r.concat(e.errorList);
  7297.       }), e.errorList = r), res;
  7298.     },
  7299.     /**
  7300.      * @param {?} command
  7301.      * @param {string} argument
  7302.      * @return {?}
  7303.      */
  7304.     rules : function(command, argument) {
  7305.       var result;
  7306.       var n;
  7307.       var b;
  7308.       var settings;
  7309.       var remote;
  7310.       var old;
  7311.       var element = this[0];
  7312.       if (command) {
  7313.         switch(result = $.data(element.form, "validator").settings, n = result.rules, b = $.validator.staticRules(element), command) {
  7314.           case "add":
  7315.             $.extend(b, $.validator.normalizeRule(argument));
  7316.             delete b.messages;
  7317.             n[element.name] = b;
  7318.             if (argument.messages) {
  7319.               result.messages[element.name] = $.extend(result.messages[element.name], argument.messages);
  7320.             }
  7321.             break;
  7322.           case "remove":
  7323.             return argument ? (old = {}, $.each(argument.split(/\s/), function(dataAndEvents, name) {
  7324.               old[name] = b[name];
  7325.               delete b[name];
  7326.               if ("required" === name) {
  7327.                 $(element).removeAttr("aria-required");
  7328.               }
  7329.             }), old) : (delete n[element.name], b);
  7330.         }
  7331.       }
  7332.       return settings = $.validator.normalizeRules($.extend({}, $.validator.classRules(element), $.validator.attributeRules(element), $.validator.dataRules(element), $.validator.staticRules(element)), element), settings.required && (remote = settings.required, delete settings.required, settings = $.extend({
  7333.         required : remote
  7334.       }, settings), $(element).attr("aria-required", "true")), settings.remote && (remote = settings.remote, delete settings.remote, settings = $.extend(settings, {
  7335.         remote : remote
  7336.       })), settings;
  7337.     }
  7338.   });
  7339.   $.extend($.expr[":"], {
  7340.     /**
  7341.      * @param {?} a
  7342.      * @return {?}
  7343.      */
  7344.     blank : function(a) {
  7345.       return!$.trim("" + $(a).val());
  7346.     },
  7347.     /**
  7348.      * @param {?} a
  7349.      * @return {?}
  7350.      */
  7351.     filled : function(a) {
  7352.       return!!$.trim("" + $(a).val());
  7353.     },
  7354.     /**
  7355.      * @param {?} a
  7356.      * @return {?}
  7357.      */
  7358.     unchecked : function(a) {
  7359.       return!$(a).prop("checked");
  7360.     }
  7361.   });
  7362.   /**
  7363.    * @param {?} options
  7364.    * @param {?} form
  7365.    * @return {undefined}
  7366.    */
  7367.   $.validator = function(options, form) {
  7368.     this.settings = $.extend(true, {}, $.validator.defaults, options);
  7369.     this.currentForm = form;
  7370.     this.init();
  7371.   };
  7372.   /**
  7373.    * @param {string} source
  7374.    * @param {?} params
  7375.    * @return {?}
  7376.    */
  7377.   $.validator.format = function(source, params) {
  7378.     return 1 === arguments.length ? function() {
  7379.       var args = $.makeArray(arguments);
  7380.       return args.unshift(source), $.validator.format.apply(this, args);
  7381.     } : (arguments.length > 2 && (params.constructor !== Array && (params = $.makeArray(arguments).slice(1))), params.constructor !== Array && (params = [params]), $.each(params, function(dataAndEvents, deepDataAndEvents) {
  7382.       source = source.replace(new RegExp("\\{" + dataAndEvents + "\\}", "g"), function() {
  7383.         return deepDataAndEvents;
  7384.       });
  7385.     }), source);
  7386.   };
  7387.   $.extend($.validator, {
  7388.     defaults : {
  7389.       messages : {},
  7390.       groups : {},
  7391.       rules : {},
  7392.       errorClass : "error",
  7393.       validClass : "valid",
  7394.       errorElement : "label",
  7395.       focusCleanup : false,
  7396.       focusInvalid : true,
  7397.       errorContainer : $([]),
  7398.       errorLabelContainer : $([]),
  7399.       onsubmit : true,
  7400.       ignore : ":hidden",
  7401.       ignoreTitle : false,
  7402.       /**
  7403.        * @param {(Object|string)} element
  7404.        * @return {undefined}
  7405.        */
  7406.       onfocusin : function(element) {
  7407.         /** @type {(Object|string)} */
  7408.         this.lastActive = element;
  7409.         if (this.settings.focusCleanup) {
  7410.           if (this.settings.unhighlight) {
  7411.             this.settings.unhighlight.call(this, element, this.settings.errorClass, this.settings.validClass);
  7412.           }
  7413.           this.hideThese(this.errorsFor(element));
  7414.         }
  7415.       },
  7416.       /**
  7417.        * @param {string} ast
  7418.        * @return {undefined}
  7419.        */
  7420.       onfocusout : function(ast) {
  7421.         if (!this.checkable(ast)) {
  7422.           if (ast.name in this.submitted || !this.optional(ast)) {
  7423.             this.element(ast);
  7424.           }
  7425.         }
  7426.       },
  7427.       /**
  7428.        * @param {string} ast
  7429.        * @param {Event} e
  7430.        * @return {undefined}
  7431.        */
  7432.       onkeyup : function(ast, e) {
  7433.         if (!(9 === e.which && "" === this.elementValue(ast))) {
  7434.           if (!(-1 !== $.inArray(e.keyCode, [16, 17, 18, 20, 35, 36, 37, 38, 39, 40, 45, 144, 225]))) {
  7435.             if (ast.name in this.submitted || ast === this.lastElement) {
  7436.               this.element(ast);
  7437.             }
  7438.           }
  7439.         }
  7440.       },
  7441.       /**
  7442.        * @param {string} ast
  7443.        * @return {undefined}
  7444.        */
  7445.       onclick : function(ast) {
  7446.         if (ast.name in this.submitted) {
  7447.           this.element(ast);
  7448.         } else {
  7449.           if (ast.parentNode.name in this.submitted) {
  7450.             this.element(ast.parentNode);
  7451.           }
  7452.         }
  7453.       },
  7454.       /**
  7455.        * @param {Object} elem
  7456.        * @param {string} klass
  7457.        * @param {string} className
  7458.        * @return {undefined}
  7459.        */
  7460.       highlight : function(elem, klass, className) {
  7461.         if ("radio" === elem.type) {
  7462.           this.findByName(elem.name).addClass(klass).removeClass(className);
  7463.         } else {
  7464.           $(elem).addClass(klass).removeClass(className);
  7465.         }
  7466.       },
  7467.       /**
  7468.        * @param {Object} element
  7469.        * @param {string} node
  7470.        * @param {string} validClass
  7471.        * @return {undefined}
  7472.        */
  7473.       unhighlight : function(element, node, validClass) {
  7474.         if ("radio" === element.type) {
  7475.           this.findByName(element.name).removeClass(node).addClass(validClass);
  7476.         } else {
  7477.           $(element).removeClass(node).addClass(validClass);
  7478.         }
  7479.       }
  7480.     },
  7481.     /**
  7482.      * @param {?} settings
  7483.      * @return {undefined}
  7484.      */
  7485.     setDefaults : function(settings) {
  7486.       $.extend($.validator.defaults, settings);
  7487.     },
  7488.     messages : {
  7489.       required : "This field is required.",
  7490.       remote : "Please fix this field.",
  7491.       email : "Please enter a valid email address.",
  7492.       url : "Please enter a valid URL.",
  7493.       date : "Please enter a valid date.",
  7494.       dateISO : "Please enter a valid date ( ISO ).",
  7495.       number : "Please enter a valid number.",
  7496.       digits : "Please enter only digits.",
  7497.       creditcard : "Please enter a valid credit card number.",
  7498.       equalTo : "Please enter the same value again.",
  7499.       maxlength : $.validator.format("Please enter no more than {0} characters."),
  7500.       minlength : $.validator.format("Please enter at least {0} characters."),
  7501.       rangelength : $.validator.format("Please enter a value between {0} and {1} characters long."),
  7502.       range : $.validator.format("Please enter a value between {0} and {1}."),
  7503.       max : $.validator.format("Please enter a value less than or equal to {0}."),
  7504.       min : $.validator.format("Please enter a value greater than or equal to {0}.")
  7505.     },
  7506.     autoCreateRanges : false,
  7507.     prototype : {
  7508.       /**
  7509.        * @return {undefined}
  7510.        */
  7511.       init : function() {
  7512.         /**
  7513.          * @param {Event} event
  7514.          * @return {undefined}
  7515.          */
  7516.         function start(event) {
  7517.           var _this = $.data(this.form, "validator");
  7518.           var handler = "on" + event.type.replace(/^validate/, "");
  7519.           var options = _this.settings;
  7520.           if (options[handler]) {
  7521.             if (!$(this).is(options.ignore)) {
  7522.               options[handler].call(_this, this, event);
  7523.             }
  7524.           }
  7525.         }
  7526.         this.labelContainer = $(this.settings.errorLabelContainer);
  7527.         this.errorContext = this.labelContainer.length && this.labelContainer || $(this.currentForm);
  7528.         this.containers = $(this.settings.errorContainer).add(this.settings.errorLabelContainer);
  7529.         this.submitted = {};
  7530.         this.valueCache = {};
  7531.         /** @type {number} */
  7532.         this.pendingRequest = 0;
  7533.         this.pending = {};
  7534.         this.invalid = {};
  7535.         this.reset();
  7536.         var attributes;
  7537.         var benchmarks = this.groups = {};
  7538.         $.each(this.settings.groups, function(ref, attributes) {
  7539.           if ("string" == typeof attributes) {
  7540.             /** @type {Array.<string>} */
  7541.             attributes = attributes.split(/\s/);
  7542.           }
  7543.           $.each(attributes, function(dataAndEvents, name) {
  7544.             benchmarks[name] = ref;
  7545.           });
  7546.         });
  7547.         attributes = this.settings.rules;
  7548.         $.each(attributes, function(name, value) {
  7549.           attributes[name] = $.validator.normalizeRule(value);
  7550.         });
  7551.         $(this.currentForm).on("focusin.validate focusout.validate keyup.validate", ":text, [type='password'], [type='file'], select, textarea, [type='number'], [type='search'], [type='tel'], [type='url'], [type='email'], [type='datetime'], [type='date'], [type='month'], [type='week'], [type='time'], [type='datetime-local'], [type='range'], [type='color'], [type='radio'], [type='checkbox']", start).on("click.validate", "select, option, [type='radio'], [type='checkbox']", start);
  7552.         if (this.settings.invalidHandler) {
  7553.           $(this.currentForm).on("invalid-form.validate", this.settings.invalidHandler);
  7554.         }
  7555.         $(this.currentForm).find("[required], [data-rule-required], .required").attr("aria-required", "true");
  7556.       },
  7557.       /**
  7558.        * @return {?}
  7559.        */
  7560.       form : function() {
  7561.         return this.checkForm(), $.extend(this.submitted, this.errorMap), this.invalid = $.extend({}, this.errorMap), this.valid() || $(this.currentForm).triggerHandler("invalid-form", [this]), this.showErrors(), this.valid();
  7562.       },
  7563.       /**
  7564.        * @return {?}
  7565.        */
  7566.       checkForm : function() {
  7567.         this.prepareForm();
  7568.         /** @type {number} */
  7569.         var i = 0;
  7570.         var elements = this.currentElements = this.elements();
  7571.         for (;elements[i];i++) {
  7572.           this.check(elements[i]);
  7573.         }
  7574.         return this.valid();
  7575.       },
  7576.       /**
  7577.        * @param {string} args
  7578.        * @return {?}
  7579.        */
  7580.       element : function(args) {
  7581.         var scope = this.clean(args);
  7582.         var element = this.validationTargetFor(scope);
  7583.         /** @type {boolean} */
  7584.         var checked = true;
  7585.         return this.lastElement = element, void 0 === element ? delete this.invalid[scope.name] : (this.prepareElement(element), this.currentElements = $(element), checked = this.check(element) !== false, checked ? delete this.invalid[element.name] : this.invalid[element.name] = true), $(args).attr("aria-invalid", !checked), this.numberOfInvalids() || (this.toHide = this.toHide.add(this.containers)), this.showErrors(), checked;
  7586.       },
  7587.       /**
  7588.        * @param {Object} errors
  7589.        * @return {undefined}
  7590.        */
  7591.       showErrors : function(errors) {
  7592.         if (errors) {
  7593.           $.extend(this.errorMap, errors);
  7594.           /** @type {Array} */
  7595.           this.errorList = [];
  7596.           var name;
  7597.           for (name in errors) {
  7598.             this.errorList.push({
  7599.               message : errors[name],
  7600.               element : this.findByName(name)[0]
  7601.             });
  7602.           }
  7603.           this.successList = $.grep(this.successList, function(element) {
  7604.             return!(element.name in errors);
  7605.           });
  7606.         }
  7607.         if (this.settings.showErrors) {
  7608.           this.settings.showErrors.call(this, this.errorMap, this.errorList);
  7609.         } else {
  7610.           this.defaultShowErrors();
  7611.         }
  7612.       },
  7613.       /**
  7614.        * @return {undefined}
  7615.        */
  7616.       resetForm : function() {
  7617.         if ($.fn.resetForm) {
  7618.           $(this.currentForm).resetForm();
  7619.         }
  7620.         this.submitted = {};
  7621.         /** @type {null} */
  7622.         this.lastElement = null;
  7623.         this.prepareForm();
  7624.         this.hideErrors();
  7625.         var x;
  7626.         var row = this.elements().removeData("previousValue").removeAttr("aria-invalid");
  7627.         if (this.settings.unhighlight) {
  7628.           /** @type {number} */
  7629.           x = 0;
  7630.           for (;row[x];x++) {
  7631.             this.settings.unhighlight.call(this, row[x], this.settings.errorClass, "");
  7632.           }
  7633.         } else {
  7634.           row.removeClass(this.settings.errorClass);
  7635.         }
  7636.       },
  7637.       /**
  7638.        * @return {?}
  7639.        */
  7640.       numberOfInvalids : function() {
  7641.         return this.objectLength(this.invalid);
  7642.       },
  7643.       /**
  7644.        * @param {?} object
  7645.        * @return {?}
  7646.        */
  7647.       objectLength : function(object) {
  7648.         var prop;
  7649.         /** @type {number} */
  7650.         var count = 0;
  7651.         for (prop in object) {
  7652.           count++;
  7653.         }
  7654.         return count;
  7655.       },
  7656.       /**
  7657.        * @return {undefined}
  7658.        */
  7659.       hideErrors : function() {
  7660.         this.hideThese(this.toHide);
  7661.       },
  7662.       /**
  7663.        * @param {Object} el
  7664.        * @return {undefined}
  7665.        */
  7666.       hideThese : function(el) {
  7667.         el.not(this.containers).text("");
  7668.         this.addWrapper(el).hide();
  7669.       },
  7670.       /**
  7671.        * @return {?}
  7672.        */
  7673.       valid : function() {
  7674.         return 0 === this.size();
  7675.       },
  7676.       /**
  7677.        * @return {?}
  7678.        */
  7679.       size : function() {
  7680.         return this.errorList.length;
  7681.       },
  7682.       /**
  7683.        * @return {undefined}
  7684.        */
  7685.       focusInvalid : function() {
  7686.         if (this.settings.focusInvalid) {
  7687.           try {
  7688.             $(this.findLastActive() || (this.errorList.length && this.errorList[0].element || [])).filter(":visible").focus().trigger("focusin");
  7689.           } catch (t) {
  7690.           }
  7691.         }
  7692.       },
  7693.       /**
  7694.        * @return {?}
  7695.        */
  7696.       findLastActive : function() {
  7697.         var lastActive = this.lastActive;
  7698.         return lastActive && (1 === $.grep(this.errorList, function(n) {
  7699.           return n.element.name === lastActive.name;
  7700.         }).length && lastActive);
  7701.       },
  7702.       /**
  7703.        * @return {?}
  7704.        */
  7705.       elements : function() {
  7706.         var validator = this;
  7707.         var rulesCache = {};
  7708.         return $(this.currentForm).find("input, select, textarea").not(":submit, :reset, :image, :disabled").not(this.settings.ignore).filter(function() {
  7709.           return!this.name && (validator.settings.debug && (window.console && console.error("%o has no name assigned", this))), this.name in rulesCache || !validator.objectLength($(this).rules()) ? false : (rulesCache[this.name] = true, true);
  7710.         });
  7711.       },
  7712.       /**
  7713.        * @param {string} elems
  7714.        * @return {?}
  7715.        */
  7716.       clean : function(elems) {
  7717.         return $(elems)[0];
  7718.       },
  7719.       /**
  7720.        * @return {?}
  7721.        */
  7722.       errors : function() {
  7723.         var errorClass = this.settings.errorClass.split(" ").join(".");
  7724.         return $(this.settings.errorElement + "." + errorClass, this.errorContext);
  7725.       },
  7726.       /**
  7727.        * @return {undefined}
  7728.        */
  7729.       reset : function() {
  7730.         /** @type {Array} */
  7731.         this.successList = [];
  7732.         /** @type {Array} */
  7733.         this.errorList = [];
  7734.         this.errorMap = {};
  7735.         this.toShow = $([]);
  7736.         this.toHide = $([]);
  7737.         this.currentElements = $([]);
  7738.       },
  7739.       /**
  7740.        * @return {undefined}
  7741.        */
  7742.       prepareForm : function() {
  7743.         this.reset();
  7744.         this.toHide = this.errors().add(this.containers);
  7745.       },
  7746.       /**
  7747.        * @param {Object} element
  7748.        * @return {undefined}
  7749.        */
  7750.       prepareElement : function(element) {
  7751.         this.reset();
  7752.         this.toHide = this.errorsFor(element);
  7753.       },
  7754.       /**
  7755.        * @param {Object} element
  7756.        * @return {?}
  7757.        */
  7758.       elementValue : function(element) {
  7759.         var a;
  7760.         var $element = $(element);
  7761.         var type = element.type;
  7762.         return "radio" === type || "checkbox" === type ? this.findByName(element.name).filter(":checked").val() : "number" === type && "undefined" != typeof element.validity ? element.validity.badInput ? false : $element.val() : (a = $element.val(), "string" == typeof a ? a.replace(/\r/g, "") : a);
  7763.       },
  7764.       /**
  7765.        * @param {Object} element
  7766.        * @return {?}
  7767.        */
  7768.       check : function(element) {
  7769.         element = this.validationTargetFor(this.clean(element));
  7770.         var result;
  7771.         var name;
  7772.         var rule;
  7773.         var scripts = $(element).rules();
  7774.         var cnl = $.map(scripts, function(deepDataAndEvents, dataAndEvents) {
  7775.           return dataAndEvents;
  7776.         }).length;
  7777.         /** @type {boolean} */
  7778.         var o = false;
  7779.         var val = this.elementValue(element);
  7780.         for (name in scripts) {
  7781.           rule = {
  7782.             method : name,
  7783.             parameters : scripts[name]
  7784.           };
  7785.           try {
  7786.             if (result = $.validator.methods[name].call(this, val, element, rule.parameters), "dependency-mismatch" === result && 1 === cnl) {
  7787.               /** @type {boolean} */
  7788.               o = true;
  7789.               continue;
  7790.             }
  7791.             if (o = false, "pending" === result) {
  7792.               return void(this.toHide = this.toHide.not(this.errorsFor(element)));
  7793.             }
  7794.             if (!result) {
  7795.               return this.formatAndAdd(element, rule), false;
  7796.             }
  7797.           } catch (ex) {
  7798.             throw this.settings.debug && (window.console && console.log("Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", ex)), ex instanceof TypeError && (ex.message += ".  Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method."), ex;
  7799.           }
  7800.         }
  7801.         if (!o) {
  7802.           return this.objectLength(scripts) && this.successList.push(element), true;
  7803.         }
  7804.       },
  7805.       /**
  7806.        * @param {Object} element
  7807.        * @param {string} method
  7808.        * @return {?}
  7809.        */
  7810.       customDataMessage : function(element, method) {
  7811.         return $(element).data("msg" + method.charAt(0).toUpperCase() + method.substring(1).toLowerCase()) || $(element).data("msg");
  7812.       },
  7813.       /**
  7814.        * @param {?} name
  7815.        * @param {string} method
  7816.        * @return {?}
  7817.        */
  7818.       customMessage : function(name, method) {
  7819.         var m = this.settings.messages[name];
  7820.         return m && (m.constructor === String ? m : m[method]);
  7821.       },
  7822.       /**
  7823.        * @return {?}
  7824.        */
  7825.       findDefined : function() {
  7826.         /** @type {number} */
  7827.         var i = 0;
  7828.         for (;i < arguments.length;i++) {
  7829.           if (void 0 !== arguments[i]) {
  7830.             return arguments[i];
  7831.           }
  7832.         }
  7833.         return void 0;
  7834.       },
  7835.       /**
  7836.        * @param {Object} element
  7837.        * @param {string} method
  7838.        * @return {?}
  7839.        */
  7840.       defaultMessage : function(element, method) {
  7841.         return this.findDefined(this.customMessage(element.name, method), this.customDataMessage(element, method), !this.settings.ignoreTitle && element.title || void 0, $.validator.messages[method], "<strong>Warning: No message defined for " + element.name + "</strong>");
  7842.       },
  7843.       /**
  7844.        * @param {Object} element
  7845.        * @param {Object} rule
  7846.        * @return {undefined}
  7847.        */
  7848.       formatAndAdd : function(element, rule) {
  7849.         var message = this.defaultMessage(element, rule.method);
  7850.         /** @type {RegExp} */
  7851.         var theregex = /\$?\{(\d+)\}/g;
  7852.         if ("function" == typeof message) {
  7853.           message = message.call(this, rule.parameters, element);
  7854.         } else {
  7855.           if (theregex.test(message)) {
  7856.             message = $.validator.format(message.replace(theregex, "{$1}"), rule.parameters);
  7857.           }
  7858.         }
  7859.         this.errorList.push({
  7860.           message : message,
  7861.           element : element,
  7862.           method : rule.method
  7863.         });
  7864.         this.errorMap[element.name] = message;
  7865.         this.submitted[element.name] = message;
  7866.       },
  7867.       /**
  7868.        * @param {Object} el
  7869.        * @return {?}
  7870.        */
  7871.       addWrapper : function(el) {
  7872.         return this.settings.wrapper && (el = el.add(el.parent(this.settings.wrapper))), el;
  7873.       },
  7874.       /**
  7875.        * @return {undefined}
  7876.        */
  7877.       defaultShowErrors : function() {
  7878.         var arr2;
  7879.         var error;
  7880.         /** @type {number} */
  7881.         var i = 0;
  7882.         for (;this.errorList[i];i++) {
  7883.           error = this.errorList[i];
  7884.           if (this.settings.highlight) {
  7885.             this.settings.highlight.call(this, error.element, this.settings.errorClass, this.settings.validClass);
  7886.           }
  7887.           this.showLabel(error.element, error.message);
  7888.         }
  7889.         if (this.errorList.length && (this.toShow = this.toShow.add(this.containers)), this.settings.success) {
  7890.           /** @type {number} */
  7891.           i = 0;
  7892.           for (;this.successList[i];i++) {
  7893.             this.showLabel(this.successList[i]);
  7894.           }
  7895.         }
  7896.         if (this.settings.unhighlight) {
  7897.           /** @type {number} */
  7898.           i = 0;
  7899.           arr2 = this.validElements();
  7900.           for (;arr2[i];i++) {
  7901.             this.settings.unhighlight.call(this, arr2[i], this.settings.errorClass, this.settings.validClass);
  7902.           }
  7903.         }
  7904.         this.toHide = this.toHide.not(this.toShow);
  7905.         this.hideErrors();
  7906.         this.addWrapper(this.toShow).show();
  7907.       },
  7908.       /**
  7909.        * @return {?}
  7910.        */
  7911.       validElements : function() {
  7912.         return this.currentElements.not(this.invalidElements());
  7913.       },
  7914.       /**
  7915.        * @return {?}
  7916.        */
  7917.       invalidElements : function() {
  7918.         return $(this.errorList).map(function() {
  7919.           return this.element;
  7920.         });
  7921.       },
  7922.       /**
  7923.        * @param {Object} element
  7924.        * @param {Object} message
  7925.        * @return {undefined}
  7926.        */
  7927.       showLabel : function(element, message) {
  7928.         var label;
  7929.         var bup;
  7930.         var arg;
  7931.         var input = this.errorsFor(element);
  7932.         var name = this.idOrName(element);
  7933.         var path = $(element).attr("aria-describedby");
  7934.         if (input.length) {
  7935.           input.removeClass(this.settings.validClass).addClass(this.settings.errorClass);
  7936.           input.html(message);
  7937.         } else {
  7938.           input = $("<" + this.settings.errorElement + ">").attr("id", name + "-error").addClass(this.settings.errorClass).html(message || "");
  7939.           label = input;
  7940.           if (this.settings.wrapper) {
  7941.             label = input.hide().show().wrap("<" + this.settings.wrapper + "/>").parent();
  7942.           }
  7943.           if (this.labelContainer.length) {
  7944.             this.labelContainer.append(label);
  7945.           } else {
  7946.             if (this.settings.errorPlacement) {
  7947.               this.settings.errorPlacement(label, $(element));
  7948.             } else {
  7949.               label.insertAfter(element);
  7950.             }
  7951.           }
  7952.           if (input.is("label")) {
  7953.             input.attr("for", name);
  7954.           } else {
  7955.             if (0 === input.parents("label[for='" + name + "']").length) {
  7956.               arg = input.attr("id").replace(/(:|\.|\[|\]|\$)/g, "\\$1");
  7957.               if (path) {
  7958.                 if (!path.match(new RegExp("\\b" + arg + "\\b"))) {
  7959.                   path += " " + arg;
  7960.                 }
  7961.               } else {
  7962.                 path = arg;
  7963.               }
  7964.               $(element).attr("aria-describedby", path);
  7965.               bup = this.groups[element.name];
  7966.               if (bup) {
  7967.                 $.each(this.groups, function(dataAndEvents, a) {
  7968.                   if (a === bup) {
  7969.                     $("[name='" + dataAndEvents + "']", this.currentForm).attr("aria-describedby", input.attr("id"));
  7970.                   }
  7971.                 });
  7972.               }
  7973.             }
  7974.           }
  7975.         }
  7976.         if (!message) {
  7977.           if (this.settings.success) {
  7978.             input.text("");
  7979.             if ("string" == typeof this.settings.success) {
  7980.               input.addClass(this.settings.success);
  7981.             } else {
  7982.               this.settings.success(input, element);
  7983.             }
  7984.           }
  7985.         }
  7986.         this.toShow = this.toShow.add(input);
  7987.       },
  7988.       /**
  7989.        * @param {Object} element
  7990.        * @return {?}
  7991.        */
  7992.       errorsFor : function(element) {
  7993.         var name = this.idOrName(element);
  7994.         var sValue = $(element).attr("aria-describedby");
  7995.         /** @type {string} */
  7996.         var qualifier = "label[for='" + name + "'], label[for='" + name + "'] *";
  7997.         return sValue && (qualifier = qualifier + ", #" + sValue.replace(/\s+/g, ", #")), this.errors().filter(qualifier);
  7998.       },
  7999.       /**
  8000.        * @param {Object} element
  8001.        * @return {?}
  8002.        */
  8003.       idOrName : function(element) {
  8004.         return this.groups[element.name] || (this.checkable(element) ? element.name : element.id || element.name);
  8005.       },
  8006.       /**
  8007.        * @param {Object} element
  8008.        * @return {?}
  8009.        */
  8010.       validationTargetFor : function(element) {
  8011.         return this.checkable(element) && (element = this.findByName(element.name)), $(element).not(this.settings.ignore)[0];
  8012.       },
  8013.       /**
  8014.        * @param {Object} element
  8015.        * @return {?}
  8016.        */
  8017.       checkable : function(element) {
  8018.         return/radio|checkbox/i.test(element.type);
  8019.       },
  8020.       /**
  8021.        * @param {string} name
  8022.        * @return {?}
  8023.        */
  8024.       findByName : function(name) {
  8025.         return $(this.currentForm).find("[name='" + name + "']");
  8026.       },
  8027.       /**
  8028.        * @param {string} value
  8029.        * @param {Object} element
  8030.        * @return {?}
  8031.        */
  8032.       getLength : function(value, element) {
  8033.         switch(element.nodeName.toLowerCase()) {
  8034.           case "select":
  8035.             return $("option:selected", element).length;
  8036.           case "input":
  8037.             if (this.checkable(element)) {
  8038.               return this.findByName(element.name).filter(":checked").length;
  8039.             }
  8040.           ;
  8041.         }
  8042.         return value.length;
  8043.       },
  8044.       /**
  8045.        * @param {?} param
  8046.        * @param {Object} element
  8047.        * @return {?}
  8048.        */
  8049.       depend : function(param, element) {
  8050.         return this.dependTypes[typeof param] ? this.dependTypes[typeof param](param, element) : true;
  8051.       },
  8052.       dependTypes : {
  8053.         /**
  8054.          * @param {?} param
  8055.          * @return {?}
  8056.          */
  8057.         boolean : function(param) {
  8058.           return param;
  8059.         },
  8060.         /**
  8061.          * @param {?} param
  8062.          * @param {Object} element
  8063.          * @return {?}
  8064.          */
  8065.         string : function(param, element) {
  8066.           return!!$(param, element.form).length;
  8067.         },
  8068.         /**
  8069.          * @param {?} param
  8070.          * @param {?} element
  8071.          * @return {?}
  8072.          */
  8073.         "function" : function(param, element) {
  8074.           return param(element);
  8075.         }
  8076.       },
  8077.       /**
  8078.        * @param {?} allow
  8079.        * @return {?}
  8080.        */
  8081.       optional : function(allow) {
  8082.         var val = this.elementValue(allow);
  8083.         return!$.validator.methods.required.call(this, val, allow) && "dependency-mismatch";
  8084.       },
  8085.       /**
  8086.        * @param {Function} element
  8087.        * @return {undefined}
  8088.        */
  8089.       startRequest : function(element) {
  8090.         if (!this.pending[element.name]) {
  8091.           this.pendingRequest++;
  8092.           /** @type {boolean} */
  8093.           this.pending[element.name] = true;
  8094.         }
  8095.       },
  8096.       /**
  8097.        * @param {Function} element
  8098.        * @param {boolean} valid
  8099.        * @return {undefined}
  8100.        */
  8101.       stopRequest : function(element, valid) {
  8102.         this.pendingRequest--;
  8103.         if (this.pendingRequest < 0) {
  8104.           /** @type {number} */
  8105.           this.pendingRequest = 0;
  8106.         }
  8107.         delete this.pending[element.name];
  8108.         if (valid && (0 === this.pendingRequest && (this.formSubmitted && this.form()))) {
  8109.           $(this.currentForm).submit();
  8110.           /** @type {boolean} */
  8111.           this.formSubmitted = false;
  8112.         } else {
  8113.           if (!valid) {
  8114.             if (0 === this.pendingRequest) {
  8115.               if (this.formSubmitted) {
  8116.                 $(this.currentForm).triggerHandler("invalid-form", [this]);
  8117.                 /** @type {boolean} */
  8118.                 this.formSubmitted = false;
  8119.               }
  8120.             }
  8121.           }
  8122.         }
  8123.       },
  8124.       /**
  8125.        * @param {string} ast
  8126.        * @return {?}
  8127.        */
  8128.       previousValue : function(ast) {
  8129.         return $.data(ast, "previousValue") || $.data(ast, "previousValue", {
  8130.           old : null,
  8131.           valid : true,
  8132.           message : this.defaultMessage(ast, "remote")
  8133.         });
  8134.       },
  8135.       /**
  8136.        * @return {undefined}
  8137.        */
  8138.       destroy : function() {
  8139.         this.resetForm();
  8140.         $(this.currentForm).off(".validate").removeData("validator");
  8141.       }
  8142.     },
  8143.     classRuleSettings : {
  8144.       required : {
  8145.         required : true
  8146.       },
  8147.       email : {
  8148.         email : true
  8149.       },
  8150.       url : {
  8151.         url : true
  8152.       },
  8153.       date : {
  8154.         date : true
  8155.       },
  8156.       dateISO : {
  8157.         dateISO : true
  8158.       },
  8159.       number : {
  8160.         number : true
  8161.       },
  8162.       digits : {
  8163.         digits : true
  8164.       },
  8165.       creditcard : {
  8166.         creditcard : true
  8167.       }
  8168.     },
  8169.     /**
  8170.      * @param {?} className
  8171.      * @param {?} rules
  8172.      * @return {undefined}
  8173.      */
  8174.     addClassRules : function(className, rules) {
  8175.       if (className.constructor === String) {
  8176.         this.classRuleSettings[className] = rules;
  8177.       } else {
  8178.         $.extend(this.classRuleSettings, className);
  8179.       }
  8180.     },
  8181.     /**
  8182.      * @param {?} element
  8183.      * @return {?}
  8184.      */
  8185.     classRules : function(element) {
  8186.       var deep = {};
  8187.       var classes = $(element).attr("class");
  8188.       return classes && $.each(classes.split(" "), function() {
  8189.         if (this in $.validator.classRuleSettings) {
  8190.           $.extend(deep, $.validator.classRuleSettings[this]);
  8191.         }
  8192.       }), deep;
  8193.     },
  8194.     /**
  8195.      * @param {Object} obj
  8196.      * @param {?} value
  8197.      * @param {?} key
  8198.      * @param {Object} val
  8199.      * @return {undefined}
  8200.      */
  8201.     normalizeAttributeRule : function(obj, value, key, val) {
  8202.       if (/min|max/.test(key)) {
  8203.         if (null === value || /number|range|text/.test(value)) {
  8204.           /** @type {number} */
  8205.           val = Number(val);
  8206.           if (isNaN(val)) {
  8207.             val = void 0;
  8208.           }
  8209.         }
  8210.       }
  8211.       if (val || 0 === val) {
  8212.         /** @type {Object} */
  8213.         obj[key] = val;
  8214.       } else {
  8215.         if (value === key) {
  8216.           if ("range" !== value) {
  8217.             /** @type {boolean} */
  8218.             obj[key] = true;
  8219.           }
  8220.         }
  8221.       }
  8222.     },
  8223.     /**
  8224.      * @param {Element} element
  8225.      * @return {?}
  8226.      */
  8227.     attributeRules : function(element) {
  8228.       var key;
  8229.       var val;
  8230.       var rules = {};
  8231.       var nodes = $(element);
  8232.       var udataCur = element.getAttribute("type");
  8233.       for (key in $.validator.methods) {
  8234.         if ("required" === key) {
  8235.           val = element.getAttribute(key);
  8236.           if ("" === val) {
  8237.             /** @type {boolean} */
  8238.             val = true;
  8239.           }
  8240.           /** @type {boolean} */
  8241.           val = !!val;
  8242.         } else {
  8243.           val = nodes.attr(key);
  8244.         }
  8245.         this.normalizeAttributeRule(rules, udataCur, key, val);
  8246.       }
  8247.       return rules.maxlength && (/-1|2147483647|524288/.test(rules.maxlength) && delete rules.maxlength), rules;
  8248.     },
  8249.     /**
  8250.      * @param {Element} element
  8251.      * @return {?}
  8252.      */
  8253.     dataRules : function(element) {
  8254.       var key;
  8255.       var indents;
  8256.       var suiteView = {};
  8257.       var $element = $(element);
  8258.       var udataCur = element.getAttribute("type");
  8259.       for (key in $.validator.methods) {
  8260.         indents = $element.data("rule" + key.charAt(0).toUpperCase() + key.substring(1).toLowerCase());
  8261.         this.normalizeAttributeRule(suiteView, udataCur, key, indents);
  8262.       }
  8263.       return suiteView;
  8264.     },
  8265.     /**
  8266.      * @param {Object} element
  8267.      * @return {?}
  8268.      */
  8269.     staticRules : function(element) {
  8270.       var rules = {};
  8271.       var validator = $.data(element.form, "validator");
  8272.       return validator.settings.rules && (rules = $.validator.normalizeRule(validator.settings.rules[element.name]) || {}), rules;
  8273.     },
  8274.     /**
  8275.      * @param {Object} rules
  8276.      * @param {Object} element
  8277.      * @return {?}
  8278.      */
  8279.     normalizeRules : function(rules, element) {
  8280.       return $.each(rules, function(prop, val) {
  8281.         if (val === false) {
  8282.           return void delete rules[prop];
  8283.         }
  8284.         if (val.param || val.depends) {
  8285.           /** @type {boolean} */
  8286.           var keepRule = true;
  8287.           switch(typeof val.depends) {
  8288.             case "string":
  8289.               /** @type {boolean} */
  8290.               keepRule = !!$(val.depends, element.form).length;
  8291.               break;
  8292.             case "function":
  8293.               keepRule = val.depends.call(element, element);
  8294.           }
  8295.           if (keepRule) {
  8296.             rules[prop] = void 0 !== val.param ? val.param : true;
  8297.           } else {
  8298.             delete rules[prop];
  8299.           }
  8300.         }
  8301.       }), $.each(rules, function(rule, parameter) {
  8302.         rules[rule] = $.isFunction(parameter) ? parameter(element) : parameter;
  8303.       }), $.each(["minlength", "maxlength"], function() {
  8304.         if (rules[this]) {
  8305.           /** @type {number} */
  8306.           rules[this] = Number(rules[this]);
  8307.         }
  8308.       }), $.each(["rangelength", "range"], function() {
  8309.         var regExpResultArray;
  8310.         if (rules[this]) {
  8311.           if ($.isArray(rules[this])) {
  8312.             /** @type {Array} */
  8313.             rules[this] = [Number(rules[this][0]), Number(rules[this][1])];
  8314.           } else {
  8315.             if ("string" == typeof rules[this]) {
  8316.               regExpResultArray = rules[this].replace(/[\[\]]/g, "").split(/[\s,]+/);
  8317.               /** @type {Array} */
  8318.               rules[this] = [Number(regExpResultArray[0]), Number(regExpResultArray[1])];
  8319.             }
  8320.           }
  8321.         }
  8322.       }), $.validator.autoCreateRanges && (null != rules.min && (null != rules.max && (rules.range = [rules.min, rules.max], delete rules.min, delete rules.max)), null != rules.minlength && (null != rules.maxlength && (rules.rangelength = [rules.minlength, rules.maxlength], delete rules.minlength, delete rules.maxlength))), rules;
  8323.     },
  8324.     /**
  8325.      * @param {string} data
  8326.      * @return {?}
  8327.      */
  8328.     normalizeRule : function(data) {
  8329.       if ("string" == typeof data) {
  8330.         var tmp = {};
  8331.         $.each(data.split(/\s/), function() {
  8332.           /** @type {boolean} */
  8333.           tmp[this] = true;
  8334.         });
  8335.         data = tmp;
  8336.       }
  8337.       return data;
  8338.     },
  8339.     /**
  8340.      * @param {string} name
  8341.      * @param {Function} method
  8342.      * @param {string} message
  8343.      * @return {undefined}
  8344.      */
  8345.     addMethod : function(name, method, message) {
  8346.       /** @type {Function} */
  8347.       $.validator.methods[name] = method;
  8348.       $.validator.messages[name] = void 0 !== message ? message : $.validator.messages[name];
  8349.       if (method.length < 3) {
  8350.         $.validator.addClassRules(name, $.validator.normalizeRule(name));
  8351.       }
  8352.     },
  8353.     methods : {
  8354.       /**
  8355.        * @param {string} value
  8356.        * @param {Object} element
  8357.        * @param {?} param
  8358.        * @return {?}
  8359.        */
  8360.       required : function(value, element, param) {
  8361.         if (!this.depend(param, element)) {
  8362.           return "dependency-mismatch";
  8363.         }
  8364.         if ("select" === element.nodeName.toLowerCase()) {
  8365.           var codeSegments = $(element).val();
  8366.           return codeSegments && codeSegments.length > 0;
  8367.         }
  8368.         return this.checkable(element) ? this.getLength(value, element) > 0 : value.length > 0;
  8369.       },
  8370.       /**
  8371.        * @param {?} value
  8372.        * @param {?} element
  8373.        * @return {?}
  8374.        */
  8375.       email : function(value, element) {
  8376.         return this.optional(element) || /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(value);
  8377.       },
  8378.       /**
  8379.        * @param {string} args
  8380.        * @param {?} element
  8381.        * @return {?}
  8382.        */
  8383.       url : function(args, element) {
  8384.         return this.optional(element) || /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})).?)(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(args);
  8385.       },
  8386.       /**
  8387.        * @param {number} input
  8388.        * @param {?} element
  8389.        * @return {?}
  8390.        */
  8391.       date : function(input, element) {
  8392.         return this.optional(element) || !/Invalid|NaN/.test((new Date(input)).toString());
  8393.       },
  8394.       /**
  8395.        * @param {?} value
  8396.        * @param {?} element
  8397.        * @return {?}
  8398.        */
  8399.       dateISO : function(value, element) {
  8400.         return this.optional(element) || /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value);
  8401.       },
  8402.       /**
  8403.        * @param {?} value
  8404.        * @param {?} element
  8405.        * @return {?}
  8406.        */
  8407.       number : function(value, element) {
  8408.         return this.optional(element) || /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value);
  8409.       },
  8410.       /**
  8411.        * @param {?} value
  8412.        * @param {?} element
  8413.        * @return {?}
  8414.        */
  8415.       digits : function(value, element) {
  8416.         return this.optional(element) || /^\d+$/.test(value);
  8417.       },
  8418.       /**
  8419.        * @param {string} value
  8420.        * @param {?} element
  8421.        * @return {?}
  8422.        */
  8423.       creditcard : function(value, element) {
  8424.         if (this.optional(element)) {
  8425.           return "dependency-mismatch";
  8426.         }
  8427.         if (/[^0-9 \-]+/.test(value)) {
  8428.           return false;
  8429.         }
  8430.         var valueIndex;
  8431.         var cDigit;
  8432.         /** @type {number} */
  8433.         var nCheck = 0;
  8434.         /** @type {number} */
  8435.         var nDigit = 0;
  8436.         /** @type {boolean} */
  8437.         var perm = false;
  8438.         if (value = value.replace(/\D/g, ""), value.length < 13 || value.length > 19) {
  8439.           return false;
  8440.         }
  8441.         /** @type {number} */
  8442.         valueIndex = value.length - 1;
  8443.         for (;valueIndex >= 0;valueIndex--) {
  8444.           cDigit = value.charAt(valueIndex);
  8445.           /** @type {number} */
  8446.           nDigit = parseInt(cDigit, 10);
  8447.           if (perm) {
  8448.             if ((nDigit *= 2) > 9) {
  8449.               nDigit -= 9;
  8450.             }
  8451.           }
  8452.           nCheck += nDigit;
  8453.           /** @type {boolean} */
  8454.           perm = !perm;
  8455.         }
  8456.         return nCheck % 10 == 0;
  8457.       },
  8458.       /**
  8459.        * @param {string} value
  8460.        * @param {Object} element
  8461.        * @param {?} param
  8462.        * @return {?}
  8463.        */
  8464.       minlength : function(value, element, param) {
  8465.         var length = $.isArray(value) ? value.length : this.getLength(value, element);
  8466.         return this.optional(element) || length >= param;
  8467.       },
  8468.       /**
  8469.        * @param {string} value
  8470.        * @param {Object} element
  8471.        * @param {number} length
  8472.        * @return {?}
  8473.        */
  8474.       maxlength : function(value, element, length) {
  8475.         var param = $.isArray(value) ? value.length : this.getLength(value, element);
  8476.         return this.optional(element) || length >= param;
  8477.       },
  8478.       /**
  8479.        * @param {string} value
  8480.        * @param {Object} element
  8481.        * @param {Array} param
  8482.        * @return {?}
  8483.        */
  8484.       rangelength : function(value, element, param) {
  8485.         var length = $.isArray(value) ? value.length : this.getLength(value, element);
  8486.         return this.optional(element) || length >= param[0] && length <= param[1];
  8487.       },
  8488.       /**
  8489.        * @param {number} value
  8490.        * @param {number} element
  8491.        * @param {number} param
  8492.        * @return {?}
  8493.        */
  8494.       min : function(value, element, param) {
  8495.         return this.optional(element) || value >= param;
  8496.       },
  8497.       /**
  8498.        * @param {number} param
  8499.        * @param {number} element
  8500.        * @param {number} value
  8501.        * @return {?}
  8502.        */
  8503.       max : function(param, element, value) {
  8504.         return this.optional(element) || value >= param;
  8505.       },
  8506.       /**
  8507.        * @param {?} value
  8508.        * @param {?} element
  8509.        * @param {Array} param
  8510.        * @return {?}
  8511.        */
  8512.       range : function(value, element, param) {
  8513.         return this.optional(element) || value >= param[0] && value <= param[1];
  8514.       },
  8515.       /**
  8516.        * @param {?} value
  8517.        * @param {?} element
  8518.        * @param {?} equalTo
  8519.        * @return {?}
  8520.        */
  8521.       equalTo : function(value, element, equalTo) {
  8522.         var el = $(equalTo);
  8523.         return this.settings.onfocusout && el.off(".validate-equalTo").on("blur.validate-equalTo", function() {
  8524.           $(element).valid();
  8525.         }), value === el.val();
  8526.       },
  8527.       /**
  8528.        * @param {string} value
  8529.        * @param {Object} element
  8530.        * @param {(Function|string)} param
  8531.        * @return {?}
  8532.        */
  8533.       remote : function(value, element, param) {
  8534.         if (this.optional(element)) {
  8535.           return "dependency-mismatch";
  8536.         }
  8537.         var validator;
  8538.         var data;
  8539.         var previous = this.previousValue(element);
  8540.         return this.settings.messages[element.name] || (this.settings.messages[element.name] = {}), previous.originalMessage = this.settings.messages[element.name].remote, this.settings.messages[element.name].remote = previous.message, param = "string" == typeof param && {
  8541.           url : param
  8542.         } || param, previous.old === value ? previous.valid : (previous.old = value, validator = this, this.startRequest(element), data = {}, data[element.name] = value, $.ajax($.extend(true, {
  8543.           mode : "abort",
  8544.           port : "validate" + element.name,
  8545.           dataType : "json",
  8546.           data : data,
  8547.           context : validator.currentForm,
  8548.           /**
  8549.            * @param {string} args
  8550.            * @return {undefined}
  8551.            */
  8552.           success : function(args) {
  8553.             var errors;
  8554.             var message;
  8555.             var submitted;
  8556.             /** @type {boolean} */
  8557.             var valid = args === true || "true" === args;
  8558.             validator.settings.messages[element.name].remote = previous.originalMessage;
  8559.             if (valid) {
  8560.               submitted = validator.formSubmitted;
  8561.               validator.prepareElement(element);
  8562.               validator.formSubmitted = submitted;
  8563.               validator.successList.push(element);
  8564.               delete validator.invalid[element.name];
  8565.               validator.showErrors();
  8566.             } else {
  8567.               errors = {};
  8568.               message = args || validator.defaultMessage(element, "remote");
  8569.               errors[element.name] = previous.message = $.isFunction(message) ? message(value) : message;
  8570.               /** @type {boolean} */
  8571.               validator.invalid[element.name] = true;
  8572.               validator.showErrors(errors);
  8573.             }
  8574.             /** @type {boolean} */
  8575.             previous.valid = valid;
  8576.             validator.stopRequest(element, valid);
  8577.           }
  8578.         }, param)), "pending");
  8579.       }
  8580.     }
  8581.   });
  8582.   var matcherFunction;
  8583.   var pendingRequests = {};
  8584.   if ($.ajaxPrefilter) {
  8585.     $.ajaxPrefilter(function(settings, dataAndEvents, xhr) {
  8586.       var port = settings.port;
  8587.       if ("abort" === settings.mode) {
  8588.         if (pendingRequests[port]) {
  8589.           pendingRequests[port].abort();
  8590.         }
  8591.         pendingRequests[port] = xhr;
  8592.       }
  8593.     });
  8594.   } else {
  8595.     /** @type {function (Object): ?} */
  8596.     matcherFunction = $.ajax;
  8597.     /**
  8598.      * @param {Object} settings
  8599.      * @return {?}
  8600.      */
  8601.     $.ajax = function(settings) {
  8602.       var mode = ("mode" in settings ? settings : $.ajaxSettings).mode;
  8603.       var port = ("port" in settings ? settings : $.ajaxSettings).port;
  8604.       return "abort" === mode ? (pendingRequests[port] && pendingRequests[port].abort(), pendingRequests[port] = matcherFunction.apply(this, arguments), pendingRequests[port]) : matcherFunction.apply(this, arguments);
  8605.     };
  8606.   }
  8607. }), function($) {
  8608.   /**
  8609.    * @param {Object} options
  8610.    * @param {string} ruleName
  8611.    * @param {Object} value
  8612.    * @return {undefined}
  8613.    */
  8614.   function setValidationValues(options, ruleName, value) {
  8615.     /** @type {Object} */
  8616.     options.rules[ruleName] = value;
  8617.     if (options.message) {
  8618.       options.messages[ruleName] = options.message;
  8619.     }
  8620.   }
  8621.   /**
  8622.    * @param {string} value
  8623.    * @return {?}
  8624.    */
  8625.   function splitAndTrim(value) {
  8626.     return value.replace(/^\s+|\s+$/g, "").split(/\s*,\s*/g);
  8627.   }
  8628.   /**
  8629.    * @param {string} value
  8630.    * @return {?}
  8631.    */
  8632.   function escapeAttributeValue(value) {
  8633.     return value.replace(/([!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~])/g, "\\$1");
  8634.  }
  8635.  /**
  8636.   * @param {string} fieldName
  8637.   * @return {?}
  8638.   */
  8639.  function getModelPrefix(fieldName) {
  8640.    return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
  8641.  }
  8642.  /**
  8643.   * @param {string} value
  8644.   * @param {?} prefix
  8645.   * @return {?}
  8646.   */
  8647.  function appendModelPrefix(value, prefix) {
  8648.    return value.indexOf("*.") === 0 && (value = value.replace("*.", prefix)), value;
  8649.  }
  8650.  /**
  8651.   * @param {Object} error
  8652.   * @param {Array} msg
  8653.   * @return {undefined}
  8654.   */
  8655.  function onError(error, msg) {
  8656.    var container = $(this).find("[data-valmsg-for='" + escapeAttributeValue(msg[0].name) + "']");
  8657.    var key = container.attr("data-valmsg-replace");
  8658.    /** @type {(boolean|null)} */
  8659.    var id = key ? $.parseJSON(key) !== false : null;
  8660.    container.removeClass("field-validation-valid").addClass("field-validation-error");
  8661.    error.data("unobtrusiveContainer", container);
  8662.    if (id) {
  8663.      container.empty();
  8664.      error.removeClass("input-validation-error").appendTo(container);
  8665.    } else {
  8666.      error.hide();
  8667.    }
  8668.  }
  8669.  /**
  8670.   * @param {?} event
  8671.   * @param {?} validator
  8672.   * @return {undefined}
  8673.   */
  8674.  function onErrors(event, validator) {
  8675.    var container = $(this).find("[data-valmsg-summary=true]");
  8676.    var list = container.find("ul");
  8677.    if (list) {
  8678.      if (list.length) {
  8679.        if (validator.errorList.length) {
  8680.          list.empty();
  8681.          container.addClass("validation-summary-errors").removeClass("validation-summary-valid");
  8682.          $.each(validator.errorList, function() {
  8683.            $("<li />").html(this.message).appendTo(list);
  8684.          });
  8685.        }
  8686.      }
  8687.    }
  8688.  }
  8689.  /**
  8690.   * @param {Object} error
  8691.   * @return {undefined}
  8692.   */
  8693.  function onSuccess(error) {
  8694.    var container = error.data("unobtrusiveContainer");
  8695.    var selector = container.attr("data-valmsg-replace");
  8696.    var elems = selector ? $.parseJSON(selector) : null;
  8697.    if (container) {
  8698.      container.addClass("field-validation-valid").removeClass("field-validation-error");
  8699.      error.removeData("unobtrusiveContainer");
  8700.      if (elems) {
  8701.        container.empty();
  8702.      }
  8703.    }
  8704.  }
  8705.  /**
  8706.   * @return {undefined}
  8707.   */
  8708.  function onReset() {
  8709.    var $form = $(this);
  8710.    $form.data("validator").resetForm();
  8711.    $form.find(".validation-summary-errors").addClass("validation-summary-valid").removeClass("validation-summary-errors");
  8712.    $form.find(".field-validation-error").addClass("field-validation-valid").removeClass("field-validation-error").removeData("unobtrusiveContainer").find(">*").removeData("unobtrusiveContainer");
  8713.  }
  8714.  /**
  8715.   * @param {Object} self
  8716.   * @return {?}
  8717.   */
  8718.  function validationInfo(self) {
  8719.    var that = $(self);
  8720.    var result = that.data(typePattern);
  8721.    var selector = $.proxy(onReset, self);
  8722.    var options = $jQval.unobtrusive.options || {};
  8723.    /**
  8724.     * @param {string} arg
  8725.     * @param {Object} args
  8726.     * @return {undefined}
  8727.     */
  8728.    var exec = function(arg, args) {
  8729.      var fn = options[arg];
  8730.      if (fn) {
  8731.        if ($.isFunction(fn)) {
  8732.          fn.apply(self, args);
  8733.        }
  8734.      }
  8735.    };
  8736.    return result || (result = {
  8737.      options : {
  8738.        errorClass : options.errorClass || "input-validation-error",
  8739.        errorElement : options.errorElement || "span",
  8740.        /**
  8741.         * @return {undefined}
  8742.         */
  8743.        errorPlacement : function() {
  8744.          onError.apply(self, arguments);
  8745.          exec("errorPlacement", arguments);
  8746.        },
  8747.        /**
  8748.         * @return {undefined}
  8749.         */
  8750.        invalidHandler : function() {
  8751.          onErrors.apply(self, arguments);
  8752.          exec("invalidHandler", arguments);
  8753.        },
  8754.        messages : {},
  8755.        rules : {},
  8756.        /**
  8757.         * @return {undefined}
  8758.         */
  8759.        success : function() {
  8760.          onSuccess.apply(self, arguments);
  8761.          exec("success", arguments);
  8762.        }
  8763.      },
  8764.      /**
  8765.       * @return {undefined}
  8766.       */
  8767.      attachValidation : function() {
  8768.        that.off("reset." + typePattern, selector).on("reset." + typePattern, selector).validate(this.options);
  8769.      },
  8770.      /**
  8771.       * @return {?}
  8772.       */
  8773.      validate : function() {
  8774.        return that.validate(), that.valid();
  8775.      }
  8776.    }, that.data(typePattern, result)), result;
  8777.  }
  8778.  var $jQval = $.validator;
  8779.  var adapters;
  8780.  /** @type {string} */
  8781.  var typePattern = "unobtrusiveValidation";
  8782.  $jQval.unobtrusive = {
  8783.    adapters : [],
  8784.    /**
  8785.     * @param {Object} element
  8786.     * @param {boolean} dataAndEvents
  8787.     * @return {undefined}
  8788.     */
  8789.    parseElement : function(element, dataAndEvents) {
  8790.      var $element = $(element);
  8791.      var form = $element.parents("form")[0];
  8792.      var valInfo;
  8793.      var deep;
  8794.      var messages;
  8795.      if (form) {
  8796.        valInfo = validationInfo(form);
  8797.        valInfo.options.rules[element.name] = deep = {};
  8798.        valInfo.options.messages[element.name] = messages = {};
  8799.        $.each(this.adapters, function() {
  8800.          /** @type {string} */
  8801.          var prefix = "data-val-" + this.name;
  8802.          var message = $element.attr(prefix);
  8803.          var paramValues = {};
  8804.          if (message !== undefined) {
  8805.            prefix += "-";
  8806.            $.each(this.params, function() {
  8807.              paramValues[this] = $element.attr(prefix + this);
  8808.            });
  8809.            this.adapt({
  8810.              element : element,
  8811.              form : form,
  8812.              message : message,
  8813.              params : paramValues,
  8814.              rules : deep,
  8815.              messages : messages
  8816.            });
  8817.          }
  8818.        });
  8819.        $.extend(deep, {
  8820.          __dummy__ : true
  8821.        });
  8822.        if (!dataAndEvents) {
  8823.          valInfo.attachValidation();
  8824.        }
  8825.      }
  8826.    },
  8827.    /**
  8828.     * @param {(Node|string)} target
  8829.     * @return {undefined}
  8830.     */
  8831.    parse : function(target) {
  8832.      var $target = $(target);
  8833.      var cursor = $target.parents().addBack().filter("form").add($target.find("form")).has("[data-val=true]");
  8834.      $target.find("[data-val=true]").each(function() {
  8835.        $jQval.unobtrusive.parseElement(this, true);
  8836.      });
  8837.      cursor.each(function() {
  8838.        var info = validationInfo(this);
  8839.        if (info) {
  8840.          info.attachValidation();
  8841.        }
  8842.      });
  8843.    }
  8844.  };
  8845.  /** @type {Array} */
  8846.  adapters = $jQval.unobtrusive.adapters;
  8847.  /**
  8848.   * @param {string} name
  8849.   * @param {Object} val
  8850.   * @param {Object} fn
  8851.   * @return {?}
  8852.   */
  8853.  adapters.add = function(name, val, fn) {
  8854.    return fn || (fn = val, val = []), this.push({
  8855.      name : name,
  8856.      params : val,
  8857.      adapt : fn
  8858.    }), this;
  8859.  };
  8860.  /**
  8861.   * @param {string} adapterName
  8862.   * @param {(Function|string)} ruleName
  8863.   * @return {?}
  8864.   */
  8865.  adapters.addBool = function(adapterName, ruleName) {
  8866.    return this.add(adapterName, function(options) {
  8867.      setValidationValues(options, ruleName || adapterName, true);
  8868.    });
  8869.  };
  8870.  /**
  8871.   * @param {Window} key
  8872.   * @param {string} minRuleName
  8873.   * @param {string} maxRuleName
  8874.   * @param {string} minMaxRuleName
  8875.   * @param {string} minAttribute
  8876.   * @param {string} maxAttribute
  8877.   * @return {?}
  8878.   */
  8879.  adapters.addMinMax = function(key, minRuleName, maxRuleName, minMaxRuleName, minAttribute, maxAttribute) {
  8880.    return this.add(key, [minAttribute || "min", maxAttribute || "max"], function(options) {
  8881.      var min = options.params.min;
  8882.      var max = options.params.max;
  8883.      if (min && max) {
  8884.        setValidationValues(options, minMaxRuleName, [min, max]);
  8885.      } else {
  8886.        if (min) {
  8887.          setValidationValues(options, minRuleName, min);
  8888.        } else {
  8889.          if (max) {
  8890.            setValidationValues(options, maxRuleName, max);
  8891.          }
  8892.        }
  8893.      }
  8894.    });
  8895.  };
  8896.  /**
  8897.   * @param {Window} adapterName
  8898.   * @param {string} attribute
  8899.   * @param {Window} ruleName
  8900.   * @return {?}
  8901.   */
  8902.  adapters.addSingleVal = function(adapterName, attribute, ruleName) {
  8903.    return this.add(adapterName, [attribute || "val"], function(options) {
  8904.      setValidationValues(options, ruleName || adapterName, options.params[attribute]);
  8905.    });
  8906.  };
  8907.  $jQval.addMethod("__dummy__", function() {
  8908.    return true;
  8909.  });
  8910.  $jQval.addMethod("regex", function(value, element, params) {
  8911.    var a;
  8912.    return this.optional(element) ? true : (a = (new RegExp(params)).exec(value), a && (a.index === 0 && a[0].length === value.length));
  8913.  });
  8914.  $jQval.addMethod("nonalphamin", function($2, dataAndEvents, nonalphamin) {
  8915.    var match;
  8916.    return nonalphamin && (match = $2.match(/\W/g), match = match && match.length >= nonalphamin), match;
  8917.  });
  8918.  if ($jQval.methods.extension) {
  8919.    adapters.addSingleVal("accept", "mimtype");
  8920.    adapters.addSingleVal("extension", "extension");
  8921.  } else {
  8922.    adapters.addSingleVal("extension", "extension", "accept");
  8923.  }
  8924.  adapters.addSingleVal("regex", "pattern");
  8925.  adapters.addBool("creditcard").addBool("date").addBool("digits").addBool("email").addBool("number").addBool("url");
  8926.  adapters.addMinMax("length", "minlength", "maxlength", "rangelength").addMinMax("range", "min", "max", "range");
  8927.  adapters.addMinMax("minlength", "minlength").addMinMax("maxlength", "minlength", "maxlength");
  8928.  adapters.add("equalto", ["other"], function(options) {
  8929.    var prefix = getModelPrefix(options.element.name);
  8930.    var other = options.params.other;
  8931.    var fullOtherName = appendModelPrefix(other, prefix);
  8932.    var udataCur = $(options.form).find(":input").filter("[name='" + escapeAttributeValue(fullOtherName) + "']")[0];
  8933.    setValidationValues(options, "equalTo", udataCur);
  8934.  });
  8935.  adapters.add("required", function(options) {
  8936.    if (options.element.tagName.toUpperCase() !== "INPUT" || options.element.type.toUpperCase() !== "CHECKBOX") {
  8937.      setValidationValues(options, "required", true);
  8938.    }
  8939.  });
  8940.  adapters.add("remote", ["url", "type", "additionalfields"], function(options) {
  8941.    var value = {
  8942.      url : options.params.url,
  8943.      type : options.params.type || "GET",
  8944.      data : {}
  8945.    };
  8946.    var prefix = getModelPrefix(options.element.name);
  8947.    $.each(splitAndTrim(options.params.additionalfields || options.element.name), function(dataAndEvents, fieldName) {
  8948.      var paramName = appendModelPrefix(fieldName, prefix);
  8949.      /**
  8950.       * @return {?}
  8951.       */
  8952.      value.data[paramName] = function() {
  8953.        return $(options.form).find(":input").filter("[name='" + escapeAttributeValue(paramName) + "']").val();
  8954.      };
  8955.    });
  8956.    setValidationValues(options, "remote", value);
  8957.  });
  8958.  adapters.add("password", ["min", "nonalphamin", "regex"], function(options) {
  8959.    if (options.params.min) {
  8960.      setValidationValues(options, "minlength", options.params.min);
  8961.    }
  8962.    if (options.params.nonalphamin) {
  8963.      setValidationValues(options, "nonalphamin", options.params.nonalphamin);
  8964.    }
  8965.    if (options.params.regex) {
  8966.      setValidationValues(options, "regex", options.params.regex);
  8967.    }
  8968.  });
  8969.  $(function() {
  8970.    $jQval.unobtrusive.parse(document);
  8971.  });
  8972. }(jQuery);
  8973. window.Modernizr = function(win, doc, value) {
  8974.  /**
  8975.   * @param {string} str
  8976.   * @return {undefined}
  8977.   */
  8978.  function setCss(str) {
  8979.    /** @type {string} */
  8980.    mStyle.cssText = str;
  8981.  }
  8982.  /**
  8983.   * @param {string} str1
  8984.   * @param {string} str2
  8985.   * @return {?}
  8986.   */
  8987.  function setCssAll(str1, str2) {
  8988.    return setCss(prefixes.join(str1 + ";") + (str2 || ""));
  8989.  }
  8990.  /**
  8991.   * @param {Function} obj
  8992.   * @param {string} type
  8993.   * @return {?}
  8994.   */
  8995.  function is(obj, type) {
  8996.    return typeof obj === type;
  8997.  }
  8998.  /**
  8999.   * @param {string} str
  9000.   * @param {string} substr
  9001.   * @return {?}
  9002.   */
  9003.  function contains(str, substr) {
  9004.    return!!~("" + str).indexOf(substr);
  9005.  }
  9006.  /**
  9007.   * @param {Array} props
  9008.   * @param {string} prefixed
  9009.   * @return {?}
  9010.   */
  9011.  function testProps(props, prefixed) {
  9012.    var i;
  9013.    var prop;
  9014.    for (i in props) {
  9015.      if (prop = props[i], !contains(prop, "-") && mStyle[prop] !== value) {
  9016.        return prefixed == "pfx" ? prop : true;
  9017.      }
  9018.    }
  9019.    return false;
  9020.  }
  9021.  /**
  9022.   * @param {Array} props
  9023.   * @param {Object} obj
  9024.   * @param {boolean} elem
  9025.   * @return {?}
  9026.   */
  9027.  function testDOMProps(props, obj, elem) {
  9028.    var i;
  9029.    var item;
  9030.    for (i in props) {
  9031.      if (item = obj[props[i]], item !== value) {
  9032.        return elem === false ? props[i] : is(item, "function") ? item.bind(elem || obj) : item;
  9033.      }
  9034.    }
  9035.    return false;
  9036.  }
  9037.  /**
  9038.   * @param {string} prop
  9039.   * @param {?} prefixed
  9040.   * @param {boolean} elem
  9041.   * @return {?}
  9042.   */
  9043.  function testPropsAll(prop, prefixed, elem) {
  9044.    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1);
  9045.    /** @type {Array.<string>} */
  9046.    var props = (prop + " " + cssomPrefixes.join(ucProp + " ") + ucProp).split(" ");
  9047.    return is(prefixed, "string") || is(prefixed, "undefined") ? testProps(props, prefixed) : (props = (prop + " " + domPrefixes.join(ucProp + " ") + ucProp).split(" "), testDOMProps(props, prefixed, elem));
  9048.  }
  9049.  /**
  9050.   * @return {undefined}
  9051.   */
  9052.  function webforms() {
  9053.    Modernizr.input = function(props) {
  9054.      /** @type {number} */
  9055.      var i = 0;
  9056.      /** @type {number} */
  9057.      var l = props.length;
  9058.      for (;i < l;i++) {
  9059.        /** @type {boolean} */
  9060.        css[props[i]] = !!(props[i] in inputElem);
  9061.      }
  9062.      return css.list && (css.list = !!(doc.createElement("datalist") && win.HTMLDataListElement)), css;
  9063.    }("autocomplete autofocus list placeholder max min multiple pattern required step".split(" "));
  9064.    Modernizr.inputtypes = function(props) {
  9065.      /** @type {number} */
  9066.      var i = 0;
  9067.      var bool;
  9068.      var inputElemType;
  9069.      var defaultView;
  9070.      /** @type {number} */
  9071.      var l = props.length;
  9072.      for (;i < l;i++) {
  9073.        inputElem.setAttribute("type", inputElemType = props[i]);
  9074.        /** @type {boolean} */
  9075.        bool = inputElem.type !== "text";
  9076.        if (bool) {
  9077.          /** @type {string} */
  9078.          inputElem.value = smile;
  9079.          /** @type {string} */
  9080.          inputElem.style.cssText = "position:absolute;visibility:hidden;";
  9081.          if (/^range$/.test(inputElemType) && inputElem.style.WebkitAppearance !== value) {
  9082.            docElement.appendChild(inputElem);
  9083.            defaultView = doc.defaultView;
  9084.            bool = defaultView.getComputedStyle && (defaultView.getComputedStyle(inputElem, null).WebkitAppearance !== "textfield" && inputElem.offsetHeight !== 0);
  9085.            docElement.removeChild(inputElem);
  9086.          } else {
  9087.            if (!/^(search|tel)$/.test(inputElemType)) {
  9088.              bool = /^(url|email)$/.test(inputElemType) ? inputElem.checkValidity && inputElem.checkValidity() === false : inputElem.value != smile;
  9089.            }
  9090.          }
  9091.        }
  9092.        /** @type {boolean} */
  9093.        inputs[props[i]] = !!bool;
  9094.      }
  9095.      return inputs;
  9096.    }("search tel url email datetime date month week time datetime-local number range color".split(" "));
  9097.  }
  9098.  var Modernizr = {};
  9099.  /** @type {boolean} */
  9100.  var f = true;
  9101.  /** @type {Element} */
  9102.  var docElement = doc.documentElement;
  9103.  /** @type {string} */
  9104.  var mod = "modernizr";
  9105.  /** @type {Element} */
  9106.  var modElem = doc.createElement(mod);
  9107.  /** @type {(CSSStyleDeclaration|null)} */
  9108.  var mStyle = modElem.style;
  9109.  /** @type {Element} */
  9110.  var inputElem = doc.createElement("input");
  9111.  /** @type {string} */
  9112.  var smile = ":)";
  9113.  /** @type {function (this:*): string} */
  9114.  var toString = {}.toString;
  9115.  /** @type {Array.<string>} */
  9116.  var prefixes = " -webkit- -moz- -o- -ms- ".split(" ");
  9117.  /** @type {string} */
  9118.  var uHostName = "Webkit Moz O ms";
  9119.  /** @type {Array.<string>} */
  9120.  var cssomPrefixes = uHostName.split(" ");
  9121.  /** @type {Array.<string>} */
  9122.  var domPrefixes = uHostName.toLowerCase().split(" ");
  9123.  var ns = {
  9124.    svg : "http://www.w3.org/2000/svg"
  9125.   };
  9126.   var _m = {};
  9127.   var inputs = {};
  9128.   var css = {};
  9129.   /** @type {Array} */
  9130.   var classes = [];
  9131.   /** @type {function (this:(Array.<T>|string|{length: number}), *=, *=): Array.<T>} */
  9132.   var __slice = classes.slice;
  9133.   var featureName;
  9134.   /**
  9135.    * @param {string} rule
  9136.    * @param {Function} callback
  9137.    * @param {number} nodes
  9138.    * @param {boolean} testnames
  9139.    * @return {?}
  9140.    */
  9141.   var injectElementWithStyles = function(rule, callback, nodes, testnames) {
  9142.     var style;
  9143.     var ret;
  9144.     var node;
  9145.     var docOverflow;
  9146.     /** @type {Element} */
  9147.     var div = doc.createElement("div");
  9148.     /** @type {(HTMLElement|null)} */
  9149.     var body = doc.body;
  9150.     /** @type {Element} */
  9151.     var fakeBody = body || doc.createElement("body");
  9152.     if (parseInt(nodes, 10)) {
  9153.       for (;nodes--;) {
  9154.         /** @type {Element} */
  9155.         node = doc.createElement("div");
  9156.         node.id = testnames ? testnames[nodes] : mod + (nodes + 1);
  9157.         div.appendChild(node);
  9158.       }
  9159.     }
  9160.     return style = ["&#173;", '<style id="s', mod, '">', rule, "</style>"].join(""), div.id = mod, (body ? div : fakeBody).innerHTML += style, fakeBody.appendChild(div), body || (fakeBody.style.background = "", fakeBody.style.overflow = "hidden", docOverflow = docElement.style.overflow, docElement.style.overflow = "hidden", docElement.appendChild(fakeBody)), ret = callback(div, rule), body ? div.parentNode.removeChild(div) : (fakeBody.parentNode.removeChild(fakeBody), docElement.style.overflow =
  9161.     docOverflow), !!ret;
  9162.   };
  9163.   /**
  9164.    * @param {string} mq
  9165.    * @return {?}
  9166.    */
  9167.   var testMediaQuery = function(mq) {
  9168.     /** @type {function (this:Window, string): (MediaQueryList|null)} */
  9169.     var matchMedia = win.matchMedia || win.msMatchMedia;
  9170.     var bool;
  9171.     return matchMedia ? matchMedia(mq).matches : (injectElementWithStyles("@media " + mq + " { #" + mod + " { position: absolute; } }", function(elem) {
  9172.       /** @type {boolean} */
  9173.       bool = (win.getComputedStyle ? getComputedStyle(elem, null) : elem.currentStyle).position == "absolute";
  9174.     }), bool);
  9175.   };
  9176.   var isEventSupported = function() {
  9177.     /**
  9178.      * @param {string} eventName
  9179.      * @param {Element} el
  9180.      * @return {?}
  9181.      */
  9182.     function isEventSupported(eventName, el) {
  9183.       el = el || doc.createElement(TAGNAMES[eventName] || "div");
  9184.       /** @type {string} */
  9185.       eventName = "on" + eventName;
  9186.       /** @type {boolean} */
  9187.       var isSupported = eventName in el;
  9188.       return isSupported || (el.setAttribute || (el = doc.createElement("div")), el.setAttribute && (el.removeAttribute && (el.setAttribute(eventName, ""), isSupported = is(el[eventName], "function"), is(el[eventName], "undefined") || (el[eventName] = value), el.removeAttribute(eventName)))), el = null, isSupported;
  9189.     }
  9190.     var TAGNAMES = {
  9191.       select : "input",
  9192.       change : "input",
  9193.       submit : "form",
  9194.       reset : "form",
  9195.       error : "img",
  9196.       load : "img",
  9197.       abort : "img"
  9198.     };
  9199.     return isEventSupported;
  9200.   }();
  9201.   /** @type {function (this:Object, *): boolean} */
  9202.   var _hasOwnProperty = {}.hasOwnProperty;
  9203.   var hasOwnProp;
  9204.   var feature;
  9205.   /** @type {function (Object, string): ?} */
  9206.   hasOwnProp = is(_hasOwnProperty, "undefined") || is(_hasOwnProperty.call, "undefined") ? function(object, property) {
  9207.     return property in object && is(object.constructor.prototype[property], "undefined");
  9208.   } : function(object, property) {
  9209.     return _hasOwnProperty.call(object, property);
  9210.   };
  9211.   if (!Function.prototype.bind) {
  9212.     /**
  9213.      * @param {(Object|null|undefined)} recurring
  9214.      * @return {Function}
  9215.      */
  9216.     Function.prototype.bind = function(recurring) {
  9217.       /** @type {Function} */
  9218.       var func = this;
  9219.       var r;
  9220.       var e;
  9221.       if (typeof func != "function") {
  9222.         throw new TypeError;
  9223.       }
  9224.       return r = __slice.call(arguments, 1), e = function() {
  9225.         var noop;
  9226.         var thisBinding;
  9227.         var result;
  9228.         return this instanceof e ? (noop = function() {
  9229.         }, noop.prototype = func.prototype, thisBinding = new noop, result = func.apply(thisBinding, r.concat(__slice.call(arguments))), Object(result) === result) ? result : thisBinding : func.apply(recurring, r.concat(__slice.call(arguments)));
  9230.       }, e;
  9231.     };
  9232.   }
  9233.   /**
  9234.    * @return {?}
  9235.    */
  9236.   _m.flexbox = function() {
  9237.     return testPropsAll("flexWrap");
  9238.   };
  9239.   /**
  9240.    * @return {?}
  9241.    */
  9242.   _m.flexboxlegacy = function() {
  9243.     return testPropsAll("boxDirection");
  9244.   };
  9245.   /**
  9246.    * @return {?}
  9247.    */
  9248.   _m.canvas = function() {
  9249.     /** @type {Element} */
  9250.     var test_canvas = doc.createElement("canvas");
  9251.     return!!(test_canvas.getContext && test_canvas.getContext("2d"));
  9252.   };
  9253.   /**
  9254.    * @return {?}
  9255.    */
  9256.   _m.canvastext = function() {
  9257.     return!!(Modernizr.canvas && is(doc.createElement("canvas").getContext("2d").fillText, "function"));
  9258.   };
  9259.   /**
  9260.    * @return {?}
  9261.    */
  9262.   _m.webgl = function() {
  9263.     return!!win.WebGLRenderingContext;
  9264.   };
  9265.   /**
  9266.    * @return {?}
  9267.    */
  9268.   _m.touch = function() {
  9269.     var i;
  9270.     return "ontouchstart" in win || win.DocumentTouch && doc instanceof DocumentTouch ? i = true : injectElementWithStyles(["@media (", prefixes.join("touch-enabled),("), mod, ")", "{#modernizr{top:9px;position:absolute}}"].join(""), function(td) {
  9271.       /** @type {boolean} */
  9272.       i = td.offsetTop === 9;
  9273.     }), i;
  9274.   };
  9275.   /**
  9276.    * @return {?}
  9277.    */
  9278.   _m.geolocation = function() {
  9279.     return "geolocation" in navigator;
  9280.   };
  9281.   /**
  9282.    * @return {?}
  9283.    */
  9284.   _m.postmessage = function() {
  9285.     return!!win.postMessage;
  9286.   };
  9287.   /**
  9288.    * @return {?}
  9289.    */
  9290.   _m.websqldatabase = function() {
  9291.     return!!win.openDatabase;
  9292.   };
  9293.   /**
  9294.    * @return {?}
  9295.    */
  9296.   _m.indexedDB = function() {
  9297.     return!!testPropsAll("indexedDB", win);
  9298.   };
  9299.   /**
  9300.    * @return {?}
  9301.    */
  9302.   _m.hashchange = function() {
  9303.     return isEventSupported("hashchange", win) && (doc.documentMode === value || doc.documentMode > 7);
  9304.   };
  9305.   /**
  9306.    * @return {?}
  9307.    */
  9308.   _m.history = function() {
  9309.     return!!(win.history && history.pushState);
  9310.   };
  9311.   /**
  9312.    * @return {?}
  9313.    */
  9314.   _m.draganddrop = function() {
  9315.     /** @type {Element} */
  9316.     var div = doc.createElement("div");
  9317.     return "draggable" in div || "ondragstart" in div && "ondrop" in div;
  9318.   };
  9319.   /**
  9320.    * @return {?}
  9321.    */
  9322.   _m.websockets = function() {
  9323.     return "WebSocket" in win || "MozWebSocket" in win;
  9324.   };
  9325.   /**
  9326.    * @return {?}
  9327.    */
  9328.   _m.rgba = function() {
  9329.     return setCss("background-color:rgba(150,255,150,.5)"), contains(mStyle.backgroundColor, "rgba");
  9330.   };
  9331.   /**
  9332.    * @return {?}
  9333.    */
  9334.   _m.hsla = function() {
  9335.     return setCss("background-color:hsla(120,40%,100%,.5)"), contains(mStyle.backgroundColor, "rgba") || contains(mStyle.backgroundColor, "hsla");
  9336.   };
  9337.   /**
  9338.    * @return {?}
  9339.    */
  9340.   _m.multiplebgs = function() {
  9341.     return setCss("background:url(https://),url(https://),red url(https://)"), /(url\s*\(.*?){3}/.test(mStyle.background);
  9342.   };
  9343.   /**
  9344.    * @return {?}
  9345.    */
  9346.   _m.backgroundsize = function() {
  9347.     return testPropsAll("backgroundSize");
  9348.   };
  9349.   /**
  9350.    * @return {?}
  9351.    */
  9352.   _m.borderimage = function() {
  9353.     return testPropsAll("borderImage");
  9354.   };
  9355.   /**
  9356.    * @return {?}
  9357.    */
  9358.   _m.borderradius = function() {
  9359.     return testPropsAll("borderRadius");
  9360.   };
  9361.   /**
  9362.    * @return {?}
  9363.    */
  9364.   _m.boxshadow = function() {
  9365.     return testPropsAll("boxShadow");
  9366.   };
  9367.   /**
  9368.    * @return {?}
  9369.    */
  9370.   _m.textshadow = function() {
  9371.     return doc.createElement("div").style.textShadow === "";
  9372.   };
  9373.   /**
  9374.    * @return {?}
  9375.    */
  9376.   _m.opacity = function() {
  9377.     return setCssAll("opacity:.55"), /^0.55$/.test(mStyle.opacity);
  9378.   };
  9379.   /**
  9380.    * @return {?}
  9381.    */
  9382.   _m.cssanimations = function() {
  9383.     return testPropsAll("animationName");
  9384.   };
  9385.   /**
  9386.    * @return {?}
  9387.    */
  9388.   _m.csscolumns = function() {
  9389.     return testPropsAll("columnCount");
  9390.   };
  9391.   /**
  9392.    * @return {?}
  9393.    */
  9394.   _m.cssgradients = function() {
  9395.     /** @type {string} */
  9396.     var str1 = "background-image:";
  9397.     return setCss((str1 + "-webkit- ".split(" ").join("gradient(linear,left top,right bottom,from(#9f9),to(white));" + str1) + prefixes.join("linear-gradient(left top,#9f9, white);" + str1)).slice(0, -str1.length)), contains(mStyle.backgroundImage, "gradient");
  9398.   };
  9399.   /**
  9400.    * @return {?}
  9401.    */
  9402.   _m.cssreflections = function() {
  9403.     return testPropsAll("boxReflect");
  9404.   };
  9405.   /**
  9406.    * @return {?}
  9407.    */
  9408.   _m.csstransforms = function() {
  9409.     return!!testPropsAll("transform");
  9410.   };
  9411.   /**
  9412.    * @return {?}
  9413.    */
  9414.   _m.csstransforms3d = function() {
  9415.     /** @type {boolean} */
  9416.     var a = !!testPropsAll("perspective");
  9417.     return a && ("webkitPerspective" in docElement.style && injectElementWithStyles("@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}", function(node) {
  9418.       /** @type {boolean} */
  9419.       a = node.offsetLeft === 9 && node.offsetHeight === 3;
  9420.     })), a;
  9421.   };
  9422.   /**
  9423.    * @return {?}
  9424.    */
  9425.   _m.csstransitions = function() {
  9426.     return testPropsAll("transition");
  9427.   };
  9428.   /**
  9429.    * @return {?}
  9430.    */
  9431.   _m.fontface = function() {
  9432.     var n;
  9433.     return injectElementWithStyles('@font-face {font-family:"font";src:url("https://")}', function(dataAndEvents, pair) {
  9434.       /** @type {(HTMLElement|null)} */
  9435.       var style = doc.getElementById("smodernizr");
  9436.       var sheet = style.sheet || style.styleSheet;
  9437.       var cssText = sheet ? sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || "" : "";
  9438.       /** @type {boolean} */
  9439.       n = /src/i.test(cssText) && cssText.indexOf(pair.split(" ")[0]) === 0;
  9440.     }), n;
  9441.   };
  9442.   /**
  9443.    * @return {?}
  9444.    */
  9445.   _m.generatedcontent = function() {
  9446.     var n;
  9447.     return injectElementWithStyles(["#", mod, "{font:0/0 a}#", mod, ':after{content:"', smile, '";visibility:hidden;font:3px/1 a}'].join(""), function(node) {
  9448.       /** @type {boolean} */
  9449.       n = node.offsetHeight >= 3;
  9450.     }), n;
  9451.   };
  9452.   /**
  9453.    * @return {?}
  9454.    */
  9455.   _m.video = function() {
  9456.     /** @type {Element} */
  9457.     var elem = doc.createElement("video");
  9458.     /** @type {boolean} */
  9459.     var bool = false;
  9460.     try {
  9461.       if (bool = !!elem.canPlayType) {
  9462.         /** @type {Boolean} */
  9463.         bool = new Boolean(bool);
  9464.         bool.ogg = elem.canPlayType('video/ogg; codecs="theora"').replace(/^no$/, "");
  9465.         bool.h264 = elem.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/, "");
  9466.         bool.webm = elem.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/, "");
  9467.       }
  9468.     } catch (r) {
  9469.     }
  9470.     return bool;
  9471.   };
  9472.   /**
  9473.    * @return {?}
  9474.    */
  9475.   _m.audio = function() {
  9476.     /** @type {Element} */
  9477.     var elem = doc.createElement("audio");
  9478.     /** @type {boolean} */
  9479.     var bool = false;
  9480.     try {
  9481.       if (bool = !!elem.canPlayType) {
  9482.         /** @type {Boolean} */
  9483.         bool = new Boolean(bool);
  9484.         bool.ogg = elem.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, "");
  9485.         bool.mp3 = elem.canPlayType("audio/mpeg;").replace(/^no$/, "");
  9486.         bool.wav = elem.canPlayType('audio/wav; codecs="1"').replace(/^no$/, "");
  9487.         bool.m4a = (elem.canPlayType("audio/x-m4a;") || elem.canPlayType("audio/aac;")).replace(/^no$/, "");
  9488.       }
  9489.     } catch (r) {
  9490.     }
  9491.     return bool;
  9492.   };
  9493.   /**
  9494.    * @return {?}
  9495.    */
  9496.   _m.localstorage = function() {
  9497.     try {
  9498.       return localStorage.setItem(mod, mod), localStorage.removeItem(mod), true;
  9499.     } catch (n) {
  9500.       return false;
  9501.     }
  9502.   };
  9503.   /**
  9504.    * @return {?}
  9505.    */
  9506.   _m.sessionstorage = function() {
  9507.     try {
  9508.       return sessionStorage.setItem(mod, mod), sessionStorage.removeItem(mod), true;
  9509.     } catch (n) {
  9510.       return false;
  9511.     }
  9512.   };
  9513.   /**
  9514.    * @return {?}
  9515.    */
  9516.   _m.webworkers = function() {
  9517.     return!!win.Worker;
  9518.   };
  9519.   /**
  9520.    * @return {?}
  9521.    */
  9522.   _m.applicationcache = function() {
  9523.     return!!win.applicationCache;
  9524.   };
  9525.   /**
  9526.    * @return {?}
  9527.    */
  9528.   _m.svg = function() {
  9529.     return!!doc.createElementNS && !!doc.createElementNS(ns.svg, "svg").createSVGRect;
  9530.   };
  9531.   /**
  9532.    * @return {?}
  9533.    */
  9534.   _m.inlinesvg = function() {
  9535.     /** @type {Element} */
  9536.     var div = doc.createElement("div");
  9537.     return div.innerHTML = "<svg/>", (div.firstChild && div.firstChild.namespaceURI) == ns.svg;
  9538.   };
  9539.   /**
  9540.    * @return {?}
  9541.    */
  9542.   _m.smil = function() {
  9543.     return!!doc.createElementNS && /SVGAnimate/.test(toString.call(doc.createElementNS(ns.svg, "animate")));
  9544.   };
  9545.   /**
  9546.    * @return {?}
  9547.    */
  9548.   _m.svgclippaths = function() {
  9549.     return!!doc.createElementNS && /SVGClipPath/.test(toString.call(doc.createElementNS(ns.svg, "clipPath")));
  9550.   };
  9551.   for (feature in _m) {
  9552.     if (hasOwnProp(_m, feature)) {
  9553.       /** @type {string} */
  9554.       featureName = feature.toLowerCase();
  9555.       Modernizr[featureName] = _m[feature]();
  9556.       classes.push((Modernizr[featureName] ? "" : "no-") + featureName);
  9557.     }
  9558.   }
  9559.   return Modernizr.input || webforms(), Modernizr.addTest = function(feature, test) {
  9560.     if (typeof feature == "object") {
  9561.       var key;
  9562.       for (key in feature) {
  9563.         if (hasOwnProp(feature, key)) {
  9564.           Modernizr.addTest(key, feature[key]);
  9565.         }
  9566.       }
  9567.     } else {
  9568.       if (feature = feature.toLowerCase(), Modernizr[feature] !== value) {
  9569.         return Modernizr;
  9570.       }
  9571.       test = typeof test == "function" ? test() : test;
  9572.       if (typeof f != "undefined") {
  9573.         if (f) {
  9574.           docElement.className += " " + (test ? "" : "no-") + feature;
  9575.         }
  9576.       }
  9577.       /** @type {boolean} */
  9578.       Modernizr[feature] = test;
  9579.     }
  9580.     return Modernizr;
  9581.   }, setCss(""), modElem = inputElem = null, function(dataAndEvents, doc) {
  9582.     /**
  9583.      * @param {Document} ownerDocument
  9584.      * @param {string} cssText
  9585.      * @return {?}
  9586.      */
  9587.     function addStyleSheet(ownerDocument, cssText) {
  9588.       var p = ownerDocument.createElement("p");
  9589.       var parent = ownerDocument.getElementsByTagName("head")[0] || ownerDocument.documentElement;
  9590.       return p.innerHTML = "x<style>" + cssText + "</style>", parent.insertBefore(p.lastChild, parent.firstChild);
  9591.     }
  9592.     /**
  9593.      * @return {?}
  9594.      */
  9595.     function getElements() {
  9596.       var elements = html5.elements;
  9597.       return typeof elements == "string" ? elements.split(" ") : elements;
  9598.     }
  9599.     /**
  9600.      * @param {HTMLElement} ownerDocument
  9601.      * @return {?}
  9602.      */
  9603.     function getExpandoData(ownerDocument) {
  9604.       var data = expandoData[ownerDocument[expando]];
  9605.       return data || (data = {}, expanID++, ownerDocument[expando] = expanID, expandoData[expanID] = data), data;
  9606.     }
  9607.     /**
  9608.      * @param {string} nodeName
  9609.      * @param {HTMLDocument} ownerDocument
  9610.      * @param {Object} data
  9611.      * @return {?}
  9612.      */
  9613.     function createElement(nodeName, ownerDocument, data) {
  9614.       if (ownerDocument || (ownerDocument = doc), supportsUnknownElements) {
  9615.         return ownerDocument.createElement(nodeName);
  9616.       }
  9617.       if (!data) {
  9618.         data = getExpandoData(ownerDocument);
  9619.       }
  9620.       var node;
  9621.       return node = data.cache[nodeName] ? data.cache[nodeName].cloneNode() : rchecked.test(nodeName) ? (data.cache[nodeName] = data.createElem(nodeName)).cloneNode() : data.createElem(nodeName), node.canHaveChildren && (!exclude.test(nodeName) && !node.tagUrn) ? data.frag.appendChild(node) : node;
  9622.     }
  9623.     /**
  9624.      * @param {HTMLDocument} ownerDocument
  9625.      * @param {Object} data
  9626.      * @return {?}
  9627.      */
  9628.     function createDocumentFragment(ownerDocument, data) {
  9629.       if (ownerDocument || (ownerDocument = doc), supportsUnknownElements) {
  9630.         return ownerDocument.createDocumentFragment();
  9631.       }
  9632.       data = data || getExpandoData(ownerDocument);
  9633.       var clone = data.frag.cloneNode();
  9634.       /** @type {number} */
  9635.       var i = 0;
  9636.       var elems = getElements();
  9637.       var length = elems.length;
  9638.       for (;i < length;i++) {
  9639.         clone.createElement(elems[i]);
  9640.       }
  9641.       return clone;
  9642.     }
  9643.     /**
  9644.      * @param {Document} ownerDocument
  9645.      * @param {Object} data
  9646.      * @return {undefined}
  9647.      */
  9648.     function shivMethods(ownerDocument, data) {
  9649.       if (!data.cache) {
  9650.         data.cache = {};
  9651.         /** @type {function (string): ?} */
  9652.         data.createElem = ownerDocument.createElement;
  9653.         data.createFrag = ownerDocument.createDocumentFragment;
  9654.         data.frag = data.createFrag();
  9655.       }
  9656.       /**
  9657.        * @param {string} nodeName
  9658.        * @return {?}
  9659.        */
  9660.       ownerDocument.createElement = function(nodeName) {
  9661.         return html5.shivMethods ? createElement(nodeName, ownerDocument, data) : data.createElem(nodeName);
  9662.       };
  9663.       ownerDocument.createDocumentFragment = Function("h,f", "return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&(" + getElements().join().replace(/[\w\-]+/g, function(nodeName) {
  9664.         return data.createElem(nodeName), data.frag.createElement(nodeName), 'c("' + nodeName + '")';
  9665.       }) + ");return n}")(html5, data.frag);
  9666.     }
  9667.     /**
  9668.      * @param {HTMLDocument} ownerDocument
  9669.      * @return {?}
  9670.      */
  9671.     function shivDocument(ownerDocument) {
  9672.       if (!ownerDocument) {
  9673.         /** @type {HTMLDocument} */
  9674.         ownerDocument = doc;
  9675.       }
  9676.       var data = getExpandoData(ownerDocument);
  9677.       return!html5.shivCSS || (supportsHtml5Styles || (data.hasCSS || (data.hasCSS = !!addStyleSheet(ownerDocument, "article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")))), supportsUnknownElements || shivMethods(ownerDocument, data), ownerDocument;
  9678.     }
  9679.     var options = dataAndEvents.html5 || {};
  9680.     /** @type {RegExp} */
  9681.     var exclude = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
  9682.     /** @type {RegExp} */
  9683.     var rchecked = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;
  9684.     var supportsHtml5Styles;
  9685.     /** @type {string} */
  9686.     var expando = "_html5shiv";
  9687.     /** @type {number} */
  9688.     var expanID = 0;
  9689.     var expandoData = {};
  9690.     var supportsUnknownElements;
  9691.     var html5;
  9692.     (function() {
  9693.       try {
  9694.         /** @type {Element} */
  9695.         var a = doc.createElement("a");
  9696.         /** @type {string} */
  9697.         a.innerHTML = "<xyz></xyz>";
  9698.         /** @type {boolean} */
  9699.         supportsHtml5Styles = "hidden" in a;
  9700.         supportsUnknownElements = a.childNodes.length == 1 || function() {
  9701.           doc.createElement("a");
  9702.           /** @type {DocumentFragment} */
  9703.           var frag = doc.createDocumentFragment();
  9704.           return typeof frag.cloneNode == "undefined" || (typeof frag.createDocumentFragment == "undefined" || typeof frag.createElement == "undefined");
  9705.         }();
  9706.       } catch (r) {
  9707.         /** @type {boolean} */
  9708.         supportsHtml5Styles = true;
  9709.         /** @type {boolean} */
  9710.         supportsUnknownElements = true;
  9711.       }
  9712.     })();
  9713.     html5 = {
  9714.       elements : options.elements || "abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output progress section summary template time video",
  9715.       version : "3.7.0",
  9716.       shivCSS : options.shivCSS !== false,
  9717.       supportsUnknownElements : supportsUnknownElements,
  9718.       shivMethods : options.shivMethods !== false,
  9719.       type : "default",
  9720.       /** @type {function (HTMLDocument): ?} */
  9721.       shivDocument : shivDocument,
  9722.       /** @type {function (string, HTMLDocument, Object): ?} */
  9723.       createElement : createElement,
  9724.       /** @type {function (HTMLDocument, Object): ?} */
  9725.       createDocumentFragment : createDocumentFragment
  9726.     };
  9727.     dataAndEvents.html5 = html5;
  9728.     shivDocument(doc);
  9729.   }(this, doc), Modernizr._version = "2.7.2", Modernizr._prefixes = prefixes, Modernizr._domPrefixes = domPrefixes, Modernizr._cssomPrefixes = cssomPrefixes, Modernizr.mq = testMediaQuery, Modernizr.hasEvent = isEventSupported, Modernizr.testProp = function(prop) {
  9730.     return testProps([prop]);
  9731.   }, Modernizr.testAllProps = testPropsAll, Modernizr.testStyles = injectElementWithStyles, Modernizr.prefixed = function(prop, obj, elem) {
  9732.     return obj ? testPropsAll(prop, obj, elem) : testPropsAll(prop, "pfx");
  9733.   }, docElement.className = docElement.className.replace(/(^|\s)no-js(\s|$)/, "$1$2") + (f ? " js " + classes.join(" ") : ""), Modernizr;
  9734. }(this, this.document), function(first) {
  9735.   /**
  9736.    * @param {string} yr
  9737.    * @param {string} dataAndEvents
  9738.    * @param {string} val
  9739.    * @return {?}
  9740.    */
  9741.   function fixYear(yr, dataAndEvents, val) {
  9742.     switch(arguments.length) {
  9743.       case 2:
  9744.         return null != yr ? yr : dataAndEvents;
  9745.       case 3:
  9746.         return null != yr ? yr : null != dataAndEvents ? dataAndEvents : val;
  9747.       default:
  9748.         throw new Error("Implement me");;
  9749.     }
  9750.   }
  9751.   /**
  9752.    * @param {Object} obj
  9753.    * @param {string} key
  9754.    * @return {?}
  9755.    */
  9756.   function hasOwn(obj, key) {
  9757.     return has.call(obj, key);
  9758.   }
  9759.   /**
  9760.    * @return {?}
  9761.    */
  9762.   function validateTransport() {
  9763.     return{
  9764.       empty : false,
  9765.       unusedTokens : [],
  9766.       unusedInput : [],
  9767.       overflow : -2,
  9768.       charsLeftOver : 0,
  9769.       nullInput : false,
  9770.       invalidMonth : null,
  9771.       invalidFormat : false,
  9772.       userInvalidated : false,
  9773.       iso : false
  9774.     };
  9775.   }
  9776.   /**
  9777.    * @param {string} message
  9778.    * @return {undefined}
  9779.    */
  9780.   function log(message) {
  9781.     if (moment.suppressDeprecationWarnings === false) {
  9782.       if ("undefined" != typeof console) {
  9783.         if (console.warn) {
  9784.           console.warn("Deprecation warning: " + message);
  9785.         }
  9786.       }
  9787.     }
  9788.   }
  9789.   /**
  9790.    * @param {string} message
  9791.    * @param {Function} fn
  9792.    * @return {?}
  9793.    */
  9794.   function timeout(message, fn) {
  9795.     /** @type {boolean} */
  9796.     var i = true;
  9797.     return extend(function() {
  9798.       return i && (log(message), i = false), fn.apply(this, arguments);
  9799.     }, fn);
  9800.   }
  9801.   /**
  9802.    * @param {string} index
  9803.    * @param {string} data
  9804.    * @return {undefined}
  9805.    */
  9806.   function done(index, data) {
  9807.     if (!viewItems[index]) {
  9808.       log(data);
  9809.       /** @type {boolean} */
  9810.       viewItems[index] = true;
  9811.     }
  9812.   }
  9813.   /**
  9814.    * @param {Function} func
  9815.    * @param {number} opt_attributes
  9816.    * @return {?}
  9817.    */
  9818.   function padToken(func, opt_attributes) {
  9819.     return function(a) {
  9820.       return leftZeroFill(func.call(this, a), opt_attributes);
  9821.     };
  9822.   }
  9823.   /**
  9824.    * @param {Function} func
  9825.    * @param {?} period
  9826.    * @return {?}
  9827.    */
  9828.   function ordinalizeToken(func, period) {
  9829.     return function(a) {
  9830.       return this.localeData().ordinal(func.call(this, a), period);
  9831.     };
  9832.   }
  9833.   /**
  9834.    * @param {Object} m
  9835.    * @param {string} t
  9836.    * @return {?}
  9837.    */
  9838.   function push(m, t) {
  9839.     var t1;
  9840.     var version;
  9841.     /** @type {number} */
  9842.     var name = 12 * (t.year() - m.year()) + (t.month() - m.month());
  9843.     var t0 = m.clone().add(name, "months");
  9844.     return 0 > t - t0 ? (t1 = m.clone().add(name - 1, "months"), version = (t - t0) / (t0 - t1)) : (t1 = m.clone().add(name + 1, "months"), version = (t - t0) / (t1 - t0)), -(name + version);
  9845.   }
  9846.   /**
  9847.    * @param {?} node
  9848.    * @param {number} str
  9849.    * @param {Object} value
  9850.    * @return {?}
  9851.    */
  9852.   function isEmpty(node, str, value) {
  9853.     var isFunction;
  9854.     return null == value ? str : null != node.meridiemHour ? node.meridiemHour(str, value) : null != node.isPM ? (isFunction = node.isPM(value), isFunction && (12 > str && (str += 12)), isFunction || (12 !== str || (str = 0)), str) : str;
  9855.   }
  9856.   /**
  9857.    * @return {undefined}
  9858.    */
  9859.   function Language() {
  9860.   }
  9861.   /**
  9862.    * @param {null} mom
  9863.    * @param {boolean} isUTC
  9864.    * @return {undefined}
  9865.    */
  9866.   function Moment(mom, isUTC) {
  9867.     if (isUTC !== false) {
  9868.       checkOverflow(mom);
  9869.     }
  9870.     config(this, mom);
  9871.     /** @type {Date} */
  9872.     this._d = new Date(+mom._d);
  9873.     if (ii === false) {
  9874.       /** @type {boolean} */
  9875.       ii = true;
  9876.       moment.updateOffset(this);
  9877.       /** @type {boolean} */
  9878.       ii = false;
  9879.     }
  9880.   }
  9881.   /**
  9882.    * @param {Object} duration
  9883.    * @return {undefined}
  9884.    */
  9885.   function Duration(duration) {
  9886.     var normalizedInput = normalizeObjectUnits(duration);
  9887.     var r = normalizedInput.year || 0;
  9888.     var isAdding = normalizedInput.quarter || 0;
  9889.     var mom = normalizedInput.month || 0;
  9890.     var HOUR_MS = normalizedInput.week || 0;
  9891.     var d = normalizedInput.day || 0;
  9892.     var s = normalizedInput.hour || 0;
  9893.     var h = normalizedInput.minute || 0;
  9894.     var _oneDayInMilliseconds = normalizedInput.second || 0;
  9895.     var _now = normalizedInput.millisecond || 0;
  9896.     /** @type {number} */
  9897.     this._milliseconds = +_now + 1E3 * _oneDayInMilliseconds + 6E4 * h + 36E5 * s;
  9898.     /** @type {number} */
  9899.     this._days = +d + 7 * HOUR_MS;
  9900.     /** @type {number} */
  9901.     this._months = +mom + 3 * isAdding + 12 * r;
  9902.     this._data = {};
  9903.     this._locale = moment.localeData();
  9904.     this._bubble();
  9905.   }
  9906.   /**
  9907.    * @param {Object} a
  9908.    * @param {Object} b
  9909.    * @return {?}
  9910.    */
  9911.   function extend(a, b) {
  9912.     var key;
  9913.     for (key in b) {
  9914.       if (hasOwn(b, key)) {
  9915.         a[key] = b[key];
  9916.       }
  9917.     }
  9918.     return hasOwn(b, "toString") && (a.toString = b.toString), hasOwn(b, "valueOf") && (a.valueOf = b.valueOf), a;
  9919.   }
  9920.   /**
  9921.    * @param {Function} config
  9922.    * @param {Function} m
  9923.    * @return {?}
  9924.    */
  9925.   function config(config, m) {
  9926.     var index;
  9927.     var key;
  9928.     var current;
  9929.     if ("undefined" != typeof m._isAMomentObject && (config._isAMomentObject = m._isAMomentObject), "undefined" != typeof m._i && (config._i = m._i), "undefined" != typeof m._f && (config._f = m._f), "undefined" != typeof m._l && (config._l = m._l), "undefined" != typeof m._strict && (config._strict = m._strict), "undefined" != typeof m._tzm && (config._tzm = m._tzm), "undefined" != typeof m._isUTC && (config._isUTC = m._isUTC), "undefined" != typeof m._offset && (config._offset = m._offset), "undefined" !=
  9930.     typeof m._pf && (config._pf = m._pf), "undefined" != typeof m._locale && (config._locale = m._locale), keys.length > 0) {
  9931.       for (index in keys) {
  9932.         key = keys[index];
  9933.         current = m[key];
  9934.         if ("undefined" != typeof current) {
  9935.           config[key] = current;
  9936.         }
  9937.       }
  9938.     }
  9939.     return config;
  9940.   }
  9941.   /**
  9942.    * @param {number} number
  9943.    * @return {?}
  9944.    */
  9945.   function absRound(number) {
  9946.     return 0 > number ? Math.ceil(number) : Math.floor(number);
  9947.   }
  9948.   /**
  9949.    * @param {number} number
  9950.    * @param {number} opt_attributes
  9951.    * @param {boolean} forceSign
  9952.    * @return {?}
  9953.    */
  9954.   function leftZeroFill(number, opt_attributes, forceSign) {
  9955.     /** @type {string} */
  9956.     var n = "" + Math.abs(number);
  9957.     /** @type {boolean} */
  9958.     var sign = number >= 0;
  9959.     for (;n.length < opt_attributes;) {
  9960.       /** @type {string} */
  9961.       n = "0" + n;
  9962.     }
  9963.     return(sign ? forceSign ? "+" : "" : "-") + n;
  9964.   }
  9965.   /**
  9966.    * @param {string} obj
  9967.    * @param {string} data
  9968.    * @return {?}
  9969.    */
  9970.   function init(obj, data) {
  9971.     var d = {
  9972.       milliseconds : 0,
  9973.       months : 0
  9974.     };
  9975.     return d.months = data.month() - obj.month() + 12 * (data.year() - obj.year()), obj.clone().add(d.months, "M").isAfter(data) && --d.months, d.milliseconds = +data - +obj.clone().add(d.months, "M"), d;
  9976.   }
  9977.   /**
  9978.    * @param {string} doc
  9979.    * @param {Text} data
  9980.    * @return {?}
  9981.    */
  9982.   function addNode(doc, data) {
  9983.     var obj;
  9984.     return data = makeAs(data, doc), doc.isBefore(data) ? obj = init(doc, data) : (obj = init(data, doc), obj.milliseconds = -obj.milliseconds, obj.months = -obj.months), obj;
  9985.   }
  9986.   /**
  9987.    * @param {number} deepDataAndEvents
  9988.    * @param {string} options
  9989.    * @return {?}
  9990.    */
  9991.   function update(deepDataAndEvents, options) {
  9992.     return function(input, val) {
  9993.       var dur;
  9994.       var n;
  9995.       return null === val || (isNaN(+val) || (done(options, "moment()." + options + "(period, number) is deprecated. Please use moment()." + options + "(number, period)."), n = input, input = val, val = n)), input = "string" == typeof input ? +input : input, dur = moment.duration(input, val), addOrSubtractDurationFromMoment(this, dur, deepDataAndEvents), this;
  9996.     };
  9997.   }
  9998.   /**
  9999.    * @param {string} mom
  10000.    * @param {?} duration
  10001.    * @param {?} deepDataAndEvents
  10002.    * @param {boolean} count
  10003.    * @return {undefined}
  10004.    */
  10005.   function addOrSubtractDurationFromMoment(mom, duration, deepDataAndEvents, count) {
  10006.     var milliseconds = duration._milliseconds;
  10007.     var days = duration._days;
  10008.     var months = duration._months;
  10009.     count = null == count ? true : count;
  10010.     if (milliseconds) {
  10011.       mom._d.setTime(+mom._d + milliseconds * deepDataAndEvents);
  10012.     }
  10013.     if (days) {
  10014.       set(mom, "Date", get(mom, "Date") + days * deepDataAndEvents);
  10015.     }
  10016.     if (months) {
  10017.       fn(mom, get(mom, "Month") + months * deepDataAndEvents);
  10018.     }
  10019.     if (count) {
  10020.       moment.updateOffset(mom, days || months);
  10021.     }
  10022.   }
  10023.   /**
  10024.    * @param {Array} input
  10025.    * @return {?}
  10026.    */
  10027.   function isArray(input) {
  10028.     return "[object Array]" === Object.prototype.toString.call(input);
  10029.   }
  10030.   /**
  10031.    * @param {?} d
  10032.    * @return {?}
  10033.    */
  10034.   function isDate(d) {
  10035.     return "[object Date]" === Object.prototype.toString.call(d) || d instanceof Date;
  10036.   }
  10037.   /**
  10038.    * @param {Array} array1
  10039.    * @param {Array} array2
  10040.    * @param {boolean} dataAndEvents
  10041.    * @return {?}
  10042.    */
  10043.   function compareArrays(array1, array2, dataAndEvents) {
  10044.     /** @type {number} */
  10045.     var l = Math.min(array1.length, array2.length);
  10046.     /** @type {number} */
  10047.     var arr = Math.abs(array1.length - array2.length);
  10048.     /** @type {number} */
  10049.     var inner = 0;
  10050.     /** @type {number} */
  10051.     var i = 0;
  10052.     for (;l > i;i++) {
  10053.       if (dataAndEvents && array1[i] !== array2[i] || !dataAndEvents && toInt(array1[i]) !== toInt(array2[i])) {
  10054.         inner++;
  10055.       }
  10056.     }
  10057.     return inner + arr;
  10058.   }
  10059.   /**
  10060.    * @param {string} num
  10061.    * @return {?}
  10062.    */
  10063.   function normalizeUnits(num) {
  10064.     if (num) {
  10065.       var lowered = num.toLowerCase().replace(/(.)s$/, "$1");
  10066.       num = unitAliases[num] || (camelFunctions[lowered] || lowered);
  10067.     }
  10068.     return num;
  10069.   }
  10070.   /**
  10071.    * @param {Object} obj
  10072.    * @return {?}
  10073.    */
  10074.   function normalizeObjectUnits(obj) {
  10075.     var field;
  10076.     var key;
  10077.     var res = {};
  10078.     for (key in obj) {
  10079.       if (hasOwn(obj, key)) {
  10080.         field = normalizeUnits(key);
  10081.         if (field) {
  10082.           res[field] = obj[key];
  10083.         }
  10084.       }
  10085.     }
  10086.     return res;
  10087.   }
  10088.   /**
  10089.    * @param {string} field
  10090.    * @return {undefined}
  10091.    */
  10092.   function makeList(field) {
  10093.     var pivotElem;
  10094.     var elem;
  10095.     if (0 === field.indexOf("week")) {
  10096.       /** @type {number} */
  10097.       pivotElem = 7;
  10098.       /** @type {string} */
  10099.       elem = "day";
  10100.     } else {
  10101.       if (0 !== field.indexOf("month")) {
  10102.         return;
  10103.       }
  10104.       /** @type {number} */
  10105.       pivotElem = 12;
  10106.       /** @type {string} */
  10107.       elem = "month";
  10108.     }
  10109.     /**
  10110.      * @param {(Object|string)} fragment
  10111.      * @param {(Object|string)} node
  10112.      * @return {?}
  10113.      */
  10114.     moment[field] = function(fragment, node) {
  10115.       var elem;
  10116.       var getter;
  10117.       var method = moment._locale[field];
  10118.       /** @type {Array} */
  10119.       var nodes = [];
  10120.       if ("number" == typeof fragment && (node = fragment, fragment = first), getter = function(camelKey) {
  10121.         var data = moment().utc().set(elem, camelKey);
  10122.         return method.call(moment._locale, data, fragment || "");
  10123.       }, null != node) {
  10124.         return getter(node);
  10125.       }
  10126.       /** @type {number} */
  10127.       elem = 0;
  10128.       for (;pivotElem > elem;elem++) {
  10129.         nodes.push(getter(elem));
  10130.       }
  10131.       return nodes;
  10132.     };
  10133.   }
  10134.   /**
  10135.    * @param {(number|string)} obj
  10136.    * @return {?}
  10137.    */
  10138.   function toInt(obj) {
  10139.     /** @type {number} */
  10140.     var num = +obj;
  10141.     /** @type {number} */
  10142.     var i = 0;
  10143.     return 0 !== num && (isFinite(num) && (i = num >= 0 ? Math.floor(num) : Math.ceil(num))), i;
  10144.   }
  10145.   /**
  10146.    * @param {?} year
  10147.    * @param {number} month
  10148.    * @return {?}
  10149.    */
  10150.   function daysInMonth(year, month) {
  10151.     return(new Date(Date.UTC(year, month + 1, 0))).getUTCDate();
  10152.   }
  10153.   /**
  10154.    * @param {?} type
  10155.    * @param {number} dataAndEvents
  10156.    * @param {number} opt_attributes
  10157.    * @return {?}
  10158.    */
  10159.   function createDom(type, dataAndEvents, opt_attributes) {
  10160.     return weekOfYear(moment([type, 11, 31 + dataAndEvents - opt_attributes]), dataAndEvents, opt_attributes).week;
  10161.   }
  10162.   /**
  10163.    * @param {number} year
  10164.    * @return {?}
  10165.    */
  10166.   function daysInYear(year) {
  10167.     return isLeapYear(year) ? 366 : 365;
  10168.   }
  10169.   /**
  10170.    * @param {number} year
  10171.    * @return {?}
  10172.    */
  10173.   function isLeapYear(year) {
  10174.     return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
  10175.   }
  10176.   /**
  10177.    * @param {number} m
  10178.    * @return {undefined}
  10179.    */
  10180.   function checkOverflow(m) {
  10181.     var overflow;
  10182.     if (m._a) {
  10183.       if (-2 === m._pf.overflow) {
  10184.         /** @type {number} */
  10185.         overflow = m._a[MONTH] < 0 || m._a[MONTH] > 11 ? MONTH : m._a[HOUR] < 1 || m._a[HOUR] > daysInMonth(m._a[YEAR], m._a[MONTH]) ? HOUR : m._a[DATE] < 0 || (m._a[DATE] > 24 || 24 === m._a[DATE] && (0 !== m._a[SECOND] || (0 !== m._a[MINUTE] || 0 !== m._a[MILLISECOND]))) ? DATE : m._a[SECOND] < 0 || m._a[SECOND] > 59 ? SECOND : m._a[MINUTE] < 0 || m._a[MINUTE] > 59 ? MINUTE : m._a[MILLISECOND] < 0 || m._a[MILLISECOND] > 999 ? MILLISECOND : -1;
  10186.         if (m._pf._overflowDayOfYear) {
  10187.           if (YEAR > overflow || overflow > HOUR) {
  10188.             /** @type {number} */
  10189.             overflow = HOUR;
  10190.           }
  10191.         }
  10192.         /** @type {number} */
  10193.         m._pf.overflow = overflow;
  10194.       }
  10195.     }
  10196.   }
  10197.   /**
  10198.    * @param {?} m
  10199.    * @return {?}
  10200.    */
  10201.   function isValid(m) {
  10202.     return null == m._isValid && (m._isValid = !isNaN(m._d.getTime()) && (m._pf.overflow < 0 && (!m._pf.empty && (!m._pf.invalidMonth && (!m._pf.nullInput && (!m._pf.invalidFormat && !m._pf.userInvalidated))))), m._strict && (m._isValid = m._isValid && (0 === m._pf.charsLeftOver && (0 === m._pf.unusedTokens.length && m._pf.bigHour === first)))), m._isValid;
  10203.   }
  10204.   /**
  10205.    * @param {Object} key
  10206.    * @return {?}
  10207.    */
  10208.   function normalizeLanguage(key) {
  10209.     return key ? key.toLowerCase().replace("_", "-") : key;
  10210.   }
  10211.   /**
  10212.    * @param {Array} key
  10213.    * @return {?}
  10214.    */
  10215.   function check(key) {
  10216.     var j;
  10217.     var next;
  10218.     var result;
  10219.     var split;
  10220.     /** @type {number} */
  10221.     var i = 0;
  10222.     for (;i < key.length;) {
  10223.       split = normalizeLanguage(key[i]).split("-");
  10224.       j = split.length;
  10225.       next = normalizeLanguage(key[i + 1]);
  10226.       next = next ? next.split("-") : null;
  10227.       for (;j > 0;) {
  10228.         if (result = test(split.slice(0, j).join("-"))) {
  10229.           return result;
  10230.         }
  10231.         if (next && (next.length >= j && compareArrays(split, next, true) >= j - 1)) {
  10232.           break;
  10233.         }
  10234.         j--;
  10235.       }
  10236.       i++;
  10237.     }
  10238.     return null;
  10239.   }
  10240.   /**
  10241.    * @param {Array} name
  10242.    * @return {?}
  10243.    */
  10244.   function test(name) {
  10245.     /** @type {null} */
  10246.     var camelKey = null;
  10247.     if (!languages[name] && sr) {
  10248.       try {
  10249.         camelKey = moment.locale();
  10250.         require("./locale/" + name);
  10251.         moment.locale(camelKey);
  10252.       } catch (r) {
  10253.       }
  10254.     }
  10255.     return languages[name];
  10256.   }
  10257.   /**
  10258.    * @param {string} input
  10259.    * @param {?} model
  10260.    * @return {?}
  10261.    */
  10262.   function makeAs(input, model) {
  10263.     var mom;
  10264.     var ms;
  10265.     return model._isUTC ? (mom = model.clone(), ms = (moment.isMoment(input) || isDate(input) ? +input : +moment(input)) - +mom, mom._d.setTime(+mom._d + ms), moment.updateOffset(mom, false), mom) : moment(input).local();
  10266.   }
  10267.   /**
  10268.    * @param {string} line
  10269.    * @return {?}
  10270.    */
  10271.   function func(line) {
  10272.     return line.match(/\[[\s\S]/) ? line.replace(/^\[|\]$/g, "") : line.replace(/\\/g, "");
  10273.   }
  10274.   /**
  10275.    * @param {string} format
  10276.    * @return {?}
  10277.    */
  10278.   function makeFormatFunction(format) {
  10279.     var array = format.match(formattingTokens);
  10280.     /** @type {number} */
  10281.     var i = 0;
  10282.     var l = array.length;
  10283.     for (;l > i;i++) {
  10284.       array[i] = formatTokenFunctions[array[i]] ? formatTokenFunctions[array[i]] : func(array[i]);
  10285.     }
  10286.     return function(mom) {
  10287.       /** @type {string} */
  10288.       var output = "";
  10289.       /** @type {number} */
  10290.       i = 0;
  10291.       for (;l > i;i++) {
  10292.         output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
  10293.       }
  10294.       return output;
  10295.     };
  10296.   }
  10297.   /**
  10298.    * @param {?} m
  10299.    * @param {string} format
  10300.    * @return {?}
  10301.    */
  10302.   function formatMoment(m, format) {
  10303.     return m.isValid() ? (format = expandFormat(format, m.localeData()), formatFunctions[format] || (formatFunctions[format] = makeFormatFunction(format)), formatFunctions[format](m)) : m.localeData().invalidDate();
  10304.   }
  10305.   /**
  10306.    * @param {string} format
  10307.    * @param {?} lang
  10308.    * @return {?}
  10309.    */
  10310.   function expandFormat(format, lang) {
  10311.     /**
  10312.      * @param {string} input
  10313.      * @return {?}
  10314.      */
  10315.     function replaceLongDateFormatTokens(input) {
  10316.       return lang.longDateFormat(input) || input;
  10317.     }
  10318.     /** @type {number} */
  10319.     var i = 5;
  10320.     /** @type {number} */
  10321.     localFormattingTokens.lastIndex = 0;
  10322.     for (;i >= 0 && localFormattingTokens.test(format);) {
  10323.       format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
  10324.       /** @type {number} */
  10325.       localFormattingTokens.lastIndex = 0;
  10326.       i -= 1;
  10327.     }
  10328.     return format;
  10329.   }
  10330.   /**
  10331.    * @param {string} token
  10332.    * @param {number} config
  10333.    * @return {?}
  10334.    */
  10335.   function getParseRegexForToken(token, config) {
  10336.     var strict = config._strict;
  10337.     switch(token) {
  10338.       case "Q":
  10339.         return parseTokenTimestampMs;
  10340.       case "DDDD":
  10341.         return parseTokenFourDigits;
  10342.       case "YYYY":
  10343.       ;
  10344.       case "GGGG":
  10345.       ;
  10346.       case "gggg":
  10347.         return strict ? parseTokenTwoDigits : parseTokenOneToSixDigits;
  10348.       case "Y":
  10349.       ;
  10350.       case "G":
  10351.       ;
  10352.       case "g":
  10353.         return parseTokenOneToThreeDigits;
  10354.       case "YYYYYY":
  10355.       ;
  10356.       case "YYYYY":
  10357.       ;
  10358.       case "GGGGG":
  10359.       ;
  10360.       case "ggggg":
  10361.         return strict ? parseTokenOneDigit : parseTokenOneToFourDigits;
  10362.       case "S":
  10363.         if (strict) {
  10364.           return parseTokenTimestampMs;
  10365.         }
  10366.       ;
  10367.       case "SS":
  10368.         if (strict) {
  10369.           return parseTokenThreeDigits;
  10370.         }
  10371.       ;
  10372.       case "SSS":
  10373.         if (strict) {
  10374.           return parseTokenFourDigits;
  10375.         }
  10376.       ;
  10377.       case "DDD":
  10378.         return parseTokenSixDigits;
  10379.       case "MMM":
  10380.       ;
  10381.       case "MMMM":
  10382.       ;
  10383.       case "dd":
  10384.       ;
  10385.       case "ddd":
  10386.       ;
  10387.       case "dddd":
  10388.         return rchecked;
  10389.       case "a":
  10390.       ;
  10391.       case "A":
  10392.         return config._locale._meridiemParse;
  10393.       case "x":
  10394.         return parseTokenWord;
  10395.       case "X":
  10396.         return parseTokenDigits;
  10397.       case "Z":
  10398.       ;
  10399.       case "ZZ":
  10400.         return parseTokenTimezone;
  10401.       case "T":
  10402.         return parseTokenT;
  10403.       case "SSSS":
  10404.         return a;
  10405.       case "MM":
  10406.       ;
  10407.       case "DD":
  10408.       ;
  10409.       case "YY":
  10410.       ;
  10411.       case "GG":
  10412.       ;
  10413.       case "gg":
  10414.       ;
  10415.       case "HH":
  10416.       ;
  10417.       case "hh":
  10418.       ;
  10419.       case "mm":
  10420.       ;
  10421.       case "ss":
  10422.       ;
  10423.       case "ww":
  10424.       ;
  10425.       case "WW":
  10426.         return strict ? parseTokenThreeDigits : parseTokenOneOrTwoDigits;
  10427.       case "M":
  10428.       ;
  10429.       case "D":
  10430.       ;
  10431.       case "d":
  10432.       ;
  10433.       case "H":
  10434.       ;
  10435.       case "h":
  10436.       ;
  10437.       case "m":
  10438.       ;
  10439.       case "s":
  10440.       ;
  10441.       case "w":
  10442.       ;
  10443.       case "W":
  10444.       ;
  10445.       case "e":
  10446.       ;
  10447.       case "E":
  10448.         return parseTokenOneOrTwoDigits;
  10449.       case "Do":
  10450.         return strict ? config._locale._ordinalParse : config._locale._ordinalParseLenient;
  10451.       default:
  10452.         return new RegExp(regexpEscape(unescapeFormat(token.replace("\\", "")), "i"));
  10453.     }
  10454.   }
  10455.   /**
  10456.    * @param {string} string
  10457.    * @return {?}
  10458.    */
  10459.   function timezoneMinutesFromString(string) {
  10460.     string = string || "";
  10461.     var codeSegments = string.match(parseTokenTimezone) || [];
  10462.     var tzchunk = codeSegments[codeSegments.length - 1] || [];
  10463.     /** @type {Array} */
  10464.     var parts = (tzchunk + "").match(parseTimezoneChunker) || ["-", 0, 0];
  10465.     var u = +(60 * parts[1]) + toInt(parts[2]);
  10466.     return "+" === parts[0] ? u : -u;
  10467.   }
  10468.   /**
  10469.    * @param {string} token
  10470.    * @param {string} input
  10471.    * @param {?} config
  10472.    * @return {undefined}
  10473.    */
  10474.   function addTimeToArrayFromToken(token, input, config) {
  10475.     var a;
  10476.     var datePartArray = config._a;
  10477.     switch(token) {
  10478.       case "Q":
  10479.         if (null != input) {
  10480.           /** @type {number} */
  10481.           datePartArray[MONTH] = 3 * (toInt(input) - 1);
  10482.         }
  10483.         break;
  10484.       case "M":
  10485.       ;
  10486.       case "MM":
  10487.         if (null != input) {
  10488.           /** @type {number} */
  10489.           datePartArray[MONTH] = toInt(input) - 1;
  10490.         }
  10491.         break;
  10492.       case "MMM":
  10493.       ;
  10494.       case "MMMM":
  10495.         a = config._locale.monthsParse(input, token, config._strict);
  10496.         if (null != a) {
  10497.           datePartArray[MONTH] = a;
  10498.         } else {
  10499.           /** @type {string} */
  10500.           config._pf.invalidMonth = input;
  10501.         }
  10502.         break;
  10503.       case "D":
  10504.       ;
  10505.       case "DD":
  10506.         if (null != input) {
  10507.           datePartArray[HOUR] = toInt(input);
  10508.         }
  10509.         break;
  10510.       case "Do":
  10511.         if (null != input) {
  10512.           datePartArray[HOUR] = toInt(parseInt(input.match(/\d{1,2}/)[0], 10));
  10513.         }
  10514.         break;
  10515.       case "DDD":
  10516.       ;
  10517.       case "DDDD":
  10518.         if (null != input) {
  10519.           config._dayOfYear = toInt(input);
  10520.         }
  10521.         break;
  10522.       case "YY":
  10523.         datePartArray[YEAR] = moment.parseTwoDigitYear(input);
  10524.         break;
  10525.       case "YYYY":
  10526.       ;
  10527.       case "YYYYY":
  10528.       ;
  10529.       case "YYYYYY":
  10530.         datePartArray[YEAR] = toInt(input);
  10531.         break;
  10532.       case "a":
  10533.       ;
  10534.       case "A":
  10535.         /** @type {string} */
  10536.         config._meridiem = input;
  10537.         break;
  10538.       case "h":
  10539.       ;
  10540.       case "hh":
  10541.         /** @type {boolean} */
  10542.         config._pf.bigHour = true;
  10543.       case "H":
  10544.       ;
  10545.       case "HH":
  10546.         datePartArray[DATE] = toInt(input);
  10547.         break;
  10548.       case "m":
  10549.       ;
  10550.       case "mm":
  10551.         datePartArray[SECOND] = toInt(input);
  10552.         break;
  10553.       case "s":
  10554.       ;
  10555.       case "ss":
  10556.         datePartArray[MINUTE] = toInt(input);
  10557.         break;
  10558.       case "S":
  10559.       ;
  10560.       case "SS":
  10561.       ;
  10562.       case "SSS":
  10563.       ;
  10564.       case "SSSS":
  10565.         datePartArray[MILLISECOND] = toInt(1E3 * ("0." + input));
  10566.         break;
  10567.       case "x":
  10568.         /** @type {Date} */
  10569.         config._d = new Date(toInt(input));
  10570.         break;
  10571.       case "X":
  10572.         /** @type {Date} */
  10573.         config._d = new Date(1E3 * parseFloat(input));
  10574.         break;
  10575.       case "Z":
  10576.       ;
  10577.       case "ZZ":
  10578.         /** @type {boolean} */
  10579.         config._useUTC = true;
  10580.         config._tzm = timezoneMinutesFromString(input);
  10581.         break;
  10582.       case "dd":
  10583.       ;
  10584.       case "ddd":
  10585.       ;
  10586.       case "dddd":
  10587.         a = config._locale.weekdaysParse(input);
  10588.         if (null != a) {
  10589.           config._w = config._w || {};
  10590.           config._w.d = a;
  10591.         } else {
  10592.           /** @type {string} */
  10593.           config._pf.invalidWeekday = input;
  10594.         }
  10595.         break;
  10596.       case "w":
  10597.       ;
  10598.       case "ww":
  10599.       ;
  10600.       case "W":
  10601.       ;
  10602.       case "WW":
  10603.       ;
  10604.       case "d":
  10605.       ;
  10606.       case "e":
  10607.       ;
  10608.       case "E":
  10609.         token = token.substr(0, 1);
  10610.       case "gggg":
  10611.       ;
  10612.       case "GGGG":
  10613.       ;
  10614.       case "GGGGG":
  10615.         token = token.substr(0, 2);
  10616.         if (input) {
  10617.           config._w = config._w || {};
  10618.           config._w[token] = toInt(input);
  10619.         }
  10620.         break;
  10621.       case "gg":
  10622.       ;
  10623.       case "GG":
  10624.         config._w = config._w || {};
  10625.         config._w[token] = moment.parseTwoDigitYear(input);
  10626.     }
  10627.   }
  10628.   /**
  10629.    * @param {?} config
  10630.    * @return {undefined}
  10631.    */
  10632.   function dateFromConfig(config) {
  10633.     var w;
  10634.     var value;
  10635.     var week;
  10636.     var d;
  10637.     var node;
  10638.     var attributes;
  10639.     var temp;
  10640.     w = config._w;
  10641.     if (null != w.GG || (null != w.W || null != w.E)) {
  10642.       /** @type {number} */
  10643.       node = 1;
  10644.       /** @type {number} */
  10645.       attributes = 4;
  10646.       value = fixYear(w.GG, config._a[YEAR], weekOfYear(moment(), 1, 4).year);
  10647.       week = fixYear(w.W, 1);
  10648.       d = fixYear(w.E, 1);
  10649.     } else {
  10650.       node = config._locale._week.dow;
  10651.       attributes = config._locale._week.doy;
  10652.       value = fixYear(w.gg, config._a[YEAR], weekOfYear(moment(), node, attributes).year);
  10653.       week = fixYear(w.w, 1);
  10654.       if (null != w.d) {
  10655.         d = w.d;
  10656.         if (node > d) {
  10657.           ++week;
  10658.         }
  10659.       } else {
  10660.         d = null != w.e ? w.e + node : node;
  10661.       }
  10662.     }
  10663.     temp = dayOfYearFromWeeks(value, week, d, attributes, node);
  10664.     config._a[YEAR] = temp.year;
  10665.     config._dayOfYear = temp.dayOfYear;
  10666.   }
  10667.   /**
  10668.    * @param {?} config
  10669.    * @return {undefined}
  10670.    */
  10671.   function dateFromArray(config) {
  10672.     var i;
  10673.     var date;
  10674.     var currentDate;
  10675.     var yearToUse;
  10676.     /** @type {Array} */
  10677.     var input = [];
  10678.     if (!config._d) {
  10679.       currentDate = currentDateArray(config);
  10680.       if (config._w) {
  10681.         if (null == config._a[HOUR]) {
  10682.           if (null == config._a[MONTH]) {
  10683.             dateFromConfig(config);
  10684.           }
  10685.         }
  10686.       }
  10687.       if (config._dayOfYear) {
  10688.         yearToUse = fixYear(config._a[YEAR], currentDate[YEAR]);
  10689.         if (config._dayOfYear > daysInYear(yearToUse)) {
  10690.           /** @type {boolean} */
  10691.           config._pf._overflowDayOfYear = true;
  10692.         }
  10693.         date = makeUTCDate(yearToUse, 0, config._dayOfYear);
  10694.         config._a[MONTH] = date.getUTCMonth();
  10695.         config._a[HOUR] = date.getUTCDate();
  10696.       }
  10697.       /** @type {number} */
  10698.       i = 0;
  10699.       for (;3 > i && null == config._a[i];++i) {
  10700.         config._a[i] = input[i] = currentDate[i];
  10701.       }
  10702.       for (;7 > i;i++) {
  10703.         config._a[i] = input[i] = null == config._a[i] ? 2 === i ? 1 : 0 : config._a[i];
  10704.       }
  10705.       if (24 === config._a[DATE]) {
  10706.         if (0 === config._a[SECOND]) {
  10707.           if (0 === config._a[MINUTE]) {
  10708.             if (0 === config._a[MILLISECOND]) {
  10709.               /** @type {boolean} */
  10710.               config._nextDay = true;
  10711.               /** @type {number} */
  10712.               config._a[DATE] = 0;
  10713.             }
  10714.           }
  10715.         }
  10716.       }
  10717.       config._d = (config._useUTC ? makeUTCDate : makeDate).apply(null, input);
  10718.       if (null != config._tzm) {
  10719.         config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
  10720.       }
  10721.       if (config._nextDay) {
  10722.         /** @type {number} */
  10723.         config._a[DATE] = 24;
  10724.       }
  10725.     }
  10726.   }
  10727.   /**
  10728.    * @param {number} config
  10729.    * @return {undefined}
  10730.    */
  10731.   function dateFromObject(config) {
  10732.     var o;
  10733.     if (!config._d) {
  10734.       o = normalizeObjectUnits(config._i);
  10735.       /** @type {Array} */
  10736.       config._a = [o.year, o.month, o.day || o.date, o.hour, o.minute, o.second, o.millisecond];
  10737.       dateFromArray(config);
  10738.     }
  10739.   }
  10740.   /**
  10741.    * @param {?} config
  10742.    * @return {?}
  10743.    */
  10744.   function currentDateArray(config) {
  10745.     /** @type {Date} */
  10746.     var today = new Date;
  10747.     return config._useUTC ? [today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate()] : [today.getFullYear(), today.getMonth(), today.getDate()];
  10748.   }
  10749.   /**
  10750.    * @param {number} config
  10751.    * @return {?}
  10752.    */
  10753.   function makeDateFromStringAndFormat(config) {
  10754.     if (config._f === moment.ISO_8601) {
  10755.       return void makeDateFromString(config);
  10756.     }
  10757.     /** @type {Array} */
  10758.     config._a = [];
  10759.     /** @type {boolean} */
  10760.     config._pf.empty = true;
  10761.     var parsedInput;
  10762.     var token;
  10763.     var copies;
  10764.     /** @type {string} */
  10765.     var string = "" + config._i;
  10766.     /** @type {number} */
  10767.     var stringLength = string.length;
  10768.     /** @type {number} */
  10769.     var totalParsedInputLength = 0;
  10770.     var codeSegments = expandFormat(config._f, config._locale).match(formattingTokens) || [];
  10771.     /** @type {number} */
  10772.     var i = 0;
  10773.     for (;i < codeSegments.length;i++) {
  10774.       token = codeSegments[i];
  10775.       parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
  10776.       if (parsedInput) {
  10777.         /** @type {string} */
  10778.         copies = string.substr(0, string.indexOf(parsedInput));
  10779.         if (copies.length > 0) {
  10780.           config._pf.unusedInput.push(copies);
  10781.         }
  10782.         /** @type {string} */
  10783.         string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
  10784.         totalParsedInputLength += parsedInput.length;
  10785.       }
  10786.       if (formatTokenFunctions[token]) {
  10787.         if (parsedInput) {
  10788.           /** @type {boolean} */
  10789.           config._pf.empty = false;
  10790.         } else {
  10791.           config._pf.unusedTokens.push(token);
  10792.         }
  10793.         addTimeToArrayFromToken(token, parsedInput, config);
  10794.       } else {
  10795.         if (config._strict) {
  10796.           if (!parsedInput) {
  10797.             config._pf.unusedTokens.push(token);
  10798.           }
  10799.         }
  10800.       }
  10801.     }
  10802.     /** @type {number} */
  10803.     config._pf.charsLeftOver = stringLength - totalParsedInputLength;
  10804.     if (string.length > 0) {
  10805.       config._pf.unusedInput.push(string);
  10806.     }
  10807.     if (config._pf.bigHour === true) {
  10808.       if (config._a[DATE] <= 12) {
  10809.         config._pf.bigHour = first;
  10810.       }
  10811.     }
  10812.     config._a[DATE] = isEmpty(config._locale, config._a[DATE], config._meridiem);
  10813.     dateFromArray(config);
  10814.     checkOverflow(config);
  10815.   }
  10816.   /**
  10817.    * @param {string} s
  10818.    * @return {?}
  10819.    */
  10820.   function unescapeFormat(s) {
  10821.     return s.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(dataAndEvents, error, e, err, err2) {
  10822.       return error || (e || (err || err2));
  10823.     });
  10824.   }
  10825.   /**
  10826.    * @param {string} s
  10827.    * @return {?}
  10828.    */
  10829.   function regexpEscape(s) {
  10830.     return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
  10831.   }
  10832.   /**
  10833.    * @param {Object} m
  10834.    * @return {?}
  10835.    */
  10836.   function makeDateFromStringAndArray(m) {
  10837.     var tempConfig;
  10838.     var bestMoment;
  10839.     var scoreToBeat;
  10840.     var i;
  10841.     var currentScore;
  10842.     if (0 === m._f.length) {
  10843.       return m._pf.invalidFormat = true, void(m._d = new Date(NaN));
  10844.     }
  10845.     /** @type {number} */
  10846.     i = 0;
  10847.     for (;i < m._f.length;i++) {
  10848.       /** @type {number} */
  10849.       currentScore = 0;
  10850.       tempConfig = config({}, m);
  10851.       if (null != m._useUTC) {
  10852.         tempConfig._useUTC = m._useUTC;
  10853.       }
  10854.       tempConfig._pf = validateTransport();
  10855.       tempConfig._f = m._f[i];
  10856.       makeDateFromStringAndFormat(tempConfig);
  10857.       if (isValid(tempConfig)) {
  10858.         currentScore += tempConfig._pf.charsLeftOver;
  10859.         currentScore += 10 * tempConfig._pf.unusedTokens.length;
  10860.         tempConfig._pf.score = currentScore;
  10861.         if (null == scoreToBeat || scoreToBeat > currentScore) {
  10862.           scoreToBeat = currentScore;
  10863.           bestMoment = tempConfig;
  10864.         }
  10865.       }
  10866.     }
  10867.     extend(m, bestMoment || tempConfig);
  10868.   }
  10869.   /**
  10870.    * @param {number} config
  10871.    * @return {undefined}
  10872.    */
  10873.   function makeDateFromString(config) {
  10874.     var i;
  10875.     var len;
  10876.     var string = config._i;
  10877.     /** @type {(Array.<string>|null)} */
  10878.     var ast = spaceRe.exec(string);
  10879.     if (ast) {
  10880.       /** @type {boolean} */
  10881.       config._pf.iso = true;
  10882.       /** @type {number} */
  10883.       i = 0;
  10884.       /** @type {number} */
  10885.       len = codeSegments.length;
  10886.       for (;len > i;i++) {
  10887.         if (codeSegments[i][1].exec(string)) {
  10888.           config._f = codeSegments[i][0] + (ast[6] || " ");
  10889.           break;
  10890.         }
  10891.       }
  10892.       /** @type {number} */
  10893.       i = 0;
  10894.       /** @type {number} */
  10895.       len = rawParams.length;
  10896.       for (;len > i;i++) {
  10897.         if (rawParams[i][1].exec(string)) {
  10898.           config._f += rawParams[i][0];
  10899.           break;
  10900.         }
  10901.       }
  10902.       if (string.match(parseTokenTimezone)) {
  10903.         config._f += "Z";
  10904.       }
  10905.       makeDateFromStringAndFormat(config);
  10906.     } else {
  10907.       /** @type {boolean} */
  10908.       config._isValid = false;
  10909.     }
  10910.   }
  10911.   /**
  10912.    * @param {number} config
  10913.    * @return {undefined}
  10914.    */
  10915.   function prepareSandboxFromConfig(config) {
  10916.     makeDateFromString(config);
  10917.     if (config._isValid === false) {
  10918.       delete config._isValid;
  10919.       moment.createFromInputFallback(config);
  10920.     }
  10921.   }
  10922.   /**
  10923.    * @param {Array} array
  10924.    * @param {Function} fn
  10925.    * @return {?}
  10926.    */
  10927.   function clean(array, fn) {
  10928.     /** @type {Array} */
  10929.     var ret = [];
  10930.     /** @type {number} */
  10931.     var i = 0;
  10932.     for (;i < array.length;++i) {
  10933.       ret.push(fn(array[i], i));
  10934.     }
  10935.     return ret;
  10936.   }
  10937.   /**
  10938.    * @param {number} config
  10939.    * @return {undefined}
  10940.    */
  10941.   function makeDateFromInput(config) {
  10942.     var matches;
  10943.     var val = config._i;
  10944.     if (val === first) {
  10945.       /** @type {Date} */
  10946.       config._d = new Date;
  10947.     } else {
  10948.       if (isDate(val)) {
  10949.         /** @type {Date} */
  10950.         config._d = new Date(+val);
  10951.       } else {
  10952.         if (null !== (matches = regexp.exec(val))) {
  10953.           /** @type {Date} */
  10954.           config._d = new Date(+matches[1]);
  10955.         } else {
  10956.           if ("string" == typeof val) {
  10957.             prepareSandboxFromConfig(config);
  10958.           } else {
  10959.             if (isArray(val)) {
  10960.               config._a = clean(val.slice(0), function(m1) {
  10961.                 return parseInt(m1, 10);
  10962.               });
  10963.               dateFromArray(config);
  10964.             } else {
  10965.               if ("object" == typeof val) {
  10966.                 dateFromObject(config);
  10967.               } else {
  10968.                 if ("number" == typeof val) {
  10969.                   /** @type {Date} */
  10970.                   config._d = new Date(val);
  10971.                 } else {
  10972.                   moment.createFromInputFallback(config);
  10973.                 }
  10974.               }
  10975.             }
  10976.           }
  10977.         }
  10978.       }
  10979.     }
  10980.   }
  10981.   /**
  10982.    * @param {number} year
  10983.    * @param {number} month
  10984.    * @param {number} date
  10985.    * @param {number} hour
  10986.    * @param {number} mins
  10987.    * @param {number} secs
  10988.    * @param {number} ms
  10989.    * @return {?}
  10990.    */
  10991.   function makeDate(year, month, date, hour, mins, secs, ms) {
  10992.     /** @type {Date} */
  10993.     var d = new Date(year, month, date, hour, mins, secs, ms);
  10994.     return 1970 > year && d.setFullYear(year), d;
  10995.   }
  10996.   /**
  10997.    * @param {number} y
  10998.    * @return {?}
  10999.    */
  11000.   function makeUTCDate(y) {
  11001.     /** @type {Date} */
  11002.     var date = new Date(Date.UTC.apply(null, arguments));
  11003.     return 1970 > y && date.setUTCFullYear(y), date;
  11004.   }
  11005.   /**
  11006.    * @param {(number|string)} input
  11007.    * @param {?} language
  11008.    * @return {?}
  11009.    */
  11010.   function parseWeekday(input, language) {
  11011.     if ("string" == typeof input) {
  11012.       if (isNaN(input)) {
  11013.         if (input = language.weekdaysParse(input), "number" != typeof input) {
  11014.           return null;
  11015.         }
  11016.       } else {
  11017.         /** @type {number} */
  11018.         input = parseInt(input, 10);
  11019.       }
  11020.     }
  11021.     return input;
  11022.   }
  11023.   /**
  11024.    * @param {?} string
  11025.    * @param {number} number
  11026.    * @param {?} withoutSuffix
  11027.    * @param {?} isFuture
  11028.    * @param {?} lang
  11029.    * @return {?}
  11030.    */
  11031.   function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
  11032.     return lang.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
  11033.   }
  11034.   /**
  11035.    * @param {number} input
  11036.    * @param {boolean} _
  11037.    * @param {?} context
  11038.    * @return {?}
  11039.    */
  11040.   function preset(input, _, context) {
  11041.     var assert = moment.duration(input).abs();
  11042.     /** @type {number} */
  11043.     var seconds = parseInt(assert.as("s"));
  11044.     /** @type {number} */
  11045.     var minutes = parseInt(assert.as("m"));
  11046.     /** @type {number} */
  11047.     var hours = parseInt(assert.as("h"));
  11048.     /** @type {number} */
  11049.     var i = parseInt(assert.as("d"));
  11050.     /** @type {number} */
  11051.     var idx = parseInt(assert.as("M"));
  11052.     /** @type {number} */
  11053.     var charCodeToReplace = parseInt(assert.as("y"));
  11054.     /** @type {Array} */
  11055.     var args = seconds < data.s && ["s", seconds] || (1 === minutes && ["m"] || (minutes < data.m && ["mm", minutes] || (1 === hours && ["h"] || (hours < data.h && ["hh", hours] || (1 === i && ["d"] || (i < data.d && ["dd", i] || (1 === idx && ["M"] || (idx < data.M && ["MM", idx] || (1 === charCodeToReplace && ["y"] || ["yy", charCodeToReplace])))))))));
  11056.     return args[2] = _, args[3] = +input > 0, args[4] = context, substituteTimeAgo.apply({}, args);
  11057.   }
  11058.   /**
  11059.    * @param {Object} mom
  11060.    * @param {number} dataAndEvents
  11061.    * @param {number} opt_attributes
  11062.    * @return {?}
  11063.    */
  11064.   function weekOfYear(mom, dataAndEvents, opt_attributes) {
  11065.     var t;
  11066.     /** @type {number} */
  11067.     var max = opt_attributes - dataAndEvents;
  11068.     /** @type {number} */
  11069.     var n = opt_attributes - mom.day();
  11070.     return n > max && (n -= 7), max - 7 > n && (n += 7), t = moment(mom).add(n, "d"), {
  11071.       week : Math.ceil(t.dayOfYear() / 7),
  11072.       year : t.year()
  11073.     };
  11074.   }
  11075.   /**
  11076.    * @param {number} year
  11077.    * @param {number} week
  11078.    * @param {number} d
  11079.    * @param {?} opt_attributes
  11080.    * @param {?} a
  11081.    * @return {?}
  11082.    */
  11083.   function dayOfYearFromWeeks(year, week, d, opt_attributes, a) {
  11084.     var o;
  11085.     var dayOfYear;
  11086.     var b = makeUTCDate(year, 0, 1).getUTCDay();
  11087.     return b = 0 === b ? 7 : b, d = null != d ? d : a, o = a - b + (b > opt_attributes ? 7 : 0) - (a > b ? 7 : 0), dayOfYear = 7 * (week - 1) + (d - a) + o + 1, {
  11088.       year : dayOfYear > 0 ? year : year - 1,
  11089.       dayOfYear : dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
  11090.     };
  11091.   }
  11092.   /**
  11093.    * @param {number} config
  11094.    * @return {?}
  11095.    */
  11096.   function makeMoment(config) {
  11097.     var Dom;
  11098.     var input = config._i;
  11099.     var format = config._f;
  11100.     return config._locale = config._locale || moment.localeData(config._l), null === input || format === first && "" === input ? moment.invalid({
  11101.       nullInput : true
  11102.     }) : ("string" == typeof input && (config._i = input = config._locale.preparse(input)), moment.isMoment(input) ? new Moment(input, true) : (format ? isArray(format) ? makeDateFromStringAndArray(config) : makeDateFromStringAndFormat(config) : makeDateFromInput(config), Dom = new Moment(config), Dom._nextDay && (Dom.add(1, "d"), Dom._nextDay = first), Dom));
  11103.   }
  11104.   /**
  11105.    * @param {string} name
  11106.    * @param {Array} val
  11107.    * @return {?}
  11108.    */
  11109.   function reduce(name, val) {
  11110.     var x;
  11111.     var j;
  11112.     if (1 === val.length && (isArray(val[0]) && (val = val[0])), !val.length) {
  11113.       return moment();
  11114.     }
  11115.     x = val[0];
  11116.     /** @type {number} */
  11117.     j = 1;
  11118.     for (;j < val.length;++j) {
  11119.       if (val[j][name](x)) {
  11120.         x = val[j];
  11121.       }
  11122.     }
  11123.     return x;
  11124.   }
  11125.   /**
  11126.    * @param {string} m
  11127.    * @param {number} value
  11128.    * @return {?}
  11129.    */
  11130.   function fn(m, value) {
  11131.     var r20;
  11132.     return "string" == typeof value && (value = m.localeData().monthsParse(value), "number" != typeof value) ? m : (r20 = Math.min(m.date(), daysInMonth(m.year(), value)), m._d["set" + (m._isUTC ? "UTC" : "") + "Month"](value, r20), m);
  11133.   }
  11134.   /**
  11135.    * @param {string} input
  11136.    * @param {string} name
  11137.    * @return {?}
  11138.    */
  11139.   function get(input, name) {
  11140.     return input._d["get" + (input._isUTC ? "UTC" : "") + name]();
  11141.   }
  11142.   /**
  11143.    * @param {string} m
  11144.    * @param {string} name
  11145.    * @param {number} key
  11146.    * @return {?}
  11147.    */
  11148.   function set(m, name, key) {
  11149.     return "Month" === name ? fn(m, key) : m._d["set" + (m._isUTC ? "UTC" : "") + name](key);
  11150.   }
  11151.   /**
  11152.    * @param {string} name
  11153.    * @param {boolean} recurring
  11154.    * @return {?}
  11155.    */
  11156.   function setTick(name, recurring) {
  11157.     return function(part) {
  11158.       return null != part ? (set(this, name, part), moment.updateOffset(this, recurring), this) : get(this, name);
  11159.     };
  11160.   }
  11161.   /**
  11162.    * @param {number} str
  11163.    * @return {?}
  11164.    */
  11165.   function isNumeric(str) {
  11166.     return 400 * str / 146097;
  11167.   }
  11168.   /**
  11169.    * @param {number} years
  11170.    * @return {?}
  11171.    */
  11172.   function randomId(years) {
  11173.     return 146097 * years / 400;
  11174.   }
  11175.   /**
  11176.    * @param {string} name
  11177.    * @return {undefined}
  11178.    */
  11179.   function makeDurationGetter(name) {
  11180.     /**
  11181.      * @return {?}
  11182.      */
  11183.     moment.duration.fn[name] = function() {
  11184.       return this._data[name];
  11185.     };
  11186.   }
  11187.   /**
  11188.    * @param {boolean} dataAndEvents
  11189.    * @return {undefined}
  11190.    */
  11191.   function clone(dataAndEvents) {
  11192.     if ("undefined" == typeof ender) {
  11193.       previous_async = root.moment;
  11194.       root.moment = dataAndEvents ? timeout("Accessing Moment through the global scope is deprecated, and will be removed in an upcoming release.", moment) : moment;
  11195.     }
  11196.   }
  11197.   var moment;
  11198.   var previous_async;
  11199.   var i;
  11200.   var root = "undefined" == typeof global || "undefined" != typeof window && window !== global.window ? this : global;
  11201.   /** @type {function (*): number} */
  11202.   var parseInt = Math.round;
  11203.   /** @type {function (this:Object, *): boolean} */
  11204.   var has = Object.prototype.hasOwnProperty;
  11205.   /** @type {number} */
  11206.   var YEAR = 0;
  11207.   /** @type {number} */
  11208.   var MONTH = 1;
  11209.   /** @type {number} */
  11210.   var HOUR = 2;
  11211.   /** @type {number} */
  11212.   var DATE = 3;
  11213.   /** @type {number} */
  11214.   var SECOND = 4;
  11215.   /** @type {number} */
  11216.   var MINUTE = 5;
  11217.   /** @type {number} */
  11218.   var MILLISECOND = 6;
  11219.   var languages = {};
  11220.   /** @type {Array} */
  11221.   var keys = [];
  11222.   var sr = "undefined" != typeof module && (module && module.exports);
  11223.   /** @type {RegExp} */
  11224.   var regexp = /^\/?Date\((\-?\d+)/i;
  11225.   /** @type {RegExp} */
  11226.   var re = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
  11227.   /** @type {RegExp} */
  11228.   var string = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
  11229.   /** @type {RegExp} */
  11230.   var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;
  11231.   /** @type {RegExp} */
  11232.   var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
  11233.   /** @type {RegExp} */
  11234.   var parseTokenOneOrTwoDigits = /\d\d?/;
  11235.   /** @type {RegExp} */
  11236.   var parseTokenSixDigits = /\d{1,3}/;
  11237.   /** @type {RegExp} */
  11238.   var parseTokenOneToSixDigits = /\d{1,4}/;
  11239.   /** @type {RegExp} */
  11240.   var parseTokenOneToFourDigits = /[+\-]?\d{1,6}/;
  11241.   /** @type {RegExp} */
  11242.   var a = /\d+/;
  11243.   /** @type {RegExp} */
  11244.   var rchecked = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
  11245.   /** @type {RegExp} */
  11246.   var parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/gi;
  11247.   /** @type {RegExp} */
  11248.   var parseTokenT = /T/i;
  11249.   /** @type {RegExp} */
  11250.   var parseTokenWord = /[\+\-]?\d+/;
  11251.   /** @type {RegExp} */
  11252.   var parseTokenDigits = /[\+\-]?\d+(\.\d{1,3})?/;
  11253.   /** @type {RegExp} */
  11254.   var parseTokenTimestampMs = /\d/;
  11255.   /** @type {RegExp} */
  11256.   var parseTokenThreeDigits = /\d\d/;
  11257.   /** @type {RegExp} */
  11258.   var parseTokenFourDigits = /\d{3}/;
  11259.   /** @type {RegExp} */
  11260.   var parseTokenTwoDigits = /\d{4}/;
  11261.   /** @type {RegExp} */
  11262.   var parseTokenOneDigit = /[+-]?\d{6}/;
  11263.   /** @type {RegExp} */
  11264.   var parseTokenOneToThreeDigits = /[+-]?\d+/;
  11265.   /** @type {RegExp} */
  11266.   var spaceRe = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
  11267.   /** @type {Array} */
  11268.   var codeSegments = [["YYYYYY-MM-DD", /[+-]\d{6}-\d{2}-\d{2}/], ["YYYY-MM-DD", /\d{4}-\d{2}-\d{2}/], ["GGGG-[W]WW-E", /\d{4}-W\d{2}-\d/], ["GGGG-[W]WW", /\d{4}-W\d{2}/], ["YYYY-DDD", /\d{4}-\d{3}/]];
  11269.   /** @type {Array} */
  11270.   var rawParams = [["HH:mm:ss.SSSS", /(T| )\d\d:\d\d:\d\d\.\d+/], ["HH:mm:ss", /(T| )\d\d:\d\d:\d\d/], ["HH:mm", /(T| )\d\d:\d\d/], ["HH", /(T| )\d\d/]];
  11271.   /** @type {RegExp} */
  11272.   var parseTimezoneChunker = /([\+\-]|\d\d)/gi;
  11273.   var obj = ("Date|Hours|Minutes|Seconds|Milliseconds".split("|"), {
  11274.     Milliseconds : 1,
  11275.     Seconds : 1E3,
  11276.     Minutes : 6E4,
  11277.     Hours : 36E5,
  11278.     Days : 864E5,
  11279.     Months : 2592E6,
  11280.     Years : 31536E6
  11281.   });
  11282.   var unitAliases = {
  11283.     ms : "millisecond",
  11284.     s : "second",
  11285.     m : "minute",
  11286.     h : "hour",
  11287.     d : "day",
  11288.     D : "date",
  11289.     w : "week",
  11290.     W : "isoWeek",
  11291.     M : "month",
  11292.     Q : "quarter",
  11293.     y : "year",
  11294.     DDD : "dayOfYear",
  11295.     e : "weekday",
  11296.     E : "isoWeekday",
  11297.     gg : "weekYear",
  11298.     GG : "isoWeekYear"
  11299.   };
  11300.   var camelFunctions = {
  11301.     dayofyear : "dayOfYear",
  11302.     isoweekday : "isoWeekday",
  11303.     isoweek : "isoWeek",
  11304.     weekyear : "weekYear",
  11305.     isoweekyear : "isoWeekYear"
  11306.   };
  11307.   var formatFunctions = {};
  11308.   var data = {
  11309.     s : 45,
  11310.     m : 45,
  11311.     h : 22,
  11312.     d : 26,
  11313.     M : 11
  11314.   };
  11315.   /** @type {Array.<string>} */
  11316.   var braceStack = "DDD w W M D d".split(" ");
  11317.   /** @type {Array.<string>} */
  11318.   var eventPath = "M D H h m s w W".split(" ");
  11319.   var formatTokenFunctions = {
  11320.     /**
  11321.      * @return {?}
  11322.      */
  11323.     M : function() {
  11324.       return this.month() + 1;
  11325.     },
  11326.     /**
  11327.      * @param {?} format
  11328.      * @return {?}
  11329.      */
  11330.     MMM : function(format) {
  11331.       return this.localeData().monthsShort(this, format);
  11332.     },
  11333.     /**
  11334.      * @param {?} classesToRemove
  11335.      * @return {?}
  11336.      */
  11337.     MMMM : function(classesToRemove) {
  11338.       return this.localeData().months(this, classesToRemove);
  11339.     },
  11340.     /**
  11341.      * @return {?}
  11342.      */
  11343.     D : function() {
  11344.       return this.date();
  11345.     },
  11346.     /**
  11347.      * @return {?}
  11348.      */
  11349.     DDD : function() {
  11350.       return this.dayOfYear();
  11351.     },
  11352.     /**
  11353.      * @return {?}
  11354.      */
  11355.     d : function() {
  11356.       return this.day();
  11357.     },
  11358.     /**
  11359.      * @param {?} format
  11360.      * @return {?}
  11361.      */
  11362.     dd : function(format) {
  11363.       return this.localeData().weekdaysMin(this, format);
  11364.     },
  11365.     /**
  11366.      * @param {?} format
  11367.      * @return {?}
  11368.      */
  11369.     ddd : function(format) {
  11370.       return this.localeData().weekdaysShort(this, format);
  11371.     },
  11372.     /**
  11373.      * @param {?} format
  11374.      * @return {?}
  11375.      */
  11376.     dddd : function(format) {
  11377.       return this.localeData().weekdays(this, format);
  11378.     },
  11379.     /**
  11380.      * @return {?}
  11381.      */
  11382.     w : function() {
  11383.       return this.week();
  11384.     },
  11385.     /**
  11386.      * @return {?}
  11387.      */
  11388.     W : function() {
  11389.       return this.isoWeek();
  11390.     },
  11391.     /**
  11392.      * @return {?}
  11393.      */
  11394.     YY : function() {
  11395.       return leftZeroFill(this.year() % 100, 2);
  11396.     },
  11397.     /**
  11398.      * @return {?}
  11399.      */
  11400.     YYYY : function() {
  11401.       return leftZeroFill(this.year(), 4);
  11402.     },
  11403.     /**
  11404.      * @return {?}
  11405.      */
  11406.     YYYYY : function() {
  11407.       return leftZeroFill(this.year(), 5);
  11408.     },
  11409.     /**
  11410.      * @return {?}
  11411.      */
  11412.     YYYYYY : function() {
  11413.       var y = this.year();
  11414.       /** @type {string} */
  11415.       var sign = y >= 0 ? "+" : "-";
  11416.       return sign + leftZeroFill(Math.abs(y), 6);
  11417.     },
  11418.     /**
  11419.      * @return {?}
  11420.      */
  11421.     gg : function() {
  11422.       return leftZeroFill(this.weekYear() % 100, 2);
  11423.     },
  11424.     /**
  11425.      * @return {?}
  11426.      */
  11427.     gggg : function() {
  11428.       return leftZeroFill(this.weekYear(), 4);
  11429.     },
  11430.     /**
  11431.      * @return {?}
  11432.      */
  11433.     ggggg : function() {
  11434.       return leftZeroFill(this.weekYear(), 5);
  11435.     },
  11436.     /**
  11437.      * @return {?}
  11438.      */
  11439.     GG : function() {
  11440.       return leftZeroFill(this.isoWeekYear() % 100, 2);
  11441.     },
  11442.     /**
  11443.      * @return {?}
  11444.      */
  11445.     GGGG : function() {
  11446.       return leftZeroFill(this.isoWeekYear(), 4);
  11447.     },
  11448.     /**
  11449.      * @return {?}
  11450.      */
  11451.     GGGGG : function() {
  11452.       return leftZeroFill(this.isoWeekYear(), 5);
  11453.     },
  11454.     /**
  11455.      * @return {?}
  11456.      */
  11457.     e : function() {
  11458.       return this.weekday();
  11459.     },
  11460.     /**
  11461.      * @return {?}
  11462.      */
  11463.     E : function() {
  11464.       return this.isoWeekday();
  11465.     },
  11466.     /**
  11467.      * @return {?}
  11468.      */
  11469.     a : function() {
  11470.       return this.localeData().meridiem(this.hours(), this.minutes(), true);
  11471.     },
  11472.     /**
  11473.      * @return {?}
  11474.      */
  11475.     A : function() {
  11476.       return this.localeData().meridiem(this.hours(), this.minutes(), false);
  11477.     },
  11478.     /**
  11479.      * @return {?}
  11480.      */
  11481.     H : function() {
  11482.       return this.hours();
  11483.     },
  11484.     /**
  11485.      * @return {?}
  11486.      */
  11487.     h : function() {
  11488.       return this.hours() % 12 || 12;
  11489.     },
  11490.     /**
  11491.      * @return {?}
  11492.      */
  11493.     m : function() {
  11494.       return this.minutes();
  11495.     },
  11496.     /**
  11497.      * @return {?}
  11498.      */
  11499.     s : function() {
  11500.       return this.seconds();
  11501.     },
  11502.     /**
  11503.      * @return {?}
  11504.      */
  11505.     S : function() {
  11506.       return toInt(this.milliseconds() / 100);
  11507.     },
  11508.     /**
  11509.      * @return {?}
  11510.      */
  11511.     SS : function() {
  11512.       return leftZeroFill(toInt(this.milliseconds() / 10), 2);
  11513.     },
  11514.     /**
  11515.      * @return {?}
  11516.      */
  11517.     SSS : function() {
  11518.       return leftZeroFill(this.milliseconds(), 3);
  11519.     },
  11520.     /**
  11521.      * @return {?}
  11522.      */
  11523.     SSSS : function() {
  11524.       return leftZeroFill(this.milliseconds(), 3);
  11525.     },
  11526.     /**
  11527.      * @return {?}
  11528.      */
  11529.     Z : function() {
  11530.       var a = this.utcOffset();
  11531.       /** @type {string} */
  11532.       var b = "+";
  11533.       return 0 > a && (a = -a, b = "-"), b + leftZeroFill(toInt(a / 60), 2) + ":" + leftZeroFill(toInt(a) % 60, 2);
  11534.     },
  11535.     /**
  11536.      * @return {?}
  11537.      */
  11538.     ZZ : function() {
  11539.       var a = this.utcOffset();
  11540.       /** @type {string} */
  11541.       var b = "+";
  11542.       return 0 > a && (a = -a, b = "-"), b + leftZeroFill(toInt(a / 60), 2) + leftZeroFill(toInt(a) % 60, 2);
  11543.     },
  11544.     /**
  11545.      * @return {?}
  11546.      */
  11547.     z : function() {
  11548.       return this.zoneAbbr();
  11549.     },
  11550.     /**
  11551.      * @return {?}
  11552.      */
  11553.     zz : function() {
  11554.       return this.zoneName();
  11555.     },
  11556.     /**
  11557.      * @return {?}
  11558.      */
  11559.     x : function() {
  11560.       return this.valueOf();
  11561.     },
  11562.     /**
  11563.      * @return {?}
  11564.      */
  11565.     X : function() {
  11566.       return this.unix();
  11567.     },
  11568.     /**
  11569.      * @return {?}
  11570.      */
  11571.     Q : function() {
  11572.       return this.quarter();
  11573.     }
  11574.   };
  11575.   var viewItems = {};
  11576.   /** @type {Array} */
  11577.   var lists = ["months", "monthsShort", "weekdays", "weekdaysShort", "weekdaysMin"];
  11578.   /** @type {boolean} */
  11579.   var ii = false;
  11580.   for (;braceStack.length;) {
  11581.     /** @type {string} */
  11582.     i = braceStack.pop();
  11583.     formatTokenFunctions[i + "o"] = ordinalizeToken(formatTokenFunctions[i], i);
  11584.   }
  11585.   for (;eventPath.length;) {
  11586.     /** @type {string} */
  11587.     i = eventPath.pop();
  11588.     formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
  11589.   }
  11590.   formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);
  11591.   extend(Language.prototype, {
  11592.     /**
  11593.      * @param {Object} elem
  11594.      * @return {undefined}
  11595.      */
  11596.     set : function(elem) {
  11597.       var val;
  11598.       var propName;
  11599.       for (propName in elem) {
  11600.         val = elem[propName];
  11601.         if ("function" == typeof val) {
  11602.           /** @type {Function} */
  11603.           this[propName] = val;
  11604.         } else {
  11605.           this["_" + propName] = val;
  11606.         }
  11607.       }
  11608.       /** @type {RegExp} */
  11609.       this._ordinalParseLenient = new RegExp(this._ordinalParse.source + "|" + /\d{1,2}/.source);
  11610.     },
  11611.     _months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
  11612.     /**
  11613.      * @param {number} m
  11614.      * @return {?}
  11615.      */
  11616.     months : function(m) {
  11617.       return this._months[m.month()];
  11618.     },
  11619.     _monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
  11620.     /**
  11621.      * @param {string} m
  11622.      * @return {?}
  11623.      */
  11624.     monthsShort : function(m) {
  11625.       return this._monthsShort[m.month()];
  11626.     },
  11627.     /**
  11628.      * @param {(number|string)} monthName
  11629.      * @param {string} element
  11630.      * @param {string} dataAndEvents
  11631.      * @return {?}
  11632.      */
  11633.     monthsParse : function(monthName, element, dataAndEvents) {
  11634.       var i;
  11635.       var mom;
  11636.       var requestUrl;
  11637.       if (!this._monthsParse) {
  11638.         /** @type {Array} */
  11639.         this._monthsParse = [];
  11640.         /** @type {Array} */
  11641.         this._longMonthsParse = [];
  11642.         /** @type {Array} */
  11643.         this._shortMonthsParse = [];
  11644.       }
  11645.       /** @type {number} */
  11646.       i = 0;
  11647.       for (;12 > i;i++) {
  11648.         if ((mom = moment.utc([2E3, i]), dataAndEvents && (!this._longMonthsParse[i] && (this._longMonthsParse[i] = new RegExp("^" + this.months(mom, "").replace(".", "") + "$", "i"), this._shortMonthsParse[i] = new RegExp("^" + this.monthsShort(mom, "").replace(".", "") + "$", "i"))), dataAndEvents || (this._monthsParse[i] || (requestUrl = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, ""), this._monthsParse[i] = new RegExp(requestUrl.replace(".", ""), "i"))), dataAndEvents && ("MMMM" ===
  11649.         element && this._longMonthsParse[i].test(monthName))) || (dataAndEvents && ("MMM" === element && this._shortMonthsParse[i].test(monthName)) || !dataAndEvents && this._monthsParse[i].test(monthName))) {
  11650.           return i;
  11651.         }
  11652.       }
  11653.     },
  11654.     _weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
  11655.     /**
  11656.      * @param {Object} m
  11657.      * @return {?}
  11658.      */
  11659.     weekdays : function(m) {
  11660.       return this._weekdays[m.day()];
  11661.     },
  11662.     _weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
  11663.     /**
  11664.      * @param {Object} m
  11665.      * @return {?}
  11666.      */
  11667.     weekdaysShort : function(m) {
  11668.       return this._weekdaysShort[m.day()];
  11669.     },
  11670.     _weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
  11671.     /**
  11672.      * @param {Object} m
  11673.      * @return {?}
  11674.      */
  11675.     weekdaysMin : function(m) {
  11676.       return this._weekdaysMin[m.day()];
  11677.     },
  11678.     /**
  11679.      * @param {string} weekdayName
  11680.      * @return {?}
  11681.      */
  11682.     weekdaysParse : function(weekdayName) {
  11683.       var i;
  11684.       var mom;
  11685.       var requestUrl;
  11686.       if (!this._weekdaysParse) {
  11687.         /** @type {Array} */
  11688.         this._weekdaysParse = [];
  11689.       }
  11690.       /** @type {number} */
  11691.       i = 0;
  11692.       for (;7 > i;i++) {
  11693.         if (this._weekdaysParse[i] || (mom = moment([2E3, 1]).day(i), requestUrl = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, ""), this._weekdaysParse[i] = new RegExp(requestUrl.replace(".", ""), "i")), this._weekdaysParse[i].test(weekdayName)) {
  11694.           return i;
  11695.         }
  11696.       }
  11697.     },
  11698.     _longDateFormat : {
  11699.       LTS : "h:mm:ss A",
  11700.       LT : "h:mm A",
  11701.       L : "MM/DD/YYYY",
  11702.       LL : "MMMM D, YYYY",
  11703.       LLL : "MMMM D, YYYY LT",
  11704.       LLLL : "dddd, MMMM D, YYYY LT"
  11705.     },
  11706.     /**
  11707.      * @param {string} key
  11708.      * @return {?}
  11709.      */
  11710.     longDateFormat : function(key) {
  11711.       var output = this._longDateFormat[key];
  11712.       return!output && (this._longDateFormat[key.toUpperCase()] && (output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function(models) {
  11713.         return models.slice(1);
  11714.       }), this._longDateFormat[key] = output)), output;
  11715.     },
  11716.     /**
  11717.      * @param {Object} input
  11718.      * @return {?}
  11719.      */
  11720.     isPM : function(input) {
  11721.       return "p" === (input + "").toLowerCase().charAt(0);
  11722.     },
  11723.     _meridiemParse : /[ap]\.?m?\.?/i,
  11724.     /**
  11725.      * @param {number} hour
  11726.      * @param {?} isUpper
  11727.      * @param {boolean} isLower
  11728.      * @return {?}
  11729.      */
  11730.     meridiem : function(hour, isUpper, isLower) {
  11731.       return hour > 11 ? isLower ? "pm" : "PM" : isLower ? "am" : "AM";
  11732.     },
  11733.     _calendar : {
  11734.       sameDay : "[Today at] LT",
  11735.       nextDay : "[Tomorrow at] LT",
  11736.       nextWeek : "dddd [at] LT",
  11737.       lastDay : "[Yesterday at] LT",
  11738.       lastWeek : "[Last] dddd [at] LT",
  11739.       sameElse : "L"
  11740.     },
  11741.     /**
  11742.      * @param {string} key
  11743.      * @param {?} recurring
  11744.      * @param {?} callback
  11745.      * @return {?}
  11746.      */
  11747.     calendar : function(key, recurring, callback) {
  11748.       var fn = this._calendar[key];
  11749.       return "function" == typeof fn ? fn.apply(recurring, [callback]) : fn;
  11750.     },
  11751.     _relativeTime : {
  11752.       future : "in %s",
  11753.       past : "%s ago",
  11754.       s : "a few seconds",
  11755.       m : "a minute",
  11756.       mm : "%d minutes",
  11757.       h : "an hour",
  11758.       hh : "%d hours",
  11759.       d : "a day",
  11760.       dd : "%d days",
  11761.       M : "a month",
  11762.       MM : "%d months",
  11763.       y : "a year",
  11764.       yy : "%d years"
  11765.     },
  11766.     /**
  11767.      * @param {?} number
  11768.      * @param {boolean} withoutSuffix
  11769.      * @param {?} string
  11770.      * @param {?} isFuture
  11771.      * @return {?}
  11772.      */
  11773.     relativeTime : function(number, withoutSuffix, string, isFuture) {
  11774.       var output = this._relativeTime[string];
  11775.       return "function" == typeof output ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
  11776.     },
  11777.     /**
  11778.      * @param {number} diff
  11779.      * @param {?} output
  11780.      * @return {?}
  11781.      */
  11782.     pastFuture : function(diff, output) {
  11783.       var format = this._relativeTime[diff > 0 ? "future" : "past"];
  11784.       return "function" == typeof format ? format(output) : format.replace(/%s/i, output);
  11785.     },
  11786.     /**
  11787.      * @param {?} number
  11788.      * @return {?}
  11789.      */
  11790.     ordinal : function(number) {
  11791.       return this._ordinal.replace("%d", number);
  11792.     },
  11793.     _ordinal : "%d",
  11794.     _ordinalParse : /\d{1,2}/,
  11795.     /**
  11796.      * @param {?} string
  11797.      * @return {?}
  11798.      */
  11799.     preparse : function(string) {
  11800.       return string;
  11801.     },
  11802.     /**
  11803.      * @param {?} string
  11804.      * @return {?}
  11805.      */
  11806.     postformat : function(string) {
  11807.       return string;
  11808.     },
  11809.     /**
  11810.      * @param {Object} mom
  11811.      * @return {?}
  11812.      */
  11813.     week : function(mom) {
  11814.       return weekOfYear(mom, this._week.dow, this._week.doy).week;
  11815.     },
  11816.     _week : {
  11817.       dow : 0,
  11818.       doy : 6
  11819.     },
  11820.     /**
  11821.      * @return {?}
  11822.      */
  11823.     firstDayOfWeek : function() {
  11824.       return this._week.dow;
  11825.     },
  11826.     /**
  11827.      * @return {?}
  11828.      */
  11829.     firstDayOfYear : function() {
  11830.       return this._week.doy;
  11831.     },
  11832.     _invalidDate : "Invalid date",
  11833.     /**
  11834.      * @return {?}
  11835.      */
  11836.     invalidDate : function() {
  11837.       return this._invalidDate;
  11838.     }
  11839.   });
  11840.   /**
  11841.    * @param {string} input
  11842.    * @param {?} res
  11843.    * @param {(Function|string)} i
  11844.    * @param {Object} item
  11845.    * @return {?}
  11846.    */
  11847.   moment = function(input, res, i, item) {
  11848.     var config;
  11849.     return "boolean" == typeof i && (item = i, i = first), config = {}, config._isAMomentObject = true, config._i = input, config._f = res, config._l = i, config._strict = item, config._isUTC = false, config._pf = validateTransport(), makeMoment(config);
  11850.   };
  11851.   /** @type {boolean} */
  11852.   moment.suppressDeprecationWarnings = false;
  11853.   moment.createFromInputFallback = timeout("moment construction falls back to js Date. This is discouraged and will be removed in upcoming major release. Please refer to https://github.com/moment/moment/issues/1407 for more info.", function(config) {
  11854.     /** @type {Date} */
  11855.     config._d = new Date(config._i + (config._useUTC ? " UTC" : ""));
  11856.   });
  11857.   /**
  11858.    * @return {?}
  11859.    */
  11860.   moment.min = function() {
  11861.     /** @type {Array.<?>} */
  11862.     var size = [].slice.call(arguments, 0);
  11863.     return reduce("isBefore", size);
  11864.   };
  11865.   /**
  11866.    * @return {?}
  11867.    */
  11868.   moment.max = function() {
  11869.     /** @type {Array.<?>} */
  11870.     var size = [].slice.call(arguments, 0);
  11871.     return reduce("isAfter", size);
  11872.   };
  11873.   /**
  11874.    * @param {string} value
  11875.    * @param {?} date
  11876.    * @param {(Function|string)} n
  11877.    * @param {(Function|string)} name
  11878.    * @return {?}
  11879.    */
  11880.   moment.utc = function(value, date, n, name) {
  11881.     var config;
  11882.     return "boolean" == typeof n && (name = n, n = first), config = {}, config._isAMomentObject = true, config._useUTC = true, config._isUTC = true, config._l = n, config._i = value, config._f = date, config._strict = name, config._pf = validateTransport(), makeMoment(config).utc();
  11883.   };
  11884.   /**
  11885.    * @param {number} timestamp
  11886.    * @return {?}
  11887.    */
  11888.   moment.unix = function(timestamp) {
  11889.     return moment(1E3 * timestamp);
  11890.   };
  11891.   /**
  11892.    * @param {number} input
  11893.    * @param {?} key
  11894.    * @return {?}
  11895.    */
  11896.   moment.duration = function(input, key) {
  11897.     var sign;
  11898.     var ret;
  11899.     var parseIso;
  11900.     var d;
  11901.     /** @type {number} */
  11902.     var duration = input;
  11903.     /** @type {null} */
  11904.     var match = null;
  11905.     return moment.isDuration(input) ? duration = {
  11906.       ms : input._milliseconds,
  11907.       d : input._days,
  11908.       M : input._months
  11909.     } : "number" == typeof input ? (duration = {}, key ? duration[key] = input : duration.milliseconds = input) : (match = re.exec(input)) ? (sign = "-" === match[1] ? -1 : 1, duration = {
  11910.       y : 0,
  11911.       d : toInt(match[HOUR]) * sign,
  11912.       h : toInt(match[DATE]) * sign,
  11913.       m : toInt(match[SECOND]) * sign,
  11914.       s : toInt(match[MINUTE]) * sign,
  11915.       ms : toInt(match[MILLISECOND]) * sign
  11916.     }) : (match = string.exec(input)) ? (sign = "-" === match[1] ? -1 : 1, parseIso = function(inp) {
  11917.       var res = inp && parseFloat(inp.replace(",", "."));
  11918.       return(isNaN(res) ? 0 : res) * sign;
  11919.     }, duration = {
  11920.       y : parseIso(match[2]),
  11921.       M : parseIso(match[3]),
  11922.       d : parseIso(match[4]),
  11923.       h : parseIso(match[5]),
  11924.       m : parseIso(match[6]),
  11925.       s : parseIso(match[7]),
  11926.       w : parseIso(match[8])
  11927.     }) : null == duration ? duration = {} : "object" == typeof duration && (("from" in duration || "to" in duration) && (d = addNode(moment(duration.from), moment(duration.to)), duration = {}, duration.ms = d.milliseconds, duration.M = d.months)), ret = new Duration(duration), moment.isDuration(input) && (hasOwn(input, "_locale") && (ret._locale = input._locale)), ret;
  11928.   };
  11929.   /** @type {string} */
  11930.   moment.version = "2.9.0";
  11931.   /** @type {string} */
  11932.   moment.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
  11933.   /**
  11934.    * @return {undefined}
  11935.    */
  11936.   moment.ISO_8601 = function() {
  11937.   };
  11938.   /** @type {Array} */
  11939.   moment.momentProperties = keys;
  11940.   /**
  11941.    * @return {undefined}
  11942.    */
  11943.   moment.updateOffset = function() {
  11944.   };
  11945.   /**
  11946.    * @param {?} key
  11947.    * @param {?} val
  11948.    * @return {?}
  11949.    */
  11950.   moment.relativeTimeThreshold = function(key, val) {
  11951.     return data[key] === first ? false : val === first ? data[key] : (data[key] = val, true);
  11952.   };
  11953.   moment.lang = timeout("moment.lang is deprecated. Use moment.locale instead.", function(storageKey, type) {
  11954.     return moment.locale(storageKey, type);
  11955.   });
  11956.   /**
  11957.    * @param {?} key
  11958.    * @param {?} type
  11959.    * @return {?}
  11960.    */
  11961.   moment.locale = function(key, type) {
  11962.     var VERSION;
  11963.     return key && (VERSION = "undefined" != typeof type ? moment.defineLocale(key, type) : moment.localeData(key), VERSION && (moment.duration._locale = moment._locale = VERSION)), moment._locale._abbr;
  11964.   };
  11965.   /**
  11966.    * @param {?} key
  11967.    * @param {Object} elem
  11968.    * @return {?}
  11969.    */
  11970.   moment.defineLocale = function(key, elem) {
  11971.     return null !== elem ? (elem.abbr = key, languages[key] || (languages[key] = new Language), languages[key].set(elem), moment.locale(key), languages[key]) : (delete languages[key], null);
  11972.   };
  11973.   moment.langData = timeout("moment.langData is deprecated. Use moment.localeData instead.", function(input) {
  11974.     return moment.localeData(input);
  11975.   });
  11976.   /**
  11977.    * @param {Array} key
  11978.    * @return {?}
  11979.    */
  11980.   moment.localeData = function(key) {
  11981.     var result;
  11982.     if (key && (key._locale && (key._locale._abbr && (key = key._locale._abbr))), !key) {
  11983.       return moment._locale;
  11984.     }
  11985.     if (!isArray(key)) {
  11986.       if (result = test(key)) {
  11987.         return result;
  11988.       }
  11989.       /** @type {Array} */
  11990.       key = [key];
  11991.     }
  11992.     return check(key);
  11993.   };
  11994.   /**
  11995.    * @param {?} obj
  11996.    * @return {?}
  11997.    */
  11998.   moment.isMoment = function(obj) {
  11999.     return obj instanceof Moment || null != obj && hasOwn(obj, "_isAMomentObject");
  12000.   };
  12001.   /**
  12002.    * @param {number} obj
  12003.    * @return {?}
  12004.    */
  12005.   moment.isDuration = function(obj) {
  12006.     return obj instanceof Duration;
  12007.   };
  12008.   /** @type {number} */
  12009.   i = lists.length - 1;
  12010.   for (;i >= 0;--i) {
  12011.     makeList(lists[i]);
  12012.   }
  12013.   /**
  12014.    * @param {string} units
  12015.    * @return {?}
  12016.    */
  12017.   moment.normalizeUnits = function(units) {
  12018.     return normalizeUnits(units);
  12019.   };
  12020.   /**
  12021.    * @param {Object} flags
  12022.    * @return {?}
  12023.    */
  12024.   moment.invalid = function(flags) {
  12025.     var m = moment.utc(NaN);
  12026.     return null != flags ? extend(m._pf, flags) : m._pf.userInvalidated = true, m;
  12027.   };
  12028.   /**
  12029.    * @return {?}
  12030.    */
  12031.   moment.parseZone = function() {
  12032.     return moment.apply(null, arguments).parseZone();
  12033.   };
  12034.   /**
  12035.    * @param {string} input
  12036.    * @return {?}
  12037.    */
  12038.   moment.parseTwoDigitYear = function(input) {
  12039.     return toInt(input) + (toInt(input) > 68 ? 1900 : 2E3);
  12040.   };
  12041.   /** @type {function (?): ?} */
  12042.   moment.isDate = isDate;
  12043.   extend(moment.fn = Moment.prototype, {
  12044.     /**
  12045.      * @return {?}
  12046.      */
  12047.     clone : function() {
  12048.       return moment(this);
  12049.     },
  12050.     /**
  12051.      * @return {?}
  12052.      */
  12053.     valueOf : function() {
  12054.       return+this._d - 6E4 * (this._offset || 0);
  12055.     },
  12056.     /**
  12057.      * @return {?}
  12058.      */
  12059.     unix : function() {
  12060.       return Math.floor(+this / 1E3);
  12061.     },
  12062.     /**
  12063.      * @return {?}
  12064.      */
  12065.     toString : function() {
  12066.       return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
  12067.     },
  12068.     /**
  12069.      * @return {?}
  12070.      */
  12071.     toDate : function() {
  12072.       return this._offset ? new Date(+this) : this._d;
  12073.     },
  12074.     /**
  12075.      * @return {?}
  12076.      */
  12077.     toISOString : function() {
  12078.       var m = moment(this).utc();
  12079.       return 0 < m.year() && m.year() <= 9999 ? "function" == typeof Date.prototype.toISOString ? this.toDate().toISOString() : formatMoment(m, "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]") : formatMoment(m, "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]");
  12080.     },
  12081.     /**
  12082.      * @return {?}
  12083.      */
  12084.     toArray : function() {
  12085.       var m = this;
  12086.       return[m.year(), m.month(), m.date(), m.hours(), m.minutes(), m.seconds(), m.milliseconds()];
  12087.     },
  12088.     /**
  12089.      * @return {?}
  12090.      */
  12091.     isValid : function() {
  12092.       return isValid(this);
  12093.     },
  12094.     /**
  12095.      * @return {?}
  12096.      */
  12097.     isDSTShifted : function() {
  12098.       return this._a ? this.isValid() && compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray()) > 0 : false;
  12099.     },
  12100.     /**
  12101.      * @return {?}
  12102.      */
  12103.     parsingFlags : function() {
  12104.       return extend({}, this._pf);
  12105.     },
  12106.     /**
  12107.      * @return {?}
  12108.      */
  12109.     invalidAt : function() {
  12110.       return this._pf.overflow;
  12111.     },
  12112.     /**
  12113.      * @param {Object} value
  12114.      * @return {?}
  12115.      */
  12116.     utc : function(value) {
  12117.       return this.utcOffset(0, value);
  12118.     },
  12119.     /**
  12120.      * @param {Object} isXML
  12121.      * @return {?}
  12122.      */
  12123.     local : function(isXML) {
  12124.       return this._isUTC && (this.utcOffset(0, isXML), this._isUTC = false, isXML && this.subtract(this._dateUtcOffset(), "m")), this;
  12125.     },
  12126.     /**
  12127.      * @param {string} inputString
  12128.      * @return {?}
  12129.      */
  12130.     format : function(inputString) {
  12131.       var output = formatMoment(this, inputString || moment.defaultFormat);
  12132.       return this.localeData().postformat(output);
  12133.     },
  12134.     add : update(1, "add"),
  12135.     subtract : update(-1, "subtract"),
  12136.     /**
  12137.      * @param {string} input
  12138.      * @param {string} units
  12139.      * @param {boolean} asFloat
  12140.      * @return {?}
  12141.      */
  12142.     diff : function(input, units, asFloat) {
  12143.       var right;
  12144.       var output;
  12145.       var i = makeAs(input, this);
  12146.       /** @type {number} */
  12147.       var left = 6E4 * (i.utcOffset() - this.utcOffset());
  12148.       return units = normalizeUnits(units), "year" === units || ("month" === units || "quarter" === units) ? (output = push(this, i), "quarter" === units ? output /= 3 : "year" === units && (output /= 12)) : (right = this - i, output = "second" === units ? right / 1E3 : "minute" === units ? right / 6E4 : "hour" === units ? right / 36E5 : "day" === units ? (right - left) / 864E5 : "week" === units ? (right - left) / 6048E5 : right), asFloat ? output : absRound(output);
  12149.     },
  12150.     /**
  12151.      * @param {(number|string)} currency
  12152.      * @param {?} withoutSuffix
  12153.      * @return {?}
  12154.      */
  12155.     from : function(currency, withoutSuffix) {
  12156.       return moment.duration({
  12157.         to : this,
  12158.         from : currency
  12159.       }).locale(this.locale()).humanize(!withoutSuffix);
  12160.     },
  12161.     /**
  12162.      * @param {?} withoutSuffix
  12163.      * @return {?}
  12164.      */
  12165.     fromNow : function(withoutSuffix) {
  12166.       return this.from(moment(), withoutSuffix);
  12167.     },
  12168.     /**
  12169.      * @param {(Object|boolean|number|string)} key
  12170.      * @return {?}
  12171.      */
  12172.     calendar : function(key) {
  12173.       var input = key || moment();
  12174.       var sod = makeAs(input, this).startOf("day");
  12175.       var diff = this.diff(sod, "days", true);
  12176.       /** @type {string} */
  12177.       var format = -6 > diff ? "sameElse" : -1 > diff ? "lastWeek" : 0 > diff ? "lastDay" : 1 > diff ? "sameDay" : 2 > diff ? "nextDay" : 7 > diff ? "nextWeek" : "sameElse";
  12178.       return this.format(this.localeData().calendar(format, this, moment(input)));
  12179.     },
  12180.     /**
  12181.      * @return {?}
  12182.      */
  12183.     isLeapYear : function() {
  12184.       return isLeapYear(this.year());
  12185.     },
  12186.     /**
  12187.      * @return {?}
  12188.      */
  12189.     isDST : function() {
  12190.       return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();
  12191.     },
  12192.     /**
  12193.      * @param {number} input
  12194.      * @return {?}
  12195.      */
  12196.     day : function(input) {
  12197.       var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
  12198.       return null != input ? (input = parseWeekday(input, this.localeData()), this.add(input - day, "d")) : day;
  12199.     },
  12200.     month : setTick("Month", true),
  12201.     /**
  12202.      * @param {string} units
  12203.      * @return {?}
  12204.      */
  12205.     startOf : function(units) {
  12206.       switch(units = normalizeUnits(units)) {
  12207.         case "year":
  12208.           this.month(0);
  12209.         case "quarter":
  12210.         ;
  12211.         case "month":
  12212.           this.date(1);
  12213.         case "week":
  12214.         ;
  12215.         case "isoWeek":
  12216.         ;
  12217.         case "day":
  12218.           this.hours(0);
  12219.         case "hour":
  12220.           this.minutes(0);
  12221.         case "minute":
  12222.           this.seconds(0);
  12223.         case "second":
  12224.           this.milliseconds(0);
  12225.       }
  12226.       return "week" === units ? this.weekday(0) : "isoWeek" === units && this.isoWeekday(1), "quarter" === units && this.month(3 * Math.floor(this.month() / 3)), this;
  12227.     },
  12228.     /**
  12229.      * @param {?} units
  12230.      * @return {?}
  12231.      */
  12232.     endOf : function(units) {
  12233.       return units = normalizeUnits(units), units === first || "millisecond" === units ? this : this.startOf(units).add(1, "isoWeek" === units ? "week" : units).subtract(1, "ms");
  12234.     },
  12235.     /**
  12236.      * @param {?} input
  12237.      * @param {number} units
  12238.      * @return {?}
  12239.      */
  12240.     isAfter : function(input, units) {
  12241.       var r;
  12242.       return units = normalizeUnits("undefined" != typeof units ? units : "millisecond"), "millisecond" === units ? (input = moment.isMoment(input) ? input : moment(input), +this > +input) : (r = moment.isMoment(input) ? +input : +moment(input), r < +this.clone().startOf(units));
  12243.     },
  12244.     /**
  12245.      * @param {string} input
  12246.      * @param {number} units
  12247.      * @return {?}
  12248.      */
  12249.     isBefore : function(input, units) {
  12250.       var length;
  12251.       return units = normalizeUnits("undefined" != typeof units ? units : "millisecond"), "millisecond" === units ? (input = moment.isMoment(input) ? input : moment(input), +input > +this) : (length = moment.isMoment(input) ? +input : +moment(input), +this.clone().endOf(units) < length);
  12252.     },
  12253.     /**
  12254.      * @param {?} a
  12255.      * @param {string} b
  12256.      * @param {number} units
  12257.      * @return {?}
  12258.      */
  12259.     isBetween : function(a, b, units) {
  12260.       return this.isAfter(a, units) && this.isBefore(b, units);
  12261.     },
  12262.     /**
  12263.      * @param {(Error|string)} input
  12264.      * @param {number} units
  12265.      * @return {?}
  12266.      */
  12267.     isSame : function(input, units) {
  12268.       var numChars;
  12269.       return units = normalizeUnits(units || "millisecond"), "millisecond" === units ? (input = moment.isMoment(input) ? input : moment(input), +this == +input) : (numChars = +moment(input), +this.clone().startOf(units) <= numChars && numChars <= +this.clone().endOf(units));
  12270.     },
  12271.     min : timeout("moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548", function(memo) {
  12272.       return memo = moment.apply(null, arguments), this > memo ? this : memo;
  12273.     }),
  12274.     max : timeout("moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548", function(other) {
  12275.       return other = moment.apply(null, arguments), other > this ? this : other;
  12276.     }),
  12277.     zone : timeout("moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779", function(v, isXML) {
  12278.       return null != v ? ("string" != typeof v && (v = -v), this.utcOffset(v, isXML), this) : -this.utcOffset();
  12279.     }),
  12280.     /**
  12281.      * @param {number} offset
  12282.      * @param {Object} value
  12283.      * @return {?}
  12284.      */
  12285.     utcOffset : function(offset, value) {
  12286.       var node;
  12287.       var input = this._offset || 0;
  12288.       return null != offset ? ("string" == typeof offset && (offset = timezoneMinutesFromString(offset)), Math.abs(offset) < 16 && (offset = 60 * offset), !this._isUTC && (value && (node = this._dateUtcOffset())), this._offset = offset, this._isUTC = true, null != node && this.add(node, "m"), input !== offset && (!value || this._changeInProgress ? addOrSubtractDurationFromMoment(this, moment.duration(offset - input, "m"), 1, false) : this._changeInProgress || (this._changeInProgress = true, moment.updateOffset(this,
  12289.       true), this._changeInProgress = null)), this) : this._isUTC ? input : this._dateUtcOffset();
  12290.     },
  12291.     /**
  12292.      * @return {?}
  12293.      */
  12294.     isLocal : function() {
  12295.       return!this._isUTC;
  12296.     },
  12297.     /**
  12298.      * @return {?}
  12299.      */
  12300.     isUtcOffset : function() {
  12301.       return this._isUTC;
  12302.     },
  12303.     /**
  12304.      * @return {?}
  12305.      */
  12306.     isUtc : function() {
  12307.       return this._isUTC && 0 === this._offset;
  12308.     },
  12309.     /**
  12310.      * @return {?}
  12311.      */
  12312.     zoneAbbr : function() {
  12313.       return this._isUTC ? "UTC" : "";
  12314.     },
  12315.     /**
  12316.      * @return {?}
  12317.      */
  12318.     zoneName : function() {
  12319.       return this._isUTC ? "Coordinated Universal Time" : "";
  12320.     },
  12321.     /**
  12322.      * @return {?}
  12323.      */
  12324.     parseZone : function() {
  12325.       return this._tzm ? this.utcOffset(this._tzm) : "string" == typeof this._i && this.utcOffset(timezoneMinutesFromString(this._i)), this;
  12326.     },
  12327.     /**
  12328.      * @param {boolean} input
  12329.      * @return {?}
  12330.      */
  12331.     hasAlignedHourOffset : function(input) {
  12332.       return input = input ? moment(input).utcOffset() : 0, (this.utcOffset() - input) % 60 == 0;
  12333.     },
  12334.     /**
  12335.      * @return {?}
  12336.      */
  12337.     daysInMonth : function() {
  12338.       return daysInMonth(this.year(), this.month());
  12339.     },
  12340.     /**
  12341.      * @param {number} d
  12342.      * @return {?}
  12343.      */
  12344.     dayOfYear : function(d) {
  12345.       /** @type {number} */
  12346.       var b = parseInt((moment(this).startOf("day") - moment(this).startOf("year")) / 864E5) + 1;
  12347.       return null == d ? b : this.add(d - b, "d");
  12348.     },
  12349.     /**
  12350.      * @param {number} dataAndEvents
  12351.      * @return {?}
  12352.      */
  12353.     quarter : function(dataAndEvents) {
  12354.       return null == dataAndEvents ? Math.ceil((this.month() + 1) / 3) : this.month(3 * (dataAndEvents - 1) + this.month() % 3);
  12355.     },
  12356.     /**
  12357.      * @param {number} max
  12358.      * @return {?}
  12359.      */
  12360.     weekYear : function(max) {
  12361.       var min = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
  12362.       return null == max ? min : this.add(max - min, "y");
  12363.     },
  12364.     /**
  12365.      * @param {number} max
  12366.      * @return {?}
  12367.      */
  12368.     isoWeekYear : function(max) {
  12369.       var min = weekOfYear(this, 1, 4).year;
  12370.       return null == max ? min : this.add(max - min, "y");
  12371.     },
  12372.     /**
  12373.      * @param {number} t
  12374.      * @return {?}
  12375.      */
  12376.     week : function(t) {
  12377.       var b = this.localeData().week(this);
  12378.       return null == t ? b : this.add(7 * (t - b), "d");
  12379.     },
  12380.     /**
  12381.      * @param {number} max
  12382.      * @return {?}
  12383.      */
  12384.     isoWeek : function(max) {
  12385.       var min = weekOfYear(this, 1, 4).week;
  12386.       return null == max ? min : this.add(7 * (max - min), "d");
  12387.     },
  12388.     /**
  12389.      * @param {number} max
  12390.      * @return {?}
  12391.      */
  12392.     weekday : function(max) {
  12393.       /** @type {number} */
  12394.       var min = (this.day() + 7 - this.localeData()._week.dow) % 7;
  12395.       return null == max ? min : this.add(max - min, "d");
  12396.     },
  12397.     /**
  12398.      * @param {number} dataAndEvents
  12399.      * @return {?}
  12400.      */
  12401.     isoWeekday : function(dataAndEvents) {
  12402.       return null == dataAndEvents ? this.day() || 7 : this.day(this.day() % 7 ? dataAndEvents : dataAndEvents - 7);
  12403.     },
  12404.     /**
  12405.      * @return {?}
  12406.      */
  12407.     isoWeeksInYear : function() {
  12408.       return createDom(this.year(), 1, 4);
  12409.     },
  12410.     /**
  12411.      * @return {?}
  12412.      */
  12413.     weeksInYear : function() {
  12414.       var expectation = this.localeData()._week;
  12415.       return createDom(this.year(), expectation.dow, expectation.doy);
  12416.     },
  12417.     /**
  12418.      * @param {Object} owner
  12419.      * @return {?}
  12420.      */
  12421.     get : function(owner) {
  12422.       return owner = normalizeUnits(owner), this[owner]();
  12423.     },
  12424.     /**
  12425.      * @param {Object} owner
  12426.      * @param {string} value
  12427.      * @return {?}
  12428.      */
  12429.     set : function(owner, value) {
  12430.       var src;
  12431.       if ("object" == typeof owner) {
  12432.         for (src in owner) {
  12433.           this.set(src, owner[src]);
  12434.         }
  12435.       } else {
  12436.         owner = normalizeUnits(owner);
  12437.         if ("function" == typeof this[owner]) {
  12438.           this[owner](value);
  12439.         }
  12440.       }
  12441.       return this;
  12442.     },
  12443.     /**
  12444.      * @param {?} key
  12445.      * @return {?}
  12446.      */
  12447.     locale : function(key) {
  12448.       var camel;
  12449.       return key === first ? this._locale._abbr : (camel = moment.localeData(key), null != camel && (this._locale = camel), this);
  12450.     },
  12451.     lang : timeout("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.", function(key) {
  12452.       return key === first ? this.localeData() : this.locale(key);
  12453.     }),
  12454.     /**
  12455.      * @return {?}
  12456.      */
  12457.     localeData : function() {
  12458.       return this._locale;
  12459.     },
  12460.     /**
  12461.      * @return {?}
  12462.      */
  12463.     _dateUtcOffset : function() {
  12464.       return 15 * -Math.round(this._d.getTimezoneOffset() / 15);
  12465.     }
  12466.   });
  12467.   moment.fn.millisecond = moment.fn.milliseconds = setTick("Milliseconds", false);
  12468.   moment.fn.second = moment.fn.seconds = setTick("Seconds", false);
  12469.   moment.fn.minute = moment.fn.minutes = setTick("Minutes", false);
  12470.   moment.fn.hour = moment.fn.hours = setTick("Hours", true);
  12471.   moment.fn.date = setTick("Date", true);
  12472.   moment.fn.dates = timeout("dates accessor is deprecated. Use date instead.", setTick("Date", true));
  12473.   moment.fn.year = setTick("FullYear", true);
  12474.   moment.fn.years = timeout("years accessor is deprecated. Use year instead.", setTick("FullYear", true));
  12475.   moment.fn.days = moment.fn.day;
  12476.   moment.fn.months = moment.fn.month;
  12477.   moment.fn.weeks = moment.fn.week;
  12478.   moment.fn.isoWeeks = moment.fn.isoWeek;
  12479.   moment.fn.quarters = moment.fn.quarter;
  12480.   moment.fn.toJSON = moment.fn.toISOString;
  12481.   moment.fn.isUTC = moment.fn.isUtc;
  12482.   extend(moment.duration.fn = Duration.prototype, {
  12483.     /**
  12484.      * @return {undefined}
  12485.      */
  12486.     _bubble : function() {
  12487.       var seconds;
  12488.       var minutes;
  12489.       var hours;
  12490.       var milliseconds = this._milliseconds;
  12491.       var days = this._days;
  12492.       var months = this._months;
  12493.       var data = this._data;
  12494.       /** @type {number} */
  12495.       var years = 0;
  12496.       /** @type {number} */
  12497.       data.milliseconds = milliseconds % 1E3;
  12498.       seconds = absRound(milliseconds / 1E3);
  12499.       /** @type {number} */
  12500.       data.seconds = seconds % 60;
  12501.       minutes = absRound(seconds / 60);
  12502.       /** @type {number} */
  12503.       data.minutes = minutes % 60;
  12504.       hours = absRound(minutes / 60);
  12505.       /** @type {number} */
  12506.       data.hours = hours % 24;
  12507.       days += absRound(hours / 24);
  12508.       years = absRound(isNumeric(days));
  12509.       days -= absRound(randomId(years));
  12510.       months += absRound(days / 30);
  12511.       days %= 30;
  12512.       years += absRound(months / 12);
  12513.       months %= 12;
  12514.       data.days = days;
  12515.       data.months = months;
  12516.       data.years = years;
  12517.     },
  12518.     /**
  12519.      * @return {?}
  12520.      */
  12521.     abs : function() {
  12522.       return this._milliseconds = Math.abs(this._milliseconds), this._days = Math.abs(this._days), this._months = Math.abs(this._months), this._data.milliseconds = Math.abs(this._data.milliseconds), this._data.seconds = Math.abs(this._data.seconds), this._data.minutes = Math.abs(this._data.minutes), this._data.hours = Math.abs(this._data.hours), this._data.months = Math.abs(this._data.months), this._data.years = Math.abs(this._data.years), this;
  12523.     },
  12524.     /**
  12525.      * @return {?}
  12526.      */
  12527.     weeks : function() {
  12528.       return absRound(this.days() / 7);
  12529.     },
  12530.     /**
  12531.      * @return {?}
  12532.      */
  12533.     valueOf : function() {
  12534.       return this._milliseconds + 864E5 * this._days + this._months % 12 * 2592E6 + 31536E6 * toInt(this._months / 12);
  12535.     },
  12536.     /**
  12537.      * @param {boolean} lowFirstLetter
  12538.      * @return {?}
  12539.      */
  12540.     humanize : function(lowFirstLetter) {
  12541.       var output = preset(this, !lowFirstLetter, this.localeData());
  12542.       return lowFirstLetter && (output = this.localeData().pastFuture(+this, output)), this.localeData().postformat(output);
  12543.     },
  12544.     /**
  12545.      * @param {number} name
  12546.      * @param {?} val
  12547.      * @return {?}
  12548.      */
  12549.     add : function(name, val) {
  12550.       var dur = moment.duration(name, val);
  12551.       return this._milliseconds += dur._milliseconds, this._days += dur._days, this._months += dur._months, this._bubble(), this;
  12552.     },
  12553.     /**
  12554.      * @param {number} input
  12555.      * @param {?} val
  12556.      * @return {?}
  12557.      */
  12558.     subtract : function(input, val) {
  12559.       var dur = moment.duration(input, val);
  12560.       return this._milliseconds -= dur._milliseconds, this._days -= dur._days, this._months -= dur._months, this._bubble(), this;
  12561.     },
  12562.     /**
  12563.      * @param {Object} num
  12564.      * @return {?}
  12565.      */
  12566.     get : function(num) {
  12567.       return num = normalizeUnits(num), this[num.toLowerCase() + "s"]();
  12568.     },
  12569.     /**
  12570.      * @param {string} v
  12571.      * @return {?}
  12572.      */
  12573.     as : function(v) {
  12574.       var ch;
  12575.       var defValue;
  12576.       if (v = normalizeUnits(v), "month" === v || "year" === v) {
  12577.         return ch = this._days + this._milliseconds / 864E5, defValue = this._months + 12 * isNumeric(ch), "month" === v ? defValue : defValue / 12;
  12578.       }
  12579.       switch(ch = this._days + Math.round(randomId(this._months / 12)), v) {
  12580.         case "week":
  12581.           return ch / 7 + this._milliseconds / 6048E5;
  12582.         case "day":
  12583.           return ch + this._milliseconds / 864E5;
  12584.         case "hour":
  12585.           return 24 * ch + this._milliseconds / 36E5;
  12586.         case "minute":
  12587.           return 1440 * ch + this._milliseconds / 6E4;
  12588.         case "second":
  12589.           return 86400 * ch + this._milliseconds / 1E3;
  12590.         case "millisecond":
  12591.           return Math.floor(864E5 * ch) + this._milliseconds;
  12592.         default:
  12593.           throw new Error("Unknown unit " + v);;
  12594.       }
  12595.     },
  12596.     lang : moment.fn.lang,
  12597.     locale : moment.fn.locale,
  12598.     toIsoString : timeout("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", function() {
  12599.       return this.toISOString();
  12600.     }),
  12601.     /**
  12602.      * @return {?}
  12603.      */
  12604.     toISOString : function() {
  12605.       /** @type {number} */
  12606.       var years = Math.abs(this.years());
  12607.       /** @type {number} */
  12608.       var months = Math.abs(this.months());
  12609.       /** @type {number} */
  12610.       var days = Math.abs(this.days());
  12611.       /** @type {number} */
  12612.       var hours = Math.abs(this.hours());
  12613.       /** @type {number} */
  12614.       var minutes = Math.abs(this.minutes());
  12615.       /** @type {number} */
  12616.       var seconds = Math.abs(this.seconds() + this.milliseconds() / 1E3);
  12617.       return this.asSeconds() ? (this.asSeconds() < 0 ? "-" : "") + "P" + (years ? years + "Y" : "") + (months ? months + "M" : "") + (days ? days + "D" : "") + (hours || (minutes || seconds) ? "T" : "") + (hours ? hours + "H" : "") + (minutes ? minutes + "M" : "") + (seconds ? seconds + "S" : "") : "P0D";
  12618.     },
  12619.     /**
  12620.      * @return {?}
  12621.      */
  12622.     localeData : function() {
  12623.       return this._locale;
  12624.     },
  12625.     /**
  12626.      * @return {?}
  12627.      */
  12628.     toJSON : function() {
  12629.       return this.toISOString();
  12630.     }
  12631.   });
  12632.   moment.duration.fn.toString = moment.duration.fn.toISOString;
  12633.   for (i in obj) {
  12634.     if (hasOwn(obj, i)) {
  12635.       makeDurationGetter(i.toLowerCase());
  12636.     }
  12637.   }
  12638.   /**
  12639.    * @return {?}
  12640.    */
  12641.   moment.duration.fn.asMilliseconds = function() {
  12642.     return this.as("ms");
  12643.   };
  12644.   /**
  12645.    * @return {?}
  12646.    */
  12647.   moment.duration.fn.asSeconds = function() {
  12648.     return this.as("s");
  12649.   };
  12650.   /**
  12651.    * @return {?}
  12652.    */
  12653.   moment.duration.fn.asMinutes = function() {
  12654.     return this.as("m");
  12655.   };
  12656.   /**
  12657.    * @return {?}
  12658.    */
  12659.   moment.duration.fn.asHours = function() {
  12660.     return this.as("h");
  12661.   };
  12662.   /**
  12663.    * @return {?}
  12664.    */
  12665.   moment.duration.fn.asDays = function() {
  12666.     return this.as("d");
  12667.   };
  12668.   /**
  12669.    * @return {?}
  12670.    */
  12671.   moment.duration.fn.asWeeks = function() {
  12672.     return this.as("weeks");
  12673.   };
  12674.   /**
  12675.    * @return {?}
  12676.    */
  12677.   moment.duration.fn.asMonths = function() {
  12678.     return this.as("M");
  12679.   };
  12680.   /**
  12681.    * @return {?}
  12682.    */
  12683.   moment.duration.fn.asYears = function() {
  12684.     return this.as("y");
  12685.   };
  12686.   moment.locale("en", {
  12687.     ordinalParse : /\d{1,2}(th|st|nd|rd)/,
  12688.     /**
  12689.      * @param {number} number
  12690.      * @return {?}
  12691.      */
  12692.     ordinal : function(number) {
  12693.       /** @type {number} */
  12694.       var b = number % 10;
  12695.       /** @type {string} */
  12696.       var output = 1 === toInt(number % 100 / 10) ? "th" : 1 === b ? "st" : 2 === b ? "nd" : 3 === b ? "rd" : "th";
  12697.       return number + output;
  12698.     }
  12699.   });
  12700.   if (sr) {
  12701.     /** @type {function (string, ?, (Function|string), Object): ?} */
  12702.     module.exports = moment;
  12703.   } else {
  12704.     if ("function" == typeof define && define.amd) {
  12705.       define(function(dataAndEvents, deepDataAndEvents, module) {
  12706.         return module.config && (module.config() && (module.config().noGlobal === true && (root.moment = previous_async))), moment;
  12707.       });
  12708.       clone(true);
  12709.     } else {
  12710.       clone();
  12711.     }
  12712.   }
  12713. }.call(this);
  12714. if (typeof String.prototype.startsWith != "function") {
  12715.   /**
  12716.    * @param {string} pattern
  12717.    * @return {?}
  12718.    */
  12719.   String.prototype.startsWith = function(pattern) {
  12720.     return this.indexOf(pattern) == 0;
  12721.   };
  12722. }
  12723. if (typeof String.prototype.format != "function") {
  12724.   /**
  12725.    * @param {string} args
  12726.    * @return {?}
  12727.    */
  12728.   String.prototype.format = function(args) {
  12729.     return this.replace(/{(\d+)}/g, function(match, which) {
  12730.       return typeof args[which] != "undefined" ? args[which] : match;
  12731.     });
  12732.   };
  12733. }
  12734. if (typeof Number.prototype.toFixedString != "function") {
  12735.   /**
  12736.    * @param {number} i
  12737.    * @return {?}
  12738.    */
  12739.   Number.prototype.toFixedString = function(i) {
  12740.     /** @type {number} */
  12741.     var s = Math.pow(10, i);
  12742.     /** @type {string} */
  12743.     var r = (this * s).toString();
  12744.     if (r && r.indexOf(".") > 0) {
  12745.       /** @type {string} */
  12746.       r = r.substring(0, r.indexOf(".") + i);
  12747.     } else {
  12748.       return this.toFixed(i);
  12749.     }
  12750.     return(Math.round(r) / s).toFixed(i);
  12751.   };
  12752. }
  12753. var CryptoJS = CryptoJS || function(Math, className) {
  12754.   var C = {};
  12755.   var C_lib = C.lib = {};
  12756.   /**
  12757.    * @return {undefined}
  12758.    */
  12759.   var F = function() {
  12760.   };
  12761.   var Base = C_lib.Base = {
  12762.     /**
  12763.      * @param {?} expectedNumberOfNonCommentArgs
  12764.      * @return {?}
  12765.      */
  12766.     extend : function(expectedNumberOfNonCommentArgs) {
  12767.       F.prototype = this;
  12768.       var subtype = new F;
  12769.       return expectedNumberOfNonCommentArgs && subtype.mixIn(expectedNumberOfNonCommentArgs), subtype.hasOwnProperty("init") || (subtype.init = function() {
  12770.         subtype.$super.init.apply(this, arguments);
  12771.       }), subtype.init.prototype = subtype, subtype.$super = this, subtype;
  12772.     },
  12773.     /**
  12774.      * @return {?}
  12775.      */
  12776.     create : function() {
  12777.       var recurring = this.extend();
  12778.       return recurring.init.apply(recurring, arguments), recurring;
  12779.     },
  12780.     /**
  12781.      * @return {undefined}
  12782.      */
  12783.     init : function() {
  12784.     },
  12785.     /**
  12786.      * @param {Object} properties
  12787.      * @return {undefined}
  12788.      */
  12789.     mixIn : function(properties) {
  12790.       var entry;
  12791.       for (entry in properties) {
  12792.         if (properties.hasOwnProperty(entry)) {
  12793.           this[entry] = properties[entry];
  12794.         }
  12795.       }
  12796.       if (properties.hasOwnProperty("toString")) {
  12797.         this.toString = properties.toString;
  12798.       }
  12799.     },
  12800.     /**
  12801.      * @return {?}
  12802.      */
  12803.     clone : function() {
  12804.       return this.init.prototype.extend(this);
  12805.     }
  12806.   };
  12807.   var nodes = C_lib.WordArray = Base.extend({
  12808.     /**
  12809.      * @param {Array} words
  12810.      * @param {number} c
  12811.      * @return {undefined}
  12812.      */
  12813.     init : function(words, c) {
  12814.       words = this.words = words || [];
  12815.       this.sigBytes = c != className ? c : 4 * words.length;
  12816.     },
  12817.     /**
  12818.      * @param {number} type
  12819.      * @return {?}
  12820.      */
  12821.     toString : function(type) {
  12822.       return(type || fx).stringify(this);
  12823.     },
  12824.     /**
  12825.      * @param {number} data
  12826.      * @return {?}
  12827.      */
  12828.     concat : function(data) {
  12829.       var recurring = this.words;
  12830.       var pending = data.words;
  12831.       var inner = this.sigBytes;
  12832.       var arr;
  12833.       if (data = data.sigBytes, this.clamp(), inner % 4) {
  12834.         /** @type {number} */
  12835.         arr = 0;
  12836.         for (;arr < data;arr++) {
  12837.           recurring[inner + arr >>> 2] |= (pending[arr >>> 2] >>> 24 - 8 * (arr % 4) & 255) << 24 - 8 * ((inner + arr) % 4);
  12838.         }
  12839.       } else {
  12840.         if (65535 < pending.length) {
  12841.           /** @type {number} */
  12842.           arr = 0;
  12843.           for (;arr < data;arr += 4) {
  12844.             recurring[inner + arr >>> 2] = pending[arr >>> 2];
  12845.           }
  12846.         } else {
  12847.           recurring.push.apply(recurring, pending);
  12848.         }
  12849.       }
  12850.       return this.sigBytes += data, this;
  12851.     },
  12852.     /**
  12853.      * @return {undefined}
  12854.      */
  12855.     clamp : function() {
  12856.       var words = this.words;
  12857.       var sigBytes = this.sigBytes;
  12858.       words[sigBytes >>> 2] &= 4294967295 << 32 - 8 * (sigBytes % 4);
  12859.       /** @type {number} */
  12860.       words.length = Math.ceil(sigBytes / 4);
  12861.     },
  12862.     /**
  12863.      * @return {?}
  12864.      */
  12865.     clone : function() {
  12866.       var sentence = Base.clone.call(this);
  12867.       return sentence.words = this.words.slice(0), sentence;
  12868.     },
  12869.     /**
  12870.      * @param {number} key
  12871.      * @return {?}
  12872.      */
  12873.     random : function(key) {
  12874.       /** @type {Array} */
  12875.       var expr = [];
  12876.       /** @type {number} */
  12877.       var leftKey = 0;
  12878.       for (;leftKey < key;leftKey += 4) {
  12879.         expr.push(4294967296 * Math.random() | 0);
  12880.       }
  12881.       return new nodes.init(expr, key);
  12882.     }
  12883.   });
  12884.   var C_enc = C.enc = {};
  12885.   var fx = C_enc.Hex = {
  12886.     /**
  12887.      * @param {number} wordArray
  12888.      * @return {?}
  12889.      */
  12890.     stringify : function(wordArray) {
  12891.       var words = wordArray.words;
  12892.       var tagNameArr;
  12893.       var i;
  12894.       var bite;
  12895.       wordArray = wordArray.sigBytes;
  12896.       /** @type {Array} */
  12897.       tagNameArr = [];
  12898.       /** @type {number} */
  12899.       i = 0;
  12900.       for (;i < wordArray;i++) {
  12901.         /** @type {number} */
  12902.         bite = words[i >>> 2] >>> 24 - 8 * (i % 4) & 255;
  12903.         tagNameArr.push((bite >>> 4).toString(16));
  12904.         tagNameArr.push((bite & 15).toString(16));
  12905.       }
  12906.       return tagNameArr.join("");
  12907.     },
  12908.     /**
  12909.      * @param {string} values
  12910.      * @return {?}
  12911.      */
  12912.     parse : function(values) {
  12913.       var valuesLen = values.length;
  12914.       /** @type {Array} */
  12915.       var selector = [];
  12916.       /** @type {number} */
  12917.       var i = 0;
  12918.       for (;i < valuesLen;i += 2) {
  12919.         selector[i >>> 3] |= parseInt(values.substr(i, 2), 16) << 24 - 4 * (i % 8);
  12920.       }
  12921.       return new nodes.init(selector, valuesLen / 2);
  12922.     }
  12923.   };
  12924.   var Latin1 = C_enc.Latin1 = {
  12925.     /**
  12926.      * @param {number} wordArray
  12927.      * @return {?}
  12928.      */
  12929.     stringify : function(wordArray) {
  12930.       var words = wordArray.words;
  12931.       var tagNameArr;
  12932.       var i;
  12933.       wordArray = wordArray.sigBytes;
  12934.       /** @type {Array} */
  12935.       tagNameArr = [];
  12936.       /** @type {number} */
  12937.       i = 0;
  12938.       for (;i < wordArray;i++) {
  12939.         tagNameArr.push(String.fromCharCode(words[i >>> 2] >>> 24 - 8 * (i % 4) & 255));
  12940.       }
  12941.       return tagNameArr.join("");
  12942.     },
  12943.     /**
  12944.      * @param {string} number
  12945.      * @return {?}
  12946.      */
  12947.     parse : function(number) {
  12948.       var n = number.length;
  12949.       /** @type {Array} */
  12950.       var selector = [];
  12951.       /** @type {number} */
  12952.       var i = 0;
  12953.       for (;i < n;i++) {
  12954.         selector[i >>> 2] |= (number.charCodeAt(i) & 255) << 24 - 8 * (i % 4);
  12955.       }
  12956.       return new nodes.init(selector, n);
  12957.     }
  12958.   };
  12959.   var fmt = C_enc.Utf8 = {
  12960.     /**
  12961.      * @param {number} wordArray
  12962.      * @return {?}
  12963.      */
  12964.     stringify : function(wordArray) {
  12965.       try {
  12966.         return decodeURIComponent(escape(Latin1.stringify(wordArray)));
  12967.       } catch (t) {
  12968.         throw Error("Malformed UTF-8 data");
  12969.       }
  12970.     },
  12971.     /**
  12972.      * @param {(Node|string)} text
  12973.      * @return {?}
  12974.      */
  12975.     parse : function(text) {
  12976.       return Latin1.parse(unescape(encodeURIComponent(text)));
  12977.     }
  12978.   };
  12979.   var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
  12980.     /**
  12981.      * @return {undefined}
  12982.      */
  12983.     reset : function() {
  12984.       this._data = new nodes.init;
  12985.       /** @type {number} */
  12986.       this._nDataBytes = 0;
  12987.     },
  12988.     /**
  12989.      * @param {string} data
  12990.      * @return {undefined}
  12991.      */
  12992.     _append : function(data) {
  12993.       if ("string" == typeof data) {
  12994.         data = fmt.parse(data);
  12995.       }
  12996.       this._data.concat(data);
  12997.       this._nDataBytes += data.sigBytes;
  12998.     },
  12999.     /**
  13000.      * @param {number} index
  13001.      * @return {?}
  13002.      */
  13003.     _process : function(index) {
  13004.       var data = this._data;
  13005.       var dataWords = data.words;
  13006.       var n = data.sigBytes;
  13007.       var c = this.blockSize;
  13008.       /** @type {number} */
  13009.       var value = n / (4 * c);
  13010.       /** @type {number} */
  13011.       value = index ? Math.ceil(value) : Math.max((value | 0) - this._minBufferSize, 0);
  13012.       var selector;
  13013.       if (index = value * c, n = Math.min(4 * index, n), index) {
  13014.         /** @type {number} */
  13015.         selector = 0;
  13016.         for (;selector < index;selector += c) {
  13017.           this._doProcessBlock(dataWords, selector);
  13018.         }
  13019.         selector = dataWords.splice(0, index);
  13020.         data.sigBytes -= n;
  13021.       }
  13022.       return new nodes.init(selector, n);
  13023.     },
  13024.     /**
  13025.      * @return {?}
  13026.      */
  13027.     clone : function() {
  13028.       var e = Base.clone.call(this);
  13029.       return e._data = this._data.clone(), e;
  13030.     },
  13031.     _minBufferSize : 0
  13032.   });
  13033.   var C_algo;
  13034.   return C_lib.Hasher = BufferedBlockAlgorithm.extend({
  13035.     cfg : Base.extend(),
  13036.     /**
  13037.      * @param {?} cfg
  13038.      * @return {undefined}
  13039.      */
  13040.     init : function(cfg) {
  13041.       this.cfg = this.cfg.extend(cfg);
  13042.       this.reset();
  13043.     },
  13044.     /**
  13045.      * @return {undefined}
  13046.      */
  13047.     reset : function() {
  13048.       BufferedBlockAlgorithm.reset.call(this);
  13049.       this._doReset();
  13050.     },
  13051.     /**
  13052.      * @param {string} messageUpdate
  13053.      * @return {?}
  13054.      */
  13055.     update : function(messageUpdate) {
  13056.       return this._append(messageUpdate), this._process(), this;
  13057.     },
  13058.     /**
  13059.      * @param {(number|string)} messageUpdate
  13060.      * @return {?}
  13061.      */
  13062.     finalize : function(messageUpdate) {
  13063.       return messageUpdate && this._append(messageUpdate), this._doFinalize();
  13064.     },
  13065.     blockSize : 16,
  13066.     /**
  13067.      * @param {Object} hasher
  13068.      * @return {?}
  13069.      */
  13070.     _createHelper : function(hasher) {
  13071.       return function(messageUpdate, cfg) {
  13072.         return(new hasher.init(cfg)).finalize(messageUpdate);
  13073.       };
  13074.     },
  13075.     /**
  13076.      * @param {Array} hasher
  13077.      * @return {?}
  13078.      */
  13079.     _createHmacHelper : function(hasher) {
  13080.       return function(messageUpdate, key) {
  13081.         return(new C_algo.HMAC.init(hasher, key)).finalize(messageUpdate);
  13082.       };
  13083.     }
  13084.   }), C_algo = C.algo = {}, C;
  13085. }(Math);
  13086. (function(Math) {
  13087.   /**
  13088.    * @param {number} a
  13089.    * @param {?} b
  13090.    * @param {?} c
  13091.    * @param {?} d
  13092.    * @param {?} item
  13093.    * @param {number} opt_attributes
  13094.    * @param {?} s
  13095.    * @return {?}
  13096.    */
  13097.   function md5_hh(a, b, c, d, item, opt_attributes, s) {
  13098.     return a = a + (b & c | ~b & d) + item + s, (a << opt_attributes | a >>> 32 - opt_attributes) + b;
  13099.   }
  13100.   /**
  13101.    * @param {number} a
  13102.    * @param {?} b
  13103.    * @param {?} c
  13104.    * @param {?} d
  13105.    * @param {?} item
  13106.    * @param {number} opt_attributes
  13107.    * @param {?} s
  13108.    * @return {?}
  13109.    */
  13110.   function md5_gg(a, b, c, d, item, opt_attributes, s) {
  13111.     return a = a + (b & d | c & ~d) + item + s, (a << opt_attributes | a >>> 32 - opt_attributes) + b;
  13112.   }
  13113.   /**
  13114.    * @param {number} a
  13115.    * @param {?} b
  13116.    * @param {?} c
  13117.    * @param {?} d
  13118.    * @param {?} item
  13119.    * @param {number} opt_attributes
  13120.    * @param {?} s
  13121.    * @return {?}
  13122.    */
  13123.   function md5_ii(a, b, c, d, item, opt_attributes, s) {
  13124.     return a = a + (b ^ c ^ d) + item + s, (a << opt_attributes | a >>> 32 - opt_attributes) + b;
  13125.   }
  13126.   /**
  13127.    * @param {number} a
  13128.    * @param {number} b
  13129.    * @param {?} c
  13130.    * @param {?} d
  13131.    * @param {?} item
  13132.    * @param {number} opt_attributes
  13133.    * @param {?} s
  13134.    * @return {?}
  13135.    */
  13136.   function md5_ff(a, b, c, d, item, opt_attributes, s) {
  13137.     return a = a + (c ^ (b | ~d)) + item + s, (a << opt_attributes | a >>> 32 - opt_attributes) + b;
  13138.   }
  13139.   var C = CryptoJS;
  13140.   var C_lib = C.lib;
  13141.   var WordArray = C_lib.WordArray;
  13142.   var Hasher = C_lib.Hasher;
  13143.   C_lib = C.algo;
  13144.   /** @type {Array} */
  13145.   var oSpace = [];
  13146.   /** @type {number} */
  13147.   var n = 0;
  13148.   for (;64 > n;n++) {
  13149.     /** @type {number} */
  13150.     oSpace[n] = 4294967296 * Math.abs(Math.sin(n + 1)) | 0;
  13151.   }
  13152.   C_lib = C_lib.MD5 = Hasher.extend({
  13153.     /**
  13154.      * @return {undefined}
  13155.      */
  13156.     _doReset : function() {
  13157.       this._hash = new WordArray.init([1732584193, 4023233417, 2562383102, 271733878]);
  13158.     },
  13159.     /**
  13160.      * @param {?} match
  13161.      * @param {number} x
  13162.      * @return {undefined}
  13163.      */
  13164.     _doProcessBlock : function(match, x) {
  13165.       var key;
  13166.       var val;
  13167.       /** @type {number} */
  13168.       var H = 0;
  13169.       for (;16 > H;H++) {
  13170.         key = x + H;
  13171.         val = match[key];
  13172.         /** @type {number} */
  13173.         match[key] = (val << 8 | val >>> 24) & 16711935 | (val << 24 | val >>> 8) & 4278255360;
  13174.       }
  13175.       H = this._hash.words;
  13176.       key = match[x + 0];
  13177.       val = match[x + 1];
  13178.       var token = match[x + 2];
  13179.       var string = match[x + 3];
  13180.       var expr = match[x + 4];
  13181.       var datum = match[x + 5];
  13182.       var compareFn = match[x + 6];
  13183.       var relativeToItem = match[x + 7];
  13184.       var activeItem = match[x + 8];
  13185.       var args = match[x + 9];
  13186.       var propName = match[x + 10];
  13187.       var iterator = match[x + 11];
  13188.       var oldItem = match[x + 12];
  13189.       var className = match[x + 13];
  13190.       var from = match[x + 14];
  13191.       var result = match[x + 15];
  13192.       var a = H[0];
  13193.       var b = H[1];
  13194.       var c = H[2];
  13195.       var d = H[3];
  13196.       a = md5_hh(a, b, c, d, key, 7, oSpace[0]);
  13197.       d = md5_hh(d, a, b, c, val, 12, oSpace[1]);
  13198.       c = md5_hh(c, d, a, b, token, 17, oSpace[2]);
  13199.       b = md5_hh(b, c, d, a, string, 22, oSpace[3]);
  13200.       a = md5_hh(a, b, c, d, expr, 7, oSpace[4]);
  13201.       d = md5_hh(d, a, b, c, datum, 12, oSpace[5]);
  13202.       c = md5_hh(c, d, a, b, compareFn, 17, oSpace[6]);
  13203.       b = md5_hh(b, c, d, a, relativeToItem, 22, oSpace[7]);
  13204.       a = md5_hh(a, b, c, d, activeItem, 7, oSpace[8]);
  13205.       d = md5_hh(d, a, b, c, args, 12, oSpace[9]);
  13206.       c = md5_hh(c, d, a, b, propName, 17, oSpace[10]);
  13207.       b = md5_hh(b, c, d, a, iterator, 22, oSpace[11]);
  13208.       a = md5_hh(a, b, c, d, oldItem, 7, oSpace[12]);
  13209.       d = md5_hh(d, a, b, c, className, 12, oSpace[13]);
  13210.       c = md5_hh(c, d, a, b, from, 17, oSpace[14]);
  13211.       b = md5_hh(b, c, d, a, result, 22, oSpace[15]);
  13212.       a = md5_gg(a, b, c, d, val, 5, oSpace[16]);
  13213.       d = md5_gg(d, a, b, c, compareFn, 9, oSpace[17]);
  13214.       c = md5_gg(c, d, a, b, iterator, 14, oSpace[18]);
  13215.       b = md5_gg(b, c, d, a, key, 20, oSpace[19]);
  13216.       a = md5_gg(a, b, c, d, datum, 5, oSpace[20]);
  13217.       d = md5_gg(d, a, b, c, propName, 9, oSpace[21]);
  13218.       c = md5_gg(c, d, a, b, result, 14, oSpace[22]);
  13219.       b = md5_gg(b, c, d, a, expr, 20, oSpace[23]);
  13220.       a = md5_gg(a, b, c, d, args, 5, oSpace[24]);
  13221.       d = md5_gg(d, a, b, c, from, 9, oSpace[25]);
  13222.       c = md5_gg(c, d, a, b, string, 14, oSpace[26]);
  13223.       b = md5_gg(b, c, d, a, activeItem, 20, oSpace[27]);
  13224.       a = md5_gg(a, b, c, d, className, 5, oSpace[28]);
  13225.       d = md5_gg(d, a, b, c, token, 9, oSpace[29]);
  13226.       c = md5_gg(c, d, a, b, relativeToItem, 14, oSpace[30]);
  13227.       b = md5_gg(b, c, d, a, oldItem, 20, oSpace[31]);
  13228.       a = md5_ii(a, b, c, d, datum, 4, oSpace[32]);
  13229.       d = md5_ii(d, a, b, c, activeItem, 11, oSpace[33]);
  13230.       c = md5_ii(c, d, a, b, iterator, 16, oSpace[34]);
  13231.       b = md5_ii(b, c, d, a, from, 23, oSpace[35]);
  13232.       a = md5_ii(a, b, c, d, val, 4, oSpace[36]);
  13233.       d = md5_ii(d, a, b, c, expr, 11, oSpace[37]);
  13234.       c = md5_ii(c, d, a, b, relativeToItem, 16, oSpace[38]);
  13235.       b = md5_ii(b, c, d, a, propName, 23, oSpace[39]);
  13236.       a = md5_ii(a, b, c, d, className, 4, oSpace[40]);
  13237.       d = md5_ii(d, a, b, c, key, 11, oSpace[41]);
  13238.       c = md5_ii(c, d, a, b, string, 16, oSpace[42]);
  13239.       b = md5_ii(b, c, d, a, compareFn, 23, oSpace[43]);
  13240.       a = md5_ii(a, b, c, d, args, 4, oSpace[44]);
  13241.       d = md5_ii(d, a, b, c, oldItem, 11, oSpace[45]);
  13242.       c = md5_ii(c, d, a, b, result, 16, oSpace[46]);
  13243.       b = md5_ii(b, c, d, a, token, 23, oSpace[47]);
  13244.       a = md5_ff(a, b, c, d, key, 6, oSpace[48]);
  13245.       d = md5_ff(d, a, b, c, relativeToItem, 10, oSpace[49]);
  13246.       c = md5_ff(c, d, a, b, from, 15, oSpace[50]);
  13247.       b = md5_ff(b, c, d, a, datum, 21, oSpace[51]);
  13248.       a = md5_ff(a, b, c, d, oldItem, 6, oSpace[52]);
  13249.       d = md5_ff(d, a, b, c, string, 10, oSpace[53]);
  13250.       c = md5_ff(c, d, a, b, propName, 15, oSpace[54]);
  13251.       b = md5_ff(b, c, d, a, val, 21, oSpace[55]);
  13252.       a = md5_ff(a, b, c, d, activeItem, 6, oSpace[56]);
  13253.       d = md5_ff(d, a, b, c, result, 10, oSpace[57]);
  13254.       c = md5_ff(c, d, a, b, compareFn, 15, oSpace[58]);
  13255.       b = md5_ff(b, c, d, a, className, 21, oSpace[59]);
  13256.       a = md5_ff(a, b, c, d, expr, 6, oSpace[60]);
  13257.       d = md5_ff(d, a, b, c, iterator, 10, oSpace[61]);
  13258.       c = md5_ff(c, d, a, b, token, 15, oSpace[62]);
  13259.       b = md5_ff(b, c, d, a, args, 21, oSpace[63]);
  13260.       /** @type {number} */
  13261.       H[0] = H[0] + a | 0;
  13262.       /** @type {number} */
  13263.       H[1] = H[1] + b | 0;
  13264.       /** @type {number} */
  13265.       H[2] = H[2] + c | 0;
  13266.       /** @type {number} */
  13267.       H[3] = H[3] + d | 0;
  13268.     },
  13269.     /**
  13270.      * @return {?}
  13271.      */
  13272.     _doFinalize : function() {
  13273.       var data = this._data;
  13274.       var target = data.words;
  13275.       /** @type {number} */
  13276.       var t = 8 * this._nDataBytes;
  13277.       /** @type {number} */
  13278.       var src = 8 * data.sigBytes;
  13279.       var w;
  13280.       target[src >>> 5] |= 128 << 24 - src % 32;
  13281.       /** @type {number} */
  13282.       w = Math.floor(t / 4294967296);
  13283.       /** @type {number} */
  13284.       target[(src + 64 >>> 9 << 4) + 15] = (w << 8 | w >>> 24) & 16711935 | (w << 24 | w >>> 8) & 4278255360;
  13285.       /** @type {number} */
  13286.       target[(src + 64 >>> 9 << 4) + 14] = (t << 8 | t >>> 24) & 16711935 | (t << 24 | t >>> 8) & 4278255360;
  13287.       /** @type {number} */
  13288.       data.sigBytes = 4 * (target.length + 1);
  13289.       this._process();
  13290.       data = this._hash;
  13291.       target = data.words;
  13292.       /** @type {number} */
  13293.       t = 0;
  13294.       for (;4 > t;t++) {
  13295.         src = target[t];
  13296.         /** @type {number} */
  13297.         target[t] = (src << 8 | src >>> 24) & 16711935 | (src << 24 | src >>> 8) & 4278255360;
  13298.       }
  13299.       return data;
  13300.     },
  13301.     /**
  13302.      * @return {?}
  13303.      */
  13304.     clone : function() {
  13305.       var hoverKeys = Hasher.clone.call(this);
  13306.       return hoverKeys._hash = this._hash.clone(), hoverKeys;
  13307.     }
  13308.   });
  13309.   C.MD5 = Hasher._createHelper(C_lib);
  13310.   C.HmacMD5 = Hasher._createHmacHelper(C_lib);
  13311. })(Math);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!