{"version":3,"sources":["vendor.js","jquery-3.5.0.js"],"names":["_typeof","obj","Symbol","iterator","constructor","prototype","global","factory","module","exports","document","w","Error","window","noGlobal","arr","getProto","Object","getPrototypeOf","slice","flat","array","call","concat","apply","push","indexOf","class2type","toString","hasOwn","hasOwnProperty","fnToString","ObjectFunctionString","support","isFunction","nodeType","isWindow","preservedScriptAttributes","type","src","nonce","noModule","DOMEval","code","node","doc","i","val","script","createElement","text","getAttribute","setAttribute","head","appendChild","parentNode","removeChild","toType","version","jQuery","selector","context","fn","init","isArrayLike","length","jquery","toArray","this","get","num","pushStack","elems","ret","merge","prevObject","each","callback","map","elem","arguments","first","eq","last","even","grep","_elem","odd","len","j","end","sort","splice","extend","options","name","copy","copyIsArray","clone","target","deep","isPlainObject","Array","isArray","undefined","expando","Math","random","replace","isReady","error","msg","noop","proto","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","second","invert","matches","callbackExpect","arg","value","guid","split","_i","toLowerCase","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","Date","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","a","b","pop","pushNative","list","booleans","whitespace","identifier","attributes","pseudos","rwhitespace","RegExp","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","ID","CLASS","TAG","ATTR","PSEUDO","CHILD","bool","needsContext","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","inDisabledFieldset","addCombinator","disabled","nodeName","dir","next","childNodes","e","els","seed","m","nid","match","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","test","testContext","scope","toSelector","join","querySelectorAll","qsaError","removeAttribute","keys","cache","key","cacheLength","shift","markFunction","assert","el","addHandle","attrs","handler","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","documentElement","hasCompare","subWindow","defaultView","top","addEventListener","attachEvent","className","createComment","getById","getElementsByName","filter","attrId","find","getAttributeNode","tag","tmp","input","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","unshift","expr","elements","attr","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","result","what","_argument","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","start","parent","useCache","lastChild","uniqueID","pseudo","args","setFilters","idx","matched","not","matcher","unmatched","has","lang","elemLang","hash","location","root","focus","activeElement","hasFocus","href","tabIndex","enabled","checked","selected","selectedIndex","empty","header","button","_matchIndexes","lt","gt","radio","checkbox","file","password","image","submit","reset","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","token","compiled","_name","defaultValue","unique","isXMLDoc","escapeSelector","until","truncate","is","siblings","n","rneedsContext","rsingleTag","winnow","qualifier","self","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","prev","sibling","targets","l","closest","index","prevAll","add","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","content","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","reject","noValue","method","promise","fail","then","Callbacks","object","_","flag","createOptions","firing","memory","fired","locked","queue","firingIndex","fire","once","stopOnFalse","remove","disable","lock","fireWith","Deferred","func","tuples","state","always","deferred","catch","pipe","fns","newDefer","tuple","returned","progress","notify","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","TypeError","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","setTimeout","stateString","when","singleValue","remaining","resolveContexts","resolveValues","master","updateFunc","rerrorNames","stack","console","warn","message","readyException","readyList","completed","removeEventListener","readyWait","wait","readyState","doScroll","access","chainable","emptyGet","raw","bulk","_key","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","toUpperCase","camelCase","string","acceptData","owner","Data","uid","create","defineProperty","configurable","set","data","prop","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","JSON","parse","getData","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","stop","setter","clearQueue","count","defer","pnum","source","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","style","display","css","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","body","showHide","show","values","hide","toggle","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","cloneNode","noCloneChecked","option","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","caption","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","createTextNode","rkeyEvent","rmouseEvent","rtypenamespace","returnTrue","returnFalse","expectSync","err","safeActiveElement","on","types","one","origFn","event","off","leverageNative","notAsync","saved","isTrigger","delegateType","stopPropagation","stopImmediatePropagation","preventDefault","trigger","Event","handleObjIn","eventHandle","events","t","handleObj","handlers","namespaces","origType","elemData","handle","triggered","dispatch","bindType","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","matchedHandlers","matchedSelectors","addProp","hook","enumerable","originalEvent","writable","load","noBubble","click","beforeunload","returnValue","props","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","now","isSimulated","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","char","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","html","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","rnumnonpx","getStyles","opener","getComputedStyle","swap","old","rboxStyle","curCSS","computed","width","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","marginLeft","right","pixelBoxStylesVal","boxSizingReliableVal","position","scrollboxSizeVal","offsetWidth","measure","round","parseFloat","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","table","trChild","trStyle","height","parseInt","cssPrefixes","emptyStyle","vendorProps","finalPropName","final","cssProps","capName","vendorPropName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","max","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","ceil","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","gridArea","gridColumn","gridColumnEnd","gridColumnStart","gridRow","gridRowEnd","gridRowStart","lineHeight","order","orphans","widows","zIndex","zoom","origName","isCustomProp","setProperty","isFinite","getBoundingClientRect","scrollboxSizeBuggy","left","margin","padding","border","prefix","suffix","expand","expanded","parts","propHooks","run","percent","eased","duration","pos","step","fx","scrollTop","scrollLeft","linear","p","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","interval","tick","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","opts","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","bind","complete","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","attrNames","getter","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","for","class","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","isValidValue","classNames","hasClass","rreturn","valHooks","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","param","s","valueOrFunction","encodeURIComponent","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","url","isLocal","protocol","processData","async","contentType","accepts","json","responseFields","converters","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","setRequestHeader","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","beforeSend","success","send","nativeStatusText","responses","isSuccess","response","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","current","conv","dataFilter","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","offsetHeight","xhr","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","open","username","xhrFields","onload","onerror","onabort","ontimeout","onreadystatechange","responseType","responseText","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","params","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","trim","define","amd","_jQuery","_$","$","noConflict"],"mappings":"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","file":"vendor.min.js","sourcesContent":["\"use strict\";function _typeof(obj) {\"@babel/helpers - typeof\";if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {_typeof = function _typeof(obj) {return typeof obj;};} else {_typeof = function _typeof(obj) {return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;};}return _typeof(obj);} /*!\n * jQuery JavaScript Library v3.5.0\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2020-04-10T15:07Z\n */\n(function (global, factory) {\n\n  \"use strict\";\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && _typeof(module.exports) === \"object\") {\n\n    // For CommonJS and CommonJS-like environments where a proper `window`\n    // is present, execute the factory and get jQuery.\n    // For environments that do not have a `window` with a `document`\n    // (such as Node.js), expose a factory as module.exports.\n    // This accentuates the need for the creation of a real `window`.\n    // e.g. var jQuery = require(\"jquery\")(window);\n    // See ticket #14549 for more info.\n    module.exports = global.document ?\n    factory(global, true) :\n    function (w) {\n      if (!w.document) {\n        throw new Error(\"jQuery requires a window with a document\");\n      }\n      return factory(w);\n    };\n  } else {\n    factory(global);\n  }\n\n  // Pass this if window is not defined yet\n})(typeof window !== \"undefined\" ? window : void 0, function (window, noGlobal) {\n\n  // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n  // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n  // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n  // enough that all such attempts are guarded in a try block.\n  \"use strict\";\n\n  var arr = [];\n\n  var getProto = Object.getPrototypeOf;\n\n  var _slice = arr.slice;\n\n  var flat = arr.flat ? function (array) {\n    return arr.flat.call(array);\n  } : function (array) {\n    return arr.concat.apply([], array);\n  };\n\n\n  var push = arr.push;\n\n  var indexOf = arr.indexOf;\n\n  var class2type = {};\n\n  var toString = class2type.toString;\n\n  var hasOwn = class2type.hasOwnProperty;\n\n  var fnToString = hasOwn.toString;\n\n  var ObjectFunctionString = fnToString.call(Object);\n\n  var support = {};\n\n  var isFunction = function isFunction(obj) {\n\n    // Support: Chrome <=57, Firefox <=52\n    // In some browsers, typeof returns \"function\" for HTML <object> elements\n    // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n    // We don't want to classify *any* DOM node as a function.\n    return typeof obj === \"function\" && typeof obj.nodeType !== \"number\";\n  };\n\n\n  var isWindow = function isWindow(obj) {\n    return obj != null && obj === obj.window;\n  };\n\n\n  var document = window.document;\n\n\n\n  var preservedScriptAttributes = {\n    type: true,\n    src: true,\n    nonce: true,\n    noModule: true };\n\n\n  function DOMEval(code, node, doc) {\n    doc = doc || document;\n\n    var i,val,\n    script = doc.createElement(\"script\");\n\n    script.text = code;\n    if (node) {\n      for (i in preservedScriptAttributes) {\n\n        // Support: Firefox 64+, Edge 18+\n        // Some browsers don't support the \"nonce\" property on scripts.\n        // On the other hand, just using `getAttribute` is not enough as\n        // the `nonce` attribute is reset to an empty string whenever it\n        // becomes browsing-context connected.\n        // See https://github.com/whatwg/html/issues/2369\n        // See https://html.spec.whatwg.org/#nonce-attributes\n        // The `node.getAttribute` check was added for the sake of\n        // `jQuery.globalEval` so that it can fake a nonce-containing node\n        // via an object.\n        val = node[i] || node.getAttribute && node.getAttribute(i);\n        if (val) {\n          script.setAttribute(i, val);\n        }\n      }\n    }\n    doc.head.appendChild(script).parentNode.removeChild(script);\n  }\n\n\n  function toType(obj) {\n    if (obj == null) {\n      return obj + \"\";\n    }\n\n    // Support: Android <=2.3 only (functionish RegExp)\n    return _typeof(obj) === \"object\" || typeof obj === \"function\" ?\n    class2type[toString.call(obj)] || \"object\" : _typeof(\n    obj);\n  }\n  /* global Symbol */\n  // Defining this global in .eslintrc.json would create a danger of using the global\n  // unguarded in another place, it seems safer to define global only for this module\n\n\n\n  var\n  version = \"3.5.0\",\n\n  // Define a local copy of jQuery\n  jQuery = function jQuery(selector, context) {\n\n    // The jQuery object is actually just the init constructor 'enhanced'\n    // Need init if jQuery is called (just allow error to be thrown if not included)\n    return new jQuery.fn.init(selector, context);\n  };\n\n  jQuery.fn = jQuery.prototype = {\n\n    // The current version of jQuery being used\n    jquery: version,\n\n    constructor: jQuery,\n\n    // The default length of a jQuery object is 0\n    length: 0,\n\n    toArray: function toArray() {\n      return _slice.call(this);\n    },\n\n    // Get the Nth element in the matched element set OR\n    // Get the whole matched element set as a clean array\n    get: function get(num) {\n\n      // Return all the elements in a clean array\n      if (num == null) {\n        return _slice.call(this);\n      }\n\n      // Return just the one element from the set\n      return num < 0 ? this[num + this.length] : this[num];\n    },\n\n    // Take an array of elements and push it onto the stack\n    // (returning the new matched element set)\n    pushStack: function pushStack(elems) {\n\n      // Build a new jQuery matched element set\n      var ret = jQuery.merge(this.constructor(), elems);\n\n      // Add the old object onto the stack (as a reference)\n      ret.prevObject = this;\n\n      // Return the newly-formed element set\n      return ret;\n    },\n\n    // Execute a callback for every element in the matched set.\n    each: function each(callback) {\n      return jQuery.each(this, callback);\n    },\n\n    map: function map(callback) {\n      return this.pushStack(jQuery.map(this, function (elem, i) {\n        return callback.call(elem, i, elem);\n      }));\n    },\n\n    slice: function slice() {\n      return this.pushStack(_slice.apply(this, arguments));\n    },\n\n    first: function first() {\n      return this.eq(0);\n    },\n\n    last: function last() {\n      return this.eq(-1);\n    },\n\n    even: function even() {\n      return this.pushStack(jQuery.grep(this, function (_elem, i) {\n        return (i + 1) % 2;\n      }));\n    },\n\n    odd: function odd() {\n      return this.pushStack(jQuery.grep(this, function (_elem, i) {\n        return i % 2;\n      }));\n    },\n\n    eq: function eq(i) {\n      var len = this.length,\n      j = +i + (i < 0 ? len : 0);\n      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);\n    },\n\n    end: function end() {\n      return this.prevObject || this.constructor();\n    },\n\n    // For internal use only.\n    // Behaves like an Array's method, not like a jQuery method.\n    push: push,\n    sort: arr.sort,\n    splice: arr.splice };\n\n\n  jQuery.extend = jQuery.fn.extend = function () {\n    var options,name,src,copy,copyIsArray,clone,\n    target = arguments[0] || {},\n    i = 1,\n    length = arguments.length,\n    deep = false;\n\n    // Handle a deep copy situation\n    if (typeof target === \"boolean\") {\n      deep = target;\n\n      // Skip the boolean and the target\n      target = arguments[i] || {};\n      i++;\n    }\n\n    // Handle case when target is a string or something (possible in deep copy)\n    if (_typeof(target) !== \"object\" && !isFunction(target)) {\n      target = {};\n    }\n\n    // Extend jQuery itself if only one argument is passed\n    if (i === length) {\n      target = this;\n      i--;\n    }\n\n    for (; i < length; i++) {\n\n      // Only deal with non-null/undefined values\n      if ((options = arguments[i]) != null) {\n\n        // Extend the base object\n        for (name in options) {\n          copy = options[name];\n\n          // Prevent Object.prototype pollution\n          // Prevent never-ending loop\n          if (name === \"__proto__\" || target === copy) {\n            continue;\n          }\n\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (jQuery.isPlainObject(copy) || (\n          copyIsArray = Array.isArray(copy)))) {\n            src = target[name];\n\n            // Ensure proper type for the source value\n            if (copyIsArray && !Array.isArray(src)) {\n              clone = [];\n            } else if (!copyIsArray && !jQuery.isPlainObject(src)) {\n              clone = {};\n            } else {\n              clone = src;\n            }\n            copyIsArray = false;\n\n            // Never move original objects, clone them\n            target[name] = jQuery.extend(deep, clone, copy);\n\n            // Don't bring in undefined values\n          } else if (copy !== undefined) {\n            target[name] = copy;\n          }\n        }\n      }\n    }\n\n    // Return the modified object\n    return target;\n  };\n\n  jQuery.extend({\n\n    // Unique for each copy of jQuery on the page\n    expando: \"jQuery\" + (version + Math.random()).replace(/\\D/g, \"\"),\n\n    // Assume jQuery is ready without the ready module\n    isReady: true,\n\n    error: function error(msg) {\n      throw new Error(msg);\n    },\n\n    noop: function noop() {},\n\n    isPlainObject: function isPlainObject(obj) {\n      var proto, Ctor;\n\n      // Detect obvious negatives\n      // Use toString instead of jQuery.type to catch host objects\n      if (!obj || toString.call(obj) !== \"[object Object]\") {\n        return false;\n      }\n\n      proto = getProto(obj);\n\n      // Objects with no prototype (e.g., `Object.create( null )`) are plain\n      if (!proto) {\n        return true;\n      }\n\n      // Objects with prototype are plain iff they were constructed by a global Object function\n      Ctor = hasOwn.call(proto, \"constructor\") && proto.constructor;\n      return typeof Ctor === \"function\" && fnToString.call(Ctor) === ObjectFunctionString;\n    },\n\n    isEmptyObject: function isEmptyObject(obj) {\n      var name;\n\n      for (name in obj) {\n        return false;\n      }\n      return true;\n    },\n\n    // Evaluates a script in a provided context; falls back to the global one\n    // if not specified.\n    globalEval: function globalEval(code, options, doc) {\n      DOMEval(code, { nonce: options && options.nonce }, doc);\n    },\n\n    each: function each(obj, callback) {\n      var length,i = 0;\n\n      if (isArrayLike(obj)) {\n        length = obj.length;\n        for (; i < length; i++) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      } else {\n        for (i in obj) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      }\n\n      return obj;\n    },\n\n    // results is for internal usage only\n    makeArray: function makeArray(arr, results) {\n      var ret = results || [];\n\n      if (arr != null) {\n        if (isArrayLike(Object(arr))) {\n          jQuery.merge(ret,\n          typeof arr === \"string\" ?\n          [arr] : arr);\n\n        } else {\n          push.call(ret, arr);\n        }\n      }\n\n      return ret;\n    },\n\n    inArray: function inArray(elem, arr, i) {\n      return arr == null ? -1 : indexOf.call(arr, elem, i);\n    },\n\n    // Support: Android <=4.0 only, PhantomJS 1 only\n    // push.apply(_, arraylike) throws on ancient WebKit\n    merge: function merge(first, second) {\n      var len = +second.length,\n      j = 0,\n      i = first.length;\n\n      for (; j < len; j++) {\n        first[i++] = second[j];\n      }\n\n      first.length = i;\n\n      return first;\n    },\n\n    grep: function grep(elems, callback, invert) {\n      var callbackInverse,\n      matches = [],\n      i = 0,\n      length = elems.length,\n      callbackExpect = !invert;\n\n      // Go through the array, only saving the items\n      // that pass the validator function\n      for (; i < length; i++) {\n        callbackInverse = !callback(elems[i], i);\n        if (callbackInverse !== callbackExpect) {\n          matches.push(elems[i]);\n        }\n      }\n\n      return matches;\n    },\n\n    // arg is for internal usage only\n    map: function map(elems, callback, arg) {\n      var length,value,\n      i = 0,\n      ret = [];\n\n      // Go through the array, translating each of the items to their new values\n      if (isArrayLike(elems)) {\n        length = elems.length;\n        for (; i < length; i++) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        }\n\n        // Go through every key on the object,\n      } else {\n        for (i in elems) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        }\n      }\n\n      // Flatten any nested arrays\n      return flat(ret);\n    },\n\n    // A global GUID counter for objects\n    guid: 1,\n\n    // jQuery.support is not used in Core but other projects attach their\n    // properties to it so it needs to exist.\n    support: support });\n\n\n  if (typeof Symbol === \"function\") {\n    jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];\n  }\n\n  // Populate the class2type map\n  jQuery.each(\"Boolean Number String Function Array Date RegExp Object Error Symbol\".split(\" \"),\n  function (_i, name) {\n    class2type[\"[object \" + name + \"]\"] = name.toLowerCase();\n  });\n\n  function isArrayLike(obj) {\n\n    // Support: real iOS 8.2 only (not reproducible in simulator)\n    // `in` check used to prevent JIT error (gh-2145)\n    // hasOwn isn't used here due to false negatives\n    // regarding Nodelist length in IE\n    var length = !!obj && \"length\" in obj && obj.length,\n    type = toType(obj);\n\n    if (isFunction(obj) || isWindow(obj)) {\n      return false;\n    }\n\n    return type === \"array\" || length === 0 ||\n    typeof length === \"number\" && length > 0 && length - 1 in obj;\n  }\n  var Sizzle =\n  /*!\n   * Sizzle CSS Selector Engine v2.3.5\n   * https://sizzlejs.com/\n   *\n   * Copyright JS Foundation and other contributors\n   * Released under the MIT license\n   * https://js.foundation/\n   *\n   * Date: 2020-03-14\n   */\n  function (window) {\n    var i,\n    support,\n    Expr,\n    getText,\n    isXML,\n    tokenize,\n    compile,\n    select,\n    outermostContext,\n    sortInput,\n    hasDuplicate,\n\n    // Local document vars\n    setDocument,\n    document,\n    docElem,\n    documentIsHTML,\n    rbuggyQSA,\n    rbuggyMatches,\n    matches,\n    contains,\n\n    // Instance-specific data\n    expando = \"sizzle\" + 1 * new Date(),\n    preferredDoc = window.document,\n    dirruns = 0,\n    done = 0,\n    classCache = createCache(),\n    tokenCache = createCache(),\n    compilerCache = createCache(),\n    nonnativeSelectorCache = createCache(),\n    sortOrder = function sortOrder(a, b) {\n      if (a === b) {\n        hasDuplicate = true;\n      }\n      return 0;\n    },\n\n    // Instance methods\n    hasOwn = {}.hasOwnProperty,\n    arr = [],\n    pop = arr.pop,\n    pushNative = arr.push,\n    push = arr.push,\n    slice = arr.slice,\n\n    // Use a stripped-down indexOf as it's faster than native\n    // https://jsperf.com/thor-indexof-vs-for/5\n    indexOf = function indexOf(list, elem) {\n      var i = 0,\n      len = list.length;\n      for (; i < len; i++) {\n        if (list[i] === elem) {\n          return i;\n        }\n      }\n      return -1;\n    },\n\n    booleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" +\n    \"ismap|loop|multiple|open|readonly|required|scoped\",\n\n    // Regular expressions\n\n    // http://www.w3.org/TR/css3-selectors/#whitespace\n    whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n    // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n    identifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n    \"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n    // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n    attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n    // Operator (capture 2)\n    \"*([*^$|!~]?=)\" + whitespace +\n\n    // \"Attribute values must be CSS identifiers [capture 5]\n    // or strings [capture 3 or capture 4]\"\n    \"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n    whitespace + \"*\\\\]\",\n\n    pseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n    // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n    // 1. quoted (capture 3; capture 4 or capture 5)\n    \"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n    // 2. simple (capture 6)\n    \"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n    // 3. anything else (capture 2)\n    \".*\" +\n    \")\\\\)|)\",\n\n    // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n    rwhitespace = new RegExp(whitespace + \"+\", \"g\"),\n    rtrim = new RegExp(\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\n    whitespace + \"+$\", \"g\"),\n\n    rcomma = new RegExp(\"^\" + whitespace + \"*,\" + whitespace + \"*\"),\n    rcombinators = new RegExp(\"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\n    \"*\"),\n    rdescend = new RegExp(whitespace + \"|>\"),\n\n    rpseudo = new RegExp(pseudos),\n    ridentifier = new RegExp(\"^\" + identifier + \"$\"),\n\n    matchExpr = {\n      \"ID\": new RegExp(\"^#(\" + identifier + \")\"),\n      \"CLASS\": new RegExp(\"^\\\\.(\" + identifier + \")\"),\n      \"TAG\": new RegExp(\"^(\" + identifier + \"|[*])\"),\n      \"ATTR\": new RegExp(\"^\" + attributes),\n      \"PSEUDO\": new RegExp(\"^\" + pseudos),\n      \"CHILD\": new RegExp(\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n      whitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n      whitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\"),\n      \"bool\": new RegExp(\"^(?:\" + booleans + \")$\", \"i\"),\n\n      // For use in libraries implementing .is()\n      // We use this for POS matching in `select`\n      \"needsContext\": new RegExp(\"^\" + whitespace +\n      \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n      \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\") },\n\n\n    rhtml = /HTML$/i,\n    rinputs = /^(?:input|select|textarea|button)$/i,\n    rheader = /^h\\d$/i,\n\n    rnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n    // Easily-parseable/retrievable ID or TAG or CLASS selectors\n    rquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n    rsibling = /[+~]/,\n\n    // CSS escapes\n    // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n    runescape = new RegExp(\"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\"),\n    funescape = function funescape(escape, nonHex) {\n      var high = \"0x\" + escape.slice(1) - 0x10000;\n\n      return nonHex ?\n\n      // Strip the backslash prefix from a non-hex escape sequence\n      nonHex :\n\n      // Replace a hexadecimal escape sequence with the encoded Unicode code point\n      // Support: IE <=11+\n      // For values outside the Basic Multilingual Plane (BMP), manually construct a\n      // surrogate pair\n      high < 0 ?\n      String.fromCharCode(high + 0x10000) :\n      String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);\n    },\n\n    // CSS string/identifier serialization\n    // https://drafts.csswg.org/cssom/#common-serializing-idioms\n    rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n    fcssescape = function fcssescape(ch, asCodePoint) {\n      if (asCodePoint) {\n\n        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n        if (ch === \"\\0\") {\n          return \"\\uFFFD\";\n        }\n\n        // Control characters and (dependent upon position) numbers get escaped as code points\n        return ch.slice(0, -1) + \"\\\\\" +\n        ch.charCodeAt(ch.length - 1).toString(16) + \" \";\n      }\n\n      // Other potentially-special ASCII characters get backslash-escaped\n      return \"\\\\\" + ch;\n    },\n\n    // Used for iframes\n    // See setDocument()\n    // Removing the function wrapper causes a \"Permission Denied\"\n    // error in IE\n    unloadHandler = function unloadHandler() {\n      setDocument();\n    },\n\n    inDisabledFieldset = addCombinator(\n    function (elem) {\n      return elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n    },\n    { dir: \"parentNode\", next: \"legend\" });\n\n\n    // Optimize for push.apply( _, NodeList )\n    try {\n      push.apply(\n      arr = slice.call(preferredDoc.childNodes),\n      preferredDoc.childNodes);\n\n\n      // Support: Android<4.0\n      // Detect silently failing push.apply\n      // eslint-disable-next-line no-unused-expressions\n      arr[preferredDoc.childNodes.length].nodeType;\n    } catch (e) {\n      push = { apply: arr.length ?\n\n        // Leverage slice if possible\n        function (target, els) {\n          pushNative.apply(target, slice.call(els));\n        } :\n\n        // Support: IE<9\n        // Otherwise append directly\n        function (target, els) {\n          var j = target.length,\n          i = 0;\n\n          // Can't trust NodeList.length\n          while (target[j++] = els[i++]) {}\n          target.length = j - 1;\n        } };\n\n    }\n\n    function Sizzle(selector, context, results, seed) {\n      var m,i,elem,nid,match,groups,newSelector,\n      newContext = context && context.ownerDocument,\n\n      // nodeType defaults to 9, since context defaults to document\n      nodeType = context ? context.nodeType : 9;\n\n      results = results || [];\n\n      // Return early from calls with invalid selector or context\n      if (typeof selector !== \"string\" || !selector ||\n      nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {\n\n        return results;\n      }\n\n      // Try to shortcut find operations (as opposed to filters) in HTML documents\n      if (!seed) {\n        setDocument(context);\n        context = context || document;\n\n        if (documentIsHTML) {\n\n          // If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n          // (excepting DocumentFragment context, where the methods don't exist)\n          if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {\n\n            // ID selector\n            if (m = match[1]) {\n\n              // Document context\n              if (nodeType === 9) {\n                if (elem = context.getElementById(m)) {\n\n                  // Support: IE, Opera, Webkit\n                  // TODO: identify versions\n                  // getElementById can match elements by name instead of ID\n                  if (elem.id === m) {\n                    results.push(elem);\n                    return results;\n                  }\n                } else {\n                  return results;\n                }\n\n                // Element context\n              } else {\n\n                // Support: IE, Opera, Webkit\n                // TODO: identify versions\n                // getElementById can match elements by name instead of ID\n                if (newContext && (elem = newContext.getElementById(m)) &&\n                contains(context, elem) &&\n                elem.id === m) {\n\n                  results.push(elem);\n                  return results;\n                }\n              }\n\n              // Type selector\n            } else if (match[2]) {\n              push.apply(results, context.getElementsByTagName(selector));\n              return results;\n\n              // Class selector\n            } else if ((m = match[3]) && support.getElementsByClassName &&\n            context.getElementsByClassName) {\n\n              push.apply(results, context.getElementsByClassName(m));\n              return results;\n            }\n          }\n\n          // Take advantage of querySelectorAll\n          if (support.qsa &&\n          !nonnativeSelectorCache[selector + \" \"] && (\n          !rbuggyQSA || !rbuggyQSA.test(selector)) && (\n\n          // Support: IE 8 only\n          // Exclude object elements\n          nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\")) {\n\n            newSelector = selector;\n            newContext = context;\n\n            // qSA considers elements outside a scoping root when evaluating child or\n            // descendant combinators, which is not what we want.\n            // In such cases, we work around the behavior by prefixing every selector in the\n            // list with an ID selector referencing the scope context.\n            // The technique has to be used as well when a leading combinator is used\n            // as such selectors are not recognized by querySelectorAll.\n            // Thanks to Andrew Dupont for this technique.\n            if (nodeType === 1 && (\n            rdescend.test(selector) || rcombinators.test(selector))) {\n\n              // Expand context for sibling selectors\n              newContext = rsibling.test(selector) && testContext(context.parentNode) ||\n              context;\n\n              // We can use :scope instead of the ID hack if the browser\n              // supports it & if we're not changing the context.\n              if (newContext !== context || !support.scope) {\n\n                // Capture the context ID, setting it first if necessary\n                if (nid = context.getAttribute(\"id\")) {\n                  nid = nid.replace(rcssescape, fcssescape);\n                } else {\n                  context.setAttribute(\"id\", nid = expando);\n                }\n              }\n\n              // Prefix every selector in the list\n              groups = tokenize(selector);\n              i = groups.length;\n              while (i--) {\n                groups[i] = (nid ? \"#\" + nid : \":scope\") + \" \" +\n                toSelector(groups[i]);\n              }\n              newSelector = groups.join(\",\");\n            }\n\n            try {\n              push.apply(results,\n              newContext.querySelectorAll(newSelector));\n\n              return results;\n            } catch (qsaError) {\n              nonnativeSelectorCache(selector, true);\n            } finally {\n              if (nid === expando) {\n                context.removeAttribute(\"id\");\n              }\n            }\n          }\n        }\n      }\n\n      // All others\n      return select(selector.replace(rtrim, \"$1\"), context, results, seed);\n    }\n\n    /**\n     * Create key-value caches of limited size\n     * @returns {function(string, object)} Returns the Object data after storing it on itself with\n     *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n     *\tdeleting the oldest entry\n     */\n    function createCache() {\n      var keys = [];\n\n      function cache(key, value) {\n\n        // Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n        if (keys.push(key + \" \") > Expr.cacheLength) {\n\n          // Only keep the most recent entries\n          delete cache[keys.shift()];\n        }\n        return cache[key + \" \"] = value;\n      }\n      return cache;\n    }\n\n    /**\n     * Mark a function for special use by Sizzle\n     * @param {Function} fn The function to mark\n     */\n    function markFunction(fn) {\n      fn[expando] = true;\n      return fn;\n    }\n\n    /**\n     * Support testing using an element\n     * @param {Function} fn Passed the created element and returns a boolean result\n     */\n    function assert(fn) {\n      var el = document.createElement(\"fieldset\");\n\n      try {\n        return !!fn(el);\n      } catch (e) {\n        return false;\n      } finally {\n\n        // Remove from its parent by default\n        if (el.parentNode) {\n          el.parentNode.removeChild(el);\n        }\n\n        // release memory in IE\n        el = null;\n      }\n    }\n\n    /**\n     * Adds the same handler for all of the specified attrs\n     * @param {String} attrs Pipe-separated list of attributes\n     * @param {Function} handler The method that will be applied\n     */\n    function addHandle(attrs, handler) {\n      var arr = attrs.split(\"|\"),\n      i = arr.length;\n\n      while (i--) {\n        Expr.attrHandle[arr[i]] = handler;\n      }\n    }\n\n    /**\n     * Checks document order of two siblings\n     * @param {Element} a\n     * @param {Element} b\n     * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n     */\n    function siblingCheck(a, b) {\n      var cur = b && a,\n      diff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n      a.sourceIndex - b.sourceIndex;\n\n      // Use IE sourceIndex if available on both nodes\n      if (diff) {\n        return diff;\n      }\n\n      // Check if b follows a\n      if (cur) {\n        while (cur = cur.nextSibling) {\n          if (cur === b) {\n            return -1;\n          }\n        }\n      }\n\n      return a ? 1 : -1;\n    }\n\n    /**\n     * Returns a function to use in pseudos for input types\n     * @param {String} type\n     */\n    function createInputPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return name === \"input\" && elem.type === type;\n      };\n    }\n\n    /**\n     * Returns a function to use in pseudos for buttons\n     * @param {String} type\n     */\n    function createButtonPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return (name === \"input\" || name === \"button\") && elem.type === type;\n      };\n    }\n\n    /**\n     * Returns a function to use in pseudos for :enabled/:disabled\n     * @param {Boolean} disabled true for :disabled; false for :enabled\n     */\n    function createDisabledPseudo(disabled) {\n\n      // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n      return function (elem) {\n\n        // Only certain elements can match :enabled or :disabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n        if (\"form\" in elem) {\n\n          // Check for inherited disabledness on relevant non-disabled elements:\n          // * listed form-associated elements in a disabled fieldset\n          //   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n          // * option elements in a disabled optgroup\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n          // All such elements have a \"form\" property.\n          if (elem.parentNode && elem.disabled === false) {\n\n            // Option elements defer to a parent optgroup if present\n            if (\"label\" in elem) {\n              if (\"label\" in elem.parentNode) {\n                return elem.parentNode.disabled === disabled;\n              } else {\n                return elem.disabled === disabled;\n              }\n            }\n\n            // Support: IE 6 - 11\n            // Use the isDisabled shortcut property to check for disabled fieldset ancestors\n            return elem.isDisabled === disabled ||\n\n            // Where there is no isDisabled, check manually\n            /* jshint -W018 */\n            elem.isDisabled !== !disabled &&\n            inDisabledFieldset(elem) === disabled;\n          }\n\n          return elem.disabled === disabled;\n\n          // Try to winnow out elements that can't be disabled before trusting the disabled property.\n          // Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n          // even exist on them, let alone have a boolean value.\n        } else if (\"label\" in elem) {\n          return elem.disabled === disabled;\n        }\n\n        // Remaining elements are neither :enabled nor :disabled\n        return false;\n      };\n    }\n\n    /**\n     * Returns a function to use in pseudos for positionals\n     * @param {Function} fn\n     */\n    function createPositionalPseudo(fn) {\n      return markFunction(function (argument) {\n        argument = +argument;\n        return markFunction(function (seed, matches) {\n          var j,\n          matchIndexes = fn([], seed.length, argument),\n          i = matchIndexes.length;\n\n          // Match elements found at the specified indexes\n          while (i--) {\n            if (seed[j = matchIndexes[i]]) {\n              seed[j] = !(matches[j] = seed[j]);\n            }\n          }\n        });\n      });\n    }\n\n    /**\n     * Checks a node for validity as a Sizzle context\n     * @param {Element|Object=} context\n     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n     */\n    function testContext(context) {\n      return context && typeof context.getElementsByTagName !== \"undefined\" && context;\n    }\n\n    // Expose support vars for convenience\n    support = Sizzle.support = {};\n\n    /**\n     * Detects XML nodes\n     * @param {Element|Object} elem An element or a document\n     * @returns {Boolean} True iff elem is a non-HTML XML node\n     */\n    isXML = Sizzle.isXML = function (elem) {\n      var namespace = elem.namespaceURI,\n      docElem = (elem.ownerDocument || elem).documentElement;\n\n      // Support: IE <=8\n      // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n      // https://bugs.jquery.com/ticket/4833\n      return !rhtml.test(namespace || docElem && docElem.nodeName || \"HTML\");\n    };\n\n    /**\n     * Sets document-related variables once based on the current document\n     * @param {Element|Object} [doc] An element or document object to use to set the document\n     * @returns {Object} Returns the current document\n     */\n    setDocument = Sizzle.setDocument = function (node) {\n      var hasCompare,subWindow,\n      doc = node ? node.ownerDocument || node : preferredDoc;\n\n      // Return early if doc is invalid or already selected\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if (doc == document || doc.nodeType !== 9 || !doc.documentElement) {\n        return document;\n      }\n\n      // Update global variables\n      document = doc;\n      docElem = document.documentElement;\n      documentIsHTML = !isXML(document);\n\n      // Support: IE 9 - 11+, Edge 12 - 18+\n      // Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if (preferredDoc != document && (\n      subWindow = document.defaultView) && subWindow.top !== subWindow) {\n\n        // Support: IE 11, Edge\n        if (subWindow.addEventListener) {\n          subWindow.addEventListener(\"unload\", unloadHandler, false);\n\n          // Support: IE 9 - 10 only\n        } else if (subWindow.attachEvent) {\n          subWindow.attachEvent(\"onunload\", unloadHandler);\n        }\n      }\n\n      // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n      // Safari 4 - 5 only, Opera <=11.6 - 12.x only\n      // IE/Edge & older browsers don't support the :scope pseudo-class.\n      // Support: Safari 6.0 only\n      // Safari 6.0 supports :scope but it's an alias of :root there.\n      support.scope = assert(function (el) {\n        docElem.appendChild(el).appendChild(document.createElement(\"div\"));\n        return typeof el.querySelectorAll !== \"undefined\" &&\n        !el.querySelectorAll(\":scope fieldset div\").length;\n      });\n\n      /* Attributes\n      ---------------------------------------------------------------------- */\n\n      // Support: IE<8\n      // Verify that getAttribute really returns attributes and not properties\n      // (excepting IE8 booleans)\n      support.attributes = assert(function (el) {\n        el.className = \"i\";\n        return !el.getAttribute(\"className\");\n      });\n\n      /* getElement(s)By*\n      ---------------------------------------------------------------------- */\n\n      // Check if getElementsByTagName(\"*\") returns only elements\n      support.getElementsByTagName = assert(function (el) {\n        el.appendChild(document.createComment(\"\"));\n        return !el.getElementsByTagName(\"*\").length;\n      });\n\n      // Support: IE<9\n      support.getElementsByClassName = rnative.test(document.getElementsByClassName);\n\n      // Support: IE<10\n      // Check if getElementById returns elements by name\n      // The broken getElementById methods don't pick up programmatically-set names,\n      // so use a roundabout getElementsByName test\n      support.getById = assert(function (el) {\n        docElem.appendChild(el).id = expando;\n        return !document.getElementsByName || !document.getElementsByName(expando).length;\n      });\n\n      // ID filter and find\n      if (support.getById) {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            return elem.getAttribute(\"id\") === attrId;\n          };\n        };\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var elem = context.getElementById(id);\n            return elem ? [elem] : [];\n          }\n        };\n      } else {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            var node = typeof elem.getAttributeNode !== \"undefined\" &&\n            elem.getAttributeNode(\"id\");\n            return node && node.value === attrId;\n          };\n        };\n\n        // Support: IE 6 - 7 only\n        // getElementById is not reliable as a find shortcut\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var node,i,elems,\n            elem = context.getElementById(id);\n\n            if (elem) {\n\n              // Verify the id attribute\n              node = elem.getAttributeNode(\"id\");\n              if (node && node.value === id) {\n                return [elem];\n              }\n\n              // Fall back on getElementsByName\n              elems = context.getElementsByName(id);\n              i = 0;\n              while (elem = elems[i++]) {\n                node = elem.getAttributeNode(\"id\");\n                if (node && node.value === id) {\n                  return [elem];\n                }\n              }\n            }\n\n            return [];\n          }\n        };\n      }\n\n      // Tag\n      Expr.find[\"TAG\"] = support.getElementsByTagName ?\n      function (tag, context) {\n        if (typeof context.getElementsByTagName !== \"undefined\") {\n          return context.getElementsByTagName(tag);\n\n          // DocumentFragment nodes don't have gEBTN\n        } else if (support.qsa) {\n          return context.querySelectorAll(tag);\n        }\n      } :\n\n      function (tag, context) {\n        var elem,\n        tmp = [],\n        i = 0,\n\n        // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n        results = context.getElementsByTagName(tag);\n\n        // Filter out possible comments\n        if (tag === \"*\") {\n          while (elem = results[i++]) {\n            if (elem.nodeType === 1) {\n              tmp.push(elem);\n            }\n          }\n\n          return tmp;\n        }\n        return results;\n      };\n\n      // Class\n      Expr.find[\"CLASS\"] = support.getElementsByClassName && function (className, context) {\n        if (typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML) {\n          return context.getElementsByClassName(className);\n        }\n      };\n\n      /* QSA/matchesSelector\n      ---------------------------------------------------------------------- */\n\n      // QSA and matchesSelector support\n\n      // matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n      rbuggyMatches = [];\n\n      // qSa(:focus) reports false when true (Chrome 21)\n      // We allow this because of a bug in IE8/9 that throws an error\n      // whenever `document.activeElement` is accessed on an iframe\n      // So, we allow :focus to pass through QSA all the time to avoid the IE error\n      // See https://bugs.jquery.com/ticket/13378\n      rbuggyQSA = [];\n\n      if (support.qsa = rnative.test(document.querySelectorAll)) {\n\n        // Build QSA regex\n        // Regex strategy adopted from Diego Perini\n        assert(function (el) {\n\n          var input;\n\n          // Select is set to empty string on purpose\n          // This is to test IE's treatment of not explicitly\n          // setting a boolean content attribute,\n          // since its presence should be enough\n          // https://bugs.jquery.com/ticket/12359\n          docElem.appendChild(el).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n          \"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n          \"<option selected=''></option></select>\";\n\n          // Support: IE8, Opera 11-12.16\n          // Nothing should be selected when empty strings follow ^= or $= or *=\n          // The test attribute must be unknown in Opera but \"safe\" for WinRT\n          // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n          if (el.querySelectorAll(\"[msallowcapture^='']\").length) {\n            rbuggyQSA.push(\"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\");\n          }\n\n          // Support: IE8\n          // Boolean attributes and \"value\" are not treated correctly\n          if (!el.querySelectorAll(\"[selected]\").length) {\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\");\n          }\n\n          // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n          if (!el.querySelectorAll(\"[id~=\" + expando + \"-]\").length) {\n            rbuggyQSA.push(\"~=\");\n          }\n\n          // Support: IE 11+, Edge 15 - 18+\n          // IE 11/Edge don't find elements on a `[name='']` query in some cases.\n          // Adding a temporary attribute to the document before the selection works\n          // around the issue.\n          // Interestingly, IE 10 & older don't seem to have the issue.\n          input = document.createElement(\"input\");\n          input.setAttribute(\"name\", \"\");\n          el.appendChild(input);\n          if (!el.querySelectorAll(\"[name='']\").length) {\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n            whitespace + \"*(?:''|\\\"\\\")\");\n          }\n\n          // Webkit/Opera - :checked should return selected option elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          // IE8 throws error here and will not see later tests\n          if (!el.querySelectorAll(\":checked\").length) {\n            rbuggyQSA.push(\":checked\");\n          }\n\n          // Support: Safari 8+, iOS 8+\n          // https://bugs.webkit.org/show_bug.cgi?id=136851\n          // In-page `selector#id sibling-combinator selector` fails\n          if (!el.querySelectorAll(\"a#\" + expando + \"+*\").length) {\n            rbuggyQSA.push(\".#.+[+~]\");\n          }\n\n          // Support: Firefox <=3.6 - 5 only\n          // Old Firefox doesn't throw on a badly-escaped identifier.\n          el.querySelectorAll(\"\\\\\\f\");\n          rbuggyQSA.push(\"[\\\\r\\\\n\\\\f]\");\n        });\n\n        assert(function (el) {\n          el.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n          \"<select disabled='disabled'><option/></select>\";\n\n          // Support: Windows 8 Native Apps\n          // The type and name attributes are restricted during .innerHTML assignment\n          var input = document.createElement(\"input\");\n          input.setAttribute(\"type\", \"hidden\");\n          el.appendChild(input).setAttribute(\"name\", \"D\");\n\n          // Support: IE8\n          // Enforce case-sensitivity of name attribute\n          if (el.querySelectorAll(\"[name=d]\").length) {\n            rbuggyQSA.push(\"name\" + whitespace + \"*[*^$|!~]?=\");\n          }\n\n          // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n          // IE8 throws error here and will not see later tests\n          if (el.querySelectorAll(\":enabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          }\n\n          // Support: IE9-11+\n          // IE's :disabled selector does not pick up the children of disabled fieldsets\n          docElem.appendChild(el).disabled = true;\n          if (el.querySelectorAll(\":disabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          }\n\n          // Support: Opera 10 - 11 only\n          // Opera 10-11 does not throw on post-comma invalid pseudos\n          el.querySelectorAll(\"*,:x\");\n          rbuggyQSA.push(\",.*:\");\n        });\n      }\n\n      if (support.matchesSelector = rnative.test(matches = docElem.matches ||\n      docElem.webkitMatchesSelector ||\n      docElem.mozMatchesSelector ||\n      docElem.oMatchesSelector ||\n      docElem.msMatchesSelector)) {\n\n        assert(function (el) {\n\n          // Check to see if it's possible to do matchesSelector\n          // on a disconnected node (IE 9)\n          support.disconnectedMatch = matches.call(el, \"*\");\n\n          // This should fail with an exception\n          // Gecko does not error, returns false instead\n          matches.call(el, \"[s!='']:x\");\n          rbuggyMatches.push(\"!=\", pseudos);\n        });\n      }\n\n      rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join(\"|\"));\n      rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join(\"|\"));\n\n      /* Contains\n      ---------------------------------------------------------------------- */\n      hasCompare = rnative.test(docElem.compareDocumentPosition);\n\n      // Element contains another\n      // Purposefully self-exclusive\n      // As in, an element does not contain itself\n      contains = hasCompare || rnative.test(docElem.contains) ?\n      function (a, b) {\n        var adown = a.nodeType === 9 ? a.documentElement : a,\n        bup = b && b.parentNode;\n        return a === bup || !!(bup && bup.nodeType === 1 && (\n        adown.contains ?\n        adown.contains(bup) :\n        a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));\n\n      } :\n      function (a, b) {\n        if (b) {\n          while (b = b.parentNode) {\n            if (b === a) {\n              return true;\n            }\n          }\n        }\n        return false;\n      };\n\n      /* Sorting\n      ---------------------------------------------------------------------- */\n\n      // Document order sorting\n      sortOrder = hasCompare ?\n      function (a, b) {\n\n        // Flag for duplicate removal\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        }\n\n        // Sort on method existence if only one input has compareDocumentPosition\n        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n        if (compare) {\n          return compare;\n        }\n\n        // Calculate position if both inputs belong to the same document\n        // Support: IE 11+, Edge 17 - 18+\n        // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n        // two documents; shallow comparisons work.\n        // eslint-disable-next-line eqeqeq\n        compare = (a.ownerDocument || a) == (b.ownerDocument || b) ?\n        a.compareDocumentPosition(b) :\n\n        // Otherwise we know they are disconnected\n        1;\n\n        // Disconnected nodes\n        if (compare & 1 ||\n        !support.sortDetached && b.compareDocumentPosition(a) === compare) {\n\n          // Choose the first element that is related to our preferred document\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n          if (a == document || a.ownerDocument == preferredDoc &&\n          contains(preferredDoc, a)) {\n            return -1;\n          }\n\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n          if (b == document || b.ownerDocument == preferredDoc &&\n          contains(preferredDoc, b)) {\n            return 1;\n          }\n\n          // Maintain original order\n          return sortInput ?\n          indexOf(sortInput, a) - indexOf(sortInput, b) :\n          0;\n        }\n\n        return compare & 4 ? -1 : 1;\n      } :\n      function (a, b) {\n\n        // Exit early if the nodes are identical\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        }\n\n        var cur,\n        i = 0,\n        aup = a.parentNode,\n        bup = b.parentNode,\n        ap = [a],\n        bp = [b];\n\n        // Parentless nodes are either documents or disconnected\n        if (!aup || !bup) {\n\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          /* eslint-disable eqeqeq */\n          return a == document ? -1 :\n          b == document ? 1 :\n          /* eslint-enable eqeqeq */\n          aup ? -1 :\n          bup ? 1 :\n          sortInput ?\n          indexOf(sortInput, a) - indexOf(sortInput, b) :\n          0;\n\n          // If the nodes are siblings, we can do a quick check\n        } else if (aup === bup) {\n          return siblingCheck(a, b);\n        }\n\n        // Otherwise we need full lists of their ancestors for comparison\n        cur = a;\n        while (cur = cur.parentNode) {\n          ap.unshift(cur);\n        }\n        cur = b;\n        while (cur = cur.parentNode) {\n          bp.unshift(cur);\n        }\n\n        // Walk down the tree looking for a discrepancy\n        while (ap[i] === bp[i]) {\n          i++;\n        }\n\n        return i ?\n\n        // Do a sibling check if the nodes have a common ancestor\n        siblingCheck(ap[i], bp[i]) :\n\n        // Otherwise nodes in our document sort first\n        // Support: IE 11+, Edge 17 - 18+\n        // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n        // two documents; shallow comparisons work.\n        /* eslint-disable eqeqeq */\n        ap[i] == preferredDoc ? -1 :\n        bp[i] == preferredDoc ? 1 :\n        /* eslint-enable eqeqeq */\n        0;\n      };\n\n      return document;\n    };\n\n    Sizzle.matches = function (expr, elements) {\n      return Sizzle(expr, null, null, elements);\n    };\n\n    Sizzle.matchesSelector = function (elem, expr) {\n      setDocument(elem);\n\n      if (support.matchesSelector && documentIsHTML &&\n      !nonnativeSelectorCache[expr + \" \"] && (\n      !rbuggyMatches || !rbuggyMatches.test(expr)) && (\n      !rbuggyQSA || !rbuggyQSA.test(expr))) {\n\n        try {\n          var ret = matches.call(elem, expr);\n\n          // IE 9's matchesSelector returns false on disconnected nodes\n          if (ret || support.disconnectedMatch ||\n\n          // As well, disconnected nodes are said to be in a document\n          // fragment in IE 9\n          elem.document && elem.document.nodeType !== 11) {\n            return ret;\n          }\n        } catch (e) {\n          nonnativeSelectorCache(expr, true);\n        }\n      }\n\n      return Sizzle(expr, document, null, [elem]).length > 0;\n    };\n\n    Sizzle.contains = function (context, elem) {\n\n      // Set document vars if needed\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if ((context.ownerDocument || context) != document) {\n        setDocument(context);\n      }\n      return contains(context, elem);\n    };\n\n    Sizzle.attr = function (elem, name) {\n\n      // Set document vars if needed\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if ((elem.ownerDocument || elem) != document) {\n        setDocument(elem);\n      }\n\n      var fn = Expr.attrHandle[name.toLowerCase()],\n\n      // Don't get fooled by Object.prototype properties (jQuery #13807)\n      val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ?\n      fn(elem, name, !documentIsHTML) :\n      undefined;\n\n      return val !== undefined ?\n      val :\n      support.attributes || !documentIsHTML ?\n      elem.getAttribute(name) :\n      (val = elem.getAttributeNode(name)) && val.specified ?\n      val.value :\n      null;\n    };\n\n    Sizzle.escape = function (sel) {\n      return (sel + \"\").replace(rcssescape, fcssescape);\n    };\n\n    Sizzle.error = function (msg) {\n      throw new Error(\"Syntax error, unrecognized expression: \" + msg);\n    };\n\n    /**\n     * Document sorting and removing duplicates\n     * @param {ArrayLike} results\n     */\n    Sizzle.uniqueSort = function (results) {\n      var elem,\n      duplicates = [],\n      j = 0,\n      i = 0;\n\n      // Unless we *know* we can detect duplicates, assume their presence\n      hasDuplicate = !support.detectDuplicates;\n      sortInput = !support.sortStable && results.slice(0);\n      results.sort(sortOrder);\n\n      if (hasDuplicate) {\n        while (elem = results[i++]) {\n          if (elem === results[i]) {\n            j = duplicates.push(i);\n          }\n        }\n        while (j--) {\n          results.splice(duplicates[j], 1);\n        }\n      }\n\n      // Clear input after sorting to release objects\n      // See https://github.com/jquery/sizzle/pull/225\n      sortInput = null;\n\n      return results;\n    };\n\n    /**\n     * Utility function for retrieving the text value of an array of DOM nodes\n     * @param {Array|Element} elem\n     */\n    getText = Sizzle.getText = function (elem) {\n      var node,\n      ret = \"\",\n      i = 0,\n      nodeType = elem.nodeType;\n\n      if (!nodeType) {\n\n        // If no nodeType, this is expected to be an array\n        while (node = elem[i++]) {\n\n          // Do not traverse comment nodes\n          ret += getText(node);\n        }\n      } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {\n\n        // Use textContent for elements\n        // innerText usage removed for consistency of new lines (jQuery #11153)\n        if (typeof elem.textContent === \"string\") {\n          return elem.textContent;\n        } else {\n\n          // Traverse its children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            ret += getText(elem);\n          }\n        }\n      } else if (nodeType === 3 || nodeType === 4) {\n        return elem.nodeValue;\n      }\n\n      // Do not include comment or processing instruction nodes\n\n      return ret;\n    };\n\n    Expr = Sizzle.selectors = {\n\n      // Can be adjusted by the user\n      cacheLength: 50,\n\n      createPseudo: markFunction,\n\n      match: matchExpr,\n\n      attrHandle: {},\n\n      find: {},\n\n      relative: {\n        \">\": { dir: \"parentNode\", first: true },\n        \" \": { dir: \"parentNode\" },\n        \"+\": { dir: \"previousSibling\", first: true },\n        \"~\": { dir: \"previousSibling\" } },\n\n\n      preFilter: {\n        \"ATTR\": function ATTR(match) {\n          match[1] = match[1].replace(runescape, funescape);\n\n          // Move the given value to match[3] whether quoted or unquoted\n          match[3] = (match[3] || match[4] ||\n          match[5] || \"\").replace(runescape, funescape);\n\n          if (match[2] === \"~=\") {\n            match[3] = \" \" + match[3] + \" \";\n          }\n\n          return match.slice(0, 4);\n        },\n\n        \"CHILD\": function CHILD(match) {\n\n          /* matches from matchExpr[\"CHILD\"]\n          \t1 type (only|nth|...)\n          \t2 what (child|of-type)\n          \t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n          \t4 xn-component of xn+y argument ([+-]?\\d*n|)\n          \t5 sign of xn-component\n          \t6 x of xn-component\n          \t7 sign of y-component\n          \t8 y of y-component\n          */\n          match[1] = match[1].toLowerCase();\n\n          if (match[1].slice(0, 3) === \"nth\") {\n\n            // nth-* requires argument\n            if (!match[3]) {\n              Sizzle.error(match[0]);\n            }\n\n            // numeric x and y parameters for Expr.filter.CHILD\n            // remember that false/true cast respectively to 0/1\n            match[4] = +(match[4] ?\n            match[5] + (match[6] || 1) :\n            2 * (match[3] === \"even\" || match[3] === \"odd\"));\n            match[5] = +(match[7] + match[8] || match[3] === \"odd\");\n\n            // other types prohibit arguments\n          } else if (match[3]) {\n            Sizzle.error(match[0]);\n          }\n\n          return match;\n        },\n\n        \"PSEUDO\": function PSEUDO(match) {\n          var excess,\n          unquoted = !match[6] && match[2];\n\n          if (matchExpr[\"CHILD\"].test(match[0])) {\n            return null;\n          }\n\n          // Accept quoted arguments as-is\n          if (match[3]) {\n            match[2] = match[4] || match[5] || \"\";\n\n            // Strip excess characters from unquoted arguments\n          } else if (unquoted && rpseudo.test(unquoted) && (\n\n          // Get excess from tokenize (recursively)\n          excess = tokenize(unquoted, true)) && (\n\n          // advance to the next closing parenthesis\n          excess = unquoted.indexOf(\")\", unquoted.length - excess) - unquoted.length)) {\n\n            // excess is a negative index\n            match[0] = match[0].slice(0, excess);\n            match[2] = unquoted.slice(0, excess);\n          }\n\n          // Return only captures needed by the pseudo filter method (type and argument)\n          return match.slice(0, 3);\n        } },\n\n\n      filter: {\n\n        \"TAG\": function TAG(nodeNameSelector) {\n          var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();\n          return nodeNameSelector === \"*\" ?\n          function () {\n            return true;\n          } :\n          function (elem) {\n            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n          };\n        },\n\n        \"CLASS\": function CLASS(className) {\n          var pattern = classCache[className + \" \"];\n\n          return pattern ||\n          (pattern = new RegExp(\"(^|\" + whitespace +\n          \")\" + className + \"(\" + whitespace + \"|$)\")) && classCache(\n          className, function (elem) {\n            return pattern.test(\n            typeof elem.className === \"string\" && elem.className ||\n            typeof elem.getAttribute !== \"undefined\" &&\n            elem.getAttribute(\"class\") ||\n            \"\");\n\n          });\n        },\n\n        \"ATTR\": function ATTR(name, operator, check) {\n          return function (elem) {\n            var result = Sizzle.attr(elem, name);\n\n            if (result == null) {\n              return operator === \"!=\";\n            }\n            if (!operator) {\n              return true;\n            }\n\n            result += \"\";\n\n            /* eslint-disable max-len */\n\n            return operator === \"=\" ? result === check :\n            operator === \"!=\" ? result !== check :\n            operator === \"^=\" ? check && result.indexOf(check) === 0 :\n            operator === \"*=\" ? check && result.indexOf(check) > -1 :\n            operator === \"$=\" ? check && result.slice(-check.length) === check :\n            operator === \"~=\" ? (\" \" + result.replace(rwhitespace, \" \") + \" \").indexOf(check) > -1 :\n            operator === \"|=\" ? result === check || result.slice(0, check.length + 1) === check + \"-\" :\n            false;\n            /* eslint-enable max-len */\n\n          };\n        },\n\n        \"CHILD\": function CHILD(type, what, _argument, first, last) {\n          var simple = type.slice(0, 3) !== \"nth\",\n          forward = type.slice(-4) !== \"last\",\n          ofType = what === \"of-type\";\n\n          return first === 1 && last === 0 ?\n\n          // Shortcut for :nth-*(n)\n          function (elem) {\n            return !!elem.parentNode;\n          } :\n\n          function (elem, _context, xml) {\n            var cache,uniqueCache,outerCache,node,nodeIndex,start,\n            dir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n            parent = elem.parentNode,\n            name = ofType && elem.nodeName.toLowerCase(),\n            useCache = !xml && !ofType,\n            diff = false;\n\n            if (parent) {\n\n              // :(first|last|only)-(child|of-type)\n              if (simple) {\n                while (dir) {\n                  node = elem;\n                  while (node = node[dir]) {\n                    if (ofType ?\n                    node.nodeName.toLowerCase() === name :\n                    node.nodeType === 1) {\n\n                      return false;\n                    }\n                  }\n\n                  // Reverse direction for :only-* (if we haven't yet done so)\n                  start = dir = type === \"only\" && !start && \"nextSibling\";\n                }\n                return true;\n              }\n\n              start = [forward ? parent.firstChild : parent.lastChild];\n\n              // non-xml :nth-child(...) stores cache data on `parent`\n              if (forward && useCache) {\n\n                // Seek `elem` from a previously-cached index\n\n                // ...in a gzip-friendly way\n                node = parent;\n                outerCache = node[expando] || (node[expando] = {});\n\n                // Support: IE <9 only\n                // Defend against cloned attroperties (jQuery gh-1709)\n                uniqueCache = outerCache[node.uniqueID] || (\n                outerCache[node.uniqueID] = {});\n\n                cache = uniqueCache[type] || [];\n                nodeIndex = cache[0] === dirruns && cache[1];\n                diff = nodeIndex && cache[2];\n                node = nodeIndex && parent.childNodes[nodeIndex];\n\n                while (node = ++nodeIndex && node && node[dir] || (\n\n                // Fallback to seeking `elem` from the start\n                diff = nodeIndex = 0) || start.pop()) {\n\n                  // When found, cache indexes on `parent` and break\n                  if (node.nodeType === 1 && ++diff && node === elem) {\n                    uniqueCache[type] = [dirruns, nodeIndex, diff];\n                    break;\n                  }\n                }\n\n              } else {\n\n                // Use previously-cached element index if available\n                if (useCache) {\n\n                  // ...in a gzip-friendly way\n                  node = elem;\n                  outerCache = node[expando] || (node[expando] = {});\n\n                  // Support: IE <9 only\n                  // Defend against cloned attroperties (jQuery gh-1709)\n                  uniqueCache = outerCache[node.uniqueID] || (\n                  outerCache[node.uniqueID] = {});\n\n                  cache = uniqueCache[type] || [];\n                  nodeIndex = cache[0] === dirruns && cache[1];\n                  diff = nodeIndex;\n                }\n\n                // xml :nth-child(...)\n                // or :nth-last-child(...) or :nth(-last)?-of-type(...)\n                if (diff === false) {\n\n                  // Use the same loop as above to seek `elem` from the start\n                  while (node = ++nodeIndex && node && node[dir] || (\n                  diff = nodeIndex = 0) || start.pop()) {\n\n                    if ((ofType ?\n                    node.nodeName.toLowerCase() === name :\n                    node.nodeType === 1) &&\n                    ++diff) {\n\n                      // Cache the index of each encountered element\n                      if (useCache) {\n                        outerCache = node[expando] || (\n                        node[expando] = {});\n\n                        // Support: IE <9 only\n                        // Defend against cloned attroperties (jQuery gh-1709)\n                        uniqueCache = outerCache[node.uniqueID] || (\n                        outerCache[node.uniqueID] = {});\n\n                        uniqueCache[type] = [dirruns, diff];\n                      }\n\n                      if (node === elem) {\n                        break;\n                      }\n                    }\n                  }\n                }\n              }\n\n              // Incorporate the offset, then check against cycle size\n              diff -= last;\n              return diff === first || diff % first === 0 && diff / first >= 0;\n            }\n          };\n        },\n\n        \"PSEUDO\": function PSEUDO(pseudo, argument) {\n\n          // pseudo-class names are case-insensitive\n          // http://www.w3.org/TR/selectors/#pseudo-classes\n          // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n          // Remember that setFilters inherits from pseudos\n          var args,\n          fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] ||\n          Sizzle.error(\"unsupported pseudo: \" + pseudo);\n\n          // The user may use createPseudo to indicate that\n          // arguments are needed to create the filter function\n          // just as Sizzle does\n          if (fn[expando]) {\n            return fn(argument);\n          }\n\n          // But maintain support for old signatures\n          if (fn.length > 1) {\n            args = [pseudo, pseudo, \"\", argument];\n            return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ?\n            markFunction(function (seed, matches) {\n              var idx,\n              matched = fn(seed, argument),\n              i = matched.length;\n              while (i--) {\n                idx = indexOf(seed, matched[i]);\n                seed[idx] = !(matches[idx] = matched[i]);\n              }\n            }) :\n            function (elem) {\n              return fn(elem, 0, args);\n            };\n          }\n\n          return fn;\n        } },\n\n\n      pseudos: {\n\n        // Potentially complex pseudos\n        \"not\": markFunction(function (selector) {\n\n          // Trim the selector passed to compile\n          // to avoid treating leading and trailing\n          // spaces as combinators\n          var input = [],\n          results = [],\n          matcher = compile(selector.replace(rtrim, \"$1\"));\n\n          return matcher[expando] ?\n          markFunction(function (seed, matches, _context, xml) {\n            var elem,\n            unmatched = matcher(seed, null, xml, []),\n            i = seed.length;\n\n            // Match elements unmatched by `matcher`\n            while (i--) {\n              if (elem = unmatched[i]) {\n                seed[i] = !(matches[i] = elem);\n              }\n            }\n          }) :\n          function (elem, _context, xml) {\n            input[0] = elem;\n            matcher(input, null, xml, results);\n\n            // Don't keep the element (issue #299)\n            input[0] = null;\n            return !results.pop();\n          };\n        }),\n\n        \"has\": markFunction(function (selector) {\n          return function (elem) {\n            return Sizzle(selector, elem).length > 0;\n          };\n        }),\n\n        \"contains\": markFunction(function (text) {\n          text = text.replace(runescape, funescape);\n          return function (elem) {\n            return (elem.textContent || getText(elem)).indexOf(text) > -1;\n          };\n        }),\n\n        // \"Whether an element is represented by a :lang() selector\n        // is based solely on the element's language value\n        // being equal to the identifier C,\n        // or beginning with the identifier C immediately followed by \"-\".\n        // The matching of C against the element's language value is performed case-insensitively.\n        // The identifier C does not have to be a valid language name.\"\n        // http://www.w3.org/TR/selectors/#lang-pseudo\n        \"lang\": markFunction(function (lang) {\n\n          // lang value must be a valid identifier\n          if (!ridentifier.test(lang || \"\")) {\n            Sizzle.error(\"unsupported lang: \" + lang);\n          }\n          lang = lang.replace(runescape, funescape).toLowerCase();\n          return function (elem) {\n            var elemLang;\n            do {\n              if (elemLang = documentIsHTML ?\n              elem.lang :\n              elem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) {\n\n                elemLang = elemLang.toLowerCase();\n                return elemLang === lang || elemLang.indexOf(lang + \"-\") === 0;\n              }\n            } while ((elem = elem.parentNode) && elem.nodeType === 1);\n            return false;\n          };\n        }),\n\n        // Miscellaneous\n        \"target\": function target(elem) {\n          var hash = window.location && window.location.hash;\n          return hash && hash.slice(1) === elem.id;\n        },\n\n        \"root\": function root(elem) {\n          return elem === docElem;\n        },\n\n        \"focus\": function focus(elem) {\n          return elem === document.activeElement && (\n          !document.hasFocus || document.hasFocus()) &&\n          !!(elem.type || elem.href || ~elem.tabIndex);\n        },\n\n        // Boolean properties\n        \"enabled\": createDisabledPseudo(false),\n        \"disabled\": createDisabledPseudo(true),\n\n        \"checked\": function checked(elem) {\n\n          // In CSS3, :checked should return both checked and selected elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          var nodeName = elem.nodeName.toLowerCase();\n          return nodeName === \"input\" && !!elem.checked ||\n          nodeName === \"option\" && !!elem.selected;\n        },\n\n        \"selected\": function selected(elem) {\n\n          // Accessing this property makes selected-by-default\n          // options in Safari work properly\n          if (elem.parentNode) {\n            // eslint-disable-next-line no-unused-expressions\n            elem.parentNode.selectedIndex;\n          }\n\n          return elem.selected === true;\n        },\n\n        // Contents\n        \"empty\": function empty(elem) {\n\n          // http://www.w3.org/TR/selectors/#empty-pseudo\n          // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n          //   but not by others (comment: 8; processing instruction: 7; etc.)\n          // nodeType < 6 works because attributes (2) do not appear as children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            if (elem.nodeType < 6) {\n              return false;\n            }\n          }\n          return true;\n        },\n\n        \"parent\": function parent(elem) {\n          return !Expr.pseudos[\"empty\"](elem);\n        },\n\n        // Element/input types\n        \"header\": function header(elem) {\n          return rheader.test(elem.nodeName);\n        },\n\n        \"input\": function input(elem) {\n          return rinputs.test(elem.nodeName);\n        },\n\n        \"button\": function button(elem) {\n          var name = elem.nodeName.toLowerCase();\n          return name === \"input\" && elem.type === \"button\" || name === \"button\";\n        },\n\n        \"text\": function text(elem) {\n          var attr;\n          return elem.nodeName.toLowerCase() === \"input\" &&\n          elem.type === \"text\" && (\n\n          // Support: IE<8\n          // New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n          (attr = elem.getAttribute(\"type\")) == null ||\n          attr.toLowerCase() === \"text\");\n        },\n\n        // Position-in-collection\n        \"first\": createPositionalPseudo(function () {\n          return [0];\n        }),\n\n        \"last\": createPositionalPseudo(function (_matchIndexes, length) {\n          return [length - 1];\n        }),\n\n        \"eq\": createPositionalPseudo(function (_matchIndexes, length, argument) {\n          return [argument < 0 ? argument + length : argument];\n        }),\n\n        \"even\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 0;\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n          return matchIndexes;\n        }),\n\n        \"odd\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 1;\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n          return matchIndexes;\n        }),\n\n        \"lt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ?\n          argument + length :\n          argument > length ?\n          length :\n          argument;\n          for (; --i >= 0;) {\n            matchIndexes.push(i);\n          }\n          return matchIndexes;\n        }),\n\n        \"gt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ? argument + length : argument;\n          for (; ++i < length;) {\n            matchIndexes.push(i);\n          }\n          return matchIndexes;\n        }) } };\n\n\n\n    Expr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\n    // Add button/input type pseudos\n    for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {\n      Expr.pseudos[i] = createInputPseudo(i);\n    }\n    for (i in { submit: true, reset: true }) {\n      Expr.pseudos[i] = createButtonPseudo(i);\n    }\n\n    // Easy API for creating new setFilters\n    function setFilters() {}\n    setFilters.prototype = Expr.filters = Expr.pseudos;\n    Expr.setFilters = new setFilters();\n\n    tokenize = Sizzle.tokenize = function (selector, parseOnly) {\n      var matched,match,tokens,type,\n      soFar,groups,preFilters,\n      cached = tokenCache[selector + \" \"];\n\n      if (cached) {\n        return parseOnly ? 0 : cached.slice(0);\n      }\n\n      soFar = selector;\n      groups = [];\n      preFilters = Expr.preFilter;\n\n      while (soFar) {\n\n        // Comma and first run\n        if (!matched || (match = rcomma.exec(soFar))) {\n          if (match) {\n\n            // Don't consume trailing commas as valid\n            soFar = soFar.slice(match[0].length) || soFar;\n          }\n          groups.push(tokens = []);\n        }\n\n        matched = false;\n\n        // Combinators\n        if (match = rcombinators.exec(soFar)) {\n          matched = match.shift();\n          tokens.push({\n            value: matched,\n\n            // Cast descendant combinators to space\n            type: match[0].replace(rtrim, \" \") });\n\n          soFar = soFar.slice(matched.length);\n        }\n\n        // Filters\n        for (type in Expr.filter) {\n          if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (\n          match = preFilters[type](match)))) {\n            matched = match.shift();\n            tokens.push({\n              value: matched,\n              type: type,\n              matches: match });\n\n            soFar = soFar.slice(matched.length);\n          }\n        }\n\n        if (!matched) {\n          break;\n        }\n      }\n\n      // Return the length of the invalid excess\n      // if we're just parsing\n      // Otherwise, throw an error or return tokens\n      return parseOnly ?\n      soFar.length :\n      soFar ?\n      Sizzle.error(selector) :\n\n      // Cache the tokens\n      tokenCache(selector, groups).slice(0);\n    };\n\n    function toSelector(tokens) {\n      var i = 0,\n      len = tokens.length,\n      selector = \"\";\n      for (; i < len; i++) {\n        selector += tokens[i].value;\n      }\n      return selector;\n    }\n\n    function addCombinator(matcher, combinator, base) {\n      var dir = combinator.dir,\n      skip = combinator.next,\n      key = skip || dir,\n      checkNonElements = base && key === \"parentNode\",\n      doneName = done++;\n\n      return combinator.first ?\n\n      // Check against closest ancestor/preceding element\n      function (elem, context, xml) {\n        while (elem = elem[dir]) {\n          if (elem.nodeType === 1 || checkNonElements) {\n            return matcher(elem, context, xml);\n          }\n        }\n        return false;\n      } :\n\n      // Check against all ancestor/preceding elements\n      function (elem, context, xml) {\n        var oldCache,uniqueCache,outerCache,\n        newCache = [dirruns, doneName];\n\n        // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n        if (xml) {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              if (matcher(elem, context, xml)) {\n                return true;\n              }\n            }\n          }\n        } else {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              outerCache = elem[expando] || (elem[expando] = {});\n\n              // Support: IE <9 only\n              // Defend against cloned attroperties (jQuery gh-1709)\n              uniqueCache = outerCache[elem.uniqueID] || (\n              outerCache[elem.uniqueID] = {});\n\n              if (skip && skip === elem.nodeName.toLowerCase()) {\n                elem = elem[dir] || elem;\n              } else if ((oldCache = uniqueCache[key]) &&\n              oldCache[0] === dirruns && oldCache[1] === doneName) {\n\n                // Assign to newCache so results back-propagate to previous elements\n                return newCache[2] = oldCache[2];\n              } else {\n\n                // Reuse newcache so results back-propagate to previous elements\n                uniqueCache[key] = newCache;\n\n                // A match means we're done; a fail means we have to keep checking\n                if (newCache[2] = matcher(elem, context, xml)) {\n                  return true;\n                }\n              }\n            }\n          }\n        }\n        return false;\n      };\n    }\n\n    function elementMatcher(matchers) {\n      return matchers.length > 1 ?\n      function (elem, context, xml) {\n        var i = matchers.length;\n        while (i--) {\n          if (!matchers[i](elem, context, xml)) {\n            return false;\n          }\n        }\n        return true;\n      } :\n      matchers[0];\n    }\n\n    function multipleContexts(selector, contexts, results) {\n      var i = 0,\n      len = contexts.length;\n      for (; i < len; i++) {\n        Sizzle(selector, contexts[i], results);\n      }\n      return results;\n    }\n\n    function condense(unmatched, map, filter, context, xml) {\n      var elem,\n      newUnmatched = [],\n      i = 0,\n      len = unmatched.length,\n      mapped = map != null;\n\n      for (; i < len; i++) {\n        if (elem = unmatched[i]) {\n          if (!filter || filter(elem, context, xml)) {\n            newUnmatched.push(elem);\n            if (mapped) {\n              map.push(i);\n            }\n          }\n        }\n      }\n\n      return newUnmatched;\n    }\n\n    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {\n      if (postFilter && !postFilter[expando]) {\n        postFilter = setMatcher(postFilter);\n      }\n      if (postFinder && !postFinder[expando]) {\n        postFinder = setMatcher(postFinder, postSelector);\n      }\n      return markFunction(function (seed, results, context, xml) {\n        var temp,i,elem,\n        preMap = [],\n        postMap = [],\n        preexisting = results.length,\n\n        // Get initial elements from seed or context\n        elems = seed || multipleContexts(\n        selector || \"*\",\n        context.nodeType ? [context] : context,\n        []),\n\n\n        // Prefilter to get matcher input, preserving a map for seed-results synchronization\n        matcherIn = preFilter && (seed || !selector) ?\n        condense(elems, preMap, preFilter, context, xml) :\n        elems,\n\n        matcherOut = matcher ?\n\n        // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n        postFinder || (seed ? preFilter : preexisting || postFilter) ?\n\n        // ...intermediate processing is necessary\n        [] :\n\n        // ...otherwise use results directly\n        results :\n        matcherIn;\n\n        // Find primary matches\n        if (matcher) {\n          matcher(matcherIn, matcherOut, context, xml);\n        }\n\n        // Apply postFilter\n        if (postFilter) {\n          temp = condense(matcherOut, postMap);\n          postFilter(temp, [], context, xml);\n\n          // Un-match failing elements by moving them back to matcherIn\n          i = temp.length;\n          while (i--) {\n            if (elem = temp[i]) {\n              matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);\n            }\n          }\n        }\n\n        if (seed) {\n          if (postFinder || preFilter) {\n            if (postFinder) {\n\n              // Get the final matcherOut by condensing this intermediate into postFinder contexts\n              temp = [];\n              i = matcherOut.length;\n              while (i--) {\n                if (elem = matcherOut[i]) {\n\n                  // Restore matcherIn since elem is not yet a final match\n                  temp.push(matcherIn[i] = elem);\n                }\n              }\n              postFinder(null, matcherOut = [], temp, xml);\n            }\n\n            // Move matched elements from seed to results to keep them synchronized\n            i = matcherOut.length;\n            while (i--) {\n              if ((elem = matcherOut[i]) &&\n              (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {\n\n                seed[temp] = !(results[temp] = elem);\n              }\n            }\n          }\n\n          // Add elements to results, through postFinder if defined\n        } else {\n          matcherOut = condense(\n          matcherOut === results ?\n          matcherOut.splice(preexisting, matcherOut.length) :\n          matcherOut);\n\n          if (postFinder) {\n            postFinder(null, results, matcherOut, xml);\n          } else {\n            push.apply(results, matcherOut);\n          }\n        }\n      });\n    }\n\n    function matcherFromTokens(tokens) {\n      var checkContext,matcher,j,\n      len = tokens.length,\n      leadingRelative = Expr.relative[tokens[0].type],\n      implicitRelative = leadingRelative || Expr.relative[\" \"],\n      i = leadingRelative ? 1 : 0,\n\n      // The foundational matcher ensures that elements are reachable from top-level context(s)\n      matchContext = addCombinator(function (elem) {\n        return elem === checkContext;\n      }, implicitRelative, true),\n      matchAnyContext = addCombinator(function (elem) {\n        return indexOf(checkContext, elem) > -1;\n      }, implicitRelative, true),\n      matchers = [function (elem, context, xml) {\n        var ret = !leadingRelative && (xml || context !== outermostContext) || (\n        (checkContext = context).nodeType ?\n        matchContext(elem, context, xml) :\n        matchAnyContext(elem, context, xml));\n\n        // Avoid hanging onto element (issue #299)\n        checkContext = null;\n        return ret;\n      }];\n\n      for (; i < len; i++) {\n        if (matcher = Expr.relative[tokens[i].type]) {\n          matchers = [addCombinator(elementMatcher(matchers), matcher)];\n        } else {\n          matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);\n\n          // Return special upon seeing a positional matcher\n          if (matcher[expando]) {\n\n            // Find the next relative operator (if any) for proper handling\n            j = ++i;\n            for (; j < len; j++) {\n              if (Expr.relative[tokens[j].type]) {\n                break;\n              }\n            }\n            return setMatcher(\n            i > 1 && elementMatcher(matchers),\n            i > 1 && toSelector(\n\n            // If the preceding token was a descendant combinator, insert an implicit any-element `*`\n            tokens.\n            slice(0, i - 1).\n            concat({ value: tokens[i - 2].type === \" \" ? \"*\" : \"\" })).\n            replace(rtrim, \"$1\"),\n            matcher,\n            i < j && matcherFromTokens(tokens.slice(i, j)),\n            j < len && matcherFromTokens(tokens = tokens.slice(j)),\n            j < len && toSelector(tokens));\n\n          }\n          matchers.push(matcher);\n        }\n      }\n\n      return elementMatcher(matchers);\n    }\n\n    function matcherFromGroupMatchers(elementMatchers, setMatchers) {\n      var bySet = setMatchers.length > 0,\n      byElement = elementMatchers.length > 0,\n      superMatcher = function superMatcher(seed, context, xml, results, outermost) {\n        var elem,j,matcher,\n        matchedCount = 0,\n        i = \"0\",\n        unmatched = seed && [],\n        setMatched = [],\n        contextBackup = outermostContext,\n\n        // We must always have either seed elements or outermost context\n        elems = seed || byElement && Expr.find[\"TAG\"](\"*\", outermost),\n\n        // Use integer dirruns iff this is the outermost matcher\n        dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,\n        len = elems.length;\n\n        if (outermost) {\n\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n          outermostContext = context == document || context || outermost;\n        }\n\n        // Add elements passing elementMatchers directly to results\n        // Support: IE<9, Safari\n        // Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n        for (; i !== len && (elem = elems[i]) != null; i++) {\n          if (byElement && elem) {\n            j = 0;\n\n            // Support: IE 11+, Edge 17 - 18+\n            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n            // two documents; shallow comparisons work.\n            // eslint-disable-next-line eqeqeq\n            if (!context && elem.ownerDocument != document) {\n              setDocument(elem);\n              xml = !documentIsHTML;\n            }\n            while (matcher = elementMatchers[j++]) {\n              if (matcher(elem, context || document, xml)) {\n                results.push(elem);\n                break;\n              }\n            }\n            if (outermost) {\n              dirruns = dirrunsUnique;\n            }\n          }\n\n          // Track unmatched elements for set filters\n          if (bySet) {\n\n            // They will have gone through all possible matchers\n            if (elem = !matcher && elem) {\n              matchedCount--;\n            }\n\n            // Lengthen the array for every element, matched or not\n            if (seed) {\n              unmatched.push(elem);\n            }\n          }\n        }\n\n        // `i` is now the count of elements visited above, and adding it to `matchedCount`\n        // makes the latter nonnegative.\n        matchedCount += i;\n\n        // Apply set filters to unmatched elements\n        // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n        // equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n        // no element matchers and no seed.\n        // Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n        // case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n        // numerically zero.\n        if (bySet && i !== matchedCount) {\n          j = 0;\n          while (matcher = setMatchers[j++]) {\n            matcher(unmatched, setMatched, context, xml);\n          }\n\n          if (seed) {\n\n            // Reintegrate element matches to eliminate the need for sorting\n            if (matchedCount > 0) {\n              while (i--) {\n                if (!(unmatched[i] || setMatched[i])) {\n                  setMatched[i] = pop.call(results);\n                }\n              }\n            }\n\n            // Discard index placeholder values to get only actual matches\n            setMatched = condense(setMatched);\n          }\n\n          // Add matches to results\n          push.apply(results, setMatched);\n\n          // Seedless set matches succeeding multiple successful matchers stipulate sorting\n          if (outermost && !seed && setMatched.length > 0 &&\n          matchedCount + setMatchers.length > 1) {\n\n            Sizzle.uniqueSort(results);\n          }\n        }\n\n        // Override manipulation of globals by nested matchers\n        if (outermost) {\n          dirruns = dirrunsUnique;\n          outermostContext = contextBackup;\n        }\n\n        return unmatched;\n      };\n\n      return bySet ?\n      markFunction(superMatcher) :\n      superMatcher;\n    }\n\n    compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {\n      var i,\n      setMatchers = [],\n      elementMatchers = [],\n      cached = compilerCache[selector + \" \"];\n\n      if (!cached) {\n\n        // Generate a function of recursive functions that can be used to check each element\n        if (!match) {\n          match = tokenize(selector);\n        }\n        i = match.length;\n        while (i--) {\n          cached = matcherFromTokens(match[i]);\n          if (cached[expando]) {\n            setMatchers.push(cached);\n          } else {\n            elementMatchers.push(cached);\n          }\n        }\n\n        // Cache the compiled function\n        cached = compilerCache(\n        selector,\n        matcherFromGroupMatchers(elementMatchers, setMatchers));\n\n\n        // Save selector and tokenization\n        cached.selector = selector;\n      }\n      return cached;\n    };\n\n    /**\n     * A low-level selection function that works with Sizzle's compiled\n     *  selector functions\n     * @param {String|Function} selector A selector or a pre-compiled\n     *  selector function built with Sizzle.compile\n     * @param {Element} context\n     * @param {Array} [results]\n     * @param {Array} [seed] A set of elements to match against\n     */\n    select = Sizzle.select = function (selector, context, results, seed) {\n      var i,tokens,token,type,find,\n      compiled = typeof selector === \"function\" && selector,\n      match = !seed && tokenize(selector = compiled.selector || selector);\n\n      results = results || [];\n\n      // Try to minimize operations if there is only one selector in the list and no seed\n      // (the latter of which guarantees us context)\n      if (match.length === 1) {\n\n        // Reduce context if the leading compound selector is an ID\n        tokens = match[0] = match[0].slice(0);\n        if (tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n        context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {\n\n          context = (Expr.find[\"ID\"](token.matches[0].\n          replace(runescape, funescape), context) || [])[0];\n          if (!context) {\n            return results;\n\n            // Precompiled matchers will still verify ancestry, so step up a level\n          } else if (compiled) {\n            context = context.parentNode;\n          }\n\n          selector = selector.slice(tokens.shift().value.length);\n        }\n\n        // Fetch a seed set for right-to-left matching\n        i = matchExpr[\"needsContext\"].test(selector) ? 0 : tokens.length;\n        while (i--) {\n          token = tokens[i];\n\n          // Abort if we hit a combinator\n          if (Expr.relative[type = token.type]) {\n            break;\n          }\n          if (find = Expr.find[type]) {\n\n            // Search, expanding context for leading sibling combinators\n            if (seed = find(\n            token.matches[0].replace(runescape, funescape),\n            rsibling.test(tokens[0].type) && testContext(context.parentNode) ||\n            context))\n            {\n\n              // If seed is empty or no tokens remain, we can return early\n              tokens.splice(i, 1);\n              selector = seed.length && toSelector(tokens);\n              if (!selector) {\n                push.apply(results, seed);\n                return results;\n              }\n\n              break;\n            }\n          }\n        }\n      }\n\n      // Compile and execute a filtering function if one is not provided\n      // Provide `match` to avoid retokenization if we modified the selector above\n      (compiled || compile(selector, match))(\n      seed,\n      context,\n      !documentIsHTML,\n      results,\n      !context || rsibling.test(selector) && testContext(context.parentNode) || context);\n\n      return results;\n    };\n\n    // One-time assignments\n\n    // Sort stability\n    support.sortStable = expando.split(\"\").sort(sortOrder).join(\"\") === expando;\n\n    // Support: Chrome 14-35+\n    // Always assume duplicates if they aren't passed to the comparison function\n    support.detectDuplicates = !!hasDuplicate;\n\n    // Initialize against the default document\n    setDocument();\n\n    // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n    // Detached nodes confoundingly follow *each other*\n    support.sortDetached = assert(function (el) {\n\n      // Should return 1, but returns 4 (following)\n      return el.compareDocumentPosition(document.createElement(\"fieldset\")) & 1;\n    });\n\n    // Support: IE<8\n    // Prevent attribute/property \"interpolation\"\n    // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\n    if (!assert(function (el) {\n      el.innerHTML = \"<a href='#'></a>\";\n      return el.firstChild.getAttribute(\"href\") === \"#\";\n    })) {\n      addHandle(\"type|href|height|width\", function (elem, name, isXML) {\n        if (!isXML) {\n          return elem.getAttribute(name, name.toLowerCase() === \"type\" ? 1 : 2);\n        }\n      });\n    }\n\n    // Support: IE<9\n    // Use defaultValue in place of getAttribute(\"value\")\n    if (!support.attributes || !assert(function (el) {\n      el.innerHTML = \"<input/>\";\n      el.firstChild.setAttribute(\"value\", \"\");\n      return el.firstChild.getAttribute(\"value\") === \"\";\n    })) {\n      addHandle(\"value\", function (elem, _name, isXML) {\n        if (!isXML && elem.nodeName.toLowerCase() === \"input\") {\n          return elem.defaultValue;\n        }\n      });\n    }\n\n    // Support: IE<9\n    // Use getAttributeNode to fetch booleans when getAttribute lies\n    if (!assert(function (el) {\n      return el.getAttribute(\"disabled\") == null;\n    })) {\n      addHandle(booleans, function (elem, name, isXML) {\n        var val;\n        if (!isXML) {\n          return elem[name] === true ? name.toLowerCase() :\n          (val = elem.getAttributeNode(name)) && val.specified ?\n          val.value :\n          null;\n        }\n      });\n    }\n\n    return Sizzle;\n\n  }(window);\n\n\n\n  jQuery.find = Sizzle;\n  jQuery.expr = Sizzle.selectors;\n\n  // Deprecated\n  jQuery.expr[\":\"] = jQuery.expr.pseudos;\n  jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\n  jQuery.text = Sizzle.getText;\n  jQuery.isXMLDoc = Sizzle.isXML;\n  jQuery.contains = Sizzle.contains;\n  jQuery.escapeSelector = Sizzle.escape;\n\n\n\n\n  var dir = function dir(elem, _dir, until) {\n    var matched = [],\n    truncate = until !== undefined;\n\n    while ((elem = elem[_dir]) && elem.nodeType !== 9) {\n      if (elem.nodeType === 1) {\n        if (truncate && jQuery(elem).is(until)) {\n          break;\n        }\n        matched.push(elem);\n      }\n    }\n    return matched;\n  };\n\n\n  var _siblings = function siblings(n, elem) {\n    var matched = [];\n\n    for (; n; n = n.nextSibling) {\n      if (n.nodeType === 1 && n !== elem) {\n        matched.push(n);\n      }\n    }\n\n    return matched;\n  };\n\n\n  var rneedsContext = jQuery.expr.match.needsContext;\n\n\n\n  function nodeName(elem, name) {\n\n    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n  };\n  var rsingleTag = /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i;\n\n\n\n  // Implement the identical functionality for filter and not\n  function winnow(elements, qualifier, not) {\n    if (isFunction(qualifier)) {\n      return jQuery.grep(elements, function (elem, i) {\n        return !!qualifier.call(elem, i, elem) !== not;\n      });\n    }\n\n    // Single element\n    if (qualifier.nodeType) {\n      return jQuery.grep(elements, function (elem) {\n        return elem === qualifier !== not;\n      });\n    }\n\n    // Arraylike of elements (jQuery, arguments, Array)\n    if (typeof qualifier !== \"string\") {\n      return jQuery.grep(elements, function (elem) {\n        return indexOf.call(qualifier, elem) > -1 !== not;\n      });\n    }\n\n    // Filtered directly for both simple and complex selectors\n    return jQuery.filter(qualifier, elements, not);\n  }\n\n  jQuery.filter = function (expr, elems, not) {\n    var elem = elems[0];\n\n    if (not) {\n      expr = \":not(\" + expr + \")\";\n    }\n\n    if (elems.length === 1 && elem.nodeType === 1) {\n      return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];\n    }\n\n    return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {\n      return elem.nodeType === 1;\n    }));\n  };\n\n  jQuery.fn.extend({\n    find: function find(selector) {\n      var i,ret,\n      len = this.length,\n      self = this;\n\n      if (typeof selector !== \"string\") {\n        return this.pushStack(jQuery(selector).filter(function () {\n          for (i = 0; i < len; i++) {\n            if (jQuery.contains(self[i], this)) {\n              return true;\n            }\n          }\n        }));\n      }\n\n      ret = this.pushStack([]);\n\n      for (i = 0; i < len; i++) {\n        jQuery.find(selector, self[i], ret);\n      }\n\n      return len > 1 ? jQuery.uniqueSort(ret) : ret;\n    },\n    filter: function filter(selector) {\n      return this.pushStack(winnow(this, selector || [], false));\n    },\n    not: function not(selector) {\n      return this.pushStack(winnow(this, selector || [], true));\n    },\n    is: function is(selector) {\n      return !!winnow(\n      this,\n\n      // If this is a positional/relative selector, check membership in the returned set\n      // so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n      typeof selector === \"string\" && rneedsContext.test(selector) ?\n      jQuery(selector) :\n      selector || [],\n      false).\n      length;\n    } });\n\n\n\n  // Initialize a jQuery object\n\n\n  // A central reference to the root jQuery(document)\n  var rootjQuery,\n\n  // A simple way to check for HTML strings\n  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n  // Strict HTML recognition (#11290: must start with <)\n  // Shortcut simple #id case for speed\n  rquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n  init = jQuery.fn.init = function (selector, context, root) {\n    var match, elem;\n\n    // HANDLE: $(\"\"), $(null), $(undefined), $(false)\n    if (!selector) {\n      return this;\n    }\n\n    // Method init() accepts an alternate rootjQuery\n    // so migrate can support jQuery.sub (gh-2101)\n    root = root || rootjQuery;\n\n    // Handle HTML strings\n    if (typeof selector === \"string\") {\n      if (selector[0] === \"<\" &&\n      selector[selector.length - 1] === \">\" &&\n      selector.length >= 3) {\n\n        // Assume that strings that start and end with <> are HTML and skip the regex check\n        match = [null, selector, null];\n\n      } else {\n        match = rquickExpr.exec(selector);\n      }\n\n      // Match html or make sure no context is specified for #id\n      if (match && (match[1] || !context)) {\n\n        // HANDLE: $(html) -> $(array)\n        if (match[1]) {\n          context = context instanceof jQuery ? context[0] : context;\n\n          // Option to run scripts is true for back-compat\n          // Intentionally let the error be thrown if parseHTML is not present\n          jQuery.merge(this, jQuery.parseHTML(\n          match[1],\n          context && context.nodeType ? context.ownerDocument || context : document,\n          true));\n\n\n          // HANDLE: $(html, props)\n          if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {\n            for (match in context) {\n\n              // Properties of context are called as methods if possible\n              if (isFunction(this[match])) {\n                this[match](context[match]);\n\n                // ...and otherwise set as attributes\n              } else {\n                this.attr(match, context[match]);\n              }\n            }\n          }\n\n          return this;\n\n          // HANDLE: $(#id)\n        } else {\n          elem = document.getElementById(match[2]);\n\n          if (elem) {\n\n            // Inject the element directly into the jQuery object\n            this[0] = elem;\n            this.length = 1;\n          }\n          return this;\n        }\n\n        // HANDLE: $(expr, $(...))\n      } else if (!context || context.jquery) {\n        return (context || root).find(selector);\n\n        // HANDLE: $(expr, context)\n        // (which is just equivalent to: $(context).find(expr)\n      } else {\n        return this.constructor(context).find(selector);\n      }\n\n      // HANDLE: $(DOMElement)\n    } else if (selector.nodeType) {\n      this[0] = selector;\n      this.length = 1;\n      return this;\n\n      // HANDLE: $(function)\n      // Shortcut for document ready\n    } else if (isFunction(selector)) {\n      return root.ready !== undefined ?\n      root.ready(selector) :\n\n      // Execute immediately if ready is not present\n      selector(jQuery);\n    }\n\n    return jQuery.makeArray(selector, this);\n  };\n\n  // Give the init function the jQuery prototype for later instantiation\n  init.prototype = jQuery.fn;\n\n  // Initialize central reference\n  rootjQuery = jQuery(document);\n\n\n  var rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n  // Methods guaranteed to produce a unique set when starting from a unique set\n  guaranteedUnique = {\n    children: true,\n    contents: true,\n    next: true,\n    prev: true };\n\n\n  jQuery.fn.extend({\n    has: function has(target) {\n      var targets = jQuery(target, this),\n      l = targets.length;\n\n      return this.filter(function () {\n        var i = 0;\n        for (; i < l; i++) {\n          if (jQuery.contains(this, targets[i])) {\n            return true;\n          }\n        }\n      });\n    },\n\n    closest: function closest(selectors, context) {\n      var cur,\n      i = 0,\n      l = this.length,\n      matched = [],\n      targets = typeof selectors !== \"string\" && jQuery(selectors);\n\n      // Positional selectors never match, since there's no _selection_ context\n      if (!rneedsContext.test(selectors)) {\n        for (; i < l; i++) {\n          for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {\n\n            // Always skip document fragments\n            if (cur.nodeType < 11 && (targets ?\n            targets.index(cur) > -1 :\n\n            // Don't pass non-elements to Sizzle\n            cur.nodeType === 1 &&\n            jQuery.find.matchesSelector(cur, selectors))) {\n\n              matched.push(cur);\n              break;\n            }\n          }\n        }\n      }\n\n      return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);\n    },\n\n    // Determine the position of an element within the set\n    index: function index(elem) {\n\n      // No argument, return index in parent\n      if (!elem) {\n        return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;\n      }\n\n      // Index in selector\n      if (typeof elem === \"string\") {\n        return indexOf.call(jQuery(elem), this[0]);\n      }\n\n      // Locate the position of the desired element\n      return indexOf.call(this,\n\n      // If it receives a jQuery object, the first element is used\n      elem.jquery ? elem[0] : elem);\n\n    },\n\n    add: function add(selector, context) {\n      return this.pushStack(\n      jQuery.uniqueSort(\n      jQuery.merge(this.get(), jQuery(selector, context))));\n\n\n    },\n\n    addBack: function addBack(selector) {\n      return this.add(selector == null ?\n      this.prevObject : this.prevObject.filter(selector));\n\n    } });\n\n\n  function sibling(cur, dir) {\n    while ((cur = cur[dir]) && cur.nodeType !== 1) {}\n    return cur;\n  }\n\n  jQuery.each({\n    parent: function parent(elem) {\n      var parent = elem.parentNode;\n      return parent && parent.nodeType !== 11 ? parent : null;\n    },\n    parents: function parents(elem) {\n      return dir(elem, \"parentNode\");\n    },\n    parentsUntil: function parentsUntil(elem, _i, until) {\n      return dir(elem, \"parentNode\", until);\n    },\n    next: function next(elem) {\n      return sibling(elem, \"nextSibling\");\n    },\n    prev: function prev(elem) {\n      return sibling(elem, \"previousSibling\");\n    },\n    nextAll: function nextAll(elem) {\n      return dir(elem, \"nextSibling\");\n    },\n    prevAll: function prevAll(elem) {\n      return dir(elem, \"previousSibling\");\n    },\n    nextUntil: function nextUntil(elem, _i, until) {\n      return dir(elem, \"nextSibling\", until);\n    },\n    prevUntil: function prevUntil(elem, _i, until) {\n      return dir(elem, \"previousSibling\", until);\n    },\n    siblings: function siblings(elem) {\n      return _siblings((elem.parentNode || {}).firstChild, elem);\n    },\n    children: function children(elem) {\n      return _siblings(elem.firstChild);\n    },\n    contents: function contents(elem) {\n      if (elem.contentDocument != null &&\n\n      // Support: IE 11+\n      // <object> elements with no `data` attribute has an object\n      // `contentDocument` with a `null` prototype.\n      getProto(elem.contentDocument)) {\n\n        return elem.contentDocument;\n      }\n\n      // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n      // Treat the template element as a regular one in browsers that\n      // don't support it.\n      if (nodeName(elem, \"template\")) {\n        elem = elem.content || elem;\n      }\n\n      return jQuery.merge([], elem.childNodes);\n    } },\n  function (name, fn) {\n    jQuery.fn[name] = function (until, selector) {\n      var matched = jQuery.map(this, fn, until);\n\n      if (name.slice(-5) !== \"Until\") {\n        selector = until;\n      }\n\n      if (selector && typeof selector === \"string\") {\n        matched = jQuery.filter(selector, matched);\n      }\n\n      if (this.length > 1) {\n\n        // Remove duplicates\n        if (!guaranteedUnique[name]) {\n          jQuery.uniqueSort(matched);\n        }\n\n        // Reverse order for parents* and prev-derivatives\n        if (rparentsprev.test(name)) {\n          matched.reverse();\n        }\n      }\n\n      return this.pushStack(matched);\n    };\n  });\n  var rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g;\n\n\n\n  // Convert String-formatted options into Object-formatted ones\n  function createOptions(options) {\n    var object = {};\n    jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {\n      object[flag] = true;\n    });\n    return object;\n  }\n\n  /*\n   * Create a callback list using the following parameters:\n   *\n   *\toptions: an optional list of space-separated options that will change how\n   *\t\t\tthe callback list behaves or a more traditional option object\n   *\n   * By default a callback list will act like an event callback list and can be\n   * \"fired\" multiple times.\n   *\n   * Possible options:\n   *\n   *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n   *\n   *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n   *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n   *\t\t\t\t\tvalues (like a Deferred)\n   *\n   *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n   *\n   *\tstopOnFalse:\tinterrupt callings when a callback returns false\n   *\n   */\n  jQuery.Callbacks = function (options) {\n\n    // Convert options from String-formatted to Object-formatted if needed\n    // (we check in cache first)\n    options = typeof options === \"string\" ?\n    createOptions(options) :\n    jQuery.extend({}, options);\n\n    var // Flag to know if list is currently firing\n    firing,\n\n    // Last fire value for non-forgettable lists\n    memory,\n\n    // Flag to know if list was already fired\n    _fired,\n\n    // Flag to prevent firing\n    _locked,\n\n    // Actual callback list\n    list = [],\n\n    // Queue of execution data for repeatable lists\n    queue = [],\n\n    // Index of currently firing callback (modified by add/remove as needed)\n    firingIndex = -1,\n\n    // Fire callbacks\n    fire = function fire() {\n\n      // Enforce single-firing\n      _locked = _locked || options.once;\n\n      // Execute callbacks for all pending executions,\n      // respecting firingIndex overrides and runtime changes\n      _fired = firing = true;\n      for (; queue.length; firingIndex = -1) {\n        memory = queue.shift();\n        while (++firingIndex < list.length) {\n\n          // Run callback and check for early termination\n          if (list[firingIndex].apply(memory[0], memory[1]) === false &&\n          options.stopOnFalse) {\n\n            // Jump to end and forget the data so .add doesn't re-fire\n            firingIndex = list.length;\n            memory = false;\n          }\n        }\n      }\n\n      // Forget the data if we're done with it\n      if (!options.memory) {\n        memory = false;\n      }\n\n      firing = false;\n\n      // Clean up if we're done firing for good\n      if (_locked) {\n\n        // Keep an empty list if we have data for future add calls\n        if (memory) {\n          list = [];\n\n          // Otherwise, this object is spent\n        } else {\n          list = \"\";\n        }\n      }\n    },\n\n    // Actual Callbacks object\n    self = {\n\n      // Add a callback or a collection of callbacks to the list\n      add: function add() {\n        if (list) {\n\n          // If we have memory from a past run, we should fire after adding\n          if (memory && !firing) {\n            firingIndex = list.length - 1;\n            queue.push(memory);\n          }\n\n          (function add(args) {\n            jQuery.each(args, function (_, arg) {\n              if (isFunction(arg)) {\n                if (!options.unique || !self.has(arg)) {\n                  list.push(arg);\n                }\n              } else if (arg && arg.length && toType(arg) !== \"string\") {\n\n                // Inspect recursively\n                add(arg);\n              }\n            });\n          })(arguments);\n\n          if (memory && !firing) {\n            fire();\n          }\n        }\n        return this;\n      },\n\n      // Remove a callback from the list\n      remove: function remove() {\n        jQuery.each(arguments, function (_, arg) {\n          var index;\n          while ((index = jQuery.inArray(arg, list, index)) > -1) {\n            list.splice(index, 1);\n\n            // Handle firing indexes\n            if (index <= firingIndex) {\n              firingIndex--;\n            }\n          }\n        });\n        return this;\n      },\n\n      // Check if a given callback is in the list.\n      // If no argument is given, return whether or not list has callbacks attached.\n      has: function has(fn) {\n        return fn ?\n        jQuery.inArray(fn, list) > -1 :\n        list.length > 0;\n      },\n\n      // Remove all callbacks from the list\n      empty: function empty() {\n        if (list) {\n          list = [];\n        }\n        return this;\n      },\n\n      // Disable .fire and .add\n      // Abort any current/pending executions\n      // Clear all callbacks and values\n      disable: function disable() {\n        _locked = queue = [];\n        list = memory = \"\";\n        return this;\n      },\n      disabled: function disabled() {\n        return !list;\n      },\n\n      // Disable .fire\n      // Also disable .add unless we have memory (since it would have no effect)\n      // Abort any pending executions\n      lock: function lock() {\n        _locked = queue = [];\n        if (!memory && !firing) {\n          list = memory = \"\";\n        }\n        return this;\n      },\n      locked: function locked() {\n        return !!_locked;\n      },\n\n      // Call all callbacks with the given context and arguments\n      fireWith: function fireWith(context, args) {\n        if (!_locked) {\n          args = args || [];\n          args = [context, args.slice ? args.slice() : args];\n          queue.push(args);\n          if (!firing) {\n            fire();\n          }\n        }\n        return this;\n      },\n\n      // Call all the callbacks with the given arguments\n      fire: function fire() {\n        self.fireWith(this, arguments);\n        return this;\n      },\n\n      // To know if the callbacks have already been called at least once\n      fired: function fired() {\n        return !!_fired;\n      } };\n\n\n    return self;\n  };\n\n\n  function Identity(v) {\n    return v;\n  }\n  function Thrower(ex) {\n    throw ex;\n  }\n\n  function adoptValue(value, resolve, reject, noValue) {\n    var method;\n\n    try {\n\n      // Check for promise aspect first to privilege synchronous behavior\n      if (value && isFunction(method = value.promise)) {\n        method.call(value).done(resolve).fail(reject);\n\n        // Other thenables\n      } else if (value && isFunction(method = value.then)) {\n        method.call(value, resolve, reject);\n\n        // Other non-thenables\n      } else {\n\n        // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n        // * false: [ value ].slice( 0 ) => resolve( value )\n        // * true: [ value ].slice( 1 ) => resolve()\n        resolve.apply(undefined, [value].slice(noValue));\n      }\n\n      // For Promises/A+, convert exceptions into rejections\n      // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n      // Deferred#then to conditionally suppress rejection.\n    } catch (value) {\n\n      // Support: Android 4.0 only\n      // Strict mode functions invoked without .call/.apply get global-object context\n      reject.apply(undefined, [value]);\n    }\n  }\n\n  jQuery.extend({\n\n    Deferred: function Deferred(func) {\n      var tuples = [\n\n      // action, add listener, callbacks,\n      // ... .then handlers, argument index, [final state]\n      [\"notify\", \"progress\", jQuery.Callbacks(\"memory\"),\n      jQuery.Callbacks(\"memory\"), 2],\n      [\"resolve\", \"done\", jQuery.Callbacks(\"once memory\"),\n      jQuery.Callbacks(\"once memory\"), 0, \"resolved\"],\n      [\"reject\", \"fail\", jQuery.Callbacks(\"once memory\"),\n      jQuery.Callbacks(\"once memory\"), 1, \"rejected\"]],\n\n      _state = \"pending\",\n      _promise = {\n        state: function state() {\n          return _state;\n        },\n        always: function always() {\n          deferred.done(arguments).fail(arguments);\n          return this;\n        },\n        \"catch\": function _catch(fn) {\n          return _promise.then(null, fn);\n        },\n\n        // Keep pipe for back-compat\n        pipe: function /* fnDone, fnFail, fnProgress */ pipe() {\n          var fns = arguments;\n\n          return jQuery.Deferred(function (newDefer) {\n            jQuery.each(tuples, function (_i, tuple) {\n\n              // Map tuples (progress, done, fail) to arguments (done, fail, progress)\n              var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]];\n\n              // deferred.progress(function() { bind to newDefer or newDefer.notify })\n              // deferred.done(function() { bind to newDefer or newDefer.resolve })\n              // deferred.fail(function() { bind to newDefer or newDefer.reject })\n              deferred[tuple[1]](function () {\n                var returned = fn && fn.apply(this, arguments);\n                if (returned && isFunction(returned.promise)) {\n                  returned.promise().\n                  progress(newDefer.notify).\n                  done(newDefer.resolve).\n                  fail(newDefer.reject);\n                } else {\n                  newDefer[tuple[0] + \"With\"](\n                  this,\n                  fn ? [returned] : arguments);\n\n                }\n              });\n            });\n            fns = null;\n          }).promise();\n        },\n        then: function then(onFulfilled, onRejected, onProgress) {\n          var maxDepth = 0;\n          function resolve(depth, deferred, handler, special) {\n            return function () {\n              var that = this,\n              args = arguments,\n              mightThrow = function mightThrow() {\n                var returned, then;\n\n                // Support: Promises/A+ section 2.3.3.3.3\n                // https://promisesaplus.com/#point-59\n                // Ignore double-resolution attempts\n                if (depth < maxDepth) {\n                  return;\n                }\n\n                returned = handler.apply(that, args);\n\n                // Support: Promises/A+ section 2.3.1\n                // https://promisesaplus.com/#point-48\n                if (returned === deferred.promise()) {\n                  throw new TypeError(\"Thenable self-resolution\");\n                }\n\n                // Support: Promises/A+ sections 2.3.3.1, 3.5\n                // https://promisesaplus.com/#point-54\n                // https://promisesaplus.com/#point-75\n                // Retrieve `then` only once\n                then = returned && (\n\n                // Support: Promises/A+ section 2.3.4\n                // https://promisesaplus.com/#point-64\n                // Only check objects and functions for thenability\n                _typeof(returned) === \"object\" ||\n                typeof returned === \"function\") &&\n                returned.then;\n\n                // Handle a returned thenable\n                if (isFunction(then)) {\n\n                  // Special processors (notify) just wait for resolution\n                  if (special) {\n                    then.call(\n                    returned,\n                    resolve(maxDepth, deferred, Identity, special),\n                    resolve(maxDepth, deferred, Thrower, special));\n\n\n                    // Normal processors (resolve) also hook into progress\n                  } else {\n\n                    // ...and disregard older resolution values\n                    maxDepth++;\n\n                    then.call(\n                    returned,\n                    resolve(maxDepth, deferred, Identity, special),\n                    resolve(maxDepth, deferred, Thrower, special),\n                    resolve(maxDepth, deferred, Identity,\n                    deferred.notifyWith));\n\n                  }\n\n                  // Handle all other returned values\n                } else {\n\n                  // Only substitute handlers pass on context\n                  // and multiple values (non-spec behavior)\n                  if (handler !== Identity) {\n                    that = undefined;\n                    args = [returned];\n                  }\n\n                  // Process the value(s)\n                  // Default process is resolve\n                  (special || deferred.resolveWith)(that, args);\n                }\n              },\n\n              // Only normal processors (resolve) catch and reject exceptions\n              process = special ?\n              mightThrow :\n              function () {\n                try {\n                  mightThrow();\n                } catch (e) {\n\n                  if (jQuery.Deferred.exceptionHook) {\n                    jQuery.Deferred.exceptionHook(e,\n                    process.stackTrace);\n                  }\n\n                  // Support: Promises/A+ section 2.3.3.3.4.1\n                  // https://promisesaplus.com/#point-61\n                  // Ignore post-resolution exceptions\n                  if (depth + 1 >= maxDepth) {\n\n                    // Only substitute handlers pass on context\n                    // and multiple values (non-spec behavior)\n                    if (handler !== Thrower) {\n                      that = undefined;\n                      args = [e];\n                    }\n\n                    deferred.rejectWith(that, args);\n                  }\n                }\n              };\n\n              // Support: Promises/A+ section 2.3.3.3.1\n              // https://promisesaplus.com/#point-57\n              // Re-resolve promises immediately to dodge false rejection from\n              // subsequent errors\n              if (depth) {\n                process();\n              } else {\n\n                // Call an optional hook to record the stack, in case of exception\n                // since it's otherwise lost when execution goes async\n                if (jQuery.Deferred.getStackHook) {\n                  process.stackTrace = jQuery.Deferred.getStackHook();\n                }\n                window.setTimeout(process);\n              }\n            };\n          }\n\n          return jQuery.Deferred(function (newDefer) {\n\n            // progress_handlers.add( ... )\n            tuples[0][3].add(\n            resolve(\n            0,\n            newDefer,\n            isFunction(onProgress) ?\n            onProgress :\n            Identity,\n            newDefer.notifyWith));\n\n\n\n            // fulfilled_handlers.add( ... )\n            tuples[1][3].add(\n            resolve(\n            0,\n            newDefer,\n            isFunction(onFulfilled) ?\n            onFulfilled :\n            Identity));\n\n\n\n            // rejected_handlers.add( ... )\n            tuples[2][3].add(\n            resolve(\n            0,\n            newDefer,\n            isFunction(onRejected) ?\n            onRejected :\n            Thrower));\n\n\n          }).promise();\n        },\n\n        // Get a promise for this deferred\n        // If obj is provided, the promise aspect is added to the object\n        promise: function promise(obj) {\n          return obj != null ? jQuery.extend(obj, _promise) : _promise;\n        } },\n\n      deferred = {};\n\n      // Add list-specific methods\n      jQuery.each(tuples, function (i, tuple) {\n        var list = tuple[2],\n        stateString = tuple[5];\n\n        // promise.progress = list.add\n        // promise.done = list.add\n        // promise.fail = list.add\n        _promise[tuple[1]] = list.add;\n\n        // Handle state\n        if (stateString) {\n          list.add(\n          function () {\n\n            // state = \"resolved\" (i.e., fulfilled)\n            // state = \"rejected\"\n            _state = stateString;\n          },\n\n          // rejected_callbacks.disable\n          // fulfilled_callbacks.disable\n          tuples[3 - i][2].disable,\n\n          // rejected_handlers.disable\n          // fulfilled_handlers.disable\n          tuples[3 - i][3].disable,\n\n          // progress_callbacks.lock\n          tuples[0][2].lock,\n\n          // progress_handlers.lock\n          tuples[0][3].lock);\n\n        }\n\n        // progress_handlers.fire\n        // fulfilled_handlers.fire\n        // rejected_handlers.fire\n        list.add(tuple[3].fire);\n\n        // deferred.notify = function() { deferred.notifyWith(...) }\n        // deferred.resolve = function() { deferred.resolveWith(...) }\n        // deferred.reject = function() { deferred.rejectWith(...) }\n        deferred[tuple[0]] = function () {\n          deferred[tuple[0] + \"With\"](this === deferred ? undefined : this, arguments);\n          return this;\n        };\n\n        // deferred.notifyWith = list.fireWith\n        // deferred.resolveWith = list.fireWith\n        // deferred.rejectWith = list.fireWith\n        deferred[tuple[0] + \"With\"] = list.fireWith;\n      });\n\n      // Make the deferred a promise\n      _promise.promise(deferred);\n\n      // Call given func if any\n      if (func) {\n        func.call(deferred, deferred);\n      }\n\n      // All done!\n      return deferred;\n    },\n\n    // Deferred helper\n    when: function when(singleValue) {\n      var\n\n      // count of uncompleted subordinates\n      remaining = arguments.length,\n\n      // count of unprocessed arguments\n      i = remaining,\n\n      // subordinate fulfillment data\n      resolveContexts = Array(i),\n      resolveValues = _slice.call(arguments),\n\n      // the master Deferred\n      master = jQuery.Deferred(),\n\n      // subordinate callback factory\n      updateFunc = function updateFunc(i) {\n        return function (value) {\n          resolveContexts[i] = this;\n          resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value;\n          if (! --remaining) {\n            master.resolveWith(resolveContexts, resolveValues);\n          }\n        };\n      };\n\n      // Single- and empty arguments are adopted like Promise.resolve\n      if (remaining <= 1) {\n        adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject,\n        !remaining);\n\n        // Use .then() to unwrap secondary thenables (cf. gh-3000)\n        if (master.state() === \"pending\" ||\n        isFunction(resolveValues[i] && resolveValues[i].then)) {\n\n          return master.then();\n        }\n      }\n\n      // Multiple arguments are aggregated like Promise.all array elements\n      while (i--) {\n        adoptValue(resolveValues[i], updateFunc(i), master.reject);\n      }\n\n      return master.promise();\n    } });\n\n\n\n  // These usually indicate a programmer mistake during development,\n  // warn about them ASAP rather than swallowing them by default.\n  var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n  jQuery.Deferred.exceptionHook = function (error, stack) {\n\n    // Support: IE 8 - 9 only\n    // Console exists when dev tools are open, which can happen at any time\n    if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {\n      window.console.warn(\"jQuery.Deferred exception: \" + error.message, error.stack, stack);\n    }\n  };\n\n\n\n\n  jQuery.readyException = function (error) {\n    window.setTimeout(function () {\n      throw error;\n    });\n  };\n\n\n\n\n  // The deferred used on DOM ready\n  var readyList = jQuery.Deferred();\n\n  jQuery.fn.ready = function (fn) {\n\n    readyList.\n    then(fn)\n\n    // Wrap jQuery.readyException in a function so that the lookup\n    // happens at the time of error handling instead of callback\n    // registration.\n    [\"catch\"](function (error) {\n      jQuery.readyException(error);\n    });\n\n    return this;\n  };\n\n  jQuery.extend({\n\n    // Is the DOM ready to be used? Set to true once it occurs.\n    isReady: false,\n\n    // A counter to track how many items to wait for before\n    // the ready event fires. See #6781\n    readyWait: 1,\n\n    // Handle when the DOM is ready\n    ready: function ready(wait) {\n\n      // Abort if there are pending holds or we're already ready\n      if (wait === true ? --jQuery.readyWait : jQuery.isReady) {\n        return;\n      }\n\n      // Remember that the DOM is ready\n      jQuery.isReady = true;\n\n      // If a normal DOM Ready event fired, decrement, and wait if need be\n      if (wait !== true && --jQuery.readyWait > 0) {\n        return;\n      }\n\n      // If there are functions bound, to execute\n      readyList.resolveWith(document, [jQuery]);\n    } });\n\n\n  jQuery.ready.then = readyList.then;\n\n  // The ready event handler and self cleanup method\n  function completed() {\n    document.removeEventListener(\"DOMContentLoaded\", completed);\n    window.removeEventListener(\"load\", completed);\n    jQuery.ready();\n  }\n\n  // Catch cases where $(document).ready() is called\n  // after the browser event has already occurred.\n  // Support: IE <=9 - 10 only\n  // Older IE sometimes signals \"interactive\" too soon\n  if (document.readyState === \"complete\" ||\n  document.readyState !== \"loading\" && !document.documentElement.doScroll) {\n\n    // Handle it asynchronously to allow scripts the opportunity to delay ready\n    window.setTimeout(jQuery.ready);\n\n  } else {\n\n    // Use the handy event callback\n    document.addEventListener(\"DOMContentLoaded\", completed);\n\n    // A fallback to window.onload, that will always work\n    window.addEventListener(\"load\", completed);\n  }\n\n\n\n\n  // Multifunctional method to get and set values of a collection\n  // The value/s can optionally be executed if it's a function\n  var access = function access(elems, fn, key, value, chainable, emptyGet, raw) {\n    var i = 0,\n    len = elems.length,\n    bulk = key == null;\n\n    // Sets many values\n    if (toType(key) === \"object\") {\n      chainable = true;\n      for (i in key) {\n        access(elems, fn, i, key[i], true, emptyGet, raw);\n      }\n\n      // Sets one value\n    } else if (value !== undefined) {\n      chainable = true;\n\n      if (!isFunction(value)) {\n        raw = true;\n      }\n\n      if (bulk) {\n\n        // Bulk operations run against the entire set\n        if (raw) {\n          fn.call(elems, value);\n          fn = null;\n\n          // ...except when executing function values\n        } else {\n          bulk = fn;\n          fn = function fn(elem, _key, value) {\n            return bulk.call(jQuery(elem), value);\n          };\n        }\n      }\n\n      if (fn) {\n        for (; i < len; i++) {\n          fn(\n          elems[i], key, raw ?\n          value :\n          value.call(elems[i], i, fn(elems[i], key)));\n\n        }\n      }\n    }\n\n    if (chainable) {\n      return elems;\n    }\n\n    // Gets\n    if (bulk) {\n      return fn.call(elems);\n    }\n\n    return len ? fn(elems[0], key) : emptyGet;\n  };\n\n\n  // Matches dashed string for camelizing\n  var rmsPrefix = /^-ms-/,\n  rdashAlpha = /-([a-z])/g;\n\n  // Used by camelCase as callback to replace()\n  function fcamelCase(_all, letter) {\n    return letter.toUpperCase();\n  }\n\n  // Convert dashed to camelCase; used by the css and data modules\n  // Support: IE <=9 - 11, Edge 12 - 15\n  // Microsoft forgot to hump their vendor prefix (#9572)\n  function camelCase(string) {\n    return string.replace(rmsPrefix, \"ms-\").replace(rdashAlpha, fcamelCase);\n  }\n  var acceptData = function acceptData(owner) {\n\n    // Accepts only:\n    //  - Node\n    //    - Node.ELEMENT_NODE\n    //    - Node.DOCUMENT_NODE\n    //  - Object\n    //    - Any\n    return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;\n  };\n\n\n\n\n  function Data() {\n    this.expando = jQuery.expando + Data.uid++;\n  }\n\n  Data.uid = 1;\n\n  Data.prototype = {\n\n    cache: function cache(owner) {\n\n      // Check if the owner object already has a cache\n      var value = owner[this.expando];\n\n      // If not, create one\n      if (!value) {\n        value = Object.create(null);\n\n        // We can accept data for non-element nodes in modern browsers,\n        // but we should not, see #8335.\n        // Always return an empty object.\n        if (acceptData(owner)) {\n\n          // If it is a node unlikely to be stringify-ed or looped over\n          // use plain assignment\n          if (owner.nodeType) {\n            owner[this.expando] = value;\n\n            // Otherwise secure it in a non-enumerable property\n            // configurable must be true to allow the property to be\n            // deleted when data is removed\n          } else {\n            Object.defineProperty(owner, this.expando, {\n              value: value,\n              configurable: true });\n\n          }\n        }\n      }\n\n      return value;\n    },\n    set: function set(owner, data, value) {\n      var prop,\n      cache = this.cache(owner);\n\n      // Handle: [ owner, key, value ] args\n      // Always use camelCase key (gh-2257)\n      if (typeof data === \"string\") {\n        cache[camelCase(data)] = value;\n\n        // Handle: [ owner, { properties } ] args\n      } else {\n\n        // Copy the properties one-by-one to the cache object\n        for (prop in data) {\n          cache[camelCase(prop)] = data[prop];\n        }\n      }\n      return cache;\n    },\n    get: function get(owner, key) {\n      return key === undefined ?\n      this.cache(owner) :\n\n      // Always use camelCase key (gh-2257)\n      owner[this.expando] && owner[this.expando][camelCase(key)];\n    },\n    access: function access(owner, key, value) {\n\n      // In cases where either:\n      //\n      //   1. No key was specified\n      //   2. A string key was specified, but no value provided\n      //\n      // Take the \"read\" path and allow the get method to determine\n      // which value to return, respectively either:\n      //\n      //   1. The entire cache object\n      //   2. The data stored at the key\n      //\n      if (key === undefined ||\n      key && typeof key === \"string\" && value === undefined) {\n\n        return this.get(owner, key);\n      }\n\n      // When the key is not a string, or both a key and value\n      // are specified, set or extend (existing objects) with either:\n      //\n      //   1. An object of properties\n      //   2. A key and value\n      //\n      this.set(owner, key, value);\n\n      // Since the \"set\" path can have two possible entry points\n      // return the expected data based on which path was taken[*]\n      return value !== undefined ? value : key;\n    },\n    remove: function remove(owner, key) {\n      var i,\n      cache = owner[this.expando];\n\n      if (cache === undefined) {\n        return;\n      }\n\n      if (key !== undefined) {\n\n        // Support array or space separated string of keys\n        if (Array.isArray(key)) {\n\n          // If key is an array of keys...\n          // We always set camelCase keys, so remove that.\n          key = key.map(camelCase);\n        } else {\n          key = camelCase(key);\n\n          // If a key with the spaces exists, use it.\n          // Otherwise, create an array by matching non-whitespace\n          key = key in cache ?\n          [key] :\n          key.match(rnothtmlwhite) || [];\n        }\n\n        i = key.length;\n\n        while (i--) {\n          delete cache[key[i]];\n        }\n      }\n\n      // Remove the expando if there's no more data\n      if (key === undefined || jQuery.isEmptyObject(cache)) {\n\n        // Support: Chrome <=35 - 45\n        // Webkit & Blink performance suffers when deleting properties\n        // from DOM nodes, so set to undefined instead\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n        if (owner.nodeType) {\n          owner[this.expando] = undefined;\n        } else {\n          delete owner[this.expando];\n        }\n      }\n    },\n    hasData: function hasData(owner) {\n      var cache = owner[this.expando];\n      return cache !== undefined && !jQuery.isEmptyObject(cache);\n    } };\n\n  var dataPriv = new Data();\n\n  var dataUser = new Data();\n\n\n\n  //\tImplementation Summary\n  //\n  //\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n  //\t2. Improve the module's maintainability by reducing the storage\n  //\t\tpaths to a single mechanism.\n  //\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n  //\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n  //\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n  //\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\n  var rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n  rmultiDash = /[A-Z]/g;\n\n  function getData(data) {\n    if (data === \"true\") {\n      return true;\n    }\n\n    if (data === \"false\") {\n      return false;\n    }\n\n    if (data === \"null\") {\n      return null;\n    }\n\n    // Only convert to a number if it doesn't change the string\n    if (data === +data + \"\") {\n      return +data;\n    }\n\n    if (rbrace.test(data)) {\n      return JSON.parse(data);\n    }\n\n    return data;\n  }\n\n  function dataAttr(elem, key, data) {\n    var name;\n\n    // If nothing was found internally, try to fetch any\n    // data from the HTML5 data-* attribute\n    if (data === undefined && elem.nodeType === 1) {\n      name = \"data-\" + key.replace(rmultiDash, \"-$&\").toLowerCase();\n      data = elem.getAttribute(name);\n\n      if (typeof data === \"string\") {\n        try {\n          data = getData(data);\n        } catch (e) {}\n\n        // Make sure we set the data so it isn't changed later\n        dataUser.set(elem, key, data);\n      } else {\n        data = undefined;\n      }\n    }\n    return data;\n  }\n\n  jQuery.extend({\n    hasData: function hasData(elem) {\n      return dataUser.hasData(elem) || dataPriv.hasData(elem);\n    },\n\n    data: function data(elem, name, _data) {\n      return dataUser.access(elem, name, _data);\n    },\n\n    removeData: function removeData(elem, name) {\n      dataUser.remove(elem, name);\n    },\n\n    // TODO: Now that all calls to _data and _removeData have been replaced\n    // with direct calls to dataPriv methods, these can be deprecated.\n    _data: function _data(elem, name, data) {\n      return dataPriv.access(elem, name, data);\n    },\n\n    _removeData: function _removeData(elem, name) {\n      dataPriv.remove(elem, name);\n    } });\n\n\n  jQuery.fn.extend({\n    data: function data(key, value) {\n      var i,name,data,\n      elem = this[0],\n      attrs = elem && elem.attributes;\n\n      // Gets all values\n      if (key === undefined) {\n        if (this.length) {\n          data = dataUser.get(elem);\n\n          if (elem.nodeType === 1 && !dataPriv.get(elem, \"hasDataAttrs\")) {\n            i = attrs.length;\n            while (i--) {\n\n              // Support: IE 11 only\n              // The attrs elements can be null (#14894)\n              if (attrs[i]) {\n                name = attrs[i].name;\n                if (name.indexOf(\"data-\") === 0) {\n                  name = camelCase(name.slice(5));\n                  dataAttr(elem, name, data[name]);\n                }\n              }\n            }\n            dataPriv.set(elem, \"hasDataAttrs\", true);\n          }\n        }\n\n        return data;\n      }\n\n      // Sets multiple values\n      if (_typeof(key) === \"object\") {\n        return this.each(function () {\n          dataUser.set(this, key);\n        });\n      }\n\n      return access(this, function (value) {\n        var data;\n\n        // The calling jQuery object (element matches) is not empty\n        // (and therefore has an element appears at this[ 0 ]) and the\n        // `value` parameter was not undefined. An empty jQuery object\n        // will result in `undefined` for elem = this[ 0 ] which will\n        // throw an exception if an attempt to read a data cache is made.\n        if (elem && value === undefined) {\n\n          // Attempt to get data from the cache\n          // The key will always be camelCased in Data\n          data = dataUser.get(elem, key);\n          if (data !== undefined) {\n            return data;\n          }\n\n          // Attempt to \"discover\" the data in\n          // HTML5 custom data-* attrs\n          data = dataAttr(elem, key);\n          if (data !== undefined) {\n            return data;\n          }\n\n          // We tried really hard, but the data doesn't exist.\n          return;\n        }\n\n        // Set the data...\n        this.each(function () {\n\n          // We always store the camelCased key\n          dataUser.set(this, key, value);\n        });\n      }, null, value, arguments.length > 1, null, true);\n    },\n\n    removeData: function removeData(key) {\n      return this.each(function () {\n        dataUser.remove(this, key);\n      });\n    } });\n\n\n\n  jQuery.extend({\n    queue: function queue(elem, type, data) {\n      var queue;\n\n      if (elem) {\n        type = (type || \"fx\") + \"queue\";\n        queue = dataPriv.get(elem, type);\n\n        // Speed up dequeue by getting out quickly if this is just a lookup\n        if (data) {\n          if (!queue || Array.isArray(data)) {\n            queue = dataPriv.access(elem, type, jQuery.makeArray(data));\n          } else {\n            queue.push(data);\n          }\n        }\n        return queue || [];\n      }\n    },\n\n    dequeue: function dequeue(elem, type) {\n      type = type || \"fx\";\n\n      var queue = jQuery.queue(elem, type),\n      startLength = queue.length,\n      fn = queue.shift(),\n      hooks = jQuery._queueHooks(elem, type),\n      next = function next() {\n        jQuery.dequeue(elem, type);\n      };\n\n      // If the fx queue is dequeued, always remove the progress sentinel\n      if (fn === \"inprogress\") {\n        fn = queue.shift();\n        startLength--;\n      }\n\n      if (fn) {\n\n        // Add a progress sentinel to prevent the fx queue from being\n        // automatically dequeued\n        if (type === \"fx\") {\n          queue.unshift(\"inprogress\");\n        }\n\n        // Clear up the last queue stop function\n        delete hooks.stop;\n        fn.call(elem, next, hooks);\n      }\n\n      if (!startLength && hooks) {\n        hooks.empty.fire();\n      }\n    },\n\n    // Not public - generate a queueHooks object, or return the current one\n    _queueHooks: function _queueHooks(elem, type) {\n      var key = type + \"queueHooks\";\n      return dataPriv.get(elem, key) || dataPriv.access(elem, key, {\n        empty: jQuery.Callbacks(\"once memory\").add(function () {\n          dataPriv.remove(elem, [type + \"queue\", key]);\n        }) });\n\n    } });\n\n\n  jQuery.fn.extend({\n    queue: function queue(type, data) {\n      var setter = 2;\n\n      if (typeof type !== \"string\") {\n        data = type;\n        type = \"fx\";\n        setter--;\n      }\n\n      if (arguments.length < setter) {\n        return jQuery.queue(this[0], type);\n      }\n\n      return data === undefined ?\n      this :\n      this.each(function () {\n        var queue = jQuery.queue(this, type, data);\n\n        // Ensure a hooks for this queue\n        jQuery._queueHooks(this, type);\n\n        if (type === \"fx\" && queue[0] !== \"inprogress\") {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    dequeue: function dequeue(type) {\n      return this.each(function () {\n        jQuery.dequeue(this, type);\n      });\n    },\n    clearQueue: function clearQueue(type) {\n      return this.queue(type || \"fx\", []);\n    },\n\n    // Get a promise resolved when queues of a certain type\n    // are emptied (fx is the type by default)\n    promise: function promise(type, obj) {\n      var tmp,\n      count = 1,\n      defer = jQuery.Deferred(),\n      elements = this,\n      i = this.length,\n      resolve = function resolve() {\n        if (! --count) {\n          defer.resolveWith(elements, [elements]);\n        }\n      };\n\n      if (typeof type !== \"string\") {\n        obj = type;\n        type = undefined;\n      }\n      type = type || \"fx\";\n\n      while (i--) {\n        tmp = dataPriv.get(elements[i], type + \"queueHooks\");\n        if (tmp && tmp.empty) {\n          count++;\n          tmp.empty.add(resolve);\n        }\n      }\n      resolve();\n      return defer.promise(obj);\n    } });\n\n  var pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source;\n\n  var rcssNum = new RegExp(\"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\");\n\n\n  var cssExpand = [\"Top\", \"Right\", \"Bottom\", \"Left\"];\n\n  var documentElement = document.documentElement;\n\n\n\n  var isAttached = function isAttached(elem) {\n    return jQuery.contains(elem.ownerDocument, elem);\n  },\n  composed = { composed: true };\n\n  // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n  // Check attachment across shadow DOM boundaries when possible (gh-3504)\n  // Support: iOS 10.0-10.2 only\n  // Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n  // leading to errors. We need to check for `getRootNode`.\n  if (documentElement.getRootNode) {\n    isAttached = function isAttached(elem) {\n      return jQuery.contains(elem.ownerDocument, elem) ||\n      elem.getRootNode(composed) === elem.ownerDocument;\n    };\n  }\n  var isHiddenWithinTree = function isHiddenWithinTree(elem, el) {\n\n    // isHiddenWithinTree might be called from jQuery#filter function;\n    // in that case, element will be second argument\n    elem = el || elem;\n\n    // Inline style trumps all\n    return elem.style.display === \"none\" ||\n    elem.style.display === \"\" &&\n\n    // Otherwise, check computed style\n    // Support: Firefox <=43 - 45\n    // Disconnected elements can have computed display: none, so first confirm that elem is\n    // in the document.\n    isAttached(elem) &&\n\n    jQuery.css(elem, \"display\") === \"none\";\n  };\n\n\n\n  function adjustCSS(elem, prop, valueParts, tween) {\n    var adjusted,scale,\n    maxIterations = 20,\n    currentValue = tween ?\n    function () {\n      return tween.cur();\n    } :\n    function () {\n      return jQuery.css(elem, prop, \"\");\n    },\n    initial = currentValue(),\n    unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? \"\" : \"px\"),\n\n    // Starting value computation is required for potential unit mismatches\n    initialInUnit = elem.nodeType && (\n    jQuery.cssNumber[prop] || unit !== \"px\" && +initial) &&\n    rcssNum.exec(jQuery.css(elem, prop));\n\n    if (initialInUnit && initialInUnit[3] !== unit) {\n\n      // Support: Firefox <=54\n      // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n      initial = initial / 2;\n\n      // Trust units reported by jQuery.css\n      unit = unit || initialInUnit[3];\n\n      // Iteratively approximate from a nonzero starting point\n      initialInUnit = +initial || 1;\n\n      while (maxIterations--) {\n\n        // Evaluate and update our best guess (doubling guesses that zero out).\n        // Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n        jQuery.style(elem, prop, initialInUnit + unit);\n        if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {\n          maxIterations = 0;\n        }\n        initialInUnit = initialInUnit / scale;\n\n      }\n\n      initialInUnit = initialInUnit * 2;\n      jQuery.style(elem, prop, initialInUnit + unit);\n\n      // Make sure we update the tween properties later on\n      valueParts = valueParts || [];\n    }\n\n    if (valueParts) {\n      initialInUnit = +initialInUnit || +initial || 0;\n\n      // Apply relative offset (+=/-=) if specified\n      adjusted = valueParts[1] ?\n      initialInUnit + (valueParts[1] + 1) * valueParts[2] :\n      +valueParts[2];\n      if (tween) {\n        tween.unit = unit;\n        tween.start = initialInUnit;\n        tween.end = adjusted;\n      }\n    }\n    return adjusted;\n  }\n\n\n  var defaultDisplayMap = {};\n\n  function getDefaultDisplay(elem) {\n    var temp,\n    doc = elem.ownerDocument,\n    nodeName = elem.nodeName,\n    display = defaultDisplayMap[nodeName];\n\n    if (display) {\n      return display;\n    }\n\n    temp = doc.body.appendChild(doc.createElement(nodeName));\n    display = jQuery.css(temp, \"display\");\n\n    temp.parentNode.removeChild(temp);\n\n    if (display === \"none\") {\n      display = \"block\";\n    }\n    defaultDisplayMap[nodeName] = display;\n\n    return display;\n  }\n\n  function showHide(elements, show) {\n    var display,elem,\n    values = [],\n    index = 0,\n    length = elements.length;\n\n    // Determine new display value for elements that need to change\n    for (; index < length; index++) {\n      elem = elements[index];\n      if (!elem.style) {\n        continue;\n      }\n\n      display = elem.style.display;\n      if (show) {\n\n        // Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n        // check is required in this first loop unless we have a nonempty display value (either\n        // inline or about-to-be-restored)\n        if (display === \"none\") {\n          values[index] = dataPriv.get(elem, \"display\") || null;\n          if (!values[index]) {\n            elem.style.display = \"\";\n          }\n        }\n        if (elem.style.display === \"\" && isHiddenWithinTree(elem)) {\n          values[index] = getDefaultDisplay(elem);\n        }\n      } else {\n        if (display !== \"none\") {\n          values[index] = \"none\";\n\n          // Remember what we're overwriting\n          dataPriv.set(elem, \"display\", display);\n        }\n      }\n    }\n\n    // Set the display of the elements in a second loop to avoid constant reflow\n    for (index = 0; index < length; index++) {\n      if (values[index] != null) {\n        elements[index].style.display = values[index];\n      }\n    }\n\n    return elements;\n  }\n\n  jQuery.fn.extend({\n    show: function show() {\n      return showHide(this, true);\n    },\n    hide: function hide() {\n      return showHide(this);\n    },\n    toggle: function toggle(state) {\n      if (typeof state === \"boolean\") {\n        return state ? this.show() : this.hide();\n      }\n\n      return this.each(function () {\n        if (isHiddenWithinTree(this)) {\n          jQuery(this).show();\n        } else {\n          jQuery(this).hide();\n        }\n      });\n    } });\n\n  var rcheckableType = /^(?:checkbox|radio)$/i;\n\n  var rtagName = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i;\n\n  var rscriptType = /^$|^module$|\\/(?:java|ecma)script/i;\n\n\n\n  (function () {\n    var fragment = document.createDocumentFragment(),\n    div = fragment.appendChild(document.createElement(\"div\")),\n    input = document.createElement(\"input\");\n\n    // Support: Android 4.0 - 4.3 only\n    // Check state lost if the name is set (#11217)\n    // Support: Windows Web Apps (WWA)\n    // `name` and `type` must use .setAttribute for WWA (#14901)\n    input.setAttribute(\"type\", \"radio\");\n    input.setAttribute(\"checked\", \"checked\");\n    input.setAttribute(\"name\", \"t\");\n\n    div.appendChild(input);\n\n    // Support: Android <=4.1 only\n    // Older WebKit doesn't clone checked state correctly in fragments\n    support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;\n\n    // Support: IE <=11 only\n    // Make sure textarea (and checkbox) defaultValue is properly cloned\n    div.innerHTML = \"<textarea>x</textarea>\";\n    support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;\n\n    // Support: IE <=9 only\n    // IE <=9 replaces <option> tags with their contents when inserted outside of\n    // the select element.\n    div.innerHTML = \"<option></option>\";\n    support.option = !!div.lastChild;\n  })();\n\n\n  // We have to close these tags to support XHTML (#13200)\n  var wrapMap = {\n\n    // XHTML parsers do not magically insert elements in the\n    // same way that tag soup parsers do. So we cannot shorten\n    // this by omitting <tbody> or other required elements.\n    thead: [1, \"<table>\", \"</table>\"],\n    col: [2, \"<table><colgroup>\", \"</colgroup></table>\"],\n    tr: [2, \"<table><tbody>\", \"</tbody></table>\"],\n    td: [3, \"<table><tbody><tr>\", \"</tr></tbody></table>\"],\n\n    _default: [0, \"\", \"\"] };\n\n\n  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\n  wrapMap.th = wrapMap.td;\n\n  // Support: IE <=9 only\n  if (!support.option) {\n    wrapMap.optgroup = wrapMap.option = [1, \"<select multiple='multiple'>\", \"</select>\"];\n  }\n\n\n  function getAll(context, tag) {\n\n    // Support: IE <=9 - 11 only\n    // Use typeof to avoid zero-argument method invocation on host objects (#15151)\n    var ret;\n\n    if (typeof context.getElementsByTagName !== \"undefined\") {\n      ret = context.getElementsByTagName(tag || \"*\");\n\n    } else if (typeof context.querySelectorAll !== \"undefined\") {\n      ret = context.querySelectorAll(tag || \"*\");\n\n    } else {\n      ret = [];\n    }\n\n    if (tag === undefined || tag && nodeName(context, tag)) {\n      return jQuery.merge([context], ret);\n    }\n\n    return ret;\n  }\n\n\n  // Mark scripts as having already been evaluated\n  function setGlobalEval(elems, refElements) {\n    var i = 0,\n    l = elems.length;\n\n    for (; i < l; i++) {\n      dataPriv.set(\n      elems[i],\n      \"globalEval\",\n      !refElements || dataPriv.get(refElements[i], \"globalEval\"));\n\n    }\n  }\n\n\n  var rhtml = /<|&#?\\w+;/;\n\n  function buildFragment(elems, context, scripts, selection, ignored) {\n    var elem,tmp,tag,wrap,attached,j,\n    fragment = context.createDocumentFragment(),\n    nodes = [],\n    i = 0,\n    l = elems.length;\n\n    for (; i < l; i++) {\n      elem = elems[i];\n\n      if (elem || elem === 0) {\n\n        // Add nodes directly\n        if (toType(elem) === \"object\") {\n\n          // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n          jQuery.merge(nodes, elem.nodeType ? [elem] : elem);\n\n          // Convert non-html into a text node\n        } else if (!rhtml.test(elem)) {\n          nodes.push(context.createTextNode(elem));\n\n          // Convert html into DOM nodes\n        } else {\n          tmp = tmp || fragment.appendChild(context.createElement(\"div\"));\n\n          // Deserialize a standard representation\n          tag = (rtagName.exec(elem) || [\"\", \"\"])[1].toLowerCase();\n          wrap = wrapMap[tag] || wrapMap._default;\n          tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];\n\n          // Descend through wrappers to the right content\n          j = wrap[0];\n          while (j--) {\n            tmp = tmp.lastChild;\n          }\n\n          // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n          jQuery.merge(nodes, tmp.childNodes);\n\n          // Remember the top-level container\n          tmp = fragment.firstChild;\n\n          // Ensure the created nodes are orphaned (#12392)\n          tmp.textContent = \"\";\n        }\n      }\n    }\n\n    // Remove wrapper from fragment\n    fragment.textContent = \"\";\n\n    i = 0;\n    while (elem = nodes[i++]) {\n\n      // Skip elements already in the context collection (trac-4087)\n      if (selection && jQuery.inArray(elem, selection) > -1) {\n        if (ignored) {\n          ignored.push(elem);\n        }\n        continue;\n      }\n\n      attached = isAttached(elem);\n\n      // Append to fragment\n      tmp = getAll(fragment.appendChild(elem), \"script\");\n\n      // Preserve script evaluation history\n      if (attached) {\n        setGlobalEval(tmp);\n      }\n\n      // Capture executables\n      if (scripts) {\n        j = 0;\n        while (elem = tmp[j++]) {\n          if (rscriptType.test(elem.type || \"\")) {\n            scripts.push(elem);\n          }\n        }\n      }\n    }\n\n    return fragment;\n  }\n\n\n  var\n  rkeyEvent = /^key/,\n  rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n  rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\n  function returnTrue() {\n    return true;\n  }\n\n  function returnFalse() {\n    return false;\n  }\n\n  // Support: IE <=9 - 11+\n  // focus() and blur() are asynchronous, except when they are no-op.\n  // So expect focus to be synchronous when the element is already active,\n  // and blur to be synchronous when the element is not already active.\n  // (focus and blur are always synchronous in other supported browsers,\n  // this just defines when we can count on it).\n  function expectSync(elem, type) {\n    return elem === safeActiveElement() === (type === \"focus\");\n  }\n\n  // Support: IE <=9 only\n  // Accessing document.activeElement can throw unexpectedly\n  // https://bugs.jquery.com/ticket/13393\n  function safeActiveElement() {\n    try {\n      return document.activeElement;\n    } catch (err) {}\n  }\n\n  function _on(elem, types, selector, data, fn, one) {\n    var origFn, type;\n\n    // Types can be a map of types/handlers\n    if (_typeof(types) === \"object\") {\n\n      // ( types-Object, selector, data )\n      if (typeof selector !== \"string\") {\n\n        // ( types-Object, data )\n        data = data || selector;\n        selector = undefined;\n      }\n      for (type in types) {\n        _on(elem, type, selector, data, types[type], one);\n      }\n      return elem;\n    }\n\n    if (data == null && fn == null) {\n\n      // ( types, fn )\n      fn = selector;\n      data = selector = undefined;\n    } else if (fn == null) {\n      if (typeof selector === \"string\") {\n\n        // ( types, selector, fn )\n        fn = data;\n        data = undefined;\n      } else {\n\n        // ( types, data, fn )\n        fn = data;\n        data = selector;\n        selector = undefined;\n      }\n    }\n    if (fn === false) {\n      fn = returnFalse;\n    } else if (!fn) {\n      return elem;\n    }\n\n    if (one === 1) {\n      origFn = fn;\n      fn = function fn(event) {\n\n        // Can use an empty set, since event contains the info\n        jQuery().off(event);\n        return origFn.apply(this, arguments);\n      };\n\n      // Use same guid so caller can remove using origFn\n      fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);\n    }\n    return elem.each(function () {\n      jQuery.event.add(this, types, fn, data, selector);\n    });\n  }\n\n  /*\n   * Helper functions for managing events -- not part of the public interface.\n   * Props to Dean Edwards' addEvent library for many of the ideas.\n   */\n  jQuery.event = {\n\n    global: {},\n\n    add: function add(elem, types, handler, data, selector) {\n\n      var handleObjIn,eventHandle,tmp,\n      events,t,handleObj,\n      special,handlers,type,namespaces,origType,\n      elemData = dataPriv.get(elem);\n\n      // Only attach events to objects that accept data\n      if (!acceptData(elem)) {\n        return;\n      }\n\n      // Caller can pass in an object of custom data in lieu of the handler\n      if (handler.handler) {\n        handleObjIn = handler;\n        handler = handleObjIn.handler;\n        selector = handleObjIn.selector;\n      }\n\n      // Ensure that invalid selectors throw exceptions at attach time\n      // Evaluate against documentElement in case elem is a non-element node (e.g., document)\n      if (selector) {\n        jQuery.find.matchesSelector(documentElement, selector);\n      }\n\n      // Make sure that the handler has a unique ID, used to find/remove it later\n      if (!handler.guid) {\n        handler.guid = jQuery.guid++;\n      }\n\n      // Init the element's event structure and main handler, if this is the first\n      if (!(events = elemData.events)) {\n        events = elemData.events = Object.create(null);\n      }\n      if (!(eventHandle = elemData.handle)) {\n        eventHandle = elemData.handle = function (e) {\n\n          // Discard the second event of a jQuery.event.trigger() and\n          // when an event is called after a page has unloaded\n          return typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n          jQuery.event.dispatch.apply(elem, arguments) : undefined;\n        };\n      }\n\n      // Handle multiple events separated by a space\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort();\n\n        // There *must* be a type, no attaching namespace-only handlers\n        if (!type) {\n          continue;\n        }\n\n        // If event changes its type, use the special event handlers for the changed type\n        special = jQuery.event.special[type] || {};\n\n        // If selector defined, determine special event api type, otherwise given type\n        type = (selector ? special.delegateType : special.bindType) || type;\n\n        // Update special based on newly reset type\n        special = jQuery.event.special[type] || {};\n\n        // handleObj is passed to all event handlers\n        handleObj = jQuery.extend({\n          type: type,\n          origType: origType,\n          data: data,\n          handler: handler,\n          guid: handler.guid,\n          selector: selector,\n          needsContext: selector && jQuery.expr.match.needsContext.test(selector),\n          namespace: namespaces.join(\".\") },\n        handleObjIn);\n\n        // Init the event handler queue if we're the first\n        if (!(handlers = events[type])) {\n          handlers = events[type] = [];\n          handlers.delegateCount = 0;\n\n          // Only use addEventListener if the special events handler returns false\n          if (!special.setup ||\n          special.setup.call(elem, data, namespaces, eventHandle) === false) {\n\n            if (elem.addEventListener) {\n              elem.addEventListener(type, eventHandle);\n            }\n          }\n        }\n\n        if (special.add) {\n          special.add.call(elem, handleObj);\n\n          if (!handleObj.handler.guid) {\n            handleObj.handler.guid = handler.guid;\n          }\n        }\n\n        // Add to the element's handler list, delegates in front\n        if (selector) {\n          handlers.splice(handlers.delegateCount++, 0, handleObj);\n        } else {\n          handlers.push(handleObj);\n        }\n\n        // Keep track of which events have ever been used, for event optimization\n        jQuery.event.global[type] = true;\n      }\n\n    },\n\n    // Detach an event or set of events from an element\n    remove: function remove(elem, types, handler, selector, mappedTypes) {\n\n      var j,origCount,tmp,\n      events,t,handleObj,\n      special,handlers,type,namespaces,origType,\n      elemData = dataPriv.hasData(elem) && dataPriv.get(elem);\n\n      if (!elemData || !(events = elemData.events)) {\n        return;\n      }\n\n      // Once for each type.namespace in types; type may be omitted\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort();\n\n        // Unbind all events (on this namespace, if provided) for the element\n        if (!type) {\n          for (type in events) {\n            jQuery.event.remove(elem, type + types[t], handler, selector, true);\n          }\n          continue;\n        }\n\n        special = jQuery.event.special[type] || {};\n        type = (selector ? special.delegateType : special.bindType) || type;\n        handlers = events[type] || [];\n        tmp = tmp[2] &&\n        new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\");\n\n        // Remove matching events\n        origCount = j = handlers.length;\n        while (j--) {\n          handleObj = handlers[j];\n\n          if ((mappedTypes || origType === handleObj.origType) && (\n          !handler || handler.guid === handleObj.guid) && (\n          !tmp || tmp.test(handleObj.namespace)) && (\n          !selector || selector === handleObj.selector ||\n          selector === \"**\" && handleObj.selector)) {\n            handlers.splice(j, 1);\n\n            if (handleObj.selector) {\n              handlers.delegateCount--;\n            }\n            if (special.remove) {\n              special.remove.call(elem, handleObj);\n            }\n          }\n        }\n\n        // Remove generic event handler if we removed something and no more handlers exist\n        // (avoids potential for endless recursion during removal of special event handlers)\n        if (origCount && !handlers.length) {\n          if (!special.teardown ||\n          special.teardown.call(elem, namespaces, elemData.handle) === false) {\n\n            jQuery.removeEvent(elem, type, elemData.handle);\n          }\n\n          delete events[type];\n        }\n      }\n\n      // Remove data and the expando if it's no longer used\n      if (jQuery.isEmptyObject(events)) {\n        dataPriv.remove(elem, \"handle events\");\n      }\n    },\n\n    dispatch: function dispatch(nativeEvent) {\n\n      var i,j,ret,matched,handleObj,handlerQueue,\n      args = new Array(arguments.length),\n\n      // Make a writable jQuery.Event from the native event object\n      event = jQuery.event.fix(nativeEvent),\n\n      handlers = (\n      dataPriv.get(this, \"events\") || Object.create(null))[\n      event.type] || [],\n      special = jQuery.event.special[event.type] || {};\n\n      // Use the fix-ed jQuery.Event rather than the (read-only) native event\n      args[0] = event;\n\n      for (i = 1; i < arguments.length; i++) {\n        args[i] = arguments[i];\n      }\n\n      event.delegateTarget = this;\n\n      // Call the preDispatch hook for the mapped type, and let it bail if desired\n      if (special.preDispatch && special.preDispatch.call(this, event) === false) {\n        return;\n      }\n\n      // Determine handlers\n      handlerQueue = jQuery.event.handlers.call(this, event, handlers);\n\n      // Run delegates first; they may want to stop propagation beneath us\n      i = 0;\n      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {\n        event.currentTarget = matched.elem;\n\n        j = 0;\n        while ((handleObj = matched.handlers[j++]) &&\n        !event.isImmediatePropagationStopped()) {\n\n          // If the event is namespaced, then each handler is only invoked if it is\n          // specially universal or its namespaces are a superset of the event's.\n          if (!event.rnamespace || handleObj.namespace === false ||\n          event.rnamespace.test(handleObj.namespace)) {\n\n            event.handleObj = handleObj;\n            event.data = handleObj.data;\n\n            ret = ((jQuery.event.special[handleObj.origType] || {}).handle ||\n            handleObj.handler).apply(matched.elem, args);\n\n            if (ret !== undefined) {\n              if ((event.result = ret) === false) {\n                event.preventDefault();\n                event.stopPropagation();\n              }\n            }\n          }\n        }\n      }\n\n      // Call the postDispatch hook for the mapped type\n      if (special.postDispatch) {\n        special.postDispatch.call(this, event);\n      }\n\n      return event.result;\n    },\n\n    handlers: function handlers(event, _handlers) {\n      var i,handleObj,sel,matchedHandlers,matchedSelectors,\n      handlerQueue = [],\n      delegateCount = _handlers.delegateCount,\n      cur = event.target;\n\n      // Find delegate handlers\n      if (delegateCount &&\n\n      // Support: IE <=9\n      // Black-hole SVG <use> instance trees (trac-13180)\n      cur.nodeType &&\n\n      // Support: Firefox <=42\n      // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n      // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n      // Support: IE 11 only\n      // ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n      !(event.type === \"click\" && event.button >= 1)) {\n\n        for (; cur !== this; cur = cur.parentNode || this) {\n\n          // Don't check non-elements (#13208)\n          // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n          if (cur.nodeType === 1 && !(event.type === \"click\" && cur.disabled === true)) {\n            matchedHandlers = [];\n            matchedSelectors = {};\n            for (i = 0; i < delegateCount; i++) {\n              handleObj = _handlers[i];\n\n              // Don't conflict with Object.prototype properties (#13203)\n              sel = handleObj.selector + \" \";\n\n              if (matchedSelectors[sel] === undefined) {\n                matchedSelectors[sel] = handleObj.needsContext ?\n                jQuery(sel, this).index(cur) > -1 :\n                jQuery.find(sel, this, null, [cur]).length;\n              }\n              if (matchedSelectors[sel]) {\n                matchedHandlers.push(handleObj);\n              }\n            }\n            if (matchedHandlers.length) {\n              handlerQueue.push({ elem: cur, handlers: matchedHandlers });\n            }\n          }\n        }\n      }\n\n      // Add the remaining (directly-bound) handlers\n      cur = this;\n      if (delegateCount < _handlers.length) {\n        handlerQueue.push({ elem: cur, handlers: _handlers.slice(delegateCount) });\n      }\n\n      return handlerQueue;\n    },\n\n    addProp: function addProp(name, hook) {\n      Object.defineProperty(jQuery.Event.prototype, name, {\n        enumerable: true,\n        configurable: true,\n\n        get: isFunction(hook) ?\n        function () {\n          if (this.originalEvent) {\n            return hook(this.originalEvent);\n          }\n        } :\n        function () {\n          if (this.originalEvent) {\n            return this.originalEvent[name];\n          }\n        },\n\n        set: function set(value) {\n          Object.defineProperty(this, name, {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: value });\n\n        } });\n\n    },\n\n    fix: function fix(originalEvent) {\n      return originalEvent[jQuery.expando] ?\n      originalEvent :\n      new jQuery.Event(originalEvent);\n    },\n\n    special: {\n      load: {\n\n        // Prevent triggered image.load events from bubbling to window.load\n        noBubble: true },\n\n      click: {\n\n        // Utilize native event to ensure correct state for checkable inputs\n        setup: function setup(data) {\n\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data;\n\n          // Claim the first handler\n          if (rcheckableType.test(el.type) &&\n          el.click && nodeName(el, \"input\")) {\n\n            // dataPriv.set( el, \"click\", ... )\n            leverageNative(el, \"click\", returnTrue);\n          }\n\n          // Return false to allow normal processing in the caller\n          return false;\n        },\n        trigger: function trigger(data) {\n\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data;\n\n          // Force setup before triggering a click\n          if (rcheckableType.test(el.type) &&\n          el.click && nodeName(el, \"input\")) {\n\n            leverageNative(el, \"click\");\n          }\n\n          // Return non-false to allow normal event-path propagation\n          return true;\n        },\n\n        // For cross-browser consistency, suppress native .click() on links\n        // Also prevent it if we're currently inside a leveraged native-event stack\n        _default: function _default(event) {\n          var target = event.target;\n          return rcheckableType.test(target.type) &&\n          target.click && nodeName(target, \"input\") &&\n          dataPriv.get(target, \"click\") ||\n          nodeName(target, \"a\");\n        } },\n\n\n      beforeunload: {\n        postDispatch: function postDispatch(event) {\n\n          // Support: Firefox 20+\n          // Firefox doesn't alert if the returnValue field is not set.\n          if (event.result !== undefined && event.originalEvent) {\n            event.originalEvent.returnValue = event.result;\n          }\n        } } } };\n\n\n\n\n  // Ensure the presence of an event listener that handles manually-triggered\n  // synthetic events by interrupting progress until reinvoked in response to\n  // *native* events that it fires directly, ensuring that state changes have\n  // already occurred before other listeners are invoked.\n  function leverageNative(el, type, expectSync) {\n\n    // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n    if (!expectSync) {\n      if (dataPriv.get(el, type) === undefined) {\n        jQuery.event.add(el, type, returnTrue);\n      }\n      return;\n    }\n\n    // Register the controller as a special universal handler for all event namespaces\n    dataPriv.set(el, type, false);\n    jQuery.event.add(el, type, {\n      namespace: false,\n      handler: function handler(event) {\n        var notAsync,result,\n        saved = dataPriv.get(this, type);\n\n        if (event.isTrigger & 1 && this[type]) {\n\n          // Interrupt processing of the outer synthetic .trigger()ed event\n          // Saved data should be false in such cases, but might be a leftover capture object\n          // from an async native handler (gh-4350)\n          if (!saved.length) {\n\n            // Store arguments for use when handling the inner native event\n            // There will always be at least one argument (an event object), so this array\n            // will not be confused with a leftover capture object.\n            saved = _slice.call(arguments);\n            dataPriv.set(this, type, saved);\n\n            // Trigger the native event and capture its result\n            // Support: IE <=9 - 11+\n            // focus() and blur() are asynchronous\n            notAsync = expectSync(this, type);\n            this[type]();\n            result = dataPriv.get(this, type);\n            if (saved !== result || notAsync) {\n              dataPriv.set(this, type, false);\n            } else {\n              result = {};\n            }\n            if (saved !== result) {\n\n              // Cancel the outer synthetic event\n              event.stopImmediatePropagation();\n              event.preventDefault();\n              return result.value;\n            }\n\n            // If this is an inner synthetic event for an event with a bubbling surrogate\n            // (focus or blur), assume that the surrogate already propagated from triggering the\n            // native event and prevent that from happening again here.\n            // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n            // bubbling surrogate propagates *after* the non-bubbling base), but that seems\n            // less bad than duplication.\n          } else if ((jQuery.event.special[type] || {}).delegateType) {\n            event.stopPropagation();\n          }\n\n          // If this is a native event triggered above, everything is now in order\n          // Fire an inner synthetic event with the original arguments\n        } else if (saved.length) {\n\n          // ...and capture the result\n          dataPriv.set(this, type, {\n            value: jQuery.event.trigger(\n\n            // Support: IE <=9 - 11+\n            // Extend with the prototype to reset the above stopImmediatePropagation()\n            jQuery.extend(saved[0], jQuery.Event.prototype),\n            saved.slice(1),\n            this) });\n\n\n\n          // Abort handling of the native event\n          event.stopImmediatePropagation();\n        }\n      } });\n\n  }\n\n  jQuery.removeEvent = function (elem, type, handle) {\n\n    // This \"if\" is needed for plain objects\n    if (elem.removeEventListener) {\n      elem.removeEventListener(type, handle);\n    }\n  };\n\n  jQuery.Event = function (src, props) {\n\n    // Allow instantiation without the 'new' keyword\n    if (!(this instanceof jQuery.Event)) {\n      return new jQuery.Event(src, props);\n    }\n\n    // Event object\n    if (src && src.type) {\n      this.originalEvent = src;\n      this.type = src.type;\n\n      // Events bubbling up the document may have been marked as prevented\n      // by a handler lower down the tree; reflect the correct value.\n      this.isDefaultPrevented = src.defaultPrevented ||\n      src.defaultPrevented === undefined &&\n\n      // Support: Android <=2.3 only\n      src.returnValue === false ?\n      returnTrue :\n      returnFalse;\n\n      // Create target properties\n      // Support: Safari <=6 - 7 only\n      // Target should not be a text node (#504, #13143)\n      this.target = src.target && src.target.nodeType === 3 ?\n      src.target.parentNode :\n      src.target;\n\n      this.currentTarget = src.currentTarget;\n      this.relatedTarget = src.relatedTarget;\n\n      // Event type\n    } else {\n      this.type = src;\n    }\n\n    // Put explicitly provided properties onto the event object\n    if (props) {\n      jQuery.extend(this, props);\n    }\n\n    // Create a timestamp if incoming event doesn't have one\n    this.timeStamp = src && src.timeStamp || Date.now();\n\n    // Mark it as fixed\n    this[jQuery.expando] = true;\n  };\n\n  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n  // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\n  jQuery.Event.prototype = {\n    constructor: jQuery.Event,\n    isDefaultPrevented: returnFalse,\n    isPropagationStopped: returnFalse,\n    isImmediatePropagationStopped: returnFalse,\n    isSimulated: false,\n\n    preventDefault: function preventDefault() {\n      var e = this.originalEvent;\n\n      this.isDefaultPrevented = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.preventDefault();\n      }\n    },\n    stopPropagation: function stopPropagation() {\n      var e = this.originalEvent;\n\n      this.isPropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopPropagation();\n      }\n    },\n    stopImmediatePropagation: function stopImmediatePropagation() {\n      var e = this.originalEvent;\n\n      this.isImmediatePropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopImmediatePropagation();\n      }\n\n      this.stopPropagation();\n    } };\n\n\n  // Includes all common event props including KeyEvent and MouseEvent specific props\n  jQuery.each({\n    altKey: true,\n    bubbles: true,\n    cancelable: true,\n    changedTouches: true,\n    ctrlKey: true,\n    detail: true,\n    eventPhase: true,\n    metaKey: true,\n    pageX: true,\n    pageY: true,\n    shiftKey: true,\n    view: true,\n    \"char\": true,\n    code: true,\n    charCode: true,\n    key: true,\n    keyCode: true,\n    button: true,\n    buttons: true,\n    clientX: true,\n    clientY: true,\n    offsetX: true,\n    offsetY: true,\n    pointerId: true,\n    pointerType: true,\n    screenX: true,\n    screenY: true,\n    targetTouches: true,\n    toElement: true,\n    touches: true,\n\n    which: function which(event) {\n      var button = event.button;\n\n      // Add which for key events\n      if (event.which == null && rkeyEvent.test(event.type)) {\n        return event.charCode != null ? event.charCode : event.keyCode;\n      }\n\n      // Add which for click: 1 === left; 2 === middle; 3 === right\n      if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {\n        if (button & 1) {\n          return 1;\n        }\n\n        if (button & 2) {\n          return 3;\n        }\n\n        if (button & 4) {\n          return 2;\n        }\n\n        return 0;\n      }\n\n      return event.which;\n    } },\n  jQuery.event.addProp);\n\n  jQuery.each({ focus: \"focusin\", blur: \"focusout\" }, function (type, delegateType) {\n    jQuery.event.special[type] = {\n\n      // Utilize native event if possible so blur/focus sequence is correct\n      setup: function setup() {\n\n        // Claim the first handler\n        // dataPriv.set( this, \"focus\", ... )\n        // dataPriv.set( this, \"blur\", ... )\n        leverageNative(this, type, expectSync);\n\n        // Return false to allow normal processing in the caller\n        return false;\n      },\n      trigger: function trigger() {\n\n        // Force setup before trigger\n        leverageNative(this, type);\n\n        // Return non-false to allow normal event-path propagation\n        return true;\n      },\n\n      delegateType: delegateType };\n\n  });\n\n  // Create mouseenter/leave events using mouseover/out and event-time checks\n  // so that event delegation works in jQuery.\n  // Do the same for pointerenter/pointerleave and pointerover/pointerout\n  //\n  // Support: Safari 7 only\n  // Safari sends mouseenter too often; see:\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n  // for the description of the bug (it existed in older Chrome versions as well).\n  jQuery.each({\n    mouseenter: \"mouseover\",\n    mouseleave: \"mouseout\",\n    pointerenter: \"pointerover\",\n    pointerleave: \"pointerout\" },\n  function (orig, fix) {\n    jQuery.event.special[orig] = {\n      delegateType: fix,\n      bindType: fix,\n\n      handle: function handle(event) {\n        var ret,\n        target = this,\n        related = event.relatedTarget,\n        handleObj = event.handleObj;\n\n        // For mouseenter/leave call the handler if related is outside the target.\n        // NB: No relatedTarget if the mouse left/entered the browser window\n        if (!related || related !== target && !jQuery.contains(target, related)) {\n          event.type = handleObj.origType;\n          ret = handleObj.handler.apply(this, arguments);\n          event.type = fix;\n        }\n        return ret;\n      } };\n\n  });\n\n  jQuery.fn.extend({\n\n    on: function on(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn);\n    },\n    one: function one(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn, 1);\n    },\n    off: function off(types, selector, fn) {\n      var handleObj, type;\n      if (types && types.preventDefault && types.handleObj) {\n\n        // ( event )  dispatched jQuery.Event\n        handleObj = types.handleObj;\n        jQuery(types.delegateTarget).off(\n        handleObj.namespace ?\n        handleObj.origType + \".\" + handleObj.namespace :\n        handleObj.origType,\n        handleObj.selector,\n        handleObj.handler);\n\n        return this;\n      }\n      if (_typeof(types) === \"object\") {\n\n        // ( types-object [, selector] )\n        for (type in types) {\n          this.off(type, selector, types[type]);\n        }\n        return this;\n      }\n      if (selector === false || typeof selector === \"function\") {\n\n        // ( types [, fn] )\n        fn = selector;\n        selector = undefined;\n      }\n      if (fn === false) {\n        fn = returnFalse;\n      }\n      return this.each(function () {\n        jQuery.event.remove(this, types, fn, selector);\n      });\n    } });\n\n\n\n  var\n\n  // Support: IE <=10 - 11, Edge 12 - 13 only\n  // In IE/Edge using regex groups here causes severe slowdowns.\n  // See https://connect.microsoft.com/IE/feedback/details/1736512/\n  rnoInnerhtml = /<script|<style|<link/i,\n\n  // checked=\"checked\" or checked\n  rchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n  rcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n  // Prefer a tbody over its parent table for containing new rows\n  function manipulationTarget(elem, content) {\n    if (nodeName(elem, \"table\") &&\n    nodeName(content.nodeType !== 11 ? content : content.firstChild, \"tr\")) {\n\n      return jQuery(elem).children(\"tbody\")[0] || elem;\n    }\n\n    return elem;\n  }\n\n  // Replace/restore the type attribute of script elements for safe DOM manipulation\n  function disableScript(elem) {\n    elem.type = (elem.getAttribute(\"type\") !== null) + \"/\" + elem.type;\n    return elem;\n  }\n  function restoreScript(elem) {\n    if ((elem.type || \"\").slice(0, 5) === \"true/\") {\n      elem.type = elem.type.slice(5);\n    } else {\n      elem.removeAttribute(\"type\");\n    }\n\n    return elem;\n  }\n\n  function cloneCopyEvent(src, dest) {\n    var i, l, type, pdataOld, udataOld, udataCur, events;\n\n    if (dest.nodeType !== 1) {\n      return;\n    }\n\n    // 1. Copy private data: events, handlers, etc.\n    if (dataPriv.hasData(src)) {\n      pdataOld = dataPriv.get(src);\n      events = pdataOld.events;\n\n      if (events) {\n        dataPriv.remove(dest, \"handle events\");\n\n        for (type in events) {\n          for (i = 0, l = events[type].length; i < l; i++) {\n            jQuery.event.add(dest, type, events[type][i]);\n          }\n        }\n      }\n    }\n\n    // 2. Copy user data\n    if (dataUser.hasData(src)) {\n      udataOld = dataUser.access(src);\n      udataCur = jQuery.extend({}, udataOld);\n\n      dataUser.set(dest, udataCur);\n    }\n  }\n\n  // Fix IE bugs, see support tests\n  function fixInput(src, dest) {\n    var nodeName = dest.nodeName.toLowerCase();\n\n    // Fails to persist the checked state of a cloned checkbox or radio button.\n    if (nodeName === \"input\" && rcheckableType.test(src.type)) {\n      dest.checked = src.checked;\n\n      // Fails to return the selected option to the default selected state when cloning options\n    } else if (nodeName === \"input\" || nodeName === \"textarea\") {\n      dest.defaultValue = src.defaultValue;\n    }\n  }\n\n  function domManip(collection, args, callback, ignored) {\n\n    // Flatten any nested arrays\n    args = flat(args);\n\n    var fragment,first,scripts,hasScripts,node,doc,\n    i = 0,\n    l = collection.length,\n    iNoClone = l - 1,\n    value = args[0],\n    valueIsFunction = isFunction(value);\n\n    // We can't cloneNode fragments that contain checked, in WebKit\n    if (valueIsFunction ||\n    l > 1 && typeof value === \"string\" &&\n    !support.checkClone && rchecked.test(value)) {\n      return collection.each(function (index) {\n        var self = collection.eq(index);\n        if (valueIsFunction) {\n          args[0] = value.call(this, index, self.html());\n        }\n        domManip(self, args, callback, ignored);\n      });\n    }\n\n    if (l) {\n      fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);\n      first = fragment.firstChild;\n\n      if (fragment.childNodes.length === 1) {\n        fragment = first;\n      }\n\n      // Require either new content or an interest in ignored elements to invoke the callback\n      if (first || ignored) {\n        scripts = jQuery.map(getAll(fragment, \"script\"), disableScript);\n        hasScripts = scripts.length;\n\n        // Use the original fragment for the last item\n        // instead of the first because it can end up\n        // being emptied incorrectly in certain situations (#8070).\n        for (; i < l; i++) {\n          node = fragment;\n\n          if (i !== iNoClone) {\n            node = jQuery.clone(node, true, true);\n\n            // Keep references to cloned scripts for later restoration\n            if (hasScripts) {\n\n              // Support: Android <=4.0 only, PhantomJS 1 only\n              // push.apply(_, arraylike) throws on ancient WebKit\n              jQuery.merge(scripts, getAll(node, \"script\"));\n            }\n          }\n\n          callback.call(collection[i], node, i);\n        }\n\n        if (hasScripts) {\n          doc = scripts[scripts.length - 1].ownerDocument;\n\n          // Reenable scripts\n          jQuery.map(scripts, restoreScript);\n\n          // Evaluate executable scripts on first document insertion\n          for (i = 0; i < hasScripts; i++) {\n            node = scripts[i];\n            if (rscriptType.test(node.type || \"\") &&\n            !dataPriv.access(node, \"globalEval\") &&\n            jQuery.contains(doc, node)) {\n\n              if (node.src && (node.type || \"\").toLowerCase() !== \"module\") {\n\n                // Optional AJAX dependency, but won't run scripts if not present\n                if (jQuery._evalUrl && !node.noModule) {\n                  jQuery._evalUrl(node.src, {\n                    nonce: node.nonce || node.getAttribute(\"nonce\") },\n                  doc);\n                }\n              } else {\n                DOMEval(node.textContent.replace(rcleanScript, \"\"), node, doc);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return collection;\n  }\n\n  function _remove(elem, selector, keepData) {\n    var node,\n    nodes = selector ? jQuery.filter(selector, elem) : elem,\n    i = 0;\n\n    for (; (node = nodes[i]) != null; i++) {\n      if (!keepData && node.nodeType === 1) {\n        jQuery.cleanData(getAll(node));\n      }\n\n      if (node.parentNode) {\n        if (keepData && isAttached(node)) {\n          setGlobalEval(getAll(node, \"script\"));\n        }\n        node.parentNode.removeChild(node);\n      }\n    }\n\n    return elem;\n  }\n\n  jQuery.extend({\n    htmlPrefilter: function htmlPrefilter(html) {\n      return html;\n    },\n\n    clone: function clone(elem, dataAndEvents, deepDataAndEvents) {\n      var i,l,srcElements,destElements,\n      clone = elem.cloneNode(true),\n      inPage = isAttached(elem);\n\n      // Fix IE cloning issues\n      if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) &&\n      !jQuery.isXMLDoc(elem)) {\n\n        // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n        destElements = getAll(clone);\n        srcElements = getAll(elem);\n\n        for (i = 0, l = srcElements.length; i < l; i++) {\n          fixInput(srcElements[i], destElements[i]);\n        }\n      }\n\n      // Copy the events from the original to the clone\n      if (dataAndEvents) {\n        if (deepDataAndEvents) {\n          srcElements = srcElements || getAll(elem);\n          destElements = destElements || getAll(clone);\n\n          for (i = 0, l = srcElements.length; i < l; i++) {\n            cloneCopyEvent(srcElements[i], destElements[i]);\n          }\n        } else {\n          cloneCopyEvent(elem, clone);\n        }\n      }\n\n      // Preserve script evaluation history\n      destElements = getAll(clone, \"script\");\n      if (destElements.length > 0) {\n        setGlobalEval(destElements, !inPage && getAll(elem, \"script\"));\n      }\n\n      // Return the cloned set\n      return clone;\n    },\n\n    cleanData: function cleanData(elems) {\n      var data,elem,type,\n      special = jQuery.event.special,\n      i = 0;\n\n      for (; (elem = elems[i]) !== undefined; i++) {\n        if (acceptData(elem)) {\n          if (data = elem[dataPriv.expando]) {\n            if (data.events) {\n              for (type in data.events) {\n                if (special[type]) {\n                  jQuery.event.remove(elem, type);\n\n                  // This is a shortcut to avoid jQuery.event.remove's overhead\n                } else {\n                  jQuery.removeEvent(elem, type, data.handle);\n                }\n              }\n            }\n\n            // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n            elem[dataPriv.expando] = undefined;\n          }\n          if (elem[dataUser.expando]) {\n\n            // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n            elem[dataUser.expando] = undefined;\n          }\n        }\n      }\n    } });\n\n\n  jQuery.fn.extend({\n    detach: function detach(selector) {\n      return _remove(this, selector, true);\n    },\n\n    remove: function remove(selector) {\n      return _remove(this, selector);\n    },\n\n    text: function text(value) {\n      return access(this, function (value) {\n        return value === undefined ?\n        jQuery.text(this) :\n        this.empty().each(function () {\n          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n            this.textContent = value;\n          }\n        });\n      }, null, value, arguments.length);\n    },\n\n    append: function append() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.appendChild(elem);\n        }\n      });\n    },\n\n    prepend: function prepend() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.insertBefore(elem, target.firstChild);\n        }\n      });\n    },\n\n    before: function before() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this);\n        }\n      });\n    },\n\n    after: function after() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this.nextSibling);\n        }\n      });\n    },\n\n    empty: function empty() {\n      var elem,\n      i = 0;\n\n      for (; (elem = this[i]) != null; i++) {\n        if (elem.nodeType === 1) {\n\n          // Prevent memory leaks\n          jQuery.cleanData(getAll(elem, false));\n\n          // Remove any remaining nodes\n          elem.textContent = \"\";\n        }\n      }\n\n      return this;\n    },\n\n    clone: function clone(dataAndEvents, deepDataAndEvents) {\n      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n      return this.map(function () {\n        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);\n      });\n    },\n\n    html: function html(value) {\n      return access(this, function (value) {\n        var elem = this[0] || {},\n        i = 0,\n        l = this.length;\n\n        if (value === undefined && elem.nodeType === 1) {\n          return elem.innerHTML;\n        }\n\n        // See if we can take a shortcut and just use innerHTML\n        if (typeof value === \"string\" && !rnoInnerhtml.test(value) &&\n        !wrapMap[(rtagName.exec(value) || [\"\", \"\"])[1].toLowerCase()]) {\n\n          value = jQuery.htmlPrefilter(value);\n\n          try {\n            for (; i < l; i++) {\n              elem = this[i] || {};\n\n              // Remove element nodes and prevent memory leaks\n              if (elem.nodeType === 1) {\n                jQuery.cleanData(getAll(elem, false));\n                elem.innerHTML = value;\n              }\n            }\n\n            elem = 0;\n\n            // If using innerHTML throws an exception, use the fallback method\n          } catch (e) {}\n        }\n\n        if (elem) {\n          this.empty().append(value);\n        }\n      }, null, value, arguments.length);\n    },\n\n    replaceWith: function replaceWith() {\n      var ignored = [];\n\n      // Make the changes, replacing each non-ignored context element with the new content\n      return domManip(this, arguments, function (elem) {\n        var parent = this.parentNode;\n\n        if (jQuery.inArray(this, ignored) < 0) {\n          jQuery.cleanData(getAll(this));\n          if (parent) {\n            parent.replaceChild(elem, this);\n          }\n        }\n\n        // Force callback invocation\n      }, ignored);\n    } });\n\n\n  jQuery.each({\n    appendTo: \"append\",\n    prependTo: \"prepend\",\n    insertBefore: \"before\",\n    insertAfter: \"after\",\n    replaceAll: \"replaceWith\" },\n  function (name, original) {\n    jQuery.fn[name] = function (selector) {\n      var elems,\n      ret = [],\n      insert = jQuery(selector),\n      last = insert.length - 1,\n      i = 0;\n\n      for (; i <= last; i++) {\n        elems = i === last ? this : this.clone(true);\n        jQuery(insert[i])[original](elems);\n\n        // Support: Android <=4.0 only, PhantomJS 1 only\n        // .get() because push.apply(_, arraylike) throws on ancient WebKit\n        push.apply(ret, elems.get());\n      }\n\n      return this.pushStack(ret);\n    };\n  });\n  var rnumnonpx = new RegExp(\"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\");\n\n  var getStyles = function getStyles(elem) {\n\n    // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n    // IE throws on elements created in popups\n    // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n    var view = elem.ownerDocument.defaultView;\n\n    if (!view || !view.opener) {\n      view = window;\n    }\n\n    return view.getComputedStyle(elem);\n  };\n\n  var swap = function swap(elem, options, callback) {\n    var ret,name,\n    old = {};\n\n    // Remember the old values, and insert the new ones\n    for (name in options) {\n      old[name] = elem.style[name];\n      elem.style[name] = options[name];\n    }\n\n    ret = callback.call(elem);\n\n    // Revert the old values\n    for (name in options) {\n      elem.style[name] = old[name];\n    }\n\n    return ret;\n  };\n\n\n  var rboxStyle = new RegExp(cssExpand.join(\"|\"), \"i\");\n\n\n\n  (function () {\n\n    // Executing both pixelPosition & boxSizingReliable tests require only one layout\n    // so they're executed at the same time to save the second computation.\n    function computeStyleTests() {\n\n      // This is a singleton, we need to execute it only once\n      if (!div) {\n        return;\n      }\n\n      container.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n      \"margin-top:1px;padding:0;border:0\";\n      div.style.cssText =\n      \"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n      \"margin:auto;border:1px;padding:1px;\" +\n      \"width:60%;top:1%\";\n      documentElement.appendChild(container).appendChild(div);\n\n      var divStyle = window.getComputedStyle(div);\n      pixelPositionVal = divStyle.top !== \"1%\";\n\n      // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n      reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12;\n\n      // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n      // Some styles come back with percentage values, even though they shouldn't\n      div.style.right = \"60%\";\n      pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36;\n\n      // Support: IE 9 - 11 only\n      // Detect misreporting of content dimensions for box-sizing:border-box elements\n      boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36;\n\n      // Support: IE 9 only\n      // Detect overflow:scroll screwiness (gh-3699)\n      // Support: Chrome <=64\n      // Don't get tricked when zoom affects offsetWidth (gh-4029)\n      div.style.position = \"absolute\";\n      scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;\n\n      documentElement.removeChild(container);\n\n      // Nullify the div so it wouldn't be stored in the memory and\n      // it will also be a sign that checks already performed\n      div = null;\n    }\n\n    function roundPixelMeasures(measure) {\n      return Math.round(parseFloat(measure));\n    }\n\n    var pixelPositionVal,boxSizingReliableVal,scrollboxSizeVal,pixelBoxStylesVal,\n    reliableTrDimensionsVal,reliableMarginLeftVal,\n    container = document.createElement(\"div\"),\n    div = document.createElement(\"div\");\n\n    // Finish early in limited (non-browser) environments\n    if (!div.style) {\n      return;\n    }\n\n    // Support: IE <=9 - 11 only\n    // Style of cloned element affects source element cloned (#8908)\n    div.style.backgroundClip = \"content-box\";\n    div.cloneNode(true).style.backgroundClip = \"\";\n    support.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n    jQuery.extend(support, {\n      boxSizingReliable: function boxSizingReliable() {\n        computeStyleTests();\n        return boxSizingReliableVal;\n      },\n      pixelBoxStyles: function pixelBoxStyles() {\n        computeStyleTests();\n        return pixelBoxStylesVal;\n      },\n      pixelPosition: function pixelPosition() {\n        computeStyleTests();\n        return pixelPositionVal;\n      },\n      reliableMarginLeft: function reliableMarginLeft() {\n        computeStyleTests();\n        return reliableMarginLeftVal;\n      },\n      scrollboxSize: function scrollboxSize() {\n        computeStyleTests();\n        return scrollboxSizeVal;\n      },\n\n      // Support: IE 9 - 11+, Edge 15 - 18+\n      // IE/Edge misreport `getComputedStyle` of table rows with width/height\n      // set in CSS while `offset*` properties report correct values.\n      // Behavior in IE 9 is more subtle than in newer versions & it passes\n      // some versions of this test; make sure not to make it pass there!\n      reliableTrDimensions: function reliableTrDimensions() {\n        var table, tr, trChild, trStyle;\n        if (reliableTrDimensionsVal == null) {\n          table = document.createElement(\"table\");\n          tr = document.createElement(\"tr\");\n          trChild = document.createElement(\"div\");\n\n          table.style.cssText = \"position:absolute;left:-11111px\";\n          tr.style.height = \"1px\";\n          trChild.style.height = \"9px\";\n\n          documentElement.\n          appendChild(table).\n          appendChild(tr).\n          appendChild(trChild);\n\n          trStyle = window.getComputedStyle(tr);\n          reliableTrDimensionsVal = parseInt(trStyle.height) > 3;\n\n          documentElement.removeChild(table);\n        }\n        return reliableTrDimensionsVal;\n      } });\n\n  })();\n\n\n  function curCSS(elem, name, computed) {\n    var width,minWidth,maxWidth,ret,\n\n    // Support: Firefox 51+\n    // Retrieving style before computed somehow\n    // fixes an issue with getting wrong values\n    // on detached elements\n    style = elem.style;\n\n    computed = computed || getStyles(elem);\n\n    // getPropertyValue is needed for:\n    //   .css('filter') (IE 9 only, #12537)\n    //   .css('--customProperty) (#3144)\n    if (computed) {\n      ret = computed.getPropertyValue(name) || computed[name];\n\n      if (ret === \"\" && !isAttached(elem)) {\n        ret = jQuery.style(elem, name);\n      }\n\n      // A tribute to the \"awesome hack by Dean Edwards\"\n      // Android Browser returns percentage for some values,\n      // but width seems to be reliably pixels.\n      // This is against the CSSOM draft spec:\n      // https://drafts.csswg.org/cssom/#resolved-values\n      if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {\n\n        // Remember the original values\n        width = style.width;\n        minWidth = style.minWidth;\n        maxWidth = style.maxWidth;\n\n        // Put in the new values to get a computed value out\n        style.minWidth = style.maxWidth = style.width = ret;\n        ret = computed.width;\n\n        // Revert the changed values\n        style.width = width;\n        style.minWidth = minWidth;\n        style.maxWidth = maxWidth;\n      }\n    }\n\n    return ret !== undefined ?\n\n    // Support: IE <=9 - 11 only\n    // IE returns zIndex value as an integer.\n    ret + \"\" :\n    ret;\n  }\n\n\n  function addGetHookIf(conditionFn, hookFn) {\n\n    // Define the hook, we'll check on the first run if it's really needed.\n    return {\n      get: function get() {\n        if (conditionFn()) {\n\n          // Hook not needed (or it's not possible to use it due\n          // to missing dependency), remove it.\n          delete this.get;\n          return;\n        }\n\n        // Hook needed; redefine it so that the support test is not executed again.\n        return (this.get = hookFn).apply(this, arguments);\n      } };\n\n  }\n\n\n  var cssPrefixes = [\"Webkit\", \"Moz\", \"ms\"],\n  emptyStyle = document.createElement(\"div\").style,\n  vendorProps = {};\n\n  // Return a vendor-prefixed property or undefined\n  function vendorPropName(name) {\n\n    // Check for vendor prefixed names\n    var capName = name[0].toUpperCase() + name.slice(1),\n    i = cssPrefixes.length;\n\n    while (i--) {\n      name = cssPrefixes[i] + capName;\n      if (name in emptyStyle) {\n        return name;\n      }\n    }\n  }\n\n  // Return a potentially-mapped jQuery.cssProps or vendor prefixed property\n  function finalPropName(name) {\n    var _final = jQuery.cssProps[name] || vendorProps[name];\n\n    if (_final) {\n      return _final;\n    }\n    if (name in emptyStyle) {\n      return name;\n    }\n    return vendorProps[name] = vendorPropName(name) || name;\n  }\n\n\n  var\n\n  // Swappable if display is none or starts with table\n  // except \"table\", \"table-cell\", or \"table-caption\"\n  // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n  rdisplayswap = /^(none|table(?!-c[ea]).+)/,\n  rcustomProp = /^--/,\n  cssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n  cssNormalTransform = {\n    letterSpacing: \"0\",\n    fontWeight: \"400\" };\n\n\n  function setPositiveNumber(_elem, value, subtract) {\n\n    // Any relative (+/-) values have already been\n    // normalized at this point\n    var matches = rcssNum.exec(value);\n    return matches ?\n\n    // Guard against undefined \"subtract\", e.g., when used as in cssHooks\n    Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || \"px\") :\n    value;\n  }\n\n  function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {\n    var i = dimension === \"width\" ? 1 : 0,\n    extra = 0,\n    delta = 0;\n\n    // Adjustment may not be necessary\n    if (box === (isBorderBox ? \"border\" : \"content\")) {\n      return 0;\n    }\n\n    for (; i < 4; i += 2) {\n\n      // Both box models exclude margin\n      if (box === \"margin\") {\n        delta += jQuery.css(elem, box + cssExpand[i], true, styles);\n      }\n\n      // If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n      if (!isBorderBox) {\n\n        // Add padding\n        delta += jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\n\n        // For \"border\" or \"margin\", add border\n        if (box !== \"padding\") {\n          delta += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n\n          // But still keep track of it otherwise\n        } else {\n          extra += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        }\n\n        // If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n        // \"padding\" or \"margin\"\n      } else {\n\n        // For \"content\", subtract padding\n        if (box === \"content\") {\n          delta -= jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\n        }\n\n        // For \"content\" or \"padding\", subtract border\n        if (box !== \"margin\") {\n          delta -= jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        }\n      }\n    }\n\n    // Account for positive content-box scroll gutter when requested by providing computedVal\n    if (!isBorderBox && computedVal >= 0) {\n\n      // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n      // Assuming integer scroll gutter, subtract the rest and round down\n      delta += Math.max(0, Math.ceil(\n      elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] -\n      computedVal -\n      delta -\n      extra -\n      0.5\n\n      // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n      // Use an explicit zero to avoid NaN (gh-3964)\n      )) || 0;\n    }\n\n    return delta;\n  }\n\n  function getWidthOrHeight(elem, dimension, extra) {\n\n    // Start with computed style\n    var styles = getStyles(elem),\n\n    // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n    // Fake content-box until we know it's needed to know the true value.\n    boxSizingNeeded = !support.boxSizingReliable() || extra,\n    isBorderBox = boxSizingNeeded &&\n    jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n    valueIsBorderBox = isBorderBox,\n\n    val = curCSS(elem, dimension, styles),\n    offsetProp = \"offset\" + dimension[0].toUpperCase() + dimension.slice(1);\n\n    // Support: Firefox <=54\n    // Return a confounding non-pixel value or feign ignorance, as appropriate.\n    if (rnumnonpx.test(val)) {\n      if (!extra) {\n        return val;\n      }\n      val = \"auto\";\n    }\n\n\n    // Support: IE 9 - 11 only\n    // Use offsetWidth/offsetHeight for when box sizing is unreliable.\n    // In those cases, the computed value can be trusted to be border-box.\n    if ((!support.boxSizingReliable() && isBorderBox ||\n\n    // Support: IE 10 - 11+, Edge 15 - 18+\n    // IE/Edge misreport `getComputedStyle` of table rows with width/height\n    // set in CSS while `offset*` properties report correct values.\n    // Interestingly, in some cases IE 9 doesn't suffer from this issue.\n    !support.reliableTrDimensions() && nodeName(elem, \"tr\") ||\n\n    // Fall back to offsetWidth/offsetHeight when value is \"auto\"\n    // This happens for inline elements with no explicit setting (gh-3571)\n    val === \"auto\" ||\n\n    // Support: Android <=4.1 - 4.3 only\n    // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n    !parseFloat(val) && jQuery.css(elem, \"display\", false, styles) === \"inline\") &&\n\n    // Make sure the element is visible & connected\n    elem.getClientRects().length) {\n\n      isBorderBox = jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\";\n\n      // Where available, offsetWidth/offsetHeight approximate border box dimensions.\n      // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n      // retrieved value as a content box dimension.\n      valueIsBorderBox = offsetProp in elem;\n      if (valueIsBorderBox) {\n        val = elem[offsetProp];\n      }\n    }\n\n    // Normalize \"\" and auto\n    val = parseFloat(val) || 0;\n\n    // Adjust for the element's box model\n    return val +\n    boxModelAdjustment(\n    elem,\n    dimension,\n    extra || (isBorderBox ? \"border\" : \"content\"),\n    valueIsBorderBox,\n    styles,\n\n    // Provide the current computed size to request scroll gutter calculation (gh-3589)\n    val) +\n\n    \"px\";\n  }\n\n  jQuery.extend({\n\n    // Add in style property hooks for overriding the default\n    // behavior of getting and setting a style property\n    cssHooks: {\n      opacity: {\n        get: function get(elem, computed) {\n          if (computed) {\n\n            // We should always get a number back from opacity\n            var ret = curCSS(elem, \"opacity\");\n            return ret === \"\" ? \"1\" : ret;\n          }\n        } } },\n\n\n\n    // Don't automatically add \"px\" to these possibly-unitless properties\n    cssNumber: {\n      \"animationIterationCount\": true,\n      \"columnCount\": true,\n      \"fillOpacity\": true,\n      \"flexGrow\": true,\n      \"flexShrink\": true,\n      \"fontWeight\": true,\n      \"gridArea\": true,\n      \"gridColumn\": true,\n      \"gridColumnEnd\": true,\n      \"gridColumnStart\": true,\n      \"gridRow\": true,\n      \"gridRowEnd\": true,\n      \"gridRowStart\": true,\n      \"lineHeight\": true,\n      \"opacity\": true,\n      \"order\": true,\n      \"orphans\": true,\n      \"widows\": true,\n      \"zIndex\": true,\n      \"zoom\": true },\n\n\n    // Add in properties whose names you wish to fix before\n    // setting or getting the value\n    cssProps: {},\n\n    // Get and set the style property on a DOM Node\n    style: function style(elem, name, value, extra) {\n\n      // Don't set styles on text and comment nodes\n      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {\n        return;\n      }\n\n      // Make sure that we're working with the right name\n      var ret,type,hooks,\n      origName = camelCase(name),\n      isCustomProp = rcustomProp.test(name),\n      style = elem.style;\n\n      // Make sure that we're working with the right name. We don't\n      // want to query the value if it is a CSS custom property\n      // since they are user-defined.\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      }\n\n      // Gets hook for the prefixed version, then unprefixed version\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];\n\n      // Check if we're setting a value\n      if (value !== undefined) {\n        type = _typeof(value);\n\n        // Convert \"+=\" or \"-=\" to relative numbers (#7345)\n        if (type === \"string\" && (ret = rcssNum.exec(value)) && ret[1]) {\n          value = adjustCSS(elem, name, ret);\n\n          // Fixes bug #9237\n          type = \"number\";\n        }\n\n        // Make sure that null and NaN values aren't set (#7116)\n        if (value == null || value !== value) {\n          return;\n        }\n\n        // If a number was passed in, add the unit (except for certain CSS properties)\n        // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n        // \"px\" to a few hardcoded values.\n        if (type === \"number\" && !isCustomProp) {\n          value += ret && ret[3] || (jQuery.cssNumber[origName] ? \"\" : \"px\");\n        }\n\n        // background-* props affect original clone's values\n        if (!support.clearCloneStyle && value === \"\" && name.indexOf(\"background\") === 0) {\n          style[name] = \"inherit\";\n        }\n\n        // If a hook was provided, use that value, otherwise just set the specified value\n        if (!hooks || !(\"set\" in hooks) ||\n        (value = hooks.set(elem, value, extra)) !== undefined) {\n\n          if (isCustomProp) {\n            style.setProperty(name, value);\n          } else {\n            style[name] = value;\n          }\n        }\n\n      } else {\n\n        // If a hook was provided get the non-computed value from there\n        if (hooks && \"get\" in hooks &&\n        (ret = hooks.get(elem, false, extra)) !== undefined) {\n\n          return ret;\n        }\n\n        // Otherwise just get the value from the style object\n        return style[name];\n      }\n    },\n\n    css: function css(elem, name, extra, styles) {\n      var val,num,hooks,\n      origName = camelCase(name),\n      isCustomProp = rcustomProp.test(name);\n\n      // Make sure that we're working with the right name. We don't\n      // want to modify the value if it is a CSS custom property\n      // since they are user-defined.\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      }\n\n      // Try prefixed name followed by the unprefixed name\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];\n\n      // If a hook was provided get the computed value from there\n      if (hooks && \"get\" in hooks) {\n        val = hooks.get(elem, true, extra);\n      }\n\n      // Otherwise, if a way to get the computed value exists, use that\n      if (val === undefined) {\n        val = curCSS(elem, name, styles);\n      }\n\n      // Convert \"normal\" to computed value\n      if (val === \"normal\" && name in cssNormalTransform) {\n        val = cssNormalTransform[name];\n      }\n\n      // Make numeric if forced or a qualifier was provided and val looks numeric\n      if (extra === \"\" || extra) {\n        num = parseFloat(val);\n        return extra === true || isFinite(num) ? num || 0 : val;\n      }\n\n      return val;\n    } });\n\n\n  jQuery.each([\"height\", \"width\"], function (_i, dimension) {\n    jQuery.cssHooks[dimension] = {\n      get: function get(elem, computed, extra) {\n        if (computed) {\n\n          // Certain elements can have dimension info if we invisibly show them\n          // but it must have a current display style that would benefit\n          return rdisplayswap.test(jQuery.css(elem, \"display\")) && (\n\n          // Support: Safari 8+\n          // Table columns in Safari have non-zero offsetWidth & zero\n          // getBoundingClientRect().width unless display is changed.\n          // Support: IE <=11 only\n          // Running getBoundingClientRect on a disconnected node\n          // in IE throws an error.\n          !elem.getClientRects().length || !elem.getBoundingClientRect().width) ?\n          swap(elem, cssShow, function () {\n            return getWidthOrHeight(elem, dimension, extra);\n          }) :\n          getWidthOrHeight(elem, dimension, extra);\n        }\n      },\n\n      set: function set(elem, value, extra) {\n        var matches,\n        styles = getStyles(elem),\n\n        // Only read styles.position if the test has a chance to fail\n        // to avoid forcing a reflow.\n        scrollboxSizeBuggy = !support.scrollboxSize() &&\n        styles.position === \"absolute\",\n\n        // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n        boxSizingNeeded = scrollboxSizeBuggy || extra,\n        isBorderBox = boxSizingNeeded &&\n        jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n        subtract = extra ?\n        boxModelAdjustment(\n        elem,\n        dimension,\n        extra,\n        isBorderBox,\n        styles) :\n\n        0;\n\n        // Account for unreliable border-box dimensions by comparing offset* to computed and\n        // faking a content-box to get border and padding (gh-3699)\n        if (isBorderBox && scrollboxSizeBuggy) {\n          subtract -= Math.ceil(\n          elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] -\n          parseFloat(styles[dimension]) -\n          boxModelAdjustment(elem, dimension, \"border\", false, styles) -\n          0.5);\n\n        }\n\n        // Convert to pixels if value adjustment is needed\n        if (subtract && (matches = rcssNum.exec(value)) &&\n        (matches[3] || \"px\") !== \"px\") {\n\n          elem.style[dimension] = value;\n          value = jQuery.css(elem, dimension);\n        }\n\n        return setPositiveNumber(elem, value, subtract);\n      } };\n\n  });\n\n  jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft,\n  function (elem, computed) {\n    if (computed) {\n      return (parseFloat(curCSS(elem, \"marginLeft\")) ||\n      elem.getBoundingClientRect().left -\n      swap(elem, { marginLeft: 0 }, function () {\n        return elem.getBoundingClientRect().left;\n      })) +\n      \"px\";\n    }\n  });\n\n\n  // These hooks are used by animate to expand properties\n  jQuery.each({\n    margin: \"\",\n    padding: \"\",\n    border: \"Width\" },\n  function (prefix, suffix) {\n    jQuery.cssHooks[prefix + suffix] = {\n      expand: function expand(value) {\n        var i = 0,\n        expanded = {},\n\n        // Assumes a single number if not a string\n        parts = typeof value === \"string\" ? value.split(\" \") : [value];\n\n        for (; i < 4; i++) {\n          expanded[prefix + cssExpand[i] + suffix] =\n          parts[i] || parts[i - 2] || parts[0];\n        }\n\n        return expanded;\n      } };\n\n\n    if (prefix !== \"margin\") {\n      jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;\n    }\n  });\n\n  jQuery.fn.extend({\n    css: function css(name, value) {\n      return access(this, function (elem, name, value) {\n        var styles,len,\n        map = {},\n        i = 0;\n\n        if (Array.isArray(name)) {\n          styles = getStyles(elem);\n          len = name.length;\n\n          for (; i < len; i++) {\n            map[name[i]] = jQuery.css(elem, name[i], false, styles);\n          }\n\n          return map;\n        }\n\n        return value !== undefined ?\n        jQuery.style(elem, name, value) :\n        jQuery.css(elem, name);\n      }, name, value, arguments.length > 1);\n    } });\n\n\n\n  function Tween(elem, options, prop, end, easing) {\n    return new Tween.prototype.init(elem, options, prop, end, easing);\n  }\n  jQuery.Tween = Tween;\n\n  Tween.prototype = {\n    constructor: Tween,\n    init: function init(elem, options, prop, end, easing, unit) {\n      this.elem = elem;\n      this.prop = prop;\n      this.easing = easing || jQuery.easing._default;\n      this.options = options;\n      this.start = this.now = this.cur();\n      this.end = end;\n      this.unit = unit || (jQuery.cssNumber[prop] ? \"\" : \"px\");\n    },\n    cur: function cur() {\n      var hooks = Tween.propHooks[this.prop];\n\n      return hooks && hooks.get ?\n      hooks.get(this) :\n      Tween.propHooks._default.get(this);\n    },\n    run: function run(percent) {\n      var eased,\n      hooks = Tween.propHooks[this.prop];\n\n      if (this.options.duration) {\n        this.pos = eased = jQuery.easing[this.easing](\n        percent, this.options.duration * percent, 0, 1, this.options.duration);\n\n      } else {\n        this.pos = eased = percent;\n      }\n      this.now = (this.end - this.start) * eased + this.start;\n\n      if (this.options.step) {\n        this.options.step.call(this.elem, this.now, this);\n      }\n\n      if (hooks && hooks.set) {\n        hooks.set(this);\n      } else {\n        Tween.propHooks._default.set(this);\n      }\n      return this;\n    } };\n\n\n  Tween.prototype.init.prototype = Tween.prototype;\n\n  Tween.propHooks = {\n    _default: {\n      get: function get(tween) {\n        var result;\n\n        // Use a property on the element directly when it is not a DOM element,\n        // or when there is no matching style property that exists.\n        if (tween.elem.nodeType !== 1 ||\n        tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {\n          return tween.elem[tween.prop];\n        }\n\n        // Passing an empty string as a 3rd parameter to .css will automatically\n        // attempt a parseFloat and fallback to a string if the parse fails.\n        // Simple values such as \"10px\" are parsed to Float;\n        // complex values such as \"rotate(1rad)\" are returned as-is.\n        result = jQuery.css(tween.elem, tween.prop, \"\");\n\n        // Empty strings, null, undefined and \"auto\" are converted to 0.\n        return !result || result === \"auto\" ? 0 : result;\n      },\n      set: function set(tween) {\n\n        // Use step hook for back compat.\n        // Use cssHook if its there.\n        // Use .style if available and use plain properties where available.\n        if (jQuery.fx.step[tween.prop]) {\n          jQuery.fx.step[tween.prop](tween);\n        } else if (tween.elem.nodeType === 1 && (\n        jQuery.cssHooks[tween.prop] ||\n        tween.elem.style[finalPropName(tween.prop)] != null)) {\n          jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);\n        } else {\n          tween.elem[tween.prop] = tween.now;\n        }\n      } } };\n\n\n\n  // Support: IE <=9 only\n  // Panic based approach to setting things on disconnected nodes\n  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n    set: function set(tween) {\n      if (tween.elem.nodeType && tween.elem.parentNode) {\n        tween.elem[tween.prop] = tween.now;\n      }\n    } };\n\n\n  jQuery.easing = {\n    linear: function linear(p) {\n      return p;\n    },\n    swing: function swing(p) {\n      return 0.5 - Math.cos(p * Math.PI) / 2;\n    },\n    _default: \"swing\" };\n\n\n  jQuery.fx = Tween.prototype.init;\n\n  // Back compat <1.8 extension point\n  jQuery.fx.step = {};\n\n\n\n\n  var\n  fxNow,inProgress,\n  rfxtypes = /^(?:toggle|show|hide)$/,\n  rrun = /queueHooks$/;\n\n  function schedule() {\n    if (inProgress) {\n      if (document.hidden === false && window.requestAnimationFrame) {\n        window.requestAnimationFrame(schedule);\n      } else {\n        window.setTimeout(schedule, jQuery.fx.interval);\n      }\n\n      jQuery.fx.tick();\n    }\n  }\n\n  // Animations created synchronously will run synchronously\n  function createFxNow() {\n    window.setTimeout(function () {\n      fxNow = undefined;\n    });\n    return fxNow = Date.now();\n  }\n\n  // Generate parameters to create a standard animation\n  function genFx(type, includeWidth) {\n    var which,\n    i = 0,\n    attrs = { height: type };\n\n    // If we include width, step value is 1 to do all cssExpand values,\n    // otherwise step value is 2 to skip over Left and Right\n    includeWidth = includeWidth ? 1 : 0;\n    for (; i < 4; i += 2 - includeWidth) {\n      which = cssExpand[i];\n      attrs[\"margin\" + which] = attrs[\"padding\" + which] = type;\n    }\n\n    if (includeWidth) {\n      attrs.opacity = attrs.width = type;\n    }\n\n    return attrs;\n  }\n\n  function createTween(value, prop, animation) {\n    var tween,\n    collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners[\"*\"]),\n    index = 0,\n    length = collection.length;\n    for (; index < length; index++) {\n      if (tween = collection[index].call(animation, prop, value)) {\n\n        // We're done with this property\n        return tween;\n      }\n    }\n  }\n\n  function defaultPrefilter(elem, props, opts) {\n    var prop,value,toggle,hooks,oldfire,propTween,restoreDisplay,display,\n    isBox = \"width\" in props || \"height\" in props,\n    anim = this,\n    orig = {},\n    style = elem.style,\n    hidden = elem.nodeType && isHiddenWithinTree(elem),\n    dataShow = dataPriv.get(elem, \"fxshow\");\n\n    // Queue-skipping animations hijack the fx hooks\n    if (!opts.queue) {\n      hooks = jQuery._queueHooks(elem, \"fx\");\n      if (hooks.unqueued == null) {\n        hooks.unqueued = 0;\n        oldfire = hooks.empty.fire;\n        hooks.empty.fire = function () {\n          if (!hooks.unqueued) {\n            oldfire();\n          }\n        };\n      }\n      hooks.unqueued++;\n\n      anim.always(function () {\n\n        // Ensure the complete handler is called before this completes\n        anim.always(function () {\n          hooks.unqueued--;\n          if (!jQuery.queue(elem, \"fx\").length) {\n            hooks.empty.fire();\n          }\n        });\n      });\n    }\n\n    // Detect show/hide animations\n    for (prop in props) {\n      value = props[prop];\n      if (rfxtypes.test(value)) {\n        delete props[prop];\n        toggle = toggle || value === \"toggle\";\n        if (value === (hidden ? \"hide\" : \"show\")) {\n\n          // Pretend to be hidden if this is a \"show\" and\n          // there is still data from a stopped show/hide\n          if (value === \"show\" && dataShow && dataShow[prop] !== undefined) {\n            hidden = true;\n\n            // Ignore all other no-op show/hide data\n          } else {\n            continue;\n          }\n        }\n        orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);\n      }\n    }\n\n    // Bail out if this is a no-op like .hide().hide()\n    propTween = !jQuery.isEmptyObject(props);\n    if (!propTween && jQuery.isEmptyObject(orig)) {\n      return;\n    }\n\n    // Restrict \"overflow\" and \"display\" styles during box animations\n    if (isBox && elem.nodeType === 1) {\n\n      // Support: IE <=9 - 11, Edge 12 - 15\n      // Record all 3 overflow attributes because IE does not infer the shorthand\n      // from identically-valued overflowX and overflowY and Edge just mirrors\n      // the overflowX value there.\n      opts.overflow = [style.overflow, style.overflowX, style.overflowY];\n\n      // Identify a display type, preferring old show/hide data over the CSS cascade\n      restoreDisplay = dataShow && dataShow.display;\n      if (restoreDisplay == null) {\n        restoreDisplay = dataPriv.get(elem, \"display\");\n      }\n      display = jQuery.css(elem, \"display\");\n      if (display === \"none\") {\n        if (restoreDisplay) {\n          display = restoreDisplay;\n        } else {\n\n          // Get nonempty value(s) by temporarily forcing visibility\n          showHide([elem], true);\n          restoreDisplay = elem.style.display || restoreDisplay;\n          display = jQuery.css(elem, \"display\");\n          showHide([elem]);\n        }\n      }\n\n      // Animate inline elements as inline-block\n      if (display === \"inline\" || display === \"inline-block\" && restoreDisplay != null) {\n        if (jQuery.css(elem, \"float\") === \"none\") {\n\n          // Restore the original display value at the end of pure show/hide animations\n          if (!propTween) {\n            anim.done(function () {\n              style.display = restoreDisplay;\n            });\n            if (restoreDisplay == null) {\n              display = style.display;\n              restoreDisplay = display === \"none\" ? \"\" : display;\n            }\n          }\n          style.display = \"inline-block\";\n        }\n      }\n    }\n\n    if (opts.overflow) {\n      style.overflow = \"hidden\";\n      anim.always(function () {\n        style.overflow = opts.overflow[0];\n        style.overflowX = opts.overflow[1];\n        style.overflowY = opts.overflow[2];\n      });\n    }\n\n    // Implement show/hide animations\n    propTween = false;\n    for (prop in orig) {\n\n      // General show/hide setup for this element animation\n      if (!propTween) {\n        if (dataShow) {\n          if (\"hidden\" in dataShow) {\n            hidden = dataShow.hidden;\n          }\n        } else {\n          dataShow = dataPriv.access(elem, \"fxshow\", { display: restoreDisplay });\n        }\n\n        // Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n        if (toggle) {\n          dataShow.hidden = !hidden;\n        }\n\n        // Show elements before animating them\n        if (hidden) {\n          showHide([elem], true);\n        }\n\n        /* eslint-disable no-loop-func */\n\n        anim.done(function () {\n\n          /* eslint-enable no-loop-func */\n\n          // The final step of a \"hide\" animation is actually hiding the element\n          if (!hidden) {\n            showHide([elem]);\n          }\n          dataPriv.remove(elem, \"fxshow\");\n          for (prop in orig) {\n            jQuery.style(elem, prop, orig[prop]);\n          }\n        });\n      }\n\n      // Per-property setup\n      propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);\n      if (!(prop in dataShow)) {\n        dataShow[prop] = propTween.start;\n        if (hidden) {\n          propTween.end = propTween.start;\n          propTween.start = 0;\n        }\n      }\n    }\n  }\n\n  function propFilter(props, specialEasing) {\n    var index, name, easing, value, hooks;\n\n    // camelCase, specialEasing and expand cssHook pass\n    for (index in props) {\n      name = camelCase(index);\n      easing = specialEasing[name];\n      value = props[index];\n      if (Array.isArray(value)) {\n        easing = value[1];\n        value = props[index] = value[0];\n      }\n\n      if (index !== name) {\n        props[name] = value;\n        delete props[index];\n      }\n\n      hooks = jQuery.cssHooks[name];\n      if (hooks && \"expand\" in hooks) {\n        value = hooks.expand(value);\n        delete props[name];\n\n        // Not quite $.extend, this won't overwrite existing keys.\n        // Reusing 'index' because we have the correct \"name\"\n        for (index in value) {\n          if (!(index in props)) {\n            props[index] = value[index];\n            specialEasing[index] = easing;\n          }\n        }\n      } else {\n        specialEasing[name] = easing;\n      }\n    }\n  }\n\n  function Animation(elem, properties, options) {\n    var result,\n    stopped,\n    index = 0,\n    length = Animation.prefilters.length,\n    deferred = jQuery.Deferred().always(function () {\n\n      // Don't match elem in the :animated selector\n      delete tick.elem;\n    }),\n    tick = function tick() {\n      if (stopped) {\n        return false;\n      }\n      var currentTime = fxNow || createFxNow(),\n      remaining = Math.max(0, animation.startTime + animation.duration - currentTime),\n\n      // Support: Android 2.3 only\n      // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n      temp = remaining / animation.duration || 0,\n      percent = 1 - temp,\n      index = 0,\n      length = animation.tweens.length;\n\n      for (; index < length; index++) {\n        animation.tweens[index].run(percent);\n      }\n\n      deferred.notifyWith(elem, [animation, percent, remaining]);\n\n      // If there's more to do, yield\n      if (percent < 1 && length) {\n        return remaining;\n      }\n\n      // If this was an empty animation, synthesize a final progress notification\n      if (!length) {\n        deferred.notifyWith(elem, [animation, 1, 0]);\n      }\n\n      // Resolve the animation and report its conclusion\n      deferred.resolveWith(elem, [animation]);\n      return false;\n    },\n    animation = deferred.promise({\n      elem: elem,\n      props: jQuery.extend({}, properties),\n      opts: jQuery.extend(true, {\n        specialEasing: {},\n        easing: jQuery.easing._default },\n      options),\n      originalProperties: properties,\n      originalOptions: options,\n      startTime: fxNow || createFxNow(),\n      duration: options.duration,\n      tweens: [],\n      createTween: function createTween(prop, end) {\n        var tween = jQuery.Tween(elem, animation.opts, prop, end,\n        animation.opts.specialEasing[prop] || animation.opts.easing);\n        animation.tweens.push(tween);\n        return tween;\n      },\n      stop: function stop(gotoEnd) {\n        var index = 0,\n\n        // If we are going to the end, we want to run all the tweens\n        // otherwise we skip this part\n        length = gotoEnd ? animation.tweens.length : 0;\n        if (stopped) {\n          return this;\n        }\n        stopped = true;\n        for (; index < length; index++) {\n          animation.tweens[index].run(1);\n        }\n\n        // Resolve when we played the last frame; otherwise, reject\n        if (gotoEnd) {\n          deferred.notifyWith(elem, [animation, 1, 0]);\n          deferred.resolveWith(elem, [animation, gotoEnd]);\n        } else {\n          deferred.rejectWith(elem, [animation, gotoEnd]);\n        }\n        return this;\n      } }),\n\n    props = animation.props;\n\n    propFilter(props, animation.opts.specialEasing);\n\n    for (; index < length; index++) {\n      result = Animation.prefilters[index].call(animation, elem, props, animation.opts);\n      if (result) {\n        if (isFunction(result.stop)) {\n          jQuery._queueHooks(animation.elem, animation.opts.queue).stop =\n          result.stop.bind(result);\n        }\n        return result;\n      }\n    }\n\n    jQuery.map(props, createTween, animation);\n\n    if (isFunction(animation.opts.start)) {\n      animation.opts.start.call(elem, animation);\n    }\n\n    // Attach callbacks from options\n    animation.\n    progress(animation.opts.progress).\n    done(animation.opts.done, animation.opts.complete).\n    fail(animation.opts.fail).\n    always(animation.opts.always);\n\n    jQuery.fx.timer(\n    jQuery.extend(tick, {\n      elem: elem,\n      anim: animation,\n      queue: animation.opts.queue }));\n\n\n\n    return animation;\n  }\n\n  jQuery.Animation = jQuery.extend(Animation, {\n\n    tweeners: {\n      \"*\": [function (prop, value) {\n        var tween = this.createTween(prop, value);\n        adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);\n        return tween;\n      }] },\n\n\n    tweener: function tweener(props, callback) {\n      if (isFunction(props)) {\n        callback = props;\n        props = [\"*\"];\n      } else {\n        props = props.match(rnothtmlwhite);\n      }\n\n      var prop,\n      index = 0,\n      length = props.length;\n\n      for (; index < length; index++) {\n        prop = props[index];\n        Animation.tweeners[prop] = Animation.tweeners[prop] || [];\n        Animation.tweeners[prop].unshift(callback);\n      }\n    },\n\n    prefilters: [defaultPrefilter],\n\n    prefilter: function prefilter(callback, prepend) {\n      if (prepend) {\n        Animation.prefilters.unshift(callback);\n      } else {\n        Animation.prefilters.push(callback);\n      }\n    } });\n\n\n  jQuery.speed = function (speed, easing, fn) {\n    var opt = speed && _typeof(speed) === \"object\" ? jQuery.extend({}, speed) : {\n      complete: fn || !fn && easing ||\n      isFunction(speed) && speed,\n      duration: speed,\n      easing: fn && easing || easing && !isFunction(easing) && easing };\n\n\n    // Go to the end state if fx are off\n    if (jQuery.fx.off) {\n      opt.duration = 0;\n\n    } else {\n      if (typeof opt.duration !== \"number\") {\n        if (opt.duration in jQuery.fx.speeds) {\n          opt.duration = jQuery.fx.speeds[opt.duration];\n\n        } else {\n          opt.duration = jQuery.fx.speeds._default;\n        }\n      }\n    }\n\n    // Normalize opt.queue - true/undefined/null -> \"fx\"\n    if (opt.queue == null || opt.queue === true) {\n      opt.queue = \"fx\";\n    }\n\n    // Queueing\n    opt.old = opt.complete;\n\n    opt.complete = function () {\n      if (isFunction(opt.old)) {\n        opt.old.call(this);\n      }\n\n      if (opt.queue) {\n        jQuery.dequeue(this, opt.queue);\n      }\n    };\n\n    return opt;\n  };\n\n  jQuery.fn.extend({\n    fadeTo: function fadeTo(speed, to, easing, callback) {\n\n      // Show any hidden elements after setting opacity to 0\n      return this.filter(isHiddenWithinTree).css(\"opacity\", 0).show()\n\n      // Animate to the value specified\n      .end().animate({ opacity: to }, speed, easing, callback);\n    },\n    animate: function animate(prop, speed, easing, callback) {\n      var empty = jQuery.isEmptyObject(prop),\n      optall = jQuery.speed(speed, easing, callback),\n      doAnimation = function doAnimation() {\n\n        // Operate on a copy of prop so per-property easing won't be lost\n        var anim = Animation(this, jQuery.extend({}, prop), optall);\n\n        // Empty animations, or finishing resolves immediately\n        if (empty || dataPriv.get(this, \"finish\")) {\n          anim.stop(true);\n        }\n      };\n      doAnimation.finish = doAnimation;\n\n      return empty || optall.queue === false ?\n      this.each(doAnimation) :\n      this.queue(optall.queue, doAnimation);\n    },\n    stop: function stop(type, clearQueue, gotoEnd) {\n      var stopQueue = function stopQueue(hooks) {\n        var stop = hooks.stop;\n        delete hooks.stop;\n        stop(gotoEnd);\n      };\n\n      if (typeof type !== \"string\") {\n        gotoEnd = clearQueue;\n        clearQueue = type;\n        type = undefined;\n      }\n      if (clearQueue) {\n        this.queue(type || \"fx\", []);\n      }\n\n      return this.each(function () {\n        var dequeue = true,\n        index = type != null && type + \"queueHooks\",\n        timers = jQuery.timers,\n        data = dataPriv.get(this);\n\n        if (index) {\n          if (data[index] && data[index].stop) {\n            stopQueue(data[index]);\n          }\n        } else {\n          for (index in data) {\n            if (data[index] && data[index].stop && rrun.test(index)) {\n              stopQueue(data[index]);\n            }\n          }\n        }\n\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && (\n          type == null || timers[index].queue === type)) {\n\n            timers[index].anim.stop(gotoEnd);\n            dequeue = false;\n            timers.splice(index, 1);\n          }\n        }\n\n        // Start the next in the queue if the last step wasn't forced.\n        // Timers currently will call their complete callbacks, which\n        // will dequeue but only if they were gotoEnd.\n        if (dequeue || !gotoEnd) {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    finish: function finish(type) {\n      if (type !== false) {\n        type = type || \"fx\";\n      }\n      return this.each(function () {\n        var index,\n        data = dataPriv.get(this),\n        queue = data[type + \"queue\"],\n        hooks = data[type + \"queueHooks\"],\n        timers = jQuery.timers,\n        length = queue ? queue.length : 0;\n\n        // Enable finishing flag on private data\n        data.finish = true;\n\n        // Empty the queue first\n        jQuery.queue(this, type, []);\n\n        if (hooks && hooks.stop) {\n          hooks.stop.call(this, true);\n        }\n\n        // Look for any active animations, and finish them\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && timers[index].queue === type) {\n            timers[index].anim.stop(true);\n            timers.splice(index, 1);\n          }\n        }\n\n        // Look for any animations in the old queue and finish them\n        for (index = 0; index < length; index++) {\n          if (queue[index] && queue[index].finish) {\n            queue[index].finish.call(this);\n          }\n        }\n\n        // Turn off finishing flag\n        delete data.finish;\n      });\n    } });\n\n\n  jQuery.each([\"toggle\", \"show\", \"hide\"], function (_i, name) {\n    var cssFn = jQuery.fn[name];\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return speed == null || typeof speed === \"boolean\" ?\n      cssFn.apply(this, arguments) :\n      this.animate(genFx(name, true), speed, easing, callback);\n    };\n  });\n\n  // Generate shortcuts for custom animations\n  jQuery.each({\n    slideDown: genFx(\"show\"),\n    slideUp: genFx(\"hide\"),\n    slideToggle: genFx(\"toggle\"),\n    fadeIn: { opacity: \"show\" },\n    fadeOut: { opacity: \"hide\" },\n    fadeToggle: { opacity: \"toggle\" } },\n  function (name, props) {\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return this.animate(props, speed, easing, callback);\n    };\n  });\n\n  jQuery.timers = [];\n  jQuery.fx.tick = function () {\n    var timer,\n    i = 0,\n    timers = jQuery.timers;\n\n    fxNow = Date.now();\n\n    for (; i < timers.length; i++) {\n      timer = timers[i];\n\n      // Run the timer and safely remove it when done (allowing for external removal)\n      if (!timer() && timers[i] === timer) {\n        timers.splice(i--, 1);\n      }\n    }\n\n    if (!timers.length) {\n      jQuery.fx.stop();\n    }\n    fxNow = undefined;\n  };\n\n  jQuery.fx.timer = function (timer) {\n    jQuery.timers.push(timer);\n    jQuery.fx.start();\n  };\n\n  jQuery.fx.interval = 13;\n  jQuery.fx.start = function () {\n    if (inProgress) {\n      return;\n    }\n\n    inProgress = true;\n    schedule();\n  };\n\n  jQuery.fx.stop = function () {\n    inProgress = null;\n  };\n\n  jQuery.fx.speeds = {\n    slow: 600,\n    fast: 200,\n\n    // Default speed\n    _default: 400 };\n\n\n\n  // Based off of the plugin by Clint Helfers, with permission.\n  // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\n  jQuery.fn.delay = function (time, type) {\n    time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;\n    type = type || \"fx\";\n\n    return this.queue(type, function (next, hooks) {\n      var timeout = window.setTimeout(next, time);\n      hooks.stop = function () {\n        window.clearTimeout(timeout);\n      };\n    });\n  };\n\n\n  (function () {\n    var input = document.createElement(\"input\"),\n    select = document.createElement(\"select\"),\n    opt = select.appendChild(document.createElement(\"option\"));\n\n    input.type = \"checkbox\";\n\n    // Support: Android <=4.3 only\n    // Default value for a checkbox should be \"on\"\n    support.checkOn = input.value !== \"\";\n\n    // Support: IE <=11 only\n    // Must access selectedIndex to make default options select\n    support.optSelected = opt.selected;\n\n    // Support: IE <=11 only\n    // An input loses its value after becoming a radio\n    input = document.createElement(\"input\");\n    input.value = \"t\";\n    input.type = \"radio\";\n    support.radioValue = input.value === \"t\";\n  })();\n\n\n  var boolHook,\n  attrHandle = jQuery.expr.attrHandle;\n\n  jQuery.fn.extend({\n    attr: function attr(name, value) {\n      return access(this, jQuery.attr, name, value, arguments.length > 1);\n    },\n\n    removeAttr: function removeAttr(name) {\n      return this.each(function () {\n        jQuery.removeAttr(this, name);\n      });\n    } });\n\n\n  jQuery.extend({\n    attr: function attr(elem, name, value) {\n      var ret,hooks,\n      nType = elem.nodeType;\n\n      // Don't get/set attributes on text, comment and attribute nodes\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      }\n\n      // Fallback to prop when attributes are not supported\n      if (typeof elem.getAttribute === \"undefined\") {\n        return jQuery.prop(elem, name, value);\n      }\n\n      // Attribute hooks are determined by the lowercase version\n      // Grab necessary hook if one is defined\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n        hooks = jQuery.attrHooks[name.toLowerCase()] || (\n        jQuery.expr.match.bool.test(name) ? boolHook : undefined);\n      }\n\n      if (value !== undefined) {\n        if (value === null) {\n          jQuery.removeAttr(elem, name);\n          return;\n        }\n\n        if (hooks && \"set\" in hooks &&\n        (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        elem.setAttribute(name, value + \"\");\n        return value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      ret = jQuery.find.attr(elem, name);\n\n      // Non-existent attributes return null, we normalize to undefined\n      return ret == null ? undefined : ret;\n    },\n\n    attrHooks: {\n      type: {\n        set: function set(elem, value) {\n          if (!support.radioValue && value === \"radio\" &&\n          nodeName(elem, \"input\")) {\n            var val = elem.value;\n            elem.setAttribute(\"type\", value);\n            if (val) {\n              elem.value = val;\n            }\n            return value;\n          }\n        } } },\n\n\n\n    removeAttr: function removeAttr(elem, value) {\n      var name,\n      i = 0,\n\n      // Attribute names can contain non-HTML whitespace characters\n      // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n      attrNames = value && value.match(rnothtmlwhite);\n\n      if (attrNames && elem.nodeType === 1) {\n        while (name = attrNames[i++]) {\n          elem.removeAttribute(name);\n        }\n      }\n    } });\n\n\n  // Hooks for boolean attributes\n  boolHook = {\n    set: function set(elem, value, name) {\n      if (value === false) {\n\n        // Remove boolean attributes when set to false\n        jQuery.removeAttr(elem, name);\n      } else {\n        elem.setAttribute(name, name);\n      }\n      return name;\n    } };\n\n\n  jQuery.each(jQuery.expr.match.bool.source.match(/\\w+/g), function (_i, name) {\n    var getter = attrHandle[name] || jQuery.find.attr;\n\n    attrHandle[name] = function (elem, name, isXML) {\n      var ret,handle,\n      lowercaseName = name.toLowerCase();\n\n      if (!isXML) {\n\n        // Avoid an infinite loop by temporarily removing this function from the getter\n        handle = attrHandle[lowercaseName];\n        attrHandle[lowercaseName] = ret;\n        ret = getter(elem, name, isXML) != null ?\n        lowercaseName :\n        null;\n        attrHandle[lowercaseName] = handle;\n      }\n      return ret;\n    };\n  });\n\n\n\n\n  var rfocusable = /^(?:input|select|textarea|button)$/i,\n  rclickable = /^(?:a|area)$/i;\n\n  jQuery.fn.extend({\n    prop: function prop(name, value) {\n      return access(this, jQuery.prop, name, value, arguments.length > 1);\n    },\n\n    removeProp: function removeProp(name) {\n      return this.each(function () {\n        delete this[jQuery.propFix[name] || name];\n      });\n    } });\n\n\n  jQuery.extend({\n    prop: function prop(elem, name, value) {\n      var ret,hooks,\n      nType = elem.nodeType;\n\n      // Don't get/set properties on text, comment and attribute nodes\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      }\n\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n\n        // Fix name and attach hooks\n        name = jQuery.propFix[name] || name;\n        hooks = jQuery.propHooks[name];\n      }\n\n      if (value !== undefined) {\n        if (hooks && \"set\" in hooks &&\n        (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        return elem[name] = value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      return elem[name];\n    },\n\n    propHooks: {\n      tabIndex: {\n        get: function get(elem) {\n\n          // Support: IE <=9 - 11 only\n          // elem.tabIndex doesn't always return the\n          // correct value when it hasn't been explicitly set\n          // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n          // Use proper attribute retrieval(#12072)\n          var tabindex = jQuery.find.attr(elem, \"tabindex\");\n\n          if (tabindex) {\n            return parseInt(tabindex, 10);\n          }\n\n          if (\n          rfocusable.test(elem.nodeName) ||\n          rclickable.test(elem.nodeName) &&\n          elem.href)\n          {\n            return 0;\n          }\n\n          return -1;\n        } } },\n\n\n\n    propFix: {\n      \"for\": \"htmlFor\",\n      \"class\": \"className\" } });\n\n\n\n  // Support: IE <=11 only\n  // Accessing the selectedIndex property\n  // forces the browser to respect setting selected\n  // on the option\n  // The getter ensures a default option is selected\n  // when in an optgroup\n  // eslint rule \"no-unused-expressions\" is disabled for this code\n  // since it considers such accessions noop\n  if (!support.optSelected) {\n    jQuery.propHooks.selected = {\n      get: function get(elem) {\n\n        /* eslint no-unused-expressions: \"off\" */\n\n        var parent = elem.parentNode;\n        if (parent && parent.parentNode) {\n          parent.parentNode.selectedIndex;\n        }\n        return null;\n      },\n      set: function set(elem) {\n\n        /* eslint no-unused-expressions: \"off\" */\n\n        var parent = elem.parentNode;\n        if (parent) {\n          parent.selectedIndex;\n\n          if (parent.parentNode) {\n            parent.parentNode.selectedIndex;\n          }\n        }\n      } };\n\n  }\n\n  jQuery.each([\n  \"tabIndex\",\n  \"readOnly\",\n  \"maxLength\",\n  \"cellSpacing\",\n  \"cellPadding\",\n  \"rowSpan\",\n  \"colSpan\",\n  \"useMap\",\n  \"frameBorder\",\n  \"contentEditable\"],\n  function () {\n    jQuery.propFix[this.toLowerCase()] = this;\n  });\n\n\n\n\n  // Strip and collapse whitespace according to HTML spec\n  // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n  function stripAndCollapse(value) {\n    var tokens = value.match(rnothtmlwhite) || [];\n    return tokens.join(\" \");\n  }\n\n\n  function getClass(elem) {\n    return elem.getAttribute && elem.getAttribute(\"class\") || \"\";\n  }\n\n  function classesToArray(value) {\n    if (Array.isArray(value)) {\n      return value;\n    }\n    if (typeof value === \"string\") {\n      return value.match(rnothtmlwhite) || [];\n    }\n    return [];\n  }\n\n  jQuery.fn.extend({\n    addClass: function addClass(value) {\n      var classes,elem,cur,curValue,clazz,j,finalValue,\n      i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).addClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem);\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n            while (clazz = classes[j++]) {\n              if (cur.indexOf(\" \" + clazz + \" \") < 0) {\n                cur += clazz + \" \";\n              }\n            }\n\n            // Only assign if different to avoid unneeded rendering.\n            finalValue = stripAndCollapse(cur);\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n\n    removeClass: function removeClass(value) {\n      var classes,elem,cur,curValue,clazz,j,finalValue,\n      i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).removeClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      if (!arguments.length) {\n        return this.attr(\"class\", \"\");\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem);\n\n          // This expression is here for better compressibility (see addClass)\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n            while (clazz = classes[j++]) {\n\n              // Remove *all* instances\n              while (cur.indexOf(\" \" + clazz + \" \") > -1) {\n                cur = cur.replace(\" \" + clazz + \" \", \" \");\n              }\n            }\n\n            // Only assign if different to avoid unneeded rendering.\n            finalValue = stripAndCollapse(cur);\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n\n    toggleClass: function toggleClass(value, stateVal) {\n      var type = _typeof(value),\n      isValidValue = type === \"string\" || Array.isArray(value);\n\n      if (typeof stateVal === \"boolean\" && isValidValue) {\n        return stateVal ? this.addClass(value) : this.removeClass(value);\n      }\n\n      if (isFunction(value)) {\n        return this.each(function (i) {\n          jQuery(this).toggleClass(\n          value.call(this, i, getClass(this), stateVal),\n          stateVal);\n\n        });\n      }\n\n      return this.each(function () {\n        var className, i, self, classNames;\n\n        if (isValidValue) {\n\n          // Toggle individual class names\n          i = 0;\n          self = jQuery(this);\n          classNames = classesToArray(value);\n\n          while (className = classNames[i++]) {\n\n            // Check each className given, space separated list\n            if (self.hasClass(className)) {\n              self.removeClass(className);\n            } else {\n              self.addClass(className);\n            }\n          }\n\n          // Toggle whole class name\n        } else if (value === undefined || type === \"boolean\") {\n          className = getClass(this);\n          if (className) {\n\n            // Store className if set\n            dataPriv.set(this, \"__className__\", className);\n          }\n\n          // If the element has a class name or if we're passed `false`,\n          // then remove the whole classname (if there was one, the above saved it).\n          // Otherwise bring back whatever was previously saved (if anything),\n          // falling back to the empty string if nothing was stored.\n          if (this.setAttribute) {\n            this.setAttribute(\"class\",\n            className || value === false ?\n            \"\" :\n            dataPriv.get(this, \"__className__\") || \"\");\n\n          }\n        }\n      });\n    },\n\n    hasClass: function hasClass(selector) {\n      var className,elem,\n      i = 0;\n\n      className = \" \" + selector + \" \";\n      while (elem = this[i++]) {\n        if (elem.nodeType === 1 &&\n        (\" \" + stripAndCollapse(getClass(elem)) + \" \").indexOf(className) > -1) {\n          return true;\n        }\n      }\n\n      return false;\n    } });\n\n\n\n\n\n  var rreturn = /\\r/g;\n\n  jQuery.fn.extend({\n    val: function val(value) {\n      var hooks,ret,valueIsFunction,\n      elem = this[0];\n\n      if (!arguments.length) {\n        if (elem) {\n          hooks = jQuery.valHooks[elem.type] ||\n          jQuery.valHooks[elem.nodeName.toLowerCase()];\n\n          if (hooks &&\n          \"get\" in hooks &&\n          (ret = hooks.get(elem, \"value\")) !== undefined)\n          {\n            return ret;\n          }\n\n          ret = elem.value;\n\n          // Handle most common string cases\n          if (typeof ret === \"string\") {\n            return ret.replace(rreturn, \"\");\n          }\n\n          // Handle cases where value is null/undef or number\n          return ret == null ? \"\" : ret;\n        }\n\n        return;\n      }\n\n      valueIsFunction = isFunction(value);\n\n      return this.each(function (i) {\n        var val;\n\n        if (this.nodeType !== 1) {\n          return;\n        }\n\n        if (valueIsFunction) {\n          val = value.call(this, i, jQuery(this).val());\n        } else {\n          val = value;\n        }\n\n        // Treat null/undefined as \"\"; convert numbers to string\n        if (val == null) {\n          val = \"\";\n\n        } else if (typeof val === \"number\") {\n          val += \"\";\n\n        } else if (Array.isArray(val)) {\n          val = jQuery.map(val, function (value) {\n            return value == null ? \"\" : value + \"\";\n          });\n        }\n\n        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];\n\n        // If set returns undefined, fall back to normal setting\n        if (!hooks || !(\"set\" in hooks) || hooks.set(this, val, \"value\") === undefined) {\n          this.value = val;\n        }\n      });\n    } });\n\n\n  jQuery.extend({\n    valHooks: {\n      option: {\n        get: function get(elem) {\n\n          var val = jQuery.find.attr(elem, \"value\");\n          return val != null ?\n          val :\n\n          // Support: IE <=10 - 11 only\n          // option.text throws exceptions (#14686, #14858)\n          // Strip and collapse whitespace\n          // https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n          stripAndCollapse(jQuery.text(elem));\n        } },\n\n      select: {\n        get: function get(elem) {\n          var value,option,i,\n          options = elem.options,\n          index = elem.selectedIndex,\n          one = elem.type === \"select-one\",\n          values = one ? null : [],\n          max = one ? index + 1 : options.length;\n\n          if (index < 0) {\n            i = max;\n\n          } else {\n            i = one ? index : 0;\n          }\n\n          // Loop through all the selected options\n          for (; i < max; i++) {\n            option = options[i];\n\n            // Support: IE <=9 only\n            // IE8-9 doesn't update selected after form reset (#2551)\n            if ((option.selected || i === index) &&\n\n            // Don't return options that are disabled or in a disabled optgroup\n            !option.disabled && (\n            !option.parentNode.disabled ||\n            !nodeName(option.parentNode, \"optgroup\"))) {\n\n              // Get the specific value for the option\n              value = jQuery(option).val();\n\n              // We don't need an array for one selects\n              if (one) {\n                return value;\n              }\n\n              // Multi-Selects return an array\n              values.push(value);\n            }\n          }\n\n          return values;\n        },\n\n        set: function set(elem, value) {\n          var optionSet,option,\n          options = elem.options,\n          values = jQuery.makeArray(value),\n          i = options.length;\n\n          while (i--) {\n            option = options[i];\n\n            /* eslint-disable no-cond-assign */\n\n            if (option.selected =\n            jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1)\n            {\n              optionSet = true;\n            }\n\n            /* eslint-enable no-cond-assign */\n          }\n\n          // Force browsers to behave consistently when non-matching value is set\n          if (!optionSet) {\n            elem.selectedIndex = -1;\n          }\n          return values;\n        } } } });\n\n\n\n\n  // Radios and checkboxes getter/setter\n  jQuery.each([\"radio\", \"checkbox\"], function () {\n    jQuery.valHooks[this] = {\n      set: function set(elem, value) {\n        if (Array.isArray(value)) {\n          return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;\n        }\n      } };\n\n    if (!support.checkOn) {\n      jQuery.valHooks[this].get = function (elem) {\n        return elem.getAttribute(\"value\") === null ? \"on\" : elem.value;\n      };\n    }\n  });\n\n\n\n\n  // Return jQuery for attributes-only inclusion\n\n\n  support.focusin = \"onfocusin\" in window;\n\n\n  var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n  stopPropagationCallback = function stopPropagationCallback(e) {\n    e.stopPropagation();\n  };\n\n  jQuery.extend(jQuery.event, {\n\n    trigger: function trigger(event, data, elem, onlyHandlers) {\n\n      var i,cur,tmp,bubbleType,ontype,handle,special,lastElement,\n      eventPath = [elem || document],\n      type = hasOwn.call(event, \"type\") ? event.type : event,\n      namespaces = hasOwn.call(event, \"namespace\") ? event.namespace.split(\".\") : [];\n\n      cur = lastElement = tmp = elem = elem || document;\n\n      // Don't do events on text and comment nodes\n      if (elem.nodeType === 3 || elem.nodeType === 8) {\n        return;\n      }\n\n      // focus/blur morphs to focusin/out; ensure we're not firing them right now\n      if (rfocusMorph.test(type + jQuery.event.triggered)) {\n        return;\n      }\n\n      if (type.indexOf(\".\") > -1) {\n\n        // Namespaced trigger; create a regexp to match event type in handle()\n        namespaces = type.split(\".\");\n        type = namespaces.shift();\n        namespaces.sort();\n      }\n      ontype = type.indexOf(\":\") < 0 && \"on\" + type;\n\n      // Caller can pass in a jQuery.Event object, Object, or just an event type string\n      event = event[jQuery.expando] ?\n      event :\n      new jQuery.Event(type, _typeof(event) === \"object\" && event);\n\n      // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n      event.isTrigger = onlyHandlers ? 2 : 3;\n      event.namespace = namespaces.join(\".\");\n      event.rnamespace = event.namespace ?\n      new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\") :\n      null;\n\n      // Clean up the event in case it is being reused\n      event.result = undefined;\n      if (!event.target) {\n        event.target = elem;\n      }\n\n      // Clone any incoming data and prepend the event, creating the handler arg list\n      data = data == null ?\n      [event] :\n      jQuery.makeArray(data, [event]);\n\n      // Allow special events to draw outside the lines\n      special = jQuery.event.special[type] || {};\n      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {\n        return;\n      }\n\n      // Determine event propagation path in advance, per W3C events spec (#9951)\n      // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n      if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {\n\n        bubbleType = special.delegateType || type;\n        if (!rfocusMorph.test(bubbleType + type)) {\n          cur = cur.parentNode;\n        }\n        for (; cur; cur = cur.parentNode) {\n          eventPath.push(cur);\n          tmp = cur;\n        }\n\n        // Only add window if we got to document (e.g., not plain obj or detached DOM)\n        if (tmp === (elem.ownerDocument || document)) {\n          eventPath.push(tmp.defaultView || tmp.parentWindow || window);\n        }\n      }\n\n      // Fire handlers on the event path\n      i = 0;\n      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {\n        lastElement = cur;\n        event.type = i > 1 ?\n        bubbleType :\n        special.bindType || type;\n\n        // jQuery handler\n        handle = (\n        dataPriv.get(cur, \"events\") || Object.create(null))[\n        event.type] &&\n        dataPriv.get(cur, \"handle\");\n        if (handle) {\n          handle.apply(cur, data);\n        }\n\n        // Native handler\n        handle = ontype && cur[ontype];\n        if (handle && handle.apply && acceptData(cur)) {\n          event.result = handle.apply(cur, data);\n          if (event.result === false) {\n            event.preventDefault();\n          }\n        }\n      }\n      event.type = type;\n\n      // If nobody prevented the default action, do it now\n      if (!onlyHandlers && !event.isDefaultPrevented()) {\n\n        if ((!special._default ||\n        special._default.apply(eventPath.pop(), data) === false) &&\n        acceptData(elem)) {\n\n          // Call a native DOM method on the target with the same name as the event.\n          // Don't do default actions on window, that's where global variables be (#6170)\n          if (ontype && isFunction(elem[type]) && !isWindow(elem)) {\n\n            // Don't re-trigger an onFOO event when we call its FOO() method\n            tmp = elem[ontype];\n\n            if (tmp) {\n              elem[ontype] = null;\n            }\n\n            // Prevent re-triggering of the same event, since we already bubbled it above\n            jQuery.event.triggered = type;\n\n            if (event.isPropagationStopped()) {\n              lastElement.addEventListener(type, stopPropagationCallback);\n            }\n\n            elem[type]();\n\n            if (event.isPropagationStopped()) {\n              lastElement.removeEventListener(type, stopPropagationCallback);\n            }\n\n            jQuery.event.triggered = undefined;\n\n            if (tmp) {\n              elem[ontype] = tmp;\n            }\n          }\n        }\n      }\n\n      return event.result;\n    },\n\n    // Piggyback on a donor event to simulate a different one\n    // Used only for `focus(in | out)` events\n    simulate: function simulate(type, elem, event) {\n      var e = jQuery.extend(\n      new jQuery.Event(),\n      event,\n      {\n        type: type,\n        isSimulated: true });\n\n\n\n      jQuery.event.trigger(e, null, elem);\n    } });\n\n\n\n  jQuery.fn.extend({\n\n    trigger: function trigger(type, data) {\n      return this.each(function () {\n        jQuery.event.trigger(type, data, this);\n      });\n    },\n    triggerHandler: function triggerHandler(type, data) {\n      var elem = this[0];\n      if (elem) {\n        return jQuery.event.trigger(type, data, elem, true);\n      }\n    } });\n\n\n\n  // Support: Firefox <=44\n  // Firefox doesn't have focus(in | out) events\n  // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n  //\n  // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n  // focus(in | out) events fire after focus & blur events,\n  // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n  // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n  if (!support.focusin) {\n    jQuery.each({ focus: \"focusin\", blur: \"focusout\" }, function (orig, fix) {\n\n      // Attach a single capturing handler on the document while someone wants focusin/focusout\n      var handler = function handler(event) {\n        jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));\n      };\n\n      jQuery.event.special[fix] = {\n        setup: function setup() {\n\n          // Handle: regular nodes (via `this.ownerDocument`), window\n          // (via `this.document`) & document (via `this`).\n          var doc = this.ownerDocument || this.document || this,\n          attaches = dataPriv.access(doc, fix);\n\n          if (!attaches) {\n            doc.addEventListener(orig, handler, true);\n          }\n          dataPriv.access(doc, fix, (attaches || 0) + 1);\n        },\n        teardown: function teardown() {\n          var doc = this.ownerDocument || this.document || this,\n          attaches = dataPriv.access(doc, fix) - 1;\n\n          if (!attaches) {\n            doc.removeEventListener(orig, handler, true);\n            dataPriv.remove(doc, fix);\n\n          } else {\n            dataPriv.access(doc, fix, attaches);\n          }\n        } };\n\n    });\n  }\n  var location = window.location;\n\n  var nonce = { guid: Date.now() };\n\n  var rquery = /\\?/;\n\n\n\n  // Cross-browser xml parsing\n  jQuery.parseXML = function (data) {\n    var xml;\n    if (!data || typeof data !== \"string\") {\n      return null;\n    }\n\n    // Support: IE 9 - 11 only\n    // IE throws on parseFromString with invalid input.\n    try {\n      xml = new window.DOMParser().parseFromString(data, \"text/xml\");\n    } catch (e) {\n      xml = undefined;\n    }\n\n    if (!xml || xml.getElementsByTagName(\"parsererror\").length) {\n      jQuery.error(\"Invalid XML: \" + data);\n    }\n    return xml;\n  };\n\n\n  var\n  rbracket = /\\[\\]$/,\n  rCRLF = /\\r?\\n/g,\n  rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n  rsubmittable = /^(?:input|select|textarea|keygen)/i;\n\n  function buildParams(prefix, obj, traditional, add) {\n    var name;\n\n    if (Array.isArray(obj)) {\n\n      // Serialize array item.\n      jQuery.each(obj, function (i, v) {\n        if (traditional || rbracket.test(prefix)) {\n\n          // Treat each array item as a scalar.\n          add(prefix, v);\n\n        } else {\n\n          // Item is non-scalar (array or object), encode its numeric index.\n          buildParams(\n          prefix + \"[\" + (_typeof(v) === \"object\" && v != null ? i : \"\") + \"]\",\n          v,\n          traditional,\n          add);\n\n        }\n      });\n\n    } else if (!traditional && toType(obj) === \"object\") {\n\n      // Serialize object item.\n      for (name in obj) {\n        buildParams(prefix + \"[\" + name + \"]\", obj[name], traditional, add);\n      }\n\n    } else {\n\n      // Serialize scalar item.\n      add(prefix, obj);\n    }\n  }\n\n  // Serialize an array of form elements or a set of\n  // key/values into a query string\n  jQuery.param = function (a, traditional) {\n    var prefix,\n    s = [],\n    add = function add(key, valueOrFunction) {\n\n      // If value is a function, invoke it and use its return value\n      var value = isFunction(valueOrFunction) ?\n      valueOrFunction() :\n      valueOrFunction;\n\n      s[s.length] = encodeURIComponent(key) + \"=\" +\n      encodeURIComponent(value == null ? \"\" : value);\n    };\n\n    if (a == null) {\n      return \"\";\n    }\n\n    // If an array was passed in, assume that it is an array of form elements.\n    if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {\n\n      // Serialize the form elements\n      jQuery.each(a, function () {\n        add(this.name, this.value);\n      });\n\n    } else {\n\n      // If traditional, encode the \"old\" way (the way 1.3.2 or older\n      // did it), otherwise encode params recursively.\n      for (prefix in a) {\n        buildParams(prefix, a[prefix], traditional, add);\n      }\n    }\n\n    // Return the resulting serialization\n    return s.join(\"&\");\n  };\n\n  jQuery.fn.extend({\n    serialize: function serialize() {\n      return jQuery.param(this.serializeArray());\n    },\n    serializeArray: function serializeArray() {\n      return this.map(function () {\n\n        // Can add propHook for \"elements\" to filter or add form elements\n        var elements = jQuery.prop(this, \"elements\");\n        return elements ? jQuery.makeArray(elements) : this;\n      }).\n      filter(function () {\n        var type = this.type;\n\n        // Use .is( \":disabled\" ) so that fieldset[disabled] works\n        return this.name && !jQuery(this).is(\":disabled\") &&\n        rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (\n        this.checked || !rcheckableType.test(type));\n      }).\n      map(function (_i, elem) {\n        var val = jQuery(this).val();\n\n        if (val == null) {\n          return null;\n        }\n\n        if (Array.isArray(val)) {\n          return jQuery.map(val, function (val) {\n            return { name: elem.name, value: val.replace(rCRLF, \"\\r\\n\") };\n          });\n        }\n\n        return { name: elem.name, value: val.replace(rCRLF, \"\\r\\n\") };\n      }).get();\n    } });\n\n\n\n  var\n  r20 = /%20/g,\n  rhash = /#.*$/,\n  rantiCache = /([?&])_=[^&]*/,\n  rheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n  // #7653, #8125, #8152: local protocol detection\n  rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n  rnoContent = /^(?:GET|HEAD)$/,\n  rprotocol = /^\\/\\//,\n\n  /* Prefilters\n   * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n   * 2) These are called:\n   *    - BEFORE asking for a transport\n   *    - AFTER param serialization (s.data is a string if s.processData is true)\n   * 3) key is the dataType\n   * 4) the catchall symbol \"*\" can be used\n   * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n   */\n  prefilters = {},\n\n  /* Transports bindings\n   * 1) key is the dataType\n   * 2) the catchall symbol \"*\" can be used\n   * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n   */\n  transports = {},\n\n  // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n  allTypes = \"*/\".concat(\"*\"),\n\n  // Anchor tag for parsing the document origin\n  originAnchor = document.createElement(\"a\");\n  originAnchor.href = location.href;\n\n  // Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\n  function addToPrefiltersOrTransports(structure) {\n\n    // dataTypeExpression is optional and defaults to \"*\"\n    return function (dataTypeExpression, func) {\n\n      if (typeof dataTypeExpression !== \"string\") {\n        func = dataTypeExpression;\n        dataTypeExpression = \"*\";\n      }\n\n      var dataType,\n      i = 0,\n      dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];\n\n      if (isFunction(func)) {\n\n        // For each dataType in the dataTypeExpression\n        while (dataType = dataTypes[i++]) {\n\n          // Prepend if requested\n          if (dataType[0] === \"+\") {\n            dataType = dataType.slice(1) || \"*\";\n            (structure[dataType] = structure[dataType] || []).unshift(func);\n\n            // Otherwise append\n          } else {\n            (structure[dataType] = structure[dataType] || []).push(func);\n          }\n        }\n      }\n    };\n  }\n\n  // Base inspection function for prefilters and transports\n  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {\n\n    var inspected = {},\n    seekingTransport = structure === transports;\n\n    function inspect(dataType) {\n      var selected;\n      inspected[dataType] = true;\n      jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {\n        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);\n        if (typeof dataTypeOrTransport === \"string\" &&\n        !seekingTransport && !inspected[dataTypeOrTransport]) {\n\n          options.dataTypes.unshift(dataTypeOrTransport);\n          inspect(dataTypeOrTransport);\n          return false;\n        } else if (seekingTransport) {\n          return !(selected = dataTypeOrTransport);\n        }\n      });\n      return selected;\n    }\n\n    return inspect(options.dataTypes[0]) || !inspected[\"*\"] && inspect(\"*\");\n  }\n\n  // A special extend for ajax options\n  // that takes \"flat\" options (not to be deep extended)\n  // Fixes #9887\n  function ajaxExtend(target, src) {\n    var key,deep,\n    flatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n    for (key in src) {\n      if (src[key] !== undefined) {\n        (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];\n      }\n    }\n    if (deep) {\n      jQuery.extend(true, target, deep);\n    }\n\n    return target;\n  }\n\n  /* Handles responses to an ajax request:\n   * - finds the right dataType (mediates between content-type and expected dataType)\n   * - returns the corresponding response\n   */\n  function ajaxHandleResponses(s, jqXHR, responses) {\n\n    var ct,type,finalDataType,firstDataType,\n    contents = s.contents,\n    dataTypes = s.dataTypes;\n\n    // Remove auto dataType and get content-type in the process\n    while (dataTypes[0] === \"*\") {\n      dataTypes.shift();\n      if (ct === undefined) {\n        ct = s.mimeType || jqXHR.getResponseHeader(\"Content-Type\");\n      }\n    }\n\n    // Check if we're dealing with a known content-type\n    if (ct) {\n      for (type in contents) {\n        if (contents[type] && contents[type].test(ct)) {\n          dataTypes.unshift(type);\n          break;\n        }\n      }\n    }\n\n    // Check to see if we have a response for the expected dataType\n    if (dataTypes[0] in responses) {\n      finalDataType = dataTypes[0];\n    } else {\n\n      // Try convertible dataTypes\n      for (type in responses) {\n        if (!dataTypes[0] || s.converters[type + \" \" + dataTypes[0]]) {\n          finalDataType = type;\n          break;\n        }\n        if (!firstDataType) {\n          firstDataType = type;\n        }\n      }\n\n      // Or just use first one\n      finalDataType = finalDataType || firstDataType;\n    }\n\n    // If we found a dataType\n    // We add the dataType to the list if needed\n    // and return the corresponding response\n    if (finalDataType) {\n      if (finalDataType !== dataTypes[0]) {\n        dataTypes.unshift(finalDataType);\n      }\n      return responses[finalDataType];\n    }\n  }\n\n  /* Chain conversions given the request and the original response\n   * Also sets the responseXXX fields on the jqXHR instance\n   */\n  function ajaxConvert(s, response, jqXHR, isSuccess) {\n    var conv2,current,conv,tmp,prev,\n    converters = {},\n\n    // Work with a copy of dataTypes in case we need to modify it for conversion\n    dataTypes = s.dataTypes.slice();\n\n    // Create converters map with lowercased keys\n    if (dataTypes[1]) {\n      for (conv in s.converters) {\n        converters[conv.toLowerCase()] = s.converters[conv];\n      }\n    }\n\n    current = dataTypes.shift();\n\n    // Convert to each sequential dataType\n    while (current) {\n\n      if (s.responseFields[current]) {\n        jqXHR[s.responseFields[current]] = response;\n      }\n\n      // Apply the dataFilter if provided\n      if (!prev && isSuccess && s.dataFilter) {\n        response = s.dataFilter(response, s.dataType);\n      }\n\n      prev = current;\n      current = dataTypes.shift();\n\n      if (current) {\n\n        // There's only work to do if current dataType is non-auto\n        if (current === \"*\") {\n\n          current = prev;\n\n          // Convert response if prev dataType is non-auto and differs from current\n        } else if (prev !== \"*\" && prev !== current) {\n\n          // Seek a direct converter\n          conv = converters[prev + \" \" + current] || converters[\"* \" + current];\n\n          // If none found, seek a pair\n          if (!conv) {\n            for (conv2 in converters) {\n\n              // If conv2 outputs current\n              tmp = conv2.split(\" \");\n              if (tmp[1] === current) {\n\n                // If prev can be converted to accepted input\n                conv = converters[prev + \" \" + tmp[0]] ||\n                converters[\"* \" + tmp[0]];\n                if (conv) {\n\n                  // Condense equivalence converters\n                  if (conv === true) {\n                    conv = converters[conv2];\n\n                    // Otherwise, insert the intermediate dataType\n                  } else if (converters[conv2] !== true) {\n                    current = tmp[0];\n                    dataTypes.unshift(tmp[1]);\n                  }\n                  break;\n                }\n              }\n            }\n          }\n\n          // Apply converter (if not an equivalence)\n          if (conv !== true) {\n\n            // Unless errors are allowed to bubble, catch and return them\n            if (conv && s[\"throws\"]) {\n              response = conv(response);\n            } else {\n              try {\n                response = conv(response);\n              } catch (e) {\n                return {\n                  state: \"parsererror\",\n                  error: conv ? e : \"No conversion from \" + prev + \" to \" + current };\n\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return { state: \"success\", data: response };\n  }\n\n  jQuery.extend({\n\n    // Counter for holding the number of active queries\n    active: 0,\n\n    // Last-Modified header cache for next request\n    lastModified: {},\n    etag: {},\n\n    ajaxSettings: {\n      url: location.href,\n      type: \"GET\",\n      isLocal: rlocalProtocol.test(location.protocol),\n      global: true,\n      processData: true,\n      async: true,\n      contentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n      /*\n      timeout: 0,\n      data: null,\n      dataType: null,\n      username: null,\n      password: null,\n      cache: null,\n      throws: false,\n      traditional: false,\n      headers: {},\n      */\n\n      accepts: {\n        \"*\": allTypes,\n        text: \"text/plain\",\n        html: \"text/html\",\n        xml: \"application/xml, text/xml\",\n        json: \"application/json, text/javascript\" },\n\n\n      contents: {\n        xml: /\\bxml\\b/,\n        html: /\\bhtml/,\n        json: /\\bjson\\b/ },\n\n\n      responseFields: {\n        xml: \"responseXML\",\n        text: \"responseText\",\n        json: \"responseJSON\" },\n\n\n      // Data converters\n      // Keys separate source (or catchall \"*\") and destination types with a single space\n      converters: {\n\n        // Convert anything to text\n        \"* text\": String,\n\n        // Text to html (true = no transformation)\n        \"text html\": true,\n\n        // Evaluate text as a json expression\n        \"text json\": JSON.parse,\n\n        // Parse text as xml\n        \"text xml\": jQuery.parseXML },\n\n\n      // For options that shouldn't be deep extended:\n      // you can add your own custom options here if\n      // and when you create one that shouldn't be\n      // deep extended (see ajaxExtend)\n      flatOptions: {\n        url: true,\n        context: true } },\n\n\n\n    // Creates a full fledged settings object into target\n    // with both ajaxSettings and settings fields.\n    // If target is omitted, writes into ajaxSettings.\n    ajaxSetup: function ajaxSetup(target, settings) {\n      return settings ?\n\n      // Building a settings object\n      ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :\n\n      // Extending ajaxSettings\n      ajaxExtend(jQuery.ajaxSettings, target);\n    },\n\n    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),\n    ajaxTransport: addToPrefiltersOrTransports(transports),\n\n    // Main method\n    ajax: function ajax(url, options) {\n\n      // If url is an object, simulate pre-1.5 signature\n      if (_typeof(url) === \"object\") {\n        options = url;\n        url = undefined;\n      }\n\n      // Force options to be an object\n      options = options || {};\n\n      var transport,\n\n      // URL without anti-cache param\n      cacheURL,\n\n      // Response headers\n      responseHeadersString,\n      responseHeaders,\n\n      // timeout handle\n      timeoutTimer,\n\n      // Url cleanup var\n      urlAnchor,\n\n      // Request state (becomes false upon send and true upon completion)\n      completed,\n\n      // To know if global events are to be dispatched\n      fireGlobals,\n\n      // Loop variable\n      i,\n\n      // uncached part of the url\n      uncached,\n\n      // Create the final options object\n      s = jQuery.ajaxSetup({}, options),\n\n      // Callbacks context\n      callbackContext = s.context || s,\n\n      // Context for global events is callbackContext if it is a DOM node or jQuery collection\n      globalEventContext = s.context && (\n      callbackContext.nodeType || callbackContext.jquery) ?\n      jQuery(callbackContext) :\n      jQuery.event,\n\n      // Deferreds\n      deferred = jQuery.Deferred(),\n      completeDeferred = jQuery.Callbacks(\"once memory\"),\n\n      // Status-dependent callbacks\n      _statusCode = s.statusCode || {},\n\n      // Headers (they are sent all at once)\n      requestHeaders = {},\n      requestHeadersNames = {},\n\n      // Default abort message\n      strAbort = \"canceled\",\n\n      // Fake xhr\n      jqXHR = {\n        readyState: 0,\n\n        // Builds headers hashtable if needed\n        getResponseHeader: function getResponseHeader(key) {\n          var match;\n          if (completed) {\n            if (!responseHeaders) {\n              responseHeaders = {};\n              while (match = rheaders.exec(responseHeadersString)) {\n                responseHeaders[match[1].toLowerCase() + \" \"] =\n                (responseHeaders[match[1].toLowerCase() + \" \"] || []).\n                concat(match[2]);\n              }\n            }\n            match = responseHeaders[key.toLowerCase() + \" \"];\n          }\n          return match == null ? null : match.join(\", \");\n        },\n\n        // Raw string\n        getAllResponseHeaders: function getAllResponseHeaders() {\n          return completed ? responseHeadersString : null;\n        },\n\n        // Caches the header\n        setRequestHeader: function setRequestHeader(name, value) {\n          if (completed == null) {\n            name = requestHeadersNames[name.toLowerCase()] =\n            requestHeadersNames[name.toLowerCase()] || name;\n            requestHeaders[name] = value;\n          }\n          return this;\n        },\n\n        // Overrides response content-type header\n        overrideMimeType: function overrideMimeType(type) {\n          if (completed == null) {\n            s.mimeType = type;\n          }\n          return this;\n        },\n\n        // Status-dependent callbacks\n        statusCode: function statusCode(map) {\n          var code;\n          if (map) {\n            if (completed) {\n\n              // Execute the appropriate callbacks\n              jqXHR.always(map[jqXHR.status]);\n            } else {\n\n              // Lazy-add the new callbacks in a way that preserves old ones\n              for (code in map) {\n                _statusCode[code] = [_statusCode[code], map[code]];\n              }\n            }\n          }\n          return this;\n        },\n\n        // Cancel the request\n        abort: function abort(statusText) {\n          var finalText = statusText || strAbort;\n          if (transport) {\n            transport.abort(finalText);\n          }\n          done(0, finalText);\n          return this;\n        } };\n\n\n      // Attach deferreds\n      deferred.promise(jqXHR);\n\n      // Add protocol if not provided (prefilters might expect it)\n      // Handle falsy url in the settings object (#10093: consistency with old signature)\n      // We also use the url parameter if available\n      s.url = ((url || s.url || location.href) + \"\").\n      replace(rprotocol, location.protocol + \"//\");\n\n      // Alias method option to type as per ticket #12004\n      s.type = options.method || options.type || s.method || s.type;\n\n      // Extract dataTypes list\n      s.dataTypes = (s.dataType || \"*\").toLowerCase().match(rnothtmlwhite) || [\"\"];\n\n      // A cross-domain request is in order when the origin doesn't match the current origin.\n      if (s.crossDomain == null) {\n        urlAnchor = document.createElement(\"a\");\n\n        // Support: IE <=8 - 11, Edge 12 - 15\n        // IE throws exception on accessing the href property if url is malformed,\n        // e.g. http://example.com:80x/\n        try {\n          urlAnchor.href = s.url;\n\n          // Support: IE <=8 - 11 only\n          // Anchor's host property isn't correctly set when s.url is relative\n          urlAnchor.href = urlAnchor.href;\n          s.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n          urlAnchor.protocol + \"//\" + urlAnchor.host;\n        } catch (e) {\n\n          // If there is an error parsing the URL, assume it is crossDomain,\n          // it can be rejected by the transport if it is invalid\n          s.crossDomain = true;\n        }\n      }\n\n      // Convert data if not already a string\n      if (s.data && s.processData && typeof s.data !== \"string\") {\n        s.data = jQuery.param(s.data, s.traditional);\n      }\n\n      // Apply prefilters\n      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);\n\n      // If request was aborted inside a prefilter, stop there\n      if (completed) {\n        return jqXHR;\n      }\n\n      // We can fire global events as of now if asked to\n      // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n      fireGlobals = jQuery.event && s.global;\n\n      // Watch for a new set of requests\n      if (fireGlobals && jQuery.active++ === 0) {\n        jQuery.event.trigger(\"ajaxStart\");\n      }\n\n      // Uppercase the type\n      s.type = s.type.toUpperCase();\n\n      // Determine if request has content\n      s.hasContent = !rnoContent.test(s.type);\n\n      // Save the URL in case we're toying with the If-Modified-Since\n      // and/or If-None-Match header later on\n      // Remove hash to simplify url manipulation\n      cacheURL = s.url.replace(rhash, \"\");\n\n      // More options handling for requests with no content\n      if (!s.hasContent) {\n\n        // Remember the hash so we can put it back\n        uncached = s.url.slice(cacheURL.length);\n\n        // If data is available and should be processed, append data to url\n        if (s.data && (s.processData || typeof s.data === \"string\")) {\n          cacheURL += (rquery.test(cacheURL) ? \"&\" : \"?\") + s.data;\n\n          // #9682: remove data so that it's not used in an eventual retry\n          delete s.data;\n        }\n\n        // Add or update anti-cache param if needed\n        if (s.cache === false) {\n          cacheURL = cacheURL.replace(rantiCache, \"$1\");\n          uncached = (rquery.test(cacheURL) ? \"&\" : \"?\") + \"_=\" + nonce.guid++ +\n          uncached;\n        }\n\n        // Put hash and anti-cache on the URL that will be requested (gh-1732)\n        s.url = cacheURL + uncached;\n\n        // Change '%20' to '+' if this is encoded form body content (gh-2658)\n      } else if (s.data && s.processData &&\n      (s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") === 0) {\n        s.data = s.data.replace(r20, \"+\");\n      }\n\n      // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n      if (s.ifModified) {\n        if (jQuery.lastModified[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-Modified-Since\", jQuery.lastModified[cacheURL]);\n        }\n        if (jQuery.etag[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-None-Match\", jQuery.etag[cacheURL]);\n        }\n      }\n\n      // Set the correct header, if data is being sent\n      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {\n        jqXHR.setRequestHeader(\"Content-Type\", s.contentType);\n      }\n\n      // Set the Accepts header for the server, depending on the dataType\n      jqXHR.setRequestHeader(\n      \"Accept\",\n      s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?\n      s.accepts[s.dataTypes[0]] + (\n      s.dataTypes[0] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\") :\n      s.accepts[\"*\"]);\n\n\n      // Check for headers option\n      for (i in s.headers) {\n        jqXHR.setRequestHeader(i, s.headers[i]);\n      }\n\n      // Allow custom headers/mimetypes and early abort\n      if (s.beforeSend && (\n      s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {\n\n        // Abort if not done already and return\n        return jqXHR.abort();\n      }\n\n      // Aborting is no longer a cancellation\n      strAbort = \"abort\";\n\n      // Install callbacks on deferreds\n      completeDeferred.add(s.complete);\n      jqXHR.done(s.success);\n      jqXHR.fail(s.error);\n\n      // Get transport\n      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);\n\n      // If no transport, we auto-abort\n      if (!transport) {\n        done(-1, \"No Transport\");\n      } else {\n        jqXHR.readyState = 1;\n\n        // Send global event\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxSend\", [jqXHR, s]);\n        }\n\n        // If request was aborted inside ajaxSend, stop there\n        if (completed) {\n          return jqXHR;\n        }\n\n        // Timeout\n        if (s.async && s.timeout > 0) {\n          timeoutTimer = window.setTimeout(function () {\n            jqXHR.abort(\"timeout\");\n          }, s.timeout);\n        }\n\n        try {\n          completed = false;\n          transport.send(requestHeaders, done);\n        } catch (e) {\n\n          // Rethrow post-completion exceptions\n          if (completed) {\n            throw e;\n          }\n\n          // Propagate others as results\n          done(-1, e);\n        }\n      }\n\n      // Callback for when everything is done\n      function done(status, nativeStatusText, responses, headers) {\n        var isSuccess,success,error,response,modified,\n        statusText = nativeStatusText;\n\n        // Ignore repeat invocations\n        if (completed) {\n          return;\n        }\n\n        completed = true;\n\n        // Clear timeout if it exists\n        if (timeoutTimer) {\n          window.clearTimeout(timeoutTimer);\n        }\n\n        // Dereference transport for early garbage collection\n        // (no matter how long the jqXHR object will be used)\n        transport = undefined;\n\n        // Cache response headers\n        responseHeadersString = headers || \"\";\n\n        // Set readyState\n        jqXHR.readyState = status > 0 ? 4 : 0;\n\n        // Determine if successful\n        isSuccess = status >= 200 && status < 300 || status === 304;\n\n        // Get response data\n        if (responses) {\n          response = ajaxHandleResponses(s, jqXHR, responses);\n        }\n\n        // Use a noop converter for missing script\n        if (!isSuccess && jQuery.inArray(\"script\", s.dataTypes) > -1) {\n          s.converters[\"text script\"] = function () {};\n        }\n\n        // Convert no matter what (that way responseXXX fields are always set)\n        response = ajaxConvert(s, response, jqXHR, isSuccess);\n\n        // If successful, handle type chaining\n        if (isSuccess) {\n\n          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n          if (s.ifModified) {\n            modified = jqXHR.getResponseHeader(\"Last-Modified\");\n            if (modified) {\n              jQuery.lastModified[cacheURL] = modified;\n            }\n            modified = jqXHR.getResponseHeader(\"etag\");\n            if (modified) {\n              jQuery.etag[cacheURL] = modified;\n            }\n          }\n\n          // if no content\n          if (status === 204 || s.type === \"HEAD\") {\n            statusText = \"nocontent\";\n\n            // if not modified\n          } else if (status === 304) {\n            statusText = \"notmodified\";\n\n            // If we have data, let's convert it\n          } else {\n            statusText = response.state;\n            success = response.data;\n            error = response.error;\n            isSuccess = !error;\n          }\n        } else {\n\n          // Extract error from statusText and normalize for non-aborts\n          error = statusText;\n          if (status || !statusText) {\n            statusText = \"error\";\n            if (status < 0) {\n              status = 0;\n            }\n          }\n        }\n\n        // Set data for the fake xhr object\n        jqXHR.status = status;\n        jqXHR.statusText = (nativeStatusText || statusText) + \"\";\n\n        // Success/Error\n        if (isSuccess) {\n          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);\n        } else {\n          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);\n        }\n\n        // Status-dependent callbacks\n        jqXHR.statusCode(_statusCode);\n        _statusCode = undefined;\n\n        if (fireGlobals) {\n          globalEventContext.trigger(isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n          [jqXHR, s, isSuccess ? success : error]);\n        }\n\n        // Complete\n        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);\n\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxComplete\", [jqXHR, s]);\n\n          // Handle the global AJAX counter\n          if (! --jQuery.active) {\n            jQuery.event.trigger(\"ajaxStop\");\n          }\n        }\n      }\n\n      return jqXHR;\n    },\n\n    getJSON: function getJSON(url, data, callback) {\n      return jQuery.get(url, data, callback, \"json\");\n    },\n\n    getScript: function getScript(url, callback) {\n      return jQuery.get(url, undefined, callback, \"script\");\n    } });\n\n\n  jQuery.each([\"get\", \"post\"], function (_i, method) {\n    jQuery[method] = function (url, data, callback, type) {\n\n      // Shift arguments if data argument was omitted\n      if (isFunction(data)) {\n        type = type || callback;\n        callback = data;\n        data = undefined;\n      }\n\n      // The url can be an options object (which then must have .url)\n      return jQuery.ajax(jQuery.extend({\n        url: url,\n        type: method,\n        dataType: type,\n        data: data,\n        success: callback },\n      jQuery.isPlainObject(url) && url));\n    };\n  });\n\n  jQuery.ajaxPrefilter(function (s) {\n    var i;\n    for (i in s.headers) {\n      if (i.toLowerCase() === \"content-type\") {\n        s.contentType = s.headers[i] || \"\";\n      }\n    }\n  });\n\n\n  jQuery._evalUrl = function (url, options, doc) {\n    return jQuery.ajax({\n      url: url,\n\n      // Make this explicit, since user can override this through ajaxSetup (#11264)\n      type: \"GET\",\n      dataType: \"script\",\n      cache: true,\n      async: false,\n      global: false,\n\n      // Only evaluate the response if it is successful (gh-4126)\n      // dataFilter is not invoked for failure responses, so using it instead\n      // of the default converter is kludgy but it works.\n      converters: {\n        \"text script\": function textScript() {} },\n\n      dataFilter: function dataFilter(response) {\n        jQuery.globalEval(response, options, doc);\n      } });\n\n  };\n\n\n  jQuery.fn.extend({\n    wrapAll: function wrapAll(html) {\n      var wrap;\n\n      if (this[0]) {\n        if (isFunction(html)) {\n          html = html.call(this[0]);\n        }\n\n        // The elements to wrap the target around\n        wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);\n\n        if (this[0].parentNode) {\n          wrap.insertBefore(this[0]);\n        }\n\n        wrap.map(function () {\n          var elem = this;\n\n          while (elem.firstElementChild) {\n            elem = elem.firstElementChild;\n          }\n\n          return elem;\n        }).append(this);\n      }\n\n      return this;\n    },\n\n    wrapInner: function wrapInner(html) {\n      if (isFunction(html)) {\n        return this.each(function (i) {\n          jQuery(this).wrapInner(html.call(this, i));\n        });\n      }\n\n      return this.each(function () {\n        var self = jQuery(this),\n        contents = self.contents();\n\n        if (contents.length) {\n          contents.wrapAll(html);\n\n        } else {\n          self.append(html);\n        }\n      });\n    },\n\n    wrap: function wrap(html) {\n      var htmlIsFunction = isFunction(html);\n\n      return this.each(function (i) {\n        jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);\n      });\n    },\n\n    unwrap: function unwrap(selector) {\n      this.parent(selector).not(\"body\").each(function () {\n        jQuery(this).replaceWith(this.childNodes);\n      });\n      return this;\n    } });\n\n\n\n  jQuery.expr.pseudos.hidden = function (elem) {\n    return !jQuery.expr.pseudos.visible(elem);\n  };\n  jQuery.expr.pseudos.visible = function (elem) {\n    return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);\n  };\n\n\n\n\n  jQuery.ajaxSettings.xhr = function () {\n    try {\n      return new window.XMLHttpRequest();\n    } catch (e) {}\n  };\n\n  var xhrSuccessStatus = {\n\n    // File protocol always yields status code 0, assume 200\n    0: 200,\n\n    // Support: IE <=9 only\n    // #1450: sometimes IE returns 1223 when it should be 204\n    1223: 204 },\n\n  xhrSupported = jQuery.ajaxSettings.xhr();\n\n  support.cors = !!xhrSupported && \"withCredentials\" in xhrSupported;\n  support.ajax = xhrSupported = !!xhrSupported;\n\n  jQuery.ajaxTransport(function (options) {\n    var _callback, errorCallback;\n\n    // Cross domain only allowed if supported through XMLHttpRequest\n    if (support.cors || xhrSupported && !options.crossDomain) {\n      return {\n        send: function send(headers, complete) {\n          var i,\n          xhr = options.xhr();\n\n          xhr.open(\n          options.type,\n          options.url,\n          options.async,\n          options.username,\n          options.password);\n\n\n          // Apply custom fields if provided\n          if (options.xhrFields) {\n            for (i in options.xhrFields) {\n              xhr[i] = options.xhrFields[i];\n            }\n          }\n\n          // Override mime type if needed\n          if (options.mimeType && xhr.overrideMimeType) {\n            xhr.overrideMimeType(options.mimeType);\n          }\n\n          // X-Requested-With header\n          // For cross-domain requests, seeing as conditions for a preflight are\n          // akin to a jigsaw puzzle, we simply never set it to be sure.\n          // (it can always be set on a per-request basis or even using ajaxSetup)\n          // For same-domain requests, won't change header if already provided.\n          if (!options.crossDomain && !headers[\"X-Requested-With\"]) {\n            headers[\"X-Requested-With\"] = \"XMLHttpRequest\";\n          }\n\n          // Set headers\n          for (i in headers) {\n            xhr.setRequestHeader(i, headers[i]);\n          }\n\n          // Callback\n          _callback = function callback(type) {\n            return function () {\n              if (_callback) {\n                _callback = errorCallback = xhr.onload =\n                xhr.onerror = xhr.onabort = xhr.ontimeout =\n                xhr.onreadystatechange = null;\n\n                if (type === \"abort\") {\n                  xhr.abort();\n                } else if (type === \"error\") {\n\n                  // Support: IE <=9 only\n                  // On a manual native abort, IE9 throws\n                  // errors on any property access that is not readyState\n                  if (typeof xhr.status !== \"number\") {\n                    complete(0, \"error\");\n                  } else {\n                    complete(\n\n                    // File: protocol always yields status 0; see #8605, #14207\n                    xhr.status,\n                    xhr.statusText);\n\n                  }\n                } else {\n                  complete(\n                  xhrSuccessStatus[xhr.status] || xhr.status,\n                  xhr.statusText,\n\n                  // Support: IE <=9 only\n                  // IE9 has no XHR2 but throws on binary (trac-11426)\n                  // For XHR2 non-text, let the caller handle it (gh-2498)\n                  (xhr.responseType || \"text\") !== \"text\" ||\n                  typeof xhr.responseText !== \"string\" ?\n                  { binary: xhr.response } :\n                  { text: xhr.responseText },\n                  xhr.getAllResponseHeaders());\n\n                }\n              }\n            };\n          };\n\n          // Listen to events\n          xhr.onload = _callback();\n          errorCallback = xhr.onerror = xhr.ontimeout = _callback(\"error\");\n\n          // Support: IE 9 only\n          // Use onreadystatechange to replace onabort\n          // to handle uncaught aborts\n          if (xhr.onabort !== undefined) {\n            xhr.onabort = errorCallback;\n          } else {\n            xhr.onreadystatechange = function () {\n\n              // Check readyState before timeout as it changes\n              if (xhr.readyState === 4) {\n\n                // Allow onerror to be called first,\n                // but that will not handle a native abort\n                // Also, save errorCallback to a variable\n                // as xhr.onerror cannot be accessed\n                window.setTimeout(function () {\n                  if (_callback) {\n                    errorCallback();\n                  }\n                });\n              }\n            };\n          }\n\n          // Create the abort callback\n          _callback = _callback(\"abort\");\n\n          try {\n\n            // Do send the request (this may raise an exception)\n            xhr.send(options.hasContent && options.data || null);\n          } catch (e) {\n\n            // #14683: Only rethrow if this hasn't been notified as an error yet\n            if (_callback) {\n              throw e;\n            }\n          }\n        },\n\n        abort: function abort() {\n          if (_callback) {\n            _callback();\n          }\n        } };\n\n    }\n  });\n\n\n\n\n  // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\n  jQuery.ajaxPrefilter(function (s) {\n    if (s.crossDomain) {\n      s.contents.script = false;\n    }\n  });\n\n  // Install script dataType\n  jQuery.ajaxSetup({\n    accepts: {\n      script: \"text/javascript, application/javascript, \" +\n      \"application/ecmascript, application/x-ecmascript\" },\n\n    contents: {\n      script: /\\b(?:java|ecma)script\\b/ },\n\n    converters: {\n      \"text script\": function textScript(text) {\n        jQuery.globalEval(text);\n        return text;\n      } } });\n\n\n\n  // Handle cache's special case and crossDomain\n  jQuery.ajaxPrefilter(\"script\", function (s) {\n    if (s.cache === undefined) {\n      s.cache = false;\n    }\n    if (s.crossDomain) {\n      s.type = \"GET\";\n    }\n  });\n\n  // Bind script tag hack transport\n  jQuery.ajaxTransport(\"script\", function (s) {\n\n    // This transport only deals with cross domain or forced-by-attrs requests\n    if (s.crossDomain || s.scriptAttrs) {\n      var script, _callback2;\n      return {\n        send: function send(_, complete) {\n          script = jQuery(\"<script>\").\n          attr(s.scriptAttrs || {}).\n          prop({ charset: s.scriptCharset, src: s.url }).\n          on(\"load error\", _callback2 = function callback(evt) {\n            script.remove();\n            _callback2 = null;\n            if (evt) {\n              complete(evt.type === \"error\" ? 404 : 200, evt.type);\n            }\n          });\n\n          // Use native DOM manipulation to avoid our domManip AJAX trickery\n          document.head.appendChild(script[0]);\n        },\n        abort: function abort() {\n          if (_callback2) {\n            _callback2();\n          }\n        } };\n\n    }\n  });\n\n\n\n\n  var oldCallbacks = [],\n  rjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n  // Default jsonp settings\n  jQuery.ajaxSetup({\n    jsonp: \"callback\",\n    jsonpCallback: function jsonpCallback() {\n      var callback = oldCallbacks.pop() || jQuery.expando + \"_\" + nonce.guid++;\n      this[callback] = true;\n      return callback;\n    } });\n\n\n  // Detect, normalize options and install callbacks for jsonp requests\n  jQuery.ajaxPrefilter(\"json jsonp\", function (s, originalSettings, jqXHR) {\n\n    var callbackName,overwritten,responseContainer,\n    jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ?\n    \"url\" :\n    typeof s.data === \"string\" &&\n    (s.contentType || \"\").\n    indexOf(\"application/x-www-form-urlencoded\") === 0 &&\n    rjsonp.test(s.data) && \"data\");\n\n\n    // Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n    if (jsonProp || s.dataTypes[0] === \"jsonp\") {\n\n      // Get callback name, remembering preexisting value associated with it\n      callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ?\n      s.jsonpCallback() :\n      s.jsonpCallback;\n\n      // Insert callback into url or form data\n      if (jsonProp) {\n        s[jsonProp] = s[jsonProp].replace(rjsonp, \"$1\" + callbackName);\n      } else if (s.jsonp !== false) {\n        s.url += (rquery.test(s.url) ? \"&\" : \"?\") + s.jsonp + \"=\" + callbackName;\n      }\n\n      // Use data converter to retrieve json after script execution\n      s.converters[\"script json\"] = function () {\n        if (!responseContainer) {\n          jQuery.error(callbackName + \" was not called\");\n        }\n        return responseContainer[0];\n      };\n\n      // Force json dataType\n      s.dataTypes[0] = \"json\";\n\n      // Install callback\n      overwritten = window[callbackName];\n      window[callbackName] = function () {\n        responseContainer = arguments;\n      };\n\n      // Clean-up function (fires after converters)\n      jqXHR.always(function () {\n\n        // If previous value didn't exist - remove it\n        if (overwritten === undefined) {\n          jQuery(window).removeProp(callbackName);\n\n          // Otherwise restore preexisting value\n        } else {\n          window[callbackName] = overwritten;\n        }\n\n        // Save back as free\n        if (s[callbackName]) {\n\n          // Make sure that re-using the options doesn't screw things around\n          s.jsonpCallback = originalSettings.jsonpCallback;\n\n          // Save the callback name for future use\n          oldCallbacks.push(callbackName);\n        }\n\n        // Call if it was a function and we have a response\n        if (responseContainer && isFunction(overwritten)) {\n          overwritten(responseContainer[0]);\n        }\n\n        responseContainer = overwritten = undefined;\n      });\n\n      // Delegate to script\n      return \"script\";\n    }\n  });\n\n\n\n\n  // Support: Safari 8 only\n  // In Safari 8 documents created via document.implementation.createHTMLDocument\n  // collapse sibling forms: the second one becomes a child of the first one.\n  // Because of that, this security measure has to be disabled in Safari 8.\n  // https://bugs.webkit.org/show_bug.cgi?id=137337\n  support.createHTMLDocument = function () {\n    var body = document.implementation.createHTMLDocument(\"\").body;\n    body.innerHTML = \"<form></form><form></form>\";\n    return body.childNodes.length === 2;\n  }();\n\n\n  // Argument \"data\" should be string of html\n  // context (optional): If specified, the fragment will be created in this context,\n  // defaults to document\n  // keepScripts (optional): If true, will include scripts passed in the html string\n  jQuery.parseHTML = function (data, context, keepScripts) {\n    if (typeof data !== \"string\") {\n      return [];\n    }\n    if (typeof context === \"boolean\") {\n      keepScripts = context;\n      context = false;\n    }\n\n    var base, parsed, scripts;\n\n    if (!context) {\n\n      // Stop scripts or inline event handlers from being executed immediately\n      // by using document.implementation\n      if (support.createHTMLDocument) {\n        context = document.implementation.createHTMLDocument(\"\");\n\n        // Set the base href for the created document\n        // so any parsed elements with URLs\n        // are based on the document's URL (gh-2965)\n        base = context.createElement(\"base\");\n        base.href = document.location.href;\n        context.head.appendChild(base);\n      } else {\n        context = document;\n      }\n    }\n\n    parsed = rsingleTag.exec(data);\n    scripts = !keepScripts && [];\n\n    // Single tag\n    if (parsed) {\n      return [context.createElement(parsed[1])];\n    }\n\n    parsed = buildFragment([data], context, scripts);\n\n    if (scripts && scripts.length) {\n      jQuery(scripts).remove();\n    }\n\n    return jQuery.merge([], parsed.childNodes);\n  };\n\n\n  /**\n   * Load a url into a page\n   */\n  jQuery.fn.load = function (url, params, callback) {\n    var selector,type,response,\n    self = this,\n    off = url.indexOf(\" \");\n\n    if (off > -1) {\n      selector = stripAndCollapse(url.slice(off));\n      url = url.slice(0, off);\n    }\n\n    // If it's a function\n    if (isFunction(params)) {\n\n      // We assume that it's the callback\n      callback = params;\n      params = undefined;\n\n      // Otherwise, build a param string\n    } else if (params && _typeof(params) === \"object\") {\n      type = \"POST\";\n    }\n\n    // If we have elements to modify, make the request\n    if (self.length > 0) {\n      jQuery.ajax({\n        url: url,\n\n        // If \"type\" variable is undefined, then \"GET\" method will be used.\n        // Make value of this field explicit since\n        // user can override it through ajaxSetup method\n        type: type || \"GET\",\n        dataType: \"html\",\n        data: params }).\n      done(function (responseText) {\n\n        // Save response for use in complete callback\n        response = arguments;\n\n        self.html(selector ?\n\n        // If a selector was specified, locate the right elements in a dummy div\n        // Exclude scripts to avoid IE 'Permission Denied' errors\n        jQuery(\"<div>\").append(jQuery.parseHTML(responseText)).find(selector) :\n\n        // Otherwise use the full result\n        responseText);\n\n        // If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n        // but they are ignored because response was set above.\n        // If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n      }).always(callback && function (jqXHR, status) {\n        self.each(function () {\n          callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);\n        });\n      });\n    }\n\n    return this;\n  };\n\n\n\n\n  jQuery.expr.pseudos.animated = function (elem) {\n    return jQuery.grep(jQuery.timers, function (fn) {\n      return elem === fn.elem;\n    }).length;\n  };\n\n\n\n\n  jQuery.offset = {\n    setOffset: function setOffset(elem, options, i) {\n      var curPosition,curLeft,curCSSTop,curTop,curOffset,curCSSLeft,calculatePosition,\n      position = jQuery.css(elem, \"position\"),\n      curElem = jQuery(elem),\n      props = {};\n\n      // Set position first, in-case top/left are set even on static elem\n      if (position === \"static\") {\n        elem.style.position = \"relative\";\n      }\n\n      curOffset = curElem.offset();\n      curCSSTop = jQuery.css(elem, \"top\");\n      curCSSLeft = jQuery.css(elem, \"left\");\n      calculatePosition = (position === \"absolute\" || position === \"fixed\") &&\n      (curCSSTop + curCSSLeft).indexOf(\"auto\") > -1;\n\n      // Need to be able to calculate position if either\n      // top or left is auto and position is either absolute or fixed\n      if (calculatePosition) {\n        curPosition = curElem.position();\n        curTop = curPosition.top;\n        curLeft = curPosition.left;\n\n      } else {\n        curTop = parseFloat(curCSSTop) || 0;\n        curLeft = parseFloat(curCSSLeft) || 0;\n      }\n\n      if (isFunction(options)) {\n\n        // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n        options = options.call(elem, i, jQuery.extend({}, curOffset));\n      }\n\n      if (options.top != null) {\n        props.top = options.top - curOffset.top + curTop;\n      }\n      if (options.left != null) {\n        props.left = options.left - curOffset.left + curLeft;\n      }\n\n      if (\"using\" in options) {\n        options.using.call(elem, props);\n\n      } else {\n        if (typeof props.top === \"number\") {\n          props.top += \"px\";\n        }\n        if (typeof props.left === \"number\") {\n          props.left += \"px\";\n        }\n        curElem.css(props);\n      }\n    } };\n\n\n  jQuery.fn.extend({\n\n    // offset() relates an element's border box to the document origin\n    offset: function offset(options) {\n\n      // Preserve chaining for setter\n      if (arguments.length) {\n        return options === undefined ?\n        this :\n        this.each(function (i) {\n          jQuery.offset.setOffset(this, options, i);\n        });\n      }\n\n      var rect,win,\n      elem = this[0];\n\n      if (!elem) {\n        return;\n      }\n\n      // Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n      // Support: IE <=11 only\n      // Running getBoundingClientRect on a\n      // disconnected node in IE throws an error\n      if (!elem.getClientRects().length) {\n        return { top: 0, left: 0 };\n      }\n\n      // Get document-relative position by adding viewport scroll to viewport-relative gBCR\n      rect = elem.getBoundingClientRect();\n      win = elem.ownerDocument.defaultView;\n      return {\n        top: rect.top + win.pageYOffset,\n        left: rect.left + win.pageXOffset };\n\n    },\n\n    // position() relates an element's margin box to its offset parent's padding box\n    // This corresponds to the behavior of CSS absolute positioning\n    position: function position() {\n      if (!this[0]) {\n        return;\n      }\n\n      var offsetParent,offset,doc,\n      elem = this[0],\n      parentOffset = { top: 0, left: 0 };\n\n      // position:fixed elements are offset from the viewport, which itself always has zero offset\n      if (jQuery.css(elem, \"position\") === \"fixed\") {\n\n        // Assume position:fixed implies availability of getBoundingClientRect\n        offset = elem.getBoundingClientRect();\n\n      } else {\n        offset = this.offset();\n\n        // Account for the *real* offset parent, which can be the document or its root element\n        // when a statically positioned element is identified\n        doc = elem.ownerDocument;\n        offsetParent = elem.offsetParent || doc.documentElement;\n        while (offsetParent && (\n        offsetParent === doc.body || offsetParent === doc.documentElement) &&\n        jQuery.css(offsetParent, \"position\") === \"static\") {\n\n          offsetParent = offsetParent.parentNode;\n        }\n        if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {\n\n          // Incorporate borders into its offset, since they are outside its content origin\n          parentOffset = jQuery(offsetParent).offset();\n          parentOffset.top += jQuery.css(offsetParent, \"borderTopWidth\", true);\n          parentOffset.left += jQuery.css(offsetParent, \"borderLeftWidth\", true);\n        }\n      }\n\n      // Subtract parent offsets and element margins\n      return {\n        top: offset.top - parentOffset.top - jQuery.css(elem, \"marginTop\", true),\n        left: offset.left - parentOffset.left - jQuery.css(elem, \"marginLeft\", true) };\n\n    },\n\n    // This method will return documentElement in the following cases:\n    // 1) For the element inside the iframe without offsetParent, this method will return\n    //    documentElement of the parent window\n    // 2) For the hidden or detached element\n    // 3) For body or html element, i.e. in case of the html node - it will return itself\n    //\n    // but those exceptions were never presented as a real life use-cases\n    // and might be considered as more preferable results.\n    //\n    // This logic, however, is not guaranteed and can change at any point in the future\n    offsetParent: function offsetParent() {\n      return this.map(function () {\n        var offsetParent = this.offsetParent;\n\n        while (offsetParent && jQuery.css(offsetParent, \"position\") === \"static\") {\n          offsetParent = offsetParent.offsetParent;\n        }\n\n        return offsetParent || documentElement;\n      });\n    } });\n\n\n  // Create scrollLeft and scrollTop methods\n  jQuery.each({ scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function (method, prop) {\n    var top = \"pageYOffset\" === prop;\n\n    jQuery.fn[method] = function (val) {\n      return access(this, function (elem, method, val) {\n\n        // Coalesce documents and windows\n        var win;\n        if (isWindow(elem)) {\n          win = elem;\n        } else if (elem.nodeType === 9) {\n          win = elem.defaultView;\n        }\n\n        if (val === undefined) {\n          return win ? win[prop] : elem[method];\n        }\n\n        if (win) {\n          win.scrollTo(\n          !top ? val : win.pageXOffset,\n          top ? val : win.pageYOffset);\n\n\n        } else {\n          elem[method] = val;\n        }\n      }, method, val, arguments.length);\n    };\n  });\n\n  // Support: Safari <=7 - 9.1, Chrome <=37 - 49\n  // Add the top/left cssHooks using jQuery.fn.position\n  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n  // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n  // getComputedStyle returns percent when specified for top/left/bottom/right;\n  // rather than make the css module depend on the offset module, just check for it here\n  jQuery.each([\"top\", \"left\"], function (_i, prop) {\n    jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition,\n    function (elem, computed) {\n      if (computed) {\n        computed = curCSS(elem, prop);\n\n        // If curCSS returns percentage, fallback to offset\n        return rnumnonpx.test(computed) ?\n        jQuery(elem).position()[prop] + \"px\" :\n        computed;\n      }\n    });\n\n  });\n\n\n  // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\n  jQuery.each({ Height: \"height\", Width: \"width\" }, function (name, type) {\n    jQuery.each({ padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n    function (defaultExtra, funcName) {\n\n      // Margin is only for outerHeight, outerWidth\n      jQuery.fn[funcName] = function (margin, value) {\n        var chainable = arguments.length && (defaultExtra || typeof margin !== \"boolean\"),\n        extra = defaultExtra || (margin === true || value === true ? \"margin\" : \"border\");\n\n        return access(this, function (elem, type, value) {\n          var doc;\n\n          if (isWindow(elem)) {\n\n            // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n            return funcName.indexOf(\"outer\") === 0 ?\n            elem[\"inner\" + name] :\n            elem.document.documentElement[\"client\" + name];\n          }\n\n          // Get document width or height\n          if (elem.nodeType === 9) {\n            doc = elem.documentElement;\n\n            // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n            // whichever is greatest\n            return Math.max(\n            elem.body[\"scroll\" + name], doc[\"scroll\" + name],\n            elem.body[\"offset\" + name], doc[\"offset\" + name],\n            doc[\"client\" + name]);\n\n          }\n\n          return value === undefined ?\n\n          // Get width or height on the element, requesting but not forcing parseFloat\n          jQuery.css(elem, type, extra) :\n\n          // Set width or height on the element\n          jQuery.style(elem, type, value, extra);\n        }, type, chainable ? margin : undefined, chainable);\n      };\n    });\n  });\n\n\n  jQuery.each([\n  \"ajaxStart\",\n  \"ajaxStop\",\n  \"ajaxComplete\",\n  \"ajaxError\",\n  \"ajaxSuccess\",\n  \"ajaxSend\"],\n  function (_i, type) {\n    jQuery.fn[type] = function (fn) {\n      return this.on(type, fn);\n    };\n  });\n\n\n\n\n  jQuery.fn.extend({\n\n    bind: function bind(types, data, fn) {\n      return this.on(types, null, data, fn);\n    },\n    unbind: function unbind(types, fn) {\n      return this.off(types, null, fn);\n    },\n\n    delegate: function delegate(selector, types, data, fn) {\n      return this.on(types, selector, data, fn);\n    },\n    undelegate: function undelegate(selector, types, fn) {\n\n      // ( namespace ) or ( selector, types [, fn] )\n      return arguments.length === 1 ?\n      this.off(selector, \"**\") :\n      this.off(types, selector || \"**\", fn);\n    },\n\n    hover: function hover(fnOver, fnOut) {\n      return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);\n    } });\n\n\n  jQuery.each((\"blur focus focusin focusout resize scroll click dblclick \" +\n  \"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n  \"change select submit keydown keypress keyup contextmenu\").split(\" \"),\n  function (_i, name) {\n\n    // Handle event binding\n    jQuery.fn[name] = function (data, fn) {\n      return arguments.length > 0 ?\n      this.on(name, null, data, fn) :\n      this.trigger(name);\n    };\n  });\n\n\n\n\n  // Support: Android <=4.0 only\n  // Make sure we trim BOM and NBSP\n  var rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\n\n  // Bind a function to a context, optionally partially applying any\n  // arguments.\n  // jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n  // However, it is not slated for removal any time soon\n  jQuery.proxy = function (fn, context) {\n    var tmp, args, proxy;\n\n    if (typeof context === \"string\") {\n      tmp = fn[context];\n      context = fn;\n      fn = tmp;\n    }\n\n    // Quick check to determine if target is callable, in the spec\n    // this throws a TypeError, but we will just return undefined.\n    if (!isFunction(fn)) {\n      return undefined;\n    }\n\n    // Simulated bind\n    args = _slice.call(arguments, 2);\n    proxy = function proxy() {\n      return fn.apply(context || this, args.concat(_slice.call(arguments)));\n    };\n\n    // Set the guid of unique handler to the same of original handler, so it can be removed\n    proxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n    return proxy;\n  };\n\n  jQuery.holdReady = function (hold) {\n    if (hold) {\n      jQuery.readyWait++;\n    } else {\n      jQuery.ready(true);\n    }\n  };\n  jQuery.isArray = Array.isArray;\n  jQuery.parseJSON = JSON.parse;\n  jQuery.nodeName = nodeName;\n  jQuery.isFunction = isFunction;\n  jQuery.isWindow = isWindow;\n  jQuery.camelCase = camelCase;\n  jQuery.type = toType;\n\n  jQuery.now = Date.now;\n\n  jQuery.isNumeric = function (obj) {\n\n    // As of jQuery 3.0, isNumeric is limited to\n    // strings and numbers (primitives or objects)\n    // that can be coerced to finite numbers (gh-2662)\n    var type = jQuery.type(obj);\n    return (type === \"number\" || type === \"string\") &&\n\n    // parseFloat NaNs numeric-cast false positives (\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    !isNaN(obj - parseFloat(obj));\n  };\n\n  jQuery.trim = function (text) {\n    return text == null ?\n    \"\" :\n    (text + \"\").replace(rtrim, \"\");\n  };\n\n\n\n  // Register as a named AMD module, since jQuery can be concatenated with other\n  // files that may use define, but not via a proper concatenation script that\n  // understands anonymous AMD modules. A named AMD is safest and most robust\n  // way to register. Lowercase jquery is used because AMD module names are\n  // derived from file names, and jQuery is normally delivered in a lowercase\n  // file name. Do this after creating the global so that if an AMD module wants\n  // to call noConflict to hide this version of jQuery, it will work.\n\n  // Note that for maximum portability, libraries that are not jQuery should\n  // declare themselves as anonymous modules, and avoid setting a global if an\n  // AMD loader is present. jQuery is a special case. For more information, see\n  // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\n  if (typeof define === \"function\" && define.amd) {\n    define(\"jquery\", [], function () {\n      return jQuery;\n    });\n  }\n\n\n\n\n  var\n\n  // Map over jQuery in case of overwrite\n  _jQuery = window.jQuery,\n\n  // Map over the $ in case of overwrite\n  _$ = window.$;\n\n  jQuery.noConflict = function (deep) {\n    if (window.$ === jQuery) {\n      window.$ = _$;\n    }\n\n    if (deep && window.jQuery === jQuery) {\n      window.jQuery = _jQuery;\n    }\n\n    return jQuery;\n  };\n\n  // Expose jQuery and $ identifiers, even in AMD\n  // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n  // and CommonJS for browser emulators (#13566)\n  if (typeof noGlobal === \"undefined\") {\n    window.jQuery = window.$ = jQuery;\n  }\n\n\n\n\n  return jQuery;\n});","/*!\n * jQuery JavaScript Library v3.5.0\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2020-04-10T15:07Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket #14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n      // Support: Chrome <=57, Firefox <=52\n      // In some browsers, typeof returns \"function\" for HTML <object> elements\n      // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n      // We don't want to classify *any* DOM node as a function.\n      return typeof obj === \"function\" && typeof obj.nodeType !== \"number\";\n  };\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n/* global Symbol */\n// Defining this global in .eslintrc.json would create a danger of using the global\n// unguarded in another place, it seems safer to define global only for this module\n\n\n\nvar\n\tversion = \"3.5.0\",\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\nfunction( _i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.3.5\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://js.foundation/\n *\n * Date: 2020-03-14\n */\n( function( window ) {\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// Instance methods\n\thasOwn = ( {} ).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpushNative = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\n\t// Use a stripped-down indexOf as it's faster than native\n\t// https://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[ i ] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" +\n\t\t\"ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5]\n\t\t// or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\n\t\twhitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\n\t\t\"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trhtml = /HTML$/i,\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\treturn nonHex ?\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\tnonHex :\n\n\t\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t\t// Support: IE <=11+\n\t\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t\t// surrogate pair\n\t\t\thigh < 0 ?\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// CSS string/identifier serialization\n\t// https://drafts.csswg.org/cssom/#common-serializing-idioms\n\trcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n\tfcssescape = function( ch, asCodePoint ) {\n\t\tif ( asCodePoint ) {\n\n\t\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\t\tif ( ch === \"\\0\" ) {\n\t\t\t\treturn \"\\uFFFD\";\n\t\t\t}\n\n\t\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\t\treturn ch.slice( 0, -1 ) + \"\\\\\" +\n\t\t\t\tch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t\t}\n\n\t\t// Other potentially-special ASCII characters get backslash-escaped\n\t\treturn \"\\\\\" + ch;\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( ( target[ j++ ] = els[ i++ ] ) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&\n\n\t\t\t\t// Support: IE 8 only\n\t\t\t\t// Exclude object elements\n\t\t\t\t( nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\" ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\tif ( newContext !== context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = nid.replace( rcssescape, fcssescape );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split( \"|\" ),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[ i ] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\ta.sourceIndex - b.sourceIndex;\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( ( cur = cur.nextSibling ) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn ( name === \"input\" || name === \"button\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\t/* jshint -W018 */\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\tvar namespace = elem.namespaceURI,\n\t\tdocElem = ( elem.ownerDocument || elem ).documentElement;\n\n\t// Support: IE <=8\n\t// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n\t// https://bugs.jquery.com/ticket/4833\n\treturn !rhtml.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( preferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 11, Edge\n\t\tif ( subWindow.addEventListener ) {\n\t\t\tsubWindow.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( subWindow.attachEvent ) {\n\t\t\tsubWindow.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n\t// Safari 4 - 5 only, Opera <=11.6 - 12.x only\n\t// IE/Edge & older browsers don't support the :scope pseudo-class.\n\t// Support: Safari 6.0 only\n\t// Safari 6.0 supports :scope but it's an alias of :root there.\n\tsupport.scope = assert( function( el ) {\n\t\tdocElem.appendChild( el ).appendChild( document.createElement( \"div\" ) );\n\t\treturn typeof el.querySelectorAll !== \"undefined\" &&\n\t\t\t!el.querySelectorAll( \":scope fieldset div\" ).length;\n\t} );\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert( function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute( \"className\" );\n\t} );\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert( function( el ) {\n\t\tel.appendChild( document.createComment( \"\" ) );\n\t\treturn !el.getElementsByTagName( \"*\" ).length;\n\t} );\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter[ \"ID\" ] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter[ \"ID\" ] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[ \"TAG\" ] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[ \"CLASS\" ] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See https://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {\n\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert( function( el ) {\n\n\t\t\tvar input;\n\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// https://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( el.querySelectorAll( \"[msallowcapture^='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"~=\" );\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t\t// Adding a temporary attribute to the document before the selection works\n\t\t\t// around the issue.\n\t\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\t\tinput = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"name\", \"\" );\n\t\t\tel.appendChild( input );\n\t\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\t\trbuggyQSA.push( \":checked\" );\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t\t}\n\n\t\t\t// Support: Firefox <=3.6 - 5 only\n\t\t\t// Old Firefox doesn't throw on a badly-escaped identifier.\n\t\t\tel.querySelectorAll( \"\\\\\\f\" );\n\t\t\trbuggyQSA.push( \"[\\\\r\\\\n\\\\f]\" );\n\t\t} );\n\n\t\tassert( function( el ) {\n\t\t\tel.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n\t\t\t\t\"<select disabled='disabled'><option/></select>\";\n\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( el.querySelectorAll( \"[name=d]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( el.querySelectorAll( \":enabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t\tdocElem.appendChild( el ).disabled = true;\n\t\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: Opera 10 - 11 only\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tel.querySelectorAll( \"*,:x\" );\n\t\t\trbuggyQSA.push( \",.*:\" );\n\t\t} );\n\t}\n\n\tif ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector ) ) ) ) {\n\n\t\tassert( function( el ) {\n\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( el, \"*\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( el, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t} );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( \"|\" ) );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t) );\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( ( b = b.parentNode ) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a == document || a.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b == document || b.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\treturn a == document ? -1 :\n\t\t\t\tb == document ? 1 :\n\t\t\t\t/* eslint-enable eqeqeq */\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[ i ] === bp[ i ] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[ i ], bp[ i ] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\tap[ i ] == preferredDoc ? -1 :\n\t\t\tbp[ i ] == preferredDoc ? 1 :\n\t\t\t/* eslint-enable eqeqeq */\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t// fragment in IE 9\n\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.escape = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] ||\n\t\t\t\tmatch[ 5 ] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tSizzle.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" ) );\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tSizzle.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr[ \"CHILD\" ].test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace +\n\t\t\t\t\t\")\" + className + \"(\" + whitespace + \"|$)\" ) ) && classCache(\n\t\t\t\t\t\tclassName, function( elem ) {\n\t\t\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\t/* eslint-disable max-len */\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t\t/* eslint-enable max-len */\n\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\t\"has\": markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\t\"contains\": markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement &&\n\t\t\t\t( !document.hasFocus || document.hasFocus() ) &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": createDisabledPseudo( false ),\n\t\t\"disabled\": createDisabledPseudo( true ),\n\n\t\t\"checked\": function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn ( nodeName === \"input\" && !!elem.checked ) ||\n\t\t\t\t( nodeName === \"option\" && !!elem.selected );\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[ \"empty\" ]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\t\"last\": createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\t\"eq\": createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\t\"even\": createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"odd\": createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"lt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ?\n\t\t\t\targument + length :\n\t\t\t\targument > length ?\n\t\t\t\t\tlength :\n\t\t\t\t\targument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"gt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos[ \"nth\" ] = Expr.pseudos[ \"eq\" ];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rcombinators.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrim, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] ||\n\t\t\t\t\t\t\t( outerCache[ elem.uniqueID ] = {} );\n\n\t\t\t\t\t\tif ( skip && skip === elem.nodeName.toLowerCase() ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = uniqueCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts(\n\t\t\t\tselector || \"*\",\n\t\t\t\tcontext.nodeType ? [ context ] : context,\n\t\t\t\t[]\n\t\t\t),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\ttokens\n\t\t\t\t\t\t.slice( 0, i - 1 )\n\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[ \"TAG\" ]( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache(\n\t\t\tselector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers )\n\t\t);\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find[ \"ID\" ]( token.matches[ 0 ]\n\t\t\t\t.replace( runescape, funescape ), context ) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[ \"needsContext\" ].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert( function( el ) {\n\tel.innerHTML = \"<a href='#'></a>\";\n\treturn el.firstChild.getAttribute( \"href\" ) === \"#\";\n} ) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert( function( el ) {\n\tel.innerHTML = \"<input/>\";\n\tel.firstChild.setAttribute( \"value\", \"\" );\n\treturn el.firstChild.getAttribute( \"value\" ) === \"\";\n} ) ) {\n\taddHandle( \"value\", function( elem, _name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert( function( el ) {\n\treturn el.getAttribute( \"disabled\" ) == null;\n} ) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\t\tnull;\n\t\t}\n\t} );\n}\n\nreturn Sizzle;\n\n} )( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\njQuery.escapeSelector = Sizzle.escape;\n\n\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\n\n\nfunction nodeName( elem, name ) {\n\n  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n};\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n\t// Strict HTML recognition (#11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to Sizzle\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.stackTrace );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the stack, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.stackTrace = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the master Deferred\n\t\t\tmaster = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tmaster.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( master.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn master.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), master.reject );\n\t\t}\n\n\t\treturn master.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\njQuery.Deferred.exceptionHook = function( error, stack ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message, error.stack, stack );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See #6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\n// Support: IE <=9 - 10 only\n// Older IE sometimes signals \"interactive\" too soon\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\tvalue :\n\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase; used by the css and data modules\n// Support: IE <=9 - 11, Edge 12 - 15\n// Microsoft forgot to hump their vendor prefix (#9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = Object.create( null );\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see #8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (#14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (#15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (#12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\nvar\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE <=9 - 11+\n// focus() and blur() are asynchronous, except when they are no-op.\n// So expect focus to be synchronous when the element is already active,\n// and blur to be synchronous when the element is not already active.\n// (focus and blur are always synchronous in other supported browsers,\n// this just defines when we can count on it).\nfunction expectSync( elem, type ) {\n\treturn ( elem === safeActiveElement() ) === ( type === \"focus\" );\n}\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", returnTrue );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, expectSync ) {\n\n\t// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !expectSync ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar notAsync, result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\t// Saved data should be false in such cases, but might be a leftover capture object\n\t\t\t\t// from an async native handler (gh-4350)\n\t\t\t\tif ( !saved.length ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t\t// focus() and blur() are asynchronous\n\t\t\t\t\tnotAsync = expectSync( this, type );\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tif ( saved !== result || notAsync ) {\n\t\t\t\t\t\tdataPriv.set( this, type, false );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresult = {};\n\t\t\t\t\t}\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\treturn result.value;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering the\n\t\t\t\t// native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved.length ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, {\n\t\t\t\t\tvalue: jQuery.event.trigger(\n\n\t\t\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t\t\t// Extend with the prototype to reset the above stopImmediatePropagation()\n\t\t\t\t\t\tjQuery.extend( saved[ 0 ], jQuery.Event.prototype ),\n\t\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\t\tthis\n\t\t\t\t\t)\n\t\t\t\t} );\n\n\t\t\t\t// Abort handling of the native event\n\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (#504, #13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\n\twhich: function( event ) {\n\t\tvar button = event.button;\n\n\t\t// Add which for key events\n\t\tif ( event.which == null && rkeyEvent.test( event.type ) ) {\n\t\t\treturn event.charCode != null ? event.charCode : event.keyCode;\n\t\t}\n\n\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\tif ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {\n\t\t\tif ( button & 1 ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\tif ( button & 2 ) {\n\t\t\t\treturn 3;\n\t\t\t}\n\n\t\t\tif ( button & 4 ) {\n\t\t\t\treturn 2;\n\t\t\t}\n\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn event.which;\n\t}\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, expectSync );\n\n\t\t\t// Return false to allow normal processing in the caller\n\t\t\treturn false;\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n} );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\trcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle events\" );\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (#8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && isAttached( node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html;\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = isAttached( elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (#8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px\";\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = parseInt( trStyle.height ) > 3;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, #12537)\n\t//   .css('--customProperty) (#3144)\n\tif ( computed ) {\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\trcustomProp = /^--/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\tif ( box === \"margin\" ) {\n\t\t\tdelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"gridArea\": true,\n\t\t\"gridColumn\": true,\n\t\t\"gridColumnEnd\": true,\n\t\t\"gridColumnStart\": true,\n\t\t\"gridRow\": true,\n\t\t\"gridRowEnd\": true,\n\t\t\"gridRowStart\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug #9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (#7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\t\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\n// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\n// eslint rule \"no-unused-expressions\" is disabled for this code\n// since it considers such accessions noop\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar type = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = classesToArray( value );\n\n\t\t\t\twhile ( ( className = classNames[ i++ ] ) ) {\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (#14686, #14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (#2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\n\n\nsupport.focusin = \"onfocusin\" in window;\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = (\n\t\t\t\t\tdataPriv.get( cur, \"events\" ) || Object.create( null )\n\t\t\t\t)[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\n// Support: Firefox <=44\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\n\t\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\n};\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} )\n\t\t.filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} )\n\t\t.map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// #7653, #8125, #8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\toriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes #9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (#10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket #12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// #9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\n\t\t\t\t\tuncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script\n\t\t\tif ( !isSuccess && jQuery.inArray( \"script\", s.dataTypes ) > -1 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (#11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// #1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see #8605, #14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// #14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Support: Safari 8 only\n// In Safari 8 documents created via document.implementation.createHTMLDocument\n// collapse sibling forms: the second one becomes a child of the first one.\n// Because of that, this security measure has to be disabled in Safari 8.\n// https://bugs.webkit.org/show_bug.cgi?id=137337\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tif ( typeof props.top === \"number\" ) {\n\t\t\t\tprops.top += \"px\";\n\t\t\t}\n\t\t\tif ( typeof props.left === \"number\" ) {\n\t\t\t\tprops.left += \"px\";\n\t\t\t}\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( _i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\njQuery.each( ( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( _i, name ) {\n\n\t\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t} );\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\n\n// Bind a function to a context, optionally partially applying any\n// arguments.\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n// However, it is not slated for removal any time soon\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"\" );\n};\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n"]}